blob: a631e1451abb992e21d08639e1f9fcfc428b86c4 [file] [log] [blame]
David Chinner2a82b8b2007-07-11 11:09:12 +10001/*
2 * Copyright (c) 2006-2007 Silicon Graphics, Inc.
3 * All Rights Reserved.
4 *
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.
8 *
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.
13 *
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
17 */
18#include "xfs.h"
19#include "xfs_bmap_btree.h"
20#include "xfs_inum.h"
21#include "xfs_dir2.h"
22#include "xfs_dir2_sf.h"
23#include "xfs_attr_sf.h"
24#include "xfs_dinode.h"
25#include "xfs_inode.h"
26#include "xfs_ag.h"
27#include "xfs_dmapi.h"
28#include "xfs_log.h"
29#include "xfs_trans.h"
30#include "xfs_sb.h"
31#include "xfs_mount.h"
32#include "xfs_bmap.h"
33#include "xfs_alloc.h"
34#include "xfs_utils.h"
35#include "xfs_mru_cache.h"
36#include "xfs_filestream.h"
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000037#include "xfs_trace.h"
David Chinner2a82b8b2007-07-11 11:09:12 +100038
39#ifdef XFS_FILESTREAMS_TRACE
40
41ktrace_t *xfs_filestreams_trace_buf;
42
43STATIC void
44xfs_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 */
49 __psunsigned_t arg0,
50 __psunsigned_t arg1,
51 __psunsigned_t arg2,
52 __psunsigned_t arg3,
53 __psunsigned_t arg4,
54 __psunsigned_t arg5)
55{
56 ktrace_enter(xfs_filestreams_trace_buf,
57 (void *)(__psint_t)(type | (line << 16)),
58 (void *)func,
59 (void *)(__psunsigned_t)current_pid(),
60 (void *)mp,
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);
68}
69
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) \
Harvey Harrison34a622b2008-04-10 12:19:21 +100077 xfs_filestreams_trace(mp, t, __func__, __LINE__, \
David Chinner2a82b8b2007-07-11 11:09:12 +100078 (__psunsigned_t)a0, (__psunsigned_t)a1, \
79 (__psunsigned_t)a2, (__psunsigned_t)a3, \
80 (__psunsigned_t)a4, (__psunsigned_t)a5)
81
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);
101
102
103#else
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)
113#endif
114
115static kmem_zone_t *item_zone;
116
117/*
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.
122 */
123typedef struct fstrm_item
124{
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. */
128} fstrm_item_t;
129
130
131/*
132 * Scan the AGs starting at startag looking for an AG that isn't in use and has
133 * at least minlen blocks free.
134 */
135static int
136_xfs_filestream_pick_ag(
137 xfs_mount_t *mp,
138 xfs_agnumber_t startag,
139 xfs_agnumber_t *agp,
140 int flags,
141 xfs_extlen_t minlen)
142{
143 int err, trylock, nscan;
Dave Chinner6cc87642009-03-16 08:29:46 +0100144 xfs_extlen_t longest, free, minfree, maxfree = 0;
David Chinner2a82b8b2007-07-11 11:09:12 +1000145 xfs_agnumber_t ag, max_ag = NULLAGNUMBER;
146 struct xfs_perag *pag;
147
148 /* 2% of an AG's blocks must be free for it to be chosen. */
149 minfree = mp->m_sb.sb_agblocks / 50;
150
151 ag = startag;
152 *agp = NULLAGNUMBER;
153
154 /* For the first pass, don't sleep trying to init the per-AG. */
155 trylock = XFS_ALLOC_FLAG_TRYLOCK;
156
157 for (nscan = 0; 1; nscan++) {
158
159 TRACE_AG_SCAN(mp, ag, xfs_filestream_peek_ag(mp, ag));
160
161 pag = mp->m_perag + ag;
162
163 if (!pag->pagf_init) {
164 err = xfs_alloc_pagf_init(mp, NULL, ag, trylock);
165 if (err && !trylock)
166 return err;
167 }
168
169 /* Might fail sometimes during the 1st pass with trylock set. */
170 if (!pag->pagf_init)
171 goto next_ag;
172
173 /* Keep track of the AG with the most free blocks. */
174 if (pag->pagf_freeblks > maxfree) {
175 maxfree = pag->pagf_freeblks;
176 max_ag = ag;
177 }
178
179 /*
180 * The AG reference count does two things: it enforces mutual
181 * exclusion when examining the suitability of an AG in this
182 * loop, and it guards against two filestreams being established
183 * in the same AG as each other.
184 */
185 if (xfs_filestream_get_ag(mp, ag) > 1) {
186 xfs_filestream_put_ag(mp, ag);
187 goto next_ag;
188 }
189
Dave Chinner6cc87642009-03-16 08:29:46 +0100190 longest = xfs_alloc_longest_free_extent(mp, pag);
David Chinner2a82b8b2007-07-11 11:09:12 +1000191 if (((minlen && longest >= minlen) ||
192 (!minlen && pag->pagf_freeblks >= minfree)) &&
193 (!pag->pagf_metadata || !(flags & XFS_PICK_USERDATA) ||
194 (flags & XFS_PICK_LOWSPACE))) {
195
196 /* Break out, retaining the reference on the AG. */
197 free = pag->pagf_freeblks;
198 *agp = ag;
199 break;
200 }
201
202 /* Drop the reference on this AG, it's not usable. */
203 xfs_filestream_put_ag(mp, ag);
204next_ag:
205 /* Move to the next AG, wrapping to AG 0 if necessary. */
206 if (++ag >= mp->m_sb.sb_agcount)
207 ag = 0;
208
209 /* If a full pass of the AGs hasn't been done yet, continue. */
210 if (ag != startag)
211 continue;
212
213 /* Allow sleeping in xfs_alloc_pagf_init() on the 2nd pass. */
214 if (trylock != 0) {
215 trylock = 0;
216 continue;
217 }
218
219 /* Finally, if lowspace wasn't set, set it for the 3rd pass. */
220 if (!(flags & XFS_PICK_LOWSPACE)) {
221 flags |= XFS_PICK_LOWSPACE;
222 continue;
223 }
224
225 /*
226 * Take the AG with the most free space, regardless of whether
227 * it's already in use by another filestream.
228 */
229 if (max_ag != NULLAGNUMBER) {
230 xfs_filestream_get_ag(mp, max_ag);
231 TRACE_AG_PICK1(mp, max_ag, maxfree);
232 free = maxfree;
233 *agp = max_ag;
234 break;
235 }
236
237 /* take AG 0 if none matched */
238 TRACE_AG_PICK1(mp, max_ag, maxfree);
239 *agp = 0;
240 return 0;
241 }
242
243 TRACE_AG_PICK2(mp, startag, *agp, xfs_filestream_peek_ag(mp, *agp),
244 free, nscan, flags);
245
246 return 0;
247}
248
249/*
250 * Set the allocation group number for a file or a directory, updating inode
251 * references and per-AG references as appropriate. Must be called with the
252 * m_peraglock held in read mode.
253 */
254static int
255_xfs_filestream_update_ag(
256 xfs_inode_t *ip,
257 xfs_inode_t *pip,
258 xfs_agnumber_t ag)
259{
260 int err = 0;
261 xfs_mount_t *mp;
262 xfs_mru_cache_t *cache;
263 fstrm_item_t *item;
264 xfs_agnumber_t old_ag;
265 xfs_inode_t *old_pip;
266
267 /*
268 * Either ip is a regular file and pip is a directory, or ip is a
269 * directory and pip is NULL.
270 */
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)));
274
275 mp = ip->i_mount;
276 cache = mp->m_filestream;
277
278 item = xfs_mru_cache_lookup(cache, ip->i_ino);
279 if (item) {
280 ASSERT(item->ip == ip);
281 old_ag = item->ag;
282 item->ag = ag;
283 old_pip = item->pip;
284 item->pip = pip;
285 xfs_mru_cache_done(cache);
286
287 /*
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.
290 */
291 if (ag != old_ag) {
292 xfs_filestream_put_ag(mp, old_ag);
293 xfs_filestream_get_ag(mp, ag);
294 }
295
296 /*
297 * If ip is a file and its pip has changed, drop the old ref and
298 * take a new one.
299 */
300 if (pip && pip != old_pip) {
301 IRELE(old_pip);
302 IHOLD(pip);
303 }
304
305 TRACE_UPDATE(mp, ip, old_ag, xfs_filestream_peek_ag(mp, old_ag),
306 ag, xfs_filestream_peek_ag(mp, ag));
307 return 0;
308 }
309
310 item = kmem_zone_zalloc(item_zone, KM_MAYFAIL);
311 if (!item)
312 return ENOMEM;
313
314 item->ag = ag;
315 item->ip = ip;
316 item->pip = pip;
317
318 err = xfs_mru_cache_insert(cache, ip->i_ino, item);
319 if (err) {
320 kmem_zone_free(item_zone, item);
321 return err;
322 }
323
324 /* Take a reference on the AG. */
325 xfs_filestream_get_ag(mp, ag);
326
327 /*
328 * Take a reference on the inode itself regardless of whether it's a
329 * regular file or a directory.
330 */
331 IHOLD(ip);
332
333 /*
334 * In the case of a regular file, take a reference on the parent inode
335 * as well to ensure it remains in-core.
336 */
337 if (pip)
338 IHOLD(pip);
339
340 TRACE_UPDATE(mp, ip, ag, xfs_filestream_peek_ag(mp, ag),
341 ag, xfs_filestream_peek_ag(mp, ag));
342
343 return 0;
344}
345
346/* xfs_fstrm_free_func(): callback for freeing cached stream items. */
David Chinnera8272ce2007-11-23 16:28:09 +1100347STATIC void
David Chinner2a82b8b2007-07-11 11:09:12 +1000348xfs_fstrm_free_func(
Eric Sandeenbcc7b442007-08-30 17:21:38 +1000349 unsigned long ino,
350 void *data)
David Chinner2a82b8b2007-07-11 11:09:12 +1000351{
Eric Sandeenbcc7b442007-08-30 17:21:38 +1000352 fstrm_item_t *item = (fstrm_item_t *)data;
David Chinner2a82b8b2007-07-11 11:09:12 +1000353 xfs_inode_t *ip = item->ip;
354 int ref;
355
356 ASSERT(ip->i_ino == ino);
357
358 xfs_iflags_clear(ip, XFS_IFILESTREAM);
359
360 /* Drop the reference taken on the AG when the item was added. */
361 ref = xfs_filestream_put_ag(ip->i_mount, item->ag);
362
363 ASSERT(ref >= 0);
364 TRACE_FREE(ip->i_mount, ip, item->pip, item->ag,
365 xfs_filestream_peek_ag(ip->i_mount, item->ag));
366
367 /*
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.
373 */
374 IRELE(ip);
375
376 /*
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
379 * too.
380 */
381 if (item->pip)
382 IRELE(item->pip);
383
384 /* Finally, free the memory allocated for the item. */
385 kmem_zone_free(item_zone, item);
386}
387
388/*
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.
391 */
392int
393xfs_filestream_init(void)
394{
395 item_zone = kmem_zone_init(sizeof(fstrm_item_t), "fstrm_item");
Christoph Hellwig9f8868f2008-07-18 17:11:46 +1000396 if (!item_zone)
397 return -ENOMEM;
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000398
Christoph Hellwig9f8868f2008-07-18 17:11:46 +1000399 return 0;
David Chinner2a82b8b2007-07-11 11:09:12 +1000400}
401
402/*
403 * xfs_filestream_uninit() is called at xfs termination time to destroy the
404 * memory zone that was used for filestream data structure allocation.
405 */
406void
407xfs_filestream_uninit(void)
408{
David Chinner2a82b8b2007-07-11 11:09:12 +1000409 kmem_zone_destroy(item_zone);
410}
411
412/*
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.
416 */
417int
418xfs_filestream_mount(
419 xfs_mount_t *mp)
420{
421 int err;
422 unsigned int lifetime, grp_count;
423
424 /*
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
429 * groups.
430 */
431 lifetime = xfs_fstrm_centisecs * 10;
432 grp_count = 10;
433
434 err = xfs_mru_cache_create(&mp->m_filestream, lifetime, grp_count,
Eric Sandeenbcc7b442007-08-30 17:21:38 +1000435 xfs_fstrm_free_func);
David Chinner2a82b8b2007-07-11 11:09:12 +1000436
437 return err;
438}
439
440/*
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
444 * allocated.
445 */
446void
447xfs_filestream_unmount(
448 xfs_mount_t *mp)
449{
450 xfs_mru_cache_destroy(mp->m_filestream);
451}
452
453/*
454 * If the mount point's m_perag array is going to be reallocated, all
455 * outstanding cache entries must be flushed to avoid accessing reference count
456 * addresses that have been freed. The call to xfs_filestream_flush() must be
457 * made inside the block that holds the m_peraglock in write mode to do the
458 * reallocation.
459 */
460void
461xfs_filestream_flush(
462 xfs_mount_t *mp)
463{
David Chinner65de5562007-08-16 15:21:11 +1000464 xfs_mru_cache_flush(mp->m_filestream);
David Chinner2a82b8b2007-07-11 11:09:12 +1000465}
466
467/*
468 * Return the AG of the filestream the file or directory belongs to, or
469 * NULLAGNUMBER otherwise.
470 */
471xfs_agnumber_t
472xfs_filestream_lookup_ag(
473 xfs_inode_t *ip)
474{
475 xfs_mru_cache_t *cache;
476 fstrm_item_t *item;
477 xfs_agnumber_t ag;
478 int ref;
479
480 if (!(ip->i_d.di_mode & (S_IFREG | S_IFDIR))) {
481 ASSERT(0);
482 return NULLAGNUMBER;
483 }
484
485 cache = ip->i_mount->m_filestream;
486 item = xfs_mru_cache_lookup(cache, ip->i_ino);
487 if (!item) {
488 TRACE_LOOKUP(ip->i_mount, ip, NULL, NULLAGNUMBER, 0);
489 return NULLAGNUMBER;
490 }
491
492 ASSERT(ip == item->ip);
493 ag = item->ag;
494 ref = xfs_filestream_peek_ag(ip->i_mount, ag);
495 xfs_mru_cache_done(cache);
496
497 TRACE_LOOKUP(ip->i_mount, ip, item->pip, ag, ref);
498 return ag;
499}
500
501/*
502 * xfs_filestream_associate() should only be called to associate a regular file
503 * with its parent directory. Calling it with a child directory isn't
504 * appropriate because filestreams don't apply to entire directory hierarchies.
505 * Creating a file in a child directory of an existing filestream directory
506 * starts a new filestream with its own allocation group association.
507 *
508 * Returns < 0 on error, 0 if successful association occurred, > 0 if
509 * we failed to get an association because of locking issues.
510 */
511int
512xfs_filestream_associate(
513 xfs_inode_t *pip,
514 xfs_inode_t *ip)
515{
516 xfs_mount_t *mp;
517 xfs_mru_cache_t *cache;
518 fstrm_item_t *item;
519 xfs_agnumber_t ag, rotorstep, startag;
520 int err = 0;
521
522 ASSERT(pip->i_d.di_mode & S_IFDIR);
523 ASSERT(ip->i_d.di_mode & S_IFREG);
524 if (!(pip->i_d.di_mode & S_IFDIR) || !(ip->i_d.di_mode & S_IFREG))
525 return -EINVAL;
526
527 mp = pip->i_mount;
528 cache = mp->m_filestream;
529 down_read(&mp->m_peraglock);
530
531 /*
532 * We have a problem, Houston.
533 *
534 * Taking the iolock here violates inode locking order - we already
535 * hold the ilock. Hence if we block getting this lock we may never
536 * wake. Unfortunately, that means if we can't get the lock, we're
537 * screwed in terms of getting a stream association - we can't spin
538 * waiting for the lock because someone else is waiting on the lock we
539 * hold and we cannot drop that as we are in a transaction here.
540 *
Christoph Hellwig075fe102009-06-08 15:35:48 +0200541 * Lucky for us, this inversion is not a problem because it's a
542 * directory inode that we are trying to lock here.
David Chinner2a82b8b2007-07-11 11:09:12 +1000543 *
544 * So, if we can't get the iolock without sleeping then just give up
545 */
546 if (!xfs_ilock_nowait(pip, XFS_IOLOCK_EXCL)) {
547 up_read(&mp->m_peraglock);
548 return 1;
549 }
550
551 /* If the parent directory is already in the cache, use its AG. */
552 item = xfs_mru_cache_lookup(cache, pip->i_ino);
553 if (item) {
554 ASSERT(item->ip == pip);
555 ag = item->ag;
556 xfs_mru_cache_done(cache);
557
558 TRACE_LOOKUP(mp, pip, pip, ag, xfs_filestream_peek_ag(mp, ag));
559 err = _xfs_filestream_update_ag(ip, pip, ag);
560
561 goto exit;
562 }
563
564 /*
565 * Set the starting AG using the rotor for inode32, otherwise
566 * use the directory inode's AG.
567 */
568 if (mp->m_flags & XFS_MOUNT_32BITINODES) {
569 rotorstep = xfs_rotorstep;
570 startag = (mp->m_agfrotor / rotorstep) % mp->m_sb.sb_agcount;
571 mp->m_agfrotor = (mp->m_agfrotor + 1) %
572 (mp->m_sb.sb_agcount * rotorstep);
573 } else
574 startag = XFS_INO_TO_AGNO(mp, pip->i_ino);
575
576 /* Pick a new AG for the parent inode starting at startag. */
577 err = _xfs_filestream_pick_ag(mp, startag, &ag, 0, 0);
578 if (err || ag == NULLAGNUMBER)
579 goto exit_did_pick;
580
581 /* Associate the parent inode with the AG. */
582 err = _xfs_filestream_update_ag(pip, NULL, ag);
583 if (err)
584 goto exit_did_pick;
585
586 /* Associate the file inode with the AG. */
587 err = _xfs_filestream_update_ag(ip, pip, ag);
588 if (err)
589 goto exit_did_pick;
590
591 TRACE_ASSOCIATE(mp, ip, pip, ag, xfs_filestream_peek_ag(mp, ag));
592
593exit_did_pick:
594 /*
595 * If _xfs_filestream_pick_ag() returned a valid AG, remove the
596 * reference it took on it, since the file and directory will have taken
597 * their own now if they were successfully cached.
598 */
599 if (ag != NULLAGNUMBER)
600 xfs_filestream_put_ag(mp, ag);
601
602exit:
603 xfs_iunlock(pip, XFS_IOLOCK_EXCL);
604 up_read(&mp->m_peraglock);
605 return -err;
606}
607
608/*
609 * Pick a new allocation group for the current file and its file stream. This
610 * function is called by xfs_bmap_filestreams() with the mount point's per-ag
611 * lock held.
612 */
613int
614xfs_filestream_new_ag(
615 xfs_bmalloca_t *ap,
616 xfs_agnumber_t *agp)
617{
618 int flags, err;
619 xfs_inode_t *ip, *pip = NULL;
620 xfs_mount_t *mp;
621 xfs_mru_cache_t *cache;
622 xfs_extlen_t minlen;
623 fstrm_item_t *dir, *file;
624 xfs_agnumber_t ag = NULLAGNUMBER;
625
626 ip = ap->ip;
627 mp = ip->i_mount;
628 cache = mp->m_filestream;
629 minlen = ap->alen;
630 *agp = NULLAGNUMBER;
631
632 /*
633 * Look for the file in the cache, removing it if it's found. Doing
634 * this allows it to be held across the dir lookup that follows.
635 */
636 file = xfs_mru_cache_remove(cache, ip->i_ino);
637 if (file) {
638 ASSERT(ip == file->ip);
639
640 /* Save the file's parent inode and old AG number for later. */
641 pip = file->pip;
642 ag = file->ag;
643
644 /* Look for the file's directory in the cache. */
645 dir = xfs_mru_cache_lookup(cache, pip->i_ino);
646 if (dir) {
647 ASSERT(pip == dir->ip);
648
649 /*
650 * If the directory has already moved on to a new AG,
651 * use that AG as the new AG for the file. Don't
652 * forget to twiddle the AG refcounts to match the
653 * movement.
654 */
655 if (dir->ag != file->ag) {
656 xfs_filestream_put_ag(mp, file->ag);
657 xfs_filestream_get_ag(mp, dir->ag);
658 *agp = file->ag = dir->ag;
659 }
660
661 xfs_mru_cache_done(cache);
662 }
663
664 /*
665 * Put the file back in the cache. If this fails, the free
666 * function needs to be called to tidy up in the same way as if
667 * the item had simply expired from the cache.
668 */
669 err = xfs_mru_cache_insert(cache, ip->i_ino, file);
670 if (err) {
671 xfs_fstrm_free_func(ip->i_ino, file);
672 return err;
673 }
674
675 /*
676 * If the file's AG was moved to the directory's new AG, there's
677 * nothing more to be done.
678 */
679 if (*agp != NULLAGNUMBER) {
680 TRACE_MOVEAG(mp, ip, pip,
681 ag, xfs_filestream_peek_ag(mp, ag),
682 *agp, xfs_filestream_peek_ag(mp, *agp));
683 return 0;
684 }
685 }
686
687 /*
688 * If the file's parent directory is known, take its iolock in exclusive
689 * mode to prevent two sibling files from racing each other to migrate
690 * themselves and their parent to different AGs.
691 */
692 if (pip)
693 xfs_ilock(pip, XFS_IOLOCK_EXCL);
694
695 /*
696 * A new AG needs to be found for the file. If the file's parent
697 * directory is also known, it will be moved to the new AG as well to
698 * ensure that files created inside it in future use the new AG.
699 */
700 ag = (ag == NULLAGNUMBER) ? 0 : (ag + 1) % mp->m_sb.sb_agcount;
701 flags = (ap->userdata ? XFS_PICK_USERDATA : 0) |
702 (ap->low ? XFS_PICK_LOWSPACE : 0);
703
704 err = _xfs_filestream_pick_ag(mp, ag, agp, flags, minlen);
705 if (err || *agp == NULLAGNUMBER)
706 goto exit;
707
708 /*
709 * If the file wasn't found in the file cache, then its parent directory
710 * inode isn't known. For this to have happened, the file must either
711 * be pre-existing, or it was created long enough ago that its cache
712 * entry has expired. This isn't the sort of usage that the filestreams
713 * allocator is trying to optimise, so there's no point trying to track
714 * its new AG somehow in the filestream data structures.
715 */
716 if (!pip) {
717 TRACE_ORPHAN(mp, ip, *agp);
718 goto exit;
719 }
720
721 /* Associate the parent inode with the AG. */
722 err = _xfs_filestream_update_ag(pip, NULL, *agp);
723 if (err)
724 goto exit;
725
726 /* Associate the file inode with the AG. */
727 err = _xfs_filestream_update_ag(ip, pip, *agp);
728 if (err)
729 goto exit;
730
731 TRACE_MOVEAG(mp, ip, pip, NULLAGNUMBER, 0,
732 *agp, xfs_filestream_peek_ag(mp, *agp));
733
734exit:
735 /*
736 * If _xfs_filestream_pick_ag() returned a valid AG, remove the
737 * reference it took on it, since the file and directory will have taken
738 * their own now if they were successfully cached.
739 */
740 if (*agp != NULLAGNUMBER)
741 xfs_filestream_put_ag(mp, *agp);
742 else
743 *agp = 0;
744
745 if (pip)
746 xfs_iunlock(pip, XFS_IOLOCK_EXCL);
747
748 return err;
749}
750
751/*
752 * Remove an association between an inode and a filestream object.
753 * Typically this is done on last close of an unlinked file.
754 */
755void
756xfs_filestream_deassociate(
757 xfs_inode_t *ip)
758{
759 xfs_mru_cache_t *cache = ip->i_mount->m_filestream;
760
761 xfs_mru_cache_delete(cache, ip->i_ino);
762}