Merge branch 'for-linus' of git://oss.sgi.com:8090/xfs/xfs-2.6
[linux-2.6] / fs / xfs / xfs_filestream.c
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
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, __FUNCTION__, __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
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
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 void
352 xfs_fstrm_free_func(
353         xfs_ino_t       ino,
354         fstrm_item_t    *item)
355 {
356         xfs_inode_t     *ip = item->ip;
357         int ref;
358
359         ASSERT(ip->i_ino == ino);
360
361         xfs_iflags_clear(ip, XFS_IFILESTREAM);
362
363         /* Drop the reference taken on the AG when the item was added. */
364         ref = xfs_filestream_put_ag(ip->i_mount, item->ag);
365
366         ASSERT(ref >= 0);
367         TRACE_FREE(ip->i_mount, ip, item->pip, item->ag,
368                 xfs_filestream_peek_ag(ip->i_mount, item->ag));
369
370         /*
371          * _xfs_filestream_update_ag() always takes a reference on the inode
372          * itself, whether it's a file or a directory.  Release it here.
373          * This can result in the inode being freed and so we must
374          * not hold any inode locks when freeing filesstreams objects
375          * otherwise we can deadlock here.
376          */
377         IRELE(ip);
378
379         /*
380          * In the case of a regular file, _xfs_filestream_update_ag() also
381          * takes a ref on the parent inode to keep it in-core.  Release that
382          * too.
383          */
384         if (item->pip)
385                 IRELE(item->pip);
386
387         /* Finally, free the memory allocated for the item. */
388         kmem_zone_free(item_zone, item);
389 }
390
391 /*
392  * xfs_filestream_init() is called at xfs initialisation time to set up the
393  * memory zone that will be used for filestream data structure allocation.
394  */
395 int
396 xfs_filestream_init(void)
397 {
398         item_zone = kmem_zone_init(sizeof(fstrm_item_t), "fstrm_item");
399 #ifdef XFS_FILESTREAMS_TRACE
400         xfs_filestreams_trace_buf = ktrace_alloc(XFS_FSTRM_KTRACE_SIZE, KM_SLEEP);
401 #endif
402         return item_zone ? 0 : -ENOMEM;
403 }
404
405 /*
406  * xfs_filestream_uninit() is called at xfs termination time to destroy the
407  * memory zone that was used for filestream data structure allocation.
408  */
409 void
410 xfs_filestream_uninit(void)
411 {
412 #ifdef XFS_FILESTREAMS_TRACE
413         ktrace_free(xfs_filestreams_trace_buf);
414 #endif
415         kmem_zone_destroy(item_zone);
416 }
417
418 /*
419  * xfs_filestream_mount() is called when a file system is mounted with the
420  * filestream option.  It is responsible for allocating the data structures
421  * needed to track the new file system's file streams.
422  */
423 int
424 xfs_filestream_mount(
425         xfs_mount_t     *mp)
426 {
427         int             err;
428         unsigned int    lifetime, grp_count;
429
430         /*
431          * The filestream timer tunable is currently fixed within the range of
432          * one second to four minutes, with five seconds being the default.  The
433          * group count is somewhat arbitrary, but it'd be nice to adhere to the
434          * timer tunable to within about 10 percent.  This requires at least 10
435          * groups.
436          */
437         lifetime  = xfs_fstrm_centisecs * 10;
438         grp_count = 10;
439
440         err = xfs_mru_cache_create(&mp->m_filestream, lifetime, grp_count,
441                              (xfs_mru_cache_free_func_t)xfs_fstrm_free_func);
442
443         return err;
444 }
445
446 /*
447  * xfs_filestream_unmount() is called when a file system that was mounted with
448  * the filestream option is unmounted.  It drains the data structures created
449  * to track the file system's file streams and frees all the memory that was
450  * allocated.
451  */
452 void
453 xfs_filestream_unmount(
454         xfs_mount_t     *mp)
455 {
456         xfs_mru_cache_destroy(mp->m_filestream);
457 }
458
459 /*
460  * If the mount point's m_perag array is going to be reallocated, all
461  * outstanding cache entries must be flushed to avoid accessing reference count
462  * addresses that have been freed.  The call to xfs_filestream_flush() must be
463  * made inside the block that holds the m_peraglock in write mode to do the
464  * reallocation.
465  */
466 void
467 xfs_filestream_flush(
468         xfs_mount_t     *mp)
469 {
470         xfs_mru_cache_flush(mp->m_filestream);
471 }
472
473 /*
474  * Return the AG of the filestream the file or directory belongs to, or
475  * NULLAGNUMBER otherwise.
476  */
477 xfs_agnumber_t
478 xfs_filestream_lookup_ag(
479         xfs_inode_t     *ip)
480 {
481         xfs_mru_cache_t *cache;
482         fstrm_item_t    *item;
483         xfs_agnumber_t  ag;
484         int             ref;
485
486         if (!(ip->i_d.di_mode & (S_IFREG | S_IFDIR))) {
487                 ASSERT(0);
488                 return NULLAGNUMBER;
489         }
490
491         cache = ip->i_mount->m_filestream;
492         item = xfs_mru_cache_lookup(cache, ip->i_ino);
493         if (!item) {
494                 TRACE_LOOKUP(ip->i_mount, ip, NULL, NULLAGNUMBER, 0);
495                 return NULLAGNUMBER;
496         }
497
498         ASSERT(ip == item->ip);
499         ag = item->ag;
500         ref = xfs_filestream_peek_ag(ip->i_mount, ag);
501         xfs_mru_cache_done(cache);
502
503         TRACE_LOOKUP(ip->i_mount, ip, item->pip, ag, ref);
504         return ag;
505 }
506
507 /*
508  * xfs_filestream_associate() should only be called to associate a regular file
509  * with its parent directory.  Calling it with a child directory isn't
510  * appropriate because filestreams don't apply to entire directory hierarchies.
511  * Creating a file in a child directory of an existing filestream directory
512  * starts a new filestream with its own allocation group association.
513  *
514  * Returns < 0 on error, 0 if successful association occurred, > 0 if
515  * we failed to get an association because of locking issues.
516  */
517 int
518 xfs_filestream_associate(
519         xfs_inode_t     *pip,
520         xfs_inode_t     *ip)
521 {
522         xfs_mount_t     *mp;
523         xfs_mru_cache_t *cache;
524         fstrm_item_t    *item;
525         xfs_agnumber_t  ag, rotorstep, startag;
526         int             err = 0;
527
528         ASSERT(pip->i_d.di_mode & S_IFDIR);
529         ASSERT(ip->i_d.di_mode & S_IFREG);
530         if (!(pip->i_d.di_mode & S_IFDIR) || !(ip->i_d.di_mode & S_IFREG))
531                 return -EINVAL;
532
533         mp = pip->i_mount;
534         cache = mp->m_filestream;
535         down_read(&mp->m_peraglock);
536
537         /*
538          * We have a problem, Houston.
539          *
540          * Taking the iolock here violates inode locking order - we already
541          * hold the ilock. Hence if we block getting this lock we may never
542          * wake. Unfortunately, that means if we can't get the lock, we're
543          * screwed in terms of getting a stream association - we can't spin
544          * waiting for the lock because someone else is waiting on the lock we
545          * hold and we cannot drop that as we are in a transaction here.
546          *
547          * Lucky for us, this inversion is rarely a problem because it's a
548          * directory inode that we are trying to lock here and that means the
549          * only place that matters is xfs_sync_inodes() and SYNC_DELWRI is
550          * used. i.e. freeze, remount-ro, quotasync or unmount.
551          *
552          * So, if we can't get the iolock without sleeping then just give up
553          */
554         if (!xfs_ilock_nowait(pip, XFS_IOLOCK_EXCL)) {
555                 up_read(&mp->m_peraglock);
556                 return 1;
557         }
558
559         /* If the parent directory is already in the cache, use its AG. */
560         item = xfs_mru_cache_lookup(cache, pip->i_ino);
561         if (item) {
562                 ASSERT(item->ip == pip);
563                 ag = item->ag;
564                 xfs_mru_cache_done(cache);
565
566                 TRACE_LOOKUP(mp, pip, pip, ag, xfs_filestream_peek_ag(mp, ag));
567                 err = _xfs_filestream_update_ag(ip, pip, ag);
568
569                 goto exit;
570         }
571
572         /*
573          * Set the starting AG using the rotor for inode32, otherwise
574          * use the directory inode's AG.
575          */
576         if (mp->m_flags & XFS_MOUNT_32BITINODES) {
577                 rotorstep = xfs_rotorstep;
578                 startag = (mp->m_agfrotor / rotorstep) % mp->m_sb.sb_agcount;
579                 mp->m_agfrotor = (mp->m_agfrotor + 1) %
580                                  (mp->m_sb.sb_agcount * rotorstep);
581         } else
582                 startag = XFS_INO_TO_AGNO(mp, pip->i_ino);
583
584         /* Pick a new AG for the parent inode starting at startag. */
585         err = _xfs_filestream_pick_ag(mp, startag, &ag, 0, 0);
586         if (err || ag == NULLAGNUMBER)
587                 goto exit_did_pick;
588
589         /* Associate the parent inode with the AG. */
590         err = _xfs_filestream_update_ag(pip, NULL, ag);
591         if (err)
592                 goto exit_did_pick;
593
594         /* Associate the file inode with the AG. */
595         err = _xfs_filestream_update_ag(ip, pip, ag);
596         if (err)
597                 goto exit_did_pick;
598
599         TRACE_ASSOCIATE(mp, ip, pip, ag, xfs_filestream_peek_ag(mp, ag));
600
601 exit_did_pick:
602         /*
603          * If _xfs_filestream_pick_ag() returned a valid AG, remove the
604          * reference it took on it, since the file and directory will have taken
605          * their own now if they were successfully cached.
606          */
607         if (ag != NULLAGNUMBER)
608                 xfs_filestream_put_ag(mp, ag);
609
610 exit:
611         xfs_iunlock(pip, XFS_IOLOCK_EXCL);
612         up_read(&mp->m_peraglock);
613         return -err;
614 }
615
616 /*
617  * Pick a new allocation group for the current file and its file stream.  This
618  * function is called by xfs_bmap_filestreams() with the mount point's per-ag
619  * lock held.
620  */
621 int
622 xfs_filestream_new_ag(
623         xfs_bmalloca_t  *ap,
624         xfs_agnumber_t  *agp)
625 {
626         int             flags, err;
627         xfs_inode_t     *ip, *pip = NULL;
628         xfs_mount_t     *mp;
629         xfs_mru_cache_t *cache;
630         xfs_extlen_t    minlen;
631         fstrm_item_t    *dir, *file;
632         xfs_agnumber_t  ag = NULLAGNUMBER;
633
634         ip = ap->ip;
635         mp = ip->i_mount;
636         cache = mp->m_filestream;
637         minlen = ap->alen;
638         *agp = NULLAGNUMBER;
639
640         /*
641          * Look for the file in the cache, removing it if it's found.  Doing
642          * this allows it to be held across the dir lookup that follows.
643          */
644         file = xfs_mru_cache_remove(cache, ip->i_ino);
645         if (file) {
646                 ASSERT(ip == file->ip);
647
648                 /* Save the file's parent inode and old AG number for later. */
649                 pip = file->pip;
650                 ag = file->ag;
651
652                 /* Look for the file's directory in the cache. */
653                 dir = xfs_mru_cache_lookup(cache, pip->i_ino);
654                 if (dir) {
655                         ASSERT(pip == dir->ip);
656
657                         /*
658                          * If the directory has already moved on to a new AG,
659                          * use that AG as the new AG for the file. Don't
660                          * forget to twiddle the AG refcounts to match the
661                          * movement.
662                          */
663                         if (dir->ag != file->ag) {
664                                 xfs_filestream_put_ag(mp, file->ag);
665                                 xfs_filestream_get_ag(mp, dir->ag);
666                                 *agp = file->ag = dir->ag;
667                         }
668
669                         xfs_mru_cache_done(cache);
670                 }
671
672                 /*
673                  * Put the file back in the cache.  If this fails, the free
674                  * function needs to be called to tidy up in the same way as if
675                  * the item had simply expired from the cache.
676                  */
677                 err = xfs_mru_cache_insert(cache, ip->i_ino, file);
678                 if (err) {
679                         xfs_fstrm_free_func(ip->i_ino, file);
680                         return err;
681                 }
682
683                 /*
684                  * If the file's AG was moved to the directory's new AG, there's
685                  * nothing more to be done.
686                  */
687                 if (*agp != NULLAGNUMBER) {
688                         TRACE_MOVEAG(mp, ip, pip,
689                                         ag, xfs_filestream_peek_ag(mp, ag),
690                                         *agp, xfs_filestream_peek_ag(mp, *agp));
691                         return 0;
692                 }
693         }
694
695         /*
696          * If the file's parent directory is known, take its iolock in exclusive
697          * mode to prevent two sibling files from racing each other to migrate
698          * themselves and their parent to different AGs.
699          */
700         if (pip)
701                 xfs_ilock(pip, XFS_IOLOCK_EXCL);
702
703         /*
704          * A new AG needs to be found for the file.  If the file's parent
705          * directory is also known, it will be moved to the new AG as well to
706          * ensure that files created inside it in future use the new AG.
707          */
708         ag = (ag == NULLAGNUMBER) ? 0 : (ag + 1) % mp->m_sb.sb_agcount;
709         flags = (ap->userdata ? XFS_PICK_USERDATA : 0) |
710                 (ap->low ? XFS_PICK_LOWSPACE : 0);
711
712         err = _xfs_filestream_pick_ag(mp, ag, agp, flags, minlen);
713         if (err || *agp == NULLAGNUMBER)
714                 goto exit;
715
716         /*
717          * If the file wasn't found in the file cache, then its parent directory
718          * inode isn't known.  For this to have happened, the file must either
719          * be pre-existing, or it was created long enough ago that its cache
720          * entry has expired.  This isn't the sort of usage that the filestreams
721          * allocator is trying to optimise, so there's no point trying to track
722          * its new AG somehow in the filestream data structures.
723          */
724         if (!pip) {
725                 TRACE_ORPHAN(mp, ip, *agp);
726                 goto exit;
727         }
728
729         /* Associate the parent inode with the AG. */
730         err = _xfs_filestream_update_ag(pip, NULL, *agp);
731         if (err)
732                 goto exit;
733
734         /* Associate the file inode with the AG. */
735         err = _xfs_filestream_update_ag(ip, pip, *agp);
736         if (err)
737                 goto exit;
738
739         TRACE_MOVEAG(mp, ip, pip, NULLAGNUMBER, 0,
740                         *agp, xfs_filestream_peek_ag(mp, *agp));
741
742 exit:
743         /*
744          * If _xfs_filestream_pick_ag() returned a valid AG, remove the
745          * reference it took on it, since the file and directory will have taken
746          * their own now if they were successfully cached.
747          */
748         if (*agp != NULLAGNUMBER)
749                 xfs_filestream_put_ag(mp, *agp);
750         else
751                 *agp = 0;
752
753         if (pip)
754                 xfs_iunlock(pip, XFS_IOLOCK_EXCL);
755
756         return err;
757 }
758
759 /*
760  * Remove an association between an inode and a filestream object.
761  * Typically this is done on last close of an unlinked file.
762  */
763 void
764 xfs_filestream_deassociate(
765         xfs_inode_t     *ip)
766 {
767         xfs_mru_cache_t *cache = ip->i_mount->m_filestream;
768
769         xfs_mru_cache_delete(cache, ip->i_ino);
770 }