blob: c407121873b4763984f21870723e6e517b03f23c [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"
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include "xfs_log.h"
Nathan Scotta844f452005-11-02 14:38:42 +110021#include "xfs_inum.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include "xfs_trans.h"
23#include "xfs_sb.h"
Nathan Scotta844f452005-11-02 14:38:42 +110024#include "xfs_ag.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include "xfs_dir2.h"
26#include "xfs_alloc.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include "xfs_quota.h"
28#include "xfs_mount.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include "xfs_bmap_btree.h"
Nathan Scotta844f452005-11-02 14:38:42 +110030#include "xfs_alloc_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include "xfs_ialloc_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include "xfs_dinode.h"
33#include "xfs_inode.h"
Nathan Scotta844f452005-11-02 14:38:42 +110034#include "xfs_btree.h"
35#include "xfs_ialloc.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include "xfs_bmap.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include "xfs_rtalloc.h"
38#include "xfs_error.h"
39#include "xfs_itable.h"
Christoph Hellwig9909c4a2007-10-11 18:11:14 +100040#include "xfs_fsops.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include "xfs_attr.h"
42#include "xfs_buf_item.h"
43#include "xfs_utils.h"
Christoph Hellwig739bfb22007-08-29 10:58:01 +100044#include "xfs_vnodeops.h"
David Chinnera67d7c52007-11-23 16:29:32 +110045#include "xfs_log_priv.h"
David Chinner249a8c12008-02-05 12:13:32 +110046#include "xfs_trans_priv.h"
Christoph Hellwig48b62a12008-05-20 11:30:39 +100047#include "xfs_filestream.h"
Christoph Hellwig9f8868f2008-07-18 17:11:46 +100048#include "xfs_da_btree.h"
Christoph Hellwig9f8868f2008-07-18 17:11:46 +100049#include "xfs_extfree_item.h"
50#include "xfs_mru_cache.h"
51#include "xfs_inode_item.h"
Dave Chinner6d8b79c2012-10-08 21:56:09 +110052#include "xfs_icache.h"
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000053#include "xfs_trace.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
55#include <linux/namei.h>
56#include <linux/init.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090057#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070058#include <linux/mount.h>
Christoph Hellwig0829c362005-09-02 16:58:49 +100059#include <linux/mempool.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070060#include <linux/writeback.h>
Christoph Hellwig4df08c52005-09-05 08:34:18 +100061#include <linux/kthread.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080062#include <linux/freezer.h>
Christoph Hellwig62a877e2008-07-18 17:12:36 +100063#include <linux/parser.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070064
Alexey Dobriyanb87221d2009-09-21 17:01:09 -070065static const struct super_operations xfs_super_operations;
David Chinner7989cb82007-02-10 18:34:56 +110066static kmem_zone_t *xfs_ioend_zone;
Christoph Hellwig0829c362005-09-02 16:58:49 +100067mempool_t *xfs_ioend_pool;
Linus Torvalds1da177e2005-04-16 15:20:36 -070068
David Chinnera67d7c52007-11-23 16:29:32 +110069#define MNTOPT_LOGBUFS "logbufs" /* number of XFS log buffers */
70#define MNTOPT_LOGBSIZE "logbsize" /* size of XFS log buffers */
71#define MNTOPT_LOGDEV "logdev" /* log device */
72#define MNTOPT_RTDEV "rtdev" /* realtime I/O device */
73#define MNTOPT_BIOSIZE "biosize" /* log2 of preferred buffered io size */
74#define MNTOPT_WSYNC "wsync" /* safe-mode nfs compatible mount */
David Chinnera67d7c52007-11-23 16:29:32 +110075#define MNTOPT_NOALIGN "noalign" /* turn off stripe alignment */
76#define MNTOPT_SWALLOC "swalloc" /* turn on stripe width allocation */
77#define MNTOPT_SUNIT "sunit" /* data volume stripe unit */
78#define MNTOPT_SWIDTH "swidth" /* data volume stripe width */
79#define MNTOPT_NOUUID "nouuid" /* ignore filesystem UUID */
80#define MNTOPT_MTPT "mtpt" /* filesystem mount point */
81#define MNTOPT_GRPID "grpid" /* group-ID from parent directory */
82#define MNTOPT_NOGRPID "nogrpid" /* group-ID from current process */
83#define MNTOPT_BSDGROUPS "bsdgroups" /* group-ID from parent directory */
84#define MNTOPT_SYSVGROUPS "sysvgroups" /* group-ID from current process */
85#define MNTOPT_ALLOCSIZE "allocsize" /* preferred allocation size */
86#define MNTOPT_NORECOVERY "norecovery" /* don't run XFS recovery */
87#define MNTOPT_BARRIER "barrier" /* use writer barriers for log write and
88 * unwritten extent conversion */
89#define MNTOPT_NOBARRIER "nobarrier" /* .. disable */
David Chinnera67d7c52007-11-23 16:29:32 +110090#define MNTOPT_64BITINODE "inode64" /* inodes can be allocated anywhere */
Carlos Maiolino08bf5402012-09-20 10:32:37 -030091#define MNTOPT_32BITINODE "inode32" /* inode allocation limited to
92 * XFS_MAXINUMBER_32 */
David Chinnera67d7c52007-11-23 16:29:32 +110093#define MNTOPT_IKEEP "ikeep" /* do not free empty inode clusters */
94#define MNTOPT_NOIKEEP "noikeep" /* free empty inode clusters */
95#define MNTOPT_LARGEIO "largeio" /* report large I/O sizes in stat() */
96#define MNTOPT_NOLARGEIO "nolargeio" /* do not report large I/O sizes
97 * in stat(). */
98#define MNTOPT_ATTR2 "attr2" /* do use attr2 attribute format */
99#define MNTOPT_NOATTR2 "noattr2" /* do not use attr2 attribute format */
100#define MNTOPT_FILESTREAM "filestreams" /* use filestreams allocator */
101#define MNTOPT_QUOTA "quota" /* disk quotas (user) */
102#define MNTOPT_NOQUOTA "noquota" /* no quotas */
103#define MNTOPT_USRQUOTA "usrquota" /* user quota enabled */
104#define MNTOPT_GRPQUOTA "grpquota" /* group quota enabled */
105#define MNTOPT_PRJQUOTA "prjquota" /* project quota enabled */
106#define MNTOPT_UQUOTA "uquota" /* user quota (IRIX variant) */
107#define MNTOPT_GQUOTA "gquota" /* group quota (IRIX variant) */
108#define MNTOPT_PQUOTA "pquota" /* project quota (IRIX variant) */
109#define MNTOPT_UQUOTANOENF "uqnoenforce"/* user quota limit enforcement */
110#define MNTOPT_GQUOTANOENF "gqnoenforce"/* group quota limit enforcement */
111#define MNTOPT_PQUOTANOENF "pqnoenforce"/* project quota limit enforcement */
112#define MNTOPT_QUOTANOENF "qnoenforce" /* same as uqnoenforce */
Christoph Hellwige84661a2011-05-20 13:45:32 +0000113#define MNTOPT_DELAYLOG "delaylog" /* Delayed logging enabled */
114#define MNTOPT_NODELAYLOG "nodelaylog" /* Delayed logging disabled */
115#define MNTOPT_DISCARD "discard" /* Discard unused blocks */
116#define MNTOPT_NODISCARD "nodiscard" /* Do not discard unused blocks */
David Chinnera67d7c52007-11-23 16:29:32 +1100117
Christoph Hellwig62a877e2008-07-18 17:12:36 +1000118/*
119 * Table driven mount option parser.
120 *
121 * Currently only used for remount, but it will be used for mount
122 * in the future, too.
123 */
124enum {
Carlos Maiolino2ea03922012-09-20 10:32:41 -0300125 Opt_barrier,
126 Opt_nobarrier,
127 Opt_inode64,
128 Opt_inode32,
129 Opt_err
Christoph Hellwig62a877e2008-07-18 17:12:36 +1000130};
131
Steven Whitehousea447c092008-10-13 10:46:57 +0100132static const match_table_t tokens = {
Christoph Hellwig62a877e2008-07-18 17:12:36 +1000133 {Opt_barrier, "barrier"},
134 {Opt_nobarrier, "nobarrier"},
Carlos Maiolinoc3a58fe2012-08-17 18:19:38 -0300135 {Opt_inode64, "inode64"},
Carlos Maiolino2ea03922012-09-20 10:32:41 -0300136 {Opt_inode32, "inode32"},
Christoph Hellwig62a877e2008-07-18 17:12:36 +1000137 {Opt_err, NULL}
138};
139
140
David Chinnera67d7c52007-11-23 16:29:32 +1100141STATIC unsigned long
Abhijit Pawara17164e2013-01-09 19:34:42 +0530142suffix_kstrtoint(char *s, unsigned int base, int *res)
David Chinnera67d7c52007-11-23 16:29:32 +1100143{
Abhijit Pawara17164e2013-01-09 19:34:42 +0530144 int last, shift_left_factor = 0, _res;
David Chinnera67d7c52007-11-23 16:29:32 +1100145 char *value = s;
146
147 last = strlen(value) - 1;
148 if (value[last] == 'K' || value[last] == 'k') {
149 shift_left_factor = 10;
150 value[last] = '\0';
151 }
152 if (value[last] == 'M' || value[last] == 'm') {
153 shift_left_factor = 20;
154 value[last] = '\0';
155 }
156 if (value[last] == 'G' || value[last] == 'g') {
157 shift_left_factor = 30;
158 value[last] = '\0';
159 }
160
Abhijit Pawara17164e2013-01-09 19:34:42 +0530161 if (kstrtoint(s, base, &_res))
162 return -EINVAL;
163 *res = _res << shift_left_factor;
164 return 0;
David Chinnera67d7c52007-11-23 16:29:32 +1100165}
166
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100167/*
168 * This function fills in xfs_mount_t fields based on mount args.
169 * Note: the superblock has _not_ yet been read in.
170 *
171 * Note that this function leaks the various device name allocations on
172 * failure. The caller takes care of them.
173 */
David Chinnera67d7c52007-11-23 16:29:32 +1100174STATIC int
175xfs_parseargs(
176 struct xfs_mount *mp,
Christoph Hellwig288699f2010-06-23 18:11:15 +1000177 char *options)
David Chinnera67d7c52007-11-23 16:29:32 +1100178{
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100179 struct super_block *sb = mp->m_super;
Abhijit Pawara17164e2013-01-09 19:34:42 +0530180 char *this_char, *value;
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100181 int dsunit = 0;
182 int dswidth = 0;
183 int iosize = 0;
Christoph Hellwiga5687782009-02-09 08:37:39 +0100184 __uint8_t iosizelog = 0;
David Chinnera67d7c52007-11-23 16:29:32 +1100185
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100186 /*
Dave Chinner4f107002011-03-07 10:00:35 +1100187 * set up the mount name first so all the errors will refer to the
188 * correct device.
189 */
190 mp->m_fsname = kstrndup(sb->s_id, MAXNAMELEN, GFP_KERNEL);
191 if (!mp->m_fsname)
192 return ENOMEM;
193 mp->m_fsname_len = strlen(mp->m_fsname) + 1;
194
195 /*
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100196 * Copy binary VFS mount flags we are interested in.
197 */
198 if (sb->s_flags & MS_RDONLY)
199 mp->m_flags |= XFS_MOUNT_RDONLY;
200 if (sb->s_flags & MS_DIRSYNC)
201 mp->m_flags |= XFS_MOUNT_DIRSYNC;
202 if (sb->s_flags & MS_SYNCHRONOUS)
203 mp->m_flags |= XFS_MOUNT_WSYNC;
204
205 /*
206 * Set some default flags that could be cleared by the mount option
207 * parsing.
208 */
209 mp->m_flags |= XFS_MOUNT_BARRIER;
210 mp->m_flags |= XFS_MOUNT_COMPAT_IOSIZE;
Carlos Maiolino08bf5402012-09-20 10:32:37 -0300211#if !XFS_BIG_INUMS
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100212 mp->m_flags |= XFS_MOUNT_SMALL_INUMS;
Carlos Maiolino08bf5402012-09-20 10:32:37 -0300213#endif
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100214
215 /*
216 * These can be overridden by the mount option parsing.
217 */
218 mp->m_logbufs = -1;
219 mp->m_logbsize = -1;
David Chinnera67d7c52007-11-23 16:29:32 +1100220
221 if (!options)
222 goto done;
223
David Chinnera67d7c52007-11-23 16:29:32 +1100224 while ((this_char = strsep(&options, ",")) != NULL) {
225 if (!*this_char)
226 continue;
227 if ((value = strchr(this_char, '=')) != NULL)
228 *value++ = 0;
229
230 if (!strcmp(this_char, MNTOPT_LOGBUFS)) {
231 if (!value || !*value) {
Dave Chinner4f107002011-03-07 10:00:35 +1100232 xfs_warn(mp, "%s option requires an argument",
David Chinnera67d7c52007-11-23 16:29:32 +1100233 this_char);
234 return EINVAL;
235 }
Abhijit Pawara17164e2013-01-09 19:34:42 +0530236 if (kstrtoint(value, 10, &mp->m_logbufs))
237 return EINVAL;
David Chinnera67d7c52007-11-23 16:29:32 +1100238 } else if (!strcmp(this_char, MNTOPT_LOGBSIZE)) {
239 if (!value || !*value) {
Dave Chinner4f107002011-03-07 10:00:35 +1100240 xfs_warn(mp, "%s option requires an argument",
David Chinnera67d7c52007-11-23 16:29:32 +1100241 this_char);
242 return EINVAL;
243 }
Abhijit Pawara17164e2013-01-09 19:34:42 +0530244 if (suffix_kstrtoint(value, 10, &mp->m_logbsize))
245 return EINVAL;
David Chinnera67d7c52007-11-23 16:29:32 +1100246 } else if (!strcmp(this_char, MNTOPT_LOGDEV)) {
247 if (!value || !*value) {
Dave Chinner4f107002011-03-07 10:00:35 +1100248 xfs_warn(mp, "%s option requires an argument",
David Chinnera67d7c52007-11-23 16:29:32 +1100249 this_char);
250 return EINVAL;
251 }
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100252 mp->m_logname = kstrndup(value, MAXNAMELEN, GFP_KERNEL);
253 if (!mp->m_logname)
254 return ENOMEM;
David Chinnera67d7c52007-11-23 16:29:32 +1100255 } else if (!strcmp(this_char, MNTOPT_MTPT)) {
Dave Chinner4f107002011-03-07 10:00:35 +1100256 xfs_warn(mp, "%s option not allowed on this system",
Christoph Hellwig288699f2010-06-23 18:11:15 +1000257 this_char);
258 return EINVAL;
David Chinnera67d7c52007-11-23 16:29:32 +1100259 } else if (!strcmp(this_char, MNTOPT_RTDEV)) {
260 if (!value || !*value) {
Dave Chinner4f107002011-03-07 10:00:35 +1100261 xfs_warn(mp, "%s option requires an argument",
David Chinnera67d7c52007-11-23 16:29:32 +1100262 this_char);
263 return EINVAL;
264 }
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100265 mp->m_rtname = kstrndup(value, MAXNAMELEN, GFP_KERNEL);
266 if (!mp->m_rtname)
267 return ENOMEM;
David Chinnera67d7c52007-11-23 16:29:32 +1100268 } else if (!strcmp(this_char, MNTOPT_BIOSIZE)) {
269 if (!value || !*value) {
Dave Chinner4f107002011-03-07 10:00:35 +1100270 xfs_warn(mp, "%s option requires an argument",
David Chinnera67d7c52007-11-23 16:29:32 +1100271 this_char);
272 return EINVAL;
273 }
Abhijit Pawara17164e2013-01-09 19:34:42 +0530274 if (kstrtoint(value, 10, &iosize))
275 return EINVAL;
Christoph Hellwig1ec79442008-10-30 17:55:08 +1100276 iosizelog = ffs(iosize) - 1;
David Chinnera67d7c52007-11-23 16:29:32 +1100277 } else if (!strcmp(this_char, MNTOPT_ALLOCSIZE)) {
278 if (!value || !*value) {
Dave Chinner4f107002011-03-07 10:00:35 +1100279 xfs_warn(mp, "%s option requires an argument",
David Chinnera67d7c52007-11-23 16:29:32 +1100280 this_char);
281 return EINVAL;
282 }
Abhijit Pawara17164e2013-01-09 19:34:42 +0530283 if (suffix_kstrtoint(value, 10, &iosize))
284 return EINVAL;
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100285 iosizelog = ffs(iosize) - 1;
David Chinnera67d7c52007-11-23 16:29:32 +1100286 } else if (!strcmp(this_char, MNTOPT_GRPID) ||
287 !strcmp(this_char, MNTOPT_BSDGROUPS)) {
288 mp->m_flags |= XFS_MOUNT_GRPID;
289 } else if (!strcmp(this_char, MNTOPT_NOGRPID) ||
290 !strcmp(this_char, MNTOPT_SYSVGROUPS)) {
291 mp->m_flags &= ~XFS_MOUNT_GRPID;
292 } else if (!strcmp(this_char, MNTOPT_WSYNC)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100293 mp->m_flags |= XFS_MOUNT_WSYNC;
David Chinnera67d7c52007-11-23 16:29:32 +1100294 } else if (!strcmp(this_char, MNTOPT_NORECOVERY)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100295 mp->m_flags |= XFS_MOUNT_NORECOVERY;
David Chinnera67d7c52007-11-23 16:29:32 +1100296 } else if (!strcmp(this_char, MNTOPT_NOALIGN)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100297 mp->m_flags |= XFS_MOUNT_NOALIGN;
David Chinnera67d7c52007-11-23 16:29:32 +1100298 } else if (!strcmp(this_char, MNTOPT_SWALLOC)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100299 mp->m_flags |= XFS_MOUNT_SWALLOC;
David Chinnera67d7c52007-11-23 16:29:32 +1100300 } else if (!strcmp(this_char, MNTOPT_SUNIT)) {
301 if (!value || !*value) {
Dave Chinner4f107002011-03-07 10:00:35 +1100302 xfs_warn(mp, "%s option requires an argument",
David Chinnera67d7c52007-11-23 16:29:32 +1100303 this_char);
304 return EINVAL;
305 }
Abhijit Pawara17164e2013-01-09 19:34:42 +0530306 if (kstrtoint(value, 10, &dsunit))
307 return EINVAL;
David Chinnera67d7c52007-11-23 16:29:32 +1100308 } else if (!strcmp(this_char, MNTOPT_SWIDTH)) {
309 if (!value || !*value) {
Dave Chinner4f107002011-03-07 10:00:35 +1100310 xfs_warn(mp, "%s option requires an argument",
David Chinnera67d7c52007-11-23 16:29:32 +1100311 this_char);
312 return EINVAL;
313 }
Abhijit Pawara17164e2013-01-09 19:34:42 +0530314 if (kstrtoint(value, 10, &dswidth))
315 return EINVAL;
Carlos Maiolino08bf5402012-09-20 10:32:37 -0300316 } else if (!strcmp(this_char, MNTOPT_32BITINODE)) {
317 mp->m_flags |= XFS_MOUNT_SMALL_INUMS;
David Chinnera67d7c52007-11-23 16:29:32 +1100318 } else if (!strcmp(this_char, MNTOPT_64BITINODE)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100319 mp->m_flags &= ~XFS_MOUNT_SMALL_INUMS;
David Chinnera67d7c52007-11-23 16:29:32 +1100320#if !XFS_BIG_INUMS
Dave Chinner4f107002011-03-07 10:00:35 +1100321 xfs_warn(mp, "%s option not allowed on this system",
David Chinnera67d7c52007-11-23 16:29:32 +1100322 this_char);
323 return EINVAL;
324#endif
325 } else if (!strcmp(this_char, MNTOPT_NOUUID)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100326 mp->m_flags |= XFS_MOUNT_NOUUID;
David Chinnera67d7c52007-11-23 16:29:32 +1100327 } else if (!strcmp(this_char, MNTOPT_BARRIER)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100328 mp->m_flags |= XFS_MOUNT_BARRIER;
David Chinnera67d7c52007-11-23 16:29:32 +1100329 } else if (!strcmp(this_char, MNTOPT_NOBARRIER)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100330 mp->m_flags &= ~XFS_MOUNT_BARRIER;
David Chinnera67d7c52007-11-23 16:29:32 +1100331 } else if (!strcmp(this_char, MNTOPT_IKEEP)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100332 mp->m_flags |= XFS_MOUNT_IKEEP;
David Chinnera67d7c52007-11-23 16:29:32 +1100333 } else if (!strcmp(this_char, MNTOPT_NOIKEEP)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100334 mp->m_flags &= ~XFS_MOUNT_IKEEP;
David Chinnera67d7c52007-11-23 16:29:32 +1100335 } else if (!strcmp(this_char, MNTOPT_LARGEIO)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100336 mp->m_flags &= ~XFS_MOUNT_COMPAT_IOSIZE;
David Chinnera67d7c52007-11-23 16:29:32 +1100337 } else if (!strcmp(this_char, MNTOPT_NOLARGEIO)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100338 mp->m_flags |= XFS_MOUNT_COMPAT_IOSIZE;
David Chinnera67d7c52007-11-23 16:29:32 +1100339 } else if (!strcmp(this_char, MNTOPT_ATTR2)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100340 mp->m_flags |= XFS_MOUNT_ATTR2;
David Chinnera67d7c52007-11-23 16:29:32 +1100341 } else if (!strcmp(this_char, MNTOPT_NOATTR2)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100342 mp->m_flags &= ~XFS_MOUNT_ATTR2;
343 mp->m_flags |= XFS_MOUNT_NOATTR2;
David Chinnera67d7c52007-11-23 16:29:32 +1100344 } else if (!strcmp(this_char, MNTOPT_FILESTREAM)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100345 mp->m_flags |= XFS_MOUNT_FILESTREAMS;
David Chinnera67d7c52007-11-23 16:29:32 +1100346 } else if (!strcmp(this_char, MNTOPT_NOQUOTA)) {
Chandra Seetharaman4177af32012-01-23 17:31:43 +0000347 mp->m_qflags &= ~XFS_ALL_QUOTA_ACCT;
348 mp->m_qflags &= ~XFS_ALL_QUOTA_ENFD;
349 mp->m_qflags &= ~XFS_ALL_QUOTA_ACTIVE;
David Chinnera67d7c52007-11-23 16:29:32 +1100350 } else if (!strcmp(this_char, MNTOPT_QUOTA) ||
351 !strcmp(this_char, MNTOPT_UQUOTA) ||
352 !strcmp(this_char, MNTOPT_USRQUOTA)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100353 mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ACTIVE |
354 XFS_UQUOTA_ENFD);
David Chinnera67d7c52007-11-23 16:29:32 +1100355 } else if (!strcmp(this_char, MNTOPT_QUOTANOENF) ||
356 !strcmp(this_char, MNTOPT_UQUOTANOENF)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100357 mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ACTIVE);
358 mp->m_qflags &= ~XFS_UQUOTA_ENFD;
David Chinnera67d7c52007-11-23 16:29:32 +1100359 } else if (!strcmp(this_char, MNTOPT_PQUOTA) ||
360 !strcmp(this_char, MNTOPT_PRJQUOTA)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100361 mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE |
362 XFS_OQUOTA_ENFD);
David Chinnera67d7c52007-11-23 16:29:32 +1100363 } else if (!strcmp(this_char, MNTOPT_PQUOTANOENF)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100364 mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE);
365 mp->m_qflags &= ~XFS_OQUOTA_ENFD;
David Chinnera67d7c52007-11-23 16:29:32 +1100366 } else if (!strcmp(this_char, MNTOPT_GQUOTA) ||
367 !strcmp(this_char, MNTOPT_GRPQUOTA)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100368 mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE |
369 XFS_OQUOTA_ENFD);
David Chinnera67d7c52007-11-23 16:29:32 +1100370 } else if (!strcmp(this_char, MNTOPT_GQUOTANOENF)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100371 mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE);
372 mp->m_qflags &= ~XFS_OQUOTA_ENFD;
Dave Chinner71e330b2010-05-21 14:37:18 +1000373 } else if (!strcmp(this_char, MNTOPT_DELAYLOG)) {
Christoph Hellwig242d6212011-08-24 05:57:51 +0000374 xfs_warn(mp,
Christoph Hellwig93b8a582011-12-06 21:58:07 +0000375 "delaylog is the default now, option is deprecated.");
376 } else if (!strcmp(this_char, MNTOPT_NODELAYLOG)) {
377 xfs_warn(mp,
378 "nodelaylog support has been removed, option is deprecated.");
Christoph Hellwige84661a2011-05-20 13:45:32 +0000379 } else if (!strcmp(this_char, MNTOPT_DISCARD)) {
380 mp->m_flags |= XFS_MOUNT_DISCARD;
381 } else if (!strcmp(this_char, MNTOPT_NODISCARD)) {
382 mp->m_flags &= ~XFS_MOUNT_DISCARD;
David Chinnera67d7c52007-11-23 16:29:32 +1100383 } else if (!strcmp(this_char, "ihashsize")) {
Dave Chinner4f107002011-03-07 10:00:35 +1100384 xfs_warn(mp,
385 "ihashsize no longer used, option is deprecated.");
David Chinnera67d7c52007-11-23 16:29:32 +1100386 } else if (!strcmp(this_char, "osyncisdsync")) {
Dave Chinner4f107002011-03-07 10:00:35 +1100387 xfs_warn(mp,
388 "osyncisdsync has no effect, option is deprecated.");
Christoph Hellwiga64afb02010-07-20 17:50:52 +1000389 } else if (!strcmp(this_char, "osyncisosync")) {
Dave Chinner4f107002011-03-07 10:00:35 +1100390 xfs_warn(mp,
391 "osyncisosync has no effect, option is deprecated.");
David Chinnera67d7c52007-11-23 16:29:32 +1100392 } else if (!strcmp(this_char, "irixsgid")) {
Dave Chinner4f107002011-03-07 10:00:35 +1100393 xfs_warn(mp,
394 "irixsgid is now a sysctl(2) variable, option is deprecated.");
David Chinnera67d7c52007-11-23 16:29:32 +1100395 } else {
Dave Chinner4f107002011-03-07 10:00:35 +1100396 xfs_warn(mp, "unknown mount option [%s].", this_char);
David Chinnera67d7c52007-11-23 16:29:32 +1100397 return EINVAL;
398 }
399 }
400
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100401 /*
402 * no recovery flag requires a read-only mount
403 */
404 if ((mp->m_flags & XFS_MOUNT_NORECOVERY) &&
405 !(mp->m_flags & XFS_MOUNT_RDONLY)) {
Dave Chinner4f107002011-03-07 10:00:35 +1100406 xfs_warn(mp, "no-recovery mounts must be read-only.");
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100407 return EINVAL;
David Chinnera67d7c52007-11-23 16:29:32 +1100408 }
409
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100410 if ((mp->m_flags & XFS_MOUNT_NOALIGN) && (dsunit || dswidth)) {
Dave Chinner4f107002011-03-07 10:00:35 +1100411 xfs_warn(mp,
412 "sunit and swidth options incompatible with the noalign option");
David Chinnera67d7c52007-11-23 16:29:32 +1100413 return EINVAL;
414 }
415
Christoph Hellwig7d095252009-06-08 15:33:32 +0200416#ifndef CONFIG_XFS_QUOTA
417 if (XFS_IS_QUOTA_RUNNING(mp)) {
Dave Chinner4f107002011-03-07 10:00:35 +1100418 xfs_warn(mp, "quota support not available in this kernel.");
Christoph Hellwig7d095252009-06-08 15:33:32 +0200419 return EINVAL;
420 }
421#endif
422
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100423 if ((mp->m_qflags & (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE)) &&
424 (mp->m_qflags & (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE))) {
Dave Chinner4f107002011-03-07 10:00:35 +1100425 xfs_warn(mp, "cannot mount with both project and group quota");
David Chinnera67d7c52007-11-23 16:29:32 +1100426 return EINVAL;
427 }
428
David Chinnera67d7c52007-11-23 16:29:32 +1100429 if ((dsunit && !dswidth) || (!dsunit && dswidth)) {
Dave Chinner4f107002011-03-07 10:00:35 +1100430 xfs_warn(mp, "sunit and swidth must be specified together");
David Chinnera67d7c52007-11-23 16:29:32 +1100431 return EINVAL;
432 }
433
434 if (dsunit && (dswidth % dsunit != 0)) {
Dave Chinner4f107002011-03-07 10:00:35 +1100435 xfs_warn(mp,
436 "stripe width (%d) must be a multiple of the stripe unit (%d)",
David Chinnera67d7c52007-11-23 16:29:32 +1100437 dswidth, dsunit);
438 return EINVAL;
439 }
440
David Chinnera67d7c52007-11-23 16:29:32 +1100441done:
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100442 if (!(mp->m_flags & XFS_MOUNT_NOALIGN)) {
443 /*
444 * At this point the superblock has not been read
445 * in, therefore we do not know the block size.
446 * Before the mount call ends we will convert
447 * these to FSBs.
448 */
449 if (dsunit) {
450 mp->m_dalign = dsunit;
451 mp->m_flags |= XFS_MOUNT_RETERR;
452 }
453
454 if (dswidth)
455 mp->m_swidth = dswidth;
456 }
457
458 if (mp->m_logbufs != -1 &&
459 mp->m_logbufs != 0 &&
460 (mp->m_logbufs < XLOG_MIN_ICLOGS ||
461 mp->m_logbufs > XLOG_MAX_ICLOGS)) {
Dave Chinner4f107002011-03-07 10:00:35 +1100462 xfs_warn(mp, "invalid logbufs value: %d [not %d-%d]",
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100463 mp->m_logbufs, XLOG_MIN_ICLOGS, XLOG_MAX_ICLOGS);
464 return XFS_ERROR(EINVAL);
465 }
466 if (mp->m_logbsize != -1 &&
467 mp->m_logbsize != 0 &&
468 (mp->m_logbsize < XLOG_MIN_RECORD_BSIZE ||
469 mp->m_logbsize > XLOG_MAX_RECORD_BSIZE ||
470 !is_power_of_2(mp->m_logbsize))) {
Dave Chinner4f107002011-03-07 10:00:35 +1100471 xfs_warn(mp,
472 "invalid logbufsize: %d [not 16k,32k,64k,128k or 256k]",
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100473 mp->m_logbsize);
474 return XFS_ERROR(EINVAL);
475 }
476
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100477 if (iosizelog) {
478 if (iosizelog > XFS_MAX_IO_LOG ||
479 iosizelog < XFS_MIN_IO_LOG) {
Dave Chinner4f107002011-03-07 10:00:35 +1100480 xfs_warn(mp, "invalid log iosize: %d [not %d-%d]",
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100481 iosizelog, XFS_MIN_IO_LOG,
482 XFS_MAX_IO_LOG);
483 return XFS_ERROR(EINVAL);
484 }
485
486 mp->m_flags |= XFS_MOUNT_DFLT_IOSIZE;
487 mp->m_readio_log = iosizelog;
488 mp->m_writeio_log = iosizelog;
489 }
490
David Chinnera67d7c52007-11-23 16:29:32 +1100491 return 0;
492}
493
494struct proc_xfs_info {
495 int flag;
496 char *str;
497};
498
499STATIC int
500xfs_showargs(
501 struct xfs_mount *mp,
502 struct seq_file *m)
503{
504 static struct proc_xfs_info xfs_info_set[] = {
505 /* the few simple ones we can get from the mount struct */
Josef Jeff Sipek1bd960e2008-02-29 13:58:40 +1100506 { XFS_MOUNT_IKEEP, "," MNTOPT_IKEEP },
David Chinnera67d7c52007-11-23 16:29:32 +1100507 { XFS_MOUNT_WSYNC, "," MNTOPT_WSYNC },
David Chinnera67d7c52007-11-23 16:29:32 +1100508 { XFS_MOUNT_NOALIGN, "," MNTOPT_NOALIGN },
509 { XFS_MOUNT_SWALLOC, "," MNTOPT_SWALLOC },
510 { XFS_MOUNT_NOUUID, "," MNTOPT_NOUUID },
511 { XFS_MOUNT_NORECOVERY, "," MNTOPT_NORECOVERY },
David Chinnera67d7c52007-11-23 16:29:32 +1100512 { XFS_MOUNT_ATTR2, "," MNTOPT_ATTR2 },
513 { XFS_MOUNT_FILESTREAMS, "," MNTOPT_FILESTREAM },
David Chinnera67d7c52007-11-23 16:29:32 +1100514 { XFS_MOUNT_GRPID, "," MNTOPT_GRPID },
Christoph Hellwige84661a2011-05-20 13:45:32 +0000515 { XFS_MOUNT_DISCARD, "," MNTOPT_DISCARD },
Carlos Maiolino08bf5402012-09-20 10:32:37 -0300516 { XFS_MOUNT_SMALL_INUMS, "," MNTOPT_32BITINODE },
David Chinnera67d7c52007-11-23 16:29:32 +1100517 { 0, NULL }
518 };
519 static struct proc_xfs_info xfs_info_unset[] = {
520 /* the few simple ones we can get from the mount struct */
David Chinnera67d7c52007-11-23 16:29:32 +1100521 { XFS_MOUNT_COMPAT_IOSIZE, "," MNTOPT_LARGEIO },
522 { XFS_MOUNT_BARRIER, "," MNTOPT_NOBARRIER },
523 { XFS_MOUNT_SMALL_INUMS, "," MNTOPT_64BITINODE },
524 { 0, NULL }
525 };
526 struct proc_xfs_info *xfs_infop;
527
528 for (xfs_infop = xfs_info_set; xfs_infop->flag; xfs_infop++) {
529 if (mp->m_flags & xfs_infop->flag)
530 seq_puts(m, xfs_infop->str);
531 }
532 for (xfs_infop = xfs_info_unset; xfs_infop->flag; xfs_infop++) {
533 if (!(mp->m_flags & xfs_infop->flag))
534 seq_puts(m, xfs_infop->str);
535 }
536
537 if (mp->m_flags & XFS_MOUNT_DFLT_IOSIZE)
538 seq_printf(m, "," MNTOPT_ALLOCSIZE "=%dk",
539 (int)(1 << mp->m_writeio_log) >> 10);
540
541 if (mp->m_logbufs > 0)
542 seq_printf(m, "," MNTOPT_LOGBUFS "=%d", mp->m_logbufs);
543 if (mp->m_logbsize > 0)
544 seq_printf(m, "," MNTOPT_LOGBSIZE "=%dk", mp->m_logbsize >> 10);
545
546 if (mp->m_logname)
547 seq_printf(m, "," MNTOPT_LOGDEV "=%s", mp->m_logname);
548 if (mp->m_rtname)
549 seq_printf(m, "," MNTOPT_RTDEV "=%s", mp->m_rtname);
550
551 if (mp->m_dalign > 0)
552 seq_printf(m, "," MNTOPT_SUNIT "=%d",
553 (int)XFS_FSB_TO_BB(mp, mp->m_dalign));
554 if (mp->m_swidth > 0)
555 seq_printf(m, "," MNTOPT_SWIDTH "=%d",
556 (int)XFS_FSB_TO_BB(mp, mp->m_swidth));
557
558 if (mp->m_qflags & (XFS_UQUOTA_ACCT|XFS_UQUOTA_ENFD))
559 seq_puts(m, "," MNTOPT_USRQUOTA);
560 else if (mp->m_qflags & XFS_UQUOTA_ACCT)
561 seq_puts(m, "," MNTOPT_UQUOTANOENF);
562
Alex Elder988abe42009-09-02 17:02:24 -0500563 /* Either project or group quotas can be active, not both */
David Chinnera67d7c52007-11-23 16:29:32 +1100564
Alex Elder988abe42009-09-02 17:02:24 -0500565 if (mp->m_qflags & XFS_PQUOTA_ACCT) {
566 if (mp->m_qflags & XFS_OQUOTA_ENFD)
567 seq_puts(m, "," MNTOPT_PRJQUOTA);
568 else
569 seq_puts(m, "," MNTOPT_PQUOTANOENF);
570 } else if (mp->m_qflags & XFS_GQUOTA_ACCT) {
571 if (mp->m_qflags & XFS_OQUOTA_ENFD)
572 seq_puts(m, "," MNTOPT_GRPQUOTA);
573 else
574 seq_puts(m, "," MNTOPT_GQUOTANOENF);
575 }
David Chinnera67d7c52007-11-23 16:29:32 +1100576
577 if (!(mp->m_qflags & XFS_ALL_QUOTA_ACCT))
578 seq_puts(m, "," MNTOPT_NOQUOTA);
579
580 return 0;
581}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582__uint64_t
583xfs_max_file_offset(
584 unsigned int blockshift)
585{
586 unsigned int pagefactor = 1;
587 unsigned int bitshift = BITS_PER_LONG - 1;
588
589 /* Figure out maximum filesize, on Linux this can depend on
590 * the filesystem blocksize (on 32 bit platforms).
Christoph Hellwigebdec242010-10-06 10:47:23 +0200591 * __block_write_begin does this in an [unsigned] long...
Linus Torvalds1da177e2005-04-16 15:20:36 -0700592 * page->index << (PAGE_CACHE_SHIFT - bbits)
593 * So, for page sized blocks (4K on 32 bit platforms),
594 * this wraps at around 8Tb (hence MAX_LFS_FILESIZE which is
595 * (((u64)PAGE_CACHE_SIZE << (BITS_PER_LONG-1))-1)
596 * but for smaller blocksizes it is less (bbits = log2 bsize).
597 * Note1: get_block_t takes a long (implicit cast from above)
598 * Note2: The Large Block Device (LBD and HAVE_SECTOR_T) patch
599 * can optionally convert the [unsigned] long from above into
600 * an [unsigned] long long.
601 */
602
603#if BITS_PER_LONG == 32
Bartlomiej Zolnierkiewicz90c699a2009-06-19 08:08:50 +0200604# if defined(CONFIG_LBDAF)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605 ASSERT(sizeof(sector_t) == 8);
606 pagefactor = PAGE_CACHE_SIZE;
607 bitshift = BITS_PER_LONG;
608# else
609 pagefactor = PAGE_CACHE_SIZE >> (PAGE_CACHE_SHIFT - blockshift);
610# endif
611#endif
612
613 return (((__uint64_t)pagefactor) << bitshift) - 1;
614}
615
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300616xfs_agnumber_t
617xfs_set_inode32(struct xfs_mount *mp)
618{
619 xfs_agnumber_t index = 0;
Carlos Maiolino4056c1d2012-09-20 10:32:40 -0300620 xfs_agnumber_t maxagi = 0;
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300621 xfs_sb_t *sbp = &mp->m_sb;
622 xfs_agnumber_t max_metadata;
623 xfs_agino_t agino = XFS_OFFBNO_TO_AGINO(mp, sbp->sb_agblocks -1, 0);
624 xfs_ino_t ino = XFS_AGINO_TO_INO(mp, sbp->sb_agcount -1, agino);
625 xfs_perag_t *pag;
626
627 /* Calculate how much should be reserved for inodes to meet
628 * the max inode percentage.
629 */
630 if (mp->m_maxicount) {
631 __uint64_t icount;
632
633 icount = sbp->sb_dblocks * sbp->sb_imax_pct;
634 do_div(icount, 100);
635 icount += sbp->sb_agblocks - 1;
636 do_div(icount, sbp->sb_agblocks);
637 max_metadata = icount;
638 } else {
639 max_metadata = sbp->sb_agcount;
640 }
641
642 for (index = 0; index < sbp->sb_agcount; index++) {
643 ino = XFS_AGINO_TO_INO(mp, index, agino);
Carlos Maiolino4056c1d2012-09-20 10:32:40 -0300644
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300645 if (ino > XFS_MAXINUMBER_32) {
Carlos Maiolino4056c1d2012-09-20 10:32:40 -0300646 pag = xfs_perag_get(mp, index);
647 pag->pagi_inodeok = 0;
648 pag->pagf_metadata = 0;
649 xfs_perag_put(pag);
650 continue;
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300651 }
652
653 pag = xfs_perag_get(mp, index);
654 pag->pagi_inodeok = 1;
Carlos Maiolino4056c1d2012-09-20 10:32:40 -0300655 maxagi++;
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300656 if (index < max_metadata)
657 pag->pagf_metadata = 1;
658 xfs_perag_put(pag);
659 }
Carlos Maiolino4056c1d2012-09-20 10:32:40 -0300660 mp->m_flags |= (XFS_MOUNT_32BITINODES |
661 XFS_MOUNT_SMALL_INUMS);
662
663 return maxagi;
Carlos Maiolino2d2194f2012-09-20 10:32:38 -0300664}
665
666xfs_agnumber_t
667xfs_set_inode64(struct xfs_mount *mp)
668{
669 xfs_agnumber_t index = 0;
670
671 for (index = 0; index < mp->m_sb.sb_agcount; index++) {
672 struct xfs_perag *pag;
673
674 pag = xfs_perag_get(mp, index);
675 pag->pagi_inodeok = 1;
676 pag->pagf_metadata = 0;
677 xfs_perag_put(pag);
678 }
679
680 /* There is no need for lock protection on m_flags,
681 * the rw_semaphore of the VFS superblock is locked
682 * during mount/umount/remount operations, so this is
683 * enough to avoid concurency on the m_flags field
684 */
685 mp->m_flags &= ~(XFS_MOUNT_32BITINODES |
686 XFS_MOUNT_SMALL_INUMS);
687 return index;
688}
689
Hannes Eder3180e662009-03-04 19:34:10 +0100690STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691xfs_blkdev_get(
692 xfs_mount_t *mp,
693 const char *name,
694 struct block_device **bdevp)
695{
696 int error = 0;
697
Tejun Heod4d77622010-11-13 11:55:18 +0100698 *bdevp = blkdev_get_by_path(name, FMODE_READ|FMODE_WRITE|FMODE_EXCL,
699 mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 if (IS_ERR(*bdevp)) {
701 error = PTR_ERR(*bdevp);
Dave Chinner4f107002011-03-07 10:00:35 +1100702 xfs_warn(mp, "Invalid device [%s], error=%d\n", name, error);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 }
704
705 return -error;
706}
707
Hannes Eder3180e662009-03-04 19:34:10 +0100708STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709xfs_blkdev_put(
710 struct block_device *bdev)
711{
712 if (bdev)
Tejun Heoe525fd82010-11-13 11:55:17 +0100713 blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714}
715
Christoph Hellwigf538d4d2005-11-02 10:26:59 +1100716void
717xfs_blkdev_issue_flush(
718 xfs_buftarg_t *buftarg)
719{
Shaohua Li7582df52012-04-24 21:23:46 +0800720 blkdev_issue_flush(buftarg->bt_bdev, GFP_NOFS, NULL);
Christoph Hellwigf538d4d2005-11-02 10:26:59 +1100721}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000723STATIC void
724xfs_close_devices(
725 struct xfs_mount *mp)
726{
727 if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp) {
Lachlan McIlroyc032bfc2008-07-18 17:13:12 +1000728 struct block_device *logdev = mp->m_logdev_targp->bt_bdev;
Christoph Hellwigb7963132009-03-03 14:48:37 -0500729 xfs_free_buftarg(mp, mp->m_logdev_targp);
Lachlan McIlroyc032bfc2008-07-18 17:13:12 +1000730 xfs_blkdev_put(logdev);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000731 }
732 if (mp->m_rtdev_targp) {
Lachlan McIlroyc032bfc2008-07-18 17:13:12 +1000733 struct block_device *rtdev = mp->m_rtdev_targp->bt_bdev;
Christoph Hellwigb7963132009-03-03 14:48:37 -0500734 xfs_free_buftarg(mp, mp->m_rtdev_targp);
Lachlan McIlroyc032bfc2008-07-18 17:13:12 +1000735 xfs_blkdev_put(rtdev);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000736 }
Christoph Hellwigb7963132009-03-03 14:48:37 -0500737 xfs_free_buftarg(mp, mp->m_ddev_targp);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000738}
739
740/*
741 * The file system configurations are:
742 * (1) device (partition) with data and internal log
743 * (2) logical volume with data and log subvolumes.
744 * (3) logical volume with data, log, and realtime subvolumes.
745 *
746 * We only have to handle opening the log and realtime volumes here if
747 * they are present. The data subvolume has already been opened by
748 * get_sb_bdev() and is stored in sb->s_bdev.
749 */
750STATIC int
751xfs_open_devices(
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100752 struct xfs_mount *mp)
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000753{
754 struct block_device *ddev = mp->m_super->s_bdev;
755 struct block_device *logdev = NULL, *rtdev = NULL;
756 int error;
757
758 /*
759 * Open real time and log devices - order is important.
760 */
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100761 if (mp->m_logname) {
762 error = xfs_blkdev_get(mp, mp->m_logname, &logdev);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000763 if (error)
764 goto out;
765 }
766
Christoph Hellwig9d565ff2008-10-30 17:53:24 +1100767 if (mp->m_rtname) {
768 error = xfs_blkdev_get(mp, mp->m_rtname, &rtdev);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000769 if (error)
770 goto out_close_logdev;
771
772 if (rtdev == ddev || rtdev == logdev) {
Dave Chinner4f107002011-03-07 10:00:35 +1100773 xfs_warn(mp,
774 "Cannot mount filesystem with identical rtdev and ddev/logdev.");
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000775 error = EINVAL;
776 goto out_close_rtdev;
777 }
778 }
779
780 /*
781 * Setup xfs_mount buffer target pointers
782 */
783 error = ENOMEM;
Dave Chinnerebad8612010-09-22 10:47:20 +1000784 mp->m_ddev_targp = xfs_alloc_buftarg(mp, ddev, 0, mp->m_fsname);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000785 if (!mp->m_ddev_targp)
786 goto out_close_rtdev;
787
788 if (rtdev) {
Dave Chinnerebad8612010-09-22 10:47:20 +1000789 mp->m_rtdev_targp = xfs_alloc_buftarg(mp, rtdev, 1,
790 mp->m_fsname);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000791 if (!mp->m_rtdev_targp)
792 goto out_free_ddev_targ;
793 }
794
795 if (logdev && logdev != ddev) {
Dave Chinnerebad8612010-09-22 10:47:20 +1000796 mp->m_logdev_targp = xfs_alloc_buftarg(mp, logdev, 1,
797 mp->m_fsname);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000798 if (!mp->m_logdev_targp)
799 goto out_free_rtdev_targ;
800 } else {
801 mp->m_logdev_targp = mp->m_ddev_targp;
802 }
803
804 return 0;
805
806 out_free_rtdev_targ:
807 if (mp->m_rtdev_targp)
Christoph Hellwigb7963132009-03-03 14:48:37 -0500808 xfs_free_buftarg(mp, mp->m_rtdev_targp);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000809 out_free_ddev_targ:
Christoph Hellwigb7963132009-03-03 14:48:37 -0500810 xfs_free_buftarg(mp, mp->m_ddev_targp);
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000811 out_close_rtdev:
812 if (rtdev)
813 xfs_blkdev_put(rtdev);
814 out_close_logdev:
815 if (logdev && logdev != ddev)
816 xfs_blkdev_put(logdev);
817 out:
818 return error;
819}
820
Christoph Hellwige34b5622008-05-20 15:10:36 +1000821/*
822 * Setup xfs_mount buffer target pointers based on superblock
823 */
824STATIC int
825xfs_setup_devices(
826 struct xfs_mount *mp)
827{
828 int error;
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000829
Christoph Hellwige34b5622008-05-20 15:10:36 +1000830 error = xfs_setsize_buftarg(mp->m_ddev_targp, mp->m_sb.sb_blocksize,
831 mp->m_sb.sb_sectsize);
832 if (error)
833 return error;
834
835 if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp) {
836 unsigned int log_sector_size = BBSIZE;
837
838 if (xfs_sb_version_hassector(&mp->m_sb))
839 log_sector_size = mp->m_sb.sb_logsectsize;
840 error = xfs_setsize_buftarg(mp->m_logdev_targp,
841 mp->m_sb.sb_blocksize,
842 log_sector_size);
843 if (error)
844 return error;
845 }
846 if (mp->m_rtdev_targp) {
847 error = xfs_setsize_buftarg(mp->m_rtdev_targp,
848 mp->m_sb.sb_blocksize,
849 mp->m_sb.sb_sectsize);
850 if (error)
851 return error;
852 }
853
854 return 0;
855}
Christoph Hellwig19f354d2008-05-20 11:31:13 +1000856
Christoph Hellwigaa6bf012012-02-29 09:53:48 +0000857STATIC int
858xfs_init_mount_workqueues(
859 struct xfs_mount *mp)
860{
861 mp->m_data_workqueue = alloc_workqueue("xfs-data/%s",
862 WQ_MEM_RECLAIM, 0, mp->m_fsname);
863 if (!mp->m_data_workqueue)
864 goto out;
865
866 mp->m_unwritten_workqueue = alloc_workqueue("xfs-conv/%s",
867 WQ_MEM_RECLAIM, 0, mp->m_fsname);
868 if (!mp->m_unwritten_workqueue)
869 goto out_destroy_data_iodone_queue;
870
Dave Chinner4c2d5422012-04-23 17:54:32 +1000871 mp->m_cil_workqueue = alloc_workqueue("xfs-cil/%s",
872 WQ_MEM_RECLAIM, 0, mp->m_fsname);
873 if (!mp->m_cil_workqueue)
874 goto out_destroy_unwritten;
Dave Chinner58896082012-10-08 21:56:05 +1100875
876 mp->m_reclaim_workqueue = alloc_workqueue("xfs-reclaim/%s",
877 WQ_NON_REENTRANT, 0, mp->m_fsname);
878 if (!mp->m_reclaim_workqueue)
879 goto out_destroy_cil;
880
881 mp->m_log_workqueue = alloc_workqueue("xfs-log/%s",
882 WQ_NON_REENTRANT, 0, mp->m_fsname);
883 if (!mp->m_log_workqueue)
884 goto out_destroy_reclaim;
885
Brian Foster579b62f2012-11-06 09:50:47 -0500886 mp->m_eofblocks_workqueue = alloc_workqueue("xfs-eofblocks/%s",
887 WQ_NON_REENTRANT, 0, mp->m_fsname);
888 if (!mp->m_eofblocks_workqueue)
889 goto out_destroy_log;
890
Christoph Hellwigaa6bf012012-02-29 09:53:48 +0000891 return 0;
892
Brian Foster579b62f2012-11-06 09:50:47 -0500893out_destroy_log:
894 destroy_workqueue(mp->m_log_workqueue);
Dave Chinner58896082012-10-08 21:56:05 +1100895out_destroy_reclaim:
896 destroy_workqueue(mp->m_reclaim_workqueue);
897out_destroy_cil:
898 destroy_workqueue(mp->m_cil_workqueue);
Dave Chinner4c2d5422012-04-23 17:54:32 +1000899out_destroy_unwritten:
900 destroy_workqueue(mp->m_unwritten_workqueue);
Christoph Hellwigaa6bf012012-02-29 09:53:48 +0000901out_destroy_data_iodone_queue:
902 destroy_workqueue(mp->m_data_workqueue);
903out:
904 return -ENOMEM;
905}
906
907STATIC void
908xfs_destroy_mount_workqueues(
909 struct xfs_mount *mp)
910{
Brian Foster579b62f2012-11-06 09:50:47 -0500911 destroy_workqueue(mp->m_eofblocks_workqueue);
Dave Chinner58896082012-10-08 21:56:05 +1100912 destroy_workqueue(mp->m_log_workqueue);
913 destroy_workqueue(mp->m_reclaim_workqueue);
Dave Chinner4c2d5422012-04-23 17:54:32 +1000914 destroy_workqueue(mp->m_cil_workqueue);
Christoph Hellwigaa6bf012012-02-29 09:53:48 +0000915 destroy_workqueue(mp->m_data_workqueue);
916 destroy_workqueue(mp->m_unwritten_workqueue);
917}
918
Dave Chinner9aa05002012-10-08 21:56:04 +1100919/*
920 * Flush all dirty data to disk. Must not be called while holding an XFS_ILOCK
921 * or a page lock. We use sync_inodes_sb() here to ensure we block while waiting
922 * for IO to complete so that we effectively throttle multiple callers to the
923 * rate at which IO is completing.
924 */
925void
926xfs_flush_inodes(
927 struct xfs_mount *mp)
928{
929 struct super_block *sb = mp->m_super;
930
931 if (down_read_trylock(&sb->s_umount)) {
932 sync_inodes_sb(sb);
933 up_read(&sb->s_umount);
934 }
935}
936
David Chinnerbf904242008-10-30 17:36:14 +1100937/* Catch misguided souls that try to use this interface on XFS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700938STATIC struct inode *
Nathan Scotta50cd262006-03-14 14:06:18 +1100939xfs_fs_alloc_inode(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940 struct super_block *sb)
941{
David Chinnerbf904242008-10-30 17:36:14 +1100942 BUG();
Lachlan McIlroy493dca62008-10-30 17:36:52 +1100943 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700944}
945
David Chinnerbf904242008-10-30 17:36:14 +1100946/*
David Chinner99fa8cb2008-10-30 17:36:40 +1100947 * Now that the generic code is guaranteed not to be accessing
948 * the linux inode, we can reclaim the inode.
David Chinnerbf904242008-10-30 17:36:14 +1100949 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950STATIC void
Nathan Scotta50cd262006-03-14 14:06:18 +1100951xfs_fs_destroy_inode(
Christoph Hellwig848ce8f2009-09-29 13:48:56 +0000952 struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953{
Christoph Hellwig848ce8f2009-09-29 13:48:56 +0000954 struct xfs_inode *ip = XFS_I(inode);
955
Christoph Hellwigcca28fb2010-06-24 11:57:09 +1000956 trace_xfs_destroy_inode(ip);
David Chinner99fa8cb2008-10-30 17:36:40 +1100957
958 XFS_STATS_INC(vn_reclaim);
Christoph Hellwig848ce8f2009-09-29 13:48:56 +0000959
960 /* bad inode, get out here ASAP */
961 if (is_bad_inode(inode))
962 goto out_reclaim;
963
Christoph Hellwig848ce8f2009-09-29 13:48:56 +0000964 ASSERT(XFS_FORCED_SHUTDOWN(ip->i_mount) || ip->i_delayed_blks == 0);
965
966 /*
967 * We should never get here with one of the reclaim flags already set.
968 */
969 ASSERT_ALWAYS(!xfs_iflags_test(ip, XFS_IRECLAIMABLE));
970 ASSERT_ALWAYS(!xfs_iflags_test(ip, XFS_IRECLAIM));
971
972 /*
Dave Chinner57817c62010-01-10 23:51:47 +0000973 * We always use background reclaim here because even if the
974 * inode is clean, it still may be under IO and hence we have
975 * to take the flush lock. The background reclaim path handles
976 * this more efficiently than we can here, so simply let background
977 * reclaim tear down all inodes.
Christoph Hellwig848ce8f2009-09-29 13:48:56 +0000978 */
Christoph Hellwig848ce8f2009-09-29 13:48:56 +0000979out_reclaim:
Dave Chinner57817c62010-01-10 23:51:47 +0000980 xfs_inode_set_reclaim_tag(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700981}
982
David Chinner07c8f672008-10-30 16:11:59 +1100983/*
984 * Slab object creation initialisation for the XFS inode.
985 * This covers only the idempotent fields in the XFS inode;
986 * all other fields need to be initialised on allocation
Uwe Kleine-Königb5950762010-11-01 15:38:34 -0400987 * from the slab. This avoids the need to repeatedly initialise
David Chinner07c8f672008-10-30 16:11:59 +1100988 * fields in the xfs inode that left in the initialise state
989 * when freeing the inode.
990 */
David Chinnerbf904242008-10-30 17:36:14 +1100991STATIC void
992xfs_fs_inode_init_once(
David Chinner07c8f672008-10-30 16:11:59 +1100993 void *inode)
994{
995 struct xfs_inode *ip = inode;
996
997 memset(ip, 0, sizeof(struct xfs_inode));
David Chinnerbf904242008-10-30 17:36:14 +1100998
999 /* vfs inode */
1000 inode_init_once(VFS_I(ip));
1001
1002 /* xfs inode */
David Chinner07c8f672008-10-30 16:11:59 +11001003 atomic_set(&ip->i_pincount, 0);
1004 spin_lock_init(&ip->i_flags_lock);
David Chinner07c8f672008-10-30 16:11:59 +11001005
1006 mrlock_init(&ip->i_lock, MRLOCK_ALLOW_EQUAL_PRI|MRLOCK_BARRIER,
1007 "xfsino", ip->i_ino);
David Chinner07c8f672008-10-30 16:11:59 +11001008}
1009
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010STATIC void
Al Virob57922d2010-06-07 14:34:48 -04001011xfs_fs_evict_inode(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012 struct inode *inode)
1013{
Christoph Hellwig1543d792007-08-29 11:46:47 +10001014 xfs_inode_t *ip = XFS_I(inode);
Christoph Hellwig56d433e2005-09-05 08:23:54 +10001015
Christoph Hellwig4f59af72012-07-04 11:13:33 -04001016 ASSERT(!rwsem_is_locked(&ip->i_iolock.mr_lock));
1017
Al Virob57922d2010-06-07 14:34:48 -04001018 trace_xfs_evict_inode(ip);
Christoph Hellwigcca28fb2010-06-24 11:57:09 +10001019
Al Virob57922d2010-06-07 14:34:48 -04001020 truncate_inode_pages(&inode->i_data, 0);
Jan Karadbd57682012-05-03 14:48:02 +02001021 clear_inode(inode);
David Chinner99fa8cb2008-10-30 17:36:40 +11001022 XFS_STATS_INC(vn_rele);
1023 XFS_STATS_INC(vn_remove);
1024 XFS_STATS_DEC(vn_active);
Christoph Hellwig56d433e2005-09-05 08:23:54 +10001025
David Chinner99fa8cb2008-10-30 17:36:40 +11001026 xfs_inactive(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027}
1028
Dave Chinner5132ba82012-03-22 05:15:10 +00001029/*
1030 * We do an unlocked check for XFS_IDONTCACHE here because we are already
1031 * serialised against cache hits here via the inode->i_lock and igrab() in
1032 * xfs_iget_cache_hit(). Hence a lookup that might clear this flag will not be
1033 * racing with us, and it avoids needing to grab a spinlock here for every inode
1034 * we drop the final reference on.
1035 */
1036STATIC int
1037xfs_fs_drop_inode(
1038 struct inode *inode)
1039{
1040 struct xfs_inode *ip = XFS_I(inode);
1041
1042 return generic_drop_inode(inode) || (ip->i_flags & XFS_IDONTCACHE);
1043}
1044
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045STATIC void
Christoph Hellwiga7381592008-08-13 16:04:05 +10001046xfs_free_fsname(
1047 struct xfs_mount *mp)
1048{
1049 kfree(mp->m_fsname);
1050 kfree(mp->m_rtname);
1051 kfree(mp->m_logname);
1052}
1053
1054STATIC void
Nathan Scotta50cd262006-03-14 14:06:18 +11001055xfs_fs_put_super(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056 struct super_block *sb)
1057{
Christoph Hellwig745f6912007-08-30 17:20:39 +10001058 struct xfs_mount *mp = XFS_M(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059
Dave Chinner7e185302012-10-08 21:56:00 +11001060 xfs_filestream_unmount(mp);
1061 xfs_unmountfs(mp);
1062
Christoph Hellwig62033002008-08-13 16:50:21 +10001063 xfs_freesb(mp);
Christoph Hellwigc962fb72008-05-20 15:10:52 +10001064 xfs_icsb_destroy_counters(mp);
Christoph Hellwigaa6bf012012-02-29 09:53:48 +00001065 xfs_destroy_mount_workqueues(mp);
Christoph Hellwig19f354d2008-05-20 11:31:13 +10001066 xfs_close_devices(mp);
Christoph Hellwiga7381592008-08-13 16:04:05 +10001067 xfs_free_fsname(mp);
Christoph Hellwigc962fb72008-05-20 15:10:52 +10001068 kfree(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069}
1070
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071STATIC int
Christoph Hellwig69961a22009-10-06 20:29:28 +00001072xfs_fs_sync_fs(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001073 struct super_block *sb,
1074 int wait)
1075{
Christoph Hellwig745f6912007-08-30 17:20:39 +10001076 struct xfs_mount *mp = XFS_M(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077
Lachlan McIlroye893bff2007-10-12 11:13:35 +10001078 /*
Christoph Hellwig34625c62011-12-06 21:58:12 +00001079 * Doing anything during the async pass would be counterproductive.
Lachlan McIlroye893bff2007-10-12 11:13:35 +10001080 */
Christoph Hellwig34625c62011-12-06 21:58:12 +00001081 if (!wait)
Christoph Hellwig69961a22009-10-06 20:29:28 +00001082 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083
Dave Chinner34061f52012-10-08 21:56:06 +11001084 xfs_log_force(mp, XFS_LOG_SYNC);
Christoph Hellwig69961a22009-10-06 20:29:28 +00001085 if (laptop_mode) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 /*
1087 * The disk must be active because we're syncing.
Dave Chinnerf661f1e2012-10-08 21:56:02 +11001088 * We schedule log work now (now that the disk is
Linus Torvalds1da177e2005-04-16 15:20:36 -07001089 * active) instead of later (when it might not be).
1090 */
Dave Chinnerf661f1e2012-10-08 21:56:02 +11001091 flush_delayed_work(&mp->m_log->l_work);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092 }
1093
Christoph Hellwig69961a22009-10-06 20:29:28 +00001094 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095}
1096
1097STATIC int
Nathan Scotta50cd262006-03-14 14:06:18 +11001098xfs_fs_statfs(
David Howells726c3342006-06-23 02:02:58 -07001099 struct dentry *dentry,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100 struct kstatfs *statp)
1101{
Christoph Hellwig4ca488e2007-10-11 18:09:40 +10001102 struct xfs_mount *mp = XFS_M(dentry->d_sb);
1103 xfs_sb_t *sbp = &mp->m_sb;
Christoph Hellwig7d095252009-06-08 15:33:32 +02001104 struct xfs_inode *ip = XFS_I(dentry->d_inode);
Christoph Hellwig4ca488e2007-10-11 18:09:40 +10001105 __uint64_t fakeinos, id;
1106 xfs_extlen_t lsize;
Stuart Brodsky2fe33662010-08-24 11:46:05 +10001107 __int64_t ffree;
Christoph Hellwig4ca488e2007-10-11 18:09:40 +10001108
1109 statp->f_type = XFS_SB_MAGIC;
1110 statp->f_namelen = MAXNAMELEN - 1;
1111
1112 id = huge_encode_dev(mp->m_ddev_targp->bt_dev);
1113 statp->f_fsid.val[0] = (u32)id;
1114 statp->f_fsid.val[1] = (u32)(id >> 32);
1115
Christoph Hellwigd4d90b52008-04-22 17:34:37 +10001116 xfs_icsb_sync_counters(mp, XFS_ICSB_LAZY_COUNT);
Christoph Hellwig4ca488e2007-10-11 18:09:40 +10001117
1118 spin_lock(&mp->m_sb_lock);
1119 statp->f_bsize = sbp->sb_blocksize;
1120 lsize = sbp->sb_logstart ? sbp->sb_logblocks : 0;
1121 statp->f_blocks = sbp->sb_dblocks - lsize;
1122 statp->f_bfree = statp->f_bavail =
1123 sbp->sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
1124 fakeinos = statp->f_bfree << sbp->sb_inopblog;
Christoph Hellwig4ca488e2007-10-11 18:09:40 +10001125 statp->f_files =
1126 MIN(sbp->sb_icount + fakeinos, (__uint64_t)XFS_MAXINUMBER);
1127 if (mp->m_maxicount)
Christoph Hellwiga19d9f82009-03-29 09:51:08 +02001128 statp->f_files = min_t(typeof(statp->f_files),
1129 statp->f_files,
1130 mp->m_maxicount);
Stuart Brodsky2fe33662010-08-24 11:46:05 +10001131
1132 /* make sure statp->f_ffree does not underflow */
1133 ffree = statp->f_files - (sbp->sb_icount - sbp->sb_ifree);
1134 statp->f_ffree = max_t(__int64_t, ffree, 0);
1135
Christoph Hellwig4ca488e2007-10-11 18:09:40 +10001136 spin_unlock(&mp->m_sb_lock);
1137
Jie Liuda5bf952012-04-12 03:59:57 +00001138 if ((ip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
Christoph Hellwig7d095252009-06-08 15:33:32 +02001139 ((mp->m_qflags & (XFS_PQUOTA_ACCT|XFS_OQUOTA_ENFD))) ==
1140 (XFS_PQUOTA_ACCT|XFS_OQUOTA_ENFD))
1141 xfs_qm_statvfs(ip, statp);
Christoph Hellwig4ca488e2007-10-11 18:09:40 +10001142 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001143}
1144
Eric Sandeend5db0f92010-02-05 22:59:53 +00001145STATIC void
1146xfs_save_resvblks(struct xfs_mount *mp)
1147{
1148 __uint64_t resblks = 0;
1149
1150 mp->m_resblks_save = mp->m_resblks;
1151 xfs_reserve_blocks(mp, &resblks, NULL);
1152}
1153
1154STATIC void
1155xfs_restore_resvblks(struct xfs_mount *mp)
1156{
1157 __uint64_t resblks;
1158
1159 if (mp->m_resblks_save) {
1160 resblks = mp->m_resblks_save;
1161 mp->m_resblks_save = 0;
1162 } else
1163 resblks = xfs_default_resblks(mp);
1164
1165 xfs_reserve_blocks(mp, &resblks, NULL);
1166}
1167
Dave Chinnerc7eea6f2012-10-08 21:56:07 +11001168/*
1169 * Trigger writeback of all the dirty metadata in the file system.
1170 *
1171 * This ensures that the metadata is written to their location on disk rather
1172 * than just existing in transactions in the log. This means after a quiesce
Dave Chinnerc75921a2012-10-08 21:56:08 +11001173 * there is no log replay required to write the inodes to disk - this is the
1174 * primary difference between a sync and a quiesce.
Dave Chinnerc7eea6f2012-10-08 21:56:07 +11001175 *
Dave Chinnerc75921a2012-10-08 21:56:08 +11001176 * Note: xfs_log_quiesce() stops background log work - the callers must ensure
1177 * it is started again when appropriate.
Dave Chinnerc7eea6f2012-10-08 21:56:07 +11001178 */
1179void
1180xfs_quiesce_attr(
1181 struct xfs_mount *mp)
1182{
1183 int error = 0;
1184
1185 /* wait for all modifications to complete */
1186 while (atomic_read(&mp->m_active_trans) > 0)
1187 delay(100);
1188
1189 /* force the log to unpin objects from the now complete transactions */
1190 xfs_log_force(mp, XFS_LOG_SYNC);
1191
1192 /* reclaim inodes to do any IO before the freeze completes */
1193 xfs_reclaim_inodes(mp, 0);
1194 xfs_reclaim_inodes(mp, SYNC_WAIT);
1195
Dave Chinnerc75921a2012-10-08 21:56:08 +11001196 /* Push the superblock and write an unmount record */
1197 error = xfs_log_sbcount(mp);
1198 if (error)
1199 xfs_warn(mp, "xfs_attr_quiesce: failed to log sb changes. "
1200 "Frozen image may not be consistent.");
Dave Chinnerc7eea6f2012-10-08 21:56:07 +11001201 /*
1202 * Just warn here till VFS can correctly support
1203 * read-only remount without racing.
1204 */
1205 WARN_ON(atomic_read(&mp->m_active_trans) != 0);
1206
Dave Chinnerc75921a2012-10-08 21:56:08 +11001207 xfs_log_quiesce(mp);
Dave Chinnerc7eea6f2012-10-08 21:56:07 +11001208}
1209
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210STATIC int
Nathan Scotta50cd262006-03-14 14:06:18 +11001211xfs_fs_remount(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212 struct super_block *sb,
1213 int *flags,
1214 char *options)
1215{
Christoph Hellwig745f6912007-08-30 17:20:39 +10001216 struct xfs_mount *mp = XFS_M(sb);
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001217 substring_t args[MAX_OPT_ARGS];
1218 char *p;
Christoph Hellwig7884bc82009-01-19 02:04:07 +01001219 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001220
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001221 while ((p = strsep(&options, ",")) != NULL) {
1222 int token;
Christoph Hellwigbdd907b2008-05-20 15:10:44 +10001223
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001224 if (!*p)
1225 continue;
Christoph Hellwig48b62a12008-05-20 11:30:39 +10001226
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001227 token = match_token(p, tokens, args);
1228 switch (token) {
1229 case Opt_barrier:
Christoph Hellwig48b62a12008-05-20 11:30:39 +10001230 mp->m_flags |= XFS_MOUNT_BARRIER;
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001231 break;
1232 case Opt_nobarrier:
Christoph Hellwig48b62a12008-05-20 11:30:39 +10001233 mp->m_flags &= ~XFS_MOUNT_BARRIER;
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001234 break;
Carlos Maiolinoc3a58fe2012-08-17 18:19:38 -03001235 case Opt_inode64:
Carlos Maiolino4c083722012-09-20 10:32:39 -03001236 mp->m_maxagi = xfs_set_inode64(mp);
Carlos Maiolinoc3a58fe2012-08-17 18:19:38 -03001237 break;
Carlos Maiolino2ea03922012-09-20 10:32:41 -03001238 case Opt_inode32:
1239 mp->m_maxagi = xfs_set_inode32(mp);
1240 break;
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001241 default:
Christoph Hellwig6efdf282008-09-17 16:49:33 +10001242 /*
1243 * Logically we would return an error here to prevent
1244 * users from believing they might have changed
1245 * mount options using remount which can't be changed.
1246 *
1247 * But unfortunately mount(8) adds all options from
1248 * mtab and fstab to the mount arguments in some cases
1249 * so we can't blindly reject options, but have to
1250 * check for each specified option if it actually
1251 * differs from the currently set option and only
1252 * reject it if that's the case.
1253 *
1254 * Until that is implemented we return success for
1255 * every remount request, and silently ignore all
1256 * options that we can't actually change.
1257 */
1258#if 0
Dave Chinner4f107002011-03-07 10:00:35 +11001259 xfs_info(mp,
1260 "mount option \"%s\" not supported for remount\n", p);
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001261 return -EINVAL;
Christoph Hellwig6efdf282008-09-17 16:49:33 +10001262#else
Christoph Hellwig6c5e51d2008-10-12 14:30:44 +02001263 break;
Christoph Hellwig6efdf282008-09-17 16:49:33 +10001264#endif
Christoph Hellwig48b62a12008-05-20 11:30:39 +10001265 }
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001266 }
1267
Christoph Hellwig7884bc82009-01-19 02:04:07 +01001268 /* ro -> rw */
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001269 if ((mp->m_flags & XFS_MOUNT_RDONLY) && !(*flags & MS_RDONLY)) {
1270 mp->m_flags &= ~XFS_MOUNT_RDONLY;
Christoph Hellwig7884bc82009-01-19 02:04:07 +01001271
1272 /*
1273 * If this is the first remount to writeable state we
1274 * might have some superblock changes to update.
1275 */
1276 if (mp->m_update_flags) {
1277 error = xfs_mount_log_sb(mp, mp->m_update_flags);
1278 if (error) {
Dave Chinner4f107002011-03-07 10:00:35 +11001279 xfs_warn(mp, "failed to write sb changes");
Christoph Hellwig7884bc82009-01-19 02:04:07 +01001280 return error;
1281 }
1282 mp->m_update_flags = 0;
1283 }
Dave Chinnercbe132a2010-01-26 15:08:49 +11001284
1285 /*
1286 * Fill out the reserve pool if it is empty. Use the stashed
1287 * value if it is non-zero, otherwise go with the default.
1288 */
Eric Sandeend5db0f92010-02-05 22:59:53 +00001289 xfs_restore_resvblks(mp);
Dave Chinnerf661f1e2012-10-08 21:56:02 +11001290 xfs_log_work_queue(mp);
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001291 }
1292
1293 /* rw -> ro */
1294 if (!(mp->m_flags & XFS_MOUNT_RDONLY) && (*flags & MS_RDONLY)) {
Dave Chinnercbe132a2010-01-26 15:08:49 +11001295 /*
Dave Chinner34061f52012-10-08 21:56:06 +11001296 * Before we sync the metadata, we need to free up the reserve
1297 * block pool so that the used block count in the superblock on
1298 * disk is correct at the end of the remount. Stash the current
1299 * reserve pool size so that if we get remounted rw, we can
1300 * return it to the same size.
Dave Chinnercbe132a2010-01-26 15:08:49 +11001301 */
Eric Sandeend5db0f92010-02-05 22:59:53 +00001302 xfs_save_resvblks(mp);
David Chinner76bf1052008-10-30 17:16:21 +11001303 xfs_quiesce_attr(mp);
Christoph Hellwig48b62a12008-05-20 11:30:39 +10001304 mp->m_flags |= XFS_MOUNT_RDONLY;
1305 }
1306
Christoph Hellwig62a877e2008-07-18 17:12:36 +10001307 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308}
1309
Christoph Hellwig9909c4a2007-10-11 18:11:14 +10001310/*
1311 * Second stage of a freeze. The data is already frozen so we only
David Chinner76bf1052008-10-30 17:16:21 +11001312 * need to take care of the metadata. Once that's done write a dummy
Christoph Hellwig9909c4a2007-10-11 18:11:14 +10001313 * record to dirty the log in case of a crash while frozen.
1314 */
Takashi Satoc4be0c12009-01-09 16:40:58 -08001315STATIC int
1316xfs_fs_freeze(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 struct super_block *sb)
1318{
Christoph Hellwig9909c4a2007-10-11 18:11:14 +10001319 struct xfs_mount *mp = XFS_M(sb);
1320
Eric Sandeend5db0f92010-02-05 22:59:53 +00001321 xfs_save_resvblks(mp);
David Chinner76bf1052008-10-30 17:16:21 +11001322 xfs_quiesce_attr(mp);
Dave Chinnerc58efdb2011-01-04 04:49:29 +00001323 return -xfs_fs_log_dummy(mp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324}
1325
1326STATIC int
Eric Sandeend5db0f92010-02-05 22:59:53 +00001327xfs_fs_unfreeze(
1328 struct super_block *sb)
1329{
1330 struct xfs_mount *mp = XFS_M(sb);
1331
1332 xfs_restore_resvblks(mp);
Dave Chinnerf661f1e2012-10-08 21:56:02 +11001333 xfs_log_work_queue(mp);
Eric Sandeend5db0f92010-02-05 22:59:53 +00001334 return 0;
1335}
1336
1337STATIC int
Nathan Scotta50cd262006-03-14 14:06:18 +11001338xfs_fs_show_options(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339 struct seq_file *m,
Al Viro34c80b12011-12-08 21:32:45 -05001340 struct dentry *root)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341{
Al Viro34c80b12011-12-08 21:32:45 -05001342 return -xfs_showargs(XFS_M(root->d_sb), m);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343}
1344
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001345/*
1346 * This function fills in xfs_mount_t fields based on mount args.
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001347 * Note: the superblock _has_ now been read in.
1348 */
1349STATIC int
1350xfs_finish_flags(
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001351 struct xfs_mount *mp)
1352{
1353 int ronly = (mp->m_flags & XFS_MOUNT_RDONLY);
1354
Frederik Schwarzer025dfda2008-10-16 19:02:37 +02001355 /* Fail a mount where the logbuf is smaller than the log stripe */
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001356 if (xfs_sb_version_haslogv2(&mp->m_sb)) {
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001357 if (mp->m_logbsize <= 0 &&
1358 mp->m_sb.sb_logsunit > XLOG_BIG_RECORD_BSIZE) {
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001359 mp->m_logbsize = mp->m_sb.sb_logsunit;
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001360 } else if (mp->m_logbsize > 0 &&
1361 mp->m_logbsize < mp->m_sb.sb_logsunit) {
Dave Chinner4f107002011-03-07 10:00:35 +11001362 xfs_warn(mp,
1363 "logbuf size must be greater than or equal to log stripe size");
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001364 return XFS_ERROR(EINVAL);
1365 }
1366 } else {
1367 /* Fail a mount if the logbuf is larger than 32K */
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001368 if (mp->m_logbsize > XLOG_BIG_RECORD_BSIZE) {
Dave Chinner4f107002011-03-07 10:00:35 +11001369 xfs_warn(mp,
1370 "logbuf size for version 1 logs must be 16K or 32K");
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001371 return XFS_ERROR(EINVAL);
1372 }
1373 }
1374
1375 /*
1376 * mkfs'ed attr2 will turn on attr2 mount unless explicitly
1377 * told by noattr2 to turn it off
1378 */
1379 if (xfs_sb_version_hasattr2(&mp->m_sb) &&
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001380 !(mp->m_flags & XFS_MOUNT_NOATTR2))
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001381 mp->m_flags |= XFS_MOUNT_ATTR2;
1382
1383 /*
1384 * prohibit r/w mounts of read-only filesystems
1385 */
1386 if ((mp->m_sb.sb_flags & XFS_SBF_READONLY) && !ronly) {
Dave Chinner4f107002011-03-07 10:00:35 +11001387 xfs_warn(mp,
1388 "cannot mount a read-only filesystem as read-write");
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001389 return XFS_ERROR(EROFS);
1390 }
1391
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001392 return 0;
1393}
1394
Linus Torvalds1da177e2005-04-16 15:20:36 -07001395STATIC int
Nathan Scotta50cd262006-03-14 14:06:18 +11001396xfs_fs_fill_super(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001397 struct super_block *sb,
1398 void *data,
1399 int silent)
1400{
Christoph Hellwigf3dcc132008-03-27 18:00:54 +11001401 struct inode *root;
Christoph Hellwig745f6912007-08-30 17:20:39 +10001402 struct xfs_mount *mp = NULL;
Christoph Hellwigc962fb72008-05-20 15:10:52 +10001403 int flags = 0, error = ENOMEM;
Christoph Hellwigbdd907b2008-05-20 15:10:44 +10001404
Christoph Hellwigc962fb72008-05-20 15:10:52 +10001405 mp = kzalloc(sizeof(struct xfs_mount), GFP_KERNEL);
1406 if (!mp)
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001407 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408
Christoph Hellwigc962fb72008-05-20 15:10:52 +10001409 spin_lock_init(&mp->m_sb_lock);
Christoph Hellwigc962fb72008-05-20 15:10:52 +10001410 mutex_init(&mp->m_growlock);
1411 atomic_set(&mp->m_active_trans, 0);
Dave Chinner7e185302012-10-08 21:56:00 +11001412 INIT_DELAYED_WORK(&mp->m_reclaim_work, xfs_reclaim_worker);
Brian Foster579b62f2012-11-06 09:50:47 -05001413 INIT_DELAYED_WORK(&mp->m_eofblocks_work, xfs_eofblocks_worker);
Christoph Hellwig74394492007-08-30 17:21:22 +10001414
Christoph Hellwigb267ce92007-08-30 17:21:30 +10001415 mp->m_super = sb;
1416 sb->s_fs_info = mp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417
Christoph Hellwig288699f2010-06-23 18:11:15 +10001418 error = xfs_parseargs(mp, (char *)data);
Christoph Hellwig745f6912007-08-30 17:20:39 +10001419 if (error)
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001420 goto out_free_fsname;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421
1422 sb_min_blocksize(sb, BBSIZE);
Lachlan McIlroy0ec58512008-06-23 13:23:01 +10001423 sb->s_xattr = xfs_xattr_handlers;
Nathan Scotta50cd262006-03-14 14:06:18 +11001424 sb->s_export_op = &xfs_export_operations;
Christoph Hellwigfcafb712009-02-09 08:47:34 +01001425#ifdef CONFIG_XFS_QUOTA
Nathan Scotta50cd262006-03-14 14:06:18 +11001426 sb->s_qcop = &xfs_quotactl_operations;
Christoph Hellwigfcafb712009-02-09 08:47:34 +01001427#endif
Nathan Scotta50cd262006-03-14 14:06:18 +11001428 sb->s_op = &xfs_super_operations;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001429
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001430 if (silent)
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001431 flags |= XFS_MFSI_QUIET;
1432
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001433 error = xfs_open_devices(mp);
Christoph Hellwig19f354d2008-05-20 11:31:13 +10001434 if (error)
Christoph Hellwig288699f2010-06-23 18:11:15 +10001435 goto out_free_fsname;
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001436
Christoph Hellwigaa6bf012012-02-29 09:53:48 +00001437 error = xfs_init_mount_workqueues(mp);
Christoph Hellwig61ba35d2010-09-30 02:25:54 +00001438 if (error)
1439 goto out_close_devices;
Christoph Hellwigc962fb72008-05-20 15:10:52 +10001440
Christoph Hellwigaa6bf012012-02-29 09:53:48 +00001441 error = xfs_icsb_init_counters(mp);
1442 if (error)
1443 goto out_destroy_workqueues;
1444
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001445 error = xfs_readsb(mp, flags);
1446 if (error)
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001447 goto out_destroy_counters;
1448
1449 error = xfs_finish_flags(mp);
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001450 if (error)
Christoph Hellwigeffa2ed2008-05-20 15:11:05 +10001451 goto out_free_sb;
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001452
Christoph Hellwige34b5622008-05-20 15:10:36 +10001453 error = xfs_setup_devices(mp);
Christoph Hellwig19f354d2008-05-20 11:31:13 +10001454 if (error)
Christoph Hellwigeffa2ed2008-05-20 15:11:05 +10001455 goto out_free_sb;
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001456
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001457 error = xfs_filestream_mount(mp);
1458 if (error)
Christoph Hellwigeffa2ed2008-05-20 15:11:05 +10001459 goto out_free_sb;
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001460
Dave Chinner704b2902011-03-26 09:14:57 +11001461 /*
1462 * we must configure the block size in the superblock before we run the
1463 * full mount process as the mount process can lookup and cache inodes.
Dave Chinner704b2902011-03-26 09:14:57 +11001464 */
Christoph Hellwig4ca488e2007-10-11 18:09:40 +10001465 sb->s_magic = XFS_SB_MAGIC;
1466 sb->s_blocksize = mp->m_sb.sb_blocksize;
1467 sb->s_blocksize_bits = ffs(sb->s_blocksize) - 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468 sb->s_maxbytes = xfs_max_file_offset(sb->s_blocksize_bits);
Al Viro8de52772012-02-06 12:45:27 -05001469 sb->s_max_links = XFS_MAXLINK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470 sb->s_time_gran = 1;
1471 set_posix_acl_flag(sb);
1472
Dave Chinner8a00ebe2012-04-13 12:10:44 +00001473 error = xfs_mountfs(mp);
Christoph Hellwig2bcf6e92011-07-13 13:43:48 +02001474 if (error)
Dave Chinner7e185302012-10-08 21:56:00 +11001475 goto out_filestream_unmount;
Dave Chinner704b2902011-03-26 09:14:57 +11001476
David Chinner01651642008-08-13 15:45:15 +10001477 root = igrab(VFS_I(mp->m_rootip));
Christoph Hellwigf3dcc132008-03-27 18:00:54 +11001478 if (!root) {
Christoph Hellwigcbc89dc2008-02-05 12:14:01 +11001479 error = ENOENT;
Dave Chinner8a00ebe2012-04-13 12:10:44 +00001480 goto out_unmount;
Christoph Hellwigcbc89dc2008-02-05 12:14:01 +11001481 }
Christoph Hellwigf3dcc132008-03-27 18:00:54 +11001482 if (is_bad_inode(root)) {
1483 error = EINVAL;
Dave Chinner8a00ebe2012-04-13 12:10:44 +00001484 goto out_unmount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485 }
Al Viro48fde702012-01-08 22:15:13 -05001486 sb->s_root = d_make_root(root);
Christoph Hellwigf3dcc132008-03-27 18:00:54 +11001487 if (!sb->s_root) {
1488 error = ENOMEM;
Dave Chinner8a00ebe2012-04-13 12:10:44 +00001489 goto out_unmount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490 }
Christoph Hellwig74394492007-08-30 17:21:22 +10001491
Dave Chinner7e185302012-10-08 21:56:00 +11001492 return 0;
1493
1494 out_filestream_unmount:
Christoph Hellwig120226c2008-05-20 15:11:11 +10001495 xfs_filestream_unmount(mp);
Christoph Hellwigeffa2ed2008-05-20 15:11:05 +10001496 out_free_sb:
1497 xfs_freesb(mp);
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001498 out_destroy_counters:
Christoph Hellwigc962fb72008-05-20 15:10:52 +10001499 xfs_icsb_destroy_counters(mp);
Christoph Hellwigaa6bf012012-02-29 09:53:48 +00001500out_destroy_workqueues:
1501 xfs_destroy_mount_workqueues(mp);
Christoph Hellwig61ba35d2010-09-30 02:25:54 +00001502 out_close_devices:
Christoph Hellwig19f354d2008-05-20 11:31:13 +10001503 xfs_close_devices(mp);
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001504 out_free_fsname:
1505 xfs_free_fsname(mp);
Christoph Hellwigc962fb72008-05-20 15:10:52 +10001506 kfree(mp);
Christoph Hellwig9d565ff2008-10-30 17:53:24 +11001507 out:
Christoph Hellwigc962fb72008-05-20 15:10:52 +10001508 return -error;
Christoph Hellwigf8f15e42008-05-20 11:30:59 +10001509
Christoph Hellwig2bcf6e92011-07-13 13:43:48 +02001510 out_unmount:
Christoph Hellwige48ad312008-05-20 11:30:52 +10001511 xfs_filestream_unmount(mp);
Christoph Hellwig19f354d2008-05-20 11:31:13 +10001512 xfs_unmountfs(mp);
Christoph Hellwig62033002008-08-13 16:50:21 +10001513 goto out_free_sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514}
1515
Al Viro152a0832010-07-25 00:46:55 +04001516STATIC struct dentry *
1517xfs_fs_mount(
Linus Torvalds1da177e2005-04-16 15:20:36 -07001518 struct file_system_type *fs_type,
1519 int flags,
1520 const char *dev_name,
Al Viro152a0832010-07-25 00:46:55 +04001521 void *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522{
Al Viro152a0832010-07-25 00:46:55 +04001523 return mount_bdev(fs_type, flags, dev_name, data, xfs_fs_fill_super);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524}
1525
Dave Chinner8daaa832011-07-08 14:14:46 +10001526static int
1527xfs_fs_nr_cached_objects(
1528 struct super_block *sb)
1529{
1530 return xfs_reclaim_inodes_count(XFS_M(sb));
1531}
1532
1533static void
1534xfs_fs_free_cached_objects(
1535 struct super_block *sb,
1536 int nr_to_scan)
1537{
1538 xfs_reclaim_inodes_nr(XFS_M(sb), nr_to_scan);
1539}
1540
Alexey Dobriyanb87221d2009-09-21 17:01:09 -07001541static const struct super_operations xfs_super_operations = {
Nathan Scotta50cd262006-03-14 14:06:18 +11001542 .alloc_inode = xfs_fs_alloc_inode,
1543 .destroy_inode = xfs_fs_destroy_inode,
Al Virob57922d2010-06-07 14:34:48 -04001544 .evict_inode = xfs_fs_evict_inode,
Dave Chinner5132ba82012-03-22 05:15:10 +00001545 .drop_inode = xfs_fs_drop_inode,
Nathan Scotta50cd262006-03-14 14:06:18 +11001546 .put_super = xfs_fs_put_super,
Christoph Hellwig69961a22009-10-06 20:29:28 +00001547 .sync_fs = xfs_fs_sync_fs,
Takashi Satoc4be0c12009-01-09 16:40:58 -08001548 .freeze_fs = xfs_fs_freeze,
Eric Sandeend5db0f92010-02-05 22:59:53 +00001549 .unfreeze_fs = xfs_fs_unfreeze,
Nathan Scotta50cd262006-03-14 14:06:18 +11001550 .statfs = xfs_fs_statfs,
1551 .remount_fs = xfs_fs_remount,
1552 .show_options = xfs_fs_show_options,
Dave Chinner8daaa832011-07-08 14:14:46 +10001553 .nr_cached_objects = xfs_fs_nr_cached_objects,
1554 .free_cached_objects = xfs_fs_free_cached_objects,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001555};
1556
Andrew Morton5085b602007-02-20 13:57:47 -08001557static struct file_system_type xfs_fs_type = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558 .owner = THIS_MODULE,
1559 .name = "xfs",
Al Viro152a0832010-07-25 00:46:55 +04001560 .mount = xfs_fs_mount,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 .kill_sb = kill_block_super,
1562 .fs_flags = FS_REQUIRES_DEV,
1563};
1564
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001565STATIC int __init
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001566xfs_init_zones(void)
1567{
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001568
1569 xfs_ioend_zone = kmem_zone_init(sizeof(xfs_ioend_t), "xfs_ioend");
1570 if (!xfs_ioend_zone)
David Chinnerbf904242008-10-30 17:36:14 +11001571 goto out;
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001572
1573 xfs_ioend_pool = mempool_create_slab_pool(4 * MAX_BUF_PER_PAGE,
1574 xfs_ioend_zone);
1575 if (!xfs_ioend_pool)
1576 goto out_destroy_ioend_zone;
1577
1578 xfs_log_ticket_zone = kmem_zone_init(sizeof(xlog_ticket_t),
1579 "xfs_log_ticket");
1580 if (!xfs_log_ticket_zone)
1581 goto out_destroy_ioend_pool;
1582
1583 xfs_bmap_free_item_zone = kmem_zone_init(sizeof(xfs_bmap_free_item_t),
1584 "xfs_bmap_free_item");
1585 if (!xfs_bmap_free_item_zone)
1586 goto out_destroy_log_ticket_zone;
David Chinnerbf904242008-10-30 17:36:14 +11001587
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001588 xfs_btree_cur_zone = kmem_zone_init(sizeof(xfs_btree_cur_t),
1589 "xfs_btree_cur");
1590 if (!xfs_btree_cur_zone)
1591 goto out_destroy_bmap_free_item_zone;
1592
1593 xfs_da_state_zone = kmem_zone_init(sizeof(xfs_da_state_t),
1594 "xfs_da_state");
1595 if (!xfs_da_state_zone)
1596 goto out_destroy_btree_cur_zone;
1597
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001598 xfs_ifork_zone = kmem_zone_init(sizeof(xfs_ifork_t), "xfs_ifork");
1599 if (!xfs_ifork_zone)
Dave Chinner1d9025e2012-06-22 18:50:14 +10001600 goto out_destroy_da_state_zone;
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001601
1602 xfs_trans_zone = kmem_zone_init(sizeof(xfs_trans_t), "xfs_trans");
1603 if (!xfs_trans_zone)
1604 goto out_destroy_ifork_zone;
1605
Christoph Hellwige98c4142010-06-23 18:11:15 +10001606 xfs_log_item_desc_zone =
1607 kmem_zone_init(sizeof(struct xfs_log_item_desc),
1608 "xfs_log_item_desc");
1609 if (!xfs_log_item_desc_zone)
1610 goto out_destroy_trans_zone;
1611
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001612 /*
1613 * The size of the zone allocated buf log item is the maximum
1614 * size possible under XFS. This wastes a little bit of memory,
1615 * but it is much faster.
1616 */
Dave Chinner77c1a082012-06-22 18:50:07 +10001617 xfs_buf_item_zone = kmem_zone_init(sizeof(struct xfs_buf_log_item),
1618 "xfs_buf_item");
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001619 if (!xfs_buf_item_zone)
Christoph Hellwige98c4142010-06-23 18:11:15 +10001620 goto out_destroy_log_item_desc_zone;
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001621
1622 xfs_efd_zone = kmem_zone_init((sizeof(xfs_efd_log_item_t) +
1623 ((XFS_EFD_MAX_FAST_EXTENTS - 1) *
1624 sizeof(xfs_extent_t))), "xfs_efd_item");
1625 if (!xfs_efd_zone)
1626 goto out_destroy_buf_item_zone;
1627
1628 xfs_efi_zone = kmem_zone_init((sizeof(xfs_efi_log_item_t) +
1629 ((XFS_EFI_MAX_FAST_EXTENTS - 1) *
1630 sizeof(xfs_extent_t))), "xfs_efi_item");
1631 if (!xfs_efi_zone)
1632 goto out_destroy_efd_zone;
1633
1634 xfs_inode_zone =
1635 kmem_zone_init_flags(sizeof(xfs_inode_t), "xfs_inode",
David Chinnerbf904242008-10-30 17:36:14 +11001636 KM_ZONE_HWALIGN | KM_ZONE_RECLAIM | KM_ZONE_SPREAD,
1637 xfs_fs_inode_init_once);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001638 if (!xfs_inode_zone)
1639 goto out_destroy_efi_zone;
1640
1641 xfs_ili_zone =
1642 kmem_zone_init_flags(sizeof(xfs_inode_log_item_t), "xfs_ili",
1643 KM_ZONE_SPREAD, NULL);
1644 if (!xfs_ili_zone)
1645 goto out_destroy_inode_zone;
1646
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001647 return 0;
1648
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001649 out_destroy_inode_zone:
1650 kmem_zone_destroy(xfs_inode_zone);
1651 out_destroy_efi_zone:
1652 kmem_zone_destroy(xfs_efi_zone);
1653 out_destroy_efd_zone:
1654 kmem_zone_destroy(xfs_efd_zone);
1655 out_destroy_buf_item_zone:
1656 kmem_zone_destroy(xfs_buf_item_zone);
Christoph Hellwige98c4142010-06-23 18:11:15 +10001657 out_destroy_log_item_desc_zone:
1658 kmem_zone_destroy(xfs_log_item_desc_zone);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001659 out_destroy_trans_zone:
1660 kmem_zone_destroy(xfs_trans_zone);
1661 out_destroy_ifork_zone:
1662 kmem_zone_destroy(xfs_ifork_zone);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001663 out_destroy_da_state_zone:
1664 kmem_zone_destroy(xfs_da_state_zone);
1665 out_destroy_btree_cur_zone:
1666 kmem_zone_destroy(xfs_btree_cur_zone);
1667 out_destroy_bmap_free_item_zone:
1668 kmem_zone_destroy(xfs_bmap_free_item_zone);
1669 out_destroy_log_ticket_zone:
1670 kmem_zone_destroy(xfs_log_ticket_zone);
1671 out_destroy_ioend_pool:
1672 mempool_destroy(xfs_ioend_pool);
1673 out_destroy_ioend_zone:
1674 kmem_zone_destroy(xfs_ioend_zone);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001675 out:
1676 return -ENOMEM;
1677}
1678
1679STATIC void
1680xfs_destroy_zones(void)
1681{
Kirill A. Shutemov8c0a8532012-09-26 11:33:07 +10001682 /*
1683 * Make sure all delayed rcu free are flushed before we
1684 * destroy caches.
1685 */
1686 rcu_barrier();
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001687 kmem_zone_destroy(xfs_ili_zone);
1688 kmem_zone_destroy(xfs_inode_zone);
1689 kmem_zone_destroy(xfs_efi_zone);
1690 kmem_zone_destroy(xfs_efd_zone);
1691 kmem_zone_destroy(xfs_buf_item_zone);
Christoph Hellwige98c4142010-06-23 18:11:15 +10001692 kmem_zone_destroy(xfs_log_item_desc_zone);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001693 kmem_zone_destroy(xfs_trans_zone);
1694 kmem_zone_destroy(xfs_ifork_zone);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001695 kmem_zone_destroy(xfs_da_state_zone);
1696 kmem_zone_destroy(xfs_btree_cur_zone);
1697 kmem_zone_destroy(xfs_bmap_free_item_zone);
1698 kmem_zone_destroy(xfs_log_ticket_zone);
1699 mempool_destroy(xfs_ioend_pool);
1700 kmem_zone_destroy(xfs_ioend_zone);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001701
1702}
1703
1704STATIC int __init
Dave Chinner0bf6a5b2011-04-08 12:45:07 +10001705xfs_init_workqueues(void)
1706{
1707 /*
Dave Chinnerc999a222012-03-22 05:15:07 +00001708 * The allocation workqueue can be used in memory reclaim situations
1709 * (writepage path), and parallelism is only limited by the number of
1710 * AGs in all the filesystems mounted. Hence use the default large
1711 * max_active value for this workqueue.
1712 */
1713 xfs_alloc_wq = alloc_workqueue("xfsalloc", WQ_MEM_RECLAIM, 0);
1714 if (!xfs_alloc_wq)
Dave Chinner58896082012-10-08 21:56:05 +11001715 return -ENOMEM;
Dave Chinnerc999a222012-03-22 05:15:07 +00001716
Dave Chinner0bf6a5b2011-04-08 12:45:07 +10001717 return 0;
Dave Chinner0bf6a5b2011-04-08 12:45:07 +10001718}
1719
Luck, Tony39411f82011-04-11 12:06:12 -07001720STATIC void
Dave Chinner0bf6a5b2011-04-08 12:45:07 +10001721xfs_destroy_workqueues(void)
1722{
Dave Chinnerc999a222012-03-22 05:15:07 +00001723 destroy_workqueue(xfs_alloc_wq);
Dave Chinner0bf6a5b2011-04-08 12:45:07 +10001724}
1725
1726STATIC int __init
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001727init_xfs_fs(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728{
1729 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730
Christoph Hellwig65795912008-11-28 14:23:33 +11001731 printk(KERN_INFO XFS_VERSION_STRING " with "
1732 XFS_BUILD_OPTIONS " enabled\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001734 xfs_dir_startup();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001735
Nathan Scott87582802006-03-14 13:18:19 +11001736 error = xfs_init_zones();
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001737 if (error)
1738 goto out;
1739
Dave Chinner0bf6a5b2011-04-08 12:45:07 +10001740 error = xfs_init_workqueues();
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001741 if (error)
Christoph Hellwig0b1b2132009-12-14 23:14:59 +00001742 goto out_destroy_zones;
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001743
Dave Chinner0bf6a5b2011-04-08 12:45:07 +10001744 error = xfs_mru_cache_init();
1745 if (error)
1746 goto out_destroy_wq;
1747
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001748 error = xfs_filestream_init();
1749 if (error)
1750 goto out_mru_cache_uninit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001751
Nathan Scottce8e9222006-01-11 15:39:08 +11001752 error = xfs_buf_init();
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001753 if (error)
1754 goto out_filestream_uninit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001755
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001756 error = xfs_init_procfs();
1757 if (error)
1758 goto out_buf_terminate;
1759
1760 error = xfs_sysctl_register();
1761 if (error)
1762 goto out_cleanup_procfs;
1763
Christoph Hellwiga05931c2012-03-13 08:52:37 +00001764 error = xfs_qm_init();
1765 if (error)
1766 goto out_sysctl_unregister;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001767
1768 error = register_filesystem(&xfs_fs_type);
1769 if (error)
Christoph Hellwiga05931c2012-03-13 08:52:37 +00001770 goto out_qm_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771 return 0;
1772
Christoph Hellwiga05931c2012-03-13 08:52:37 +00001773 out_qm_exit:
1774 xfs_qm_exit();
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001775 out_sysctl_unregister:
1776 xfs_sysctl_unregister();
1777 out_cleanup_procfs:
1778 xfs_cleanup_procfs();
1779 out_buf_terminate:
Nathan Scottce8e9222006-01-11 15:39:08 +11001780 xfs_buf_terminate();
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001781 out_filestream_uninit:
1782 xfs_filestream_uninit();
1783 out_mru_cache_uninit:
1784 xfs_mru_cache_uninit();
Dave Chinner0bf6a5b2011-04-08 12:45:07 +10001785 out_destroy_wq:
1786 xfs_destroy_workqueues();
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001787 out_destroy_zones:
Nathan Scott87582802006-03-14 13:18:19 +11001788 xfs_destroy_zones();
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001789 out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 return error;
1791}
1792
1793STATIC void __exit
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001794exit_xfs_fs(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001795{
Christoph Hellwiga05931c2012-03-13 08:52:37 +00001796 xfs_qm_exit();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797 unregister_filesystem(&xfs_fs_type);
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001798 xfs_sysctl_unregister();
1799 xfs_cleanup_procfs();
Nathan Scottce8e9222006-01-11 15:39:08 +11001800 xfs_buf_terminate();
Christoph Hellwig9f8868f2008-07-18 17:11:46 +10001801 xfs_filestream_uninit();
1802 xfs_mru_cache_uninit();
Dave Chinner0bf6a5b2011-04-08 12:45:07 +10001803 xfs_destroy_workqueues();
Nathan Scott87582802006-03-14 13:18:19 +11001804 xfs_destroy_zones();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805}
1806
1807module_init(init_xfs_fs);
1808module_exit(exit_xfs_fs);
1809
1810MODULE_AUTHOR("Silicon Graphics, Inc.");
1811MODULE_DESCRIPTION(XFS_VERSION_STRING " with " XFS_BUILD_OPTIONS " enabled");
1812MODULE_LICENSE("GPL");