Commit | Line | Data |
---|---|---|
0b61f8a4 | 1 | // SPDX-License-Identifier: GPL-2.0 |
2a82b8be DC |
2 | /* |
3 | * Copyright (c) 2006-2007 Silicon Graphics, Inc. | |
2cd2ef6a | 4 | * Copyright (c) 2014 Christoph Hellwig. |
2a82b8be | 5 | * All Rights Reserved. |
2a82b8be DC |
6 | */ |
7 | #include "xfs.h" | |
5467b34b | 8 | #include "xfs_shared.h" |
a4fbe6ab | 9 | #include "xfs_format.h" |
239880ef DC |
10 | #include "xfs_log_format.h" |
11 | #include "xfs_trans_resv.h" | |
239880ef | 12 | #include "xfs_mount.h" |
2a82b8be | 13 | #include "xfs_inode.h" |
2a82b8be DC |
14 | #include "xfs_bmap.h" |
15 | #include "xfs_alloc.h" | |
2a82b8be | 16 | #include "xfs_mru_cache.h" |
0b1b213f | 17 | #include "xfs_trace.h" |
9bbafc71 | 18 | #include "xfs_ag.h" |
3fd129b6 | 19 | #include "xfs_ag_resv.h" |
3e3673e3 | 20 | #include "xfs_trans.h" |
f368b29b | 21 | #include "xfs_filestream.h" |
2a82b8be | 22 | |
2cd2ef6a CH |
23 | struct xfs_fstrm_item { |
24 | struct xfs_mru_cache_elem mru; | |
2cd2ef6a CH |
25 | xfs_agnumber_t ag; /* AG in use for this directory */ |
26 | }; | |
27 | ||
28 | enum xfs_fstrm_alloc { | |
29 | XFS_PICK_USERDATA = 1, | |
30 | XFS_PICK_LOWSPACE = 2, | |
31 | }; | |
2a82b8be | 32 | |
0664ce8d CH |
33 | /* |
34 | * Allocation group filestream associations are tracked with per-ag atomic | |
2cd2ef6a | 35 | * counters. These counters allow xfs_filestream_pick_ag() to tell whether a |
b38e0740 | 36 | * particular AG already has active filestreams associated with it. |
0664ce8d | 37 | */ |
b94acd47 | 38 | int |
0664ce8d CH |
39 | xfs_filestream_peek_ag( |
40 | xfs_mount_t *mp, | |
41 | xfs_agnumber_t agno) | |
42 | { | |
43 | struct xfs_perag *pag; | |
44 | int ret; | |
45 | ||
46 | pag = xfs_perag_get(mp, agno); | |
47 | ret = atomic_read(&pag->pagf_fstrms); | |
48 | xfs_perag_put(pag); | |
49 | return ret; | |
50 | } | |
51 | ||
52 | static int | |
53 | xfs_filestream_get_ag( | |
54 | xfs_mount_t *mp, | |
55 | xfs_agnumber_t agno) | |
56 | { | |
57 | struct xfs_perag *pag; | |
58 | int ret; | |
59 | ||
60 | pag = xfs_perag_get(mp, agno); | |
61 | ret = atomic_inc_return(&pag->pagf_fstrms); | |
62 | xfs_perag_put(pag); | |
63 | return ret; | |
64 | } | |
65 | ||
66 | static void | |
67 | xfs_filestream_put_ag( | |
68 | xfs_mount_t *mp, | |
69 | xfs_agnumber_t agno) | |
70 | { | |
71 | struct xfs_perag *pag; | |
72 | ||
73 | pag = xfs_perag_get(mp, agno); | |
74 | atomic_dec(&pag->pagf_fstrms); | |
75 | xfs_perag_put(pag); | |
76 | } | |
2a82b8be | 77 | |
2cd2ef6a CH |
78 | static void |
79 | xfs_fstrm_free_func( | |
7fcd3efa | 80 | void *data, |
2cd2ef6a CH |
81 | struct xfs_mru_cache_elem *mru) |
82 | { | |
7fcd3efa | 83 | struct xfs_mount *mp = data; |
2cd2ef6a CH |
84 | struct xfs_fstrm_item *item = |
85 | container_of(mru, struct xfs_fstrm_item, mru); | |
86 | ||
7fcd3efa CH |
87 | xfs_filestream_put_ag(mp, item->ag); |
88 | trace_xfs_filestream_free(mp, mru->key, item->ag); | |
2cd2ef6a | 89 | |
1919adda | 90 | kmem_free(item); |
2cd2ef6a CH |
91 | } |
92 | ||
2a82b8be DC |
93 | /* |
94 | * Scan the AGs starting at startag looking for an AG that isn't in use and has | |
95 | * at least minlen blocks free. | |
96 | */ | |
97 | static int | |
2cd2ef6a CH |
98 | xfs_filestream_pick_ag( |
99 | struct xfs_inode *ip, | |
100 | xfs_agnumber_t startag, | |
101 | xfs_agnumber_t *agp, | |
102 | int flags, | |
103 | xfs_extlen_t minlen) | |
2a82b8be | 104 | { |
2cd2ef6a CH |
105 | struct xfs_mount *mp = ip->i_mount; |
106 | struct xfs_fstrm_item *item; | |
107 | struct xfs_perag *pag; | |
b94acd47 | 108 | xfs_extlen_t longest, free = 0, minfree, maxfree = 0; |
2cd2ef6a | 109 | xfs_agnumber_t ag, max_ag = NULLAGNUMBER; |
2cd2ef6a CH |
110 | int err, trylock, nscan; |
111 | ||
c19b3b05 | 112 | ASSERT(S_ISDIR(VFS_I(ip)->i_mode)); |
2a82b8be DC |
113 | |
114 | /* 2% of an AG's blocks must be free for it to be chosen. */ | |
115 | minfree = mp->m_sb.sb_agblocks / 50; | |
116 | ||
117 | ag = startag; | |
118 | *agp = NULLAGNUMBER; | |
119 | ||
120 | /* For the first pass, don't sleep trying to init the per-AG. */ | |
121 | trylock = XFS_ALLOC_FLAG_TRYLOCK; | |
122 | ||
123 | for (nscan = 0; 1; nscan++) { | |
7fcd3efa | 124 | trace_xfs_filestream_scan(mp, ip->i_ino, ag); |
b94acd47 | 125 | |
4196ac08 | 126 | pag = xfs_perag_get(mp, ag); |
2a82b8be DC |
127 | |
128 | if (!pag->pagf_init) { | |
129 | err = xfs_alloc_pagf_init(mp, NULL, ag, trylock); | |
f48e2df8 | 130 | if (err) { |
4196ac08 | 131 | xfs_perag_put(pag); |
f48e2df8 DW |
132 | if (err != -EAGAIN) |
133 | return err; | |
134 | /* Couldn't lock the AGF, skip this AG. */ | |
135 | continue; | |
4196ac08 | 136 | } |
2a82b8be DC |
137 | } |
138 | ||
2a82b8be DC |
139 | /* Keep track of the AG with the most free blocks. */ |
140 | if (pag->pagf_freeblks > maxfree) { | |
141 | maxfree = pag->pagf_freeblks; | |
142 | max_ag = ag; | |
143 | } | |
144 | ||
145 | /* | |
146 | * The AG reference count does two things: it enforces mutual | |
147 | * exclusion when examining the suitability of an AG in this | |
148 | * loop, and it guards against two filestreams being established | |
149 | * in the same AG as each other. | |
150 | */ | |
151 | if (xfs_filestream_get_ag(mp, ag) > 1) { | |
152 | xfs_filestream_put_ag(mp, ag); | |
153 | goto next_ag; | |
154 | } | |
155 | ||
a1f69417 | 156 | longest = xfs_alloc_longest_free_extent(pag, |
3fd129b6 DW |
157 | xfs_alloc_min_freelist(mp, pag), |
158 | xfs_ag_resv_needed(pag, XFS_AG_RESV_NONE)); | |
2a82b8be DC |
159 | if (((minlen && longest >= minlen) || |
160 | (!minlen && pag->pagf_freeblks >= minfree)) && | |
161 | (!pag->pagf_metadata || !(flags & XFS_PICK_USERDATA) || | |
162 | (flags & XFS_PICK_LOWSPACE))) { | |
163 | ||
164 | /* Break out, retaining the reference on the AG. */ | |
165 | free = pag->pagf_freeblks; | |
4196ac08 | 166 | xfs_perag_put(pag); |
2a82b8be DC |
167 | *agp = ag; |
168 | break; | |
169 | } | |
170 | ||
171 | /* Drop the reference on this AG, it's not usable. */ | |
172 | xfs_filestream_put_ag(mp, ag); | |
173 | next_ag: | |
4196ac08 | 174 | xfs_perag_put(pag); |
2a82b8be DC |
175 | /* Move to the next AG, wrapping to AG 0 if necessary. */ |
176 | if (++ag >= mp->m_sb.sb_agcount) | |
177 | ag = 0; | |
178 | ||
179 | /* If a full pass of the AGs hasn't been done yet, continue. */ | |
180 | if (ag != startag) | |
181 | continue; | |
182 | ||
183 | /* Allow sleeping in xfs_alloc_pagf_init() on the 2nd pass. */ | |
184 | if (trylock != 0) { | |
185 | trylock = 0; | |
186 | continue; | |
187 | } | |
188 | ||
189 | /* Finally, if lowspace wasn't set, set it for the 3rd pass. */ | |
190 | if (!(flags & XFS_PICK_LOWSPACE)) { | |
191 | flags |= XFS_PICK_LOWSPACE; | |
192 | continue; | |
193 | } | |
194 | ||
195 | /* | |
196 | * Take the AG with the most free space, regardless of whether | |
197 | * it's already in use by another filestream. | |
198 | */ | |
199 | if (max_ag != NULLAGNUMBER) { | |
200 | xfs_filestream_get_ag(mp, max_ag); | |
2a82b8be DC |
201 | free = maxfree; |
202 | *agp = max_ag; | |
203 | break; | |
204 | } | |
205 | ||
206 | /* take AG 0 if none matched */ | |
b94acd47 | 207 | trace_xfs_filestream_pick(ip, *agp, free, nscan); |
2a82b8be DC |
208 | *agp = 0; |
209 | return 0; | |
210 | } | |
211 | ||
b94acd47 | 212 | trace_xfs_filestream_pick(ip, *agp, free, nscan); |
2a82b8be | 213 | |
2cd2ef6a | 214 | if (*agp == NULLAGNUMBER) |
2a82b8be | 215 | return 0; |
2a82b8be | 216 | |
2451337d | 217 | err = -ENOMEM; |
1919adda | 218 | item = kmem_alloc(sizeof(*item), KM_MAYFAIL); |
2a82b8be | 219 | if (!item) |
2cd2ef6a | 220 | goto out_put_ag; |
2a82b8be | 221 | |
2cd2ef6a | 222 | item->ag = *agp; |
2a82b8be | 223 | |
22328d71 | 224 | err = xfs_mru_cache_insert(mp->m_filestream, ip->i_ino, &item->mru); |
2a82b8be | 225 | if (err) { |
2451337d | 226 | if (err == -EEXIST) |
2cd2ef6a CH |
227 | err = 0; |
228 | goto out_free_item; | |
2a82b8be DC |
229 | } |
230 | ||
2a82b8be | 231 | return 0; |
2a82b8be | 232 | |
2cd2ef6a | 233 | out_free_item: |
1919adda | 234 | kmem_free(item); |
2cd2ef6a CH |
235 | out_put_ag: |
236 | xfs_filestream_put_ag(mp, *agp); | |
237 | return err; | |
2a82b8be DC |
238 | } |
239 | ||
2cd2ef6a CH |
240 | static struct xfs_inode * |
241 | xfs_filestream_get_parent( | |
242 | struct xfs_inode *ip) | |
2a82b8be | 243 | { |
2cd2ef6a CH |
244 | struct inode *inode = VFS_I(ip), *dir = NULL; |
245 | struct dentry *dentry, *parent; | |
2a82b8be | 246 | |
2cd2ef6a CH |
247 | dentry = d_find_alias(inode); |
248 | if (!dentry) | |
249 | goto out; | |
2a82b8be | 250 | |
2cd2ef6a CH |
251 | parent = dget_parent(dentry); |
252 | if (!parent) | |
253 | goto out_dput; | |
2a82b8be | 254 | |
2b0143b5 | 255 | dir = igrab(d_inode(parent)); |
2cd2ef6a | 256 | dput(parent); |
2a82b8be | 257 | |
2cd2ef6a CH |
258 | out_dput: |
259 | dput(dentry); | |
260 | out: | |
261 | return dir ? XFS_I(dir) : NULL; | |
2a82b8be DC |
262 | } |
263 | ||
2a82b8be | 264 | /* |
3b8d9076 CH |
265 | * Find the right allocation group for a file, either by finding an |
266 | * existing file stream or creating a new one. | |
267 | * | |
268 | * Returns NULLAGNUMBER in case of an error. | |
2a82b8be DC |
269 | */ |
270 | xfs_agnumber_t | |
271 | xfs_filestream_lookup_ag( | |
2cd2ef6a | 272 | struct xfs_inode *ip) |
2a82b8be | 273 | { |
2cd2ef6a | 274 | struct xfs_mount *mp = ip->i_mount; |
2cd2ef6a | 275 | struct xfs_inode *pip = NULL; |
3b8d9076 | 276 | xfs_agnumber_t startag, ag = NULLAGNUMBER; |
22328d71 | 277 | struct xfs_mru_cache_elem *mru; |
2a82b8be | 278 | |
c19b3b05 | 279 | ASSERT(S_ISREG(VFS_I(ip)->i_mode)); |
2a82b8be | 280 | |
2cd2ef6a CH |
281 | pip = xfs_filestream_get_parent(ip); |
282 | if (!pip) | |
b26384dc | 283 | return NULLAGNUMBER; |
2cd2ef6a CH |
284 | |
285 | mru = xfs_mru_cache_lookup(mp->m_filestream, pip->i_ino); | |
22328d71 | 286 | if (mru) { |
3b8d9076 | 287 | ag = container_of(mru, struct xfs_fstrm_item, mru)->ag; |
22328d71 | 288 | xfs_mru_cache_done(mp->m_filestream); |
3b8d9076 | 289 | |
7fcd3efa | 290 | trace_xfs_filestream_lookup(mp, ip->i_ino, ag); |
3b8d9076 | 291 | goto out; |
2a82b8be DC |
292 | } |
293 | ||
294 | /* | |
295 | * Set the starting AG using the rotor for inode32, otherwise | |
296 | * use the directory inode's AG. | |
297 | */ | |
2e973b2c | 298 | if (xfs_is_inode32(mp)) { |
2cd2ef6a | 299 | xfs_agnumber_t rotorstep = xfs_rotorstep; |
2a82b8be DC |
300 | startag = (mp->m_agfrotor / rotorstep) % mp->m_sb.sb_agcount; |
301 | mp->m_agfrotor = (mp->m_agfrotor + 1) % | |
302 | (mp->m_sb.sb_agcount * rotorstep); | |
303 | } else | |
304 | startag = XFS_INO_TO_AGNO(mp, pip->i_ino); | |
305 | ||
3b8d9076 CH |
306 | if (xfs_filestream_pick_ag(pip, startag, &ag, 0, 0)) |
307 | ag = NULLAGNUMBER; | |
308 | out: | |
44a8736b | 309 | xfs_irele(pip); |
3b8d9076 | 310 | return ag; |
2a82b8be DC |
311 | } |
312 | ||
313 | /* | |
2cd2ef6a CH |
314 | * Pick a new allocation group for the current file and its file stream. |
315 | * | |
316 | * This is called when the allocator can't find a suitable extent in the | |
317 | * current AG, and we have to move the stream into a new AG with more space. | |
2a82b8be DC |
318 | */ |
319 | int | |
320 | xfs_filestream_new_ag( | |
68988114 DC |
321 | struct xfs_bmalloca *ap, |
322 | xfs_agnumber_t *agp) | |
2a82b8be | 323 | { |
2cd2ef6a CH |
324 | struct xfs_inode *ip = ap->ip, *pip; |
325 | struct xfs_mount *mp = ip->i_mount; | |
326 | xfs_extlen_t minlen = ap->length; | |
327 | xfs_agnumber_t startag = 0; | |
292378ed DC |
328 | int flags = 0; |
329 | int err = 0; | |
2cd2ef6a | 330 | struct xfs_mru_cache_elem *mru; |
2a82b8be | 331 | |
2cd2ef6a | 332 | *agp = NULLAGNUMBER; |
2a82b8be | 333 | |
2cd2ef6a CH |
334 | pip = xfs_filestream_get_parent(ip); |
335 | if (!pip) | |
336 | goto exit; | |
2a82b8be | 337 | |
2cd2ef6a CH |
338 | mru = xfs_mru_cache_remove(mp->m_filestream, pip->i_ino); |
339 | if (mru) { | |
340 | struct xfs_fstrm_item *item = | |
341 | container_of(mru, struct xfs_fstrm_item, mru); | |
342 | startag = (item->ag + 1) % mp->m_sb.sb_agcount; | |
2a82b8be DC |
343 | } |
344 | ||
c34d570d | 345 | if (ap->datatype & XFS_ALLOC_USERDATA) |
292378ed | 346 | flags |= XFS_PICK_USERDATA; |
1214f1cf | 347 | if (ap->tp->t_flags & XFS_TRANS_LOWMODE) |
292378ed | 348 | flags |= XFS_PICK_LOWSPACE; |
2a82b8be | 349 | |
2cd2ef6a | 350 | err = xfs_filestream_pick_ag(pip, startag, agp, flags, minlen); |
2a82b8be DC |
351 | |
352 | /* | |
2cd2ef6a | 353 | * Only free the item here so we skip over the old AG earlier. |
2a82b8be | 354 | */ |
2cd2ef6a | 355 | if (mru) |
7fcd3efa | 356 | xfs_fstrm_free_func(mp, mru); |
2a82b8be | 357 | |
44a8736b | 358 | xfs_irele(pip); |
2cd2ef6a CH |
359 | exit: |
360 | if (*agp == NULLAGNUMBER) | |
361 | *agp = 0; | |
362 | return err; | |
363 | } | |
2a82b8be | 364 | |
2cd2ef6a CH |
365 | void |
366 | xfs_filestream_deassociate( | |
367 | struct xfs_inode *ip) | |
368 | { | |
369 | xfs_mru_cache_delete(ip->i_mount->m_filestream, ip->i_ino); | |
370 | } | |
2a82b8be | 371 | |
2cd2ef6a CH |
372 | int |
373 | xfs_filestream_mount( | |
374 | xfs_mount_t *mp) | |
375 | { | |
2a82b8be | 376 | /* |
2cd2ef6a CH |
377 | * The filestream timer tunable is currently fixed within the range of |
378 | * one second to four minutes, with five seconds being the default. The | |
379 | * group count is somewhat arbitrary, but it'd be nice to adhere to the | |
380 | * timer tunable to within about 10 percent. This requires at least 10 | |
381 | * groups. | |
2a82b8be | 382 | */ |
7fcd3efa CH |
383 | return xfs_mru_cache_create(&mp->m_filestream, mp, |
384 | xfs_fstrm_centisecs * 10, 10, xfs_fstrm_free_func); | |
2cd2ef6a | 385 | } |
2a82b8be | 386 | |
2cd2ef6a CH |
387 | void |
388 | xfs_filestream_unmount( | |
389 | xfs_mount_t *mp) | |
390 | { | |
391 | xfs_mru_cache_destroy(mp->m_filestream); | |
392 | } |