1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Copyright (c) 2000-2006 Silicon Graphics, Inc. 4 * All Rights Reserved. 5 */ 6 7 #include "xfs.h" 8 #include "xfs_shared.h" 9 #include "xfs_format.h" 10 #include "xfs_log_format.h" 11 #include "xfs_trans_resv.h" 12 #include "xfs_sb.h" 13 #include "xfs_mount.h" 14 #include "xfs_inode.h" 15 #include "xfs_btree.h" 16 #include "xfs_bmap.h" 17 #include "xfs_alloc.h" 18 #include "xfs_fsops.h" 19 #include "xfs_trans.h" 20 #include "xfs_buf_item.h" 21 #include "xfs_log.h" 22 #include "xfs_log_priv.h" 23 #include "xfs_dir2.h" 24 #include "xfs_extfree_item.h" 25 #include "xfs_mru_cache.h" 26 #include "xfs_inode_item.h" 27 #include "xfs_icache.h" 28 #include "xfs_trace.h" 29 #include "xfs_icreate_item.h" 30 #include "xfs_filestream.h" 31 #include "xfs_quota.h" 32 #include "xfs_sysfs.h" 33 #include "xfs_ondisk.h" 34 #include "xfs_rmap_item.h" 35 #include "xfs_refcount_item.h" 36 #include "xfs_bmap_item.h" 37 #include "xfs_reflink.h" 38 #include "xfs_pwork.h" 39 #include "xfs_ag.h" 40 #include "xfs_defer.h" 41 #include "xfs_attr_item.h" 42 #include "xfs_xattr.h" 43 #include "xfs_iunlink_item.h" 44 #include "xfs_dahash_test.h" 45 #include "xfs_rtbitmap.h" 46 #include "xfs_exchmaps_item.h" 47 #include "xfs_parent.h" 48 #include "xfs_rtalloc.h" 49 #include "scrub/stats.h" 50 #include "scrub/rcbag_btree.h" 51 52 #include <linux/magic.h> 53 #include <linux/fs_context.h> 54 #include <linux/fs_parser.h> 55 56 static const struct super_operations xfs_super_operations; 57 58 static struct dentry *xfs_debugfs; /* top-level xfs debugfs dir */ 59 static struct kset *xfs_kset; /* top-level xfs sysfs dir */ 60 #ifdef DEBUG 61 static struct xfs_kobj xfs_dbg_kobj; /* global debug sysfs attrs */ 62 #endif 63 64 enum xfs_dax_mode { 65 XFS_DAX_INODE = 0, 66 XFS_DAX_ALWAYS = 1, 67 XFS_DAX_NEVER = 2, 68 }; 69 70 /* Were quota mount options provided? Must use the upper 16 bits of qflags. */ 71 #define XFS_QFLAGS_MNTOPTS (1U << 31) 72 73 static void 74 xfs_mount_set_dax_mode( 75 struct xfs_mount *mp, 76 enum xfs_dax_mode mode) 77 { 78 switch (mode) { 79 case XFS_DAX_INODE: 80 mp->m_features &= ~(XFS_FEAT_DAX_ALWAYS | XFS_FEAT_DAX_NEVER); 81 break; 82 case XFS_DAX_ALWAYS: 83 mp->m_features |= XFS_FEAT_DAX_ALWAYS; 84 mp->m_features &= ~XFS_FEAT_DAX_NEVER; 85 break; 86 case XFS_DAX_NEVER: 87 mp->m_features |= XFS_FEAT_DAX_NEVER; 88 mp->m_features &= ~XFS_FEAT_DAX_ALWAYS; 89 break; 90 } 91 } 92 93 static const struct constant_table dax_param_enums[] = { 94 {"inode", XFS_DAX_INODE }, 95 {"always", XFS_DAX_ALWAYS }, 96 {"never", XFS_DAX_NEVER }, 97 {} 98 }; 99 100 /* 101 * Table driven mount option parser. 102 */ 103 enum { 104 Opt_logbufs, Opt_logbsize, Opt_logdev, Opt_rtdev, 105 Opt_wsync, Opt_noalign, Opt_swalloc, Opt_sunit, Opt_swidth, Opt_nouuid, 106 Opt_grpid, Opt_nogrpid, Opt_bsdgroups, Opt_sysvgroups, 107 Opt_allocsize, Opt_norecovery, Opt_inode64, Opt_inode32, Opt_ikeep, 108 Opt_noikeep, Opt_largeio, Opt_nolargeio, Opt_attr2, Opt_noattr2, 109 Opt_filestreams, Opt_quota, Opt_noquota, Opt_usrquota, Opt_grpquota, 110 Opt_prjquota, Opt_uquota, Opt_gquota, Opt_pquota, 111 Opt_uqnoenforce, Opt_gqnoenforce, Opt_pqnoenforce, Opt_qnoenforce, 112 Opt_discard, Opt_nodiscard, Opt_dax, Opt_dax_enum, 113 }; 114 115 static const struct fs_parameter_spec xfs_fs_parameters[] = { 116 fsparam_u32("logbufs", Opt_logbufs), 117 fsparam_string("logbsize", Opt_logbsize), 118 fsparam_string("logdev", Opt_logdev), 119 fsparam_string("rtdev", Opt_rtdev), 120 fsparam_flag("wsync", Opt_wsync), 121 fsparam_flag("noalign", Opt_noalign), 122 fsparam_flag("swalloc", Opt_swalloc), 123 fsparam_u32("sunit", Opt_sunit), 124 fsparam_u32("swidth", Opt_swidth), 125 fsparam_flag("nouuid", Opt_nouuid), 126 fsparam_flag("grpid", Opt_grpid), 127 fsparam_flag("nogrpid", Opt_nogrpid), 128 fsparam_flag("bsdgroups", Opt_bsdgroups), 129 fsparam_flag("sysvgroups", Opt_sysvgroups), 130 fsparam_string("allocsize", Opt_allocsize), 131 fsparam_flag("norecovery", Opt_norecovery), 132 fsparam_flag("inode64", Opt_inode64), 133 fsparam_flag("inode32", Opt_inode32), 134 fsparam_flag("ikeep", Opt_ikeep), 135 fsparam_flag("noikeep", Opt_noikeep), 136 fsparam_flag("largeio", Opt_largeio), 137 fsparam_flag("nolargeio", Opt_nolargeio), 138 fsparam_flag("attr2", Opt_attr2), 139 fsparam_flag("noattr2", Opt_noattr2), 140 fsparam_flag("filestreams", Opt_filestreams), 141 fsparam_flag("quota", Opt_quota), 142 fsparam_flag("noquota", Opt_noquota), 143 fsparam_flag("usrquota", Opt_usrquota), 144 fsparam_flag("grpquota", Opt_grpquota), 145 fsparam_flag("prjquota", Opt_prjquota), 146 fsparam_flag("uquota", Opt_uquota), 147 fsparam_flag("gquota", Opt_gquota), 148 fsparam_flag("pquota", Opt_pquota), 149 fsparam_flag("uqnoenforce", Opt_uqnoenforce), 150 fsparam_flag("gqnoenforce", Opt_gqnoenforce), 151 fsparam_flag("pqnoenforce", Opt_pqnoenforce), 152 fsparam_flag("qnoenforce", Opt_qnoenforce), 153 fsparam_flag("discard", Opt_discard), 154 fsparam_flag("nodiscard", Opt_nodiscard), 155 fsparam_flag("dax", Opt_dax), 156 fsparam_enum("dax", Opt_dax_enum, dax_param_enums), 157 {} 158 }; 159 160 struct proc_xfs_info { 161 uint64_t flag; 162 char *str; 163 }; 164 165 static int 166 xfs_fs_show_options( 167 struct seq_file *m, 168 struct dentry *root) 169 { 170 static struct proc_xfs_info xfs_info_set[] = { 171 /* the few simple ones we can get from the mount struct */ 172 { XFS_FEAT_IKEEP, ",ikeep" }, 173 { XFS_FEAT_WSYNC, ",wsync" }, 174 { XFS_FEAT_NOALIGN, ",noalign" }, 175 { XFS_FEAT_SWALLOC, ",swalloc" }, 176 { XFS_FEAT_NOUUID, ",nouuid" }, 177 { XFS_FEAT_NORECOVERY, ",norecovery" }, 178 { XFS_FEAT_ATTR2, ",attr2" }, 179 { XFS_FEAT_FILESTREAMS, ",filestreams" }, 180 { XFS_FEAT_GRPID, ",grpid" }, 181 { XFS_FEAT_DISCARD, ",discard" }, 182 { XFS_FEAT_LARGE_IOSIZE, ",largeio" }, 183 { XFS_FEAT_DAX_ALWAYS, ",dax=always" }, 184 { XFS_FEAT_DAX_NEVER, ",dax=never" }, 185 { 0, NULL } 186 }; 187 struct xfs_mount *mp = XFS_M(root->d_sb); 188 struct proc_xfs_info *xfs_infop; 189 190 for (xfs_infop = xfs_info_set; xfs_infop->flag; xfs_infop++) { 191 if (mp->m_features & xfs_infop->flag) 192 seq_puts(m, xfs_infop->str); 193 } 194 195 seq_printf(m, ",inode%d", xfs_has_small_inums(mp) ? 32 : 64); 196 197 if (xfs_has_allocsize(mp)) 198 seq_printf(m, ",allocsize=%dk", 199 (1 << mp->m_allocsize_log) >> 10); 200 201 if (mp->m_logbufs > 0) 202 seq_printf(m, ",logbufs=%d", mp->m_logbufs); 203 if (mp->m_logbsize > 0) 204 seq_printf(m, ",logbsize=%dk", mp->m_logbsize >> 10); 205 206 if (mp->m_logname) 207 seq_show_option(m, "logdev", mp->m_logname); 208 if (mp->m_rtname) 209 seq_show_option(m, "rtdev", mp->m_rtname); 210 211 if (mp->m_dalign > 0) 212 seq_printf(m, ",sunit=%d", 213 (int)XFS_FSB_TO_BB(mp, mp->m_dalign)); 214 if (mp->m_swidth > 0) 215 seq_printf(m, ",swidth=%d", 216 (int)XFS_FSB_TO_BB(mp, mp->m_swidth)); 217 218 if (mp->m_qflags & XFS_UQUOTA_ENFD) 219 seq_puts(m, ",usrquota"); 220 else if (mp->m_qflags & XFS_UQUOTA_ACCT) 221 seq_puts(m, ",uqnoenforce"); 222 223 if (mp->m_qflags & XFS_PQUOTA_ENFD) 224 seq_puts(m, ",prjquota"); 225 else if (mp->m_qflags & XFS_PQUOTA_ACCT) 226 seq_puts(m, ",pqnoenforce"); 227 228 if (mp->m_qflags & XFS_GQUOTA_ENFD) 229 seq_puts(m, ",grpquota"); 230 else if (mp->m_qflags & XFS_GQUOTA_ACCT) 231 seq_puts(m, ",gqnoenforce"); 232 233 if (!(mp->m_qflags & XFS_ALL_QUOTA_ACCT)) 234 seq_puts(m, ",noquota"); 235 236 return 0; 237 } 238 239 static bool 240 xfs_set_inode_alloc_perag( 241 struct xfs_perag *pag, 242 xfs_ino_t ino, 243 xfs_agnumber_t max_metadata) 244 { 245 if (!xfs_is_inode32(pag_mount(pag))) { 246 set_bit(XFS_AGSTATE_ALLOWS_INODES, &pag->pag_opstate); 247 clear_bit(XFS_AGSTATE_PREFERS_METADATA, &pag->pag_opstate); 248 return false; 249 } 250 251 if (ino > XFS_MAXINUMBER_32) { 252 clear_bit(XFS_AGSTATE_ALLOWS_INODES, &pag->pag_opstate); 253 clear_bit(XFS_AGSTATE_PREFERS_METADATA, &pag->pag_opstate); 254 return false; 255 } 256 257 set_bit(XFS_AGSTATE_ALLOWS_INODES, &pag->pag_opstate); 258 if (pag_agno(pag) < max_metadata) 259 set_bit(XFS_AGSTATE_PREFERS_METADATA, &pag->pag_opstate); 260 else 261 clear_bit(XFS_AGSTATE_PREFERS_METADATA, &pag->pag_opstate); 262 return true; 263 } 264 265 /* 266 * Set parameters for inode allocation heuristics, taking into account 267 * filesystem size and inode32/inode64 mount options; i.e. specifically 268 * whether or not XFS_FEAT_SMALL_INUMS is set. 269 * 270 * Inode allocation patterns are altered only if inode32 is requested 271 * (XFS_FEAT_SMALL_INUMS), and the filesystem is sufficiently large. 272 * If altered, XFS_OPSTATE_INODE32 is set as well. 273 * 274 * An agcount independent of that in the mount structure is provided 275 * because in the growfs case, mp->m_sb.sb_agcount is not yet updated 276 * to the potentially higher ag count. 277 * 278 * Returns the maximum AG index which may contain inodes. 279 */ 280 xfs_agnumber_t 281 xfs_set_inode_alloc( 282 struct xfs_mount *mp, 283 xfs_agnumber_t agcount) 284 { 285 xfs_agnumber_t index; 286 xfs_agnumber_t maxagi = 0; 287 xfs_sb_t *sbp = &mp->m_sb; 288 xfs_agnumber_t max_metadata; 289 xfs_agino_t agino; 290 xfs_ino_t ino; 291 292 /* 293 * Calculate how much should be reserved for inodes to meet 294 * the max inode percentage. Used only for inode32. 295 */ 296 if (M_IGEO(mp)->maxicount) { 297 uint64_t icount; 298 299 icount = sbp->sb_dblocks * sbp->sb_imax_pct; 300 do_div(icount, 100); 301 icount += sbp->sb_agblocks - 1; 302 do_div(icount, sbp->sb_agblocks); 303 max_metadata = icount; 304 } else { 305 max_metadata = agcount; 306 } 307 308 /* Get the last possible inode in the filesystem */ 309 agino = XFS_AGB_TO_AGINO(mp, sbp->sb_agblocks - 1); 310 ino = XFS_AGINO_TO_INO(mp, agcount - 1, agino); 311 312 /* 313 * If user asked for no more than 32-bit inodes, and the fs is 314 * sufficiently large, set XFS_OPSTATE_INODE32 if we must alter 315 * the allocator to accommodate the request. 316 */ 317 if (xfs_has_small_inums(mp) && ino > XFS_MAXINUMBER_32) 318 xfs_set_inode32(mp); 319 else 320 xfs_clear_inode32(mp); 321 322 for (index = 0; index < agcount; index++) { 323 struct xfs_perag *pag; 324 325 ino = XFS_AGINO_TO_INO(mp, index, agino); 326 327 pag = xfs_perag_get(mp, index); 328 if (xfs_set_inode_alloc_perag(pag, ino, max_metadata)) 329 maxagi++; 330 xfs_perag_put(pag); 331 } 332 333 return xfs_is_inode32(mp) ? maxagi : agcount; 334 } 335 336 static int 337 xfs_setup_dax_always( 338 struct xfs_mount *mp) 339 { 340 if (!mp->m_ddev_targp->bt_daxdev && 341 (!mp->m_rtdev_targp || !mp->m_rtdev_targp->bt_daxdev)) { 342 xfs_alert(mp, 343 "DAX unsupported by block device. Turning off DAX."); 344 goto disable_dax; 345 } 346 347 if (mp->m_super->s_blocksize != PAGE_SIZE) { 348 xfs_alert(mp, 349 "DAX not supported for blocksize. Turning off DAX."); 350 goto disable_dax; 351 } 352 353 if (xfs_has_reflink(mp) && 354 bdev_is_partition(mp->m_ddev_targp->bt_bdev)) { 355 xfs_alert(mp, 356 "DAX and reflink cannot work with multi-partitions!"); 357 return -EINVAL; 358 } 359 360 return 0; 361 362 disable_dax: 363 xfs_mount_set_dax_mode(mp, XFS_DAX_NEVER); 364 return 0; 365 } 366 367 STATIC int 368 xfs_blkdev_get( 369 xfs_mount_t *mp, 370 const char *name, 371 struct file **bdev_filep) 372 { 373 int error = 0; 374 375 *bdev_filep = bdev_file_open_by_path(name, 376 BLK_OPEN_READ | BLK_OPEN_WRITE | BLK_OPEN_RESTRICT_WRITES, 377 mp->m_super, &fs_holder_ops); 378 if (IS_ERR(*bdev_filep)) { 379 error = PTR_ERR(*bdev_filep); 380 *bdev_filep = NULL; 381 xfs_warn(mp, "Invalid device [%s], error=%d", name, error); 382 } 383 384 return error; 385 } 386 387 STATIC void 388 xfs_shutdown_devices( 389 struct xfs_mount *mp) 390 { 391 /* 392 * Udev is triggered whenever anyone closes a block device or unmounts 393 * a file systemm on a block device. 394 * The default udev rules invoke blkid to read the fs super and create 395 * symlinks to the bdev under /dev/disk. For this, it uses buffered 396 * reads through the page cache. 397 * 398 * xfs_db also uses buffered reads to examine metadata. There is no 399 * coordination between xfs_db and udev, which means that they can run 400 * concurrently. Note there is no coordination between the kernel and 401 * blkid either. 402 * 403 * On a system with 64k pages, the page cache can cache the superblock 404 * and the root inode (and hence the root directory) with the same 64k 405 * page. If udev spawns blkid after the mkfs and the system is busy 406 * enough that it is still running when xfs_db starts up, they'll both 407 * read from the same page in the pagecache. 408 * 409 * The unmount writes updated inode metadata to disk directly. The XFS 410 * buffer cache does not use the bdev pagecache, so it needs to 411 * invalidate that pagecache on unmount. If the above scenario occurs, 412 * the pagecache no longer reflects what's on disk, xfs_db reads the 413 * stale metadata, and fails to find /a. Most of the time this succeeds 414 * because closing a bdev invalidates the page cache, but when processes 415 * race, everyone loses. 416 */ 417 if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp) { 418 blkdev_issue_flush(mp->m_logdev_targp->bt_bdev); 419 invalidate_bdev(mp->m_logdev_targp->bt_bdev); 420 } 421 if (mp->m_rtdev_targp) { 422 blkdev_issue_flush(mp->m_rtdev_targp->bt_bdev); 423 invalidate_bdev(mp->m_rtdev_targp->bt_bdev); 424 } 425 blkdev_issue_flush(mp->m_ddev_targp->bt_bdev); 426 invalidate_bdev(mp->m_ddev_targp->bt_bdev); 427 } 428 429 /* 430 * The file system configurations are: 431 * (1) device (partition) with data and internal log 432 * (2) logical volume with data and log subvolumes. 433 * (3) logical volume with data, log, and realtime subvolumes. 434 * 435 * We only have to handle opening the log and realtime volumes here if 436 * they are present. The data subvolume has already been opened by 437 * get_sb_bdev() and is stored in sb->s_bdev. 438 */ 439 STATIC int 440 xfs_open_devices( 441 struct xfs_mount *mp) 442 { 443 struct super_block *sb = mp->m_super; 444 struct block_device *ddev = sb->s_bdev; 445 struct file *logdev_file = NULL, *rtdev_file = NULL; 446 int error; 447 448 /* 449 * Open real time and log devices - order is important. 450 */ 451 if (mp->m_logname) { 452 error = xfs_blkdev_get(mp, mp->m_logname, &logdev_file); 453 if (error) 454 return error; 455 } 456 457 if (mp->m_rtname) { 458 error = xfs_blkdev_get(mp, mp->m_rtname, &rtdev_file); 459 if (error) 460 goto out_close_logdev; 461 462 if (file_bdev(rtdev_file) == ddev || 463 (logdev_file && 464 file_bdev(rtdev_file) == file_bdev(logdev_file))) { 465 xfs_warn(mp, 466 "Cannot mount filesystem with identical rtdev and ddev/logdev."); 467 error = -EINVAL; 468 goto out_close_rtdev; 469 } 470 } 471 472 /* 473 * Setup xfs_mount buffer target pointers 474 */ 475 error = -ENOMEM; 476 mp->m_ddev_targp = xfs_alloc_buftarg(mp, sb->s_bdev_file); 477 if (!mp->m_ddev_targp) 478 goto out_close_rtdev; 479 480 if (rtdev_file) { 481 mp->m_rtdev_targp = xfs_alloc_buftarg(mp, rtdev_file); 482 if (!mp->m_rtdev_targp) 483 goto out_free_ddev_targ; 484 } 485 486 if (logdev_file && file_bdev(logdev_file) != ddev) { 487 mp->m_logdev_targp = xfs_alloc_buftarg(mp, logdev_file); 488 if (!mp->m_logdev_targp) 489 goto out_free_rtdev_targ; 490 } else { 491 mp->m_logdev_targp = mp->m_ddev_targp; 492 /* Handle won't be used, drop it */ 493 if (logdev_file) 494 bdev_fput(logdev_file); 495 } 496 497 return 0; 498 499 out_free_rtdev_targ: 500 if (mp->m_rtdev_targp) 501 xfs_free_buftarg(mp->m_rtdev_targp); 502 out_free_ddev_targ: 503 xfs_free_buftarg(mp->m_ddev_targp); 504 out_close_rtdev: 505 if (rtdev_file) 506 bdev_fput(rtdev_file); 507 out_close_logdev: 508 if (logdev_file) 509 bdev_fput(logdev_file); 510 return error; 511 } 512 513 /* 514 * Setup xfs_mount buffer target pointers based on superblock 515 */ 516 STATIC int 517 xfs_setup_devices( 518 struct xfs_mount *mp) 519 { 520 int error; 521 522 error = xfs_setsize_buftarg(mp->m_ddev_targp, mp->m_sb.sb_sectsize); 523 if (error) 524 return error; 525 526 if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp) { 527 unsigned int log_sector_size = BBSIZE; 528 529 if (xfs_has_sector(mp)) 530 log_sector_size = mp->m_sb.sb_logsectsize; 531 error = xfs_setsize_buftarg(mp->m_logdev_targp, 532 log_sector_size); 533 if (error) 534 return error; 535 } 536 if (mp->m_rtdev_targp) { 537 error = xfs_setsize_buftarg(mp->m_rtdev_targp, 538 mp->m_sb.sb_sectsize); 539 if (error) 540 return error; 541 } 542 543 return 0; 544 } 545 546 STATIC int 547 xfs_init_mount_workqueues( 548 struct xfs_mount *mp) 549 { 550 mp->m_buf_workqueue = alloc_workqueue("xfs-buf/%s", 551 XFS_WQFLAGS(WQ_FREEZABLE | WQ_MEM_RECLAIM), 552 1, mp->m_super->s_id); 553 if (!mp->m_buf_workqueue) 554 goto out; 555 556 mp->m_unwritten_workqueue = alloc_workqueue("xfs-conv/%s", 557 XFS_WQFLAGS(WQ_FREEZABLE | WQ_MEM_RECLAIM), 558 0, mp->m_super->s_id); 559 if (!mp->m_unwritten_workqueue) 560 goto out_destroy_buf; 561 562 mp->m_reclaim_workqueue = alloc_workqueue("xfs-reclaim/%s", 563 XFS_WQFLAGS(WQ_FREEZABLE | WQ_MEM_RECLAIM), 564 0, mp->m_super->s_id); 565 if (!mp->m_reclaim_workqueue) 566 goto out_destroy_unwritten; 567 568 mp->m_blockgc_wq = alloc_workqueue("xfs-blockgc/%s", 569 XFS_WQFLAGS(WQ_UNBOUND | WQ_FREEZABLE | WQ_MEM_RECLAIM), 570 0, mp->m_super->s_id); 571 if (!mp->m_blockgc_wq) 572 goto out_destroy_reclaim; 573 574 mp->m_inodegc_wq = alloc_workqueue("xfs-inodegc/%s", 575 XFS_WQFLAGS(WQ_FREEZABLE | WQ_MEM_RECLAIM), 576 1, mp->m_super->s_id); 577 if (!mp->m_inodegc_wq) 578 goto out_destroy_blockgc; 579 580 mp->m_sync_workqueue = alloc_workqueue("xfs-sync/%s", 581 XFS_WQFLAGS(WQ_FREEZABLE), 0, mp->m_super->s_id); 582 if (!mp->m_sync_workqueue) 583 goto out_destroy_inodegc; 584 585 return 0; 586 587 out_destroy_inodegc: 588 destroy_workqueue(mp->m_inodegc_wq); 589 out_destroy_blockgc: 590 destroy_workqueue(mp->m_blockgc_wq); 591 out_destroy_reclaim: 592 destroy_workqueue(mp->m_reclaim_workqueue); 593 out_destroy_unwritten: 594 destroy_workqueue(mp->m_unwritten_workqueue); 595 out_destroy_buf: 596 destroy_workqueue(mp->m_buf_workqueue); 597 out: 598 return -ENOMEM; 599 } 600 601 STATIC void 602 xfs_destroy_mount_workqueues( 603 struct xfs_mount *mp) 604 { 605 destroy_workqueue(mp->m_sync_workqueue); 606 destroy_workqueue(mp->m_blockgc_wq); 607 destroy_workqueue(mp->m_inodegc_wq); 608 destroy_workqueue(mp->m_reclaim_workqueue); 609 destroy_workqueue(mp->m_unwritten_workqueue); 610 destroy_workqueue(mp->m_buf_workqueue); 611 } 612 613 static void 614 xfs_flush_inodes_worker( 615 struct work_struct *work) 616 { 617 struct xfs_mount *mp = container_of(work, struct xfs_mount, 618 m_flush_inodes_work); 619 struct super_block *sb = mp->m_super; 620 621 if (down_read_trylock(&sb->s_umount)) { 622 sync_inodes_sb(sb); 623 up_read(&sb->s_umount); 624 } 625 } 626 627 /* 628 * Flush all dirty data to disk. Must not be called while holding an XFS_ILOCK 629 * or a page lock. We use sync_inodes_sb() here to ensure we block while waiting 630 * for IO to complete so that we effectively throttle multiple callers to the 631 * rate at which IO is completing. 632 */ 633 void 634 xfs_flush_inodes( 635 struct xfs_mount *mp) 636 { 637 /* 638 * If flush_work() returns true then that means we waited for a flush 639 * which was already in progress. Don't bother running another scan. 640 */ 641 if (flush_work(&mp->m_flush_inodes_work)) 642 return; 643 644 queue_work(mp->m_sync_workqueue, &mp->m_flush_inodes_work); 645 flush_work(&mp->m_flush_inodes_work); 646 } 647 648 /* Catch misguided souls that try to use this interface on XFS */ 649 STATIC struct inode * 650 xfs_fs_alloc_inode( 651 struct super_block *sb) 652 { 653 BUG(); 654 return NULL; 655 } 656 657 /* 658 * Now that the generic code is guaranteed not to be accessing 659 * the linux inode, we can inactivate and reclaim the inode. 660 */ 661 STATIC void 662 xfs_fs_destroy_inode( 663 struct inode *inode) 664 { 665 struct xfs_inode *ip = XFS_I(inode); 666 667 trace_xfs_destroy_inode(ip); 668 669 ASSERT(!rwsem_is_locked(&inode->i_rwsem)); 670 XFS_STATS_INC(ip->i_mount, vn_rele); 671 XFS_STATS_INC(ip->i_mount, vn_remove); 672 xfs_inode_mark_reclaimable(ip); 673 } 674 675 static void 676 xfs_fs_dirty_inode( 677 struct inode *inode, 678 int flags) 679 { 680 struct xfs_inode *ip = XFS_I(inode); 681 struct xfs_mount *mp = ip->i_mount; 682 struct xfs_trans *tp; 683 684 if (!(inode->i_sb->s_flags & SB_LAZYTIME)) 685 return; 686 687 /* 688 * Only do the timestamp update if the inode is dirty (I_DIRTY_SYNC) 689 * and has dirty timestamp (I_DIRTY_TIME). I_DIRTY_TIME can be passed 690 * in flags possibly together with I_DIRTY_SYNC. 691 */ 692 if ((flags & ~I_DIRTY_TIME) != I_DIRTY_SYNC || !(flags & I_DIRTY_TIME)) 693 return; 694 695 if (xfs_trans_alloc(mp, &M_RES(mp)->tr_fsyncts, 0, 0, 0, &tp)) 696 return; 697 xfs_ilock(ip, XFS_ILOCK_EXCL); 698 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL); 699 xfs_trans_log_inode(tp, ip, XFS_ILOG_TIMESTAMP); 700 xfs_trans_commit(tp); 701 } 702 703 /* 704 * Slab object creation initialisation for the XFS inode. 705 * This covers only the idempotent fields in the XFS inode; 706 * all other fields need to be initialised on allocation 707 * from the slab. This avoids the need to repeatedly initialise 708 * fields in the xfs inode that left in the initialise state 709 * when freeing the inode. 710 */ 711 STATIC void 712 xfs_fs_inode_init_once( 713 void *inode) 714 { 715 struct xfs_inode *ip = inode; 716 717 memset(ip, 0, sizeof(struct xfs_inode)); 718 719 /* vfs inode */ 720 inode_init_once(VFS_I(ip)); 721 722 /* xfs inode */ 723 atomic_set(&ip->i_pincount, 0); 724 spin_lock_init(&ip->i_flags_lock); 725 init_rwsem(&ip->i_lock); 726 } 727 728 /* 729 * We do an unlocked check for XFS_IDONTCACHE here because we are already 730 * serialised against cache hits here via the inode->i_lock and igrab() in 731 * xfs_iget_cache_hit(). Hence a lookup that might clear this flag will not be 732 * racing with us, and it avoids needing to grab a spinlock here for every inode 733 * we drop the final reference on. 734 */ 735 STATIC int 736 xfs_fs_drop_inode( 737 struct inode *inode) 738 { 739 struct xfs_inode *ip = XFS_I(inode); 740 741 /* 742 * If this unlinked inode is in the middle of recovery, don't 743 * drop the inode just yet; log recovery will take care of 744 * that. See the comment for this inode flag. 745 */ 746 if (ip->i_flags & XFS_IRECOVERY) { 747 ASSERT(xlog_recovery_needed(ip->i_mount->m_log)); 748 return 0; 749 } 750 751 return generic_drop_inode(inode); 752 } 753 754 static void 755 xfs_mount_free( 756 struct xfs_mount *mp) 757 { 758 if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp) 759 xfs_free_buftarg(mp->m_logdev_targp); 760 if (mp->m_rtdev_targp) 761 xfs_free_buftarg(mp->m_rtdev_targp); 762 if (mp->m_ddev_targp) 763 xfs_free_buftarg(mp->m_ddev_targp); 764 765 debugfs_remove(mp->m_debugfs); 766 kfree(mp->m_rtname); 767 kfree(mp->m_logname); 768 kfree(mp); 769 } 770 771 STATIC int 772 xfs_fs_sync_fs( 773 struct super_block *sb, 774 int wait) 775 { 776 struct xfs_mount *mp = XFS_M(sb); 777 int error; 778 779 trace_xfs_fs_sync_fs(mp, __return_address); 780 781 /* 782 * Doing anything during the async pass would be counterproductive. 783 */ 784 if (!wait) 785 return 0; 786 787 error = xfs_log_force(mp, XFS_LOG_SYNC); 788 if (error) 789 return error; 790 791 if (laptop_mode) { 792 /* 793 * The disk must be active because we're syncing. 794 * We schedule log work now (now that the disk is 795 * active) instead of later (when it might not be). 796 */ 797 flush_delayed_work(&mp->m_log->l_work); 798 } 799 800 /* 801 * If we are called with page faults frozen out, it means we are about 802 * to freeze the transaction subsystem. Take the opportunity to shut 803 * down inodegc because once SB_FREEZE_FS is set it's too late to 804 * prevent inactivation races with freeze. The fs doesn't get called 805 * again by the freezing process until after SB_FREEZE_FS has been set, 806 * so it's now or never. Same logic applies to speculative allocation 807 * garbage collection. 808 * 809 * We don't care if this is a normal syncfs call that does this or 810 * freeze that does this - we can run this multiple times without issue 811 * and we won't race with a restart because a restart can only occur 812 * when the state is either SB_FREEZE_FS or SB_FREEZE_COMPLETE. 813 */ 814 if (sb->s_writers.frozen == SB_FREEZE_PAGEFAULT) { 815 xfs_inodegc_stop(mp); 816 xfs_blockgc_stop(mp); 817 } 818 819 return 0; 820 } 821 822 static xfs_extlen_t 823 xfs_internal_log_size( 824 struct xfs_mount *mp) 825 { 826 if (!mp->m_sb.sb_logstart) 827 return 0; 828 return mp->m_sb.sb_logblocks; 829 } 830 831 static void 832 xfs_statfs_data( 833 struct xfs_mount *mp, 834 struct kstatfs *st) 835 { 836 int64_t fdblocks = 837 percpu_counter_sum(&mp->m_fdblocks); 838 839 /* make sure st->f_bfree does not underflow */ 840 st->f_bfree = max(0LL, fdblocks - xfs_fdblocks_unavailable(mp)); 841 /* 842 * sb_dblocks can change during growfs, but nothing cares about reporting 843 * the old or new value during growfs. 844 */ 845 st->f_blocks = mp->m_sb.sb_dblocks - xfs_internal_log_size(mp); 846 } 847 848 /* 849 * When stat(v)fs is called on a file with the realtime bit set or a directory 850 * with the rtinherit bit, report freespace information for the RT device 851 * instead of the main data device. 852 */ 853 static void 854 xfs_statfs_rt( 855 struct xfs_mount *mp, 856 struct kstatfs *st) 857 { 858 st->f_bfree = xfs_rtbxlen_to_blen(mp, 859 percpu_counter_sum_positive(&mp->m_frextents)); 860 st->f_blocks = mp->m_sb.sb_rblocks; 861 } 862 863 static void 864 xfs_statfs_inodes( 865 struct xfs_mount *mp, 866 struct kstatfs *st) 867 { 868 uint64_t icount = percpu_counter_sum(&mp->m_icount); 869 uint64_t ifree = percpu_counter_sum(&mp->m_ifree); 870 uint64_t fakeinos = XFS_FSB_TO_INO(mp, st->f_bfree); 871 872 st->f_files = min(icount + fakeinos, (uint64_t)XFS_MAXINUMBER); 873 if (M_IGEO(mp)->maxicount) 874 st->f_files = min_t(typeof(st->f_files), st->f_files, 875 M_IGEO(mp)->maxicount); 876 877 /* If sb_icount overshot maxicount, report actual allocation */ 878 st->f_files = max_t(typeof(st->f_files), st->f_files, 879 mp->m_sb.sb_icount); 880 881 /* Make sure st->f_ffree does not underflow */ 882 st->f_ffree = max_t(int64_t, 0, st->f_files - (icount - ifree)); 883 } 884 885 STATIC int 886 xfs_fs_statfs( 887 struct dentry *dentry, 888 struct kstatfs *st) 889 { 890 struct xfs_mount *mp = XFS_M(dentry->d_sb); 891 struct xfs_inode *ip = XFS_I(d_inode(dentry)); 892 893 /* 894 * Expedite background inodegc but don't wait. We do not want to block 895 * here waiting hours for a billion extent file to be truncated. 896 */ 897 xfs_inodegc_push(mp); 898 899 st->f_type = XFS_SUPER_MAGIC; 900 st->f_namelen = MAXNAMELEN - 1; 901 st->f_bsize = mp->m_sb.sb_blocksize; 902 st->f_fsid = u64_to_fsid(huge_encode_dev(mp->m_ddev_targp->bt_dev)); 903 904 xfs_statfs_data(mp, st); 905 xfs_statfs_inodes(mp, st); 906 907 if (XFS_IS_REALTIME_MOUNT(mp) && 908 (ip->i_diflags & (XFS_DIFLAG_RTINHERIT | XFS_DIFLAG_REALTIME))) 909 xfs_statfs_rt(mp, st); 910 911 if ((ip->i_diflags & XFS_DIFLAG_PROJINHERIT) && 912 ((mp->m_qflags & (XFS_PQUOTA_ACCT|XFS_PQUOTA_ENFD))) == 913 (XFS_PQUOTA_ACCT|XFS_PQUOTA_ENFD)) 914 xfs_qm_statvfs(ip, st); 915 916 /* 917 * XFS does not distinguish between blocks available to privileged and 918 * unprivileged users. 919 */ 920 st->f_bavail = st->f_bfree; 921 return 0; 922 } 923 924 STATIC void 925 xfs_save_resvblks(struct xfs_mount *mp) 926 { 927 mp->m_resblks_save = mp->m_resblks; 928 xfs_reserve_blocks(mp, 0); 929 } 930 931 STATIC void 932 xfs_restore_resvblks(struct xfs_mount *mp) 933 { 934 uint64_t resblks; 935 936 if (mp->m_resblks_save) { 937 resblks = mp->m_resblks_save; 938 mp->m_resblks_save = 0; 939 } else 940 resblks = xfs_default_resblks(mp); 941 942 xfs_reserve_blocks(mp, resblks); 943 } 944 945 /* 946 * Second stage of a freeze. The data is already frozen so we only 947 * need to take care of the metadata. Once that's done sync the superblock 948 * to the log to dirty it in case of a crash while frozen. This ensures that we 949 * will recover the unlinked inode lists on the next mount. 950 */ 951 STATIC int 952 xfs_fs_freeze( 953 struct super_block *sb) 954 { 955 struct xfs_mount *mp = XFS_M(sb); 956 unsigned int flags; 957 int ret; 958 959 /* 960 * The filesystem is now frozen far enough that memory reclaim 961 * cannot safely operate on the filesystem. Hence we need to 962 * set a GFP_NOFS context here to avoid recursion deadlocks. 963 */ 964 flags = memalloc_nofs_save(); 965 xfs_save_resvblks(mp); 966 ret = xfs_log_quiesce(mp); 967 memalloc_nofs_restore(flags); 968 969 /* 970 * For read-write filesystems, we need to restart the inodegc on error 971 * because we stopped it at SB_FREEZE_PAGEFAULT level and a thaw is not 972 * going to be run to restart it now. We are at SB_FREEZE_FS level 973 * here, so we can restart safely without racing with a stop in 974 * xfs_fs_sync_fs(). 975 */ 976 if (ret && !xfs_is_readonly(mp)) { 977 xfs_blockgc_start(mp); 978 xfs_inodegc_start(mp); 979 } 980 981 return ret; 982 } 983 984 STATIC int 985 xfs_fs_unfreeze( 986 struct super_block *sb) 987 { 988 struct xfs_mount *mp = XFS_M(sb); 989 990 xfs_restore_resvblks(mp); 991 xfs_log_work_queue(mp); 992 993 /* 994 * Don't reactivate the inodegc worker on a readonly filesystem because 995 * inodes are sent directly to reclaim. Don't reactivate the blockgc 996 * worker because there are no speculative preallocations on a readonly 997 * filesystem. 998 */ 999 if (!xfs_is_readonly(mp)) { 1000 xfs_blockgc_start(mp); 1001 xfs_inodegc_start(mp); 1002 } 1003 1004 return 0; 1005 } 1006 1007 /* 1008 * This function fills in xfs_mount_t fields based on mount args. 1009 * Note: the superblock _has_ now been read in. 1010 */ 1011 STATIC int 1012 xfs_finish_flags( 1013 struct xfs_mount *mp) 1014 { 1015 /* Fail a mount where the logbuf is smaller than the log stripe */ 1016 if (xfs_has_logv2(mp)) { 1017 if (mp->m_logbsize <= 0 && 1018 mp->m_sb.sb_logsunit > XLOG_BIG_RECORD_BSIZE) { 1019 mp->m_logbsize = mp->m_sb.sb_logsunit; 1020 } else if (mp->m_logbsize > 0 && 1021 mp->m_logbsize < mp->m_sb.sb_logsunit) { 1022 xfs_warn(mp, 1023 "logbuf size must be greater than or equal to log stripe size"); 1024 return -EINVAL; 1025 } 1026 } else { 1027 /* Fail a mount if the logbuf is larger than 32K */ 1028 if (mp->m_logbsize > XLOG_BIG_RECORD_BSIZE) { 1029 xfs_warn(mp, 1030 "logbuf size for version 1 logs must be 16K or 32K"); 1031 return -EINVAL; 1032 } 1033 } 1034 1035 /* 1036 * V5 filesystems always use attr2 format for attributes. 1037 */ 1038 if (xfs_has_crc(mp) && xfs_has_noattr2(mp)) { 1039 xfs_warn(mp, "Cannot mount a V5 filesystem as noattr2. " 1040 "attr2 is always enabled for V5 filesystems."); 1041 return -EINVAL; 1042 } 1043 1044 /* 1045 * prohibit r/w mounts of read-only filesystems 1046 */ 1047 if ((mp->m_sb.sb_flags & XFS_SBF_READONLY) && !xfs_is_readonly(mp)) { 1048 xfs_warn(mp, 1049 "cannot mount a read-only filesystem as read-write"); 1050 return -EROFS; 1051 } 1052 1053 if ((mp->m_qflags & XFS_GQUOTA_ACCT) && 1054 (mp->m_qflags & XFS_PQUOTA_ACCT) && 1055 !xfs_has_pquotino(mp)) { 1056 xfs_warn(mp, 1057 "Super block does not support project and group quota together"); 1058 return -EINVAL; 1059 } 1060 1061 return 0; 1062 } 1063 1064 static int 1065 xfs_init_percpu_counters( 1066 struct xfs_mount *mp) 1067 { 1068 int error; 1069 1070 error = percpu_counter_init(&mp->m_icount, 0, GFP_KERNEL); 1071 if (error) 1072 return -ENOMEM; 1073 1074 error = percpu_counter_init(&mp->m_ifree, 0, GFP_KERNEL); 1075 if (error) 1076 goto free_icount; 1077 1078 error = percpu_counter_init(&mp->m_fdblocks, 0, GFP_KERNEL); 1079 if (error) 1080 goto free_ifree; 1081 1082 error = percpu_counter_init(&mp->m_delalloc_blks, 0, GFP_KERNEL); 1083 if (error) 1084 goto free_fdblocks; 1085 1086 error = percpu_counter_init(&mp->m_delalloc_rtextents, 0, GFP_KERNEL); 1087 if (error) 1088 goto free_delalloc; 1089 1090 error = percpu_counter_init(&mp->m_frextents, 0, GFP_KERNEL); 1091 if (error) 1092 goto free_delalloc_rt; 1093 1094 return 0; 1095 1096 free_delalloc_rt: 1097 percpu_counter_destroy(&mp->m_delalloc_rtextents); 1098 free_delalloc: 1099 percpu_counter_destroy(&mp->m_delalloc_blks); 1100 free_fdblocks: 1101 percpu_counter_destroy(&mp->m_fdblocks); 1102 free_ifree: 1103 percpu_counter_destroy(&mp->m_ifree); 1104 free_icount: 1105 percpu_counter_destroy(&mp->m_icount); 1106 return -ENOMEM; 1107 } 1108 1109 void 1110 xfs_reinit_percpu_counters( 1111 struct xfs_mount *mp) 1112 { 1113 percpu_counter_set(&mp->m_icount, mp->m_sb.sb_icount); 1114 percpu_counter_set(&mp->m_ifree, mp->m_sb.sb_ifree); 1115 percpu_counter_set(&mp->m_fdblocks, mp->m_sb.sb_fdblocks); 1116 percpu_counter_set(&mp->m_frextents, mp->m_sb.sb_frextents); 1117 } 1118 1119 static void 1120 xfs_destroy_percpu_counters( 1121 struct xfs_mount *mp) 1122 { 1123 percpu_counter_destroy(&mp->m_icount); 1124 percpu_counter_destroy(&mp->m_ifree); 1125 percpu_counter_destroy(&mp->m_fdblocks); 1126 ASSERT(xfs_is_shutdown(mp) || 1127 percpu_counter_sum(&mp->m_delalloc_rtextents) == 0); 1128 percpu_counter_destroy(&mp->m_delalloc_rtextents); 1129 ASSERT(xfs_is_shutdown(mp) || 1130 percpu_counter_sum(&mp->m_delalloc_blks) == 0); 1131 percpu_counter_destroy(&mp->m_delalloc_blks); 1132 percpu_counter_destroy(&mp->m_frextents); 1133 } 1134 1135 static int 1136 xfs_inodegc_init_percpu( 1137 struct xfs_mount *mp) 1138 { 1139 struct xfs_inodegc *gc; 1140 int cpu; 1141 1142 mp->m_inodegc = alloc_percpu(struct xfs_inodegc); 1143 if (!mp->m_inodegc) 1144 return -ENOMEM; 1145 1146 for_each_possible_cpu(cpu) { 1147 gc = per_cpu_ptr(mp->m_inodegc, cpu); 1148 gc->cpu = cpu; 1149 gc->mp = mp; 1150 init_llist_head(&gc->list); 1151 gc->items = 0; 1152 gc->error = 0; 1153 INIT_DELAYED_WORK(&gc->work, xfs_inodegc_worker); 1154 } 1155 return 0; 1156 } 1157 1158 static void 1159 xfs_inodegc_free_percpu( 1160 struct xfs_mount *mp) 1161 { 1162 if (!mp->m_inodegc) 1163 return; 1164 free_percpu(mp->m_inodegc); 1165 } 1166 1167 static void 1168 xfs_fs_put_super( 1169 struct super_block *sb) 1170 { 1171 struct xfs_mount *mp = XFS_M(sb); 1172 1173 xfs_notice(mp, "Unmounting Filesystem %pU", &mp->m_sb.sb_uuid); 1174 xfs_filestream_unmount(mp); 1175 xfs_unmountfs(mp); 1176 1177 xfs_rtmount_freesb(mp); 1178 xfs_freesb(mp); 1179 xchk_mount_stats_free(mp); 1180 free_percpu(mp->m_stats.xs_stats); 1181 xfs_inodegc_free_percpu(mp); 1182 xfs_destroy_percpu_counters(mp); 1183 xfs_destroy_mount_workqueues(mp); 1184 xfs_shutdown_devices(mp); 1185 } 1186 1187 static long 1188 xfs_fs_nr_cached_objects( 1189 struct super_block *sb, 1190 struct shrink_control *sc) 1191 { 1192 /* Paranoia: catch incorrect calls during mount setup or teardown */ 1193 if (WARN_ON_ONCE(!sb->s_fs_info)) 1194 return 0; 1195 return xfs_reclaim_inodes_count(XFS_M(sb)); 1196 } 1197 1198 static long 1199 xfs_fs_free_cached_objects( 1200 struct super_block *sb, 1201 struct shrink_control *sc) 1202 { 1203 return xfs_reclaim_inodes_nr(XFS_M(sb), sc->nr_to_scan); 1204 } 1205 1206 static void 1207 xfs_fs_shutdown( 1208 struct super_block *sb) 1209 { 1210 xfs_force_shutdown(XFS_M(sb), SHUTDOWN_DEVICE_REMOVED); 1211 } 1212 1213 static const struct super_operations xfs_super_operations = { 1214 .alloc_inode = xfs_fs_alloc_inode, 1215 .destroy_inode = xfs_fs_destroy_inode, 1216 .dirty_inode = xfs_fs_dirty_inode, 1217 .drop_inode = xfs_fs_drop_inode, 1218 .put_super = xfs_fs_put_super, 1219 .sync_fs = xfs_fs_sync_fs, 1220 .freeze_fs = xfs_fs_freeze, 1221 .unfreeze_fs = xfs_fs_unfreeze, 1222 .statfs = xfs_fs_statfs, 1223 .show_options = xfs_fs_show_options, 1224 .nr_cached_objects = xfs_fs_nr_cached_objects, 1225 .free_cached_objects = xfs_fs_free_cached_objects, 1226 .shutdown = xfs_fs_shutdown, 1227 }; 1228 1229 static int 1230 suffix_kstrtoint( 1231 const char *s, 1232 unsigned int base, 1233 int *res) 1234 { 1235 int last, shift_left_factor = 0, _res; 1236 char *value; 1237 int ret = 0; 1238 1239 value = kstrdup(s, GFP_KERNEL); 1240 if (!value) 1241 return -ENOMEM; 1242 1243 last = strlen(value) - 1; 1244 if (value[last] == 'K' || value[last] == 'k') { 1245 shift_left_factor = 10; 1246 value[last] = '\0'; 1247 } 1248 if (value[last] == 'M' || value[last] == 'm') { 1249 shift_left_factor = 20; 1250 value[last] = '\0'; 1251 } 1252 if (value[last] == 'G' || value[last] == 'g') { 1253 shift_left_factor = 30; 1254 value[last] = '\0'; 1255 } 1256 1257 if (kstrtoint(value, base, &_res)) 1258 ret = -EINVAL; 1259 kfree(value); 1260 *res = _res << shift_left_factor; 1261 return ret; 1262 } 1263 1264 static inline void 1265 xfs_fs_warn_deprecated( 1266 struct fs_context *fc, 1267 struct fs_parameter *param, 1268 uint64_t flag, 1269 bool value) 1270 { 1271 /* Don't print the warning if reconfiguring and current mount point 1272 * already had the flag set 1273 */ 1274 if ((fc->purpose & FS_CONTEXT_FOR_RECONFIGURE) && 1275 !!(XFS_M(fc->root->d_sb)->m_features & flag) == value) 1276 return; 1277 xfs_warn(fc->s_fs_info, "%s mount option is deprecated.", param->key); 1278 } 1279 1280 /* 1281 * Set mount state from a mount option. 1282 * 1283 * NOTE: mp->m_super is NULL here! 1284 */ 1285 static int 1286 xfs_fs_parse_param( 1287 struct fs_context *fc, 1288 struct fs_parameter *param) 1289 { 1290 struct xfs_mount *parsing_mp = fc->s_fs_info; 1291 struct fs_parse_result result; 1292 int size = 0; 1293 int opt; 1294 1295 BUILD_BUG_ON(XFS_QFLAGS_MNTOPTS & XFS_MOUNT_QUOTA_ALL); 1296 1297 opt = fs_parse(fc, xfs_fs_parameters, param, &result); 1298 if (opt < 0) 1299 return opt; 1300 1301 switch (opt) { 1302 case Opt_logbufs: 1303 parsing_mp->m_logbufs = result.uint_32; 1304 return 0; 1305 case Opt_logbsize: 1306 if (suffix_kstrtoint(param->string, 10, &parsing_mp->m_logbsize)) 1307 return -EINVAL; 1308 return 0; 1309 case Opt_logdev: 1310 kfree(parsing_mp->m_logname); 1311 parsing_mp->m_logname = kstrdup(param->string, GFP_KERNEL); 1312 if (!parsing_mp->m_logname) 1313 return -ENOMEM; 1314 return 0; 1315 case Opt_rtdev: 1316 kfree(parsing_mp->m_rtname); 1317 parsing_mp->m_rtname = kstrdup(param->string, GFP_KERNEL); 1318 if (!parsing_mp->m_rtname) 1319 return -ENOMEM; 1320 return 0; 1321 case Opt_allocsize: 1322 if (suffix_kstrtoint(param->string, 10, &size)) 1323 return -EINVAL; 1324 parsing_mp->m_allocsize_log = ffs(size) - 1; 1325 parsing_mp->m_features |= XFS_FEAT_ALLOCSIZE; 1326 return 0; 1327 case Opt_grpid: 1328 case Opt_bsdgroups: 1329 parsing_mp->m_features |= XFS_FEAT_GRPID; 1330 return 0; 1331 case Opt_nogrpid: 1332 case Opt_sysvgroups: 1333 parsing_mp->m_features &= ~XFS_FEAT_GRPID; 1334 return 0; 1335 case Opt_wsync: 1336 parsing_mp->m_features |= XFS_FEAT_WSYNC; 1337 return 0; 1338 case Opt_norecovery: 1339 parsing_mp->m_features |= XFS_FEAT_NORECOVERY; 1340 return 0; 1341 case Opt_noalign: 1342 parsing_mp->m_features |= XFS_FEAT_NOALIGN; 1343 return 0; 1344 case Opt_swalloc: 1345 parsing_mp->m_features |= XFS_FEAT_SWALLOC; 1346 return 0; 1347 case Opt_sunit: 1348 parsing_mp->m_dalign = result.uint_32; 1349 return 0; 1350 case Opt_swidth: 1351 parsing_mp->m_swidth = result.uint_32; 1352 return 0; 1353 case Opt_inode32: 1354 parsing_mp->m_features |= XFS_FEAT_SMALL_INUMS; 1355 return 0; 1356 case Opt_inode64: 1357 parsing_mp->m_features &= ~XFS_FEAT_SMALL_INUMS; 1358 return 0; 1359 case Opt_nouuid: 1360 parsing_mp->m_features |= XFS_FEAT_NOUUID; 1361 return 0; 1362 case Opt_largeio: 1363 parsing_mp->m_features |= XFS_FEAT_LARGE_IOSIZE; 1364 return 0; 1365 case Opt_nolargeio: 1366 parsing_mp->m_features &= ~XFS_FEAT_LARGE_IOSIZE; 1367 return 0; 1368 case Opt_filestreams: 1369 parsing_mp->m_features |= XFS_FEAT_FILESTREAMS; 1370 return 0; 1371 case Opt_noquota: 1372 parsing_mp->m_qflags &= ~XFS_ALL_QUOTA_ACCT; 1373 parsing_mp->m_qflags &= ~XFS_ALL_QUOTA_ENFD; 1374 parsing_mp->m_qflags |= XFS_QFLAGS_MNTOPTS; 1375 return 0; 1376 case Opt_quota: 1377 case Opt_uquota: 1378 case Opt_usrquota: 1379 parsing_mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ENFD); 1380 parsing_mp->m_qflags |= XFS_QFLAGS_MNTOPTS; 1381 return 0; 1382 case Opt_qnoenforce: 1383 case Opt_uqnoenforce: 1384 parsing_mp->m_qflags |= XFS_UQUOTA_ACCT; 1385 parsing_mp->m_qflags &= ~XFS_UQUOTA_ENFD; 1386 parsing_mp->m_qflags |= XFS_QFLAGS_MNTOPTS; 1387 return 0; 1388 case Opt_pquota: 1389 case Opt_prjquota: 1390 parsing_mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ENFD); 1391 parsing_mp->m_qflags |= XFS_QFLAGS_MNTOPTS; 1392 return 0; 1393 case Opt_pqnoenforce: 1394 parsing_mp->m_qflags |= XFS_PQUOTA_ACCT; 1395 parsing_mp->m_qflags &= ~XFS_PQUOTA_ENFD; 1396 parsing_mp->m_qflags |= XFS_QFLAGS_MNTOPTS; 1397 return 0; 1398 case Opt_gquota: 1399 case Opt_grpquota: 1400 parsing_mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ENFD); 1401 parsing_mp->m_qflags |= XFS_QFLAGS_MNTOPTS; 1402 return 0; 1403 case Opt_gqnoenforce: 1404 parsing_mp->m_qflags |= XFS_GQUOTA_ACCT; 1405 parsing_mp->m_qflags &= ~XFS_GQUOTA_ENFD; 1406 parsing_mp->m_qflags |= XFS_QFLAGS_MNTOPTS; 1407 return 0; 1408 case Opt_discard: 1409 parsing_mp->m_features |= XFS_FEAT_DISCARD; 1410 return 0; 1411 case Opt_nodiscard: 1412 parsing_mp->m_features &= ~XFS_FEAT_DISCARD; 1413 return 0; 1414 #ifdef CONFIG_FS_DAX 1415 case Opt_dax: 1416 xfs_mount_set_dax_mode(parsing_mp, XFS_DAX_ALWAYS); 1417 return 0; 1418 case Opt_dax_enum: 1419 xfs_mount_set_dax_mode(parsing_mp, result.uint_32); 1420 return 0; 1421 #endif 1422 /* Following mount options will be removed in September 2025 */ 1423 case Opt_ikeep: 1424 xfs_fs_warn_deprecated(fc, param, XFS_FEAT_IKEEP, true); 1425 parsing_mp->m_features |= XFS_FEAT_IKEEP; 1426 return 0; 1427 case Opt_noikeep: 1428 xfs_fs_warn_deprecated(fc, param, XFS_FEAT_IKEEP, false); 1429 parsing_mp->m_features &= ~XFS_FEAT_IKEEP; 1430 return 0; 1431 case Opt_attr2: 1432 xfs_fs_warn_deprecated(fc, param, XFS_FEAT_ATTR2, true); 1433 parsing_mp->m_features |= XFS_FEAT_ATTR2; 1434 return 0; 1435 case Opt_noattr2: 1436 xfs_fs_warn_deprecated(fc, param, XFS_FEAT_NOATTR2, true); 1437 parsing_mp->m_features |= XFS_FEAT_NOATTR2; 1438 return 0; 1439 default: 1440 xfs_warn(parsing_mp, "unknown mount option [%s].", param->key); 1441 return -EINVAL; 1442 } 1443 1444 return 0; 1445 } 1446 1447 static int 1448 xfs_fs_validate_params( 1449 struct xfs_mount *mp) 1450 { 1451 /* No recovery flag requires a read-only mount */ 1452 if (xfs_has_norecovery(mp) && !xfs_is_readonly(mp)) { 1453 xfs_warn(mp, "no-recovery mounts must be read-only."); 1454 return -EINVAL; 1455 } 1456 1457 /* 1458 * We have not read the superblock at this point, so only the attr2 1459 * mount option can set the attr2 feature by this stage. 1460 */ 1461 if (xfs_has_attr2(mp) && xfs_has_noattr2(mp)) { 1462 xfs_warn(mp, "attr2 and noattr2 cannot both be specified."); 1463 return -EINVAL; 1464 } 1465 1466 1467 if (xfs_has_noalign(mp) && (mp->m_dalign || mp->m_swidth)) { 1468 xfs_warn(mp, 1469 "sunit and swidth options incompatible with the noalign option"); 1470 return -EINVAL; 1471 } 1472 1473 if (!IS_ENABLED(CONFIG_XFS_QUOTA) && 1474 (mp->m_qflags & ~XFS_QFLAGS_MNTOPTS)) { 1475 xfs_warn(mp, "quota support not available in this kernel."); 1476 return -EINVAL; 1477 } 1478 1479 if ((mp->m_dalign && !mp->m_swidth) || 1480 (!mp->m_dalign && mp->m_swidth)) { 1481 xfs_warn(mp, "sunit and swidth must be specified together"); 1482 return -EINVAL; 1483 } 1484 1485 if (mp->m_dalign && (mp->m_swidth % mp->m_dalign != 0)) { 1486 xfs_warn(mp, 1487 "stripe width (%d) must be a multiple of the stripe unit (%d)", 1488 mp->m_swidth, mp->m_dalign); 1489 return -EINVAL; 1490 } 1491 1492 if (mp->m_logbufs != -1 && 1493 mp->m_logbufs != 0 && 1494 (mp->m_logbufs < XLOG_MIN_ICLOGS || 1495 mp->m_logbufs > XLOG_MAX_ICLOGS)) { 1496 xfs_warn(mp, "invalid logbufs value: %d [not %d-%d]", 1497 mp->m_logbufs, XLOG_MIN_ICLOGS, XLOG_MAX_ICLOGS); 1498 return -EINVAL; 1499 } 1500 1501 if (mp->m_logbsize != -1 && 1502 mp->m_logbsize != 0 && 1503 (mp->m_logbsize < XLOG_MIN_RECORD_BSIZE || 1504 mp->m_logbsize > XLOG_MAX_RECORD_BSIZE || 1505 !is_power_of_2(mp->m_logbsize))) { 1506 xfs_warn(mp, 1507 "invalid logbufsize: %d [not 16k,32k,64k,128k or 256k]", 1508 mp->m_logbsize); 1509 return -EINVAL; 1510 } 1511 1512 if (xfs_has_allocsize(mp) && 1513 (mp->m_allocsize_log > XFS_MAX_IO_LOG || 1514 mp->m_allocsize_log < XFS_MIN_IO_LOG)) { 1515 xfs_warn(mp, "invalid log iosize: %d [not %d-%d]", 1516 mp->m_allocsize_log, XFS_MIN_IO_LOG, XFS_MAX_IO_LOG); 1517 return -EINVAL; 1518 } 1519 1520 return 0; 1521 } 1522 1523 struct dentry * 1524 xfs_debugfs_mkdir( 1525 const char *name, 1526 struct dentry *parent) 1527 { 1528 struct dentry *child; 1529 1530 /* Apparently we're expected to ignore error returns?? */ 1531 child = debugfs_create_dir(name, parent); 1532 if (IS_ERR(child)) 1533 return NULL; 1534 1535 return child; 1536 } 1537 1538 static int 1539 xfs_fs_fill_super( 1540 struct super_block *sb, 1541 struct fs_context *fc) 1542 { 1543 struct xfs_mount *mp = sb->s_fs_info; 1544 struct inode *root; 1545 int flags = 0, error; 1546 1547 mp->m_super = sb; 1548 1549 /* 1550 * Copy VFS mount flags from the context now that all parameter parsing 1551 * is guaranteed to have been completed by either the old mount API or 1552 * the newer fsopen/fsconfig API. 1553 */ 1554 if (fc->sb_flags & SB_RDONLY) 1555 xfs_set_readonly(mp); 1556 if (fc->sb_flags & SB_DIRSYNC) 1557 mp->m_features |= XFS_FEAT_DIRSYNC; 1558 if (fc->sb_flags & SB_SYNCHRONOUS) 1559 mp->m_features |= XFS_FEAT_WSYNC; 1560 1561 error = xfs_fs_validate_params(mp); 1562 if (error) 1563 return error; 1564 1565 sb_min_blocksize(sb, BBSIZE); 1566 sb->s_xattr = xfs_xattr_handlers; 1567 sb->s_export_op = &xfs_export_operations; 1568 #ifdef CONFIG_XFS_QUOTA 1569 sb->s_qcop = &xfs_quotactl_operations; 1570 sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP | QTYPE_MASK_PRJ; 1571 #endif 1572 sb->s_op = &xfs_super_operations; 1573 1574 /* 1575 * Delay mount work if the debug hook is set. This is debug 1576 * instrumention to coordinate simulation of xfs mount failures with 1577 * VFS superblock operations 1578 */ 1579 if (xfs_globals.mount_delay) { 1580 xfs_notice(mp, "Delaying mount for %d seconds.", 1581 xfs_globals.mount_delay); 1582 msleep(xfs_globals.mount_delay * 1000); 1583 } 1584 1585 if (fc->sb_flags & SB_SILENT) 1586 flags |= XFS_MFSI_QUIET; 1587 1588 error = xfs_open_devices(mp); 1589 if (error) 1590 return error; 1591 1592 if (xfs_debugfs) { 1593 mp->m_debugfs = xfs_debugfs_mkdir(mp->m_super->s_id, 1594 xfs_debugfs); 1595 } else { 1596 mp->m_debugfs = NULL; 1597 } 1598 1599 error = xfs_init_mount_workqueues(mp); 1600 if (error) 1601 goto out_shutdown_devices; 1602 1603 error = xfs_init_percpu_counters(mp); 1604 if (error) 1605 goto out_destroy_workqueues; 1606 1607 error = xfs_inodegc_init_percpu(mp); 1608 if (error) 1609 goto out_destroy_counters; 1610 1611 /* Allocate stats memory before we do operations that might use it */ 1612 mp->m_stats.xs_stats = alloc_percpu(struct xfsstats); 1613 if (!mp->m_stats.xs_stats) { 1614 error = -ENOMEM; 1615 goto out_destroy_inodegc; 1616 } 1617 1618 error = xchk_mount_stats_alloc(mp); 1619 if (error) 1620 goto out_free_stats; 1621 1622 error = xfs_readsb(mp, flags); 1623 if (error) 1624 goto out_free_scrub_stats; 1625 1626 error = xfs_finish_flags(mp); 1627 if (error) 1628 goto out_free_sb; 1629 1630 error = xfs_setup_devices(mp); 1631 if (error) 1632 goto out_free_sb; 1633 1634 /* 1635 * V4 support is undergoing deprecation. 1636 * 1637 * Note: this has to use an open coded m_features check as xfs_has_crc 1638 * always returns false for !CONFIG_XFS_SUPPORT_V4. 1639 */ 1640 if (!(mp->m_features & XFS_FEAT_CRC)) { 1641 if (!IS_ENABLED(CONFIG_XFS_SUPPORT_V4)) { 1642 xfs_warn(mp, 1643 "Deprecated V4 format (crc=0) not supported by kernel."); 1644 error = -EINVAL; 1645 goto out_free_sb; 1646 } 1647 xfs_warn_once(mp, 1648 "Deprecated V4 format (crc=0) will not be supported after September 2030."); 1649 } 1650 1651 /* ASCII case insensitivity is undergoing deprecation. */ 1652 if (xfs_has_asciici(mp)) { 1653 #ifdef CONFIG_XFS_SUPPORT_ASCII_CI 1654 xfs_warn_once(mp, 1655 "Deprecated ASCII case-insensitivity feature (ascii-ci=1) will not be supported after September 2030."); 1656 #else 1657 xfs_warn(mp, 1658 "Deprecated ASCII case-insensitivity feature (ascii-ci=1) not supported by kernel."); 1659 error = -EINVAL; 1660 goto out_free_sb; 1661 #endif 1662 } 1663 1664 /* Filesystem claims it needs repair, so refuse the mount. */ 1665 if (xfs_has_needsrepair(mp)) { 1666 xfs_warn(mp, "Filesystem needs repair. Please run xfs_repair."); 1667 error = -EFSCORRUPTED; 1668 goto out_free_sb; 1669 } 1670 1671 /* 1672 * Don't touch the filesystem if a user tool thinks it owns the primary 1673 * superblock. mkfs doesn't clear the flag from secondary supers, so 1674 * we don't check them at all. 1675 */ 1676 if (mp->m_sb.sb_inprogress) { 1677 xfs_warn(mp, "Offline file system operation in progress!"); 1678 error = -EFSCORRUPTED; 1679 goto out_free_sb; 1680 } 1681 1682 if (mp->m_sb.sb_blocksize > PAGE_SIZE) { 1683 size_t max_folio_size = mapping_max_folio_size_supported(); 1684 1685 if (!xfs_has_crc(mp)) { 1686 xfs_warn(mp, 1687 "V4 Filesystem with blocksize %d bytes. Only pagesize (%ld) or less is supported.", 1688 mp->m_sb.sb_blocksize, PAGE_SIZE); 1689 error = -ENOSYS; 1690 goto out_free_sb; 1691 } 1692 1693 if (mp->m_sb.sb_blocksize > max_folio_size) { 1694 xfs_warn(mp, 1695 "block size (%u bytes) not supported; Only block size (%zu) or less is supported", 1696 mp->m_sb.sb_blocksize, max_folio_size); 1697 error = -ENOSYS; 1698 goto out_free_sb; 1699 } 1700 1701 xfs_warn_experimental(mp, XFS_EXPERIMENTAL_LBS); 1702 } 1703 1704 /* Ensure this filesystem fits in the page cache limits */ 1705 if (xfs_sb_validate_fsb_count(&mp->m_sb, mp->m_sb.sb_dblocks) || 1706 xfs_sb_validate_fsb_count(&mp->m_sb, mp->m_sb.sb_rblocks)) { 1707 xfs_warn(mp, 1708 "file system too large to be mounted on this system."); 1709 error = -EFBIG; 1710 goto out_free_sb; 1711 } 1712 1713 /* 1714 * XFS block mappings use 54 bits to store the logical block offset. 1715 * This should suffice to handle the maximum file size that the VFS 1716 * supports (currently 2^63 bytes on 64-bit and ULONG_MAX << PAGE_SHIFT 1717 * bytes on 32-bit), but as XFS and VFS have gotten the s_maxbytes 1718 * calculation wrong on 32-bit kernels in the past, we'll add a WARN_ON 1719 * to check this assertion. 1720 * 1721 * Avoid integer overflow by comparing the maximum bmbt offset to the 1722 * maximum pagecache offset in units of fs blocks. 1723 */ 1724 if (!xfs_verify_fileoff(mp, XFS_B_TO_FSBT(mp, MAX_LFS_FILESIZE))) { 1725 xfs_warn(mp, 1726 "MAX_LFS_FILESIZE block offset (%llu) exceeds extent map maximum (%llu)!", 1727 XFS_B_TO_FSBT(mp, MAX_LFS_FILESIZE), 1728 XFS_MAX_FILEOFF); 1729 error = -EINVAL; 1730 goto out_free_sb; 1731 } 1732 1733 error = xfs_rtmount_readsb(mp); 1734 if (error) 1735 goto out_free_sb; 1736 1737 error = xfs_filestream_mount(mp); 1738 if (error) 1739 goto out_free_rtsb; 1740 1741 /* 1742 * we must configure the block size in the superblock before we run the 1743 * full mount process as the mount process can lookup and cache inodes. 1744 */ 1745 sb->s_magic = XFS_SUPER_MAGIC; 1746 sb->s_blocksize = mp->m_sb.sb_blocksize; 1747 sb->s_blocksize_bits = ffs(sb->s_blocksize) - 1; 1748 sb->s_maxbytes = MAX_LFS_FILESIZE; 1749 sb->s_max_links = XFS_MAXLINK; 1750 sb->s_time_gran = 1; 1751 if (xfs_has_bigtime(mp)) { 1752 sb->s_time_min = xfs_bigtime_to_unix(XFS_BIGTIME_TIME_MIN); 1753 sb->s_time_max = xfs_bigtime_to_unix(XFS_BIGTIME_TIME_MAX); 1754 } else { 1755 sb->s_time_min = XFS_LEGACY_TIME_MIN; 1756 sb->s_time_max = XFS_LEGACY_TIME_MAX; 1757 } 1758 trace_xfs_inode_timestamp_range(mp, sb->s_time_min, sb->s_time_max); 1759 sb->s_iflags |= SB_I_CGROUPWB | SB_I_ALLOW_HSM; 1760 1761 set_posix_acl_flag(sb); 1762 1763 /* version 5 superblocks support inode version counters. */ 1764 if (xfs_has_crc(mp)) 1765 sb->s_flags |= SB_I_VERSION; 1766 1767 if (xfs_has_dax_always(mp)) { 1768 error = xfs_setup_dax_always(mp); 1769 if (error) 1770 goto out_filestream_unmount; 1771 } 1772 1773 if (xfs_has_discard(mp) && !bdev_max_discard_sectors(sb->s_bdev)) { 1774 xfs_warn(mp, 1775 "mounting with \"discard\" option, but the device does not support discard"); 1776 mp->m_features &= ~XFS_FEAT_DISCARD; 1777 } 1778 1779 if (xfs_has_metadir(mp)) 1780 xfs_warn_experimental(mp, XFS_EXPERIMENTAL_METADIR); 1781 1782 if (xfs_has_reflink(mp)) { 1783 if (xfs_has_realtime(mp) && 1784 !xfs_reflink_supports_rextsize(mp, mp->m_sb.sb_rextsize)) { 1785 xfs_alert(mp, 1786 "reflink not compatible with realtime extent size %u!", 1787 mp->m_sb.sb_rextsize); 1788 error = -EINVAL; 1789 goto out_filestream_unmount; 1790 } 1791 1792 if (xfs_globals.always_cow) { 1793 xfs_info(mp, "using DEBUG-only always_cow mode."); 1794 mp->m_always_cow = true; 1795 } 1796 } 1797 1798 1799 if (xfs_has_exchange_range(mp)) 1800 xfs_warn_experimental(mp, XFS_EXPERIMENTAL_EXCHRANGE); 1801 1802 if (xfs_has_parent(mp)) 1803 xfs_warn_experimental(mp, XFS_EXPERIMENTAL_PPTR); 1804 1805 /* 1806 * If no quota mount options were provided, maybe we'll try to pick 1807 * up the quota accounting and enforcement flags from the ondisk sb. 1808 */ 1809 if (!(mp->m_qflags & XFS_QFLAGS_MNTOPTS)) 1810 xfs_set_resuming_quotaon(mp); 1811 mp->m_qflags &= ~XFS_QFLAGS_MNTOPTS; 1812 1813 error = xfs_mountfs(mp); 1814 if (error) 1815 goto out_filestream_unmount; 1816 1817 root = igrab(VFS_I(mp->m_rootip)); 1818 if (!root) { 1819 error = -ENOENT; 1820 goto out_unmount; 1821 } 1822 sb->s_root = d_make_root(root); 1823 if (!sb->s_root) { 1824 error = -ENOMEM; 1825 goto out_unmount; 1826 } 1827 1828 return 0; 1829 1830 out_filestream_unmount: 1831 xfs_filestream_unmount(mp); 1832 out_free_rtsb: 1833 xfs_rtmount_freesb(mp); 1834 out_free_sb: 1835 xfs_freesb(mp); 1836 out_free_scrub_stats: 1837 xchk_mount_stats_free(mp); 1838 out_free_stats: 1839 free_percpu(mp->m_stats.xs_stats); 1840 out_destroy_inodegc: 1841 xfs_inodegc_free_percpu(mp); 1842 out_destroy_counters: 1843 xfs_destroy_percpu_counters(mp); 1844 out_destroy_workqueues: 1845 xfs_destroy_mount_workqueues(mp); 1846 out_shutdown_devices: 1847 xfs_shutdown_devices(mp); 1848 return error; 1849 1850 out_unmount: 1851 xfs_filestream_unmount(mp); 1852 xfs_unmountfs(mp); 1853 goto out_free_rtsb; 1854 } 1855 1856 static int 1857 xfs_fs_get_tree( 1858 struct fs_context *fc) 1859 { 1860 return get_tree_bdev(fc, xfs_fs_fill_super); 1861 } 1862 1863 static int 1864 xfs_remount_rw( 1865 struct xfs_mount *mp) 1866 { 1867 struct xfs_sb *sbp = &mp->m_sb; 1868 int error; 1869 1870 if (xfs_has_norecovery(mp)) { 1871 xfs_warn(mp, 1872 "ro->rw transition prohibited on norecovery mount"); 1873 return -EINVAL; 1874 } 1875 1876 if (xfs_sb_is_v5(sbp) && 1877 xfs_sb_has_ro_compat_feature(sbp, XFS_SB_FEAT_RO_COMPAT_UNKNOWN)) { 1878 xfs_warn(mp, 1879 "ro->rw transition prohibited on unknown (0x%x) ro-compat filesystem", 1880 (sbp->sb_features_ro_compat & 1881 XFS_SB_FEAT_RO_COMPAT_UNKNOWN)); 1882 return -EINVAL; 1883 } 1884 1885 xfs_clear_readonly(mp); 1886 1887 /* 1888 * If this is the first remount to writeable state we might have some 1889 * superblock changes to update. 1890 */ 1891 if (mp->m_update_sb) { 1892 error = xfs_sync_sb(mp, false); 1893 if (error) { 1894 xfs_warn(mp, "failed to write sb changes"); 1895 return error; 1896 } 1897 mp->m_update_sb = false; 1898 } 1899 1900 /* 1901 * Fill out the reserve pool if it is empty. Use the stashed value if 1902 * it is non-zero, otherwise go with the default. 1903 */ 1904 xfs_restore_resvblks(mp); 1905 xfs_log_work_queue(mp); 1906 xfs_blockgc_start(mp); 1907 1908 /* Create the per-AG metadata reservation pool .*/ 1909 error = xfs_fs_reserve_ag_blocks(mp); 1910 if (error && error != -ENOSPC) 1911 return error; 1912 1913 /* Re-enable the background inode inactivation worker. */ 1914 xfs_inodegc_start(mp); 1915 1916 return 0; 1917 } 1918 1919 static int 1920 xfs_remount_ro( 1921 struct xfs_mount *mp) 1922 { 1923 struct xfs_icwalk icw = { 1924 .icw_flags = XFS_ICWALK_FLAG_SYNC, 1925 }; 1926 int error; 1927 1928 /* Flush all the dirty data to disk. */ 1929 error = sync_filesystem(mp->m_super); 1930 if (error) 1931 return error; 1932 1933 /* 1934 * Cancel background eofb scanning so it cannot race with the final 1935 * log force+buftarg wait and deadlock the remount. 1936 */ 1937 xfs_blockgc_stop(mp); 1938 1939 /* 1940 * Clear out all remaining COW staging extents and speculative post-EOF 1941 * preallocations so that we don't leave inodes requiring inactivation 1942 * cleanups during reclaim on a read-only mount. We must process every 1943 * cached inode, so this requires a synchronous cache scan. 1944 */ 1945 error = xfs_blockgc_free_space(mp, &icw); 1946 if (error) { 1947 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE); 1948 return error; 1949 } 1950 1951 /* 1952 * Stop the inodegc background worker. xfs_fs_reconfigure already 1953 * flushed all pending inodegc work when it sync'd the filesystem. 1954 * The VFS holds s_umount, so we know that inodes cannot enter 1955 * xfs_fs_destroy_inode during a remount operation. In readonly mode 1956 * we send inodes straight to reclaim, so no inodes will be queued. 1957 */ 1958 xfs_inodegc_stop(mp); 1959 1960 /* Free the per-AG metadata reservation pool. */ 1961 xfs_fs_unreserve_ag_blocks(mp); 1962 1963 /* 1964 * Before we sync the metadata, we need to free up the reserve block 1965 * pool so that the used block count in the superblock on disk is 1966 * correct at the end of the remount. Stash the current* reserve pool 1967 * size so that if we get remounted rw, we can return it to the same 1968 * size. 1969 */ 1970 xfs_save_resvblks(mp); 1971 1972 xfs_log_clean(mp); 1973 xfs_set_readonly(mp); 1974 1975 return 0; 1976 } 1977 1978 /* 1979 * Logically we would return an error here to prevent users from believing 1980 * they might have changed mount options using remount which can't be changed. 1981 * 1982 * But unfortunately mount(8) adds all options from mtab and fstab to the mount 1983 * arguments in some cases so we can't blindly reject options, but have to 1984 * check for each specified option if it actually differs from the currently 1985 * set option and only reject it if that's the case. 1986 * 1987 * Until that is implemented we return success for every remount request, and 1988 * silently ignore all options that we can't actually change. 1989 */ 1990 static int 1991 xfs_fs_reconfigure( 1992 struct fs_context *fc) 1993 { 1994 struct xfs_mount *mp = XFS_M(fc->root->d_sb); 1995 struct xfs_mount *new_mp = fc->s_fs_info; 1996 int flags = fc->sb_flags; 1997 int error; 1998 1999 new_mp->m_qflags &= ~XFS_QFLAGS_MNTOPTS; 2000 2001 /* version 5 superblocks always support version counters. */ 2002 if (xfs_has_crc(mp)) 2003 fc->sb_flags |= SB_I_VERSION; 2004 2005 error = xfs_fs_validate_params(new_mp); 2006 if (error) 2007 return error; 2008 2009 /* inode32 -> inode64 */ 2010 if (xfs_has_small_inums(mp) && !xfs_has_small_inums(new_mp)) { 2011 mp->m_features &= ~XFS_FEAT_SMALL_INUMS; 2012 mp->m_maxagi = xfs_set_inode_alloc(mp, mp->m_sb.sb_agcount); 2013 } 2014 2015 /* inode64 -> inode32 */ 2016 if (!xfs_has_small_inums(mp) && xfs_has_small_inums(new_mp)) { 2017 mp->m_features |= XFS_FEAT_SMALL_INUMS; 2018 mp->m_maxagi = xfs_set_inode_alloc(mp, mp->m_sb.sb_agcount); 2019 } 2020 2021 /* ro -> rw */ 2022 if (xfs_is_readonly(mp) && !(flags & SB_RDONLY)) { 2023 error = xfs_remount_rw(mp); 2024 if (error) 2025 return error; 2026 } 2027 2028 /* rw -> ro */ 2029 if (!xfs_is_readonly(mp) && (flags & SB_RDONLY)) { 2030 error = xfs_remount_ro(mp); 2031 if (error) 2032 return error; 2033 } 2034 2035 return 0; 2036 } 2037 2038 static void 2039 xfs_fs_free( 2040 struct fs_context *fc) 2041 { 2042 struct xfs_mount *mp = fc->s_fs_info; 2043 2044 /* 2045 * mp is stored in the fs_context when it is initialized. 2046 * mp is transferred to the superblock on a successful mount, 2047 * but if an error occurs before the transfer we have to free 2048 * it here. 2049 */ 2050 if (mp) 2051 xfs_mount_free(mp); 2052 } 2053 2054 static const struct fs_context_operations xfs_context_ops = { 2055 .parse_param = xfs_fs_parse_param, 2056 .get_tree = xfs_fs_get_tree, 2057 .reconfigure = xfs_fs_reconfigure, 2058 .free = xfs_fs_free, 2059 }; 2060 2061 /* 2062 * WARNING: do not initialise any parameters in this function that depend on 2063 * mount option parsing having already been performed as this can be called from 2064 * fsopen() before any parameters have been set. 2065 */ 2066 static int 2067 xfs_init_fs_context( 2068 struct fs_context *fc) 2069 { 2070 struct xfs_mount *mp; 2071 int i; 2072 2073 mp = kzalloc(sizeof(struct xfs_mount), GFP_KERNEL | __GFP_NOFAIL); 2074 if (!mp) 2075 return -ENOMEM; 2076 2077 spin_lock_init(&mp->m_sb_lock); 2078 for (i = 0; i < XG_TYPE_MAX; i++) 2079 xa_init(&mp->m_groups[i].xa); 2080 mutex_init(&mp->m_growlock); 2081 INIT_WORK(&mp->m_flush_inodes_work, xfs_flush_inodes_worker); 2082 INIT_DELAYED_WORK(&mp->m_reclaim_work, xfs_reclaim_worker); 2083 mp->m_kobj.kobject.kset = xfs_kset; 2084 /* 2085 * We don't create the finobt per-ag space reservation until after log 2086 * recovery, so we must set this to true so that an ifree transaction 2087 * started during log recovery will not depend on space reservations 2088 * for finobt expansion. 2089 */ 2090 mp->m_finobt_nores = true; 2091 2092 /* 2093 * These can be overridden by the mount option parsing. 2094 */ 2095 mp->m_logbufs = -1; 2096 mp->m_logbsize = -1; 2097 mp->m_allocsize_log = 16; /* 64k */ 2098 2099 xfs_hooks_init(&mp->m_dir_update_hooks); 2100 2101 fc->s_fs_info = mp; 2102 fc->ops = &xfs_context_ops; 2103 2104 return 0; 2105 } 2106 2107 static void 2108 xfs_kill_sb( 2109 struct super_block *sb) 2110 { 2111 kill_block_super(sb); 2112 xfs_mount_free(XFS_M(sb)); 2113 } 2114 2115 static struct file_system_type xfs_fs_type = { 2116 .owner = THIS_MODULE, 2117 .name = "xfs", 2118 .init_fs_context = xfs_init_fs_context, 2119 .parameters = xfs_fs_parameters, 2120 .kill_sb = xfs_kill_sb, 2121 .fs_flags = FS_REQUIRES_DEV | FS_ALLOW_IDMAP | FS_MGTIME, 2122 }; 2123 MODULE_ALIAS_FS("xfs"); 2124 2125 STATIC int __init 2126 xfs_init_caches(void) 2127 { 2128 int error; 2129 2130 xfs_buf_cache = kmem_cache_create("xfs_buf", sizeof(struct xfs_buf), 0, 2131 SLAB_HWCACHE_ALIGN | 2132 SLAB_RECLAIM_ACCOUNT, 2133 NULL); 2134 if (!xfs_buf_cache) 2135 goto out; 2136 2137 xfs_log_ticket_cache = kmem_cache_create("xfs_log_ticket", 2138 sizeof(struct xlog_ticket), 2139 0, 0, NULL); 2140 if (!xfs_log_ticket_cache) 2141 goto out_destroy_buf_cache; 2142 2143 error = xfs_btree_init_cur_caches(); 2144 if (error) 2145 goto out_destroy_log_ticket_cache; 2146 2147 error = rcbagbt_init_cur_cache(); 2148 if (error) 2149 goto out_destroy_btree_cur_cache; 2150 2151 error = xfs_defer_init_item_caches(); 2152 if (error) 2153 goto out_destroy_rcbagbt_cur_cache; 2154 2155 xfs_da_state_cache = kmem_cache_create("xfs_da_state", 2156 sizeof(struct xfs_da_state), 2157 0, 0, NULL); 2158 if (!xfs_da_state_cache) 2159 goto out_destroy_defer_item_cache; 2160 2161 xfs_ifork_cache = kmem_cache_create("xfs_ifork", 2162 sizeof(struct xfs_ifork), 2163 0, 0, NULL); 2164 if (!xfs_ifork_cache) 2165 goto out_destroy_da_state_cache; 2166 2167 xfs_trans_cache = kmem_cache_create("xfs_trans", 2168 sizeof(struct xfs_trans), 2169 0, 0, NULL); 2170 if (!xfs_trans_cache) 2171 goto out_destroy_ifork_cache; 2172 2173 2174 /* 2175 * The size of the cache-allocated buf log item is the maximum 2176 * size possible under XFS. This wastes a little bit of memory, 2177 * but it is much faster. 2178 */ 2179 xfs_buf_item_cache = kmem_cache_create("xfs_buf_item", 2180 sizeof(struct xfs_buf_log_item), 2181 0, 0, NULL); 2182 if (!xfs_buf_item_cache) 2183 goto out_destroy_trans_cache; 2184 2185 xfs_efd_cache = kmem_cache_create("xfs_efd_item", 2186 xfs_efd_log_item_sizeof(XFS_EFD_MAX_FAST_EXTENTS), 2187 0, 0, NULL); 2188 if (!xfs_efd_cache) 2189 goto out_destroy_buf_item_cache; 2190 2191 xfs_efi_cache = kmem_cache_create("xfs_efi_item", 2192 xfs_efi_log_item_sizeof(XFS_EFI_MAX_FAST_EXTENTS), 2193 0, 0, NULL); 2194 if (!xfs_efi_cache) 2195 goto out_destroy_efd_cache; 2196 2197 xfs_inode_cache = kmem_cache_create("xfs_inode", 2198 sizeof(struct xfs_inode), 0, 2199 (SLAB_HWCACHE_ALIGN | 2200 SLAB_RECLAIM_ACCOUNT | 2201 SLAB_ACCOUNT), 2202 xfs_fs_inode_init_once); 2203 if (!xfs_inode_cache) 2204 goto out_destroy_efi_cache; 2205 2206 xfs_ili_cache = kmem_cache_create("xfs_ili", 2207 sizeof(struct xfs_inode_log_item), 0, 2208 SLAB_RECLAIM_ACCOUNT, 2209 NULL); 2210 if (!xfs_ili_cache) 2211 goto out_destroy_inode_cache; 2212 2213 xfs_icreate_cache = kmem_cache_create("xfs_icr", 2214 sizeof(struct xfs_icreate_item), 2215 0, 0, NULL); 2216 if (!xfs_icreate_cache) 2217 goto out_destroy_ili_cache; 2218 2219 xfs_rud_cache = kmem_cache_create("xfs_rud_item", 2220 sizeof(struct xfs_rud_log_item), 2221 0, 0, NULL); 2222 if (!xfs_rud_cache) 2223 goto out_destroy_icreate_cache; 2224 2225 xfs_rui_cache = kmem_cache_create("xfs_rui_item", 2226 xfs_rui_log_item_sizeof(XFS_RUI_MAX_FAST_EXTENTS), 2227 0, 0, NULL); 2228 if (!xfs_rui_cache) 2229 goto out_destroy_rud_cache; 2230 2231 xfs_cud_cache = kmem_cache_create("xfs_cud_item", 2232 sizeof(struct xfs_cud_log_item), 2233 0, 0, NULL); 2234 if (!xfs_cud_cache) 2235 goto out_destroy_rui_cache; 2236 2237 xfs_cui_cache = kmem_cache_create("xfs_cui_item", 2238 xfs_cui_log_item_sizeof(XFS_CUI_MAX_FAST_EXTENTS), 2239 0, 0, NULL); 2240 if (!xfs_cui_cache) 2241 goto out_destroy_cud_cache; 2242 2243 xfs_bud_cache = kmem_cache_create("xfs_bud_item", 2244 sizeof(struct xfs_bud_log_item), 2245 0, 0, NULL); 2246 if (!xfs_bud_cache) 2247 goto out_destroy_cui_cache; 2248 2249 xfs_bui_cache = kmem_cache_create("xfs_bui_item", 2250 xfs_bui_log_item_sizeof(XFS_BUI_MAX_FAST_EXTENTS), 2251 0, 0, NULL); 2252 if (!xfs_bui_cache) 2253 goto out_destroy_bud_cache; 2254 2255 xfs_attrd_cache = kmem_cache_create("xfs_attrd_item", 2256 sizeof(struct xfs_attrd_log_item), 2257 0, 0, NULL); 2258 if (!xfs_attrd_cache) 2259 goto out_destroy_bui_cache; 2260 2261 xfs_attri_cache = kmem_cache_create("xfs_attri_item", 2262 sizeof(struct xfs_attri_log_item), 2263 0, 0, NULL); 2264 if (!xfs_attri_cache) 2265 goto out_destroy_attrd_cache; 2266 2267 xfs_iunlink_cache = kmem_cache_create("xfs_iul_item", 2268 sizeof(struct xfs_iunlink_item), 2269 0, 0, NULL); 2270 if (!xfs_iunlink_cache) 2271 goto out_destroy_attri_cache; 2272 2273 xfs_xmd_cache = kmem_cache_create("xfs_xmd_item", 2274 sizeof(struct xfs_xmd_log_item), 2275 0, 0, NULL); 2276 if (!xfs_xmd_cache) 2277 goto out_destroy_iul_cache; 2278 2279 xfs_xmi_cache = kmem_cache_create("xfs_xmi_item", 2280 sizeof(struct xfs_xmi_log_item), 2281 0, 0, NULL); 2282 if (!xfs_xmi_cache) 2283 goto out_destroy_xmd_cache; 2284 2285 xfs_parent_args_cache = kmem_cache_create("xfs_parent_args", 2286 sizeof(struct xfs_parent_args), 2287 0, 0, NULL); 2288 if (!xfs_parent_args_cache) 2289 goto out_destroy_xmi_cache; 2290 2291 return 0; 2292 2293 out_destroy_xmi_cache: 2294 kmem_cache_destroy(xfs_xmi_cache); 2295 out_destroy_xmd_cache: 2296 kmem_cache_destroy(xfs_xmd_cache); 2297 out_destroy_iul_cache: 2298 kmem_cache_destroy(xfs_iunlink_cache); 2299 out_destroy_attri_cache: 2300 kmem_cache_destroy(xfs_attri_cache); 2301 out_destroy_attrd_cache: 2302 kmem_cache_destroy(xfs_attrd_cache); 2303 out_destroy_bui_cache: 2304 kmem_cache_destroy(xfs_bui_cache); 2305 out_destroy_bud_cache: 2306 kmem_cache_destroy(xfs_bud_cache); 2307 out_destroy_cui_cache: 2308 kmem_cache_destroy(xfs_cui_cache); 2309 out_destroy_cud_cache: 2310 kmem_cache_destroy(xfs_cud_cache); 2311 out_destroy_rui_cache: 2312 kmem_cache_destroy(xfs_rui_cache); 2313 out_destroy_rud_cache: 2314 kmem_cache_destroy(xfs_rud_cache); 2315 out_destroy_icreate_cache: 2316 kmem_cache_destroy(xfs_icreate_cache); 2317 out_destroy_ili_cache: 2318 kmem_cache_destroy(xfs_ili_cache); 2319 out_destroy_inode_cache: 2320 kmem_cache_destroy(xfs_inode_cache); 2321 out_destroy_efi_cache: 2322 kmem_cache_destroy(xfs_efi_cache); 2323 out_destroy_efd_cache: 2324 kmem_cache_destroy(xfs_efd_cache); 2325 out_destroy_buf_item_cache: 2326 kmem_cache_destroy(xfs_buf_item_cache); 2327 out_destroy_trans_cache: 2328 kmem_cache_destroy(xfs_trans_cache); 2329 out_destroy_ifork_cache: 2330 kmem_cache_destroy(xfs_ifork_cache); 2331 out_destroy_da_state_cache: 2332 kmem_cache_destroy(xfs_da_state_cache); 2333 out_destroy_defer_item_cache: 2334 xfs_defer_destroy_item_caches(); 2335 out_destroy_rcbagbt_cur_cache: 2336 rcbagbt_destroy_cur_cache(); 2337 out_destroy_btree_cur_cache: 2338 xfs_btree_destroy_cur_caches(); 2339 out_destroy_log_ticket_cache: 2340 kmem_cache_destroy(xfs_log_ticket_cache); 2341 out_destroy_buf_cache: 2342 kmem_cache_destroy(xfs_buf_cache); 2343 out: 2344 return -ENOMEM; 2345 } 2346 2347 STATIC void 2348 xfs_destroy_caches(void) 2349 { 2350 /* 2351 * Make sure all delayed rcu free are flushed before we 2352 * destroy caches. 2353 */ 2354 rcu_barrier(); 2355 kmem_cache_destroy(xfs_parent_args_cache); 2356 kmem_cache_destroy(xfs_xmd_cache); 2357 kmem_cache_destroy(xfs_xmi_cache); 2358 kmem_cache_destroy(xfs_iunlink_cache); 2359 kmem_cache_destroy(xfs_attri_cache); 2360 kmem_cache_destroy(xfs_attrd_cache); 2361 kmem_cache_destroy(xfs_bui_cache); 2362 kmem_cache_destroy(xfs_bud_cache); 2363 kmem_cache_destroy(xfs_cui_cache); 2364 kmem_cache_destroy(xfs_cud_cache); 2365 kmem_cache_destroy(xfs_rui_cache); 2366 kmem_cache_destroy(xfs_rud_cache); 2367 kmem_cache_destroy(xfs_icreate_cache); 2368 kmem_cache_destroy(xfs_ili_cache); 2369 kmem_cache_destroy(xfs_inode_cache); 2370 kmem_cache_destroy(xfs_efi_cache); 2371 kmem_cache_destroy(xfs_efd_cache); 2372 kmem_cache_destroy(xfs_buf_item_cache); 2373 kmem_cache_destroy(xfs_trans_cache); 2374 kmem_cache_destroy(xfs_ifork_cache); 2375 kmem_cache_destroy(xfs_da_state_cache); 2376 xfs_defer_destroy_item_caches(); 2377 rcbagbt_destroy_cur_cache(); 2378 xfs_btree_destroy_cur_caches(); 2379 kmem_cache_destroy(xfs_log_ticket_cache); 2380 kmem_cache_destroy(xfs_buf_cache); 2381 } 2382 2383 STATIC int __init 2384 xfs_init_workqueues(void) 2385 { 2386 /* 2387 * The allocation workqueue can be used in memory reclaim situations 2388 * (writepage path), and parallelism is only limited by the number of 2389 * AGs in all the filesystems mounted. Hence use the default large 2390 * max_active value for this workqueue. 2391 */ 2392 xfs_alloc_wq = alloc_workqueue("xfsalloc", 2393 XFS_WQFLAGS(WQ_MEM_RECLAIM | WQ_FREEZABLE), 0); 2394 if (!xfs_alloc_wq) 2395 return -ENOMEM; 2396 2397 xfs_discard_wq = alloc_workqueue("xfsdiscard", XFS_WQFLAGS(WQ_UNBOUND), 2398 0); 2399 if (!xfs_discard_wq) 2400 goto out_free_alloc_wq; 2401 2402 return 0; 2403 out_free_alloc_wq: 2404 destroy_workqueue(xfs_alloc_wq); 2405 return -ENOMEM; 2406 } 2407 2408 STATIC void 2409 xfs_destroy_workqueues(void) 2410 { 2411 destroy_workqueue(xfs_discard_wq); 2412 destroy_workqueue(xfs_alloc_wq); 2413 } 2414 2415 STATIC int __init 2416 init_xfs_fs(void) 2417 { 2418 int error; 2419 2420 xfs_check_ondisk_structs(); 2421 2422 error = xfs_dahash_test(); 2423 if (error) 2424 return error; 2425 2426 printk(KERN_INFO XFS_VERSION_STRING " with " 2427 XFS_BUILD_OPTIONS " enabled\n"); 2428 2429 xfs_dir_startup(); 2430 2431 error = xfs_init_caches(); 2432 if (error) 2433 goto out; 2434 2435 error = xfs_init_workqueues(); 2436 if (error) 2437 goto out_destroy_caches; 2438 2439 error = xfs_mru_cache_init(); 2440 if (error) 2441 goto out_destroy_wq; 2442 2443 error = xfs_init_procfs(); 2444 if (error) 2445 goto out_mru_cache_uninit; 2446 2447 error = xfs_sysctl_register(); 2448 if (error) 2449 goto out_cleanup_procfs; 2450 2451 xfs_debugfs = xfs_debugfs_mkdir("xfs", NULL); 2452 2453 xfs_kset = kset_create_and_add("xfs", NULL, fs_kobj); 2454 if (!xfs_kset) { 2455 error = -ENOMEM; 2456 goto out_debugfs_unregister; 2457 } 2458 2459 xfsstats.xs_kobj.kobject.kset = xfs_kset; 2460 2461 xfsstats.xs_stats = alloc_percpu(struct xfsstats); 2462 if (!xfsstats.xs_stats) { 2463 error = -ENOMEM; 2464 goto out_kset_unregister; 2465 } 2466 2467 error = xfs_sysfs_init(&xfsstats.xs_kobj, &xfs_stats_ktype, NULL, 2468 "stats"); 2469 if (error) 2470 goto out_free_stats; 2471 2472 error = xchk_global_stats_setup(xfs_debugfs); 2473 if (error) 2474 goto out_remove_stats_kobj; 2475 2476 #ifdef DEBUG 2477 xfs_dbg_kobj.kobject.kset = xfs_kset; 2478 error = xfs_sysfs_init(&xfs_dbg_kobj, &xfs_dbg_ktype, NULL, "debug"); 2479 if (error) 2480 goto out_remove_scrub_stats; 2481 #endif 2482 2483 error = xfs_qm_init(); 2484 if (error) 2485 goto out_remove_dbg_kobj; 2486 2487 error = register_filesystem(&xfs_fs_type); 2488 if (error) 2489 goto out_qm_exit; 2490 return 0; 2491 2492 out_qm_exit: 2493 xfs_qm_exit(); 2494 out_remove_dbg_kobj: 2495 #ifdef DEBUG 2496 xfs_sysfs_del(&xfs_dbg_kobj); 2497 out_remove_scrub_stats: 2498 #endif 2499 xchk_global_stats_teardown(); 2500 out_remove_stats_kobj: 2501 xfs_sysfs_del(&xfsstats.xs_kobj); 2502 out_free_stats: 2503 free_percpu(xfsstats.xs_stats); 2504 out_kset_unregister: 2505 kset_unregister(xfs_kset); 2506 out_debugfs_unregister: 2507 debugfs_remove(xfs_debugfs); 2508 xfs_sysctl_unregister(); 2509 out_cleanup_procfs: 2510 xfs_cleanup_procfs(); 2511 out_mru_cache_uninit: 2512 xfs_mru_cache_uninit(); 2513 out_destroy_wq: 2514 xfs_destroy_workqueues(); 2515 out_destroy_caches: 2516 xfs_destroy_caches(); 2517 out: 2518 return error; 2519 } 2520 2521 STATIC void __exit 2522 exit_xfs_fs(void) 2523 { 2524 xfs_qm_exit(); 2525 unregister_filesystem(&xfs_fs_type); 2526 #ifdef DEBUG 2527 xfs_sysfs_del(&xfs_dbg_kobj); 2528 #endif 2529 xchk_global_stats_teardown(); 2530 xfs_sysfs_del(&xfsstats.xs_kobj); 2531 free_percpu(xfsstats.xs_stats); 2532 kset_unregister(xfs_kset); 2533 debugfs_remove(xfs_debugfs); 2534 xfs_sysctl_unregister(); 2535 xfs_cleanup_procfs(); 2536 xfs_mru_cache_uninit(); 2537 xfs_destroy_workqueues(); 2538 xfs_destroy_caches(); 2539 xfs_uuid_table_free(); 2540 } 2541 2542 module_init(init_xfs_fs); 2543 module_exit(exit_xfs_fs); 2544 2545 MODULE_AUTHOR("Silicon Graphics, Inc."); 2546 MODULE_DESCRIPTION(XFS_VERSION_STRING " with " XFS_BUILD_OPTIONS " enabled"); 2547 MODULE_LICENSE("GPL"); 2548