~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/btrfs/super.c

Version: ~ [ linux-5.8 ] ~ [ linux-5.7.14 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.57 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.138 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.193 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.232 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.232 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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 <linux/btrfs.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 "print-tree.h"
 51 #include "hash.h"
 52 #include "props.h"
 53 #include "xattr.h"
 54 #include "volumes.h"
 55 #include "export.h"
 56 #include "compression.h"
 57 #include "rcu-string.h"
 58 #include "dev-replace.h"
 59 #include "free-space-cache.h"
 60 #include "backref.h"
 61 #include "tests/btrfs-tests.h"
 62 
 63 #include "qgroup.h"
 64 #define CREATE_TRACE_POINTS
 65 #include <trace/events/btrfs.h>
 66 
 67 static const struct super_operations btrfs_super_ops;
 68 static struct file_system_type btrfs_fs_type;
 69 
 70 static int btrfs_remount(struct super_block *sb, int *flags, char *data);
 71 
 72 static const char *btrfs_decode_error(int errno)
 73 {
 74         char *errstr = "unknown";
 75 
 76         switch (errno) {
 77         case -EIO:
 78                 errstr = "IO failure";
 79                 break;
 80         case -ENOMEM:
 81                 errstr = "Out of memory";
 82                 break;
 83         case -EROFS:
 84                 errstr = "Readonly filesystem";
 85                 break;
 86         case -EEXIST:
 87                 errstr = "Object already exists";
 88                 break;
 89         case -ENOSPC:
 90                 errstr = "No space left";
 91                 break;
 92         case -ENOENT:
 93                 errstr = "No such entry";
 94                 break;
 95         }
 96 
 97         return errstr;
 98 }
 99 
100 static void save_error_info(struct btrfs_fs_info *fs_info)
101 {
102         /*
103          * today we only save the error info into ram.  Long term we'll
104          * also send it down to the disk
105          */
106         set_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state);
107 }
108 
109 /* btrfs handle error by forcing the filesystem readonly */
110 static void btrfs_handle_error(struct btrfs_fs_info *fs_info)
111 {
112         struct super_block *sb = fs_info->sb;
113 
114         if (sb->s_flags & MS_RDONLY)
115                 return;
116 
117         if (test_bit(BTRFS_FS_STATE_ERROR, &fs_info->fs_state)) {
118                 sb->s_flags |= MS_RDONLY;
119                 btrfs_info(fs_info, "forced readonly");
120                 /*
121                  * Note that a running device replace operation is not
122                  * canceled here although there is no way to update
123                  * the progress. It would add the risk of a deadlock,
124                  * therefore the canceling is ommited. The only penalty
125                  * is that some I/O remains active until the procedure
126                  * completes. The next time when the filesystem is
127                  * mounted writeable again, the device replace
128                  * operation continues.
129                  */
130         }
131 }
132 
133 #ifdef CONFIG_PRINTK
134 /*
135  * __btrfs_std_error decodes expected errors from the caller and
136  * invokes the approciate error response.
137  */
138 void __btrfs_std_error(struct btrfs_fs_info *fs_info, const char *function,
139                        unsigned int line, int errno, const char *fmt, ...)
140 {
141         struct super_block *sb = fs_info->sb;
142         const char *errstr;
143 
144         /*
145          * Special case: if the error is EROFS, and we're already
146          * under MS_RDONLY, then it is safe here.
147          */
148         if (errno == -EROFS && (sb->s_flags & MS_RDONLY))
149                 return;
150 
151         errstr = btrfs_decode_error(errno);
152         if (fmt) {
153                 struct va_format vaf;
154                 va_list args;
155 
156                 va_start(args, fmt);
157                 vaf.fmt = fmt;
158                 vaf.va = &args;
159 
160                 printk(KERN_CRIT
161                         "BTRFS: error (device %s) in %s:%d: errno=%d %s (%pV)\n",
162                         sb->s_id, function, line, errno, errstr, &vaf);
163                 va_end(args);
164         } else {
165                 printk(KERN_CRIT "BTRFS: error (device %s) in %s:%d: errno=%d %s\n",
166                         sb->s_id, function, line, errno, errstr);
167         }
168 
169         /* Don't go through full error handling during mount */
170         save_error_info(fs_info);
171         if (sb->s_flags & MS_BORN)
172                 btrfs_handle_error(fs_info);
173 }
174 
175 static const char * const logtypes[] = {
176         "emergency",
177         "alert",
178         "critical",
179         "error",
180         "warning",
181         "notice",
182         "info",
183         "debug",
184 };
185 
186 void btrfs_printk(const struct btrfs_fs_info *fs_info, const char *fmt, ...)
187 {
188         struct super_block *sb = fs_info->sb;
189         char lvl[4];
190         struct va_format vaf;
191         va_list args;
192         const char *type = logtypes[4];
193         int kern_level;
194 
195         va_start(args, fmt);
196 
197         kern_level = printk_get_level(fmt);
198         if (kern_level) {
199                 size_t size = printk_skip_level(fmt) - fmt;
200                 memcpy(lvl, fmt,  size);
201                 lvl[size] = '\0';
202                 fmt += size;
203                 type = logtypes[kern_level - ''];
204         } else
205                 *lvl = '\0';
206 
207         vaf.fmt = fmt;
208         vaf.va = &args;
209 
210         printk("%sBTRFS %s (device %s): %pV\n", lvl, type, sb->s_id, &vaf);
211 
212         va_end(args);
213 }
214 
215 #else
216 
217 void __btrfs_std_error(struct btrfs_fs_info *fs_info, const char *function,
218                        unsigned int line, int errno, const char *fmt, ...)
219 {
220         struct super_block *sb = fs_info->sb;
221 
222         /*
223          * Special case: if the error is EROFS, and we're already
224          * under MS_RDONLY, then it is safe here.
225          */
226         if (errno == -EROFS && (sb->s_flags & MS_RDONLY))
227                 return;
228 
229         /* Don't go through full error handling during mount */
230         if (sb->s_flags & MS_BORN) {
231                 save_error_info(fs_info);
232                 btrfs_handle_error(fs_info);
233         }
234 }
235 #endif
236 
237 /*
238  * We only mark the transaction aborted and then set the file system read-only.
239  * This will prevent new transactions from starting or trying to join this
240  * one.
241  *
242  * This means that error recovery at the call site is limited to freeing
243  * any local memory allocations and passing the error code up without
244  * further cleanup. The transaction should complete as it normally would
245  * in the call path but will return -EIO.
246  *
247  * We'll complete the cleanup in btrfs_end_transaction and
248  * btrfs_commit_transaction.
249  */
250 void __btrfs_abort_transaction(struct btrfs_trans_handle *trans,
251                                struct btrfs_root *root, const char *function,
252                                unsigned int line, int errno)
253 {
254         /*
255          * Report first abort since mount
256          */
257         if (!test_and_set_bit(BTRFS_FS_STATE_TRANS_ABORTED,
258                                 &root->fs_info->fs_state)) {
259                 WARN(1, KERN_DEBUG "BTRFS: Transaction aborted (error %d)\n",
260                                 errno);
261         }
262         trans->aborted = errno;
263         /* Nothing used. The other threads that have joined this
264          * transaction may be able to continue. */
265         if (!trans->dirty && list_empty(&trans->new_bgs)) {
266                 const char *errstr;
267 
268                 errstr = btrfs_decode_error(errno);
269                 btrfs_warn(root->fs_info,
270                            "%s:%d: Aborting unused transaction(%s).",
271                            function, line, errstr);
272                 return;
273         }
274         ACCESS_ONCE(trans->transaction->aborted) = errno;
275         /* Wake up anybody who may be waiting on this transaction */
276         wake_up(&root->fs_info->transaction_wait);
277         wake_up(&root->fs_info->transaction_blocked_wait);
278         __btrfs_std_error(root->fs_info, function, line, errno, NULL);
279 }
280 /*
281  * __btrfs_panic decodes unexpected, fatal errors from the caller,
282  * issues an alert, and either panics or BUGs, depending on mount options.
283  */
284 void __btrfs_panic(struct btrfs_fs_info *fs_info, const char *function,
285                    unsigned int line, int errno, const char *fmt, ...)
286 {
287         char *s_id = "<unknown>";
288         const char *errstr;
289         struct va_format vaf = { .fmt = fmt };
290         va_list args;
291 
292         if (fs_info)
293                 s_id = fs_info->sb->s_id;
294 
295         va_start(args, fmt);
296         vaf.va = &args;
297 
298         errstr = btrfs_decode_error(errno);
299         if (fs_info && (fs_info->mount_opt & BTRFS_MOUNT_PANIC_ON_FATAL_ERROR))
300                 panic(KERN_CRIT "BTRFS panic (device %s) in %s:%d: %pV (errno=%d %s)\n",
301                         s_id, function, line, &vaf, errno, errstr);
302 
303         btrfs_crit(fs_info, "panic in %s:%d: %pV (errno=%d %s)",
304                    function, line, &vaf, errno, errstr);
305         va_end(args);
306         /* Caller calls BUG() */
307 }
308 
309 static void btrfs_put_super(struct super_block *sb)
310 {
311         close_ctree(btrfs_sb(sb)->tree_root);
312 }
313 
314 enum {
315         Opt_degraded, Opt_subvol, Opt_subvolid, Opt_device, Opt_nodatasum,
316         Opt_nodatacow, Opt_max_inline, Opt_alloc_start, Opt_nobarrier, Opt_ssd,
317         Opt_nossd, Opt_ssd_spread, Opt_thread_pool, Opt_noacl, Opt_compress,
318         Opt_compress_type, Opt_compress_force, Opt_compress_force_type,
319         Opt_notreelog, Opt_ratio, Opt_flushoncommit, Opt_discard,
320         Opt_space_cache, Opt_clear_cache, Opt_user_subvol_rm_allowed,
321         Opt_enospc_debug, Opt_subvolrootid, Opt_defrag, Opt_inode_cache,
322         Opt_no_space_cache, Opt_recovery, Opt_skip_balance,
323         Opt_check_integrity, Opt_check_integrity_including_extent_data,
324         Opt_check_integrity_print_mask, Opt_fatal_errors, Opt_rescan_uuid_tree,
325         Opt_commit_interval, Opt_barrier, Opt_nodefrag, Opt_nodiscard,
326         Opt_noenospc_debug, Opt_noflushoncommit, Opt_acl, Opt_datacow,
327         Opt_datasum, Opt_treelog, Opt_noinode_cache,
328         Opt_err,
329 };
330 
331 static match_table_t tokens = {
332         {Opt_degraded, "degraded"},
333         {Opt_subvol, "subvol=%s"},
334         {Opt_subvolid, "subvolid=%s"},
335         {Opt_device, "device=%s"},
336         {Opt_nodatasum, "nodatasum"},
337         {Opt_datasum, "datasum"},
338         {Opt_nodatacow, "nodatacow"},
339         {Opt_datacow, "datacow"},
340         {Opt_nobarrier, "nobarrier"},
341         {Opt_barrier, "barrier"},
342         {Opt_max_inline, "max_inline=%s"},
343         {Opt_alloc_start, "alloc_start=%s"},
344         {Opt_thread_pool, "thread_pool=%d"},
345         {Opt_compress, "compress"},
346         {Opt_compress_type, "compress=%s"},
347         {Opt_compress_force, "compress-force"},
348         {Opt_compress_force_type, "compress-force=%s"},
349         {Opt_ssd, "ssd"},
350         {Opt_ssd_spread, "ssd_spread"},
351         {Opt_nossd, "nossd"},
352         {Opt_acl, "acl"},
353         {Opt_noacl, "noacl"},
354         {Opt_notreelog, "notreelog"},
355         {Opt_treelog, "treelog"},
356         {Opt_flushoncommit, "flushoncommit"},
357         {Opt_noflushoncommit, "noflushoncommit"},
358         {Opt_ratio, "metadata_ratio=%d"},
359         {Opt_discard, "discard"},
360         {Opt_nodiscard, "nodiscard"},
361         {Opt_space_cache, "space_cache"},
362         {Opt_clear_cache, "clear_cache"},
363         {Opt_user_subvol_rm_allowed, "user_subvol_rm_allowed"},
364         {Opt_enospc_debug, "enospc_debug"},
365         {Opt_noenospc_debug, "noenospc_debug"},
366         {Opt_subvolrootid, "subvolrootid=%d"},
367         {Opt_defrag, "autodefrag"},
368         {Opt_nodefrag, "noautodefrag"},
369         {Opt_inode_cache, "inode_cache"},
370         {Opt_noinode_cache, "noinode_cache"},
371         {Opt_no_space_cache, "nospace_cache"},
372         {Opt_recovery, "recovery"},
373         {Opt_skip_balance, "skip_balance"},
374         {Opt_check_integrity, "check_int"},
375         {Opt_check_integrity_including_extent_data, "check_int_data"},
376         {Opt_check_integrity_print_mask, "check_int_print_mask=%d"},
377         {Opt_rescan_uuid_tree, "rescan_uuid_tree"},
378         {Opt_fatal_errors, "fatal_errors=%s"},
379         {Opt_commit_interval, "commit=%d"},
380         {Opt_err, NULL},
381 };
382 
383 /*
384  * Regular mount options parser.  Everything that is needed only when
385  * reading in a new superblock is parsed here.
386  * XXX JDM: This needs to be cleaned up for remount.
387  */
388 int btrfs_parse_options(struct btrfs_root *root, char *options)
389 {
390         struct btrfs_fs_info *info = root->fs_info;
391         substring_t args[MAX_OPT_ARGS];
392         char *p, *num, *orig = NULL;
393         u64 cache_gen;
394         int intarg;
395         int ret = 0;
396         char *compress_type;
397         bool compress_force = false;
398 
399         cache_gen = btrfs_super_cache_generation(root->fs_info->super_copy);
400         if (cache_gen)
401                 btrfs_set_opt(info->mount_opt, SPACE_CACHE);
402 
403         if (!options)
404                 goto out;
405 
406         /*
407          * strsep changes the string, duplicate it because parse_options
408          * gets called twice
409          */
410         options = kstrdup(options, GFP_NOFS);
411         if (!options)
412                 return -ENOMEM;
413 
414         orig = options;
415 
416         while ((p = strsep(&options, ",")) != NULL) {
417                 int token;
418                 if (!*p)
419                         continue;
420 
421                 token = match_token(p, tokens, args);
422                 switch (token) {
423                 case Opt_degraded:
424                         btrfs_info(root->fs_info, "allowing degraded mounts");
425                         btrfs_set_opt(info->mount_opt, DEGRADED);
426                         break;
427                 case Opt_subvol:
428                 case Opt_subvolid:
429                 case Opt_subvolrootid:
430                 case Opt_device:
431                         /*
432                          * These are parsed by btrfs_parse_early_options
433                          * and can be happily ignored here.
434                          */
435                         break;
436                 case Opt_nodatasum:
437                         btrfs_set_and_info(root, NODATASUM,
438                                            "setting nodatasum");
439                         break;
440                 case Opt_datasum:
441                         if (btrfs_test_opt(root, NODATASUM)) {
442                                 if (btrfs_test_opt(root, NODATACOW))
443                                         btrfs_info(root->fs_info, "setting datasum, datacow enabled");
444                                 else
445                                         btrfs_info(root->fs_info, "setting datasum");
446                         }
447                         btrfs_clear_opt(info->mount_opt, NODATACOW);
448                         btrfs_clear_opt(info->mount_opt, NODATASUM);
449                         break;
450                 case Opt_nodatacow:
451                         if (!btrfs_test_opt(root, NODATACOW)) {
452                                 if (!btrfs_test_opt(root, COMPRESS) ||
453                                     !btrfs_test_opt(root, FORCE_COMPRESS)) {
454                                         btrfs_info(root->fs_info,
455                                                    "setting nodatacow, compression disabled");
456                                 } else {
457                                         btrfs_info(root->fs_info, "setting nodatacow");
458                                 }
459                         }
460                         btrfs_clear_opt(info->mount_opt, COMPRESS);
461                         btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
462                         btrfs_set_opt(info->mount_opt, NODATACOW);
463                         btrfs_set_opt(info->mount_opt, NODATASUM);
464                         break;
465                 case Opt_datacow:
466                         btrfs_clear_and_info(root, NODATACOW,
467                                              "setting datacow");
468                         break;
469                 case Opt_compress_force:
470                 case Opt_compress_force_type:
471                         compress_force = true;
472                         /* Fallthrough */
473                 case Opt_compress:
474                 case Opt_compress_type:
475                         if (token == Opt_compress ||
476                             token == Opt_compress_force ||
477                             strcmp(args[0].from, "zlib") == 0) {
478                                 compress_type = "zlib";
479                                 info->compress_type = BTRFS_COMPRESS_ZLIB;
480                                 btrfs_set_opt(info->mount_opt, COMPRESS);
481                                 btrfs_clear_opt(info->mount_opt, NODATACOW);
482                                 btrfs_clear_opt(info->mount_opt, NODATASUM);
483                         } else if (strcmp(args[0].from, "lzo") == 0) {
484                                 compress_type = "lzo";
485                                 info->compress_type = BTRFS_COMPRESS_LZO;
486                                 btrfs_set_opt(info->mount_opt, COMPRESS);
487                                 btrfs_clear_opt(info->mount_opt, NODATACOW);
488                                 btrfs_clear_opt(info->mount_opt, NODATASUM);
489                                 btrfs_set_fs_incompat(info, COMPRESS_LZO);
490                         } else if (strncmp(args[0].from, "no", 2) == 0) {
491                                 compress_type = "no";
492                                 btrfs_clear_opt(info->mount_opt, COMPRESS);
493                                 btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
494                                 compress_force = false;
495                         } else {
496                                 ret = -EINVAL;
497                                 goto out;
498                         }
499 
500                         if (compress_force) {
501                                 btrfs_set_and_info(root, FORCE_COMPRESS,
502                                                    "force %s compression",
503                                                    compress_type);
504                         } else {
505                                 if (!btrfs_test_opt(root, COMPRESS))
506                                         btrfs_info(root->fs_info,
507                                                    "btrfs: use %s compression",
508                                                    compress_type);
509                                 /*
510                                  * If we remount from compress-force=xxx to
511                                  * compress=xxx, we need clear FORCE_COMPRESS
512                                  * flag, otherwise, there is no way for users
513                                  * to disable forcible compression separately.
514                                  */
515                                 btrfs_clear_opt(info->mount_opt, FORCE_COMPRESS);
516                         }
517                         break;
518                 case Opt_ssd:
519                         btrfs_set_and_info(root, SSD,
520                                            "use ssd allocation scheme");
521                         break;
522                 case Opt_ssd_spread:
523                         btrfs_set_and_info(root, SSD_SPREAD,
524                                            "use spread ssd allocation scheme");
525                         btrfs_set_opt(info->mount_opt, SSD);
526                         break;
527                 case Opt_nossd:
528                         btrfs_set_and_info(root, NOSSD,
529                                              "not using ssd allocation scheme");
530                         btrfs_clear_opt(info->mount_opt, SSD);
531                         break;
532                 case Opt_barrier:
533                         btrfs_clear_and_info(root, NOBARRIER,
534                                              "turning on barriers");
535                         break;
536                 case Opt_nobarrier:
537                         btrfs_set_and_info(root, NOBARRIER,
538                                            "turning off barriers");
539                         break;
540                 case Opt_thread_pool:
541                         ret = match_int(&args[0], &intarg);
542                         if (ret) {
543                                 goto out;
544                         } else if (intarg > 0) {
545                                 info->thread_pool_size = intarg;
546                         } else {
547                                 ret = -EINVAL;
548                                 goto out;
549                         }
550                         break;
551                 case Opt_max_inline:
552                         num = match_strdup(&args[0]);
553                         if (num) {
554                                 info->max_inline = memparse(num, NULL);
555                                 kfree(num);
556 
557                                 if (info->max_inline) {
558                                         info->max_inline = min_t(u64,
559                                                 info->max_inline,
560                                                 root->sectorsize);
561                                 }
562                                 btrfs_info(root->fs_info, "max_inline at %llu",
563                                         info->max_inline);
564                         } else {
565                                 ret = -ENOMEM;
566                                 goto out;
567                         }
568                         break;
569                 case Opt_alloc_start:
570                         num = match_strdup(&args[0]);
571                         if (num) {
572                                 mutex_lock(&info->chunk_mutex);
573                                 info->alloc_start = memparse(num, NULL);
574                                 mutex_unlock(&info->chunk_mutex);
575                                 kfree(num);
576                                 btrfs_info(root->fs_info, "allocations start at %llu",
577                                         info->alloc_start);
578                         } else {
579                                 ret = -ENOMEM;
580                                 goto out;
581                         }
582                         break;
583                 case Opt_acl:
584 #ifdef CONFIG_BTRFS_FS_POSIX_ACL
585                         root->fs_info->sb->s_flags |= MS_POSIXACL;
586                         break;
587 #else
588                         btrfs_err(root->fs_info,
589                                 "support for ACL not compiled in!");
590                         ret = -EINVAL;
591                         goto out;
592 #endif
593                 case Opt_noacl:
594                         root->fs_info->sb->s_flags &= ~MS_POSIXACL;
595                         break;
596                 case Opt_notreelog:
597                         btrfs_set_and_info(root, NOTREELOG,
598                                            "disabling tree log");
599                         break;
600                 case Opt_treelog:
601                         btrfs_clear_and_info(root, NOTREELOG,
602                                              "enabling tree log");
603                         break;
604                 case Opt_flushoncommit:
605                         btrfs_set_and_info(root, FLUSHONCOMMIT,
606                                            "turning on flush-on-commit");
607                         break;
608                 case Opt_noflushoncommit:
609                         btrfs_clear_and_info(root, FLUSHONCOMMIT,
610                                              "turning off flush-on-commit");
611                         break;
612                 case Opt_ratio:
613                         ret = match_int(&args[0], &intarg);
614                         if (ret) {
615                                 goto out;
616                         } else if (intarg >= 0) {
617                                 info->metadata_ratio = intarg;
618                                 btrfs_info(root->fs_info, "metadata ratio %d",
619                                        info->metadata_ratio);
620                         } else {
621                                 ret = -EINVAL;
622                                 goto out;
623                         }
624                         break;
625                 case Opt_discard:
626                         btrfs_set_and_info(root, DISCARD,
627                                            "turning on discard");
628                         break;
629                 case Opt_nodiscard:
630                         btrfs_clear_and_info(root, DISCARD,
631                                              "turning off discard");
632                         break;
633                 case Opt_space_cache:
634                         btrfs_set_and_info(root, SPACE_CACHE,
635                                            "enabling disk space caching");
636                         break;
637                 case Opt_rescan_uuid_tree:
638                         btrfs_set_opt(info->mount_opt, RESCAN_UUID_TREE);
639                         break;
640                 case Opt_no_space_cache:
641                         btrfs_clear_and_info(root, SPACE_CACHE,
642                                              "disabling disk space caching");
643                         break;
644                 case Opt_inode_cache:
645                         btrfs_set_and_info(root, CHANGE_INODE_CACHE,
646                                            "enabling inode map caching");
647                         break;
648                 case Opt_noinode_cache:
649                         btrfs_clear_and_info(root, CHANGE_INODE_CACHE,
650                                              "disabling inode map caching");
651                         break;
652                 case Opt_clear_cache:
653                         btrfs_set_and_info(root, CLEAR_CACHE,
654                                            "force clearing of disk cache");
655                         break;
656                 case Opt_user_subvol_rm_allowed:
657                         btrfs_set_opt(info->mount_opt, USER_SUBVOL_RM_ALLOWED);
658                         break;
659                 case Opt_enospc_debug:
660                         btrfs_set_opt(info->mount_opt, ENOSPC_DEBUG);
661                         break;
662                 case Opt_noenospc_debug:
663                         btrfs_clear_opt(info->mount_opt, ENOSPC_DEBUG);
664                         break;
665                 case Opt_defrag:
666                         btrfs_set_and_info(root, AUTO_DEFRAG,
667                                            "enabling auto defrag");
668                         break;
669                 case Opt_nodefrag:
670                         btrfs_clear_and_info(root, AUTO_DEFRAG,
671                                              "disabling auto defrag");
672                         break;
673                 case Opt_recovery:
674                         btrfs_info(root->fs_info, "enabling auto recovery");
675                         btrfs_set_opt(info->mount_opt, RECOVERY);
676                         break;
677                 case Opt_skip_balance:
678                         btrfs_set_opt(info->mount_opt, SKIP_BALANCE);
679                         break;
680 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
681                 case Opt_check_integrity_including_extent_data:
682                         btrfs_info(root->fs_info,
683                                    "enabling check integrity including extent data");
684                         btrfs_set_opt(info->mount_opt,
685                                       CHECK_INTEGRITY_INCLUDING_EXTENT_DATA);
686                         btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY);
687                         break;
688                 case Opt_check_integrity:
689                         btrfs_info(root->fs_info, "enabling check integrity");
690                         btrfs_set_opt(info->mount_opt, CHECK_INTEGRITY);
691                         break;
692                 case Opt_check_integrity_print_mask:
693                         ret = match_int(&args[0], &intarg);
694                         if (ret) {
695                                 goto out;
696                         } else if (intarg >= 0) {
697                                 info->check_integrity_print_mask = intarg;
698                                 btrfs_info(root->fs_info, "check_integrity_print_mask 0x%x",
699                                        info->check_integrity_print_mask);
700                         } else {
701                                 ret = -EINVAL;
702                                 goto out;
703                         }
704                         break;
705 #else
706                 case Opt_check_integrity_including_extent_data:
707                 case Opt_check_integrity:
708                 case Opt_check_integrity_print_mask:
709                         btrfs_err(root->fs_info,
710                                 "support for check_integrity* not compiled in!");
711                         ret = -EINVAL;
712                         goto out;
713 #endif
714                 case Opt_fatal_errors:
715                         if (strcmp(args[0].from, "panic") == 0)
716                                 btrfs_set_opt(info->mount_opt,
717                                               PANIC_ON_FATAL_ERROR);
718                         else if (strcmp(args[0].from, "bug") == 0)
719                                 btrfs_clear_opt(info->mount_opt,
720                                               PANIC_ON_FATAL_ERROR);
721                         else {
722                                 ret = -EINVAL;
723                                 goto out;
724                         }
725                         break;
726                 case Opt_commit_interval:
727                         intarg = 0;
728                         ret = match_int(&args[0], &intarg);
729                         if (ret < 0) {
730                                 btrfs_err(root->fs_info, "invalid commit interval");
731                                 ret = -EINVAL;
732                                 goto out;
733                         }
734                         if (intarg > 0) {
735                                 if (intarg > 300) {
736                                         btrfs_warn(root->fs_info, "excessive commit interval %d",
737                                                         intarg);
738                                 }
739                                 info->commit_interval = intarg;
740                         } else {
741                                 btrfs_info(root->fs_info, "using default commit interval %ds",
742                                     BTRFS_DEFAULT_COMMIT_INTERVAL);
743                                 info->commit_interval = BTRFS_DEFAULT_COMMIT_INTERVAL;
744                         }
745                         break;
746                 case Opt_err:
747                         btrfs_info(root->fs_info, "unrecognized mount option '%s'", p);
748                         ret = -EINVAL;
749                         goto out;
750                 default:
751                         break;
752                 }
753         }
754 out:
755         if (!ret && btrfs_test_opt(root, SPACE_CACHE))
756                 btrfs_info(root->fs_info, "disk space caching is enabled");
757         kfree(orig);
758         return ret;
759 }
760 
761 /*
762  * Parse mount options that are required early in the mount process.
763  *
764  * All other options will be parsed on much later in the mount process and
765  * only when we need to allocate a new super block.
766  */
767 static int btrfs_parse_early_options(const char *options, fmode_t flags,
768                 void *holder, char **subvol_name, u64 *subvol_objectid,
769                 struct btrfs_fs_devices **fs_devices)
770 {
771         substring_t args[MAX_OPT_ARGS];
772         char *device_name, *opts, *orig, *p;
773         char *num = NULL;
774         int error = 0;
775 
776         if (!options)
777                 return 0;
778 
779         /*
780          * strsep changes the string, duplicate it because parse_options
781          * gets called twice
782          */
783         opts = kstrdup(options, GFP_KERNEL);
784         if (!opts)
785                 return -ENOMEM;
786         orig = opts;
787 
788         while ((p = strsep(&opts, ",")) != NULL) {
789                 int token;
790                 if (!*p)
791                         continue;
792 
793                 token = match_token(p, tokens, args);
794                 switch (token) {
795                 case Opt_subvol:
796                         kfree(*subvol_name);
797                         *subvol_name = match_strdup(&args[0]);
798                         if (!*subvol_name) {
799                                 error = -ENOMEM;
800                                 goto out;
801                         }
802                         break;
803                 case Opt_subvolid:
804                         num = match_strdup(&args[0]);
805                         if (num) {
806                                 *subvol_objectid = memparse(num, NULL);
807                                 kfree(num);
808                                 /* we want the original fs_tree */
809                                 if (!*subvol_objectid)
810                                         *subvol_objectid =
811                                                 BTRFS_FS_TREE_OBJECTID;
812                         } else {
813                                 error = -EINVAL;
814                                 goto out;
815                         }
816                         break;
817                 case Opt_subvolrootid:
818                         printk(KERN_WARNING
819                                 "BTRFS: 'subvolrootid' mount option is deprecated and has "
820                                 "no effect\n");
821                         break;
822                 case Opt_device:
823                         device_name = match_strdup(&args[0]);
824                         if (!device_name) {
825                                 error = -ENOMEM;
826                                 goto out;
827                         }
828                         error = btrfs_scan_one_device(device_name,
829                                         flags, holder, fs_devices);
830                         kfree(device_name);
831                         if (error)
832                                 goto out;
833                         break;
834                 default:
835                         break;
836                 }
837         }
838 
839 out:
840         kfree(orig);
841         return error;
842 }
843 
844 static struct dentry *get_default_root(struct super_block *sb,
845                                        u64 subvol_objectid)
846 {
847         struct btrfs_fs_info *fs_info = btrfs_sb(sb);
848         struct btrfs_root *root = fs_info->tree_root;
849         struct btrfs_root *new_root;
850         struct btrfs_dir_item *di;
851         struct btrfs_path *path;
852         struct btrfs_key location;
853         struct inode *inode;
854         u64 dir_id;
855         int new = 0;
856 
857         /*
858          * We have a specific subvol we want to mount, just setup location and
859          * go look up the root.
860          */
861         if (subvol_objectid) {
862                 location.objectid = subvol_objectid;
863                 location.type = BTRFS_ROOT_ITEM_KEY;
864                 location.offset = (u64)-1;
865                 goto find_root;
866         }
867 
868         path = btrfs_alloc_path();
869         if (!path)
870                 return ERR_PTR(-ENOMEM);
871         path->leave_spinning = 1;
872 
873         /*
874          * Find the "default" dir item which points to the root item that we
875          * will mount by default if we haven't been given a specific subvolume
876          * to mount.
877          */
878         dir_id = btrfs_super_root_dir(fs_info->super_copy);
879         di = btrfs_lookup_dir_item(NULL, root, path, dir_id, "default", 7, 0);
880         if (IS_ERR(di)) {
881                 btrfs_free_path(path);
882                 return ERR_CAST(di);
883         }
884         if (!di) {
885                 /*
886                  * Ok the default dir item isn't there.  This is weird since
887                  * it's always been there, but don't freak out, just try and
888                  * mount to root most subvolume.
889                  */
890                 btrfs_free_path(path);
891                 dir_id = BTRFS_FIRST_FREE_OBJECTID;
892                 new_root = fs_info->fs_root;
893                 goto setup_root;
894         }
895 
896         btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
897         btrfs_free_path(path);
898 
899 find_root:
900         new_root = btrfs_read_fs_root_no_name(fs_info, &location);
901         if (IS_ERR(new_root))
902                 return ERR_CAST(new_root);
903 
904         if (!(sb->s_flags & MS_RDONLY)) {
905                 int ret;
906                 down_read(&fs_info->cleanup_work_sem);
907                 ret = btrfs_orphan_cleanup(new_root);
908                 up_read(&fs_info->cleanup_work_sem);
909                 if (ret)
910                         return ERR_PTR(ret);
911         }
912 
913         dir_id = btrfs_root_dirid(&new_root->root_item);
914 setup_root:
915         location.objectid = dir_id;
916         location.type = BTRFS_INODE_ITEM_KEY;
917         location.offset = 0;
918 
919         inode = btrfs_iget(sb, &location, new_root, &new);
920         if (IS_ERR(inode))
921                 return ERR_CAST(inode);
922 
923         /*
924          * If we're just mounting the root most subvol put the inode and return
925          * a reference to the dentry.  We will have already gotten a reference
926          * to the inode in btrfs_fill_super so we're good to go.
927          */
928         if (!new && sb->s_root->d_inode == inode) {
929                 iput(inode);
930                 return dget(sb->s_root);
931         }
932 
933         return d_obtain_root(inode);
934 }
935 
936 static int btrfs_fill_super(struct super_block *sb,
937                             struct btrfs_fs_devices *fs_devices,
938                             void *data, int silent)
939 {
940         struct inode *inode;
941         struct btrfs_fs_info *fs_info = btrfs_sb(sb);
942         struct btrfs_key key;
943         int err;
944 
945         sb->s_maxbytes = MAX_LFS_FILESIZE;
946         sb->s_magic = BTRFS_SUPER_MAGIC;
947         sb->s_op = &btrfs_super_ops;
948         sb->s_d_op = &btrfs_dentry_operations;
949         sb->s_export_op = &btrfs_export_ops;
950         sb->s_xattr = btrfs_xattr_handlers;
951         sb->s_time_gran = 1;
952 #ifdef CONFIG_BTRFS_FS_POSIX_ACL
953         sb->s_flags |= MS_POSIXACL;
954 #endif
955         sb->s_flags |= MS_I_VERSION;
956         err = open_ctree(sb, fs_devices, (char *)data);
957         if (err) {
958                 printk(KERN_ERR "BTRFS: open_ctree failed\n");
959                 return err;
960         }
961 
962         key.objectid = BTRFS_FIRST_FREE_OBJECTID;
963         key.type = BTRFS_INODE_ITEM_KEY;
964         key.offset = 0;
965         inode = btrfs_iget(sb, &key, fs_info->fs_root, NULL);
966         if (IS_ERR(inode)) {
967                 err = PTR_ERR(inode);
968                 goto fail_close;
969         }
970 
971         sb->s_root = d_make_root(inode);
972         if (!sb->s_root) {
973                 err = -ENOMEM;
974                 goto fail_close;
975         }
976 
977         save_mount_options(sb, data);
978         cleancache_init_fs(sb);
979         sb->s_flags |= MS_ACTIVE;
980         return 0;
981 
982 fail_close:
983         close_ctree(fs_info->tree_root);
984         return err;
985 }
986 
987 int btrfs_sync_fs(struct super_block *sb, int wait)
988 {
989         struct btrfs_trans_handle *trans;
990         struct btrfs_fs_info *fs_info = btrfs_sb(sb);
991         struct btrfs_root *root = fs_info->tree_root;
992 
993         trace_btrfs_sync_fs(wait);
994 
995         if (!wait) {
996                 filemap_flush(fs_info->btree_inode->i_mapping);
997                 return 0;
998         }
999 
1000         btrfs_wait_ordered_roots(fs_info, -1);
1001 
1002         trans = btrfs_attach_transaction_barrier(root);
1003         if (IS_ERR(trans)) {
1004                 /* no transaction, don't bother */
1005                 if (PTR_ERR(trans) == -ENOENT)
1006                         return 0;
1007                 return PTR_ERR(trans);
1008         }
1009         return btrfs_commit_transaction(trans, root);
1010 }
1011 
1012 static int btrfs_show_options(struct seq_file *seq, struct dentry *dentry)
1013 {
1014         struct btrfs_fs_info *info = btrfs_sb(dentry->d_sb);
1015         struct btrfs_root *root = info->tree_root;
1016         char *compress_type;
1017 
1018         if (btrfs_test_opt(root, DEGRADED))
1019                 seq_puts(seq, ",degraded");
1020         if (btrfs_test_opt(root, NODATASUM))
1021                 seq_puts(seq, ",nodatasum");
1022         if (btrfs_test_opt(root, NODATACOW))
1023                 seq_puts(seq, ",nodatacow");
1024         if (btrfs_test_opt(root, NOBARRIER))
1025                 seq_puts(seq, ",nobarrier");
1026         if (info->max_inline != BTRFS_DEFAULT_MAX_INLINE)
1027                 seq_printf(seq, ",max_inline=%llu", info->max_inline);
1028         if (info->alloc_start != 0)
1029                 seq_printf(seq, ",alloc_start=%llu", info->alloc_start);
1030         if (info->thread_pool_size !=  min_t(unsigned long,
1031                                              num_online_cpus() + 2, 8))
1032                 seq_printf(seq, ",thread_pool=%d", info->thread_pool_size);
1033         if (btrfs_test_opt(root, COMPRESS)) {
1034                 if (info->compress_type == BTRFS_COMPRESS_ZLIB)
1035                         compress_type = "zlib";
1036                 else
1037                         compress_type = "lzo";
1038                 if (btrfs_test_opt(root, FORCE_COMPRESS))
1039                         seq_printf(seq, ",compress-force=%s", compress_type);
1040                 else
1041                         seq_printf(seq, ",compress=%s", compress_type);
1042         }
1043         if (btrfs_test_opt(root, NOSSD))
1044                 seq_puts(seq, ",nossd");
1045         if (btrfs_test_opt(root, SSD_SPREAD))
1046                 seq_puts(seq, ",ssd_spread");
1047         else if (btrfs_test_opt(root, SSD))
1048                 seq_puts(seq, ",ssd");
1049         if (btrfs_test_opt(root, NOTREELOG))
1050                 seq_puts(seq, ",notreelog");
1051         if (btrfs_test_opt(root, FLUSHONCOMMIT))
1052                 seq_puts(seq, ",flushoncommit");
1053         if (btrfs_test_opt(root, DISCARD))
1054                 seq_puts(seq, ",discard");
1055         if (!(root->fs_info->sb->s_flags & MS_POSIXACL))
1056                 seq_puts(seq, ",noacl");
1057         if (btrfs_test_opt(root, SPACE_CACHE))
1058                 seq_puts(seq, ",space_cache");
1059         else
1060                 seq_puts(seq, ",nospace_cache");
1061         if (btrfs_test_opt(root, RESCAN_UUID_TREE))
1062                 seq_puts(seq, ",rescan_uuid_tree");
1063         if (btrfs_test_opt(root, CLEAR_CACHE))
1064                 seq_puts(seq, ",clear_cache");
1065         if (btrfs_test_opt(root, USER_SUBVOL_RM_ALLOWED))
1066                 seq_puts(seq, ",user_subvol_rm_allowed");
1067         if (btrfs_test_opt(root, ENOSPC_DEBUG))
1068                 seq_puts(seq, ",enospc_debug");
1069         if (btrfs_test_opt(root, AUTO_DEFRAG))
1070                 seq_puts(seq, ",autodefrag");
1071         if (btrfs_test_opt(root, INODE_MAP_CACHE))
1072                 seq_puts(seq, ",inode_cache");
1073         if (btrfs_test_opt(root, SKIP_BALANCE))
1074                 seq_puts(seq, ",skip_balance");
1075         if (btrfs_test_opt(root, RECOVERY))
1076                 seq_puts(seq, ",recovery");
1077 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
1078         if (btrfs_test_opt(root, CHECK_INTEGRITY_INCLUDING_EXTENT_DATA))
1079                 seq_puts(seq, ",check_int_data");
1080         else if (btrfs_test_opt(root, CHECK_INTEGRITY))
1081                 seq_puts(seq, ",check_int");
1082         if (info->check_integrity_print_mask)
1083                 seq_printf(seq, ",check_int_print_mask=%d",
1084                                 info->check_integrity_print_mask);
1085 #endif
1086         if (info->metadata_ratio)
1087                 seq_printf(seq, ",metadata_ratio=%d",
1088                                 info->metadata_ratio);
1089         if (btrfs_test_opt(root, PANIC_ON_FATAL_ERROR))
1090                 seq_puts(seq, ",fatal_errors=panic");
1091         if (info->commit_interval != BTRFS_DEFAULT_COMMIT_INTERVAL)
1092                 seq_printf(seq, ",commit=%d", info->commit_interval);
1093         return 0;
1094 }
1095 
1096 static int btrfs_test_super(struct super_block *s, void *data)
1097 {
1098         struct btrfs_fs_info *p = data;
1099         struct btrfs_fs_info *fs_info = btrfs_sb(s);
1100 
1101         return fs_info->fs_devices == p->fs_devices;
1102 }
1103 
1104 static int btrfs_set_super(struct super_block *s, void *data)
1105 {
1106         int err = set_anon_super(s, data);
1107         if (!err)
1108                 s->s_fs_info = data;
1109         return err;
1110 }
1111 
1112 /*
1113  * subvolumes are identified by ino 256
1114  */
1115 static inline int is_subvolume_inode(struct inode *inode)
1116 {
1117         if (inode && inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)
1118                 return 1;
1119         return 0;
1120 }
1121 
1122 /*
1123  * This will strip out the subvol=%s argument for an argument string and add
1124  * subvolid=0 to make sure we get the actual tree root for path walking to the
1125  * subvol we want.
1126  */
1127 static char *setup_root_args(char *args)
1128 {
1129         unsigned len = strlen(args) + 2 + 1;
1130         char *src, *dst, *buf;
1131 
1132         /*
1133          * We need the same args as before, but with this substitution:
1134          * s!subvol=[^,]+!subvolid=0!
1135          *
1136          * Since the replacement string is up to 2 bytes longer than the
1137          * original, allocate strlen(args) + 2 + 1 bytes.
1138          */
1139 
1140         src = strstr(args, "subvol=");
1141         /* This shouldn't happen, but just in case.. */
1142         if (!src)
1143                 return NULL;
1144 
1145         buf = dst = kmalloc(len, GFP_NOFS);
1146         if (!buf)
1147                 return NULL;
1148 
1149         /*
1150          * If the subvol= arg is not at the start of the string,
1151          * copy whatever precedes it into buf.
1152          */
1153         if (src != args) {
1154                 *src++ = '\0';
1155                 strcpy(buf, args);
1156                 dst += strlen(args);
1157         }
1158 
1159         strcpy(dst, "subvolid=0");
1160         dst += strlen("subvolid=0");
1161 
1162         /*
1163          * If there is a "," after the original subvol=... string,
1164          * copy that suffix into our buffer.  Otherwise, we're done.
1165          */
1166         src = strchr(src, ',');
1167         if (src)
1168                 strcpy(dst, src);
1169 
1170         return buf;
1171 }
1172 
1173 static struct dentry *mount_subvol(const char *subvol_name, int flags,
1174                                    const char *device_name, char *data)
1175 {
1176         struct dentry *root;
1177         struct vfsmount *mnt;
1178         char *newargs;
1179 
1180         newargs = setup_root_args(data);
1181         if (!newargs)
1182                 return ERR_PTR(-ENOMEM);
1183         mnt = vfs_kern_mount(&btrfs_fs_type, flags, device_name,
1184                              newargs);
1185 
1186         if (PTR_RET(mnt) == -EBUSY) {
1187                 if (flags & MS_RDONLY) {
1188                         mnt = vfs_kern_mount(&btrfs_fs_type, flags & ~MS_RDONLY, device_name,
1189                                              newargs);
1190                 } else {
1191                         int r;
1192                         mnt = vfs_kern_mount(&btrfs_fs_type, flags | MS_RDONLY, device_name,
1193                                              newargs);
1194                         if (IS_ERR(mnt)) {
1195                                 kfree(newargs);
1196                                 return ERR_CAST(mnt);
1197                         }
1198 
1199                         r = btrfs_remount(mnt->mnt_sb, &flags, NULL);
1200                         if (r < 0) {
1201                                 /* FIXME: release vfsmount mnt ??*/
1202                                 kfree(newargs);
1203                                 return ERR_PTR(r);
1204                         }
1205                 }
1206         }
1207 
1208         kfree(newargs);
1209 
1210         if (IS_ERR(mnt))
1211                 return ERR_CAST(mnt);
1212 
1213         root = mount_subtree(mnt, subvol_name);
1214 
1215         if (!IS_ERR(root) && !is_subvolume_inode(root->d_inode)) {
1216                 struct super_block *s = root->d_sb;
1217                 dput(root);
1218                 root = ERR_PTR(-EINVAL);
1219                 deactivate_locked_super(s);
1220                 printk(KERN_ERR "BTRFS: '%s' is not a valid subvolume\n",
1221                                 subvol_name);
1222         }
1223 
1224         return root;
1225 }
1226 
1227 static int parse_security_options(char *orig_opts,
1228                                   struct security_mnt_opts *sec_opts)
1229 {
1230         char *secdata = NULL;
1231         int ret = 0;
1232 
1233         secdata = alloc_secdata();
1234         if (!secdata)
1235                 return -ENOMEM;
1236         ret = security_sb_copy_data(orig_opts, secdata);
1237         if (ret) {
1238                 free_secdata(secdata);
1239                 return ret;
1240         }
1241         ret = security_sb_parse_opts_str(secdata, sec_opts);
1242         free_secdata(secdata);
1243         return ret;
1244 }
1245 
1246 static int setup_security_options(struct btrfs_fs_info *fs_info,
1247                                   struct super_block *sb,
1248                                   struct security_mnt_opts *sec_opts)
1249 {
1250         int ret = 0;
1251 
1252         /*
1253          * Call security_sb_set_mnt_opts() to check whether new sec_opts
1254          * is valid.
1255          */
1256         ret = security_sb_set_mnt_opts(sb, sec_opts, 0, NULL);
1257         if (ret)
1258                 return ret;
1259 
1260 #ifdef CONFIG_SECURITY
1261         if (!fs_info->security_opts.num_mnt_opts) {
1262                 /* first time security setup, copy sec_opts to fs_info */
1263                 memcpy(&fs_info->security_opts, sec_opts, sizeof(*sec_opts));
1264         } else {
1265                 /*
1266                  * Since SELinux(the only one supports security_mnt_opts) does
1267                  * NOT support changing context during remount/mount same sb,
1268                  * This must be the same or part of the same security options,
1269                  * just free it.
1270                  */
1271                 security_free_mnt_opts(sec_opts);
1272         }
1273 #endif
1274         return ret;
1275 }
1276 
1277 /*
1278  * Find a superblock for the given device / mount point.
1279  *
1280  * Note:  This is based on get_sb_bdev from fs/super.c with a few additions
1281  *        for multiple device setup.  Make sure to keep it in sync.
1282  */
1283 static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
1284                 const char *device_name, void *data)
1285 {
1286         struct block_device *bdev = NULL;
1287         struct super_block *s;
1288         struct dentry *root;
1289         struct btrfs_fs_devices *fs_devices = NULL;
1290         struct btrfs_fs_info *fs_info = NULL;
1291         struct security_mnt_opts new_sec_opts;
1292         fmode_t mode = FMODE_READ;
1293         char *subvol_name = NULL;
1294         u64 subvol_objectid = 0;
1295         int error = 0;
1296 
1297         if (!(flags & MS_RDONLY))
1298                 mode |= FMODE_WRITE;
1299 
1300         error = btrfs_parse_early_options(data, mode, fs_type,
1301                                           &subvol_name, &subvol_objectid,
1302                                           &fs_devices);
1303         if (error) {
1304                 kfree(subvol_name);
1305                 return ERR_PTR(error);
1306         }
1307 
1308         if (subvol_name) {
1309                 root = mount_subvol(subvol_name, flags, device_name, data);
1310                 kfree(subvol_name);
1311                 return root;
1312         }
1313 
1314         security_init_mnt_opts(&new_sec_opts);
1315         if (data) {
1316                 error = parse_security_options(data, &new_sec_opts);
1317                 if (error)
1318                         return ERR_PTR(error);
1319         }
1320 
1321         error = btrfs_scan_one_device(device_name, mode, fs_type, &fs_devices);
1322         if (error)
1323                 goto error_sec_opts;
1324 
1325         /*
1326          * Setup a dummy root and fs_info for test/set super.  This is because
1327          * we don't actually fill this stuff out until open_ctree, but we need
1328          * it for searching for existing supers, so this lets us do that and
1329          * then open_ctree will properly initialize everything later.
1330          */
1331         fs_info = kzalloc(sizeof(struct btrfs_fs_info), GFP_NOFS);
1332         if (!fs_info) {
1333                 error = -ENOMEM;
1334                 goto error_sec_opts;
1335         }
1336 
1337         fs_info->fs_devices = fs_devices;
1338 
1339         fs_info->super_copy = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_NOFS);
1340         fs_info->super_for_commit = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_NOFS);
1341         security_init_mnt_opts(&fs_info->security_opts);
1342         if (!fs_info->super_copy || !fs_info->super_for_commit) {
1343                 error = -ENOMEM;
1344                 goto error_fs_info;
1345         }
1346 
1347         error = btrfs_open_devices(fs_devices, mode, fs_type);
1348         if (error)
1349                 goto error_fs_info;
1350 
1351         if (!(flags & MS_RDONLY) && fs_devices->rw_devices == 0) {
1352                 error = -EACCES;
1353                 goto error_close_devices;
1354         }
1355 
1356         bdev = fs_devices->latest_bdev;
1357         s = sget(fs_type, btrfs_test_super, btrfs_set_super, flags | MS_NOSEC,
1358                  fs_info);
1359         if (IS_ERR(s)) {
1360                 error = PTR_ERR(s);
1361                 goto error_close_devices;
1362         }
1363 
1364         if (s->s_root) {
1365                 btrfs_close_devices(fs_devices);
1366                 free_fs_info(fs_info);
1367                 if ((flags ^ s->s_flags) & MS_RDONLY)
1368                         error = -EBUSY;
1369         } else {
1370                 char b[BDEVNAME_SIZE];
1371 
1372                 strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
1373                 btrfs_sb(s)->bdev_holder = fs_type;
1374                 error = btrfs_fill_super(s, fs_devices, data,
1375                                          flags & MS_SILENT ? 1 : 0);
1376         }
1377 
1378         root = !error ? get_default_root(s, subvol_objectid) : ERR_PTR(error);
1379         if (IS_ERR(root)) {
1380                 deactivate_locked_super(s);
1381                 error = PTR_ERR(root);
1382                 goto error_sec_opts;
1383         }
1384 
1385         fs_info = btrfs_sb(s);
1386         error = setup_security_options(fs_info, s, &new_sec_opts);
1387         if (error) {
1388                 dput(root);
1389                 deactivate_locked_super(s);
1390                 goto error_sec_opts;
1391         }
1392 
1393         return root;
1394 
1395 error_close_devices:
1396         btrfs_close_devices(fs_devices);
1397 error_fs_info:
1398         free_fs_info(fs_info);
1399 error_sec_opts:
1400         security_free_mnt_opts(&new_sec_opts);
1401         return ERR_PTR(error);
1402 }
1403 
1404 static void btrfs_resize_thread_pool(struct btrfs_fs_info *fs_info,
1405                                      int new_pool_size, int old_pool_size)
1406 {
1407         if (new_pool_size == old_pool_size)
1408                 return;
1409 
1410         fs_info->thread_pool_size = new_pool_size;
1411 
1412         btrfs_info(fs_info, "resize thread pool %d -> %d",
1413                old_pool_size, new_pool_size);
1414 
1415         btrfs_workqueue_set_max(fs_info->workers, new_pool_size);
1416         btrfs_workqueue_set_max(fs_info->delalloc_workers, new_pool_size);
1417         btrfs_workqueue_set_max(fs_info->submit_workers, new_pool_size);
1418         btrfs_workqueue_set_max(fs_info->caching_workers, new_pool_size);
1419         btrfs_workqueue_set_max(fs_info->endio_workers, new_pool_size);
1420         btrfs_workqueue_set_max(fs_info->endio_meta_workers, new_pool_size);
1421         btrfs_workqueue_set_max(fs_info->endio_meta_write_workers,
1422                                 new_pool_size);
1423         btrfs_workqueue_set_max(fs_info->endio_write_workers, new_pool_size);
1424         btrfs_workqueue_set_max(fs_info->endio_freespace_worker, new_pool_size);
1425         btrfs_workqueue_set_max(fs_info->delayed_workers, new_pool_size);
1426         btrfs_workqueue_set_max(fs_info->readahead_workers, new_pool_size);
1427         btrfs_workqueue_set_max(fs_info->scrub_wr_completion_workers,
1428                                 new_pool_size);
1429 }
1430 
1431 static inline void btrfs_remount_prepare(struct btrfs_fs_info *fs_info)
1432 {
1433         set_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state);
1434 }
1435 
1436 static inline void btrfs_remount_begin(struct btrfs_fs_info *fs_info,
1437                                        unsigned long old_opts, int flags)
1438 {
1439         if (btrfs_raw_test_opt(old_opts, AUTO_DEFRAG) &&
1440             (!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) ||
1441              (flags & MS_RDONLY))) {
1442                 /* wait for any defraggers to finish */
1443                 wait_event(fs_info->transaction_wait,
1444                            (atomic_read(&fs_info->defrag_running) == 0));
1445                 if (flags & MS_RDONLY)
1446                         sync_filesystem(fs_info->sb);
1447         }
1448 }
1449 
1450 static inline void btrfs_remount_cleanup(struct btrfs_fs_info *fs_info,
1451                                          unsigned long old_opts)
1452 {
1453         /*
1454          * We need cleanup all defragable inodes if the autodefragment is
1455          * close or the fs is R/O.
1456          */
1457         if (btrfs_raw_test_opt(old_opts, AUTO_DEFRAG) &&
1458             (!btrfs_raw_test_opt(fs_info->mount_opt, AUTO_DEFRAG) ||
1459              (fs_info->sb->s_flags & MS_RDONLY))) {
1460                 btrfs_cleanup_defrag_inodes(fs_info);
1461         }
1462 
1463         clear_bit(BTRFS_FS_STATE_REMOUNTING, &fs_info->fs_state);
1464 }
1465 
1466 static int btrfs_remount(struct super_block *sb, int *flags, char *data)
1467 {
1468         struct btrfs_fs_info *fs_info = btrfs_sb(sb);
1469         struct btrfs_root *root = fs_info->tree_root;
1470         unsigned old_flags = sb->s_flags;
1471         unsigned long old_opts = fs_info->mount_opt;
1472         unsigned long old_compress_type = fs_info->compress_type;
1473         u64 old_max_inline = fs_info->max_inline;
1474         u64 old_alloc_start = fs_info->alloc_start;
1475         int old_thread_pool_size = fs_info->thread_pool_size;
1476         unsigned int old_metadata_ratio = fs_info->metadata_ratio;
1477         int ret;
1478 
1479         sync_filesystem(sb);
1480         btrfs_remount_prepare(fs_info);
1481 
1482         if (data) {
1483                 struct security_mnt_opts new_sec_opts;
1484 
1485                 security_init_mnt_opts(&new_sec_opts);
1486                 ret = parse_security_options(data, &new_sec_opts);
1487                 if (ret)
1488                         goto restore;
1489                 ret = setup_security_options(fs_info, sb,
1490                                              &new_sec_opts);
1491                 if (ret) {
1492                         security_free_mnt_opts(&new_sec_opts);
1493                         goto restore;
1494                 }
1495         }
1496 
1497         ret = btrfs_parse_options(root, data);
1498         if (ret) {
1499                 ret = -EINVAL;
1500                 goto restore;
1501         }
1502 
1503         btrfs_remount_begin(fs_info, old_opts, *flags);
1504         btrfs_resize_thread_pool(fs_info,
1505                 fs_info->thread_pool_size, old_thread_pool_size);
1506 
1507         if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
1508                 goto out;
1509 
1510         if (*flags & MS_RDONLY) {
1511                 /*
1512                  * this also happens on 'umount -rf' or on shutdown, when
1513                  * the filesystem is busy.
1514                  */
1515                 cancel_work_sync(&fs_info->async_reclaim_work);
1516 
1517                 /* wait for the uuid_scan task to finish */
1518                 down(&fs_info->uuid_tree_rescan_sem);
1519                 /* avoid complains from lockdep et al. */
1520                 up(&fs_info->uuid_tree_rescan_sem);
1521 
1522                 sb->s_flags |= MS_RDONLY;
1523 
1524                 btrfs_dev_replace_suspend_for_unmount(fs_info);
1525                 btrfs_scrub_cancel(fs_info);
1526                 btrfs_pause_balance(fs_info);
1527 
1528                 ret = btrfs_commit_super(root);
1529                 if (ret)
1530                         goto restore;
1531         } else {
1532                 if (test_bit(BTRFS_FS_STATE_ERROR, &root->fs_info->fs_state)) {
1533                         btrfs_err(fs_info,
1534                                 "Remounting read-write after error is not allowed");
1535                         ret = -EINVAL;
1536                         goto restore;
1537                 }
1538                 if (fs_info->fs_devices->rw_devices == 0) {
1539                         ret = -EACCES;
1540                         goto restore;
1541                 }
1542 
1543                 if (fs_info->fs_devices->missing_devices >
1544                      fs_info->num_tolerated_disk_barrier_failures &&
1545                     !(*flags & MS_RDONLY)) {
1546                         btrfs_warn(fs_info,
1547                                 "too many missing devices, writeable remount is not allowed");
1548                         ret = -EACCES;
1549                         goto restore;
1550                 }
1551 
1552                 if (btrfs_super_log_root(fs_info->super_copy) != 0) {
1553                         ret = -EINVAL;
1554                         goto restore;
1555                 }
1556 
1557                 ret = btrfs_cleanup_fs_roots(fs_info);
1558                 if (ret)
1559                         goto restore;
1560 
1561                 /* recover relocation */
1562                 mutex_lock(&fs_info->cleaner_mutex);
1563                 ret = btrfs_recover_relocation(root);
1564                 mutex_unlock(&fs_info->cleaner_mutex);
1565                 if (ret)
1566                         goto restore;
1567 
1568                 ret = btrfs_resume_balance_async(fs_info);
1569                 if (ret)
1570                         goto restore;
1571 
1572                 ret = btrfs_resume_dev_replace_async(fs_info);
1573                 if (ret) {
1574                         btrfs_warn(fs_info, "failed to resume dev_replace");
1575                         goto restore;
1576                 }
1577 
1578                 btrfs_qgroup_rescan_resume(fs_info);
1579 
1580                 if (!fs_info->uuid_root) {
1581                         btrfs_info(fs_info, "creating UUID tree");
1582                         ret = btrfs_create_uuid_tree(fs_info);
1583                         if (ret) {
1584                                 btrfs_warn(fs_info, "failed to create the UUID tree %d", ret);
1585                                 goto restore;
1586                         }
1587                 }
1588                 sb->s_flags &= ~MS_RDONLY;
1589         }
1590 out:
1591         wake_up_process(fs_info->transaction_kthread);
1592         btrfs_remount_cleanup(fs_info, old_opts);
1593         return 0;
1594 
1595 restore:
1596         /* We've hit an error - don't reset MS_RDONLY */
1597         if (sb->s_flags & MS_RDONLY)
1598                 old_flags |= MS_RDONLY;
1599         sb->s_flags = old_flags;
1600         fs_info->mount_opt = old_opts;
1601         fs_info->compress_type = old_compress_type;
1602         fs_info->max_inline = old_max_inline;
1603         mutex_lock(&fs_info->chunk_mutex);
1604         fs_info->alloc_start = old_alloc_start;
1605         mutex_unlock(&fs_info->chunk_mutex);
1606         btrfs_resize_thread_pool(fs_info,
1607                 old_thread_pool_size, fs_info->thread_pool_size);
1608         fs_info->metadata_ratio = old_metadata_ratio;
1609         btrfs_remount_cleanup(fs_info, old_opts);
1610         return ret;
1611 }
1612 
1613 /* Used to sort the devices by max_avail(descending sort) */
1614 static int btrfs_cmp_device_free_bytes(const void *dev_info1,
1615                                        const void *dev_info2)
1616 {
1617         if (((struct btrfs_device_info *)dev_info1)->max_avail >
1618             ((struct btrfs_device_info *)dev_info2)->max_avail)
1619                 return -1;
1620         else if (((struct btrfs_device_info *)dev_info1)->max_avail <
1621                  ((struct btrfs_device_info *)dev_info2)->max_avail)
1622                 return 1;
1623         else
1624         return 0;
1625 }
1626 
1627 /*
1628  * sort the devices by max_avail, in which max free extent size of each device
1629  * is stored.(Descending Sort)
1630  */
1631 static inline void btrfs_descending_sort_devices(
1632                                         struct btrfs_device_info *devices,
1633                                         size_t nr_devices)
1634 {
1635         sort(devices, nr_devices, sizeof(struct btrfs_device_info),
1636              btrfs_cmp_device_free_bytes, NULL);
1637 }
1638 
1639 /*
1640  * The helper to calc the free space on the devices that can be used to store
1641  * file data.
1642  */
1643 static int btrfs_calc_avail_data_space(struct btrfs_root *root, u64 *free_bytes)
1644 {
1645         struct btrfs_fs_info *fs_info = root->fs_info;
1646         struct btrfs_device_info *devices_info;
1647         struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
1648         struct btrfs_device *device;
1649         u64 skip_space;
1650         u64 type;
1651         u64 avail_space;
1652         u64 used_space;
1653         u64 min_stripe_size;
1654         int min_stripes = 1, num_stripes = 1;
1655         int i = 0, nr_devices;
1656         int ret;
1657 
1658         nr_devices = fs_info->fs_devices->open_devices;
1659         BUG_ON(!nr_devices);
1660 
1661         devices_info = kmalloc_array(nr_devices, sizeof(*devices_info),
1662                                GFP_NOFS);
1663         if (!devices_info)
1664                 return -ENOMEM;
1665 
1666         /* calc min stripe number for data space alloction */
1667         type = btrfs_get_alloc_profile(root, 1);
1668         if (type & BTRFS_BLOCK_GROUP_RAID0) {
1669                 min_stripes = 2;
1670                 num_stripes = nr_devices;
1671         } else if (type & BTRFS_BLOCK_GROUP_RAID1) {
1672                 min_stripes = 2;
1673                 num_stripes = 2;
1674         } else if (type & BTRFS_BLOCK_GROUP_RAID10) {
1675                 min_stripes = 4;
1676                 num_stripes = 4;
1677         }
1678 
1679         if (type & BTRFS_BLOCK_GROUP_DUP)
1680                 min_stripe_size = 2 * BTRFS_STRIPE_LEN;
1681         else
1682                 min_stripe_size = BTRFS_STRIPE_LEN;
1683 
1684         list_for_each_entry(device, &fs_devices->devices, dev_list) {
1685                 if (!device->in_fs_metadata || !device->bdev ||
1686                     device->is_tgtdev_for_dev_replace)
1687                         continue;
1688 
1689                 avail_space = device->total_bytes - device->bytes_used;
1690 
1691                 /* align with stripe_len */
1692                 do_div(avail_space, BTRFS_STRIPE_LEN);
1693                 avail_space *= BTRFS_STRIPE_LEN;
1694 
1695                 /*
1696                  * In order to avoid overwritting the superblock on the drive,
1697                  * btrfs starts at an offset of at least 1MB when doing chunk
1698                  * allocation.
1699                  */
1700                 skip_space = 1024 * 1024;
1701 
1702                 /* user can set the offset in fs_info->alloc_start. */
1703                 if (fs_info->alloc_start + BTRFS_STRIPE_LEN <=
1704                     device->total_bytes)
1705                         skip_space = max(fs_info->alloc_start, skip_space);
1706 
1707                 /*
1708                  * btrfs can not use the free space in [0, skip_space - 1],
1709                  * we must subtract it from the total. In order to implement
1710                  * it, we account the used space in this range first.
1711                  */
1712                 ret = btrfs_account_dev_extents_size(device, 0, skip_space - 1,
1713                                                      &used_space);
1714                 if (ret) {
1715                         kfree(devices_info);
1716                         return ret;
1717                 }
1718 
1719                 /* calc the free space in [0, skip_space - 1] */
1720                 skip_space -= used_space;
1721 
1722                 /*
1723                  * we can use the free space in [0, skip_space - 1], subtract
1724                  * it from the total.
1725                  */
1726                 if (avail_space && avail_space >= skip_space)
1727                         avail_space -= skip_space;
1728                 else
1729                         avail_space = 0;
1730 
1731                 if (avail_space < min_stripe_size)
1732                         continue;
1733 
1734                 devices_info[i].dev = device;
1735                 devices_info[i].max_avail = avail_space;
1736 
1737                 i++;
1738         }
1739 
1740         nr_devices = i;
1741 
1742         btrfs_descending_sort_devices(devices_info, nr_devices);
1743 
1744         i = nr_devices - 1;
1745         avail_space = 0;
1746         while (nr_devices >= min_stripes) {
1747                 if (num_stripes > nr_devices)
1748                         num_stripes = nr_devices;
1749 
1750                 if (devices_info[i].max_avail >= min_stripe_size) {
1751                         int j;
1752                         u64 alloc_size;
1753 
1754                         avail_space += devices_info[i].max_avail * num_stripes;
1755                         alloc_size = devices_info[i].max_avail;
1756                         for (j = i + 1 - num_stripes; j <= i; j++)
1757                                 devices_info[j].max_avail -= alloc_size;
1758                 }
1759                 i--;
1760                 nr_devices--;
1761         }
1762 
1763         kfree(devices_info);
1764         *free_bytes = avail_space;
1765         return 0;
1766 }
1767 
1768 /*
1769  * Calculate numbers for 'df', pessimistic in case of mixed raid profiles.
1770  *
1771  * If there's a redundant raid level at DATA block groups, use the respective
1772  * multiplier to scale the sizes.
1773  *
1774  * Unused device space usage is based on simulating the chunk allocator
1775  * algorithm that respects the device sizes, order of allocations and the
1776  * 'alloc_start' value, this is a close approximation of the actual use but
1777  * there are other factors that may change the result (like a new metadata
1778  * chunk).
1779  *
1780  * If metadata is exhausted, f_bavail will be 0.
1781  *
1782  * FIXME: not accurate for mixed block groups, total and free/used are ok,
1783  * available appears slightly larger.
1784  */
1785 static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
1786 {
1787         struct btrfs_fs_info *fs_info = btrfs_sb(dentry->d_sb);
1788         struct btrfs_super_block *disk_super = fs_info->super_copy;
1789         struct list_head *head = &fs_info->space_info;
1790         struct btrfs_space_info *found;
1791         u64 total_used = 0;
1792         u64 total_free_data = 0;
1793         u64 total_free_meta = 0;
1794         int bits = dentry->d_sb->s_blocksize_bits;
1795         __be32 *fsid = (__be32 *)fs_info->fsid;
1796         unsigned factor = 1;
1797         struct btrfs_block_rsv *block_rsv = &fs_info->global_block_rsv;
1798         int ret;
1799         u64 thresh = 0;
1800 
1801         /*
1802          * holding chunk_muext to avoid allocating new chunks, holding
1803          * device_list_mutex to avoid the device being removed
1804          */
1805         mutex_lock(&fs_info->fs_devices->device_list_mutex);
1806         mutex_lock(&fs_info->chunk_mutex);
1807         rcu_read_lock();
1808         list_for_each_entry_rcu(found, head, list) {
1809                 if (found->flags & BTRFS_BLOCK_GROUP_DATA) {
1810                         int i;
1811 
1812                         total_free_data += found->disk_total - found->disk_used;
1813                         total_free_data -=
1814                                 btrfs_account_ro_block_groups_free_space(found);
1815 
1816                         for (i = 0; i < BTRFS_NR_RAID_TYPES; i++) {
1817                                 if (!list_empty(&found->block_groups[i])) {
1818                                         switch (i) {
1819                                         case BTRFS_RAID_DUP:
1820                                         case BTRFS_RAID_RAID1:
1821                                         case BTRFS_RAID_RAID10:
1822                                                 factor = 2;
1823                                         }
1824                                 }
1825                         }
1826                 }
1827                 if (found->flags & BTRFS_BLOCK_GROUP_METADATA)
1828                         total_free_meta += found->disk_total - found->disk_used;
1829 
1830                 total_used += found->disk_used;
1831         }
1832 
1833         rcu_read_unlock();
1834 
1835         buf->f_blocks = div_u64(btrfs_super_total_bytes(disk_super), factor);
1836         buf->f_blocks >>= bits;
1837         buf->f_bfree = buf->f_blocks - (div_u64(total_used, factor) >> bits);
1838 
1839         /* Account global block reserve as used, it's in logical size already */
1840         spin_lock(&block_rsv->lock);
1841         buf->f_bfree -= block_rsv->size >> bits;
1842         spin_unlock(&block_rsv->lock);
1843 
1844         buf->f_bavail = div_u64(total_free_data, factor);
1845         ret = btrfs_calc_avail_data_space(fs_info->tree_root, &total_free_data);
1846         if (ret) {
1847                 mutex_unlock(&fs_info->chunk_mutex);
1848                 mutex_unlock(&fs_info->fs_devices->device_list_mutex);
1849                 return ret;
1850         }
1851         buf->f_bavail += div_u64(total_free_data, factor);
1852         buf->f_bavail = buf->f_bavail >> bits;
1853         mutex_unlock(&fs_info->chunk_mutex);
1854         mutex_unlock(&fs_info->fs_devices->device_list_mutex);
1855 
1856         /*
1857          * We calculate the remaining metadata space minus global reserve. If
1858          * this is (supposedly) smaller than zero, there's no space. But this
1859          * does not hold in practice, the exhausted state happens where's still
1860          * some positive delta. So we apply some guesswork and compare the
1861          * delta to a 4M threshold.  (Practically observed delta was ~2M.)
1862          *
1863          * We probably cannot calculate the exact threshold value because this
1864          * depends on the internal reservations requested by various
1865          * operations, so some operations that consume a few metadata will
1866          * succeed even if the Avail is zero. But this is better than the other
1867          * way around.
1868          */
1869         thresh = 4 * 1024 * 1024;
1870 
1871         if (total_free_meta - thresh < block_rsv->size)
1872                 buf->f_bavail = 0;
1873 
1874         buf->f_type = BTRFS_SUPER_MAGIC;
1875         buf->f_bsize = dentry->d_sb->s_blocksize;
1876         buf->f_namelen = BTRFS_NAME_LEN;
1877 
1878         /* We treat it as constant endianness (it doesn't matter _which_)
1879            because we want the fsid to come out the same whether mounted
1880            on a big-endian or little-endian host */
1881         buf->f_fsid.val[0] = be32_to_cpu(fsid[0]) ^ be32_to_cpu(fsid[2]);
1882         buf->f_fsid.val[1] = be32_to_cpu(fsid[1]) ^ be32_to_cpu(fsid[3]);
1883         /* Mask in the root object ID too, to disambiguate subvols */
1884         buf->f_fsid.val[0] ^= BTRFS_I(dentry->d_inode)->root->objectid >> 32;
1885         buf->f_fsid.val[1] ^= BTRFS_I(dentry->d_inode)->root->objectid;
1886 
1887         return 0;
1888 }
1889 
1890 static void btrfs_kill_super(struct super_block *sb)
1891 {
1892         struct btrfs_fs_info *fs_info = btrfs_sb(sb);
1893         kill_anon_super(sb);
1894         free_fs_info(fs_info);
1895 }
1896 
1897 static struct file_system_type btrfs_fs_type = {
1898         .owner          = THIS_MODULE,
1899         .name           = "btrfs",
1900         .mount          = btrfs_mount,
1901         .kill_sb        = btrfs_kill_super,
1902         .fs_flags       = FS_REQUIRES_DEV | FS_BINARY_MOUNTDATA,
1903 };
1904 MODULE_ALIAS_FS("btrfs");
1905 
1906 /*
1907  * used by btrfsctl to scan devices when no FS is mounted
1908  */
1909 static long btrfs_control_ioctl(struct file *file, unsigned int cmd,
1910                                 unsigned long arg)
1911 {
1912         struct btrfs_ioctl_vol_args *vol;
1913         struct btrfs_fs_devices *fs_devices;
1914         int ret = -ENOTTY;
1915 
1916         if (!capable(CAP_SYS_ADMIN))
1917                 return -EPERM;
1918 
1919         vol = memdup_user((void __user *)arg, sizeof(*vol));
1920         if (IS_ERR(vol))
1921                 return PTR_ERR(vol);
1922 
1923         switch (cmd) {
1924         case BTRFS_IOC_SCAN_DEV:
1925                 ret = btrfs_scan_one_device(vol->name, FMODE_READ,
1926                                             &btrfs_fs_type, &fs_devices);
1927                 break;
1928         case BTRFS_IOC_DEVICES_READY:
1929                 ret = btrfs_scan_one_device(vol->name, FMODE_READ,
1930                                             &btrfs_fs_type, &fs_devices);
1931                 if (ret)
1932                         break;
1933                 ret = !(fs_devices->num_devices == fs_devices->total_devices);
1934                 break;
1935         }
1936 
1937         kfree(vol);
1938         return ret;
1939 }
1940 
1941 static int btrfs_freeze(struct super_block *sb)
1942 {
1943         struct btrfs_trans_handle *trans;
1944         struct btrfs_root *root = btrfs_sb(sb)->tree_root;
1945 
1946         trans = btrfs_attach_transaction_barrier(root);
1947         if (IS_ERR(trans)) {
1948                 /* no transaction, don't bother */
1949                 if (PTR_ERR(trans) == -ENOENT)
1950                         return 0;
1951                 return PTR_ERR(trans);
1952         }
1953         return btrfs_commit_transaction(trans, root);
1954 }
1955 
1956 static int btrfs_unfreeze(struct super_block *sb)
1957 {
1958         return 0;
1959 }
1960 
1961 static int btrfs_show_devname(struct seq_file *m, struct dentry *root)
1962 {
1963         struct btrfs_fs_info *fs_info = btrfs_sb(root->d_sb);
1964         struct btrfs_fs_devices *cur_devices;
1965         struct btrfs_device *dev, *first_dev = NULL;
1966         struct list_head *head;
1967         struct rcu_string *name;
1968 
1969         mutex_lock(&fs_info->fs_devices->device_list_mutex);
1970         cur_devices = fs_info->fs_devices;
1971         while (cur_devices) {
1972                 head = &cur_devices->devices;
1973                 list_for_each_entry(dev, head, dev_list) {
1974                         if (dev->missing)
1975                                 continue;
1976                         if (!dev->name)
1977                                 continue;
1978                         if (!first_dev || dev->devid < first_dev->devid)
1979                                 first_dev = dev;
1980                 }
1981                 cur_devices = cur_devices->seed;
1982         }
1983 
1984         if (first_dev) {
1985                 rcu_read_lock();
1986                 name = rcu_dereference(first_dev->name);
1987                 seq_escape(m, name->str, " \t\n\\");
1988                 rcu_read_unlock();
1989         } else {
1990                 WARN_ON(1);
1991         }
1992         mutex_unlock(&fs_info->fs_devices->device_list_mutex);
1993         return 0;
1994 }
1995 
1996 static const struct super_operations btrfs_super_ops = {
1997         .drop_inode     = btrfs_drop_inode,
1998         .evict_inode    = btrfs_evict_inode,
1999         .put_super      = btrfs_put_super,
2000         .sync_fs        = btrfs_sync_fs,
2001         .show_options   = btrfs_show_options,
2002         .show_devname   = btrfs_show_devname,
2003         .write_inode    = btrfs_write_inode,
2004         .alloc_inode    = btrfs_alloc_inode,
2005         .destroy_inode  = btrfs_destroy_inode,
2006         .statfs         = btrfs_statfs,
2007         .remount_fs     = btrfs_remount,
2008         .freeze_fs      = btrfs_freeze,
2009         .unfreeze_fs    = btrfs_unfreeze,
2010 };
2011 
2012 static const struct file_operations btrfs_ctl_fops = {
2013         .unlocked_ioctl  = btrfs_control_ioctl,
2014         .compat_ioctl = btrfs_control_ioctl,
2015         .owner   = THIS_MODULE,
2016         .llseek = noop_llseek,
2017 };
2018 
2019 static struct miscdevice btrfs_misc = {
2020         .minor          = BTRFS_MINOR,
2021         .name           = "btrfs-control",
2022         .fops           = &btrfs_ctl_fops
2023 };
2024 
2025 MODULE_ALIAS_MISCDEV(BTRFS_MINOR);
2026 MODULE_ALIAS("devname:btrfs-control");
2027 
2028 static int btrfs_interface_init(void)
2029 {
2030         return misc_register(&btrfs_misc);
2031 }
2032 
2033 static void btrfs_interface_exit(void)
2034 {
2035         if (misc_deregister(&btrfs_misc) < 0)
2036                 printk(KERN_INFO "BTRFS: misc_deregister failed for control device\n");
2037 }
2038 
2039 static void btrfs_print_info(void)
2040 {
2041         printk(KERN_INFO "Btrfs loaded"
2042 #ifdef CONFIG_BTRFS_DEBUG
2043                         ", debug=on"
2044 #endif
2045 #ifdef CONFIG_BTRFS_ASSERT
2046                         ", assert=on"
2047 #endif
2048 #ifdef CONFIG_BTRFS_FS_CHECK_INTEGRITY
2049                         ", integrity-checker=on"
2050 #endif
2051                         "\n");
2052 }
2053 
2054 static int btrfs_run_sanity_tests(void)
2055 {
2056         int ret;
2057 
2058         ret = btrfs_init_test_fs();
2059         if (ret)
2060                 return ret;
2061 
2062         ret = btrfs_test_free_space_cache();
2063         if (ret)
2064                 goto out;
2065         ret = btrfs_test_extent_buffer_operations();
2066         if (ret)
2067                 goto out;
2068         ret = btrfs_test_extent_io();
2069         if (ret)
2070                 goto out;
2071         ret = btrfs_test_inodes();
2072         if (ret)
2073                 goto out;
2074         ret = btrfs_test_qgroups();
2075 out:
2076         btrfs_destroy_test_fs();
2077         return ret;
2078 }
2079 
2080 static int __init init_btrfs_fs(void)
2081 {
2082         int err;
2083 
2084         err = btrfs_hash_init();
2085         if (err)
2086                 return err;
2087 
2088         btrfs_props_init();
2089 
2090         err = btrfs_init_sysfs();
2091         if (err)
2092                 goto free_hash;
2093 
2094         btrfs_init_compress();
2095 
2096         err = btrfs_init_cachep();
2097         if (err)
2098                 goto free_compress;
2099 
2100         err = extent_io_init();
2101         if (err)
2102                 goto free_cachep;
2103 
2104         err = extent_map_init();
2105         if (err)
2106                 goto free_extent_io;
2107 
2108         err = ordered_data_init();
2109         if (err)
2110                 goto free_extent_map;
2111 
2112         err = btrfs_delayed_inode_init();
2113         if (err)
2114                 goto free_ordered_data;
2115 
2116         err = btrfs_auto_defrag_init();
2117         if (err)
2118                 goto free_delayed_inode;
2119 
2120         err = btrfs_delayed_ref_init();
2121         if (err)
2122                 goto free_auto_defrag;
2123 
2124         err = btrfs_prelim_ref_init();
2125         if (err)
2126                 goto free_delayed_ref;
2127 
2128         err = btrfs_end_io_wq_init();
2129         if (err)
2130                 goto free_prelim_ref;
2131 
2132         err = btrfs_interface_init();
2133         if (err)
2134                 goto free_end_io_wq;
2135 
2136         btrfs_init_lockdep();
2137 
2138         btrfs_print_info();
2139 
2140         err = btrfs_run_sanity_tests();
2141         if (err)
2142                 goto unregister_ioctl;
2143 
2144         err = register_filesystem(&btrfs_fs_type);
2145         if (err)
2146                 goto unregister_ioctl;
2147 
2148         return 0;
2149 
2150 unregister_ioctl:
2151         btrfs_interface_exit();
2152 free_end_io_wq:
2153         btrfs_end_io_wq_exit();
2154 free_prelim_ref:
2155         btrfs_prelim_ref_exit();
2156 free_delayed_ref:
2157         btrfs_delayed_ref_exit();
2158 free_auto_defrag:
2159         btrfs_auto_defrag_exit();
2160 free_delayed_inode:
2161         btrfs_delayed_inode_exit();
2162 free_ordered_data:
2163         ordered_data_exit();
2164 free_extent_map:
2165         extent_map_exit();
2166 free_extent_io:
2167         extent_io_exit();
2168 free_cachep:
2169         btrfs_destroy_cachep();
2170 free_compress:
2171         btrfs_exit_compress();
2172         btrfs_exit_sysfs();
2173 free_hash:
2174         btrfs_hash_exit();
2175         return err;
2176 }
2177 
2178 static void __exit exit_btrfs_fs(void)
2179 {
2180         btrfs_destroy_cachep();
2181         btrfs_delayed_ref_exit();
2182         btrfs_auto_defrag_exit();
2183         btrfs_delayed_inode_exit();
2184         btrfs_prelim_ref_exit();
2185         ordered_data_exit();
2186         extent_map_exit();
2187         extent_io_exit();
2188         btrfs_interface_exit();
2189         btrfs_end_io_wq_exit();
2190         unregister_filesystem(&btrfs_fs_type);
2191         btrfs_exit_sysfs();
2192         btrfs_cleanup_fs_uuids();
2193         btrfs_exit_compress();
2194         btrfs_hash_exit();
2195 }
2196 
2197 late_initcall(init_btrfs_fs);
2198 module_exit(exit_btrfs_fs)
2199 
2200 MODULE_LICENSE("GPL");
2201 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp