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/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>
19 #include <linux/smp_lock.h>
21 #include <linux/gfs2_ondisk.h>
22 #include <linux/ext2_fs.h>
23 #include <linux/crc32.h>
24 #include <linux/iflags.h>
25 #include <linux/lm_interface.h>
26 #include <asm/uaccess.h>
46 /* For regular, non-NFS */
48 struct gfs2_sbd
*fdr_sbd
;
51 filldir_t fdr_filldir
;
56 * Most fields left uninitialised to catch anybody who tries to
57 * use them. f_flags set to prevent file_accessed() from touching
58 * any other part of this. Its use is purely as a flag so that we
59 * know (in readpage()) whether or not do to locking.
61 struct file gfs2_internal_file_sentinel
= {
62 .f_flags
= O_NOATIME
|O_RDONLY
,
65 static int gfs2_read_actor(read_descriptor_t
*desc
, struct page
*page
,
66 unsigned long offset
, unsigned long size
)
69 unsigned long count
= desc
->count
;
75 memcpy(desc
->arg
.buf
, kaddr
+ offset
, size
);
78 desc
->count
= count
- size
;
79 desc
->written
+= size
;
80 desc
->arg
.buf
+= size
;
84 int gfs2_internal_read(struct gfs2_inode
*ip
, struct file_ra_state
*ra_state
,
85 char *buf
, loff_t
*pos
, unsigned size
)
87 struct inode
*inode
= &ip
->i_inode
;
88 read_descriptor_t desc
;
93 do_generic_mapping_read(inode
->i_mapping
, ra_state
,
94 &gfs2_internal_file_sentinel
, pos
, &desc
,
96 return desc
.written
? desc
.written
: desc
.error
;
100 * gfs2_llseek - seek to a location in a file
102 * @offset: the offset
103 * @origin: Where to seek from (SEEK_SET, SEEK_CUR, or SEEK_END)
105 * SEEK_END requires the glock for the file because it references the
108 * Returns: The new offset, or errno
111 static loff_t
gfs2_llseek(struct file
*file
, loff_t offset
, int origin
)
113 struct gfs2_inode
*ip
= GFS2_I(file
->f_mapping
->host
);
114 struct gfs2_holder i_gh
;
118 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_SHARED
, LM_FLAG_ANY
,
121 error
= remote_llseek(file
, offset
, origin
);
122 gfs2_glock_dq_uninit(&i_gh
);
125 error
= remote_llseek(file
, offset
, origin
);
131 * filldir_func - Report a directory entry to the caller of gfs2_dir_read()
132 * @opaque: opaque data used by the function
133 * @name: the name of the directory entry
134 * @length: the length of the name
135 * @offset: the entry's offset in the directory
136 * @inum: the inode number the entry points to
137 * @type: the type of inode the entry points to
139 * Returns: 0 on success, 1 if buffer full
142 static int filldir_func(void *opaque
, const char *name
, unsigned int length
,
143 u64 offset
, struct gfs2_inum
*inum
,
146 struct filldir_reg
*fdr
= (struct filldir_reg
*)opaque
;
147 struct gfs2_sbd
*sdp
= fdr
->fdr_sbd
;
150 error
= fdr
->fdr_filldir(fdr
->fdr_opaque
, name
, length
, offset
,
151 inum
->no_addr
, type
);
155 if (fdr
->fdr_prefetch
&& !(length
== 1 && *name
== '.')) {
156 gfs2_glock_prefetch_num(sdp
, inum
->no_addr
, &gfs2_inode_glops
,
157 LM_ST_SHARED
, LM_FLAG_TRY
| LM_FLAG_ANY
);
158 gfs2_glock_prefetch_num(sdp
, inum
->no_addr
, &gfs2_iopen_glops
,
159 LM_ST_SHARED
, LM_FLAG_TRY
);
166 * gfs2_readdir - Read directory entries from a directory
167 * @file: The directory to read from
168 * @dirent: Buffer for dirents
169 * @filldir: Function used to do the copying
174 static int gfs2_readdir(struct file
*file
, void *dirent
, filldir_t filldir
)
176 struct inode
*dir
= file
->f_mapping
->host
;
177 struct gfs2_inode
*dip
= GFS2_I(dir
);
178 struct filldir_reg fdr
;
179 struct gfs2_holder d_gh
;
180 u64 offset
= file
->f_pos
;
183 fdr
.fdr_sbd
= GFS2_SB(dir
);
184 fdr
.fdr_prefetch
= 1;
185 fdr
.fdr_filldir
= filldir
;
186 fdr
.fdr_opaque
= dirent
;
188 gfs2_holder_init(dip
->i_gl
, LM_ST_SHARED
, GL_ATIME
, &d_gh
);
189 error
= gfs2_glock_nq_atime(&d_gh
);
191 gfs2_holder_uninit(&d_gh
);
195 error
= gfs2_dir_read(dir
, &offset
, &fdr
, filldir_func
);
197 gfs2_glock_dq_uninit(&d_gh
);
199 file
->f_pos
= offset
;
205 static const u32 iflags_to_gfs2
[32] = {
206 [iflag_Sync
] = GFS2_DIF_SYNC
,
207 [iflag_Immutable
] = GFS2_DIF_IMMUTABLE
,
208 [iflag_Append
] = GFS2_DIF_APPENDONLY
,
209 [iflag_NoAtime
] = GFS2_DIF_NOATIME
,
210 [iflag_Index
] = GFS2_DIF_EXHASH
,
211 [iflag_JournalData
] = GFS2_DIF_JDATA
,
212 [iflag_DirectIO
] = GFS2_DIF_DIRECTIO
,
215 static const u32 gfs2_to_iflags
[32] = {
216 [gfs2fl_Sync
] = IFLAG_SYNC
,
217 [gfs2fl_Immutable
] = IFLAG_IMMUTABLE
,
218 [gfs2fl_AppendOnly
] = IFLAG_APPEND
,
219 [gfs2fl_NoAtime
] = IFLAG_NOATIME
,
220 [gfs2fl_ExHash
] = IFLAG_INDEX
,
221 [gfs2fl_Jdata
] = IFLAG_JOURNAL_DATA
,
222 [gfs2fl_Directio
] = IFLAG_DIRECTIO
,
223 [gfs2fl_InheritDirectio
] = IFLAG_DIRECTIO
,
224 [gfs2fl_InheritJdata
] = IFLAG_JOURNAL_DATA
,
227 static int gfs2_get_flags(struct file
*filp
, u32 __user
*ptr
)
229 struct inode
*inode
= filp
->f_dentry
->d_inode
;
230 struct gfs2_inode
*ip
= GFS2_I(inode
);
231 struct gfs2_holder gh
;
235 gfs2_holder_init(ip
->i_gl
, LM_ST_SHARED
, GL_ATIME
, &gh
);
236 error
= gfs2_glock_nq_m_atime(1, &gh
);
240 iflags
= iflags_cvt(gfs2_to_iflags
, ip
->i_di
.di_flags
);
241 if (put_user(iflags
, ptr
))
244 gfs2_glock_dq_m(1, &gh
);
245 gfs2_holder_uninit(&gh
);
249 /* Flags that can be set by user space */
250 #define GFS2_FLAGS_USER_SET (GFS2_DIF_JDATA| \
252 GFS2_DIF_IMMUTABLE| \
253 GFS2_DIF_APPENDONLY| \
257 GFS2_DIF_INHERIT_DIRECTIO| \
258 GFS2_DIF_INHERIT_JDATA)
261 * gfs2_set_flags - set flags on an inode
263 * @flags: The flags to set
264 * @mask: Indicates which flags are valid
267 static int do_gfs2_set_flags(struct file
*filp
, u32 reqflags
, u32 mask
)
269 struct inode
*inode
= filp
->f_dentry
->d_inode
;
270 struct gfs2_inode
*ip
= GFS2_I(inode
);
271 struct gfs2_sbd
*sdp
= GFS2_SB(inode
);
272 struct buffer_head
*bh
;
273 struct gfs2_holder gh
;
275 u32 new_flags
, flags
;
277 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_EXCLUSIVE
, 0, &gh
);
281 flags
= ip
->i_di
.di_flags
;
282 new_flags
= (flags
& ~mask
) | (reqflags
& mask
);
283 if ((new_flags
^ flags
) == 0)
286 if (S_ISDIR(inode
->i_mode
)) {
287 if ((new_flags
^ flags
) & GFS2_DIF_JDATA
)
288 new_flags
^= (GFS2_DIF_JDATA
|GFS2_DIF_INHERIT_JDATA
);
289 if ((new_flags
^ flags
) & GFS2_DIF_DIRECTIO
)
290 new_flags
^= (GFS2_DIF_DIRECTIO
|GFS2_DIF_INHERIT_DIRECTIO
);
294 if ((new_flags
^ flags
) & ~GFS2_FLAGS_USER_SET
)
298 if (IS_IMMUTABLE(inode
) && (new_flags
& GFS2_DIF_IMMUTABLE
))
300 if (IS_APPEND(inode
) && (new_flags
& GFS2_DIF_APPENDONLY
))
302 if (((new_flags
^ flags
) & GFS2_DIF_IMMUTABLE
) &&
303 !capable(CAP_LINUX_IMMUTABLE
))
305 if (!IS_IMMUTABLE(inode
)) {
306 error
= permission(inode
, MAY_WRITE
, NULL
);
311 error
= gfs2_trans_begin(sdp
, RES_DINODE
, 0);
314 error
= gfs2_meta_inode_buffer(ip
, &bh
);
317 gfs2_trans_add_bh(ip
->i_gl
, bh
, 1);
318 ip
->i_di
.di_flags
= new_flags
;
319 gfs2_dinode_out(&ip
->i_di
, bh
->b_data
);
324 gfs2_glock_dq_uninit(&gh
);
328 static int gfs2_set_flags(struct file
*filp
, u32 __user
*ptr
)
330 u32 iflags
, gfsflags
;
331 if (get_user(iflags
, ptr
))
333 gfsflags
= iflags_cvt(iflags_to_gfs2
, iflags
);
334 return do_gfs2_set_flags(filp
, gfsflags
, ~0);
337 static long gfs2_ioctl(struct file
*filp
, unsigned int cmd
, unsigned long arg
)
341 return gfs2_get_flags(filp
, (u32 __user
*)arg
);
343 return gfs2_set_flags(filp
, (u32 __user
*)arg
);
351 * @file: The file to map
352 * @vma: The VMA which described the mapping
354 * Returns: 0 or error code
357 static int gfs2_mmap(struct file
*file
, struct vm_area_struct
*vma
)
359 struct gfs2_inode
*ip
= GFS2_I(file
->f_mapping
->host
);
360 struct gfs2_holder i_gh
;
363 gfs2_holder_init(ip
->i_gl
, LM_ST_SHARED
, GL_ATIME
, &i_gh
);
364 error
= gfs2_glock_nq_atime(&i_gh
);
366 gfs2_holder_uninit(&i_gh
);
370 /* This is VM_MAYWRITE instead of VM_WRITE because a call
371 to mprotect() can turn on VM_WRITE later. */
373 if ((vma
->vm_flags
& (VM_MAYSHARE
| VM_MAYWRITE
)) ==
374 (VM_MAYSHARE
| VM_MAYWRITE
))
375 vma
->vm_ops
= &gfs2_vm_ops_sharewrite
;
377 vma
->vm_ops
= &gfs2_vm_ops_private
;
379 gfs2_glock_dq_uninit(&i_gh
);
385 * gfs2_open - open a file
386 * @inode: the inode to open
387 * @file: the struct file for this opening
392 static int gfs2_open(struct inode
*inode
, struct file
*file
)
394 struct gfs2_inode
*ip
= GFS2_I(inode
);
395 struct gfs2_holder i_gh
;
396 struct gfs2_file
*fp
;
399 fp
= kzalloc(sizeof(struct gfs2_file
), GFP_KERNEL
);
403 mutex_init(&fp
->f_fl_mutex
);
405 gfs2_assert_warn(GFS2_SB(inode
), !file
->private_data
);
406 file
->private_data
= fp
;
408 if (S_ISREG(ip
->i_di
.di_mode
)) {
409 error
= gfs2_glock_nq_init(ip
->i_gl
, LM_ST_SHARED
, LM_FLAG_ANY
,
414 if (!(file
->f_flags
& O_LARGEFILE
) &&
415 ip
->i_di
.di_size
> MAX_NON_LFS
) {
420 /* Listen to the Direct I/O flag */
422 if (ip
->i_di
.di_flags
& GFS2_DIF_DIRECTIO
)
423 file
->f_flags
|= O_DIRECT
;
425 gfs2_glock_dq_uninit(&i_gh
);
431 gfs2_glock_dq_uninit(&i_gh
);
433 file
->private_data
= NULL
;
439 * gfs2_close - called to close a struct file
440 * @inode: the inode the struct file belongs to
441 * @file: the struct file being closed
446 static int gfs2_close(struct inode
*inode
, struct file
*file
)
448 struct gfs2_sbd
*sdp
= inode
->i_sb
->s_fs_info
;
449 struct gfs2_file
*fp
;
451 fp
= file
->private_data
;
452 file
->private_data
= NULL
;
454 if (gfs2_assert_warn(sdp
, fp
))
463 * gfs2_fsync - sync the dirty data for a file (across the cluster)
464 * @file: the file that points to the dentry (we ignore this)
465 * @dentry: the dentry that points to the inode to sync
470 static int gfs2_fsync(struct file
*file
, struct dentry
*dentry
, int datasync
)
472 struct gfs2_inode
*ip
= GFS2_I(dentry
->d_inode
);
474 gfs2_log_flush(ip
->i_gl
->gl_sbd
, ip
->i_gl
);
480 * gfs2_lock - acquire/release a posix lock on a file
481 * @file: the file pointer
482 * @cmd: either modify or retrieve lock state, possibly wait
483 * @fl: type and range of lock
488 static int gfs2_lock(struct file
*file
, int cmd
, struct file_lock
*fl
)
490 struct gfs2_inode
*ip
= GFS2_I(file
->f_mapping
->host
);
491 struct gfs2_sbd
*sdp
= GFS2_SB(file
->f_mapping
->host
);
492 struct lm_lockname name
=
493 { .ln_number
= ip
->i_num
.no_addr
,
494 .ln_type
= LM_TYPE_PLOCK
};
496 if (!(fl
->fl_flags
& FL_POSIX
))
498 if ((ip
->i_di
.di_mode
& (S_ISGID
| S_IXGRP
)) == S_ISGID
)
501 if (sdp
->sd_args
.ar_localflocks
) {
503 struct file_lock tmp
;
505 ret
= posix_test_lock(file
, fl
, &tmp
);
506 fl
->fl_type
= F_UNLCK
;
508 memcpy(fl
, &tmp
, sizeof(struct file_lock
));
511 return posix_lock_file_wait(file
, fl
);
516 return gfs2_lm_plock_get(sdp
, &name
, file
, fl
);
517 else if (fl
->fl_type
== F_UNLCK
)
518 return gfs2_lm_punlock(sdp
, &name
, file
, fl
);
520 return gfs2_lm_plock(sdp
, &name
, file
, cmd
, fl
);
523 static int do_flock(struct file
*file
, int cmd
, struct file_lock
*fl
)
525 struct gfs2_file
*fp
= file
->private_data
;
526 struct gfs2_holder
*fl_gh
= &fp
->f_fl_gh
;
527 struct gfs2_inode
*ip
= GFS2_I(file
->f_dentry
->d_inode
);
528 struct gfs2_glock
*gl
;
533 state
= (fl
->fl_type
== F_WRLCK
) ? LM_ST_EXCLUSIVE
: LM_ST_SHARED
;
534 flags
= (IS_SETLKW(cmd
) ? 0 : LM_FLAG_TRY
) | GL_EXACT
| GL_NOCACHE
;
536 mutex_lock(&fp
->f_fl_mutex
);
540 if (fl_gh
->gh_state
== state
)
543 flock_lock_file_wait(file
,
544 &(struct file_lock
){.fl_type
= F_UNLCK
});
545 gfs2_glock_dq_uninit(fl_gh
);
547 error
= gfs2_glock_get(GFS2_SB(&ip
->i_inode
),
548 ip
->i_num
.no_addr
, &gfs2_flock_glops
,
554 gfs2_holder_init(gl
, state
, flags
, fl_gh
);
557 error
= gfs2_glock_nq(fl_gh
);
559 gfs2_holder_uninit(fl_gh
);
560 if (error
== GLR_TRYFAILED
)
563 error
= flock_lock_file_wait(file
, fl
);
564 gfs2_assert_warn(GFS2_SB(&ip
->i_inode
), !error
);
568 mutex_unlock(&fp
->f_fl_mutex
);
572 static void do_unflock(struct file
*file
, struct file_lock
*fl
)
574 struct gfs2_file
*fp
= file
->private_data
;
575 struct gfs2_holder
*fl_gh
= &fp
->f_fl_gh
;
577 mutex_lock(&fp
->f_fl_mutex
);
578 flock_lock_file_wait(file
, fl
);
580 gfs2_glock_dq_uninit(fl_gh
);
581 mutex_unlock(&fp
->f_fl_mutex
);
585 * gfs2_flock - acquire/release a flock lock on a file
586 * @file: the file pointer
587 * @cmd: either modify or retrieve lock state, possibly wait
588 * @fl: type and range of lock
593 static int gfs2_flock(struct file
*file
, int cmd
, struct file_lock
*fl
)
595 struct gfs2_inode
*ip
= GFS2_I(file
->f_mapping
->host
);
596 struct gfs2_sbd
*sdp
= GFS2_SB(file
->f_mapping
->host
);
598 if (!(fl
->fl_flags
& FL_FLOCK
))
600 if ((ip
->i_di
.di_mode
& (S_ISGID
| S_IXGRP
)) == S_ISGID
)
603 if (sdp
->sd_args
.ar_localflocks
)
604 return flock_lock_file_wait(file
, fl
);
606 if (fl
->fl_type
== F_UNLCK
) {
607 do_unflock(file
, fl
);
610 return do_flock(file
, cmd
, fl
);
613 const struct file_operations gfs2_file_fops
= {
614 .llseek
= gfs2_llseek
,
615 .read
= generic_file_read
,
616 .readv
= generic_file_readv
,
617 .aio_read
= generic_file_aio_read
,
618 .write
= generic_file_write
,
619 .writev
= generic_file_writev
,
620 .aio_write
= generic_file_aio_write
,
621 .unlocked_ioctl
= gfs2_ioctl
,
624 .release
= gfs2_close
,
627 .sendfile
= generic_file_sendfile
,
629 .splice_read
= generic_file_splice_read
,
630 .splice_write
= generic_file_splice_write
,
633 const struct file_operations gfs2_dir_fops
= {
634 .readdir
= gfs2_readdir
,
635 .unlocked_ioctl
= gfs2_ioctl
,
637 .release
= gfs2_close
,