/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2020 Tintri by DDN, Inc.  All rights reserved.
 * Copyright 2019 Joyent, Inc.
 * Copyright 2022 RackTop Systems, Inc.
 */

/*
 * Test & debug program for oplocks
 *
 * This implements a simple command reader which accepts
 * commands to simulate oplock events, and prints the
 * state changes and actions that would happen after
 * each event.
 */

#include <sys/types.h>
#include <sys/debug.h>
#include <sys/stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <unistd.h>

#include <smbsrv/smb_kproto.h>
#include <smbsrv/smb_oplock.h>

extern const char *xlate_nt_status(uint32_t);

#define	OPLOCK_CACHE_RWH	(READ_CACHING | HANDLE_CACHING | WRITE_CACHING)
#define	OPLOCK_TYPE	(LEVEL_TWO_OPLOCK | LEVEL_ONE_OPLOCK |\
			BATCH_OPLOCK | OPLOCK_LEVEL_GRANULAR)

#define	MAXFID 10

smb_node_t root_node, test_node;
smb_ofile_t  ofile_array[MAXFID];
smb_request_t test_sr;
uint32_t last_ind_break_level;
char cmdbuf[100];

static void run_ind_break_in_ack(smb_ofile_t *);

#define	BIT_DEF(name) { name, #name }

struct bit_defs {
	uint32_t mask;
	const char *name;
} state_bits[] = {
	BIT_DEF(NO_OPLOCK),
	BIT_DEF(BREAK_TO_NO_CACHING),
	BIT_DEF(BREAK_TO_WRITE_CACHING),
	BIT_DEF(BREAK_TO_HANDLE_CACHING),
	BIT_DEF(BREAK_TO_READ_CACHING),
	BIT_DEF(BREAK_TO_TWO_TO_NONE),
	BIT_DEF(BREAK_TO_NONE),
	BIT_DEF(BREAK_TO_TWO),
	BIT_DEF(BATCH_OPLOCK),
	BIT_DEF(LEVEL_ONE_OPLOCK),
	BIT_DEF(LEVEL_TWO_OPLOCK),
	BIT_DEF(MIXED_R_AND_RH),
	BIT_DEF(EXCLUSIVE),
	BIT_DEF(WRITE_CACHING),
	BIT_DEF(HANDLE_CACHING),
	BIT_DEF(READ_CACHING),
	{ 0, NULL }
};

/*
 * Helper to print flags fields
 */
static void
print_bits32(char *label, struct bit_defs *bit, uint32_t state)
{
	printf("%s0x%x (", label, state);
	while (bit->mask != 0) {
		if ((state & bit->mask) != 0)
			printf(" %s", bit->name);
		bit++;
	}
	printf(" )\n");
}

/*
 * Command language:
 *
 */
const char helpstr[] = "Commands:\n"
	"help\t\tList commands\n"
	"show\t\tShow OpLock state etc.\n"
	"open FID\n"
	"close FID\n"
	"req FID [OplockLevel]\n"
	"ack FID [OplockLevel]\n"
	"brk-parent FID\n"
	"brk-open [OverWrite]\n"
	"brk-handle FID\n"
	"brk-read FID\n"
	"brk-write FID\n"
	"brk-setinfo FID [InfoClass]\n"
	"move FID1 FID2\n"
	"waiters FID [count]\n";

/*
 * Command handlers
 */

static void
do_show(void)
{
	smb_node_t *node = &test_node;
	smb_oplock_t *ol = &node->n_oplock;
	uint32_t state = ol->ol_state;
	smb_ofile_t *f;

	print_bits32(" ol_state=", state_bits, state);

	if (ol->excl_open != NULL)
		printf(" Excl=Y (FID=%d)", ol->excl_open->f_fid);
	else
		printf(" Excl=n");
	printf(" cnt_II=%d cnt_R=%d cnt_RH=%d cnt_RHBQ=%d\n",
	    ol->cnt_II, ol->cnt_R, ol->cnt_RH, ol->cnt_RHBQ);

	printf(" ofile_cnt=%d\n", node->n_ofile_list.ll_count);
	FOREACH_NODE_OFILE(node, f) {
		smb_oplock_grant_t *og = &f->f_oplock;
		printf("  fid=%d Lease=%s State=0x%x",
		    f->f_fid,
		    f->TargetOplockKey,	/* lease */
		    og->og_state);
		if (og->og_breaking)
			printf(" BreakTo=0x%x", og->og_breakto);
		printf(" Excl=%s onlist:",
		    (ol->excl_open == f) ? "Y" : "N");
		if (og->onlist_II)
			printf(" II");
		if (og->onlist_R)
			printf(" R");
		if (og->onlist_RH)
			printf(" RH");
		if (og->onlist_RHBQ) {
			printf(" RHBQ(to %s)",
			    og->BreakingToRead ?
			    "read" : "none");
		}
		printf("\n");
	}
}

