Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
5db11c21 MM |
2 | /* |
3 | * (C) 2001 Clemson University and The University of Chicago | |
4 | * | |
5 | * See COPYING in top-level directory. | |
6 | */ | |
7 | ||
8 | /* | |
9 | * Linux VFS file operations. | |
10 | */ | |
11 | ||
12 | #include "protocol.h" | |
575e9461 MM |
13 | #include "orangefs-kernel.h" |
14 | #include "orangefs-bufmap.h" | |
5db11c21 MM |
15 | #include <linux/fs.h> |
16 | #include <linux/pagemap.h> | |
17 | ||
ed1e1587 MB |
18 | static int flush_racache(struct inode *inode) |
19 | { | |
20 | struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode); | |
21 | struct orangefs_kernel_op_s *new_op; | |
22 | int ret; | |
23 | ||
24 | gossip_debug(GOSSIP_UTILS_DEBUG, | |
25 | "%s: %pU: Handle is %pU | fs_id %d\n", __func__, | |
26 | get_khandle_from_ino(inode), &orangefs_inode->refn.khandle, | |
27 | orangefs_inode->refn.fs_id); | |
28 | ||
29 | new_op = op_alloc(ORANGEFS_VFS_OP_RA_FLUSH); | |
30 | if (!new_op) | |
31 | return -ENOMEM; | |
32 | new_op->upcall.req.ra_cache_flush.refn = orangefs_inode->refn; | |
33 | ||
34 | ret = service_operation(new_op, "orangefs_flush_racache", | |
35 | get_interruptible_flag(inode)); | |
36 | ||
37 | gossip_debug(GOSSIP_UTILS_DEBUG, "%s: got return value of %d\n", | |
38 | __func__, ret); | |
39 | ||
40 | op_release(new_op); | |
41 | return ret; | |
42 | } | |
43 | ||
5db11c21 MM |
44 | /* |
45 | * Post and wait for the I/O upcall to finish | |
46 | */ | |
8bb8aefd | 47 | static ssize_t wait_for_direct_io(enum ORANGEFS_io_type type, struct inode *inode, |
3c2fcfcb | 48 | loff_t *offset, struct iov_iter *iter, |
4d1c4404 | 49 | size_t total_size, loff_t readahead_size) |
5db11c21 | 50 | { |
8bb8aefd YL |
51 | struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode); |
52 | struct orangefs_khandle *handle = &orangefs_inode->refn.khandle; | |
8bb8aefd | 53 | struct orangefs_kernel_op_s *new_op = NULL; |
5db11c21 MM |
54 | int buffer_index = -1; |
55 | ssize_t ret; | |
56 | ||
8bb8aefd | 57 | new_op = op_alloc(ORANGEFS_VFS_OP_FILE_IO); |
ed42fe05 AV |
58 | if (!new_op) |
59 | return -ENOMEM; | |
60 | ||
5db11c21 | 61 | /* synchronous I/O */ |
5db11c21 MM |
62 | new_op->upcall.req.io.readahead_size = readahead_size; |
63 | new_op->upcall.req.io.io_type = type; | |
8bb8aefd | 64 | new_op->upcall.req.io.refn = orangefs_inode->refn; |
5db11c21 MM |
65 | |
66 | populate_shared_memory: | |
67 | /* get a shared buffer index */ | |
b8a99a8f AV |
68 | buffer_index = orangefs_bufmap_get(); |
69 | if (buffer_index < 0) { | |
70 | ret = buffer_index; | |
5db11c21 | 71 | gossip_debug(GOSSIP_FILE_DEBUG, |
b8a99a8f AV |
72 | "%s: orangefs_bufmap_get failure (%zd)\n", |
73 | __func__, ret); | |
5db11c21 MM |
74 | goto out; |
75 | } | |
76 | gossip_debug(GOSSIP_FILE_DEBUG, | |
77 | "%s(%pU): GET op %p -> buffer_index %d\n", | |
78 | __func__, | |
79 | handle, | |
80 | new_op, | |
81 | buffer_index); | |
82 | ||
83 | new_op->uses_shared_memory = 1; | |
84 | new_op->upcall.req.io.buf_index = buffer_index; | |
85 | new_op->upcall.req.io.count = total_size; | |
86 | new_op->upcall.req.io.offset = *offset; | |
87 | ||
88 | gossip_debug(GOSSIP_FILE_DEBUG, | |
3c2fcfcb | 89 | "%s(%pU): offset: %llu total_size: %zd\n", |
5db11c21 MM |
90 | __func__, |
91 | handle, | |
5db11c21 MM |
92 | llu(*offset), |
93 | total_size); | |
94 | /* | |
95 | * Stage 1: copy the buffers into client-core's address space | |
5db11c21 | 96 | */ |
dbcb5e7f MB |
97 | if (type == ORANGEFS_IO_WRITE && total_size) { |
98 | ret = orangefs_bufmap_copy_from_iovec(iter, buffer_index, | |
99 | total_size); | |
100 | if (ret < 0) { | |
101 | gossip_err("%s: Failed to copy-in buffers. Please make sure that the pvfs2-client is running. %ld\n", | |
102 | __func__, (long)ret); | |
5db11c21 | 103 | goto out; |
dbcb5e7f | 104 | } |
5db11c21 MM |
105 | } |
106 | ||
107 | gossip_debug(GOSSIP_FILE_DEBUG, | |
108 | "%s(%pU): Calling post_io_request with tag (%llu)\n", | |
109 | __func__, | |
110 | handle, | |
111 | llu(new_op->tag)); | |
112 | ||
113 | /* Stage 2: Service the I/O operation */ | |
114 | ret = service_operation(new_op, | |
8bb8aefd | 115 | type == ORANGEFS_IO_WRITE ? |
5db11c21 MM |
116 | "file_write" : |
117 | "file_read", | |
118 | get_interruptible_flag(inode)); | |
119 | ||
120 | /* | |
121 | * If service_operation() returns -EAGAIN #and# the operation was | |
8bb8aefd | 122 | * purged from orangefs_request_list or htable_ops_in_progress, then |
5db11c21 MM |
123 | * we know that the client was restarted, causing the shared memory |
124 | * area to be wiped clean. To restart a write operation in this | |
125 | * case, we must re-copy the data from the user's iovec to a NEW | |
126 | * shared memory location. To restart a read operation, we must get | |
127 | * a new shared memory location. | |
128 | */ | |
129 | if (ret == -EAGAIN && op_state_purged(new_op)) { | |
1357d06d | 130 | orangefs_bufmap_put(buffer_index); |
e17be9fd | 131 | buffer_index = -1; |
7b9761af | 132 | if (type == ORANGEFS_IO_WRITE) |
c63ed807 | 133 | iov_iter_revert(iter, total_size); |
5db11c21 MM |
134 | gossip_debug(GOSSIP_FILE_DEBUG, |
135 | "%s:going to repopulate_shared_memory.\n", | |
136 | __func__); | |
137 | goto populate_shared_memory; | |
138 | } | |
139 | ||
140 | if (ret < 0) { | |
162ada77 MM |
141 | if (ret == -EINTR) { |
142 | /* | |
143 | * We can't return EINTR if any data was written, | |
144 | * it's not POSIX. It is minimally acceptable | |
145 | * to give a partial write, the way NFS does. | |
146 | * | |
147 | * It would be optimal to return all or nothing, | |
148 | * but if a userspace write is bigger than | |
149 | * an IO buffer, and the interrupt occurs | |
150 | * between buffer writes, that would not be | |
151 | * possible. | |
152 | */ | |
153 | switch (new_op->op_state - OP_VFS_STATE_GIVEN_UP) { | |
154 | /* | |
155 | * If the op was waiting when the interrupt | |
156 | * occurred, then the client-core did not | |
157 | * trigger the write. | |
158 | */ | |
159 | case OP_VFS_STATE_WAITING: | |
160 | if (*offset == 0) | |
161 | ret = -EINTR; | |
162 | else | |
163 | ret = 0; | |
164 | break; | |
165 | /* | |
166 | * If the op was in progress when the interrupt | |
167 | * occurred, then the client-core was able to | |
168 | * trigger the write. | |
169 | */ | |
170 | case OP_VFS_STATE_INPROGR: | |
171 | ret = total_size; | |
172 | break; | |
173 | default: | |
174 | gossip_err("%s: unexpected op state :%d:.\n", | |
175 | __func__, | |
176 | new_op->op_state); | |
177 | ret = 0; | |
178 | break; | |
179 | } | |
5db11c21 | 180 | gossip_debug(GOSSIP_FILE_DEBUG, |
162ada77 MM |
181 | "%s: got EINTR, state:%d: %p\n", |
182 | __func__, | |
183 | new_op->op_state, | |
184 | new_op); | |
185 | } else { | |
5db11c21 MM |
186 | gossip_err("%s: error in %s handle %pU, returning %zd\n", |
187 | __func__, | |
8bb8aefd | 188 | type == ORANGEFS_IO_READ ? |
5db11c21 MM |
189 | "read from" : "write to", |
190 | handle, ret); | |
162ada77 | 191 | } |
78699e29 AV |
192 | if (orangefs_cancel_op_in_progress(new_op)) |
193 | return ret; | |
194 | ||
897c5df6 | 195 | goto out; |
5db11c21 MM |
196 | } |
197 | ||
198 | /* | |
199 | * Stage 3: Post copy buffers from client-core's address space | |
5db11c21 | 200 | */ |
dbcb5e7f MB |
201 | if (type == ORANGEFS_IO_READ && new_op->downcall.resp.io.amt_complete) { |
202 | /* | |
203 | * NOTE: the iovector can either contain addresses which | |
204 | * can futher be kernel-space or user-space addresses. | |
205 | * or it can pointers to struct page's | |
206 | */ | |
207 | ret = orangefs_bufmap_copy_to_iovec(iter, buffer_index, | |
208 | new_op->downcall.resp.io.amt_complete); | |
209 | if (ret < 0) { | |
210 | gossip_err("%s: Failed to copy-out buffers. Please make sure that the pvfs2-client is running (%ld)\n", | |
211 | __func__, (long)ret); | |
897c5df6 | 212 | goto out; |
dbcb5e7f | 213 | } |
5db11c21 MM |
214 | } |
215 | gossip_debug(GOSSIP_FILE_DEBUG, | |
9d9e7ba9 | 216 | "%s(%pU): Amount %s, returned by the sys-io call:%d\n", |
5db11c21 MM |
217 | __func__, |
218 | handle, | |
9d9e7ba9 | 219 | type == ORANGEFS_IO_READ ? "read" : "written", |
5db11c21 MM |
220 | (int)new_op->downcall.resp.io.amt_complete); |
221 | ||
222 | ret = new_op->downcall.resp.io.amt_complete; | |
223 | ||
5db11c21 MM |
224 | out: |
225 | if (buffer_index >= 0) { | |
1357d06d | 226 | orangefs_bufmap_put(buffer_index); |
5db11c21 MM |
227 | gossip_debug(GOSSIP_FILE_DEBUG, |
228 | "%s(%pU): PUT buffer_index %d\n", | |
229 | __func__, handle, buffer_index); | |
230 | buffer_index = -1; | |
231 | } | |
ed42fe05 | 232 | op_release(new_op); |
5db11c21 MM |
233 | return ret; |
234 | } | |
235 | ||
5db11c21 MM |
236 | /* |
237 | * Common entry point for read/write/readv/writev | |
238 | * This function will dispatch it to either the direct I/O | |
239 | * or buffered I/O path depending on the mount options and/or | |
240 | * augmented/extended metadata attached to the file. | |
241 | * Note: File extended attributes override any mount options. | |
242 | */ | |
8bb8aefd | 243 | static ssize_t do_readv_writev(enum ORANGEFS_io_type type, struct file *file, |
0071ed1e | 244 | loff_t *offset, struct iov_iter *iter) |
5db11c21 MM |
245 | { |
246 | struct inode *inode = file->f_mapping->host; | |
8bb8aefd YL |
247 | struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode); |
248 | struct orangefs_khandle *handle = &orangefs_inode->refn.khandle; | |
0071ed1e | 249 | size_t count = iov_iter_count(iter); |
dc4067f6 AV |
250 | ssize_t total_count = 0; |
251 | ssize_t ret = -EINVAL; | |
5db11c21 MM |
252 | |
253 | gossip_debug(GOSSIP_FILE_DEBUG, | |
254 | "%s-BEGIN(%pU): count(%d) after estimate_max_iovecs.\n", | |
255 | __func__, | |
256 | handle, | |
257 | (int)count); | |
258 | ||
8bb8aefd | 259 | if (type == ORANGEFS_IO_WRITE) { |
5db11c21 MM |
260 | gossip_debug(GOSSIP_FILE_DEBUG, |
261 | "%s(%pU): proceeding with offset : %llu, " | |
262 | "size %d\n", | |
263 | __func__, | |
264 | handle, | |
265 | llu(*offset), | |
266 | (int)count); | |
267 | } | |
268 | ||
269 | if (count == 0) { | |
270 | ret = 0; | |
271 | goto out; | |
272 | } | |
273 | ||
0071ed1e AV |
274 | while (iov_iter_count(iter)) { |
275 | size_t each_count = iov_iter_count(iter); | |
5db11c21 MM |
276 | size_t amt_complete; |
277 | ||
278 | /* how much to transfer in this loop iteration */ | |
8bb8aefd YL |
279 | if (each_count > orangefs_bufmap_size_query()) |
280 | each_count = orangefs_bufmap_size_query(); | |
5db11c21 MM |
281 | |
282 | gossip_debug(GOSSIP_FILE_DEBUG, | |
283 | "%s(%pU): size of each_count(%d)\n", | |
284 | __func__, | |
285 | handle, | |
286 | (int)each_count); | |
287 | gossip_debug(GOSSIP_FILE_DEBUG, | |
288 | "%s(%pU): BEFORE wait_for_io: offset is %d\n", | |
289 | __func__, | |
290 | handle, | |
291 | (int)*offset); | |
292 | ||
0071ed1e | 293 | ret = wait_for_direct_io(type, inode, offset, iter, |
3c2fcfcb | 294 | each_count, 0); |
5db11c21 MM |
295 | gossip_debug(GOSSIP_FILE_DEBUG, |
296 | "%s(%pU): return from wait_for_io:%d\n", | |
297 | __func__, | |
298 | handle, | |
299 | (int)ret); | |
300 | ||
301 | if (ret < 0) | |
302 | goto out; | |
303 | ||
5db11c21 MM |
304 | *offset += ret; |
305 | total_count += ret; | |
306 | amt_complete = ret; | |
307 | ||
308 | gossip_debug(GOSSIP_FILE_DEBUG, | |
309 | "%s(%pU): AFTER wait_for_io: offset is %d\n", | |
310 | __func__, | |
311 | handle, | |
312 | (int)*offset); | |
313 | ||
314 | /* | |
315 | * if we got a short I/O operations, | |
316 | * fall out and return what we got so far | |
317 | */ | |
318 | if (amt_complete < each_count) | |
319 | break; | |
320 | } /*end while */ | |
321 | ||
6d4c1a30 | 322 | out: |
5db11c21 MM |
323 | if (total_count > 0) |
324 | ret = total_count; | |
5db11c21 | 325 | if (ret > 0) { |
8bb8aefd | 326 | if (type == ORANGEFS_IO_READ) { |
5db11c21 MM |
327 | file_accessed(file); |
328 | } else { | |
a55f2d86 MB |
329 | file_update_time(file); |
330 | /* | |
331 | * Must invalidate to ensure write loop doesn't | |
332 | * prevent kernel from reading updated | |
333 | * attribute. Size probably changed because of | |
334 | * the write, and other clients could update | |
335 | * any other attribute. | |
336 | */ | |
337 | orangefs_inode->getattr_time = jiffies - 1; | |
5db11c21 MM |
338 | } |
339 | } | |
340 | ||
341 | gossip_debug(GOSSIP_FILE_DEBUG, | |
342 | "%s(%pU): Value(%d) returned.\n", | |
343 | __func__, | |
344 | handle, | |
345 | (int)ret); | |
346 | ||
347 | return ret; | |
348 | } | |
349 | ||
350 | /* | |
351 | * Read data from a specified offset in a file (referenced by inode). | |
352 | * Data may be placed either in a user or kernel buffer. | |
353 | */ | |
8bb8aefd YL |
354 | ssize_t orangefs_inode_read(struct inode *inode, |
355 | struct iov_iter *iter, | |
356 | loff_t *offset, | |
357 | loff_t readahead_size) | |
5db11c21 | 358 | { |
8bb8aefd | 359 | struct orangefs_inode_s *orangefs_inode = ORANGEFS_I(inode); |
74f68fce | 360 | size_t count = iov_iter_count(iter); |
5db11c21 | 361 | size_t bufmap_size; |
5db11c21 MM |
362 | ssize_t ret = -EINVAL; |
363 | ||
889d5f1b | 364 | orangefs_stats.reads++; |
5db11c21 | 365 | |
8bb8aefd | 366 | bufmap_size = orangefs_bufmap_size_query(); |
5db11c21 MM |
367 | if (count > bufmap_size) { |
368 | gossip_debug(GOSSIP_FILE_DEBUG, | |
369 | "%s: count is too large (%zd/%zd)!\n", | |
370 | __func__, count, bufmap_size); | |
371 | return -EINVAL; | |
372 | } | |
373 | ||
374 | gossip_debug(GOSSIP_FILE_DEBUG, | |
375 | "%s(%pU) %zd@%llu\n", | |
376 | __func__, | |
8bb8aefd | 377 | &orangefs_inode->refn.khandle, |
5db11c21 MM |
378 | count, |
379 | llu(*offset)); | |
380 | ||
8bb8aefd | 381 | ret = wait_for_direct_io(ORANGEFS_IO_READ, inode, offset, iter, |
4d1c4404 | 382 | count, readahead_size); |
5db11c21 MM |
383 | if (ret > 0) |
384 | *offset += ret; | |
385 | ||
386 | gossip_debug(GOSSIP_FILE_DEBUG, | |
387 | "%s(%pU): Value(%zd) returned.\n", | |
388 | __func__, | |
8bb8aefd | 389 | &orangefs_inode->refn.khandle, |
5db11c21 MM |
390 | ret); |
391 | ||
392 | return ret; | |
393 | } | |
394 | ||
8bb8aefd | 395 | static ssize_t orangefs_file_read_iter(struct kiocb *iocb, struct iov_iter *iter) |
5db11c21 MM |
396 | { |
397 | struct file *file = iocb->ki_filp; | |
6793f1c4 | 398 | loff_t pos = iocb->ki_pos; |
5db11c21 | 399 | ssize_t rc = 0; |
5db11c21 MM |
400 | |
401 | BUG_ON(iocb->private); | |
402 | ||
8bb8aefd | 403 | gossip_debug(GOSSIP_FILE_DEBUG, "orangefs_file_read_iter\n"); |
5db11c21 | 404 | |
889d5f1b | 405 | orangefs_stats.reads++; |
5db11c21 | 406 | |
8bb8aefd | 407 | rc = do_readv_writev(ORANGEFS_IO_READ, file, &pos, iter); |
5db11c21 MM |
408 | iocb->ki_pos = pos; |
409 | ||
410 | return rc; | |
411 | } | |
412 | ||
8bb8aefd | 413 | static ssize_t orangefs_file_write_iter(struct kiocb *iocb, struct iov_iter *iter) |
5db11c21 MM |
414 | { |
415 | struct file *file = iocb->ki_filp; | |
3f1b6947 | 416 | loff_t pos; |
5db11c21 MM |
417 | ssize_t rc; |
418 | ||
419 | BUG_ON(iocb->private); | |
420 | ||
8bb8aefd | 421 | gossip_debug(GOSSIP_FILE_DEBUG, "orangefs_file_write_iter\n"); |
5db11c21 | 422 | |
5ecfcb26 | 423 | inode_lock(file->f_mapping->host); |
5db11c21 MM |
424 | |
425 | /* Make sure generic_write_checks sees an up to date inode size. */ | |
426 | if (file->f_flags & O_APPEND) { | |
68a24a6c MB |
427 | rc = orangefs_inode_getattr(file->f_mapping->host, 0, 1, |
428 | STATX_SIZE); | |
e2f7f0d7 MB |
429 | if (rc == -ESTALE) |
430 | rc = -EIO; | |
5db11c21 | 431 | if (rc) { |
e2f7f0d7 MB |
432 | gossip_err("%s: orangefs_inode_getattr failed, " |
433 | "rc:%zd:.\n", __func__, rc); | |
5db11c21 MM |
434 | goto out; |
435 | } | |
436 | } | |
437 | ||
5db11c21 MM |
438 | rc = generic_write_checks(iocb, iter); |
439 | ||
440 | if (rc <= 0) { | |
441 | gossip_err("%s: generic_write_checks failed, rc:%zd:.\n", | |
442 | __func__, rc); | |
443 | goto out; | |
444 | } | |
445 | ||
3f1b6947 MM |
446 | /* |
447 | * if we are appending, generic_write_checks would have updated | |
448 | * pos to the end of the file, so we will wait till now to set | |
449 | * pos... | |
450 | */ | |
6793f1c4 | 451 | pos = iocb->ki_pos; |
3f1b6947 | 452 | |
8bb8aefd | 453 | rc = do_readv_writev(ORANGEFS_IO_WRITE, |
5db11c21 MM |
454 | file, |
455 | &pos, | |
0071ed1e | 456 | iter); |
5db11c21 MM |
457 | if (rc < 0) { |
458 | gossip_err("%s: do_readv_writev failed, rc:%zd:.\n", | |
459 | __func__, rc); | |
460 | goto out; | |
461 | } | |
462 | ||
463 | iocb->ki_pos = pos; | |
889d5f1b | 464 | orangefs_stats.writes++; |
5db11c21 MM |
465 | |
466 | out: | |
467 | ||
5ecfcb26 | 468 | inode_unlock(file->f_mapping->host); |
5db11c21 MM |
469 | return rc; |
470 | } | |
471 | ||
472 | /* | |
473 | * Perform a miscellaneous operation on a file. | |
474 | */ | |
8bb8aefd | 475 | static long orangefs_ioctl(struct file *file, unsigned int cmd, unsigned long arg) |
5db11c21 MM |
476 | { |
477 | int ret = -ENOTTY; | |
478 | __u64 val = 0; | |
479 | unsigned long uval; | |
480 | ||
481 | gossip_debug(GOSSIP_FILE_DEBUG, | |
8bb8aefd | 482 | "orangefs_ioctl: called with cmd %d\n", |
5db11c21 MM |
483 | cmd); |
484 | ||
485 | /* | |
486 | * we understand some general ioctls on files, such as the immutable | |
487 | * and append flags | |
488 | */ | |
489 | if (cmd == FS_IOC_GETFLAGS) { | |
490 | val = 0; | |
8bb8aefd | 491 | ret = orangefs_inode_getxattr(file_inode(file), |
8bb8aefd YL |
492 | "user.pvfs2.meta_hint", |
493 | &val, sizeof(val)); | |
5db11c21 MM |
494 | if (ret < 0 && ret != -ENODATA) |
495 | return ret; | |
496 | else if (ret == -ENODATA) | |
497 | val = 0; | |
498 | uval = val; | |
499 | gossip_debug(GOSSIP_FILE_DEBUG, | |
8bb8aefd | 500 | "orangefs_ioctl: FS_IOC_GETFLAGS: %llu\n", |
5db11c21 MM |
501 | (unsigned long long)uval); |
502 | return put_user(uval, (int __user *)arg); | |
503 | } else if (cmd == FS_IOC_SETFLAGS) { | |
504 | ret = 0; | |
505 | if (get_user(uval, (int __user *)arg)) | |
506 | return -EFAULT; | |
507 | /* | |
8bb8aefd | 508 | * ORANGEFS_MIRROR_FL is set internally when the mirroring mode |
5db11c21 MM |
509 | * is turned on for a file. The user is not allowed to turn |
510 | * on this bit, but the bit is present if the user first gets | |
511 | * the flags and then updates the flags with some new | |
512 | * settings. So, we ignore it in the following edit. bligon. | |
513 | */ | |
8bb8aefd | 514 | if ((uval & ~ORANGEFS_MIRROR_FL) & |
5db11c21 | 515 | (~(FS_IMMUTABLE_FL | FS_APPEND_FL | FS_NOATIME_FL))) { |
8bb8aefd | 516 | gossip_err("orangefs_ioctl: the FS_IOC_SETFLAGS only supports setting one of FS_IMMUTABLE_FL|FS_APPEND_FL|FS_NOATIME_FL\n"); |
5db11c21 MM |
517 | return -EINVAL; |
518 | } | |
519 | val = uval; | |
520 | gossip_debug(GOSSIP_FILE_DEBUG, | |
8bb8aefd | 521 | "orangefs_ioctl: FS_IOC_SETFLAGS: %llu\n", |
5db11c21 | 522 | (unsigned long long)val); |
8bb8aefd | 523 | ret = orangefs_inode_setxattr(file_inode(file), |
8bb8aefd YL |
524 | "user.pvfs2.meta_hint", |
525 | &val, sizeof(val), 0); | |
5db11c21 MM |
526 | } |
527 | ||
528 | return ret; | |
529 | } | |
530 | ||
531 | /* | |
532 | * Memory map a region of a file. | |
533 | */ | |
8bb8aefd | 534 | static int orangefs_file_mmap(struct file *file, struct vm_area_struct *vma) |
5db11c21 MM |
535 | { |
536 | gossip_debug(GOSSIP_FILE_DEBUG, | |
8bb8aefd | 537 | "orangefs_file_mmap: called on %s\n", |
5db11c21 MM |
538 | (file ? |
539 | (char *)file->f_path.dentry->d_name.name : | |
540 | (char *)"Unknown")); | |
541 | ||
542 | /* set the sequential readahead hint */ | |
543 | vma->vm_flags |= VM_SEQ_READ; | |
544 | vma->vm_flags &= ~VM_RAND_READ; | |
35390803 MB |
545 | |
546 | /* Use readonly mmap since we cannot support writable maps. */ | |
547 | return generic_file_readonly_mmap(file, vma); | |
5db11c21 MM |
548 | } |
549 | ||
550 | #define mapping_nrpages(idata) ((idata)->nrpages) | |
551 | ||
552 | /* | |
553 | * Called to notify the module that there are no more references to | |
554 | * this file (i.e. no processes have it open). | |
555 | * | |
556 | * \note Not called when each file is closed. | |
557 | */ | |
8bb8aefd | 558 | static int orangefs_file_release(struct inode *inode, struct file *file) |
5db11c21 MM |
559 | { |
560 | gossip_debug(GOSSIP_FILE_DEBUG, | |
f66debf1 AV |
561 | "orangefs_file_release: called on %pD\n", |
562 | file); | |
5db11c21 | 563 | |
5db11c21 | 564 | /* |
6eaff8c7 | 565 | * remove all associated inode pages from the page cache and |
54804949 MM |
566 | * readahead cache (if any); this forces an expensive refresh of |
567 | * data for the next caller of mmap (or 'get_block' accesses) | |
5db11c21 | 568 | */ |
d62a9025 AG |
569 | if (file_inode(file) && |
570 | file_inode(file)->i_mapping && | |
571 | mapping_nrpages(&file_inode(file)->i_data)) { | |
c51e0129 MB |
572 | if (orangefs_features & ORANGEFS_FEATURE_READAHEAD) { |
573 | gossip_debug(GOSSIP_INODE_DEBUG, | |
574 | "calling flush_racache on %pU\n", | |
575 | get_khandle_from_ino(inode)); | |
576 | flush_racache(inode); | |
577 | gossip_debug(GOSSIP_INODE_DEBUG, | |
578 | "flush_racache finished\n"); | |
579 | } | |
d62a9025 | 580 | truncate_inode_pages(file_inode(file)->i_mapping, |
5db11c21 | 581 | 0); |
ed1e1587 | 582 | } |
5db11c21 MM |
583 | return 0; |
584 | } | |
585 | ||
586 | /* | |
587 | * Push all data for a specific file onto permanent storage. | |
588 | */ | |
8bb8aefd | 589 | static int orangefs_fsync(struct file *file, |
84d02150 MM |
590 | loff_t start, |
591 | loff_t end, | |
592 | int datasync) | |
5db11c21 | 593 | { |
49e55713 | 594 | int ret; |
8bb8aefd | 595 | struct orangefs_inode_s *orangefs_inode = |
d62a9025 | 596 | ORANGEFS_I(file_inode(file)); |
8bb8aefd | 597 | struct orangefs_kernel_op_s *new_op = NULL; |
5db11c21 | 598 | |
8bb8aefd | 599 | new_op = op_alloc(ORANGEFS_VFS_OP_FSYNC); |
5db11c21 MM |
600 | if (!new_op) |
601 | return -ENOMEM; | |
8bb8aefd | 602 | new_op->upcall.req.fsync.refn = orangefs_inode->refn; |
5db11c21 MM |
603 | |
604 | ret = service_operation(new_op, | |
8bb8aefd | 605 | "orangefs_fsync", |
d62a9025 | 606 | get_interruptible_flag(file_inode(file))); |
5db11c21 MM |
607 | |
608 | gossip_debug(GOSSIP_FILE_DEBUG, | |
8bb8aefd | 609 | "orangefs_fsync got return value of %d\n", |
5db11c21 MM |
610 | ret); |
611 | ||
612 | op_release(new_op); | |
5db11c21 MM |
613 | return ret; |
614 | } | |
615 | ||
616 | /* | |
617 | * Change the file pointer position for an instance of an open file. | |
618 | * | |
619 | * \note If .llseek is overriden, we must acquire lock as described in | |
620 | * Documentation/filesystems/Locking. | |
621 | * | |
622 | * Future upgrade could support SEEK_DATA and SEEK_HOLE but would | |
623 | * require much changes to the FS | |
624 | */ | |
8bb8aefd | 625 | static loff_t orangefs_file_llseek(struct file *file, loff_t offset, int origin) |
5db11c21 MM |
626 | { |
627 | int ret = -EINVAL; | |
177f8fc4 | 628 | struct inode *inode = file_inode(file); |
5db11c21 | 629 | |
177f8fc4 | 630 | if (origin == SEEK_END) { |
5db11c21 MM |
631 | /* |
632 | * revalidate the inode's file size. | |
633 | * NOTE: We are only interested in file size here, | |
634 | * so we set mask accordingly. | |
635 | */ | |
68a24a6c MB |
636 | ret = orangefs_inode_getattr(file->f_mapping->host, 0, 1, |
637 | STATX_SIZE); | |
e2f7f0d7 MB |
638 | if (ret == -ESTALE) |
639 | ret = -EIO; | |
5db11c21 MM |
640 | if (ret) { |
641 | gossip_debug(GOSSIP_FILE_DEBUG, | |
642 | "%s:%s:%d calling make bad inode\n", | |
643 | __FILE__, | |
644 | __func__, | |
645 | __LINE__); | |
5db11c21 MM |
646 | return ret; |
647 | } | |
648 | } | |
649 | ||
650 | gossip_debug(GOSSIP_FILE_DEBUG, | |
8bb8aefd | 651 | "orangefs_file_llseek: offset is %ld | origin is %d" |
54804949 | 652 | " | inode size is %lu\n", |
5db11c21 MM |
653 | (long)offset, |
654 | origin, | |
177f8fc4 | 655 | (unsigned long)i_size_read(inode)); |
5db11c21 MM |
656 | |
657 | return generic_file_llseek(file, offset, origin); | |
658 | } | |
659 | ||
660 | /* | |
661 | * Support local locks (locks that only this kernel knows about) | |
662 | * if Orangefs was mounted -o local_lock. | |
663 | */ | |
8bb8aefd | 664 | static int orangefs_lock(struct file *filp, int cmd, struct file_lock *fl) |
5db11c21 | 665 | { |
f957ae2d | 666 | int rc = -EINVAL; |
5db11c21 | 667 | |
45063097 | 668 | if (ORANGEFS_SB(file_inode(filp)->i_sb)->flags & ORANGEFS_OPT_LOCAL_LOCK) { |
5db11c21 MM |
669 | if (cmd == F_GETLK) { |
670 | rc = 0; | |
671 | posix_test_lock(filp, fl); | |
672 | } else { | |
673 | rc = posix_lock_file(filp, fl, NULL); | |
674 | } | |
675 | } | |
676 | ||
677 | return rc; | |
678 | } | |
679 | ||
8bb8aefd YL |
680 | /** ORANGEFS implementation of VFS file operations */ |
681 | const struct file_operations orangefs_file_operations = { | |
682 | .llseek = orangefs_file_llseek, | |
683 | .read_iter = orangefs_file_read_iter, | |
684 | .write_iter = orangefs_file_write_iter, | |
685 | .lock = orangefs_lock, | |
686 | .unlocked_ioctl = orangefs_ioctl, | |
687 | .mmap = orangefs_file_mmap, | |
5db11c21 | 688 | .open = generic_file_open, |
8bb8aefd YL |
689 | .release = orangefs_file_release, |
690 | .fsync = orangefs_fsync, | |
5db11c21 | 691 | }; |