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"
22 #include "xfs_dir2_sf.h"
23 #include "xfs_attr_sf.h"
24 #include "xfs_dinode.h"
25 #include "xfs_inode.h"
27 #include "xfs_dmapi.h"
29 #include "xfs_trans.h"
31 #include "xfs_mount.h"
33 #include "xfs_alloc.h"
34 #include "xfs_utils.h"
35 #include "xfs_mru_cache.h"
36 #include "xfs_filestream.h"
38 #ifdef XFS_FILESTREAMS_TRACE
40 ktrace_t *xfs_filestreams_trace_buf;
43 xfs_filestreams_trace(
44 xfs_mount_t *mp, /* mount point */
45 int type, /* type of trace */
46 const char *func, /* source function */
47 int line, /* source line number */
55 ktrace_enter(xfs_filestreams_trace_buf,
56 (void *)(__psint_t)(type | (line << 16)),
58 (void *)(__psunsigned_t)current_pid(),
60 (void *)(__psunsigned_t)arg0,
61 (void *)(__psunsigned_t)arg1,
62 (void *)(__psunsigned_t)arg2,
63 (void *)(__psunsigned_t)arg3,
64 (void *)(__psunsigned_t)arg4,
65 (void *)(__psunsigned_t)arg5,
66 NULL, NULL, NULL, NULL, NULL, NULL);
69 #define TRACE0(mp,t) TRACE6(mp,t,0,0,0,0,0,0)
70 #define TRACE1(mp,t,a0) TRACE6(mp,t,a0,0,0,0,0,0)
71 #define TRACE2(mp,t,a0,a1) TRACE6(mp,t,a0,a1,0,0,0,0)
72 #define TRACE3(mp,t,a0,a1,a2) TRACE6(mp,t,a0,a1,a2,0,0,0)
73 #define TRACE4(mp,t,a0,a1,a2,a3) TRACE6(mp,t,a0,a1,a2,a3,0,0)
74 #define TRACE5(mp,t,a0,a1,a2,a3,a4) TRACE6(mp,t,a0,a1,a2,a3,a4,0)
75 #define TRACE6(mp,t,a0,a1,a2,a3,a4,a5) \
76 xfs_filestreams_trace(mp, t, __func__, __LINE__, \
77 (__psunsigned_t)a0, (__psunsigned_t)a1, \
78 (__psunsigned_t)a2, (__psunsigned_t)a3, \
79 (__psunsigned_t)a4, (__psunsigned_t)a5)
81 #define TRACE_AG_SCAN(mp, ag, ag2) \
82 TRACE2(mp, XFS_FSTRM_KTRACE_AGSCAN, ag, ag2);
83 #define TRACE_AG_PICK1(mp, max_ag, maxfree) \
84 TRACE2(mp, XFS_FSTRM_KTRACE_AGPICK1, max_ag, maxfree);
85 #define TRACE_AG_PICK2(mp, ag, ag2, cnt, free, scan, flag) \
86 TRACE6(mp, XFS_FSTRM_KTRACE_AGPICK2, ag, ag2, \
87 cnt, free, scan, flag)
88 #define TRACE_UPDATE(mp, ip, ag, cnt, ag2, cnt2) \
89 TRACE5(mp, XFS_FSTRM_KTRACE_UPDATE, ip, ag, cnt, ag2, cnt2)
90 #define TRACE_FREE(mp, ip, pip, ag, cnt) \
91 TRACE4(mp, XFS_FSTRM_KTRACE_FREE, ip, pip, ag, cnt)
92 #define TRACE_LOOKUP(mp, ip, pip, ag, cnt) \
93 TRACE4(mp, XFS_FSTRM_KTRACE_ITEM_LOOKUP, ip, pip, ag, cnt)
94 #define TRACE_ASSOCIATE(mp, ip, pip, ag, cnt) \
95 TRACE4(mp, XFS_FSTRM_KTRACE_ASSOCIATE, ip, pip, ag, cnt)
96 #define TRACE_MOVEAG(mp, ip, pip, oag, ocnt, nag, ncnt) \
97 TRACE6(mp, XFS_FSTRM_KTRACE_MOVEAG, ip, pip, oag, ocnt, nag, ncnt)
98 #define TRACE_ORPHAN(mp, ip, ag) \
99 TRACE2(mp, XFS_FSTRM_KTRACE_ORPHAN, ip, ag);
103 #define TRACE_AG_SCAN(mp, ag, ag2)
104 #define TRACE_AG_PICK1(mp, max_ag, maxfree)
105 #define TRACE_AG_PICK2(mp, ag, ag2, cnt, free, scan, flag)
106 #define TRACE_UPDATE(mp, ip, ag, cnt, ag2, cnt2)
107 #define TRACE_FREE(mp, ip, pip, ag, cnt)
108 #define TRACE_LOOKUP(mp, ip, pip, ag, cnt)
109 #define TRACE_ASSOCIATE(mp, ip, pip, ag, cnt)
110 #define TRACE_MOVEAG(mp, ip, pip, oag, ocnt, nag, ncnt)
111 #define TRACE_ORPHAN(mp, ip, ag)
114 static kmem_zone_t *item_zone;
117 * Structure for associating a file or a directory with an allocation group.
118 * The parent directory pointer is only needed for files, but since there will
119 * generally be vastly more files than directories in the cache, using the same
120 * data structure simplifies the code with very little memory overhead.
122 typedef struct fstrm_item
124 xfs_agnumber_t ag; /* AG currently in use for the file/directory. */
125 xfs_inode_t *ip; /* inode self-pointer. */
126 xfs_inode_t *pip; /* Parent directory inode pointer. */
131 * Scan the AGs starting at startag looking for an AG that isn't in use and has
132 * at least minlen blocks free.
135 _xfs_filestream_pick_ag(
137 xfs_agnumber_t startag,
142 int err, trylock, nscan;
143 xfs_extlen_t longest, free, minfree, maxfree = 0;
144 xfs_agnumber_t ag, max_ag = NULLAGNUMBER;
145 struct xfs_perag *pag;
147 /* 2% of an AG's blocks must be free for it to be chosen. */
148 minfree = mp->m_sb.sb_agblocks / 50;
153 /* For the first pass, don't sleep trying to init the per-AG. */
154 trylock = XFS_ALLOC_FLAG_TRYLOCK;
156 for (nscan = 0; 1; nscan++) {
158 TRACE_AG_SCAN(mp, ag, xfs_filestream_peek_ag(mp, ag));
160 pag = mp->m_perag + ag;
162 if (!pag->pagf_init) {
163 err = xfs_alloc_pagf_init(mp, NULL, ag, trylock);
168 /* Might fail sometimes during the 1st pass with trylock set. */
172 /* Keep track of the AG with the most free blocks. */
173 if (pag->pagf_freeblks > maxfree) {
174 maxfree = pag->pagf_freeblks;
179 * The AG reference count does two things: it enforces mutual
180 * exclusion when examining the suitability of an AG in this
181 * loop, and it guards against two filestreams being established
182 * in the same AG as each other.
184 if (xfs_filestream_get_ag(mp, ag) > 1) {
185 xfs_filestream_put_ag(mp, ag);
189 longest = xfs_alloc_longest_free_extent(mp, pag);
190 if (((minlen && longest >= minlen) ||
191 (!minlen && pag->pagf_freeblks >= minfree)) &&
192 (!pag->pagf_metadata || !(flags & XFS_PICK_USERDATA) ||
193 (flags & XFS_PICK_LOWSPACE))) {
195 /* Break out, retaining the reference on the AG. */
196 free = pag->pagf_freeblks;
201 /* Drop the reference on this AG, it's not usable. */
202 xfs_filestream_put_ag(mp, ag);
204 /* Move to the next AG, wrapping to AG 0 if necessary. */
205 if (++ag >= mp->m_sb.sb_agcount)
208 /* If a full pass of the AGs hasn't been done yet, continue. */
212 /* Allow sleeping in xfs_alloc_pagf_init() on the 2nd pass. */
218 /* Finally, if lowspace wasn't set, set it for the 3rd pass. */
219 if (!(flags & XFS_PICK_LOWSPACE)) {
220 flags |= XFS_PICK_LOWSPACE;
225 * Take the AG with the most free space, regardless of whether
226 * it's already in use by another filestream.
228 if (max_ag != NULLAGNUMBER) {
229 xfs_filestream_get_ag(mp, max_ag);
230 TRACE_AG_PICK1(mp, max_ag, maxfree);
236 /* take AG 0 if none matched */
237 TRACE_AG_PICK1(mp, max_ag, maxfree);
242 TRACE_AG_PICK2(mp, startag, *agp, xfs_filestream_peek_ag(mp, *agp),
249 * Set the allocation group number for a file or a directory, updating inode
250 * references and per-AG references as appropriate. Must be called with the
251 * m_peraglock held in read mode.
254 _xfs_filestream_update_ag(
261 xfs_mru_cache_t *cache;
263 xfs_agnumber_t old_ag;
264 xfs_inode_t *old_pip;
267 * Either ip is a regular file and pip is a directory, or ip is a
268 * directory and pip is NULL.
270 ASSERT(ip && (((ip->i_d.di_mode & S_IFREG) && pip &&
271 (pip->i_d.di_mode & S_IFDIR)) ||
272 ((ip->i_d.di_mode & S_IFDIR) && !pip)));
275 cache = mp->m_filestream;
277 item = xfs_mru_cache_lookup(cache, ip->i_ino);
279 ASSERT(item->ip == ip);
284 xfs_mru_cache_done(cache);
287 * If the AG has changed, drop the old ref and take a new one,
288 * effectively transferring the reference from old to new AG.
291 xfs_filestream_put_ag(mp, old_ag);
292 xfs_filestream_get_ag(mp, ag);
296 * If ip is a file and its pip has changed, drop the old ref and
299 if (pip && pip != old_pip) {
304 TRACE_UPDATE(mp, ip, old_ag, xfs_filestream_peek_ag(mp, old_ag),
305 ag, xfs_filestream_peek_ag(mp, ag));
309 item = kmem_zone_zalloc(item_zone, KM_MAYFAIL);
317 err = xfs_mru_cache_insert(cache, ip->i_ino, item);
319 kmem_zone_free(item_zone, item);
323 /* Take a reference on the AG. */
324 xfs_filestream_get_ag(mp, ag);
327 * Take a reference on the inode itself regardless of whether it's a
328 * regular file or a directory.
333 * In the case of a regular file, take a reference on the parent inode
334 * as well to ensure it remains in-core.
339 TRACE_UPDATE(mp, ip, ag, xfs_filestream_peek_ag(mp, ag),
340 ag, xfs_filestream_peek_ag(mp, ag));
345 /* xfs_fstrm_free_func(): callback for freeing cached stream items. */
351 fstrm_item_t *item = (fstrm_item_t *)data;
352 xfs_inode_t *ip = item->ip;
355 ASSERT(ip->i_ino == ino);
357 xfs_iflags_clear(ip, XFS_IFILESTREAM);
359 /* Drop the reference taken on the AG when the item was added. */
360 ref = xfs_filestream_put_ag(ip->i_mount, item->ag);
363 TRACE_FREE(ip->i_mount, ip, item->pip, item->ag,
364 xfs_filestream_peek_ag(ip->i_mount, item->ag));
367 * _xfs_filestream_update_ag() always takes a reference on the inode
368 * itself, whether it's a file or a directory. Release it here.
369 * This can result in the inode being freed and so we must
370 * not hold any inode locks when freeing filesstreams objects
371 * otherwise we can deadlock here.
376 * In the case of a regular file, _xfs_filestream_update_ag() also
377 * takes a ref on the parent inode to keep it in-core. Release that
383 /* Finally, free the memory allocated for the item. */
384 kmem_zone_free(item_zone, item);
388 * xfs_filestream_init() is called at xfs initialisation time to set up the
389 * memory zone that will be used for filestream data structure allocation.
392 xfs_filestream_init(void)
394 item_zone = kmem_zone_init(sizeof(fstrm_item_t), "fstrm_item");
397 #ifdef XFS_FILESTREAMS_TRACE
398 xfs_filestreams_trace_buf = ktrace_alloc(XFS_FSTRM_KTRACE_SIZE, KM_NOFS);
404 * xfs_filestream_uninit() is called at xfs termination time to destroy the
405 * memory zone that was used for filestream data structure allocation.
408 xfs_filestream_uninit(void)
410 #ifdef XFS_FILESTREAMS_TRACE
411 ktrace_free(xfs_filestreams_trace_buf);
413 kmem_zone_destroy(item_zone);
417 * xfs_filestream_mount() is called when a file system is mounted with the
418 * filestream option. It is responsible for allocating the data structures
419 * needed to track the new file system's file streams.
422 xfs_filestream_mount(
426 unsigned int lifetime, grp_count;
429 * The filestream timer tunable is currently fixed within the range of
430 * one second to four minutes, with five seconds being the default. The
431 * group count is somewhat arbitrary, but it'd be nice to adhere to the
432 * timer tunable to within about 10 percent. This requires at least 10
435 lifetime = xfs_fstrm_centisecs * 10;
438 err = xfs_mru_cache_create(&mp->m_filestream, lifetime, grp_count,
439 xfs_fstrm_free_func);
445 * xfs_filestream_unmount() is called when a file system that was mounted with
446 * the filestream option is unmounted. It drains the data structures created
447 * to track the file system's file streams and frees all the memory that was
451 xfs_filestream_unmount(
454 xfs_mru_cache_destroy(mp->m_filestream);
458 * If the mount point's m_perag array is going to be reallocated, all
459 * outstanding cache entries must be flushed to avoid accessing reference count
460 * addresses that have been freed. The call to xfs_filestream_flush() must be
461 * made inside the block that holds the m_peraglock in write mode to do the
465 xfs_filestream_flush(
468 xfs_mru_cache_flush(mp->m_filestream);
472 * Return the AG of the filestream the file or directory belongs to, or
473 * NULLAGNUMBER otherwise.
476 xfs_filestream_lookup_ag(
479 xfs_mru_cache_t *cache;
484 if (!(ip->i_d.di_mode & (S_IFREG | S_IFDIR))) {
489 cache = ip->i_mount->m_filestream;
490 item = xfs_mru_cache_lookup(cache, ip->i_ino);
492 TRACE_LOOKUP(ip->i_mount, ip, NULL, NULLAGNUMBER, 0);
496 ASSERT(ip == item->ip);
498 ref = xfs_filestream_peek_ag(ip->i_mount, ag);
499 xfs_mru_cache_done(cache);
501 TRACE_LOOKUP(ip->i_mount, ip, item->pip, ag, ref);
506 * xfs_filestream_associate() should only be called to associate a regular file
507 * with its parent directory. Calling it with a child directory isn't
508 * appropriate because filestreams don't apply to entire directory hierarchies.
509 * Creating a file in a child directory of an existing filestream directory
510 * starts a new filestream with its own allocation group association.
512 * Returns < 0 on error, 0 if successful association occurred, > 0 if
513 * we failed to get an association because of locking issues.
516 xfs_filestream_associate(
521 xfs_mru_cache_t *cache;
523 xfs_agnumber_t ag, rotorstep, startag;
526 ASSERT(pip->i_d.di_mode & S_IFDIR);
527 ASSERT(ip->i_d.di_mode & S_IFREG);
528 if (!(pip->i_d.di_mode & S_IFDIR) || !(ip->i_d.di_mode & S_IFREG))
532 cache = mp->m_filestream;
533 down_read(&mp->m_peraglock);
536 * We have a problem, Houston.
538 * Taking the iolock here violates inode locking order - we already
539 * hold the ilock. Hence if we block getting this lock we may never
540 * wake. Unfortunately, that means if we can't get the lock, we're
541 * screwed in terms of getting a stream association - we can't spin
542 * waiting for the lock because someone else is waiting on the lock we
543 * hold and we cannot drop that as we are in a transaction here.
545 * Lucky for us, this inversion is rarely a problem because it's a
546 * directory inode that we are trying to lock here and that means the
547 * only place that matters is xfs_sync_inodes() and SYNC_DELWRI is
548 * used. i.e. freeze, remount-ro, quotasync or unmount.
550 * So, if we can't get the iolock without sleeping then just give up
552 if (!xfs_ilock_nowait(pip, XFS_IOLOCK_EXCL)) {
553 up_read(&mp->m_peraglock);
557 /* If the parent directory is already in the cache, use its AG. */
558 item = xfs_mru_cache_lookup(cache, pip->i_ino);
560 ASSERT(item->ip == pip);
562 xfs_mru_cache_done(cache);
564 TRACE_LOOKUP(mp, pip, pip, ag, xfs_filestream_peek_ag(mp, ag));
565 err = _xfs_filestream_update_ag(ip, pip, ag);
571 * Set the starting AG using the rotor for inode32, otherwise
572 * use the directory inode's AG.
574 if (mp->m_flags & XFS_MOUNT_32BITINODES) {
575 rotorstep = xfs_rotorstep;
576 startag = (mp->m_agfrotor / rotorstep) % mp->m_sb.sb_agcount;
577 mp->m_agfrotor = (mp->m_agfrotor + 1) %
578 (mp->m_sb.sb_agcount * rotorstep);
580 startag = XFS_INO_TO_AGNO(mp, pip->i_ino);
582 /* Pick a new AG for the parent inode starting at startag. */
583 err = _xfs_filestream_pick_ag(mp, startag, &ag, 0, 0);
584 if (err || ag == NULLAGNUMBER)
587 /* Associate the parent inode with the AG. */
588 err = _xfs_filestream_update_ag(pip, NULL, ag);
592 /* Associate the file inode with the AG. */
593 err = _xfs_filestream_update_ag(ip, pip, ag);
597 TRACE_ASSOCIATE(mp, ip, pip, ag, xfs_filestream_peek_ag(mp, ag));
601 * If _xfs_filestream_pick_ag() returned a valid AG, remove the
602 * reference it took on it, since the file and directory will have taken
603 * their own now if they were successfully cached.
605 if (ag != NULLAGNUMBER)
606 xfs_filestream_put_ag(mp, ag);
609 xfs_iunlock(pip, XFS_IOLOCK_EXCL);
610 up_read(&mp->m_peraglock);
615 * Pick a new allocation group for the current file and its file stream. This
616 * function is called by xfs_bmap_filestreams() with the mount point's per-ag
620 xfs_filestream_new_ag(
625 xfs_inode_t *ip, *pip = NULL;
627 xfs_mru_cache_t *cache;
629 fstrm_item_t *dir, *file;
630 xfs_agnumber_t ag = NULLAGNUMBER;
634 cache = mp->m_filestream;
639 * Look for the file in the cache, removing it if it's found. Doing
640 * this allows it to be held across the dir lookup that follows.
642 file = xfs_mru_cache_remove(cache, ip->i_ino);
644 ASSERT(ip == file->ip);
646 /* Save the file's parent inode and old AG number for later. */
650 /* Look for the file's directory in the cache. */
651 dir = xfs_mru_cache_lookup(cache, pip->i_ino);
653 ASSERT(pip == dir->ip);
656 * If the directory has already moved on to a new AG,
657 * use that AG as the new AG for the file. Don't
658 * forget to twiddle the AG refcounts to match the
661 if (dir->ag != file->ag) {
662 xfs_filestream_put_ag(mp, file->ag);
663 xfs_filestream_get_ag(mp, dir->ag);
664 *agp = file->ag = dir->ag;
667 xfs_mru_cache_done(cache);
671 * Put the file back in the cache. If this fails, the free
672 * function needs to be called to tidy up in the same way as if
673 * the item had simply expired from the cache.
675 err = xfs_mru_cache_insert(cache, ip->i_ino, file);
677 xfs_fstrm_free_func(ip->i_ino, file);
682 * If the file's AG was moved to the directory's new AG, there's
683 * nothing more to be done.
685 if (*agp != NULLAGNUMBER) {
686 TRACE_MOVEAG(mp, ip, pip,
687 ag, xfs_filestream_peek_ag(mp, ag),
688 *agp, xfs_filestream_peek_ag(mp, *agp));
694 * If the file's parent directory is known, take its iolock in exclusive
695 * mode to prevent two sibling files from racing each other to migrate
696 * themselves and their parent to different AGs.
699 xfs_ilock(pip, XFS_IOLOCK_EXCL);
702 * A new AG needs to be found for the file. If the file's parent
703 * directory is also known, it will be moved to the new AG as well to
704 * ensure that files created inside it in future use the new AG.
706 ag = (ag == NULLAGNUMBER) ? 0 : (ag + 1) % mp->m_sb.sb_agcount;
707 flags = (ap->userdata ? XFS_PICK_USERDATA : 0) |
708 (ap->low ? XFS_PICK_LOWSPACE : 0);
710 err = _xfs_filestream_pick_ag(mp, ag, agp, flags, minlen);
711 if (err || *agp == NULLAGNUMBER)
715 * If the file wasn't found in the file cache, then its parent directory
716 * inode isn't known. For this to have happened, the file must either
717 * be pre-existing, or it was created long enough ago that its cache
718 * entry has expired. This isn't the sort of usage that the filestreams
719 * allocator is trying to optimise, so there's no point trying to track
720 * its new AG somehow in the filestream data structures.
723 TRACE_ORPHAN(mp, ip, *agp);
727 /* Associate the parent inode with the AG. */
728 err = _xfs_filestream_update_ag(pip, NULL, *agp);
732 /* Associate the file inode with the AG. */
733 err = _xfs_filestream_update_ag(ip, pip, *agp);
737 TRACE_MOVEAG(mp, ip, pip, NULLAGNUMBER, 0,
738 *agp, xfs_filestream_peek_ag(mp, *agp));
742 * If _xfs_filestream_pick_ag() returned a valid AG, remove the
743 * reference it took on it, since the file and directory will have taken
744 * their own now if they were successfully cached.
746 if (*agp != NULLAGNUMBER)
747 xfs_filestream_put_ag(mp, *agp);
752 xfs_iunlock(pip, XFS_IOLOCK_EXCL);
758 * Remove an association between an inode and a filestream object.
759 * Typically this is done on last close of an unlinked file.
762 xfs_filestream_deassociate(
765 xfs_mru_cache_t *cache = ip->i_mount->m_filestream;
767 xfs_mru_cache_delete(cache, ip->i_ino);