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