static void
do_open(int fid, char *arg2)
{
	smb_node_t *node = &test_node;
	smb_ofile_t *ofile = &ofile_array[fid];

	/*
	 * Simulate an open (minimal init)
	 */
	if (ofile->f_refcnt) {
		printf("open fid %d already opened\n");
		return;
	}

	if (arg2 != NULL) {
		(void) strlcpy((char *)ofile->TargetOplockKey, arg2,
		    SMB_LEASE_KEY_SZ);
	}

	ofile->f_refcnt++;
	node->n_open_count++;
	smb_llist_insert_tail(&node->n_ofile_list, ofile);
	printf(" open %d OK\n", fid);
}

static void
do_close(int fid)
{
	smb_node_t *node = &test_node;
	smb_ofile_t *ofile = &ofile_array[fid];

	/*
	 * Simulate an close
	 */
	if (ofile->f_refcnt <= 0) {
		printf(" close fid %d already closed\n");
		return;
	}

	smb_llist_enter(&node->n_ofile_list, RW_READER);
	mutex_enter(&node->n_oplock.ol_mutex);

	smb_oplock_break_CLOSE(ofile->f_node, ofile);

	smb_llist_remove(&node->n_ofile_list, ofile);
	node->n_open_count--;

	mutex_exit(&node->n_oplock.ol_mutex);
	smb_llist_exit(&node->n_ofile_list);

	ofile->f_refcnt--;

	bzero(ofile->TargetOplockKey, SMB_LEASE_KEY_SZ);

	printf(" close OK\n");
}

static void
do_req(int fid, char *arg2)
{
	smb_ofile_t *ofile = &ofile_array[fid];
	uint32_t oplock = BATCH_OPLOCK;
	uint32_t status;

	if (arg2 != NULL)
		oplock = strtol(arg2, NULL, 16);

	/*
	 * Request an oplock
	 */
	status = smb_oplock_request(&test_sr, ofile, &oplock);
	if (status == 0 ||
	    status == NT_STATUS_OPLOCK_BREAK_IN_PROGRESS) {
		ofile->f_oplock.og_state = oplock;
		/* When no break pending, breakto=state */
		ofile->f_oplock.og_breakto = oplock;
		ofile->f_oplock.og_breaking = B_FALSE;
	}
	printf(" req oplock fid=%d ret oplock=0x%x status=0x%x (%s)\n",
	    fid, oplock, status, xlate_nt_status(status));
}


static void
do_ack(int fid, char *arg2)
{
	smb_node_t *node = &test_node;
	smb_ofile_t *ofile = &ofile_array[fid];
	uint32_t oplock;
	uint32_t status;

	/* Default to level in last smb_oplock_ind_break() */
	oplock = last_ind_break_level;
	if (arg2 != NULL)
		oplock = strtol(arg2, NULL, 16);

	smb_llist_enter(&node->n_ofile_list, RW_READER);
	mutex_enter(&node->n_oplock.ol_mutex);

	ofile->f_oplock.og_breaking = 0;
	status = smb_oplock_ack_break(&test_sr, ofile, &oplock);
	if (status == 0)
		ofile->f_oplock.og_state = oplock;

	mutex_exit(&node->n_oplock.ol_mutex);
	smb_llist_exit(&node->n_ofile_list);

	if (status == NT_STATUS_OPLOCK_BREAK_IN_PROGRESS) {
		/* should not get this status */
		printf(" ack: break fid=%d, break-in-progress\n", fid);
		ASSERT(0);
	}

	printf(" ack: break fid=%d, newstate=0x%x, status=0x%x (%s)\n",
	    fid, oplock, status, xlate_nt_status(status));

	run_ind_break_in_ack(ofile);
}

