4 * Copyright (C) 1995, 1996 by Volker Lendecke
5 * Modified 1997 Peter Waltenberg, Bill Hawes, David Woodhouse for 2.1 dcache
9 #include <asm/uaccess.h>
10 #include <asm/system.h>
12 #include <linux/time.h>
13 #include <linux/kernel.h>
14 #include <linux/errno.h>
15 #include <linux/fcntl.h>
16 #include <linux/stat.h>
18 #include <linux/vmalloc.h>
19 #include <linux/sched.h>
21 #include <linux/ncp_fs.h>
22 #include "ncplib_kernel.h"
24 static int ncp_fsync(struct file
*file
, int datasync
)
30 * Open a file with the specified read/write mode.
32 int ncp_make_open(struct inode
*inode
, int right
)
39 printk(KERN_ERR
"ncp_make_open: got NULL inode\n");
43 DPRINTK("ncp_make_open: opened=%d, volume # %u, dir entry # %u\n",
44 atomic_read(&NCP_FINFO(inode
)->opened
),
45 NCP_FINFO(inode
)->volNumber
,
46 NCP_FINFO(inode
)->dirEntNum
);
48 mutex_lock(&NCP_FINFO(inode
)->open_mutex
);
49 if (!atomic_read(&NCP_FINFO(inode
)->opened
)) {
50 struct ncp_entry_info finfo
;
53 /* tries max. rights */
54 finfo
.access
= O_RDWR
;
55 result
= ncp_open_create_file_or_subdir(NCP_SERVER(inode
),
56 inode
, NULL
, OC_MODE_OPEN
,
57 0, AR_READ
| AR_WRITE
, &finfo
);
60 /* RDWR did not succeeded, try readonly or writeonly as requested */
63 finfo
.access
= O_RDONLY
;
64 result
= ncp_open_create_file_or_subdir(NCP_SERVER(inode
),
65 inode
, NULL
, OC_MODE_OPEN
,
69 finfo
.access
= O_WRONLY
;
70 result
= ncp_open_create_file_or_subdir(NCP_SERVER(inode
),
71 inode
, NULL
, OC_MODE_OPEN
,
76 PPRINTK("ncp_make_open: failed, result=%d\n", result
);
80 * Update the inode information.
83 ncp_update_inode(inode
, &finfo
);
84 atomic_set(&NCP_FINFO(inode
)->opened
, 1);
87 access
= NCP_FINFO(inode
)->access
;
88 PPRINTK("ncp_make_open: file open, access=%x\n", access
);
89 if (access
== right
|| access
== O_RDWR
) {
90 atomic_inc(&NCP_FINFO(inode
)->opened
);
95 mutex_unlock(&NCP_FINFO(inode
)->open_mutex
);
101 ncp_file_read(struct file
*file
, char __user
*buf
, size_t count
, loff_t
*ppos
)
103 struct dentry
*dentry
= file
->f_path
.dentry
;
104 struct inode
*inode
= dentry
->d_inode
;
105 size_t already_read
= 0;
112 DPRINTK("ncp_file_read: enter %s/%s\n",
113 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
);
117 if ((ssize_t
) count
< 0) {
122 if (pos
> inode
->i_sb
->s_maxbytes
)
124 if (pos
+ count
> inode
->i_sb
->s_maxbytes
) {
125 count
= inode
->i_sb
->s_maxbytes
- pos
;
128 error
= ncp_make_open(inode
, O_RDONLY
);
130 DPRINTK(KERN_ERR
"ncp_file_read: open failed, error=%d\n", error
);
134 bufsize
= NCP_SERVER(inode
)->buffer_size
;
137 freelen
= ncp_read_bounce_size(bufsize
);
138 freepage
= vmalloc(freelen
);
142 /* First read in as much as possible for each bufsize. */
143 while (already_read
< count
) {
145 size_t to_read
= min_t(unsigned int,
146 bufsize
- (pos
% bufsize
),
147 count
- already_read
);
149 error
= ncp_read_bounce(NCP_SERVER(inode
),
150 NCP_FINFO(inode
)->file_handle
,
151 pos
, to_read
, buf
, &read_this_time
,
154 error
= -EIO
; /* NW errno -> Linux errno */
157 pos
+= read_this_time
;
158 buf
+= read_this_time
;
159 already_read
+= read_this_time
;
161 if (read_this_time
!= to_read
) {
171 DPRINTK("ncp_file_read: exit %s/%s\n",
172 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
);
174 ncp_inode_close(inode
);
175 return already_read
? already_read
: error
;
179 ncp_file_write(struct file
*file
, const char __user
*buf
, size_t count
, loff_t
*ppos
)
181 struct dentry
*dentry
= file
->f_path
.dentry
;
182 struct inode
*inode
= dentry
->d_inode
;
183 size_t already_written
= 0;
189 DPRINTK("ncp_file_write: enter %s/%s\n",
190 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
);
191 if ((ssize_t
) count
< 0)
194 if (file
->f_flags
& O_APPEND
) {
195 pos
= i_size_read(inode
);
198 if (pos
+ count
> MAX_NON_LFS
&& !(file
->f_flags
&O_LARGEFILE
)) {
199 if (pos
>= MAX_NON_LFS
) {
202 if (count
> MAX_NON_LFS
- (u32
)pos
) {
203 count
= MAX_NON_LFS
- (u32
)pos
;
206 if (pos
>= inode
->i_sb
->s_maxbytes
) {
207 if (count
|| pos
> inode
->i_sb
->s_maxbytes
) {
211 if (pos
+ count
> inode
->i_sb
->s_maxbytes
) {
212 count
= inode
->i_sb
->s_maxbytes
- pos
;
217 errno
= ncp_make_open(inode
, O_WRONLY
);
219 DPRINTK(KERN_ERR
"ncp_file_write: open failed, error=%d\n", errno
);
222 bufsize
= NCP_SERVER(inode
)->buffer_size
;
226 bouncebuffer
= vmalloc(bufsize
);
228 errno
= -EIO
; /* -ENOMEM */
231 while (already_written
< count
) {
232 int written_this_time
;
233 size_t to_write
= min_t(unsigned int,
234 bufsize
- (pos
% bufsize
),
235 count
- already_written
);
237 if (copy_from_user(bouncebuffer
, buf
, to_write
)) {
241 if (ncp_write_kernel(NCP_SERVER(inode
),
242 NCP_FINFO(inode
)->file_handle
,
243 pos
, to_write
, bouncebuffer
, &written_this_time
) != 0) {
247 pos
+= written_this_time
;
248 buf
+= written_this_time
;
249 already_written
+= written_this_time
;
251 if (written_this_time
!= to_write
) {
257 file_update_time(file
);
261 if (pos
> i_size_read(inode
)) {
262 mutex_lock(&inode
->i_mutex
);
263 if (pos
> i_size_read(inode
))
264 i_size_write(inode
, pos
);
265 mutex_unlock(&inode
->i_mutex
);
267 DPRINTK("ncp_file_write: exit %s/%s\n",
268 dentry
->d_parent
->d_name
.name
, dentry
->d_name
.name
);
270 ncp_inode_close(inode
);
271 return already_written
? already_written
: errno
;
274 static int ncp_release(struct inode
*inode
, struct file
*file
) {
275 if (ncp_make_closed(inode
)) {
276 DPRINTK("ncp_release: failed to close\n");
281 const struct file_operations ncp_file_operations
=
283 .llseek
= generic_file_llseek
,
284 .read
= ncp_file_read
,
285 .write
= ncp_file_write
,
286 .unlocked_ioctl
= ncp_ioctl
,
288 .compat_ioctl
= ncp_compat_ioctl
,
291 .release
= ncp_release
,
295 const struct inode_operations ncp_file_inode_operations
=
297 .setattr
= ncp_notify_change
,