blob: 390850ee6603922651e9ceebfc0f160ce7ff9495 [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{
Dave Chinner4196ac02010-01-11 11:47:42 +0000143 int streams, max_streams;
David Chinner2a82b8b2007-07-11 11:09:12 +1000144 int err, trylock, nscan;
Dave Chinner6cc87642009-03-16 08:29:46 +0100145 xfs_extlen_t longest, free, minfree, maxfree = 0;
David Chinner2a82b8b2007-07-11 11:09:12 +1000146 xfs_agnumber_t ag, max_ag = NULLAGNUMBER;
147 struct xfs_perag *pag;
148
149 /* 2% of an AG's blocks must be free for it to be chosen. */
150 minfree = mp->m_sb.sb_agblocks / 50;
151
152 ag = startag;
153 *agp = NULLAGNUMBER;
154
155 /* For the first pass, don't sleep trying to init the per-AG. */
156 trylock = XFS_ALLOC_FLAG_TRYLOCK;
157
158 for (nscan = 0; 1; nscan++) {
Dave Chinner4196ac02010-01-11 11:47:42 +0000159 pag = xfs_perag_get(mp, ag);
160 TRACE_AG_SCAN(mp, ag, atomic_read(&pag->pagf_fstrms));
David Chinner2a82b8b2007-07-11 11:09:12 +1000161
162 if (!pag->pagf_init) {
163 err = xfs_alloc_pagf_init(mp, NULL, ag, trylock);
Dave Chinner4196ac02010-01-11 11:47:42 +0000164 if (err && !trylock) {
165 xfs_perag_put(pag);
David Chinner2a82b8b2007-07-11 11:09:12 +1000166 return err;
Dave Chinner4196ac02010-01-11 11:47:42 +0000167 }
David Chinner2a82b8b2007-07-11 11:09:12 +1000168 }
169
170 /* Might fail sometimes during the 1st pass with trylock set. */
171 if (!pag->pagf_init)
172 goto next_ag;
173
174 /* Keep track of the AG with the most free blocks. */
175 if (pag->pagf_freeblks > maxfree) {
176 maxfree = pag->pagf_freeblks;
Dave Chinner4196ac02010-01-11 11:47:42 +0000177 max_streams = atomic_read(&pag->pagf_fstrms);
David Chinner2a82b8b2007-07-11 11:09:12 +1000178 max_ag = ag;
179 }
180
181 /*
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.
186 */
187 if (xfs_filestream_get_ag(mp, ag) > 1) {
188 xfs_filestream_put_ag(mp, ag);
189 goto next_ag;
190 }
191
Dave Chinner6cc87642009-03-16 08:29:46 +0100192 longest = xfs_alloc_longest_free_extent(mp, pag);
David Chinner2a82b8b2007-07-11 11:09:12 +1000193 if (((minlen && longest >= minlen) ||
194 (!minlen && pag->pagf_freeblks >= minfree)) &&
195 (!pag->pagf_metadata || !(flags & XFS_PICK_USERDATA) ||
196 (flags & XFS_PICK_LOWSPACE))) {
197
198 /* Break out, retaining the reference on the AG. */
199 free = pag->pagf_freeblks;
Dave Chinner4196ac02010-01-11 11:47:42 +0000200 streams = atomic_read(&pag->pagf_fstrms);
201 xfs_perag_put(pag);
David Chinner2a82b8b2007-07-11 11:09:12 +1000202 *agp = ag;
203 break;
204 }
205
206 /* Drop the reference on this AG, it's not usable. */
207 xfs_filestream_put_ag(mp, ag);
208next_ag:
Dave Chinner4196ac02010-01-11 11:47:42 +0000209 xfs_perag_put(pag);
David Chinner2a82b8b2007-07-11 11:09:12 +1000210 /* Move to the next AG, wrapping to AG 0 if necessary. */
211 if (++ag >= mp->m_sb.sb_agcount)
212 ag = 0;
213
214 /* If a full pass of the AGs hasn't been done yet, continue. */
215 if (ag != startag)
216 continue;
217
218 /* Allow sleeping in xfs_alloc_pagf_init() on the 2nd pass. */
219 if (trylock != 0) {
220 trylock = 0;
221 continue;
222 }
223
224 /* Finally, if lowspace wasn't set, set it for the 3rd pass. */
225 if (!(flags & XFS_PICK_LOWSPACE)) {
226 flags |= XFS_PICK_LOWSPACE;
227 continue;
228 }
229
230 /*
231 * Take the AG with the most free space, regardless of whether
232 * it's already in use by another filestream.
233 */
234 if (max_ag != NULLAGNUMBER) {
235 xfs_filestream_get_ag(mp, max_ag);
236 TRACE_AG_PICK1(mp, max_ag, maxfree);
Dave Chinner4196ac02010-01-11 11:47:42 +0000237 streams = max_streams;
David Chinner2a82b8b2007-07-11 11:09:12 +1000238 free = maxfree;
239 *agp = max_ag;
240 break;
241 }
242
243 /* take AG 0 if none matched */
244 TRACE_AG_PICK1(mp, max_ag, maxfree);
245 *agp = 0;
246 return 0;
247 }
248
Dave Chinner4196ac02010-01-11 11:47:42 +0000249 TRACE_AG_PICK2(mp, startag, *agp, streams, free, nscan, flags);
David Chinner2a82b8b2007-07-11 11:09:12 +1000250
251 return 0;
252}
253
254/*
255 * Set the allocation group number for a file or a directory, updating inode
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000256 * references and per-AG references as appropriate.
David Chinner2a82b8b2007-07-11 11:09:12 +1000257 */
258static int
259_xfs_filestream_update_ag(
260 xfs_inode_t *ip,
261 xfs_inode_t *pip,
262 xfs_agnumber_t ag)
263{
264 int err = 0;
265 xfs_mount_t *mp;
266 xfs_mru_cache_t *cache;
267 fstrm_item_t *item;
268 xfs_agnumber_t old_ag;
269 xfs_inode_t *old_pip;
270
271 /*
272 * Either ip is a regular file and pip is a directory, or ip is a
273 * directory and pip is NULL.
274 */
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)));
278
279 mp = ip->i_mount;
280 cache = mp->m_filestream;
281
282 item = xfs_mru_cache_lookup(cache, ip->i_ino);
283 if (item) {
284 ASSERT(item->ip == ip);
285 old_ag = item->ag;
286 item->ag = ag;
287 old_pip = item->pip;
288 item->pip = pip;
289 xfs_mru_cache_done(cache);
290
291 /*
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.
294 */
295 if (ag != old_ag) {
296 xfs_filestream_put_ag(mp, old_ag);
297 xfs_filestream_get_ag(mp, ag);
298 }
299
300 /*
301 * If ip is a file and its pip has changed, drop the old ref and
302 * take a new one.
303 */
304 if (pip && pip != old_pip) {
305 IRELE(old_pip);
306 IHOLD(pip);
307 }
308
309 TRACE_UPDATE(mp, ip, old_ag, xfs_filestream_peek_ag(mp, old_ag),
310 ag, xfs_filestream_peek_ag(mp, ag));
311 return 0;
312 }
313
314 item = kmem_zone_zalloc(item_zone, KM_MAYFAIL);
315 if (!item)
316 return ENOMEM;
317
318 item->ag = ag;
319 item->ip = ip;
320 item->pip = pip;
321
322 err = xfs_mru_cache_insert(cache, ip->i_ino, item);
323 if (err) {
324 kmem_zone_free(item_zone, item);
325 return err;
326 }
327
328 /* Take a reference on the AG. */
329 xfs_filestream_get_ag(mp, ag);
330
331 /*
332 * Take a reference on the inode itself regardless of whether it's a
333 * regular file or a directory.
334 */
335 IHOLD(ip);
336
337 /*
338 * In the case of a regular file, take a reference on the parent inode
339 * as well to ensure it remains in-core.
340 */
341 if (pip)
342 IHOLD(pip);
343
344 TRACE_UPDATE(mp, ip, ag, xfs_filestream_peek_ag(mp, ag),
345 ag, xfs_filestream_peek_ag(mp, ag));
346
347 return 0;
348}
349
350/* xfs_fstrm_free_func(): callback for freeing cached stream items. */
David Chinnera8272ce2007-11-23 16:28:09 +1100351STATIC void
David Chinner2a82b8b2007-07-11 11:09:12 +1000352xfs_fstrm_free_func(
Eric Sandeenbcc7b442007-08-30 17:21:38 +1000353 unsigned long ino,
354 void *data)
David Chinner2a82b8b2007-07-11 11:09:12 +1000355{
Eric Sandeenbcc7b442007-08-30 17:21:38 +1000356 fstrm_item_t *item = (fstrm_item_t *)data;
David Chinner2a82b8b2007-07-11 11:09:12 +1000357 xfs_inode_t *ip = item->ip;
358 int ref;
359
360 ASSERT(ip->i_ino == ino);
361
362 xfs_iflags_clear(ip, XFS_IFILESTREAM);
363
364 /* Drop the reference taken on the AG when the item was added. */
365 ref = xfs_filestream_put_ag(ip->i_mount, item->ag);
366
367 ASSERT(ref >= 0);
368 TRACE_FREE(ip->i_mount, ip, item->pip, item->ag,
369 xfs_filestream_peek_ag(ip->i_mount, item->ag));
370
371 /*
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.
377 */
378 IRELE(ip);
379
380 /*
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
383 * too.
384 */
385 if (item->pip)
386 IRELE(item->pip);
387
388 /* Finally, free the memory allocated for the item. */
389 kmem_zone_free(item_zone, item);
390}
391
392/*
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.
395 */
396int
397xfs_filestream_init(void)
398{
399 item_zone = kmem_zone_init(sizeof(fstrm_item_t), "fstrm_item");
Christoph Hellwig9f8868f2008-07-18 17:11:46 +1000400 if (!item_zone)
401 return -ENOMEM;
Christoph Hellwig0b1b2132009-12-14 23:14:59 +0000402
Christoph Hellwig9f8868f2008-07-18 17:11:46 +1000403 return 0;
David Chinner2a82b8b2007-07-11 11:09:12 +1000404}
405
406/*
407 * xfs_filestream_uninit() is called at xfs termination time to destroy the
408 * memory zone that was used for filestream data structure allocation.
409 */
410void
411xfs_filestream_uninit(void)
412{
David Chinner2a82b8b2007-07-11 11:09:12 +1000413 kmem_zone_destroy(item_zone);
414}
415
416/*
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.
420 */
421int
422xfs_filestream_mount(
423 xfs_mount_t *mp)
424{
425 int err;
426 unsigned int lifetime, grp_count;
427
428 /*
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
433 * groups.
434 */
435 lifetime = xfs_fstrm_centisecs * 10;
436 grp_count = 10;
437
438 err = xfs_mru_cache_create(&mp->m_filestream, lifetime, grp_count,
Eric Sandeenbcc7b442007-08-30 17:21:38 +1000439 xfs_fstrm_free_func);
David Chinner2a82b8b2007-07-11 11:09:12 +1000440
441 return err;
442}
443
444/*
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
448 * allocated.
449 */
450void
451xfs_filestream_unmount(
452 xfs_mount_t *mp)
453{
454 xfs_mru_cache_destroy(mp->m_filestream);
455}
456
457/*
David Chinner2a82b8b2007-07-11 11:09:12 +1000458 * Return the AG of the filestream the file or directory belongs to, or
459 * NULLAGNUMBER otherwise.
460 */
461xfs_agnumber_t
462xfs_filestream_lookup_ag(
463 xfs_inode_t *ip)
464{
465 xfs_mru_cache_t *cache;
466 fstrm_item_t *item;
467 xfs_agnumber_t ag;
468 int ref;
469
470 if (!(ip->i_d.di_mode & (S_IFREG | S_IFDIR))) {
471 ASSERT(0);
472 return NULLAGNUMBER;
473 }
474
475 cache = ip->i_mount->m_filestream;
476 item = xfs_mru_cache_lookup(cache, ip->i_ino);
477 if (!item) {
478 TRACE_LOOKUP(ip->i_mount, ip, NULL, NULLAGNUMBER, 0);
479 return NULLAGNUMBER;
480 }
481
482 ASSERT(ip == item->ip);
483 ag = item->ag;
484 ref = xfs_filestream_peek_ag(ip->i_mount, ag);
485 xfs_mru_cache_done(cache);
486
487 TRACE_LOOKUP(ip->i_mount, ip, item->pip, ag, ref);
488 return ag;
489}
490
491/*
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.
497 *
498 * Returns < 0 on error, 0 if successful association occurred, > 0 if
499 * we failed to get an association because of locking issues.
500 */
501int
502xfs_filestream_associate(
503 xfs_inode_t *pip,
504 xfs_inode_t *ip)
505{
506 xfs_mount_t *mp;
507 xfs_mru_cache_t *cache;
508 fstrm_item_t *item;
509 xfs_agnumber_t ag, rotorstep, startag;
510 int err = 0;
511
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))
515 return -EINVAL;
516
517 mp = pip->i_mount;
518 cache = mp->m_filestream;
David Chinner2a82b8b2007-07-11 11:09:12 +1000519
520 /*
521 * We have a problem, Houston.
522 *
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.
529 *
Christoph Hellwig075fe102009-06-08 15:35:48 +0200530 * Lucky for us, this inversion is not a problem because it's a
531 * directory inode that we are trying to lock here.
David Chinner2a82b8b2007-07-11 11:09:12 +1000532 *
533 * So, if we can't get the iolock without sleeping then just give up
534 */
Dave Chinner1c1c6eb2010-01-11 11:47:44 +0000535 if (!xfs_ilock_nowait(pip, XFS_IOLOCK_EXCL))
David Chinner2a82b8b2007-07-11 11:09:12 +1000536 return 1;
David Chinner2a82b8b2007-07-11 11:09:12 +1000537
538 /* If the parent directory is already in the cache, use its AG. */
539 item = xfs_mru_cache_lookup(cache, pip->i_ino);
540 if (item) {
541 ASSERT(item->ip == pip);
542 ag = item->ag;
543 xfs_mru_cache_done(cache);
544
545 TRACE_LOOKUP(mp, pip, pip, ag, xfs_filestream_peek_ag(mp, ag));
546 err = _xfs_filestream_update_ag(ip, pip, ag);
547
548 goto exit;
549 }
550
551 /*
552 * Set the starting AG using the rotor for inode32, otherwise
553 * use the directory inode's AG.
554 */
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);
560 } else
561 startag = XFS_INO_TO_AGNO(mp, pip->i_ino);
562
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)
566 goto exit_did_pick;
567
568 /* Associate the parent inode with the AG. */
569 err = _xfs_filestream_update_ag(pip, NULL, ag);
570 if (err)
571 goto exit_did_pick;
572
573 /* Associate the file inode with the AG. */
574 err = _xfs_filestream_update_ag(ip, pip, ag);
575 if (err)
576 goto exit_did_pick;
577
578 TRACE_ASSOCIATE(mp, ip, pip, ag, xfs_filestream_peek_ag(mp, ag));
579
580exit_did_pick:
581 /*
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.
585 */
586 if (ag != NULLAGNUMBER)
587 xfs_filestream_put_ag(mp, ag);
588
589exit:
590 xfs_iunlock(pip, XFS_IOLOCK_EXCL);
David Chinner2a82b8b2007-07-11 11:09:12 +1000591 return -err;
592}
593
594/*
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
597 * lock held.
598 */
599int
600xfs_filestream_new_ag(
601 xfs_bmalloca_t *ap,
602 xfs_agnumber_t *agp)
603{
604 int flags, err;
605 xfs_inode_t *ip, *pip = NULL;
606 xfs_mount_t *mp;
607 xfs_mru_cache_t *cache;
608 xfs_extlen_t minlen;
609 fstrm_item_t *dir, *file;
610 xfs_agnumber_t ag = NULLAGNUMBER;
611
612 ip = ap->ip;
613 mp = ip->i_mount;
614 cache = mp->m_filestream;
615 minlen = ap->alen;
616 *agp = NULLAGNUMBER;
617
618 /*
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.
621 */
622 file = xfs_mru_cache_remove(cache, ip->i_ino);
623 if (file) {
624 ASSERT(ip == file->ip);
625
626 /* Save the file's parent inode and old AG number for later. */
627 pip = file->pip;
628 ag = file->ag;
629
630 /* Look for the file's directory in the cache. */
631 dir = xfs_mru_cache_lookup(cache, pip->i_ino);
632 if (dir) {
633 ASSERT(pip == dir->ip);
634
635 /*
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
639 * movement.
640 */
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;
645 }
646
647 xfs_mru_cache_done(cache);
648 }
649
650 /*
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.
654 */
655 err = xfs_mru_cache_insert(cache, ip->i_ino, file);
656 if (err) {
657 xfs_fstrm_free_func(ip->i_ino, file);
658 return err;
659 }
660
661 /*
662 * If the file's AG was moved to the directory's new AG, there's
663 * nothing more to be done.
664 */
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));
669 return 0;
670 }
671 }
672
673 /*
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.
677 */
678 if (pip)
679 xfs_ilock(pip, XFS_IOLOCK_EXCL);
680
681 /*
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.
685 */
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);
689
690 err = _xfs_filestream_pick_ag(mp, ag, agp, flags, minlen);
691 if (err || *agp == NULLAGNUMBER)
692 goto exit;
693
694 /*
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.
701 */
702 if (!pip) {
703 TRACE_ORPHAN(mp, ip, *agp);
704 goto exit;
705 }
706
707 /* Associate the parent inode with the AG. */
708 err = _xfs_filestream_update_ag(pip, NULL, *agp);
709 if (err)
710 goto exit;
711
712 /* Associate the file inode with the AG. */
713 err = _xfs_filestream_update_ag(ip, pip, *agp);
714 if (err)
715 goto exit;
716
717 TRACE_MOVEAG(mp, ip, pip, NULLAGNUMBER, 0,
718 *agp, xfs_filestream_peek_ag(mp, *agp));
719
720exit:
721 /*
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.
725 */
726 if (*agp != NULLAGNUMBER)
727 xfs_filestream_put_ag(mp, *agp);
728 else
729 *agp = 0;
730
731 if (pip)
732 xfs_iunlock(pip, XFS_IOLOCK_EXCL);
733
734 return err;
735}
736
737/*
738 * Remove an association between an inode and a filestream object.
739 * Typically this is done on last close of an unlinked file.
740 */
741void
742xfs_filestream_deassociate(
743 xfs_inode_t *ip)
744{
745 xfs_mru_cache_t *cache = ip->i_mount->m_filestream;
746
747 xfs_mru_cache_delete(cache, ip->i_ino);
748}