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 41 #include <linux/magic.h> 42 #include <linux/fs_context.h> 43 #include <linux/fs_parser.h> 44 45 static const struct super_operations xfs_super_operations; 46 47 static struct kset *xfs_kset; /* top-level xfs sysfs dir */ 48 #ifdef DEBUG 49 static struct xfs_kobj xfs_dbg_kobj; /* global debug sysfs attrs */ 50 #endif 51 52 enum xfs_dax_mode { 53 XFS_DAX_INODE = 0, 54 XFS_DAX_ALWAYS = 1, 55 XFS_DAX_NEVER = 2, 56 }; 57 58 static void 59 xfs_mount_set_dax_mode( 60 struct xfs_mount *mp, 61 enum xfs_dax_mode mode) 62 { 63 switch (mode) { 64 case XFS_DAX_INODE: 65 mp->m_flags &= ~(XFS_MOUNT_DAX_ALWAYS | XFS_MOUNT_DAX_NEVER); 66 break; 67 case XFS_DAX_ALWAYS: 68 mp->m_flags |= XFS_MOUNT_DAX_ALWAYS; 69 mp->m_flags &= ~XFS_MOUNT_DAX_NEVER; 70 break; 71 case XFS_DAX_NEVER: 72 mp->m_flags |= XFS_MOUNT_DAX_NEVER; 73 mp->m_flags &= ~XFS_MOUNT_DAX_ALWAYS; 74 break; 75 } 76 } 77 78 static const struct constant_table dax_param_enums[] = { 79 {"inode", XFS_DAX_INODE }, 80 {"always", XFS_DAX_ALWAYS }, 81 {"never", XFS_DAX_NEVER }, 82 {} 83 }; 84 85 /* 86 * Table driven mount option parser. 87 */ 88 enum { 89 Opt_logbufs, Opt_logbsize, Opt_logdev, Opt_rtdev, 90 Opt_wsync, Opt_noalign, Opt_swalloc, Opt_sunit, Opt_swidth, Opt_nouuid, 91 Opt_grpid, Opt_nogrpid, Opt_bsdgroups, Opt_sysvgroups, 92 Opt_allocsize, Opt_norecovery, Opt_inode64, Opt_inode32, Opt_ikeep, 93 Opt_noikeep, Opt_largeio, Opt_nolargeio, Opt_attr2, Opt_noattr2, 94 Opt_filestreams, Opt_quota, Opt_noquota, Opt_usrquota, Opt_grpquota, 95 Opt_prjquota, Opt_uquota, Opt_gquota, Opt_pquota, 96 Opt_uqnoenforce, Opt_gqnoenforce, Opt_pqnoenforce, Opt_qnoenforce, 97 Opt_discard, Opt_nodiscard, Opt_dax, Opt_dax_enum, 98 }; 99 100 static const struct fs_parameter_spec xfs_fs_parameters[] = { 101 fsparam_u32("logbufs", Opt_logbufs), 102 fsparam_string("logbsize", Opt_logbsize), 103 fsparam_string("logdev", Opt_logdev), 104 fsparam_string("rtdev", Opt_rtdev), 105 fsparam_flag("wsync", Opt_wsync), 106 fsparam_flag("noalign", Opt_noalign), 107 fsparam_flag("swalloc", Opt_swalloc), 108 fsparam_u32("sunit", Opt_sunit), 109 fsparam_u32("swidth", Opt_swidth), 110 fsparam_flag("nouuid", Opt_nouuid), 111 fsparam_flag("grpid", Opt_grpid), 112 fsparam_flag("nogrpid", Opt_nogrpid), 113 fsparam_flag("bsdgroups", Opt_bsdgroups), 114 fsparam_flag("sysvgroups", Opt_sysvgroups), 115 fsparam_string("allocsize", Opt_allocsize), 116 fsparam_flag("norecovery", Opt_norecovery), 117 fsparam_flag("inode64", Opt_inode64), 118 fsparam_flag("inode32", Opt_inode32), 119 fsparam_flag("ikeep", Opt_ikeep), 120 fsparam_flag("noikeep", Opt_noikeep), 121 fsparam_flag("largeio", Opt_largeio), 122 fsparam_flag("nolargeio", Opt_nolargeio), 123 fsparam_flag("attr2", Opt_attr2), 124 fsparam_flag("noattr2", Opt_noattr2), 125 fsparam_flag("filestreams", Opt_filestreams), 126 fsparam_flag("quota", Opt_quota), 127 fsparam_flag("noquota", Opt_noquota), 128 fsparam_flag("usrquota", Opt_usrquota), 129 fsparam_flag("grpquota", Opt_grpquota), 130 fsparam_flag("prjquota", Opt_prjquota), 131 fsparam_flag("uquota", Opt_uquota), 132 fsparam_flag("gquota", Opt_gquota), 133 fsparam_flag("pquota", Opt_pquota), 134 fsparam_flag("uqnoenforce", Opt_uqnoenforce), 135 fsparam_flag("gqnoenforce", Opt_gqnoenforce), 136 fsparam_flag("pqnoenforce", Opt_pqnoenforce), 137 fsparam_flag("qnoenforce", Opt_qnoenforce), 138 fsparam_flag("discard", Opt_discard), 139 fsparam_flag("nodiscard", Opt_nodiscard), 140 fsparam_flag("dax", Opt_dax), 141 fsparam_enum("dax", Opt_dax_enum, dax_param_enums), 142 {} 143 }; 144 145 struct proc_xfs_info { 146 uint64_t flag; 147 char *str; 148 }; 149 150 static int 151 xfs_fs_show_options( 152 struct seq_file *m, 153 struct dentry *root) 154 { 155 static struct proc_xfs_info xfs_info_set[] = { 156 /* the few simple ones we can get from the mount struct */ 157 { XFS_MOUNT_IKEEP, ",ikeep" }, 158 { XFS_MOUNT_WSYNC, ",wsync" }, 159 { XFS_MOUNT_NOALIGN, ",noalign" }, 160 { XFS_MOUNT_SWALLOC, ",swalloc" }, 161 { XFS_MOUNT_NOUUID, ",nouuid" }, 162 { XFS_MOUNT_NORECOVERY, ",norecovery" }, 163 { XFS_MOUNT_ATTR2, ",attr2" }, 164 { XFS_MOUNT_FILESTREAMS, ",filestreams" }, 165 { XFS_MOUNT_GRPID, ",grpid" }, 166 { XFS_MOUNT_DISCARD, ",discard" }, 167 { XFS_MOUNT_LARGEIO, ",largeio" }, 168 { XFS_MOUNT_DAX_ALWAYS, ",dax=always" }, 169 { XFS_MOUNT_DAX_NEVER, ",dax=never" }, 170 { 0, NULL } 171 }; 172 struct xfs_mount *mp = XFS_M(root->d_sb); 173 struct proc_xfs_info *xfs_infop; 174 175 for (xfs_infop = xfs_info_set; xfs_infop->flag; xfs_infop++) { 176 if (mp->m_flags & xfs_infop->flag) 177 seq_puts(m, xfs_infop->str); 178 } 179 180 seq_printf(m, ",inode%d", 181 (mp->m_flags & XFS_MOUNT_SMALL_INUMS) ? 32 : 64); 182 183 if (mp->m_flags & XFS_MOUNT_ALLOCSIZE) 184 seq_printf(m, ",allocsize=%dk", 185 (1 << mp->m_allocsize_log) >> 10); 186 187 if (mp->m_logbufs > 0) 188 seq_printf(m, ",logbufs=%d", mp->m_logbufs); 189 if (mp->m_logbsize > 0) 190 seq_printf(m, ",logbsize=%dk", mp->m_logbsize >> 10); 191 192 if (mp->m_logname) 193 seq_show_option(m, "logdev", mp->m_logname); 194 if (mp->m_rtname) 195 seq_show_option(m, "rtdev", mp->m_rtname); 196 197 if (mp->m_dalign > 0) 198 seq_printf(m, ",sunit=%d", 199 (int)XFS_FSB_TO_BB(mp, mp->m_dalign)); 200 if (mp->m_swidth > 0) 201 seq_printf(m, ",swidth=%d", 202 (int)XFS_FSB_TO_BB(mp, mp->m_swidth)); 203 204 if (mp->m_qflags & XFS_UQUOTA_ACCT) { 205 if (mp->m_qflags & XFS_UQUOTA_ENFD) 206 seq_puts(m, ",usrquota"); 207 else 208 seq_puts(m, ",uqnoenforce"); 209 } 210 211 if (mp->m_qflags & XFS_PQUOTA_ACCT) { 212 if (mp->m_qflags & XFS_PQUOTA_ENFD) 213 seq_puts(m, ",prjquota"); 214 else 215 seq_puts(m, ",pqnoenforce"); 216 } 217 if (mp->m_qflags & XFS_GQUOTA_ACCT) { 218 if (mp->m_qflags & XFS_GQUOTA_ENFD) 219 seq_puts(m, ",grpquota"); 220 else 221 seq_puts(m, ",gqnoenforce"); 222 } 223 224 if (!(mp->m_qflags & XFS_ALL_QUOTA_ACCT)) 225 seq_puts(m, ",noquota"); 226 227 return 0; 228 } 229 230 /* 231 * Set parameters for inode allocation heuristics, taking into account 232 * filesystem size and inode32/inode64 mount options; i.e. specifically 233 * whether or not XFS_MOUNT_SMALL_INUMS is set. 234 * 235 * Inode allocation patterns are altered only if inode32 is requested 236 * (XFS_MOUNT_SMALL_INUMS), and the filesystem is sufficiently large. 237 * If altered, XFS_MOUNT_32BITINODES is set as well. 238 * 239 * An agcount independent of that in the mount structure is provided 240 * because in the growfs case, mp->m_sb.sb_agcount is not yet updated 241 * to the potentially higher ag count. 242 * 243 * Returns the maximum AG index which may contain inodes. 244 */ 245 xfs_agnumber_t 246 xfs_set_inode_alloc( 247 struct xfs_mount *mp, 248 xfs_agnumber_t agcount) 249 { 250 xfs_agnumber_t index; 251 xfs_agnumber_t maxagi = 0; 252 xfs_sb_t *sbp = &mp->m_sb; 253 xfs_agnumber_t max_metadata; 254 xfs_agino_t agino; 255 xfs_ino_t ino; 256 257 /* 258 * Calculate how much should be reserved for inodes to meet 259 * the max inode percentage. Used only for inode32. 260 */ 261 if (M_IGEO(mp)->maxicount) { 262 uint64_t icount; 263 264 icount = sbp->sb_dblocks * sbp->sb_imax_pct; 265 do_div(icount, 100); 266 icount += sbp->sb_agblocks - 1; 267 do_div(icount, sbp->sb_agblocks); 268 max_metadata = icount; 269 } else { 270 max_metadata = agcount; 271 } 272 273 /* Get the last possible inode in the filesystem */ 274 agino = XFS_AGB_TO_AGINO(mp, sbp->sb_agblocks - 1); 275 ino = XFS_AGINO_TO_INO(mp, agcount - 1, agino); 276 277 /* 278 * If user asked for no more than 32-bit inodes, and the fs is 279 * sufficiently large, set XFS_MOUNT_32BITINODES if we must alter 280 * the allocator to accommodate the request. 281 */ 282 if ((mp->m_flags & XFS_MOUNT_SMALL_INUMS) && ino > XFS_MAXINUMBER_32) 283 mp->m_flags |= XFS_MOUNT_32BITINODES; 284 else 285 mp->m_flags &= ~XFS_MOUNT_32BITINODES; 286 287 for (index = 0; index < agcount; index++) { 288 struct xfs_perag *pag; 289 290 ino = XFS_AGINO_TO_INO(mp, index, agino); 291 292 pag = xfs_perag_get(mp, index); 293 294 if (mp->m_flags & XFS_MOUNT_32BITINODES) { 295 if (ino > XFS_MAXINUMBER_32) { 296 pag->pagi_inodeok = 0; 297 pag->pagf_metadata = 0; 298 } else { 299 pag->pagi_inodeok = 1; 300 maxagi++; 301 if (index < max_metadata) 302 pag->pagf_metadata = 1; 303 else 304 pag->pagf_metadata = 0; 305 } 306 } else { 307 pag->pagi_inodeok = 1; 308 pag->pagf_metadata = 0; 309 } 310 311 xfs_perag_put(pag); 312 } 313 314 return (mp->m_flags & XFS_MOUNT_32BITINODES) ? maxagi : agcount; 315 } 316 317 STATIC int 318 xfs_blkdev_get( 319 xfs_mount_t *mp, 320 const char *name, 321 struct block_device **bdevp) 322 { 323 int error = 0; 324 325 *bdevp = blkdev_get_by_path(name, FMODE_READ|FMODE_WRITE|FMODE_EXCL, 326 mp); 327 if (IS_ERR(*bdevp)) { 328 error = PTR_ERR(*bdevp); 329 xfs_warn(mp, "Invalid device [%s], error=%d", name, error); 330 } 331 332 return error; 333 } 334 335 STATIC void 336 xfs_blkdev_put( 337 struct block_device *bdev) 338 { 339 if (bdev) 340 blkdev_put(bdev, FMODE_READ|FMODE_WRITE|FMODE_EXCL); 341 } 342 343 STATIC void 344 xfs_close_devices( 345 struct xfs_mount *mp) 346 { 347 struct dax_device *dax_ddev = mp->m_ddev_targp->bt_daxdev; 348 349 if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp) { 350 struct block_device *logdev = mp->m_logdev_targp->bt_bdev; 351 struct dax_device *dax_logdev = mp->m_logdev_targp->bt_daxdev; 352 353 xfs_free_buftarg(mp->m_logdev_targp); 354 xfs_blkdev_put(logdev); 355 fs_put_dax(dax_logdev); 356 } 357 if (mp->m_rtdev_targp) { 358 struct block_device *rtdev = mp->m_rtdev_targp->bt_bdev; 359 struct dax_device *dax_rtdev = mp->m_rtdev_targp->bt_daxdev; 360 361 xfs_free_buftarg(mp->m_rtdev_targp); 362 xfs_blkdev_put(rtdev); 363 fs_put_dax(dax_rtdev); 364 } 365 xfs_free_buftarg(mp->m_ddev_targp); 366 fs_put_dax(dax_ddev); 367 } 368 369 /* 370 * The file system configurations are: 371 * (1) device (partition) with data and internal log 372 * (2) logical volume with data and log subvolumes. 373 * (3) logical volume with data, log, and realtime subvolumes. 374 * 375 * We only have to handle opening the log and realtime volumes here if 376 * they are present. The data subvolume has already been opened by 377 * get_sb_bdev() and is stored in sb->s_bdev. 378 */ 379 STATIC int 380 xfs_open_devices( 381 struct xfs_mount *mp) 382 { 383 struct block_device *ddev = mp->m_super->s_bdev; 384 struct dax_device *dax_ddev = fs_dax_get_by_bdev(ddev); 385 struct dax_device *dax_logdev = NULL, *dax_rtdev = NULL; 386 struct block_device *logdev = NULL, *rtdev = NULL; 387 int error; 388 389 /* 390 * Open real time and log devices - order is important. 391 */ 392 if (mp->m_logname) { 393 error = xfs_blkdev_get(mp, mp->m_logname, &logdev); 394 if (error) 395 goto out; 396 dax_logdev = fs_dax_get_by_bdev(logdev); 397 } 398 399 if (mp->m_rtname) { 400 error = xfs_blkdev_get(mp, mp->m_rtname, &rtdev); 401 if (error) 402 goto out_close_logdev; 403 404 if (rtdev == ddev || rtdev == logdev) { 405 xfs_warn(mp, 406 "Cannot mount filesystem with identical rtdev and ddev/logdev."); 407 error = -EINVAL; 408 goto out_close_rtdev; 409 } 410 dax_rtdev = fs_dax_get_by_bdev(rtdev); 411 } 412 413 /* 414 * Setup xfs_mount buffer target pointers 415 */ 416 error = -ENOMEM; 417 mp->m_ddev_targp = xfs_alloc_buftarg(mp, ddev, dax_ddev); 418 if (!mp->m_ddev_targp) 419 goto out_close_rtdev; 420 421 if (rtdev) { 422 mp->m_rtdev_targp = xfs_alloc_buftarg(mp, rtdev, dax_rtdev); 423 if (!mp->m_rtdev_targp) 424 goto out_free_ddev_targ; 425 } 426 427 if (logdev && logdev != ddev) { 428 mp->m_logdev_targp = xfs_alloc_buftarg(mp, logdev, dax_logdev); 429 if (!mp->m_logdev_targp) 430 goto out_free_rtdev_targ; 431 } else { 432 mp->m_logdev_targp = mp->m_ddev_targp; 433 } 434 435 return 0; 436 437 out_free_rtdev_targ: 438 if (mp->m_rtdev_targp) 439 xfs_free_buftarg(mp->m_rtdev_targp); 440 out_free_ddev_targ: 441 xfs_free_buftarg(mp->m_ddev_targp); 442 out_close_rtdev: 443 xfs_blkdev_put(rtdev); 444 fs_put_dax(dax_rtdev); 445 out_close_logdev: 446 if (logdev && logdev != ddev) { 447 xfs_blkdev_put(logdev); 448 fs_put_dax(dax_logdev); 449 } 450 out: 451 fs_put_dax(dax_ddev); 452 return error; 453 } 454 455 /* 456 * Setup xfs_mount buffer target pointers based on superblock 457 */ 458 STATIC int 459 xfs_setup_devices( 460 struct xfs_mount *mp) 461 { 462 int error; 463 464 error = xfs_setsize_buftarg(mp->m_ddev_targp, mp->m_sb.sb_sectsize); 465 if (error) 466 return error; 467 468 if (mp->m_logdev_targp && mp->m_logdev_targp != mp->m_ddev_targp) { 469 unsigned int log_sector_size = BBSIZE; 470 471 if (xfs_sb_version_hassector(&mp->m_sb)) 472 log_sector_size = mp->m_sb.sb_logsectsize; 473 error = xfs_setsize_buftarg(mp->m_logdev_targp, 474 log_sector_size); 475 if (error) 476 return error; 477 } 478 if (mp->m_rtdev_targp) { 479 error = xfs_setsize_buftarg(mp->m_rtdev_targp, 480 mp->m_sb.sb_sectsize); 481 if (error) 482 return error; 483 } 484 485 return 0; 486 } 487 488 STATIC int 489 xfs_init_mount_workqueues( 490 struct xfs_mount *mp) 491 { 492 mp->m_buf_workqueue = alloc_workqueue("xfs-buf/%s", 493 XFS_WQFLAGS(WQ_FREEZABLE | WQ_MEM_RECLAIM), 494 1, mp->m_super->s_id); 495 if (!mp->m_buf_workqueue) 496 goto out; 497 498 mp->m_unwritten_workqueue = alloc_workqueue("xfs-conv/%s", 499 XFS_WQFLAGS(WQ_FREEZABLE | WQ_MEM_RECLAIM), 500 0, mp->m_super->s_id); 501 if (!mp->m_unwritten_workqueue) 502 goto out_destroy_buf; 503 504 mp->m_cil_workqueue = alloc_workqueue("xfs-cil/%s", 505 XFS_WQFLAGS(WQ_FREEZABLE | WQ_MEM_RECLAIM | WQ_UNBOUND), 506 0, mp->m_super->s_id); 507 if (!mp->m_cil_workqueue) 508 goto out_destroy_unwritten; 509 510 mp->m_reclaim_workqueue = alloc_workqueue("xfs-reclaim/%s", 511 XFS_WQFLAGS(WQ_FREEZABLE | WQ_MEM_RECLAIM), 512 0, mp->m_super->s_id); 513 if (!mp->m_reclaim_workqueue) 514 goto out_destroy_cil; 515 516 mp->m_gc_workqueue = alloc_workqueue("xfs-gc/%s", 517 WQ_SYSFS | WQ_UNBOUND | WQ_FREEZABLE | WQ_MEM_RECLAIM, 518 0, mp->m_super->s_id); 519 if (!mp->m_gc_workqueue) 520 goto out_destroy_reclaim; 521 522 mp->m_sync_workqueue = alloc_workqueue("xfs-sync/%s", 523 XFS_WQFLAGS(WQ_FREEZABLE), 0, mp->m_super->s_id); 524 if (!mp->m_sync_workqueue) 525 goto out_destroy_eofb; 526 527 return 0; 528 529 out_destroy_eofb: 530 destroy_workqueue(mp->m_gc_workqueue); 531 out_destroy_reclaim: 532 destroy_workqueue(mp->m_reclaim_workqueue); 533 out_destroy_cil: 534 destroy_workqueue(mp->m_cil_workqueue); 535 out_destroy_unwritten: 536 destroy_workqueue(mp->m_unwritten_workqueue); 537 out_destroy_buf: 538 destroy_workqueue(mp->m_buf_workqueue); 539 out: 540 return -ENOMEM; 541 } 542 543 STATIC void 544 xfs_destroy_mount_workqueues( 545 struct xfs_mount *mp) 546 { 547 destroy_workqueue(mp->m_sync_workqueue); 548 destroy_workqueue(mp->m_gc_workqueue); 549 destroy_workqueue(mp->m_reclaim_workqueue); 550 destroy_workqueue(mp->m_cil_workqueue); 551 destroy_workqueue(mp->m_unwritten_workqueue); 552 destroy_workqueue(mp->m_buf_workqueue); 553 } 554 555 static void 556 xfs_flush_inodes_worker( 557 struct work_struct *work) 558 { 559 struct xfs_mount *mp = container_of(work, struct xfs_mount, 560 m_flush_inodes_work); 561 struct super_block *sb = mp->m_super; 562 563 if (down_read_trylock(&sb->s_umount)) { 564 sync_inodes_sb(sb); 565 up_read(&sb->s_umount); 566 } 567 } 568 569 /* 570 * Flush all dirty data to disk. Must not be called while holding an XFS_ILOCK 571 * or a page lock. We use sync_inodes_sb() here to ensure we block while waiting 572 * for IO to complete so that we effectively throttle multiple callers to the 573 * rate at which IO is completing. 574 */ 575 void 576 xfs_flush_inodes( 577 struct xfs_mount *mp) 578 { 579 /* 580 * If flush_work() returns true then that means we waited for a flush 581 * which was already in progress. Don't bother running another scan. 582 */ 583 if (flush_work(&mp->m_flush_inodes_work)) 584 return; 585 586 queue_work(mp->m_sync_workqueue, &mp->m_flush_inodes_work); 587 flush_work(&mp->m_flush_inodes_work); 588 } 589 590 /* Catch misguided souls that try to use this interface on XFS */ 591 STATIC struct inode * 592 xfs_fs_alloc_inode( 593 struct super_block *sb) 594 { 595 BUG(); 596 return NULL; 597 } 598 599 #ifdef DEBUG 600 static void 601 xfs_check_delalloc( 602 struct xfs_inode *ip, 603 int whichfork) 604 { 605 struct xfs_ifork *ifp = XFS_IFORK_PTR(ip, whichfork); 606 struct xfs_bmbt_irec got; 607 struct xfs_iext_cursor icur; 608 609 if (!ifp || !xfs_iext_lookup_extent(ip, ifp, 0, &icur, &got)) 610 return; 611 do { 612 if (isnullstartblock(got.br_startblock)) { 613 xfs_warn(ip->i_mount, 614 "ino %llx %s fork has delalloc extent at [0x%llx:0x%llx]", 615 ip->i_ino, 616 whichfork == XFS_DATA_FORK ? "data" : "cow", 617 got.br_startoff, got.br_blockcount); 618 } 619 } while (xfs_iext_next_extent(ifp, &icur, &got)); 620 } 621 #else 622 #define xfs_check_delalloc(ip, whichfork) do { } while (0) 623 #endif 624 625 /* 626 * Now that the generic code is guaranteed not to be accessing 627 * the linux inode, we can inactivate and reclaim the inode. 628 */ 629 STATIC void 630 xfs_fs_destroy_inode( 631 struct inode *inode) 632 { 633 struct xfs_inode *ip = XFS_I(inode); 634 635 trace_xfs_destroy_inode(ip); 636 637 ASSERT(!rwsem_is_locked(&inode->i_rwsem)); 638 XFS_STATS_INC(ip->i_mount, vn_rele); 639 XFS_STATS_INC(ip->i_mount, vn_remove); 640 641 xfs_inactive(ip); 642 643 if (!XFS_FORCED_SHUTDOWN(ip->i_mount) && ip->i_delayed_blks) { 644 xfs_check_delalloc(ip, XFS_DATA_FORK); 645 xfs_check_delalloc(ip, XFS_COW_FORK); 646 ASSERT(0); 647 } 648 649 XFS_STATS_INC(ip->i_mount, vn_reclaim); 650 651 /* 652 * We should never get here with one of the reclaim flags already set. 653 */ 654 ASSERT_ALWAYS(!xfs_iflags_test(ip, XFS_IRECLAIMABLE)); 655 ASSERT_ALWAYS(!xfs_iflags_test(ip, XFS_IRECLAIM)); 656 657 /* 658 * We always use background reclaim here because even if the inode is 659 * clean, it still may be under IO and hence we have wait for IO 660 * completion to occur before we can reclaim the inode. The background 661 * reclaim path handles this more efficiently than we can here, so 662 * simply let background reclaim tear down all inodes. 663 */ 664 xfs_inode_mark_reclaimable(ip); 665 } 666 667 static void 668 xfs_fs_dirty_inode( 669 struct inode *inode, 670 int flag) 671 { 672 struct xfs_inode *ip = XFS_I(inode); 673 struct xfs_mount *mp = ip->i_mount; 674 struct xfs_trans *tp; 675 676 if (!(inode->i_sb->s_flags & SB_LAZYTIME)) 677 return; 678 if (flag != I_DIRTY_SYNC || !(inode->i_state & I_DIRTY_TIME)) 679 return; 680 681 if (xfs_trans_alloc(mp, &M_RES(mp)->tr_fsyncts, 0, 0, 0, &tp)) 682 return; 683 xfs_ilock(ip, XFS_ILOCK_EXCL); 684 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL); 685 xfs_trans_log_inode(tp, ip, XFS_ILOG_TIMESTAMP); 686 xfs_trans_commit(tp); 687 } 688 689 /* 690 * Slab object creation initialisation for the XFS inode. 691 * This covers only the idempotent fields in the XFS inode; 692 * all other fields need to be initialised on allocation 693 * from the slab. This avoids the need to repeatedly initialise 694 * fields in the xfs inode that left in the initialise state 695 * when freeing the inode. 696 */ 697 STATIC void 698 xfs_fs_inode_init_once( 699 void *inode) 700 { 701 struct xfs_inode *ip = inode; 702 703 memset(ip, 0, sizeof(struct xfs_inode)); 704 705 /* vfs inode */ 706 inode_init_once(VFS_I(ip)); 707 708 /* xfs inode */ 709 atomic_set(&ip->i_pincount, 0); 710 spin_lock_init(&ip->i_flags_lock); 711 712 mrlock_init(&ip->i_mmaplock, MRLOCK_ALLOW_EQUAL_PRI|MRLOCK_BARRIER, 713 "xfsino", ip->i_ino); 714 mrlock_init(&ip->i_lock, MRLOCK_ALLOW_EQUAL_PRI|MRLOCK_BARRIER, 715 "xfsino", ip->i_ino); 716 } 717 718 /* 719 * We do an unlocked check for XFS_IDONTCACHE here because we are already 720 * serialised against cache hits here via the inode->i_lock and igrab() in 721 * xfs_iget_cache_hit(). Hence a lookup that might clear this flag will not be 722 * racing with us, and it avoids needing to grab a spinlock here for every inode 723 * we drop the final reference on. 724 */ 725 STATIC int 726 xfs_fs_drop_inode( 727 struct inode *inode) 728 { 729 struct xfs_inode *ip = XFS_I(inode); 730 731 /* 732 * If this unlinked inode is in the middle of recovery, don't 733 * drop the inode just yet; log recovery will take care of 734 * that. See the comment for this inode flag. 735 */ 736 if (ip->i_flags & XFS_IRECOVERY) { 737 ASSERT(ip->i_mount->m_log->l_flags & XLOG_RECOVERY_NEEDED); 738 return 0; 739 } 740 741 return generic_drop_inode(inode); 742 } 743 744 static void 745 xfs_mount_free( 746 struct xfs_mount *mp) 747 { 748 kfree(mp->m_rtname); 749 kfree(mp->m_logname); 750 kmem_free(mp); 751 } 752 753 STATIC int 754 xfs_fs_sync_fs( 755 struct super_block *sb, 756 int wait) 757 { 758 struct xfs_mount *mp = XFS_M(sb); 759 760 /* 761 * Doing anything during the async pass would be counterproductive. 762 */ 763 if (!wait) 764 return 0; 765 766 xfs_log_force(mp, XFS_LOG_SYNC); 767 if (laptop_mode) { 768 /* 769 * The disk must be active because we're syncing. 770 * We schedule log work now (now that the disk is 771 * active) instead of later (when it might not be). 772 */ 773 flush_delayed_work(&mp->m_log->l_work); 774 } 775 776 return 0; 777 } 778 779 STATIC int 780 xfs_fs_statfs( 781 struct dentry *dentry, 782 struct kstatfs *statp) 783 { 784 struct xfs_mount *mp = XFS_M(dentry->d_sb); 785 xfs_sb_t *sbp = &mp->m_sb; 786 struct xfs_inode *ip = XFS_I(d_inode(dentry)); 787 uint64_t fakeinos, id; 788 uint64_t icount; 789 uint64_t ifree; 790 uint64_t fdblocks; 791 xfs_extlen_t lsize; 792 int64_t ffree; 793 794 statp->f_type = XFS_SUPER_MAGIC; 795 statp->f_namelen = MAXNAMELEN - 1; 796 797 id = huge_encode_dev(mp->m_ddev_targp->bt_dev); 798 statp->f_fsid = u64_to_fsid(id); 799 800 icount = percpu_counter_sum(&mp->m_icount); 801 ifree = percpu_counter_sum(&mp->m_ifree); 802 fdblocks = percpu_counter_sum(&mp->m_fdblocks); 803 804 spin_lock(&mp->m_sb_lock); 805 statp->f_bsize = sbp->sb_blocksize; 806 lsize = sbp->sb_logstart ? sbp->sb_logblocks : 0; 807 statp->f_blocks = sbp->sb_dblocks - lsize; 808 spin_unlock(&mp->m_sb_lock); 809 810 /* make sure statp->f_bfree does not underflow */ 811 statp->f_bfree = max_t(int64_t, fdblocks - mp->m_alloc_set_aside, 0); 812 statp->f_bavail = statp->f_bfree; 813 814 fakeinos = XFS_FSB_TO_INO(mp, statp->f_bfree); 815 statp->f_files = min(icount + fakeinos, (uint64_t)XFS_MAXINUMBER); 816 if (M_IGEO(mp)->maxicount) 817 statp->f_files = min_t(typeof(statp->f_files), 818 statp->f_files, 819 M_IGEO(mp)->maxicount); 820 821 /* If sb_icount overshot maxicount, report actual allocation */ 822 statp->f_files = max_t(typeof(statp->f_files), 823 statp->f_files, 824 sbp->sb_icount); 825 826 /* make sure statp->f_ffree does not underflow */ 827 ffree = statp->f_files - (icount - ifree); 828 statp->f_ffree = max_t(int64_t, ffree, 0); 829 830 831 if ((ip->i_diflags & XFS_DIFLAG_PROJINHERIT) && 832 ((mp->m_qflags & (XFS_PQUOTA_ACCT|XFS_PQUOTA_ENFD))) == 833 (XFS_PQUOTA_ACCT|XFS_PQUOTA_ENFD)) 834 xfs_qm_statvfs(ip, statp); 835 836 if (XFS_IS_REALTIME_MOUNT(mp) && 837 (ip->i_diflags & (XFS_DIFLAG_RTINHERIT | XFS_DIFLAG_REALTIME))) { 838 statp->f_blocks = sbp->sb_rblocks; 839 statp->f_bavail = statp->f_bfree = 840 sbp->sb_frextents * sbp->sb_rextsize; 841 } 842 843 return 0; 844 } 845 846 STATIC void 847 xfs_save_resvblks(struct xfs_mount *mp) 848 { 849 uint64_t resblks = 0; 850 851 mp->m_resblks_save = mp->m_resblks; 852 xfs_reserve_blocks(mp, &resblks, NULL); 853 } 854 855 STATIC void 856 xfs_restore_resvblks(struct xfs_mount *mp) 857 { 858 uint64_t resblks; 859 860 if (mp->m_resblks_save) { 861 resblks = mp->m_resblks_save; 862 mp->m_resblks_save = 0; 863 } else 864 resblks = xfs_default_resblks(mp); 865 866 xfs_reserve_blocks(mp, &resblks, NULL); 867 } 868 869 /* 870 * Second stage of a freeze. The data is already frozen so we only 871 * need to take care of the metadata. Once that's done sync the superblock 872 * to the log to dirty it in case of a crash while frozen. This ensures that we 873 * will recover the unlinked inode lists on the next mount. 874 */ 875 STATIC int 876 xfs_fs_freeze( 877 struct super_block *sb) 878 { 879 struct xfs_mount *mp = XFS_M(sb); 880 unsigned int flags; 881 int ret; 882 883 /* 884 * The filesystem is now frozen far enough that memory reclaim 885 * cannot safely operate on the filesystem. Hence we need to 886 * set a GFP_NOFS context here to avoid recursion deadlocks. 887 */ 888 flags = memalloc_nofs_save(); 889 xfs_blockgc_stop(mp); 890 xfs_save_resvblks(mp); 891 ret = xfs_log_quiesce(mp); 892 memalloc_nofs_restore(flags); 893 return ret; 894 } 895 896 STATIC int 897 xfs_fs_unfreeze( 898 struct super_block *sb) 899 { 900 struct xfs_mount *mp = XFS_M(sb); 901 902 xfs_restore_resvblks(mp); 903 xfs_log_work_queue(mp); 904 xfs_blockgc_start(mp); 905 return 0; 906 } 907 908 /* 909 * This function fills in xfs_mount_t fields based on mount args. 910 * Note: the superblock _has_ now been read in. 911 */ 912 STATIC int 913 xfs_finish_flags( 914 struct xfs_mount *mp) 915 { 916 int ronly = (mp->m_flags & XFS_MOUNT_RDONLY); 917 918 /* Fail a mount where the logbuf is smaller than the log stripe */ 919 if (xfs_sb_version_haslogv2(&mp->m_sb)) { 920 if (mp->m_logbsize <= 0 && 921 mp->m_sb.sb_logsunit > XLOG_BIG_RECORD_BSIZE) { 922 mp->m_logbsize = mp->m_sb.sb_logsunit; 923 } else if (mp->m_logbsize > 0 && 924 mp->m_logbsize < mp->m_sb.sb_logsunit) { 925 xfs_warn(mp, 926 "logbuf size must be greater than or equal to log stripe size"); 927 return -EINVAL; 928 } 929 } else { 930 /* Fail a mount if the logbuf is larger than 32K */ 931 if (mp->m_logbsize > XLOG_BIG_RECORD_BSIZE) { 932 xfs_warn(mp, 933 "logbuf size for version 1 logs must be 16K or 32K"); 934 return -EINVAL; 935 } 936 } 937 938 /* 939 * V5 filesystems always use attr2 format for attributes. 940 */ 941 if (xfs_sb_version_hascrc(&mp->m_sb) && 942 (mp->m_flags & XFS_MOUNT_NOATTR2)) { 943 xfs_warn(mp, "Cannot mount a V5 filesystem as noattr2. " 944 "attr2 is always enabled for V5 filesystems."); 945 return -EINVAL; 946 } 947 948 /* 949 * mkfs'ed attr2 will turn on attr2 mount unless explicitly 950 * told by noattr2 to turn it off 951 */ 952 if (xfs_sb_version_hasattr2(&mp->m_sb) && 953 !(mp->m_flags & XFS_MOUNT_NOATTR2)) 954 mp->m_flags |= XFS_MOUNT_ATTR2; 955 956 /* 957 * prohibit r/w mounts of read-only filesystems 958 */ 959 if ((mp->m_sb.sb_flags & XFS_SBF_READONLY) && !ronly) { 960 xfs_warn(mp, 961 "cannot mount a read-only filesystem as read-write"); 962 return -EROFS; 963 } 964 965 if ((mp->m_qflags & (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE)) && 966 (mp->m_qflags & (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE)) && 967 !xfs_sb_version_has_pquotino(&mp->m_sb)) { 968 xfs_warn(mp, 969 "Super block does not support project and group quota together"); 970 return -EINVAL; 971 } 972 973 return 0; 974 } 975 976 static int 977 xfs_init_percpu_counters( 978 struct xfs_mount *mp) 979 { 980 int error; 981 982 error = percpu_counter_init(&mp->m_icount, 0, GFP_KERNEL); 983 if (error) 984 return -ENOMEM; 985 986 error = percpu_counter_init(&mp->m_ifree, 0, GFP_KERNEL); 987 if (error) 988 goto free_icount; 989 990 error = percpu_counter_init(&mp->m_fdblocks, 0, GFP_KERNEL); 991 if (error) 992 goto free_ifree; 993 994 error = percpu_counter_init(&mp->m_delalloc_blks, 0, GFP_KERNEL); 995 if (error) 996 goto free_fdblocks; 997 998 return 0; 999 1000 free_fdblocks: 1001 percpu_counter_destroy(&mp->m_fdblocks); 1002 free_ifree: 1003 percpu_counter_destroy(&mp->m_ifree); 1004 free_icount: 1005 percpu_counter_destroy(&mp->m_icount); 1006 return -ENOMEM; 1007 } 1008 1009 void 1010 xfs_reinit_percpu_counters( 1011 struct xfs_mount *mp) 1012 { 1013 percpu_counter_set(&mp->m_icount, mp->m_sb.sb_icount); 1014 percpu_counter_set(&mp->m_ifree, mp->m_sb.sb_ifree); 1015 percpu_counter_set(&mp->m_fdblocks, mp->m_sb.sb_fdblocks); 1016 } 1017 1018 static void 1019 xfs_destroy_percpu_counters( 1020 struct xfs_mount *mp) 1021 { 1022 percpu_counter_destroy(&mp->m_icount); 1023 percpu_counter_destroy(&mp->m_ifree); 1024 percpu_counter_destroy(&mp->m_fdblocks); 1025 ASSERT(XFS_FORCED_SHUTDOWN(mp) || 1026 percpu_counter_sum(&mp->m_delalloc_blks) == 0); 1027 percpu_counter_destroy(&mp->m_delalloc_blks); 1028 } 1029 1030 static void 1031 xfs_fs_put_super( 1032 struct super_block *sb) 1033 { 1034 struct xfs_mount *mp = XFS_M(sb); 1035 1036 /* if ->fill_super failed, we have no mount to tear down */ 1037 if (!sb->s_fs_info) 1038 return; 1039 1040 xfs_notice(mp, "Unmounting Filesystem"); 1041 xfs_filestream_unmount(mp); 1042 xfs_unmountfs(mp); 1043 1044 xfs_freesb(mp); 1045 free_percpu(mp->m_stats.xs_stats); 1046 xfs_destroy_percpu_counters(mp); 1047 xfs_destroy_mount_workqueues(mp); 1048 xfs_close_devices(mp); 1049 1050 sb->s_fs_info = NULL; 1051 xfs_mount_free(mp); 1052 } 1053 1054 static long 1055 xfs_fs_nr_cached_objects( 1056 struct super_block *sb, 1057 struct shrink_control *sc) 1058 { 1059 /* Paranoia: catch incorrect calls during mount setup or teardown */ 1060 if (WARN_ON_ONCE(!sb->s_fs_info)) 1061 return 0; 1062 return xfs_reclaim_inodes_count(XFS_M(sb)); 1063 } 1064 1065 static long 1066 xfs_fs_free_cached_objects( 1067 struct super_block *sb, 1068 struct shrink_control *sc) 1069 { 1070 return xfs_reclaim_inodes_nr(XFS_M(sb), sc->nr_to_scan); 1071 } 1072 1073 static const struct super_operations xfs_super_operations = { 1074 .alloc_inode = xfs_fs_alloc_inode, 1075 .destroy_inode = xfs_fs_destroy_inode, 1076 .dirty_inode = xfs_fs_dirty_inode, 1077 .drop_inode = xfs_fs_drop_inode, 1078 .put_super = xfs_fs_put_super, 1079 .sync_fs = xfs_fs_sync_fs, 1080 .freeze_fs = xfs_fs_freeze, 1081 .unfreeze_fs = xfs_fs_unfreeze, 1082 .statfs = xfs_fs_statfs, 1083 .show_options = xfs_fs_show_options, 1084 .nr_cached_objects = xfs_fs_nr_cached_objects, 1085 .free_cached_objects = xfs_fs_free_cached_objects, 1086 }; 1087 1088 static int 1089 suffix_kstrtoint( 1090 const char *s, 1091 unsigned int base, 1092 int *res) 1093 { 1094 int last, shift_left_factor = 0, _res; 1095 char *value; 1096 int ret = 0; 1097 1098 value = kstrdup(s, GFP_KERNEL); 1099 if (!value) 1100 return -ENOMEM; 1101 1102 last = strlen(value) - 1; 1103 if (value[last] == 'K' || value[last] == 'k') { 1104 shift_left_factor = 10; 1105 value[last] = '\0'; 1106 } 1107 if (value[last] == 'M' || value[last] == 'm') { 1108 shift_left_factor = 20; 1109 value[last] = '\0'; 1110 } 1111 if (value[last] == 'G' || value[last] == 'g') { 1112 shift_left_factor = 30; 1113 value[last] = '\0'; 1114 } 1115 1116 if (kstrtoint(value, base, &_res)) 1117 ret = -EINVAL; 1118 kfree(value); 1119 *res = _res << shift_left_factor; 1120 return ret; 1121 } 1122 1123 static inline void 1124 xfs_fs_warn_deprecated( 1125 struct fs_context *fc, 1126 struct fs_parameter *param, 1127 uint64_t flag, 1128 bool value) 1129 { 1130 /* Don't print the warning if reconfiguring and current mount point 1131 * already had the flag set 1132 */ 1133 if ((fc->purpose & FS_CONTEXT_FOR_RECONFIGURE) && 1134 !!(XFS_M(fc->root->d_sb)->m_flags & flag) == value) 1135 return; 1136 xfs_warn(fc->s_fs_info, "%s mount option is deprecated.", param->key); 1137 } 1138 1139 /* 1140 * Set mount state from a mount option. 1141 * 1142 * NOTE: mp->m_super is NULL here! 1143 */ 1144 static int 1145 xfs_fs_parse_param( 1146 struct fs_context *fc, 1147 struct fs_parameter *param) 1148 { 1149 struct xfs_mount *parsing_mp = fc->s_fs_info; 1150 struct fs_parse_result result; 1151 int size = 0; 1152 int opt; 1153 1154 opt = fs_parse(fc, xfs_fs_parameters, param, &result); 1155 if (opt < 0) 1156 return opt; 1157 1158 switch (opt) { 1159 case Opt_logbufs: 1160 parsing_mp->m_logbufs = result.uint_32; 1161 return 0; 1162 case Opt_logbsize: 1163 if (suffix_kstrtoint(param->string, 10, &parsing_mp->m_logbsize)) 1164 return -EINVAL; 1165 return 0; 1166 case Opt_logdev: 1167 kfree(parsing_mp->m_logname); 1168 parsing_mp->m_logname = kstrdup(param->string, GFP_KERNEL); 1169 if (!parsing_mp->m_logname) 1170 return -ENOMEM; 1171 return 0; 1172 case Opt_rtdev: 1173 kfree(parsing_mp->m_rtname); 1174 parsing_mp->m_rtname = kstrdup(param->string, GFP_KERNEL); 1175 if (!parsing_mp->m_rtname) 1176 return -ENOMEM; 1177 return 0; 1178 case Opt_allocsize: 1179 if (suffix_kstrtoint(param->string, 10, &size)) 1180 return -EINVAL; 1181 parsing_mp->m_allocsize_log = ffs(size) - 1; 1182 parsing_mp->m_flags |= XFS_MOUNT_ALLOCSIZE; 1183 return 0; 1184 case Opt_grpid: 1185 case Opt_bsdgroups: 1186 parsing_mp->m_flags |= XFS_MOUNT_GRPID; 1187 return 0; 1188 case Opt_nogrpid: 1189 case Opt_sysvgroups: 1190 parsing_mp->m_flags &= ~XFS_MOUNT_GRPID; 1191 return 0; 1192 case Opt_wsync: 1193 parsing_mp->m_flags |= XFS_MOUNT_WSYNC; 1194 return 0; 1195 case Opt_norecovery: 1196 parsing_mp->m_flags |= XFS_MOUNT_NORECOVERY; 1197 return 0; 1198 case Opt_noalign: 1199 parsing_mp->m_flags |= XFS_MOUNT_NOALIGN; 1200 return 0; 1201 case Opt_swalloc: 1202 parsing_mp->m_flags |= XFS_MOUNT_SWALLOC; 1203 return 0; 1204 case Opt_sunit: 1205 parsing_mp->m_dalign = result.uint_32; 1206 return 0; 1207 case Opt_swidth: 1208 parsing_mp->m_swidth = result.uint_32; 1209 return 0; 1210 case Opt_inode32: 1211 parsing_mp->m_flags |= XFS_MOUNT_SMALL_INUMS; 1212 return 0; 1213 case Opt_inode64: 1214 parsing_mp->m_flags &= ~XFS_MOUNT_SMALL_INUMS; 1215 return 0; 1216 case Opt_nouuid: 1217 parsing_mp->m_flags |= XFS_MOUNT_NOUUID; 1218 return 0; 1219 case Opt_largeio: 1220 parsing_mp->m_flags |= XFS_MOUNT_LARGEIO; 1221 return 0; 1222 case Opt_nolargeio: 1223 parsing_mp->m_flags &= ~XFS_MOUNT_LARGEIO; 1224 return 0; 1225 case Opt_filestreams: 1226 parsing_mp->m_flags |= XFS_MOUNT_FILESTREAMS; 1227 return 0; 1228 case Opt_noquota: 1229 parsing_mp->m_qflags &= ~XFS_ALL_QUOTA_ACCT; 1230 parsing_mp->m_qflags &= ~XFS_ALL_QUOTA_ENFD; 1231 parsing_mp->m_qflags &= ~XFS_ALL_QUOTA_ACTIVE; 1232 return 0; 1233 case Opt_quota: 1234 case Opt_uquota: 1235 case Opt_usrquota: 1236 parsing_mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ACTIVE | 1237 XFS_UQUOTA_ENFD); 1238 return 0; 1239 case Opt_qnoenforce: 1240 case Opt_uqnoenforce: 1241 parsing_mp->m_qflags |= (XFS_UQUOTA_ACCT | XFS_UQUOTA_ACTIVE); 1242 parsing_mp->m_qflags &= ~XFS_UQUOTA_ENFD; 1243 return 0; 1244 case Opt_pquota: 1245 case Opt_prjquota: 1246 parsing_mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE | 1247 XFS_PQUOTA_ENFD); 1248 return 0; 1249 case Opt_pqnoenforce: 1250 parsing_mp->m_qflags |= (XFS_PQUOTA_ACCT | XFS_PQUOTA_ACTIVE); 1251 parsing_mp->m_qflags &= ~XFS_PQUOTA_ENFD; 1252 return 0; 1253 case Opt_gquota: 1254 case Opt_grpquota: 1255 parsing_mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE | 1256 XFS_GQUOTA_ENFD); 1257 return 0; 1258 case Opt_gqnoenforce: 1259 parsing_mp->m_qflags |= (XFS_GQUOTA_ACCT | XFS_GQUOTA_ACTIVE); 1260 parsing_mp->m_qflags &= ~XFS_GQUOTA_ENFD; 1261 return 0; 1262 case Opt_discard: 1263 parsing_mp->m_flags |= XFS_MOUNT_DISCARD; 1264 return 0; 1265 case Opt_nodiscard: 1266 parsing_mp->m_flags &= ~XFS_MOUNT_DISCARD; 1267 return 0; 1268 #ifdef CONFIG_FS_DAX 1269 case Opt_dax: 1270 xfs_mount_set_dax_mode(parsing_mp, XFS_DAX_ALWAYS); 1271 return 0; 1272 case Opt_dax_enum: 1273 xfs_mount_set_dax_mode(parsing_mp, result.uint_32); 1274 return 0; 1275 #endif 1276 /* Following mount options will be removed in September 2025 */ 1277 case Opt_ikeep: 1278 xfs_fs_warn_deprecated(fc, param, XFS_MOUNT_IKEEP, true); 1279 parsing_mp->m_flags |= XFS_MOUNT_IKEEP; 1280 return 0; 1281 case Opt_noikeep: 1282 xfs_fs_warn_deprecated(fc, param, XFS_MOUNT_IKEEP, false); 1283 parsing_mp->m_flags &= ~XFS_MOUNT_IKEEP; 1284 return 0; 1285 case Opt_attr2: 1286 xfs_fs_warn_deprecated(fc, param, XFS_MOUNT_ATTR2, true); 1287 parsing_mp->m_flags |= XFS_MOUNT_ATTR2; 1288 return 0; 1289 case Opt_noattr2: 1290 xfs_fs_warn_deprecated(fc, param, XFS_MOUNT_NOATTR2, true); 1291 parsing_mp->m_flags &= ~XFS_MOUNT_ATTR2; 1292 parsing_mp->m_flags |= XFS_MOUNT_NOATTR2; 1293 return 0; 1294 default: 1295 xfs_warn(parsing_mp, "unknown mount option [%s].", param->key); 1296 return -EINVAL; 1297 } 1298 1299 return 0; 1300 } 1301 1302 static int 1303 xfs_fs_validate_params( 1304 struct xfs_mount *mp) 1305 { 1306 /* 1307 * no recovery flag requires a read-only mount 1308 */ 1309 if ((mp->m_flags & XFS_MOUNT_NORECOVERY) && 1310 !(mp->m_flags & XFS_MOUNT_RDONLY)) { 1311 xfs_warn(mp, "no-recovery mounts must be read-only."); 1312 return -EINVAL; 1313 } 1314 1315 if ((mp->m_flags & XFS_MOUNT_NOALIGN) && 1316 (mp->m_dalign || mp->m_swidth)) { 1317 xfs_warn(mp, 1318 "sunit and swidth options incompatible with the noalign option"); 1319 return -EINVAL; 1320 } 1321 1322 if (!IS_ENABLED(CONFIG_XFS_QUOTA) && mp->m_qflags != 0) { 1323 xfs_warn(mp, "quota support not available in this kernel."); 1324 return -EINVAL; 1325 } 1326 1327 if ((mp->m_dalign && !mp->m_swidth) || 1328 (!mp->m_dalign && mp->m_swidth)) { 1329 xfs_warn(mp, "sunit and swidth must be specified together"); 1330 return -EINVAL; 1331 } 1332 1333 if (mp->m_dalign && (mp->m_swidth % mp->m_dalign != 0)) { 1334 xfs_warn(mp, 1335 "stripe width (%d) must be a multiple of the stripe unit (%d)", 1336 mp->m_swidth, mp->m_dalign); 1337 return -EINVAL; 1338 } 1339 1340 if (mp->m_logbufs != -1 && 1341 mp->m_logbufs != 0 && 1342 (mp->m_logbufs < XLOG_MIN_ICLOGS || 1343 mp->m_logbufs > XLOG_MAX_ICLOGS)) { 1344 xfs_warn(mp, "invalid logbufs value: %d [not %d-%d]", 1345 mp->m_logbufs, XLOG_MIN_ICLOGS, XLOG_MAX_ICLOGS); 1346 return -EINVAL; 1347 } 1348 1349 if (mp->m_logbsize != -1 && 1350 mp->m_logbsize != 0 && 1351 (mp->m_logbsize < XLOG_MIN_RECORD_BSIZE || 1352 mp->m_logbsize > XLOG_MAX_RECORD_BSIZE || 1353 !is_power_of_2(mp->m_logbsize))) { 1354 xfs_warn(mp, 1355 "invalid logbufsize: %d [not 16k,32k,64k,128k or 256k]", 1356 mp->m_logbsize); 1357 return -EINVAL; 1358 } 1359 1360 if ((mp->m_flags & XFS_MOUNT_ALLOCSIZE) && 1361 (mp->m_allocsize_log > XFS_MAX_IO_LOG || 1362 mp->m_allocsize_log < XFS_MIN_IO_LOG)) { 1363 xfs_warn(mp, "invalid log iosize: %d [not %d-%d]", 1364 mp->m_allocsize_log, XFS_MIN_IO_LOG, XFS_MAX_IO_LOG); 1365 return -EINVAL; 1366 } 1367 1368 return 0; 1369 } 1370 1371 static int 1372 xfs_fs_fill_super( 1373 struct super_block *sb, 1374 struct fs_context *fc) 1375 { 1376 struct xfs_mount *mp = sb->s_fs_info; 1377 struct inode *root; 1378 int flags = 0, error; 1379 1380 mp->m_super = sb; 1381 1382 error = xfs_fs_validate_params(mp); 1383 if (error) 1384 goto out_free_names; 1385 1386 sb_min_blocksize(sb, BBSIZE); 1387 sb->s_xattr = xfs_xattr_handlers; 1388 sb->s_export_op = &xfs_export_operations; 1389 #ifdef CONFIG_XFS_QUOTA 1390 sb->s_qcop = &xfs_quotactl_operations; 1391 sb->s_quota_types = QTYPE_MASK_USR | QTYPE_MASK_GRP | QTYPE_MASK_PRJ; 1392 #endif 1393 sb->s_op = &xfs_super_operations; 1394 1395 /* 1396 * Delay mount work if the debug hook is set. This is debug 1397 * instrumention to coordinate simulation of xfs mount failures with 1398 * VFS superblock operations 1399 */ 1400 if (xfs_globals.mount_delay) { 1401 xfs_notice(mp, "Delaying mount for %d seconds.", 1402 xfs_globals.mount_delay); 1403 msleep(xfs_globals.mount_delay * 1000); 1404 } 1405 1406 if (fc->sb_flags & SB_SILENT) 1407 flags |= XFS_MFSI_QUIET; 1408 1409 error = xfs_open_devices(mp); 1410 if (error) 1411 goto out_free_names; 1412 1413 error = xfs_init_mount_workqueues(mp); 1414 if (error) 1415 goto out_close_devices; 1416 1417 error = xfs_init_percpu_counters(mp); 1418 if (error) 1419 goto out_destroy_workqueues; 1420 1421 /* Allocate stats memory before we do operations that might use it */ 1422 mp->m_stats.xs_stats = alloc_percpu(struct xfsstats); 1423 if (!mp->m_stats.xs_stats) { 1424 error = -ENOMEM; 1425 goto out_destroy_counters; 1426 } 1427 1428 error = xfs_readsb(mp, flags); 1429 if (error) 1430 goto out_free_stats; 1431 1432 error = xfs_finish_flags(mp); 1433 if (error) 1434 goto out_free_sb; 1435 1436 error = xfs_setup_devices(mp); 1437 if (error) 1438 goto out_free_sb; 1439 1440 /* V4 support is undergoing deprecation. */ 1441 if (!xfs_sb_version_hascrc(&mp->m_sb)) { 1442 #ifdef CONFIG_XFS_SUPPORT_V4 1443 xfs_warn_once(mp, 1444 "Deprecated V4 format (crc=0) will not be supported after September 2030."); 1445 #else 1446 xfs_warn(mp, 1447 "Deprecated V4 format (crc=0) not supported by kernel."); 1448 error = -EINVAL; 1449 goto out_free_sb; 1450 #endif 1451 } 1452 1453 /* Filesystem claims it needs repair, so refuse the mount. */ 1454 if (xfs_sb_version_needsrepair(&mp->m_sb)) { 1455 xfs_warn(mp, "Filesystem needs repair. Please run xfs_repair."); 1456 error = -EFSCORRUPTED; 1457 goto out_free_sb; 1458 } 1459 1460 /* 1461 * Don't touch the filesystem if a user tool thinks it owns the primary 1462 * superblock. mkfs doesn't clear the flag from secondary supers, so 1463 * we don't check them at all. 1464 */ 1465 if (mp->m_sb.sb_inprogress) { 1466 xfs_warn(mp, "Offline file system operation in progress!"); 1467 error = -EFSCORRUPTED; 1468 goto out_free_sb; 1469 } 1470 1471 /* 1472 * Until this is fixed only page-sized or smaller data blocks work. 1473 */ 1474 if (mp->m_sb.sb_blocksize > PAGE_SIZE) { 1475 xfs_warn(mp, 1476 "File system with blocksize %d bytes. " 1477 "Only pagesize (%ld) or less will currently work.", 1478 mp->m_sb.sb_blocksize, PAGE_SIZE); 1479 error = -ENOSYS; 1480 goto out_free_sb; 1481 } 1482 1483 /* Ensure this filesystem fits in the page cache limits */ 1484 if (xfs_sb_validate_fsb_count(&mp->m_sb, mp->m_sb.sb_dblocks) || 1485 xfs_sb_validate_fsb_count(&mp->m_sb, mp->m_sb.sb_rblocks)) { 1486 xfs_warn(mp, 1487 "file system too large to be mounted on this system."); 1488 error = -EFBIG; 1489 goto out_free_sb; 1490 } 1491 1492 /* 1493 * XFS block mappings use 54 bits to store the logical block offset. 1494 * This should suffice to handle the maximum file size that the VFS 1495 * supports (currently 2^63 bytes on 64-bit and ULONG_MAX << PAGE_SHIFT 1496 * bytes on 32-bit), but as XFS and VFS have gotten the s_maxbytes 1497 * calculation wrong on 32-bit kernels in the past, we'll add a WARN_ON 1498 * to check this assertion. 1499 * 1500 * Avoid integer overflow by comparing the maximum bmbt offset to the 1501 * maximum pagecache offset in units of fs blocks. 1502 */ 1503 if (!xfs_verify_fileoff(mp, XFS_B_TO_FSBT(mp, MAX_LFS_FILESIZE))) { 1504 xfs_warn(mp, 1505 "MAX_LFS_FILESIZE block offset (%llu) exceeds extent map maximum (%llu)!", 1506 XFS_B_TO_FSBT(mp, MAX_LFS_FILESIZE), 1507 XFS_MAX_FILEOFF); 1508 error = -EINVAL; 1509 goto out_free_sb; 1510 } 1511 1512 error = xfs_filestream_mount(mp); 1513 if (error) 1514 goto out_free_sb; 1515 1516 /* 1517 * we must configure the block size in the superblock before we run the 1518 * full mount process as the mount process can lookup and cache inodes. 1519 */ 1520 sb->s_magic = XFS_SUPER_MAGIC; 1521 sb->s_blocksize = mp->m_sb.sb_blocksize; 1522 sb->s_blocksize_bits = ffs(sb->s_blocksize) - 1; 1523 sb->s_maxbytes = MAX_LFS_FILESIZE; 1524 sb->s_max_links = XFS_MAXLINK; 1525 sb->s_time_gran = 1; 1526 if (xfs_sb_version_hasbigtime(&mp->m_sb)) { 1527 sb->s_time_min = xfs_bigtime_to_unix(XFS_BIGTIME_TIME_MIN); 1528 sb->s_time_max = xfs_bigtime_to_unix(XFS_BIGTIME_TIME_MAX); 1529 } else { 1530 sb->s_time_min = XFS_LEGACY_TIME_MIN; 1531 sb->s_time_max = XFS_LEGACY_TIME_MAX; 1532 } 1533 trace_xfs_inode_timestamp_range(mp, sb->s_time_min, sb->s_time_max); 1534 sb->s_iflags |= SB_I_CGROUPWB; 1535 1536 set_posix_acl_flag(sb); 1537 1538 /* version 5 superblocks support inode version counters. */ 1539 if (XFS_SB_VERSION_NUM(&mp->m_sb) == XFS_SB_VERSION_5) 1540 sb->s_flags |= SB_I_VERSION; 1541 1542 if (xfs_sb_version_hasbigtime(&mp->m_sb)) 1543 xfs_warn(mp, 1544 "EXPERIMENTAL big timestamp feature in use. Use at your own risk!"); 1545 1546 if (mp->m_flags & XFS_MOUNT_DAX_ALWAYS) { 1547 bool rtdev_is_dax = false, datadev_is_dax; 1548 1549 xfs_warn(mp, 1550 "DAX enabled. Warning: EXPERIMENTAL, use at your own risk"); 1551 1552 datadev_is_dax = bdev_dax_supported(mp->m_ddev_targp->bt_bdev, 1553 sb->s_blocksize); 1554 if (mp->m_rtdev_targp) 1555 rtdev_is_dax = bdev_dax_supported( 1556 mp->m_rtdev_targp->bt_bdev, sb->s_blocksize); 1557 if (!rtdev_is_dax && !datadev_is_dax) { 1558 xfs_alert(mp, 1559 "DAX unsupported by block device. Turning off DAX."); 1560 xfs_mount_set_dax_mode(mp, XFS_DAX_NEVER); 1561 } 1562 if (xfs_sb_version_hasreflink(&mp->m_sb)) { 1563 xfs_alert(mp, 1564 "DAX and reflink cannot be used together!"); 1565 error = -EINVAL; 1566 goto out_filestream_unmount; 1567 } 1568 } 1569 1570 if (mp->m_flags & XFS_MOUNT_DISCARD) { 1571 struct request_queue *q = bdev_get_queue(sb->s_bdev); 1572 1573 if (!blk_queue_discard(q)) { 1574 xfs_warn(mp, "mounting with \"discard\" option, but " 1575 "the device does not support discard"); 1576 mp->m_flags &= ~XFS_MOUNT_DISCARD; 1577 } 1578 } 1579 1580 if (xfs_sb_version_hasreflink(&mp->m_sb)) { 1581 if (mp->m_sb.sb_rblocks) { 1582 xfs_alert(mp, 1583 "reflink not compatible with realtime device!"); 1584 error = -EINVAL; 1585 goto out_filestream_unmount; 1586 } 1587 1588 if (xfs_globals.always_cow) { 1589 xfs_info(mp, "using DEBUG-only always_cow mode."); 1590 mp->m_always_cow = true; 1591 } 1592 } 1593 1594 if (xfs_sb_version_hasrmapbt(&mp->m_sb) && mp->m_sb.sb_rblocks) { 1595 xfs_alert(mp, 1596 "reverse mapping btree not compatible with realtime device!"); 1597 error = -EINVAL; 1598 goto out_filestream_unmount; 1599 } 1600 1601 if (xfs_sb_version_hasinobtcounts(&mp->m_sb)) 1602 xfs_warn(mp, 1603 "EXPERIMENTAL inode btree counters feature in use. Use at your own risk!"); 1604 1605 error = xfs_mountfs(mp); 1606 if (error) 1607 goto out_filestream_unmount; 1608 1609 root = igrab(VFS_I(mp->m_rootip)); 1610 if (!root) { 1611 error = -ENOENT; 1612 goto out_unmount; 1613 } 1614 sb->s_root = d_make_root(root); 1615 if (!sb->s_root) { 1616 error = -ENOMEM; 1617 goto out_unmount; 1618 } 1619 1620 return 0; 1621 1622 out_filestream_unmount: 1623 xfs_filestream_unmount(mp); 1624 out_free_sb: 1625 xfs_freesb(mp); 1626 out_free_stats: 1627 free_percpu(mp->m_stats.xs_stats); 1628 out_destroy_counters: 1629 xfs_destroy_percpu_counters(mp); 1630 out_destroy_workqueues: 1631 xfs_destroy_mount_workqueues(mp); 1632 out_close_devices: 1633 xfs_close_devices(mp); 1634 out_free_names: 1635 sb->s_fs_info = NULL; 1636 xfs_mount_free(mp); 1637 return error; 1638 1639 out_unmount: 1640 xfs_filestream_unmount(mp); 1641 xfs_unmountfs(mp); 1642 goto out_free_sb; 1643 } 1644 1645 static int 1646 xfs_fs_get_tree( 1647 struct fs_context *fc) 1648 { 1649 return get_tree_bdev(fc, xfs_fs_fill_super); 1650 } 1651 1652 static int 1653 xfs_remount_rw( 1654 struct xfs_mount *mp) 1655 { 1656 struct xfs_sb *sbp = &mp->m_sb; 1657 int error; 1658 1659 if (mp->m_flags & XFS_MOUNT_NORECOVERY) { 1660 xfs_warn(mp, 1661 "ro->rw transition prohibited on norecovery mount"); 1662 return -EINVAL; 1663 } 1664 1665 if (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5 && 1666 xfs_sb_has_ro_compat_feature(sbp, XFS_SB_FEAT_RO_COMPAT_UNKNOWN)) { 1667 xfs_warn(mp, 1668 "ro->rw transition prohibited on unknown (0x%x) ro-compat filesystem", 1669 (sbp->sb_features_ro_compat & 1670 XFS_SB_FEAT_RO_COMPAT_UNKNOWN)); 1671 return -EINVAL; 1672 } 1673 1674 mp->m_flags &= ~XFS_MOUNT_RDONLY; 1675 1676 /* 1677 * If this is the first remount to writeable state we might have some 1678 * superblock changes to update. 1679 */ 1680 if (mp->m_update_sb) { 1681 error = xfs_sync_sb(mp, false); 1682 if (error) { 1683 xfs_warn(mp, "failed to write sb changes"); 1684 return error; 1685 } 1686 mp->m_update_sb = false; 1687 } 1688 1689 /* 1690 * Fill out the reserve pool if it is empty. Use the stashed value if 1691 * it is non-zero, otherwise go with the default. 1692 */ 1693 xfs_restore_resvblks(mp); 1694 xfs_log_work_queue(mp); 1695 1696 /* Recover any CoW blocks that never got remapped. */ 1697 error = xfs_reflink_recover_cow(mp); 1698 if (error) { 1699 xfs_err(mp, 1700 "Error %d recovering leftover CoW allocations.", error); 1701 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE); 1702 return error; 1703 } 1704 xfs_blockgc_start(mp); 1705 1706 /* Create the per-AG metadata reservation pool .*/ 1707 error = xfs_fs_reserve_ag_blocks(mp); 1708 if (error && error != -ENOSPC) 1709 return error; 1710 1711 return 0; 1712 } 1713 1714 static int 1715 xfs_remount_ro( 1716 struct xfs_mount *mp) 1717 { 1718 int error; 1719 1720 /* 1721 * Cancel background eofb scanning so it cannot race with the final 1722 * log force+buftarg wait and deadlock the remount. 1723 */ 1724 xfs_blockgc_stop(mp); 1725 1726 /* Get rid of any leftover CoW reservations... */ 1727 error = xfs_blockgc_free_space(mp, NULL); 1728 if (error) { 1729 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE); 1730 return error; 1731 } 1732 1733 /* Free the per-AG metadata reservation pool. */ 1734 error = xfs_fs_unreserve_ag_blocks(mp); 1735 if (error) { 1736 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE); 1737 return error; 1738 } 1739 1740 /* 1741 * Before we sync the metadata, we need to free up the reserve block 1742 * pool so that the used block count in the superblock on disk is 1743 * correct at the end of the remount. Stash the current* reserve pool 1744 * size so that if we get remounted rw, we can return it to the same 1745 * size. 1746 */ 1747 xfs_save_resvblks(mp); 1748 1749 xfs_log_clean(mp); 1750 mp->m_flags |= XFS_MOUNT_RDONLY; 1751 1752 return 0; 1753 } 1754 1755 /* 1756 * Logically we would return an error here to prevent users from believing 1757 * they might have changed mount options using remount which can't be changed. 1758 * 1759 * But unfortunately mount(8) adds all options from mtab and fstab to the mount 1760 * arguments in some cases so we can't blindly reject options, but have to 1761 * check for each specified option if it actually differs from the currently 1762 * set option and only reject it if that's the case. 1763 * 1764 * Until that is implemented we return success for every remount request, and 1765 * silently ignore all options that we can't actually change. 1766 */ 1767 static int 1768 xfs_fs_reconfigure( 1769 struct fs_context *fc) 1770 { 1771 struct xfs_mount *mp = XFS_M(fc->root->d_sb); 1772 struct xfs_mount *new_mp = fc->s_fs_info; 1773 xfs_sb_t *sbp = &mp->m_sb; 1774 int flags = fc->sb_flags; 1775 int error; 1776 1777 /* version 5 superblocks always support version counters. */ 1778 if (XFS_SB_VERSION_NUM(&mp->m_sb) == XFS_SB_VERSION_5) 1779 fc->sb_flags |= SB_I_VERSION; 1780 1781 error = xfs_fs_validate_params(new_mp); 1782 if (error) 1783 return error; 1784 1785 sync_filesystem(mp->m_super); 1786 1787 /* inode32 -> inode64 */ 1788 if ((mp->m_flags & XFS_MOUNT_SMALL_INUMS) && 1789 !(new_mp->m_flags & XFS_MOUNT_SMALL_INUMS)) { 1790 mp->m_flags &= ~XFS_MOUNT_SMALL_INUMS; 1791 mp->m_maxagi = xfs_set_inode_alloc(mp, sbp->sb_agcount); 1792 } 1793 1794 /* inode64 -> inode32 */ 1795 if (!(mp->m_flags & XFS_MOUNT_SMALL_INUMS) && 1796 (new_mp->m_flags & XFS_MOUNT_SMALL_INUMS)) { 1797 mp->m_flags |= XFS_MOUNT_SMALL_INUMS; 1798 mp->m_maxagi = xfs_set_inode_alloc(mp, sbp->sb_agcount); 1799 } 1800 1801 /* ro -> rw */ 1802 if ((mp->m_flags & XFS_MOUNT_RDONLY) && !(flags & SB_RDONLY)) { 1803 error = xfs_remount_rw(mp); 1804 if (error) 1805 return error; 1806 } 1807 1808 /* rw -> ro */ 1809 if (!(mp->m_flags & XFS_MOUNT_RDONLY) && (flags & SB_RDONLY)) { 1810 error = xfs_remount_ro(mp); 1811 if (error) 1812 return error; 1813 } 1814 1815 return 0; 1816 } 1817 1818 static void xfs_fs_free( 1819 struct fs_context *fc) 1820 { 1821 struct xfs_mount *mp = fc->s_fs_info; 1822 1823 /* 1824 * mp is stored in the fs_context when it is initialized. 1825 * mp is transferred to the superblock on a successful mount, 1826 * but if an error occurs before the transfer we have to free 1827 * it here. 1828 */ 1829 if (mp) 1830 xfs_mount_free(mp); 1831 } 1832 1833 static const struct fs_context_operations xfs_context_ops = { 1834 .parse_param = xfs_fs_parse_param, 1835 .get_tree = xfs_fs_get_tree, 1836 .reconfigure = xfs_fs_reconfigure, 1837 .free = xfs_fs_free, 1838 }; 1839 1840 static int xfs_init_fs_context( 1841 struct fs_context *fc) 1842 { 1843 struct xfs_mount *mp; 1844 1845 mp = kmem_alloc(sizeof(struct xfs_mount), KM_ZERO); 1846 if (!mp) 1847 return -ENOMEM; 1848 1849 spin_lock_init(&mp->m_sb_lock); 1850 spin_lock_init(&mp->m_agirotor_lock); 1851 INIT_RADIX_TREE(&mp->m_perag_tree, GFP_ATOMIC); 1852 spin_lock_init(&mp->m_perag_lock); 1853 mutex_init(&mp->m_growlock); 1854 INIT_WORK(&mp->m_flush_inodes_work, xfs_flush_inodes_worker); 1855 INIT_DELAYED_WORK(&mp->m_reclaim_work, xfs_reclaim_worker); 1856 mp->m_kobj.kobject.kset = xfs_kset; 1857 /* 1858 * We don't create the finobt per-ag space reservation until after log 1859 * recovery, so we must set this to true so that an ifree transaction 1860 * started during log recovery will not depend on space reservations 1861 * for finobt expansion. 1862 */ 1863 mp->m_finobt_nores = true; 1864 1865 /* 1866 * These can be overridden by the mount option parsing. 1867 */ 1868 mp->m_logbufs = -1; 1869 mp->m_logbsize = -1; 1870 mp->m_allocsize_log = 16; /* 64k */ 1871 1872 /* 1873 * Copy binary VFS mount flags we are interested in. 1874 */ 1875 if (fc->sb_flags & SB_RDONLY) 1876 mp->m_flags |= XFS_MOUNT_RDONLY; 1877 if (fc->sb_flags & SB_DIRSYNC) 1878 mp->m_flags |= XFS_MOUNT_DIRSYNC; 1879 if (fc->sb_flags & SB_SYNCHRONOUS) 1880 mp->m_flags |= XFS_MOUNT_WSYNC; 1881 1882 fc->s_fs_info = mp; 1883 fc->ops = &xfs_context_ops; 1884 1885 return 0; 1886 } 1887 1888 static struct file_system_type xfs_fs_type = { 1889 .owner = THIS_MODULE, 1890 .name = "xfs", 1891 .init_fs_context = xfs_init_fs_context, 1892 .parameters = xfs_fs_parameters, 1893 .kill_sb = kill_block_super, 1894 .fs_flags = FS_REQUIRES_DEV | FS_ALLOW_IDMAP, 1895 }; 1896 MODULE_ALIAS_FS("xfs"); 1897 1898 STATIC int __init 1899 xfs_init_zones(void) 1900 { 1901 xfs_log_ticket_zone = kmem_cache_create("xfs_log_ticket", 1902 sizeof(struct xlog_ticket), 1903 0, 0, NULL); 1904 if (!xfs_log_ticket_zone) 1905 goto out; 1906 1907 xfs_bmap_free_item_zone = kmem_cache_create("xfs_bmap_free_item", 1908 sizeof(struct xfs_extent_free_item), 1909 0, 0, NULL); 1910 if (!xfs_bmap_free_item_zone) 1911 goto out_destroy_log_ticket_zone; 1912 1913 xfs_btree_cur_zone = kmem_cache_create("xfs_btree_cur", 1914 sizeof(struct xfs_btree_cur), 1915 0, 0, NULL); 1916 if (!xfs_btree_cur_zone) 1917 goto out_destroy_bmap_free_item_zone; 1918 1919 xfs_da_state_zone = kmem_cache_create("xfs_da_state", 1920 sizeof(struct xfs_da_state), 1921 0, 0, NULL); 1922 if (!xfs_da_state_zone) 1923 goto out_destroy_btree_cur_zone; 1924 1925 xfs_ifork_zone = kmem_cache_create("xfs_ifork", 1926 sizeof(struct xfs_ifork), 1927 0, 0, NULL); 1928 if (!xfs_ifork_zone) 1929 goto out_destroy_da_state_zone; 1930 1931 xfs_trans_zone = kmem_cache_create("xfs_trans", 1932 sizeof(struct xfs_trans), 1933 0, 0, NULL); 1934 if (!xfs_trans_zone) 1935 goto out_destroy_ifork_zone; 1936 1937 1938 /* 1939 * The size of the zone allocated buf log item is the maximum 1940 * size possible under XFS. This wastes a little bit of memory, 1941 * but it is much faster. 1942 */ 1943 xfs_buf_item_zone = kmem_cache_create("xfs_buf_item", 1944 sizeof(struct xfs_buf_log_item), 1945 0, 0, NULL); 1946 if (!xfs_buf_item_zone) 1947 goto out_destroy_trans_zone; 1948 1949 xfs_efd_zone = kmem_cache_create("xfs_efd_item", 1950 (sizeof(struct xfs_efd_log_item) + 1951 (XFS_EFD_MAX_FAST_EXTENTS - 1) * 1952 sizeof(struct xfs_extent)), 1953 0, 0, NULL); 1954 if (!xfs_efd_zone) 1955 goto out_destroy_buf_item_zone; 1956 1957 xfs_efi_zone = kmem_cache_create("xfs_efi_item", 1958 (sizeof(struct xfs_efi_log_item) + 1959 (XFS_EFI_MAX_FAST_EXTENTS - 1) * 1960 sizeof(struct xfs_extent)), 1961 0, 0, NULL); 1962 if (!xfs_efi_zone) 1963 goto out_destroy_efd_zone; 1964 1965 xfs_inode_zone = kmem_cache_create("xfs_inode", 1966 sizeof(struct xfs_inode), 0, 1967 (SLAB_HWCACHE_ALIGN | 1968 SLAB_RECLAIM_ACCOUNT | 1969 SLAB_MEM_SPREAD | SLAB_ACCOUNT), 1970 xfs_fs_inode_init_once); 1971 if (!xfs_inode_zone) 1972 goto out_destroy_efi_zone; 1973 1974 xfs_ili_zone = kmem_cache_create("xfs_ili", 1975 sizeof(struct xfs_inode_log_item), 0, 1976 SLAB_RECLAIM_ACCOUNT | SLAB_MEM_SPREAD, 1977 NULL); 1978 if (!xfs_ili_zone) 1979 goto out_destroy_inode_zone; 1980 1981 xfs_icreate_zone = kmem_cache_create("xfs_icr", 1982 sizeof(struct xfs_icreate_item), 1983 0, 0, NULL); 1984 if (!xfs_icreate_zone) 1985 goto out_destroy_ili_zone; 1986 1987 xfs_rud_zone = kmem_cache_create("xfs_rud_item", 1988 sizeof(struct xfs_rud_log_item), 1989 0, 0, NULL); 1990 if (!xfs_rud_zone) 1991 goto out_destroy_icreate_zone; 1992 1993 xfs_rui_zone = kmem_cache_create("xfs_rui_item", 1994 xfs_rui_log_item_sizeof(XFS_RUI_MAX_FAST_EXTENTS), 1995 0, 0, NULL); 1996 if (!xfs_rui_zone) 1997 goto out_destroy_rud_zone; 1998 1999 xfs_cud_zone = kmem_cache_create("xfs_cud_item", 2000 sizeof(struct xfs_cud_log_item), 2001 0, 0, NULL); 2002 if (!xfs_cud_zone) 2003 goto out_destroy_rui_zone; 2004 2005 xfs_cui_zone = kmem_cache_create("xfs_cui_item", 2006 xfs_cui_log_item_sizeof(XFS_CUI_MAX_FAST_EXTENTS), 2007 0, 0, NULL); 2008 if (!xfs_cui_zone) 2009 goto out_destroy_cud_zone; 2010 2011 xfs_bud_zone = kmem_cache_create("xfs_bud_item", 2012 sizeof(struct xfs_bud_log_item), 2013 0, 0, NULL); 2014 if (!xfs_bud_zone) 2015 goto out_destroy_cui_zone; 2016 2017 xfs_bui_zone = kmem_cache_create("xfs_bui_item", 2018 xfs_bui_log_item_sizeof(XFS_BUI_MAX_FAST_EXTENTS), 2019 0, 0, NULL); 2020 if (!xfs_bui_zone) 2021 goto out_destroy_bud_zone; 2022 2023 return 0; 2024 2025 out_destroy_bud_zone: 2026 kmem_cache_destroy(xfs_bud_zone); 2027 out_destroy_cui_zone: 2028 kmem_cache_destroy(xfs_cui_zone); 2029 out_destroy_cud_zone: 2030 kmem_cache_destroy(xfs_cud_zone); 2031 out_destroy_rui_zone: 2032 kmem_cache_destroy(xfs_rui_zone); 2033 out_destroy_rud_zone: 2034 kmem_cache_destroy(xfs_rud_zone); 2035 out_destroy_icreate_zone: 2036 kmem_cache_destroy(xfs_icreate_zone); 2037 out_destroy_ili_zone: 2038 kmem_cache_destroy(xfs_ili_zone); 2039 out_destroy_inode_zone: 2040 kmem_cache_destroy(xfs_inode_zone); 2041 out_destroy_efi_zone: 2042 kmem_cache_destroy(xfs_efi_zone); 2043 out_destroy_efd_zone: 2044 kmem_cache_destroy(xfs_efd_zone); 2045 out_destroy_buf_item_zone: 2046 kmem_cache_destroy(xfs_buf_item_zone); 2047 out_destroy_trans_zone: 2048 kmem_cache_destroy(xfs_trans_zone); 2049 out_destroy_ifork_zone: 2050 kmem_cache_destroy(xfs_ifork_zone); 2051 out_destroy_da_state_zone: 2052 kmem_cache_destroy(xfs_da_state_zone); 2053 out_destroy_btree_cur_zone: 2054 kmem_cache_destroy(xfs_btree_cur_zone); 2055 out_destroy_bmap_free_item_zone: 2056 kmem_cache_destroy(xfs_bmap_free_item_zone); 2057 out_destroy_log_ticket_zone: 2058 kmem_cache_destroy(xfs_log_ticket_zone); 2059 out: 2060 return -ENOMEM; 2061 } 2062 2063 STATIC void 2064 xfs_destroy_zones(void) 2065 { 2066 /* 2067 * Make sure all delayed rcu free are flushed before we 2068 * destroy caches. 2069 */ 2070 rcu_barrier(); 2071 kmem_cache_destroy(xfs_bui_zone); 2072 kmem_cache_destroy(xfs_bud_zone); 2073 kmem_cache_destroy(xfs_cui_zone); 2074 kmem_cache_destroy(xfs_cud_zone); 2075 kmem_cache_destroy(xfs_rui_zone); 2076 kmem_cache_destroy(xfs_rud_zone); 2077 kmem_cache_destroy(xfs_icreate_zone); 2078 kmem_cache_destroy(xfs_ili_zone); 2079 kmem_cache_destroy(xfs_inode_zone); 2080 kmem_cache_destroy(xfs_efi_zone); 2081 kmem_cache_destroy(xfs_efd_zone); 2082 kmem_cache_destroy(xfs_buf_item_zone); 2083 kmem_cache_destroy(xfs_trans_zone); 2084 kmem_cache_destroy(xfs_ifork_zone); 2085 kmem_cache_destroy(xfs_da_state_zone); 2086 kmem_cache_destroy(xfs_btree_cur_zone); 2087 kmem_cache_destroy(xfs_bmap_free_item_zone); 2088 kmem_cache_destroy(xfs_log_ticket_zone); 2089 } 2090 2091 STATIC int __init 2092 xfs_init_workqueues(void) 2093 { 2094 /* 2095 * The allocation workqueue can be used in memory reclaim situations 2096 * (writepage path), and parallelism is only limited by the number of 2097 * AGs in all the filesystems mounted. Hence use the default large 2098 * max_active value for this workqueue. 2099 */ 2100 xfs_alloc_wq = alloc_workqueue("xfsalloc", 2101 XFS_WQFLAGS(WQ_MEM_RECLAIM | WQ_FREEZABLE), 0); 2102 if (!xfs_alloc_wq) 2103 return -ENOMEM; 2104 2105 xfs_discard_wq = alloc_workqueue("xfsdiscard", XFS_WQFLAGS(WQ_UNBOUND), 2106 0); 2107 if (!xfs_discard_wq) 2108 goto out_free_alloc_wq; 2109 2110 return 0; 2111 out_free_alloc_wq: 2112 destroy_workqueue(xfs_alloc_wq); 2113 return -ENOMEM; 2114 } 2115 2116 STATIC void 2117 xfs_destroy_workqueues(void) 2118 { 2119 destroy_workqueue(xfs_discard_wq); 2120 destroy_workqueue(xfs_alloc_wq); 2121 } 2122 2123 STATIC int __init 2124 init_xfs_fs(void) 2125 { 2126 int error; 2127 2128 xfs_check_ondisk_structs(); 2129 2130 printk(KERN_INFO XFS_VERSION_STRING " with " 2131 XFS_BUILD_OPTIONS " enabled\n"); 2132 2133 xfs_dir_startup(); 2134 2135 error = xfs_init_zones(); 2136 if (error) 2137 goto out; 2138 2139 error = xfs_init_workqueues(); 2140 if (error) 2141 goto out_destroy_zones; 2142 2143 error = xfs_mru_cache_init(); 2144 if (error) 2145 goto out_destroy_wq; 2146 2147 error = xfs_buf_init(); 2148 if (error) 2149 goto out_mru_cache_uninit; 2150 2151 error = xfs_init_procfs(); 2152 if (error) 2153 goto out_buf_terminate; 2154 2155 error = xfs_sysctl_register(); 2156 if (error) 2157 goto out_cleanup_procfs; 2158 2159 xfs_kset = kset_create_and_add("xfs", NULL, fs_kobj); 2160 if (!xfs_kset) { 2161 error = -ENOMEM; 2162 goto out_sysctl_unregister; 2163 } 2164 2165 xfsstats.xs_kobj.kobject.kset = xfs_kset; 2166 2167 xfsstats.xs_stats = alloc_percpu(struct xfsstats); 2168 if (!xfsstats.xs_stats) { 2169 error = -ENOMEM; 2170 goto out_kset_unregister; 2171 } 2172 2173 error = xfs_sysfs_init(&xfsstats.xs_kobj, &xfs_stats_ktype, NULL, 2174 "stats"); 2175 if (error) 2176 goto out_free_stats; 2177 2178 #ifdef DEBUG 2179 xfs_dbg_kobj.kobject.kset = xfs_kset; 2180 error = xfs_sysfs_init(&xfs_dbg_kobj, &xfs_dbg_ktype, NULL, "debug"); 2181 if (error) 2182 goto out_remove_stats_kobj; 2183 #endif 2184 2185 error = xfs_qm_init(); 2186 if (error) 2187 goto out_remove_dbg_kobj; 2188 2189 error = register_filesystem(&xfs_fs_type); 2190 if (error) 2191 goto out_qm_exit; 2192 return 0; 2193 2194 out_qm_exit: 2195 xfs_qm_exit(); 2196 out_remove_dbg_kobj: 2197 #ifdef DEBUG 2198 xfs_sysfs_del(&xfs_dbg_kobj); 2199 out_remove_stats_kobj: 2200 #endif 2201 xfs_sysfs_del(&xfsstats.xs_kobj); 2202 out_free_stats: 2203 free_percpu(xfsstats.xs_stats); 2204 out_kset_unregister: 2205 kset_unregister(xfs_kset); 2206 out_sysctl_unregister: 2207 xfs_sysctl_unregister(); 2208 out_cleanup_procfs: 2209 xfs_cleanup_procfs(); 2210 out_buf_terminate: 2211 xfs_buf_terminate(); 2212 out_mru_cache_uninit: 2213 xfs_mru_cache_uninit(); 2214 out_destroy_wq: 2215 xfs_destroy_workqueues(); 2216 out_destroy_zones: 2217 xfs_destroy_zones(); 2218 out: 2219 return error; 2220 } 2221 2222 STATIC void __exit 2223 exit_xfs_fs(void) 2224 { 2225 xfs_qm_exit(); 2226 unregister_filesystem(&xfs_fs_type); 2227 #ifdef DEBUG 2228 xfs_sysfs_del(&xfs_dbg_kobj); 2229 #endif 2230 xfs_sysfs_del(&xfsstats.xs_kobj); 2231 free_percpu(xfsstats.xs_stats); 2232 kset_unregister(xfs_kset); 2233 xfs_sysctl_unregister(); 2234 xfs_cleanup_procfs(); 2235 xfs_buf_terminate(); 2236 xfs_mru_cache_uninit(); 2237 xfs_destroy_workqueues(); 2238 xfs_destroy_zones(); 2239 xfs_uuid_table_free(); 2240 } 2241 2242 module_init(init_xfs_fs); 2243 module_exit(exit_xfs_fs); 2244 2245 MODULE_AUTHOR("Silicon Graphics, Inc."); 2246 MODULE_DESCRIPTION(XFS_VERSION_STRING " with " XFS_BUILD_OPTIONS " enabled"); 2247 MODULE_LICENSE("GPL"); 2248