blob: d760934109b5d628891ea3e91fa1a9e3f68ec36b [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"
Darrick J. Wong30cbc592016-03-09 08:15:14 +110048#include "xfs_ondisk.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070049
50#include <linux/namei.h>
51#include <linux/init.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090052#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070053#include <linux/mount.h>
Christoph Hellwig0829c362005-09-02 16:58:49 +100054#include <linux/mempool.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070055#include <linux/writeback.h>
Christoph Hellwig4df08c52005-09-05 08:34:18 +100056#include <linux/kthread.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080057#include <linux/freezer.h>
Christoph Hellwig62a877e2008-07-18 17:12:36 +100058#include <linux/parser.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
Alexey Dobriyanb87221d2009-09-21 17:01:09 -070060static const struct super_operations xfs_super_operations;
David Chinner7989cb82007-02-10 18:34:56 +110061static kmem_zone_t *xfs_ioend_zone;
Christoph Hellwig0829c362005-09-02 16:58:49 +100062mempool_t *xfs_ioend_pool;
Brian Foster65b65732014-09-09 11:52:42 +100063
Dave Chinnere3aed1a2014-09-29 10:46:08 +100064static struct kset *xfs_kset; /* top-level xfs sysfs dir */
Brian Foster65b65732014-09-09 11:52:42 +100065#ifdef DEBUG
66static struct xfs_kobj xfs_dbg_kobj; /* global debug sysfs attrs */
67#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070068
Christoph Hellwig62a877e2008-07-18 17:12:36 +100069/*
70 * Table driven mount option parser.
Christoph Hellwig62a877e2008-07-18 17:12:36 +100071 */
72enum {
Eric Sandeen2e74af02016-03-02 09:55:38 +110073 Opt_logbufs, Opt_logbsize, Opt_logdev, Opt_rtdev, Opt_biosize,
74 Opt_wsync, Opt_noalign, Opt_swalloc, Opt_sunit, Opt_swidth, Opt_nouuid,
75 Opt_mtpt, Opt_grpid, Opt_nogrpid, Opt_bsdgroups, Opt_sysvgroups,
76 Opt_allocsize, Opt_norecovery, Opt_barrier, Opt_nobarrier,
77 Opt_inode64, Opt_inode32, Opt_ikeep, Opt_noikeep,
78 Opt_largeio, Opt_nolargeio, Opt_attr2, Opt_noattr2, Opt_filestreams,
79 Opt_quota, Opt_noquota, Opt_usrquota, Opt_grpquota, Opt_prjquota,
80 Opt_uquota, Opt_gquota, Opt_pquota,
81 Opt_uqnoenforce, Opt_gqnoenforce, Opt_pqnoenforce, Opt_qnoenforce,
82 Opt_discard, Opt_nodiscard, Opt_dax, Opt_err,
Christoph Hellwig62a877e2008-07-18 17:12:36 +100083};
84
Steven Whitehousea447c092008-10-13 10:46:57 +010085static const match_table_t tokens = {
Eric Sandeen2e74af02016-03-02 09:55:38 +110086 {Opt_logbufs, "logbufs=%u"}, /* number of XFS log buffers */
87 {Opt_logbsize, "logbsize=%s"}, /* size of XFS log buffers */
88 {Opt_logdev, "logdev=%s"}, /* log device */
89 {Opt_rtdev, "rtdev=%s"}, /* realtime I/O device */
90 {Opt_biosize, "biosize=%u"}, /* log2 of preferred buffered io size */
91 {Opt_wsync, "wsync"}, /* safe-mode nfs compatible mount */
92 {Opt_noalign, "noalign"}, /* turn off stripe alignment */
93 {Opt_swalloc, "swalloc"}, /* turn on stripe width allocation */
94 {Opt_sunit, "sunit=%u"}, /* data volume stripe unit */
95 {Opt_swidth, "swidth=%u"}, /* data volume stripe width */
96 {Opt_nouuid, "nouuid"}, /* ignore filesystem UUID */
97 {Opt_mtpt, "mtpt"}, /* filesystem mount point */
98 {Opt_grpid, "grpid"}, /* group-ID from parent directory */
99 {Opt_nogrpid, "nogrpid"}, /* group-ID from current process */
100 {Opt_bsdgroups, "bsdgroups"}, /* group-ID from parent directory */
101 {Opt_sysvgroups,"sysvgroups"}, /* group-ID from current process */
102 {Opt_allocsize, "allocsize=%s"},/* preferred allocation size */
103 {Opt_norecovery,"norecovery"}, /* don't run XFS recovery */
104 {Opt_barrier, "barrier"}, /* use writer barriers for log write and
105 * unwritten extent conversion */
106 {Opt_nobarrier, "nobarrier"}, /* .. disable */
107 {Opt_inode64, "inode64"}, /* inodes can be allocated anywhere */
108 {Opt_inode32, "inode32"}, /* inode allocation limited to
109 * XFS_MAXINUMBER_32 */
110 {Opt_ikeep, "ikeep"}, /* do not free empty inode clusters */
111 {Opt_noikeep, "noikeep"}, /* free empty inode clusters */
112 {Opt_largeio, "largeio"}, /* report large I/O sizes in stat() */
113 {Opt_nolargeio, "nolargeio"}, /* do not report large I/O sizes
114 * in stat(). */
115 {Opt_attr2, "attr2"}, /* do use attr2 attribute format */
116 {Opt_noattr2, "noattr2"}, /* do not use attr2 attribute format */
117 {Opt_filestreams,"filestreams"},/* use filestreams allocator */
118 {Opt_quota, "quota"}, /* disk quotas (user) */
119 {Opt_noquota, "noquota"}, /* no quotas */
120 {Opt_usrquota, "usrquota"}, /* user quota enabled */
121 {Opt_grpquota, "grpquota"}, /* group quota enabled */
122 {Opt_prjquota, "prjquota"}, /* project quota enabled */
123 {Opt_uquota, "uquota"}, /* user quota (IRIX variant) */
124 {Opt_gquota, "gquota"}, /* group quota (IRIX variant) */
125 {Opt_pquota, "pquota"}, /* project quota (IRIX variant) */
126 {Opt_uqnoenforce,"uqnoenforce"},/* user quota limit enforcement */
127 {Opt_gqnoenforce,"gqnoenforce"},/* group quota limit enforcement */
128 {Opt_pqnoenforce,"pqnoenforce"},/* project quota limit enforcement */
129 {Opt_qnoenforce, "qnoenforce"}, /* same as uqnoenforce */
130 {Opt_discard, "discard"}, /* Discard unused blocks */
131 {Opt_nodiscard, "nodiscard"}, /* Do not discard unused blocks */
132
133 {Opt_dax, "dax"}, /* Enable direct access to bdev pages */
134 {Opt_err, NULL},
Christoph Hellwig62a877e2008-07-18 17:12:36 +1000135};
136
137
Markus Elfringa841b642016-01-04 16:13:21 +1100138STATIC int
Eric Sandeen2e74af02016-03-02 09:55:38 +1100139suffix_kstrtoint(const substring_t *s, unsigned int base, int *res)
David Chinnera67d7c52007-11-23 16:29:32 +1100140{
Abhijit Pawara17164e2013-01-09 19:34:42 +0530141 int last, shift_left_factor = 0, _res;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100142 char *value;
143 int ret = 0;
144
145 value = match_strdup(s);
146 if (!value)
147 return -ENOMEM;
David Chinnera67d7c52007-11-23 16:29:32 +1100148
149 last = strlen(value) - 1;
150 if (value[last] == 'K' || value[last] == 'k') {
151 shift_left_factor = 10;
152 value[last] = '\0';
153 }
154 if (value[last] == 'M' || value[last] == 'm') {
155 shift_left_factor = 20;
156 value[last] = '\0';
157 }
158 if (value[last] == 'G' || value[last] == 'g') {
159 shift_left_factor = 30;
160 value[last] = '\0';
161 }
162
Eric Sandeen2e74af02016-03-02 09:55:38 +1100163 if (kstrtoint(value, base, &_res))
164 ret = -EINVAL;
165 kfree(value);
Abhijit Pawara17164e2013-01-09 19:34:42 +0530166 *res = _res << shift_left_factor;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100167 return ret;
David Chinnera67d7c52007-11-23 16:29:32 +1100168}
169
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100170/*
171 * This function fills in xfs_mount_t fields based on mount args.
172 * Note: the superblock has _not_ yet been read in.
173 *
174 * Note that this function leaks the various device name allocations on
175 * failure. The caller takes care of them.
Eric Sandeena08ee402016-03-02 09:56:31 +1100176 *
177 * *sb is const because this is also used to test options on the remount
178 * path, and we don't want this to have any side effects at remount time.
179 * Today this function does not change *sb, but just to future-proof...
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100180 */
David Chinnera67d7c52007-11-23 16:29:32 +1100181STATIC int
182xfs_parseargs(
183 struct xfs_mount *mp,
Christoph Hellwig288699f2010-06-23 18:11:15 +1000184 char *options)
David Chinnera67d7c52007-11-23 16:29:32 +1100185{
Eric Sandeena08ee402016-03-02 09:56:31 +1100186 const struct super_block *sb = mp->m_super;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100187 char *p;
188 substring_t args[MAX_OPT_ARGS];
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100189 int dsunit = 0;
190 int dswidth = 0;
191 int iosize = 0;
Christoph Hellwiga5687782009-02-09 08:37:39 +0100192 __uint8_t iosizelog = 0;
David Chinnera67d7c52007-11-23 16:29:32 +1100193
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100194 /*
Dave Chinner4f107002011-03-07 10:00:35 +1100195 * set up the mount name first so all the errors will refer to the
196 * correct device.
197 */
198 mp->m_fsname = kstrndup(sb->s_id, MAXNAMELEN, GFP_KERNEL);
199 if (!mp->m_fsname)
Dave Chinner24513372014-06-25 14:58:08 +1000200 return -ENOMEM;
Dave Chinner4f107002011-03-07 10:00:35 +1100201 mp->m_fsname_len = strlen(mp->m_fsname) + 1;
202
203 /*
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100204 * Copy binary VFS mount flags we are interested in.
205 */
206 if (sb->s_flags & MS_RDONLY)
207 mp->m_flags |= XFS_MOUNT_RDONLY;
208 if (sb->s_flags & MS_DIRSYNC)
209 mp->m_flags |= XFS_MOUNT_DIRSYNC;
210 if (sb->s_flags & MS_SYNCHRONOUS)
211 mp->m_flags |= XFS_MOUNT_WSYNC;
212
213 /*
214 * Set some default flags that could be cleared by the mount option
215 * parsing.
216 */
217 mp->m_flags |= XFS_MOUNT_BARRIER;
218 mp->m_flags |= XFS_MOUNT_COMPAT_IOSIZE;
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100219
220 /*
221 * These can be overridden by the mount option parsing.
222 */
223 mp->m_logbufs = -1;
224 mp->m_logbsize = -1;
David Chinnera67d7c52007-11-23 16:29:32 +1100225
226 if (!options)
227 goto done;
228
Eric Sandeen2e74af02016-03-02 09:55:38 +1100229 while ((p = strsep(&options, ",")) != NULL) {
230 int token;
David Chinnera67d7c52007-11-23 16:29:32 +1100231
Eric Sandeen2e74af02016-03-02 09:55:38 +1100232 if (!*p)
233 continue;
234
235 token = match_token(p, tokens, args);
236 switch (token) {
237 case Opt_logbufs:
238 if (match_int(args, &mp->m_logbufs))
Dave Chinner24513372014-06-25 14:58:08 +1000239 return -EINVAL;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100240 break;
241 case Opt_logbsize:
242 if (suffix_kstrtoint(args, 10, &mp->m_logbsize))
Dave Chinner24513372014-06-25 14:58:08 +1000243 return -EINVAL;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100244 break;
245 case Opt_logdev:
246 mp->m_logname = match_strdup(args);
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100247 if (!mp->m_logname)
Dave Chinner24513372014-06-25 14:58:08 +1000248 return -ENOMEM;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100249 break;
250 case Opt_mtpt:
251 xfs_warn(mp, "%s option not allowed on this system", p);
Dave Chinner24513372014-06-25 14:58:08 +1000252 return -EINVAL;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100253 case Opt_rtdev:
254 mp->m_rtname = match_strdup(args);
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100255 if (!mp->m_rtname)
Dave Chinner24513372014-06-25 14:58:08 +1000256 return -ENOMEM;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100257 break;
258 case Opt_allocsize:
259 case Opt_biosize:
260 if (suffix_kstrtoint(args, 10, &iosize))
Dave Chinner24513372014-06-25 14:58:08 +1000261 return -EINVAL;
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100262 iosizelog = ffs(iosize) - 1;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100263 break;
264 case Opt_grpid:
265 case Opt_bsdgroups:
David Chinnera67d7c52007-11-23 16:29:32 +1100266 mp->m_flags |= XFS_MOUNT_GRPID;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100267 break;
268 case Opt_nogrpid:
269 case Opt_sysvgroups:
David Chinnera67d7c52007-11-23 16:29:32 +1100270 mp->m_flags &= ~XFS_MOUNT_GRPID;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100271 break;
272 case Opt_wsync:
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100273 mp->m_flags |= XFS_MOUNT_WSYNC;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100274 break;
275 case Opt_norecovery:
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100276 mp->m_flags |= XFS_MOUNT_NORECOVERY;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100277 break;
278 case Opt_noalign:
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100279 mp->m_flags |= XFS_MOUNT_NOALIGN;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100280 break;
281 case Opt_swalloc:
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100282 mp->m_flags |= XFS_MOUNT_SWALLOC;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100283 break;
284 case Opt_sunit:
285 if (match_int(args, &dsunit))
Dave Chinner24513372014-06-25 14:58:08 +1000286 return -EINVAL;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100287 break;
288 case Opt_swidth:
289 if (match_int(args, &dswidth))
Dave Chinner24513372014-06-25 14:58:08 +1000290 return -EINVAL;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100291 break;
292 case Opt_inode32:
Carlos Maiolino08bf5402012-09-20 10:32:37 -0300293 mp->m_flags |= XFS_MOUNT_SMALL_INUMS;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100294 break;
295 case Opt_inode64:
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100296 mp->m_flags &= ~XFS_MOUNT_SMALL_INUMS;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100297 break;
298 case Opt_nouuid:
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100299 mp->m_flags |= XFS_MOUNT_NOUUID;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100300 break;
301 case Opt_barrier:
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100302 mp->m_flags |= XFS_MOUNT_BARRIER;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100303 break;
304 case Opt_nobarrier:
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100305 mp->m_flags &= ~XFS_MOUNT_BARRIER;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100306 break;
307 case Opt_ikeep:
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100308 mp->m_flags |= XFS_MOUNT_IKEEP;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100309 break;
310 case Opt_noikeep:
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100311 mp->m_flags &= ~XFS_MOUNT_IKEEP;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100312 break;
313 case Opt_largeio:
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100314 mp->m_flags &= ~XFS_MOUNT_COMPAT_IOSIZE;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100315 break;
316 case Opt_nolargeio:
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100317 mp->m_flags |= XFS_MOUNT_COMPAT_IOSIZE;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100318 break;
319 case Opt_attr2:
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100320 mp->m_flags |= XFS_MOUNT_ATTR2;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100321 break;
322 case Opt_noattr2:
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100323 mp->m_flags &= ~XFS_MOUNT_ATTR2;
324 mp->m_flags |= XFS_MOUNT_NOATTR2;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100325 break;
326 case Opt_filestreams:
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100327 mp->m_flags |= XFS_MOUNT_FILESTREAMS;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100328 break;
329 case Opt_noquota:
Chandra Seetharaman4177af32012-01-23 17:31:43 +0000330 mp->m_qflags &= ~XFS_ALL_QUOTA_ACCT;
331 mp->m_qflags &= ~XFS_ALL_QUOTA_ENFD;
332 mp->m_qflags &= ~XFS_ALL_QUOTA_ACTIVE;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100333 break;
334 case Opt_quota:
335 case Opt_uquota:
336 case Opt_usrquota:
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100337 mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ACTIVE |
338 XFS_UQUOTA_ENFD);
Eric Sandeen2e74af02016-03-02 09:55:38 +1100339 break;
340 case Opt_qnoenforce:
341 case Opt_uqnoenforce:
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100342 mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ACTIVE);
343 mp->m_qflags &= ~XFS_UQUOTA_ENFD;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100344 break;
345 case Opt_pquota:
346 case Opt_prjquota:
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100347 mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE |
Chandra Seetharaman83e782e2013-06-27 17:25:10 -0500348 XFS_PQUOTA_ENFD);
Eric Sandeen2e74af02016-03-02 09:55:38 +1100349 break;
350 case Opt_pqnoenforce:
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100351 mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE);
Chandra Seetharaman83e782e2013-06-27 17:25:10 -0500352 mp->m_qflags &= ~XFS_PQUOTA_ENFD;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100353 case Opt_gquota:
354 case Opt_grpquota:
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100355 mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE |
Chandra Seetharaman83e782e2013-06-27 17:25:10 -0500356 XFS_GQUOTA_ENFD);
Eric Sandeen2e74af02016-03-02 09:55:38 +1100357 break;
358 case Opt_gqnoenforce:
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 mp->m_qflags &= ~XFS_GQUOTA_ENFD;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100361 break;
362 case Opt_discard:
Christoph Hellwige84661a2011-05-20 13:45:32 +0000363 mp->m_flags |= XFS_MOUNT_DISCARD;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100364 break;
365 case Opt_nodiscard:
Christoph Hellwige84661a2011-05-20 13:45:32 +0000366 mp->m_flags &= ~XFS_MOUNT_DISCARD;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100367 break;
Dave Chinnercbe4dab2015-06-04 09:19:18 +1000368#ifdef CONFIG_FS_DAX
Eric Sandeen2e74af02016-03-02 09:55:38 +1100369 case Opt_dax:
Dave Chinnercbe4dab2015-06-04 09:19:18 +1000370 mp->m_flags |= XFS_MOUNT_DAX;
Eric Sandeen2e74af02016-03-02 09:55:38 +1100371 break;
Dave Chinnercbe4dab2015-06-04 09:19:18 +1000372#endif
Eric Sandeen2e74af02016-03-02 09:55:38 +1100373 default:
374 xfs_warn(mp, "unknown mount option [%s].", p);
Dave Chinner24513372014-06-25 14:58:08 +1000375 return -EINVAL;
David Chinnera67d7c52007-11-23 16:29:32 +1100376 }
377 }
378
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100379 /*
380 * no recovery flag requires a read-only mount
381 */
382 if ((mp->m_flags & XFS_MOUNT_NORECOVERY) &&
383 !(mp->m_flags & XFS_MOUNT_RDONLY)) {
Dave Chinner4f107002011-03-07 10:00:35 +1100384 xfs_warn(mp, "no-recovery mounts must be read-only.");
Dave Chinner24513372014-06-25 14:58:08 +1000385 return -EINVAL;
David Chinnera67d7c52007-11-23 16:29:32 +1100386 }
387
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100388 if ((mp->m_flags & XFS_MOUNT_NOALIGN) && (dsunit || dswidth)) {
Dave Chinner4f107002011-03-07 10:00:35 +1100389 xfs_warn(mp,
390 "sunit and swidth options incompatible with the noalign option");
Dave Chinner24513372014-06-25 14:58:08 +1000391 return -EINVAL;
David Chinnera67d7c52007-11-23 16:29:32 +1100392 }
393
Christoph Hellwig7d095252009-06-08 15:33:32 +0200394#ifndef CONFIG_XFS_QUOTA
395 if (XFS_IS_QUOTA_RUNNING(mp)) {
Dave Chinner4f107002011-03-07 10:00:35 +1100396 xfs_warn(mp, "quota support not available in this kernel.");
Dave Chinner24513372014-06-25 14:58:08 +1000397 return -EINVAL;
Christoph Hellwig7d095252009-06-08 15:33:32 +0200398 }
399#endif
400
David Chinnera67d7c52007-11-23 16:29:32 +1100401 if ((dsunit && !dswidth) || (!dsunit && dswidth)) {
Dave Chinner4f107002011-03-07 10:00:35 +1100402 xfs_warn(mp, "sunit and swidth must be specified together");
Dave Chinner24513372014-06-25 14:58:08 +1000403 return -EINVAL;
David Chinnera67d7c52007-11-23 16:29:32 +1100404 }
405
406 if (dsunit && (dswidth % dsunit != 0)) {
Dave Chinner4f107002011-03-07 10:00:35 +1100407 xfs_warn(mp,
408 "stripe width (%d) must be a multiple of the stripe unit (%d)",
David Chinnera67d7c52007-11-23 16:29:32 +1100409 dswidth, dsunit);
Dave Chinner24513372014-06-25 14:58:08 +1000410 return -EINVAL;
David Chinnera67d7c52007-11-23 16:29:32 +1100411 }
412
David Chinnera67d7c52007-11-23 16:29:32 +1100413done:
Jie Liu39a45d82013-05-02 19:27:47 +0800414 if (dsunit && !(mp->m_flags & XFS_MOUNT_NOALIGN)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100415 /*
416 * At this point the superblock has not been read
417 * in, therefore we do not know the block size.
418 * Before the mount call ends we will convert
419 * these to FSBs.
420 */
Jie Liu39a45d82013-05-02 19:27:47 +0800421 mp->m_dalign = dsunit;
422 mp->m_swidth = dswidth;
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100423 }
424
425 if (mp->m_logbufs != -1 &&
426 mp->m_logbufs != 0 &&
427 (mp->m_logbufs < XLOG_MIN_ICLOGS ||
428 mp->m_logbufs > XLOG_MAX_ICLOGS)) {
Dave Chinner4f107002011-03-07 10:00:35 +1100429 xfs_warn(mp, "invalid logbufs value: %d [not %d-%d]",
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100430 mp->m_logbufs, XLOG_MIN_ICLOGS, XLOG_MAX_ICLOGS);
Dave Chinner24513372014-06-25 14:58:08 +1000431 return -EINVAL;
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100432 }
433 if (mp->m_logbsize != -1 &&
434 mp->m_logbsize != 0 &&
435 (mp->m_logbsize < XLOG_MIN_RECORD_BSIZE ||
436 mp->m_logbsize > XLOG_MAX_RECORD_BSIZE ||
437 !is_power_of_2(mp->m_logbsize))) {
Dave Chinner4f107002011-03-07 10:00:35 +1100438 xfs_warn(mp,
439 "invalid logbufsize: %d [not 16k,32k,64k,128k or 256k]",
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100440 mp->m_logbsize);
Dave Chinner24513372014-06-25 14:58:08 +1000441 return -EINVAL;
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100442 }
443
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100444 if (iosizelog) {
445 if (iosizelog > XFS_MAX_IO_LOG ||
446 iosizelog < XFS_MIN_IO_LOG) {
Dave Chinner4f107002011-03-07 10:00:35 +1100447 xfs_warn(mp, "invalid log iosize: %d [not %d-%d]",
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100448 iosizelog, XFS_MIN_IO_LOG,
449 XFS_MAX_IO_LOG);
Dave Chinner24513372014-06-25 14:58:08 +1000450 return -EINVAL;
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100451 }
452
453 mp->m_flags |= XFS_MOUNT_DFLT_IOSIZE;
454 mp->m_readio_log = iosizelog;
455 mp->m_writeio_log = iosizelog;
456 }
457
David Chinnera67d7c52007-11-23 16:29:32 +1100458 return 0;
459}
460
461struct proc_xfs_info {
Dave Chinnercbe4dab2015-06-04 09:19:18 +1000462 uint64_t flag;
463 char *str;
David Chinnera67d7c52007-11-23 16:29:32 +1100464};
465
466STATIC int
467xfs_showargs(
468 struct xfs_mount *mp,
469 struct seq_file *m)
470{
471 static struct proc_xfs_info xfs_info_set[] = {
472 /* the few simple ones we can get from the mount struct */
Eric Sandeen2e74af02016-03-02 09:55:38 +1100473 { XFS_MOUNT_IKEEP, ",ikeep" },
474 { XFS_MOUNT_WSYNC, ",wsync" },
475 { XFS_MOUNT_NOALIGN, ",noalign" },
476 { XFS_MOUNT_SWALLOC, ",swalloc" },
477 { XFS_MOUNT_NOUUID, ",nouuid" },
478 { XFS_MOUNT_NORECOVERY, ",norecovery" },
479 { XFS_MOUNT_ATTR2, ",attr2" },
480 { XFS_MOUNT_FILESTREAMS, ",filestreams" },
481 { XFS_MOUNT_GRPID, ",grpid" },
482 { XFS_MOUNT_DISCARD, ",discard" },
483 { XFS_MOUNT_SMALL_INUMS, ",inode32" },
484 { XFS_MOUNT_DAX, ",dax" },
David Chinnera67d7c52007-11-23 16:29:32 +1100485 { 0, NULL }
486 };
487 static struct proc_xfs_info xfs_info_unset[] = {
488 /* the few simple ones we can get from the mount struct */
Eric Sandeen2e74af02016-03-02 09:55:38 +1100489 { XFS_MOUNT_COMPAT_IOSIZE, ",largeio" },
490 { XFS_MOUNT_BARRIER, ",nobarrier" },
491 { XFS_MOUNT_SMALL_INUMS, ",inode64" },
David Chinnera67d7c52007-11-23 16:29:32 +1100492 { 0, NULL }
493 };
494 struct proc_xfs_info *xfs_infop;
495
496 for (xfs_infop = xfs_info_set; xfs_infop->flag; xfs_infop++) {
497 if (mp->m_flags & xfs_infop->flag)
498 seq_puts(m, xfs_infop->str);
499 }
500 for (xfs_infop = xfs_info_unset; xfs_infop->flag; xfs_infop++) {
501 if (!(mp->m_flags & xfs_infop->flag))
502 seq_puts(m, xfs_infop->str);
503 }
504
505 if (mp->m_flags & XFS_MOUNT_DFLT_IOSIZE)
Eric Sandeen2e74af02016-03-02 09:55:38 +1100506 seq_printf(m, ",allocsize=%dk",
David Chinnera67d7c52007-11-23 16:29:32 +1100507 (int)(1 << mp->m_writeio_log) >> 10);
508
509 if (mp->m_logbufs > 0)
Eric Sandeen2e74af02016-03-02 09:55:38 +1100510 seq_printf(m, ",logbufs=%d", mp->m_logbufs);
David Chinnera67d7c52007-11-23 16:29:32 +1100511 if (mp->m_logbsize > 0)
Eric Sandeen2e74af02016-03-02 09:55:38 +1100512 seq_printf(m, ",logbsize=%dk", mp->m_logbsize >> 10);
David Chinnera67d7c52007-11-23 16:29:32 +1100513
514 if (mp->m_logname)
Eric Sandeen2e74af02016-03-02 09:55:38 +1100515 seq_show_option(m, "logdev", mp->m_logname);
David Chinnera67d7c52007-11-23 16:29:32 +1100516 if (mp->m_rtname)
Eric Sandeen2e74af02016-03-02 09:55:38 +1100517 seq_show_option(m, "rtdev", mp->m_rtname);
David Chinnera67d7c52007-11-23 16:29:32 +1100518
519 if (mp->m_dalign > 0)
Eric Sandeen2e74af02016-03-02 09:55:38 +1100520 seq_printf(m, ",sunit=%d",
David Chinnera67d7c52007-11-23 16:29:32 +1100521 (int)XFS_FSB_TO_BB(mp, mp->m_dalign));
522 if (mp->m_swidth > 0)
Eric Sandeen2e74af02016-03-02 09:55:38 +1100523 seq_printf(m, ",swidth=%d",
David Chinnera67d7c52007-11-23 16:29:32 +1100524 (int)XFS_FSB_TO_BB(mp, mp->m_swidth));
525
526 if (mp->m_qflags & (XFS_UQUOTA_ACCT|XFS_UQUOTA_ENFD))
Eric Sandeen2e74af02016-03-02 09:55:38 +1100527 seq_puts(m, ",usrquota");
David Chinnera67d7c52007-11-23 16:29:32 +1100528 else if (mp->m_qflags & XFS_UQUOTA_ACCT)
Eric Sandeen2e74af02016-03-02 09:55:38 +1100529 seq_puts(m, ",uqnoenforce");
David Chinnera67d7c52007-11-23 16:29:32 +1100530
Alex Elder988abe42009-09-02 17:02:24 -0500531 if (mp->m_qflags & XFS_PQUOTA_ACCT) {
Chandra Seetharaman83e782e2013-06-27 17:25:10 -0500532 if (mp->m_qflags & XFS_PQUOTA_ENFD)
Eric Sandeen2e74af02016-03-02 09:55:38 +1100533 seq_puts(m, ",prjquota");
Alex Elder988abe42009-09-02 17:02:24 -0500534 else
Eric Sandeen2e74af02016-03-02 09:55:38 +1100535 seq_puts(m, ",pqnoenforce");
Chandra Seetharamand892d582013-07-19 17:36:02 -0500536 }
537 if (mp->m_qflags & XFS_GQUOTA_ACCT) {
Chandra Seetharaman83e782e2013-06-27 17:25:10 -0500538 if (mp->m_qflags & XFS_GQUOTA_ENFD)
Eric Sandeen2e74af02016-03-02 09:55:38 +1100539 seq_puts(m, ",grpquota");
Alex Elder988abe42009-09-02 17:02:24 -0500540 else
Eric Sandeen2e74af02016-03-02 09:55:38 +1100541 seq_puts(m, ",gqnoenforce");
Alex Elder988abe42009-09-02 17:02:24 -0500542 }
David Chinnera67d7c52007-11-23 16:29:32 +1100543
544 if (!(mp->m_qflags & XFS_ALL_QUOTA_ACCT))
Eric Sandeen2e74af02016-03-02 09:55:38 +1100545 seq_puts(m, ",noquota");
David Chinnera67d7c52007-11-23 16:29:32 +1100546
547 return 0;
548}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549__uint64_t
550xfs_max_file_offset(
551 unsigned int blockshift)
552{
553 unsigned int pagefactor = 1;
554 unsigned int bitshift = BITS_PER_LONG - 1;
555
556 /* Figure out maximum filesize, on Linux this can depend on
557 * the filesystem blocksize (on 32 bit platforms).
Christoph Hellwigebdec242010-10-06 10:47:23 +0200558 * __block_write_begin does this in an [unsigned] long...
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 * page->index << (PAGE_CACHE_SHIFT - bbits)
560 * So, for page sized blocks (4K on 32 bit platforms),
561 * this wraps at around 8Tb (hence MAX_LFS_FILESIZE which is
562 * (((u64)PAGE_CACHE_SIZE << (BITS_PER_LONG-1))-1)
563 * but for smaller blocksizes it is less (bbits = log2 bsize).
564 * Note1: get_block_t takes a long (implicit cast from above)
565 * Note2: The Large Block Device (LBD and HAVE_SECTOR_T) patch
566 * can optionally convert the [unsigned] long from above into
567 * an [unsigned] long long.
568 */
569
570#if BITS_PER_LONG == 32
Bartlomiej Zolnierkiewicz90c699a2009-06-19 08:08:50 +0200571# if defined(CONFIG_LBDAF)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 ASSERT(sizeof(sector_t) == 8);
573 pagefactor = PAGE_CACHE_SIZE;
574 bitshift = BITS_PER_LONG;
575# else
576 pagefactor = PAGE_CACHE_SIZE >> (PAGE_CACHE_SHIFT - blockshift);
577# endif
578#endif
579
580 return (((__uint64_t)pagefactor) << bitshift) - 1;
581}
582
Eric Sandeen9de67c32014-07-24 20:51:54 +1000583/*
Eric Sandeen12c3f052016-03-02 09:58:09 +1100584 * Set parameters for inode allocation heuristics, taking into account
585 * filesystem size and inode32/inode64 mount options; i.e. specifically
586 * whether or not XFS_MOUNT_SMALL_INUMS is set.
587 *
588 * Inode allocation patterns are altered only if inode32 is requested
589 * (XFS_MOUNT_SMALL_INUMS), and the filesystem is sufficiently large.
590 * If altered, XFS_MOUNT_32BITINODES is set as well.
591 *
592 * An agcount independent of that in the mount structure is provided
593 * because in the growfs case, mp->m_sb.sb_agcount is not yet updated
594 * to the potentially higher ag count.
595 *
596 * Returns the maximum AG index which may contain inodes.
Eric Sandeen9de67c32014-07-24 20:51:54 +1000597 */
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300598xfs_agnumber_t
Eric Sandeen12c3f052016-03-02 09:58:09 +1100599xfs_set_inode_alloc(
600 struct xfs_mount *mp,
601 xfs_agnumber_t agcount)
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300602{
Eric Sandeen12c3f052016-03-02 09:58:09 +1100603 xfs_agnumber_t index;
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
Eric Sandeen12c3f052016-03-02 09:58:09 +1100610 /*
611 * Calculate how much should be reserved for inodes to meet
612 * the max inode percentage. Used only for inode32.
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300613 */
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 Sandeen12c3f052016-03-02 09:58:09 +1100626 /* Get the last possible inode in the filesystem */
Eric Sandeen54aa61f2014-07-24 20:53:10 +1000627 agino = XFS_OFFBNO_TO_AGINO(mp, sbp->sb_agblocks - 1, 0);
Eric Sandeen12c3f052016-03-02 09:58:09 +1100628 ino = XFS_AGINO_TO_INO(mp, agcount - 1, agino);
Eric Sandeen54aa61f2014-07-24 20:53:10 +1000629
Eric Sandeen12c3f052016-03-02 09:58:09 +1100630 /*
631 * If user asked for no more than 32-bit inodes, and the fs is
632 * sufficiently large, set XFS_MOUNT_32BITINODES if we must alter
633 * the allocator to accommodate the request.
634 */
635 if ((mp->m_flags & XFS_MOUNT_SMALL_INUMS) && ino > XFS_MAXINUMBER_32)
636 mp->m_flags |= XFS_MOUNT_32BITINODES;
637 else
638 mp->m_flags &= ~XFS_MOUNT_32BITINODES;
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300639
Eric Sandeen9de67c32014-07-24 20:51:54 +1000640 for (index = 0; index < agcount; index++) {
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300641 struct xfs_perag *pag;
642
Eric Sandeen12c3f052016-03-02 09:58:09 +1100643 ino = XFS_AGINO_TO_INO(mp, index, agino);
644
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300645 pag = xfs_perag_get(mp, index);
Eric Sandeen12c3f052016-03-02 09:58:09 +1100646
647 if (mp->m_flags & XFS_MOUNT_32BITINODES) {
648 if (ino > XFS_MAXINUMBER_32) {
649 pag->pagi_inodeok = 0;
650 pag->pagf_metadata = 0;
651 } else {
652 pag->pagi_inodeok = 1;
653 maxagi++;
654 if (index < max_metadata)
655 pag->pagf_metadata = 1;
656 else
657 pag->pagf_metadata = 0;
658 }
659 } else {
660 pag->pagi_inodeok = 1;
661 pag->pagf_metadata = 0;
662 }
663
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300664 xfs_perag_put(pag);
665 }
666
Eric Sandeen12c3f052016-03-02 09:58:09 +1100667 return (mp->m_flags & XFS_MOUNT_32BITINODES) ? maxagi : agcount;
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300668}
669
Hannes Eder3180e662009-03-04 19:34:10 +0100670STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671xfs_blkdev_get(
672 xfs_mount_t *mp,
673 const char *name,
674 struct block_device **bdevp)
675{
676 int error = 0;
677
Tejun Heod4d77622010-11-13 11:55:18 +0100678 *bdevp = blkdev_get_by_path(name, FMODE_READ|FMODE_WRITE|FMODE_EXCL,
679 mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 if (IS_ERR(*bdevp)) {
681 error = PTR_ERR(*bdevp);
Eric Sandeen77af5742014-12-24 09:47:27 +1100682 xfs_warn(mp, "Invalid device [%s], error=%d", name, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 }
684
Dave Chinner24513372014-06-25 14:58:08 +1000685 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686}
687
Hannes Eder3180e662009-03-04 19:34:10 +0100688STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689xfs_blkdev_put(
690 struct block_device *bdev)
691{
692 if (bdev)
Tejun Heoe525fd82010-11-13 11:55:17 +0100693 blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694}
695
Christoph Hellwigf538d4d2005-11-02 10:26:59 +1100696void
697xfs_blkdev_issue_flush(
698 xfs_buftarg_t *buftarg)
699{
Shaohua Li7582df52012-04-24 21:23:46 +0800700 blkdev_issue_flush(buftarg->bt_bdev, GFP_NOFS, NULL);
Christoph Hellwigf538d4d2005-11-02 10:26:59 +1100701}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000703STATIC void
704xfs_close_devices(
705 struct xfs_mount *mp)
706{
707 if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp) {
Lachlan McIlroyc032bfc2008-07-18 17:13:12 +1000708 struct block_device *logdev = mp->m_logdev_targp->bt_bdev;
Christoph Hellwigb7963132009-03-03 14:48:37 -0500709 xfs_free_buftarg(mp, mp->m_logdev_targp);
Lachlan McIlroyc032bfc2008-07-18 17:13:12 +1000710 xfs_blkdev_put(logdev);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000711 }
712 if (mp->m_rtdev_targp) {
Lachlan McIlroyc032bfc2008-07-18 17:13:12 +1000713 struct block_device *rtdev = mp->m_rtdev_targp->bt_bdev;
Christoph Hellwigb7963132009-03-03 14:48:37 -0500714 xfs_free_buftarg(mp, mp->m_rtdev_targp);
Lachlan McIlroyc032bfc2008-07-18 17:13:12 +1000715 xfs_blkdev_put(rtdev);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000716 }
Christoph Hellwigb7963132009-03-03 14:48:37 -0500717 xfs_free_buftarg(mp, mp->m_ddev_targp);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000718}
719
720/*
721 * The file system configurations are:
722 * (1) device (partition) with data and internal log
723 * (2) logical volume with data and log subvolumes.
724 * (3) logical volume with data, log, and realtime subvolumes.
725 *
726 * We only have to handle opening the log and realtime volumes here if
727 * they are present. The data subvolume has already been opened by
728 * get_sb_bdev() and is stored in sb->s_bdev.
729 */
730STATIC int
731xfs_open_devices(
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100732 struct xfs_mount *mp)
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000733{
734 struct block_device *ddev = mp->m_super->s_bdev;
735 struct block_device *logdev = NULL, *rtdev = NULL;
736 int error;
737
738 /*
739 * Open real time and log devices - order is important.
740 */
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100741 if (mp->m_logname) {
742 error = xfs_blkdev_get(mp, mp->m_logname, &logdev);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000743 if (error)
744 goto out;
745 }
746
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100747 if (mp->m_rtname) {
748 error = xfs_blkdev_get(mp, mp->m_rtname, &rtdev);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000749 if (error)
750 goto out_close_logdev;
751
752 if (rtdev == ddev || rtdev == logdev) {
Dave Chinner4f107002011-03-07 10:00:35 +1100753 xfs_warn(mp,
754 "Cannot mount filesystem with identical rtdev and ddev/logdev.");
Dave Chinner24513372014-06-25 14:58:08 +1000755 error = -EINVAL;
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000756 goto out_close_rtdev;
757 }
758 }
759
760 /*
761 * Setup xfs_mount buffer target pointers
762 */
Dave Chinner24513372014-06-25 14:58:08 +1000763 error = -ENOMEM;
Eric Sandeen34dcefd2014-04-14 19:01:00 +1000764 mp->m_ddev_targp = xfs_alloc_buftarg(mp, ddev);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000765 if (!mp->m_ddev_targp)
766 goto out_close_rtdev;
767
768 if (rtdev) {
Eric Sandeen34dcefd2014-04-14 19:01:00 +1000769 mp->m_rtdev_targp = xfs_alloc_buftarg(mp, rtdev);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000770 if (!mp->m_rtdev_targp)
771 goto out_free_ddev_targ;
772 }
773
774 if (logdev && logdev != ddev) {
Eric Sandeen34dcefd2014-04-14 19:01:00 +1000775 mp->m_logdev_targp = xfs_alloc_buftarg(mp, logdev);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000776 if (!mp->m_logdev_targp)
777 goto out_free_rtdev_targ;
778 } else {
779 mp->m_logdev_targp = mp->m_ddev_targp;
780 }
781
782 return 0;
783
784 out_free_rtdev_targ:
785 if (mp->m_rtdev_targp)
Christoph Hellwigb7963132009-03-03 14:48:37 -0500786 xfs_free_buftarg(mp, mp->m_rtdev_targp);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000787 out_free_ddev_targ:
Christoph Hellwigb7963132009-03-03 14:48:37 -0500788 xfs_free_buftarg(mp, mp->m_ddev_targp);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000789 out_close_rtdev:
Markus Elfringd2a5e3c2014-12-01 08:24:20 +1100790 xfs_blkdev_put(rtdev);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000791 out_close_logdev:
792 if (logdev && logdev != ddev)
793 xfs_blkdev_put(logdev);
794 out:
795 return error;
796}
797
Christoph Hellwige34b5622008-05-20 15:10:36 +1000798/*
799 * Setup xfs_mount buffer target pointers based on superblock
800 */
801STATIC int
802xfs_setup_devices(
803 struct xfs_mount *mp)
804{
805 int error;
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000806
Eric Sandeena96c4152014-04-14 19:00:29 +1000807 error = xfs_setsize_buftarg(mp->m_ddev_targp, mp->m_sb.sb_sectsize);
Christoph Hellwige34b5622008-05-20 15:10:36 +1000808 if (error)
809 return error;
810
811 if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp) {
812 unsigned int log_sector_size = BBSIZE;
813
814 if (xfs_sb_version_hassector(&mp->m_sb))
815 log_sector_size = mp->m_sb.sb_logsectsize;
816 error = xfs_setsize_buftarg(mp->m_logdev_targp,
Christoph Hellwige34b5622008-05-20 15:10:36 +1000817 log_sector_size);
818 if (error)
819 return error;
820 }
821 if (mp->m_rtdev_targp) {
822 error = xfs_setsize_buftarg(mp->m_rtdev_targp,
Christoph Hellwige34b5622008-05-20 15:10:36 +1000823 mp->m_sb.sb_sectsize);
824 if (error)
825 return error;
826 }
827
828 return 0;
829}
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000830
Christoph Hellwigaa6bf012012-02-29 09:53:48 +0000831STATIC int
832xfs_init_mount_workqueues(
833 struct xfs_mount *mp)
834{
Brian Foster78c931b2014-11-28 13:59:58 +1100835 mp->m_buf_workqueue = alloc_workqueue("xfs-buf/%s",
Brian Fosterb29c70f2014-12-04 09:43:17 +1100836 WQ_MEM_RECLAIM|WQ_FREEZABLE, 1, mp->m_fsname);
Brian Foster78c931b2014-11-28 13:59:58 +1100837 if (!mp->m_buf_workqueue)
838 goto out;
839
Christoph Hellwigaa6bf012012-02-29 09:53:48 +0000840 mp->m_data_workqueue = alloc_workqueue("xfs-data/%s",
Brian Foster8018ec02014-09-09 11:44:46 +1000841 WQ_MEM_RECLAIM|WQ_FREEZABLE, 0, mp->m_fsname);
Christoph Hellwigaa6bf012012-02-29 09:53:48 +0000842 if (!mp->m_data_workqueue)
Brian Foster78c931b2014-11-28 13:59:58 +1100843 goto out_destroy_buf;
Christoph Hellwigaa6bf012012-02-29 09:53:48 +0000844
845 mp->m_unwritten_workqueue = alloc_workqueue("xfs-conv/%s",
Brian Foster8018ec02014-09-09 11:44:46 +1000846 WQ_MEM_RECLAIM|WQ_FREEZABLE, 0, mp->m_fsname);
Christoph Hellwigaa6bf012012-02-29 09:53:48 +0000847 if (!mp->m_unwritten_workqueue)
848 goto out_destroy_data_iodone_queue;
849
Dave Chinner4c2d5422012-04-23 17:54:32 +1000850 mp->m_cil_workqueue = alloc_workqueue("xfs-cil/%s",
Brian Foster8018ec02014-09-09 11:44:46 +1000851 WQ_MEM_RECLAIM|WQ_FREEZABLE, 0, mp->m_fsname);
Dave Chinner4c2d5422012-04-23 17:54:32 +1000852 if (!mp->m_cil_workqueue)
853 goto out_destroy_unwritten;
Dave Chinner58896082012-10-08 21:56:05 +1100854
855 mp->m_reclaim_workqueue = alloc_workqueue("xfs-reclaim/%s",
Chris Mason7a29ac42015-11-10 10:10:34 +1100856 WQ_MEM_RECLAIM|WQ_FREEZABLE, 0, mp->m_fsname);
Dave Chinner58896082012-10-08 21:56:05 +1100857 if (!mp->m_reclaim_workqueue)
858 goto out_destroy_cil;
859
860 mp->m_log_workqueue = alloc_workqueue("xfs-log/%s",
Chris Mason7a29ac42015-11-10 10:10:34 +1100861 WQ_MEM_RECLAIM|WQ_FREEZABLE|WQ_HIGHPRI, 0,
862 mp->m_fsname);
Dave Chinner58896082012-10-08 21:56:05 +1100863 if (!mp->m_log_workqueue)
864 goto out_destroy_reclaim;
865
Brian Foster579b62f2012-11-06 09:50:47 -0500866 mp->m_eofblocks_workqueue = alloc_workqueue("xfs-eofblocks/%s",
Chris Mason7a29ac42015-11-10 10:10:34 +1100867 WQ_MEM_RECLAIM|WQ_FREEZABLE, 0, mp->m_fsname);
Brian Foster579b62f2012-11-06 09:50:47 -0500868 if (!mp->m_eofblocks_workqueue)
869 goto out_destroy_log;
870
Christoph Hellwigaa6bf012012-02-29 09:53:48 +0000871 return 0;
872
Brian Foster579b62f2012-11-06 09:50:47 -0500873out_destroy_log:
874 destroy_workqueue(mp->m_log_workqueue);
Dave Chinner58896082012-10-08 21:56:05 +1100875out_destroy_reclaim:
876 destroy_workqueue(mp->m_reclaim_workqueue);
877out_destroy_cil:
878 destroy_workqueue(mp->m_cil_workqueue);
Dave Chinner4c2d5422012-04-23 17:54:32 +1000879out_destroy_unwritten:
880 destroy_workqueue(mp->m_unwritten_workqueue);
Christoph Hellwigaa6bf012012-02-29 09:53:48 +0000881out_destroy_data_iodone_queue:
882 destroy_workqueue(mp->m_data_workqueue);
Brian Foster78c931b2014-11-28 13:59:58 +1100883out_destroy_buf:
884 destroy_workqueue(mp->m_buf_workqueue);
Christoph Hellwigaa6bf012012-02-29 09:53:48 +0000885out:
886 return -ENOMEM;
887}
888
889STATIC void
890xfs_destroy_mount_workqueues(
891 struct xfs_mount *mp)
892{
Brian Foster579b62f2012-11-06 09:50:47 -0500893 destroy_workqueue(mp->m_eofblocks_workqueue);
Dave Chinner58896082012-10-08 21:56:05 +1100894 destroy_workqueue(mp->m_log_workqueue);
895 destroy_workqueue(mp->m_reclaim_workqueue);
Dave Chinner4c2d5422012-04-23 17:54:32 +1000896 destroy_workqueue(mp->m_cil_workqueue);
Christoph Hellwigaa6bf012012-02-29 09:53:48 +0000897 destroy_workqueue(mp->m_data_workqueue);
898 destroy_workqueue(mp->m_unwritten_workqueue);
Brian Foster78c931b2014-11-28 13:59:58 +1100899 destroy_workqueue(mp->m_buf_workqueue);
Christoph Hellwigaa6bf012012-02-29 09:53:48 +0000900}
901
Dave Chinner9aa05002012-10-08 21:56:04 +1100902/*
903 * Flush all dirty data to disk. Must not be called while holding an XFS_ILOCK
904 * or a page lock. We use sync_inodes_sb() here to ensure we block while waiting
905 * for IO to complete so that we effectively throttle multiple callers to the
906 * rate at which IO is completing.
907 */
908void
909xfs_flush_inodes(
910 struct xfs_mount *mp)
911{
912 struct super_block *sb = mp->m_super;
913
914 if (down_read_trylock(&sb->s_umount)) {
Jan Kara0dc83bd2014-02-21 11:19:04 +0100915 sync_inodes_sb(sb);
Dave Chinner9aa05002012-10-08 21:56:04 +1100916 up_read(&sb->s_umount);
917 }
918}
919
David Chinnerbf904242008-10-30 17:36:14 +1100920/* Catch misguided souls that try to use this interface on XFS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921STATIC struct inode *
Nathan Scotta50cd262006-03-14 14:06:18 +1100922xfs_fs_alloc_inode(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 struct super_block *sb)
924{
David Chinnerbf904242008-10-30 17:36:14 +1100925 BUG();
Lachlan McIlroy493dca62008-10-30 17:36:52 +1100926 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927}
928
David Chinnerbf904242008-10-30 17:36:14 +1100929/*
David Chinner99fa8cb2008-10-30 17:36:40 +1100930 * Now that the generic code is guaranteed not to be accessing
931 * the linux inode, we can reclaim the inode.
David Chinnerbf904242008-10-30 17:36:14 +1100932 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933STATIC void
Nathan Scotta50cd262006-03-14 14:06:18 +1100934xfs_fs_destroy_inode(
Christoph Hellwig848ce8f2009-09-29 13:48:56 +0000935 struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936{
Christoph Hellwig848ce8f2009-09-29 13:48:56 +0000937 struct xfs_inode *ip = XFS_I(inode);
938
Christoph Hellwigcca28fb2010-06-24 11:57:09 +1000939 trace_xfs_destroy_inode(ip);
David Chinner99fa8cb2008-10-30 17:36:40 +1100940
Bill O'Donnellff6d6af2015-10-12 18:21:22 +1100941 XFS_STATS_INC(ip->i_mount, vn_reclaim);
Christoph Hellwig848ce8f2009-09-29 13:48:56 +0000942
Christoph Hellwig848ce8f2009-09-29 13:48:56 +0000943 ASSERT(XFS_FORCED_SHUTDOWN(ip->i_mount) || ip->i_delayed_blks == 0);
944
945 /*
946 * We should never get here with one of the reclaim flags already set.
947 */
948 ASSERT_ALWAYS(!xfs_iflags_test(ip, XFS_IRECLAIMABLE));
949 ASSERT_ALWAYS(!xfs_iflags_test(ip, XFS_IRECLAIM));
950
951 /*
Dave Chinner57817c62010-01-10 23:51:47 +0000952 * We always use background reclaim here because even if the
953 * inode is clean, it still may be under IO and hence we have
954 * to take the flush lock. The background reclaim path handles
955 * this more efficiently than we can here, so simply let background
956 * reclaim tear down all inodes.
Christoph Hellwig848ce8f2009-09-29 13:48:56 +0000957 */
Dave Chinner57817c62010-01-10 23:51:47 +0000958 xfs_inode_set_reclaim_tag(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959}
960
David Chinner07c8f672008-10-30 16:11:59 +1100961/*
962 * Slab object creation initialisation for the XFS inode.
963 * This covers only the idempotent fields in the XFS inode;
964 * all other fields need to be initialised on allocation
Uwe Kleine-Königb5950762010-11-01 15:38:34 -0400965 * from the slab. This avoids the need to repeatedly initialise
David Chinner07c8f672008-10-30 16:11:59 +1100966 * fields in the xfs inode that left in the initialise state
967 * when freeing the inode.
968 */
David Chinnerbf904242008-10-30 17:36:14 +1100969STATIC void
970xfs_fs_inode_init_once(
David Chinner07c8f672008-10-30 16:11:59 +1100971 void *inode)
972{
973 struct xfs_inode *ip = inode;
974
975 memset(ip, 0, sizeof(struct xfs_inode));
David Chinnerbf904242008-10-30 17:36:14 +1100976
977 /* vfs inode */
978 inode_init_once(VFS_I(ip));
979
980 /* xfs inode */
David Chinner07c8f672008-10-30 16:11:59 +1100981 atomic_set(&ip->i_pincount, 0);
982 spin_lock_init(&ip->i_flags_lock);
David Chinner07c8f672008-10-30 16:11:59 +1100983
Dave Chinner653c60b2015-02-23 21:43:37 +1100984 mrlock_init(&ip->i_mmaplock, MRLOCK_ALLOW_EQUAL_PRI|MRLOCK_BARRIER,
985 "xfsino", ip->i_ino);
David Chinner07c8f672008-10-30 16:11:59 +1100986 mrlock_init(&ip->i_lock, MRLOCK_ALLOW_EQUAL_PRI|MRLOCK_BARRIER,
987 "xfsino", ip->i_ino);
David Chinner07c8f672008-10-30 16:11:59 +1100988}
989
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990STATIC void
Al Virob57922d2010-06-07 14:34:48 -0400991xfs_fs_evict_inode(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992 struct inode *inode)
993{
Christoph Hellwig1543d792007-08-29 11:46:47 +1000994 xfs_inode_t *ip = XFS_I(inode);
Christoph Hellwig56d433e2005-09-05 08:23:54 +1000995
Christoph Hellwig4f59af72012-07-04 11:13:33 -0400996 ASSERT(!rwsem_is_locked(&ip->i_iolock.mr_lock));
997
Al Virob57922d2010-06-07 14:34:48 -0400998 trace_xfs_evict_inode(ip);
Christoph Hellwigcca28fb2010-06-24 11:57:09 +1000999
Johannes Weiner91b0abe2014-04-03 14:47:49 -07001000 truncate_inode_pages_final(&inode->i_data);
Jan Karadbd57682012-05-03 14:48:02 +02001001 clear_inode(inode);
Bill O'Donnellff6d6af2015-10-12 18:21:22 +11001002 XFS_STATS_INC(ip->i_mount, vn_rele);
1003 XFS_STATS_INC(ip->i_mount, vn_remove);
Christoph Hellwig56d433e2005-09-05 08:23:54 +10001004
David Chinner99fa8cb2008-10-30 17:36:40 +11001005 xfs_inactive(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006}
1007
Dave Chinner5132ba82012-03-22 05:15:10 +00001008/*
1009 * We do an unlocked check for XFS_IDONTCACHE here because we are already
1010 * serialised against cache hits here via the inode->i_lock and igrab() in
1011 * xfs_iget_cache_hit(). Hence a lookup that might clear this flag will not be
1012 * racing with us, and it avoids needing to grab a spinlock here for every inode
1013 * we drop the final reference on.
1014 */
1015STATIC int
1016xfs_fs_drop_inode(
1017 struct inode *inode)
1018{
1019 struct xfs_inode *ip = XFS_I(inode);
1020
1021 return generic_drop_inode(inode) || (ip->i_flags & XFS_IDONTCACHE);
1022}
1023
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024STATIC void
Christoph Hellwiga7381592008-08-13 16:04:05 +10001025xfs_free_fsname(
1026 struct xfs_mount *mp)
1027{
1028 kfree(mp->m_fsname);
1029 kfree(mp->m_rtname);
1030 kfree(mp->m_logname);
1031}
1032
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033STATIC int
Christoph Hellwig69961a22009-10-06 20:29:28 +00001034xfs_fs_sync_fs(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035 struct super_block *sb,
1036 int wait)
1037{
Christoph Hellwig745f6912007-08-30 17:20:39 +10001038 struct xfs_mount *mp = XFS_M(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039
Lachlan McIlroye893bff2007-10-12 11:13:35 +10001040 /*
Christoph Hellwig34625c62011-12-06 21:58:12 +00001041 * Doing anything during the async pass would be counterproductive.
Lachlan McIlroye893bff2007-10-12 11:13:35 +10001042 */
Christoph Hellwig34625c62011-12-06 21:58:12 +00001043 if (!wait)
Christoph Hellwig69961a22009-10-06 20:29:28 +00001044 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045
Dave Chinner34061f52012-10-08 21:56:06 +11001046 xfs_log_force(mp, XFS_LOG_SYNC);
Christoph Hellwig69961a22009-10-06 20:29:28 +00001047 if (laptop_mode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048 /*
1049 * The disk must be active because we're syncing.
Dave Chinnerf661f1e2012-10-08 21:56:02 +11001050 * We schedule log work now (now that the disk is
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051 * active) instead of later (when it might not be).
1052 */
Dave Chinnerf661f1e2012-10-08 21:56:02 +11001053 flush_delayed_work(&mp->m_log->l_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054 }
1055
Christoph Hellwig69961a22009-10-06 20:29:28 +00001056 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057}
1058
1059STATIC int
Nathan Scotta50cd262006-03-14 14:06:18 +11001060xfs_fs_statfs(
David Howells726c3342006-06-23 02:02:58 -07001061 struct dentry *dentry,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062 struct kstatfs *statp)
1063{
Christoph Hellwig4ca488e2007-10-11 18:09:40 +10001064 struct xfs_mount *mp = XFS_M(dentry->d_sb);
1065 xfs_sb_t *sbp = &mp->m_sb;
David Howells2b0143b2015-03-17 22:25:59 +00001066 struct xfs_inode *ip = XFS_I(d_inode(dentry));
Christoph Hellwig4ca488e2007-10-11 18:09:40 +10001067 __uint64_t fakeinos, id;
Dave Chinner501ab322015-02-23 21:19:28 +11001068 __uint64_t icount;
Dave Chinnere88b64e2015-02-23 21:19:53 +11001069 __uint64_t ifree;
Dave Chinner0d485ad2015-02-23 21:22:03 +11001070 __uint64_t fdblocks;
Christoph Hellwig4ca488e2007-10-11 18:09:40 +10001071 xfs_extlen_t lsize;
Stuart Brodsky2fe33662010-08-24 11:46:05 +10001072 __int64_t ffree;
Christoph Hellwig4ca488e2007-10-11 18:09:40 +10001073
1074 statp->f_type = XFS_SB_MAGIC;
1075 statp->f_namelen = MAXNAMELEN - 1;
1076
1077 id = huge_encode_dev(mp->m_ddev_targp->bt_dev);
1078 statp->f_fsid.val[0] = (u32)id;
1079 statp->f_fsid.val[1] = (u32)(id >> 32);
1080
Dave Chinner501ab322015-02-23 21:19:28 +11001081 icount = percpu_counter_sum(&mp->m_icount);
Dave Chinnere88b64e2015-02-23 21:19:53 +11001082 ifree = percpu_counter_sum(&mp->m_ifree);
Dave Chinner0d485ad2015-02-23 21:22:03 +11001083 fdblocks = percpu_counter_sum(&mp->m_fdblocks);
Christoph Hellwig4ca488e2007-10-11 18:09:40 +10001084
1085 spin_lock(&mp->m_sb_lock);
1086 statp->f_bsize = sbp->sb_blocksize;
1087 lsize = sbp->sb_logstart ? sbp->sb_logblocks : 0;
1088 statp->f_blocks = sbp->sb_dblocks - lsize;
Dave Chinner0d485ad2015-02-23 21:22:03 +11001089 spin_unlock(&mp->m_sb_lock);
1090
1091 statp->f_bfree = fdblocks - XFS_ALLOC_SET_ASIDE(mp);
1092 statp->f_bavail = statp->f_bfree;
1093
Christoph Hellwig4ca488e2007-10-11 18:09:40 +10001094 fakeinos = statp->f_bfree << sbp->sb_inopblog;
Dave Chinner501ab322015-02-23 21:19:28 +11001095 statp->f_files = MIN(icount + fakeinos, (__uint64_t)XFS_MAXINUMBER);
Christoph Hellwig4ca488e2007-10-11 18:09:40 +10001096 if (mp->m_maxicount)
Christoph Hellwiga19d9f82009-03-29 09:51:08 +02001097 statp->f_files = min_t(typeof(statp->f_files),
1098 statp->f_files,
1099 mp->m_maxicount);
Stuart Brodsky2fe33662010-08-24 11:46:05 +10001100
Eric Sandeen01f98822015-02-06 09:53:02 +11001101 /* If sb_icount overshot maxicount, report actual allocation */
1102 statp->f_files = max_t(typeof(statp->f_files),
1103 statp->f_files,
1104 sbp->sb_icount);
1105
Stuart Brodsky2fe33662010-08-24 11:46:05 +10001106 /* make sure statp->f_ffree does not underflow */
Dave Chinnere88b64e2015-02-23 21:19:53 +11001107 ffree = statp->f_files - (icount - ifree);
Stuart Brodsky2fe33662010-08-24 11:46:05 +10001108 statp->f_ffree = max_t(__int64_t, ffree, 0);
1109
Christoph Hellwig4ca488e2007-10-11 18:09:40 +10001110
Jie Liuda5bf952012-04-12 03:59:57 +00001111 if ((ip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
Chandra Seetharaman83e782e2013-06-27 17:25:10 -05001112 ((mp->m_qflags & (XFS_PQUOTA_ACCT|XFS_PQUOTA_ENFD))) ==
1113 (XFS_PQUOTA_ACCT|XFS_PQUOTA_ENFD))
Christoph Hellwig7d095252009-06-08 15:33:32 +02001114 xfs_qm_statvfs(ip, statp);
Christoph Hellwig4ca488e2007-10-11 18:09:40 +10001115 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001116}
1117
Eric Sandeend5db0f92010-02-05 22:59:53 +00001118STATIC void
1119xfs_save_resvblks(struct xfs_mount *mp)
1120{
1121 __uint64_t resblks = 0;
1122
1123 mp->m_resblks_save = mp->m_resblks;
1124 xfs_reserve_blocks(mp, &resblks, NULL);
1125}
1126
1127STATIC void
1128xfs_restore_resvblks(struct xfs_mount *mp)
1129{
1130 __uint64_t resblks;
1131
1132 if (mp->m_resblks_save) {
1133 resblks = mp->m_resblks_save;
1134 mp->m_resblks_save = 0;
1135 } else
1136 resblks = xfs_default_resblks(mp);
1137
1138 xfs_reserve_blocks(mp, &resblks, NULL);
1139}
1140
Dave Chinnerc7eea6f2012-10-08 21:56:07 +11001141/*
1142 * Trigger writeback of all the dirty metadata in the file system.
1143 *
1144 * This ensures that the metadata is written to their location on disk rather
1145 * than just existing in transactions in the log. This means after a quiesce
Dave Chinnerc75921a2012-10-08 21:56:08 +11001146 * there is no log replay required to write the inodes to disk - this is the
1147 * primary difference between a sync and a quiesce.
Dave Chinnerc7eea6f2012-10-08 21:56:07 +11001148 *
Dave Chinnerc75921a2012-10-08 21:56:08 +11001149 * Note: xfs_log_quiesce() stops background log work - the callers must ensure
1150 * it is started again when appropriate.
Dave Chinnerc7eea6f2012-10-08 21:56:07 +11001151 */
Dave Chinner632b89e2013-10-29 22:11:58 +11001152static void
Dave Chinnerc7eea6f2012-10-08 21:56:07 +11001153xfs_quiesce_attr(
1154 struct xfs_mount *mp)
1155{
1156 int error = 0;
1157
1158 /* wait for all modifications to complete */
1159 while (atomic_read(&mp->m_active_trans) > 0)
1160 delay(100);
1161
1162 /* force the log to unpin objects from the now complete transactions */
1163 xfs_log_force(mp, XFS_LOG_SYNC);
1164
1165 /* reclaim inodes to do any IO before the freeze completes */
1166 xfs_reclaim_inodes(mp, 0);
1167 xfs_reclaim_inodes(mp, SYNC_WAIT);
1168
Dave Chinnerc75921a2012-10-08 21:56:08 +11001169 /* Push the superblock and write an unmount record */
1170 error = xfs_log_sbcount(mp);
1171 if (error)
1172 xfs_warn(mp, "xfs_attr_quiesce: failed to log sb changes. "
1173 "Frozen image may not be consistent.");
Dave Chinnerc7eea6f2012-10-08 21:56:07 +11001174 /*
1175 * Just warn here till VFS can correctly support
1176 * read-only remount without racing.
1177 */
1178 WARN_ON(atomic_read(&mp->m_active_trans) != 0);
1179
Dave Chinnerc75921a2012-10-08 21:56:08 +11001180 xfs_log_quiesce(mp);
Dave Chinnerc7eea6f2012-10-08 21:56:07 +11001181}
1182
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183STATIC int
Eric Sandeena08ee402016-03-02 09:56:31 +11001184xfs_test_remount_options(
1185 struct super_block *sb,
1186 struct xfs_mount *mp,
1187 char *options)
1188{
1189 int error = 0;
1190 struct xfs_mount *tmp_mp;
1191
1192 tmp_mp = kmem_zalloc(sizeof(*tmp_mp), KM_MAYFAIL);
1193 if (!tmp_mp)
1194 return -ENOMEM;
1195
1196 tmp_mp->m_super = sb;
1197 error = xfs_parseargs(tmp_mp, options);
1198 xfs_free_fsname(tmp_mp);
1199 kfree(tmp_mp);
1200
1201 return error;
1202}
1203
1204STATIC int
Nathan Scotta50cd262006-03-14 14:06:18 +11001205xfs_fs_remount(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 struct super_block *sb,
1207 int *flags,
1208 char *options)
1209{
Christoph Hellwig745f6912007-08-30 17:20:39 +10001210 struct xfs_mount *mp = XFS_M(sb);
Eric Sandeen9de67c32014-07-24 20:51:54 +10001211 xfs_sb_t *sbp = &mp->m_sb;
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001212 substring_t args[MAX_OPT_ARGS];
1213 char *p;
Christoph Hellwig7884bc82009-01-19 02:04:07 +01001214 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215
Eric Sandeena08ee402016-03-02 09:56:31 +11001216 /* First, check for complete junk; i.e. invalid options */
1217 error = xfs_test_remount_options(sb, mp, options);
1218 if (error)
1219 return error;
1220
Theodore Ts'o02b99842014-03-13 10:14:33 -04001221 sync_filesystem(sb);
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001222 while ((p = strsep(&options, ",")) != NULL) {
1223 int token;
Christoph Hellwigbdd907b2008-05-20 15:10:44 +10001224
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001225 if (!*p)
1226 continue;
Christoph Hellwig48b62a12008-05-20 11:30:39 +10001227
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001228 token = match_token(p, tokens, args);
1229 switch (token) {
1230 case Opt_barrier:
Christoph Hellwig48b62a12008-05-20 11:30:39 +10001231 mp->m_flags |= XFS_MOUNT_BARRIER;
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001232 break;
1233 case Opt_nobarrier:
Christoph Hellwig48b62a12008-05-20 11:30:39 +10001234 mp->m_flags &= ~XFS_MOUNT_BARRIER;
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001235 break;
Carlos Maiolinoc3a58fe2012-08-17 18:19:38 -03001236 case Opt_inode64:
Eric Sandeen12c3f052016-03-02 09:58:09 +11001237 mp->m_flags &= ~XFS_MOUNT_SMALL_INUMS;
1238 mp->m_maxagi = xfs_set_inode_alloc(mp, sbp->sb_agcount);
Carlos Maiolinoc3a58fe2012-08-17 18:19:38 -03001239 break;
Carlos Maiolino2ea03922012-09-20 10:32:41 -03001240 case Opt_inode32:
Eric Sandeen12c3f052016-03-02 09:58:09 +11001241 mp->m_flags |= XFS_MOUNT_SMALL_INUMS;
1242 mp->m_maxagi = xfs_set_inode_alloc(mp, sbp->sb_agcount);
Carlos Maiolino2ea03922012-09-20 10:32:41 -03001243 break;
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001244 default:
Christoph Hellwig6efdf282008-09-17 16:49:33 +10001245 /*
1246 * Logically we would return an error here to prevent
1247 * users from believing they might have changed
1248 * mount options using remount which can't be changed.
1249 *
1250 * But unfortunately mount(8) adds all options from
1251 * mtab and fstab to the mount arguments in some cases
1252 * so we can't blindly reject options, but have to
1253 * check for each specified option if it actually
1254 * differs from the currently set option and only
1255 * reject it if that's the case.
1256 *
1257 * Until that is implemented we return success for
1258 * every remount request, and silently ignore all
1259 * options that we can't actually change.
1260 */
1261#if 0
Dave Chinner4f107002011-03-07 10:00:35 +11001262 xfs_info(mp,
Eric Sandeen08e96e12013-10-11 20:59:05 -05001263 "mount option \"%s\" not supported for remount", p);
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001264 return -EINVAL;
Christoph Hellwig6efdf282008-09-17 16:49:33 +10001265#else
Christoph Hellwig6c5e51d2008-10-12 14:30:44 +02001266 break;
Christoph Hellwig6efdf282008-09-17 16:49:33 +10001267#endif
Christoph Hellwig48b62a12008-05-20 11:30:39 +10001268 }
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001269 }
1270
Christoph Hellwig7884bc82009-01-19 02:04:07 +01001271 /* ro -> rw */
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001272 if ((mp->m_flags & XFS_MOUNT_RDONLY) && !(*flags & MS_RDONLY)) {
Eric Sandeenbbe051c2015-04-13 11:25:41 +10001273 if (mp->m_flags & XFS_MOUNT_NORECOVERY) {
1274 xfs_warn(mp,
1275 "ro->rw transition prohibited on norecovery mount");
1276 return -EINVAL;
1277 }
1278
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001279 mp->m_flags &= ~XFS_MOUNT_RDONLY;
Christoph Hellwig7884bc82009-01-19 02:04:07 +01001280
1281 /*
1282 * If this is the first remount to writeable state we
1283 * might have some superblock changes to update.
1284 */
Dave Chinner61e63ec2015-01-22 09:10:31 +11001285 if (mp->m_update_sb) {
1286 error = xfs_sync_sb(mp, false);
Christoph Hellwig7884bc82009-01-19 02:04:07 +01001287 if (error) {
Dave Chinner4f107002011-03-07 10:00:35 +11001288 xfs_warn(mp, "failed to write sb changes");
Christoph Hellwig7884bc82009-01-19 02:04:07 +01001289 return error;
1290 }
Dave Chinner61e63ec2015-01-22 09:10:31 +11001291 mp->m_update_sb = false;
Christoph Hellwig7884bc82009-01-19 02:04:07 +01001292 }
Dave Chinnercbe132a2010-01-26 15:08:49 +11001293
1294 /*
1295 * Fill out the reserve pool if it is empty. Use the stashed
1296 * value if it is non-zero, otherwise go with the default.
1297 */
Eric Sandeend5db0f92010-02-05 22:59:53 +00001298 xfs_restore_resvblks(mp);
Dave Chinnerf661f1e2012-10-08 21:56:02 +11001299 xfs_log_work_queue(mp);
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001300 }
1301
1302 /* rw -> ro */
1303 if (!(mp->m_flags & XFS_MOUNT_RDONLY) && (*flags & MS_RDONLY)) {
Dave Chinnercbe132a2010-01-26 15:08:49 +11001304 /*
Dave Chinner34061f52012-10-08 21:56:06 +11001305 * Before we sync the metadata, we need to free up the reserve
1306 * block pool so that the used block count in the superblock on
1307 * disk is correct at the end of the remount. Stash the current
1308 * reserve pool size so that if we get remounted rw, we can
1309 * return it to the same size.
Dave Chinnercbe132a2010-01-26 15:08:49 +11001310 */
Eric Sandeend5db0f92010-02-05 22:59:53 +00001311 xfs_save_resvblks(mp);
David Chinner76bf1052008-10-30 17:16:21 +11001312 xfs_quiesce_attr(mp);
Christoph Hellwig48b62a12008-05-20 11:30:39 +10001313 mp->m_flags |= XFS_MOUNT_RDONLY;
1314 }
1315
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001316 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317}
1318
Christoph Hellwig9909c4a2007-10-11 18:11:14 +10001319/*
1320 * Second stage of a freeze. The data is already frozen so we only
Dave Chinner61e63ec2015-01-22 09:10:31 +11001321 * need to take care of the metadata. Once that's done sync the superblock
1322 * to the log to dirty it in case of a crash while frozen. This ensures that we
1323 * will recover the unlinked inode lists on the next mount.
Christoph Hellwig9909c4a2007-10-11 18:11:14 +10001324 */
Takashi Satoc4be0c12009-01-09 16:40:58 -08001325STATIC int
1326xfs_fs_freeze(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327 struct super_block *sb)
1328{
Christoph Hellwig9909c4a2007-10-11 18:11:14 +10001329 struct xfs_mount *mp = XFS_M(sb);
1330
Eric Sandeend5db0f92010-02-05 22:59:53 +00001331 xfs_save_resvblks(mp);
David Chinner76bf1052008-10-30 17:16:21 +11001332 xfs_quiesce_attr(mp);
Dave Chinner61e63ec2015-01-22 09:10:31 +11001333 return xfs_sync_sb(mp, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334}
1335
1336STATIC int
Eric Sandeend5db0f92010-02-05 22:59:53 +00001337xfs_fs_unfreeze(
1338 struct super_block *sb)
1339{
1340 struct xfs_mount *mp = XFS_M(sb);
1341
1342 xfs_restore_resvblks(mp);
Dave Chinnerf661f1e2012-10-08 21:56:02 +11001343 xfs_log_work_queue(mp);
Eric Sandeend5db0f92010-02-05 22:59:53 +00001344 return 0;
1345}
1346
1347STATIC int
Nathan Scotta50cd262006-03-14 14:06:18 +11001348xfs_fs_show_options(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001349 struct seq_file *m,
Al Viro34c80b12011-12-08 21:32:45 -05001350 struct dentry *root)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351{
Dave Chinner24513372014-06-25 14:58:08 +10001352 return xfs_showargs(XFS_M(root->d_sb), m);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353}
1354
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001355/*
1356 * This function fills in xfs_mount_t fields based on mount args.
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001357 * Note: the superblock _has_ now been read in.
1358 */
1359STATIC int
1360xfs_finish_flags(
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001361 struct xfs_mount *mp)
1362{
1363 int ronly = (mp->m_flags & XFS_MOUNT_RDONLY);
1364
Frederik Schwarzer025dfda2008-10-16 19:02:37 +02001365 /* Fail a mount where the logbuf is smaller than the log stripe */
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001366 if (xfs_sb_version_haslogv2(&mp->m_sb)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001367 if (mp->m_logbsize <= 0 &&
1368 mp->m_sb.sb_logsunit > XLOG_BIG_RECORD_BSIZE) {
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001369 mp->m_logbsize = mp->m_sb.sb_logsunit;
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001370 } else if (mp->m_logbsize > 0 &&
1371 mp->m_logbsize < mp->m_sb.sb_logsunit) {
Dave Chinner4f107002011-03-07 10:00:35 +11001372 xfs_warn(mp,
1373 "logbuf size must be greater than or equal to log stripe size");
Dave Chinner24513372014-06-25 14:58:08 +10001374 return -EINVAL;
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001375 }
1376 } else {
1377 /* Fail a mount if the logbuf is larger than 32K */
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001378 if (mp->m_logbsize > XLOG_BIG_RECORD_BSIZE) {
Dave Chinner4f107002011-03-07 10:00:35 +11001379 xfs_warn(mp,
1380 "logbuf size for version 1 logs must be 16K or 32K");
Dave Chinner24513372014-06-25 14:58:08 +10001381 return -EINVAL;
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001382 }
1383 }
1384
1385 /*
Dave Chinnerd3eaace2013-06-05 12:09:09 +10001386 * V5 filesystems always use attr2 format for attributes.
1387 */
1388 if (xfs_sb_version_hascrc(&mp->m_sb) &&
1389 (mp->m_flags & XFS_MOUNT_NOATTR2)) {
Eric Sandeen2e74af02016-03-02 09:55:38 +11001390 xfs_warn(mp, "Cannot mount a V5 filesystem as noattr2. "
1391 "attr2 is always enabled for V5 filesystems.");
Dave Chinner24513372014-06-25 14:58:08 +10001392 return -EINVAL;
Dave Chinnerd3eaace2013-06-05 12:09:09 +10001393 }
1394
1395 /*
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001396 * mkfs'ed attr2 will turn on attr2 mount unless explicitly
1397 * told by noattr2 to turn it off
1398 */
1399 if (xfs_sb_version_hasattr2(&mp->m_sb) &&
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001400 !(mp->m_flags & XFS_MOUNT_NOATTR2))
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001401 mp->m_flags |= XFS_MOUNT_ATTR2;
1402
1403 /*
1404 * prohibit r/w mounts of read-only filesystems
1405 */
1406 if ((mp->m_sb.sb_flags & XFS_SBF_READONLY) && !ronly) {
Dave Chinner4f107002011-03-07 10:00:35 +11001407 xfs_warn(mp,
1408 "cannot mount a read-only filesystem as read-write");
Dave Chinner24513372014-06-25 14:58:08 +10001409 return -EROFS;
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001410 }
1411
Chandra Seetharamand892d582013-07-19 17:36:02 -05001412 if ((mp->m_qflags & (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE)) &&
1413 (mp->m_qflags & (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE)) &&
1414 !xfs_sb_version_has_pquotino(&mp->m_sb)) {
1415 xfs_warn(mp,
1416 "Super block does not support project and group quota together");
Dave Chinner24513372014-06-25 14:58:08 +10001417 return -EINVAL;
Chandra Seetharamand892d582013-07-19 17:36:02 -05001418 }
1419
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001420 return 0;
1421}
1422
Dave Chinner5681ca42015-02-23 21:22:31 +11001423static int
1424xfs_init_percpu_counters(
1425 struct xfs_mount *mp)
1426{
1427 int error;
1428
1429 error = percpu_counter_init(&mp->m_icount, 0, GFP_KERNEL);
1430 if (error)
Joe Perches5e9383f2015-03-25 15:00:24 +11001431 return -ENOMEM;
Dave Chinner5681ca42015-02-23 21:22:31 +11001432
1433 error = percpu_counter_init(&mp->m_ifree, 0, GFP_KERNEL);
1434 if (error)
1435 goto free_icount;
1436
1437 error = percpu_counter_init(&mp->m_fdblocks, 0, GFP_KERNEL);
1438 if (error)
1439 goto free_ifree;
1440
1441 return 0;
1442
1443free_ifree:
1444 percpu_counter_destroy(&mp->m_ifree);
1445free_icount:
1446 percpu_counter_destroy(&mp->m_icount);
1447 return -ENOMEM;
1448}
1449
1450void
1451xfs_reinit_percpu_counters(
1452 struct xfs_mount *mp)
1453{
1454 percpu_counter_set(&mp->m_icount, mp->m_sb.sb_icount);
1455 percpu_counter_set(&mp->m_ifree, mp->m_sb.sb_ifree);
1456 percpu_counter_set(&mp->m_fdblocks, mp->m_sb.sb_fdblocks);
1457}
1458
1459static void
1460xfs_destroy_percpu_counters(
1461 struct xfs_mount *mp)
1462{
1463 percpu_counter_destroy(&mp->m_icount);
1464 percpu_counter_destroy(&mp->m_ifree);
1465 percpu_counter_destroy(&mp->m_fdblocks);
1466}
1467
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468STATIC int
Nathan Scotta50cd262006-03-14 14:06:18 +11001469xfs_fs_fill_super(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470 struct super_block *sb,
1471 void *data,
1472 int silent)
1473{
Christoph Hellwigf3dcc132008-03-27 18:00:54 +11001474 struct inode *root;
Christoph Hellwig745f6912007-08-30 17:20:39 +10001475 struct xfs_mount *mp = NULL;
Dave Chinner24513372014-06-25 14:58:08 +10001476 int flags = 0, error = -ENOMEM;
Christoph Hellwigbdd907b2008-05-20 15:10:44 +10001477
Christoph Hellwigc962fb72008-05-20 15:10:52 +10001478 mp = kzalloc(sizeof(struct xfs_mount), GFP_KERNEL);
1479 if (!mp)
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001480 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481
Christoph Hellwigc962fb72008-05-20 15:10:52 +10001482 spin_lock_init(&mp->m_sb_lock);
Christoph Hellwigc962fb72008-05-20 15:10:52 +10001483 mutex_init(&mp->m_growlock);
1484 atomic_set(&mp->m_active_trans, 0);
Dave Chinner7e185302012-10-08 21:56:00 +11001485 INIT_DELAYED_WORK(&mp->m_reclaim_work, xfs_reclaim_worker);
Brian Foster579b62f2012-11-06 09:50:47 -05001486 INIT_DELAYED_WORK(&mp->m_eofblocks_work, xfs_eofblocks_worker);
Dave Chinnere3aed1a2014-09-29 10:46:08 +10001487 mp->m_kobj.kobject.kset = xfs_kset;
Christoph Hellwig74394492007-08-30 17:21:22 +10001488
Christoph Hellwigb267ce92007-08-30 17:21:30 +10001489 mp->m_super = sb;
1490 sb->s_fs_info = mp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491
Christoph Hellwig288699f2010-06-23 18:11:15 +10001492 error = xfs_parseargs(mp, (char *)data);
Christoph Hellwig745f6912007-08-30 17:20:39 +10001493 if (error)
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001494 goto out_free_fsname;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495
1496 sb_min_blocksize(sb, BBSIZE);
Lachlan McIlroy0ec58512008-06-23 13:23:01 +10001497 sb->s_xattr = xfs_xattr_handlers;
Nathan Scotta50cd262006-03-14 14:06:18 +11001498 sb->s_export_op = &xfs_export_operations;
Christoph Hellwigfcafb712009-02-09 08:47:34 +01001499#ifdef CONFIG_XFS_QUOTA
Nathan Scotta50cd262006-03-14 14:06:18 +11001500 sb->s_qcop = &xfs_quotactl_operations;
Jan Kara17ef4fd2014-09-30 22:35:33 +02001501 sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP | QTYPE_MASK_PRJ;
Christoph Hellwigfcafb712009-02-09 08:47:34 +01001502#endif
Nathan Scotta50cd262006-03-14 14:06:18 +11001503 sb->s_op = &xfs_super_operations;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001505 if (silent)
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001506 flags |= XFS_MFSI_QUIET;
1507
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001508 error = xfs_open_devices(mp);
Christoph Hellwig19f354d2008-05-20 11:31:13 +10001509 if (error)
Christoph Hellwig288699f2010-06-23 18:11:15 +10001510 goto out_free_fsname;
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001511
Dave Chinner24513372014-06-25 14:58:08 +10001512 error = xfs_init_mount_workqueues(mp);
Christoph Hellwig61ba35d2010-09-30 02:25:54 +00001513 if (error)
1514 goto out_close_devices;
Christoph Hellwigc962fb72008-05-20 15:10:52 +10001515
Dave Chinner5681ca42015-02-23 21:22:31 +11001516 error = xfs_init_percpu_counters(mp);
Christoph Hellwigaa6bf012012-02-29 09:53:48 +00001517 if (error)
1518 goto out_destroy_workqueues;
1519
Bill O'Donnell225e4632015-10-12 18:21:19 +11001520 /* Allocate stats memory before we do operations that might use it */
1521 mp->m_stats.xs_stats = alloc_percpu(struct xfsstats);
1522 if (!mp->m_stats.xs_stats) {
Dan Carpenterf9d460b2015-10-19 08:42:47 +11001523 error = -ENOMEM;
Bill O'Donnell225e4632015-10-12 18:21:19 +11001524 goto out_destroy_counters;
1525 }
1526
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001527 error = xfs_readsb(mp, flags);
1528 if (error)
Bill O'Donnell225e4632015-10-12 18:21:19 +11001529 goto out_free_stats;
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001530
1531 error = xfs_finish_flags(mp);
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001532 if (error)
Christoph Hellwigeffa2ed2008-05-20 15:11:05 +10001533 goto out_free_sb;
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001534
Christoph Hellwige34b5622008-05-20 15:10:36 +10001535 error = xfs_setup_devices(mp);
Christoph Hellwig19f354d2008-05-20 11:31:13 +10001536 if (error)
Christoph Hellwigeffa2ed2008-05-20 15:11:05 +10001537 goto out_free_sb;
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001538
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001539 error = xfs_filestream_mount(mp);
1540 if (error)
Christoph Hellwigeffa2ed2008-05-20 15:11:05 +10001541 goto out_free_sb;
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001542
Dave Chinner704b2902011-03-26 09:14:57 +11001543 /*
1544 * we must configure the block size in the superblock before we run the
1545 * full mount process as the mount process can lookup and cache inodes.
Dave Chinner704b2902011-03-26 09:14:57 +11001546 */
Christoph Hellwig4ca488e2007-10-11 18:09:40 +10001547 sb->s_magic = XFS_SB_MAGIC;
1548 sb->s_blocksize = mp->m_sb.sb_blocksize;
1549 sb->s_blocksize_bits = ffs(sb->s_blocksize) - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001550 sb->s_maxbytes = xfs_max_file_offset(sb->s_blocksize_bits);
Al Viro8de52772012-02-06 12:45:27 -05001551 sb->s_max_links = XFS_MAXLINK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552 sb->s_time_gran = 1;
1553 set_posix_acl_flag(sb);
1554
Dave Chinnerdc037ad2013-06-27 16:04:59 +10001555 /* version 5 superblocks support inode version counters. */
1556 if (XFS_SB_VERSION_NUM(&mp->m_sb) == XFS_SB_VERSION_5)
1557 sb->s_flags |= MS_I_VERSION;
1558
Dave Chinnercbe4dab2015-06-04 09:19:18 +10001559 if (mp->m_flags & XFS_MOUNT_DAX) {
1560 xfs_warn(mp,
1561 "DAX enabled. Warning: EXPERIMENTAL, use at your own risk");
1562 if (sb->s_blocksize != PAGE_SIZE) {
1563 xfs_alert(mp,
1564 "Filesystem block size invalid for DAX Turning DAX off.");
1565 mp->m_flags &= ~XFS_MOUNT_DAX;
1566 } else if (!sb->s_bdev->bd_disk->fops->direct_access) {
1567 xfs_alert(mp,
1568 "Block device does not support DAX Turning DAX off.");
1569 mp->m_flags &= ~XFS_MOUNT_DAX;
1570 }
1571 }
1572
Brian Foster1b867d32015-08-19 10:32:14 +10001573 if (xfs_sb_version_hassparseinodes(&mp->m_sb))
1574 xfs_alert(mp,
1575 "EXPERIMENTAL sparse inode feature enabled. Use at your own risk!");
1576
Dave Chinner8a00ebe2012-04-13 12:10:44 +00001577 error = xfs_mountfs(mp);
Christoph Hellwig2bcf6e92011-07-13 13:43:48 +02001578 if (error)
Dave Chinner7e185302012-10-08 21:56:00 +11001579 goto out_filestream_unmount;
Dave Chinner704b2902011-03-26 09:14:57 +11001580
David Chinner01651642008-08-13 15:45:15 +10001581 root = igrab(VFS_I(mp->m_rootip));
Christoph Hellwigf3dcc132008-03-27 18:00:54 +11001582 if (!root) {
Dave Chinner24513372014-06-25 14:58:08 +10001583 error = -ENOENT;
Dave Chinner8a00ebe2012-04-13 12:10:44 +00001584 goto out_unmount;
Christoph Hellwigcbc89dc2008-02-05 12:14:01 +11001585 }
Al Viro48fde702012-01-08 22:15:13 -05001586 sb->s_root = d_make_root(root);
Christoph Hellwigf3dcc132008-03-27 18:00:54 +11001587 if (!sb->s_root) {
Dave Chinner24513372014-06-25 14:58:08 +10001588 error = -ENOMEM;
Dave Chinner8a00ebe2012-04-13 12:10:44 +00001589 goto out_unmount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590 }
Christoph Hellwig74394492007-08-30 17:21:22 +10001591
Dave Chinner7e185302012-10-08 21:56:00 +11001592 return 0;
1593
1594 out_filestream_unmount:
Christoph Hellwig120226c2008-05-20 15:11:11 +10001595 xfs_filestream_unmount(mp);
Christoph Hellwigeffa2ed2008-05-20 15:11:05 +10001596 out_free_sb:
1597 xfs_freesb(mp);
Bill O'Donnell225e4632015-10-12 18:21:19 +11001598 out_free_stats:
1599 free_percpu(mp->m_stats.xs_stats);
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001600 out_destroy_counters:
Dave Chinner5681ca42015-02-23 21:22:31 +11001601 xfs_destroy_percpu_counters(mp);
Bill O'Donnell225e4632015-10-12 18:21:19 +11001602 out_destroy_workqueues:
Christoph Hellwigaa6bf012012-02-29 09:53:48 +00001603 xfs_destroy_mount_workqueues(mp);
Christoph Hellwig61ba35d2010-09-30 02:25:54 +00001604 out_close_devices:
Christoph Hellwig19f354d2008-05-20 11:31:13 +10001605 xfs_close_devices(mp);
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001606 out_free_fsname:
1607 xfs_free_fsname(mp);
Christoph Hellwigc962fb72008-05-20 15:10:52 +10001608 kfree(mp);
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001609 out:
Dave Chinner24513372014-06-25 14:58:08 +10001610 return error;
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001611
Christoph Hellwig2bcf6e92011-07-13 13:43:48 +02001612 out_unmount:
Christoph Hellwige48ad312008-05-20 11:30:52 +10001613 xfs_filestream_unmount(mp);
Christoph Hellwig19f354d2008-05-20 11:31:13 +10001614 xfs_unmountfs(mp);
Christoph Hellwig62033002008-08-13 16:50:21 +10001615 goto out_free_sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616}
1617
Dave Chinner5681ca42015-02-23 21:22:31 +11001618STATIC void
1619xfs_fs_put_super(
1620 struct super_block *sb)
1621{
1622 struct xfs_mount *mp = XFS_M(sb);
1623
Dave Chinner42254412015-02-24 10:27:28 +11001624 xfs_notice(mp, "Unmounting Filesystem");
Dave Chinner5681ca42015-02-23 21:22:31 +11001625 xfs_filestream_unmount(mp);
1626 xfs_unmountfs(mp);
1627
1628 xfs_freesb(mp);
Bill O'Donnell225e4632015-10-12 18:21:19 +11001629 free_percpu(mp->m_stats.xs_stats);
Dave Chinner5681ca42015-02-23 21:22:31 +11001630 xfs_destroy_percpu_counters(mp);
1631 xfs_destroy_mount_workqueues(mp);
1632 xfs_close_devices(mp);
1633 xfs_free_fsname(mp);
1634 kfree(mp);
1635}
1636
Al Viro152a0832010-07-25 00:46:55 +04001637STATIC struct dentry *
1638xfs_fs_mount(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639 struct file_system_type *fs_type,
1640 int flags,
1641 const char *dev_name,
Al Viro152a0832010-07-25 00:46:55 +04001642 void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643{
Al Viro152a0832010-07-25 00:46:55 +04001644 return mount_bdev(fs_type, flags, dev_name, data, xfs_fs_fill_super);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645}
1646
Dave Chinner0a234c62013-08-28 10:17:57 +10001647static long
Dave Chinner8daaa832011-07-08 14:14:46 +10001648xfs_fs_nr_cached_objects(
Dave Chinner9b17c622013-08-28 10:18:05 +10001649 struct super_block *sb,
Vladimir Davydov4101b622015-02-12 14:58:51 -08001650 struct shrink_control *sc)
Dave Chinner8daaa832011-07-08 14:14:46 +10001651{
1652 return xfs_reclaim_inodes_count(XFS_M(sb));
1653}
1654
Dave Chinner0a234c62013-08-28 10:17:57 +10001655static long
Dave Chinner8daaa832011-07-08 14:14:46 +10001656xfs_fs_free_cached_objects(
1657 struct super_block *sb,
Vladimir Davydov4101b622015-02-12 14:58:51 -08001658 struct shrink_control *sc)
Dave Chinner8daaa832011-07-08 14:14:46 +10001659{
Vladimir Davydov4101b622015-02-12 14:58:51 -08001660 return xfs_reclaim_inodes_nr(XFS_M(sb), sc->nr_to_scan);
Dave Chinner8daaa832011-07-08 14:14:46 +10001661}
1662
Alexey Dobriyanb87221d2009-09-21 17:01:09 -07001663static const struct super_operations xfs_super_operations = {
Nathan Scotta50cd262006-03-14 14:06:18 +11001664 .alloc_inode = xfs_fs_alloc_inode,
1665 .destroy_inode = xfs_fs_destroy_inode,
Al Virob57922d2010-06-07 14:34:48 -04001666 .evict_inode = xfs_fs_evict_inode,
Dave Chinner5132ba82012-03-22 05:15:10 +00001667 .drop_inode = xfs_fs_drop_inode,
Nathan Scotta50cd262006-03-14 14:06:18 +11001668 .put_super = xfs_fs_put_super,
Christoph Hellwig69961a22009-10-06 20:29:28 +00001669 .sync_fs = xfs_fs_sync_fs,
Takashi Satoc4be0c12009-01-09 16:40:58 -08001670 .freeze_fs = xfs_fs_freeze,
Eric Sandeend5db0f92010-02-05 22:59:53 +00001671 .unfreeze_fs = xfs_fs_unfreeze,
Nathan Scotta50cd262006-03-14 14:06:18 +11001672 .statfs = xfs_fs_statfs,
1673 .remount_fs = xfs_fs_remount,
1674 .show_options = xfs_fs_show_options,
Dave Chinner8daaa832011-07-08 14:14:46 +10001675 .nr_cached_objects = xfs_fs_nr_cached_objects,
1676 .free_cached_objects = xfs_fs_free_cached_objects,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677};
1678
Andrew Morton5085b602007-02-20 13:57:47 -08001679static struct file_system_type xfs_fs_type = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 .owner = THIS_MODULE,
1681 .name = "xfs",
Al Viro152a0832010-07-25 00:46:55 +04001682 .mount = xfs_fs_mount,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 .kill_sb = kill_block_super,
1684 .fs_flags = FS_REQUIRES_DEV,
1685};
Eric W. Biederman7f78e032013-03-02 19:39:14 -08001686MODULE_ALIAS_FS("xfs");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001687
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001688STATIC int __init
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001689xfs_init_zones(void)
1690{
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001691
1692 xfs_ioend_zone = kmem_zone_init(sizeof(xfs_ioend_t), "xfs_ioend");
1693 if (!xfs_ioend_zone)
David Chinnerbf904242008-10-30 17:36:14 +11001694 goto out;
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001695
1696 xfs_ioend_pool = mempool_create_slab_pool(4 * MAX_BUF_PER_PAGE,
1697 xfs_ioend_zone);
1698 if (!xfs_ioend_pool)
1699 goto out_destroy_ioend_zone;
1700
1701 xfs_log_ticket_zone = kmem_zone_init(sizeof(xlog_ticket_t),
1702 "xfs_log_ticket");
1703 if (!xfs_log_ticket_zone)
1704 goto out_destroy_ioend_pool;
1705
1706 xfs_bmap_free_item_zone = kmem_zone_init(sizeof(xfs_bmap_free_item_t),
1707 "xfs_bmap_free_item");
1708 if (!xfs_bmap_free_item_zone)
1709 goto out_destroy_log_ticket_zone;
David Chinnerbf904242008-10-30 17:36:14 +11001710
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001711 xfs_btree_cur_zone = kmem_zone_init(sizeof(xfs_btree_cur_t),
1712 "xfs_btree_cur");
1713 if (!xfs_btree_cur_zone)
1714 goto out_destroy_bmap_free_item_zone;
1715
1716 xfs_da_state_zone = kmem_zone_init(sizeof(xfs_da_state_t),
1717 "xfs_da_state");
1718 if (!xfs_da_state_zone)
1719 goto out_destroy_btree_cur_zone;
1720
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001721 xfs_ifork_zone = kmem_zone_init(sizeof(xfs_ifork_t), "xfs_ifork");
1722 if (!xfs_ifork_zone)
Dave Chinner1d9025e2012-06-22 18:50:14 +10001723 goto out_destroy_da_state_zone;
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001724
1725 xfs_trans_zone = kmem_zone_init(sizeof(xfs_trans_t), "xfs_trans");
1726 if (!xfs_trans_zone)
1727 goto out_destroy_ifork_zone;
1728
Christoph Hellwige98c4142010-06-23 18:11:15 +10001729 xfs_log_item_desc_zone =
1730 kmem_zone_init(sizeof(struct xfs_log_item_desc),
1731 "xfs_log_item_desc");
1732 if (!xfs_log_item_desc_zone)
1733 goto out_destroy_trans_zone;
1734
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001735 /*
1736 * The size of the zone allocated buf log item is the maximum
1737 * size possible under XFS. This wastes a little bit of memory,
1738 * but it is much faster.
1739 */
Dave Chinner77c1a082012-06-22 18:50:07 +10001740 xfs_buf_item_zone = kmem_zone_init(sizeof(struct xfs_buf_log_item),
1741 "xfs_buf_item");
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001742 if (!xfs_buf_item_zone)
Christoph Hellwige98c4142010-06-23 18:11:15 +10001743 goto out_destroy_log_item_desc_zone;
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001744
1745 xfs_efd_zone = kmem_zone_init((sizeof(xfs_efd_log_item_t) +
1746 ((XFS_EFD_MAX_FAST_EXTENTS - 1) *
1747 sizeof(xfs_extent_t))), "xfs_efd_item");
1748 if (!xfs_efd_zone)
1749 goto out_destroy_buf_item_zone;
1750
1751 xfs_efi_zone = kmem_zone_init((sizeof(xfs_efi_log_item_t) +
1752 ((XFS_EFI_MAX_FAST_EXTENTS - 1) *
1753 sizeof(xfs_extent_t))), "xfs_efi_item");
1754 if (!xfs_efi_zone)
1755 goto out_destroy_efd_zone;
1756
1757 xfs_inode_zone =
1758 kmem_zone_init_flags(sizeof(xfs_inode_t), "xfs_inode",
Vladimir Davydov5d097052016-01-14 15:18:21 -08001759 KM_ZONE_HWALIGN | KM_ZONE_RECLAIM | KM_ZONE_SPREAD |
1760 KM_ZONE_ACCOUNT, xfs_fs_inode_init_once);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001761 if (!xfs_inode_zone)
1762 goto out_destroy_efi_zone;
1763
1764 xfs_ili_zone =
1765 kmem_zone_init_flags(sizeof(xfs_inode_log_item_t), "xfs_ili",
1766 KM_ZONE_SPREAD, NULL);
1767 if (!xfs_ili_zone)
1768 goto out_destroy_inode_zone;
Dave Chinner3ebe7d22013-06-27 16:04:53 +10001769 xfs_icreate_zone = kmem_zone_init(sizeof(struct xfs_icreate_item),
1770 "xfs_icr");
1771 if (!xfs_icreate_zone)
1772 goto out_destroy_ili_zone;
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001773
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001774 return 0;
1775
Dave Chinner3ebe7d22013-06-27 16:04:53 +10001776 out_destroy_ili_zone:
1777 kmem_zone_destroy(xfs_ili_zone);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001778 out_destroy_inode_zone:
1779 kmem_zone_destroy(xfs_inode_zone);
1780 out_destroy_efi_zone:
1781 kmem_zone_destroy(xfs_efi_zone);
1782 out_destroy_efd_zone:
1783 kmem_zone_destroy(xfs_efd_zone);
1784 out_destroy_buf_item_zone:
1785 kmem_zone_destroy(xfs_buf_item_zone);
Christoph Hellwige98c4142010-06-23 18:11:15 +10001786 out_destroy_log_item_desc_zone:
1787 kmem_zone_destroy(xfs_log_item_desc_zone);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001788 out_destroy_trans_zone:
1789 kmem_zone_destroy(xfs_trans_zone);
1790 out_destroy_ifork_zone:
1791 kmem_zone_destroy(xfs_ifork_zone);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001792 out_destroy_da_state_zone:
1793 kmem_zone_destroy(xfs_da_state_zone);
1794 out_destroy_btree_cur_zone:
1795 kmem_zone_destroy(xfs_btree_cur_zone);
1796 out_destroy_bmap_free_item_zone:
1797 kmem_zone_destroy(xfs_bmap_free_item_zone);
1798 out_destroy_log_ticket_zone:
1799 kmem_zone_destroy(xfs_log_ticket_zone);
1800 out_destroy_ioend_pool:
1801 mempool_destroy(xfs_ioend_pool);
1802 out_destroy_ioend_zone:
1803 kmem_zone_destroy(xfs_ioend_zone);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001804 out:
1805 return -ENOMEM;
1806}
1807
1808STATIC void
1809xfs_destroy_zones(void)
1810{
Kirill A. Shutemov8c0a8532012-09-26 11:33:07 +10001811 /*
1812 * Make sure all delayed rcu free are flushed before we
1813 * destroy caches.
1814 */
1815 rcu_barrier();
Dave Chinner3ebe7d22013-06-27 16:04:53 +10001816 kmem_zone_destroy(xfs_icreate_zone);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001817 kmem_zone_destroy(xfs_ili_zone);
1818 kmem_zone_destroy(xfs_inode_zone);
1819 kmem_zone_destroy(xfs_efi_zone);
1820 kmem_zone_destroy(xfs_efd_zone);
1821 kmem_zone_destroy(xfs_buf_item_zone);
Christoph Hellwige98c4142010-06-23 18:11:15 +10001822 kmem_zone_destroy(xfs_log_item_desc_zone);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001823 kmem_zone_destroy(xfs_trans_zone);
1824 kmem_zone_destroy(xfs_ifork_zone);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001825 kmem_zone_destroy(xfs_da_state_zone);
1826 kmem_zone_destroy(xfs_btree_cur_zone);
1827 kmem_zone_destroy(xfs_bmap_free_item_zone);
1828 kmem_zone_destroy(xfs_log_ticket_zone);
1829 mempool_destroy(xfs_ioend_pool);
1830 kmem_zone_destroy(xfs_ioend_zone);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001831
1832}
1833
1834STATIC int __init
Dave Chinner0bf6a5b2011-04-08 12:45:07 +10001835xfs_init_workqueues(void)
1836{
1837 /*
Dave Chinnerc999a222012-03-22 05:15:07 +00001838 * The allocation workqueue can be used in memory reclaim situations
1839 * (writepage path), and parallelism is only limited by the number of
1840 * AGs in all the filesystems mounted. Hence use the default large
1841 * max_active value for this workqueue.
1842 */
Brian Foster8018ec02014-09-09 11:44:46 +10001843 xfs_alloc_wq = alloc_workqueue("xfsalloc",
1844 WQ_MEM_RECLAIM|WQ_FREEZABLE, 0);
Dave Chinnerc999a222012-03-22 05:15:07 +00001845 if (!xfs_alloc_wq)
Dave Chinner58896082012-10-08 21:56:05 +11001846 return -ENOMEM;
Dave Chinnerc999a222012-03-22 05:15:07 +00001847
Dave Chinner0bf6a5b2011-04-08 12:45:07 +10001848 return 0;
Dave Chinner0bf6a5b2011-04-08 12:45:07 +10001849}
1850
Luck, Tony39411f82011-04-11 12:06:12 -07001851STATIC void
Dave Chinner0bf6a5b2011-04-08 12:45:07 +10001852xfs_destroy_workqueues(void)
1853{
Dave Chinnerc999a222012-03-22 05:15:07 +00001854 destroy_workqueue(xfs_alloc_wq);
Dave Chinner0bf6a5b2011-04-08 12:45:07 +10001855}
1856
1857STATIC int __init
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001858init_xfs_fs(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859{
1860 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861
Darrick J. Wong30cbc592016-03-09 08:15:14 +11001862 xfs_check_ondisk_structs();
1863
Christoph Hellwig65795912008-11-28 14:23:33 +11001864 printk(KERN_INFO XFS_VERSION_STRING " with "
1865 XFS_BUILD_OPTIONS " enabled\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001867 xfs_dir_startup();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001868
Nathan Scott87582802006-03-14 13:18:19 +11001869 error = xfs_init_zones();
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001870 if (error)
1871 goto out;
1872
Dave Chinner0bf6a5b2011-04-08 12:45:07 +10001873 error = xfs_init_workqueues();
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001874 if (error)
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001875 goto out_destroy_zones;
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001876
Dave Chinner0bf6a5b2011-04-08 12:45:07 +10001877 error = xfs_mru_cache_init();
1878 if (error)
1879 goto out_destroy_wq;
1880
Nathan Scottce8e9222006-01-11 15:39:08 +11001881 error = xfs_buf_init();
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001882 if (error)
Christoph Hellwig1919add2014-04-23 07:11:51 +10001883 goto out_mru_cache_uninit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001885 error = xfs_init_procfs();
1886 if (error)
1887 goto out_buf_terminate;
1888
1889 error = xfs_sysctl_register();
1890 if (error)
1891 goto out_cleanup_procfs;
1892
Brian Foster3d871222014-07-15 07:41:37 +10001893 xfs_kset = kset_create_and_add("xfs", NULL, fs_kobj);
1894 if (!xfs_kset) {
1895 error = -ENOMEM;
Bill O'Donnellbb230c12015-10-12 05:15:45 +11001896 goto out_sysctl_unregister;
Brian Foster3d871222014-07-15 07:41:37 +10001897 }
1898
Bill O'Donnell80529c42015-10-12 05:19:45 +11001899 xfsstats.xs_kobj.kobject.kset = xfs_kset;
1900
1901 xfsstats.xs_stats = alloc_percpu(struct xfsstats);
1902 if (!xfsstats.xs_stats) {
1903 error = -ENOMEM;
1904 goto out_kset_unregister;
1905 }
1906
1907 error = xfs_sysfs_init(&xfsstats.xs_kobj, &xfs_stats_ktype, NULL,
Bill O'Donnellbb230c12015-10-12 05:15:45 +11001908 "stats");
1909 if (error)
Bill O'Donnell80529c42015-10-12 05:19:45 +11001910 goto out_free_stats;
Bill O'Donnellbb230c12015-10-12 05:15:45 +11001911
Brian Foster65b65732014-09-09 11:52:42 +10001912#ifdef DEBUG
1913 xfs_dbg_kobj.kobject.kset = xfs_kset;
1914 error = xfs_sysfs_init(&xfs_dbg_kobj, &xfs_dbg_ktype, NULL, "debug");
Christoph Hellwiga05931c2012-03-13 08:52:37 +00001915 if (error)
Bill O'Donnellbb230c12015-10-12 05:15:45 +11001916 goto out_remove_stats_kobj;
Brian Foster65b65732014-09-09 11:52:42 +10001917#endif
1918
1919 error = xfs_qm_init();
1920 if (error)
Bill O'Donnellbb230c12015-10-12 05:15:45 +11001921 goto out_remove_dbg_kobj;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922
1923 error = register_filesystem(&xfs_fs_type);
1924 if (error)
Christoph Hellwiga05931c2012-03-13 08:52:37 +00001925 goto out_qm_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 return 0;
1927
Christoph Hellwiga05931c2012-03-13 08:52:37 +00001928 out_qm_exit:
1929 xfs_qm_exit();
Bill O'Donnellbb230c12015-10-12 05:15:45 +11001930 out_remove_dbg_kobj:
Brian Foster65b65732014-09-09 11:52:42 +10001931#ifdef DEBUG
1932 xfs_sysfs_del(&xfs_dbg_kobj);
Bill O'Donnellbb230c12015-10-12 05:15:45 +11001933 out_remove_stats_kobj:
Brian Foster65b65732014-09-09 11:52:42 +10001934#endif
Bill O'Donnell80529c42015-10-12 05:19:45 +11001935 xfs_sysfs_del(&xfsstats.xs_kobj);
1936 out_free_stats:
1937 free_percpu(xfsstats.xs_stats);
Bill O'Donnellbb230c12015-10-12 05:15:45 +11001938 out_kset_unregister:
Brian Foster3d871222014-07-15 07:41:37 +10001939 kset_unregister(xfs_kset);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001940 out_sysctl_unregister:
1941 xfs_sysctl_unregister();
1942 out_cleanup_procfs:
1943 xfs_cleanup_procfs();
1944 out_buf_terminate:
Nathan Scottce8e9222006-01-11 15:39:08 +11001945 xfs_buf_terminate();
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001946 out_mru_cache_uninit:
1947 xfs_mru_cache_uninit();
Dave Chinner0bf6a5b2011-04-08 12:45:07 +10001948 out_destroy_wq:
1949 xfs_destroy_workqueues();
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001950 out_destroy_zones:
Nathan Scott87582802006-03-14 13:18:19 +11001951 xfs_destroy_zones();
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001952 out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001953 return error;
1954}
1955
1956STATIC void __exit
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001957exit_xfs_fs(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958{
Christoph Hellwiga05931c2012-03-13 08:52:37 +00001959 xfs_qm_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001960 unregister_filesystem(&xfs_fs_type);
Brian Foster65b65732014-09-09 11:52:42 +10001961#ifdef DEBUG
1962 xfs_sysfs_del(&xfs_dbg_kobj);
1963#endif
Bill O'Donnell80529c42015-10-12 05:19:45 +11001964 xfs_sysfs_del(&xfsstats.xs_kobj);
1965 free_percpu(xfsstats.xs_stats);
Brian Foster3d871222014-07-15 07:41:37 +10001966 kset_unregister(xfs_kset);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001967 xfs_sysctl_unregister();
1968 xfs_cleanup_procfs();
Nathan Scottce8e9222006-01-11 15:39:08 +11001969 xfs_buf_terminate();
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001970 xfs_mru_cache_uninit();
Dave Chinner0bf6a5b2011-04-08 12:45:07 +10001971 xfs_destroy_workqueues();
Nathan Scott87582802006-03-14 13:18:19 +11001972 xfs_destroy_zones();
Darrick J. Wongaf3b6382015-11-03 13:06:34 +11001973 xfs_uuid_table_free();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001974}
1975
1976module_init(init_xfs_fs);
1977module_exit(exit_xfs_fs);
1978
1979MODULE_AUTHOR("Silicon Graphics, Inc.");
1980MODULE_DESCRIPTION(XFS_VERSION_STRING " with " XFS_BUILD_OPTIONS " enabled");
1981MODULE_LICENSE("GPL");