Merge branch 'for-linus' of master.kernel.org:/pub/scm/linux/kernel/git/cooloney...
[linux-2.6] / fs / ocfs2 / file.c
1 /* -*- 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
26 #include <linux/capability.h>
27 #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>
33 #include <linux/sched.h>
34 #include <linux/splice.h>
35 #include <linux/mount.h>
36 #include <linux/writeback.h>
37 #include <linux/falloc.h>
38
39 #define MLOG_MASK_PREFIX ML_INODE
40 #include <cluster/masklog.h>
41
42 #include "ocfs2.h"
43
44 #include "alloc.h"
45 #include "aops.h"
46 #include "dir.h"
47 #include "dlmglue.h"
48 #include "extent_map.h"
49 #include "file.h"
50 #include "sysfile.h"
51 #include "inode.h"
52 #include "ioctl.h"
53 #include "journal.h"
54 #include "mmap.h"
55 #include "suballoc.h"
56 #include "super.h"
57
58 #include "buffer_head_io.h"
59
60 static int ocfs2_sync_inode(struct inode *inode)
61 {
62         filemap_fdatawrite(inode->i_mapping);
63         return sync_mapping_buffers(inode->i_mapping);
64 }
65
66 static int ocfs2_file_open(struct inode *inode, struct file *file)
67 {
68         int status;
69         int mode = file->f_flags;
70         struct ocfs2_inode_info *oi = OCFS2_I(inode);
71
72         mlog_entry("(0x%p, 0x%p, '%.*s')\n", inode, file,
73                    file->f_path.dentry->d_name.len, file->f_path.dentry->d_name.name);
74
75         spin_lock(&oi->ip_lock);
76
77         /* Check that the inode hasn't been wiped from disk by another
78          * node. If it hasn't then we're safe as long as we hold the
79          * spin lock until our increment of open count. */
80         if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_DELETED) {
81                 spin_unlock(&oi->ip_lock);
82
83                 status = -ENOENT;
84                 goto leave;
85         }
86
87         if (mode & O_DIRECT)
88                 oi->ip_flags |= OCFS2_INODE_OPEN_DIRECT;
89
90         oi->ip_open_count++;
91         spin_unlock(&oi->ip_lock);
92         status = 0;
93 leave:
94         mlog_exit(status);
95         return status;
96 }
97
98 static int ocfs2_file_release(struct inode *inode, struct file *file)
99 {
100         struct ocfs2_inode_info *oi = OCFS2_I(inode);
101
102         mlog_entry("(0x%p, 0x%p, '%.*s')\n", inode, file,
103                        file->f_path.dentry->d_name.len,
104                        file->f_path.dentry->d_name.name);
105
106         spin_lock(&oi->ip_lock);
107         if (!--oi->ip_open_count)
108                 oi->ip_flags &= ~OCFS2_INODE_OPEN_DIRECT;
109         spin_unlock(&oi->ip_lock);
110
111         mlog_exit(0);
112
113         return 0;
114 }
115
116 static int ocfs2_sync_file(struct file *file,
117                            struct dentry *dentry,
118                            int datasync)
119 {
120         int err = 0;
121         journal_t *journal;
122         struct inode *inode = dentry->d_inode;
123         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
124
125         mlog_entry("(0x%p, 0x%p, %d, '%.*s')\n", file, dentry, datasync,
126                    dentry->d_name.len, dentry->d_name.name);
127
128         err = ocfs2_sync_inode(dentry->d_inode);
129         if (err)
130                 goto bail;
131
132         journal = osb->journal->j_journal;
133         err = journal_force_commit(journal);
134
135 bail:
136         mlog_exit(err);
137
138         return (err < 0) ? -EIO : 0;
139 }
140
141 int ocfs2_should_update_atime(struct inode *inode,
142                               struct vfsmount *vfsmnt)
143 {
144         struct timespec now;
145         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
146
147         if (ocfs2_is_hard_readonly(osb) || ocfs2_is_soft_readonly(osb))
148                 return 0;
149
150         if ((inode->i_flags & S_NOATIME) ||
151             ((inode->i_sb->s_flags & MS_NODIRATIME) && S_ISDIR(inode->i_mode)))
152                 return 0;
153
154         /*
155          * We can be called with no vfsmnt structure - NFSD will
156          * sometimes do this.
157          *
158          * Note that our action here is different than touch_atime() -
159          * if we can't tell whether this is a noatime mount, then we
160          * don't know whether to trust the value of s_atime_quantum.
161          */
162         if (vfsmnt == NULL)
163                 return 0;
164
165         if ((vfsmnt->mnt_flags & MNT_NOATIME) ||
166             ((vfsmnt->mnt_flags & MNT_NODIRATIME) && S_ISDIR(inode->i_mode)))
167                 return 0;
168
169         if (vfsmnt->mnt_flags & MNT_RELATIME) {
170                 if ((timespec_compare(&inode->i_atime, &inode->i_mtime) <= 0) ||
171                     (timespec_compare(&inode->i_atime, &inode->i_ctime) <= 0))
172                         return 1;
173
174                 return 0;
175         }
176
177         now = CURRENT_TIME;
178         if ((now.tv_sec - inode->i_atime.tv_sec <= osb->s_atime_quantum))
179                 return 0;
180         else
181                 return 1;
182 }
183
184 int ocfs2_update_inode_atime(struct inode *inode,
185                              struct buffer_head *bh)
186 {
187         int ret;
188         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
189         handle_t *handle;
190
191         mlog_entry_void();
192
193         handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
194         if (handle == NULL) {
195                 ret = -ENOMEM;
196                 mlog_errno(ret);
197                 goto out;
198         }
199
200         inode->i_atime = CURRENT_TIME;
201         ret = ocfs2_mark_inode_dirty(handle, inode, bh);
202         if (ret < 0)
203                 mlog_errno(ret);
204
205         ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
206 out:
207         mlog_exit(ret);
208         return ret;
209 }
210
211 static int ocfs2_set_inode_size(handle_t *handle,
212                                 struct inode *inode,
213                                 struct buffer_head *fe_bh,
214                                 u64 new_i_size)
215 {
216         int status;
217
218         mlog_entry_void();
219         i_size_write(inode, new_i_size);
220         inode->i_blocks = ocfs2_inode_sector_count(inode);
221         inode->i_ctime = inode->i_mtime = CURRENT_TIME;
222
223         status = ocfs2_mark_inode_dirty(handle, inode, fe_bh);
224         if (status < 0) {
225                 mlog_errno(status);
226                 goto bail;
227         }
228
229 bail:
230         mlog_exit(status);
231         return status;
232 }
233
234 static int ocfs2_simple_size_update(struct inode *inode,
235                                     struct buffer_head *di_bh,
236                                     u64 new_i_size)
237 {
238         int ret;
239         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
240         handle_t *handle = NULL;
241
242         handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
243         if (handle == NULL) {
244                 ret = -ENOMEM;
245                 mlog_errno(ret);
246                 goto out;
247         }
248
249         ret = ocfs2_set_inode_size(handle, inode, di_bh,
250                                    new_i_size);
251         if (ret < 0)
252                 mlog_errno(ret);
253
254         ocfs2_commit_trans(osb, handle);
255 out:
256         return ret;
257 }
258
259 static int ocfs2_orphan_for_truncate(struct ocfs2_super *osb,
260                                      struct inode *inode,
261                                      struct buffer_head *fe_bh,
262                                      u64 new_i_size)
263 {
264         int status;
265         handle_t *handle;
266         struct ocfs2_dinode *di;
267         u64 cluster_bytes;
268
269         mlog_entry_void();
270
271         /* TODO: This needs to actually orphan the inode in this
272          * transaction. */
273
274         handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
275         if (IS_ERR(handle)) {
276                 status = PTR_ERR(handle);
277                 mlog_errno(status);
278                 goto out;
279         }
280
281         status = ocfs2_journal_access(handle, inode, fe_bh,
282                                       OCFS2_JOURNAL_ACCESS_WRITE);
283         if (status < 0) {
284                 mlog_errno(status);
285                 goto out_commit;
286         }
287
288         /*
289          * Do this before setting i_size.
290          */
291         cluster_bytes = ocfs2_align_bytes_to_clusters(inode->i_sb, new_i_size);
292         status = ocfs2_zero_range_for_truncate(inode, handle, new_i_size,
293                                                cluster_bytes);
294         if (status) {
295                 mlog_errno(status);
296                 goto out_commit;
297         }
298
299         i_size_write(inode, new_i_size);
300         inode->i_blocks = ocfs2_align_bytes_to_sectors(new_i_size);
301         inode->i_ctime = inode->i_mtime = CURRENT_TIME;
302
303         di = (struct ocfs2_dinode *) fe_bh->b_data;
304         di->i_size = cpu_to_le64(new_i_size);
305         di->i_ctime = di->i_mtime = cpu_to_le64(inode->i_ctime.tv_sec);
306         di->i_ctime_nsec = di->i_mtime_nsec = cpu_to_le32(inode->i_ctime.tv_nsec);
307
308         status = ocfs2_journal_dirty(handle, fe_bh);
309         if (status < 0)
310                 mlog_errno(status);
311
312 out_commit:
313         ocfs2_commit_trans(osb, handle);
314 out:
315
316         mlog_exit(status);
317         return status;
318 }
319
320 static int ocfs2_truncate_file(struct inode *inode,
321                                struct buffer_head *di_bh,
322                                u64 new_i_size)
323 {
324         int status = 0;
325         struct ocfs2_dinode *fe = NULL;
326         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
327         struct ocfs2_truncate_context *tc = NULL;
328
329         mlog_entry("(inode = %llu, new_i_size = %llu\n",
330                    (unsigned long long)OCFS2_I(inode)->ip_blkno,
331                    (unsigned long long)new_i_size);
332
333         fe = (struct ocfs2_dinode *) di_bh->b_data;
334         if (!OCFS2_IS_VALID_DINODE(fe)) {
335                 OCFS2_RO_ON_INVALID_DINODE(inode->i_sb, fe);
336                 status = -EIO;
337                 goto bail;
338         }
339
340         mlog_bug_on_msg(le64_to_cpu(fe->i_size) != i_size_read(inode),
341                         "Inode %llu, inode i_size = %lld != di "
342                         "i_size = %llu, i_flags = 0x%x\n",
343                         (unsigned long long)OCFS2_I(inode)->ip_blkno,
344                         i_size_read(inode),
345                         (unsigned long long)le64_to_cpu(fe->i_size),
346                         le32_to_cpu(fe->i_flags));
347
348         if (new_i_size > le64_to_cpu(fe->i_size)) {
349                 mlog(0, "asked to truncate file with size (%llu) to size (%llu)!\n",
350                      (unsigned long long)le64_to_cpu(fe->i_size),
351                      (unsigned long long)new_i_size);
352                 status = -EINVAL;
353                 mlog_errno(status);
354                 goto bail;
355         }
356
357         mlog(0, "inode %llu, i_size = %llu, new_i_size = %llu\n",
358              (unsigned long long)le64_to_cpu(fe->i_blkno),
359              (unsigned long long)le64_to_cpu(fe->i_size),
360              (unsigned long long)new_i_size);
361
362         /* lets handle the simple truncate cases before doing any more
363          * cluster locking. */
364         if (new_i_size == le64_to_cpu(fe->i_size))
365                 goto bail;
366
367         down_write(&OCFS2_I(inode)->ip_alloc_sem);
368
369         /* This forces other nodes to sync and drop their pages. Do
370          * this even if we have a truncate without allocation change -
371          * ocfs2 cluster sizes can be much greater than page size, so
372          * we have to truncate them anyway.  */
373         status = ocfs2_data_lock(inode, 1);
374         if (status < 0) {
375                 up_write(&OCFS2_I(inode)->ip_alloc_sem);
376
377                 mlog_errno(status);
378                 goto bail;
379         }
380
381         unmap_mapping_range(inode->i_mapping, new_i_size + PAGE_SIZE - 1, 0, 1);
382         truncate_inode_pages(inode->i_mapping, new_i_size);
383
384         /* alright, we're going to need to do a full blown alloc size
385          * change. Orphan the inode so that recovery can complete the
386          * truncate if necessary. This does the task of marking
387          * i_size. */
388         status = ocfs2_orphan_for_truncate(osb, inode, di_bh, new_i_size);
389         if (status < 0) {
390                 mlog_errno(status);
391                 goto bail_unlock_data;
392         }
393
394         status = ocfs2_prepare_truncate(osb, inode, di_bh, &tc);
395         if (status < 0) {
396                 mlog_errno(status);
397                 goto bail_unlock_data;
398         }
399
400         status = ocfs2_commit_truncate(osb, inode, di_bh, tc);
401         if (status < 0) {
402                 mlog_errno(status);
403                 goto bail_unlock_data;
404         }
405
406         /* TODO: orphan dir cleanup here. */
407 bail_unlock_data:
408         ocfs2_data_unlock(inode, 1);
409
410         up_write(&OCFS2_I(inode)->ip_alloc_sem);
411
412 bail:
413
414         mlog_exit(status);
415         return status;
416 }
417
418 /*
419  * extend allocation only here.
420  * we'll update all the disk stuff, and oip->alloc_size
421  *
422  * expect stuff to be locked, a transaction started and enough data /
423  * metadata reservations in the contexts.
424  *
425  * Will return -EAGAIN, and a reason if a restart is needed.
426  * If passed in, *reason will always be set, even in error.
427  */
428 int ocfs2_do_extend_allocation(struct ocfs2_super *osb,
429                                struct inode *inode,
430                                u32 *logical_offset,
431                                u32 clusters_to_add,
432                                int mark_unwritten,
433                                struct buffer_head *fe_bh,
434                                handle_t *handle,
435                                struct ocfs2_alloc_context *data_ac,
436                                struct ocfs2_alloc_context *meta_ac,
437                                enum ocfs2_alloc_restarted *reason_ret)
438 {
439         int status = 0;
440         int free_extents;
441         struct ocfs2_dinode *fe = (struct ocfs2_dinode *) fe_bh->b_data;
442         enum ocfs2_alloc_restarted reason = RESTART_NONE;
443         u32 bit_off, num_bits;
444         u64 block;
445         u8 flags = 0;
446
447         BUG_ON(!clusters_to_add);
448
449         if (mark_unwritten)
450                 flags = OCFS2_EXT_UNWRITTEN;
451
452         free_extents = ocfs2_num_free_extents(osb, inode, fe);
453         if (free_extents < 0) {
454                 status = free_extents;
455                 mlog_errno(status);
456                 goto leave;
457         }
458
459         /* there are two cases which could cause us to EAGAIN in the
460          * we-need-more-metadata case:
461          * 1) we haven't reserved *any*
462          * 2) we are so fragmented, we've needed to add metadata too
463          *    many times. */
464         if (!free_extents && !meta_ac) {
465                 mlog(0, "we haven't reserved any metadata!\n");
466                 status = -EAGAIN;
467                 reason = RESTART_META;
468                 goto leave;
469         } else if ((!free_extents)
470                    && (ocfs2_alloc_context_bits_left(meta_ac)
471                        < ocfs2_extend_meta_needed(fe))) {
472                 mlog(0, "filesystem is really fragmented...\n");
473                 status = -EAGAIN;
474                 reason = RESTART_META;
475                 goto leave;
476         }
477
478         status = ocfs2_claim_clusters(osb, handle, data_ac, 1,
479                                       &bit_off, &num_bits);
480         if (status < 0) {
481                 if (status != -ENOSPC)
482                         mlog_errno(status);
483                 goto leave;
484         }
485
486         BUG_ON(num_bits > clusters_to_add);
487
488         /* reserve our write early -- insert_extent may update the inode */
489         status = ocfs2_journal_access(handle, inode, fe_bh,
490                                       OCFS2_JOURNAL_ACCESS_WRITE);
491         if (status < 0) {
492                 mlog_errno(status);
493                 goto leave;
494         }
495
496         block = ocfs2_clusters_to_blocks(osb->sb, bit_off);
497         mlog(0, "Allocating %u clusters at block %u for inode %llu\n",
498              num_bits, bit_off, (unsigned long long)OCFS2_I(inode)->ip_blkno);
499         status = ocfs2_insert_extent(osb, handle, inode, fe_bh,
500                                      *logical_offset, block, num_bits,
501                                      flags, meta_ac);
502         if (status < 0) {
503                 mlog_errno(status);
504                 goto leave;
505         }
506
507         status = ocfs2_journal_dirty(handle, fe_bh);
508         if (status < 0) {
509                 mlog_errno(status);
510                 goto leave;
511         }
512
513         clusters_to_add -= num_bits;
514         *logical_offset += num_bits;
515
516         if (clusters_to_add) {
517                 mlog(0, "need to alloc once more, clusters = %u, wanted = "
518                      "%u\n", fe->i_clusters, clusters_to_add);
519                 status = -EAGAIN;
520                 reason = RESTART_TRANS;
521         }
522
523 leave:
524         mlog_exit(status);
525         if (reason_ret)
526                 *reason_ret = reason;
527         return status;
528 }
529
530 /*
531  * For a given allocation, determine which allocators will need to be
532  * accessed, and lock them, reserving the appropriate number of bits.
533  *
534  * Sparse file systems call this from ocfs2_write_begin_nolock()
535  * and ocfs2_allocate_unwritten_extents().
536  *
537  * File systems which don't support holes call this from
538  * ocfs2_extend_allocation().
539  */
540 int ocfs2_lock_allocators(struct inode *inode, struct ocfs2_dinode *di,
541                           u32 clusters_to_add, u32 extents_to_split,
542                           struct ocfs2_alloc_context **data_ac,
543                           struct ocfs2_alloc_context **meta_ac)
544 {
545         int ret = 0, num_free_extents;
546         unsigned int max_recs_needed = clusters_to_add + 2 * extents_to_split;
547         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
548
549         *meta_ac = NULL;
550         if (data_ac)
551                 *data_ac = NULL;
552
553         BUG_ON(clusters_to_add != 0 && data_ac == NULL);
554
555         mlog(0, "extend inode %llu, i_size = %lld, di->i_clusters = %u, "
556              "clusters_to_add = %u, extents_to_split = %u\n",
557              (unsigned long long)OCFS2_I(inode)->ip_blkno, i_size_read(inode),
558              le32_to_cpu(di->i_clusters), clusters_to_add, extents_to_split);
559
560         num_free_extents = ocfs2_num_free_extents(osb, inode, di);
561         if (num_free_extents < 0) {
562                 ret = num_free_extents;
563                 mlog_errno(ret);
564                 goto out;
565         }
566
567         /*
568          * Sparse allocation file systems need to be more conservative
569          * with reserving room for expansion - the actual allocation
570          * happens while we've got a journal handle open so re-taking
571          * a cluster lock (because we ran out of room for another
572          * extent) will violate ordering rules.
573          *
574          * Most of the time we'll only be seeing this 1 cluster at a time
575          * anyway.
576          *
577          * Always lock for any unwritten extents - we might want to
578          * add blocks during a split.
579          */
580         if (!num_free_extents ||
581             (ocfs2_sparse_alloc(osb) && num_free_extents < max_recs_needed)) {
582                 ret = ocfs2_reserve_new_metadata(osb, di, meta_ac);
583                 if (ret < 0) {
584                         if (ret != -ENOSPC)
585                                 mlog_errno(ret);
586                         goto out;
587                 }
588         }
589
590         if (clusters_to_add == 0)
591                 goto out;
592
593         ret = ocfs2_reserve_clusters(osb, clusters_to_add, data_ac);
594         if (ret < 0) {
595                 if (ret != -ENOSPC)
596                         mlog_errno(ret);
597                 goto out;
598         }
599
600 out:
601         if (ret) {
602                 if (*meta_ac) {
603                         ocfs2_free_alloc_context(*meta_ac);
604                         *meta_ac = NULL;
605                 }
606
607                 /*
608                  * We cannot have an error and a non null *data_ac.
609                  */
610         }
611
612         return ret;
613 }
614
615 static int __ocfs2_extend_allocation(struct inode *inode, u32 logical_start,
616                                      u32 clusters_to_add, int mark_unwritten)
617 {
618         int status = 0;
619         int restart_func = 0;
620         int credits;
621         u32 prev_clusters;
622         struct buffer_head *bh = NULL;
623         struct ocfs2_dinode *fe = NULL;
624         handle_t *handle = NULL;
625         struct ocfs2_alloc_context *data_ac = NULL;
626         struct ocfs2_alloc_context *meta_ac = NULL;
627         enum ocfs2_alloc_restarted why;
628         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
629
630         mlog_entry("(clusters_to_add = %u)\n", clusters_to_add);
631
632         /*
633          * This function only exists for file systems which don't
634          * support holes.
635          */
636         BUG_ON(mark_unwritten && !ocfs2_sparse_alloc(osb));
637
638         status = ocfs2_read_block(osb, OCFS2_I(inode)->ip_blkno, &bh,
639                                   OCFS2_BH_CACHED, inode);
640         if (status < 0) {
641                 mlog_errno(status);
642                 goto leave;
643         }
644
645         fe = (struct ocfs2_dinode *) bh->b_data;
646         if (!OCFS2_IS_VALID_DINODE(fe)) {
647                 OCFS2_RO_ON_INVALID_DINODE(inode->i_sb, fe);
648                 status = -EIO;
649                 goto leave;
650         }
651
652 restart_all:
653         BUG_ON(le32_to_cpu(fe->i_clusters) != OCFS2_I(inode)->ip_clusters);
654
655         status = ocfs2_lock_allocators(inode, fe, clusters_to_add, 0, &data_ac,
656                                        &meta_ac);
657         if (status) {
658                 mlog_errno(status);
659                 goto leave;
660         }
661
662         credits = ocfs2_calc_extend_credits(osb->sb, fe, clusters_to_add);
663         handle = ocfs2_start_trans(osb, credits);
664         if (IS_ERR(handle)) {
665                 status = PTR_ERR(handle);
666                 handle = NULL;
667                 mlog_errno(status);
668                 goto leave;
669         }
670
671 restarted_transaction:
672         /* reserve a write to the file entry early on - that we if we
673          * run out of credits in the allocation path, we can still
674          * update i_size. */
675         status = ocfs2_journal_access(handle, inode, bh,
676                                       OCFS2_JOURNAL_ACCESS_WRITE);
677         if (status < 0) {
678                 mlog_errno(status);
679                 goto leave;
680         }
681
682         prev_clusters = OCFS2_I(inode)->ip_clusters;
683
684         status = ocfs2_do_extend_allocation(osb,
685                                             inode,
686                                             &logical_start,
687                                             clusters_to_add,
688                                             mark_unwritten,
689                                             bh,
690                                             handle,
691                                             data_ac,
692                                             meta_ac,
693                                             &why);
694         if ((status < 0) && (status != -EAGAIN)) {
695                 if (status != -ENOSPC)
696                         mlog_errno(status);
697                 goto leave;
698         }
699
700         status = ocfs2_journal_dirty(handle, bh);
701         if (status < 0) {
702                 mlog_errno(status);
703                 goto leave;
704         }
705
706         spin_lock(&OCFS2_I(inode)->ip_lock);
707         clusters_to_add -= (OCFS2_I(inode)->ip_clusters - prev_clusters);
708         spin_unlock(&OCFS2_I(inode)->ip_lock);
709
710         if (why != RESTART_NONE && clusters_to_add) {
711                 if (why == RESTART_META) {
712                         mlog(0, "restarting function.\n");
713                         restart_func = 1;
714                 } else {
715                         BUG_ON(why != RESTART_TRANS);
716
717                         mlog(0, "restarting transaction.\n");
718                         /* TODO: This can be more intelligent. */
719                         credits = ocfs2_calc_extend_credits(osb->sb,
720                                                             fe,
721                                                             clusters_to_add);
722                         status = ocfs2_extend_trans(handle, credits);
723                         if (status < 0) {
724                                 /* handle still has to be committed at
725                                  * this point. */
726                                 status = -ENOMEM;
727                                 mlog_errno(status);
728                                 goto leave;
729                         }
730                         goto restarted_transaction;
731                 }
732         }
733
734         mlog(0, "fe: i_clusters = %u, i_size=%llu\n",
735              le32_to_cpu(fe->i_clusters),
736              (unsigned long long)le64_to_cpu(fe->i_size));
737         mlog(0, "inode: ip_clusters=%u, i_size=%lld\n",
738              OCFS2_I(inode)->ip_clusters, i_size_read(inode));
739
740 leave:
741         if (handle) {
742                 ocfs2_commit_trans(osb, handle);
743                 handle = NULL;
744         }
745         if (data_ac) {
746                 ocfs2_free_alloc_context(data_ac);
747                 data_ac = NULL;
748         }
749         if (meta_ac) {
750                 ocfs2_free_alloc_context(meta_ac);
751                 meta_ac = NULL;
752         }
753         if ((!status) && restart_func) {
754                 restart_func = 0;
755                 goto restart_all;
756         }
757         if (bh) {
758                 brelse(bh);
759                 bh = NULL;
760         }
761
762         mlog_exit(status);
763         return status;
764 }
765
766 static int ocfs2_extend_allocation(struct inode *inode, u32 logical_start,
767                                    u32 clusters_to_add, int mark_unwritten)
768 {
769         int ret;
770
771         /*
772          * The alloc sem blocks peope in read/write from reading our
773          * allocation until we're done changing it. We depend on
774          * i_mutex to block other extend/truncate calls while we're
775          * here.
776          */
777         down_write(&OCFS2_I(inode)->ip_alloc_sem);
778         ret = __ocfs2_extend_allocation(inode, logical_start, clusters_to_add,
779                                         mark_unwritten);
780         up_write(&OCFS2_I(inode)->ip_alloc_sem);
781
782         return ret;
783 }
784
785 /* Some parts of this taken from generic_cont_expand, which turned out
786  * to be too fragile to do exactly what we need without us having to
787  * worry about recursive locking in ->prepare_write() and
788  * ->commit_write(). */
789 static int ocfs2_write_zero_page(struct inode *inode,
790                                  u64 size)
791 {
792         struct address_space *mapping = inode->i_mapping;
793         struct page *page;
794         unsigned long index;
795         unsigned int offset;
796         handle_t *handle = NULL;
797         int ret;
798
799         offset = (size & (PAGE_CACHE_SIZE-1)); /* Within page */
800         /* ugh.  in prepare/commit_write, if from==to==start of block, we 
801         ** skip the prepare.  make sure we never send an offset for the start
802         ** of a block
803         */
804         if ((offset & (inode->i_sb->s_blocksize - 1)) == 0) {
805                 offset++;
806         }
807         index = size >> PAGE_CACHE_SHIFT;
808
809         page = grab_cache_page(mapping, index);
810         if (!page) {
811                 ret = -ENOMEM;
812                 mlog_errno(ret);
813                 goto out;
814         }
815
816         ret = ocfs2_prepare_write_nolock(inode, page, offset, offset);
817         if (ret < 0) {
818                 mlog_errno(ret);
819                 goto out_unlock;
820         }
821
822         if (ocfs2_should_order_data(inode)) {
823                 handle = ocfs2_start_walk_page_trans(inode, page, offset,
824                                                      offset);
825                 if (IS_ERR(handle)) {
826                         ret = PTR_ERR(handle);
827                         handle = NULL;
828                         goto out_unlock;
829                 }
830         }
831
832         /* must not update i_size! */
833         ret = block_commit_write(page, offset, offset);
834         if (ret < 0)
835                 mlog_errno(ret);
836         else
837                 ret = 0;
838
839         if (handle)
840                 ocfs2_commit_trans(OCFS2_SB(inode->i_sb), handle);
841 out_unlock:
842         unlock_page(page);
843         page_cache_release(page);
844 out:
845         return ret;
846 }
847
848 static int ocfs2_zero_extend(struct inode *inode,
849                              u64 zero_to_size)
850 {
851         int ret = 0;
852         u64 start_off;
853         struct super_block *sb = inode->i_sb;
854
855         start_off = ocfs2_align_bytes_to_blocks(sb, i_size_read(inode));
856         while (start_off < zero_to_size) {
857                 ret = ocfs2_write_zero_page(inode, start_off);
858                 if (ret < 0) {
859                         mlog_errno(ret);
860                         goto out;
861                 }
862
863                 start_off += sb->s_blocksize;
864
865                 /*
866                  * Very large extends have the potential to lock up
867                  * the cpu for extended periods of time.
868                  */
869                 cond_resched();
870         }
871
872 out:
873         return ret;
874 }
875
876 /* 
877  * A tail_to_skip value > 0 indicates that we're being called from
878  * ocfs2_file_aio_write(). This has the following implications:
879  *
880  * - we don't want to update i_size
881  * - di_bh will be NULL, which is fine because it's only used in the
882  *   case where we want to update i_size.
883  * - ocfs2_zero_extend() will then only be filling the hole created
884  *   between i_size and the start of the write.
885  */
886 static int ocfs2_extend_file(struct inode *inode,
887                              struct buffer_head *di_bh,
888                              u64 new_i_size,
889                              size_t tail_to_skip)
890 {
891         int ret = 0;
892         u32 clusters_to_add = 0;
893
894         BUG_ON(!tail_to_skip && !di_bh);
895
896         /* setattr sometimes calls us like this. */
897         if (new_i_size == 0)
898                 goto out;
899
900         if (i_size_read(inode) == new_i_size)
901                 goto out;
902         BUG_ON(new_i_size < i_size_read(inode));
903
904         if (ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb))) {
905                 BUG_ON(tail_to_skip != 0);
906                 goto out_update_size;
907         }
908
909         clusters_to_add = ocfs2_clusters_for_bytes(inode->i_sb, new_i_size) - 
910                 OCFS2_I(inode)->ip_clusters;
911
912         /* 
913          * protect the pages that ocfs2_zero_extend is going to be
914          * pulling into the page cache.. we do this before the
915          * metadata extend so that we don't get into the situation
916          * where we've extended the metadata but can't get the data
917          * lock to zero.
918          */
919         ret = ocfs2_data_lock(inode, 1);
920         if (ret < 0) {
921                 mlog_errno(ret);
922                 goto out;
923         }
924
925         if (clusters_to_add) {
926                 ret = ocfs2_extend_allocation(inode,
927                                               OCFS2_I(inode)->ip_clusters,
928                                               clusters_to_add, 0);
929                 if (ret < 0) {
930                         mlog_errno(ret);
931                         goto out_unlock;
932                 }
933         }
934
935         /*
936          * Call this even if we don't add any clusters to the tree. We
937          * still need to zero the area between the old i_size and the
938          * new i_size.
939          */
940         ret = ocfs2_zero_extend(inode, (u64)new_i_size - tail_to_skip);
941         if (ret < 0) {
942                 mlog_errno(ret);
943                 goto out_unlock;
944         }
945
946 out_update_size:
947         if (!tail_to_skip) {
948                 /* We're being called from ocfs2_setattr() which wants
949                  * us to update i_size */
950                 ret = ocfs2_simple_size_update(inode, di_bh, new_i_size);
951                 if (ret < 0)
952                         mlog_errno(ret);
953         }
954
955 out_unlock:
956         if (!ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb)))
957                 ocfs2_data_unlock(inode, 1);
958
959 out:
960         return ret;
961 }
962
963 int ocfs2_setattr(struct dentry *dentry, struct iattr *attr)
964 {
965         int status = 0, size_change;
966         struct inode *inode = dentry->d_inode;
967         struct super_block *sb = inode->i_sb;
968         struct ocfs2_super *osb = OCFS2_SB(sb);
969         struct buffer_head *bh = NULL;
970         handle_t *handle = NULL;
971
972         mlog_entry("(0x%p, '%.*s')\n", dentry,
973                    dentry->d_name.len, dentry->d_name.name);
974
975         if (attr->ia_valid & ATTR_MODE)
976                 mlog(0, "mode change: %d\n", attr->ia_mode);
977         if (attr->ia_valid & ATTR_UID)
978                 mlog(0, "uid change: %d\n", attr->ia_uid);
979         if (attr->ia_valid & ATTR_GID)
980                 mlog(0, "gid change: %d\n", attr->ia_gid);
981         if (attr->ia_valid & ATTR_SIZE)
982                 mlog(0, "size change...\n");
983         if (attr->ia_valid & (ATTR_ATIME | ATTR_MTIME | ATTR_CTIME))
984                 mlog(0, "time change...\n");
985
986 #define OCFS2_VALID_ATTRS (ATTR_ATIME | ATTR_MTIME | ATTR_CTIME | ATTR_SIZE \
987                            | ATTR_GID | ATTR_UID | ATTR_MODE)
988         if (!(attr->ia_valid & OCFS2_VALID_ATTRS)) {
989                 mlog(0, "can't handle attrs: 0x%x\n", attr->ia_valid);
990                 return 0;
991         }
992
993         status = inode_change_ok(inode, attr);
994         if (status)
995                 return status;
996
997         size_change = S_ISREG(inode->i_mode) && attr->ia_valid & ATTR_SIZE;
998         if (size_change) {
999                 status = ocfs2_rw_lock(inode, 1);
1000                 if (status < 0) {
1001                         mlog_errno(status);
1002                         goto bail;
1003                 }
1004         }
1005
1006         status = ocfs2_meta_lock(inode, &bh, 1);
1007         if (status < 0) {
1008                 if (status != -ENOENT)
1009                         mlog_errno(status);
1010                 goto bail_unlock_rw;
1011         }
1012
1013         if (size_change && attr->ia_size != i_size_read(inode)) {
1014                 if (i_size_read(inode) > attr->ia_size)
1015                         status = ocfs2_truncate_file(inode, bh, attr->ia_size);
1016                 else
1017                         status = ocfs2_extend_file(inode, bh, attr->ia_size, 0);
1018                 if (status < 0) {
1019                         if (status != -ENOSPC)
1020                                 mlog_errno(status);
1021                         status = -ENOSPC;
1022                         goto bail_unlock;
1023                 }
1024         }
1025
1026         handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
1027         if (IS_ERR(handle)) {
1028                 status = PTR_ERR(handle);
1029                 mlog_errno(status);
1030                 goto bail_unlock;
1031         }
1032
1033         /*
1034          * This will intentionally not wind up calling vmtruncate(),
1035          * since all the work for a size change has been done above.
1036          * Otherwise, we could get into problems with truncate as
1037          * ip_alloc_sem is used there to protect against i_size
1038          * changes.
1039          */
1040         status = inode_setattr(inode, attr);
1041         if (status < 0) {
1042                 mlog_errno(status);
1043                 goto bail_commit;
1044         }
1045
1046         status = ocfs2_mark_inode_dirty(handle, inode, bh);
1047         if (status < 0)
1048                 mlog_errno(status);
1049
1050 bail_commit:
1051         ocfs2_commit_trans(osb, handle);
1052 bail_unlock:
1053         ocfs2_meta_unlock(inode, 1);
1054 bail_unlock_rw:
1055         if (size_change)
1056                 ocfs2_rw_unlock(inode, 1);
1057 bail:
1058         if (bh)
1059                 brelse(bh);
1060
1061         mlog_exit(status);
1062         return status;
1063 }
1064
1065 int ocfs2_getattr(struct vfsmount *mnt,
1066                   struct dentry *dentry,
1067                   struct kstat *stat)
1068 {
1069         struct inode *inode = dentry->d_inode;
1070         struct super_block *sb = dentry->d_inode->i_sb;
1071         struct ocfs2_super *osb = sb->s_fs_info;
1072         int err;
1073
1074         mlog_entry_void();
1075
1076         err = ocfs2_inode_revalidate(dentry);
1077         if (err) {
1078                 if (err != -ENOENT)
1079                         mlog_errno(err);
1080                 goto bail;
1081         }
1082
1083         generic_fillattr(inode, stat);
1084
1085         /* We set the blksize from the cluster size for performance */
1086         stat->blksize = osb->s_clustersize;
1087
1088 bail:
1089         mlog_exit(err);
1090
1091         return err;
1092 }
1093
1094 int ocfs2_permission(struct inode *inode, int mask, struct nameidata *nd)
1095 {
1096         int ret;
1097
1098         mlog_entry_void();
1099
1100         ret = ocfs2_meta_lock(inode, NULL, 0);
1101         if (ret) {
1102                 if (ret != -ENOENT)
1103                         mlog_errno(ret);
1104                 goto out;
1105         }
1106
1107         ret = generic_permission(inode, mask, NULL);
1108
1109         ocfs2_meta_unlock(inode, 0);
1110 out:
1111         mlog_exit(ret);
1112         return ret;
1113 }
1114
1115 static int __ocfs2_write_remove_suid(struct inode *inode,
1116                                      struct buffer_head *bh)
1117 {
1118         int ret;
1119         handle_t *handle;
1120         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1121         struct ocfs2_dinode *di;
1122
1123         mlog_entry("(Inode %llu, mode 0%o)\n",
1124                    (unsigned long long)OCFS2_I(inode)->ip_blkno, inode->i_mode);
1125
1126         handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
1127         if (handle == NULL) {
1128                 ret = -ENOMEM;
1129                 mlog_errno(ret);
1130                 goto out;
1131         }
1132
1133         ret = ocfs2_journal_access(handle, inode, bh,
1134                                    OCFS2_JOURNAL_ACCESS_WRITE);
1135         if (ret < 0) {
1136                 mlog_errno(ret);
1137                 goto out_trans;
1138         }
1139
1140         inode->i_mode &= ~S_ISUID;
1141         if ((inode->i_mode & S_ISGID) && (inode->i_mode & S_IXGRP))
1142                 inode->i_mode &= ~S_ISGID;
1143
1144         di = (struct ocfs2_dinode *) bh->b_data;
1145         di->i_mode = cpu_to_le16(inode->i_mode);
1146
1147         ret = ocfs2_journal_dirty(handle, bh);
1148         if (ret < 0)
1149                 mlog_errno(ret);
1150
1151 out_trans:
1152         ocfs2_commit_trans(osb, handle);
1153 out:
1154         mlog_exit(ret);
1155         return ret;
1156 }
1157
1158 /*
1159  * Will look for holes and unwritten extents in the range starting at
1160  * pos for count bytes (inclusive).
1161  */
1162 static int ocfs2_check_range_for_holes(struct inode *inode, loff_t pos,
1163                                        size_t count)
1164 {
1165         int ret = 0;
1166         unsigned int extent_flags;
1167         u32 cpos, clusters, extent_len, phys_cpos;
1168         struct super_block *sb = inode->i_sb;
1169
1170         cpos = pos >> OCFS2_SB(sb)->s_clustersize_bits;
1171         clusters = ocfs2_clusters_for_bytes(sb, pos + count) - cpos;
1172
1173         while (clusters) {
1174                 ret = ocfs2_get_clusters(inode, cpos, &phys_cpos, &extent_len,
1175                                          &extent_flags);
1176                 if (ret < 0) {
1177                         mlog_errno(ret);
1178                         goto out;
1179                 }
1180
1181                 if (phys_cpos == 0 || (extent_flags & OCFS2_EXT_UNWRITTEN)) {
1182                         ret = 1;
1183                         break;
1184                 }
1185
1186                 if (extent_len > clusters)
1187                         extent_len = clusters;
1188
1189                 clusters -= extent_len;
1190                 cpos += extent_len;
1191         }
1192 out:
1193         return ret;
1194 }
1195
1196 static int ocfs2_write_remove_suid(struct inode *inode)
1197 {
1198         int ret;
1199         struct buffer_head *bh = NULL;
1200         struct ocfs2_inode_info *oi = OCFS2_I(inode);
1201
1202         ret = ocfs2_read_block(OCFS2_SB(inode->i_sb),
1203                                oi->ip_blkno, &bh, OCFS2_BH_CACHED, inode);
1204         if (ret < 0) {
1205                 mlog_errno(ret);
1206                 goto out;
1207         }
1208
1209         ret =  __ocfs2_write_remove_suid(inode, bh);
1210 out:
1211         brelse(bh);
1212         return ret;
1213 }
1214
1215 /*
1216  * Allocate enough extents to cover the region starting at byte offset
1217  * start for len bytes. Existing extents are skipped, any extents
1218  * added are marked as "unwritten".
1219  */
1220 static int ocfs2_allocate_unwritten_extents(struct inode *inode,
1221                                             u64 start, u64 len)
1222 {
1223         int ret;
1224         u32 cpos, phys_cpos, clusters, alloc_size;
1225
1226         /*
1227          * We consider both start and len to be inclusive.
1228          */
1229         cpos = start >> OCFS2_SB(inode->i_sb)->s_clustersize_bits;
1230         clusters = ocfs2_clusters_for_bytes(inode->i_sb, start + len);
1231         clusters -= cpos;
1232
1233         while (clusters) {
1234                 ret = ocfs2_get_clusters(inode, cpos, &phys_cpos,
1235                                          &alloc_size, NULL);
1236                 if (ret) {
1237                         mlog_errno(ret);
1238                         goto out;
1239                 }
1240
1241                 /*
1242                  * Hole or existing extent len can be arbitrary, so
1243                  * cap it to our own allocation request.
1244                  */
1245                 if (alloc_size > clusters)
1246                         alloc_size = clusters;
1247
1248                 if (phys_cpos) {
1249                         /*
1250                          * We already have an allocation at this
1251                          * region so we can safely skip it.
1252                          */
1253                         goto next;
1254                 }
1255
1256                 ret = __ocfs2_extend_allocation(inode, cpos, alloc_size, 1);
1257                 if (ret) {
1258                         if (ret != -ENOSPC)
1259                                 mlog_errno(ret);
1260                         goto out;
1261                 }
1262
1263 next:
1264                 cpos += alloc_size;
1265                 clusters -= alloc_size;
1266         }
1267
1268         ret = 0;
1269 out:
1270         return ret;
1271 }
1272
1273 static int __ocfs2_remove_inode_range(struct inode *inode,
1274                                       struct buffer_head *di_bh,
1275                                       u32 cpos, u32 phys_cpos, u32 len,
1276                                       struct ocfs2_cached_dealloc_ctxt *dealloc)
1277 {
1278         int ret;
1279         u64 phys_blkno = ocfs2_clusters_to_blocks(inode->i_sb, phys_cpos);
1280         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1281         struct inode *tl_inode = osb->osb_tl_inode;
1282         handle_t *handle;
1283         struct ocfs2_alloc_context *meta_ac = NULL;
1284         struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
1285
1286         ret = ocfs2_lock_allocators(inode, di, 0, 1, NULL, &meta_ac);
1287         if (ret) {
1288                 mlog_errno(ret);
1289                 return ret;
1290         }
1291
1292         mutex_lock(&tl_inode->i_mutex);
1293
1294         if (ocfs2_truncate_log_needs_flush(osb)) {
1295                 ret = __ocfs2_flush_truncate_log(osb);
1296                 if (ret < 0) {
1297                         mlog_errno(ret);
1298                         goto out;
1299                 }
1300         }
1301
1302         handle = ocfs2_start_trans(osb, OCFS2_REMOVE_EXTENT_CREDITS);
1303         if (handle == NULL) {
1304                 ret = -ENOMEM;
1305                 mlog_errno(ret);
1306                 goto out;
1307         }
1308
1309         ret = ocfs2_journal_access(handle, inode, di_bh,
1310                                    OCFS2_JOURNAL_ACCESS_WRITE);
1311         if (ret) {
1312                 mlog_errno(ret);
1313                 goto out;
1314         }
1315
1316         ret = ocfs2_remove_extent(inode, di_bh, cpos, len, handle, meta_ac,
1317                                   dealloc);
1318         if (ret) {
1319                 mlog_errno(ret);
1320                 goto out_commit;
1321         }
1322
1323         OCFS2_I(inode)->ip_clusters -= len;
1324         di->i_clusters = cpu_to_le32(OCFS2_I(inode)->ip_clusters);
1325
1326         ret = ocfs2_journal_dirty(handle, di_bh);
1327         if (ret) {
1328                 mlog_errno(ret);
1329                 goto out_commit;
1330         }
1331
1332         ret = ocfs2_truncate_log_append(osb, handle, phys_blkno, len);
1333         if (ret)
1334                 mlog_errno(ret);
1335
1336 out_commit:
1337         ocfs2_commit_trans(osb, handle);
1338 out:
1339         mutex_unlock(&tl_inode->i_mutex);
1340
1341         if (meta_ac)
1342                 ocfs2_free_alloc_context(meta_ac);
1343
1344         return ret;
1345 }
1346
1347 /*
1348  * Truncate a byte range, avoiding pages within partial clusters. This
1349  * preserves those pages for the zeroing code to write to.
1350  */
1351 static void ocfs2_truncate_cluster_pages(struct inode *inode, u64 byte_start,
1352                                          u64 byte_len)
1353 {
1354         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1355         loff_t start, end;
1356         struct address_space *mapping = inode->i_mapping;
1357
1358         start = (loff_t)ocfs2_align_bytes_to_clusters(inode->i_sb, byte_start);
1359         end = byte_start + byte_len;
1360         end = end & ~(osb->s_clustersize - 1);
1361
1362         if (start < end) {
1363                 unmap_mapping_range(mapping, start, end - start, 0);
1364                 truncate_inode_pages_range(mapping, start, end - 1);
1365         }
1366 }
1367
1368 static int ocfs2_zero_partial_clusters(struct inode *inode,
1369                                        u64 start, u64 len)
1370 {
1371         int ret = 0;
1372         u64 tmpend, end = start + len;
1373         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1374         unsigned int csize = osb->s_clustersize;
1375         handle_t *handle;
1376
1377         /*
1378          * The "start" and "end" values are NOT necessarily part of
1379          * the range whose allocation is being deleted. Rather, this
1380          * is what the user passed in with the request. We must zero
1381          * partial clusters here. There's no need to worry about
1382          * physical allocation - the zeroing code knows to skip holes.
1383          */
1384         mlog(0, "byte start: %llu, end: %llu\n",
1385              (unsigned long long)start, (unsigned long long)end);
1386
1387         /*
1388          * If both edges are on a cluster boundary then there's no
1389          * zeroing required as the region is part of the allocation to
1390          * be truncated.
1391          */
1392         if ((start & (csize - 1)) == 0 && (end & (csize - 1)) == 0)
1393                 goto out;
1394
1395         handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
1396         if (handle == NULL) {
1397                 ret = -ENOMEM;
1398                 mlog_errno(ret);
1399                 goto out;
1400         }
1401
1402         /*
1403          * We want to get the byte offset of the end of the 1st cluster.
1404          */
1405         tmpend = (u64)osb->s_clustersize + (start & ~(osb->s_clustersize - 1));
1406         if (tmpend > end)
1407                 tmpend = end;
1408
1409         mlog(0, "1st range: start: %llu, tmpend: %llu\n",
1410              (unsigned long long)start, (unsigned long long)tmpend);
1411
1412         ret = ocfs2_zero_range_for_truncate(inode, handle, start, tmpend);
1413         if (ret)
1414                 mlog_errno(ret);
1415
1416         if (tmpend < end) {
1417                 /*
1418                  * This may make start and end equal, but the zeroing
1419                  * code will skip any work in that case so there's no
1420                  * need to catch it up here.
1421                  */
1422                 start = end & ~(osb->s_clustersize - 1);
1423
1424                 mlog(0, "2nd range: start: %llu, end: %llu\n",
1425                      (unsigned long long)start, (unsigned long long)end);
1426
1427                 ret = ocfs2_zero_range_for_truncate(inode, handle, start, end);
1428                 if (ret)
1429                         mlog_errno(ret);
1430         }
1431
1432         ocfs2_commit_trans(osb, handle);
1433 out:
1434         return ret;
1435 }
1436
1437 static int ocfs2_remove_inode_range(struct inode *inode,
1438                                     struct buffer_head *di_bh, u64 byte_start,
1439                                     u64 byte_len)
1440 {
1441         int ret = 0;
1442         u32 trunc_start, trunc_len, cpos, phys_cpos, alloc_size;
1443         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1444         struct ocfs2_cached_dealloc_ctxt dealloc;
1445
1446         ocfs2_init_dealloc_ctxt(&dealloc);
1447
1448         if (byte_len == 0)
1449                 return 0;
1450
1451         trunc_start = ocfs2_clusters_for_bytes(osb->sb, byte_start);
1452         trunc_len = (byte_start + byte_len) >> osb->s_clustersize_bits;
1453         if (trunc_len >= trunc_start)
1454                 trunc_len -= trunc_start;
1455         else
1456                 trunc_len = 0;
1457
1458         mlog(0, "Inode: %llu, start: %llu, len: %llu, cstart: %u, clen: %u\n",
1459              (unsigned long long)OCFS2_I(inode)->ip_blkno,
1460              (unsigned long long)byte_start,
1461              (unsigned long long)byte_len, trunc_start, trunc_len);
1462
1463         ret = ocfs2_zero_partial_clusters(inode, byte_start, byte_len);
1464         if (ret) {
1465                 mlog_errno(ret);
1466                 goto out;
1467         }
1468
1469         cpos = trunc_start;
1470         while (trunc_len) {
1471                 ret = ocfs2_get_clusters(inode, cpos, &phys_cpos,
1472                                          &alloc_size, NULL);
1473                 if (ret) {
1474                         mlog_errno(ret);
1475                         goto out;
1476                 }
1477
1478                 if (alloc_size > trunc_len)
1479                         alloc_size = trunc_len;
1480
1481                 /* Only do work for non-holes */
1482                 if (phys_cpos != 0) {
1483                         ret = __ocfs2_remove_inode_range(inode, di_bh, cpos,
1484                                                          phys_cpos, alloc_size,
1485                                                          &dealloc);
1486                         if (ret) {
1487                                 mlog_errno(ret);
1488                                 goto out;
1489                         }
1490                 }
1491
1492                 cpos += alloc_size;
1493                 trunc_len -= alloc_size;
1494         }
1495
1496         ocfs2_truncate_cluster_pages(inode, byte_start, byte_len);
1497
1498 out:
1499         ocfs2_schedule_truncate_log_flush(osb, 1);
1500         ocfs2_run_deallocs(osb, &dealloc);
1501
1502         return ret;
1503 }
1504
1505 /*
1506  * Parts of this function taken from xfs_change_file_space()
1507  */
1508 static int __ocfs2_change_file_space(struct file *file, struct inode *inode,
1509                                      loff_t f_pos, unsigned int cmd,
1510                                      struct ocfs2_space_resv *sr,
1511                                      int change_size)
1512 {
1513         int ret;
1514         s64 llen;
1515         loff_t size;
1516         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1517         struct buffer_head *di_bh = NULL;
1518         handle_t *handle;
1519         unsigned long long max_off = ocfs2_max_file_offset(inode->i_sb->s_blocksize_bits);
1520
1521         if (ocfs2_is_hard_readonly(osb) || ocfs2_is_soft_readonly(osb))
1522                 return -EROFS;
1523
1524         mutex_lock(&inode->i_mutex);
1525
1526         /*
1527          * This prevents concurrent writes on other nodes
1528          */
1529         ret = ocfs2_rw_lock(inode, 1);
1530         if (ret) {
1531                 mlog_errno(ret);
1532                 goto out;
1533         }
1534
1535         ret = ocfs2_meta_lock(inode, &di_bh, 1);
1536         if (ret) {
1537                 mlog_errno(ret);
1538                 goto out_rw_unlock;
1539         }
1540
1541         if (inode->i_flags & (S_IMMUTABLE|S_APPEND)) {
1542                 ret = -EPERM;
1543                 goto out_meta_unlock;
1544         }
1545
1546         switch (sr->l_whence) {
1547         case 0: /*SEEK_SET*/
1548                 break;
1549         case 1: /*SEEK_CUR*/
1550                 sr->l_start += f_pos;
1551                 break;
1552         case 2: /*SEEK_END*/
1553                 sr->l_start += i_size_read(inode);
1554                 break;
1555         default:
1556                 ret = -EINVAL;
1557                 goto out_meta_unlock;
1558         }
1559         sr->l_whence = 0;
1560
1561         llen = sr->l_len > 0 ? sr->l_len - 1 : sr->l_len;
1562
1563         if (sr->l_start < 0
1564             || sr->l_start > max_off
1565             || (sr->l_start + llen) < 0
1566             || (sr->l_start + llen) > max_off) {
1567                 ret = -EINVAL;
1568                 goto out_meta_unlock;
1569         }
1570         size = sr->l_start + sr->l_len;
1571
1572         if (cmd == OCFS2_IOC_RESVSP || cmd == OCFS2_IOC_RESVSP64) {
1573                 if (sr->l_len <= 0) {
1574                         ret = -EINVAL;
1575                         goto out_meta_unlock;
1576                 }
1577         }
1578
1579         if (file && should_remove_suid(file->f_path.dentry)) {
1580                 ret = __ocfs2_write_remove_suid(inode, di_bh);
1581                 if (ret) {
1582                         mlog_errno(ret);
1583                         goto out_meta_unlock;
1584                 }
1585         }
1586
1587         down_write(&OCFS2_I(inode)->ip_alloc_sem);
1588         switch (cmd) {
1589         case OCFS2_IOC_RESVSP:
1590         case OCFS2_IOC_RESVSP64:
1591                 /*
1592                  * This takes unsigned offsets, but the signed ones we
1593                  * pass have been checked against overflow above.
1594                  */
1595                 ret = ocfs2_allocate_unwritten_extents(inode, sr->l_start,
1596                                                        sr->l_len);
1597                 break;
1598         case OCFS2_IOC_UNRESVSP:
1599         case OCFS2_IOC_UNRESVSP64:
1600                 ret = ocfs2_remove_inode_range(inode, di_bh, sr->l_start,
1601                                                sr->l_len);
1602                 break;
1603         default:
1604                 ret = -EINVAL;
1605         }
1606         up_write(&OCFS2_I(inode)->ip_alloc_sem);
1607         if (ret) {
1608                 mlog_errno(ret);
1609                 goto out_meta_unlock;
1610         }
1611
1612         /*
1613          * We update c/mtime for these changes
1614          */
1615         handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
1616         if (IS_ERR(handle)) {
1617                 ret = PTR_ERR(handle);
1618                 mlog_errno(ret);
1619                 goto out_meta_unlock;
1620         }
1621
1622         if (change_size && i_size_read(inode) < size)
1623                 i_size_write(inode, size);
1624
1625         inode->i_ctime = inode->i_mtime = CURRENT_TIME;
1626         ret = ocfs2_mark_inode_dirty(handle, inode, di_bh);
1627         if (ret < 0)
1628                 mlog_errno(ret);
1629
1630         ocfs2_commit_trans(osb, handle);
1631
1632 out_meta_unlock:
1633         brelse(di_bh);
1634         ocfs2_meta_unlock(inode, 1);
1635 out_rw_unlock:
1636         ocfs2_rw_unlock(inode, 1);
1637
1638         mutex_unlock(&inode->i_mutex);
1639 out:
1640         return ret;
1641 }
1642
1643 int ocfs2_change_file_space(struct file *file, unsigned int cmd,
1644                             struct ocfs2_space_resv *sr)
1645 {
1646         struct inode *inode = file->f_path.dentry->d_inode;
1647         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);;
1648
1649         if ((cmd == OCFS2_IOC_RESVSP || cmd == OCFS2_IOC_RESVSP64) &&
1650             !ocfs2_writes_unwritten_extents(osb))
1651                 return -ENOTTY;
1652         else if ((cmd == OCFS2_IOC_UNRESVSP || cmd == OCFS2_IOC_UNRESVSP64) &&
1653                  !ocfs2_sparse_alloc(osb))
1654                 return -ENOTTY;
1655
1656         if (!S_ISREG(inode->i_mode))
1657                 return -EINVAL;
1658
1659         if (!(file->f_mode & FMODE_WRITE))
1660                 return -EBADF;
1661
1662         return __ocfs2_change_file_space(file, inode, file->f_pos, cmd, sr, 0);
1663 }
1664
1665 static long ocfs2_fallocate(struct inode *inode, int mode, loff_t offset,
1666                             loff_t len)
1667 {
1668         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1669         struct ocfs2_space_resv sr;
1670         int change_size = 1;
1671
1672         if (!ocfs2_writes_unwritten_extents(osb))
1673                 return -EOPNOTSUPP;
1674
1675         if (S_ISDIR(inode->i_mode))
1676                 return -ENODEV;
1677
1678         if (mode & FALLOC_FL_KEEP_SIZE)
1679                 change_size = 0;
1680
1681         sr.l_whence = 0;
1682         sr.l_start = (s64)offset;
1683         sr.l_len = (s64)len;
1684
1685         return __ocfs2_change_file_space(NULL, inode, offset,
1686                                          OCFS2_IOC_RESVSP64, &sr, change_size);
1687 }
1688
1689 static int ocfs2_prepare_inode_for_write(struct dentry *dentry,
1690                                          loff_t *ppos,
1691                                          size_t count,
1692                                          int appending,
1693                                          int *direct_io)
1694 {
1695         int ret = 0, meta_level = appending;
1696         struct inode *inode = dentry->d_inode;
1697         u32 clusters;
1698         loff_t newsize, saved_pos;
1699
1700         /* 
1701          * We sample i_size under a read level meta lock to see if our write
1702          * is extending the file, if it is we back off and get a write level
1703          * meta lock.
1704          */
1705         for(;;) {
1706                 ret = ocfs2_meta_lock(inode, NULL, meta_level);
1707                 if (ret < 0) {
1708                         meta_level = -1;
1709                         mlog_errno(ret);
1710                         goto out;
1711                 }
1712
1713                 /* Clear suid / sgid if necessary. We do this here
1714                  * instead of later in the write path because
1715                  * remove_suid() calls ->setattr without any hint that
1716                  * we may have already done our cluster locking. Since
1717                  * ocfs2_setattr() *must* take cluster locks to
1718                  * proceeed, this will lead us to recursively lock the
1719                  * inode. There's also the dinode i_size state which
1720                  * can be lost via setattr during extending writes (we
1721                  * set inode->i_size at the end of a write. */
1722                 if (should_remove_suid(dentry)) {
1723                         if (meta_level == 0) {
1724                                 ocfs2_meta_unlock(inode, meta_level);
1725                                 meta_level = 1;
1726                                 continue;
1727                         }
1728
1729                         ret = ocfs2_write_remove_suid(inode);
1730                         if (ret < 0) {
1731                                 mlog_errno(ret);
1732                                 goto out_unlock;
1733                         }
1734                 }
1735
1736                 /* work on a copy of ppos until we're sure that we won't have
1737                  * to recalculate it due to relocking. */
1738                 if (appending) {
1739                         saved_pos = i_size_read(inode);
1740                         mlog(0, "O_APPEND: inode->i_size=%llu\n", saved_pos);
1741                 } else {
1742                         saved_pos = *ppos;
1743                 }
1744
1745                 if (ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb))) {
1746                         loff_t end = saved_pos + count;
1747
1748                         /*
1749                          * Skip the O_DIRECT checks if we don't need
1750                          * them.
1751                          */
1752                         if (!direct_io || !(*direct_io))
1753                                 break;
1754
1755                         /*
1756                          * Allowing concurrent direct writes means
1757                          * i_size changes wouldn't be synchronized, so
1758                          * one node could wind up truncating another
1759                          * nodes writes.
1760                          */
1761                         if (end > i_size_read(inode)) {
1762                                 *direct_io = 0;
1763                                 break;
1764                         }
1765
1766                         /*
1767                          * We don't fill holes during direct io, so
1768                          * check for them here. If any are found, the
1769                          * caller will have to retake some cluster
1770                          * locks and initiate the io as buffered.
1771                          */
1772                         ret = ocfs2_check_range_for_holes(inode, saved_pos,
1773                                                           count);
1774                         if (ret == 1) {
1775                                 *direct_io = 0;
1776                                 ret = 0;
1777                         } else if (ret < 0)
1778                                 mlog_errno(ret);
1779                         break;
1780                 }
1781
1782                 /*
1783                  * The rest of this loop is concerned with legacy file
1784                  * systems which don't support sparse files.
1785                  */
1786
1787                 newsize = count + saved_pos;
1788
1789                 mlog(0, "pos=%lld newsize=%lld cursize=%lld\n",
1790                      (long long) saved_pos, (long long) newsize,
1791                      (long long) i_size_read(inode));
1792
1793                 /* No need for a higher level metadata lock if we're
1794                  * never going past i_size. */
1795                 if (newsize <= i_size_read(inode))
1796                         break;
1797
1798                 if (meta_level == 0) {
1799                         ocfs2_meta_unlock(inode, meta_level);
1800                         meta_level = 1;
1801                         continue;
1802                 }
1803
1804                 spin_lock(&OCFS2_I(inode)->ip_lock);
1805                 clusters = ocfs2_clusters_for_bytes(inode->i_sb, newsize) -
1806                         OCFS2_I(inode)->ip_clusters;
1807                 spin_unlock(&OCFS2_I(inode)->ip_lock);
1808
1809                 mlog(0, "Writing at EOF, may need more allocation: "
1810                      "i_size = %lld, newsize = %lld, need %u clusters\n",
1811                      (long long) i_size_read(inode), (long long) newsize,
1812                      clusters);
1813
1814                 /* We only want to continue the rest of this loop if
1815                  * our extend will actually require more
1816                  * allocation. */
1817                 if (!clusters)
1818                         break;
1819
1820                 ret = ocfs2_extend_file(inode, NULL, newsize, count);
1821                 if (ret < 0) {
1822                         if (ret != -ENOSPC)
1823                                 mlog_errno(ret);
1824                         goto out_unlock;
1825                 }
1826                 break;
1827         }
1828
1829         if (appending)
1830                 *ppos = saved_pos;
1831
1832 out_unlock:
1833         ocfs2_meta_unlock(inode, meta_level);
1834
1835 out:
1836         return ret;
1837 }
1838
1839 static inline void
1840 ocfs2_set_next_iovec(const struct iovec **iovp, size_t *basep, size_t bytes)
1841 {
1842         const struct iovec *iov = *iovp;
1843         size_t base = *basep;
1844
1845         do {
1846                 int copy = min(bytes, iov->iov_len - base);
1847
1848                 bytes -= copy;
1849                 base += copy;
1850                 if (iov->iov_len == base) {
1851                         iov++;
1852                         base = 0;
1853                 }
1854         } while (bytes);
1855         *iovp = iov;
1856         *basep = base;
1857 }
1858
1859 static struct page * ocfs2_get_write_source(char **ret_src_buf,
1860                                             const struct iovec *cur_iov,
1861                                             size_t iov_offset)
1862 {
1863         int ret;
1864         char *buf = cur_iov->iov_base + iov_offset;
1865         struct page *src_page = NULL;
1866         unsigned long off;
1867
1868         off = (unsigned long)(buf) & ~PAGE_CACHE_MASK;
1869
1870         if (!segment_eq(get_fs(), KERNEL_DS)) {
1871                 /*
1872                  * Pull in the user page. We want to do this outside
1873                  * of the meta data locks in order to preserve locking
1874                  * order in case of page fault.
1875                  */
1876                 ret = get_user_pages(current, current->mm,
1877                                      (unsigned long)buf & PAGE_CACHE_MASK, 1,
1878                                      0, 0, &src_page, NULL);
1879                 if (ret == 1)
1880                         *ret_src_buf = kmap(src_page) + off;
1881                 else
1882                         src_page = ERR_PTR(-EFAULT);
1883         } else {
1884                 *ret_src_buf = buf;
1885         }
1886
1887         return src_page;
1888 }
1889
1890 static void ocfs2_put_write_source(struct page *page)
1891 {
1892         if (page) {
1893                 kunmap(page);
1894                 page_cache_release(page);
1895         }
1896 }
1897
1898 static ssize_t ocfs2_file_buffered_write(struct file *file, loff_t *ppos,
1899                                          const struct iovec *iov,
1900                                          unsigned long nr_segs,
1901                                          size_t count,
1902                                          ssize_t o_direct_written)
1903 {
1904         int ret = 0;
1905         ssize_t copied, total = 0;
1906         size_t iov_offset = 0, bytes;
1907         loff_t pos;
1908         const struct iovec *cur_iov = iov;
1909         struct page *user_page, *page;
1910         char * uninitialized_var(buf);
1911         char *dst;
1912         void *fsdata;
1913
1914         /*
1915          * handle partial DIO write.  Adjust cur_iov if needed.
1916          */
1917         ocfs2_set_next_iovec(&cur_iov, &iov_offset, o_direct_written);
1918
1919         do {
1920                 pos = *ppos;
1921
1922                 user_page = ocfs2_get_write_source(&buf, cur_iov, iov_offset);
1923                 if (IS_ERR(user_page)) {
1924                         ret = PTR_ERR(user_page);
1925                         goto out;
1926                 }
1927
1928                 /* Stay within our page boundaries */
1929                 bytes = min((PAGE_CACHE_SIZE - ((unsigned long)pos & ~PAGE_CACHE_MASK)),
1930                             (PAGE_CACHE_SIZE - ((unsigned long)buf & ~PAGE_CACHE_MASK)));
1931                 /* Stay within the vector boundary */
1932                 bytes = min_t(size_t, bytes, cur_iov->iov_len - iov_offset);
1933                 /* Stay within count */
1934                 bytes = min(bytes, count);
1935
1936                 page = NULL;
1937                 ret = ocfs2_write_begin(file, file->f_mapping, pos, bytes, 0,
1938                                         &page, &fsdata);
1939                 if (ret) {
1940                         mlog_errno(ret);
1941                         goto out;
1942                 }
1943
1944                 dst = kmap_atomic(page, KM_USER0);
1945                 memcpy(dst + (pos & (PAGE_CACHE_SIZE - 1)), buf, bytes);
1946                 kunmap_atomic(dst, KM_USER0);
1947                 flush_dcache_page(page);
1948                 ocfs2_put_write_source(user_page);
1949
1950                 copied = ocfs2_write_end(file, file->f_mapping, pos, bytes,
1951                                          bytes, page, fsdata);
1952                 if (copied < 0) {
1953                         mlog_errno(copied);
1954                         ret = copied;
1955                         goto out;
1956                 }
1957
1958                 total += copied;
1959                 *ppos = pos + copied;
1960                 count -= copied;
1961
1962                 ocfs2_set_next_iovec(&cur_iov, &iov_offset, copied);
1963         } while(count);
1964
1965 out:
1966         return total ? total : ret;
1967 }
1968
1969 static ssize_t ocfs2_file_aio_write(struct kiocb *iocb,
1970                                     const struct iovec *iov,
1971                                     unsigned long nr_segs,
1972                                     loff_t pos)
1973 {
1974         int ret, direct_io, appending, rw_level, have_alloc_sem  = 0;
1975         int can_do_direct, sync = 0;
1976         ssize_t written = 0;
1977         size_t ocount;          /* original count */
1978         size_t count;           /* after file limit checks */
1979         loff_t *ppos = &iocb->ki_pos;
1980         struct file *file = iocb->ki_filp;
1981         struct inode *inode = file->f_path.dentry->d_inode;
1982
1983         mlog_entry("(0x%p, %u, '%.*s')\n", file,
1984                    (unsigned int)nr_segs,
1985                    file->f_path.dentry->d_name.len,
1986                    file->f_path.dentry->d_name.name);
1987
1988         if (iocb->ki_left == 0)
1989                 return 0;
1990
1991         ret = generic_segment_checks(iov, &nr_segs, &ocount, VERIFY_READ);
1992         if (ret)
1993                 return ret;
1994
1995         count = ocount;
1996
1997         vfs_check_frozen(inode->i_sb, SB_FREEZE_WRITE);
1998
1999         appending = file->f_flags & O_APPEND ? 1 : 0;
2000         direct_io = file->f_flags & O_DIRECT ? 1 : 0;
2001
2002         mutex_lock(&inode->i_mutex);
2003
2004 relock:
2005         /* to match setattr's i_mutex -> i_alloc_sem -> rw_lock ordering */
2006         if (direct_io) {
2007                 down_read(&inode->i_alloc_sem);
2008                 have_alloc_sem = 1;
2009         }
2010
2011         /* concurrent O_DIRECT writes are allowed */
2012         rw_level = !direct_io;
2013         ret = ocfs2_rw_lock(inode, rw_level);
2014         if (ret < 0) {
2015                 mlog_errno(ret);
2016                 goto out_sems;
2017         }
2018
2019         can_do_direct = direct_io;
2020         ret = ocfs2_prepare_inode_for_write(file->f_path.dentry, ppos,
2021                                             iocb->ki_left, appending,
2022                                             &can_do_direct);
2023         if (ret < 0) {
2024                 mlog_errno(ret);
2025                 goto out;
2026         }
2027
2028         /*
2029          * We can't complete the direct I/O as requested, fall back to
2030          * buffered I/O.
2031          */
2032         if (direct_io && !can_do_direct) {
2033                 ocfs2_rw_unlock(inode, rw_level);
2034                 up_read(&inode->i_alloc_sem);
2035
2036                 have_alloc_sem = 0;
2037                 rw_level = -1;
2038
2039                 direct_io = 0;
2040                 sync = 1;
2041                 goto relock;
2042         }
2043
2044         if (!sync && ((file->f_flags & O_SYNC) || IS_SYNC(inode)))
2045                 sync = 1;
2046
2047         /*
2048          * XXX: Is it ok to execute these checks a second time?
2049          */
2050         ret = generic_write_checks(file, ppos, &count, S_ISBLK(inode->i_mode));
2051         if (ret)
2052                 goto out;
2053
2054         /*
2055          * Set pos so that sync_page_range_nolock() below understands
2056          * where to start from. We might've moved it around via the
2057          * calls above. The range we want to actually sync starts from
2058          * *ppos here.
2059          *
2060          */
2061         pos = *ppos;
2062
2063         /* communicate with ocfs2_dio_end_io */
2064         ocfs2_iocb_set_rw_locked(iocb, rw_level);
2065
2066         if (direct_io) {
2067                 written = generic_file_direct_write(iocb, iov, &nr_segs, *ppos,
2068                                                     ppos, count, ocount);
2069                 if (written < 0) {
2070                         ret = written;
2071                         goto out_dio;
2072                 }
2073         } else {
2074                 written = ocfs2_file_buffered_write(file, ppos, iov, nr_segs,
2075                                                     count, written);
2076                 if (written < 0) {
2077                         ret = written;
2078                         if (ret != -EFAULT || ret != -ENOSPC)
2079                                 mlog_errno(ret);
2080                         goto out;
2081                 }
2082         }
2083
2084 out_dio:
2085         /* buffered aio wouldn't have proper lock coverage today */
2086         BUG_ON(ret == -EIOCBQUEUED && !(file->f_flags & O_DIRECT));
2087
2088         /* 
2089          * deep in g_f_a_w_n()->ocfs2_direct_IO we pass in a ocfs2_dio_end_io
2090          * function pointer which is called when o_direct io completes so that
2091          * it can unlock our rw lock.  (it's the clustered equivalent of
2092          * i_alloc_sem; protects truncate from racing with pending ios).
2093          * Unfortunately there are error cases which call end_io and others
2094          * that don't.  so we don't have to unlock the rw_lock if either an
2095          * async dio is going to do it in the future or an end_io after an
2096          * error has already done it.
2097          */
2098         if (ret == -EIOCBQUEUED || !ocfs2_iocb_is_rw_locked(iocb)) {
2099                 rw_level = -1;
2100                 have_alloc_sem = 0;
2101         }
2102
2103 out:
2104         if (rw_level != -1)
2105                 ocfs2_rw_unlock(inode, rw_level);
2106
2107 out_sems:
2108         if (have_alloc_sem)
2109                 up_read(&inode->i_alloc_sem);
2110
2111         if (written > 0 && sync) {
2112                 ssize_t err;
2113
2114                 err = sync_page_range_nolock(inode, file->f_mapping, pos, count);
2115                 if (err < 0)
2116                         written = err;
2117         }
2118
2119         mutex_unlock(&inode->i_mutex);
2120
2121         mlog_exit(ret);
2122         return written ? written : ret;
2123 }
2124
2125 static int ocfs2_splice_write_actor(struct pipe_inode_info *pipe,
2126                                     struct pipe_buffer *buf,
2127                                     struct splice_desc *sd)
2128 {
2129         int ret, count;
2130         ssize_t copied = 0;
2131         struct file *file = sd->u.file;
2132         unsigned int offset;
2133         struct page *page = NULL;
2134         void *fsdata;
2135         char *src, *dst;
2136
2137         ret = buf->ops->confirm(pipe, buf);
2138         if (ret)
2139                 goto out;
2140
2141         offset = sd->pos & ~PAGE_CACHE_MASK;
2142         count = sd->len;
2143         if (count + offset > PAGE_CACHE_SIZE)
2144                 count = PAGE_CACHE_SIZE - offset;
2145
2146         ret = ocfs2_write_begin(file, file->f_mapping, sd->pos, count, 0,
2147                                 &page, &fsdata);
2148         if (ret) {
2149                 mlog_errno(ret);
2150                 goto out;
2151         }
2152
2153         src = buf->ops->map(pipe, buf, 1);
2154         dst = kmap_atomic(page, KM_USER1);
2155         memcpy(dst + offset, src + buf->offset, count);
2156         kunmap_atomic(dst, KM_USER1);
2157         buf->ops->unmap(pipe, buf, src);
2158
2159         copied = ocfs2_write_end(file, file->f_mapping, sd->pos, count, count,
2160                                  page, fsdata);
2161         if (copied < 0) {
2162                 mlog_errno(copied);
2163                 ret = copied;
2164                 goto out;
2165         }
2166 out:
2167
2168         return copied ? copied : ret;
2169 }
2170
2171 static ssize_t __ocfs2_file_splice_write(struct pipe_inode_info *pipe,
2172                                          struct file *out,
2173                                          loff_t *ppos,
2174                                          size_t len,
2175                                          unsigned int flags)
2176 {
2177         int ret, err;
2178         struct address_space *mapping = out->f_mapping;
2179         struct inode *inode = mapping->host;
2180         struct splice_desc sd = {
2181                 .total_len = len,
2182                 .flags = flags,
2183                 .pos = *ppos,
2184                 .u.file = out,
2185         };
2186
2187         ret = __splice_from_pipe(pipe, &sd, ocfs2_splice_write_actor);
2188         if (ret > 0) {
2189                 *ppos += ret;
2190
2191                 if (unlikely((out->f_flags & O_SYNC) || IS_SYNC(inode))) {
2192                         err = generic_osync_inode(inode, mapping,
2193                                                   OSYNC_METADATA|OSYNC_DATA);
2194                         if (err)
2195                                 ret = err;
2196                 }
2197         }
2198
2199         return ret;
2200 }
2201
2202 static ssize_t ocfs2_file_splice_write(struct pipe_inode_info *pipe,
2203                                        struct file *out,
2204                                        loff_t *ppos,
2205                                        size_t len,
2206                                        unsigned int flags)
2207 {
2208         int ret;
2209         struct inode *inode = out->f_path.dentry->d_inode;
2210
2211         mlog_entry("(0x%p, 0x%p, %u, '%.*s')\n", out, pipe,
2212                    (unsigned int)len,
2213                    out->f_path.dentry->d_name.len,
2214                    out->f_path.dentry->d_name.name);
2215
2216         inode_double_lock(inode, pipe->inode);
2217
2218         ret = ocfs2_rw_lock(inode, 1);
2219         if (ret < 0) {
2220                 mlog_errno(ret);
2221                 goto out;
2222         }
2223
2224         ret = ocfs2_prepare_inode_for_write(out->f_path.dentry, ppos, len, 0,
2225                                             NULL);
2226         if (ret < 0) {
2227                 mlog_errno(ret);
2228                 goto out_unlock;
2229         }
2230
2231         /* ok, we're done with i_size and alloc work */
2232         ret = __ocfs2_file_splice_write(pipe, out, ppos, len, flags);
2233
2234 out_unlock:
2235         ocfs2_rw_unlock(inode, 1);
2236 out:
2237         inode_double_unlock(inode, pipe->inode);
2238
2239         mlog_exit(ret);
2240         return ret;
2241 }
2242
2243 static ssize_t ocfs2_file_splice_read(struct file *in,
2244                                       loff_t *ppos,
2245                                       struct pipe_inode_info *pipe,
2246                                       size_t len,
2247                                       unsigned int flags)
2248 {
2249         int ret = 0;
2250         struct inode *inode = in->f_path.dentry->d_inode;
2251
2252         mlog_entry("(0x%p, 0x%p, %u, '%.*s')\n", in, pipe,
2253                    (unsigned int)len,
2254                    in->f_path.dentry->d_name.len,
2255                    in->f_path.dentry->d_name.name);
2256
2257         /*
2258          * See the comment in ocfs2_file_aio_read()
2259          */
2260         ret = ocfs2_meta_lock(inode, NULL, 0);
2261         if (ret < 0) {
2262                 mlog_errno(ret);
2263                 goto bail;
2264         }
2265         ocfs2_meta_unlock(inode, 0);
2266
2267         ret = generic_file_splice_read(in, ppos, pipe, len, flags);
2268
2269 bail:
2270         mlog_exit(ret);
2271         return ret;
2272 }
2273
2274 static ssize_t ocfs2_file_aio_read(struct kiocb *iocb,
2275                                    const struct iovec *iov,
2276                                    unsigned long nr_segs,
2277                                    loff_t pos)
2278 {
2279         int ret = 0, rw_level = -1, have_alloc_sem = 0, lock_level = 0;
2280         struct file *filp = iocb->ki_filp;
2281         struct inode *inode = filp->f_path.dentry->d_inode;
2282
2283         mlog_entry("(0x%p, %u, '%.*s')\n", filp,
2284                    (unsigned int)nr_segs,
2285                    filp->f_path.dentry->d_name.len,
2286                    filp->f_path.dentry->d_name.name);
2287
2288         if (!inode) {
2289                 ret = -EINVAL;
2290                 mlog_errno(ret);
2291                 goto bail;
2292         }
2293
2294         /* 
2295          * buffered reads protect themselves in ->readpage().  O_DIRECT reads
2296          * need locks to protect pending reads from racing with truncate.
2297          */
2298         if (filp->f_flags & O_DIRECT) {
2299                 down_read(&inode->i_alloc_sem);
2300                 have_alloc_sem = 1;
2301
2302                 ret = ocfs2_rw_lock(inode, 0);
2303                 if (ret < 0) {
2304                         mlog_errno(ret);
2305                         goto bail;
2306                 }
2307                 rw_level = 0;
2308                 /* communicate with ocfs2_dio_end_io */
2309                 ocfs2_iocb_set_rw_locked(iocb, rw_level);
2310         }
2311
2312         /*
2313          * We're fine letting folks race truncates and extending
2314          * writes with read across the cluster, just like they can
2315          * locally. Hence no rw_lock during read.
2316          * 
2317          * Take and drop the meta data lock to update inode fields
2318          * like i_size. This allows the checks down below
2319          * generic_file_aio_read() a chance of actually working. 
2320          */
2321         ret = ocfs2_meta_lock_atime(inode, filp->f_vfsmnt, &lock_level);
2322         if (ret < 0) {
2323                 mlog_errno(ret);
2324                 goto bail;
2325         }
2326         ocfs2_meta_unlock(inode, lock_level);
2327
2328         ret = generic_file_aio_read(iocb, iov, nr_segs, iocb->ki_pos);
2329         if (ret == -EINVAL)
2330                 mlog(ML_ERROR, "generic_file_aio_read returned -EINVAL\n");
2331
2332         /* buffered aio wouldn't have proper lock coverage today */
2333         BUG_ON(ret == -EIOCBQUEUED && !(filp->f_flags & O_DIRECT));
2334
2335         /* see ocfs2_file_aio_write */
2336         if (ret == -EIOCBQUEUED || !ocfs2_iocb_is_rw_locked(iocb)) {
2337                 rw_level = -1;
2338                 have_alloc_sem = 0;
2339         }
2340
2341 bail:
2342         if (have_alloc_sem)
2343                 up_read(&inode->i_alloc_sem);
2344         if (rw_level != -1) 
2345                 ocfs2_rw_unlock(inode, rw_level);
2346         mlog_exit(ret);
2347
2348         return ret;
2349 }
2350
2351 const struct inode_operations ocfs2_file_iops = {
2352         .setattr        = ocfs2_setattr,
2353         .getattr        = ocfs2_getattr,
2354         .permission     = ocfs2_permission,
2355         .fallocate      = ocfs2_fallocate,
2356 };
2357
2358 const struct inode_operations ocfs2_special_file_iops = {
2359         .setattr        = ocfs2_setattr,
2360         .getattr        = ocfs2_getattr,
2361         .permission     = ocfs2_permission,
2362 };
2363
2364 const struct file_operations ocfs2_fops = {
2365         .read           = do_sync_read,
2366         .write          = do_sync_write,
2367         .mmap           = ocfs2_mmap,
2368         .fsync          = ocfs2_sync_file,
2369         .release        = ocfs2_file_release,
2370         .open           = ocfs2_file_open,
2371         .aio_read       = ocfs2_file_aio_read,
2372         .aio_write      = ocfs2_file_aio_write,
2373         .ioctl          = ocfs2_ioctl,
2374 #ifdef CONFIG_COMPAT
2375         .compat_ioctl   = ocfs2_compat_ioctl,
2376 #endif
2377         .splice_read    = ocfs2_file_splice_read,
2378         .splice_write   = ocfs2_file_splice_write,
2379 };
2380
2381 const struct file_operations ocfs2_dops = {
2382         .read           = generic_read_dir,
2383         .readdir        = ocfs2_readdir,
2384         .fsync          = ocfs2_sync_file,
2385         .ioctl          = ocfs2_ioctl,
2386 #ifdef CONFIG_COMPAT
2387         .compat_ioctl   = ocfs2_compat_ioctl,
2388 #endif
2389 };