blob: 5920159a421f609d4c6710662b2a6506afc355d1 [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;
Joel Becker54532582010-07-16 13:32:33 -0700770 int ret = 0;
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 Becker56934862010-07-01 15:13:31 -0700790 mlog(0,
791 "abs_from = %llu, abs_to = %llu, index = %lu, zero_from = %u, zero_to = %u\n",
792 (unsigned long long)abs_from, (unsigned long long)abs_to,
793 index, zero_from, zero_to);
794
Joel Beckera4bfb4c2010-07-06 14:36:06 -0700795 /* We know that zero_from is block aligned */
796 for (block_start = zero_from; block_start < zero_to;
797 block_start = block_end) {
798 block_end = block_start + (1 << inode->i_blkbits);
799
800 /*
801 * block_start is block-aligned. Bump it by one to
802 * force ocfs2_{prepare,commit}_write() to zero the
803 * whole block.
804 */
805 ret = ocfs2_prepare_write_nolock(inode, page,
806 block_start + 1,
807 block_start + 1);
808 if (ret < 0) {
809 mlog_errno(ret);
Mark Fashehccd979b2005-12-15 14:31:24 -0800810 goto out_unlock;
811 }
Mark Fashehccd979b2005-12-15 14:31:24 -0800812
Joel Beckera4bfb4c2010-07-06 14:36:06 -0700813 if (!handle) {
814 handle = ocfs2_zero_start_ordered_transaction(inode);
815 if (IS_ERR(handle)) {
816 ret = PTR_ERR(handle);
817 handle = NULL;
818 break;
819 }
820 }
821
822 /* must not update i_size! */
823 ret = block_commit_write(page, block_start + 1,
824 block_start + 1);
825 if (ret < 0)
826 mlog_errno(ret);
827 else
828 ret = 0;
829 }
Mark Fashehccd979b2005-12-15 14:31:24 -0800830
831 if (handle)
Mark Fasheh02dc1af2006-10-09 16:48:10 -0700832 ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
Joel Beckera4bfb4c2010-07-06 14:36:06 -0700833
Mark Fashehccd979b2005-12-15 14:31:24 -0800834out_unlock:
835 unlock_page(page);
836 page_cache_release(page);
837out:
838 return ret;
839}
840
Joel Becker56934862010-07-01 15:13:31 -0700841/*
842 * Find the next range to zero. We do this in terms of bytes because
843 * that's what ocfs2_zero_extend() wants, and it is dealing with the
844 * pagecache. We may return multiple extents.
845 *
846 * zero_start and zero_end are ocfs2_zero_extend()s current idea of what
847 * needs to be zeroed. range_start and range_end return the next zeroing
848 * range. A subsequent call should pass the previous range_end as its
849 * zero_start. If range_end is 0, there's nothing to do.
850 *
851 * Unwritten extents are skipped over. Refcounted extents are CoWd.
852 */
853static int ocfs2_zero_extend_get_range(struct inode *inode,
854 struct buffer_head *di_bh,
855 u64 zero_start, u64 zero_end,
856 u64 *range_start, u64 *range_end)
Mark Fashehccd979b2005-12-15 14:31:24 -0800857{
Joel Becker56934862010-07-01 15:13:31 -0700858 int rc = 0, needs_cow = 0;
859 u32 p_cpos, zero_clusters = 0;
860 u32 zero_cpos =
861 zero_start >> OCFS2_SB(inode->i_sb)->s_clustersize_bits;
862 u32 last_cpos = ocfs2_clusters_for_bytes(inode->i_sb, zero_end);
863 unsigned int num_clusters = 0;
864 unsigned int ext_flags = 0;
Mark Fashehccd979b2005-12-15 14:31:24 -0800865
Joel Becker56934862010-07-01 15:13:31 -0700866 while (zero_cpos < last_cpos) {
867 rc = ocfs2_get_clusters(inode, zero_cpos, &p_cpos,
868 &num_clusters, &ext_flags);
869 if (rc) {
870 mlog_errno(rc);
Mark Fashehccd979b2005-12-15 14:31:24 -0800871 goto out;
872 }
873
Joel Becker56934862010-07-01 15:13:31 -0700874 if (p_cpos && !(ext_flags & OCFS2_EXT_UNWRITTEN)) {
875 zero_clusters = num_clusters;
876 if (ext_flags & OCFS2_EXT_REFCOUNTED)
877 needs_cow = 1;
878 break;
879 }
880
881 zero_cpos += num_clusters;
882 }
883 if (!zero_clusters) {
884 *range_end = 0;
885 goto out;
886 }
887
888 while ((zero_cpos + zero_clusters) < last_cpos) {
889 rc = ocfs2_get_clusters(inode, zero_cpos + zero_clusters,
890 &p_cpos, &num_clusters,
891 &ext_flags);
892 if (rc) {
893 mlog_errno(rc);
894 goto out;
895 }
896
897 if (!p_cpos || (ext_flags & OCFS2_EXT_UNWRITTEN))
898 break;
899 if (ext_flags & OCFS2_EXT_REFCOUNTED)
900 needs_cow = 1;
901 zero_clusters += num_clusters;
902 }
903 if ((zero_cpos + zero_clusters) > last_cpos)
904 zero_clusters = last_cpos - zero_cpos;
905
906 if (needs_cow) {
907 rc = ocfs2_refcount_cow(inode, di_bh, zero_cpos, zero_clusters,
908 UINT_MAX);
909 if (rc) {
910 mlog_errno(rc);
911 goto out;
912 }
913 }
914
915 *range_start = ocfs2_clusters_to_bytes(inode->i_sb, zero_cpos);
916 *range_end = ocfs2_clusters_to_bytes(inode->i_sb,
917 zero_cpos + zero_clusters);
918
919out:
920 return rc;
921}
922
923/*
924 * Zero one range returned from ocfs2_zero_extend_get_range(). The caller
925 * has made sure that the entire range needs zeroing.
926 */
927static int ocfs2_zero_extend_range(struct inode *inode, u64 range_start,
928 u64 range_end)
929{
930 int rc = 0;
931 u64 next_pos;
932 u64 zero_pos = range_start;
933
934 mlog(0, "range_start = %llu, range_end = %llu\n",
935 (unsigned long long)range_start,
936 (unsigned long long)range_end);
937 BUG_ON(range_start >= range_end);
938
939 while (zero_pos < range_end) {
940 next_pos = (zero_pos & PAGE_CACHE_MASK) + PAGE_CACHE_SIZE;
941 if (next_pos > range_end)
942 next_pos = range_end;
943 rc = ocfs2_write_zero_page(inode, zero_pos, next_pos);
944 if (rc < 0) {
945 mlog_errno(rc);
946 break;
947 }
948 zero_pos = next_pos;
Mark Fashehe2057c52006-10-03 17:53:05 -0700949
950 /*
951 * Very large extends have the potential to lock up
952 * the cpu for extended periods of time.
953 */
954 cond_resched();
Mark Fashehccd979b2005-12-15 14:31:24 -0800955 }
956
Joel Becker56934862010-07-01 15:13:31 -0700957 return rc;
958}
959
960int ocfs2_zero_extend(struct inode *inode, struct buffer_head *di_bh,
961 loff_t zero_to_size)
962{
963 int ret = 0;
964 u64 zero_start, range_start = 0, range_end = 0;
965 struct super_block *sb = inode->i_sb;
966
967 zero_start = ocfs2_align_bytes_to_blocks(sb, i_size_read(inode));
968 mlog(0, "zero_start %llu for i_size %llu\n",
969 (unsigned long long)zero_start,
970 (unsigned long long)i_size_read(inode));
971 while (zero_start < zero_to_size) {
972 ret = ocfs2_zero_extend_get_range(inode, di_bh, zero_start,
973 zero_to_size,
974 &range_start,
975 &range_end);
976 if (ret) {
977 mlog_errno(ret);
978 break;
979 }
980 if (!range_end)
981 break;
982 /* Trim the ends */
983 if (range_start < zero_start)
984 range_start = zero_start;
985 if (range_end > zero_to_size)
986 range_end = zero_to_size;
987
988 ret = ocfs2_zero_extend_range(inode, range_start,
989 range_end);
990 if (ret) {
991 mlog_errno(ret);
992 break;
993 }
994 zero_start = range_end;
995 }
996
Mark Fashehccd979b2005-12-15 14:31:24 -0800997 return ret;
998}
999
Joel Becker56934862010-07-01 15:13:31 -07001000int ocfs2_extend_no_holes(struct inode *inode, struct buffer_head *di_bh,
1001 u64 new_i_size, u64 zero_to)
Mark Fasheh65ed39d2007-08-28 17:13:23 -07001002{
1003 int ret;
1004 u32 clusters_to_add;
1005 struct ocfs2_inode_info *oi = OCFS2_I(inode);
1006
Joel Becker56934862010-07-01 15:13:31 -07001007 /*
1008 * Only quota files call this without a bh, and they can't be
1009 * refcounted.
1010 */
1011 BUG_ON(!di_bh && (oi->ip_dyn_features & OCFS2_HAS_REFCOUNT_FL));
1012 BUG_ON(!di_bh && !(oi->ip_flags & OCFS2_INODE_SYSTEM_FILE));
1013
Mark Fasheh65ed39d2007-08-28 17:13:23 -07001014 clusters_to_add = ocfs2_clusters_for_bytes(inode->i_sb, new_i_size);
1015 if (clusters_to_add < oi->ip_clusters)
1016 clusters_to_add = 0;
1017 else
1018 clusters_to_add -= oi->ip_clusters;
1019
1020 if (clusters_to_add) {
1021 ret = __ocfs2_extend_allocation(inode, oi->ip_clusters,
1022 clusters_to_add, 0);
1023 if (ret) {
1024 mlog_errno(ret);
1025 goto out;
1026 }
1027 }
1028
1029 /*
1030 * Call this even if we don't add any clusters to the tree. We
1031 * still need to zero the area between the old i_size and the
1032 * new i_size.
1033 */
Joel Becker56934862010-07-01 15:13:31 -07001034 ret = ocfs2_zero_extend(inode, di_bh, zero_to);
Mark Fasheh65ed39d2007-08-28 17:13:23 -07001035 if (ret < 0)
1036 mlog_errno(ret);
1037
1038out:
1039 return ret;
1040}
1041
Mark Fashehccd979b2005-12-15 14:31:24 -08001042static int ocfs2_extend_file(struct inode *inode,
1043 struct buffer_head *di_bh,
Mark Fasheh65ed39d2007-08-28 17:13:23 -07001044 u64 new_i_size)
Mark Fashehccd979b2005-12-15 14:31:24 -08001045{
Mark Fashehc934a922007-10-18 15:23:46 -07001046 int ret = 0;
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001047 struct ocfs2_inode_info *oi = OCFS2_I(inode);
Mark Fashehccd979b2005-12-15 14:31:24 -08001048
Mark Fasheh65ed39d2007-08-28 17:13:23 -07001049 BUG_ON(!di_bh);
Mark Fasheh53013cb2006-05-05 19:04:03 -07001050
Mark Fashehccd979b2005-12-15 14:31:24 -08001051 /* setattr sometimes calls us like this. */
1052 if (new_i_size == 0)
1053 goto out;
1054
1055 if (i_size_read(inode) == new_i_size)
Joel Becker56934862010-07-01 15:13:31 -07001056 goto out;
Mark Fashehccd979b2005-12-15 14:31:24 -08001057 BUG_ON(new_i_size < i_size_read(inode));
1058
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001059 /*
Mark Fasheh65ed39d2007-08-28 17:13:23 -07001060 * The alloc sem blocks people in read/write from reading our
1061 * allocation until we're done changing it. We depend on
1062 * i_mutex to block other extend/truncate calls while we're
Joel Becker56934862010-07-01 15:13:31 -07001063 * here. We even have to hold it for sparse files because there
1064 * might be some tail zeroing.
Mark Fasheh0effef72006-10-03 17:44:42 -07001065 */
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001066 down_write(&oi->ip_alloc_sem);
1067
1068 if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
1069 /*
1070 * We can optimize small extends by keeping the inodes
1071 * inline data.
1072 */
1073 if (ocfs2_size_fits_inline_data(di_bh, new_i_size)) {
1074 up_write(&oi->ip_alloc_sem);
1075 goto out_update_size;
1076 }
1077
1078 ret = ocfs2_convert_inline_data_to_extents(inode, di_bh);
1079 if (ret) {
1080 up_write(&oi->ip_alloc_sem);
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001081 mlog_errno(ret);
Mark Fashehc934a922007-10-18 15:23:46 -07001082 goto out;
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001083 }
1084 }
1085
Joel Becker56934862010-07-01 15:13:31 -07001086 if (ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb)))
1087 ret = ocfs2_zero_extend(inode, di_bh, new_i_size);
1088 else
1089 ret = ocfs2_extend_no_holes(inode, di_bh, new_i_size,
1090 new_i_size);
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001091
1092 up_write(&oi->ip_alloc_sem);
Mark Fasheh65ed39d2007-08-28 17:13:23 -07001093
Mark Fasheh0effef72006-10-03 17:44:42 -07001094 if (ret < 0) {
1095 mlog_errno(ret);
Mark Fashehc934a922007-10-18 15:23:46 -07001096 goto out;
Mark Fashehccd979b2005-12-15 14:31:24 -08001097 }
1098
Mark Fasheh3a0782d2007-01-17 12:53:31 -08001099out_update_size:
Mark Fasheh65ed39d2007-08-28 17:13:23 -07001100 ret = ocfs2_simple_size_update(inode, di_bh, new_i_size);
1101 if (ret < 0)
1102 mlog_errno(ret);
Mark Fasheh53013cb2006-05-05 19:04:03 -07001103
Mark Fashehccd979b2005-12-15 14:31:24 -08001104out:
1105 return ret;
1106}
1107
1108int ocfs2_setattr(struct dentry *dentry, struct iattr *attr)
1109{
1110 int status = 0, size_change;
1111 struct inode *inode = dentry->d_inode;
1112 struct super_block *sb = inode->i_sb;
1113 struct ocfs2_super *osb = OCFS2_SB(sb);
1114 struct buffer_head *bh = NULL;
Mark Fasheh1fabe142006-10-09 18:11:45 -07001115 handle_t *handle = NULL;
Jan Kara65bac572009-06-02 14:24:01 +02001116 struct dquot *transfer_to[MAXQUOTAS] = { };
Jan Kara52a9ee22010-05-13 20:18:45 +02001117 int qtype;
Mark Fashehccd979b2005-12-15 14:31:24 -08001118
1119 mlog_entry("(0x%p, '%.*s')\n", dentry,
1120 dentry->d_name.len, dentry->d_name.name);
1121
Sunil Mushranbc535802008-04-18 10:23:53 -07001122 /* ensuring we don't even attempt to truncate a symlink */
1123 if (S_ISLNK(inode->i_mode))
1124 attr->ia_valid &= ~ATTR_SIZE;
1125
Mark Fashehccd979b2005-12-15 14:31:24 -08001126 if (attr->ia_valid & ATTR_MODE)
1127 mlog(0, "mode change: %d\n", attr->ia_mode);
1128 if (attr->ia_valid & ATTR_UID)
1129 mlog(0, "uid change: %d\n", attr->ia_uid);
1130 if (attr->ia_valid & ATTR_GID)
1131 mlog(0, "gid change: %d\n", attr->ia_gid);
1132 if (attr->ia_valid & ATTR_SIZE)
1133 mlog(0, "size change...\n");
1134 if (attr->ia_valid & (ATTR_ATIME | ATTR_MTIME | ATTR_CTIME))
1135 mlog(0, "time change...\n");
1136
1137#define OCFS2_VALID_ATTRS (ATTR_ATIME | ATTR_MTIME | ATTR_CTIME | ATTR_SIZE \
1138 | ATTR_GID | ATTR_UID | ATTR_MODE)
1139 if (!(attr->ia_valid & OCFS2_VALID_ATTRS)) {
1140 mlog(0, "can't handle attrs: 0x%x\n", attr->ia_valid);
1141 return 0;
1142 }
1143
1144 status = inode_change_ok(inode, attr);
1145 if (status)
1146 return status;
1147
Dmitry Monakhov12755622010-04-08 22:04:20 +04001148 if (is_quota_modification(inode, attr))
1149 dquot_initialize(inode);
Mark Fashehccd979b2005-12-15 14:31:24 -08001150 size_change = S_ISREG(inode->i_mode) && attr->ia_valid & ATTR_SIZE;
1151 if (size_change) {
1152 status = ocfs2_rw_lock(inode, 1);
1153 if (status < 0) {
1154 mlog_errno(status);
1155 goto bail;
1156 }
1157 }
1158
Mark Fashehe63aecb62007-10-18 15:30:42 -07001159 status = ocfs2_inode_lock(inode, &bh, 1);
Mark Fashehccd979b2005-12-15 14:31:24 -08001160 if (status < 0) {
1161 if (status != -ENOENT)
1162 mlog_errno(status);
1163 goto bail_unlock_rw;
1164 }
1165
1166 if (size_change && attr->ia_size != i_size_read(inode)) {
Wengang Wang5051f762010-02-26 18:18:25 +08001167 status = inode_newsize_ok(inode, attr->ia_size);
1168 if (status)
Mark Fashehce76fd32007-07-20 12:02:14 -07001169 goto bail_unlock;
Mark Fashehce76fd32007-07-20 12:02:14 -07001170
Joel Becker2b4e30f2008-09-03 20:03:41 -07001171 if (i_size_read(inode) > attr->ia_size) {
1172 if (ocfs2_should_order_data(inode)) {
1173 status = ocfs2_begin_ordered_truncate(inode,
1174 attr->ia_size);
1175 if (status)
1176 goto bail_unlock;
1177 }
Mark Fashehccd979b2005-12-15 14:31:24 -08001178 status = ocfs2_truncate_file(inode, bh, attr->ia_size);
Joel Becker2b4e30f2008-09-03 20:03:41 -07001179 } else
Mark Fasheh65ed39d2007-08-28 17:13:23 -07001180 status = ocfs2_extend_file(inode, bh, attr->ia_size);
Mark Fashehccd979b2005-12-15 14:31:24 -08001181 if (status < 0) {
1182 if (status != -ENOSPC)
1183 mlog_errno(status);
1184 status = -ENOSPC;
1185 goto bail_unlock;
1186 }
1187 }
1188
Jan Karaa90714c2008-10-09 19:38:40 +02001189 if ((attr->ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid) ||
1190 (attr->ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid)) {
Jan Kara65bac572009-06-02 14:24:01 +02001191 /*
1192 * Gather pointers to quota structures so that allocation /
1193 * freeing of quota structures happens here and not inside
Christoph Hellwigb43fa822010-03-03 09:05:03 -05001194 * dquot_transfer() where we have problems with lock ordering
Jan Kara65bac572009-06-02 14:24:01 +02001195 */
Jan Karaa90714c2008-10-09 19:38:40 +02001196 if (attr->ia_valid & ATTR_UID && attr->ia_uid != inode->i_uid
1197 && OCFS2_HAS_RO_COMPAT_FEATURE(sb,
1198 OCFS2_FEATURE_RO_COMPAT_USRQUOTA)) {
Jan Kara65bac572009-06-02 14:24:01 +02001199 transfer_to[USRQUOTA] = dqget(sb, attr->ia_uid,
1200 USRQUOTA);
Jan Kara52a9ee22010-05-13 20:18:45 +02001201 if (!transfer_to[USRQUOTA]) {
Jan Kara65bac572009-06-02 14:24:01 +02001202 status = -ESRCH;
Jan Karaa90714c2008-10-09 19:38:40 +02001203 goto bail_unlock;
Jan Kara65bac572009-06-02 14:24:01 +02001204 }
Jan Karaa90714c2008-10-09 19:38:40 +02001205 }
1206 if (attr->ia_valid & ATTR_GID && attr->ia_gid != inode->i_gid
1207 && OCFS2_HAS_RO_COMPAT_FEATURE(sb,
1208 OCFS2_FEATURE_RO_COMPAT_GRPQUOTA)) {
Jan Kara65bac572009-06-02 14:24:01 +02001209 transfer_to[GRPQUOTA] = dqget(sb, attr->ia_gid,
1210 GRPQUOTA);
Jan Kara52a9ee22010-05-13 20:18:45 +02001211 if (!transfer_to[GRPQUOTA]) {
Jan Kara65bac572009-06-02 14:24:01 +02001212 status = -ESRCH;
Jan Karaa90714c2008-10-09 19:38:40 +02001213 goto bail_unlock;
Jan Kara65bac572009-06-02 14:24:01 +02001214 }
Jan Karaa90714c2008-10-09 19:38:40 +02001215 }
Jan Kara65bac572009-06-02 14:24:01 +02001216 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS +
1217 2 * ocfs2_quota_trans_credits(sb));
Jan Karaa90714c2008-10-09 19:38:40 +02001218 if (IS_ERR(handle)) {
1219 status = PTR_ERR(handle);
1220 mlog_errno(status);
1221 goto bail_unlock;
1222 }
Jan Kara52a9ee22010-05-13 20:18:45 +02001223 status = __dquot_transfer(inode, transfer_to);
Jan Karaa90714c2008-10-09 19:38:40 +02001224 if (status < 0)
1225 goto bail_commit;
1226 } else {
1227 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
1228 if (IS_ERR(handle)) {
1229 status = PTR_ERR(handle);
1230 mlog_errno(status);
1231 goto bail_unlock;
1232 }
Mark Fashehccd979b2005-12-15 14:31:24 -08001233 }
1234
Mark Fasheh7307de82007-05-09 15:16:19 -07001235 /*
Christoph Hellwig2c27c652010-06-04 11:30:04 +02001236 * This will intentionally not wind up calling truncate_setsize(),
Mark Fasheh7307de82007-05-09 15:16:19 -07001237 * since all the work for a size change has been done above.
1238 * Otherwise, we could get into problems with truncate as
1239 * ip_alloc_sem is used there to protect against i_size
1240 * changes.
Christoph Hellwig10257742010-06-04 11:30:02 +02001241 *
1242 * XXX: this means the conditional below can probably be removed.
Mark Fasheh7307de82007-05-09 15:16:19 -07001243 */
Christoph Hellwig10257742010-06-04 11:30:02 +02001244 if ((attr->ia_valid & ATTR_SIZE) &&
1245 attr->ia_size != i_size_read(inode)) {
1246 status = vmtruncate(inode, attr->ia_size);
1247 if (status) {
1248 mlog_errno(status);
1249 goto bail_commit;
1250 }
Mark Fashehccd979b2005-12-15 14:31:24 -08001251 }
1252
Christoph Hellwig10257742010-06-04 11:30:02 +02001253 setattr_copy(inode, attr);
1254 mark_inode_dirty(inode);
1255
Mark Fashehccd979b2005-12-15 14:31:24 -08001256 status = ocfs2_mark_inode_dirty(handle, inode, bh);
1257 if (status < 0)
1258 mlog_errno(status);
1259
1260bail_commit:
Mark Fasheh02dc1af2006-10-09 16:48:10 -07001261 ocfs2_commit_trans(osb, handle);
Mark Fashehccd979b2005-12-15 14:31:24 -08001262bail_unlock:
Mark Fashehe63aecb62007-10-18 15:30:42 -07001263 ocfs2_inode_unlock(inode, 1);
Mark Fashehccd979b2005-12-15 14:31:24 -08001264bail_unlock_rw:
1265 if (size_change)
1266 ocfs2_rw_unlock(inode, 1);
1267bail:
Mark Fasheha81cb882008-10-07 14:25:16 -07001268 brelse(bh);
Mark Fashehccd979b2005-12-15 14:31:24 -08001269
Jan Kara65bac572009-06-02 14:24:01 +02001270 /* Release quota pointers in case we acquired them */
Jan Kara52a9ee22010-05-13 20:18:45 +02001271 for (qtype = 0; qtype < MAXQUOTAS; qtype++)
Jan Kara65bac572009-06-02 14:24:01 +02001272 dqput(transfer_to[qtype]);
Jan Kara65bac572009-06-02 14:24:01 +02001273
Tiger Yang060bc662008-11-14 11:17:29 +08001274 if (!status && attr->ia_valid & ATTR_MODE) {
1275 status = ocfs2_acl_chmod(inode);
1276 if (status < 0)
1277 mlog_errno(status);
1278 }
1279
Mark Fashehccd979b2005-12-15 14:31:24 -08001280 mlog_exit(status);
1281 return status;
1282}
1283
1284int ocfs2_getattr(struct vfsmount *mnt,
1285 struct dentry *dentry,
1286 struct kstat *stat)
1287{
1288 struct inode *inode = dentry->d_inode;
1289 struct super_block *sb = dentry->d_inode->i_sb;
1290 struct ocfs2_super *osb = sb->s_fs_info;
1291 int err;
1292
1293 mlog_entry_void();
1294
1295 err = ocfs2_inode_revalidate(dentry);
1296 if (err) {
1297 if (err != -ENOENT)
1298 mlog_errno(err);
1299 goto bail;
1300 }
1301
1302 generic_fillattr(inode, stat);
1303
1304 /* We set the blksize from the cluster size for performance */
1305 stat->blksize = osb->s_clustersize;
1306
1307bail:
1308 mlog_exit(err);
1309
1310 return err;
1311}
1312
Al Viroe6305c42008-07-15 21:03:57 -04001313int ocfs2_permission(struct inode *inode, int mask)
Tiger Yangd38eb8d2006-11-27 09:59:21 +08001314{
1315 int ret;
1316
1317 mlog_entry_void();
1318
Mark Fashehe63aecb62007-10-18 15:30:42 -07001319 ret = ocfs2_inode_lock(inode, NULL, 0);
Tiger Yangd38eb8d2006-11-27 09:59:21 +08001320 if (ret) {
Mark Fasheha9f5f702007-04-26 11:43:43 -07001321 if (ret != -ENOENT)
1322 mlog_errno(ret);
Tiger Yangd38eb8d2006-11-27 09:59:21 +08001323 goto out;
1324 }
1325
Tiger Yang23fc2702008-11-14 11:17:18 +08001326 ret = generic_permission(inode, mask, ocfs2_check_acl);
Tiger Yangd38eb8d2006-11-27 09:59:21 +08001327
Mark Fashehe63aecb62007-10-18 15:30:42 -07001328 ocfs2_inode_unlock(inode, 0);
Tiger Yangd38eb8d2006-11-27 09:59:21 +08001329out:
1330 mlog_exit(ret);
1331 return ret;
1332}
1333
Mark Fashehb2580102007-03-09 16:53:21 -08001334static int __ocfs2_write_remove_suid(struct inode *inode,
1335 struct buffer_head *bh)
Mark Fashehccd979b2005-12-15 14:31:24 -08001336{
1337 int ret;
Mark Fasheh1fabe142006-10-09 18:11:45 -07001338 handle_t *handle;
Mark Fashehccd979b2005-12-15 14:31:24 -08001339 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1340 struct ocfs2_dinode *di;
1341
Mark Fashehb06970532006-03-03 10:24:33 -08001342 mlog_entry("(Inode %llu, mode 0%o)\n",
Mark Fashehb2580102007-03-09 16:53:21 -08001343 (unsigned long long)OCFS2_I(inode)->ip_blkno, inode->i_mode);
Mark Fashehccd979b2005-12-15 14:31:24 -08001344
Mark Fasheh65eff9c2006-10-09 17:26:22 -07001345 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
Jan Karafa38e922008-10-20 19:23:51 +02001346 if (IS_ERR(handle)) {
1347 ret = PTR_ERR(handle);
Mark Fashehccd979b2005-12-15 14:31:24 -08001348 mlog_errno(ret);
1349 goto out;
1350 }
1351
Joel Becker0cf2f762009-02-12 16:41:25 -08001352 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), bh,
Joel Becker13723d02008-10-17 19:25:01 -07001353 OCFS2_JOURNAL_ACCESS_WRITE);
Mark Fashehccd979b2005-12-15 14:31:24 -08001354 if (ret < 0) {
1355 mlog_errno(ret);
Mark Fashehb2580102007-03-09 16:53:21 -08001356 goto out_trans;
Mark Fashehccd979b2005-12-15 14:31:24 -08001357 }
1358
1359 inode->i_mode &= ~S_ISUID;
1360 if ((inode->i_mode & S_ISGID) && (inode->i_mode & S_IXGRP))
1361 inode->i_mode &= ~S_ISGID;
1362
1363 di = (struct ocfs2_dinode *) bh->b_data;
1364 di->i_mode = cpu_to_le16(inode->i_mode);
1365
Joel Beckerec20cec2010-03-19 14:13:52 -07001366 ocfs2_journal_dirty(handle, bh);
Mark Fashehb2580102007-03-09 16:53:21 -08001367
Mark Fashehccd979b2005-12-15 14:31:24 -08001368out_trans:
Mark Fasheh02dc1af2006-10-09 16:48:10 -07001369 ocfs2_commit_trans(osb, handle);
Mark Fashehccd979b2005-12-15 14:31:24 -08001370out:
1371 mlog_exit(ret);
1372 return ret;
1373}
1374
Mark Fasheh9517bac2007-02-09 20:24:12 -08001375/*
1376 * Will look for holes and unwritten extents in the range starting at
1377 * pos for count bytes (inclusive).
1378 */
1379static int ocfs2_check_range_for_holes(struct inode *inode, loff_t pos,
1380 size_t count)
1381{
1382 int ret = 0;
Mark Fasheh49cb8d22007-03-09 16:21:46 -08001383 unsigned int extent_flags;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001384 u32 cpos, clusters, extent_len, phys_cpos;
1385 struct super_block *sb = inode->i_sb;
1386
1387 cpos = pos >> OCFS2_SB(sb)->s_clustersize_bits;
1388 clusters = ocfs2_clusters_for_bytes(sb, pos + count) - cpos;
1389
1390 while (clusters) {
Mark Fasheh49cb8d22007-03-09 16:21:46 -08001391 ret = ocfs2_get_clusters(inode, cpos, &phys_cpos, &extent_len,
1392 &extent_flags);
Mark Fasheh9517bac2007-02-09 20:24:12 -08001393 if (ret < 0) {
1394 mlog_errno(ret);
1395 goto out;
1396 }
1397
Mark Fasheh49cb8d22007-03-09 16:21:46 -08001398 if (phys_cpos == 0 || (extent_flags & OCFS2_EXT_UNWRITTEN)) {
Mark Fasheh9517bac2007-02-09 20:24:12 -08001399 ret = 1;
1400 break;
1401 }
1402
1403 if (extent_len > clusters)
1404 extent_len = clusters;
1405
1406 clusters -= extent_len;
1407 cpos += extent_len;
1408 }
1409out:
1410 return ret;
1411}
1412
Mark Fashehb2580102007-03-09 16:53:21 -08001413static int ocfs2_write_remove_suid(struct inode *inode)
1414{
1415 int ret;
1416 struct buffer_head *bh = NULL;
Mark Fashehb2580102007-03-09 16:53:21 -08001417
Joel Beckerb657c952008-11-13 14:49:11 -08001418 ret = ocfs2_read_inode_block(inode, &bh);
Mark Fashehb2580102007-03-09 16:53:21 -08001419 if (ret < 0) {
1420 mlog_errno(ret);
1421 goto out;
1422 }
1423
1424 ret = __ocfs2_write_remove_suid(inode, bh);
1425out:
1426 brelse(bh);
1427 return ret;
1428}
1429
Mark Fasheh2ae99a62007-03-09 16:43:28 -08001430/*
1431 * Allocate enough extents to cover the region starting at byte offset
1432 * start for len bytes. Existing extents are skipped, any extents
1433 * added are marked as "unwritten".
1434 */
1435static int ocfs2_allocate_unwritten_extents(struct inode *inode,
1436 u64 start, u64 len)
1437{
1438 int ret;
1439 u32 cpos, phys_cpos, clusters, alloc_size;
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001440 u64 end = start + len;
1441 struct buffer_head *di_bh = NULL;
1442
1443 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
Joel Beckerb657c952008-11-13 14:49:11 -08001444 ret = ocfs2_read_inode_block(inode, &di_bh);
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001445 if (ret) {
1446 mlog_errno(ret);
1447 goto out;
1448 }
1449
1450 /*
1451 * Nothing to do if the requested reservation range
1452 * fits within the inode.
1453 */
1454 if (ocfs2_size_fits_inline_data(di_bh, end))
1455 goto out;
1456
1457 ret = ocfs2_convert_inline_data_to_extents(inode, di_bh);
1458 if (ret) {
1459 mlog_errno(ret);
1460 goto out;
1461 }
1462 }
Mark Fasheh2ae99a62007-03-09 16:43:28 -08001463
1464 /*
1465 * We consider both start and len to be inclusive.
1466 */
1467 cpos = start >> OCFS2_SB(inode->i_sb)->s_clustersize_bits;
1468 clusters = ocfs2_clusters_for_bytes(inode->i_sb, start + len);
1469 clusters -= cpos;
1470
1471 while (clusters) {
1472 ret = ocfs2_get_clusters(inode, cpos, &phys_cpos,
1473 &alloc_size, NULL);
1474 if (ret) {
1475 mlog_errno(ret);
1476 goto out;
1477 }
1478
1479 /*
1480 * Hole or existing extent len can be arbitrary, so
1481 * cap it to our own allocation request.
1482 */
1483 if (alloc_size > clusters)
1484 alloc_size = clusters;
1485
1486 if (phys_cpos) {
1487 /*
1488 * We already have an allocation at this
1489 * region so we can safely skip it.
1490 */
1491 goto next;
1492 }
1493
1494 ret = __ocfs2_extend_allocation(inode, cpos, alloc_size, 1);
1495 if (ret) {
1496 if (ret != -ENOSPC)
1497 mlog_errno(ret);
1498 goto out;
1499 }
1500
1501next:
1502 cpos += alloc_size;
1503 clusters -= alloc_size;
1504 }
1505
1506 ret = 0;
1507out:
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001508
1509 brelse(di_bh);
Mark Fasheh2ae99a62007-03-09 16:43:28 -08001510 return ret;
1511}
1512
Mark Fasheh063c4562007-07-03 13:34:11 -07001513/*
1514 * Truncate a byte range, avoiding pages within partial clusters. This
1515 * preserves those pages for the zeroing code to write to.
1516 */
1517static void ocfs2_truncate_cluster_pages(struct inode *inode, u64 byte_start,
1518 u64 byte_len)
1519{
1520 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1521 loff_t start, end;
1522 struct address_space *mapping = inode->i_mapping;
1523
1524 start = (loff_t)ocfs2_align_bytes_to_clusters(inode->i_sb, byte_start);
1525 end = byte_start + byte_len;
1526 end = end & ~(osb->s_clustersize - 1);
1527
1528 if (start < end) {
1529 unmap_mapping_range(mapping, start, end - start, 0);
1530 truncate_inode_pages_range(mapping, start, end - 1);
1531 }
1532}
1533
1534static int ocfs2_zero_partial_clusters(struct inode *inode,
1535 u64 start, u64 len)
1536{
1537 int ret = 0;
1538 u64 tmpend, end = start + len;
1539 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1540 unsigned int csize = osb->s_clustersize;
1541 handle_t *handle;
1542
1543 /*
1544 * The "start" and "end" values are NOT necessarily part of
1545 * the range whose allocation is being deleted. Rather, this
1546 * is what the user passed in with the request. We must zero
1547 * partial clusters here. There's no need to worry about
1548 * physical allocation - the zeroing code knows to skip holes.
1549 */
1550 mlog(0, "byte start: %llu, end: %llu\n",
1551 (unsigned long long)start, (unsigned long long)end);
1552
1553 /*
1554 * If both edges are on a cluster boundary then there's no
1555 * zeroing required as the region is part of the allocation to
1556 * be truncated.
1557 */
1558 if ((start & (csize - 1)) == 0 && (end & (csize - 1)) == 0)
1559 goto out;
1560
1561 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
Jan Karafa38e922008-10-20 19:23:51 +02001562 if (IS_ERR(handle)) {
1563 ret = PTR_ERR(handle);
Mark Fasheh063c4562007-07-03 13:34:11 -07001564 mlog_errno(ret);
1565 goto out;
1566 }
1567
1568 /*
1569 * We want to get the byte offset of the end of the 1st cluster.
1570 */
1571 tmpend = (u64)osb->s_clustersize + (start & ~(osb->s_clustersize - 1));
1572 if (tmpend > end)
1573 tmpend = end;
1574
1575 mlog(0, "1st range: start: %llu, tmpend: %llu\n",
1576 (unsigned long long)start, (unsigned long long)tmpend);
1577
1578 ret = ocfs2_zero_range_for_truncate(inode, handle, start, tmpend);
1579 if (ret)
1580 mlog_errno(ret);
1581
1582 if (tmpend < end) {
1583 /*
1584 * This may make start and end equal, but the zeroing
1585 * code will skip any work in that case so there's no
1586 * need to catch it up here.
1587 */
1588 start = end & ~(osb->s_clustersize - 1);
1589
1590 mlog(0, "2nd range: start: %llu, end: %llu\n",
1591 (unsigned long long)start, (unsigned long long)end);
1592
1593 ret = ocfs2_zero_range_for_truncate(inode, handle, start, end);
1594 if (ret)
1595 mlog_errno(ret);
1596 }
1597
1598 ocfs2_commit_trans(osb, handle);
1599out:
1600 return ret;
1601}
1602
Tristan Yec1631d42010-05-11 17:54:45 +08001603static int ocfs2_find_rec(struct ocfs2_extent_list *el, u32 pos)
1604{
1605 int i;
1606 struct ocfs2_extent_rec *rec = NULL;
1607
1608 for (i = le16_to_cpu(el->l_next_free_rec) - 1; i >= 0; i--) {
1609
1610 rec = &el->l_recs[i];
1611
1612 if (le32_to_cpu(rec->e_cpos) < pos)
1613 break;
1614 }
1615
1616 return i;
1617}
1618
1619/*
1620 * Helper to calculate the punching pos and length in one run, we handle the
1621 * following three cases in order:
1622 *
1623 * - remove the entire record
1624 * - remove a partial record
1625 * - no record needs to be removed (hole-punching completed)
1626*/
1627static void ocfs2_calc_trunc_pos(struct inode *inode,
1628 struct ocfs2_extent_list *el,
1629 struct ocfs2_extent_rec *rec,
1630 u32 trunc_start, u32 *trunc_cpos,
1631 u32 *trunc_len, u32 *trunc_end,
1632 u64 *blkno, int *done)
1633{
1634 int ret = 0;
1635 u32 coff, range;
1636
1637 range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
1638
1639 if (le32_to_cpu(rec->e_cpos) >= trunc_start) {
1640 *trunc_cpos = le32_to_cpu(rec->e_cpos);
1641 /*
1642 * Skip holes if any.
1643 */
1644 if (range < *trunc_end)
1645 *trunc_end = range;
1646 *trunc_len = *trunc_end - le32_to_cpu(rec->e_cpos);
1647 *blkno = le64_to_cpu(rec->e_blkno);
1648 *trunc_end = le32_to_cpu(rec->e_cpos);
1649 } else if (range > trunc_start) {
1650 *trunc_cpos = trunc_start;
1651 *trunc_len = *trunc_end - trunc_start;
1652 coff = trunc_start - le32_to_cpu(rec->e_cpos);
1653 *blkno = le64_to_cpu(rec->e_blkno) +
1654 ocfs2_clusters_to_blocks(inode->i_sb, coff);
1655 *trunc_end = trunc_start;
1656 } else {
1657 /*
1658 * It may have two following possibilities:
1659 *
1660 * - last record has been removed
1661 * - trunc_start was within a hole
1662 *
1663 * both two cases mean the completion of hole punching.
1664 */
1665 ret = 1;
1666 }
1667
1668 *done = ret;
1669}
1670
Mark Fasheh063c4562007-07-03 13:34:11 -07001671static int ocfs2_remove_inode_range(struct inode *inode,
1672 struct buffer_head *di_bh, u64 byte_start,
1673 u64 byte_len)
1674{
Tristan Yec1631d42010-05-11 17:54:45 +08001675 int ret = 0, flags = 0, done = 0, i;
1676 u32 trunc_start, trunc_len, trunc_end, trunc_cpos, phys_cpos;
1677 u32 cluster_in_el;
Mark Fasheh063c4562007-07-03 13:34:11 -07001678 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1679 struct ocfs2_cached_dealloc_ctxt dealloc;
Mark Fashehb1967d02007-11-20 11:56:39 -08001680 struct address_space *mapping = inode->i_mapping;
Mark Fashehfecc0112008-11-12 15:16:38 -08001681 struct ocfs2_extent_tree et;
Tristan Yec1631d42010-05-11 17:54:45 +08001682 struct ocfs2_path *path = NULL;
1683 struct ocfs2_extent_list *el = NULL;
1684 struct ocfs2_extent_rec *rec = NULL;
Tristan Yee8aec062010-05-11 17:54:43 +08001685 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
Tristan Yec1631d42010-05-11 17:54:45 +08001686 u64 blkno, refcount_loc = le64_to_cpu(di->i_refcount_loc);
Mark Fasheh063c4562007-07-03 13:34:11 -07001687
Joel Becker5e404e92009-02-13 03:54:22 -08001688 ocfs2_init_dinode_extent_tree(&et, INODE_CACHE(inode), di_bh);
Mark Fasheh063c4562007-07-03 13:34:11 -07001689 ocfs2_init_dealloc_ctxt(&dealloc);
1690
1691 if (byte_len == 0)
1692 return 0;
1693
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001694 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
1695 ret = ocfs2_truncate_inline(inode, di_bh, byte_start,
Mark Fashehb1967d02007-11-20 11:56:39 -08001696 byte_start + byte_len, 0);
1697 if (ret) {
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001698 mlog_errno(ret);
Mark Fashehb1967d02007-11-20 11:56:39 -08001699 goto out;
1700 }
1701 /*
1702 * There's no need to get fancy with the page cache
1703 * truncate of an inline-data inode. We're talking
1704 * about less than a page here, which will be cached
1705 * in the dinode buffer anyway.
1706 */
1707 unmap_mapping_range(mapping, 0, 0, 0);
1708 truncate_inode_pages(mapping, 0);
1709 goto out;
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001710 }
1711
Tristan Yee8aec062010-05-11 17:54:43 +08001712 /*
1713 * For reflinks, we may need to CoW 2 clusters which might be
1714 * partially zero'd later, if hole's start and end offset were
1715 * within one cluster(means is not exactly aligned to clustersize).
1716 */
Mark Fasheh063c4562007-07-03 13:34:11 -07001717
Tristan Yee8aec062010-05-11 17:54:43 +08001718 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_HAS_REFCOUNT_FL) {
1719
1720 ret = ocfs2_cow_file_pos(inode, di_bh, byte_start);
1721 if (ret) {
1722 mlog_errno(ret);
1723 goto out;
1724 }
1725
1726 ret = ocfs2_cow_file_pos(inode, di_bh, byte_start + byte_len);
1727 if (ret) {
1728 mlog_errno(ret);
1729 goto out;
1730 }
1731 }
1732
Mark Fasheh063c4562007-07-03 13:34:11 -07001733 trunc_start = ocfs2_clusters_for_bytes(osb->sb, byte_start);
Tristan Yec1631d42010-05-11 17:54:45 +08001734 trunc_end = (byte_start + byte_len) >> osb->s_clustersize_bits;
1735 cluster_in_el = trunc_end;
Mark Fasheh063c4562007-07-03 13:34:11 -07001736
Tristan Yec1631d42010-05-11 17:54:45 +08001737 mlog(0, "Inode: %llu, start: %llu, len: %llu, cstart: %u, cend: %u\n",
Mark Fasheh063c4562007-07-03 13:34:11 -07001738 (unsigned long long)OCFS2_I(inode)->ip_blkno,
1739 (unsigned long long)byte_start,
Tristan Yec1631d42010-05-11 17:54:45 +08001740 (unsigned long long)byte_len, trunc_start, trunc_end);
Mark Fasheh063c4562007-07-03 13:34:11 -07001741
1742 ret = ocfs2_zero_partial_clusters(inode, byte_start, byte_len);
1743 if (ret) {
1744 mlog_errno(ret);
1745 goto out;
1746 }
1747
Tristan Yec1631d42010-05-11 17:54:45 +08001748 path = ocfs2_new_path_from_et(&et);
1749 if (!path) {
1750 ret = -ENOMEM;
1751 mlog_errno(ret);
1752 goto out;
1753 }
1754
1755 while (trunc_end > trunc_start) {
1756
1757 ret = ocfs2_find_path(INODE_CACHE(inode), path,
1758 cluster_in_el);
Mark Fasheh063c4562007-07-03 13:34:11 -07001759 if (ret) {
1760 mlog_errno(ret);
1761 goto out;
1762 }
1763
Tristan Yec1631d42010-05-11 17:54:45 +08001764 el = path_leaf_el(path);
Mark Fasheh063c4562007-07-03 13:34:11 -07001765
Tristan Yec1631d42010-05-11 17:54:45 +08001766 i = ocfs2_find_rec(el, trunc_end);
1767 /*
1768 * Need to go to previous extent block.
1769 */
1770 if (i < 0) {
1771 if (path->p_tree_depth == 0)
1772 break;
1773
1774 ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb,
1775 path,
1776 &cluster_in_el);
Mark Fasheh063c4562007-07-03 13:34:11 -07001777 if (ret) {
1778 mlog_errno(ret);
1779 goto out;
1780 }
Tristan Yec1631d42010-05-11 17:54:45 +08001781
1782 /*
1783 * We've reached the leftmost extent block,
1784 * it's safe to leave.
1785 */
1786 if (cluster_in_el == 0)
1787 break;
1788
1789 /*
1790 * The 'pos' searched for previous extent block is
1791 * always one cluster less than actual trunc_end.
1792 */
1793 trunc_end = cluster_in_el + 1;
1794
1795 ocfs2_reinit_path(path, 1);
1796
1797 continue;
1798
1799 } else
1800 rec = &el->l_recs[i];
1801
1802 ocfs2_calc_trunc_pos(inode, el, rec, trunc_start, &trunc_cpos,
1803 &trunc_len, &trunc_end, &blkno, &done);
1804 if (done)
1805 break;
1806
1807 flags = rec->e_flags;
1808 phys_cpos = ocfs2_blocks_to_clusters(inode->i_sb, blkno);
1809
1810 ret = ocfs2_remove_btree_range(inode, &et, trunc_cpos,
1811 phys_cpos, trunc_len, flags,
1812 &dealloc, refcount_loc);
1813 if (ret < 0) {
1814 mlog_errno(ret);
1815 goto out;
Mark Fasheh063c4562007-07-03 13:34:11 -07001816 }
1817
Tristan Yec1631d42010-05-11 17:54:45 +08001818 cluster_in_el = trunc_end;
1819
1820 ocfs2_reinit_path(path, 1);
Mark Fasheh063c4562007-07-03 13:34:11 -07001821 }
1822
1823 ocfs2_truncate_cluster_pages(inode, byte_start, byte_len);
1824
1825out:
1826 ocfs2_schedule_truncate_log_flush(osb, 1);
1827 ocfs2_run_deallocs(osb, &dealloc);
1828
1829 return ret;
1830}
1831
Mark Fashehb2580102007-03-09 16:53:21 -08001832/*
1833 * Parts of this function taken from xfs_change_file_space()
1834 */
Mark Fasheh385820a2007-07-19 00:14:38 -07001835static int __ocfs2_change_file_space(struct file *file, struct inode *inode,
1836 loff_t f_pos, unsigned int cmd,
1837 struct ocfs2_space_resv *sr,
1838 int change_size)
Mark Fashehb2580102007-03-09 16:53:21 -08001839{
1840 int ret;
1841 s64 llen;
Mark Fasheh385820a2007-07-19 00:14:38 -07001842 loff_t size;
Mark Fashehb2580102007-03-09 16:53:21 -08001843 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1844 struct buffer_head *di_bh = NULL;
1845 handle_t *handle;
Mark Fasheha00cce32007-07-20 11:28:30 -07001846 unsigned long long max_off = inode->i_sb->s_maxbytes;
Mark Fashehb2580102007-03-09 16:53:21 -08001847
Mark Fashehb2580102007-03-09 16:53:21 -08001848 if (ocfs2_is_hard_readonly(osb) || ocfs2_is_soft_readonly(osb))
1849 return -EROFS;
1850
1851 mutex_lock(&inode->i_mutex);
1852
1853 /*
1854 * This prevents concurrent writes on other nodes
1855 */
1856 ret = ocfs2_rw_lock(inode, 1);
1857 if (ret) {
1858 mlog_errno(ret);
1859 goto out;
1860 }
1861
Mark Fashehe63aecb62007-10-18 15:30:42 -07001862 ret = ocfs2_inode_lock(inode, &di_bh, 1);
Mark Fashehb2580102007-03-09 16:53:21 -08001863 if (ret) {
1864 mlog_errno(ret);
1865 goto out_rw_unlock;
1866 }
1867
1868 if (inode->i_flags & (S_IMMUTABLE|S_APPEND)) {
1869 ret = -EPERM;
Mark Fashehe63aecb62007-10-18 15:30:42 -07001870 goto out_inode_unlock;
Mark Fashehb2580102007-03-09 16:53:21 -08001871 }
1872
1873 switch (sr->l_whence) {
1874 case 0: /*SEEK_SET*/
1875 break;
1876 case 1: /*SEEK_CUR*/
Mark Fasheh385820a2007-07-19 00:14:38 -07001877 sr->l_start += f_pos;
Mark Fashehb2580102007-03-09 16:53:21 -08001878 break;
1879 case 2: /*SEEK_END*/
1880 sr->l_start += i_size_read(inode);
1881 break;
1882 default:
1883 ret = -EINVAL;
Mark Fashehe63aecb62007-10-18 15:30:42 -07001884 goto out_inode_unlock;
Mark Fashehb2580102007-03-09 16:53:21 -08001885 }
1886 sr->l_whence = 0;
1887
1888 llen = sr->l_len > 0 ? sr->l_len - 1 : sr->l_len;
1889
1890 if (sr->l_start < 0
1891 || sr->l_start > max_off
1892 || (sr->l_start + llen) < 0
1893 || (sr->l_start + llen) > max_off) {
1894 ret = -EINVAL;
Mark Fashehe63aecb62007-10-18 15:30:42 -07001895 goto out_inode_unlock;
Mark Fashehb2580102007-03-09 16:53:21 -08001896 }
Mark Fasheh385820a2007-07-19 00:14:38 -07001897 size = sr->l_start + sr->l_len;
Mark Fashehb2580102007-03-09 16:53:21 -08001898
1899 if (cmd == OCFS2_IOC_RESVSP || cmd == OCFS2_IOC_RESVSP64) {
1900 if (sr->l_len <= 0) {
1901 ret = -EINVAL;
Mark Fashehe63aecb62007-10-18 15:30:42 -07001902 goto out_inode_unlock;
Mark Fashehb2580102007-03-09 16:53:21 -08001903 }
1904 }
1905
Mark Fasheh385820a2007-07-19 00:14:38 -07001906 if (file && should_remove_suid(file->f_path.dentry)) {
Mark Fashehb2580102007-03-09 16:53:21 -08001907 ret = __ocfs2_write_remove_suid(inode, di_bh);
1908 if (ret) {
1909 mlog_errno(ret);
Mark Fashehe63aecb62007-10-18 15:30:42 -07001910 goto out_inode_unlock;
Mark Fashehb2580102007-03-09 16:53:21 -08001911 }
1912 }
1913
1914 down_write(&OCFS2_I(inode)->ip_alloc_sem);
1915 switch (cmd) {
1916 case OCFS2_IOC_RESVSP:
1917 case OCFS2_IOC_RESVSP64:
1918 /*
1919 * This takes unsigned offsets, but the signed ones we
1920 * pass have been checked against overflow above.
1921 */
1922 ret = ocfs2_allocate_unwritten_extents(inode, sr->l_start,
1923 sr->l_len);
1924 break;
1925 case OCFS2_IOC_UNRESVSP:
1926 case OCFS2_IOC_UNRESVSP64:
1927 ret = ocfs2_remove_inode_range(inode, di_bh, sr->l_start,
1928 sr->l_len);
1929 break;
1930 default:
1931 ret = -EINVAL;
1932 }
1933 up_write(&OCFS2_I(inode)->ip_alloc_sem);
1934 if (ret) {
1935 mlog_errno(ret);
Mark Fashehe63aecb62007-10-18 15:30:42 -07001936 goto out_inode_unlock;
Mark Fashehb2580102007-03-09 16:53:21 -08001937 }
1938
1939 /*
1940 * We update c/mtime for these changes
1941 */
1942 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
1943 if (IS_ERR(handle)) {
1944 ret = PTR_ERR(handle);
1945 mlog_errno(ret);
Mark Fashehe63aecb62007-10-18 15:30:42 -07001946 goto out_inode_unlock;
Mark Fashehb2580102007-03-09 16:53:21 -08001947 }
1948
Mark Fasheh385820a2007-07-19 00:14:38 -07001949 if (change_size && i_size_read(inode) < size)
1950 i_size_write(inode, size);
1951
Mark Fashehb2580102007-03-09 16:53:21 -08001952 inode->i_ctime = inode->i_mtime = CURRENT_TIME;
1953 ret = ocfs2_mark_inode_dirty(handle, inode, di_bh);
1954 if (ret < 0)
1955 mlog_errno(ret);
1956
1957 ocfs2_commit_trans(osb, handle);
1958
Mark Fashehe63aecb62007-10-18 15:30:42 -07001959out_inode_unlock:
Mark Fashehb2580102007-03-09 16:53:21 -08001960 brelse(di_bh);
Mark Fashehe63aecb62007-10-18 15:30:42 -07001961 ocfs2_inode_unlock(inode, 1);
Mark Fashehb2580102007-03-09 16:53:21 -08001962out_rw_unlock:
1963 ocfs2_rw_unlock(inode, 1);
1964
Mark Fashehb2580102007-03-09 16:53:21 -08001965out:
Julia Lawallc259ae52008-07-21 09:59:15 +02001966 mutex_unlock(&inode->i_mutex);
Mark Fashehb2580102007-03-09 16:53:21 -08001967 return ret;
1968}
1969
Mark Fasheh385820a2007-07-19 00:14:38 -07001970int ocfs2_change_file_space(struct file *file, unsigned int cmd,
1971 struct ocfs2_space_resv *sr)
1972{
1973 struct inode *inode = file->f_path.dentry->d_inode;
Fernando Carrijoc19a28e2009-01-07 18:09:08 -08001974 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
Mark Fasheh385820a2007-07-19 00:14:38 -07001975
1976 if ((cmd == OCFS2_IOC_RESVSP || cmd == OCFS2_IOC_RESVSP64) &&
1977 !ocfs2_writes_unwritten_extents(osb))
1978 return -ENOTTY;
1979 else if ((cmd == OCFS2_IOC_UNRESVSP || cmd == OCFS2_IOC_UNRESVSP64) &&
1980 !ocfs2_sparse_alloc(osb))
1981 return -ENOTTY;
1982
1983 if (!S_ISREG(inode->i_mode))
1984 return -EINVAL;
1985
1986 if (!(file->f_mode & FMODE_WRITE))
1987 return -EBADF;
1988
1989 return __ocfs2_change_file_space(file, inode, file->f_pos, cmd, sr, 0);
1990}
1991
1992static long ocfs2_fallocate(struct inode *inode, int mode, loff_t offset,
1993 loff_t len)
1994{
1995 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1996 struct ocfs2_space_resv sr;
1997 int change_size = 1;
1998
1999 if (!ocfs2_writes_unwritten_extents(osb))
2000 return -EOPNOTSUPP;
2001
2002 if (S_ISDIR(inode->i_mode))
2003 return -ENODEV;
2004
2005 if (mode & FALLOC_FL_KEEP_SIZE)
2006 change_size = 0;
2007
2008 sr.l_whence = 0;
2009 sr.l_start = (s64)offset;
2010 sr.l_len = (s64)len;
2011
2012 return __ocfs2_change_file_space(NULL, inode, offset,
2013 OCFS2_IOC_RESVSP64, &sr, change_size);
2014}
2015
Tao Ma293b2f72009-08-25 08:02:48 +08002016int ocfs2_check_range_for_refcount(struct inode *inode, loff_t pos,
2017 size_t count)
2018{
2019 int ret = 0;
2020 unsigned int extent_flags;
2021 u32 cpos, clusters, extent_len, phys_cpos;
2022 struct super_block *sb = inode->i_sb;
2023
2024 if (!ocfs2_refcount_tree(OCFS2_SB(inode->i_sb)) ||
Tao Ma2f48d592009-10-15 11:10:49 +08002025 !(OCFS2_I(inode)->ip_dyn_features & OCFS2_HAS_REFCOUNT_FL) ||
2026 OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL)
Tao Ma293b2f72009-08-25 08:02:48 +08002027 return 0;
2028
2029 cpos = pos >> OCFS2_SB(sb)->s_clustersize_bits;
2030 clusters = ocfs2_clusters_for_bytes(sb, pos + count) - cpos;
2031
2032 while (clusters) {
2033 ret = ocfs2_get_clusters(inode, cpos, &phys_cpos, &extent_len,
2034 &extent_flags);
2035 if (ret < 0) {
2036 mlog_errno(ret);
2037 goto out;
2038 }
2039
2040 if (phys_cpos && (extent_flags & OCFS2_EXT_REFCOUNTED)) {
2041 ret = 1;
2042 break;
2043 }
2044
2045 if (extent_len > clusters)
2046 extent_len = clusters;
2047
2048 clusters -= extent_len;
2049 cpos += extent_len;
2050 }
2051out:
2052 return ret;
2053}
2054
2055static int ocfs2_prepare_inode_for_refcount(struct inode *inode,
Tao Mab8908232010-08-12 10:27:14 +08002056 struct file *file,
Tao Ma293b2f72009-08-25 08:02:48 +08002057 loff_t pos, size_t count,
2058 int *meta_level)
2059{
2060 int ret;
2061 struct buffer_head *di_bh = NULL;
2062 u32 cpos = pos >> OCFS2_SB(inode->i_sb)->s_clustersize_bits;
2063 u32 clusters =
2064 ocfs2_clusters_for_bytes(inode->i_sb, pos + count) - cpos;
2065
2066 ret = ocfs2_inode_lock(inode, &di_bh, 1);
2067 if (ret) {
2068 mlog_errno(ret);
2069 goto out;
2070 }
2071
2072 *meta_level = 1;
2073
Tao Ma37f8a2b2009-08-26 09:47:28 +08002074 ret = ocfs2_refcount_cow(inode, di_bh, cpos, clusters, UINT_MAX);
Tao Ma293b2f72009-08-25 08:02:48 +08002075 if (ret)
2076 mlog_errno(ret);
2077out:
2078 brelse(di_bh);
2079 return ret;
2080}
2081
Tao Mab8908232010-08-12 10:27:14 +08002082static int ocfs2_prepare_inode_for_write(struct file *file,
Tiger Yang8659ac22006-10-17 18:29:52 -07002083 loff_t *ppos,
2084 size_t count,
Mark Fasheh9517bac2007-02-09 20:24:12 -08002085 int appending,
Tao Ma86470e92009-12-03 21:55:05 +08002086 int *direct_io,
2087 int *has_refcount)
Mark Fashehccd979b2005-12-15 14:31:24 -08002088{
Mark Fasheh65ed39d2007-08-28 17:13:23 -07002089 int ret = 0, meta_level = 0;
Tao Mab8908232010-08-12 10:27:14 +08002090 struct dentry *dentry = file->f_path.dentry;
Tiger Yang8659ac22006-10-17 18:29:52 -07002091 struct inode *inode = dentry->d_inode;
Mark Fasheh65ed39d2007-08-28 17:13:23 -07002092 loff_t saved_pos, end;
Mark Fashehccd979b2005-12-15 14:31:24 -08002093
Sunil Mushran2bd63212010-01-25 16:57:38 -08002094 /*
Mark Fasheh65ed39d2007-08-28 17:13:23 -07002095 * We start with a read level meta lock and only jump to an ex
2096 * if we need to make modifications here.
Mark Fashehccd979b2005-12-15 14:31:24 -08002097 */
Mark Fashehccd979b2005-12-15 14:31:24 -08002098 for(;;) {
Mark Fashehe63aecb62007-10-18 15:30:42 -07002099 ret = ocfs2_inode_lock(inode, NULL, meta_level);
Mark Fashehccd979b2005-12-15 14:31:24 -08002100 if (ret < 0) {
2101 meta_level = -1;
2102 mlog_errno(ret);
2103 goto out;
2104 }
2105
2106 /* Clear suid / sgid if necessary. We do this here
2107 * instead of later in the write path because
2108 * remove_suid() calls ->setattr without any hint that
2109 * we may have already done our cluster locking. Since
2110 * ocfs2_setattr() *must* take cluster locks to
2111 * proceeed, this will lead us to recursively lock the
2112 * inode. There's also the dinode i_size state which
2113 * can be lost via setattr during extending writes (we
2114 * set inode->i_size at the end of a write. */
Tiger Yang8659ac22006-10-17 18:29:52 -07002115 if (should_remove_suid(dentry)) {
Mark Fashehccd979b2005-12-15 14:31:24 -08002116 if (meta_level == 0) {
Mark Fashehe63aecb62007-10-18 15:30:42 -07002117 ocfs2_inode_unlock(inode, meta_level);
Mark Fashehccd979b2005-12-15 14:31:24 -08002118 meta_level = 1;
2119 continue;
2120 }
2121
2122 ret = ocfs2_write_remove_suid(inode);
2123 if (ret < 0) {
2124 mlog_errno(ret);
Tiger Yang8659ac22006-10-17 18:29:52 -07002125 goto out_unlock;
Mark Fashehccd979b2005-12-15 14:31:24 -08002126 }
2127 }
2128
2129 /* work on a copy of ppos until we're sure that we won't have
2130 * to recalculate it due to relocking. */
Tiger Yang8659ac22006-10-17 18:29:52 -07002131 if (appending) {
Mark Fashehccd979b2005-12-15 14:31:24 -08002132 saved_pos = i_size_read(inode);
2133 mlog(0, "O_APPEND: inode->i_size=%llu\n", saved_pos);
2134 } else {
Tiger Yang8659ac22006-10-17 18:29:52 -07002135 saved_pos = *ppos;
Mark Fashehccd979b2005-12-15 14:31:24 -08002136 }
Mark Fasheh3a0782d2007-01-17 12:53:31 -08002137
Mark Fasheh65ed39d2007-08-28 17:13:23 -07002138 end = saved_pos + count;
Mark Fasheh9517bac2007-02-09 20:24:12 -08002139
Tao Ma293b2f72009-08-25 08:02:48 +08002140 ret = ocfs2_check_range_for_refcount(inode, saved_pos, count);
2141 if (ret == 1) {
2142 ocfs2_inode_unlock(inode, meta_level);
2143 meta_level = -1;
2144
2145 ret = ocfs2_prepare_inode_for_refcount(inode,
Tao Mab8908232010-08-12 10:27:14 +08002146 file,
Tao Ma293b2f72009-08-25 08:02:48 +08002147 saved_pos,
2148 count,
2149 &meta_level);
Tao Ma86470e92009-12-03 21:55:05 +08002150 if (has_refcount)
2151 *has_refcount = 1;
Wengang Wang96a1cc72010-02-09 14:57:45 +08002152 if (direct_io)
2153 *direct_io = 0;
Tao Ma293b2f72009-08-25 08:02:48 +08002154 }
2155
2156 if (ret < 0) {
2157 mlog_errno(ret);
2158 goto out_unlock;
2159 }
2160
Mark Fasheh65ed39d2007-08-28 17:13:23 -07002161 /*
2162 * Skip the O_DIRECT checks if we don't need
2163 * them.
2164 */
2165 if (!direct_io || !(*direct_io))
2166 break;
Mark Fasheh9517bac2007-02-09 20:24:12 -08002167
Mark Fasheh65ed39d2007-08-28 17:13:23 -07002168 /*
Mark Fasheh1afc32b2007-09-07 14:46:51 -07002169 * There's no sane way to do direct writes to an inode
2170 * with inline data.
2171 */
2172 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
2173 *direct_io = 0;
2174 break;
2175 }
2176
2177 /*
Mark Fasheh65ed39d2007-08-28 17:13:23 -07002178 * Allowing concurrent direct writes means
2179 * i_size changes wouldn't be synchronized, so
2180 * one node could wind up truncating another
2181 * nodes writes.
2182 */
2183 if (end > i_size_read(inode)) {
2184 *direct_io = 0;
Mark Fasheh9517bac2007-02-09 20:24:12 -08002185 break;
2186 }
2187
Mark Fasheh3a0782d2007-01-17 12:53:31 -08002188 /*
Mark Fasheh65ed39d2007-08-28 17:13:23 -07002189 * We don't fill holes during direct io, so
2190 * check for them here. If any are found, the
2191 * caller will have to retake some cluster
2192 * locks and initiate the io as buffered.
Mark Fasheh3a0782d2007-01-17 12:53:31 -08002193 */
Mark Fasheh65ed39d2007-08-28 17:13:23 -07002194 ret = ocfs2_check_range_for_holes(inode, saved_pos, count);
2195 if (ret == 1) {
2196 *direct_io = 0;
2197 ret = 0;
2198 } else if (ret < 0)
2199 mlog_errno(ret);
Mark Fashehccd979b2005-12-15 14:31:24 -08002200 break;
2201 }
2202
Tiger Yang8659ac22006-10-17 18:29:52 -07002203 if (appending)
2204 *ppos = saved_pos;
2205
2206out_unlock:
Tao Ma293b2f72009-08-25 08:02:48 +08002207 if (meta_level >= 0)
2208 ocfs2_inode_unlock(inode, meta_level);
Tiger Yang8659ac22006-10-17 18:29:52 -07002209
2210out:
2211 return ret;
2212}
2213
2214static ssize_t ocfs2_file_aio_write(struct kiocb *iocb,
2215 const struct iovec *iov,
2216 unsigned long nr_segs,
2217 loff_t pos)
2218{
Mark Fasheh9517bac2007-02-09 20:24:12 -08002219 int ret, direct_io, appending, rw_level, have_alloc_sem = 0;
Tao Ma86470e92009-12-03 21:55:05 +08002220 int can_do_direct, has_refcount = 0;
Mark Fasheh9517bac2007-02-09 20:24:12 -08002221 ssize_t written = 0;
2222 size_t ocount; /* original count */
2223 size_t count; /* after file limit checks */
Mark Fasheh9ea2d322007-10-18 14:14:45 -07002224 loff_t old_size, *ppos = &iocb->ki_pos;
2225 u32 old_clusters;
Mark Fasheh9517bac2007-02-09 20:24:12 -08002226 struct file *file = iocb->ki_filp;
2227 struct inode *inode = file->f_path.dentry->d_inode;
Mark Fasheh9ea2d322007-10-18 14:14:45 -07002228 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
Tiger Yang8659ac22006-10-17 18:29:52 -07002229
Mark Fasheh9517bac2007-02-09 20:24:12 -08002230 mlog_entry("(0x%p, %u, '%.*s')\n", file,
Tiger Yang8659ac22006-10-17 18:29:52 -07002231 (unsigned int)nr_segs,
Mark Fasheh9517bac2007-02-09 20:24:12 -08002232 file->f_path.dentry->d_name.len,
2233 file->f_path.dentry->d_name.name);
Tiger Yang8659ac22006-10-17 18:29:52 -07002234
Tiger Yang8659ac22006-10-17 18:29:52 -07002235 if (iocb->ki_left == 0)
2236 return 0;
2237
Mark Fasheh9517bac2007-02-09 20:24:12 -08002238 vfs_check_frozen(inode->i_sb, SB_FREEZE_WRITE);
2239
2240 appending = file->f_flags & O_APPEND ? 1 : 0;
2241 direct_io = file->f_flags & O_DIRECT ? 1 : 0;
2242
Tiger Yang8659ac22006-10-17 18:29:52 -07002243 mutex_lock(&inode->i_mutex);
Mark Fasheh9517bac2007-02-09 20:24:12 -08002244
2245relock:
Tiger Yang8659ac22006-10-17 18:29:52 -07002246 /* to match setattr's i_mutex -> i_alloc_sem -> rw_lock ordering */
Mark Fasheh9517bac2007-02-09 20:24:12 -08002247 if (direct_io) {
Tiger Yang8659ac22006-10-17 18:29:52 -07002248 down_read(&inode->i_alloc_sem);
Mark Fasheh9517bac2007-02-09 20:24:12 -08002249 have_alloc_sem = 1;
Tiger Yang8659ac22006-10-17 18:29:52 -07002250 }
2251
2252 /* concurrent O_DIRECT writes are allowed */
Mark Fasheh9517bac2007-02-09 20:24:12 -08002253 rw_level = !direct_io;
Tiger Yang8659ac22006-10-17 18:29:52 -07002254 ret = ocfs2_rw_lock(inode, rw_level);
2255 if (ret < 0) {
Mark Fasheh9517bac2007-02-09 20:24:12 -08002256 mlog_errno(ret);
2257 goto out_sems;
2258 }
2259
2260 can_do_direct = direct_io;
Tao Mab8908232010-08-12 10:27:14 +08002261 ret = ocfs2_prepare_inode_for_write(file, ppos,
Mark Fasheh9517bac2007-02-09 20:24:12 -08002262 iocb->ki_left, appending,
Tao Ma86470e92009-12-03 21:55:05 +08002263 &can_do_direct, &has_refcount);
Mark Fasheh9517bac2007-02-09 20:24:12 -08002264 if (ret < 0) {
Tiger Yang8659ac22006-10-17 18:29:52 -07002265 mlog_errno(ret);
2266 goto out;
2267 }
2268
Mark Fasheh9517bac2007-02-09 20:24:12 -08002269 /*
2270 * We can't complete the direct I/O as requested, fall back to
2271 * buffered I/O.
2272 */
2273 if (direct_io && !can_do_direct) {
2274 ocfs2_rw_unlock(inode, rw_level);
2275 up_read(&inode->i_alloc_sem);
2276
2277 have_alloc_sem = 0;
2278 rw_level = -1;
2279
2280 direct_io = 0;
Mark Fasheh9517bac2007-02-09 20:24:12 -08002281 goto relock;
Tiger Yang8659ac22006-10-17 18:29:52 -07002282 }
Mark Fashehccd979b2005-12-15 14:31:24 -08002283
Mark Fasheh9ea2d322007-10-18 14:14:45 -07002284 /*
2285 * To later detect whether a journal commit for sync writes is
2286 * necessary, we sample i_size, and cluster count here.
2287 */
2288 old_size = i_size_read(inode);
2289 old_clusters = OCFS2_I(inode)->ip_clusters;
2290
Mark Fashehccd979b2005-12-15 14:31:24 -08002291 /* communicate with ocfs2_dio_end_io */
Mark Fasheh7cdfc3a2007-04-16 17:28:51 -07002292 ocfs2_iocb_set_rw_locked(iocb, rw_level);
Mark Fashehccd979b2005-12-15 14:31:24 -08002293
Li Dongyang6b933c82010-04-17 17:49:10 +08002294 ret = generic_segment_checks(iov, &nr_segs, &ocount,
2295 VERIFY_READ);
2296 if (ret)
2297 goto out_dio;
2298
2299 count = ocount;
2300 ret = generic_write_checks(file, ppos, &count,
2301 S_ISBLK(inode->i_mode));
2302 if (ret)
2303 goto out_dio;
2304
Mark Fasheh9517bac2007-02-09 20:24:12 -08002305 if (direct_io) {
2306 written = generic_file_direct_write(iocb, iov, &nr_segs, *ppos,
2307 ppos, count, ocount);
2308 if (written < 0) {
Dmitri Monakhovc4354002008-10-27 13:01:49 -07002309 /*
2310 * direct write may have instantiated a few
2311 * blocks outside i_size. Trim these off again.
2312 * Don't need i_size_read because we hold i_mutex.
npiggin@suse.de15c6fd92010-05-27 01:05:34 +10002313 *
Christoph Hellwig2c27c652010-06-04 11:30:04 +02002314 * XXX(truncate): this looks buggy because ocfs2 did not
npiggin@suse.de15c6fd92010-05-27 01:05:34 +10002315 * actually implement ->truncate. Take a look at
2316 * the new truncate sequence and update this accordingly
Dmitri Monakhovc4354002008-10-27 13:01:49 -07002317 */
2318 if (*ppos + count > inode->i_size)
Christoph Hellwig2c27c652010-06-04 11:30:04 +02002319 truncate_setsize(inode, inode->i_size);
Mark Fasheh9517bac2007-02-09 20:24:12 -08002320 ret = written;
2321 goto out_dio;
2322 }
2323 } else {
Li Dongyang6b933c82010-04-17 17:49:10 +08002324 current->backing_dev_info = file->f_mapping->backing_dev_info;
2325 written = generic_file_buffered_write(iocb, iov, nr_segs, *ppos,
2326 ppos, count, 0);
2327 current->backing_dev_info = NULL;
Mark Fasheh9517bac2007-02-09 20:24:12 -08002328 }
Mark Fashehccd979b2005-12-15 14:31:24 -08002329
Mark Fasheh9517bac2007-02-09 20:24:12 -08002330out_dio:
Mark Fashehccd979b2005-12-15 14:31:24 -08002331 /* buffered aio wouldn't have proper lock coverage today */
Mark Fasheh9517bac2007-02-09 20:24:12 -08002332 BUG_ON(ret == -EIOCBQUEUED && !(file->f_flags & O_DIRECT));
Mark Fashehccd979b2005-12-15 14:31:24 -08002333
Tao Ma60c48672010-02-03 09:56:04 +08002334 if (((file->f_flags & O_DSYNC) && !direct_io) || IS_SYNC(inode) ||
2335 ((file->f_flags & O_DIRECT) && has_refcount)) {
Jan Kara918941a2009-08-17 18:50:08 +02002336 ret = filemap_fdatawrite_range(file->f_mapping, pos,
2337 pos + count - 1);
2338 if (ret < 0)
2339 written = ret;
2340
Coly Lia03ab782010-03-26 05:15:12 +08002341 if (!ret && ((old_size != i_size_read(inode)) ||
2342 (old_clusters != OCFS2_I(inode)->ip_clusters) ||
2343 has_refcount)) {
Joel Becker2b4e30f2008-09-03 20:03:41 -07002344 ret = jbd2_journal_force_commit(osb->journal->j_journal);
Mark Fasheh9ea2d322007-10-18 14:14:45 -07002345 if (ret < 0)
2346 written = ret;
2347 }
Jan Kara918941a2009-08-17 18:50:08 +02002348
2349 if (!ret)
2350 ret = filemap_fdatawait_range(file->f_mapping, pos,
2351 pos + count - 1);
Mark Fasheh9ea2d322007-10-18 14:14:45 -07002352 }
2353
Sunil Mushran2bd63212010-01-25 16:57:38 -08002354 /*
Mark Fashehccd979b2005-12-15 14:31:24 -08002355 * deep in g_f_a_w_n()->ocfs2_direct_IO we pass in a ocfs2_dio_end_io
2356 * function pointer which is called when o_direct io completes so that
2357 * it can unlock our rw lock. (it's the clustered equivalent of
2358 * i_alloc_sem; protects truncate from racing with pending ios).
2359 * Unfortunately there are error cases which call end_io and others
2360 * that don't. so we don't have to unlock the rw_lock if either an
2361 * async dio is going to do it in the future or an end_io after an
2362 * error has already done it.
2363 */
Coly Li66b116c2010-02-25 14:57:13 +08002364 if ((ret == -EIOCBQUEUED) || (!ocfs2_iocb_is_rw_locked(iocb))) {
Mark Fashehccd979b2005-12-15 14:31:24 -08002365 rw_level = -1;
2366 have_alloc_sem = 0;
2367 }
2368
2369out:
Mark Fasheh9517bac2007-02-09 20:24:12 -08002370 if (rw_level != -1)
2371 ocfs2_rw_unlock(inode, rw_level);
2372
2373out_sems:
Mark Fashehccd979b2005-12-15 14:31:24 -08002374 if (have_alloc_sem)
2375 up_read(&inode->i_alloc_sem);
Mark Fasheh9517bac2007-02-09 20:24:12 -08002376
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002377 mutex_unlock(&inode->i_mutex);
Mark Fashehccd979b2005-12-15 14:31:24 -08002378
Wengang Wang812e7a62009-07-10 13:26:04 +08002379 if (written)
2380 ret = written;
Mark Fashehccd979b2005-12-15 14:31:24 -08002381 mlog_exit(ret);
Wengang Wang812e7a62009-07-10 13:26:04 +08002382 return ret;
Mark Fashehccd979b2005-12-15 14:31:24 -08002383}
2384
Miklos Szeredi328eaab2009-04-14 19:48:39 +02002385static int ocfs2_splice_to_file(struct pipe_inode_info *pipe,
2386 struct file *out,
2387 struct splice_desc *sd)
2388{
2389 int ret;
2390
Tao Mab8908232010-08-12 10:27:14 +08002391 ret = ocfs2_prepare_inode_for_write(out, &sd->pos,
Tao Ma86470e92009-12-03 21:55:05 +08002392 sd->total_len, 0, NULL, NULL);
Miklos Szeredi328eaab2009-04-14 19:48:39 +02002393 if (ret < 0) {
2394 mlog_errno(ret);
2395 return ret;
2396 }
2397
2398 return splice_from_pipe_feed(pipe, sd, pipe_to_file);
2399}
2400
Tiger Yang8659ac22006-10-17 18:29:52 -07002401static ssize_t ocfs2_file_splice_write(struct pipe_inode_info *pipe,
2402 struct file *out,
2403 loff_t *ppos,
2404 size_t len,
2405 unsigned int flags)
2406{
2407 int ret;
Miklos Szeredi328eaab2009-04-14 19:48:39 +02002408 struct address_space *mapping = out->f_mapping;
2409 struct inode *inode = mapping->host;
2410 struct splice_desc sd = {
2411 .total_len = len,
2412 .flags = flags,
2413 .pos = *ppos,
2414 .u.file = out,
2415 };
Tiger Yang8659ac22006-10-17 18:29:52 -07002416
2417 mlog_entry("(0x%p, 0x%p, %u, '%.*s')\n", out, pipe,
2418 (unsigned int)len,
Josef Sipekd28c9172006-12-08 02:37:25 -08002419 out->f_path.dentry->d_name.len,
2420 out->f_path.dentry->d_name.name);
Tiger Yang8659ac22006-10-17 18:29:52 -07002421
Miklos Szeredi7bfac9e2009-04-06 17:41:00 +02002422 if (pipe->inode)
Miklos Szeredi328eaab2009-04-14 19:48:39 +02002423 mutex_lock_nested(&pipe->inode->i_mutex, I_MUTEX_PARENT);
2424
2425 splice_from_pipe_begin(&sd);
2426 do {
2427 ret = splice_from_pipe_next(pipe, &sd);
2428 if (ret <= 0)
2429 break;
2430
2431 mutex_lock_nested(&inode->i_mutex, I_MUTEX_CHILD);
2432 ret = ocfs2_rw_lock(inode, 1);
2433 if (ret < 0)
2434 mlog_errno(ret);
2435 else {
2436 ret = ocfs2_splice_to_file(pipe, out, &sd);
2437 ocfs2_rw_unlock(inode, 1);
2438 }
2439 mutex_unlock(&inode->i_mutex);
2440 } while (ret > 0);
2441 splice_from_pipe_end(pipe, &sd);
2442
Miklos Szeredi7bfac9e2009-04-06 17:41:00 +02002443 if (pipe->inode)
2444 mutex_unlock(&pipe->inode->i_mutex);
Tiger Yang8659ac22006-10-17 18:29:52 -07002445
Miklos Szeredi328eaab2009-04-14 19:48:39 +02002446 if (sd.num_spliced)
2447 ret = sd.num_spliced;
2448
2449 if (ret > 0) {
2450 unsigned long nr_pages;
Jan Karad23c9372009-08-18 18:24:31 +02002451 int err;
Miklos Szeredi328eaab2009-04-14 19:48:39 +02002452
Miklos Szeredi328eaab2009-04-14 19:48:39 +02002453 nr_pages = (ret + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
2454
Jan Karad23c9372009-08-18 18:24:31 +02002455 err = generic_write_sync(out, *ppos, ret);
2456 if (err)
2457 ret = err;
2458 else
2459 *ppos += ret;
Miklos Szeredi328eaab2009-04-14 19:48:39 +02002460
Miklos Szeredi328eaab2009-04-14 19:48:39 +02002461 balance_dirty_pages_ratelimited_nr(mapping, nr_pages);
2462 }
Tiger Yang8659ac22006-10-17 18:29:52 -07002463
2464 mlog_exit(ret);
2465 return ret;
2466}
2467
2468static ssize_t ocfs2_file_splice_read(struct file *in,
2469 loff_t *ppos,
2470 struct pipe_inode_info *pipe,
2471 size_t len,
2472 unsigned int flags)
2473{
Tao Ma1962f392009-06-19 15:36:52 +08002474 int ret = 0, lock_level = 0;
Josef Sipekd28c9172006-12-08 02:37:25 -08002475 struct inode *inode = in->f_path.dentry->d_inode;
Tiger Yang8659ac22006-10-17 18:29:52 -07002476
2477 mlog_entry("(0x%p, 0x%p, %u, '%.*s')\n", in, pipe,
2478 (unsigned int)len,
Josef Sipekd28c9172006-12-08 02:37:25 -08002479 in->f_path.dentry->d_name.len,
2480 in->f_path.dentry->d_name.name);
Tiger Yang8659ac22006-10-17 18:29:52 -07002481
2482 /*
2483 * See the comment in ocfs2_file_aio_read()
2484 */
Tao Ma1962f392009-06-19 15:36:52 +08002485 ret = ocfs2_inode_lock_atime(inode, in->f_vfsmnt, &lock_level);
Tiger Yang8659ac22006-10-17 18:29:52 -07002486 if (ret < 0) {
2487 mlog_errno(ret);
2488 goto bail;
2489 }
Tao Ma1962f392009-06-19 15:36:52 +08002490 ocfs2_inode_unlock(inode, lock_level);
Tiger Yang8659ac22006-10-17 18:29:52 -07002491
2492 ret = generic_file_splice_read(in, ppos, pipe, len, flags);
2493
2494bail:
2495 mlog_exit(ret);
2496 return ret;
2497}
2498
Mark Fashehccd979b2005-12-15 14:31:24 -08002499static ssize_t ocfs2_file_aio_read(struct kiocb *iocb,
Badari Pulavarty027445c2006-09-30 23:28:46 -07002500 const struct iovec *iov,
2501 unsigned long nr_segs,
Mark Fashehccd979b2005-12-15 14:31:24 -08002502 loff_t pos)
2503{
Tiger Yang25899de2006-11-15 15:49:02 +08002504 int ret = 0, rw_level = -1, have_alloc_sem = 0, lock_level = 0;
Mark Fashehccd979b2005-12-15 14:31:24 -08002505 struct file *filp = iocb->ki_filp;
Josef Sipekd28c9172006-12-08 02:37:25 -08002506 struct inode *inode = filp->f_path.dentry->d_inode;
Mark Fashehccd979b2005-12-15 14:31:24 -08002507
Badari Pulavarty027445c2006-09-30 23:28:46 -07002508 mlog_entry("(0x%p, %u, '%.*s')\n", filp,
2509 (unsigned int)nr_segs,
Josef Sipekd28c9172006-12-08 02:37:25 -08002510 filp->f_path.dentry->d_name.len,
2511 filp->f_path.dentry->d_name.name);
Mark Fashehccd979b2005-12-15 14:31:24 -08002512
2513 if (!inode) {
2514 ret = -EINVAL;
2515 mlog_errno(ret);
2516 goto bail;
2517 }
2518
Sunil Mushran2bd63212010-01-25 16:57:38 -08002519 /*
Mark Fashehccd979b2005-12-15 14:31:24 -08002520 * buffered reads protect themselves in ->readpage(). O_DIRECT reads
2521 * need locks to protect pending reads from racing with truncate.
2522 */
2523 if (filp->f_flags & O_DIRECT) {
2524 down_read(&inode->i_alloc_sem);
2525 have_alloc_sem = 1;
2526
2527 ret = ocfs2_rw_lock(inode, 0);
2528 if (ret < 0) {
2529 mlog_errno(ret);
2530 goto bail;
2531 }
2532 rw_level = 0;
2533 /* communicate with ocfs2_dio_end_io */
Mark Fasheh7cdfc3a2007-04-16 17:28:51 -07002534 ocfs2_iocb_set_rw_locked(iocb, rw_level);
Mark Fashehccd979b2005-12-15 14:31:24 -08002535 }
2536
Mark Fashehc4374f82006-05-05 19:04:35 -07002537 /*
2538 * We're fine letting folks race truncates and extending
2539 * writes with read across the cluster, just like they can
2540 * locally. Hence no rw_lock during read.
Sunil Mushran2bd63212010-01-25 16:57:38 -08002541 *
Mark Fashehc4374f82006-05-05 19:04:35 -07002542 * Take and drop the meta data lock to update inode fields
2543 * like i_size. This allows the checks down below
Sunil Mushran2bd63212010-01-25 16:57:38 -08002544 * generic_file_aio_read() a chance of actually working.
Mark Fashehc4374f82006-05-05 19:04:35 -07002545 */
Mark Fashehe63aecb62007-10-18 15:30:42 -07002546 ret = ocfs2_inode_lock_atime(inode, filp->f_vfsmnt, &lock_level);
Mark Fashehc4374f82006-05-05 19:04:35 -07002547 if (ret < 0) {
2548 mlog_errno(ret);
2549 goto bail;
2550 }
Mark Fashehe63aecb62007-10-18 15:30:42 -07002551 ocfs2_inode_unlock(inode, lock_level);
Mark Fashehc4374f82006-05-05 19:04:35 -07002552
Badari Pulavarty027445c2006-09-30 23:28:46 -07002553 ret = generic_file_aio_read(iocb, iov, nr_segs, iocb->ki_pos);
Mark Fashehccd979b2005-12-15 14:31:24 -08002554 if (ret == -EINVAL)
Sunil Mushran56753bd2008-06-09 11:24:41 -07002555 mlog(0, "generic_file_aio_read returned -EINVAL\n");
Mark Fashehccd979b2005-12-15 14:31:24 -08002556
2557 /* buffered aio wouldn't have proper lock coverage today */
2558 BUG_ON(ret == -EIOCBQUEUED && !(filp->f_flags & O_DIRECT));
2559
2560 /* see ocfs2_file_aio_write */
2561 if (ret == -EIOCBQUEUED || !ocfs2_iocb_is_rw_locked(iocb)) {
2562 rw_level = -1;
2563 have_alloc_sem = 0;
2564 }
2565
2566bail:
2567 if (have_alloc_sem)
2568 up_read(&inode->i_alloc_sem);
Sunil Mushran2bd63212010-01-25 16:57:38 -08002569 if (rw_level != -1)
Mark Fashehccd979b2005-12-15 14:31:24 -08002570 ocfs2_rw_unlock(inode, rw_level);
2571 mlog_exit(ret);
2572
2573 return ret;
2574}
2575
Arjan van de Ven92e1d5b2007-02-12 00:55:39 -08002576const struct inode_operations ocfs2_file_iops = {
Mark Fashehccd979b2005-12-15 14:31:24 -08002577 .setattr = ocfs2_setattr,
2578 .getattr = ocfs2_getattr,
Tiger Yangd38eb8d2006-11-27 09:59:21 +08002579 .permission = ocfs2_permission,
Tiger Yangcf1d6c72008-08-18 17:11:00 +08002580 .setxattr = generic_setxattr,
2581 .getxattr = generic_getxattr,
2582 .listxattr = ocfs2_listxattr,
2583 .removexattr = generic_removexattr,
Mark Fasheh385820a2007-07-19 00:14:38 -07002584 .fallocate = ocfs2_fallocate,
Mark Fasheh00dc4172008-10-03 17:32:11 -04002585 .fiemap = ocfs2_fiemap,
Mark Fashehccd979b2005-12-15 14:31:24 -08002586};
2587
Arjan van de Ven92e1d5b2007-02-12 00:55:39 -08002588const struct inode_operations ocfs2_special_file_iops = {
Mark Fashehccd979b2005-12-15 14:31:24 -08002589 .setattr = ocfs2_setattr,
2590 .getattr = ocfs2_getattr,
Tiger Yangd38eb8d2006-11-27 09:59:21 +08002591 .permission = ocfs2_permission,
Mark Fashehccd979b2005-12-15 14:31:24 -08002592};
2593
Mark Fasheh53da4932008-07-21 14:29:16 -07002594/*
2595 * Other than ->lock, keep ocfs2_fops and ocfs2_dops in sync with
2596 * ocfs2_fops_no_plocks and ocfs2_dops_no_plocks!
2597 */
Arjan van de Ven4b6f5d22006-03-28 01:56:42 -08002598const struct file_operations ocfs2_fops = {
Jan Kara32c3c0e2007-12-19 15:24:52 +01002599 .llseek = generic_file_llseek,
Mark Fashehccd979b2005-12-15 14:31:24 -08002600 .read = do_sync_read,
2601 .write = do_sync_write,
Mark Fashehccd979b2005-12-15 14:31:24 -08002602 .mmap = ocfs2_mmap,
2603 .fsync = ocfs2_sync_file,
2604 .release = ocfs2_file_release,
2605 .open = ocfs2_file_open,
2606 .aio_read = ocfs2_file_aio_read,
2607 .aio_write = ocfs2_file_aio_write,
Andi Kleenc9ec1482008-01-27 03:17:17 +01002608 .unlocked_ioctl = ocfs2_ioctl,
Mark Fasheh586d2322007-03-09 15:56:28 -08002609#ifdef CONFIG_COMPAT
2610 .compat_ioctl = ocfs2_compat_ioctl,
2611#endif
Mark Fasheh53da4932008-07-21 14:29:16 -07002612 .lock = ocfs2_lock,
2613 .flock = ocfs2_flock,
2614 .splice_read = ocfs2_file_splice_read,
2615 .splice_write = ocfs2_file_splice_write,
2616};
2617
2618const struct file_operations ocfs2_dops = {
2619 .llseek = generic_file_llseek,
2620 .read = generic_read_dir,
2621 .readdir = ocfs2_readdir,
2622 .fsync = ocfs2_sync_file,
2623 .release = ocfs2_dir_release,
2624 .open = ocfs2_dir_open,
2625 .unlocked_ioctl = ocfs2_ioctl,
2626#ifdef CONFIG_COMPAT
2627 .compat_ioctl = ocfs2_compat_ioctl,
2628#endif
2629 .lock = ocfs2_lock,
2630 .flock = ocfs2_flock,
2631};
2632
2633/*
2634 * POSIX-lockless variants of our file_operations.
2635 *
2636 * These will be used if the underlying cluster stack does not support
2637 * posix file locking, if the user passes the "localflocks" mount
2638 * option, or if we have a local-only fs.
2639 *
2640 * ocfs2_flock is in here because all stacks handle UNIX file locks,
2641 * so we still want it in the case of no stack support for
2642 * plocks. Internally, it will do the right thing when asked to ignore
2643 * the cluster.
2644 */
2645const struct file_operations ocfs2_fops_no_plocks = {
2646 .llseek = generic_file_llseek,
2647 .read = do_sync_read,
2648 .write = do_sync_write,
2649 .mmap = ocfs2_mmap,
2650 .fsync = ocfs2_sync_file,
2651 .release = ocfs2_file_release,
2652 .open = ocfs2_file_open,
2653 .aio_read = ocfs2_file_aio_read,
2654 .aio_write = ocfs2_file_aio_write,
2655 .unlocked_ioctl = ocfs2_ioctl,
2656#ifdef CONFIG_COMPAT
2657 .compat_ioctl = ocfs2_compat_ioctl,
2658#endif
Mark Fasheh53fc6222007-12-20 16:49:04 -08002659 .flock = ocfs2_flock,
Tiger Yang8659ac22006-10-17 18:29:52 -07002660 .splice_read = ocfs2_file_splice_read,
2661 .splice_write = ocfs2_file_splice_write,
Mark Fashehccd979b2005-12-15 14:31:24 -08002662};
2663
Mark Fasheh53da4932008-07-21 14:29:16 -07002664const struct file_operations ocfs2_dops_no_plocks = {
Jan Kara32c3c0e2007-12-19 15:24:52 +01002665 .llseek = generic_file_llseek,
Mark Fashehccd979b2005-12-15 14:31:24 -08002666 .read = generic_read_dir,
2667 .readdir = ocfs2_readdir,
2668 .fsync = ocfs2_sync_file,
Mark Fasheh53fc6222007-12-20 16:49:04 -08002669 .release = ocfs2_dir_release,
2670 .open = ocfs2_dir_open,
Andi Kleenc9ec1482008-01-27 03:17:17 +01002671 .unlocked_ioctl = ocfs2_ioctl,
Mark Fasheh586d2322007-03-09 15:56:28 -08002672#ifdef CONFIG_COMPAT
2673 .compat_ioctl = ocfs2_compat_ioctl,
2674#endif
Mark Fasheh53fc6222007-12-20 16:49:04 -08002675 .flock = ocfs2_flock,
Mark Fashehccd979b2005-12-15 14:31:24 -08002676};