1 /* 2 * This file and its contents are supplied under the terms of the 3 * Common Development and Distribution License ("CDDL"), version 1.0. 4 * You may only use this file in accordance with the terms of version 5 * 1.0 of the CDDL. 6 * 7 * A full copy of the text of the CDDL should have accompanied this 8 * source. A copy of the CDDL is also available via the Internet at 9 * http://www.illumos.org/license/CDDL. 10 */ 11 12 /* 13 * Copyright 2018 Nexenta Systems, Inc. All rights reserved. 14 * Copyright 2019 Joyent, Inc. 15 */ 16 17 /* 18 * Test & debug program for oplocks 19 * 20 * This implements a simple command reader which accepts 21 * commands to simulate oplock events, and prints the 22 * state changes and actions that would happen after 23 * each event. 24 */ 25 26 #include <sys/types.h> 27 #include <sys/debug.h> 28 #include <sys/stddef.h> 29 #include <stdio.h> 30 #include <stdlib.h> 31 #include <string.h> 32 #include <strings.h> 33 #include <unistd.h> 34 35 #include <smbsrv/smb_kproto.h> 36 #include <smbsrv/smb_oplock.h> 37 38 #define OPLOCK_CACHE_RWH (READ_CACHING | HANDLE_CACHING | WRITE_CACHING) 39 #define OPLOCK_TYPE (LEVEL_TWO_OPLOCK | LEVEL_ONE_OPLOCK |\ 40 BATCH_OPLOCK | OPLOCK_LEVEL_GRANULAR) 41 42 #define MAXFID 10 43 44 smb_node_t root_node, test_node; 45 smb_ofile_t ofile_array[MAXFID]; 46 smb_request_t test_sr; 47 uint32_t last_ind_break_level; 48 char cmdbuf[100]; 49 50 extern const char *xlate_nt_status(uint32_t); 51 52 #define BIT_DEF(name) { name, #name } 53 54 struct bit_defs { 55 uint32_t mask; 56 const char *name; 57 } state_bits[] = { 58 BIT_DEF(NO_OPLOCK), 59 BIT_DEF(BREAK_TO_NO_CACHING), 60 BIT_DEF(BREAK_TO_WRITE_CACHING), 61 BIT_DEF(BREAK_TO_HANDLE_CACHING), 62 BIT_DEF(BREAK_TO_READ_CACHING), 63 BIT_DEF(BREAK_TO_TWO_TO_NONE), 64 BIT_DEF(BREAK_TO_NONE), 65 BIT_DEF(BREAK_TO_TWO), 66 BIT_DEF(BATCH_OPLOCK), 67 BIT_DEF(LEVEL_ONE_OPLOCK), 68 BIT_DEF(LEVEL_TWO_OPLOCK), 69 BIT_DEF(MIXED_R_AND_RH), 70 BIT_DEF(EXCLUSIVE), 71 BIT_DEF(WRITE_CACHING), 72 BIT_DEF(HANDLE_CACHING), 73 BIT_DEF(READ_CACHING), 74 { 0, NULL } 75 }; 76 77 /* 78 * Helper to print flags fields 79 */ 80 static void 81 print_bits32(char *label, struct bit_defs *bit, uint32_t state) 82 { 83 printf("%s0x%x (", label, state); 84 while (bit->mask != 0) { 85 if ((state & bit->mask) != 0) 86 printf(" %s", bit->name); 87 bit++; 88 } 89 printf(" )\n"); 90 } 91 92 /* 93 * Command language: 94 * 95 */ 96 const char helpstr[] = "Commands:\n" 97 "help\t\tList commands\n" 98 "show\t\tShow OpLock state etc.\n" 99 "open FID\n" 100 "close FID\n" 101 "req FID [OplockLevel]\n" 102 "ack FID [OplockLevel]\n" 103 "brk-parent FID\n" 104 "brk-open [OverWrite]\n" 105 "brk-handle FID\n" 106 "brk-read FID\n" 107 "brk-write FID\n" 108 "brk-setinfo FID [InfoClass]\n" 109 "move FID1 FID2\n" 110 "waiters FID [count]\n"; 111 112 /* 113 * Command handlers 114 */ 115 116 static void 117 do_show(void) 118 { 119 smb_node_t *node = &test_node; 120 smb_oplock_t *ol = &node->n_oplock; 121 uint32_t state = ol->ol_state; 122 smb_ofile_t *f; 123 124 print_bits32(" ol_state=", state_bits, state); 125 126 if (ol->excl_open != NULL) 127 printf(" Excl=Y (FID=%d)", ol->excl_open->f_fid); 128 else 129 printf(" Excl=n"); 130 printf(" cnt_II=%d cnt_R=%d cnt_RH=%d cnt_RHBQ=%d\n", 131 ol->cnt_II, ol->cnt_R, ol->cnt_RH, ol->cnt_RHBQ); 132 133 printf(" ofile_cnt=%d\n", node->n_ofile_list.ll_count); 134 FOREACH_NODE_OFILE(node, f) { 135 smb_oplock_grant_t *og = &f->f_oplock; 136 printf(" fid=%d Lease=%s OgState=0x%x Brk=0x%x", 137 f->f_fid, 138 f->TargetOplockKey, /* lease */ 139 f->f_oplock.og_state, 140 f->f_oplock.og_breaking); 141 printf(" Excl=%s onlist: %s %s %s", 142 (ol->excl_open == f) ? "Y" : "N", 143 og->onlist_II ? "II" : "", 144 og->onlist_R ? "R" : "", 145 og->onlist_RH ? "RH" : ""); 146 if (og->onlist_RHBQ) { 147 printf(" RHBQ(to %s)", 148 og->BreakingToRead ? 149 "read" : "none"); 150 } 151 printf("\n"); 152 } 153 } 154 155 static void 156 do_open(int fid, char *arg2) 157 { 158 smb_node_t *node = &test_node; 159 smb_ofile_t *ofile = &ofile_array[fid]; 160 161 /* 162 * Simulate an open (minimal init) 163 */ 164 if (ofile->f_refcnt) { 165 printf("open fid %d already opened\n"); 166 return; 167 } 168 169 if (arg2 != NULL) { 170 (void) strlcpy((char *)ofile->TargetOplockKey, arg2, 171 SMB_LEASE_KEY_SZ); 172 } 173 174 ofile->f_refcnt++; 175 node->n_open_count++; 176 smb_llist_insert_tail(&node->n_ofile_list, ofile); 177 printf(" open %d OK\n", fid); 178 } 179 180 static void 181 do_close(int fid) 182 { 183 smb_node_t *node = &test_node; 184 smb_ofile_t *ofile = &ofile_array[fid]; 185 186 /* 187 * Simulate an close 188 */ 189 if (ofile->f_refcnt <= 0) { 190 printf(" close fid %d already closed\n"); 191 return; 192 } 193 smb_oplock_break_CLOSE(ofile->f_node, ofile); 194 195 smb_llist_remove(&node->n_ofile_list, ofile); 196 node->n_open_count--; 197 ofile->f_refcnt--; 198 199 bzero(ofile->TargetOplockKey, SMB_LEASE_KEY_SZ); 200 201 printf(" close OK\n"); 202 } 203 204 static void 205 do_req(int fid, char *arg2) 206 { 207 smb_ofile_t *ofile = &ofile_array[fid]; 208 uint32_t oplock = BATCH_OPLOCK; 209 uint32_t status; 210 211 if (arg2 != NULL) 212 oplock = strtol(arg2, NULL, 16); 213 214 /* 215 * Request an oplock 216 */ 217 status = smb_oplock_request(&test_sr, ofile, &oplock); 218 if (status == 0) 219 ofile->f_oplock.og_state = oplock; 220 printf(" req oplock fid=%d ret oplock=0x%x status=0x%x (%s)\n", 221 fid, oplock, status, xlate_nt_status(status)); 222 } 223 224 225 static void 226 do_ack(int fid, char *arg2) 227 { 228 smb_ofile_t *ofile = &ofile_array[fid]; 229 uint32_t oplock; 230 uint32_t status; 231 232 /* Default to level in last smb_oplock_ind_break() */ 233 oplock = last_ind_break_level; 234 if (arg2 != NULL) 235 oplock = strtol(arg2, NULL, 16); 236 237 ofile->f_oplock.og_breaking = 0; 238 status = smb_oplock_ack_break(&test_sr, ofile, &oplock); 239 if (status == NT_STATUS_OPLOCK_BREAK_IN_PROGRESS) { 240 printf(" ack: break fid=%d, break-in-progress\n", fid); 241 ofile->f_oplock.og_state = oplock; 242 } 243 if (status == 0) 244 ofile->f_oplock.og_state = oplock; 245 246 printf(" ack: break fid=%d, newstate=0x%x, status=0x%x (%s)\n", 247 fid, oplock, status, xlate_nt_status(status)); 248 } 249 250 static void 251 do_brk_parent(int fid) 252 { 253 smb_ofile_t *ofile = &ofile_array[fid]; 254 uint32_t status; 255 256 status = smb_oplock_break_PARENT(&test_node, ofile); 257 printf(" brk-parent %d ret status=0x%x (%s)\n", 258 fid, status, xlate_nt_status(status)); 259 } 260 261 static void 262 do_brk_open(int fid, char *arg2) 263 { 264 smb_ofile_t *ofile = &ofile_array[fid]; 265 uint32_t status; 266 int disp = FILE_OPEN; 267 268 if (arg2 != NULL) 269 disp = strtol(arg2, NULL, 16); 270 271 status = smb_oplock_break_OPEN(&test_node, ofile, 7, disp); 272 printf(" brk-open %d ret status=0x%x (%s)\n", 273 fid, status, xlate_nt_status(status)); 274 } 275 276 static void 277 do_brk_handle(int fid) 278 { 279 smb_ofile_t *ofile = &ofile_array[fid]; 280 uint32_t status; 281 282 status = smb_oplock_break_HANDLE(&test_node, ofile); 283 printf(" brk-handle %d ret status=0x%x (%s)\n", 284 fid, status, xlate_nt_status(status)); 285 286 } 287 288 static void 289 do_brk_read(int fid) 290 { 291 smb_ofile_t *ofile = &ofile_array[fid]; 292 uint32_t status; 293 294 status = smb_oplock_break_READ(ofile->f_node, ofile); 295 printf(" brk-read %d ret status=0x%x (%s)\n", 296 fid, status, xlate_nt_status(status)); 297 } 298 299 static void 300 do_brk_write(int fid) 301 { 302 smb_ofile_t *ofile = &ofile_array[fid]; 303 uint32_t status; 304 305 status = smb_oplock_break_WRITE(ofile->f_node, ofile); 306 printf(" brk-write %d ret status=0x%x (%s)\n", 307 fid, status, xlate_nt_status(status)); 308 } 309 310 static void 311 do_brk_setinfo(int fid, char *arg2) 312 { 313 smb_ofile_t *ofile = &ofile_array[fid]; 314 uint32_t status; 315 int infoclass = FileEndOfFileInformation; /* 20 */ 316 317 if (arg2 != NULL) 318 infoclass = strtol(arg2, NULL, 16); 319 320 status = smb_oplock_break_SETINFO( 321 &test_node, ofile, infoclass); 322 printf(" brk-setinfo %d ret status=0x%x (%s)\n", 323 fid, status, xlate_nt_status(status)); 324 325 } 326 327 /* 328 * Move oplock to another FD, as specified, 329 * or any other available open 330 */ 331 static void 332 do_move(int fid, char *arg2) 333 { 334 smb_ofile_t *ofile = &ofile_array[fid]; 335 smb_ofile_t *of2; 336 int fid2; 337 338 if (arg2 == NULL) { 339 fprintf(stderr, "move: FID2 required\n"); 340 return; 341 } 342 fid2 = atoi(arg2); 343 if (fid2 <= 0 || fid2 >= MAXFID) { 344 fprintf(stderr, "move: bad FID2 %d\n", fid2); 345 return; 346 } 347 of2 = &ofile_array[fid2]; 348 349 smb_oplock_move(&test_node, ofile, of2); 350 printf(" move %d %d\n", fid, fid2); 351 } 352 353 /* 354 * Set/clear oplock.waiters, which affects ack-break 355 */ 356 static void 357 do_waiters(int fid, char *arg2) 358 { 359 smb_node_t *node = &test_node; 360 smb_oplock_t *ol = &node->n_oplock; 361 int old, new = 0; 362 363 if (arg2 != NULL) 364 new = atoi(arg2); 365 366 old = ol->waiters; 367 ol->waiters = new; 368 369 printf(" waiters %d -> %d\n", old, new); 370 } 371 372 int 373 main(int argc, char *argv[]) 374 { 375 smb_node_t *node = &test_node; 376 char *cmd; 377 char *arg1; 378 char *arg2; 379 char *savep; 380 char *sep = " \t\n"; 381 char *prompt = NULL; 382 int fid; 383 384 if (isatty(0)) 385 prompt = "> "; 386 387 smb_llist_constructor(&node->n_ofile_list, sizeof (smb_ofile_t), 388 offsetof(smb_ofile_t, f_node_lnd)); 389 390 for (fid = 0; fid < MAXFID; fid++) { 391 smb_ofile_t *f = &ofile_array[fid]; 392 393 f->f_magic = SMB_OFILE_MAGIC; 394 mutex_init(&f->f_mutex, NULL, MUTEX_DEFAULT, NULL); 395 f->f_fid = fid; 396 f->f_ftype = SMB_FTYPE_DISK; 397 f->f_node = &test_node; 398 } 399 400 for (;;) { 401 if (prompt) { 402 (void) fputs(prompt, stdout); 403 fflush(stdout); 404 } 405 406 cmd = fgets(cmdbuf, sizeof (cmdbuf), stdin); 407 if (cmd == NULL) 408 break; 409 if (cmd[0] == '#') 410 continue; 411 412 if (prompt == NULL) { 413 /* Put commands in the output too. */ 414 (void) fputs(cmdbuf, stdout); 415 } 416 cmd = strtok_r(cmd, sep, &savep); 417 if (cmd == NULL) 418 continue; 419 420 /* 421 * Commands with no args 422 */ 423 if (0 == strcmp(cmd, "help")) { 424 (void) fputs(helpstr, stdout); 425 continue; 426 } 427 428 if (0 == strcmp(cmd, "show")) { 429 do_show(); 430 continue; 431 } 432 433 /* 434 * Commands with one arg (the FID) 435 */ 436 arg1 = strtok_r(NULL, sep, &savep); 437 if (arg1 == NULL) { 438 fprintf(stderr, "%s missing arg1\n", cmd); 439 continue; 440 } 441 fid = atoi(arg1); 442 if (fid <= 0 || fid >= MAXFID) { 443 fprintf(stderr, "%s bad FID %d\n", cmd, fid); 444 continue; 445 } 446 447 if (0 == strcmp(cmd, "close")) { 448 do_close(fid); 449 continue; 450 } 451 if (0 == strcmp(cmd, "brk-parent")) { 452 do_brk_parent(fid); 453 continue; 454 } 455 if (0 == strcmp(cmd, "brk-handle")) { 456 do_brk_handle(fid); 457 continue; 458 } 459 if (0 == strcmp(cmd, "brk-read")) { 460 do_brk_read(fid); 461 continue; 462 } 463 if (0 == strcmp(cmd, "brk-write")) { 464 do_brk_write(fid); 465 continue; 466 } 467 468 /* 469 * Commands with an (optional) arg2. 470 */ 471 arg2 = strtok_r(NULL, sep, &savep); 472 473 if (0 == strcmp(cmd, "open")) { 474 do_open(fid, arg2); 475 continue; 476 } 477 if (0 == strcmp(cmd, "req")) { 478 do_req(fid, arg2); 479 continue; 480 } 481 if (0 == strcmp(cmd, "ack")) { 482 do_ack(fid, arg2); 483 continue; 484 } 485 if (0 == strcmp(cmd, "brk-open")) { 486 do_brk_open(fid, arg2); 487 continue; 488 } 489 if (0 == strcmp(cmd, "brk-setinfo")) { 490 do_brk_setinfo(fid, arg2); 491 continue; 492 } 493 if (0 == strcmp(cmd, "move")) { 494 do_move(fid, arg2); 495 continue; 496 } 497 if (0 == strcmp(cmd, "waiters")) { 498 do_waiters(fid, arg2); 499 continue; 500 } 501 502 fprintf(stderr, "%s unknown command. Try help\n", cmd); 503 } 504 return (0); 505 } 506 507 /* 508 * A few functions called by the oplock code 509 * Stubbed out, and/or just print a message. 510 */ 511 512 boolean_t 513 smb_node_is_file(smb_node_t *node) 514 { 515 return (B_TRUE); 516 } 517 518 boolean_t 519 smb_ofile_is_open(smb_ofile_t *ofile) 520 { 521 return (ofile->f_refcnt != 0); 522 } 523 524 int 525 smb_lock_range_access( 526 smb_request_t *sr, 527 smb_node_t *node, 528 uint64_t start, 529 uint64_t length, 530 boolean_t will_write) 531 { 532 return (0); 533 } 534 535 /* 536 * Test code replacement for: smb_oplock_send_brk() 537 */ 538 static void 539 test_oplock_send_brk(smb_ofile_t *ofile, 540 uint32_t NewLevel, boolean_t AckReq) 541 { 542 smb_oplock_grant_t *og = &ofile->f_oplock; 543 544 /* Skip building a message. */ 545 546 if ((og->og_state & OPLOCK_LEVEL_GRANULAR) != 0) 547 NewLevel |= OPLOCK_LEVEL_GRANULAR; 548 549 /* 550 * In a real server, we would send a break to the client, 551 * and keep track (at the SMB level) whether this oplock 552 * was obtained via a lease or an old-style oplock. 553 */ 554 if (AckReq) { 555 uint32_t BreakTo; 556 557 if ((og->og_state & OPLOCK_LEVEL_GRANULAR) != 0) { 558 559 BreakTo = (NewLevel & CACHE_RWH) << BREAK_SHIFT; 560 if (BreakTo == 0) 561 BreakTo = BREAK_TO_NO_CACHING; 562 } else { 563 if ((NewLevel & LEVEL_TWO_OPLOCK) != 0) 564 BreakTo = BREAK_TO_TWO; 565 else 566 BreakTo = BREAK_TO_NONE; 567 } 568 og->og_breaking = BreakTo; 569 last_ind_break_level = NewLevel; 570 /* Set og_state in do_ack */ 571 } else { 572 og->og_state = NewLevel; 573 /* Clear og_breaking in do_ack */ 574 } 575 } 576 577 /* 578 * Simplified version of what's in smb_srv_oplock.c 579 */ 580 void 581 smb_oplock_ind_break(smb_ofile_t *ofile, uint32_t NewLevel, 582 boolean_t AckReq, uint32_t status) 583 { 584 smb_oplock_grant_t *og = &ofile->f_oplock; 585 586 printf("*smb_oplock_ind_break fid=%d NewLevel=0x%x," 587 " AckReq=%d, ComplStatus=0x%x (%s)\n", 588 ofile->f_fid, NewLevel, AckReq, 589 status, xlate_nt_status(status)); 590 591 /* 592 * Note that the CompletionStatus from the FS level 593 * (smb_cmn_oplock.c) encodes what kind of action we 594 * need to take at the SMB level. 595 */ 596 switch (status) { 597 598 case NT_STATUS_SUCCESS: 599 case NT_STATUS_CANNOT_GRANT_REQUESTED_OPLOCK: 600 test_oplock_send_brk(ofile, NewLevel, AckReq); 601 break; 602 603 case NT_STATUS_OPLOCK_SWITCHED_TO_NEW_HANDLE: 604 case NT_STATUS_OPLOCK_HANDLE_CLOSED: 605 og->og_state = OPLOCK_LEVEL_NONE; 606 break; 607 608 default: 609 /* Checked by caller. */ 610 ASSERT(0); 611 break; 612 } 613 } 614 615 void 616 smb_oplock_ind_break_in_ack(smb_request_t *sr, smb_ofile_t *ofile, 617 uint32_t NewLevel, boolean_t AckRequired) 618 { 619 ASSERT(sr == &test_sr); 620 smb_oplock_ind_break(ofile, NewLevel, AckRequired, STATUS_CANT_GRANT); 621 } 622 623 uint32_t 624 smb_oplock_wait_break(smb_node_t *node, int timeout) 625 { 626 printf("*smb_oplock_wait_break (state=0x%x)\n", 627 node->n_oplock.ol_state); 628 return (0); 629 } 630 631 /* 632 * There are a couple DTRACE_PROBE* in smb_cmn_oplock.c but we're 633 * not linking with the user-level dtrace support, so just 634 * stub these out. 635 */ 636 void 637 __dtrace_fksmb___probe1(char *n, unsigned long a) 638 { 639 } 640 void 641 __dtrace_fksmb___probe2(char *n, unsigned long a, unsigned long b) 642 { 643 } 644