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