blob: 4cfc976a90675195a33df6b12df13732c51ad005 [file] [log] [blame]
Mark Fashehccd979b2005-12-15 14:31:24 -08001/* -*- mode: c; c-basic-offset: 8; -*-
2 * vim: noexpandtab sw=8 ts=8 sts=0:
3 *
4 * file.c
5 *
6 * File open, close, extend, truncate
7 *
8 * Copyright (C) 2002, 2004 Oracle. All rights reserved.
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public
12 * License as published by the Free Software Foundation; either
13 * version 2 of the License, or (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public
21 * License along with this program; if not, write to the
22 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
23 * Boston, MA 021110-1307, USA.
24 */
25
Randy Dunlap16f7e0f2006-01-11 12:17:46 -080026#include <linux/capability.h>
Mark Fashehccd979b2005-12-15 14:31:24 -080027#include <linux/fs.h>
28#include <linux/types.h>
29#include <linux/slab.h>
30#include <linux/highmem.h>
31#include <linux/pagemap.h>
32#include <linux/uio.h>
Mark Fashehe2057c52006-10-03 17:53:05 -070033#include <linux/sched.h>
Jens Axboed6b29d72007-06-04 09:59:47 +020034#include <linux/splice.h>
Tiger Yang7f1a37e2006-11-15 15:48:42 +080035#include <linux/mount.h>
Mark Fasheh9517bac2007-02-09 20:24:12 -080036#include <linux/writeback.h>
Mark Fasheh385820a2007-07-19 00:14:38 -070037#include <linux/falloc.h>
Jan Karaa90714c2008-10-09 19:38:40 +020038#include <linux/quotaops.h>
Mark Fashehccd979b2005-12-15 14:31:24 -080039
40#define MLOG_MASK_PREFIX ML_INODE
41#include <cluster/masklog.h>
42
43#include "ocfs2.h"
44
45#include "alloc.h"
46#include "aops.h"
47#include "dir.h"
48#include "dlmglue.h"
49#include "extent_map.h"
50#include "file.h"
51#include "sysfile.h"
52#include "inode.h"
Herbert Poetzlca4d1472006-07-03 17:27:12 -070053#include "ioctl.h"
Mark Fashehccd979b2005-12-15 14:31:24 -080054#include "journal.h"
Mark Fasheh53fc6222007-12-20 16:49:04 -080055#include "locks.h"
Mark Fashehccd979b2005-12-15 14:31:24 -080056#include "mmap.h"
57#include "suballoc.h"
58#include "super.h"
Tiger Yangcf1d6c72008-08-18 17:11:00 +080059#include "xattr.h"
Tiger Yang23fc2702008-11-14 11:17:18 +080060#include "acl.h"
Jan Karaa90714c2008-10-09 19:38:40 +020061#include "quota.h"
Tao Ma293b2f72009-08-25 08:02:48 +080062#include "refcounttree.h"
Mark Fashehccd979b2005-12-15 14:31:24 -080063
64#include "buffer_head_io.h"
65
66static int ocfs2_sync_inode(struct inode *inode)
67{
68 filemap_fdatawrite(inode->i_mapping);
69 return sync_mapping_buffers(inode->i_mapping);
70}
71
Mark Fasheh53fc6222007-12-20 16:49:04 -080072static int ocfs2_init_file_private(struct inode *inode, struct file *file)
73{
74 struct ocfs2_file_private *fp;
75
76 fp = kzalloc(sizeof(struct ocfs2_file_private), GFP_KERNEL);
77 if (!fp)
78 return -ENOMEM;
79
80 fp->fp_file = file;
81 mutex_init(&fp->fp_mutex);
82 ocfs2_file_lock_res_init(&fp->fp_flock, fp);
83 file->private_data = fp;
84
85 return 0;
86}
87
88static void ocfs2_free_file_private(struct inode *inode, struct file *file)
89{
90 struct ocfs2_file_private *fp = file->private_data;
91 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
92
93 if (fp) {
94 ocfs2_simple_drop_lockres(osb, &fp->fp_flock);
95 ocfs2_lock_res_free(&fp->fp_flock);
96 kfree(fp);
97 file->private_data = NULL;
98 }
99}
100
Mark Fashehccd979b2005-12-15 14:31:24 -0800101static int ocfs2_file_open(struct inode *inode, struct file *file)
102{
103 int status;
104 int mode = file->f_flags;
105 struct ocfs2_inode_info *oi = OCFS2_I(inode);
106
107 mlog_entry("(0x%p, 0x%p, '%.*s')\n", inode, file,
Josef Sipekd28c9172006-12-08 02:37:25 -0800108 file->f_path.dentry->d_name.len, file->f_path.dentry->d_name.name);
Mark Fashehccd979b2005-12-15 14:31:24 -0800109
Christoph Hellwig907f4552010-03-03 09:05:06 -0500110 if (file->f_mode & FMODE_WRITE)
Christoph Hellwig871a2932010-03-03 09:05:07 -0500111 dquot_initialize(inode);
Christoph Hellwig907f4552010-03-03 09:05:06 -0500112
Mark Fashehccd979b2005-12-15 14:31:24 -0800113 spin_lock(&oi->ip_lock);
114
115 /* Check that the inode hasn't been wiped from disk by another
116 * node. If it hasn't then we're safe as long as we hold the
117 * spin lock until our increment of open count. */
118 if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_DELETED) {
119 spin_unlock(&oi->ip_lock);
120
121 status = -ENOENT;
122 goto leave;
123 }
124
125 if (mode & O_DIRECT)
126 oi->ip_flags |= OCFS2_INODE_OPEN_DIRECT;
127
128 oi->ip_open_count++;
129 spin_unlock(&oi->ip_lock);
Mark Fasheh53fc6222007-12-20 16:49:04 -0800130
131 status = ocfs2_init_file_private(inode, file);
132 if (status) {
133 /*
134 * We want to set open count back if we're failing the
135 * open.
136 */
137 spin_lock(&oi->ip_lock);
138 oi->ip_open_count--;
139 spin_unlock(&oi->ip_lock);
140 }
141
Mark Fashehccd979b2005-12-15 14:31:24 -0800142leave:
143 mlog_exit(status);
144 return status;
145}
146
147static int ocfs2_file_release(struct inode *inode, struct file *file)
148{
149 struct ocfs2_inode_info *oi = OCFS2_I(inode);
150
151 mlog_entry("(0x%p, 0x%p, '%.*s')\n", inode, file,
Josef Sipekd28c9172006-12-08 02:37:25 -0800152 file->f_path.dentry->d_name.len,
153 file->f_path.dentry->d_name.name);
Mark Fashehccd979b2005-12-15 14:31:24 -0800154
155 spin_lock(&oi->ip_lock);
156 if (!--oi->ip_open_count)
157 oi->ip_flags &= ~OCFS2_INODE_OPEN_DIRECT;
158 spin_unlock(&oi->ip_lock);
159
Mark Fasheh53fc6222007-12-20 16:49:04 -0800160 ocfs2_free_file_private(inode, file);
161
Mark Fashehccd979b2005-12-15 14:31:24 -0800162 mlog_exit(0);
163
164 return 0;
165}
166
Mark Fasheh53fc6222007-12-20 16:49:04 -0800167static int ocfs2_dir_open(struct inode *inode, struct file *file)
168{
169 return ocfs2_init_file_private(inode, file);
170}
171
172static int ocfs2_dir_release(struct inode *inode, struct file *file)
173{
174 ocfs2_free_file_private(inode, file);
175 return 0;
176}
177
Christoph Hellwig7ea80852010-05-26 17:53:25 +0200178static int ocfs2_sync_file(struct file *file, int datasync)
Mark Fashehccd979b2005-12-15 14:31:24 -0800179{
180 int err = 0;
181 journal_t *journal;
Christoph Hellwig7ea80852010-05-26 17:53:25 +0200182 struct dentry *dentry = file->f_path.dentry;
183 struct inode *inode = file->f_mapping->host;
Mark Fashehccd979b2005-12-15 14:31:24 -0800184 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
185
186 mlog_entry("(0x%p, 0x%p, %d, '%.*s')\n", file, dentry, datasync,
187 dentry->d_name.len, dentry->d_name.name);
188
189 err = ocfs2_sync_inode(dentry->d_inode);
190 if (err)
191 goto bail;
192
Hisashi Hifumie04cc152009-06-09 16:47:45 +0900193 if (datasync && !(inode->i_state & I_DIRTY_DATASYNC))
194 goto bail;
195
Mark Fashehccd979b2005-12-15 14:31:24 -0800196 journal = osb->journal->j_journal;
Joel Becker2b4e30f2008-09-03 20:03:41 -0700197 err = jbd2_journal_force_commit(journal);
Mark Fashehccd979b2005-12-15 14:31:24 -0800198
199bail:
200 mlog_exit(err);
201
202 return (err < 0) ? -EIO : 0;
203}
204
Tiger Yang7f1a37e2006-11-15 15:48:42 +0800205int ocfs2_should_update_atime(struct inode *inode,
206 struct vfsmount *vfsmnt)
207{
208 struct timespec now;
209 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
210
211 if (ocfs2_is_hard_readonly(osb) || ocfs2_is_soft_readonly(osb))
212 return 0;
213
214 if ((inode->i_flags & S_NOATIME) ||
215 ((inode->i_sb->s_flags & MS_NODIRATIME) && S_ISDIR(inode->i_mode)))
216 return 0;
217
Mark Fasheh6c2aad02006-12-19 15:25:52 -0800218 /*
219 * We can be called with no vfsmnt structure - NFSD will
220 * sometimes do this.
221 *
222 * Note that our action here is different than touch_atime() -
223 * if we can't tell whether this is a noatime mount, then we
224 * don't know whether to trust the value of s_atime_quantum.
225 */
226 if (vfsmnt == NULL)
227 return 0;
228
Tiger Yang7f1a37e2006-11-15 15:48:42 +0800229 if ((vfsmnt->mnt_flags & MNT_NOATIME) ||
230 ((vfsmnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)))
231 return 0;
232
Mark Fasheh7e913c52006-12-13 00:34:35 -0800233 if (vfsmnt->mnt_flags & MNT_RELATIME) {
234 if ((timespec_compare(&inode->i_atime, &inode->i_mtime) <= 0) ||
235 (timespec_compare(&inode->i_atime, &inode->i_ctime) <= 0))
236 return 1;
237
238 return 0;
239 }
240
Tiger Yang7f1a37e2006-11-15 15:48:42 +0800241 now = CURRENT_TIME;
242 if ((now.tv_sec - inode->i_atime.tv_sec <= osb->s_atime_quantum))
243 return 0;
244 else
245 return 1;
246}
247
248int ocfs2_update_inode_atime(struct inode *inode,
249 struct buffer_head *bh)
250{
251 int ret;
252 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
253 handle_t *handle;
Mark Fashehc11e9fa2007-07-20 11:24:53 -0700254 struct ocfs2_dinode *di = (struct ocfs2_dinode *) bh->b_data;
Tiger Yang7f1a37e2006-11-15 15:48:42 +0800255
256 mlog_entry_void();
257
258 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
Jan Karafa38e922008-10-20 19:23:51 +0200259 if (IS_ERR(handle)) {
260 ret = PTR_ERR(handle);
Tiger Yang7f1a37e2006-11-15 15:48:42 +0800261 mlog_errno(ret);
262 goto out;
263 }
264
Joel Becker0cf2f762009-02-12 16:41:25 -0800265 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), bh,
Joel Becker13723d02008-10-17 19:25:01 -0700266 OCFS2_JOURNAL_ACCESS_WRITE);
Mark Fashehc11e9fa2007-07-20 11:24:53 -0700267 if (ret) {
268 mlog_errno(ret);
269 goto out_commit;
270 }
271
272 /*
273 * Don't use ocfs2_mark_inode_dirty() here as we don't always
274 * have i_mutex to guard against concurrent changes to other
275 * inode fields.
276 */
Tiger Yang7f1a37e2006-11-15 15:48:42 +0800277 inode->i_atime = CURRENT_TIME;
Mark Fashehc11e9fa2007-07-20 11:24:53 -0700278 di->i_atime = cpu_to_le64(inode->i_atime.tv_sec);
279 di->i_atime_nsec = cpu_to_le32(inode->i_atime.tv_nsec);
Joel Beckerec20cec2010-03-19 14:13:52 -0700280 ocfs2_journal_dirty(handle, bh);
Tiger Yang7f1a37e2006-11-15 15:48:42 +0800281
Mark Fashehc11e9fa2007-07-20 11:24:53 -0700282out_commit:
Tiger Yang7f1a37e2006-11-15 15:48:42 +0800283 ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
284out:
285 mlog_exit(ret);
286 return ret;
287}
288
Adrian Bunk6cb129f2007-04-26 00:29:35 -0700289static int ocfs2_set_inode_size(handle_t *handle,
290 struct inode *inode,
291 struct buffer_head *fe_bh,
292 u64 new_i_size)
Mark Fashehccd979b2005-12-15 14:31:24 -0800293{
294 int status;
295
296 mlog_entry_void();
297 i_size_write(inode, new_i_size);
Mark Fasheh8110b072007-03-22 16:53:23 -0700298 inode->i_blocks = ocfs2_inode_sector_count(inode);
Mark Fashehccd979b2005-12-15 14:31:24 -0800299 inode->i_ctime = inode->i_mtime = CURRENT_TIME;
300
301 status = ocfs2_mark_inode_dirty(handle, inode, fe_bh);
302 if (status < 0) {
303 mlog_errno(status);
304 goto bail;
305 }
306
307bail:
308 mlog_exit(status);
309 return status;
310}
311
Jan Kara9e33d692008-08-25 19:56:50 +0200312int ocfs2_simple_size_update(struct inode *inode,
313 struct buffer_head *di_bh,
314 u64 new_i_size)
Mark Fashehccd979b2005-12-15 14:31:24 -0800315{
316 int ret;
317 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
Mark Fasheh1fabe142006-10-09 18:11:45 -0700318 handle_t *handle = NULL;
Mark Fashehccd979b2005-12-15 14:31:24 -0800319
Mark Fasheh65eff9c2006-10-09 17:26:22 -0700320 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
Jan Karafa38e922008-10-20 19:23:51 +0200321 if (IS_ERR(handle)) {
322 ret = PTR_ERR(handle);
Mark Fashehccd979b2005-12-15 14:31:24 -0800323 mlog_errno(ret);
324 goto out;
325 }
326
327 ret = ocfs2_set_inode_size(handle, inode, di_bh,
328 new_i_size);
329 if (ret < 0)
330 mlog_errno(ret);
331
Mark Fasheh02dc1af2006-10-09 16:48:10 -0700332 ocfs2_commit_trans(osb, handle);
Mark Fashehccd979b2005-12-15 14:31:24 -0800333out:
334 return ret;
335}
336
Tao Ma37f8a2b2009-08-26 09:47:28 +0800337static int ocfs2_cow_file_pos(struct inode *inode,
338 struct buffer_head *fe_bh,
339 u64 offset)
340{
341 int status;
342 u32 phys, cpos = offset >> OCFS2_SB(inode->i_sb)->s_clustersize_bits;
343 unsigned int num_clusters = 0;
344 unsigned int ext_flags = 0;
345
346 /*
347 * If the new offset is aligned to the range of the cluster, there is
348 * no space for ocfs2_zero_range_for_truncate to fill, so no need to
349 * CoW either.
350 */
351 if ((offset & (OCFS2_SB(inode->i_sb)->s_clustersize - 1)) == 0)
352 return 0;
353
354 status = ocfs2_get_clusters(inode, cpos, &phys,
355 &num_clusters, &ext_flags);
356 if (status) {
357 mlog_errno(status);
358 goto out;
359 }
360
361 if (!(ext_flags & OCFS2_EXT_REFCOUNTED))
362 goto out;
363
364 return ocfs2_refcount_cow(inode, fe_bh, cpos, 1, cpos+1);
365
366out:
367 return status;
368}
369
Mark Fashehccd979b2005-12-15 14:31:24 -0800370static int ocfs2_orphan_for_truncate(struct ocfs2_super *osb,
371 struct inode *inode,
372 struct buffer_head *fe_bh,
373 u64 new_i_size)
374{
375 int status;
Mark Fasheh1fabe142006-10-09 18:11:45 -0700376 handle_t *handle;
Mark Fasheh60b11392007-02-16 11:46:50 -0800377 struct ocfs2_dinode *di;
Mark Fasheh35edec12007-07-06 14:41:18 -0700378 u64 cluster_bytes;
Mark Fashehccd979b2005-12-15 14:31:24 -0800379
380 mlog_entry_void();
381
Tao Ma37f8a2b2009-08-26 09:47:28 +0800382 /*
383 * We need to CoW the cluster contains the offset if it is reflinked
384 * since we will call ocfs2_zero_range_for_truncate later which will
385 * write "0" from offset to the end of the cluster.
386 */
387 status = ocfs2_cow_file_pos(inode, fe_bh, new_i_size);
388 if (status) {
389 mlog_errno(status);
390 return status;
391 }
392
Mark Fashehccd979b2005-12-15 14:31:24 -0800393 /* TODO: This needs to actually orphan the inode in this
394 * transaction. */
395
Mark Fasheh65eff9c2006-10-09 17:26:22 -0700396 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
Mark Fashehccd979b2005-12-15 14:31:24 -0800397 if (IS_ERR(handle)) {
398 status = PTR_ERR(handle);
399 mlog_errno(status);
400 goto out;
401 }
402
Joel Becker0cf2f762009-02-12 16:41:25 -0800403 status = ocfs2_journal_access_di(handle, INODE_CACHE(inode), fe_bh,
Joel Becker13723d02008-10-17 19:25:01 -0700404 OCFS2_JOURNAL_ACCESS_WRITE);
Mark Fasheh60b11392007-02-16 11:46:50 -0800405 if (status < 0) {
406 mlog_errno(status);
407 goto out_commit;
408 }
409
410 /*
411 * Do this before setting i_size.
412 */
Mark Fasheh35edec12007-07-06 14:41:18 -0700413 cluster_bytes = ocfs2_align_bytes_to_clusters(inode->i_sb, new_i_size);
414 status = ocfs2_zero_range_for_truncate(inode, handle, new_i_size,
415 cluster_bytes);
Mark Fasheh60b11392007-02-16 11:46:50 -0800416 if (status) {
417 mlog_errno(status);
418 goto out_commit;
419 }
420
421 i_size_write(inode, new_i_size);
Mark Fasheh60b11392007-02-16 11:46:50 -0800422 inode->i_ctime = inode->i_mtime = CURRENT_TIME;
423
424 di = (struct ocfs2_dinode *) fe_bh->b_data;
425 di->i_size = cpu_to_le64(new_i_size);
426 di->i_ctime = di->i_mtime = cpu_to_le64(inode->i_ctime.tv_sec);
427 di->i_ctime_nsec = di->i_mtime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
428
Joel Beckerec20cec2010-03-19 14:13:52 -0700429 ocfs2_journal_dirty(handle, fe_bh);
Mark Fashehccd979b2005-12-15 14:31:24 -0800430
Mark Fasheh60b11392007-02-16 11:46:50 -0800431out_commit:
Mark Fasheh02dc1af2006-10-09 16:48:10 -0700432 ocfs2_commit_trans(osb, handle);
Mark Fashehccd979b2005-12-15 14:31:24 -0800433out:
Mark Fasheh60b11392007-02-16 11:46:50 -0800434
Mark Fashehccd979b2005-12-15 14:31:24 -0800435 mlog_exit(status);
436 return status;
437}
438
439static int ocfs2_truncate_file(struct inode *inode,
440 struct buffer_head *di_bh,
441 u64 new_i_size)
442{
443 int status = 0;
444 struct ocfs2_dinode *fe = NULL;
445 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
Mark Fashehccd979b2005-12-15 14:31:24 -0800446
Mark Fashehb06970532006-03-03 10:24:33 -0800447 mlog_entry("(inode = %llu, new_i_size = %llu\n",
448 (unsigned long long)OCFS2_I(inode)->ip_blkno,
449 (unsigned long long)new_i_size);
Mark Fashehccd979b2005-12-15 14:31:24 -0800450
Joel Beckerb657c952008-11-13 14:49:11 -0800451 /* We trust di_bh because it comes from ocfs2_inode_lock(), which
452 * already validated it */
Mark Fashehccd979b2005-12-15 14:31:24 -0800453 fe = (struct ocfs2_dinode *) di_bh->b_data;
Mark Fashehccd979b2005-12-15 14:31:24 -0800454
455 mlog_bug_on_msg(le64_to_cpu(fe->i_size) != i_size_read(inode),
Mark Fashehb06970532006-03-03 10:24:33 -0800456 "Inode %llu, inode i_size = %lld != di "
457 "i_size = %llu, i_flags = 0x%x\n",
458 (unsigned long long)OCFS2_I(inode)->ip_blkno,
Mark Fashehccd979b2005-12-15 14:31:24 -0800459 i_size_read(inode),
Mark Fashehb06970532006-03-03 10:24:33 -0800460 (unsigned long long)le64_to_cpu(fe->i_size),
461 le32_to_cpu(fe->i_flags));
Mark Fashehccd979b2005-12-15 14:31:24 -0800462
463 if (new_i_size > le64_to_cpu(fe->i_size)) {
Mark Fashehb06970532006-03-03 10:24:33 -0800464 mlog(0, "asked to truncate file with size (%llu) to size (%llu)!\n",
465 (unsigned long long)le64_to_cpu(fe->i_size),
466 (unsigned long long)new_i_size);
Mark Fashehccd979b2005-12-15 14:31:24 -0800467 status = -EINVAL;
468 mlog_errno(status);
469 goto bail;
470 }
471
Mark Fashehb06970532006-03-03 10:24:33 -0800472 mlog(0, "inode %llu, i_size = %llu, new_i_size = %llu\n",
473 (unsigned long long)le64_to_cpu(fe->i_blkno),
474 (unsigned long long)le64_to_cpu(fe->i_size),
475 (unsigned long long)new_i_size);
Mark Fashehccd979b2005-12-15 14:31:24 -0800476
477 /* lets handle the simple truncate cases before doing any more
478 * cluster locking. */
479 if (new_i_size == le64_to_cpu(fe->i_size))
480 goto bail;
481
Mark Fasheh2e89b2e2007-05-09 13:40:18 -0700482 down_write(&OCFS2_I(inode)->ip_alloc_sem);
483
Mark Fasheh4fe370a2009-12-07 13:15:40 -0800484 ocfs2_resv_discard(&osb->osb_la_resmap,
485 &OCFS2_I(inode)->ip_la_data_resv);
486
Mark Fashehc934a922007-10-18 15:23:46 -0700487 /*
488 * The inode lock forced other nodes to sync and drop their
489 * pages, which (correctly) happens even if we have a truncate
490 * without allocation change - ocfs2 cluster sizes can be much
491 * greater than page size, so we have to truncate them
492 * anyway.
493 */
Mark Fasheh2e89b2e2007-05-09 13:40:18 -0700494 unmap_mapping_range(inode->i_mapping, new_i_size + PAGE_SIZE - 1, 0, 1);
495 truncate_inode_pages(inode->i_mapping, new_i_size);
496
Mark Fasheh1afc32b2007-09-07 14:46:51 -0700497 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
498 status = ocfs2_truncate_inline(inode, di_bh, new_i_size,
Mark Fashehb1967d02007-11-20 11:56:39 -0800499 i_size_read(inode), 1);
Mark Fasheh1afc32b2007-09-07 14:46:51 -0700500 if (status)
501 mlog_errno(status);
502
Mark Fashehc934a922007-10-18 15:23:46 -0700503 goto bail_unlock_sem;
Mark Fasheh1afc32b2007-09-07 14:46:51 -0700504 }
505
Mark Fashehccd979b2005-12-15 14:31:24 -0800506 /* alright, we're going to need to do a full blown alloc size
507 * change. Orphan the inode so that recovery can complete the
508 * truncate if necessary. This does the task of marking
509 * i_size. */
510 status = ocfs2_orphan_for_truncate(osb, inode, di_bh, new_i_size);
511 if (status < 0) {
512 mlog_errno(status);
Mark Fashehc934a922007-10-18 15:23:46 -0700513 goto bail_unlock_sem;
Mark Fashehccd979b2005-12-15 14:31:24 -0800514 }
515
Tristan Ye78f94672010-05-11 17:54:42 +0800516 status = ocfs2_commit_truncate(osb, inode, di_bh);
Mark Fashehccd979b2005-12-15 14:31:24 -0800517 if (status < 0) {
518 mlog_errno(status);
Mark Fashehc934a922007-10-18 15:23:46 -0700519 goto bail_unlock_sem;
Mark Fashehccd979b2005-12-15 14:31:24 -0800520 }
521
522 /* TODO: orphan dir cleanup here. */
Mark Fashehc934a922007-10-18 15:23:46 -0700523bail_unlock_sem:
Mark Fasheh2e89b2e2007-05-09 13:40:18 -0700524 up_write(&OCFS2_I(inode)->ip_alloc_sem);
525
Mark Fashehccd979b2005-12-15 14:31:24 -0800526bail:
Tao Ma8b2c0db2009-08-18 11:43:49 +0800527 if (!status && OCFS2_I(inode)->ip_clusters == 0)
528 status = ocfs2_try_remove_refcount_tree(inode, di_bh);
Mark Fashehccd979b2005-12-15 14:31:24 -0800529
530 mlog_exit(status);
531 return status;
532}
533
534/*
Tao Ma0eb8d472008-08-18 17:38:45 +0800535 * extend file allocation only here.
Mark Fashehccd979b2005-12-15 14:31:24 -0800536 * we'll update all the disk stuff, and oip->alloc_size
537 *
538 * expect stuff to be locked, a transaction started and enough data /
539 * metadata reservations in the contexts.
540 *
541 * Will return -EAGAIN, and a reason if a restart is needed.
542 * If passed in, *reason will always be set, even in error.
543 */
Tao Ma0eb8d472008-08-18 17:38:45 +0800544int ocfs2_add_inode_data(struct ocfs2_super *osb,
545 struct inode *inode,
546 u32 *logical_offset,
547 u32 clusters_to_add,
548 int mark_unwritten,
549 struct buffer_head *fe_bh,
550 handle_t *handle,
551 struct ocfs2_alloc_context *data_ac,
552 struct ocfs2_alloc_context *meta_ac,
553 enum ocfs2_alloc_restarted *reason_ret)
Mark Fashehccd979b2005-12-15 14:31:24 -0800554{
Joel Beckerf99b9b72008-08-20 19:36:33 -0700555 int ret;
556 struct ocfs2_extent_tree et;
Mark Fashehccd979b2005-12-15 14:31:24 -0800557
Joel Becker5e404e92009-02-13 03:54:22 -0800558 ocfs2_init_dinode_extent_tree(&et, INODE_CACHE(inode), fe_bh);
Joel Beckercbee7e12009-02-13 03:34:15 -0800559 ret = ocfs2_add_clusters_in_btree(handle, &et, logical_offset,
560 clusters_to_add, mark_unwritten,
561 data_ac, meta_ac, reason_ret);
Joel Beckerf99b9b72008-08-20 19:36:33 -0700562
563 return ret;
Mark Fashehccd979b2005-12-15 14:31:24 -0800564}
565
Mark Fasheh2ae99a62007-03-09 16:43:28 -0800566static int __ocfs2_extend_allocation(struct inode *inode, u32 logical_start,
567 u32 clusters_to_add, int mark_unwritten)
Mark Fashehccd979b2005-12-15 14:31:24 -0800568{
569 int status = 0;
570 int restart_func = 0;
Mark Fashehabf8b152007-01-17 13:07:24 -0800571 int credits;
Mark Fasheh2ae99a62007-03-09 16:43:28 -0800572 u32 prev_clusters;
Mark Fashehccd979b2005-12-15 14:31:24 -0800573 struct buffer_head *bh = NULL;
574 struct ocfs2_dinode *fe = NULL;
Mark Fasheh1fabe142006-10-09 18:11:45 -0700575 handle_t *handle = NULL;
Mark Fashehccd979b2005-12-15 14:31:24 -0800576 struct ocfs2_alloc_context *data_ac = NULL;
577 struct ocfs2_alloc_context *meta_ac = NULL;
578 enum ocfs2_alloc_restarted why;
579 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
Joel Beckerf99b9b72008-08-20 19:36:33 -0700580 struct ocfs2_extent_tree et;
Jan Karaa90714c2008-10-09 19:38:40 +0200581 int did_quota = 0;
Mark Fashehccd979b2005-12-15 14:31:24 -0800582
583 mlog_entry("(clusters_to_add = %u)\n", clusters_to_add);
584
Mark Fashehdcd05382007-01-16 11:32:23 -0800585 /*
586 * This function only exists for file systems which don't
587 * support holes.
588 */
Mark Fasheh2ae99a62007-03-09 16:43:28 -0800589 BUG_ON(mark_unwritten && !ocfs2_sparse_alloc(osb));
Mark Fashehdcd05382007-01-16 11:32:23 -0800590
Joel Beckerb657c952008-11-13 14:49:11 -0800591 status = ocfs2_read_inode_block(inode, &bh);
Mark Fashehccd979b2005-12-15 14:31:24 -0800592 if (status < 0) {
593 mlog_errno(status);
594 goto leave;
595 }
Mark Fashehccd979b2005-12-15 14:31:24 -0800596 fe = (struct ocfs2_dinode *) bh->b_data;
Mark Fashehccd979b2005-12-15 14:31:24 -0800597
598restart_all:
599 BUG_ON(le32_to_cpu(fe->i_clusters) != OCFS2_I(inode)->ip_clusters);
600
Tao Mae7d4cb62008-08-18 17:38:44 +0800601 mlog(0, "extend inode %llu, i_size = %lld, di->i_clusters = %u, "
602 "clusters_to_add = %u\n",
603 (unsigned long long)OCFS2_I(inode)->ip_blkno,
604 (long long)i_size_read(inode), le32_to_cpu(fe->i_clusters),
605 clusters_to_add);
Joel Becker5e404e92009-02-13 03:54:22 -0800606 ocfs2_init_dinode_extent_tree(&et, INODE_CACHE(inode), bh);
Joel Beckerf99b9b72008-08-20 19:36:33 -0700607 status = ocfs2_lock_allocators(inode, &et, clusters_to_add, 0,
608 &data_ac, &meta_ac);
Mark Fasheh9517bac2007-02-09 20:24:12 -0800609 if (status) {
610 mlog_errno(status);
611 goto leave;
612 }
613
Tao Ma811f9332008-08-18 17:38:43 +0800614 credits = ocfs2_calc_extend_credits(osb->sb, &fe->id2.i_list,
615 clusters_to_add);
Mark Fasheh65eff9c2006-10-09 17:26:22 -0700616 handle = ocfs2_start_trans(osb, credits);
Mark Fashehccd979b2005-12-15 14:31:24 -0800617 if (IS_ERR(handle)) {
618 status = PTR_ERR(handle);
619 handle = NULL;
620 mlog_errno(status);
621 goto leave;
622 }
623
624restarted_transaction:
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500625 status = dquot_alloc_space_nodirty(inode,
626 ocfs2_clusters_to_bytes(osb->sb, clusters_to_add));
627 if (status)
Jan Karaa90714c2008-10-09 19:38:40 +0200628 goto leave;
Jan Karaa90714c2008-10-09 19:38:40 +0200629 did_quota = 1;
630
Mark Fashehccd979b2005-12-15 14:31:24 -0800631 /* reserve a write to the file entry early on - that we if we
632 * run out of credits in the allocation path, we can still
633 * update i_size. */
Joel Becker0cf2f762009-02-12 16:41:25 -0800634 status = ocfs2_journal_access_di(handle, INODE_CACHE(inode), bh,
Joel Becker13723d02008-10-17 19:25:01 -0700635 OCFS2_JOURNAL_ACCESS_WRITE);
Mark Fashehccd979b2005-12-15 14:31:24 -0800636 if (status < 0) {
637 mlog_errno(status);
638 goto leave;
639 }
640
641 prev_clusters = OCFS2_I(inode)->ip_clusters;
642
Tao Ma0eb8d472008-08-18 17:38:45 +0800643 status = ocfs2_add_inode_data(osb,
644 inode,
645 &logical_start,
646 clusters_to_add,
647 mark_unwritten,
648 bh,
649 handle,
650 data_ac,
651 meta_ac,
652 &why);
Mark Fashehccd979b2005-12-15 14:31:24 -0800653 if ((status < 0) && (status != -EAGAIN)) {
654 if (status != -ENOSPC)
655 mlog_errno(status);
656 goto leave;
657 }
658
Joel Beckerec20cec2010-03-19 14:13:52 -0700659 ocfs2_journal_dirty(handle, bh);
Mark Fashehccd979b2005-12-15 14:31:24 -0800660
661 spin_lock(&OCFS2_I(inode)->ip_lock);
662 clusters_to_add -= (OCFS2_I(inode)->ip_clusters - prev_clusters);
663 spin_unlock(&OCFS2_I(inode)->ip_lock);
Jan Karaa90714c2008-10-09 19:38:40 +0200664 /* Release unused quota reservation */
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500665 dquot_free_space(inode,
Jan Karaa90714c2008-10-09 19:38:40 +0200666 ocfs2_clusters_to_bytes(osb->sb, clusters_to_add));
667 did_quota = 0;
Mark Fashehccd979b2005-12-15 14:31:24 -0800668
669 if (why != RESTART_NONE && clusters_to_add) {
670 if (why == RESTART_META) {
671 mlog(0, "restarting function.\n");
672 restart_func = 1;
Tao Ma79681842010-04-16 13:59:25 +0800673 status = 0;
Mark Fashehccd979b2005-12-15 14:31:24 -0800674 } else {
675 BUG_ON(why != RESTART_TRANS);
676
677 mlog(0, "restarting transaction.\n");
678 /* TODO: This can be more intelligent. */
679 credits = ocfs2_calc_extend_credits(osb->sb,
Tao Ma811f9332008-08-18 17:38:43 +0800680 &fe->id2.i_list,
Mark Fashehccd979b2005-12-15 14:31:24 -0800681 clusters_to_add);
Mark Fasheh1fabe142006-10-09 18:11:45 -0700682 status = ocfs2_extend_trans(handle, credits);
Mark Fashehccd979b2005-12-15 14:31:24 -0800683 if (status < 0) {
684 /* handle still has to be committed at
685 * this point. */
686 status = -ENOMEM;
687 mlog_errno(status);
688 goto leave;
689 }
690 goto restarted_transaction;
691 }
692 }
693
Mark Fashehb06970532006-03-03 10:24:33 -0800694 mlog(0, "fe: i_clusters = %u, i_size=%llu\n",
Mark Fasheh1ca1a112007-04-27 16:01:25 -0700695 le32_to_cpu(fe->i_clusters),
696 (unsigned long long)le64_to_cpu(fe->i_size));
Mark Fashehccd979b2005-12-15 14:31:24 -0800697 mlog(0, "inode: ip_clusters=%u, i_size=%lld\n",
Jan Kara634bf742007-12-19 15:25:42 +0100698 OCFS2_I(inode)->ip_clusters, (long long)i_size_read(inode));
Mark Fashehccd979b2005-12-15 14:31:24 -0800699
700leave:
Jan Karaa90714c2008-10-09 19:38:40 +0200701 if (status < 0 && did_quota)
Christoph Hellwig5dd40562010-03-03 09:05:00 -0500702 dquot_free_space(inode,
Jan Karaa90714c2008-10-09 19:38:40 +0200703 ocfs2_clusters_to_bytes(osb->sb, clusters_to_add));
Mark Fashehccd979b2005-12-15 14:31:24 -0800704 if (handle) {
Mark Fasheh02dc1af2006-10-09 16:48:10 -0700705 ocfs2_commit_trans(osb, handle);
Mark Fashehccd979b2005-12-15 14:31:24 -0800706 handle = NULL;
707 }
708 if (data_ac) {
709 ocfs2_free_alloc_context(data_ac);
710 data_ac = NULL;
711 }
712 if (meta_ac) {
713 ocfs2_free_alloc_context(meta_ac);
714 meta_ac = NULL;
715 }
716 if ((!status) && restart_func) {
717 restart_func = 0;
718 goto restart_all;
719 }
Mark Fasheha81cb882008-10-07 14:25:16 -0700720 brelse(bh);
721 bh = NULL;
Mark Fashehccd979b2005-12-15 14:31:24 -0800722
723 mlog_exit(status);
724 return status;
725}
726
Joel Beckera4bfb4c2010-07-06 14:36:06 -0700727/*
728 * While a write will already be ordering the data, a truncate will not.
729 * Thus, we need to explicitly order the zeroed pages.
730 */
731static handle_t *ocfs2_zero_start_ordered_transaction(struct inode *inode)
732{
733 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
734 handle_t *handle = NULL;
735 int ret = 0;
736
737 if (!ocfs2_should_order_data(inode))
738 goto out;
739
740 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
741 if (IS_ERR(handle)) {
742 ret = -ENOMEM;
743 mlog_errno(ret);
744 goto out;
745 }
746
747 ret = ocfs2_jbd2_file_inode(handle, inode);
748 if (ret < 0)
749 mlog_errno(ret);
750
751out:
752 if (ret) {
753 if (!IS_ERR(handle))
754 ocfs2_commit_trans(osb, handle);
755 handle = ERR_PTR(ret);
756 }
757 return handle;
758}
759
Mark Fashehccd979b2005-12-15 14:31:24 -0800760/* Some parts of this taken from generic_cont_expand, which turned out
761 * to be too fragile to do exactly what we need without us having to
Nick Piggin4e02ed42008-10-29 14:00:55 -0700762 * worry about recursive locking in ->write_begin() and ->write_end(). */
Joel Beckera4bfb4c2010-07-06 14:36:06 -0700763static int ocfs2_write_zero_page(struct inode *inode, u64 abs_from,
764 u64 abs_to)
Mark Fashehccd979b2005-12-15 14:31:24 -0800765{
766 struct address_space *mapping = inode->i_mapping;
767 struct page *page;
Joel Beckera4bfb4c2010-07-06 14:36:06 -0700768 unsigned long index = abs_from >> PAGE_CACHE_SHIFT;
Mark Fasheh1fabe142006-10-09 18:11:45 -0700769 handle_t *handle = NULL;
Mark Fashehccd979b2005-12-15 14:31:24 -0800770 int ret;
Joel Beckera4bfb4c2010-07-06 14:36:06 -0700771 unsigned zero_from, zero_to, block_start, block_end;
Mark Fashehccd979b2005-12-15 14:31:24 -0800772
Joel Beckera4bfb4c2010-07-06 14:36:06 -0700773 BUG_ON(abs_from >= abs_to);
774 BUG_ON(abs_to > (((u64)index + 1) << PAGE_CACHE_SHIFT));
775 BUG_ON(abs_from & (inode->i_blkbits - 1));
Mark Fashehccd979b2005-12-15 14:31:24 -0800776
777 page = grab_cache_page(mapping, index);
778 if (!page) {
779 ret = -ENOMEM;
780 mlog_errno(ret);
781 goto out;
782 }
783
Joel Beckera4bfb4c2010-07-06 14:36:06 -0700784 /* Get the offsets within the page that we want to zero */
785 zero_from = abs_from & (PAGE_CACHE_SIZE - 1);
786 zero_to = abs_to & (PAGE_CACHE_SIZE - 1);
787 if (!zero_to)
788 zero_to = PAGE_CACHE_SIZE;
Mark Fashehccd979b2005-12-15 14:31:24 -0800789
Joel Beckera4bfb4c2010-07-06 14:36:06 -0700790 /* We know that zero_from is block aligned */
791 for (block_start = zero_from; block_start < zero_to;
792 block_start = block_end) {
793 block_end = block_start + (1 << inode->i_blkbits);
794
795 /*
796 * block_start is block-aligned. Bump it by one to
797 * force ocfs2_{prepare,commit}_write() to zero the
798 * whole block.
799 */
800 ret = ocfs2_prepare_write_nolock(inode, page,
801 block_start + 1,
802 block_start + 1);
803 if (ret < 0) {
804 mlog_errno(ret);
Mark Fashehccd979b2005-12-15 14:31:24 -0800805 goto out_unlock;
806 }
Mark Fashehccd979b2005-12-15 14:31:24 -0800807
Joel Beckera4bfb4c2010-07-06 14:36:06 -0700808 if (!handle) {
809 handle = ocfs2_zero_start_ordered_transaction(inode);
810 if (IS_ERR(handle)) {
811 ret = PTR_ERR(handle);
812 handle = NULL;
813 break;
814 }
815 }
816
817 /* must not update i_size! */
818 ret = block_commit_write(page, block_start + 1,
819 block_start + 1);
820 if (ret < 0)
821 mlog_errno(ret);
822 else
823 ret = 0;
824 }
Mark Fashehccd979b2005-12-15 14:31:24 -0800825
826 if (handle)
Mark Fasheh02dc1af2006-10-09 16:48:10 -0700827 ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
Joel Beckera4bfb4c2010-07-06 14:36:06 -0700828
Mark Fashehccd979b2005-12-15 14:31:24 -0800829out_unlock:
830 unlock_page(page);
831 page_cache_release(page);
832out:
833 return ret;
834}
835
836static int ocfs2_zero_extend(struct inode *inode,
837 u64 zero_to_size)
838{
839 int ret = 0;
Joel Beckera4bfb4c2010-07-06 14:36:06 -0700840 u64 start_off, next_off;
Mark Fashehccd979b2005-12-15 14:31:24 -0800841 struct super_block *sb = inode->i_sb;
842
843 start_off = ocfs2_align_bytes_to_blocks(sb, i_size_read(inode));
844 while (start_off < zero_to_size) {
Joel Beckera4bfb4c2010-07-06 14:36:06 -0700845 next_off = (start_off & PAGE_CACHE_MASK) + PAGE_CACHE_SIZE;
846 if (next_off > zero_to_size)
847 next_off = zero_to_size;
848 ret = ocfs2_write_zero_page(inode, start_off, next_off);
Mark Fashehccd979b2005-12-15 14:31:24 -0800849 if (ret < 0) {
850 mlog_errno(ret);
851 goto out;
852 }
853
Joel Beckera4bfb4c2010-07-06 14:36:06 -0700854 start_off = next_off;
Mark Fashehe2057c52006-10-03 17:53:05 -0700855
856 /*
857 * Very large extends have the potential to lock up
858 * the cpu for extended periods of time.
859 */
860 cond_resched();
Mark Fashehccd979b2005-12-15 14:31:24 -0800861 }
862
863out:
864 return ret;
865}
866
Mark Fasheh65ed39d2007-08-28 17:13:23 -0700867int ocfs2_extend_no_holes(struct inode *inode, u64 new_i_size, u64 zero_to)
868{
869 int ret;
870 u32 clusters_to_add;
871 struct ocfs2_inode_info *oi = OCFS2_I(inode);
872
873 clusters_to_add = ocfs2_clusters_for_bytes(inode->i_sb, new_i_size);
874 if (clusters_to_add < oi->ip_clusters)
875 clusters_to_add = 0;
876 else
877 clusters_to_add -= oi->ip_clusters;
878
879 if (clusters_to_add) {
880 ret = __ocfs2_extend_allocation(inode, oi->ip_clusters,
881 clusters_to_add, 0);
882 if (ret) {
883 mlog_errno(ret);
884 goto out;
885 }
886 }
887
888 /*
889 * Call this even if we don't add any clusters to the tree. We
890 * still need to zero the area between the old i_size and the
891 * new i_size.
892 */
893 ret = ocfs2_zero_extend(inode, zero_to);
894 if (ret < 0)
895 mlog_errno(ret);
896
897out:
898 return ret;
899}
900
Mark Fashehccd979b2005-12-15 14:31:24 -0800901static int ocfs2_extend_file(struct inode *inode,
902 struct buffer_head *di_bh,
Mark Fasheh65ed39d2007-08-28 17:13:23 -0700903 u64 new_i_size)
Mark Fashehccd979b2005-12-15 14:31:24 -0800904{
Mark Fashehc934a922007-10-18 15:23:46 -0700905 int ret = 0;
Mark Fasheh1afc32b2007-09-07 14:46:51 -0700906 struct ocfs2_inode_info *oi = OCFS2_I(inode);
Mark Fashehccd979b2005-12-15 14:31:24 -0800907
Mark Fasheh65ed39d2007-08-28 17:13:23 -0700908 BUG_ON(!di_bh);
Mark Fasheh53013cb2006-05-05 19:04:03 -0700909
Mark Fashehccd979b2005-12-15 14:31:24 -0800910 /* setattr sometimes calls us like this. */
911 if (new_i_size == 0)
912 goto out;
913
914 if (i_size_read(inode) == new_i_size)
915 goto out;
916 BUG_ON(new_i_size < i_size_read(inode));
917
Mark Fasheh1afc32b2007-09-07 14:46:51 -0700918 /*
919 * Fall through for converting inline data, even if the fs
920 * supports sparse files.
921 *
922 * The check for inline data here is legal - nobody can add
923 * the feature since we have i_mutex. We must check it again
924 * after acquiring ip_alloc_sem though, as paths like mmap
925 * might have raced us to converting the inode to extents.
926 */
927 if (!(oi->ip_dyn_features & OCFS2_INLINE_DATA_FL)
928 && ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb)))
Mark Fasheh3a0782d2007-01-17 12:53:31 -0800929 goto out_update_size;
Mark Fashehccd979b2005-12-15 14:31:24 -0800930
Mark Fasheh0effef72006-10-03 17:44:42 -0700931 /*
Mark Fasheh65ed39d2007-08-28 17:13:23 -0700932 * The alloc sem blocks people in read/write from reading our
933 * allocation until we're done changing it. We depend on
934 * i_mutex to block other extend/truncate calls while we're
935 * here.
Mark Fasheh0effef72006-10-03 17:44:42 -0700936 */
Mark Fasheh1afc32b2007-09-07 14:46:51 -0700937 down_write(&oi->ip_alloc_sem);
938
939 if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
940 /*
941 * We can optimize small extends by keeping the inodes
942 * inline data.
943 */
944 if (ocfs2_size_fits_inline_data(di_bh, new_i_size)) {
945 up_write(&oi->ip_alloc_sem);
946 goto out_update_size;
947 }
948
949 ret = ocfs2_convert_inline_data_to_extents(inode, di_bh);
950 if (ret) {
951 up_write(&oi->ip_alloc_sem);
952
953 mlog_errno(ret);
Mark Fashehc934a922007-10-18 15:23:46 -0700954 goto out;
Mark Fasheh1afc32b2007-09-07 14:46:51 -0700955 }
956 }
957
958 if (!ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb)))
959 ret = ocfs2_extend_no_holes(inode, new_i_size, new_i_size);
960
961 up_write(&oi->ip_alloc_sem);
Mark Fasheh65ed39d2007-08-28 17:13:23 -0700962
Mark Fasheh0effef72006-10-03 17:44:42 -0700963 if (ret < 0) {
964 mlog_errno(ret);
Mark Fashehc934a922007-10-18 15:23:46 -0700965 goto out;
Mark Fashehccd979b2005-12-15 14:31:24 -0800966 }
967
Mark Fasheh3a0782d2007-01-17 12:53:31 -0800968out_update_size:
Mark Fasheh65ed39d2007-08-28 17:13:23 -0700969 ret = ocfs2_simple_size_update(inode, di_bh, new_i_size);
970 if (ret < 0)
971 mlog_errno(ret);
Mark Fasheh53013cb2006-05-05 19:04:03 -0700972
Mark Fashehccd979b2005-12-15 14:31:24 -0800973out:
974 return ret;
975}
976
977int ocfs2_setattr(struct dentry *dentry, struct iattr *attr)
978{
979 int status = 0, size_change;
980 struct inode *inode = dentry->d_inode;
981 struct super_block *sb = inode->i_sb;
982 struct ocfs2_super *osb = OCFS2_SB(sb);
983 struct buffer_head *bh = NULL;
Mark Fasheh1fabe142006-10-09 18:11:45 -0700984 handle_t *handle = NULL;
Jan Kara65bac572009-06-02 14:24:01 +0200985 struct dquot *transfer_to[MAXQUOTAS] = { };
Jan Kara52a9ee22010-05-13 20:18:45 +0200986 int qtype;
Mark Fashehccd979b2005-12-15 14:31:24 -0800987
988 mlog_entry("(0x%p, '%.*s')\n", dentry,
989 dentry->d_name.len, dentry->d_name.name);
990
Sunil Mushranbc535802008-04-18 10:23:53 -0700991 /* ensuring we don't even attempt to truncate a symlink */
992 if (S_ISLNK(inode->i_mode))
993 attr->ia_valid &= ~ATTR_SIZE;
994
Mark Fashehccd979b2005-12-15 14:31:24 -0800995 if (attr->ia_valid & ATTR_MODE)
996 mlog(0, "mode change: %d\n", attr->ia_mode);
997 if (attr->ia_valid & ATTR_UID)
998 mlog(0, "uid change: %d\n", attr->ia_uid);
999 if (attr->ia_valid & ATTR_GID)
1000 mlog(0, "gid change: %d\n", attr->ia_gid);
1001 if (attr->ia_valid & ATTR_SIZE)
1002 mlog(0, "size change...\n");
1003 if (attr->ia_valid & (ATTR_ATIME | ATTR_MTIME | ATTR_CTIME))
1004 mlog(0, "time change...\n");
1005
1006#define OCFS2_VALID_ATTRS (ATTR_ATIME | ATTR_MTIME | ATTR_CTIME | ATTR_SIZE \
1007 | ATTR_GID | ATTR_UID | ATTR_MODE)
1008 if (!(attr->ia_valid & OCFS2_VALID_ATTRS)) {
1009 mlog(0, "can't handle attrs: 0x%x\n", attr->ia_valid);
1010 return 0;
1011 }
1012
1013 status = inode_change_ok(inode, attr);
1014 if (status)
1015 return status;
1016
Dmitry Monakhov12755622010-04-08 22:04:20 +04001017 if (is_quota_modification(inode, attr))
1018 dquot_initialize(inode);
Mark Fashehccd979b2005-12-15 14:31:24 -08001019 size_change = S_ISREG(inode->i_mode) && attr->ia_valid & ATTR_SIZE;
1020 if (size_change) {
1021 status = ocfs2_rw_lock(inode, 1);
1022 if (status < 0) {
1023 mlog_errno(status);
1024 goto bail;
1025 }
1026 }
1027
Mark Fashehe63aecb62007-10-18 15:30:42 -07001028 status = ocfs2_inode_lock(inode, &bh, 1);
Mark Fashehccd979b2005-12-15 14:31:24 -08001029 if (status < 0) {
1030 if (status != -ENOENT)
1031 mlog_errno(status);
1032 goto bail_unlock_rw;
1033 }
1034
1035 if (size_change && attr->ia_size != i_size_read(inode)) {
Wengang Wang5051f762010-02-26 18:18:25 +08001036 status = inode_newsize_ok(inode, attr->ia_size);
1037 if (status)
Mark Fashehce76fd32007-07-20 12:02:14 -07001038 goto bail_unlock;
Mark Fashehce76fd32007-07-20 12:02:14 -07001039
Joel Becker2b4e30f2008-09-03 20:03:41 -07001040 if (i_size_read(inode) > attr->ia_size) {
1041 if (ocfs2_should_order_data(inode)) {
1042 status = ocfs2_begin_ordered_truncate(inode,
1043 attr->ia_size);
1044 if (status)
1045 goto bail_unlock;
1046 }
Mark Fashehccd979b2005-12-15 14:31:24 -08001047 status = ocfs2_truncate_file(inode, bh, attr->ia_size);
Joel Becker2b4e30f2008-09-03 20:03:41 -07001048 } else
Mark Fasheh65ed39d2007-08-28 17:13:23 -07001049 status = ocfs2_extend_file(inode, bh, attr->ia_size);
Mark Fashehccd979b2005-12-15 14:31:24 -08001050 if (status < 0) {
1051 if (status != -ENOSPC)
1052 mlog_errno(status);
1053 status = -ENOSPC;
1054 goto bail_unlock;
1055 }
1056 }
1057
Jan Karaa90714c2008-10-09 19:38:40 +02001058 if ((attr->ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
1059 (attr->ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
Jan Kara65bac572009-06-02 14:24:01 +02001060 /*
1061 * Gather pointers to quota structures so that allocation /
1062 * freeing of quota structures happens here and not inside
Christoph Hellwigb43fa822010-03-03 09:05:03 -05001063 * dquot_transfer() where we have problems with lock ordering
Jan Kara65bac572009-06-02 14:24:01 +02001064 */
Jan Karaa90714c2008-10-09 19:38:40 +02001065 if (attr->ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid
1066 && OCFS2_HAS_RO_COMPAT_FEATURE(sb,
1067 OCFS2_FEATURE_RO_COMPAT_USRQUOTA)) {
Jan Kara65bac572009-06-02 14:24:01 +02001068 transfer_to[USRQUOTA] = dqget(sb, attr->ia_uid,
1069 USRQUOTA);
Jan Kara52a9ee22010-05-13 20:18:45 +02001070 if (!transfer_to[USRQUOTA]) {
Jan Kara65bac572009-06-02 14:24:01 +02001071 status = -ESRCH;
Jan Karaa90714c2008-10-09 19:38:40 +02001072 goto bail_unlock;
Jan Kara65bac572009-06-02 14:24:01 +02001073 }
Jan Karaa90714c2008-10-09 19:38:40 +02001074 }
1075 if (attr->ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid
1076 && OCFS2_HAS_RO_COMPAT_FEATURE(sb,
1077 OCFS2_FEATURE_RO_COMPAT_GRPQUOTA)) {
Jan Kara65bac572009-06-02 14:24:01 +02001078 transfer_to[GRPQUOTA] = dqget(sb, attr->ia_gid,
1079 GRPQUOTA);
Jan Kara52a9ee22010-05-13 20:18:45 +02001080 if (!transfer_to[GRPQUOTA]) {
Jan Kara65bac572009-06-02 14:24:01 +02001081 status = -ESRCH;
Jan Karaa90714c2008-10-09 19:38:40 +02001082 goto bail_unlock;
Jan Kara65bac572009-06-02 14:24:01 +02001083 }
Jan Karaa90714c2008-10-09 19:38:40 +02001084 }
Jan Kara65bac572009-06-02 14:24:01 +02001085 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS +
1086 2 * ocfs2_quota_trans_credits(sb));
Jan Karaa90714c2008-10-09 19:38:40 +02001087 if (IS_ERR(handle)) {
1088 status = PTR_ERR(handle);
1089 mlog_errno(status);
1090 goto bail_unlock;
1091 }
Jan Kara52a9ee22010-05-13 20:18:45 +02001092 status = __dquot_transfer(inode, transfer_to);
Jan Karaa90714c2008-10-09 19:38:40 +02001093 if (status < 0)
1094 goto bail_commit;
1095 } else {
1096 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
1097 if (IS_ERR(handle)) {
1098 status = PTR_ERR(handle);
1099 mlog_errno(status);
1100 goto bail_unlock;
1101 }
Mark Fashehccd979b2005-12-15 14:31:24 -08001102 }
1103
Mark Fasheh7307de82007-05-09 15:16:19 -07001104 /*
npiggin@suse.de15c6fd92010-05-27 01:05:34 +10001105 * This will intentionally not wind up calling simple_setsize(),
Mark Fasheh7307de82007-05-09 15:16:19 -07001106 * since all the work for a size change has been done above.
1107 * Otherwise, we could get into problems with truncate as
1108 * ip_alloc_sem is used there to protect against i_size
1109 * changes.
1110 */
Mark Fashehccd979b2005-12-15 14:31:24 -08001111 status = inode_setattr(inode, attr);
1112 if (status < 0) {
1113 mlog_errno(status);
1114 goto bail_commit;
1115 }
1116
1117 status = ocfs2_mark_inode_dirty(handle, inode, bh);
1118 if (status < 0)
1119 mlog_errno(status);
1120
1121bail_commit:
Mark Fasheh02dc1af2006-10-09 16:48:10 -07001122 ocfs2_commit_trans(osb, handle);
Mark Fashehccd979b2005-12-15 14:31:24 -08001123bail_unlock:
Mark Fashehe63aecb62007-10-18 15:30:42 -07001124 ocfs2_inode_unlock(inode, 1);
Mark Fashehccd979b2005-12-15 14:31:24 -08001125bail_unlock_rw:
1126 if (size_change)
1127 ocfs2_rw_unlock(inode, 1);
1128bail:
Mark Fasheha81cb882008-10-07 14:25:16 -07001129 brelse(bh);
Mark Fashehccd979b2005-12-15 14:31:24 -08001130
Jan Kara65bac572009-06-02 14:24:01 +02001131 /* Release quota pointers in case we acquired them */
Jan Kara52a9ee22010-05-13 20:18:45 +02001132 for (qtype = 0; qtype < MAXQUOTAS; qtype++)
Jan Kara65bac572009-06-02 14:24:01 +02001133 dqput(transfer_to[qtype]);
Jan Kara65bac572009-06-02 14:24:01 +02001134
Tiger Yang060bc662008-11-14 11:17:29 +08001135 if (!status && attr->ia_valid & ATTR_MODE) {
1136 status = ocfs2_acl_chmod(inode);
1137 if (status < 0)
1138 mlog_errno(status);
1139 }
1140
Mark Fashehccd979b2005-12-15 14:31:24 -08001141 mlog_exit(status);
1142 return status;
1143}
1144
1145int ocfs2_getattr(struct vfsmount *mnt,
1146 struct dentry *dentry,
1147 struct kstat *stat)
1148{
1149 struct inode *inode = dentry->d_inode;
1150 struct super_block *sb = dentry->d_inode->i_sb;
1151 struct ocfs2_super *osb = sb->s_fs_info;
1152 int err;
1153
1154 mlog_entry_void();
1155
1156 err = ocfs2_inode_revalidate(dentry);
1157 if (err) {
1158 if (err != -ENOENT)
1159 mlog_errno(err);
1160 goto bail;
1161 }
1162
1163 generic_fillattr(inode, stat);
1164
1165 /* We set the blksize from the cluster size for performance */
1166 stat->blksize = osb->s_clustersize;
1167
1168bail:
1169 mlog_exit(err);
1170
1171 return err;
1172}
1173
Al Viroe6305c42008-07-15 21:03:57 -04001174int ocfs2_permission(struct inode *inode, int mask)
Tiger Yangd38eb8d2006-11-27 09:59:21 +08001175{
1176 int ret;
1177
1178 mlog_entry_void();
1179
Mark Fashehe63aecb62007-10-18 15:30:42 -07001180 ret = ocfs2_inode_lock(inode, NULL, 0);
Tiger Yangd38eb8d2006-11-27 09:59:21 +08001181 if (ret) {
Mark Fasheha9f5f702007-04-26 11:43:43 -07001182 if (ret != -ENOENT)
1183 mlog_errno(ret);
Tiger Yangd38eb8d2006-11-27 09:59:21 +08001184 goto out;
1185 }
1186
Tiger Yang23fc2702008-11-14 11:17:18 +08001187 ret = generic_permission(inode, mask, ocfs2_check_acl);
Tiger Yangd38eb8d2006-11-27 09:59:21 +08001188
Mark Fashehe63aecb62007-10-18 15:30:42 -07001189 ocfs2_inode_unlock(inode, 0);
Tiger Yangd38eb8d2006-11-27 09:59:21 +08001190out:
1191 mlog_exit(ret);
1192 return ret;
1193}
1194
Mark Fashehb2580102007-03-09 16:53:21 -08001195static int __ocfs2_write_remove_suid(struct inode *inode,
1196 struct buffer_head *bh)
Mark Fashehccd979b2005-12-15 14:31:24 -08001197{
1198 int ret;
Mark Fasheh1fabe142006-10-09 18:11:45 -07001199 handle_t *handle;
Mark Fashehccd979b2005-12-15 14:31:24 -08001200 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1201 struct ocfs2_dinode *di;
1202
Mark Fashehb06970532006-03-03 10:24:33 -08001203 mlog_entry("(Inode %llu, mode 0%o)\n",
Mark Fashehb2580102007-03-09 16:53:21 -08001204 (unsigned long long)OCFS2_I(inode)->ip_blkno, inode->i_mode);
Mark Fashehccd979b2005-12-15 14:31:24 -08001205
Mark Fasheh65eff9c2006-10-09 17:26:22 -07001206 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
Jan Karafa38e922008-10-20 19:23:51 +02001207 if (IS_ERR(handle)) {
1208 ret = PTR_ERR(handle);
Mark Fashehccd979b2005-12-15 14:31:24 -08001209 mlog_errno(ret);
1210 goto out;
1211 }
1212
Joel Becker0cf2f762009-02-12 16:41:25 -08001213 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), bh,
Joel Becker13723d02008-10-17 19:25:01 -07001214 OCFS2_JOURNAL_ACCESS_WRITE);
Mark Fashehccd979b2005-12-15 14:31:24 -08001215 if (ret < 0) {
1216 mlog_errno(ret);
Mark Fashehb2580102007-03-09 16:53:21 -08001217 goto out_trans;
Mark Fashehccd979b2005-12-15 14:31:24 -08001218 }
1219
1220 inode->i_mode &= ~S_ISUID;
1221 if ((inode->i_mode & S_ISGID) && (inode->i_mode & S_IXGRP))
1222 inode->i_mode &= ~S_ISGID;
1223
1224 di = (struct ocfs2_dinode *) bh->b_data;
1225 di->i_mode = cpu_to_le16(inode->i_mode);
1226
Joel Beckerec20cec2010-03-19 14:13:52 -07001227 ocfs2_journal_dirty(handle, bh);
Mark Fashehb2580102007-03-09 16:53:21 -08001228
Mark Fashehccd979b2005-12-15 14:31:24 -08001229out_trans:
Mark Fasheh02dc1af2006-10-09 16:48:10 -07001230 ocfs2_commit_trans(osb, handle);
Mark Fashehccd979b2005-12-15 14:31:24 -08001231out:
1232 mlog_exit(ret);
1233 return ret;
1234}
1235
Mark Fasheh9517bac2007-02-09 20:24:12 -08001236/*
1237 * Will look for holes and unwritten extents in the range starting at
1238 * pos for count bytes (inclusive).
1239 */
1240static int ocfs2_check_range_for_holes(struct inode *inode, loff_t pos,
1241 size_t count)
1242{
1243 int ret = 0;
Mark Fasheh49cb8d22007-03-09 16:21:46 -08001244 unsigned int extent_flags;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001245 u32 cpos, clusters, extent_len, phys_cpos;
1246 struct super_block *sb = inode->i_sb;
1247
1248 cpos = pos >> OCFS2_SB(sb)->s_clustersize_bits;
1249 clusters = ocfs2_clusters_for_bytes(sb, pos + count) - cpos;
1250
1251 while (clusters) {
Mark Fasheh49cb8d22007-03-09 16:21:46 -08001252 ret = ocfs2_get_clusters(inode, cpos, &phys_cpos, &extent_len,
1253 &extent_flags);
Mark Fasheh9517bac2007-02-09 20:24:12 -08001254 if (ret < 0) {
1255 mlog_errno(ret);
1256 goto out;
1257 }
1258
Mark Fasheh49cb8d22007-03-09 16:21:46 -08001259 if (phys_cpos == 0 || (extent_flags & OCFS2_EXT_UNWRITTEN)) {
Mark Fasheh9517bac2007-02-09 20:24:12 -08001260 ret = 1;
1261 break;
1262 }
1263
1264 if (extent_len > clusters)
1265 extent_len = clusters;
1266
1267 clusters -= extent_len;
1268 cpos += extent_len;
1269 }
1270out:
1271 return ret;
1272}
1273
Mark Fashehb2580102007-03-09 16:53:21 -08001274static int ocfs2_write_remove_suid(struct inode *inode)
1275{
1276 int ret;
1277 struct buffer_head *bh = NULL;
Mark Fashehb2580102007-03-09 16:53:21 -08001278
Joel Beckerb657c952008-11-13 14:49:11 -08001279 ret = ocfs2_read_inode_block(inode, &bh);
Mark Fashehb2580102007-03-09 16:53:21 -08001280 if (ret < 0) {
1281 mlog_errno(ret);
1282 goto out;
1283 }
1284
1285 ret = __ocfs2_write_remove_suid(inode, bh);
1286out:
1287 brelse(bh);
1288 return ret;
1289}
1290
Mark Fasheh2ae99a62007-03-09 16:43:28 -08001291/*
1292 * Allocate enough extents to cover the region starting at byte offset
1293 * start for len bytes. Existing extents are skipped, any extents
1294 * added are marked as "unwritten".
1295 */
1296static int ocfs2_allocate_unwritten_extents(struct inode *inode,
1297 u64 start, u64 len)
1298{
1299 int ret;
1300 u32 cpos, phys_cpos, clusters, alloc_size;
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001301 u64 end = start + len;
1302 struct buffer_head *di_bh = NULL;
1303
1304 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
Joel Beckerb657c952008-11-13 14:49:11 -08001305 ret = ocfs2_read_inode_block(inode, &di_bh);
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001306 if (ret) {
1307 mlog_errno(ret);
1308 goto out;
1309 }
1310
1311 /*
1312 * Nothing to do if the requested reservation range
1313 * fits within the inode.
1314 */
1315 if (ocfs2_size_fits_inline_data(di_bh, end))
1316 goto out;
1317
1318 ret = ocfs2_convert_inline_data_to_extents(inode, di_bh);
1319 if (ret) {
1320 mlog_errno(ret);
1321 goto out;
1322 }
1323 }
Mark Fasheh2ae99a62007-03-09 16:43:28 -08001324
1325 /*
1326 * We consider both start and len to be inclusive.
1327 */
1328 cpos = start >> OCFS2_SB(inode->i_sb)->s_clustersize_bits;
1329 clusters = ocfs2_clusters_for_bytes(inode->i_sb, start + len);
1330 clusters -= cpos;
1331
1332 while (clusters) {
1333 ret = ocfs2_get_clusters(inode, cpos, &phys_cpos,
1334 &alloc_size, NULL);
1335 if (ret) {
1336 mlog_errno(ret);
1337 goto out;
1338 }
1339
1340 /*
1341 * Hole or existing extent len can be arbitrary, so
1342 * cap it to our own allocation request.
1343 */
1344 if (alloc_size > clusters)
1345 alloc_size = clusters;
1346
1347 if (phys_cpos) {
1348 /*
1349 * We already have an allocation at this
1350 * region so we can safely skip it.
1351 */
1352 goto next;
1353 }
1354
1355 ret = __ocfs2_extend_allocation(inode, cpos, alloc_size, 1);
1356 if (ret) {
1357 if (ret != -ENOSPC)
1358 mlog_errno(ret);
1359 goto out;
1360 }
1361
1362next:
1363 cpos += alloc_size;
1364 clusters -= alloc_size;
1365 }
1366
1367 ret = 0;
1368out:
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001369
1370 brelse(di_bh);
Mark Fasheh2ae99a62007-03-09 16:43:28 -08001371 return ret;
1372}
1373
Mark Fasheh063c4562007-07-03 13:34:11 -07001374/*
1375 * Truncate a byte range, avoiding pages within partial clusters. This
1376 * preserves those pages for the zeroing code to write to.
1377 */
1378static void ocfs2_truncate_cluster_pages(struct inode *inode, u64 byte_start,
1379 u64 byte_len)
1380{
1381 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1382 loff_t start, end;
1383 struct address_space *mapping = inode->i_mapping;
1384
1385 start = (loff_t)ocfs2_align_bytes_to_clusters(inode->i_sb, byte_start);
1386 end = byte_start + byte_len;
1387 end = end & ~(osb->s_clustersize - 1);
1388
1389 if (start < end) {
1390 unmap_mapping_range(mapping, start, end - start, 0);
1391 truncate_inode_pages_range(mapping, start, end - 1);
1392 }
1393}
1394
1395static int ocfs2_zero_partial_clusters(struct inode *inode,
1396 u64 start, u64 len)
1397{
1398 int ret = 0;
1399 u64 tmpend, end = start + len;
1400 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1401 unsigned int csize = osb->s_clustersize;
1402 handle_t *handle;
1403
1404 /*
1405 * The "start" and "end" values are NOT necessarily part of
1406 * the range whose allocation is being deleted. Rather, this
1407 * is what the user passed in with the request. We must zero
1408 * partial clusters here. There's no need to worry about
1409 * physical allocation - the zeroing code knows to skip holes.
1410 */
1411 mlog(0, "byte start: %llu, end: %llu\n",
1412 (unsigned long long)start, (unsigned long long)end);
1413
1414 /*
1415 * If both edges are on a cluster boundary then there's no
1416 * zeroing required as the region is part of the allocation to
1417 * be truncated.
1418 */
1419 if ((start & (csize - 1)) == 0 && (end & (csize - 1)) == 0)
1420 goto out;
1421
1422 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
Jan Karafa38e922008-10-20 19:23:51 +02001423 if (IS_ERR(handle)) {
1424 ret = PTR_ERR(handle);
Mark Fasheh063c4562007-07-03 13:34:11 -07001425 mlog_errno(ret);
1426 goto out;
1427 }
1428
1429 /*
1430 * We want to get the byte offset of the end of the 1st cluster.
1431 */
1432 tmpend = (u64)osb->s_clustersize + (start & ~(osb->s_clustersize - 1));
1433 if (tmpend > end)
1434 tmpend = end;
1435
1436 mlog(0, "1st range: start: %llu, tmpend: %llu\n",
1437 (unsigned long long)start, (unsigned long long)tmpend);
1438
1439 ret = ocfs2_zero_range_for_truncate(inode, handle, start, tmpend);
1440 if (ret)
1441 mlog_errno(ret);
1442
1443 if (tmpend < end) {
1444 /*
1445 * This may make start and end equal, but the zeroing
1446 * code will skip any work in that case so there's no
1447 * need to catch it up here.
1448 */
1449 start = end & ~(osb->s_clustersize - 1);
1450
1451 mlog(0, "2nd range: start: %llu, end: %llu\n",
1452 (unsigned long long)start, (unsigned long long)end);
1453
1454 ret = ocfs2_zero_range_for_truncate(inode, handle, start, end);
1455 if (ret)
1456 mlog_errno(ret);
1457 }
1458
1459 ocfs2_commit_trans(osb, handle);
1460out:
1461 return ret;
1462}
1463
Tristan Yec1631d42010-05-11 17:54:45 +08001464static int ocfs2_find_rec(struct ocfs2_extent_list *el, u32 pos)
1465{
1466 int i;
1467 struct ocfs2_extent_rec *rec = NULL;
1468
1469 for (i = le16_to_cpu(el->l_next_free_rec) - 1; i >= 0; i--) {
1470
1471 rec = &el->l_recs[i];
1472
1473 if (le32_to_cpu(rec->e_cpos) < pos)
1474 break;
1475 }
1476
1477 return i;
1478}
1479
1480/*
1481 * Helper to calculate the punching pos and length in one run, we handle the
1482 * following three cases in order:
1483 *
1484 * - remove the entire record
1485 * - remove a partial record
1486 * - no record needs to be removed (hole-punching completed)
1487*/
1488static void ocfs2_calc_trunc_pos(struct inode *inode,
1489 struct ocfs2_extent_list *el,
1490 struct ocfs2_extent_rec *rec,
1491 u32 trunc_start, u32 *trunc_cpos,
1492 u32 *trunc_len, u32 *trunc_end,
1493 u64 *blkno, int *done)
1494{
1495 int ret = 0;
1496 u32 coff, range;
1497
1498 range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
1499
1500 if (le32_to_cpu(rec->e_cpos) >= trunc_start) {
1501 *trunc_cpos = le32_to_cpu(rec->e_cpos);
1502 /*
1503 * Skip holes if any.
1504 */
1505 if (range < *trunc_end)
1506 *trunc_end = range;
1507 *trunc_len = *trunc_end - le32_to_cpu(rec->e_cpos);
1508 *blkno = le64_to_cpu(rec->e_blkno);
1509 *trunc_end = le32_to_cpu(rec->e_cpos);
1510 } else if (range > trunc_start) {
1511 *trunc_cpos = trunc_start;
1512 *trunc_len = *trunc_end - trunc_start;
1513 coff = trunc_start - le32_to_cpu(rec->e_cpos);
1514 *blkno = le64_to_cpu(rec->e_blkno) +
1515 ocfs2_clusters_to_blocks(inode->i_sb, coff);
1516 *trunc_end = trunc_start;
1517 } else {
1518 /*
1519 * It may have two following possibilities:
1520 *
1521 * - last record has been removed
1522 * - trunc_start was within a hole
1523 *
1524 * both two cases mean the completion of hole punching.
1525 */
1526 ret = 1;
1527 }
1528
1529 *done = ret;
1530}
1531
Mark Fasheh063c4562007-07-03 13:34:11 -07001532static int ocfs2_remove_inode_range(struct inode *inode,
1533 struct buffer_head *di_bh, u64 byte_start,
1534 u64 byte_len)
1535{
Tristan Yec1631d42010-05-11 17:54:45 +08001536 int ret = 0, flags = 0, done = 0, i;
1537 u32 trunc_start, trunc_len, trunc_end, trunc_cpos, phys_cpos;
1538 u32 cluster_in_el;
Mark Fasheh063c4562007-07-03 13:34:11 -07001539 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1540 struct ocfs2_cached_dealloc_ctxt dealloc;
Mark Fashehb1967d02007-11-20 11:56:39 -08001541 struct address_space *mapping = inode->i_mapping;
Mark Fashehfecc0112008-11-12 15:16:38 -08001542 struct ocfs2_extent_tree et;
Tristan Yec1631d42010-05-11 17:54:45 +08001543 struct ocfs2_path *path = NULL;
1544 struct ocfs2_extent_list *el = NULL;
1545 struct ocfs2_extent_rec *rec = NULL;
Tristan Yee8aec062010-05-11 17:54:43 +08001546 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
Tristan Yec1631d42010-05-11 17:54:45 +08001547 u64 blkno, refcount_loc = le64_to_cpu(di->i_refcount_loc);
Mark Fasheh063c4562007-07-03 13:34:11 -07001548
Joel Becker5e404e92009-02-13 03:54:22 -08001549 ocfs2_init_dinode_extent_tree(&et, INODE_CACHE(inode), di_bh);
Mark Fasheh063c4562007-07-03 13:34:11 -07001550 ocfs2_init_dealloc_ctxt(&dealloc);
1551
1552 if (byte_len == 0)
1553 return 0;
1554
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001555 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
1556 ret = ocfs2_truncate_inline(inode, di_bh, byte_start,
Mark Fashehb1967d02007-11-20 11:56:39 -08001557 byte_start + byte_len, 0);
1558 if (ret) {
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001559 mlog_errno(ret);
Mark Fashehb1967d02007-11-20 11:56:39 -08001560 goto out;
1561 }
1562 /*
1563 * There's no need to get fancy with the page cache
1564 * truncate of an inline-data inode. We're talking
1565 * about less than a page here, which will be cached
1566 * in the dinode buffer anyway.
1567 */
1568 unmap_mapping_range(mapping, 0, 0, 0);
1569 truncate_inode_pages(mapping, 0);
1570 goto out;
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001571 }
1572
Tristan Yee8aec062010-05-11 17:54:43 +08001573 /*
1574 * For reflinks, we may need to CoW 2 clusters which might be
1575 * partially zero'd later, if hole's start and end offset were
1576 * within one cluster(means is not exactly aligned to clustersize).
1577 */
Mark Fasheh063c4562007-07-03 13:34:11 -07001578
Tristan Yee8aec062010-05-11 17:54:43 +08001579 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_HAS_REFCOUNT_FL) {
1580
1581 ret = ocfs2_cow_file_pos(inode, di_bh, byte_start);
1582 if (ret) {
1583 mlog_errno(ret);
1584 goto out;
1585 }
1586
1587 ret = ocfs2_cow_file_pos(inode, di_bh, byte_start + byte_len);
1588 if (ret) {
1589 mlog_errno(ret);
1590 goto out;
1591 }
1592 }
1593
Mark Fasheh063c4562007-07-03 13:34:11 -07001594 trunc_start = ocfs2_clusters_for_bytes(osb->sb, byte_start);
Tristan Yec1631d42010-05-11 17:54:45 +08001595 trunc_end = (byte_start + byte_len) >> osb->s_clustersize_bits;
1596 cluster_in_el = trunc_end;
Mark Fasheh063c4562007-07-03 13:34:11 -07001597
Tristan Yec1631d42010-05-11 17:54:45 +08001598 mlog(0, "Inode: %llu, start: %llu, len: %llu, cstart: %u, cend: %u\n",
Mark Fasheh063c4562007-07-03 13:34:11 -07001599 (unsigned long long)OCFS2_I(inode)->ip_blkno,
1600 (unsigned long long)byte_start,
Tristan Yec1631d42010-05-11 17:54:45 +08001601 (unsigned long long)byte_len, trunc_start, trunc_end);
Mark Fasheh063c4562007-07-03 13:34:11 -07001602
1603 ret = ocfs2_zero_partial_clusters(inode, byte_start, byte_len);
1604 if (ret) {
1605 mlog_errno(ret);
1606 goto out;
1607 }
1608
Tristan Yec1631d42010-05-11 17:54:45 +08001609 path = ocfs2_new_path_from_et(&et);
1610 if (!path) {
1611 ret = -ENOMEM;
1612 mlog_errno(ret);
1613 goto out;
1614 }
1615
1616 while (trunc_end > trunc_start) {
1617
1618 ret = ocfs2_find_path(INODE_CACHE(inode), path,
1619 cluster_in_el);
Mark Fasheh063c4562007-07-03 13:34:11 -07001620 if (ret) {
1621 mlog_errno(ret);
1622 goto out;
1623 }
1624
Tristan Yec1631d42010-05-11 17:54:45 +08001625 el = path_leaf_el(path);
Mark Fasheh063c4562007-07-03 13:34:11 -07001626
Tristan Yec1631d42010-05-11 17:54:45 +08001627 i = ocfs2_find_rec(el, trunc_end);
1628 /*
1629 * Need to go to previous extent block.
1630 */
1631 if (i < 0) {
1632 if (path->p_tree_depth == 0)
1633 break;
1634
1635 ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb,
1636 path,
1637 &cluster_in_el);
Mark Fasheh063c4562007-07-03 13:34:11 -07001638 if (ret) {
1639 mlog_errno(ret);
1640 goto out;
1641 }
Tristan Yec1631d42010-05-11 17:54:45 +08001642
1643 /*
1644 * We've reached the leftmost extent block,
1645 * it's safe to leave.
1646 */
1647 if (cluster_in_el == 0)
1648 break;
1649
1650 /*
1651 * The 'pos' searched for previous extent block is
1652 * always one cluster less than actual trunc_end.
1653 */
1654 trunc_end = cluster_in_el + 1;
1655
1656 ocfs2_reinit_path(path, 1);
1657
1658 continue;
1659
1660 } else
1661 rec = &el->l_recs[i];
1662
1663 ocfs2_calc_trunc_pos(inode, el, rec, trunc_start, &trunc_cpos,
1664 &trunc_len, &trunc_end, &blkno, &done);
1665 if (done)
1666 break;
1667
1668 flags = rec->e_flags;
1669 phys_cpos = ocfs2_blocks_to_clusters(inode->i_sb, blkno);
1670
1671 ret = ocfs2_remove_btree_range(inode, &et, trunc_cpos,
1672 phys_cpos, trunc_len, flags,
1673 &dealloc, refcount_loc);
1674 if (ret < 0) {
1675 mlog_errno(ret);
1676 goto out;
Mark Fasheh063c4562007-07-03 13:34:11 -07001677 }
1678
Tristan Yec1631d42010-05-11 17:54:45 +08001679 cluster_in_el = trunc_end;
1680
1681 ocfs2_reinit_path(path, 1);
Mark Fasheh063c4562007-07-03 13:34:11 -07001682 }
1683
1684 ocfs2_truncate_cluster_pages(inode, byte_start, byte_len);
1685
1686out:
1687 ocfs2_schedule_truncate_log_flush(osb, 1);
1688 ocfs2_run_deallocs(osb, &dealloc);
1689
1690 return ret;
1691}
1692
Mark Fashehb2580102007-03-09 16:53:21 -08001693/*
1694 * Parts of this function taken from xfs_change_file_space()
1695 */
Mark Fasheh385820a2007-07-19 00:14:38 -07001696static int __ocfs2_change_file_space(struct file *file, struct inode *inode,
1697 loff_t f_pos, unsigned int cmd,
1698 struct ocfs2_space_resv *sr,
1699 int change_size)
Mark Fashehb2580102007-03-09 16:53:21 -08001700{
1701 int ret;
1702 s64 llen;
Mark Fasheh385820a2007-07-19 00:14:38 -07001703 loff_t size;
Mark Fashehb2580102007-03-09 16:53:21 -08001704 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1705 struct buffer_head *di_bh = NULL;
1706 handle_t *handle;
Mark Fasheha00cce32007-07-20 11:28:30 -07001707 unsigned long long max_off = inode->i_sb->s_maxbytes;
Mark Fashehb2580102007-03-09 16:53:21 -08001708
Mark Fashehb2580102007-03-09 16:53:21 -08001709 if (ocfs2_is_hard_readonly(osb) || ocfs2_is_soft_readonly(osb))
1710 return -EROFS;
1711
1712 mutex_lock(&inode->i_mutex);
1713
1714 /*
1715 * This prevents concurrent writes on other nodes
1716 */
1717 ret = ocfs2_rw_lock(inode, 1);
1718 if (ret) {
1719 mlog_errno(ret);
1720 goto out;
1721 }
1722
Mark Fashehe63aecb62007-10-18 15:30:42 -07001723 ret = ocfs2_inode_lock(inode, &di_bh, 1);
Mark Fashehb2580102007-03-09 16:53:21 -08001724 if (ret) {
1725 mlog_errno(ret);
1726 goto out_rw_unlock;
1727 }
1728
1729 if (inode->i_flags & (S_IMMUTABLE|S_APPEND)) {
1730 ret = -EPERM;
Mark Fashehe63aecb62007-10-18 15:30:42 -07001731 goto out_inode_unlock;
Mark Fashehb2580102007-03-09 16:53:21 -08001732 }
1733
1734 switch (sr->l_whence) {
1735 case 0: /*SEEK_SET*/
1736 break;
1737 case 1: /*SEEK_CUR*/
Mark Fasheh385820a2007-07-19 00:14:38 -07001738 sr->l_start += f_pos;
Mark Fashehb2580102007-03-09 16:53:21 -08001739 break;
1740 case 2: /*SEEK_END*/
1741 sr->l_start += i_size_read(inode);
1742 break;
1743 default:
1744 ret = -EINVAL;
Mark Fashehe63aecb62007-10-18 15:30:42 -07001745 goto out_inode_unlock;
Mark Fashehb2580102007-03-09 16:53:21 -08001746 }
1747 sr->l_whence = 0;
1748
1749 llen = sr->l_len > 0 ? sr->l_len - 1 : sr->l_len;
1750
1751 if (sr->l_start < 0
1752 || sr->l_start > max_off
1753 || (sr->l_start + llen) < 0
1754 || (sr->l_start + llen) > max_off) {
1755 ret = -EINVAL;
Mark Fashehe63aecb62007-10-18 15:30:42 -07001756 goto out_inode_unlock;
Mark Fashehb2580102007-03-09 16:53:21 -08001757 }
Mark Fasheh385820a2007-07-19 00:14:38 -07001758 size = sr->l_start + sr->l_len;
Mark Fashehb2580102007-03-09 16:53:21 -08001759
1760 if (cmd == OCFS2_IOC_RESVSP || cmd == OCFS2_IOC_RESVSP64) {
1761 if (sr->l_len <= 0) {
1762 ret = -EINVAL;
Mark Fashehe63aecb62007-10-18 15:30:42 -07001763 goto out_inode_unlock;
Mark Fashehb2580102007-03-09 16:53:21 -08001764 }
1765 }
1766
Mark Fasheh385820a2007-07-19 00:14:38 -07001767 if (file && should_remove_suid(file->f_path.dentry)) {
Mark Fashehb2580102007-03-09 16:53:21 -08001768 ret = __ocfs2_write_remove_suid(inode, di_bh);
1769 if (ret) {
1770 mlog_errno(ret);
Mark Fashehe63aecb62007-10-18 15:30:42 -07001771 goto out_inode_unlock;
Mark Fashehb2580102007-03-09 16:53:21 -08001772 }
1773 }
1774
1775 down_write(&OCFS2_I(inode)->ip_alloc_sem);
1776 switch (cmd) {
1777 case OCFS2_IOC_RESVSP:
1778 case OCFS2_IOC_RESVSP64:
1779 /*
1780 * This takes unsigned offsets, but the signed ones we
1781 * pass have been checked against overflow above.
1782 */
1783 ret = ocfs2_allocate_unwritten_extents(inode, sr->l_start,
1784 sr->l_len);
1785 break;
1786 case OCFS2_IOC_UNRESVSP:
1787 case OCFS2_IOC_UNRESVSP64:
1788 ret = ocfs2_remove_inode_range(inode, di_bh, sr->l_start,
1789 sr->l_len);
1790 break;
1791 default:
1792 ret = -EINVAL;
1793 }
1794 up_write(&OCFS2_I(inode)->ip_alloc_sem);
1795 if (ret) {
1796 mlog_errno(ret);
Mark Fashehe63aecb62007-10-18 15:30:42 -07001797 goto out_inode_unlock;
Mark Fashehb2580102007-03-09 16:53:21 -08001798 }
1799
1800 /*
1801 * We update c/mtime for these changes
1802 */
1803 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
1804 if (IS_ERR(handle)) {
1805 ret = PTR_ERR(handle);
1806 mlog_errno(ret);
Mark Fashehe63aecb62007-10-18 15:30:42 -07001807 goto out_inode_unlock;
Mark Fashehb2580102007-03-09 16:53:21 -08001808 }
1809
Mark Fasheh385820a2007-07-19 00:14:38 -07001810 if (change_size && i_size_read(inode) < size)
1811 i_size_write(inode, size);
1812
Mark Fashehb2580102007-03-09 16:53:21 -08001813 inode->i_ctime = inode->i_mtime = CURRENT_TIME;
1814 ret = ocfs2_mark_inode_dirty(handle, inode, di_bh);
1815 if (ret < 0)
1816 mlog_errno(ret);
1817
1818 ocfs2_commit_trans(osb, handle);
1819
Mark Fashehe63aecb62007-10-18 15:30:42 -07001820out_inode_unlock:
Mark Fashehb2580102007-03-09 16:53:21 -08001821 brelse(di_bh);
Mark Fashehe63aecb62007-10-18 15:30:42 -07001822 ocfs2_inode_unlock(inode, 1);
Mark Fashehb2580102007-03-09 16:53:21 -08001823out_rw_unlock:
1824 ocfs2_rw_unlock(inode, 1);
1825
Mark Fashehb2580102007-03-09 16:53:21 -08001826out:
Julia Lawallc259ae52008-07-21 09:59:15 +02001827 mutex_unlock(&inode->i_mutex);
Mark Fashehb2580102007-03-09 16:53:21 -08001828 return ret;
1829}
1830
Mark Fasheh385820a2007-07-19 00:14:38 -07001831int ocfs2_change_file_space(struct file *file, unsigned int cmd,
1832 struct ocfs2_space_resv *sr)
1833{
1834 struct inode *inode = file->f_path.dentry->d_inode;
Fernando Carrijoc19a28e2009-01-07 18:09:08 -08001835 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
Mark Fasheh385820a2007-07-19 00:14:38 -07001836
1837 if ((cmd == OCFS2_IOC_RESVSP || cmd == OCFS2_IOC_RESVSP64) &&
1838 !ocfs2_writes_unwritten_extents(osb))
1839 return -ENOTTY;
1840 else if ((cmd == OCFS2_IOC_UNRESVSP || cmd == OCFS2_IOC_UNRESVSP64) &&
1841 !ocfs2_sparse_alloc(osb))
1842 return -ENOTTY;
1843
1844 if (!S_ISREG(inode->i_mode))
1845 return -EINVAL;
1846
1847 if (!(file->f_mode & FMODE_WRITE))
1848 return -EBADF;
1849
1850 return __ocfs2_change_file_space(file, inode, file->f_pos, cmd, sr, 0);
1851}
1852
1853static long ocfs2_fallocate(struct inode *inode, int mode, loff_t offset,
1854 loff_t len)
1855{
1856 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1857 struct ocfs2_space_resv sr;
1858 int change_size = 1;
1859
1860 if (!ocfs2_writes_unwritten_extents(osb))
1861 return -EOPNOTSUPP;
1862
1863 if (S_ISDIR(inode->i_mode))
1864 return -ENODEV;
1865
1866 if (mode & FALLOC_FL_KEEP_SIZE)
1867 change_size = 0;
1868
1869 sr.l_whence = 0;
1870 sr.l_start = (s64)offset;
1871 sr.l_len = (s64)len;
1872
1873 return __ocfs2_change_file_space(NULL, inode, offset,
1874 OCFS2_IOC_RESVSP64, &sr, change_size);
1875}
1876
Tao Ma293b2f72009-08-25 08:02:48 +08001877int ocfs2_check_range_for_refcount(struct inode *inode, loff_t pos,
1878 size_t count)
1879{
1880 int ret = 0;
1881 unsigned int extent_flags;
1882 u32 cpos, clusters, extent_len, phys_cpos;
1883 struct super_block *sb = inode->i_sb;
1884
1885 if (!ocfs2_refcount_tree(OCFS2_SB(inode->i_sb)) ||
Tao Ma2f48d592009-10-15 11:10:49 +08001886 !(OCFS2_I(inode)->ip_dyn_features & OCFS2_HAS_REFCOUNT_FL) ||
1887 OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL)
Tao Ma293b2f72009-08-25 08:02:48 +08001888 return 0;
1889
1890 cpos = pos >> OCFS2_SB(sb)->s_clustersize_bits;
1891 clusters = ocfs2_clusters_for_bytes(sb, pos + count) - cpos;
1892
1893 while (clusters) {
1894 ret = ocfs2_get_clusters(inode, cpos, &phys_cpos, &extent_len,
1895 &extent_flags);
1896 if (ret < 0) {
1897 mlog_errno(ret);
1898 goto out;
1899 }
1900
1901 if (phys_cpos && (extent_flags & OCFS2_EXT_REFCOUNTED)) {
1902 ret = 1;
1903 break;
1904 }
1905
1906 if (extent_len > clusters)
1907 extent_len = clusters;
1908
1909 clusters -= extent_len;
1910 cpos += extent_len;
1911 }
1912out:
1913 return ret;
1914}
1915
1916static int ocfs2_prepare_inode_for_refcount(struct inode *inode,
1917 loff_t pos, size_t count,
1918 int *meta_level)
1919{
1920 int ret;
1921 struct buffer_head *di_bh = NULL;
1922 u32 cpos = pos >> OCFS2_SB(inode->i_sb)->s_clustersize_bits;
1923 u32 clusters =
1924 ocfs2_clusters_for_bytes(inode->i_sb, pos + count) - cpos;
1925
1926 ret = ocfs2_inode_lock(inode, &di_bh, 1);
1927 if (ret) {
1928 mlog_errno(ret);
1929 goto out;
1930 }
1931
1932 *meta_level = 1;
1933
Tao Ma37f8a2b2009-08-26 09:47:28 +08001934 ret = ocfs2_refcount_cow(inode, di_bh, cpos, clusters, UINT_MAX);
Tao Ma293b2f72009-08-25 08:02:48 +08001935 if (ret)
1936 mlog_errno(ret);
1937out:
1938 brelse(di_bh);
1939 return ret;
1940}
1941
Tiger Yang8659ac22006-10-17 18:29:52 -07001942static int ocfs2_prepare_inode_for_write(struct dentry *dentry,
1943 loff_t *ppos,
1944 size_t count,
Mark Fasheh9517bac2007-02-09 20:24:12 -08001945 int appending,
Tao Ma86470e92009-12-03 21:55:05 +08001946 int *direct_io,
1947 int *has_refcount)
Mark Fashehccd979b2005-12-15 14:31:24 -08001948{
Mark Fasheh65ed39d2007-08-28 17:13:23 -07001949 int ret = 0, meta_level = 0;
Tiger Yang8659ac22006-10-17 18:29:52 -07001950 struct inode *inode = dentry->d_inode;
Mark Fasheh65ed39d2007-08-28 17:13:23 -07001951 loff_t saved_pos, end;
Mark Fashehccd979b2005-12-15 14:31:24 -08001952
Sunil Mushran2bd63212010-01-25 16:57:38 -08001953 /*
Mark Fasheh65ed39d2007-08-28 17:13:23 -07001954 * We start with a read level meta lock and only jump to an ex
1955 * if we need to make modifications here.
Mark Fashehccd979b2005-12-15 14:31:24 -08001956 */
Mark Fashehccd979b2005-12-15 14:31:24 -08001957 for(;;) {
Mark Fashehe63aecb62007-10-18 15:30:42 -07001958 ret = ocfs2_inode_lock(inode, NULL, meta_level);
Mark Fashehccd979b2005-12-15 14:31:24 -08001959 if (ret < 0) {
1960 meta_level = -1;
1961 mlog_errno(ret);
1962 goto out;
1963 }
1964
1965 /* Clear suid / sgid if necessary. We do this here
1966 * instead of later in the write path because
1967 * remove_suid() calls ->setattr without any hint that
1968 * we may have already done our cluster locking. Since
1969 * ocfs2_setattr() *must* take cluster locks to
1970 * proceeed, this will lead us to recursively lock the
1971 * inode. There's also the dinode i_size state which
1972 * can be lost via setattr during extending writes (we
1973 * set inode->i_size at the end of a write. */
Tiger Yang8659ac22006-10-17 18:29:52 -07001974 if (should_remove_suid(dentry)) {
Mark Fashehccd979b2005-12-15 14:31:24 -08001975 if (meta_level == 0) {
Mark Fashehe63aecb62007-10-18 15:30:42 -07001976 ocfs2_inode_unlock(inode, meta_level);
Mark Fashehccd979b2005-12-15 14:31:24 -08001977 meta_level = 1;
1978 continue;
1979 }
1980
1981 ret = ocfs2_write_remove_suid(inode);
1982 if (ret < 0) {
1983 mlog_errno(ret);
Tiger Yang8659ac22006-10-17 18:29:52 -07001984 goto out_unlock;
Mark Fashehccd979b2005-12-15 14:31:24 -08001985 }
1986 }
1987
1988 /* work on a copy of ppos until we're sure that we won't have
1989 * to recalculate it due to relocking. */
Tiger Yang8659ac22006-10-17 18:29:52 -07001990 if (appending) {
Mark Fashehccd979b2005-12-15 14:31:24 -08001991 saved_pos = i_size_read(inode);
1992 mlog(0, "O_APPEND: inode->i_size=%llu\n", saved_pos);
1993 } else {
Tiger Yang8659ac22006-10-17 18:29:52 -07001994 saved_pos = *ppos;
Mark Fashehccd979b2005-12-15 14:31:24 -08001995 }
Mark Fasheh3a0782d2007-01-17 12:53:31 -08001996
Mark Fasheh65ed39d2007-08-28 17:13:23 -07001997 end = saved_pos + count;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001998
Tao Ma293b2f72009-08-25 08:02:48 +08001999 ret = ocfs2_check_range_for_refcount(inode, saved_pos, count);
2000 if (ret == 1) {
2001 ocfs2_inode_unlock(inode, meta_level);
2002 meta_level = -1;
2003
2004 ret = ocfs2_prepare_inode_for_refcount(inode,
2005 saved_pos,
2006 count,
2007 &meta_level);
Tao Ma86470e92009-12-03 21:55:05 +08002008 if (has_refcount)
2009 *has_refcount = 1;
Wengang Wang96a1cc72010-02-09 14:57:45 +08002010 if (direct_io)
2011 *direct_io = 0;
Tao Ma293b2f72009-08-25 08:02:48 +08002012 }
2013
2014 if (ret < 0) {
2015 mlog_errno(ret);
2016 goto out_unlock;
2017 }
2018
Mark Fasheh65ed39d2007-08-28 17:13:23 -07002019 /*
2020 * Skip the O_DIRECT checks if we don't need
2021 * them.
2022 */
2023 if (!direct_io || !(*direct_io))
2024 break;
Mark Fasheh9517bac2007-02-09 20:24:12 -08002025
Mark Fasheh65ed39d2007-08-28 17:13:23 -07002026 /*
Mark Fasheh1afc32b2007-09-07 14:46:51 -07002027 * There's no sane way to do direct writes to an inode
2028 * with inline data.
2029 */
2030 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
2031 *direct_io = 0;
2032 break;
2033 }
2034
2035 /*
Mark Fasheh65ed39d2007-08-28 17:13:23 -07002036 * Allowing concurrent direct writes means
2037 * i_size changes wouldn't be synchronized, so
2038 * one node could wind up truncating another
2039 * nodes writes.
2040 */
2041 if (end > i_size_read(inode)) {
2042 *direct_io = 0;
Mark Fasheh9517bac2007-02-09 20:24:12 -08002043 break;
2044 }
2045
Mark Fasheh3a0782d2007-01-17 12:53:31 -08002046 /*
Mark Fasheh65ed39d2007-08-28 17:13:23 -07002047 * We don't fill holes during direct io, so
2048 * check for them here. If any are found, the
2049 * caller will have to retake some cluster
2050 * locks and initiate the io as buffered.
Mark Fasheh3a0782d2007-01-17 12:53:31 -08002051 */
Mark Fasheh65ed39d2007-08-28 17:13:23 -07002052 ret = ocfs2_check_range_for_holes(inode, saved_pos, count);
2053 if (ret == 1) {
2054 *direct_io = 0;
2055 ret = 0;
2056 } else if (ret < 0)
2057 mlog_errno(ret);
Mark Fashehccd979b2005-12-15 14:31:24 -08002058 break;
2059 }
2060
Tiger Yang8659ac22006-10-17 18:29:52 -07002061 if (appending)
2062 *ppos = saved_pos;
2063
2064out_unlock:
Tao Ma293b2f72009-08-25 08:02:48 +08002065 if (meta_level >= 0)
2066 ocfs2_inode_unlock(inode, meta_level);
Tiger Yang8659ac22006-10-17 18:29:52 -07002067
2068out:
2069 return ret;
2070}
2071
2072static ssize_t ocfs2_file_aio_write(struct kiocb *iocb,
2073 const struct iovec *iov,
2074 unsigned long nr_segs,
2075 loff_t pos)
2076{
Mark Fasheh9517bac2007-02-09 20:24:12 -08002077 int ret, direct_io, appending, rw_level, have_alloc_sem = 0;
Tao Ma86470e92009-12-03 21:55:05 +08002078 int can_do_direct, has_refcount = 0;
Mark Fasheh9517bac2007-02-09 20:24:12 -08002079 ssize_t written = 0;
2080 size_t ocount; /* original count */
2081 size_t count; /* after file limit checks */
Mark Fasheh9ea2d322007-10-18 14:14:45 -07002082 loff_t old_size, *ppos = &iocb->ki_pos;
2083 u32 old_clusters;
Mark Fasheh9517bac2007-02-09 20:24:12 -08002084 struct file *file = iocb->ki_filp;
2085 struct inode *inode = file->f_path.dentry->d_inode;
Mark Fasheh9ea2d322007-10-18 14:14:45 -07002086 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
Tiger Yang8659ac22006-10-17 18:29:52 -07002087
Mark Fasheh9517bac2007-02-09 20:24:12 -08002088 mlog_entry("(0x%p, %u, '%.*s')\n", file,
Tiger Yang8659ac22006-10-17 18:29:52 -07002089 (unsigned int)nr_segs,
Mark Fasheh9517bac2007-02-09 20:24:12 -08002090 file->f_path.dentry->d_name.len,
2091 file->f_path.dentry->d_name.name);
Tiger Yang8659ac22006-10-17 18:29:52 -07002092
Tiger Yang8659ac22006-10-17 18:29:52 -07002093 if (iocb->ki_left == 0)
2094 return 0;
2095
Mark Fasheh9517bac2007-02-09 20:24:12 -08002096 vfs_check_frozen(inode->i_sb, SB_FREEZE_WRITE);
2097
2098 appending = file->f_flags & O_APPEND ? 1 : 0;
2099 direct_io = file->f_flags & O_DIRECT ? 1 : 0;
2100
Tiger Yang8659ac22006-10-17 18:29:52 -07002101 mutex_lock(&inode->i_mutex);
Mark Fasheh9517bac2007-02-09 20:24:12 -08002102
2103relock:
Tiger Yang8659ac22006-10-17 18:29:52 -07002104 /* to match setattr's i_mutex -> i_alloc_sem -> rw_lock ordering */
Mark Fasheh9517bac2007-02-09 20:24:12 -08002105 if (direct_io) {
Tiger Yang8659ac22006-10-17 18:29:52 -07002106 down_read(&inode->i_alloc_sem);
Mark Fasheh9517bac2007-02-09 20:24:12 -08002107 have_alloc_sem = 1;
Tiger Yang8659ac22006-10-17 18:29:52 -07002108 }
2109
2110 /* concurrent O_DIRECT writes are allowed */
Mark Fasheh9517bac2007-02-09 20:24:12 -08002111 rw_level = !direct_io;
Tiger Yang8659ac22006-10-17 18:29:52 -07002112 ret = ocfs2_rw_lock(inode, rw_level);
2113 if (ret < 0) {
Mark Fasheh9517bac2007-02-09 20:24:12 -08002114 mlog_errno(ret);
2115 goto out_sems;
2116 }
2117
2118 can_do_direct = direct_io;
2119 ret = ocfs2_prepare_inode_for_write(file->f_path.dentry, ppos,
2120 iocb->ki_left, appending,
Tao Ma86470e92009-12-03 21:55:05 +08002121 &can_do_direct, &has_refcount);
Mark Fasheh9517bac2007-02-09 20:24:12 -08002122 if (ret < 0) {
Tiger Yang8659ac22006-10-17 18:29:52 -07002123 mlog_errno(ret);
2124 goto out;
2125 }
2126
Mark Fasheh9517bac2007-02-09 20:24:12 -08002127 /*
2128 * We can't complete the direct I/O as requested, fall back to
2129 * buffered I/O.
2130 */
2131 if (direct_io && !can_do_direct) {
2132 ocfs2_rw_unlock(inode, rw_level);
2133 up_read(&inode->i_alloc_sem);
2134
2135 have_alloc_sem = 0;
2136 rw_level = -1;
2137
2138 direct_io = 0;
Mark Fasheh9517bac2007-02-09 20:24:12 -08002139 goto relock;
Tiger Yang8659ac22006-10-17 18:29:52 -07002140 }
Mark Fashehccd979b2005-12-15 14:31:24 -08002141
Mark Fasheh9ea2d322007-10-18 14:14:45 -07002142 /*
2143 * To later detect whether a journal commit for sync writes is
2144 * necessary, we sample i_size, and cluster count here.
2145 */
2146 old_size = i_size_read(inode);
2147 old_clusters = OCFS2_I(inode)->ip_clusters;
2148
Mark Fashehccd979b2005-12-15 14:31:24 -08002149 /* communicate with ocfs2_dio_end_io */
Mark Fasheh7cdfc3a2007-04-16 17:28:51 -07002150 ocfs2_iocb_set_rw_locked(iocb, rw_level);
Mark Fashehccd979b2005-12-15 14:31:24 -08002151
Li Dongyang6b933c82010-04-17 17:49:10 +08002152 ret = generic_segment_checks(iov, &nr_segs, &ocount,
2153 VERIFY_READ);
2154 if (ret)
2155 goto out_dio;
2156
2157 count = ocount;
2158 ret = generic_write_checks(file, ppos, &count,
2159 S_ISBLK(inode->i_mode));
2160 if (ret)
2161 goto out_dio;
2162
Mark Fasheh9517bac2007-02-09 20:24:12 -08002163 if (direct_io) {
2164 written = generic_file_direct_write(iocb, iov, &nr_segs, *ppos,
2165 ppos, count, ocount);
2166 if (written < 0) {
Dmitri Monakhovc4354002008-10-27 13:01:49 -07002167 /*
2168 * direct write may have instantiated a few
2169 * blocks outside i_size. Trim these off again.
2170 * Don't need i_size_read because we hold i_mutex.
npiggin@suse.de15c6fd92010-05-27 01:05:34 +10002171 *
2172 * XXX(hch): this looks buggy because ocfs2 did not
2173 * actually implement ->truncate. Take a look at
2174 * the new truncate sequence and update this accordingly
Dmitri Monakhovc4354002008-10-27 13:01:49 -07002175 */
2176 if (*ppos + count > inode->i_size)
npiggin@suse.de15c6fd92010-05-27 01:05:34 +10002177 simple_setsize(inode, inode->i_size);
Mark Fasheh9517bac2007-02-09 20:24:12 -08002178 ret = written;
2179 goto out_dio;
2180 }
2181 } else {
Li Dongyang6b933c82010-04-17 17:49:10 +08002182 current->backing_dev_info = file->f_mapping->backing_dev_info;
2183 written = generic_file_buffered_write(iocb, iov, nr_segs, *ppos,
2184 ppos, count, 0);
2185 current->backing_dev_info = NULL;
Mark Fasheh9517bac2007-02-09 20:24:12 -08002186 }
Mark Fashehccd979b2005-12-15 14:31:24 -08002187
Mark Fasheh9517bac2007-02-09 20:24:12 -08002188out_dio:
Mark Fashehccd979b2005-12-15 14:31:24 -08002189 /* buffered aio wouldn't have proper lock coverage today */
Mark Fasheh9517bac2007-02-09 20:24:12 -08002190 BUG_ON(ret == -EIOCBQUEUED && !(file->f_flags & O_DIRECT));
Mark Fashehccd979b2005-12-15 14:31:24 -08002191
Tao Ma60c48672010-02-03 09:56:04 +08002192 if (((file->f_flags & O_DSYNC) && !direct_io) || IS_SYNC(inode) ||
2193 ((file->f_flags & O_DIRECT) && has_refcount)) {
Jan Kara918941a2009-08-17 18:50:08 +02002194 ret = filemap_fdatawrite_range(file->f_mapping, pos,
2195 pos + count - 1);
2196 if (ret < 0)
2197 written = ret;
2198
Coly Lia03ab782010-03-26 05:15:12 +08002199 if (!ret && ((old_size != i_size_read(inode)) ||
2200 (old_clusters != OCFS2_I(inode)->ip_clusters) ||
2201 has_refcount)) {
Joel Becker2b4e30f2008-09-03 20:03:41 -07002202 ret = jbd2_journal_force_commit(osb->journal->j_journal);
Mark Fasheh9ea2d322007-10-18 14:14:45 -07002203 if (ret < 0)
2204 written = ret;
2205 }
Jan Kara918941a2009-08-17 18:50:08 +02002206
2207 if (!ret)
2208 ret = filemap_fdatawait_range(file->f_mapping, pos,
2209 pos + count - 1);
Mark Fasheh9ea2d322007-10-18 14:14:45 -07002210 }
2211
Sunil Mushran2bd63212010-01-25 16:57:38 -08002212 /*
Mark Fashehccd979b2005-12-15 14:31:24 -08002213 * deep in g_f_a_w_n()->ocfs2_direct_IO we pass in a ocfs2_dio_end_io
2214 * function pointer which is called when o_direct io completes so that
2215 * it can unlock our rw lock. (it's the clustered equivalent of
2216 * i_alloc_sem; protects truncate from racing with pending ios).
2217 * Unfortunately there are error cases which call end_io and others
2218 * that don't. so we don't have to unlock the rw_lock if either an
2219 * async dio is going to do it in the future or an end_io after an
2220 * error has already done it.
2221 */
Coly Li66b116c2010-02-25 14:57:13 +08002222 if ((ret == -EIOCBQUEUED) || (!ocfs2_iocb_is_rw_locked(iocb))) {
Mark Fashehccd979b2005-12-15 14:31:24 -08002223 rw_level = -1;
2224 have_alloc_sem = 0;
2225 }
2226
2227out:
Mark Fasheh9517bac2007-02-09 20:24:12 -08002228 if (rw_level != -1)
2229 ocfs2_rw_unlock(inode, rw_level);
2230
2231out_sems:
Mark Fashehccd979b2005-12-15 14:31:24 -08002232 if (have_alloc_sem)
2233 up_read(&inode->i_alloc_sem);
Mark Fasheh9517bac2007-02-09 20:24:12 -08002234
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002235 mutex_unlock(&inode->i_mutex);
Mark Fashehccd979b2005-12-15 14:31:24 -08002236
Wengang Wang812e7a62009-07-10 13:26:04 +08002237 if (written)
2238 ret = written;
Mark Fashehccd979b2005-12-15 14:31:24 -08002239 mlog_exit(ret);
Wengang Wang812e7a62009-07-10 13:26:04 +08002240 return ret;
Mark Fashehccd979b2005-12-15 14:31:24 -08002241}
2242
Miklos Szeredi328eaab2009-04-14 19:48:39 +02002243static int ocfs2_splice_to_file(struct pipe_inode_info *pipe,
2244 struct file *out,
2245 struct splice_desc *sd)
2246{
2247 int ret;
2248
2249 ret = ocfs2_prepare_inode_for_write(out->f_path.dentry, &sd->pos,
Tao Ma86470e92009-12-03 21:55:05 +08002250 sd->total_len, 0, NULL, NULL);
Miklos Szeredi328eaab2009-04-14 19:48:39 +02002251 if (ret < 0) {
2252 mlog_errno(ret);
2253 return ret;
2254 }
2255
2256 return splice_from_pipe_feed(pipe, sd, pipe_to_file);
2257}
2258
Tiger Yang8659ac22006-10-17 18:29:52 -07002259static ssize_t ocfs2_file_splice_write(struct pipe_inode_info *pipe,
2260 struct file *out,
2261 loff_t *ppos,
2262 size_t len,
2263 unsigned int flags)
2264{
2265 int ret;
Miklos Szeredi328eaab2009-04-14 19:48:39 +02002266 struct address_space *mapping = out->f_mapping;
2267 struct inode *inode = mapping->host;
2268 struct splice_desc sd = {
2269 .total_len = len,
2270 .flags = flags,
2271 .pos = *ppos,
2272 .u.file = out,
2273 };
Tiger Yang8659ac22006-10-17 18:29:52 -07002274
2275 mlog_entry("(0x%p, 0x%p, %u, '%.*s')\n", out, pipe,
2276 (unsigned int)len,
Josef Sipekd28c9172006-12-08 02:37:25 -08002277 out->f_path.dentry->d_name.len,
2278 out->f_path.dentry->d_name.name);
Tiger Yang8659ac22006-10-17 18:29:52 -07002279
Miklos Szeredi7bfac9e2009-04-06 17:41:00 +02002280 if (pipe->inode)
Miklos Szeredi328eaab2009-04-14 19:48:39 +02002281 mutex_lock_nested(&pipe->inode->i_mutex, I_MUTEX_PARENT);
2282
2283 splice_from_pipe_begin(&sd);
2284 do {
2285 ret = splice_from_pipe_next(pipe, &sd);
2286 if (ret <= 0)
2287 break;
2288
2289 mutex_lock_nested(&inode->i_mutex, I_MUTEX_CHILD);
2290 ret = ocfs2_rw_lock(inode, 1);
2291 if (ret < 0)
2292 mlog_errno(ret);
2293 else {
2294 ret = ocfs2_splice_to_file(pipe, out, &sd);
2295 ocfs2_rw_unlock(inode, 1);
2296 }
2297 mutex_unlock(&inode->i_mutex);
2298 } while (ret > 0);
2299 splice_from_pipe_end(pipe, &sd);
2300
Miklos Szeredi7bfac9e2009-04-06 17:41:00 +02002301 if (pipe->inode)
2302 mutex_unlock(&pipe->inode->i_mutex);
Tiger Yang8659ac22006-10-17 18:29:52 -07002303
Miklos Szeredi328eaab2009-04-14 19:48:39 +02002304 if (sd.num_spliced)
2305 ret = sd.num_spliced;
2306
2307 if (ret > 0) {
2308 unsigned long nr_pages;
Jan Karad23c9372009-08-18 18:24:31 +02002309 int err;
Miklos Szeredi328eaab2009-04-14 19:48:39 +02002310
Miklos Szeredi328eaab2009-04-14 19:48:39 +02002311 nr_pages = (ret + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
2312
Jan Karad23c9372009-08-18 18:24:31 +02002313 err = generic_write_sync(out, *ppos, ret);
2314 if (err)
2315 ret = err;
2316 else
2317 *ppos += ret;
Miklos Szeredi328eaab2009-04-14 19:48:39 +02002318
Miklos Szeredi328eaab2009-04-14 19:48:39 +02002319 balance_dirty_pages_ratelimited_nr(mapping, nr_pages);
2320 }
Tiger Yang8659ac22006-10-17 18:29:52 -07002321
2322 mlog_exit(ret);
2323 return ret;
2324}
2325
2326static ssize_t ocfs2_file_splice_read(struct file *in,
2327 loff_t *ppos,
2328 struct pipe_inode_info *pipe,
2329 size_t len,
2330 unsigned int flags)
2331{
Tao Ma1962f392009-06-19 15:36:52 +08002332 int ret = 0, lock_level = 0;
Josef Sipekd28c9172006-12-08 02:37:25 -08002333 struct inode *inode = in->f_path.dentry->d_inode;
Tiger Yang8659ac22006-10-17 18:29:52 -07002334
2335 mlog_entry("(0x%p, 0x%p, %u, '%.*s')\n", in, pipe,
2336 (unsigned int)len,
Josef Sipekd28c9172006-12-08 02:37:25 -08002337 in->f_path.dentry->d_name.len,
2338 in->f_path.dentry->d_name.name);
Tiger Yang8659ac22006-10-17 18:29:52 -07002339
2340 /*
2341 * See the comment in ocfs2_file_aio_read()
2342 */
Tao Ma1962f392009-06-19 15:36:52 +08002343 ret = ocfs2_inode_lock_atime(inode, in->f_vfsmnt, &lock_level);
Tiger Yang8659ac22006-10-17 18:29:52 -07002344 if (ret < 0) {
2345 mlog_errno(ret);
2346 goto bail;
2347 }
Tao Ma1962f392009-06-19 15:36:52 +08002348 ocfs2_inode_unlock(inode, lock_level);
Tiger Yang8659ac22006-10-17 18:29:52 -07002349
2350 ret = generic_file_splice_read(in, ppos, pipe, len, flags);
2351
2352bail:
2353 mlog_exit(ret);
2354 return ret;
2355}
2356
Mark Fashehccd979b2005-12-15 14:31:24 -08002357static ssize_t ocfs2_file_aio_read(struct kiocb *iocb,
Badari Pulavarty027445c2006-09-30 23:28:46 -07002358 const struct iovec *iov,
2359 unsigned long nr_segs,
Mark Fashehccd979b2005-12-15 14:31:24 -08002360 loff_t pos)
2361{
Tiger Yang25899de2006-11-15 15:49:02 +08002362 int ret = 0, rw_level = -1, have_alloc_sem = 0, lock_level = 0;
Mark Fashehccd979b2005-12-15 14:31:24 -08002363 struct file *filp = iocb->ki_filp;
Josef Sipekd28c9172006-12-08 02:37:25 -08002364 struct inode *inode = filp->f_path.dentry->d_inode;
Mark Fashehccd979b2005-12-15 14:31:24 -08002365
Badari Pulavarty027445c2006-09-30 23:28:46 -07002366 mlog_entry("(0x%p, %u, '%.*s')\n", filp,
2367 (unsigned int)nr_segs,
Josef Sipekd28c9172006-12-08 02:37:25 -08002368 filp->f_path.dentry->d_name.len,
2369 filp->f_path.dentry->d_name.name);
Mark Fashehccd979b2005-12-15 14:31:24 -08002370
2371 if (!inode) {
2372 ret = -EINVAL;
2373 mlog_errno(ret);
2374 goto bail;
2375 }
2376
Sunil Mushran2bd63212010-01-25 16:57:38 -08002377 /*
Mark Fashehccd979b2005-12-15 14:31:24 -08002378 * buffered reads protect themselves in ->readpage(). O_DIRECT reads
2379 * need locks to protect pending reads from racing with truncate.
2380 */
2381 if (filp->f_flags & O_DIRECT) {
2382 down_read(&inode->i_alloc_sem);
2383 have_alloc_sem = 1;
2384
2385 ret = ocfs2_rw_lock(inode, 0);
2386 if (ret < 0) {
2387 mlog_errno(ret);
2388 goto bail;
2389 }
2390 rw_level = 0;
2391 /* communicate with ocfs2_dio_end_io */
Mark Fasheh7cdfc3a2007-04-16 17:28:51 -07002392 ocfs2_iocb_set_rw_locked(iocb, rw_level);
Mark Fashehccd979b2005-12-15 14:31:24 -08002393 }
2394
Mark Fashehc4374f82006-05-05 19:04:35 -07002395 /*
2396 * We're fine letting folks race truncates and extending
2397 * writes with read across the cluster, just like they can
2398 * locally. Hence no rw_lock during read.
Sunil Mushran2bd63212010-01-25 16:57:38 -08002399 *
Mark Fashehc4374f82006-05-05 19:04:35 -07002400 * Take and drop the meta data lock to update inode fields
2401 * like i_size. This allows the checks down below
Sunil Mushran2bd63212010-01-25 16:57:38 -08002402 * generic_file_aio_read() a chance of actually working.
Mark Fashehc4374f82006-05-05 19:04:35 -07002403 */
Mark Fashehe63aecb62007-10-18 15:30:42 -07002404 ret = ocfs2_inode_lock_atime(inode, filp->f_vfsmnt, &lock_level);
Mark Fashehc4374f82006-05-05 19:04:35 -07002405 if (ret < 0) {
2406 mlog_errno(ret);
2407 goto bail;
2408 }
Mark Fashehe63aecb62007-10-18 15:30:42 -07002409 ocfs2_inode_unlock(inode, lock_level);
Mark Fashehc4374f82006-05-05 19:04:35 -07002410
Badari Pulavarty027445c2006-09-30 23:28:46 -07002411 ret = generic_file_aio_read(iocb, iov, nr_segs, iocb->ki_pos);
Mark Fashehccd979b2005-12-15 14:31:24 -08002412 if (ret == -EINVAL)
Sunil Mushran56753bd2008-06-09 11:24:41 -07002413 mlog(0, "generic_file_aio_read returned -EINVAL\n");
Mark Fashehccd979b2005-12-15 14:31:24 -08002414
2415 /* buffered aio wouldn't have proper lock coverage today */
2416 BUG_ON(ret == -EIOCBQUEUED && !(filp->f_flags & O_DIRECT));
2417
2418 /* see ocfs2_file_aio_write */
2419 if (ret == -EIOCBQUEUED || !ocfs2_iocb_is_rw_locked(iocb)) {
2420 rw_level = -1;
2421 have_alloc_sem = 0;
2422 }
2423
2424bail:
2425 if (have_alloc_sem)
2426 up_read(&inode->i_alloc_sem);
Sunil Mushran2bd63212010-01-25 16:57:38 -08002427 if (rw_level != -1)
Mark Fashehccd979b2005-12-15 14:31:24 -08002428 ocfs2_rw_unlock(inode, rw_level);
2429 mlog_exit(ret);
2430
2431 return ret;
2432}
2433
Arjan van de Ven92e1d5b2007-02-12 00:55:39 -08002434const struct inode_operations ocfs2_file_iops = {
Mark Fashehccd979b2005-12-15 14:31:24 -08002435 .setattr = ocfs2_setattr,
2436 .getattr = ocfs2_getattr,
Tiger Yangd38eb8d2006-11-27 09:59:21 +08002437 .permission = ocfs2_permission,
Tiger Yangcf1d6c72008-08-18 17:11:00 +08002438 .setxattr = generic_setxattr,
2439 .getxattr = generic_getxattr,
2440 .listxattr = ocfs2_listxattr,
2441 .removexattr = generic_removexattr,
Mark Fasheh385820a2007-07-19 00:14:38 -07002442 .fallocate = ocfs2_fallocate,
Mark Fasheh00dc4172008-10-03 17:32:11 -04002443 .fiemap = ocfs2_fiemap,
Mark Fashehccd979b2005-12-15 14:31:24 -08002444};
2445
Arjan van de Ven92e1d5b2007-02-12 00:55:39 -08002446const struct inode_operations ocfs2_special_file_iops = {
Mark Fashehccd979b2005-12-15 14:31:24 -08002447 .setattr = ocfs2_setattr,
2448 .getattr = ocfs2_getattr,
Tiger Yangd38eb8d2006-11-27 09:59:21 +08002449 .permission = ocfs2_permission,
Mark Fashehccd979b2005-12-15 14:31:24 -08002450};
2451
Mark Fasheh53da4932008-07-21 14:29:16 -07002452/*
2453 * Other than ->lock, keep ocfs2_fops and ocfs2_dops in sync with
2454 * ocfs2_fops_no_plocks and ocfs2_dops_no_plocks!
2455 */
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -08002456const struct file_operations ocfs2_fops = {
Jan Kara32c3c0e2007-12-19 15:24:52 +01002457 .llseek = generic_file_llseek,
Mark Fashehccd979b2005-12-15 14:31:24 -08002458 .read = do_sync_read,
2459 .write = do_sync_write,
Mark Fashehccd979b2005-12-15 14:31:24 -08002460 .mmap = ocfs2_mmap,
2461 .fsync = ocfs2_sync_file,
2462 .release = ocfs2_file_release,
2463 .open = ocfs2_file_open,
2464 .aio_read = ocfs2_file_aio_read,
2465 .aio_write = ocfs2_file_aio_write,
Andi Kleenc9ec1482008-01-27 03:17:17 +01002466 .unlocked_ioctl = ocfs2_ioctl,
Mark Fasheh586d2322007-03-09 15:56:28 -08002467#ifdef CONFIG_COMPAT
2468 .compat_ioctl = ocfs2_compat_ioctl,
2469#endif
Mark Fasheh53da4932008-07-21 14:29:16 -07002470 .lock = ocfs2_lock,
2471 .flock = ocfs2_flock,
2472 .splice_read = ocfs2_file_splice_read,
2473 .splice_write = ocfs2_file_splice_write,
2474};
2475
2476const struct file_operations ocfs2_dops = {
2477 .llseek = generic_file_llseek,
2478 .read = generic_read_dir,
2479 .readdir = ocfs2_readdir,
2480 .fsync = ocfs2_sync_file,
2481 .release = ocfs2_dir_release,
2482 .open = ocfs2_dir_open,
2483 .unlocked_ioctl = ocfs2_ioctl,
2484#ifdef CONFIG_COMPAT
2485 .compat_ioctl = ocfs2_compat_ioctl,
2486#endif
2487 .lock = ocfs2_lock,
2488 .flock = ocfs2_flock,
2489};
2490
2491/*
2492 * POSIX-lockless variants of our file_operations.
2493 *
2494 * These will be used if the underlying cluster stack does not support
2495 * posix file locking, if the user passes the "localflocks" mount
2496 * option, or if we have a local-only fs.
2497 *
2498 * ocfs2_flock is in here because all stacks handle UNIX file locks,
2499 * so we still want it in the case of no stack support for
2500 * plocks. Internally, it will do the right thing when asked to ignore
2501 * the cluster.
2502 */
2503const struct file_operations ocfs2_fops_no_plocks = {
2504 .llseek = generic_file_llseek,
2505 .read = do_sync_read,
2506 .write = do_sync_write,
2507 .mmap = ocfs2_mmap,
2508 .fsync = ocfs2_sync_file,
2509 .release = ocfs2_file_release,
2510 .open = ocfs2_file_open,
2511 .aio_read = ocfs2_file_aio_read,
2512 .aio_write = ocfs2_file_aio_write,
2513 .unlocked_ioctl = ocfs2_ioctl,
2514#ifdef CONFIG_COMPAT
2515 .compat_ioctl = ocfs2_compat_ioctl,
2516#endif
Mark Fasheh53fc6222007-12-20 16:49:04 -08002517 .flock = ocfs2_flock,
Tiger Yang8659ac22006-10-17 18:29:52 -07002518 .splice_read = ocfs2_file_splice_read,
2519 .splice_write = ocfs2_file_splice_write,
Mark Fashehccd979b2005-12-15 14:31:24 -08002520};
2521
Mark Fasheh53da4932008-07-21 14:29:16 -07002522const struct file_operations ocfs2_dops_no_plocks = {
Jan Kara32c3c0e2007-12-19 15:24:52 +01002523 .llseek = generic_file_llseek,
Mark Fashehccd979b2005-12-15 14:31:24 -08002524 .read = generic_read_dir,
2525 .readdir = ocfs2_readdir,
2526 .fsync = ocfs2_sync_file,
Mark Fasheh53fc6222007-12-20 16:49:04 -08002527 .release = ocfs2_dir_release,
2528 .open = ocfs2_dir_open,
Andi Kleenc9ec1482008-01-27 03:17:17 +01002529 .unlocked_ioctl = ocfs2_ioctl,
Mark Fasheh586d2322007-03-09 15:56:28 -08002530#ifdef CONFIG_COMPAT
2531 .compat_ioctl = ocfs2_compat_ioctl,
2532#endif
Mark Fasheh53fc6222007-12-20 16:49:04 -08002533 .flock = ocfs2_flock,
Mark Fashehccd979b2005-12-15 14:31:24 -08002534};