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