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 }