Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
xfs_super.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2000-2006 Silicon Graphics, Inc.
3  * All Rights Reserved.
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License as
7  * published by the Free Software Foundation.
8  *
9  * 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.
13  *
14  * 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
17  */
18 
19 #include "xfs.h"
20 #include "xfs_log.h"
21 #include "xfs_inum.h"
22 #include "xfs_trans.h"
23 #include "xfs_sb.h"
24 #include "xfs_ag.h"
25 #include "xfs_dir2.h"
26 #include "xfs_alloc.h"
27 #include "xfs_quota.h"
28 #include "xfs_mount.h"
29 #include "xfs_bmap_btree.h"
30 #include "xfs_alloc_btree.h"
31 #include "xfs_ialloc_btree.h"
32 #include "xfs_dinode.h"
33 #include "xfs_inode.h"
34 #include "xfs_btree.h"
35 #include "xfs_ialloc.h"
36 #include "xfs_bmap.h"
37 #include "xfs_rtalloc.h"
38 #include "xfs_error.h"
39 #include "xfs_itable.h"
40 #include "xfs_fsops.h"
41 #include "xfs_attr.h"
42 #include "xfs_buf_item.h"
43 #include "xfs_utils.h"
44 #include "xfs_vnodeops.h"
45 #include "xfs_log_priv.h"
46 #include "xfs_trans_priv.h"
47 #include "xfs_filestream.h"
48 #include "xfs_da_btree.h"
49 #include "xfs_extfree_item.h"
50 #include "xfs_mru_cache.h"
51 #include "xfs_inode_item.h"
52 #include "xfs_sync.h"
53 #include "xfs_trace.h"
54 
55 #include <linux/namei.h>
56 #include <linux/init.h>
57 #include <linux/slab.h>
58 #include <linux/mount.h>
59 #include <linux/mempool.h>
60 #include <linux/writeback.h>
61 #include <linux/kthread.h>
62 #include <linux/freezer.h>
63 #include <linux/parser.h>
64 
65 static const struct super_operations xfs_super_operations;
66 static kmem_zone_t *xfs_ioend_zone;
67 mempool_t *xfs_ioend_pool;
68 
69 #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 */
75 #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 */
90 #define MNTOPT_64BITINODE "inode64" /* inodes can be allocated anywhere */
91 #define MNTOPT_32BITINODE "inode32" /* inode allocation limited to
92  * XFS_MAXINUMBER_32 */
93 #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 */
113 #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 */
117 
118 /*
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  */
124 enum {
125  Opt_barrier,
126  Opt_nobarrier,
127  Opt_inode64,
128  Opt_inode32,
129  Opt_err
130 };
131 
132 static const match_table_t tokens = {
133  {Opt_barrier, "barrier"},
134  {Opt_nobarrier, "nobarrier"},
135  {Opt_inode64, "inode64"},
136  {Opt_inode32, "inode32"},
137  {Opt_err, NULL}
138 };
139 
140 
141 STATIC unsigned long
142 suffix_strtoul(char *s, char **endp, unsigned int base)
143 {
144  int last, shift_left_factor = 0;
145  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 
161  return simple_strtoul((const char *)s, endp, base) << shift_left_factor;
162 }
163 
164 /*
165  * This function fills in xfs_mount_t fields based on mount args.
166  * Note: the superblock has _not_ yet been read in.
167  *
168  * Note that this function leaks the various device name allocations on
169  * failure. The caller takes care of them.
170  */
171 STATIC int
172 xfs_parseargs(
173  struct xfs_mount *mp,
174  char *options)
175 {
176  struct super_block *sb = mp->m_super;
177  char *this_char, *value, *eov;
178  int dsunit = 0;
179  int dswidth = 0;
180  int iosize = 0;
181  __uint8_t iosizelog = 0;
182 
183  /*
184  * set up the mount name first so all the errors will refer to the
185  * correct device.
186  */
187  mp->m_fsname = kstrndup(sb->s_id, MAXNAMELEN, GFP_KERNEL);
188  if (!mp->m_fsname)
189  return ENOMEM;
190  mp->m_fsname_len = strlen(mp->m_fsname) + 1;
191 
192  /*
193  * Copy binary VFS mount flags we are interested in.
194  */
195  if (sb->s_flags & MS_RDONLY)
196  mp->m_flags |= XFS_MOUNT_RDONLY;
197  if (sb->s_flags & MS_DIRSYNC)
198  mp->m_flags |= XFS_MOUNT_DIRSYNC;
199  if (sb->s_flags & MS_SYNCHRONOUS)
200  mp->m_flags |= XFS_MOUNT_WSYNC;
201 
202  /*
203  * Set some default flags that could be cleared by the mount option
204  * parsing.
205  */
206  mp->m_flags |= XFS_MOUNT_BARRIER;
207  mp->m_flags |= XFS_MOUNT_COMPAT_IOSIZE;
208 #if !XFS_BIG_INUMS
209  mp->m_flags |= XFS_MOUNT_SMALL_INUMS;
210 #endif
211 
212  /*
213  * These can be overridden by the mount option parsing.
214  */
215  mp->m_logbufs = -1;
216  mp->m_logbsize = -1;
217 
218  if (!options)
219  goto done;
220 
221  while ((this_char = strsep(&options, ",")) != NULL) {
222  if (!*this_char)
223  continue;
224  if ((value = strchr(this_char, '=')) != NULL)
225  *value++ = 0;
226 
227  if (!strcmp(this_char, MNTOPT_LOGBUFS)) {
228  if (!value || !*value) {
229  xfs_warn(mp, "%s option requires an argument",
230  this_char);
231  return EINVAL;
232  }
233  mp->m_logbufs = simple_strtoul(value, &eov, 10);
234  } else if (!strcmp(this_char, MNTOPT_LOGBSIZE)) {
235  if (!value || !*value) {
236  xfs_warn(mp, "%s option requires an argument",
237  this_char);
238  return EINVAL;
239  }
240  mp->m_logbsize = suffix_strtoul(value, &eov, 10);
241  } else if (!strcmp(this_char, MNTOPT_LOGDEV)) {
242  if (!value || !*value) {
243  xfs_warn(mp, "%s option requires an argument",
244  this_char);
245  return EINVAL;
246  }
247  mp->m_logname = kstrndup(value, MAXNAMELEN, GFP_KERNEL);
248  if (!mp->m_logname)
249  return ENOMEM;
250  } else if (!strcmp(this_char, MNTOPT_MTPT)) {
251  xfs_warn(mp, "%s option not allowed on this system",
252  this_char);
253  return EINVAL;
254  } else if (!strcmp(this_char, MNTOPT_RTDEV)) {
255  if (!value || !*value) {
256  xfs_warn(mp, "%s option requires an argument",
257  this_char);
258  return EINVAL;
259  }
260  mp->m_rtname = kstrndup(value, MAXNAMELEN, GFP_KERNEL);
261  if (!mp->m_rtname)
262  return ENOMEM;
263  } else if (!strcmp(this_char, MNTOPT_BIOSIZE)) {
264  if (!value || !*value) {
265  xfs_warn(mp, "%s option requires an argument",
266  this_char);
267  return EINVAL;
268  }
269  iosize = simple_strtoul(value, &eov, 10);
270  iosizelog = ffs(iosize) - 1;
271  } else if (!strcmp(this_char, MNTOPT_ALLOCSIZE)) {
272  if (!value || !*value) {
273  xfs_warn(mp, "%s option requires an argument",
274  this_char);
275  return EINVAL;
276  }
277  iosize = suffix_strtoul(value, &eov, 10);
278  iosizelog = ffs(iosize) - 1;
279  } else if (!strcmp(this_char, MNTOPT_GRPID) ||
280  !strcmp(this_char, MNTOPT_BSDGROUPS)) {
281  mp->m_flags |= XFS_MOUNT_GRPID;
282  } else if (!strcmp(this_char, MNTOPT_NOGRPID) ||
283  !strcmp(this_char, MNTOPT_SYSVGROUPS)) {
284  mp->m_flags &= ~XFS_MOUNT_GRPID;
285  } else if (!strcmp(this_char, MNTOPT_WSYNC)) {
286  mp->m_flags |= XFS_MOUNT_WSYNC;
287  } else if (!strcmp(this_char, MNTOPT_NORECOVERY)) {
288  mp->m_flags |= XFS_MOUNT_NORECOVERY;
289  } else if (!strcmp(this_char, MNTOPT_NOALIGN)) {
290  mp->m_flags |= XFS_MOUNT_NOALIGN;
291  } else if (!strcmp(this_char, MNTOPT_SWALLOC)) {
292  mp->m_flags |= XFS_MOUNT_SWALLOC;
293  } else if (!strcmp(this_char, MNTOPT_SUNIT)) {
294  if (!value || !*value) {
295  xfs_warn(mp, "%s option requires an argument",
296  this_char);
297  return EINVAL;
298  }
299  dsunit = simple_strtoul(value, &eov, 10);
300  } else if (!strcmp(this_char, MNTOPT_SWIDTH)) {
301  if (!value || !*value) {
302  xfs_warn(mp, "%s option requires an argument",
303  this_char);
304  return EINVAL;
305  }
306  dswidth = simple_strtoul(value, &eov, 10);
307  } else if (!strcmp(this_char, MNTOPT_32BITINODE)) {
308  mp->m_flags |= XFS_MOUNT_SMALL_INUMS;
309  } else if (!strcmp(this_char, MNTOPT_64BITINODE)) {
310  mp->m_flags &= ~XFS_MOUNT_SMALL_INUMS;
311 #if !XFS_BIG_INUMS
312  xfs_warn(mp, "%s option not allowed on this system",
313  this_char);
314  return EINVAL;
315 #endif
316  } else if (!strcmp(this_char, MNTOPT_NOUUID)) {
317  mp->m_flags |= XFS_MOUNT_NOUUID;
318  } else if (!strcmp(this_char, MNTOPT_BARRIER)) {
319  mp->m_flags |= XFS_MOUNT_BARRIER;
320  } else if (!strcmp(this_char, MNTOPT_NOBARRIER)) {
321  mp->m_flags &= ~XFS_MOUNT_BARRIER;
322  } else if (!strcmp(this_char, MNTOPT_IKEEP)) {
323  mp->m_flags |= XFS_MOUNT_IKEEP;
324  } else if (!strcmp(this_char, MNTOPT_NOIKEEP)) {
325  mp->m_flags &= ~XFS_MOUNT_IKEEP;
326  } else if (!strcmp(this_char, MNTOPT_LARGEIO)) {
327  mp->m_flags &= ~XFS_MOUNT_COMPAT_IOSIZE;
328  } else if (!strcmp(this_char, MNTOPT_NOLARGEIO)) {
329  mp->m_flags |= XFS_MOUNT_COMPAT_IOSIZE;
330  } else if (!strcmp(this_char, MNTOPT_ATTR2)) {
331  mp->m_flags |= XFS_MOUNT_ATTR2;
332  } else if (!strcmp(this_char, MNTOPT_NOATTR2)) {
333  mp->m_flags &= ~XFS_MOUNT_ATTR2;
334  mp->m_flags |= XFS_MOUNT_NOATTR2;
335  } else if (!strcmp(this_char, MNTOPT_FILESTREAM)) {
336  mp->m_flags |= XFS_MOUNT_FILESTREAMS;
337  } else if (!strcmp(this_char, MNTOPT_NOQUOTA)) {
338  mp->m_qflags &= ~XFS_ALL_QUOTA_ACCT;
339  mp->m_qflags &= ~XFS_ALL_QUOTA_ENFD;
340  mp->m_qflags &= ~XFS_ALL_QUOTA_ACTIVE;
341  } else if (!strcmp(this_char, MNTOPT_QUOTA) ||
342  !strcmp(this_char, MNTOPT_UQUOTA) ||
343  !strcmp(this_char, MNTOPT_USRQUOTA)) {
344  mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ACTIVE |
345  XFS_UQUOTA_ENFD);
346  } else if (!strcmp(this_char, MNTOPT_QUOTANOENF) ||
347  !strcmp(this_char, MNTOPT_UQUOTANOENF)) {
348  mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ACTIVE);
349  mp->m_qflags &= ~XFS_UQUOTA_ENFD;
350  } else if (!strcmp(this_char, MNTOPT_PQUOTA) ||
351  !strcmp(this_char, MNTOPT_PRJQUOTA)) {
352  mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE |
353  XFS_OQUOTA_ENFD);
354  } else if (!strcmp(this_char, MNTOPT_PQUOTANOENF)) {
355  mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE);
356  mp->m_qflags &= ~XFS_OQUOTA_ENFD;
357  } else if (!strcmp(this_char, MNTOPT_GQUOTA) ||
358  !strcmp(this_char, MNTOPT_GRPQUOTA)) {
359  mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE |
360  XFS_OQUOTA_ENFD);
361  } else if (!strcmp(this_char, MNTOPT_GQUOTANOENF)) {
362  mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE);
363  mp->m_qflags &= ~XFS_OQUOTA_ENFD;
364  } else if (!strcmp(this_char, MNTOPT_DELAYLOG)) {
365  xfs_warn(mp,
366  "delaylog is the default now, option is deprecated.");
367  } else if (!strcmp(this_char, MNTOPT_NODELAYLOG)) {
368  xfs_warn(mp,
369  "nodelaylog support has been removed, option is deprecated.");
370  } else if (!strcmp(this_char, MNTOPT_DISCARD)) {
371  mp->m_flags |= XFS_MOUNT_DISCARD;
372  } else if (!strcmp(this_char, MNTOPT_NODISCARD)) {
373  mp->m_flags &= ~XFS_MOUNT_DISCARD;
374  } else if (!strcmp(this_char, "ihashsize")) {
375  xfs_warn(mp,
376  "ihashsize no longer used, option is deprecated.");
377  } else if (!strcmp(this_char, "osyncisdsync")) {
378  xfs_warn(mp,
379  "osyncisdsync has no effect, option is deprecated.");
380  } else if (!strcmp(this_char, "osyncisosync")) {
381  xfs_warn(mp,
382  "osyncisosync has no effect, option is deprecated.");
383  } else if (!strcmp(this_char, "irixsgid")) {
384  xfs_warn(mp,
385  "irixsgid is now a sysctl(2) variable, option is deprecated.");
386  } else {
387  xfs_warn(mp, "unknown mount option [%s].", this_char);
388  return EINVAL;
389  }
390  }
391 
392  /*
393  * no recovery flag requires a read-only mount
394  */
395  if ((mp->m_flags & XFS_MOUNT_NORECOVERY) &&
396  !(mp->m_flags & XFS_MOUNT_RDONLY)) {
397  xfs_warn(mp, "no-recovery mounts must be read-only.");
398  return EINVAL;
399  }
400 
401  if ((mp->m_flags & XFS_MOUNT_NOALIGN) && (dsunit || dswidth)) {
402  xfs_warn(mp,
403  "sunit and swidth options incompatible with the noalign option");
404  return EINVAL;
405  }
406 
407 #ifndef CONFIG_XFS_QUOTA
408  if (XFS_IS_QUOTA_RUNNING(mp)) {
409  xfs_warn(mp, "quota support not available in this kernel.");
410  return EINVAL;
411  }
412 #endif
413 
414  if ((mp->m_qflags & (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE)) &&
415  (mp->m_qflags & (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE))) {
416  xfs_warn(mp, "cannot mount with both project and group quota");
417  return EINVAL;
418  }
419 
420  if ((dsunit && !dswidth) || (!dsunit && dswidth)) {
421  xfs_warn(mp, "sunit and swidth must be specified together");
422  return EINVAL;
423  }
424 
425  if (dsunit && (dswidth % dsunit != 0)) {
426  xfs_warn(mp,
427  "stripe width (%d) must be a multiple of the stripe unit (%d)",
428  dswidth, dsunit);
429  return EINVAL;
430  }
431 
432 done:
433  if (!(mp->m_flags & XFS_MOUNT_NOALIGN)) {
434  /*
435  * At this point the superblock has not been read
436  * in, therefore we do not know the block size.
437  * Before the mount call ends we will convert
438  * these to FSBs.
439  */
440  if (dsunit) {
441  mp->m_dalign = dsunit;
442  mp->m_flags |= XFS_MOUNT_RETERR;
443  }
444 
445  if (dswidth)
446  mp->m_swidth = dswidth;
447  }
448 
449  if (mp->m_logbufs != -1 &&
450  mp->m_logbufs != 0 &&
451  (mp->m_logbufs < XLOG_MIN_ICLOGS ||
452  mp->m_logbufs > XLOG_MAX_ICLOGS)) {
453  xfs_warn(mp, "invalid logbufs value: %d [not %d-%d]",
454  mp->m_logbufs, XLOG_MIN_ICLOGS, XLOG_MAX_ICLOGS);
455  return XFS_ERROR(EINVAL);
456  }
457  if (mp->m_logbsize != -1 &&
458  mp->m_logbsize != 0 &&
459  (mp->m_logbsize < XLOG_MIN_RECORD_BSIZE ||
460  mp->m_logbsize > XLOG_MAX_RECORD_BSIZE ||
461  !is_power_of_2(mp->m_logbsize))) {
462  xfs_warn(mp,
463  "invalid logbufsize: %d [not 16k,32k,64k,128k or 256k]",
464  mp->m_logbsize);
465  return XFS_ERROR(EINVAL);
466  }
467 
468  if (iosizelog) {
469  if (iosizelog > XFS_MAX_IO_LOG ||
470  iosizelog < XFS_MIN_IO_LOG) {
471  xfs_warn(mp, "invalid log iosize: %d [not %d-%d]",
472  iosizelog, XFS_MIN_IO_LOG,
473  XFS_MAX_IO_LOG);
474  return XFS_ERROR(EINVAL);
475  }
476 
477  mp->m_flags |= XFS_MOUNT_DFLT_IOSIZE;
478  mp->m_readio_log = iosizelog;
479  mp->m_writeio_log = iosizelog;
480  }
481 
482  return 0;
483 }
484 
485 struct proc_xfs_info {
486  int flag;
487  char *str;
488 };
489 
490 STATIC int
491 xfs_showargs(
492  struct xfs_mount *mp,
493  struct seq_file *m)
494 {
495  static struct proc_xfs_info xfs_info_set[] = {
496  /* the few simple ones we can get from the mount struct */
497  { XFS_MOUNT_IKEEP, "," MNTOPT_IKEEP },
498  { XFS_MOUNT_WSYNC, "," MNTOPT_WSYNC },
499  { XFS_MOUNT_NOALIGN, "," MNTOPT_NOALIGN },
500  { XFS_MOUNT_SWALLOC, "," MNTOPT_SWALLOC },
501  { XFS_MOUNT_NOUUID, "," MNTOPT_NOUUID },
502  { XFS_MOUNT_NORECOVERY, "," MNTOPT_NORECOVERY },
503  { XFS_MOUNT_ATTR2, "," MNTOPT_ATTR2 },
504  { XFS_MOUNT_FILESTREAMS, "," MNTOPT_FILESTREAM },
505  { XFS_MOUNT_GRPID, "," MNTOPT_GRPID },
506  { XFS_MOUNT_DISCARD, "," MNTOPT_DISCARD },
507  { XFS_MOUNT_SMALL_INUMS, "," MNTOPT_32BITINODE },
508  { 0, NULL }
509  };
510  static struct proc_xfs_info xfs_info_unset[] = {
511  /* the few simple ones we can get from the mount struct */
512  { XFS_MOUNT_COMPAT_IOSIZE, "," MNTOPT_LARGEIO },
513  { XFS_MOUNT_BARRIER, "," MNTOPT_NOBARRIER },
514  { XFS_MOUNT_SMALL_INUMS, "," MNTOPT_64BITINODE },
515  { 0, NULL }
516  };
517  struct proc_xfs_info *xfs_infop;
518 
519  for (xfs_infop = xfs_info_set; xfs_infop->flag; xfs_infop++) {
520  if (mp->m_flags & xfs_infop->flag)
521  seq_puts(m, xfs_infop->str);
522  }
523  for (xfs_infop = xfs_info_unset; xfs_infop->flag; xfs_infop++) {
524  if (!(mp->m_flags & xfs_infop->flag))
525  seq_puts(m, xfs_infop->str);
526  }
527 
528  if (mp->m_flags & XFS_MOUNT_DFLT_IOSIZE)
529  seq_printf(m, "," MNTOPT_ALLOCSIZE "=%dk",
530  (int)(1 << mp->m_writeio_log) >> 10);
531 
532  if (mp->m_logbufs > 0)
533  seq_printf(m, "," MNTOPT_LOGBUFS "=%d", mp->m_logbufs);
534  if (mp->m_logbsize > 0)
535  seq_printf(m, "," MNTOPT_LOGBSIZE "=%dk", mp->m_logbsize >> 10);
536 
537  if (mp->m_logname)
538  seq_printf(m, "," MNTOPT_LOGDEV "=%s", mp->m_logname);
539  if (mp->m_rtname)
540  seq_printf(m, "," MNTOPT_RTDEV "=%s", mp->m_rtname);
541 
542  if (mp->m_dalign > 0)
543  seq_printf(m, "," MNTOPT_SUNIT "=%d",
544  (int)XFS_FSB_TO_BB(mp, mp->m_dalign));
545  if (mp->m_swidth > 0)
546  seq_printf(m, "," MNTOPT_SWIDTH "=%d",
547  (int)XFS_FSB_TO_BB(mp, mp->m_swidth));
548 
549  if (mp->m_qflags & (XFS_UQUOTA_ACCT|XFS_UQUOTA_ENFD))
550  seq_puts(m, "," MNTOPT_USRQUOTA);
551  else if (mp->m_qflags & XFS_UQUOTA_ACCT)
552  seq_puts(m, "," MNTOPT_UQUOTANOENF);
553 
554  /* Either project or group quotas can be active, not both */
555 
556  if (mp->m_qflags & XFS_PQUOTA_ACCT) {
557  if (mp->m_qflags & XFS_OQUOTA_ENFD)
558  seq_puts(m, "," MNTOPT_PRJQUOTA);
559  else
560  seq_puts(m, "," MNTOPT_PQUOTANOENF);
561  } else if (mp->m_qflags & XFS_GQUOTA_ACCT) {
562  if (mp->m_qflags & XFS_OQUOTA_ENFD)
563  seq_puts(m, "," MNTOPT_GRPQUOTA);
564  else
565  seq_puts(m, "," MNTOPT_GQUOTANOENF);
566  }
567 
568  if (!(mp->m_qflags & XFS_ALL_QUOTA_ACCT))
569  seq_puts(m, "," MNTOPT_NOQUOTA);
570 
571  return 0;
572 }
573 __uint64_t
574 xfs_max_file_offset(
575  unsigned int blockshift)
576 {
577  unsigned int pagefactor = 1;
578  unsigned int bitshift = BITS_PER_LONG - 1;
579 
580  /* Figure out maximum filesize, on Linux this can depend on
581  * the filesystem blocksize (on 32 bit platforms).
582  * __block_write_begin does this in an [unsigned] long...
583  * page->index << (PAGE_CACHE_SHIFT - bbits)
584  * So, for page sized blocks (4K on 32 bit platforms),
585  * this wraps at around 8Tb (hence MAX_LFS_FILESIZE which is
586  * (((u64)PAGE_CACHE_SIZE << (BITS_PER_LONG-1))-1)
587  * but for smaller blocksizes it is less (bbits = log2 bsize).
588  * Note1: get_block_t takes a long (implicit cast from above)
589  * Note2: The Large Block Device (LBD and HAVE_SECTOR_T) patch
590  * can optionally convert the [unsigned] long from above into
591  * an [unsigned] long long.
592  */
593 
594 #if BITS_PER_LONG == 32
595 # if defined(CONFIG_LBDAF)
596  ASSERT(sizeof(sector_t) == 8);
597  pagefactor = PAGE_CACHE_SIZE;
598  bitshift = BITS_PER_LONG;
599 # else
600  pagefactor = PAGE_CACHE_SIZE >> (PAGE_CACHE_SHIFT - blockshift);
601 # endif
602 #endif
603 
604  return (((__uint64_t)pagefactor) << bitshift) - 1;
605 }
606 
607 xfs_agnumber_t
608 xfs_set_inode32(struct xfs_mount *mp)
609 {
610  xfs_agnumber_t index = 0;
611  xfs_agnumber_t maxagi = 0;
612  xfs_sb_t *sbp = &mp->m_sb;
613  xfs_agnumber_t max_metadata;
614  xfs_agino_t agino = XFS_OFFBNO_TO_AGINO(mp, sbp->sb_agblocks -1, 0);
615  xfs_ino_t ino = XFS_AGINO_TO_INO(mp, sbp->sb_agcount -1, agino);
616  xfs_perag_t *pag;
617 
618  /* Calculate how much should be reserved for inodes to meet
619  * the max inode percentage.
620  */
621  if (mp->m_maxicount) {
622  __uint64_t icount;
623 
624  icount = sbp->sb_dblocks * sbp->sb_imax_pct;
625  do_div(icount, 100);
626  icount += sbp->sb_agblocks - 1;
627  do_div(icount, sbp->sb_agblocks);
628  max_metadata = icount;
629  } else {
630  max_metadata = sbp->sb_agcount;
631  }
632 
633  for (index = 0; index < sbp->sb_agcount; index++) {
634  ino = XFS_AGINO_TO_INO(mp, index, agino);
635 
636  if (ino > XFS_MAXINUMBER_32) {
637  pag = xfs_perag_get(mp, index);
638  pag->pagi_inodeok = 0;
639  pag->pagf_metadata = 0;
640  xfs_perag_put(pag);
641  continue;
642  }
643 
644  pag = xfs_perag_get(mp, index);
645  pag->pagi_inodeok = 1;
646  maxagi++;
647  if (index < max_metadata)
648  pag->pagf_metadata = 1;
649  xfs_perag_put(pag);
650  }
651  mp->m_flags |= (XFS_MOUNT_32BITINODES |
652  XFS_MOUNT_SMALL_INUMS);
653 
654  return maxagi;
655 }
656 
657 xfs_agnumber_t
658 xfs_set_inode64(struct xfs_mount *mp)
659 {
660  xfs_agnumber_t index = 0;
661 
662  for (index = 0; index < mp->m_sb.sb_agcount; index++) {
663  struct xfs_perag *pag;
664 
665  pag = xfs_perag_get(mp, index);
666  pag->pagi_inodeok = 1;
667  pag->pagf_metadata = 0;
668  xfs_perag_put(pag);
669  }
670 
671  /* There is no need for lock protection on m_flags,
672  * the rw_semaphore of the VFS superblock is locked
673  * during mount/umount/remount operations, so this is
674  * enough to avoid concurency on the m_flags field
675  */
676  mp->m_flags &= ~(XFS_MOUNT_32BITINODES |
677  XFS_MOUNT_SMALL_INUMS);
678  return index;
679 }
680 
681 STATIC int
682 xfs_blkdev_get(
683  xfs_mount_t *mp,
684  const char *name,
685  struct block_device **bdevp)
686 {
687  int error = 0;
688 
689  *bdevp = blkdev_get_by_path(name, FMODE_READ|FMODE_WRITE|FMODE_EXCL,
690  mp);
691  if (IS_ERR(*bdevp)) {
692  error = PTR_ERR(*bdevp);
693  xfs_warn(mp, "Invalid device [%s], error=%d\n", name, error);
694  }
695 
696  return -error;
697 }
698 
699 STATIC void
700 xfs_blkdev_put(
701  struct block_device *bdev)
702 {
703  if (bdev)
704  blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL);
705 }
706 
707 void
708 xfs_blkdev_issue_flush(
709  xfs_buftarg_t *buftarg)
710 {
711  blkdev_issue_flush(buftarg->bt_bdev, GFP_NOFS, NULL);
712 }
713 
714 STATIC void
715 xfs_close_devices(
716  struct xfs_mount *mp)
717 {
718  if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp) {
719  struct block_device *logdev = mp->m_logdev_targp->bt_bdev;
720  xfs_free_buftarg(mp, mp->m_logdev_targp);
721  xfs_blkdev_put(logdev);
722  }
723  if (mp->m_rtdev_targp) {
724  struct block_device *rtdev = mp->m_rtdev_targp->bt_bdev;
725  xfs_free_buftarg(mp, mp->m_rtdev_targp);
726  xfs_blkdev_put(rtdev);
727  }
728  xfs_free_buftarg(mp, mp->m_ddev_targp);
729 }
730 
731 /*
732  * The file system configurations are:
733  * (1) device (partition) with data and internal log
734  * (2) logical volume with data and log subvolumes.
735  * (3) logical volume with data, log, and realtime subvolumes.
736  *
737  * We only have to handle opening the log and realtime volumes here if
738  * they are present. The data subvolume has already been opened by
739  * get_sb_bdev() and is stored in sb->s_bdev.
740  */
741 STATIC int
742 xfs_open_devices(
743  struct xfs_mount *mp)
744 {
745  struct block_device *ddev = mp->m_super->s_bdev;
746  struct block_device *logdev = NULL, *rtdev = NULL;
747  int error;
748 
749  /*
750  * Open real time and log devices - order is important.
751  */
752  if (mp->m_logname) {
753  error = xfs_blkdev_get(mp, mp->m_logname, &logdev);
754  if (error)
755  goto out;
756  }
757 
758  if (mp->m_rtname) {
759  error = xfs_blkdev_get(mp, mp->m_rtname, &rtdev);
760  if (error)
761  goto out_close_logdev;
762 
763  if (rtdev == ddev || rtdev == logdev) {
764  xfs_warn(mp,
765  "Cannot mount filesystem with identical rtdev and ddev/logdev.");
766  error = EINVAL;
767  goto out_close_rtdev;
768  }
769  }
770 
771  /*
772  * Setup xfs_mount buffer target pointers
773  */
774  error = ENOMEM;
775  mp->m_ddev_targp = xfs_alloc_buftarg(mp, ddev, 0, mp->m_fsname);
776  if (!mp->m_ddev_targp)
777  goto out_close_rtdev;
778 
779  if (rtdev) {
780  mp->m_rtdev_targp = xfs_alloc_buftarg(mp, rtdev, 1,
781  mp->m_fsname);
782  if (!mp->m_rtdev_targp)
783  goto out_free_ddev_targ;
784  }
785 
786  if (logdev && logdev != ddev) {
787  mp->m_logdev_targp = xfs_alloc_buftarg(mp, logdev, 1,
788  mp->m_fsname);
789  if (!mp->m_logdev_targp)
790  goto out_free_rtdev_targ;
791  } else {
792  mp->m_logdev_targp = mp->m_ddev_targp;
793  }
794 
795  return 0;
796 
797  out_free_rtdev_targ:
798  if (mp->m_rtdev_targp)
799  xfs_free_buftarg(mp, mp->m_rtdev_targp);
800  out_free_ddev_targ:
801  xfs_free_buftarg(mp, mp->m_ddev_targp);
802  out_close_rtdev:
803  if (rtdev)
804  xfs_blkdev_put(rtdev);
805  out_close_logdev:
806  if (logdev && logdev != ddev)
807  xfs_blkdev_put(logdev);
808  out:
809  return error;
810 }
811 
812 /*
813  * Setup xfs_mount buffer target pointers based on superblock
814  */
815 STATIC int
816 xfs_setup_devices(
817  struct xfs_mount *mp)
818 {
819  int error;
820 
821  error = xfs_setsize_buftarg(mp->m_ddev_targp, mp->m_sb.sb_blocksize,
822  mp->m_sb.sb_sectsize);
823  if (error)
824  return error;
825 
826  if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp) {
827  unsigned int log_sector_size = BBSIZE;
828 
829  if (xfs_sb_version_hassector(&mp->m_sb))
830  log_sector_size = mp->m_sb.sb_logsectsize;
831  error = xfs_setsize_buftarg(mp->m_logdev_targp,
832  mp->m_sb.sb_blocksize,
833  log_sector_size);
834  if (error)
835  return error;
836  }
837  if (mp->m_rtdev_targp) {
838  error = xfs_setsize_buftarg(mp->m_rtdev_targp,
839  mp->m_sb.sb_blocksize,
840  mp->m_sb.sb_sectsize);
841  if (error)
842  return error;
843  }
844 
845  return 0;
846 }
847 
848 STATIC int
849 xfs_init_mount_workqueues(
850  struct xfs_mount *mp)
851 {
852  mp->m_data_workqueue = alloc_workqueue("xfs-data/%s",
853  WQ_MEM_RECLAIM, 0, mp->m_fsname);
854  if (!mp->m_data_workqueue)
855  goto out;
856 
857  mp->m_unwritten_workqueue = alloc_workqueue("xfs-conv/%s",
858  WQ_MEM_RECLAIM, 0, mp->m_fsname);
859  if (!mp->m_unwritten_workqueue)
860  goto out_destroy_data_iodone_queue;
861 
862  mp->m_cil_workqueue = alloc_workqueue("xfs-cil/%s",
863  WQ_MEM_RECLAIM, 0, mp->m_fsname);
864  if (!mp->m_cil_workqueue)
865  goto out_destroy_unwritten;
866  return 0;
867 
868 out_destroy_unwritten:
869  destroy_workqueue(mp->m_unwritten_workqueue);
870 out_destroy_data_iodone_queue:
871  destroy_workqueue(mp->m_data_workqueue);
872 out:
873  return -ENOMEM;
874 }
875 
876 STATIC void
877 xfs_destroy_mount_workqueues(
878  struct xfs_mount *mp)
879 {
880  destroy_workqueue(mp->m_cil_workqueue);
881  destroy_workqueue(mp->m_data_workqueue);
882  destroy_workqueue(mp->m_unwritten_workqueue);
883 }
884 
885 /* Catch misguided souls that try to use this interface on XFS */
886 STATIC struct inode *
887 xfs_fs_alloc_inode(
888  struct super_block *sb)
889 {
890  BUG();
891  return NULL;
892 }
893 
894 /*
895  * Now that the generic code is guaranteed not to be accessing
896  * the linux inode, we can reclaim the inode.
897  */
898 STATIC void
899 xfs_fs_destroy_inode(
900  struct inode *inode)
901 {
902  struct xfs_inode *ip = XFS_I(inode);
903 
904  trace_xfs_destroy_inode(ip);
905 
906  XFS_STATS_INC(vn_reclaim);
907 
908  /* bad inode, get out here ASAP */
909  if (is_bad_inode(inode))
910  goto out_reclaim;
911 
912  ASSERT(XFS_FORCED_SHUTDOWN(ip->i_mount) || ip->i_delayed_blks == 0);
913 
914  /*
915  * We should never get here with one of the reclaim flags already set.
916  */
917  ASSERT_ALWAYS(!xfs_iflags_test(ip, XFS_IRECLAIMABLE));
918  ASSERT_ALWAYS(!xfs_iflags_test(ip, XFS_IRECLAIM));
919 
920  /*
921  * We always use background reclaim here because even if the
922  * inode is clean, it still may be under IO and hence we have
923  * to take the flush lock. The background reclaim path handles
924  * this more efficiently than we can here, so simply let background
925  * reclaim tear down all inodes.
926  */
927 out_reclaim:
928  xfs_inode_set_reclaim_tag(ip);
929 }
930 
931 /*
932  * Slab object creation initialisation for the XFS inode.
933  * This covers only the idempotent fields in the XFS inode;
934  * all other fields need to be initialised on allocation
935  * from the slab. This avoids the need to repeatedly initialise
936  * fields in the xfs inode that left in the initialise state
937  * when freeing the inode.
938  */
939 STATIC void
940 xfs_fs_inode_init_once(
941  void *inode)
942 {
943  struct xfs_inode *ip = inode;
944 
945  memset(ip, 0, sizeof(struct xfs_inode));
946 
947  /* vfs inode */
948  inode_init_once(VFS_I(ip));
949 
950  /* xfs inode */
951  atomic_set(&ip->i_pincount, 0);
952  spin_lock_init(&ip->i_flags_lock);
953 
954  mrlock_init(&ip->i_lock, MRLOCK_ALLOW_EQUAL_PRI|MRLOCK_BARRIER,
955  "xfsino", ip->i_ino);
956 }
957 
958 STATIC void
959 xfs_fs_evict_inode(
960  struct inode *inode)
961 {
962  xfs_inode_t *ip = XFS_I(inode);
963 
964  ASSERT(!rwsem_is_locked(&ip->i_iolock.mr_lock));
965 
966  trace_xfs_evict_inode(ip);
967 
968  truncate_inode_pages(&inode->i_data, 0);
969  clear_inode(inode);
970  XFS_STATS_INC(vn_rele);
971  XFS_STATS_INC(vn_remove);
972  XFS_STATS_DEC(vn_active);
973 
974  xfs_inactive(ip);
975 }
976 
977 /*
978  * We do an unlocked check for XFS_IDONTCACHE here because we are already
979  * serialised against cache hits here via the inode->i_lock and igrab() in
980  * xfs_iget_cache_hit(). Hence a lookup that might clear this flag will not be
981  * racing with us, and it avoids needing to grab a spinlock here for every inode
982  * we drop the final reference on.
983  */
984 STATIC int
985 xfs_fs_drop_inode(
986  struct inode *inode)
987 {
988  struct xfs_inode *ip = XFS_I(inode);
989 
990  return generic_drop_inode(inode) || (ip->i_flags & XFS_IDONTCACHE);
991 }
992 
993 STATIC void
994 xfs_free_fsname(
995  struct xfs_mount *mp)
996 {
997  kfree(mp->m_fsname);
998  kfree(mp->m_rtname);
999  kfree(mp->m_logname);
1000 }
1001 
1002 STATIC void
1003 xfs_fs_put_super(
1004  struct super_block *sb)
1005 {
1006  struct xfs_mount *mp = XFS_M(sb);
1007 
1008  xfs_filestream_unmount(mp);
1009  cancel_delayed_work_sync(&mp->m_sync_work);
1010  xfs_unmountfs(mp);
1011  xfs_syncd_stop(mp);
1012  xfs_freesb(mp);
1013  xfs_icsb_destroy_counters(mp);
1014  xfs_destroy_mount_workqueues(mp);
1015  xfs_close_devices(mp);
1016  xfs_free_fsname(mp);
1017  kfree(mp);
1018 }
1019 
1020 STATIC int
1021 xfs_fs_sync_fs(
1022  struct super_block *sb,
1023  int wait)
1024 {
1025  struct xfs_mount *mp = XFS_M(sb);
1026  int error;
1027 
1028  /*
1029  * Doing anything during the async pass would be counterproductive.
1030  */
1031  if (!wait)
1032  return 0;
1033 
1034  error = xfs_quiesce_data(mp);
1035  if (error)
1036  return -error;
1037 
1038  if (laptop_mode) {
1039  /*
1040  * The disk must be active because we're syncing.
1041  * We schedule xfssyncd now (now that the disk is
1042  * active) instead of later (when it might not be).
1043  */
1044  flush_delayed_work(&mp->m_sync_work);
1045  }
1046 
1047  return 0;
1048 }
1049 
1050 STATIC int
1051 xfs_fs_statfs(
1052  struct dentry *dentry,
1053  struct kstatfs *statp)
1054 {
1055  struct xfs_mount *mp = XFS_M(dentry->d_sb);
1056  xfs_sb_t *sbp = &mp->m_sb;
1057  struct xfs_inode *ip = XFS_I(dentry->d_inode);
1058  __uint64_t fakeinos, id;
1059  xfs_extlen_t lsize;
1060  __int64_t ffree;
1061 
1062  statp->f_type = XFS_SB_MAGIC;
1063  statp->f_namelen = MAXNAMELEN - 1;
1064 
1065  id = huge_encode_dev(mp->m_ddev_targp->bt_dev);
1066  statp->f_fsid.val[0] = (u32)id;
1067  statp->f_fsid.val[1] = (u32)(id >> 32);
1068 
1069  xfs_icsb_sync_counters(mp, XFS_ICSB_LAZY_COUNT);
1070 
1071  spin_lock(&mp->m_sb_lock);
1072  statp->f_bsize = sbp->sb_blocksize;
1073  lsize = sbp->sb_logstart ? sbp->sb_logblocks : 0;
1074  statp->f_blocks = sbp->sb_dblocks - lsize;
1075  statp->f_bfree = statp->f_bavail =
1076  sbp->sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
1077  fakeinos = statp->f_bfree << sbp->sb_inopblog;
1078  statp->f_files =
1079  MIN(sbp->sb_icount + fakeinos, (__uint64_t)XFS_MAXINUMBER);
1080  if (mp->m_maxicount)
1081  statp->f_files = min_t(typeof(statp->f_files),
1082  statp->f_files,
1083  mp->m_maxicount);
1084 
1085  /* make sure statp->f_ffree does not underflow */
1086  ffree = statp->f_files - (sbp->sb_icount - sbp->sb_ifree);
1087  statp->f_ffree = max_t(__int64_t, ffree, 0);
1088 
1089  spin_unlock(&mp->m_sb_lock);
1090 
1091  if ((ip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
1092  ((mp->m_qflags & (XFS_PQUOTA_ACCT|XFS_OQUOTA_ENFD))) ==
1093  (XFS_PQUOTA_ACCT|XFS_OQUOTA_ENFD))
1094  xfs_qm_statvfs(ip, statp);
1095  return 0;
1096 }
1097 
1098 STATIC void
1099 xfs_save_resvblks(struct xfs_mount *mp)
1100 {
1101  __uint64_t resblks = 0;
1102 
1103  mp->m_resblks_save = mp->m_resblks;
1104  xfs_reserve_blocks(mp, &resblks, NULL);
1105 }
1106 
1107 STATIC void
1108 xfs_restore_resvblks(struct xfs_mount *mp)
1109 {
1110  __uint64_t resblks;
1111 
1112  if (mp->m_resblks_save) {
1113  resblks = mp->m_resblks_save;
1114  mp->m_resblks_save = 0;
1115  } else
1116  resblks = xfs_default_resblks(mp);
1117 
1118  xfs_reserve_blocks(mp, &resblks, NULL);
1119 }
1120 
1121 STATIC int
1122 xfs_fs_remount(
1123  struct super_block *sb,
1124  int *flags,
1125  char *options)
1126 {
1127  struct xfs_mount *mp = XFS_M(sb);
1128  substring_t args[MAX_OPT_ARGS];
1129  char *p;
1130  int error;
1131 
1132  while ((p = strsep(&options, ",")) != NULL) {
1133  int token;
1134 
1135  if (!*p)
1136  continue;
1137 
1138  token = match_token(p, tokens, args);
1139  switch (token) {
1140  case Opt_barrier:
1141  mp->m_flags |= XFS_MOUNT_BARRIER;
1142  break;
1143  case Opt_nobarrier:
1144  mp->m_flags &= ~XFS_MOUNT_BARRIER;
1145  break;
1146  case Opt_inode64:
1147  mp->m_maxagi = xfs_set_inode64(mp);
1148  break;
1149  case Opt_inode32:
1150  mp->m_maxagi = xfs_set_inode32(mp);
1151  break;
1152  default:
1153  /*
1154  * Logically we would return an error here to prevent
1155  * users from believing they might have changed
1156  * mount options using remount which can't be changed.
1157  *
1158  * But unfortunately mount(8) adds all options from
1159  * mtab and fstab to the mount arguments in some cases
1160  * so we can't blindly reject options, but have to
1161  * check for each specified option if it actually
1162  * differs from the currently set option and only
1163  * reject it if that's the case.
1164  *
1165  * Until that is implemented we return success for
1166  * every remount request, and silently ignore all
1167  * options that we can't actually change.
1168  */
1169 #if 0
1170  xfs_info(mp,
1171  "mount option \"%s\" not supported for remount\n", p);
1172  return -EINVAL;
1173 #else
1174  break;
1175 #endif
1176  }
1177  }
1178 
1179  /* ro -> rw */
1180  if ((mp->m_flags & XFS_MOUNT_RDONLY) && !(*flags & MS_RDONLY)) {
1181  mp->m_flags &= ~XFS_MOUNT_RDONLY;
1182 
1183  /*
1184  * If this is the first remount to writeable state we
1185  * might have some superblock changes to update.
1186  */
1187  if (mp->m_update_flags) {
1188  error = xfs_mount_log_sb(mp, mp->m_update_flags);
1189  if (error) {
1190  xfs_warn(mp, "failed to write sb changes");
1191  return error;
1192  }
1193  mp->m_update_flags = 0;
1194  }
1195 
1196  /*
1197  * Fill out the reserve pool if it is empty. Use the stashed
1198  * value if it is non-zero, otherwise go with the default.
1199  */
1200  xfs_restore_resvblks(mp);
1201  }
1202 
1203  /* rw -> ro */
1204  if (!(mp->m_flags & XFS_MOUNT_RDONLY) && (*flags & MS_RDONLY)) {
1205  /*
1206  * After we have synced the data but before we sync the
1207  * metadata, we need to free up the reserve block pool so that
1208  * the used block count in the superblock on disk is correct at
1209  * the end of the remount. Stash the current reserve pool size
1210  * so that if we get remounted rw, we can return it to the same
1211  * size.
1212  */
1213 
1214  xfs_quiesce_data(mp);
1215  xfs_save_resvblks(mp);
1216  xfs_quiesce_attr(mp);
1217  mp->m_flags |= XFS_MOUNT_RDONLY;
1218  }
1219 
1220  return 0;
1221 }
1222 
1223 /*
1224  * Second stage of a freeze. The data is already frozen so we only
1225  * need to take care of the metadata. Once that's done write a dummy
1226  * record to dirty the log in case of a crash while frozen.
1227  */
1228 STATIC int
1229 xfs_fs_freeze(
1230  struct super_block *sb)
1231 {
1232  struct xfs_mount *mp = XFS_M(sb);
1233 
1234  xfs_save_resvblks(mp);
1235  xfs_quiesce_attr(mp);
1236  return -xfs_fs_log_dummy(mp);
1237 }
1238 
1239 STATIC int
1240 xfs_fs_unfreeze(
1241  struct super_block *sb)
1242 {
1243  struct xfs_mount *mp = XFS_M(sb);
1244 
1245  xfs_restore_resvblks(mp);
1246  return 0;
1247 }
1248 
1249 STATIC int
1250 xfs_fs_show_options(
1251  struct seq_file *m,
1252  struct dentry *root)
1253 {
1254  return -xfs_showargs(XFS_M(root->d_sb), m);
1255 }
1256 
1257 /*
1258  * This function fills in xfs_mount_t fields based on mount args.
1259  * Note: the superblock _has_ now been read in.
1260  */
1261 STATIC int
1262 xfs_finish_flags(
1263  struct xfs_mount *mp)
1264 {
1265  int ronly = (mp->m_flags & XFS_MOUNT_RDONLY);
1266 
1267  /* Fail a mount where the logbuf is smaller than the log stripe */
1268  if (xfs_sb_version_haslogv2(&mp->m_sb)) {
1269  if (mp->m_logbsize <= 0 &&
1270  mp->m_sb.sb_logsunit > XLOG_BIG_RECORD_BSIZE) {
1271  mp->m_logbsize = mp->m_sb.sb_logsunit;
1272  } else if (mp->m_logbsize > 0 &&
1273  mp->m_logbsize < mp->m_sb.sb_logsunit) {
1274  xfs_warn(mp,
1275  "logbuf size must be greater than or equal to log stripe size");
1276  return XFS_ERROR(EINVAL);
1277  }
1278  } else {
1279  /* Fail a mount if the logbuf is larger than 32K */
1280  if (mp->m_logbsize > XLOG_BIG_RECORD_BSIZE) {
1281  xfs_warn(mp,
1282  "logbuf size for version 1 logs must be 16K or 32K");
1283  return XFS_ERROR(EINVAL);
1284  }
1285  }
1286 
1287  /*
1288  * mkfs'ed attr2 will turn on attr2 mount unless explicitly
1289  * told by noattr2 to turn it off
1290  */
1291  if (xfs_sb_version_hasattr2(&mp->m_sb) &&
1292  !(mp->m_flags & XFS_MOUNT_NOATTR2))
1293  mp->m_flags |= XFS_MOUNT_ATTR2;
1294 
1295  /*
1296  * prohibit r/w mounts of read-only filesystems
1297  */
1298  if ((mp->m_sb.sb_flags & XFS_SBF_READONLY) && !ronly) {
1299  xfs_warn(mp,
1300  "cannot mount a read-only filesystem as read-write");
1301  return XFS_ERROR(EROFS);
1302  }
1303 
1304  return 0;
1305 }
1306 
1307 STATIC int
1308 xfs_fs_fill_super(
1309  struct super_block *sb,
1310  void *data,
1311  int silent)
1312 {
1313  struct inode *root;
1314  struct xfs_mount *mp = NULL;
1315  int flags = 0, error = ENOMEM;
1316 
1317  mp = kzalloc(sizeof(struct xfs_mount), GFP_KERNEL);
1318  if (!mp)
1319  goto out;
1320 
1321  spin_lock_init(&mp->m_sb_lock);
1322  mutex_init(&mp->m_growlock);
1323  atomic_set(&mp->m_active_trans, 0);
1324 
1325  mp->m_super = sb;
1326  sb->s_fs_info = mp;
1327 
1328  error = xfs_parseargs(mp, (char *)data);
1329  if (error)
1330  goto out_free_fsname;
1331 
1332  sb_min_blocksize(sb, BBSIZE);
1333  sb->s_xattr = xfs_xattr_handlers;
1334  sb->s_export_op = &xfs_export_operations;
1335 #ifdef CONFIG_XFS_QUOTA
1336  sb->s_qcop = &xfs_quotactl_operations;
1337 #endif
1338  sb->s_op = &xfs_super_operations;
1339 
1340  if (silent)
1341  flags |= XFS_MFSI_QUIET;
1342 
1343  error = xfs_open_devices(mp);
1344  if (error)
1345  goto out_free_fsname;
1346 
1347  error = xfs_init_mount_workqueues(mp);
1348  if (error)
1349  goto out_close_devices;
1350 
1351  error = xfs_icsb_init_counters(mp);
1352  if (error)
1353  goto out_destroy_workqueues;
1354 
1355  error = xfs_readsb(mp, flags);
1356  if (error)
1357  goto out_destroy_counters;
1358 
1359  error = xfs_finish_flags(mp);
1360  if (error)
1361  goto out_free_sb;
1362 
1363  error = xfs_setup_devices(mp);
1364  if (error)
1365  goto out_free_sb;
1366 
1367  error = xfs_filestream_mount(mp);
1368  if (error)
1369  goto out_free_sb;
1370 
1371  /*
1372  * we must configure the block size in the superblock before we run the
1373  * full mount process as the mount process can lookup and cache inodes.
1374  * For the same reason we must also initialise the syncd and register
1375  * the inode cache shrinker so that inodes can be reclaimed during
1376  * operations like a quotacheck that iterate all inodes in the
1377  * filesystem.
1378  */
1379  sb->s_magic = XFS_SB_MAGIC;
1380  sb->s_blocksize = mp->m_sb.sb_blocksize;
1381  sb->s_blocksize_bits = ffs(sb->s_blocksize) - 1;
1382  sb->s_maxbytes = xfs_max_file_offset(sb->s_blocksize_bits);
1383  sb->s_max_links = XFS_MAXLINK;
1384  sb->s_time_gran = 1;
1385  set_posix_acl_flag(sb);
1386 
1387  error = xfs_syncd_init(mp);
1388  if (error)
1389  goto out_filestream_unmount;
1390 
1391  error = xfs_mountfs(mp);
1392  if (error)
1393  goto out_syncd_stop;
1394 
1395  root = igrab(VFS_I(mp->m_rootip));
1396  if (!root) {
1397  error = ENOENT;
1398  goto out_unmount;
1399  }
1400  if (is_bad_inode(root)) {
1401  error = EINVAL;
1402  goto out_unmount;
1403  }
1404  sb->s_root = d_make_root(root);
1405  if (!sb->s_root) {
1406  error = ENOMEM;
1407  goto out_unmount;
1408  }
1409 
1410  return 0;
1411  out_syncd_stop:
1412  xfs_syncd_stop(mp);
1413  out_filestream_unmount:
1414  xfs_filestream_unmount(mp);
1415  out_free_sb:
1416  xfs_freesb(mp);
1417  out_destroy_counters:
1418  xfs_icsb_destroy_counters(mp);
1419 out_destroy_workqueues:
1420  xfs_destroy_mount_workqueues(mp);
1421  out_close_devices:
1422  xfs_close_devices(mp);
1423  out_free_fsname:
1424  xfs_free_fsname(mp);
1425  kfree(mp);
1426  out:
1427  return -error;
1428 
1429  out_unmount:
1430  xfs_filestream_unmount(mp);
1431  xfs_unmountfs(mp);
1432  xfs_syncd_stop(mp);
1433  goto out_free_sb;
1434 }
1435 
1436 STATIC struct dentry *
1437 xfs_fs_mount(
1438  struct file_system_type *fs_type,
1439  int flags,
1440  const char *dev_name,
1441  void *data)
1442 {
1443  return mount_bdev(fs_type, flags, dev_name, data, xfs_fs_fill_super);
1444 }
1445 
1446 static int
1447 xfs_fs_nr_cached_objects(
1448  struct super_block *sb)
1449 {
1450  return xfs_reclaim_inodes_count(XFS_M(sb));
1451 }
1452 
1453 static void
1454 xfs_fs_free_cached_objects(
1455  struct super_block *sb,
1456  int nr_to_scan)
1457 {
1458  xfs_reclaim_inodes_nr(XFS_M(sb), nr_to_scan);
1459 }
1460 
1461 static const struct super_operations xfs_super_operations = {
1462  .alloc_inode = xfs_fs_alloc_inode,
1463  .destroy_inode = xfs_fs_destroy_inode,
1464  .evict_inode = xfs_fs_evict_inode,
1465  .drop_inode = xfs_fs_drop_inode,
1466  .put_super = xfs_fs_put_super,
1467  .sync_fs = xfs_fs_sync_fs,
1468  .freeze_fs = xfs_fs_freeze,
1469  .unfreeze_fs = xfs_fs_unfreeze,
1470  .statfs = xfs_fs_statfs,
1471  .remount_fs = xfs_fs_remount,
1472  .show_options = xfs_fs_show_options,
1473  .nr_cached_objects = xfs_fs_nr_cached_objects,
1474  .free_cached_objects = xfs_fs_free_cached_objects,
1475 };
1476 
1477 static struct file_system_type xfs_fs_type = {
1478  .owner = THIS_MODULE,
1479  .name = "xfs",
1480  .mount = xfs_fs_mount,
1481  .kill_sb = kill_block_super,
1482  .fs_flags = FS_REQUIRES_DEV,
1483 };
1484 
1485 STATIC int __init
1486 xfs_init_zones(void)
1487 {
1488 
1489  xfs_ioend_zone = kmem_zone_init(sizeof(xfs_ioend_t), "xfs_ioend");
1490  if (!xfs_ioend_zone)
1491  goto out;
1492 
1493  xfs_ioend_pool = mempool_create_slab_pool(4 * MAX_BUF_PER_PAGE,
1494  xfs_ioend_zone);
1495  if (!xfs_ioend_pool)
1496  goto out_destroy_ioend_zone;
1497 
1498  xfs_log_ticket_zone = kmem_zone_init(sizeof(xlog_ticket_t),
1499  "xfs_log_ticket");
1500  if (!xfs_log_ticket_zone)
1501  goto out_destroy_ioend_pool;
1502 
1503  xfs_bmap_free_item_zone = kmem_zone_init(sizeof(xfs_bmap_free_item_t),
1504  "xfs_bmap_free_item");
1505  if (!xfs_bmap_free_item_zone)
1506  goto out_destroy_log_ticket_zone;
1507 
1508  xfs_btree_cur_zone = kmem_zone_init(sizeof(xfs_btree_cur_t),
1509  "xfs_btree_cur");
1510  if (!xfs_btree_cur_zone)
1511  goto out_destroy_bmap_free_item_zone;
1512 
1513  xfs_da_state_zone = kmem_zone_init(sizeof(xfs_da_state_t),
1514  "xfs_da_state");
1515  if (!xfs_da_state_zone)
1516  goto out_destroy_btree_cur_zone;
1517 
1518  xfs_ifork_zone = kmem_zone_init(sizeof(xfs_ifork_t), "xfs_ifork");
1519  if (!xfs_ifork_zone)
1520  goto out_destroy_da_state_zone;
1521 
1522  xfs_trans_zone = kmem_zone_init(sizeof(xfs_trans_t), "xfs_trans");
1523  if (!xfs_trans_zone)
1524  goto out_destroy_ifork_zone;
1525 
1526  xfs_log_item_desc_zone =
1527  kmem_zone_init(sizeof(struct xfs_log_item_desc),
1528  "xfs_log_item_desc");
1529  if (!xfs_log_item_desc_zone)
1530  goto out_destroy_trans_zone;
1531 
1532  /*
1533  * The size of the zone allocated buf log item is the maximum
1534  * size possible under XFS. This wastes a little bit of memory,
1535  * but it is much faster.
1536  */
1537  xfs_buf_item_zone = kmem_zone_init(sizeof(struct xfs_buf_log_item),
1538  "xfs_buf_item");
1539  if (!xfs_buf_item_zone)
1540  goto out_destroy_log_item_desc_zone;
1541 
1542  xfs_efd_zone = kmem_zone_init((sizeof(xfs_efd_log_item_t) +
1543  ((XFS_EFD_MAX_FAST_EXTENTS - 1) *
1544  sizeof(xfs_extent_t))), "xfs_efd_item");
1545  if (!xfs_efd_zone)
1546  goto out_destroy_buf_item_zone;
1547 
1548  xfs_efi_zone = kmem_zone_init((sizeof(xfs_efi_log_item_t) +
1549  ((XFS_EFI_MAX_FAST_EXTENTS - 1) *
1550  sizeof(xfs_extent_t))), "xfs_efi_item");
1551  if (!xfs_efi_zone)
1552  goto out_destroy_efd_zone;
1553 
1554  xfs_inode_zone =
1555  kmem_zone_init_flags(sizeof(xfs_inode_t), "xfs_inode",
1556  KM_ZONE_HWALIGN | KM_ZONE_RECLAIM | KM_ZONE_SPREAD,
1557  xfs_fs_inode_init_once);
1558  if (!xfs_inode_zone)
1559  goto out_destroy_efi_zone;
1560 
1561  xfs_ili_zone =
1562  kmem_zone_init_flags(sizeof(xfs_inode_log_item_t), "xfs_ili",
1563  KM_ZONE_SPREAD, NULL);
1564  if (!xfs_ili_zone)
1565  goto out_destroy_inode_zone;
1566 
1567  return 0;
1568 
1569  out_destroy_inode_zone:
1570  kmem_zone_destroy(xfs_inode_zone);
1571  out_destroy_efi_zone:
1572  kmem_zone_destroy(xfs_efi_zone);
1573  out_destroy_efd_zone:
1574  kmem_zone_destroy(xfs_efd_zone);
1575  out_destroy_buf_item_zone:
1576  kmem_zone_destroy(xfs_buf_item_zone);
1577  out_destroy_log_item_desc_zone:
1578  kmem_zone_destroy(xfs_log_item_desc_zone);
1579  out_destroy_trans_zone:
1580  kmem_zone_destroy(xfs_trans_zone);
1581  out_destroy_ifork_zone:
1582  kmem_zone_destroy(xfs_ifork_zone);
1583  out_destroy_da_state_zone:
1584  kmem_zone_destroy(xfs_da_state_zone);
1585  out_destroy_btree_cur_zone:
1586  kmem_zone_destroy(xfs_btree_cur_zone);
1587  out_destroy_bmap_free_item_zone:
1588  kmem_zone_destroy(xfs_bmap_free_item_zone);
1589  out_destroy_log_ticket_zone:
1590  kmem_zone_destroy(xfs_log_ticket_zone);
1591  out_destroy_ioend_pool:
1592  mempool_destroy(xfs_ioend_pool);
1593  out_destroy_ioend_zone:
1594  kmem_zone_destroy(xfs_ioend_zone);
1595  out:
1596  return -ENOMEM;
1597 }
1598 
1599 STATIC void
1600 xfs_destroy_zones(void)
1601 {
1602  /*
1603  * Make sure all delayed rcu free are flushed before we
1604  * destroy caches.
1605  */
1606  rcu_barrier();
1607  kmem_zone_destroy(xfs_ili_zone);
1608  kmem_zone_destroy(xfs_inode_zone);
1609  kmem_zone_destroy(xfs_efi_zone);
1610  kmem_zone_destroy(xfs_efd_zone);
1611  kmem_zone_destroy(xfs_buf_item_zone);
1612  kmem_zone_destroy(xfs_log_item_desc_zone);
1613  kmem_zone_destroy(xfs_trans_zone);
1614  kmem_zone_destroy(xfs_ifork_zone);
1615  kmem_zone_destroy(xfs_da_state_zone);
1616  kmem_zone_destroy(xfs_btree_cur_zone);
1617  kmem_zone_destroy(xfs_bmap_free_item_zone);
1618  kmem_zone_destroy(xfs_log_ticket_zone);
1619  mempool_destroy(xfs_ioend_pool);
1620  kmem_zone_destroy(xfs_ioend_zone);
1621 
1622 }
1623 
1624 STATIC int __init
1625 xfs_init_workqueues(void)
1626 {
1627  /*
1628  * We never want to the same work item to run twice, reclaiming inodes
1629  * or idling the log is not going to get any faster by multiple CPUs
1630  * competing for ressources. Use the default large max_active value
1631  * so that even lots of filesystems can perform these task in parallel.
1632  */
1633  xfs_syncd_wq = alloc_workqueue("xfssyncd", WQ_NON_REENTRANT, 0);
1634  if (!xfs_syncd_wq)
1635  return -ENOMEM;
1636 
1637  /*
1638  * The allocation workqueue can be used in memory reclaim situations
1639  * (writepage path), and parallelism is only limited by the number of
1640  * AGs in all the filesystems mounted. Hence use the default large
1641  * max_active value for this workqueue.
1642  */
1643  xfs_alloc_wq = alloc_workqueue("xfsalloc", WQ_MEM_RECLAIM, 0);
1644  if (!xfs_alloc_wq)
1645  goto out_destroy_syncd;
1646 
1647  return 0;
1648 
1649 out_destroy_syncd:
1650  destroy_workqueue(xfs_syncd_wq);
1651  return -ENOMEM;
1652 }
1653 
1654 STATIC void
1655 xfs_destroy_workqueues(void)
1656 {
1657  destroy_workqueue(xfs_alloc_wq);
1658  destroy_workqueue(xfs_syncd_wq);
1659 }
1660 
1661 STATIC int __init
1662 init_xfs_fs(void)
1663 {
1664  int error;
1665 
1666  printk(KERN_INFO XFS_VERSION_STRING " with "
1667  XFS_BUILD_OPTIONS " enabled\n");
1668 
1669  xfs_dir_startup();
1670 
1671  error = xfs_init_zones();
1672  if (error)
1673  goto out;
1674 
1675  error = xfs_init_workqueues();
1676  if (error)
1677  goto out_destroy_zones;
1678 
1679  error = xfs_mru_cache_init();
1680  if (error)
1681  goto out_destroy_wq;
1682 
1683  error = xfs_filestream_init();
1684  if (error)
1685  goto out_mru_cache_uninit;
1686 
1687  error = xfs_buf_init();
1688  if (error)
1689  goto out_filestream_uninit;
1690 
1691  error = xfs_init_procfs();
1692  if (error)
1693  goto out_buf_terminate;
1694 
1695  error = xfs_sysctl_register();
1696  if (error)
1697  goto out_cleanup_procfs;
1698 
1699  error = xfs_qm_init();
1700  if (error)
1701  goto out_sysctl_unregister;
1702 
1703  error = register_filesystem(&xfs_fs_type);
1704  if (error)
1705  goto out_qm_exit;
1706  return 0;
1707 
1708  out_qm_exit:
1709  xfs_qm_exit();
1710  out_sysctl_unregister:
1711  xfs_sysctl_unregister();
1712  out_cleanup_procfs:
1713  xfs_cleanup_procfs();
1714  out_buf_terminate:
1715  xfs_buf_terminate();
1716  out_filestream_uninit:
1717  xfs_filestream_uninit();
1718  out_mru_cache_uninit:
1719  xfs_mru_cache_uninit();
1720  out_destroy_wq:
1721  xfs_destroy_workqueues();
1722  out_destroy_zones:
1723  xfs_destroy_zones();
1724  out:
1725  return error;
1726 }
1727 
1728 STATIC void __exit
1729 exit_xfs_fs(void)
1730 {
1731  xfs_qm_exit();
1732  unregister_filesystem(&xfs_fs_type);
1733  xfs_sysctl_unregister();
1734  xfs_cleanup_procfs();
1735  xfs_buf_terminate();
1736  xfs_filestream_uninit();
1737  xfs_mru_cache_uninit();
1738  xfs_destroy_workqueues();
1739  xfs_destroy_zones();
1740 }
1741 
1742 module_init(init_xfs_fs);
1743 module_exit(exit_xfs_fs);
1744 
1745 MODULE_AUTHOR("Silicon Graphics, Inc.");
1746 MODULE_DESCRIPTION(XFS_VERSION_STRING " with " XFS_BUILD_OPTIONS " enabled");
1747 MODULE_LICENSE("GPL");
Generated on Thu Jan 10 2013 14:50:38 for Linux Kernel by   doxygen 1.8.2