Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
super.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2007 Oracle. All rights reserved.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public
6  * License v2 as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope that it will be useful,
9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11  * General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public
14  * License along with this program; if not, write to the
15  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
16  * Boston, MA 021110-1307, USA.
17  */
18 
19 #include <linux/blkdev.h>
20 #include <linux/module.h>
21 #include <linux/buffer_head.h>
22 #include <linux/fs.h>
23 #include <linux/pagemap.h>
24 #include <linux/highmem.h>
25 #include <linux/time.h>
26 #include <linux/init.h>
27 #include <linux/seq_file.h>
28 #include <linux/string.h>
29 #include <linux/backing-dev.h>
30 #include <linux/mount.h>
31 #include <linux/mpage.h>
32 #include <linux/swap.h>
33 #include <linux/writeback.h>
34 #include <linux/statfs.h>
35 #include <linux/compat.h>
36 #include <linux/parser.h>
37 #include <linux/ctype.h>
38 #include <linux/namei.h>
39 #include <linux/miscdevice.h>
40 #include <linux/magic.h>
41 #include <linux/slab.h>
42 #include <linux/cleancache.h>
43 #include <linux/ratelimit.h>
44 #include "compat.h"
45 #include "delayed-inode.h"
46 #include "ctree.h"
47 #include "disk-io.h"
48 #include "transaction.h"
49 #include "btrfs_inode.h"
50 #include "ioctl.h"
51 #include "print-tree.h"
52 #include "xattr.h"
53 #include "volumes.h"
54 #include "version.h"
55 #include "export.h"
56 #include "compression.h"
57 #include "rcu-string.h"
58 
59 #define CREATE_TRACE_POINTS
60 #include <trace/events/btrfs.h>
61 
62 static const struct super_operations btrfs_super_ops;
63 static struct file_system_type btrfs_fs_type;
64 
65 static const char *btrfs_decode_error(struct btrfs_fs_info *fs_info, int errno,
66  char nbuf[16])
67 {
68  char *errstr = NULL;
69 
70  switch (errno) {
71  case -EIO:
72  errstr = "IO failure";
73  break;
74  case -ENOMEM:
75  errstr = "Out of memory";
76  break;
77  case -EROFS:
78  errstr = "Readonly filesystem";
79  break;
80  case -EEXIST:
81  errstr = "Object already exists";
82  break;
83  default:
84  if (nbuf) {
85  if (snprintf(nbuf, 16, "error %d", -errno) >= 0)
86  errstr = nbuf;
87  }
88  break;
89  }
90 
91  return errstr;
92 }
93 
94 static void __save_error_info(struct btrfs_fs_info *fs_info)
95 {
96  /*
97  * today we only save the error info into ram. Long term we'll
98  * also send it down to the disk
99  */
100  fs_info->fs_state = BTRFS_SUPER_FLAG_ERROR;
101 }
102 
103 static void save_error_info(struct btrfs_fs_info *fs_info)
104 {
105  __save_error_info(fs_info);
106 }
107 
108 /* btrfs handle error by forcing the filesystem readonly */
109 static void btrfs_handle_error(struct btrfs_fs_info *fs_info)
110 {
111  struct super_block *sb = fs_info->sb;
112 
113  if (sb->s_flags & MS_RDONLY)
114  return;
115 
116  if (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {
117  sb->s_flags |= MS_RDONLY;
118  printk(KERN_INFO "btrfs is forced readonly\n");
119  __btrfs_scrub_cancel(fs_info);
120 // WARN_ON(1);
121  }
122 }
123 
124 #ifdef CONFIG_PRINTK
125 /*
126  * __btrfs_std_error decodes expected errors from the caller and
127  * invokes the approciate error response.
128  */
129 void __btrfs_std_error(struct btrfs_fs_info *fs_info, const char *function,
130  unsigned int line, int errno, const char *fmt, ...)
131 {
132  struct super_block *sb = fs_info->sb;
133  char nbuf[16];
134  const char *errstr;
135  va_list args;
136  va_start(args, fmt);
137 
138  /*
139  * Special case: if the error is EROFS, and we're already
140  * under MS_RDONLY, then it is safe here.
141  */
142  if (errno == -EROFS && (sb->s_flags & MS_RDONLY))
143  return;
144 
145  errstr = btrfs_decode_error(fs_info, errno, nbuf);
146  if (fmt) {
147  struct va_format vaf = {
148  .fmt = fmt,
149  .va = &args,
150  };
151 
152  printk(KERN_CRIT "BTRFS error (device %s) in %s:%d: %s (%pV)\n",
153  sb->s_id, function, line, errstr, &vaf);
154  } else {
155  printk(KERN_CRIT "BTRFS error (device %s) in %s:%d: %s\n",
156  sb->s_id, function, line, errstr);
157  }
158 
159  /* Don't go through full error handling during mount */
160  if (sb->s_flags & MS_BORN) {
161  save_error_info(fs_info);
162  btrfs_handle_error(fs_info);
163  }
164  va_end(args);
165 }
166 
167 static const char * const logtypes[] = {
168  "emergency",
169  "alert",
170  "critical",
171  "error",
172  "warning",
173  "notice",
174  "info",
175  "debug",
176 };
177 
178 void btrfs_printk(struct btrfs_fs_info *fs_info, const char *fmt, ...)
179 {
180  struct super_block *sb = fs_info->sb;
181  char lvl[4];
182  struct va_format vaf;
183  va_list args;
184  const char *type = logtypes[4];
185  int kern_level;
186 
187  va_start(args, fmt);
188 
189  kern_level = printk_get_level(fmt);
190  if (kern_level) {
191  size_t size = printk_skip_level(fmt) - fmt;
192  memcpy(lvl, fmt, size);
193  lvl[size] = '\0';
194  fmt += size;
195  type = logtypes[kern_level - '0'];
196  } else
197  *lvl = '\0';
198 
199  vaf.fmt = fmt;
200  vaf.va = &args;
201 
202  printk("%sBTRFS %s (device %s): %pV", lvl, type, sb->s_id, &vaf);
203 
204  va_end(args);
205 }
206 
207 #else
208 
209 void __btrfs_std_error(struct btrfs_fs_info *fs_info, const char *function,
210  unsigned int line, int errno, const char *fmt, ...)
211 {
212  struct super_block *sb = fs_info->sb;
213 
214  /*
215  * Special case: if the error is EROFS, and we're already
216  * under MS_RDONLY, then it is safe here.
217  */
218  if (errno == -EROFS && (sb->s_flags & MS_RDONLY))
219  return;
220 
221  /* Don't go through full error handling during mount */
222  if (sb->s_flags & MS_BORN) {
223  save_error_info(fs_info);
224  btrfs_handle_error(fs_info);
225  }
226 }
227 #endif
228 
229 /*
230  * We only mark the transaction aborted and then set the file system read-only.
231  * This will prevent new transactions from starting or trying to join this
232  * one.
233  *
234  * This means that error recovery at the call site is limited to freeing
235  * any local memory allocations and passing the error code up without
236  * further cleanup. The transaction should complete as it normally would
237  * in the call path but will return -EIO.
238  *
239  * We'll complete the cleanup in btrfs_end_transaction and
240  * btrfs_commit_transaction.
241  */
243  struct btrfs_root *root, const char *function,
244  unsigned int line, int errno)
245 {
246  WARN_ONCE(1, KERN_DEBUG "btrfs: Transaction aborted\n");
247  trans->aborted = errno;
248  /* Nothing used. The other threads that have joined this
249  * transaction may be able to continue. */
250  if (!trans->blocks_used) {
251  char nbuf[16];
252  const char *errstr;
253 
254  errstr = btrfs_decode_error(root->fs_info, errno, nbuf);
255  btrfs_printk(root->fs_info,
256  "%s:%d: Aborting unused transaction(%s).\n",
257  function, line, errstr);
258  return;
259  }
260  trans->transaction->aborted = errno;
261  __btrfs_std_error(root->fs_info, function, line, errno, NULL);
262 }
263 /*
264  * __btrfs_panic decodes unexpected, fatal errors from the caller,
265  * issues an alert, and either panics or BUGs, depending on mount options.
266  */
267 void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function,
268  unsigned int line, int errno, const char *fmt, ...)
269 {
270  char nbuf[16];
271  char *s_id = "<unknown>";
272  const char *errstr;
273  struct va_format vaf = { .fmt = fmt };
274  va_list args;
275 
276  if (fs_info)
277  s_id = fs_info->sb->s_id;
278 
279  va_start(args, fmt);
280  vaf.va = &args;
281 
282  errstr = btrfs_decode_error(fs_info, errno, nbuf);
284  panic(KERN_CRIT "BTRFS panic (device %s) in %s:%d: %pV (%s)\n",
285  s_id, function, line, &vaf, errstr);
286 
287  printk(KERN_CRIT "BTRFS panic (device %s) in %s:%d: %pV (%s)\n",
288  s_id, function, line, &vaf, errstr);
289  va_end(args);
290  /* Caller calls BUG() */
291 }
292 
293 static void btrfs_put_super(struct super_block *sb)
294 {
295  (void)close_ctree(btrfs_sb(sb)->tree_root);
296  /* FIXME: need to fix VFS to return error? */
297  /* AV: return it _where_? ->put_super() can be triggered by any number
298  * of async events, up to and including delivery of SIGKILL to the
299  * last process that kept it busy. Or segfault in the aforementioned
300  * process... Whom would you report that to?
301  */
302 }
303 
304 enum {
316 };
317 
318 static match_table_t tokens = {
319  {Opt_degraded, "degraded"},
320  {Opt_subvol, "subvol=%s"},
321  {Opt_subvolid, "subvolid=%d"},
322  {Opt_device, "device=%s"},
323  {Opt_nodatasum, "nodatasum"},
324  {Opt_nodatacow, "nodatacow"},
325  {Opt_nobarrier, "nobarrier"},
326  {Opt_max_inline, "max_inline=%s"},
327  {Opt_alloc_start, "alloc_start=%s"},
328  {Opt_thread_pool, "thread_pool=%d"},
329  {Opt_compress, "compress"},
330  {Opt_compress_type, "compress=%s"},
331  {Opt_compress_force, "compress-force"},
332  {Opt_compress_force_type, "compress-force=%s"},
333  {Opt_ssd, "ssd"},
334  {Opt_ssd_spread, "ssd_spread"},
335  {Opt_nossd, "nossd"},
336  {Opt_noacl, "noacl"},
337  {Opt_notreelog, "notreelog"},
338  {Opt_flushoncommit, "flushoncommit"},
339  {Opt_ratio, "metadata_ratio=%d"},
340  {Opt_discard, "discard"},
341  {Opt_space_cache, "space_cache"},
342  {Opt_clear_cache, "clear_cache"},
343  {Opt_user_subvol_rm_allowed, "user_subvol_rm_allowed"},
344  {Opt_enospc_debug, "enospc_debug"},
345  {Opt_subvolrootid, "subvolrootid=%d"},
346  {Opt_defrag, "autodefrag"},
347  {Opt_inode_cache, "inode_cache"},
348  {Opt_no_space_cache, "nospace_cache"},
349  {Opt_recovery, "recovery"},
350  {Opt_skip_balance, "skip_balance"},
351  {Opt_check_integrity, "check_int"},
352  {Opt_check_integrity_including_extent_data, "check_int_data"},
353  {Opt_check_integrity_print_mask, "check_int_print_mask=%d"},
354  {Opt_fatal_errors, "fatal_errors=%s"},
355  {Opt_err, NULL},
356 };
357 
358 /*
359  * Regular mount options parser. Everything that is needed only when
360  * reading in a new superblock is parsed here.
361  * XXX JDM: This needs to be cleaned up for remount.
362  */
363 int btrfs_parse_options(struct btrfs_root *root, char *options)
364 {
365  struct btrfs_fs_info *info = root->fs_info;
367  char *p, *num, *orig = NULL;
368  u64 cache_gen;
369  int intarg;
370  int ret = 0;
371  char *compress_type;
372  bool compress_force = false;
373 
374  cache_gen = btrfs_super_cache_generation(root->fs_info->super_copy);
375  if (cache_gen)
376  btrfs_set_opt(info->mount_opt, SPACE_CACHE);
377 
378  if (!options)
379  goto out;
380 
381  /*
382  * strsep changes the string, duplicate it because parse_options
383  * gets called twice
384  */
385  options = kstrdup(options, GFP_NOFS);
386  if (!options)
387  return -ENOMEM;
388 
389  orig = options;
390 
391  while ((p = strsep(&options, ",")) != NULL) {
392  int token;
393  if (!*p)
394  continue;
395 
396  token = match_token(p, tokens, args);
397  switch (token) {
398  case Opt_degraded:
399  printk(KERN_INFO "btrfs: allowing degraded mounts\n");
400  btrfs_set_opt(info->mount_opt, DEGRADED);
401  break;
402  case Opt_subvol:
403  case Opt_subvolid:
404  case Opt_subvolrootid:
405  case Opt_device:
406  /*
407  * These are parsed by btrfs_parse_early_options
408  * and can be happily ignored here.
409  */
410  break;
411  case Opt_nodatasum:
412  printk(KERN_INFO "btrfs: setting nodatasum\n");
413  btrfs_set_opt(info->mount_opt, NODATASUM);
414  break;
415  case Opt_nodatacow:
416  if (!btrfs_test_opt(root, COMPRESS) ||
417  !btrfs_test_opt(root, FORCE_COMPRESS)) {
418  printk(KERN_INFO "btrfs: setting nodatacow, compression disabled\n");
419  } else {
420  printk(KERN_INFO "btrfs: setting nodatacow\n");
421  }
423  btrfs_clear_opt(info->mount_opt, COMPRESS);
424  btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
425  btrfs_set_opt(info->mount_opt, NODATACOW);
426  btrfs_set_opt(info->mount_opt, NODATASUM);
427  break;
428  case Opt_compress_force:
430  compress_force = true;
431  case Opt_compress:
432  case Opt_compress_type:
433  if (token == Opt_compress ||
434  token == Opt_compress_force ||
435  strcmp(args[0].from, "zlib") == 0) {
436  compress_type = "zlib";
438  btrfs_set_opt(info->mount_opt, COMPRESS);
439  btrfs_clear_opt(info->mount_opt, NODATACOW);
440  btrfs_clear_opt(info->mount_opt, NODATASUM);
441  } else if (strcmp(args[0].from, "lzo") == 0) {
442  compress_type = "lzo";
444  btrfs_set_opt(info->mount_opt, COMPRESS);
445  btrfs_clear_opt(info->mount_opt, NODATACOW);
446  btrfs_clear_opt(info->mount_opt, NODATASUM);
447  btrfs_set_fs_incompat(info, COMPRESS_LZO);
448  } else if (strncmp(args[0].from, "no", 2) == 0) {
449  compress_type = "no";
451  btrfs_clear_opt(info->mount_opt, COMPRESS);
452  btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
453  compress_force = false;
454  } else {
455  ret = -EINVAL;
456  goto out;
457  }
458 
459  if (compress_force) {
460  btrfs_set_opt(info->mount_opt, FORCE_COMPRESS);
461  pr_info("btrfs: force %s compression\n",
462  compress_type);
463  } else
464  pr_info("btrfs: use %s compression\n",
465  compress_type);
466  break;
467  case Opt_ssd:
468  printk(KERN_INFO "btrfs: use ssd allocation scheme\n");
469  btrfs_set_opt(info->mount_opt, SSD);
470  break;
471  case Opt_ssd_spread:
472  printk(KERN_INFO "btrfs: use spread ssd "
473  "allocation scheme\n");
474  btrfs_set_opt(info->mount_opt, SSD);
475  btrfs_set_opt(info->mount_opt, SSD_SPREAD);
476  break;
477  case Opt_nossd:
478  printk(KERN_INFO "btrfs: not using ssd allocation "
479  "scheme\n");
480  btrfs_set_opt(info->mount_opt, NOSSD);
481  btrfs_clear_opt(info->mount_opt, SSD);
482  btrfs_clear_opt(info->mount_opt, SSD_SPREAD);
483  break;
484  case Opt_nobarrier:
485  printk(KERN_INFO "btrfs: turning off barriers\n");
486  btrfs_set_opt(info->mount_opt, NOBARRIER);
487  break;
488  case Opt_thread_pool:
489  intarg = 0;
490  match_int(&args[0], &intarg);
491  if (intarg)
492  info->thread_pool_size = intarg;
493  break;
494  case Opt_max_inline:
495  num = match_strdup(&args[0]);
496  if (num) {
497  info->max_inline = memparse(num, NULL);
498  kfree(num);
499 
500  if (info->max_inline) {
501  info->max_inline = max_t(u64,
502  info->max_inline,
503  root->sectorsize);
504  }
505  printk(KERN_INFO "btrfs: max_inline at %llu\n",
506  (unsigned long long)info->max_inline);
507  }
508  break;
509  case Opt_alloc_start:
510  num = match_strdup(&args[0]);
511  if (num) {
512  info->alloc_start = memparse(num, NULL);
513  kfree(num);
515  "btrfs: allocations start at %llu\n",
516  (unsigned long long)info->alloc_start);
517  }
518  break;
519  case Opt_noacl:
520  root->fs_info->sb->s_flags &= ~MS_POSIXACL;
521  break;
522  case Opt_notreelog:
523  printk(KERN_INFO "btrfs: disabling tree log\n");
524  btrfs_set_opt(info->mount_opt, NOTREELOG);
525  break;
526  case Opt_flushoncommit:
527  printk(KERN_INFO "btrfs: turning on flush-on-commit\n");
528  btrfs_set_opt(info->mount_opt, FLUSHONCOMMIT);
529  break;
530  case Opt_ratio:
531  intarg = 0;
532  match_int(&args[0], &intarg);
533  if (intarg) {
534  info->metadata_ratio = intarg;
535  printk(KERN_INFO "btrfs: metadata ratio %d\n",
536  info->metadata_ratio);
537  }
538  break;
539  case Opt_discard:
540  btrfs_set_opt(info->mount_opt, DISCARD);
541  break;
542  case Opt_space_cache:
543  btrfs_set_opt(info->mount_opt, SPACE_CACHE);
544  break;
545  case Opt_no_space_cache:
546  printk(KERN_INFO "btrfs: disabling disk space caching\n");
547  btrfs_clear_opt(info->mount_opt, SPACE_CACHE);
548  break;
549  case Opt_inode_cache:
550  printk(KERN_INFO "btrfs: enabling inode map caching\n");
551  btrfs_set_opt(info->mount_opt, INODE_MAP_CACHE);
552  break;
553  case Opt_clear_cache:
554  printk(KERN_INFO "btrfs: force clearing of disk cache\n");
555  btrfs_set_opt(info->mount_opt, CLEAR_CACHE);
556  break;
558  btrfs_set_opt(info->mount_opt, USER_SUBVOL_RM_ALLOWED);
559  break;
560  case Opt_enospc_debug:
561  btrfs_set_opt(info->mount_opt, ENOSPC_DEBUG);
562  break;
563  case Opt_defrag:
564  printk(KERN_INFO "btrfs: enabling auto defrag\n");
565  btrfs_set_opt(info->mount_opt, AUTO_DEFRAG);
566  break;
567  case Opt_recovery:
568  printk(KERN_INFO "btrfs: enabling auto recovery\n");
570  break;
571  case Opt_skip_balance:
572  btrfs_set_opt(info->mount_opt, SKIP_BALANCE);
573  break;
574 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
576  printk(KERN_INFO "btrfs: enabling check integrity"
577  " including extent data\n");
578  btrfs_set_opt(info->mount_opt,
579  CHECK_INTEGRITY_INCLUDING_EXTENT_DATA);
580  btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY);
581  break;
582  case Opt_check_integrity:
583  printk(KERN_INFO "btrfs: enabling check integrity\n");
584  btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY);
585  break;
587  intarg = 0;
588  match_int(&args[0], &intarg);
589  if (intarg) {
590  info->check_integrity_print_mask = intarg;
591  printk(KERN_INFO "btrfs:"
592  " check_integrity_print_mask 0x%x\n",
593  info->check_integrity_print_mask);
594  }
595  break;
596 #else
598  case Opt_check_integrity:
600  printk(KERN_ERR "btrfs: support for check_integrity*"
601  " not compiled in!\n");
602  ret = -EINVAL;
603  goto out;
604 #endif
605  case Opt_fatal_errors:
606  if (strcmp(args[0].from, "panic") == 0)
607  btrfs_set_opt(info->mount_opt,
608  PANIC_ON_FATAL_ERROR);
609  else if (strcmp(args[0].from, "bug") == 0)
611  PANIC_ON_FATAL_ERROR);
612  else {
613  ret = -EINVAL;
614  goto out;
615  }
616  break;
617  case Opt_err:
618  printk(KERN_INFO "btrfs: unrecognized mount option "
619  "'%s'\n", p);
620  ret = -EINVAL;
621  goto out;
622  default:
623  break;
624  }
625  }
626 out:
627  if (!ret && btrfs_test_opt(root, SPACE_CACHE))
628  printk(KERN_INFO "btrfs: disk space caching is enabled\n");
629  kfree(orig);
630  return ret;
631 }
632 
633 /*
634  * Parse mount options that are required early in the mount process.
635  *
636  * All other options will be parsed on much later in the mount process and
637  * only when we need to allocate a new super block.
638  */
639 static int btrfs_parse_early_options(const char *options, fmode_t flags,
640  void *holder, char **subvol_name, u64 *subvol_objectid,
641  u64 *subvol_rootid, struct btrfs_fs_devices **fs_devices)
642 {
644  char *device_name, *opts, *orig, *p;
645  int error = 0;
646  int intarg;
647 
648  if (!options)
649  return 0;
650 
651  /*
652  * strsep changes the string, duplicate it because parse_options
653  * gets called twice
654  */
655  opts = kstrdup(options, GFP_KERNEL);
656  if (!opts)
657  return -ENOMEM;
658  orig = opts;
659 
660  while ((p = strsep(&opts, ",")) != NULL) {
661  int token;
662  if (!*p)
663  continue;
664 
665  token = match_token(p, tokens, args);
666  switch (token) {
667  case Opt_subvol:
668  kfree(*subvol_name);
669  *subvol_name = match_strdup(&args[0]);
670  break;
671  case Opt_subvolid:
672  intarg = 0;
673  error = match_int(&args[0], &intarg);
674  if (!error) {
675  /* we want the original fs_tree */
676  if (!intarg)
677  *subvol_objectid =
679  else
680  *subvol_objectid = intarg;
681  }
682  break;
683  case Opt_subvolrootid:
684  intarg = 0;
685  error = match_int(&args[0], &intarg);
686  if (!error) {
687  /* we want the original fs_tree */
688  if (!intarg)
689  *subvol_rootid =
691  else
692  *subvol_rootid = intarg;
693  }
694  break;
695  case Opt_device:
696  device_name = match_strdup(&args[0]);
697  if (!device_name) {
698  error = -ENOMEM;
699  goto out;
700  }
701  error = btrfs_scan_one_device(device_name,
702  flags, holder, fs_devices);
703  kfree(device_name);
704  if (error)
705  goto out;
706  break;
707  default:
708  break;
709  }
710  }
711 
712 out:
713  kfree(orig);
714  return error;
715 }
716 
717 static struct dentry *get_default_root(struct super_block *sb,
718  u64 subvol_objectid)
719 {
720  struct btrfs_fs_info *fs_info = btrfs_sb(sb);
721  struct btrfs_root *root = fs_info->tree_root;
722  struct btrfs_root *new_root;
723  struct btrfs_dir_item *di;
724  struct btrfs_path *path;
725  struct btrfs_key location;
726  struct inode *inode;
727  u64 dir_id;
728  int new = 0;
729 
730  /*
731  * We have a specific subvol we want to mount, just setup location and
732  * go look up the root.
733  */
734  if (subvol_objectid) {
735  location.objectid = subvol_objectid;
737  location.offset = (u64)-1;
738  goto find_root;
739  }
740 
741  path = btrfs_alloc_path();
742  if (!path)
743  return ERR_PTR(-ENOMEM);
744  path->leave_spinning = 1;
745 
746  /*
747  * Find the "default" dir item which points to the root item that we
748  * will mount by default if we haven't been given a specific subvolume
749  * to mount.
750  */
751  dir_id = btrfs_super_root_dir(fs_info->super_copy);
752  di = btrfs_lookup_dir_item(NULL, root, path, dir_id, "default", 7, 0);
753  if (IS_ERR(di)) {
754  btrfs_free_path(path);
755  return ERR_CAST(di);
756  }
757  if (!di) {
758  /*
759  * Ok the default dir item isn't there. This is weird since
760  * it's always been there, but don't freak out, just try and
761  * mount to root most subvolume.
762  */
763  btrfs_free_path(path);
764  dir_id = BTRFS_FIRST_FREE_OBJECTID;
765  new_root = fs_info->fs_root;
766  goto setup_root;
767  }
768 
769  btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
770  btrfs_free_path(path);
771 
772 find_root:
773  new_root = btrfs_read_fs_root_no_name(fs_info, &location);
774  if (IS_ERR(new_root))
775  return ERR_CAST(new_root);
776 
777  if (btrfs_root_refs(&new_root->root_item) == 0)
778  return ERR_PTR(-ENOENT);
779 
780  dir_id = btrfs_root_dirid(&new_root->root_item);
781 setup_root:
782  location.objectid = dir_id;
784  location.offset = 0;
785 
786  inode = btrfs_iget(sb, &location, new_root, &new);
787  if (IS_ERR(inode))
788  return ERR_CAST(inode);
789 
790  /*
791  * If we're just mounting the root most subvol put the inode and return
792  * a reference to the dentry. We will have already gotten a reference
793  * to the inode in btrfs_fill_super so we're good to go.
794  */
795  if (!new && sb->s_root->d_inode == inode) {
796  iput(inode);
797  return dget(sb->s_root);
798  }
799 
800  return d_obtain_alias(inode);
801 }
802 
803 static int btrfs_fill_super(struct super_block *sb,
804  struct btrfs_fs_devices *fs_devices,
805  void *data, int silent)
806 {
807  struct inode *inode;
808  struct btrfs_fs_info *fs_info = btrfs_sb(sb);
809  struct btrfs_key key;
810  int err;
811 
812  sb->s_maxbytes = MAX_LFS_FILESIZE;
814  sb->s_op = &btrfs_super_ops;
818  sb->s_time_gran = 1;
819 #ifdef CONFIG_BTRFS_FS_POSIX_ACL
820  sb->s_flags |= MS_POSIXACL;
821 #endif
822  sb->s_flags |= MS_I_VERSION;
823  err = open_ctree(sb, fs_devices, (char *)data);
824  if (err) {
825  printk("btrfs: open_ctree failed\n");
826  return err;
827  }
828 
829  key.objectid = BTRFS_FIRST_FREE_OBJECTID;
830  key.type = BTRFS_INODE_ITEM_KEY;
831  key.offset = 0;
832  inode = btrfs_iget(sb, &key, fs_info->fs_root, NULL);
833  if (IS_ERR(inode)) {
834  err = PTR_ERR(inode);
835  goto fail_close;
836  }
837 
838  sb->s_root = d_make_root(inode);
839  if (!sb->s_root) {
840  err = -ENOMEM;
841  goto fail_close;
842  }
843 
844  save_mount_options(sb, data);
845  cleancache_init_fs(sb);
846  sb->s_flags |= MS_ACTIVE;
847  return 0;
848 
849 fail_close:
850  close_ctree(fs_info->tree_root);
851  return err;
852 }
853 
854 int btrfs_sync_fs(struct super_block *sb, int wait)
855 {
856  struct btrfs_trans_handle *trans;
857  struct btrfs_fs_info *fs_info = btrfs_sb(sb);
858  struct btrfs_root *root = fs_info->tree_root;
859 
860  trace_btrfs_sync_fs(wait);
861 
862  if (!wait) {
863  filemap_flush(fs_info->btree_inode->i_mapping);
864  return 0;
865  }
866 
868 
869  trans = btrfs_attach_transaction(root);
870  if (IS_ERR(trans)) {
871  /* no transaction, don't bother */
872  if (PTR_ERR(trans) == -ENOENT)
873  return 0;
874  return PTR_ERR(trans);
875  }
876  return btrfs_commit_transaction(trans, root);
877 }
878 
879 static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry)
880 {
881  struct btrfs_fs_info *info = btrfs_sb(dentry->d_sb);
882  struct btrfs_root *root = info->tree_root;
883  char *compress_type;
884 
885  if (btrfs_test_opt(root, DEGRADED))
886  seq_puts(seq, ",degraded");
887  if (btrfs_test_opt(root, NODATASUM))
888  seq_puts(seq, ",nodatasum");
889  if (btrfs_test_opt(root, NODATACOW))
890  seq_puts(seq, ",nodatacow");
891  if (btrfs_test_opt(root, NOBARRIER))
892  seq_puts(seq, ",nobarrier");
893  if (info->max_inline != 8192 * 1024)
894  seq_printf(seq, ",max_inline=%llu",
895  (unsigned long long)info->max_inline);
896  if (info->alloc_start != 0)
897  seq_printf(seq, ",alloc_start=%llu",
898  (unsigned long long)info->alloc_start);
899  if (info->thread_pool_size != min_t(unsigned long,
900  num_online_cpus() + 2, 8))
901  seq_printf(seq, ",thread_pool=%d", info->thread_pool_size);
902  if (btrfs_test_opt(root, COMPRESS)) {
903  if (info->compress_type == BTRFS_COMPRESS_ZLIB)
904  compress_type = "zlib";
905  else
906  compress_type = "lzo";
907  if (btrfs_test_opt(root, FORCE_COMPRESS))
908  seq_printf(seq, ",compress-force=%s", compress_type);
909  else
910  seq_printf(seq, ",compress=%s", compress_type);
911  }
912  if (btrfs_test_opt(root, NOSSD))
913  seq_puts(seq, ",nossd");
914  if (btrfs_test_opt(root, SSD_SPREAD))
915  seq_puts(seq, ",ssd_spread");
916  else if (btrfs_test_opt(root, SSD))
917  seq_puts(seq, ",ssd");
918  if (btrfs_test_opt(root, NOTREELOG))
919  seq_puts(seq, ",notreelog");
920  if (btrfs_test_opt(root, FLUSHONCOMMIT))
921  seq_puts(seq, ",flushoncommit");
922  if (btrfs_test_opt(root, DISCARD))
923  seq_puts(seq, ",discard");
924  if (!(root->fs_info->sb->s_flags & MS_POSIXACL))
925  seq_puts(seq, ",noacl");
926  if (btrfs_test_opt(root, SPACE_CACHE))
927  seq_puts(seq, ",space_cache");
928  else
929  seq_puts(seq, ",nospace_cache");
930  if (btrfs_test_opt(root, CLEAR_CACHE))
931  seq_puts(seq, ",clear_cache");
932  if (btrfs_test_opt(root, USER_SUBVOL_RM_ALLOWED))
933  seq_puts(seq, ",user_subvol_rm_allowed");
934  if (btrfs_test_opt(root, ENOSPC_DEBUG))
935  seq_puts(seq, ",enospc_debug");
936  if (btrfs_test_opt(root, AUTO_DEFRAG))
937  seq_puts(seq, ",autodefrag");
938  if (btrfs_test_opt(root, INODE_MAP_CACHE))
939  seq_puts(seq, ",inode_cache");
940  if (btrfs_test_opt(root, SKIP_BALANCE))
941  seq_puts(seq, ",skip_balance");
942  if (btrfs_test_opt(root, PANIC_ON_FATAL_ERROR))
943  seq_puts(seq, ",fatal_errors=panic");
944  return 0;
945 }
946 
947 static int btrfs_test_super(struct super_block *s, void *data)
948 {
949  struct btrfs_fs_info *p = data;
950  struct btrfs_fs_info *fs_info = btrfs_sb(s);
951 
952  return fs_info->fs_devices == p->fs_devices;
953 }
954 
955 static int btrfs_set_super(struct super_block *s, void *data)
956 {
957  int err = set_anon_super(s, data);
958  if (!err)
959  s->s_fs_info = data;
960  return err;
961 }
962 
963 /*
964  * subvolumes are identified by ino 256
965  */
966 static inline int is_subvolume_inode(struct inode *inode)
967 {
968  if (inode && inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)
969  return 1;
970  return 0;
971 }
972 
973 /*
974  * This will strip out the subvol=%s argument for an argument string and add
975  * subvolid=0 to make sure we get the actual tree root for path walking to the
976  * subvol we want.
977  */
978 static char *setup_root_args(char *args)
979 {
980  unsigned len = strlen(args) + 2 + 1;
981  char *src, *dst, *buf;
982 
983  /*
984  * We need the same args as before, but with this substitution:
985  * s!subvol=[^,]+!subvolid=0!
986  *
987  * Since the replacement string is up to 2 bytes longer than the
988  * original, allocate strlen(args) + 2 + 1 bytes.
989  */
990 
991  src = strstr(args, "subvol=");
992  /* This shouldn't happen, but just in case.. */
993  if (!src)
994  return NULL;
995 
996  buf = dst = kmalloc(len, GFP_NOFS);
997  if (!buf)
998  return NULL;
999 
1000  /*
1001  * If the subvol= arg is not at the start of the string,
1002  * copy whatever precedes it into buf.
1003  */
1004  if (src != args) {
1005  *src++ = '\0';
1006  strcpy(buf, args);
1007  dst += strlen(args);
1008  }
1009 
1010  strcpy(dst, "subvolid=0");
1011  dst += strlen("subvolid=0");
1012 
1013  /*
1014  * If there is a "," after the original subvol=... string,
1015  * copy that suffix into our buffer. Otherwise, we're done.
1016  */
1017  src = strchr(src, ',');
1018  if (src)
1019  strcpy(dst, src);
1020 
1021  return buf;
1022 }
1023 
1024 static struct dentry *mount_subvol(const char *subvol_name, int flags,
1025  const char *device_name, char *data)
1026 {
1027  struct dentry *root;
1028  struct vfsmount *mnt;
1029  char *newargs;
1030 
1031  newargs = setup_root_args(data);
1032  if (!newargs)
1033  return ERR_PTR(-ENOMEM);
1034  mnt = vfs_kern_mount(&btrfs_fs_type, flags, device_name,
1035  newargs);
1036  kfree(newargs);
1037  if (IS_ERR(mnt))
1038  return ERR_CAST(mnt);
1039 
1040  root = mount_subtree(mnt, subvol_name);
1041 
1042  if (!IS_ERR(root) && !is_subvolume_inode(root->d_inode)) {
1043  struct super_block *s = root->d_sb;
1044  dput(root);
1045  root = ERR_PTR(-EINVAL);
1047  printk(KERN_ERR "btrfs: '%s' is not a valid subvolume\n",
1048  subvol_name);
1049  }
1050 
1051  return root;
1052 }
1053 
1054 /*
1055  * Find a superblock for the given device / mount point.
1056  *
1057  * Note: This is based on get_sb_bdev from fs/super.c with a few additions
1058  * for multiple device setup. Make sure to keep it in sync.
1059  */
1060 static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
1061  const char *device_name, void *data)
1062 {
1063  struct block_device *bdev = NULL;
1064  struct super_block *s;
1065  struct dentry *root;
1066  struct btrfs_fs_devices *fs_devices = NULL;
1067  struct btrfs_fs_info *fs_info = NULL;
1069  char *subvol_name = NULL;
1070  u64 subvol_objectid = 0;
1071  u64 subvol_rootid = 0;
1072  int error = 0;
1073 
1074  if (!(flags & MS_RDONLY))
1075  mode |= FMODE_WRITE;
1076 
1077  error = btrfs_parse_early_options(data, mode, fs_type,
1078  &subvol_name, &subvol_objectid,
1079  &subvol_rootid, &fs_devices);
1080  if (error) {
1081  kfree(subvol_name);
1082  return ERR_PTR(error);
1083  }
1084 
1085  if (subvol_name) {
1086  root = mount_subvol(subvol_name, flags, device_name, data);
1087  kfree(subvol_name);
1088  return root;
1089  }
1090 
1091  error = btrfs_scan_one_device(device_name, mode, fs_type, &fs_devices);
1092  if (error)
1093  return ERR_PTR(error);
1094 
1095  /*
1096  * Setup a dummy root and fs_info for test/set super. This is because
1097  * we don't actually fill this stuff out until open_ctree, but we need
1098  * it for searching for existing supers, so this lets us do that and
1099  * then open_ctree will properly initialize everything later.
1100  */
1101  fs_info = kzalloc(sizeof(struct btrfs_fs_info), GFP_NOFS);
1102  if (!fs_info)
1103  return ERR_PTR(-ENOMEM);
1104 
1105  fs_info->fs_devices = fs_devices;
1106 
1107  fs_info->super_copy = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_NOFS);
1108  fs_info->super_for_commit = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_NOFS);
1109  if (!fs_info->super_copy || !fs_info->super_for_commit) {
1110  error = -ENOMEM;
1111  goto error_fs_info;
1112  }
1113 
1114  error = btrfs_open_devices(fs_devices, mode, fs_type);
1115  if (error)
1116  goto error_fs_info;
1117 
1118  if (!(flags & MS_RDONLY) && fs_devices->rw_devices == 0) {
1119  error = -EACCES;
1120  goto error_close_devices;
1121  }
1122 
1123  bdev = fs_devices->latest_bdev;
1124  s = sget(fs_type, btrfs_test_super, btrfs_set_super, flags | MS_NOSEC,
1125  fs_info);
1126  if (IS_ERR(s)) {
1127  error = PTR_ERR(s);
1128  goto error_close_devices;
1129  }
1130 
1131  if (s->s_root) {
1132  btrfs_close_devices(fs_devices);
1133  free_fs_info(fs_info);
1134  if ((flags ^ s->s_flags) & MS_RDONLY)
1135  error = -EBUSY;
1136  } else {
1137  char b[BDEVNAME_SIZE];
1138 
1139  strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
1140  btrfs_sb(s)->bdev_holder = fs_type;
1141  error = btrfs_fill_super(s, fs_devices, data,
1142  flags & MS_SILENT ? 1 : 0);
1143  }
1144 
1145  root = !error ? get_default_root(s, subvol_objectid) : ERR_PTR(error);
1146  if (IS_ERR(root))
1148 
1149  return root;
1150 
1151 error_close_devices:
1152  btrfs_close_devices(fs_devices);
1153 error_fs_info:
1154  free_fs_info(fs_info);
1155  return ERR_PTR(error);
1156 }
1157 
1158 static void btrfs_set_max_workers(struct btrfs_workers *workers, int new_limit)
1159 {
1160  spin_lock_irq(&workers->lock);
1161  workers->max_workers = new_limit;
1162  spin_unlock_irq(&workers->lock);
1163 }
1164 
1165 static void btrfs_resize_thread_pool(struct btrfs_fs_info *fs_info,
1166  int new_pool_size, int old_pool_size)
1167 {
1168  if (new_pool_size == old_pool_size)
1169  return;
1170 
1171  fs_info->thread_pool_size = new_pool_size;
1172 
1173  printk(KERN_INFO "btrfs: resize thread pool %d -> %d\n",
1174  old_pool_size, new_pool_size);
1175 
1176  btrfs_set_max_workers(&fs_info->generic_worker, new_pool_size);
1177  btrfs_set_max_workers(&fs_info->workers, new_pool_size);
1178  btrfs_set_max_workers(&fs_info->delalloc_workers, new_pool_size);
1179  btrfs_set_max_workers(&fs_info->submit_workers, new_pool_size);
1180  btrfs_set_max_workers(&fs_info->caching_workers, new_pool_size);
1181  btrfs_set_max_workers(&fs_info->fixup_workers, new_pool_size);
1182  btrfs_set_max_workers(&fs_info->endio_workers, new_pool_size);
1183  btrfs_set_max_workers(&fs_info->endio_meta_workers, new_pool_size);
1184  btrfs_set_max_workers(&fs_info->endio_meta_write_workers, new_pool_size);
1185  btrfs_set_max_workers(&fs_info->endio_write_workers, new_pool_size);
1186  btrfs_set_max_workers(&fs_info->endio_freespace_worker, new_pool_size);
1187  btrfs_set_max_workers(&fs_info->delayed_workers, new_pool_size);
1188  btrfs_set_max_workers(&fs_info->readahead_workers, new_pool_size);
1189  btrfs_set_max_workers(&fs_info->scrub_workers, new_pool_size);
1190 }
1191 
1192 static int btrfs_remount(struct super_block *sb, int *flags, char *data)
1193 {
1194  struct btrfs_fs_info *fs_info = btrfs_sb(sb);
1195  struct btrfs_root *root = fs_info->tree_root;
1196  unsigned old_flags = sb->s_flags;
1197  unsigned long old_opts = fs_info->mount_opt;
1198  unsigned long old_compress_type = fs_info->compress_type;
1199  u64 old_max_inline = fs_info->max_inline;
1200  u64 old_alloc_start = fs_info->alloc_start;
1201  int old_thread_pool_size = fs_info->thread_pool_size;
1202  unsigned int old_metadata_ratio = fs_info->metadata_ratio;
1203  int ret;
1204 
1205  ret = btrfs_parse_options(root, data);
1206  if (ret) {
1207  ret = -EINVAL;
1208  goto restore;
1209  }
1210 
1211  btrfs_resize_thread_pool(fs_info,
1212  fs_info->thread_pool_size, old_thread_pool_size);
1213 
1214  if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
1215  return 0;
1216 
1217  if (*flags & MS_RDONLY) {
1218  sb->s_flags |= MS_RDONLY;
1219 
1220  ret = btrfs_commit_super(root);
1221  if (ret)
1222  goto restore;
1223  } else {
1224  if (fs_info->fs_devices->rw_devices == 0) {
1225  ret = -EACCES;
1226  goto restore;
1227  }
1228 
1229  if (btrfs_super_log_root(fs_info->super_copy) != 0) {
1230  ret = -EINVAL;
1231  goto restore;
1232  }
1233 
1234  ret = btrfs_cleanup_fs_roots(fs_info);
1235  if (ret)
1236  goto restore;
1237 
1238  /* recover relocation */
1239  ret = btrfs_recover_relocation(root);
1240  if (ret)
1241  goto restore;
1242 
1243  ret = btrfs_resume_balance_async(fs_info);
1244  if (ret)
1245  goto restore;
1246 
1247  sb->s_flags &= ~MS_RDONLY;
1248  }
1249 
1250  return 0;
1251 
1252 restore:
1253  /* We've hit an error - don't reset MS_RDONLY */
1254  if (sb->s_flags & MS_RDONLY)
1255  old_flags |= MS_RDONLY;
1256  sb->s_flags = old_flags;
1257  fs_info->mount_opt = old_opts;
1258  fs_info->compress_type = old_compress_type;
1259  fs_info->max_inline = old_max_inline;
1260  fs_info->alloc_start = old_alloc_start;
1261  btrfs_resize_thread_pool(fs_info,
1262  old_thread_pool_size, fs_info->thread_pool_size);
1263  fs_info->metadata_ratio = old_metadata_ratio;
1264  return ret;
1265 }
1266 
1267 /* Used to sort the devices by max_avail(descending sort) */
1268 static int btrfs_cmp_device_free_bytes(const void *dev_info1,
1269  const void *dev_info2)
1270 {
1271  if (((struct btrfs_device_info *)dev_info1)->max_avail >
1272  ((struct btrfs_device_info *)dev_info2)->max_avail)
1273  return -1;
1274  else if (((struct btrfs_device_info *)dev_info1)->max_avail <
1275  ((struct btrfs_device_info *)dev_info2)->max_avail)
1276  return 1;
1277  else
1278  return 0;
1279 }
1280 
1281 /*
1282  * sort the devices by max_avail, in which max free extent size of each device
1283  * is stored.(Descending Sort)
1284  */
1285 static inline void btrfs_descending_sort_devices(
1286  struct btrfs_device_info *devices,
1287  size_t nr_devices)
1288 {
1289  sort(devices, nr_devices, sizeof(struct btrfs_device_info),
1290  btrfs_cmp_device_free_bytes, NULL);
1291 }
1292 
1293 /*
1294  * The helper to calc the free space on the devices that can be used to store
1295  * file data.
1296  */
1297 static int btrfs_calc_avail_data_space(struct btrfs_root *root, u64 *free_bytes)
1298 {
1299  struct btrfs_fs_info *fs_info = root->fs_info;
1300  struct btrfs_device_info *devices_info;
1301  struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
1302  struct btrfs_device *device;
1303  u64 skip_space;
1304  u64 type;
1305  u64 avail_space;
1306  u64 used_space;
1307  u64 min_stripe_size;
1308  int min_stripes = 1, num_stripes = 1;
1309  int i = 0, nr_devices;
1310  int ret;
1311 
1312  nr_devices = fs_info->fs_devices->open_devices;
1313  BUG_ON(!nr_devices);
1314 
1315  devices_info = kmalloc(sizeof(*devices_info) * nr_devices,
1316  GFP_NOFS);
1317  if (!devices_info)
1318  return -ENOMEM;
1319 
1320  /* calc min stripe number for data space alloction */
1321  type = btrfs_get_alloc_profile(root, 1);
1322  if (type & BTRFS_BLOCK_GROUP_RAID0) {
1323  min_stripes = 2;
1324  num_stripes = nr_devices;
1325  } else if (type & BTRFS_BLOCK_GROUP_RAID1) {
1326  min_stripes = 2;
1327  num_stripes = 2;
1328  } else if (type & BTRFS_BLOCK_GROUP_RAID10) {
1329  min_stripes = 4;
1330  num_stripes = 4;
1331  }
1332 
1333  if (type & BTRFS_BLOCK_GROUP_DUP)
1334  min_stripe_size = 2 * BTRFS_STRIPE_LEN;
1335  else
1336  min_stripe_size = BTRFS_STRIPE_LEN;
1337 
1338  list_for_each_entry(device, &fs_devices->devices, dev_list) {
1339  if (!device->in_fs_metadata || !device->bdev)
1340  continue;
1341 
1342  avail_space = device->total_bytes - device->bytes_used;
1343 
1344  /* align with stripe_len */
1345  do_div(avail_space, BTRFS_STRIPE_LEN);
1346  avail_space *= BTRFS_STRIPE_LEN;
1347 
1348  /*
1349  * In order to avoid overwritting the superblock on the drive,
1350  * btrfs starts at an offset of at least 1MB when doing chunk
1351  * allocation.
1352  */
1353  skip_space = 1024 * 1024;
1354 
1355  /* user can set the offset in fs_info->alloc_start. */
1356  if (fs_info->alloc_start + BTRFS_STRIPE_LEN <=
1357  device->total_bytes)
1358  skip_space = max(fs_info->alloc_start, skip_space);
1359 
1360  /*
1361  * btrfs can not use the free space in [0, skip_space - 1],
1362  * we must subtract it from the total. In order to implement
1363  * it, we account the used space in this range first.
1364  */
1365  ret = btrfs_account_dev_extents_size(device, 0, skip_space - 1,
1366  &used_space);
1367  if (ret) {
1368  kfree(devices_info);
1369  return ret;
1370  }
1371 
1372  /* calc the free space in [0, skip_space - 1] */
1373  skip_space -= used_space;
1374 
1375  /*
1376  * we can use the free space in [0, skip_space - 1], subtract
1377  * it from the total.
1378  */
1379  if (avail_space && avail_space >= skip_space)
1380  avail_space -= skip_space;
1381  else
1382  avail_space = 0;
1383 
1384  if (avail_space < min_stripe_size)
1385  continue;
1386 
1387  devices_info[i].dev = device;
1388  devices_info[i].max_avail = avail_space;
1389 
1390  i++;
1391  }
1392 
1393  nr_devices = i;
1394 
1395  btrfs_descending_sort_devices(devices_info, nr_devices);
1396 
1397  i = nr_devices - 1;
1398  avail_space = 0;
1399  while (nr_devices >= min_stripes) {
1400  if (num_stripes > nr_devices)
1401  num_stripes = nr_devices;
1402 
1403  if (devices_info[i].max_avail >= min_stripe_size) {
1404  int j;
1405  u64 alloc_size;
1406 
1407  avail_space += devices_info[i].max_avail * num_stripes;
1408  alloc_size = devices_info[i].max_avail;
1409  for (j = i + 1 - num_stripes; j <= i; j++)
1410  devices_info[j].max_avail -= alloc_size;
1411  }
1412  i--;
1413  nr_devices--;
1414  }
1415 
1416  kfree(devices_info);
1417  *free_bytes = avail_space;
1418  return 0;
1419 }
1420 
1421 static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
1422 {
1423  struct btrfs_fs_info *fs_info = btrfs_sb(dentry->d_sb);
1424  struct btrfs_super_block *disk_super = fs_info->super_copy;
1425  struct list_head *head = &fs_info->space_info;
1426  struct btrfs_space_info *found;
1427  u64 total_used = 0;
1428  u64 total_free_data = 0;
1429  int bits = dentry->d_sb->s_blocksize_bits;
1430  __be32 *fsid = (__be32 *)fs_info->fsid;
1431  int ret;
1432 
1433  /* holding chunk_muext to avoid allocating new chunks */
1434  mutex_lock(&fs_info->chunk_mutex);
1435  rcu_read_lock();
1436  list_for_each_entry_rcu(found, head, list) {
1437  if (found->flags & BTRFS_BLOCK_GROUP_DATA) {
1438  total_free_data += found->disk_total - found->disk_used;
1439  total_free_data -=
1441  }
1442 
1443  total_used += found->disk_used;
1444  }
1445  rcu_read_unlock();
1446 
1447  buf->f_namelen = BTRFS_NAME_LEN;
1448  buf->f_blocks = btrfs_super_total_bytes(disk_super) >> bits;
1449  buf->f_bfree = buf->f_blocks - (total_used >> bits);
1450  buf->f_bsize = dentry->d_sb->s_blocksize;
1451  buf->f_type = BTRFS_SUPER_MAGIC;
1452  buf->f_bavail = total_free_data;
1453  ret = btrfs_calc_avail_data_space(fs_info->tree_root, &total_free_data);
1454  if (ret) {
1455  mutex_unlock(&fs_info->chunk_mutex);
1456  return ret;
1457  }
1458  buf->f_bavail += total_free_data;
1459  buf->f_bavail = buf->f_bavail >> bits;
1460  mutex_unlock(&fs_info->chunk_mutex);
1461 
1462  /* We treat it as constant endianness (it doesn't matter _which_)
1463  because we want the fsid to come out the same whether mounted
1464  on a big-endian or little-endian host */
1465  buf->f_fsid.val[0] = be32_to_cpu(fsid[0]) ^ be32_to_cpu(fsid[2]);
1466  buf->f_fsid.val[1] = be32_to_cpu(fsid[1]) ^ be32_to_cpu(fsid[3]);
1467  /* Mask in the root object ID too, to disambiguate subvols */
1468  buf->f_fsid.val[0] ^= BTRFS_I(dentry->d_inode)->root->objectid >> 32;
1469  buf->f_fsid.val[1] ^= BTRFS_I(dentry->d_inode)->root->objectid;
1470 
1471  return 0;
1472 }
1473 
1474 static void btrfs_kill_super(struct super_block *sb)
1475 {
1476  struct btrfs_fs_info *fs_info = btrfs_sb(sb);
1477  kill_anon_super(sb);
1478  free_fs_info(fs_info);
1479 }
1480 
1481 static struct file_system_type btrfs_fs_type = {
1482  .owner = THIS_MODULE,
1483  .name = "btrfs",
1484  .mount = btrfs_mount,
1485  .kill_sb = btrfs_kill_super,
1486  .fs_flags = FS_REQUIRES_DEV,
1487 };
1488 
1489 /*
1490  * used by btrfsctl to scan devices when no FS is mounted
1491  */
1492 static long btrfs_control_ioctl(struct file *file, unsigned int cmd,
1493  unsigned long arg)
1494 {
1495  struct btrfs_ioctl_vol_args *vol;
1496  struct btrfs_fs_devices *fs_devices;
1497  int ret = -ENOTTY;
1498 
1499  if (!capable(CAP_SYS_ADMIN))
1500  return -EPERM;
1501 
1502  vol = memdup_user((void __user *)arg, sizeof(*vol));
1503  if (IS_ERR(vol))
1504  return PTR_ERR(vol);
1505 
1506  switch (cmd) {
1507  case BTRFS_IOC_SCAN_DEV:
1509  &btrfs_fs_type, &fs_devices);
1510  break;
1513  &btrfs_fs_type, &fs_devices);
1514  if (ret)
1515  break;
1516  ret = !(fs_devices->num_devices == fs_devices->total_devices);
1517  break;
1518  }
1519 
1520  kfree(vol);
1521  return ret;
1522 }
1523 
1524 static int btrfs_freeze(struct super_block *sb)
1525 {
1526  struct btrfs_trans_handle *trans;
1527  struct btrfs_root *root = btrfs_sb(sb)->tree_root;
1528 
1529  trans = btrfs_attach_transaction(root);
1530  if (IS_ERR(trans)) {
1531  /* no transaction, don't bother */
1532  if (PTR_ERR(trans) == -ENOENT)
1533  return 0;
1534  return PTR_ERR(trans);
1535  }
1536  return btrfs_commit_transaction(trans, root);
1537 }
1538 
1539 static int btrfs_unfreeze(struct super_block *sb)
1540 {
1541  return 0;
1542 }
1543 
1544 static int btrfs_show_devname(struct seq_file *m, struct dentry *root)
1545 {
1546  struct btrfs_fs_info *fs_info = btrfs_sb(root->d_sb);
1547  struct btrfs_fs_devices *cur_devices;
1548  struct btrfs_device *dev, *first_dev = NULL;
1549  struct list_head *head;
1550  struct rcu_string *name;
1551 
1552  mutex_lock(&fs_info->fs_devices->device_list_mutex);
1553  cur_devices = fs_info->fs_devices;
1554  while (cur_devices) {
1555  head = &cur_devices->devices;
1556  list_for_each_entry(dev, head, dev_list) {
1557  if (dev->missing)
1558  continue;
1559  if (!first_dev || dev->devid < first_dev->devid)
1560  first_dev = dev;
1561  }
1562  cur_devices = cur_devices->seed;
1563  }
1564 
1565  if (first_dev) {
1566  rcu_read_lock();
1567  name = rcu_dereference(first_dev->name);
1568  seq_escape(m, name->str, " \t\n\\");
1569  rcu_read_unlock();
1570  } else {
1571  WARN_ON(1);
1572  }
1573  mutex_unlock(&fs_info->fs_devices->device_list_mutex);
1574  return 0;
1575 }
1576 
1577 static const struct super_operations btrfs_super_ops = {
1578  .drop_inode = btrfs_drop_inode,
1579  .evict_inode = btrfs_evict_inode,
1580  .put_super = btrfs_put_super,
1581  .sync_fs = btrfs_sync_fs,
1582  .show_options = btrfs_show_options,
1583  .show_devname = btrfs_show_devname,
1584  .write_inode = btrfs_write_inode,
1585  .alloc_inode = btrfs_alloc_inode,
1586  .destroy_inode = btrfs_destroy_inode,
1587  .statfs = btrfs_statfs,
1588  .remount_fs = btrfs_remount,
1589  .freeze_fs = btrfs_freeze,
1590  .unfreeze_fs = btrfs_unfreeze,
1591 };
1592 
1593 static const struct file_operations btrfs_ctl_fops = {
1594  .unlocked_ioctl = btrfs_control_ioctl,
1595  .compat_ioctl = btrfs_control_ioctl,
1596  .owner = THIS_MODULE,
1597  .llseek = noop_llseek,
1598 };
1599 
1600 static struct miscdevice btrfs_misc = {
1601  .minor = BTRFS_MINOR,
1602  .name = "btrfs-control",
1603  .fops = &btrfs_ctl_fops
1604 };
1605 
1607 MODULE_ALIAS("devname:btrfs-control");
1608 
1609 static int btrfs_interface_init(void)
1610 {
1611  return misc_register(&btrfs_misc);
1612 }
1613 
1614 static void btrfs_interface_exit(void)
1615 {
1616  if (misc_deregister(&btrfs_misc) < 0)
1617  printk(KERN_INFO "btrfs: misc_deregister failed for control device\n");
1618 }
1619 
1620 static int __init init_btrfs_fs(void)
1621 {
1622  int err;
1623 
1624  err = btrfs_init_sysfs();
1625  if (err)
1626  return err;
1627 
1629 
1630  err = btrfs_init_cachep();
1631  if (err)
1632  goto free_compress;
1633 
1634  err = extent_io_init();
1635  if (err)
1636  goto free_cachep;
1637 
1638  err = extent_map_init();
1639  if (err)
1640  goto free_extent_io;
1641 
1642  err = ordered_data_init();
1643  if (err)
1644  goto free_extent_map;
1645 
1646  err = btrfs_delayed_inode_init();
1647  if (err)
1648  goto free_ordered_data;
1649 
1650  err = btrfs_interface_init();
1651  if (err)
1652  goto free_delayed_inode;
1653 
1654  err = register_filesystem(&btrfs_fs_type);
1655  if (err)
1656  goto unregister_ioctl;
1657 
1658  btrfs_init_lockdep();
1659 
1660  printk(KERN_INFO "%s loaded\n", BTRFS_BUILD_VERSION);
1661  return 0;
1662 
1663 unregister_ioctl:
1664  btrfs_interface_exit();
1665 free_delayed_inode:
1667 free_ordered_data:
1670  extent_map_exit();
1671 free_extent_io:
1672  extent_io_exit();
1673 free_cachep:
1675 free_compress:
1677  btrfs_exit_sysfs();
1678  return err;
1679 }
1680 
1681 static void __exit exit_btrfs_fs(void)
1682 {
1686  extent_map_exit();
1687  extent_io_exit();
1688  btrfs_interface_exit();
1689  unregister_filesystem(&btrfs_fs_type);
1690  btrfs_exit_sysfs();
1693 }
1694 
1695 module_init(init_btrfs_fs)
1696 module_exit(exit_btrfs_fs)
1697 
1698 MODULE_LICENSE("GPL");