Loading...
Note: File does not exist in v6.9.4.
1/*
2 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
3 * All Rights Reserved.
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
7 * published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
13 *
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
17 */
18
19#include "xfs.h"
20#include "xfs_fs.h"
21#include "xfs_types.h"
22#include "xfs_bit.h"
23#include "xfs_log.h"
24#include "xfs_trans.h"
25#include "xfs_sb.h"
26#include "xfs_ag.h"
27#include "xfs_dir2.h"
28#include "xfs_mount.h"
29#include "xfs_da_btree.h"
30#include "xfs_bmap_btree.h"
31#include "xfs_ialloc_btree.h"
32#include "xfs_dinode.h"
33#include "xfs_inode.h"
34#include "xfs_inode_item.h"
35#include "xfs_itable.h"
36#include "xfs_ialloc.h"
37#include "xfs_alloc.h"
38#include "xfs_bmap.h"
39#include "xfs_acl.h"
40#include "xfs_attr.h"
41#include "xfs_error.h"
42#include "xfs_quota.h"
43#include "xfs_utils.h"
44#include "xfs_rtalloc.h"
45#include "xfs_trans_space.h"
46#include "xfs_log_priv.h"
47#include "xfs_filestream.h"
48#include "xfs_vnodeops.h"
49#include "xfs_trace.h"
50
51/*
52 * The maximum pathlen is 1024 bytes. Since the minimum file system
53 * blocksize is 512 bytes, we can get a max of 2 extents back from
54 * bmapi.
55 */
56#define SYMLINK_MAPS 2
57
58STATIC int
59xfs_readlink_bmap(
60 xfs_inode_t *ip,
61 char *link)
62{
63 xfs_mount_t *mp = ip->i_mount;
64 int pathlen = ip->i_d.di_size;
65 int nmaps = SYMLINK_MAPS;
66 xfs_bmbt_irec_t mval[SYMLINK_MAPS];
67 xfs_daddr_t d;
68 int byte_cnt;
69 int n;
70 xfs_buf_t *bp;
71 int error = 0;
72
73 error = xfs_bmapi_read(ip, 0, XFS_B_TO_FSB(mp, pathlen), mval, &nmaps,
74 0);
75 if (error)
76 goto out;
77
78 for (n = 0; n < nmaps; n++) {
79 d = XFS_FSB_TO_DADDR(mp, mval[n].br_startblock);
80 byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount);
81
82 bp = xfs_buf_read(mp->m_ddev_targp, d, BTOBB(byte_cnt), 0);
83 if (!bp)
84 return XFS_ERROR(ENOMEM);
85 error = bp->b_error;
86 if (error) {
87 xfs_buf_ioerror_alert(bp, __func__);
88 xfs_buf_relse(bp);
89 goto out;
90 }
91 if (pathlen < byte_cnt)
92 byte_cnt = pathlen;
93 pathlen -= byte_cnt;
94
95 memcpy(link, bp->b_addr, byte_cnt);
96 xfs_buf_relse(bp);
97 }
98
99 link[ip->i_d.di_size] = '\0';
100 error = 0;
101
102 out:
103 return error;
104}
105
106int
107xfs_readlink(
108 xfs_inode_t *ip,
109 char *link)
110{
111 xfs_mount_t *mp = ip->i_mount;
112 xfs_fsize_t pathlen;
113 int error = 0;
114
115 trace_xfs_readlink(ip);
116
117 if (XFS_FORCED_SHUTDOWN(mp))
118 return XFS_ERROR(EIO);
119
120 xfs_ilock(ip, XFS_ILOCK_SHARED);
121
122 pathlen = ip->i_d.di_size;
123 if (!pathlen)
124 goto out;
125
126 if (pathlen < 0 || pathlen > MAXPATHLEN) {
127 xfs_alert(mp, "%s: inode (%llu) bad symlink length (%lld)",
128 __func__, (unsigned long long) ip->i_ino,
129 (long long) pathlen);
130 ASSERT(0);
131 error = XFS_ERROR(EFSCORRUPTED);
132 goto out;
133 }
134
135
136 if (ip->i_df.if_flags & XFS_IFINLINE) {
137 memcpy(link, ip->i_df.if_u1.if_data, pathlen);
138 link[pathlen] = '\0';
139 } else {
140 error = xfs_readlink_bmap(ip, link);
141 }
142
143 out:
144 xfs_iunlock(ip, XFS_ILOCK_SHARED);
145 return error;
146}
147
148/*
149 * Flags for xfs_free_eofblocks
150 */
151#define XFS_FREE_EOF_TRYLOCK (1<<0)
152
153/*
154 * This is called by xfs_inactive to free any blocks beyond eof
155 * when the link count isn't zero and by xfs_dm_punch_hole() when
156 * punching a hole to EOF.
157 */
158STATIC int
159xfs_free_eofblocks(
160 xfs_mount_t *mp,
161 xfs_inode_t *ip,
162 int flags)
163{
164 xfs_trans_t *tp;
165 int error;
166 xfs_fileoff_t end_fsb;
167 xfs_fileoff_t last_fsb;
168 xfs_filblks_t map_len;
169 int nimaps;
170 xfs_bmbt_irec_t imap;
171
172 /*
173 * Figure out if there are any blocks beyond the end
174 * of the file. If not, then there is nothing to do.
175 */
176 end_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_ISIZE(ip));
177 last_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_MAXIOFFSET(mp));
178 if (last_fsb <= end_fsb)
179 return 0;
180 map_len = last_fsb - end_fsb;
181
182 nimaps = 1;
183 xfs_ilock(ip, XFS_ILOCK_SHARED);
184 error = xfs_bmapi_read(ip, end_fsb, map_len, &imap, &nimaps, 0);
185 xfs_iunlock(ip, XFS_ILOCK_SHARED);
186
187 if (!error && (nimaps != 0) &&
188 (imap.br_startblock != HOLESTARTBLOCK ||
189 ip->i_delayed_blks)) {
190 /*
191 * Attach the dquots to the inode up front.
192 */
193 error = xfs_qm_dqattach(ip, 0);
194 if (error)
195 return error;
196
197 /*
198 * There are blocks after the end of file.
199 * Free them up now by truncating the file to
200 * its current size.
201 */
202 tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
203
204 if (flags & XFS_FREE_EOF_TRYLOCK) {
205 if (!xfs_ilock_nowait(ip, XFS_IOLOCK_EXCL)) {
206 xfs_trans_cancel(tp, 0);
207 return 0;
208 }
209 } else {
210 xfs_ilock(ip, XFS_IOLOCK_EXCL);
211 }
212
213 error = xfs_trans_reserve(tp, 0,
214 XFS_ITRUNCATE_LOG_RES(mp),
215 0, XFS_TRANS_PERM_LOG_RES,
216 XFS_ITRUNCATE_LOG_COUNT);
217 if (error) {
218 ASSERT(XFS_FORCED_SHUTDOWN(mp));
219 xfs_trans_cancel(tp, 0);
220 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
221 return error;
222 }
223
224 xfs_ilock(ip, XFS_ILOCK_EXCL);
225 xfs_trans_ijoin(tp, ip, 0);
226
227 /*
228 * Do not update the on-disk file size. If we update the
229 * on-disk file size and then the system crashes before the
230 * contents of the file are flushed to disk then the files
231 * may be full of holes (ie NULL files bug).
232 */
233 error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK,
234 XFS_ISIZE(ip));
235 if (error) {
236 /*
237 * If we get an error at this point we simply don't
238 * bother truncating the file.
239 */
240 xfs_trans_cancel(tp,
241 (XFS_TRANS_RELEASE_LOG_RES |
242 XFS_TRANS_ABORT));
243 } else {
244 error = xfs_trans_commit(tp,
245 XFS_TRANS_RELEASE_LOG_RES);
246 }
247 xfs_iunlock(ip, XFS_IOLOCK_EXCL|XFS_ILOCK_EXCL);
248 }
249 return error;
250}
251
252/*
253 * Free a symlink that has blocks associated with it.
254 */
255STATIC int
256xfs_inactive_symlink_rmt(
257 xfs_inode_t *ip,
258 xfs_trans_t **tpp)
259{
260 xfs_buf_t *bp;
261 int committed;
262 int done;
263 int error;
264 xfs_fsblock_t first_block;
265 xfs_bmap_free_t free_list;
266 int i;
267 xfs_mount_t *mp;
268 xfs_bmbt_irec_t mval[SYMLINK_MAPS];
269 int nmaps;
270 xfs_trans_t *ntp;
271 int size;
272 xfs_trans_t *tp;
273
274 tp = *tpp;
275 mp = ip->i_mount;
276 ASSERT(ip->i_d.di_size > XFS_IFORK_DSIZE(ip));
277 /*
278 * We're freeing a symlink that has some
279 * blocks allocated to it. Free the
280 * blocks here. We know that we've got
281 * either 1 or 2 extents and that we can
282 * free them all in one bunmapi call.
283 */
284 ASSERT(ip->i_d.di_nextents > 0 && ip->i_d.di_nextents <= 2);
285 if ((error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0,
286 XFS_TRANS_PERM_LOG_RES, XFS_ITRUNCATE_LOG_COUNT))) {
287 ASSERT(XFS_FORCED_SHUTDOWN(mp));
288 xfs_trans_cancel(tp, 0);
289 *tpp = NULL;
290 return error;
291 }
292 /*
293 * Lock the inode, fix the size, and join it to the transaction.
294 * Hold it so in the normal path, we still have it locked for
295 * the second transaction. In the error paths we need it
296 * held so the cancel won't rele it, see below.
297 */
298 xfs_ilock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
299 size = (int)ip->i_d.di_size;
300 ip->i_d.di_size = 0;
301 xfs_trans_ijoin(tp, ip, 0);
302 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
303 /*
304 * Find the block(s) so we can inval and unmap them.
305 */
306 done = 0;
307 xfs_bmap_init(&free_list, &first_block);
308 nmaps = ARRAY_SIZE(mval);
309 error = xfs_bmapi_read(ip, 0, XFS_B_TO_FSB(mp, size),
310 mval, &nmaps, 0);
311 if (error)
312 goto error0;
313 /*
314 * Invalidate the block(s).
315 */
316 for (i = 0; i < nmaps; i++) {
317 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp,
318 XFS_FSB_TO_DADDR(mp, mval[i].br_startblock),
319 XFS_FSB_TO_BB(mp, mval[i].br_blockcount), 0);
320 if (!bp) {
321 error = ENOMEM;
322 goto error1;
323 }
324 xfs_trans_binval(tp, bp);
325 }
326 /*
327 * Unmap the dead block(s) to the free_list.
328 */
329 if ((error = xfs_bunmapi(tp, ip, 0, size, XFS_BMAPI_METADATA, nmaps,
330 &first_block, &free_list, &done)))
331 goto error1;
332 ASSERT(done);
333 /*
334 * Commit the first transaction. This logs the EFI and the inode.
335 */
336 if ((error = xfs_bmap_finish(&tp, &free_list, &committed)))
337 goto error1;
338 /*
339 * The transaction must have been committed, since there were
340 * actually extents freed by xfs_bunmapi. See xfs_bmap_finish.
341 * The new tp has the extent freeing and EFDs.
342 */
343 ASSERT(committed);
344 /*
345 * The first xact was committed, so add the inode to the new one.
346 * Mark it dirty so it will be logged and moved forward in the log as
347 * part of every commit.
348 */
349 xfs_trans_ijoin(tp, ip, 0);
350 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
351 /*
352 * Get a new, empty transaction to return to our caller.
353 */
354 ntp = xfs_trans_dup(tp);
355 /*
356 * Commit the transaction containing extent freeing and EFDs.
357 * If we get an error on the commit here or on the reserve below,
358 * we need to unlock the inode since the new transaction doesn't
359 * have the inode attached.
360 */
361 error = xfs_trans_commit(tp, 0);
362 tp = ntp;
363 if (error) {
364 ASSERT(XFS_FORCED_SHUTDOWN(mp));
365 goto error0;
366 }
367 /*
368 * transaction commit worked ok so we can drop the extra ticket
369 * reference that we gained in xfs_trans_dup()
370 */
371 xfs_log_ticket_put(tp->t_ticket);
372
373 /*
374 * Remove the memory for extent descriptions (just bookkeeping).
375 */
376 if (ip->i_df.if_bytes)
377 xfs_idata_realloc(ip, -ip->i_df.if_bytes, XFS_DATA_FORK);
378 ASSERT(ip->i_df.if_bytes == 0);
379 /*
380 * Put an itruncate log reservation in the new transaction
381 * for our caller.
382 */
383 if ((error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0,
384 XFS_TRANS_PERM_LOG_RES, XFS_ITRUNCATE_LOG_COUNT))) {
385 ASSERT(XFS_FORCED_SHUTDOWN(mp));
386 goto error0;
387 }
388 /*
389 * Return with the inode locked but not joined to the transaction.
390 */
391 *tpp = tp;
392 return 0;
393
394 error1:
395 xfs_bmap_cancel(&free_list);
396 error0:
397 /*
398 * Have to come here with the inode locked and either
399 * (held and in the transaction) or (not in the transaction).
400 * If the inode isn't held then cancel would iput it, but
401 * that's wrong since this is inactive and the vnode ref
402 * count is 0 already.
403 * Cancel won't do anything to the inode if held, but it still
404 * needs to be locked until the cancel is done, if it was
405 * joined to the transaction.
406 */
407 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
408 xfs_iunlock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
409 *tpp = NULL;
410 return error;
411
412}
413
414STATIC int
415xfs_inactive_symlink_local(
416 xfs_inode_t *ip,
417 xfs_trans_t **tpp)
418{
419 int error;
420
421 ASSERT(ip->i_d.di_size <= XFS_IFORK_DSIZE(ip));
422 /*
423 * We're freeing a symlink which fit into
424 * the inode. Just free the memory used
425 * to hold the old symlink.
426 */
427 error = xfs_trans_reserve(*tpp, 0,
428 XFS_ITRUNCATE_LOG_RES(ip->i_mount),
429 0, XFS_TRANS_PERM_LOG_RES,
430 XFS_ITRUNCATE_LOG_COUNT);
431
432 if (error) {
433 xfs_trans_cancel(*tpp, 0);
434 *tpp = NULL;
435 return error;
436 }
437 xfs_ilock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
438
439 /*
440 * Zero length symlinks _can_ exist.
441 */
442 if (ip->i_df.if_bytes > 0) {
443 xfs_idata_realloc(ip,
444 -(ip->i_df.if_bytes),
445 XFS_DATA_FORK);
446 ASSERT(ip->i_df.if_bytes == 0);
447 }
448 return 0;
449}
450
451STATIC int
452xfs_inactive_attrs(
453 xfs_inode_t *ip,
454 xfs_trans_t **tpp)
455{
456 xfs_trans_t *tp;
457 int error;
458 xfs_mount_t *mp;
459
460 ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
461 tp = *tpp;
462 mp = ip->i_mount;
463 ASSERT(ip->i_d.di_forkoff != 0);
464 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
465 xfs_iunlock(ip, XFS_ILOCK_EXCL);
466 if (error)
467 goto error_unlock;
468
469 error = xfs_attr_inactive(ip);
470 if (error)
471 goto error_unlock;
472
473 tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
474 error = xfs_trans_reserve(tp, 0,
475 XFS_IFREE_LOG_RES(mp),
476 0, XFS_TRANS_PERM_LOG_RES,
477 XFS_INACTIVE_LOG_COUNT);
478 if (error)
479 goto error_cancel;
480
481 xfs_ilock(ip, XFS_ILOCK_EXCL);
482 xfs_trans_ijoin(tp, ip, 0);
483 xfs_idestroy_fork(ip, XFS_ATTR_FORK);
484
485 ASSERT(ip->i_d.di_anextents == 0);
486
487 *tpp = tp;
488 return 0;
489
490error_cancel:
491 ASSERT(XFS_FORCED_SHUTDOWN(mp));
492 xfs_trans_cancel(tp, 0);
493error_unlock:
494 *tpp = NULL;
495 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
496 return error;
497}
498
499int
500xfs_release(
501 xfs_inode_t *ip)
502{
503 xfs_mount_t *mp = ip->i_mount;
504 int error;
505
506 if (!S_ISREG(ip->i_d.di_mode) || (ip->i_d.di_mode == 0))
507 return 0;
508
509 /* If this is a read-only mount, don't do this (would generate I/O) */
510 if (mp->m_flags & XFS_MOUNT_RDONLY)
511 return 0;
512
513 if (!XFS_FORCED_SHUTDOWN(mp)) {
514 int truncated;
515
516 /*
517 * If we are using filestreams, and we have an unlinked
518 * file that we are processing the last close on, then nothing
519 * will be able to reopen and write to this file. Purge this
520 * inode from the filestreams cache so that it doesn't delay
521 * teardown of the inode.
522 */
523 if ((ip->i_d.di_nlink == 0) && xfs_inode_is_filestream(ip))
524 xfs_filestream_deassociate(ip);
525
526 /*
527 * If we previously truncated this file and removed old data
528 * in the process, we want to initiate "early" writeout on
529 * the last close. This is an attempt to combat the notorious
530 * NULL files problem which is particularly noticeable from a
531 * truncate down, buffered (re-)write (delalloc), followed by
532 * a crash. What we are effectively doing here is
533 * significantly reducing the time window where we'd otherwise
534 * be exposed to that problem.
535 */
536 truncated = xfs_iflags_test_and_clear(ip, XFS_ITRUNCATED);
537 if (truncated) {
538 xfs_iflags_clear(ip, XFS_IDIRTY_RELEASE);
539 if (VN_DIRTY(VFS_I(ip)) && ip->i_delayed_blks > 0)
540 xfs_flush_pages(ip, 0, -1, XBF_ASYNC, FI_NONE);
541 }
542 }
543
544 if (ip->i_d.di_nlink == 0)
545 return 0;
546
547 if ((S_ISREG(ip->i_d.di_mode) &&
548 (VFS_I(ip)->i_size > 0 ||
549 (VN_CACHED(VFS_I(ip)) > 0 || ip->i_delayed_blks > 0)) &&
550 (ip->i_df.if_flags & XFS_IFEXTENTS)) &&
551 (!(ip->i_d.di_flags & (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)))) {
552
553 /*
554 * If we can't get the iolock just skip truncating the blocks
555 * past EOF because we could deadlock with the mmap_sem
556 * otherwise. We'll get another chance to drop them once the
557 * last reference to the inode is dropped, so we'll never leak
558 * blocks permanently.
559 *
560 * Further, check if the inode is being opened, written and
561 * closed frequently and we have delayed allocation blocks
562 * outstanding (e.g. streaming writes from the NFS server),
563 * truncating the blocks past EOF will cause fragmentation to
564 * occur.
565 *
566 * In this case don't do the truncation, either, but we have to
567 * be careful how we detect this case. Blocks beyond EOF show
568 * up as i_delayed_blks even when the inode is clean, so we
569 * need to truncate them away first before checking for a dirty
570 * release. Hence on the first dirty close we will still remove
571 * the speculative allocation, but after that we will leave it
572 * in place.
573 */
574 if (xfs_iflags_test(ip, XFS_IDIRTY_RELEASE))
575 return 0;
576
577 error = xfs_free_eofblocks(mp, ip,
578 XFS_FREE_EOF_TRYLOCK);
579 if (error)
580 return error;
581
582 /* delalloc blocks after truncation means it really is dirty */
583 if (ip->i_delayed_blks)
584 xfs_iflags_set(ip, XFS_IDIRTY_RELEASE);
585 }
586 return 0;
587}
588
589/*
590 * xfs_inactive
591 *
592 * This is called when the vnode reference count for the vnode
593 * goes to zero. If the file has been unlinked, then it must
594 * now be truncated. Also, we clear all of the read-ahead state
595 * kept for the inode here since the file is now closed.
596 */
597int
598xfs_inactive(
599 xfs_inode_t *ip)
600{
601 xfs_bmap_free_t free_list;
602 xfs_fsblock_t first_block;
603 int committed;
604 xfs_trans_t *tp;
605 xfs_mount_t *mp;
606 int error;
607 int truncate;
608
609 /*
610 * If the inode is already free, then there can be nothing
611 * to clean up here.
612 */
613 if (ip->i_d.di_mode == 0 || is_bad_inode(VFS_I(ip))) {
614 ASSERT(ip->i_df.if_real_bytes == 0);
615 ASSERT(ip->i_df.if_broot_bytes == 0);
616 return VN_INACTIVE_CACHE;
617 }
618
619 /*
620 * Only do a truncate if it's a regular file with
621 * some actual space in it. It's OK to look at the
622 * inode's fields without the lock because we're the
623 * only one with a reference to the inode.
624 */
625 truncate = ((ip->i_d.di_nlink == 0) &&
626 ((ip->i_d.di_size != 0) || XFS_ISIZE(ip) != 0 ||
627 (ip->i_d.di_nextents > 0) || (ip->i_delayed_blks > 0)) &&
628 S_ISREG(ip->i_d.di_mode));
629
630 mp = ip->i_mount;
631
632 error = 0;
633
634 /* If this is a read-only mount, don't do this (would generate I/O) */
635 if (mp->m_flags & XFS_MOUNT_RDONLY)
636 goto out;
637
638 if (ip->i_d.di_nlink != 0) {
639 if ((S_ISREG(ip->i_d.di_mode) &&
640 (VFS_I(ip)->i_size > 0 ||
641 (VN_CACHED(VFS_I(ip)) > 0 || ip->i_delayed_blks > 0)) &&
642 (ip->i_df.if_flags & XFS_IFEXTENTS) &&
643 (!(ip->i_d.di_flags &
644 (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)) ||
645 ip->i_delayed_blks != 0))) {
646 error = xfs_free_eofblocks(mp, ip, 0);
647 if (error)
648 return VN_INACTIVE_CACHE;
649 }
650 goto out;
651 }
652
653 ASSERT(ip->i_d.di_nlink == 0);
654
655 error = xfs_qm_dqattach(ip, 0);
656 if (error)
657 return VN_INACTIVE_CACHE;
658
659 tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
660 if (truncate) {
661 xfs_ilock(ip, XFS_IOLOCK_EXCL);
662
663 error = xfs_trans_reserve(tp, 0,
664 XFS_ITRUNCATE_LOG_RES(mp),
665 0, XFS_TRANS_PERM_LOG_RES,
666 XFS_ITRUNCATE_LOG_COUNT);
667 if (error) {
668 /* Don't call itruncate_cleanup */
669 ASSERT(XFS_FORCED_SHUTDOWN(mp));
670 xfs_trans_cancel(tp, 0);
671 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
672 return VN_INACTIVE_CACHE;
673 }
674
675 xfs_ilock(ip, XFS_ILOCK_EXCL);
676 xfs_trans_ijoin(tp, ip, 0);
677
678 ip->i_d.di_size = 0;
679 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
680
681 error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK, 0);
682 if (error) {
683 xfs_trans_cancel(tp,
684 XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
685 xfs_iunlock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
686 return VN_INACTIVE_CACHE;
687 }
688
689 ASSERT(ip->i_d.di_nextents == 0);
690 } else if (S_ISLNK(ip->i_d.di_mode)) {
691
692 /*
693 * If we get an error while cleaning up a
694 * symlink we bail out.
695 */
696 error = (ip->i_d.di_size > XFS_IFORK_DSIZE(ip)) ?
697 xfs_inactive_symlink_rmt(ip, &tp) :
698 xfs_inactive_symlink_local(ip, &tp);
699
700 if (error) {
701 ASSERT(tp == NULL);
702 return VN_INACTIVE_CACHE;
703 }
704
705 xfs_trans_ijoin(tp, ip, 0);
706 } else {
707 error = xfs_trans_reserve(tp, 0,
708 XFS_IFREE_LOG_RES(mp),
709 0, XFS_TRANS_PERM_LOG_RES,
710 XFS_INACTIVE_LOG_COUNT);
711 if (error) {
712 ASSERT(XFS_FORCED_SHUTDOWN(mp));
713 xfs_trans_cancel(tp, 0);
714 return VN_INACTIVE_CACHE;
715 }
716
717 xfs_ilock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
718 xfs_trans_ijoin(tp, ip, 0);
719 }
720
721 /*
722 * If there are attributes associated with the file
723 * then blow them away now. The code calls a routine
724 * that recursively deconstructs the attribute fork.
725 * We need to just commit the current transaction
726 * because we can't use it for xfs_attr_inactive().
727 */
728 if (ip->i_d.di_anextents > 0) {
729 error = xfs_inactive_attrs(ip, &tp);
730 /*
731 * If we got an error, the transaction is already
732 * cancelled, and the inode is unlocked. Just get out.
733 */
734 if (error)
735 return VN_INACTIVE_CACHE;
736 } else if (ip->i_afp) {
737 xfs_idestroy_fork(ip, XFS_ATTR_FORK);
738 }
739
740 /*
741 * Free the inode.
742 */
743 xfs_bmap_init(&free_list, &first_block);
744 error = xfs_ifree(tp, ip, &free_list);
745 if (error) {
746 /*
747 * If we fail to free the inode, shut down. The cancel
748 * might do that, we need to make sure. Otherwise the
749 * inode might be lost for a long time or forever.
750 */
751 if (!XFS_FORCED_SHUTDOWN(mp)) {
752 xfs_notice(mp, "%s: xfs_ifree returned error %d",
753 __func__, error);
754 xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
755 }
756 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES|XFS_TRANS_ABORT);
757 } else {
758 /*
759 * Credit the quota account(s). The inode is gone.
760 */
761 xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_ICOUNT, -1);
762
763 /*
764 * Just ignore errors at this point. There is nothing we can
765 * do except to try to keep going. Make sure it's not a silent
766 * error.
767 */
768 error = xfs_bmap_finish(&tp, &free_list, &committed);
769 if (error)
770 xfs_notice(mp, "%s: xfs_bmap_finish returned error %d",
771 __func__, error);
772 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
773 if (error)
774 xfs_notice(mp, "%s: xfs_trans_commit returned error %d",
775 __func__, error);
776 }
777
778 /*
779 * Release the dquots held by inode, if any.
780 */
781 xfs_qm_dqdetach(ip);
782 xfs_iunlock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
783
784 out:
785 return VN_INACTIVE_CACHE;
786}
787
788/*
789 * Lookups up an inode from "name". If ci_name is not NULL, then a CI match
790 * is allowed, otherwise it has to be an exact match. If a CI match is found,
791 * ci_name->name will point to a the actual name (caller must free) or
792 * will be set to NULL if an exact match is found.
793 */
794int
795xfs_lookup(
796 xfs_inode_t *dp,
797 struct xfs_name *name,
798 xfs_inode_t **ipp,
799 struct xfs_name *ci_name)
800{
801 xfs_ino_t inum;
802 int error;
803 uint lock_mode;
804
805 trace_xfs_lookup(dp, name);
806
807 if (XFS_FORCED_SHUTDOWN(dp->i_mount))
808 return XFS_ERROR(EIO);
809
810 lock_mode = xfs_ilock_map_shared(dp);
811 error = xfs_dir_lookup(NULL, dp, name, &inum, ci_name);
812 xfs_iunlock_map_shared(dp, lock_mode);
813
814 if (error)
815 goto out;
816
817 error = xfs_iget(dp->i_mount, NULL, inum, 0, 0, ipp);
818 if (error)
819 goto out_free_name;
820
821 return 0;
822
823out_free_name:
824 if (ci_name)
825 kmem_free(ci_name->name);
826out:
827 *ipp = NULL;
828 return error;
829}
830
831int
832xfs_create(
833 xfs_inode_t *dp,
834 struct xfs_name *name,
835 umode_t mode,
836 xfs_dev_t rdev,
837 xfs_inode_t **ipp)
838{
839 int is_dir = S_ISDIR(mode);
840 struct xfs_mount *mp = dp->i_mount;
841 struct xfs_inode *ip = NULL;
842 struct xfs_trans *tp = NULL;
843 int error;
844 xfs_bmap_free_t free_list;
845 xfs_fsblock_t first_block;
846 boolean_t unlock_dp_on_error = B_FALSE;
847 uint cancel_flags;
848 int committed;
849 prid_t prid;
850 struct xfs_dquot *udqp = NULL;
851 struct xfs_dquot *gdqp = NULL;
852 uint resblks;
853 uint log_res;
854 uint log_count;
855
856 trace_xfs_create(dp, name);
857
858 if (XFS_FORCED_SHUTDOWN(mp))
859 return XFS_ERROR(EIO);
860
861 if (dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
862 prid = xfs_get_projid(dp);
863 else
864 prid = XFS_PROJID_DEFAULT;
865
866 /*
867 * Make sure that we have allocated dquot(s) on disk.
868 */
869 error = xfs_qm_vop_dqalloc(dp, current_fsuid(), current_fsgid(), prid,
870 XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT, &udqp, &gdqp);
871 if (error)
872 return error;
873
874 if (is_dir) {
875 rdev = 0;
876 resblks = XFS_MKDIR_SPACE_RES(mp, name->len);
877 log_res = XFS_MKDIR_LOG_RES(mp);
878 log_count = XFS_MKDIR_LOG_COUNT;
879 tp = xfs_trans_alloc(mp, XFS_TRANS_MKDIR);
880 } else {
881 resblks = XFS_CREATE_SPACE_RES(mp, name->len);
882 log_res = XFS_CREATE_LOG_RES(mp);
883 log_count = XFS_CREATE_LOG_COUNT;
884 tp = xfs_trans_alloc(mp, XFS_TRANS_CREATE);
885 }
886
887 cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
888
889 /*
890 * Initially assume that the file does not exist and
891 * reserve the resources for that case. If that is not
892 * the case we'll drop the one we have and get a more
893 * appropriate transaction later.
894 */
895 error = xfs_trans_reserve(tp, resblks, log_res, 0,
896 XFS_TRANS_PERM_LOG_RES, log_count);
897 if (error == ENOSPC) {
898 /* flush outstanding delalloc blocks and retry */
899 xfs_flush_inodes(dp);
900 error = xfs_trans_reserve(tp, resblks, log_res, 0,
901 XFS_TRANS_PERM_LOG_RES, log_count);
902 }
903 if (error == ENOSPC) {
904 /* No space at all so try a "no-allocation" reservation */
905 resblks = 0;
906 error = xfs_trans_reserve(tp, 0, log_res, 0,
907 XFS_TRANS_PERM_LOG_RES, log_count);
908 }
909 if (error) {
910 cancel_flags = 0;
911 goto out_trans_cancel;
912 }
913
914 xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
915 unlock_dp_on_error = B_TRUE;
916
917 xfs_bmap_init(&free_list, &first_block);
918
919 /*
920 * Reserve disk quota and the inode.
921 */
922 error = xfs_trans_reserve_quota(tp, mp, udqp, gdqp, resblks, 1, 0);
923 if (error)
924 goto out_trans_cancel;
925
926 error = xfs_dir_canenter(tp, dp, name, resblks);
927 if (error)
928 goto out_trans_cancel;
929
930 /*
931 * A newly created regular or special file just has one directory
932 * entry pointing to them, but a directory also the "." entry
933 * pointing to itself.
934 */
935 error = xfs_dir_ialloc(&tp, dp, mode, is_dir ? 2 : 1, rdev,
936 prid, resblks > 0, &ip, &committed);
937 if (error) {
938 if (error == ENOSPC)
939 goto out_trans_cancel;
940 goto out_trans_abort;
941 }
942
943 /*
944 * Now we join the directory inode to the transaction. We do not do it
945 * earlier because xfs_dir_ialloc might commit the previous transaction
946 * (and release all the locks). An error from here on will result in
947 * the transaction cancel unlocking dp so don't do it explicitly in the
948 * error path.
949 */
950 xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
951 unlock_dp_on_error = B_FALSE;
952
953 error = xfs_dir_createname(tp, dp, name, ip->i_ino,
954 &first_block, &free_list, resblks ?
955 resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
956 if (error) {
957 ASSERT(error != ENOSPC);
958 goto out_trans_abort;
959 }
960 xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
961 xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
962
963 if (is_dir) {
964 error = xfs_dir_init(tp, ip, dp);
965 if (error)
966 goto out_bmap_cancel;
967
968 error = xfs_bumplink(tp, dp);
969 if (error)
970 goto out_bmap_cancel;
971 }
972
973 /*
974 * If this is a synchronous mount, make sure that the
975 * create transaction goes to disk before returning to
976 * the user.
977 */
978 if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
979 xfs_trans_set_sync(tp);
980
981 /*
982 * Attach the dquot(s) to the inodes and modify them incore.
983 * These ids of the inode couldn't have changed since the new
984 * inode has been locked ever since it was created.
985 */
986 xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp);
987
988 error = xfs_bmap_finish(&tp, &free_list, &committed);
989 if (error)
990 goto out_bmap_cancel;
991
992 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
993 if (error)
994 goto out_release_inode;
995
996 xfs_qm_dqrele(udqp);
997 xfs_qm_dqrele(gdqp);
998
999 *ipp = ip;
1000 return 0;
1001
1002 out_bmap_cancel:
1003 xfs_bmap_cancel(&free_list);
1004 out_trans_abort:
1005 cancel_flags |= XFS_TRANS_ABORT;
1006 out_trans_cancel:
1007 xfs_trans_cancel(tp, cancel_flags);
1008 out_release_inode:
1009 /*
1010 * Wait until after the current transaction is aborted to
1011 * release the inode. This prevents recursive transactions
1012 * and deadlocks from xfs_inactive.
1013 */
1014 if (ip)
1015 IRELE(ip);
1016
1017 xfs_qm_dqrele(udqp);
1018 xfs_qm_dqrele(gdqp);
1019
1020 if (unlock_dp_on_error)
1021 xfs_iunlock(dp, XFS_ILOCK_EXCL);
1022 return error;
1023}
1024
1025#ifdef DEBUG
1026int xfs_locked_n;
1027int xfs_small_retries;
1028int xfs_middle_retries;
1029int xfs_lots_retries;
1030int xfs_lock_delays;
1031#endif
1032
1033/*
1034 * Bump the subclass so xfs_lock_inodes() acquires each lock with
1035 * a different value
1036 */
1037static inline int
1038xfs_lock_inumorder(int lock_mode, int subclass)
1039{
1040 if (lock_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL))
1041 lock_mode |= (subclass + XFS_LOCK_INUMORDER) << XFS_IOLOCK_SHIFT;
1042 if (lock_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL))
1043 lock_mode |= (subclass + XFS_LOCK_INUMORDER) << XFS_ILOCK_SHIFT;
1044
1045 return lock_mode;
1046}
1047
1048/*
1049 * The following routine will lock n inodes in exclusive mode.
1050 * We assume the caller calls us with the inodes in i_ino order.
1051 *
1052 * We need to detect deadlock where an inode that we lock
1053 * is in the AIL and we start waiting for another inode that is locked
1054 * by a thread in a long running transaction (such as truncate). This can
1055 * result in deadlock since the long running trans might need to wait
1056 * for the inode we just locked in order to push the tail and free space
1057 * in the log.
1058 */
1059void
1060xfs_lock_inodes(
1061 xfs_inode_t **ips,
1062 int inodes,
1063 uint lock_mode)
1064{
1065 int attempts = 0, i, j, try_lock;
1066 xfs_log_item_t *lp;
1067
1068 ASSERT(ips && (inodes >= 2)); /* we need at least two */
1069
1070 try_lock = 0;
1071 i = 0;
1072
1073again:
1074 for (; i < inodes; i++) {
1075 ASSERT(ips[i]);
1076
1077 if (i && (ips[i] == ips[i-1])) /* Already locked */
1078 continue;
1079
1080 /*
1081 * If try_lock is not set yet, make sure all locked inodes
1082 * are not in the AIL.
1083 * If any are, set try_lock to be used later.
1084 */
1085
1086 if (!try_lock) {
1087 for (j = (i - 1); j >= 0 && !try_lock; j--) {
1088 lp = (xfs_log_item_t *)ips[j]->i_itemp;
1089 if (lp && (lp->li_flags & XFS_LI_IN_AIL)) {
1090 try_lock++;
1091 }
1092 }
1093 }
1094
1095 /*
1096 * If any of the previous locks we have locked is in the AIL,
1097 * we must TRY to get the second and subsequent locks. If
1098 * we can't get any, we must release all we have
1099 * and try again.
1100 */
1101
1102 if (try_lock) {
1103 /* try_lock must be 0 if i is 0. */
1104 /*
1105 * try_lock means we have an inode locked
1106 * that is in the AIL.
1107 */
1108 ASSERT(i != 0);
1109 if (!xfs_ilock_nowait(ips[i], xfs_lock_inumorder(lock_mode, i))) {
1110 attempts++;
1111
1112 /*
1113 * Unlock all previous guys and try again.
1114 * xfs_iunlock will try to push the tail
1115 * if the inode is in the AIL.
1116 */
1117
1118 for(j = i - 1; j >= 0; j--) {
1119
1120 /*
1121 * Check to see if we've already
1122 * unlocked this one.
1123 * Not the first one going back,
1124 * and the inode ptr is the same.
1125 */
1126 if ((j != (i - 1)) && ips[j] ==
1127 ips[j+1])
1128 continue;
1129
1130 xfs_iunlock(ips[j], lock_mode);
1131 }
1132
1133 if ((attempts % 5) == 0) {
1134 delay(1); /* Don't just spin the CPU */
1135#ifdef DEBUG
1136 xfs_lock_delays++;
1137#endif
1138 }
1139 i = 0;
1140 try_lock = 0;
1141 goto again;
1142 }
1143 } else {
1144 xfs_ilock(ips[i], xfs_lock_inumorder(lock_mode, i));
1145 }
1146 }
1147
1148#ifdef DEBUG
1149 if (attempts) {
1150 if (attempts < 5) xfs_small_retries++;
1151 else if (attempts < 100) xfs_middle_retries++;
1152 else xfs_lots_retries++;
1153 } else {
1154 xfs_locked_n++;
1155 }
1156#endif
1157}
1158
1159/*
1160 * xfs_lock_two_inodes() can only be used to lock one type of lock
1161 * at a time - the iolock or the ilock, but not both at once. If
1162 * we lock both at once, lockdep will report false positives saying
1163 * we have violated locking orders.
1164 */
1165void
1166xfs_lock_two_inodes(
1167 xfs_inode_t *ip0,
1168 xfs_inode_t *ip1,
1169 uint lock_mode)
1170{
1171 xfs_inode_t *temp;
1172 int attempts = 0;
1173 xfs_log_item_t *lp;
1174
1175 if (lock_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL))
1176 ASSERT((lock_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)) == 0);
1177 ASSERT(ip0->i_ino != ip1->i_ino);
1178
1179 if (ip0->i_ino > ip1->i_ino) {
1180 temp = ip0;
1181 ip0 = ip1;
1182 ip1 = temp;
1183 }
1184
1185 again:
1186 xfs_ilock(ip0, xfs_lock_inumorder(lock_mode, 0));
1187
1188 /*
1189 * If the first lock we have locked is in the AIL, we must TRY to get
1190 * the second lock. If we can't get it, we must release the first one
1191 * and try again.
1192 */
1193 lp = (xfs_log_item_t *)ip0->i_itemp;
1194 if (lp && (lp->li_flags & XFS_LI_IN_AIL)) {
1195 if (!xfs_ilock_nowait(ip1, xfs_lock_inumorder(lock_mode, 1))) {
1196 xfs_iunlock(ip0, lock_mode);
1197 if ((++attempts % 5) == 0)
1198 delay(1); /* Don't just spin the CPU */
1199 goto again;
1200 }
1201 } else {
1202 xfs_ilock(ip1, xfs_lock_inumorder(lock_mode, 1));
1203 }
1204}
1205
1206int
1207xfs_remove(
1208 xfs_inode_t *dp,
1209 struct xfs_name *name,
1210 xfs_inode_t *ip)
1211{
1212 xfs_mount_t *mp = dp->i_mount;
1213 xfs_trans_t *tp = NULL;
1214 int is_dir = S_ISDIR(ip->i_d.di_mode);
1215 int error = 0;
1216 xfs_bmap_free_t free_list;
1217 xfs_fsblock_t first_block;
1218 int cancel_flags;
1219 int committed;
1220 int link_zero;
1221 uint resblks;
1222 uint log_count;
1223
1224 trace_xfs_remove(dp, name);
1225
1226 if (XFS_FORCED_SHUTDOWN(mp))
1227 return XFS_ERROR(EIO);
1228
1229 error = xfs_qm_dqattach(dp, 0);
1230 if (error)
1231 goto std_return;
1232
1233 error = xfs_qm_dqattach(ip, 0);
1234 if (error)
1235 goto std_return;
1236
1237 if (is_dir) {
1238 tp = xfs_trans_alloc(mp, XFS_TRANS_RMDIR);
1239 log_count = XFS_DEFAULT_LOG_COUNT;
1240 } else {
1241 tp = xfs_trans_alloc(mp, XFS_TRANS_REMOVE);
1242 log_count = XFS_REMOVE_LOG_COUNT;
1243 }
1244 cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
1245
1246 /*
1247 * We try to get the real space reservation first,
1248 * allowing for directory btree deletion(s) implying
1249 * possible bmap insert(s). If we can't get the space
1250 * reservation then we use 0 instead, and avoid the bmap
1251 * btree insert(s) in the directory code by, if the bmap
1252 * insert tries to happen, instead trimming the LAST
1253 * block from the directory.
1254 */
1255 resblks = XFS_REMOVE_SPACE_RES(mp);
1256 error = xfs_trans_reserve(tp, resblks, XFS_REMOVE_LOG_RES(mp), 0,
1257 XFS_TRANS_PERM_LOG_RES, log_count);
1258 if (error == ENOSPC) {
1259 resblks = 0;
1260 error = xfs_trans_reserve(tp, 0, XFS_REMOVE_LOG_RES(mp), 0,
1261 XFS_TRANS_PERM_LOG_RES, log_count);
1262 }
1263 if (error) {
1264 ASSERT(error != ENOSPC);
1265 cancel_flags = 0;
1266 goto out_trans_cancel;
1267 }
1268
1269 xfs_lock_two_inodes(dp, ip, XFS_ILOCK_EXCL);
1270
1271 xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
1272 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
1273
1274 /*
1275 * If we're removing a directory perform some additional validation.
1276 */
1277 if (is_dir) {
1278 ASSERT(ip->i_d.di_nlink >= 2);
1279 if (ip->i_d.di_nlink != 2) {
1280 error = XFS_ERROR(ENOTEMPTY);
1281 goto out_trans_cancel;
1282 }
1283 if (!xfs_dir_isempty(ip)) {
1284 error = XFS_ERROR(ENOTEMPTY);
1285 goto out_trans_cancel;
1286 }
1287 }
1288
1289 xfs_bmap_init(&free_list, &first_block);
1290 error = xfs_dir_removename(tp, dp, name, ip->i_ino,
1291 &first_block, &free_list, resblks);
1292 if (error) {
1293 ASSERT(error != ENOENT);
1294 goto out_bmap_cancel;
1295 }
1296 xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1297
1298 if (is_dir) {
1299 /*
1300 * Drop the link from ip's "..".
1301 */
1302 error = xfs_droplink(tp, dp);
1303 if (error)
1304 goto out_bmap_cancel;
1305
1306 /*
1307 * Drop the "." link from ip to self.
1308 */
1309 error = xfs_droplink(tp, ip);
1310 if (error)
1311 goto out_bmap_cancel;
1312 } else {
1313 /*
1314 * When removing a non-directory we need to log the parent
1315 * inode here. For a directory this is done implicitly
1316 * by the xfs_droplink call for the ".." entry.
1317 */
1318 xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
1319 }
1320
1321 /*
1322 * Drop the link from dp to ip.
1323 */
1324 error = xfs_droplink(tp, ip);
1325 if (error)
1326 goto out_bmap_cancel;
1327
1328 /*
1329 * Determine if this is the last link while
1330 * we are in the transaction.
1331 */
1332 link_zero = (ip->i_d.di_nlink == 0);
1333
1334 /*
1335 * If this is a synchronous mount, make sure that the
1336 * remove transaction goes to disk before returning to
1337 * the user.
1338 */
1339 if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
1340 xfs_trans_set_sync(tp);
1341
1342 error = xfs_bmap_finish(&tp, &free_list, &committed);
1343 if (error)
1344 goto out_bmap_cancel;
1345
1346 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
1347 if (error)
1348 goto std_return;
1349
1350 /*
1351 * If we are using filestreams, kill the stream association.
1352 * If the file is still open it may get a new one but that
1353 * will get killed on last close in xfs_close() so we don't
1354 * have to worry about that.
1355 */
1356 if (!is_dir && link_zero && xfs_inode_is_filestream(ip))
1357 xfs_filestream_deassociate(ip);
1358
1359 return 0;
1360
1361 out_bmap_cancel:
1362 xfs_bmap_cancel(&free_list);
1363 cancel_flags |= XFS_TRANS_ABORT;
1364 out_trans_cancel:
1365 xfs_trans_cancel(tp, cancel_flags);
1366 std_return:
1367 return error;
1368}
1369
1370int
1371xfs_link(
1372 xfs_inode_t *tdp,
1373 xfs_inode_t *sip,
1374 struct xfs_name *target_name)
1375{
1376 xfs_mount_t *mp = tdp->i_mount;
1377 xfs_trans_t *tp;
1378 int error;
1379 xfs_bmap_free_t free_list;
1380 xfs_fsblock_t first_block;
1381 int cancel_flags;
1382 int committed;
1383 int resblks;
1384
1385 trace_xfs_link(tdp, target_name);
1386
1387 ASSERT(!S_ISDIR(sip->i_d.di_mode));
1388
1389 if (XFS_FORCED_SHUTDOWN(mp))
1390 return XFS_ERROR(EIO);
1391
1392 error = xfs_qm_dqattach(sip, 0);
1393 if (error)
1394 goto std_return;
1395
1396 error = xfs_qm_dqattach(tdp, 0);
1397 if (error)
1398 goto std_return;
1399
1400 tp = xfs_trans_alloc(mp, XFS_TRANS_LINK);
1401 cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
1402 resblks = XFS_LINK_SPACE_RES(mp, target_name->len);
1403 error = xfs_trans_reserve(tp, resblks, XFS_LINK_LOG_RES(mp), 0,
1404 XFS_TRANS_PERM_LOG_RES, XFS_LINK_LOG_COUNT);
1405 if (error == ENOSPC) {
1406 resblks = 0;
1407 error = xfs_trans_reserve(tp, 0, XFS_LINK_LOG_RES(mp), 0,
1408 XFS_TRANS_PERM_LOG_RES, XFS_LINK_LOG_COUNT);
1409 }
1410 if (error) {
1411 cancel_flags = 0;
1412 goto error_return;
1413 }
1414
1415 xfs_lock_two_inodes(sip, tdp, XFS_ILOCK_EXCL);
1416
1417 xfs_trans_ijoin(tp, sip, XFS_ILOCK_EXCL);
1418 xfs_trans_ijoin(tp, tdp, XFS_ILOCK_EXCL);
1419
1420 /*
1421 * If we are using project inheritance, we only allow hard link
1422 * creation in our tree when the project IDs are the same; else
1423 * the tree quota mechanism could be circumvented.
1424 */
1425 if (unlikely((tdp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
1426 (xfs_get_projid(tdp) != xfs_get_projid(sip)))) {
1427 error = XFS_ERROR(EXDEV);
1428 goto error_return;
1429 }
1430
1431 error = xfs_dir_canenter(tp, tdp, target_name, resblks);
1432 if (error)
1433 goto error_return;
1434
1435 xfs_bmap_init(&free_list, &first_block);
1436
1437 error = xfs_dir_createname(tp, tdp, target_name, sip->i_ino,
1438 &first_block, &free_list, resblks);
1439 if (error)
1440 goto abort_return;
1441 xfs_trans_ichgtime(tp, tdp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1442 xfs_trans_log_inode(tp, tdp, XFS_ILOG_CORE);
1443
1444 error = xfs_bumplink(tp, sip);
1445 if (error)
1446 goto abort_return;
1447
1448 /*
1449 * If this is a synchronous mount, make sure that the
1450 * link transaction goes to disk before returning to
1451 * the user.
1452 */
1453 if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
1454 xfs_trans_set_sync(tp);
1455 }
1456
1457 error = xfs_bmap_finish (&tp, &free_list, &committed);
1458 if (error) {
1459 xfs_bmap_cancel(&free_list);
1460 goto abort_return;
1461 }
1462
1463 return xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
1464
1465 abort_return:
1466 cancel_flags |= XFS_TRANS_ABORT;
1467 error_return:
1468 xfs_trans_cancel(tp, cancel_flags);
1469 std_return:
1470 return error;
1471}
1472
1473int
1474xfs_symlink(
1475 xfs_inode_t *dp,
1476 struct xfs_name *link_name,
1477 const char *target_path,
1478 umode_t mode,
1479 xfs_inode_t **ipp)
1480{
1481 xfs_mount_t *mp = dp->i_mount;
1482 xfs_trans_t *tp;
1483 xfs_inode_t *ip;
1484 int error;
1485 int pathlen;
1486 xfs_bmap_free_t free_list;
1487 xfs_fsblock_t first_block;
1488 boolean_t unlock_dp_on_error = B_FALSE;
1489 uint cancel_flags;
1490 int committed;
1491 xfs_fileoff_t first_fsb;
1492 xfs_filblks_t fs_blocks;
1493 int nmaps;
1494 xfs_bmbt_irec_t mval[SYMLINK_MAPS];
1495 xfs_daddr_t d;
1496 const char *cur_chunk;
1497 int byte_cnt;
1498 int n;
1499 xfs_buf_t *bp;
1500 prid_t prid;
1501 struct xfs_dquot *udqp, *gdqp;
1502 uint resblks;
1503
1504 *ipp = NULL;
1505 error = 0;
1506 ip = NULL;
1507 tp = NULL;
1508
1509 trace_xfs_symlink(dp, link_name);
1510
1511 if (XFS_FORCED_SHUTDOWN(mp))
1512 return XFS_ERROR(EIO);
1513
1514 /*
1515 * Check component lengths of the target path name.
1516 */
1517 pathlen = strlen(target_path);
1518 if (pathlen >= MAXPATHLEN) /* total string too long */
1519 return XFS_ERROR(ENAMETOOLONG);
1520
1521 udqp = gdqp = NULL;
1522 if (dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
1523 prid = xfs_get_projid(dp);
1524 else
1525 prid = XFS_PROJID_DEFAULT;
1526
1527 /*
1528 * Make sure that we have allocated dquot(s) on disk.
1529 */
1530 error = xfs_qm_vop_dqalloc(dp, current_fsuid(), current_fsgid(), prid,
1531 XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT, &udqp, &gdqp);
1532 if (error)
1533 goto std_return;
1534
1535 tp = xfs_trans_alloc(mp, XFS_TRANS_SYMLINK);
1536 cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
1537 /*
1538 * The symlink will fit into the inode data fork?
1539 * There can't be any attributes so we get the whole variable part.
1540 */
1541 if (pathlen <= XFS_LITINO(mp))
1542 fs_blocks = 0;
1543 else
1544 fs_blocks = XFS_B_TO_FSB(mp, pathlen);
1545 resblks = XFS_SYMLINK_SPACE_RES(mp, link_name->len, fs_blocks);
1546 error = xfs_trans_reserve(tp, resblks, XFS_SYMLINK_LOG_RES(mp), 0,
1547 XFS_TRANS_PERM_LOG_RES, XFS_SYMLINK_LOG_COUNT);
1548 if (error == ENOSPC && fs_blocks == 0) {
1549 resblks = 0;
1550 error = xfs_trans_reserve(tp, 0, XFS_SYMLINK_LOG_RES(mp), 0,
1551 XFS_TRANS_PERM_LOG_RES, XFS_SYMLINK_LOG_COUNT);
1552 }
1553 if (error) {
1554 cancel_flags = 0;
1555 goto error_return;
1556 }
1557
1558 xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
1559 unlock_dp_on_error = B_TRUE;
1560
1561 /*
1562 * Check whether the directory allows new symlinks or not.
1563 */
1564 if (dp->i_d.di_flags & XFS_DIFLAG_NOSYMLINKS) {
1565 error = XFS_ERROR(EPERM);
1566 goto error_return;
1567 }
1568
1569 /*
1570 * Reserve disk quota : blocks and inode.
1571 */
1572 error = xfs_trans_reserve_quota(tp, mp, udqp, gdqp, resblks, 1, 0);
1573 if (error)
1574 goto error_return;
1575
1576 /*
1577 * Check for ability to enter directory entry, if no space reserved.
1578 */
1579 error = xfs_dir_canenter(tp, dp, link_name, resblks);
1580 if (error)
1581 goto error_return;
1582 /*
1583 * Initialize the bmap freelist prior to calling either
1584 * bmapi or the directory create code.
1585 */
1586 xfs_bmap_init(&free_list, &first_block);
1587
1588 /*
1589 * Allocate an inode for the symlink.
1590 */
1591 error = xfs_dir_ialloc(&tp, dp, S_IFLNK | (mode & ~S_IFMT), 1, 0,
1592 prid, resblks > 0, &ip, NULL);
1593 if (error) {
1594 if (error == ENOSPC)
1595 goto error_return;
1596 goto error1;
1597 }
1598
1599 /*
1600 * An error after we've joined dp to the transaction will result in the
1601 * transaction cancel unlocking dp so don't do it explicitly in the
1602 * error path.
1603 */
1604 xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
1605 unlock_dp_on_error = B_FALSE;
1606
1607 /*
1608 * Also attach the dquot(s) to it, if applicable.
1609 */
1610 xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp);
1611
1612 if (resblks)
1613 resblks -= XFS_IALLOC_SPACE_RES(mp);
1614 /*
1615 * If the symlink will fit into the inode, write it inline.
1616 */
1617 if (pathlen <= XFS_IFORK_DSIZE(ip)) {
1618 xfs_idata_realloc(ip, pathlen, XFS_DATA_FORK);
1619 memcpy(ip->i_df.if_u1.if_data, target_path, pathlen);
1620 ip->i_d.di_size = pathlen;
1621
1622 /*
1623 * The inode was initially created in extent format.
1624 */
1625 ip->i_df.if_flags &= ~(XFS_IFEXTENTS | XFS_IFBROOT);
1626 ip->i_df.if_flags |= XFS_IFINLINE;
1627
1628 ip->i_d.di_format = XFS_DINODE_FMT_LOCAL;
1629 xfs_trans_log_inode(tp, ip, XFS_ILOG_DDATA | XFS_ILOG_CORE);
1630
1631 } else {
1632 first_fsb = 0;
1633 nmaps = SYMLINK_MAPS;
1634
1635 error = xfs_bmapi_write(tp, ip, first_fsb, fs_blocks,
1636 XFS_BMAPI_METADATA, &first_block, resblks,
1637 mval, &nmaps, &free_list);
1638 if (error)
1639 goto error2;
1640
1641 if (resblks)
1642 resblks -= fs_blocks;
1643 ip->i_d.di_size = pathlen;
1644 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1645
1646 cur_chunk = target_path;
1647 for (n = 0; n < nmaps; n++) {
1648 d = XFS_FSB_TO_DADDR(mp, mval[n].br_startblock);
1649 byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount);
1650 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
1651 BTOBB(byte_cnt), 0);
1652 if (!bp) {
1653 error = ENOMEM;
1654 goto error2;
1655 }
1656 if (pathlen < byte_cnt) {
1657 byte_cnt = pathlen;
1658 }
1659 pathlen -= byte_cnt;
1660
1661 memcpy(bp->b_addr, cur_chunk, byte_cnt);
1662 cur_chunk += byte_cnt;
1663
1664 xfs_trans_log_buf(tp, bp, 0, byte_cnt - 1);
1665 }
1666 }
1667
1668 /*
1669 * Create the directory entry for the symlink.
1670 */
1671 error = xfs_dir_createname(tp, dp, link_name, ip->i_ino,
1672 &first_block, &free_list, resblks);
1673 if (error)
1674 goto error2;
1675 xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1676 xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
1677
1678 /*
1679 * If this is a synchronous mount, make sure that the
1680 * symlink transaction goes to disk before returning to
1681 * the user.
1682 */
1683 if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
1684 xfs_trans_set_sync(tp);
1685 }
1686
1687 error = xfs_bmap_finish(&tp, &free_list, &committed);
1688 if (error) {
1689 goto error2;
1690 }
1691 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
1692 xfs_qm_dqrele(udqp);
1693 xfs_qm_dqrele(gdqp);
1694
1695 *ipp = ip;
1696 return 0;
1697
1698 error2:
1699 IRELE(ip);
1700 error1:
1701 xfs_bmap_cancel(&free_list);
1702 cancel_flags |= XFS_TRANS_ABORT;
1703 error_return:
1704 xfs_trans_cancel(tp, cancel_flags);
1705 xfs_qm_dqrele(udqp);
1706 xfs_qm_dqrele(gdqp);
1707
1708 if (unlock_dp_on_error)
1709 xfs_iunlock(dp, XFS_ILOCK_EXCL);
1710 std_return:
1711 return error;
1712}
1713
1714int
1715xfs_set_dmattrs(
1716 xfs_inode_t *ip,
1717 u_int evmask,
1718 u_int16_t state)
1719{
1720 xfs_mount_t *mp = ip->i_mount;
1721 xfs_trans_t *tp;
1722 int error;
1723
1724 if (!capable(CAP_SYS_ADMIN))
1725 return XFS_ERROR(EPERM);
1726
1727 if (XFS_FORCED_SHUTDOWN(mp))
1728 return XFS_ERROR(EIO);
1729
1730 tp = xfs_trans_alloc(mp, XFS_TRANS_SET_DMATTRS);
1731 error = xfs_trans_reserve(tp, 0, XFS_ICHANGE_LOG_RES (mp), 0, 0, 0);
1732 if (error) {
1733 xfs_trans_cancel(tp, 0);
1734 return error;
1735 }
1736 xfs_ilock(ip, XFS_ILOCK_EXCL);
1737 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
1738
1739 ip->i_d.di_dmevmask = evmask;
1740 ip->i_d.di_dmstate = state;
1741
1742 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1743 error = xfs_trans_commit(tp, 0);
1744
1745 return error;
1746}
1747
1748/*
1749 * xfs_alloc_file_space()
1750 * This routine allocates disk space for the given file.
1751 *
1752 * If alloc_type == 0, this request is for an ALLOCSP type
1753 * request which will change the file size. In this case, no
1754 * DMAPI event will be generated by the call. A TRUNCATE event
1755 * will be generated later by xfs_setattr.
1756 *
1757 * If alloc_type != 0, this request is for a RESVSP type
1758 * request, and a DMAPI DM_EVENT_WRITE will be generated if the
1759 * lower block boundary byte address is less than the file's
1760 * length.
1761 *
1762 * RETURNS:
1763 * 0 on success
1764 * errno on error
1765 *
1766 */
1767STATIC int
1768xfs_alloc_file_space(
1769 xfs_inode_t *ip,
1770 xfs_off_t offset,
1771 xfs_off_t len,
1772 int alloc_type,
1773 int attr_flags)
1774{
1775 xfs_mount_t *mp = ip->i_mount;
1776 xfs_off_t count;
1777 xfs_filblks_t allocated_fsb;
1778 xfs_filblks_t allocatesize_fsb;
1779 xfs_extlen_t extsz, temp;
1780 xfs_fileoff_t startoffset_fsb;
1781 xfs_fsblock_t firstfsb;
1782 int nimaps;
1783 int quota_flag;
1784 int rt;
1785 xfs_trans_t *tp;
1786 xfs_bmbt_irec_t imaps[1], *imapp;
1787 xfs_bmap_free_t free_list;
1788 uint qblocks, resblks, resrtextents;
1789 int committed;
1790 int error;
1791
1792 trace_xfs_alloc_file_space(ip);
1793
1794 if (XFS_FORCED_SHUTDOWN(mp))
1795 return XFS_ERROR(EIO);
1796
1797 error = xfs_qm_dqattach(ip, 0);
1798 if (error)
1799 return error;
1800
1801 if (len <= 0)
1802 return XFS_ERROR(EINVAL);
1803
1804 rt = XFS_IS_REALTIME_INODE(ip);
1805 extsz = xfs_get_extsz_hint(ip);
1806
1807 count = len;
1808 imapp = &imaps[0];
1809 nimaps = 1;
1810 startoffset_fsb = XFS_B_TO_FSBT(mp, offset);
1811 allocatesize_fsb = XFS_B_TO_FSB(mp, count);
1812
1813 /*
1814 * Allocate file space until done or until there is an error
1815 */
1816 while (allocatesize_fsb && !error) {
1817 xfs_fileoff_t s, e;
1818
1819 /*
1820 * Determine space reservations for data/realtime.
1821 */
1822 if (unlikely(extsz)) {
1823 s = startoffset_fsb;
1824 do_div(s, extsz);
1825 s *= extsz;
1826 e = startoffset_fsb + allocatesize_fsb;
1827 if ((temp = do_mod(startoffset_fsb, extsz)))
1828 e += temp;
1829 if ((temp = do_mod(e, extsz)))
1830 e += extsz - temp;
1831 } else {
1832 s = 0;
1833 e = allocatesize_fsb;
1834 }
1835
1836 /*
1837 * The transaction reservation is limited to a 32-bit block
1838 * count, hence we need to limit the number of blocks we are
1839 * trying to reserve to avoid an overflow. We can't allocate
1840 * more than @nimaps extents, and an extent is limited on disk
1841 * to MAXEXTLEN (21 bits), so use that to enforce the limit.
1842 */
1843 resblks = min_t(xfs_fileoff_t, (e - s), (MAXEXTLEN * nimaps));
1844 if (unlikely(rt)) {
1845 resrtextents = qblocks = resblks;
1846 resrtextents /= mp->m_sb.sb_rextsize;
1847 resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
1848 quota_flag = XFS_QMOPT_RES_RTBLKS;
1849 } else {
1850 resrtextents = 0;
1851 resblks = qblocks = XFS_DIOSTRAT_SPACE_RES(mp, resblks);
1852 quota_flag = XFS_QMOPT_RES_REGBLKS;
1853 }
1854
1855 /*
1856 * Allocate and setup the transaction.
1857 */
1858 tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
1859 error = xfs_trans_reserve(tp, resblks,
1860 XFS_WRITE_LOG_RES(mp), resrtextents,
1861 XFS_TRANS_PERM_LOG_RES,
1862 XFS_WRITE_LOG_COUNT);
1863 /*
1864 * Check for running out of space
1865 */
1866 if (error) {
1867 /*
1868 * Free the transaction structure.
1869 */
1870 ASSERT(error == ENOSPC || XFS_FORCED_SHUTDOWN(mp));
1871 xfs_trans_cancel(tp, 0);
1872 break;
1873 }
1874 xfs_ilock(ip, XFS_ILOCK_EXCL);
1875 error = xfs_trans_reserve_quota_nblks(tp, ip, qblocks,
1876 0, quota_flag);
1877 if (error)
1878 goto error1;
1879
1880 xfs_trans_ijoin(tp, ip, 0);
1881
1882 xfs_bmap_init(&free_list, &firstfsb);
1883 error = xfs_bmapi_write(tp, ip, startoffset_fsb,
1884 allocatesize_fsb, alloc_type, &firstfsb,
1885 0, imapp, &nimaps, &free_list);
1886 if (error) {
1887 goto error0;
1888 }
1889
1890 /*
1891 * Complete the transaction
1892 */
1893 error = xfs_bmap_finish(&tp, &free_list, &committed);
1894 if (error) {
1895 goto error0;
1896 }
1897
1898 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
1899 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1900 if (error) {
1901 break;
1902 }
1903
1904 allocated_fsb = imapp->br_blockcount;
1905
1906 if (nimaps == 0) {
1907 error = XFS_ERROR(ENOSPC);
1908 break;
1909 }
1910
1911 startoffset_fsb += allocated_fsb;
1912 allocatesize_fsb -= allocated_fsb;
1913 }
1914
1915 return error;
1916
1917error0: /* Cancel bmap, unlock inode, unreserve quota blocks, cancel trans */
1918 xfs_bmap_cancel(&free_list);
1919 xfs_trans_unreserve_quota_nblks(tp, ip, (long)qblocks, 0, quota_flag);
1920
1921error1: /* Just cancel transaction */
1922 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
1923 xfs_iunlock(ip, XFS_ILOCK_EXCL);
1924 return error;
1925}
1926
1927/*
1928 * Zero file bytes between startoff and endoff inclusive.
1929 * The iolock is held exclusive and no blocks are buffered.
1930 *
1931 * This function is used by xfs_free_file_space() to zero
1932 * partial blocks when the range to free is not block aligned.
1933 * When unreserving space with boundaries that are not block
1934 * aligned we round up the start and round down the end
1935 * boundaries and then use this function to zero the parts of
1936 * the blocks that got dropped during the rounding.
1937 */
1938STATIC int
1939xfs_zero_remaining_bytes(
1940 xfs_inode_t *ip,
1941 xfs_off_t startoff,
1942 xfs_off_t endoff)
1943{
1944 xfs_bmbt_irec_t imap;
1945 xfs_fileoff_t offset_fsb;
1946 xfs_off_t lastoffset;
1947 xfs_off_t offset;
1948 xfs_buf_t *bp;
1949 xfs_mount_t *mp = ip->i_mount;
1950 int nimap;
1951 int error = 0;
1952
1953 /*
1954 * Avoid doing I/O beyond eof - it's not necessary
1955 * since nothing can read beyond eof. The space will
1956 * be zeroed when the file is extended anyway.
1957 */
1958 if (startoff >= XFS_ISIZE(ip))
1959 return 0;
1960
1961 if (endoff > XFS_ISIZE(ip))
1962 endoff = XFS_ISIZE(ip);
1963
1964 bp = xfs_buf_get_uncached(XFS_IS_REALTIME_INODE(ip) ?
1965 mp->m_rtdev_targp : mp->m_ddev_targp,
1966 BTOBB(mp->m_sb.sb_blocksize), 0);
1967 if (!bp)
1968 return XFS_ERROR(ENOMEM);
1969
1970 xfs_buf_unlock(bp);
1971
1972 for (offset = startoff; offset <= endoff; offset = lastoffset + 1) {
1973 offset_fsb = XFS_B_TO_FSBT(mp, offset);
1974 nimap = 1;
1975 error = xfs_bmapi_read(ip, offset_fsb, 1, &imap, &nimap, 0);
1976 if (error || nimap < 1)
1977 break;
1978 ASSERT(imap.br_blockcount >= 1);
1979 ASSERT(imap.br_startoff == offset_fsb);
1980 lastoffset = XFS_FSB_TO_B(mp, imap.br_startoff + 1) - 1;
1981 if (lastoffset > endoff)
1982 lastoffset = endoff;
1983 if (imap.br_startblock == HOLESTARTBLOCK)
1984 continue;
1985 ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
1986 if (imap.br_state == XFS_EXT_UNWRITTEN)
1987 continue;
1988 XFS_BUF_UNDONE(bp);
1989 XFS_BUF_UNWRITE(bp);
1990 XFS_BUF_READ(bp);
1991 XFS_BUF_SET_ADDR(bp, xfs_fsb_to_db(ip, imap.br_startblock));
1992 xfsbdstrat(mp, bp);
1993 error = xfs_buf_iowait(bp);
1994 if (error) {
1995 xfs_buf_ioerror_alert(bp,
1996 "xfs_zero_remaining_bytes(read)");
1997 break;
1998 }
1999 memset(bp->b_addr +
2000 (offset - XFS_FSB_TO_B(mp, imap.br_startoff)),
2001 0, lastoffset - offset + 1);
2002 XFS_BUF_UNDONE(bp);
2003 XFS_BUF_UNREAD(bp);
2004 XFS_BUF_WRITE(bp);
2005 xfsbdstrat(mp, bp);
2006 error = xfs_buf_iowait(bp);
2007 if (error) {
2008 xfs_buf_ioerror_alert(bp,
2009 "xfs_zero_remaining_bytes(write)");
2010 break;
2011 }
2012 }
2013 xfs_buf_free(bp);
2014 return error;
2015}
2016
2017/*
2018 * xfs_free_file_space()
2019 * This routine frees disk space for the given file.
2020 *
2021 * This routine is only called by xfs_change_file_space
2022 * for an UNRESVSP type call.
2023 *
2024 * RETURNS:
2025 * 0 on success
2026 * errno on error
2027 *
2028 */
2029STATIC int
2030xfs_free_file_space(
2031 xfs_inode_t *ip,
2032 xfs_off_t offset,
2033 xfs_off_t len,
2034 int attr_flags)
2035{
2036 int committed;
2037 int done;
2038 xfs_fileoff_t endoffset_fsb;
2039 int error;
2040 xfs_fsblock_t firstfsb;
2041 xfs_bmap_free_t free_list;
2042 xfs_bmbt_irec_t imap;
2043 xfs_off_t ioffset;
2044 xfs_extlen_t mod=0;
2045 xfs_mount_t *mp;
2046 int nimap;
2047 uint resblks;
2048 uint rounding;
2049 int rt;
2050 xfs_fileoff_t startoffset_fsb;
2051 xfs_trans_t *tp;
2052 int need_iolock = 1;
2053
2054 mp = ip->i_mount;
2055
2056 trace_xfs_free_file_space(ip);
2057
2058 error = xfs_qm_dqattach(ip, 0);
2059 if (error)
2060 return error;
2061
2062 error = 0;
2063 if (len <= 0) /* if nothing being freed */
2064 return error;
2065 rt = XFS_IS_REALTIME_INODE(ip);
2066 startoffset_fsb = XFS_B_TO_FSB(mp, offset);
2067 endoffset_fsb = XFS_B_TO_FSBT(mp, offset + len);
2068
2069 if (attr_flags & XFS_ATTR_NOLOCK)
2070 need_iolock = 0;
2071 if (need_iolock) {
2072 xfs_ilock(ip, XFS_IOLOCK_EXCL);
2073 /* wait for the completion of any pending DIOs */
2074 inode_dio_wait(VFS_I(ip));
2075 }
2076
2077 rounding = max_t(uint, 1 << mp->m_sb.sb_blocklog, PAGE_CACHE_SIZE);
2078 ioffset = offset & ~(rounding - 1);
2079
2080 if (VN_CACHED(VFS_I(ip)) != 0) {
2081 error = xfs_flushinval_pages(ip, ioffset, -1, FI_REMAPF_LOCKED);
2082 if (error)
2083 goto out_unlock_iolock;
2084 }
2085
2086 /*
2087 * Need to zero the stuff we're not freeing, on disk.
2088 * If it's a realtime file & can't use unwritten extents then we
2089 * actually need to zero the extent edges. Otherwise xfs_bunmapi
2090 * will take care of it for us.
2091 */
2092 if (rt && !xfs_sb_version_hasextflgbit(&mp->m_sb)) {
2093 nimap = 1;
2094 error = xfs_bmapi_read(ip, startoffset_fsb, 1,
2095 &imap, &nimap, 0);
2096 if (error)
2097 goto out_unlock_iolock;
2098 ASSERT(nimap == 0 || nimap == 1);
2099 if (nimap && imap.br_startblock != HOLESTARTBLOCK) {
2100 xfs_daddr_t block;
2101
2102 ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
2103 block = imap.br_startblock;
2104 mod = do_div(block, mp->m_sb.sb_rextsize);
2105 if (mod)
2106 startoffset_fsb += mp->m_sb.sb_rextsize - mod;
2107 }
2108 nimap = 1;
2109 error = xfs_bmapi_read(ip, endoffset_fsb - 1, 1,
2110 &imap, &nimap, 0);
2111 if (error)
2112 goto out_unlock_iolock;
2113 ASSERT(nimap == 0 || nimap == 1);
2114 if (nimap && imap.br_startblock != HOLESTARTBLOCK) {
2115 ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
2116 mod++;
2117 if (mod && (mod != mp->m_sb.sb_rextsize))
2118 endoffset_fsb -= mod;
2119 }
2120 }
2121 if ((done = (endoffset_fsb <= startoffset_fsb)))
2122 /*
2123 * One contiguous piece to clear
2124 */
2125 error = xfs_zero_remaining_bytes(ip, offset, offset + len - 1);
2126 else {
2127 /*
2128 * Some full blocks, possibly two pieces to clear
2129 */
2130 if (offset < XFS_FSB_TO_B(mp, startoffset_fsb))
2131 error = xfs_zero_remaining_bytes(ip, offset,
2132 XFS_FSB_TO_B(mp, startoffset_fsb) - 1);
2133 if (!error &&
2134 XFS_FSB_TO_B(mp, endoffset_fsb) < offset + len)
2135 error = xfs_zero_remaining_bytes(ip,
2136 XFS_FSB_TO_B(mp, endoffset_fsb),
2137 offset + len - 1);
2138 }
2139
2140 /*
2141 * free file space until done or until there is an error
2142 */
2143 resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
2144 while (!error && !done) {
2145
2146 /*
2147 * allocate and setup the transaction. Allow this
2148 * transaction to dip into the reserve blocks to ensure
2149 * the freeing of the space succeeds at ENOSPC.
2150 */
2151 tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
2152 tp->t_flags |= XFS_TRANS_RESERVE;
2153 error = xfs_trans_reserve(tp,
2154 resblks,
2155 XFS_WRITE_LOG_RES(mp),
2156 0,
2157 XFS_TRANS_PERM_LOG_RES,
2158 XFS_WRITE_LOG_COUNT);
2159
2160 /*
2161 * check for running out of space
2162 */
2163 if (error) {
2164 /*
2165 * Free the transaction structure.
2166 */
2167 ASSERT(error == ENOSPC || XFS_FORCED_SHUTDOWN(mp));
2168 xfs_trans_cancel(tp, 0);
2169 break;
2170 }
2171 xfs_ilock(ip, XFS_ILOCK_EXCL);
2172 error = xfs_trans_reserve_quota(tp, mp,
2173 ip->i_udquot, ip->i_gdquot,
2174 resblks, 0, XFS_QMOPT_RES_REGBLKS);
2175 if (error)
2176 goto error1;
2177
2178 xfs_trans_ijoin(tp, ip, 0);
2179
2180 /*
2181 * issue the bunmapi() call to free the blocks
2182 */
2183 xfs_bmap_init(&free_list, &firstfsb);
2184 error = xfs_bunmapi(tp, ip, startoffset_fsb,
2185 endoffset_fsb - startoffset_fsb,
2186 0, 2, &firstfsb, &free_list, &done);
2187 if (error) {
2188 goto error0;
2189 }
2190
2191 /*
2192 * complete the transaction
2193 */
2194 error = xfs_bmap_finish(&tp, &free_list, &committed);
2195 if (error) {
2196 goto error0;
2197 }
2198
2199 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
2200 xfs_iunlock(ip, XFS_ILOCK_EXCL);
2201 }
2202
2203 out_unlock_iolock:
2204 if (need_iolock)
2205 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
2206 return error;
2207
2208 error0:
2209 xfs_bmap_cancel(&free_list);
2210 error1:
2211 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
2212 xfs_iunlock(ip, need_iolock ? (XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL) :
2213 XFS_ILOCK_EXCL);
2214 return error;
2215}
2216
2217/*
2218 * xfs_change_file_space()
2219 * This routine allocates or frees disk space for the given file.
2220 * The user specified parameters are checked for alignment and size
2221 * limitations.
2222 *
2223 * RETURNS:
2224 * 0 on success
2225 * errno on error
2226 *
2227 */
2228int
2229xfs_change_file_space(
2230 xfs_inode_t *ip,
2231 int cmd,
2232 xfs_flock64_t *bf,
2233 xfs_off_t offset,
2234 int attr_flags)
2235{
2236 xfs_mount_t *mp = ip->i_mount;
2237 int clrprealloc;
2238 int error;
2239 xfs_fsize_t fsize;
2240 int setprealloc;
2241 xfs_off_t startoffset;
2242 xfs_off_t llen;
2243 xfs_trans_t *tp;
2244 struct iattr iattr;
2245 int prealloc_type;
2246
2247 if (!S_ISREG(ip->i_d.di_mode))
2248 return XFS_ERROR(EINVAL);
2249
2250 switch (bf->l_whence) {
2251 case 0: /*SEEK_SET*/
2252 break;
2253 case 1: /*SEEK_CUR*/
2254 bf->l_start += offset;
2255 break;
2256 case 2: /*SEEK_END*/
2257 bf->l_start += XFS_ISIZE(ip);
2258 break;
2259 default:
2260 return XFS_ERROR(EINVAL);
2261 }
2262
2263 llen = bf->l_len > 0 ? bf->l_len - 1 : bf->l_len;
2264
2265 if ( (bf->l_start < 0)
2266 || (bf->l_start > XFS_MAXIOFFSET(mp))
2267 || (bf->l_start + llen < 0)
2268 || (bf->l_start + llen > XFS_MAXIOFFSET(mp)))
2269 return XFS_ERROR(EINVAL);
2270
2271 bf->l_whence = 0;
2272
2273 startoffset = bf->l_start;
2274 fsize = XFS_ISIZE(ip);
2275
2276 /*
2277 * XFS_IOC_RESVSP and XFS_IOC_UNRESVSP will reserve or unreserve
2278 * file space.
2279 * These calls do NOT zero the data space allocated to the file,
2280 * nor do they change the file size.
2281 *
2282 * XFS_IOC_ALLOCSP and XFS_IOC_FREESP will allocate and free file
2283 * space.
2284 * These calls cause the new file data to be zeroed and the file
2285 * size to be changed.
2286 */
2287 setprealloc = clrprealloc = 0;
2288 prealloc_type = XFS_BMAPI_PREALLOC;
2289
2290 switch (cmd) {
2291 case XFS_IOC_ZERO_RANGE:
2292 prealloc_type |= XFS_BMAPI_CONVERT;
2293 xfs_tosspages(ip, startoffset, startoffset + bf->l_len, 0);
2294 /* FALLTHRU */
2295 case XFS_IOC_RESVSP:
2296 case XFS_IOC_RESVSP64:
2297 error = xfs_alloc_file_space(ip, startoffset, bf->l_len,
2298 prealloc_type, attr_flags);
2299 if (error)
2300 return error;
2301 setprealloc = 1;
2302 break;
2303
2304 case XFS_IOC_UNRESVSP:
2305 case XFS_IOC_UNRESVSP64:
2306 if ((error = xfs_free_file_space(ip, startoffset, bf->l_len,
2307 attr_flags)))
2308 return error;
2309 break;
2310
2311 case XFS_IOC_ALLOCSP:
2312 case XFS_IOC_ALLOCSP64:
2313 case XFS_IOC_FREESP:
2314 case XFS_IOC_FREESP64:
2315 /*
2316 * These operations actually do IO when extending the file, but
2317 * the allocation is done seperately to the zeroing that is
2318 * done. This set of operations need to be serialised against
2319 * other IO operations, such as truncate and buffered IO. We
2320 * need to take the IOLOCK here to serialise the allocation and
2321 * zeroing IO to prevent other IOLOCK holders (e.g. getbmap,
2322 * truncate, direct IO) from racing against the transient
2323 * allocated but not written state we can have here.
2324 */
2325 xfs_ilock(ip, XFS_IOLOCK_EXCL);
2326 if (startoffset > fsize) {
2327 error = xfs_alloc_file_space(ip, fsize,
2328 startoffset - fsize, 0,
2329 attr_flags | XFS_ATTR_NOLOCK);
2330 if (error) {
2331 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
2332 break;
2333 }
2334 }
2335
2336 iattr.ia_valid = ATTR_SIZE;
2337 iattr.ia_size = startoffset;
2338
2339 error = xfs_setattr_size(ip, &iattr,
2340 attr_flags | XFS_ATTR_NOLOCK);
2341 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
2342
2343 if (error)
2344 return error;
2345
2346 clrprealloc = 1;
2347 break;
2348
2349 default:
2350 ASSERT(0);
2351 return XFS_ERROR(EINVAL);
2352 }
2353
2354 /*
2355 * update the inode timestamp, mode, and prealloc flag bits
2356 */
2357 tp = xfs_trans_alloc(mp, XFS_TRANS_WRITEID);
2358
2359 if ((error = xfs_trans_reserve(tp, 0, XFS_WRITEID_LOG_RES(mp),
2360 0, 0, 0))) {
2361 /* ASSERT(0); */
2362 xfs_trans_cancel(tp, 0);
2363 return error;
2364 }
2365
2366 xfs_ilock(ip, XFS_ILOCK_EXCL);
2367 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
2368
2369 if ((attr_flags & XFS_ATTR_DMI) == 0) {
2370 ip->i_d.di_mode &= ~S_ISUID;
2371
2372 /*
2373 * Note that we don't have to worry about mandatory
2374 * file locking being disabled here because we only
2375 * clear the S_ISGID bit if the Group execute bit is
2376 * on, but if it was on then mandatory locking wouldn't
2377 * have been enabled.
2378 */
2379 if (ip->i_d.di_mode & S_IXGRP)
2380 ip->i_d.di_mode &= ~S_ISGID;
2381
2382 xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
2383 }
2384 if (setprealloc)
2385 ip->i_d.di_flags |= XFS_DIFLAG_PREALLOC;
2386 else if (clrprealloc)
2387 ip->i_d.di_flags &= ~XFS_DIFLAG_PREALLOC;
2388
2389 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
2390 if (attr_flags & XFS_ATTR_SYNC)
2391 xfs_trans_set_sync(tp);
2392 return xfs_trans_commit(tp, 0);
2393}