Remove unneeded parameter fd from SMB_VFS_PREAD().
[ira/wip.git] / source3 / modules / vfs_readahead.c
1 /*
2  * Copyright (c) Jeremy Allison 2007.
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 3 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, see <http://www.gnu.org/licenses/>.
16  */
17
18 #include "includes.h"
19
20 struct readahead_data {
21         SMB_OFF_T off_bound;
22         SMB_OFF_T len;
23         bool didmsg;
24 };
25
26 /* 
27  * This module copes with Vista AIO read requests on Linux
28  * by detecting the initial 0x80000 boundary reads and causing
29  * the buffer cache to be filled in advance.
30  */
31
32 /*******************************************************************
33  sendfile wrapper that does readahead/posix_fadvise.
34 *******************************************************************/
35
36 static ssize_t readahead_sendfile(struct vfs_handle_struct *handle,
37                                         int tofd,
38                                         files_struct *fsp,
39                                         int fromfd,
40                                         const DATA_BLOB *header,
41                                         SMB_OFF_T offset,
42                                         size_t count)
43 {
44         struct readahead_data *rhd = (struct readahead_data *)handle->data;
45
46         if ( offset % rhd->off_bound == 0) {
47 #if defined(HAVE_LINUX_READAHEAD)
48                 int err = readahead(fromfd, offset, (size_t)rhd->len);
49                 DEBUG(10,("readahead_sendfile: readahead on fd %u, offset %llu, len %u returned %d\n",
50                         (unsigned int)fromfd,
51                         (unsigned long long)offset,
52                         (unsigned int)rhd->len,
53                         err ));
54 #elif defined(HAVE_POSIX_FADVISE)
55                 int err = posix_fadvise(fromfd, offset, (off_t)rhd->len, POSIX_FADV_WILLNEED);
56                 DEBUG(10,("readahead_sendfile: posix_fadvise on fd %u, offset %llu, len %u returned %d\n",
57                         (unsigned int)fromfd,
58                         (unsigned long long)offset,
59                         (unsigned int)rhd->len,
60                         err ));
61 #else
62                 if (!rhd->didmsg) {
63                         DEBUG(0,("readahead_sendfile: no readahead on this platform\n"));
64                         rhd->didmsg = True;
65                 }
66 #endif
67         }
68         return SMB_VFS_NEXT_SENDFILE(handle,
69                                         tofd,
70                                         fsp,
71                                         fromfd,
72                                         header,
73                                         offset,
74                                         count);
75 }
76
77 /*******************************************************************
78  pread wrapper that does readahead/posix_fadvise.
79 *******************************************************************/
80
81 static ssize_t readahead_pread(vfs_handle_struct *handle,
82                                 files_struct *fsp,
83                                 void *data,
84                                 size_t count,
85                                 SMB_OFF_T offset)
86 {
87         struct readahead_data *rhd = (struct readahead_data *)handle->data;
88
89         if ( offset % rhd->off_bound == 0) {
90 #if defined(HAVE_LINUX_READAHEAD)
91                 int err = readahead(fsp->fh->fd, offset, (size_t)rhd->len);
92                 DEBUG(10,("readahead_pread: readahead on fd %u, offset %llu, len %u returned %d\n",
93                         (unsigned int)fsp->fh->fd,
94                         (unsigned long long)offset,
95                         (unsigned int)rhd->len,
96                         err ));
97 #elif defined(HAVE_POSIX_FADVISE)
98                 int err = posix_fadvise(fsp->fh->fd, offset, (off_t)rhd->len, POSIX_FADV_WILLNEED);
99                 DEBUG(10,("readahead_pread: posix_fadvise on fd %u, offset %llu, len %u returned %d\n",
100                         (unsigned int)fsp->fh->fd,
101                         (unsigned long long)offset,
102                         (unsigned int)rhd->len,
103                         err ));
104 #else
105                 if (!rhd->didmsg) {
106                         DEBUG(0,("readahead_pread: no readahead on this platform\n"));
107                         rhd->didmsg = True;
108                 }
109 #endif
110         }
111         return SMB_VFS_NEXT_PREAD(handle, fsp, data, count, offset);
112 }
113
114 /*******************************************************************
115  Directly called from main smbd when freeing handle.
116 *******************************************************************/
117
118 static void free_readahead_data(void **pptr)
119 {
120         SAFE_FREE(*pptr);
121 }
122
123 /*******************************************************************
124  Allocate the handle specific data so we don't call the expensive
125  conv_str_size function for each sendfile/pread.
126 *******************************************************************/
127
128 static int readahead_connect(struct vfs_handle_struct *handle,
129                                 const char *service,
130                                 const char *user)
131 {
132         struct readahead_data *rhd = SMB_MALLOC_P(struct readahead_data);
133         if (!rhd) {
134                 DEBUG(0,("readahead_connect: out of memory\n"));
135                 return -1;
136         }
137         ZERO_STRUCTP(rhd);
138
139         rhd->didmsg = False;
140         rhd->off_bound = conv_str_size(lp_parm_const_string(SNUM(handle->conn),
141                                                 "readahead",
142                                                 "offset",
143                                                 NULL));
144         if (rhd->off_bound == 0) {
145                 rhd->off_bound = 0x80000;
146         }
147         rhd->len = conv_str_size(lp_parm_const_string(SNUM(handle->conn),
148                                                 "readahead",
149                                                 "length",
150                                                 NULL));
151         if (rhd->len == 0) {
152                 rhd->len = rhd->off_bound;
153         }
154
155         handle->data = (void *)rhd;
156         handle->free_data = free_readahead_data;
157         return SMB_VFS_NEXT_CONNECT(handle, service, user);
158 }
159
160 /*******************************************************************
161  Functions we're replacing.
162  We don't replace read as it isn't used from smbd to read file
163  data.
164 *******************************************************************/
165
166 static vfs_op_tuple readahead_ops [] =
167 {
168         {SMB_VFS_OP(readahead_sendfile), SMB_VFS_OP_SENDFILE, SMB_VFS_LAYER_TRANSPARENT},
169         {SMB_VFS_OP(readahead_pread), SMB_VFS_OP_PREAD, SMB_VFS_LAYER_TRANSPARENT},
170         {SMB_VFS_OP(readahead_connect), SMB_VFS_OP_CONNECT,  SMB_VFS_LAYER_TRANSPARENT},
171         {SMB_VFS_OP(NULL), SMB_VFS_OP_NOOP, SMB_VFS_LAYER_NOOP}
172 };
173
174 /*******************************************************************
175  Module initialization boilerplate.
176 *******************************************************************/
177
178 NTSTATUS vfs_readahead_init(void);
179 NTSTATUS vfs_readahead_init(void)
180 {
181         return smb_register_vfs(SMB_VFS_INTERFACE_VERSION, "readahead", readahead_ops);
182 }