Move from timestamp to gen count file id's for finding oplocked files

in a tdb.
Jeremy.
(This used to be commit 058ae6b58f61ef46013dd076af3a84de5fbaaab1)

5 files changed, 983 insertions, 993 deletions

diff --git a/source3/smbd/files.c b/source3/smbd/files.c
index 8c7fa930e1..3935a12442 100644
--- a/source3/smbd/files.c
+++ b/source3/smbd/files.c
@@ -39,8 +39,22 @@ static files_struct *oplock_save_chain_fsp = NULL;
 static int files_used;
 
 /****************************************************************************
-  find first available file slot
+ Return a unique number identifying this fsp over the life of this pid.
 ****************************************************************************/
+
+static unsigned long get_gen_count(void)
+{
+	static unsigned long file_gen_counter;
+
+	if ((++file_gen_counter) == 0)
+		return ++file_gen_counter;
+	return file_gen_counter;
+}
+
+/****************************************************************************
+ Find first available file slot.
+****************************************************************************/
+
 files_struct *file_new(connection_struct *conn)
 {
 	int i;
@@ -90,6 +104,8 @@ files_struct *file_new(connection_struct *conn)
 	ZERO_STRUCTP(fsp);
 	fsp->fd = -1;
 	fsp->conn = conn;
+	fsp->file_id = get_gen_count();
+	GetTimeOfDay(&fsp->open_time);
 
 	first_file = (i+1) % real_max_open_files;
 
@@ -109,10 +125,10 @@ files_struct *file_new(connection_struct *conn)
 	return fsp;
 }
 
-
 /****************************************************************************
-close all open files for a connection
+ Close all open files for a connection.
 ****************************************************************************/
+
 void file_close_conn(connection_struct *conn)
 {
 	files_struct *fsp, *next;
@@ -126,7 +142,7 @@ void file_close_conn(connection_struct *conn)
 }
 
 /****************************************************************************
-initialise file structures
+ Initialise file structures.
 ****************************************************************************/
 
 #define MAX_OPEN_FUDGEFACTOR 10
@@ -162,10 +178,10 @@ open files, %d are available.\n", request_max_open_files, real_max_open_files));
 	set_pipe_handle_offset(real_max_open_files);
 }
 
-
 /****************************************************************************
-close files open by a specified vuid
+ Close files open by a specified vuid.
 ****************************************************************************/
+
 void file_close_user(int vuid)
 {
 	files_struct *fsp, *next;
@@ -178,13 +194,32 @@ void file_close_user(int vuid)
 	}
 }
 
+/****************************************************************************
+ Find a fsp given a file descriptor.
+****************************************************************************/
+
+files_struct *file_find_fd(int fd)
+{
+	int count=0;
+	files_struct *fsp;
+
+	for (fsp=Files;fsp;fsp=fsp->next,count++) {
+		if (fsp->fd == fd) {
+			if (count > 10) {
+				DLIST_PROMOTE(Files, fsp);
+			}
+			return fsp;
+		}
+	}
+
+	return NULL;
+}
 
 /****************************************************************************
- Find a fsp given a device, inode and timevalue
- If this is from a kernel oplock break request then tval may be NULL.
+ Find a fsp given a device, inode and file_id.
 ****************************************************************************/
 