static void
do_brk_parent(int fid)
{
	smb_ofile_t *ofile = &ofile_array[fid];
	uint32_t status;

	status = smb_oplock_break_PARENT(&test_node, ofile);
	printf(" brk-parent %d ret status=0x%x (%s)\n",
	    fid, status, xlate_nt_status(status));
}

static void
do_brk_open(int fid, char *arg2)
{
	smb_ofile_t *ofile = &ofile_array[fid];
	uint32_t status;
	int disp = FILE_OPEN;

	if (arg2 != NULL)
		disp = strtol(arg2, NULL, 16);

	status = smb_oplock_break_OPEN(&test_node, ofile, 7, disp);
	printf(" brk-open %d ret status=0x%x (%s)\n",
	    fid, status, xlate_nt_status(status));
}

static void
do_brk_handle(int fid)
{
	smb_ofile_t *ofile = &ofile_array[fid];
	uint32_t status;

	status = smb_oplock_break_HANDLE(&test_node, ofile);
	printf(" brk-handle %d ret status=0x%x (%s)\n",
	    fid, status, xlate_nt_status(status));

}

static void
do_brk_read(int fid)
{
	smb_ofile_t *ofile = &ofile_array[fid];
	uint32_t status;

	status = smb_oplock_break_READ(ofile->f_node, ofile);
	printf(" brk-read %d ret status=0x%x (%s)\n",
	    fid, status, xlate_nt_status(status));
}

static void
do_brk_write(int fid)
{
	smb_ofile_t *ofile = &ofile_array[fid];
	uint32_t status;

	status = smb_oplock_break_WRITE(ofile->f_node, ofile);
	printf(" brk-write %d ret status=0x%x (%s)\n",
	    fid, status, xlate_nt_status(status));
}

static void
do_brk_setinfo(int fid, char *arg2)
{
	smb_ofile_t *ofile = &ofile_array[fid];
	uint32_t status;
	int infoclass = FileEndOfFileInformation; /* 20 */

	if (arg2 != NULL)
		infoclass = strtol(arg2, NULL, 16);

	status = smb_oplock_break_SETINFO(
	    &test_node, ofile, infoclass);
	printf(" brk-setinfo %d 0x%x ret status=0x%x (%s)\n",
	    fid, infoclass, status, xlate_nt_status(status));

}

/*
 * Move oplock to another FD, as specified,
 * or any other available open
 */
static void
do_move(int fid, char *arg2)
{
	smb_node_t *node = &test_node;
	smb_ofile_t *ofile = &ofile_array[fid];
	smb_ofile_t *of2;
	int fid2;

	if (arg2 == NULL) {
		fprintf(stderr, "move: FID2 required\n");
		return;
	}
	fid2 = atoi(arg2);
	if (fid2 <= 0 || fid2 >= MAXFID) {
		fprintf(stderr, "move: bad FID2 %d\n", fid2);
		return;
	}
	of2 = &ofile_array[fid2];

	mutex_enter(&node->n_oplock.ol_mutex);

	smb_oplock_move(&test_node, ofile, of2);

	mutex_exit(&node->n_oplock.ol_mutex);

	printf(" move %d %d\n", fid, fid2);
}

/*
 * Set/clear oplock.waiters, which affects ack-break
 */
static void
do_waiters(int fid, char *arg2)
{
	smb_node_t *node = &test_node;
	smb_oplock_t *ol = &node->n_oplock;
	int old, new = 0;

	if (arg2 != NULL)
		new = atoi(arg2);

	old = ol->waiters;
	ol->waiters = new;

	printf(" waiters %d -> %d\n", old, new);
}

