4 Unix SMB/Netbios implementation.
6 kernel oplock processing for Linux
7 Copyright (C) Andrew Tridgell 2000
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 #if HAVE_KERNEL_OPLOCKS_LINUX
28 extern int DEBUGLEVEL;
30 static unsigned signals_received;
31 static unsigned signals_processed;
32 static int fd_pending; /* the fd of the current pending SIGIO */
34 /* these can be removed when they are in libc */
35 typedef struct __user_cap_header_struct {
40 typedef struct __user_cap_data_struct {
47 /****************************************************************************
48 handle a SIGIO, incrementing the signals_received and blocking SIGIO
49 ****************************************************************************/
50 static void sigio_handler(int signal, siginfo_t *info, void *unused)
52 fd_pending = info->si_fd;
54 BlockSignals(True, SIGIO);
57 /****************************************************************************
58 try to gain the CAP_LEASE capability
59 ****************************************************************************/
60 static void set_lease_capability(void)
62 cap_user_header_t header;
64 if (capget(header, data) == -1) {
65 DEBUG(3,("Unable to get kernel capabilities\n"));
68 data->effective |= (1<<CAP_LEASE);
69 if (capset(header, data) == -1) {
70 DEBUG(3,("Unable to set CAP_LEASE capability\n"));
75 /****************************************************************************
76 call SETLEASE. If we get EACCES then we try setting up the right capability and
78 ****************************************************************************/
79 static int linux_setlease(int fd, int leasetype)
82 ret = fcntl(fd, F_SETLEASE, leasetype);
83 if (ret == -1 && errno == EACCES) {
84 set_lease_capability();
85 ret = fcntl(fd, F_SETLEASE, leasetype);
92 /****************************************************************************
93 * Deal with the Linux kernel <--> smbd
94 * oplock break protocol.
95 ****************************************************************************/
96 static BOOL linux_oplock_receive_message(fd_set *fds, char *buffer, int buffer_len)
100 SMB_STRUCT_STAT sbuf;
103 if (signals_received == signals_processed) return False;
105 if (sys_fstat(fd_pending,&sbuf) == -1) {
106 DEBUG(0,("Invalid file descriptor %d in kernel oplock break!\n", fd_pending));
114 DEBUG(5,("receive_local_message: kernel oplock break request received for \
115 dev = %x, inode = %.0f\n", (unsigned int)dev, (double)inode ));
118 * Create a kernel oplock break message.
121 /* Setup the message header */
122 SIVAL(buffer,OPBRK_CMD_LEN_OFFSET,KERNEL_OPLOCK_BREAK_MSG_LEN);
123 SSVAL(buffer,OPBRK_CMD_PORT_OFFSET,0);
125 buffer += OPBRK_CMD_HEADER_LEN;
127 SSVAL(buffer,OPBRK_MESSAGE_CMD_OFFSET,KERNEL_OPLOCK_BREAK_CMD);
129 memcpy(buffer + KERNEL_OPLOCK_BREAK_DEV_OFFSET, (char *)&dev, sizeof(dev));
130 memcpy(buffer + KERNEL_OPLOCK_BREAK_INODE_OFFSET, (char *)&inode, sizeof(inode));
133 /* now we can receive more signals */
136 BlockSignals(False, SIGIO);
142 /****************************************************************************
143 Attempt to set an kernel oplock on a file.
144 ****************************************************************************/
145 static BOOL linux_set_kernel_oplock(files_struct *fsp, int oplock_type)
147 if (linux_setlease(fsp->fd, F_WRLCK) == -1) {
148 DEBUG(5,("set_file_oplock: Refused oplock on file %s, fd = %d, dev = %x, \
149 inode = %.0f. (%s)\n",
150 fsp->fsp_name, fsp->fd,
151 (unsigned int)fsp->dev, (double)fsp->inode, strerror(errno)));
155 DEBUG(10,("set_file_oplock: got kernel oplock on file %s, dev = %x, inode = %.0f\n",
156 fsp->fsp_name, (unsigned int)fsp->dev, (double)fsp->inode));
162 /****************************************************************************
163 Release a kernel oplock on a file.
164 ****************************************************************************/
165 static void linux_release_kernel_oplock(files_struct *fsp)
169 * Check and print out the current kernel
170 * oplock state of this file.
172 int state = fcntl(fsp->fd, F_GETLEASE, 0);
173 dbgtext("release_kernel_oplock: file %s, dev = %x, inode = %.0f has kernel \
174 oplock state of %x.\n", fsp->fsp_name, (unsigned int)fsp->dev,
175 (double)fsp->inode, state );
179 * Remove the kernel oplock on this file.
181 if (linux_setlease(fsp->fd, F_UNLCK) == -1) {
183 dbgtext("release_kernel_oplock: Error when removing kernel oplock on file " );
184 dbgtext("%s, dev = %x, inode = %.0f. Error was %s\n",
185 fsp->fsp_name, (unsigned int)fsp->dev,
186 (double)fsp->inode, strerror(errno) );
192 /****************************************************************************
193 parse a kernel oplock message
194 ****************************************************************************/
195 static BOOL linux_kernel_oplock_parse(char *msg_start, int msg_len, SMB_INO_T *inode, SMB_DEV_T *dev)
197 /* Ensure that the msg length is correct. */
198 if (msg_len != KERNEL_OPLOCK_BREAK_MSG_LEN) {
199 DEBUG(0,("process_local_message: incorrect length for KERNEL_OPLOCK_BREAK_CMD (was %d, \
200 should be %d).\n", msg_len, KERNEL_OPLOCK_BREAK_MSG_LEN));
204 memcpy((char *)inode, msg_start+KERNEL_OPLOCK_BREAK_INODE_OFFSET, sizeof(*inode));
205 memcpy((char *)dev, msg_start+KERNEL_OPLOCK_BREAK_DEV_OFFSET, sizeof(*dev));
207 DEBUG(5,("process_local_message: kernel oplock break request for \
208 file dev = %x, inode = %.0f\n", (unsigned int)*dev, (double)*inode));
214 /****************************************************************************
215 see if a oplock message is waiting
216 ****************************************************************************/
217 static BOOL linux_oplock_msg_waiting(fd_set *fds)
219 return signals_processed != signals_received;
223 /****************************************************************************
225 ****************************************************************************/
226 struct kernel_oplocks *linux_init_kernel_oplocks(void)
228 static struct kernel_oplocks koplocks;
229 struct sigaction act;
231 act.sa_handler = NULL;
232 act.sa_sigaction = sigio_handler;
233 act.sa_flags = SA_SIGINFO;
234 if (sigaction(SIGIO, &act, NULL) != 0) {
235 DEBUG(0,("Failed to setup SIGIO handler\n"));
239 koplocks.receive_message = linux_oplock_receive_message;
240 koplocks.set_oplock = linux_set_kernel_oplock;
241 koplocks.release_oplock = linux_release_kernel_oplock;
242 koplocks.parse_message = linux_kernel_oplock_parse;
243 koplocks.msg_waiting = linux_oplock_msg_waiting;
244 koplocks.notification_fd = -1;
252 void oplock_linux_dummy(void) {}
253 #endif /* HAVE_KERNEL_OPLOCKS_LINUX */