KVM: SVM: delay svm_vcpu_init_msrpm after svm->vmcb is initialized
[linux-2.6-microblaze.git] / fs / xfs / xfs_filestream.c
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_alloc.h"
16 #include "xfs_mru_cache.h"
17 #include "xfs_trace.h"
18 #include "xfs_ag.h"
19 #include "xfs_ag_resv.h"
20 #include "xfs_trans.h"
21 #include "xfs_filestream.h"
22
23 struct xfs_fstrm_item {
24         struct xfs_mru_cache_elem       mru;
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 };
32
33 /*
34  * Allocation group filestream associations are tracked with per-ag atomic
35  * counters.  These counters allow xfs_filestream_pick_ag() to tell whether a
36  * particular AG already has active filestreams associated with it.
37  */
38 int
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 }
77
78 static void
79 xfs_fstrm_free_func(
80         void                    *data,
81         struct xfs_mru_cache_elem *mru)
82 {
83         struct xfs_mount        *mp = data;
84         struct xfs_fstrm_item   *item =
85                 container_of(mru, struct xfs_fstrm_item, mru);
86
87         xfs_filestream_put_ag(mp, item->ag);
88         trace_xfs_filestream_free(mp, mru->key, item->ag);
89
90         kmem_free(item);
91 }
92
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
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)
104 {
105         struct xfs_mount        *mp = ip->i_mount;
106         struct xfs_fstrm_item   *item;
107         struct xfs_perag        *pag;
108         xfs_extlen_t            longest, free = 0, minfree, maxfree = 0;
109         xfs_agnumber_t          ag, max_ag = NULLAGNUMBER;
110         int                     err, trylock, nscan;
111
112         ASSERT(S_ISDIR(VFS_I(ip)->i_mode));
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++) {
124                 trace_xfs_filestream_scan(mp, ip->i_ino, ag);
125
126                 pag = xfs_perag_get(mp, ag);
127
128                 if (!pag->pagf_init) {
129                         err = xfs_alloc_pagf_init(mp, NULL, ag, trylock);
130                         if (err) {
131                                 xfs_perag_put(pag);
132                                 if (err != -EAGAIN)
133                                         return err;
134                                 /* Couldn't lock the AGF, skip this AG. */
135                                 continue;
136                         }
137                 }
138
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
156                 longest = xfs_alloc_longest_free_extent(pag,
157                                 xfs_alloc_min_freelist(mp, pag),
158                                 xfs_ag_resv_needed(pag, XFS_AG_RESV_NONE));
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;
166                         xfs_perag_put(pag);
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:
174                 xfs_perag_put(pag);
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);
201                         free = maxfree;
202                         *agp = max_ag;
203                         break;
204                 }
205
206                 /* take AG 0 if none matched */
207                 trace_xfs_filestream_pick(ip, *agp, free, nscan);
208                 *agp = 0;
209                 return 0;
210         }
211
212         trace_xfs_filestream_pick(ip, *agp, free, nscan);
213
214         if (*agp == NULLAGNUMBER)
215                 return 0;
216
217         err = -ENOMEM;
218         item = kmem_alloc(sizeof(*item), KM_MAYFAIL);
219         if (!item)
220                 goto out_put_ag;
221
222         item->ag = *agp;
223
224         err = xfs_mru_cache_insert(mp->m_filestream, ip->i_ino, &item->mru);
225         if (err) {
226                 if (err == -EEXIST)
227                         err = 0;
228                 goto out_free_item;
229         }
230
231         return 0;
232
233 out_free_item:
234         kmem_free(item);
235 out_put_ag:
236         xfs_filestream_put_ag(mp, *agp);
237         return err;
238 }
239
240 static struct xfs_inode *
241 xfs_filestream_get_parent(
242         struct xfs_inode        *ip)
243 {
244         struct inode            *inode = VFS_I(ip), *dir = NULL;
245         struct dentry           *dentry, *parent;
246
247         dentry = d_find_alias(inode);
248         if (!dentry)
249                 goto out;
250
251         parent = dget_parent(dentry);
252         if (!parent)
253                 goto out_dput;
254
255         dir = igrab(d_inode(parent));
256         dput(parent);
257
258 out_dput:
259         dput(dentry);
260 out:
261         return dir ? XFS_I(dir) : NULL;
262 }
263
264 /*
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.
269  */
270 xfs_agnumber_t
271 xfs_filestream_lookup_ag(
272         struct xfs_inode        *ip)
273 {
274         struct xfs_mount        *mp = ip->i_mount;
275         struct xfs_inode        *pip = NULL;
276         xfs_agnumber_t          startag, ag = NULLAGNUMBER;
277         struct xfs_mru_cache_elem *mru;
278
279         ASSERT(S_ISREG(VFS_I(ip)->i_mode));
280
281         pip = xfs_filestream_get_parent(ip);
282         if (!pip)
283                 return NULLAGNUMBER;
284
285         mru = xfs_mru_cache_lookup(mp->m_filestream, pip->i_ino);
286         if (mru) {
287                 ag = container_of(mru, struct xfs_fstrm_item, mru)->ag;
288                 xfs_mru_cache_done(mp->m_filestream);
289
290                 trace_xfs_filestream_lookup(mp, ip->i_ino, ag);
291                 goto out;
292         }
293
294         /*
295          * Set the starting AG using the rotor for inode32, otherwise
296          * use the directory inode's AG.
297          */
298         if (mp->m_flags & XFS_MOUNT_32BITINODES) {
299                 xfs_agnumber_t   rotorstep = xfs_rotorstep;
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
306         if (xfs_filestream_pick_ag(pip, startag, &ag, 0, 0))
307                 ag = NULLAGNUMBER;
308 out:
309         xfs_irele(pip);
310         return ag;
311 }
312
313 /*
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.
318  */
319 int
320 xfs_filestream_new_ag(
321         struct xfs_bmalloca     *ap,
322         xfs_agnumber_t          *agp)
323 {
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;
328         int                     flags = 0;
329         int                     err = 0;
330         struct xfs_mru_cache_elem *mru;
331
332         *agp = NULLAGNUMBER;
333
334         pip = xfs_filestream_get_parent(ip);
335         if (!pip)
336                 goto exit;
337
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;
343         }
344
345         if (ap->datatype & XFS_ALLOC_USERDATA)
346                 flags |= XFS_PICK_USERDATA;
347         if (ap->tp->t_flags & XFS_TRANS_LOWMODE)
348                 flags |= XFS_PICK_LOWSPACE;
349
350         err = xfs_filestream_pick_ag(pip, startag, agp, flags, minlen);
351
352         /*
353          * Only free the item here so we skip over the old AG earlier.
354          */
355         if (mru)
356                 xfs_fstrm_free_func(mp, mru);
357
358         xfs_irele(pip);
359 exit:
360         if (*agp == NULLAGNUMBER)
361                 *agp = 0;
362         return err;
363 }
364
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 }
371
372 int
373 xfs_filestream_mount(
374         xfs_mount_t     *mp)
375 {
376         /*
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.
382          */
383         return xfs_mru_cache_create(&mp->m_filestream, mp,
384                         xfs_fstrm_centisecs * 10, 10, xfs_fstrm_free_func);
385 }
386
387 void
388 xfs_filestream_unmount(
389         xfs_mount_t     *mp)
390 {
391         xfs_mru_cache_destroy(mp->m_filestream);
392 }