1
2
3
4
5
6
7
8
9
10#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
11
12#include <linux/uaccess.h>
13
14#include <linux/time.h>
15#include <linux/kernel.h>
16#include <linux/errno.h>
17#include <linux/fcntl.h>
18#include <linux/stat.h>
19#include <linux/mm.h>
20#include <linux/vmalloc.h>
21#include <linux/sched.h>
22
23#include "ncp_fs.h"
24
25static int ncp_fsync(struct file *file, loff_t start, loff_t end, int datasync)
26{
27 return file_write_and_wait_range(file, start, end);
28}
29
30
31
32
33int ncp_make_open(struct inode *inode, int right)
34{
35 int error;
36 int access;
37
38 error = -EINVAL;
39 if (!inode) {
40 pr_err("%s: got NULL inode\n", __func__);
41 goto out;
42 }
43
44 ncp_dbg(1, "opened=%d, volume # %u, dir entry # %u\n",
45 atomic_read(&NCP_FINFO(inode)->opened),
46 NCP_FINFO(inode)->volNumber,
47 NCP_FINFO(inode)->dirEntNum);
48 error = -EACCES;
49 mutex_lock(&NCP_FINFO(inode)->open_mutex);
50 if (!atomic_read(&NCP_FINFO(inode)->opened)) {
51 struct ncp_entry_info finfo;
52 int result;
53
54
55 finfo.access = O_RDWR;
56 result = ncp_open_create_file_or_subdir(NCP_SERVER(inode),
57 inode, NULL, OC_MODE_OPEN,
58 0, AR_READ | AR_WRITE, &finfo);
59 if (!result)
60 goto update;
61
62 switch (right) {
63 case O_RDONLY:
64 finfo.access = O_RDONLY;
65 result = ncp_open_create_file_or_subdir(NCP_SERVER(inode),
66 inode, NULL, OC_MODE_OPEN,
67 0, AR_READ, &finfo);
68 break;
69 case O_WRONLY:
70 finfo.access = O_WRONLY;
71 result = ncp_open_create_file_or_subdir(NCP_SERVER(inode),
72 inode, NULL, OC_MODE_OPEN,
73 0, AR_WRITE, &finfo);
74 break;
75 }
76 if (result) {
77 ncp_vdbg("failed, result=%d\n", result);
78 goto out_unlock;
79 }
80
81
82
83 update:
84 ncp_update_inode(inode, &finfo);
85 atomic_set(&NCP_FINFO(inode)->opened, 1);
86 }
87
88 access = NCP_FINFO(inode)->access;
89 ncp_vdbg("file open, access=%x\n", access);
90 if (access == right || access == O_RDWR) {
91 atomic_inc(&NCP_FINFO(inode)->opened);
92 error = 0;
93 }
94
95out_unlock:
96 mutex_unlock(&NCP_FINFO(inode)->open_mutex);
97out:
98 return error;
99}
100
101static ssize_t
102ncp_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
103{
104 struct file *file = iocb->ki_filp;
105 struct inode *inode = file_inode(file);
106 size_t already_read = 0;
107 off_t pos = iocb->ki_pos;
108 size_t bufsize;
109 int error;
110 void *freepage;
111 size_t freelen;
112
113 ncp_dbg(1, "enter %pD2\n", file);
114
115 if (!iov_iter_count(to))
116 return 0;
117 if (pos > inode->i_sb->s_maxbytes)
118 return 0;
119 iov_iter_truncate(to, inode->i_sb->s_maxbytes - pos);
120
121 error = ncp_make_open(inode, O_RDONLY);
122 if (error) {
123 ncp_dbg(1, "open failed, error=%d\n", error);
124 return error;
125 }
126
127 bufsize = NCP_SERVER(inode)->buffer_size;
128
129 error = -EIO;
130 freelen = ncp_read_bounce_size(bufsize);
131 freepage = vmalloc(freelen);
132 if (!freepage)
133 goto outrel;
134 error = 0;
135
136 while (iov_iter_count(to)) {
137 int read_this_time;
138 size_t to_read = min_t(size_t,
139 bufsize - (pos % bufsize),
140 iov_iter_count(to));
141
142 error = ncp_read_bounce(NCP_SERVER(inode),
143 NCP_FINFO(inode)->file_handle,
144 pos, to_read, to, &read_this_time,
145 freepage, freelen);
146 if (error) {
147 error = -EIO;
148 break;
149 }
150 pos += read_this_time;
151 already_read += read_this_time;
152
153 if (read_this_time != to_read)
154 break;
155 }
156 vfree(freepage);
157
158 iocb->ki_pos = pos;
159
160 file_accessed(file);
161
162 ncp_dbg(1, "exit %pD2\n", file);
163outrel:
164 ncp_inode_close(inode);
165 return already_read ? already_read : error;
166}
167
168static ssize_t
169ncp_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
170{
171 struct file *file = iocb->ki_filp;
172 struct inode *inode = file_inode(file);
173 size_t already_written = 0;
174 size_t bufsize;
175 int errno;
176 void *bouncebuffer;
177 off_t pos;
178
179 ncp_dbg(1, "enter %pD2\n", file);
180 errno = generic_write_checks(iocb, from);
181 if (errno <= 0)
182 return errno;
183
184 errno = ncp_make_open(inode, O_WRONLY);
185 if (errno) {
186 ncp_dbg(1, "open failed, error=%d\n", errno);
187 return errno;
188 }
189 bufsize = NCP_SERVER(inode)->buffer_size;
190
191 errno = file_update_time(file);
192 if (errno)
193 goto outrel;
194
195 bouncebuffer = vmalloc(bufsize);
196 if (!bouncebuffer) {
197 errno = -EIO;
198 goto outrel;
199 }
200 pos = iocb->ki_pos;
201 while (iov_iter_count(from)) {
202 int written_this_time;
203 size_t to_write = min_t(size_t,
204 bufsize - (pos % bufsize),
205 iov_iter_count(from));
206
207 if (!copy_from_iter_full(bouncebuffer, to_write, from)) {
208 errno = -EFAULT;
209 break;
210 }
211 if (ncp_write_kernel(NCP_SERVER(inode),
212 NCP_FINFO(inode)->file_handle,
213 pos, to_write, bouncebuffer, &written_this_time) != 0) {
214 errno = -EIO;
215 break;
216 }
217 pos += written_this_time;
218 already_written += written_this_time;
219
220 if (written_this_time != to_write)
221 break;
222 }
223 vfree(bouncebuffer);
224
225 iocb->ki_pos = pos;
226
227 if (pos > i_size_read(inode)) {
228 inode_lock(inode);
229 if (pos > i_size_read(inode))
230 i_size_write(inode, pos);
231 inode_unlock(inode);
232 }
233 ncp_dbg(1, "exit %pD2\n", file);
234outrel:
235 ncp_inode_close(inode);
236 return already_written ? already_written : errno;
237}
238
239static int ncp_release(struct inode *inode, struct file *file) {
240 if (ncp_make_closed(inode)) {
241 ncp_dbg(1, "failed to close\n");
242 }
243 return 0;
244}
245
246const struct file_operations ncp_file_operations =
247{
248 .llseek = generic_file_llseek,
249 .read_iter = ncp_file_read_iter,
250 .write_iter = ncp_file_write_iter,
251 .unlocked_ioctl = ncp_ioctl,
252#ifdef CONFIG_COMPAT
253 .compat_ioctl = ncp_compat_ioctl,
254#endif
255 .mmap = ncp_mmap,
256 .release = ncp_release,
257 .fsync = ncp_fsync,
258};
259
260const struct inode_operations ncp_file_inode_operations =
261{
262 .setattr = ncp_notify_change,
263};
264
