xfs_fsops.c 22 KB

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