afs: WriteThroughDSlots: Avoid write error panic
[openafs.git] / src / afs / LINUX / osi_fetchstore.c
1 /*
2  * Copyright (c) 2009 Simon Wilkinson. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR `AS IS'' AND ANY EXPRESS OR
14  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
15  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
16  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
17  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
18  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
19  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
20  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
22  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
23  */
24
25 /* Linux specific store operations
26  *
27  * The idea of these operations is to reduce the number of copies
28  * that data incurs when passing from the disk cache through to the
29  * RX layer, and vice versa.
30  *
31  * In kernels which support it, we use the splice() operation - in
32  * older kernels, the filesystem's sendpage() operation is used directly.
33  * Either way, this means that we can get direct access to the page contents,
34  * rather than getting a copy.
35  */
36
37 #include <afsconfig.h>
38 #include "afs/param.h"
39
40 #include <linux/fs.h>
41 #if 0 && defined(HAVE_LINUX_SPLICE_DIRECT_TO_ACTOR)
42 # include <linux/splice.h>
43 #else
44 # include <linux/pipe_fs_i.h>
45 #endif
46
47 #include "afs/sysincludes.h"
48 #include "afsincludes.h"
49
50 #if 0 && defined(HAVE_LINUX_SPLICE_DIRECT_TO_ACTOR)
51 static int
52 afs_linux_splice_actor(struct pipe_inode_info *pipe,
53                        struct pipe_buffer *buf,
54                        struct splice_desc *sd)
55 {
56     struct rxfs_storeVariables *svar = sd->u.data;
57     size_t size;
58     int code;
59
60     code = buf->ops->confirm(pipe, buf);
61     if (code)
62         return code;
63
64     size = sd->len;
65
66     /* Eventually, this could be rx_WritePage */
67     code = rx_Write(svar->call, kmap(buf->page), size);
68
69     if (code != size)
70         size = -33; /* Can't get a proper rx error out from here */
71
72     kunmap(buf->page);
73
74     return size;
75 }
76
77 static int
78 afs_linux_ds_actor(struct pipe_inode_info *pipe, struct splice_desc *sd)
79 {
80     return __splice_from_pipe(pipe, sd, afs_linux_splice_actor);
81 }
82
83 /* This is a store proc which uses splice to reduce the number
84  * of page copies. */
85 afs_int32
86 afs_linux_storeproc(struct storeOps *ops, void *rock, struct dcache *tdc,
87                     int *shouldwake, afs_size_t *bytesXferred)
88 {
89     struct rxfs_storeVariables *svar = rock;
90     struct file *cacheFp;
91     struct splice_desc sd = {
92         .len    = 0,
93         .total_len = tdc->f.chunkBytes,
94         .pos    = 0,
95         .u.data = rock
96     };
97     int code;
98
99     /* Open the file, splice its contents */
100     AFS_GUNLOCK();
101     cacheFp = afs_linux_raw_open(&tdc->f.inode);
102     code = splice_direct_to_actor(cacheFp, &sd, afs_linux_ds_actor);
103     filp_close(cacheFp, NULL);
104     AFS_GLOCK();
105
106     /* If we're being called from a backing request, then wake up that
107      * request once the file server says its happy. Potentially, we should
108      * do this each time we rx_Write, but that would mean acquiring the
109      * GLOCK in the middle of our actor */
110     if (shouldwake && *shouldwake && ((*ops->status)(rock) == 0)) {
111         *shouldwake = 0;
112         afs_wakeup(svar->vcache);
113     }
114
115     if (code > 0) {
116         *bytesXferred+=code;
117         return 0;
118     }
119
120     return code;
121 }
122
123 # else
124
125 static int
126 afs_linux_read_actor(read_descriptor_t *desc, struct page *page,
127                      unsigned long offset, unsigned long size)
128 {
129 #ifdef READ_DESCRIPTOR_T_HAS_BUF
130     struct rxfs_storeVariables *svar = (void *) desc->buf;
131 #else
132     struct rxfs_storeVariables *svar = desc->arg.data;
133 #endif
134     unsigned long count = desc->count;
135     int code;
136
137     if (size > count)
138         size = count;
139
140     /* Eventually, this could be rx_WritePage */
141     code = rx_Write(svar->call, kmap(page) + offset, size);
142     kunmap(page);
143
144     if (code != size) {
145         return -33; /* Can't get a proper rx error out from here */
146     }
147
148     desc->count = count - size;
149     desc->written += size;
150
151     return size;
152 }
153
154 #if 0
155 afs_int32
156 afs_linux_storeproc(struct storeOps *ops, void *rock, struct dcache *tdc,
157                     int *shouldwake, afs_size_t *bytesXferred)
158 {
159     struct rxfs_storeVariables *svar = rock;
160     struct file *cacheFp;
161     int code;
162     loff_t offset = 0;
163
164     /* Open the file, splice its contents */
165     AFS_GUNLOCK();
166     cacheFp = afs_linux_raw_open(&tdc->f.inode);
167     code = cacheFp->f_op->sendfile(cacheFp, &offset, tdc->f.chunkBytes,
168                                    afs_linux_read_actor, rock);
169     filp_close(cacheFp, NULL);
170     AFS_GLOCK();
171
172     /* If we're being called from a backing request, then wake up that
173      * request once the file server says its happy. Potentially, we should
174      * do this each time we rx_Write, but that would mean acquiring the
175      * GLOCK in the middle of our actor */
176     if (shouldwake && *shouldwake && ((*ops->status)(rock) == 0)) {
177         *shouldwake = 0;
178         afs_wakeup(svar->vcache);
179     }
180
181     if (code > 0) {
182         *bytesXferred+=code;
183         return 0;
184     }
185
186     return code;
187 }
188 #endif
189
190 #endif