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 8989 : xfs_fstrm_free_func(
36 : void *data,
37 : struct xfs_mru_cache_elem *mru)
38 : {
39 8989 : struct xfs_fstrm_item *item =
40 8989 : container_of(mru, struct xfs_fstrm_item, mru);
41 8989 : struct xfs_perag *pag = item->pag;
42 :
43 8989 : trace_xfs_filestream_free(pag, mru->key);
44 8989 : atomic_dec(&pag->pagf_fstrms);
45 8989 : xfs_perag_rele(pag);
46 :
47 8989 : kmem_free(item);
48 8989 : }
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 8983 : 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 8983 : struct xfs_mount *mp = args->mp;
64 8983 : struct xfs_perag *pag;
65 8983 : struct xfs_perag *max_pag = NULL;
66 8983 : xfs_extlen_t minlen = *longest;
67 8983 : xfs_extlen_t free = 0, minfree, maxfree = 0;
68 8983 : xfs_agnumber_t agno;
69 8983 : bool first_pass = true;
70 8983 : int err;
71 :
72 : /* 2% of an AG's blocks must be free for it to be chosen. */
73 8983 : minfree = mp->m_sb.sb_agblocks / 50;
74 :
75 : restart:
76 397461 : for_each_perag_wrap(mp, start_agno, agno, pag) {
77 390696 : trace_xfs_filestream_scan(pag, pino);
78 390695 : *longest = 0;
79 390695 : err = xfs_bmap_longest_free_extent(pag, NULL, longest);
80 390686 : if (err) {
81 1 : 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 390685 : if (pag->pagf_freeblks > maxfree) {
90 25792 : maxfree = pag->pagf_freeblks;
91 25792 : if (max_pag)
92 16809 : xfs_perag_rele(max_pag);
93 25793 : atomic_inc(&pag->pag_active_ref);
94 25793 : 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 390688 : if (atomic_inc_return(&pag->pagf_fstrms) <= 1) {
104 301729 : if (((minlen && *longest >= minlen) ||
105 6727 : (!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 6727 : free = pag->pagf_freeblks;
111 6727 : break;
112 : }
113 : }
114 :
115 : /* Drop the reference on this AG, it's not usable. */
116 383954 : atomic_dec(&pag->pagf_fstrms);
117 : }
118 :
119 13511 : 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 13511 : 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 6783 : if (first_pass) {
133 2261 : first_pass = false;
134 2261 : 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 4522 : if (!(flags & XFS_PICK_LOWSPACE)) {
142 2261 : flags |= XFS_PICK_LOWSPACE;
143 2261 : 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 2261 : 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 2261 : pag = max_pag;
159 2261 : free = maxfree;
160 2261 : atomic_inc(&pag->pagf_fstrms);
161 : }
162 6728 : } else if (max_pag) {
163 6728 : xfs_perag_rele(max_pag);
164 : }
165 :
166 8988 : trace_xfs_filestream_pick(pag, pino, free);
167 8987 : args->pag = pag;
168 8987 : return 0;
169 :
170 : }
171 :
172 : static struct xfs_inode *
173 61537 : xfs_filestream_get_parent(
174 : struct xfs_inode *ip)
175 : {
176 61537 : struct inode *inode = VFS_I(ip), *dir = NULL;
177 61537 : struct dentry *dentry, *parent;
178 :
179 61537 : dentry = d_find_alias(inode);
180 61540 : if (!dentry)
181 0 : goto out;
182 :
183 61540 : parent = dget_parent(dentry);
184 61540 : if (!parent)
185 0 : goto out_dput;
186 :
187 61540 : dir = igrab(d_inode(parent));
188 61545 : dput(parent);
189 :
190 61542 : out_dput:
191 61542 : dput(dentry);
192 : out:
193 61548 : 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 61542 : 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 61542 : struct xfs_mount *mp = args->mp;
213 61542 : struct xfs_perag *pag;
214 61542 : struct xfs_mru_cache_elem *mru;
215 61542 : int error = 0;
216 :
217 61542 : *longest = 0;
218 61542 : mru = xfs_mru_cache_lookup(mp->m_filestream, pino);
219 61554 : 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 57234 : pag = container_of(mru, struct xfs_fstrm_item, mru)->pag;
228 57234 : atomic_inc(&pag->pag_active_ref);
229 57234 : xfs_mru_cache_done(mp->m_filestream);
230 :
231 57234 : trace_xfs_filestream_lookup(pag, ap->ip->i_ino);
232 :
233 57234 : ap->blkno = XFS_AGB_TO_FSB(args->mp, pag->pag_agno, 0);
234 57234 : 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 57234 : if (ap->tp->t_flags & XFS_TRANS_LOWMODE) {
242 0 : *longest = 1;
243 0 : goto out_done;
244 : }
245 :
246 57234 : error = xfs_bmap_longest_free_extent(pag, args->tp, longest);
247 57228 : if (error == -EAGAIN)
248 : error = 0;
249 57228 : if (error || *longest < args->maxlen) {
250 : /* We aren't going to use this perag */
251 4669 : *longest = 0;
252 4669 : xfs_perag_rele(pag);
253 4669 : return error;
254 : }
255 :
256 52559 : out_done:
257 52559 : args->pag = pag;
258 52559 : return 0;
259 : }
260 :
261 : static int
262 8988 : 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 8988 : struct xfs_mount *mp = args->mp;
269 8988 : struct xfs_mru_cache_elem *mru;
270 8988 : struct xfs_fstrm_item *item;
271 8988 : xfs_agnumber_t agno = XFS_INO_TO_AGNO(mp, pino);
272 8988 : int flags = 0;
273 8988 : int error;
274 :
275 : /* Changing parent AG association now, so remove the existing one. */
276 8988 : mru = xfs_mru_cache_remove(mp->m_filestream, pino);
277 8986 : if (mru) {
278 4669 : struct xfs_fstrm_item *item =
279 4669 : container_of(mru, struct xfs_fstrm_item, mru);
280 :
281 4669 : agno = (item->pag->pag_agno + 1) % mp->m_sb.sb_agcount;
282 4669 : xfs_fstrm_free_func(mp, mru);
283 8634 : } 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 8986 : ap->blkno = XFS_AGB_TO_FSB(args->mp, agno, 0);
292 8986 : xfs_bmap_adjacent(ap);
293 :
294 8981 : if (ap->datatype & XFS_ALLOC_USERDATA)
295 8981 : flags |= XFS_PICK_USERDATA;
296 8981 : if (ap->tp->t_flags & XFS_TRANS_LOWMODE)
297 0 : flags |= XFS_PICK_LOWSPACE;
298 :
299 8981 : *longest = ap->length;
300 8981 : error = xfs_filestream_pick_ag(args, pino, agno, flags, longest);
301 8987 : 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 8987 : item = kmem_alloc(sizeof(*item), KM_MAYFAIL);
317 8987 : if (!item)
318 0 : goto out_put_fstrms;
319 :
320 8987 : atomic_inc(&args->pag->pag_active_ref);
321 8989 : item->pag = args->pag;
322 8989 : error = xfs_mru_cache_insert(mp->m_filestream, pino, &item->mru);
323 8989 : 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 0 : 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 61543 : xfs_filestream_select_ag(
346 : struct xfs_bmalloca *ap,
347 : struct xfs_alloc_arg *args,
348 : xfs_extlen_t *longest)
349 : {
350 61543 : struct xfs_mount *mp = args->mp;
351 61543 : struct xfs_inode *pip;
352 61543 : xfs_ino_t ino = 0;
353 61543 : int error = 0;
354 :
355 61543 : *longest = 0;
356 61543 : args->total = ap->total;
357 61543 : pip = xfs_filestream_get_parent(ap->ip);
358 61542 : if (pip) {
359 61542 : ino = pip->i_ino;
360 61542 : error = xfs_filestream_lookup_association(ap, args, ino,
361 : longest);
362 61547 : xfs_irele(pip);
363 61549 : if (error)
364 : return error;
365 61549 : if (*longest >= args->maxlen)
366 52562 : goto out_select;
367 8987 : if (ap->tp->t_flags & XFS_TRANS_LOWMODE)
368 0 : goto out_select;
369 : }
370 :
371 8987 : error = xfs_filestream_create_association(ap, args, ino, longest);
372 8989 : if (error)
373 : return error;
374 :
375 8989 : out_select:
376 61551 : ap->blkno = XFS_AGB_TO_FSB(mp, args->pag->pag_agno, 0);
377 61551 : return 0;
378 : }
379 :
380 : void
381 4320 : xfs_filestream_deassociate(
382 : struct xfs_inode *ip)
383 : {
384 4320 : xfs_mru_cache_delete(ip->i_mount->m_filestream, ip->i_ino);
385 4320 : }
386 :
387 : int
388 59415 : 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 118830 : return xfs_mru_cache_create(&mp->m_filestream, mp,
399 59415 : xfs_fstrm_centisecs * 10, 10, xfs_fstrm_free_func);
400 : }
401 :
402 : void
403 59422 : xfs_filestream_unmount(
404 : xfs_mount_t *mp)
405 : {
406 59422 : xfs_mru_cache_destroy(mp->m_filestream);
407 59422 : }
|
