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 */
36 #define F_SETLEASE 1024
40 #define F_GETLEASE 1025
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 a linux capability
59 ****************************************************************************/
60 static void set_capability(unsigned capability)
62 #ifndef _LINUX_CAPABILITY_VERSION
63 #define _LINUX_CAPABILITY_VERSION 0x19980330
65 /* these can be removed when they are in glibc headers */
76 header.version = _LINUX_CAPABILITY_VERSION;
79 if (capget(&header, &data) == -1) {
80 DEBUG(3,("Unable to get kernel capabilities (%s)\n", strerror(errno)));
84 data.effective |= (1<<capability);
86 if (capset(&header, &data) == -1) {
87 DEBUG(3,("Unable to set %d capability (%s)\n",
88 capability, strerror(errno)));
93 /****************************************************************************
94 call SETLEASE. If we get EACCES then we try setting up the right capability and
96 ****************************************************************************/
97 static int linux_setlease(int fd, int leasetype)
100 ret = fcntl(fd, F_SETLEASE, leasetype);
101 if (ret == -1 && errno == EACCES) {
102 set_capability(CAP_LEASE);
103 ret = fcntl(fd, F_SETLEASE, leasetype);
110 /****************************************************************************
111 * Deal with the Linux kernel <--> smbd
112 * oplock break protocol.
113 ****************************************************************************/
114 static BOOL linux_oplock_receive_message(fd_set *fds, char *buffer, int buffer_len)
118 SMB_STRUCT_STAT sbuf;
121 if (signals_received == signals_processed) return False;
123 if (sys_fstat(fd_pending,&sbuf) == -1) {
124 DEBUG(0,("Invalid file descriptor %d in kernel oplock break!\n", fd_pending));
132 DEBUG(5,("receive_local_message: kernel oplock break request received for \
133 dev = %x, inode = %.0f\n", (unsigned int)dev, (double)inode ));
136 * Create a kernel oplock break message.
139 /* Setup the message header */
140 SIVAL(buffer,OPBRK_CMD_LEN_OFFSET,KERNEL_OPLOCK_BREAK_MSG_LEN);
141 SSVAL(buffer,OPBRK_CMD_PORT_OFFSET,0);
143 buffer += OPBRK_CMD_HEADER_LEN;
145 SSVAL(buffer,OPBRK_MESSAGE_CMD_OFFSET,KERNEL_OPLOCK_BREAK_CMD);
147 memcpy(buffer + KERNEL_OPLOCK_BREAK_DEV_OFFSET, (char *)&dev, sizeof(dev));
148 memcpy(buffer + KERNEL_OPLOCK_BREAK_INODE_OFFSET, (char *)&inode, sizeof(inode));
151 /* now we can receive more signals */
154 BlockSignals(False, SIGIO);
160 /****************************************************************************
161 Attempt to set an kernel oplock on a file.
162 ****************************************************************************/
163 static BOOL linux_set_kernel_oplock(files_struct *fsp, int oplock_type)
165 if (linux_setlease(fsp->fd, F_WRLCK) == -1) {
166 DEBUG(5,("set_file_oplock: Refused oplock on file %s, fd = %d, dev = %x, \
167 inode = %.0f. (%s)\n",
168 fsp->fsp_name, fsp->fd,
169 (unsigned int)fsp->dev, (double)fsp->inode, strerror(errno)));
173 DEBUG(10,("set_file_oplock: got kernel oplock on file %s, dev = %x, inode = %.0f\n",
174 fsp->fsp_name, (unsigned int)fsp->dev, (double)fsp->inode));
180 /****************************************************************************
181 Release a kernel oplock on a file.
182 ****************************************************************************/
183 static void linux_release_kernel_oplock(files_struct *fsp)
187 * Check and print out the current kernel
188 * oplock state of this file.
190 int state = fcntl(fsp->fd, F_GETLEASE, 0);
191 dbgtext("release_kernel_oplock: file %s, dev = %x, inode = %.0f has kernel \
192 oplock state of %x.\n", fsp->fsp_name, (unsigned int)fsp->dev,
193 (double)fsp->inode, state );
197 * Remove the kernel oplock on this file.
199 if (linux_setlease(fsp->fd, F_UNLCK) == -1) {
201 dbgtext("release_kernel_oplock: Error when removing kernel oplock on file " );
202 dbgtext("%s, dev = %x, inode = %.0f. Error was %s\n",
203 fsp->fsp_name, (unsigned int)fsp->dev,
204 (double)fsp->inode, strerror(errno) );
210 /****************************************************************************
211 parse a kernel oplock message
212 ****************************************************************************/
213 static BOOL linux_kernel_oplock_parse(char *msg_start, int msg_len, SMB_INO_T *inode, SMB_DEV_T *dev)
215 /* Ensure that the msg length is correct. */
216 if (msg_len != KERNEL_OPLOCK_BREAK_MSG_LEN) {
217 DEBUG(0,("process_local_message: incorrect length for KERNEL_OPLOCK_BREAK_CMD (was %d, \
218 should be %d).\n", msg_len, KERNEL_OPLOCK_BREAK_MSG_LEN));
222 memcpy((char *)inode, msg_start+KERNEL_OPLOCK_BREAK_INODE_OFFSET, sizeof(*inode));
223 memcpy((char *)dev, msg_start+KERNEL_OPLOCK_BREAK_DEV_OFFSET, sizeof(*dev));
225 DEBUG(5,("process_local_message: kernel oplock break request for \
226 file dev = %x, inode = %.0f\n", (unsigned int)*dev, (double)*inode));
232 /****************************************************************************
233 see if a oplock message is waiting
234 ****************************************************************************/
235 static BOOL linux_oplock_msg_waiting(fd_set *fds)
237 return signals_processed != signals_received;
241 /****************************************************************************
243 ****************************************************************************/
244 struct kernel_oplocks *linux_init_kernel_oplocks(void)
246 static struct kernel_oplocks koplocks;
247 struct sigaction act;
249 act.sa_handler = NULL;
250 act.sa_sigaction = sigio_handler;
251 act.sa_flags = SA_SIGINFO;
252 if (sigaction(SIGIO, &act, NULL) != 0) {
253 DEBUG(0,("Failed to setup SIGIO handler\n"));
257 koplocks.receive_message = linux_oplock_receive_message;
258 koplocks.set_oplock = linux_set_kernel_oplock;
259 koplocks.release_oplock = linux_release_kernel_oplock;
260 koplocks.parse_message = linux_kernel_oplock_parse;
261 koplocks.msg_waiting = linux_oplock_msg_waiting;
262 koplocks.notification_fd = -1;
270 void oplock_linux_dummy(void) {}
271 #endif /* HAVE_KERNEL_OPLOCKS_LINUX */