int
main(int argc, char *argv[])
{
	smb_node_t *node = &test_node;
	char *cmd;
	char *arg1;
	char *arg2;
	char *savep;
	char *sep = " \t\n";
	char *prompt = NULL;
	int fid;

	if (isatty(0))
		prompt = "> ";

	mutex_init(&node->n_mutex, NULL, MUTEX_DEFAULT, NULL);

	smb_llist_constructor(&node->n_ofile_list, sizeof (smb_ofile_t),
	    offsetof(smb_ofile_t, f_node_lnd));

	for (fid = 0; fid < MAXFID; fid++) {
		smb_ofile_t *f = &ofile_array[fid];

		f->f_magic = SMB_OFILE_MAGIC;
		mutex_init(&f->f_mutex, NULL, MUTEX_DEFAULT, NULL);
		f->f_fid = fid;
		f->f_ftype = SMB_FTYPE_DISK;
		f->f_node = &test_node;
	}

	for (;;) {
		if (prompt) {
			(void) fputs(prompt, stdout);
			fflush(stdout);
		}

		cmd = fgets(cmdbuf, sizeof (cmdbuf), stdin);
		if (cmd == NULL)
			break;
		if (cmd[0] == '#')
			continue;

		if (prompt == NULL) {
			/* Put commands in the output too. */
			(void) fputs(cmdbuf, stdout);
		}
		cmd = strtok_r(cmd, sep, &savep);
		if (cmd == NULL)
			continue;

		/*
		 * Commands with no args
		 */
		if (0 == strcmp(cmd, "help")) {
			(void) fputs(helpstr, stdout);
			continue;
		}

		if (0 == strcmp(cmd, "show")) {
			do_show();
			continue;
		}

		/*
		 * Commands with one arg (the FID)
		 */
		arg1 = strtok_r(NULL, sep, &savep);
		if (arg1 == NULL) {
			fprintf(stderr, "%s missing arg1\n", cmd);
			continue;
		}
		fid = atoi(arg1);
		if (fid <= 0 || fid >= MAXFID) {
			fprintf(stderr, "%s bad FID %d\n", cmd, fid);
			continue;
		}

		if (0 == strcmp(cmd, "close")) {
			do_close(fid);
			continue;
		}
		if (0 == strcmp(cmd, "brk-parent")) {
			do_brk_parent(fid);
			continue;
		}
		if (0 == strcmp(cmd, "brk-handle")) {
			do_brk_handle(fid);
			continue;
		}
		if (0 == strcmp(cmd, "brk-read")) {
			do_brk_read(fid);
			continue;
		}
		if (0 == strcmp(cmd, "brk-write")) {
			do_brk_write(fid);
			continue;
		}

		/*
		 * Commands with an (optional) arg2.
		 */
		arg2 = strtok_r(NULL, sep, &savep);

		if (0 == strcmp(cmd, "open")) {
			do_open(fid, arg2);
			continue;
		}
		if (0 == strcmp(cmd, "req")) {
			do_req(fid, arg2);
			continue;
		}
		if (0 == strcmp(cmd, "ack")) {
			do_ack(fid, arg2);
			continue;
		}
		if (0 == strcmp(cmd, "brk-open")) {
			do_brk_open(fid, arg2);
			continue;
		}
		if (0 == strcmp(cmd, "brk-setinfo")) {
			do_brk_setinfo(fid, arg2);
			continue;
		}
		if (0 == strcmp(cmd, "move")) {
			do_move(fid, arg2);
			continue;
		}
		if (0 == strcmp(cmd, "waiters")) {
			do_waiters(fid, arg2);
			continue;
		}

		fprintf(stderr, "%s unknown command. Try help\n", cmd);
	}
	return (0);
}

/*
 * A few functions called by the oplock code
 * Stubbed out, and/or just print a message.
 */

boolean_t
smb_node_is_file(smb_node_t *node)
{
	return (B_TRUE);
}

boolean_t
smb_ofile_is_open(smb_ofile_t *ofile)
{
	return (ofile->f_refcnt != 0);
}

int
smb_lock_range_access(
    smb_request_t	*sr,
    smb_node_t		*node,
    uint64_t		start,
    uint64_t		length,
    boolean_t		will_write)
{
	return (0);
}

/*
 * Test code replacement for combination of:
 *	smb_oplock_hdl_update()
 *	smb_oplock_send_break()
 *
 * In a real server, we would send a break to the client,
 * and keep track (at the SMB level) whether this oplock
 * was obtained via a lease or an old-style oplock.
 */
