Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[firefly-linux-kernel-4.4.55.git] / fs / xfs / xfs_itable.c
1 /*
2  * Copyright (c) 2000-2002,2005 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_fs.h"
20 #include "xfs_shared.h"
21 #include "xfs_format.h"
22 #include "xfs_log_format.h"
23 #include "xfs_trans_resv.h"
24 #include "xfs_mount.h"
25 #include "xfs_inode.h"
26 #include "xfs_btree.h"
27 #include "xfs_ialloc.h"
28 #include "xfs_ialloc_btree.h"
29 #include "xfs_itable.h"
30 #include "xfs_error.h"
31 #include "xfs_trace.h"
32 #include "xfs_icache.h"
33
34 STATIC int
35 xfs_internal_inum(
36         xfs_mount_t     *mp,
37         xfs_ino_t       ino)
38 {
39         return (ino == mp->m_sb.sb_rbmino || ino == mp->m_sb.sb_rsumino ||
40                 (xfs_sb_version_hasquota(&mp->m_sb) &&
41                  xfs_is_quota_inode(&mp->m_sb, ino)));
42 }
43
44 /*
45  * Return stat information for one inode.
46  * Return 0 if ok, else errno.
47  */
48 int
49 xfs_bulkstat_one_int(
50         struct xfs_mount        *mp,            /* mount point for filesystem */
51         xfs_ino_t               ino,            /* inode to get data for */
52         void __user             *buffer,        /* buffer to place output in */
53         int                     ubsize,         /* size of buffer */
54         bulkstat_one_fmt_pf     formatter,      /* formatter, copy to user */
55         int                     *ubused,        /* bytes used by me */
56         int                     *stat)          /* BULKSTAT_RV_... */
57 {
58         struct xfs_icdinode     *dic;           /* dinode core info pointer */
59         struct xfs_inode        *ip;            /* incore inode pointer */
60         struct xfs_bstat        *buf;           /* return buffer */
61         int                     error = 0;      /* error value */
62
63         *stat = BULKSTAT_RV_NOTHING;
64
65         if (!buffer || xfs_internal_inum(mp, ino))
66                 return -EINVAL;
67
68         buf = kmem_alloc(sizeof(*buf), KM_SLEEP | KM_MAYFAIL);
69         if (!buf)
70                 return -ENOMEM;
71
72         error = xfs_iget(mp, NULL, ino,
73                          (XFS_IGET_DONTCACHE | XFS_IGET_UNTRUSTED),
74                          XFS_ILOCK_SHARED, &ip);
75         if (error)
76                 goto out_free;
77
78         ASSERT(ip != NULL);
79         ASSERT(ip->i_imap.im_blkno != 0);
80
81         dic = &ip->i_d;
82
83         /* xfs_iget returns the following without needing
84          * further change.
85          */
86         buf->bs_nlink = dic->di_nlink;
87         buf->bs_projid_lo = dic->di_projid_lo;
88         buf->bs_projid_hi = dic->di_projid_hi;
89         buf->bs_ino = ino;
90         buf->bs_mode = dic->di_mode;
91         buf->bs_uid = dic->di_uid;
92         buf->bs_gid = dic->di_gid;
93         buf->bs_size = dic->di_size;
94         buf->bs_atime.tv_sec = dic->di_atime.t_sec;
95         buf->bs_atime.tv_nsec = dic->di_atime.t_nsec;
96         buf->bs_mtime.tv_sec = dic->di_mtime.t_sec;
97         buf->bs_mtime.tv_nsec = dic->di_mtime.t_nsec;
98         buf->bs_ctime.tv_sec = dic->di_ctime.t_sec;
99         buf->bs_ctime.tv_nsec = dic->di_ctime.t_nsec;
100         buf->bs_xflags = xfs_ip2xflags(ip);
101         buf->bs_extsize = dic->di_extsize << mp->m_sb.sb_blocklog;
102         buf->bs_extents = dic->di_nextents;
103         buf->bs_gen = dic->di_gen;
104         memset(buf->bs_pad, 0, sizeof(buf->bs_pad));
105         buf->bs_dmevmask = dic->di_dmevmask;
106         buf->bs_dmstate = dic->di_dmstate;
107         buf->bs_aextents = dic->di_anextents;
108         buf->bs_forkoff = XFS_IFORK_BOFF(ip);
109
110         switch (dic->di_format) {
111         case XFS_DINODE_FMT_DEV:
112                 buf->bs_rdev = ip->i_df.if_u2.if_rdev;
113                 buf->bs_blksize = BLKDEV_IOSIZE;
114                 buf->bs_blocks = 0;
115                 break;
116         case XFS_DINODE_FMT_LOCAL:
117         case XFS_DINODE_FMT_UUID:
118                 buf->bs_rdev = 0;
119                 buf->bs_blksize = mp->m_sb.sb_blocksize;
120                 buf->bs_blocks = 0;
121                 break;
122         case XFS_DINODE_FMT_EXTENTS:
123         case XFS_DINODE_FMT_BTREE:
124                 buf->bs_rdev = 0;
125                 buf->bs_blksize = mp->m_sb.sb_blocksize;
126                 buf->bs_blocks = dic->di_nblocks + ip->i_delayed_blks;
127                 break;
128         }
129         xfs_iunlock(ip, XFS_ILOCK_SHARED);
130         IRELE(ip);
131
132         error = formatter(buffer, ubsize, ubused, buf);
133         if (!error)
134                 *stat = BULKSTAT_RV_DIDONE;
135
136  out_free:
137         kmem_free(buf);
138         return error;
139 }
140
141 /* Return 0 on success or positive error */
142 STATIC int
143 xfs_bulkstat_one_fmt(
144         void                    __user *ubuffer,
145         int                     ubsize,
146         int                     *ubused,
147         const xfs_bstat_t       *buffer)
148 {
149         if (ubsize < sizeof(*buffer))
150                 return -ENOMEM;
151         if (copy_to_user(ubuffer, buffer, sizeof(*buffer)))
152                 return -EFAULT;
153         if (ubused)
154                 *ubused = sizeof(*buffer);
155         return 0;
156 }
157
158 int
159 xfs_bulkstat_one(
160         xfs_mount_t     *mp,            /* mount point for filesystem */
161         xfs_ino_t       ino,            /* inode number to get data for */
162         void            __user *buffer, /* buffer to place output in */
163         int             ubsize,         /* size of buffer */
164         int             *ubused,        /* bytes used by me */
165         int             *stat)          /* BULKSTAT_RV_... */
166 {
167         return xfs_bulkstat_one_int(mp, ino, buffer, ubsize,
168                                     xfs_bulkstat_one_fmt, ubused, stat);
169 }
170
171 /*
172  * Loop over all clusters in a chunk for a given incore inode allocation btree
173  * record.  Do a readahead if there are any allocated inodes in that cluster.
174  */
175 STATIC void
176 xfs_bulkstat_ichunk_ra(
177         struct xfs_mount                *mp,
178         xfs_agnumber_t                  agno,
179         struct xfs_inobt_rec_incore     *irec)
180 {
181         xfs_agblock_t                   agbno;
182         struct blk_plug                 plug;
183         int                             blks_per_cluster;
184         int                             inodes_per_cluster;
185         int                             i;      /* inode chunk index */
186
187         agbno = XFS_AGINO_TO_AGBNO(mp, irec->ir_startino);
188         blks_per_cluster = xfs_icluster_size_fsb(mp);
189         inodes_per_cluster = blks_per_cluster << mp->m_sb.sb_inopblog;
190
191         blk_start_plug(&plug);
192         for (i = 0; i < XFS_INODES_PER_CHUNK;
193              i += inodes_per_cluster, agbno += blks_per_cluster) {
194                 if (xfs_inobt_maskn(i, inodes_per_cluster) & ~irec->ir_free) {
195                         xfs_btree_reada_bufs(mp, agno, agbno, blks_per_cluster,
196                                              &xfs_inode_buf_ops);
197                 }
198         }
199         blk_finish_plug(&plug);
200 }
201
202 /*
203  * Lookup the inode chunk that the given inode lives in and then get the record
204  * if we found the chunk.  If the inode was not the last in the chunk and there
205  * are some left allocated, update the data for the pointed-to record as well as
206  * return the count of grabbed inodes.
207  */
208 STATIC int
209 xfs_bulkstat_grab_ichunk(
210         struct xfs_btree_cur            *cur,   /* btree cursor */
211         xfs_agino_t                     agino,  /* starting inode of chunk */
212         int                             *icount,/* return # of inodes grabbed */
213         struct xfs_inobt_rec_incore     *irec)  /* btree record */
214 {
215         int                             idx;    /* index into inode chunk */
216         int                             stat;
217         int                             error = 0;
218
219         /* Lookup the inode chunk that this inode lives in */
220         error = xfs_inobt_lookup(cur, agino, XFS_LOOKUP_LE, &stat);
221         if (error)
222                 return error;
223         if (!stat) {
224                 *icount = 0;
225                 return error;
226         }
227
228         /* Get the record, should always work */
229         error = xfs_inobt_get_rec(cur, irec, &stat);
230         if (error)
231                 return error;
232         XFS_WANT_CORRUPTED_RETURN(cur->bc_mp, stat == 1);
233
234         /* Check if the record contains the inode in request */
235         if (irec->ir_startino + XFS_INODES_PER_CHUNK <= agino) {
236                 *icount = 0;
237                 return 0;
238         }
239
240         idx = agino - irec->ir_startino + 1;
241         if (idx < XFS_INODES_PER_CHUNK &&
242             (xfs_inobt_maskn(idx, XFS_INODES_PER_CHUNK - idx) & ~irec->ir_free)) {
243                 int     i;
244
245                 /* We got a right chunk with some left inodes allocated at it.
246                  * Grab the chunk record.  Mark all the uninteresting inodes
247                  * free -- because they're before our start point.
248                  */
249                 for (i = 0; i < idx; i++) {
250                         if (XFS_INOBT_MASK(i) & ~irec->ir_free)
251                                 irec->ir_freecount++;
252                 }
253
254                 irec->ir_free |= xfs_inobt_maskn(0, idx);
255                 *icount = irec->ir_count - irec->ir_freecount;
256         }
257
258         return 0;
259 }
260
261 #define XFS_BULKSTAT_UBLEFT(ubleft)     ((ubleft) >= statstruct_size)
262
263 struct xfs_bulkstat_agichunk {
264         char            __user **ac_ubuffer;/* pointer into user's buffer */
265         int             ac_ubleft;      /* bytes left in user's buffer */
266         int             ac_ubelem;      /* spaces used in user's buffer */
267 };
268
269 /*
270  * Process inodes in chunk with a pointer to a formatter function
271  * that will iget the inode and fill in the appropriate structure.
272  */
273 static int
274 xfs_bulkstat_ag_ichunk(
275         struct xfs_mount                *mp,
276         xfs_agnumber_t                  agno,
277         struct xfs_inobt_rec_incore     *irbp,
278         bulkstat_one_pf                 formatter,
279         size_t                          statstruct_size,
280         struct xfs_bulkstat_agichunk    *acp,
281         xfs_agino_t                     *last_agino)
282 {
283         char                            __user **ubufp = acp->ac_ubuffer;
284         int                             chunkidx;
285         int                             error = 0;
286         xfs_agino_t                     agino = irbp->ir_startino;
287
288         for (chunkidx = 0; chunkidx < XFS_INODES_PER_CHUNK;
289              chunkidx++, agino++) {
290                 int             fmterror;
291                 int             ubused;
292
293                 /* inode won't fit in buffer, we are done */
294                 if (acp->ac_ubleft < statstruct_size)
295                         break;
296
297                 /* Skip if this inode is free */
298                 if (XFS_INOBT_MASK(chunkidx) & irbp->ir_free)
299                         continue;
300
301                 /* Get the inode and fill in a single buffer */
302                 ubused = statstruct_size;
303                 error = formatter(mp, XFS_AGINO_TO_INO(mp, agno, agino),
304                                   *ubufp, acp->ac_ubleft, &ubused, &fmterror);
305
306                 if (fmterror == BULKSTAT_RV_GIVEUP ||
307                     (error && error != -ENOENT && error != -EINVAL)) {
308                         acp->ac_ubleft = 0;
309                         ASSERT(error);
310                         break;
311                 }
312
313                 /* be careful not to leak error if at end of chunk */
314                 if (fmterror == BULKSTAT_RV_NOTHING || error) {
315                         error = 0;
316                         continue;
317                 }
318
319                 *ubufp += ubused;
320                 acp->ac_ubleft -= ubused;
321                 acp->ac_ubelem++;
322         }
323
324         /*
325          * Post-update *last_agino. At this point, agino will always point one
326          * inode past the last inode we processed successfully. Hence we
327          * substract that inode when setting the *last_agino cursor so that we
328          * return the correct cookie to userspace. On the next bulkstat call,
329          * the inode under the lastino cookie will be skipped as we have already
330          * processed it here.
331          */
332         *last_agino = agino - 1;
333
334         return error;
335 }
336
337 /*
338  * Return stat information in bulk (by-inode) for the filesystem.
339  */
340 int                                     /* error status */
341 xfs_bulkstat(
342         xfs_mount_t             *mp,    /* mount point for filesystem */
343         xfs_ino_t               *lastinop, /* last inode returned */
344         int                     *ubcountp, /* size of buffer/count returned */
345         bulkstat_one_pf         formatter, /* func that'd fill a single buf */
346         size_t                  statstruct_size, /* sizeof struct filling */
347         char                    __user *ubuffer, /* buffer with inode stats */
348         int                     *done)  /* 1 if there are more stats to get */
349 {
350         xfs_buf_t               *agbp;  /* agi header buffer */
351         xfs_agino_t             agino;  /* inode # in allocation group */
352         xfs_agnumber_t          agno;   /* allocation group number */
353         xfs_btree_cur_t         *cur;   /* btree cursor for ialloc btree */
354         size_t                  irbsize; /* size of irec buffer in bytes */
355         xfs_inobt_rec_incore_t  *irbuf; /* start of irec buffer */
356         int                     nirbuf; /* size of irbuf */
357         int                     ubcount; /* size of user's buffer */
358         struct xfs_bulkstat_agichunk ac;
359         int                     error = 0;
360
361         /*
362          * Get the last inode value, see if there's nothing to do.
363          */
364         agno = XFS_INO_TO_AGNO(mp, *lastinop);
365         agino = XFS_INO_TO_AGINO(mp, *lastinop);
366         if (agno >= mp->m_sb.sb_agcount ||
367             *lastinop != XFS_AGINO_TO_INO(mp, agno, agino)) {
368                 *done = 1;
369                 *ubcountp = 0;
370                 return 0;
371         }
372
373         ubcount = *ubcountp; /* statstruct's */
374         ac.ac_ubuffer = &ubuffer;
375         ac.ac_ubleft = ubcount * statstruct_size; /* bytes */;
376         ac.ac_ubelem = 0;
377
378         *ubcountp = 0;
379         *done = 0;
380
381         irbuf = kmem_zalloc_greedy(&irbsize, PAGE_SIZE, PAGE_SIZE * 4);
382         if (!irbuf)
383                 return -ENOMEM;
384
385         nirbuf = irbsize / sizeof(*irbuf);
386
387         /*
388          * Loop over the allocation groups, starting from the last
389          * inode returned; 0 means start of the allocation group.
390          */
391         while (agno < mp->m_sb.sb_agcount) {
392                 struct xfs_inobt_rec_incore     *irbp = irbuf;
393                 struct xfs_inobt_rec_incore     *irbufend = irbuf + nirbuf;
394                 bool                            end_of_ag = false;
395                 int                             icount = 0;
396                 int                             stat;
397
398                 error = xfs_ialloc_read_agi(mp, NULL, agno, &agbp);
399                 if (error)
400                         break;
401                 /*
402                  * Allocate and initialize a btree cursor for ialloc btree.
403                  */
404                 cur = xfs_inobt_init_cursor(mp, NULL, agbp, agno,
405                                             XFS_BTNUM_INO);
406                 if (agino > 0) {
407                         /*
408                          * In the middle of an allocation group, we need to get
409                          * the remainder of the chunk we're in.
410                          */
411                         struct xfs_inobt_rec_incore     r;
412
413                         error = xfs_bulkstat_grab_ichunk(cur, agino, &icount, &r);
414                         if (error)
415                                 goto del_cursor;
416                         if (icount) {
417                                 irbp->ir_startino = r.ir_startino;
418                                 irbp->ir_holemask = r.ir_holemask;
419                                 irbp->ir_count = r.ir_count;
420                                 irbp->ir_freecount = r.ir_freecount;
421                                 irbp->ir_free = r.ir_free;
422                                 irbp++;
423                         }
424                         /* Increment to the next record */
425                         error = xfs_btree_increment(cur, 0, &stat);
426                 } else {
427                         /* Start of ag.  Lookup the first inode chunk */
428                         error = xfs_inobt_lookup(cur, 0, XFS_LOOKUP_GE, &stat);
429                 }
430                 if (error || stat == 0) {
431                         end_of_ag = true;
432                         goto del_cursor;
433                 }
434
435                 /*
436                  * Loop through inode btree records in this ag,
437                  * until we run out of inodes or space in the buffer.
438                  */
439                 while (irbp < irbufend && icount < ubcount) {
440                         struct xfs_inobt_rec_incore     r;
441
442                         error = xfs_inobt_get_rec(cur, &r, &stat);
443                         if (error || stat == 0) {
444                                 end_of_ag = true;
445                                 goto del_cursor;
446                         }
447
448                         /*
449                          * If this chunk has any allocated inodes, save it.
450                          * Also start read-ahead now for this chunk.
451                          */
452                         if (r.ir_freecount < r.ir_count) {
453                                 xfs_bulkstat_ichunk_ra(mp, agno, &r);
454                                 irbp->ir_startino = r.ir_startino;
455                                 irbp->ir_holemask = r.ir_holemask;
456                                 irbp->ir_count = r.ir_count;
457                                 irbp->ir_freecount = r.ir_freecount;
458                                 irbp->ir_free = r.ir_free;
459                                 irbp++;
460                                 icount += r.ir_count - r.ir_freecount;
461                         }
462                         error = xfs_btree_increment(cur, 0, &stat);
463                         if (error || stat == 0) {
464                                 end_of_ag = true;
465                                 goto del_cursor;
466                         }
467                         cond_resched();
468                 }
469
470                 /*
471                  * Drop the btree buffers and the agi buffer as we can't hold any
472                  * of the locks these represent when calling iget. If there is a
473                  * pending error, then we are done.
474                  */
475 del_cursor:
476                 xfs_btree_del_cursor(cur, error ?
477                                           XFS_BTREE_ERROR : XFS_BTREE_NOERROR);
478                 xfs_buf_relse(agbp);
479                 if (error)
480                         break;
481                 /*
482                  * Now format all the good inodes into the user's buffer. The
483                  * call to xfs_bulkstat_ag_ichunk() sets up the agino pointer
484                  * for the next loop iteration.
485                  */
486                 irbufend = irbp;
487                 for (irbp = irbuf;
488                      irbp < irbufend && ac.ac_ubleft >= statstruct_size;
489                      irbp++) {
490                         error = xfs_bulkstat_ag_ichunk(mp, agno, irbp,
491                                         formatter, statstruct_size, &ac,
492                                         &agino);
493                         if (error)
494                                 break;
495
496                         cond_resched();
497                 }
498
499                 /*
500                  * If we've run out of space or had a formatting error, we
501                  * are now done
502                  */
503                 if (ac.ac_ubleft < statstruct_size || error)
504                         break;
505
506                 if (end_of_ag) {
507                         agno++;
508                         agino = 0;
509                 }
510         }
511         /*
512          * Done, we're either out of filesystem or space to put the data.
513          */
514         kmem_free(irbuf);
515         *ubcountp = ac.ac_ubelem;
516
517         /*
518          * We found some inodes, so clear the error status and return them.
519          * The lastino pointer will point directly at the inode that triggered
520          * any error that occurred, so on the next call the error will be
521          * triggered again and propagated to userspace as there will be no
522          * formatted inodes in the buffer.
523          */
524         if (ac.ac_ubelem)
525                 error = 0;
526
527         /*
528          * If we ran out of filesystem, lastino will point off the end of
529          * the filesystem so the next call will return immediately.
530          */
531         *lastinop = XFS_AGINO_TO_INO(mp, agno, agino);
532         if (agno >= mp->m_sb.sb_agcount)
533                 *done = 1;
534
535         return error;
536 }
537
538 int
539 xfs_inumbers_fmt(
540         void                    __user *ubuffer, /* buffer to write to */
541         const struct xfs_inogrp *buffer,        /* buffer to read from */
542         long                    count,          /* # of elements to read */
543         long                    *written)       /* # of bytes written */
544 {
545         if (copy_to_user(ubuffer, buffer, count * sizeof(*buffer)))
546                 return -EFAULT;
547         *written = count * sizeof(*buffer);
548         return 0;
549 }
550
551 /*
552  * Return inode number table for the filesystem.
553  */
554 int                                     /* error status */
555 xfs_inumbers(
556         struct xfs_mount        *mp,/* mount point for filesystem */
557         xfs_ino_t               *lastino,/* last inode returned */
558         int                     *count,/* size of buffer/count returned */
559         void                    __user *ubuffer,/* buffer with inode descriptions */
560         inumbers_fmt_pf         formatter)
561 {
562         xfs_agnumber_t          agno = XFS_INO_TO_AGNO(mp, *lastino);
563         xfs_agino_t             agino = XFS_INO_TO_AGINO(mp, *lastino);
564         struct xfs_btree_cur    *cur = NULL;
565         struct xfs_buf          *agbp = NULL;
566         struct xfs_inogrp       *buffer;
567         int                     bcount;
568         int                     left = *count;
569         int                     bufidx = 0;
570         int                     error = 0;
571
572         *count = 0;
573         if (agno >= mp->m_sb.sb_agcount ||
574             *lastino != XFS_AGINO_TO_INO(mp, agno, agino))
575                 return error;
576
577         bcount = MIN(left, (int)(PAGE_SIZE / sizeof(*buffer)));
578         buffer = kmem_alloc(bcount * sizeof(*buffer), KM_SLEEP);
579         do {
580                 struct xfs_inobt_rec_incore     r;
581                 int                             stat;
582
583                 if (!agbp) {
584                         error = xfs_ialloc_read_agi(mp, NULL, agno, &agbp);
585                         if (error)
586                                 break;
587
588                         cur = xfs_inobt_init_cursor(mp, NULL, agbp, agno,
589                                                     XFS_BTNUM_INO);
590                         error = xfs_inobt_lookup(cur, agino, XFS_LOOKUP_GE,
591                                                  &stat);
592                         if (error)
593                                 break;
594                         if (!stat)
595                                 goto next_ag;
596                 }
597
598                 error = xfs_inobt_get_rec(cur, &r, &stat);
599                 if (error)
600                         break;
601                 if (!stat)
602                         goto next_ag;
603
604                 agino = r.ir_startino + XFS_INODES_PER_CHUNK - 1;
605                 buffer[bufidx].xi_startino =
606                         XFS_AGINO_TO_INO(mp, agno, r.ir_startino);
607                 buffer[bufidx].xi_alloccount = r.ir_count - r.ir_freecount;
608                 buffer[bufidx].xi_allocmask = ~r.ir_free;
609                 if (++bufidx == bcount) {
610                         long    written;
611
612                         error = formatter(ubuffer, buffer, bufidx, &written);
613                         if (error)
614                                 break;
615                         ubuffer += written;
616                         *count += bufidx;
617                         bufidx = 0;
618                 }
619                 if (!--left)
620                         break;
621
622                 error = xfs_btree_increment(cur, 0, &stat);
623                 if (error)
624                         break;
625                 if (stat)
626                         continue;
627
628 next_ag:
629                 xfs_btree_del_cursor(cur, XFS_BTREE_ERROR);
630                 cur = NULL;
631                 xfs_buf_relse(agbp);
632                 agbp = NULL;
633                 agino = 0;
634                 agno++;
635         } while (agno < mp->m_sb.sb_agcount);
636
637         if (!error) {
638                 if (bufidx) {
639                         long    written;
640
641                         error = formatter(ubuffer, buffer, bufidx, &written);
642                         if (!error)
643                                 *count += bufidx;
644                 }
645                 *lastino = XFS_AGINO_TO_INO(mp, agno, agino);
646         }
647
648         kmem_free(buffer);
649         if (cur)
650                 xfs_btree_del_cursor(cur, (error ? XFS_BTREE_ERROR :
651                                            XFS_BTREE_NOERROR));
652         if (agbp)
653                 xfs_buf_relse(agbp);
654
655         return error;
656 }