]>
git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blob - fs/xfs/xfs_filestream.c
7b94036900138b6cbb9f380b6ffd57354c9910dc
2 * Copyright (c) 2006-2007 Silicon Graphics, Inc.
3 * Copyright (c) 2014 Christoph Hellwig.
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.
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.
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
20 #include "xfs_format.h"
21 #include "xfs_log_format.h"
22 #include "xfs_trans_resv.h"
25 #include "xfs_mount.h"
27 #include "xfs_inode.h"
29 #include "xfs_bmap_util.h"
30 #include "xfs_alloc.h"
31 #include "xfs_mru_cache.h"
32 #include "xfs_dinode.h"
33 #include "xfs_filestream.h"
34 #include "xfs_trace.h"
36 #define TRACE_AG_SCAN(mp, ag, ag2)
37 #define TRACE_AG_PICK1(mp, max_ag, maxfree)
38 #define TRACE_AG_PICK2(mp, ag, ag2, cnt, free, scan, flag)
39 #define TRACE_FREE(mp, ip, pip, ag, cnt)
40 #define TRACE_LOOKUP(mp, ip, pip, ag, cnt)
42 struct xfs_fstrm_item
{
43 struct xfs_mru_cache_elem mru
;
45 xfs_agnumber_t ag
; /* AG in use for this directory */
48 enum xfs_fstrm_alloc
{
49 XFS_PICK_USERDATA
= 1,
50 XFS_PICK_LOWSPACE
= 2,
54 * Allocation group filestream associations are tracked with per-ag atomic
55 * counters. These counters allow xfs_filestream_pick_ag() to tell whether a
56 * particular AG already has active filestreams associated with it. The mount
57 * point's m_peraglock is used to protect these counters from per-ag array
58 * re-allocation during a growfs operation. When xfs_growfs_data_private() is
59 * about to reallocate the array, it calls xfs_filestream_flush() with the
60 * m_peraglock held in write mode.
62 * Since xfs_mru_cache_flush() guarantees that all the free functions for all
63 * the cache elements have finished executing before it returns, it's safe for
64 * the free functions to use the atomic counters without m_peraglock protection.
65 * This allows the implementation of xfs_fstrm_free_func() to be agnostic about
66 * whether it was called with the m_peraglock held in read mode, write mode or
67 * not held at all. The race condition this addresses is the following:
69 * - The work queue scheduler fires and pulls a filestream directory cache
70 * element off the LRU end of the cache for deletion, then gets pre-empted.
71 * - A growfs operation grabs the m_peraglock in write mode, flushes all the
72 * remaining items from the cache and reallocates the mount point's per-ag
73 * array, resetting all the counters to zero.
74 * - The work queue thread resumes and calls the free function for the element
75 * it started cleaning up earlier. In the process it decrements the
76 * filestreams counter for an AG that now has no references.
78 * With a shrinkfs feature, the above scenario could panic the system.
80 * All other uses of the following macros should be protected by either the
81 * m_peraglock held in read mode, or the cache's internal locking exposed by the
82 * interval between a call to xfs_mru_cache_lookup() and a call to
83 * xfs_mru_cache_done(). In addition, the m_peraglock must be held in read mode
84 * when new elements are added to the cache.
86 * Combined, these locking rules ensure that no associations will ever exist in
87 * the cache that reference per-ag array elements that have since been
91 xfs_filestream_peek_ag(
95 struct xfs_perag
*pag
;
98 pag
= xfs_perag_get(mp
, agno
);
99 ret
= atomic_read(&pag
->pagf_fstrms
);
105 xfs_filestream_get_ag(
109 struct xfs_perag
*pag
;
112 pag
= xfs_perag_get(mp
, agno
);
113 ret
= atomic_inc_return(&pag
->pagf_fstrms
);
119 xfs_filestream_put_ag(
123 struct xfs_perag
*pag
;
125 pag
= xfs_perag_get(mp
, agno
);
126 atomic_dec(&pag
->pagf_fstrms
);
132 struct xfs_mru_cache_elem
*mru
)
134 struct xfs_fstrm_item
*item
=
135 container_of(mru
, struct xfs_fstrm_item
, mru
);
137 xfs_filestream_put_ag(item
->ip
->i_mount
, item
->ag
);
139 TRACE_FREE(mp
, ip
, NULL
, item
->ag
,
140 xfs_filestream_peek_ag(mp
, item
->ag
));
146 * Scan the AGs starting at startag looking for an AG that isn't in use and has
147 * at least minlen blocks free.
150 xfs_filestream_pick_ag(
151 struct xfs_inode
*ip
,
152 xfs_agnumber_t startag
,
157 struct xfs_mount
*mp
= ip
->i_mount
;
158 struct xfs_fstrm_item
*item
;
159 struct xfs_perag
*pag
;
160 xfs_extlen_t longest
, free
, minfree
, maxfree
= 0;
161 xfs_agnumber_t ag
, max_ag
= NULLAGNUMBER
;
162 int streams
, max_streams
;
163 int err
, trylock
, nscan
;
165 ASSERT(S_ISDIR(ip
->i_d
.di_mode
));
167 /* 2% of an AG's blocks must be free for it to be chosen. */
168 minfree
= mp
->m_sb
.sb_agblocks
/ 50;
173 /* For the first pass, don't sleep trying to init the per-AG. */
174 trylock
= XFS_ALLOC_FLAG_TRYLOCK
;
176 for (nscan
= 0; 1; nscan
++) {
177 pag
= xfs_perag_get(mp
, ag
);
178 TRACE_AG_SCAN(mp
, ag
, atomic_read(&pag
->pagf_fstrms
));
180 if (!pag
->pagf_init
) {
181 err
= xfs_alloc_pagf_init(mp
, NULL
, ag
, trylock
);
182 if (err
&& !trylock
) {
188 /* Might fail sometimes during the 1st pass with trylock set. */
192 /* Keep track of the AG with the most free blocks. */
193 if (pag
->pagf_freeblks
> maxfree
) {
194 maxfree
= pag
->pagf_freeblks
;
195 max_streams
= atomic_read(&pag
->pagf_fstrms
);
200 * The AG reference count does two things: it enforces mutual
201 * exclusion when examining the suitability of an AG in this
202 * loop, and it guards against two filestreams being established
203 * in the same AG as each other.
205 if (xfs_filestream_get_ag(mp
, ag
) > 1) {
206 xfs_filestream_put_ag(mp
, ag
);
210 longest
= xfs_alloc_longest_free_extent(mp
, pag
);
211 if (((minlen
&& longest
>= minlen
) ||
212 (!minlen
&& pag
->pagf_freeblks
>= minfree
)) &&
213 (!pag
->pagf_metadata
|| !(flags
& XFS_PICK_USERDATA
) ||
214 (flags
& XFS_PICK_LOWSPACE
))) {
216 /* Break out, retaining the reference on the AG. */
217 free
= pag
->pagf_freeblks
;
218 streams
= atomic_read(&pag
->pagf_fstrms
);
224 /* Drop the reference on this AG, it's not usable. */
225 xfs_filestream_put_ag(mp
, ag
);
228 /* Move to the next AG, wrapping to AG 0 if necessary. */
229 if (++ag
>= mp
->m_sb
.sb_agcount
)
232 /* If a full pass of the AGs hasn't been done yet, continue. */
236 /* Allow sleeping in xfs_alloc_pagf_init() on the 2nd pass. */
242 /* Finally, if lowspace wasn't set, set it for the 3rd pass. */
243 if (!(flags
& XFS_PICK_LOWSPACE
)) {
244 flags
|= XFS_PICK_LOWSPACE
;
249 * Take the AG with the most free space, regardless of whether
250 * it's already in use by another filestream.
252 if (max_ag
!= NULLAGNUMBER
) {
253 xfs_filestream_get_ag(mp
, max_ag
);
254 TRACE_AG_PICK1(mp
, max_ag
, maxfree
);
255 streams
= max_streams
;
261 /* take AG 0 if none matched */
262 TRACE_AG_PICK1(mp
, max_ag
, maxfree
);
267 TRACE_AG_PICK2(mp
, startag
, *agp
, streams
, free
, nscan
, flags
);
269 if (*agp
== NULLAGNUMBER
)
273 item
= kmem_alloc(sizeof(*item
), KM_MAYFAIL
);
280 err
= xfs_mru_cache_insert(mp
->m_filestream
, ip
->i_ino
, &item
->mru
);
292 xfs_filestream_put_ag(mp
, *agp
);
296 static struct xfs_inode
*
297 xfs_filestream_get_parent(
298 struct xfs_inode
*ip
)
300 struct inode
*inode
= VFS_I(ip
), *dir
= NULL
;
301 struct dentry
*dentry
, *parent
;
303 dentry
= d_find_alias(inode
);
307 parent
= dget_parent(dentry
);
311 dir
= igrab(parent
->d_inode
);
317 return dir
? XFS_I(dir
) : NULL
;
321 * Return the AG of the filestream the file or directory belongs to, or
322 * NULLAGNUMBER otherwise.
325 xfs_filestream_lookup_ag(
326 struct xfs_inode
*ip
)
328 struct xfs_mount
*mp
= ip
->i_mount
;
329 struct xfs_fstrm_item
*item
;
330 struct xfs_inode
*pip
= NULL
;
331 xfs_agnumber_t ag
= NULLAGNUMBER
;
333 struct xfs_mru_cache_elem
*mru
;
335 ASSERT(S_ISREG(ip
->i_d
.di_mode
));
337 pip
= xfs_filestream_get_parent(ip
);
341 mru
= xfs_mru_cache_lookup(mp
->m_filestream
, pip
->i_ino
);
345 item
= container_of(mru
, struct xfs_fstrm_item
, mru
);
348 xfs_mru_cache_done(mp
->m_filestream
);
350 ref
= xfs_filestream_peek_ag(ip
->i_mount
, ag
);
352 TRACE_LOOKUP(mp
, ip
, pip
, ag
, ref
);
358 * Make sure a directory has a filestream associated with it.
360 * This is called when creating regular files in an directory that has
361 * filestreams enabled, so that a stream is ready by the time we need it
362 * in the allocator for the files inside the directory.
365 xfs_filestream_associate(
366 struct xfs_inode
*pip
)
368 struct xfs_mount
*mp
= pip
->i_mount
;
369 struct xfs_mru_cache_elem
*mru
;
370 xfs_agnumber_t startag
, ag
;
372 ASSERT(S_ISDIR(pip
->i_d
.di_mode
));
375 * If the directory already has a file stream associated we're done.
377 mru
= xfs_mru_cache_lookup(mp
->m_filestream
, pip
->i_ino
);
379 xfs_mru_cache_done(mp
->m_filestream
);
384 * Set the starting AG using the rotor for inode32, otherwise
385 * use the directory inode's AG.
387 if (mp
->m_flags
& XFS_MOUNT_32BITINODES
) {
388 xfs_agnumber_t rotorstep
= xfs_rotorstep
;
389 startag
= (mp
->m_agfrotor
/ rotorstep
) % mp
->m_sb
.sb_agcount
;
390 mp
->m_agfrotor
= (mp
->m_agfrotor
+ 1) %
391 (mp
->m_sb
.sb_agcount
* rotorstep
);
393 startag
= XFS_INO_TO_AGNO(mp
, pip
->i_ino
);
395 return xfs_filestream_pick_ag(pip
, startag
, &ag
, 0, 0);
399 * Pick a new allocation group for the current file and its file stream.
401 * This is called when the allocator can't find a suitable extent in the
402 * current AG, and we have to move the stream into a new AG with more space.
405 xfs_filestream_new_ag(
406 struct xfs_bmalloca
*ap
,
409 struct xfs_inode
*ip
= ap
->ip
, *pip
;
410 struct xfs_mount
*mp
= ip
->i_mount
;
411 xfs_extlen_t minlen
= ap
->length
;
412 xfs_agnumber_t startag
= 0;
414 struct xfs_mru_cache_elem
*mru
;
418 pip
= xfs_filestream_get_parent(ip
);
422 mru
= xfs_mru_cache_remove(mp
->m_filestream
, pip
->i_ino
);
424 struct xfs_fstrm_item
*item
=
425 container_of(mru
, struct xfs_fstrm_item
, mru
);
426 startag
= (item
->ag
+ 1) % mp
->m_sb
.sb_agcount
;
429 flags
= (ap
->userdata
? XFS_PICK_USERDATA
: 0) |
430 (ap
->flist
->xbf_low
? XFS_PICK_LOWSPACE
: 0);
432 err
= xfs_filestream_pick_ag(pip
, startag
, agp
, flags
, minlen
);
435 * Only free the item here so we skip over the old AG earlier.
438 xfs_fstrm_free_func(mru
);
442 if (*agp
== NULLAGNUMBER
)
448 xfs_filestream_deassociate(
449 struct xfs_inode
*ip
)
451 xfs_mru_cache_delete(ip
->i_mount
->m_filestream
, ip
->i_ino
);
455 xfs_filestream_mount(
459 * The filestream timer tunable is currently fixed within the range of
460 * one second to four minutes, with five seconds being the default. The
461 * group count is somewhat arbitrary, but it'd be nice to adhere to the
462 * timer tunable to within about 10 percent. This requires at least 10
465 return xfs_mru_cache_create(&mp
->m_filestream
, xfs_fstrm_centisecs
* 10,
466 10, xfs_fstrm_free_func
);
470 xfs_filestream_unmount(
473 xfs_mru_cache_destroy(mp
->m_filestream
);