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