blob: efac8857ccb17315c3b8ae837db714db2e245c64 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Olaf Weber3e57ecf2006-06-09 14:48:12 +10002 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
Nathan Scott7b718762005-11-02 14:58:39 +11003 * All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
Nathan Scott7b718762005-11-02 14:58:39 +11005 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * published by the Free Software Foundation.
8 *
Nathan Scott7b718762005-11-02 14:58:39 +11009 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
Nathan Scott7b718762005-11-02 14:58:39 +110014 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 */
Robert P. J. Day40ebd812007-11-23 16:30:51 +110018#include <linux/log2.h>
19
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include "xfs.h"
Nathan Scotta844f452005-11-02 14:38:42 +110021#include "xfs_fs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include "xfs_types.h"
Nathan Scotta844f452005-11-02 14:38:42 +110023#include "xfs_bit.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include "xfs_log.h"
Nathan Scotta844f452005-11-02 14:38:42 +110025#include "xfs_inum.h"
26#include "xfs_imap.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include "xfs_trans.h"
28#include "xfs_trans_priv.h"
29#include "xfs_sb.h"
30#include "xfs_ag.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include "xfs_dir2.h"
32#include "xfs_dmapi.h"
33#include "xfs_mount.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include "xfs_bmap_btree.h"
Nathan Scotta844f452005-11-02 14:38:42 +110035#include "xfs_alloc_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include "xfs_ialloc_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include "xfs_dir2_sf.h"
Nathan Scotta844f452005-11-02 14:38:42 +110038#include "xfs_attr_sf.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include "xfs_dinode.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include "xfs_inode.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include "xfs_buf_item.h"
Nathan Scotta844f452005-11-02 14:38:42 +110042#include "xfs_inode_item.h"
43#include "xfs_btree.h"
44#include "xfs_alloc.h"
45#include "xfs_ialloc.h"
46#include "xfs_bmap.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070047#include "xfs_rw.h"
48#include "xfs_error.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070049#include "xfs_utils.h"
50#include "xfs_dir2_trace.h"
51#include "xfs_quota.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070052#include "xfs_acl.h"
David Chinner2a82b8b2007-07-11 11:09:12 +100053#include "xfs_filestream.h"
Christoph Hellwig739bfb22007-08-29 10:58:01 +100054#include "xfs_vnodeops.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
Linus Torvalds1da177e2005-04-16 15:20:36 -070056kmem_zone_t *xfs_ifork_zone;
57kmem_zone_t *xfs_inode_zone;
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
59/*
60 * Used in xfs_itruncate(). This is the maximum number of extents
61 * freed from a file in a single transaction.
62 */
63#define XFS_ITRUNC_MAX_EXTENTS 2
64
65STATIC int xfs_iflush_int(xfs_inode_t *, xfs_buf_t *);
66STATIC int xfs_iformat_local(xfs_inode_t *, xfs_dinode_t *, int, int);
67STATIC int xfs_iformat_extents(xfs_inode_t *, xfs_dinode_t *, int);
68STATIC int xfs_iformat_btree(xfs_inode_t *, xfs_dinode_t *, int);
69
Linus Torvalds1da177e2005-04-16 15:20:36 -070070#ifdef DEBUG
71/*
72 * Make sure that the extents in the given memory buffer
73 * are valid.
74 */
75STATIC void
76xfs_validate_extents(
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +110077 xfs_ifork_t *ifp,
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 int nrecs,
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 xfs_exntfmt_t fmt)
80{
81 xfs_bmbt_irec_t irec;
Christoph Hellwiga6f64d42007-08-16 16:23:40 +100082 xfs_bmbt_rec_host_t rec;
Linus Torvalds1da177e2005-04-16 15:20:36 -070083 int i;
84
85 for (i = 0; i < nrecs; i++) {
Christoph Hellwiga6f64d42007-08-16 16:23:40 +100086 xfs_bmbt_rec_host_t *ep = xfs_iext_get_ext(ifp, i);
87 rec.l0 = get_unaligned(&ep->l0);
88 rec.l1 = get_unaligned(&ep->l1);
89 xfs_bmbt_get_all(&rec, &irec);
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 if (fmt == XFS_EXTFMT_NOSTATE)
91 ASSERT(irec.br_state == XFS_EXT_NORM);
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 }
93}
94#else /* DEBUG */
Christoph Hellwiga6f64d42007-08-16 16:23:40 +100095#define xfs_validate_extents(ifp, nrecs, fmt)
Linus Torvalds1da177e2005-04-16 15:20:36 -070096#endif /* DEBUG */
97
98/*
99 * Check that none of the inode's in the buffer have a next
100 * unlinked field of 0.
101 */
102#if defined(DEBUG)
103void
104xfs_inobp_check(
105 xfs_mount_t *mp,
106 xfs_buf_t *bp)
107{
108 int i;
109 int j;
110 xfs_dinode_t *dip;
111
112 j = mp->m_inode_cluster_size >> mp->m_sb.sb_inodelog;
113
114 for (i = 0; i < j; i++) {
115 dip = (xfs_dinode_t *)xfs_buf_offset(bp,
116 i * mp->m_sb.sb_inodesize);
117 if (!dip->di_next_unlinked) {
118 xfs_fs_cmn_err(CE_ALERT, mp,
119 "Detected a bogus zero next_unlinked field in incore inode buffer 0x%p. About to pop an ASSERT.",
120 bp);
121 ASSERT(dip->di_next_unlinked);
122 }
123 }
124}
125#endif
126
127/*
David Chinner4ae29b42008-03-06 13:43:34 +1100128 * Find the buffer associated with the given inode map
129 * We do basic validation checks on the buffer once it has been
130 * retrieved from disk.
131 */
132STATIC int
133xfs_imap_to_bp(
134 xfs_mount_t *mp,
135 xfs_trans_t *tp,
136 xfs_imap_t *imap,
137 xfs_buf_t **bpp,
138 uint buf_flags,
139 uint imap_flags)
140{
141 int error;
142 int i;
143 int ni;
144 xfs_buf_t *bp;
145
146 error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, imap->im_blkno,
David Chinnera3f74ff2008-03-06 13:43:42 +1100147 (int)imap->im_len, buf_flags, &bp);
David Chinner4ae29b42008-03-06 13:43:34 +1100148 if (error) {
David Chinnera3f74ff2008-03-06 13:43:42 +1100149 if (error != EAGAIN) {
150 cmn_err(CE_WARN,
151 "xfs_imap_to_bp: xfs_trans_read_buf()returned "
David Chinner4ae29b42008-03-06 13:43:34 +1100152 "an error %d on %s. Returning error.",
153 error, mp->m_fsname);
David Chinnera3f74ff2008-03-06 13:43:42 +1100154 } else {
155 ASSERT(buf_flags & XFS_BUF_TRYLOCK);
156 }
David Chinner4ae29b42008-03-06 13:43:34 +1100157 return error;
158 }
159
160 /*
161 * Validate the magic number and version of every inode in the buffer
162 * (if DEBUG kernel) or the first inode in the buffer, otherwise.
163 */
164#ifdef DEBUG
165 ni = BBTOB(imap->im_len) >> mp->m_sb.sb_inodelog;
166#else /* usual case */
167 ni = 1;
168#endif
169
170 for (i = 0; i < ni; i++) {
171 int di_ok;
172 xfs_dinode_t *dip;
173
174 dip = (xfs_dinode_t *)xfs_buf_offset(bp,
175 (i << mp->m_sb.sb_inodelog));
176 di_ok = be16_to_cpu(dip->di_core.di_magic) == XFS_DINODE_MAGIC &&
177 XFS_DINODE_GOOD_VERSION(dip->di_core.di_version);
178 if (unlikely(XFS_TEST_ERROR(!di_ok, mp,
179 XFS_ERRTAG_ITOBP_INOTOBP,
180 XFS_RANDOM_ITOBP_INOTOBP))) {
181 if (imap_flags & XFS_IMAP_BULKSTAT) {
182 xfs_trans_brelse(tp, bp);
183 return XFS_ERROR(EINVAL);
184 }
185 XFS_CORRUPTION_ERROR("xfs_imap_to_bp",
186 XFS_ERRLEVEL_HIGH, mp, dip);
187#ifdef DEBUG
188 cmn_err(CE_PANIC,
189 "Device %s - bad inode magic/vsn "
190 "daddr %lld #%d (magic=%x)",
191 XFS_BUFTARG_NAME(mp->m_ddev_targp),
192 (unsigned long long)imap->im_blkno, i,
193 be16_to_cpu(dip->di_core.di_magic));
194#endif
195 xfs_trans_brelse(tp, bp);
196 return XFS_ERROR(EFSCORRUPTED);
197 }
198 }
199
200 xfs_inobp_check(mp, bp);
201
202 /*
203 * Mark the buffer as an inode buffer now that it looks good
204 */
205 XFS_BUF_SET_VTYPE(bp, B_FS_INO);
206
207 *bpp = bp;
208 return 0;
209}
210
211/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 * This routine is called to map an inode number within a file
213 * system to the buffer containing the on-disk version of the
214 * inode. It returns a pointer to the buffer containing the
215 * on-disk inode in the bpp parameter, and in the dip parameter
216 * it returns a pointer to the on-disk inode within that buffer.
217 *
218 * If a non-zero error is returned, then the contents of bpp and
219 * dipp are undefined.
220 *
221 * Use xfs_imap() to determine the size and location of the
222 * buffer to read from disk.
223 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +1000224STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225xfs_inotobp(
226 xfs_mount_t *mp,
227 xfs_trans_t *tp,
228 xfs_ino_t ino,
229 xfs_dinode_t **dipp,
230 xfs_buf_t **bpp,
231 int *offset)
232{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700233 xfs_imap_t imap;
234 xfs_buf_t *bp;
235 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 imap.im_blkno = 0;
238 error = xfs_imap(mp, tp, ino, &imap, XFS_IMAP_LOOKUP);
David Chinner4ae29b42008-03-06 13:43:34 +1100239 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700240 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700241
David Chinner4ae29b42008-03-06 13:43:34 +1100242 error = xfs_imap_to_bp(mp, tp, &imap, &bp, XFS_BUF_LOCK, 0);
243 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 *dipp = (xfs_dinode_t *)xfs_buf_offset(bp, imap.im_boffset);
247 *bpp = bp;
248 *offset = imap.im_boffset;
249 return 0;
250}
251
252
253/*
254 * This routine is called to map an inode to the buffer containing
255 * the on-disk version of the inode. It returns a pointer to the
256 * buffer containing the on-disk inode in the bpp parameter, and in
257 * the dip parameter it returns a pointer to the on-disk inode within
258 * that buffer.
259 *
260 * If a non-zero error is returned, then the contents of bpp and
261 * dipp are undefined.
262 *
263 * If the inode is new and has not yet been initialized, use xfs_imap()
264 * to determine the size and location of the buffer to read from disk.
265 * If the inode has already been mapped to its buffer and read in once,
266 * then use the mapping information stored in the inode rather than
267 * calling xfs_imap(). This allows us to avoid the overhead of looking
268 * at the inode btree for small block file systems (see xfs_dilocate()).
269 * We can tell whether the inode has been mapped in before by comparing
270 * its disk block address to 0. Only uninitialized inodes will have
271 * 0 for the disk block address.
272 */
273int
274xfs_itobp(
275 xfs_mount_t *mp,
276 xfs_trans_t *tp,
277 xfs_inode_t *ip,
278 xfs_dinode_t **dipp,
279 xfs_buf_t **bpp,
Nathan Scottb12dd342006-03-17 17:26:04 +1100280 xfs_daddr_t bno,
David Chinnera3f74ff2008-03-06 13:43:42 +1100281 uint imap_flags,
282 uint buf_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283{
Nathan Scott4d1a2ed2006-06-09 17:12:28 +1000284 xfs_imap_t imap;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 xfs_buf_t *bp;
286 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287
288 if (ip->i_blkno == (xfs_daddr_t)0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 imap.im_blkno = bno;
David Chinner4ae29b42008-03-06 13:43:34 +1100290 error = xfs_imap(mp, tp, ip->i_ino, &imap,
291 XFS_IMAP_LOOKUP | imap_flags);
292 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294
295 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 * Fill in the fields in the inode that will be used to
297 * map the inode to its buffer from now on.
298 */
299 ip->i_blkno = imap.im_blkno;
300 ip->i_len = imap.im_len;
301 ip->i_boffset = imap.im_boffset;
302 } else {
303 /*
304 * We've already mapped the inode once, so just use the
305 * mapping that we saved the first time.
306 */
307 imap.im_blkno = ip->i_blkno;
308 imap.im_len = ip->i_len;
309 imap.im_boffset = ip->i_boffset;
310 }
311 ASSERT(bno == 0 || bno == imap.im_blkno);
312
David Chinnera3f74ff2008-03-06 13:43:42 +1100313 error = xfs_imap_to_bp(mp, tp, &imap, &bp, buf_flags, imap_flags);
David Chinner4ae29b42008-03-06 13:43:34 +1100314 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 return error;
Nathan Scott4d1a2ed2006-06-09 17:12:28 +1000316
David Chinnera3f74ff2008-03-06 13:43:42 +1100317 if (!bp) {
318 ASSERT(buf_flags & XFS_BUF_TRYLOCK);
319 ASSERT(tp == NULL);
320 *bpp = NULL;
321 return EAGAIN;
322 }
323
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 *dipp = (xfs_dinode_t *)xfs_buf_offset(bp, imap.im_boffset);
325 *bpp = bp;
326 return 0;
327}
328
329/*
330 * Move inode type and inode format specific information from the
331 * on-disk inode to the in-core inode. For fifos, devs, and sockets
332 * this means set if_rdev to the proper value. For files, directories,
333 * and symlinks this means to bring in the in-line data or extent
334 * pointers. For a file in B-tree format, only the root is immediately
335 * brought in-core. The rest will be in-lined in if_extents when it
336 * is first referenced (see xfs_iread_extents()).
337 */
338STATIC int
339xfs_iformat(
340 xfs_inode_t *ip,
341 xfs_dinode_t *dip)
342{
343 xfs_attr_shortform_t *atp;
344 int size;
345 int error;
346 xfs_fsize_t di_size;
347 ip->i_df.if_ext_max =
348 XFS_IFORK_DSIZE(ip) / (uint)sizeof(xfs_bmbt_rec_t);
349 error = 0;
350
Christoph Hellwig347d1c02007-08-28 13:57:51 +1000351 if (unlikely(be32_to_cpu(dip->di_core.di_nextents) +
352 be16_to_cpu(dip->di_core.di_anextents) >
353 be64_to_cpu(dip->di_core.di_nblocks))) {
Nathan Scott3762ec62006-01-12 10:29:53 +1100354 xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
355 "corrupt dinode %Lu, extent total = %d, nblocks = %Lu.",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 (unsigned long long)ip->i_ino,
Christoph Hellwig347d1c02007-08-28 13:57:51 +1000357 (int)(be32_to_cpu(dip->di_core.di_nextents) +
358 be16_to_cpu(dip->di_core.di_anextents)),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 (unsigned long long)
Christoph Hellwig347d1c02007-08-28 13:57:51 +1000360 be64_to_cpu(dip->di_core.di_nblocks));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 XFS_CORRUPTION_ERROR("xfs_iformat(1)", XFS_ERRLEVEL_LOW,
362 ip->i_mount, dip);
363 return XFS_ERROR(EFSCORRUPTED);
364 }
365
Christoph Hellwig347d1c02007-08-28 13:57:51 +1000366 if (unlikely(dip->di_core.di_forkoff > ip->i_mount->m_sb.sb_inodesize)) {
Nathan Scott3762ec62006-01-12 10:29:53 +1100367 xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
368 "corrupt dinode %Lu, forkoff = 0x%x.",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 (unsigned long long)ip->i_ino,
Christoph Hellwig347d1c02007-08-28 13:57:51 +1000370 dip->di_core.di_forkoff);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 XFS_CORRUPTION_ERROR("xfs_iformat(2)", XFS_ERRLEVEL_LOW,
372 ip->i_mount, dip);
373 return XFS_ERROR(EFSCORRUPTED);
374 }
375
376 switch (ip->i_d.di_mode & S_IFMT) {
377 case S_IFIFO:
378 case S_IFCHR:
379 case S_IFBLK:
380 case S_IFSOCK:
Christoph Hellwig347d1c02007-08-28 13:57:51 +1000381 if (unlikely(dip->di_core.di_format != XFS_DINODE_FMT_DEV)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382 XFS_CORRUPTION_ERROR("xfs_iformat(3)", XFS_ERRLEVEL_LOW,
383 ip->i_mount, dip);
384 return XFS_ERROR(EFSCORRUPTED);
385 }
386 ip->i_d.di_size = 0;
Lachlan McIlroyba87ea62007-05-08 13:49:46 +1000387 ip->i_size = 0;
Christoph Hellwig347d1c02007-08-28 13:57:51 +1000388 ip->i_df.if_u2.if_rdev = be32_to_cpu(dip->di_u.di_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 break;
390
391 case S_IFREG:
392 case S_IFLNK:
393 case S_IFDIR:
Christoph Hellwig347d1c02007-08-28 13:57:51 +1000394 switch (dip->di_core.di_format) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395 case XFS_DINODE_FMT_LOCAL:
396 /*
397 * no local regular files yet
398 */
Christoph Hellwig347d1c02007-08-28 13:57:51 +1000399 if (unlikely((be16_to_cpu(dip->di_core.di_mode) & S_IFMT) == S_IFREG)) {
Nathan Scott3762ec62006-01-12 10:29:53 +1100400 xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
401 "corrupt inode %Lu "
402 "(local format for regular file).",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 (unsigned long long) ip->i_ino);
404 XFS_CORRUPTION_ERROR("xfs_iformat(4)",
405 XFS_ERRLEVEL_LOW,
406 ip->i_mount, dip);
407 return XFS_ERROR(EFSCORRUPTED);
408 }
409
Christoph Hellwig347d1c02007-08-28 13:57:51 +1000410 di_size = be64_to_cpu(dip->di_core.di_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 if (unlikely(di_size > XFS_DFORK_DSIZE(dip, ip->i_mount))) {
Nathan Scott3762ec62006-01-12 10:29:53 +1100412 xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
413 "corrupt inode %Lu "
414 "(bad size %Ld for local inode).",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 (unsigned long long) ip->i_ino,
416 (long long) di_size);
417 XFS_CORRUPTION_ERROR("xfs_iformat(5)",
418 XFS_ERRLEVEL_LOW,
419 ip->i_mount, dip);
420 return XFS_ERROR(EFSCORRUPTED);
421 }
422
423 size = (int)di_size;
424 error = xfs_iformat_local(ip, dip, XFS_DATA_FORK, size);
425 break;
426 case XFS_DINODE_FMT_EXTENTS:
427 error = xfs_iformat_extents(ip, dip, XFS_DATA_FORK);
428 break;
429 case XFS_DINODE_FMT_BTREE:
430 error = xfs_iformat_btree(ip, dip, XFS_DATA_FORK);
431 break;
432 default:
433 XFS_ERROR_REPORT("xfs_iformat(6)", XFS_ERRLEVEL_LOW,
434 ip->i_mount);
435 return XFS_ERROR(EFSCORRUPTED);
436 }
437 break;
438
439 default:
440 XFS_ERROR_REPORT("xfs_iformat(7)", XFS_ERRLEVEL_LOW, ip->i_mount);
441 return XFS_ERROR(EFSCORRUPTED);
442 }
443 if (error) {
444 return error;
445 }
446 if (!XFS_DFORK_Q(dip))
447 return 0;
448 ASSERT(ip->i_afp == NULL);
449 ip->i_afp = kmem_zone_zalloc(xfs_ifork_zone, KM_SLEEP);
450 ip->i_afp->if_ext_max =
451 XFS_IFORK_ASIZE(ip) / (uint)sizeof(xfs_bmbt_rec_t);
Christoph Hellwig347d1c02007-08-28 13:57:51 +1000452 switch (dip->di_core.di_aformat) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 case XFS_DINODE_FMT_LOCAL:
454 atp = (xfs_attr_shortform_t *)XFS_DFORK_APTR(dip);
Nathan Scott3b244aa2006-03-17 17:29:25 +1100455 size = be16_to_cpu(atp->hdr.totsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 error = xfs_iformat_local(ip, dip, XFS_ATTR_FORK, size);
457 break;
458 case XFS_DINODE_FMT_EXTENTS:
459 error = xfs_iformat_extents(ip, dip, XFS_ATTR_FORK);
460 break;
461 case XFS_DINODE_FMT_BTREE:
462 error = xfs_iformat_btree(ip, dip, XFS_ATTR_FORK);
463 break;
464 default:
465 error = XFS_ERROR(EFSCORRUPTED);
466 break;
467 }
468 if (error) {
469 kmem_zone_free(xfs_ifork_zone, ip->i_afp);
470 ip->i_afp = NULL;
471 xfs_idestroy_fork(ip, XFS_DATA_FORK);
472 }
473 return error;
474}
475
476/*
477 * The file is in-lined in the on-disk inode.
478 * If it fits into if_inline_data, then copy
479 * it there, otherwise allocate a buffer for it
480 * and copy the data there. Either way, set
481 * if_data to point at the data.
482 * If we allocate a buffer for the data, make
483 * sure that its size is a multiple of 4 and
484 * record the real size in i_real_bytes.
485 */
486STATIC int
487xfs_iformat_local(
488 xfs_inode_t *ip,
489 xfs_dinode_t *dip,
490 int whichfork,
491 int size)
492{
493 xfs_ifork_t *ifp;
494 int real_size;
495
496 /*
497 * If the size is unreasonable, then something
498 * is wrong and we just bail out rather than crash in
499 * kmem_alloc() or memcpy() below.
500 */
501 if (unlikely(size > XFS_DFORK_SIZE(dip, ip->i_mount, whichfork))) {
Nathan Scott3762ec62006-01-12 10:29:53 +1100502 xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
503 "corrupt inode %Lu "
504 "(bad size %d for local fork, size = %d).",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700505 (unsigned long long) ip->i_ino, size,
506 XFS_DFORK_SIZE(dip, ip->i_mount, whichfork));
507 XFS_CORRUPTION_ERROR("xfs_iformat_local", XFS_ERRLEVEL_LOW,
508 ip->i_mount, dip);
509 return XFS_ERROR(EFSCORRUPTED);
510 }
511 ifp = XFS_IFORK_PTR(ip, whichfork);
512 real_size = 0;
513 if (size == 0)
514 ifp->if_u1.if_data = NULL;
515 else if (size <= sizeof(ifp->if_u2.if_inline_data))
516 ifp->if_u1.if_data = ifp->if_u2.if_inline_data;
517 else {
518 real_size = roundup(size, 4);
519 ifp->if_u1.if_data = kmem_alloc(real_size, KM_SLEEP);
520 }
521 ifp->if_bytes = size;
522 ifp->if_real_bytes = real_size;
523 if (size)
524 memcpy(ifp->if_u1.if_data, XFS_DFORK_PTR(dip, whichfork), size);
525 ifp->if_flags &= ~XFS_IFEXTENTS;
526 ifp->if_flags |= XFS_IFINLINE;
527 return 0;
528}
529
530/*
531 * The file consists of a set of extents all
532 * of which fit into the on-disk inode.
533 * If there are few enough extents to fit into
534 * the if_inline_ext, then copy them there.
535 * Otherwise allocate a buffer for them and copy
536 * them into it. Either way, set if_extents
537 * to point at the extents.
538 */
539STATIC int
540xfs_iformat_extents(
541 xfs_inode_t *ip,
542 xfs_dinode_t *dip,
543 int whichfork)
544{
Christoph Hellwiga6f64d42007-08-16 16:23:40 +1000545 xfs_bmbt_rec_t *dp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 xfs_ifork_t *ifp;
547 int nex;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548 int size;
549 int i;
550
551 ifp = XFS_IFORK_PTR(ip, whichfork);
552 nex = XFS_DFORK_NEXTENTS(dip, whichfork);
553 size = nex * (uint)sizeof(xfs_bmbt_rec_t);
554
555 /*
556 * If the number of extents is unreasonable, then something
557 * is wrong and we just bail out rather than crash in
558 * kmem_alloc() or memcpy() below.
559 */
560 if (unlikely(size < 0 || size > XFS_DFORK_SIZE(dip, ip->i_mount, whichfork))) {
Nathan Scott3762ec62006-01-12 10:29:53 +1100561 xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
562 "corrupt inode %Lu ((a)extents = %d).",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 (unsigned long long) ip->i_ino, nex);
564 XFS_CORRUPTION_ERROR("xfs_iformat_extents(1)", XFS_ERRLEVEL_LOW,
565 ip->i_mount, dip);
566 return XFS_ERROR(EFSCORRUPTED);
567 }
568
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +1100569 ifp->if_real_bytes = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 if (nex == 0)
571 ifp->if_u1.if_extents = NULL;
572 else if (nex <= XFS_INLINE_EXTS)
573 ifp->if_u1.if_extents = ifp->if_u2.if_inline_ext;
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +1100574 else
575 xfs_iext_add(ifp, 0, nex);
576
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 ifp->if_bytes = size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 if (size) {
579 dp = (xfs_bmbt_rec_t *) XFS_DFORK_PTR(dip, whichfork);
Christoph Hellwiga6f64d42007-08-16 16:23:40 +1000580 xfs_validate_extents(ifp, nex, XFS_EXTFMT_INODE(ip));
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +1100581 for (i = 0; i < nex; i++, dp++) {
Christoph Hellwiga6f64d42007-08-16 16:23:40 +1000582 xfs_bmbt_rec_host_t *ep = xfs_iext_get_ext(ifp, i);
Christoph Hellwigcd8b0a92007-08-16 16:24:15 +1000583 ep->l0 = be64_to_cpu(get_unaligned(&dp->l0));
584 ep->l1 = be64_to_cpu(get_unaligned(&dp->l1));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 }
Eric Sandeen3a59c942007-07-11 11:09:47 +1000586 XFS_BMAP_TRACE_EXLIST(ip, nex, whichfork);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587 if (whichfork != XFS_DATA_FORK ||
588 XFS_EXTFMT_INODE(ip) == XFS_EXTFMT_NOSTATE)
589 if (unlikely(xfs_check_nostate_extents(
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +1100590 ifp, 0, nex))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 XFS_ERROR_REPORT("xfs_iformat_extents(2)",
592 XFS_ERRLEVEL_LOW,
593 ip->i_mount);
594 return XFS_ERROR(EFSCORRUPTED);
595 }
596 }
597 ifp->if_flags |= XFS_IFEXTENTS;
598 return 0;
599}
600
601/*
602 * The file has too many extents to fit into
603 * the inode, so they are in B-tree format.
604 * Allocate a buffer for the root of the B-tree
605 * and copy the root into it. The i_extents
606 * field will remain NULL until all of the
607 * extents are read in (when they are needed).
608 */
609STATIC int
610xfs_iformat_btree(
611 xfs_inode_t *ip,
612 xfs_dinode_t *dip,
613 int whichfork)
614{
615 xfs_bmdr_block_t *dfp;
616 xfs_ifork_t *ifp;
617 /* REFERENCED */
618 int nrecs;
619 int size;
620
621 ifp = XFS_IFORK_PTR(ip, whichfork);
622 dfp = (xfs_bmdr_block_t *)XFS_DFORK_PTR(dip, whichfork);
623 size = XFS_BMAP_BROOT_SPACE(dfp);
624 nrecs = XFS_BMAP_BROOT_NUMRECS(dfp);
625
626 /*
627 * blow out if -- fork has less extents than can fit in
628 * fork (fork shouldn't be a btree format), root btree
629 * block has more records than can fit into the fork,
630 * or the number of extents is greater than the number of
631 * blocks.
632 */
633 if (unlikely(XFS_IFORK_NEXTENTS(ip, whichfork) <= ifp->if_ext_max
634 || XFS_BMDR_SPACE_CALC(nrecs) >
635 XFS_DFORK_SIZE(dip, ip->i_mount, whichfork)
636 || XFS_IFORK_NEXTENTS(ip, whichfork) > ip->i_d.di_nblocks)) {
Nathan Scott3762ec62006-01-12 10:29:53 +1100637 xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
638 "corrupt inode %Lu (btree).",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 (unsigned long long) ip->i_ino);
640 XFS_ERROR_REPORT("xfs_iformat_btree", XFS_ERRLEVEL_LOW,
641 ip->i_mount);
642 return XFS_ERROR(EFSCORRUPTED);
643 }
644
645 ifp->if_broot_bytes = size;
646 ifp->if_broot = kmem_alloc(size, KM_SLEEP);
647 ASSERT(ifp->if_broot != NULL);
648 /*
649 * Copy and convert from the on-disk structure
650 * to the in-memory structure.
651 */
652 xfs_bmdr_to_bmbt(dfp, XFS_DFORK_SIZE(dip, ip->i_mount, whichfork),
653 ifp->if_broot, size);
654 ifp->if_flags &= ~XFS_IFEXTENTS;
655 ifp->if_flags |= XFS_IFBROOT;
656
657 return 0;
658}
659
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660void
Christoph Hellwig347d1c02007-08-28 13:57:51 +1000661xfs_dinode_from_disk(
662 xfs_icdinode_t *to,
663 xfs_dinode_core_t *from)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664{
Christoph Hellwig347d1c02007-08-28 13:57:51 +1000665 to->di_magic = be16_to_cpu(from->di_magic);
666 to->di_mode = be16_to_cpu(from->di_mode);
667 to->di_version = from ->di_version;
668 to->di_format = from->di_format;
669 to->di_onlink = be16_to_cpu(from->di_onlink);
670 to->di_uid = be32_to_cpu(from->di_uid);
671 to->di_gid = be32_to_cpu(from->di_gid);
672 to->di_nlink = be32_to_cpu(from->di_nlink);
673 to->di_projid = be16_to_cpu(from->di_projid);
674 memcpy(to->di_pad, from->di_pad, sizeof(to->di_pad));
675 to->di_flushiter = be16_to_cpu(from->di_flushiter);
676 to->di_atime.t_sec = be32_to_cpu(from->di_atime.t_sec);
677 to->di_atime.t_nsec = be32_to_cpu(from->di_atime.t_nsec);
678 to->di_mtime.t_sec = be32_to_cpu(from->di_mtime.t_sec);
679 to->di_mtime.t_nsec = be32_to_cpu(from->di_mtime.t_nsec);
680 to->di_ctime.t_sec = be32_to_cpu(from->di_ctime.t_sec);
681 to->di_ctime.t_nsec = be32_to_cpu(from->di_ctime.t_nsec);
682 to->di_size = be64_to_cpu(from->di_size);
683 to->di_nblocks = be64_to_cpu(from->di_nblocks);
684 to->di_extsize = be32_to_cpu(from->di_extsize);
685 to->di_nextents = be32_to_cpu(from->di_nextents);
686 to->di_anextents = be16_to_cpu(from->di_anextents);
687 to->di_forkoff = from->di_forkoff;
688 to->di_aformat = from->di_aformat;
689 to->di_dmevmask = be32_to_cpu(from->di_dmevmask);
690 to->di_dmstate = be16_to_cpu(from->di_dmstate);
691 to->di_flags = be16_to_cpu(from->di_flags);
692 to->di_gen = be32_to_cpu(from->di_gen);
693}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694
Christoph Hellwig347d1c02007-08-28 13:57:51 +1000695void
696xfs_dinode_to_disk(
697 xfs_dinode_core_t *to,
698 xfs_icdinode_t *from)
699{
700 to->di_magic = cpu_to_be16(from->di_magic);
701 to->di_mode = cpu_to_be16(from->di_mode);
702 to->di_version = from ->di_version;
703 to->di_format = from->di_format;
704 to->di_onlink = cpu_to_be16(from->di_onlink);
705 to->di_uid = cpu_to_be32(from->di_uid);
706 to->di_gid = cpu_to_be32(from->di_gid);
707 to->di_nlink = cpu_to_be32(from->di_nlink);
708 to->di_projid = cpu_to_be16(from->di_projid);
709 memcpy(to->di_pad, from->di_pad, sizeof(to->di_pad));
710 to->di_flushiter = cpu_to_be16(from->di_flushiter);
711 to->di_atime.t_sec = cpu_to_be32(from->di_atime.t_sec);
712 to->di_atime.t_nsec = cpu_to_be32(from->di_atime.t_nsec);
713 to->di_mtime.t_sec = cpu_to_be32(from->di_mtime.t_sec);
714 to->di_mtime.t_nsec = cpu_to_be32(from->di_mtime.t_nsec);
715 to->di_ctime.t_sec = cpu_to_be32(from->di_ctime.t_sec);
716 to->di_ctime.t_nsec = cpu_to_be32(from->di_ctime.t_nsec);
717 to->di_size = cpu_to_be64(from->di_size);
718 to->di_nblocks = cpu_to_be64(from->di_nblocks);
719 to->di_extsize = cpu_to_be32(from->di_extsize);
720 to->di_nextents = cpu_to_be32(from->di_nextents);
721 to->di_anextents = cpu_to_be16(from->di_anextents);
722 to->di_forkoff = from->di_forkoff;
723 to->di_aformat = from->di_aformat;
724 to->di_dmevmask = cpu_to_be32(from->di_dmevmask);
725 to->di_dmstate = cpu_to_be16(from->di_dmstate);
726 to->di_flags = cpu_to_be16(from->di_flags);
727 to->di_gen = cpu_to_be32(from->di_gen);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700728}
729
730STATIC uint
731_xfs_dic2xflags(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 __uint16_t di_flags)
733{
734 uint flags = 0;
735
736 if (di_flags & XFS_DIFLAG_ANY) {
737 if (di_flags & XFS_DIFLAG_REALTIME)
738 flags |= XFS_XFLAG_REALTIME;
739 if (di_flags & XFS_DIFLAG_PREALLOC)
740 flags |= XFS_XFLAG_PREALLOC;
741 if (di_flags & XFS_DIFLAG_IMMUTABLE)
742 flags |= XFS_XFLAG_IMMUTABLE;
743 if (di_flags & XFS_DIFLAG_APPEND)
744 flags |= XFS_XFLAG_APPEND;
745 if (di_flags & XFS_DIFLAG_SYNC)
746 flags |= XFS_XFLAG_SYNC;
747 if (di_flags & XFS_DIFLAG_NOATIME)
748 flags |= XFS_XFLAG_NOATIME;
749 if (di_flags & XFS_DIFLAG_NODUMP)
750 flags |= XFS_XFLAG_NODUMP;
751 if (di_flags & XFS_DIFLAG_RTINHERIT)
752 flags |= XFS_XFLAG_RTINHERIT;
753 if (di_flags & XFS_DIFLAG_PROJINHERIT)
754 flags |= XFS_XFLAG_PROJINHERIT;
755 if (di_flags & XFS_DIFLAG_NOSYMLINKS)
756 flags |= XFS_XFLAG_NOSYMLINKS;
Nathan Scottdd9f4382006-01-11 15:28:28 +1100757 if (di_flags & XFS_DIFLAG_EXTSIZE)
758 flags |= XFS_XFLAG_EXTSIZE;
759 if (di_flags & XFS_DIFLAG_EXTSZINHERIT)
760 flags |= XFS_XFLAG_EXTSZINHERIT;
Barry Naujokd3446ea2006-06-09 14:54:19 +1000761 if (di_flags & XFS_DIFLAG_NODEFRAG)
762 flags |= XFS_XFLAG_NODEFRAG;
David Chinner2a82b8b2007-07-11 11:09:12 +1000763 if (di_flags & XFS_DIFLAG_FILESTREAM)
764 flags |= XFS_XFLAG_FILESTREAM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700765 }
766
767 return flags;
768}
769
770uint
771xfs_ip2xflags(
772 xfs_inode_t *ip)
773{
Christoph Hellwig347d1c02007-08-28 13:57:51 +1000774 xfs_icdinode_t *dic = &ip->i_d;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775
Nathan Scotta916e2b2006-06-09 17:12:17 +1000776 return _xfs_dic2xflags(dic->di_flags) |
Christoph Hellwig45ba5982007-12-07 14:07:20 +1100777 (XFS_IFORK_Q(ip) ? XFS_XFLAG_HASATTR : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778}
779
780uint
781xfs_dic2xflags(
Christoph Hellwig45ba5982007-12-07 14:07:20 +1100782 xfs_dinode_t *dip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783{
Christoph Hellwig45ba5982007-12-07 14:07:20 +1100784 xfs_dinode_core_t *dic = &dip->di_core;
785
Christoph Hellwig347d1c02007-08-28 13:57:51 +1000786 return _xfs_dic2xflags(be16_to_cpu(dic->di_flags)) |
Christoph Hellwig45ba5982007-12-07 14:07:20 +1100787 (XFS_DFORK_Q(dip) ? XFS_XFLAG_HASATTR : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788}
789
790/*
791 * Given a mount structure and an inode number, return a pointer
Nathan Scottc41564b2006-03-29 08:55:14 +1000792 * to a newly allocated in-core inode corresponding to the given
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 * inode number.
794 *
795 * Initialize the inode's attributes and extent pointers if it
796 * already has them (it will not if the inode has no links).
797 */
798int
799xfs_iread(
800 xfs_mount_t *mp,
801 xfs_trans_t *tp,
802 xfs_ino_t ino,
803 xfs_inode_t **ipp,
Nathan Scott745b1f472006-09-28 11:02:23 +1000804 xfs_daddr_t bno,
805 uint imap_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806{
807 xfs_buf_t *bp;
808 xfs_dinode_t *dip;
809 xfs_inode_t *ip;
810 int error;
811
812 ASSERT(xfs_inode_zone != NULL);
813
814 ip = kmem_zone_zalloc(xfs_inode_zone, KM_SLEEP);
815 ip->i_ino = ino;
816 ip->i_mount = mp;
Christoph Hellwigb677c212007-08-29 11:46:28 +1000817 atomic_set(&ip->i_iocount, 0);
David Chinnerf273ab82006-09-28 11:06:03 +1000818 spin_lock_init(&ip->i_flags_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819
820 /*
821 * Get pointer's to the on-disk inode and the buffer containing it.
822 * If the inode number refers to a block outside the file system
823 * then xfs_itobp() will return NULL. In this case we should
824 * return NULL as well. Set i_blkno to 0 so that xfs_itobp() will
825 * know that this is a new incore inode.
826 */
David Chinnera3f74ff2008-03-06 13:43:42 +1100827 error = xfs_itobp(mp, tp, ip, &dip, &bp, bno, imap_flags, XFS_BUF_LOCK);
Nathan Scottb12dd342006-03-17 17:26:04 +1100828 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 kmem_zone_free(xfs_inode_zone, ip);
830 return error;
831 }
832
833 /*
834 * Initialize inode's trace buffers.
835 * Do this before xfs_iformat in case it adds entries.
836 */
Lachlan McIlroycf441ee2008-02-07 16:42:19 +1100837#ifdef XFS_INODE_TRACE
838 ip->i_trace = ktrace_alloc(INODE_TRACE_SIZE, KM_SLEEP);
Christoph Hellwig1543d792007-08-29 11:46:47 +1000839#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840#ifdef XFS_BMAP_TRACE
841 ip->i_xtrace = ktrace_alloc(XFS_BMAP_KTRACE_SIZE, KM_SLEEP);
842#endif
843#ifdef XFS_BMBT_TRACE
844 ip->i_btrace = ktrace_alloc(XFS_BMBT_KTRACE_SIZE, KM_SLEEP);
845#endif
846#ifdef XFS_RW_TRACE
847 ip->i_rwtrace = ktrace_alloc(XFS_RW_KTRACE_SIZE, KM_SLEEP);
848#endif
849#ifdef XFS_ILOCK_TRACE
850 ip->i_lock_trace = ktrace_alloc(XFS_ILOCK_KTRACE_SIZE, KM_SLEEP);
851#endif
852#ifdef XFS_DIR2_TRACE
853 ip->i_dir_trace = ktrace_alloc(XFS_DIR2_KTRACE_SIZE, KM_SLEEP);
854#endif
855
856 /*
857 * If we got something that isn't an inode it means someone
858 * (nfs or dmi) has a stale handle.
859 */
Christoph Hellwig347d1c02007-08-28 13:57:51 +1000860 if (be16_to_cpu(dip->di_core.di_magic) != XFS_DINODE_MAGIC) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 kmem_zone_free(xfs_inode_zone, ip);
862 xfs_trans_brelse(tp, bp);
863#ifdef DEBUG
864 xfs_fs_cmn_err(CE_ALERT, mp, "xfs_iread: "
865 "dip->di_core.di_magic (0x%x) != "
866 "XFS_DINODE_MAGIC (0x%x)",
Christoph Hellwig347d1c02007-08-28 13:57:51 +1000867 be16_to_cpu(dip->di_core.di_magic),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 XFS_DINODE_MAGIC);
869#endif /* DEBUG */
870 return XFS_ERROR(EINVAL);
871 }
872
873 /*
874 * If the on-disk inode is already linked to a directory
875 * entry, copy all of the inode into the in-core inode.
876 * xfs_iformat() handles copying in the inode format
877 * specific information.
878 * Otherwise, just get the truly permanent information.
879 */
880 if (dip->di_core.di_mode) {
Christoph Hellwig347d1c02007-08-28 13:57:51 +1000881 xfs_dinode_from_disk(&ip->i_d, &dip->di_core);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700882 error = xfs_iformat(ip, dip);
883 if (error) {
884 kmem_zone_free(xfs_inode_zone, ip);
885 xfs_trans_brelse(tp, bp);
886#ifdef DEBUG
887 xfs_fs_cmn_err(CE_ALERT, mp, "xfs_iread: "
888 "xfs_iformat() returned error %d",
889 error);
890#endif /* DEBUG */
891 return error;
892 }
893 } else {
Christoph Hellwig347d1c02007-08-28 13:57:51 +1000894 ip->i_d.di_magic = be16_to_cpu(dip->di_core.di_magic);
895 ip->i_d.di_version = dip->di_core.di_version;
896 ip->i_d.di_gen = be32_to_cpu(dip->di_core.di_gen);
897 ip->i_d.di_flushiter = be16_to_cpu(dip->di_core.di_flushiter);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 /*
899 * Make sure to pull in the mode here as well in
900 * case the inode is released without being used.
901 * This ensures that xfs_inactive() will see that
902 * the inode is already free and not try to mess
903 * with the uninitialized part of it.
904 */
905 ip->i_d.di_mode = 0;
906 /*
907 * Initialize the per-fork minima and maxima for a new
908 * inode here. xfs_iformat will do it for old inodes.
909 */
910 ip->i_df.if_ext_max =
911 XFS_IFORK_DSIZE(ip) / (uint)sizeof(xfs_bmbt_rec_t);
912 }
913
914 INIT_LIST_HEAD(&ip->i_reclaim);
915
916 /*
917 * The inode format changed when we moved the link count and
918 * made it 32 bits long. If this is an old format inode,
919 * convert it in memory to look like a new one. If it gets
920 * flushed to disk we will convert back before flushing or
921 * logging it. We zero out the new projid field and the old link
922 * count field. We'll handle clearing the pad field (the remains
923 * of the old uuid field) when we actually convert the inode to
924 * the new format. We don't change the version number so that we
925 * can distinguish this from a real new format inode.
926 */
927 if (ip->i_d.di_version == XFS_DINODE_VERSION_1) {
928 ip->i_d.di_nlink = ip->i_d.di_onlink;
929 ip->i_d.di_onlink = 0;
930 ip->i_d.di_projid = 0;
931 }
932
933 ip->i_delayed_blks = 0;
Lachlan McIlroyba87ea62007-05-08 13:49:46 +1000934 ip->i_size = ip->i_d.di_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935
936 /*
937 * Mark the buffer containing the inode as something to keep
938 * around for a while. This helps to keep recently accessed
939 * meta-data in-core longer.
940 */
941 XFS_BUF_SET_REF(bp, XFS_INO_REF);
942
943 /*
944 * Use xfs_trans_brelse() to release the buffer containing the
945 * on-disk inode, because it was acquired with xfs_trans_read_buf()
946 * in xfs_itobp() above. If tp is NULL, this is just a normal
947 * brelse(). If we're within a transaction, then xfs_trans_brelse()
948 * will only release the buffer if it is not dirty within the
949 * transaction. It will be OK to release the buffer in this case,
950 * because inodes on disk are never destroyed and we will be
951 * locking the new in-core inode before putting it in the hash
952 * table where other processes can find it. Thus we don't have
953 * to worry about the inode being changed just because we released
954 * the buffer.
955 */
956 xfs_trans_brelse(tp, bp);
957 *ipp = ip;
958 return 0;
959}
960
961/*
962 * Read in extents from a btree-format inode.
963 * Allocate and fill in if_extents. Real work is done in xfs_bmap.c.
964 */
965int
966xfs_iread_extents(
967 xfs_trans_t *tp,
968 xfs_inode_t *ip,
969 int whichfork)
970{
971 int error;
972 xfs_ifork_t *ifp;
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +1100973 xfs_extnum_t nextents;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 size_t size;
975
976 if (unlikely(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE)) {
977 XFS_ERROR_REPORT("xfs_iread_extents", XFS_ERRLEVEL_LOW,
978 ip->i_mount);
979 return XFS_ERROR(EFSCORRUPTED);
980 }
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +1100981 nextents = XFS_IFORK_NEXTENTS(ip, whichfork);
982 size = nextents * sizeof(xfs_bmbt_rec_t);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 ifp = XFS_IFORK_PTR(ip, whichfork);
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +1100984
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985 /*
986 * We know that the size is valid (it's checked in iformat_btree)
987 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 ifp->if_lastex = NULLEXTNUM;
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +1100989 ifp->if_bytes = ifp->if_real_bytes = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 ifp->if_flags |= XFS_IFEXTENTS;
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +1100991 xfs_iext_add(ifp, 0, nextents);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992 error = xfs_bmap_read_extents(tp, ip, whichfork);
993 if (error) {
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +1100994 xfs_iext_destroy(ifp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 ifp->if_flags &= ~XFS_IFEXTENTS;
996 return error;
997 }
Christoph Hellwiga6f64d42007-08-16 16:23:40 +1000998 xfs_validate_extents(ifp, nextents, XFS_EXTFMT_INODE(ip));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 return 0;
1000}
1001
1002/*
1003 * Allocate an inode on disk and return a copy of its in-core version.
1004 * The in-core inode is locked exclusively. Set mode, nlink, and rdev
1005 * appropriately within the inode. The uid and gid for the inode are
1006 * set according to the contents of the given cred structure.
1007 *
1008 * Use xfs_dialloc() to allocate the on-disk inode. If xfs_dialloc()
1009 * has a free inode available, call xfs_iget()
1010 * to obtain the in-core version of the allocated inode. Finally,
1011 * fill in the inode and log its initial contents. In this case,
1012 * ialloc_context would be set to NULL and call_again set to false.
1013 *
1014 * If xfs_dialloc() does not have an available inode,
1015 * it will replenish its supply by doing an allocation. Since we can
1016 * only do one allocation within a transaction without deadlocks, we
1017 * must commit the current transaction before returning the inode itself.
1018 * In this case, therefore, we will set call_again to true and return.
1019 * The caller should then commit the current transaction, start a new
1020 * transaction, and call xfs_ialloc() again to actually get the inode.
1021 *
1022 * To ensure that some other process does not grab the inode that
1023 * was allocated during the first call to xfs_ialloc(), this routine
1024 * also returns the [locked] bp pointing to the head of the freelist
1025 * as ialloc_context. The caller should hold this buffer across
1026 * the commit and pass it back into this routine on the second call.
David Chinnerb11f94d2007-07-11 11:09:33 +10001027 *
1028 * If we are allocating quota inodes, we do not have a parent inode
1029 * to attach to or associate with (i.e. pip == NULL) because they
1030 * are not linked into the directory structure - they are attached
1031 * directly to the superblock - and so have no parent.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032 */
1033int
1034xfs_ialloc(
1035 xfs_trans_t *tp,
1036 xfs_inode_t *pip,
1037 mode_t mode,
Nathan Scott31b084a2005-05-05 13:25:00 -07001038 xfs_nlink_t nlink,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039 xfs_dev_t rdev,
1040 cred_t *cr,
1041 xfs_prid_t prid,
1042 int okalloc,
1043 xfs_buf_t **ialloc_context,
1044 boolean_t *call_again,
1045 xfs_inode_t **ipp)
1046{
1047 xfs_ino_t ino;
1048 xfs_inode_t *ip;
Nathan Scott67fcaa72006-06-09 17:00:52 +10001049 bhv_vnode_t *vp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 uint flags;
1051 int error;
1052
1053 /*
1054 * Call the space management code to pick
1055 * the on-disk inode to be allocated.
1056 */
David Chinnerb11f94d2007-07-11 11:09:33 +10001057 error = xfs_dialloc(tp, pip ? pip->i_ino : 0, mode, okalloc,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058 ialloc_context, call_again, &ino);
1059 if (error != 0) {
1060 return error;
1061 }
1062 if (*call_again || ino == NULLFSINO) {
1063 *ipp = NULL;
1064 return 0;
1065 }
1066 ASSERT(*ialloc_context == NULL);
1067
1068 /*
1069 * Get the in-core inode with the lock held exclusively.
1070 * This is because we're setting fields here we need
1071 * to prevent others from looking at until we're done.
1072 */
1073 error = xfs_trans_iget(tp->t_mountp, tp, ino,
Nathan Scott745b1f472006-09-28 11:02:23 +10001074 XFS_IGET_CREATE, XFS_ILOCK_EXCL, &ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075 if (error != 0) {
1076 return error;
1077 }
1078 ASSERT(ip != NULL);
1079
David Chinner705db4a2008-08-13 15:47:43 +10001080 vp = VFS_I(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001081 ip->i_d.di_mode = (__uint16_t)mode;
1082 ip->i_d.di_onlink = 0;
1083 ip->i_d.di_nlink = nlink;
1084 ASSERT(ip->i_d.di_nlink == nlink);
1085 ip->i_d.di_uid = current_fsuid(cr);
1086 ip->i_d.di_gid = current_fsgid(cr);
1087 ip->i_d.di_projid = prid;
1088 memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad));
1089
1090 /*
1091 * If the superblock version is up to where we support new format
1092 * inodes and this is currently an old format inode, then change
1093 * the inode version number now. This way we only do the conversion
1094 * here rather than here and in the flush/logging code.
1095 */
Eric Sandeen62118702008-03-06 13:44:28 +11001096 if (xfs_sb_version_hasnlink(&tp->t_mountp->m_sb) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001097 ip->i_d.di_version == XFS_DINODE_VERSION_1) {
1098 ip->i_d.di_version = XFS_DINODE_VERSION_2;
1099 /*
1100 * We've already zeroed the old link count, the projid field,
1101 * and the pad field.
1102 */
1103 }
1104
1105 /*
1106 * Project ids won't be stored on disk if we are using a version 1 inode.
1107 */
David Chinner2a82b8b2007-07-11 11:09:12 +10001108 if ((prid != 0) && (ip->i_d.di_version == XFS_DINODE_VERSION_1))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109 xfs_bump_ino_vers2(tp, ip);
1110
Christoph Hellwigbd186aa2007-08-30 17:21:12 +10001111 if (pip && XFS_INHERIT_GID(pip)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112 ip->i_d.di_gid = pip->i_d.di_gid;
1113 if ((pip->i_d.di_mode & S_ISGID) && (mode & S_IFMT) == S_IFDIR) {
1114 ip->i_d.di_mode |= S_ISGID;
1115 }
1116 }
1117
1118 /*
1119 * If the group ID of the new file does not match the effective group
1120 * ID or one of the supplementary group IDs, the S_ISGID bit is cleared
1121 * (and only if the irix_sgid_inherit compatibility variable is set).
1122 */
1123 if ((irix_sgid_inherit) &&
1124 (ip->i_d.di_mode & S_ISGID) &&
1125 (!in_group_p((gid_t)ip->i_d.di_gid))) {
1126 ip->i_d.di_mode &= ~S_ISGID;
1127 }
1128
1129 ip->i_d.di_size = 0;
Lachlan McIlroyba87ea62007-05-08 13:49:46 +10001130 ip->i_size = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131 ip->i_d.di_nextents = 0;
1132 ASSERT(ip->i_d.di_nblocks == 0);
1133 xfs_ichgtime(ip, XFS_ICHGTIME_CHG|XFS_ICHGTIME_ACC|XFS_ICHGTIME_MOD);
1134 /*
1135 * di_gen will have been taken care of in xfs_iread.
1136 */
1137 ip->i_d.di_extsize = 0;
1138 ip->i_d.di_dmevmask = 0;
1139 ip->i_d.di_dmstate = 0;
1140 ip->i_d.di_flags = 0;
1141 flags = XFS_ILOG_CORE;
1142 switch (mode & S_IFMT) {
1143 case S_IFIFO:
1144 case S_IFCHR:
1145 case S_IFBLK:
1146 case S_IFSOCK:
1147 ip->i_d.di_format = XFS_DINODE_FMT_DEV;
1148 ip->i_df.if_u2.if_rdev = rdev;
1149 ip->i_df.if_flags = 0;
1150 flags |= XFS_ILOG_DEV;
1151 break;
1152 case S_IFREG:
David Chinnerb11f94d2007-07-11 11:09:33 +10001153 if (pip && xfs_inode_is_filestream(pip)) {
David Chinner2a82b8b2007-07-11 11:09:12 +10001154 error = xfs_filestream_associate(pip, ip);
1155 if (error < 0)
1156 return -error;
1157 if (!error)
1158 xfs_iflags_set(ip, XFS_IFILESTREAM);
1159 }
1160 /* fall through */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 case S_IFDIR:
David Chinnerb11f94d2007-07-11 11:09:33 +10001162 if (pip && (pip->i_d.di_flags & XFS_DIFLAG_ANY)) {
Nathan Scott365ca832005-06-21 15:39:12 +10001163 uint di_flags = 0;
1164
1165 if ((mode & S_IFMT) == S_IFDIR) {
1166 if (pip->i_d.di_flags & XFS_DIFLAG_RTINHERIT)
1167 di_flags |= XFS_DIFLAG_RTINHERIT;
Nathan Scottdd9f4382006-01-11 15:28:28 +11001168 if (pip->i_d.di_flags & XFS_DIFLAG_EXTSZINHERIT) {
1169 di_flags |= XFS_DIFLAG_EXTSZINHERIT;
1170 ip->i_d.di_extsize = pip->i_d.di_extsize;
1171 }
1172 } else if ((mode & S_IFMT) == S_IFREG) {
Christoph Hellwig613d7042007-10-11 17:44:08 +10001173 if (pip->i_d.di_flags & XFS_DIFLAG_RTINHERIT)
Nathan Scott365ca832005-06-21 15:39:12 +10001174 di_flags |= XFS_DIFLAG_REALTIME;
Nathan Scottdd9f4382006-01-11 15:28:28 +11001175 if (pip->i_d.di_flags & XFS_DIFLAG_EXTSZINHERIT) {
1176 di_flags |= XFS_DIFLAG_EXTSIZE;
1177 ip->i_d.di_extsize = pip->i_d.di_extsize;
1178 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179 }
1180 if ((pip->i_d.di_flags & XFS_DIFLAG_NOATIME) &&
1181 xfs_inherit_noatime)
Nathan Scott365ca832005-06-21 15:39:12 +10001182 di_flags |= XFS_DIFLAG_NOATIME;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001183 if ((pip->i_d.di_flags & XFS_DIFLAG_NODUMP) &&
1184 xfs_inherit_nodump)
Nathan Scott365ca832005-06-21 15:39:12 +10001185 di_flags |= XFS_DIFLAG_NODUMP;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 if ((pip->i_d.di_flags & XFS_DIFLAG_SYNC) &&
1187 xfs_inherit_sync)
Nathan Scott365ca832005-06-21 15:39:12 +10001188 di_flags |= XFS_DIFLAG_SYNC;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 if ((pip->i_d.di_flags & XFS_DIFLAG_NOSYMLINKS) &&
1190 xfs_inherit_nosymlinks)
Nathan Scott365ca832005-06-21 15:39:12 +10001191 di_flags |= XFS_DIFLAG_NOSYMLINKS;
1192 if (pip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
1193 di_flags |= XFS_DIFLAG_PROJINHERIT;
Barry Naujokd3446ea2006-06-09 14:54:19 +10001194 if ((pip->i_d.di_flags & XFS_DIFLAG_NODEFRAG) &&
1195 xfs_inherit_nodefrag)
1196 di_flags |= XFS_DIFLAG_NODEFRAG;
David Chinner2a82b8b2007-07-11 11:09:12 +10001197 if (pip->i_d.di_flags & XFS_DIFLAG_FILESTREAM)
1198 di_flags |= XFS_DIFLAG_FILESTREAM;
Nathan Scott365ca832005-06-21 15:39:12 +10001199 ip->i_d.di_flags |= di_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 }
1201 /* FALLTHROUGH */
1202 case S_IFLNK:
1203 ip->i_d.di_format = XFS_DINODE_FMT_EXTENTS;
1204 ip->i_df.if_flags = XFS_IFEXTENTS;
1205 ip->i_df.if_bytes = ip->i_df.if_real_bytes = 0;
1206 ip->i_df.if_u1.if_extents = NULL;
1207 break;
1208 default:
1209 ASSERT(0);
1210 }
1211 /*
1212 * Attribute fork settings for new inode.
1213 */
1214 ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
1215 ip->i_d.di_anextents = 0;
1216
1217 /*
1218 * Log the new values stuffed into the inode.
1219 */
1220 xfs_trans_log_inode(tp, ip, flags);
1221
Nathan Scottb83bd132006-06-09 16:48:30 +10001222 /* now that we have an i_mode we can setup inode ops and unlock */
Christoph Hellwig745f6912007-08-30 17:20:39 +10001223 xfs_initialize_vnode(tp->t_mountp, vp, ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001224
1225 *ipp = ip;
1226 return 0;
1227}
1228
1229/*
1230 * Check to make sure that there are no blocks allocated to the
1231 * file beyond the size of the file. We don't check this for
1232 * files with fixed size extents or real time extents, but we
1233 * at least do it for regular files.
1234 */
1235#ifdef DEBUG
1236void
1237xfs_isize_check(
1238 xfs_mount_t *mp,
1239 xfs_inode_t *ip,
1240 xfs_fsize_t isize)
1241{
1242 xfs_fileoff_t map_first;
1243 int nimaps;
1244 xfs_bmbt_irec_t imaps[2];
1245
1246 if ((ip->i_d.di_mode & S_IFMT) != S_IFREG)
1247 return;
1248
Eric Sandeen71ddabb2007-11-23 16:29:42 +11001249 if (XFS_IS_REALTIME_INODE(ip))
1250 return;
1251
1252 if (ip->i_d.di_flags & XFS_DIFLAG_EXTSIZE)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253 return;
1254
1255 nimaps = 2;
1256 map_first = XFS_B_TO_FSB(mp, (xfs_ufsize_t)isize);
1257 /*
1258 * The filesystem could be shutting down, so bmapi may return
1259 * an error.
1260 */
1261 if (xfs_bmapi(NULL, ip, map_first,
1262 (XFS_B_TO_FSB(mp,
1263 (xfs_ufsize_t)XFS_MAXIOFFSET(mp)) -
1264 map_first),
1265 XFS_BMAPI_ENTIRE, NULL, 0, imaps, &nimaps,
Olaf Weber3e57ecf2006-06-09 14:48:12 +10001266 NULL, NULL))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 return;
1268 ASSERT(nimaps == 1);
1269 ASSERT(imaps[0].br_startblock == HOLESTARTBLOCK);
1270}
1271#endif /* DEBUG */
1272
1273/*
1274 * Calculate the last possible buffered byte in a file. This must
1275 * include data that was buffered beyond the EOF by the write code.
1276 * This also needs to deal with overflowing the xfs_fsize_t type
1277 * which can happen for sizes near the limit.
1278 *
1279 * We also need to take into account any blocks beyond the EOF. It
1280 * may be the case that they were buffered by a write which failed.
1281 * In that case the pages will still be in memory, but the inode size
1282 * will never have been updated.
1283 */
1284xfs_fsize_t
1285xfs_file_last_byte(
1286 xfs_inode_t *ip)
1287{
1288 xfs_mount_t *mp;
1289 xfs_fsize_t last_byte;
1290 xfs_fileoff_t last_block;
1291 xfs_fileoff_t size_last_block;
1292 int error;
1293
Christoph Hellwig579aa9c2008-04-22 17:34:00 +10001294 ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL|XFS_IOLOCK_SHARED));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295
1296 mp = ip->i_mount;
1297 /*
1298 * Only check for blocks beyond the EOF if the extents have
1299 * been read in. This eliminates the need for the inode lock,
1300 * and it also saves us from looking when it really isn't
1301 * necessary.
1302 */
1303 if (ip->i_df.if_flags & XFS_IFEXTENTS) {
1304 error = xfs_bmap_last_offset(NULL, ip, &last_block,
1305 XFS_DATA_FORK);
1306 if (error) {
1307 last_block = 0;
1308 }
1309 } else {
1310 last_block = 0;
1311 }
Lachlan McIlroyba87ea62007-05-08 13:49:46 +10001312 size_last_block = XFS_B_TO_FSB(mp, (xfs_ufsize_t)ip->i_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313 last_block = XFS_FILEOFF_MAX(last_block, size_last_block);
1314
1315 last_byte = XFS_FSB_TO_B(mp, last_block);
1316 if (last_byte < 0) {
1317 return XFS_MAXIOFFSET(mp);
1318 }
1319 last_byte += (1 << mp->m_writeio_log);
1320 if (last_byte < 0) {
1321 return XFS_MAXIOFFSET(mp);
1322 }
1323 return last_byte;
1324}
1325
1326#if defined(XFS_RW_TRACE)
1327STATIC void
1328xfs_itrunc_trace(
1329 int tag,
1330 xfs_inode_t *ip,
1331 int flag,
1332 xfs_fsize_t new_size,
1333 xfs_off_t toss_start,
1334 xfs_off_t toss_finish)
1335{
1336 if (ip->i_rwtrace == NULL) {
1337 return;
1338 }
1339
1340 ktrace_enter(ip->i_rwtrace,
1341 (void*)((long)tag),
1342 (void*)ip,
1343 (void*)(unsigned long)((ip->i_d.di_size >> 32) & 0xffffffff),
1344 (void*)(unsigned long)(ip->i_d.di_size & 0xffffffff),
1345 (void*)((long)flag),
1346 (void*)(unsigned long)((new_size >> 32) & 0xffffffff),
1347 (void*)(unsigned long)(new_size & 0xffffffff),
1348 (void*)(unsigned long)((toss_start >> 32) & 0xffffffff),
1349 (void*)(unsigned long)(toss_start & 0xffffffff),
1350 (void*)(unsigned long)((toss_finish >> 32) & 0xffffffff),
1351 (void*)(unsigned long)(toss_finish & 0xffffffff),
1352 (void*)(unsigned long)current_cpu(),
Yingping Luf1fdc842006-03-22 12:44:15 +11001353 (void*)(unsigned long)current_pid(),
1354 (void*)NULL,
1355 (void*)NULL,
1356 (void*)NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357}
1358#else
1359#define xfs_itrunc_trace(tag, ip, flag, new_size, toss_start, toss_finish)
1360#endif
1361
1362/*
1363 * Start the truncation of the file to new_size. The new size
1364 * must be smaller than the current size. This routine will
1365 * clear the buffer and page caches of file data in the removed
1366 * range, and xfs_itruncate_finish() will remove the underlying
1367 * disk blocks.
1368 *
1369 * The inode must have its I/O lock locked EXCLUSIVELY, and it
1370 * must NOT have the inode lock held at all. This is because we're
1371 * calling into the buffer/page cache code and we can't hold the
1372 * inode lock when we do so.
1373 *
David Chinner38e22992006-03-22 12:47:15 +11001374 * We need to wait for any direct I/Os in flight to complete before we
1375 * proceed with the truncate. This is needed to prevent the extents
1376 * being read or written by the direct I/Os from being removed while the
1377 * I/O is in flight as there is no other method of synchronising
1378 * direct I/O with the truncate operation. Also, because we hold
1379 * the IOLOCK in exclusive mode, we prevent new direct I/Os from being
1380 * started until the truncate completes and drops the lock. Essentially,
1381 * the vn_iowait() call forms an I/O barrier that provides strict ordering
1382 * between direct I/Os and the truncate operation.
1383 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384 * The flags parameter can have either the value XFS_ITRUNC_DEFINITE
1385 * or XFS_ITRUNC_MAYBE. The XFS_ITRUNC_MAYBE value should be used
1386 * in the case that the caller is locking things out of order and
1387 * may not be able to call xfs_itruncate_finish() with the inode lock
1388 * held without dropping the I/O lock. If the caller must drop the
1389 * I/O lock before calling xfs_itruncate_finish(), then xfs_itruncate_start()
1390 * must be called again with all the same restrictions as the initial
1391 * call.
1392 */
Lachlan McIlroyd3cf2092007-05-08 13:49:27 +10001393int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394xfs_itruncate_start(
1395 xfs_inode_t *ip,
1396 uint flags,
1397 xfs_fsize_t new_size)
1398{
1399 xfs_fsize_t last_byte;
1400 xfs_off_t toss_start;
1401 xfs_mount_t *mp;
Lachlan McIlroyd3cf2092007-05-08 13:49:27 +10001402 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403
Christoph Hellwig579aa9c2008-04-22 17:34:00 +10001404 ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
Lachlan McIlroyba87ea62007-05-08 13:49:46 +10001405 ASSERT((new_size == 0) || (new_size <= ip->i_size));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001406 ASSERT((flags == XFS_ITRUNC_DEFINITE) ||
1407 (flags == XFS_ITRUNC_MAYBE));
1408
1409 mp = ip->i_mount;
Yingping Lu9fa80462006-03-22 12:44:35 +11001410
Lachlan McIlroyc734c792007-12-18 16:17:41 +11001411 /* wait for the completion of any pending DIOs */
1412 if (new_size < ip->i_size)
1413 vn_iowait(ip);
1414
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415 /*
Nathan Scott67fcaa72006-06-09 17:00:52 +10001416 * Call toss_pages or flushinval_pages to get rid of pages
Linus Torvalds1da177e2005-04-16 15:20:36 -07001417 * overlapping the region being removed. We have to use
Nathan Scott67fcaa72006-06-09 17:00:52 +10001418 * the less efficient flushinval_pages in the case that the
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419 * caller may not be able to finish the truncate without
1420 * dropping the inode's I/O lock. Make sure
1421 * to catch any pages brought in by buffers overlapping
1422 * the EOF by searching out beyond the isize by our
1423 * block size. We round new_size up to a block boundary
1424 * so that we don't toss things on the same block as
1425 * new_size but before it.
1426 *
Nathan Scott67fcaa72006-06-09 17:00:52 +10001427 * Before calling toss_page or flushinval_pages, make sure to
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428 * call remapf() over the same region if the file is mapped.
1429 * This frees up mapped file references to the pages in the
Nathan Scott67fcaa72006-06-09 17:00:52 +10001430 * given range and for the flushinval_pages case it ensures
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431 * that we get the latest mapped changes flushed out.
1432 */
1433 toss_start = XFS_B_TO_FSB(mp, (xfs_ufsize_t)new_size);
1434 toss_start = XFS_FSB_TO_B(mp, toss_start);
1435 if (toss_start < 0) {
1436 /*
1437 * The place to start tossing is beyond our maximum
1438 * file size, so there is no way that the data extended
1439 * out there.
1440 */
Lachlan McIlroyd3cf2092007-05-08 13:49:27 +10001441 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 }
1443 last_byte = xfs_file_last_byte(ip);
1444 xfs_itrunc_trace(XFS_ITRUNC_START, ip, flags, new_size, toss_start,
1445 last_byte);
1446 if (last_byte > toss_start) {
1447 if (flags & XFS_ITRUNC_DEFINITE) {
Christoph Hellwig739bfb22007-08-29 10:58:01 +10001448 xfs_tosspages(ip, toss_start,
1449 -1, FI_REMAPF_LOCKED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001450 } else {
Christoph Hellwig739bfb22007-08-29 10:58:01 +10001451 error = xfs_flushinval_pages(ip, toss_start,
1452 -1, FI_REMAPF_LOCKED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453 }
1454 }
1455
1456#ifdef DEBUG
1457 if (new_size == 0) {
Christoph Hellwigdf80c932008-08-13 16:22:09 +10001458 ASSERT(VN_CACHED(VFS_I(ip)) == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459 }
1460#endif
Lachlan McIlroyd3cf2092007-05-08 13:49:27 +10001461 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001462}
1463
1464/*
David Chinnerf6485052008-04-17 16:50:04 +10001465 * Shrink the file to the given new_size. The new size must be smaller than
1466 * the current size. This will free up the underlying blocks in the removed
1467 * range after a call to xfs_itruncate_start() or xfs_atruncate_start().
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468 *
David Chinnerf6485052008-04-17 16:50:04 +10001469 * The transaction passed to this routine must have made a permanent log
1470 * reservation of at least XFS_ITRUNCATE_LOG_RES. This routine may commit the
1471 * given transaction and start new ones, so make sure everything involved in
1472 * the transaction is tidy before calling here. Some transaction will be
1473 * returned to the caller to be committed. The incoming transaction must
1474 * already include the inode, and both inode locks must be held exclusively.
1475 * The inode must also be "held" within the transaction. On return the inode
1476 * will be "held" within the returned transaction. This routine does NOT
1477 * require any disk space to be reserved for it within the transaction.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478 *
David Chinnerf6485052008-04-17 16:50:04 +10001479 * The fork parameter must be either xfs_attr_fork or xfs_data_fork, and it
1480 * indicates the fork which is to be truncated. For the attribute fork we only
1481 * support truncation to size 0.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482 *
David Chinnerf6485052008-04-17 16:50:04 +10001483 * We use the sync parameter to indicate whether or not the first transaction
1484 * we perform might have to be synchronous. For the attr fork, it needs to be
1485 * so if the unlink of the inode is not yet known to be permanent in the log.
1486 * This keeps us from freeing and reusing the blocks of the attribute fork
1487 * before the unlink of the inode becomes permanent.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001488 *
David Chinnerf6485052008-04-17 16:50:04 +10001489 * For the data fork, we normally have to run synchronously if we're being
1490 * called out of the inactive path or we're being called out of the create path
1491 * where we're truncating an existing file. Either way, the truncate needs to
1492 * be sync so blocks don't reappear in the file with altered data in case of a
1493 * crash. wsync filesystems can run the first case async because anything that
1494 * shrinks the inode has to run sync so by the time we're called here from
1495 * inactive, the inode size is permanently set to 0.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496 *
David Chinnerf6485052008-04-17 16:50:04 +10001497 * Calls from the truncate path always need to be sync unless we're in a wsync
1498 * filesystem and the file has already been unlinked.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499 *
David Chinnerf6485052008-04-17 16:50:04 +10001500 * The caller is responsible for correctly setting the sync parameter. It gets
1501 * too hard for us to guess here which path we're being called out of just
1502 * based on inode state.
1503 *
1504 * If we get an error, we must return with the inode locked and linked into the
1505 * current transaction. This keeps things simple for the higher level code,
1506 * because it always knows that the inode is locked and held in the transaction
1507 * that returns to it whether errors occur or not. We don't mark the inode
1508 * dirty on error so that transactions can be easily aborted if possible.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509 */
1510int
1511xfs_itruncate_finish(
1512 xfs_trans_t **tp,
1513 xfs_inode_t *ip,
1514 xfs_fsize_t new_size,
1515 int fork,
1516 int sync)
1517{
1518 xfs_fsblock_t first_block;
1519 xfs_fileoff_t first_unmap_block;
1520 xfs_fileoff_t last_block;
1521 xfs_filblks_t unmap_len=0;
1522 xfs_mount_t *mp;
1523 xfs_trans_t *ntp;
1524 int done;
1525 int committed;
1526 xfs_bmap_free_t free_list;
1527 int error;
1528
Christoph Hellwig579aa9c2008-04-22 17:34:00 +10001529 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_IOLOCK_EXCL));
Lachlan McIlroyba87ea62007-05-08 13:49:46 +10001530 ASSERT((new_size == 0) || (new_size <= ip->i_size));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531 ASSERT(*tp != NULL);
1532 ASSERT((*tp)->t_flags & XFS_TRANS_PERM_LOG_RES);
1533 ASSERT(ip->i_transp == *tp);
1534 ASSERT(ip->i_itemp != NULL);
1535 ASSERT(ip->i_itemp->ili_flags & XFS_ILI_HOLD);
1536
1537
1538 ntp = *tp;
1539 mp = (ntp)->t_mountp;
1540 ASSERT(! XFS_NOT_DQATTACHED(mp, ip));
1541
1542 /*
1543 * We only support truncating the entire attribute fork.
1544 */
1545 if (fork == XFS_ATTR_FORK) {
1546 new_size = 0LL;
1547 }
1548 first_unmap_block = XFS_B_TO_FSB(mp, (xfs_ufsize_t)new_size);
1549 xfs_itrunc_trace(XFS_ITRUNC_FINISH1, ip, 0, new_size, 0, 0);
1550 /*
1551 * The first thing we do is set the size to new_size permanently
1552 * on disk. This way we don't have to worry about anyone ever
1553 * being able to look at the data being freed even in the face
1554 * of a crash. What we're getting around here is the case where
1555 * we free a block, it is allocated to another file, it is written
1556 * to, and then we crash. If the new data gets written to the
1557 * file but the log buffers containing the free and reallocation
1558 * don't, then we'd end up with garbage in the blocks being freed.
1559 * As long as we make the new_size permanent before actually
1560 * freeing any blocks it doesn't matter if they get writtten to.
1561 *
1562 * The callers must signal into us whether or not the size
1563 * setting here must be synchronous. There are a few cases
1564 * where it doesn't have to be synchronous. Those cases
1565 * occur if the file is unlinked and we know the unlink is
1566 * permanent or if the blocks being truncated are guaranteed
1567 * to be beyond the inode eof (regardless of the link count)
1568 * and the eof value is permanent. Both of these cases occur
1569 * only on wsync-mounted filesystems. In those cases, we're
1570 * guaranteed that no user will ever see the data in the blocks
1571 * that are being truncated so the truncate can run async.
1572 * In the free beyond eof case, the file may wind up with
1573 * more blocks allocated to it than it needs if we crash
1574 * and that won't get fixed until the next time the file
1575 * is re-opened and closed but that's ok as that shouldn't
1576 * be too many blocks.
1577 *
1578 * However, we can't just make all wsync xactions run async
1579 * because there's one call out of the create path that needs
1580 * to run sync where it's truncating an existing file to size
1581 * 0 whose size is > 0.
1582 *
1583 * It's probably possible to come up with a test in this
1584 * routine that would correctly distinguish all the above
1585 * cases from the values of the function parameters and the
1586 * inode state but for sanity's sake, I've decided to let the
1587 * layers above just tell us. It's simpler to correctly figure
1588 * out in the layer above exactly under what conditions we
1589 * can run async and I think it's easier for others read and
1590 * follow the logic in case something has to be changed.
1591 * cscope is your friend -- rcc.
1592 *
1593 * The attribute fork is much simpler.
1594 *
1595 * For the attribute fork we allow the caller to tell us whether
1596 * the unlink of the inode that led to this call is yet permanent
1597 * in the on disk log. If it is not and we will be freeing extents
1598 * in this inode then we make the first transaction synchronous
1599 * to make sure that the unlink is permanent by the time we free
1600 * the blocks.
1601 */
1602 if (fork == XFS_DATA_FORK) {
1603 if (ip->i_d.di_nextents > 0) {
Lachlan McIlroyba87ea62007-05-08 13:49:46 +10001604 /*
1605 * If we are not changing the file size then do
1606 * not update the on-disk file size - we may be
1607 * called from xfs_inactive_free_eofblocks(). If we
1608 * update the on-disk file size and then the system
1609 * crashes before the contents of the file are
1610 * flushed to disk then the files may be full of
1611 * holes (ie NULL files bug).
1612 */
1613 if (ip->i_size != new_size) {
1614 ip->i_d.di_size = new_size;
1615 ip->i_size = new_size;
1616 xfs_trans_log_inode(ntp, ip, XFS_ILOG_CORE);
1617 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618 }
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);
Lachlan McIlroy541d7d32007-10-11 17:34:33 +10001661 error = xfs_bunmapi(ntp, ip,
Olaf Weber3e57ecf2006-06-09 14:48:12 +10001662 first_unmap_block, unmap_len,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663 XFS_BMAPI_AFLAG(fork) |
1664 (sync ? 0 : XFS_BMAPI_ASYNC),
1665 XFS_ITRUNC_MAX_EXTENTS,
Olaf Weber3e57ecf2006-06-09 14:48:12 +10001666 &first_block, &free_list,
1667 NULL, &done);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 if (error) {
1669 /*
1670 * If the bunmapi call encounters an error,
1671 * return to the caller where the transaction
1672 * can be properly aborted. We just need to
1673 * make sure we're not holding any resources
1674 * that we were not when we came in.
1675 */
1676 xfs_bmap_cancel(&free_list);
1677 return error;
1678 }
1679
1680 /*
1681 * Duplicate the transaction that has the permanent
1682 * reservation and commit the old transaction.
1683 */
Eric Sandeenf7c99b62007-02-10 18:37:16 +11001684 error = xfs_bmap_finish(tp, &free_list, &committed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685 ntp = *tp;
David Chinnerf6485052008-04-17 16:50:04 +10001686 if (committed) {
1687 /* link the inode into the next xact in the chain */
1688 xfs_trans_ijoin(ntp, ip,
1689 XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
1690 xfs_trans_ihold(ntp, ip);
1691 }
1692
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693 if (error) {
1694 /*
David Chinnerf6485052008-04-17 16:50:04 +10001695 * If the bmap finish call encounters an error, return
1696 * to the caller where the transaction can be properly
1697 * aborted. We just need to make sure we're not
1698 * holding any resources that we were not when we came
1699 * in.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001700 *
David Chinnerf6485052008-04-17 16:50:04 +10001701 * Aborting from this point might lose some blocks in
1702 * the file system, but oh well.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 */
1704 xfs_bmap_cancel(&free_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705 return error;
1706 }
1707
1708 if (committed) {
1709 /*
David Chinnerf6485052008-04-17 16:50:04 +10001710 * Mark the inode dirty so it will be logged and
David Chinnere5720ee2008-04-10 12:21:18 +10001711 * moved forward in the log as part of every commit.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713 xfs_trans_log_inode(ntp, ip, XFS_ILOG_CORE);
1714 }
David Chinnerf6485052008-04-17 16:50:04 +10001715
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716 ntp = xfs_trans_dup(ntp);
David Chinnere5720ee2008-04-10 12:21:18 +10001717 error = xfs_trans_commit(*tp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718 *tp = ntp;
David Chinnere5720ee2008-04-10 12:21:18 +10001719
David Chinnerf6485052008-04-17 16:50:04 +10001720 /* link the inode into the next transaction in the chain */
1721 xfs_trans_ijoin(ntp, ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
1722 xfs_trans_ihold(ntp, ip);
1723
1724 if (!error)
1725 error = xfs_trans_reserve(ntp, 0,
1726 XFS_ITRUNCATE_LOG_RES(mp), 0,
1727 XFS_TRANS_PERM_LOG_RES,
1728 XFS_ITRUNCATE_LOG_COUNT);
1729 if (error)
1730 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731 }
1732 /*
1733 * Only update the size in the case of the data fork, but
1734 * always re-log the inode so that our permanent transaction
1735 * can keep on rolling it forward in the log.
1736 */
1737 if (fork == XFS_DATA_FORK) {
1738 xfs_isize_check(mp, ip, new_size);
Lachlan McIlroyba87ea62007-05-08 13:49:46 +10001739 /*
1740 * If we are not changing the file size then do
1741 * not update the on-disk file size - we may be
1742 * called from xfs_inactive_free_eofblocks(). If we
1743 * update the on-disk file size and then the system
1744 * crashes before the contents of the file are
1745 * flushed to disk then the files may be full of
1746 * holes (ie NULL files bug).
1747 */
1748 if (ip->i_size != new_size) {
1749 ip->i_d.di_size = new_size;
1750 ip->i_size = new_size;
1751 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752 }
1753 xfs_trans_log_inode(ntp, ip, XFS_ILOG_CORE);
1754 ASSERT((new_size != 0) ||
1755 (fork == XFS_ATTR_FORK) ||
1756 (ip->i_delayed_blks == 0));
1757 ASSERT((new_size != 0) ||
1758 (fork == XFS_ATTR_FORK) ||
1759 (ip->i_d.di_nextents == 0));
1760 xfs_itrunc_trace(XFS_ITRUNC_FINISH2, ip, 0, new_size, 0, 0);
1761 return 0;
1762}
1763
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764/*
1765 * This is called when the inode's link count goes to 0.
1766 * We place the on-disk inode on a list in the AGI. It
1767 * will be pulled from this list when the inode is freed.
1768 */
1769int
1770xfs_iunlink(
1771 xfs_trans_t *tp,
1772 xfs_inode_t *ip)
1773{
1774 xfs_mount_t *mp;
1775 xfs_agi_t *agi;
1776 xfs_dinode_t *dip;
1777 xfs_buf_t *agibp;
1778 xfs_buf_t *ibp;
1779 xfs_agnumber_t agno;
1780 xfs_daddr_t agdaddr;
1781 xfs_agino_t agino;
1782 short bucket_index;
1783 int offset;
1784 int error;
1785 int agi_ok;
1786
1787 ASSERT(ip->i_d.di_nlink == 0);
1788 ASSERT(ip->i_d.di_mode != 0);
1789 ASSERT(ip->i_transp == tp);
1790
1791 mp = tp->t_mountp;
1792
1793 agno = XFS_INO_TO_AGNO(mp, ip->i_ino);
1794 agdaddr = XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp));
1795
1796 /*
1797 * Get the agi buffer first. It ensures lock ordering
1798 * on the list.
1799 */
1800 error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, agdaddr,
1801 XFS_FSS_TO_BB(mp, 1), 0, &agibp);
Vlad Apostolov859d7182007-10-11 17:44:18 +10001802 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803 return error;
Vlad Apostolov859d7182007-10-11 17:44:18 +10001804
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805 /*
1806 * Validate the magic number of the agi block.
1807 */
1808 agi = XFS_BUF_TO_AGI(agibp);
1809 agi_ok =
Christoph Hellwig16259e72005-11-02 15:11:25 +11001810 be32_to_cpu(agi->agi_magicnum) == XFS_AGI_MAGIC &&
1811 XFS_AGI_GOOD_VERSION(be32_to_cpu(agi->agi_versionnum));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812 if (unlikely(XFS_TEST_ERROR(!agi_ok, mp, XFS_ERRTAG_IUNLINK,
1813 XFS_RANDOM_IUNLINK))) {
1814 XFS_CORRUPTION_ERROR("xfs_iunlink", XFS_ERRLEVEL_LOW, mp, agi);
1815 xfs_trans_brelse(tp, agibp);
1816 return XFS_ERROR(EFSCORRUPTED);
1817 }
1818 /*
1819 * Get the index into the agi hash table for the
1820 * list this inode will go on.
1821 */
1822 agino = XFS_INO_TO_AGINO(mp, ip->i_ino);
1823 ASSERT(agino != 0);
1824 bucket_index = agino % XFS_AGI_UNLINKED_BUCKETS;
1825 ASSERT(agi->agi_unlinked[bucket_index]);
Christoph Hellwig16259e72005-11-02 15:11:25 +11001826 ASSERT(be32_to_cpu(agi->agi_unlinked[bucket_index]) != agino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827
Christoph Hellwig16259e72005-11-02 15:11:25 +11001828 if (be32_to_cpu(agi->agi_unlinked[bucket_index]) != NULLAGINO) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829 /*
1830 * There is already another inode in the bucket we need
1831 * to add ourselves to. Add us at the front of the list.
1832 * Here we put the head pointer into our next pointer,
1833 * and then we fall through to point the head at us.
1834 */
David Chinnera3f74ff2008-03-06 13:43:42 +11001835 error = xfs_itobp(mp, tp, ip, &dip, &ibp, 0, 0, XFS_BUF_LOCK);
Vlad Apostolovc319b582007-11-23 16:27:51 +11001836 if (error)
1837 return error;
1838
Christoph Hellwig347d1c02007-08-28 13:57:51 +10001839 ASSERT(be32_to_cpu(dip->di_next_unlinked) == NULLAGINO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001840 /* both on-disk, don't endian flip twice */
1841 dip->di_next_unlinked = agi->agi_unlinked[bucket_index];
1842 offset = ip->i_boffset +
1843 offsetof(xfs_dinode_t, di_next_unlinked);
1844 xfs_trans_inode_buf(tp, ibp);
1845 xfs_trans_log_buf(tp, ibp, offset,
1846 (offset + sizeof(xfs_agino_t) - 1));
1847 xfs_inobp_check(mp, ibp);
1848 }
1849
1850 /*
1851 * Point the bucket head pointer at the inode being inserted.
1852 */
1853 ASSERT(agino != 0);
Christoph Hellwig16259e72005-11-02 15:11:25 +11001854 agi->agi_unlinked[bucket_index] = cpu_to_be32(agino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855 offset = offsetof(xfs_agi_t, agi_unlinked) +
1856 (sizeof(xfs_agino_t) * bucket_index);
1857 xfs_trans_log_buf(tp, agibp, offset,
1858 (offset + sizeof(xfs_agino_t) - 1));
1859 return 0;
1860}
1861
1862/*
1863 * Pull the on-disk inode from the AGI unlinked list.
1864 */
1865STATIC int
1866xfs_iunlink_remove(
1867 xfs_trans_t *tp,
1868 xfs_inode_t *ip)
1869{
1870 xfs_ino_t next_ino;
1871 xfs_mount_t *mp;
1872 xfs_agi_t *agi;
1873 xfs_dinode_t *dip;
1874 xfs_buf_t *agibp;
1875 xfs_buf_t *ibp;
1876 xfs_agnumber_t agno;
1877 xfs_daddr_t agdaddr;
1878 xfs_agino_t agino;
1879 xfs_agino_t next_agino;
1880 xfs_buf_t *last_ibp;
Nathan Scott6fdf8cc2006-06-28 10:13:52 +10001881 xfs_dinode_t *last_dip = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882 short bucket_index;
Nathan Scott6fdf8cc2006-06-28 10:13:52 +10001883 int offset, last_offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884 int error;
1885 int agi_ok;
1886
1887 /*
1888 * First pull the on-disk inode from the AGI unlinked list.
1889 */
1890 mp = tp->t_mountp;
1891
1892 agno = XFS_INO_TO_AGNO(mp, ip->i_ino);
1893 agdaddr = XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp));
1894
1895 /*
1896 * Get the agi buffer first. It ensures lock ordering
1897 * on the list.
1898 */
1899 error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, agdaddr,
1900 XFS_FSS_TO_BB(mp, 1), 0, &agibp);
1901 if (error) {
1902 cmn_err(CE_WARN,
1903 "xfs_iunlink_remove: xfs_trans_read_buf() returned an error %d on %s. Returning error.",
1904 error, mp->m_fsname);
1905 return error;
1906 }
1907 /*
1908 * Validate the magic number of the agi block.
1909 */
1910 agi = XFS_BUF_TO_AGI(agibp);
1911 agi_ok =
Christoph Hellwig16259e72005-11-02 15:11:25 +11001912 be32_to_cpu(agi->agi_magicnum) == XFS_AGI_MAGIC &&
1913 XFS_AGI_GOOD_VERSION(be32_to_cpu(agi->agi_versionnum));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914 if (unlikely(XFS_TEST_ERROR(!agi_ok, mp, XFS_ERRTAG_IUNLINK_REMOVE,
1915 XFS_RANDOM_IUNLINK_REMOVE))) {
1916 XFS_CORRUPTION_ERROR("xfs_iunlink_remove", XFS_ERRLEVEL_LOW,
1917 mp, agi);
1918 xfs_trans_brelse(tp, agibp);
1919 cmn_err(CE_WARN,
1920 "xfs_iunlink_remove: XFS_TEST_ERROR() returned an error on %s. Returning EFSCORRUPTED.",
1921 mp->m_fsname);
1922 return XFS_ERROR(EFSCORRUPTED);
1923 }
1924 /*
1925 * Get the index into the agi hash table for the
1926 * list this inode will go on.
1927 */
1928 agino = XFS_INO_TO_AGINO(mp, ip->i_ino);
1929 ASSERT(agino != 0);
1930 bucket_index = agino % XFS_AGI_UNLINKED_BUCKETS;
Christoph Hellwig16259e72005-11-02 15:11:25 +11001931 ASSERT(be32_to_cpu(agi->agi_unlinked[bucket_index]) != NULLAGINO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001932 ASSERT(agi->agi_unlinked[bucket_index]);
1933
Christoph Hellwig16259e72005-11-02 15:11:25 +11001934 if (be32_to_cpu(agi->agi_unlinked[bucket_index]) == agino) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935 /*
1936 * We're at the head of the list. Get the inode's
1937 * on-disk buffer to see if there is anyone after us
1938 * on the list. Only modify our next pointer if it
1939 * is not already NULLAGINO. This saves us the overhead
1940 * of dealing with the buffer when there is no need to
1941 * change it.
1942 */
David Chinnera3f74ff2008-03-06 13:43:42 +11001943 error = xfs_itobp(mp, tp, ip, &dip, &ibp, 0, 0, XFS_BUF_LOCK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001944 if (error) {
1945 cmn_err(CE_WARN,
1946 "xfs_iunlink_remove: xfs_itobp() returned an error %d on %s. Returning error.",
1947 error, mp->m_fsname);
1948 return error;
1949 }
Christoph Hellwig347d1c02007-08-28 13:57:51 +10001950 next_agino = be32_to_cpu(dip->di_next_unlinked);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951 ASSERT(next_agino != 0);
1952 if (next_agino != NULLAGINO) {
Christoph Hellwig347d1c02007-08-28 13:57:51 +10001953 dip->di_next_unlinked = cpu_to_be32(NULLAGINO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954 offset = ip->i_boffset +
1955 offsetof(xfs_dinode_t, di_next_unlinked);
1956 xfs_trans_inode_buf(tp, ibp);
1957 xfs_trans_log_buf(tp, ibp, offset,
1958 (offset + sizeof(xfs_agino_t) - 1));
1959 xfs_inobp_check(mp, ibp);
1960 } else {
1961 xfs_trans_brelse(tp, ibp);
1962 }
1963 /*
1964 * Point the bucket head pointer at the next inode.
1965 */
1966 ASSERT(next_agino != 0);
1967 ASSERT(next_agino != agino);
Christoph Hellwig16259e72005-11-02 15:11:25 +11001968 agi->agi_unlinked[bucket_index] = cpu_to_be32(next_agino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001969 offset = offsetof(xfs_agi_t, agi_unlinked) +
1970 (sizeof(xfs_agino_t) * bucket_index);
1971 xfs_trans_log_buf(tp, agibp, offset,
1972 (offset + sizeof(xfs_agino_t) - 1));
1973 } else {
1974 /*
1975 * We need to search the list for the inode being freed.
1976 */
Christoph Hellwig16259e72005-11-02 15:11:25 +11001977 next_agino = be32_to_cpu(agi->agi_unlinked[bucket_index]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001978 last_ibp = NULL;
1979 while (next_agino != agino) {
1980 /*
1981 * If the last inode wasn't the one pointing to
1982 * us, then release its buffer since we're not
1983 * going to do anything with it.
1984 */
1985 if (last_ibp != NULL) {
1986 xfs_trans_brelse(tp, last_ibp);
1987 }
1988 next_ino = XFS_AGINO_TO_INO(mp, agno, next_agino);
1989 error = xfs_inotobp(mp, tp, next_ino, &last_dip,
1990 &last_ibp, &last_offset);
1991 if (error) {
1992 cmn_err(CE_WARN,
1993 "xfs_iunlink_remove: xfs_inotobp() returned an error %d on %s. Returning error.",
1994 error, mp->m_fsname);
1995 return error;
1996 }
Christoph Hellwig347d1c02007-08-28 13:57:51 +10001997 next_agino = be32_to_cpu(last_dip->di_next_unlinked);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998 ASSERT(next_agino != NULLAGINO);
1999 ASSERT(next_agino != 0);
2000 }
2001 /*
2002 * Now last_ibp points to the buffer previous to us on
2003 * the unlinked list. Pull us from the list.
2004 */
David Chinnera3f74ff2008-03-06 13:43:42 +11002005 error = xfs_itobp(mp, tp, ip, &dip, &ibp, 0, 0, XFS_BUF_LOCK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006 if (error) {
2007 cmn_err(CE_WARN,
2008 "xfs_iunlink_remove: xfs_itobp() returned an error %d on %s. Returning error.",
2009 error, mp->m_fsname);
2010 return error;
2011 }
Christoph Hellwig347d1c02007-08-28 13:57:51 +10002012 next_agino = be32_to_cpu(dip->di_next_unlinked);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002013 ASSERT(next_agino != 0);
2014 ASSERT(next_agino != agino);
2015 if (next_agino != NULLAGINO) {
Christoph Hellwig347d1c02007-08-28 13:57:51 +10002016 dip->di_next_unlinked = cpu_to_be32(NULLAGINO);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017 offset = ip->i_boffset +
2018 offsetof(xfs_dinode_t, di_next_unlinked);
2019 xfs_trans_inode_buf(tp, ibp);
2020 xfs_trans_log_buf(tp, ibp, offset,
2021 (offset + sizeof(xfs_agino_t) - 1));
2022 xfs_inobp_check(mp, ibp);
2023 } else {
2024 xfs_trans_brelse(tp, ibp);
2025 }
2026 /*
2027 * Point the previous inode on the list to the next inode.
2028 */
Christoph Hellwig347d1c02007-08-28 13:57:51 +10002029 last_dip->di_next_unlinked = cpu_to_be32(next_agino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002030 ASSERT(next_agino != 0);
2031 offset = last_offset + offsetof(xfs_dinode_t, di_next_unlinked);
2032 xfs_trans_inode_buf(tp, last_ibp);
2033 xfs_trans_log_buf(tp, last_ibp, offset,
2034 (offset + sizeof(xfs_agino_t) - 1));
2035 xfs_inobp_check(mp, last_ibp);
2036 }
2037 return 0;
2038}
2039
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002040STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -07002041xfs_ifree_cluster(
2042 xfs_inode_t *free_ip,
2043 xfs_trans_t *tp,
2044 xfs_ino_t inum)
2045{
2046 xfs_mount_t *mp = free_ip->i_mount;
2047 int blks_per_cluster;
2048 int nbufs;
2049 int ninodes;
2050 int i, j, found, pre_flushed;
2051 xfs_daddr_t blkno;
2052 xfs_buf_t *bp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002053 xfs_inode_t *ip, **ip_found;
2054 xfs_inode_log_item_t *iip;
2055 xfs_log_item_t *lip;
David Chinnerda353b02007-08-28 14:00:13 +10002056 xfs_perag_t *pag = xfs_get_perag(mp, inum);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002057
2058 if (mp->m_sb.sb_blocksize >= XFS_INODE_CLUSTER_SIZE(mp)) {
2059 blks_per_cluster = 1;
2060 ninodes = mp->m_sb.sb_inopblock;
2061 nbufs = XFS_IALLOC_BLOCKS(mp);
2062 } else {
2063 blks_per_cluster = XFS_INODE_CLUSTER_SIZE(mp) /
2064 mp->m_sb.sb_blocksize;
2065 ninodes = blks_per_cluster * mp->m_sb.sb_inopblock;
2066 nbufs = XFS_IALLOC_BLOCKS(mp) / blks_per_cluster;
2067 }
2068
2069 ip_found = kmem_alloc(ninodes * sizeof(xfs_inode_t *), KM_NOFS);
2070
2071 for (j = 0; j < nbufs; j++, inum += ninodes) {
2072 blkno = XFS_AGB_TO_DADDR(mp, XFS_INO_TO_AGNO(mp, inum),
2073 XFS_INO_TO_AGBNO(mp, inum));
2074
2075
2076 /*
2077 * Look for each inode in memory and attempt to lock it,
2078 * we can be racing with flush and tail pushing here.
2079 * any inode we get the locks on, add to an array of
2080 * inode items to process later.
2081 *
2082 * The get the buffer lock, we could beat a flush
2083 * or tail pushing thread to the lock here, in which
2084 * case they will go looking for the inode buffer
2085 * and fail, we need some other form of interlock
2086 * here.
2087 */
2088 found = 0;
2089 for (i = 0; i < ninodes; i++) {
David Chinnerda353b02007-08-28 14:00:13 +10002090 read_lock(&pag->pag_ici_lock);
2091 ip = radix_tree_lookup(&pag->pag_ici_root,
2092 XFS_INO_TO_AGINO(mp, (inum + i)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002093
2094 /* Inode not in memory or we found it already,
2095 * nothing to do
2096 */
David Chinner7a18c382006-11-11 18:04:54 +11002097 if (!ip || xfs_iflags_test(ip, XFS_ISTALE)) {
David Chinnerda353b02007-08-28 14:00:13 +10002098 read_unlock(&pag->pag_ici_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002099 continue;
2100 }
2101
2102 if (xfs_inode_clean(ip)) {
David Chinnerda353b02007-08-28 14:00:13 +10002103 read_unlock(&pag->pag_ici_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002104 continue;
2105 }
2106
2107 /* If we can get the locks then add it to the
2108 * list, otherwise by the time we get the bp lock
2109 * below it will already be attached to the
2110 * inode buffer.
2111 */
2112
2113 /* This inode will already be locked - by us, lets
2114 * keep it that way.
2115 */
2116
2117 if (ip == free_ip) {
2118 if (xfs_iflock_nowait(ip)) {
David Chinner7a18c382006-11-11 18:04:54 +11002119 xfs_iflags_set(ip, XFS_ISTALE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002120 if (xfs_inode_clean(ip)) {
2121 xfs_ifunlock(ip);
2122 } else {
2123 ip_found[found++] = ip;
2124 }
2125 }
David Chinnerda353b02007-08-28 14:00:13 +10002126 read_unlock(&pag->pag_ici_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002127 continue;
2128 }
2129
2130 if (xfs_ilock_nowait(ip, XFS_ILOCK_EXCL)) {
2131 if (xfs_iflock_nowait(ip)) {
David Chinner7a18c382006-11-11 18:04:54 +11002132 xfs_iflags_set(ip, XFS_ISTALE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002133
2134 if (xfs_inode_clean(ip)) {
2135 xfs_ifunlock(ip);
2136 xfs_iunlock(ip, XFS_ILOCK_EXCL);
2137 } else {
2138 ip_found[found++] = ip;
2139 }
2140 } else {
2141 xfs_iunlock(ip, XFS_ILOCK_EXCL);
2142 }
2143 }
David Chinnerda353b02007-08-28 14:00:13 +10002144 read_unlock(&pag->pag_ici_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002145 }
2146
2147 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, blkno,
2148 mp->m_bsize * blks_per_cluster,
2149 XFS_BUF_LOCK);
2150
2151 pre_flushed = 0;
2152 lip = XFS_BUF_FSPRIVATE(bp, xfs_log_item_t *);
2153 while (lip) {
2154 if (lip->li_type == XFS_LI_INODE) {
2155 iip = (xfs_inode_log_item_t *)lip;
2156 ASSERT(iip->ili_logged == 1);
2157 lip->li_cb = (void(*)(xfs_buf_t*,xfs_log_item_t*)) xfs_istale_done;
Donald Douwsma287f3da2007-10-11 17:36:05 +10002158 spin_lock(&mp->m_ail_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002159 iip->ili_flush_lsn = iip->ili_item.li_lsn;
Donald Douwsma287f3da2007-10-11 17:36:05 +10002160 spin_unlock(&mp->m_ail_lock);
David Chinnere5ffd2b2006-11-21 18:55:33 +11002161 xfs_iflags_set(iip->ili_inode, XFS_ISTALE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002162 pre_flushed++;
2163 }
2164 lip = lip->li_bio_list;
2165 }
2166
2167 for (i = 0; i < found; i++) {
2168 ip = ip_found[i];
2169 iip = ip->i_itemp;
2170
2171 if (!iip) {
2172 ip->i_update_core = 0;
2173 xfs_ifunlock(ip);
2174 xfs_iunlock(ip, XFS_ILOCK_EXCL);
2175 continue;
2176 }
2177
2178 iip->ili_last_fields = iip->ili_format.ilf_fields;
2179 iip->ili_format.ilf_fields = 0;
2180 iip->ili_logged = 1;
Donald Douwsma287f3da2007-10-11 17:36:05 +10002181 spin_lock(&mp->m_ail_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002182 iip->ili_flush_lsn = iip->ili_item.li_lsn;
Donald Douwsma287f3da2007-10-11 17:36:05 +10002183 spin_unlock(&mp->m_ail_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002184
2185 xfs_buf_attach_iodone(bp,
2186 (void(*)(xfs_buf_t*,xfs_log_item_t*))
2187 xfs_istale_done, (xfs_log_item_t *)iip);
2188 if (ip != free_ip) {
2189 xfs_iunlock(ip, XFS_ILOCK_EXCL);
2190 }
2191 }
2192
2193 if (found || pre_flushed)
2194 xfs_trans_stale_inode_buf(tp, bp);
2195 xfs_trans_binval(tp, bp);
2196 }
2197
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10002198 kmem_free(ip_found);
David Chinnerda353b02007-08-28 14:00:13 +10002199 xfs_put_perag(mp, pag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200}
2201
2202/*
2203 * This is called to return an inode to the inode free list.
2204 * The inode should already be truncated to 0 length and have
2205 * no pages associated with it. This routine also assumes that
2206 * the inode is already a part of the transaction.
2207 *
2208 * The on-disk copy of the inode will have been added to the list
2209 * of unlinked inodes in the AGI. We need to remove the inode from
2210 * that list atomically with respect to freeing it here.
2211 */
2212int
2213xfs_ifree(
2214 xfs_trans_t *tp,
2215 xfs_inode_t *ip,
2216 xfs_bmap_free_t *flist)
2217{
2218 int error;
2219 int delete;
2220 xfs_ino_t first_ino;
Vlad Apostolovc319b582007-11-23 16:27:51 +11002221 xfs_dinode_t *dip;
2222 xfs_buf_t *ibp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002223
Christoph Hellwig579aa9c2008-04-22 17:34:00 +10002224 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002225 ASSERT(ip->i_transp == tp);
2226 ASSERT(ip->i_d.di_nlink == 0);
2227 ASSERT(ip->i_d.di_nextents == 0);
2228 ASSERT(ip->i_d.di_anextents == 0);
Lachlan McIlroyba87ea62007-05-08 13:49:46 +10002229 ASSERT((ip->i_d.di_size == 0 && ip->i_size == 0) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -07002230 ((ip->i_d.di_mode & S_IFMT) != S_IFREG));
2231 ASSERT(ip->i_d.di_nblocks == 0);
2232
2233 /*
2234 * Pull the on-disk inode from the AGI unlinked list.
2235 */
2236 error = xfs_iunlink_remove(tp, ip);
2237 if (error != 0) {
2238 return error;
2239 }
2240
2241 error = xfs_difree(tp, ip->i_ino, flist, &delete, &first_ino);
2242 if (error != 0) {
2243 return error;
2244 }
2245 ip->i_d.di_mode = 0; /* mark incore inode as free */
2246 ip->i_d.di_flags = 0;
2247 ip->i_d.di_dmevmask = 0;
2248 ip->i_d.di_forkoff = 0; /* mark the attr fork not in use */
2249 ip->i_df.if_ext_max =
2250 XFS_IFORK_DSIZE(ip) / (uint)sizeof(xfs_bmbt_rec_t);
2251 ip->i_d.di_format = XFS_DINODE_FMT_EXTENTS;
2252 ip->i_d.di_aformat = XFS_DINODE_FMT_EXTENTS;
2253 /*
2254 * Bump the generation count so no one will be confused
2255 * by reincarnations of this inode.
2256 */
2257 ip->i_d.di_gen++;
Vlad Apostolovc319b582007-11-23 16:27:51 +11002258
Linus Torvalds1da177e2005-04-16 15:20:36 -07002259 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
2260
David Chinnera3f74ff2008-03-06 13:43:42 +11002261 error = xfs_itobp(ip->i_mount, tp, ip, &dip, &ibp, 0, 0, XFS_BUF_LOCK);
Vlad Apostolovc319b582007-11-23 16:27:51 +11002262 if (error)
2263 return error;
2264
2265 /*
2266 * Clear the on-disk di_mode. This is to prevent xfs_bulkstat
2267 * from picking up this inode when it is reclaimed (its incore state
2268 * initialzed but not flushed to disk yet). The in-core di_mode is
2269 * already cleared and a corresponding transaction logged.
2270 * The hack here just synchronizes the in-core to on-disk
2271 * di_mode value in advance before the actual inode sync to disk.
2272 * This is OK because the inode is already unlinked and would never
2273 * change its di_mode again for this inode generation.
2274 * This is a temporary hack that would require a proper fix
2275 * in the future.
2276 */
2277 dip->di_core.di_mode = 0;
2278
Linus Torvalds1da177e2005-04-16 15:20:36 -07002279 if (delete) {
2280 xfs_ifree_cluster(ip, tp, first_ino);
2281 }
2282
2283 return 0;
2284}
2285
2286/*
2287 * Reallocate the space for if_broot based on the number of records
2288 * being added or deleted as indicated in rec_diff. Move the records
2289 * and pointers in if_broot to fit the new size. When shrinking this
2290 * will eliminate holes between the records and pointers created by
2291 * the caller. When growing this will create holes to be filled in
2292 * by the caller.
2293 *
2294 * The caller must not request to add more records than would fit in
2295 * the on-disk inode root. If the if_broot is currently NULL, then
2296 * if we adding records one will be allocated. The caller must also
2297 * not request that the number of records go below zero, although
2298 * it can go to zero.
2299 *
2300 * ip -- the inode whose if_broot area is changing
2301 * ext_diff -- the change in the number of records, positive or negative,
2302 * requested for the if_broot array.
2303 */
2304void
2305xfs_iroot_realloc(
2306 xfs_inode_t *ip,
2307 int rec_diff,
2308 int whichfork)
2309{
2310 int cur_max;
2311 xfs_ifork_t *ifp;
2312 xfs_bmbt_block_t *new_broot;
2313 int new_max;
2314 size_t new_size;
2315 char *np;
2316 char *op;
2317
2318 /*
2319 * Handle the degenerate case quietly.
2320 */
2321 if (rec_diff == 0) {
2322 return;
2323 }
2324
2325 ifp = XFS_IFORK_PTR(ip, whichfork);
2326 if (rec_diff > 0) {
2327 /*
2328 * If there wasn't any memory allocated before, just
2329 * allocate it now and get out.
2330 */
2331 if (ifp->if_broot_bytes == 0) {
2332 new_size = (size_t)XFS_BMAP_BROOT_SPACE_CALC(rec_diff);
2333 ifp->if_broot = (xfs_bmbt_block_t*)kmem_alloc(new_size,
2334 KM_SLEEP);
2335 ifp->if_broot_bytes = (int)new_size;
2336 return;
2337 }
2338
2339 /*
2340 * If there is already an existing if_broot, then we need
2341 * to realloc() it and shift the pointers to their new
2342 * location. The records don't change location because
2343 * they are kept butted up against the btree block header.
2344 */
2345 cur_max = XFS_BMAP_BROOT_MAXRECS(ifp->if_broot_bytes);
2346 new_max = cur_max + rec_diff;
2347 new_size = (size_t)XFS_BMAP_BROOT_SPACE_CALC(new_max);
2348 ifp->if_broot = (xfs_bmbt_block_t *)
2349 kmem_realloc(ifp->if_broot,
2350 new_size,
2351 (size_t)XFS_BMAP_BROOT_SPACE_CALC(cur_max), /* old size */
2352 KM_SLEEP);
2353 op = (char *)XFS_BMAP_BROOT_PTR_ADDR(ifp->if_broot, 1,
2354 ifp->if_broot_bytes);
2355 np = (char *)XFS_BMAP_BROOT_PTR_ADDR(ifp->if_broot, 1,
2356 (int)new_size);
2357 ifp->if_broot_bytes = (int)new_size;
2358 ASSERT(ifp->if_broot_bytes <=
2359 XFS_IFORK_SIZE(ip, whichfork) + XFS_BROOT_SIZE_ADJ);
2360 memmove(np, op, cur_max * (uint)sizeof(xfs_dfsbno_t));
2361 return;
2362 }
2363
2364 /*
2365 * rec_diff is less than 0. In this case, we are shrinking the
2366 * if_broot buffer. It must already exist. If we go to zero
2367 * records, just get rid of the root and clear the status bit.
2368 */
2369 ASSERT((ifp->if_broot != NULL) && (ifp->if_broot_bytes > 0));
2370 cur_max = XFS_BMAP_BROOT_MAXRECS(ifp->if_broot_bytes);
2371 new_max = cur_max + rec_diff;
2372 ASSERT(new_max >= 0);
2373 if (new_max > 0)
2374 new_size = (size_t)XFS_BMAP_BROOT_SPACE_CALC(new_max);
2375 else
2376 new_size = 0;
2377 if (new_size > 0) {
2378 new_broot = (xfs_bmbt_block_t *)kmem_alloc(new_size, KM_SLEEP);
2379 /*
2380 * First copy over the btree block header.
2381 */
2382 memcpy(new_broot, ifp->if_broot, sizeof(xfs_bmbt_block_t));
2383 } else {
2384 new_broot = NULL;
2385 ifp->if_flags &= ~XFS_IFBROOT;
2386 }
2387
2388 /*
2389 * Only copy the records and pointers if there are any.
2390 */
2391 if (new_max > 0) {
2392 /*
2393 * First copy the records.
2394 */
2395 op = (char *)XFS_BMAP_BROOT_REC_ADDR(ifp->if_broot, 1,
2396 ifp->if_broot_bytes);
2397 np = (char *)XFS_BMAP_BROOT_REC_ADDR(new_broot, 1,
2398 (int)new_size);
2399 memcpy(np, op, new_max * (uint)sizeof(xfs_bmbt_rec_t));
2400
2401 /*
2402 * Then copy the pointers.
2403 */
2404 op = (char *)XFS_BMAP_BROOT_PTR_ADDR(ifp->if_broot, 1,
2405 ifp->if_broot_bytes);
2406 np = (char *)XFS_BMAP_BROOT_PTR_ADDR(new_broot, 1,
2407 (int)new_size);
2408 memcpy(np, op, new_max * (uint)sizeof(xfs_dfsbno_t));
2409 }
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10002410 kmem_free(ifp->if_broot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002411 ifp->if_broot = new_broot;
2412 ifp->if_broot_bytes = (int)new_size;
2413 ASSERT(ifp->if_broot_bytes <=
2414 XFS_IFORK_SIZE(ip, whichfork) + XFS_BROOT_SIZE_ADJ);
2415 return;
2416}
2417
2418
2419/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002420 * This is called when the amount of space needed for if_data
2421 * is increased or decreased. The change in size is indicated by
2422 * the number of bytes that need to be added or deleted in the
2423 * byte_diff parameter.
2424 *
2425 * If the amount of space needed has decreased below the size of the
2426 * inline buffer, then switch to using the inline buffer. Otherwise,
2427 * use kmem_realloc() or kmem_alloc() to adjust the size of the buffer
2428 * to what is needed.
2429 *
2430 * ip -- the inode whose if_data area is changing
2431 * byte_diff -- the change in the number of bytes, positive or negative,
2432 * requested for the if_data array.
2433 */
2434void
2435xfs_idata_realloc(
2436 xfs_inode_t *ip,
2437 int byte_diff,
2438 int whichfork)
2439{
2440 xfs_ifork_t *ifp;
2441 int new_size;
2442 int real_size;
2443
2444 if (byte_diff == 0) {
2445 return;
2446 }
2447
2448 ifp = XFS_IFORK_PTR(ip, whichfork);
2449 new_size = (int)ifp->if_bytes + byte_diff;
2450 ASSERT(new_size >= 0);
2451
2452 if (new_size == 0) {
2453 if (ifp->if_u1.if_data != ifp->if_u2.if_inline_data) {
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10002454 kmem_free(ifp->if_u1.if_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002455 }
2456 ifp->if_u1.if_data = NULL;
2457 real_size = 0;
2458 } else if (new_size <= sizeof(ifp->if_u2.if_inline_data)) {
2459 /*
2460 * If the valid extents/data can fit in if_inline_ext/data,
2461 * copy them from the malloc'd vector and free it.
2462 */
2463 if (ifp->if_u1.if_data == NULL) {
2464 ifp->if_u1.if_data = ifp->if_u2.if_inline_data;
2465 } else if (ifp->if_u1.if_data != ifp->if_u2.if_inline_data) {
2466 ASSERT(ifp->if_real_bytes != 0);
2467 memcpy(ifp->if_u2.if_inline_data, ifp->if_u1.if_data,
2468 new_size);
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10002469 kmem_free(ifp->if_u1.if_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002470 ifp->if_u1.if_data = ifp->if_u2.if_inline_data;
2471 }
2472 real_size = 0;
2473 } else {
2474 /*
2475 * Stuck with malloc/realloc.
2476 * For inline data, the underlying buffer must be
2477 * a multiple of 4 bytes in size so that it can be
2478 * logged and stay on word boundaries. We enforce
2479 * that here.
2480 */
2481 real_size = roundup(new_size, 4);
2482 if (ifp->if_u1.if_data == NULL) {
2483 ASSERT(ifp->if_real_bytes == 0);
2484 ifp->if_u1.if_data = kmem_alloc(real_size, KM_SLEEP);
2485 } else if (ifp->if_u1.if_data != ifp->if_u2.if_inline_data) {
2486 /*
2487 * Only do the realloc if the underlying size
2488 * is really changing.
2489 */
2490 if (ifp->if_real_bytes != real_size) {
2491 ifp->if_u1.if_data =
2492 kmem_realloc(ifp->if_u1.if_data,
2493 real_size,
2494 ifp->if_real_bytes,
2495 KM_SLEEP);
2496 }
2497 } else {
2498 ASSERT(ifp->if_real_bytes == 0);
2499 ifp->if_u1.if_data = kmem_alloc(real_size, KM_SLEEP);
2500 memcpy(ifp->if_u1.if_data, ifp->if_u2.if_inline_data,
2501 ifp->if_bytes);
2502 }
2503 }
2504 ifp->if_real_bytes = real_size;
2505 ifp->if_bytes = new_size;
2506 ASSERT(ifp->if_bytes <= XFS_IFORK_SIZE(ip, whichfork));
2507}
2508
2509
2510
2511
2512/*
2513 * Map inode to disk block and offset.
2514 *
2515 * mp -- the mount point structure for the current file system
2516 * tp -- the current transaction
2517 * ino -- the inode number of the inode to be located
2518 * imap -- this structure is filled in with the information necessary
2519 * to retrieve the given inode from disk
2520 * flags -- flags to pass to xfs_dilocate indicating whether or not
2521 * lookups in the inode btree were OK or not
2522 */
2523int
2524xfs_imap(
2525 xfs_mount_t *mp,
2526 xfs_trans_t *tp,
2527 xfs_ino_t ino,
2528 xfs_imap_t *imap,
2529 uint flags)
2530{
2531 xfs_fsblock_t fsbno;
2532 int len;
2533 int off;
2534 int error;
2535
2536 fsbno = imap->im_blkno ?
2537 XFS_DADDR_TO_FSB(mp, imap->im_blkno) : NULLFSBLOCK;
2538 error = xfs_dilocate(mp, tp, ino, &fsbno, &len, &off, flags);
David Chinner4ae29b42008-03-06 13:43:34 +11002539 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002540 return error;
David Chinner4ae29b42008-03-06 13:43:34 +11002541
Linus Torvalds1da177e2005-04-16 15:20:36 -07002542 imap->im_blkno = XFS_FSB_TO_DADDR(mp, fsbno);
2543 imap->im_len = XFS_FSB_TO_BB(mp, len);
2544 imap->im_agblkno = XFS_FSB_TO_AGBNO(mp, fsbno);
2545 imap->im_ioffset = (ushort)off;
2546 imap->im_boffset = (ushort)(off << mp->m_sb.sb_inodelog);
David Chinner4ae29b42008-03-06 13:43:34 +11002547
2548 /*
2549 * If the inode number maps to a block outside the bounds
2550 * of the file system then return NULL rather than calling
2551 * read_buf and panicing when we get an error from the
2552 * driver.
2553 */
2554 if ((imap->im_blkno + imap->im_len) >
2555 XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks)) {
2556 xfs_fs_cmn_err(CE_ALERT, mp, "xfs_imap: "
2557 "(imap->im_blkno (0x%llx) + imap->im_len (0x%llx)) > "
2558 " XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks) (0x%llx)",
2559 (unsigned long long) imap->im_blkno,
2560 (unsigned long long) imap->im_len,
2561 XFS_FSB_TO_BB(mp, mp->m_sb.sb_dblocks));
2562 return EINVAL;
2563 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002564 return 0;
2565}
2566
2567void
2568xfs_idestroy_fork(
2569 xfs_inode_t *ip,
2570 int whichfork)
2571{
2572 xfs_ifork_t *ifp;
2573
2574 ifp = XFS_IFORK_PTR(ip, whichfork);
2575 if (ifp->if_broot != NULL) {
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10002576 kmem_free(ifp->if_broot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002577 ifp->if_broot = NULL;
2578 }
2579
2580 /*
2581 * If the format is local, then we can't have an extents
2582 * array so just look for an inline data array. If we're
2583 * not local then we may or may not have an extents list,
2584 * so check and free it up if we do.
2585 */
2586 if (XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL) {
2587 if ((ifp->if_u1.if_data != ifp->if_u2.if_inline_data) &&
2588 (ifp->if_u1.if_data != NULL)) {
2589 ASSERT(ifp->if_real_bytes != 0);
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10002590 kmem_free(ifp->if_u1.if_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002591 ifp->if_u1.if_data = NULL;
2592 ifp->if_real_bytes = 0;
2593 }
2594 } else if ((ifp->if_flags & XFS_IFEXTENTS) &&
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11002595 ((ifp->if_flags & XFS_IFEXTIREC) ||
2596 ((ifp->if_u1.if_extents != NULL) &&
2597 (ifp->if_u1.if_extents != ifp->if_u2.if_inline_ext)))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002598 ASSERT(ifp->if_real_bytes != 0);
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11002599 xfs_iext_destroy(ifp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002600 }
2601 ASSERT(ifp->if_u1.if_extents == NULL ||
2602 ifp->if_u1.if_extents == ifp->if_u2.if_inline_ext);
2603 ASSERT(ifp->if_real_bytes == 0);
2604 if (whichfork == XFS_ATTR_FORK) {
2605 kmem_zone_free(xfs_ifork_zone, ip->i_afp);
2606 ip->i_afp = NULL;
2607 }
2608}
2609
2610/*
2611 * This is called free all the memory associated with an inode.
2612 * It must free the inode itself and any buffers allocated for
2613 * if_extents/if_data and if_broot. It must also free the lock
2614 * associated with the inode.
2615 */
2616void
2617xfs_idestroy(
2618 xfs_inode_t *ip)
2619{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002620 switch (ip->i_d.di_mode & S_IFMT) {
2621 case S_IFREG:
2622 case S_IFDIR:
2623 case S_IFLNK:
2624 xfs_idestroy_fork(ip, XFS_DATA_FORK);
2625 break;
2626 }
2627 if (ip->i_afp)
2628 xfs_idestroy_fork(ip, XFS_ATTR_FORK);
2629 mrfree(&ip->i_lock);
2630 mrfree(&ip->i_iolock);
2631 freesema(&ip->i_flock);
Christoph Hellwig1543d792007-08-29 11:46:47 +10002632
Lachlan McIlroycf441ee2008-02-07 16:42:19 +11002633#ifdef XFS_INODE_TRACE
Christoph Hellwig1543d792007-08-29 11:46:47 +10002634 ktrace_free(ip->i_trace);
2635#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002636#ifdef XFS_BMAP_TRACE
2637 ktrace_free(ip->i_xtrace);
2638#endif
2639#ifdef XFS_BMBT_TRACE
2640 ktrace_free(ip->i_btrace);
2641#endif
2642#ifdef XFS_RW_TRACE
2643 ktrace_free(ip->i_rwtrace);
2644#endif
2645#ifdef XFS_ILOCK_TRACE
2646 ktrace_free(ip->i_lock_trace);
2647#endif
2648#ifdef XFS_DIR2_TRACE
2649 ktrace_free(ip->i_dir_trace);
2650#endif
2651 if (ip->i_itemp) {
David Chinnerf74eaf52007-02-10 18:36:04 +11002652 /*
2653 * Only if we are shutting down the fs will we see an
2654 * inode still in the AIL. If it is there, we should remove
2655 * it to prevent a use-after-free from occurring.
2656 */
2657 xfs_mount_t *mp = ip->i_mount;
2658 xfs_log_item_t *lip = &ip->i_itemp->ili_item;
David Chinnerf74eaf52007-02-10 18:36:04 +11002659
2660 ASSERT(((lip->li_flags & XFS_LI_IN_AIL) == 0) ||
2661 XFS_FORCED_SHUTDOWN(ip->i_mount));
2662 if (lip->li_flags & XFS_LI_IN_AIL) {
Donald Douwsma287f3da2007-10-11 17:36:05 +10002663 spin_lock(&mp->m_ail_lock);
David Chinnerf74eaf52007-02-10 18:36:04 +11002664 if (lip->li_flags & XFS_LI_IN_AIL)
Donald Douwsma287f3da2007-10-11 17:36:05 +10002665 xfs_trans_delete_ail(mp, lip);
David Chinnerf74eaf52007-02-10 18:36:04 +11002666 else
Donald Douwsma287f3da2007-10-11 17:36:05 +10002667 spin_unlock(&mp->m_ail_lock);
David Chinnerf74eaf52007-02-10 18:36:04 +11002668 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002669 xfs_inode_item_destroy(ip);
2670 }
2671 kmem_zone_free(xfs_inode_zone, ip);
2672}
2673
2674
2675/*
2676 * Increment the pin count of the given buffer.
2677 * This value is protected by ipinlock spinlock in the mount structure.
2678 */
2679void
2680xfs_ipin(
2681 xfs_inode_t *ip)
2682{
Christoph Hellwig579aa9c2008-04-22 17:34:00 +10002683 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002684
2685 atomic_inc(&ip->i_pincount);
2686}
2687
2688/*
2689 * Decrement the pin count of the given inode, and wake up
2690 * anyone in xfs_iwait_unpin() if the count goes to 0. The
Nathan Scottc41564b2006-03-29 08:55:14 +10002691 * inode must have been previously pinned with a call to xfs_ipin().
Linus Torvalds1da177e2005-04-16 15:20:36 -07002692 */
2693void
2694xfs_iunpin(
2695 xfs_inode_t *ip)
2696{
2697 ASSERT(atomic_read(&ip->i_pincount) > 0);
2698
David Chinner5d51eff2007-11-23 16:29:18 +11002699 if (atomic_dec_and_test(&ip->i_pincount))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002700 wake_up(&ip->i_ipin_wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002701}
2702
2703/*
David Chinnera3f74ff2008-03-06 13:43:42 +11002704 * This is called to unpin an inode. It can be directed to wait or to return
2705 * immediately without waiting for the inode to be unpinned. The caller must
2706 * have the inode locked in at least shared mode so that the buffer cannot be
2707 * subsequently pinned once someone is waiting for it to be unpinned.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002708 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002709STATIC void
David Chinnera3f74ff2008-03-06 13:43:42 +11002710__xfs_iunpin_wait(
2711 xfs_inode_t *ip,
2712 int wait)
2713{
2714 xfs_inode_log_item_t *iip = ip->i_itemp;
2715
Christoph Hellwig579aa9c2008-04-22 17:34:00 +10002716 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
David Chinnera3f74ff2008-03-06 13:43:42 +11002717 if (atomic_read(&ip->i_pincount) == 0)
2718 return;
2719
2720 /* Give the log a push to start the unpinning I/O */
2721 xfs_log_force(ip->i_mount, (iip && iip->ili_last_lsn) ?
2722 iip->ili_last_lsn : 0, XFS_LOG_FORCE);
2723 if (wait)
2724 wait_event(ip->i_ipin_wait, (atomic_read(&ip->i_pincount) == 0));
2725}
2726
2727static inline void
Linus Torvalds1da177e2005-04-16 15:20:36 -07002728xfs_iunpin_wait(
2729 xfs_inode_t *ip)
2730{
David Chinnera3f74ff2008-03-06 13:43:42 +11002731 __xfs_iunpin_wait(ip, 1);
2732}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002733
David Chinnera3f74ff2008-03-06 13:43:42 +11002734static inline void
2735xfs_iunpin_nowait(
2736 xfs_inode_t *ip)
2737{
2738 __xfs_iunpin_wait(ip, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002739}
2740
2741
2742/*
2743 * xfs_iextents_copy()
2744 *
2745 * This is called to copy the REAL extents (as opposed to the delayed
2746 * allocation extents) from the inode into the given buffer. It
2747 * returns the number of bytes copied into the buffer.
2748 *
2749 * If there are no delayed allocation extents, then we can just
2750 * memcpy() the extents into the buffer. Otherwise, we need to
2751 * examine each extent in turn and skip those which are delayed.
2752 */
2753int
2754xfs_iextents_copy(
2755 xfs_inode_t *ip,
Christoph Hellwiga6f64d42007-08-16 16:23:40 +10002756 xfs_bmbt_rec_t *dp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002757 int whichfork)
2758{
2759 int copied;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002760 int i;
2761 xfs_ifork_t *ifp;
2762 int nrecs;
2763 xfs_fsblock_t start_block;
2764
2765 ifp = XFS_IFORK_PTR(ip, whichfork);
Christoph Hellwig579aa9c2008-04-22 17:34:00 +10002766 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002767 ASSERT(ifp->if_bytes > 0);
2768
2769 nrecs = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
Eric Sandeen3a59c942007-07-11 11:09:47 +10002770 XFS_BMAP_TRACE_EXLIST(ip, nrecs, whichfork);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002771 ASSERT(nrecs > 0);
2772
2773 /*
2774 * There are some delayed allocation extents in the
2775 * inode, so copy the extents one at a time and skip
2776 * the delayed ones. There must be at least one
2777 * non-delayed extent.
2778 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002779 copied = 0;
2780 for (i = 0; i < nrecs; i++) {
Christoph Hellwiga6f64d42007-08-16 16:23:40 +10002781 xfs_bmbt_rec_host_t *ep = xfs_iext_get_ext(ifp, i);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002782 start_block = xfs_bmbt_get_startblock(ep);
2783 if (ISNULLSTARTBLOCK(start_block)) {
2784 /*
2785 * It's a delayed allocation extent, so skip it.
2786 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002787 continue;
2788 }
2789
2790 /* Translate to on disk format */
Christoph Hellwigcd8b0a92007-08-16 16:24:15 +10002791 put_unaligned(cpu_to_be64(ep->l0), &dp->l0);
2792 put_unaligned(cpu_to_be64(ep->l1), &dp->l1);
Christoph Hellwiga6f64d42007-08-16 16:23:40 +10002793 dp++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002794 copied++;
2795 }
2796 ASSERT(copied != 0);
Christoph Hellwiga6f64d42007-08-16 16:23:40 +10002797 xfs_validate_extents(ifp, copied, XFS_EXTFMT_INODE(ip));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002798
2799 return (copied * (uint)sizeof(xfs_bmbt_rec_t));
2800}
2801
2802/*
2803 * Each of the following cases stores data into the same region
2804 * of the on-disk inode, so only one of them can be valid at
2805 * any given time. While it is possible to have conflicting formats
2806 * and log flags, e.g. having XFS_ILOG_?DATA set when the fork is
2807 * in EXTENTS format, this can only happen when the fork has
2808 * changed formats after being modified but before being flushed.
2809 * In these cases, the format always takes precedence, because the
2810 * format indicates the current state of the fork.
2811 */
2812/*ARGSUSED*/
David Chinnere4ac9672008-04-10 12:23:58 +10002813STATIC void
Linus Torvalds1da177e2005-04-16 15:20:36 -07002814xfs_iflush_fork(
2815 xfs_inode_t *ip,
2816 xfs_dinode_t *dip,
2817 xfs_inode_log_item_t *iip,
2818 int whichfork,
2819 xfs_buf_t *bp)
2820{
2821 char *cp;
2822 xfs_ifork_t *ifp;
2823 xfs_mount_t *mp;
2824#ifdef XFS_TRANS_DEBUG
2825 int first;
2826#endif
2827 static const short brootflag[2] =
2828 { XFS_ILOG_DBROOT, XFS_ILOG_ABROOT };
2829 static const short dataflag[2] =
2830 { XFS_ILOG_DDATA, XFS_ILOG_ADATA };
2831 static const short extflag[2] =
2832 { XFS_ILOG_DEXT, XFS_ILOG_AEXT };
2833
David Chinnere4ac9672008-04-10 12:23:58 +10002834 if (!iip)
2835 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002836 ifp = XFS_IFORK_PTR(ip, whichfork);
2837 /*
2838 * This can happen if we gave up in iformat in an error path,
2839 * for the attribute fork.
2840 */
David Chinnere4ac9672008-04-10 12:23:58 +10002841 if (!ifp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002842 ASSERT(whichfork == XFS_ATTR_FORK);
David Chinnere4ac9672008-04-10 12:23:58 +10002843 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002844 }
2845 cp = XFS_DFORK_PTR(dip, whichfork);
2846 mp = ip->i_mount;
2847 switch (XFS_IFORK_FORMAT(ip, whichfork)) {
2848 case XFS_DINODE_FMT_LOCAL:
2849 if ((iip->ili_format.ilf_fields & dataflag[whichfork]) &&
2850 (ifp->if_bytes > 0)) {
2851 ASSERT(ifp->if_u1.if_data != NULL);
2852 ASSERT(ifp->if_bytes <= XFS_IFORK_SIZE(ip, whichfork));
2853 memcpy(cp, ifp->if_u1.if_data, ifp->if_bytes);
2854 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002855 break;
2856
2857 case XFS_DINODE_FMT_EXTENTS:
2858 ASSERT((ifp->if_flags & XFS_IFEXTENTS) ||
2859 !(iip->ili_format.ilf_fields & extflag[whichfork]));
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11002860 ASSERT((xfs_iext_get_ext(ifp, 0) != NULL) ||
2861 (ifp->if_bytes == 0));
2862 ASSERT((xfs_iext_get_ext(ifp, 0) == NULL) ||
2863 (ifp->if_bytes > 0));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002864 if ((iip->ili_format.ilf_fields & extflag[whichfork]) &&
2865 (ifp->if_bytes > 0)) {
2866 ASSERT(XFS_IFORK_NEXTENTS(ip, whichfork) > 0);
2867 (void)xfs_iextents_copy(ip, (xfs_bmbt_rec_t *)cp,
2868 whichfork);
2869 }
2870 break;
2871
2872 case XFS_DINODE_FMT_BTREE:
2873 if ((iip->ili_format.ilf_fields & brootflag[whichfork]) &&
2874 (ifp->if_broot_bytes > 0)) {
2875 ASSERT(ifp->if_broot != NULL);
2876 ASSERT(ifp->if_broot_bytes <=
2877 (XFS_IFORK_SIZE(ip, whichfork) +
2878 XFS_BROOT_SIZE_ADJ));
2879 xfs_bmbt_to_bmdr(ifp->if_broot, ifp->if_broot_bytes,
2880 (xfs_bmdr_block_t *)cp,
2881 XFS_DFORK_SIZE(dip, mp, whichfork));
2882 }
2883 break;
2884
2885 case XFS_DINODE_FMT_DEV:
2886 if (iip->ili_format.ilf_fields & XFS_ILOG_DEV) {
2887 ASSERT(whichfork == XFS_DATA_FORK);
Christoph Hellwig347d1c02007-08-28 13:57:51 +10002888 dip->di_u.di_dev = cpu_to_be32(ip->i_df.if_u2.if_rdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002889 }
2890 break;
2891
2892 case XFS_DINODE_FMT_UUID:
2893 if (iip->ili_format.ilf_fields & XFS_ILOG_UUID) {
2894 ASSERT(whichfork == XFS_DATA_FORK);
2895 memcpy(&dip->di_u.di_muuid, &ip->i_df.if_u2.if_uuid,
2896 sizeof(uuid_t));
2897 }
2898 break;
2899
2900 default:
2901 ASSERT(0);
2902 break;
2903 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002904}
2905
David Chinnerbad55842008-03-06 13:43:49 +11002906STATIC int
2907xfs_iflush_cluster(
2908 xfs_inode_t *ip,
2909 xfs_buf_t *bp)
2910{
2911 xfs_mount_t *mp = ip->i_mount;
2912 xfs_perag_t *pag = xfs_get_perag(mp, ip->i_ino);
2913 unsigned long first_index, mask;
David Chinnerc8f5f122008-05-20 11:30:15 +10002914 unsigned long inodes_per_cluster;
David Chinnerbad55842008-03-06 13:43:49 +11002915 int ilist_size;
2916 xfs_inode_t **ilist;
2917 xfs_inode_t *iq;
David Chinnerbad55842008-03-06 13:43:49 +11002918 int nr_found;
2919 int clcount = 0;
2920 int bufwasdelwri;
2921 int i;
2922
2923 ASSERT(pag->pagi_inodeok);
2924 ASSERT(pag->pag_ici_init);
2925
David Chinnerc8f5f122008-05-20 11:30:15 +10002926 inodes_per_cluster = XFS_INODE_CLUSTER_SIZE(mp) >> mp->m_sb.sb_inodelog;
2927 ilist_size = inodes_per_cluster * sizeof(xfs_inode_t *);
David Chinner49383b02008-05-19 16:29:34 +10002928 ilist = kmem_alloc(ilist_size, KM_MAYFAIL|KM_NOFS);
David Chinnerbad55842008-03-06 13:43:49 +11002929 if (!ilist)
2930 return 0;
2931
2932 mask = ~(((XFS_INODE_CLUSTER_SIZE(mp) >> mp->m_sb.sb_inodelog)) - 1);
2933 first_index = XFS_INO_TO_AGINO(mp, ip->i_ino) & mask;
2934 read_lock(&pag->pag_ici_lock);
2935 /* really need a gang lookup range call here */
2936 nr_found = radix_tree_gang_lookup(&pag->pag_ici_root, (void**)ilist,
David Chinnerc8f5f122008-05-20 11:30:15 +10002937 first_index, inodes_per_cluster);
David Chinnerbad55842008-03-06 13:43:49 +11002938 if (nr_found == 0)
2939 goto out_free;
2940
2941 for (i = 0; i < nr_found; i++) {
2942 iq = ilist[i];
2943 if (iq == ip)
2944 continue;
2945 /* if the inode lies outside this cluster, we're done. */
2946 if ((XFS_INO_TO_AGINO(mp, iq->i_ino) & mask) != first_index)
2947 break;
2948 /*
2949 * Do an un-protected check to see if the inode is dirty and
2950 * is a candidate for flushing. These checks will be repeated
2951 * later after the appropriate locks are acquired.
2952 */
David Chinner33540402008-03-06 13:43:59 +11002953 if (xfs_inode_clean(iq) && xfs_ipincount(iq) == 0)
David Chinnerbad55842008-03-06 13:43:49 +11002954 continue;
David Chinnerbad55842008-03-06 13:43:49 +11002955
2956 /*
2957 * Try to get locks. If any are unavailable or it is pinned,
2958 * then this inode cannot be flushed and is skipped.
2959 */
2960
2961 if (!xfs_ilock_nowait(iq, XFS_ILOCK_SHARED))
2962 continue;
2963 if (!xfs_iflock_nowait(iq)) {
2964 xfs_iunlock(iq, XFS_ILOCK_SHARED);
2965 continue;
2966 }
2967 if (xfs_ipincount(iq)) {
2968 xfs_ifunlock(iq);
2969 xfs_iunlock(iq, XFS_ILOCK_SHARED);
2970 continue;
2971 }
2972
2973 /*
2974 * arriving here means that this inode can be flushed. First
2975 * re-check that it's dirty before flushing.
2976 */
David Chinner33540402008-03-06 13:43:59 +11002977 if (!xfs_inode_clean(iq)) {
2978 int error;
David Chinnerbad55842008-03-06 13:43:49 +11002979 error = xfs_iflush_int(iq, bp);
2980 if (error) {
2981 xfs_iunlock(iq, XFS_ILOCK_SHARED);
2982 goto cluster_corrupt_out;
2983 }
2984 clcount++;
2985 } else {
2986 xfs_ifunlock(iq);
2987 }
2988 xfs_iunlock(iq, XFS_ILOCK_SHARED);
2989 }
2990
2991 if (clcount) {
2992 XFS_STATS_INC(xs_icluster_flushcnt);
2993 XFS_STATS_ADD(xs_icluster_flushinode, clcount);
2994 }
2995
2996out_free:
2997 read_unlock(&pag->pag_ici_lock);
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10002998 kmem_free(ilist);
David Chinnerbad55842008-03-06 13:43:49 +11002999 return 0;
3000
3001
3002cluster_corrupt_out:
3003 /*
3004 * Corruption detected in the clustering loop. Invalidate the
3005 * inode buffer and shut down the filesystem.
3006 */
3007 read_unlock(&pag->pag_ici_lock);
3008 /*
3009 * Clean up the buffer. If it was B_DELWRI, just release it --
3010 * brelse can handle it with no problems. If not, shut down the
3011 * filesystem before releasing the buffer.
3012 */
3013 bufwasdelwri = XFS_BUF_ISDELAYWRITE(bp);
3014 if (bufwasdelwri)
3015 xfs_buf_relse(bp);
3016
3017 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
3018
3019 if (!bufwasdelwri) {
3020 /*
3021 * Just like incore_relse: if we have b_iodone functions,
3022 * mark the buffer as an error and call them. Otherwise
3023 * mark it as stale and brelse.
3024 */
3025 if (XFS_BUF_IODONE_FUNC(bp)) {
3026 XFS_BUF_CLR_BDSTRAT_FUNC(bp);
3027 XFS_BUF_UNDONE(bp);
3028 XFS_BUF_STALE(bp);
3029 XFS_BUF_SHUT(bp);
3030 XFS_BUF_ERROR(bp,EIO);
3031 xfs_biodone(bp);
3032 } else {
3033 XFS_BUF_STALE(bp);
3034 xfs_buf_relse(bp);
3035 }
3036 }
3037
3038 /*
3039 * Unlocks the flush lock
3040 */
3041 xfs_iflush_abort(iq);
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10003042 kmem_free(ilist);
David Chinnerbad55842008-03-06 13:43:49 +11003043 return XFS_ERROR(EFSCORRUPTED);
3044}
3045
Linus Torvalds1da177e2005-04-16 15:20:36 -07003046/*
3047 * xfs_iflush() will write a modified inode's changes out to the
3048 * inode's on disk home. The caller must have the inode lock held
3049 * in at least shared mode and the inode flush semaphore must be
3050 * held as well. The inode lock will still be held upon return from
3051 * the call and the caller is free to unlock it.
3052 * The inode flush lock will be unlocked when the inode reaches the disk.
3053 * The flags indicate how the inode's buffer should be written out.
3054 */
3055int
3056xfs_iflush(
3057 xfs_inode_t *ip,
3058 uint flags)
3059{
3060 xfs_inode_log_item_t *iip;
3061 xfs_buf_t *bp;
3062 xfs_dinode_t *dip;
3063 xfs_mount_t *mp;
3064 int error;
David Chinnera3f74ff2008-03-06 13:43:42 +11003065 int noblock = (flags == XFS_IFLUSH_ASYNC_NOBLOCK);
David Chinnerbad55842008-03-06 13:43:49 +11003066 enum { INT_DELWRI = (1 << 0), INT_ASYNC = (1 << 1) };
Linus Torvalds1da177e2005-04-16 15:20:36 -07003067
3068 XFS_STATS_INC(xs_iflush_count);
3069
Christoph Hellwig579aa9c2008-04-22 17:34:00 +10003070 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
Al Viro0d8fee32006-06-19 08:41:30 +10003071 ASSERT(issemalocked(&(ip->i_flock)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003072 ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE ||
3073 ip->i_d.di_nextents > ip->i_df.if_ext_max);
3074
3075 iip = ip->i_itemp;
3076 mp = ip->i_mount;
3077
3078 /*
3079 * If the inode isn't dirty, then just release the inode
3080 * flush lock and do nothing.
3081 */
David Chinner33540402008-03-06 13:43:59 +11003082 if (xfs_inode_clean(ip)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003083 xfs_ifunlock(ip);
3084 return 0;
3085 }
3086
3087 /*
David Chinnera3f74ff2008-03-06 13:43:42 +11003088 * We can't flush the inode until it is unpinned, so wait for it if we
3089 * are allowed to block. We know noone new can pin it, because we are
3090 * holding the inode lock shared and you need to hold it exclusively to
3091 * pin the inode.
3092 *
3093 * If we are not allowed to block, force the log out asynchronously so
3094 * that when we come back the inode will be unpinned. If other inodes
3095 * in the same cluster are dirty, they will probably write the inode
3096 * out for us if they occur after the log force completes.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003097 */
David Chinnera3f74ff2008-03-06 13:43:42 +11003098 if (noblock && xfs_ipincount(ip)) {
3099 xfs_iunpin_nowait(ip);
3100 xfs_ifunlock(ip);
3101 return EAGAIN;
3102 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003103 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 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07003119 * Decide how buffer will be flushed out. This is done before
3120 * the call to xfs_iflush_int because this field is zeroed by it.
3121 */
3122 if (iip != NULL && iip->ili_format.ilf_fields != 0) {
3123 /*
3124 * Flush out the inode buffer according to the directions
3125 * of the caller. In the cases where the caller has given
3126 * us a choice choose the non-delwri case. This is because
3127 * the inode is in the AIL and we need to get it out soon.
3128 */
3129 switch (flags) {
3130 case XFS_IFLUSH_SYNC:
3131 case XFS_IFLUSH_DELWRI_ELSE_SYNC:
3132 flags = 0;
3133 break;
David Chinnera3f74ff2008-03-06 13:43:42 +11003134 case XFS_IFLUSH_ASYNC_NOBLOCK:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003135 case XFS_IFLUSH_ASYNC:
3136 case XFS_IFLUSH_DELWRI_ELSE_ASYNC:
3137 flags = INT_ASYNC;
3138 break;
3139 case XFS_IFLUSH_DELWRI:
3140 flags = INT_DELWRI;
3141 break;
3142 default:
3143 ASSERT(0);
3144 flags = 0;
3145 break;
3146 }
3147 } else {
3148 switch (flags) {
3149 case XFS_IFLUSH_DELWRI_ELSE_SYNC:
3150 case XFS_IFLUSH_DELWRI_ELSE_ASYNC:
3151 case XFS_IFLUSH_DELWRI:
3152 flags = INT_DELWRI;
3153 break;
David Chinnera3f74ff2008-03-06 13:43:42 +11003154 case XFS_IFLUSH_ASYNC_NOBLOCK:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003155 case XFS_IFLUSH_ASYNC:
3156 flags = INT_ASYNC;
3157 break;
3158 case XFS_IFLUSH_SYNC:
3159 flags = 0;
3160 break;
3161 default:
3162 ASSERT(0);
3163 flags = 0;
3164 break;
3165 }
3166 }
3167
3168 /*
David Chinnera3f74ff2008-03-06 13:43:42 +11003169 * Get the buffer containing the on-disk inode.
3170 */
3171 error = xfs_itobp(mp, NULL, ip, &dip, &bp, 0, 0,
3172 noblock ? XFS_BUF_TRYLOCK : XFS_BUF_LOCK);
3173 if (error || !bp) {
3174 xfs_ifunlock(ip);
3175 return error;
3176 }
3177
3178 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07003179 * First flush out the inode that xfs_iflush was called with.
3180 */
3181 error = xfs_iflush_int(ip, bp);
David Chinnerbad55842008-03-06 13:43:49 +11003182 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003183 goto corrupt_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003184
3185 /*
David Chinnera3f74ff2008-03-06 13:43:42 +11003186 * If the buffer is pinned then push on the log now so we won't
3187 * get stuck waiting in the write for too long.
3188 */
3189 if (XFS_BUF_ISPINNED(bp))
3190 xfs_log_force(mp, (xfs_lsn_t)0, XFS_LOG_FORCE);
3191
3192 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07003193 * inode clustering:
3194 * see if other inodes can be gathered into this write
3195 */
David Chinnerbad55842008-03-06 13:43:49 +11003196 error = xfs_iflush_cluster(ip, bp);
3197 if (error)
3198 goto cluster_corrupt_out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003199
Linus Torvalds1da177e2005-04-16 15:20:36 -07003200 if (flags & INT_DELWRI) {
3201 xfs_bdwrite(mp, bp);
3202 } else if (flags & INT_ASYNC) {
David Chinnerdb7a19f2008-04-10 12:22:24 +10003203 error = xfs_bawrite(mp, bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003204 } else {
3205 error = xfs_bwrite(mp, bp);
3206 }
3207 return error;
3208
3209corrupt_out:
3210 xfs_buf_relse(bp);
Nathan Scott7d04a332006-06-09 14:58:38 +10003211 xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003212cluster_corrupt_out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003213 /*
3214 * Unlocks the flush lock
3215 */
David Chinnerbad55842008-03-06 13:43:49 +11003216 xfs_iflush_abort(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003217 return XFS_ERROR(EFSCORRUPTED);
3218}
3219
3220
3221STATIC int
3222xfs_iflush_int(
3223 xfs_inode_t *ip,
3224 xfs_buf_t *bp)
3225{
3226 xfs_inode_log_item_t *iip;
3227 xfs_dinode_t *dip;
3228 xfs_mount_t *mp;
3229#ifdef XFS_TRANS_DEBUG
3230 int first;
3231#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07003232
Christoph Hellwig579aa9c2008-04-22 17:34:00 +10003233 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
Al Viro0d8fee32006-06-19 08:41:30 +10003234 ASSERT(issemalocked(&(ip->i_flock)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003235 ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE ||
3236 ip->i_d.di_nextents > ip->i_df.if_ext_max);
3237
3238 iip = ip->i_itemp;
3239 mp = ip->i_mount;
3240
3241
3242 /*
3243 * If the inode isn't dirty, then just release the inode
3244 * flush lock and do nothing.
3245 */
David Chinner33540402008-03-06 13:43:59 +11003246 if (xfs_inode_clean(ip)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003247 xfs_ifunlock(ip);
3248 return 0;
3249 }
3250
3251 /* set *dip = inode's place in the buffer */
3252 dip = (xfs_dinode_t *)xfs_buf_offset(bp, ip->i_boffset);
3253
3254 /*
3255 * Clear i_update_core before copying out the data.
3256 * This is for coordination with our timestamp updates
3257 * that don't hold the inode lock. They will always
3258 * update the timestamps BEFORE setting i_update_core,
3259 * so if we clear i_update_core after they set it we
3260 * are guaranteed to see their updates to the timestamps.
3261 * I believe that this depends on strongly ordered memory
3262 * semantics, but we have that. We use the SYNCHRONIZE
3263 * macro to make sure that the compiler does not reorder
3264 * the i_update_core access below the data copy below.
3265 */
3266 ip->i_update_core = 0;
3267 SYNCHRONIZE();
3268
Christoph Hellwig42fe2b12006-01-11 15:35:17 +11003269 /*
3270 * Make sure to get the latest atime from the Linux inode.
3271 */
3272 xfs_synchronize_atime(ip);
3273
Christoph Hellwig347d1c02007-08-28 13:57:51 +10003274 if (XFS_TEST_ERROR(be16_to_cpu(dip->di_core.di_magic) != XFS_DINODE_MAGIC,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003275 mp, XFS_ERRTAG_IFLUSH_1, XFS_RANDOM_IFLUSH_1)) {
3276 xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp,
3277 "xfs_iflush: Bad inode %Lu magic number 0x%x, ptr 0x%p",
Christoph Hellwig347d1c02007-08-28 13:57:51 +10003278 ip->i_ino, be16_to_cpu(dip->di_core.di_magic), dip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003279 goto corrupt_out;
3280 }
3281 if (XFS_TEST_ERROR(ip->i_d.di_magic != XFS_DINODE_MAGIC,
3282 mp, XFS_ERRTAG_IFLUSH_2, XFS_RANDOM_IFLUSH_2)) {
3283 xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp,
3284 "xfs_iflush: Bad inode %Lu, ptr 0x%p, magic number 0x%x",
3285 ip->i_ino, ip, ip->i_d.di_magic);
3286 goto corrupt_out;
3287 }
3288 if ((ip->i_d.di_mode & S_IFMT) == S_IFREG) {
3289 if (XFS_TEST_ERROR(
3290 (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS) &&
3291 (ip->i_d.di_format != XFS_DINODE_FMT_BTREE),
3292 mp, XFS_ERRTAG_IFLUSH_3, XFS_RANDOM_IFLUSH_3)) {
3293 xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp,
3294 "xfs_iflush: Bad regular inode %Lu, ptr 0x%p",
3295 ip->i_ino, ip);
3296 goto corrupt_out;
3297 }
3298 } else if ((ip->i_d.di_mode & S_IFMT) == S_IFDIR) {
3299 if (XFS_TEST_ERROR(
3300 (ip->i_d.di_format != XFS_DINODE_FMT_EXTENTS) &&
3301 (ip->i_d.di_format != XFS_DINODE_FMT_BTREE) &&
3302 (ip->i_d.di_format != XFS_DINODE_FMT_LOCAL),
3303 mp, XFS_ERRTAG_IFLUSH_4, XFS_RANDOM_IFLUSH_4)) {
3304 xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp,
3305 "xfs_iflush: Bad directory inode %Lu, ptr 0x%p",
3306 ip->i_ino, ip);
3307 goto corrupt_out;
3308 }
3309 }
3310 if (XFS_TEST_ERROR(ip->i_d.di_nextents + ip->i_d.di_anextents >
3311 ip->i_d.di_nblocks, mp, XFS_ERRTAG_IFLUSH_5,
3312 XFS_RANDOM_IFLUSH_5)) {
3313 xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp,
3314 "xfs_iflush: detected corrupt incore inode %Lu, total extents = %d, nblocks = %Ld, ptr 0x%p",
3315 ip->i_ino,
3316 ip->i_d.di_nextents + ip->i_d.di_anextents,
3317 ip->i_d.di_nblocks,
3318 ip);
3319 goto corrupt_out;
3320 }
3321 if (XFS_TEST_ERROR(ip->i_d.di_forkoff > mp->m_sb.sb_inodesize,
3322 mp, XFS_ERRTAG_IFLUSH_6, XFS_RANDOM_IFLUSH_6)) {
3323 xfs_cmn_err(XFS_PTAG_IFLUSH, CE_ALERT, mp,
3324 "xfs_iflush: bad inode %Lu, forkoff 0x%x, ptr 0x%p",
3325 ip->i_ino, ip->i_d.di_forkoff, ip);
3326 goto corrupt_out;
3327 }
3328 /*
3329 * bump the flush iteration count, used to detect flushes which
3330 * postdate a log record during recovery.
3331 */
3332
3333 ip->i_d.di_flushiter++;
3334
3335 /*
3336 * Copy the dirty parts of the inode into the on-disk
3337 * inode. We always copy out the core of the inode,
3338 * because if the inode is dirty at all the core must
3339 * be.
3340 */
Christoph Hellwig347d1c02007-08-28 13:57:51 +10003341 xfs_dinode_to_disk(&dip->di_core, &ip->i_d);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003342
3343 /* Wrap, we never let the log put out DI_MAX_FLUSH */
3344 if (ip->i_d.di_flushiter == DI_MAX_FLUSH)
3345 ip->i_d.di_flushiter = 0;
3346
3347 /*
3348 * If this is really an old format inode and the superblock version
3349 * has not been updated to support only new format inodes, then
3350 * convert back to the old inode format. If the superblock version
3351 * has been updated, then make the conversion permanent.
3352 */
3353 ASSERT(ip->i_d.di_version == XFS_DINODE_VERSION_1 ||
Eric Sandeen62118702008-03-06 13:44:28 +11003354 xfs_sb_version_hasnlink(&mp->m_sb));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003355 if (ip->i_d.di_version == XFS_DINODE_VERSION_1) {
Eric Sandeen62118702008-03-06 13:44:28 +11003356 if (!xfs_sb_version_hasnlink(&mp->m_sb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003357 /*
3358 * Convert it back.
3359 */
3360 ASSERT(ip->i_d.di_nlink <= XFS_MAXLINK_1);
Christoph Hellwig347d1c02007-08-28 13:57:51 +10003361 dip->di_core.di_onlink = cpu_to_be16(ip->i_d.di_nlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003362 } else {
3363 /*
3364 * The superblock version has already been bumped,
3365 * so just make the conversion to the new inode
3366 * format permanent.
3367 */
3368 ip->i_d.di_version = XFS_DINODE_VERSION_2;
Christoph Hellwig347d1c02007-08-28 13:57:51 +10003369 dip->di_core.di_version = XFS_DINODE_VERSION_2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003370 ip->i_d.di_onlink = 0;
3371 dip->di_core.di_onlink = 0;
3372 memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad));
3373 memset(&(dip->di_core.di_pad[0]), 0,
3374 sizeof(dip->di_core.di_pad));
3375 ASSERT(ip->i_d.di_projid == 0);
3376 }
3377 }
3378
David Chinnere4ac9672008-04-10 12:23:58 +10003379 xfs_iflush_fork(ip, dip, iip, XFS_DATA_FORK, bp);
3380 if (XFS_IFORK_Q(ip))
3381 xfs_iflush_fork(ip, dip, iip, XFS_ATTR_FORK, bp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003382 xfs_inobp_check(mp, bp);
3383
3384 /*
3385 * We've recorded everything logged in the inode, so we'd
3386 * like to clear the ilf_fields bits so we don't log and
3387 * flush things unnecessarily. However, we can't stop
3388 * logging all this information until the data we've copied
3389 * into the disk buffer is written to disk. If we did we might
3390 * overwrite the copy of the inode in the log with all the
3391 * data after re-logging only part of it, and in the face of
3392 * a crash we wouldn't have all the data we need to recover.
3393 *
3394 * What we do is move the bits to the ili_last_fields field.
3395 * When logging the inode, these bits are moved back to the
3396 * ilf_fields field. In the xfs_iflush_done() routine we
3397 * clear ili_last_fields, since we know that the information
3398 * those bits represent is permanently on disk. As long as
3399 * the flush completes before the inode is logged again, then
3400 * both ilf_fields and ili_last_fields will be cleared.
3401 *
3402 * We can play with the ilf_fields bits here, because the inode
3403 * lock must be held exclusively in order to set bits there
3404 * and the flush lock protects the ili_last_fields bits.
3405 * Set ili_logged so the flush done
3406 * routine can tell whether or not to look in the AIL.
3407 * Also, store the current LSN of the inode so that we can tell
3408 * whether the item has moved in the AIL from xfs_iflush_done().
3409 * In order to read the lsn we need the AIL lock, because
3410 * it is a 64 bit value that cannot be read atomically.
3411 */
3412 if (iip != NULL && iip->ili_format.ilf_fields != 0) {
3413 iip->ili_last_fields = iip->ili_format.ilf_fields;
3414 iip->ili_format.ilf_fields = 0;
3415 iip->ili_logged = 1;
3416
3417 ASSERT(sizeof(xfs_lsn_t) == 8); /* don't lock if it shrinks */
Donald Douwsma287f3da2007-10-11 17:36:05 +10003418 spin_lock(&mp->m_ail_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003419 iip->ili_flush_lsn = iip->ili_item.li_lsn;
Donald Douwsma287f3da2007-10-11 17:36:05 +10003420 spin_unlock(&mp->m_ail_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003421
3422 /*
3423 * Attach the function xfs_iflush_done to the inode's
3424 * buffer. This will remove the inode from the AIL
3425 * and unlock the inode's flush lock when the inode is
3426 * completely written to disk.
3427 */
3428 xfs_buf_attach_iodone(bp, (void(*)(xfs_buf_t*,xfs_log_item_t*))
3429 xfs_iflush_done, (xfs_log_item_t *)iip);
3430
3431 ASSERT(XFS_BUF_FSPRIVATE(bp, void *) != NULL);
3432 ASSERT(XFS_BUF_IODONE_FUNC(bp) != NULL);
3433 } else {
3434 /*
3435 * We're flushing an inode which is not in the AIL and has
3436 * not been logged but has i_update_core set. For this
3437 * case we can use a B_DELWRI flush and immediately drop
3438 * the inode flush lock because we can avoid the whole
3439 * AIL state thing. It's OK to drop the flush lock now,
3440 * because we've already locked the buffer and to do anything
3441 * you really need both.
3442 */
3443 if (iip != NULL) {
3444 ASSERT(iip->ili_logged == 0);
3445 ASSERT(iip->ili_last_fields == 0);
3446 ASSERT((iip->ili_item.li_flags & XFS_LI_IN_AIL) == 0);
3447 }
3448 xfs_ifunlock(ip);
3449 }
3450
3451 return 0;
3452
3453corrupt_out:
3454 return XFS_ERROR(EFSCORRUPTED);
3455}
3456
3457
3458/*
Christoph Hellwigefa80272005-06-21 15:37:17 +10003459 * Flush all inactive inodes in mp.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003460 */
Christoph Hellwigefa80272005-06-21 15:37:17 +10003461void
Linus Torvalds1da177e2005-04-16 15:20:36 -07003462xfs_iflush_all(
Christoph Hellwigefa80272005-06-21 15:37:17 +10003463 xfs_mount_t *mp)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003464{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003465 xfs_inode_t *ip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003466
Christoph Hellwigefa80272005-06-21 15:37:17 +10003467 again:
3468 XFS_MOUNT_ILOCK(mp);
3469 ip = mp->m_inodes;
3470 if (ip == NULL)
3471 goto out;
3472
3473 do {
3474 /* Make sure we skip markers inserted by sync */
3475 if (ip->i_mount == NULL) {
3476 ip = ip->i_mnext;
3477 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003478 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003479
Christoph Hellwigdf80c932008-08-13 16:22:09 +10003480 if (!VFS_I(ip)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003481 XFS_MOUNT_IUNLOCK(mp);
Christoph Hellwigefa80272005-06-21 15:37:17 +10003482 xfs_finish_reclaim(ip, 0, XFS_IFLUSH_ASYNC);
3483 goto again;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003484 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003485
Christoph Hellwigdf80c932008-08-13 16:22:09 +10003486 ASSERT(vn_count(VFS_I(ip)) == 0);
Christoph Hellwigefa80272005-06-21 15:37:17 +10003487
3488 ip = ip->i_mnext;
3489 } while (ip != mp->m_inodes);
3490 out:
3491 XFS_MOUNT_IUNLOCK(mp);
3492}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003493
Linus Torvalds1da177e2005-04-16 15:20:36 -07003494#ifdef XFS_ILOCK_TRACE
3495ktrace_t *xfs_ilock_trace_buf;
3496
3497void
3498xfs_ilock_trace(xfs_inode_t *ip, int lock, unsigned int lockflags, inst_t *ra)
3499{
3500 ktrace_enter(ip->i_lock_trace,
3501 (void *)ip,
3502 (void *)(unsigned long)lock, /* 1 = LOCK, 3=UNLOCK, etc */
3503 (void *)(unsigned long)lockflags, /* XFS_ILOCK_EXCL etc */
3504 (void *)ra, /* caller of ilock */
3505 (void *)(unsigned long)current_cpu(),
3506 (void *)(unsigned long)current_pid(),
3507 NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL);
3508}
3509#endif
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11003510
3511/*
3512 * Return a pointer to the extent record at file index idx.
3513 */
Christoph Hellwiga6f64d42007-08-16 16:23:40 +10003514xfs_bmbt_rec_host_t *
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11003515xfs_iext_get_ext(
3516 xfs_ifork_t *ifp, /* inode fork pointer */
3517 xfs_extnum_t idx) /* index of target extent */
3518{
3519 ASSERT(idx >= 0);
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11003520 if ((ifp->if_flags & XFS_IFEXTIREC) && (idx == 0)) {
3521 return ifp->if_u1.if_ext_irec->er_extbuf;
3522 } else if (ifp->if_flags & XFS_IFEXTIREC) {
3523 xfs_ext_irec_t *erp; /* irec pointer */
3524 int erp_idx = 0; /* irec index */
3525 xfs_extnum_t page_idx = idx; /* ext index in target list */
3526
3527 erp = xfs_iext_idx_to_irec(ifp, &page_idx, &erp_idx, 0);
3528 return &erp->er_extbuf[page_idx];
3529 } else if (ifp->if_bytes) {
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11003530 return &ifp->if_u1.if_extents[idx];
3531 } else {
3532 return NULL;
3533 }
3534}
3535
3536/*
3537 * Insert new item(s) into the extent records for incore inode
3538 * fork 'ifp'. 'count' new items are inserted at index 'idx'.
3539 */
3540void
3541xfs_iext_insert(
3542 xfs_ifork_t *ifp, /* inode fork pointer */
3543 xfs_extnum_t idx, /* starting index of new items */
3544 xfs_extnum_t count, /* number of inserted items */
3545 xfs_bmbt_irec_t *new) /* items to insert */
3546{
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11003547 xfs_extnum_t i; /* extent record index */
3548
3549 ASSERT(ifp->if_flags & XFS_IFEXTENTS);
3550 xfs_iext_add(ifp, idx, count);
Christoph Hellwiga6f64d42007-08-16 16:23:40 +10003551 for (i = idx; i < idx + count; i++, new++)
3552 xfs_bmbt_set_all(xfs_iext_get_ext(ifp, i), new);
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11003553}
3554
3555/*
3556 * This is called when the amount of space required for incore file
3557 * extents needs to be increased. The ext_diff parameter stores the
3558 * number of new extents being added and the idx parameter contains
3559 * the extent index where the new extents will be added. If the new
3560 * extents are being appended, then we just need to (re)allocate and
3561 * initialize the space. Otherwise, if the new extents are being
3562 * inserted into the middle of the existing entries, a bit more work
3563 * is required to make room for the new extents to be inserted. The
3564 * caller is responsible for filling in the new extent entries upon
3565 * return.
3566 */
3567void
3568xfs_iext_add(
3569 xfs_ifork_t *ifp, /* inode fork pointer */
3570 xfs_extnum_t idx, /* index to begin adding exts */
Nathan Scottc41564b2006-03-29 08:55:14 +10003571 int ext_diff) /* number of extents to add */
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11003572{
3573 int byte_diff; /* new bytes being added */
3574 int new_size; /* size of extents after adding */
3575 xfs_extnum_t nextents; /* number of extents in file */
3576
3577 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
3578 ASSERT((idx >= 0) && (idx <= nextents));
3579 byte_diff = ext_diff * sizeof(xfs_bmbt_rec_t);
3580 new_size = ifp->if_bytes + byte_diff;
3581 /*
3582 * If the new number of extents (nextents + ext_diff)
3583 * fits inside the inode, then continue to use the inline
3584 * extent buffer.
3585 */
3586 if (nextents + ext_diff <= XFS_INLINE_EXTS) {
3587 if (idx < nextents) {
3588 memmove(&ifp->if_u2.if_inline_ext[idx + ext_diff],
3589 &ifp->if_u2.if_inline_ext[idx],
3590 (nextents - idx) * sizeof(xfs_bmbt_rec_t));
3591 memset(&ifp->if_u2.if_inline_ext[idx], 0, byte_diff);
3592 }
3593 ifp->if_u1.if_extents = ifp->if_u2.if_inline_ext;
3594 ifp->if_real_bytes = 0;
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11003595 ifp->if_lastex = nextents + ext_diff;
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11003596 }
3597 /*
3598 * Otherwise use a linear (direct) extent list.
3599 * If the extents are currently inside the inode,
3600 * xfs_iext_realloc_direct will switch us from
3601 * inline to direct extent allocation mode.
3602 */
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11003603 else if (nextents + ext_diff <= XFS_LINEAR_EXTS) {
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11003604 xfs_iext_realloc_direct(ifp, new_size);
3605 if (idx < nextents) {
3606 memmove(&ifp->if_u1.if_extents[idx + ext_diff],
3607 &ifp->if_u1.if_extents[idx],
3608 (nextents - idx) * sizeof(xfs_bmbt_rec_t));
3609 memset(&ifp->if_u1.if_extents[idx], 0, byte_diff);
3610 }
3611 }
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11003612 /* Indirection array */
3613 else {
3614 xfs_ext_irec_t *erp;
3615 int erp_idx = 0;
3616 int page_idx = idx;
3617
3618 ASSERT(nextents + ext_diff > XFS_LINEAR_EXTS);
3619 if (ifp->if_flags & XFS_IFEXTIREC) {
3620 erp = xfs_iext_idx_to_irec(ifp, &page_idx, &erp_idx, 1);
3621 } else {
3622 xfs_iext_irec_init(ifp);
3623 ASSERT(ifp->if_flags & XFS_IFEXTIREC);
3624 erp = ifp->if_u1.if_ext_irec;
3625 }
3626 /* Extents fit in target extent page */
3627 if (erp && erp->er_extcount + ext_diff <= XFS_LINEAR_EXTS) {
3628 if (page_idx < erp->er_extcount) {
3629 memmove(&erp->er_extbuf[page_idx + ext_diff],
3630 &erp->er_extbuf[page_idx],
3631 (erp->er_extcount - page_idx) *
3632 sizeof(xfs_bmbt_rec_t));
3633 memset(&erp->er_extbuf[page_idx], 0, byte_diff);
3634 }
3635 erp->er_extcount += ext_diff;
3636 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, ext_diff);
3637 }
3638 /* Insert a new extent page */
3639 else if (erp) {
3640 xfs_iext_add_indirect_multi(ifp,
3641 erp_idx, page_idx, ext_diff);
3642 }
3643 /*
3644 * If extent(s) are being appended to the last page in
3645 * the indirection array and the new extent(s) don't fit
3646 * in the page, then erp is NULL and erp_idx is set to
3647 * the next index needed in the indirection array.
3648 */
3649 else {
3650 int count = ext_diff;
3651
3652 while (count) {
3653 erp = xfs_iext_irec_new(ifp, erp_idx);
3654 erp->er_extcount = count;
3655 count -= MIN(count, (int)XFS_LINEAR_EXTS);
3656 if (count) {
3657 erp_idx++;
3658 }
3659 }
3660 }
3661 }
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11003662 ifp->if_bytes = new_size;
3663}
3664
3665/*
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11003666 * This is called when incore extents are being added to the indirection
3667 * array and the new extents do not fit in the target extent list. The
3668 * erp_idx parameter contains the irec index for the target extent list
3669 * in the indirection array, and the idx parameter contains the extent
3670 * index within the list. The number of extents being added is stored
3671 * in the count parameter.
3672 *
3673 * |-------| |-------|
3674 * | | | | idx - number of extents before idx
3675 * | idx | | count |
3676 * | | | | count - number of extents being inserted at idx
3677 * |-------| |-------|
3678 * | count | | nex2 | nex2 - number of extents after idx + count
3679 * |-------| |-------|
3680 */
3681void
3682xfs_iext_add_indirect_multi(
3683 xfs_ifork_t *ifp, /* inode fork pointer */
3684 int erp_idx, /* target extent irec index */
3685 xfs_extnum_t idx, /* index within target list */
3686 int count) /* new extents being added */
3687{
3688 int byte_diff; /* new bytes being added */
3689 xfs_ext_irec_t *erp; /* pointer to irec entry */
3690 xfs_extnum_t ext_diff; /* number of extents to add */
3691 xfs_extnum_t ext_cnt; /* new extents still needed */
3692 xfs_extnum_t nex2; /* extents after idx + count */
3693 xfs_bmbt_rec_t *nex2_ep = NULL; /* temp list for nex2 extents */
3694 int nlists; /* number of irec's (lists) */
3695
3696 ASSERT(ifp->if_flags & XFS_IFEXTIREC);
3697 erp = &ifp->if_u1.if_ext_irec[erp_idx];
3698 nex2 = erp->er_extcount - idx;
3699 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
3700
3701 /*
3702 * Save second part of target extent list
3703 * (all extents past */
3704 if (nex2) {
3705 byte_diff = nex2 * sizeof(xfs_bmbt_rec_t);
David Chinner67850732008-08-13 16:02:51 +10003706 nex2_ep = (xfs_bmbt_rec_t *) kmem_alloc(byte_diff, KM_NOFS);
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11003707 memmove(nex2_ep, &erp->er_extbuf[idx], byte_diff);
3708 erp->er_extcount -= nex2;
3709 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, -nex2);
3710 memset(&erp->er_extbuf[idx], 0, byte_diff);
3711 }
3712
3713 /*
3714 * Add the new extents to the end of the target
3715 * list, then allocate new irec record(s) and
3716 * extent buffer(s) as needed to store the rest
3717 * of the new extents.
3718 */
3719 ext_cnt = count;
3720 ext_diff = MIN(ext_cnt, (int)XFS_LINEAR_EXTS - erp->er_extcount);
3721 if (ext_diff) {
3722 erp->er_extcount += ext_diff;
3723 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, ext_diff);
3724 ext_cnt -= ext_diff;
3725 }
3726 while (ext_cnt) {
3727 erp_idx++;
3728 erp = xfs_iext_irec_new(ifp, erp_idx);
3729 ext_diff = MIN(ext_cnt, (int)XFS_LINEAR_EXTS);
3730 erp->er_extcount = ext_diff;
3731 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, ext_diff);
3732 ext_cnt -= ext_diff;
3733 }
3734
3735 /* Add nex2 extents back to indirection array */
3736 if (nex2) {
3737 xfs_extnum_t ext_avail;
3738 int i;
3739
3740 byte_diff = nex2 * sizeof(xfs_bmbt_rec_t);
3741 ext_avail = XFS_LINEAR_EXTS - erp->er_extcount;
3742 i = 0;
3743 /*
3744 * If nex2 extents fit in the current page, append
3745 * nex2_ep after the new extents.
3746 */
3747 if (nex2 <= ext_avail) {
3748 i = erp->er_extcount;
3749 }
3750 /*
3751 * Otherwise, check if space is available in the
3752 * next page.
3753 */
3754 else if ((erp_idx < nlists - 1) &&
3755 (nex2 <= (ext_avail = XFS_LINEAR_EXTS -
3756 ifp->if_u1.if_ext_irec[erp_idx+1].er_extcount))) {
3757 erp_idx++;
3758 erp++;
3759 /* Create a hole for nex2 extents */
3760 memmove(&erp->er_extbuf[nex2], erp->er_extbuf,
3761 erp->er_extcount * sizeof(xfs_bmbt_rec_t));
3762 }
3763 /*
3764 * Final choice, create a new extent page for
3765 * nex2 extents.
3766 */
3767 else {
3768 erp_idx++;
3769 erp = xfs_iext_irec_new(ifp, erp_idx);
3770 }
3771 memmove(&erp->er_extbuf[i], nex2_ep, byte_diff);
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10003772 kmem_free(nex2_ep);
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11003773 erp->er_extcount += nex2;
3774 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, nex2);
3775 }
3776}
3777
3778/*
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11003779 * This is called when the amount of space required for incore file
3780 * extents needs to be decreased. The ext_diff parameter stores the
3781 * number of extents to be removed and the idx parameter contains
3782 * the extent index where the extents will be removed from.
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11003783 *
3784 * If the amount of space needed has decreased below the linear
3785 * limit, XFS_IEXT_BUFSZ, then switch to using the contiguous
3786 * extent array. Otherwise, use kmem_realloc() to adjust the
3787 * size to what is needed.
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11003788 */
3789void
3790xfs_iext_remove(
3791 xfs_ifork_t *ifp, /* inode fork pointer */
3792 xfs_extnum_t idx, /* index to begin removing exts */
3793 int ext_diff) /* number of extents to remove */
3794{
3795 xfs_extnum_t nextents; /* number of extents in file */
3796 int new_size; /* size of extents after removal */
3797
3798 ASSERT(ext_diff > 0);
3799 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
3800 new_size = (nextents - ext_diff) * sizeof(xfs_bmbt_rec_t);
3801
3802 if (new_size == 0) {
3803 xfs_iext_destroy(ifp);
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11003804 } else if (ifp->if_flags & XFS_IFEXTIREC) {
3805 xfs_iext_remove_indirect(ifp, idx, ext_diff);
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11003806 } else if (ifp->if_real_bytes) {
3807 xfs_iext_remove_direct(ifp, idx, ext_diff);
3808 } else {
3809 xfs_iext_remove_inline(ifp, idx, ext_diff);
3810 }
3811 ifp->if_bytes = new_size;
3812}
3813
3814/*
3815 * This removes ext_diff extents from the inline buffer, beginning
3816 * at extent index idx.
3817 */
3818void
3819xfs_iext_remove_inline(
3820 xfs_ifork_t *ifp, /* inode fork pointer */
3821 xfs_extnum_t idx, /* index to begin removing exts */
3822 int ext_diff) /* number of extents to remove */
3823{
3824 int nextents; /* number of extents in file */
3825
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11003826 ASSERT(!(ifp->if_flags & XFS_IFEXTIREC));
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11003827 ASSERT(idx < XFS_INLINE_EXTS);
3828 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
3829 ASSERT(((nextents - ext_diff) > 0) &&
3830 (nextents - ext_diff) < XFS_INLINE_EXTS);
3831
3832 if (idx + ext_diff < nextents) {
3833 memmove(&ifp->if_u2.if_inline_ext[idx],
3834 &ifp->if_u2.if_inline_ext[idx + ext_diff],
3835 (nextents - (idx + ext_diff)) *
3836 sizeof(xfs_bmbt_rec_t));
3837 memset(&ifp->if_u2.if_inline_ext[nextents - ext_diff],
3838 0, ext_diff * sizeof(xfs_bmbt_rec_t));
3839 } else {
3840 memset(&ifp->if_u2.if_inline_ext[idx], 0,
3841 ext_diff * sizeof(xfs_bmbt_rec_t));
3842 }
3843}
3844
3845/*
3846 * This removes ext_diff extents from a linear (direct) extent list,
3847 * beginning at extent index idx. If the extents are being removed
3848 * from the end of the list (ie. truncate) then we just need to re-
3849 * allocate the list to remove the extra space. Otherwise, if the
3850 * extents are being removed from the middle of the existing extent
3851 * entries, then we first need to move the extent records beginning
3852 * at idx + ext_diff up in the list to overwrite the records being
3853 * removed, then remove the extra space via kmem_realloc.
3854 */
3855void
3856xfs_iext_remove_direct(
3857 xfs_ifork_t *ifp, /* inode fork pointer */
3858 xfs_extnum_t idx, /* index to begin removing exts */
3859 int ext_diff) /* number of extents to remove */
3860{
3861 xfs_extnum_t nextents; /* number of extents in file */
3862 int new_size; /* size of extents after removal */
3863
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11003864 ASSERT(!(ifp->if_flags & XFS_IFEXTIREC));
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11003865 new_size = ifp->if_bytes -
3866 (ext_diff * sizeof(xfs_bmbt_rec_t));
3867 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
3868
3869 if (new_size == 0) {
3870 xfs_iext_destroy(ifp);
3871 return;
3872 }
3873 /* Move extents up in the list (if needed) */
3874 if (idx + ext_diff < nextents) {
3875 memmove(&ifp->if_u1.if_extents[idx],
3876 &ifp->if_u1.if_extents[idx + ext_diff],
3877 (nextents - (idx + ext_diff)) *
3878 sizeof(xfs_bmbt_rec_t));
3879 }
3880 memset(&ifp->if_u1.if_extents[nextents - ext_diff],
3881 0, ext_diff * sizeof(xfs_bmbt_rec_t));
3882 /*
3883 * Reallocate the direct extent list. If the extents
3884 * will fit inside the inode then xfs_iext_realloc_direct
3885 * will switch from direct to inline extent allocation
3886 * mode for us.
3887 */
3888 xfs_iext_realloc_direct(ifp, new_size);
3889 ifp->if_bytes = new_size;
3890}
3891
3892/*
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11003893 * This is called when incore extents are being removed from the
3894 * indirection array and the extents being removed span multiple extent
3895 * buffers. The idx parameter contains the file extent index where we
3896 * want to begin removing extents, and the count parameter contains
3897 * how many extents need to be removed.
3898 *
3899 * |-------| |-------|
3900 * | nex1 | | | nex1 - number of extents before idx
3901 * |-------| | count |
3902 * | | | | count - number of extents being removed at idx
3903 * | count | |-------|
3904 * | | | nex2 | nex2 - number of extents after idx + count
3905 * |-------| |-------|
3906 */
3907void
3908xfs_iext_remove_indirect(
3909 xfs_ifork_t *ifp, /* inode fork pointer */
3910 xfs_extnum_t idx, /* index to begin removing extents */
3911 int count) /* number of extents to remove */
3912{
3913 xfs_ext_irec_t *erp; /* indirection array pointer */
3914 int erp_idx = 0; /* indirection array index */
3915 xfs_extnum_t ext_cnt; /* extents left to remove */
3916 xfs_extnum_t ext_diff; /* extents to remove in current list */
3917 xfs_extnum_t nex1; /* number of extents before idx */
3918 xfs_extnum_t nex2; /* extents after idx + count */
Nathan Scottc41564b2006-03-29 08:55:14 +10003919 int nlists; /* entries in indirection array */
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11003920 int page_idx = idx; /* index in target extent list */
3921
3922 ASSERT(ifp->if_flags & XFS_IFEXTIREC);
3923 erp = xfs_iext_idx_to_irec(ifp, &page_idx, &erp_idx, 0);
3924 ASSERT(erp != NULL);
3925 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
3926 nex1 = page_idx;
3927 ext_cnt = count;
3928 while (ext_cnt) {
3929 nex2 = MAX((erp->er_extcount - (nex1 + ext_cnt)), 0);
3930 ext_diff = MIN(ext_cnt, (erp->er_extcount - nex1));
3931 /*
3932 * Check for deletion of entire list;
3933 * xfs_iext_irec_remove() updates extent offsets.
3934 */
3935 if (ext_diff == erp->er_extcount) {
3936 xfs_iext_irec_remove(ifp, erp_idx);
3937 ext_cnt -= ext_diff;
3938 nex1 = 0;
3939 if (ext_cnt) {
3940 ASSERT(erp_idx < ifp->if_real_bytes /
3941 XFS_IEXT_BUFSZ);
3942 erp = &ifp->if_u1.if_ext_irec[erp_idx];
3943 nex1 = 0;
3944 continue;
3945 } else {
3946 break;
3947 }
3948 }
3949 /* Move extents up (if needed) */
3950 if (nex2) {
3951 memmove(&erp->er_extbuf[nex1],
3952 &erp->er_extbuf[nex1 + ext_diff],
3953 nex2 * sizeof(xfs_bmbt_rec_t));
3954 }
3955 /* Zero out rest of page */
3956 memset(&erp->er_extbuf[nex1 + nex2], 0, (XFS_IEXT_BUFSZ -
3957 ((nex1 + nex2) * sizeof(xfs_bmbt_rec_t))));
3958 /* Update remaining counters */
3959 erp->er_extcount -= ext_diff;
3960 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1, -ext_diff);
3961 ext_cnt -= ext_diff;
3962 nex1 = 0;
3963 erp_idx++;
3964 erp++;
3965 }
3966 ifp->if_bytes -= count * sizeof(xfs_bmbt_rec_t);
3967 xfs_iext_irec_compact(ifp);
3968}
3969
3970/*
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11003971 * Create, destroy, or resize a linear (direct) block of extents.
3972 */
3973void
3974xfs_iext_realloc_direct(
3975 xfs_ifork_t *ifp, /* inode fork pointer */
3976 int new_size) /* new size of extents */
3977{
3978 int rnew_size; /* real new size of extents */
3979
3980 rnew_size = new_size;
3981
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11003982 ASSERT(!(ifp->if_flags & XFS_IFEXTIREC) ||
3983 ((new_size >= 0) && (new_size <= XFS_IEXT_BUFSZ) &&
3984 (new_size != ifp->if_real_bytes)));
3985
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11003986 /* Free extent records */
3987 if (new_size == 0) {
3988 xfs_iext_destroy(ifp);
3989 }
3990 /* Resize direct extent list and zero any new bytes */
3991 else if (ifp->if_real_bytes) {
3992 /* Check if extents will fit inside the inode */
3993 if (new_size <= XFS_INLINE_EXTS * sizeof(xfs_bmbt_rec_t)) {
3994 xfs_iext_direct_to_inline(ifp, new_size /
3995 (uint)sizeof(xfs_bmbt_rec_t));
3996 ifp->if_bytes = new_size;
3997 return;
3998 }
Vignesh Babu16a087d2007-06-28 16:46:37 +10003999 if (!is_power_of_2(new_size)){
Robert P. J. Day40ebd812007-11-23 16:30:51 +11004000 rnew_size = roundup_pow_of_two(new_size);
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11004001 }
4002 if (rnew_size != ifp->if_real_bytes) {
Christoph Hellwiga6f64d42007-08-16 16:23:40 +10004003 ifp->if_u1.if_extents =
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11004004 kmem_realloc(ifp->if_u1.if_extents,
4005 rnew_size,
David Chinner67850732008-08-13 16:02:51 +10004006 ifp->if_real_bytes, KM_NOFS);
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11004007 }
4008 if (rnew_size > ifp->if_real_bytes) {
4009 memset(&ifp->if_u1.if_extents[ifp->if_bytes /
4010 (uint)sizeof(xfs_bmbt_rec_t)], 0,
4011 rnew_size - ifp->if_real_bytes);
4012 }
4013 }
4014 /*
4015 * Switch from the inline extent buffer to a direct
4016 * extent list. Be sure to include the inline extent
4017 * bytes in new_size.
4018 */
4019 else {
4020 new_size += ifp->if_bytes;
Vignesh Babu16a087d2007-06-28 16:46:37 +10004021 if (!is_power_of_2(new_size)) {
Robert P. J. Day40ebd812007-11-23 16:30:51 +11004022 rnew_size = roundup_pow_of_two(new_size);
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11004023 }
4024 xfs_iext_inline_to_direct(ifp, rnew_size);
4025 }
4026 ifp->if_real_bytes = rnew_size;
4027 ifp->if_bytes = new_size;
4028}
4029
4030/*
4031 * Switch from linear (direct) extent records to inline buffer.
4032 */
4033void
4034xfs_iext_direct_to_inline(
4035 xfs_ifork_t *ifp, /* inode fork pointer */
4036 xfs_extnum_t nextents) /* number of extents in file */
4037{
4038 ASSERT(ifp->if_flags & XFS_IFEXTENTS);
4039 ASSERT(nextents <= XFS_INLINE_EXTS);
4040 /*
4041 * The inline buffer was zeroed when we switched
4042 * from inline to direct extent allocation mode,
4043 * so we don't need to clear it here.
4044 */
4045 memcpy(ifp->if_u2.if_inline_ext, ifp->if_u1.if_extents,
4046 nextents * sizeof(xfs_bmbt_rec_t));
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10004047 kmem_free(ifp->if_u1.if_extents);
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11004048 ifp->if_u1.if_extents = ifp->if_u2.if_inline_ext;
4049 ifp->if_real_bytes = 0;
4050}
4051
4052/*
4053 * Switch from inline buffer to linear (direct) extent records.
4054 * new_size should already be rounded up to the next power of 2
4055 * by the caller (when appropriate), so use new_size as it is.
4056 * However, since new_size may be rounded up, we can't update
4057 * if_bytes here. It is the caller's responsibility to update
4058 * if_bytes upon return.
4059 */
4060void
4061xfs_iext_inline_to_direct(
4062 xfs_ifork_t *ifp, /* inode fork pointer */
4063 int new_size) /* number of extents in file */
4064{
David Chinner67850732008-08-13 16:02:51 +10004065 ifp->if_u1.if_extents = kmem_alloc(new_size, KM_NOFS);
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11004066 memset(ifp->if_u1.if_extents, 0, new_size);
4067 if (ifp->if_bytes) {
4068 memcpy(ifp->if_u1.if_extents, ifp->if_u2.if_inline_ext,
4069 ifp->if_bytes);
4070 memset(ifp->if_u2.if_inline_ext, 0, XFS_INLINE_EXTS *
4071 sizeof(xfs_bmbt_rec_t));
4072 }
4073 ifp->if_real_bytes = new_size;
4074}
4075
4076/*
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11004077 * Resize an extent indirection array to new_size bytes.
4078 */
4079void
4080xfs_iext_realloc_indirect(
4081 xfs_ifork_t *ifp, /* inode fork pointer */
4082 int new_size) /* new indirection array size */
4083{
4084 int nlists; /* number of irec's (ex lists) */
4085 int size; /* current indirection array size */
4086
4087 ASSERT(ifp->if_flags & XFS_IFEXTIREC);
4088 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
4089 size = nlists * sizeof(xfs_ext_irec_t);
4090 ASSERT(ifp->if_real_bytes);
4091 ASSERT((new_size >= 0) && (new_size != size));
4092 if (new_size == 0) {
4093 xfs_iext_destroy(ifp);
4094 } else {
4095 ifp->if_u1.if_ext_irec = (xfs_ext_irec_t *)
4096 kmem_realloc(ifp->if_u1.if_ext_irec,
David Chinner67850732008-08-13 16:02:51 +10004097 new_size, size, KM_NOFS);
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11004098 }
4099}
4100
4101/*
4102 * Switch from indirection array to linear (direct) extent allocations.
4103 */
4104void
4105xfs_iext_indirect_to_direct(
4106 xfs_ifork_t *ifp) /* inode fork pointer */
4107{
Christoph Hellwiga6f64d42007-08-16 16:23:40 +10004108 xfs_bmbt_rec_host_t *ep; /* extent record pointer */
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11004109 xfs_extnum_t nextents; /* number of extents in file */
4110 int size; /* size of file extents */
4111
4112 ASSERT(ifp->if_flags & XFS_IFEXTIREC);
4113 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
4114 ASSERT(nextents <= XFS_LINEAR_EXTS);
4115 size = nextents * sizeof(xfs_bmbt_rec_t);
4116
4117 xfs_iext_irec_compact_full(ifp);
4118 ASSERT(ifp->if_real_bytes == XFS_IEXT_BUFSZ);
4119
4120 ep = ifp->if_u1.if_ext_irec->er_extbuf;
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10004121 kmem_free(ifp->if_u1.if_ext_irec);
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11004122 ifp->if_flags &= ~XFS_IFEXTIREC;
4123 ifp->if_u1.if_extents = ep;
4124 ifp->if_bytes = size;
4125 if (nextents < XFS_LINEAR_EXTS) {
4126 xfs_iext_realloc_direct(ifp, size);
4127 }
4128}
4129
4130/*
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11004131 * Free incore file extents.
4132 */
4133void
4134xfs_iext_destroy(
4135 xfs_ifork_t *ifp) /* inode fork pointer */
4136{
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11004137 if (ifp->if_flags & XFS_IFEXTIREC) {
4138 int erp_idx;
4139 int nlists;
4140
4141 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
4142 for (erp_idx = nlists - 1; erp_idx >= 0 ; erp_idx--) {
4143 xfs_iext_irec_remove(ifp, erp_idx);
4144 }
4145 ifp->if_flags &= ~XFS_IFEXTIREC;
4146 } else if (ifp->if_real_bytes) {
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10004147 kmem_free(ifp->if_u1.if_extents);
Mandy Kirkconnell4eea22f2006-03-14 13:29:52 +11004148 } else if (ifp->if_bytes) {
4149 memset(ifp->if_u2.if_inline_ext, 0, XFS_INLINE_EXTS *
4150 sizeof(xfs_bmbt_rec_t));
4151 }
4152 ifp->if_u1.if_extents = NULL;
4153 ifp->if_real_bytes = 0;
4154 ifp->if_bytes = 0;
4155}
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11004156
4157/*
Mandy Kirkconnell8867bc92006-03-17 17:25:04 +11004158 * Return a pointer to the extent record for file system block bno.
4159 */
Christoph Hellwiga6f64d42007-08-16 16:23:40 +10004160xfs_bmbt_rec_host_t * /* pointer to found extent record */
Mandy Kirkconnell8867bc92006-03-17 17:25:04 +11004161xfs_iext_bno_to_ext(
4162 xfs_ifork_t *ifp, /* inode fork pointer */
4163 xfs_fileoff_t bno, /* block number to search for */
4164 xfs_extnum_t *idxp) /* index of target extent */
4165{
Christoph Hellwiga6f64d42007-08-16 16:23:40 +10004166 xfs_bmbt_rec_host_t *base; /* pointer to first extent */
Mandy Kirkconnell8867bc92006-03-17 17:25:04 +11004167 xfs_filblks_t blockcount = 0; /* number of blocks in extent */
Christoph Hellwiga6f64d42007-08-16 16:23:40 +10004168 xfs_bmbt_rec_host_t *ep = NULL; /* pointer to target extent */
Mandy Kirkconnell8867bc92006-03-17 17:25:04 +11004169 xfs_ext_irec_t *erp = NULL; /* indirection array pointer */
Nathan Scottc41564b2006-03-29 08:55:14 +10004170 int high; /* upper boundary in search */
Mandy Kirkconnell8867bc92006-03-17 17:25:04 +11004171 xfs_extnum_t idx = 0; /* index of target extent */
Nathan Scottc41564b2006-03-29 08:55:14 +10004172 int low; /* lower boundary in search */
Mandy Kirkconnell8867bc92006-03-17 17:25:04 +11004173 xfs_extnum_t nextents; /* number of file extents */
4174 xfs_fileoff_t startoff = 0; /* start offset of extent */
4175
4176 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
4177 if (nextents == 0) {
4178 *idxp = 0;
4179 return NULL;
4180 }
4181 low = 0;
4182 if (ifp->if_flags & XFS_IFEXTIREC) {
4183 /* Find target extent list */
4184 int erp_idx = 0;
4185 erp = xfs_iext_bno_to_irec(ifp, bno, &erp_idx);
4186 base = erp->er_extbuf;
4187 high = erp->er_extcount - 1;
4188 } else {
4189 base = ifp->if_u1.if_extents;
4190 high = nextents - 1;
4191 }
4192 /* Binary search extent records */
4193 while (low <= high) {
4194 idx = (low + high) >> 1;
4195 ep = base + idx;
4196 startoff = xfs_bmbt_get_startoff(ep);
4197 blockcount = xfs_bmbt_get_blockcount(ep);
4198 if (bno < startoff) {
4199 high = idx - 1;
4200 } else if (bno >= startoff + blockcount) {
4201 low = idx + 1;
4202 } else {
4203 /* Convert back to file-based extent index */
4204 if (ifp->if_flags & XFS_IFEXTIREC) {
4205 idx += erp->er_extoff;
4206 }
4207 *idxp = idx;
4208 return ep;
4209 }
4210 }
4211 /* Convert back to file-based extent index */
4212 if (ifp->if_flags & XFS_IFEXTIREC) {
4213 idx += erp->er_extoff;
4214 }
4215 if (bno >= startoff + blockcount) {
4216 if (++idx == nextents) {
4217 ep = NULL;
4218 } else {
4219 ep = xfs_iext_get_ext(ifp, idx);
4220 }
4221 }
4222 *idxp = idx;
4223 return ep;
4224}
4225
4226/*
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11004227 * Return a pointer to the indirection array entry containing the
4228 * extent record for filesystem block bno. Store the index of the
4229 * target irec in *erp_idxp.
4230 */
Mandy Kirkconnell8867bc92006-03-17 17:25:04 +11004231xfs_ext_irec_t * /* pointer to found extent record */
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11004232xfs_iext_bno_to_irec(
4233 xfs_ifork_t *ifp, /* inode fork pointer */
4234 xfs_fileoff_t bno, /* block number to search for */
4235 int *erp_idxp) /* irec index of target ext list */
4236{
4237 xfs_ext_irec_t *erp = NULL; /* indirection array pointer */
4238 xfs_ext_irec_t *erp_next; /* next indirection array entry */
Mandy Kirkconnell8867bc92006-03-17 17:25:04 +11004239 int erp_idx; /* indirection array index */
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11004240 int nlists; /* number of extent irec's (lists) */
4241 int high; /* binary search upper limit */
4242 int low; /* binary search lower limit */
4243
4244 ASSERT(ifp->if_flags & XFS_IFEXTIREC);
4245 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
4246 erp_idx = 0;
4247 low = 0;
4248 high = nlists - 1;
4249 while (low <= high) {
4250 erp_idx = (low + high) >> 1;
4251 erp = &ifp->if_u1.if_ext_irec[erp_idx];
4252 erp_next = erp_idx < nlists - 1 ? erp + 1 : NULL;
4253 if (bno < xfs_bmbt_get_startoff(erp->er_extbuf)) {
4254 high = erp_idx - 1;
4255 } else if (erp_next && bno >=
4256 xfs_bmbt_get_startoff(erp_next->er_extbuf)) {
4257 low = erp_idx + 1;
4258 } else {
4259 break;
4260 }
4261 }
4262 *erp_idxp = erp_idx;
4263 return erp;
4264}
4265
4266/*
4267 * Return a pointer to the indirection array entry containing the
4268 * extent record at file extent index *idxp. Store the index of the
4269 * target irec in *erp_idxp and store the page index of the target
4270 * extent record in *idxp.
4271 */
4272xfs_ext_irec_t *
4273xfs_iext_idx_to_irec(
4274 xfs_ifork_t *ifp, /* inode fork pointer */
4275 xfs_extnum_t *idxp, /* extent index (file -> page) */
4276 int *erp_idxp, /* pointer to target irec */
4277 int realloc) /* new bytes were just added */
4278{
4279 xfs_ext_irec_t *prev; /* pointer to previous irec */
4280 xfs_ext_irec_t *erp = NULL; /* pointer to current irec */
4281 int erp_idx; /* indirection array index */
4282 int nlists; /* number of irec's (ex lists) */
4283 int high; /* binary search upper limit */
4284 int low; /* binary search lower limit */
4285 xfs_extnum_t page_idx = *idxp; /* extent index in target list */
4286
4287 ASSERT(ifp->if_flags & XFS_IFEXTIREC);
4288 ASSERT(page_idx >= 0 && page_idx <=
4289 ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t));
4290 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
4291 erp_idx = 0;
4292 low = 0;
4293 high = nlists - 1;
4294
4295 /* Binary search extent irec's */
4296 while (low <= high) {
4297 erp_idx = (low + high) >> 1;
4298 erp = &ifp->if_u1.if_ext_irec[erp_idx];
4299 prev = erp_idx > 0 ? erp - 1 : NULL;
4300 if (page_idx < erp->er_extoff || (page_idx == erp->er_extoff &&
4301 realloc && prev && prev->er_extcount < XFS_LINEAR_EXTS)) {
4302 high = erp_idx - 1;
4303 } else if (page_idx > erp->er_extoff + erp->er_extcount ||
4304 (page_idx == erp->er_extoff + erp->er_extcount &&
4305 !realloc)) {
4306 low = erp_idx + 1;
4307 } else if (page_idx == erp->er_extoff + erp->er_extcount &&
4308 erp->er_extcount == XFS_LINEAR_EXTS) {
4309 ASSERT(realloc);
4310 page_idx = 0;
4311 erp_idx++;
4312 erp = erp_idx < nlists ? erp + 1 : NULL;
4313 break;
4314 } else {
4315 page_idx -= erp->er_extoff;
4316 break;
4317 }
4318 }
4319 *idxp = page_idx;
4320 *erp_idxp = erp_idx;
4321 return(erp);
4322}
4323
4324/*
4325 * Allocate and initialize an indirection array once the space needed
4326 * for incore extents increases above XFS_IEXT_BUFSZ.
4327 */
4328void
4329xfs_iext_irec_init(
4330 xfs_ifork_t *ifp) /* inode fork pointer */
4331{
4332 xfs_ext_irec_t *erp; /* indirection array pointer */
4333 xfs_extnum_t nextents; /* number of extents in file */
4334
4335 ASSERT(!(ifp->if_flags & XFS_IFEXTIREC));
4336 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
4337 ASSERT(nextents <= XFS_LINEAR_EXTS);
4338
David Chinner67850732008-08-13 16:02:51 +10004339 erp = kmem_alloc(sizeof(xfs_ext_irec_t), KM_NOFS);
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11004340
4341 if (nextents == 0) {
David Chinner67850732008-08-13 16:02:51 +10004342 ifp->if_u1.if_extents = kmem_alloc(XFS_IEXT_BUFSZ, KM_NOFS);
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11004343 } else if (!ifp->if_real_bytes) {
4344 xfs_iext_inline_to_direct(ifp, XFS_IEXT_BUFSZ);
4345 } else if (ifp->if_real_bytes < XFS_IEXT_BUFSZ) {
4346 xfs_iext_realloc_direct(ifp, XFS_IEXT_BUFSZ);
4347 }
4348 erp->er_extbuf = ifp->if_u1.if_extents;
4349 erp->er_extcount = nextents;
4350 erp->er_extoff = 0;
4351
4352 ifp->if_flags |= XFS_IFEXTIREC;
4353 ifp->if_real_bytes = XFS_IEXT_BUFSZ;
4354 ifp->if_bytes = nextents * sizeof(xfs_bmbt_rec_t);
4355 ifp->if_u1.if_ext_irec = erp;
4356
4357 return;
4358}
4359
4360/*
4361 * Allocate and initialize a new entry in the indirection array.
4362 */
4363xfs_ext_irec_t *
4364xfs_iext_irec_new(
4365 xfs_ifork_t *ifp, /* inode fork pointer */
4366 int erp_idx) /* index for new irec */
4367{
4368 xfs_ext_irec_t *erp; /* indirection array pointer */
4369 int i; /* loop counter */
4370 int nlists; /* number of irec's (ex lists) */
4371
4372 ASSERT(ifp->if_flags & XFS_IFEXTIREC);
4373 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
4374
4375 /* Resize indirection array */
4376 xfs_iext_realloc_indirect(ifp, ++nlists *
4377 sizeof(xfs_ext_irec_t));
4378 /*
4379 * Move records down in the array so the
4380 * new page can use erp_idx.
4381 */
4382 erp = ifp->if_u1.if_ext_irec;
4383 for (i = nlists - 1; i > erp_idx; i--) {
4384 memmove(&erp[i], &erp[i-1], sizeof(xfs_ext_irec_t));
4385 }
4386 ASSERT(i == erp_idx);
4387
4388 /* Initialize new extent record */
4389 erp = ifp->if_u1.if_ext_irec;
David Chinner67850732008-08-13 16:02:51 +10004390 erp[erp_idx].er_extbuf = kmem_alloc(XFS_IEXT_BUFSZ, KM_NOFS);
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11004391 ifp->if_real_bytes = nlists * XFS_IEXT_BUFSZ;
4392 memset(erp[erp_idx].er_extbuf, 0, XFS_IEXT_BUFSZ);
4393 erp[erp_idx].er_extcount = 0;
4394 erp[erp_idx].er_extoff = erp_idx > 0 ?
4395 erp[erp_idx-1].er_extoff + erp[erp_idx-1].er_extcount : 0;
4396 return (&erp[erp_idx]);
4397}
4398
4399/*
4400 * Remove a record from the indirection array.
4401 */
4402void
4403xfs_iext_irec_remove(
4404 xfs_ifork_t *ifp, /* inode fork pointer */
4405 int erp_idx) /* irec index to remove */
4406{
4407 xfs_ext_irec_t *erp; /* indirection array pointer */
4408 int i; /* loop counter */
4409 int nlists; /* number of irec's (ex lists) */
4410
4411 ASSERT(ifp->if_flags & XFS_IFEXTIREC);
4412 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
4413 erp = &ifp->if_u1.if_ext_irec[erp_idx];
4414 if (erp->er_extbuf) {
4415 xfs_iext_irec_update_extoffs(ifp, erp_idx + 1,
4416 -erp->er_extcount);
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10004417 kmem_free(erp->er_extbuf);
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11004418 }
4419 /* Compact extent records */
4420 erp = ifp->if_u1.if_ext_irec;
4421 for (i = erp_idx; i < nlists - 1; i++) {
4422 memmove(&erp[i], &erp[i+1], sizeof(xfs_ext_irec_t));
4423 }
4424 /*
4425 * Manually free the last extent record from the indirection
4426 * array. A call to xfs_iext_realloc_indirect() with a size
4427 * of zero would result in a call to xfs_iext_destroy() which
4428 * would in turn call this function again, creating a nasty
4429 * infinite loop.
4430 */
4431 if (--nlists) {
4432 xfs_iext_realloc_indirect(ifp,
4433 nlists * sizeof(xfs_ext_irec_t));
4434 } else {
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10004435 kmem_free(ifp->if_u1.if_ext_irec);
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11004436 }
4437 ifp->if_real_bytes = nlists * XFS_IEXT_BUFSZ;
4438}
4439
4440/*
4441 * This is called to clean up large amounts of unused memory allocated
4442 * by the indirection array. Before compacting anything though, verify
4443 * that the indirection array is still needed and switch back to the
4444 * linear extent list (or even the inline buffer) if possible. The
4445 * compaction policy is as follows:
4446 *
4447 * Full Compaction: Extents fit into a single page (or inline buffer)
4448 * Full Compaction: Extents occupy less than 10% of allocated space
4449 * Partial Compaction: Extents occupy > 10% and < 50% of allocated space
4450 * No Compaction: Extents occupy at least 50% of allocated space
4451 */
4452void
4453xfs_iext_irec_compact(
4454 xfs_ifork_t *ifp) /* inode fork pointer */
4455{
4456 xfs_extnum_t nextents; /* number of extents in file */
4457 int nlists; /* number of irec's (ex lists) */
4458
4459 ASSERT(ifp->if_flags & XFS_IFEXTIREC);
4460 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
4461 nextents = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
4462
4463 if (nextents == 0) {
4464 xfs_iext_destroy(ifp);
4465 } else if (nextents <= XFS_INLINE_EXTS) {
4466 xfs_iext_indirect_to_direct(ifp);
4467 xfs_iext_direct_to_inline(ifp, nextents);
4468 } else if (nextents <= XFS_LINEAR_EXTS) {
4469 xfs_iext_indirect_to_direct(ifp);
4470 } else if (nextents < (nlists * XFS_LINEAR_EXTS) >> 3) {
4471 xfs_iext_irec_compact_full(ifp);
4472 } else if (nextents < (nlists * XFS_LINEAR_EXTS) >> 1) {
4473 xfs_iext_irec_compact_pages(ifp);
4474 }
4475}
4476
4477/*
4478 * Combine extents from neighboring extent pages.
4479 */
4480void
4481xfs_iext_irec_compact_pages(
4482 xfs_ifork_t *ifp) /* inode fork pointer */
4483{
4484 xfs_ext_irec_t *erp, *erp_next;/* pointers to irec entries */
4485 int erp_idx = 0; /* indirection array index */
4486 int nlists; /* number of irec's (ex lists) */
4487
4488 ASSERT(ifp->if_flags & XFS_IFEXTIREC);
4489 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
4490 while (erp_idx < nlists - 1) {
4491 erp = &ifp->if_u1.if_ext_irec[erp_idx];
4492 erp_next = erp + 1;
4493 if (erp_next->er_extcount <=
4494 (XFS_LINEAR_EXTS - erp->er_extcount)) {
4495 memmove(&erp->er_extbuf[erp->er_extcount],
4496 erp_next->er_extbuf, erp_next->er_extcount *
4497 sizeof(xfs_bmbt_rec_t));
4498 erp->er_extcount += erp_next->er_extcount;
4499 /*
4500 * Free page before removing extent record
4501 * so er_extoffs don't get modified in
4502 * xfs_iext_irec_remove.
4503 */
Denys Vlasenkof0e2d932008-05-19 16:31:57 +10004504 kmem_free(erp_next->er_extbuf);
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11004505 erp_next->er_extbuf = NULL;
4506 xfs_iext_irec_remove(ifp, erp_idx + 1);
4507 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
4508 } else {
4509 erp_idx++;
4510 }
4511 }
4512}
4513
4514/*
4515 * Fully compact the extent records managed by the indirection array.
4516 */
4517void
4518xfs_iext_irec_compact_full(
4519 xfs_ifork_t *ifp) /* inode fork pointer */
4520{
Christoph Hellwiga6f64d42007-08-16 16:23:40 +10004521 xfs_bmbt_rec_host_t *ep, *ep_next; /* extent record pointers */
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11004522 xfs_ext_irec_t *erp, *erp_next; /* extent irec pointers */
4523 int erp_idx = 0; /* extent irec index */
4524 int ext_avail; /* empty entries in ex list */
4525 int ext_diff; /* number of exts to add */
4526 int nlists; /* number of irec's (ex lists) */
4527
4528 ASSERT(ifp->if_flags & XFS_IFEXTIREC);
Lachlan McIlroy6278deb2008-06-23 13:25:02 +10004529
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11004530 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
4531 erp = ifp->if_u1.if_ext_irec;
4532 ep = &erp->er_extbuf[erp->er_extcount];
4533 erp_next = erp + 1;
4534 ep_next = erp_next->er_extbuf;
Lachlan McIlroy6278deb2008-06-23 13:25:02 +10004535
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11004536 while (erp_idx < nlists - 1) {
Lachlan McIlroy6278deb2008-06-23 13:25:02 +10004537 /*
4538 * Check how many extent records are available in this irec.
4539 * If there is none skip the whole exercise.
4540 */
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11004541 ext_avail = XFS_LINEAR_EXTS - erp->er_extcount;
Lachlan McIlroy6278deb2008-06-23 13:25:02 +10004542 if (ext_avail) {
4543
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11004544 /*
Lachlan McIlroy6278deb2008-06-23 13:25:02 +10004545 * Copy over as many as possible extent records into
4546 * the previous page.
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11004547 */
Lachlan McIlroy6278deb2008-06-23 13:25:02 +10004548 ext_diff = MIN(ext_avail, erp_next->er_extcount);
4549 memcpy(ep, ep_next, ext_diff * sizeof(xfs_bmbt_rec_t));
4550 erp->er_extcount += ext_diff;
4551 erp_next->er_extcount -= ext_diff;
4552
4553 /*
4554 * If the next irec is empty now we can simply
4555 * remove it.
4556 */
4557 if (erp_next->er_extcount == 0) {
4558 /*
4559 * Free page before removing extent record
4560 * so er_extoffs don't get modified in
4561 * xfs_iext_irec_remove.
4562 */
4563 kmem_free(erp_next->er_extbuf);
4564 erp_next->er_extbuf = NULL;
4565 xfs_iext_irec_remove(ifp, erp_idx + 1);
4566 erp = &ifp->if_u1.if_ext_irec[erp_idx];
4567 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
4568
4569 /*
4570 * If the next irec is not empty move up the content
4571 * that has not been copied to the previous page to
4572 * the beggining of this one.
4573 */
4574 } else {
4575 memmove(erp_next->er_extbuf, &ep_next[ext_diff],
4576 erp_next->er_extcount *
4577 sizeof(xfs_bmbt_rec_t));
4578 ep_next = erp_next->er_extbuf;
4579 memset(&ep_next[erp_next->er_extcount], 0,
4580 (XFS_LINEAR_EXTS -
4581 erp_next->er_extcount) *
4582 sizeof(xfs_bmbt_rec_t));
4583 }
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11004584 }
Lachlan McIlroy6278deb2008-06-23 13:25:02 +10004585
Mandy Kirkconnell0293ce32006-03-14 13:30:23 +11004586 if (erp->er_extcount == XFS_LINEAR_EXTS) {
4587 erp_idx++;
4588 if (erp_idx < nlists)
4589 erp = &ifp->if_u1.if_ext_irec[erp_idx];
4590 else
4591 break;
4592 }
4593 ep = &erp->er_extbuf[erp->er_extcount];
4594 erp_next = erp + 1;
4595 ep_next = erp_next->er_extbuf;
4596 }
4597}
4598
4599/*
4600 * This is called to update the er_extoff field in the indirection
4601 * array when extents have been added or removed from one of the
4602 * extent lists. erp_idx contains the irec index to begin updating
4603 * at and ext_diff contains the number of extents that were added
4604 * or removed.
4605 */
4606void
4607xfs_iext_irec_update_extoffs(
4608 xfs_ifork_t *ifp, /* inode fork pointer */
4609 int erp_idx, /* irec index to update */
4610 int ext_diff) /* number of new extents */
4611{
4612 int i; /* loop counter */
4613 int nlists; /* number of irec's (ex lists */
4614
4615 ASSERT(ifp->if_flags & XFS_IFEXTIREC);
4616 nlists = ifp->if_real_bytes / XFS_IEXT_BUFSZ;
4617 for (i = erp_idx; i < nlists; i++) {
4618 ifp->if_u1.if_ext_irec[i].er_extoff += ext_diff;
4619 }
4620}