Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0
2 : /*
3 : * Copyright (c) 2006-2007 Silicon Graphics, Inc.
4 : * Copyright (c) 2014 Christoph Hellwig.
5 : * All Rights Reserved.
6 : */
7 : #include "xfs.h"
8 : #include "xfs_shared.h"
9 : #include "xfs_format.h"
10 : #include "xfs_log_format.h"
11 : #include "xfs_trans_resv.h"
12 : #include "xfs_mount.h"
13 : #include "xfs_inode.h"
14 : #include "xfs_bmap.h"
15 : #include "xfs_bmap_util.h"
16 : #include "xfs_alloc.h"
17 : #include "xfs_mru_cache.h"
18 : #include "xfs_trace.h"
19 : #include "xfs_ag.h"
20 : #include "xfs_ag_resv.h"
21 : #include "xfs_trans.h"
22 : #include "xfs_filestream.h"
23 :
24 : struct xfs_fstrm_item {
25 : struct xfs_mru_cache_elem mru;
26 : struct xfs_perag *pag; /* AG in use for this directory */
27 : };
28 :
29 : enum xfs_fstrm_alloc {
30 : XFS_PICK_USERDATA = 1,
31 : XFS_PICK_LOWSPACE = 2,
32 : };
33 :
34 : static void
35 1670 : xfs_fstrm_free_func(
36 : void *data,
37 : struct xfs_mru_cache_elem *mru)
38 : {
39 1670 : struct xfs_fstrm_item *item =
40 1670 : container_of(mru, struct xfs_fstrm_item, mru);
41 1670 : struct xfs_perag *pag = item->pag;
42 :
43 1670 : trace_xfs_filestream_free(pag, mru->key);
44 1670 : atomic_dec(&pag->pagf_fstrms);
45 1670 : xfs_perag_rele(pag);
46 :
47 1670 : kmem_free(item);
48 1670 : }
49 :
50 : /*
51 : * Scan the AGs starting at start_agno looking for an AG that isn't in use and
52 : * has at least minlen blocks free. If no AG is found to match the allocation
53 : * requirements, pick the AG with the most free space in it.
54 : */
55 : static int
56 1669 : xfs_filestream_pick_ag(
57 : struct xfs_alloc_arg *args,
58 : xfs_ino_t pino,
59 : xfs_agnumber_t start_agno,
60 : int flags,
61 : xfs_extlen_t *longest)
62 : {
63 1669 : struct xfs_mount *mp = args->mp;
64 1669 : struct xfs_perag *pag;
65 1669 : struct xfs_perag *max_pag = NULL;
66 1669 : xfs_extlen_t minlen = *longest;
67 1669 : xfs_extlen_t free = 0, minfree, maxfree = 0;
68 1669 : xfs_agnumber_t agno;
69 1669 : bool first_pass = true;
70 1669 : int err;
71 :
72 : /* 2% of an AG's blocks must be free for it to be chosen. */
73 1669 : minfree = mp->m_sb.sb_agblocks / 50;
74 :
75 : restart:
76 77531 : for_each_perag_wrap(mp, start_agno, agno, pag) {
77 76236 : trace_xfs_filestream_scan(pag, pino);
78 76236 : *longest = 0;
79 76236 : err = xfs_bmap_longest_free_extent(pag, NULL, longest);
80 76235 : if (err) {
81 0 : if (err != -EAGAIN)
82 : break;
83 : /* Couldn't lock the AGF, skip this AG. */
84 0 : err = 0;
85 0 : continue;
86 : }
87 :
88 : /* Keep track of the AG with the most free blocks. */
89 76235 : if (pag->pagf_freeblks > maxfree) {
90 5185 : maxfree = pag->pagf_freeblks;
91 5185 : if (max_pag)
92 3516 : xfs_perag_rele(max_pag);
93 5185 : atomic_inc(&pag->pag_active_ref);
94 : max_pag = pag;
95 : }
96 :
97 : /*
98 : * The AG reference count does two things: it enforces mutual
99 : * exclusion when examining the suitability of an AG in this
100 : * loop, and it guards against two filestreams being established
101 : * in the same AG as each other.
102 : */
103 152471 : if (atomic_inc_return(&pag->pagf_fstrms) <= 1) {
104 59798 : if (((minlen && *longest >= minlen) ||
105 1237 : (!minlen && pag->pagf_freeblks >= minfree)) &&
106 : (!xfs_perag_prefers_metadata(pag) ||
107 0 : !(flags & XFS_PICK_USERDATA) ||
108 : (flags & XFS_PICK_LOWSPACE))) {
109 : /* Break out, retaining the reference on the AG. */
110 1238 : free = pag->pagf_freeblks;
111 1238 : break;
112 : }
113 : }
114 :
115 : /* Drop the reference on this AG, it's not usable. */
116 74997 : atomic_dec(&pag->pagf_fstrms);
117 : }
118 :
119 2534 : if (err) {
120 0 : xfs_perag_rele(pag);
121 0 : if (max_pag)
122 0 : xfs_perag_rele(max_pag);
123 0 : return err;
124 : }
125 :
126 2534 : if (!pag) {
127 : /*
128 : * Allow a second pass to give xfs_bmap_longest_free_extent()
129 : * another attempt at locking AGFs that it might have skipped
130 : * over before we fail.
131 : */
132 1296 : if (first_pass) {
133 432 : first_pass = false;
134 432 : goto restart;
135 : }
136 :
137 : /*
138 : * We must be low on data space, so run a final lowspace
139 : * optimised selection pass if we haven't already.
140 : */
141 864 : if (!(flags & XFS_PICK_LOWSPACE)) {
142 432 : flags |= XFS_PICK_LOWSPACE;
143 432 : goto restart;
144 : }
145 :
146 : /*
147 : * No unassociated AGs are available, so select the AG with the
148 : * most free space, regardless of whether it's already in use by
149 : * another filestream. It none suit, just use whatever AG we can
150 : * grab.
151 : */
152 432 : if (!max_pag) {
153 0 : for_each_perag_wrap(args->mp, 0, start_agno, args->pag)
154 : break;
155 0 : atomic_inc(&args->pag->pagf_fstrms);
156 0 : *longest = 0;
157 : } else {
158 432 : pag = max_pag;
159 432 : free = maxfree;
160 432 : atomic_inc(&pag->pagf_fstrms);
161 : }
162 1238 : } else if (max_pag) {
163 1238 : xfs_perag_rele(max_pag);
164 : }
165 :
166 1669 : trace_xfs_filestream_pick(pag, pino, free);
167 1669 : args->pag = pag;
168 1669 : return 0;
169 :
170 : }
171 :
172 : static struct xfs_inode *
173 11220 : xfs_filestream_get_parent(
174 : struct xfs_inode *ip)
175 : {
176 11220 : struct inode *inode = VFS_I(ip), *dir = NULL;
177 11220 : struct dentry *dentry, *parent;
178 :
179 11220 : dentry = d_find_alias(inode);
180 11221 : if (!dentry)
181 0 : goto out;
182 :
183 11221 : parent = dget_parent(dentry);
184 11223 : if (!parent)
185 0 : goto out_dput;
186 :
187 11223 : dir = igrab(d_inode(parent));
188 11224 : dput(parent);
189 :
190 11223 : out_dput:
191 11223 : dput(dentry);
192 : out:
193 11223 : return dir ? XFS_I(dir) : NULL;
194 : }
195 :
196 : /*
197 : * Lookup the mru cache for an existing association. If one exists and we can
198 : * use it, return with an active perag reference indicating that the allocation
199 : * will proceed with that association.
200 : *
201 : * If we have no association, or we cannot use the current one and have to
202 : * destroy it, return with longest = 0 to tell the caller to create a new
203 : * association.
204 : */
205 : static int
206 11222 : xfs_filestream_lookup_association(
207 : struct xfs_bmalloca *ap,
208 : struct xfs_alloc_arg *args,
209 : xfs_ino_t pino,
210 : xfs_extlen_t *longest)
211 : {
212 11222 : struct xfs_mount *mp = args->mp;
213 11222 : struct xfs_perag *pag;
214 11222 : struct xfs_mru_cache_elem *mru;
215 11222 : int error = 0;
216 :
217 11222 : *longest = 0;
218 11222 : mru = xfs_mru_cache_lookup(mp->m_filestream, pino);
219 11223 : if (!mru)
220 : return 0;
221 : /*
222 : * Grab the pag and take an extra active reference for the caller whilst
223 : * the mru item cannot go away. This means we'll pin the perag with
224 : * the reference we get here even if the filestreams association is torn
225 : * down immediately after we mark the lookup as done.
226 : */
227 10422 : pag = container_of(mru, struct xfs_fstrm_item, mru)->pag;
228 10422 : atomic_inc(&pag->pag_active_ref);
229 10422 : xfs_mru_cache_done(mp->m_filestream);
230 :
231 10422 : trace_xfs_filestream_lookup(pag, ap->ip->i_ino);
232 :
233 10422 : ap->blkno = XFS_AGB_TO_FSB(args->mp, pag->pag_agno, 0);
234 10422 : xfs_bmap_adjacent(ap);
235 :
236 : /*
237 : * If there is very little free space before we start a filestreams
238 : * allocation, we're almost guaranteed to fail to find a large enough
239 : * free space available so just use the cached AG.
240 : */
241 10422 : if (ap->tp->t_flags & XFS_TRANS_LOWMODE) {
242 0 : *longest = 1;
243 0 : goto out_done;
244 : }
245 :
246 10422 : error = xfs_bmap_longest_free_extent(pag, args->tp, longest);
247 10422 : if (error == -EAGAIN)
248 : error = 0;
249 10422 : if (error || *longest < args->maxlen) {
250 : /* We aren't going to use this perag */
251 868 : *longest = 0;
252 868 : xfs_perag_rele(pag);
253 868 : return error;
254 : }
255 :
256 9554 : out_done:
257 9554 : args->pag = pag;
258 9554 : return 0;
259 : }
260 :
261 : static int
262 1669 : xfs_filestream_create_association(
263 : struct xfs_bmalloca *ap,
264 : struct xfs_alloc_arg *args,
265 : xfs_ino_t pino,
266 : xfs_extlen_t *longest)
267 : {
268 1669 : struct xfs_mount *mp = args->mp;
269 1669 : struct xfs_mru_cache_elem *mru;
270 1669 : struct xfs_fstrm_item *item;
271 1669 : xfs_agnumber_t agno = XFS_INO_TO_AGNO(mp, pino);
272 1669 : int flags = 0;
273 1669 : int error;
274 :
275 : /* Changing parent AG association now, so remove the existing one. */
276 1669 : mru = xfs_mru_cache_remove(mp->m_filestream, pino);
277 1670 : if (mru) {
278 868 : struct xfs_fstrm_item *item =
279 868 : container_of(mru, struct xfs_fstrm_item, mru);
280 :
281 868 : agno = (item->pag->pag_agno + 1) % mp->m_sb.sb_agcount;
282 868 : xfs_fstrm_free_func(mp, mru);
283 1604 : } else if (xfs_is_inode32(mp)) {
284 0 : xfs_agnumber_t rotorstep = xfs_rotorstep;
285 :
286 0 : agno = (mp->m_agfrotor / rotorstep) % mp->m_sb.sb_agcount;
287 0 : mp->m_agfrotor = (mp->m_agfrotor + 1) %
288 0 : (mp->m_sb.sb_agcount * rotorstep);
289 : }
290 :
291 1670 : ap->blkno = XFS_AGB_TO_FSB(args->mp, agno, 0);
292 1670 : xfs_bmap_adjacent(ap);
293 :
294 1669 : if (ap->datatype & XFS_ALLOC_USERDATA)
295 1669 : flags |= XFS_PICK_USERDATA;
296 1669 : if (ap->tp->t_flags & XFS_TRANS_LOWMODE)
297 0 : flags |= XFS_PICK_LOWSPACE;
298 :
299 1669 : *longest = ap->length;
300 1669 : error = xfs_filestream_pick_ag(args, pino, agno, flags, longest);
301 1670 : if (error)
302 : return error;
303 :
304 : /*
305 : * We are going to use this perag now, so create an assoication for it.
306 : * xfs_filestream_pick_ag() has already bumped the perag fstrms counter
307 : * for us, so all we need to do here is take another active reference to
308 : * the perag for the cached association.
309 : *
310 : * If we fail to store the association, we need to drop the fstrms
311 : * counter as well as drop the perag reference we take here for the
312 : * item. We do not need to return an error for this failure - as long as
313 : * we return a referenced AG, the allocation can still go ahead just
314 : * fine.
315 : */
316 1670 : item = kmem_alloc(sizeof(*item), KM_MAYFAIL);
317 1670 : if (!item)
318 0 : goto out_put_fstrms;
319 :
320 1670 : atomic_inc(&args->pag->pag_active_ref);
321 1670 : item->pag = args->pag;
322 1670 : error = xfs_mru_cache_insert(mp->m_filestream, pino, &item->mru);
323 1670 : if (error)
324 0 : goto out_free_item;
325 : return 0;
326 :
327 : out_free_item:
328 0 : xfs_perag_rele(item->pag);
329 0 : kmem_free(item);
330 0 : out_put_fstrms:
331 0 : atomic_dec(&args->pag->pagf_fstrms);
332 : return 0;
333 : }
334 :
335 : /*
336 : * Search for an allocation group with a single extent large enough for
337 : * the request. First we look for an existing association and use that if it
338 : * is found. Otherwise, we create a new association by selecting an AG that fits
339 : * the allocation criteria.
340 : *
341 : * We return with a referenced perag in args->pag to indicate which AG we are
342 : * allocating into or an error with no references held.
343 : */
344 : int
345 11222 : xfs_filestream_select_ag(
346 : struct xfs_bmalloca *ap,
347 : struct xfs_alloc_arg *args,
348 : xfs_extlen_t *longest)
349 : {
350 11222 : struct xfs_mount *mp = args->mp;
351 11222 : struct xfs_inode *pip;
352 11222 : xfs_ino_t ino = 0;
353 11222 : int error = 0;
354 :
355 11222 : *longest = 0;
356 11222 : args->total = ap->total;
357 11222 : pip = xfs_filestream_get_parent(ap->ip);
358 11220 : if (pip) {
359 11220 : ino = pip->i_ino;
360 11220 : error = xfs_filestream_lookup_association(ap, args, ino,
361 : longest);
362 11223 : xfs_irele(pip);
363 11223 : if (error)
364 : return error;
365 11223 : if (*longest >= args->maxlen)
366 9554 : goto out_select;
367 1669 : if (ap->tp->t_flags & XFS_TRANS_LOWMODE)
368 0 : goto out_select;
369 : }
370 :
371 1669 : error = xfs_filestream_create_association(ap, args, ino, longest);
372 1670 : if (error)
373 : return error;
374 :
375 1670 : out_select:
376 11224 : ap->blkno = XFS_AGB_TO_FSB(mp, args->pag->pag_agno, 0);
377 11224 : return 0;
378 : }
379 :
380 : void
381 802 : xfs_filestream_deassociate(
382 : struct xfs_inode *ip)
383 : {
384 802 : xfs_mru_cache_delete(ip->i_mount->m_filestream, ip->i_ino);
385 802 : }
386 :
387 : int
388 24343 : xfs_filestream_mount(
389 : xfs_mount_t *mp)
390 : {
391 : /*
392 : * The filestream timer tunable is currently fixed within the range of
393 : * one second to four minutes, with five seconds being the default. The
394 : * group count is somewhat arbitrary, but it'd be nice to adhere to the
395 : * timer tunable to within about 10 percent. This requires at least 10
396 : * groups.
397 : */
398 48686 : return xfs_mru_cache_create(&mp->m_filestream, mp,
399 24343 : xfs_fstrm_centisecs * 10, 10, xfs_fstrm_free_func);
400 : }
401 :
402 : void
403 24349 : xfs_filestream_unmount(
404 : xfs_mount_t *mp)
405 : {
406 24349 : xfs_mru_cache_destroy(mp->m_filestream);
407 24349 : }
|
