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"
37 #include "xfs_trace.h"
39 #ifdef XFS_FILESTREAMS_TRACE
41 ktrace_t *xfs_filestreams_trace_buf;
44 xfs_filestreams_trace(
45 xfs_mount_t *mp, /* mount point */
46 int type, /* type of trace */
47 const char *func, /* source function */
48 int line, /* source line number */
56 ktrace_enter(xfs_filestreams_trace_buf,
57 (void *)(__psint_t)(type | (line << 16)),
59 (void *)(__psunsigned_t)current_pid(),
61 (void *)(__psunsigned_t)arg0,
62 (void *)(__psunsigned_t)arg1,
63 (void *)(__psunsigned_t)arg2,
64 (void *)(__psunsigned_t)arg3,
65 (void *)(__psunsigned_t)arg4,
66 (void *)(__psunsigned_t)arg5,
67 NULL, NULL, NULL, NULL, NULL, NULL);
70 #define TRACE0(mp,t) TRACE6(mp,t,0,0,0,0,0,0)
71 #define TRACE1(mp,t,a0) TRACE6(mp,t,a0,0,0,0,0,0)
72 #define TRACE2(mp,t,a0,a1) TRACE6(mp,t,a0,a1,0,0,0,0)
73 #define TRACE3(mp,t,a0,a1,a2) TRACE6(mp,t,a0,a1,a2,0,0,0)
74 #define TRACE4(mp,t,a0,a1,a2,a3) TRACE6(mp,t,a0,a1,a2,a3,0,0)
75 #define TRACE5(mp,t,a0,a1,a2,a3,a4) TRACE6(mp,t,a0,a1,a2,a3,a4,0)
76 #define TRACE6(mp,t,a0,a1,a2,a3,a4,a5) \
77 xfs_filestreams_trace(mp, t, __func__, __LINE__, \
78 (__psunsigned_t)a0, (__psunsigned_t)a1, \
79 (__psunsigned_t)a2, (__psunsigned_t)a3, \
80 (__psunsigned_t)a4, (__psunsigned_t)a5)
82 #define TRACE_AG_SCAN(mp, ag, ag2) \
83 TRACE2(mp, XFS_FSTRM_KTRACE_AGSCAN, ag, ag2);
84 #define TRACE_AG_PICK1(mp, max_ag, maxfree) \
85 TRACE2(mp, XFS_FSTRM_KTRACE_AGPICK1, max_ag, maxfree);
86 #define TRACE_AG_PICK2(mp, ag, ag2, cnt, free, scan, flag) \
87 TRACE6(mp, XFS_FSTRM_KTRACE_AGPICK2, ag, ag2, \
88 cnt, free, scan, flag)
89 #define TRACE_UPDATE(mp, ip, ag, cnt, ag2, cnt2) \
90 TRACE5(mp, XFS_FSTRM_KTRACE_UPDATE, ip, ag, cnt, ag2, cnt2)
91 #define TRACE_FREE(mp, ip, pip, ag, cnt) \
92 TRACE4(mp, XFS_FSTRM_KTRACE_FREE, ip, pip, ag, cnt)
93 #define TRACE_LOOKUP(mp, ip, pip, ag, cnt) \
94 TRACE4(mp, XFS_FSTRM_KTRACE_ITEM_LOOKUP, ip, pip, ag, cnt)
95 #define TRACE_ASSOCIATE(mp, ip, pip, ag, cnt) \
96 TRACE4(mp, XFS_FSTRM_KTRACE_ASSOCIATE, ip, pip, ag, cnt)
97 #define TRACE_MOVEAG(mp, ip, pip, oag, ocnt, nag, ncnt) \
98 TRACE6(mp, XFS_FSTRM_KTRACE_MOVEAG, ip, pip, oag, ocnt, nag, ncnt)
99 #define TRACE_ORPHAN(mp, ip, ag) \
100 TRACE2(mp, XFS_FSTRM_KTRACE_ORPHAN, ip, ag);
104 #define TRACE_AG_SCAN(mp, ag, ag2)
105 #define TRACE_AG_PICK1(mp, max_ag, maxfree)
106 #define TRACE_AG_PICK2(mp, ag, ag2, cnt, free, scan, flag)
107 #define TRACE_UPDATE(mp, ip, ag, cnt, ag2, cnt2)
108 #define TRACE_FREE(mp, ip, pip, ag, cnt)
109 #define TRACE_LOOKUP(mp, ip, pip, ag, cnt)
110 #define TRACE_ASSOCIATE(mp, ip, pip, ag, cnt)
111 #define TRACE_MOVEAG(mp, ip, pip, oag, ocnt, nag, ncnt)
112 #define TRACE_ORPHAN(mp, ip, ag)
115 static kmem_zone_t *item_zone;
118 * Structure for associating a file or a directory with an allocation group.
119 * The parent directory pointer is only needed for files, but since there will
120 * generally be vastly more files than directories in the cache, using the same
121 * data structure simplifies the code with very little memory overhead.
123 typedef struct fstrm_item
125 xfs_agnumber_t ag; /* AG currently in use for the file/directory. */
126 xfs_inode_t *ip; /* inode self-pointer. */
127 xfs_inode_t *pip; /* Parent directory inode pointer. */
132 * Scan the AGs starting at startag looking for an AG that isn't in use and has
133 * at least minlen blocks free.
136 _xfs_filestream_pick_ag(
138 xfs_agnumber_t startag,
143 int streams, max_streams;
144 int err, trylock, nscan;
145 xfs_extlen_t longest, free, minfree, maxfree = 0;
146 xfs_agnumber_t ag, max_ag = NULLAGNUMBER;
147 struct xfs_perag *pag;
149 /* 2% of an AG's blocks must be free for it to be chosen. */
150 minfree = mp->m_sb.sb_agblocks / 50;
155 /* For the first pass, don't sleep trying to init the per-AG. */
156 trylock = XFS_ALLOC_FLAG_TRYLOCK;
158 for (nscan = 0; 1; nscan++) {
159 pag = xfs_perag_get(mp, ag);
160 TRACE_AG_SCAN(mp, ag, atomic_read(&pag->pagf_fstrms));
162 if (!pag->pagf_init) {
163 err = xfs_alloc_pagf_init(mp, NULL, ag, trylock);
164 if (err && !trylock) {
170 /* Might fail sometimes during the 1st pass with trylock set. */
174 /* Keep track of the AG with the most free blocks. */
175 if (pag->pagf_freeblks > maxfree) {
176 maxfree = pag->pagf_freeblks;
177 max_streams = atomic_read(&pag->pagf_fstrms);
182 * The AG reference count does two things: it enforces mutual
183 * exclusion when examining the suitability of an AG in this
184 * loop, and it guards against two filestreams being established
185 * in the same AG as each other.
187 if (xfs_filestream_get_ag(mp, ag) > 1) {
188 xfs_filestream_put_ag(mp, ag);
192 longest = xfs_alloc_longest_free_extent(mp, pag);
193 if (((minlen && longest >= minlen) ||
194 (!minlen && pag->pagf_freeblks >= minfree)) &&
195 (!pag->pagf_metadata || !(flags & XFS_PICK_USERDATA) ||
196 (flags & XFS_PICK_LOWSPACE))) {
198 /* Break out, retaining the reference on the AG. */
199 free = pag->pagf_freeblks;
200 streams = atomic_read(&pag->pagf_fstrms);
206 /* Drop the reference on this AG, it's not usable. */
207 xfs_filestream_put_ag(mp, ag);
210 /* Move to the next AG, wrapping to AG 0 if necessary. */
211 if (++ag >= mp->m_sb.sb_agcount)
214 /* If a full pass of the AGs hasn't been done yet, continue. */
218 /* Allow sleeping in xfs_alloc_pagf_init() on the 2nd pass. */
224 /* Finally, if lowspace wasn't set, set it for the 3rd pass. */
225 if (!(flags & XFS_PICK_LOWSPACE)) {
226 flags |= XFS_PICK_LOWSPACE;
231 * Take the AG with the most free space, regardless of whether
232 * it's already in use by another filestream.
234 if (max_ag != NULLAGNUMBER) {
235 xfs_filestream_get_ag(mp, max_ag);
236 TRACE_AG_PICK1(mp, max_ag, maxfree);
237 streams = max_streams;
243 /* take AG 0 if none matched */
244 TRACE_AG_PICK1(mp, max_ag, maxfree);
249 TRACE_AG_PICK2(mp, startag, *agp, streams, free, nscan, flags);
255 * Set the allocation group number for a file or a directory, updating inode
256 * references and per-AG references as appropriate.
259 _xfs_filestream_update_ag(
266 xfs_mru_cache_t *cache;
268 xfs_agnumber_t old_ag;
269 xfs_inode_t *old_pip;
272 * Either ip is a regular file and pip is a directory, or ip is a
273 * directory and pip is NULL.
275 ASSERT(ip && (((ip->i_d.di_mode & S_IFREG) && pip &&
276 (pip->i_d.di_mode & S_IFDIR)) ||
277 ((ip->i_d.di_mode & S_IFDIR) && !pip)));
280 cache = mp->m_filestream;
282 item = xfs_mru_cache_lookup(cache, ip->i_ino);
284 ASSERT(item->ip == ip);
289 xfs_mru_cache_done(cache);
292 * If the AG has changed, drop the old ref and take a new one,
293 * effectively transferring the reference from old to new AG.
296 xfs_filestream_put_ag(mp, old_ag);
297 xfs_filestream_get_ag(mp, ag);
301 * If ip is a file and its pip has changed, drop the old ref and
304 if (pip && pip != old_pip) {
309 TRACE_UPDATE(mp, ip, old_ag, xfs_filestream_peek_ag(mp, old_ag),
310 ag, xfs_filestream_peek_ag(mp, ag));
314 item = kmem_zone_zalloc(item_zone, KM_MAYFAIL);
322 err = xfs_mru_cache_insert(cache, ip->i_ino, item);
324 kmem_zone_free(item_zone, item);
328 /* Take a reference on the AG. */
329 xfs_filestream_get_ag(mp, ag);
332 * Take a reference on the inode itself regardless of whether it's a
333 * regular file or a directory.
338 * In the case of a regular file, take a reference on the parent inode
339 * as well to ensure it remains in-core.
344 TRACE_UPDATE(mp, ip, ag, xfs_filestream_peek_ag(mp, ag),
345 ag, xfs_filestream_peek_ag(mp, ag));
350 /* xfs_fstrm_free_func(): callback for freeing cached stream items. */
356 fstrm_item_t *item = (fstrm_item_t *)data;
357 xfs_inode_t *ip = item->ip;
360 ASSERT(ip->i_ino == ino);
362 xfs_iflags_clear(ip, XFS_IFILESTREAM);
364 /* Drop the reference taken on the AG when the item was added. */
365 ref = xfs_filestream_put_ag(ip->i_mount, item->ag);
368 TRACE_FREE(ip->i_mount, ip, item->pip, item->ag,
369 xfs_filestream_peek_ag(ip->i_mount, item->ag));
372 * _xfs_filestream_update_ag() always takes a reference on the inode
373 * itself, whether it's a file or a directory. Release it here.
374 * This can result in the inode being freed and so we must
375 * not hold any inode locks when freeing filesstreams objects
376 * otherwise we can deadlock here.
381 * In the case of a regular file, _xfs_filestream_update_ag() also
382 * takes a ref on the parent inode to keep it in-core. Release that
388 /* Finally, free the memory allocated for the item. */
389 kmem_zone_free(item_zone, item);
393 * xfs_filestream_init() is called at xfs initialisation time to set up the
394 * memory zone that will be used for filestream data structure allocation.
397 xfs_filestream_init(void)
399 item_zone = kmem_zone_init(sizeof(fstrm_item_t), "fstrm_item");
407 * xfs_filestream_uninit() is called at xfs termination time to destroy the
408 * memory zone that was used for filestream data structure allocation.
411 xfs_filestream_uninit(void)
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 * Return the AG of the filestream the file or directory belongs to, or
459 * NULLAGNUMBER otherwise.
462 xfs_filestream_lookup_ag(
465 xfs_mru_cache_t *cache;
470 if (!(ip->i_d.di_mode & (S_IFREG | S_IFDIR))) {
475 cache = ip->i_mount->m_filestream;
476 item = xfs_mru_cache_lookup(cache, ip->i_ino);
478 TRACE_LOOKUP(ip->i_mount, ip, NULL, NULLAGNUMBER, 0);
482 ASSERT(ip == item->ip);
484 ref = xfs_filestream_peek_ag(ip->i_mount, ag);
485 xfs_mru_cache_done(cache);
487 TRACE_LOOKUP(ip->i_mount, ip, item->pip, ag, ref);
492 * xfs_filestream_associate() should only be called to associate a regular file
493 * with its parent directory. Calling it with a child directory isn't
494 * appropriate because filestreams don't apply to entire directory hierarchies.
495 * Creating a file in a child directory of an existing filestream directory
496 * starts a new filestream with its own allocation group association.
498 * Returns < 0 on error, 0 if successful association occurred, > 0 if
499 * we failed to get an association because of locking issues.
502 xfs_filestream_associate(
507 xfs_mru_cache_t *cache;
509 xfs_agnumber_t ag, rotorstep, startag;
512 ASSERT(pip->i_d.di_mode & S_IFDIR);
513 ASSERT(ip->i_d.di_mode & S_IFREG);
514 if (!(pip->i_d.di_mode & S_IFDIR) || !(ip->i_d.di_mode & S_IFREG))
518 cache = mp->m_filestream;
521 * We have a problem, Houston.
523 * Taking the iolock here violates inode locking order - we already
524 * hold the ilock. Hence if we block getting this lock we may never
525 * wake. Unfortunately, that means if we can't get the lock, we're
526 * screwed in terms of getting a stream association - we can't spin
527 * waiting for the lock because someone else is waiting on the lock we
528 * hold and we cannot drop that as we are in a transaction here.
530 * Lucky for us, this inversion is not a problem because it's a
531 * directory inode that we are trying to lock here.
533 * So, if we can't get the iolock without sleeping then just give up
535 if (!xfs_ilock_nowait(pip, XFS_IOLOCK_EXCL))
538 /* If the parent directory is already in the cache, use its AG. */
539 item = xfs_mru_cache_lookup(cache, pip->i_ino);
541 ASSERT(item->ip == pip);
543 xfs_mru_cache_done(cache);
545 TRACE_LOOKUP(mp, pip, pip, ag, xfs_filestream_peek_ag(mp, ag));
546 err = _xfs_filestream_update_ag(ip, pip, ag);
552 * Set the starting AG using the rotor for inode32, otherwise
553 * use the directory inode's AG.
555 if (mp->m_flags & XFS_MOUNT_32BITINODES) {
556 rotorstep = xfs_rotorstep;
557 startag = (mp->m_agfrotor / rotorstep) % mp->m_sb.sb_agcount;
558 mp->m_agfrotor = (mp->m_agfrotor + 1) %
559 (mp->m_sb.sb_agcount * rotorstep);
561 startag = XFS_INO_TO_AGNO(mp, pip->i_ino);
563 /* Pick a new AG for the parent inode starting at startag. */
564 err = _xfs_filestream_pick_ag(mp, startag, &ag, 0, 0);
565 if (err || ag == NULLAGNUMBER)
568 /* Associate the parent inode with the AG. */
569 err = _xfs_filestream_update_ag(pip, NULL, ag);
573 /* Associate the file inode with the AG. */
574 err = _xfs_filestream_update_ag(ip, pip, ag);
578 TRACE_ASSOCIATE(mp, ip, pip, ag, xfs_filestream_peek_ag(mp, ag));
582 * If _xfs_filestream_pick_ag() returned a valid AG, remove the
583 * reference it took on it, since the file and directory will have taken
584 * their own now if they were successfully cached.
586 if (ag != NULLAGNUMBER)
587 xfs_filestream_put_ag(mp, ag);
590 xfs_iunlock(pip, XFS_IOLOCK_EXCL);
595 * Pick a new allocation group for the current file and its file stream. This
596 * function is called by xfs_bmap_filestreams() with the mount point's per-ag
600 xfs_filestream_new_ag(
605 xfs_inode_t *ip, *pip = NULL;
607 xfs_mru_cache_t *cache;
609 fstrm_item_t *dir, *file;
610 xfs_agnumber_t ag = NULLAGNUMBER;
614 cache = mp->m_filestream;
619 * Look for the file in the cache, removing it if it's found. Doing
620 * this allows it to be held across the dir lookup that follows.
622 file = xfs_mru_cache_remove(cache, ip->i_ino);
624 ASSERT(ip == file->ip);
626 /* Save the file's parent inode and old AG number for later. */
630 /* Look for the file's directory in the cache. */
631 dir = xfs_mru_cache_lookup(cache, pip->i_ino);
633 ASSERT(pip == dir->ip);
636 * If the directory has already moved on to a new AG,
637 * use that AG as the new AG for the file. Don't
638 * forget to twiddle the AG refcounts to match the
641 if (dir->ag != file->ag) {
642 xfs_filestream_put_ag(mp, file->ag);
643 xfs_filestream_get_ag(mp, dir->ag);
644 *agp = file->ag = dir->ag;
647 xfs_mru_cache_done(cache);
651 * Put the file back in the cache. If this fails, the free
652 * function needs to be called to tidy up in the same way as if
653 * the item had simply expired from the cache.
655 err = xfs_mru_cache_insert(cache, ip->i_ino, file);
657 xfs_fstrm_free_func(ip->i_ino, file);
662 * If the file's AG was moved to the directory's new AG, there's
663 * nothing more to be done.
665 if (*agp != NULLAGNUMBER) {
666 TRACE_MOVEAG(mp, ip, pip,
667 ag, xfs_filestream_peek_ag(mp, ag),
668 *agp, xfs_filestream_peek_ag(mp, *agp));
674 * If the file's parent directory is known, take its iolock in exclusive
675 * mode to prevent two sibling files from racing each other to migrate
676 * themselves and their parent to different AGs.
679 xfs_ilock(pip, XFS_IOLOCK_EXCL);
682 * A new AG needs to be found for the file. If the file's parent
683 * directory is also known, it will be moved to the new AG as well to
684 * ensure that files created inside it in future use the new AG.
686 ag = (ag == NULLAGNUMBER) ? 0 : (ag + 1) % mp->m_sb.sb_agcount;
687 flags = (ap->userdata ? XFS_PICK_USERDATA : 0) |
688 (ap->low ? XFS_PICK_LOWSPACE : 0);
690 err = _xfs_filestream_pick_ag(mp, ag, agp, flags, minlen);
691 if (err || *agp == NULLAGNUMBER)
695 * If the file wasn't found in the file cache, then its parent directory
696 * inode isn't known. For this to have happened, the file must either
697 * be pre-existing, or it was created long enough ago that its cache
698 * entry has expired. This isn't the sort of usage that the filestreams
699 * allocator is trying to optimise, so there's no point trying to track
700 * its new AG somehow in the filestream data structures.
703 TRACE_ORPHAN(mp, ip, *agp);
707 /* Associate the parent inode with the AG. */
708 err = _xfs_filestream_update_ag(pip, NULL, *agp);
712 /* Associate the file inode with the AG. */
713 err = _xfs_filestream_update_ag(ip, pip, *agp);
717 TRACE_MOVEAG(mp, ip, pip, NULLAGNUMBER, 0,
718 *agp, xfs_filestream_peek_ag(mp, *agp));
722 * If _xfs_filestream_pick_ag() returned a valid AG, remove the
723 * reference it took on it, since the file and directory will have taken
724 * their own now if they were successfully cached.
726 if (*agp != NULLAGNUMBER)
727 xfs_filestream_put_ag(mp, *agp);
732 xfs_iunlock(pip, XFS_IOLOCK_EXCL);
738 * Remove an association between an inode and a filestream object.
739 * Typically this is done on last close of an unlinked file.
742 xfs_filestream_deassociate(
745 xfs_mru_cache_t *cache = ip->i_mount->m_filestream;
747 xfs_mru_cache_delete(cache, ip->i_ino);