2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
3 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
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.
10 #include <linux/slab.h>
11 #include <linux/spinlock.h>
12 #include <linux/completion.h>
13 #include <linux/buffer_head.h>
14 #include <linux/pagemap.h>
15 #include <linux/uio.h>
16 #include <linux/blkdev.h>
19 #include <linux/gfs2_ondisk.h>
20 #include <linux/ext2_fs.h>
21 #include <linux/crc32.h>
22 #include <linux/lm_interface.h>
23 #include <linux/writeback.h>
24 #include <asm/uaccess.h>
44 * gfs2_llseek - seek to a location in a file
47 * @origin: Where to seek from (SEEK_SET, SEEK_CUR, or SEEK_END)
49 * SEEK_END requires the glock for the file because it references the
52 * Returns: The new offset, or errno
55 static loff_t gfs2_llseek(struct file *file, loff_t offset, int origin)
57 struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
58 struct gfs2_holder i_gh;
62 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
65 error = remote_llseek(file, offset, origin);
66 gfs2_glock_dq_uninit(&i_gh);
69 error = remote_llseek(file, offset, origin);
75 * gfs2_readdir - Read directory entries from a directory
76 * @file: The directory to read from
77 * @dirent: Buffer for dirents
78 * @filldir: Function used to do the copying
83 static int gfs2_readdir(struct file *file, void *dirent, filldir_t filldir)
85 struct inode *dir = file->f_mapping->host;
86 struct gfs2_inode *dip = GFS2_I(dir);
87 struct gfs2_holder d_gh;
88 u64 offset = file->f_pos;
91 gfs2_holder_init(dip->i_gl, LM_ST_SHARED, GL_ATIME, &d_gh);
92 error = gfs2_glock_nq_atime(&d_gh);
94 gfs2_holder_uninit(&d_gh);
98 error = gfs2_dir_read(dir, &offset, dirent, filldir);
100 gfs2_glock_dq_uninit(&d_gh);
102 file->f_pos = offset;
109 * @table: A table of 32 u32 flags
110 * @val: a 32 bit value to convert
112 * This function can be used to convert between fsflags values and
113 * GFS2's own flags values.
115 * Returns: the converted flags
117 static u32 fsflags_cvt(const u32 *table, u32 val)
129 static const u32 fsflags_to_gfs2[32] = {
131 [4] = GFS2_DIF_IMMUTABLE,
132 [5] = GFS2_DIF_APPENDONLY,
133 [7] = GFS2_DIF_NOATIME,
134 [12] = GFS2_DIF_EXHASH,
135 [14] = GFS2_DIF_INHERIT_JDATA,
136 [20] = GFS2_DIF_INHERIT_DIRECTIO,
139 static const u32 gfs2_to_fsflags[32] = {
140 [gfs2fl_Sync] = FS_SYNC_FL,
141 [gfs2fl_Immutable] = FS_IMMUTABLE_FL,
142 [gfs2fl_AppendOnly] = FS_APPEND_FL,
143 [gfs2fl_NoAtime] = FS_NOATIME_FL,
144 [gfs2fl_ExHash] = FS_INDEX_FL,
145 [gfs2fl_InheritDirectio] = FS_DIRECTIO_FL,
146 [gfs2fl_InheritJdata] = FS_JOURNAL_DATA_FL,
149 static int gfs2_get_flags(struct file *filp, u32 __user *ptr)
151 struct inode *inode = filp->f_path.dentry->d_inode;
152 struct gfs2_inode *ip = GFS2_I(inode);
153 struct gfs2_holder gh;
157 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &gh);
158 error = gfs2_glock_nq_atime(&gh);
162 fsflags = fsflags_cvt(gfs2_to_fsflags, ip->i_di.di_flags);
163 if (!S_ISDIR(inode->i_mode)) {
164 if (ip->i_di.di_flags & GFS2_DIF_JDATA)
165 fsflags |= FS_JOURNAL_DATA_FL;
166 if (ip->i_di.di_flags & GFS2_DIF_DIRECTIO)
167 fsflags |= FS_DIRECTIO_FL;
169 if (put_user(fsflags, ptr))
172 gfs2_glock_dq_m(1, &gh);
173 gfs2_holder_uninit(&gh);
177 void gfs2_set_inode_flags(struct inode *inode)
179 struct gfs2_inode *ip = GFS2_I(inode);
180 struct gfs2_dinode_host *di = &ip->i_di;
181 unsigned int flags = inode->i_flags;
183 flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
184 if (di->di_flags & GFS2_DIF_IMMUTABLE)
185 flags |= S_IMMUTABLE;
186 if (di->di_flags & GFS2_DIF_APPENDONLY)
188 if (di->di_flags & GFS2_DIF_NOATIME)
190 if (di->di_flags & GFS2_DIF_SYNC)
192 inode->i_flags = flags;
195 /* Flags that can be set by user space */
196 #define GFS2_FLAGS_USER_SET (GFS2_DIF_JDATA| \
198 GFS2_DIF_IMMUTABLE| \
199 GFS2_DIF_APPENDONLY| \
203 GFS2_DIF_INHERIT_DIRECTIO| \
204 GFS2_DIF_INHERIT_JDATA)
207 * gfs2_set_flags - set flags on an inode
209 * @flags: The flags to set
210 * @mask: Indicates which flags are valid
213 static int do_gfs2_set_flags(struct file *filp, u32 reqflags, u32 mask)
215 struct inode *inode = filp->f_path.dentry->d_inode;
216 struct gfs2_inode *ip = GFS2_I(inode);
217 struct gfs2_sbd *sdp = GFS2_SB(inode);
218 struct buffer_head *bh;
219 struct gfs2_holder gh;
221 u32 new_flags, flags;
223 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
227 flags = ip->i_di.di_flags;
228 new_flags = (flags & ~mask) | (reqflags & mask);
229 if ((new_flags ^ flags) == 0)
233 if ((new_flags ^ flags) & ~GFS2_FLAGS_USER_SET)
237 if (IS_IMMUTABLE(inode) && (new_flags & GFS2_DIF_IMMUTABLE))
239 if (IS_APPEND(inode) && (new_flags & GFS2_DIF_APPENDONLY))
241 if (((new_flags ^ flags) & GFS2_DIF_IMMUTABLE) &&
242 !capable(CAP_LINUX_IMMUTABLE))
244 if (!IS_IMMUTABLE(inode)) {
245 error = permission(inode, MAY_WRITE, NULL);
250 error = gfs2_trans_begin(sdp, RES_DINODE, 0);
253 error = gfs2_meta_inode_buffer(ip, &bh);
256 gfs2_trans_add_bh(ip->i_gl, bh, 1);
257 ip->i_di.di_flags = new_flags;
258 gfs2_dinode_out(ip, bh->b_data);
260 gfs2_set_inode_flags(inode);
264 gfs2_glock_dq_uninit(&gh);
268 static int gfs2_set_flags(struct file *filp, u32 __user *ptr)
270 struct inode *inode = filp->f_path.dentry->d_inode;
271 u32 fsflags, gfsflags;
272 if (get_user(fsflags, ptr))
274 gfsflags = fsflags_cvt(fsflags_to_gfs2, fsflags);
275 if (!S_ISDIR(inode->i_mode)) {
276 if (gfsflags & GFS2_DIF_INHERIT_JDATA)
277 gfsflags ^= (GFS2_DIF_JDATA | GFS2_DIF_INHERIT_JDATA);
278 if (gfsflags & GFS2_DIF_INHERIT_DIRECTIO)
279 gfsflags ^= (GFS2_DIF_DIRECTIO | GFS2_DIF_INHERIT_DIRECTIO);
280 return do_gfs2_set_flags(filp, gfsflags, ~0);
282 return do_gfs2_set_flags(filp, gfsflags, ~GFS2_DIF_JDATA);
285 static long gfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
288 case FS_IOC_GETFLAGS:
289 return gfs2_get_flags(filp, (u32 __user *)arg);
290 case FS_IOC_SETFLAGS:
291 return gfs2_set_flags(filp, (u32 __user *)arg);
299 * @file: The file to map
300 * @vma: The VMA which described the mapping
302 * Returns: 0 or error code
305 static int gfs2_mmap(struct file *file, struct vm_area_struct *vma)
307 struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
308 struct gfs2_holder i_gh;
311 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &i_gh);
312 error = gfs2_glock_nq_atime(&i_gh);
314 gfs2_holder_uninit(&i_gh);
318 /* This is VM_MAYWRITE instead of VM_WRITE because a call
319 to mprotect() can turn on VM_WRITE later. */
321 if ((vma->vm_flags & (VM_MAYSHARE | VM_MAYWRITE)) ==
322 (VM_MAYSHARE | VM_MAYWRITE))
323 vma->vm_ops = &gfs2_vm_ops_sharewrite;
325 vma->vm_ops = &gfs2_vm_ops_private;
327 gfs2_glock_dq_uninit(&i_gh);
333 * gfs2_open - open a file
334 * @inode: the inode to open
335 * @file: the struct file for this opening
340 static int gfs2_open(struct inode *inode, struct file *file)
342 struct gfs2_inode *ip = GFS2_I(inode);
343 struct gfs2_holder i_gh;
344 struct gfs2_file *fp;
347 fp = kzalloc(sizeof(struct gfs2_file), GFP_KERNEL);
351 mutex_init(&fp->f_fl_mutex);
353 gfs2_assert_warn(GFS2_SB(inode), !file->private_data);
354 file->private_data = fp;
356 if (S_ISREG(ip->i_inode.i_mode)) {
357 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
362 if (!(file->f_flags & O_LARGEFILE) &&
363 ip->i_di.di_size > MAX_NON_LFS) {
368 /* Listen to the Direct I/O flag */
370 if (ip->i_di.di_flags & GFS2_DIF_DIRECTIO)
371 file->f_flags |= O_DIRECT;
373 gfs2_glock_dq_uninit(&i_gh);
379 gfs2_glock_dq_uninit(&i_gh);
381 file->private_data = NULL;
387 * gfs2_close - called to close a struct file
388 * @inode: the inode the struct file belongs to
389 * @file: the struct file being closed
394 static int gfs2_close(struct inode *inode, struct file *file)
396 struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;
397 struct gfs2_file *fp;
399 fp = file->private_data;
400 file->private_data = NULL;
402 if (gfs2_assert_warn(sdp, fp))
411 * gfs2_fsync - sync the dirty data for a file (across the cluster)
412 * @file: the file that points to the dentry (we ignore this)
413 * @dentry: the dentry that points to the inode to sync
415 * The VFS will flush "normal" data for us. We only need to worry
416 * about metadata here. For journaled data, we just do a log flush
417 * as we can't avoid it. Otherwise we can just bale out if datasync
418 * is set. For stuffed inodes we must flush the log in order to
419 * ensure that all data is on disk.
421 * The call to write_inode_now() is there to write back metadata and
422 * the inode itself. It does also try and write the data, but thats
423 * (hopefully) a no-op due to the VFS having already called filemap_fdatawrite()
429 static int gfs2_fsync(struct file *file, struct dentry *dentry, int datasync)
431 struct inode *inode = dentry->d_inode;
432 int sync_state = inode->i_state & (I_DIRTY_SYNC|I_DIRTY_DATASYNC);
435 if (gfs2_is_jdata(GFS2_I(inode))) {
436 gfs2_log_flush(GFS2_SB(inode), GFS2_I(inode)->i_gl);
440 if (sync_state != 0) {
442 ret = write_inode_now(inode, 0);
444 if (gfs2_is_stuffed(GFS2_I(inode)))
445 gfs2_log_flush(GFS2_SB(inode), GFS2_I(inode)->i_gl);
452 * gfs2_setlease - acquire/release a file lease
453 * @file: the file pointer
460 static int gfs2_setlease(struct file *file, long arg, struct file_lock **fl)
462 struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host);
465 * We don't currently have a way to enforce a lease across the whole
466 * cluster; until we do, disable leases (by just returning -EINVAL),
467 * unless the administrator has requested purely local locking.
469 if (!sdp->sd_args.ar_localflocks)
471 return generic_setlease(file, arg, fl);
475 * gfs2_lock - acquire/release a posix lock on a file
476 * @file: the file pointer
477 * @cmd: either modify or retrieve lock state, possibly wait
478 * @fl: type and range of lock
483 static int gfs2_lock(struct file *file, int cmd, struct file_lock *fl)
485 struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
486 struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host);
487 struct lm_lockname name =
488 { .ln_number = ip->i_no_addr,
489 .ln_type = LM_TYPE_PLOCK };
491 if (!(fl->fl_flags & FL_POSIX))
493 if (__mandatory_lock(&ip->i_inode))
496 if (sdp->sd_args.ar_localflocks) {
498 posix_test_lock(file, fl);
501 return posix_lock_file_wait(file, fl);
505 if (cmd == F_CANCELLK) {
508 fl->fl_type = F_UNLCK;
511 return gfs2_lm_plock_get(sdp, &name, file, fl);
512 else if (fl->fl_type == F_UNLCK)
513 return gfs2_lm_punlock(sdp, &name, file, fl);
515 return gfs2_lm_plock(sdp, &name, file, cmd, fl);
518 static int do_flock(struct file *file, int cmd, struct file_lock *fl)
520 struct gfs2_file *fp = file->private_data;
521 struct gfs2_holder *fl_gh = &fp->f_fl_gh;
522 struct gfs2_inode *ip = GFS2_I(file->f_path.dentry->d_inode);
523 struct gfs2_glock *gl;
528 state = (fl->fl_type == F_WRLCK) ? LM_ST_EXCLUSIVE : LM_ST_SHARED;
529 flags = (IS_SETLKW(cmd) ? 0 : LM_FLAG_TRY) | GL_EXACT | GL_NOCACHE
532 mutex_lock(&fp->f_fl_mutex);
536 if (fl_gh->gh_state == state)
538 flock_lock_file_wait(file,
539 &(struct file_lock){.fl_type = F_UNLCK});
540 gfs2_glock_dq_wait(fl_gh);
541 gfs2_holder_reinit(state, flags, fl_gh);
543 error = gfs2_glock_get(GFS2_SB(&ip->i_inode),
544 ip->i_no_addr, &gfs2_flock_glops,
548 gfs2_holder_init(gl, state, flags, fl_gh);
551 error = gfs2_glock_nq(fl_gh);
553 gfs2_holder_uninit(fl_gh);
554 if (error == GLR_TRYFAILED)
557 error = flock_lock_file_wait(file, fl);
558 gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
562 mutex_unlock(&fp->f_fl_mutex);
566 static void do_unflock(struct file *file, struct file_lock *fl)
568 struct gfs2_file *fp = file->private_data;
569 struct gfs2_holder *fl_gh = &fp->f_fl_gh;
571 mutex_lock(&fp->f_fl_mutex);
572 flock_lock_file_wait(file, fl);
574 gfs2_glock_dq_uninit(fl_gh);
575 mutex_unlock(&fp->f_fl_mutex);
579 * gfs2_flock - acquire/release a flock lock on a file
580 * @file: the file pointer
581 * @cmd: either modify or retrieve lock state, possibly wait
582 * @fl: type and range of lock
587 static int gfs2_flock(struct file *file, int cmd, struct file_lock *fl)
589 struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
590 struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host);
592 if (!(fl->fl_flags & FL_FLOCK))
594 if (__mandatory_lock(&ip->i_inode))
597 if (sdp->sd_args.ar_localflocks)
598 return flock_lock_file_wait(file, fl);
600 if (fl->fl_type == F_UNLCK) {
601 do_unflock(file, fl);
604 return do_flock(file, cmd, fl);
608 const struct file_operations gfs2_file_fops = {
609 .llseek = gfs2_llseek,
610 .read = do_sync_read,
611 .aio_read = generic_file_aio_read,
612 .write = do_sync_write,
613 .aio_write = generic_file_aio_write,
614 .unlocked_ioctl = gfs2_ioctl,
617 .release = gfs2_close,
621 .splice_read = generic_file_splice_read,
622 .splice_write = generic_file_splice_write,
623 .setlease = gfs2_setlease,
626 const struct file_operations gfs2_dir_fops = {
627 .readdir = gfs2_readdir,
628 .unlocked_ioctl = gfs2_ioctl,
630 .release = gfs2_close,