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