1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 /* 27 * File Change Notification (FCN) 28 */ 29 30 /* 31 * SMB: nt_transact_notify_change 32 * 33 * Client Setup Words Description 34 * ================================== ================================= 35 * 36 * ULONG CompletionFilter; Specifies operation to monitor 37 * USHORT Fid; Fid of directory to monitor 38 * BOOLEAN WatchTree; TRUE = watch all subdirectories too 39 * UCHAR Reserved; MBZ 40 * 41 * This command notifies the client when the directory specified by Fid is 42 * modified. It also returns the name(s) of the file(s) that changed. The 43 * command completes once the directory has been modified based on the 44 * supplied CompletionFilter. The command is a "single shot" and therefore 45 * needs to be reissued to watch for more directory changes. 46 * 47 * A directory file must be opened before this command may be used. Once 48 * the directory is open, this command may be used to begin watching files 49 * and subdirectories in the specified directory for changes. The first 50 * time the command is issued, the MaxParameterCount field in the transact 51 * header determines the size of the buffer that will be used at the server 52 * to buffer directory change information between issuances of the notify 53 * change commands. 54 * 55 * When a change that is in the CompletionFilter is made to the directory, 56 * the command completes. The names of the files that have changed since 57 * the last time the command was issued are returned to the client. The 58 * ParameterCount field of the response indicates the number of bytes that 59 * are being returned. If too many files have changed since the last time 60 * the command was issued, then zero bytes are returned and an alternate 61 * status code is returned in the Status field of the response. 62 * 63 * The CompletionFilter is a mask created as the sum of any of the 64 * following flags: 65 * 66 * FILE_NOTIFY_CHANGE_FILE_NAME 0x00000001 67 * FILE_NOTIFY_CHANGE_DIR_NAME 0x00000002 68 * FILE_NOTIFY_CHANGE_NAME 0x00000003 69 * FILE_NOTIFY_CHANGE_ATTRIBUTES 0x00000004 70 * FILE_NOTIFY_CHANGE_SIZE 0x00000008 71 * FILE_NOTIFY_CHANGE_LAST_WRITE 0x00000010 72 * FILE_NOTIFY_CHANGE_LAST_ACCESS 0x00000020 73 * FILE_NOTIFY_CHANGE_CREATION 0x00000040 74 * FILE_NOTIFY_CHANGE_EA 0x00000080 75 * FILE_NOTIFY_CHANGE_SECURITY 0x00000100 76 * FILE_NOTIFY_CHANGE_STREAM_NAME 0x00000200 77 * FILE_NOTIFY_CHANGE_STREAM_SIZE 0x00000400 78 * FILE_NOTIFY_CHANGE_STREAM_WRITE 0x00000800 79 * 80 * Server Response Description 81 * ================================== ================================ 82 * ParameterCount # of bytes of change data 83 * Parameters[ ParameterCount ] FILE_NOTIFY_INFORMATION 84 * structures 85 * 86 * The response contains FILE_NOTIFY_INFORMATION structures, as defined 87 * below. The NextEntryOffset field of the structure specifies the offset, 88 * in bytes, from the start of the current entry to the next entry in the 89 * list. If this is the last entry in the list, this field is zero. Each 90 * entry in the list must be longword aligned, so NextEntryOffset must be a 91 * multiple of four. 92 * 93 * typedef struct { 94 * ULONG NextEntryOffset; 95 * ULONG Action; 96 * ULONG FileNameLength; 97 * WCHAR FileName[1]; 98 * } FILE_NOTIFY_INFORMATION; 99 * 100 * Where Action describes what happened to the file named FileName: 101 * 102 * FILE_ACTION_ADDED 0x00000001 103 * FILE_ACTION_REMOVED 0x00000002 104 * FILE_ACTION_MODIFIED 0x00000003 105 * FILE_ACTION_RENAMED_OLD_NAME 0x00000004 106 * FILE_ACTION_RENAMED_NEW_NAME 0x00000005 107 * FILE_ACTION_ADDED_STREAM 0x00000006 108 * FILE_ACTION_REMOVED_STREAM 0x00000007 109 * FILE_ACTION_MODIFIED_STREAM 0x00000008 110 */ 111 112 #include <smbsrv/smb_kproto.h> 113 #include <sys/sdt.h> 114 115 static void smb_notify_change_daemon(smb_thread_t *, void *); 116 static boolean_t smb_notify_change_required(smb_request_t *, smb_node_t *); 117 118 static boolean_t smb_notify_initialized = B_FALSE; 119 static smb_slist_t smb_ncr_list; 120 static smb_slist_t smb_nce_list; 121 static smb_thread_t smb_thread_notify_daemon; 122 123 /* 124 * smb_notify_init 125 * 126 * This function is not multi-thread safe. The caller must make sure only one 127 * thread makes the call. 128 */ 129 int 130 smb_notify_init(void) 131 { 132 int rc; 133 134 if (smb_notify_initialized) 135 return (0); 136 137 smb_slist_constructor(&smb_ncr_list, sizeof (smb_request_t), 138 offsetof(smb_request_t, sr_ncr.nc_lnd)); 139 140 smb_slist_constructor(&smb_nce_list, sizeof (smb_request_t), 141 offsetof(smb_request_t, sr_ncr.nc_lnd)); 142 143 smb_thread_init(&smb_thread_notify_daemon, 144 "smb_notify_change_daemon", smb_notify_change_daemon, NULL, 145 NULL, NULL); 146 147 rc = smb_thread_start(&smb_thread_notify_daemon); 148 if (rc) { 149 smb_thread_destroy(&smb_thread_notify_daemon); 150 smb_slist_destructor(&smb_ncr_list); 151 smb_slist_destructor(&smb_nce_list); 152 return (rc); 153 } 154 155 smb_notify_initialized = B_TRUE; 156 157 return (0); 158 } 159 160 /* 161 * smb_notify_fini 162 * 163 * This function is not multi-thread safe. The caller must make sure only one 164 * thread makes the call. 165 */ 166 void 167 smb_notify_fini(void) 168 { 169 if (!smb_notify_initialized) 170 return; 171 172 smb_thread_stop(&smb_thread_notify_daemon); 173 smb_thread_destroy(&smb_thread_notify_daemon); 174 smb_slist_destructor(&smb_ncr_list); 175 smb_slist_destructor(&smb_nce_list); 176 smb_notify_initialized = B_FALSE; 177 } 178 179 /* 180 * smb_nt_transact_notify_change 181 * 182 * This function is responsible for processing NOTIFY CHANGE requests. 183 * Requests are stored in a global queue. This queue is processed when 184 * a monitored directory is changed or client cancels one of its already 185 * sent requests. 186 */ 187 smb_sdrc_t 188 smb_nt_transact_notify_change(struct smb_request *sr, struct smb_xa *xa) 189 { 190 uint32_t CompletionFilter; 191 unsigned char WatchTree; 192 smb_node_t *node; 193 194 if (smb_mbc_decodef(&xa->req_setup_mb, "lwb", 195 &CompletionFilter, &sr->smb_fid, &WatchTree) != 0) 196 return (SDRC_NOT_IMPLEMENTED); 197 198 smbsr_lookup_file(sr); 199 if (sr->fid_ofile == NULL) { 200 smbsr_error(sr, NT_STATUS_INVALID_HANDLE, ERRDOS, ERRbadfid); 201 return (SDRC_ERROR); 202 } 203 204 node = sr->fid_ofile->f_node; 205 206 if (!smb_node_is_dir(node)) { 207 /* 208 * Notify change requests are only valid on directories. 209 */ 210 smbsr_error(sr, NT_STATUS_NOT_A_DIRECTORY, 0, 0); 211 return (SDRC_ERROR); 212 } 213 214 mutex_enter(&sr->sr_mutex); 215 switch (sr->sr_state) { 216 case SMB_REQ_STATE_ACTIVE: 217 node->waiting_event++; 218 node->flags |= NODE_FLAGS_NOTIFY_CHANGE; 219 if ((node->flags & NODE_FLAGS_CHANGED) == 0) { 220 sr->sr_ncr.nc_node = node; 221 sr->sr_ncr.nc_flags = CompletionFilter; 222 if (WatchTree) 223 sr->sr_ncr.nc_flags |= NODE_FLAGS_WATCH_TREE; 224 225 sr->sr_keep = B_TRUE; 226 sr->sr_state = SMB_REQ_STATE_WAITING_EVENT; 227 228 smb_slist_insert_tail(&smb_ncr_list, sr); 229 230 /* 231 * Monitor events system-wide. 232 * 233 * XXX: smb_node_ref() and smb_node_release() 234 * take &node->n_lock. May need alternate forms 235 * of these routines if node->n_lock is taken 236 * around calls to smb_fem_fcn_install() and 237 * smb_fem_fcn_uninstall(). 238 */ 239 240 smb_fem_fcn_install(node); 241 242 mutex_exit(&sr->sr_mutex); 243 return (SDRC_SR_KEPT); 244 } else { 245 /* node already changed, reply immediately */ 246 if (--node->waiting_event == 0) 247 node->flags &= 248 ~(NODE_FLAGS_NOTIFY_CHANGE | 249 NODE_FLAGS_CHANGED); 250 mutex_exit(&sr->sr_mutex); 251 return (SDRC_SUCCESS); 252 } 253 254 case SMB_REQ_STATE_CANCELED: 255 mutex_exit(&sr->sr_mutex); 256 smbsr_error(sr, NT_STATUS_CANCELLED, 0, 0); 257 return (SDRC_ERROR); 258 259 default: 260 ASSERT(0); 261 mutex_exit(&sr->sr_mutex); 262 return (SDRC_SUCCESS); 263 } 264 } 265 266 /* 267 * smb_reply_notify_change_request 268 * 269 * This function sends appropriate response to an already queued NOTIFY CHANGE 270 * request. If node is changed (reply == NODE_FLAGS_CHANGED), a normal reply is 271 * sent. 272 * If client cancels the request or session dropped, an NT_STATUS_CANCELED 273 * is sent in reply. 274 */ 275 276 void 277 smb_reply_notify_change_request(smb_request_t *sr) 278 { 279 smb_node_t *node; 280 int total_bytes, n_setup, n_param, n_data; 281 int param_off, param_pad, data_off, data_pad; 282 struct smb_xa *xa; 283 smb_error_t err; 284 285 xa = sr->r_xa; 286 node = sr->sr_ncr.nc_node; 287 288 if (--node->waiting_event == 0) { 289 node->flags &= ~(NODE_FLAGS_NOTIFY_CHANGE | NODE_FLAGS_CHANGED); 290 smb_fem_fcn_uninstall(node); 291 } 292 293 mutex_enter(&sr->sr_mutex); 294 switch (sr->sr_state) { 295 296 case SMB_REQ_STATE_EVENT_OCCURRED: 297 sr->sr_state = SMB_REQ_STATE_ACTIVE; 298 299 /* many things changed */ 300 301 (void) smb_mbc_encodef(&xa->rep_data_mb, "l", 0L); 302 303 /* setup the NT transact reply */ 304 305 n_setup = MBC_LENGTH(&xa->rep_setup_mb); 306 n_param = MBC_LENGTH(&xa->rep_param_mb); 307 n_data = MBC_LENGTH(&xa->rep_data_mb); 308 309 n_setup = (n_setup + 1) / 2; /* Convert to setup words */ 310 param_pad = 1; /* must be one */ 311 param_off = param_pad + 32 + 37 + (n_setup << 1) + 2; 312 /* Pad to 4 bytes */ 313 data_pad = (4 - ((param_off + n_param) & 3)) % 4; 314 /* Param off from hdr */ 315 data_off = param_off + n_param + data_pad; 316 total_bytes = param_pad + n_param + data_pad + n_data; 317 318 (void) smbsr_encode_result(sr, 18+n_setup, total_bytes, 319 "b3.llllllllbCw#.C#.C", 320 18 + n_setup, /* wct */ 321 n_param, /* Total Parameter Bytes */ 322 n_data, /* Total Data Bytes */ 323 n_param, /* Total Parameter Bytes this buffer */ 324 param_off, /* Param offset from header start */ 325 0, /* Param displacement */ 326 n_data, /* Total Data Bytes this buffer */ 327 data_off, /* Data offset from header start */ 328 0, /* Data displacement */ 329 n_setup, /* suwcnt */ 330 &xa->rep_setup_mb, /* setup[] */ 331 total_bytes, /* Total data bytes */ 332 param_pad, 333 &xa->rep_param_mb, 334 data_pad, 335 &xa->rep_data_mb); 336 break; 337 338 case SMB_REQ_STATE_CANCELED: 339 err.severity = ERROR_SEVERITY_ERROR; 340 err.status = NT_STATUS_CANCELLED; 341 err.errcls = ERRDOS; 342 err.errcode = ERROR_OPERATION_ABORTED; 343 smbsr_set_error(sr, &err); 344 345 (void) smb_mbc_encodef(&sr->reply, "bwbw", 346 (short)0, 0L, (short)0, 0L); 347 sr->smb_wct = 0; 348 sr->smb_bcc = 0; 349 break; 350 default: 351 ASSERT(0); 352 } 353 mutex_exit(&sr->sr_mutex); 354 355 /* Setup the header */ 356 (void) smb_mbc_poke(&sr->reply, 0, SMB_HEADER_ED_FMT, 357 sr->first_smb_com, 358 sr->smb_rcls, 359 sr->smb_reh, 360 sr->smb_err, 361 sr->smb_flg | SMB_FLAGS_REPLY, 362 sr->smb_flg2, 363 sr->smb_pid_high, 364 sr->smb_sig, 365 sr->smb_tid, 366 sr->smb_pid, 367 sr->smb_uid, 368 sr->smb_mid); 369 370 if (sr->session->signing.flags & SMB_SIGNING_ENABLED) 371 smb_sign_reply(sr, NULL); 372 373 /* send the reply */ 374 DTRACE_PROBE1(ncr__reply, struct smb_request *, sr) 375 (void) smb_session_send(sr->session, 0, &sr->reply); 376 smbsr_cleanup(sr); 377 378 mutex_enter(&sr->sr_mutex); 379 sr->sr_state = SMB_REQ_STATE_COMPLETED; 380 mutex_exit(&sr->sr_mutex); 381 smb_request_free(sr); 382 } 383 384 /* 385 * smb_process_session_notify_change_queue 386 * 387 * This function traverses notify change request queue and sends 388 * cancel replies to all of requests that are related to a specific 389 * session. 390 */ 391 void 392 smb_process_session_notify_change_queue( 393 smb_session_t *session, 394 smb_tree_t *tree) 395 { 396 smb_request_t *sr; 397 smb_request_t *tmp; 398 boolean_t sig = B_FALSE; 399 400 smb_slist_enter(&smb_ncr_list); 401 smb_slist_enter(&smb_nce_list); 402 sr = smb_slist_head(&smb_ncr_list); 403 while (sr) { 404 ASSERT(sr->sr_magic == SMB_REQ_MAGIC); 405 tmp = smb_slist_next(&smb_ncr_list, sr); 406 if ((sr->session == session) && 407 (tree == NULL || sr->tid_tree == tree)) { 408 mutex_enter(&sr->sr_mutex); 409 switch (sr->sr_state) { 410 case SMB_REQ_STATE_WAITING_EVENT: 411 smb_slist_obj_move( 412 &smb_nce_list, 413 &smb_ncr_list, 414 sr); 415 sr->sr_state = SMB_REQ_STATE_CANCELED; 416 sig = B_TRUE; 417 break; 418 default: 419 ASSERT(0); 420 break; 421 } 422 mutex_exit(&sr->sr_mutex); 423 } 424 sr = tmp; 425 } 426 smb_slist_exit(&smb_nce_list); 427 smb_slist_exit(&smb_ncr_list); 428 if (sig) 429 smb_thread_signal(&smb_thread_notify_daemon); 430 } 431 432 /* 433 * smb_process_file_notify_change_queue 434 * 435 * This function traverses notify change request queue and sends 436 * cancel replies to all of requests that are related to the 437 * specified file. 438 */ 439 void 440 smb_process_file_notify_change_queue(struct smb_ofile *of) 441 { 442 smb_request_t *sr; 443 smb_request_t *tmp; 444 boolean_t sig = B_FALSE; 445 446 smb_slist_enter(&smb_ncr_list); 447 smb_slist_enter(&smb_nce_list); 448 sr = smb_slist_head(&smb_ncr_list); 449 while (sr) { 450 ASSERT(sr->sr_magic == SMB_REQ_MAGIC); 451 tmp = smb_slist_next(&smb_ncr_list, sr); 452 if (sr->fid_ofile == of) { 453 mutex_enter(&sr->sr_mutex); 454 switch (sr->sr_state) { 455 case SMB_REQ_STATE_WAITING_EVENT: 456 smb_slist_obj_move(&smb_nce_list, 457 &smb_ncr_list, sr); 458 sr->sr_state = SMB_REQ_STATE_CANCELED; 459 sig = B_TRUE; 460 break; 461 default: 462 ASSERT(0); 463 break; 464 } 465 mutex_exit(&sr->sr_mutex); 466 } 467 sr = tmp; 468 } 469 smb_slist_exit(&smb_nce_list); 470 smb_slist_exit(&smb_ncr_list); 471 if (sig) 472 smb_thread_signal(&smb_thread_notify_daemon); 473 } 474 475 /* 476 * smb_reply_specific_cancel_request 477 * 478 * This function searches global request list for a specific request. If found, 479 * moves the request to event queue and kicks the notify change daemon. 480 */ 481 482 void 483 smb_reply_specific_cancel_request(struct smb_request *zsr) 484 { 485 smb_request_t *sr; 486 smb_request_t *tmp; 487 boolean_t sig = B_FALSE; 488 489 smb_slist_enter(&smb_ncr_list); 490 smb_slist_enter(&smb_nce_list); 491 sr = smb_slist_head(&smb_ncr_list); 492 while (sr) { 493 ASSERT(sr->sr_magic == SMB_REQ_MAGIC); 494 tmp = smb_slist_next(&smb_ncr_list, sr); 495 if ((sr->session == zsr->session) && 496 (sr->smb_uid == zsr->smb_uid) && 497 (sr->smb_pid == zsr->smb_pid) && 498 (sr->smb_tid == zsr->smb_tid) && 499 (sr->smb_mid == zsr->smb_mid)) { 500 mutex_enter(&sr->sr_mutex); 501 switch (sr->sr_state) { 502 case SMB_REQ_STATE_WAITING_EVENT: 503 smb_slist_obj_move(&smb_nce_list, 504 &smb_ncr_list, sr); 505 sr->sr_state = SMB_REQ_STATE_CANCELED; 506 sig = B_TRUE; 507 break; 508 default: 509 ASSERT(0); 510 break; 511 } 512 mutex_exit(&sr->sr_mutex); 513 } 514 sr = tmp; 515 } 516 smb_slist_exit(&smb_nce_list); 517 smb_slist_exit(&smb_ncr_list); 518 if (sig) 519 smb_thread_signal(&smb_thread_notify_daemon); 520 } 521 522 /* 523 * smb_process_node_notify_change_queue 524 * 525 * This function searches notify change request queue and sends 526 * 'NODE MODIFIED' reply to all requests which are related to a 527 * specific node. 528 * WatchTree flag: We handle this flag in a special manner just 529 * for DAVE clients. When something is changed, we notify all 530 * requests which came from DAVE clients on the same volume which 531 * has been modified. We don't care about the tree that they wanted 532 * us to monitor. any change in any part of the volume will lead 533 * to notifying all notify change requests from DAVE clients on the 534 * different parts of the volume hierarchy. 535 */ 536 void 537 smb_process_node_notify_change_queue(smb_node_t *node) 538 { 539 smb_request_t *sr; 540 smb_request_t *tmp; 541 boolean_t sig = B_FALSE; 542 543 ASSERT(node->n_magic == SMB_NODE_MAGIC); 544 545 if (!(node->flags & NODE_FLAGS_NOTIFY_CHANGE)) 546 return; 547 548 node->flags |= NODE_FLAGS_CHANGED; 549 550 smb_slist_enter(&smb_ncr_list); 551 smb_slist_enter(&smb_nce_list); 552 sr = smb_slist_head(&smb_ncr_list); 553 while (sr) { 554 ASSERT(sr->sr_magic == SMB_REQ_MAGIC); 555 tmp = smb_slist_next(&smb_ncr_list, sr); 556 557 if (smb_notify_change_required(sr, node)) { 558 mutex_enter(&sr->sr_mutex); 559 switch (sr->sr_state) { 560 case SMB_REQ_STATE_WAITING_EVENT: 561 smb_slist_obj_move(&smb_nce_list, 562 &smb_ncr_list, sr); 563 sr->sr_state = SMB_REQ_STATE_EVENT_OCCURRED; 564 sig = B_TRUE; 565 break; 566 default: 567 ASSERT(0); 568 break; 569 } 570 mutex_exit(&sr->sr_mutex); 571 } 572 sr = tmp; 573 } 574 smb_slist_exit(&smb_nce_list); 575 smb_slist_exit(&smb_ncr_list); 576 if (sig) 577 smb_thread_signal(&smb_thread_notify_daemon); 578 } 579 580 /* 581 * Change notification is required if: 582 * - the request node matches the specified node 583 * or 584 * - the request is from a Mac client, the watch-tree flag 585 * is set and it is monitoring a tree on the same volume. 586 */ 587 static boolean_t 588 smb_notify_change_required(smb_request_t *sr, smb_node_t *node) 589 { 590 smb_node_t *nc_node = sr->sr_ncr.nc_node; 591 592 if (nc_node == node) 593 return (B_TRUE); 594 595 if ((sr->sr_ncr.nc_flags & NODE_FLAGS_WATCH_TREE) && 596 (sr->session->native_os == NATIVE_OS_MACOS) && 597 smb_vfs_cmp(SMB_NODE_VFS(nc_node), SMB_NODE_VFS(node))) 598 return (B_TRUE); 599 600 return (B_FALSE); 601 } 602 603 /* 604 * smb_notify_change_daemon 605 * 606 * This function processes notify change event list and send appropriate 607 * responses to the requests. This function executes in the system as an 608 * indivdual thread. 609 */ 610 static void 611 smb_notify_change_daemon(smb_thread_t *thread, void *arg) 612 { 613 _NOTE(ARGUNUSED(arg)) 614 615 smb_request_t *sr; 616 smb_request_t *tmp; 617 list_t sr_list; 618 619 list_create(&sr_list, sizeof (smb_request_t), 620 offsetof(smb_request_t, sr_ncr.nc_lnd)); 621 622 while (smb_thread_continue(thread)) { 623 624 while (smb_slist_move_tail(&sr_list, &smb_nce_list)) { 625 sr = list_head(&sr_list); 626 while (sr) { 627 ASSERT(sr->sr_magic == SMB_REQ_MAGIC); 628 tmp = list_next(&sr_list, sr); 629 list_remove(&sr_list, sr); 630 smb_reply_notify_change_request(sr); 631 sr = tmp; 632 } 633 } 634 } 635 list_destroy(&sr_list); 636 } 637
Indexes created Sat Nov 28 14:09:03 UTC 2009
Terms of Use |
Privacy |
Trademarks |
Copyright Policy |
Site Guidelines |
Help
Your use of this web site or any of its content or software indicates your agreement to be bound by these Terms of Use.
Copyright © 1995-2008 Sun Microsystems, Inc.