xfs_fsops.c 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768
  1. /*
  2. * Copyright (c) 2000-2005 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. #include "xfs.h"
  19. #include "xfs_fs.h"
  20. #include "xfs_types.h"
  21. #include "xfs_log.h"
  22. #include "xfs_trans.h"
  23. #include "xfs_sb.h"
  24. #include "xfs_ag.h"
  25. #include "xfs_mount.h"
  26. #include "xfs_bmap_btree.h"
  27. #include "xfs_alloc_btree.h"
  28. #include "xfs_ialloc_btree.h"
  29. #include "xfs_dinode.h"
  30. #include "xfs_inode.h"
  31. #include "xfs_inode_item.h"
  32. #include "xfs_btree.h"
  33. #include "xfs_error.h"
  34. #include "xfs_alloc.h"
  35. #include "xfs_ialloc.h"
  36. #include "xfs_fsops.h"
  37. #include "xfs_itable.h"
  38. #include "xfs_trans_space.h"
  39. #include "xfs_rtalloc.h"
  40. #include "xfs_filestream.h"
  41. #include "xfs_trace.h"
  42. /*
  43. * File system operations
  44. */
  45. int
  46. xfs_fs_geometry(
  47. xfs_mount_t *mp,
  48. xfs_fsop_geom_t *geo,
  49. int new_version)
  50. {
  51. memset(geo, 0, sizeof(*geo));
  52. geo->blocksize = mp->m_sb.sb_blocksize;
  53. geo->rtextsize = mp->m_sb.sb_rextsize;
  54. geo->agblocks = mp->m_sb.sb_agblocks;
  55. geo->agcount = mp->m_sb.sb_agcount;
  56. geo->logblocks = mp->m_sb.sb_logblocks;
  57. geo->sectsize = mp->m_sb.sb_sectsize;
  58. geo->inodesize = mp->m_sb.sb_inodesize;
  59. geo->imaxpct = mp->m_sb.sb_imax_pct;
  60. geo->datablocks = mp->m_sb.sb_dblocks;
  61. geo->rtblocks = mp->m_sb.sb_rblocks;
  62. geo->rtextents = mp->m_sb.sb_rextents;
  63. geo->logstart = mp->m_sb.sb_logstart;
  64. ASSERT(sizeof(geo->uuid)==sizeof(mp->m_sb.sb_uuid));
  65. memcpy(geo->uuid, &mp->m_sb.sb_uuid, sizeof(mp->m_sb.sb_uuid));
  66. if (new_version >= 2) {
  67. geo->sunit = mp->m_sb.sb_unit;
  68. geo->swidth = mp->m_sb.sb_width;
  69. }
  70. if (new_version >= 3) {
  71. geo->version = XFS_FSOP_GEOM_VERSION;
  72. geo->flags =
  73. (xfs_sb_version_hasattr(&mp->m_sb) ?
  74. XFS_FSOP_GEOM_FLAGS_ATTR : 0) |
  75. (xfs_sb_version_hasnlink(&mp->m_sb) ?
  76. XFS_FSOP_GEOM_FLAGS_NLINK : 0) |
  77. (xfs_sb_version_hasquota(&mp->m_sb) ?
  78. XFS_FSOP_GEOM_FLAGS_QUOTA : 0) |
  79. (xfs_sb_version_hasalign(&mp->m_sb) ?
  80. XFS_FSOP_GEOM_FLAGS_IALIGN : 0) |
  81. (xfs_sb_version_hasdalign(&mp->m_sb) ?
  82. XFS_FSOP_GEOM_FLAGS_DALIGN : 0) |
  83. (xfs_sb_version_hasshared(&mp->m_sb) ?
  84. XFS_FSOP_GEOM_FLAGS_SHARED : 0) |
  85. (xfs_sb_version_hasextflgbit(&mp->m_sb) ?
  86. XFS_FSOP_GEOM_FLAGS_EXTFLG : 0) |
  87. (xfs_sb_version_hasdirv2(&mp->m_sb) ?
  88. XFS_FSOP_GEOM_FLAGS_DIRV2 : 0) |
  89. (xfs_sb_version_hassector(&mp->m_sb) ?
  90. XFS_FSOP_GEOM_FLAGS_SECTOR : 0) |
  91. (xfs_sb_version_hasasciici(&mp->m_sb) ?
  92. XFS_FSOP_GEOM_FLAGS_DIRV2CI : 0) |
  93. (xfs_sb_version_haslazysbcount(&mp->m_sb) ?
  94. XFS_FSOP_GEOM_FLAGS_LAZYSB : 0) |
  95. (xfs_sb_version_hasattr2(&mp->m_sb) ?
  96. XFS_FSOP_GEOM_FLAGS_ATTR2 : 0) |
  97. (xfs_sb_version_hasprojid32bit(&mp->m_sb) ?
  98. XFS_FSOP_GEOM_FLAGS_PROJID32 : 0);
  99. geo->logsectsize = xfs_sb_version_hassector(&mp->m_sb) ?
  100. mp->m_sb.sb_logsectsize : BBSIZE;
  101. geo->rtsectsize = mp->m_sb.sb_blocksize;
  102. geo->dirblocksize = mp->m_dirblksize;
  103. }
  104. if (new_version >= 4) {
  105. geo->flags |=
  106. (xfs_sb_version_haslogv2(&mp->m_sb) ?
  107. XFS_FSOP_GEOM_FLAGS_LOGV2 : 0);
  108. geo->logsunit = mp->m_sb.sb_logsunit;
  109. }
  110. return 0;
  111. }
  112. static int
  113. xfs_growfs_data_private(
  114. xfs_mount_t *mp, /* mount point for filesystem */
  115. xfs_growfs_data_t *in) /* growfs data input struct */
  116. {
  117. xfs_agf_t *agf;
  118. xfs_agi_t *agi;
  119. xfs_agnumber_t agno;
  120. xfs_extlen_t agsize;
  121. xfs_extlen_t tmpsize;
  122. xfs_alloc_rec_t *arec;
  123. struct xfs_btree_block *block;
  124. xfs_buf_t *bp;
  125. int bucket;
  126. int dpct;
  127. int error;
  128. xfs_agnumber_t nagcount;
  129. xfs_agnumber_t nagimax = 0;
  130. xfs_rfsblock_t nb, nb_mod;
  131. xfs_rfsblock_t new;
  132. xfs_rfsblock_t nfree;
  133. xfs_agnumber_t oagcount;
  134. int pct;
  135. xfs_trans_t *tp;
  136. nb = in->newblocks;
  137. pct = in->imaxpct;
  138. if (nb < mp->m_sb.sb_dblocks || pct < 0 || pct > 100)
  139. return XFS_ERROR(EINVAL);
  140. if ((error = xfs_sb_validate_fsb_count(&mp->m_sb, nb)))
  141. return error;
  142. dpct = pct - mp->m_sb.sb_imax_pct;
  143. bp = xfs_buf_read_uncached(mp->m_ddev_targp,
  144. XFS_FSB_TO_BB(mp, nb) - XFS_FSS_TO_BB(mp, 1),
  145. XFS_FSS_TO_BB(mp, 1), 0);
  146. if (!bp)
  147. return EIO;
  148. xfs_buf_relse(bp);
  149. new = nb; /* use new as a temporary here */
  150. nb_mod = do_div(new, mp->m_sb.sb_agblocks);
  151. nagcount = new + (nb_mod != 0);
  152. if (nb_mod && nb_mod < XFS_MIN_AG_BLOCKS) {
  153. nagcount--;
  154. nb = (xfs_rfsblock_t)nagcount * mp->m_sb.sb_agblocks;
  155. if (nb < mp->m_sb.sb_dblocks)
  156. return XFS_ERROR(EINVAL);
  157. }
  158. new = nb - mp->m_sb.sb_dblocks;
  159. oagcount = mp->m_sb.sb_agcount;
  160. /* allocate the new per-ag structures */
  161. if (nagcount > oagcount) {
  162. error = xfs_initialize_perag(mp, nagcount, &nagimax);
  163. if (error)
  164. return error;
  165. }
  166. tp = xfs_trans_alloc(mp, XFS_TRANS_GROWFS);
  167. tp->t_flags |= XFS_TRANS_RESERVE;
  168. if ((error = xfs_trans_reserve(tp, XFS_GROWFS_SPACE_RES(mp),
  169. XFS_GROWDATA_LOG_RES(mp), 0, 0, 0))) {
  170. xfs_trans_cancel(tp, 0);
  171. return error;
  172. }
  173. /*
  174. * Write new AG headers to disk. Non-transactional, but written
  175. * synchronously so they are completed prior to the growfs transaction
  176. * being logged.
  177. */
  178. nfree = 0;
  179. for (agno = nagcount - 1; agno >= oagcount; agno--, new -= agsize) {
  180. /*
  181. * AG freelist header block
  182. */
  183. bp = xfs_buf_get(mp->m_ddev_targp,
  184. XFS_AG_DADDR(mp, agno, XFS_AGF_DADDR(mp)),
  185. XFS_FSS_TO_BB(mp, 1), 0);
  186. if (!bp) {
  187. error = ENOMEM;
  188. goto error0;
  189. }
  190. agf = XFS_BUF_TO_AGF(bp);
  191. memset(agf, 0, mp->m_sb.sb_sectsize);
  192. agf->agf_magicnum = cpu_to_be32(XFS_AGF_MAGIC);
  193. agf->agf_versionnum = cpu_to_be32(XFS_AGF_VERSION);
  194. agf->agf_seqno = cpu_to_be32(agno);
  195. if (agno == nagcount - 1)
  196. agsize =
  197. nb -
  198. (agno * (xfs_rfsblock_t)mp->m_sb.sb_agblocks);
  199. else
  200. agsize = mp->m_sb.sb_agblocks;
  201. agf->agf_length = cpu_to_be32(agsize);
  202. agf->agf_roots[XFS_BTNUM_BNOi] = cpu_to_be32(XFS_BNO_BLOCK(mp));
  203. agf->agf_roots[XFS_BTNUM_CNTi] = cpu_to_be32(XFS_CNT_BLOCK(mp));
  204. agf->agf_levels[XFS_BTNUM_BNOi] = cpu_to_be32(1);
  205. agf->agf_levels[XFS_BTNUM_CNTi] = cpu_to_be32(1);
  206. agf->agf_flfirst = 0;
  207. agf->agf_fllast = cpu_to_be32(XFS_AGFL_SIZE(mp) - 1);
  208. agf->agf_flcount = 0;
  209. tmpsize = agsize - XFS_PREALLOC_BLOCKS(mp);
  210. agf->agf_freeblks = cpu_to_be32(tmpsize);
  211. agf->agf_longest = cpu_to_be32(tmpsize);
  212. error = xfs_bwrite(bp);
  213. xfs_buf_relse(bp);
  214. if (error)
  215. goto error0;
  216. /*
  217. * AG inode header block
  218. */
  219. bp = xfs_buf_get(mp->m_ddev_targp,
  220. XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
  221. XFS_FSS_TO_BB(mp, 1), 0);
  222. if (!bp) {
  223. error = ENOMEM;
  224. goto error0;
  225. }
  226. agi = XFS_BUF_TO_AGI(bp);
  227. memset(agi, 0, mp->m_sb.sb_sectsize);
  228. agi->agi_magicnum = cpu_to_be32(XFS_AGI_MAGIC);
  229. agi->agi_versionnum = cpu_to_be32(XFS_AGI_VERSION);
  230. agi->agi_seqno = cpu_to_be32(agno);
  231. agi->agi_length = cpu_to_be32(agsize);
  232. agi->agi_count = 0;
  233. agi->agi_root = cpu_to_be32(XFS_IBT_BLOCK(mp));
  234. agi->agi_level = cpu_to_be32(1);
  235. agi->agi_freecount = 0;
  236. agi->agi_newino = cpu_to_be32(NULLAGINO);
  237. agi->agi_dirino = cpu_to_be32(NULLAGINO);
  238. for (bucket = 0; bucket < XFS_AGI_UNLINKED_BUCKETS; bucket++)
  239. agi->agi_unlinked[bucket] = cpu_to_be32(NULLAGINO);
  240. error = xfs_bwrite(bp);
  241. xfs_buf_relse(bp);
  242. if (error)
  243. goto error0;
  244. /*
  245. * BNO btree root block
  246. */
  247. bp = xfs_buf_get(mp->m_ddev_targp,
  248. XFS_AGB_TO_DADDR(mp, agno, XFS_BNO_BLOCK(mp)),
  249. BTOBB(mp->m_sb.sb_blocksize), 0);
  250. if (!bp) {
  251. error = ENOMEM;
  252. goto error0;
  253. }
  254. block = XFS_BUF_TO_BLOCK(bp);
  255. memset(block, 0, mp->m_sb.sb_blocksize);
  256. block->bb_magic = cpu_to_be32(XFS_ABTB_MAGIC);
  257. block->bb_level = 0;
  258. block->bb_numrecs = cpu_to_be16(1);
  259. block->bb_u.s.bb_leftsib = cpu_to_be32(NULLAGBLOCK);
  260. block->bb_u.s.bb_rightsib = cpu_to_be32(NULLAGBLOCK);
  261. arec = XFS_ALLOC_REC_ADDR(mp, block, 1);
  262. arec->ar_startblock = cpu_to_be32(XFS_PREALLOC_BLOCKS(mp));
  263. arec->ar_blockcount = cpu_to_be32(
  264. agsize - be32_to_cpu(arec->ar_startblock));
  265. error = xfs_bwrite(bp);
  266. xfs_buf_relse(bp);
  267. if (error)
  268. goto error0;
  269. /*
  270. * CNT btree root block
  271. */
  272. bp = xfs_buf_get(mp->m_ddev_targp,
  273. XFS_AGB_TO_DADDR(mp, agno, XFS_CNT_BLOCK(mp)),
  274. BTOBB(mp->m_sb.sb_blocksize), 0);
  275. if (!bp) {
  276. error = ENOMEM;
  277. goto error0;
  278. }
  279. block = XFS_BUF_TO_BLOCK(bp);
  280. memset(block, 0, mp->m_sb.sb_blocksize);
  281. block->bb_magic = cpu_to_be32(XFS_ABTC_MAGIC);
  282. block->bb_level = 0;
  283. block->bb_numrecs = cpu_to_be16(1);
  284. block->bb_u.s.bb_leftsib = cpu_to_be32(NULLAGBLOCK);
  285. block->bb_u.s.bb_rightsib = cpu_to_be32(NULLAGBLOCK);
  286. arec = XFS_ALLOC_REC_ADDR(mp, block, 1);
  287. arec->ar_startblock = cpu_to_be32(XFS_PREALLOC_BLOCKS(mp));
  288. arec->ar_blockcount = cpu_to_be32(
  289. agsize - be32_to_cpu(arec->ar_startblock));
  290. nfree += be32_to_cpu(arec->ar_blockcount);
  291. error = xfs_bwrite(bp);
  292. xfs_buf_relse(bp);
  293. if (error)
  294. goto error0;
  295. /*
  296. * INO btree root block
  297. */
  298. bp = xfs_buf_get(mp->m_ddev_targp,
  299. XFS_AGB_TO_DADDR(mp, agno, XFS_IBT_BLOCK(mp)),
  300. BTOBB(mp->m_sb.sb_blocksize), 0);
  301. if (!bp) {
  302. error = ENOMEM;
  303. goto error0;
  304. }
  305. block = XFS_BUF_TO_BLOCK(bp);
  306. memset(block, 0, mp->m_sb.sb_blocksize);
  307. block->bb_magic = cpu_to_be32(XFS_IBT_MAGIC);
  308. block->bb_level = 0;
  309. block->bb_numrecs = 0;
  310. block->bb_u.s.bb_leftsib = cpu_to_be32(NULLAGBLOCK);
  311. block->bb_u.s.bb_rightsib = cpu_to_be32(NULLAGBLOCK);
  312. error = xfs_bwrite(bp);
  313. xfs_buf_relse(bp);
  314. if (error)
  315. goto error0;
  316. }
  317. xfs_trans_agblocks_delta(tp, nfree);
  318. /*
  319. * There are new blocks in the old last a.g.
  320. */
  321. if (new) {
  322. /*
  323. * Change the agi length.
  324. */
  325. error = xfs_ialloc_read_agi(mp, tp, agno, &bp);
  326. if (error) {
  327. goto error0;
  328. }
  329. ASSERT(bp);
  330. agi = XFS_BUF_TO_AGI(bp);
  331. be32_add_cpu(&agi->agi_length, new);
  332. ASSERT(nagcount == oagcount ||
  333. be32_to_cpu(agi->agi_length) == mp->m_sb.sb_agblocks);
  334. xfs_ialloc_log_agi(tp, bp, XFS_AGI_LENGTH);
  335. /*
  336. * Change agf length.
  337. */
  338. error = xfs_alloc_read_agf(mp, tp, agno, 0, &bp);
  339. if (error) {
  340. goto error0;
  341. }
  342. ASSERT(bp);
  343. agf = XFS_BUF_TO_AGF(bp);
  344. be32_add_cpu(&agf->agf_length, new);
  345. ASSERT(be32_to_cpu(agf->agf_length) ==
  346. be32_to_cpu(agi->agi_length));
  347. xfs_alloc_log_agf(tp, bp, XFS_AGF_LENGTH);
  348. /*
  349. * Free the new space.
  350. */
  351. error = xfs_free_extent(tp, XFS_AGB_TO_FSB(mp, agno,
  352. be32_to_cpu(agf->agf_length) - new), new);
  353. if (error) {
  354. goto error0;
  355. }
  356. }
  357. /*
  358. * Update changed superblock fields transactionally. These are not
  359. * seen by the rest of the world until the transaction commit applies
  360. * them atomically to the superblock.
  361. */
  362. if (nagcount > oagcount)
  363. xfs_trans_mod_sb(tp, XFS_TRANS_SB_AGCOUNT, nagcount - oagcount);
  364. if (nb > mp->m_sb.sb_dblocks)
  365. xfs_trans_mod_sb(tp, XFS_TRANS_SB_DBLOCKS,
  366. nb - mp->m_sb.sb_dblocks);
  367. if (nfree)
  368. xfs_trans_mod_sb(tp, XFS_TRANS_SB_FDBLOCKS, nfree);
  369. if (dpct)
  370. xfs_trans_mod_sb(tp, XFS_TRANS_SB_IMAXPCT, dpct);
  371. error = xfs_trans_commit(tp, 0);
  372. if (error)
  373. return error;
  374. /* New allocation groups fully initialized, so update mount struct */
  375. if (nagimax)
  376. mp->m_maxagi = nagimax;
  377. if (mp->m_sb.sb_imax_pct) {
  378. __uint64_t icount = mp->m_sb.sb_dblocks * mp->m_sb.sb_imax_pct;
  379. do_div(icount, 100);
  380. mp->m_maxicount = icount << mp->m_sb.sb_inopblog;
  381. } else
  382. mp->m_maxicount = 0;
  383. xfs_set_low_space_thresholds(mp);
  384. /* update secondary superblocks. */
  385. for (agno = 1; agno < nagcount; agno++) {
  386. error = 0;
  387. /*
  388. * new secondary superblocks need to be zeroed, not read from
  389. * disk as the contents of the new area we are growing into is
  390. * completely unknown.
  391. */
  392. if (agno < oagcount) {
  393. error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,
  394. XFS_AGB_TO_DADDR(mp, agno, XFS_SB_BLOCK(mp)),
  395. XFS_FSS_TO_BB(mp, 1), 0, &bp);
  396. } else {
  397. bp = xfs_trans_get_buf(NULL, mp->m_ddev_targp,
  398. XFS_AGB_TO_DADDR(mp, agno, XFS_SB_BLOCK(mp)),
  399. XFS_FSS_TO_BB(mp, 1), 0);
  400. if (bp)
  401. xfs_buf_zero(bp, 0, BBTOB(bp->b_length));
  402. else
  403. error = ENOMEM;
  404. }
  405. if (error) {
  406. xfs_warn(mp,
  407. "error %d reading secondary superblock for ag %d",
  408. error, agno);
  409. break;
  410. }
  411. xfs_sb_to_disk(XFS_BUF_TO_SBP(bp), &mp->m_sb, XFS_SB_ALL_BITS);
  412. /*
  413. * If we get an error writing out the alternate superblocks,
  414. * just issue a warning and continue. The real work is
  415. * already done and committed.
  416. */
  417. error = xfs_bwrite(bp);
  418. xfs_buf_relse(bp);
  419. if (error) {
  420. xfs_warn(mp,
  421. "write error %d updating secondary superblock for ag %d",
  422. error, agno);
  423. break; /* no point in continuing */
  424. }
  425. }
  426. return error;
  427. error0:
  428. xfs_trans_cancel(tp, XFS_TRANS_ABORT);
  429. return error;
  430. }
  431. static int
  432. xfs_growfs_log_private(
  433. xfs_mount_t *mp, /* mount point for filesystem */
  434. xfs_growfs_log_t *in) /* growfs log input struct */
  435. {
  436. xfs_extlen_t nb;
  437. nb = in->newblocks;
  438. if (nb < XFS_MIN_LOG_BLOCKS || nb < XFS_B_TO_FSB(mp, XFS_MIN_LOG_BYTES))
  439. return XFS_ERROR(EINVAL);
  440. if (nb == mp->m_sb.sb_logblocks &&
  441. in->isint == (mp->m_sb.sb_logstart != 0))
  442. return XFS_ERROR(EINVAL);
  443. /*
  444. * Moving the log is hard, need new interfaces to sync
  445. * the log first, hold off all activity while moving it.
  446. * Can have shorter or longer log in the same space,
  447. * or transform internal to external log or vice versa.
  448. */
  449. return XFS_ERROR(ENOSYS);
  450. }
  451. /*
  452. * protected versions of growfs function acquire and release locks on the mount
  453. * point - exported through ioctls: XFS_IOC_FSGROWFSDATA, XFS_IOC_FSGROWFSLOG,
  454. * XFS_IOC_FSGROWFSRT
  455. */
  456. int
  457. xfs_growfs_data(
  458. xfs_mount_t *mp,
  459. xfs_growfs_data_t *in)
  460. {
  461. int error;
  462. if (!capable(CAP_SYS_ADMIN))
  463. return XFS_ERROR(EPERM);
  464. if (!mutex_trylock(&mp->m_growlock))
  465. return XFS_ERROR(EWOULDBLOCK);
  466. error = xfs_growfs_data_private(mp, in);
  467. mutex_unlock(&mp->m_growlock);
  468. return error;
  469. }
  470. int
  471. xfs_growfs_log(
  472. xfs_mount_t *mp,
  473. xfs_growfs_log_t *in)
  474. {
  475. int error;
  476. if (!capable(CAP_SYS_ADMIN))
  477. return XFS_ERROR(EPERM);
  478. if (!mutex_trylock(&mp->m_growlock))
  479. return XFS_ERROR(EWOULDBLOCK);
  480. error = xfs_growfs_log_private(mp, in);
  481. mutex_unlock(&mp->m_growlock);
  482. return error;
  483. }
  484. /*
  485. * exported through ioctl XFS_IOC_FSCOUNTS
  486. */
  487. int
  488. xfs_fs_counts(
  489. xfs_mount_t *mp,
  490. xfs_fsop_counts_t *cnt)
  491. {
  492. xfs_icsb_sync_counters(mp, XFS_ICSB_LAZY_COUNT);
  493. spin_lock(&mp->m_sb_lock);
  494. cnt->freedata = mp->m_sb.sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
  495. cnt->freertx = mp->m_sb.sb_frextents;
  496. cnt->freeino = mp->m_sb.sb_ifree;
  497. cnt->allocino = mp->m_sb.sb_icount;
  498. spin_unlock(&mp->m_sb_lock);
  499. return 0;
  500. }
  501. /*
  502. * exported through ioctl XFS_IOC_SET_RESBLKS & XFS_IOC_GET_RESBLKS
  503. *
  504. * xfs_reserve_blocks is called to set m_resblks
  505. * in the in-core mount table. The number of unused reserved blocks
  506. * is kept in m_resblks_avail.
  507. *
  508. * Reserve the requested number of blocks if available. Otherwise return
  509. * as many as possible to satisfy the request. The actual number
  510. * reserved are returned in outval
  511. *
  512. * A null inval pointer indicates that only the current reserved blocks
  513. * available should be returned no settings are changed.
  514. */
  515. int
  516. xfs_reserve_blocks(
  517. xfs_mount_t *mp,
  518. __uint64_t *inval,
  519. xfs_fsop_resblks_t *outval)
  520. {
  521. __int64_t lcounter, delta, fdblks_delta;
  522. __uint64_t request;
  523. /* If inval is null, report current values and return */
  524. if (inval == (__uint64_t *)NULL) {
  525. if (!outval)
  526. return EINVAL;
  527. outval->resblks = mp->m_resblks;
  528. outval->resblks_avail = mp->m_resblks_avail;
  529. return 0;
  530. }
  531. request = *inval;
  532. /*
  533. * With per-cpu counters, this becomes an interesting
  534. * problem. we needto work out if we are freeing or allocation
  535. * blocks first, then we can do the modification as necessary.
  536. *
  537. * We do this under the m_sb_lock so that if we are near
  538. * ENOSPC, we will hold out any changes while we work out
  539. * what to do. This means that the amount of free space can
  540. * change while we do this, so we need to retry if we end up
  541. * trying to reserve more space than is available.
  542. *
  543. * We also use the xfs_mod_incore_sb() interface so that we
  544. * don't have to care about whether per cpu counter are
  545. * enabled, disabled or even compiled in....
  546. */
  547. retry:
  548. spin_lock(&mp->m_sb_lock);
  549. xfs_icsb_sync_counters_locked(mp, 0);
  550. /*
  551. * If our previous reservation was larger than the current value,
  552. * then move any unused blocks back to the free pool.
  553. */
  554. fdblks_delta = 0;
  555. if (mp->m_resblks > request) {
  556. lcounter = mp->m_resblks_avail - request;
  557. if (lcounter > 0) { /* release unused blocks */
  558. fdblks_delta = lcounter;
  559. mp->m_resblks_avail -= lcounter;
  560. }
  561. mp->m_resblks = request;
  562. } else {
  563. __int64_t free;
  564. free = mp->m_sb.sb_fdblocks - XFS_ALLOC_SET_ASIDE(mp);
  565. if (!free)
  566. goto out; /* ENOSPC and fdblks_delta = 0 */
  567. delta = request - mp->m_resblks;
  568. lcounter = free - delta;
  569. if (lcounter < 0) {
  570. /* We can't satisfy the request, just get what we can */
  571. mp->m_resblks += free;
  572. mp->m_resblks_avail += free;
  573. fdblks_delta = -free;
  574. } else {
  575. fdblks_delta = -delta;
  576. mp->m_resblks = request;
  577. mp->m_resblks_avail += delta;
  578. }
  579. }
  580. out:
  581. if (outval) {
  582. outval->resblks = mp->m_resblks;
  583. outval->resblks_avail = mp->m_resblks_avail;
  584. }
  585. spin_unlock(&mp->m_sb_lock);
  586. if (fdblks_delta) {
  587. /*
  588. * If we are putting blocks back here, m_resblks_avail is
  589. * already at its max so this will put it in the free pool.
  590. *
  591. * If we need space, we'll either succeed in getting it
  592. * from the free block count or we'll get an enospc. If
  593. * we get a ENOSPC, it means things changed while we were
  594. * calculating fdblks_delta and so we should try again to
  595. * see if there is anything left to reserve.
  596. *
  597. * Don't set the reserved flag here - we don't want to reserve
  598. * the extra reserve blocks from the reserve.....
  599. */
  600. int error;
  601. error = xfs_icsb_modify_counters(mp, XFS_SBS_FDBLOCKS,
  602. fdblks_delta, 0);
  603. if (error == ENOSPC)
  604. goto retry;
  605. }
  606. return 0;
  607. }
  608. /*
  609. * Dump a transaction into the log that contains no real change. This is needed
  610. * to be able to make the log dirty or stamp the current tail LSN into the log
  611. * during the covering operation.
  612. *
  613. * We cannot use an inode here for this - that will push dirty state back up
  614. * into the VFS and then periodic inode flushing will prevent log covering from
  615. * making progress. Hence we log a field in the superblock instead and use a
  616. * synchronous transaction to ensure the superblock is immediately unpinned
  617. * and can be written back.
  618. */
  619. int
  620. xfs_fs_log_dummy(
  621. xfs_mount_t *mp)
  622. {
  623. xfs_trans_t *tp;
  624. int error;
  625. tp = _xfs_trans_alloc(mp, XFS_TRANS_DUMMY1, KM_SLEEP);
  626. error = xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0,
  627. XFS_DEFAULT_LOG_COUNT);
  628. if (error) {
  629. xfs_trans_cancel(tp, 0);
  630. return error;
  631. }
  632. /* log the UUID because it is an unchanging field */
  633. xfs_mod_sb(tp, XFS_SB_UUID);
  634. xfs_trans_set_sync(tp);
  635. return xfs_trans_commit(tp, 0);
  636. }
  637. int
  638. xfs_fs_goingdown(
  639. xfs_mount_t *mp,
  640. __uint32_t inflags)
  641. {
  642. switch (inflags) {
  643. case XFS_FSOP_GOING_FLAGS_DEFAULT: {
  644. struct super_block *sb = freeze_bdev(mp->m_super->s_bdev);
  645. if (sb && !IS_ERR(sb)) {
  646. xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
  647. thaw_bdev(sb->s_bdev, sb);
  648. }
  649. break;
  650. }
  651. case XFS_FSOP_GOING_FLAGS_LOGFLUSH:
  652. xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
  653. break;
  654. case XFS_FSOP_GOING_FLAGS_NOLOGFLUSH:
  655. xfs_force_shutdown(mp,
  656. SHUTDOWN_FORCE_UMOUNT | SHUTDOWN_LOG_IO_ERROR);
  657. break;
  658. default:
  659. return XFS_ERROR(EINVAL);
  660. }
  661. return 0;
  662. }
  663. /*
  664. * Force a shutdown of the filesystem instantly while keeping the filesystem
  665. * consistent. We don't do an unmount here; just shutdown the shop, make sure
  666. * that absolutely nothing persistent happens to this filesystem after this
  667. * point.
  668. */
  669. void
  670. xfs_do_force_shutdown(
  671. xfs_mount_t *mp,
  672. int flags,
  673. char *fname,
  674. int lnnum)
  675. {
  676. int logerror;
  677. logerror = flags & SHUTDOWN_LOG_IO_ERROR;
  678. if (!(flags & SHUTDOWN_FORCE_UMOUNT)) {
  679. xfs_notice(mp,
  680. "%s(0x%x) called from line %d of file %s. Return address = 0x%p",
  681. __func__, flags, lnnum, fname, __return_address);
  682. }
  683. /*
  684. * No need to duplicate efforts.
  685. */
  686. if (XFS_FORCED_SHUTDOWN(mp) && !logerror)
  687. return;
  688. /*
  689. * This flags XFS_MOUNT_FS_SHUTDOWN, makes sure that we don't
  690. * queue up anybody new on the log reservations, and wakes up
  691. * everybody who's sleeping on log reservations to tell them
  692. * the bad news.
  693. */
  694. if (xfs_log_force_umount(mp, logerror))
  695. return;
  696. if (flags & SHUTDOWN_CORRUPT_INCORE) {
  697. xfs_alert_tag(mp, XFS_PTAG_SHUTDOWN_CORRUPT,
  698. "Corruption of in-memory data detected. Shutting down filesystem");
  699. if (XFS_ERRLEVEL_HIGH <= xfs_error_level)
  700. xfs_stack_trace();
  701. } else if (!(flags & SHUTDOWN_FORCE_UMOUNT)) {
  702. if (logerror) {
  703. xfs_alert_tag(mp, XFS_PTAG_SHUTDOWN_LOGERROR,
  704. "Log I/O Error Detected. Shutting down filesystem");
  705. } else if (flags & SHUTDOWN_DEVICE_REQ) {
  706. xfs_alert_tag(mp, XFS_PTAG_SHUTDOWN_IOERROR,
  707. "All device paths lost. Shutting down filesystem");
  708. } else if (!(flags & SHUTDOWN_REMOTE_REQ)) {
  709. xfs_alert_tag(mp, XFS_PTAG_SHUTDOWN_IOERROR,
  710. "I/O Error Detected. Shutting down filesystem");
  711. }
  712. }
  713. if (!(flags & SHUTDOWN_FORCE_UMOUNT)) {
  714. xfs_alert(mp,
  715. "Please umount the filesystem and rectify the problem(s)");
  716. }
  717. }