2 * File operations for Coda.
3 * Original version: (C) 1996 Peter Braam
4 * Rewritten for Linux 2.1: (C) 1997 Carnegie Mellon University
6 * Carnegie Mellon encourages users of this code to contribute improvements
7 * to the Coda project. Contact Peter Braam <coda@cs.cmu.edu>.
10 #include <linux/types.h>
11 #include <linux/kernel.h>
12 #include <linux/time.h>
13 #include <linux/file.h>
15 #include <linux/stat.h>
16 #include <linux/errno.h>
17 #include <linux/smp_lock.h>
18 #include <linux/string.h>
19 #include <asm/uaccess.h>
21 #include <linux/coda.h>
22 #include <linux/coda_linux.h>
23 #include <linux/coda_fs_i.h>
24 #include <linux/coda_psdev.h>
25 #include <linux/coda_proc.h>
29 /* if CODA_STORE fails with EOPNOTSUPP, venus clearly doesn't support
30 * CODA_STORE/CODA_RELEASE and we fall back on using the CODA_CLOSE upcall */
31 static int use_coda_close
;
34 coda_file_read(struct file
*coda_file
, char __user
*buf
, size_t count
, loff_t
*ppos
)
36 struct coda_file_info
*cfi
;
37 struct file
*host_file
;
39 cfi
= CODA_FTOC(coda_file
);
40 BUG_ON(!cfi
|| cfi
->cfi_magic
!= CODA_MAGIC
);
41 host_file
= cfi
->cfi_container
;
43 if (!host_file
->f_op
|| !host_file
->f_op
->read
)
46 return host_file
->f_op
->read(host_file
, buf
, count
, ppos
);
50 coda_file_splice_read(struct file
*coda_file
, loff_t
*ppos
,
51 struct pipe_inode_info
*pipe
, size_t count
,
54 struct coda_file_info
*cfi
;
55 struct file
*host_file
;
57 cfi
= CODA_FTOC(coda_file
);
58 BUG_ON(!cfi
|| cfi
->cfi_magic
!= CODA_MAGIC
);
59 host_file
= cfi
->cfi_container
;
61 if (!host_file
->f_op
|| !host_file
->f_op
->splice_read
)
64 return host_file
->f_op
->splice_read(host_file
, ppos
, pipe
, count
,flags
);
68 coda_file_write(struct file
*coda_file
, const char __user
*buf
, size_t count
, loff_t
*ppos
)
70 struct inode
*host_inode
, *coda_inode
= coda_file
->f_path
.dentry
->d_inode
;
71 struct coda_file_info
*cfi
;
72 struct file
*host_file
;
75 cfi
= CODA_FTOC(coda_file
);
76 BUG_ON(!cfi
|| cfi
->cfi_magic
!= CODA_MAGIC
);
77 host_file
= cfi
->cfi_container
;
79 if (!host_file
->f_op
|| !host_file
->f_op
->write
)
82 host_inode
= host_file
->f_path
.dentry
->d_inode
;
83 mutex_lock(&coda_inode
->i_mutex
);
85 ret
= host_file
->f_op
->write(host_file
, buf
, count
, ppos
);
87 coda_inode
->i_size
= host_inode
->i_size
;
88 coda_inode
->i_blocks
= (coda_inode
->i_size
+ 511) >> 9;
89 coda_inode
->i_mtime
= coda_inode
->i_ctime
= CURRENT_TIME_SEC
;
90 mutex_unlock(&coda_inode
->i_mutex
);
96 coda_file_mmap(struct file
*coda_file
, struct vm_area_struct
*vma
)
98 struct coda_file_info
*cfi
;
99 struct coda_inode_info
*cii
;
100 struct file
*host_file
;
101 struct inode
*coda_inode
, *host_inode
;
103 cfi
= CODA_FTOC(coda_file
);
104 BUG_ON(!cfi
|| cfi
->cfi_magic
!= CODA_MAGIC
);
105 host_file
= cfi
->cfi_container
;
107 if (!host_file
->f_op
|| !host_file
->f_op
->mmap
)
110 coda_inode
= coda_file
->f_path
.dentry
->d_inode
;
111 host_inode
= host_file
->f_path
.dentry
->d_inode
;
112 coda_file
->f_mapping
= host_file
->f_mapping
;
113 if (coda_inode
->i_mapping
== &coda_inode
->i_data
)
114 coda_inode
->i_mapping
= host_inode
->i_mapping
;
116 /* only allow additional mmaps as long as userspace isn't changing
117 * the container file on us! */
118 else if (coda_inode
->i_mapping
!= host_inode
->i_mapping
)
121 /* keep track of how often the coda_inode/host_file has been mmapped */
122 cii
= ITOC(coda_inode
);
126 return host_file
->f_op
->mmap(host_file
, vma
);
129 int coda_open(struct inode
*coda_inode
, struct file
*coda_file
)
131 struct file
*host_file
= NULL
;
133 unsigned short flags
= coda_file
->f_flags
& (~O_EXCL
);
134 unsigned short coda_flags
= coda_flags_to_cflags(flags
);
135 struct coda_file_info
*cfi
;
137 coda_vfs_stat
.open
++;
139 cfi
= kmalloc(sizeof(struct coda_file_info
), GFP_KERNEL
);
145 error
= venus_open(coda_inode
->i_sb
, coda_i2f(coda_inode
), coda_flags
,
147 if (error
|| !host_file
) {
153 host_file
->f_flags
|= coda_file
->f_flags
& (O_APPEND
| O_SYNC
);
155 cfi
->cfi_magic
= CODA_MAGIC
;
156 cfi
->cfi_mapcount
= 0;
157 cfi
->cfi_container
= host_file
;
159 BUG_ON(coda_file
->private_data
!= NULL
);
160 coda_file
->private_data
= cfi
;
166 int coda_flush(struct file
*coda_file
, fl_owner_t id
)
168 unsigned short flags
= coda_file
->f_flags
& ~O_EXCL
;
169 unsigned short coda_flags
= coda_flags_to_cflags(flags
);
170 struct coda_file_info
*cfi
;
171 struct inode
*coda_inode
;
176 coda_vfs_stat
.flush
++;
178 /* last close semantics */
179 fcnt
= file_count(coda_file
);
183 /* No need to make an upcall when we have not made any modifications
185 if ((coda_file
->f_flags
& O_ACCMODE
) == O_RDONLY
)
191 cfi
= CODA_FTOC(coda_file
);
192 BUG_ON(!cfi
|| cfi
->cfi_magic
!= CODA_MAGIC
);
194 coda_inode
= coda_file
->f_path
.dentry
->d_inode
;
196 err
= venus_store(coda_inode
->i_sb
, coda_i2f(coda_inode
), coda_flags
,
199 if (err
== -EOPNOTSUPP
) {
209 int coda_release(struct inode
*coda_inode
, struct file
*coda_file
)
211 unsigned short flags
= (coda_file
->f_flags
) & (~O_EXCL
);
212 unsigned short coda_flags
= coda_flags_to_cflags(flags
);
213 struct coda_file_info
*cfi
;
214 struct coda_inode_info
*cii
;
215 struct inode
*host_inode
;
219 coda_vfs_stat
.release
++;
221 if (!use_coda_close
) {
222 err
= venus_release(coda_inode
->i_sb
, coda_i2f(coda_inode
),
224 if (err
== -EOPNOTSUPP
) {
230 cfi
= CODA_FTOC(coda_file
);
231 BUG_ON(!cfi
|| cfi
->cfi_magic
!= CODA_MAGIC
);
234 err
= venus_close(coda_inode
->i_sb
, coda_i2f(coda_inode
),
235 coda_flags
, coda_file
->f_uid
);
237 host_inode
= cfi
->cfi_container
->f_path
.dentry
->d_inode
;
238 cii
= ITOC(coda_inode
);
240 /* did we mmap this file? */
241 if (coda_inode
->i_mapping
== &host_inode
->i_data
) {
242 cii
->c_mapcount
-= cfi
->cfi_mapcount
;
243 if (!cii
->c_mapcount
)
244 coda_inode
->i_mapping
= &coda_inode
->i_data
;
247 fput(cfi
->cfi_container
);
248 kfree(coda_file
->private_data
);
249 coda_file
->private_data
= NULL
;
255 int coda_fsync(struct file
*coda_file
, struct dentry
*coda_dentry
, int datasync
)
257 struct file
*host_file
;
258 struct dentry
*host_dentry
;
259 struct inode
*host_inode
, *coda_inode
= coda_dentry
->d_inode
;
260 struct coda_file_info
*cfi
;
263 if (!(S_ISREG(coda_inode
->i_mode
) || S_ISDIR(coda_inode
->i_mode
) ||
264 S_ISLNK(coda_inode
->i_mode
)))
267 cfi
= CODA_FTOC(coda_file
);
268 BUG_ON(!cfi
|| cfi
->cfi_magic
!= CODA_MAGIC
);
269 host_file
= cfi
->cfi_container
;
271 coda_vfs_stat
.fsync
++;
273 if (host_file
->f_op
&& host_file
->f_op
->fsync
) {
274 host_dentry
= host_file
->f_path
.dentry
;
275 host_inode
= host_dentry
->d_inode
;
276 mutex_lock(&host_inode
->i_mutex
);
277 err
= host_file
->f_op
->fsync(host_file
, host_dentry
, datasync
);
278 mutex_unlock(&host_inode
->i_mutex
);
281 if ( !err
&& !datasync
) {
283 err
= venus_fsync(coda_inode
->i_sb
, coda_i2f(coda_inode
));
290 const struct file_operations coda_file_operations
= {
291 .llseek
= generic_file_llseek
,
292 .read
= coda_file_read
,
293 .write
= coda_file_write
,
294 .mmap
= coda_file_mmap
,
297 .release
= coda_release
,
299 .splice_read
= coda_file_splice_read
,