source3/smbd/oplock_irix.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    IRIX kernel oplock processing
   4    Copyright (C) Andrew Tridgell 1992-1998
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 2 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; if not, write to the Free Software
  18    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19 */
  20
  21 #include "includes.h"
  22
  23 #if HAVE_KERNEL_OPLOCKS_IRIX
  24
  25 static int oplock_pipe_write = -1;
  26 static int oplock_pipe_read = -1;
  27
  28 /****************************************************************************
  29  Test to see if IRIX kernel oplocks work.
  30 ****************************************************************************/
  31
  32 static BOOL irix_oplocks_available(void)
  33 {
  34         int fd;
  35         int pfd[2];
  36         pstring tmpname;
  37
  38         oplock_set_capability(True, False);
  39
  40         slprintf(tmpname,sizeof(tmpname)-1, "%s/koplock.%d", lp_lockdir(), (int)sys_getpid());
  41
  42         if(pipe(pfd) != 0) {
  43                 DEBUG(0,("check_kernel_oplocks: Unable to create pipe. Error was %s\n",
  44                          strerror(errno) ));
  45                 return False;
  46         }
  47
  48         if((fd = sys_open(tmpname, O_RDWR|O_CREAT|O_EXCL|O_TRUNC, 0600)) < 0) {
  49                 DEBUG(0,("check_kernel_oplocks: Unable to open temp test file %s. Error was %s\n",
  50                          tmpname, strerror(errno) ));
  51                 unlink( tmpname );
  52                 close(pfd[0]);
  53                 close(pfd[1]);
  54                 return False;
  55         }
  56
  57         unlink(tmpname);
  58
  59         if(sys_fcntl_long(fd, F_OPLKREG, pfd[1]) == -1) {
  60                 DEBUG(0,("check_kernel_oplocks: Kernel oplocks are not available on this machine. \
  61 Disabling kernel oplock support.\n" ));
  62                 close(pfd[0]);
  63                 close(pfd[1]);
  64                 close(fd);
  65                 return False;
  66         }
  67
  68         if(sys_fcntl_long(fd, F_OPLKACK, OP_REVOKE) < 0 ) {
  69                 DEBUG(0,("check_kernel_oplocks: Error when removing kernel oplock. Error was %s. \
  70 Disabling kernel oplock support.\n", strerror(errno) ));
  71                 close(pfd[0]);
  72                 close(pfd[1]);
  73                 close(fd);
  74                 return False;
  75         }
  76
  77         close(pfd[0]);
  78         close(pfd[1]);
  79         close(fd);
  80
  81         return True;
  82 }
  83
  84 /****************************************************************************
  85  * Deal with the IRIX kernel <--> smbd
  86  * oplock break protocol.
  87 ****************************************************************************/
  88
  89 static BOOL irix_oplock_receive_message(fd_set *fds, char *buffer, int buffer_len)
  90 {
  91         extern int smb_read_error;
  92         oplock_stat_t os;
  93         char dummy;
  94         files_struct *fsp;
  95
  96         /*
  97          * Read one byte of zero to clear the
  98          * kernel break notify message.
  99          */
 100
 101         if(read(oplock_pipe_read, &dummy, 1) != 1) {
 102                 DEBUG(0,("irix_oplock_receive_message: read of kernel notification failed. \
 103 Error was %s.\n", strerror(errno) ));
 104                 smb_read_error = READ_ERROR;
 105                 return False;
 106         }
 107
 108         /*
 109          * Do a query to get the
 110          * device and inode of the file that has the break
 111          * request outstanding.
 112          */
 113
 114         if(sys_fcntl_ptr(oplock_pipe_read, F_OPLKSTAT, &os) < 0) {
 115                 DEBUG(0,("irix_oplock_receive_message: fcntl of kernel notification failed. \
 116 Error was %s.\n", strerror(errno) ));
 117                 if(errno == EAGAIN) {
 118                         /*
 119                          * Duplicate kernel break message - ignore.
 120                          */
 121                         memset(buffer, '\0', KERNEL_OPLOCK_BREAK_MSG_LEN);
 122                         return True;
 123                 }
 124                 smb_read_error = READ_ERROR;
 125                 return False;
 126         }
 127
 128         /*
 129          * We only have device and inode info here - we have to guess that this
 130          * is the first fsp open with this dev,ino pair.
 131          */
 132
 133         if ((fsp = file_find_di_first((SMB_DEV_T)os.os_dev, (SMB_INO_T)os.os_ino)) == NULL) {
 134                 DEBUG(0,("irix_oplock_receive_message: unable to find open file with dev = %x, inode = %.0f\n",
 135                         (unsigned int)os.os_dev, (double)os.os_ino ));
 136                 return False;
 137         }
 138
 139         DEBUG(5,("irix_oplock_receive_message: kernel oplock break request received for \
 140 dev = %x, inode = %.0f\n, file_id = %ul", (unsigned int)fsp->dev, (double)fsp->inode, fsp->file_id ));
 141
 142         /*
 143          * Create a kernel oplock break message.
 144          */
 145
 146         /* Setup the message header */
 147         SIVAL(buffer,OPBRK_CMD_LEN_OFFSET,KERNEL_OPLOCK_BREAK_MSG_LEN);
 148         SSVAL(buffer,OPBRK_CMD_PORT_OFFSET,0);
 149
 150         buffer += OPBRK_CMD_HEADER_LEN;
 151
 152         SSVAL(buffer,OPBRK_MESSAGE_CMD_OFFSET,KERNEL_OPLOCK_BREAK_CMD);
 153
 154         memcpy(buffer + KERNEL_OPLOCK_BREAK_DEV_OFFSET, (char *)&fsp->dev, sizeof(fsp->dev));
 155         memcpy(buffer + KERNEL_OPLOCK_BREAK_INODE_OFFSET, (char *)&fsp->inode, sizeof(fsp->inode));
 156         memcpy(buffer + KERNEL_OPLOCK_BREAK_FILEID_OFFSET, (char *)&fsp->file_id, sizeof(fsp->file_id));
 157
 158         return True;
 159 }
 160
 161 /****************************************************************************
 162  Attempt to set an kernel oplock on a file.
 163 ****************************************************************************/
 164
 165 static BOOL irix_set_kernel_oplock(files_struct *fsp, int oplock_type)
 166 {
 167         if (sys_fcntl_long(fsp->fd, F_OPLKREG, oplock_pipe_write) == -1) {
 168                 if(errno != EAGAIN) {
 169                         DEBUG(0,("irix_set_kernel_oplock: Unable to get kernel oplock on file %s, dev = %x, \
 170 inode = %.0f, file_id = %ul. Error was %s\n",
 171                                  fsp->fsp_name, (unsigned int)fsp->dev, (double)fsp->inode, fsp->file_id,
 172                                  strerror(errno) ));
 173                 } else {
 174                         DEBUG(5,("irix_set_kernel_oplock: Refused oplock on file %s, fd = %d, dev = %x, \
 175 inode = %.0f, file_id = %ul. Another process had the file open.\n",
 176                                  fsp->fsp_name, fsp->fd, (unsigned int)fsp->dev, (double)fsp->inode, fsp->file_id ));
 177                 }
 178                 return False;
 179         }
 180
 181         DEBUG(10,("irix_set_kernel_oplock: got kernel oplock on file %s, dev = %x, inode = %.0f, file_id = %ul\n",
 182                   fsp->fsp_name, (unsigned int)fsp->dev, (double)fsp->inode, fsp->file_id));
 183
 184         return True;
 185 }
 186
 187 /****************************************************************************
 188  Release a kernel oplock on a file.
 189 ****************************************************************************/
 190
 191 static void irix_release_kernel_oplock(files_struct *fsp)
 192 {
 193         if (DEBUGLVL(10)) {
 194                 /*
 195                  * Check and print out the current kernel
 196                  * oplock state of this file.
 197                  */
 198                 int state = sys_fcntl_long(fsp->fd, F_OPLKACK, -1);
 199                 dbgtext("irix_release_kernel_oplock: file %s, dev = %x, inode = %.0f file_id = %ul, has kernel \
 200 oplock state of %x.\n", fsp->fsp_name, (unsigned int)fsp->dev,
 201                         (double)fsp->inode, fsp->file_id, state );
 202         }
 203
 204         /*
 205          * Remove the kernel oplock on this file.
 206          */
 207         if(sys_fcntl_long(fsp->fd, F_OPLKACK, OP_REVOKE) < 0) {
 208                 if( DEBUGLVL( 0 )) {
 209                         dbgtext("irix_release_kernel_oplock: Error when removing kernel oplock on file " );
 210                         dbgtext("%s, dev = %x, inode = %.0f, file_id = %ul. Error was %s\n",
 211                                 fsp->fsp_name, (unsigned int)fsp->dev,
 212                                 (double)fsp->inode, fsp->file_id, strerror(errno) );
 213                 }
 214         }
 215 }
 216
 217 /****************************************************************************
 218  Parse a kernel oplock message.
 219 ****************************************************************************/
 220
 221 static BOOL irix_kernel_oplock_parse(char *msg_start, int msg_len,
 222                 SMB_INO_T *inode, SMB_DEV_T *dev, unsigned long *file_id)
 223 {
 224         /* Ensure that the msg length is correct. */
 225         if(msg_len != KERNEL_OPLOCK_BREAK_MSG_LEN) {
 226                 DEBUG(0,("incorrect length for KERNEL_OPLOCK_BREAK_CMD (was %d, should be %d).\n",
 227                          msg_len, KERNEL_OPLOCK_BREAK_MSG_LEN));
 228                 return False;
 229         }
 230
 231         memcpy((char *)inode, msg_start+KERNEL_OPLOCK_BREAK_INODE_OFFSET, sizeof(*inode));
 232         memcpy((char *)dev, msg_start+KERNEL_OPLOCK_BREAK_DEV_OFFSET, sizeof(*dev));
 233         memcpy((char *)file_id, msg_start+KERNEL_OPLOCK_BREAK_FILEID_OFFSET, sizeof(*file_id));
 234
 235         DEBUG(5,("kernel oplock break request for file dev = %x, inode = %.0f, file_id = %ul\n",
 236                 (unsigned int)*dev, (double)*inode, *file_id));
 237
 238         return True;
 239 }
 240
 241 /****************************************************************************
 242  Set *maxfd to include oplock read pipe.
 243 ****************************************************************************/
 244
 245 static BOOL irix_oplock_msg_waiting(fd_set *fds)
 246 {
 247         if (oplock_pipe_read == -1)
 248                 return False;
 249
 250         return FD_ISSET(oplock_pipe_read,fds);
 251 }
 252
 253 /****************************************************************************
 254  Setup kernel oplocks.
 255 ****************************************************************************/
 256
 257 struct kernel_oplocks *irix_init_kernel_oplocks(void)
 258 {
 259         int pfd[2];
 260         static struct kernel_oplocks koplocks;
 261
 262         if (!irix_oplocks_available())
 263                 return NULL;
 264
 265         if(pipe(pfd) != 0) {
 266                 DEBUG(0,("setup_kernel_oplock_pipe: Unable to create pipe. Error was %s\n",
 267                          strerror(errno) ));
 268                 return False;
 269         }
 270
 271         oplock_pipe_read = pfd[0];
 272         oplock_pipe_write = pfd[1];
 273
 274         koplocks.receive_message = irix_oplock_receive_message;
 275         koplocks.set_oplock = irix_set_kernel_oplock;
 276         koplocks.release_oplock = irix_release_kernel_oplock;
 277         koplocks.parse_message = irix_kernel_oplock_parse;
 278         koplocks.msg_waiting = irix_oplock_msg_waiting;
 279         koplocks.notification_fd = oplock_pipe_read;
 280
 281         return &koplocks;
 282 }
 283 #else
 284  void oplock_irix_dummy(void) {}
 285 #endif /* HAVE_KERNEL_OPLOCKS_IRIX */