/* Unix SMB/CIFS implementation. 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 the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "includes.h" /* Oplock ipc UDP socket. */ static int oplock_sock = -1; uint16 global_oplock_port = 0; /* Current number of oplocks we have outstanding. */ static int32 exclusive_oplocks_open = 0; static int32 level_II_oplocks_open = 0; BOOL global_client_failed_oplock_break = False; BOOL global_oplock_break = False; extern int smb_read_error; static struct kernel_oplocks *koplocks; 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. ****************************************************************************/ int32 get_number_of_exclusive_open_oplocks(void) { return exclusive_oplocks_open; } /**************************************************************************** Return True if an oplock message is pending. ****************************************************************************/ BOOL oplock_message_waiting(fd_set *fds) { if (koplocks && koplocks->msg_waiting(fds)) return True; if (FD_ISSET(oplock_sock, fds)) return True; return False; } /**************************************************************************** Read an oplock break message from either the oplock UDP fd or the kernel (if kernel oplocks are supported). If timeout is zero then *fds contains the file descriptors that are ready to be read and acted upon. If timeout is non-zero then *fds contains the file descriptors to be selected on for read. The timeout is in milliseconds ****************************************************************************/ BOOL receive_local_message( char *buffer, int buffer_len, int timeout) { struct sockaddr_in from; socklen_t fromlen = sizeof(from); int32 msg_len = 0; fd_set fds; int selrtn = -1; smb_read_error = 0; while (timeout > 0) { struct timeval to; int maxfd = oplock_sock; time_t starttime = time(NULL); FD_ZERO(&fds); maxfd = setup_oplock_select_set(&fds); to.tv_sec = timeout / 1000; to.tv_usec = (timeout % 1000) * 1000; DEBUG(5,("receive_local_message: doing select with timeout of %d ms\n", timeout)); selrtn = sys_select(maxfd+1,&fds,NULL,NULL,&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); } /* Not a kernel interrupt - could be a SIGUSR1 message. We must restart. */ /* We need to decrement the timeout here. */ timeout -= ((time(NULL) - starttime)*1000); if (timeout < 0) timeout = 1; DEBUG(5,("receive_local_message: EINTR : new timeout %d ms\n", timeout)); continue; } /* 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 = sys_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)) return False; fsp->oplock_type = oplock_type; fsp->sent_oplock_break = NO_BREAK_SENT; if (oplock_type == LEVEL_II_OPLOCK) level_II_oplocks_open++; else exclusive_oplocks_open++; 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; } /**************************************************************************** Attempt to release an oplock on a file. Decrements oplock count. ****************************************************************************/ void release_file_oplock(files_struct *fsp) { if (koplocks) koplocks->release_oplock(fsp); if (fsp->oplock_type == LEVEL_II_OPLOCK) level_II_oplocks_open--; else exclusive_oplocks_open--; fsp->oplock_type = NO_OPLOCK; fsp->sent_oplock_break = NO_BREAK_SENT; flush_write_cache(fsp, OPLOCK_RELEASE_FLUSH); } /**************************************************************************** Attempt to downgrade an oplock on a file. Doesn't decrement oplock count. ****************************************************************************/ static void downgrade_file_oplock(files_struct *fsp) { if (koplocks) koplocks->release_oplock(fsp); fsp->oplock_type = LEVEL_II_OPLOCK; exclusive_oplocks_open--; level_II_oplocks_open++; fsp->sent_oplock_break = NO_BREAK_SENT; } /**************************************************************************** Remove a file oplock. Copes with level II and exclusive. Locks then unlocks the share mode lock. Client can decide to go directly to none even if a "break-to-level II" was sent. ****************************************************************************/ BOOL remove_oplock(files_struct *fsp, BOOL break_to_none) { SMB_DEV_T dev = fsp->dev; SMB_INO_T inode = fsp->inode; BOOL ret = True; /* Remove the oplock flag from the sharemode. */ if (lock_share_entry_fsp(fsp) == False) { DEBUG(0,("remove_oplock: failed to lock share entry for file %s\n", fsp->fsp_name )); ret = False; } if (fsp->sent_oplock_break == EXCLUSIVE_BREAK_SENT || break_to_none) { /* * Deal with a reply when a break-to-none was sent. */ if(remove_share_oplock(fsp)==False) { DEBUG(0,("remove_oplock: failed to remove share oplock for file %s fnum %d, \ dev = %x, inode = %.0f\n", fsp->fsp_name, fsp->fnum, (unsigned int)dev, (double)inode)); ret = False; } release_file_oplock(fsp); } else { /* * Deal with a reply when a break-to-level II was sent. */ if(downgrade_share_oplock(fsp)==False) { DEBUG(0,("remove_oplock: failed to downgrade share oplock for file %s fnum %d, \ dev = %x, inode = %.0f\n", fsp->fsp_name, fsp->fnum, (unsigned int)dev, (double)inode)); ret = False; } downgrade_file_oplock(fsp); } unlock_share_entry_fsp(fsp); return ret; } /**************************************************************************** Setup the listening set of file descriptors for an oplock break message either from the UDP socket or from the kernel. Returns the maximum fd used. ****************************************************************************/ int setup_oplock_select_set( fd_set *fds) { int maxfd = oplock_sock; if(oplock_sock == -1) return 0; FD_SET(oplock_sock,fds); if (koplocks && koplocks->notification_fd != -1) { FD_SET(koplocks->notification_fd, fds); maxfd = MAX(maxfd, koplocks->notification_fd); } return maxfd; } /**************************************************************************** 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; 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 \ (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)); 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(sys_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; } /**************************************************************************** Set up an oplock break message. ****************************************************************************/ static void prepare_break_message(char *outbuf, files_struct *fsp, BOOL level2) { memset(outbuf,'\0',smb_size); set_message(outbuf,8,0,True); SCVAL(outbuf,smb_com,SMBlockingX); SSVAL(outbuf,smb_tid,fsp->conn->cnum); SSVAL(outbuf,smb_pid,0xFFFF); SSVAL(outbuf,smb_uid,0); SSVAL(outbuf,smb_mid,0xFFFF); SCVAL(outbuf,smb_vwv0,0xFF); SSVAL(outbuf,smb_vwv2,fsp->fnum); SCVAL(outbuf,smb_vwv3,LOCKING_ANDX_OPLOCK_RELEASE); SCVAL(outbuf,smb_vwv3+1,level2 ? OPLOCKLEVEL_II : OPLOCKLEVEL_NONE); } /**************************************************************************** Function to do the waiting before sending a local break. ****************************************************************************/ static void wait_before_sending_break(BOOL local_request) { extern struct timeval smb_last_time; if(local_request) { struct timeval cur_tv; long wait_left = (long)lp_oplock_break_wait_time(); if (wait_left == 0) return; GetTimeOfDay(&cur_tv); 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); } } } /**************************************************************************** Ensure that we have a valid oplock. ****************************************************************************/ 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 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; } /**************************************************************************** Process a level II oplock break directly. ****************************************************************************/ 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."); } /* * 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, 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, 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."); /* 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; change_to_root_user(); vfs_GetWd(saved_fsp_conn,saved_dir); /* Save the chain fnum. */ file_chain_save(); /* * From Charles Hoch . 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); #if FASCIST_OPLOCK_BACKOFF global_client_failed_oplock_break = True; /* Never grant this client an oplock again. */ #endif } /* * 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; } /**************************************************************************** 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) { 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; } DEBUG(5,("request_oplock_break: breaking our own oplock\n")); #if 1 /* JRA PARANOIA TEST.... */ { 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, 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, file_id = %lu\n", (unsigned int)dev, (double)inode, file_id ); } if(sys_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; if(receive_local_message(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; } /**************************************************************************** Attempt to break an oplock on a file (if oplocked). Returns True if the file was closed as a result of the oplock break, False otherwise. 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)); 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; } /**************************************************************************** This function is called on any file modification or lock request. If a file is level 2 oplocked then it must tell all other level 2 holders to break to none. ****************************************************************************/ void release_level_2_oplocks_on_change(files_struct *fsp) { share_mode_entry *share_list = NULL; pid_t pid = sys_getpid(); int token = -1; int num_share_modes = 0; int i; /* * If this file is level II oplocked then we need * to grab the shared memory lock and inform all * other files with a level II lock that they need * to flush their read caches. We keep the lock over * the shared memory area whilst doing this. */ if (!LEVEL_II_OPLOCK_TYPE(fsp->oplock_type)) return; if (lock_share_entry_fsp(fsp) == False) { DEBUG(0,("release_level_2_oplocks_on_change: failed to lock share mode entry for file %s.\n", fsp->fsp_name )); } num_share_modes = get_share_modes(fsp->conn, fsp->dev, fsp->inode, &share_list); DEBUG(10,("release_level_2_oplocks_on_change: num_share_modes = %d\n", num_share_modes )); for(i = 0; i < num_share_modes; i++) { share_mode_entry *share_entry = &share_list[i]; /* * As there could have been multiple writes waiting at the lock_share_entry * gate we may not be the first to enter. Hence the state of the op_types * in the share mode entries may be partly NO_OPLOCK and partly LEVEL_II * oplock. It will do no harm to re-send break messages to those smbd's * that are still waiting their turn to remove their LEVEL_II state, and * also no harm to ignore existing NO_OPLOCK states. JRA. */ DEBUG(10,("release_level_2_oplocks_on_change: share_entry[%i]->op_type == %d\n", i, share_entry->op_type )); if (share_entry->op_type == NO_OPLOCK) continue; /* Paranoia .... */ if (EXCLUSIVE_OPLOCK_TYPE(share_entry->op_type)) { DEBUG(0,("release_level_2_oplocks_on_change: PANIC. share mode entry %d is an exlusive oplock !\n", i )); unlock_share_entry(fsp->conn, fsp->dev, fsp->inode); abort(); } /* * Check if this is a file we have open (including the * file we've been called to do write_file on. If so * then break it directly without releasing the lock. */ if (pid == share_entry->pid) { files_struct *new_fsp = file_find_dif(share_entry->dev, share_entry->inode, share_entry->share_file_id); /* Paranoia check... */ if(new_fsp == NULL) { DEBUG(0,("release_level_2_oplocks_on_change: PANIC. share mode entry %d is not a local file !\n", i )); unlock_share_entry(fsp->conn, fsp->dev, fsp->inode); abort(); } DEBUG(10,("release_level_2_oplocks_on_change: breaking our own oplock.\n")); oplock_break_level2(new_fsp, True, token); } else { /* * This is a remote file and so we send an asynchronous * message. */ DEBUG(10,("release_level_2_oplocks_on_change: breaking remote oplock.\n")); request_oplock_break(share_entry); } } SAFE_FREE(share_list); unlock_share_entry_fsp(fsp); /* Paranoia check... */ if (LEVEL_II_OPLOCK_TYPE(fsp->oplock_type)) { DEBUG(0,("release_level_2_oplocks_on_change: PANIC. File %s still has a level II oplock.\n", fsp->fsp_name)); smb_panic("release_level_2_oplocks_on_change"); } } /**************************************************************************** setup oplocks for this process ****************************************************************************/ BOOL init_oplocks(void) { struct sockaddr_in sock_name; socklen_t len = sizeof(sock_name); DEBUG(3,("open_oplock_ipc: opening loopback UDP socket.\n")); /* Open a lookback UDP socket on a random port. */ oplock_sock = open_socket_in(SOCK_DGRAM, 0, 0, htonl(INADDR_LOOPBACK),False); if (oplock_sock == -1) { DEBUG(0,("open_oplock_ipc: Failed to get local UDP socket for \ address %lx. Error was %s\n", (long)htonl(INADDR_LOOPBACK), strerror(errno))); global_oplock_port = 0; return(False); } /* Find out the transient UDP port we have been allocated. */ if(getsockname(oplock_sock, (struct sockaddr *)&sock_name, &len)<0) { DEBUG(0,("open_oplock_ipc: Failed to get local UDP port. Error was %s\n", strerror(errno))); close(oplock_sock); oplock_sock = -1; global_oplock_port = 0; return False; } global_oplock_port = ntohs(sock_name.sin_port); if (lp_kernel_oplocks()) { #if HAVE_KERNEL_OPLOCKS_IRIX koplocks = irix_init_kernel_oplocks(); #elif HAVE_KERNEL_OPLOCKS_LINUX koplocks = linux_init_kernel_oplocks(); #endif } DEBUG(3,("open_oplock ipc: pid = %d, global_oplock_port = %u\n", (int)sys_getpid(), global_oplock_port)); return True; }