xfs_filestream.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432
  1. /*
  2. * Copyright (c) 2006-2007 Silicon Graphics, Inc.
  3. * Copyright (c) 2014 Christoph Hellwig.
  4. * All Rights Reserved.
  5. *
  6. * This program is free software; you can redistribute it and/or
  7. * modify it under the terms of the GNU General Public License as
  8. * published by the Free Software Foundation.
  9. *
  10. * This program is distributed in the hope that it would be useful,
  11. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13. * GNU General Public License for more details.
  14. *
  15. * You should have received a copy of the GNU General Public License
  16. * along with this program; if not, write the Free Software Foundation,
  17. * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  18. */
  19. #include "xfs.h"
  20. #include "xfs_format.h"
  21. #include "xfs_log_format.h"
  22. #include "xfs_trans_resv.h"
  23. #include "xfs_sb.h"
  24. #include "xfs_mount.h"
  25. #include "xfs_inode.h"
  26. #include "xfs_bmap.h"
  27. #include "xfs_bmap_util.h"
  28. #include "xfs_alloc.h"
  29. #include "xfs_mru_cache.h"
  30. #include "xfs_filestream.h"
  31. #include "xfs_trace.h"
  32. struct xfs_fstrm_item {
  33. struct xfs_mru_cache_elem mru;
  34. struct xfs_inode *ip;
  35. xfs_agnumber_t ag; /* AG in use for this directory */
  36. };
  37. enum xfs_fstrm_alloc {
  38. XFS_PICK_USERDATA = 1,
  39. XFS_PICK_LOWSPACE = 2,
  40. };
  41. /*
  42. * Allocation group filestream associations are tracked with per-ag atomic
  43. * counters. These counters allow xfs_filestream_pick_ag() to tell whether a
  44. * particular AG already has active filestreams associated with it. The mount
  45. * point's m_peraglock is used to protect these counters from per-ag array
  46. * re-allocation during a growfs operation. When xfs_growfs_data_private() is
  47. * about to reallocate the array, it calls xfs_filestream_flush() with the
  48. * m_peraglock held in write mode.
  49. *
  50. * Since xfs_mru_cache_flush() guarantees that all the free functions for all
  51. * the cache elements have finished executing before it returns, it's safe for
  52. * the free functions to use the atomic counters without m_peraglock protection.
  53. * This allows the implementation of xfs_fstrm_free_func() to be agnostic about
  54. * whether it was called with the m_peraglock held in read mode, write mode or
  55. * not held at all. The race condition this addresses is the following:
  56. *
  57. * - The work queue scheduler fires and pulls a filestream directory cache
  58. * element off the LRU end of the cache for deletion, then gets pre-empted.
  59. * - A growfs operation grabs the m_peraglock in write mode, flushes all the
  60. * remaining items from the cache and reallocates the mount point's per-ag
  61. * array, resetting all the counters to zero.
  62. * - The work queue thread resumes and calls the free function for the element
  63. * it started cleaning up earlier. In the process it decrements the
  64. * filestreams counter for an AG that now has no references.
  65. *
  66. * With a shrinkfs feature, the above scenario could panic the system.
  67. *
  68. * All other uses of the following macros should be protected by either the
  69. * m_peraglock held in read mode, or the cache's internal locking exposed by the
  70. * interval between a call to xfs_mru_cache_lookup() and a call to
  71. * xfs_mru_cache_done(). In addition, the m_peraglock must be held in read mode
  72. * when new elements are added to the cache.
  73. *
  74. * Combined, these locking rules ensure that no associations will ever exist in
  75. * the cache that reference per-ag array elements that have since been
  76. * reallocated.
  77. */
  78. int
  79. xfs_filestream_peek_ag(
  80. xfs_mount_t *mp,
  81. xfs_agnumber_t agno)
  82. {
  83. struct xfs_perag *pag;
  84. int ret;
  85. pag = xfs_perag_get(mp, agno);
  86. ret = atomic_read(&pag->pagf_fstrms);
  87. xfs_perag_put(pag);
  88. return ret;
  89. }
  90. static int
  91. xfs_filestream_get_ag(
  92. xfs_mount_t *mp,
  93. xfs_agnumber_t agno)
  94. {
  95. struct xfs_perag *pag;
  96. int ret;
  97. pag = xfs_perag_get(mp, agno);
  98. ret = atomic_inc_return(&pag->pagf_fstrms);
  99. xfs_perag_put(pag);
  100. return ret;
  101. }
  102. static void
  103. xfs_filestream_put_ag(
  104. xfs_mount_t *mp,
  105. xfs_agnumber_t agno)
  106. {
  107. struct xfs_perag *pag;
  108. pag = xfs_perag_get(mp, agno);
  109. atomic_dec(&pag->pagf_fstrms);
  110. xfs_perag_put(pag);
  111. }
  112. static void
  113. xfs_fstrm_free_func(
  114. struct xfs_mru_cache_elem *mru)
  115. {
  116. struct xfs_fstrm_item *item =
  117. container_of(mru, struct xfs_fstrm_item, mru);
  118. xfs_filestream_put_ag(item->ip->i_mount, item->ag);
  119. trace_xfs_filestream_free(item->ip, item->ag);
  120. kmem_free(item);
  121. }
  122. /*
  123. * Scan the AGs starting at startag looking for an AG that isn't in use and has
  124. * at least minlen blocks free.
  125. */
  126. static int
  127. xfs_filestream_pick_ag(
  128. struct xfs_inode *ip,
  129. xfs_agnumber_t startag,
  130. xfs_agnumber_t *agp,
  131. int flags,
  132. xfs_extlen_t minlen)
  133. {
  134. struct xfs_mount *mp = ip->i_mount;
  135. struct xfs_fstrm_item *item;
  136. struct xfs_perag *pag;
  137. xfs_extlen_t longest, free = 0, minfree, maxfree = 0;
  138. xfs_agnumber_t ag, max_ag = NULLAGNUMBER;
  139. int err, trylock, nscan;
  140. ASSERT(S_ISDIR(ip->i_d.di_mode));
  141. /* 2% of an AG's blocks must be free for it to be chosen. */
  142. minfree = mp->m_sb.sb_agblocks / 50;
  143. ag = startag;
  144. *agp = NULLAGNUMBER;
  145. /* For the first pass, don't sleep trying to init the per-AG. */
  146. trylock = XFS_ALLOC_FLAG_TRYLOCK;
  147. for (nscan = 0; 1; nscan++) {
  148. trace_xfs_filestream_scan(ip, ag);
  149. pag = xfs_perag_get(mp, ag);
  150. if (!pag->pagf_init) {
  151. err = xfs_alloc_pagf_init(mp, NULL, ag, trylock);
  152. if (err && !trylock) {
  153. xfs_perag_put(pag);
  154. return err;
  155. }
  156. }
  157. /* Might fail sometimes during the 1st pass with trylock set. */
  158. if (!pag->pagf_init)
  159. goto next_ag;
  160. /* Keep track of the AG with the most free blocks. */
  161. if (pag->pagf_freeblks > maxfree) {
  162. maxfree = pag->pagf_freeblks;
  163. max_ag = ag;
  164. }
  165. /*
  166. * The AG reference count does two things: it enforces mutual
  167. * exclusion when examining the suitability of an AG in this
  168. * loop, and it guards against two filestreams being established
  169. * in the same AG as each other.
  170. */
  171. if (xfs_filestream_get_ag(mp, ag) > 1) {
  172. xfs_filestream_put_ag(mp, ag);
  173. goto next_ag;
  174. }
  175. longest = xfs_alloc_longest_free_extent(mp, pag,
  176. xfs_alloc_min_freelist(mp, pag));
  177. if (((minlen && longest >= minlen) ||
  178. (!minlen && pag->pagf_freeblks >= minfree)) &&
  179. (!pag->pagf_metadata || !(flags & XFS_PICK_USERDATA) ||
  180. (flags & XFS_PICK_LOWSPACE))) {
  181. /* Break out, retaining the reference on the AG. */
  182. free = pag->pagf_freeblks;
  183. xfs_perag_put(pag);
  184. *agp = ag;
  185. break;
  186. }
  187. /* Drop the reference on this AG, it's not usable. */
  188. xfs_filestream_put_ag(mp, ag);
  189. next_ag:
  190. xfs_perag_put(pag);
  191. /* Move to the next AG, wrapping to AG 0 if necessary. */
  192. if (++ag >= mp->m_sb.sb_agcount)
  193. ag = 0;
  194. /* If a full pass of the AGs hasn't been done yet, continue. */
  195. if (ag != startag)
  196. continue;
  197. /* Allow sleeping in xfs_alloc_pagf_init() on the 2nd pass. */
  198. if (trylock != 0) {
  199. trylock = 0;
  200. continue;
  201. }
  202. /* Finally, if lowspace wasn't set, set it for the 3rd pass. */
  203. if (!(flags & XFS_PICK_LOWSPACE)) {
  204. flags |= XFS_PICK_LOWSPACE;
  205. continue;
  206. }
  207. /*
  208. * Take the AG with the most free space, regardless of whether
  209. * it's already in use by another filestream.
  210. */
  211. if (max_ag != NULLAGNUMBER) {
  212. xfs_filestream_get_ag(mp, max_ag);
  213. free = maxfree;
  214. *agp = max_ag;
  215. break;
  216. }
  217. /* take AG 0 if none matched */
  218. trace_xfs_filestream_pick(ip, *agp, free, nscan);
  219. *agp = 0;
  220. return 0;
  221. }
  222. trace_xfs_filestream_pick(ip, *agp, free, nscan);
  223. if (*agp == NULLAGNUMBER)
  224. return 0;
  225. err = -ENOMEM;
  226. item = kmem_alloc(sizeof(*item), KM_MAYFAIL);
  227. if (!item)
  228. goto out_put_ag;
  229. item->ag = *agp;
  230. item->ip = ip;
  231. err = xfs_mru_cache_insert(mp->m_filestream, ip->i_ino, &item->mru);
  232. if (err) {
  233. if (err == -EEXIST)
  234. err = 0;
  235. goto out_free_item;
  236. }
  237. return 0;
  238. out_free_item:
  239. kmem_free(item);
  240. out_put_ag:
  241. xfs_filestream_put_ag(mp, *agp);
  242. return err;
  243. }
  244. static struct xfs_inode *
  245. xfs_filestream_get_parent(
  246. struct xfs_inode *ip)
  247. {
  248. struct inode *inode = VFS_I(ip), *dir = NULL;
  249. struct dentry *dentry, *parent;
  250. dentry = d_find_alias(inode);
  251. if (!dentry)
  252. goto out;
  253. parent = dget_parent(dentry);
  254. if (!parent)
  255. goto out_dput;
  256. dir = igrab(d_inode(parent));
  257. dput(parent);
  258. out_dput:
  259. dput(dentry);
  260. out:
  261. return dir ? XFS_I(dir) : NULL;
  262. }
  263. /*
  264. * Find the right allocation group for a file, either by finding an
  265. * existing file stream or creating a new one.
  266. *
  267. * Returns NULLAGNUMBER in case of an error.
  268. */
  269. xfs_agnumber_t
  270. xfs_filestream_lookup_ag(
  271. struct xfs_inode *ip)
  272. {
  273. struct xfs_mount *mp = ip->i_mount;
  274. struct xfs_inode *pip = NULL;
  275. xfs_agnumber_t startag, ag = NULLAGNUMBER;
  276. struct xfs_mru_cache_elem *mru;
  277. ASSERT(S_ISREG(ip->i_d.di_mode));
  278. pip = xfs_filestream_get_parent(ip);
  279. if (!pip)
  280. return NULLAGNUMBER;
  281. mru = xfs_mru_cache_lookup(mp->m_filestream, pip->i_ino);
  282. if (mru) {
  283. ag = container_of(mru, struct xfs_fstrm_item, mru)->ag;
  284. xfs_mru_cache_done(mp->m_filestream);
  285. trace_xfs_filestream_lookup(ip, ag);
  286. goto out;
  287. }
  288. /*
  289. * Set the starting AG using the rotor for inode32, otherwise
  290. * use the directory inode's AG.
  291. */
  292. if (mp->m_flags & XFS_MOUNT_32BITINODES) {
  293. xfs_agnumber_t rotorstep = xfs_rotorstep;
  294. startag = (mp->m_agfrotor / rotorstep) % mp->m_sb.sb_agcount;
  295. mp->m_agfrotor = (mp->m_agfrotor + 1) %
  296. (mp->m_sb.sb_agcount * rotorstep);
  297. } else
  298. startag = XFS_INO_TO_AGNO(mp, pip->i_ino);
  299. if (xfs_filestream_pick_ag(pip, startag, &ag, 0, 0))
  300. ag = NULLAGNUMBER;
  301. out:
  302. IRELE(pip);
  303. return ag;
  304. }
  305. /*
  306. * Pick a new allocation group for the current file and its file stream.
  307. *
  308. * This is called when the allocator can't find a suitable extent in the
  309. * current AG, and we have to move the stream into a new AG with more space.
  310. */
  311. int
  312. xfs_filestream_new_ag(
  313. struct xfs_bmalloca *ap,
  314. xfs_agnumber_t *agp)
  315. {
  316. struct xfs_inode *ip = ap->ip, *pip;
  317. struct xfs_mount *mp = ip->i_mount;
  318. xfs_extlen_t minlen = ap->length;
  319. xfs_agnumber_t startag = 0;
  320. int flags, err = 0;
  321. struct xfs_mru_cache_elem *mru;
  322. *agp = NULLAGNUMBER;
  323. pip = xfs_filestream_get_parent(ip);
  324. if (!pip)
  325. goto exit;
  326. mru = xfs_mru_cache_remove(mp->m_filestream, pip->i_ino);
  327. if (mru) {
  328. struct xfs_fstrm_item *item =
  329. container_of(mru, struct xfs_fstrm_item, mru);
  330. startag = (item->ag + 1) % mp->m_sb.sb_agcount;
  331. }
  332. flags = (ap->userdata ? XFS_PICK_USERDATA : 0) |
  333. (ap->flist->xbf_low ? XFS_PICK_LOWSPACE : 0);
  334. err = xfs_filestream_pick_ag(pip, startag, agp, flags, minlen);
  335. /*
  336. * Only free the item here so we skip over the old AG earlier.
  337. */
  338. if (mru)
  339. xfs_fstrm_free_func(mru);
  340. IRELE(pip);
  341. exit:
  342. if (*agp == NULLAGNUMBER)
  343. *agp = 0;
  344. return err;
  345. }
  346. void
  347. xfs_filestream_deassociate(
  348. struct xfs_inode *ip)
  349. {
  350. xfs_mru_cache_delete(ip->i_mount->m_filestream, ip->i_ino);
  351. }
  352. int
  353. xfs_filestream_mount(
  354. xfs_mount_t *mp)
  355. {
  356. /*
  357. * The filestream timer tunable is currently fixed within the range of
  358. * one second to four minutes, with five seconds being the default. The
  359. * group count is somewhat arbitrary, but it'd be nice to adhere to the
  360. * timer tunable to within about 10 percent. This requires at least 10
  361. * groups.
  362. */
  363. return xfs_mru_cache_create(&mp->m_filestream, xfs_fstrm_centisecs * 10,
  364. 10, xfs_fstrm_free_func);
  365. }
  366. void
  367. xfs_filestream_unmount(
  368. xfs_mount_t *mp)
  369. {
  370. xfs_mru_cache_destroy(mp->m_filestream);
  371. }