1/* 2 Unix SMB/CIFS implementation. 3 oplock processing 4 Copyright (C) Andrew Tridgell 1992-1998 5 Copyright (C) Jeremy Allison 1998 - 2001 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 2 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program; if not, write to the Free Software 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 20*/ 21 22#include "includes.h" 23 24/* Oplock ipc UDP socket. */ 25static int oplock_sock = -1; 26uint16 global_oplock_port = 0; 27 28/* Current number of oplocks we have outstanding. */ 29static int32 exclusive_oplocks_open = 0; 30static int32 level_II_oplocks_open = 0; 31BOOL global_client_failed_oplock_break = False; 32BOOL global_oplock_break = False; 33 34extern int smb_read_error; 35 36static struct kernel_oplocks *koplocks; 37 38static BOOL oplock_break(SMB_DEV_T dev, SMB_INO_T inode, unsigned long file_id, BOOL local); 39 40/**************************************************************************** 41 Get the number of current exclusive oplocks. 42****************************************************************************/ 43 44int32 get_number_of_exclusive_open_oplocks(void) 45{ 46 return exclusive_oplocks_open; 47} 48 49/**************************************************************************** 50 Return True if an oplock message is pending. 51****************************************************************************/ 52 53BOOL oplock_message_waiting(fd_set *fds) 54{ 55 if (koplocks && koplocks->msg_waiting(fds)) 56 return True; 57 58 if (FD_ISSET(oplock_sock, fds)) 59 return True; 60 61 return False; 62} 63 64/**************************************************************************** 65 Read an oplock break message from either the oplock UDP fd or the 66 kernel (if kernel oplocks are supported). 67 68 If timeout is zero then *fds contains the file descriptors that 69 are ready to be read and acted upon. If timeout is non-zero then 70 *fds contains the file descriptors to be selected on for read. 71 The timeout is in milliseconds 72 73****************************************************************************/ 74 75BOOL receive_local_message( char *buffer, int buffer_len, int timeout) 76{ 77 struct sockaddr_in from; 78 socklen_t fromlen = sizeof(from); 79 int32 msg_len = 0; 80 fd_set fds; 81 int selrtn = -1; 82 83 FD_ZERO(&fds); 84 smb_read_error = 0; 85 86 /* 87 * We need to check for kernel oplocks before going into the select 88 * here, as the EINTR generated by the linux kernel oplock may have 89 * already been eaten. JRA. 90 */ 91 92 if (koplocks && koplocks->msg_waiting(&fds)) { 93 return koplocks->receive_message(&fds, buffer, buffer_len); 94 } 95 96 while (timeout > 0 && selrtn == -1) { 97 struct timeval to; 98 int maxfd = oplock_sock; 99 time_t starttime = time(NULL); 100 101 FD_ZERO(&fds); 102 maxfd = setup_oplock_select_set(&fds); 103 104 to.tv_sec = timeout / 1000; 105 to.tv_usec = (timeout % 1000) * 1000; 106 107 DEBUG(5,("receive_local_message: doing select with timeout of %d ms\n", timeout)); 108 109 selrtn = sys_select(maxfd+1,&fds,NULL,NULL,&to); 110 111 if (selrtn == -1 && errno == EINTR) { 112 113 /* could be a kernel oplock interrupt */ 114 if (koplocks && koplocks->msg_waiting(&fds)) { 115 return koplocks->receive_message(&fds, buffer, buffer_len); 116 } 117 118 /* 119 * Linux 2.0.x seems to have a bug in that 120 * it can return -1, EINTR with a timeout of zero. 121 * Make sure we bail out here with a read timeout 122 * if we got EINTR on a timeout of 1 or less. 123 */ 124 125 if (timeout <= 1) { 126 smb_read_error = READ_TIMEOUT; 127 return False; 128 } 129 130 /* Not a kernel interrupt - could be a SIGUSR1 message. We must restart. */ 131 /* We need to decrement the timeout here. */ 132 timeout -= ((time(NULL) - starttime)*1000); 133 if (timeout < 0) 134 timeout = 1; 135 136 DEBUG(5,("receive_local_message: EINTR : new timeout %d ms\n", timeout)); 137 continue; 138 } 139 140 /* Check if error */ 141 if(selrtn == -1) { 142 /* something is wrong. Maybe the socket is dead? */ 143 smb_read_error = READ_ERROR; 144 return False; 145 } 146 147 /* Did we timeout ? */ 148 if (selrtn == 0) { 149 smb_read_error = READ_TIMEOUT; 150 return False; 151 } 152 } 153 154 if (koplocks && koplocks->msg_waiting(&fds)) { 155 return koplocks->receive_message(&fds, buffer, buffer_len); 156 } 157 158 if (!FD_ISSET(oplock_sock, &fds)) 159 return False; 160 161 /* 162 * From here down we deal with the smbd <--> smbd 163 * oplock break protocol only. 164 */ 165 166 /* 167 * Read a loopback udp message. 168 */ 169 msg_len = sys_recvfrom(oplock_sock, &buffer[OPBRK_CMD_HEADER_LEN], 170 buffer_len - OPBRK_CMD_HEADER_LEN, 0, (struct sockaddr *)&from, &fromlen); 171 172 if(msg_len < 0) { 173 DEBUG(0,("receive_local_message. Error in recvfrom. (%s).\n",strerror(errno))); 174 return False; 175 } 176 177 /* Validate message length. */ 178 if(msg_len > (buffer_len - OPBRK_CMD_HEADER_LEN)) { 179 DEBUG(0,("receive_local_message: invalid msg_len (%d) max can be %d\n", msg_len, 180 buffer_len - OPBRK_CMD_HEADER_LEN)); 181 return False; 182 } 183 184 /* Validate message from address (must be localhost). */ 185 if(from.sin_addr.s_addr != htonl(INADDR_LOOPBACK)) { 186 DEBUG(0,("receive_local_message: invalid 'from' address \ 187(was %lx should be 127.0.0.1)\n", (long)from.sin_addr.s_addr)); 188 return False; 189 } 190 191 /* Setup the message header */ 192 SIVAL(buffer,OPBRK_CMD_LEN_OFFSET,msg_len); 193 SSVAL(buffer,OPBRK_CMD_PORT_OFFSET,ntohs(from.sin_port)); 194 195 return True; 196} 197 198/**************************************************************************** 199 Attempt to set an oplock on a file. Always succeeds if kernel oplocks are 200 disabled (just sets flags). Returns True if oplock set. 201****************************************************************************/ 202 203BOOL set_file_oplock(files_struct *fsp, int oplock_type) 204{ 205 if (koplocks && !koplocks->set_oplock(fsp, oplock_type)) 206 return False; 207 208 fsp->oplock_type = oplock_type; 209 fsp->sent_oplock_break = NO_BREAK_SENT; 210 if (oplock_type == LEVEL_II_OPLOCK) 211 level_II_oplocks_open++; 212 else 213 exclusive_oplocks_open++; 214 215 DEBUG(5,("set_file_oplock: granted oplock on file %s, dev = %x, inode = %.0f, file_id = %lu, \ 216tv_sec = %x, tv_usec = %x\n", 217 fsp->fsp_name, (unsigned int)fsp->dev, (double)fsp->inode, fsp->file_id, 218 (int)fsp->open_time.tv_sec, (int)fsp->open_time.tv_usec )); 219 220 return True; 221} 222 223/**************************************************************************** 224 Attempt to release an oplock on a file. Decrements oplock count. 225****************************************************************************/ 226 227void release_file_oplock(files_struct *fsp) 228{ 229 if ((fsp->oplock_type != NO_OPLOCK) && koplocks) 230 koplocks->release_oplock(fsp); 231 232 if (fsp->oplock_type == LEVEL_II_OPLOCK) 233 level_II_oplocks_open--; 234 else if (fsp->oplock_type) 235 exclusive_oplocks_open--; 236 237 fsp->oplock_type = NO_OPLOCK; 238 fsp->sent_oplock_break = NO_BREAK_SENT; 239 240 flush_write_cache(fsp, OPLOCK_RELEASE_FLUSH); 241} 242 243/**************************************************************************** 244 Attempt to downgrade an oplock on a file. Doesn't decrement oplock count. 245****************************************************************************/ 246 247static void downgrade_file_oplock(files_struct *fsp) 248{ 249 if (koplocks) 250 koplocks->release_oplock(fsp); 251 fsp->oplock_type = LEVEL_II_OPLOCK; 252 exclusive_oplocks_open--; 253 level_II_oplocks_open++; 254 fsp->sent_oplock_break = NO_BREAK_SENT; 255} 256 257/**************************************************************************** 258 Remove a file oplock. Copes with level II and exclusive. 259 Locks then unlocks the share mode lock. Client can decide to go directly 260 to none even if a "break-to-level II" was sent. 261****************************************************************************/ 262 263BOOL remove_oplock(files_struct *fsp, BOOL break_to_none) 264{ 265 SMB_DEV_T dev = fsp->dev; 266 SMB_INO_T inode = fsp->inode; 267 BOOL ret = True; 268 269 /* Remove the oplock flag from the sharemode. */ 270 if (lock_share_entry_fsp(fsp) == False) { 271 DEBUG(0,("remove_oplock: failed to lock share entry for file %s\n", 272 fsp->fsp_name )); 273 return False; 274 } 275 276 if (fsp->sent_oplock_break == EXCLUSIVE_BREAK_SENT || break_to_none) { 277 /* 278 * Deal with a reply when a break-to-none was sent. 279 */ 280 281 if(remove_share_oplock(fsp)==False) { 282 DEBUG(0,("remove_oplock: failed to remove share oplock for file %s fnum %d, \ 283dev = %x, inode = %.0f\n", fsp->fsp_name, fsp->fnum, (unsigned int)dev, (double)inode)); 284 ret = False; 285 } 286 287 release_file_oplock(fsp); 288 } else { 289 /* 290 * Deal with a reply when a break-to-level II was sent. 291 */ 292 if(downgrade_share_oplock(fsp)==False) { 293 DEBUG(0,("remove_oplock: failed to downgrade share oplock for file %s fnum %d, \ 294dev = %x, inode = %.0f\n", fsp->fsp_name, fsp->fnum, (unsigned int)dev, (double)inode)); 295 ret = False; 296 } 297 298 downgrade_file_oplock(fsp); 299 } 300 301 unlock_share_entry_fsp(fsp); 302 return ret; 303} 304 305/**************************************************************************** 306 Setup the listening set of file descriptors for an oplock break 307 message either from the UDP socket or from the kernel. Returns the maximum 308 fd used. 309****************************************************************************/ 310 311int setup_oplock_select_set( fd_set *fds) 312{ 313 int maxfd = oplock_sock; 314 315 if(oplock_sock == -1) 316 return 0; 317 318 FD_SET(oplock_sock,fds); 319 320 if (koplocks && koplocks->notification_fd != -1) { 321 FD_SET(koplocks->notification_fd, fds); 322 maxfd = MAX(maxfd, koplocks->notification_fd); 323 } 324 325 return maxfd; 326} 327 328/**************************************************************************** 329 Process an oplock break message - whether it came from the UDP socket 330 or from the kernel. 331****************************************************************************/ 332 333BOOL process_local_message(char *buffer, int buf_size) 334{ 335 int32 msg_len; 336 uint16 from_port; 337 char *msg_start; 338 pid_t remotepid; 339 SMB_DEV_T dev; 340 SMB_INO_T inode; 341 unsigned long file_id; 342 uint16 break_cmd_type; 343 344 msg_len = IVAL(buffer,OPBRK_CMD_LEN_OFFSET); 345 from_port = SVAL(buffer,OPBRK_CMD_PORT_OFFSET); 346 347 msg_start = &buffer[OPBRK_CMD_HEADER_LEN]; 348 349 DEBUG(5,("process_local_message: Got a message of length %d from port (%d)\n", 350 msg_len, from_port)); 351 352 /* 353 * Pull the info out of the requesting packet. 354 */ 355 356 break_cmd_type = SVAL(msg_start,OPBRK_MESSAGE_CMD_OFFSET); 357 358 switch(break_cmd_type) { 359 case KERNEL_OPLOCK_BREAK_CMD: 360 if (!koplocks) { 361 DEBUG(0,("unexpected kernel oplock break!\n")); 362 break; 363 } 364 if (!koplocks->parse_message(msg_start, msg_len, &inode, &dev, &file_id)) { 365 DEBUG(0,("kernel oplock break parse failure!\n")); 366 } 367 break; 368 369 case OPLOCK_BREAK_CMD: 370 case LEVEL_II_OPLOCK_BREAK_CMD: 371 case ASYNC_LEVEL_II_OPLOCK_BREAK_CMD: 372 373 /* Ensure that the msg length is correct. */ 374 if(msg_len != OPLOCK_BREAK_MSG_LEN) { 375 DEBUG(0,("process_local_message: incorrect length for OPLOCK_BREAK_CMD (was %d, should be %d).\n", 376 (int)msg_len, (int)OPLOCK_BREAK_MSG_LEN)); 377 return False; 378 } 379 380 memcpy((char *)&remotepid, msg_start+OPLOCK_BREAK_PID_OFFSET,sizeof(remotepid)); 381 memcpy((char *)&inode, msg_start+OPLOCK_BREAK_INODE_OFFSET,sizeof(inode)); 382 memcpy((char *)&dev, msg_start+OPLOCK_BREAK_DEV_OFFSET,sizeof(dev)); 383 memcpy((char *)&file_id, msg_start+OPLOCK_BREAK_FILEID_OFFSET,sizeof(file_id)); 384 385 DEBUG(5,("process_local_message: (%s) oplock break request from \ 386pid %d, port %d, dev = %x, inode = %.0f, file_id = %lu\n", 387 (break_cmd_type == OPLOCK_BREAK_CMD) ? "exclusive" : "level II", 388 (int)remotepid, from_port, (unsigned int)dev, (double)inode, file_id)); 389 break; 390 391 case RETRY_DEFERRED_OPEN_CMD: 392 393 /* Request to retry and open that would return SHARING_VIOLATION. */ 394 if (msg_len != DEFERRED_OPEN_MSG_LEN) { 395 DEBUG(0,("process_local_message: incorrect length for RETRY_DEFERRED_OPEN_CMD (was %d, should be %d).\n", 396 (int)msg_len, (int)DEFERRED_OPEN_MSG_LEN)); 397 return False; 398 } 399 { 400 uint16 mid; 401 402 memcpy((char *)&remotepid, msg_start+DEFERRED_OPEN_PID_OFFSET,sizeof(remotepid)); 403 memcpy((char *)&inode, msg_start+DEFERRED_OPEN_INODE_OFFSET,sizeof(inode)); 404 memcpy((char *)&dev, msg_start+DEFERRED_OPEN_DEV_OFFSET,sizeof(dev)); 405 memcpy((char *)&mid, msg_start+DEFERRED_OPEN_MID_OFFSET,sizeof(mid)); 406 407 DEBUG(5,("process_local_message: RETRY_DEFERRED_OPEN from \ 408pid %d, port %d, dev = %x, inode = %.0f, mid = %u\n", 409 (int)remotepid, from_port, (unsigned int)dev, (double)inode, (unsigned int)mid)); 410 411 schedule_sharing_violation_open_smb_message(mid); 412 } 413 return True; 414 415 /* 416 * Keep this as a debug case - eventually we can remove it. 417 */ 418 case 0x8001: 419 DEBUG(0,("process_local_message: Received unsolicited break \ 420reply - dumping info.\n")); 421 422 if(msg_len != OPLOCK_BREAK_MSG_LEN) { 423 DEBUG(0,("process_local_message: ubr: incorrect length for reply \ 424(was %d, should be %d).\n", (int)msg_len, (int)OPLOCK_BREAK_MSG_LEN)); 425 return False; 426 } 427 428 memcpy((char *)&inode, msg_start+OPLOCK_BREAK_INODE_OFFSET,sizeof(inode)); 429 memcpy((char *)&remotepid, msg_start+OPLOCK_BREAK_PID_OFFSET,sizeof(remotepid)); 430 memcpy((char *)&dev, msg_start+OPLOCK_BREAK_DEV_OFFSET,sizeof(dev)); 431 memcpy((char *)&file_id, msg_start+OPLOCK_BREAK_FILEID_OFFSET,sizeof(file_id)); 432 433 DEBUG(0,("process_local_message: unsolicited oplock break reply from \ 434pid %d, port %d, dev = %x, inode = %.0f, file_id = %lu\n", 435 (int)remotepid, from_port, (unsigned int)dev, (double)inode, file_id)); 436 437 return False; 438 439 default: 440 DEBUG(0,("process_local_message: unknown UDP message command code (%x) - ignoring.\n", 441 (unsigned int)SVAL(msg_start,0))); 442 return False; 443 } 444 445 /* 446 * Now actually process the break request. 447 */ 448 449 if((exclusive_oplocks_open + level_II_oplocks_open) != 0) { 450 if (oplock_break(dev, inode, file_id, False) == False) { 451 DEBUG(0,("process_local_message: oplock break failed.\n")); 452 return False; 453 } 454 } else { 455 /* 456 * If we have no record of any currently open oplocks, 457 * it's not an error, as a close command may have 458 * just been issued on the file that was oplocked. 459 * Just log a message and return success in this case. 460 */ 461 DEBUG(3,("process_local_message: oplock break requested with no outstanding \ 462oplocks. Returning success.\n")); 463 } 464 465 /* 466 * Do the appropriate reply - none in the kernel or async level II case. 467 */ 468 469 if(break_cmd_type == OPLOCK_BREAK_CMD || break_cmd_type == LEVEL_II_OPLOCK_BREAK_CMD) { 470 struct sockaddr_in toaddr; 471 472 /* Send the message back after OR'ing in the 'REPLY' bit. */ 473 SSVAL(msg_start,OPBRK_MESSAGE_CMD_OFFSET,break_cmd_type | CMD_REPLY); 474 475 memset((char *)&toaddr,'\0',sizeof(toaddr)); 476 toaddr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); 477 toaddr.sin_port = htons(from_port); 478 toaddr.sin_family = AF_INET; 479 480 if(sys_sendto( oplock_sock, msg_start, OPLOCK_BREAK_MSG_LEN, 0, 481 (struct sockaddr *)&toaddr, sizeof(toaddr)) < 0) { 482 DEBUG(0,("process_local_message: sendto process %d failed. Errno was %s\n", 483 (int)remotepid, strerror(errno))); 484 return False; 485 } 486 487 DEBUG(5,("process_local_message: oplock break reply sent to \ 488pid %d, port %d, for file dev = %x, inode = %.0f, file_id = %lu\n", 489 (int)remotepid, from_port, (unsigned int)dev, (double)inode, file_id)); 490 } 491 492 return True; 493} 494 495/**************************************************************************** 496 Set up an oplock break message. 497****************************************************************************/ 498 499static void prepare_break_message(char *outbuf, files_struct *fsp, BOOL level2) 500{ 501 memset(outbuf,'\0',smb_size); 502 set_message(outbuf,8,0,True); 503 504 SCVAL(outbuf,smb_com,SMBlockingX); 505 SSVAL(outbuf,smb_tid,fsp->conn->cnum); 506 SSVAL(outbuf,smb_pid,0xFFFF); 507 SSVAL(outbuf,smb_uid,0); 508 SSVAL(outbuf,smb_mid,0xFFFF); 509 SCVAL(outbuf,smb_vwv0,0xFF); 510 SSVAL(outbuf,smb_vwv2,fsp->fnum); 511 SCVAL(outbuf,smb_vwv3,LOCKING_ANDX_OPLOCK_RELEASE); 512 SCVAL(outbuf,smb_vwv3+1,level2 ? OPLOCKLEVEL_II : OPLOCKLEVEL_NONE); 513} 514 515/**************************************************************************** 516 Function to do the waiting before sending a local break. 517****************************************************************************/ 518 519static void wait_before_sending_break(BOOL local_request) 520{ 521 extern struct timeval smb_last_time; 522 523 if(local_request) { 524 struct timeval cur_tv; 525 long wait_left = (long)lp_oplock_break_wait_time(); 526 527 if (wait_left == 0) 528 return; 529 530 GetTimeOfDay(&cur_tv); 531 532 wait_left -= ((cur_tv.tv_sec - smb_last_time.tv_sec)*1000) + 533 ((cur_tv.tv_usec - smb_last_time.tv_usec)/1000); 534 535 if(wait_left > 0) { 536 wait_left = MIN(wait_left, 1000); 537 sys_usleep(wait_left * 1000); 538 } 539 } 540} 541 542/**************************************************************************** 543 Ensure that we have a valid oplock. 544****************************************************************************/ 545 546static files_struct *initial_break_processing(SMB_DEV_T dev, SMB_INO_T inode, unsigned long file_id) 547{ 548 files_struct *fsp = NULL; 549 550 if( DEBUGLVL( 3 ) ) { 551 dbgtext( "initial_break_processing: called for dev = %x, inode = %.0f file_id = %lu\n", 552 (unsigned int)dev, (double)inode, file_id); 553 dbgtext( "Current oplocks_open (exclusive = %d, levelII = %d)\n", 554 exclusive_oplocks_open, level_II_oplocks_open ); 555 } 556 557 /* 558 * We need to search the file open table for the 559 * entry containing this dev and inode, and ensure 560 * we have an oplock on it. 561 */ 562 563 fsp = file_find_dif(dev, inode, file_id); 564 565 if(fsp == NULL) { 566 /* The file could have been closed in the meantime - return success. */ 567 if( DEBUGLVL( 3 ) ) { 568 dbgtext( "initial_break_processing: cannot find open file with " ); 569 dbgtext( "dev = %x, inode = %.0f file_id = %lu", (unsigned int)dev, 570 (double)inode, file_id); 571 dbgtext( "allowing break to succeed.\n" ); 572 } 573 return NULL; 574 } 575 576 /* Ensure we have an oplock on the file */ 577 578 /* 579 * There is a potential race condition in that an oplock could 580 * have been broken due to another udp request, and yet there are 581 * still oplock break messages being sent in the udp message 582 * queue for this file. So return true if we don't have an oplock, 583 * as we may have just freed it. 584 */ 585 586 if(fsp->oplock_type == NO_OPLOCK) { 587 if( DEBUGLVL( 3 ) ) { 588 dbgtext( "initial_break_processing: file %s ", fsp->fsp_name ); 589 dbgtext( "(dev = %x, inode = %.0f, file_id = %lu) has no oplock.\n", 590 (unsigned int)dev, (double)inode, fsp->file_id ); 591 dbgtext( "Allowing break to succeed regardless.\n" ); 592 } 593 return NULL; 594 } 595 596 return fsp; 597} 598 599/**************************************************************************** 600 Process a level II oplock break directly. 601 We must call this function with the share mode entry locked. 602****************************************************************************/ 603 604static BOOL oplock_break_level2(files_struct *fsp, BOOL local_request) 605{ 606 extern uint32 global_client_caps; 607 char outbuf[128]; 608 SMB_DEV_T dev = fsp->dev; 609 SMB_INO_T inode = fsp->inode; 610 611 /* 612 * We can have a level II oplock even if the client is not 613 * level II oplock aware. In this case just remove the 614 * flags and don't send the break-to-none message to 615 * the client. 616 */ 617 618 if (global_client_caps & CAP_LEVEL_II_OPLOCKS) { 619 BOOL sign_state; 620 621 /* 622 * If we are sending an oplock break due to an SMB sent 623 * by our own client we ensure that we wait at leat 624 * lp_oplock_break_wait_time() milliseconds before sending 625 * the packet. Sending the packet sooner can break Win9x 626 * and has reported to cause problems on NT. JRA. 627 */ 628 629 wait_before_sending_break(local_request); 630 631 /* Prepare the SMBlockingX message. */ 632 prepare_break_message( outbuf, fsp, False); 633 634 /* Save the server smb signing state. */ 635 sign_state = srv_oplock_set_signing(False); 636 637 if (!send_smb(smbd_server_fd(), outbuf)) 638 exit_server("oplock_break_level2: send_smb failed."); 639 640 /* Restore the sign state to what it was. */ 641 srv_oplock_set_signing(sign_state); 642 } 643 644 /* 645 * Now we must update the shared memory structure to tell 646 * everyone else we no longer have a level II oplock on 647 * this open file. We must call this function with the share mode 648 * entry locked so we can change the entry directly. 649 */ 650 651 if(remove_share_oplock(fsp)==False) { 652 DEBUG(0,("oplock_break_level2: unable to remove level II oplock for file %s\n", fsp->fsp_name )); 653 } 654 655 release_file_oplock(fsp); 656 657 if(level_II_oplocks_open < 0) { 658 DEBUG(0,("oplock_break_level2: level_II_oplocks_open < 0 (%d). PANIC ERROR\n", 659 level_II_oplocks_open)); 660 abort(); 661 } 662 663 if( DEBUGLVL( 3 ) ) { 664 dbgtext( "oplock_break_level2: returning success for " ); 665 dbgtext( "dev = %x, inode = %.0f, file_id = %lu\n", (unsigned int)dev, (double)inode, fsp->file_id ); 666 dbgtext( "Current level II oplocks_open = %d\n", level_II_oplocks_open ); 667 } 668 669 return True; 670} 671 672/**************************************************************************** 673 Process an oplock break directly. 674 This is always called with the share mode lock *NOT* held. 675****************************************************************************/ 676 677static BOOL oplock_break(SMB_DEV_T dev, SMB_INO_T inode, unsigned long file_id, BOOL local_request) 678{ 679 extern uint32 global_client_caps; 680 extern struct current_user current_user; 681 char *inbuf = NULL; 682 char *outbuf = NULL; 683 files_struct *fsp = NULL; 684 time_t start_time; 685 BOOL shutdown_server = False; 686 BOOL oplock_timeout = False; 687 BOOL sign_state; 688 connection_struct *saved_user_conn; 689 connection_struct *saved_fsp_conn; 690 int saved_vuid; 691 pstring saved_dir; 692 int timeout = (OPLOCK_BREAK_TIMEOUT * 1000); 693 pstring file_name; 694 BOOL using_levelII; 695 696 if((fsp = initial_break_processing(dev, inode, file_id)) == NULL) 697 return True; 698 699 /* 700 * Deal with a level II oplock going break to none separately. 701 */ 702 703 if (LEVEL_II_OPLOCK_TYPE(fsp->oplock_type)) { 704 BOOL ret; 705 /* We must always call oplock_break_level2() with 706 the share mode entry locked. */ 707 if (lock_share_entry_fsp(fsp) == False) { 708 DEBUG(0,("oplock_break: unable to lock share entry for file %s\n", fsp->fsp_name )); 709 return False; 710 } 711 ret = oplock_break_level2(fsp, local_request); 712 unlock_share_entry_fsp(fsp); 713 return ret; 714 } 715 716 /* Mark the oplock break as sent - we don't want to send twice! */ 717 if (fsp->sent_oplock_break) { 718 if( DEBUGLVL( 0 ) ) { 719 dbgtext( "oplock_break: ERROR: oplock_break already sent for " ); 720 dbgtext( "file %s ", fsp->fsp_name); 721 dbgtext( "(dev = %x, inode = %.0f, file_id = %lu)\n", (unsigned int)dev, (double)inode, fsp->file_id ); 722 } 723 724 /* 725 * We have to fail the open here as we cannot send another oplock break on 726 * this file whilst we are awaiting a response from the client - neither 727 * can we allow another open to succeed while we are waiting for the client. 728 */ 729 return False; 730 } 731 732 if(global_oplock_break) { 733 DEBUG(0,("ABORT : ABORT : recursion in oplock_break !!!!!\n")); 734 abort(); 735 } 736 737 /* 738 * Now comes the horrid part. We must send an oplock break to the client, 739 * and then process incoming messages until we get a close or oplock release. 740 * At this point we know we need a new inbuf/outbuf buffer pair. 741 * We cannot use these staticaly as we may recurse into here due to 742 * messages crossing on the wire. 743 */ 744 745 if((inbuf = (char *)SMB_MALLOC(BUFFER_SIZE + LARGE_WRITEX_HDR_SIZE + SAFETY_MARGIN))==NULL) { 746 DEBUG(0,("oplock_break: malloc fail for input buffer.\n")); 747 return False; 748 } 749 750 if((outbuf = (char *)SMB_MALLOC(BUFFER_SIZE + LARGE_WRITEX_HDR_SIZE + SAFETY_MARGIN))==NULL) { 751 DEBUG(0,("oplock_break: malloc fail for output buffer.\n")); 752 SAFE_FREE(inbuf); 753 return False; 754 } 755 756 /* 757 * If we are sending an oplock break due to an SMB sent 758 * by our own client we ensure that we wait at leat 759 * lp_oplock_break_wait_time() milliseconds before sending 760 * the packet. Sending the packet sooner can break Win9x 761 * and has reported to cause problems on NT. JRA. 762 */ 763 764 wait_before_sending_break(local_request); 765 766 /* Prepare the SMBlockingX message. */ 767 768 if ((global_client_caps & CAP_LEVEL_II_OPLOCKS) && 769 !koplocks && /* NOTE: we force levelII off for kernel oplocks - this will change when it is supported */ 770 lp_level2_oplocks(SNUM(fsp->conn))) { 771 using_levelII = True; 772 } else { 773 using_levelII = False; 774 } 775 776 prepare_break_message( outbuf, fsp, using_levelII); 777 /* Remember if we just sent a break to level II on this file. */ 778 fsp->sent_oplock_break = using_levelII? LEVEL_II_BREAK_SENT:EXCLUSIVE_BREAK_SENT; 779 780 /* Save the server smb signing state. */ 781 sign_state = srv_oplock_set_signing(False); 782 783 if (!send_smb(smbd_server_fd(), outbuf)) { 784 srv_oplock_set_signing(sign_state); 785 exit_server("oplock_break: send_smb failed."); 786 } 787 788 /* Restore the sign state to what it was. */ 789 srv_oplock_set_signing(sign_state); 790 791 /* We need this in case a readraw crosses on the wire. */ 792 global_oplock_break = True; 793 794 /* Process incoming messages. */ 795 796 /* 797 * JRA - If we don't get a break from the client in OPLOCK_BREAK_TIMEOUT 798 * seconds we should just die.... 799 */ 800 801 start_time = time(NULL); 802 803 /* 804 * Save the information we need to re-become the 805 * user, then unbecome the user whilst we're doing this. 806 */ 807 saved_user_conn = current_user.conn; 808 saved_vuid = current_user.vuid; 809 saved_fsp_conn = fsp->conn; 810 change_to_root_user(); 811 vfs_GetWd(saved_fsp_conn,saved_dir); 812 /* Save the chain fnum. */ 813 file_chain_save(); 814 815 /* 816 * From Charles Hoch <hoch@exemplary.com>. If the break processing 817 * code closes the file (as it often does), then the fsp pointer here 818 * points to free()'d memory. We *must* revalidate fsp each time 819 * around the loop. 820 */ 821 822 pstrcpy(file_name, fsp->fsp_name); 823 824 while((fsp = initial_break_processing(dev, inode, file_id)) && 825 OPEN_FSP(fsp) && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) { 826 if(receive_smb(smbd_server_fd(),inbuf, timeout) == False) { 827 /* 828 * Die if we got an error. 829 */ 830 831 if (smb_read_error == READ_EOF) { 832 DEBUG( 0, ( "oplock_break: end of file from client\n" ) ); 833 shutdown_server = True; 834 } else if (smb_read_error == READ_ERROR) { 835 DEBUG( 0, ("oplock_break: receive_smb error (%s)\n", strerror(errno)) ); 836 shutdown_server = True; 837 } else if (smb_read_error == READ_BAD_SIG) { 838 DEBUG( 0, ("oplock_break: bad signature from client\n" )); 839 shutdown_server = True; 840 } else if (smb_read_error == READ_TIMEOUT) { 841 DEBUG( 0, ( "oplock_break: receive_smb timed out after %d seconds.\n", OPLOCK_BREAK_TIMEOUT ) ); 842 oplock_timeout = True; 843 } 844 845 DEBUGADD( 0, ( "oplock_break failed for file %s ", file_name ) ); 846 DEBUGADD( 0, ( "(dev = %x, inode = %.0f, file_id = %lu).\n", 847 (unsigned int)dev, (double)inode, file_id)); 848 849 break; 850 } 851 852 /* 853 * There are certain SMB requests that we shouldn't allow 854 * to recurse. opens, renames and deletes are the obvious 855 * ones. This is handled in the switch_message() function. 856 * If global_oplock_break is set they will push the packet onto 857 * the pending smb queue and return -1 (no reply). 858 * JRA. 859 */ 860 861 process_smb(inbuf, outbuf); 862 863 /* 864 * Die if we go over the time limit. 865 */ 866 867 if((time(NULL) - start_time) > OPLOCK_BREAK_TIMEOUT) { 868 if( DEBUGLVL( 0 ) ) { 869 dbgtext( "oplock_break: no break received from client " ); 870 dbgtext( "within %d seconds.\n", OPLOCK_BREAK_TIMEOUT ); 871 dbgtext( "oplock_break failed for file %s ", fsp->fsp_name ); 872 dbgtext( "(dev = %x, inode = %.0f, file_id = %lu).\n", 873 (unsigned int)dev, (double)inode, file_id ); 874 } 875 oplock_timeout = True; 876 break; 877 } 878 } 879 880 /* 881 * Go back to being the user who requested the oplock 882 * break. 883 */ 884 if((saved_user_conn != NULL) && (saved_vuid != UID_FIELD_INVALID) && !change_to_user(saved_user_conn, saved_vuid)) { 885 DEBUG( 0, ( "oplock_break: unable to re-become user!" ) ); 886 DEBUGADD( 0, ( "Shutting down server\n" ) ); 887 close(oplock_sock); 888 exit_server("unable to re-become user"); 889 } 890 891 /* Including the directory. */ 892 vfs_ChDir(saved_fsp_conn,saved_dir); 893 894 /* Restore the chain fnum. */ 895 file_chain_restore(); 896 897 /* Free the buffers we've been using to recurse. */ 898 SAFE_FREE(inbuf); 899 SAFE_FREE(outbuf); 900 901 /* We need this in case a readraw crossed on the wire. */ 902 if(global_oplock_break) 903 global_oplock_break = False; 904 905 /* 906 * If the client timed out then clear the oplock (or go to level II) 907 * and continue. This seems to be what NT does and is better than dropping 908 * the connection. 909 */ 910 911 if(oplock_timeout && (fsp = initial_break_processing(dev, inode, file_id)) && 912 OPEN_FSP(fsp) && EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type)) { 913 DEBUG(0,("oplock_break: client failure in oplock break in file %s\n", fsp->fsp_name)); 914 remove_oplock(fsp,True); 915#if FASCIST_OPLOCK_BACKOFF 916 global_client_failed_oplock_break = True; /* Never grant this client an oplock again. */ 917#endif 918 } 919 920 /* 921 * If the client had an error we must die. 922 */ 923 924 if(shutdown_server) { 925 DEBUG( 0, ( "oplock_break: client failure in break - " ) ); 926 DEBUGADD( 0, ( "shutting down this smbd.\n" ) ); 927 close(oplock_sock); 928 exit_server("oplock break failure"); 929 } 930 931 /* Santity check - remove this later. JRA */ 932 if(exclusive_oplocks_open < 0) { 933 DEBUG(0,("oplock_break: exclusive_oplocks_open < 0 (%d). PANIC ERROR\n", exclusive_oplocks_open)); 934 abort(); 935 } 936 937 if( DEBUGLVL( 3 ) ) { 938 dbgtext( "oplock_break: returning success for " ); 939 dbgtext( "dev = %x, inode = %.0f, file_id = %lu\n", (unsigned int)dev, (double)inode, file_id ); 940 dbgtext( "Current exclusive_oplocks_open = %d\n", exclusive_oplocks_open ); 941 } 942 943 return True; 944} 945 946/**************************************************************************** 947 Send an oplock break message to another smbd process. If the oplock is held 948 by the local smbd then call the oplock break function directly. 949 This function is called with no share locks held. 950****************************************************************************/ 951 952BOOL request_oplock_break(share_mode_entry *share_entry) 953{ 954 char op_break_msg[OPLOCK_BREAK_MSG_LEN]; 955 struct sockaddr_in addr_out; 956 pid_t pid = sys_getpid(); 957 time_t start_time; 958 int time_left; 959 SMB_DEV_T dev = share_entry->dev; 960 SMB_INO_T inode = share_entry->inode; 961 unsigned long file_id = share_entry->share_file_id; 962 uint16 break_cmd_type; 963 964 if(pid == share_entry->pid) { 965 /* We are breaking our own oplock, make sure it's us. */ 966 if(share_entry->op_port != global_oplock_port) { 967 DEBUG(0,("request_oplock_break: corrupt share mode entry - pid = %d, port = %d \ 968should be %d\n", (int)pid, share_entry->op_port, global_oplock_port)); 969 return False; 970 } 971 972 DEBUG(5,("request_oplock_break: breaking our own oplock\n")); 973 974#if 1 /* JRA PARANOIA TEST.... */ 975 { 976 files_struct *fsp = file_find_dif(dev, inode, file_id); 977 if (!fsp) { 978 DEBUG(0,("request_oplock_break: PANIC : breaking our own oplock requested for \ 979dev = %x, inode = %.0f, file_id = %lu and no fsp found !\n", 980 (unsigned int)dev, (double)inode, file_id )); 981 smb_panic("request_oplock_break: no fsp found for our own oplock\n"); 982 } 983 } 984#endif /* END JRA PARANOIA TEST... */ 985 986 /* Call oplock break direct. */ 987 return oplock_break(dev, inode, file_id, True); 988 } 989 990 /* We need to send a OPLOCK_BREAK_CMD message to the port in the share mode entry. */ 991 992 if (LEVEL_II_OPLOCK_TYPE(share_entry->op_type)) { 993 break_cmd_type = LEVEL_II_OPLOCK_BREAK_CMD; 994 } else { 995 break_cmd_type = OPLOCK_BREAK_CMD; 996 } 997 998 SSVAL(op_break_msg,OPBRK_MESSAGE_CMD_OFFSET,break_cmd_type); 999 memcpy(op_break_msg+OPLOCK_BREAK_PID_OFFSET,(char *)&pid,sizeof(pid)); 1000 memcpy(op_break_msg+OPLOCK_BREAK_DEV_OFFSET,(char *)&dev,sizeof(dev)); 1001 memcpy(op_break_msg+OPLOCK_BREAK_INODE_OFFSET,(char *)&inode,sizeof(inode)); 1002 memcpy(op_break_msg+OPLOCK_BREAK_FILEID_OFFSET,(char *)&file_id,sizeof(file_id)); 1003 1004 /* Set the address and port. */ 1005 memset((char *)&addr_out,'\0',sizeof(addr_out)); 1006 addr_out.sin_addr.s_addr = htonl(INADDR_LOOPBACK); 1007 addr_out.sin_port = htons( share_entry->op_port ); 1008 addr_out.sin_family = AF_INET; 1009 1010 if( DEBUGLVL( 3 ) ) { 1011 dbgtext( "request_oplock_break: sending a synchronous oplock break message to " ); 1012 dbgtext( "pid %d on port %d ", (int)share_entry->pid, share_entry->op_port ); 1013 dbgtext( "for dev = %x, inode = %.0f, file_id = %lu\n", 1014 (unsigned int)dev, (double)inode, file_id ); 1015 } 1016 1017 if(sys_sendto(oplock_sock,op_break_msg,OPLOCK_BREAK_MSG_LEN,0, 1018 (struct sockaddr *)&addr_out,sizeof(addr_out)) < 0) { 1019 if( DEBUGLVL( 0 ) ) { 1020 dbgtext( "request_oplock_break: failed when sending a oplock " ); 1021 dbgtext( "break message to pid %d ", (int)share_entry->pid ); 1022 dbgtext( "on port %d ", share_entry->op_port ); 1023 dbgtext( "for dev = %x, inode = %.0f, file_id = %lu\n", 1024 (unsigned int)dev, (double)inode, file_id ); 1025 dbgtext( "Error was %s\n", strerror(errno) ); 1026 } 1027 return False; 1028 } 1029 1030 /* 1031 * Now we must await the oplock broken message coming back 1032 * from the target smbd process. Timeout if it fails to 1033 * return in (OPLOCK_BREAK_TIMEOUT + OPLOCK_BREAK_TIMEOUT_FUDGEFACTOR) seconds. 1034 * While we get messages that aren't ours, loop. 1035 */ 1036 1037 start_time = time(NULL); 1038 time_left = OPLOCK_BREAK_TIMEOUT+OPLOCK_BREAK_TIMEOUT_FUDGEFACTOR; 1039 1040 while(time_left >= 0) { 1041 char op_break_reply[OPBRK_CMD_HEADER_LEN+OPLOCK_BREAK_MSG_LEN]; 1042 uint16 reply_from_port; 1043 char *reply_msg_start; 1044 1045 if(receive_local_message(op_break_reply, sizeof(op_break_reply), 1046 time_left ? time_left * 1000 : 1) == False) { 1047 if(smb_read_error == READ_TIMEOUT) { 1048 if( DEBUGLVL( 0 ) ) { 1049 dbgtext( "request_oplock_break: no response received to oplock " ); 1050 dbgtext( "break request to pid %d ", (int)share_entry->pid ); 1051 dbgtext( "on port %d ", share_entry->op_port ); 1052 dbgtext( "for dev = %x, inode = %.0f, file_id = %lu\n", 1053 (unsigned int)dev, (double)inode, file_id ); 1054 } 1055 1056 /* 1057 * This is a hack to make handling of failing clients more robust. 1058 * If a oplock break response message is not received in the timeout 1059 * period we may assume that the smbd servicing that client holding 1060 * the oplock has died and the client changes were lost anyway, so 1061 * we should continue to try and open the file. 1062 */ 1063 break; 1064 } else { 1065 if( DEBUGLVL( 0 ) ) { 1066 dbgtext( "request_oplock_break: error in response received " ); 1067 dbgtext( "to oplock break request to pid %d ", (int)share_entry->pid ); 1068 dbgtext( "on port %d ", share_entry->op_port ); 1069 dbgtext( "for dev = %x, inode = %.0f, file_id = %lu\n", 1070 (unsigned int)dev, (double)inode, file_id ); 1071 dbgtext( "Error was (%s).\n", strerror(errno) ); 1072 } 1073 } 1074 return False; 1075 } 1076 1077 reply_from_port = SVAL(op_break_reply,OPBRK_CMD_PORT_OFFSET); 1078 reply_msg_start = &op_break_reply[OPBRK_CMD_HEADER_LEN]; 1079 1080 /* 1081 * Test to see if this is the reply we are awaiting (ie. the one we sent with the CMD_REPLY flag OR'ed in). 1082 */ 1083 if((SVAL(reply_msg_start,OPBRK_MESSAGE_CMD_OFFSET) & CMD_REPLY) && 1084 ((SVAL(reply_msg_start,OPBRK_MESSAGE_CMD_OFFSET) & ~CMD_REPLY) == break_cmd_type) && 1085 (reply_from_port == share_entry->op_port) && 1086 (memcmp(&reply_msg_start[OPLOCK_BREAK_PID_OFFSET], &op_break_msg[OPLOCK_BREAK_PID_OFFSET], 1087 OPLOCK_BREAK_MSG_LEN - OPLOCK_BREAK_PID_OFFSET) == 0)) { 1088 1089 /* 1090 * This is the reply we've been waiting for. 1091 */ 1092 break; 1093 } else { 1094 /* 1095 * This is another message - a break request. 1096 * Note that both kernel oplock break requests 1097 * and UDP inter-smbd oplock break requests will 1098 * be processed here. 1099 * 1100 * Process it to prevent potential deadlock. 1101 * Note that the code in switch_message() prevents 1102 * us from recursing into here as any SMB requests 1103 * we might process that would cause another oplock 1104 * break request to be made will be queued. 1105 * JRA. 1106 */ 1107 1108 process_local_message(op_break_reply, sizeof(op_break_reply)); 1109 } 1110 1111 time_left -= (time(NULL) - start_time); 1112 } 1113 1114 DEBUG(3,("request_oplock_break: broke oplock.\n")); 1115 1116 return True; 1117} 1118 1119/**************************************************************************** 1120 Attempt to break an oplock on a file (if oplocked). 1121 Returns True if the file was closed as a result of 1122 the oplock break, False otherwise. 1123 Used as a last ditch attempt to free a space in the 1124 file table when we have run out. 1125****************************************************************************/ 1126 1127BOOL attempt_close_oplocked_file(files_struct *fsp) 1128{ 1129 DEBUG(5,("attempt_close_oplocked_file: checking file %s.\n", fsp->fsp_name)); 1130 1131 if (EXCLUSIVE_OPLOCK_TYPE(fsp->oplock_type) && !fsp->sent_oplock_break && (fsp->fd != -1)) { 1132 /* Try and break the oplock. */ 1133 if (oplock_break(fsp->dev, fsp->inode, fsp->file_id, True)) { 1134 if(file_find_fsp(fsp) == NULL) /* Did the oplock break close the file ? */ 1135 return True; 1136 } 1137 } 1138 1139 return False; 1140} 1141 1142/**************************************************************************** 1143 Send an asynchronous oplock break message to another smbd process. 1144****************************************************************************/ 1145 1146static BOOL request_remote_level2_async_oplock_break(share_mode_entry *share_entry) 1147{ 1148 char op_break_msg[OPLOCK_BREAK_MSG_LEN]; 1149 struct sockaddr_in addr_out; 1150 pid_t pid = sys_getpid(); 1151 SMB_DEV_T dev = share_entry->dev; 1152 SMB_INO_T inode = share_entry->inode; 1153 unsigned long file_id = share_entry->share_file_id; 1154 1155 /* We need to send a ASYNC_LEVEL_II_OPLOCK_BREAK_CMD message to the port in the share mode entry. */ 1156 1157 SSVAL(op_break_msg,OPBRK_MESSAGE_CMD_OFFSET,ASYNC_LEVEL_II_OPLOCK_BREAK_CMD); 1158 memcpy(op_break_msg+OPLOCK_BREAK_PID_OFFSET,(char *)&pid,sizeof(pid)); 1159 memcpy(op_break_msg+OPLOCK_BREAK_DEV_OFFSET,(char *)&dev,sizeof(dev)); 1160 memcpy(op_break_msg+OPLOCK_BREAK_INODE_OFFSET,(char *)&inode,sizeof(inode)); 1161 memcpy(op_break_msg+OPLOCK_BREAK_FILEID_OFFSET,(char *)&file_id,sizeof(file_id)); 1162 1163 /* Set the address and port. */ 1164 memset((char *)&addr_out,'\0',sizeof(addr_out)); 1165 addr_out.sin_addr.s_addr = htonl(INADDR_LOOPBACK); 1166 addr_out.sin_port = htons( share_entry->op_port ); 1167 addr_out.sin_family = AF_INET; 1168 1169 if( DEBUGLVL( 3 ) ) { 1170 dbgtext( "request_remote_level2_async_oplock_break: sending an asynchronous oplock break message to "); 1171 dbgtext( "pid %d on port %d ", (int)share_entry->pid, share_entry->op_port ); 1172 dbgtext( "for dev = %x, inode = %.0f, file_id = %lu\n", 1173 (unsigned int)dev, (double)inode, file_id ); 1174 } 1175 1176 if(sys_sendto(oplock_sock,op_break_msg,OPLOCK_BREAK_MSG_LEN,0, 1177 (struct sockaddr *)&addr_out,sizeof(addr_out)) < 0) { 1178 if( DEBUGLVL( 0 ) ) { 1179 dbgtext( "request_remote_level2_async_oplock_break: failed when sending a oplock " ); 1180 dbgtext( "break message to pid %d ", (int)share_entry->pid ); 1181 dbgtext( "on port %d ", share_entry->op_port ); 1182 dbgtext( "for dev = %x, inode = %.0f, file_id = %lu\n", 1183 (unsigned int)dev, (double)inode, file_id ); 1184 dbgtext( "Error was %s\n", strerror(errno) ); 1185 } 1186 return False; 1187 } 1188 1189 DEBUG(3,("request_remote_level2_async_oplock_break: sent async break message to level II entry.\n")); 1190 return True; 1191} 1192 1193/**************************************************************************** 1194 This function is called on any file modification or lock request. If a file 1195 is level 2 oplocked then it must tell all other level 2 holders to break to none. 1196****************************************************************************/ 1197 1198void release_level_2_oplocks_on_change(files_struct *fsp) 1199{ 1200 share_mode_entry *share_list = NULL; 1201 pid_t pid = sys_getpid(); 1202 int num_share_modes = 0; 1203 int i; 1204 1205 /* 1206 * If this file is level II oplocked then we need 1207 * to grab the shared memory lock and inform all 1208 * other files with a level II lock that they need 1209 * to flush their read caches. We keep the lock over 1210 * the shared memory area whilst doing this. 1211 */ 1212 1213 if (!LEVEL_II_OPLOCK_TYPE(fsp->oplock_type)) 1214 return; 1215 1216 if (lock_share_entry_fsp(fsp) == False) { 1217 DEBUG(0,("release_level_2_oplocks_on_change: failed to lock share mode entry for file %s.\n", fsp->fsp_name )); 1218 } 1219 1220 num_share_modes = get_share_modes(fsp->conn, fsp->dev, fsp->inode, &share_list); 1221 1222 DEBUG(10,("release_level_2_oplocks_on_change: num_share_modes = %d\n", 1223 num_share_modes )); 1224 1225 for(i = 0; i < num_share_modes; i++) { 1226 share_mode_entry *share_entry = &share_list[i]; 1227 1228 /* 1229 * As there could have been multiple writes waiting at the lock_share_entry 1230 * gate we may not be the first to enter. Hence the state of the op_types 1231 * in the share mode entries may be partly NO_OPLOCK and partly LEVEL_II 1232 * oplock. It will do no harm to re-send break messages to those smbd's 1233 * that are still waiting their turn to remove their LEVEL_II state, and 1234 * also no harm to ignore existing NO_OPLOCK states. JRA. 1235 */ 1236 1237 DEBUG(10,("release_level_2_oplocks_on_change: share_entry[%i]->op_type == %d\n", 1238 i, share_entry->op_type )); 1239 1240 if (share_entry->op_type == NO_OPLOCK) 1241 continue; 1242 1243 /* Paranoia .... */ 1244 if (EXCLUSIVE_OPLOCK_TYPE(share_entry->op_type)) { 1245 DEBUG(0,("release_level_2_oplocks_on_change: PANIC. share mode entry %d is an exlusive oplock !\n", i )); 1246 unlock_share_entry(fsp->conn, fsp->dev, fsp->inode); 1247 abort(); 1248 } 1249 1250 /* 1251 * Check if this is a file we have open (including the 1252 * file we've been called to do write_file on. If so 1253 * then break it directly without releasing the lock. 1254 */ 1255 1256 if (pid == share_entry->pid) { 1257 files_struct *new_fsp = file_find_dif(share_entry->dev, share_entry->inode, share_entry->share_file_id); 1258 1259 /* Paranoia check... */ 1260 if(new_fsp == NULL) { 1261 DEBUG(0,("release_level_2_oplocks_on_change: PANIC. share mode entry %d is not a local file !\n", i )); 1262 unlock_share_entry(fsp->conn, fsp->dev, fsp->inode); 1263 abort(); 1264 } 1265 1266 DEBUG(10,("release_level_2_oplocks_on_change: breaking our own oplock.\n")); 1267 1268 oplock_break_level2(new_fsp, True); 1269 1270 } else { 1271 1272 /* 1273 * This is a remote file and so we send an asynchronous 1274 * message. 1275 */ 1276 1277 DEBUG(10,("release_level_2_oplocks_on_change: breaking remote oplock (async).\n")); 1278 request_remote_level2_async_oplock_break(share_entry); 1279 } 1280 } 1281 1282 SAFE_FREE(share_list); 1283 unlock_share_entry_fsp(fsp); 1284 1285 /* Paranoia check... */ 1286 if (LEVEL_II_OPLOCK_TYPE(fsp->oplock_type)) { 1287 DEBUG(0,("release_level_2_oplocks_on_change: PANIC. File %s still has a level II oplock.\n", fsp->fsp_name)); 1288 smb_panic("release_level_2_oplocks_on_change"); 1289 } 1290} 1291 1292/**************************************************************************** 1293 Send a 'retry your open' message to a process with a deferred open entry. 1294****************************************************************************/ 1295 1296BOOL send_deferred_open_retry_message(deferred_open_entry *entry) 1297{ 1298 char de_msg[DEFERRED_OPEN_MSG_LEN]; 1299 struct sockaddr_in addr_out; 1300 pid_t pid = sys_getpid(); 1301 1302 memset(de_msg, '\0', DEFERRED_OPEN_MSG_LEN); 1303 SSVAL(de_msg,DEFERRED_OPEN_CMD_OFFSET,RETRY_DEFERRED_OPEN_CMD); 1304 memcpy(de_msg+DEFERRED_OPEN_PID_OFFSET,(char *)&pid,sizeof(pid)); 1305 memcpy(de_msg+DEFERRED_OPEN_DEV_OFFSET,(char *)&entry->dev,sizeof(entry->dev)); 1306 memcpy(de_msg+DEFERRED_OPEN_INODE_OFFSET,(char *)&entry->inode,sizeof(entry->inode)); 1307 memcpy(de_msg+DEFERRED_OPEN_MID_OFFSET,(char *)&entry->mid,sizeof(entry->mid)); 1308 1309 /* Set the address and port. */ 1310 memset((char *)&addr_out,'\0',sizeof(addr_out)); 1311 addr_out.sin_addr.s_addr = htonl(INADDR_LOOPBACK); 1312 addr_out.sin_port = htons( entry->port ); 1313 addr_out.sin_family = AF_INET; 1314 1315 if( DEBUGLVL( 3 ) ) { 1316 dbgtext( "send_deferred_open_retry_message: sending a message to "); 1317 dbgtext( "pid %d on port %d ", (int)entry->pid, entry->port ); 1318 dbgtext( "for dev = %x, inode = %.0f, mid = %u\n", 1319 (unsigned int)entry->dev, (double)entry->inode, (unsigned int)entry->mid ); 1320 } 1321 1322 if(sys_sendto(oplock_sock,de_msg,DEFERRED_OPEN_MSG_LEN,0, 1323 (struct sockaddr *)&addr_out,sizeof(addr_out)) < 0) { 1324 if( DEBUGLVL( 0 ) ) { 1325 dbgtext( "send_deferred_open_retry_message: failed sending a message to "); 1326 dbgtext( "pid %d on port %d ", (int)entry->pid, entry->port ); 1327 dbgtext( "for dev = %x, inode = %.0f, mid = %u\n", 1328 (unsigned int)entry->dev, (double)entry->inode, (unsigned int)entry->mid ); 1329 dbgtext( "Error was %s\n", strerror(errno) ); 1330 } 1331 return False; 1332 } 1333 return True; 1334} 1335 1336/**************************************************************************** 1337 Setup oplocks for this process. 1338****************************************************************************/ 1339 1340BOOL init_oplocks(void) 1341{ 1342 struct sockaddr_in sock_name; 1343 socklen_t len = sizeof(sock_name); 1344 1345 DEBUG(3,("open_oplock_ipc: opening loopback UDP socket.\n")); 1346 1347 /* Open a lookback UDP socket on a random port. */ 1348 oplock_sock = open_socket_in(SOCK_DGRAM, 0, 0, htonl(INADDR_LOOPBACK),False); 1349 if (oplock_sock == -1) { 1350 DEBUG(0,("open_oplock_ipc: Failed to get local UDP socket for \ 1351address %lx. Error was %s\n", (long)htonl(INADDR_LOOPBACK), strerror(errno))); 1352 global_oplock_port = 0; 1353 return(False); 1354 } 1355 1356 /* Find out the transient UDP port we have been allocated. */ 1357 if(getsockname(oplock_sock, (struct sockaddr *)&sock_name, &len)<0) { 1358 DEBUG(0,("open_oplock_ipc: Failed to get local UDP port. Error was %s\n", 1359 strerror(errno))); 1360 close(oplock_sock); 1361 oplock_sock = -1; 1362 global_oplock_port = 0; 1363 return False; 1364 } 1365 global_oplock_port = ntohs(sock_name.sin_port); 1366 1367 if (lp_kernel_oplocks()) { 1368#if HAVE_KERNEL_OPLOCKS_IRIX 1369 koplocks = irix_init_kernel_oplocks(); 1370#elif HAVE_KERNEL_OPLOCKS_LINUX 1371 koplocks = linux_init_kernel_oplocks(); 1372#endif 1373 } 1374 1375 DEBUG(3,("open_oplock ipc: pid = %d, global_oplock_port = %u\n", 1376 (int)sys_getpid(), global_oplock_port)); 1377 1378 return True; 1379} 1380