blob: 4c7c7bfb2b2fc0aa8cc3cb3c98334392eb902c00 [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"
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include "xfs_mount.h"
Nathan Scotta844f452005-11-02 14:38:42 +110030#include "xfs_da_btree.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070031#include "xfs_bmap_btree.h"
32#include "xfs_ialloc_btree.h"
Nathan Scotta844f452005-11-02 14:38:42 +110033#include "xfs_dinode.h"
34#include "xfs_inode.h"
35#include "xfs_inode_item.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include "xfs_itable.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include "xfs_ialloc.h"
38#include "xfs_alloc.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070039#include "xfs_bmap.h"
Christoph Hellwigef14f0c2009-06-10 17:07:47 +020040#include "xfs_acl.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include "xfs_attr.h"
42#include "xfs_rw.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070043#include "xfs_error.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070044#include "xfs_quota.h"
45#include "xfs_utils.h"
Nathan Scotta844f452005-11-02 14:38:42 +110046#include "xfs_rtalloc.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070047#include "xfs_trans_space.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070048#include "xfs_log_priv.h"
David Chinner2a82b8b2007-07-11 11:09:12 +100049#include "xfs_filestream.h"
Christoph Hellwig993386c2007-08-28 16:12:30 +100050#include "xfs_vnodeops.h"
Christoph Hellwig0b1b2132009-12-14 23:14:59 +000051#include "xfs_trace.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070052
Christoph Hellwig993386c2007-08-28 16:12:30 +100053int
Linus Torvalds1da177e2005-04-16 15:20:36 -070054xfs_setattr(
Christoph Hellwig0f285c82008-07-18 17:13:28 +100055 struct xfs_inode *ip,
56 struct iattr *iattr,
Christoph Hellwigea5a3dc82008-10-30 18:27:48 +110057 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -070058{
Christoph Hellwig993386c2007-08-28 16:12:30 +100059 xfs_mount_t *mp = ip->i_mount;
David Chinnere4f75292008-08-13 16:00:45 +100060 struct inode *inode = VFS_I(ip);
Christoph Hellwig0f285c82008-07-18 17:13:28 +100061 int mask = iattr->ia_valid;
Linus Torvalds1da177e2005-04-16 15:20:36 -070062 xfs_trans_t *tp;
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 int code;
64 uint lock_flags;
65 uint commit_flags=0;
66 uid_t uid=0, iuid=0;
67 gid_t gid=0, igid=0;
Linus Torvalds1da177e2005-04-16 15:20:36 -070068 struct xfs_dquot *udqp, *gdqp, *olddquot1, *olddquot2;
Dean Roehrich5fcbab32005-05-05 13:27:19 -070069 int need_iolock = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070070
Christoph Hellwigcca28fb2010-06-24 11:57:09 +100071 trace_xfs_setattr(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -070072
Christoph Hellwigbd186aa2007-08-30 17:21:12 +100073 if (mp->m_flags & XFS_MOUNT_RDONLY)
Linus Torvalds1da177e2005-04-16 15:20:36 -070074 return XFS_ERROR(EROFS);
75
Linus Torvalds1da177e2005-04-16 15:20:36 -070076 if (XFS_FORCED_SHUTDOWN(mp))
77 return XFS_ERROR(EIO);
78
Christoph Hellwigc4cd7472008-12-09 04:47:34 -050079 code = -inode_change_ok(inode, iattr);
80 if (code)
81 return code;
82
Linus Torvalds1da177e2005-04-16 15:20:36 -070083 olddquot1 = olddquot2 = NULL;
84 udqp = gdqp = NULL;
85
86 /*
87 * If disk quotas is on, we make sure that the dquots do exist on disk,
88 * before we start any other transactions. Trying to do this later
89 * is messy. We don't care to take a readlock to look at the ids
90 * in inode here, because we can't hold it across the trans_reserve.
91 * If the IDs do change before we take the ilock, we're covered
92 * because the i_*dquot fields will get updated anyway.
93 */
Christoph Hellwig0f285c82008-07-18 17:13:28 +100094 if (XFS_IS_QUOTA_ON(mp) && (mask & (ATTR_UID|ATTR_GID))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 uint qflags = 0;
96
Christoph Hellwig0f285c82008-07-18 17:13:28 +100097 if ((mask & ATTR_UID) && XFS_IS_UQUOTA_ON(mp)) {
98 uid = iattr->ia_uid;
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 qflags |= XFS_QMOPT_UQUOTA;
100 } else {
101 uid = ip->i_d.di_uid;
102 }
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000103 if ((mask & ATTR_GID) && XFS_IS_GQUOTA_ON(mp)) {
104 gid = iattr->ia_gid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105 qflags |= XFS_QMOPT_GQUOTA;
106 } else {
107 gid = ip->i_d.di_gid;
108 }
Christoph Hellwig25fe55e2008-07-18 17:13:20 +1000109
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 /*
111 * We take a reference when we initialize udqp and gdqp,
112 * so it is important that we never blindly double trip on
113 * the same variable. See xfs_create() for an example.
114 */
115 ASSERT(udqp == NULL);
116 ASSERT(gdqp == NULL);
Christoph Hellwig7d095252009-06-08 15:33:32 +0200117 code = xfs_qm_vop_dqalloc(ip, uid, gid, ip->i_d.di_projid,
Christoph Hellwig25fe55e2008-07-18 17:13:20 +1000118 qflags, &udqp, &gdqp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 if (code)
Jesper Juhl014c2542006-01-15 02:37:08 +0100120 return code;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121 }
122
123 /*
124 * For the other attributes, we acquire the inode lock and
125 * first do an error checking pass.
126 */
127 tp = NULL;
128 lock_flags = XFS_ILOCK_EXCL;
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000129 if (flags & XFS_ATTR_NOLOCK)
Dean Roehrich5fcbab32005-05-05 13:27:19 -0700130 need_iolock = 0;
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000131 if (!(mask & ATTR_SIZE)) {
Christoph Hellwigd6d59ba2009-12-23 16:09:13 +0000132 tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_NOT_SIZE);
133 commit_flags = 0;
134 code = xfs_trans_reserve(tp, 0, XFS_ICHANGE_LOG_RES(mp),
135 0, 0, 0);
136 if (code) {
137 lock_flags = 0;
138 goto error_return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 }
140 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 if (need_iolock)
142 lock_flags |= XFS_IOLOCK_EXCL;
143 }
144
145 xfs_ilock(ip, lock_flags);
146
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 /*
148 * Change file ownership. Must be the owner or privileged.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 */
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000150 if (mask & (ATTR_UID|ATTR_GID)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 /*
152 * These IDs could have changed since we last looked at them.
153 * But, we're assured that if the ownership did change
154 * while we didn't have the inode locked, inode's dquot(s)
155 * would have changed also.
156 */
157 iuid = ip->i_d.di_uid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158 igid = ip->i_d.di_gid;
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000159 gid = (mask & ATTR_GID) ? iattr->ia_gid : igid;
160 uid = (mask & ATTR_UID) ? iattr->ia_uid : iuid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161
162 /*
Christoph Hellwig25fe55e2008-07-18 17:13:20 +1000163 * Do a quota reservation only if uid/gid is actually
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 * going to change.
165 */
Christoph Hellwig7d095252009-06-08 15:33:32 +0200166 if (XFS_IS_QUOTA_RUNNING(mp) &&
167 ((XFS_IS_UQUOTA_ON(mp) && iuid != uid) ||
168 (XFS_IS_GQUOTA_ON(mp) && igid != gid))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 ASSERT(tp);
Christoph Hellwig7d095252009-06-08 15:33:32 +0200170 code = xfs_qm_vop_chown_reserve(tp, ip, udqp, gdqp,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 capable(CAP_FOWNER) ?
172 XFS_QMOPT_FORCE_RES : 0);
173 if (code) /* out of quota */
174 goto error_return;
175 }
176 }
177
178 /*
179 * Truncate file. Must have write permission and not be a directory.
180 */
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000181 if (mask & ATTR_SIZE) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 /* Short circuit the truncate case for zero length files */
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000183 if (iattr->ia_size == 0 &&
184 ip->i_size == 0 && ip->i_d.di_nextents == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700185 xfs_iunlock(ip, XFS_ILOCK_EXCL);
186 lock_flags &= ~XFS_ILOCK_EXCL;
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000187 if (mask & ATTR_CTIME)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 xfs_ichgtime(ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
189 code = 0;
190 goto error_return;
191 }
192
Christoph Hellwig42173f62008-04-22 17:33:25 +1000193 if (S_ISDIR(ip->i_d.di_mode)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700194 code = XFS_ERROR(EISDIR);
195 goto error_return;
Christoph Hellwig42173f62008-04-22 17:33:25 +1000196 } else if (!S_ISREG(ip->i_d.di_mode)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 code = XFS_ERROR(EINVAL);
198 goto error_return;
199 }
Christoph Hellwigc4cd7472008-12-09 04:47:34 -0500200
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 /*
202 * Make sure that the dquots are attached to the inode.
203 */
Christoph Hellwig7d095252009-06-08 15:33:32 +0200204 code = xfs_qm_dqattach_locked(ip, 0);
Christoph Hellwigc4cd7472008-12-09 04:47:34 -0500205 if (code)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 goto error_return;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207
Christoph Hellwigc4cd7472008-12-09 04:47:34 -0500208 /*
209 * Now we can make the changes. Before we join the inode
210 * to the transaction, if ATTR_SIZE is set then take care of
211 * the part of the truncation that must be done without the
212 * inode lock. This needs to be done before joining the inode
213 * to the transaction, because the inode cannot be unlocked
214 * once it is a part of the transaction.
215 */
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000216 if (iattr->ia_size > ip->i_size) {
Christoph Hellwig61436fe2008-05-20 11:30:46 +1000217 /*
218 * Do the first part of growing a file: zero any data
219 * in the last block that is beyond the old EOF. We
220 * need to do this before the inode is joined to the
221 * transaction to modify the i_size.
222 */
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000223 code = xfs_zero_eof(ip, iattr->ia_size, ip->i_size);
Christoph Hellwigfa9b2272010-06-14 05:17:31 -0400224 if (code)
225 goto error_return;
Eric Sandeen374e2ac2005-11-02 15:07:34 +1100226 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700227 xfs_iunlock(ip, XFS_ILOCK_EXCL);
Christoph Hellwigfa9b2272010-06-14 05:17:31 -0400228 lock_flags &= ~XFS_ILOCK_EXCL;
David Chinnerc32676e2007-07-19 16:28:58 +1000229
230 /*
231 * We are going to log the inode size change in this
232 * transaction so any previous writes that are beyond the on
233 * disk EOF and the new EOF that have not been written out need
234 * to be written here. If we do not write the data out, we
235 * expose ourselves to the null files problem.
236 *
237 * Only flush from the on disk size to the smaller of the in
238 * memory file size or the new size as that's the range we
239 * really care about here and prevents waiting for other data
240 * not within the range we care about here.
241 */
Christoph Hellwigfa9b2272010-06-14 05:17:31 -0400242 if (ip->i_size != ip->i_d.di_size &&
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000243 iattr->ia_size > ip->i_d.di_size) {
Christoph Hellwig739bfb22007-08-29 10:58:01 +1000244 code = xfs_flush_pages(ip,
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000245 ip->i_d.di_size, iattr->ia_size,
Christoph Hellwig0cadda12010-01-19 09:56:44 +0000246 XBF_ASYNC, FI_NONE);
Christoph Hellwigfa9b2272010-06-14 05:17:31 -0400247 if (code)
248 goto error_return;
David Chinnerc32676e2007-07-19 16:28:58 +1000249 }
250
251 /* wait for all I/O to complete */
Christoph Hellwig25e41b32008-12-03 12:20:39 +0100252 xfs_ioend_wait(ip);
David Chinnerc32676e2007-07-19 16:28:58 +1000253
Christoph Hellwigfa9b2272010-06-14 05:17:31 -0400254 code = -block_truncate_page(inode->i_mapping, iattr->ia_size,
255 xfs_get_blocks);
256 if (code)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 goto error_return;
Christoph Hellwigfa9b2272010-06-14 05:17:31 -0400258
Linus Torvalds1da177e2005-04-16 15:20:36 -0700259 tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_SIZE);
Christoph Hellwigfa9b2272010-06-14 05:17:31 -0400260 code = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0,
261 XFS_TRANS_PERM_LOG_RES,
262 XFS_ITRUNCATE_LOG_COUNT);
263 if (code)
264 goto error_return;
265
266 truncate_setsize(inode, iattr->ia_size);
267
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 commit_flags = XFS_TRANS_RELEASE_LOG_RES;
Christoph Hellwigfa9b2272010-06-14 05:17:31 -0400269 lock_flags |= XFS_ILOCK_EXCL;
270
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 xfs_ilock(ip, XFS_ILOCK_EXCL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272
Christoph Hellwig898621d2010-06-24 11:36:58 +1000273 xfs_trans_ijoin(tp, ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274
David Chinner44d814c2008-03-06 13:45:29 +1100275 /*
276 * Only change the c/mtime if we are changing the size
277 * or we are explicitly asked to change it. This handles
278 * the semantic difference between truncate() and ftruncate()
279 * as implemented in the VFS.
Christoph Hellwigd6d59ba2009-12-23 16:09:13 +0000280 *
281 * The regular truncate() case without ATTR_CTIME and ATTR_MTIME
282 * is a special case where we need to update the times despite
283 * not having these flags set. For all other operations the
284 * VFS set these flags explicitly if it wants a timestamp
285 * update.
David Chinner44d814c2008-03-06 13:45:29 +1100286 */
Christoph Hellwigd6d59ba2009-12-23 16:09:13 +0000287 if (iattr->ia_size != ip->i_size &&
288 (!(mask & (ATTR_CTIME | ATTR_MTIME)))) {
289 iattr->ia_ctime = iattr->ia_mtime =
290 current_fs_time(inode->i_sb);
291 mask |= ATTR_CTIME | ATTR_MTIME;
292 }
David Chinner44d814c2008-03-06 13:45:29 +1100293
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000294 if (iattr->ia_size > ip->i_size) {
295 ip->i_d.di_size = iattr->ia_size;
296 ip->i_size = iattr->ia_size;
Christoph Hellwig61436fe2008-05-20 11:30:46 +1000297 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000298 } else if (iattr->ia_size <= ip->i_size ||
299 (iattr->ia_size == 0 && ip->i_d.di_nextents)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300 /*
301 * signal a sync transaction unless
302 * we're truncating an already unlinked
303 * file on a wsync filesystem
304 */
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000305 code = xfs_itruncate_finish(&tp, ip, iattr->ia_size,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 XFS_DATA_FORK,
307 ((ip->i_d.di_nlink != 0 ||
308 !(mp->m_flags & XFS_MOUNT_WSYNC))
309 ? 1 : 0));
Nathan Scott7d4fb402006-06-09 15:27:16 +1000310 if (code)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 goto abort_return;
Nathan Scott7d4fb402006-06-09 15:27:16 +1000312 /*
313 * Truncated "down", so we're removing references
314 * to old data here - if we now delay flushing for
315 * a long time, we expose ourselves unduly to the
316 * notorious NULL files problem. So, we mark this
317 * vnode and flush it when the file is closed, and
318 * do not wait the usual (long) time for writeout.
319 */
Christoph Hellwigb3aea4e2007-08-29 11:44:37 +1000320 xfs_iflags_set(ip, XFS_ITRUNCATED);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 }
Christoph Hellwigc4cd7472008-12-09 04:47:34 -0500322 } else if (tp) {
Christoph Hellwig898621d2010-06-24 11:36:58 +1000323 xfs_trans_ijoin(tp, ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 }
325
326 /*
327 * Change file ownership. Must be the owner or privileged.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 */
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000329 if (mask & (ATTR_UID|ATTR_GID)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330 /*
331 * CAP_FSETID overrides the following restrictions:
332 *
333 * The set-user-ID and set-group-ID bits of a file will be
334 * cleared upon successful return from chown()
335 */
336 if ((ip->i_d.di_mode & (S_ISUID|S_ISGID)) &&
337 !capable(CAP_FSETID)) {
338 ip->i_d.di_mode &= ~(S_ISUID|S_ISGID);
339 }
340
341 /*
342 * Change the ownerships and register quota modifications
343 * in the transaction.
344 */
345 if (iuid != uid) {
Christoph Hellwig7d095252009-06-08 15:33:32 +0200346 if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_UQUOTA_ON(mp)) {
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000347 ASSERT(mask & ATTR_UID);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 ASSERT(udqp);
Christoph Hellwig7d095252009-06-08 15:33:32 +0200349 olddquot1 = xfs_qm_vop_chown(tp, ip,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 &ip->i_udquot, udqp);
351 }
352 ip->i_d.di_uid = uid;
Christoph Hellwigf13fae22008-07-21 16:16:15 +1000353 inode->i_uid = uid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 }
355 if (igid != gid) {
Christoph Hellwig7d095252009-06-08 15:33:32 +0200356 if (XFS_IS_QUOTA_RUNNING(mp) && XFS_IS_GQUOTA_ON(mp)) {
Nathan Scottc8ad20f2005-06-21 15:38:48 +1000357 ASSERT(!XFS_IS_PQUOTA_ON(mp));
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000358 ASSERT(mask & ATTR_GID);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 ASSERT(gdqp);
Christoph Hellwig7d095252009-06-08 15:33:32 +0200360 olddquot2 = xfs_qm_vop_chown(tp, ip,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 &ip->i_gdquot, gdqp);
362 }
363 ip->i_d.di_gid = gid;
Christoph Hellwigf13fae22008-07-21 16:16:15 +1000364 inode->i_gid = gid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 }
367
Christoph Hellwigc4cd7472008-12-09 04:47:34 -0500368 /*
369 * Change file access modes.
370 */
371 if (mask & ATTR_MODE) {
372 umode_t mode = iattr->ia_mode;
373
374 if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID))
375 mode &= ~S_ISGID;
376
377 ip->i_d.di_mode &= S_IFMT;
378 ip->i_d.di_mode |= mode & ~S_IFMT;
379
380 inode->i_mode &= S_IFMT;
381 inode->i_mode |= mode & ~S_IFMT;
Christoph Hellwigc4cd7472008-12-09 04:47:34 -0500382 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383
384 /*
385 * Change file access or modified times.
386 */
Christoph Hellwigd6d59ba2009-12-23 16:09:13 +0000387 if (mask & ATTR_ATIME) {
388 inode->i_atime = iattr->ia_atime;
389 ip->i_d.di_atime.t_sec = iattr->ia_atime.tv_sec;
390 ip->i_d.di_atime.t_nsec = iattr->ia_atime.tv_nsec;
391 ip->i_update_core = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 }
Christoph Hellwigd6d59ba2009-12-23 16:09:13 +0000393 if (mask & ATTR_CTIME) {
Christoph Hellwigf13fae22008-07-21 16:16:15 +1000394 inode->i_ctime = iattr->ia_ctime;
Christoph Hellwig0f285c82008-07-18 17:13:28 +1000395 ip->i_d.di_ctime.t_sec = iattr->ia_ctime.tv_sec;
396 ip->i_d.di_ctime.t_nsec = iattr->ia_ctime.tv_nsec;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 ip->i_update_core = 1;
Christoph Hellwigd6d59ba2009-12-23 16:09:13 +0000398 }
399 if (mask & ATTR_MTIME) {
400 inode->i_mtime = iattr->ia_mtime;
401 ip->i_d.di_mtime.t_sec = iattr->ia_mtime.tv_sec;
402 ip->i_d.di_mtime.t_nsec = iattr->ia_mtime.tv_nsec;
403 ip->i_update_core = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700404 }
405
406 /*
Christoph Hellwigd6d59ba2009-12-23 16:09:13 +0000407 * And finally, log the inode core if any attribute in it
408 * has been changed.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 */
Christoph Hellwigd6d59ba2009-12-23 16:09:13 +0000410 if (mask & (ATTR_UID|ATTR_GID|ATTR_MODE|
411 ATTR_ATIME|ATTR_CTIME|ATTR_MTIME))
412 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413
414 XFS_STATS_INC(xs_ig_attrchg);
415
416 /*
417 * If this is a synchronous mount, make sure that the
418 * transaction goes to disk before returning to the user.
419 * This is slightly sub-optimal in that truncates require
Nathan Scottc41564b2006-03-29 08:55:14 +1000420 * two sync transactions instead of one for wsync filesystems.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 * One for the truncate and one for the timestamps since we
422 * don't want to change the timestamps unless we're sure the
423 * truncate worked. Truncates are less than 1% of the laddis
424 * mix so this probably isn't worth the trouble to optimize.
425 */
426 code = 0;
Christoph Hellwigd6d59ba2009-12-23 16:09:13 +0000427 if (mp->m_flags & XFS_MOUNT_WSYNC)
428 xfs_trans_set_sync(tp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429
Christoph Hellwigd6d59ba2009-12-23 16:09:13 +0000430 code = xfs_trans_commit(tp, commit_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 xfs_iunlock(ip, lock_flags);
433
434 /*
435 * Release any dquot(s) the inode had kept before chown.
436 */
Christoph Hellwig7d095252009-06-08 15:33:32 +0200437 xfs_qm_dqrele(olddquot1);
438 xfs_qm_dqrele(olddquot2);
439 xfs_qm_dqrele(udqp);
440 xfs_qm_dqrele(gdqp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441
Christoph Hellwigef14f0c2009-06-10 17:07:47 +0200442 if (code)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 return code;
Christoph Hellwigef14f0c2009-06-10 17:07:47 +0200444
445 /*
446 * XXX(hch): Updating the ACL entries is not atomic vs the i_mode
447 * update. We could avoid this with linked transactions
448 * and passing down the transaction pointer all the way
449 * to attr_set. No previous user of the generic
450 * Posix ACL code seems to care about this issue either.
451 */
452 if ((mask & ATTR_MODE) && !(flags & XFS_ATTR_NOACL)) {
453 code = -xfs_acl_chmod(inode);
454 if (code)
455 return XFS_ERROR(code);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 }
457
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 return 0;
459
460 abort_return:
461 commit_flags |= XFS_TRANS_ABORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 error_return:
Christoph Hellwig7d095252009-06-08 15:33:32 +0200463 xfs_qm_dqrele(udqp);
464 xfs_qm_dqrele(gdqp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 if (tp) {
466 xfs_trans_cancel(tp, commit_flags);
467 }
468 if (lock_flags != 0) {
469 xfs_iunlock(ip, lock_flags);
470 }
471 return code;
472}
473
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474/*
Nathan Scott7d4fb402006-06-09 15:27:16 +1000475 * The maximum pathlen is 1024 bytes. Since the minimum file system
476 * blocksize is 512 bytes, we can get a max of 2 extents back from
477 * bmapi.
478 */
479#define SYMLINK_MAPS 2
480
Christoph Hellwig804c83c2007-08-28 13:59:03 +1000481STATIC int
482xfs_readlink_bmap(
483 xfs_inode_t *ip,
484 char *link)
485{
486 xfs_mount_t *mp = ip->i_mount;
487 int pathlen = ip->i_d.di_size;
488 int nmaps = SYMLINK_MAPS;
489 xfs_bmbt_irec_t mval[SYMLINK_MAPS];
490 xfs_daddr_t d;
491 int byte_cnt;
492 int n;
493 xfs_buf_t *bp;
494 int error = 0;
495
496 error = xfs_bmapi(NULL, ip, 0, XFS_B_TO_FSB(mp, pathlen), 0, NULL, 0,
Christoph Hellwigb4e91812010-06-23 18:11:15 +1000497 mval, &nmaps, NULL);
Christoph Hellwig804c83c2007-08-28 13:59:03 +1000498 if (error)
499 goto out;
500
501 for (n = 0; n < nmaps; n++) {
502 d = XFS_FSB_TO_DADDR(mp, mval[n].br_startblock);
503 byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount);
504
Christoph Hellwig6ad112b2009-11-24 18:02:23 +0000505 bp = xfs_buf_read(mp->m_ddev_targp, d, BTOBB(byte_cnt),
506 XBF_LOCK | XBF_MAPPED | XBF_DONT_BLOCK);
Christoph Hellwig804c83c2007-08-28 13:59:03 +1000507 error = XFS_BUF_GETERROR(bp);
508 if (error) {
509 xfs_ioerror_alert("xfs_readlink",
510 ip->i_mount, bp, XFS_BUF_ADDR(bp));
511 xfs_buf_relse(bp);
512 goto out;
513 }
514 if (pathlen < byte_cnt)
515 byte_cnt = pathlen;
516 pathlen -= byte_cnt;
517
518 memcpy(link, XFS_BUF_PTR(bp), byte_cnt);
519 xfs_buf_relse(bp);
520 }
521
522 link[ip->i_d.di_size] = '\0';
523 error = 0;
524
525 out:
526 return error;
527}
528
Christoph Hellwig993386c2007-08-28 16:12:30 +1000529int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530xfs_readlink(
Christoph Hellwig993386c2007-08-28 16:12:30 +1000531 xfs_inode_t *ip,
Christoph Hellwig804c83c2007-08-28 13:59:03 +1000532 char *link)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533{
Christoph Hellwig804c83c2007-08-28 13:59:03 +1000534 xfs_mount_t *mp = ip->i_mount;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 int pathlen;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537
Christoph Hellwigcca28fb2010-06-24 11:57:09 +1000538 trace_xfs_readlink(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539
540 if (XFS_FORCED_SHUTDOWN(mp))
541 return XFS_ERROR(EIO);
542
543 xfs_ilock(ip, XFS_ILOCK_SHARED);
544
545 ASSERT((ip->i_d.di_mode & S_IFMT) == S_IFLNK);
Christoph Hellwig804c83c2007-08-28 13:59:03 +1000546 ASSERT(ip->i_d.di_size <= MAXPATHLEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547
Christoph Hellwig804c83c2007-08-28 13:59:03 +1000548 pathlen = ip->i_d.di_size;
549 if (!pathlen)
550 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551
552 if (ip->i_df.if_flags & XFS_IFINLINE) {
Christoph Hellwig804c83c2007-08-28 13:59:03 +1000553 memcpy(link, ip->i_df.if_u1.if_data, pathlen);
554 link[pathlen] = '\0';
555 } else {
556 error = xfs_readlink_bmap(ip, link);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 }
558
Christoph Hellwig804c83c2007-08-28 13:59:03 +1000559 out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 xfs_iunlock(ip, XFS_ILOCK_SHARED);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 return error;
562}
563
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564/*
Christoph Hellwigc56c9632009-10-19 04:03:46 +0000565 * Flags for xfs_free_eofblocks
566 */
567#define XFS_FREE_EOF_TRYLOCK (1<<0)
568
569/*
David Chinner92dfe8d2007-05-24 15:22:19 +1000570 * This is called by xfs_inactive to free any blocks beyond eof
571 * when the link count isn't zero and by xfs_dm_punch_hole() when
572 * punching a hole to EOF.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 */
Eric Sandeend96f8f82009-07-02 00:09:33 -0500574STATIC int
David Chinner92dfe8d2007-05-24 15:22:19 +1000575xfs_free_eofblocks(
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 xfs_mount_t *mp,
David Chinner92dfe8d2007-05-24 15:22:19 +1000577 xfs_inode_t *ip,
578 int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700579{
580 xfs_trans_t *tp;
581 int error;
582 xfs_fileoff_t end_fsb;
583 xfs_fileoff_t last_fsb;
584 xfs_filblks_t map_len;
585 int nimaps;
586 xfs_bmbt_irec_t imap;
587
588 /*
589 * Figure out if there are any blocks beyond the end
590 * of the file. If not, then there is nothing to do.
591 */
Lachlan McIlroyba87ea62007-05-08 13:49:46 +1000592 end_fsb = XFS_B_TO_FSB(mp, ((xfs_ufsize_t)ip->i_size));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 last_fsb = XFS_B_TO_FSB(mp, (xfs_ufsize_t)XFS_MAXIOFFSET(mp));
Kulikov Vasiliy3f348852010-07-20 17:54:28 +1000594 if (last_fsb <= end_fsb)
Jesper Juhl014c2542006-01-15 02:37:08 +0100595 return 0;
Kulikov Vasiliy3f348852010-07-20 17:54:28 +1000596 map_len = last_fsb - end_fsb;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597
598 nimaps = 1;
599 xfs_ilock(ip, XFS_ILOCK_SHARED);
Lachlan McIlroy541d7d32007-10-11 17:34:33 +1000600 error = xfs_bmapi(NULL, ip, end_fsb, map_len, 0,
Christoph Hellwigb4e91812010-06-23 18:11:15 +1000601 NULL, 0, &imap, &nimaps, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 xfs_iunlock(ip, XFS_ILOCK_SHARED);
603
604 if (!error && (nimaps != 0) &&
Yingping Lu68bdb6e2006-01-11 15:38:31 +1100605 (imap.br_startblock != HOLESTARTBLOCK ||
606 ip->i_delayed_blks)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 /*
608 * Attach the dquots to the inode up front.
609 */
Christoph Hellwig7d095252009-06-08 15:33:32 +0200610 error = xfs_qm_dqattach(ip, 0);
611 if (error)
Jesper Juhl014c2542006-01-15 02:37:08 +0100612 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613
614 /*
615 * There are blocks after the end of file.
616 * Free them up now by truncating the file to
617 * its current size.
618 */
619 tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
620
621 /*
622 * Do the xfs_itruncate_start() call before
623 * reserving any log space because
624 * itruncate_start will call into the buffer
625 * cache and we can't
626 * do that within a transaction.
627 */
Christoph Hellwigc56c9632009-10-19 04:03:46 +0000628 if (flags & XFS_FREE_EOF_TRYLOCK) {
629 if (!xfs_ilock_nowait(ip, XFS_IOLOCK_EXCL)) {
630 xfs_trans_cancel(tp, 0);
631 return 0;
632 }
633 } else {
David Chinner92dfe8d2007-05-24 15:22:19 +1000634 xfs_ilock(ip, XFS_IOLOCK_EXCL);
Christoph Hellwigc56c9632009-10-19 04:03:46 +0000635 }
Lachlan McIlroyd3cf2092007-05-08 13:49:27 +1000636 error = xfs_itruncate_start(ip, XFS_ITRUNC_DEFINITE,
Lachlan McIlroyba87ea62007-05-08 13:49:46 +1000637 ip->i_size);
Lachlan McIlroyd3cf2092007-05-08 13:49:27 +1000638 if (error) {
Jesper Juhl87ae3c22007-06-28 16:43:14 +1000639 xfs_trans_cancel(tp, 0);
Christoph Hellwigc56c9632009-10-19 04:03:46 +0000640 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
Lachlan McIlroyd3cf2092007-05-08 13:49:27 +1000641 return error;
642 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643
644 error = xfs_trans_reserve(tp, 0,
645 XFS_ITRUNCATE_LOG_RES(mp),
646 0, XFS_TRANS_PERM_LOG_RES,
647 XFS_ITRUNCATE_LOG_COUNT);
648 if (error) {
649 ASSERT(XFS_FORCED_SHUTDOWN(mp));
650 xfs_trans_cancel(tp, 0);
651 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
Jesper Juhl014c2542006-01-15 02:37:08 +0100652 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 }
654
655 xfs_ilock(ip, XFS_ILOCK_EXCL);
Christoph Hellwig898621d2010-06-24 11:36:58 +1000656 xfs_trans_ijoin(tp, ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700657
658 error = xfs_itruncate_finish(&tp, ip,
Lachlan McIlroyba87ea62007-05-08 13:49:46 +1000659 ip->i_size,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 XFS_DATA_FORK,
661 0);
662 /*
663 * If we get an error at this point we
664 * simply don't bother truncating the file.
665 */
666 if (error) {
667 xfs_trans_cancel(tp,
668 (XFS_TRANS_RELEASE_LOG_RES |
669 XFS_TRANS_ABORT));
670 } else {
671 error = xfs_trans_commit(tp,
Eric Sandeen1c72bf92007-05-08 13:48:42 +1000672 XFS_TRANS_RELEASE_LOG_RES);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 }
Christoph Hellwigc56c9632009-10-19 04:03:46 +0000674 xfs_iunlock(ip, XFS_IOLOCK_EXCL|XFS_ILOCK_EXCL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 }
Jesper Juhl014c2542006-01-15 02:37:08 +0100676 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677}
678
679/*
680 * Free a symlink that has blocks associated with it.
681 */
682STATIC int
683xfs_inactive_symlink_rmt(
684 xfs_inode_t *ip,
685 xfs_trans_t **tpp)
686{
687 xfs_buf_t *bp;
688 int committed;
689 int done;
690 int error;
691 xfs_fsblock_t first_block;
692 xfs_bmap_free_t free_list;
693 int i;
694 xfs_mount_t *mp;
695 xfs_bmbt_irec_t mval[SYMLINK_MAPS];
696 int nmaps;
697 xfs_trans_t *ntp;
698 int size;
699 xfs_trans_t *tp;
700
701 tp = *tpp;
702 mp = ip->i_mount;
703 ASSERT(ip->i_d.di_size > XFS_IFORK_DSIZE(ip));
704 /*
705 * We're freeing a symlink that has some
706 * blocks allocated to it. Free the
707 * blocks here. We know that we've got
708 * either 1 or 2 extents and that we can
709 * free them all in one bunmapi call.
710 */
711 ASSERT(ip->i_d.di_nextents > 0 && ip->i_d.di_nextents <= 2);
712 if ((error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0,
713 XFS_TRANS_PERM_LOG_RES, XFS_ITRUNCATE_LOG_COUNT))) {
714 ASSERT(XFS_FORCED_SHUTDOWN(mp));
715 xfs_trans_cancel(tp, 0);
716 *tpp = NULL;
717 return error;
718 }
719 /*
720 * Lock the inode, fix the size, and join it to the transaction.
721 * Hold it so in the normal path, we still have it locked for
722 * the second transaction. In the error paths we need it
723 * held so the cancel won't rele it, see below.
724 */
725 xfs_ilock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
726 size = (int)ip->i_d.di_size;
727 ip->i_d.di_size = 0;
Christoph Hellwig898621d2010-06-24 11:36:58 +1000728 xfs_trans_ijoin(tp, ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
730 /*
731 * Find the block(s) so we can inval and unmap them.
732 */
733 done = 0;
Eric Sandeen9d87c312009-01-14 23:22:07 -0600734 xfs_bmap_init(&free_list, &first_block);
Tobias Klausere8c96f82006-03-24 03:15:34 -0800735 nmaps = ARRAY_SIZE(mval);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 if ((error = xfs_bmapi(tp, ip, 0, XFS_B_TO_FSB(mp, size),
737 XFS_BMAPI_METADATA, &first_block, 0, mval, &nmaps,
Christoph Hellwigb4e91812010-06-23 18:11:15 +1000738 &free_list)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 goto error0;
740 /*
741 * Invalidate the block(s).
742 */
743 for (i = 0; i < nmaps; i++) {
744 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp,
745 XFS_FSB_TO_DADDR(mp, mval[i].br_startblock),
746 XFS_FSB_TO_BB(mp, mval[i].br_blockcount), 0);
747 xfs_trans_binval(tp, bp);
748 }
749 /*
750 * Unmap the dead block(s) to the free_list.
751 */
752 if ((error = xfs_bunmapi(tp, ip, 0, size, XFS_BMAPI_METADATA, nmaps,
Christoph Hellwigb4e91812010-06-23 18:11:15 +1000753 &first_block, &free_list, &done)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754 goto error1;
755 ASSERT(done);
756 /*
757 * Commit the first transaction. This logs the EFI and the inode.
758 */
Eric Sandeenf7c99b62007-02-10 18:37:16 +1100759 if ((error = xfs_bmap_finish(&tp, &free_list, &committed)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 goto error1;
761 /*
762 * The transaction must have been committed, since there were
763 * actually extents freed by xfs_bunmapi. See xfs_bmap_finish.
764 * The new tp has the extent freeing and EFDs.
765 */
766 ASSERT(committed);
767 /*
768 * The first xact was committed, so add the inode to the new one.
769 * Mark it dirty so it will be logged and moved forward in the log as
770 * part of every commit.
771 */
Christoph Hellwig898621d2010-06-24 11:36:58 +1000772 xfs_trans_ijoin(tp, ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
774 /*
775 * Get a new, empty transaction to return to our caller.
776 */
777 ntp = xfs_trans_dup(tp);
778 /*
Nathan Scottc41564b2006-03-29 08:55:14 +1000779 * Commit the transaction containing extent freeing and EFDs.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780 * If we get an error on the commit here or on the reserve below,
781 * we need to unlock the inode since the new transaction doesn't
782 * have the inode attached.
783 */
Eric Sandeen1c72bf92007-05-08 13:48:42 +1000784 error = xfs_trans_commit(tp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785 tp = ntp;
786 if (error) {
787 ASSERT(XFS_FORCED_SHUTDOWN(mp));
788 goto error0;
789 }
790 /*
Dave Chinnercc09c0d2008-11-17 17:37:10 +1100791 * transaction commit worked ok so we can drop the extra ticket
792 * reference that we gained in xfs_trans_dup()
793 */
794 xfs_log_ticket_put(tp->t_ticket);
795
796 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 * Remove the memory for extent descriptions (just bookkeeping).
798 */
799 if (ip->i_df.if_bytes)
800 xfs_idata_realloc(ip, -ip->i_df.if_bytes, XFS_DATA_FORK);
801 ASSERT(ip->i_df.if_bytes == 0);
802 /*
803 * Put an itruncate log reservation in the new transaction
804 * for our caller.
805 */
806 if ((error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0,
807 XFS_TRANS_PERM_LOG_RES, XFS_ITRUNCATE_LOG_COUNT))) {
808 ASSERT(XFS_FORCED_SHUTDOWN(mp));
809 goto error0;
810 }
811 /*
812 * Return with the inode locked but not joined to the transaction.
813 */
814 *tpp = tp;
815 return 0;
816
817 error1:
818 xfs_bmap_cancel(&free_list);
819 error0:
820 /*
821 * Have to come here with the inode locked and either
822 * (held and in the transaction) or (not in the transaction).
823 * If the inode isn't held then cancel would iput it, but
824 * that's wrong since this is inactive and the vnode ref
825 * count is 0 already.
826 * Cancel won't do anything to the inode if held, but it still
827 * needs to be locked until the cancel is done, if it was
828 * joined to the transaction.
829 */
830 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
831 xfs_iunlock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
832 *tpp = NULL;
833 return error;
834
835}
836
837STATIC int
838xfs_inactive_symlink_local(
839 xfs_inode_t *ip,
840 xfs_trans_t **tpp)
841{
842 int error;
843
844 ASSERT(ip->i_d.di_size <= XFS_IFORK_DSIZE(ip));
845 /*
846 * We're freeing a symlink which fit into
847 * the inode. Just free the memory used
848 * to hold the old symlink.
849 */
850 error = xfs_trans_reserve(*tpp, 0,
851 XFS_ITRUNCATE_LOG_RES(ip->i_mount),
852 0, XFS_TRANS_PERM_LOG_RES,
853 XFS_ITRUNCATE_LOG_COUNT);
854
855 if (error) {
856 xfs_trans_cancel(*tpp, 0);
857 *tpp = NULL;
Jesper Juhl014c2542006-01-15 02:37:08 +0100858 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 }
860 xfs_ilock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
861
862 /*
863 * Zero length symlinks _can_ exist.
864 */
865 if (ip->i_df.if_bytes > 0) {
866 xfs_idata_realloc(ip,
867 -(ip->i_df.if_bytes),
868 XFS_DATA_FORK);
869 ASSERT(ip->i_df.if_bytes == 0);
870 }
Jesper Juhl014c2542006-01-15 02:37:08 +0100871 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872}
873
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874STATIC int
875xfs_inactive_attrs(
876 xfs_inode_t *ip,
877 xfs_trans_t **tpp)
878{
879 xfs_trans_t *tp;
880 int error;
881 xfs_mount_t *mp;
882
Christoph Hellwig579aa9c2008-04-22 17:34:00 +1000883 ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 tp = *tpp;
885 mp = ip->i_mount;
886 ASSERT(ip->i_d.di_forkoff != 0);
David Chinnere5720ee2008-04-10 12:21:18 +1000887 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 xfs_iunlock(ip, XFS_ILOCK_EXCL);
David Chinnere5720ee2008-04-10 12:21:18 +1000889 if (error)
890 goto error_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891
892 error = xfs_attr_inactive(ip);
David Chinnere5720ee2008-04-10 12:21:18 +1000893 if (error)
894 goto error_unlock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895
896 tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
897 error = xfs_trans_reserve(tp, 0,
898 XFS_IFREE_LOG_RES(mp),
899 0, XFS_TRANS_PERM_LOG_RES,
900 XFS_INACTIVE_LOG_COUNT);
David Chinnere5720ee2008-04-10 12:21:18 +1000901 if (error)
902 goto error_cancel;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700903
904 xfs_ilock(ip, XFS_ILOCK_EXCL);
Christoph Hellwig898621d2010-06-24 11:36:58 +1000905 xfs_trans_ijoin(tp, ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 xfs_idestroy_fork(ip, XFS_ATTR_FORK);
907
908 ASSERT(ip->i_d.di_anextents == 0);
909
910 *tpp = tp;
Jesper Juhl014c2542006-01-15 02:37:08 +0100911 return 0;
David Chinnere5720ee2008-04-10 12:21:18 +1000912
913error_cancel:
914 ASSERT(XFS_FORCED_SHUTDOWN(mp));
915 xfs_trans_cancel(tp, 0);
916error_unlock:
917 *tpp = NULL;
918 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
919 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920}
921
Christoph Hellwig993386c2007-08-28 16:12:30 +1000922int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923xfs_release(
Christoph Hellwig993386c2007-08-28 16:12:30 +1000924 xfs_inode_t *ip)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700925{
Christoph Hellwig993386c2007-08-28 16:12:30 +1000926 xfs_mount_t *mp = ip->i_mount;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700927 int error;
928
Christoph Hellwig42173f62008-04-22 17:33:25 +1000929 if (!S_ISREG(ip->i_d.di_mode) || (ip->i_d.di_mode == 0))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931
932 /* If this is a read-only mount, don't do this (would generate I/O) */
Christoph Hellwigbd186aa2007-08-30 17:21:12 +1000933 if (mp->m_flags & XFS_MOUNT_RDONLY)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700934 return 0;
935
David Chinner2a82b8b2007-07-11 11:09:12 +1000936 if (!XFS_FORCED_SHUTDOWN(mp)) {
Christoph Hellwigb3aea4e2007-08-29 11:44:37 +1000937 int truncated;
938
David Chinner2a82b8b2007-07-11 11:09:12 +1000939 /*
940 * If we are using filestreams, and we have an unlinked
941 * file that we are processing the last close on, then nothing
942 * will be able to reopen and write to this file. Purge this
943 * inode from the filestreams cache so that it doesn't delay
944 * teardown of the inode.
945 */
946 if ((ip->i_d.di_nlink == 0) && xfs_inode_is_filestream(ip))
947 xfs_filestream_deassociate(ip);
948
Christoph Hellwigfbf3ce82007-06-28 16:46:47 +1000949 /*
950 * If we previously truncated this file and removed old data
951 * in the process, we want to initiate "early" writeout on
952 * the last close. This is an attempt to combat the notorious
953 * NULL files problem which is particularly noticable from a
954 * truncate down, buffered (re-)write (delalloc), followed by
955 * a crash. What we are effectively doing here is
956 * significantly reducing the time window where we'd otherwise
957 * be exposed to that problem.
958 */
Christoph Hellwig09262b42007-08-29 11:44:50 +1000959 truncated = xfs_iflags_test_and_clear(ip, XFS_ITRUNCATED);
Christoph Hellwigdf80c932008-08-13 16:22:09 +1000960 if (truncated && VN_DIRTY(VFS_I(ip)) && ip->i_delayed_blks > 0)
Christoph Hellwig0cadda12010-01-19 09:56:44 +0000961 xfs_flush_pages(ip, 0, -1, XBF_ASYNC, FI_NONE);
Christoph Hellwigfbf3ce82007-06-28 16:46:47 +1000962 }
963
Linus Torvalds1da177e2005-04-16 15:20:36 -0700964 if (ip->i_d.di_nlink != 0) {
965 if ((((ip->i_d.di_mode & S_IFMT) == S_IFREG) &&
Christoph Hellwigdf80c932008-08-13 16:22:09 +1000966 ((ip->i_size > 0) || (VN_CACHED(VFS_I(ip)) > 0 ||
Yingping Lu68bdb6e2006-01-11 15:38:31 +1100967 ip->i_delayed_blks > 0)) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -0700968 (ip->i_df.if_flags & XFS_IFEXTENTS)) &&
Nathan Scottdd9f4382006-01-11 15:28:28 +1100969 (!(ip->i_d.di_flags &
970 (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)))) {
Christoph Hellwigc56c9632009-10-19 04:03:46 +0000971
972 /*
973 * If we can't get the iolock just skip truncating
974 * the blocks past EOF because we could deadlock
975 * with the mmap_sem otherwise. We'll get another
976 * chance to drop them once the last reference to
977 * the inode is dropped, so we'll never leak blocks
978 * permanently.
979 */
980 error = xfs_free_eofblocks(mp, ip,
981 XFS_FREE_EOF_TRYLOCK);
David Chinner92dfe8d2007-05-24 15:22:19 +1000982 if (error)
Jesper Juhl014c2542006-01-15 02:37:08 +0100983 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 }
985 }
986
987 return 0;
988}
989
990/*
991 * xfs_inactive
992 *
993 * This is called when the vnode reference count for the vnode
994 * goes to zero. If the file has been unlinked, then it must
995 * now be truncated. Also, we clear all of the read-ahead state
996 * kept for the inode here since the file is now closed.
997 */
Christoph Hellwig993386c2007-08-28 16:12:30 +1000998int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999xfs_inactive(
Christoph Hellwig993386c2007-08-28 16:12:30 +10001000 xfs_inode_t *ip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001{
Nathan Scott67fcaa72006-06-09 17:00:52 +10001002 xfs_bmap_free_t free_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 xfs_fsblock_t first_block;
1004 int committed;
1005 xfs_trans_t *tp;
1006 xfs_mount_t *mp;
1007 int error;
1008 int truncate;
1009
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010 /*
1011 * If the inode is already free, then there can be nothing
1012 * to clean up here.
1013 */
Christoph Hellwigcb4c8cc2009-03-16 08:25:25 +01001014 if (ip->i_d.di_mode == 0 || is_bad_inode(VFS_I(ip))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 ASSERT(ip->i_df.if_real_bytes == 0);
1016 ASSERT(ip->i_df.if_broot_bytes == 0);
1017 return VN_INACTIVE_CACHE;
1018 }
1019
1020 /*
1021 * Only do a truncate if it's a regular file with
1022 * some actual space in it. It's OK to look at the
1023 * inode's fields without the lock because we're the
1024 * only one with a reference to the inode.
1025 */
1026 truncate = ((ip->i_d.di_nlink == 0) &&
Lachlan McIlroyba87ea62007-05-08 13:49:46 +10001027 ((ip->i_d.di_size != 0) || (ip->i_size != 0) ||
1028 (ip->i_d.di_nextents > 0) || (ip->i_delayed_blks > 0)) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 ((ip->i_d.di_mode & S_IFMT) == S_IFREG));
1030
1031 mp = ip->i_mount;
1032
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 error = 0;
1034
1035 /* If this is a read-only mount, don't do this (would generate I/O) */
Christoph Hellwigbd186aa2007-08-30 17:21:12 +10001036 if (mp->m_flags & XFS_MOUNT_RDONLY)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001037 goto out;
1038
1039 if (ip->i_d.di_nlink != 0) {
1040 if ((((ip->i_d.di_mode & S_IFMT) == S_IFREG) &&
Christoph Hellwigdf80c932008-08-13 16:22:09 +10001041 ((ip->i_size > 0) || (VN_CACHED(VFS_I(ip)) > 0 ||
Yingping Lu68bdb6e2006-01-11 15:38:31 +11001042 ip->i_delayed_blks > 0)) &&
Nathan Scottdd9f4382006-01-11 15:28:28 +11001043 (ip->i_df.if_flags & XFS_IFEXTENTS) &&
1044 (!(ip->i_d.di_flags &
1045 (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)) ||
1046 (ip->i_delayed_blks != 0)))) {
Christoph Hellwigc56c9632009-10-19 04:03:46 +00001047 error = xfs_free_eofblocks(mp, ip, 0);
David Chinner92dfe8d2007-05-24 15:22:19 +10001048 if (error)
Jesper Juhl014c2542006-01-15 02:37:08 +01001049 return VN_INACTIVE_CACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 }
1051 goto out;
1052 }
1053
1054 ASSERT(ip->i_d.di_nlink == 0);
1055
Christoph Hellwig7d095252009-06-08 15:33:32 +02001056 error = xfs_qm_dqattach(ip, 0);
1057 if (error)
Jesper Juhl014c2542006-01-15 02:37:08 +01001058 return VN_INACTIVE_CACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059
1060 tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
1061 if (truncate) {
1062 /*
1063 * Do the xfs_itruncate_start() call before
1064 * reserving any log space because itruncate_start
1065 * will call into the buffer cache and we can't
1066 * do that within a transaction.
1067 */
1068 xfs_ilock(ip, XFS_IOLOCK_EXCL);
1069
Lachlan McIlroyd3cf2092007-05-08 13:49:27 +10001070 error = xfs_itruncate_start(ip, XFS_ITRUNC_DEFINITE, 0);
1071 if (error) {
Jesper Juhl87ae3c22007-06-28 16:43:14 +10001072 xfs_trans_cancel(tp, 0);
Lachlan McIlroyd3cf2092007-05-08 13:49:27 +10001073 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
1074 return VN_INACTIVE_CACHE;
1075 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001076
1077 error = xfs_trans_reserve(tp, 0,
1078 XFS_ITRUNCATE_LOG_RES(mp),
1079 0, XFS_TRANS_PERM_LOG_RES,
1080 XFS_ITRUNCATE_LOG_COUNT);
1081 if (error) {
1082 /* Don't call itruncate_cleanup */
1083 ASSERT(XFS_FORCED_SHUTDOWN(mp));
1084 xfs_trans_cancel(tp, 0);
1085 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
Jesper Juhl014c2542006-01-15 02:37:08 +01001086 return VN_INACTIVE_CACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001087 }
1088
1089 xfs_ilock(ip, XFS_ILOCK_EXCL);
Christoph Hellwig898621d2010-06-24 11:36:58 +10001090 xfs_trans_ijoin(tp, ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091
1092 /*
1093 * normally, we have to run xfs_itruncate_finish sync.
1094 * But if filesystem is wsync and we're in the inactive
1095 * path, then we know that nlink == 0, and that the
1096 * xaction that made nlink == 0 is permanently committed
1097 * since xfs_remove runs as a synchronous transaction.
1098 */
1099 error = xfs_itruncate_finish(&tp, ip, 0, XFS_DATA_FORK,
1100 (!(mp->m_flags & XFS_MOUNT_WSYNC) ? 1 : 0));
1101
1102 if (error) {
1103 xfs_trans_cancel(tp,
1104 XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
1105 xfs_iunlock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
Jesper Juhl014c2542006-01-15 02:37:08 +01001106 return VN_INACTIVE_CACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107 }
1108 } else if ((ip->i_d.di_mode & S_IFMT) == S_IFLNK) {
1109
1110 /*
1111 * If we get an error while cleaning up a
1112 * symlink we bail out.
1113 */
1114 error = (ip->i_d.di_size > XFS_IFORK_DSIZE(ip)) ?
1115 xfs_inactive_symlink_rmt(ip, &tp) :
1116 xfs_inactive_symlink_local(ip, &tp);
1117
1118 if (error) {
1119 ASSERT(tp == NULL);
Jesper Juhl014c2542006-01-15 02:37:08 +01001120 return VN_INACTIVE_CACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121 }
1122
Christoph Hellwig898621d2010-06-24 11:36:58 +10001123 xfs_trans_ijoin(tp, ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124 } else {
1125 error = xfs_trans_reserve(tp, 0,
1126 XFS_IFREE_LOG_RES(mp),
1127 0, XFS_TRANS_PERM_LOG_RES,
1128 XFS_INACTIVE_LOG_COUNT);
1129 if (error) {
1130 ASSERT(XFS_FORCED_SHUTDOWN(mp));
1131 xfs_trans_cancel(tp, 0);
Jesper Juhl014c2542006-01-15 02:37:08 +01001132 return VN_INACTIVE_CACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 }
1134
1135 xfs_ilock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
Christoph Hellwig898621d2010-06-24 11:36:58 +10001136 xfs_trans_ijoin(tp, ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 }
1138
1139 /*
1140 * If there are attributes associated with the file
1141 * then blow them away now. The code calls a routine
1142 * that recursively deconstructs the attribute fork.
1143 * We need to just commit the current transaction
1144 * because we can't use it for xfs_attr_inactive().
1145 */
1146 if (ip->i_d.di_anextents > 0) {
1147 error = xfs_inactive_attrs(ip, &tp);
1148 /*
1149 * If we got an error, the transaction is already
1150 * cancelled, and the inode is unlocked. Just get out.
1151 */
1152 if (error)
Jesper Juhl014c2542006-01-15 02:37:08 +01001153 return VN_INACTIVE_CACHE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154 } else if (ip->i_afp) {
1155 xfs_idestroy_fork(ip, XFS_ATTR_FORK);
1156 }
1157
1158 /*
1159 * Free the inode.
1160 */
Eric Sandeen9d87c312009-01-14 23:22:07 -06001161 xfs_bmap_init(&free_list, &first_block);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 error = xfs_ifree(tp, ip, &free_list);
1163 if (error) {
1164 /*
1165 * If we fail to free the inode, shut down. The cancel
1166 * might do that, we need to make sure. Otherwise the
1167 * inode might be lost for a long time or forever.
1168 */
1169 if (!XFS_FORCED_SHUTDOWN(mp)) {
1170 cmn_err(CE_NOTE,
1171 "xfs_inactive: xfs_ifree() returned an error = %d on %s",
1172 error, mp->m_fsname);
Nathan Scott7d04a332006-06-09 14:58:38 +10001173 xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174 }
1175 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES|XFS_TRANS_ABORT);
1176 } else {
1177 /*
1178 * Credit the quota account(s). The inode is gone.
1179 */
Christoph Hellwig7d095252009-06-08 15:33:32 +02001180 xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_ICOUNT, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181
1182 /*
David Chinner78e9da72008-04-10 12:24:17 +10001183 * Just ignore errors at this point. There is nothing we can
1184 * do except to try to keep going. Make sure it's not a silent
1185 * error.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 */
David Chinner78e9da72008-04-10 12:24:17 +10001187 error = xfs_bmap_finish(&tp, &free_list, &committed);
1188 if (error)
1189 xfs_fs_cmn_err(CE_NOTE, mp, "xfs_inactive: "
1190 "xfs_bmap_finish() returned error %d", error);
1191 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
1192 if (error)
1193 xfs_fs_cmn_err(CE_NOTE, mp, "xfs_inactive: "
1194 "xfs_trans_commit() returned error %d", error);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001195 }
Christoph Hellwig7d095252009-06-08 15:33:32 +02001196
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197 /*
1198 * Release the dquots held by inode, if any.
1199 */
Christoph Hellwig7d095252009-06-08 15:33:32 +02001200 xfs_qm_dqdetach(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201 xfs_iunlock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
1202
1203 out:
1204 return VN_INACTIVE_CACHE;
1205}
1206
Barry Naujok384f3ce2008-05-21 16:58:22 +10001207/*
1208 * Lookups up an inode from "name". If ci_name is not NULL, then a CI match
1209 * is allowed, otherwise it has to be an exact match. If a CI match is found,
1210 * ci_name->name will point to a the actual name (caller must free) or
1211 * will be set to NULL if an exact match is found.
1212 */
Christoph Hellwig993386c2007-08-28 16:12:30 +10001213int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001214xfs_lookup(
Christoph Hellwig993386c2007-08-28 16:12:30 +10001215 xfs_inode_t *dp,
Barry Naujok556b8b12008-04-10 12:22:07 +10001216 struct xfs_name *name,
Barry Naujok384f3ce2008-05-21 16:58:22 +10001217 xfs_inode_t **ipp,
1218 struct xfs_name *ci_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001219{
Christoph Hellwigeca450b2008-04-22 17:33:52 +10001220 xfs_ino_t inum;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221 int error;
1222 uint lock_mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223
Christoph Hellwigcca28fb2010-06-24 11:57:09 +10001224 trace_xfs_lookup(dp, name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225
1226 if (XFS_FORCED_SHUTDOWN(dp->i_mount))
1227 return XFS_ERROR(EIO);
1228
1229 lock_mode = xfs_ilock_map_shared(dp);
Barry Naujok384f3ce2008-05-21 16:58:22 +10001230 error = xfs_dir_lookup(NULL, dp, name, &inum, ci_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231 xfs_iunlock_map_shared(dp, lock_mode);
Christoph Hellwigeca450b2008-04-22 17:33:52 +10001232
1233 if (error)
1234 goto out;
1235
Dave Chinner7b6259e2010-06-24 11:35:17 +10001236 error = xfs_iget(dp->i_mount, NULL, inum, 0, 0, ipp);
Christoph Hellwigeca450b2008-04-22 17:33:52 +10001237 if (error)
Barry Naujok384f3ce2008-05-21 16:58:22 +10001238 goto out_free_name;
Christoph Hellwigeca450b2008-04-22 17:33:52 +10001239
Christoph Hellwigeca450b2008-04-22 17:33:52 +10001240 return 0;
1241
Barry Naujok384f3ce2008-05-21 16:58:22 +10001242out_free_name:
1243 if (ci_name)
1244 kmem_free(ci_name->name);
1245out:
Christoph Hellwigeca450b2008-04-22 17:33:52 +10001246 *ipp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 return error;
1248}
1249
Christoph Hellwig993386c2007-08-28 16:12:30 +10001250int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251xfs_create(
Christoph Hellwig993386c2007-08-28 16:12:30 +10001252 xfs_inode_t *dp,
Barry Naujok556b8b12008-04-10 12:22:07 +10001253 struct xfs_name *name,
Christoph Hellwig3e5daf02007-10-11 18:09:12 +10001254 mode_t mode,
1255 xfs_dev_t rdev,
Christoph Hellwig979ebab2008-03-06 13:46:05 +11001256 xfs_inode_t **ipp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257 cred_t *credp)
1258{
Christoph Hellwig517b5e82009-02-09 08:38:02 +01001259 int is_dir = S_ISDIR(mode);
1260 struct xfs_mount *mp = dp->i_mount;
1261 struct xfs_inode *ip = NULL;
1262 struct xfs_trans *tp = NULL;
Barry Naujok556b8b12008-04-10 12:22:07 +10001263 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264 xfs_bmap_free_t free_list;
1265 xfs_fsblock_t first_block;
Christoph Hellwig993386c2007-08-28 16:12:30 +10001266 boolean_t unlock_dp_on_error = B_FALSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 uint cancel_flags;
1268 int committed;
1269 xfs_prid_t prid;
Christoph Hellwig517b5e82009-02-09 08:38:02 +01001270 struct xfs_dquot *udqp = NULL;
1271 struct xfs_dquot *gdqp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001272 uint resblks;
Christoph Hellwig517b5e82009-02-09 08:38:02 +01001273 uint log_res;
1274 uint log_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275
Christoph Hellwigcca28fb2010-06-24 11:57:09 +10001276 trace_xfs_create(dp, name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277
Christoph Hellwig517b5e82009-02-09 08:38:02 +01001278 if (XFS_FORCED_SHUTDOWN(mp))
1279 return XFS_ERROR(EIO);
1280
Nathan Scott365ca832005-06-21 15:39:12 +10001281 if (dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
1282 prid = dp->i_d.di_projid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283 else
Christoph Hellwig517b5e82009-02-09 08:38:02 +01001284 prid = dfltprid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285
1286 /*
1287 * Make sure that we have allocated dquot(s) on disk.
1288 */
Christoph Hellwig7d095252009-06-08 15:33:32 +02001289 error = xfs_qm_vop_dqalloc(dp, current_fsuid(), current_fsgid(), prid,
Christoph Hellwig517b5e82009-02-09 08:38:02 +01001290 XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT, &udqp, &gdqp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291 if (error)
1292 goto std_return;
1293
Christoph Hellwig517b5e82009-02-09 08:38:02 +01001294 if (is_dir) {
1295 rdev = 0;
1296 resblks = XFS_MKDIR_SPACE_RES(mp, name->len);
1297 log_res = XFS_MKDIR_LOG_RES(mp);
1298 log_count = XFS_MKDIR_LOG_COUNT;
1299 tp = xfs_trans_alloc(mp, XFS_TRANS_MKDIR);
1300 } else {
1301 resblks = XFS_CREATE_SPACE_RES(mp, name->len);
1302 log_res = XFS_CREATE_LOG_RES(mp);
1303 log_count = XFS_CREATE_LOG_COUNT;
1304 tp = xfs_trans_alloc(mp, XFS_TRANS_CREATE);
1305 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307 cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
Christoph Hellwig517b5e82009-02-09 08:38:02 +01001308
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309 /*
1310 * Initially assume that the file does not exist and
1311 * reserve the resources for that case. If that is not
1312 * the case we'll drop the one we have and get a more
1313 * appropriate transaction later.
1314 */
Christoph Hellwig517b5e82009-02-09 08:38:02 +01001315 error = xfs_trans_reserve(tp, resblks, log_res, 0,
1316 XFS_TRANS_PERM_LOG_RES, log_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 if (error == ENOSPC) {
Dave Chinner153fec42009-04-06 18:48:30 +02001318 /* flush outstanding delalloc blocks and retry */
1319 xfs_flush_inodes(dp);
Christoph Hellwig4734d402009-09-09 18:19:02 -05001320 error = xfs_trans_reserve(tp, resblks, log_res, 0,
1321 XFS_TRANS_PERM_LOG_RES, log_count);
Dave Chinner153fec42009-04-06 18:48:30 +02001322 }
1323 if (error == ENOSPC) {
1324 /* No space at all so try a "no-allocation" reservation */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001325 resblks = 0;
Christoph Hellwig517b5e82009-02-09 08:38:02 +01001326 error = xfs_trans_reserve(tp, 0, log_res, 0,
1327 XFS_TRANS_PERM_LOG_RES, log_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328 }
1329 if (error) {
1330 cancel_flags = 0;
Christoph Hellwig517b5e82009-02-09 08:38:02 +01001331 goto out_trans_cancel;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332 }
1333
Lachlan McIlroyf7c66ce2007-05-08 13:50:19 +10001334 xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
Christoph Hellwig993386c2007-08-28 16:12:30 +10001335 unlock_dp_on_error = B_TRUE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336
Christoph Hellwig517b5e82009-02-09 08:38:02 +01001337 /*
1338 * Check for directory link count overflow.
1339 */
1340 if (is_dir && dp->i_d.di_nlink >= XFS_MAXLINK) {
1341 error = XFS_ERROR(EMLINK);
1342 goto out_trans_cancel;
1343 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344
Christoph Hellwig517b5e82009-02-09 08:38:02 +01001345 xfs_bmap_init(&free_list, &first_block);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001346
1347 /*
1348 * Reserve disk quota and the inode.
1349 */
Christoph Hellwig7d095252009-06-08 15:33:32 +02001350 error = xfs_trans_reserve_quota(tp, mp, udqp, gdqp, resblks, 1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351 if (error)
Christoph Hellwig517b5e82009-02-09 08:38:02 +01001352 goto out_trans_cancel;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001353
Barry Naujok556b8b12008-04-10 12:22:07 +10001354 error = xfs_dir_canenter(tp, dp, name, resblks);
1355 if (error)
Christoph Hellwig517b5e82009-02-09 08:38:02 +01001356 goto out_trans_cancel;
1357
1358 /*
1359 * A newly created regular or special file just has one directory
1360 * entry pointing to them, but a directory also the "." entry
1361 * pointing to itself.
1362 */
1363 error = xfs_dir_ialloc(&tp, dp, mode, is_dir ? 2 : 1, rdev, credp,
1364 prid, resblks > 0, &ip, &committed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365 if (error) {
1366 if (error == ENOSPC)
Christoph Hellwig517b5e82009-02-09 08:38:02 +01001367 goto out_trans_cancel;
1368 goto out_trans_abort;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001369 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370
1371 /*
1372 * At this point, we've gotten a newly allocated inode.
1373 * It is locked (and joined to the transaction).
1374 */
Christoph Hellwig579aa9c2008-04-22 17:34:00 +10001375 ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376
1377 /*
Christoph Hellwig993386c2007-08-28 16:12:30 +10001378 * Now we join the directory inode to the transaction. We do not do it
1379 * earlier because xfs_dir_ialloc might commit the previous transaction
1380 * (and release all the locks). An error from here on will result in
1381 * the transaction cancel unlocking dp so don't do it explicitly in the
1382 * error path.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 */
Christoph Hellwig898621d2010-06-24 11:36:58 +10001384 xfs_trans_ijoin_ref(tp, dp, XFS_ILOCK_EXCL);
Christoph Hellwig993386c2007-08-28 16:12:30 +10001385 unlock_dp_on_error = B_FALSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001386
Barry Naujok556b8b12008-04-10 12:22:07 +10001387 error = xfs_dir_createname(tp, dp, name, ip->i_ino,
Nathan Scottf6c2d1f2006-06-20 13:04:51 +10001388 &first_block, &free_list, resblks ?
1389 resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 if (error) {
1391 ASSERT(error != ENOSPC);
Christoph Hellwig517b5e82009-02-09 08:38:02 +01001392 goto out_trans_abort;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393 }
1394 xfs_ichgtime(dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1395 xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
1396
Christoph Hellwig517b5e82009-02-09 08:38:02 +01001397 if (is_dir) {
1398 error = xfs_dir_init(tp, ip, dp);
1399 if (error)
1400 goto out_bmap_cancel;
1401
1402 error = xfs_bumplink(tp, dp);
1403 if (error)
1404 goto out_bmap_cancel;
1405 }
1406
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 /*
1408 * If this is a synchronous mount, make sure that the
1409 * create transaction goes to disk before returning to
1410 * the user.
1411 */
Christoph Hellwig517b5e82009-02-09 08:38:02 +01001412 if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001413 xfs_trans_set_sync(tp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415 /*
1416 * Attach the dquot(s) to the inodes and modify them incore.
1417 * These ids of the inode couldn't have changed since the new
1418 * inode has been locked ever since it was created.
1419 */
Christoph Hellwig7d095252009-06-08 15:33:32 +02001420 xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421
1422 /*
1423 * xfs_trans_commit normally decrements the vnode ref count
1424 * when it unlocks the inode. Since we want to return the
1425 * vnode to the caller, we bump the vnode ref count now.
1426 */
1427 IHOLD(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428
Eric Sandeenf7c99b62007-02-10 18:37:16 +11001429 error = xfs_bmap_finish(&tp, &free_list, &committed);
Christoph Hellwig517b5e82009-02-09 08:38:02 +01001430 if (error)
1431 goto out_abort_rele;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432
Eric Sandeen1c72bf92007-05-08 13:48:42 +10001433 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434 if (error) {
1435 IRELE(ip);
Christoph Hellwig517b5e82009-02-09 08:38:02 +01001436 goto out_dqrele;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001437 }
1438
Christoph Hellwig7d095252009-06-08 15:33:32 +02001439 xfs_qm_dqrele(udqp);
1440 xfs_qm_dqrele(gdqp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001441
Christoph Hellwig979ebab2008-03-06 13:46:05 +11001442 *ipp = ip;
Christoph Hellwig288699f2010-06-23 18:11:15 +10001443 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444
Christoph Hellwig517b5e82009-02-09 08:38:02 +01001445 out_bmap_cancel:
1446 xfs_bmap_cancel(&free_list);
1447 out_trans_abort:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 cancel_flags |= XFS_TRANS_ABORT;
Christoph Hellwig517b5e82009-02-09 08:38:02 +01001449 out_trans_cancel:
1450 xfs_trans_cancel(tp, cancel_flags);
1451 out_dqrele:
Christoph Hellwig7d095252009-06-08 15:33:32 +02001452 xfs_qm_dqrele(udqp);
1453 xfs_qm_dqrele(gdqp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001454
Christoph Hellwig993386c2007-08-28 16:12:30 +10001455 if (unlock_dp_on_error)
1456 xfs_iunlock(dp, XFS_ILOCK_EXCL);
Christoph Hellwig288699f2010-06-23 18:11:15 +10001457 std_return:
1458 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459
Christoph Hellwig517b5e82009-02-09 08:38:02 +01001460 out_abort_rele:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461 /*
1462 * Wait until after the current transaction is aborted to
1463 * release the inode. This prevents recursive transactions
1464 * and deadlocks from xfs_inactive.
1465 */
Christoph Hellwig517b5e82009-02-09 08:38:02 +01001466 xfs_bmap_cancel(&free_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001467 cancel_flags |= XFS_TRANS_ABORT;
1468 xfs_trans_cancel(tp, cancel_flags);
1469 IRELE(ip);
Christoph Hellwig517b5e82009-02-09 08:38:02 +01001470 unlock_dp_on_error = B_FALSE;
1471 goto out_dqrele;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472}
1473
1474#ifdef DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -07001475int xfs_locked_n;
1476int xfs_small_retries;
1477int xfs_middle_retries;
1478int xfs_lots_retries;
1479int xfs_lock_delays;
1480#endif
1481
1482/*
Lachlan McIlroyf7c66ce2007-05-08 13:50:19 +10001483 * Bump the subclass so xfs_lock_inodes() acquires each lock with
1484 * a different value
1485 */
1486static inline int
1487xfs_lock_inumorder(int lock_mode, int subclass)
1488{
1489 if (lock_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL))
David Chinner0f1145c2007-06-29 17:26:09 +10001490 lock_mode |= (subclass + XFS_LOCK_INUMORDER) << XFS_IOLOCK_SHIFT;
Lachlan McIlroyf7c66ce2007-05-08 13:50:19 +10001491 if (lock_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL))
David Chinner0f1145c2007-06-29 17:26:09 +10001492 lock_mode |= (subclass + XFS_LOCK_INUMORDER) << XFS_ILOCK_SHIFT;
Lachlan McIlroyf7c66ce2007-05-08 13:50:19 +10001493
1494 return lock_mode;
1495}
1496
1497/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498 * The following routine will lock n inodes in exclusive mode.
1499 * We assume the caller calls us with the inodes in i_ino order.
1500 *
1501 * We need to detect deadlock where an inode that we lock
1502 * is in the AIL and we start waiting for another inode that is locked
1503 * by a thread in a long running transaction (such as truncate). This can
1504 * result in deadlock since the long running trans might need to wait
1505 * for the inode we just locked in order to push the tail and free space
1506 * in the log.
1507 */
1508void
1509xfs_lock_inodes(
1510 xfs_inode_t **ips,
1511 int inodes,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512 uint lock_mode)
1513{
1514 int attempts = 0, i, j, try_lock;
1515 xfs_log_item_t *lp;
1516
1517 ASSERT(ips && (inodes >= 2)); /* we need at least two */
1518
Christoph Hellwigcfa853e2008-04-22 17:34:06 +10001519 try_lock = 0;
1520 i = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521
1522again:
1523 for (; i < inodes; i++) {
1524 ASSERT(ips[i]);
1525
1526 if (i && (ips[i] == ips[i-1])) /* Already locked */
1527 continue;
1528
1529 /*
1530 * If try_lock is not set yet, make sure all locked inodes
1531 * are not in the AIL.
1532 * If any are, set try_lock to be used later.
1533 */
1534
1535 if (!try_lock) {
1536 for (j = (i - 1); j >= 0 && !try_lock; j--) {
1537 lp = (xfs_log_item_t *)ips[j]->i_itemp;
1538 if (lp && (lp->li_flags & XFS_LI_IN_AIL)) {
1539 try_lock++;
1540 }
1541 }
1542 }
1543
1544 /*
1545 * If any of the previous locks we have locked is in the AIL,
1546 * we must TRY to get the second and subsequent locks. If
1547 * we can't get any, we must release all we have
1548 * and try again.
1549 */
1550
1551 if (try_lock) {
1552 /* try_lock must be 0 if i is 0. */
1553 /*
1554 * try_lock means we have an inode locked
1555 * that is in the AIL.
1556 */
1557 ASSERT(i != 0);
Lachlan McIlroyf7c66ce2007-05-08 13:50:19 +10001558 if (!xfs_ilock_nowait(ips[i], xfs_lock_inumorder(lock_mode, i))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559 attempts++;
1560
1561 /*
1562 * Unlock all previous guys and try again.
1563 * xfs_iunlock will try to push the tail
1564 * if the inode is in the AIL.
1565 */
1566
1567 for(j = i - 1; j >= 0; j--) {
1568
1569 /*
1570 * Check to see if we've already
1571 * unlocked this one.
1572 * Not the first one going back,
1573 * and the inode ptr is the same.
1574 */
1575 if ((j != (i - 1)) && ips[j] ==
1576 ips[j+1])
1577 continue;
1578
1579 xfs_iunlock(ips[j], lock_mode);
1580 }
1581
1582 if ((attempts % 5) == 0) {
1583 delay(1); /* Don't just spin the CPU */
1584#ifdef DEBUG
1585 xfs_lock_delays++;
1586#endif
1587 }
1588 i = 0;
1589 try_lock = 0;
1590 goto again;
1591 }
1592 } else {
Lachlan McIlroyf7c66ce2007-05-08 13:50:19 +10001593 xfs_ilock(ips[i], xfs_lock_inumorder(lock_mode, i));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594 }
1595 }
1596
1597#ifdef DEBUG
1598 if (attempts) {
1599 if (attempts < 5) xfs_small_retries++;
1600 else if (attempts < 100) xfs_middle_retries++;
1601 else xfs_lots_retries++;
1602 } else {
1603 xfs_locked_n++;
1604 }
1605#endif
1606}
1607
David Chinnerf9114eb2008-09-17 16:51:21 +10001608/*
1609 * xfs_lock_two_inodes() can only be used to lock one type of lock
1610 * at a time - the iolock or the ilock, but not both at once. If
1611 * we lock both at once, lockdep will report false positives saying
1612 * we have violated locking orders.
1613 */
Christoph Hellwige1cccd92008-08-13 16:18:07 +10001614void
1615xfs_lock_two_inodes(
1616 xfs_inode_t *ip0,
1617 xfs_inode_t *ip1,
1618 uint lock_mode)
1619{
1620 xfs_inode_t *temp;
1621 int attempts = 0;
1622 xfs_log_item_t *lp;
1623
David Chinnerf9114eb2008-09-17 16:51:21 +10001624 if (lock_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL))
1625 ASSERT((lock_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL)) == 0);
Christoph Hellwige1cccd92008-08-13 16:18:07 +10001626 ASSERT(ip0->i_ino != ip1->i_ino);
1627
1628 if (ip0->i_ino > ip1->i_ino) {
1629 temp = ip0;
1630 ip0 = ip1;
1631 ip1 = temp;
1632 }
1633
1634 again:
1635 xfs_ilock(ip0, xfs_lock_inumorder(lock_mode, 0));
1636
1637 /*
1638 * If the first lock we have locked is in the AIL, we must TRY to get
1639 * the second lock. If we can't get it, we must release the first one
1640 * and try again.
1641 */
1642 lp = (xfs_log_item_t *)ip0->i_itemp;
1643 if (lp && (lp->li_flags & XFS_LI_IN_AIL)) {
1644 if (!xfs_ilock_nowait(ip1, xfs_lock_inumorder(lock_mode, 1))) {
1645 xfs_iunlock(ip0, lock_mode);
1646 if ((++attempts % 5) == 0)
1647 delay(1); /* Don't just spin the CPU */
1648 goto again;
1649 }
1650 } else {
1651 xfs_ilock(ip1, xfs_lock_inumorder(lock_mode, 1));
1652 }
1653}
1654
Christoph Hellwig993386c2007-08-28 16:12:30 +10001655int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656xfs_remove(
Christoph Hellwig993386c2007-08-28 16:12:30 +10001657 xfs_inode_t *dp,
Barry Naujok556b8b12008-04-10 12:22:07 +10001658 struct xfs_name *name,
1659 xfs_inode_t *ip)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660{
Christoph Hellwig993386c2007-08-28 16:12:30 +10001661 xfs_mount_t *mp = dp->i_mount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662 xfs_trans_t *tp = NULL;
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001663 int is_dir = S_ISDIR(ip->i_d.di_mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664 int error = 0;
1665 xfs_bmap_free_t free_list;
1666 xfs_fsblock_t first_block;
1667 int cancel_flags;
1668 int committed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669 int link_zero;
1670 uint resblks;
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001671 uint log_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672
Christoph Hellwigcca28fb2010-06-24 11:57:09 +10001673 trace_xfs_remove(dp, name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675 if (XFS_FORCED_SHUTDOWN(mp))
1676 return XFS_ERROR(EIO);
1677
Christoph Hellwig7d095252009-06-08 15:33:32 +02001678 error = xfs_qm_dqattach(dp, 0);
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001679 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 goto std_return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681
Christoph Hellwig7d095252009-06-08 15:33:32 +02001682 error = xfs_qm_dqattach(ip, 0);
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001683 if (error)
1684 goto std_return;
1685
1686 if (is_dir) {
1687 tp = xfs_trans_alloc(mp, XFS_TRANS_RMDIR);
1688 log_count = XFS_DEFAULT_LOG_COUNT;
1689 } else {
1690 tp = xfs_trans_alloc(mp, XFS_TRANS_REMOVE);
1691 log_count = XFS_REMOVE_LOG_COUNT;
1692 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693 cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001694
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 /*
1696 * We try to get the real space reservation first,
1697 * allowing for directory btree deletion(s) implying
1698 * possible bmap insert(s). If we can't get the space
1699 * reservation then we use 0 instead, and avoid the bmap
1700 * btree insert(s) in the directory code by, if the bmap
1701 * insert tries to happen, instead trimming the LAST
1702 * block from the directory.
1703 */
1704 resblks = XFS_REMOVE_SPACE_RES(mp);
1705 error = xfs_trans_reserve(tp, resblks, XFS_REMOVE_LOG_RES(mp), 0,
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001706 XFS_TRANS_PERM_LOG_RES, log_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 if (error == ENOSPC) {
1708 resblks = 0;
1709 error = xfs_trans_reserve(tp, 0, XFS_REMOVE_LOG_RES(mp), 0,
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001710 XFS_TRANS_PERM_LOG_RES, log_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001711 }
1712 if (error) {
1713 ASSERT(error != ENOSPC);
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001714 cancel_flags = 0;
1715 goto out_trans_cancel;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716 }
1717
Christoph Hellwige1cccd92008-08-13 16:18:07 +10001718 xfs_lock_two_inodes(dp, ip, XFS_ILOCK_EXCL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719
Christoph Hellwig898621d2010-06-24 11:36:58 +10001720 xfs_trans_ijoin_ref(tp, dp, XFS_ILOCK_EXCL);
1721 xfs_trans_ijoin_ref(tp, ip, XFS_ILOCK_EXCL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722
1723 /*
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001724 * If we're removing a directory perform some additional validation.
1725 */
1726 if (is_dir) {
1727 ASSERT(ip->i_d.di_nlink >= 2);
1728 if (ip->i_d.di_nlink != 2) {
1729 error = XFS_ERROR(ENOTEMPTY);
1730 goto out_trans_cancel;
1731 }
1732 if (!xfs_dir_isempty(ip)) {
1733 error = XFS_ERROR(ENOTEMPTY);
1734 goto out_trans_cancel;
1735 }
1736 }
1737
Eric Sandeen9d87c312009-01-14 23:22:07 -06001738 xfs_bmap_init(&free_list, &first_block);
Barry Naujok556b8b12008-04-10 12:22:07 +10001739 error = xfs_dir_removename(tp, dp, name, ip->i_ino,
Christoph Hellwigd4377d82008-04-22 17:33:46 +10001740 &first_block, &free_list, resblks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741 if (error) {
1742 ASSERT(error != ENOENT);
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001743 goto out_bmap_cancel;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744 }
1745 xfs_ichgtime(dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
1746
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001747 if (is_dir) {
1748 /*
1749 * Drop the link from ip's "..".
1750 */
1751 error = xfs_droplink(tp, dp);
1752 if (error)
1753 goto out_bmap_cancel;
1754
1755 /*
Christoph Hellwig2b7035f2008-10-30 17:55:18 +11001756 * Drop the "." link from ip to self.
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001757 */
1758 error = xfs_droplink(tp, ip);
1759 if (error)
1760 goto out_bmap_cancel;
1761 } else {
1762 /*
1763 * When removing a non-directory we need to log the parent
Dave Chinner26c52952008-11-28 14:23:37 +11001764 * inode here. For a directory this is done implicitly
1765 * by the xfs_droplink call for the ".." entry.
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001766 */
1767 xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001768 }
1769
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001770 /*
Christoph Hellwig2b7035f2008-10-30 17:55:18 +11001771 * Drop the link from dp to ip.
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001772 */
1773 error = xfs_droplink(tp, ip);
1774 if (error)
1775 goto out_bmap_cancel;
1776
1777 /*
1778 * Determine if this is the last link while
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779 * we are in the transaction.
1780 */
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001781 link_zero = (ip->i_d.di_nlink == 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782
1783 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784 * If this is a synchronous mount, make sure that the
1785 * remove transaction goes to disk before returning to
1786 * the user.
1787 */
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001788 if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789 xfs_trans_set_sync(tp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790
Eric Sandeenf7c99b62007-02-10 18:37:16 +11001791 error = xfs_bmap_finish(&tp, &free_list, &committed);
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001792 if (error)
1793 goto out_bmap_cancel;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794
Eric Sandeen1c72bf92007-05-08 13:48:42 +10001795 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
Christoph Hellwig5df78e72008-04-22 17:34:24 +10001796 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797 goto std_return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798
1799 /*
David Chinner2a82b8b2007-07-11 11:09:12 +10001800 * If we are using filestreams, kill the stream association.
1801 * If the file is still open it may get a new one but that
1802 * will get killed on last close in xfs_close() so we don't
1803 * have to worry about that.
1804 */
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001805 if (!is_dir && link_zero && xfs_inode_is_filestream(ip))
David Chinner2a82b8b2007-07-11 11:09:12 +10001806 xfs_filestream_deassociate(ip);
1807
Christoph Hellwig288699f2010-06-23 18:11:15 +10001808 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001809
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001810 out_bmap_cancel:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811 xfs_bmap_cancel(&free_list);
1812 cancel_flags |= XFS_TRANS_ABORT;
Christoph Hellwig8f112e32008-06-23 13:25:17 +10001813 out_trans_cancel:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814 xfs_trans_cancel(tp, cancel_flags);
Christoph Hellwig288699f2010-06-23 18:11:15 +10001815 std_return:
1816 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817}
1818
Christoph Hellwig993386c2007-08-28 16:12:30 +10001819int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820xfs_link(
Christoph Hellwig993386c2007-08-28 16:12:30 +10001821 xfs_inode_t *tdp,
Christoph Hellwiga3da7892008-03-06 13:46:12 +11001822 xfs_inode_t *sip,
Barry Naujok556b8b12008-04-10 12:22:07 +10001823 struct xfs_name *target_name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824{
Christoph Hellwig993386c2007-08-28 16:12:30 +10001825 xfs_mount_t *mp = tdp->i_mount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 xfs_trans_t *tp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827 int error;
1828 xfs_bmap_free_t free_list;
1829 xfs_fsblock_t first_block;
1830 int cancel_flags;
1831 int committed;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832 int resblks;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001833
Christoph Hellwigcca28fb2010-06-24 11:57:09 +10001834 trace_xfs_link(tdp, target_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835
Christoph Hellwiga3da7892008-03-06 13:46:12 +11001836 ASSERT(!S_ISDIR(sip->i_d.di_mode));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001837
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838 if (XFS_FORCED_SHUTDOWN(mp))
1839 return XFS_ERROR(EIO);
1840
Christoph Hellwig7d095252009-06-08 15:33:32 +02001841 error = xfs_qm_dqattach(sip, 0);
Christoph Hellwigcb3f35b2009-02-04 09:34:20 +01001842 if (error)
1843 goto std_return;
1844
Christoph Hellwig7d095252009-06-08 15:33:32 +02001845 error = xfs_qm_dqattach(tdp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846 if (error)
1847 goto std_return;
1848
1849 tp = xfs_trans_alloc(mp, XFS_TRANS_LINK);
1850 cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
Barry Naujok556b8b12008-04-10 12:22:07 +10001851 resblks = XFS_LINK_SPACE_RES(mp, target_name->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852 error = xfs_trans_reserve(tp, resblks, XFS_LINK_LOG_RES(mp), 0,
1853 XFS_TRANS_PERM_LOG_RES, XFS_LINK_LOG_COUNT);
1854 if (error == ENOSPC) {
1855 resblks = 0;
1856 error = xfs_trans_reserve(tp, 0, XFS_LINK_LOG_RES(mp), 0,
1857 XFS_TRANS_PERM_LOG_RES, XFS_LINK_LOG_COUNT);
1858 }
1859 if (error) {
1860 cancel_flags = 0;
1861 goto error_return;
1862 }
1863
Christoph Hellwige1cccd92008-08-13 16:18:07 +10001864 xfs_lock_two_inodes(sip, tdp, XFS_ILOCK_EXCL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001865
Christoph Hellwig898621d2010-06-24 11:36:58 +10001866 xfs_trans_ijoin_ref(tp, sip, XFS_ILOCK_EXCL);
1867 xfs_trans_ijoin_ref(tp, tdp, XFS_ILOCK_EXCL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001868
1869 /*
1870 * If the source has too many links, we can't make any more to it.
1871 */
1872 if (sip->i_d.di_nlink >= XFS_MAXLINK) {
1873 error = XFS_ERROR(EMLINK);
1874 goto error_return;
1875 }
1876
Nathan Scott365ca832005-06-21 15:39:12 +10001877 /*
1878 * If we are using project inheritance, we only allow hard link
1879 * creation in our tree when the project IDs are the same; else
1880 * the tree quota mechanism could be circumvented.
1881 */
1882 if (unlikely((tdp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT) &&
1883 (tdp->i_d.di_projid != sip->i_d.di_projid))) {
Nathan Scottb1ecdda2006-05-08 19:51:42 +10001884 error = XFS_ERROR(EXDEV);
Nathan Scott365ca832005-06-21 15:39:12 +10001885 goto error_return;
1886 }
1887
Barry Naujok556b8b12008-04-10 12:22:07 +10001888 error = xfs_dir_canenter(tp, tdp, target_name, resblks);
1889 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890 goto error_return;
1891
Eric Sandeen9d87c312009-01-14 23:22:07 -06001892 xfs_bmap_init(&free_list, &first_block);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893
Barry Naujok556b8b12008-04-10 12:22:07 +10001894 error = xfs_dir_createname(tp, tdp, target_name, sip->i_ino,
1895 &first_block, &free_list, resblks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896 if (error)
1897 goto abort_return;
1898 xfs_ichgtime(tdp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899 xfs_trans_log_inode(tp, tdp, XFS_ILOG_CORE);
1900
1901 error = xfs_bumplink(tp, sip);
Alexey Dobriyanb71d3002006-06-27 12:45:17 +10001902 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903 goto abort_return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904
1905 /*
1906 * If this is a synchronous mount, make sure that the
1907 * link transaction goes to disk before returning to
1908 * the user.
1909 */
1910 if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
1911 xfs_trans_set_sync(tp);
1912 }
1913
Eric Sandeenf7c99b62007-02-10 18:37:16 +11001914 error = xfs_bmap_finish (&tp, &free_list, &committed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915 if (error) {
1916 xfs_bmap_cancel(&free_list);
1917 goto abort_return;
1918 }
1919
Christoph Hellwig288699f2010-06-23 18:11:15 +10001920 return xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921
1922 abort_return:
1923 cancel_flags |= XFS_TRANS_ABORT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001924 error_return:
1925 xfs_trans_cancel(tp, cancel_flags);
Christoph Hellwig288699f2010-06-23 18:11:15 +10001926 std_return:
1927 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928}
Alexey Dobriyanb71d3002006-06-27 12:45:17 +10001929
Christoph Hellwig993386c2007-08-28 16:12:30 +10001930int
Linus Torvalds1da177e2005-04-16 15:20:36 -07001931xfs_symlink(
Christoph Hellwig993386c2007-08-28 16:12:30 +10001932 xfs_inode_t *dp,
Barry Naujok556b8b12008-04-10 12:22:07 +10001933 struct xfs_name *link_name,
1934 const char *target_path,
Christoph Hellwig3e5daf02007-10-11 18:09:12 +10001935 mode_t mode,
Christoph Hellwig3937be52008-03-06 13:46:19 +11001936 xfs_inode_t **ipp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937 cred_t *credp)
1938{
Christoph Hellwig993386c2007-08-28 16:12:30 +10001939 xfs_mount_t *mp = dp->i_mount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940 xfs_trans_t *tp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941 xfs_inode_t *ip;
1942 int error;
1943 int pathlen;
1944 xfs_bmap_free_t free_list;
1945 xfs_fsblock_t first_block;
Christoph Hellwig993386c2007-08-28 16:12:30 +10001946 boolean_t unlock_dp_on_error = B_FALSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947 uint cancel_flags;
1948 int committed;
1949 xfs_fileoff_t first_fsb;
1950 xfs_filblks_t fs_blocks;
1951 int nmaps;
1952 xfs_bmbt_irec_t mval[SYMLINK_MAPS];
1953 xfs_daddr_t d;
Barry Naujok556b8b12008-04-10 12:22:07 +10001954 const char *cur_chunk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955 int byte_cnt;
1956 int n;
1957 xfs_buf_t *bp;
1958 xfs_prid_t prid;
1959 struct xfs_dquot *udqp, *gdqp;
1960 uint resblks;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961
Christoph Hellwig3937be52008-03-06 13:46:19 +11001962 *ipp = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963 error = 0;
1964 ip = NULL;
1965 tp = NULL;
1966
Christoph Hellwigcca28fb2010-06-24 11:57:09 +10001967 trace_xfs_symlink(dp, link_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968
1969 if (XFS_FORCED_SHUTDOWN(mp))
1970 return XFS_ERROR(EIO);
1971
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972 /*
1973 * Check component lengths of the target path name.
1974 */
1975 pathlen = strlen(target_path);
1976 if (pathlen >= MAXPATHLEN) /* total string too long */
1977 return XFS_ERROR(ENAMETOOLONG);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001978
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979 udqp = gdqp = NULL;
Nathan Scott365ca832005-06-21 15:39:12 +10001980 if (dp->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
1981 prid = dp->i_d.di_projid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001982 else
1983 prid = (xfs_prid_t)dfltprid;
1984
1985 /*
1986 * Make sure that we have allocated dquot(s) on disk.
1987 */
Christoph Hellwig7d095252009-06-08 15:33:32 +02001988 error = xfs_qm_vop_dqalloc(dp, current_fsuid(), current_fsgid(), prid,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989 XFS_QMOPT_QUOTALL | XFS_QMOPT_INHERIT, &udqp, &gdqp);
1990 if (error)
1991 goto std_return;
1992
1993 tp = xfs_trans_alloc(mp, XFS_TRANS_SYMLINK);
1994 cancel_flags = XFS_TRANS_RELEASE_LOG_RES;
1995 /*
1996 * The symlink will fit into the inode data fork?
1997 * There can't be any attributes so we get the whole variable part.
1998 */
1999 if (pathlen <= XFS_LITINO(mp))
2000 fs_blocks = 0;
2001 else
2002 fs_blocks = XFS_B_TO_FSB(mp, pathlen);
Barry Naujok556b8b12008-04-10 12:22:07 +10002003 resblks = XFS_SYMLINK_SPACE_RES(mp, link_name->len, fs_blocks);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002004 error = xfs_trans_reserve(tp, resblks, XFS_SYMLINK_LOG_RES(mp), 0,
2005 XFS_TRANS_PERM_LOG_RES, XFS_SYMLINK_LOG_COUNT);
2006 if (error == ENOSPC && fs_blocks == 0) {
2007 resblks = 0;
2008 error = xfs_trans_reserve(tp, 0, XFS_SYMLINK_LOG_RES(mp), 0,
2009 XFS_TRANS_PERM_LOG_RES, XFS_SYMLINK_LOG_COUNT);
2010 }
2011 if (error) {
2012 cancel_flags = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002013 goto error_return;
2014 }
2015
Lachlan McIlroyf7c66ce2007-05-08 13:50:19 +10002016 xfs_ilock(dp, XFS_ILOCK_EXCL | XFS_ILOCK_PARENT);
Christoph Hellwig993386c2007-08-28 16:12:30 +10002017 unlock_dp_on_error = B_TRUE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002018
2019 /*
2020 * Check whether the directory allows new symlinks or not.
2021 */
2022 if (dp->i_d.di_flags & XFS_DIFLAG_NOSYMLINKS) {
2023 error = XFS_ERROR(EPERM);
2024 goto error_return;
2025 }
2026
2027 /*
2028 * Reserve disk quota : blocks and inode.
2029 */
Christoph Hellwig7d095252009-06-08 15:33:32 +02002030 error = xfs_trans_reserve_quota(tp, mp, udqp, gdqp, resblks, 1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002031 if (error)
2032 goto error_return;
2033
2034 /*
2035 * Check for ability to enter directory entry, if no space reserved.
2036 */
Barry Naujok556b8b12008-04-10 12:22:07 +10002037 error = xfs_dir_canenter(tp, dp, link_name, resblks);
2038 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002039 goto error_return;
2040 /*
2041 * Initialize the bmap freelist prior to calling either
2042 * bmapi or the directory create code.
2043 */
Eric Sandeen9d87c312009-01-14 23:22:07 -06002044 xfs_bmap_init(&free_list, &first_block);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002045
2046 /*
2047 * Allocate an inode for the symlink.
2048 */
Christoph Hellwig3e5daf02007-10-11 18:09:12 +10002049 error = xfs_dir_ialloc(&tp, dp, S_IFLNK | (mode & ~S_IFMT),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002050 1, 0, credp, prid, resblks > 0, &ip, NULL);
2051 if (error) {
2052 if (error == ENOSPC)
2053 goto error_return;
2054 goto error1;
2055 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002056
Christoph Hellwig993386c2007-08-28 16:12:30 +10002057 /*
2058 * An error after we've joined dp to the transaction will result in the
2059 * transaction cancel unlocking dp so don't do it explicitly in the
2060 * error path.
2061 */
Christoph Hellwig898621d2010-06-24 11:36:58 +10002062 xfs_trans_ijoin_ref(tp, dp, XFS_ILOCK_EXCL);
Christoph Hellwig993386c2007-08-28 16:12:30 +10002063 unlock_dp_on_error = B_FALSE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064
2065 /*
2066 * Also attach the dquot(s) to it, if applicable.
2067 */
Christoph Hellwig7d095252009-06-08 15:33:32 +02002068 xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002069
2070 if (resblks)
2071 resblks -= XFS_IALLOC_SPACE_RES(mp);
2072 /*
2073 * If the symlink will fit into the inode, write it inline.
2074 */
2075 if (pathlen <= XFS_IFORK_DSIZE(ip)) {
2076 xfs_idata_realloc(ip, pathlen, XFS_DATA_FORK);
2077 memcpy(ip->i_df.if_u1.if_data, target_path, pathlen);
2078 ip->i_d.di_size = pathlen;
2079
2080 /*
2081 * The inode was initially created in extent format.
2082 */
2083 ip->i_df.if_flags &= ~(XFS_IFEXTENTS | XFS_IFBROOT);
2084 ip->i_df.if_flags |= XFS_IFINLINE;
2085
2086 ip->i_d.di_format = XFS_DINODE_FMT_LOCAL;
2087 xfs_trans_log_inode(tp, ip, XFS_ILOG_DDATA | XFS_ILOG_CORE);
2088
2089 } else {
2090 first_fsb = 0;
2091 nmaps = SYMLINK_MAPS;
2092
2093 error = xfs_bmapi(tp, ip, first_fsb, fs_blocks,
2094 XFS_BMAPI_WRITE | XFS_BMAPI_METADATA,
2095 &first_block, resblks, mval, &nmaps,
Christoph Hellwigb4e91812010-06-23 18:11:15 +10002096 &free_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097 if (error) {
2098 goto error1;
2099 }
2100
2101 if (resblks)
2102 resblks -= fs_blocks;
2103 ip->i_d.di_size = pathlen;
2104 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
2105
2106 cur_chunk = target_path;
2107 for (n = 0; n < nmaps; n++) {
2108 d = XFS_FSB_TO_DADDR(mp, mval[n].br_startblock);
2109 byte_cnt = XFS_FSB_TO_B(mp, mval[n].br_blockcount);
2110 bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
2111 BTOBB(byte_cnt), 0);
2112 ASSERT(bp && !XFS_BUF_GETERROR(bp));
2113 if (pathlen < byte_cnt) {
2114 byte_cnt = pathlen;
2115 }
2116 pathlen -= byte_cnt;
2117
2118 memcpy(XFS_BUF_PTR(bp), cur_chunk, byte_cnt);
2119 cur_chunk += byte_cnt;
2120
2121 xfs_trans_log_buf(tp, bp, 0, byte_cnt - 1);
2122 }
2123 }
2124
2125 /*
2126 * Create the directory entry for the symlink.
2127 */
Barry Naujok556b8b12008-04-10 12:22:07 +10002128 error = xfs_dir_createname(tp, dp, link_name, ip->i_ino,
2129 &first_block, &free_list, resblks);
Nathan Scottf6c2d1f2006-06-20 13:04:51 +10002130 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002131 goto error1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132 xfs_ichgtime(dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
2133 xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
2134
2135 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002136 * If this is a synchronous mount, make sure that the
2137 * symlink transaction goes to disk before returning to
2138 * the user.
2139 */
2140 if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC)) {
2141 xfs_trans_set_sync(tp);
2142 }
2143
2144 /*
2145 * xfs_trans_commit normally decrements the vnode ref count
2146 * when it unlocks the inode. Since we want to return the
2147 * vnode to the caller, we bump the vnode ref count now.
2148 */
2149 IHOLD(ip);
2150
Eric Sandeenf7c99b62007-02-10 18:37:16 +11002151 error = xfs_bmap_finish(&tp, &free_list, &committed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002152 if (error) {
2153 goto error2;
2154 }
Eric Sandeen1c72bf92007-05-08 13:48:42 +10002155 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
Christoph Hellwig7d095252009-06-08 15:33:32 +02002156 xfs_qm_dqrele(udqp);
2157 xfs_qm_dqrele(gdqp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002158
Christoph Hellwig288699f2010-06-23 18:11:15 +10002159 *ipp = ip;
2160 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002161
2162 error2:
2163 IRELE(ip);
2164 error1:
2165 xfs_bmap_cancel(&free_list);
2166 cancel_flags |= XFS_TRANS_ABORT;
2167 error_return:
2168 xfs_trans_cancel(tp, cancel_flags);
Christoph Hellwig7d095252009-06-08 15:33:32 +02002169 xfs_qm_dqrele(udqp);
2170 xfs_qm_dqrele(gdqp);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002171
Christoph Hellwig993386c2007-08-28 16:12:30 +10002172 if (unlock_dp_on_error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002173 xfs_iunlock(dp, XFS_ILOCK_EXCL);
Christoph Hellwig288699f2010-06-23 18:11:15 +10002174 std_return:
2175 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002176}
2177
Linus Torvalds1da177e2005-04-16 15:20:36 -07002178int
Christoph Hellwig993386c2007-08-28 16:12:30 +10002179xfs_set_dmattrs(
2180 xfs_inode_t *ip,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002181 u_int evmask,
Christoph Hellwig993386c2007-08-28 16:12:30 +10002182 u_int16_t state)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002183{
Christoph Hellwig993386c2007-08-28 16:12:30 +10002184 xfs_mount_t *mp = ip->i_mount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002185 xfs_trans_t *tp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002186 int error;
2187
2188 if (!capable(CAP_SYS_ADMIN))
2189 return XFS_ERROR(EPERM);
2190
Linus Torvalds1da177e2005-04-16 15:20:36 -07002191 if (XFS_FORCED_SHUTDOWN(mp))
2192 return XFS_ERROR(EIO);
2193
2194 tp = xfs_trans_alloc(mp, XFS_TRANS_SET_DMATTRS);
2195 error = xfs_trans_reserve(tp, 0, XFS_ICHANGE_LOG_RES (mp), 0, 0, 0);
2196 if (error) {
2197 xfs_trans_cancel(tp, 0);
2198 return error;
2199 }
2200 xfs_ilock(ip, XFS_ILOCK_EXCL);
Christoph Hellwig898621d2010-06-24 11:36:58 +10002201 xfs_trans_ijoin_ref(tp, ip, XFS_ILOCK_EXCL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002202
Christoph Hellwig613d7042007-10-11 17:44:08 +10002203 ip->i_d.di_dmevmask = evmask;
2204 ip->i_d.di_dmstate = state;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002205
2206 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
Eric Sandeen1c72bf92007-05-08 13:48:42 +10002207 error = xfs_trans_commit(tp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002208
2209 return error;
2210}
2211
Linus Torvalds1da177e2005-04-16 15:20:36 -07002212/*
2213 * xfs_alloc_file_space()
2214 * This routine allocates disk space for the given file.
2215 *
2216 * If alloc_type == 0, this request is for an ALLOCSP type
2217 * request which will change the file size. In this case, no
2218 * DMAPI event will be generated by the call. A TRUNCATE event
2219 * will be generated later by xfs_setattr.
2220 *
2221 * If alloc_type != 0, this request is for a RESVSP type
2222 * request, and a DMAPI DM_EVENT_WRITE will be generated if the
2223 * lower block boundary byte address is less than the file's
2224 * length.
2225 *
2226 * RETURNS:
2227 * 0 on success
2228 * errno on error
2229 *
2230 */
Christoph Hellwigba0f32d2005-06-21 15:36:52 +10002231STATIC int
Linus Torvalds1da177e2005-04-16 15:20:36 -07002232xfs_alloc_file_space(
2233 xfs_inode_t *ip,
2234 xfs_off_t offset,
2235 xfs_off_t len,
2236 int alloc_type,
2237 int attr_flags)
2238{
Nathan Scottdd9f4382006-01-11 15:28:28 +11002239 xfs_mount_t *mp = ip->i_mount;
2240 xfs_off_t count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002241 xfs_filblks_t allocated_fsb;
2242 xfs_filblks_t allocatesize_fsb;
Nathan Scottdd9f4382006-01-11 15:28:28 +11002243 xfs_extlen_t extsz, temp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244 xfs_fileoff_t startoffset_fsb;
Nathan Scottdd9f4382006-01-11 15:28:28 +11002245 xfs_fsblock_t firstfsb;
2246 int nimaps;
2247 int bmapi_flag;
2248 int quota_flag;
2249 int rt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002250 xfs_trans_t *tp;
Nathan Scottdd9f4382006-01-11 15:28:28 +11002251 xfs_bmbt_irec_t imaps[1], *imapp;
2252 xfs_bmap_free_t free_list;
2253 uint qblocks, resblks, resrtextents;
2254 int committed;
2255 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002256
Christoph Hellwigcca28fb2010-06-24 11:57:09 +10002257 trace_xfs_alloc_file_space(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002258
2259 if (XFS_FORCED_SHUTDOWN(mp))
2260 return XFS_ERROR(EIO);
2261
Christoph Hellwig7d095252009-06-08 15:33:32 +02002262 error = xfs_qm_dqattach(ip, 0);
2263 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002264 return error;
2265
2266 if (len <= 0)
2267 return XFS_ERROR(EINVAL);
2268
David Chinner957d0eb2007-06-18 16:50:37 +10002269 rt = XFS_IS_REALTIME_INODE(ip);
2270 extsz = xfs_get_extsz_hint(ip);
2271
Linus Torvalds1da177e2005-04-16 15:20:36 -07002272 count = len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002273 imapp = &imaps[0];
Nathan Scottdd9f4382006-01-11 15:28:28 +11002274 nimaps = 1;
2275 bmapi_flag = XFS_BMAPI_WRITE | (alloc_type ? XFS_BMAPI_PREALLOC : 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002276 startoffset_fsb = XFS_B_TO_FSBT(mp, offset);
2277 allocatesize_fsb = XFS_B_TO_FSB(mp, count);
2278
Linus Torvalds1da177e2005-04-16 15:20:36 -07002279 /*
Nathan Scottdd9f4382006-01-11 15:28:28 +11002280 * Allocate file space until done or until there is an error
Linus Torvalds1da177e2005-04-16 15:20:36 -07002281 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002282 while (allocatesize_fsb && !error) {
Nathan Scottdd9f4382006-01-11 15:28:28 +11002283 xfs_fileoff_t s, e;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002284
Nathan Scottdd9f4382006-01-11 15:28:28 +11002285 /*
Nathan Scott3ddb8fa2006-01-11 15:33:02 +11002286 * Determine space reservations for data/realtime.
Nathan Scottdd9f4382006-01-11 15:28:28 +11002287 */
2288 if (unlikely(extsz)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002289 s = startoffset_fsb;
Nathan Scottdd9f4382006-01-11 15:28:28 +11002290 do_div(s, extsz);
2291 s *= extsz;
2292 e = startoffset_fsb + allocatesize_fsb;
2293 if ((temp = do_mod(startoffset_fsb, extsz)))
2294 e += temp;
2295 if ((temp = do_mod(e, extsz)))
2296 e += extsz - temp;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002297 } else {
Nathan Scottdd9f4382006-01-11 15:28:28 +11002298 s = 0;
2299 e = allocatesize_fsb;
2300 }
2301
Dave Chinner72656c42010-09-03 12:19:33 +10002302 /*
2303 * The transaction reservation is limited to a 32-bit block
2304 * count, hence we need to limit the number of blocks we are
2305 * trying to reserve to avoid an overflow. We can't allocate
2306 * more than @nimaps extents, and an extent is limited on disk
2307 * to MAXEXTLEN (21 bits), so use that to enforce the limit.
2308 */
2309 resblks = min_t(xfs_fileoff_t, (e - s), (MAXEXTLEN * nimaps));
Nathan Scottdd9f4382006-01-11 15:28:28 +11002310 if (unlikely(rt)) {
Dave Chinner72656c42010-09-03 12:19:33 +10002311 resrtextents = qblocks = resblks;
Nathan Scottdd9f4382006-01-11 15:28:28 +11002312 resrtextents /= mp->m_sb.sb_rextsize;
2313 resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
2314 quota_flag = XFS_QMOPT_RES_RTBLKS;
2315 } else {
2316 resrtextents = 0;
Dave Chinner72656c42010-09-03 12:19:33 +10002317 resblks = qblocks = XFS_DIOSTRAT_SPACE_RES(mp, resblks);
Nathan Scottdd9f4382006-01-11 15:28:28 +11002318 quota_flag = XFS_QMOPT_RES_REGBLKS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002319 }
2320
2321 /*
Nathan Scottdd9f4382006-01-11 15:28:28 +11002322 * Allocate and setup the transaction.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002323 */
2324 tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
Nathan Scottdd9f4382006-01-11 15:28:28 +11002325 error = xfs_trans_reserve(tp, resblks,
2326 XFS_WRITE_LOG_RES(mp), resrtextents,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002327 XFS_TRANS_PERM_LOG_RES,
2328 XFS_WRITE_LOG_COUNT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002329 /*
Nathan Scottdd9f4382006-01-11 15:28:28 +11002330 * Check for running out of space
Linus Torvalds1da177e2005-04-16 15:20:36 -07002331 */
2332 if (error) {
2333 /*
2334 * Free the transaction structure.
2335 */
2336 ASSERT(error == ENOSPC || XFS_FORCED_SHUTDOWN(mp));
2337 xfs_trans_cancel(tp, 0);
2338 break;
2339 }
2340 xfs_ilock(ip, XFS_ILOCK_EXCL);
Christoph Hellwig7d095252009-06-08 15:33:32 +02002341 error = xfs_trans_reserve_quota_nblks(tp, ip, qblocks,
2342 0, quota_flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002343 if (error)
2344 goto error1;
2345
Christoph Hellwig898621d2010-06-24 11:36:58 +10002346 xfs_trans_ijoin(tp, ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002347
2348 /*
Nathan Scottdd9f4382006-01-11 15:28:28 +11002349 * Issue the xfs_bmapi() call to allocate the blocks
Linus Torvalds1da177e2005-04-16 15:20:36 -07002350 */
Eric Sandeen9d87c312009-01-14 23:22:07 -06002351 xfs_bmap_init(&free_list, &firstfsb);
Lachlan McIlroy541d7d32007-10-11 17:34:33 +10002352 error = xfs_bmapi(tp, ip, startoffset_fsb,
Nathan Scottdd9f4382006-01-11 15:28:28 +11002353 allocatesize_fsb, bmapi_flag,
2354 &firstfsb, 0, imapp, &nimaps,
Christoph Hellwigb4e91812010-06-23 18:11:15 +10002355 &free_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002356 if (error) {
2357 goto error0;
2358 }
2359
2360 /*
Nathan Scottdd9f4382006-01-11 15:28:28 +11002361 * Complete the transaction
Linus Torvalds1da177e2005-04-16 15:20:36 -07002362 */
Eric Sandeenf7c99b62007-02-10 18:37:16 +11002363 error = xfs_bmap_finish(&tp, &free_list, &committed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002364 if (error) {
2365 goto error0;
2366 }
2367
Eric Sandeen1c72bf92007-05-08 13:48:42 +10002368 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002369 xfs_iunlock(ip, XFS_ILOCK_EXCL);
2370 if (error) {
2371 break;
2372 }
2373
2374 allocated_fsb = imapp->br_blockcount;
2375
Nathan Scottdd9f4382006-01-11 15:28:28 +11002376 if (nimaps == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377 error = XFS_ERROR(ENOSPC);
2378 break;
2379 }
2380
2381 startoffset_fsb += allocated_fsb;
2382 allocatesize_fsb -= allocated_fsb;
2383 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002384
2385 return error;
2386
Nathan Scottdd9f4382006-01-11 15:28:28 +11002387error0: /* Cancel bmap, unlock inode, unreserve quota blocks, cancel trans */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002388 xfs_bmap_cancel(&free_list);
Christoph Hellwig7d095252009-06-08 15:33:32 +02002389 xfs_trans_unreserve_quota_nblks(tp, ip, qblocks, 0, quota_flag);
Nathan Scottdd9f4382006-01-11 15:28:28 +11002390
2391error1: /* Just cancel transaction */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002392 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
2393 xfs_iunlock(ip, XFS_ILOCK_EXCL);
Christoph Hellwig288699f2010-06-23 18:11:15 +10002394 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002395}
2396
2397/*
2398 * Zero file bytes between startoff and endoff inclusive.
2399 * The iolock is held exclusive and no blocks are buffered.
Lachlan McIlroy2fd6f6e2008-09-17 16:52:50 +10002400 *
2401 * This function is used by xfs_free_file_space() to zero
2402 * partial blocks when the range to free is not block aligned.
2403 * When unreserving space with boundaries that are not block
2404 * aligned we round up the start and round down the end
2405 * boundaries and then use this function to zero the parts of
2406 * the blocks that got dropped during the rounding.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002407 */
2408STATIC int
2409xfs_zero_remaining_bytes(
2410 xfs_inode_t *ip,
2411 xfs_off_t startoff,
2412 xfs_off_t endoff)
2413{
2414 xfs_bmbt_irec_t imap;
2415 xfs_fileoff_t offset_fsb;
2416 xfs_off_t lastoffset;
2417 xfs_off_t offset;
2418 xfs_buf_t *bp;
2419 xfs_mount_t *mp = ip->i_mount;
2420 int nimap;
2421 int error = 0;
2422
Lachlan McIlroy2fd6f6e2008-09-17 16:52:50 +10002423 /*
2424 * Avoid doing I/O beyond eof - it's not necessary
2425 * since nothing can read beyond eof. The space will
2426 * be zeroed when the file is extended anyway.
2427 */
2428 if (startoff >= ip->i_size)
2429 return 0;
2430
2431 if (endoff > ip->i_size)
2432 endoff = ip->i_size;
2433
Linus Torvalds1da177e2005-04-16 15:20:36 -07002434 bp = xfs_buf_get_noaddr(mp->m_sb.sb_blocksize,
Eric Sandeen71ddabb2007-11-23 16:29:42 +11002435 XFS_IS_REALTIME_INODE(ip) ?
Linus Torvalds1da177e2005-04-16 15:20:36 -07002436 mp->m_rtdev_targp : mp->m_ddev_targp);
Lachlan McIlroyc6422612008-12-05 13:16:15 +11002437 if (!bp)
2438 return XFS_ERROR(ENOMEM);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002439
2440 for (offset = startoff; offset <= endoff; offset = lastoffset + 1) {
2441 offset_fsb = XFS_B_TO_FSBT(mp, offset);
2442 nimap = 1;
Lachlan McIlroy541d7d32007-10-11 17:34:33 +10002443 error = xfs_bmapi(NULL, ip, offset_fsb, 1, 0,
Christoph Hellwigb4e91812010-06-23 18:11:15 +10002444 NULL, 0, &imap, &nimap, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002445 if (error || nimap < 1)
2446 break;
2447 ASSERT(imap.br_blockcount >= 1);
2448 ASSERT(imap.br_startoff == offset_fsb);
2449 lastoffset = XFS_FSB_TO_B(mp, imap.br_startoff + 1) - 1;
2450 if (lastoffset > endoff)
2451 lastoffset = endoff;
2452 if (imap.br_startblock == HOLESTARTBLOCK)
2453 continue;
2454 ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
2455 if (imap.br_state == XFS_EXT_UNWRITTEN)
2456 continue;
2457 XFS_BUF_UNDONE(bp);
2458 XFS_BUF_UNWRITE(bp);
2459 XFS_BUF_READ(bp);
Eric Sandeen9d87c312009-01-14 23:22:07 -06002460 XFS_BUF_SET_ADDR(bp, xfs_fsb_to_db(ip, imap.br_startblock));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002461 xfsbdstrat(mp, bp);
David Chinnerd64e31a2008-04-10 12:22:17 +10002462 error = xfs_iowait(bp);
2463 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002464 xfs_ioerror_alert("xfs_zero_remaining_bytes(read)",
2465 mp, bp, XFS_BUF_ADDR(bp));
2466 break;
2467 }
2468 memset(XFS_BUF_PTR(bp) +
2469 (offset - XFS_FSB_TO_B(mp, imap.br_startoff)),
2470 0, lastoffset - offset + 1);
2471 XFS_BUF_UNDONE(bp);
2472 XFS_BUF_UNREAD(bp);
2473 XFS_BUF_WRITE(bp);
2474 xfsbdstrat(mp, bp);
David Chinnerd64e31a2008-04-10 12:22:17 +10002475 error = xfs_iowait(bp);
2476 if (error) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002477 xfs_ioerror_alert("xfs_zero_remaining_bytes(write)",
2478 mp, bp, XFS_BUF_ADDR(bp));
2479 break;
2480 }
2481 }
2482 xfs_buf_free(bp);
2483 return error;
2484}
2485
2486/*
2487 * xfs_free_file_space()
2488 * This routine frees disk space for the given file.
2489 *
2490 * This routine is only called by xfs_change_file_space
2491 * for an UNRESVSP type call.
2492 *
2493 * RETURNS:
2494 * 0 on success
2495 * errno on error
2496 *
2497 */
2498STATIC int
2499xfs_free_file_space(
2500 xfs_inode_t *ip,
2501 xfs_off_t offset,
2502 xfs_off_t len,
2503 int attr_flags)
2504{
2505 int committed;
2506 int done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002507 xfs_fileoff_t endoffset_fsb;
2508 int error;
2509 xfs_fsblock_t firstfsb;
2510 xfs_bmap_free_t free_list;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002511 xfs_bmbt_irec_t imap;
2512 xfs_off_t ioffset;
2513 xfs_extlen_t mod=0;
2514 xfs_mount_t *mp;
2515 int nimap;
2516 uint resblks;
Nathan Scott673cdf52006-09-28 10:56:26 +10002517 uint rounding;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002518 int rt;
2519 xfs_fileoff_t startoffset_fsb;
2520 xfs_trans_t *tp;
Dean Roehrich5fcbab32005-05-05 13:27:19 -07002521 int need_iolock = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002522
Linus Torvalds1da177e2005-04-16 15:20:36 -07002523 mp = ip->i_mount;
2524
Christoph Hellwigcca28fb2010-06-24 11:57:09 +10002525 trace_xfs_free_file_space(ip);
Christoph Hellwigbd5a8762005-06-21 15:47:39 +10002526
Christoph Hellwig7d095252009-06-08 15:33:32 +02002527 error = xfs_qm_dqattach(ip, 0);
2528 if (error)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002529 return error;
2530
2531 error = 0;
2532 if (len <= 0) /* if nothing being freed */
2533 return error;
Eric Sandeen71ddabb2007-11-23 16:29:42 +11002534 rt = XFS_IS_REALTIME_INODE(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002535 startoffset_fsb = XFS_B_TO_FSB(mp, offset);
Christoph Hellwig288699f2010-06-23 18:11:15 +10002536 endoffset_fsb = XFS_B_TO_FSBT(mp, offset + len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002537
Christoph Hellwig0f285c82008-07-18 17:13:28 +10002538 if (attr_flags & XFS_ATTR_NOLOCK)
Dean Roehrich5fcbab32005-05-05 13:27:19 -07002539 need_iolock = 0;
Yingping Lu9fa80462006-03-22 12:44:35 +11002540 if (need_iolock) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002541 xfs_ilock(ip, XFS_IOLOCK_EXCL);
Christoph Hellwig25e41b32008-12-03 12:20:39 +01002542 /* wait for the completion of any pending DIOs */
2543 xfs_ioend_wait(ip);
Yingping Lu9fa80462006-03-22 12:44:35 +11002544 }
Dean Roehrich5fcbab32005-05-05 13:27:19 -07002545
Tim Shimmine6a4b372007-11-23 16:30:42 +11002546 rounding = max_t(uint, 1 << mp->m_sb.sb_blocklog, PAGE_CACHE_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002547 ioffset = offset & ~(rounding - 1);
Christoph Hellwigbd5a8762005-06-21 15:47:39 +10002548
Christoph Hellwigdf80c932008-08-13 16:22:09 +10002549 if (VN_CACHED(VFS_I(ip)) != 0) {
Tim Shimmine6a4b372007-11-23 16:30:42 +11002550 error = xfs_flushinval_pages(ip, ioffset, -1, FI_REMAPF_LOCKED);
Lachlan McIlroyd3cf2092007-05-08 13:49:27 +10002551 if (error)
2552 goto out_unlock_iolock;
Christoph Hellwigbd5a8762005-06-21 15:47:39 +10002553 }
2554
Linus Torvalds1da177e2005-04-16 15:20:36 -07002555 /*
2556 * Need to zero the stuff we're not freeing, on disk.
Malcolm Parsons9da096f2009-03-29 09:55:42 +02002557 * If it's a realtime file & can't use unwritten extents then we
Linus Torvalds1da177e2005-04-16 15:20:36 -07002558 * actually need to zero the extent edges. Otherwise xfs_bunmapi
2559 * will take care of it for us.
2560 */
Eric Sandeen62118702008-03-06 13:44:28 +11002561 if (rt && !xfs_sb_version_hasextflgbit(&mp->m_sb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002562 nimap = 1;
Lachlan McIlroy541d7d32007-10-11 17:34:33 +10002563 error = xfs_bmapi(NULL, ip, startoffset_fsb,
Christoph Hellwigb4e91812010-06-23 18:11:15 +10002564 1, 0, NULL, 0, &imap, &nimap, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002565 if (error)
2566 goto out_unlock_iolock;
2567 ASSERT(nimap == 0 || nimap == 1);
2568 if (nimap && imap.br_startblock != HOLESTARTBLOCK) {
2569 xfs_daddr_t block;
2570
2571 ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
2572 block = imap.br_startblock;
2573 mod = do_div(block, mp->m_sb.sb_rextsize);
2574 if (mod)
2575 startoffset_fsb += mp->m_sb.sb_rextsize - mod;
2576 }
2577 nimap = 1;
Lachlan McIlroy541d7d32007-10-11 17:34:33 +10002578 error = xfs_bmapi(NULL, ip, endoffset_fsb - 1,
Christoph Hellwigb4e91812010-06-23 18:11:15 +10002579 1, 0, NULL, 0, &imap, &nimap, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002580 if (error)
2581 goto out_unlock_iolock;
2582 ASSERT(nimap == 0 || nimap == 1);
2583 if (nimap && imap.br_startblock != HOLESTARTBLOCK) {
2584 ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
2585 mod++;
2586 if (mod && (mod != mp->m_sb.sb_rextsize))
2587 endoffset_fsb -= mod;
2588 }
2589 }
2590 if ((done = (endoffset_fsb <= startoffset_fsb)))
2591 /*
2592 * One contiguous piece to clear
2593 */
2594 error = xfs_zero_remaining_bytes(ip, offset, offset + len - 1);
2595 else {
2596 /*
2597 * Some full blocks, possibly two pieces to clear
2598 */
2599 if (offset < XFS_FSB_TO_B(mp, startoffset_fsb))
2600 error = xfs_zero_remaining_bytes(ip, offset,
2601 XFS_FSB_TO_B(mp, startoffset_fsb) - 1);
2602 if (!error &&
2603 XFS_FSB_TO_B(mp, endoffset_fsb) < offset + len)
2604 error = xfs_zero_remaining_bytes(ip,
2605 XFS_FSB_TO_B(mp, endoffset_fsb),
2606 offset + len - 1);
2607 }
2608
2609 /*
2610 * free file space until done or until there is an error
2611 */
2612 resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
2613 while (!error && !done) {
2614
2615 /*
David Chinner91ebecc2007-07-19 16:28:30 +10002616 * allocate and setup the transaction. Allow this
2617 * transaction to dip into the reserve blocks to ensure
2618 * the freeing of the space succeeds at ENOSPC.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002619 */
2620 tp = xfs_trans_alloc(mp, XFS_TRANS_DIOSTRAT);
David Chinner91ebecc2007-07-19 16:28:30 +10002621 tp->t_flags |= XFS_TRANS_RESERVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002622 error = xfs_trans_reserve(tp,
2623 resblks,
2624 XFS_WRITE_LOG_RES(mp),
2625 0,
2626 XFS_TRANS_PERM_LOG_RES,
2627 XFS_WRITE_LOG_COUNT);
2628
2629 /*
2630 * check for running out of space
2631 */
2632 if (error) {
2633 /*
2634 * Free the transaction structure.
2635 */
2636 ASSERT(error == ENOSPC || XFS_FORCED_SHUTDOWN(mp));
2637 xfs_trans_cancel(tp, 0);
2638 break;
2639 }
2640 xfs_ilock(ip, XFS_ILOCK_EXCL);
Christoph Hellwig7d095252009-06-08 15:33:32 +02002641 error = xfs_trans_reserve_quota(tp, mp,
2642 ip->i_udquot, ip->i_gdquot,
2643 resblks, 0, XFS_QMOPT_RES_REGBLKS);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002644 if (error)
2645 goto error1;
2646
Christoph Hellwig898621d2010-06-24 11:36:58 +10002647 xfs_trans_ijoin(tp, ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002648
2649 /*
2650 * issue the bunmapi() call to free the blocks
2651 */
Eric Sandeen9d87c312009-01-14 23:22:07 -06002652 xfs_bmap_init(&free_list, &firstfsb);
Lachlan McIlroy541d7d32007-10-11 17:34:33 +10002653 error = xfs_bunmapi(tp, ip, startoffset_fsb,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002654 endoffset_fsb - startoffset_fsb,
Christoph Hellwigb4e91812010-06-23 18:11:15 +10002655 0, 2, &firstfsb, &free_list, &done);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002656 if (error) {
2657 goto error0;
2658 }
2659
2660 /*
2661 * complete the transaction
2662 */
Eric Sandeenf7c99b62007-02-10 18:37:16 +11002663 error = xfs_bmap_finish(&tp, &free_list, &committed);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002664 if (error) {
2665 goto error0;
2666 }
2667
Eric Sandeen1c72bf92007-05-08 13:48:42 +10002668 error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002669 xfs_iunlock(ip, XFS_ILOCK_EXCL);
2670 }
2671
2672 out_unlock_iolock:
2673 if (need_iolock)
2674 xfs_iunlock(ip, XFS_IOLOCK_EXCL);
2675 return error;
2676
2677 error0:
2678 xfs_bmap_cancel(&free_list);
2679 error1:
2680 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
2681 xfs_iunlock(ip, need_iolock ? (XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL) :
2682 XFS_ILOCK_EXCL);
2683 return error;
2684}
2685
2686/*
2687 * xfs_change_file_space()
2688 * This routine allocates or frees disk space for the given file.
2689 * The user specified parameters are checked for alignment and size
2690 * limitations.
2691 *
2692 * RETURNS:
2693 * 0 on success
2694 * errno on error
2695 *
2696 */
2697int
2698xfs_change_file_space(
Christoph Hellwig993386c2007-08-28 16:12:30 +10002699 xfs_inode_t *ip,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002700 int cmd,
2701 xfs_flock64_t *bf,
2702 xfs_off_t offset,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002703 int attr_flags)
2704{
Christoph Hellwig993386c2007-08-28 16:12:30 +10002705 xfs_mount_t *mp = ip->i_mount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002706 int clrprealloc;
2707 int error;
2708 xfs_fsize_t fsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002709 int setprealloc;
2710 xfs_off_t startoffset;
2711 xfs_off_t llen;
2712 xfs_trans_t *tp;
Christoph Hellwig0f285c82008-07-18 17:13:28 +10002713 struct iattr iattr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002714
Christoph Hellwig993386c2007-08-28 16:12:30 +10002715 if (!S_ISREG(ip->i_d.di_mode))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002716 return XFS_ERROR(EINVAL);
2717
Linus Torvalds1da177e2005-04-16 15:20:36 -07002718 switch (bf->l_whence) {
2719 case 0: /*SEEK_SET*/
2720 break;
2721 case 1: /*SEEK_CUR*/
2722 bf->l_start += offset;
2723 break;
2724 case 2: /*SEEK_END*/
Lachlan McIlroyba87ea62007-05-08 13:49:46 +10002725 bf->l_start += ip->i_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002726 break;
2727 default:
2728 return XFS_ERROR(EINVAL);
2729 }
2730
2731 llen = bf->l_len > 0 ? bf->l_len - 1 : bf->l_len;
2732
2733 if ( (bf->l_start < 0)
2734 || (bf->l_start > XFS_MAXIOFFSET(mp))
2735 || (bf->l_start + llen < 0)
2736 || (bf->l_start + llen > XFS_MAXIOFFSET(mp)))
2737 return XFS_ERROR(EINVAL);
2738
2739 bf->l_whence = 0;
2740
2741 startoffset = bf->l_start;
Lachlan McIlroyba87ea62007-05-08 13:49:46 +10002742 fsize = ip->i_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002743
2744 /*
2745 * XFS_IOC_RESVSP and XFS_IOC_UNRESVSP will reserve or unreserve
2746 * file space.
2747 * These calls do NOT zero the data space allocated to the file,
2748 * nor do they change the file size.
2749 *
2750 * XFS_IOC_ALLOCSP and XFS_IOC_FREESP will allocate and free file
2751 * space.
2752 * These calls cause the new file data to be zeroed and the file
2753 * size to be changed.
2754 */
2755 setprealloc = clrprealloc = 0;
2756
2757 switch (cmd) {
2758 case XFS_IOC_RESVSP:
2759 case XFS_IOC_RESVSP64:
2760 error = xfs_alloc_file_space(ip, startoffset, bf->l_len,
2761 1, attr_flags);
2762 if (error)
2763 return error;
2764 setprealloc = 1;
2765 break;
2766
2767 case XFS_IOC_UNRESVSP:
2768 case XFS_IOC_UNRESVSP64:
2769 if ((error = xfs_free_file_space(ip, startoffset, bf->l_len,
2770 attr_flags)))
2771 return error;
2772 break;
2773
2774 case XFS_IOC_ALLOCSP:
2775 case XFS_IOC_ALLOCSP64:
2776 case XFS_IOC_FREESP:
2777 case XFS_IOC_FREESP64:
2778 if (startoffset > fsize) {
2779 error = xfs_alloc_file_space(ip, fsize,
2780 startoffset - fsize, 0, attr_flags);
2781 if (error)
2782 break;
2783 }
2784
Christoph Hellwig0f285c82008-07-18 17:13:28 +10002785 iattr.ia_valid = ATTR_SIZE;
2786 iattr.ia_size = startoffset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002787
Christoph Hellwigea5a3dc82008-10-30 18:27:48 +11002788 error = xfs_setattr(ip, &iattr, attr_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002789
2790 if (error)
2791 return error;
2792
2793 clrprealloc = 1;
2794 break;
2795
2796 default:
2797 ASSERT(0);
2798 return XFS_ERROR(EINVAL);
2799 }
2800
2801 /*
2802 * update the inode timestamp, mode, and prealloc flag bits
2803 */
2804 tp = xfs_trans_alloc(mp, XFS_TRANS_WRITEID);
2805
2806 if ((error = xfs_trans_reserve(tp, 0, XFS_WRITEID_LOG_RES(mp),
2807 0, 0, 0))) {
2808 /* ASSERT(0); */
2809 xfs_trans_cancel(tp, 0);
2810 return error;
2811 }
2812
2813 xfs_ilock(ip, XFS_ILOCK_EXCL);
2814
Christoph Hellwig898621d2010-06-24 11:36:58 +10002815 xfs_trans_ijoin(tp, ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002816
Christoph Hellwig0f285c82008-07-18 17:13:28 +10002817 if ((attr_flags & XFS_ATTR_DMI) == 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002818 ip->i_d.di_mode &= ~S_ISUID;
2819
2820 /*
2821 * Note that we don't have to worry about mandatory
2822 * file locking being disabled here because we only
2823 * clear the S_ISGID bit if the Group execute bit is
2824 * on, but if it was on then mandatory locking wouldn't
2825 * have been enabled.
2826 */
2827 if (ip->i_d.di_mode & S_IXGRP)
2828 ip->i_d.di_mode &= ~S_ISGID;
2829
2830 xfs_ichgtime(ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
2831 }
2832 if (setprealloc)
2833 ip->i_d.di_flags |= XFS_DIFLAG_PREALLOC;
2834 else if (clrprealloc)
2835 ip->i_d.di_flags &= ~XFS_DIFLAG_PREALLOC;
2836
2837 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
2838 xfs_trans_set_sync(tp);
2839
Eric Sandeen1c72bf92007-05-08 13:48:42 +10002840 error = xfs_trans_commit(tp, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002841
2842 xfs_iunlock(ip, XFS_ILOCK_EXCL);
2843
2844 return error;
2845}