2 * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
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.
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.
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
20 #include "xfs_types.h"
24 #include "xfs_trans.h"
29 #include "xfs_dmapi.h"
30 #include "xfs_mount.h"
31 #include "xfs_bmap_btree.h"
32 #include "xfs_dir_sf.h"
33 #include "xfs_dir2_sf.h"
34 #include "xfs_attr_sf.h"
35 #include "xfs_dinode.h"
36 #include "xfs_inode.h"
37 #include "xfs_inode_item.h"
39 #include "xfs_error.h"
40 #include "xfs_quota.h"
42 #include "xfs_itable.h"
43 #include "xfs_utils.h"
46 * xfs_get_dir_entry is used to get a reference to an inode given
47 * its parent directory inode and the name of the file. It does
48 * not lock the child inode, and it unlocks the directory before
49 * returning. The directory's generation number is returned for
50 * use by a later call to xfs_lock_dir_and_entry.
60 vp
= VNAME_TO_VNODE(dentry
);
61 bdp
= vn_bhv_lookup_unlocked(VN_BHV_HEAD(vp
), &xfs_vnodeops
);
64 return XFS_ERROR(ENOENT
);
67 *ipp
= XFS_BHVTOI(bdp
);
83 dir_vp
= BHV_TO_VNODE(dir_bdp
);
84 vn_trace_entry(dir_vp
, __FUNCTION__
, (inst_t
*)__return_address
);
86 dp
= XFS_BHVTOI(dir_bdp
);
88 error
= XFS_DIR_LOOKUP(dp
->i_mount
, NULL
, dp
,
89 VNAME(dentry
), VNAMELEN(dentry
), inum
);
92 * Unlock the directory. We do this because we can't
93 * hold the directory lock while doing the vn_get()
94 * in xfs_iget(). Doing so could cause us to hold
95 * a lock while waiting for the inode to finish
96 * being inactive while it's waiting for a log
97 * reservation in the inactive routine.
99 xfs_iunlock(dp
, lock_mode
);
100 error
= xfs_iget(dp
->i_mount
, NULL
, *inum
, 0, 0, ipp
, 0);
101 xfs_ilock(dp
, lock_mode
);
105 } else if ((*ipp
)->i_d
.di_mode
== 0) {
107 * The inode has been freed. Something is
108 * wrong so just get out of here.
110 xfs_iunlock(dp
, lock_mode
);
111 xfs_iput_new(*ipp
, 0);
113 xfs_ilock(dp
, lock_mode
);
114 error
= XFS_ERROR(ENOENT
);
121 * Allocates a new inode from disk and return a pointer to the
122 * incore copy. This routine will internally commit the current
123 * transaction and allocate a new one if the Space Manager needed
124 * to do an allocation to replenish the inode free-list.
126 * This routine is designed to be called from xfs_create and
132 xfs_trans_t
**tpp
, /* input: current transaction;
133 output: may be a new transaction. */
134 xfs_inode_t
*dp
, /* directory within whose allocate
140 prid_t prid
, /* project id */
141 int okalloc
, /* ok to allocate new space */
142 xfs_inode_t
**ipp
, /* pointer to inode; it will be
150 xfs_buf_t
*ialloc_context
= NULL
;
151 boolean_t call_again
= B_FALSE
;
159 ASSERT(tp
->t_flags
& XFS_TRANS_PERM_LOG_RES
);
162 * xfs_ialloc will return a pointer to an incore inode if
163 * the Space Manager has an available inode on the free
164 * list. Otherwise, it will do an allocation and replenish
165 * the freelist. Since we can only do one allocation per
166 * transaction without deadlocks, we will need to commit the
167 * current transaction and start a new one. We will then
168 * need to call xfs_ialloc again to get the inode.
170 * If xfs_ialloc did an allocation to replenish the freelist,
171 * it returns the bp containing the head of the freelist as
172 * ialloc_context. We will hold a lock on it across the
173 * transaction commit so that no other process can steal
174 * the inode(s) that we've just allocated.
176 code
= xfs_ialloc(tp
, dp
, mode
, nlink
, rdev
, credp
, prid
, okalloc
,
177 &ialloc_context
, &call_again
, &ip
);
180 * Return an error if we were unable to allocate a new inode.
181 * This should only happen if we run out of space on disk or
182 * encounter a disk error.
188 if (!call_again
&& (ip
== NULL
)) {
190 return XFS_ERROR(ENOSPC
);
194 * If call_again is set, then we were unable to get an
195 * inode in one operation. We need to commit the current
196 * transaction and call xfs_ialloc() again. It is guaranteed
197 * to succeed the second time.
202 * Normally, xfs_trans_commit releases all the locks.
203 * We call bhold to hang on to the ialloc_context across
204 * the commit. Holding this buffer prevents any other
205 * processes from doing any allocations in this
208 xfs_trans_bhold(tp
, ialloc_context
);
210 * Save the log reservation so we can use
211 * them in the next transaction.
213 log_res
= xfs_trans_get_log_res(tp
);
214 log_count
= xfs_trans_get_log_count(tp
);
217 * We want the quota changes to be associated with the next
218 * transaction, NOT this one. So, detach the dqinfo from this
219 * and attach it to the next transaction.
224 dqinfo
= (void *)tp
->t_dqinfo
;
226 tflags
= tp
->t_flags
& XFS_TRANS_DQ_DIRTY
;
227 tp
->t_flags
&= ~(XFS_TRANS_DQ_DIRTY
);
230 ntp
= xfs_trans_dup(tp
);
231 code
= xfs_trans_commit(tp
, 0, NULL
);
233 if (committed
!= NULL
) {
237 * If we get an error during the commit processing,
238 * release the buffer that is still held and return
242 xfs_buf_relse(ialloc_context
);
244 tp
->t_dqinfo
= dqinfo
;
245 XFS_TRANS_FREE_DQINFO(tp
->t_mountp
, tp
);
251 code
= xfs_trans_reserve(tp
, 0, log_res
, 0,
252 XFS_TRANS_PERM_LOG_RES
, log_count
);
254 * Re-attach the quota info that we detached from prev trx.
257 tp
->t_dqinfo
= dqinfo
;
258 tp
->t_flags
|= tflags
;
262 xfs_buf_relse(ialloc_context
);
267 xfs_trans_bjoin(tp
, ialloc_context
);
270 * Call ialloc again. Since we've locked out all
271 * other allocations in this allocation group,
272 * this call should always succeed.
274 code
= xfs_ialloc(tp
, dp
, mode
, nlink
, rdev
, credp
, prid
,
275 okalloc
, &ialloc_context
, &call_again
, &ip
);
278 * If we get an error at this point, return to the caller
279 * so that the current transaction can be aborted.
286 ASSERT ((!call_again
) && (ip
!= NULL
));
289 if (committed
!= NULL
) {
301 * Decrement the link count on an inode & log the change.
302 * If this causes the link count to go to zero, initiate the
303 * logging activity required to truncate a file.
312 xfs_ichgtime(ip
, XFS_ICHGTIME_CHG
);
314 ASSERT (ip
->i_d
.di_nlink
> 0);
316 xfs_trans_log_inode(tp
, ip
, XFS_ILOG_CORE
);
319 if (ip
->i_d
.di_nlink
== 0) {
321 * We're dropping the last link to this file.
322 * Move the on-disk inode to the AGI unlinked list.
323 * From xfs_inactive() we will pull the inode from
324 * the list and free it.
326 error
= xfs_iunlink(tp
, ip
);
332 * This gets called when the inode's version needs to be changed from 1 to 2.
333 * Currently this happens when the nlink field overflows the old 16-bit value
334 * or when chproj is called to change the project for the first time.
335 * As a side effect the superblock version will also get rev'd
336 * to contain the NLINK bit.
346 ASSERT(ismrlocked (&ip
->i_lock
, MR_UPDATE
));
347 ASSERT(ip
->i_d
.di_version
== XFS_DINODE_VERSION_1
);
349 ip
->i_d
.di_version
= XFS_DINODE_VERSION_2
;
350 ip
->i_d
.di_onlink
= 0;
351 memset(&(ip
->i_d
.di_pad
[0]), 0, sizeof(ip
->i_d
.di_pad
));
353 if (!XFS_SB_VERSION_HASNLINK(&mp
->m_sb
)) {
355 if (!XFS_SB_VERSION_HASNLINK(&mp
->m_sb
)) {
356 XFS_SB_VERSION_ADDNLINK(&mp
->m_sb
);
357 XFS_SB_UNLOCK(mp
, s
);
358 xfs_mod_sb(tp
, XFS_SB_VERSIONNUM
);
360 XFS_SB_UNLOCK(mp
, s
);
363 /* Caller must log the inode */
367 * Increment the link count on an inode & log the change.
374 if (ip
->i_d
.di_nlink
>= XFS_MAXLINK
)
375 return XFS_ERROR(EMLINK
);
376 xfs_ichgtime(ip
, XFS_ICHGTIME_CHG
);
378 ASSERT(ip
->i_d
.di_nlink
> 0);
380 if ((ip
->i_d
.di_version
== XFS_DINODE_VERSION_1
) &&
381 (ip
->i_d
.di_nlink
> XFS_MAXLINK_1
)) {
383 * The inode has increased its number of links beyond
384 * what can fit in an old format inode. It now needs
385 * to be converted to a version 2 inode with a 32 bit
386 * link count. If this is the first inode in the file
387 * system to do this, then we need to bump the superblock
388 * version number as well.
390 xfs_bump_ino_vers2(tp
, ip
);
393 xfs_trans_log_inode(tp
, ip
, XFS_ILOG_CORE
);
398 * Try to truncate the given file to 0 length. Currently called
399 * only out of xfs_remove when it has to truncate a file to free
400 * up space for the remove to proceed.
412 * This is called to truncate the quotainodes too.
414 if (XFS_IS_UQUOTA_ON(mp
)) {
415 if (ip
->i_ino
!= mp
->m_sb
.sb_uquotino
)
416 ASSERT(ip
->i_udquot
);
418 if (XFS_IS_OQUOTA_ON(mp
)) {
419 if (ip
->i_ino
!= mp
->m_sb
.sb_gquotino
)
420 ASSERT(ip
->i_gdquot
);
424 * Make the call to xfs_itruncate_start before starting the
425 * transaction, because we cannot make the call while we're
428 xfs_ilock(ip
, XFS_IOLOCK_EXCL
);
429 xfs_itruncate_start(ip
, XFS_ITRUNC_DEFINITE
, (xfs_fsize_t
)0);
431 tp
= xfs_trans_alloc(mp
, XFS_TRANS_TRUNCATE_FILE
);
432 if ((error
= xfs_trans_reserve(tp
, 0, XFS_ITRUNCATE_LOG_RES(mp
), 0,
433 XFS_TRANS_PERM_LOG_RES
,
434 XFS_ITRUNCATE_LOG_COUNT
))) {
435 xfs_trans_cancel(tp
, 0);
436 xfs_iunlock(ip
, XFS_IOLOCK_EXCL
);
441 * Follow the normal truncate locking protocol. Since we
442 * hold the inode in the transaction, we know that it's number
443 * of references will stay constant.
445 xfs_ilock(ip
, XFS_ILOCK_EXCL
);
446 xfs_trans_ijoin(tp
, ip
, XFS_ILOCK_EXCL
| XFS_IOLOCK_EXCL
);
447 xfs_trans_ihold(tp
, ip
);
449 * Signal a sync xaction. The only case where that isn't
450 * the case is if we're truncating an already unlinked file
451 * on a wsync fs. In that case, we know the blocks can't
452 * reappear in the file because the links to file are
453 * permanently toast. Currently, we're always going to
454 * want a sync transaction because this code is being
455 * called from places where nlink is guaranteed to be 1
456 * but I'm leaving the tests in to protect against future
459 error
= xfs_itruncate_finish(&tp
, ip
, (xfs_fsize_t
)0,
461 ((ip
->i_d
.di_nlink
!= 0 ||
462 !(mp
->m_flags
& XFS_MOUNT_WSYNC
))
465 xfs_trans_cancel(tp
, XFS_TRANS_RELEASE_LOG_RES
|
468 xfs_ichgtime(ip
, XFS_ICHGTIME_MOD
| XFS_ICHGTIME_CHG
);
469 error
= xfs_trans_commit(tp
, XFS_TRANS_RELEASE_LOG_RES
,
472 xfs_iunlock(ip
, XFS_ILOCK_EXCL
| XFS_IOLOCK_EXCL
);