static void
test_oplock_send_break(smb_ofile_t *ofile,
    uint32_t NewLevel, boolean_t AckReq)
{
	smb_oplock_grant_t *og = &ofile->f_oplock;
	uint32_t OldLevel;

	/* Skip building a message. */

	if ((og->og_state & OPLOCK_LEVEL_GRANULAR) != 0)
		NewLevel |= OPLOCK_LEVEL_GRANULAR;

	OldLevel = og->og_state;
	og->og_breakto = NewLevel;
	og->og_breaking = B_TRUE;

	printf("*smb_oplock_send_break fid=%d "
	    "NewLevel=0x%x, OldLevel=0x%x, AckReq=%d)\n",
	    ofile->f_fid, NewLevel, OldLevel, AckReq);

	if (!AckReq) {
		og->og_state = NewLevel;
		og->og_breaking = B_FALSE;
	}

	/* Next, smb_oplock_send_break() would send a break. */
	last_ind_break_level = NewLevel;
}

/*
 * Simplified version of what's in smb_srv_oplock.c
 */
void
smb_oplock_ind_break(smb_ofile_t *ofile, uint32_t NewLevel,
    boolean_t AckReq, uint32_t status)
{
	smb_oplock_grant_t *og = &ofile->f_oplock;

	printf("*smb_oplock_ind_break fid=%d NewLevel=0x%x,"
	    " AckReq=%d, ComplStatus=0x%x (%s)\n",
	    ofile->f_fid, NewLevel, AckReq,
	    status, xlate_nt_status(status));

	/*
	 * Note that the CompletionStatus from the FS level
	 * (smb_cmn_oplock.c) encodes what kind of action we
	 * need to take at the SMB level.
	 */
	switch (status) {

	case NT_STATUS_SUCCESS:
	case NT_STATUS_CANNOT_GRANT_REQUESTED_OPLOCK:
		test_oplock_send_break(ofile, NewLevel, AckReq);
		break;

	case NT_STATUS_OPLOCK_SWITCHED_TO_NEW_HANDLE:
	case NT_STATUS_OPLOCK_HANDLE_CLOSED:
		og->og_state = OPLOCK_LEVEL_NONE;
		og->og_breakto = OPLOCK_LEVEL_NONE;
		og->og_breaking = B_FALSE;
		break;

	default:
		ASSERT(0);
		break;
	}
}

/* Arrange for break_in_ack to run after ack completes. */
static uint32_t break_in_ack_NewLevel;
static boolean_t break_in_ack_AckReq;
static boolean_t break_in_ack_called;

void
smb_oplock_ind_break_in_ack(smb_request_t *sr, smb_ofile_t *ofile,
    uint32_t NewLevel, boolean_t AckRequired)
{
	ASSERT(sr == &test_sr);

	/* Process these after ack */
	ASSERT(!break_in_ack_called);
	break_in_ack_called = B_TRUE;
	break_in_ack_NewLevel = NewLevel;
	break_in_ack_AckReq = AckRequired;
}

static void
run_ind_break_in_ack(smb_ofile_t *ofile)
{
	uint32_t NewLevel;
	boolean_t AckReq;

	/* Process these after ack */
	if (!break_in_ack_called)
		return;
	break_in_ack_called = B_FALSE;
	NewLevel = break_in_ack_NewLevel;
	AckReq = break_in_ack_AckReq;

	printf("*smb_oplock_ind_break_in_ack fid=%d NewLevel=0x%x,"
	    " AckReq=%d\n",
	    ofile->f_fid, NewLevel, AckReq);

	test_oplock_send_break(ofile, NewLevel, AckReq);
}

uint32_t
smb_oplock_wait_break(smb_request_t *sr, smb_node_t *node, int timeout)
{
	printf("*smb_oplock_wait_break (state=0x%x)\n",
	    node->n_oplock.ol_state);
	return (0);
}

int
smb_fem_oplock_install(smb_node_t *node)
{
	return (0);
}

void
smb_fem_oplock_uninstall(smb_node_t *node)
{
}

/*
 * There are a couple DTRACE_PROBE* in smb_cmn_oplock.c but we're
 * not linking with the user-level dtrace support, so just
 * stub these out.
 */
void
__dtrace_fksmb___probe1(char *n, unsigned long a)
{
}
void
__dtrace_fksmb___probe2(char *n, unsigned long a, unsigned long b)
{
}