Merge git://git.kernel.org/pub/scm/linux/kernel/git/steve/gfs2-2.6
[linux-2.6] / fs / gfs2 / ops_file.c
1 /*
2  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
3  * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
4  *
5  * This copyrighted material is made available to anyone wishing to use,
6  * modify, copy, or redistribute it subject to the terms and conditions
7  * of the GNU General Public License version 2.
8  */
9
10 #include <linux/sched.h>
11 #include <linux/slab.h>
12 #include <linux/spinlock.h>
13 #include <linux/completion.h>
14 #include <linux/buffer_head.h>
15 #include <linux/pagemap.h>
16 #include <linux/uio.h>
17 #include <linux/blkdev.h>
18 #include <linux/mm.h>
19 #include <linux/smp_lock.h>
20 #include <linux/fs.h>
21 #include <linux/gfs2_ondisk.h>
22 #include <linux/ext2_fs.h>
23 #include <linux/crc32.h>
24 #include <linux/lm_interface.h>
25 #include <asm/uaccess.h>
26
27 #include "gfs2.h"
28 #include "incore.h"
29 #include "bmap.h"
30 #include "dir.h"
31 #include "glock.h"
32 #include "glops.h"
33 #include "inode.h"
34 #include "lm.h"
35 #include "log.h"
36 #include "meta_io.h"
37 #include "ops_file.h"
38 #include "ops_vm.h"
39 #include "quota.h"
40 #include "rgrp.h"
41 #include "trans.h"
42 #include "util.h"
43 #include "eaops.h"
44
45 /* For regular, non-NFS */
46 struct filldir_reg {
47         struct gfs2_sbd *fdr_sbd;
48         int fdr_prefetch;
49
50         filldir_t fdr_filldir;
51         void *fdr_opaque;
52 };
53
54 /*
55  * Most fields left uninitialised to catch anybody who tries to
56  * use them. f_flags set to prevent file_accessed() from touching
57  * any other part of this. Its use is purely as a flag so that we
58  * know (in readpage()) whether or not do to locking.
59  */
60 struct file gfs2_internal_file_sentinel = {
61         .f_flags = O_NOATIME|O_RDONLY,
62 };
63
64 static int gfs2_read_actor(read_descriptor_t *desc, struct page *page,
65                            unsigned long offset, unsigned long size)
66 {
67         char *kaddr;
68         unsigned long count = desc->count;
69
70         if (size > count)
71                 size = count;
72
73         kaddr = kmap(page);
74         memcpy(desc->arg.buf, kaddr + offset, size);
75         kunmap(page);
76
77         desc->count = count - size;
78         desc->written += size;
79         desc->arg.buf += size;
80         return size;
81 }
82
83 int gfs2_internal_read(struct gfs2_inode *ip, struct file_ra_state *ra_state,
84                        char *buf, loff_t *pos, unsigned size)
85 {
86         struct inode *inode = &ip->i_inode;
87         read_descriptor_t desc;
88         desc.written = 0;
89         desc.arg.buf = buf;
90         desc.count = size;
91         desc.error = 0;
92         do_generic_mapping_read(inode->i_mapping, ra_state,
93                                 &gfs2_internal_file_sentinel, pos, &desc,
94                                 gfs2_read_actor);
95         return desc.written ? desc.written : desc.error;
96 }
97
98 /**
99  * gfs2_llseek - seek to a location in a file
100  * @file: the file
101  * @offset: the offset
102  * @origin: Where to seek from (SEEK_SET, SEEK_CUR, or SEEK_END)
103  *
104  * SEEK_END requires the glock for the file because it references the
105  * file's size.
106  *
107  * Returns: The new offset, or errno
108  */
109
110 static loff_t gfs2_llseek(struct file *file, loff_t offset, int origin)
111 {
112         struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
113         struct gfs2_holder i_gh;
114         loff_t error;
115
116         if (origin == 2) {
117                 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
118                                            &i_gh);
119                 if (!error) {
120                         error = remote_llseek(file, offset, origin);
121                         gfs2_glock_dq_uninit(&i_gh);
122                 }
123         } else
124                 error = remote_llseek(file, offset, origin);
125
126         return error;
127 }
128
129 /**
130  * filldir_func - Report a directory entry to the caller of gfs2_dir_read()
131  * @opaque: opaque data used by the function
132  * @name: the name of the directory entry
133  * @length: the length of the name
134  * @offset: the entry's offset in the directory
135  * @inum: the inode number the entry points to
136  * @type: the type of inode the entry points to
137  *
138  * Returns: 0 on success, 1 if buffer full
139  */
140
141 static int filldir_func(void *opaque, const char *name, unsigned int length,
142                         u64 offset, struct gfs2_inum *inum,
143                         unsigned int type)
144 {
145         struct filldir_reg *fdr = (struct filldir_reg *)opaque;
146         struct gfs2_sbd *sdp = fdr->fdr_sbd;
147         int error;
148
149         error = fdr->fdr_filldir(fdr->fdr_opaque, name, length, offset,
150                                  inum->no_addr, type);
151         if (error)
152                 return 1;
153
154         if (fdr->fdr_prefetch && !(length == 1 && *name == '.')) {
155                 gfs2_glock_prefetch_num(sdp, inum->no_addr, &gfs2_inode_glops,
156                                        LM_ST_SHARED, LM_FLAG_TRY | LM_FLAG_ANY);
157                 gfs2_glock_prefetch_num(sdp, inum->no_addr, &gfs2_iopen_glops,
158                                        LM_ST_SHARED, LM_FLAG_TRY);
159         }
160
161         return 0;
162 }
163
164 /**
165  * gfs2_readdir - Read directory entries from a directory
166  * @file: The directory to read from
167  * @dirent: Buffer for dirents
168  * @filldir: Function used to do the copying
169  *
170  * Returns: errno
171  */
172
173 static int gfs2_readdir(struct file *file, void *dirent, filldir_t filldir)
174 {
175         struct inode *dir = file->f_mapping->host;
176         struct gfs2_inode *dip = GFS2_I(dir);
177         struct filldir_reg fdr;
178         struct gfs2_holder d_gh;
179         u64 offset = file->f_pos;
180         int error;
181
182         fdr.fdr_sbd = GFS2_SB(dir);
183         fdr.fdr_prefetch = 1;
184         fdr.fdr_filldir = filldir;
185         fdr.fdr_opaque = dirent;
186
187         gfs2_holder_init(dip->i_gl, LM_ST_SHARED, GL_ATIME, &d_gh);
188         error = gfs2_glock_nq_atime(&d_gh);
189         if (error) {
190                 gfs2_holder_uninit(&d_gh);
191                 return error;
192         }
193
194         error = gfs2_dir_read(dir, &offset, &fdr, filldir_func);
195
196         gfs2_glock_dq_uninit(&d_gh);
197
198         file->f_pos = offset;
199
200         return error;
201 }
202
203 /**
204  * fsflags_cvt
205  * @table: A table of 32 u32 flags
206  * @val: a 32 bit value to convert
207  *
208  * This function can be used to convert between fsflags values and
209  * GFS2's own flags values.
210  *
211  * Returns: the converted flags
212  */
213 static u32 fsflags_cvt(const u32 *table, u32 val)
214 {
215         u32 res = 0;
216         while(val) {
217                 if (val & 1)
218                         res |= *table;
219                 table++;
220                 val >>= 1;
221         }
222         return res;
223 }
224
225 static const u32 fsflags_to_gfs2[32] = {
226         [3] = GFS2_DIF_SYNC,
227         [4] = GFS2_DIF_IMMUTABLE,
228         [5] = GFS2_DIF_APPENDONLY,
229         [7] = GFS2_DIF_NOATIME,
230         [12] = GFS2_DIF_EXHASH,
231         [14] = GFS2_DIF_JDATA,
232         [20] = GFS2_DIF_DIRECTIO,
233 };
234
235 static const u32 gfs2_to_fsflags[32] = {
236         [gfs2fl_Sync] = FS_SYNC_FL,
237         [gfs2fl_Immutable] = FS_IMMUTABLE_FL,
238         [gfs2fl_AppendOnly] = FS_APPEND_FL,
239         [gfs2fl_NoAtime] = FS_NOATIME_FL,
240         [gfs2fl_ExHash] = FS_INDEX_FL,
241         [gfs2fl_Jdata] = FS_JOURNAL_DATA_FL,
242         [gfs2fl_Directio] = FS_DIRECTIO_FL,
243         [gfs2fl_InheritDirectio] = FS_DIRECTIO_FL,
244         [gfs2fl_InheritJdata] = FS_JOURNAL_DATA_FL,
245 };
246
247 static int gfs2_get_flags(struct file *filp, u32 __user *ptr)
248 {
249         struct inode *inode = filp->f_dentry->d_inode;
250         struct gfs2_inode *ip = GFS2_I(inode);
251         struct gfs2_holder gh;
252         int error;
253         u32 fsflags;
254
255         gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &gh);
256         error = gfs2_glock_nq_m_atime(1, &gh);
257         if (error)
258                 return error;
259
260         fsflags = fsflags_cvt(gfs2_to_fsflags, ip->i_di.di_flags);
261         if (put_user(fsflags, ptr))
262                 error = -EFAULT;
263
264         gfs2_glock_dq_m(1, &gh);
265         gfs2_holder_uninit(&gh);
266         return error;
267 }
268
269 /* Flags that can be set by user space */
270 #define GFS2_FLAGS_USER_SET (GFS2_DIF_JDATA|                    \
271                              GFS2_DIF_DIRECTIO|                 \
272                              GFS2_DIF_IMMUTABLE|                \
273                              GFS2_DIF_APPENDONLY|               \
274                              GFS2_DIF_NOATIME|                  \
275                              GFS2_DIF_SYNC|                     \
276                              GFS2_DIF_SYSTEM|                   \
277                              GFS2_DIF_INHERIT_DIRECTIO|         \
278                              GFS2_DIF_INHERIT_JDATA)
279
280 /**
281  * gfs2_set_flags - set flags on an inode
282  * @inode: The inode
283  * @flags: The flags to set
284  * @mask: Indicates which flags are valid
285  *
286  */
287 static int do_gfs2_set_flags(struct file *filp, u32 reqflags, u32 mask)
288 {
289         struct inode *inode = filp->f_dentry->d_inode;
290         struct gfs2_inode *ip = GFS2_I(inode);
291         struct gfs2_sbd *sdp = GFS2_SB(inode);
292         struct buffer_head *bh;
293         struct gfs2_holder gh;
294         int error;
295         u32 new_flags, flags;
296
297         error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
298         if (error)
299                 return error;
300
301         flags = ip->i_di.di_flags;
302         new_flags = (flags & ~mask) | (reqflags & mask);
303         if ((new_flags ^ flags) == 0)
304                 goto out;
305
306         if (S_ISDIR(inode->i_mode)) {
307                 if ((new_flags ^ flags) & GFS2_DIF_JDATA)
308                         new_flags ^= (GFS2_DIF_JDATA|GFS2_DIF_INHERIT_JDATA);
309                 if ((new_flags ^ flags) & GFS2_DIF_DIRECTIO)
310                         new_flags ^= (GFS2_DIF_DIRECTIO|GFS2_DIF_INHERIT_DIRECTIO);
311         }
312
313         error = -EINVAL;
314         if ((new_flags ^ flags) & ~GFS2_FLAGS_USER_SET)
315                 goto out;
316
317         error = -EPERM;
318         if (IS_IMMUTABLE(inode) && (new_flags & GFS2_DIF_IMMUTABLE))
319                 goto out;
320         if (IS_APPEND(inode) && (new_flags & GFS2_DIF_APPENDONLY))
321                 goto out;
322         if (((new_flags ^ flags) & GFS2_DIF_IMMUTABLE) &&
323             !capable(CAP_LINUX_IMMUTABLE))
324                 goto out;
325         if (!IS_IMMUTABLE(inode)) {
326                 error = permission(inode, MAY_WRITE, NULL);
327                 if (error)
328                         goto out;
329         }
330
331         error = gfs2_trans_begin(sdp, RES_DINODE, 0);
332         if (error)
333                 goto out;
334         error = gfs2_meta_inode_buffer(ip, &bh);
335         if (error)
336                 goto out_trans_end;
337         gfs2_trans_add_bh(ip->i_gl, bh, 1);
338         ip->i_di.di_flags = new_flags;
339         gfs2_dinode_out(&ip->i_di, bh->b_data);
340         brelse(bh);
341 out_trans_end:
342         gfs2_trans_end(sdp);
343 out:
344         gfs2_glock_dq_uninit(&gh);
345         return error;
346 }
347
348 static int gfs2_set_flags(struct file *filp, u32 __user *ptr)
349 {
350         u32 fsflags, gfsflags;
351         if (get_user(fsflags, ptr))
352                 return -EFAULT;
353         gfsflags = fsflags_cvt(fsflags_to_gfs2, fsflags);
354         return do_gfs2_set_flags(filp, gfsflags, ~0);
355 }
356
357 static long gfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
358 {
359         switch(cmd) {
360         case FS_IOC_GETFLAGS:
361                 return gfs2_get_flags(filp, (u32 __user *)arg);
362         case FS_IOC_SETFLAGS:
363                 return gfs2_set_flags(filp, (u32 __user *)arg);
364         }
365         return -ENOTTY;
366 }
367
368
369 /**
370  * gfs2_mmap -
371  * @file: The file to map
372  * @vma: The VMA which described the mapping
373  *
374  * Returns: 0 or error code
375  */
376
377 static int gfs2_mmap(struct file *file, struct vm_area_struct *vma)
378 {
379         struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
380         struct gfs2_holder i_gh;
381         int error;
382
383         gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &i_gh);
384         error = gfs2_glock_nq_atime(&i_gh);
385         if (error) {
386                 gfs2_holder_uninit(&i_gh);
387                 return error;
388         }
389
390         /* This is VM_MAYWRITE instead of VM_WRITE because a call
391            to mprotect() can turn on VM_WRITE later. */
392
393         if ((vma->vm_flags & (VM_MAYSHARE | VM_MAYWRITE)) ==
394             (VM_MAYSHARE | VM_MAYWRITE))
395                 vma->vm_ops = &gfs2_vm_ops_sharewrite;
396         else
397                 vma->vm_ops = &gfs2_vm_ops_private;
398
399         gfs2_glock_dq_uninit(&i_gh);
400
401         return error;
402 }
403
404 /**
405  * gfs2_open - open a file
406  * @inode: the inode to open
407  * @file: the struct file for this opening
408  *
409  * Returns: errno
410  */
411
412 static int gfs2_open(struct inode *inode, struct file *file)
413 {
414         struct gfs2_inode *ip = GFS2_I(inode);
415         struct gfs2_holder i_gh;
416         struct gfs2_file *fp;
417         int error;
418
419         fp = kzalloc(sizeof(struct gfs2_file), GFP_KERNEL);
420         if (!fp)
421                 return -ENOMEM;
422
423         mutex_init(&fp->f_fl_mutex);
424
425         gfs2_assert_warn(GFS2_SB(inode), !file->private_data);
426         file->private_data = fp;
427
428         if (S_ISREG(ip->i_di.di_mode)) {
429                 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
430                                            &i_gh);
431                 if (error)
432                         goto fail;
433
434                 if (!(file->f_flags & O_LARGEFILE) &&
435                     ip->i_di.di_size > MAX_NON_LFS) {
436                         error = -EFBIG;
437                         goto fail_gunlock;
438                 }
439
440                 /* Listen to the Direct I/O flag */
441
442                 if (ip->i_di.di_flags & GFS2_DIF_DIRECTIO)
443                         file->f_flags |= O_DIRECT;
444
445                 gfs2_glock_dq_uninit(&i_gh);
446         }
447
448         return 0;
449
450 fail_gunlock:
451         gfs2_glock_dq_uninit(&i_gh);
452 fail:
453         file->private_data = NULL;
454         kfree(fp);
455         return error;
456 }
457
458 /**
459  * gfs2_close - called to close a struct file
460  * @inode: the inode the struct file belongs to
461  * @file: the struct file being closed
462  *
463  * Returns: errno
464  */
465
466 static int gfs2_close(struct inode *inode, struct file *file)
467 {
468         struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;
469         struct gfs2_file *fp;
470
471         fp = file->private_data;
472         file->private_data = NULL;
473
474         if (gfs2_assert_warn(sdp, fp))
475                 return -EIO;
476
477         kfree(fp);
478
479         return 0;
480 }
481
482 /**
483  * gfs2_fsync - sync the dirty data for a file (across the cluster)
484  * @file: the file that points to the dentry (we ignore this)
485  * @dentry: the dentry that points to the inode to sync
486  *
487  * Returns: errno
488  */
489
490 static int gfs2_fsync(struct file *file, struct dentry *dentry, int datasync)
491 {
492         struct gfs2_inode *ip = GFS2_I(dentry->d_inode);
493
494         gfs2_log_flush(ip->i_gl->gl_sbd, ip->i_gl);
495
496         return 0;
497 }
498
499 /**
500  * gfs2_lock - acquire/release a posix lock on a file
501  * @file: the file pointer
502  * @cmd: either modify or retrieve lock state, possibly wait
503  * @fl: type and range of lock
504  *
505  * Returns: errno
506  */
507
508 static int gfs2_lock(struct file *file, int cmd, struct file_lock *fl)
509 {
510         struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
511         struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host);
512         struct lm_lockname name =
513                 { .ln_number = ip->i_num.no_addr,
514                   .ln_type = LM_TYPE_PLOCK };
515
516         if (!(fl->fl_flags & FL_POSIX))
517                 return -ENOLCK;
518         if ((ip->i_di.di_mode & (S_ISGID | S_IXGRP)) == S_ISGID)
519                 return -ENOLCK;
520
521         if (sdp->sd_args.ar_localflocks) {
522                 if (IS_GETLK(cmd)) {
523                         struct file_lock tmp;
524                         int ret;
525                         ret = posix_test_lock(file, fl, &tmp);
526                         fl->fl_type = F_UNLCK;
527                         if (ret)
528                                 memcpy(fl, &tmp, sizeof(struct file_lock));
529                         return 0;
530                 } else {
531                         return posix_lock_file_wait(file, fl);
532                 }
533         }
534
535         if (IS_GETLK(cmd))
536                 return gfs2_lm_plock_get(sdp, &name, file, fl);
537         else if (fl->fl_type == F_UNLCK)
538                 return gfs2_lm_punlock(sdp, &name, file, fl);
539         else
540                 return gfs2_lm_plock(sdp, &name, file, cmd, fl);
541 }
542
543 static int do_flock(struct file *file, int cmd, struct file_lock *fl)
544 {
545         struct gfs2_file *fp = file->private_data;
546         struct gfs2_holder *fl_gh = &fp->f_fl_gh;
547         struct gfs2_inode *ip = GFS2_I(file->f_dentry->d_inode);
548         struct gfs2_glock *gl;
549         unsigned int state;
550         int flags;
551         int error = 0;
552
553         state = (fl->fl_type == F_WRLCK) ? LM_ST_EXCLUSIVE : LM_ST_SHARED;
554         flags = (IS_SETLKW(cmd) ? 0 : LM_FLAG_TRY) | GL_EXACT | GL_NOCACHE;
555
556         mutex_lock(&fp->f_fl_mutex);
557
558         gl = fl_gh->gh_gl;
559         if (gl) {
560                 if (fl_gh->gh_state == state)
561                         goto out;
562                 gfs2_glock_hold(gl);
563                 flock_lock_file_wait(file,
564                                      &(struct file_lock){.fl_type = F_UNLCK});
565                 gfs2_glock_dq_uninit(fl_gh);
566         } else {
567                 error = gfs2_glock_get(GFS2_SB(&ip->i_inode),
568                                       ip->i_num.no_addr, &gfs2_flock_glops,
569                                       CREATE, &gl);
570                 if (error)
571                         goto out;
572         }
573
574         gfs2_holder_init(gl, state, flags, fl_gh);
575         gfs2_glock_put(gl);
576
577         error = gfs2_glock_nq(fl_gh);
578         if (error) {
579                 gfs2_holder_uninit(fl_gh);
580                 if (error == GLR_TRYFAILED)
581                         error = -EAGAIN;
582         } else {
583                 error = flock_lock_file_wait(file, fl);
584                 gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
585         }
586
587 out:
588         mutex_unlock(&fp->f_fl_mutex);
589         return error;
590 }
591
592 static void do_unflock(struct file *file, struct file_lock *fl)
593 {
594         struct gfs2_file *fp = file->private_data;
595         struct gfs2_holder *fl_gh = &fp->f_fl_gh;
596
597         mutex_lock(&fp->f_fl_mutex);
598         flock_lock_file_wait(file, fl);
599         if (fl_gh->gh_gl)
600                 gfs2_glock_dq_uninit(fl_gh);
601         mutex_unlock(&fp->f_fl_mutex);
602 }
603
604 /**
605  * gfs2_flock - acquire/release a flock lock on a file
606  * @file: the file pointer
607  * @cmd: either modify or retrieve lock state, possibly wait
608  * @fl: type and range of lock
609  *
610  * Returns: errno
611  */
612
613 static int gfs2_flock(struct file *file, int cmd, struct file_lock *fl)
614 {
615         struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
616         struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host);
617
618         if (!(fl->fl_flags & FL_FLOCK))
619                 return -ENOLCK;
620         if ((ip->i_di.di_mode & (S_ISGID | S_IXGRP)) == S_ISGID)
621                 return -ENOLCK;
622
623         if (sdp->sd_args.ar_localflocks)
624                 return flock_lock_file_wait(file, fl);
625
626         if (fl->fl_type == F_UNLCK) {
627                 do_unflock(file, fl);
628                 return 0;
629         } else {
630                 return do_flock(file, cmd, fl);
631         }
632 }
633
634 const struct file_operations gfs2_file_fops = {
635         .llseek         = gfs2_llseek,
636         .read           = do_sync_read,
637         .aio_read       = generic_file_aio_read,
638         .write          = do_sync_write,
639         .aio_write      = generic_file_aio_write,
640         .unlocked_ioctl = gfs2_ioctl,
641         .mmap           = gfs2_mmap,
642         .open           = gfs2_open,
643         .release        = gfs2_close,
644         .fsync          = gfs2_fsync,
645         .lock           = gfs2_lock,
646         .sendfile       = generic_file_sendfile,
647         .flock          = gfs2_flock,
648         .splice_read    = generic_file_splice_read,
649         .splice_write   = generic_file_splice_write,
650 };
651
652 const struct file_operations gfs2_dir_fops = {
653         .readdir        = gfs2_readdir,
654         .unlocked_ioctl = gfs2_ioctl,
655         .open           = gfs2_open,
656         .release        = gfs2_close,
657         .fsync          = gfs2_fsync,
658         .lock           = gfs2_lock,
659         .flock          = gfs2_flock,
660 };
661