1 /*
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"
37
38 #ifdef XFS_FILESTREAMS_TRACE
39
40 ktrace_t *xfs_filestreams_trace_buf;
41
42 STATIC void
xfs_filestreams_trace(xfs_mount_t * mp,int type,const char * func,int line,__psunsigned_t arg0,__psunsigned_t arg1,__psunsigned_t arg2,__psunsigned_t arg3,__psunsigned_t arg4,__psunsigned_t arg5)43 xfs_filestreams_trace(
44 xfs_mount_t *mp, /* mount point */
45 int type, /* type of trace */
46 const char *func, /* source function */
47 int line, /* source line number */
48 __psunsigned_t arg0,
49 __psunsigned_t arg1,
50 __psunsigned_t arg2,
51 __psunsigned_t arg3,
52 __psunsigned_t arg4,
53 __psunsigned_t arg5)
54 {
55 ktrace_enter(xfs_filestreams_trace_buf,
56 (void *)(__psint_t)(type | (line << 16)),
57 (void *)func,
58 (void *)(__psunsigned_t)current_pid(),
59 (void *)mp,
60 (void *)(__psunsigned_t)arg0,
61 (void *)(__psunsigned_t)arg1,
62 (void *)(__psunsigned_t)arg2,
63 (void *)(__psunsigned_t)arg3,
64 (void *)(__psunsigned_t)arg4,
65 (void *)(__psunsigned_t)arg5,
66 NULL, NULL, NULL, NULL, NULL, NULL);
67 }
68
69 #define TRACE0(mp,t) TRACE6(mp,t,0,0,0,0,0,0)
70 #define TRACE1(mp,t,a0) TRACE6(mp,t,a0,0,0,0,0,0)
71 #define TRACE2(mp,t,a0,a1) TRACE6(mp,t,a0,a1,0,0,0,0)
72 #define TRACE3(mp,t,a0,a1,a2) TRACE6(mp,t,a0,a1,a2,0,0,0)
73 #define TRACE4(mp,t,a0,a1,a2,a3) TRACE6(mp,t,a0,a1,a2,a3,0,0)
74 #define TRACE5(mp,t,a0,a1,a2,a3,a4) TRACE6(mp,t,a0,a1,a2,a3,a4,0)
75 #define TRACE6(mp,t,a0,a1,a2,a3,a4,a5) \
76 xfs_filestreams_trace(mp, t, __func__, __LINE__, \
77 (__psunsigned_t)a0, (__psunsigned_t)a1, \
78 (__psunsigned_t)a2, (__psunsigned_t)a3, \
79 (__psunsigned_t)a4, (__psunsigned_t)a5)
80
81 #define TRACE_AG_SCAN(mp, ag, ag2) \
82 TRACE2(mp, XFS_FSTRM_KTRACE_AGSCAN, ag, ag2);
83 #define TRACE_AG_PICK1(mp, max_ag, maxfree) \
84 TRACE2(mp, XFS_FSTRM_KTRACE_AGPICK1, max_ag, maxfree);
85 #define TRACE_AG_PICK2(mp, ag, ag2, cnt, free, scan, flag) \
86 TRACE6(mp, XFS_FSTRM_KTRACE_AGPICK2, ag, ag2, \
87 cnt, free, scan, flag)
88 #define TRACE_UPDATE(mp, ip, ag, cnt, ag2, cnt2) \
89 TRACE5(mp, XFS_FSTRM_KTRACE_UPDATE, ip, ag, cnt, ag2, cnt2)
90 #define TRACE_FREE(mp, ip, pip, ag, cnt) \
91 TRACE4(mp, XFS_FSTRM_KTRACE_FREE, ip, pip, ag, cnt)
92 #define TRACE_LOOKUP(mp, ip, pip, ag, cnt) \
93 TRACE4(mp, XFS_FSTRM_KTRACE_ITEM_LOOKUP, ip, pip, ag, cnt)
94 #define TRACE_ASSOCIATE(mp, ip, pip, ag, cnt) \
95 TRACE4(mp, XFS_FSTRM_KTRACE_ASSOCIATE, ip, pip, ag, cnt)
96 #define TRACE_MOVEAG(mp, ip, pip, oag, ocnt, nag, ncnt) \
97 TRACE6(mp, XFS_FSTRM_KTRACE_MOVEAG, ip, pip, oag, ocnt, nag, ncnt)
98 #define TRACE_ORPHAN(mp, ip, ag) \
99 TRACE2(mp, XFS_FSTRM_KTRACE_ORPHAN, ip, ag);
100
101
102 #else
103 #define TRACE_AG_SCAN(mp, ag, ag2)
104 #define TRACE_AG_PICK1(mp, max_ag, maxfree)
105 #define TRACE_AG_PICK2(mp, ag, ag2, cnt, free, scan, flag)
106 #define TRACE_UPDATE(mp, ip, ag, cnt, ag2, cnt2)
107 #define TRACE_FREE(mp, ip, pip, ag, cnt)
108 #define TRACE_LOOKUP(mp, ip, pip, ag, cnt)
109 #define TRACE_ASSOCIATE(mp, ip, pip, ag, cnt)
110 #define TRACE_MOVEAG(mp, ip, pip, oag, ocnt, nag, ncnt)
111 #define TRACE_ORPHAN(mp, ip, ag)
112 #endif
113
114 static kmem_zone_t *item_zone;
115
116 /*
117 * Structure for associating a file or a directory with an allocation group.
118 * The parent directory pointer is only needed for files, but since there will
119 * generally be vastly more files than directories in the cache, using the same
120 * data structure simplifies the code with very little memory overhead.
121 */
122 typedef struct fstrm_item
123 {
124 xfs_agnumber_t ag; /* AG currently in use for the file/directory. */
125 xfs_inode_t *ip; /* inode self-pointer. */
126 xfs_inode_t *pip; /* Parent directory inode pointer. */
127 } fstrm_item_t;
128
129
130 /*
131 * Scan the AGs starting at startag looking for an AG that isn't in use and has
132 * at least minlen blocks free.
133 */
134 static int
_xfs_filestream_pick_ag(xfs_mount_t * mp,xfs_agnumber_t startag,xfs_agnumber_t * agp,int flags,xfs_extlen_t minlen)135 _xfs_filestream_pick_ag(
136 xfs_mount_t *mp,
137 xfs_agnumber_t startag,
138 xfs_agnumber_t *agp,
139 int flags,
140 xfs_extlen_t minlen)
141 {
142 int err, trylock, nscan;
143 xfs_extlen_t delta, longest, need, free, minfree, maxfree = 0;
144 xfs_agnumber_t ag, max_ag = NULLAGNUMBER;
145 struct xfs_perag *pag;
146
147 /* 2% of an AG's blocks must be free for it to be chosen. */
148 minfree = mp->m_sb.sb_agblocks / 50;
149
150 ag = startag;
151 *agp = NULLAGNUMBER;
152
153 /* For the first pass, don't sleep trying to init the per-AG. */
154 trylock = XFS_ALLOC_FLAG_TRYLOCK;
155
156 for (nscan = 0; 1; nscan++) {
157
158 TRACE_AG_SCAN(mp, ag, xfs_filestream_peek_ag(mp, ag));
159
160 pag = mp->m_perag + ag;
161
162 if (!pag->pagf_init) {
163 err = xfs_alloc_pagf_init(mp, NULL, ag, trylock);
164 if (err && !trylock)
165 return err;
166 }
167
168 /* Might fail sometimes during the 1st pass with trylock set. */
169 if (!pag->pagf_init)
170 goto next_ag;
171
172 /* Keep track of the AG with the most free blocks. */
173 if (pag->pagf_freeblks > maxfree) {
174 maxfree = pag->pagf_freeblks;
175 max_ag = ag;
176 }
177
178 /*
179 * The AG reference count does two things: it enforces mutual
180 * exclusion when examining the suitability of an AG in this
181 * loop, and it guards against two filestreams being established
182 * in the same AG as each other.
183 */
184 if (xfs_filestream_get_ag(mp, ag) > 1) {
185 xfs_filestream_put_ag(mp, ag);
186 goto next_ag;
187 }
188
189 need = XFS_MIN_FREELIST_PAG(pag, mp);
190 delta = need > pag->pagf_flcount ? need - pag->pagf_flcount : 0;
191 longest = (pag->pagf_longest > delta) ?
192 (pag->pagf_longest - delta) :
193 (pag->pagf_flcount > 0 || pag->pagf_longest > 0);
194
195 if (((minlen && longest >= minlen) ||
196 (!minlen && pag->pagf_freeblks >= minfree)) &&
197 (!pag->pagf_metadata || !(flags & XFS_PICK_USERDATA) ||
198 (flags & XFS_PICK_LOWSPACE))) {
199
200 /* Break out, retaining the reference on the AG. */
201 free = pag->pagf_freeblks;
202 *agp = ag;
203 break;
204 }
205
206 /* Drop the reference on this AG, it's not usable. */
207 xfs_filestream_put_ag(mp, ag);
208 next_ag:
209 /* Move to the next AG, wrapping to AG 0 if necessary. */
210 if (++ag >= mp->m_sb.sb_agcount)
211 ag = 0;
212
213 /* If a full pass of the AGs hasn't been done yet, continue. */
214 if (ag != startag)
215 continue;
216
217 /* Allow sleeping in xfs_alloc_pagf_init() on the 2nd pass. */
218 if (trylock != 0) {
219 trylock = 0;
220 continue;
221 }
222
223 /* Finally, if lowspace wasn't set, set it for the 3rd pass. */
224 if (!(flags & XFS_PICK_LOWSPACE)) {
225 flags |= XFS_PICK_LOWSPACE;
226 continue;
227 }
228
229 /*
230 * Take the AG with the most free space, regardless of whether
231 * it's already in use by another filestream.
232 */
233 if (max_ag != NULLAGNUMBER) {
234 xfs_filestream_get_ag(mp, max_ag);
235 TRACE_AG_PICK1(mp, max_ag, maxfree);
236 free = maxfree;
237 *agp = max_ag;
238 break;
239 }
240
241 /* take AG 0 if none matched */
242 TRACE_AG_PICK1(mp, max_ag, maxfree);
243 *agp = 0;
244 return 0;
245 }
246
247 TRACE_AG_PICK2(mp, startag, *agp, xfs_filestream_peek_ag(mp, *agp),
248 free, nscan, flags);
249
250 return 0;
251 }
252
253 /*
254 * Set the allocation group number for a file or a directory, updating inode
255 * references and per-AG references as appropriate. Must be called with the
256 * m_peraglock held in read mode.
257 */
258 static int
_xfs_filestream_update_ag(xfs_inode_t * ip,xfs_inode_t * pip,xfs_agnumber_t ag)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. */
351 STATIC void
xfs_fstrm_free_func(unsigned long ino,void * data)352 xfs_fstrm_free_func(
353 unsigned long ino,
354 void *data)
355 {
356 fstrm_item_t *item = (fstrm_item_t *)data;
357 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 */
396 int
xfs_filestream_init(void)397 xfs_filestream_init(void)
398 {
399 item_zone = kmem_zone_init(sizeof(fstrm_item_t), "fstrm_item");
400 if (!item_zone)
401 return -ENOMEM;
402 #ifdef XFS_FILESTREAMS_TRACE
403 xfs_filestreams_trace_buf = ktrace_alloc(XFS_FSTRM_KTRACE_SIZE, KM_NOFS);
404 #endif
405 return 0;
406 }
407
408 /*
409 * xfs_filestream_uninit() is called at xfs termination time to destroy the
410 * memory zone that was used for filestream data structure allocation.
411 */
412 void
xfs_filestream_uninit(void)413 xfs_filestream_uninit(void)
414 {
415 #ifdef XFS_FILESTREAMS_TRACE
416 ktrace_free(xfs_filestreams_trace_buf);
417 #endif
418 kmem_zone_destroy(item_zone);
419 }
420
421 /*
422 * xfs_filestream_mount() is called when a file system is mounted with the
423 * filestream option. It is responsible for allocating the data structures
424 * needed to track the new file system's file streams.
425 */
426 int
xfs_filestream_mount(xfs_mount_t * mp)427 xfs_filestream_mount(
428 xfs_mount_t *mp)
429 {
430 int err;
431 unsigned int lifetime, grp_count;
432
433 /*
434 * The filestream timer tunable is currently fixed within the range of
435 * one second to four minutes, with five seconds being the default. The
436 * group count is somewhat arbitrary, but it'd be nice to adhere to the
437 * timer tunable to within about 10 percent. This requires at least 10
438 * groups.
439 */
440 lifetime = xfs_fstrm_centisecs * 10;
441 grp_count = 10;
442
443 err = xfs_mru_cache_create(&mp->m_filestream, lifetime, grp_count,
444 xfs_fstrm_free_func);
445
446 return err;
447 }
448
449 /*
450 * xfs_filestream_unmount() is called when a file system that was mounted with
451 * the filestream option is unmounted. It drains the data structures created
452 * to track the file system's file streams and frees all the memory that was
453 * allocated.
454 */
455 void
xfs_filestream_unmount(xfs_mount_t * mp)456 xfs_filestream_unmount(
457 xfs_mount_t *mp)
458 {
459 xfs_mru_cache_destroy(mp->m_filestream);
460 }
461
462 /*
463 * If the mount point's m_perag array is going to be reallocated, all
464 * outstanding cache entries must be flushed to avoid accessing reference count
465 * addresses that have been freed. The call to xfs_filestream_flush() must be
466 * made inside the block that holds the m_peraglock in write mode to do the
467 * reallocation.
468 */
469 void
xfs_filestream_flush(xfs_mount_t * mp)470 xfs_filestream_flush(
471 xfs_mount_t *mp)
472 {
473 xfs_mru_cache_flush(mp->m_filestream);
474 }
475
476 /*
477 * Return the AG of the filestream the file or directory belongs to, or
478 * NULLAGNUMBER otherwise.
479 */
480 xfs_agnumber_t
xfs_filestream_lookup_ag(xfs_inode_t * ip)481 xfs_filestream_lookup_ag(
482 xfs_inode_t *ip)
483 {
484 xfs_mru_cache_t *cache;
485 fstrm_item_t *item;
486 xfs_agnumber_t ag;
487 int ref;
488
489 if (!(ip->i_d.di_mode & (S_IFREG | S_IFDIR))) {
490 ASSERT(0);
491 return NULLAGNUMBER;
492 }
493
494 cache = ip->i_mount->m_filestream;
495 item = xfs_mru_cache_lookup(cache, ip->i_ino);
496 if (!item) {
497 TRACE_LOOKUP(ip->i_mount, ip, NULL, NULLAGNUMBER, 0);
498 return NULLAGNUMBER;
499 }
500
501 ASSERT(ip == item->ip);
502 ag = item->ag;
503 ref = xfs_filestream_peek_ag(ip->i_mount, ag);
504 xfs_mru_cache_done(cache);
505
506 TRACE_LOOKUP(ip->i_mount, ip, item->pip, ag, ref);
507 return ag;
508 }
509
510 /*
511 * xfs_filestream_associate() should only be called to associate a regular file
512 * with its parent directory. Calling it with a child directory isn't
513 * appropriate because filestreams don't apply to entire directory hierarchies.
514 * Creating a file in a child directory of an existing filestream directory
515 * starts a new filestream with its own allocation group association.
516 *
517 * Returns < 0 on error, 0 if successful association occurred, > 0 if
518 * we failed to get an association because of locking issues.
519 */
520 int
xfs_filestream_associate(xfs_inode_t * pip,xfs_inode_t * ip)521 xfs_filestream_associate(
522 xfs_inode_t *pip,
523 xfs_inode_t *ip)
524 {
525 xfs_mount_t *mp;
526 xfs_mru_cache_t *cache;
527 fstrm_item_t *item;
528 xfs_agnumber_t ag, rotorstep, startag;
529 int err = 0;
530
531 ASSERT(pip->i_d.di_mode & S_IFDIR);
532 ASSERT(ip->i_d.di_mode & S_IFREG);
533 if (!(pip->i_d.di_mode & S_IFDIR) || !(ip->i_d.di_mode & S_IFREG))
534 return -EINVAL;
535
536 mp = pip->i_mount;
537 cache = mp->m_filestream;
538 down_read(&mp->m_peraglock);
539
540 /*
541 * We have a problem, Houston.
542 *
543 * Taking the iolock here violates inode locking order - we already
544 * hold the ilock. Hence if we block getting this lock we may never
545 * wake. Unfortunately, that means if we can't get the lock, we're
546 * screwed in terms of getting a stream association - we can't spin
547 * waiting for the lock because someone else is waiting on the lock we
548 * hold and we cannot drop that as we are in a transaction here.
549 *
550 * Lucky for us, this inversion is rarely a problem because it's a
551 * directory inode that we are trying to lock here and that means the
552 * only place that matters is xfs_sync_inodes() and SYNC_DELWRI is
553 * used. i.e. freeze, remount-ro, quotasync or unmount.
554 *
555 * So, if we can't get the iolock without sleeping then just give up
556 */
557 if (!xfs_ilock_nowait(pip, XFS_IOLOCK_EXCL)) {
558 up_read(&mp->m_peraglock);
559 return 1;
560 }
561
562 /* If the parent directory is already in the cache, use its AG. */
563 item = xfs_mru_cache_lookup(cache, pip->i_ino);
564 if (item) {
565 ASSERT(item->ip == pip);
566 ag = item->ag;
567 xfs_mru_cache_done(cache);
568
569 TRACE_LOOKUP(mp, pip, pip, ag, xfs_filestream_peek_ag(mp, ag));
570 err = _xfs_filestream_update_ag(ip, pip, ag);
571
572 goto exit;
573 }
574
575 /*
576 * Set the starting AG using the rotor for inode32, otherwise
577 * use the directory inode's AG.
578 */
579 if (mp->m_flags & XFS_MOUNT_32BITINODES) {
580 rotorstep = xfs_rotorstep;
581 startag = (mp->m_agfrotor / rotorstep) % mp->m_sb.sb_agcount;
582 mp->m_agfrotor = (mp->m_agfrotor + 1) %
583 (mp->m_sb.sb_agcount * rotorstep);
584 } else
585 startag = XFS_INO_TO_AGNO(mp, pip->i_ino);
586
587 /* Pick a new AG for the parent inode starting at startag. */
588 err = _xfs_filestream_pick_ag(mp, startag, &ag, 0, 0);
589 if (err || ag == NULLAGNUMBER)
590 goto exit_did_pick;
591
592 /* Associate the parent inode with the AG. */
593 err = _xfs_filestream_update_ag(pip, NULL, ag);
594 if (err)
595 goto exit_did_pick;
596
597 /* Associate the file inode with the AG. */
598 err = _xfs_filestream_update_ag(ip, pip, ag);
599 if (err)
600 goto exit_did_pick;
601
602 TRACE_ASSOCIATE(mp, ip, pip, ag, xfs_filestream_peek_ag(mp, ag));
603
604 exit_did_pick:
605 /*
606 * If _xfs_filestream_pick_ag() returned a valid AG, remove the
607 * reference it took on it, since the file and directory will have taken
608 * their own now if they were successfully cached.
609 */
610 if (ag != NULLAGNUMBER)
611 xfs_filestream_put_ag(mp, ag);
612
613 exit:
614 xfs_iunlock(pip, XFS_IOLOCK_EXCL);
615 up_read(&mp->m_peraglock);
616 return -err;
617 }
618
619 /*
620 * Pick a new allocation group for the current file and its file stream. This
621 * function is called by xfs_bmap_filestreams() with the mount point's per-ag
622 * lock held.
623 */
624 int
xfs_filestream_new_ag(xfs_bmalloca_t * ap,xfs_agnumber_t * agp)625 xfs_filestream_new_ag(
626 xfs_bmalloca_t *ap,
627 xfs_agnumber_t *agp)
628 {
629 int flags, err;
630 xfs_inode_t *ip, *pip = NULL;
631 xfs_mount_t *mp;
632 xfs_mru_cache_t *cache;
633 xfs_extlen_t minlen;
634 fstrm_item_t *dir, *file;
635 xfs_agnumber_t ag = NULLAGNUMBER;
636
637 ip = ap->ip;
638 mp = ip->i_mount;
639 cache = mp->m_filestream;
640 minlen = ap->alen;
641 *agp = NULLAGNUMBER;
642
643 /*
644 * Look for the file in the cache, removing it if it's found. Doing
645 * this allows it to be held across the dir lookup that follows.
646 */
647 file = xfs_mru_cache_remove(cache, ip->i_ino);
648 if (file) {
649 ASSERT(ip == file->ip);
650
651 /* Save the file's parent inode and old AG number for later. */
652 pip = file->pip;
653 ag = file->ag;
654
655 /* Look for the file's directory in the cache. */
656 dir = xfs_mru_cache_lookup(cache, pip->i_ino);
657 if (dir) {
658 ASSERT(pip == dir->ip);
659
660 /*
661 * If the directory has already moved on to a new AG,
662 * use that AG as the new AG for the file. Don't
663 * forget to twiddle the AG refcounts to match the
664 * movement.
665 */
666 if (dir->ag != file->ag) {
667 xfs_filestream_put_ag(mp, file->ag);
668 xfs_filestream_get_ag(mp, dir->ag);
669 *agp = file->ag = dir->ag;
670 }
671
672 xfs_mru_cache_done(cache);
673 }
674
675 /*
676 * Put the file back in the cache. If this fails, the free
677 * function needs to be called to tidy up in the same way as if
678 * the item had simply expired from the cache.
679 */
680 err = xfs_mru_cache_insert(cache, ip->i_ino, file);
681 if (err) {
682 xfs_fstrm_free_func(ip->i_ino, file);
683 return err;
684 }
685
686 /*
687 * If the file's AG was moved to the directory's new AG, there's
688 * nothing more to be done.
689 */
690 if (*agp != NULLAGNUMBER) {
691 TRACE_MOVEAG(mp, ip, pip,
692 ag, xfs_filestream_peek_ag(mp, ag),
693 *agp, xfs_filestream_peek_ag(mp, *agp));
694 return 0;
695 }
696 }
697
698 /*
699 * If the file's parent directory is known, take its iolock in exclusive
700 * mode to prevent two sibling files from racing each other to migrate
701 * themselves and their parent to different AGs.
702 */
703 if (pip)
704 xfs_ilock(pip, XFS_IOLOCK_EXCL);
705
706 /*
707 * A new AG needs to be found for the file. If the file's parent
708 * directory is also known, it will be moved to the new AG as well to
709 * ensure that files created inside it in future use the new AG.
710 */
711 ag = (ag == NULLAGNUMBER) ? 0 : (ag + 1) % mp->m_sb.sb_agcount;
712 flags = (ap->userdata ? XFS_PICK_USERDATA : 0) |
713 (ap->low ? XFS_PICK_LOWSPACE : 0);
714
715 err = _xfs_filestream_pick_ag(mp, ag, agp, flags, minlen);
716 if (err || *agp == NULLAGNUMBER)
717 goto exit;
718
719 /*
720 * If the file wasn't found in the file cache, then its parent directory
721 * inode isn't known. For this to have happened, the file must either
722 * be pre-existing, or it was created long enough ago that its cache
723 * entry has expired. This isn't the sort of usage that the filestreams
724 * allocator is trying to optimise, so there's no point trying to track
725 * its new AG somehow in the filestream data structures.
726 */
727 if (!pip) {
728 TRACE_ORPHAN(mp, ip, *agp);
729 goto exit;
730 }
731
732 /* Associate the parent inode with the AG. */
733 err = _xfs_filestream_update_ag(pip, NULL, *agp);
734 if (err)
735 goto exit;
736
737 /* Associate the file inode with the AG. */
738 err = _xfs_filestream_update_ag(ip, pip, *agp);
739 if (err)
740 goto exit;
741
742 TRACE_MOVEAG(mp, ip, pip, NULLAGNUMBER, 0,
743 *agp, xfs_filestream_peek_ag(mp, *agp));
744
745 exit:
746 /*
747 * If _xfs_filestream_pick_ag() returned a valid AG, remove the
748 * reference it took on it, since the file and directory will have taken
749 * their own now if they were successfully cached.
750 */
751 if (*agp != NULLAGNUMBER)
752 xfs_filestream_put_ag(mp, *agp);
753 else
754 *agp = 0;
755
756 if (pip)
757 xfs_iunlock(pip, XFS_IOLOCK_EXCL);
758
759 return err;
760 }
761
762 /*
763 * Remove an association between an inode and a filestream object.
764 * Typically this is done on last close of an unlinked file.
765 */
766 void
xfs_filestream_deassociate(xfs_inode_t * ip)767 xfs_filestream_deassociate(
768 xfs_inode_t *ip)
769 {
770 xfs_mru_cache_t *cache = ip->i_mount->m_filestream;
771
772 xfs_mru_cache_delete(cache, ip->i_ino);
773 }
774