4 * Copyright (C) 1995, 1996 by Volker Lendecke
5 * Modified 1997 Peter Waltenberg, Bill Hawes, David Woodhouse for 2.1 dcache
9 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11 #include <asm/uaccess.h>
13 #include <linux/time.h>
14 #include <linux/kernel.h>
15 #include <linux/errno.h>
16 #include <linux/fcntl.h>
17 #include <linux/stat.h>
19 #include <linux/vmalloc.h>
20 #include <linux/sched.h>
24 static int ncp_fsync(struct file
*file
, loff_t start
, loff_t end
, int datasync
)
26 return filemap_write_and_wait_range(file
->f_mapping
, start
, end
);
30 * Open a file with the specified read/write mode.
32 int ncp_make_open(struct inode
*inode
, int right
)
39 pr_err("%s: got NULL inode\n", __func__
);
43 ncp_dbg(1, "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 ncp_vdbg("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 ncp_vdbg("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 ncp_dbg(1, "enter %pd2\n", dentry
);
116 if ((ssize_t
) count
< 0) {
121 if (pos
> inode
->i_sb
->s_maxbytes
)
123 if (pos
+ count
> inode
->i_sb
->s_maxbytes
) {
124 count
= inode
->i_sb
->s_maxbytes
- pos
;
127 error
= ncp_make_open(inode
, O_RDONLY
);
129 ncp_dbg(1, "open failed, error=%d\n", error
);
133 bufsize
= NCP_SERVER(inode
)->buffer_size
;
136 freelen
= ncp_read_bounce_size(bufsize
);
137 freepage
= vmalloc(freelen
);
141 /* First read in as much as possible for each bufsize. */
142 while (already_read
< count
) {
144 size_t to_read
= min_t(unsigned int,
145 bufsize
- (pos
% bufsize
),
146 count
- already_read
);
148 error
= ncp_read_bounce(NCP_SERVER(inode
),
149 NCP_FINFO(inode
)->file_handle
,
150 pos
, to_read
, buf
, &read_this_time
,
153 error
= -EIO
; /* NW errno -> Linux errno */
156 pos
+= read_this_time
;
157 buf
+= read_this_time
;
158 already_read
+= read_this_time
;
160 if (read_this_time
!= to_read
) {
170 ncp_dbg(1, "exit %pd2\n", dentry
);
172 ncp_inode_close(inode
);
173 return already_read
? already_read
: error
;
177 ncp_file_write(struct file
*file
, const char __user
*buf
, size_t count
, loff_t
*ppos
)
179 struct dentry
*dentry
= file
->f_path
.dentry
;
180 struct inode
*inode
= dentry
->d_inode
;
181 size_t already_written
= 0;
187 ncp_dbg(1, "enter %pd2\n", dentry
);
188 if ((ssize_t
) count
< 0)
191 if (file
->f_flags
& O_APPEND
) {
192 pos
= i_size_read(inode
);
195 if (pos
+ count
> MAX_NON_LFS
&& !(file
->f_flags
&O_LARGEFILE
)) {
196 if (pos
>= MAX_NON_LFS
) {
199 if (count
> MAX_NON_LFS
- (u32
)pos
) {
200 count
= MAX_NON_LFS
- (u32
)pos
;
203 if (pos
>= inode
->i_sb
->s_maxbytes
) {
204 if (count
|| pos
> inode
->i_sb
->s_maxbytes
) {
208 if (pos
+ count
> inode
->i_sb
->s_maxbytes
) {
209 count
= inode
->i_sb
->s_maxbytes
- pos
;
214 errno
= ncp_make_open(inode
, O_WRONLY
);
216 ncp_dbg(1, "open failed, error=%d\n", errno
);
219 bufsize
= NCP_SERVER(inode
)->buffer_size
;
223 errno
= file_update_time(file
);
227 bouncebuffer
= vmalloc(bufsize
);
229 errno
= -EIO
; /* -ENOMEM */
232 while (already_written
< count
) {
233 int written_this_time
;
234 size_t to_write
= min_t(unsigned int,
235 bufsize
- (pos
% bufsize
),
236 count
- already_written
);
238 if (copy_from_user(bouncebuffer
, buf
, to_write
)) {
242 if (ncp_write_kernel(NCP_SERVER(inode
),
243 NCP_FINFO(inode
)->file_handle
,
244 pos
, to_write
, bouncebuffer
, &written_this_time
) != 0) {
248 pos
+= written_this_time
;
249 buf
+= written_this_time
;
250 already_written
+= written_this_time
;
252 if (written_this_time
!= to_write
) {
260 if (pos
> i_size_read(inode
)) {
261 mutex_lock(&inode
->i_mutex
);
262 if (pos
> i_size_read(inode
))
263 i_size_write(inode
, pos
);
264 mutex_unlock(&inode
->i_mutex
);
266 ncp_dbg(1, "exit %pd2\n", dentry
);
268 ncp_inode_close(inode
);
269 return already_written
? already_written
: errno
;
272 static int ncp_release(struct inode
*inode
, struct file
*file
) {
273 if (ncp_make_closed(inode
)) {
274 ncp_dbg(1, "failed to close\n");
279 const struct file_operations ncp_file_operations
=
281 .llseek
= generic_file_llseek
,
282 .read
= ncp_file_read
,
283 .write
= ncp_file_write
,
284 .unlocked_ioctl
= ncp_ioctl
,
286 .compat_ioctl
= ncp_compat_ioctl
,
289 .release
= ncp_release
,
293 const struct inode_operations ncp_file_inode_operations
=
295 .setattr
= ncp_notify_change
,