-files_struct *file_find_dit(SMB_DEV_T dev, SMB_INO_T inode, struct timeval *tval)
+files_struct *file_find_dif(SMB_DEV_T dev, SMB_INO_T inode, unsigned long file_id)
 {
 	int count=0;
 	files_struct *fsp;
@@ -193,8 +228,7 @@ files_struct *file_find_dit(SMB_DEV_T dev, SMB_INO_T inode, struct timeval *tval
 		if (fsp->fd != -1 &&
 		    fsp->dev == dev && 
 		    fsp->inode == inode &&
-		    (tval ? (fsp->open_time.tv_sec == tval->tv_sec) : True ) &&
-		    (tval ? (fsp->open_time.tv_usec == tval->tv_usec) : True )) {
+		    fsp->file_id == file_id ) {
 			if (count > 10) {
 				DLIST_PROMOTE(Files, fsp);
 			}
@@ -258,8 +292,9 @@ files_struct *file_find_di_next(files_struct *start_fsp)
 }
 
 /****************************************************************************
-find a fsp that is open for printing
+ Find a fsp that is open for printing.
 ****************************************************************************/
+
 files_struct *file_find_print(void)
 {
 	files_struct *fsp;
@@ -271,10 +306,10 @@ files_struct *file_find_print(void)
 	return NULL;
 }
 
-
 /****************************************************************************
-sync open files on a connection
+ Sync open files on a connection.
 ****************************************************************************/
+
 void file_sync_all(connection_struct *conn)
 {
 	files_struct *fsp, *next;
@@ -287,10 +322,10 @@ void file_sync_all(connection_struct *conn)
 	}
 }
 
-
 /****************************************************************************
-free up a fsp
+ Free up a fsp.
 ****************************************************************************/
+
 void file_free(files_struct *fsp)
 {
 	DLIST_REMOVE(Files, fsp);
@@ -312,16 +347,17 @@ void file_free(files_struct *fsp)
 	SAFE_FREE(fsp);
 }
 
-
 /****************************************************************************
-get a fsp from a packet given the offset of a 16 bit fnum
+ Get a fsp from a packet given the offset of a 16 bit fnum.
 ****************************************************************************/
+
 files_struct *file_fsp(char *buf, int where)
 {
 	int fnum, count=0;
 	files_struct *fsp;
 
-	if (chain_fsp) return chain_fsp;
+	if (chain_fsp)
+		return chain_fsp;
 
 	fnum = SVAL(buf, where);
 
@@ -338,7 +374,7 @@ files_struct *file_fsp(char *buf, int where)
 }
 
 /****************************************************************************
- Reset the chained fsp - done at the start of a packet reply
+ Reset the chained fsp - done at the start of a packet reply.
 ****************************************************************************/
 
 void file_chain_reset(void)
@@ -358,6 +394,7 @@ void file_chain_save(void)
 /****************************************************************************
 Restore the chained fsp - done after an oplock break.
 ****************************************************************************/
+
 void file_chain_restore(void)
 {
 	chain_fsp = oplock_save_chain_fsp;
diff --git a/source3/smbd/open.c b/source3/smbd/open.c
index 3578a82f8f..325913c3d9 100644
--- a/source3/smbd/open.c
+++ b/source3/smbd/open.c
@@ -181,7 +181,6 @@ static BOOL open_file(files_struct *fsp,connection_struct *conn,
 	fsp->mode = psbuf->st_mode;
 	fsp->inode = psbuf->st_ino;
 	fsp->dev = psbuf->st_dev;
-	GetTimeOfDay(&fsp->open_time);
 	fsp->vuid = current_user.vuid;
 	fsp->size = psbuf->st_size;
 	fsp->pos = -1;
@@ -489,7 +488,7 @@ dev = %x, inode = %.0f\n", *p_oplock_request, share_entry->op_type, fname, (unsi
 				/* Oplock break - unlock to request it. */
 				unlock_share_entry(conn, dev, inode);
 				
-				opb_ret = request_oplock_break(share_entry, dev, inode);
+				opb_ret = request_oplock_break(share_entry);
 				
 				/* Now relock. */
 				lock_share_entry(conn, dev, inode);
@@ -946,11 +945,9 @@ files_struct *open_file_stat(connection_struct *conn, char *fname,
 	 * Setup the files_struct for it.
 	 */
 	
-	fsp->fd = -1;
 	fsp->mode = psbuf->st_mode;
 	fsp->inode = psbuf->st_ino;
 	fsp->dev = psbuf->st_dev;
-	GetTimeOfDay(&fsp->open_time);
 	fsp->size = psbuf->st_size;
 	fsp->vuid = current_user.vuid;
 	fsp->pos = -1;
@@ -1110,11 +1107,9 @@ files_struct *open_directory(connection_struct *conn, char *fname,
 	 * Setup the files_struct for it.
 	 */
 	
-	fsp->fd = -1;
 	fsp->mode = psbuf->st_mode;
 	fsp->inode = psbuf->st_ino;
 	fsp->dev = psbuf->st_dev;
-	GetTimeOfDay(&fsp->open_time);
 	fsp->size = psbuf->st_size;
 	fsp->vuid = current_user.vuid;
 	fsp->pos = -1;
@@ -1230,7 +1225,7 @@ dev = %x, inode = %.0f\n", share_entry->op_type, fname, (unsigned int)dev, (doub
 
             /* Oplock break.... */
             unlock_share_entry(conn, dev, inode);
-            if(request_oplock_break(share_entry, dev, inode) == False)
+            if(request_oplock_break(share_entry) == False)
             {
               DEBUG(0,("check_file_sharing: FAILED when breaking oplock (%x) on file %s, \
 dev = %x, inode = %.0f\n", old_shares[i].op_type, fname, (unsigned int)dev, (double)inode));
diff --git a/source3/smbd/oplock.c b/source3/smbd/oplock.c
index 927719ac1a..9d285d4ae3 100644
--- a/source3/smbd/oplock.c
+++ b/source3/smbd/oplock.c
@@ -1,8 +1,9 @@
 /* 
    Unix SMB/Netbios implementation.
-   Version 1.9.
+   Version 2.2.x
    oplock processing
    Copyright (C) Andrew Tridgell 1992-1998
+   Copyright (C) Jeremy Allison 1998 - 2001
    
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -35,7 +36,7 @@ extern int smb_read_error;
 
 static struct kernel_oplocks *koplocks;
 
-static BOOL oplock_break(SMB_DEV_T dev, SMB_INO_T inode, struct timeval *tval, BOOL local);
+static BOOL oplock_break(SMB_DEV_T dev, SMB_INO_T inode, unsigned long file_id, BOOL local);
 
 /****************************************************************************
  Get the number of current exclusive oplocks.
@@ -74,97 +75,97 @@ BOOL oplock_message_waiting(fd_set *fds)
 
 BOOL receive_local_message(fd_set *fds, char *buffer, int buffer_len, int timeout)
 {
-  struct sockaddr_in from;
-  int fromlen = sizeof(from);
-  int32 msg_len = 0;
-
-  smb_read_error = 0;
-
-  if(timeout != 0) {
-	  struct timeval to;
-	  int selrtn;
-	  int maxfd = oplock_sock;
-
-	  if (koplocks && koplocks->notification_fd != -1) {
-		  FD_SET(koplocks->notification_fd, fds);
-		  maxfd = MAX(maxfd, koplocks->notification_fd);
-	  }
-
-	  to.tv_sec = timeout / 1000;
-	  to.tv_usec = (timeout % 1000) * 1000;
-
-	  selrtn = sys_select(maxfd+1,fds,&to);
-
-	  if (selrtn == -1 && errno == EINTR) {
-		  /* could be a kernel oplock interrupt */
-		  if (koplocks && koplocks->msg_waiting(fds)) {
-			  return koplocks->receive_message(fds, buffer, buffer_len);
-		  }
-	  }
-
-	  /* Check if error */
-	  if(selrtn == -1) {
-		  /* something is wrong. Maybe the socket is dead? */
-		  smb_read_error = READ_ERROR;
-		  return False;
-	  }
-
-	  /* Did we timeout ? */
-	  if (selrtn == 0) {
-		  smb_read_error = READ_TIMEOUT;
-		  return False;
-	  }
-  }
-
-  if (koplocks && koplocks->msg_waiting(fds)) {
-	  return koplocks->receive_message(fds, buffer, buffer_len);
-  }
-
-  if (!FD_ISSET(oplock_sock, fds)) return False;
-
-  /*
-   * From here down we deal with the smbd <--> smbd
-   * oplock break protocol only.
-   */
-
-  /*
-   * Read a loopback udp message.
-   */
-  msg_len = recvfrom(oplock_sock, &buffer[OPBRK_CMD_HEADER_LEN],
-                     buffer_len - OPBRK_CMD_HEADER_LEN, 0,
-                     (struct sockaddr *)&from, &fromlen);
-
-  if(msg_len < 0) {
-    DEBUG(0,("receive_local_message. Error in recvfrom. (%s).\n",strerror(errno)));
-    return False;
-  }
-
-  /* Validate message length. */
-  if(msg_len > (buffer_len - OPBRK_CMD_HEADER_LEN)) {
-    DEBUG(0,("receive_local_message: invalid msg_len (%d) max can be %d\n",
-              msg_len,
-              buffer_len  - OPBRK_CMD_HEADER_LEN));
-    return False;
-  }
-
-  /* Validate message from address (must be localhost). */
-  if(from.sin_addr.s_addr != htonl(INADDR_LOOPBACK)) {
-    DEBUG(0,("receive_local_message: invalid 'from' address \
-(was %lx should be 127.0.0.1\n", (long)from.sin_addr.s_addr));
-   return False;
-  }
-
-  /* Setup the message header */
-  SIVAL(buffer,OPBRK_CMD_LEN_OFFSET,msg_len);
-  SSVAL(buffer,OPBRK_CMD_PORT_OFFSET,ntohs(from.sin_port));
-
-  return True;
+	struct sockaddr_in from;
+	int fromlen = sizeof(from);
+	int32 msg_len = 0;
+
+	smb_read_error = 0;
+
+	if(timeout != 0) {
+		struct timeval to;
+		int selrtn;
+		int maxfd = oplock_sock;
+
+		if (koplocks && koplocks->notification_fd != -1) {
+			FD_SET(koplocks->notification_fd, fds);
+			maxfd = MAX(maxfd, koplocks->notification_fd);
+		}
+
+		to.tv_sec = timeout / 1000;
+		to.tv_usec = (timeout % 1000) * 1000;
+
+		selrtn = sys_select(maxfd+1,fds,&to);
+
+		if (selrtn == -1 && errno == EINTR) {
+			/* could be a kernel oplock interrupt */
+			if (koplocks && koplocks->msg_waiting(fds)) {
+				return koplocks->receive_message(fds, buffer, buffer_len);
+			}
+		}
+
+		/* Check if error */
+		if(selrtn == -1) {
+			/* something is wrong. Maybe the socket is dead? */
+			smb_read_error = READ_ERROR;
+			return False;
+		}
+
+		/* Did we timeout ? */
+		if (selrtn == 0) {
+			smb_read_error = READ_TIMEOUT;
+			return False;
+		}
+	}
+
+	if (koplocks && koplocks->msg_waiting(fds)) {
+		return koplocks->receive_message(fds, buffer, buffer_len);
+	}
+
+	if (!FD_ISSET(oplock_sock, fds))
+		return False;
+
+	/*
+	 * From here down we deal with the smbd <--> smbd
+	 * oplock break protocol only.
+	 */
+
+	/*
+	 * Read a loopback udp message.
+	 */
+	msg_len = recvfrom(oplock_sock, &buffer[OPBRK_CMD_HEADER_LEN],
+						buffer_len - OPBRK_CMD_HEADER_LEN, 0, (struct sockaddr *)&from, &fromlen);
+
+	if(msg_len < 0) {
+		DEBUG(0,("receive_local_message. Error in recvfrom. (%s).\n",strerror(errno)));
+		return False;
+	}
+
+	/* Validate message length. */
+	if(msg_len > (buffer_len - OPBRK_CMD_HEADER_LEN)) {
+		DEBUG(0,("receive_local_message: invalid msg_len (%d) max can be %d\n", msg_len,
+			buffer_len  - OPBRK_CMD_HEADER_LEN));
+		return False;
+	}
+
+	/* Validate message from address (must be localhost). */
+	if(from.sin_addr.s_addr != htonl(INADDR_LOOPBACK)) {
+		DEBUG(0,("receive_local_message: invalid 'from' address \
+(was %lx should be 127.0.0.1)\n", (long)from.sin_addr.s_addr));
+		return False;
+	}
+
+	/* Setup the message header */
+	SIVAL(buffer,OPBRK_CMD_LEN_OFFSET,msg_len);
+	SSVAL(buffer,OPBRK_CMD_PORT_OFFSET,ntohs(from.sin_port));
+
+	return True;
 }
 
 /****************************************************************************
  Attempt to set an oplock on a file. Always succeeds if kernel oplocks are
  disabled (just sets flags). Returns True if oplock set.
 ****************************************************************************/
+
 BOOL set_file_oplock(files_struct *fsp, int oplock_type)
 {
 	if (koplocks && !koplocks->set_oplock(fsp, oplock_type))
@@ -177,8 +178,9 @@ BOOL set_file_oplock(files_struct *fsp, int oplock_type)
 	else
 		exclusive_oplocks_open++;
 
-	DEBUG(5,("set_file_oplock: granted oplock on file %s, dev = %x, inode = %.0f, tv_sec = %x, tv_usec = %x\n",
-		 fsp->fsp_name, (unsigned int)fsp->dev, (double)fsp->inode,
+	DEBUG(5,("set_file_oplock: granted oplock on file %s, dev = %x, inode = %.0f, file_id = %lu, \
+tv_sec = %x, tv_usec = %x\n",
+		 fsp->fsp_name, (unsigned int)fsp->dev, (double)fsp->inode, fsp->file_id,
 		 (int)fsp->open_time.tv_sec, (int)fsp->open_time.tv_usec ));
 
 	return True;
@@ -190,7 +192,8 @@ BOOL set_file_oplock(files_struct *fsp, int oplock_type)
 
 void release_file_oplock(files_struct *fsp)
 {
-	if (koplocks) koplocks->release_oplock(fsp);
+	if (koplocks)
+		koplocks->release_oplock(fsp);
 
 	if (fsp->oplock_type == LEVEL_II_OPLOCK)
 		level_II_oplocks_open--;
@@ -209,7 +212,8 @@ void release_file_oplock(files_struct *fsp)
 
 static void downgrade_file_oplock(files_struct *fsp)
 {
-	if (koplocks) koplocks->release_oplock(fsp);
+	if (koplocks)
+		koplocks->release_oplock(fsp);
 	fsp->oplock_type = LEVEL_II_OPLOCK;
 	exclusive_oplocks_open--;
 	level_II_oplocks_open++;
@@ -291,161 +295,142 @@ int setup_oplock_select_set( fd_set *fds)
  Process an oplock break message - whether it came from the UDP socket
  or from the kernel.
 ****************************************************************************/
+
 BOOL process_local_message(char *buffer, int buf_size)
 {
-  int32 msg_len;
-  uint16 from_port;
-  char *msg_start;
-  SMB_DEV_T dev;
-  SMB_INO_T inode;
-  pid_t remotepid;
-  struct timeval tval;
-  struct timeval *ptval = NULL;
-  uint16 break_cmd_type;
-
-  msg_len = IVAL(buffer,OPBRK_CMD_LEN_OFFSET);
-  from_port = SVAL(buffer,OPBRK_CMD_PORT_OFFSET);
-
-  msg_start = &buffer[OPBRK_CMD_HEADER_LEN];
-
-  DEBUG(5,("process_local_message: Got a message of length %d from port (%d)\n", 
-            msg_len, from_port));
-
-  /* 
-   * Pull the info out of the requesting packet.
-   */
-
-  break_cmd_type = SVAL(msg_start,OPBRK_MESSAGE_CMD_OFFSET);
-
-  switch(break_cmd_type)
-  {
-    case KERNEL_OPLOCK_BREAK_CMD:
-	    if (!koplocks) {
-		    DEBUG(0,("unexpected kernel oplock break!\n"));
-		    break;
-	    } 
-	    if (!koplocks->parse_message(msg_start, msg_len, &inode, &dev)) {
-		    DEBUG(0,("kernel oplock break parse failure!\n"));
-	    }
-	    break;
-
-    case OPLOCK_BREAK_CMD:
-    case LEVEL_II_OPLOCK_BREAK_CMD:
-
-      /* Ensure that the msg length is correct. */
-      if(msg_len != OPLOCK_BREAK_MSG_LEN)
-      {
-        DEBUG(0,("process_local_message: incorrect length for OPLOCK_BREAK_CMD (was %d, should be %d).\n",
-              (int)msg_len, (int)OPLOCK_BREAK_MSG_LEN));
-        return False;
-      }
-      {
-        long usec;
-        time_t sec;
-
-        memcpy((char *)&inode, msg_start+OPLOCK_BREAK_INODE_OFFSET,sizeof(inode));
-        memcpy((char *)&dev, msg_start+OPLOCK_BREAK_DEV_OFFSET,sizeof(dev));
-        memcpy((char *)&sec, msg_start+OPLOCK_BREAK_SEC_OFFSET,sizeof(sec));
-        tval.tv_sec = sec;
-        memcpy((char *)&usec, msg_start+OPLOCK_BREAK_USEC_OFFSET, sizeof(usec));
-        tval.tv_usec = usec;
-
-        ptval = &tval;
-
-        memcpy((char *)&remotepid, msg_start+OPLOCK_BREAK_PID_OFFSET,sizeof(remotepid));
-
-        DEBUG(5,("process_local_message: (%s) oplock break request from \
-pid %d, port %d, dev = %x, inode = %.0f\n",
-             (break_cmd_type == OPLOCK_BREAK_CMD) ? "exclusive" : "level II",
-             (int)remotepid, from_port, (unsigned int)dev, (double)inode));
-      }
-      break;
-
-    /* 
-     * Keep this as a debug case - eventually we can remove it.
-     */
-    case 0x8001:
-      DEBUG(0,("process_local_message: Received unsolicited break \
+	int32 msg_len;
+	uint16 from_port;
+	char *msg_start;
+	pid_t remotepid;
+	SMB_DEV_T dev;
+	SMB_INO_T inode;
+	unsigned long file_id;
+	uint16 break_cmd_type;
+
+	msg_len = IVAL(buffer,OPBRK_CMD_LEN_OFFSET);
+	from_port = SVAL(buffer,OPBRK_CMD_PORT_OFFSET);
+
+	msg_start = &buffer[OPBRK_CMD_HEADER_LEN];
+
+	DEBUG(5,("process_local_message: Got a message of length %d from port (%d)\n", 
+		msg_len, from_port));
+
+	/* 
+	 * Pull the info out of the requesting packet.
+	 */
+
+	break_cmd_type = SVAL(msg_start,OPBRK_MESSAGE_CMD_OFFSET);
+
+	switch(break_cmd_type) {
+		case KERNEL_OPLOCK_BREAK_CMD:
+			if (!koplocks) {
+				DEBUG(0,("unexpected kernel oplock break!\n"));
+				break;
+			} 
+			if (!koplocks->parse_message(msg_start, msg_len, &inode, &dev, &file_id)) {
+				DEBUG(0,("kernel oplock break parse failure!\n"));
+			}
+			break;
+
+		case OPLOCK_BREAK_CMD:
+		case LEVEL_II_OPLOCK_BREAK_CMD:
+
+			/* Ensure that the msg length is correct. */
+			if(msg_len != OPLOCK_BREAK_MSG_LEN) {
+				DEBUG(0,("process_local_message: incorrect length for OPLOCK_BREAK_CMD (was %d, should be %d).\n",
+					(int)msg_len, (int)OPLOCK_BREAK_MSG_LEN));
+				return False;
+			}
+
+			memcpy((char *)&remotepid, msg_start+OPLOCK_BREAK_PID_OFFSET,sizeof(remotepid));
+			memcpy((char *)&inode, msg_start+OPLOCK_BREAK_INODE_OFFSET,sizeof(inode));
+			memcpy((char *)&dev, msg_start+OPLOCK_BREAK_DEV_OFFSET,sizeof(dev));
+			memcpy((char *)&file_id, msg_start+OPLOCK_BREAK_FILEID_OFFSET,sizeof(file_id));
+
+			DEBUG(5,("process_local_message: (%s) oplock break request from \
+pid %d, port %d, dev = %x, inode = %.0f, file_id = %lu\n",
+				(break_cmd_type == OPLOCK_BREAK_CMD) ? "exclusive" : "level II",
+				(int)remotepid, from_port, (unsigned int)dev, (double)inode, file_id));
+			break;
+
+		/* 
+		 * Keep this as a debug case - eventually we can remove it.
+		 */
+		case 0x8001:
+			DEBUG(0,("process_local_message: Received unsolicited break \
 reply - dumping info.\n"));
 
-      if(msg_len != OPLOCK_BREAK_MSG_LEN)
-      {
-        DEBUG(0,("process_local_message: ubr: incorrect length for reply \
+			if(msg_len != OPLOCK_BREAK_MSG_LEN) {
+				DEBUG(0,("process_local_message: ubr: incorrect length for reply \
 (was %d, should be %d).\n", (int)msg_len, (int)OPLOCK_BREAK_MSG_LEN));
-        return False;
-      }
-
-      {
-        memcpy((char *)&inode, msg_start+OPLOCK_BREAK_INODE_OFFSET,sizeof(inode));
-        memcpy((char *)&remotepid, msg_start+OPLOCK_BREAK_PID_OFFSET,sizeof(remotepid));
-        memcpy((char *)&dev, msg_start+OPLOCK_BREAK_DEV_OFFSET,sizeof(dev));
-
-        DEBUG(0,("process_local_message: unsolicited oplock break reply from \
-pid %d, port %d, dev = %x, inode = %.0f\n", (int)remotepid, from_port, (unsigned int)dev, (double)inode));
-
-       }
-       return False;
-
-    default:
-      DEBUG(0,("process_local_message: unknown UDP message command code (%x) - ignoring.\n",
-                (unsigned int)SVAL(msg_start,0)));
-      return False;
-  }
-
-  /*
-   * Now actually process the break request.
-   */
-
-  if((exclusive_oplocks_open + level_II_oplocks_open) != 0)
-  {
-    if (oplock_break(dev, inode, ptval, False) == False)
-    {
-      DEBUG(0,("process_local_message: oplock break failed.\n"));
-      return False;
-    }
-  }
-  else
-  {
-    /*
-     * If we have no record of any currently open oplocks,
-     * it's not an error, as a close command may have
-     * just been issued on the file that was oplocked.
-     * Just log a message and return success in this case.
-     */
-    DEBUG(3,("process_local_message: oplock break requested with no outstanding \
+				return False;
+			}
+
+			memcpy((char *)&inode, msg_start+OPLOCK_BREAK_INODE_OFFSET,sizeof(inode));
+			memcpy((char *)&remotepid, msg_start+OPLOCK_BREAK_PID_OFFSET,sizeof(remotepid));
+			memcpy((char *)&dev, msg_start+OPLOCK_BREAK_DEV_OFFSET,sizeof(dev));
+			memcpy((char *)&file_id, msg_start+OPLOCK_BREAK_FILEID_OFFSET,sizeof(file_id));
+
+			DEBUG(0,("process_local_message: unsolicited oplock break reply from \
+pid %d, port %d, dev = %x, inode = %.0f, file_id = %lu\n",
+				(int)remotepid, from_port, (unsigned int)dev, (double)inode, file_id));
+
+			return False;
+
+		default:
+			DEBUG(0,("process_local_message: unknown UDP message command code (%x) - ignoring.\n",
+				(unsigned int)SVAL(msg_start,0)));
+			return False;
+	}
+
+	/*
+	 * Now actually process the break request.
+	 */
+
+	if((exclusive_oplocks_open + level_II_oplocks_open) != 0) {
+		if (oplock_break(dev, inode, file_id, False) == False) {
+			DEBUG(0,("process_local_message: oplock break failed.\n"));
+			return False;
+		}
+	} else {
+		/*
+		 * If we have no record of any currently open oplocks,
+		 * it's not an error, as a close command may have
+		 * just been issued on the file that was oplocked.
+		 * Just log a message and return success in this case.
+		 */
+		DEBUG(3,("process_local_message: oplock break requested with no outstanding \
 oplocks. Returning success.\n"));
-  }
-
-  /* 
-   * Do the appropriate reply - none in the kernel or level II case.
-   */
-
-  if(SVAL(msg_start,OPBRK_MESSAGE_CMD_OFFSET) == OPLOCK_BREAK_CMD)
-  {
-    struct sockaddr_in toaddr;
-
-    /* Send the message back after OR'ing in the 'REPLY' bit. */
-    SSVAL(msg_start,OPBRK_MESSAGE_CMD_OFFSET,OPLOCK_BREAK_CMD | CMD_REPLY);
-
-    memset((char *)&toaddr,'\0',sizeof(toaddr));
-    toaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
-    toaddr.sin_port = htons(from_port);
-    toaddr.sin_family = AF_INET;
-
-    if(sendto( oplock_sock, msg_start, OPLOCK_BREAK_MSG_LEN, 0,
-            (struct sockaddr *)&toaddr, sizeof(toaddr)) < 0) 
-    {
-      DEBUG(0,("process_local_message: sendto process %d failed. Errno was %s\n",
-                (int)remotepid, strerror(errno)));
-      return False;
-    }
-
-    DEBUG(5,("process_local_message: oplock break reply sent to \
-pid %d, port %d, for file dev = %x, inode = %.0f\n",
-          (int)remotepid, from_port, (unsigned int)dev, (double)inode));
-  }
-
-  return True;
+	}
+
+	/* 
+	 * Do the appropriate reply - none in the kernel or level II case.
+	 */
+
+	if(SVAL(msg_start,OPBRK_MESSAGE_CMD_OFFSET) == OPLOCK_BREAK_CMD) {
+		struct sockaddr_in toaddr;
+
+		/* Send the message back after OR'ing in the 'REPLY' bit. */
+		SSVAL(msg_start,OPBRK_MESSAGE_CMD_OFFSET,OPLOCK_BREAK_CMD | CMD_REPLY);
+
+		memset((char *)&toaddr,'\0',sizeof(toaddr));
+		toaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+		toaddr.sin_port = htons(from_port);
+		toaddr.sin_family = AF_INET;
+
+		if(sendto( oplock_sock, msg_start, OPLOCK_BREAK_MSG_LEN, 0,
+				(struct sockaddr *)&toaddr, sizeof(toaddr)) < 0) {
+			DEBUG(0,("process_local_message: sendto process %d failed. Errno was %s\n",
+				(int)remotepid, strerror(errno)));
+			return False;
+		}
+
+		DEBUG(5,("process_local_message: oplock break reply sent to \
+pid %d, port %d, for file dev = %x, inode = %.0f, file_id = %lu\n",
+			(int)remotepid, from_port, (unsigned int)dev, (double)inode, file_id));
+	}
+
+	return True;
 }
 
 /****************************************************************************
@@ -474,81 +459,82 @@ static void prepare_break_message(char *outbuf, files_struct *fsp, BOOL level2)
 
 static void wait_before_sending_break(BOOL local_request)
 {
-  extern struct timeval smb_last_time;
+	extern struct timeval smb_last_time;
 
-  if(local_request) {
-    struct timeval cur_tv;
-    long wait_left = (long)lp_oplock_break_wait_time();
+	if(local_request) {
+		struct timeval cur_tv;
+		long wait_left = (long)lp_oplock_break_wait_time();
 
-	if (wait_left == 0)
-		return;
+		if (wait_left == 0)
+			return;
 
-    GetTimeOfDay(&cur_tv);
+		GetTimeOfDay(&cur_tv);
 
-    wait_left -= ((cur_tv.tv_sec - smb_last_time.tv_sec)*1000) +
+		wait_left -= ((cur_tv.tv_sec - smb_last_time.tv_sec)*1000) +
                 ((cur_tv.tv_usec - smb_last_time.tv_usec)/1000);
 
-    if(wait_left > 0) {
-      wait_left = MIN(wait_left, 1000);
-      sys_usleep(wait_left * 1000);
-    }
-  }
+		if(wait_left > 0) {
+			wait_left = MIN(wait_left, 1000);
+			sys_usleep(wait_left * 1000);
+		}
+	}
 }
 
 /****************************************************************************
  Ensure that we have a valid oplock.
 ****************************************************************************/
-static files_struct *initial_break_processing(SMB_DEV_T dev, SMB_INO_T inode, struct timeval *tval)
+
+static files_struct *initial_break_processing(SMB_DEV_T dev, SMB_INO_T inode, unsigned long file_id)
 {
-  files_struct *fsp = NULL;
-
-  if( DEBUGLVL( 3 ) )
-  {
-    dbgtext( "initial_break_processing: called for dev = %x, inode = %.0f tv_sec = %x, tv_usec = %x.\n",
-      (unsigned int)dev, (double)inode, tval ? (int)tval->tv_sec : 0,
-      tval ? (int)tval->tv_usec : 0);
-    dbgtext( "Current oplocks_open (exclusive = %d, levelII = %d)\n",
-              exclusive_oplocks_open, level_II_oplocks_open );
-  }
-
-  /* We need to search the file open table for the
-     entry containing this dev and inode, and ensure
-     we have an oplock on it. */
-  fsp = file_find_dit(dev, inode, tval);
-
-  if(fsp == NULL)
-  {
-    /* The file could have been closed in the meantime - return success. */
-    if( DEBUGLVL( 3 ) )
-    {
-      dbgtext( "initial_break_processing: cannot find open file with " );
-      dbgtext( "dev = %x, inode = %.0f ", (unsigned int)dev, (double)inode);
-      dbgtext( "allowing break to succeed.\n" );
-    }
-    return NULL;
-  }
-
-  /* Ensure we have an oplock on the file */
-
-  /* There is a potential race condition in that an oplock could
-     have been broken due to another udp request, and yet there are
-     still oplock break messages being sent in the udp message
-     queue for this file. So return true if we don't have an oplock,
-     as we may have just freed it.
-   */
-
-  if(fsp->oplock_type == NO_OPLOCK)
-  {
-    if( DEBUGLVL( 3 ) )
-    {
-      dbgtext( "initial_break_processing: file %s ", fsp->fsp_name );
-      dbgtext( "(dev = %x, inode = %.0f) has no oplock.\n", (unsigned int)dev, (double)inode );
-      dbgtext( "Allowing break to succeed regardless.\n" );
-    }
-    return NULL;
-  }
-
-  return fsp;
+	files_struct *fsp = NULL;
+
+	if( DEBUGLVL( 3 ) ) {
+		dbgtext( "initial_break_processing: called for dev = %x, inode = %.0f file_id = %lu\n",
+			(unsigned int)dev, (double)inode, file_id);
+		dbgtext( "Current oplocks_open (exclusive = %d, levelII = %d)\n",
+			exclusive_oplocks_open, level_II_oplocks_open );
+	}
+
+	/*
+	 * We need to search the file open table for the
+	 * entry containing this dev and inode, and ensure
+	 * we have an oplock on it.
+	 */
+
+	fsp = file_find_dif(dev, inode, file_id);
+
+	if(fsp == NULL) {
+		/* The file could have been closed in the meantime - return success. */
+		if( DEBUGLVL( 3 ) ) {
+			dbgtext( "initial_break_processing: cannot find open file with " );
+			dbgtext( "dev = %x, inode = %.0f file_id = %lu", (unsigned int)dev,
+				(double)inode, file_id);
+			dbgtext( "allowing break to succeed.\n" );
+		}
+		return NULL;
+	}
+
+	/* Ensure we have an oplock on the file */
+
+	/*
+	 * There is a potential race condition in that an oplock could
+	 * have been broken due to another udp request, and yet there are
+	 * still oplock break messages being sent in the udp message
+	 * queue for this file. So return true if we don't have an oplock,
+	 * as we may have just freed it.
+	 */
+
+	if(fsp->oplock_type == NO_OPLOCK) {
+		if( DEBUGLVL( 3 ) ) {
+			dbgtext( "initial_break_processing: file %s ", fsp->fsp_name );
+			dbgtext( "(dev = %x, inode = %.0f, file_id = %lu) has no oplock.\n",
+				(unsigned int)dev, (double)inode, fsp->file_id );
+			dbgtext( "Allowing break to succeed regardless.\n" );
+		}
+		return NULL;
+	}
+
+	return fsp;
 }
 
 /****************************************************************************
@@ -557,335 +543,322 @@ static files_struct *initial_break_processing(SMB_DEV_T dev, SMB_INO_T inode, st
 
 BOOL oplock_break_level2(files_struct *fsp, BOOL local_request, int token)
 {
-  extern uint32 global_client_caps;
-  char outbuf[128];
-  BOOL got_lock = False;
-  SMB_DEV_T dev = fsp->dev;
-  SMB_INO_T inode = fsp->inode;
-
-  /*
-   * We can have a level II oplock even if the client is not
-   * level II oplock aware. In this case just remove the
-   * flags and don't send the break-to-none message to
-   * the client.
-   */
-
-  if (global_client_caps & CAP_LEVEL_II_OPLOCKS) {
-    /*
-     * If we are sending an oplock break due to an SMB sent
-     * by our own client we ensure that we wait at leat
-     * lp_oplock_break_wait_time() milliseconds before sending
-     * the packet. Sending the packet sooner can break Win9x
-     * and has reported to cause problems on NT. JRA.
-     */
-
-    wait_before_sending_break(local_request);
-
-    /* Prepare the SMBlockingX message. */
-
-    prepare_break_message( outbuf, fsp, False);
-    if (!send_smb(smbd_server_fd(), outbuf))
-		exit_server("oplock_break_level2: send_smb failed.\n");
-  }
-
-  /*
-   * Now we must update the shared memory structure to tell
-   * everyone else we no longer have a level II oplock on 
-   * this open file. If local_request is true then token is
-   * the existing lock on the shared memory area.
-   */
-
-  if(!local_request && lock_share_entry_fsp(fsp) == False) {
-      DEBUG(0,("oplock_break_level2: unable to lock share entry for file %s\n", fsp->fsp_name ));
-  } else {
-    got_lock = True;
-  }
-
-  if(remove_share_oplock(fsp)==False) {
-    DEBUG(0,("oplock_break_level2: unable to remove level II oplock for file %s\n", fsp->fsp_name ));
-  }
-
-  if (!local_request && got_lock)
-    unlock_share_entry_fsp(fsp);
-
-  fsp->oplock_type = NO_OPLOCK;
-  level_II_oplocks_open--;
-
-  if(level_II_oplocks_open < 0)
-  {
-    DEBUG(0,("oplock_break_level2: level_II_oplocks_open < 0 (%d). PANIC ERROR\n",
-              level_II_oplocks_open));
-    abort();
-  }
-
-  if( DEBUGLVL( 3 ) )
-  {
-    dbgtext( "oplock_break_level2: returning success for " );
-    dbgtext( "dev = %x, inode = %.0f\n", (unsigned int)dev, (double)inode );
-    dbgtext( "Current level II oplocks_open = %d\n", level_II_oplocks_open );
-  }
-
-  return True;
+	extern uint32 global_client_caps;
+	char outbuf[128];
+	BOOL got_lock = False;
+	SMB_DEV_T dev = fsp->dev;
+	SMB_INO_T inode = fsp->inode;
+
+	/*
+	 * We can have a level II oplock even if the client is not
+	 * level II oplock aware. In this case just remove the
+	 * flags and don't send the break-to-none message to
+	 * the client.
+	 */
+
+	if (global_client_caps & CAP_LEVEL_II_OPLOCKS) {
+		/*
+		 * If we are sending an oplock break due to an SMB sent
+		 * by our own client we ensure that we wait at leat
+		 * lp_oplock_break_wait_time() milliseconds before sending
+		 * the packet. Sending the packet sooner can break Win9x
+		 * and has reported to cause problems on NT. JRA.
+		 */
+
+		wait_before_sending_break(local_request);
+
+		/* Prepare the SMBlockingX message. */
+
+		prepare_break_message( outbuf, fsp, False);
+		if (!send_smb(smbd_server_fd(), outbuf))
+			exit_server("oplock_break_level2: send_smb failed.\n");
+	}
+
+	/*
+	 * Now we must update the shared memory structure to tell
+	 * everyone else we no longer have a level II oplock on 
+	 * this open file. If local_request is true then token is
+	 * the existing lock on the shared memory area.
+	 */
+
+	if(!local_request && lock_share_entry_fsp(fsp) == False) {
+		DEBUG(0,("oplock_break_level2: unable to lock share entry for file %s\n", fsp->fsp_name ));
+	} else {
+		got_lock = True;
+	}
+
+	if(remove_share_oplock(fsp)==False) {
+		DEBUG(0,("oplock_break_level2: unable to remove level II oplock for file %s\n", fsp->fsp_name ));
+	}
+
+	if (!local_request && got_lock)
+		unlock_share_entry_fsp(fsp);
+
+	fsp->oplock_type = NO_OPLOCK;
+	level_II_oplocks_open--;
+
+	if(level_II_oplocks_open < 0) {
+		DEBUG(0,("oplock_break_level2: level_II_oplocks_open < 0 (%d). PANIC ERROR\n",
+			level_II_oplocks_open));
+		abort();
+	}
+
+	if( DEBUGLVL( 3 ) ) {
+		dbgtext( "oplock_break_level2: returning success for " );
+		dbgtext( "dev = %x, inode = %.0f, file_id = %lu\n", (unsigned int)dev, (double)inode, fsp->file_id );
+		dbgtext( "Current level II oplocks_open = %d\n", level_II_oplocks_open );
+	}
+
+	return True;
 }
 
 /****************************************************************************
  Process an oplock break directly.
 ****************************************************************************/
 
-static BOOL oplock_break(SMB_DEV_T dev, SMB_INO_T inode, struct timeval *tval, BOOL local_request)
+static BOOL oplock_break(SMB_DEV_T dev, SMB_INO_T inode, unsigned long file_id, BOOL local_request)
 {
-  extern uint32 global_client_caps;
-  extern struct current_user current_user;
-  char *inbuf = NULL;
-  char *outbuf = NULL;
-  files_struct *fsp = NULL;
-  time_t start_time;
-  BOOL shutdown_server = False;
-  BOOL oplock_timeout = False;
-  connection_struct *saved_user_conn;
-  connection_struct *saved_fsp_conn;
-  int saved_vuid;
-  pstring saved_dir; 
-  int timeout = (OPLOCK_BREAK_TIMEOUT * 1000);
-  pstring file_name;
-  BOOL using_levelII;
-
-  if((fsp = initial_break_processing(dev, inode, tval)) == NULL)
-    return True;
-
-  /*
-   * Deal with a level II oplock going break to none separately.
-   */
-
-  if (LEVEL_II_OPLOCK_TYPE(fsp->oplock_type))
-    return oplock_break_level2(fsp, local_request, -1);
-
-  /* Mark the oplock break as sent - we don't want to send twice! */
-  if (fsp->sent_oplock_break)
-  {
-    if( DEBUGLVL( 0 ) )
-    {
-      dbgtext( "oplock_break: ERROR: oplock_break already sent for " );
-      dbgtext( "file %s ", fsp->fsp_name);
-      dbgtext( "(dev = %x, inode = %.0f)\n", (unsigned int)dev, (double)inode );
-    }
-
-    /* We have to fail the open here as we cannot send another oplock break on
-       this file whilst we are awaiting a response from the client - neither
-       can we allow another open to succeed while we are waiting for the
-       client.
-     */
-    return False;
-  }
-
-  if(global_oplock_break) {
-    DEBUG(0,("ABORT : ABORT : recursion in oplock_break !!!!!\n"));
-    abort();
-  }
-
-  /* Now comes the horrid part. We must send an oplock break to the client,
-     and then process incoming messages until we get a close or oplock release.
-     At this point we know we need a new inbuf/outbuf buffer pair.
-     We cannot use these staticaly as we may recurse into here due to
-     messages crossing on the wire.
-   */
-
-  if((inbuf = (char *)malloc(BUFFER_SIZE + LARGE_WRITEX_HDR_SIZE + SAFETY_MARGIN))==NULL)
-  {
-    DEBUG(0,("oplock_break: malloc fail for input buffer.\n"));
-    return False;
-  }
-
-  if((outbuf = (char *)malloc(BUFFER_SIZE + LARGE_WRITEX_HDR_SIZE + SAFETY_MARGIN))==NULL)
-  {
-    DEBUG(0,("oplock_break: malloc fail for output buffer.\n"));
-    SAFE_FREE(inbuf);
-    return False;
-  }
-
-  /*
-   * If we are sending an oplock break due to an SMB sent
-   * by our own client we ensure that we wait at leat
-   * lp_oplock_break_wait_time() milliseconds before sending
-   * the packet. Sending the packet sooner can break Win9x
-   * and has reported to cause problems on NT. JRA.
-   */
-
-  wait_before_sending_break(local_request);
-
-  /* Prepare the SMBlockingX message. */
-
-  if ((global_client_caps & CAP_LEVEL_II_OPLOCKS) && 
-      !koplocks && /* NOTE: we force levelII off for kernel oplocks -
-                      this will change when it is supported */
-      lp_level2_oplocks(SNUM(fsp->conn))) {
-	  using_levelII = True;
-  } else {
-	  using_levelII = False;
-  }
-
-  prepare_break_message( outbuf, fsp, using_levelII);
-  /* Remember if we just sent a break to level II on this file. */
-  fsp->sent_oplock_break = using_levelII?
-	  LEVEL_II_BREAK_SENT:EXCLUSIVE_BREAK_SENT;
-
-  if (!send_smb(smbd_server_fd(), outbuf))
-    exit_server("oplock_break: send_smb failed.\n");
-
-  /* We need this in case a readraw crosses on the wire. */
-  global_oplock_break = True;
+	extern uint32 global_client_caps;
+	extern struct current_user current_user;
+	char *inbuf = NULL;
+	char *outbuf = NULL;
+	files_struct *fsp = NULL;
+	time_t start_time;
+	BOOL shutdown_server = False;
+	BOOL oplock_timeout = False;
+	connection_struct *saved_user_conn;
+	connection_struct *saved_fsp_conn;
+	int saved_vuid;
+	pstring saved_dir; 
+	int timeout = (OPLOCK_BREAK_TIMEOUT * 1000);
+	pstring file_name;
+	BOOL using_levelII;
+
+	if((fsp = initial_break_processing(dev, inode, file_id)) == NULL)
+		return True;
+
+	/*
+	 * Deal with a level II oplock going break to none separately.
+	 */
+
+	if (LEVEL_II_OPLOCK_TYPE(fsp->oplock_type))
+		return oplock_break_level2(fsp, local_request, -1);
+
+	/* Mark the oplock break as sent - we don't want to send twice! */
+	if (fsp->sent_oplock_break) {
+		if( DEBUGLVL( 0 ) ) {
+			dbgtext( "oplock_break: ERROR: oplock_break already sent for " );
+			dbgtext( "file %s ", fsp->fsp_name);
+			dbgtext( "(dev = %x, inode = %.0f, file_id = %lu)\n", (unsigned int)dev, (double)inode, fsp->file_id );
+		}
+
+		/*
+		 * We have to fail the open here as we cannot send another oplock break on
+		 * this file whilst we are awaiting a response from the client - neither
+		 * can we allow another open to succeed while we are waiting for the client.
+		 */
+		return False;
+	}
+
+	if(global_oplock_break) {
+		DEBUG(0,("ABORT : ABORT : recursion in oplock_break !!!!!\n"));
+		abort();
+	}
+
+	/*
+	 * Now comes the horrid part. We must send an oplock break to the client,
+	 * and then process incoming messages until we get a close or oplock release.
+	 * At this point we know we need a new inbuf/outbuf buffer pair.
+	 * We cannot use these staticaly as we may recurse into here due to
+	 * messages crossing on the wire.
+	 */
+
+	if((inbuf = (char *)malloc(BUFFER_SIZE + LARGE_WRITEX_HDR_SIZE + SAFETY_MARGIN))==NULL) {
+		DEBUG(0,("oplock_break: malloc fail for input buffer.\n"));
+		return False;
+	}
+
+	if((outbuf = (char *)malloc(BUFFER_SIZE + LARGE_WRITEX_HDR_SIZE + SAFETY_MARGIN))==NULL) {
+		DEBUG(0,("oplock_break: malloc fail for output buffer.\n"));
+		SAFE_FREE(inbuf);
+		return False;
+	}
+
+	/*
+	 * If we are sending an oplock break due to an SMB sent
+	 * by our own client we ensure that we wait at leat
+	 * lp_oplock_break_wait_time() milliseconds before sending
+	 * the packet. Sending the packet sooner can break Win9x
+	 * and has reported to cause problems on NT. JRA.
+	 */
+
+	wait_before_sending_break(local_request);
+
+	/* Prepare the SMBlockingX message. */
+
+	if ((global_client_caps & CAP_LEVEL_II_OPLOCKS) && 
+			!koplocks && /* NOTE: we force levelII off for kernel oplocks - this will change when it is supported */
+			lp_level2_oplocks(SNUM(fsp->conn))) {
+		using_levelII = True;
+	} else {
+		using_levelII = False;
+	}
+
+	prepare_break_message( outbuf, fsp, using_levelII);
+	/* Remember if we just sent a break to level II on this file. */
+	fsp->sent_oplock_break = using_levelII? LEVEL_II_BREAK_SENT:EXCLUSIVE_BREAK_SENT;
+
+	if (!send_smb(smbd_server_fd(), outbuf))
+		exit_server("oplock_break: send_smb failed.\n");
+
+	/* We need this in case a readraw crosses on the wire. */
+	global_oplock_break = True;
  
-  /* Process incoming messages. */
-
-  /* JRA - If we don't get a break from the client in OPLOCK_BREAK_TIMEOUT
-     seconds we should just die.... */
-
-  start_time = time(NULL);
-
-  /*
-   * Save the information we need to re-become the
-   * user, then unbecome the user whilst we're doing this.
-   */
-  saved_user_conn = current_user.conn;
-  saved_vuid = current_user.vuid;
-  saved_fsp_conn = fsp->conn;
-  vfs_GetWd(saved_fsp_conn,saved_dir);
-  change_to_root_user();
-  /* Save the chain fnum. */
-  file_chain_save();
-
-  /*
-   * From Charles Hoch <hoch@exemplary.com>. If the break processing
-   * code closes the file (as it often does), then the fsp pointer here
-   * points to free()'d memory. We *must* revalidate fsp each time
-   * around the loop.
-   */
-
-  pstrcpy(file_name, fsp->fsp_name);
-
-  while((fsp = initial_break_processing(dev, inode, tval)) &&
-        OPEN_FSP(fsp) && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type))
-  {
-    if(receive_smb(smbd_server_fd(),inbuf, timeout) == False)
-    {
-      /*
-       * Die if we got an error.
-       */
-
-      if (smb_read_error == READ_EOF) {
-        DEBUG( 0, ( "oplock_break: end of file from client\n" ) );
-        shutdown_server = True;
-      } else if (smb_read_error == READ_ERROR) {
-        DEBUG( 0, ("oplock_break: receive_smb error (%s)\n", strerror(errno)) );
-        shutdown_server = True;
-      } else if (smb_read_error == READ_TIMEOUT) {
-        DEBUG( 0, ( "oplock_break: receive_smb timed out after %d seconds.\n",
-                     OPLOCK_BREAK_TIMEOUT ) );
-        oplock_timeout = True;
-      }
-
-      DEBUGADD( 0, ( "oplock_break failed for file %s ", file_name ) );
-      DEBUGADD( 0, ( "(dev = %x, inode = %.0f).\n", (unsigned int)dev, (double)inode));
-
-      break;
-    }
-
-    /*
-     * There are certain SMB requests that we shouldn't allow
-     * to recurse. opens, renames and deletes are the obvious
-     * ones. This is handled in the switch_message() function.
-     * If global_oplock_break is set they will push the packet onto
-     * the pending smb queue and return -1 (no reply).
-     * JRA.
-     */
-
-    process_smb(inbuf, outbuf);
-
-    /*
-     * Die if we go over the time limit.
-     */
-
-    if((time(NULL) - start_time) > OPLOCK_BREAK_TIMEOUT)
-    {
-      if( DEBUGLVL( 0 ) )
-      {
-        dbgtext( "oplock_break: no break received from client " );
-        dbgtext( "within %d seconds.\n", OPLOCK_BREAK_TIMEOUT );
-        dbgtext( "oplock_break failed for file %s ", fsp->fsp_name );
-        dbgtext( "(dev = %x, inode = %.0f).\n", (unsigned int)dev, (double)inode );
-      }
-      oplock_timeout = True;
-      break;
-    }
-  }
-
-  /*
-   * Go back to being the user who requested the oplock
-   * break.
-   */
-  if((saved_user_conn != NULL) && (saved_vuid != UID_FIELD_INVALID) && !change_to_user(saved_user_conn, saved_vuid))
-  {
-    DEBUG( 0, ( "oplock_break: unable to re-become user!" ) );
-    DEBUGADD( 0, ( "Shutting down server\n" ) );
-    close(oplock_sock);
-    exit_server("unable to re-become user");
-  }
-  /* Including the directory. */
-  vfs_ChDir(saved_fsp_conn,saved_dir);
-
-  /* Restore the chain fnum. */
-  file_chain_restore();
-
-  /* Free the buffers we've been using to recurse. */
-  SAFE_FREE(inbuf);
-  SAFE_FREE(outbuf);
-
-  /* We need this in case a readraw crossed on the wire. */
-  if(global_oplock_break)
-    global_oplock_break = False;
-
-  /*
-   * If the client timed out then clear the oplock (or go to level II)
-   * and continue. This seems to be what NT does and is better than dropping
-   * the connection.
-   */
-
-  if(oplock_timeout && (fsp = initial_break_processing(dev, inode, tval)) &&
-        OPEN_FSP(fsp) && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type))
-  {
-    DEBUG(0,("oplock_break: client failure in oplock break in file %s\n", fsp->fsp_name));
-    remove_oplock(fsp,True);
-    global_client_failed_oplock_break = True; /* Never grant this client an oplock again. */
-  }
-
-  /*
-   * If the client had an error we must die.
-   */
-
-  if(shutdown_server)
-  {
-    DEBUG( 0, ( "oplock_break: client failure in break - " ) );
-    DEBUGADD( 0, ( "shutting down this smbd.\n" ) );
-    close(oplock_sock);
-    exit_server("oplock break failure");
-  }
-
-  /* Santity check - remove this later. JRA */
-  if(exclusive_oplocks_open < 0)
-  {
-    DEBUG(0,("oplock_break: exclusive_oplocks_open < 0 (%d). PANIC ERROR\n",
-              exclusive_oplocks_open));
-    abort();
-  }
-
-  if( DEBUGLVL( 3 ) )
-  {
-    dbgtext( "oplock_break: returning success for " );
-    dbgtext( "dev = %x, inode = %.0f\n", (unsigned int)dev, (double)inode );
-    dbgtext( "Current exclusive_oplocks_open = %d\n", exclusive_oplocks_open );
-  }
-
-  return True;
+	/* Process incoming messages. */
+
+	/*
+	 * JRA - If we don't get a break from the client in OPLOCK_BREAK_TIMEOUT
+	 * seconds we should just die....
+	 */
+
+	start_time = time(NULL);
+
+	/*
+	 * Save the information we need to re-become the
+	 * user, then unbecome the user whilst we're doing this.
+	 */
+	saved_user_conn = current_user.conn;
+	saved_vuid = current_user.vuid;
+	saved_fsp_conn = fsp->conn;
+	vfs_GetWd(saved_fsp_conn,saved_dir);
+	change_to_root_user();
+	/* Save the chain fnum. */
+	file_chain_save();
+
+	/*
+	 * From Charles Hoch <hoch@exemplary.com>. If the break processing
+	 * code closes the file (as it often does), then the fsp pointer here
+	 * points to free()'d memory. We *must* revalidate fsp each time
+	 * around the loop.
+	 */
+
+	pstrcpy(file_name, fsp->fsp_name);
+
+	while((fsp = initial_break_processing(dev, inode, file_id)) &&
+			OPEN_FSP(fsp) && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
+		if(receive_smb(smbd_server_fd(),inbuf, timeout) == False) {
+			/*
+			 * Die if we got an error.
+			 */
+
+			if (smb_read_error == READ_EOF) {
+				DEBUG( 0, ( "oplock_break: end of file from client\n" ) );
+				shutdown_server = True;
+			} else if (smb_read_error == READ_ERROR) {
+				DEBUG( 0, ("oplock_break: receive_smb error (%s)\n", strerror(errno)) );
+				shutdown_server = True;
+			} else if (smb_read_error == READ_TIMEOUT) {
+				DEBUG( 0, ( "oplock_break: receive_smb timed out after %d seconds.\n", OPLOCK_BREAK_TIMEOUT ) );
+				oplock_timeout = True;
+			}
+
+			DEBUGADD( 0, ( "oplock_break failed for file %s ", file_name ) );
+			DEBUGADD( 0, ( "(dev = %x, inode = %.0f, file_id = %lu).\n",
+				(unsigned int)dev, (double)inode, file_id));
+
+			break;
+		}
+
+		/*
+		 * There are certain SMB requests that we shouldn't allow
+		 * to recurse. opens, renames and deletes are the obvious
+		 * ones. This is handled in the switch_message() function.
+		 * If global_oplock_break is set they will push the packet onto
+		 * the pending smb queue and return -1 (no reply).
+		 * JRA.
+		 */
+
+		process_smb(inbuf, outbuf);
+
+		/*
+		 * Die if we go over the time limit.
+		 */
+
+		if((time(NULL) - start_time) > OPLOCK_BREAK_TIMEOUT) {
+			if( DEBUGLVL( 0 ) ) {
+				dbgtext( "oplock_break: no break received from client " );
+				dbgtext( "within %d seconds.\n", OPLOCK_BREAK_TIMEOUT );
+				dbgtext( "oplock_break failed for file %s ", fsp->fsp_name );
+				dbgtext( "(dev = %x, inode = %.0f, file_id = %lu).\n",	
+					(unsigned int)dev, (double)inode, file_id );
+			}
+			oplock_timeout = True;
+			break;
+		}
+	}
+
+	/*
+	 * Go back to being the user who requested the oplock
+	 * break.
+	 */
+	if((saved_user_conn != NULL) && (saved_vuid != UID_FIELD_INVALID) && !change_to_user(saved_user_conn, saved_vuid)) {
+		DEBUG( 0, ( "oplock_break: unable to re-become user!" ) );
+		DEBUGADD( 0, ( "Shutting down server\n" ) );
+		close(oplock_sock);
+		exit_server("unable to re-become user");
+	}
+
+	/* Including the directory. */
+	vfs_ChDir(saved_fsp_conn,saved_dir);
+
+	/* Restore the chain fnum. */
+	file_chain_restore();
+
+	/* Free the buffers we've been using to recurse. */
+	SAFE_FREE(inbuf);
+	SAFE_FREE(outbuf);
+
+	/* We need this in case a readraw crossed on the wire. */
+	if(global_oplock_break)
+		global_oplock_break = False;
+
+	/*
+	 * If the client timed out then clear the oplock (or go to level II)
+	 * and continue. This seems to be what NT does and is better than dropping
+	 * the connection.
+	 */
+
+	if(oplock_timeout && (fsp = initial_break_processing(dev, inode, file_id)) &&
+			OPEN_FSP(fsp) && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) {
+		DEBUG(0,("oplock_break: client failure in oplock break in file %s\n", fsp->fsp_name));
+		remove_oplock(fsp,True);
+		global_client_failed_oplock_break = True; /* Never grant this client an oplock again. */
+	}
+
+	/*
+	 * If the client had an error we must die.
+	 */
+
+	if(shutdown_server) {
+		DEBUG( 0, ( "oplock_break: client failure in break - " ) );
+		DEBUGADD( 0, ( "shutting down this smbd.\n" ) );
+		close(oplock_sock);
+		exit_server("oplock break failure");
+	}
+
+	/* Santity check - remove this later. JRA */
+	if(exclusive_oplocks_open < 0) {
+		DEBUG(0,("oplock_break: exclusive_oplocks_open < 0 (%d). PANIC ERROR\n", exclusive_oplocks_open));
+		abort();
+	}
+
+	if( DEBUGLVL( 3 ) ) {
+		dbgtext( "oplock_break: returning success for " );
+		dbgtext( "dev = %x, inode = %.0f, file_id = %lu\n", (unsigned int)dev, (double)inode, file_id );
+		dbgtext( "Current exclusive_oplocks_open = %d\n", exclusive_oplocks_open );
+	}
+
+	return True;
 }
 
 /****************************************************************************
@@ -893,212 +866,187 @@ Send an oplock break message to another smbd process. If the oplock is held
 by the local smbd then call the oplock break function directly.
 ****************************************************************************/
 
-BOOL request_oplock_break(share_mode_entry *share_entry, 
-                          SMB_DEV_T dev, SMB_INO_T inode)
+BOOL request_oplock_break(share_mode_entry *share_entry)
 {
-  char op_break_msg[OPLOCK_BREAK_MSG_LEN];
-  struct sockaddr_in addr_out;
-  pid_t pid = sys_getpid();
-  time_t start_time;
-  int time_left;
-  long usec;
-  time_t sec;
-
-  if(pid == share_entry->pid)
-  {
-    /* We are breaking our own oplock, make sure it's us. */
-    if(share_entry->op_port != global_oplock_port)
-    {
-      DEBUG(0,("request_oplock_break: corrupt share mode entry - pid = %d, port = %d \
+	char op_break_msg[OPLOCK_BREAK_MSG_LEN];
+	struct sockaddr_in addr_out;
+	pid_t pid = sys_getpid();
+	time_t start_time;
+	int time_left;
+	SMB_DEV_T dev = share_entry->dev;
+	SMB_INO_T inode = share_entry->inode;
+	unsigned long file_id = share_entry->share_file_id;
+
+	if(pid == share_entry->pid) {
+		/* We are breaking our own oplock, make sure it's us. */
+		if(share_entry->op_port != global_oplock_port) {
+			DEBUG(0,("request_oplock_break: corrupt share mode entry - pid = %d, port = %d \
 should be %d\n", (int)pid, share_entry->op_port, global_oplock_port));
-      return False;
-    }
+			return False;
+		}
 
-    DEBUG(5,("request_oplock_break: breaking our own oplock\n"));
+		DEBUG(5,("request_oplock_break: breaking our own oplock\n"));
 
 #if 1 /* JRA PARANOIA TEST.... */
-    {
-      files_struct *fsp = file_find_dit(dev, inode, &share_entry->time);
-      if (!fsp) {
-        DEBUG(0,("request_oplock_break: PANIC : breaking our own oplock requested for \
-dev = %x, inode = %.0f, tv_sec = %x, tv_usec = %x and no fsp found !\n",
-            (unsigned int)dev, (double)inode, (int)share_entry->time.tv_sec,
-            (int)share_entry->time.tv_usec ));
-        smb_panic("request_oplock_break: no fsp found for our own oplock\n");
-      }
-    }
+		{
+			files_struct *fsp = file_find_dif(dev, inode, file_id);
+			if (!fsp) {
+				DEBUG(0,("request_oplock_break: PANIC : breaking our own oplock requested for \
+dev = %x, inode = %.0f, file_id = %lu and no fsp found !\n",
+            (unsigned int)dev, (double)inode, file_id ));
+				smb_panic("request_oplock_break: no fsp found for our own oplock\n");
+			}
+		}
 #endif /* END JRA PARANOIA TEST... */
 
-    /* Call oplock break direct. */
-    return oplock_break(dev, inode, &share_entry->time, True);
-  }
-
-  /* We need to send a OPLOCK_BREAK_CMD message to the
-     port in the share mode entry. */
-
-  if (LEVEL_II_OPLOCK_TYPE(share_entry->op_type)) {
-    SSVAL(op_break_msg,OPBRK_MESSAGE_CMD_OFFSET,LEVEL_II_OPLOCK_BREAK_CMD);
-  } else {
-    SSVAL(op_break_msg,OPBRK_MESSAGE_CMD_OFFSET,OPLOCK_BREAK_CMD);
-  }
-  memcpy(op_break_msg+OPLOCK_BREAK_PID_OFFSET,(char *)&pid,sizeof(pid));
-  sec = (time_t)share_entry->time.tv_sec;
-  memcpy(op_break_msg+OPLOCK_BREAK_SEC_OFFSET,(char *)&sec,sizeof(sec));
-  usec = (long)share_entry->time.tv_usec;
-  memcpy(op_break_msg+OPLOCK_BREAK_USEC_OFFSET,(char *)&usec,sizeof(usec));
-  memcpy(op_break_msg+OPLOCK_BREAK_DEV_OFFSET,(char *)&dev,sizeof(dev));
-  memcpy(op_break_msg+OPLOCK_BREAK_INODE_OFFSET,(char *)&inode,sizeof(inode));
-
-  /* set the address and port */
-  memset((char *)&addr_out,'\0',sizeof(addr_out));
-  addr_out.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
-  addr_out.sin_port = htons( share_entry->op_port );
-  addr_out.sin_family = AF_INET;
+		/* Call oplock break direct. */
+		return oplock_break(dev, inode, file_id, True);
+	}
+
+	/* We need to send a OPLOCK_BREAK_CMD message to the port in the share mode entry. */
+
+	if (LEVEL_II_OPLOCK_TYPE(share_entry->op_type)) {
+		SSVAL(op_break_msg,OPBRK_MESSAGE_CMD_OFFSET,LEVEL_II_OPLOCK_BREAK_CMD);
+	} else {
+		SSVAL(op_break_msg,OPBRK_MESSAGE_CMD_OFFSET,OPLOCK_BREAK_CMD);
+	}
+
+	memcpy(op_break_msg+OPLOCK_BREAK_PID_OFFSET,(char *)&pid,sizeof(pid));
+	memcpy(op_break_msg+OPLOCK_BREAK_DEV_OFFSET,(char *)&dev,sizeof(dev));
+	memcpy(op_break_msg+OPLOCK_BREAK_INODE_OFFSET,(char *)&inode,sizeof(inode));
+	memcpy(op_break_msg+OPLOCK_BREAK_FILEID_OFFSET,(char *)&file_id,sizeof(file_id));
+
+	/* Set the address and port. */
+	memset((char *)&addr_out,'\0',sizeof(addr_out));
+	addr_out.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
+	addr_out.sin_port = htons( share_entry->op_port );
+	addr_out.sin_family = AF_INET;
    
-  if( DEBUGLVL( 3 ) )
-  {
-    dbgtext( "request_oplock_break: sending a oplock break message to " );
-    dbgtext( "pid %d on port %d ", (int)share_entry->pid, share_entry->op_port );
-    dbgtext( "for dev = %x, inode = %.0f, tv_sec = %x, tv_usec = %x\n",
-            (unsigned int)dev, (double)inode, (int)share_entry->time.tv_sec,
-            (int)share_entry->time.tv_usec );
-
-  }
-
-  if(sendto(oplock_sock,op_break_msg,OPLOCK_BREAK_MSG_LEN,0,
-         (struct sockaddr *)&addr_out,sizeof(addr_out)) < 0)
-  {
-    if( DEBUGLVL( 0 ) )
-    {
-      dbgtext( "request_oplock_break: failed when sending a oplock " );
-      dbgtext( "break message to pid %d ", (int)share_entry->pid );
-      dbgtext( "on port %d ", share_entry->op_port );
-      dbgtext( "for dev = %x, inode = %.0f, tv_sec = %x, tv_usec = %x\n",
-          (unsigned int)dev, (double)inode, (int)share_entry->time.tv_sec,
-          (int)share_entry->time.tv_usec );
-      dbgtext( "Error was %s\n", strerror(errno) );
-    }
-    return False;
-  }
-
-  /*
-   * If we just sent a message to a level II oplock share entry then
-   * we are done and may return.
-   */
-
-  if (LEVEL_II_OPLOCK_TYPE(share_entry->op_type)) {
-    DEBUG(3,("request_oplock_break: sent break message to level II entry.\n"));
-    return True;
-  }
-
-  /*
-   * Now we must await the oplock broken message coming back
-   * from the target smbd process. Timeout if it fails to
-   * return in (OPLOCK_BREAK_TIMEOUT + OPLOCK_BREAK_TIMEOUT_FUDGEFACTOR) seconds.
-   * While we get messages that aren't ours, loop.
-   */
-
-  start_time = time(NULL);
-  time_left = OPLOCK_BREAK_TIMEOUT+OPLOCK_BREAK_TIMEOUT_FUDGEFACTOR;
-
-  while(time_left >= 0)
-  {
-    char op_break_reply[OPBRK_CMD_HEADER_LEN+OPLOCK_BREAK_MSG_LEN];
-    uint16 reply_from_port;
-    char *reply_msg_start;
-    fd_set fds;
-
-    FD_ZERO(&fds);
-    FD_SET(oplock_sock,&fds);
-
-    if (koplocks && koplocks->notification_fd != -1) {
-	    FD_SET(koplocks->notification_fd, &fds);
-    }
-
-    if(receive_local_message(&fds, op_break_reply, sizeof(op_break_reply),
-               time_left ? time_left * 1000 : 1) == False)
-    {
-      if(smb_read_error == READ_TIMEOUT)
-      {
-        if( DEBUGLVL( 0 ) )
-        {
-          dbgtext( "request_oplock_break: no response received to oplock " );
-          dbgtext( "break request to pid %d ", (int)share_entry->pid );
-          dbgtext( "on port %d ", share_entry->op_port );
-          dbgtext( "for dev = %x, inode = %.0f\n", (unsigned int)dev, (double)inode );
-          dbgtext( "for dev = %x, inode = %.0f, tv_sec = %x, tv_usec = %x\n",
-             (unsigned int)dev, (double)inode, (int)share_entry->time.tv_sec,
-             (int)share_entry->time.tv_usec );
-        }
-
-        /*
-         * This is a hack to make handling of failing clients more robust.
-         * If a oplock break response message is not received in the timeout
-         * period we may assume that the smbd servicing that client holding
-         * the oplock has died and the client changes were lost anyway, so
-         * we should continue to try and open the file.
-         */
-        break;
-      }
-      else
-        if( DEBUGLVL( 0 ) )
-        {
-          dbgtext( "request_oplock_break: error in response received " );
-          dbgtext( "to oplock break request to pid %d ", (int)share_entry->pid );
-          dbgtext( "on port %d ", share_entry->op_port );
-          dbgtext( "for dev = %x, inode = %.0f, tv_sec = %x, tv_usec = %x\n",
-               (unsigned int)dev, (double)inode, (int)share_entry->time.tv_sec,
-               (int)share_entry->time.tv_usec );
-          dbgtext( "Error was (%s).\n", strerror(errno) );
-        }
-      return False;
-    }
-
-    reply_from_port = SVAL(op_break_reply,OPBRK_CMD_PORT_OFFSET);
-
-    reply_msg_start = &op_break_reply[OPBRK_CMD_HEADER_LEN];
-
-
-    /*
-     * Test to see if this is the reply we are awaiting.
-     */
-    if((SVAL(reply_msg_start,OPBRK_MESSAGE_CMD_OFFSET) & CMD_REPLY) &&
-       ((SVAL(reply_msg_start,OPBRK_MESSAGE_CMD_OFFSET) & ~CMD_REPLY) == OPLOCK_BREAK_CMD) &&
-       (reply_from_port == share_entry->op_port) && 
-       (memcmp(&reply_msg_start[OPLOCK_BREAK_PID_OFFSET], 
-               &op_break_msg[OPLOCK_BREAK_PID_OFFSET],
-               OPLOCK_BREAK_MSG_LEN - OPLOCK_BREAK_PID_OFFSET) == 0))
-    {
-      /*
-       * This is the reply we've been waiting for.
-       */
-      break;
-    }
-    else
-    {
-      /*
-       * This is another message - a break request.
-       * Note that both kernel oplock break requests
-       * and UDP inter-smbd oplock break requests will
-       * be processed here.
-       *
-       * Process it to prevent potential deadlock.
-       * Note that the code in switch_message() prevents
-       * us from recursing into here as any SMB requests
-       * we might process that would cause another oplock
-       * break request to be made will be queued.
-       * JRA.
-       */
-
-      process_local_message(op_break_reply, sizeof(op_break_reply));
-    }
-
-    time_left -= (time(NULL) - start_time);
-  }
-
-  DEBUG(3,("request_oplock_break: broke oplock.\n"));
-
-  return True;
+	if( DEBUGLVL( 3 ) ) {
+		dbgtext( "request_oplock_break: sending a oplock break message to " );
+		dbgtext( "pid %d on port %d ", (int)share_entry->pid, share_entry->op_port );
+		dbgtext( "for dev = %x, inode = %.0f, file_id = %lu\n",
+            (unsigned int)dev, (double)inode, file_id );
+	}
+
+	if(sendto(oplock_sock,op_break_msg,OPLOCK_BREAK_MSG_LEN,0,
+			(struct sockaddr *)&addr_out,sizeof(addr_out)) < 0) {
+		if( DEBUGLVL( 0 ) ) {
+			dbgtext( "request_oplock_break: failed when sending a oplock " );
+			dbgtext( "break message to pid %d ", (int)share_entry->pid );
+			dbgtext( "on port %d ", share_entry->op_port );
+			dbgtext( "for dev = %x, inode = %.0f, file_id = %lu\n",
+          (unsigned int)dev, (double)inode, file_id );
+			dbgtext( "Error was %s\n", strerror(errno) );
+		}
+		return False;
+	}
+
+	/*
+	 * If we just sent a message to a level II oplock share entry then
+	 * we are done and may return.
+	 */
+
+	if (LEVEL_II_OPLOCK_TYPE(share_entry->op_type)) {
+		DEBUG(3,("request_oplock_break: sent break message to level II entry.\n"));
+		return True;
+	}
+
+	/*
+	 * Now we must await the oplock broken message coming back
+	 * from the target smbd process. Timeout if it fails to
+	 * return in (OPLOCK_BREAK_TIMEOUT + OPLOCK_BREAK_TIMEOUT_FUDGEFACTOR) seconds.
+	 * While we get messages that aren't ours, loop.
+	 */
+
+	start_time = time(NULL);
+	time_left = OPLOCK_BREAK_TIMEOUT+OPLOCK_BREAK_TIMEOUT_FUDGEFACTOR;
+
+	while(time_left >= 0) {
+		char op_break_reply[OPBRK_CMD_HEADER_LEN+OPLOCK_BREAK_MSG_LEN];
+		uint16 reply_from_port;
+		char *reply_msg_start;
+		fd_set fds;
+
+		FD_ZERO(&fds);
+		FD_SET(oplock_sock,&fds);
+
+		if (koplocks && koplocks->notification_fd != -1) {
+			FD_SET(koplocks->notification_fd, &fds);
+		}
+
+		if(receive_local_message(&fds, op_break_reply, sizeof(op_break_reply),
+				time_left ? time_left * 1000 : 1) == False) {
+			if(smb_read_error == READ_TIMEOUT) {
+				if( DEBUGLVL( 0 ) ) {
+					dbgtext( "request_oplock_break: no response received to oplock " );
+					dbgtext( "break request to pid %d ", (int)share_entry->pid );
+					dbgtext( "on port %d ", share_entry->op_port );
+					dbgtext( "for dev = %x, inode = %.0f, file_id = %lu\n",
+							(unsigned int)dev, (double)inode, file_id );
+				}
+
+				/*
+				 * This is a hack to make handling of failing clients more robust.
+				 * If a oplock break response message is not received in the timeout
+				 * period we may assume that the smbd servicing that client holding
+				 * the oplock has died and the client changes were lost anyway, so
+				 * we should continue to try and open the file.
+				 */
+				break;
+			} else {
+				if( DEBUGLVL( 0 ) ) {
+					dbgtext( "request_oplock_break: error in response received " );
+					dbgtext( "to oplock break request to pid %d ", (int)share_entry->pid );
+					dbgtext( "on port %d ", share_entry->op_port );
+					dbgtext( "for dev = %x, inode = %.0f, file_id = %lu\n",
+						(unsigned int)dev, (double)inode, file_id );
+					dbgtext( "Error was (%s).\n", strerror(errno) );
+				}
+			}
+			return False;
+		}
+
+		reply_from_port = SVAL(op_break_reply,OPBRK_CMD_PORT_OFFSET);
+		reply_msg_start = &op_break_reply[OPBRK_CMD_HEADER_LEN];
+
+		/*
+		 * Test to see if this is the reply we are awaiting.
+		 */
+		if((SVAL(reply_msg_start,OPBRK_MESSAGE_CMD_OFFSET) & CMD_REPLY) &&
+			((SVAL(reply_msg_start,OPBRK_MESSAGE_CMD_OFFSET) & ~CMD_REPLY) == OPLOCK_BREAK_CMD) &&
+			(reply_from_port == share_entry->op_port) && 
+			(memcmp(&reply_msg_start[OPLOCK_BREAK_PID_OFFSET], &op_break_msg[OPLOCK_BREAK_PID_OFFSET],
+				OPLOCK_BREAK_MSG_LEN - OPLOCK_BREAK_PID_OFFSET) == 0)) {
+
+			/*
+			 * This is the reply we've been waiting for.
+			 */
+			break;
+		} else {
+			/*
+			 * This is another message - a break request.
+			 * Note that both kernel oplock break requests
+			 * and UDP inter-smbd oplock break requests will
+			 * be processed here.
+			 *
+			 * Process it to prevent potential deadlock.
+			 * Note that the code in switch_message() prevents
+			 * us from recursing into here as any SMB requests
+			 * we might process that would cause another oplock
+			 * break request to be made will be queued.
+			 * JRA.
+			 */
+
+			process_local_message(op_break_reply, sizeof(op_break_reply));
+		}
+
+		time_left -= (time(NULL) - start_time);
+	}
+
+	DEBUG(3,("request_oplock_break: broke oplock.\n"));
+
+	return True;
 }
 
 /****************************************************************************
@@ -1108,20 +1056,20 @@ dev = %x, inode = %.0f, tv_sec = %x, tv_usec = %x and no fsp found !\n",
   Used as a last ditch attempt to free a space in the 
   file table when we have run out.
 ****************************************************************************/
+
 BOOL attempt_close_oplocked_file(files_struct *fsp)
 {
+	DEBUG(5,("attempt_close_oplocked_file: checking file %s.\n", fsp->fsp_name));
 
-  DEBUG(5,("attempt_close_oplocked_file: checking file %s.\n", fsp->fsp_name));
-
-  if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && !fsp->sent_oplock_break && (fsp->fd != -1)) {
-	  /* Try and break the oplock. */
-	  if (oplock_break(fsp->dev, fsp->inode, &fsp->open_time, True)) {
-		  if(file_find_fsp(fsp) == NULL) /* Did the oplock break close the file ? */
-			  return True;
-	  }
-  }
+	if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && !fsp->sent_oplock_break && (fsp->fd != -1)) {
+		/* Try and break the oplock. */
+		if (oplock_break(fsp->dev, fsp->inode, fsp->file_id, True)) {
+			if(file_find_fsp(fsp) == NULL) /* Did the oplock break close the file ? */
+				return True;
+		}
+	}
 
-  return False;
+	return False;
 }
 
 /****************************************************************************
@@ -1189,7 +1137,7 @@ void release_level_2_oplocks_on_change(files_struct *fsp)
 		 */
 
 		if (pid == share_entry->pid) {
-			files_struct *new_fsp = file_find_dit(fsp->dev, fsp->inode, &share_entry->time);
+			files_struct *new_fsp = file_find_dif(share_entry->dev, share_entry->inode, share_entry->share_file_id);
 
 			/* Paranoia check... */
 			if(new_fsp == NULL) {
@@ -1210,11 +1158,11 @@ void release_level_2_oplocks_on_change(files_struct *fsp)
 			 */
 
 			DEBUG(10,("release_level_2_oplocks_on_change: breaking remote oplock.\n"));
-			request_oplock_break(share_entry, fsp->dev, fsp->inode);
+			request_oplock_break(share_entry);
 		}
 	}
 
-	SAFE_FREE(share_list);
+	SAFE_FREE((char *)share_list);
 	unlock_share_entry_fsp(fsp);
 
 	/* Paranoia check... */
@@ -1227,6 +1175,7 @@ void release_level_2_oplocks_on_change(files_struct *fsp)
 /****************************************************************************
 setup oplocks for this process
 ****************************************************************************/
+
 BOOL init_oplocks(void)
 {
 	struct sockaddr_in sock_name;
diff --git a/source3/smbd/oplock_irix.c b/source3/smbd/oplock_irix.c
index c6055fc329..1052046175 100644
--- a/source3/smbd/oplock_irix.c
+++ b/source3/smbd/oplock_irix.c
@@ -27,8 +27,9 @@ static int oplock_pipe_write = -1;
 static int oplock_pipe_read = -1;
 
 /****************************************************************************
-test to see if IRIX kernel oplocks work
+ Test to see if IRIX kernel oplocks work.
 ****************************************************************************/
+
 static BOOL irix_oplocks_available(void)
 {
 	int fd;
@@ -81,106 +82,113 @@ Disabling kernel oplock support.\n", strerror(errno) ));
 	return True;
 }
 
-
-
 /****************************************************************************
  * Deal with the IRIX kernel <--> smbd
  * oplock break protocol.
 ****************************************************************************/
+
 static BOOL irix_oplock_receive_message(fd_set *fds, char *buffer, int buffer_len)
 {
 	extern int smb_read_error;
-     oplock_stat_t os;
-     SMB_DEV_T dev;
-     SMB_INO_T inode;
-     char dummy;
-
-     /*
-      * Read one byte of zero to clear the
-      * kernel break notify message.
-      */
-
-     if(read(oplock_pipe_read, &dummy, 1) != 1) {
-	     DEBUG(0,("receive_local_message: read of kernel notification failed. \
+	oplock_stat_t os;
+	char dummy;
+	files_struct *fsp;
+
+	/*
+	 * Read one byte of zero to clear the
+	 * kernel break notify message.
+	 */
+
+	if(read(oplock_pipe_read, &dummy, 1) != 1) {
+		DEBUG(0,("receive_local_message: read of kernel notification failed. \
 Error was %s.\n", strerror(errno) ));
-	     smb_read_error = READ_ERROR;
-	     return False;
-     }
-
-     /*
-      * Do a query to get the
-      * device and inode of the file that has the break
-      * request outstanding.
-      */
-
-     if(fcntl(oplock_pipe_read, F_OPLKSTAT, &os) < 0) {
-	     DEBUG(0,("receive_local_message: fcntl of kernel notification failed. \
+		smb_read_error = READ_ERROR;
+		return False;
+	}
+
+	/*
+	 * Do a query to get the
+	 * device and inode of the file that has the break
+	 * request outstanding.
+	 */
+
+	if(fcntl(oplock_pipe_read, F_OPLKSTAT, &os) < 0) {
+		DEBUG(0,("receive_local_message: fcntl of kernel notification failed. \
 Error was %s.\n", strerror(errno) ));
-	     if(errno == EAGAIN) {
-		     /*
-		      * Duplicate kernel break message - ignore.
-		      */
-		     memset(buffer, '\0', KERNEL_OPLOCK_BREAK_MSG_LEN);
-		     return True;
-	     }
-	     smb_read_error = READ_ERROR;
-	     return False;
-     }
-
-     dev = (SMB_DEV_T)os.os_dev;
-     inode = (SMB_INO_T)os.os_ino;
-     
-     DEBUG(5,("receive_local_message: kernel oplock break request received for \
-dev = %x, inode = %.0f\n", (unsigned int)dev, (double)inode ));
-     
-     /*
-      * Create a kernel oplock break message.
-      */
-     
-     /* Setup the message header */
-     SIVAL(buffer,OPBRK_CMD_LEN_OFFSET,KERNEL_OPLOCK_BREAK_MSG_LEN);
-     SSVAL(buffer,OPBRK_CMD_PORT_OFFSET,0);
-     
-     buffer += OPBRK_CMD_HEADER_LEN;
+		if(errno == EAGAIN) {
+			/*
+			 * Duplicate kernel break message - ignore.
+			 */
+			memset(buffer, '\0', KERNEL_OPLOCK_BREAK_MSG_LEN);
+			return True;
+		}
+		smb_read_error = READ_ERROR;
+		return False;
+	}
+
+	/*
+	 * We only have device and inode info here - we have to guess that this
+	 * is the first fsp open with this dev,ino pair.
+	 */
+
+	if ((fsp = file_find_di_first((SMB_DEV_T)os.os_dev, (SMB_INO_T)os.os_ino)) == NULL) {
+		DEBUG(0,("receive_local_message: unable to find open file with dev = %x, inode = %.0f\n",
+			(unsigned int)os.os_dev, (double)os.os_ino ));
+		return False;
+	}
      
-     SSVAL(buffer,OPBRK_MESSAGE_CMD_OFFSET,KERNEL_OPLOCK_BREAK_CMD);
+	DEBUG(5,("receive_local_message: kernel oplock break request received for \
+dev = %x, inode = %.0f\n, file_id = %ul", (unsigned int)fsp->dev, (double)fsp->inode, fsp->file_id ));
      
-     memcpy(buffer + KERNEL_OPLOCK_BREAK_DEV_OFFSET, (char *)&dev, sizeof(dev));
-     memcpy(buffer + KERNEL_OPLOCK_BREAK_INODE_OFFSET, (char *)&inode, sizeof(inode));	
+	/*
+	 * Create a kernel oplock break message.
+	 */
+    
+	/* Setup the message header */
+	SIVAL(buffer,OPBRK_CMD_LEN_OFFSET,KERNEL_OPLOCK_BREAK_MSG_LEN);
+	SSVAL(buffer,OPBRK_CMD_PORT_OFFSET,0);
+   
+	buffer += OPBRK_CMD_HEADER_LEN;
      
-     return True;
+	SSVAL(buffer,OPBRK_MESSAGE_CMD_OFFSET,KERNEL_OPLOCK_BREAK_CMD);
+   
+	memcpy(buffer + KERNEL_OPLOCK_BREAK_DEV_OFFSET, (char *)&fsp->dev, sizeof(fsp->dev));
+	memcpy(buffer + KERNEL_OPLOCK_BREAK_INODE_OFFSET, (char *)&fsp->inode, sizeof(fsp->inode));	
+	memcpy(buffer + KERNEL_OPLOCK_BREAK_FILEID_OFFSET, (char *)&fsp->file_id, sizeof(fsp->file_id));	
+   
+	return True;
 }
 
-
 /****************************************************************************
  Attempt to set an kernel oplock on a file.
 ****************************************************************************/
+
 static BOOL irix_set_kernel_oplock(files_struct *fsp, int oplock_type)
 {
 	if (fcntl(fsp->fd, F_OPLKREG, oplock_pipe_write) == -1) {
 		if(errno != EAGAIN) {
 			DEBUG(0,("set_file_oplock: Unable to get kernel oplock on file %s, dev = %x, \
-inode = %.0f. Error was %s\n", 
-				 fsp->fsp_name, (unsigned int)fsp->dev, (double)fsp->inode,
+inode = %.0f, file_id = %ul. Error was %s\n", 
+				 fsp->fsp_name, (unsigned int)fsp->dev, (double)fsp->inode, fsp->file_id,
 				 strerror(errno) ));
 		} else {
 			DEBUG(5,("set_file_oplock: Refused oplock on file %s, fd = %d, dev = %x, \
-inode = %.0f. Another process had the file open.\n",
-				 fsp->fsp_name, fsp->fd, (unsigned int)fsp->dev, (double)fsp->inode ));
+inode = %.0f, file_id = %ul. Another process had the file open.\n",
+				 fsp->fsp_name, fsp->fd, (unsigned int)fsp->dev, (double)fsp->inode, fsp->file_id ));
 		}
 		return False;
 	}
 	
-	DEBUG(10,("set_file_oplock: got kernel oplock on file %s, dev = %x, inode = %.0f\n",
-		  fsp->fsp_name, (unsigned int)fsp->dev, (double)fsp->inode));
+	DEBUG(10,("set_file_oplock: got kernel oplock on file %s, dev = %x, inode = %.0f, file_id = %ul\n",
+		  fsp->fsp_name, (unsigned int)fsp->dev, (double)fsp->inode, fsp->file_id));
 
 	return True;
 }
 
-
 /****************************************************************************
  Release a kernel oplock on a file.
 ****************************************************************************/
+
 static void irix_release_kernel_oplock(files_struct *fsp)
 {
 	if (DEBUGLVL(10)) {
@@ -189,9 +197,9 @@ static void irix_release_kernel_oplock(files_struct *fsp)
 		 * oplock state of this file.
 		 */
 		int state = fcntl(fsp->fd, F_OPLKACK, -1);
-		dbgtext("release_kernel_oplock: file %s, dev = %x, inode = %.0f has kernel \
+		dbgtext("release_kernel_oplock: file %s, dev = %x, inode = %.0f file_id = %ul, has kernel \
 oplock state of %x.\n", fsp->fsp_name, (unsigned int)fsp->dev,
-                        (double)fsp->inode, state );
+                        (double)fsp->inode, fsp->file_id, state );
 	}
 
 	/*
@@ -200,18 +208,19 @@ oplock state of %x.\n", fsp->fsp_name, (unsigned int)fsp->dev,
 	if(fcntl(fsp->fd, F_OPLKACK, OP_REVOKE) < 0) {
 		if( DEBUGLVL( 0 )) {
 			dbgtext("release_kernel_oplock: Error when removing kernel oplock on file " );
-			dbgtext("%s, dev = %x, inode = %.0f. Error was %s\n",
+			dbgtext("%s, dev = %x, inode = %.0f, file_id = %ul. Error was %s\n",
 				fsp->fsp_name, (unsigned int)fsp->dev, 
-				(double)fsp->inode, strerror(errno) );
+				(double)fsp->inode, fsp->file_id, strerror(errno) );
 		}
 	}
 }
 
-
 /****************************************************************************
-parse a kernel oplock message
+ Parse a kernel oplock message.
 ****************************************************************************/
-static BOOL irix_kernel_oplock_parse(char *msg_start, int msg_len, SMB_INO_T *inode, SMB_DEV_T *dev)
+
+static BOOL irix_kernel_oplock_parse(char *msg_start, int msg_len,
+		SMB_INO_T *inode, SMB_DEV_T *dev, unsigned long *file_id)
 {
 	/* Ensure that the msg length is correct. */
 	if(msg_len != KERNEL_OPLOCK_BREAK_MSG_LEN) {
@@ -220,36 +229,39 @@ static BOOL irix_kernel_oplock_parse(char *msg_start, int msg_len, SMB_INO_T *in
 		return False;
 	}
 
-        memcpy((char *)inode, msg_start+KERNEL_OPLOCK_BREAK_INODE_OFFSET, sizeof(*inode));
-        memcpy((char *)dev, msg_start+KERNEL_OPLOCK_BREAK_DEV_OFFSET, sizeof(*dev));
+	memcpy((char *)inode, msg_start+KERNEL_OPLOCK_BREAK_INODE_OFFSET, sizeof(*inode));
+	memcpy((char *)dev, msg_start+KERNEL_OPLOCK_BREAK_DEV_OFFSET, sizeof(*dev));
+	memcpy((char *)file_id, msg_start+KERNEL_OPLOCK_BREAK_FILEID_OFFSET, sizeof(*file_id));
 
-        DEBUG(5,("kernel oplock break request for file dev = %x, inode = %.0f\n", 
-		 (unsigned int)*dev, (double)*inode));
+	DEBUG(5,("kernel oplock break request for file dev = %x, inode = %.0f, file_id = %ul\n", 
+		(unsigned int)*dev, (double)*inode, *file_id));
 
 	return True;
 }
 
-
 /****************************************************************************
-set *maxfd to include oplock read pipe
+ Set *maxfd to include oplock read pipe.
 ****************************************************************************/
+
 static BOOL irix_oplock_msg_waiting(fd_set *fds)
 {
-	if (oplock_pipe_read == -1) return False;
+	if (oplock_pipe_read == -1)
+		return False;
 
 	return FD_ISSET(oplock_pipe_read,fds);
 }
 
-
 /****************************************************************************
-setup kernel oplocks
+ Setup kernel oplocks.
 ****************************************************************************/
+
 struct kernel_oplocks *irix_init_kernel_oplocks(void) 
 {
 	int pfd[2];
 	static struct kernel_oplocks koplocks;
 
-	if (!irix_oplocks_available()) return NULL;
+	if (!irix_oplocks_available())
+		return NULL;
 
 	if(pipe(pfd) != 0) {
 		DEBUG(0,("setup_kernel_oplock_pipe: Unable to create pipe. Error was %s\n",
@@ -269,9 +281,6 @@ struct kernel_oplocks *irix_init_kernel_oplocks(void)
 
 	return &koplocks;
 }
-
-
-
 #else
  void oplock_irix_dummy(void) {}
 #endif /* HAVE_KERNEL_OPLOCKS_IRIX */
diff --git a/source3/smbd/oplock_linux.c b/source3/smbd/oplock_linux.c
index 8c4259ac53..f42d55d297 100644
--- a/source3/smbd/oplock_linux.c
+++ b/source3/smbd/oplock_linux.c
@@ -48,8 +48,9 @@ static VOLATILE sig_atomic_t fd_pending; /* the fd of the current pending signal
 #endif
 
 /****************************************************************************
-handle a LEASE signal, incrementing the signals_received and blocking the signal
+ Handle a LEASE signal, incrementing the signals_received and blocking the signal.
 ****************************************************************************/
+
 static void signal_handler(int sig, siginfo_t *info, void *unused)
 {
 	BlockSignals(True, sig);
@@ -59,8 +60,9 @@ static void signal_handler(int sig, siginfo_t *info, void *unused)
 }
 
 /****************************************************************************
-try to gain a linux capability
+ Try to gain a linux capability.
 ****************************************************************************/
+
 static void set_capability(unsigned capability)
 {
 #ifndef _LINUX_CAPABILITY_VERSION
@@ -93,11 +95,11 @@ static void set_capability(unsigned capability)
 	}
 }
 
-
 /****************************************************************************
-call SETLEASE. If we get EACCES then we try setting up the right capability and
-try again
+ Call SETLEASE. If we get EACCES then we try setting up the right capability and
+ try again
 ****************************************************************************/
+
 static int linux_setlease(int fd, int leasetype)
 {
 	int ret;
@@ -116,31 +118,27 @@ static int linux_setlease(int fd, int leasetype)
 	return ret;
 }
 
-
 /****************************************************************************
  * Deal with the Linux kernel <--> smbd
  * oplock break protocol.
 ****************************************************************************/
+
 static BOOL linux_oplock_receive_message(fd_set *fds, char *buffer, int buffer_len)
 {
-	SMB_DEV_T dev;
-	SMB_INO_T inode;
-	SMB_STRUCT_STAT sbuf;
 	BOOL ret = True;
+	struct files_struct *fsp;
 
-	if (signals_received == signals_processed) return False;
+	if (signals_received == signals_processed)
+		return False;
 
-	if (sys_fstat((int)fd_pending,&sbuf) == -1) {
+	if ((fsp = file_find_fd(fd_pending)) == NULL) {
 		DEBUG(0,("Invalid file descriptor %d in kernel oplock break!\n", (int)fd_pending));
 		ret = False;
 		goto out;
 	}
 
-	dev = sbuf.st_dev;
-	inode = sbuf.st_ino;
-     
 	DEBUG(3,("receive_local_message: kernel oplock break request received for \
-dev = %x, inode = %.0f\n", (unsigned int)dev, (double)inode ));
+dev = %x, inode = %.0f\n", (unsigned int)fsp->dev, (double)fsp->inode ));
      
 	/*
 	 * Create a kernel oplock break message.
@@ -154,8 +152,9 @@ dev = %x, inode = %.0f\n", (unsigned int)dev, (double)inode ));
      
 	SSVAL(buffer,OPBRK_MESSAGE_CMD_OFFSET,KERNEL_OPLOCK_BREAK_CMD);
      
-	memcpy(buffer + KERNEL_OPLOCK_BREAK_DEV_OFFSET, (char *)&dev, sizeof(dev));
-	memcpy(buffer + KERNEL_OPLOCK_BREAK_INODE_OFFSET, (char *)&inode, sizeof(inode));	
+	memcpy(buffer + KERNEL_OPLOCK_BREAK_DEV_OFFSET, (char *)&fsp->dev, sizeof(fsp->dev));
+	memcpy(buffer + KERNEL_OPLOCK_BREAK_INODE_OFFSET, (char *)&fsp->inode, sizeof(fsp->inode));	
+	memcpy(buffer + KERNEL_OPLOCK_BREAK_FILEID_OFFSET, (char *)&fsp->file_id, sizeof(fsp->file_id));	
 
  out:
 	/* now we can receive more signals */
@@ -166,10 +165,10 @@ dev = %x, inode = %.0f\n", (unsigned int)dev, (double)inode ));
 	return ret;
 }
 
-
 /****************************************************************************
  Attempt to set an kernel oplock on a file.
 ****************************************************************************/
+
 static BOOL linux_set_kernel_oplock(files_struct *fsp, int oplock_type)
 {
 	if (linux_setlease(fsp->fd, F_WRLCK) == -1) {
@@ -180,16 +179,16 @@ inode = %.0f. (%s)\n",
 		return False;
 	}
 	
-	DEBUG(3,("set_file_oplock: got kernel oplock on file %s, dev = %x, inode = %.0f\n",
-		  fsp->fsp_name, (unsigned int)fsp->dev, (double)fsp->inode));
+	DEBUG(3,("set_file_oplock: got kernel oplock on file %s, dev = %x, inode = %.0f, file_id = %ul\n",
+		  fsp->fsp_name, (unsigned int)fsp->dev, (double)fsp->inode, fsp->file_id));
 
 	return True;
 }
 
-
 /****************************************************************************
  Release a kernel oplock on a file.
 ****************************************************************************/
+
 static void linux_release_kernel_oplock(files_struct *fsp)
 {
 	if (DEBUGLVL(10)) {
@@ -198,9 +197,9 @@ static void linux_release_kernel_oplock(files_struct *fsp)
 		 * oplock state of this file.
 		 */
 		int state = fcntl(fsp->fd, F_GETLEASE, 0);
-		dbgtext("release_kernel_oplock: file %s, dev = %x, inode = %.0f has kernel \
+		dbgtext("release_kernel_oplock: file %s, dev = %x, inode = %.0f file_id = %ul has kernel \
 oplock state of %x.\n", fsp->fsp_name, (unsigned int)fsp->dev,
-                        (double)fsp->inode, state );
+                        (double)fsp->inode, fsp->file_id, state );
 	}
 
 	/*
@@ -209,18 +208,19 @@ oplock state of %x.\n", fsp->fsp_name, (unsigned int)fsp->dev,
 	if (linux_setlease(fsp->fd, F_UNLCK) == -1) {
 		if (DEBUGLVL(0)) {
 			dbgtext("release_kernel_oplock: Error when removing kernel oplock on file " );
-			dbgtext("%s, dev = %x, inode = %.0f. Error was %s\n",
+			dbgtext("%s, dev = %x, inode = %.0f, file_id = %ul. Error was %s\n",
 				fsp->fsp_name, (unsigned int)fsp->dev, 
-				(double)fsp->inode, strerror(errno) );
+				(double)fsp->inode, fsp->file_id, strerror(errno) );
 		}
 	}
 }
 
-
 /****************************************************************************
-parse a kernel oplock message
+ Parse a kernel oplock message.
 ****************************************************************************/
-static BOOL linux_kernel_oplock_parse(char *msg_start, int msg_len, SMB_INO_T *inode, SMB_DEV_T *dev)
+
+static BOOL linux_kernel_oplock_parse(char *msg_start, int msg_len, SMB_INO_T *inode,
+		SMB_DEV_T *dev, unsigned long *file_id)
 {
 	/* Ensure that the msg length is correct. */
 	if (msg_len != KERNEL_OPLOCK_BREAK_MSG_LEN) {
@@ -229,41 +229,44 @@ static BOOL linux_kernel_oplock_parse(char *msg_start, int msg_len, SMB_INO_T *i
 		return False;
 	}
 
-        memcpy((char *)inode, msg_start+KERNEL_OPLOCK_BREAK_INODE_OFFSET, sizeof(*inode));
-        memcpy((char *)dev, msg_start+KERNEL_OPLOCK_BREAK_DEV_OFFSET, sizeof(*dev));
+	memcpy((char *)inode, msg_start+KERNEL_OPLOCK_BREAK_INODE_OFFSET, sizeof(*inode));
+	memcpy((char *)dev, msg_start+KERNEL_OPLOCK_BREAK_DEV_OFFSET, sizeof(*dev));
+	memcpy((char *)file_id, msg_start+KERNEL_OPLOCK_BREAK_FILEID_OFFSET, sizeof(*file_id));
 
-        DEBUG(3,("kernel oplock break request for file dev = %x, inode = %.0f\n", 
-		 (unsigned int)*dev, (double)*inode));
+	DEBUG(3,("kernel oplock break request for file dev = %x, inode = %.0f, file_id = %ul\n", 
+		(unsigned int)*dev, (double)*inode, *file_id));
 
 	return True;
 }
 
-
 /****************************************************************************
-see if a oplock message is waiting
+ See if a oplock message is waiting.
 ****************************************************************************/
+
 static BOOL linux_oplock_msg_waiting(fd_set *fds)
 {
 	return signals_processed != signals_received;
 }
 
 /****************************************************************************
-see if the kernel supports oplocks
+ See if the kernel supports oplocks.
 ****************************************************************************/
+
 static BOOL linux_oplocks_available(void)
 {
 	int fd, ret;
 	fd = open("/dev/null", O_RDONLY);
-	if (fd == -1) return False; /* uggh! */
+	if (fd == -1)
+		return False; /* uggh! */
 	ret = fcntl(fd, F_GETLEASE, 0);
 	close(fd);
 	return ret == F_UNLCK;
 }
 
-
 /****************************************************************************
-setup kernel oplocks
+ Setup kernel oplocks.
 ****************************************************************************/
+
 struct kernel_oplocks *linux_init_kernel_oplocks(void) 
 {
 	static struct kernel_oplocks koplocks;
@@ -274,13 +277,13 @@ struct kernel_oplocks *linux_init_kernel_oplocks(void)
 		return NULL;
 	}
 
-        act.sa_handler = NULL;
-        act.sa_sigaction = signal_handler;
-        act.sa_flags = SA_SIGINFO;
-        if (sigaction(RT_SIGNAL_LEASE, &act, NULL) != 0) {
+	act.sa_handler = NULL;
+	act.sa_sigaction = signal_handler;
+	act.sa_flags = SA_SIGINFO;
+	if (sigaction(RT_SIGNAL_LEASE, &act, NULL) != 0) {
 		DEBUG(0,("Failed to setup RT_SIGNAL_LEASE handler\n"));
 		return NULL;
-        }
+	}
 
 	koplocks.receive_message = linux_oplock_receive_message;
 	koplocks.set_oplock = linux_set_kernel_oplock;
@@ -293,9 +296,6 @@ struct kernel_oplocks *linux_init_kernel_oplocks(void)
 
 	return &koplocks;
 }
-
-
-
 #else
  void oplock_linux_dummy(void) {}
 #endif /* HAVE_KERNEL_OPLOCKS_LINUX */