diff options
Diffstat (limited to 'source3/smbd/oplock.c')
| -rw-r--r-- | source3/smbd/oplock.c | 1619 |
1 files changed, 784 insertions, 835 deletions
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; |