blob: 8b6812f66a15bf2895aba5fed5f04be0c22625d8 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Olaf Weber3e57ecf2006-06-09 14:48:12 +10002 * Copyright (c) 2000-2006 Silicon Graphics, Inc.
Nathan Scott7b718762005-11-02 14:58:39 +11003 * All Rights Reserved.
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 *
Nathan Scott7b718762005-11-02 14:58:39 +11005 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License as
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * published by the Free Software Foundation.
8 *
Nathan Scott7b718762005-11-02 14:58:39 +11009 * This program is distributed in the hope that it would be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 *
Nathan Scott7b718762005-11-02 14:58:39 +110014 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write the Free Software Foundation,
16 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 */
Randy Dunlap16f7e0f2006-01-11 12:17:46 -080018
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include "xfs.h"
Nathan Scotta844f452005-11-02 14:38:42 +110020#include "xfs_fs.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include "xfs_types.h"
Nathan Scotta844f452005-11-02 14:38:42 +110022#include "xfs_bit.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070023#include "xfs_log.h"
Nathan Scotta844f452005-11-02 14:38:42 +110024#include "xfs_inum.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070025#include "xfs_trans.h"
26#include "xfs_sb.h"
27#include "xfs_ag.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include "xfs_dir2.h"
29#include "xfs_dmapi.h"
30#include "xfs_mount.h"
Nathan Scotta844f452005-11-02 14:38:42 +110031#include "xfs_da_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include "xfs_bmap_btree.h"
Nathan Scotta844f452005-11-02 14:38:42 +110033#include "xfs_alloc_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include "xfs_ialloc_btree.h"
Nathan Scotta844f452005-11-02 14:38:42 +110035#include "xfs_dir2_sf.h"
36#include "xfs_attr_sf.h"
37#include "xfs_dinode.h"
38#include "xfs_inode.h"
39#include "xfs_inode_item.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070040#include "xfs_itable.h"
41#include "xfs_btree.h"
42#include "xfs_ialloc.h"
43#include "xfs_alloc.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#include "xfs_bmap.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#include "xfs_attr.h"
46#include "xfs_rw.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070047#include "xfs_error.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070048#include "xfs_quota.h"
49#include "xfs_utils.h"
Nathan Scotta844f452005-11-02 14:38:42 +110050#include "xfs_rtalloc.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070051#include "xfs_trans_space.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070052#include "xfs_log_priv.h"
David Chinner2a82b8b2007-07-11 11:09:12 +100053#include "xfs_filestream.h"
Christoph Hellwig993386c2007-08-28 16:12:30 +100054#include "xfs_vnodeops.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
Christoph Hellwig993386c2007-08-28 16:12:30 +100056int
Linus Torvalds1da177e2005-04-16 15:20:36 -070057xfs_open(
Christoph Hellwig993386c2007-08-28 16:12:30 +100058 xfs_inode_t *ip)
Linus Torvalds1da177e2005-04-16 15:20:36 -070059{
60 int mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -070061
62 if (XFS_FORCED_SHUTDOWN(ip->i_mount))
63 return XFS_ERROR(EIO);
64
65 /*
66 * If it's a directory with any blocks, read-ahead block 0
67 * as we're almost certain to have the next operation be a read there.
68 */
Christoph Hellwig993386c2007-08-28 16:12:30 +100069 if (S_ISDIR(ip->i_d.di_mode) && ip->i_d.di_nextents > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070070 mode = xfs_ilock_map_shared(ip);
71 if (ip->i_d.di_nextents > 0)
72 (void)xfs_da_reada_buf(NULL, ip, 0, XFS_DATA_FORK);
73 xfs_iunlock(ip, mode);
74 }
75 return 0;
76}
77
Linus Torvalds1da177e2005-04-16 15:20:36 -070078int
79xfs_setattr(
Christoph Hellwig0f285c82008-07-18 17:13:28 +100080 struct xfs_inode *ip,
81 struct iattr *iattr,
Linus Torvalds1da177e2005-04-16 15:20:36 -070082 int flags,
83 cred_t *credp)
84{
Christoph Hellwig993386c2007-08-28 16:12:30 +100085 xfs_mount_t *mp = ip->i_mount;
David Chinnere4f75292008-08-13 16:00:45 +100086 struct inode *inode = VFS_I(ip);
Christoph Hellwig0f285c82008-07-18 17:13:28 +100087 int mask = iattr->ia_valid;
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 xfs_trans_t *tp;
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 int code;
90 uint lock_flags;
91 uint commit_flags=0;
92 uid_t uid=0, iuid=0;
93 gid_t gid=0, igid=0;
94 int timeflags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 struct xfs_dquot *udqp, *gdqp, *olddquot1, *olddquot2;
96 int file_owner;
Dean Roehrich5fcbab32005-05-05 13:27:19 -070097 int need_iolock = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070098
Lachlan McIlroycf441ee2008-02-07 16:42:19 +110099 xfs_itrace_entry(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100
Christoph Hellwigbd186aa2007-08-30 17:21:12 +1000101 if (mp->m_flags & XFS_MOUNT_RDONLY)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 return XFS_ERROR(EROFS);
103
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 if (XFS_FORCED_SHUTDOWN(mp))
105 return XFS_ERROR(EIO);
106
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107 olddquot1 = olddquot2 = NULL;
108 udqp = gdqp = NULL;
109
110 /*
111 * If disk quotas is on, we make sure that the dquots do exist on disk,
112 * before we start any other transactions. Trying to do this later
113 * is messy. We don't care to take a readlock to look at the ids
114 * in inode here, because we can't hold it across the trans_reserve.
115 * If the IDs do change before we take the ilock, we're covered
116 * because the i_*dquot fields will get updated anyway.
117 */
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000118 if (XFS_IS_QUOTA_ON(mp) && (mask & (ATTR_UID|ATTR_GID))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 uint qflags = 0;
120
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000121 if ((mask & ATTR_UID) && XFS_IS_UQUOTA_ON(mp)) {
122 uid = iattr->ia_uid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123 qflags |= XFS_QMOPT_UQUOTA;
124 } else {
125 uid = ip->i_d.di_uid;
126 }
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000127 if ((mask & ATTR_GID) && XFS_IS_GQUOTA_ON(mp)) {
128 gid = iattr->ia_gid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 qflags |= XFS_QMOPT_GQUOTA;
130 } else {
131 gid = ip->i_d.di_gid;
132 }
Christoph Hellwig25fe55e2008-07-18 17:13:20 +1000133
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 /*
135 * We take a reference when we initialize udqp and gdqp,
136 * so it is important that we never blindly double trip on
137 * the same variable. See xfs_create() for an example.
138 */
139 ASSERT(udqp == NULL);
140 ASSERT(gdqp == NULL);
Christoph Hellwig25fe55e2008-07-18 17:13:20 +1000141 code = XFS_QM_DQVOPALLOC(mp, ip, uid, gid, ip->i_d.di_projid,
142 qflags, &udqp, &gdqp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143 if (code)
Jesper Juhl014c2542006-01-15 02:37:08 +0100144 return code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 }
146
147 /*
148 * For the other attributes, we acquire the inode lock and
149 * first do an error checking pass.
150 */
151 tp = NULL;
152 lock_flags = XFS_ILOCK_EXCL;
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000153 if (flags & XFS_ATTR_NOLOCK)
Dean Roehrich5fcbab32005-05-05 13:27:19 -0700154 need_iolock = 0;
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000155 if (!(mask & ATTR_SIZE)) {
156 if ((mask != (ATTR_CTIME|ATTR_ATIME|ATTR_MTIME)) ||
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 (mp->m_flags & XFS_MOUNT_WSYNC)) {
158 tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_NOT_SIZE);
159 commit_flags = 0;
160 if ((code = xfs_trans_reserve(tp, 0,
161 XFS_ICHANGE_LOG_RES(mp), 0,
162 0, 0))) {
163 lock_flags = 0;
164 goto error_return;
165 }
166 }
167 } else {
Christoph Hellwigeb9df392007-08-16 18:42:07 +1000168 if (DM_EVENT_ENABLED(ip, DM_EVENT_TRUNCATE) &&
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000169 !(flags & XFS_ATTR_DMI)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170 int dmflags = AT_DELAY_FLAG(flags) | DM_SEM_FLAG_WR;
Christoph Hellwigbc4ac742008-03-06 13:45:58 +1100171 code = XFS_SEND_DATA(mp, DM_EVENT_TRUNCATE, ip,
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000172 iattr->ia_size, 0, dmflags, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 if (code) {
174 lock_flags = 0;
175 goto error_return;
176 }
177 }
178 if (need_iolock)
179 lock_flags |= XFS_IOLOCK_EXCL;
180 }
181
182 xfs_ilock(ip, lock_flags);
183
184 /* boolean: are we the file owner? */
David Howells9e2b2dc2008-08-13 16:20:04 +0100185 file_owner = (current_fsuid() == ip->i_d.di_uid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186
187 /*
188 * Change various properties of a file.
189 * Only the owner or users with CAP_FOWNER
190 * capability may do these things.
191 */
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000192 if (mask & (ATTR_MODE|ATTR_UID|ATTR_GID)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 /*
194 * CAP_FOWNER overrides the following restrictions:
195 *
196 * The user ID of the calling process must be equal
197 * to the file owner ID, except in cases where the
198 * CAP_FSETID capability is applicable.
199 */
200 if (!file_owner && !capable(CAP_FOWNER)) {
201 code = XFS_ERROR(EPERM);
202 goto error_return;
203 }
204
205 /*
206 * CAP_FSETID overrides the following restrictions:
207 *
208 * The effective user ID of the calling process shall match
209 * the file owner when setting the set-user-ID and
210 * set-group-ID bits on that file.
211 *
212 * The effective group ID or one of the supplementary group
213 * IDs of the calling process shall match the group owner of
214 * the file when setting the set-group-ID bit on that file
215 */
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000216 if (mask & ATTR_MODE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 mode_t m = 0;
218
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000219 if ((iattr->ia_mode & S_ISUID) && !file_owner)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 m |= S_ISUID;
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000221 if ((iattr->ia_mode & S_ISGID) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 !in_group_p((gid_t)ip->i_d.di_gid))
223 m |= S_ISGID;
224#if 0
225 /* Linux allows this, Irix doesn't. */
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000226 if ((iattr->ia_mode & S_ISVTX) && !S_ISDIR(ip->i_d.di_mode))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 m |= S_ISVTX;
228#endif
229 if (m && !capable(CAP_FSETID))
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000230 iattr->ia_mode &= ~m;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 }
232 }
233
234 /*
235 * Change file ownership. Must be the owner or privileged.
236 * If the system was configured with the "restricted_chown"
237 * option, the owner is not permitted to give away the file,
238 * and can change the group id only to a group of which he
239 * or she is a member.
240 */
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000241 if (mask & (ATTR_UID|ATTR_GID)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 /*
243 * These IDs could have changed since we last looked at them.
244 * But, we're assured that if the ownership did change
245 * while we didn't have the inode locked, inode's dquot(s)
246 * would have changed also.
247 */
248 iuid = ip->i_d.di_uid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700249 igid = ip->i_d.di_gid;
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000250 gid = (mask & ATTR_GID) ? iattr->ia_gid : igid;
251 uid = (mask & ATTR_UID) ? iattr->ia_uid : iuid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252
253 /*
254 * CAP_CHOWN overrides the following restrictions:
255 *
256 * If _POSIX_CHOWN_RESTRICTED is defined, this capability
257 * shall override the restriction that a process cannot
258 * change the user ID of a file it owns and the restriction
259 * that the group ID supplied to the chown() function
260 * shall be equal to either the group ID or one of the
261 * supplementary group IDs of the calling process.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 */
263 if (restricted_chown &&
264 (iuid != uid || (igid != gid &&
265 !in_group_p((gid_t)gid))) &&
266 !capable(CAP_CHOWN)) {
267 code = XFS_ERROR(EPERM);
268 goto error_return;
269 }
270 /*
Christoph Hellwig25fe55e2008-07-18 17:13:20 +1000271 * Do a quota reservation only if uid/gid is actually
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 * going to change.
273 */
274 if ((XFS_IS_UQUOTA_ON(mp) && iuid != uid) ||
275 (XFS_IS_GQUOTA_ON(mp) && igid != gid)) {
276 ASSERT(tp);
277 code = XFS_QM_DQVOPCHOWNRESV(mp, tp, ip, udqp, gdqp,
278 capable(CAP_FOWNER) ?
279 XFS_QMOPT_FORCE_RES : 0);
280 if (code) /* out of quota */
281 goto error_return;
282 }
283 }
284
285 /*
286 * Truncate file. Must have write permission and not be a directory.
287 */
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000288 if (mask & ATTR_SIZE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 /* Short circuit the truncate case for zero length files */
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000290 if (iattr->ia_size == 0 &&
291 ip->i_size == 0 && ip->i_d.di_nextents == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 xfs_iunlock(ip, XFS_ILOCK_EXCL);
293 lock_flags &= ~XFS_ILOCK_EXCL;
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000294 if (mask & ATTR_CTIME)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 xfs_ichgtime(ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
296 code = 0;
297 goto error_return;
298 }
299
Christoph Hellwig42173f62008-04-22 17:33:25 +1000300 if (S_ISDIR(ip->i_d.di_mode)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 code = XFS_ERROR(EISDIR);
302 goto error_return;
Christoph Hellwig42173f62008-04-22 17:33:25 +1000303 } else if (!S_ISREG(ip->i_d.di_mode)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304 code = XFS_ERROR(EINVAL);
305 goto error_return;
306 }
307 /*
308 * Make sure that the dquots are attached to the inode.
309 */
310 if ((code = XFS_QM_DQATTACH(mp, ip, XFS_QMOPT_ILOCKED)))
311 goto error_return;
312 }
313
314 /*
315 * Change file access or modified times.
316 */
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000317 if (mask & (ATTR_ATIME|ATTR_MTIME)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700318 if (!file_owner) {
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000319 if ((mask & (ATTR_MTIME_SET|ATTR_ATIME_SET)) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 !capable(CAP_FOWNER)) {
321 code = XFS_ERROR(EPERM);
322 goto error_return;
323 }
324 }
325 }
326
327 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 * Now we can make the changes. Before we join the inode
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000329 * to the transaction, if ATTR_SIZE is set then take care of
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 * the part of the truncation that must be done without the
331 * inode lock. This needs to be done before joining the inode
332 * to the transaction, because the inode cannot be unlocked
333 * once it is a part of the transaction.
334 */
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000335 if (mask & ATTR_SIZE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336 code = 0;
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000337 if (iattr->ia_size > ip->i_size) {
Christoph Hellwig61436fe2008-05-20 11:30:46 +1000338 /*
339 * Do the first part of growing a file: zero any data
340 * in the last block that is beyond the old EOF. We
341 * need to do this before the inode is joined to the
342 * transaction to modify the i_size.
343 */
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000344 code = xfs_zero_eof(ip, iattr->ia_size, ip->i_size);
Eric Sandeen374e2ac2005-11-02 15:07:34 +1100345 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 xfs_iunlock(ip, XFS_ILOCK_EXCL);
David Chinnerc32676e2007-07-19 16:28:58 +1000347
348 /*
349 * We are going to log the inode size change in this
350 * transaction so any previous writes that are beyond the on
351 * disk EOF and the new EOF that have not been written out need
352 * to be written here. If we do not write the data out, we
353 * expose ourselves to the null files problem.
354 *
355 * Only flush from the on disk size to the smaller of the in
356 * memory file size or the new size as that's the range we
357 * really care about here and prevents waiting for other data
358 * not within the range we care about here.
359 */
360 if (!code &&
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000361 ip->i_size != ip->i_d.di_size &&
362 iattr->ia_size > ip->i_d.di_size) {
Christoph Hellwig739bfb22007-08-29 10:58:01 +1000363 code = xfs_flush_pages(ip,
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000364 ip->i_d.di_size, iattr->ia_size,
David Chinnerc32676e2007-07-19 16:28:58 +1000365 XFS_B_ASYNC, FI_NONE);
366 }
367
368 /* wait for all I/O to complete */
Christoph Hellwigb677c212007-08-29 11:46:28 +1000369 vn_iowait(ip);
David Chinnerc32676e2007-07-19 16:28:58 +1000370
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 if (!code)
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000372 code = xfs_itruncate_data(ip, iattr->ia_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 if (code) {
374 ASSERT(tp == NULL);
375 lock_flags &= ~XFS_ILOCK_EXCL;
376 ASSERT(lock_flags == XFS_IOLOCK_EXCL);
377 goto error_return;
378 }
379 tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_SIZE);
380 if ((code = xfs_trans_reserve(tp, 0,
381 XFS_ITRUNCATE_LOG_RES(mp), 0,
382 XFS_TRANS_PERM_LOG_RES,
383 XFS_ITRUNCATE_LOG_COUNT))) {
384 xfs_trans_cancel(tp, 0);
385 if (need_iolock)
386 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
387 return code;
388 }
389 commit_flags = XFS_TRANS_RELEASE_LOG_RES;
390 xfs_ilock(ip, XFS_ILOCK_EXCL);
391 }
392
393 if (tp) {
394 xfs_trans_ijoin(tp, ip, lock_flags);
395 xfs_trans_ihold(tp, ip);
396 }
397
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 /*
399 * Truncate file. Must have write permission and not be a directory.
400 */
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000401 if (mask & ATTR_SIZE) {
David Chinner44d814c2008-03-06 13:45:29 +1100402 /*
403 * Only change the c/mtime if we are changing the size
404 * or we are explicitly asked to change it. This handles
405 * the semantic difference between truncate() and ftruncate()
406 * as implemented in the VFS.
407 */
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000408 if (iattr->ia_size != ip->i_size || (mask & ATTR_CTIME))
David Chinner44d814c2008-03-06 13:45:29 +1100409 timeflags |= XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG;
410
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000411 if (iattr->ia_size > ip->i_size) {
412 ip->i_d.di_size = iattr->ia_size;
413 ip->i_size = iattr->ia_size;
414 if (!(flags & XFS_ATTR_DMI))
Christoph Hellwig61436fe2008-05-20 11:30:46 +1000415 xfs_ichgtime(ip, XFS_ICHGTIME_CHG);
416 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000417 } else if (iattr->ia_size <= ip->i_size ||
418 (iattr->ia_size == 0 && ip->i_d.di_nextents)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 /*
420 * signal a sync transaction unless
421 * we're truncating an already unlinked
422 * file on a wsync filesystem
423 */
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000424 code = xfs_itruncate_finish(&tp, ip, iattr->ia_size,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 XFS_DATA_FORK,
426 ((ip->i_d.di_nlink != 0 ||
427 !(mp->m_flags & XFS_MOUNT_WSYNC))
428 ? 1 : 0));
Nathan Scott7d4fb402006-06-09 15:27:16 +1000429 if (code)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 goto abort_return;
Nathan Scott7d4fb402006-06-09 15:27:16 +1000431 /*
432 * Truncated "down", so we're removing references
433 * to old data here - if we now delay flushing for
434 * a long time, we expose ourselves unduly to the
435 * notorious NULL files problem. So, we mark this
436 * vnode and flush it when the file is closed, and
437 * do not wait the usual (long) time for writeout.
438 */
Christoph Hellwigb3aea4e2007-08-29 11:44:37 +1000439 xfs_iflags_set(ip, XFS_ITRUNCATED);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 }
442
443 /*
444 * Change file access modes.
445 */
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000446 if (mask & ATTR_MODE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 ip->i_d.di_mode &= S_IFMT;
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000448 ip->i_d.di_mode |= iattr->ia_mode & ~S_IFMT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449
Christoph Hellwigf13fae22008-07-21 16:16:15 +1000450 inode->i_mode &= S_IFMT;
451 inode->i_mode |= iattr->ia_mode & ~S_IFMT;
452
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 xfs_trans_log_inode (tp, ip, XFS_ILOG_CORE);
454 timeflags |= XFS_ICHGTIME_CHG;
455 }
456
457 /*
458 * Change file ownership. Must be the owner or privileged.
459 * If the system was configured with the "restricted_chown"
460 * option, the owner is not permitted to give away the file,
461 * and can change the group id only to a group of which he
462 * or she is a member.
463 */
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000464 if (mask & (ATTR_UID|ATTR_GID)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 /*
466 * CAP_FSETID overrides the following restrictions:
467 *
468 * The set-user-ID and set-group-ID bits of a file will be
469 * cleared upon successful return from chown()
470 */
471 if ((ip->i_d.di_mode & (S_ISUID|S_ISGID)) &&
472 !capable(CAP_FSETID)) {
473 ip->i_d.di_mode &= ~(S_ISUID|S_ISGID);
474 }
475
476 /*
477 * Change the ownerships and register quota modifications
478 * in the transaction.
479 */
480 if (iuid != uid) {
481 if (XFS_IS_UQUOTA_ON(mp)) {
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000482 ASSERT(mask & ATTR_UID);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 ASSERT(udqp);
484 olddquot1 = XFS_QM_DQVOPCHOWN(mp, tp, ip,
485 &ip->i_udquot, udqp);
486 }
487 ip->i_d.di_uid = uid;
Christoph Hellwigf13fae22008-07-21 16:16:15 +1000488 inode->i_uid = uid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 }
490 if (igid != gid) {
491 if (XFS_IS_GQUOTA_ON(mp)) {
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000492 ASSERT(!XFS_IS_PQUOTA_ON(mp));
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000493 ASSERT(mask & ATTR_GID);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 ASSERT(gdqp);
495 olddquot2 = XFS_QM_DQVOPCHOWN(mp, tp, ip,
496 &ip->i_gdquot, gdqp);
497 }
498 ip->i_d.di_gid = gid;
Christoph Hellwigf13fae22008-07-21 16:16:15 +1000499 inode->i_gid = gid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501
502 xfs_trans_log_inode (tp, ip, XFS_ILOG_CORE);
503 timeflags |= XFS_ICHGTIME_CHG;
504 }
505
506
507 /*
508 * Change file access or modified times.
509 */
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000510 if (mask & (ATTR_ATIME|ATTR_MTIME)) {
511 if (mask & ATTR_ATIME) {
Christoph Hellwigf13fae22008-07-21 16:16:15 +1000512 inode->i_atime = iattr->ia_atime;
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000513 ip->i_d.di_atime.t_sec = iattr->ia_atime.tv_sec;
514 ip->i_d.di_atime.t_nsec = iattr->ia_atime.tv_nsec;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 ip->i_update_core = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516 }
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000517 if (mask & ATTR_MTIME) {
Christoph Hellwigf13fae22008-07-21 16:16:15 +1000518 inode->i_mtime = iattr->ia_mtime;
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000519 ip->i_d.di_mtime.t_sec = iattr->ia_mtime.tv_sec;
520 ip->i_d.di_mtime.t_nsec = iattr->ia_mtime.tv_nsec;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 timeflags &= ~XFS_ICHGTIME_MOD;
522 timeflags |= XFS_ICHGTIME_CHG;
523 }
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000524 if (tp && (mask & (ATTR_MTIME_SET|ATTR_ATIME_SET)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 xfs_trans_log_inode (tp, ip, XFS_ILOG_CORE);
526 }
527
528 /*
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000529 * Change file inode change time only if ATTR_CTIME set
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 * AND we have been called by a DMI function.
531 */
532
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000533 if ((flags & XFS_ATTR_DMI) && (mask & ATTR_CTIME)) {
Christoph Hellwigf13fae22008-07-21 16:16:15 +1000534 inode->i_ctime = iattr->ia_ctime;
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000535 ip->i_d.di_ctime.t_sec = iattr->ia_ctime.tv_sec;
536 ip->i_d.di_ctime.t_nsec = iattr->ia_ctime.tv_nsec;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537 ip->i_update_core = 1;
538 timeflags &= ~XFS_ICHGTIME_CHG;
539 }
540
541 /*
542 * Send out timestamp changes that need to be set to the
543 * current time. Not done when called by a DMI function.
544 */
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000545 if (timeflags && !(flags & XFS_ATTR_DMI))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 xfs_ichgtime(ip, timeflags);
547
548 XFS_STATS_INC(xs_ig_attrchg);
549
550 /*
551 * If this is a synchronous mount, make sure that the
552 * transaction goes to disk before returning to the user.
553 * This is slightly sub-optimal in that truncates require
Nathan Scottc41564b2006-03-29 08:55:14 +1000554 * two sync transactions instead of one for wsync filesystems.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 * One for the truncate and one for the timestamps since we
556 * don't want to change the timestamps unless we're sure the
557 * truncate worked. Truncates are less than 1% of the laddis
558 * mix so this probably isn't worth the trouble to optimize.
559 */
560 code = 0;
561 if (tp) {
562 if (mp->m_flags & XFS_MOUNT_WSYNC)
563 xfs_trans_set_sync(tp);
564
Eric Sandeen1c72bf92007-05-08 13:48:42 +1000565 code = xfs_trans_commit(tp, commit_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 }
567
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568 xfs_iunlock(ip, lock_flags);
569
570 /*
571 * Release any dquot(s) the inode had kept before chown.
572 */
573 XFS_QM_DQRELE(mp, olddquot1);
574 XFS_QM_DQRELE(mp, olddquot2);
575 XFS_QM_DQRELE(mp, udqp);
576 XFS_QM_DQRELE(mp, gdqp);
577
578 if (code) {
579 return code;
580 }
581
Christoph Hellwigeb9df392007-08-16 18:42:07 +1000582 if (DM_EVENT_ENABLED(ip, DM_EVENT_ATTRIBUTE) &&
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000583 !(flags & XFS_ATTR_DMI)) {
Christoph Hellwigbc4ac742008-03-06 13:45:58 +1100584 (void) XFS_SEND_NAMESP(mp, DM_EVENT_ATTRIBUTE, ip, DM_RIGHT_NULL,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 NULL, DM_RIGHT_NULL, NULL, NULL,
586 0, 0, AT_DELAY_FLAG(flags));
587 }
588 return 0;
589
590 abort_return:
591 commit_flags |= XFS_TRANS_ABORT;
592 /* FALLTHROUGH */
593 error_return:
594 XFS_QM_DQRELE(mp, udqp);
595 XFS_QM_DQRELE(mp, gdqp);
596 if (tp) {
597 xfs_trans_cancel(tp, commit_flags);
598 }
599 if (lock_flags != 0) {
600 xfs_iunlock(ip, lock_flags);
601 }
602 return code;
603}
604
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605/*
Nathan Scott7d4fb402006-06-09 15:27:16 +1000606 * The maximum pathlen is 1024 bytes. Since the minimum file system
607 * blocksize is 512 bytes, we can get a max of 2 extents back from
608 * bmapi.
609 */
610#define SYMLINK_MAPS 2
611
Christoph Hellwig804c83c2007-08-28 13:59:03 +1000612STATIC int
613xfs_readlink_bmap(
614 xfs_inode_t *ip,
615 char *link)
616{
617 xfs_mount_t *mp = ip->i_mount;
618 int pathlen = ip->i_d.di_size;
619 int nmaps = SYMLINK_MAPS;
620 xfs_bmbt_irec_t mval[SYMLINK_MAPS];
621 xfs_daddr_t d;
622 int byte_cnt;
623 int n;
624 xfs_buf_t *bp;
625 int error = 0;
626
627 error = xfs_bmapi(NULL, ip, 0, XFS_B_TO_FSB(mp, pathlen), 0, NULL, 0,
628 mval, &nmaps, NULL, NULL);
629 if (error)
630 goto out;
631
632 for (n = 0; n < nmaps; n++) {
633 d = XFS_FSB_TO_DADDR(mp, mval[n].br_startblock);
634 byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount);
635
636 bp = xfs_buf_read(mp->m_ddev_targp, d, BTOBB(byte_cnt), 0);
637 error = XFS_BUF_GETERROR(bp);
638 if (error) {
639 xfs_ioerror_alert("xfs_readlink",
640 ip->i_mount, bp, XFS_BUF_ADDR(bp));
641 xfs_buf_relse(bp);
642 goto out;
643 }
644 if (pathlen < byte_cnt)
645 byte_cnt = pathlen;
646 pathlen -= byte_cnt;
647
648 memcpy(link, XFS_BUF_PTR(bp), byte_cnt);
649 xfs_buf_relse(bp);
650 }
651
652 link[ip->i_d.di_size] = '\0';
653 error = 0;
654
655 out:
656 return error;
657}
658
Christoph Hellwig993386c2007-08-28 16:12:30 +1000659int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660xfs_readlink(
Christoph Hellwig993386c2007-08-28 16:12:30 +1000661 xfs_inode_t *ip,
Christoph Hellwig804c83c2007-08-28 13:59:03 +1000662 char *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663{
Christoph Hellwig804c83c2007-08-28 13:59:03 +1000664 xfs_mount_t *mp = ip->i_mount;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 int pathlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700666 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667
Lachlan McIlroycf441ee2008-02-07 16:42:19 +1100668 xfs_itrace_entry(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669
670 if (XFS_FORCED_SHUTDOWN(mp))
671 return XFS_ERROR(EIO);
672
673 xfs_ilock(ip, XFS_ILOCK_SHARED);
674
675 ASSERT((ip->i_d.di_mode & S_IFMT) == S_IFLNK);
Christoph Hellwig804c83c2007-08-28 13:59:03 +1000676 ASSERT(ip->i_d.di_size <= MAXPATHLEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677
Christoph Hellwig804c83c2007-08-28 13:59:03 +1000678 pathlen = ip->i_d.di_size;
679 if (!pathlen)
680 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681
682 if (ip->i_df.if_flags & XFS_IFINLINE) {
Christoph Hellwig804c83c2007-08-28 13:59:03 +1000683 memcpy(link, ip->i_df.if_u1.if_data, pathlen);
684 link[pathlen] = '\0';
685 } else {
686 error = xfs_readlink_bmap(ip, link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700687 }
688
Christoph Hellwig804c83c2007-08-28 13:59:03 +1000689 out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690 xfs_iunlock(ip, XFS_ILOCK_SHARED);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 return error;
692}
693
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694/*
695 * xfs_fsync
696 *
David Chinner978b7232008-05-19 16:29:46 +1000697 * This is called to sync the inode and its data out to disk. We need to hold
698 * the I/O lock while flushing the data, and the inode lock while flushing the
699 * inode. The inode lock CANNOT be held while flushing the data, so acquire
700 * after we're done with that.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 */
Christoph Hellwig993386c2007-08-28 16:12:30 +1000702int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703xfs_fsync(
David Chinner978b7232008-05-19 16:29:46 +1000704 xfs_inode_t *ip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 xfs_trans_t *tp;
707 int error;
Christoph Hellwigf538d4d2005-11-02 10:26:59 +1100708 int log_flushed = 0, changed = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709
Lachlan McIlroycf441ee2008-02-07 16:42:19 +1100710 xfs_itrace_entry(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 if (XFS_FORCED_SHUTDOWN(ip->i_mount))
713 return XFS_ERROR(EIO);
714
David Chinner978b7232008-05-19 16:29:46 +1000715 /* capture size updates in I/O completion before writing the inode. */
Christoph Hellwig863890c2008-08-13 16:12:05 +1000716 error = filemap_fdatawait(VFS_I(ip)->i_mapping);
David Chinner978b7232008-05-19 16:29:46 +1000717 if (error)
718 return XFS_ERROR(error);
Lachlan McIlroy776a75fa2007-09-14 15:22:50 +1000719
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 /*
David Chinner978b7232008-05-19 16:29:46 +1000721 * We always need to make sure that the required inode state is safe on
722 * disk. The vnode might be clean but we still might need to force the
723 * log because of committed transactions that haven't hit the disk yet.
724 * Likewise, there could be unflushed non-transactional changes to the
725 * inode core that have to go to disk and this requires us to issue
726 * a synchronous transaction to capture these changes correctly.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 *
David Chinner978b7232008-05-19 16:29:46 +1000728 * This code relies on the assumption that if the update_* fields
729 * of the inode are clear and the inode is unpinned then it is clean
730 * and no action is required.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 */
732 xfs_ilock(ip, XFS_ILOCK_SHARED);
733
David Chinner978b7232008-05-19 16:29:46 +1000734 if (!(ip->i_update_size || ip->i_update_core)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 /*
David Chinner978b7232008-05-19 16:29:46 +1000736 * Timestamps/size haven't changed since last inode flush or
737 * inode transaction commit. That means either nothing got
738 * written or a transaction committed which caught the updates.
739 * If the latter happened and the transaction hasn't hit the
740 * disk yet, the inode will be still be pinned. If it is,
741 * force the log.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 */
743
744 xfs_iunlock(ip, XFS_ILOCK_SHARED);
745
746 if (xfs_ipincount(ip)) {
David Chinner978b7232008-05-19 16:29:46 +1000747 error = _xfs_log_force(ip->i_mount, (xfs_lsn_t)0,
748 XFS_LOG_FORCE | XFS_LOG_SYNC,
Christoph Hellwigf538d4d2005-11-02 10:26:59 +1100749 &log_flushed);
750 } else {
751 /*
David Chinner978b7232008-05-19 16:29:46 +1000752 * If the inode is not pinned and nothing has changed
753 * we don't need to flush the cache.
Christoph Hellwigf538d4d2005-11-02 10:26:59 +1100754 */
755 changed = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 } else {
758 /*
David Chinner978b7232008-05-19 16:29:46 +1000759 * Kick off a transaction to log the inode core to get the
760 * updates. The sync transaction will also force the log.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 */
762 xfs_iunlock(ip, XFS_ILOCK_SHARED);
763 tp = xfs_trans_alloc(ip->i_mount, XFS_TRANS_FSYNC_TS);
David Chinner978b7232008-05-19 16:29:46 +1000764 error = xfs_trans_reserve(tp, 0,
765 XFS_FSYNC_TS_LOG_RES(ip->i_mount), 0, 0, 0);
766 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767 xfs_trans_cancel(tp, 0);
768 return error;
769 }
770 xfs_ilock(ip, XFS_ILOCK_EXCL);
771
772 /*
David Chinner978b7232008-05-19 16:29:46 +1000773 * Note - it's possible that we might have pushed ourselves out
774 * of the way during trans_reserve which would flush the inode.
775 * But there's no guarantee that the inode buffer has actually
776 * gone out yet (it's delwri). Plus the buffer could be pinned
777 * anyway if it's part of an inode in another recent
778 * transaction. So we play it safe and fire off the
779 * transaction anyway.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780 */
781 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
782 xfs_trans_ihold(tp, ip);
783 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
David Chinner978b7232008-05-19 16:29:46 +1000784 xfs_trans_set_sync(tp);
Eric Sandeen1c72bf92007-05-08 13:48:42 +1000785 error = _xfs_trans_commit(tp, 0, &log_flushed);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786
787 xfs_iunlock(ip, XFS_ILOCK_EXCL);
788 }
Christoph Hellwigf538d4d2005-11-02 10:26:59 +1100789
790 if ((ip->i_mount->m_flags & XFS_MOUNT_BARRIER) && changed) {
791 /*
792 * If the log write didn't issue an ordered tag we need
793 * to flush the disk cache for the data device now.
794 */
795 if (!log_flushed)
796 xfs_blkdev_issue_flush(ip->i_mount->m_ddev_targp);
797
798 /*
799 * If this inode is on the RT dev we need to flush that
Nathan Scottc41564b2006-03-29 08:55:14 +1000800 * cache as well.
Christoph Hellwigf538d4d2005-11-02 10:26:59 +1100801 */
Eric Sandeen71ddabb2007-11-23 16:29:42 +1100802 if (XFS_IS_REALTIME_INODE(ip))
Christoph Hellwigf538d4d2005-11-02 10:26:59 +1100803 xfs_blkdev_issue_flush(ip->i_mount->m_rtdev_targp);
804 }
805
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 return error;
807}
808
809/*
David Chinner92dfe8d2007-05-24 15:22:19 +1000810 * This is called by xfs_inactive to free any blocks beyond eof
811 * when the link count isn't zero and by xfs_dm_punch_hole() when
812 * punching a hole to EOF.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 */
David Chinner92dfe8d2007-05-24 15:22:19 +1000814int
815xfs_free_eofblocks(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 xfs_mount_t *mp,
David Chinner92dfe8d2007-05-24 15:22:19 +1000817 xfs_inode_t *ip,
818 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819{
820 xfs_trans_t *tp;
821 int error;
822 xfs_fileoff_t end_fsb;
823 xfs_fileoff_t last_fsb;
824 xfs_filblks_t map_len;
825 int nimaps;
826 xfs_bmbt_irec_t imap;
David Chinner92dfe8d2007-05-24 15:22:19 +1000827 int use_iolock = (flags & XFS_FREE_EOF_LOCK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700828
829 /*
830 * Figure out if there are any blocks beyond the end
831 * of the file. If not, then there is nothing to do.
832 */
Lachlan McIlroyba87ea62007-05-08 13:49:46 +1000833 end_fsb = XFS_B_TO_FSB(mp, ((xfs_ufsize_t)ip->i_size));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 last_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_MAXIOFFSET(mp));
835 map_len = last_fsb - end_fsb;
836 if (map_len <= 0)
Jesper Juhl014c2542006-01-15 02:37:08 +0100837 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838
839 nimaps = 1;
840 xfs_ilock(ip, XFS_ILOCK_SHARED);
Lachlan McIlroy541d7d32007-10-11 17:34:33 +1000841 error = xfs_bmapi(NULL, ip, end_fsb, map_len, 0,
Olaf Weber3e57ecf2006-06-09 14:48:12 +1000842 NULL, 0, &imap, &nimaps, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 xfs_iunlock(ip, XFS_ILOCK_SHARED);
844
845 if (!error && (nimaps != 0) &&
Yingping Lu68bdb6e2006-01-11 15:38:31 +1100846 (imap.br_startblock != HOLESTARTBLOCK ||
847 ip->i_delayed_blks)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 /*
849 * Attach the dquots to the inode up front.
850 */
851 if ((error = XFS_QM_DQATTACH(mp, ip, 0)))
Jesper Juhl014c2542006-01-15 02:37:08 +0100852 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853
854 /*
855 * There are blocks after the end of file.
856 * Free them up now by truncating the file to
857 * its current size.
858 */
859 tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
860
861 /*
862 * Do the xfs_itruncate_start() call before
863 * reserving any log space because
864 * itruncate_start will call into the buffer
865 * cache and we can't
866 * do that within a transaction.
867 */
David Chinner92dfe8d2007-05-24 15:22:19 +1000868 if (use_iolock)
869 xfs_ilock(ip, XFS_IOLOCK_EXCL);
Lachlan McIlroyd3cf2092007-05-08 13:49:27 +1000870 error = xfs_itruncate_start(ip, XFS_ITRUNC_DEFINITE,
Lachlan McIlroyba87ea62007-05-08 13:49:46 +1000871 ip->i_size);
Lachlan McIlroyd3cf2092007-05-08 13:49:27 +1000872 if (error) {
Jesper Juhl87ae3c22007-06-28 16:43:14 +1000873 xfs_trans_cancel(tp, 0);
David Chinner92dfe8d2007-05-24 15:22:19 +1000874 if (use_iolock)
875 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
Lachlan McIlroyd3cf2092007-05-08 13:49:27 +1000876 return error;
877 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878
879 error = xfs_trans_reserve(tp, 0,
880 XFS_ITRUNCATE_LOG_RES(mp),
881 0, XFS_TRANS_PERM_LOG_RES,
882 XFS_ITRUNCATE_LOG_COUNT);
883 if (error) {
884 ASSERT(XFS_FORCED_SHUTDOWN(mp));
885 xfs_trans_cancel(tp, 0);
886 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
Jesper Juhl014c2542006-01-15 02:37:08 +0100887 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 }
889
890 xfs_ilock(ip, XFS_ILOCK_EXCL);
891 xfs_trans_ijoin(tp, ip,
892 XFS_IOLOCK_EXCL |
893 XFS_ILOCK_EXCL);
894 xfs_trans_ihold(tp, ip);
895
896 error = xfs_itruncate_finish(&tp, ip,
Lachlan McIlroyba87ea62007-05-08 13:49:46 +1000897 ip->i_size,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 XFS_DATA_FORK,
899 0);
900 /*
901 * If we get an error at this point we
902 * simply don't bother truncating the file.
903 */
904 if (error) {
905 xfs_trans_cancel(tp,
906 (XFS_TRANS_RELEASE_LOG_RES |
907 XFS_TRANS_ABORT));
908 } else {
909 error = xfs_trans_commit(tp,
Eric Sandeen1c72bf92007-05-08 13:48:42 +1000910 XFS_TRANS_RELEASE_LOG_RES);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911 }
David Chinner92dfe8d2007-05-24 15:22:19 +1000912 xfs_iunlock(ip, (use_iolock ? (XFS_IOLOCK_EXCL|XFS_ILOCK_EXCL)
913 : XFS_ILOCK_EXCL));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914 }
Jesper Juhl014c2542006-01-15 02:37:08 +0100915 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916}
917
918/*
919 * Free a symlink that has blocks associated with it.
920 */
921STATIC int
922xfs_inactive_symlink_rmt(
923 xfs_inode_t *ip,
924 xfs_trans_t **tpp)
925{
926 xfs_buf_t *bp;
927 int committed;
928 int done;
929 int error;
930 xfs_fsblock_t first_block;
931 xfs_bmap_free_t free_list;
932 int i;
933 xfs_mount_t *mp;
934 xfs_bmbt_irec_t mval[SYMLINK_MAPS];
935 int nmaps;
936 xfs_trans_t *ntp;
937 int size;
938 xfs_trans_t *tp;
939
940 tp = *tpp;
941 mp = ip->i_mount;
942 ASSERT(ip->i_d.di_size > XFS_IFORK_DSIZE(ip));
943 /*
944 * We're freeing a symlink that has some
945 * blocks allocated to it. Free the
946 * blocks here. We know that we've got
947 * either 1 or 2 extents and that we can
948 * free them all in one bunmapi call.
949 */
950 ASSERT(ip->i_d.di_nextents > 0 && ip->i_d.di_nextents <= 2);
951 if ((error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0,
952 XFS_TRANS_PERM_LOG_RES, XFS_ITRUNCATE_LOG_COUNT))) {
953 ASSERT(XFS_FORCED_SHUTDOWN(mp));
954 xfs_trans_cancel(tp, 0);
955 *tpp = NULL;
956 return error;
957 }
958 /*
959 * Lock the inode, fix the size, and join it to the transaction.
960 * Hold it so in the normal path, we still have it locked for
961 * the second transaction. In the error paths we need it
962 * held so the cancel won't rele it, see below.
963 */
964 xfs_ilock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
965 size = (int)ip->i_d.di_size;
966 ip->i_d.di_size = 0;
967 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
968 xfs_trans_ihold(tp, ip);
969 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
970 /*
971 * Find the block(s) so we can inval and unmap them.
972 */
973 done = 0;
974 XFS_BMAP_INIT(&free_list, &first_block);
Tobias Klausere8c96f82006-03-24 03:15:34 -0800975 nmaps = ARRAY_SIZE(mval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700976 if ((error = xfs_bmapi(tp, ip, 0, XFS_B_TO_FSB(mp, size),
977 XFS_BMAPI_METADATA, &first_block, 0, mval, &nmaps,
Olaf Weber3e57ecf2006-06-09 14:48:12 +1000978 &free_list, NULL)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979 goto error0;
980 /*
981 * Invalidate the block(s).
982 */
983 for (i = 0; i < nmaps; i++) {
984 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp,
985 XFS_FSB_TO_DADDR(mp, mval[i].br_startblock),
986 XFS_FSB_TO_BB(mp, mval[i].br_blockcount), 0);
987 xfs_trans_binval(tp, bp);
988 }
989 /*
990 * Unmap the dead block(s) to the free_list.
991 */
992 if ((error = xfs_bunmapi(tp, ip, 0, size, XFS_BMAPI_METADATA, nmaps,
Olaf Weber3e57ecf2006-06-09 14:48:12 +1000993 &first_block, &free_list, NULL, &done)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994 goto error1;
995 ASSERT(done);
996 /*
997 * Commit the first transaction. This logs the EFI and the inode.
998 */
Eric Sandeenf7c99b62007-02-10 18:37:16 +1100999 if ((error = xfs_bmap_finish(&tp, &free_list, &committed)))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 goto error1;
1001 /*
1002 * The transaction must have been committed, since there were
1003 * actually extents freed by xfs_bunmapi. See xfs_bmap_finish.
1004 * The new tp has the extent freeing and EFDs.
1005 */
1006 ASSERT(committed);
1007 /*
1008 * The first xact was committed, so add the inode to the new one.
1009 * Mark it dirty so it will be logged and moved forward in the log as
1010 * part of every commit.
1011 */
1012 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
1013 xfs_trans_ihold(tp, ip);
1014 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
1015 /*
1016 * Get a new, empty transaction to return to our caller.
1017 */
1018 ntp = xfs_trans_dup(tp);
1019 /*
Nathan Scottc41564b2006-03-29 08:55:14 +10001020 * Commit the transaction containing extent freeing and EFDs.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021 * If we get an error on the commit here or on the reserve below,
1022 * we need to unlock the inode since the new transaction doesn't
1023 * have the inode attached.
1024 */
Eric Sandeen1c72bf92007-05-08 13:48:42 +10001025 error = xfs_trans_commit(tp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 tp = ntp;
1027 if (error) {
1028 ASSERT(XFS_FORCED_SHUTDOWN(mp));
1029 goto error0;
1030 }
1031 /*
1032 * Remove the memory for extent descriptions (just bookkeeping).
1033 */
1034 if (ip->i_df.if_bytes)
1035 xfs_idata_realloc(ip, -ip->i_df.if_bytes, XFS_DATA_FORK);
1036 ASSERT(ip->i_df.if_bytes == 0);
1037 /*
1038 * Put an itruncate log reservation in the new transaction
1039 * for our caller.
1040 */
1041 if ((error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0,
1042 XFS_TRANS_PERM_LOG_RES, XFS_ITRUNCATE_LOG_COUNT))) {
1043 ASSERT(XFS_FORCED_SHUTDOWN(mp));
1044 goto error0;
1045 }
1046 /*
1047 * Return with the inode locked but not joined to the transaction.
1048 */
1049 *tpp = tp;
1050 return 0;
1051
1052 error1:
1053 xfs_bmap_cancel(&free_list);
1054 error0:
1055 /*
1056 * Have to come here with the inode locked and either
1057 * (held and in the transaction) or (not in the transaction).
1058 * If the inode isn't held then cancel would iput it, but
1059 * that's wrong since this is inactive and the vnode ref
1060 * count is 0 already.
1061 * Cancel won't do anything to the inode if held, but it still
1062 * needs to be locked until the cancel is done, if it was
1063 * joined to the transaction.
1064 */
1065 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
1066 xfs_iunlock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1067 *tpp = NULL;
1068 return error;
1069
1070}
1071
1072STATIC int
1073xfs_inactive_symlink_local(
1074 xfs_inode_t *ip,
1075 xfs_trans_t **tpp)
1076{
1077 int error;
1078
1079 ASSERT(ip->i_d.di_size <= XFS_IFORK_DSIZE(ip));
1080 /*
1081 * We're freeing a symlink which fit into
1082 * the inode. Just free the memory used
1083 * to hold the old symlink.
1084 */
1085 error = xfs_trans_reserve(*tpp, 0,
1086 XFS_ITRUNCATE_LOG_RES(ip->i_mount),
1087 0, XFS_TRANS_PERM_LOG_RES,
1088 XFS_ITRUNCATE_LOG_COUNT);
1089
1090 if (error) {
1091 xfs_trans_cancel(*tpp, 0);
1092 *tpp = NULL;
Jesper Juhl014c2542006-01-15 02:37:08 +01001093 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001094 }
1095 xfs_ilock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
1096
1097 /*
1098 * Zero length symlinks _can_ exist.
1099 */
1100 if (ip->i_df.if_bytes > 0) {
1101 xfs_idata_realloc(ip,
1102 -(ip->i_df.if_bytes),
1103 XFS_DATA_FORK);
1104 ASSERT(ip->i_df.if_bytes == 0);
1105 }
Jesper Juhl014c2542006-01-15 02:37:08 +01001106 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107}
1108
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109STATIC int
1110xfs_inactive_attrs(
1111 xfs_inode_t *ip,
1112 xfs_trans_t **tpp)
1113{
1114 xfs_trans_t *tp;
1115 int error;
1116 xfs_mount_t *mp;
1117
Christoph Hellwig579aa9c2008-04-22 17:34:00 +10001118 ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119 tp = *tpp;
1120 mp = ip->i_mount;
1121 ASSERT(ip->i_d.di_forkoff != 0);
David Chinnere5720ee2008-04-10 12:21:18 +10001122 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123 xfs_iunlock(ip, XFS_ILOCK_EXCL);
David Chinnere5720ee2008-04-10 12:21:18 +10001124 if (error)
1125 goto error_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126
1127 error = xfs_attr_inactive(ip);
David Chinnere5720ee2008-04-10 12:21:18 +10001128 if (error)
1129 goto error_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130
1131 tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
1132 error = xfs_trans_reserve(tp, 0,
1133 XFS_IFREE_LOG_RES(mp),
1134 0, XFS_TRANS_PERM_LOG_RES,
1135 XFS_INACTIVE_LOG_COUNT);
David Chinnere5720ee2008-04-10 12:21:18 +10001136 if (error)
1137 goto error_cancel;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138
1139 xfs_ilock(ip, XFS_ILOCK_EXCL);
1140 xfs_trans_ijoin(tp, ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1141 xfs_trans_ihold(tp, ip);
1142 xfs_idestroy_fork(ip, XFS_ATTR_FORK);
1143
1144 ASSERT(ip->i_d.di_anextents == 0);
1145
1146 *tpp = tp;
Jesper Juhl014c2542006-01-15 02:37:08 +01001147 return 0;
David Chinnere5720ee2008-04-10 12:21:18 +10001148
1149error_cancel:
1150 ASSERT(XFS_FORCED_SHUTDOWN(mp));
1151 xfs_trans_cancel(tp, 0);
1152error_unlock:
1153 *tpp = NULL;
1154 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
1155 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156}
1157
Christoph Hellwig993386c2007-08-28 16:12:30 +10001158int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159xfs_release(
Christoph Hellwig993386c2007-08-28 16:12:30 +10001160 xfs_inode_t *ip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161{
Christoph Hellwig993386c2007-08-28 16:12:30 +10001162 xfs_mount_t *mp = ip->i_mount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001163 int error;
1164
Christoph Hellwig42173f62008-04-22 17:33:25 +10001165 if (!S_ISREG(ip->i_d.di_mode) || (ip->i_d.di_mode == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167
1168 /* If this is a read-only mount, don't do this (would generate I/O) */
Christoph Hellwigbd186aa2007-08-30 17:21:12 +10001169 if (mp->m_flags & XFS_MOUNT_RDONLY)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 return 0;
1171
David Chinner2a82b8b2007-07-11 11:09:12 +10001172 if (!XFS_FORCED_SHUTDOWN(mp)) {
Christoph Hellwigb3aea4e2007-08-29 11:44:37 +10001173 int truncated;
1174
David Chinner2a82b8b2007-07-11 11:09:12 +10001175 /*
1176 * If we are using filestreams, and we have an unlinked
1177 * file that we are processing the last close on, then nothing
1178 * will be able to reopen and write to this file. Purge this
1179 * inode from the filestreams cache so that it doesn't delay
1180 * teardown of the inode.
1181 */
1182 if ((ip->i_d.di_nlink == 0) && xfs_inode_is_filestream(ip))
1183 xfs_filestream_deassociate(ip);
1184
Christoph Hellwigfbf3ce82007-06-28 16:46:47 +10001185 /*
1186 * If we previously truncated this file and removed old data
1187 * in the process, we want to initiate "early" writeout on
1188 * the last close. This is an attempt to combat the notorious
1189 * NULL files problem which is particularly noticable from a
1190 * truncate down, buffered (re-)write (delalloc), followed by
1191 * a crash. What we are effectively doing here is
1192 * significantly reducing the time window where we'd otherwise
1193 * be exposed to that problem.
1194 */
Christoph Hellwig09262b42007-08-29 11:44:50 +10001195 truncated = xfs_iflags_test_and_clear(ip, XFS_ITRUNCATED);
Christoph Hellwigdf80c932008-08-13 16:22:09 +10001196 if (truncated && VN_DIRTY(VFS_I(ip)) && ip->i_delayed_blks > 0)
Christoph Hellwig739bfb22007-08-29 10:58:01 +10001197 xfs_flush_pages(ip, 0, -1, XFS_B_ASYNC, FI_NONE);
Christoph Hellwigfbf3ce82007-06-28 16:46:47 +10001198 }
1199
Linus Torvalds1da177e2005-04-16 15:20:36 -07001200 if (ip->i_d.di_nlink != 0) {
1201 if ((((ip->i_d.di_mode & S_IFMT) == S_IFREG) &&
Christoph Hellwigdf80c932008-08-13 16:22:09 +10001202 ((ip->i_size > 0) || (VN_CACHED(VFS_I(ip)) > 0 ||
Yingping Lu68bdb6e2006-01-11 15:38:31 +11001203 ip->i_delayed_blks > 0)) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001204 (ip->i_df.if_flags & XFS_IFEXTENTS)) &&
Nathan Scottdd9f4382006-01-11 15:28:28 +11001205 (!(ip->i_d.di_flags &
1206 (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)))) {
David Chinner92dfe8d2007-05-24 15:22:19 +10001207 error = xfs_free_eofblocks(mp, ip, XFS_FREE_EOF_LOCK);
1208 if (error)
Jesper Juhl014c2542006-01-15 02:37:08 +01001209 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210 }
1211 }
1212
1213 return 0;
1214}
1215
1216/*
1217 * xfs_inactive
1218 *
1219 * This is called when the vnode reference count for the vnode
1220 * goes to zero. If the file has been unlinked, then it must
1221 * now be truncated. Also, we clear all of the read-ahead state
1222 * kept for the inode here since the file is now closed.
1223 */
Christoph Hellwig993386c2007-08-28 16:12:30 +10001224int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225xfs_inactive(
Christoph Hellwig993386c2007-08-28 16:12:30 +10001226 xfs_inode_t *ip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227{
Nathan Scott67fcaa72006-06-09 17:00:52 +10001228 xfs_bmap_free_t free_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229 xfs_fsblock_t first_block;
1230 int committed;
1231 xfs_trans_t *tp;
1232 xfs_mount_t *mp;
1233 int error;
1234 int truncate;
1235
Lachlan McIlroycf441ee2008-02-07 16:42:19 +11001236 xfs_itrace_entry(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238 /*
1239 * If the inode is already free, then there can be nothing
1240 * to clean up here.
1241 */
Christoph Hellwigdf80c932008-08-13 16:22:09 +10001242 if (ip->i_d.di_mode == 0 || VN_BAD(VFS_I(ip))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001243 ASSERT(ip->i_df.if_real_bytes == 0);
1244 ASSERT(ip->i_df.if_broot_bytes == 0);
1245 return VN_INACTIVE_CACHE;
1246 }
1247
1248 /*
1249 * Only do a truncate if it's a regular file with
1250 * some actual space in it. It's OK to look at the
1251 * inode's fields without the lock because we're the
1252 * only one with a reference to the inode.
1253 */
1254 truncate = ((ip->i_d.di_nlink == 0) &&
Lachlan McIlroyba87ea62007-05-08 13:49:46 +10001255 ((ip->i_d.di_size != 0) || (ip->i_size != 0) ||
1256 (ip->i_d.di_nextents > 0) || (ip->i_delayed_blks > 0)) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 ((ip->i_d.di_mode & S_IFMT) == S_IFREG));
1258
1259 mp = ip->i_mount;
1260
Christoph Hellwigbc4ac742008-03-06 13:45:58 +11001261 if (ip->i_d.di_nlink == 0 && DM_EVENT_ENABLED(ip, DM_EVENT_DESTROY))
1262 XFS_SEND_DESTROY(mp, ip, DM_RIGHT_NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263
1264 error = 0;
1265
1266 /* If this is a read-only mount, don't do this (would generate I/O) */
Christoph Hellwigbd186aa2007-08-30 17:21:12 +10001267 if (mp->m_flags & XFS_MOUNT_RDONLY)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 goto out;
1269
1270 if (ip->i_d.di_nlink != 0) {
1271 if ((((ip->i_d.di_mode & S_IFMT) == S_IFREG) &&
Christoph Hellwigdf80c932008-08-13 16:22:09 +10001272 ((ip->i_size > 0) || (VN_CACHED(VFS_I(ip)) > 0 ||
Yingping Lu68bdb6e2006-01-11 15:38:31 +11001273 ip->i_delayed_blks > 0)) &&
Nathan Scottdd9f4382006-01-11 15:28:28 +11001274 (ip->i_df.if_flags & XFS_IFEXTENTS) &&
1275 (!(ip->i_d.di_flags &
1276 (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)) ||
1277 (ip->i_delayed_blks != 0)))) {
David Chinner92dfe8d2007-05-24 15:22:19 +10001278 error = xfs_free_eofblocks(mp, ip, XFS_FREE_EOF_LOCK);
1279 if (error)
Jesper Juhl014c2542006-01-15 02:37:08 +01001280 return VN_INACTIVE_CACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 }
1282 goto out;
1283 }
1284
1285 ASSERT(ip->i_d.di_nlink == 0);
1286
1287 if ((error = XFS_QM_DQATTACH(mp, ip, 0)))
Jesper Juhl014c2542006-01-15 02:37:08 +01001288 return VN_INACTIVE_CACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289
1290 tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
1291 if (truncate) {
1292 /*
1293 * Do the xfs_itruncate_start() call before
1294 * reserving any log space because itruncate_start
1295 * will call into the buffer cache and we can't
1296 * do that within a transaction.
1297 */
1298 xfs_ilock(ip, XFS_IOLOCK_EXCL);
1299
Lachlan McIlroyd3cf2092007-05-08 13:49:27 +10001300 error = xfs_itruncate_start(ip, XFS_ITRUNC_DEFINITE, 0);
1301 if (error) {
Jesper Juhl87ae3c22007-06-28 16:43:14 +10001302 xfs_trans_cancel(tp, 0);
Lachlan McIlroyd3cf2092007-05-08 13:49:27 +10001303 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
1304 return VN_INACTIVE_CACHE;
1305 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306
1307 error = xfs_trans_reserve(tp, 0,
1308 XFS_ITRUNCATE_LOG_RES(mp),
1309 0, XFS_TRANS_PERM_LOG_RES,
1310 XFS_ITRUNCATE_LOG_COUNT);
1311 if (error) {
1312 /* Don't call itruncate_cleanup */
1313 ASSERT(XFS_FORCED_SHUTDOWN(mp));
1314 xfs_trans_cancel(tp, 0);
1315 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
Jesper Juhl014c2542006-01-15 02:37:08 +01001316 return VN_INACTIVE_CACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 }
1318
1319 xfs_ilock(ip, XFS_ILOCK_EXCL);
1320 xfs_trans_ijoin(tp, ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1321 xfs_trans_ihold(tp, ip);
1322
1323 /*
1324 * normally, we have to run xfs_itruncate_finish sync.
1325 * But if filesystem is wsync and we're in the inactive
1326 * path, then we know that nlink == 0, and that the
1327 * xaction that made nlink == 0 is permanently committed
1328 * since xfs_remove runs as a synchronous transaction.
1329 */
1330 error = xfs_itruncate_finish(&tp, ip, 0, XFS_DATA_FORK,
1331 (!(mp->m_flags & XFS_MOUNT_WSYNC) ? 1 : 0));
1332
1333 if (error) {
1334 xfs_trans_cancel(tp,
1335 XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
1336 xfs_iunlock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
Jesper Juhl014c2542006-01-15 02:37:08 +01001337 return VN_INACTIVE_CACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 }
1339 } else if ((ip->i_d.di_mode & S_IFMT) == S_IFLNK) {
1340
1341 /*
1342 * If we get an error while cleaning up a
1343 * symlink we bail out.
1344 */
1345 error = (ip->i_d.di_size > XFS_IFORK_DSIZE(ip)) ?
1346 xfs_inactive_symlink_rmt(ip, &tp) :
1347 xfs_inactive_symlink_local(ip, &tp);
1348
1349 if (error) {
1350 ASSERT(tp == NULL);
Jesper Juhl014c2542006-01-15 02:37:08 +01001351 return VN_INACTIVE_CACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352 }
1353
1354 xfs_trans_ijoin(tp, ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1355 xfs_trans_ihold(tp, ip);
1356 } else {
1357 error = xfs_trans_reserve(tp, 0,
1358 XFS_IFREE_LOG_RES(mp),
1359 0, XFS_TRANS_PERM_LOG_RES,
1360 XFS_INACTIVE_LOG_COUNT);
1361 if (error) {
1362 ASSERT(XFS_FORCED_SHUTDOWN(mp));
1363 xfs_trans_cancel(tp, 0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001364 return VN_INACTIVE_CACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 }
1366
1367 xfs_ilock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
1368 xfs_trans_ijoin(tp, ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1369 xfs_trans_ihold(tp, ip);
1370 }
1371
1372 /*
1373 * If there are attributes associated with the file
1374 * then blow them away now. The code calls a routine
1375 * that recursively deconstructs the attribute fork.
1376 * We need to just commit the current transaction
1377 * because we can't use it for xfs_attr_inactive().
1378 */
1379 if (ip->i_d.di_anextents > 0) {
1380 error = xfs_inactive_attrs(ip, &tp);
1381 /*
1382 * If we got an error, the transaction is already
1383 * cancelled, and the inode is unlocked. Just get out.
1384 */
1385 if (error)
Jesper Juhl014c2542006-01-15 02:37:08 +01001386 return VN_INACTIVE_CACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387 } else if (ip->i_afp) {
1388 xfs_idestroy_fork(ip, XFS_ATTR_FORK);
1389 }
1390
1391 /*
1392 * Free the inode.
1393 */
1394 XFS_BMAP_INIT(&free_list, &first_block);
1395 error = xfs_ifree(tp, ip, &free_list);
1396 if (error) {
1397 /*
1398 * If we fail to free the inode, shut down. The cancel
1399 * might do that, we need to make sure. Otherwise the
1400 * inode might be lost for a long time or forever.
1401 */
1402 if (!XFS_FORCED_SHUTDOWN(mp)) {
1403 cmn_err(CE_NOTE,
1404 "xfs_inactive: xfs_ifree() returned an error = %d on %s",
1405 error, mp->m_fsname);
Nathan Scott7d04a332006-06-09 14:58:38 +10001406 xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 }
1408 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES|XFS_TRANS_ABORT);
1409 } else {
1410 /*
1411 * Credit the quota account(s). The inode is gone.
1412 */
1413 XFS_TRANS_MOD_DQUOT_BYINO(mp, tp, ip, XFS_TRANS_DQ_ICOUNT, -1);
1414
1415 /*
David Chinner78e9da72008-04-10 12:24:17 +10001416 * Just ignore errors at this point. There is nothing we can
1417 * do except to try to keep going. Make sure it's not a silent
1418 * error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001419 */
David Chinner78e9da72008-04-10 12:24:17 +10001420 error = xfs_bmap_finish(&tp, &free_list, &committed);
1421 if (error)
1422 xfs_fs_cmn_err(CE_NOTE, mp, "xfs_inactive: "
1423 "xfs_bmap_finish() returned error %d", error);
1424 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
1425 if (error)
1426 xfs_fs_cmn_err(CE_NOTE, mp, "xfs_inactive: "
1427 "xfs_trans_commit() returned error %d", error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428 }
1429 /*
1430 * Release the dquots held by inode, if any.
1431 */
1432 XFS_QM_DQDETACH(mp, ip);
1433
1434 xfs_iunlock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1435
1436 out:
1437 return VN_INACTIVE_CACHE;
1438}
1439
Barry Naujok384f3ce2008-05-21 16:58:22 +10001440/*
1441 * Lookups up an inode from "name". If ci_name is not NULL, then a CI match
1442 * is allowed, otherwise it has to be an exact match. If a CI match is found,
1443 * ci_name->name will point to a the actual name (caller must free) or
1444 * will be set to NULL if an exact match is found.
1445 */
Christoph Hellwig993386c2007-08-28 16:12:30 +10001446int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447xfs_lookup(
Christoph Hellwig993386c2007-08-28 16:12:30 +10001448 xfs_inode_t *dp,
Barry Naujok556b8b12008-04-10 12:22:07 +10001449 struct xfs_name *name,
Barry Naujok384f3ce2008-05-21 16:58:22 +10001450 xfs_inode_t **ipp,
1451 struct xfs_name *ci_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452{
Christoph Hellwigeca450b2008-04-22 17:33:52 +10001453 xfs_ino_t inum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454 int error;
1455 uint lock_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456
Lachlan McIlroycf441ee2008-02-07 16:42:19 +11001457 xfs_itrace_entry(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458
1459 if (XFS_FORCED_SHUTDOWN(dp->i_mount))
1460 return XFS_ERROR(EIO);
1461
1462 lock_mode = xfs_ilock_map_shared(dp);
Barry Naujok384f3ce2008-05-21 16:58:22 +10001463 error = xfs_dir_lookup(NULL, dp, name, &inum, ci_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464 xfs_iunlock_map_shared(dp, lock_mode);
Christoph Hellwigeca450b2008-04-22 17:33:52 +10001465
1466 if (error)
1467 goto out;
1468
1469 error = xfs_iget(dp->i_mount, NULL, inum, 0, 0, ipp, 0);
1470 if (error)
Barry Naujok384f3ce2008-05-21 16:58:22 +10001471 goto out_free_name;
Christoph Hellwigeca450b2008-04-22 17:33:52 +10001472
1473 xfs_itrace_ref(*ipp);
1474 return 0;
1475
Barry Naujok384f3ce2008-05-21 16:58:22 +10001476out_free_name:
1477 if (ci_name)
1478 kmem_free(ci_name->name);
1479out:
Christoph Hellwigeca450b2008-04-22 17:33:52 +10001480 *ipp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481 return error;
1482}
1483
Christoph Hellwig993386c2007-08-28 16:12:30 +10001484int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001485xfs_create(
Christoph Hellwig993386c2007-08-28 16:12:30 +10001486 xfs_inode_t *dp,
Barry Naujok556b8b12008-04-10 12:22:07 +10001487 struct xfs_name *name,
Christoph Hellwig3e5daf02007-10-11 18:09:12 +10001488 mode_t mode,
1489 xfs_dev_t rdev,
Christoph Hellwig979ebab2008-03-06 13:46:05 +11001490 xfs_inode_t **ipp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001491 cred_t *credp)
1492{
Barry Naujok556b8b12008-04-10 12:22:07 +10001493 xfs_mount_t *mp = dp->i_mount;
Christoph Hellwig993386c2007-08-28 16:12:30 +10001494 xfs_inode_t *ip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495 xfs_trans_t *tp;
Barry Naujok556b8b12008-04-10 12:22:07 +10001496 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 xfs_bmap_free_t free_list;
1498 xfs_fsblock_t first_block;
Christoph Hellwig993386c2007-08-28 16:12:30 +10001499 boolean_t unlock_dp_on_error = B_FALSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001500 int dm_event_sent = 0;
1501 uint cancel_flags;
1502 int committed;
1503 xfs_prid_t prid;
1504 struct xfs_dquot *udqp, *gdqp;
1505 uint resblks;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506
Christoph Hellwig979ebab2008-03-06 13:46:05 +11001507 ASSERT(!*ipp);
Lachlan McIlroycf441ee2008-02-07 16:42:19 +11001508 xfs_itrace_entry(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509
Christoph Hellwigeb9df392007-08-16 18:42:07 +10001510 if (DM_EVENT_ENABLED(dp, DM_EVENT_CREATE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511 error = XFS_SEND_NAMESP(mp, DM_EVENT_CREATE,
Christoph Hellwigbc4ac742008-03-06 13:45:58 +11001512 dp, DM_RIGHT_NULL, NULL,
Barry Naujok556b8b12008-04-10 12:22:07 +10001513 DM_RIGHT_NULL, name->name, NULL,
Christoph Hellwig3e5daf02007-10-11 18:09:12 +10001514 mode, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515
1516 if (error)
1517 return error;
1518 dm_event_sent = 1;
1519 }
1520
1521 if (XFS_FORCED_SHUTDOWN(mp))
1522 return XFS_ERROR(EIO);
1523
1524 /* Return through std_return after this point. */
1525
1526 udqp = gdqp = NULL;
Nathan Scott365ca832005-06-21 15:39:12 +10001527 if (dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
1528 prid = dp->i_d.di_projid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529 else
1530 prid = (xfs_prid_t)dfltprid;
1531
1532 /*
1533 * Make sure that we have allocated dquot(s) on disk.
1534 */
1535 error = XFS_QM_DQVOPALLOC(mp, dp,
David Howells9e2b2dc2008-08-13 16:20:04 +01001536 current_fsuid(), current_fsgid(), prid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537 XFS_QMOPT_QUOTALL|XFS_QMOPT_INHERIT, &udqp, &gdqp);
1538 if (error)
1539 goto std_return;
1540
1541 ip = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001542
1543 tp = xfs_trans_alloc(mp, XFS_TRANS_CREATE);
1544 cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
Barry Naujok556b8b12008-04-10 12:22:07 +10001545 resblks = XFS_CREATE_SPACE_RES(mp, name->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001546 /*
1547 * Initially assume that the file does not exist and
1548 * reserve the resources for that case. If that is not
1549 * the case we'll drop the one we have and get a more
1550 * appropriate transaction later.
1551 */
1552 error = xfs_trans_reserve(tp, resblks, XFS_CREATE_LOG_RES(mp), 0,
1553 XFS_TRANS_PERM_LOG_RES, XFS_CREATE_LOG_COUNT);
1554 if (error == ENOSPC) {
1555 resblks = 0;
1556 error = xfs_trans_reserve(tp, 0, XFS_CREATE_LOG_RES(mp), 0,
1557 XFS_TRANS_PERM_LOG_RES, XFS_CREATE_LOG_COUNT);
1558 }
1559 if (error) {
1560 cancel_flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 goto error_return;
1562 }
1563
Lachlan McIlroyf7c66ce2007-05-08 13:50:19 +10001564 xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
Christoph Hellwig993386c2007-08-28 16:12:30 +10001565 unlock_dp_on_error = B_TRUE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001566
1567 XFS_BMAP_INIT(&free_list, &first_block);
1568
1569 ASSERT(ip == NULL);
1570
1571 /*
1572 * Reserve disk quota and the inode.
1573 */
1574 error = XFS_TRANS_RESERVE_QUOTA(mp, tp, udqp, gdqp, resblks, 1, 0);
1575 if (error)
1576 goto error_return;
1577
Barry Naujok556b8b12008-04-10 12:22:07 +10001578 error = xfs_dir_canenter(tp, dp, name, resblks);
1579 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580 goto error_return;
Christoph Hellwig3e5daf02007-10-11 18:09:12 +10001581 error = xfs_dir_ialloc(&tp, dp, mode, 1,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582 rdev, credp, prid, resblks > 0,
1583 &ip, &committed);
1584 if (error) {
1585 if (error == ENOSPC)
1586 goto error_return;
1587 goto abort_return;
1588 }
Lachlan McIlroycf441ee2008-02-07 16:42:19 +11001589 xfs_itrace_ref(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590
1591 /*
1592 * At this point, we've gotten a newly allocated inode.
1593 * It is locked (and joined to the transaction).
1594 */
1595
Christoph Hellwig579aa9c2008-04-22 17:34:00 +10001596 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001597
1598 /*
Christoph Hellwig993386c2007-08-28 16:12:30 +10001599 * Now we join the directory inode to the transaction. We do not do it
1600 * earlier because xfs_dir_ialloc might commit the previous transaction
1601 * (and release all the locks). An error from here on will result in
1602 * the transaction cancel unlocking dp so don't do it explicitly in the
1603 * error path.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604 */
Christoph Hellwig979ebab2008-03-06 13:46:05 +11001605 IHOLD(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606 xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
Christoph Hellwig993386c2007-08-28 16:12:30 +10001607 unlock_dp_on_error = B_FALSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608
Barry Naujok556b8b12008-04-10 12:22:07 +10001609 error = xfs_dir_createname(tp, dp, name, ip->i_ino,
Nathan Scottf6c2d1f2006-06-20 13:04:51 +10001610 &first_block, &free_list, resblks ?
1611 resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612 if (error) {
1613 ASSERT(error != ENOSPC);
1614 goto abort_return;
1615 }
1616 xfs_ichgtime(dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1617 xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
1618
1619 /*
1620 * If this is a synchronous mount, make sure that the
1621 * create transaction goes to disk before returning to
1622 * the user.
1623 */
1624 if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
1625 xfs_trans_set_sync(tp);
1626 }
1627
1628 dp->i_gen++;
1629
1630 /*
1631 * Attach the dquot(s) to the inodes and modify them incore.
1632 * These ids of the inode couldn't have changed since the new
1633 * inode has been locked ever since it was created.
1634 */
1635 XFS_QM_DQVOPCREATE(mp, tp, ip, udqp, gdqp);
1636
1637 /*
1638 * xfs_trans_commit normally decrements the vnode ref count
1639 * when it unlocks the inode. Since we want to return the
1640 * vnode to the caller, we bump the vnode ref count now.
1641 */
1642 IHOLD(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643
Eric Sandeenf7c99b62007-02-10 18:37:16 +11001644 error = xfs_bmap_finish(&tp, &free_list, &committed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645 if (error) {
1646 xfs_bmap_cancel(&free_list);
1647 goto abort_rele;
1648 }
1649
Eric Sandeen1c72bf92007-05-08 13:48:42 +10001650 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 if (error) {
1652 IRELE(ip);
1653 tp = NULL;
1654 goto error_return;
1655 }
1656
1657 XFS_QM_DQRELE(mp, udqp);
1658 XFS_QM_DQRELE(mp, gdqp);
1659
Christoph Hellwig979ebab2008-03-06 13:46:05 +11001660 *ipp = ip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661
1662 /* Fallthrough to std_return with error = 0 */
1663
1664std_return:
Christoph Hellwig979ebab2008-03-06 13:46:05 +11001665 if ((*ipp || (error != 0 && dm_event_sent != 0)) &&
Christoph Hellwig993386c2007-08-28 16:12:30 +10001666 DM_EVENT_ENABLED(dp, DM_EVENT_POSTCREATE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667 (void) XFS_SEND_NAMESP(mp, DM_EVENT_POSTCREATE,
Christoph Hellwigbc4ac742008-03-06 13:45:58 +11001668 dp, DM_RIGHT_NULL,
Christoph Hellwig979ebab2008-03-06 13:46:05 +11001669 *ipp ? ip : NULL,
Barry Naujok556b8b12008-04-10 12:22:07 +10001670 DM_RIGHT_NULL, name->name, NULL,
Christoph Hellwig3e5daf02007-10-11 18:09:12 +10001671 mode, error, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 }
1673 return error;
1674
1675 abort_return:
1676 cancel_flags |= XFS_TRANS_ABORT;
1677 /* FALLTHROUGH */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678
Jesper Juhl014c2542006-01-15 02:37:08 +01001679 error_return:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 if (tp != NULL)
1681 xfs_trans_cancel(tp, cancel_flags);
1682
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 XFS_QM_DQRELE(mp, udqp);
1684 XFS_QM_DQRELE(mp, gdqp);
1685
Christoph Hellwig993386c2007-08-28 16:12:30 +10001686 if (unlock_dp_on_error)
1687 xfs_iunlock(dp, XFS_ILOCK_EXCL);
1688
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689 goto std_return;
1690
1691 abort_rele:
1692 /*
1693 * Wait until after the current transaction is aborted to
1694 * release the inode. This prevents recursive transactions
1695 * and deadlocks from xfs_inactive.
1696 */
1697 cancel_flags |= XFS_TRANS_ABORT;
1698 xfs_trans_cancel(tp, cancel_flags);
1699 IRELE(ip);
1700
1701 XFS_QM_DQRELE(mp, udqp);
1702 XFS_QM_DQRELE(mp, gdqp);
1703
1704 goto std_return;
1705}
1706
1707#ifdef DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -07001708int xfs_locked_n;
1709int xfs_small_retries;
1710int xfs_middle_retries;
1711int xfs_lots_retries;
1712int xfs_lock_delays;
1713#endif
1714
1715/*
Lachlan McIlroyf7c66ce2007-05-08 13:50:19 +10001716 * Bump the subclass so xfs_lock_inodes() acquires each lock with
1717 * a different value
1718 */
1719static inline int
1720xfs_lock_inumorder(int lock_mode, int subclass)
1721{
1722 if (lock_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL))
David Chinner0f1145c2007-06-29 17:26:09 +10001723 lock_mode |= (subclass + XFS_LOCK_INUMORDER) << XFS_IOLOCK_SHIFT;
Lachlan McIlroyf7c66ce2007-05-08 13:50:19 +10001724 if (lock_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL))
David Chinner0f1145c2007-06-29 17:26:09 +10001725 lock_mode |= (subclass + XFS_LOCK_INUMORDER) << XFS_ILOCK_SHIFT;
Lachlan McIlroyf7c66ce2007-05-08 13:50:19 +10001726
1727 return lock_mode;
1728}
1729
1730/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731 * The following routine will lock n inodes in exclusive mode.
1732 * We assume the caller calls us with the inodes in i_ino order.
1733 *
1734 * We need to detect deadlock where an inode that we lock
1735 * is in the AIL and we start waiting for another inode that is locked
1736 * by a thread in a long running transaction (such as truncate). This can
1737 * result in deadlock since the long running trans might need to wait
1738 * for the inode we just locked in order to push the tail and free space
1739 * in the log.
1740 */
1741void
1742xfs_lock_inodes(
1743 xfs_inode_t **ips,
1744 int inodes,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745 uint lock_mode)
1746{
1747 int attempts = 0, i, j, try_lock;
1748 xfs_log_item_t *lp;
1749
1750 ASSERT(ips && (inodes >= 2)); /* we need at least two */
1751
Christoph Hellwigcfa853e2008-04-22 17:34:06 +10001752 try_lock = 0;
1753 i = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754
1755again:
1756 for (; i < inodes; i++) {
1757 ASSERT(ips[i]);
1758
1759 if (i && (ips[i] == ips[i-1])) /* Already locked */
1760 continue;
1761
1762 /*
1763 * If try_lock is not set yet, make sure all locked inodes
1764 * are not in the AIL.
1765 * If any are, set try_lock to be used later.
1766 */
1767
1768 if (!try_lock) {
1769 for (j = (i - 1); j >= 0 && !try_lock; j--) {
1770 lp = (xfs_log_item_t *)ips[j]->i_itemp;
1771 if (lp && (lp->li_flags & XFS_LI_IN_AIL)) {
1772 try_lock++;
1773 }
1774 }
1775 }
1776
1777 /*
1778 * If any of the previous locks we have locked is in the AIL,
1779 * we must TRY to get the second and subsequent locks. If
1780 * we can't get any, we must release all we have
1781 * and try again.
1782 */
1783
1784 if (try_lock) {
1785 /* try_lock must be 0 if i is 0. */
1786 /*
1787 * try_lock means we have an inode locked
1788 * that is in the AIL.
1789 */
1790 ASSERT(i != 0);
Lachlan McIlroyf7c66ce2007-05-08 13:50:19 +10001791 if (!xfs_ilock_nowait(ips[i], xfs_lock_inumorder(lock_mode, i))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792 attempts++;
1793
1794 /*
1795 * Unlock all previous guys and try again.
1796 * xfs_iunlock will try to push the tail
1797 * if the inode is in the AIL.
1798 */
1799
1800 for(j = i - 1; j >= 0; j--) {
1801
1802 /*
1803 * Check to see if we've already
1804 * unlocked this one.
1805 * Not the first one going back,
1806 * and the inode ptr is the same.
1807 */
1808 if ((j != (i - 1)) && ips[j] ==
1809 ips[j+1])
1810 continue;
1811
1812 xfs_iunlock(ips[j], lock_mode);
1813 }
1814
1815 if ((attempts % 5) == 0) {
1816 delay(1); /* Don't just spin the CPU */
1817#ifdef DEBUG
1818 xfs_lock_delays++;
1819#endif
1820 }
1821 i = 0;
1822 try_lock = 0;
1823 goto again;
1824 }
1825 } else {
Lachlan McIlroyf7c66ce2007-05-08 13:50:19 +10001826 xfs_ilock(ips[i], xfs_lock_inumorder(lock_mode, i));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827 }
1828 }
1829
1830#ifdef DEBUG
1831 if (attempts) {
1832 if (attempts < 5) xfs_small_retries++;
1833 else if (attempts < 100) xfs_middle_retries++;
1834 else xfs_lots_retries++;
1835 } else {
1836 xfs_locked_n++;
1837 }
1838#endif
1839}
1840
David Chinnerf9114eb2008-09-17 16:51:21 +10001841/*
1842 * xfs_lock_two_inodes() can only be used to lock one type of lock
1843 * at a time - the iolock or the ilock, but not both at once. If
1844 * we lock both at once, lockdep will report false positives saying
1845 * we have violated locking orders.
1846 */
Christoph Hellwige1cccd92008-08-13 16:18:07 +10001847void
1848xfs_lock_two_inodes(
1849 xfs_inode_t *ip0,
1850 xfs_inode_t *ip1,
1851 uint lock_mode)
1852{
1853 xfs_inode_t *temp;
1854 int attempts = 0;
1855 xfs_log_item_t *lp;
1856
David Chinnerf9114eb2008-09-17 16:51:21 +10001857 if (lock_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL))
1858 ASSERT((lock_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)) == 0);
Christoph Hellwige1cccd92008-08-13 16:18:07 +10001859 ASSERT(ip0->i_ino != ip1->i_ino);
1860
1861 if (ip0->i_ino > ip1->i_ino) {
1862 temp = ip0;
1863 ip0 = ip1;
1864 ip1 = temp;
1865 }
1866
1867 again:
1868 xfs_ilock(ip0, xfs_lock_inumorder(lock_mode, 0));
1869
1870 /*
1871 * If the first lock we have locked is in the AIL, we must TRY to get
1872 * the second lock. If we can't get it, we must release the first one
1873 * and try again.
1874 */
1875 lp = (xfs_log_item_t *)ip0->i_itemp;
1876 if (lp && (lp->li_flags & XFS_LI_IN_AIL)) {
1877 if (!xfs_ilock_nowait(ip1, xfs_lock_inumorder(lock_mode, 1))) {
1878 xfs_iunlock(ip0, lock_mode);
1879 if ((++attempts % 5) == 0)
1880 delay(1); /* Don't just spin the CPU */
1881 goto again;
1882 }
1883 } else {
1884 xfs_ilock(ip1, xfs_lock_inumorder(lock_mode, 1));
1885 }
1886}
1887
Christoph Hellwig993386c2007-08-28 16:12:30 +10001888int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889xfs_remove(
Christoph Hellwig993386c2007-08-28 16:12:30 +10001890 xfs_inode_t *dp,
Barry Naujok556b8b12008-04-10 12:22:07 +10001891 struct xfs_name *name,
1892 xfs_inode_t *ip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893{
Christoph Hellwig993386c2007-08-28 16:12:30 +10001894 xfs_mount_t *mp = dp->i_mount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895 xfs_trans_t *tp = NULL;
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001896 int is_dir = S_ISDIR(ip->i_d.di_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897 int error = 0;
1898 xfs_bmap_free_t free_list;
1899 xfs_fsblock_t first_block;
1900 int cancel_flags;
1901 int committed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902 int link_zero;
1903 uint resblks;
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001904 uint log_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905
Lachlan McIlroycf441ee2008-02-07 16:42:19 +11001906 xfs_itrace_entry(dp);
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001907 xfs_itrace_entry(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909 if (XFS_FORCED_SHUTDOWN(mp))
1910 return XFS_ERROR(EIO);
1911
Christoph Hellwigeb9df392007-08-16 18:42:07 +10001912 if (DM_EVENT_ENABLED(dp, DM_EVENT_REMOVE)) {
Barry Naujok556b8b12008-04-10 12:22:07 +10001913 error = XFS_SEND_NAMESP(mp, DM_EVENT_REMOVE, dp, DM_RIGHT_NULL,
1914 NULL, DM_RIGHT_NULL, name->name, NULL,
1915 ip->i_d.di_mode, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916 if (error)
1917 return error;
1918 }
1919
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920 error = XFS_QM_DQATTACH(mp, dp, 0);
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001921 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922 goto std_return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001924 error = XFS_QM_DQATTACH(mp, ip, 0);
1925 if (error)
1926 goto std_return;
1927
1928 if (is_dir) {
1929 tp = xfs_trans_alloc(mp, XFS_TRANS_RMDIR);
1930 log_count = XFS_DEFAULT_LOG_COUNT;
1931 } else {
1932 tp = xfs_trans_alloc(mp, XFS_TRANS_REMOVE);
1933 log_count = XFS_REMOVE_LOG_COUNT;
1934 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935 cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001936
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937 /*
1938 * We try to get the real space reservation first,
1939 * allowing for directory btree deletion(s) implying
1940 * possible bmap insert(s). If we can't get the space
1941 * reservation then we use 0 instead, and avoid the bmap
1942 * btree insert(s) in the directory code by, if the bmap
1943 * insert tries to happen, instead trimming the LAST
1944 * block from the directory.
1945 */
1946 resblks = XFS_REMOVE_SPACE_RES(mp);
1947 error = xfs_trans_reserve(tp, resblks, XFS_REMOVE_LOG_RES(mp), 0,
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001948 XFS_TRANS_PERM_LOG_RES, log_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949 if (error == ENOSPC) {
1950 resblks = 0;
1951 error = xfs_trans_reserve(tp, 0, XFS_REMOVE_LOG_RES(mp), 0,
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001952 XFS_TRANS_PERM_LOG_RES, log_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001953 }
1954 if (error) {
1955 ASSERT(error != ENOSPC);
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001956 cancel_flags = 0;
1957 goto out_trans_cancel;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958 }
1959
Christoph Hellwige1cccd92008-08-13 16:18:07 +10001960 xfs_lock_two_inodes(dp, ip, XFS_ILOCK_EXCL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961
1962 /*
1963 * At this point, we've gotten both the directory and the entry
1964 * inodes locked.
1965 */
Christoph Hellwig5df78e72008-04-22 17:34:24 +10001966 IHOLD(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001967 xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
Christoph Hellwig82dab942008-04-22 17:34:18 +10001968
1969 IHOLD(dp);
1970 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001971
1972 /*
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001973 * If we're removing a directory perform some additional validation.
1974 */
1975 if (is_dir) {
1976 ASSERT(ip->i_d.di_nlink >= 2);
1977 if (ip->i_d.di_nlink != 2) {
1978 error = XFS_ERROR(ENOTEMPTY);
1979 goto out_trans_cancel;
1980 }
1981 if (!xfs_dir_isempty(ip)) {
1982 error = XFS_ERROR(ENOTEMPTY);
1983 goto out_trans_cancel;
1984 }
1985 }
1986
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987 XFS_BMAP_INIT(&free_list, &first_block);
Barry Naujok556b8b12008-04-10 12:22:07 +10001988 error = xfs_dir_removename(tp, dp, name, ip->i_ino,
Christoph Hellwigd4377d82008-04-22 17:33:46 +10001989 &first_block, &free_list, resblks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001990 if (error) {
1991 ASSERT(error != ENOENT);
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001992 goto out_bmap_cancel;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001993 }
1994 xfs_ichgtime(dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1995
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001996 /*
1997 * Bump the in memory generation count on the parent
1998 * directory so that other can know that it has changed.
1999 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000 dp->i_gen++;
2001 xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
2002
Christoph Hellwig8f112e32008-06-23 13:25:17 +10002003 if (is_dir) {
2004 /*
2005 * Drop the link from ip's "..".
2006 */
2007 error = xfs_droplink(tp, dp);
2008 if (error)
2009 goto out_bmap_cancel;
2010
2011 /*
2012 * Drop the link from dp to ip.
2013 */
2014 error = xfs_droplink(tp, ip);
2015 if (error)
2016 goto out_bmap_cancel;
2017 } else {
2018 /*
2019 * When removing a non-directory we need to log the parent
2020 * inode here for the i_gen update. For a directory this is
2021 * done implicitly by the xfs_droplink call for the ".." entry.
2022 */
2023 xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024 }
2025
Christoph Hellwig8f112e32008-06-23 13:25:17 +10002026 /*
2027 * Drop the "." link from ip to self.
2028 */
2029 error = xfs_droplink(tp, ip);
2030 if (error)
2031 goto out_bmap_cancel;
2032
2033 /*
2034 * Determine if this is the last link while
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035 * we are in the transaction.
2036 */
Christoph Hellwig8f112e32008-06-23 13:25:17 +10002037 link_zero = (ip->i_d.di_nlink == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038
2039 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040 * If this is a synchronous mount, make sure that the
2041 * remove transaction goes to disk before returning to
2042 * the user.
2043 */
Christoph Hellwig8f112e32008-06-23 13:25:17 +10002044 if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002045 xfs_trans_set_sync(tp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002046
Eric Sandeenf7c99b62007-02-10 18:37:16 +11002047 error = xfs_bmap_finish(&tp, &free_list, &committed);
Christoph Hellwig8f112e32008-06-23 13:25:17 +10002048 if (error)
2049 goto out_bmap_cancel;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002050
Eric Sandeen1c72bf92007-05-08 13:48:42 +10002051 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
Christoph Hellwig5df78e72008-04-22 17:34:24 +10002052 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002053 goto std_return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002054
2055 /*
David Chinner2a82b8b2007-07-11 11:09:12 +10002056 * If we are using filestreams, kill the stream association.
2057 * If the file is still open it may get a new one but that
2058 * will get killed on last close in xfs_close() so we don't
2059 * have to worry about that.
2060 */
Christoph Hellwig8f112e32008-06-23 13:25:17 +10002061 if (!is_dir && link_zero && xfs_inode_is_filestream(ip))
David Chinner2a82b8b2007-07-11 11:09:12 +10002062 xfs_filestream_deassociate(ip);
2063
Lachlan McIlroycf441ee2008-02-07 16:42:19 +11002064 xfs_itrace_exit(ip);
Christoph Hellwig8f112e32008-06-23 13:25:17 +10002065 xfs_itrace_exit(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002066
Linus Torvalds1da177e2005-04-16 15:20:36 -07002067 std_return:
Christoph Hellwigeb9df392007-08-16 18:42:07 +10002068 if (DM_EVENT_ENABLED(dp, DM_EVENT_POSTREMOVE)) {
Christoph Hellwig8f112e32008-06-23 13:25:17 +10002069 XFS_SEND_NAMESP(mp, DM_EVENT_POSTREMOVE, dp, DM_RIGHT_NULL,
2070 NULL, DM_RIGHT_NULL, name->name, NULL,
2071 ip->i_d.di_mode, error, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002072 }
Christoph Hellwig8f112e32008-06-23 13:25:17 +10002073
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074 return error;
2075
Christoph Hellwig8f112e32008-06-23 13:25:17 +10002076 out_bmap_cancel:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077 xfs_bmap_cancel(&free_list);
2078 cancel_flags |= XFS_TRANS_ABORT;
Christoph Hellwig8f112e32008-06-23 13:25:17 +10002079 out_trans_cancel:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002080 xfs_trans_cancel(tp, cancel_flags);
2081 goto std_return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002082}
2083
Christoph Hellwig993386c2007-08-28 16:12:30 +10002084int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002085xfs_link(
Christoph Hellwig993386c2007-08-28 16:12:30 +10002086 xfs_inode_t *tdp,
Christoph Hellwiga3da7892008-03-06 13:46:12 +11002087 xfs_inode_t *sip,
Barry Naujok556b8b12008-04-10 12:22:07 +10002088 struct xfs_name *target_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002089{
Christoph Hellwig993386c2007-08-28 16:12:30 +10002090 xfs_mount_t *mp = tdp->i_mount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002091 xfs_trans_t *tp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002092 int error;
2093 xfs_bmap_free_t free_list;
2094 xfs_fsblock_t first_block;
2095 int cancel_flags;
2096 int committed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097 int resblks;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002098
Lachlan McIlroycf441ee2008-02-07 16:42:19 +11002099 xfs_itrace_entry(tdp);
Christoph Hellwiga3da7892008-03-06 13:46:12 +11002100 xfs_itrace_entry(sip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002101
Christoph Hellwiga3da7892008-03-06 13:46:12 +11002102 ASSERT(!S_ISDIR(sip->i_d.di_mode));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103
Linus Torvalds1da177e2005-04-16 15:20:36 -07002104 if (XFS_FORCED_SHUTDOWN(mp))
2105 return XFS_ERROR(EIO);
2106
Christoph Hellwigeb9df392007-08-16 18:42:07 +10002107 if (DM_EVENT_ENABLED(tdp, DM_EVENT_LINK)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002108 error = XFS_SEND_NAMESP(mp, DM_EVENT_LINK,
Christoph Hellwigbc4ac742008-03-06 13:45:58 +11002109 tdp, DM_RIGHT_NULL,
2110 sip, DM_RIGHT_NULL,
Barry Naujok556b8b12008-04-10 12:22:07 +10002111 target_name->name, NULL, 0, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002112 if (error)
2113 return error;
2114 }
2115
2116 /* Return through std_return after this point. */
2117
2118 error = XFS_QM_DQATTACH(mp, sip, 0);
2119 if (!error && sip != tdp)
2120 error = XFS_QM_DQATTACH(mp, tdp, 0);
2121 if (error)
2122 goto std_return;
2123
2124 tp = xfs_trans_alloc(mp, XFS_TRANS_LINK);
2125 cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
Barry Naujok556b8b12008-04-10 12:22:07 +10002126 resblks = XFS_LINK_SPACE_RES(mp, target_name->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002127 error = xfs_trans_reserve(tp, resblks, XFS_LINK_LOG_RES(mp), 0,
2128 XFS_TRANS_PERM_LOG_RES, XFS_LINK_LOG_COUNT);
2129 if (error == ENOSPC) {
2130 resblks = 0;
2131 error = xfs_trans_reserve(tp, 0, XFS_LINK_LOG_RES(mp), 0,
2132 XFS_TRANS_PERM_LOG_RES, XFS_LINK_LOG_COUNT);
2133 }
2134 if (error) {
2135 cancel_flags = 0;
2136 goto error_return;
2137 }
2138
Christoph Hellwige1cccd92008-08-13 16:18:07 +10002139 xfs_lock_two_inodes(sip, tdp, XFS_ILOCK_EXCL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002140
2141 /*
2142 * Increment vnode ref counts since xfs_trans_commit &
2143 * xfs_trans_cancel will both unlock the inodes and
2144 * decrement the associated ref counts.
2145 */
Christoph Hellwiga3da7892008-03-06 13:46:12 +11002146 IHOLD(sip);
2147 IHOLD(tdp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002148 xfs_trans_ijoin(tp, sip, XFS_ILOCK_EXCL);
2149 xfs_trans_ijoin(tp, tdp, XFS_ILOCK_EXCL);
2150
2151 /*
2152 * If the source has too many links, we can't make any more to it.
2153 */
2154 if (sip->i_d.di_nlink >= XFS_MAXLINK) {
2155 error = XFS_ERROR(EMLINK);
2156 goto error_return;
2157 }
2158
Nathan Scott365ca832005-06-21 15:39:12 +10002159 /*
2160 * If we are using project inheritance, we only allow hard link
2161 * creation in our tree when the project IDs are the same; else
2162 * the tree quota mechanism could be circumvented.
2163 */
2164 if (unlikely((tdp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
2165 (tdp->i_d.di_projid != sip->i_d.di_projid))) {
Nathan Scottb1ecdda2006-05-08 19:51:42 +10002166 error = XFS_ERROR(EXDEV);
Nathan Scott365ca832005-06-21 15:39:12 +10002167 goto error_return;
2168 }
2169
Barry Naujok556b8b12008-04-10 12:22:07 +10002170 error = xfs_dir_canenter(tp, tdp, target_name, resblks);
2171 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002172 goto error_return;
2173
2174 XFS_BMAP_INIT(&free_list, &first_block);
2175
Barry Naujok556b8b12008-04-10 12:22:07 +10002176 error = xfs_dir_createname(tp, tdp, target_name, sip->i_ino,
2177 &first_block, &free_list, resblks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002178 if (error)
2179 goto abort_return;
2180 xfs_ichgtime(tdp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
2181 tdp->i_gen++;
2182 xfs_trans_log_inode(tp, tdp, XFS_ILOG_CORE);
2183
2184 error = xfs_bumplink(tp, sip);
Alexey Dobriyanb71d3002006-06-27 12:45:17 +10002185 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002186 goto abort_return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002187
2188 /*
2189 * If this is a synchronous mount, make sure that the
2190 * link transaction goes to disk before returning to
2191 * the user.
2192 */
2193 if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
2194 xfs_trans_set_sync(tp);
2195 }
2196
Eric Sandeenf7c99b62007-02-10 18:37:16 +11002197 error = xfs_bmap_finish (&tp, &free_list, &committed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002198 if (error) {
2199 xfs_bmap_cancel(&free_list);
2200 goto abort_return;
2201 }
2202
Eric Sandeen1c72bf92007-05-08 13:48:42 +10002203 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
Alexey Dobriyanb71d3002006-06-27 12:45:17 +10002204 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002205 goto std_return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002206
2207 /* Fall through to std_return with error = 0. */
2208std_return:
Christoph Hellwigeb9df392007-08-16 18:42:07 +10002209 if (DM_EVENT_ENABLED(sip, DM_EVENT_POSTLINK)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002210 (void) XFS_SEND_NAMESP(mp, DM_EVENT_POSTLINK,
Christoph Hellwigbc4ac742008-03-06 13:45:58 +11002211 tdp, DM_RIGHT_NULL,
2212 sip, DM_RIGHT_NULL,
Barry Naujok556b8b12008-04-10 12:22:07 +10002213 target_name->name, NULL, 0, error, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002214 }
2215 return error;
2216
2217 abort_return:
2218 cancel_flags |= XFS_TRANS_ABORT;
2219 /* FALLTHROUGH */
Jesper Juhl014c2542006-01-15 02:37:08 +01002220
Linus Torvalds1da177e2005-04-16 15:20:36 -07002221 error_return:
2222 xfs_trans_cancel(tp, cancel_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002223 goto std_return;
2224}
Alexey Dobriyanb71d3002006-06-27 12:45:17 +10002225
2226
Christoph Hellwig993386c2007-08-28 16:12:30 +10002227int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228xfs_mkdir(
Christoph Hellwig993386c2007-08-28 16:12:30 +10002229 xfs_inode_t *dp,
Barry Naujok556b8b12008-04-10 12:22:07 +10002230 struct xfs_name *dir_name,
Christoph Hellwig3e5daf02007-10-11 18:09:12 +10002231 mode_t mode,
Christoph Hellwig979ebab2008-03-06 13:46:05 +11002232 xfs_inode_t **ipp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002233 cred_t *credp)
2234{
Christoph Hellwig993386c2007-08-28 16:12:30 +10002235 xfs_mount_t *mp = dp->i_mount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002236 xfs_inode_t *cdp; /* inode of created dir */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002237 xfs_trans_t *tp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238 int cancel_flags;
2239 int error;
2240 int committed;
2241 xfs_bmap_free_t free_list;
2242 xfs_fsblock_t first_block;
Christoph Hellwig993386c2007-08-28 16:12:30 +10002243 boolean_t unlock_dp_on_error = B_FALSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244 boolean_t created = B_FALSE;
2245 int dm_event_sent = 0;
2246 xfs_prid_t prid;
2247 struct xfs_dquot *udqp, *gdqp;
2248 uint resblks;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002249
2250 if (XFS_FORCED_SHUTDOWN(mp))
2251 return XFS_ERROR(EIO);
2252
Linus Torvalds1da177e2005-04-16 15:20:36 -07002253 tp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002254
Christoph Hellwigeb9df392007-08-16 18:42:07 +10002255 if (DM_EVENT_ENABLED(dp, DM_EVENT_CREATE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002256 error = XFS_SEND_NAMESP(mp, DM_EVENT_CREATE,
Christoph Hellwigbc4ac742008-03-06 13:45:58 +11002257 dp, DM_RIGHT_NULL, NULL,
Barry Naujok556b8b12008-04-10 12:22:07 +10002258 DM_RIGHT_NULL, dir_name->name, NULL,
Christoph Hellwig3e5daf02007-10-11 18:09:12 +10002259 mode, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260 if (error)
2261 return error;
2262 dm_event_sent = 1;
2263 }
2264
2265 /* Return through std_return after this point. */
2266
Lachlan McIlroycf441ee2008-02-07 16:42:19 +11002267 xfs_itrace_entry(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002268
2269 mp = dp->i_mount;
2270 udqp = gdqp = NULL;
Nathan Scott365ca832005-06-21 15:39:12 +10002271 if (dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
2272 prid = dp->i_d.di_projid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002273 else
2274 prid = (xfs_prid_t)dfltprid;
2275
2276 /*
2277 * Make sure that we have allocated dquot(s) on disk.
2278 */
2279 error = XFS_QM_DQVOPALLOC(mp, dp,
David Howells9e2b2dc2008-08-13 16:20:04 +01002280 current_fsuid(), current_fsgid(), prid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002281 XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT, &udqp, &gdqp);
2282 if (error)
2283 goto std_return;
2284
2285 tp = xfs_trans_alloc(mp, XFS_TRANS_MKDIR);
2286 cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
Barry Naujok556b8b12008-04-10 12:22:07 +10002287 resblks = XFS_MKDIR_SPACE_RES(mp, dir_name->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002288 error = xfs_trans_reserve(tp, resblks, XFS_MKDIR_LOG_RES(mp), 0,
2289 XFS_TRANS_PERM_LOG_RES, XFS_MKDIR_LOG_COUNT);
2290 if (error == ENOSPC) {
2291 resblks = 0;
2292 error = xfs_trans_reserve(tp, 0, XFS_MKDIR_LOG_RES(mp), 0,
2293 XFS_TRANS_PERM_LOG_RES,
2294 XFS_MKDIR_LOG_COUNT);
2295 }
2296 if (error) {
2297 cancel_flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002298 goto error_return;
2299 }
2300
Lachlan McIlroyf7c66ce2007-05-08 13:50:19 +10002301 xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
Christoph Hellwig993386c2007-08-28 16:12:30 +10002302 unlock_dp_on_error = B_TRUE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002303
2304 /*
2305 * Check for directory link count overflow.
2306 */
2307 if (dp->i_d.di_nlink >= XFS_MAXLINK) {
2308 error = XFS_ERROR(EMLINK);
2309 goto error_return;
2310 }
2311
2312 /*
2313 * Reserve disk quota and the inode.
2314 */
2315 error = XFS_TRANS_RESERVE_QUOTA(mp, tp, udqp, gdqp, resblks, 1, 0);
2316 if (error)
2317 goto error_return;
2318
Barry Naujok556b8b12008-04-10 12:22:07 +10002319 error = xfs_dir_canenter(tp, dp, dir_name, resblks);
2320 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002321 goto error_return;
2322 /*
2323 * create the directory inode.
2324 */
Christoph Hellwig3e5daf02007-10-11 18:09:12 +10002325 error = xfs_dir_ialloc(&tp, dp, mode, 2,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002326 0, credp, prid, resblks > 0,
2327 &cdp, NULL);
2328 if (error) {
2329 if (error == ENOSPC)
2330 goto error_return;
2331 goto abort_return;
2332 }
Lachlan McIlroycf441ee2008-02-07 16:42:19 +11002333 xfs_itrace_ref(cdp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002334
2335 /*
2336 * Now we add the directory inode to the transaction.
2337 * We waited until now since xfs_dir_ialloc might start
2338 * a new transaction. Had we joined the transaction
Christoph Hellwig993386c2007-08-28 16:12:30 +10002339 * earlier, the locks might have gotten released. An error
2340 * from here on will result in the transaction cancel
2341 * unlocking dp so don't do it explicitly in the error path.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002342 */
Christoph Hellwig979ebab2008-03-06 13:46:05 +11002343 IHOLD(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002344 xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
Christoph Hellwig993386c2007-08-28 16:12:30 +10002345 unlock_dp_on_error = B_FALSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002346
2347 XFS_BMAP_INIT(&free_list, &first_block);
2348
Barry Naujok556b8b12008-04-10 12:22:07 +10002349 error = xfs_dir_createname(tp, dp, dir_name, cdp->i_ino,
2350 &first_block, &free_list, resblks ?
2351 resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002352 if (error) {
2353 ASSERT(error != ENOSPC);
2354 goto error1;
2355 }
2356 xfs_ichgtime(dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
2357
2358 /*
2359 * Bump the in memory version number of the parent directory
2360 * so that other processes accessing it will recognize that
2361 * the directory has changed.
2362 */
2363 dp->i_gen++;
2364
Nathan Scottf6c2d1f2006-06-20 13:04:51 +10002365 error = xfs_dir_init(tp, cdp, dp);
2366 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002367 goto error2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002368
2369 cdp->i_gen = 1;
2370 error = xfs_bumplink(tp, dp);
Nathan Scottf6c2d1f2006-06-20 13:04:51 +10002371 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002372 goto error2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002373
Linus Torvalds1da177e2005-04-16 15:20:36 -07002374 created = B_TRUE;
2375
Christoph Hellwig979ebab2008-03-06 13:46:05 +11002376 *ipp = cdp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377 IHOLD(cdp);
2378
2379 /*
2380 * Attach the dquots to the new inode and modify the icount incore.
2381 */
2382 XFS_QM_DQVOPCREATE(mp, tp, cdp, udqp, gdqp);
2383
2384 /*
2385 * If this is a synchronous mount, make sure that the
2386 * mkdir transaction goes to disk before returning to
2387 * the user.
2388 */
2389 if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
2390 xfs_trans_set_sync(tp);
2391 }
2392
Eric Sandeenf7c99b62007-02-10 18:37:16 +11002393 error = xfs_bmap_finish(&tp, &free_list, &committed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002394 if (error) {
2395 IRELE(cdp);
2396 goto error2;
2397 }
2398
Eric Sandeen1c72bf92007-05-08 13:48:42 +10002399 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002400 XFS_QM_DQRELE(mp, udqp);
2401 XFS_QM_DQRELE(mp, gdqp);
2402 if (error) {
2403 IRELE(cdp);
2404 }
2405
2406 /* Fall through to std_return with error = 0 or errno from
2407 * xfs_trans_commit. */
2408
2409std_return:
Christoph Hellwigeb9df392007-08-16 18:42:07 +10002410 if ((created || (error != 0 && dm_event_sent != 0)) &&
Christoph Hellwig993386c2007-08-28 16:12:30 +10002411 DM_EVENT_ENABLED(dp, DM_EVENT_POSTCREATE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002412 (void) XFS_SEND_NAMESP(mp, DM_EVENT_POSTCREATE,
Christoph Hellwigbc4ac742008-03-06 13:45:58 +11002413 dp, DM_RIGHT_NULL,
2414 created ? cdp : NULL,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002415 DM_RIGHT_NULL,
Barry Naujok556b8b12008-04-10 12:22:07 +10002416 dir_name->name, NULL,
Christoph Hellwig3e5daf02007-10-11 18:09:12 +10002417 mode, error, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002418 }
2419 return error;
2420
2421 error2:
2422 error1:
2423 xfs_bmap_cancel(&free_list);
2424 abort_return:
2425 cancel_flags |= XFS_TRANS_ABORT;
2426 error_return:
2427 xfs_trans_cancel(tp, cancel_flags);
2428 XFS_QM_DQRELE(mp, udqp);
2429 XFS_QM_DQRELE(mp, gdqp);
2430
Christoph Hellwig993386c2007-08-28 16:12:30 +10002431 if (unlock_dp_on_error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002432 xfs_iunlock(dp, XFS_ILOCK_EXCL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002433
2434 goto std_return;
2435}
2436
Christoph Hellwig993386c2007-08-28 16:12:30 +10002437int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002438xfs_symlink(
Christoph Hellwig993386c2007-08-28 16:12:30 +10002439 xfs_inode_t *dp,
Barry Naujok556b8b12008-04-10 12:22:07 +10002440 struct xfs_name *link_name,
2441 const char *target_path,
Christoph Hellwig3e5daf02007-10-11 18:09:12 +10002442 mode_t mode,
Christoph Hellwig3937be52008-03-06 13:46:19 +11002443 xfs_inode_t **ipp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002444 cred_t *credp)
2445{
Christoph Hellwig993386c2007-08-28 16:12:30 +10002446 xfs_mount_t *mp = dp->i_mount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002447 xfs_trans_t *tp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002448 xfs_inode_t *ip;
2449 int error;
2450 int pathlen;
2451 xfs_bmap_free_t free_list;
2452 xfs_fsblock_t first_block;
Christoph Hellwig993386c2007-08-28 16:12:30 +10002453 boolean_t unlock_dp_on_error = B_FALSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002454 uint cancel_flags;
2455 int committed;
2456 xfs_fileoff_t first_fsb;
2457 xfs_filblks_t fs_blocks;
2458 int nmaps;
2459 xfs_bmbt_irec_t mval[SYMLINK_MAPS];
2460 xfs_daddr_t d;
Barry Naujok556b8b12008-04-10 12:22:07 +10002461 const char *cur_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002462 int byte_cnt;
2463 int n;
2464 xfs_buf_t *bp;
2465 xfs_prid_t prid;
2466 struct xfs_dquot *udqp, *gdqp;
2467 uint resblks;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002468
Christoph Hellwig3937be52008-03-06 13:46:19 +11002469 *ipp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002470 error = 0;
2471 ip = NULL;
2472 tp = NULL;
2473
Lachlan McIlroycf441ee2008-02-07 16:42:19 +11002474 xfs_itrace_entry(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002475
2476 if (XFS_FORCED_SHUTDOWN(mp))
2477 return XFS_ERROR(EIO);
2478
Linus Torvalds1da177e2005-04-16 15:20:36 -07002479 /*
2480 * Check component lengths of the target path name.
2481 */
2482 pathlen = strlen(target_path);
2483 if (pathlen >= MAXPATHLEN) /* total string too long */
2484 return XFS_ERROR(ENAMETOOLONG);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002485
Christoph Hellwigeb9df392007-08-16 18:42:07 +10002486 if (DM_EVENT_ENABLED(dp, DM_EVENT_SYMLINK)) {
Christoph Hellwigbc4ac742008-03-06 13:45:58 +11002487 error = XFS_SEND_NAMESP(mp, DM_EVENT_SYMLINK, dp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002488 DM_RIGHT_NULL, NULL, DM_RIGHT_NULL,
Barry Naujok556b8b12008-04-10 12:22:07 +10002489 link_name->name, target_path, 0, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002490 if (error)
2491 return error;
2492 }
2493
2494 /* Return through std_return after this point. */
2495
2496 udqp = gdqp = NULL;
Nathan Scott365ca832005-06-21 15:39:12 +10002497 if (dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
2498 prid = dp->i_d.di_projid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002499 else
2500 prid = (xfs_prid_t)dfltprid;
2501
2502 /*
2503 * Make sure that we have allocated dquot(s) on disk.
2504 */
2505 error = XFS_QM_DQVOPALLOC(mp, dp,
David Howells9e2b2dc2008-08-13 16:20:04 +01002506 current_fsuid(), current_fsgid(), prid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002507 XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT, &udqp, &gdqp);
2508 if (error)
2509 goto std_return;
2510
2511 tp = xfs_trans_alloc(mp, XFS_TRANS_SYMLINK);
2512 cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
2513 /*
2514 * The symlink will fit into the inode data fork?
2515 * There can't be any attributes so we get the whole variable part.
2516 */
2517 if (pathlen <= XFS_LITINO(mp))
2518 fs_blocks = 0;
2519 else
2520 fs_blocks = XFS_B_TO_FSB(mp, pathlen);
Barry Naujok556b8b12008-04-10 12:22:07 +10002521 resblks = XFS_SYMLINK_SPACE_RES(mp, link_name->len, fs_blocks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002522 error = xfs_trans_reserve(tp, resblks, XFS_SYMLINK_LOG_RES(mp), 0,
2523 XFS_TRANS_PERM_LOG_RES, XFS_SYMLINK_LOG_COUNT);
2524 if (error == ENOSPC && fs_blocks == 0) {
2525 resblks = 0;
2526 error = xfs_trans_reserve(tp, 0, XFS_SYMLINK_LOG_RES(mp), 0,
2527 XFS_TRANS_PERM_LOG_RES, XFS_SYMLINK_LOG_COUNT);
2528 }
2529 if (error) {
2530 cancel_flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002531 goto error_return;
2532 }
2533
Lachlan McIlroyf7c66ce2007-05-08 13:50:19 +10002534 xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
Christoph Hellwig993386c2007-08-28 16:12:30 +10002535 unlock_dp_on_error = B_TRUE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002536
2537 /*
2538 * Check whether the directory allows new symlinks or not.
2539 */
2540 if (dp->i_d.di_flags & XFS_DIFLAG_NOSYMLINKS) {
2541 error = XFS_ERROR(EPERM);
2542 goto error_return;
2543 }
2544
2545 /*
2546 * Reserve disk quota : blocks and inode.
2547 */
2548 error = XFS_TRANS_RESERVE_QUOTA(mp, tp, udqp, gdqp, resblks, 1, 0);
2549 if (error)
2550 goto error_return;
2551
2552 /*
2553 * Check for ability to enter directory entry, if no space reserved.
2554 */
Barry Naujok556b8b12008-04-10 12:22:07 +10002555 error = xfs_dir_canenter(tp, dp, link_name, resblks);
2556 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002557 goto error_return;
2558 /*
2559 * Initialize the bmap freelist prior to calling either
2560 * bmapi or the directory create code.
2561 */
2562 XFS_BMAP_INIT(&free_list, &first_block);
2563
2564 /*
2565 * Allocate an inode for the symlink.
2566 */
Christoph Hellwig3e5daf02007-10-11 18:09:12 +10002567 error = xfs_dir_ialloc(&tp, dp, S_IFLNK | (mode & ~S_IFMT),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002568 1, 0, credp, prid, resblks > 0, &ip, NULL);
2569 if (error) {
2570 if (error == ENOSPC)
2571 goto error_return;
2572 goto error1;
2573 }
Lachlan McIlroycf441ee2008-02-07 16:42:19 +11002574 xfs_itrace_ref(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002575
Christoph Hellwig993386c2007-08-28 16:12:30 +10002576 /*
2577 * An error after we've joined dp to the transaction will result in the
2578 * transaction cancel unlocking dp so don't do it explicitly in the
2579 * error path.
2580 */
Christoph Hellwig3937be52008-03-06 13:46:19 +11002581 IHOLD(dp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002582 xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
Christoph Hellwig993386c2007-08-28 16:12:30 +10002583 unlock_dp_on_error = B_FALSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002584
2585 /*
2586 * Also attach the dquot(s) to it, if applicable.
2587 */
2588 XFS_QM_DQVOPCREATE(mp, tp, ip, udqp, gdqp);
2589
2590 if (resblks)
2591 resblks -= XFS_IALLOC_SPACE_RES(mp);
2592 /*
2593 * If the symlink will fit into the inode, write it inline.
2594 */
2595 if (pathlen <= XFS_IFORK_DSIZE(ip)) {
2596 xfs_idata_realloc(ip, pathlen, XFS_DATA_FORK);
2597 memcpy(ip->i_df.if_u1.if_data, target_path, pathlen);
2598 ip->i_d.di_size = pathlen;
2599
2600 /*
2601 * The inode was initially created in extent format.
2602 */
2603 ip->i_df.if_flags &= ~(XFS_IFEXTENTS | XFS_IFBROOT);
2604 ip->i_df.if_flags |= XFS_IFINLINE;
2605
2606 ip->i_d.di_format = XFS_DINODE_FMT_LOCAL;
2607 xfs_trans_log_inode(tp, ip, XFS_ILOG_DDATA | XFS_ILOG_CORE);
2608
2609 } else {
2610 first_fsb = 0;
2611 nmaps = SYMLINK_MAPS;
2612
2613 error = xfs_bmapi(tp, ip, first_fsb, fs_blocks,
2614 XFS_BMAPI_WRITE | XFS_BMAPI_METADATA,
2615 &first_block, resblks, mval, &nmaps,
Olaf Weber3e57ecf2006-06-09 14:48:12 +10002616 &free_list, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002617 if (error) {
2618 goto error1;
2619 }
2620
2621 if (resblks)
2622 resblks -= fs_blocks;
2623 ip->i_d.di_size = pathlen;
2624 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
2625
2626 cur_chunk = target_path;
2627 for (n = 0; n < nmaps; n++) {
2628 d = XFS_FSB_TO_DADDR(mp, mval[n].br_startblock);
2629 byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount);
2630 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
2631 BTOBB(byte_cnt), 0);
2632 ASSERT(bp && !XFS_BUF_GETERROR(bp));
2633 if (pathlen < byte_cnt) {
2634 byte_cnt = pathlen;
2635 }
2636 pathlen -= byte_cnt;
2637
2638 memcpy(XFS_BUF_PTR(bp), cur_chunk, byte_cnt);
2639 cur_chunk += byte_cnt;
2640
2641 xfs_trans_log_buf(tp, bp, 0, byte_cnt - 1);
2642 }
2643 }
2644
2645 /*
2646 * Create the directory entry for the symlink.
2647 */
Barry Naujok556b8b12008-04-10 12:22:07 +10002648 error = xfs_dir_createname(tp, dp, link_name, ip->i_ino,
2649 &first_block, &free_list, resblks);
Nathan Scottf6c2d1f2006-06-20 13:04:51 +10002650 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002651 goto error1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002652 xfs_ichgtime(dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
2653 xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
2654
2655 /*
2656 * Bump the in memory version number of the parent directory
2657 * so that other processes accessing it will recognize that
2658 * the directory has changed.
2659 */
2660 dp->i_gen++;
2661
2662 /*
2663 * If this is a synchronous mount, make sure that the
2664 * symlink transaction goes to disk before returning to
2665 * the user.
2666 */
2667 if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
2668 xfs_trans_set_sync(tp);
2669 }
2670
2671 /*
2672 * xfs_trans_commit normally decrements the vnode ref count
2673 * when it unlocks the inode. Since we want to return the
2674 * vnode to the caller, we bump the vnode ref count now.
2675 */
2676 IHOLD(ip);
2677
Eric Sandeenf7c99b62007-02-10 18:37:16 +11002678 error = xfs_bmap_finish(&tp, &free_list, &committed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002679 if (error) {
2680 goto error2;
2681 }
Eric Sandeen1c72bf92007-05-08 13:48:42 +10002682 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002683 XFS_QM_DQRELE(mp, udqp);
2684 XFS_QM_DQRELE(mp, gdqp);
2685
2686 /* Fall through to std_return with error = 0 or errno from
2687 * xfs_trans_commit */
2688std_return:
Christoph Hellwig993386c2007-08-28 16:12:30 +10002689 if (DM_EVENT_ENABLED(dp, DM_EVENT_POSTSYMLINK)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002690 (void) XFS_SEND_NAMESP(mp, DM_EVENT_POSTSYMLINK,
Christoph Hellwigbc4ac742008-03-06 13:45:58 +11002691 dp, DM_RIGHT_NULL,
2692 error ? NULL : ip,
Barry Naujok556b8b12008-04-10 12:22:07 +10002693 DM_RIGHT_NULL, link_name->name,
2694 target_path, 0, error, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002695 }
2696
Christoph Hellwig3937be52008-03-06 13:46:19 +11002697 if (!error)
2698 *ipp = ip;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002699 return error;
2700
2701 error2:
2702 IRELE(ip);
2703 error1:
2704 xfs_bmap_cancel(&free_list);
2705 cancel_flags |= XFS_TRANS_ABORT;
2706 error_return:
2707 xfs_trans_cancel(tp, cancel_flags);
2708 XFS_QM_DQRELE(mp, udqp);
2709 XFS_QM_DQRELE(mp, gdqp);
2710
Christoph Hellwig993386c2007-08-28 16:12:30 +10002711 if (unlock_dp_on_error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002712 xfs_iunlock(dp, XFS_ILOCK_EXCL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002713
2714 goto std_return;
2715}
2716
Linus Torvalds1da177e2005-04-16 15:20:36 -07002717int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002718xfs_inode_flush(
Christoph Hellwig993386c2007-08-28 16:12:30 +10002719 xfs_inode_t *ip,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002720 int flags)
2721{
Christoph Hellwig993386c2007-08-28 16:12:30 +10002722 xfs_mount_t *mp = ip->i_mount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002723 int error = 0;
2724
Linus Torvalds1da177e2005-04-16 15:20:36 -07002725 if (XFS_FORCED_SHUTDOWN(mp))
2726 return XFS_ERROR(EIO);
2727
2728 /*
2729 * Bypass inodes which have already been cleaned by
2730 * the inode flush clustering code inside xfs_iflush
2731 */
David Chinner33540402008-03-06 13:43:59 +11002732 if (xfs_inode_clean(ip))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002733 return 0;
2734
Linus Torvalds1da177e2005-04-16 15:20:36 -07002735 /*
2736 * We make this non-blocking if the inode is contended,
2737 * return EAGAIN to indicate to the caller that they
2738 * did not succeed. This prevents the flush path from
2739 * blocking on inodes inside another operation right
2740 * now, they get caught later by xfs_sync.
2741 */
David Chinnera3f74ff2008-03-06 13:43:42 +11002742 if (flags & FLUSH_SYNC) {
2743 xfs_ilock(ip, XFS_ILOCK_SHARED);
2744 xfs_iflock(ip);
2745 } else if (xfs_ilock_nowait(ip, XFS_ILOCK_SHARED)) {
2746 if (xfs_ipincount(ip) || !xfs_iflock_nowait(ip)) {
2747 xfs_iunlock(ip, XFS_ILOCK_SHARED);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002748 return EAGAIN;
2749 }
David Chinnera3f74ff2008-03-06 13:43:42 +11002750 } else {
2751 return EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002752 }
2753
David Chinnera3f74ff2008-03-06 13:43:42 +11002754 error = xfs_iflush(ip, (flags & FLUSH_SYNC) ? XFS_IFLUSH_SYNC
2755 : XFS_IFLUSH_ASYNC_NOBLOCK);
2756 xfs_iunlock(ip, XFS_ILOCK_SHARED);
2757
Linus Torvalds1da177e2005-04-16 15:20:36 -07002758 return error;
2759}
2760
Christoph Hellwig993386c2007-08-28 16:12:30 +10002761
Linus Torvalds1da177e2005-04-16 15:20:36 -07002762int
Christoph Hellwig993386c2007-08-28 16:12:30 +10002763xfs_set_dmattrs(
2764 xfs_inode_t *ip,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002765 u_int evmask,
Christoph Hellwig993386c2007-08-28 16:12:30 +10002766 u_int16_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002767{
Christoph Hellwig993386c2007-08-28 16:12:30 +10002768 xfs_mount_t *mp = ip->i_mount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002769 xfs_trans_t *tp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002770 int error;
2771
2772 if (!capable(CAP_SYS_ADMIN))
2773 return XFS_ERROR(EPERM);
2774
Linus Torvalds1da177e2005-04-16 15:20:36 -07002775 if (XFS_FORCED_SHUTDOWN(mp))
2776 return XFS_ERROR(EIO);
2777
2778 tp = xfs_trans_alloc(mp, XFS_TRANS_SET_DMATTRS);
2779 error = xfs_trans_reserve(tp, 0, XFS_ICHANGE_LOG_RES (mp), 0, 0, 0);
2780 if (error) {
2781 xfs_trans_cancel(tp, 0);
2782 return error;
2783 }
2784 xfs_ilock(ip, XFS_ILOCK_EXCL);
2785 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
2786
Christoph Hellwig613d7042007-10-11 17:44:08 +10002787 ip->i_d.di_dmevmask = evmask;
2788 ip->i_d.di_dmstate = state;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002789
2790 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
2791 IHOLD(ip);
Eric Sandeen1c72bf92007-05-08 13:48:42 +10002792 error = xfs_trans_commit(tp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002793
2794 return error;
2795}
2796
Christoph Hellwig993386c2007-08-28 16:12:30 +10002797int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002798xfs_reclaim(
Christoph Hellwig993386c2007-08-28 16:12:30 +10002799 xfs_inode_t *ip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002800{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002801
Lachlan McIlroycf441ee2008-02-07 16:42:19 +11002802 xfs_itrace_entry(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002803
Christoph Hellwigdf80c932008-08-13 16:22:09 +10002804 ASSERT(!VN_MAPPED(VFS_I(ip)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002805
2806 /* bad inode, get out here ASAP */
Christoph Hellwigdf80c932008-08-13 16:22:09 +10002807 if (VN_BAD(VFS_I(ip))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002808 xfs_ireclaim(ip);
2809 return 0;
2810 }
2811
Christoph Hellwigb677c212007-08-29 11:46:28 +10002812 vn_iowait(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002813
Christoph Hellwig51c91ed2005-09-02 16:58:38 +10002814 ASSERT(XFS_FORCED_SHUTDOWN(ip->i_mount) || ip->i_delayed_blks == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002815
Christoph Hellwig42fe2b12006-01-11 15:35:17 +11002816 /*
2817 * Make sure the atime in the XFS inode is correct before freeing the
2818 * Linux inode.
2819 */
2820 xfs_synchronize_atime(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002821
David Chinner4c606582006-11-11 18:05:00 +11002822 /*
2823 * If we have nothing to flush with this inode then complete the
2824 * teardown now, otherwise break the link between the xfs inode and the
2825 * linux inode and clean up the xfs inode later. This avoids flushing
2826 * the inode to disk during the delete operation itself.
2827 *
2828 * When breaking the link, we need to set the XFS_IRECLAIMABLE flag
2829 * first to ensure that xfs_iunpin() will never see an xfs inode
2830 * that has a linux inode being reclaimed. Synchronisation is provided
2831 * by the i_flags_lock.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002832 */
2833 if (!ip->i_update_core && (ip->i_itemp == NULL)) {
2834 xfs_ilock(ip, XFS_ILOCK_EXCL);
2835 xfs_iflock(ip);
2836 return xfs_finish_reclaim(ip, 1, XFS_IFLUSH_DELWRI_ELSE_SYNC);
2837 } else {
2838 xfs_mount_t *mp = ip->i_mount;
2839
David Chinner4c606582006-11-11 18:05:00 +11002840 /* Protect sync and unpin from us */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002841 XFS_MOUNT_ILOCK(mp);
David Chinner4c606582006-11-11 18:05:00 +11002842 spin_lock(&ip->i_flags_lock);
2843 __xfs_iflags_set(ip, XFS_IRECLAIMABLE);
Christoph Hellwigdf80c932008-08-13 16:22:09 +10002844 VFS_I(ip)->i_private = NULL;
Christoph Hellwig739bfb22007-08-29 10:58:01 +10002845 ip->i_vnode = NULL;
David Chinner4c606582006-11-11 18:05:00 +11002846 spin_unlock(&ip->i_flags_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002847 list_add_tail(&ip->i_reclaim, &mp->m_del_inodes);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002848 XFS_MOUNT_IUNLOCK(mp);
2849 }
2850 return 0;
2851}
2852
2853int
2854xfs_finish_reclaim(
2855 xfs_inode_t *ip,
2856 int locked,
2857 int sync_mode)
2858{
David Chinnerda353b02007-08-28 14:00:13 +10002859 xfs_perag_t *pag = xfs_get_perag(ip->i_mount, ip->i_ino);
Christoph Hellwig5ec7f8c2008-08-13 16:22:40 +10002860 struct inode *vp = VFS_I(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002861
2862 if (vp && VN_BAD(vp))
2863 goto reclaim;
2864
2865 /* The hash lock here protects a thread in xfs_iget_core from
2866 * racing with us on linking the inode back with a vnode.
2867 * Once we have the XFS_IRECLAIM flag set it will not touch
2868 * us.
2869 */
David Chinnerda353b02007-08-28 14:00:13 +10002870 write_lock(&pag->pag_ici_lock);
David Chinnerf273ab82006-09-28 11:06:03 +10002871 spin_lock(&ip->i_flags_lock);
David Chinner7a18c382006-11-11 18:04:54 +11002872 if (__xfs_iflags_test(ip, XFS_IRECLAIM) ||
2873 (!__xfs_iflags_test(ip, XFS_IRECLAIMABLE) && vp == NULL)) {
David Chinnerf273ab82006-09-28 11:06:03 +10002874 spin_unlock(&ip->i_flags_lock);
David Chinnerda353b02007-08-28 14:00:13 +10002875 write_unlock(&pag->pag_ici_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002876 if (locked) {
2877 xfs_ifunlock(ip);
2878 xfs_iunlock(ip, XFS_ILOCK_EXCL);
2879 }
Jesper Juhl014c2542006-01-15 02:37:08 +01002880 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002881 }
David Chinner7a18c382006-11-11 18:04:54 +11002882 __xfs_iflags_set(ip, XFS_IRECLAIM);
David Chinnerf273ab82006-09-28 11:06:03 +10002883 spin_unlock(&ip->i_flags_lock);
David Chinnerda353b02007-08-28 14:00:13 +10002884 write_unlock(&pag->pag_ici_lock);
2885 xfs_put_perag(ip->i_mount, pag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002886
2887 /*
2888 * If the inode is still dirty, then flush it out. If the inode
2889 * is not in the AIL, then it will be OK to flush it delwri as
2890 * long as xfs_iflush() does not keep any references to the inode.
2891 * We leave that decision up to xfs_iflush() since it has the
2892 * knowledge of whether it's OK to simply do a delwri flush of
2893 * the inode or whether we need to wait until the inode is
2894 * pulled from the AIL.
2895 * We get the flush lock regardless, though, just to make sure
2896 * we don't free it while it is being flushed.
2897 */
Lachlan McIlroy461aa8a2008-03-06 13:43:11 +11002898 if (!locked) {
2899 xfs_ilock(ip, XFS_ILOCK_EXCL);
2900 xfs_iflock(ip);
2901 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002902
Lachlan McIlroy7f871d52008-06-23 13:23:57 +10002903 /*
2904 * In the case of a forced shutdown we rely on xfs_iflush() to
2905 * wait for the inode to be unpinned before returning an error.
2906 */
2907 if (xfs_iflush(ip, sync_mode) == 0) {
2908 /* synchronize with xfs_iflush_done */
2909 xfs_iflock(ip);
2910 xfs_ifunlock(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002911 }
2912
Lachlan McIlroy461aa8a2008-03-06 13:43:11 +11002913 xfs_iunlock(ip, XFS_ILOCK_EXCL);
2914
Linus Torvalds1da177e2005-04-16 15:20:36 -07002915 reclaim:
2916 xfs_ireclaim(ip);
2917 return 0;
2918}
2919
2920int
2921xfs_finish_reclaim_all(xfs_mount_t *mp, int noblock)
2922{
2923 int purged;
2924 xfs_inode_t *ip, *n;
2925 int done = 0;
2926
2927 while (!done) {
2928 purged = 0;
2929 XFS_MOUNT_ILOCK(mp);
2930 list_for_each_entry_safe(ip, n, &mp->m_del_inodes, i_reclaim) {
2931 if (noblock) {
2932 if (xfs_ilock_nowait(ip, XFS_ILOCK_EXCL) == 0)
2933 continue;
2934 if (xfs_ipincount(ip) ||
2935 !xfs_iflock_nowait(ip)) {
2936 xfs_iunlock(ip, XFS_ILOCK_EXCL);
2937 continue;
2938 }
2939 }
2940 XFS_MOUNT_IUNLOCK(mp);
Felix Blyakher6b2cf612005-11-25 16:42:13 +11002941 if (xfs_finish_reclaim(ip, noblock,
2942 XFS_IFLUSH_DELWRI_ELSE_ASYNC))
2943 delay(1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002944 purged = 1;
2945 break;
2946 }
2947
2948 done = !purged;
2949 }
2950
2951 XFS_MOUNT_IUNLOCK(mp);
2952 return 0;
2953}
2954
2955/*
2956 * xfs_alloc_file_space()
2957 * This routine allocates disk space for the given file.
2958 *
2959 * If alloc_type == 0, this request is for an ALLOCSP type
2960 * request which will change the file size. In this case, no
2961 * DMAPI event will be generated by the call. A TRUNCATE event
2962 * will be generated later by xfs_setattr.
2963 *
2964 * If alloc_type != 0, this request is for a RESVSP type
2965 * request, and a DMAPI DM_EVENT_WRITE will be generated if the
2966 * lower block boundary byte address is less than the file's
2967 * length.
2968 *
2969 * RETURNS:
2970 * 0 on success
2971 * errno on error
2972 *
2973 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002974STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002975xfs_alloc_file_space(
2976 xfs_inode_t *ip,
2977 xfs_off_t offset,
2978 xfs_off_t len,
2979 int alloc_type,
2980 int attr_flags)
2981{
Nathan Scottdd9f4382006-01-11 15:28:28 +11002982 xfs_mount_t *mp = ip->i_mount;
2983 xfs_off_t count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002984 xfs_filblks_t allocated_fsb;
2985 xfs_filblks_t allocatesize_fsb;
Nathan Scottdd9f4382006-01-11 15:28:28 +11002986 xfs_extlen_t extsz, temp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002987 xfs_fileoff_t startoffset_fsb;
Nathan Scottdd9f4382006-01-11 15:28:28 +11002988 xfs_fsblock_t firstfsb;
2989 int nimaps;
2990 int bmapi_flag;
2991 int quota_flag;
2992 int rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002993 xfs_trans_t *tp;
Nathan Scottdd9f4382006-01-11 15:28:28 +11002994 xfs_bmbt_irec_t imaps[1], *imapp;
2995 xfs_bmap_free_t free_list;
2996 uint qblocks, resblks, resrtextents;
2997 int committed;
2998 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002999
Lachlan McIlroycf441ee2008-02-07 16:42:19 +11003000 xfs_itrace_entry(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003001
3002 if (XFS_FORCED_SHUTDOWN(mp))
3003 return XFS_ERROR(EIO);
3004
Linus Torvalds1da177e2005-04-16 15:20:36 -07003005 if ((error = XFS_QM_DQATTACH(mp, ip, 0)))
3006 return error;
3007
3008 if (len <= 0)
3009 return XFS_ERROR(EINVAL);
3010
David Chinner957d0eb2007-06-18 16:50:37 +10003011 rt = XFS_IS_REALTIME_INODE(ip);
3012 extsz = xfs_get_extsz_hint(ip);
3013
Linus Torvalds1da177e2005-04-16 15:20:36 -07003014 count = len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003015 imapp = &imaps[0];
Nathan Scottdd9f4382006-01-11 15:28:28 +11003016 nimaps = 1;
3017 bmapi_flag = XFS_BMAPI_WRITE | (alloc_type ? XFS_BMAPI_PREALLOC : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003018 startoffset_fsb = XFS_B_TO_FSBT(mp, offset);
3019 allocatesize_fsb = XFS_B_TO_FSB(mp, count);
3020
3021 /* Generate a DMAPI event if needed. */
Lachlan McIlroyba87ea62007-05-08 13:49:46 +10003022 if (alloc_type != 0 && offset < ip->i_size &&
Christoph Hellwig0f285c82008-07-18 17:13:28 +10003023 (attr_flags & XFS_ATTR_DMI) == 0 &&
Christoph Hellwigeb9df392007-08-16 18:42:07 +10003024 DM_EVENT_ENABLED(ip, DM_EVENT_WRITE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003025 xfs_off_t end_dmi_offset;
3026
3027 end_dmi_offset = offset+len;
Lachlan McIlroyba87ea62007-05-08 13:49:46 +10003028 if (end_dmi_offset > ip->i_size)
3029 end_dmi_offset = ip->i_size;
Christoph Hellwigbc4ac742008-03-06 13:45:58 +11003030 error = XFS_SEND_DATA(mp, DM_EVENT_WRITE, ip, offset,
3031 end_dmi_offset - offset, 0, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003032 if (error)
Jesper Juhl014c2542006-01-15 02:37:08 +01003033 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003034 }
3035
3036 /*
Nathan Scottdd9f4382006-01-11 15:28:28 +11003037 * Allocate file space until done or until there is an error
Linus Torvalds1da177e2005-04-16 15:20:36 -07003038 */
3039retry:
3040 while (allocatesize_fsb && !error) {
Nathan Scottdd9f4382006-01-11 15:28:28 +11003041 xfs_fileoff_t s, e;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003042
Nathan Scottdd9f4382006-01-11 15:28:28 +11003043 /*
Nathan Scott3ddb8fa2006-01-11 15:33:02 +11003044 * Determine space reservations for data/realtime.
Nathan Scottdd9f4382006-01-11 15:28:28 +11003045 */
3046 if (unlikely(extsz)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003047 s = startoffset_fsb;
Nathan Scottdd9f4382006-01-11 15:28:28 +11003048 do_div(s, extsz);
3049 s *= extsz;
3050 e = startoffset_fsb + allocatesize_fsb;
3051 if ((temp = do_mod(startoffset_fsb, extsz)))
3052 e += temp;
3053 if ((temp = do_mod(e, extsz)))
3054 e += extsz - temp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003055 } else {
Nathan Scottdd9f4382006-01-11 15:28:28 +11003056 s = 0;
3057 e = allocatesize_fsb;
3058 }
3059
3060 if (unlikely(rt)) {
3061 resrtextents = qblocks = (uint)(e - s);
3062 resrtextents /= mp->m_sb.sb_rextsize;
3063 resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
3064 quota_flag = XFS_QMOPT_RES_RTBLKS;
3065 } else {
3066 resrtextents = 0;
3067 resblks = qblocks = \
3068 XFS_DIOSTRAT_SPACE_RES(mp, (uint)(e - s));
3069 quota_flag = XFS_QMOPT_RES_REGBLKS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003070 }
3071
3072 /*
Nathan Scottdd9f4382006-01-11 15:28:28 +11003073 * Allocate and setup the transaction.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003074 */
3075 tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
Nathan Scottdd9f4382006-01-11 15:28:28 +11003076 error = xfs_trans_reserve(tp, resblks,
3077 XFS_WRITE_LOG_RES(mp), resrtextents,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003078 XFS_TRANS_PERM_LOG_RES,
3079 XFS_WRITE_LOG_COUNT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003080 /*
Nathan Scottdd9f4382006-01-11 15:28:28 +11003081 * Check for running out of space
Linus Torvalds1da177e2005-04-16 15:20:36 -07003082 */
3083 if (error) {
3084 /*
3085 * Free the transaction structure.
3086 */
3087 ASSERT(error == ENOSPC || XFS_FORCED_SHUTDOWN(mp));
3088 xfs_trans_cancel(tp, 0);
3089 break;
3090 }
3091 xfs_ilock(ip, XFS_ILOCK_EXCL);
Nathan Scottdd9f4382006-01-11 15:28:28 +11003092 error = XFS_TRANS_RESERVE_QUOTA_NBLKS(mp, tp, ip,
3093 qblocks, 0, quota_flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003094 if (error)
3095 goto error1;
3096
3097 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
3098 xfs_trans_ihold(tp, ip);
3099
3100 /*
Nathan Scottdd9f4382006-01-11 15:28:28 +11003101 * Issue the xfs_bmapi() call to allocate the blocks
Linus Torvalds1da177e2005-04-16 15:20:36 -07003102 */
3103 XFS_BMAP_INIT(&free_list, &firstfsb);
Lachlan McIlroy541d7d32007-10-11 17:34:33 +10003104 error = xfs_bmapi(tp, ip, startoffset_fsb,
Nathan Scottdd9f4382006-01-11 15:28:28 +11003105 allocatesize_fsb, bmapi_flag,
3106 &firstfsb, 0, imapp, &nimaps,
Olaf Weber3e57ecf2006-06-09 14:48:12 +10003107 &free_list, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003108 if (error) {
3109 goto error0;
3110 }
3111
3112 /*
Nathan Scottdd9f4382006-01-11 15:28:28 +11003113 * Complete the transaction
Linus Torvalds1da177e2005-04-16 15:20:36 -07003114 */
Eric Sandeenf7c99b62007-02-10 18:37:16 +11003115 error = xfs_bmap_finish(&tp, &free_list, &committed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003116 if (error) {
3117 goto error0;
3118 }
3119
Eric Sandeen1c72bf92007-05-08 13:48:42 +10003120 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003121 xfs_iunlock(ip, XFS_ILOCK_EXCL);
3122 if (error) {
3123 break;
3124 }
3125
3126 allocated_fsb = imapp->br_blockcount;
3127
Nathan Scottdd9f4382006-01-11 15:28:28 +11003128 if (nimaps == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003129 error = XFS_ERROR(ENOSPC);
3130 break;
3131 }
3132
3133 startoffset_fsb += allocated_fsb;
3134 allocatesize_fsb -= allocated_fsb;
3135 }
3136dmapi_enospc_check:
Christoph Hellwig0f285c82008-07-18 17:13:28 +10003137 if (error == ENOSPC && (attr_flags & XFS_ATTR_DMI) == 0 &&
Christoph Hellwigeb9df392007-08-16 18:42:07 +10003138 DM_EVENT_ENABLED(ip, DM_EVENT_NOSPACE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003139 error = XFS_SEND_NAMESP(mp, DM_EVENT_NOSPACE,
Christoph Hellwigbc4ac742008-03-06 13:45:58 +11003140 ip, DM_RIGHT_NULL,
3141 ip, DM_RIGHT_NULL,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003142 NULL, NULL, 0, 0, 0); /* Delay flag intentionally unused */
3143 if (error == 0)
3144 goto retry; /* Maybe DMAPI app. has made space */
3145 /* else fall through with error from XFS_SEND_DATA */
3146 }
3147
3148 return error;
3149
Nathan Scottdd9f4382006-01-11 15:28:28 +11003150error0: /* Cancel bmap, unlock inode, unreserve quota blocks, cancel trans */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003151 xfs_bmap_cancel(&free_list);
Nathan Scottdd9f4382006-01-11 15:28:28 +11003152 XFS_TRANS_UNRESERVE_QUOTA_NBLKS(mp, tp, ip, qblocks, 0, quota_flag);
3153
3154error1: /* Just cancel transaction */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003155 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
3156 xfs_iunlock(ip, XFS_ILOCK_EXCL);
3157 goto dmapi_enospc_check;
3158}
3159
3160/*
3161 * Zero file bytes between startoff and endoff inclusive.
3162 * The iolock is held exclusive and no blocks are buffered.
Lachlan McIlroy2fd6f6e2008-09-17 16:52:50 +10003163 *
3164 * This function is used by xfs_free_file_space() to zero
3165 * partial blocks when the range to free is not block aligned.
3166 * When unreserving space with boundaries that are not block
3167 * aligned we round up the start and round down the end
3168 * boundaries and then use this function to zero the parts of
3169 * the blocks that got dropped during the rounding.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003170 */
3171STATIC int
3172xfs_zero_remaining_bytes(
3173 xfs_inode_t *ip,
3174 xfs_off_t startoff,
3175 xfs_off_t endoff)
3176{
3177 xfs_bmbt_irec_t imap;
3178 xfs_fileoff_t offset_fsb;
3179 xfs_off_t lastoffset;
3180 xfs_off_t offset;
3181 xfs_buf_t *bp;
3182 xfs_mount_t *mp = ip->i_mount;
3183 int nimap;
3184 int error = 0;
3185
Lachlan McIlroy2fd6f6e2008-09-17 16:52:50 +10003186 /*
3187 * Avoid doing I/O beyond eof - it's not necessary
3188 * since nothing can read beyond eof. The space will
3189 * be zeroed when the file is extended anyway.
3190 */
3191 if (startoff >= ip->i_size)
3192 return 0;
3193
3194 if (endoff > ip->i_size)
3195 endoff = ip->i_size;
3196
Linus Torvalds1da177e2005-04-16 15:20:36 -07003197 bp = xfs_buf_get_noaddr(mp->m_sb.sb_blocksize,
Eric Sandeen71ddabb2007-11-23 16:29:42 +11003198 XFS_IS_REALTIME_INODE(ip) ?
Linus Torvalds1da177e2005-04-16 15:20:36 -07003199 mp->m_rtdev_targp : mp->m_ddev_targp);
3200
3201 for (offset = startoff; offset <= endoff; offset = lastoffset + 1) {
3202 offset_fsb = XFS_B_TO_FSBT(mp, offset);
3203 nimap = 1;
Lachlan McIlroy541d7d32007-10-11 17:34:33 +10003204 error = xfs_bmapi(NULL, ip, offset_fsb, 1, 0,
Olaf Weber3e57ecf2006-06-09 14:48:12 +10003205 NULL, 0, &imap, &nimap, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003206 if (error || nimap < 1)
3207 break;
3208 ASSERT(imap.br_blockcount >= 1);
3209 ASSERT(imap.br_startoff == offset_fsb);
3210 lastoffset = XFS_FSB_TO_B(mp, imap.br_startoff + 1) - 1;
3211 if (lastoffset > endoff)
3212 lastoffset = endoff;
3213 if (imap.br_startblock == HOLESTARTBLOCK)
3214 continue;
3215 ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
3216 if (imap.br_state == XFS_EXT_UNWRITTEN)
3217 continue;
3218 XFS_BUF_UNDONE(bp);
3219 XFS_BUF_UNWRITE(bp);
3220 XFS_BUF_READ(bp);
3221 XFS_BUF_SET_ADDR(bp, XFS_FSB_TO_DB(ip, imap.br_startblock));
3222 xfsbdstrat(mp, bp);
David Chinnerd64e31a2008-04-10 12:22:17 +10003223 error = xfs_iowait(bp);
3224 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003225 xfs_ioerror_alert("xfs_zero_remaining_bytes(read)",
3226 mp, bp, XFS_BUF_ADDR(bp));
3227 break;
3228 }
3229 memset(XFS_BUF_PTR(bp) +
3230 (offset - XFS_FSB_TO_B(mp, imap.br_startoff)),
3231 0, lastoffset - offset + 1);
3232 XFS_BUF_UNDONE(bp);
3233 XFS_BUF_UNREAD(bp);
3234 XFS_BUF_WRITE(bp);
3235 xfsbdstrat(mp, bp);
David Chinnerd64e31a2008-04-10 12:22:17 +10003236 error = xfs_iowait(bp);
3237 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003238 xfs_ioerror_alert("xfs_zero_remaining_bytes(write)",
3239 mp, bp, XFS_BUF_ADDR(bp));
3240 break;
3241 }
3242 }
3243 xfs_buf_free(bp);
3244 return error;
3245}
3246
3247/*
3248 * xfs_free_file_space()
3249 * This routine frees disk space for the given file.
3250 *
3251 * This routine is only called by xfs_change_file_space
3252 * for an UNRESVSP type call.
3253 *
3254 * RETURNS:
3255 * 0 on success
3256 * errno on error
3257 *
3258 */
3259STATIC int
3260xfs_free_file_space(
3261 xfs_inode_t *ip,
3262 xfs_off_t offset,
3263 xfs_off_t len,
3264 int attr_flags)
3265{
3266 int committed;
3267 int done;
3268 xfs_off_t end_dmi_offset;
3269 xfs_fileoff_t endoffset_fsb;
3270 int error;
3271 xfs_fsblock_t firstfsb;
3272 xfs_bmap_free_t free_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003273 xfs_bmbt_irec_t imap;
3274 xfs_off_t ioffset;
3275 xfs_extlen_t mod=0;
3276 xfs_mount_t *mp;
3277 int nimap;
3278 uint resblks;
Nathan Scott673cdf52006-09-28 10:56:26 +10003279 uint rounding;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003280 int rt;
3281 xfs_fileoff_t startoffset_fsb;
3282 xfs_trans_t *tp;
Dean Roehrich5fcbab32005-05-05 13:27:19 -07003283 int need_iolock = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003284
Linus Torvalds1da177e2005-04-16 15:20:36 -07003285 mp = ip->i_mount;
3286
Lachlan McIlroycf441ee2008-02-07 16:42:19 +11003287 xfs_itrace_entry(ip);
Christoph Hellwigbd5a8762005-06-21 15:47:39 +10003288
Linus Torvalds1da177e2005-04-16 15:20:36 -07003289 if ((error = XFS_QM_DQATTACH(mp, ip, 0)))
3290 return error;
3291
3292 error = 0;
3293 if (len <= 0) /* if nothing being freed */
3294 return error;
Eric Sandeen71ddabb2007-11-23 16:29:42 +11003295 rt = XFS_IS_REALTIME_INODE(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003296 startoffset_fsb = XFS_B_TO_FSB(mp, offset);
3297 end_dmi_offset = offset + len;
3298 endoffset_fsb = XFS_B_TO_FSBT(mp, end_dmi_offset);
3299
Christoph Hellwig0f285c82008-07-18 17:13:28 +10003300 if (offset < ip->i_size && (attr_flags & XFS_ATTR_DMI) == 0 &&
Christoph Hellwigeb9df392007-08-16 18:42:07 +10003301 DM_EVENT_ENABLED(ip, DM_EVENT_WRITE)) {
Lachlan McIlroyba87ea62007-05-08 13:49:46 +10003302 if (end_dmi_offset > ip->i_size)
3303 end_dmi_offset = ip->i_size;
Christoph Hellwigbc4ac742008-03-06 13:45:58 +11003304 error = XFS_SEND_DATA(mp, DM_EVENT_WRITE, ip,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003305 offset, end_dmi_offset - offset,
3306 AT_DELAY_FLAG(attr_flags), NULL);
3307 if (error)
Jesper Juhl014c2542006-01-15 02:37:08 +01003308 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003309 }
3310
Christoph Hellwig0f285c82008-07-18 17:13:28 +10003311 if (attr_flags & XFS_ATTR_NOLOCK)
Dean Roehrich5fcbab32005-05-05 13:27:19 -07003312 need_iolock = 0;
Yingping Lu9fa80462006-03-22 12:44:35 +11003313 if (need_iolock) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003314 xfs_ilock(ip, XFS_IOLOCK_EXCL);
Christoph Hellwigb677c212007-08-29 11:46:28 +10003315 vn_iowait(ip); /* wait for the completion of any pending DIOs */
Yingping Lu9fa80462006-03-22 12:44:35 +11003316 }
Dean Roehrich5fcbab32005-05-05 13:27:19 -07003317
Tim Shimmine6a4b372007-11-23 16:30:42 +11003318 rounding = max_t(uint, 1 << mp->m_sb.sb_blocklog, PAGE_CACHE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003319 ioffset = offset & ~(rounding - 1);
Christoph Hellwigbd5a8762005-06-21 15:47:39 +10003320
Christoph Hellwigdf80c932008-08-13 16:22:09 +10003321 if (VN_CACHED(VFS_I(ip)) != 0) {
Tim Shimmine6a4b372007-11-23 16:30:42 +11003322 xfs_inval_cached_trace(ip, ioffset, -1, ioffset, -1);
3323 error = xfs_flushinval_pages(ip, ioffset, -1, FI_REMAPF_LOCKED);
Lachlan McIlroyd3cf2092007-05-08 13:49:27 +10003324 if (error)
3325 goto out_unlock_iolock;
Christoph Hellwigbd5a8762005-06-21 15:47:39 +10003326 }
3327
Linus Torvalds1da177e2005-04-16 15:20:36 -07003328 /*
3329 * Need to zero the stuff we're not freeing, on disk.
3330 * If its a realtime file & can't use unwritten extents then we
3331 * actually need to zero the extent edges. Otherwise xfs_bunmapi
3332 * will take care of it for us.
3333 */
Eric Sandeen62118702008-03-06 13:44:28 +11003334 if (rt && !xfs_sb_version_hasextflgbit(&mp->m_sb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003335 nimap = 1;
Lachlan McIlroy541d7d32007-10-11 17:34:33 +10003336 error = xfs_bmapi(NULL, ip, startoffset_fsb,
Olaf Weber3e57ecf2006-06-09 14:48:12 +10003337 1, 0, NULL, 0, &imap, &nimap, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003338 if (error)
3339 goto out_unlock_iolock;
3340 ASSERT(nimap == 0 || nimap == 1);
3341 if (nimap && imap.br_startblock != HOLESTARTBLOCK) {
3342 xfs_daddr_t block;
3343
3344 ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
3345 block = imap.br_startblock;
3346 mod = do_div(block, mp->m_sb.sb_rextsize);
3347 if (mod)
3348 startoffset_fsb += mp->m_sb.sb_rextsize - mod;
3349 }
3350 nimap = 1;
Lachlan McIlroy541d7d32007-10-11 17:34:33 +10003351 error = xfs_bmapi(NULL, ip, endoffset_fsb - 1,
Olaf Weber3e57ecf2006-06-09 14:48:12 +10003352 1, 0, NULL, 0, &imap, &nimap, NULL, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003353 if (error)
3354 goto out_unlock_iolock;
3355 ASSERT(nimap == 0 || nimap == 1);
3356 if (nimap && imap.br_startblock != HOLESTARTBLOCK) {
3357 ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
3358 mod++;
3359 if (mod && (mod != mp->m_sb.sb_rextsize))
3360 endoffset_fsb -= mod;
3361 }
3362 }
3363 if ((done = (endoffset_fsb <= startoffset_fsb)))
3364 /*
3365 * One contiguous piece to clear
3366 */
3367 error = xfs_zero_remaining_bytes(ip, offset, offset + len - 1);
3368 else {
3369 /*
3370 * Some full blocks, possibly two pieces to clear
3371 */
3372 if (offset < XFS_FSB_TO_B(mp, startoffset_fsb))
3373 error = xfs_zero_remaining_bytes(ip, offset,
3374 XFS_FSB_TO_B(mp, startoffset_fsb) - 1);
3375 if (!error &&
3376 XFS_FSB_TO_B(mp, endoffset_fsb) < offset + len)
3377 error = xfs_zero_remaining_bytes(ip,
3378 XFS_FSB_TO_B(mp, endoffset_fsb),
3379 offset + len - 1);
3380 }
3381
3382 /*
3383 * free file space until done or until there is an error
3384 */
3385 resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
3386 while (!error && !done) {
3387
3388 /*
David Chinner91ebecc2007-07-19 16:28:30 +10003389 * allocate and setup the transaction. Allow this
3390 * transaction to dip into the reserve blocks to ensure
3391 * the freeing of the space succeeds at ENOSPC.
Linus Torvalds1da177e2005-04-16 15:20:36 -07003392 */
3393 tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
David Chinner91ebecc2007-07-19 16:28:30 +10003394 tp->t_flags |= XFS_TRANS_RESERVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003395 error = xfs_trans_reserve(tp,
3396 resblks,
3397 XFS_WRITE_LOG_RES(mp),
3398 0,
3399 XFS_TRANS_PERM_LOG_RES,
3400 XFS_WRITE_LOG_COUNT);
3401
3402 /*
3403 * check for running out of space
3404 */
3405 if (error) {
3406 /*
3407 * Free the transaction structure.
3408 */
3409 ASSERT(error == ENOSPC || XFS_FORCED_SHUTDOWN(mp));
3410 xfs_trans_cancel(tp, 0);
3411 break;
3412 }
3413 xfs_ilock(ip, XFS_ILOCK_EXCL);
3414 error = XFS_TRANS_RESERVE_QUOTA(mp, tp,
Nathan Scottdd9f4382006-01-11 15:28:28 +11003415 ip->i_udquot, ip->i_gdquot, resblks, 0,
3416 XFS_QMOPT_RES_REGBLKS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003417 if (error)
3418 goto error1;
3419
3420 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
3421 xfs_trans_ihold(tp, ip);
3422
3423 /*
3424 * issue the bunmapi() call to free the blocks
3425 */
3426 XFS_BMAP_INIT(&free_list, &firstfsb);
Lachlan McIlroy541d7d32007-10-11 17:34:33 +10003427 error = xfs_bunmapi(tp, ip, startoffset_fsb,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003428 endoffset_fsb - startoffset_fsb,
Olaf Weber3e57ecf2006-06-09 14:48:12 +10003429 0, 2, &firstfsb, &free_list, NULL, &done);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003430 if (error) {
3431 goto error0;
3432 }
3433
3434 /*
3435 * complete the transaction
3436 */
Eric Sandeenf7c99b62007-02-10 18:37:16 +11003437 error = xfs_bmap_finish(&tp, &free_list, &committed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003438 if (error) {
3439 goto error0;
3440 }
3441
Eric Sandeen1c72bf92007-05-08 13:48:42 +10003442 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003443 xfs_iunlock(ip, XFS_ILOCK_EXCL);
3444 }
3445
3446 out_unlock_iolock:
3447 if (need_iolock)
3448 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
3449 return error;
3450
3451 error0:
3452 xfs_bmap_cancel(&free_list);
3453 error1:
3454 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
3455 xfs_iunlock(ip, need_iolock ? (XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL) :
3456 XFS_ILOCK_EXCL);
3457 return error;
3458}
3459
3460/*
3461 * xfs_change_file_space()
3462 * This routine allocates or frees disk space for the given file.
3463 * The user specified parameters are checked for alignment and size
3464 * limitations.
3465 *
3466 * RETURNS:
3467 * 0 on success
3468 * errno on error
3469 *
3470 */
3471int
3472xfs_change_file_space(
Christoph Hellwig993386c2007-08-28 16:12:30 +10003473 xfs_inode_t *ip,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003474 int cmd,
3475 xfs_flock64_t *bf,
3476 xfs_off_t offset,
3477 cred_t *credp,
3478 int attr_flags)
3479{
Christoph Hellwig993386c2007-08-28 16:12:30 +10003480 xfs_mount_t *mp = ip->i_mount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003481 int clrprealloc;
3482 int error;
3483 xfs_fsize_t fsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003484 int setprealloc;
3485 xfs_off_t startoffset;
3486 xfs_off_t llen;
3487 xfs_trans_t *tp;
Christoph Hellwig0f285c82008-07-18 17:13:28 +10003488 struct iattr iattr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003489
Lachlan McIlroycf441ee2008-02-07 16:42:19 +11003490 xfs_itrace_entry(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003491
Christoph Hellwig993386c2007-08-28 16:12:30 +10003492 if (!S_ISREG(ip->i_d.di_mode))
Linus Torvalds1da177e2005-04-16 15:20:36 -07003493 return XFS_ERROR(EINVAL);
3494
Linus Torvalds1da177e2005-04-16 15:20:36 -07003495 switch (bf->l_whence) {
3496 case 0: /*SEEK_SET*/
3497 break;
3498 case 1: /*SEEK_CUR*/
3499 bf->l_start += offset;
3500 break;
3501 case 2: /*SEEK_END*/
Lachlan McIlroyba87ea62007-05-08 13:49:46 +10003502 bf->l_start += ip->i_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003503 break;
3504 default:
3505 return XFS_ERROR(EINVAL);
3506 }
3507
3508 llen = bf->l_len > 0 ? bf->l_len - 1 : bf->l_len;
3509
3510 if ( (bf->l_start < 0)
3511 || (bf->l_start > XFS_MAXIOFFSET(mp))
3512 || (bf->l_start + llen < 0)
3513 || (bf->l_start + llen > XFS_MAXIOFFSET(mp)))
3514 return XFS_ERROR(EINVAL);
3515
3516 bf->l_whence = 0;
3517
3518 startoffset = bf->l_start;
Lachlan McIlroyba87ea62007-05-08 13:49:46 +10003519 fsize = ip->i_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003520
3521 /*
3522 * XFS_IOC_RESVSP and XFS_IOC_UNRESVSP will reserve or unreserve
3523 * file space.
3524 * These calls do NOT zero the data space allocated to the file,
3525 * nor do they change the file size.
3526 *
3527 * XFS_IOC_ALLOCSP and XFS_IOC_FREESP will allocate and free file
3528 * space.
3529 * These calls cause the new file data to be zeroed and the file
3530 * size to be changed.
3531 */
3532 setprealloc = clrprealloc = 0;
3533
3534 switch (cmd) {
3535 case XFS_IOC_RESVSP:
3536 case XFS_IOC_RESVSP64:
3537 error = xfs_alloc_file_space(ip, startoffset, bf->l_len,
3538 1, attr_flags);
3539 if (error)
3540 return error;
3541 setprealloc = 1;
3542 break;
3543
3544 case XFS_IOC_UNRESVSP:
3545 case XFS_IOC_UNRESVSP64:
3546 if ((error = xfs_free_file_space(ip, startoffset, bf->l_len,
3547 attr_flags)))
3548 return error;
3549 break;
3550
3551 case XFS_IOC_ALLOCSP:
3552 case XFS_IOC_ALLOCSP64:
3553 case XFS_IOC_FREESP:
3554 case XFS_IOC_FREESP64:
3555 if (startoffset > fsize) {
3556 error = xfs_alloc_file_space(ip, fsize,
3557 startoffset - fsize, 0, attr_flags);
3558 if (error)
3559 break;
3560 }
3561
Christoph Hellwig0f285c82008-07-18 17:13:28 +10003562 iattr.ia_valid = ATTR_SIZE;
3563 iattr.ia_size = startoffset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003564
Christoph Hellwig0f285c82008-07-18 17:13:28 +10003565 error = xfs_setattr(ip, &iattr, attr_flags, credp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003566
3567 if (error)
3568 return error;
3569
3570 clrprealloc = 1;
3571 break;
3572
3573 default:
3574 ASSERT(0);
3575 return XFS_ERROR(EINVAL);
3576 }
3577
3578 /*
3579 * update the inode timestamp, mode, and prealloc flag bits
3580 */
3581 tp = xfs_trans_alloc(mp, XFS_TRANS_WRITEID);
3582
3583 if ((error = xfs_trans_reserve(tp, 0, XFS_WRITEID_LOG_RES(mp),
3584 0, 0, 0))) {
3585 /* ASSERT(0); */
3586 xfs_trans_cancel(tp, 0);
3587 return error;
3588 }
3589
3590 xfs_ilock(ip, XFS_ILOCK_EXCL);
3591
3592 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
3593 xfs_trans_ihold(tp, ip);
3594
Christoph Hellwig0f285c82008-07-18 17:13:28 +10003595 if ((attr_flags & XFS_ATTR_DMI) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003596 ip->i_d.di_mode &= ~S_ISUID;
3597
3598 /*
3599 * Note that we don't have to worry about mandatory
3600 * file locking being disabled here because we only
3601 * clear the S_ISGID bit if the Group execute bit is
3602 * on, but if it was on then mandatory locking wouldn't
3603 * have been enabled.
3604 */
3605 if (ip->i_d.di_mode & S_IXGRP)
3606 ip->i_d.di_mode &= ~S_ISGID;
3607
3608 xfs_ichgtime(ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
3609 }
3610 if (setprealloc)
3611 ip->i_d.di_flags |= XFS_DIFLAG_PREALLOC;
3612 else if (clrprealloc)
3613 ip->i_d.di_flags &= ~XFS_DIFLAG_PREALLOC;
3614
3615 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
3616 xfs_trans_set_sync(tp);
3617
Eric Sandeen1c72bf92007-05-08 13:48:42 +10003618 error = xfs_trans_commit(tp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003619
3620 xfs_iunlock(ip, XFS_ILOCK_EXCL);
3621
3622 return error;
3623}