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