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>
28 /* if CODA_STORE fails with EOPNOTSUPP, venus clearly doesn't support
29 * CODA_STORE/CODA_RELEASE and we fall back on using the CODA_CLOSE upcall */
30 static int use_coda_close
;
33 coda_file_read(struct file
*coda_file
, char __user
*buf
, size_t count
, loff_t
*ppos
)
35 struct coda_file_info
*cfi
;
36 struct file
*host_file
;
38 cfi
= CODA_FTOC(coda_file
);
39 BUG_ON(!cfi
|| cfi
->cfi_magic
!= CODA_MAGIC
);
40 host_file
= cfi
->cfi_container
;
42 if (!host_file
->f_op
|| !host_file
->f_op
->read
)
45 return host_file
->f_op
->read(host_file
, buf
, count
, ppos
);
49 coda_file_splice_read(struct file
*coda_file
, loff_t
*ppos
,
50 struct pipe_inode_info
*pipe
, size_t count
,
53 struct coda_file_info
*cfi
;
54 struct file
*host_file
;
56 cfi
= CODA_FTOC(coda_file
);
57 BUG_ON(!cfi
|| cfi
->cfi_magic
!= CODA_MAGIC
);
58 host_file
= cfi
->cfi_container
;
60 if (!host_file
->f_op
|| !host_file
->f_op
->splice_read
)
63 return host_file
->f_op
->splice_read(host_file
, ppos
, pipe
, count
,flags
);
67 coda_file_write(struct file
*coda_file
, const char __user
*buf
, size_t count
, loff_t
*ppos
)
69 struct inode
*host_inode
, *coda_inode
= coda_file
->f_path
.dentry
->d_inode
;
70 struct coda_file_info
*cfi
;
71 struct file
*host_file
;
74 cfi
= CODA_FTOC(coda_file
);
75 BUG_ON(!cfi
|| cfi
->cfi_magic
!= CODA_MAGIC
);
76 host_file
= cfi
->cfi_container
;
78 if (!host_file
->f_op
|| !host_file
->f_op
->write
)
81 host_inode
= host_file
->f_path
.dentry
->d_inode
;
82 mutex_lock(&coda_inode
->i_mutex
);
84 ret
= host_file
->f_op
->write(host_file
, buf
, count
, ppos
);
86 coda_inode
->i_size
= host_inode
->i_size
;
87 coda_inode
->i_blocks
= (coda_inode
->i_size
+ 511) >> 9;
88 coda_inode
->i_mtime
= coda_inode
->i_ctime
= CURRENT_TIME_SEC
;
89 mutex_unlock(&coda_inode
->i_mutex
);
95 coda_file_mmap(struct file
*coda_file
, struct vm_area_struct
*vma
)
97 struct coda_file_info
*cfi
;
98 struct coda_inode_info
*cii
;
99 struct file
*host_file
;
100 struct inode
*coda_inode
, *host_inode
;
102 cfi
= CODA_FTOC(coda_file
);
103 BUG_ON(!cfi
|| cfi
->cfi_magic
!= CODA_MAGIC
);
104 host_file
= cfi
->cfi_container
;
106 if (!host_file
->f_op
|| !host_file
->f_op
->mmap
)
109 coda_inode
= coda_file
->f_path
.dentry
->d_inode
;
110 host_inode
= host_file
->f_path
.dentry
->d_inode
;
111 coda_file
->f_mapping
= host_file
->f_mapping
;
112 if (coda_inode
->i_mapping
== &coda_inode
->i_data
)
113 coda_inode
->i_mapping
= host_inode
->i_mapping
;
115 /* only allow additional mmaps as long as userspace isn't changing
116 * the container file on us! */
117 else if (coda_inode
->i_mapping
!= host_inode
->i_mapping
)
120 /* keep track of how often the coda_inode/host_file has been mmapped */
121 cii
= ITOC(coda_inode
);
125 return host_file
->f_op
->mmap(host_file
, vma
);
128 int coda_open(struct inode
*coda_inode
, struct file
*coda_file
)
130 struct file
*host_file
= NULL
;
132 unsigned short flags
= coda_file
->f_flags
& (~O_EXCL
);
133 unsigned short coda_flags
= coda_flags_to_cflags(flags
);
134 struct coda_file_info
*cfi
;
136 cfi
= kmalloc(sizeof(struct coda_file_info
), GFP_KERNEL
);
142 error
= venus_open(coda_inode
->i_sb
, coda_i2f(coda_inode
), coda_flags
,
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 /* last close semantics */
177 fcnt
= file_count(coda_file
);
181 /* No need to make an upcall when we have not made any modifications
183 if ((coda_file
->f_flags
& O_ACCMODE
) == O_RDONLY
)
189 cfi
= CODA_FTOC(coda_file
);
190 BUG_ON(!cfi
|| cfi
->cfi_magic
!= CODA_MAGIC
);
192 coda_inode
= coda_file
->f_path
.dentry
->d_inode
;
194 err
= venus_store(coda_inode
->i_sb
, coda_i2f(coda_inode
), coda_flags
,
197 if (err
== -EOPNOTSUPP
) {
207 int coda_release(struct inode
*coda_inode
, struct file
*coda_file
)
209 unsigned short flags
= (coda_file
->f_flags
) & (~O_EXCL
);
210 unsigned short coda_flags
= coda_flags_to_cflags(flags
);
211 struct coda_file_info
*cfi
;
212 struct coda_inode_info
*cii
;
213 struct inode
*host_inode
;
218 if (!use_coda_close
) {
219 err
= venus_release(coda_inode
->i_sb
, coda_i2f(coda_inode
),
221 if (err
== -EOPNOTSUPP
) {
227 cfi
= CODA_FTOC(coda_file
);
228 BUG_ON(!cfi
|| cfi
->cfi_magic
!= CODA_MAGIC
);
231 err
= venus_close(coda_inode
->i_sb
, coda_i2f(coda_inode
),
232 coda_flags
, coda_file
->f_uid
);
234 host_inode
= cfi
->cfi_container
->f_path
.dentry
->d_inode
;
235 cii
= ITOC(coda_inode
);
237 /* did we mmap this file? */
238 if (coda_inode
->i_mapping
== &host_inode
->i_data
) {
239 cii
->c_mapcount
-= cfi
->cfi_mapcount
;
240 if (!cii
->c_mapcount
)
241 coda_inode
->i_mapping
= &coda_inode
->i_data
;
244 fput(cfi
->cfi_container
);
245 kfree(coda_file
->private_data
);
246 coda_file
->private_data
= NULL
;
252 int coda_fsync(struct file
*coda_file
, struct dentry
*coda_dentry
, int datasync
)
254 struct file
*host_file
;
255 struct dentry
*host_dentry
;
256 struct inode
*host_inode
, *coda_inode
= coda_dentry
->d_inode
;
257 struct coda_file_info
*cfi
;
260 if (!(S_ISREG(coda_inode
->i_mode
) || S_ISDIR(coda_inode
->i_mode
) ||
261 S_ISLNK(coda_inode
->i_mode
)))
264 cfi
= CODA_FTOC(coda_file
);
265 BUG_ON(!cfi
|| cfi
->cfi_magic
!= CODA_MAGIC
);
266 host_file
= cfi
->cfi_container
;
268 if (host_file
->f_op
&& host_file
->f_op
->fsync
) {
269 host_dentry
= host_file
->f_path
.dentry
;
270 host_inode
= host_dentry
->d_inode
;
271 mutex_lock(&host_inode
->i_mutex
);
272 err
= host_file
->f_op
->fsync(host_file
, host_dentry
, datasync
);
273 mutex_unlock(&host_inode
->i_mutex
);
276 if ( !err
&& !datasync
) {
278 err
= venus_fsync(coda_inode
->i_sb
, coda_i2f(coda_inode
));
285 const struct file_operations coda_file_operations
= {
286 .llseek
= generic_file_llseek
,
287 .read
= coda_file_read
,
288 .write
= coda_file_write
,
289 .mmap
= coda_file_mmap
,
292 .release
= coda_release
,
294 .splice_read
= coda_file_splice_read
,