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. Must be called with the
257 * m_peraglock held in read mode.
260 _xfs_filestream_update_ag(
267 xfs_mru_cache_t *cache;
269 xfs_agnumber_t old_ag;
270 xfs_inode_t *old_pip;
273 * Either ip is a regular file and pip is a directory, or ip is a
274 * directory and pip is NULL.
276 ASSERT(ip && (((ip->i_d.di_mode & S_IFREG) && pip &&
277 (pip->i_d.di_mode & S_IFDIR)) ||
278 ((ip->i_d.di_mode & S_IFDIR) && !pip)));
281 cache = mp->m_filestream;
283 item = xfs_mru_cache_lookup(cache, ip->i_ino);
285 ASSERT(item->ip == ip);
290 xfs_mru_cache_done(cache);
293 * If the AG has changed, drop the old ref and take a new one,
294 * effectively transferring the reference from old to new AG.
297 xfs_filestream_put_ag(mp, old_ag);
298 xfs_filestream_get_ag(mp, ag);
302 * If ip is a file and its pip has changed, drop the old ref and
305 if (pip && pip != old_pip) {
310 TRACE_UPDATE(mp, ip, old_ag, xfs_filestream_peek_ag(mp, old_ag),
311 ag, xfs_filestream_peek_ag(mp, ag));
315 item = kmem_zone_zalloc(item_zone, KM_MAYFAIL);
323 err = xfs_mru_cache_insert(cache, ip->i_ino, item);
325 kmem_zone_free(item_zone, item);
329 /* Take a reference on the AG. */
330 xfs_filestream_get_ag(mp, ag);
333 * Take a reference on the inode itself regardless of whether it's a
334 * regular file or a directory.
339 * In the case of a regular file, take a reference on the parent inode
340 * as well to ensure it remains in-core.
345 TRACE_UPDATE(mp, ip, ag, xfs_filestream_peek_ag(mp, ag),
346 ag, xfs_filestream_peek_ag(mp, ag));
351 /* xfs_fstrm_free_func(): callback for freeing cached stream items. */
357 fstrm_item_t *item = (fstrm_item_t *)data;
358 xfs_inode_t *ip = item->ip;
361 ASSERT(ip->i_ino == ino);
363 xfs_iflags_clear(ip, XFS_IFILESTREAM);
365 /* Drop the reference taken on the AG when the item was added. */
366 ref = xfs_filestream_put_ag(ip->i_mount, item->ag);
369 TRACE_FREE(ip->i_mount, ip, item->pip, item->ag,
370 xfs_filestream_peek_ag(ip->i_mount, item->ag));
373 * _xfs_filestream_update_ag() always takes a reference on the inode
374 * itself, whether it's a file or a directory. Release it here.
375 * This can result in the inode being freed and so we must
376 * not hold any inode locks when freeing filesstreams objects
377 * otherwise we can deadlock here.
382 * In the case of a regular file, _xfs_filestream_update_ag() also
383 * takes a ref on the parent inode to keep it in-core. Release that
389 /* Finally, free the memory allocated for the item. */
390 kmem_zone_free(item_zone, item);
394 * xfs_filestream_init() is called at xfs initialisation time to set up the
395 * memory zone that will be used for filestream data structure allocation.
398 xfs_filestream_init(void)
400 item_zone = kmem_zone_init(sizeof(fstrm_item_t), "fstrm_item");
408 * xfs_filestream_uninit() is called at xfs termination time to destroy the
409 * memory zone that was used for filestream data structure allocation.
412 xfs_filestream_uninit(void)
414 kmem_zone_destroy(item_zone);
418 * xfs_filestream_mount() is called when a file system is mounted with the
419 * filestream option. It is responsible for allocating the data structures
420 * needed to track the new file system's file streams.
423 xfs_filestream_mount(
427 unsigned int lifetime, grp_count;
430 * The filestream timer tunable is currently fixed within the range of
431 * one second to four minutes, with five seconds being the default. The
432 * group count is somewhat arbitrary, but it'd be nice to adhere to the
433 * timer tunable to within about 10 percent. This requires at least 10
436 lifetime = xfs_fstrm_centisecs * 10;
439 err = xfs_mru_cache_create(&mp->m_filestream, lifetime, grp_count,
440 xfs_fstrm_free_func);
446 * xfs_filestream_unmount() is called when a file system that was mounted with
447 * the filestream option is unmounted. It drains the data structures created
448 * to track the file system's file streams and frees all the memory that was
452 xfs_filestream_unmount(
455 xfs_mru_cache_destroy(mp->m_filestream);
459 * If the mount point's m_perag array is going to be reallocated, all
460 * outstanding cache entries must be flushed to avoid accessing reference count
461 * addresses that have been freed. The call to xfs_filestream_flush() must be
462 * made inside the block that holds the m_peraglock in write mode to do the
466 xfs_filestream_flush(
469 xfs_mru_cache_flush(mp->m_filestream);
473 * Return the AG of the filestream the file or directory belongs to, or
474 * NULLAGNUMBER otherwise.
477 xfs_filestream_lookup_ag(
480 xfs_mru_cache_t *cache;
485 if (!(ip->i_d.di_mode & (S_IFREG | S_IFDIR))) {
490 cache = ip->i_mount->m_filestream;
491 item = xfs_mru_cache_lookup(cache, ip->i_ino);
493 TRACE_LOOKUP(ip->i_mount, ip, NULL, NULLAGNUMBER, 0);
497 ASSERT(ip == item->ip);
499 ref = xfs_filestream_peek_ag(ip->i_mount, ag);
500 xfs_mru_cache_done(cache);
502 TRACE_LOOKUP(ip->i_mount, ip, item->pip, ag, ref);
507 * xfs_filestream_associate() should only be called to associate a regular file
508 * with its parent directory. Calling it with a child directory isn't
509 * appropriate because filestreams don't apply to entire directory hierarchies.
510 * Creating a file in a child directory of an existing filestream directory
511 * starts a new filestream with its own allocation group association.
513 * Returns < 0 on error, 0 if successful association occurred, > 0 if
514 * we failed to get an association because of locking issues.
517 xfs_filestream_associate(
522 xfs_mru_cache_t *cache;
524 xfs_agnumber_t ag, rotorstep, startag;
527 ASSERT(pip->i_d.di_mode & S_IFDIR);
528 ASSERT(ip->i_d.di_mode & S_IFREG);
529 if (!(pip->i_d.di_mode & S_IFDIR) || !(ip->i_d.di_mode & S_IFREG))
533 cache = mp->m_filestream;
534 down_read(&mp->m_peraglock);
537 * We have a problem, Houston.
539 * Taking the iolock here violates inode locking order - we already
540 * hold the ilock. Hence if we block getting this lock we may never
541 * wake. Unfortunately, that means if we can't get the lock, we're
542 * screwed in terms of getting a stream association - we can't spin
543 * waiting for the lock because someone else is waiting on the lock we
544 * hold and we cannot drop that as we are in a transaction here.
546 * Lucky for us, this inversion is not a problem because it's a
547 * directory inode that we are trying to lock here.
549 * So, if we can't get the iolock without sleeping then just give up
551 if (!xfs_ilock_nowait(pip, XFS_IOLOCK_EXCL)) {
552 up_read(&mp->m_peraglock);
556 /* If the parent directory is already in the cache, use its AG. */
557 item = xfs_mru_cache_lookup(cache, pip->i_ino);
559 ASSERT(item->ip == pip);
561 xfs_mru_cache_done(cache);
563 TRACE_LOOKUP(mp, pip, pip, ag, xfs_filestream_peek_ag(mp, ag));
564 err = _xfs_filestream_update_ag(ip, pip, ag);
570 * Set the starting AG using the rotor for inode32, otherwise
571 * use the directory inode's AG.
573 if (mp->m_flags & XFS_MOUNT_32BITINODES) {
574 rotorstep = xfs_rotorstep;
575 startag = (mp->m_agfrotor / rotorstep) % mp->m_sb.sb_agcount;
576 mp->m_agfrotor = (mp->m_agfrotor + 1) %
577 (mp->m_sb.sb_agcount * rotorstep);
579 startag = XFS_INO_TO_AGNO(mp, pip->i_ino);
581 /* Pick a new AG for the parent inode starting at startag. */
582 err = _xfs_filestream_pick_ag(mp, startag, &ag, 0, 0);
583 if (err || ag == NULLAGNUMBER)
586 /* Associate the parent inode with the AG. */
587 err = _xfs_filestream_update_ag(pip, NULL, ag);
591 /* Associate the file inode with the AG. */
592 err = _xfs_filestream_update_ag(ip, pip, ag);
596 TRACE_ASSOCIATE(mp, ip, pip, ag, xfs_filestream_peek_ag(mp, ag));
600 * If _xfs_filestream_pick_ag() returned a valid AG, remove the
601 * reference it took on it, since the file and directory will have taken
602 * their own now if they were successfully cached.
604 if (ag != NULLAGNUMBER)
605 xfs_filestream_put_ag(mp, ag);
608 xfs_iunlock(pip, XFS_IOLOCK_EXCL);
609 up_read(&mp->m_peraglock);
614 * Pick a new allocation group for the current file and its file stream. This
615 * function is called by xfs_bmap_filestreams() with the mount point's per-ag
619 xfs_filestream_new_ag(
624 xfs_inode_t *ip, *pip = NULL;
626 xfs_mru_cache_t *cache;
628 fstrm_item_t *dir, *file;
629 xfs_agnumber_t ag = NULLAGNUMBER;
633 cache = mp->m_filestream;
638 * Look for the file in the cache, removing it if it's found. Doing
639 * this allows it to be held across the dir lookup that follows.
641 file = xfs_mru_cache_remove(cache, ip->i_ino);
643 ASSERT(ip == file->ip);
645 /* Save the file's parent inode and old AG number for later. */
649 /* Look for the file's directory in the cache. */
650 dir = xfs_mru_cache_lookup(cache, pip->i_ino);
652 ASSERT(pip == dir->ip);
655 * If the directory has already moved on to a new AG,
656 * use that AG as the new AG for the file. Don't
657 * forget to twiddle the AG refcounts to match the
660 if (dir->ag != file->ag) {
661 xfs_filestream_put_ag(mp, file->ag);
662 xfs_filestream_get_ag(mp, dir->ag);
663 *agp = file->ag = dir->ag;
666 xfs_mru_cache_done(cache);
670 * Put the file back in the cache. If this fails, the free
671 * function needs to be called to tidy up in the same way as if
672 * the item had simply expired from the cache.
674 err = xfs_mru_cache_insert(cache, ip->i_ino, file);
676 xfs_fstrm_free_func(ip->i_ino, file);
681 * If the file's AG was moved to the directory's new AG, there's
682 * nothing more to be done.
684 if (*agp != NULLAGNUMBER) {
685 TRACE_MOVEAG(mp, ip, pip,
686 ag, xfs_filestream_peek_ag(mp, ag),
687 *agp, xfs_filestream_peek_ag(mp, *agp));
693 * If the file's parent directory is known, take its iolock in exclusive
694 * mode to prevent two sibling files from racing each other to migrate
695 * themselves and their parent to different AGs.
698 xfs_ilock(pip, XFS_IOLOCK_EXCL);
701 * A new AG needs to be found for the file. If the file's parent
702 * directory is also known, it will be moved to the new AG as well to
703 * ensure that files created inside it in future use the new AG.
705 ag = (ag == NULLAGNUMBER) ? 0 : (ag + 1) % mp->m_sb.sb_agcount;
706 flags = (ap->userdata ? XFS_PICK_USERDATA : 0) |
707 (ap->low ? XFS_PICK_LOWSPACE : 0);
709 err = _xfs_filestream_pick_ag(mp, ag, agp, flags, minlen);
710 if (err || *agp == NULLAGNUMBER)
714 * If the file wasn't found in the file cache, then its parent directory
715 * inode isn't known. For this to have happened, the file must either
716 * be pre-existing, or it was created long enough ago that its cache
717 * entry has expired. This isn't the sort of usage that the filestreams
718 * allocator is trying to optimise, so there's no point trying to track
719 * its new AG somehow in the filestream data structures.
722 TRACE_ORPHAN(mp, ip, *agp);
726 /* Associate the parent inode with the AG. */
727 err = _xfs_filestream_update_ag(pip, NULL, *agp);
731 /* Associate the file inode with the AG. */
732 err = _xfs_filestream_update_ag(ip, pip, *agp);
736 TRACE_MOVEAG(mp, ip, pip, NULLAGNUMBER, 0,
737 *agp, xfs_filestream_peek_ag(mp, *agp));
741 * If _xfs_filestream_pick_ag() returned a valid AG, remove the
742 * reference it took on it, since the file and directory will have taken
743 * their own now if they were successfully cached.
745 if (*agp != NULLAGNUMBER)
746 xfs_filestream_put_ag(mp, *agp);
751 xfs_iunlock(pip, XFS_IOLOCK_EXCL);
757 * Remove an association between an inode and a filestream object.
758 * Typically this is done on last close of an unlinked file.
761 xfs_filestream_deassociate(
764 xfs_mru_cache_t *cache = ip->i_mount->m_filestream;
766 xfs_mru_cache_delete(cache, ip->i_ino);