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_format.h"
20 #include "xfs_log_format.h"
21 #include "xfs_trans_resv.h"
24 #include "xfs_mount.h"
26 #include "xfs_inode.h"
28 #include "xfs_bmap_util.h"
29 #include "xfs_alloc.h"
30 #include "xfs_mru_cache.h"
31 #include "xfs_dinode.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 struct xfs_mru_cache_elem mru
;
122 xfs_agnumber_t ag
; /* AG currently in use for the file/directory. */
123 xfs_inode_t
*ip
; /* inode self-pointer. */
124 xfs_inode_t
*pip
; /* Parent directory inode pointer. */
128 * Allocation group filestream associations are tracked with per-ag atomic
129 * counters. These counters allow _xfs_filestream_pick_ag() to tell whether a
130 * particular AG already has active filestreams associated with it. The mount
131 * point's m_peraglock is used to protect these counters from per-ag array
132 * re-allocation during a growfs operation. When xfs_growfs_data_private() is
133 * about to reallocate the array, it calls xfs_filestream_flush() with the
134 * m_peraglock held in write mode.
136 * Since xfs_mru_cache_flush() guarantees that all the free functions for all
137 * the cache elements have finished executing before it returns, it's safe for
138 * the free functions to use the atomic counters without m_peraglock protection.
139 * This allows the implementation of xfs_fstrm_free_func() to be agnostic about
140 * whether it was called with the m_peraglock held in read mode, write mode or
141 * not held at all. The race condition this addresses is the following:
143 * - The work queue scheduler fires and pulls a filestream directory cache
144 * element off the LRU end of the cache for deletion, then gets pre-empted.
145 * - A growfs operation grabs the m_peraglock in write mode, flushes all the
146 * remaining items from the cache and reallocates the mount point's per-ag
147 * array, resetting all the counters to zero.
148 * - The work queue thread resumes and calls the free function for the element
149 * it started cleaning up earlier. In the process it decrements the
150 * filestreams counter for an AG that now has no references.
152 * With a shrinkfs feature, the above scenario could panic the system.
154 * All other uses of the following macros should be protected by either the
155 * m_peraglock held in read mode, or the cache's internal locking exposed by the
156 * interval between a call to xfs_mru_cache_lookup() and a call to
157 * xfs_mru_cache_done(). In addition, the m_peraglock must be held in read mode
158 * when new elements are added to the cache.
160 * Combined, these locking rules ensure that no associations will ever exist in
161 * the cache that reference per-ag array elements that have since been
165 xfs_filestream_peek_ag(
169 struct xfs_perag
*pag
;
172 pag
= xfs_perag_get(mp
, agno
);
173 ret
= atomic_read(&pag
->pagf_fstrms
);
179 xfs_filestream_get_ag(
183 struct xfs_perag
*pag
;
186 pag
= xfs_perag_get(mp
, agno
);
187 ret
= atomic_inc_return(&pag
->pagf_fstrms
);
193 xfs_filestream_put_ag(
197 struct xfs_perag
*pag
;
199 pag
= xfs_perag_get(mp
, agno
);
200 atomic_dec(&pag
->pagf_fstrms
);
205 * Scan the AGs starting at startag looking for an AG that isn't in use and has
206 * at least minlen blocks free.
209 _xfs_filestream_pick_ag(
211 xfs_agnumber_t startag
,
216 int streams
, max_streams
;
217 int err
, trylock
, nscan
;
218 xfs_extlen_t longest
, free
, minfree
, maxfree
= 0;
219 xfs_agnumber_t ag
, max_ag
= NULLAGNUMBER
;
220 struct xfs_perag
*pag
;
222 /* 2% of an AG's blocks must be free for it to be chosen. */
223 minfree
= mp
->m_sb
.sb_agblocks
/ 50;
228 /* For the first pass, don't sleep trying to init the per-AG. */
229 trylock
= XFS_ALLOC_FLAG_TRYLOCK
;
231 for (nscan
= 0; 1; nscan
++) {
232 pag
= xfs_perag_get(mp
, ag
);
233 TRACE_AG_SCAN(mp
, ag
, atomic_read(&pag
->pagf_fstrms
));
235 if (!pag
->pagf_init
) {
236 err
= xfs_alloc_pagf_init(mp
, NULL
, ag
, trylock
);
237 if (err
&& !trylock
) {
243 /* Might fail sometimes during the 1st pass with trylock set. */
247 /* Keep track of the AG with the most free blocks. */
248 if (pag
->pagf_freeblks
> maxfree
) {
249 maxfree
= pag
->pagf_freeblks
;
250 max_streams
= atomic_read(&pag
->pagf_fstrms
);
255 * The AG reference count does two things: it enforces mutual
256 * exclusion when examining the suitability of an AG in this
257 * loop, and it guards against two filestreams being established
258 * in the same AG as each other.
260 if (xfs_filestream_get_ag(mp
, ag
) > 1) {
261 xfs_filestream_put_ag(mp
, ag
);
265 longest
= xfs_alloc_longest_free_extent(mp
, pag
);
266 if (((minlen
&& longest
>= minlen
) ||
267 (!minlen
&& pag
->pagf_freeblks
>= minfree
)) &&
268 (!pag
->pagf_metadata
|| !(flags
& XFS_PICK_USERDATA
) ||
269 (flags
& XFS_PICK_LOWSPACE
))) {
271 /* Break out, retaining the reference on the AG. */
272 free
= pag
->pagf_freeblks
;
273 streams
= atomic_read(&pag
->pagf_fstrms
);
279 /* Drop the reference on this AG, it's not usable. */
280 xfs_filestream_put_ag(mp
, ag
);
283 /* Move to the next AG, wrapping to AG 0 if necessary. */
284 if (++ag
>= mp
->m_sb
.sb_agcount
)
287 /* If a full pass of the AGs hasn't been done yet, continue. */
291 /* Allow sleeping in xfs_alloc_pagf_init() on the 2nd pass. */
297 /* Finally, if lowspace wasn't set, set it for the 3rd pass. */
298 if (!(flags
& XFS_PICK_LOWSPACE
)) {
299 flags
|= XFS_PICK_LOWSPACE
;
304 * Take the AG with the most free space, regardless of whether
305 * it's already in use by another filestream.
307 if (max_ag
!= NULLAGNUMBER
) {
308 xfs_filestream_get_ag(mp
, max_ag
);
309 TRACE_AG_PICK1(mp
, max_ag
, maxfree
);
310 streams
= max_streams
;
316 /* take AG 0 if none matched */
317 TRACE_AG_PICK1(mp
, max_ag
, maxfree
);
322 TRACE_AG_PICK2(mp
, startag
, *agp
, streams
, free
, nscan
, flags
);
328 * Set the allocation group number for a file or a directory, updating inode
329 * references and per-AG references as appropriate.
332 _xfs_filestream_update_ag(
340 xfs_agnumber_t old_ag
;
341 xfs_inode_t
*old_pip
;
342 struct xfs_mru_cache_elem
*mru
;
345 * Either ip is a regular file and pip is a directory, or ip is a
346 * directory and pip is NULL.
348 ASSERT(ip
&& ((S_ISREG(ip
->i_d
.di_mode
) && pip
&&
349 S_ISDIR(pip
->i_d
.di_mode
)) ||
350 (S_ISDIR(ip
->i_d
.di_mode
) && !pip
)));
354 mru
= xfs_mru_cache_lookup(mp
->m_filestream
, ip
->i_ino
);
356 item
= container_of(mru
, fstrm_item_t
, mru
);
358 ASSERT(item
->ip
== ip
);
363 xfs_mru_cache_done(mp
->m_filestream
);
366 * If the AG has changed, drop the old ref and take a new one,
367 * effectively transferring the reference from old to new AG.
370 xfs_filestream_put_ag(mp
, old_ag
);
371 xfs_filestream_get_ag(mp
, ag
);
375 * If ip is a file and its pip has changed, drop the old ref and
378 if (pip
&& pip
!= old_pip
) {
383 TRACE_UPDATE(mp
, ip
, old_ag
, xfs_filestream_peek_ag(mp
, old_ag
),
384 ag
, xfs_filestream_peek_ag(mp
, ag
));
388 item
= kmem_zone_zalloc(item_zone
, KM_MAYFAIL
);
396 err
= xfs_mru_cache_insert(mp
->m_filestream
, ip
->i_ino
, &item
->mru
);
398 kmem_zone_free(item_zone
, item
);
402 /* Take a reference on the AG. */
403 xfs_filestream_get_ag(mp
, ag
);
406 * Take a reference on the inode itself regardless of whether it's a
407 * regular file or a directory.
412 * In the case of a regular file, take a reference on the parent inode
413 * as well to ensure it remains in-core.
418 TRACE_UPDATE(mp
, ip
, ag
, xfs_filestream_peek_ag(mp
, ag
),
419 ag
, xfs_filestream_peek_ag(mp
, ag
));
424 /* xfs_fstrm_free_func(): callback for freeing cached stream items. */
427 struct xfs_mru_cache_elem
*mru
)
430 container_of(mru
, fstrm_item_t
, mru
);
431 xfs_inode_t
*ip
= item
->ip
;
433 xfs_iflags_clear(ip
, XFS_IFILESTREAM
);
435 /* Drop the reference taken on the AG when the item was added. */
436 xfs_filestream_put_ag(ip
->i_mount
, item
->ag
);
438 TRACE_FREE(ip
->i_mount
, ip
, item
->pip
, item
->ag
,
439 xfs_filestream_peek_ag(ip
->i_mount
, item
->ag
));
442 * _xfs_filestream_update_ag() always takes a reference on the inode
443 * itself, whether it's a file or a directory. Release it here.
444 * This can result in the inode being freed and so we must
445 * not hold any inode locks when freeing filesstreams objects
446 * otherwise we can deadlock here.
451 * In the case of a regular file, _xfs_filestream_update_ag() also
452 * takes a ref on the parent inode to keep it in-core. Release that
458 /* Finally, free the memory allocated for the item. */
459 kmem_zone_free(item_zone
, item
);
463 * xfs_filestream_init() is called at xfs initialisation time to set up the
464 * memory zone that will be used for filestream data structure allocation.
467 xfs_filestream_init(void)
469 item_zone
= kmem_zone_init(sizeof(fstrm_item_t
), "fstrm_item");
477 * xfs_filestream_uninit() is called at xfs termination time to destroy the
478 * memory zone that was used for filestream data structure allocation.
481 xfs_filestream_uninit(void)
483 kmem_zone_destroy(item_zone
);
487 * xfs_filestream_mount() is called when a file system is mounted with the
488 * filestream option. It is responsible for allocating the data structures
489 * needed to track the new file system's file streams.
492 xfs_filestream_mount(
496 unsigned int lifetime
, grp_count
;
499 * The filestream timer tunable is currently fixed within the range of
500 * one second to four minutes, with five seconds being the default. The
501 * group count is somewhat arbitrary, but it'd be nice to adhere to the
502 * timer tunable to within about 10 percent. This requires at least 10
505 lifetime
= xfs_fstrm_centisecs
* 10;
508 err
= xfs_mru_cache_create(&mp
->m_filestream
, lifetime
, grp_count
,
509 xfs_fstrm_free_func
);
515 * xfs_filestream_unmount() is called when a file system that was mounted with
516 * the filestream option is unmounted. It drains the data structures created
517 * to track the file system's file streams and frees all the memory that was
521 xfs_filestream_unmount(
524 xfs_mru_cache_destroy(mp
->m_filestream
);
528 * Return the AG of the filestream the file or directory belongs to, or
529 * NULLAGNUMBER otherwise.
532 xfs_filestream_lookup_ag(
535 struct xfs_mount
*mp
= ip
->i_mount
;
536 struct xfs_mru_cache_elem
*mru
;
541 if (!S_ISREG(ip
->i_d
.di_mode
) && !S_ISDIR(ip
->i_d
.di_mode
)) {
546 mru
= xfs_mru_cache_lookup(mp
->m_filestream
, ip
->i_ino
);
548 TRACE_LOOKUP(ip
->i_mount
, ip
, NULL
, NULLAGNUMBER
, 0);
552 item
= container_of(mru
, fstrm_item_t
, mru
);
553 ASSERT(ip
== item
->ip
);
555 ref
= xfs_filestream_peek_ag(ip
->i_mount
, ag
);
556 xfs_mru_cache_done(mp
->m_filestream
);
558 TRACE_LOOKUP(ip
->i_mount
, ip
, item
->pip
, ag
, ref
);
563 * xfs_filestream_associate() should only be called to associate a regular file
564 * with its parent directory. Calling it with a child directory isn't
565 * appropriate because filestreams don't apply to entire directory hierarchies.
566 * Creating a file in a child directory of an existing filestream directory
567 * starts a new filestream with its own allocation group association.
569 * Returns < 0 on error, 0 if successful association occurred, > 0 if
570 * we failed to get an association because of locking issues.
573 xfs_filestream_associate(
577 struct xfs_mru_cache_elem
*mru
;
580 xfs_agnumber_t ag
, rotorstep
, startag
;
583 ASSERT(S_ISDIR(pip
->i_d
.di_mode
));
584 ASSERT(S_ISREG(ip
->i_d
.di_mode
));
585 if (!S_ISDIR(pip
->i_d
.di_mode
) || !S_ISREG(ip
->i_d
.di_mode
))
591 * We have a problem, Houston.
593 * Taking the iolock here violates inode locking order - we already
594 * hold the ilock. Hence if we block getting this lock we may never
595 * wake. Unfortunately, that means if we can't get the lock, we're
596 * screwed in terms of getting a stream association - we can't spin
597 * waiting for the lock because someone else is waiting on the lock we
598 * hold and we cannot drop that as we are in a transaction here.
600 * Lucky for us, this inversion is not a problem because it's a
601 * directory inode that we are trying to lock here.
603 * So, if we can't get the iolock without sleeping then just give up
605 if (!xfs_ilock_nowait(pip
, XFS_IOLOCK_EXCL
))
608 /* If the parent directory is already in the cache, use its AG. */
609 mru
= xfs_mru_cache_lookup(mp
->m_filestream
, pip
->i_ino
);
611 item
= container_of(mru
, fstrm_item_t
, mru
);
613 ASSERT(item
->ip
== pip
);
615 xfs_mru_cache_done(mp
->m_filestream
);
617 TRACE_LOOKUP(mp
, pip
, pip
, ag
, xfs_filestream_peek_ag(mp
, ag
));
618 err
= _xfs_filestream_update_ag(ip
, pip
, ag
);
624 * Set the starting AG using the rotor for inode32, otherwise
625 * use the directory inode's AG.
627 if (mp
->m_flags
& XFS_MOUNT_32BITINODES
) {
628 rotorstep
= xfs_rotorstep
;
629 startag
= (mp
->m_agfrotor
/ rotorstep
) % mp
->m_sb
.sb_agcount
;
630 mp
->m_agfrotor
= (mp
->m_agfrotor
+ 1) %
631 (mp
->m_sb
.sb_agcount
* rotorstep
);
633 startag
= XFS_INO_TO_AGNO(mp
, pip
->i_ino
);
635 /* Pick a new AG for the parent inode starting at startag. */
636 err
= _xfs_filestream_pick_ag(mp
, startag
, &ag
, 0, 0);
637 if (err
|| ag
== NULLAGNUMBER
)
640 /* Associate the parent inode with the AG. */
641 err
= _xfs_filestream_update_ag(pip
, NULL
, ag
);
645 /* Associate the file inode with the AG. */
646 err
= _xfs_filestream_update_ag(ip
, pip
, ag
);
650 TRACE_ASSOCIATE(mp
, ip
, pip
, ag
, xfs_filestream_peek_ag(mp
, ag
));
654 * If _xfs_filestream_pick_ag() returned a valid AG, remove the
655 * reference it took on it, since the file and directory will have taken
656 * their own now if they were successfully cached.
658 if (ag
!= NULLAGNUMBER
)
659 xfs_filestream_put_ag(mp
, ag
);
662 xfs_iunlock(pip
, XFS_IOLOCK_EXCL
);
667 * Pick a new allocation group for the current file and its file stream. This
668 * function is called by xfs_bmap_filestreams() with the mount point's per-ag
672 xfs_filestream_new_ag(
673 struct xfs_bmalloca
*ap
,
676 struct xfs_mru_cache_elem
*mru
, *mru2
;
678 xfs_inode_t
*ip
, *pip
= NULL
;
681 fstrm_item_t
*dir
, *file
;
682 xfs_agnumber_t ag
= NULLAGNUMBER
;
690 * Look for the file in the cache, removing it if it's found. Doing
691 * this allows it to be held across the dir lookup that follows.
693 mru
= xfs_mru_cache_remove(mp
->m_filestream
, ip
->i_ino
);
695 file
= container_of(mru
, fstrm_item_t
, mru
);
696 ASSERT(ip
== file
->ip
);
698 /* Save the file's parent inode and old AG number for later. */
702 /* Look for the file's directory in the cache. */
703 mru2
= xfs_mru_cache_lookup(mp
->m_filestream
, pip
->i_ino
);
705 dir
= container_of(mru2
, fstrm_item_t
, mru
);
706 ASSERT(pip
== dir
->ip
);
709 * If the directory has already moved on to a new AG,
710 * use that AG as the new AG for the file. Don't
711 * forget to twiddle the AG refcounts to match the
714 if (dir
->ag
!= file
->ag
) {
715 xfs_filestream_put_ag(mp
, file
->ag
);
716 xfs_filestream_get_ag(mp
, dir
->ag
);
717 *agp
= file
->ag
= dir
->ag
;
720 xfs_mru_cache_done(mp
->m_filestream
);
724 * Put the file back in the cache. If this fails, the free
725 * function needs to be called to tidy up in the same way as if
726 * the item had simply expired from the cache.
728 err
= xfs_mru_cache_insert(mp
->m_filestream
, ip
->i_ino
, mru
);
730 xfs_fstrm_free_func(mru
);
735 * If the file's AG was moved to the directory's new AG, there's
736 * nothing more to be done.
738 if (*agp
!= NULLAGNUMBER
) {
739 TRACE_MOVEAG(mp
, ip
, pip
,
740 ag
, xfs_filestream_peek_ag(mp
, ag
),
741 *agp
, xfs_filestream_peek_ag(mp
, *agp
));
747 * If the file's parent directory is known, take its iolock in exclusive
748 * mode to prevent two sibling files from racing each other to migrate
749 * themselves and their parent to different AGs.
751 * Note that we lock the parent directory iolock inside the child
752 * iolock here. That's fine as we never hold both parent and child
753 * iolock in any other place. This is different from the ilock,
754 * which requires locking of the child after the parent for namespace
758 xfs_ilock(pip
, XFS_IOLOCK_EXCL
| XFS_IOLOCK_PARENT
);
761 * A new AG needs to be found for the file. If the file's parent
762 * directory is also known, it will be moved to the new AG as well to
763 * ensure that files created inside it in future use the new AG.
765 ag
= (ag
== NULLAGNUMBER
) ? 0 : (ag
+ 1) % mp
->m_sb
.sb_agcount
;
766 flags
= (ap
->userdata
? XFS_PICK_USERDATA
: 0) |
767 (ap
->flist
->xbf_low
? XFS_PICK_LOWSPACE
: 0);
769 err
= _xfs_filestream_pick_ag(mp
, ag
, agp
, flags
, minlen
);
770 if (err
|| *agp
== NULLAGNUMBER
)
774 * If the file wasn't found in the file cache, then its parent directory
775 * inode isn't known. For this to have happened, the file must either
776 * be pre-existing, or it was created long enough ago that its cache
777 * entry has expired. This isn't the sort of usage that the filestreams
778 * allocator is trying to optimise, so there's no point trying to track
779 * its new AG somehow in the filestream data structures.
782 TRACE_ORPHAN(mp
, ip
, *agp
);
786 /* Associate the parent inode with the AG. */
787 err
= _xfs_filestream_update_ag(pip
, NULL
, *agp
);
791 /* Associate the file inode with the AG. */
792 err
= _xfs_filestream_update_ag(ip
, pip
, *agp
);
796 TRACE_MOVEAG(mp
, ip
, pip
, NULLAGNUMBER
, 0,
797 *agp
, xfs_filestream_peek_ag(mp
, *agp
));
801 * If _xfs_filestream_pick_ag() returned a valid AG, remove the
802 * reference it took on it, since the file and directory will have taken
803 * their own now if they were successfully cached.
805 if (*agp
!= NULLAGNUMBER
)
806 xfs_filestream_put_ag(mp
, *agp
);
811 xfs_iunlock(pip
, XFS_IOLOCK_EXCL
);
817 * Remove an association between an inode and a filestream object.
818 * Typically this is done on last close of an unlinked file.
821 xfs_filestream_deassociate(
824 xfs_mru_cache_delete(ip
->i_mount
->m_filestream
, ip
->i_ino
);