?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[media] ivtv: remove open_id/id from the filehandle code
[linux/fpc-iii.git] / fs / btrfs / super.c
blob200f63bc6675eca20cf1b55c9ced534efccaf63b
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/mnt_namespace.h>
44 #include <linux/ratelimit.h>
45 #include "compat.h"
46 #include "delayed-inode.h"
47 #include "ctree.h"
48 #include "disk-io.h"
49 #include "transaction.h"
50 #include "btrfs_inode.h"
51 #include "ioctl.h"
52 #include "print-tree.h"
53 #include "xattr.h"
54 #include "volumes.h"
55 #include "version.h"
56 #include "export.h"
57 #include "compression.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 default:
81 if (nbuf) {
82 if (snprintf(nbuf, 16, "error %d", -errno) >= 0)
83 errstr = nbuf;
84 }
85 break;
86 }
87
88 return errstr;
89 }
90
91 static void __save_error_info(struct btrfs_fs_info *fs_info)
92 {
93 /*
94 * today we only save the error info into ram. Long term we'll
95 * also send it down to the disk
96 */
97 fs_info->fs_state = BTRFS_SUPER_FLAG_ERROR;
98 }
99
100 /* NOTE:
101 * We move write_super stuff at umount in order to avoid deadlock
102 * for umount hold all lock.
103 */
104 static void save_error_info(struct btrfs_fs_info *fs_info)
105 {
106 __save_error_info(fs_info);
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 (fs_info->fs_state & BTRFS_SUPER_FLAG_ERROR) {
118 sb->s_flags |= MS_RDONLY;
119 printk(KERN_INFO "btrfs is forced readonly\n");
120 }
121 }
122
123 /*
124 * __btrfs_std_error decodes expected errors from the caller and
125 * invokes the approciate error response.
126 */
127 void __btrfs_std_error(struct btrfs_fs_info *fs_info, const char *function,
128 unsigned int line, int errno)
129 {
130 struct super_block *sb = fs_info->sb;
131 char nbuf[16];
132 const char *errstr;
133
134 /*
135 * Special case: if the error is EROFS, and we're already
136 * under MS_RDONLY, then it is safe here.
137 */
138 if (errno == -EROFS && (sb->s_flags & MS_RDONLY))
139 return;
140
141 errstr = btrfs_decode_error(fs_info, errno, nbuf);
142 printk(KERN_CRIT "BTRFS error (device %s) in %s:%d: %s\n",
143 sb->s_id, function, line, errstr);
144 save_error_info(fs_info);
145
146 btrfs_handle_error(fs_info);
147 }
148
149 static void btrfs_put_super(struct super_block *sb)
150 {
151 struct btrfs_root *root = btrfs_sb(sb);
152 int ret;
153
154 ret = close_ctree(root);
155 sb->s_fs_info = NULL;
156
157 (void)ret; /* FIXME: need to fix VFS to return error? */
158 }
159
160 enum {
161 Opt_degraded, Opt_subvol, Opt_subvolid, Opt_device, Opt_nodatasum,
162 Opt_nodatacow, Opt_max_inline, Opt_alloc_start, Opt_nobarrier, Opt_ssd,
163 Opt_nossd, Opt_ssd_spread, Opt_thread_pool, Opt_noacl, Opt_compress,
164 Opt_compress_type, Opt_compress_force, Opt_compress_force_type,
165 Opt_notreelog, Opt_ratio, Opt_flushoncommit, Opt_discard,
166 Opt_space_cache, Opt_clear_cache, Opt_user_subvol_rm_allowed,
167 Opt_enospc_debug, Opt_subvolrootid, Opt_defrag,
168 Opt_inode_cache, Opt_no_space_cache, Opt_recovery, Opt_err,
169 };
170
171 static match_table_t tokens = {
172 {Opt_degraded, "degraded"},
173 {Opt_subvol, "subvol=%s"},
174 {Opt_subvolid, "subvolid=%d"},
175 {Opt_device, "device=%s"},
176 {Opt_nodatasum, "nodatasum"},
177 {Opt_nodatacow, "nodatacow"},
178 {Opt_nobarrier, "nobarrier"},
179 {Opt_max_inline, "max_inline=%s"},
180 {Opt_alloc_start, "alloc_start=%s"},
181 {Opt_thread_pool, "thread_pool=%d"},
182 {Opt_compress, "compress"},
183 {Opt_compress_type, "compress=%s"},
184 {Opt_compress_force, "compress-force"},
185 {Opt_compress_force_type, "compress-force=%s"},
186 {Opt_ssd, "ssd"},
187 {Opt_ssd_spread, "ssd_spread"},
188 {Opt_nossd, "nossd"},
189 {Opt_noacl, "noacl"},
190 {Opt_notreelog, "notreelog"},
191 {Opt_flushoncommit, "flushoncommit"},
192 {Opt_ratio, "metadata_ratio=%d"},
193 {Opt_discard, "discard"},
194 {Opt_space_cache, "space_cache"},
195 {Opt_clear_cache, "clear_cache"},
196 {Opt_user_subvol_rm_allowed, "user_subvol_rm_allowed"},
197 {Opt_enospc_debug, "enospc_debug"},
198 {Opt_subvolrootid, "subvolrootid=%d"},
199 {Opt_defrag, "autodefrag"},
200 {Opt_inode_cache, "inode_cache"},
201 {Opt_no_space_cache, "nospace_cache"},
202 {Opt_recovery, "recovery"},
203 {Opt_err, NULL},
204 };
205
206 /*
207 * Regular mount options parser. Everything that is needed only when
208 * reading in a new superblock is parsed here.
209 */
210 int btrfs_parse_options(struct btrfs_root *root, char *options)
211 {
212 struct btrfs_fs_info *info = root->fs_info;
213 substring_t args[MAX_OPT_ARGS];
214 char *p, *num, *orig = NULL;
215 u64 cache_gen;
216 int intarg;
217 int ret = 0;
218 char *compress_type;
219 bool compress_force = false;
220
221 cache_gen = btrfs_super_cache_generation(root->fs_info->super_copy);
222 if (cache_gen)
223 btrfs_set_opt(info->mount_opt, SPACE_CACHE);
224
225 if (!options)
226 goto out;
227
228 /*
229 * strsep changes the string, duplicate it because parse_options
230 * gets called twice
231 */
232 options = kstrdup(options, GFP_NOFS);
233 if (!options)
234 return -ENOMEM;
235
236 orig = options;
237
238 while ((p = strsep(&options, ",")) != NULL) {
239 int token;
240 if (!*p)
241 continue;
242
243 token = match_token(p, tokens, args);
244 switch (token) {
245 case Opt_degraded:
246 printk(KERN_INFO "btrfs: allowing degraded mounts\n");
247 btrfs_set_opt(info->mount_opt, DEGRADED);
248 break;
249 case Opt_subvol:
250 case Opt_subvolid:
251 case Opt_subvolrootid:
252 case Opt_device:
253 /*
254 * These are parsed by btrfs_parse_early_options
255 * and can be happily ignored here.
256 */
257 break;
258 case Opt_nodatasum:
259 printk(KERN_INFO "btrfs: setting nodatasum\n");
260 btrfs_set_opt(info->mount_opt, NODATASUM);
261 break;
262 case Opt_nodatacow:
263 printk(KERN_INFO "btrfs: setting nodatacow\n");
264 btrfs_set_opt(info->mount_opt, NODATACOW);
265 btrfs_set_opt(info->mount_opt, NODATASUM);
266 break;
267 case Opt_compress_force:
268 case Opt_compress_force_type:
269 compress_force = true;
270 case Opt_compress:
271 case Opt_compress_type:
272 if (token == Opt_compress ||
273 token == Opt_compress_force ||
274 strcmp(args[0].from, "zlib") == 0) {
275 compress_type = "zlib";
276 info->compress_type = BTRFS_COMPRESS_ZLIB;
277 } else if (strcmp(args[0].from, "lzo") == 0) {
278 compress_type = "lzo";
279 info->compress_type = BTRFS_COMPRESS_LZO;
280 } else {
281 ret = -EINVAL;
282 goto out;
283 }
284
285 btrfs_set_opt(info->mount_opt, COMPRESS);
286 if (compress_force) {
287 btrfs_set_opt(info->mount_opt, FORCE_COMPRESS);
288 pr_info("btrfs: force %s compression\n",
289 compress_type);
290 } else
291 pr_info("btrfs: use %s compression\n",
292 compress_type);
293 break;
294 case Opt_ssd:
295 printk(KERN_INFO "btrfs: use ssd allocation scheme\n");
296 btrfs_set_opt(info->mount_opt, SSD);
297 break;
298 case Opt_ssd_spread:
299 printk(KERN_INFO "btrfs: use spread ssd "
300 "allocation scheme\n");
301 btrfs_set_opt(info->mount_opt, SSD);
302 btrfs_set_opt(info->mount_opt, SSD_SPREAD);
303 break;
304 case Opt_nossd:
305 printk(KERN_INFO "btrfs: not using ssd allocation "
306 "scheme\n");
307 btrfs_set_opt(info->mount_opt, NOSSD);
308 btrfs_clear_opt(info->mount_opt, SSD);
309 btrfs_clear_opt(info->mount_opt, SSD_SPREAD);
310 break;
311 case Opt_nobarrier:
312 printk(KERN_INFO "btrfs: turning off barriers\n");
313 btrfs_set_opt(info->mount_opt, NOBARRIER);
314 break;
315 case Opt_thread_pool:
316 intarg = 0;
317 match_int(&args[0], &intarg);
318 if (intarg) {
319 info->thread_pool_size = intarg;
320 printk(KERN_INFO "btrfs: thread pool %d\n",
321 info->thread_pool_size);
322 }
323 break;
324 case Opt_max_inline:
325 num = match_strdup(&args[0]);
326 if (num) {
327 info->max_inline = memparse(num, NULL);
328 kfree(num);
329
330 if (info->max_inline) {
331 info->max_inline = max_t(u64,
332 info->max_inline,
333 root->sectorsize);
334 }
335 printk(KERN_INFO "btrfs: max_inline at %llu\n",
336 (unsigned long long)info->max_inline);
337 }
338 break;
339 case Opt_alloc_start:
340 num = match_strdup(&args[0]);
341 if (num) {
342 info->alloc_start = memparse(num, NULL);
343 kfree(num);
344 printk(KERN_INFO
345 "btrfs: allocations start at %llu\n",
346 (unsigned long long)info->alloc_start);
347 }
348 break;
349 case Opt_noacl:
350 root->fs_info->sb->s_flags &= ~MS_POSIXACL;
351 break;
352 case Opt_notreelog:
353 printk(KERN_INFO "btrfs: disabling tree log\n");
354 btrfs_set_opt(info->mount_opt, NOTREELOG);
355 break;
356 case Opt_flushoncommit:
357 printk(KERN_INFO "btrfs: turning on flush-on-commit\n");
358 btrfs_set_opt(info->mount_opt, FLUSHONCOMMIT);
359 break;
360 case Opt_ratio:
361 intarg = 0;
362 match_int(&args[0], &intarg);
363 if (intarg) {
364 info->metadata_ratio = intarg;
365 printk(KERN_INFO "btrfs: metadata ratio %d\n",
366 info->metadata_ratio);
367 }
368 break;
369 case Opt_discard:
370 btrfs_set_opt(info->mount_opt, DISCARD);
371 break;
372 case Opt_space_cache:
373 btrfs_set_opt(info->mount_opt, SPACE_CACHE);
374 break;
375 case Opt_no_space_cache:
376 printk(KERN_INFO "btrfs: disabling disk space caching\n");
377 btrfs_clear_opt(info->mount_opt, SPACE_CACHE);
378 break;
379 case Opt_inode_cache:
380 printk(KERN_INFO "btrfs: enabling inode map caching\n");
381 btrfs_set_opt(info->mount_opt, INODE_MAP_CACHE);
382 break;
383 case Opt_clear_cache:
384 printk(KERN_INFO "btrfs: force clearing of disk cache\n");
385 btrfs_set_opt(info->mount_opt, CLEAR_CACHE);
386 break;
387 case Opt_user_subvol_rm_allowed:
388 btrfs_set_opt(info->mount_opt, USER_SUBVOL_RM_ALLOWED);
389 break;
390 case Opt_enospc_debug:
391 btrfs_set_opt(info->mount_opt, ENOSPC_DEBUG);
392 break;
393 case Opt_defrag:
394 printk(KERN_INFO "btrfs: enabling auto defrag");
395 btrfs_set_opt(info->mount_opt, AUTO_DEFRAG);
396 break;
397 case Opt_recovery:
398 printk(KERN_INFO "btrfs: enabling auto recovery");
399 btrfs_set_opt(info->mount_opt, RECOVERY);
400 break;
401 case Opt_err:
402 printk(KERN_INFO "btrfs: unrecognized mount option "
403 "'%s'\n", p);
404 ret = -EINVAL;
405 goto out;
406 default:
407 break;
408 }
409 }
410 out:
411 if (!ret && btrfs_test_opt(root, SPACE_CACHE))
412 printk(KERN_INFO "btrfs: disk space caching is enabled\n");
413 kfree(orig);
414 return ret;
415 }
416
417 /*
418 * Parse mount options that are required early in the mount process.
419 *
420 * All other options will be parsed on much later in the mount process and
421 * only when we need to allocate a new super block.
422 */
423 static int btrfs_parse_early_options(const char *options, fmode_t flags,
424 void *holder, char **subvol_name, u64 *subvol_objectid,
425 u64 *subvol_rootid, struct btrfs_fs_devices **fs_devices)
426 {
427 substring_t args[MAX_OPT_ARGS];
428 char *device_name, *opts, *orig, *p;
429 int error = 0;
430 int intarg;
431
432 if (!options)
433 return 0;
434
435 /*
436 * strsep changes the string, duplicate it because parse_options
437 * gets called twice
438 */
439 opts = kstrdup(options, GFP_KERNEL);
440 if (!opts)
441 return -ENOMEM;
442 orig = opts;
443
444 while ((p = strsep(&opts, ",")) != NULL) {
445 int token;
446 if (!*p)
447 continue;
448
449 token = match_token(p, tokens, args);
450 switch (token) {
451 case Opt_subvol:
452 kfree(*subvol_name);
453 *subvol_name = match_strdup(&args[0]);
454 break;
455 case Opt_subvolid:
456 intarg = 0;
457 error = match_int(&args[0], &intarg);
458 if (!error) {
459 /* we want the original fs_tree */
460 if (!intarg)
461 *subvol_objectid =
462 BTRFS_FS_TREE_OBJECTID;
463 else
464 *subvol_objectid = intarg;
465 }
466 break;
467 case Opt_subvolrootid:
468 intarg = 0;
469 error = match_int(&args[0], &intarg);
470 if (!error) {
471 /* we want the original fs_tree */
472 if (!intarg)
473 *subvol_rootid =
474 BTRFS_FS_TREE_OBJECTID;
475 else
476 *subvol_rootid = intarg;
477 }
478 break;
479 case Opt_device:
480 device_name = match_strdup(&args[0]);
481 if (!device_name) {
482 error = -ENOMEM;
483 goto out;
484 }
485 error = btrfs_scan_one_device(device_name,
486 flags, holder, fs_devices);
487 kfree(device_name);
488 if (error)
489 goto out;
490 break;
491 default:
492 break;
493 }
494 }
495
496 out:
497 kfree(orig);
498 return error;
499 }
500
501 static struct dentry *get_default_root(struct super_block *sb,
502 u64 subvol_objectid)
503 {
504 struct btrfs_root *root = sb->s_fs_info;
505 struct btrfs_root *new_root;
506 struct btrfs_dir_item *di;
507 struct btrfs_path *path;
508 struct btrfs_key location;
509 struct inode *inode;
510 u64 dir_id;
511 int new = 0;
512
513 /*
514 * We have a specific subvol we want to mount, just setup location and
515 * go look up the root.
516 */
517 if (subvol_objectid) {
518 location.objectid = subvol_objectid;
519 location.type = BTRFS_ROOT_ITEM_KEY;
520 location.offset = (u64)-1;
521 goto find_root;
522 }
523
524 path = btrfs_alloc_path();
525 if (!path)
526 return ERR_PTR(-ENOMEM);
527 path->leave_spinning = 1;
528
529 /*
530 * Find the "default" dir item which points to the root item that we
531 * will mount by default if we haven't been given a specific subvolume
532 * to mount.
533 */
534 dir_id = btrfs_super_root_dir(root->fs_info->super_copy);
535 di = btrfs_lookup_dir_item(NULL, root, path, dir_id, "default", 7, 0);
536 if (IS_ERR(di)) {
537 btrfs_free_path(path);
538 return ERR_CAST(di);
539 }
540 if (!di) {
541 /*
542 * Ok the default dir item isn't there. This is weird since
543 * it's always been there, but don't freak out, just try and
544 * mount to root most subvolume.
545 */
546 btrfs_free_path(path);
547 dir_id = BTRFS_FIRST_FREE_OBJECTID;
548 new_root = root->fs_info->fs_root;
549 goto setup_root;
550 }
551
552 btrfs_dir_item_key_to_cpu(path->nodes[0], di, &location);
553 btrfs_free_path(path);
554
555 find_root:
556 new_root = btrfs_read_fs_root_no_name(root->fs_info, &location);
557 if (IS_ERR(new_root))
558 return ERR_CAST(new_root);
559
560 if (btrfs_root_refs(&new_root->root_item) == 0)
561 return ERR_PTR(-ENOENT);
562
563 dir_id = btrfs_root_dirid(&new_root->root_item);
564 setup_root:
565 location.objectid = dir_id;
566 location.type = BTRFS_INODE_ITEM_KEY;
567 location.offset = 0;
568
569 inode = btrfs_iget(sb, &location, new_root, &new);
570 if (IS_ERR(inode))
571 return ERR_CAST(inode);
572
573 /*
574 * If we're just mounting the root most subvol put the inode and return
575 * a reference to the dentry. We will have already gotten a reference
576 * to the inode in btrfs_fill_super so we're good to go.
577 */
578 if (!new && sb->s_root->d_inode == inode) {
579 iput(inode);
580 return dget(sb->s_root);
581 }
582
583 return d_obtain_alias(inode);
584 }
585
586 static int btrfs_fill_super(struct super_block *sb,
587 struct btrfs_fs_devices *fs_devices,
588 void *data, int silent)
589 {
590 struct inode *inode;
591 struct dentry *root_dentry;
592 struct btrfs_root *tree_root;
593 struct btrfs_key key;
594 int err;
595
596 sb->s_maxbytes = MAX_LFS_FILESIZE;
597 sb->s_magic = BTRFS_SUPER_MAGIC;
598 sb->s_op = &btrfs_super_ops;
599 sb->s_d_op = &btrfs_dentry_operations;
600 sb->s_export_op = &btrfs_export_ops;
601 sb->s_xattr = btrfs_xattr_handlers;
602 sb->s_time_gran = 1;
603 #ifdef CONFIG_BTRFS_FS_POSIX_ACL
604 sb->s_flags |= MS_POSIXACL;
605 #endif
606
607 tree_root = open_ctree(sb, fs_devices, (char *)data);
608
609 if (IS_ERR(tree_root)) {
610 printk("btrfs: open_ctree failed\n");
611 return PTR_ERR(tree_root);
612 }
613 sb->s_fs_info = tree_root;
614
615 key.objectid = BTRFS_FIRST_FREE_OBJECTID;
616 key.type = BTRFS_INODE_ITEM_KEY;
617 key.offset = 0;
618 inode = btrfs_iget(sb, &key, tree_root->fs_info->fs_root, NULL);
619 if (IS_ERR(inode)) {
620 err = PTR_ERR(inode);
621 goto fail_close;
622 }
623
624 root_dentry = d_alloc_root(inode);
625 if (!root_dentry) {
626 iput(inode);
627 err = -ENOMEM;
628 goto fail_close;
629 }
630
631 sb->s_root = root_dentry;
632
633 save_mount_options(sb, data);
634 cleancache_init_fs(sb);
635 return 0;
636
637 fail_close:
638 close_ctree(tree_root);
639 return err;
640 }
641
642 int btrfs_sync_fs(struct super_block *sb, int wait)
643 {
644 struct btrfs_trans_handle *trans;
645 struct btrfs_root *root = btrfs_sb(sb);
646 int ret;
647
648 trace_btrfs_sync_fs(wait);
649
650 if (!wait) {
651 filemap_flush(root->fs_info->btree_inode->i_mapping);
652 return 0;
653 }
654
655 btrfs_start_delalloc_inodes(root, 0);
656 btrfs_wait_ordered_extents(root, 0, 0);
657
658 trans = btrfs_start_transaction(root, 0);
659 if (IS_ERR(trans))
660 return PTR_ERR(trans);
661 ret = btrfs_commit_transaction(trans, root);
662 return ret;
663 }
664
665 static int btrfs_show_options(struct seq_file *seq, struct vfsmount *vfs)
666 {
667 struct btrfs_root *root = btrfs_sb(vfs->mnt_sb);
668 struct btrfs_fs_info *info = root->fs_info;
669 char *compress_type;
670
671 if (btrfs_test_opt(root, DEGRADED))
672 seq_puts(seq, ",degraded");
673 if (btrfs_test_opt(root, NODATASUM))
674 seq_puts(seq, ",nodatasum");
675 if (btrfs_test_opt(root, NODATACOW))
676 seq_puts(seq, ",nodatacow");
677 if (btrfs_test_opt(root, NOBARRIER))
678 seq_puts(seq, ",nobarrier");
679 if (info->max_inline != 8192 * 1024)
680 seq_printf(seq, ",max_inline=%llu",
681 (unsigned long long)info->max_inline);
682 if (info->alloc_start != 0)
683 seq_printf(seq, ",alloc_start=%llu",
684 (unsigned long long)info->alloc_start);
685 if (info->thread_pool_size != min_t(unsigned long,
686 num_online_cpus() + 2, 8))
687 seq_printf(seq, ",thread_pool=%d", info->thread_pool_size);
688 if (btrfs_test_opt(root, COMPRESS)) {
689 if (info->compress_type == BTRFS_COMPRESS_ZLIB)
690 compress_type = "zlib";
691 else
692 compress_type = "lzo";
693 if (btrfs_test_opt(root, FORCE_COMPRESS))
694 seq_printf(seq, ",compress-force=%s", compress_type);
695 else
696 seq_printf(seq, ",compress=%s", compress_type);
697 }
698 if (btrfs_test_opt(root, NOSSD))
699 seq_puts(seq, ",nossd");
700 if (btrfs_test_opt(root, SSD_SPREAD))
701 seq_puts(seq, ",ssd_spread");
702 else if (btrfs_test_opt(root, SSD))
703 seq_puts(seq, ",ssd");
704 if (btrfs_test_opt(root, NOTREELOG))
705 seq_puts(seq, ",notreelog");
706 if (btrfs_test_opt(root, FLUSHONCOMMIT))
707 seq_puts(seq, ",flushoncommit");
708 if (btrfs_test_opt(root, DISCARD))
709 seq_puts(seq, ",discard");
710 if (!(root->fs_info->sb->s_flags & MS_POSIXACL))
711 seq_puts(seq, ",noacl");
712 if (btrfs_test_opt(root, SPACE_CACHE))
713 seq_puts(seq, ",space_cache");
714 else
715 seq_puts(seq, ",nospace_cache");
716 if (btrfs_test_opt(root, CLEAR_CACHE))
717 seq_puts(seq, ",clear_cache");
718 if (btrfs_test_opt(root, USER_SUBVOL_RM_ALLOWED))
719 seq_puts(seq, ",user_subvol_rm_allowed");
720 if (btrfs_test_opt(root, ENOSPC_DEBUG))
721 seq_puts(seq, ",enospc_debug");
722 if (btrfs_test_opt(root, AUTO_DEFRAG))
723 seq_puts(seq, ",autodefrag");
724 if (btrfs_test_opt(root, INODE_MAP_CACHE))
725 seq_puts(seq, ",inode_cache");
726 return 0;
727 }
728
729 static int btrfs_test_super(struct super_block *s, void *data)
730 {
731 struct btrfs_root *test_root = data;
732 struct btrfs_root *root = btrfs_sb(s);
733
734 /*
735 * If this super block is going away, return false as it
736 * can't match as an existing super block.
737 */
738 if (!atomic_read(&s->s_active))
739 return 0;
740 return root->fs_info->fs_devices == test_root->fs_info->fs_devices;
741 }
742
743 static int btrfs_set_super(struct super_block *s, void *data)
744 {
745 s->s_fs_info = data;
746
747 return set_anon_super(s, data);
748 }
749
750 /*
751 * subvolumes are identified by ino 256
752 */
753 static inline int is_subvolume_inode(struct inode *inode)
754 {
755 if (inode && inode->i_ino == BTRFS_FIRST_FREE_OBJECTID)
756 return 1;
757 return 0;
758 }
759
760 /*
761 * This will strip out the subvol=%s argument for an argument string and add
762 * subvolid=0 to make sure we get the actual tree root for path walking to the
763 * subvol we want.
764 */
765 static char *setup_root_args(char *args)
766 {
767 unsigned copied = 0;
768 unsigned len = strlen(args) + 2;
769 char *pos;
770 char *ret;
771
772 /*
773 * We need the same args as before, but minus
774 *
775 * subvol=a
776 *
777 * and add
778 *
779 * subvolid=0
780 *
781 * which is a difference of 2 characters, so we allocate strlen(args) +
782 * 2 characters.
783 */
784 ret = kzalloc(len * sizeof(char), GFP_NOFS);
785 if (!ret)
786 return NULL;
787 pos = strstr(args, "subvol=");
788
789 /* This shouldn't happen, but just in case.. */
790 if (!pos) {
791 kfree(ret);
792 return NULL;
793 }
794
795 /*
796 * The subvol=<> arg is not at the front of the string, copy everybody
797 * up to that into ret.
798 */
799 if (pos != args) {
800 *pos = '\0';
801 strcpy(ret, args);
802 copied += strlen(args);
803 pos++;
804 }
805
806 strncpy(ret + copied, "subvolid=0", len - copied);
807
808 /* Length of subvolid=0 */
809 copied += 10;
810
811 /*
812 * If there is no , after the subvol= option then we know there's no
813 * other options and we can just return.
814 */
815 pos = strchr(pos, ',');
816 if (!pos)
817 return ret;
818
819 /* Copy the rest of the arguments into our buffer */
820 strncpy(ret + copied, pos, len - copied);
821 copied += strlen(pos);
822
823 return ret;
824 }
825
826 static struct dentry *mount_subvol(const char *subvol_name, int flags,
827 const char *device_name, char *data)
828 {
829 struct dentry *root;
830 struct vfsmount *mnt;
831 char *newargs;
832
833 newargs = setup_root_args(data);
834 if (!newargs)
835 return ERR_PTR(-ENOMEM);
836 mnt = vfs_kern_mount(&btrfs_fs_type, flags, device_name,
837 newargs);
838 kfree(newargs);
839 if (IS_ERR(mnt))
840 return ERR_CAST(mnt);
841
842 root = mount_subtree(mnt, subvol_name);
843
844 if (!IS_ERR(root) && !is_subvolume_inode(root->d_inode)) {
845 struct super_block *s = root->d_sb;
846 dput(root);
847 root = ERR_PTR(-EINVAL);
848 deactivate_locked_super(s);
849 printk(KERN_ERR "btrfs: '%s' is not a valid subvolume\n",
850 subvol_name);
851 }
852
853 return root;
854 }
855
856 /*
857 * Find a superblock for the given device / mount point.
858 *
859 * Note: This is based on get_sb_bdev from fs/super.c with a few additions
860 * for multiple device setup. Make sure to keep it in sync.
861 */
862 static struct dentry *btrfs_mount(struct file_system_type *fs_type, int flags,
863 const char *device_name, void *data)
864 {
865 struct block_device *bdev = NULL;
866 struct super_block *s;
867 struct dentry *root;
868 struct btrfs_fs_devices *fs_devices = NULL;
869 struct btrfs_fs_info *fs_info = NULL;
870 fmode_t mode = FMODE_READ;
871 char *subvol_name = NULL;
872 u64 subvol_objectid = 0;
873 u64 subvol_rootid = 0;
874 int error = 0;
875
876 if (!(flags & MS_RDONLY))
877 mode |= FMODE_WRITE;
878
879 error = btrfs_parse_early_options(data, mode, fs_type,
880 &subvol_name, &subvol_objectid,
881 &subvol_rootid, &fs_devices);
882 if (error) {
883 kfree(subvol_name);
884 return ERR_PTR(error);
885 }
886
887 if (subvol_name) {
888 root = mount_subvol(subvol_name, flags, device_name, data);
889 kfree(subvol_name);
890 return root;
891 }
892
893 error = btrfs_scan_one_device(device_name, mode, fs_type, &fs_devices);
894 if (error)
895 return ERR_PTR(error);
896
897 /*
898 * Setup a dummy root and fs_info for test/set super. This is because
899 * we don't actually fill this stuff out until open_ctree, but we need
900 * it for searching for existing supers, so this lets us do that and
901 * then open_ctree will properly initialize everything later.
902 */
903 fs_info = kzalloc(sizeof(struct btrfs_fs_info), GFP_NOFS);
904 if (!fs_info)
905 return ERR_PTR(-ENOMEM);
906
907 fs_info->tree_root = kzalloc(sizeof(struct btrfs_root), GFP_NOFS);
908 if (!fs_info->tree_root) {
909 error = -ENOMEM;
910 goto error_fs_info;
911 }
912 fs_info->tree_root->fs_info = fs_info;
913 fs_info->fs_devices = fs_devices;
914
915 fs_info->super_copy = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_NOFS);
916 fs_info->super_for_commit = kzalloc(BTRFS_SUPER_INFO_SIZE, GFP_NOFS);
917 if (!fs_info->super_copy || !fs_info->super_for_commit) {
918 error = -ENOMEM;
919 goto error_fs_info;
920 }
921
922 error = btrfs_open_devices(fs_devices, mode, fs_type);
923 if (error)
924 goto error_fs_info;
925
926 if (!(flags & MS_RDONLY) && fs_devices->rw_devices == 0) {
927 error = -EACCES;
928 goto error_close_devices;
929 }
930
931 bdev = fs_devices->latest_bdev;
932 s = sget(fs_type, btrfs_test_super, btrfs_set_super,
933 fs_info->tree_root);
934 if (IS_ERR(s)) {
935 error = PTR_ERR(s);
936 goto error_close_devices;
937 }
938
939 if (s->s_root) {
940 if ((flags ^ s->s_flags) & MS_RDONLY) {
941 deactivate_locked_super(s);
942 error = -EBUSY;
943 goto error_close_devices;
944 }
945
946 btrfs_close_devices(fs_devices);
947 free_fs_info(fs_info);
948 } else {
949 char b[BDEVNAME_SIZE];
950
951 s->s_flags = flags | MS_NOSEC;
952 strlcpy(s->s_id, bdevname(bdev, b), sizeof(s->s_id));
953 btrfs_sb(s)->fs_info->bdev_holder = fs_type;
954 error = btrfs_fill_super(s, fs_devices, data,
955 flags & MS_SILENT ? 1 : 0);
956 if (error) {
957 deactivate_locked_super(s);
958 return ERR_PTR(error);
959 }
960
961 s->s_flags |= MS_ACTIVE;
962 }
963
964 root = get_default_root(s, subvol_objectid);
965 if (IS_ERR(root)) {
966 deactivate_locked_super(s);
967 return root;
968 }
969
970 return root;
971
972 error_close_devices:
973 btrfs_close_devices(fs_devices);
974 error_fs_info:
975 free_fs_info(fs_info);
976 return ERR_PTR(error);
977 }
978
979 static int btrfs_remount(struct super_block *sb, int *flags, char *data)
980 {
981 struct btrfs_root *root = btrfs_sb(sb);
982 int ret;
983
984 ret = btrfs_parse_options(root, data);
985 if (ret)
986 return -EINVAL;
987
988 if ((*flags & MS_RDONLY) == (sb->s_flags & MS_RDONLY))
989 return 0;
990
991 if (*flags & MS_RDONLY) {
992 sb->s_flags |= MS_RDONLY;
993
994 ret = btrfs_commit_super(root);
995 WARN_ON(ret);
996 } else {
997 if (root->fs_info->fs_devices->rw_devices == 0)
998 return -EACCES;
999
1000 if (btrfs_super_log_root(root->fs_info->super_copy) != 0)
1001 return -EINVAL;
1002
1003 ret = btrfs_cleanup_fs_roots(root->fs_info);
1004 WARN_ON(ret);
1005
1006 /* recover relocation */
1007 ret = btrfs_recover_relocation(root);
1008 WARN_ON(ret);
1009
1010 sb->s_flags &= ~MS_RDONLY;
1011 }
1012
1013 return 0;
1014 }
1015
1016 /* Used to sort the devices by max_avail(descending sort) */
1017 static int btrfs_cmp_device_free_bytes(const void *dev_info1,
1018 const void *dev_info2)
1019 {
1020 if (((struct btrfs_device_info *)dev_info1)->max_avail >
1021 ((struct btrfs_device_info *)dev_info2)->max_avail)
1022 return -1;
1023 else if (((struct btrfs_device_info *)dev_info1)->max_avail <
1024 ((struct btrfs_device_info *)dev_info2)->max_avail)
1025 return 1;
1026 else
1027 return 0;
1028 }
1029
1030 /*
1031 * sort the devices by max_avail, in which max free extent size of each device
1032 * is stored.(Descending Sort)
1033 */
1034 static inline void btrfs_descending_sort_devices(
1035 struct btrfs_device_info *devices,
1036 size_t nr_devices)
1037 {
1038 sort(devices, nr_devices, sizeof(struct btrfs_device_info),
1039 btrfs_cmp_device_free_bytes, NULL);
1040 }
1041
1042 /*
1043 * The helper to calc the free space on the devices that can be used to store
1044 * file data.
1045 */
1046 static int btrfs_calc_avail_data_space(struct btrfs_root *root, u64 *free_bytes)
1047 {
1048 struct btrfs_fs_info *fs_info = root->fs_info;
1049 struct btrfs_device_info *devices_info;
1050 struct btrfs_fs_devices *fs_devices = fs_info->fs_devices;
1051 struct btrfs_device *device;
1052 u64 skip_space;
1053 u64 type;
1054 u64 avail_space;
1055 u64 used_space;
1056 u64 min_stripe_size;
1057 int min_stripes = 1, num_stripes = 1;
1058 int i = 0, nr_devices;
1059 int ret;
1060
1061 nr_devices = fs_info->fs_devices->open_devices;
1062 BUG_ON(!nr_devices);
1063
1064 devices_info = kmalloc(sizeof(*devices_info) * nr_devices,
1065 GFP_NOFS);
1066 if (!devices_info)
1067 return -ENOMEM;
1068
1069 /* calc min stripe number for data space alloction */
1070 type = btrfs_get_alloc_profile(root, 1);
1071 if (type & BTRFS_BLOCK_GROUP_RAID0) {
1072 min_stripes = 2;
1073 num_stripes = nr_devices;
1074 } else if (type & BTRFS_BLOCK_GROUP_RAID1) {
1075 min_stripes = 2;
1076 num_stripes = 2;
1077 } else if (type & BTRFS_BLOCK_GROUP_RAID10) {
1078 min_stripes = 4;
1079 num_stripes = 4;
1080 }
1081
1082 if (type & BTRFS_BLOCK_GROUP_DUP)
1083 min_stripe_size = 2 * BTRFS_STRIPE_LEN;
1084 else
1085 min_stripe_size = BTRFS_STRIPE_LEN;
1086
1087 list_for_each_entry(device, &fs_devices->devices, dev_list) {
1088 if (!device->in_fs_metadata || !device->bdev)
1089 continue;
1090
1091 avail_space = device->total_bytes - device->bytes_used;
1092
1093 /* align with stripe_len */
1094 do_div(avail_space, BTRFS_STRIPE_LEN);
1095 avail_space *= BTRFS_STRIPE_LEN;
1096
1097 /*
1098 * In order to avoid overwritting the superblock on the drive,
1099 * btrfs starts at an offset of at least 1MB when doing chunk
1100 * allocation.
1101 */
1102 skip_space = 1024 * 1024;
1103
1104 /* user can set the offset in fs_info->alloc_start. */
1105 if (fs_info->alloc_start + BTRFS_STRIPE_LEN <=
1106 device->total_bytes)
1107 skip_space = max(fs_info->alloc_start, skip_space);
1108
1109 /*
1110 * btrfs can not use the free space in [0, skip_space - 1],
1111 * we must subtract it from the total. In order to implement
1112 * it, we account the used space in this range first.
1113 */
1114 ret = btrfs_account_dev_extents_size(device, 0, skip_space - 1,
1115 &used_space);
1116 if (ret) {
1117 kfree(devices_info);
1118 return ret;
1119 }
1120
1121 /* calc the free space in [0, skip_space - 1] */
1122 skip_space -= used_space;
1123
1124 /*
1125 * we can use the free space in [0, skip_space - 1], subtract
1126 * it from the total.
1127 */
1128 if (avail_space && avail_space >= skip_space)
1129 avail_space -= skip_space;
1130 else
1131 avail_space = 0;
1132
1133 if (avail_space < min_stripe_size)
1134 continue;
1135
1136 devices_info[i].dev = device;
1137 devices_info[i].max_avail = avail_space;
1138
1139 i++;
1140 }
1141
1142 nr_devices = i;
1143
1144 btrfs_descending_sort_devices(devices_info, nr_devices);
1145
1146 i = nr_devices - 1;
1147 avail_space = 0;
1148 while (nr_devices >= min_stripes) {
1149 if (num_stripes > nr_devices)
1150 num_stripes = nr_devices;
1151
1152 if (devices_info[i].max_avail >= min_stripe_size) {
1153 int j;
1154 u64 alloc_size;
1155
1156 avail_space += devices_info[i].max_avail * num_stripes;
1157 alloc_size = devices_info[i].max_avail;
1158 for (j = i + 1 - num_stripes; j <= i; j++)
1159 devices_info[j].max_avail -= alloc_size;
1160 }
1161 i--;
1162 nr_devices--;
1163 }
1164
1165 kfree(devices_info);
1166 *free_bytes = avail_space;
1167 return 0;
1168 }
1169
1170 static int btrfs_statfs(struct dentry *dentry, struct kstatfs *buf)
1171 {
1172 struct btrfs_root *root = btrfs_sb(dentry->d_sb);
1173 struct btrfs_super_block *disk_super = root->fs_info->super_copy;
1174 struct list_head *head = &root->fs_info->space_info;
1175 struct btrfs_space_info *found;
1176 u64 total_used = 0;
1177 u64 total_free_data = 0;
1178 int bits = dentry->d_sb->s_blocksize_bits;
1179 __be32 *fsid = (__be32 *)root->fs_info->fsid;
1180 int ret;
1181
1182 /* holding chunk_muext to avoid allocating new chunks */
1183 mutex_lock(&root->fs_info->chunk_mutex);
1184 rcu_read_lock();
1185 list_for_each_entry_rcu(found, head, list) {
1186 if (found->flags & BTRFS_BLOCK_GROUP_DATA) {
1187 total_free_data += found->disk_total - found->disk_used;
1188 total_free_data -=
1189 btrfs_account_ro_block_groups_free_space(found);
1190 }
1191
1192 total_used += found->disk_used;
1193 }
1194 rcu_read_unlock();
1195
1196 buf->f_namelen = BTRFS_NAME_LEN;
1197 buf->f_blocks = btrfs_super_total_bytes(disk_super) >> bits;
1198 buf->f_bfree = buf->f_blocks - (total_used >> bits);
1199 buf->f_bsize = dentry->d_sb->s_blocksize;
1200 buf->f_type = BTRFS_SUPER_MAGIC;
1201 buf->f_bavail = total_free_data;
1202 ret = btrfs_calc_avail_data_space(root, &total_free_data);
1203 if (ret) {
1204 mutex_unlock(&root->fs_info->chunk_mutex);
1205 return ret;
1206 }
1207 buf->f_bavail += total_free_data;
1208 buf->f_bavail = buf->f_bavail >> bits;
1209 mutex_unlock(&root->fs_info->chunk_mutex);
1210
1211 /* We treat it as constant endianness (it doesn't matter _which_)
1212 because we want the fsid to come out the same whether mounted
1213 on a big-endian or little-endian host */
1214 buf->f_fsid.val[0] = be32_to_cpu(fsid[0]) ^ be32_to_cpu(fsid[2]);
1215 buf->f_fsid.val[1] = be32_to_cpu(fsid[1]) ^ be32_to_cpu(fsid[3]);
1216 /* Mask in the root object ID too, to disambiguate subvols */
1217 buf->f_fsid.val[0] ^= BTRFS_I(dentry->d_inode)->root->objectid >> 32;
1218 buf->f_fsid.val[1] ^= BTRFS_I(dentry->d_inode)->root->objectid;
1219
1220 return 0;
1221 }
1222
1223 static struct file_system_type btrfs_fs_type = {
1224 .owner = THIS_MODULE,
1225 .name = "btrfs",
1226 .mount = btrfs_mount,
1227 .kill_sb = kill_anon_super,
1228 .fs_flags = FS_REQUIRES_DEV,
1229 };
1230
1231 /*
1232 * used by btrfsctl to scan devices when no FS is mounted
1233 */
1234 static long btrfs_control_ioctl(struct file *file, unsigned int cmd,
1235 unsigned long arg)
1236 {
1237 struct btrfs_ioctl_vol_args *vol;
1238 struct btrfs_fs_devices *fs_devices;
1239 int ret = -ENOTTY;
1240
1241 if (!capable(CAP_SYS_ADMIN))
1242 return -EPERM;
1243
1244 vol = memdup_user((void __user *)arg, sizeof(*vol));
1245 if (IS_ERR(vol))
1246 return PTR_ERR(vol);
1247
1248 switch (cmd) {
1249 case BTRFS_IOC_SCAN_DEV:
1250 ret = btrfs_scan_one_device(vol->name, FMODE_READ,
1251 &btrfs_fs_type, &fs_devices);
1252 break;
1253 }
1254
1255 kfree(vol);
1256 return ret;
1257 }
1258
1259 static int btrfs_freeze(struct super_block *sb)
1260 {
1261 struct btrfs_root *root = btrfs_sb(sb);
1262 mutex_lock(&root->fs_info->transaction_kthread_mutex);
1263 mutex_lock(&root->fs_info->cleaner_mutex);
1264 return 0;
1265 }
1266
1267 static int btrfs_unfreeze(struct super_block *sb)
1268 {
1269 struct btrfs_root *root = btrfs_sb(sb);
1270 mutex_unlock(&root->fs_info->cleaner_mutex);
1271 mutex_unlock(&root->fs_info->transaction_kthread_mutex);
1272 return 0;
1273 }
1274
1275 static void btrfs_fs_dirty_inode(struct inode *inode, int flags)
1276 {
1277 int ret;
1278
1279 ret = btrfs_dirty_inode(inode);
1280 if (ret)
1281 printk_ratelimited(KERN_ERR "btrfs: fail to dirty inode %Lu "
1282 "error %d\n", btrfs_ino(inode), ret);
1283 }
1284
1285 static const struct super_operations btrfs_super_ops = {
1286 .drop_inode = btrfs_drop_inode,
1287 .evict_inode = btrfs_evict_inode,
1288 .put_super = btrfs_put_super,
1289 .sync_fs = btrfs_sync_fs,
1290 .show_options = btrfs_show_options,
1291 .write_inode = btrfs_write_inode,
1292 .dirty_inode = btrfs_fs_dirty_inode,
1293 .alloc_inode = btrfs_alloc_inode,
1294 .destroy_inode = btrfs_destroy_inode,
1295 .statfs = btrfs_statfs,
1296 .remount_fs = btrfs_remount,
1297 .freeze_fs = btrfs_freeze,
1298 .unfreeze_fs = btrfs_unfreeze,
1299 };
1300
1301 static const struct file_operations btrfs_ctl_fops = {
1302 .unlocked_ioctl = btrfs_control_ioctl,
1303 .compat_ioctl = btrfs_control_ioctl,
1304 .owner = THIS_MODULE,
1305 .llseek = noop_llseek,
1306 };
1307
1308 static struct miscdevice btrfs_misc = {
1309 .minor = BTRFS_MINOR,
1310 .name = "btrfs-control",
1311 .fops = &btrfs_ctl_fops
1312 };
1313
1314 MODULE_ALIAS_MISCDEV(BTRFS_MINOR);
1315 MODULE_ALIAS("devname:btrfs-control");
1316
1317 static int btrfs_interface_init(void)
1318 {
1319 return misc_register(&btrfs_misc);
1320 }
1321
1322 static void btrfs_interface_exit(void)
1323 {
1324 if (misc_deregister(&btrfs_misc) < 0)
1325 printk(KERN_INFO "misc_deregister failed for control device");
1326 }
1327
1328 static int __init init_btrfs_fs(void)
1329 {
1330 int err;
1331
1332 err = btrfs_init_sysfs();
1333 if (err)
1334 return err;
1335
1336 err = btrfs_init_compress();
1337 if (err)
1338 goto free_sysfs;
1339
1340 err = btrfs_init_cachep();
1341 if (err)
1342 goto free_compress;
1343
1344 err = extent_io_init();
1345 if (err)
1346 goto free_cachep;
1347
1348 err = extent_map_init();
1349 if (err)
1350 goto free_extent_io;
1351
1352 err = btrfs_delayed_inode_init();
1353 if (err)
1354 goto free_extent_map;
1355
1356 err = btrfs_interface_init();
1357 if (err)
1358 goto free_delayed_inode;
1359
1360 err = register_filesystem(&btrfs_fs_type);
1361 if (err)
1362 goto unregister_ioctl;
1363
1364 printk(KERN_INFO "%s loaded\n", BTRFS_BUILD_VERSION);
1365 return 0;
1366
1367 unregister_ioctl:
1368 btrfs_interface_exit();
1369 free_delayed_inode:
1370 btrfs_delayed_inode_exit();
1371 free_extent_map:
1372 extent_map_exit();
1373 free_extent_io:
1374 extent_io_exit();
1375 free_cachep:
1376 btrfs_destroy_cachep();
1377 free_compress:
1378 btrfs_exit_compress();
1379 free_sysfs:
1380 btrfs_exit_sysfs();
1381 return err;
1382 }
1383
1384 static void __exit exit_btrfs_fs(void)
1385 {
1386 btrfs_destroy_cachep();
1387 btrfs_delayed_inode_exit();
1388 extent_map_exit();
1389 extent_io_exit();
1390 btrfs_interface_exit();
1391 unregister_filesystem(&btrfs_fs_type);
1392 btrfs_exit_sysfs();
1393 btrfs_cleanup_fs_uuids();
1394 btrfs_exit_compress();
1395 }
1396
1397 module_init(init_btrfs_fs)
1398 module_exit(exit_btrfs_fs)
1399
1400 MODULE_LICENSE("GPL");
Linux with added FPC-III support