2 * Copyright (c) 2006-2007 Silicon Graphics, Inc.
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation.
9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
19 #include "xfs_bmap_btree.h"
21 #include "xfs_dinode.h"
22 #include "xfs_inode.h"
25 #include "xfs_trans.h"
27 #include "xfs_mount.h"
29 #include "xfs_alloc.h"
30 #include "xfs_utils.h"
31 #include "xfs_mru_cache.h"
32 #include "xfs_filestream.h"
33 #include "xfs_trace.h"
35 #ifdef XFS_FILESTREAMS_TRACE
37 ktrace_t
*xfs_filestreams_trace_buf
;
40 xfs_filestreams_trace(
41 xfs_mount_t
*mp
, /* mount point */
42 int type
, /* type of trace */
43 const char *func
, /* source function */
44 int line
, /* source line number */
52 ktrace_enter(xfs_filestreams_trace_buf
,
53 (void *)(__psint_t
)(type
| (line
<< 16)),
55 (void *)(__psunsigned_t
)current_pid(),
57 (void *)(__psunsigned_t
)arg0
,
58 (void *)(__psunsigned_t
)arg1
,
59 (void *)(__psunsigned_t
)arg2
,
60 (void *)(__psunsigned_t
)arg3
,
61 (void *)(__psunsigned_t
)arg4
,
62 (void *)(__psunsigned_t
)arg5
,
63 NULL
, NULL
, NULL
, NULL
, NULL
, NULL
);
66 #define TRACE0(mp,t) TRACE6(mp,t,0,0,0,0,0,0)
67 #define TRACE1(mp,t,a0) TRACE6(mp,t,a0,0,0,0,0,0)
68 #define TRACE2(mp,t,a0,a1) TRACE6(mp,t,a0,a1,0,0,0,0)
69 #define TRACE3(mp,t,a0,a1,a2) TRACE6(mp,t,a0,a1,a2,0,0,0)
70 #define TRACE4(mp,t,a0,a1,a2,a3) TRACE6(mp,t,a0,a1,a2,a3,0,0)
71 #define TRACE5(mp,t,a0,a1,a2,a3,a4) TRACE6(mp,t,a0,a1,a2,a3,a4,0)
72 #define TRACE6(mp,t,a0,a1,a2,a3,a4,a5) \
73 xfs_filestreams_trace(mp, t, __func__, __LINE__, \
74 (__psunsigned_t)a0, (__psunsigned_t)a1, \
75 (__psunsigned_t)a2, (__psunsigned_t)a3, \
76 (__psunsigned_t)a4, (__psunsigned_t)a5)
78 #define TRACE_AG_SCAN(mp, ag, ag2) \
79 TRACE2(mp, XFS_FSTRM_KTRACE_AGSCAN, ag, ag2);
80 #define TRACE_AG_PICK1(mp, max_ag, maxfree) \
81 TRACE2(mp, XFS_FSTRM_KTRACE_AGPICK1, max_ag, maxfree);
82 #define TRACE_AG_PICK2(mp, ag, ag2, cnt, free, scan, flag) \
83 TRACE6(mp, XFS_FSTRM_KTRACE_AGPICK2, ag, ag2, \
84 cnt, free, scan, flag)
85 #define TRACE_UPDATE(mp, ip, ag, cnt, ag2, cnt2) \
86 TRACE5(mp, XFS_FSTRM_KTRACE_UPDATE, ip, ag, cnt, ag2, cnt2)
87 #define TRACE_FREE(mp, ip, pip, ag, cnt) \
88 TRACE4(mp, XFS_FSTRM_KTRACE_FREE, ip, pip, ag, cnt)
89 #define TRACE_LOOKUP(mp, ip, pip, ag, cnt) \
90 TRACE4(mp, XFS_FSTRM_KTRACE_ITEM_LOOKUP, ip, pip, ag, cnt)
91 #define TRACE_ASSOCIATE(mp, ip, pip, ag, cnt) \
92 TRACE4(mp, XFS_FSTRM_KTRACE_ASSOCIATE, ip, pip, ag, cnt)
93 #define TRACE_MOVEAG(mp, ip, pip, oag, ocnt, nag, ncnt) \
94 TRACE6(mp, XFS_FSTRM_KTRACE_MOVEAG, ip, pip, oag, ocnt, nag, ncnt)
95 #define TRACE_ORPHAN(mp, ip, ag) \
96 TRACE2(mp, XFS_FSTRM_KTRACE_ORPHAN, ip, ag);
100 #define TRACE_AG_SCAN(mp, ag, ag2)
101 #define TRACE_AG_PICK1(mp, max_ag, maxfree)
102 #define TRACE_AG_PICK2(mp, ag, ag2, cnt, free, scan, flag)
103 #define TRACE_UPDATE(mp, ip, ag, cnt, ag2, cnt2)
104 #define TRACE_FREE(mp, ip, pip, ag, cnt)
105 #define TRACE_LOOKUP(mp, ip, pip, ag, cnt)
106 #define TRACE_ASSOCIATE(mp, ip, pip, ag, cnt)
107 #define TRACE_MOVEAG(mp, ip, pip, oag, ocnt, nag, ncnt)
108 #define TRACE_ORPHAN(mp, ip, ag)
111 static kmem_zone_t
*item_zone
;
114 * Structure for associating a file or a directory with an allocation group.
115 * The parent directory pointer is only needed for files, but since there will
116 * generally be vastly more files than directories in the cache, using the same
117 * data structure simplifies the code with very little memory overhead.
119 typedef struct fstrm_item
121 xfs_agnumber_t ag
; /* AG currently in use for the file/directory. */
122 xfs_inode_t
*ip
; /* inode self-pointer. */
123 xfs_inode_t
*pip
; /* Parent directory inode pointer. */
128 * Scan the AGs starting at startag looking for an AG that isn't in use and has
129 * at least minlen blocks free.
132 _xfs_filestream_pick_ag(
134 xfs_agnumber_t startag
,
139 int streams
, max_streams
;
140 int err
, trylock
, nscan
;
141 xfs_extlen_t longest
, free
, minfree
, maxfree
= 0;
142 xfs_agnumber_t ag
, max_ag
= NULLAGNUMBER
;
143 struct xfs_perag
*pag
;
145 /* 2% of an AG's blocks must be free for it to be chosen. */
146 minfree
= mp
->m_sb
.sb_agblocks
/ 50;
151 /* For the first pass, don't sleep trying to init the per-AG. */
152 trylock
= XFS_ALLOC_FLAG_TRYLOCK
;
154 for (nscan
= 0; 1; nscan
++) {
155 pag
= xfs_perag_get(mp
, ag
);
156 TRACE_AG_SCAN(mp
, ag
, atomic_read(&pag
->pagf_fstrms
));
158 if (!pag
->pagf_init
) {
159 err
= xfs_alloc_pagf_init(mp
, NULL
, ag
, trylock
);
160 if (err
&& !trylock
) {
166 /* Might fail sometimes during the 1st pass with trylock set. */
170 /* Keep track of the AG with the most free blocks. */
171 if (pag
->pagf_freeblks
> maxfree
) {
172 maxfree
= pag
->pagf_freeblks
;
173 max_streams
= atomic_read(&pag
->pagf_fstrms
);
178 * The AG reference count does two things: it enforces mutual
179 * exclusion when examining the suitability of an AG in this
180 * loop, and it guards against two filestreams being established
181 * in the same AG as each other.
183 if (xfs_filestream_get_ag(mp
, ag
) > 1) {
184 xfs_filestream_put_ag(mp
, ag
);
188 longest
= xfs_alloc_longest_free_extent(mp
, pag
);
189 if (((minlen
&& longest
>= minlen
) ||
190 (!minlen
&& pag
->pagf_freeblks
>= minfree
)) &&
191 (!pag
->pagf_metadata
|| !(flags
& XFS_PICK_USERDATA
) ||
192 (flags
& XFS_PICK_LOWSPACE
))) {
194 /* Break out, retaining the reference on the AG. */
195 free
= pag
->pagf_freeblks
;
196 streams
= atomic_read(&pag
->pagf_fstrms
);
202 /* Drop the reference on this AG, it's not usable. */
203 xfs_filestream_put_ag(mp
, ag
);
206 /* Move to the next AG, wrapping to AG 0 if necessary. */
207 if (++ag
>= mp
->m_sb
.sb_agcount
)
210 /* If a full pass of the AGs hasn't been done yet, continue. */
214 /* Allow sleeping in xfs_alloc_pagf_init() on the 2nd pass. */
220 /* Finally, if lowspace wasn't set, set it for the 3rd pass. */
221 if (!(flags
& XFS_PICK_LOWSPACE
)) {
222 flags
|= XFS_PICK_LOWSPACE
;
227 * Take the AG with the most free space, regardless of whether
228 * it's already in use by another filestream.
230 if (max_ag
!= NULLAGNUMBER
) {
231 xfs_filestream_get_ag(mp
, max_ag
);
232 TRACE_AG_PICK1(mp
, max_ag
, maxfree
);
233 streams
= max_streams
;
239 /* take AG 0 if none matched */
240 TRACE_AG_PICK1(mp
, max_ag
, maxfree
);
245 TRACE_AG_PICK2(mp
, startag
, *agp
, streams
, free
, nscan
, flags
);
251 * Set the allocation group number for a file or a directory, updating inode
252 * references and per-AG references as appropriate.
255 _xfs_filestream_update_ag(
262 xfs_mru_cache_t
*cache
;
264 xfs_agnumber_t old_ag
;
265 xfs_inode_t
*old_pip
;
268 * Either ip is a regular file and pip is a directory, or ip is a
269 * directory and pip is NULL.
271 ASSERT(ip
&& (((ip
->i_d
.di_mode
& S_IFREG
) && pip
&&
272 (pip
->i_d
.di_mode
& S_IFDIR
)) ||
273 ((ip
->i_d
.di_mode
& S_IFDIR
) && !pip
)));
276 cache
= mp
->m_filestream
;
278 item
= xfs_mru_cache_lookup(cache
, ip
->i_ino
);
280 ASSERT(item
->ip
== ip
);
285 xfs_mru_cache_done(cache
);
288 * If the AG has changed, drop the old ref and take a new one,
289 * effectively transferring the reference from old to new AG.
292 xfs_filestream_put_ag(mp
, old_ag
);
293 xfs_filestream_get_ag(mp
, ag
);
297 * If ip is a file and its pip has changed, drop the old ref and
300 if (pip
&& pip
!= old_pip
) {
305 TRACE_UPDATE(mp
, ip
, old_ag
, xfs_filestream_peek_ag(mp
, old_ag
),
306 ag
, xfs_filestream_peek_ag(mp
, ag
));
310 item
= kmem_zone_zalloc(item_zone
, KM_MAYFAIL
);
318 err
= xfs_mru_cache_insert(cache
, ip
->i_ino
, item
);
320 kmem_zone_free(item_zone
, item
);
324 /* Take a reference on the AG. */
325 xfs_filestream_get_ag(mp
, ag
);
328 * Take a reference on the inode itself regardless of whether it's a
329 * regular file or a directory.
334 * In the case of a regular file, take a reference on the parent inode
335 * as well to ensure it remains in-core.
340 TRACE_UPDATE(mp
, ip
, ag
, xfs_filestream_peek_ag(mp
, ag
),
341 ag
, xfs_filestream_peek_ag(mp
, ag
));
346 /* xfs_fstrm_free_func(): callback for freeing cached stream items. */
352 fstrm_item_t
*item
= (fstrm_item_t
*)data
;
353 xfs_inode_t
*ip
= item
->ip
;
356 ASSERT(ip
->i_ino
== ino
);
358 xfs_iflags_clear(ip
, XFS_IFILESTREAM
);
360 /* Drop the reference taken on the AG when the item was added. */
361 ref
= xfs_filestream_put_ag(ip
->i_mount
, item
->ag
);
364 TRACE_FREE(ip
->i_mount
, ip
, item
->pip
, item
->ag
,
365 xfs_filestream_peek_ag(ip
->i_mount
, item
->ag
));
368 * _xfs_filestream_update_ag() always takes a reference on the inode
369 * itself, whether it's a file or a directory. Release it here.
370 * This can result in the inode being freed and so we must
371 * not hold any inode locks when freeing filesstreams objects
372 * otherwise we can deadlock here.
377 * In the case of a regular file, _xfs_filestream_update_ag() also
378 * takes a ref on the parent inode to keep it in-core. Release that
384 /* Finally, free the memory allocated for the item. */
385 kmem_zone_free(item_zone
, item
);
389 * xfs_filestream_init() is called at xfs initialisation time to set up the
390 * memory zone that will be used for filestream data structure allocation.
393 xfs_filestream_init(void)
395 item_zone
= kmem_zone_init(sizeof(fstrm_item_t
), "fstrm_item");
403 * xfs_filestream_uninit() is called at xfs termination time to destroy the
404 * memory zone that was used for filestream data structure allocation.
407 xfs_filestream_uninit(void)
409 kmem_zone_destroy(item_zone
);
413 * xfs_filestream_mount() is called when a file system is mounted with the
414 * filestream option. It is responsible for allocating the data structures
415 * needed to track the new file system's file streams.
418 xfs_filestream_mount(
422 unsigned int lifetime
, grp_count
;
425 * The filestream timer tunable is currently fixed within the range of
426 * one second to four minutes, with five seconds being the default. The
427 * group count is somewhat arbitrary, but it'd be nice to adhere to the
428 * timer tunable to within about 10 percent. This requires at least 10
431 lifetime
= xfs_fstrm_centisecs
* 10;
434 err
= xfs_mru_cache_create(&mp
->m_filestream
, lifetime
, grp_count
,
435 xfs_fstrm_free_func
);
441 * xfs_filestream_unmount() is called when a file system that was mounted with
442 * the filestream option is unmounted. It drains the data structures created
443 * to track the file system's file streams and frees all the memory that was
447 xfs_filestream_unmount(
450 xfs_mru_cache_destroy(mp
->m_filestream
);
454 * Return the AG of the filestream the file or directory belongs to, or
455 * NULLAGNUMBER otherwise.
458 xfs_filestream_lookup_ag(
461 xfs_mru_cache_t
*cache
;
466 if (!(ip
->i_d
.di_mode
& (S_IFREG
| S_IFDIR
))) {
471 cache
= ip
->i_mount
->m_filestream
;
472 item
= xfs_mru_cache_lookup(cache
, ip
->i_ino
);
474 TRACE_LOOKUP(ip
->i_mount
, ip
, NULL
, NULLAGNUMBER
, 0);
478 ASSERT(ip
== item
->ip
);
480 ref
= xfs_filestream_peek_ag(ip
->i_mount
, ag
);
481 xfs_mru_cache_done(cache
);
483 TRACE_LOOKUP(ip
->i_mount
, ip
, item
->pip
, ag
, ref
);
488 * xfs_filestream_associate() should only be called to associate a regular file
489 * with its parent directory. Calling it with a child directory isn't
490 * appropriate because filestreams don't apply to entire directory hierarchies.
491 * Creating a file in a child directory of an existing filestream directory
492 * starts a new filestream with its own allocation group association.
494 * Returns < 0 on error, 0 if successful association occurred, > 0 if
495 * we failed to get an association because of locking issues.
498 xfs_filestream_associate(
503 xfs_mru_cache_t
*cache
;
505 xfs_agnumber_t ag
, rotorstep
, startag
;
508 ASSERT(pip
->i_d
.di_mode
& S_IFDIR
);
509 ASSERT(ip
->i_d
.di_mode
& S_IFREG
);
510 if (!(pip
->i_d
.di_mode
& S_IFDIR
) || !(ip
->i_d
.di_mode
& S_IFREG
))
514 cache
= mp
->m_filestream
;
517 * We have a problem, Houston.
519 * Taking the iolock here violates inode locking order - we already
520 * hold the ilock. Hence if we block getting this lock we may never
521 * wake. Unfortunately, that means if we can't get the lock, we're
522 * screwed in terms of getting a stream association - we can't spin
523 * waiting for the lock because someone else is waiting on the lock we
524 * hold and we cannot drop that as we are in a transaction here.
526 * Lucky for us, this inversion is not a problem because it's a
527 * directory inode that we are trying to lock here.
529 * So, if we can't get the iolock without sleeping then just give up
531 if (!xfs_ilock_nowait(pip
, XFS_IOLOCK_EXCL
))
534 /* If the parent directory is already in the cache, use its AG. */
535 item
= xfs_mru_cache_lookup(cache
, pip
->i_ino
);
537 ASSERT(item
->ip
== pip
);
539 xfs_mru_cache_done(cache
);
541 TRACE_LOOKUP(mp
, pip
, pip
, ag
, xfs_filestream_peek_ag(mp
, ag
));
542 err
= _xfs_filestream_update_ag(ip
, pip
, ag
);
548 * Set the starting AG using the rotor for inode32, otherwise
549 * use the directory inode's AG.
551 if (mp
->m_flags
& XFS_MOUNT_32BITINODES
) {
552 rotorstep
= xfs_rotorstep
;
553 startag
= (mp
->m_agfrotor
/ rotorstep
) % mp
->m_sb
.sb_agcount
;
554 mp
->m_agfrotor
= (mp
->m_agfrotor
+ 1) %
555 (mp
->m_sb
.sb_agcount
* rotorstep
);
557 startag
= XFS_INO_TO_AGNO(mp
, pip
->i_ino
);
559 /* Pick a new AG for the parent inode starting at startag. */
560 err
= _xfs_filestream_pick_ag(mp
, startag
, &ag
, 0, 0);
561 if (err
|| ag
== NULLAGNUMBER
)
564 /* Associate the parent inode with the AG. */
565 err
= _xfs_filestream_update_ag(pip
, NULL
, ag
);
569 /* Associate the file inode with the AG. */
570 err
= _xfs_filestream_update_ag(ip
, pip
, ag
);
574 TRACE_ASSOCIATE(mp
, ip
, pip
, ag
, xfs_filestream_peek_ag(mp
, ag
));
578 * If _xfs_filestream_pick_ag() returned a valid AG, remove the
579 * reference it took on it, since the file and directory will have taken
580 * their own now if they were successfully cached.
582 if (ag
!= NULLAGNUMBER
)
583 xfs_filestream_put_ag(mp
, ag
);
586 xfs_iunlock(pip
, XFS_IOLOCK_EXCL
);
591 * Pick a new allocation group for the current file and its file stream. This
592 * function is called by xfs_bmap_filestreams() with the mount point's per-ag
596 xfs_filestream_new_ag(
601 xfs_inode_t
*ip
, *pip
= NULL
;
603 xfs_mru_cache_t
*cache
;
605 fstrm_item_t
*dir
, *file
;
606 xfs_agnumber_t ag
= NULLAGNUMBER
;
610 cache
= mp
->m_filestream
;
615 * Look for the file in the cache, removing it if it's found. Doing
616 * this allows it to be held across the dir lookup that follows.
618 file
= xfs_mru_cache_remove(cache
, ip
->i_ino
);
620 ASSERT(ip
== file
->ip
);
622 /* Save the file's parent inode and old AG number for later. */
626 /* Look for the file's directory in the cache. */
627 dir
= xfs_mru_cache_lookup(cache
, pip
->i_ino
);
629 ASSERT(pip
== dir
->ip
);
632 * If the directory has already moved on to a new AG,
633 * use that AG as the new AG for the file. Don't
634 * forget to twiddle the AG refcounts to match the
637 if (dir
->ag
!= file
->ag
) {
638 xfs_filestream_put_ag(mp
, file
->ag
);
639 xfs_filestream_get_ag(mp
, dir
->ag
);
640 *agp
= file
->ag
= dir
->ag
;
643 xfs_mru_cache_done(cache
);
647 * Put the file back in the cache. If this fails, the free
648 * function needs to be called to tidy up in the same way as if
649 * the item had simply expired from the cache.
651 err
= xfs_mru_cache_insert(cache
, ip
->i_ino
, file
);
653 xfs_fstrm_free_func(ip
->i_ino
, file
);
658 * If the file's AG was moved to the directory's new AG, there's
659 * nothing more to be done.
661 if (*agp
!= NULLAGNUMBER
) {
662 TRACE_MOVEAG(mp
, ip
, pip
,
663 ag
, xfs_filestream_peek_ag(mp
, ag
),
664 *agp
, xfs_filestream_peek_ag(mp
, *agp
));
670 * If the file's parent directory is known, take its iolock in exclusive
671 * mode to prevent two sibling files from racing each other to migrate
672 * themselves and their parent to different AGs.
675 xfs_ilock(pip
, XFS_IOLOCK_EXCL
);
678 * A new AG needs to be found for the file. If the file's parent
679 * directory is also known, it will be moved to the new AG as well to
680 * ensure that files created inside it in future use the new AG.
682 ag
= (ag
== NULLAGNUMBER
) ? 0 : (ag
+ 1) % mp
->m_sb
.sb_agcount
;
683 flags
= (ap
->userdata
? XFS_PICK_USERDATA
: 0) |
684 (ap
->low
? XFS_PICK_LOWSPACE
: 0);
686 err
= _xfs_filestream_pick_ag(mp
, ag
, agp
, flags
, minlen
);
687 if (err
|| *agp
== NULLAGNUMBER
)
691 * If the file wasn't found in the file cache, then its parent directory
692 * inode isn't known. For this to have happened, the file must either
693 * be pre-existing, or it was created long enough ago that its cache
694 * entry has expired. This isn't the sort of usage that the filestreams
695 * allocator is trying to optimise, so there's no point trying to track
696 * its new AG somehow in the filestream data structures.
699 TRACE_ORPHAN(mp
, ip
, *agp
);
703 /* Associate the parent inode with the AG. */
704 err
= _xfs_filestream_update_ag(pip
, NULL
, *agp
);
708 /* Associate the file inode with the AG. */
709 err
= _xfs_filestream_update_ag(ip
, pip
, *agp
);
713 TRACE_MOVEAG(mp
, ip
, pip
, NULLAGNUMBER
, 0,
714 *agp
, xfs_filestream_peek_ag(mp
, *agp
));
718 * If _xfs_filestream_pick_ag() returned a valid AG, remove the
719 * reference it took on it, since the file and directory will have taken
720 * their own now if they were successfully cached.
722 if (*agp
!= NULLAGNUMBER
)
723 xfs_filestream_put_ag(mp
, *agp
);
728 xfs_iunlock(pip
, XFS_IOLOCK_EXCL
);
734 * Remove an association between an inode and a filestream object.
735 * Typically this is done on last close of an unlinked file.
738 xfs_filestream_deassociate(
741 xfs_mru_cache_t
*cache
= ip
->i_mount
->m_filestream
;
743 xfs_mru_cache_delete(cache
, ip
->i_ino
);