Merge branch 'master'
[linux-2.6] / fs / xfs / xfs_inode.c
1 /*
2  * Copyright (c) 2000-2003,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_types.h"
21 #include "xfs_bit.h"
22 #include "xfs_log.h"
23 #include "xfs_inum.h"
24 #include "xfs_imap.h"
25 #include "xfs_trans.h"
26 #include "xfs_trans_priv.h"
27 #include "xfs_sb.h"
28 #include "xfs_ag.h"
29 #include "xfs_dir.h"
30 #include "xfs_dir2.h"
31 #include "xfs_dmapi.h"
32 #include "xfs_mount.h"
33 #include "xfs_bmap_btree.h"
34 #include "xfs_alloc_btree.h"
35 #include "xfs_ialloc_btree.h"
36 #include "xfs_dir_sf.h"
37 #include "xfs_dir2_sf.h"
38 #include "xfs_attr_sf.h"
39 #include "xfs_dinode.h"
40 #include "xfs_inode.h"
41 #include "xfs_buf_item.h"
42 #include "xfs_inode_item.h"
43 #include "xfs_btree.h"
44 #include "xfs_alloc.h"
45 #include "xfs_ialloc.h"
46 #include "xfs_bmap.h"
47 #include "xfs_rw.h"
48 #include "xfs_error.h"
49 #include "xfs_utils.h"
50 #include "xfs_dir2_trace.h"
51 #include "xfs_quota.h"
52 #include "xfs_mac.h"
53 #include "xfs_acl.h"
54
55
56 kmem_zone_t *xfs_ifork_zone;
57 kmem_zone_t *xfs_inode_zone;
58 kmem_zone_t *xfs_chashlist_zone;
59
60 /*
61  * Used in xfs_itruncate().  This is the maximum number of extents
62  * freed from a file in a single transaction.
63  */
64 #define XFS_ITRUNC_MAX_EXTENTS  2
65
66 STATIC int xfs_iflush_int(xfs_inode_t *, xfs_buf_t *);
67 STATIC int xfs_iformat_local(xfs_inode_t *, xfs_dinode_t *, int, int);
68 STATIC int xfs_iformat_extents(xfs_inode_t *, xfs_dinode_t *, int);
69 STATIC int xfs_iformat_btree(xfs_inode_t *, xfs_dinode_t *, int);
70
71
72 #ifdef DEBUG
73 /*
74  * Make sure that the extents in the given memory buffer
75  * are valid.
76  */
77 STATIC void
78 xfs_validate_extents(
79         xfs_ifork_t             *ifp,
80         int                     nrecs,
81         int                     disk,
82         xfs_exntfmt_t           fmt)
83 {
84         xfs_bmbt_rec_t          *ep;
85         xfs_bmbt_irec_t         irec;
86         xfs_bmbt_rec_t          rec;
87         int                     i;
88
89         for (i = 0; i < nrecs; i++) {
90                 ep = xfs_iext_get_ext(ifp, i);
91                 rec.l0 = get_unaligned((__uint64_t*)&ep->l0);
92                 rec.l1 = get_unaligned((__uint64_t*)&ep->l1);
93                 if (disk)
94                         xfs_bmbt_disk_get_all(&rec, &irec);
95                 else
96                         xfs_bmbt_get_all(&rec, &irec);
97                 if (fmt == XFS_EXTFMT_NOSTATE)
98                         ASSERT(irec.br_state == XFS_EXT_NORM);
99         }
100 }
101 #else /* DEBUG */
102 #define xfs_validate_extents(ifp, nrecs, disk, fmt)
103 #endif /* DEBUG */
104
105 /*
106  * Check that none of the inode's in the buffer have a next
107  * unlinked field of 0.
108  */
109 #if defined(DEBUG)
110 void
111 xfs_inobp_check(
112         xfs_mount_t     *mp,
113         xfs_buf_t       *bp)
114 {
115         int             i;
116         int             j;
117         xfs_dinode_t    *dip;
118
119         j = mp->m_inode_cluster_size >> mp->m_sb.sb_inodelog;
120
121         for (i = 0; i < j; i++) {
122                 dip = (xfs_dinode_t *)xfs_buf_offset(bp,
123                                         i * mp->m_sb.sb_inodesize);
124                 if (!dip->di_next_unlinked)  {
125                         xfs_fs_cmn_err(CE_ALERT, mp,
126                                 "Detected a bogus zero next_unlinked field in incore inode buffer 0x%p.  About to pop an ASSERT.",
127                                 bp);
128                         ASSERT(dip->di_next_unlinked);
129                 }
130         }
131 }
132 #endif
133
134 /*
135  * This routine is called to map an inode number within a file
136  * system to the buffer containing the on-disk version of the
137  * inode.  It returns a pointer to the buffer containing the
138  * on-disk inode in the bpp parameter, and in the dip parameter
139  * it returns a pointer to the on-disk inode within that buffer.
140  *
141  * If a non-zero error is returned, then the contents of bpp and
142  * dipp are undefined.
143  *
144  * Use xfs_imap() to determine the size and location of the
145  * buffer to read from disk.
146  */
147 STATIC int
148 xfs_inotobp(
149         xfs_mount_t     *mp,
150         xfs_trans_t     *tp,
151         xfs_ino_t       ino,
152         xfs_dinode_t    **dipp,
153         xfs_buf_t       **bpp,
154         int             *offset)
155 {
156         int             di_ok;
157         xfs_imap_t      imap;
158         xfs_buf_t       *bp;
159         int             error;
160         xfs_dinode_t    *dip;
161
162         /*
163          * Call the space management code to find the location of the
164          * inode on disk.
165          */
166         imap.im_blkno = 0;
167         error = xfs_imap(mp, tp, ino, &imap, XFS_IMAP_LOOKUP);
168         if (error != 0) {
169                 cmn_err(CE_WARN,
170         "xfs_inotobp: xfs_imap()  returned an "
171         "error %d on %s.  Returning error.", error, mp->m_fsname);
172                 return error;
173         }
174
175         /*
176          * If the inode number maps to a block outside the bounds of the
177          * file system then return NULL rather than calling read_buf
178          * and panicing when we get an error from the driver.
179          */
180         if ((imap.im_blkno + imap.im_len) >
181             XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks)) {
182                 cmn_err(CE_WARN,
183         "xfs_inotobp: inode number (%llu + %d) maps to a block outside the bounds "
184         "of the file system %s.  Returning EINVAL.",
185                         (unsigned long long)imap.im_blkno,
186                         imap.im_len, mp->m_fsname);
187                 return XFS_ERROR(EINVAL);
188         }
189
190         /*
191          * Read in the buffer.  If tp is NULL, xfs_trans_read_buf() will
192          * default to just a read_buf() call.
193          */
194         error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, imap.im_blkno,
195                                    (int)imap.im_len, XFS_BUF_LOCK, &bp);
196
197         if (error) {
198                 cmn_err(CE_WARN,
199         "xfs_inotobp: xfs_trans_read_buf()  returned an "
200         "error %d on %s.  Returning error.", error, mp->m_fsname);
201                 return error;
202         }
203         dip = (xfs_dinode_t *)xfs_buf_offset(bp, 0);
204         di_ok =
205                 INT_GET(dip->di_core.di_magic, ARCH_CONVERT) == XFS_DINODE_MAGIC &&
206                 XFS_DINODE_GOOD_VERSION(INT_GET(dip->di_core.di_version, ARCH_CONVERT));
207         if (unlikely(XFS_TEST_ERROR(!di_ok, mp, XFS_ERRTAG_ITOBP_INOTOBP,
208                         XFS_RANDOM_ITOBP_INOTOBP))) {
209                 XFS_CORRUPTION_ERROR("xfs_inotobp", XFS_ERRLEVEL_LOW, mp, dip);
210                 xfs_trans_brelse(tp, bp);
211                 cmn_err(CE_WARN,
212         "xfs_inotobp: XFS_TEST_ERROR()  returned an "
213         "error on %s.  Returning EFSCORRUPTED.",  mp->m_fsname);
214                 return XFS_ERROR(EFSCORRUPTED);
215         }
216
217         xfs_inobp_check(mp, bp);
218
219         /*
220          * Set *dipp to point to the on-disk inode in the buffer.
221          */
222         *dipp = (xfs_dinode_t *)xfs_buf_offset(bp, imap.im_boffset);
223         *bpp = bp;
224         *offset = imap.im_boffset;
225         return 0;
226 }
227
228
229 /*
230  * This routine is called to map an inode to the buffer containing
231  * the on-disk version of the inode.  It returns a pointer to the
232  * buffer containing the on-disk inode in the bpp parameter, and in
233  * the dip parameter it returns a pointer to the on-disk inode within
234  * that buffer.
235  *
236  * If a non-zero error is returned, then the contents of bpp and
237  * dipp are undefined.
238  *
239  * If the inode is new and has not yet been initialized, use xfs_imap()
240  * to determine the size and location of the buffer to read from disk.
241  * If the inode has already been mapped to its buffer and read in once,
242  * then use the mapping information stored in the inode rather than
243  * calling xfs_imap().  This allows us to avoid the overhead of looking
244  * at the inode btree for small block file systems (see xfs_dilocate()).
245  * We can tell whether the inode has been mapped in before by comparing
246  * its disk block address to 0.  Only uninitialized inodes will have
247  * 0 for the disk block address.
248  */
249 int
250 xfs_itobp(
251         xfs_mount_t     *mp,
252         xfs_trans_t     *tp,
253         xfs_inode_t     *ip,
254         xfs_dinode_t    **dipp,
255         xfs_buf_t       **bpp,
256         xfs_daddr_t     bno,
257         uint            imap_flags)
258 {
259         xfs_buf_t       *bp;
260         int             error;
261         xfs_imap_t      imap;
262 #ifdef __KERNEL__
263         int             i;
264         int             ni;
265 #endif
266
267         if (ip->i_blkno == (xfs_daddr_t)0) {
268                 /*
269                  * Call the space management code to find the location of the
270                  * inode on disk.
271                  */
272                 imap.im_blkno = bno;
273                 if ((error = xfs_imap(mp, tp, ip->i_ino, &imap,
274                                         XFS_IMAP_LOOKUP | imap_flags)))
275                         return error;
276
277                 /*
278                  * If the inode number maps to a block outside the bounds
279                  * of the file system then return NULL rather than calling
280                  * read_buf and panicing when we get an error from the
281                  * driver.
282                  */
283                 if ((imap.im_blkno + imap.im_len) >
284                     XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks)) {
285 #ifdef DEBUG
286                         xfs_fs_cmn_err(CE_ALERT, mp, "xfs_itobp: "
287                                         "(imap.im_blkno (0x%llx) "
288                                         "+ imap.im_len (0x%llx)) > "
289                                         " XFS_FSB_TO_BB(mp, "
290                                         "mp->m_sb.sb_dblocks) (0x%llx)",
291                                         (unsigned long long) imap.im_blkno,
292                                         (unsigned long long) imap.im_len,
293                                         XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks));
294 #endif /* DEBUG */
295                         return XFS_ERROR(EINVAL);
296                 }
297
298                 /*
299                  * Fill in the fields in the inode that will be used to
300                  * map the inode to its buffer from now on.
301                  */
302                 ip->i_blkno = imap.im_blkno;
303                 ip->i_len = imap.im_len;
304                 ip->i_boffset = imap.im_boffset;
305         } else {
306                 /*
307                  * We've already mapped the inode once, so just use the
308                  * mapping that we saved the first time.
309                  */
310                 imap.im_blkno = ip->i_blkno;
311                 imap.im_len = ip->i_len;
312                 imap.im_boffset = ip->i_boffset;
313         }
314         ASSERT(bno == 0 || bno == imap.im_blkno);
315
316         /*
317          * Read in the buffer.  If tp is NULL, xfs_trans_read_buf() will
318          * default to just a read_buf() call.
319          */
320         error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, imap.im_blkno,
321                                    (int)imap.im_len, XFS_BUF_LOCK, &bp);
322
323         if (error) {
324 #ifdef DEBUG
325                 xfs_fs_cmn_err(CE_ALERT, mp, "xfs_itobp: "
326                                 "xfs_trans_read_buf() returned error %d, "
327                                 "imap.im_blkno 0x%llx, imap.im_len 0x%llx",
328                                 error, (unsigned long long) imap.im_blkno,
329                                 (unsigned long long) imap.im_len);
330 #endif /* DEBUG */
331                 return error;
332         }
333 #ifdef __KERNEL__
334         /*
335          * Validate the magic number and version of every inode in the buffer
336          * (if DEBUG kernel) or the first inode in the buffer, otherwise.
337          */
338 #ifdef DEBUG
339         ni = (imap_flags & XFS_IMAP_BULKSTAT) ? 0 :
340                 (BBTOB(imap.im_len) >> mp->m_sb.sb_inodelog);
341 #else
342         ni = (imap_flags & XFS_IMAP_BULKSTAT) ? 0 : 1;
343 #endif
344         for (i = 0; i < ni; i++) {
345                 int             di_ok;
346                 xfs_dinode_t    *dip;
347
348                 dip = (xfs_dinode_t *)xfs_buf_offset(bp,
349                                         (i << mp->m_sb.sb_inodelog));
350                 di_ok = INT_GET(dip->di_core.di_magic, ARCH_CONVERT) == XFS_DINODE_MAGIC &&
351                             XFS_DINODE_GOOD_VERSION(INT_GET(dip->di_core.di_version, ARCH_CONVERT));
352                 if (unlikely(XFS_TEST_ERROR(!di_ok, mp, XFS_ERRTAG_ITOBP_INOTOBP,
353                                  XFS_RANDOM_ITOBP_INOTOBP))) {
354 #ifdef DEBUG
355                         prdev("bad inode magic/vsn daddr %lld #%d (magic=%x)",
356                                 mp->m_ddev_targp,
357                                 (unsigned long long)imap.im_blkno, i,
358                                 INT_GET(dip->di_core.di_magic, ARCH_CONVERT));
359 #endif
360                         XFS_CORRUPTION_ERROR("xfs_itobp", XFS_ERRLEVEL_HIGH,
361                                              mp, dip);
362                         xfs_trans_brelse(tp, bp);
363                         return XFS_ERROR(EFSCORRUPTED);
364                 }
365         }
366 #endif  /* __KERNEL__ */
367
368         xfs_inobp_check(mp, bp);
369
370         /*
371          * Mark the buffer as an inode buffer now that it looks good
372          */
373         XFS_BUF_SET_VTYPE(bp, B_FS_INO);
374
375         /*
376          * Set *dipp to point to the on-disk inode in the buffer.
377          */
378         *dipp = (xfs_dinode_t *)xfs_buf_offset(bp, imap.im_boffset);
379         *bpp = bp;
380         return 0;
381 }
382
383 /*
384  * Move inode type and inode format specific information from the
385  * on-disk inode to the in-core inode.  For fifos, devs, and sockets
386  * this means set if_rdev to the proper value.  For files, directories,
387  * and symlinks this means to bring in the in-line data or extent
388  * pointers.  For a file in B-tree format, only the root is immediately
389  * brought in-core.  The rest will be in-lined in if_extents when it
390  * is first referenced (see xfs_iread_extents()).
391  */
392 STATIC int
393 xfs_iformat(
394         xfs_inode_t             *ip,
395         xfs_dinode_t            *dip)
396 {
397         xfs_attr_shortform_t    *atp;
398         int                     size;
399         int                     error;
400         xfs_fsize_t             di_size;
401         ip->i_df.if_ext_max =
402                 XFS_IFORK_DSIZE(ip) / (uint)sizeof(xfs_bmbt_rec_t);
403         error = 0;
404
405         if (unlikely(
406             INT_GET(dip->di_core.di_nextents, ARCH_CONVERT) +
407                 INT_GET(dip->di_core.di_anextents, ARCH_CONVERT) >
408             INT_GET(dip->di_core.di_nblocks, ARCH_CONVERT))) {
409                 xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
410                         "corrupt dinode %Lu, extent total = %d, nblocks = %Lu.",
411                         (unsigned long long)ip->i_ino,
412                         (int)(INT_GET(dip->di_core.di_nextents, ARCH_CONVERT)
413                             + INT_GET(dip->di_core.di_anextents, ARCH_CONVERT)),
414                         (unsigned long long)
415                         INT_GET(dip->di_core.di_nblocks, ARCH_CONVERT));
416                 XFS_CORRUPTION_ERROR("xfs_iformat(1)", XFS_ERRLEVEL_LOW,
417                                      ip->i_mount, dip);
418                 return XFS_ERROR(EFSCORRUPTED);
419         }
420
421         if (unlikely(INT_GET(dip->di_core.di_forkoff, ARCH_CONVERT) > ip->i_mount->m_sb.sb_inodesize)) {
422                 xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
423                         "corrupt dinode %Lu, forkoff = 0x%x.",
424                         (unsigned long long)ip->i_ino,
425                         (int)(INT_GET(dip->di_core.di_forkoff, ARCH_CONVERT)));
426                 XFS_CORRUPTION_ERROR("xfs_iformat(2)", XFS_ERRLEVEL_LOW,
427                                      ip->i_mount, dip);
428                 return XFS_ERROR(EFSCORRUPTED);
429         }
430
431         switch (ip->i_d.di_mode & S_IFMT) {
432         case S_IFIFO:
433         case S_IFCHR:
434         case S_IFBLK:
435         case S_IFSOCK:
436                 if (unlikely(INT_GET(dip->di_core.di_format, ARCH_CONVERT) != XFS_DINODE_FMT_DEV)) {
437                         XFS_CORRUPTION_ERROR("xfs_iformat(3)", XFS_ERRLEVEL_LOW,
438                                               ip->i_mount, dip);
439                         return XFS_ERROR(EFSCORRUPTED);
440                 }
441                 ip->i_d.di_size = 0;
442                 ip->i_df.if_u2.if_rdev = INT_GET(dip->di_u.di_dev, ARCH_CONVERT);
443                 break;
444
445         case S_IFREG:
446         case S_IFLNK:
447         case S_IFDIR:
448                 switch (INT_GET(dip->di_core.di_format, ARCH_CONVERT)) {
449                 case XFS_DINODE_FMT_LOCAL:
450                         /*
451                          * no local regular files yet
452                          */
453                         if (unlikely((INT_GET(dip->di_core.di_mode, ARCH_CONVERT) & S_IFMT) == S_IFREG)) {
454                                 xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
455                                         "corrupt inode %Lu "
456                                         "(local format for regular file).",
457                                         (unsigned long long) ip->i_ino);
458                                 XFS_CORRUPTION_ERROR("xfs_iformat(4)",
459                                                      XFS_ERRLEVEL_LOW,
460                                                      ip->i_mount, dip);
461                                 return XFS_ERROR(EFSCORRUPTED);
462                         }
463
464                         di_size = INT_GET(dip->di_core.di_size, ARCH_CONVERT);
465                         if (unlikely(di_size > XFS_DFORK_DSIZE(dip, ip->i_mount))) {
466                                 xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
467                                         "corrupt inode %Lu "
468                                         "(bad size %Ld for local inode).",
469                                         (unsigned long long) ip->i_ino,
470                                         (long long) di_size);
471                                 XFS_CORRUPTION_ERROR("xfs_iformat(5)",
472                                                      XFS_ERRLEVEL_LOW,
473                                                      ip->i_mount, dip);
474                                 return XFS_ERROR(EFSCORRUPTED);
475                         }
476
477                         size = (int)di_size;
478                         error = xfs_iformat_local(ip, dip, XFS_DATA_FORK, size);
479                         break;
480                 case XFS_DINODE_FMT_EXTENTS:
481                         error = xfs_iformat_extents(ip, dip, XFS_DATA_FORK);
482                         break;
483                 case XFS_DINODE_FMT_BTREE:
484                         error = xfs_iformat_btree(ip, dip, XFS_DATA_FORK);
485                         break;
486                 default:
487                         XFS_ERROR_REPORT("xfs_iformat(6)", XFS_ERRLEVEL_LOW,
488                                          ip->i_mount);
489                         return XFS_ERROR(EFSCORRUPTED);
490                 }
491                 break;
492
493         default:
494                 XFS_ERROR_REPORT("xfs_iformat(7)", XFS_ERRLEVEL_LOW, ip->i_mount);
495                 return XFS_ERROR(EFSCORRUPTED);
496         }
497         if (error) {
498                 return error;
499         }
500         if (!XFS_DFORK_Q(dip))
501                 return 0;
502         ASSERT(ip->i_afp == NULL);
503         ip->i_afp = kmem_zone_zalloc(xfs_ifork_zone, KM_SLEEP);
504         ip->i_afp->if_ext_max =
505                 XFS_IFORK_ASIZE(ip) / (uint)sizeof(xfs_bmbt_rec_t);
506         switch (INT_GET(dip->di_core.di_aformat, ARCH_CONVERT)) {
507         case XFS_DINODE_FMT_LOCAL:
508                 atp = (xfs_attr_shortform_t *)XFS_DFORK_APTR(dip);
509                 size = be16_to_cpu(atp->hdr.totsize);
510                 error = xfs_iformat_local(ip, dip, XFS_ATTR_FORK, size);
511                 break;
512         case XFS_DINODE_FMT_EXTENTS:
513                 error = xfs_iformat_extents(ip, dip, XFS_ATTR_FORK);
514                 break;
515         case XFS_DINODE_FMT_BTREE:
516                 error = xfs_iformat_btree(ip, dip, XFS_ATTR_FORK);
517                 break;
518         default:
519                 error = XFS_ERROR(EFSCORRUPTED);
520                 break;
521         }
522         if (error) {
523                 kmem_zone_free(xfs_ifork_zone, ip->i_afp);
524                 ip->i_afp = NULL;
525                 xfs_idestroy_fork(ip, XFS_DATA_FORK);
526         }
527         return error;
528 }
529
530 /*
531  * The file is in-lined in the on-disk inode.
532  * If it fits into if_inline_data, then copy
533  * it there, otherwise allocate a buffer for it
534  * and copy the data there.  Either way, set
535  * if_data to point at the data.
536  * If we allocate a buffer for the data, make
537  * sure that its size is a multiple of 4 and
538  * record the real size in i_real_bytes.
539  */
540 STATIC int
541 xfs_iformat_local(
542         xfs_inode_t     *ip,
543         xfs_dinode_t    *dip,
544         int             whichfork,
545         int             size)
546 {
547         xfs_ifork_t     *ifp;
548         int             real_size;
549
550         /*
551          * If the size is unreasonable, then something
552          * is wrong and we just bail out rather than crash in
553          * kmem_alloc() or memcpy() below.
554          */
555         if (unlikely(size > XFS_DFORK_SIZE(dip, ip->i_mount, whichfork))) {
556                 xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
557                         "corrupt inode %Lu "
558                         "(bad size %d for local fork, size = %d).",
559                         (unsigned long long) ip->i_ino, size,
560                         XFS_DFORK_SIZE(dip, ip->i_mount, whichfork));
561                 XFS_CORRUPTION_ERROR("xfs_iformat_local", XFS_ERRLEVEL_LOW,
562                                      ip->i_mount, dip);
563                 return XFS_ERROR(EFSCORRUPTED);
564         }
565         ifp = XFS_IFORK_PTR(ip, whichfork);
566         real_size = 0;
567         if (size == 0)
568                 ifp->if_u1.if_data = NULL;
569         else if (size <= sizeof(ifp->if_u2.if_inline_data))
570                 ifp->if_u1.if_data = ifp->if_u2.if_inline_data;
571         else {
572                 real_size = roundup(size, 4);
573                 ifp->if_u1.if_data = kmem_alloc(real_size, KM_SLEEP);
574         }
575         ifp->if_bytes = size;
576         ifp->if_real_bytes = real_size;
577         if (size)
578                 memcpy(ifp->if_u1.if_data, XFS_DFORK_PTR(dip, whichfork), size);
579         ifp->if_flags &= ~XFS_IFEXTENTS;
580         ifp->if_flags |= XFS_IFINLINE;
581         return 0;
582 }
583
584 /*
585  * The file consists of a set of extents all
586  * of which fit into the on-disk inode.
587  * If there are few enough extents to fit into
588  * the if_inline_ext, then copy them there.
589  * Otherwise allocate a buffer for them and copy
590  * them into it.  Either way, set if_extents
591  * to point at the extents.
592  */
593 STATIC int
594 xfs_iformat_extents(
595         xfs_inode_t     *ip,
596         xfs_dinode_t    *dip,
597         int             whichfork)
598 {
599         xfs_bmbt_rec_t  *ep, *dp;
600         xfs_ifork_t     *ifp;
601         int             nex;
602         int             size;
603         int             i;
604
605         ifp = XFS_IFORK_PTR(ip, whichfork);
606         nex = XFS_DFORK_NEXTENTS(dip, whichfork);
607         size = nex * (uint)sizeof(xfs_bmbt_rec_t);
608
609         /*
610          * If the number of extents is unreasonable, then something
611          * is wrong and we just bail out rather than crash in
612          * kmem_alloc() or memcpy() below.
613          */
614         if (unlikely(size < 0 || size > XFS_DFORK_SIZE(dip, ip->i_mount, whichfork))) {
615                 xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
616                         "corrupt inode %Lu ((a)extents = %d).",
617                         (unsigned long long) ip->i_ino, nex);
618                 XFS_CORRUPTION_ERROR("xfs_iformat_extents(1)", XFS_ERRLEVEL_LOW,
619                                      ip->i_mount, dip);
620                 return XFS_ERROR(EFSCORRUPTED);
621         }
622
623         ifp->if_real_bytes = 0;
624         if (nex == 0)
625                 ifp->if_u1.if_extents = NULL;
626         else if (nex <= XFS_INLINE_EXTS)
627                 ifp->if_u1.if_extents = ifp->if_u2.if_inline_ext;
628         else
629                 xfs_iext_add(ifp, 0, nex);
630
631         ifp->if_bytes = size;
632         if (size) {
633                 dp = (xfs_bmbt_rec_t *) XFS_DFORK_PTR(dip, whichfork);
634                 xfs_validate_extents(ifp, nex, 1, XFS_EXTFMT_INODE(ip));
635                 for (i = 0; i < nex; i++, dp++) {
636                         ep = xfs_iext_get_ext(ifp, i);
637                         ep->l0 = INT_GET(get_unaligned((__uint64_t*)&dp->l0),
638                                                                 ARCH_CONVERT);
639                         ep->l1 = INT_GET(get_unaligned((__uint64_t*)&dp->l1),
640                                                                 ARCH_CONVERT);
641                 }
642                 xfs_bmap_trace_exlist("xfs_iformat_extents", ip, nex,
643                         whichfork);
644                 if (whichfork != XFS_DATA_FORK ||
645                         XFS_EXTFMT_INODE(ip) == XFS_EXTFMT_NOSTATE)
646                                 if (unlikely(xfs_check_nostate_extents(
647                                     ifp, 0, nex))) {
648                                         XFS_ERROR_REPORT("xfs_iformat_extents(2)",
649                                                          XFS_ERRLEVEL_LOW,
650                                                          ip->i_mount);
651                                         return XFS_ERROR(EFSCORRUPTED);
652                                 }
653         }
654         ifp->if_flags |= XFS_IFEXTENTS;
655         return 0;
656 }
657
658 /*
659  * The file has too many extents to fit into
660  * the inode, so they are in B-tree format.
661  * Allocate a buffer for the root of the B-tree
662  * and copy the root into it.  The i_extents
663  * field will remain NULL until all of the
664  * extents are read in (when they are needed).
665  */
666 STATIC int
667 xfs_iformat_btree(
668         xfs_inode_t             *ip,
669         xfs_dinode_t            *dip,
670         int                     whichfork)
671 {
672         xfs_bmdr_block_t        *dfp;
673         xfs_ifork_t             *ifp;
674         /* REFERENCED */
675         int                     nrecs;
676         int                     size;
677
678         ifp = XFS_IFORK_PTR(ip, whichfork);
679         dfp = (xfs_bmdr_block_t *)XFS_DFORK_PTR(dip, whichfork);
680         size = XFS_BMAP_BROOT_SPACE(dfp);
681         nrecs = XFS_BMAP_BROOT_NUMRECS(dfp);
682
683         /*
684          * blow out if -- fork has less extents than can fit in
685          * fork (fork shouldn't be a btree format), root btree
686          * block has more records than can fit into the fork,
687          * or the number of extents is greater than the number of
688          * blocks.
689          */
690         if (unlikely(XFS_IFORK_NEXTENTS(ip, whichfork) <= ifp->if_ext_max
691             || XFS_BMDR_SPACE_CALC(nrecs) >
692                         XFS_DFORK_SIZE(dip, ip->i_mount, whichfork)
693             || XFS_IFORK_NEXTENTS(ip, whichfork) > ip->i_d.di_nblocks)) {
694                 xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
695                         "corrupt inode %Lu (btree).",
696                         (unsigned long long) ip->i_ino);
697                 XFS_ERROR_REPORT("xfs_iformat_btree", XFS_ERRLEVEL_LOW,
698                                  ip->i_mount);
699                 return XFS_ERROR(EFSCORRUPTED);
700         }
701
702         ifp->if_broot_bytes = size;
703         ifp->if_broot = kmem_alloc(size, KM_SLEEP);
704         ASSERT(ifp->if_broot != NULL);
705         /*
706          * Copy and convert from the on-disk structure
707          * to the in-memory structure.
708          */
709         xfs_bmdr_to_bmbt(dfp, XFS_DFORK_SIZE(dip, ip->i_mount, whichfork),
710                 ifp->if_broot, size);
711         ifp->if_flags &= ~XFS_IFEXTENTS;
712         ifp->if_flags |= XFS_IFBROOT;
713
714         return 0;
715 }
716
717 /*
718  * xfs_xlate_dinode_core - translate an xfs_inode_core_t between ondisk
719  * and native format
720  *
721  * buf  = on-disk representation
722  * dip  = native representation
723  * dir  = direction - +ve -> disk to native
724  *                    -ve -> native to disk
725  */
726 void
727 xfs_xlate_dinode_core(
728         xfs_caddr_t             buf,
729         xfs_dinode_core_t       *dip,
730         int                     dir)
731 {
732         xfs_dinode_core_t       *buf_core = (xfs_dinode_core_t *)buf;
733         xfs_dinode_core_t       *mem_core = (xfs_dinode_core_t *)dip;
734         xfs_arch_t              arch = ARCH_CONVERT;
735
736         ASSERT(dir);
737
738         INT_XLATE(buf_core->di_magic, mem_core->di_magic, dir, arch);
739         INT_XLATE(buf_core->di_mode, mem_core->di_mode, dir, arch);
740         INT_XLATE(buf_core->di_version, mem_core->di_version, dir, arch);
741         INT_XLATE(buf_core->di_format, mem_core->di_format, dir, arch);
742         INT_XLATE(buf_core->di_onlink, mem_core->di_onlink, dir, arch);
743         INT_XLATE(buf_core->di_uid, mem_core->di_uid, dir, arch);
744         INT_XLATE(buf_core->di_gid, mem_core->di_gid, dir, arch);
745         INT_XLATE(buf_core->di_nlink, mem_core->di_nlink, dir, arch);
746         INT_XLATE(buf_core->di_projid, mem_core->di_projid, dir, arch);
747
748         if (dir > 0) {
749                 memcpy(mem_core->di_pad, buf_core->di_pad,
750                         sizeof(buf_core->di_pad));
751         } else {
752                 memcpy(buf_core->di_pad, mem_core->di_pad,
753                         sizeof(buf_core->di_pad));
754         }
755
756         INT_XLATE(buf_core->di_flushiter, mem_core->di_flushiter, dir, arch);
757
758         INT_XLATE(buf_core->di_atime.t_sec, mem_core->di_atime.t_sec,
759                         dir, arch);
760         INT_XLATE(buf_core->di_atime.t_nsec, mem_core->di_atime.t_nsec,
761                         dir, arch);
762         INT_XLATE(buf_core->di_mtime.t_sec, mem_core->di_mtime.t_sec,
763                         dir, arch);
764         INT_XLATE(buf_core->di_mtime.t_nsec, mem_core->di_mtime.t_nsec,
765                         dir, arch);
766         INT_XLATE(buf_core->di_ctime.t_sec, mem_core->di_ctime.t_sec,
767                         dir, arch);
768         INT_XLATE(buf_core->di_ctime.t_nsec, mem_core->di_ctime.t_nsec,
769                         dir, arch);
770         INT_XLATE(buf_core->di_size, mem_core->di_size, dir, arch);
771         INT_XLATE(buf_core->di_nblocks, mem_core->di_nblocks, dir, arch);
772         INT_XLATE(buf_core->di_extsize, mem_core->di_extsize, dir, arch);
773         INT_XLATE(buf_core->di_nextents, mem_core->di_nextents, dir, arch);
774         INT_XLATE(buf_core->di_anextents, mem_core->di_anextents, dir, arch);
775         INT_XLATE(buf_core->di_forkoff, mem_core->di_forkoff, dir, arch);
776         INT_XLATE(buf_core->di_aformat, mem_core->di_aformat, dir, arch);
777         INT_XLATE(buf_core->di_dmevmask, mem_core->di_dmevmask, dir, arch);
778         INT_XLATE(buf_core->di_dmstate, mem_core->di_dmstate, dir, arch);
779         INT_XLATE(buf_core->di_flags, mem_core->di_flags, dir, arch);
780         INT_XLATE(buf_core->di_gen, mem_core->di_gen, dir, arch);
781 }
782
783 STATIC uint
784 _xfs_dic2xflags(
785         xfs_dinode_core_t       *dic,
786         __uint16_t              di_flags)
787 {
788         uint                    flags = 0;
789
790         if (di_flags & XFS_DIFLAG_ANY) {
791                 if (di_flags & XFS_DIFLAG_REALTIME)
792                         flags |= XFS_XFLAG_REALTIME;
793                 if (di_flags & XFS_DIFLAG_PREALLOC)
794                         flags |= XFS_XFLAG_PREALLOC;
795                 if (di_flags & XFS_DIFLAG_IMMUTABLE)
796                         flags |= XFS_XFLAG_IMMUTABLE;
797                 if (di_flags & XFS_DIFLAG_APPEND)
798                         flags |= XFS_XFLAG_APPEND;
799                 if (di_flags & XFS_DIFLAG_SYNC)
800                         flags |= XFS_XFLAG_SYNC;
801                 if (di_flags & XFS_DIFLAG_NOATIME)
802                         flags |= XFS_XFLAG_NOATIME;
803                 if (di_flags & XFS_DIFLAG_NODUMP)
804                         flags |= XFS_XFLAG_NODUMP;
805                 if (di_flags & XFS_DIFLAG_RTINHERIT)
806                         flags |= XFS_XFLAG_RTINHERIT;
807                 if (di_flags & XFS_DIFLAG_PROJINHERIT)
808                         flags |= XFS_XFLAG_PROJINHERIT;
809                 if (di_flags & XFS_DIFLAG_NOSYMLINKS)
810                         flags |= XFS_XFLAG_NOSYMLINKS;
811                 if (di_flags & XFS_DIFLAG_EXTSIZE)
812                         flags |= XFS_XFLAG_EXTSIZE;
813                 if (di_flags & XFS_DIFLAG_EXTSZINHERIT)
814                         flags |= XFS_XFLAG_EXTSZINHERIT;
815         }
816
817         return flags;
818 }
819
820 uint
821 xfs_ip2xflags(
822         xfs_inode_t             *ip)
823 {
824         xfs_dinode_core_t       *dic = &ip->i_d;
825
826         return _xfs_dic2xflags(dic, dic->di_flags) |
827                 (XFS_CFORK_Q(dic) ? XFS_XFLAG_HASATTR : 0);
828 }
829
830 uint
831 xfs_dic2xflags(
832         xfs_dinode_core_t       *dic)
833 {
834         return _xfs_dic2xflags(dic, INT_GET(dic->di_flags, ARCH_CONVERT)) |
835                 (XFS_CFORK_Q_DISK(dic) ? XFS_XFLAG_HASATTR : 0);
836 }
837
838 /*
839  * Given a mount structure and an inode number, return a pointer
840  * to a newly allocated in-core inode corresponding to the given
841  * inode number.
842  *
843  * Initialize the inode's attributes and extent pointers if it
844  * already has them (it will not if the inode has no links).
845  */
846 int
847 xfs_iread(
848         xfs_mount_t     *mp,
849         xfs_trans_t     *tp,
850         xfs_ino_t       ino,
851         xfs_inode_t     **ipp,
852         xfs_daddr_t     bno)
853 {
854         xfs_buf_t       *bp;
855         xfs_dinode_t    *dip;
856         xfs_inode_t     *ip;
857         int             error;
858
859         ASSERT(xfs_inode_zone != NULL);
860
861         ip = kmem_zone_zalloc(xfs_inode_zone, KM_SLEEP);
862         ip->i_ino = ino;
863         ip->i_mount = mp;
864
865         /*
866          * Get pointer's to the on-disk inode and the buffer containing it.
867          * If the inode number refers to a block outside the file system
868          * then xfs_itobp() will return NULL.  In this case we should
869          * return NULL as well.  Set i_blkno to 0 so that xfs_itobp() will
870          * know that this is a new incore inode.
871          */
872         error = xfs_itobp(mp, tp, ip, &dip, &bp, bno, 0);
873         if (error) {
874                 kmem_zone_free(xfs_inode_zone, ip);
875                 return error;
876         }
877
878         /*
879          * Initialize inode's trace buffers.
880          * Do this before xfs_iformat in case it adds entries.
881          */
882 #ifdef XFS_BMAP_TRACE
883         ip->i_xtrace = ktrace_alloc(XFS_BMAP_KTRACE_SIZE, KM_SLEEP);
884 #endif
885 #ifdef XFS_BMBT_TRACE
886         ip->i_btrace = ktrace_alloc(XFS_BMBT_KTRACE_SIZE, KM_SLEEP);
887 #endif
888 #ifdef XFS_RW_TRACE
889         ip->i_rwtrace = ktrace_alloc(XFS_RW_KTRACE_SIZE, KM_SLEEP);
890 #endif
891 #ifdef XFS_ILOCK_TRACE
892         ip->i_lock_trace = ktrace_alloc(XFS_ILOCK_KTRACE_SIZE, KM_SLEEP);
893 #endif
894 #ifdef XFS_DIR2_TRACE
895         ip->i_dir_trace = ktrace_alloc(XFS_DIR2_KTRACE_SIZE, KM_SLEEP);
896 #endif
897
898         /*
899          * If we got something that isn't an inode it means someone
900          * (nfs or dmi) has a stale handle.
901          */
902         if (INT_GET(dip->di_core.di_magic, ARCH_CONVERT) != XFS_DINODE_MAGIC) {
903                 kmem_zone_free(xfs_inode_zone, ip);
904                 xfs_trans_brelse(tp, bp);
905 #ifdef DEBUG
906                 xfs_fs_cmn_err(CE_ALERT, mp, "xfs_iread: "
907                                 "dip->di_core.di_magic (0x%x) != "
908                                 "XFS_DINODE_MAGIC (0x%x)",
909                                 INT_GET(dip->di_core.di_magic, ARCH_CONVERT),
910                                 XFS_DINODE_MAGIC);
911 #endif /* DEBUG */
912                 return XFS_ERROR(EINVAL);
913         }
914
915         /*
916          * If the on-disk inode is already linked to a directory
917          * entry, copy all of the inode into the in-core inode.
918          * xfs_iformat() handles copying in the inode format
919          * specific information.
920          * Otherwise, just get the truly permanent information.
921          */
922         if (dip->di_core.di_mode) {
923                 xfs_xlate_dinode_core((xfs_caddr_t)&dip->di_core,
924                      &(ip->i_d), 1);
925                 error = xfs_iformat(ip, dip);
926                 if (error)  {
927                         kmem_zone_free(xfs_inode_zone, ip);
928                         xfs_trans_brelse(tp, bp);
929 #ifdef DEBUG
930                         xfs_fs_cmn_err(CE_ALERT, mp, "xfs_iread: "
931                                         "xfs_iformat() returned error %d",
932                                         error);
933 #endif /* DEBUG */
934                         return error;
935                 }
936         } else {
937                 ip->i_d.di_magic = INT_GET(dip->di_core.di_magic, ARCH_CONVERT);
938                 ip->i_d.di_version = INT_GET(dip->di_core.di_version, ARCH_CONVERT);
939                 ip->i_d.di_gen = INT_GET(dip->di_core.di_gen, ARCH_CONVERT);
940                 ip->i_d.di_flushiter = INT_GET(dip->di_core.di_flushiter, ARCH_CONVERT);
941                 /*
942                  * Make sure to pull in the mode here as well in
943                  * case the inode is released without being used.
944                  * This ensures that xfs_inactive() will see that
945                  * the inode is already free and not try to mess
946                  * with the uninitialized part of it.
947                  */
948                 ip->i_d.di_mode = 0;
949                 /*
950                  * Initialize the per-fork minima and maxima for a new
951                  * inode here.  xfs_iformat will do it for old inodes.
952                  */
953                 ip->i_df.if_ext_max =
954                         XFS_IFORK_DSIZE(ip) / (uint)sizeof(xfs_bmbt_rec_t);
955         }
956
957         INIT_LIST_HEAD(&ip->i_reclaim);
958
959         /*
960          * The inode format changed when we moved the link count and
961          * made it 32 bits long.  If this is an old format inode,
962          * convert it in memory to look like a new one.  If it gets
963          * flushed to disk we will convert back before flushing or
964          * logging it.  We zero out the new projid field and the old link
965          * count field.  We'll handle clearing the pad field (the remains
966          * of the old uuid field) when we actually convert the inode to
967          * the new format. We don't change the version number so that we
968          * can distinguish this from a real new format inode.
969          */
970         if (ip->i_d.di_version == XFS_DINODE_VERSION_1) {
971                 ip->i_d.di_nlink = ip->i_d.di_onlink;
972                 ip->i_d.di_onlink = 0;
973                 ip->i_d.di_projid = 0;
974         }
975
976         ip->i_delayed_blks = 0;
977
978         /*
979          * Mark the buffer containing the inode as something to keep
980          * around for a while.  This helps to keep recently accessed
981          * meta-data in-core longer.
982          */
983          XFS_BUF_SET_REF(bp, XFS_INO_REF);
984
985         /*
986          * Use xfs_trans_brelse() to release the buffer containing the
987          * on-disk inode, because it was acquired with xfs_trans_read_buf()
988          * in xfs_itobp() above.  If tp is NULL, this is just a normal
989          * brelse().  If we're within a transaction, then xfs_trans_brelse()
990          * will only release the buffer if it is not dirty within the
991          * transaction.  It will be OK to release the buffer in this case,
992          * because inodes on disk are never destroyed and we will be
993          * locking the new in-core inode before putting it in the hash
994          * table where other processes can find it.  Thus we don't have
995          * to worry about the inode being changed just because we released
996          * the buffer.
997          */
998         xfs_trans_brelse(tp, bp);
999         *ipp = ip;
1000         return 0;
1001 }
1002
1003 /*
1004  * Read in extents from a btree-format inode.
1005  * Allocate and fill in if_extents.  Real work is done in xfs_bmap.c.
1006  */
1007 int
1008 xfs_iread_extents(
1009         xfs_trans_t     *tp,
1010         xfs_inode_t     *ip,
1011         int             whichfork)
1012 {
1013         int             error;
1014         xfs_ifork_t     *ifp;
1015         xfs_extnum_t    nextents;
1016         size_t          size;
1017
1018         if (unlikely(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE)) {
1019                 XFS_ERROR_REPORT("xfs_iread_extents", XFS_ERRLEVEL_LOW,
1020                                  ip->i_mount);
1021                 return XFS_ERROR(EFSCORRUPTED);
1022         }
1023         nextents = XFS_IFORK_NEXTENTS(ip, whichfork);
1024         size = nextents * sizeof(xfs_bmbt_rec_t);
1025         ifp = XFS_IFORK_PTR(ip, whichfork);
1026
1027         /*
1028          * We know that the size is valid (it's checked in iformat_btree)
1029          */
1030         ifp->if_lastex = NULLEXTNUM;
1031         ifp->if_bytes = ifp->if_real_bytes = 0;
1032         ifp->if_flags |= XFS_IFEXTENTS;
1033         xfs_iext_add(ifp, 0, nextents);
1034         error = xfs_bmap_read_extents(tp, ip, whichfork);
1035         if (error) {
1036                 xfs_iext_destroy(ifp);
1037                 ifp->if_flags &= ~XFS_IFEXTENTS;
1038                 return error;
1039         }
1040         xfs_validate_extents(ifp, nextents, 0, XFS_EXTFMT_INODE(ip));
1041         return 0;
1042 }
1043
1044 /*
1045  * Allocate an inode on disk and return a copy of its in-core version.
1046  * The in-core inode is locked exclusively.  Set mode, nlink, and rdev
1047  * appropriately within the inode.  The uid and gid for the inode are
1048  * set according to the contents of the given cred structure.
1049  *
1050  * Use xfs_dialloc() to allocate the on-disk inode. If xfs_dialloc()
1051  * has a free inode available, call xfs_iget()
1052  * to obtain the in-core version of the allocated inode.  Finally,
1053  * fill in the inode and log its initial contents.  In this case,
1054  * ialloc_context would be set to NULL and call_again set to false.
1055  *
1056  * If xfs_dialloc() does not have an available inode,
1057  * it will replenish its supply by doing an allocation. Since we can
1058  * only do one allocation within a transaction without deadlocks, we
1059  * must commit the current transaction before returning the inode itself.
1060  * In this case, therefore, we will set call_again to true and return.
1061  * The caller should then commit the current transaction, start a new
1062  * transaction, and call xfs_ialloc() again to actually get the inode.
1063  *
1064  * To ensure that some other process does not grab the inode that
1065  * was allocated during the first call to xfs_ialloc(), this routine
1066  * also returns the [locked] bp pointing to the head of the freelist
1067  * as ialloc_context.  The caller should hold this buffer across
1068  * the commit and pass it back into this routine on the second call.
1069  */
1070 int
1071 xfs_ialloc(
1072         xfs_trans_t     *tp,
1073         xfs_inode_t     *pip,
1074         mode_t          mode,
1075         xfs_nlink_t     nlink,
1076         xfs_dev_t       rdev,
1077         cred_t          *cr,
1078         xfs_prid_t      prid,
1079         int             okalloc,
1080         xfs_buf_t       **ialloc_context,
1081         boolean_t       *call_again,
1082         xfs_inode_t     **ipp)
1083 {
1084         xfs_ino_t       ino;
1085         xfs_inode_t     *ip;
1086         vnode_t         *vp;
1087         uint            flags;
1088         int             error;
1089
1090         /*
1091          * Call the space management code to pick
1092          * the on-disk inode to be allocated.
1093          */
1094         error = xfs_dialloc(tp, pip->i_ino, mode, okalloc,
1095                             ialloc_context, call_again, &ino);
1096         if (error != 0) {
1097                 return error;
1098         }
1099         if (*call_again || ino == NULLFSINO) {
1100                 *ipp = NULL;
1101                 return 0;
1102         }
1103         ASSERT(*ialloc_context == NULL);
1104
1105         /*
1106          * Get the in-core inode with the lock held exclusively.
1107          * This is because we're setting fields here we need
1108          * to prevent others from looking at until we're done.
1109          */
1110         error = xfs_trans_iget(tp->t_mountp, tp, ino,
1111                         IGET_CREATE, XFS_ILOCK_EXCL, &ip);
1112         if (error != 0) {
1113                 return error;
1114         }
1115         ASSERT(ip != NULL);
1116
1117         vp = XFS_ITOV(ip);
1118         ip->i_d.di_mode = (__uint16_t)mode;
1119         ip->i_d.di_onlink = 0;
1120         ip->i_d.di_nlink = nlink;
1121         ASSERT(ip->i_d.di_nlink == nlink);
1122         ip->i_d.di_uid = current_fsuid(cr);
1123         ip->i_d.di_gid = current_fsgid(cr);
1124         ip->i_d.di_projid = prid;
1125         memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad));
1126
1127         /*
1128          * If the superblock version is up to where we support new format
1129          * inodes and this is currently an old format inode, then change
1130          * the inode version number now.  This way we only do the conversion
1131          * here rather than here and in the flush/logging code.
1132          */
1133         if (XFS_SB_VERSION_HASNLINK(&tp->t_mountp->m_sb) &&
1134             ip->i_d.di_version == XFS_DINODE_VERSION_1) {
1135                 ip->i_d.di_version = XFS_DINODE_VERSION_2;
1136                 /*
1137                  * We've already zeroed the old link count, the projid field,
1138                  * and the pad field.
1139                  */
1140         }
1141
1142         /*
1143          * Project ids won't be stored on disk if we are using a version 1 inode.
1144          */
1145         if ( (prid != 0) && (ip->i_d.di_version == XFS_DINODE_VERSION_1))
1146                 xfs_bump_ino_vers2(tp, ip);
1147
1148         if (XFS_INHERIT_GID(pip, vp->v_vfsp)) {
1149                 ip->i_d.di_gid = pip->i_d.di_gid;
1150                 if ((pip->i_d.di_mode & S_ISGID) && (mode & S_IFMT) == S_IFDIR) {
1151                         ip->i_d.di_mode |= S_ISGID;
1152                 }
1153         }
1154
1155         /*
1156          * If the group ID of the new file does not match the effective group
1157          * ID or one of the supplementary group IDs, the S_ISGID bit is cleared
1158          * (and only if the irix_sgid_inherit compatibility variable is set).
1159          */
1160         if ((irix_sgid_inherit) &&
1161             (ip->i_d.di_mode & S_ISGID) &&
1162             (!in_group_p((gid_t)ip->i_d.di_gid))) {
1163                 ip->i_d.di_mode &= ~S_ISGID;
1164         }
1165
1166         ip->i_d.di_size = 0;
1167         ip->i_d.di_nextents = 0;
1168         ASSERT(ip->i_d.di_nblocks == 0);
1169         xfs_ichgtime(ip, XFS_ICHGTIME_CHG|XFS_ICHGTIME_ACC|XFS_ICHGTIME_MOD);
1170         /*
1171          * di_gen will have been taken care of in xfs_iread.
1172          */
1173         ip->i_d.di_extsize = 0;
1174         ip->i_d.di_dmevmask = 0;
1175         ip->i_d.di_dmstate = 0;
1176         ip->i_d.di_flags = 0;
1177         flags = XFS_ILOG_CORE;
1178         switch (mode & S_IFMT) {
1179         case S_IFIFO:
1180         case S_IFCHR:
1181         case S_IFBLK:
1182         case S_IFSOCK:
1183                 ip->i_d.di_format = XFS_DINODE_FMT_DEV;
1184                 ip->i_df.if_u2.if_rdev = rdev;
1185                 ip->i_df.if_flags = 0;
1186                 flags |= XFS_ILOG_DEV;
1187                 break;
1188         case S_IFREG:
1189         case S_IFDIR:
1190                 if (unlikely(pip->i_d.di_flags & XFS_DIFLAG_ANY)) {
1191                         uint    di_flags = 0;
1192
1193                         if ((mode & S_IFMT) == S_IFDIR) {
1194                                 if (pip->i_d.di_flags & XFS_DIFLAG_RTINHERIT)
1195                                         di_flags |= XFS_DIFLAG_RTINHERIT;
1196                                 if (pip->i_d.di_flags & XFS_DIFLAG_EXTSZINHERIT) {
1197                                         di_flags |= XFS_DIFLAG_EXTSZINHERIT;
1198                                         ip->i_d.di_extsize = pip->i_d.di_extsize;
1199                                 }
1200                         } else if ((mode & S_IFMT) == S_IFREG) {
1201                                 if (pip->i_d.di_flags & XFS_DIFLAG_RTINHERIT) {
1202                                         di_flags |= XFS_DIFLAG_REALTIME;
1203                                         ip->i_iocore.io_flags |= XFS_IOCORE_RT;
1204                                 }
1205                                 if (pip->i_d.di_flags & XFS_DIFLAG_EXTSZINHERIT) {
1206                                         di_flags |= XFS_DIFLAG_EXTSIZE;
1207                                         ip->i_d.di_extsize = pip->i_d.di_extsize;
1208                                 }
1209                         }
1210                         if ((pip->i_d.di_flags & XFS_DIFLAG_NOATIME) &&
1211                             xfs_inherit_noatime)
1212                                 di_flags |= XFS_DIFLAG_NOATIME;
1213                         if ((pip->i_d.di_flags & XFS_DIFLAG_NODUMP) &&
1214                             xfs_inherit_nodump)
1215                                 di_flags |= XFS_DIFLAG_NODUMP;
1216                         if ((pip->i_d.di_flags & XFS_DIFLAG_SYNC) &&
1217                             xfs_inherit_sync)
1218                                 di_flags |= XFS_DIFLAG_SYNC;
1219                         if ((pip->i_d.di_flags & XFS_DIFLAG_NOSYMLINKS) &&
1220                             xfs_inherit_nosymlinks)
1221                                 di_flags |= XFS_DIFLAG_NOSYMLINKS;
1222                         if (pip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
1223                                 di_flags |= XFS_DIFLAG_PROJINHERIT;
1224                         ip->i_d.di_flags |= di_flags;
1225                 }
1226                 /* FALLTHROUGH */
1227         case S_IFLNK:
1228                 ip->i_d.di_format = XFS_DINODE_FMT_EXTENTS;
1229                 ip->i_df.if_flags = XFS_IFEXTENTS;
1230                 ip->i_df.if_bytes = ip->i_df.if_real_bytes = 0;
1231                 ip->i_df.if_u1.if_extents = NULL;
1232                 break;
1233         default:
1234                 ASSERT(0);
1235         }
1236         /*
1237          * Attribute fork settings for new inode.
1238          */
1239         ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
1240         ip->i_d.di_anextents = 0;
1241
1242         /*
1243          * Log the new values stuffed into the inode.
1244          */
1245         xfs_trans_log_inode(tp, ip, flags);
1246
1247         /* now that we have an i_mode  we can set Linux inode ops (& unlock) */
1248         VFS_INIT_VNODE(XFS_MTOVFS(tp->t_mountp), vp, XFS_ITOBHV(ip), 1);
1249
1250         *ipp = ip;
1251         return 0;
1252 }
1253
1254 /*
1255  * Check to make sure that there are no blocks allocated to the
1256  * file beyond the size of the file.  We don't check this for
1257  * files with fixed size extents or real time extents, but we
1258  * at least do it for regular files.
1259  */
1260 #ifdef DEBUG
1261 void
1262 xfs_isize_check(
1263         xfs_mount_t     *mp,
1264         xfs_inode_t     *ip,
1265         xfs_fsize_t     isize)
1266 {
1267         xfs_fileoff_t   map_first;
1268         int             nimaps;
1269         xfs_bmbt_irec_t imaps[2];
1270
1271         if ((ip->i_d.di_mode & S_IFMT) != S_IFREG)
1272                 return;
1273
1274         if (ip->i_d.di_flags & (XFS_DIFLAG_REALTIME | XFS_DIFLAG_EXTSIZE))
1275                 return;
1276
1277         nimaps = 2;
1278         map_first = XFS_B_TO_FSB(mp, (xfs_ufsize_t)isize);
1279         /*
1280          * The filesystem could be shutting down, so bmapi may return
1281          * an error.
1282          */
1283         if (xfs_bmapi(NULL, ip, map_first,
1284                          (XFS_B_TO_FSB(mp,
1285                                        (xfs_ufsize_t)XFS_MAXIOFFSET(mp)) -
1286                           map_first),
1287                          XFS_BMAPI_ENTIRE, NULL, 0, imaps, &nimaps,
1288                          NULL))
1289             return;
1290         ASSERT(nimaps == 1);
1291         ASSERT(imaps[0].br_startblock == HOLESTARTBLOCK);
1292 }
1293 #endif  /* DEBUG */
1294
1295 /*
1296  * Calculate the last possible buffered byte in a file.  This must
1297  * include data that was buffered beyond the EOF by the write code.
1298  * This also needs to deal with overflowing the xfs_fsize_t type
1299  * which can happen for sizes near the limit.
1300  *
1301  * We also need to take into account any blocks beyond the EOF.  It
1302  * may be the case that they were buffered by a write which failed.
1303  * In that case the pages will still be in memory, but the inode size
1304  * will never have been updated.
1305  */
1306 xfs_fsize_t
1307 xfs_file_last_byte(
1308         xfs_inode_t     *ip)
1309 {
1310         xfs_mount_t     *mp;
1311         xfs_fsize_t     last_byte;
1312         xfs_fileoff_t   last_block;
1313         xfs_fileoff_t   size_last_block;
1314         int             error;
1315
1316         ASSERT(ismrlocked(&(ip->i_iolock), MR_UPDATE | MR_ACCESS));
1317
1318         mp = ip->i_mount;
1319         /*
1320          * Only check for blocks beyond the EOF if the extents have
1321          * been read in.  This eliminates the need for the inode lock,
1322          * and it also saves us from looking when it really isn't
1323          * necessary.
1324          */
1325         if (ip->i_df.if_flags & XFS_IFEXTENTS) {
1326                 error = xfs_bmap_last_offset(NULL, ip, &last_block,
1327                         XFS_DATA_FORK);
1328                 if (error) {
1329                         last_block = 0;
1330                 }
1331         } else {
1332                 last_block = 0;
1333         }
1334         size_last_block = XFS_B_TO_FSB(mp, (xfs_ufsize_t)ip->i_d.di_size);
1335         last_block = XFS_FILEOFF_MAX(last_block, size_last_block);
1336
1337         last_byte = XFS_FSB_TO_B(mp, last_block);
1338         if (last_byte < 0) {
1339                 return XFS_MAXIOFFSET(mp);
1340         }
1341         last_byte += (1 << mp->m_writeio_log);
1342         if (last_byte < 0) {
1343                 return XFS_MAXIOFFSET(mp);
1344         }
1345         return last_byte;
1346 }
1347
1348 #if defined(XFS_RW_TRACE)
1349 STATIC void
1350 xfs_itrunc_trace(
1351         int             tag,
1352         xfs_inode_t     *ip,
1353         int             flag,
1354         xfs_fsize_t     new_size,
1355         xfs_off_t       toss_start,
1356         xfs_off_t       toss_finish)
1357 {
1358         if (ip->i_rwtrace == NULL) {
1359                 return;
1360         }
1361
1362         ktrace_enter(ip->i_rwtrace,
1363                      (void*)((long)tag),
1364                      (void*)ip,
1365                      (void*)(unsigned long)((ip->i_d.di_size >> 32) & 0xffffffff),
1366                      (void*)(unsigned long)(ip->i_d.di_size & 0xffffffff),
1367                      (void*)((long)flag),
1368                      (void*)(unsigned long)((new_size >> 32) & 0xffffffff),
1369                      (void*)(unsigned long)(new_size & 0xffffffff),
1370                      (void*)(unsigned long)((toss_start >> 32) & 0xffffffff),
1371                      (void*)(unsigned long)(toss_start & 0xffffffff),
1372                      (void*)(unsigned long)((toss_finish >> 32) & 0xffffffff),
1373                      (void*)(unsigned long)(toss_finish & 0xffffffff),
1374                      (void*)(unsigned long)current_cpu(),
1375                      (void*)(unsigned long)current_pid(),
1376                      (void*)NULL,
1377                      (void*)NULL,
1378                      (void*)NULL);
1379 }
1380 #else
1381 #define xfs_itrunc_trace(tag, ip, flag, new_size, toss_start, toss_finish)
1382 #endif
1383
1384 /*
1385  * Start the truncation of the file to new_size.  The new size
1386  * must be smaller than the current size.  This routine will
1387  * clear the buffer and page caches of file data in the removed
1388  * range, and xfs_itruncate_finish() will remove the underlying
1389  * disk blocks.
1390  *
1391  * The inode must have its I/O lock locked EXCLUSIVELY, and it
1392  * must NOT have the inode lock held at all.  This is because we're
1393  * calling into the buffer/page cache code and we can't hold the
1394  * inode lock when we do so.
1395  *
1396  * We need to wait for any direct I/Os in flight to complete before we
1397  * proceed with the truncate. This is needed to prevent the extents
1398  * being read or written by the direct I/Os from being removed while the
1399  * I/O is in flight as there is no other method of synchronising
1400  * direct I/O with the truncate operation.  Also, because we hold
1401  * the IOLOCK in exclusive mode, we prevent new direct I/Os from being
1402  * started until the truncate completes and drops the lock. Essentially,
1403  * the vn_iowait() call forms an I/O barrier that provides strict ordering
1404  * between direct I/Os and the truncate operation.
1405  *
1406  * The flags parameter can have either the value XFS_ITRUNC_DEFINITE
1407  * or XFS_ITRUNC_MAYBE.  The XFS_ITRUNC_MAYBE value should be used
1408  * in the case that the caller is locking things out of order and
1409  * may not be able to call xfs_itruncate_finish() with the inode lock
1410  * held without dropping the I/O lock.  If the caller must drop the
1411  * I/O lock before calling xfs_itruncate_finish(), then xfs_itruncate_start()
1412  * must be called again with all the same restrictions as the initial
1413  * call.
1414  */
1415 void
1416 xfs_itruncate_start(
1417         xfs_inode_t     *ip,
1418         uint            flags,
1419         xfs_fsize_t     new_size)
1420 {
1421         xfs_fsize_t     last_byte;
1422         xfs_off_t       toss_start;
1423         xfs_mount_t     *mp;
1424         vnode_t         *vp;
1425
1426         ASSERT(ismrlocked(&ip->i_iolock, MR_UPDATE) != 0);
1427         ASSERT((new_size == 0) || (new_size <= ip->i_d.di_size));
1428         ASSERT((flags == XFS_ITRUNC_DEFINITE) ||
1429                (flags == XFS_ITRUNC_MAYBE));
1430
1431         mp = ip->i_mount;
1432         vp = XFS_ITOV(ip);
1433
1434         vn_iowait(vp);  /* wait for the completion of any pending DIOs */
1435         
1436         /*
1437          * Call VOP_TOSS_PAGES() or VOP_FLUSHINVAL_PAGES() to get rid of pages and buffers
1438          * overlapping the region being removed.  We have to use
1439          * the less efficient VOP_FLUSHINVAL_PAGES() in the case that the
1440          * caller may not be able to finish the truncate without
1441          * dropping the inode's I/O lock.  Make sure
1442          * to catch any pages brought in by buffers overlapping
1443          * the EOF by searching out beyond the isize by our
1444          * block size. We round new_size up to a block boundary
1445          * so that we don't toss things on the same block as
1446          * new_size but before it.
1447          *
1448          * Before calling VOP_TOSS_PAGES() or VOP_FLUSHINVAL_PAGES(), make sure to
1449          * call remapf() over the same region if the file is mapped.
1450          * This frees up mapped file references to the pages in the
1451          * given range and for the VOP_FLUSHINVAL_PAGES() case it ensures
1452          * that we get the latest mapped changes flushed out.
1453          */
1454         toss_start = XFS_B_TO_FSB(mp, (xfs_ufsize_t)new_size);
1455         toss_start = XFS_FSB_TO_B(mp, toss_start);
1456         if (toss_start < 0) {
1457                 /*
1458                  * The place to start tossing is beyond our maximum
1459                  * file size, so there is no way that the data extended
1460                  * out there.
1461                  */
1462                 return;
1463         }
1464         last_byte = xfs_file_last_byte(ip);
1465         xfs_itrunc_trace(XFS_ITRUNC_START, ip, flags, new_size, toss_start,
1466                          last_byte);
1467         if (last_byte > toss_start) {
1468                 if (flags & XFS_ITRUNC_DEFINITE) {
1469                         VOP_TOSS_PAGES(vp, toss_start, -1, FI_REMAPF_LOCKED);
1470                 } else {
1471                         VOP_FLUSHINVAL_PAGES(vp, toss_start, -1, FI_REMAPF_LOCKED);
1472                 }
1473         }
1474
1475 #ifdef DEBUG
1476         if (new_size == 0) {
1477                 ASSERT(VN_CACHED(vp) == 0);
1478         }
1479 #endif
1480 }
1481
1482 /*
1483  * Shrink the file to the given new_size.  The new
1484  * size must be smaller than the current size.
1485  * This will free up the underlying blocks
1486  * in the removed range after a call to xfs_itruncate_start()
1487  * or xfs_atruncate_start().
1488  *
1489  * The transaction passed to this routine must have made
1490  * a permanent log reservation of at least XFS_ITRUNCATE_LOG_RES.
1491  * This routine may commit the given transaction and
1492  * start new ones, so make sure everything involved in
1493  * the transaction is tidy before calling here.
1494  * Some transaction will be returned to the caller to be
1495  * committed.  The incoming transaction must already include
1496  * the inode, and both inode locks must be held exclusively.
1497  * The inode must also be "held" within the transaction.  On
1498  * return the inode will be "held" within the returned transaction.
1499  * This routine does NOT require any disk space to be reserved
1500  * for it within the transaction.
1501  *
1502  * The fork parameter must be either xfs_attr_fork or xfs_data_fork,
1503  * and it indicates the fork which is to be truncated.  For the
1504  * attribute fork we only support truncation to size 0.
1505  *
1506  * We use the sync parameter to indicate whether or not the first
1507  * transaction we perform might have to be synchronous.  For the attr fork,
1508  * it needs to be so if the unlink of the inode is not yet known to be
1509  * permanent in the log.  This keeps us from freeing and reusing the
1510  * blocks of the attribute fork before the unlink of the inode becomes
1511  * permanent.
1512  *
1513  * For the data fork, we normally have to run synchronously if we're
1514  * being called out of the inactive path or we're being called
1515  * out of the create path where we're truncating an existing file.
1516  * Either way, the truncate needs to be sync so blocks don't reappear
1517  * in the file with altered data in case of a crash.  wsync filesystems
1518  * can run the first case async because anything that shrinks the inode
1519  * has to run sync so by the time we're called here from inactive, the
1520  * inode size is permanently set to 0.
1521  *
1522  * Calls from the truncate path always need to be sync unless we're
1523  * in a wsync filesystem and the file has already been unlinked.
1524  *
1525  * The caller is responsible for correctly setting the sync parameter.
1526  * It gets too hard for us to guess here which path we're being called
1527  * out of just based on inode state.
1528  */
1529 int
1530 xfs_itruncate_finish(
1531         xfs_trans_t     **tp,
1532         xfs_inode_t     *ip,
1533         xfs_fsize_t     new_size,
1534         int             fork,
1535         int             sync)
1536 {
1537         xfs_fsblock_t   first_block;
1538         xfs_fileoff_t   first_unmap_block;
1539         xfs_fileoff_t   last_block;
1540         xfs_filblks_t   unmap_len=0;
1541         xfs_mount_t     *mp;
1542         xfs_trans_t     *ntp;
1543         int             done;
1544         int             committed;
1545         xfs_bmap_free_t free_list;
1546         int             error;
1547
1548         ASSERT(ismrlocked(&ip->i_iolock, MR_UPDATE) != 0);
1549         ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE) != 0);
1550         ASSERT((new_size == 0) || (new_size <= ip->i_d.di_size));
1551         ASSERT(*tp != NULL);
1552         ASSERT((*tp)->t_flags & XFS_TRANS_PERM_LOG_RES);
1553         ASSERT(ip->i_transp == *tp);
1554         ASSERT(ip->i_itemp != NULL);
1555         ASSERT(ip->i_itemp->ili_flags & XFS_ILI_HOLD);
1556
1557
1558         ntp = *tp;
1559         mp = (ntp)->t_mountp;
1560         ASSERT(! XFS_NOT_DQATTACHED(mp, ip));
1561
1562         /*
1563          * We only support truncating the entire attribute fork.
1564          */
1565         if (fork == XFS_ATTR_FORK) {
1566                 new_size = 0LL;
1567         }
1568         first_unmap_block = XFS_B_TO_FSB(mp, (xfs_ufsize_t)new_size);
1569         xfs_itrunc_trace(XFS_ITRUNC_FINISH1, ip, 0, new_size, 0, 0);
1570         /*
1571          * The first thing we do is set the size to new_size permanently
1572          * on disk.  This way we don't have to worry about anyone ever
1573          * being able to look at the data being freed even in the face
1574          * of a crash.  What we're getting around here is the case where
1575          * we free a block, it is allocated to another file, it is written
1576          * to, and then we crash.  If the new data gets written to the
1577          * file but the log buffers containing the free and reallocation
1578          * don't, then we'd end up with garbage in the blocks being freed.
1579          * As long as we make the new_size permanent before actually
1580          * freeing any blocks it doesn't matter if they get writtten to.
1581          *
1582          * The callers must signal into us whether or not the size
1583          * setting here must be synchronous.  There are a few cases
1584          * where it doesn't have to be synchronous.  Those cases
1585          * occur if the file is unlinked and we know the unlink is
1586          * permanent or if the blocks being truncated are guaranteed
1587          * to be beyond the inode eof (regardless of the link count)
1588          * and the eof value is permanent.  Both of these cases occur
1589          * only on wsync-mounted filesystems.  In those cases, we're
1590          * guaranteed that no user will ever see the data in the blocks
1591          * that are being truncated so the truncate can run async.
1592          * In the free beyond eof case, the file may wind up with
1593          * more blocks allocated to it than it needs if we crash
1594          * and that won't get fixed until the next time the file
1595          * is re-opened and closed but that's ok as that shouldn't
1596          * be too many blocks.
1597          *
1598          * However, we can't just make all wsync xactions run async
1599          * because there's one call out of the create path that needs
1600          * to run sync where it's truncating an existing file to size
1601          * 0 whose size is > 0.
1602          *
1603          * It's probably possible to come up with a test in this
1604          * routine that would correctly distinguish all the above
1605          * cases from the values of the function parameters and the
1606          * inode state but for sanity's sake, I've decided to let the
1607          * layers above just tell us.  It's simpler to correctly figure
1608          * out in the layer above exactly under what conditions we
1609          * can run async and I think it's easier for others read and
1610          * follow the logic in case something has to be changed.
1611          * cscope is your friend -- rcc.
1612          *
1613          * The attribute fork is much simpler.
1614          *
1615          * For the attribute fork we allow the caller to tell us whether
1616          * the unlink of the inode that led to this call is yet permanent
1617          * in the on disk log.  If it is not and we will be freeing extents
1618          * in this inode then we make the first transaction synchronous
1619          * to make sure that the unlink is permanent by the time we free
1620          * the blocks.
1621          */
1622         if (fork == XFS_DATA_FORK) {
1623                 if (ip->i_d.di_nextents > 0) {
1624                         ip->i_d.di_size = new_size;
1625                         xfs_trans_log_inode(ntp, ip, XFS_ILOG_CORE);
1626                 }
1627         } else if (sync) {
1628                 ASSERT(!(mp->m_flags & XFS_MOUNT_WSYNC));
1629                 if (ip->i_d.di_anextents > 0)
1630                         xfs_trans_set_sync(ntp);
1631         }
1632         ASSERT(fork == XFS_DATA_FORK ||
1633                 (fork == XFS_ATTR_FORK &&
1634                         ((sync && !(mp->m_flags & XFS_MOUNT_WSYNC)) ||
1635                          (sync == 0 && (mp->m_flags & XFS_MOUNT_WSYNC)))));
1636
1637         /*
1638          * Since it is possible for space to become allocated beyond
1639          * the end of the file (in a crash where the space is allocated
1640          * but the inode size is not yet updated), simply remove any
1641          * blocks which show up between the new EOF and the maximum
1642          * possible file size.  If the first block to be removed is
1643          * beyond the maximum file size (ie it is the same as last_block),
1644          * then there is nothing to do.
1645          */
1646         last_block = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_MAXIOFFSET(mp));
1647         ASSERT(first_unmap_block <= last_block);
1648         done = 0;
1649         if (last_block == first_unmap_block) {
1650                 done = 1;
1651         } else {
1652                 unmap_len = last_block - first_unmap_block + 1;
1653         }
1654         while (!done) {
1655                 /*
1656                  * Free up up to XFS_ITRUNC_MAX_EXTENTS.  xfs_bunmapi()
1657                  * will tell us whether it freed the entire range or
1658                  * not.  If this is a synchronous mount (wsync),
1659                  * then we can tell bunmapi to keep all the
1660                  * transactions asynchronous since the unlink
1661                  * transaction that made this inode inactive has
1662                  * already hit the disk.  There's no danger of
1663                  * the freed blocks being reused, there being a
1664                  * crash, and the reused blocks suddenly reappearing
1665                  * in this file with garbage in them once recovery
1666                  * runs.
1667                  */
1668                 XFS_BMAP_INIT(&free_list, &first_block);
1669                 error = xfs_bunmapi(ntp, ip, first_unmap_block,
1670                                     unmap_len,
1671                                     XFS_BMAPI_AFLAG(fork) |
1672                                       (sync ? 0 : XFS_BMAPI_ASYNC),
1673                                     XFS_ITRUNC_MAX_EXTENTS,
1674                                     &first_block, &free_list, &done);
1675                 if (error) {
1676                         /*
1677                          * If the bunmapi call encounters an error,
1678                          * return to the caller where the transaction
1679                          * can be properly aborted.  We just need to
1680                          * make sure we're not holding any resources
1681                          * that we were not when we came in.
1682                          */
1683                         xfs_bmap_cancel(&free_list);
1684                         return error;
1685                 }
1686
1687                 /*
1688                  * Duplicate the transaction that has the permanent
1689                  * reservation and commit the old transaction.
1690                  */
1691                 error = xfs_bmap_finish(tp, &free_list, first_block,
1692                                         &committed);
1693                 ntp = *tp;
1694                 if (error) {
1695                         /*
1696                          * If the bmap finish call encounters an error,
1697                          * return to the caller where the transaction
1698                          * can be properly aborted.  We just need to
1699                          * make sure we're not holding any resources
1700                          * that we were not when we came in.
1701                          *
1702                          * Aborting from this point might lose some
1703                          * blocks in the file system, but oh well.
1704                          */
1705                         xfs_bmap_cancel(&free_list);
1706                         if (committed) {
1707                                 /*
1708                                  * If the passed in transaction committed
1709                                  * in xfs_bmap_finish(), then we want to
1710                                  * add the inode to this one before returning.
1711                                  * This keeps things simple for the higher
1712                                  * level code, because it always knows that
1713                                  * the inode is locked and held in the
1714                                  * transaction that returns to it whether
1715                                  * errors occur or not.  We don't mark the
1716                                  * inode dirty so that this transaction can
1717                                  * be easily aborted if possible.
1718                                  */
1719                                 xfs_trans_ijoin(ntp, ip,
1720                                         XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
1721                                 xfs_trans_ihold(ntp, ip);
1722                         }
1723                         return error;
1724                 }
1725
1726                 if (committed) {
1727                         /*
1728                          * The first xact was committed,
1729                          * so add the inode to the new one.
1730                          * Mark it dirty so it will be logged
1731                          * and moved forward in the log as
1732                          * part of every commit.
1733                          */
1734                         xfs_trans_ijoin(ntp, ip,
1735                                         XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
1736                         xfs_trans_ihold(ntp, ip);
1737                         xfs_trans_log_inode(ntp, ip, XFS_ILOG_CORE);
1738                 }
1739                 ntp = xfs_trans_dup(ntp);
1740                 (void) xfs_trans_commit(*tp, 0, NULL);
1741                 *tp = ntp;
1742                 error = xfs_trans_reserve(ntp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0,
1743                                           XFS_TRANS_PERM_LOG_RES,
1744                                           XFS_ITRUNCATE_LOG_COUNT);
1745                 /*
1746                  * Add the inode being truncated to the next chained
1747                  * transaction.
1748                  */
1749                 xfs_trans_ijoin(ntp, ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
1750                 xfs_trans_ihold(ntp, ip);
1751                 if (error)
1752                         return (error);
1753         }
1754         /*
1755          * Only update the size in the case of the data fork, but
1756          * always re-log the inode so that our permanent transaction
1757          * can keep on rolling it forward in the log.
1758          */
1759         if (fork == XFS_DATA_FORK) {
1760                 xfs_isize_check(mp, ip, new_size);
1761                 ip->i_d.di_size = new_size;
1762         }
1763         xfs_trans_log_inode(ntp, ip, XFS_ILOG_CORE);
1764         ASSERT((new_size != 0) ||
1765                (fork == XFS_ATTR_FORK) ||
1766                (ip->i_delayed_blks == 0));
1767         ASSERT((new_size != 0) ||
1768                (fork == XFS_ATTR_FORK) ||
1769                (ip->i_d.di_nextents == 0));
1770         xfs_itrunc_trace(XFS_ITRUNC_FINISH2, ip, 0, new_size, 0, 0);
1771         return 0;
1772 }
1773
1774
1775 /*
1776  * xfs_igrow_start
1777  *
1778  * Do the first part of growing a file: zero any data in the last
1779  * block that is beyond the old EOF.  We need to do this before
1780  * the inode is joined to the transaction to modify the i_size.
1781  * That way we can drop the inode lock and call into the buffer
1782  * cache to get the buffer mapping the EOF.
1783  */
1784 int
1785 xfs_igrow_start(
1786         xfs_inode_t     *ip,
1787         xfs_fsize_t     new_size,
1788         cred_t          *credp)
1789 {
1790         int             error;
1791
1792         ASSERT(ismrlocked(&(ip->i_lock), MR_UPDATE) != 0);
1793         ASSERT(ismrlocked(&(ip->i_iolock), MR_UPDATE) != 0);
1794         ASSERT(new_size > ip->i_d.di_size);
1795
1796         /*
1797          * Zero any pages that may have been created by
1798          * xfs_write_file() beyond the end of the file
1799          * and any blocks between the old and new file sizes.
1800          */
1801         error = xfs_zero_eof(XFS_ITOV(ip), &ip->i_iocore, new_size,
1802                              ip->i_d.di_size, new_size);
1803         return error;
1804 }
1805
1806 /*
1807  * xfs_igrow_finish
1808  *
1809  * This routine is called to extend the size of a file.
1810  * The inode must have both the iolock and the ilock locked
1811  * for update and it must be a part of the current transaction.
1812  * The xfs_igrow_start() function must have been called previously.
1813  * If the change_flag is not zero, the inode change timestamp will
1814  * be updated.
1815  */
1816 void
1817 xfs_igrow_finish(
1818         xfs_trans_t     *tp,
1819         xfs_inode_t     *ip,
1820         xfs_fsize_t     new_size,
1821         int             change_flag)
1822 {
1823         ASSERT(ismrlocked(&(ip->i_lock), MR_UPDATE) != 0);
1824         ASSERT(ismrlocked(&(ip->i_iolock), MR_UPDATE) != 0);
1825         ASSERT(ip->i_transp == tp);
1826         ASSERT(new_size > ip->i_d.di_size);
1827
1828         /*
1829          * Update the file size.  Update the inode change timestamp
1830          * if change_flag set.
1831          */
1832         ip->i_d.di_size = new_size;
1833         if (change_flag)
1834                 xfs_ichgtime(ip, XFS_ICHGTIME_CHG);
1835         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1836
1837 }
1838
1839
1840 /*
1841  * This is called when the inode's link count goes to 0.
1842  * We place the on-disk inode on a list in the AGI.  It
1843  * will be pulled from this list when the inode is freed.
1844  */
1845 int
1846 xfs_iunlink(
1847         xfs_trans_t     *tp,
1848         xfs_inode_t     *ip)
1849 {
1850         xfs_mount_t     *mp;
1851         xfs_agi_t       *agi;
1852         xfs_dinode_t    *dip;
1853         xfs_buf_t       *agibp;
1854         xfs_buf_t       *ibp;
1855         xfs_agnumber_t  agno;
1856         xfs_daddr_t     agdaddr;
1857         xfs_agino_t     agino;
1858         short           bucket_index;
1859         int             offset;
1860         int             error;
1861         int             agi_ok;
1862
1863         ASSERT(ip->i_d.di_nlink == 0);
1864         ASSERT(ip->i_d.di_mode != 0);
1865         ASSERT(ip->i_transp == tp);
1866
1867         mp = tp->t_mountp;
1868
1869         agno = XFS_INO_TO_AGNO(mp, ip->i_ino);
1870         agdaddr = XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp));
1871
1872         /*
1873          * Get the agi buffer first.  It ensures lock ordering
1874          * on the list.
1875          */
1876         error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, agdaddr,
1877                                    XFS_FSS_TO_BB(mp, 1), 0, &agibp);
1878         if (error) {
1879                 return error;
1880         }
1881         /*
1882          * Validate the magic number of the agi block.
1883          */
1884         agi = XFS_BUF_TO_AGI(agibp);
1885         agi_ok =
1886                 be32_to_cpu(agi->agi_magicnum) == XFS_AGI_MAGIC &&
1887                 XFS_AGI_GOOD_VERSION(be32_to_cpu(agi->agi_versionnum));
1888         if (unlikely(XFS_TEST_ERROR(!agi_ok, mp, XFS_ERRTAG_IUNLINK,
1889                         XFS_RANDOM_IUNLINK))) {
1890                 XFS_CORRUPTION_ERROR("xfs_iunlink", XFS_ERRLEVEL_LOW, mp, agi);
1891                 xfs_trans_brelse(tp, agibp);
1892                 return XFS_ERROR(EFSCORRUPTED);
1893         }
1894         /*
1895          * Get the index into the agi hash table for the
1896          * list this inode will go on.
1897          */
1898         agino = XFS_INO_TO_AGINO(mp, ip->i_ino);
1899         ASSERT(agino != 0);
1900         bucket_index = agino % XFS_AGI_UNLINKED_BUCKETS;
1901         ASSERT(agi->agi_unlinked[bucket_index]);
1902         ASSERT(be32_to_cpu(agi->agi_unlinked[bucket_index]) != agino);
1903
1904         if (be32_to_cpu(agi->agi_unlinked[bucket_index]) != NULLAGINO) {
1905                 /*
1906                  * There is already another inode in the bucket we need
1907                  * to add ourselves to.  Add us at the front of the list.
1908                  * Here we put the head pointer into our next pointer,
1909                  * and then we fall through to point the head at us.
1910                  */
1911                 error = xfs_itobp(mp, tp, ip, &dip, &ibp, 0, 0);
1912                 if (error) {
1913                         return error;
1914                 }
1915                 ASSERT(INT_GET(dip->di_next_unlinked, ARCH_CONVERT) == NULLAGINO);
1916                 ASSERT(dip->di_next_unlinked);
1917                 /* both on-disk, don't endian flip twice */
1918                 dip->di_next_unlinked = agi->agi_unlinked[bucket_index];
1919                 offset = ip->i_boffset +
1920                         offsetof(xfs_dinode_t, di_next_unlinked);
1921                 xfs_trans_inode_buf(tp, ibp);
1922                 xfs_trans_log_buf(tp, ibp, offset,
1923                                   (offset + sizeof(xfs_agino_t) - 1));
1924                 xfs_inobp_check(mp, ibp);
1925         }
1926
1927         /*
1928          * Point the bucket head pointer at the inode being inserted.
1929          */
1930         ASSERT(agino != 0);
1931         agi->agi_unlinked[bucket_index] = cpu_to_be32(agino);
1932         offset = offsetof(xfs_agi_t, agi_unlinked) +
1933                 (sizeof(xfs_agino_t) * bucket_index);
1934         xfs_trans_log_buf(tp, agibp, offset,
1935                           (offset + sizeof(xfs_agino_t) - 1));
1936         return 0;
1937 }
1938
1939 /*
1940  * Pull the on-disk inode from the AGI unlinked list.
1941  */
1942 STATIC int
1943 xfs_iunlink_remove(
1944         xfs_trans_t     *tp,
1945         xfs_inode_t     *ip)
1946 {
1947         xfs_ino_t       next_ino;
1948         xfs_mount_t     *mp;
1949         xfs_agi_t       *agi;
1950         xfs_dinode_t    *dip;
1951         xfs_buf_t       *agibp;
1952         xfs_buf_t       *ibp;
1953         xfs_agnumber_t  agno;
1954         xfs_daddr_t     agdaddr;
1955         xfs_agino_t     agino;
1956         xfs_agino_t     next_agino;
1957         xfs_buf_t       *last_ibp;
1958         xfs_dinode_t    *last_dip;
1959         short           bucket_index;
1960         int             offset, last_offset;
1961         int             error;
1962         int             agi_ok;
1963
1964         /*
1965          * First pull the on-disk inode from the AGI unlinked list.
1966          */
1967         mp = tp->t_mountp;
1968
1969         agno = XFS_INO_TO_AGNO(mp, ip->i_ino);
1970         agdaddr = XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp));
1971
1972         /*
1973          * Get the agi buffer first.  It ensures lock ordering
1974          * on the list.
1975          */
1976         error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, agdaddr,
1977                                    XFS_FSS_TO_BB(mp, 1), 0, &agibp);
1978         if (error) {
1979                 cmn_err(CE_WARN,
1980                         "xfs_iunlink_remove: xfs_trans_read_buf()  returned an error %d on %s.  Returning error.",
1981                         error, mp->m_fsname);
1982                 return error;
1983         }
1984         /*
1985          * Validate the magic number of the agi block.
1986          */
1987         agi = XFS_BUF_TO_AGI(agibp);
1988         agi_ok =
1989                 be32_to_cpu(agi->agi_magicnum) == XFS_AGI_MAGIC &&
1990                 XFS_AGI_GOOD_VERSION(be32_to_cpu(agi->agi_versionnum));
1991         if (unlikely(XFS_TEST_ERROR(!agi_ok, mp, XFS_ERRTAG_IUNLINK_REMOVE,
1992                         XFS_RANDOM_IUNLINK_REMOVE))) {
1993                 XFS_CORRUPTION_ERROR("xfs_iunlink_remove", XFS_ERRLEVEL_LOW,
1994                                      mp, agi);
1995                 xfs_trans_brelse(tp, agibp);
1996                 cmn_err(CE_WARN,
1997                         "xfs_iunlink_remove: XFS_TEST_ERROR()  returned an error on %s.  Returning EFSCORRUPTED.",
1998                          mp->m_fsname);
1999                 return XFS_ERROR(EFSCORRUPTED);
2000         }
2001         /*
2002          * Get the index into the agi hash table for the
2003          * list this inode will go on.
2004          */
2005         agino = XFS_INO_TO_AGINO(mp, ip->i_ino);
2006         ASSERT(agino != 0);
2007         bucket_index = agino % XFS_AGI_UNLINKED_BUCKETS;
2008         ASSERT(be32_to_cpu(agi->agi_unlinked[bucket_index]) != NULLAGINO);
2009         ASSERT(agi->agi_unlinked[bucket_index]);
2010
2011         if (be32_to_cpu(agi->agi_unlinked[bucket_index]) == agino) {
2012                 /*
2013                  * We're at the head of the list.  Get the inode's
2014                  * on-disk buffer to see if there is anyone after us
2015                  * on the list.  Only modify our next pointer if it
2016                  * is not already NULLAGINO.  This saves us the overhead
2017                  * of dealing with the buffer when there is no need to
2018                  * change it.
2019                  */
2020                 error = xfs_itobp(mp, tp, ip, &dip, &ibp, 0, 0);
2021                 if (error) {
2022                         cmn_err(CE_WARN,
2023                                 "xfs_iunlink_remove: xfs_itobp()  returned an error %d on %s.  Returning error.",
2024                                 error, mp->m_fsname);
2025                         return error;
2026                 }
2027                 next_agino = INT_GET(dip->di_next_unlinked, ARCH_CONVERT);
2028                 ASSERT(next_agino != 0);
2029                 if (next_agino != NULLAGINO) {
2030                         INT_SET(dip->di_next_unlinked, ARCH_CONVERT, NULLAGINO);
2031                         offset = ip->i_boffset +
2032                                 offsetof(xfs_dinode_t, di_next_unlinked);
2033                         xfs_trans_inode_buf(tp, ibp);
2034                         xfs_trans_log_buf(tp, ibp, offset,
2035                                           (offset + sizeof(xfs_agino_t) - 1));
2036                         xfs_inobp_check(mp, ibp);
2037                 } else {
2038                         xfs_trans_brelse(tp, ibp);
2039                 }
2040                 /*
2041                  * Point the bucket head pointer at the next inode.
2042                  */
2043                 ASSERT(next_agino != 0);
2044                 ASSERT(next_agino != agino);
2045                 agi->agi_unlinked[bucket_index] = cpu_to_be32(next_agino);
2046                 offset = offsetof(xfs_agi_t, agi_unlinked) +
2047                         (sizeof(xfs_agino_t) * bucket_index);
2048                 xfs_trans_log_buf(tp, agibp, offset,
2049                                   (offset + sizeof(xfs_agino_t) - 1));
2050         } else {
2051                 /*
2052                  * We need to search the list for the inode being freed.
2053                  */
2054                 next_agino = be32_to_cpu(agi->agi_unlinked[bucket_index]);
2055                 last_ibp = NULL;
2056                 while (next_agino != agino) {
2057                         /*
2058                          * If the last inode wasn't the one pointing to
2059                          * us, then release its buffer since we're not
2060                          * going to do anything with it.
2061                          */
2062                         if (last_ibp != NULL) {
2063                                 xfs_trans_brelse(tp, last_ibp);
2064                         }
2065                         next_ino = XFS_AGINO_TO_INO(mp, agno, next_agino);
2066                         error = xfs_inotobp(mp, tp, next_ino, &last_dip,
2067                                             &last_ibp, &last_offset);
2068                         if (error) {
2069                                 cmn_err(CE_WARN,
2070                         "xfs_iunlink_remove: xfs_inotobp()  returned an error %d on %s.  Returning error.",
2071                                         error, mp->m_fsname);
2072                                 return error;
2073                         }
2074                         next_agino = INT_GET(last_dip->di_next_unlinked, ARCH_CONVERT);
2075                         ASSERT(next_agino != NULLAGINO);
2076                         ASSERT(next_agino != 0);
2077                 }
2078                 /*
2079                  * Now last_ibp points to the buffer previous to us on
2080                  * the unlinked list.  Pull us from the list.
2081                  */
2082                 error = xfs_itobp(mp, tp, ip, &dip, &ibp, 0, 0);
2083                 if (error) {
2084                         cmn_err(CE_WARN,
2085                                 "xfs_iunlink_remove: xfs_itobp()  returned an error %d on %s.  Returning error.",
2086                                 error, mp->m_fsname);
2087                         return error;
2088                 }
2089                 next_agino = INT_GET(dip->di_next_unlinked, ARCH_CONVERT);
2090                 ASSERT(next_agino != 0);
2091                 ASSERT(next_agino != agino);
2092                 if (next_agino != NULLAGINO) {
2093                         INT_SET(dip->di_next_unlinked, ARCH_CONVERT, NULLAGINO);
2094                         offset = ip->i_boffset +
2095                                 offsetof(xfs_dinode_t, di_next_unlinked);
2096                         xfs_trans_inode_buf(tp, ibp);
2097                         xfs_trans_log_buf(tp, ibp, offset,
2098                                           (offset + sizeof(xfs_agino_t) - 1));
2099                         xfs_inobp_check(mp, ibp);
2100                 } else {
2101                         xfs_trans_brelse(tp, ibp);
2102                 }
2103                 /*
2104                  * Point the previous inode on the list to the next inode.
2105                  */
2106                 INT_SET(last_dip->di_next_unlinked, ARCH_CONVERT, next_agino);
2107                 ASSERT(next_agino != 0);
2108                 offset = last_offset + offsetof(xfs_dinode_t, di_next_unlinked);
2109                 xfs_trans_inode_buf(tp, last_ibp);
2110                 xfs_trans_log_buf(tp, last_ibp, offset,
2111                                   (offset + sizeof(xfs_agino_t) - 1));
2112                 xfs_inobp_check(mp, last_ibp);
2113         }
2114         return 0;
2115 }
2116
2117 static __inline__ int xfs_inode_clean(xfs_inode_t *ip)
2118 {
2119         return (((ip->i_itemp == NULL) ||
2120                 !(ip->i_itemp->ili_format.ilf_fields & XFS_ILOG_ALL)) &&
2121                 (ip->i_update_core == 0));
2122 }
2123
2124 STATIC void
2125 xfs_ifree_cluster(
2126         xfs_inode_t     *free_ip,
2127         xfs_trans_t     *tp,
2128         xfs_ino_t       inum)
2129 {
2130         xfs_mount_t             *mp = free_ip->i_mount;
2131         int                     blks_per_cluster;
2132         int                     nbufs;
2133         int                     ninodes;
2134         int                     i, j, found, pre_flushed;
2135         xfs_daddr_t             blkno;
2136         xfs_buf_t               *bp;
2137         xfs_ihash_t             *ih;
2138         xfs_inode_t             *ip, **ip_found;
2139         xfs_inode_log_item_t    *iip;
2140         xfs_log_item_t          *lip;
2141         SPLDECL(s);
2142
2143         if (mp->m_sb.sb_blocksize >= XFS_INODE_CLUSTER_SIZE(mp)) {
2144                 blks_per_cluster = 1;
2145                 ninodes = mp->m_sb.sb_inopblock;
2146                 nbufs = XFS_IALLOC_BLOCKS(mp);
2147         } else {
2148                 blks_per_cluster = XFS_INODE_CLUSTER_SIZE(mp) /
2149                                         mp->m_sb.sb_blocksize;
2150                 ninodes = blks_per_cluster * mp->m_sb.sb_inopblock;
2151                 nbufs = XFS_IALLOC_BLOCKS(mp) / blks_per_cluster;
2152         }
2153
2154         ip_found = kmem_alloc(ninodes * sizeof(xfs_inode_t *), KM_NOFS);
2155
2156         for (j = 0; j < nbufs; j++, inum += ninodes) {
2157                 blkno = XFS_AGB_TO_DADDR(mp, XFS_INO_TO_AGNO(mp, inum),
2158                                          XFS_INO_TO_AGBNO(mp, inum));
2159
2160
2161                 /*
2162                  * Look for each inode in memory and attempt to lock it,
2163                  * we can be racing with flush and tail pushing here.
2164                  * any inode we get the locks on, add to an array of
2165                  * inode items to process later.
2166                  *
2167                  * The get the buffer lock, we could beat a flush
2168                  * or tail pushing thread to the lock here, in which
2169                  * case they will go looking for the inode buffer
2170                  * and fail, we need some other form of interlock
2171                  * here.
2172                  */
2173                 found = 0;
2174                 for (i = 0; i < ninodes; i++) {
2175                         ih = XFS_IHASH(mp, inum + i);
2176                         read_lock(&ih->ih_lock);
2177                         for (ip = ih->ih_next; ip != NULL; ip = ip->i_next) {
2178                                 if (ip->i_ino == inum + i)
2179                                         break;
2180                         }
2181
2182                         /* Inode not in memory or we found it already,
2183                          * nothing to do
2184                          */
2185                         if (!ip || (ip->i_flags & XFS_ISTALE)) {
2186                                 read_unlock(&ih->ih_lock);
2187                                 continue;
2188                         }
2189
2190                         if (xfs_inode_clean(ip)) {
2191                                 read_unlock(&ih->ih_lock);
2192                                 continue;
2193                         }
2194
2195                         /* If we can get the locks then add it to the
2196                          * list, otherwise by the time we get the bp lock
2197                          * below it will already be attached to the
2198                          * inode buffer.
2199                          */
2200
2201                         /* This inode will already be locked - by us, lets
2202                          * keep it that way.
2203                          */
2204
2205                         if (ip == free_ip) {
2206                                 if (xfs_iflock_nowait(ip)) {
2207                                         ip->i_flags |= XFS_ISTALE;
2208
2209                                         if (xfs_inode_clean(ip)) {
2210                                                 xfs_ifunlock(ip);
2211                                         } else {
2212                                                 ip_found[found++] = ip;
2213                                         }
2214                                 }
2215                                 read_unlock(&ih->ih_lock);
2216                                 continue;
2217                         }
2218
2219                         if (xfs_ilock_nowait(ip, XFS_ILOCK_EXCL)) {
2220                                 if (xfs_iflock_nowait(ip)) {
2221                                         ip->i_flags |= XFS_ISTALE;
2222
2223                                         if (xfs_inode_clean(ip)) {
2224                                                 xfs_ifunlock(ip);
2225                                                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
2226                                         } else {
2227                                                 ip_found[found++] = ip;
2228                                         }
2229                                 } else {
2230                                         xfs_iunlock(ip, XFS_ILOCK_EXCL);
2231                                 }
2232                         }
2233
2234                         read_unlock(&ih->ih_lock);
2235                 }
2236
2237                 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, blkno, 
2238                                         mp->m_bsize * blks_per_cluster,
2239                                         XFS_BUF_LOCK);
2240
2241                 pre_flushed = 0;
2242                 lip = XFS_BUF_FSPRIVATE(bp, xfs_log_item_t *);
2243                 while (lip) {
2244                         if (lip->li_type == XFS_LI_INODE) {
2245                                 iip = (xfs_inode_log_item_t *)lip;
2246                                 ASSERT(iip->ili_logged == 1);
2247                                 lip->li_cb = (void(*)(xfs_buf_t*,xfs_log_item_t*)) xfs_istale_done;
2248                                 AIL_LOCK(mp,s);
2249                                 iip->ili_flush_lsn = iip->ili_item.li_lsn;
2250                                 AIL_UNLOCK(mp, s);
2251                                 iip->ili_inode->i_flags |= XFS_ISTALE;
2252                                 pre_flushed++;
2253                         }
2254                         lip = lip->li_bio_list;
2255                 }
2256
2257                 for (i = 0; i < found; i++) {
2258                         ip = ip_found[i];
2259                         iip = ip->i_itemp;
2260
2261                         if (!iip) {
2262                                 ip->i_update_core = 0;
2263                                 xfs_ifunlock(ip);
2264                                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
2265                                 continue;
2266                         }
2267
2268                         iip->ili_last_fields = iip->ili_format.ilf_fields;
2269                         iip->ili_format.ilf_fields = 0;
2270                         iip->ili_logged = 1;
2271                         AIL_LOCK(mp,s);
2272                         iip->ili_flush_lsn = iip->ili_item.li_lsn;
2273                         AIL_UNLOCK(mp, s);
2274
2275                         xfs_buf_attach_iodone(bp,
2276                                 (void(*)(xfs_buf_t*,xfs_log_item_t*))
2277                                 xfs_istale_done, (xfs_log_item_t *)iip);
2278                         if (ip != free_ip) {
2279                                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
2280                         }
2281                 }
2282
2283                 if (found || pre_flushed)
2284                         xfs_trans_stale_inode_buf(tp, bp);
2285                 xfs_trans_binval(tp, bp);
2286         }
2287
2288         kmem_free(ip_found, ninodes * sizeof(xfs_inode_t *));
2289 }
2290
2291 /*
2292  * This is called to return an inode to the inode free list.
2293  * The inode should already be truncated to 0 length and have
2294  * no pages associated with it.  This routine also assumes that
2295  * the inode is already a part of the transaction.
2296  *
2297  * The on-disk copy of the inode will have been added to the list
2298  * of unlinked inodes in the AGI. We need to remove the inode from
2299  * that list atomically with respect to freeing it here.
2300  */
2301 int
2302 xfs_ifree(
2303         xfs_trans_t     *tp,
2304         xfs_inode_t     *ip,
2305         xfs_bmap_free_t *flist)
2306 {
2307         int                     error;
2308         int                     delete;
2309         xfs_ino_t               first_ino;
2310
2311         ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE));
2312         ASSERT(ip->i_transp == tp);
2313         ASSERT(ip->i_d.di_nlink == 0);
2314         ASSERT(ip->i_d.di_nextents == 0);
2315         ASSERT(ip->i_d.di_anextents == 0);
2316         ASSERT((ip->i_d.di_size == 0) ||
2317                ((ip->i_d.di_mode & S_IFMT) != S_IFREG));
2318         ASSERT(ip->i_d.di_nblocks == 0);
2319
2320         /*
2321          * Pull the on-disk inode from the AGI unlinked list.
2322          */
2323         error = xfs_iunlink_remove(tp, ip);
2324         if (error != 0) {
2325                 return error;
2326         }
2327
2328         error = xfs_difree(tp, ip->i_ino, flist, &delete, &first_ino);
2329         if (error != 0) {
2330                 return error;
2331         }
2332         ip->i_d.di_mode = 0;            /* mark incore inode as free */
2333         ip->i_d.di_flags = 0;
2334         ip->i_d.di_dmevmask = 0;
2335         ip->i_d.di_forkoff = 0;         /* mark the attr fork not in use */
2336         ip->i_df.if_ext_max =
2337                 XFS_IFORK_DSIZE(ip) / (uint)sizeof(xfs_bmbt_rec_t);
2338         ip->i_d.di_format = XFS_DINODE_FMT_EXTENTS;
2339         ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
2340         /*
2341          * Bump the generation count so no one will be confused
2342          * by reincarnations of this inode.
2343          */
2344         ip->i_d.di_gen++;
2345         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
2346
2347         if (delete) {
2348                 xfs_ifree_cluster(ip, tp, first_ino);
2349         }
2350
2351         return 0;
2352 }
2353
2354 /*
2355  * Reallocate the space for if_broot based on the number of records
2356  * being added or deleted as indicated in rec_diff.  Move the records
2357  * and pointers in if_broot to fit the new size.  When shrinking this
2358  * will eliminate holes between the records and pointers created by
2359  * the caller.  When growing this will create holes to be filled in
2360  * by the caller.
2361  *
2362  * The caller must not request to add more records than would fit in
2363  * the on-disk inode root.  If the if_broot is currently NULL, then
2364  * if we adding records one will be allocated.  The caller must also
2365  * not request that the number of records go below zero, although
2366  * it can go to zero.
2367  *
2368  * ip -- the inode whose if_broot area is changing
2369  * ext_diff -- the change in the number of records, positive or negative,
2370  *       requested for the if_broot array.
2371  */
2372 void
2373 xfs_iroot_realloc(
2374         xfs_inode_t             *ip,
2375         int                     rec_diff,
2376         int                     whichfork)
2377 {
2378         int                     cur_max;
2379         xfs_ifork_t             *ifp;
2380         xfs_bmbt_block_t        *new_broot;
2381         int                     new_max;
2382         size_t                  new_size;
2383         char                    *np;
2384         char                    *op;
2385
2386         /*
2387          * Handle the degenerate case quietly.
2388          */
2389         if (rec_diff == 0) {
2390                 return;
2391         }
2392
2393         ifp = XFS_IFORK_PTR(ip, whichfork);
2394         if (rec_diff > 0) {
2395                 /*
2396                  * If there wasn't any memory allocated before, just
2397                  * allocate it now and get out.
2398                  */
2399                 if (ifp->if_broot_bytes == 0) {
2400                         new_size = (size_t)XFS_BMAP_BROOT_SPACE_CALC(rec_diff);
2401                         ifp->if_broot = (xfs_bmbt_block_t*)kmem_alloc(new_size,
2402                                                                      KM_SLEEP);
2403                         ifp->if_broot_bytes = (int)new_size;
2404                         return;
2405                 }
2406
2407                 /*
2408                  * If there is already an existing if_broot, then we need
2409                  * to realloc() it and shift the pointers to their new
2410                  * location.  The records don't change location because
2411                  * they are kept butted up against the btree block header.
2412                  */
2413                 cur_max = XFS_BMAP_BROOT_MAXRECS(ifp->if_broot_bytes);
2414                 new_max = cur_max + rec_diff;
2415                 new_size = (size_t)XFS_BMAP_BROOT_SPACE_CALC(new_max);
2416                 ifp->if_broot = (xfs_bmbt_block_t *)
2417                   kmem_realloc(ifp->if_broot,
2418                                 new_size,
2419                                 (size_t)XFS_BMAP_BROOT_SPACE_CALC(cur_max), /* old size */
2420                                 KM_SLEEP);
2421                 op = (char *)XFS_BMAP_BROOT_PTR_ADDR(ifp->if_broot, 1,
2422                                                       ifp->if_broot_bytes);
2423                 np = (char *)XFS_BMAP_BROOT_PTR_ADDR(ifp->if_broot, 1,
2424                                                       (int)new_size);
2425                 ifp->if_broot_bytes = (int)new_size;
2426                 ASSERT(ifp->if_broot_bytes <=
2427                         XFS_IFORK_SIZE(ip, whichfork) + XFS_BROOT_SIZE_ADJ);
2428                 memmove(np, op, cur_max * (uint)sizeof(xfs_dfsbno_t));
2429                 return;
2430         }
2431
2432         /*
2433          * rec_diff is less than 0.  In this case, we are shrinking the
2434          * if_broot buffer.  It must already exist.  If we go to zero
2435          * records, just get rid of the root and clear the status bit.
2436          */
2437         ASSERT((ifp->if_broot != NULL) && (ifp->if_broot_bytes > 0));
2438         cur_max = XFS_BMAP_BROOT_MAXRECS(ifp->if_broot_bytes);
2439         new_max = cur_max + rec_diff;
2440         ASSERT(new_max >= 0);
2441         if (new_max > 0)
2442                 new_size = (size_t)XFS_BMAP_BROOT_SPACE_CALC(new_max);
2443         else
2444                 new_size = 0;
2445         if (new_size > 0) {
2446                 new_broot = (xfs_bmbt_block_t *)kmem_alloc(new_size, KM_SLEEP);
2447                 /*
2448                  * First copy over the btree block header.
2449                  */
2450                 memcpy(new_broot, ifp->if_broot, sizeof(xfs_bmbt_block_t));
2451         } else {
2452                 new_broot = NULL;
2453                 ifp->if_flags &= ~XFS_IFBROOT;
2454         }
2455
2456         /*
2457          * Only copy the records and pointers if there are any.
2458          */
2459         if (new_max > 0) {
2460                 /*
2461                  * First copy the records.
2462                  */
2463                 op = (char *)XFS_BMAP_BROOT_REC_ADDR(ifp->if_broot, 1,
2464                                                      ifp->if_broot_bytes);
2465                 np = (char *)XFS_BMAP_BROOT_REC_ADDR(new_broot, 1,
2466                                                      (int)new_size);
2467                 memcpy(np, op, new_max * (uint)sizeof(xfs_bmbt_rec_t));
2468
2469                 /*
2470                  * Then copy the pointers.
2471                  */
2472                 op = (char *)XFS_BMAP_BROOT_PTR_ADDR(ifp->if_broot, 1,
2473                                                      ifp->if_broot_bytes);
2474                 np = (char *)XFS_BMAP_BROOT_PTR_ADDR(new_broot, 1,
2475                                                      (int)new_size);
2476                 memcpy(np, op, new_max * (uint)sizeof(xfs_dfsbno_t));
2477         }
2478         kmem_free(ifp->if_broot, ifp->if_broot_bytes);
2479         ifp->if_broot = new_broot;
2480         ifp->if_broot_bytes = (int)new_size;
2481         ASSERT(ifp->if_broot_bytes <=
2482                 XFS_IFORK_SIZE(ip, whichfork) + XFS_BROOT_SIZE_ADJ);
2483         return;
2484 }
2485
2486
2487 /*
2488  * This is called when the amount of space needed for if_data
2489  * is increased or decreased.  The change in size is indicated by
2490  * the number of bytes that need to be added or deleted in the
2491  * byte_diff parameter.
2492  *
2493  * If the amount of space needed has decreased below the size of the
2494  * inline buffer, then switch to using the inline buffer.  Otherwise,
2495  * use kmem_realloc() or kmem_alloc() to adjust the size of the buffer
2496  * to what is needed.
2497  *
2498  * ip -- the inode whose if_data area is changing
2499  * byte_diff -- the change in the number of bytes, positive or negative,
2500  *       requested for the if_data array.
2501  */
2502 void
2503 xfs_idata_realloc(
2504         xfs_inode_t     *ip,
2505         int             byte_diff,
2506         int             whichfork)
2507 {
2508         xfs_ifork_t     *ifp;
2509         int             new_size;
2510         int             real_size;
2511
2512         if (byte_diff == 0) {
2513                 return;
2514         }
2515
2516         ifp = XFS_IFORK_PTR(ip, whichfork);
2517         new_size = (int)ifp->if_bytes + byte_diff;
2518         ASSERT(new_size >= 0);
2519
2520         if (new_size == 0) {
2521                 if (ifp->if_u1.if_data != ifp->if_u2.if_inline_data) {
2522                         kmem_free(ifp->if_u1.if_data, ifp->if_real_bytes);
2523                 }
2524                 ifp->if_u1.if_data = NULL;
2525                 real_size = 0;
2526         } else if (new_size <= sizeof(ifp->if_u2.if_inline_data)) {
2527                 /*
2528                  * If the valid extents/data can fit in if_inline_ext/data,
2529                  * copy them from the malloc'd vector and free it.
2530                  */
2531                 if (ifp->if_u1.if_data == NULL) {
2532                         ifp->if_u1.if_data = ifp->if_u2.if_inline_data;
2533                 } else if (ifp->if_u1.if_data != ifp->if_u2.if_inline_data) {
2534                         ASSERT(ifp->if_real_bytes != 0);
2535                         memcpy(ifp->if_u2.if_inline_data, ifp->if_u1.if_data,
2536                               new_size);
2537                         kmem_free(ifp->if_u1.if_data, ifp->if_real_bytes);
2538                         ifp->if_u1.if_data = ifp->if_u2.if_inline_data;
2539                 }
2540                 real_size = 0;
2541         } else {
2542                 /*
2543                  * Stuck with malloc/realloc.
2544                  * For inline data, the underlying buffer must be
2545                  * a multiple of 4 bytes in size so that it can be
2546                  * logged and stay on word boundaries.  We enforce
2547                  * that here.
2548                  */
2549                 real_size = roundup(new_size, 4);
2550                 if (ifp->if_u1.if_data == NULL) {
2551                         ASSERT(ifp->if_real_bytes == 0);
2552                         ifp->if_u1.if_data = kmem_alloc(real_size, KM_SLEEP);
2553                 } else if (ifp->if_u1.if_data != ifp->if_u2.if_inline_data) {
2554                         /*
2555                          * Only do the realloc if the underlying size
2556                          * is really changing.
2557                          */
2558                         if (ifp->if_real_bytes != real_size) {
2559                                 ifp->if_u1.if_data =
2560                                         kmem_realloc(ifp->if_u1.if_data,
2561                                                         real_size,
2562                                                         ifp->if_real_bytes,
2563                                                         KM_SLEEP);
2564                         }
2565                 } else {
2566                         ASSERT(ifp->if_real_bytes == 0);
2567                         ifp->if_u1.if_data = kmem_alloc(real_size, KM_SLEEP);
2568                         memcpy(ifp->if_u1.if_data, ifp->if_u2.if_inline_data,
2569                                 ifp->if_bytes);
2570                 }
2571         }
2572         ifp->if_real_bytes = real_size;
2573         ifp->if_bytes = new_size;
2574         ASSERT(ifp->if_bytes <= XFS_IFORK_SIZE(ip, whichfork));
2575 }
2576
2577
2578
2579
2580 /*
2581  * Map inode to disk block and offset.
2582  *
2583  * mp -- the mount point structure for the current file system
2584  * tp -- the current transaction
2585  * ino -- the inode number of the inode to be located
2586  * imap -- this structure is filled in with the information necessary
2587  *       to retrieve the given inode from disk
2588  * flags -- flags to pass to xfs_dilocate indicating whether or not
2589  *       lookups in the inode btree were OK or not
2590  */
2591 int
2592 xfs_imap(
2593         xfs_mount_t     *mp,
2594         xfs_trans_t     *tp,
2595         xfs_ino_t       ino,
2596         xfs_imap_t      *imap,
2597         uint            flags)
2598 {
2599         xfs_fsblock_t   fsbno;
2600         int             len;
2601         int             off;
2602         int             error;
2603
2604         fsbno = imap->im_blkno ?
2605                 XFS_DADDR_TO_FSB(mp, imap->im_blkno) : NULLFSBLOCK;
2606         error = xfs_dilocate(mp, tp, ino, &fsbno, &len, &off, flags);
2607         if (error != 0) {
2608                 return error;
2609         }
2610         imap->im_blkno = XFS_FSB_TO_DADDR(mp, fsbno);
2611         imap->im_len = XFS_FSB_TO_BB(mp, len);
2612         imap->im_agblkno = XFS_FSB_TO_AGBNO(mp, fsbno);
2613         imap->im_ioffset = (ushort)off;
2614         imap->im_boffset = (ushort)(off << mp->m_sb.sb_inodelog);
2615         return 0;
2616 }
2617
2618 void
2619 xfs_idestroy_fork(
2620         xfs_inode_t     *ip,
2621         int             whichfork)
2622 {
2623         xfs_ifork_t     *ifp;
2624
2625         ifp = XFS_IFORK_PTR(ip, whichfork);
2626         if (ifp->if_broot != NULL) {
2627                 kmem_free(ifp->if_broot, ifp->if_broot_bytes);
2628                 ifp->if_broot = NULL;
2629         }
2630
2631         /*
2632          * If the format is local, then we can't have an extents
2633          * array so just look for an inline data array.  If we're
2634          * not local then we may or may not have an extents list,
2635          * so check and free it up if we do.
2636          */
2637         if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL) {
2638                 if ((ifp->if_u1.if_data != ifp->if_u2.if_inline_data) &&
2639                     (ifp->if_u1.if_data != NULL)) {
2640                         ASSERT(ifp->if_real_bytes != 0);
2641                         kmem_free(ifp->if_u1.if_data, ifp->if_real_bytes);
2642                         ifp->if_u1.if_data = NULL;
2643                         ifp->if_real_bytes = 0;
2644                 }
2645         } else if ((ifp->if_flags & XFS_IFEXTENTS) &&
2646                    ((ifp->if_flags & XFS_IFEXTIREC) ||
2647                     ((ifp->if_u1.if_extents != NULL) &&
2648                      (ifp->if_u1.if_extents != ifp->if_u2.if_inline_ext)))) {
2649                 ASSERT(ifp->if_real_bytes != 0);
2650                 xfs_iext_destroy(ifp);
2651         }
2652         ASSERT(ifp->if_u1.if_extents == NULL ||
2653                ifp->if_u1.if_extents == ifp->if_u2.if_inline_ext);
2654         ASSERT(ifp->if_real_bytes == 0);
2655         if (whichfork == XFS_ATTR_FORK) {
2656                 kmem_zone_free(xfs_ifork_zone, ip->i_afp);
2657                 ip->i_afp = NULL;
2658         }
2659 }
2660
2661 /*
2662  * This is called free all the memory associated with an inode.
2663  * It must free the inode itself and any buffers allocated for
2664  * if_extents/if_data and if_broot.  It must also free the lock
2665  * associated with the inode.
2666  */
2667 void
2668 xfs_idestroy(
2669         xfs_inode_t     *ip)
2670 {
2671
2672         switch (ip->i_d.di_mode & S_IFMT) {
2673         case S_IFREG:
2674         case S_IFDIR:
2675         case S_IFLNK:
2676                 xfs_idestroy_fork(ip, XFS_DATA_FORK);
2677                 break;
2678         }
2679         if (ip->i_afp)
2680                 xfs_idestroy_fork(ip, XFS_ATTR_FORK);
2681         mrfree(&ip->i_lock);
2682         mrfree(&ip->i_iolock);
2683         freesema(&ip->i_flock);
2684 #ifdef XFS_BMAP_TRACE
2685         ktrace_free(ip->i_xtrace);
2686 #endif
2687 #ifdef XFS_BMBT_TRACE
2688         ktrace_free(ip->i_btrace);
2689 #endif
2690 #ifdef XFS_RW_TRACE
2691         ktrace_free(ip->i_rwtrace);
2692 #endif
2693 #ifdef XFS_ILOCK_TRACE
2694         ktrace_free(ip->i_lock_trace);
2695 #endif
2696 #ifdef XFS_DIR2_TRACE
2697         ktrace_free(ip->i_dir_trace);
2698 #endif
2699         if (ip->i_itemp) {
2700                 /* XXXdpd should be able to assert this but shutdown
2701                  * is leaving the AIL behind. */
2702                 ASSERT(((ip->i_itemp->ili_item.li_flags & XFS_LI_IN_AIL) == 0) ||
2703                        XFS_FORCED_SHUTDOWN(ip->i_mount));
2704                 xfs_inode_item_destroy(ip);
2705         }
2706         kmem_zone_free(xfs_inode_zone, ip);
2707 }
2708
2709
2710 /*
2711  * Increment the pin count of the given buffer.
2712  * This value is protected by ipinlock spinlock in the mount structure.
2713  */
2714 void
2715 xfs_ipin(
2716         xfs_inode_t     *ip)
2717 {
2718         ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE));
2719
2720         atomic_inc(&ip->i_pincount);
2721 }
2722
2723 /*
2724  * Decrement the pin count of the given inode, and wake up
2725  * anyone in xfs_iwait_unpin() if the count goes to 0.  The
2726  * inode must have been previously pinned with a call to xfs_ipin().
2727  */
2728 void
2729 xfs_iunpin(
2730         xfs_inode_t     *ip)
2731 {
2732         ASSERT(atomic_read(&ip->i_pincount) > 0);
2733
2734         if (atomic_dec_and_test(&ip->i_pincount)) {
2735                 vnode_t *vp = XFS_ITOV_NULL(ip);
2736
2737                 /* make sync come back and flush this inode */
2738                 if (vp) {
2739                         struct inode    *inode = vn_to_inode(vp);
2740
2741                         if (!(inode->i_state & I_NEW))
2742                                 mark_inode_dirty_sync(inode);
2743                 }
2744
2745                 wake_up(&ip->i_ipin_wait);
2746         }
2747 }
2748
2749 /*
2750  * This is called to wait for the given inode to be unpinned.
2751  * It will sleep until this happens.  The caller must have the
2752  * inode locked in at least shared mode so that the buffer cannot
2753  * be subsequently pinned once someone is waiting for it to be
2754  * unpinned.
2755  */
2756 STATIC void
2757 xfs_iunpin_wait(
2758         xfs_inode_t     *ip)
2759 {
2760         xfs_inode_log_item_t    *iip;
2761         xfs_lsn_t       lsn;
2762
2763         ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE | MR_ACCESS));
2764
2765         if (atomic_read(&ip->i_pincount) == 0) {
2766                 return;
2767         }
2768
2769         iip = ip->i_itemp;
2770         if (iip && iip->ili_last_lsn) {
2771                 lsn = iip->ili_last_lsn;
2772         } else {
2773                 lsn = (xfs_lsn_t)0;
2774         }
2775
2776         /*
2777          * Give the log a push so we don't wait here too long.
2778          */
2779         xfs_log_force(ip->i_mount, lsn, XFS_LOG_FORCE);
2780
2781         wait_event(ip->i_ipin_wait, (atomic_read(&ip->i_pincount) == 0));
2782 }
2783
2784
2785 /*
2786  * xfs_iextents_copy()
2787  *
2788  * This is called to copy the REAL extents (as opposed to the delayed
2789  * allocation extents) from the inode into the given buffer.  It
2790  * returns the number of bytes copied into the buffer.
2791  *
2792  * If there are no delayed allocation extents, then we can just
2793  * memcpy() the extents into the buffer.  Otherwise, we need to
2794  * examine each extent in turn and skip those which are delayed.
2795  */
2796 int
2797 xfs_iextents_copy(
2798         xfs_inode_t             *ip,
2799         xfs_bmbt_rec_t          *buffer,
2800         int                     whichfork)
2801 {
2802         int                     copied;
2803         xfs_bmbt_rec_t          *dest_ep;
2804         xfs_bmbt_rec_t          *ep;
2805 #ifdef XFS_BMAP_TRACE
2806         static char             fname[] = "xfs_iextents_copy";
2807 #endif
2808         int                     i;
2809         xfs_ifork_t             *ifp;
2810         int                     nrecs;
2811         xfs_fsblock_t           start_block;
2812
2813         ifp = XFS_IFORK_PTR(ip, whichfork);
2814         ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE|MR_ACCESS));
2815         ASSERT(ifp->if_bytes > 0);
2816
2817         nrecs = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
2818         xfs_bmap_trace_exlist(fname, ip, nrecs, whichfork);
2819         ASSERT(nrecs > 0);
2820
2821         /*
2822          * There are some delayed allocation extents in the
2823          * inode, so copy the extents one at a time and skip
2824          * the delayed ones.  There must be at least one
2825          * non-delayed extent.
2826          */
2827         dest_ep = buffer;
2828         copied = 0;
2829         for (i = 0; i < nrecs; i++) {
2830                 ep = xfs_iext_get_ext(ifp, i);
2831                 start_block = xfs_bmbt_get_startblock(ep);
2832                 if (ISNULLSTARTBLOCK(start_block)) {
2833                         /*
2834                          * It's a delayed allocation extent, so skip it.
2835                          */
2836                         continue;
2837                 }
2838
2839                 /* Translate to on disk format */
2840                 put_unaligned(INT_GET(ep->l0, ARCH_CONVERT),
2841                               (__uint64_t*)&dest_ep->l0);
2842                 put_unaligned(INT_GET(ep->l1, ARCH_CONVERT),
2843                               (__uint64_t*)&dest_ep->l1);
2844                 dest_ep++;
2845                 copied++;
2846         }
2847         ASSERT(copied != 0);
2848         xfs_validate_extents(ifp, copied, 1, XFS_EXTFMT_INODE(ip));
2849
2850         return (copied * (uint)sizeof(xfs_bmbt_rec_t));
2851 }
2852
2853 /*
2854  * Each of the following cases stores data into the same region
2855  * of the on-disk inode, so only one of them can be valid at
2856  * any given time. While it is possible to have conflicting formats
2857  * and log flags, e.g. having XFS_ILOG_?DATA set when the fork is
2858  * in EXTENTS format, this can only happen when the fork has
2859  * changed formats after being modified but before being flushed.
2860  * In these cases, the format always takes precedence, because the
2861  * format indicates the current state of the fork.
2862  */
2863 /*ARGSUSED*/
2864 STATIC int
2865 xfs_iflush_fork(
2866         xfs_inode_t             *ip,
2867         xfs_dinode_t            *dip,
2868         xfs_inode_log_item_t    *iip,
2869         int                     whichfork,
2870         xfs_buf_t               *bp)
2871 {
2872         char                    *cp;
2873         xfs_ifork_t             *ifp;
2874         xfs_mount_t             *mp;
2875 #ifdef XFS_TRANS_DEBUG
2876         int                     first;
2877 #endif
2878         static const short      brootflag[2] =
2879                 { XFS_ILOG_DBROOT, XFS_ILOG_ABROOT };
2880         static const short      dataflag[2] =
2881                 { XFS_ILOG_DDATA, XFS_ILOG_ADATA };
2882         static const short      extflag[2] =
2883                 { XFS_ILOG_DEXT, XFS_ILOG_AEXT };
2884
2885         if (iip == NULL)
2886                 return 0;
2887         ifp = XFS_IFORK_PTR(ip, whichfork);
2888         /*
2889          * This can happen if we gave up in iformat in an error path,
2890          * for the attribute fork.
2891          */
2892         if (ifp == NULL) {
2893                 ASSERT(whichfork == XFS_ATTR_FORK);
2894                 return 0;
2895         }
2896         cp = XFS_DFORK_PTR(dip, whichfork);
2897         mp = ip->i_mount;
2898         switch (XFS_IFORK_FORMAT(ip, whichfork)) {
2899         case XFS_DINODE_FMT_LOCAL:
2900                 if ((iip->ili_format.ilf_fields & dataflag[whichfork]) &&
2901                     (ifp->if_bytes > 0)) {
2902                         ASSERT(ifp->if_u1.if_data != NULL);
2903                         ASSERT(ifp->if_bytes <= XFS_IFORK_SIZE(ip, whichfork));
2904                         memcpy(cp, ifp->if_u1.if_data, ifp->if_bytes);
2905                 }
2906                 if (whichfork == XFS_DATA_FORK) {
2907                         if (unlikely(XFS_DIR_SHORTFORM_VALIDATE_ONDISK(mp, dip))) {
2908                                 XFS_ERROR_REPORT("xfs_iflush_fork",
2909                                                  XFS_ERRLEVEL_LOW, mp);
2910                                 return XFS_ERROR(EFSCORRUPTED);
2911                         }
2912                 }
2913                 break;
2914
2915         case XFS_DINODE_FMT_EXTENTS:
2916                 ASSERT((ifp->if_flags & XFS_IFEXTENTS) ||
2917                        !(iip->ili_format.ilf_fields & extflag[whichfork]));
2918                 ASSERT((xfs_iext_get_ext(ifp, 0) != NULL) ||
2919                         (ifp->if_bytes == 0));
2920                 ASSERT((xfs_iext_get_ext(ifp, 0) == NULL) ||
2921                         (ifp->if_bytes > 0));
2922                 if ((iip->ili_format.ilf_fields & extflag[whichfork]) &&
2923                     (ifp->if_bytes > 0)) {
2924                         ASSERT(XFS_IFORK_NEXTENTS(ip, whichfork) > 0);
2925                         (void)xfs_iextents_copy(ip, (xfs_bmbt_rec_t *)cp,
2926                                 whichfork);
2927                 }
2928                 break;
2929
2930         case XFS_DINODE_FMT_BTREE:
2931                 if ((iip->ili_format.ilf_fields & brootflag[whichfork]) &&
2932                     (ifp->if_broot_bytes > 0)) {
2933                         ASSERT(ifp->if_broot != NULL);
2934                         ASSERT(ifp->if_broot_bytes <=
2935                                (XFS_IFORK_SIZE(ip, whichfork) +
2936                                 XFS_BROOT_SIZE_ADJ));
2937                         xfs_bmbt_to_bmdr(ifp->if_broot, ifp->if_broot_bytes,
2938                                 (xfs_bmdr_block_t *)cp,
2939                                 XFS_DFORK_SIZE(dip, mp, whichfork));
2940                 }
2941                 break;
2942
2943         case XFS_DINODE_FMT_DEV:
2944                 if (iip->ili_format.ilf_fields & XFS_ILOG_DEV) {
2945                         ASSERT(whichfork == XFS_DATA_FORK);
2946                         INT_SET(dip->di_u.di_dev, ARCH_CONVERT, ip->i_df.if_u2.if_rdev);
2947                 }
2948                 break;
2949
2950         case XFS_DINODE_FMT_UUID:
2951                 if (iip->ili_format.ilf_fields & XFS_ILOG_UUID) {
2952                         ASSERT(whichfork == XFS_DATA_FORK);
2953                         memcpy(&dip->di_u.di_muuid, &ip->i_df.if_u2.if_uuid,
2954                                 sizeof(uuid_t));
2955                 }
2956                 break;
2957
2958         default:
2959                 ASSERT(0);
2960                 break;
2961         }
2962
2963         return 0;
2964 }
2965
2966 /*
2967  * xfs_iflush() will write a modified inode's changes out to the
2968  * inode's on disk home.  The caller must have the inode lock held
2969  * in at least shared mode and the inode flush semaphore must be
2970  * held as well.  The inode lock will still be held upon return from
2971  * the call and the caller is free to unlock it.
2972  * The inode flush lock will be unlocked when the inode reaches the disk.
2973  * The flags indicate how the inode's buffer should be written out.
2974  */
2975 int
2976 xfs_iflush(
2977         xfs_inode_t             *ip,
2978         uint                    flags)
2979 {
2980         xfs_inode_log_item_t    *iip;
2981         xfs_buf_t               *bp;
2982         xfs_dinode_t            *dip;
2983         xfs_mount_t             *mp;
2984         int                     error;
2985         /* REFERENCED */
2986         xfs_chash_t             *ch;
2987         xfs_inode_t             *iq;
2988         int                     clcount;        /* count of inodes clustered */
2989         int                     bufwasdelwri;
2990         enum { INT_DELWRI = (1 << 0), INT_ASYNC = (1 << 1) };
2991         SPLDECL(s);
2992
2993         XFS_STATS_INC(xs_iflush_count);
2994
2995         ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE|MR_ACCESS));
2996         ASSERT(valusema(&ip->i_flock) <= 0);
2997         ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE ||
2998                ip->i_d.di_nextents > ip->i_df.if_ext_max);
2999
3000         iip = ip->i_itemp;
3001         mp = ip->i_mount;
3002
3003         /*
3004          * If the inode isn't dirty, then just release the inode
3005          * flush lock and do nothing.
3006          */
3007         if ((ip->i_update_core == 0) &&
3008             ((iip == NULL) || !(iip->ili_format.ilf_fields & XFS_ILOG_ALL))) {
3009                 ASSERT((iip != NULL) ?
3010                          !(iip->ili_item.li_flags & XFS_LI_IN_AIL) : 1);
3011                 xfs_ifunlock(ip);
3012                 return 0;
3013         }
3014
3015         /*
3016          * We can't flush the inode until it is unpinned, so
3017          * wait for it.  We know noone new can pin it, because
3018          * we are holding the inode lock shared and you need
3019          * to hold it exclusively to pin the inode.
3020          */
3021         xfs_iunpin_wait(ip);
3022
3023         /*
3024          * This may have been unpinned because the filesystem is shutting
3025          * down forcibly. If that's the case we must not write this inode
3026          * to disk, because the log record didn't make it to disk!
3027          */
3028         if (XFS_FORCED_SHUTDOWN(mp)) {
3029                 ip->i_update_core = 0;
3030                 if (iip)
3031                         iip->ili_format.ilf_fields = 0;
3032                 xfs_ifunlock(ip);
3033                 return XFS_ERROR(EIO);
3034         }
3035
3036         /*
3037          * Get the buffer containing the on-disk inode.
3038          */
3039         error = xfs_itobp(mp, NULL, ip, &dip, &bp, 0, 0);
3040         if (error) {
3041                 xfs_ifunlock(ip);
3042                 return error;
3043         }
3044
3045         /*
3046          * Decide how buffer will be flushed out.  This is done before
3047          * the call to xfs_iflush_int because this field is zeroed by it.
3048          */
3049         if (iip != NULL && iip->ili_format.ilf_fields != 0) {
3050                 /*
3051                  * Flush out the inode buffer according to the directions
3052                  * of the caller.  In the cases where the caller has given
3053                  * us a choice choose the non-delwri case.  This is because
3054                  * the inode is in the AIL and we need to get it out soon.
3055                  */
3056                 switch (flags) {
3057                 case XFS_IFLUSH_SYNC:
3058                 case XFS_IFLUSH_DELWRI_ELSE_SYNC:
3059                         flags = 0;
3060                         break;
3061                 case XFS_IFLUSH_ASYNC:
3062                 case XFS_IFLUSH_DELWRI_ELSE_ASYNC:
3063                         flags = INT_ASYNC;
3064                         break;
3065                 case XFS_IFLUSH_DELWRI:
3066                         flags = INT_DELWRI;
3067                         break;
3068                 default:
3069                         ASSERT(0);
3070                         flags = 0;
3071                         break;
3072                 }
3073         } else {
3074                 switch (flags) {
3075                 case XFS_IFLUSH_DELWRI_ELSE_SYNC:
3076                 case XFS_IFLUSH_DELWRI_ELSE_ASYNC:
3077                 case XFS_IFLUSH_DELWRI:
3078                         flags = INT_DELWRI;
3079                         break;
3080                 case XFS_IFLUSH_ASYNC:
3081                         flags = INT_ASYNC;
3082                         break;
3083                 case XFS_IFLUSH_SYNC:
3084                         flags = 0;
3085                         break;
3086                 default:
3087                         ASSERT(0);
3088                         flags = 0;
3089                         break;
3090                 }
3091         }
3092
3093         /*
3094          * First flush out the inode that xfs_iflush was called with.
3095          */
3096         error = xfs_iflush_int(ip, bp);
3097         if (error) {
3098                 goto corrupt_out;
3099         }
3100
3101         /*
3102          * inode clustering:
3103          * see if other inodes can be gathered into this write
3104          */
3105
3106         ip->i_chash->chl_buf = bp;
3107
3108         ch = XFS_CHASH(mp, ip->i_blkno);
3109         s = mutex_spinlock(&ch->ch_lock);
3110
3111         clcount = 0;
3112         for (iq = ip->i_cnext; iq != ip; iq = iq->i_cnext) {
3113                 /*
3114                  * Do an un-protected check to see if the inode is dirty and
3115                  * is a candidate for flushing.  These checks will be repeated
3116                  * later after the appropriate locks are acquired.
3117                  */
3118                 iip = iq->i_itemp;
3119                 if ((iq->i_update_core == 0) &&
3120                     ((iip == NULL) ||
3121                      !(iip->ili_format.ilf_fields & XFS_ILOG_ALL)) &&
3122                       xfs_ipincount(iq) == 0) {
3123                         continue;
3124                 }
3125
3126                 /*
3127                  * Try to get locks.  If any are unavailable,
3128                  * then this inode cannot be flushed and is skipped.
3129                  */
3130
3131                 /* get inode locks (just i_lock) */
3132                 if (xfs_ilock_nowait(iq, XFS_ILOCK_SHARED)) {
3133                         /* get inode flush lock */
3134                         if (xfs_iflock_nowait(iq)) {
3135                                 /* check if pinned */
3136                                 if (xfs_ipincount(iq) == 0) {
3137                                         /* arriving here means that
3138                                          * this inode can be flushed.
3139                                          * first re-check that it's
3140                                          * dirty
3141                                          */
3142                                         iip = iq->i_itemp;
3143                                         if ((iq->i_update_core != 0)||
3144                                             ((iip != NULL) &&
3145                                              (iip->ili_format.ilf_fields & XFS_ILOG_ALL))) {
3146                                                 clcount++;
3147                                                 error = xfs_iflush_int(iq, bp);
3148                                                 if (error) {
3149                                                         xfs_iunlock(iq,
3150                                                                     XFS_ILOCK_SHARED);
3151                                                         goto cluster_corrupt_out;
3152                                                 }
3153                                         } else {
3154                                                 xfs_ifunlock(iq);
3155                                         }
3156                                 } else {
3157                                         xfs_ifunlock(iq);
3158                                 }
3159                         }
3160                         xfs_iunlock(iq, XFS_ILOCK_SHARED);
3161                 }
3162         }
3163         mutex_spinunlock(&ch->ch_lock, s);
3164
3165         if (clcount) {
3166                 XFS_STATS_INC(xs_icluster_flushcnt);
3167                 XFS_STATS_ADD(xs_icluster_flushinode, clcount);
3168         }
3169
3170         /*
3171          * If the buffer is pinned then push on the log so we won't
3172          * get stuck waiting in the write for too long.
3173          */
3174         if (XFS_BUF_ISPINNED(bp)){
3175                 xfs_log_force(mp, (xfs_lsn_t)0, XFS_LOG_FORCE);
3176         }
3177
3178         if (flags & INT_DELWRI) {
3179                 xfs_bdwrite(mp, bp);
3180         } else if (flags & INT_ASYNC) {
3181                 xfs_bawrite(mp, bp);
3182         } else {
3183                 error = xfs_bwrite(mp, bp);
3184         }
3185         return error;
3186
3187 corrupt_out:
3188         xfs_buf_relse(bp);
3189         xfs_force_shutdown(mp, XFS_CORRUPT_INCORE);
3190         xfs_iflush_abort(ip);
3191         /*
3192          * Unlocks the flush lock
3193          */
3194         return XFS_ERROR(EFSCORRUPTED);
3195
3196 cluster_corrupt_out:
3197         /* Corruption detected in the clustering loop.  Invalidate the
3198          * inode buffer and shut down the filesystem.
3199          */
3200         mutex_spinunlock(&ch->ch_lock, s);
3201
3202         /*
3203          * Clean up the buffer.  If it was B_DELWRI, just release it --
3204          * brelse can handle it with no problems.  If not, shut down the
3205          * filesystem before releasing the buffer.
3206          */
3207         if ((bufwasdelwri= XFS_BUF_ISDELAYWRITE(bp))) {
3208                 xfs_buf_relse(bp);
3209         }
3210
3211         xfs_force_shutdown(mp, XFS_CORRUPT_INCORE);
3212
3213         if(!bufwasdelwri)  {
3214                 /*
3215                  * Just like incore_relse: if we have b_iodone functions,
3216                  * mark the buffer as an error and call them.  Otherwise
3217                  * mark it as stale and brelse.
3218                  */
3219                 if (XFS_BUF_IODONE_FUNC(bp)) {
3220                         XFS_BUF_CLR_BDSTRAT_FUNC(bp);
3221                         XFS_BUF_UNDONE(bp);
3222                         XFS_BUF_STALE(bp);
3223                         XFS_BUF_SHUT(bp);
3224                         XFS_BUF_ERROR(bp,EIO);
3225                         xfs_biodone(bp);
3226                 } else {
3227                         XFS_BUF_STALE(bp);
3228                         xfs_buf_relse(bp);
3229                 }
3230         }
3231
3232         xfs_iflush_abort(iq);
3233         /*
3234          * Unlocks the flush lock
3235          */
3236         return XFS_ERROR(EFSCORRUPTED);
3237 }
3238
3239
3240 STATIC int
3241 xfs_iflush_int(
3242         xfs_inode_t             *ip,
3243         xfs_buf_t               *bp)
3244 {
3245         xfs_inode_log_item_t    *iip;
3246         xfs_dinode_t            *dip;
3247         xfs_mount_t             *mp;
3248 #ifdef XFS_TRANS_DEBUG
3249         int                     first;
3250 #endif
3251         SPLDECL(s);
3252
3253         ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE|MR_ACCESS));
3254         ASSERT(valusema(&ip->i_flock) <= 0);
3255         ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE ||
3256                ip->i_d.di_nextents > ip->i_df.if_ext_max);
3257
3258         iip = ip->i_itemp;
3259         mp = ip->i_mount;
3260
3261
3262         /*
3263          * If the inode isn't dirty, then just release the inode
3264          * flush lock and do nothing.
3265          */
3266         if ((ip->i_update_core == 0) &&
3267             ((iip == NULL) || !(iip->ili_format.ilf_fields & XFS_ILOG_ALL))) {
3268                 xfs_ifunlock(ip);
3269                 return 0;
3270         }
3271
3272         /* set *dip = inode's place in the buffer */
3273         dip = (xfs_dinode_t *)xfs_buf_offset(bp, ip->i_boffset);
3274
3275         /*
3276          * Clear i_update_core before copying out the data.
3277          * This is for coordination with our timestamp updates
3278          * that don't hold the inode lock. They will always
3279          * update the timestamps BEFORE setting i_update_core,
3280          * so if we clear i_update_core after they set it we
3281          * are guaranteed to see their updates to the timestamps.
3282          * I believe that this depends on strongly ordered memory
3283          * semantics, but we have that.  We use the SYNCHRONIZE
3284          * macro to make sure that the compiler does not reorder
3285          * the i_update_core access below the data copy below.
3286          */
3287         ip->i_update_core = 0;
3288         SYNCHRONIZE();
3289
3290         /*
3291          * Make sure to get the latest atime from the Linux inode.
3292          */
3293         xfs_synchronize_atime(ip);
3294
3295         if (XFS_TEST_ERROR(INT_GET(dip->di_core.di_magic,ARCH_CONVERT) != XFS_DINODE_MAGIC,
3296                                mp, XFS_ERRTAG_IFLUSH_1, XFS_RANDOM_IFLUSH_1)) {
3297                 xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp,
3298                     "xfs_iflush: Bad inode %Lu magic number 0x%x, ptr 0x%p",
3299                         ip->i_ino, (int) INT_GET(dip->di_core.di_magic, ARCH_CONVERT), dip);
3300                 goto corrupt_out;
3301         }
3302         if (XFS_TEST_ERROR(ip->i_d.di_magic != XFS_DINODE_MAGIC,
3303                                 mp, XFS_ERRTAG_IFLUSH_2, XFS_RANDOM_IFLUSH_2)) {
3304                 xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp,
3305                         "xfs_iflush: Bad inode %Lu, ptr 0x%p, magic number 0x%x",
3306                         ip->i_ino, ip, ip->i_d.di_magic);
3307                 goto corrupt_out;
3308         }
3309         if ((ip->i_d.di_mode & S_IFMT) == S_IFREG) {
3310                 if (XFS_TEST_ERROR(
3311                     (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS) &&
3312                     (ip->i_d.di_format != XFS_DINODE_FMT_BTREE),
3313                     mp, XFS_ERRTAG_IFLUSH_3, XFS_RANDOM_IFLUSH_3)) {
3314                         xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp,
3315                                 "xfs_iflush: Bad regular inode %Lu, ptr 0x%p",
3316                                 ip->i_ino, ip);
3317                         goto corrupt_out;
3318                 }
3319         } else if ((ip->i_d.di_mode & S_IFMT) == S_IFDIR) {
3320                 if (XFS_TEST_ERROR(
3321                     (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS) &&
3322                     (ip->i_d.di_format != XFS_DINODE_FMT_BTREE) &&
3323                     (ip->i_d.di_format != XFS_DINODE_FMT_LOCAL),
3324                     mp, XFS_ERRTAG_IFLUSH_4, XFS_RANDOM_IFLUSH_4)) {
3325                         xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp,
3326                                 "xfs_iflush: Bad directory inode %Lu, ptr 0x%p",
3327                                 ip->i_ino, ip);
3328                         goto corrupt_out;
3329                 }
3330         }
3331         if (XFS_TEST_ERROR(ip->i_d.di_nextents + ip->i_d.di_anextents >
3332                                 ip->i_d.di_nblocks, mp, XFS_ERRTAG_IFLUSH_5,
3333                                 XFS_RANDOM_IFLUSH_5)) {
3334                 xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp,
3335                         "xfs_iflush: detected corrupt incore inode %Lu, total extents = %d, nblocks = %Ld, ptr 0x%p",
3336                         ip->i_ino,
3337                         ip->i_d.di_nextents + ip->i_d.di_anextents,
3338                         ip->i_d.di_nblocks,
3339                         ip);
3340                 goto corrupt_out;
3341         }
3342         if (XFS_TEST_ERROR(ip->i_d.di_forkoff > mp->m_sb.sb_inodesize,
3343                                 mp, XFS_ERRTAG_IFLUSH_6, XFS_RANDOM_IFLUSH_6)) {
3344                 xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp,
3345                         "xfs_iflush: bad inode %Lu, forkoff 0x%x, ptr 0x%p",
3346                         ip->i_ino, ip->i_d.di_forkoff, ip);
3347                 goto corrupt_out;
3348         }
3349         /*
3350          * bump the flush iteration count, used to detect flushes which
3351          * postdate a log record during recovery.
3352          */
3353
3354         ip->i_d.di_flushiter++;
3355
3356         /*
3357          * Copy the dirty parts of the inode into the on-disk
3358          * inode.  We always copy out the core of the inode,
3359          * because if the inode is dirty at all the core must
3360          * be.
3361          */
3362         xfs_xlate_dinode_core((xfs_caddr_t)&(dip->di_core), &(ip->i_d), -1);
3363
3364         /* Wrap, we never let the log put out DI_MAX_FLUSH */
3365         if (ip->i_d.di_flushiter == DI_MAX_FLUSH)
3366                 ip->i_d.di_flushiter = 0;
3367
3368         /*
3369          * If this is really an old format inode and the superblock version
3370          * has not been updated to support only new format inodes, then
3371          * convert back to the old inode format.  If the superblock version
3372          * has been updated, then make the conversion permanent.
3373          */
3374         ASSERT(ip->i_d.di_version == XFS_DINODE_VERSION_1 ||
3375                XFS_SB_VERSION_HASNLINK(&mp->m_sb));
3376         if (ip->i_d.di_version == XFS_DINODE_VERSION_1) {
3377                 if (!XFS_SB_VERSION_HASNLINK(&mp->m_sb)) {
3378                         /*
3379                          * Convert it back.
3380                          */
3381                         ASSERT(ip->i_d.di_nlink <= XFS_MAXLINK_1);
3382                         INT_SET(dip->di_core.di_onlink, ARCH_CONVERT, ip->i_d.di_nlink);
3383                 } else {
3384                         /*
3385                          * The superblock version has already been bumped,
3386                          * so just make the conversion to the new inode
3387                          * format permanent.
3388                          */
3389                         ip->i_d.di_version = XFS_DINODE_VERSION_2;
3390                         INT_SET(dip->di_core.di_version, ARCH_CONVERT, XFS_DINODE_VERSION_2);
3391                         ip->i_d.di_onlink = 0;
3392                         dip->di_core.di_onlink = 0;
3393                         memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad));
3394                         memset(&(dip->di_core.di_pad[0]), 0,
3395                               sizeof(dip->di_core.di_pad));
3396                         ASSERT(ip->i_d.di_projid == 0);
3397                 }
3398         }
3399
3400         if (xfs_iflush_fork(ip, dip, iip, XFS_DATA_FORK, bp) == EFSCORRUPTED) {
3401                 goto corrupt_out;
3402         }
3403
3404         if (XFS_IFORK_Q(ip)) {
3405                 /*
3406                  * The only error from xfs_iflush_fork is on the data fork.
3407                  */
3408                 (void) xfs_iflush_fork(ip, dip, iip, XFS_ATTR_FORK, bp);
3409         }
3410         xfs_inobp_check(mp, bp);
3411
3412         /*
3413          * We've recorded everything logged in the inode, so we'd
3414          * like to clear the ilf_fields bits so we don't log and
3415          * flush things unnecessarily.  However, we can't stop
3416          * logging all this information until the data we've copied
3417          * into the disk buffer is written to disk.  If we did we might
3418          * overwrite the copy of the inode in the log with all the
3419          * data after re-logging only part of it, and in the face of
3420          * a crash we wouldn't have all the data we need to recover.
3421          *
3422          * What we do is move the bits to the ili_last_fields field.
3423          * When logging the inode, these bits are moved back to the
3424          * ilf_fields field.  In the xfs_iflush_done() routine we
3425          * clear ili_last_fields, since we know that the information
3426          * those bits represent is permanently on disk.  As long as
3427          * the flush completes before the inode is logged again, then
3428          * both ilf_fields and ili_last_fields will be cleared.
3429          *
3430          * We can play with the ilf_fields bits here, because the inode
3431          * lock must be held exclusively in order to set bits there
3432          * and the flush lock protects the ili_last_fields bits.
3433          * Set ili_logged so the flush done
3434          * routine can tell whether or not to look in the AIL.
3435          * Also, store the current LSN of the inode so that we can tell
3436          * whether the item has moved in the AIL from xfs_iflush_done().
3437          * In order to read the lsn we need the AIL lock, because
3438          * it is a 64 bit value that cannot be read atomically.
3439          */
3440         if (iip != NULL && iip->ili_format.ilf_fields != 0) {
3441                 iip->ili_last_fields = iip->ili_format.ilf_fields;
3442                 iip->ili_format.ilf_fields = 0;
3443                 iip->ili_logged = 1;
3444
3445                 ASSERT(sizeof(xfs_lsn_t) == 8); /* don't lock if it shrinks */
3446                 AIL_LOCK(mp,s);
3447                 iip->ili_flush_lsn = iip->ili_item.li_lsn;
3448                 AIL_UNLOCK(mp, s);
3449
3450                 /*
3451                  * Attach the function xfs_iflush_done to the inode's
3452                  * buffer.  This will remove the inode from the AIL
3453                  * and unlock the inode's flush lock when the inode is
3454                  * completely written to disk.
3455                  */
3456                 xfs_buf_attach_iodone(bp, (void(*)(xfs_buf_t*,xfs_log_item_t*))
3457                                       xfs_iflush_done, (xfs_log_item_t *)iip);
3458
3459                 ASSERT(XFS_BUF_FSPRIVATE(bp, void *) != NULL);
3460                 ASSERT(XFS_BUF_IODONE_FUNC(bp) != NULL);
3461         } else {
3462                 /*
3463                  * We're flushing an inode which is not in the AIL and has
3464                  * not been logged but has i_update_core set.  For this
3465                  * case we can use a B_DELWRI flush and immediately drop
3466                  * the inode flush lock because we can avoid the whole
3467                  * AIL state thing.  It's OK to drop the flush lock now,
3468                  * because we've already locked the buffer and to do anything
3469                  * you really need both.
3470                  */
3471                 if (iip != NULL) {
3472                         ASSERT(iip->ili_logged == 0);
3473                         ASSERT(iip->ili_last_fields == 0);
3474                         ASSERT((iip->ili_item.li_flags & XFS_LI_IN_AIL) == 0);
3475                 }
3476                 xfs_ifunlock(ip);
3477         }
3478
3479         return 0;
3480
3481 corrupt_out:
3482         return XFS_ERROR(EFSCORRUPTED);
3483 }
3484
3485
3486 /*
3487  * Flush all inactive inodes in mp.
3488  */
3489 void
3490 xfs_iflush_all(
3491         xfs_mount_t     *mp)
3492 {
3493         xfs_inode_t     *ip;
3494         vnode_t         *vp;
3495
3496  again:
3497         XFS_MOUNT_ILOCK(mp);
3498         ip = mp->m_inodes;
3499         if (ip == NULL)
3500                 goto out;
3501
3502         do {
3503                 /* Make sure we skip markers inserted by sync */
3504                 if (ip->i_mount == NULL) {
3505                         ip = ip->i_mnext;
3506                         continue;
3507                 }
3508
3509                 vp = XFS_ITOV_NULL(ip);
3510                 if (!vp) {
3511                         XFS_MOUNT_IUNLOCK(mp);
3512                         xfs_finish_reclaim(ip, 0, XFS_IFLUSH_ASYNC);
3513                         goto again;
3514                 }
3515
3516                 ASSERT(vn_count(vp) == 0);
3517
3518                 ip = ip->i_mnext;
3519         } while (ip != mp->m_inodes);
3520  out:
3521         XFS_MOUNT_IUNLOCK(mp);
3522 }
3523
3524 /*
3525  * xfs_iaccess: check accessibility of inode for mode.
3526  */
3527 int
3528 xfs_iaccess(
3529         xfs_inode_t     *ip,
3530         mode_t          mode,
3531         cred_t          *cr)
3532 {
3533         int             error;
3534         mode_t          orgmode = mode;
3535         struct inode    *inode = vn_to_inode(XFS_ITOV(ip));
3536
3537         if (mode & S_IWUSR) {
3538                 umode_t         imode = inode->i_mode;
3539
3540                 if (IS_RDONLY(inode) &&
3541                     (S_ISREG(imode) || S_ISDIR(imode) || S_ISLNK(imode)))
3542                         return XFS_ERROR(EROFS);
3543
3544                 if (IS_IMMUTABLE(inode))
3545                         return XFS_ERROR(EACCES);
3546         }
3547
3548         /*
3549          * If there's an Access Control List it's used instead of
3550          * the mode bits.
3551          */
3552         if ((error = _ACL_XFS_IACCESS(ip, mode, cr)) != -1)
3553                 return error ? XFS_ERROR(error) : 0;
3554
3555         if (current_fsuid(cr) != ip->i_d.di_uid) {
3556                 mode >>= 3;
3557                 if (!in_group_p((gid_t)ip->i_d.di_gid))
3558                         mode >>= 3;
3559         }
3560
3561         /*
3562          * If the DACs are ok we don't need any capability check.
3563          */
3564         if ((ip->i_d.di_mode & mode) == mode)
3565                 return 0;
3566         /*
3567          * Read/write DACs are always overridable.
3568          * Executable DACs are overridable if at least one exec bit is set.
3569          */
3570         if (!(orgmode & S_IXUSR) ||
3571             (inode->i_mode & S_IXUGO) || S_ISDIR(inode->i_mode))
3572                 if (capable_cred(cr, CAP_DAC_OVERRIDE))
3573                         return 0;
3574
3575         if ((orgmode == S_IRUSR) ||
3576             (S_ISDIR(inode->i_mode) && (!(orgmode & S_IWUSR)))) {
3577                 if (capable_cred(cr, CAP_DAC_READ_SEARCH))
3578                         return 0;
3579 #ifdef  NOISE
3580                 cmn_err(CE_NOTE, "Ick: mode=%o, orgmode=%o", mode, orgmode);
3581 #endif  /* NOISE */
3582                 return XFS_ERROR(EACCES);
3583         }
3584         return XFS_ERROR(EACCES);
3585 }
3586
3587 /*
3588  * xfs_iroundup: round up argument to next power of two
3589  */
3590 uint
3591 xfs_iroundup(
3592         uint    v)
3593 {
3594         int i;
3595         uint m;
3596
3597         if ((v & (v - 1)) == 0)
3598                 return v;
3599         ASSERT((v & 0x80000000) == 0);
3600         if ((v & (v + 1)) == 0)
3601                 return v + 1;
3602         for (i = 0, m = 1; i < 31; i++, m <<= 1) {
3603                 if (v & m)
3604                         continue;
3605                 v |= m;
3606                 if ((v & (v + 1)) == 0)
3607                         return v + 1;
3608         }
3609         ASSERT(0);
3610         return( 0 );
3611 }
3612
3613 #ifdef XFS_ILOCK_TRACE
3614 ktrace_t        *xfs_ilock_trace_buf;
3615
3616 void
3617 xfs_ilock_trace(xfs_inode_t *ip, int lock, unsigned int lockflags, inst_t *ra)
3618 {
3619         ktrace_enter(ip->i_lock_trace,
3620                      (void *)ip,
3621                      (void *)(unsigned long)lock, /* 1 = LOCK, 3=UNLOCK, etc */
3622                      (void *)(unsigned long)lockflags, /* XFS_ILOCK_EXCL etc */
3623                      (void *)ra,                /* caller of ilock */
3624                      (void *)(unsigned long)current_cpu(),
3625                      (void *)(unsigned long)current_pid(),
3626                      NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
3627 }
3628 #endif
3629
3630 /*
3631  * Return a pointer to the extent record at file index idx.
3632  */
3633 xfs_bmbt_rec_t *
3634 xfs_iext_get_ext(
3635         xfs_ifork_t     *ifp,           /* inode fork pointer */
3636         xfs_extnum_t    idx)            /* index of target extent */
3637 {
3638         ASSERT(idx >= 0);
3639         if ((ifp->if_flags & XFS_IFEXTIREC) && (idx == 0)) {
3640                 return ifp->if_u1.if_ext_irec->er_extbuf;
3641         } else if (ifp->if_flags & XFS_IFEXTIREC) {
3642                 xfs_ext_irec_t  *erp;           /* irec pointer */
3643                 int             erp_idx = 0;    /* irec index */
3644                 xfs_extnum_t    page_idx = idx; /* ext index in target list */
3645
3646                 erp = xfs_iext_idx_to_irec(ifp, &page_idx, &erp_idx, 0);
3647                 return &erp->er_extbuf[page_idx];
3648         } else if (ifp->if_bytes) {
3649                 return &ifp->if_u1.if_extents[idx];
3650         } else {
3651                 return NULL;
3652         }
3653 }
3654
3655 /*
3656  * Insert new item(s) into the extent records for incore inode
3657  * fork 'ifp'.  'count' new items are inserted at index 'idx'.
3658  */
3659 void
3660 xfs_iext_insert(
3661         xfs_ifork_t     *ifp,           /* inode fork pointer */
3662         xfs_extnum_t    idx,            /* starting index of new items */
3663         xfs_extnum_t    count,          /* number of inserted items */
3664         xfs_bmbt_irec_t *new)           /* items to insert */
3665 {
3666         xfs_bmbt_rec_t  *ep;            /* extent record pointer */
3667         xfs_extnum_t    i;              /* extent record index */
3668
3669         ASSERT(ifp->if_flags & XFS_IFEXTENTS);
3670         xfs_iext_add(ifp, idx, count);
3671         for (i = idx; i < idx + count; i++, new++) {
3672                 ep = xfs_iext_get_ext(ifp, i);
3673                 xfs_bmbt_set_all(ep, new);
3674         }
3675 }
3676
3677 /*
3678  * This is called when the amount of space required for incore file
3679  * extents needs to be increased. The ext_diff parameter stores the
3680  * number of new extents being added and the idx parameter contains
3681  * the extent index where the new extents will be added. If the new
3682  * extents are being appended, then we just need to (re)allocate and
3683  * initialize the space. Otherwise, if the new extents are being
3684  * inserted into the middle of the existing entries, a bit more work
3685  * is required to make room for the new extents to be inserted. The
3686  * caller is responsible for filling in the new extent entries upon
3687  * return.
3688  */
3689 void
3690 xfs_iext_add(
3691         xfs_ifork_t     *ifp,           /* inode fork pointer */
3692         xfs_extnum_t    idx,            /* index to begin adding exts */
3693         int             ext_diff)       /* number of extents to add */
3694 {
3695         int             byte_diff;      /* new bytes being added */
3696         int             new_size;       /* size of extents after adding */
3697         xfs_extnum_t    nextents;       /* number of extents in file */
3698
3699         nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
3700         ASSERT((idx >= 0) && (idx <= nextents));
3701         byte_diff = ext_diff * sizeof(xfs_bmbt_rec_t);
3702         new_size = ifp->if_bytes + byte_diff;
3703         /*
3704          * If the new number of extents (nextents + ext_diff)
3705          * fits inside the inode, then continue to use the inline
3706          * extent buffer.
3707          */
3708         if (nextents + ext_diff <= XFS_INLINE_EXTS) {
3709                 if (idx < nextents) {
3710                         memmove(&ifp->if_u2.if_inline_ext[idx + ext_diff],
3711                                 &ifp->if_u2.if_inline_ext[idx],
3712                                 (nextents - idx) * sizeof(xfs_bmbt_rec_t));
3713                         memset(&ifp->if_u2.if_inline_ext[idx], 0, byte_diff);
3714                 }
3715                 ifp->if_u1.if_extents = ifp->if_u2.if_inline_ext;
3716                 ifp->if_real_bytes = 0;
3717                 ifp->if_lastex = nextents + ext_diff;
3718         }
3719         /*
3720          * Otherwise use a linear (direct) extent list.
3721          * If the extents are currently inside the inode,
3722          * xfs_iext_realloc_direct will switch us from
3723          * inline to direct extent allocation mode.
3724          */
3725         else if (nextents + ext_diff <= XFS_LINEAR_EXTS) {
3726                 xfs_iext_realloc_direct(ifp, new_size);
3727                 if (idx < nextents) {
3728                         memmove(&ifp->if_u1.if_extents[idx + ext_diff],
3729                                 &ifp->if_u1.if_extents[idx],
3730                                 (nextents - idx) * sizeof(xfs_bmbt_rec_t));
3731                         memset(&ifp->if_u1.if_extents[idx], 0, byte_diff);
3732                 }
3733         }
3734         /* Indirection array */
3735         else {
3736                 xfs_ext_irec_t  *erp;
3737                 int             erp_idx = 0;
3738                 int             page_idx = idx;
3739
3740                 ASSERT(nextents + ext_diff > XFS_LINEAR_EXTS);
3741                 if (ifp->if_flags & XFS_IFEXTIREC) {
3742                         erp = xfs_iext_idx_to_irec(ifp, &page_idx, &erp_idx, 1);
3743                 } else {
3744                         xfs_iext_irec_init(ifp);
3745                         ASSERT(ifp->if_flags & XFS_IFEXTIREC);
3746                         erp = ifp->if_u1.if_ext_irec;
3747                 }
3748                 /* Extents fit in target extent page */
3749                 if (erp && erp->er_extcount + ext_diff <= XFS_LINEAR_EXTS) {
3750                         if (page_idx < erp->er_extcount) {
3751                                 memmove(&erp->er_extbuf[page_idx + ext_diff],
3752                                         &erp->er_extbuf[page_idx],
3753                                         (erp->er_extcount - page_idx) *
3754                                         sizeof(xfs_bmbt_rec_t));
3755                                 memset(&erp->er_extbuf[page_idx], 0, byte_diff);
3756                         }
3757                         erp->er_extcount += ext_diff;
3758                         xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, ext_diff);
3759                 }
3760                 /* Insert a new extent page */
3761                 else if (erp) {
3762                         xfs_iext_add_indirect_multi(ifp,
3763                                 erp_idx, page_idx, ext_diff);
3764                 }
3765                 /*
3766                  * If extent(s) are being appended to the last page in
3767                  * the indirection array and the new extent(s) don't fit
3768                  * in the page, then erp is NULL and erp_idx is set to
3769                  * the next index needed in the indirection array.
3770                  */
3771                 else {
3772                         int     count = ext_diff;
3773
3774                         while (count) {
3775                                 erp = xfs_iext_irec_new(ifp, erp_idx);
3776                                 erp->er_extcount = count;
3777                                 count -= MIN(count, (int)XFS_LINEAR_EXTS);
3778                                 if (count) {
3779                                         erp_idx++;
3780                                 }
3781                         }
3782                 }
3783         }
3784         ifp->if_bytes = new_size;
3785 }
3786
3787 /*
3788  * This is called when incore extents are being added to the indirection
3789  * array and the new extents do not fit in the target extent list. The
3790  * erp_idx parameter contains the irec index for the target extent list
3791  * in the indirection array, and the idx parameter contains the extent
3792  * index within the list. The number of extents being added is stored
3793  * in the count parameter.
3794  *
3795  *    |-------|   |-------|
3796  *    |       |   |       |    idx - number of extents before idx
3797  *    |  idx  |   | count |
3798  *    |       |   |       |    count - number of extents being inserted at idx
3799  *    |-------|   |-------|
3800  *    | count |   | nex2  |    nex2 - number of extents after idx + count
3801  *    |-------|   |-------|
3802  */
3803 void
3804 xfs_iext_add_indirect_multi(
3805         xfs_ifork_t     *ifp,                   /* inode fork pointer */
3806         int             erp_idx,                /* target extent irec index */
3807         xfs_extnum_t    idx,                    /* index within target list */
3808         int             count)                  /* new extents being added */
3809 {
3810         int             byte_diff;              /* new bytes being added */
3811         xfs_ext_irec_t  *erp;                   /* pointer to irec entry */
3812         xfs_extnum_t    ext_diff;               /* number of extents to add */
3813         xfs_extnum_t    ext_cnt;                /* new extents still needed */
3814         xfs_extnum_t    nex2;                   /* extents after idx + count */
3815         xfs_bmbt_rec_t  *nex2_ep = NULL;        /* temp list for nex2 extents */
3816         int             nlists;                 /* number of irec's (lists) */
3817
3818         ASSERT(ifp->if_flags & XFS_IFEXTIREC);
3819         erp = &ifp->if_u1.if_ext_irec[erp_idx];
3820         nex2 = erp->er_extcount - idx;
3821         nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
3822
3823         /*
3824          * Save second part of target extent list
3825          * (all extents past */
3826         if (nex2) {
3827                 byte_diff = nex2 * sizeof(xfs_bmbt_rec_t);
3828                 nex2_ep = (xfs_bmbt_rec_t *) kmem_alloc(byte_diff, KM_SLEEP);
3829                 memmove(nex2_ep, &erp->er_extbuf[idx], byte_diff);
3830                 erp->er_extcount -= nex2;
3831                 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, -nex2);
3832                 memset(&erp->er_extbuf[idx], 0, byte_diff);
3833         }
3834
3835         /*
3836          * Add the new extents to the end of the target
3837          * list, then allocate new irec record(s) and
3838          * extent buffer(s) as needed to store the rest
3839          * of the new extents.
3840          */
3841         ext_cnt = count;
3842         ext_diff = MIN(ext_cnt, (int)XFS_LINEAR_EXTS - erp->er_extcount);
3843         if (ext_diff) {
3844                 erp->er_extcount += ext_diff;
3845                 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, ext_diff);
3846                 ext_cnt -= ext_diff;
3847         }
3848         while (ext_cnt) {
3849                 erp_idx++;
3850                 erp = xfs_iext_irec_new(ifp, erp_idx);
3851                 ext_diff = MIN(ext_cnt, (int)XFS_LINEAR_EXTS);
3852                 erp->er_extcount = ext_diff;
3853                 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, ext_diff);
3854                 ext_cnt -= ext_diff;
3855         }
3856
3857         /* Add nex2 extents back to indirection array */
3858         if (nex2) {
3859                 xfs_extnum_t    ext_avail;
3860                 int             i;
3861
3862                 byte_diff = nex2 * sizeof(xfs_bmbt_rec_t);
3863                 ext_avail = XFS_LINEAR_EXTS - erp->er_extcount;
3864                 i = 0;
3865                 /*
3866                  * If nex2 extents fit in the current page, append
3867                  * nex2_ep after the new extents.
3868                  */
3869                 if (nex2 <= ext_avail) {
3870                         i = erp->er_extcount;
3871                 }
3872                 /*
3873                  * Otherwise, check if space is available in the
3874                  * next page.
3875                  */
3876                 else if ((erp_idx < nlists - 1) &&
3877                          (nex2 <= (ext_avail = XFS_LINEAR_EXTS -
3878                           ifp->if_u1.if_ext_irec[erp_idx+1].er_extcount))) {
3879                         erp_idx++;
3880                         erp++;
3881                         /* Create a hole for nex2 extents */
3882                         memmove(&erp->er_extbuf[nex2], erp->er_extbuf,
3883                                 erp->er_extcount * sizeof(xfs_bmbt_rec_t));
3884                 }
3885                 /*
3886                  * Final choice, create a new extent page for
3887                  * nex2 extents.
3888                  */
3889                 else {
3890                         erp_idx++;
3891                         erp = xfs_iext_irec_new(ifp, erp_idx);
3892                 }
3893                 memmove(&erp->er_extbuf[i], nex2_ep, byte_diff);
3894                 kmem_free(nex2_ep, byte_diff);
3895                 erp->er_extcount += nex2;
3896                 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, nex2);
3897         }
3898 }
3899
3900 /*
3901  * This is called when the amount of space required for incore file
3902  * extents needs to be decreased. The ext_diff parameter stores the
3903  * number of extents to be removed and the idx parameter contains
3904  * the extent index where the extents will be removed from.
3905  *
3906  * If the amount of space needed has decreased below the linear
3907  * limit, XFS_IEXT_BUFSZ, then switch to using the contiguous
3908  * extent array.  Otherwise, use kmem_realloc() to adjust the
3909  * size to what is needed.
3910  */
3911 void
3912 xfs_iext_remove(
3913         xfs_ifork_t     *ifp,           /* inode fork pointer */
3914         xfs_extnum_t    idx,            /* index to begin removing exts */
3915         int             ext_diff)       /* number of extents to remove */
3916 {
3917         xfs_extnum_t    nextents;       /* number of extents in file */
3918         int             new_size;       /* size of extents after removal */
3919
3920         ASSERT(ext_diff > 0);
3921         nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
3922         new_size = (nextents - ext_diff) * sizeof(xfs_bmbt_rec_t);
3923
3924         if (new_size == 0) {
3925                 xfs_iext_destroy(ifp);
3926         } else if (ifp->if_flags & XFS_IFEXTIREC) {
3927                 xfs_iext_remove_indirect(ifp, idx, ext_diff);
3928         } else if (ifp->if_real_bytes) {
3929                 xfs_iext_remove_direct(ifp, idx, ext_diff);
3930         } else {
3931                 xfs_iext_remove_inline(ifp, idx, ext_diff);
3932         }
3933         ifp->if_bytes = new_size;
3934 }
3935
3936 /*
3937  * This removes ext_diff extents from the inline buffer, beginning
3938  * at extent index idx.
3939  */
3940 void
3941 xfs_iext_remove_inline(
3942         xfs_ifork_t     *ifp,           /* inode fork pointer */
3943         xfs_extnum_t    idx,            /* index to begin removing exts */
3944         int             ext_diff)       /* number of extents to remove */
3945 {
3946         int             nextents;       /* number of extents in file */
3947
3948         ASSERT(!(ifp->if_flags & XFS_IFEXTIREC));
3949         ASSERT(idx < XFS_INLINE_EXTS);
3950         nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
3951         ASSERT(((nextents - ext_diff) > 0) &&
3952                 (nextents - ext_diff) < XFS_INLINE_EXTS);
3953
3954         if (idx + ext_diff < nextents) {
3955                 memmove(&ifp->if_u2.if_inline_ext[idx],
3956                         &ifp->if_u2.if_inline_ext[idx + ext_diff],
3957                         (nextents - (idx + ext_diff)) *
3958                          sizeof(xfs_bmbt_rec_t));
3959                 memset(&ifp->if_u2.if_inline_ext[nextents - ext_diff],
3960                         0, ext_diff * sizeof(xfs_bmbt_rec_t));
3961         } else {
3962                 memset(&ifp->if_u2.if_inline_ext[idx], 0,
3963                         ext_diff * sizeof(xfs_bmbt_rec_t));
3964         }
3965 }
3966
3967 /*
3968  * This removes ext_diff extents from a linear (direct) extent list,
3969  * beginning at extent index idx. If the extents are being removed
3970  * from the end of the list (ie. truncate) then we just need to re-
3971  * allocate the list to remove the extra space. Otherwise, if the
3972  * extents are being removed from the middle of the existing extent
3973  * entries, then we first need to move the extent records beginning
3974  * at idx + ext_diff up in the list to overwrite the records being
3975  * removed, then remove the extra space via kmem_realloc.
3976  */
3977 void
3978 xfs_iext_remove_direct(
3979         xfs_ifork_t     *ifp,           /* inode fork pointer */
3980         xfs_extnum_t    idx,            /* index to begin removing exts */
3981         int             ext_diff)       /* number of extents to remove */
3982 {
3983         xfs_extnum_t    nextents;       /* number of extents in file */
3984         int             new_size;       /* size of extents after removal */
3985
3986         ASSERT(!(ifp->if_flags & XFS_IFEXTIREC));
3987         new_size = ifp->if_bytes -
3988                 (ext_diff * sizeof(xfs_bmbt_rec_t));
3989         nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
3990
3991         if (new_size == 0) {
3992                 xfs_iext_destroy(ifp);
3993                 return;
3994         }
3995         /* Move extents up in the list (if needed) */
3996         if (idx + ext_diff < nextents) {
3997                 memmove(&ifp->if_u1.if_extents[idx],
3998                         &ifp->if_u1.if_extents[idx + ext_diff],
3999                         (nextents - (idx + ext_diff)) *
4000                          sizeof(xfs_bmbt_rec_t));
4001         }
4002         memset(&ifp->if_u1.if_extents[nextents - ext_diff],
4003                 0, ext_diff * sizeof(xfs_bmbt_rec_t));
4004         /*
4005          * Reallocate the direct extent list. If the extents
4006          * will fit inside the inode then xfs_iext_realloc_direct
4007          * will switch from direct to inline extent allocation
4008          * mode for us.
4009          */
4010         xfs_iext_realloc_direct(ifp, new_size);
4011         ifp->if_bytes = new_size;
4012 }
4013
4014 /*
4015  * This is called when incore extents are being removed from the
4016  * indirection array and the extents being removed span multiple extent
4017  * buffers. The idx parameter contains the file extent index where we
4018  * want to begin removing extents, and the count parameter contains
4019  * how many extents need to be removed.
4020  *
4021  *    |-------|   |-------|
4022  *    | nex1  |   |       |    nex1 - number of extents before idx
4023  *    |-------|   | count |
4024  *    |       |   |       |    count - number of extents being removed at idx
4025  *    | count |   |-------|
4026  *    |       |   | nex2  |    nex2 - number of extents after idx + count
4027  *    |-------|   |-------|
4028  */
4029 void
4030 xfs_iext_remove_indirect(
4031         xfs_ifork_t     *ifp,           /* inode fork pointer */
4032         xfs_extnum_t    idx,            /* index to begin removing extents */
4033         int             count)          /* number of extents to remove */
4034 {
4035         xfs_ext_irec_t  *erp;           /* indirection array pointer */
4036         int             erp_idx = 0;    /* indirection array index */
4037         xfs_extnum_t    ext_cnt;        /* extents left to remove */
4038         xfs_extnum_t    ext_diff;       /* extents to remove in current list */
4039         xfs_extnum_t    nex1;           /* number of extents before idx */
4040         xfs_extnum_t    nex2;           /* extents after idx + count */
4041         int             nlists;         /* entries in indirection array */
4042         int             page_idx = idx; /* index in target extent list */
4043
4044         ASSERT(ifp->if_flags & XFS_IFEXTIREC);
4045         erp = xfs_iext_idx_to_irec(ifp,  &page_idx, &erp_idx, 0);
4046         ASSERT(erp != NULL);
4047         nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
4048         nex1 = page_idx;
4049         ext_cnt = count;
4050         while (ext_cnt) {
4051                 nex2 = MAX((erp->er_extcount - (nex1 + ext_cnt)), 0);
4052                 ext_diff = MIN(ext_cnt, (erp->er_extcount - nex1));
4053                 /*
4054                  * Check for deletion of entire list;
4055                  * xfs_iext_irec_remove() updates extent offsets.
4056                  */
4057                 if (ext_diff == erp->er_extcount) {
4058                         xfs_iext_irec_remove(ifp, erp_idx);
4059                         ext_cnt -= ext_diff;
4060                         nex1 = 0;
4061                         if (ext_cnt) {
4062                                 ASSERT(erp_idx < ifp->if_real_bytes /
4063                                         XFS_IEXT_BUFSZ);
4064                                 erp = &ifp->if_u1.if_ext_irec[erp_idx];
4065                                 nex1 = 0;
4066                                 continue;
4067                         } else {
4068                                 break;
4069                         }
4070                 }
4071                 /* Move extents up (if needed) */
4072                 if (nex2) {
4073                         memmove(&erp->er_extbuf[nex1],
4074                                 &erp->er_extbuf[nex1 + ext_diff],
4075                                 nex2 * sizeof(xfs_bmbt_rec_t));
4076                 }
4077                 /* Zero out rest of page */
4078                 memset(&erp->er_extbuf[nex1 + nex2], 0, (XFS_IEXT_BUFSZ -
4079                         ((nex1 + nex2) * sizeof(xfs_bmbt_rec_t))));
4080                 /* Update remaining counters */
4081                 erp->er_extcount -= ext_diff;
4082                 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, -ext_diff);
4083                 ext_cnt -= ext_diff;
4084                 nex1 = 0;
4085                 erp_idx++;
4086                 erp++;
4087         }
4088         ifp->if_bytes -= count * sizeof(xfs_bmbt_rec_t);
4089         xfs_iext_irec_compact(ifp);
4090 }
4091
4092 /*
4093  * Create, destroy, or resize a linear (direct) block of extents.
4094  */
4095 void
4096 xfs_iext_realloc_direct(
4097         xfs_ifork_t     *ifp,           /* inode fork pointer */
4098         int             new_size)       /* new size of extents */
4099 {
4100         int             rnew_size;      /* real new size of extents */
4101
4102         rnew_size = new_size;
4103
4104         ASSERT(!(ifp->if_flags & XFS_IFEXTIREC) ||
4105                 ((new_size >= 0) && (new_size <= XFS_IEXT_BUFSZ) &&
4106                  (new_size != ifp->if_real_bytes)));
4107
4108         /* Free extent records */
4109         if (new_size == 0) {
4110                 xfs_iext_destroy(ifp);
4111         }
4112         /* Resize direct extent list and zero any new bytes */
4113         else if (ifp->if_real_bytes) {
4114                 /* Check if extents will fit inside the inode */
4115                 if (new_size <= XFS_INLINE_EXTS * sizeof(xfs_bmbt_rec_t)) {
4116                         xfs_iext_direct_to_inline(ifp, new_size /
4117                                 (uint)sizeof(xfs_bmbt_rec_t));
4118                         ifp->if_bytes = new_size;
4119                         return;
4120                 }
4121                 if ((new_size & (new_size - 1)) != 0) {
4122                         rnew_size = xfs_iroundup(new_size);
4123                 }
4124                 if (rnew_size != ifp->if_real_bytes) {
4125                         ifp->if_u1.if_extents = (xfs_bmbt_rec_t *)
4126                                 kmem_realloc(ifp->if_u1.if_extents,
4127                                                 rnew_size,
4128                                                 ifp->if_real_bytes,
4129                                                 KM_SLEEP);
4130                 }
4131                 if (rnew_size > ifp->if_real_bytes) {
4132                         memset(&ifp->if_u1.if_extents[ifp->if_bytes /
4133                                 (uint)sizeof(xfs_bmbt_rec_t)], 0,
4134                                 rnew_size - ifp->if_real_bytes);
4135                 }
4136         }
4137         /*
4138          * Switch from the inline extent buffer to a direct
4139          * extent list. Be sure to include the inline extent
4140          * bytes in new_size.
4141          */
4142         else {
4143                 new_size += ifp->if_bytes;
4144                 if ((new_size & (new_size - 1)) != 0) {
4145                         rnew_size = xfs_iroundup(new_size);
4146                 }
4147                 xfs_iext_inline_to_direct(ifp, rnew_size);
4148         }
4149         ifp->if_real_bytes = rnew_size;
4150         ifp->if_bytes = new_size;
4151 }
4152
4153 /*
4154  * Switch from linear (direct) extent records to inline buffer.
4155  */
4156 void
4157 xfs_iext_direct_to_inline(
4158         xfs_ifork_t     *ifp,           /* inode fork pointer */
4159         xfs_extnum_t    nextents)       /* number of extents in file */
4160 {
4161         ASSERT(ifp->if_flags & XFS_IFEXTENTS);
4162         ASSERT(nextents <= XFS_INLINE_EXTS);
4163         /*
4164          * The inline buffer was zeroed when we switched
4165          * from inline to direct extent allocation mode,
4166          * so we don't need to clear it here.
4167          */
4168         memcpy(ifp->if_u2.if_inline_ext, ifp->if_u1.if_extents,
4169                 nextents * sizeof(xfs_bmbt_rec_t));
4170         kmem_free(ifp->if_u1.if_extents, KM_SLEEP);
4171         ifp->if_u1.if_extents = ifp->if_u2.if_inline_ext;
4172         ifp->if_real_bytes = 0;
4173 }
4174
4175 /*
4176  * Switch from inline buffer to linear (direct) extent records.
4177  * new_size should already be rounded up to the next power of 2
4178  * by the caller (when appropriate), so use new_size as it is.
4179  * However, since new_size may be rounded up, we can't update
4180  * if_bytes here. It is the caller's responsibility to update
4181  * if_bytes upon return.
4182  */
4183 void
4184 xfs_iext_inline_to_direct(
4185         xfs_ifork_t     *ifp,           /* inode fork pointer */
4186         int             new_size)       /* number of extents in file */
4187 {
4188         ifp->if_u1.if_extents = (xfs_bmbt_rec_t *)
4189                 kmem_alloc(new_size, KM_SLEEP);
4190         memset(ifp->if_u1.if_extents, 0, new_size);
4191         if (ifp->if_bytes) {
4192                 memcpy(ifp->if_u1.if_extents, ifp->if_u2.if_inline_ext,
4193                         ifp->if_bytes);
4194                 memset(ifp->if_u2.if_inline_ext, 0, XFS_INLINE_EXTS *
4195                         sizeof(xfs_bmbt_rec_t));
4196         }
4197         ifp->if_real_bytes = new_size;
4198 }
4199
4200 /*
4201  * Resize an extent indirection array to new_size bytes.
4202  */
4203 void
4204 xfs_iext_realloc_indirect(
4205         xfs_ifork_t     *ifp,           /* inode fork pointer */
4206         int             new_size)       /* new indirection array size */
4207 {
4208         int             nlists;         /* number of irec's (ex lists) */
4209         int             size;           /* current indirection array size */
4210
4211         ASSERT(ifp->if_flags & XFS_IFEXTIREC);
4212         nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
4213         size = nlists * sizeof(xfs_ext_irec_t);
4214         ASSERT(ifp->if_real_bytes);
4215         ASSERT((new_size >= 0) && (new_size != size));
4216         if (new_size == 0) {
4217                 xfs_iext_destroy(ifp);
4218         } else {
4219                 ifp->if_u1.if_ext_irec = (xfs_ext_irec_t *)
4220                         kmem_realloc(ifp->if_u1.if_ext_irec,
4221                                 new_size, size, KM_SLEEP);
4222         }
4223 }
4224
4225 /*
4226  * Switch from indirection array to linear (direct) extent allocations.
4227  */
4228 void
4229 xfs_iext_indirect_to_direct(
4230          xfs_ifork_t    *ifp)           /* inode fork pointer */
4231 {
4232         xfs_bmbt_rec_t  *ep;            /* extent record pointer */
4233         xfs_extnum_t    nextents;       /* number of extents in file */
4234         int             size;           /* size of file extents */
4235
4236         ASSERT(ifp->if_flags & XFS_IFEXTIREC);
4237         nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
4238         ASSERT(nextents <= XFS_LINEAR_EXTS);
4239         size = nextents * sizeof(xfs_bmbt_rec_t);
4240
4241         xfs_iext_irec_compact_full(ifp);
4242         ASSERT(ifp->if_real_bytes == XFS_IEXT_BUFSZ);
4243
4244         ep = ifp->if_u1.if_ext_irec->er_extbuf;
4245         kmem_free(ifp->if_u1.if_ext_irec, sizeof(xfs_ext_irec_t));
4246         ifp->if_flags &= ~XFS_IFEXTIREC;
4247         ifp->if_u1.if_extents = ep;
4248         ifp->if_bytes = size;
4249         if (nextents < XFS_LINEAR_EXTS) {
4250                 xfs_iext_realloc_direct(ifp, size);
4251         }
4252 }
4253
4254 /*
4255  * Free incore file extents.
4256  */
4257 void
4258 xfs_iext_destroy(
4259         xfs_ifork_t     *ifp)           /* inode fork pointer */
4260 {
4261         if (ifp->if_flags & XFS_IFEXTIREC) {
4262                 int     erp_idx;
4263                 int     nlists;
4264
4265                 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
4266                 for (erp_idx = nlists - 1; erp_idx >= 0 ; erp_idx--) {
4267                         xfs_iext_irec_remove(ifp, erp_idx);
4268                 }
4269                 ifp->if_flags &= ~XFS_IFEXTIREC;
4270         } else if (ifp->if_real_bytes) {
4271                 kmem_free(ifp->if_u1.if_extents, ifp->if_real_bytes);
4272         } else if (ifp->if_bytes) {
4273                 memset(ifp->if_u2.if_inline_ext, 0, XFS_INLINE_EXTS *
4274                         sizeof(xfs_bmbt_rec_t));
4275         }
4276         ifp->if_u1.if_extents = NULL;
4277         ifp->if_real_bytes = 0;
4278         ifp->if_bytes = 0;
4279 }
4280
4281 /*
4282  * Return a pointer to the extent record for file system block bno.
4283  */
4284 xfs_bmbt_rec_t *                        /* pointer to found extent record */
4285 xfs_iext_bno_to_ext(
4286         xfs_ifork_t     *ifp,           /* inode fork pointer */
4287         xfs_fileoff_t   bno,            /* block number to search for */
4288         xfs_extnum_t    *idxp)          /* index of target extent */
4289 {
4290         xfs_bmbt_rec_t  *base;          /* pointer to first extent */
4291         xfs_filblks_t   blockcount = 0; /* number of blocks in extent */
4292         xfs_bmbt_rec_t  *ep = NULL;     /* pointer to target extent */
4293         xfs_ext_irec_t  *erp = NULL;    /* indirection array pointer */
4294         int             high;           /* upper boundary in search */
4295         xfs_extnum_t    idx = 0;        /* index of target extent */
4296         int             low;            /* lower boundary in search */
4297         xfs_extnum_t    nextents;       /* number of file extents */
4298         xfs_fileoff_t   startoff = 0;   /* start offset of extent */
4299
4300         nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
4301         if (nextents == 0) {
4302                 *idxp = 0;
4303                 return NULL;
4304         }
4305         low = 0;
4306         if (ifp->if_flags & XFS_IFEXTIREC) {
4307                 /* Find target extent list */
4308                 int     erp_idx = 0;
4309                 erp = xfs_iext_bno_to_irec(ifp, bno, &erp_idx);
4310                 base = erp->er_extbuf;
4311                 high = erp->er_extcount - 1;
4312         } else {
4313                 base = ifp->if_u1.if_extents;
4314                 high = nextents - 1;
4315         }
4316         /* Binary search extent records */
4317         while (low <= high) {
4318                 idx = (low + high) >> 1;
4319                 ep = base + idx;
4320                 startoff = xfs_bmbt_get_startoff(ep);
4321                 blockcount = xfs_bmbt_get_blockcount(ep);
4322                 if (bno < startoff) {
4323                         high = idx - 1;
4324                 } else if (bno >= startoff + blockcount) {
4325                         low = idx + 1;
4326                 } else {
4327                         /* Convert back to file-based extent index */
4328                         if (ifp->if_flags & XFS_IFEXTIREC) {
4329                                 idx += erp->er_extoff;
4330                         }
4331                         *idxp = idx;
4332                         return ep;
4333                 }
4334         }
4335         /* Convert back to file-based extent index */
4336         if (ifp->if_flags & XFS_IFEXTIREC) {
4337                 idx += erp->er_extoff;
4338         }
4339         if (bno >= startoff + blockcount) {
4340                 if (++idx == nextents) {
4341                         ep = NULL;
4342                 } else {
4343                         ep = xfs_iext_get_ext(ifp, idx);
4344                 }
4345         }
4346         *idxp = idx;
4347         return ep;
4348 }
4349
4350 /*
4351  * Return a pointer to the indirection array entry containing the
4352  * extent record for filesystem block bno. Store the index of the
4353  * target irec in *erp_idxp.
4354  */
4355 xfs_ext_irec_t *                        /* pointer to found extent record */
4356 xfs_iext_bno_to_irec(
4357         xfs_ifork_t     *ifp,           /* inode fork pointer */
4358         xfs_fileoff_t   bno,            /* block number to search for */
4359         int             *erp_idxp)      /* irec index of target ext list */
4360 {
4361         xfs_ext_irec_t  *erp = NULL;    /* indirection array pointer */
4362         xfs_ext_irec_t  *erp_next;      /* next indirection array entry */
4363         int             erp_idx;        /* indirection array index */
4364         int             nlists;         /* number of extent irec's (lists) */
4365         int             high;           /* binary search upper limit */
4366         int             low;            /* binary search lower limit */
4367
4368         ASSERT(ifp->if_flags & XFS_IFEXTIREC);
4369         nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
4370         erp_idx = 0;
4371         low = 0;
4372         high = nlists - 1;
4373         while (low <= high) {
4374                 erp_idx = (low + high) >> 1;
4375                 erp = &ifp->if_u1.if_ext_irec[erp_idx];
4376                 erp_next = erp_idx < nlists - 1 ? erp + 1 : NULL;
4377                 if (bno < xfs_bmbt_get_startoff(erp->er_extbuf)) {
4378                         high = erp_idx - 1;
4379                 } else if (erp_next && bno >=
4380                            xfs_bmbt_get_startoff(erp_next->er_extbuf)) {
4381                         low = erp_idx + 1;
4382                 } else {
4383                         break;
4384                 }
4385         }
4386         *erp_idxp = erp_idx;
4387         return erp;
4388 }
4389
4390 /*
4391  * Return a pointer to the indirection array entry containing the
4392  * extent record at file extent index *idxp. Store the index of the
4393  * target irec in *erp_idxp and store the page index of the target
4394  * extent record in *idxp.
4395  */
4396 xfs_ext_irec_t *
4397 xfs_iext_idx_to_irec(
4398         xfs_ifork_t     *ifp,           /* inode fork pointer */
4399         xfs_extnum_t    *idxp,          /* extent index (file -> page) */
4400         int             *erp_idxp,      /* pointer to target irec */
4401         int             realloc)        /* new bytes were just added */
4402 {
4403         xfs_ext_irec_t  *prev;          /* pointer to previous irec */
4404         xfs_ext_irec_t  *erp = NULL;    /* pointer to current irec */
4405         int             erp_idx;        /* indirection array index */
4406         int             nlists;         /* number of irec's (ex lists) */
4407         int             high;           /* binary search upper limit */
4408         int             low;            /* binary search lower limit */
4409         xfs_extnum_t    page_idx = *idxp; /* extent index in target list */
4410
4411         ASSERT(ifp->if_flags & XFS_IFEXTIREC);
4412         ASSERT(page_idx >= 0 && page_idx <=
4413                 ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t));
4414         nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
4415         erp_idx = 0;
4416         low = 0;
4417         high = nlists - 1;
4418
4419         /* Binary search extent irec's */
4420         while (low <= high) {
4421                 erp_idx = (low + high) >> 1;
4422                 erp = &ifp->if_u1.if_ext_irec[erp_idx];
4423                 prev = erp_idx > 0 ? erp - 1 : NULL;
4424                 if (page_idx < erp->er_extoff || (page_idx == erp->er_extoff &&
4425                      realloc && prev && prev->er_extcount < XFS_LINEAR_EXTS)) {
4426                         high = erp_idx - 1;
4427                 } else if (page_idx > erp->er_extoff + erp->er_extcount ||
4428                            (page_idx == erp->er_extoff + erp->er_extcount &&
4429                             !realloc)) {
4430                         low = erp_idx + 1;
4431                 } else if (page_idx == erp->er_extoff + erp->er_extcount &&
4432                            erp->er_extcount == XFS_LINEAR_EXTS) {
4433                         ASSERT(realloc);
4434                         page_idx = 0;
4435                         erp_idx++;
4436                         erp = erp_idx < nlists ? erp + 1 : NULL;
4437                         break;
4438                 } else {
4439                         page_idx -= erp->er_extoff;
4440                         break;
4441                 }
4442         }
4443         *idxp = page_idx;
4444         *erp_idxp = erp_idx;
4445         return(erp);
4446 }
4447
4448 /*
4449  * Allocate and initialize an indirection array once the space needed
4450  * for incore extents increases above XFS_IEXT_BUFSZ.
4451  */
4452 void
4453 xfs_iext_irec_init(
4454         xfs_ifork_t     *ifp)           /* inode fork pointer */
4455 {
4456         xfs_ext_irec_t  *erp;           /* indirection array pointer */
4457         xfs_extnum_t    nextents;       /* number of extents in file */
4458
4459         ASSERT(!(ifp->if_flags & XFS_IFEXTIREC));
4460         nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
4461         ASSERT(nextents <= XFS_LINEAR_EXTS);
4462
4463         erp = (xfs_ext_irec_t *)
4464                 kmem_alloc(sizeof(xfs_ext_irec_t), KM_SLEEP);
4465
4466         if (nextents == 0) {
4467                 ifp->if_u1.if_extents = (xfs_bmbt_rec_t *)
4468                         kmem_alloc(XFS_IEXT_BUFSZ, KM_SLEEP);
4469         } else if (!ifp->if_real_bytes) {
4470                 xfs_iext_inline_to_direct(ifp, XFS_IEXT_BUFSZ);
4471         } else if (ifp->if_real_bytes < XFS_IEXT_BUFSZ) {
4472                 xfs_iext_realloc_direct(ifp, XFS_IEXT_BUFSZ);
4473         }
4474         erp->er_extbuf = ifp->if_u1.if_extents;
4475         erp->er_extcount = nextents;
4476         erp->er_extoff = 0;
4477
4478         ifp->if_flags |= XFS_IFEXTIREC;
4479         ifp->if_real_bytes = XFS_IEXT_BUFSZ;
4480         ifp->if_bytes = nextents * sizeof(xfs_bmbt_rec_t);
4481         ifp->if_u1.if_ext_irec = erp;
4482
4483         return;
4484 }
4485
4486 /*
4487  * Allocate and initialize a new entry in the indirection array.
4488  */
4489 xfs_ext_irec_t *
4490 xfs_iext_irec_new(
4491         xfs_ifork_t     *ifp,           /* inode fork pointer */
4492         int             erp_idx)        /* index for new irec */
4493 {
4494         xfs_ext_irec_t  *erp;           /* indirection array pointer */
4495         int             i;              /* loop counter */
4496         int             nlists;         /* number of irec's (ex lists) */
4497
4498         ASSERT(ifp->if_flags & XFS_IFEXTIREC);
4499         nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
4500
4501         /* Resize indirection array */
4502         xfs_iext_realloc_indirect(ifp, ++nlists *
4503                                   sizeof(xfs_ext_irec_t));
4504         /*
4505          * Move records down in the array so the
4506          * new page can use erp_idx.
4507          */
4508         erp = ifp->if_u1.if_ext_irec;
4509         for (i = nlists - 1; i > erp_idx; i--) {
4510                 memmove(&erp[i], &erp[i-1], sizeof(xfs_ext_irec_t));
4511         }
4512         ASSERT(i == erp_idx);
4513
4514         /* Initialize new extent record */
4515         erp = ifp->if_u1.if_ext_irec;
4516         erp[erp_idx].er_extbuf = (xfs_bmbt_rec_t *)
4517                 kmem_alloc(XFS_IEXT_BUFSZ, KM_SLEEP);
4518         ifp->if_real_bytes = nlists * XFS_IEXT_BUFSZ;
4519         memset(erp[erp_idx].er_extbuf, 0, XFS_IEXT_BUFSZ);
4520         erp[erp_idx].er_extcount = 0;
4521         erp[erp_idx].er_extoff = erp_idx > 0 ?
4522                 erp[erp_idx-1].er_extoff + erp[erp_idx-1].er_extcount : 0;
4523         return (&erp[erp_idx]);
4524 }
4525
4526 /*
4527  * Remove a record from the indirection array.
4528  */
4529 void
4530 xfs_iext_irec_remove(
4531         xfs_ifork_t     *ifp,           /* inode fork pointer */
4532         int             erp_idx)        /* irec index to remove */
4533 {
4534         xfs_ext_irec_t  *erp;           /* indirection array pointer */
4535         int             i;              /* loop counter */
4536         int             nlists;         /* number of irec's (ex lists) */
4537
4538         ASSERT(ifp->if_flags & XFS_IFEXTIREC);
4539         nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
4540         erp = &ifp->if_u1.if_ext_irec[erp_idx];
4541         if (erp->er_extbuf) {
4542                 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1,
4543                         -erp->er_extcount);
4544                 kmem_free(erp->er_extbuf, XFS_IEXT_BUFSZ);
4545         }
4546         /* Compact extent records */
4547         erp = ifp->if_u1.if_ext_irec;
4548         for (i = erp_idx; i < nlists - 1; i++) {
4549                 memmove(&erp[i], &erp[i+1], sizeof(xfs_ext_irec_t));
4550         }
4551         /*
4552          * Manually free the last extent record from the indirection
4553          * array.  A call to xfs_iext_realloc_indirect() with a size
4554          * of zero would result in a call to xfs_iext_destroy() which
4555          * would in turn call this function again, creating a nasty
4556          * infinite loop.
4557          */
4558         if (--nlists) {
4559                 xfs_iext_realloc_indirect(ifp,
4560                         nlists * sizeof(xfs_ext_irec_t));
4561         } else {
4562                 kmem_free(ifp->if_u1.if_ext_irec,
4563                         sizeof(xfs_ext_irec_t));
4564         }
4565         ifp->if_real_bytes = nlists * XFS_IEXT_BUFSZ;
4566 }
4567
4568 /*
4569  * This is called to clean up large amounts of unused memory allocated
4570  * by the indirection array.  Before compacting anything though, verify
4571  * that the indirection array is still needed and switch back to the
4572  * linear extent list (or even the inline buffer) if possible.  The
4573  * compaction policy is as follows:
4574  *
4575  *    Full Compaction: Extents fit into a single page (or inline buffer)
4576  *    Full Compaction: Extents occupy less than 10% of allocated space
4577  * Partial Compaction: Extents occupy > 10% and < 50% of allocated space
4578  *      No Compaction: Extents occupy at least 50% of allocated space
4579  */
4580 void
4581 xfs_iext_irec_compact(
4582         xfs_ifork_t     *ifp)           /* inode fork pointer */
4583 {
4584         xfs_extnum_t    nextents;       /* number of extents in file */
4585         int             nlists;         /* number of irec's (ex lists) */
4586
4587         ASSERT(ifp->if_flags & XFS_IFEXTIREC);
4588         nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
4589         nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
4590
4591         if (nextents == 0) {
4592                 xfs_iext_destroy(ifp);
4593         } else if (nextents <= XFS_INLINE_EXTS) {
4594                 xfs_iext_indirect_to_direct(ifp);
4595                 xfs_iext_direct_to_inline(ifp, nextents);
4596         } else if (nextents <= XFS_LINEAR_EXTS) {
4597                 xfs_iext_indirect_to_direct(ifp);
4598         } else if (nextents < (nlists * XFS_LINEAR_EXTS) >> 3) {
4599                 xfs_iext_irec_compact_full(ifp);
4600         } else if (nextents < (nlists * XFS_LINEAR_EXTS) >> 1) {
4601                 xfs_iext_irec_compact_pages(ifp);
4602         }
4603 }
4604
4605 /*
4606  * Combine extents from neighboring extent pages.
4607  */
4608 void
4609 xfs_iext_irec_compact_pages(
4610         xfs_ifork_t     *ifp)           /* inode fork pointer */
4611 {
4612         xfs_ext_irec_t  *erp, *erp_next;/* pointers to irec entries */
4613         int             erp_idx = 0;    /* indirection array index */
4614         int             nlists;         /* number of irec's (ex lists) */
4615
4616         ASSERT(ifp->if_flags & XFS_IFEXTIREC);
4617         nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
4618         while (erp_idx < nlists - 1) {
4619                 erp = &ifp->if_u1.if_ext_irec[erp_idx];
4620                 erp_next = erp + 1;
4621                 if (erp_next->er_extcount <=
4622                     (XFS_LINEAR_EXTS - erp->er_extcount)) {
4623                         memmove(&erp->er_extbuf[erp->er_extcount],
4624                                 erp_next->er_extbuf, erp_next->er_extcount *
4625                                 sizeof(xfs_bmbt_rec_t));
4626                         erp->er_extcount += erp_next->er_extcount;
4627                         /*
4628                          * Free page before removing extent record
4629                          * so er_extoffs don't get modified in
4630                          * xfs_iext_irec_remove.
4631                          */
4632                         kmem_free(erp_next->er_extbuf, XFS_IEXT_BUFSZ);
4633                         erp_next->er_extbuf = NULL;
4634                         xfs_iext_irec_remove(ifp, erp_idx + 1);
4635                         nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
4636                 } else {
4637                         erp_idx++;
4638                 }
4639         }
4640 }
4641
4642 /*
4643  * Fully compact the extent records managed by the indirection array.
4644  */
4645 void
4646 xfs_iext_irec_compact_full(
4647         xfs_ifork_t     *ifp)                   /* inode fork pointer */
4648 {
4649         xfs_bmbt_rec_t  *ep, *ep_next;          /* extent record pointers */
4650         xfs_ext_irec_t  *erp, *erp_next;        /* extent irec pointers */
4651         int             erp_idx = 0;            /* extent irec index */
4652         int             ext_avail;              /* empty entries in ex list */
4653         int             ext_diff;               /* number of exts to add */
4654         int             nlists;                 /* number of irec's (ex lists) */
4655
4656         ASSERT(ifp->if_flags & XFS_IFEXTIREC);
4657         nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
4658         erp = ifp->if_u1.if_ext_irec;
4659         ep = &erp->er_extbuf[erp->er_extcount];
4660         erp_next = erp + 1;
4661         ep_next = erp_next->er_extbuf;
4662         while (erp_idx < nlists - 1) {
4663                 ext_avail = XFS_LINEAR_EXTS - erp->er_extcount;
4664                 ext_diff = MIN(ext_avail, erp_next->er_extcount);
4665                 memcpy(ep, ep_next, ext_diff * sizeof(xfs_bmbt_rec_t));
4666                 erp->er_extcount += ext_diff;
4667                 erp_next->er_extcount -= ext_diff;
4668                 /* Remove next page */
4669                 if (erp_next->er_extcount == 0) {
4670                         /*
4671                          * Free page before removing extent record
4672                          * so er_extoffs don't get modified in
4673                          * xfs_iext_irec_remove.
4674                          */
4675                         kmem_free(erp_next->er_extbuf,
4676                                 erp_next->er_extcount * sizeof(xfs_bmbt_rec_t));
4677                         erp_next->er_extbuf = NULL;
4678                         xfs_iext_irec_remove(ifp, erp_idx + 1);
4679                         erp = &ifp->if_u1.if_ext_irec[erp_idx];
4680                         nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
4681                 /* Update next page */
4682                 } else {
4683                         /* Move rest of page up to become next new page */
4684                         memmove(erp_next->er_extbuf, ep_next,
4685                                 erp_next->er_extcount * sizeof(xfs_bmbt_rec_t));
4686                         ep_next = erp_next->er_extbuf;
4687                         memset(&ep_next[erp_next->er_extcount], 0,
4688                                 (XFS_LINEAR_EXTS - erp_next->er_extcount) *
4689                                 sizeof(xfs_bmbt_rec_t));
4690                 }
4691                 if (erp->er_extcount == XFS_LINEAR_EXTS) {
4692                         erp_idx++;
4693                         if (erp_idx < nlists)
4694                                 erp = &ifp->if_u1.if_ext_irec[erp_idx];
4695                         else
4696                                 break;
4697                 }
4698                 ep = &erp->er_extbuf[erp->er_extcount];
4699                 erp_next = erp + 1;
4700                 ep_next = erp_next->er_extbuf;
4701         }
4702 }
4703
4704 /*
4705  * This is called to update the er_extoff field in the indirection
4706  * array when extents have been added or removed from one of the
4707  * extent lists. erp_idx contains the irec index to begin updating
4708  * at and ext_diff contains the number of extents that were added
4709  * or removed.
4710  */
4711 void
4712 xfs_iext_irec_update_extoffs(
4713         xfs_ifork_t     *ifp,           /* inode fork pointer */
4714         int             erp_idx,        /* irec index to update */
4715         int             ext_diff)       /* number of new extents */
4716 {
4717         int             i;              /* loop counter */
4718         int             nlists;         /* number of irec's (ex lists */
4719
4720         ASSERT(ifp->if_flags & XFS_IFEXTIREC);
4721         nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
4722         for (i = erp_idx; i < nlists; i++) {
4723                 ifp->if_u1.if_ext_irec[i].er_extoff += ext_diff;
4724         }
4725 }