blob: 1a5e8e893d7529e805ee016f6852a35423e128bf [file] [log] [blame]
David Teiglandb3b94fa2006-01-16 16:50:04 +00001/*
2 * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
Steven Whitehouse3a8a9a12006-05-18 15:09:15 -04003 * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved.
David Teiglandb3b94fa2006-01-16 16:50:04 +00004 *
5 * This copyrighted material is made available to anyone wishing to use,
6 * modify, copy, or redistribute it subject to the terms and conditions
Steven Whitehousee9fc2aa2006-09-01 11:05:15 -04007 * of the GNU General Public License version 2.
David Teiglandb3b94fa2006-01-16 16:50:04 +00008 */
9
David Teiglandb3b94fa2006-01-16 16:50:04 +000010#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>
17#include <linux/mm.h>
Steven Whitehouse18ec7d52006-02-08 11:50:51 +000018#include <linux/fs.h>
Steven Whitehouse5c676f62006-02-27 17:23:27 -050019#include <linux/gfs2_ondisk.h>
Steven Whitehouse71b86f52006-03-28 14:14:04 -050020#include <linux/ext2_fs.h>
21#include <linux/crc32.h>
Fabio Massimo Di Nitto7d308592006-09-19 07:56:29 +020022#include <linux/lm_interface.h>
Steven Whitehouse33c3de32006-11-30 10:14:32 -050023#include <linux/writeback.h>
David Teiglandb3b94fa2006-01-16 16:50:04 +000024#include <asm/uaccess.h>
25
26#include "gfs2.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050027#include "incore.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000028#include "bmap.h"
29#include "dir.h"
30#include "glock.h"
31#include "glops.h"
32#include "inode.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000033#include "lm.h"
34#include "log.h"
35#include "meta_io.h"
36#include "ops_file.h"
37#include "ops_vm.h"
38#include "quota.h"
39#include "rgrp.h"
40#include "trans.h"
Steven Whitehouse5c676f62006-02-27 17:23:27 -050041#include "util.h"
Steven Whitehouse71b86f52006-03-28 14:14:04 -050042#include "eaops.h"
David Teiglandb3b94fa2006-01-16 16:50:04 +000043
Steven Whitehouse61a30dc2006-02-15 10:15:18 +000044/*
45 * Most fields left uninitialised to catch anybody who tries to
46 * use them. f_flags set to prevent file_accessed() from touching
47 * any other part of this. Its use is purely as a flag so that we
48 * know (in readpage()) whether or not do to locking.
49 */
Steven Whitehousedd538c82006-09-04 14:53:30 -040050struct file gfs2_internal_file_sentinel = {
Steven Whitehouse61a30dc2006-02-15 10:15:18 +000051 .f_flags = O_NOATIME|O_RDONLY,
52};
53
Steven Whitehouse18ec7d52006-02-08 11:50:51 +000054static int gfs2_read_actor(read_descriptor_t *desc, struct page *page,
55 unsigned long offset, unsigned long size)
56{
57 char *kaddr;
58 unsigned long count = desc->count;
59
60 if (size > count)
61 size = count;
62
63 kaddr = kmap(page);
Al Viro9c9ab3d2006-10-13 23:49:23 -040064 memcpy(desc->arg.data, kaddr + offset, size);
Steven Whitehouse26c1a572006-09-04 15:32:10 -040065 kunmap(page);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +000066
Steven Whitehouse26c1a572006-09-04 15:32:10 -040067 desc->count = count - size;
68 desc->written += size;
69 desc->arg.buf += size;
70 return size;
Steven Whitehouse18ec7d52006-02-08 11:50:51 +000071}
72
73int gfs2_internal_read(struct gfs2_inode *ip, struct file_ra_state *ra_state,
74 char *buf, loff_t *pos, unsigned size)
75{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -040076 struct inode *inode = &ip->i_inode;
Steven Whitehouse18ec7d52006-02-08 11:50:51 +000077 read_descriptor_t desc;
78 desc.written = 0;
Al Viro9c9ab3d2006-10-13 23:49:23 -040079 desc.arg.data = buf;
Steven Whitehouse18ec7d52006-02-08 11:50:51 +000080 desc.count = size;
81 desc.error = 0;
Steven Whitehouse61a30dc2006-02-15 10:15:18 +000082 do_generic_mapping_read(inode->i_mapping, ra_state,
Steven Whitehousedd538c82006-09-04 14:53:30 -040083 &gfs2_internal_file_sentinel, pos, &desc,
Steven Whitehouse61a30dc2006-02-15 10:15:18 +000084 gfs2_read_actor);
Steven Whitehouse18ec7d52006-02-08 11:50:51 +000085 return desc.written ? desc.written : desc.error;
86}
David Teiglandb3b94fa2006-01-16 16:50:04 +000087
88/**
89 * gfs2_llseek - seek to a location in a file
90 * @file: the file
91 * @offset: the offset
92 * @origin: Where to seek from (SEEK_SET, SEEK_CUR, or SEEK_END)
93 *
94 * SEEK_END requires the glock for the file because it references the
95 * file's size.
96 *
97 * Returns: The new offset, or errno
98 */
99
100static loff_t gfs2_llseek(struct file *file, loff_t offset, int origin)
101{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400102 struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000103 struct gfs2_holder i_gh;
104 loff_t error;
105
David Teiglandb3b94fa2006-01-16 16:50:04 +0000106 if (origin == 2) {
107 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
108 &i_gh);
109 if (!error) {
110 error = remote_llseek(file, offset, origin);
111 gfs2_glock_dq_uninit(&i_gh);
112 }
113 } else
114 error = remote_llseek(file, offset, origin);
115
116 return error;
117}
118
David Teiglandb3b94fa2006-01-16 16:50:04 +0000119/**
Steven Whitehousef0e522a2006-09-19 16:41:11 -0400120 * gfs2_readdir - Read directory entries from a directory
David Teiglandb3b94fa2006-01-16 16:50:04 +0000121 * @file: The directory to read from
122 * @dirent: Buffer for dirents
123 * @filldir: Function used to do the copying
124 *
125 * Returns: errno
126 */
127
Steven Whitehousef0e522a2006-09-19 16:41:11 -0400128static int gfs2_readdir(struct file *file, void *dirent, filldir_t filldir)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000129{
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500130 struct inode *dir = file->f_mapping->host;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400131 struct gfs2_inode *dip = GFS2_I(dir);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000132 struct gfs2_holder d_gh;
Steven Whitehousecd915492006-09-04 12:49:07 -0400133 u64 offset = file->f_pos;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000134 int error;
135
David Teiglandb3b94fa2006-01-16 16:50:04 +0000136 gfs2_holder_init(dip->i_gl, LM_ST_SHARED, GL_ATIME, &d_gh);
137 error = gfs2_glock_nq_atime(&d_gh);
138 if (error) {
139 gfs2_holder_uninit(&d_gh);
140 return error;
141 }
142
Steven Whitehouse3699e3a2007-01-17 15:09:20 +0000143 error = gfs2_dir_read(dir, &offset, dirent, filldir);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000144
145 gfs2_glock_dq_uninit(&d_gh);
146
147 file->f_pos = offset;
148
149 return error;
150}
151
Steven Whitehouse128e5eb2006-10-02 11:24:43 -0400152/**
153 * fsflags_cvt
154 * @table: A table of 32 u32 flags
155 * @val: a 32 bit value to convert
156 *
157 * This function can be used to convert between fsflags values and
158 * GFS2's own flags values.
159 *
160 * Returns: the converted flags
161 */
162static u32 fsflags_cvt(const u32 *table, u32 val)
163{
164 u32 res = 0;
165 while(val) {
166 if (val & 1)
167 res |= *table;
168 table++;
169 val >>= 1;
170 }
171 return res;
172}
David Teiglandb3b94fa2006-01-16 16:50:04 +0000173
Steven Whitehouse128e5eb2006-10-02 11:24:43 -0400174static const u32 fsflags_to_gfs2[32] = {
175 [3] = GFS2_DIF_SYNC,
176 [4] = GFS2_DIF_IMMUTABLE,
177 [5] = GFS2_DIF_APPENDONLY,
178 [7] = GFS2_DIF_NOATIME,
179 [12] = GFS2_DIF_EXHASH,
180 [14] = GFS2_DIF_JDATA,
181 [20] = GFS2_DIF_DIRECTIO,
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500182};
183
Steven Whitehouse128e5eb2006-10-02 11:24:43 -0400184static const u32 gfs2_to_fsflags[32] = {
185 [gfs2fl_Sync] = FS_SYNC_FL,
186 [gfs2fl_Immutable] = FS_IMMUTABLE_FL,
187 [gfs2fl_AppendOnly] = FS_APPEND_FL,
188 [gfs2fl_NoAtime] = FS_NOATIME_FL,
189 [gfs2fl_ExHash] = FS_INDEX_FL,
190 [gfs2fl_Jdata] = FS_JOURNAL_DATA_FL,
191 [gfs2fl_Directio] = FS_DIRECTIO_FL,
192 [gfs2fl_InheritDirectio] = FS_DIRECTIO_FL,
193 [gfs2fl_InheritJdata] = FS_JOURNAL_DATA_FL,
Steven Whitehouse7ea9ea82006-03-31 15:01:28 -0500194};
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500195
Steven Whitehouseb09e5932006-04-07 11:17:32 -0400196static int gfs2_get_flags(struct file *filp, u32 __user *ptr)
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500197{
Josef Sipek81454092006-12-08 02:37:03 -0800198 struct inode *inode = filp->f_path.dentry->d_inode;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400199 struct gfs2_inode *ip = GFS2_I(inode);
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500200 struct gfs2_holder gh;
201 int error;
Steven Whitehouse128e5eb2006-10-02 11:24:43 -0400202 u32 fsflags;
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500203
204 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &gh);
Steven Whitehousedcd24792006-11-16 11:08:16 -0500205 error = gfs2_glock_nq_atime(&gh);
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500206 if (error)
207 return error;
Steven Whitehouse907b9bc2006-09-25 09:26:04 -0400208
Steven Whitehouse128e5eb2006-10-02 11:24:43 -0400209 fsflags = fsflags_cvt(gfs2_to_fsflags, ip->i_di.di_flags);
210 if (put_user(fsflags, ptr))
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500211 error = -EFAULT;
212
213 gfs2_glock_dq_m(1, &gh);
214 gfs2_holder_uninit(&gh);
215 return error;
216}
217
Steven Whitehouse6b124d82006-11-08 12:51:06 -0500218void gfs2_set_inode_flags(struct inode *inode)
219{
220 struct gfs2_inode *ip = GFS2_I(inode);
221 struct gfs2_dinode_host *di = &ip->i_di;
222 unsigned int flags = inode->i_flags;
223
224 flags &= ~(S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
225 if (di->di_flags & GFS2_DIF_IMMUTABLE)
226 flags |= S_IMMUTABLE;
227 if (di->di_flags & GFS2_DIF_APPENDONLY)
228 flags |= S_APPEND;
229 if (di->di_flags & GFS2_DIF_NOATIME)
230 flags |= S_NOATIME;
231 if (di->di_flags & GFS2_DIF_SYNC)
232 flags |= S_SYNC;
233 inode->i_flags = flags;
234}
235
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500236/* Flags that can be set by user space */
237#define GFS2_FLAGS_USER_SET (GFS2_DIF_JDATA| \
238 GFS2_DIF_DIRECTIO| \
239 GFS2_DIF_IMMUTABLE| \
240 GFS2_DIF_APPENDONLY| \
241 GFS2_DIF_NOATIME| \
242 GFS2_DIF_SYNC| \
243 GFS2_DIF_SYSTEM| \
244 GFS2_DIF_INHERIT_DIRECTIO| \
245 GFS2_DIF_INHERIT_JDATA)
246
247/**
248 * gfs2_set_flags - set flags on an inode
249 * @inode: The inode
250 * @flags: The flags to set
251 * @mask: Indicates which flags are valid
252 *
253 */
Steven Whitehouseb09e5932006-04-07 11:17:32 -0400254static int do_gfs2_set_flags(struct file *filp, u32 reqflags, u32 mask)
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500255{
Josef Sipek81454092006-12-08 02:37:03 -0800256 struct inode *inode = filp->f_path.dentry->d_inode;
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400257 struct gfs2_inode *ip = GFS2_I(inode);
258 struct gfs2_sbd *sdp = GFS2_SB(inode);
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500259 struct buffer_head *bh;
260 struct gfs2_holder gh;
261 int error;
Steven Whitehouse55eccc62006-04-04 14:29:30 -0400262 u32 new_flags, flags;
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500263
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500264 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
Abhijith Das52f341c2006-07-21 02:03:21 -0400265 if (error)
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500266 return error;
267
Steven Whitehouse55eccc62006-04-04 14:29:30 -0400268 flags = ip->i_di.di_flags;
269 new_flags = (flags & ~mask) | (reqflags & mask);
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500270 if ((new_flags ^ flags) == 0)
271 goto out;
272
Steven Whitehouse4bcf7092006-04-25 13:20:27 -0400273 if (S_ISDIR(inode->i_mode)) {
274 if ((new_flags ^ flags) & GFS2_DIF_JDATA)
275 new_flags ^= (GFS2_DIF_JDATA|GFS2_DIF_INHERIT_JDATA);
276 if ((new_flags ^ flags) & GFS2_DIF_DIRECTIO)
277 new_flags ^= (GFS2_DIF_DIRECTIO|GFS2_DIF_INHERIT_DIRECTIO);
278 }
279
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500280 error = -EINVAL;
281 if ((new_flags ^ flags) & ~GFS2_FLAGS_USER_SET)
282 goto out;
283
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500284 error = -EPERM;
285 if (IS_IMMUTABLE(inode) && (new_flags & GFS2_DIF_IMMUTABLE))
286 goto out;
287 if (IS_APPEND(inode) && (new_flags & GFS2_DIF_APPENDONLY))
288 goto out;
Steven Whitehouse907b9bc2006-09-25 09:26:04 -0400289 if (((new_flags ^ flags) & GFS2_DIF_IMMUTABLE) &&
Steven Whitehouseb9cb9812006-05-12 17:07:56 -0400290 !capable(CAP_LINUX_IMMUTABLE))
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500291 goto out;
Steven Whitehouseb9cb9812006-05-12 17:07:56 -0400292 if (!IS_IMMUTABLE(inode)) {
Steven Whitehousefaf450e2006-06-22 10:59:10 -0400293 error = permission(inode, MAY_WRITE, NULL);
Steven Whitehouseb9cb9812006-05-12 17:07:56 -0400294 if (error)
295 goto out;
296 }
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500297
Steven Whitehouse55eccc62006-04-04 14:29:30 -0400298 error = gfs2_trans_begin(sdp, RES_DINODE, 0);
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500299 if (error)
300 goto out;
Steven Whitehouse55eccc62006-04-04 14:29:30 -0400301 error = gfs2_meta_inode_buffer(ip, &bh);
302 if (error)
303 goto out_trans_end;
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500304 gfs2_trans_add_bh(ip->i_gl, bh, 1);
305 ip->i_di.di_flags = new_flags;
Steven Whitehouse539e5d62006-10-31 15:07:05 -0500306 gfs2_dinode_out(ip, bh->b_data);
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500307 brelse(bh);
Steven Whitehouse6b124d82006-11-08 12:51:06 -0500308 gfs2_set_inode_flags(inode);
Steven Whitehouse55eccc62006-04-04 14:29:30 -0400309out_trans_end:
310 gfs2_trans_end(sdp);
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500311out:
312 gfs2_glock_dq_uninit(&gh);
313 return error;
314}
315
Steven Whitehouseb09e5932006-04-07 11:17:32 -0400316static int gfs2_set_flags(struct file *filp, u32 __user *ptr)
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500317{
Steven Whitehouse128e5eb2006-10-02 11:24:43 -0400318 u32 fsflags, gfsflags;
319 if (get_user(fsflags, ptr))
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500320 return -EFAULT;
Steven Whitehouse128e5eb2006-10-02 11:24:43 -0400321 gfsflags = fsflags_cvt(fsflags_to_gfs2, fsflags);
Steven Whitehouseb09e5932006-04-07 11:17:32 -0400322 return do_gfs2_set_flags(filp, gfsflags, ~0);
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500323}
324
Steven Whitehouseb09e5932006-04-07 11:17:32 -0400325static long gfs2_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500326{
327 switch(cmd) {
Steven Whitehouse128e5eb2006-10-02 11:24:43 -0400328 case FS_IOC_GETFLAGS:
Steven Whitehouseb09e5932006-04-07 11:17:32 -0400329 return gfs2_get_flags(filp, (u32 __user *)arg);
Steven Whitehouse128e5eb2006-10-02 11:24:43 -0400330 case FS_IOC_SETFLAGS:
Steven Whitehouseb09e5932006-04-07 11:17:32 -0400331 return gfs2_set_flags(filp, (u32 __user *)arg);
Steven Whitehouse71b86f52006-03-28 14:14:04 -0500332 }
333 return -ENOTTY;
334}
335
336
David Teiglandb3b94fa2006-01-16 16:50:04 +0000337/**
338 * gfs2_mmap -
339 * @file: The file to map
340 * @vma: The VMA which described the mapping
341 *
342 * Returns: 0 or error code
343 */
344
345static int gfs2_mmap(struct file *file, struct vm_area_struct *vma)
346{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400347 struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000348 struct gfs2_holder i_gh;
349 int error;
350
David Teiglandb3b94fa2006-01-16 16:50:04 +0000351 gfs2_holder_init(ip->i_gl, LM_ST_SHARED, GL_ATIME, &i_gh);
352 error = gfs2_glock_nq_atime(&i_gh);
353 if (error) {
354 gfs2_holder_uninit(&i_gh);
355 return error;
356 }
357
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000358 /* This is VM_MAYWRITE instead of VM_WRITE because a call
359 to mprotect() can turn on VM_WRITE later. */
David Teiglandb3b94fa2006-01-16 16:50:04 +0000360
Steven Whitehouse18ec7d52006-02-08 11:50:51 +0000361 if ((vma->vm_flags & (VM_MAYSHARE | VM_MAYWRITE)) ==
362 (VM_MAYSHARE | VM_MAYWRITE))
363 vma->vm_ops = &gfs2_vm_ops_sharewrite;
364 else
365 vma->vm_ops = &gfs2_vm_ops_private;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000366
367 gfs2_glock_dq_uninit(&i_gh);
368
369 return error;
370}
371
372/**
373 * gfs2_open - open a file
374 * @inode: the inode to open
375 * @file: the struct file for this opening
376 *
377 * Returns: errno
378 */
379
380static int gfs2_open(struct inode *inode, struct file *file)
381{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400382 struct gfs2_inode *ip = GFS2_I(inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000383 struct gfs2_holder i_gh;
384 struct gfs2_file *fp;
385 int error;
386
David Teiglandb3b94fa2006-01-16 16:50:04 +0000387 fp = kzalloc(sizeof(struct gfs2_file), GFP_KERNEL);
388 if (!fp)
389 return -ENOMEM;
390
Steven Whitehousef55ab262006-02-21 12:51:39 +0000391 mutex_init(&fp->f_fl_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000392
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400393 gfs2_assert_warn(GFS2_SB(inode), !file->private_data);
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500394 file->private_data = fp;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000395
Steven Whitehouseb60623c2006-11-01 12:22:46 -0500396 if (S_ISREG(ip->i_inode.i_mode)) {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000397 error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY,
398 &i_gh);
399 if (error)
400 goto fail;
401
402 if (!(file->f_flags & O_LARGEFILE) &&
403 ip->i_di.di_size > MAX_NON_LFS) {
404 error = -EFBIG;
405 goto fail_gunlock;
406 }
407
408 /* Listen to the Direct I/O flag */
409
410 if (ip->i_di.di_flags & GFS2_DIF_DIRECTIO)
411 file->f_flags |= O_DIRECT;
412
David Teiglandb3b94fa2006-01-16 16:50:04 +0000413 gfs2_glock_dq_uninit(&i_gh);
414 }
415
416 return 0;
417
Steven Whitehouse420b9e52006-07-31 15:42:17 -0400418fail_gunlock:
David Teiglandb3b94fa2006-01-16 16:50:04 +0000419 gfs2_glock_dq_uninit(&i_gh);
Steven Whitehouse420b9e52006-07-31 15:42:17 -0400420fail:
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500421 file->private_data = NULL;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000422 kfree(fp);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000423 return error;
424}
425
426/**
427 * gfs2_close - called to close a struct file
428 * @inode: the inode the struct file belongs to
429 * @file: the struct file being closed
430 *
431 * Returns: errno
432 */
433
434static int gfs2_close(struct inode *inode, struct file *file)
435{
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500436 struct gfs2_sbd *sdp = inode->i_sb->s_fs_info;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000437 struct gfs2_file *fp;
438
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500439 fp = file->private_data;
440 file->private_data = NULL;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000441
442 if (gfs2_assert_warn(sdp, fp))
443 return -EIO;
444
445 kfree(fp);
446
447 return 0;
448}
449
450/**
451 * gfs2_fsync - sync the dirty data for a file (across the cluster)
452 * @file: the file that points to the dentry (we ignore this)
453 * @dentry: the dentry that points to the inode to sync
454 *
Steven Whitehouse33c3de32006-11-30 10:14:32 -0500455 * The VFS will flush "normal" data for us. We only need to worry
456 * about metadata here. For journaled data, we just do a log flush
457 * as we can't avoid it. Otherwise we can just bale out if datasync
458 * is set. For stuffed inodes we must flush the log in order to
459 * ensure that all data is on disk.
460 *
Steven Whitehouse34126f92006-12-07 09:13:14 -0500461 * The call to write_inode_now() is there to write back metadata and
462 * the inode itself. It does also try and write the data, but thats
463 * (hopefully) a no-op due to the VFS having already called filemap_fdatawrite()
464 * for us.
465 *
David Teiglandb3b94fa2006-01-16 16:50:04 +0000466 * Returns: errno
467 */
468
469static int gfs2_fsync(struct file *file, struct dentry *dentry, int datasync)
470{
Steven Whitehouse33c3de32006-11-30 10:14:32 -0500471 struct inode *inode = dentry->d_inode;
472 int sync_state = inode->i_state & (I_DIRTY_SYNC|I_DIRTY_DATASYNC);
473 int ret = 0;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000474
Steven Whitehouse33c3de32006-11-30 10:14:32 -0500475 if (gfs2_is_jdata(GFS2_I(inode))) {
476 gfs2_log_flush(GFS2_SB(inode), GFS2_I(inode)->i_gl);
477 return 0;
478 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000479
Steven Whitehouse33c3de32006-11-30 10:14:32 -0500480 if (sync_state != 0) {
481 if (!datasync)
Steven Whitehouse34126f92006-12-07 09:13:14 -0500482 ret = write_inode_now(inode, 0);
Steven Whitehouse33c3de32006-11-30 10:14:32 -0500483
484 if (gfs2_is_stuffed(GFS2_I(inode)))
485 gfs2_log_flush(GFS2_SB(inode), GFS2_I(inode)->i_gl);
486 }
487
488 return ret;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000489}
490
491/**
Marc Eshel60446062007-01-15 18:33:36 -0500492 * gfs2_setlease - acquire/release a file lease
493 * @file: the file pointer
494 * @arg: lease type
495 * @fl: file lock
496 *
497 * Returns: errno
498 */
499
500static int gfs2_setlease(struct file *file, long arg, struct file_lock **fl)
501{
502 struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host);
503
504 /*
505 * We don't currently have a way to enforce a lease across the whole
506 * cluster; until we do, disable leases (by just returning -EINVAL),
507 * unless the administrator has requested purely local locking.
508 */
509 if (!sdp->sd_args.ar_localflocks)
510 return -EINVAL;
511 return setlease(file, arg, fl);
512}
513
514/**
David Teiglandb3b94fa2006-01-16 16:50:04 +0000515 * gfs2_lock - acquire/release a posix lock on a file
516 * @file: the file pointer
517 * @cmd: either modify or retrieve lock state, possibly wait
518 * @fl: type and range of lock
519 *
520 * Returns: errno
521 */
522
523static int gfs2_lock(struct file *file, int cmd, struct file_lock *fl)
524{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400525 struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
526 struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000527 struct lm_lockname name =
Steven Whitehousedbb7cae2007-05-15 15:37:50 +0100528 { .ln_number = ip->i_no_addr,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000529 .ln_type = LM_TYPE_PLOCK };
530
David Teiglandb3b94fa2006-01-16 16:50:04 +0000531 if (!(fl->fl_flags & FL_POSIX))
532 return -ENOLCK;
Steven Whitehouseb60623c2006-11-01 12:22:46 -0500533 if ((ip->i_inode.i_mode & (S_ISGID | S_IXGRP)) == S_ISGID)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000534 return -ENOLCK;
535
536 if (sdp->sd_args.ar_localflocks) {
537 if (IS_GETLK(cmd)) {
Marc Eshel9d6a8c52007-02-21 00:55:18 -0500538 posix_test_lock(file, fl);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000539 return 0;
540 } else {
Steven Whitehouse8628de02006-03-31 16:48:41 -0500541 return posix_lock_file_wait(file, fl);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000542 }
543 }
544
Marc Eshel586759f2006-11-14 16:37:25 -0500545 if (cmd == F_CANCELLK) {
546 /* Hack: */
547 cmd = F_SETLK;
548 fl->fl_type = F_UNLCK;
549 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000550 if (IS_GETLK(cmd))
551 return gfs2_lm_plock_get(sdp, &name, file, fl);
552 else if (fl->fl_type == F_UNLCK)
553 return gfs2_lm_punlock(sdp, &name, file, fl);
554 else
555 return gfs2_lm_plock(sdp, &name, file, cmd, fl);
556}
557
David Teiglandb3b94fa2006-01-16 16:50:04 +0000558static int do_flock(struct file *file, int cmd, struct file_lock *fl)
559{
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500560 struct gfs2_file *fp = file->private_data;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000561 struct gfs2_holder *fl_gh = &fp->f_fl_gh;
Josef Sipek81454092006-12-08 02:37:03 -0800562 struct gfs2_inode *ip = GFS2_I(file->f_path.dentry->d_inode);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000563 struct gfs2_glock *gl;
564 unsigned int state;
565 int flags;
566 int error = 0;
567
568 state = (fl->fl_type == F_WRLCK) ? LM_ST_EXCLUSIVE : LM_ST_SHARED;
Steven Whitehouse26c1a572006-09-04 15:32:10 -0400569 flags = (IS_SETLKW(cmd) ? 0 : LM_FLAG_TRY) | GL_EXACT | GL_NOCACHE;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000570
Steven Whitehousef55ab262006-02-21 12:51:39 +0000571 mutex_lock(&fp->f_fl_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000572
573 gl = fl_gh->gh_gl;
574 if (gl) {
575 if (fl_gh->gh_state == state)
576 goto out;
577 gfs2_glock_hold(gl);
578 flock_lock_file_wait(file,
Steven Whitehouse907b9bc2006-09-25 09:26:04 -0400579 &(struct file_lock){.fl_type = F_UNLCK});
David Teiglandb3b94fa2006-01-16 16:50:04 +0000580 gfs2_glock_dq_uninit(fl_gh);
581 } else {
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400582 error = gfs2_glock_get(GFS2_SB(&ip->i_inode),
Steven Whitehousedbb7cae2007-05-15 15:37:50 +0100583 ip->i_no_addr, &gfs2_flock_glops,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000584 CREATE, &gl);
585 if (error)
586 goto out;
587 }
588
589 gfs2_holder_init(gl, state, flags, fl_gh);
590 gfs2_glock_put(gl);
591
592 error = gfs2_glock_nq(fl_gh);
593 if (error) {
594 gfs2_holder_uninit(fl_gh);
595 if (error == GLR_TRYFAILED)
596 error = -EAGAIN;
597 } else {
598 error = flock_lock_file_wait(file, fl);
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400599 gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000600 }
601
Steven Whitehouse420b9e52006-07-31 15:42:17 -0400602out:
Steven Whitehousef55ab262006-02-21 12:51:39 +0000603 mutex_unlock(&fp->f_fl_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000604 return error;
605}
606
607static void do_unflock(struct file *file, struct file_lock *fl)
608{
Steven Whitehouse5c676f62006-02-27 17:23:27 -0500609 struct gfs2_file *fp = file->private_data;
David Teiglandb3b94fa2006-01-16 16:50:04 +0000610 struct gfs2_holder *fl_gh = &fp->f_fl_gh;
611
Steven Whitehousef55ab262006-02-21 12:51:39 +0000612 mutex_lock(&fp->f_fl_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000613 flock_lock_file_wait(file, fl);
614 if (fl_gh->gh_gl)
615 gfs2_glock_dq_uninit(fl_gh);
Steven Whitehousef55ab262006-02-21 12:51:39 +0000616 mutex_unlock(&fp->f_fl_mutex);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000617}
618
619/**
620 * gfs2_flock - acquire/release a flock lock on a file
621 * @file: the file pointer
622 * @cmd: either modify or retrieve lock state, possibly wait
623 * @fl: type and range of lock
624 *
625 * Returns: errno
626 */
627
628static int gfs2_flock(struct file *file, int cmd, struct file_lock *fl)
629{
Steven Whitehousefeaa7bb2006-06-14 15:32:57 -0400630 struct gfs2_inode *ip = GFS2_I(file->f_mapping->host);
631 struct gfs2_sbd *sdp = GFS2_SB(file->f_mapping->host);
David Teiglandb3b94fa2006-01-16 16:50:04 +0000632
David Teiglandb3b94fa2006-01-16 16:50:04 +0000633 if (!(fl->fl_flags & FL_FLOCK))
634 return -ENOLCK;
Steven Whitehouseb60623c2006-11-01 12:22:46 -0500635 if ((ip->i_inode.i_mode & (S_ISGID | S_IXGRP)) == S_ISGID)
David Teiglandb3b94fa2006-01-16 16:50:04 +0000636 return -ENOLCK;
637
638 if (sdp->sd_args.ar_localflocks)
639 return flock_lock_file_wait(file, fl);
640
641 if (fl->fl_type == F_UNLCK) {
642 do_unflock(file, fl);
643 return 0;
Steven Whitehoused00223f2006-10-02 10:28:05 -0400644 } else {
David Teiglandb3b94fa2006-01-16 16:50:04 +0000645 return do_flock(file, cmd, fl);
Steven Whitehoused00223f2006-10-02 10:28:05 -0400646 }
David Teiglandb3b94fa2006-01-16 16:50:04 +0000647}
648
Steven Whitehouseb0dd9302006-07-03 13:47:02 -0400649const struct file_operations gfs2_file_fops = {
Steven Whitehouse26c1a572006-09-04 15:32:10 -0400650 .llseek = gfs2_llseek,
Steven Whitehoused00223f2006-10-02 10:28:05 -0400651 .read = do_sync_read,
Steven Whitehouse26c1a572006-09-04 15:32:10 -0400652 .aio_read = generic_file_aio_read,
Steven Whitehoused00223f2006-10-02 10:28:05 -0400653 .write = do_sync_write,
Steven Whitehouse26c1a572006-09-04 15:32:10 -0400654 .aio_write = generic_file_aio_write,
655 .unlocked_ioctl = gfs2_ioctl,
656 .mmap = gfs2_mmap,
657 .open = gfs2_open,
658 .release = gfs2_close,
659 .fsync = gfs2_fsync,
660 .lock = gfs2_lock,
Steven Whitehouse26c1a572006-09-04 15:32:10 -0400661 .flock = gfs2_flock,
662 .splice_read = generic_file_splice_read,
663 .splice_write = generic_file_splice_write,
Marc Eshel60446062007-01-15 18:33:36 -0500664 .setlease = gfs2_setlease,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000665};
666
Steven Whitehouseb0dd9302006-07-03 13:47:02 -0400667const struct file_operations gfs2_dir_fops = {
Steven Whitehouse26c1a572006-09-04 15:32:10 -0400668 .readdir = gfs2_readdir,
669 .unlocked_ioctl = gfs2_ioctl,
670 .open = gfs2_open,
671 .release = gfs2_close,
672 .fsync = gfs2_fsync,
673 .lock = gfs2_lock,
674 .flock = gfs2_flock,
David Teiglandb3b94fa2006-01-16 16:50:04 +0000675};
676