/* $NetBSD: readhappy_mpsafe.c,v 1.3 2025/06/27 21:36:22 andvar Exp $ */

/* $NetBSD: readhappy_mpsafe.c,v 1.3 2025/06/27 21:36:22 andvar Exp $ */

/*-
* Copyright (c) 2018 The NetBSD Foundation, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: readhappy_mpsafe.c,v 1.3 2025/06/27 21:36:22 andvar Exp $");

#include <sys/param.h>
#include <sys/module.h>
#include <sys/condvar.h>
#include <sys/conf.h>
#include <sys/device.h>
#include <sys/kernel.h>
#include <sys/mutex.h>

/*
* This module is a modification of the readhappy module to illustrate
* how to make a device MPSAFE (Multiprocessor Safe).
*
* 1. Supports opening device by multiple processes but allows only one at a time.
* 2. Supports multiple read() functions but allows only one at a time.
* 3. Uses mutex for ensuring synchronization.
*
* Create a device /dev/happy_mpsafe from which you can read sequential happy numbers.
*
* To use this device you need to do:
* mknod /dev/happy_mpsafe c 351 0
*
* To test whether the device is MPSAFE. Compile and run the test_readhappy file
* provided.
*/

#define HAPPY_NUMBER 1

#define SAD_NUMBER 4

/*
* kmutex_t variables have been added to the structure to
* ensure proper synchronization while opened by multiple devices.
*
* kcondvar_t conditional variable added. Boolean part added to
* check whether the device is in use.
*/

struct happy_softc {
kcondvar_t cv;
bool inuse_cv;
unsigned last;
kmutex_t lock;
kmutex_t read_lock;
};

static struct happy_softc sc;

static unsigned
dsum(unsigned n)
{
unsigned sum, x;

for (sum = 0; n; n /= 10) {
x = n % 10;
sum += x * x;
}
return sum;
}

static int
check_happy(unsigned n)
{
unsigned total;

KASSERT(mutex_owned(&sc.read_lock));

for (;;) {
total = dsum(n);

if (total == HAPPY_NUMBER)
return 1;
if (total == SAD_NUMBER)
return 0;

n = total;
}
}

dev_type_open(happy_open);
dev_type_close(happy_close);
dev_type_read(happy_read);

/*
* Notice that the .d_flag has a additional D_MPSAFE flag to
* tag is as a multiprocessor safe device.
*/

static struct cdevsw happy_cdevsw = {
.d_open = happy_open,
.d_close = happy_close,
.d_read = happy_read,
.d_write = nowrite,
.d_ioctl = noioctl,
.d_stop = nostop,
.d_tty = notty,
.d_poll = nopoll,
.d_mmap = nommap,
.d_kqfilter = nokqfilter,
.d_discard = nodiscard,
.d_flag = D_OTHER | D_MPSAFE,
};

/*
* happy_open : used to open the device for read. mutex_enter and mutex_exit:
* to lock the critical section and allow only a single process to open the
* device at a time.
*/
int
happy_open(dev_t self __unused, int flag __unused, int mode __unused,
struct lwp *l __unused)
{
int error;

error = 0;

mutex_enter(&sc.lock);
while (sc.inuse_cv == true) {
error = cv_wait_sig(&sc.cv, &sc.lock);
if (error)
break;
}
if (!error) {
sc.inuse_cv = true;
sc.last = 0;
}
mutex_exit(&sc.lock);

return 0;
}

/*
* happy_close allows only a single process to close the device at a time.
* It uses mutex_enter and mutex_exit for the same.
*/
int
happy_close(dev_t self __unused, int flag __unused, int mode __unused,
struct lwp *l __unused)
{

mutex_enter(&sc.lock);
sc.inuse_cv = false;
cv_signal(&sc.cv);
mutex_exit(&sc.lock);

return 0;
}

/*
* happy_read allows only a single file descriptor to read at a point of time
* it uses mutex_enter and mutex_exit: to lock the critical section and allow
* only a single process to open the device at a time.
*/
int
happy_read(dev_t self __unused, struct uio *uio, int flags __unused)
{
char line[80];
int error, len;

mutex_enter(&sc.read_lock);

while (check_happy(++sc.last) == 0)
continue;

len = snprintf(line, sizeof(line), "%u\n", sc.last);

if (uio->uio_resid < len) {
--sc.last;
error = EINVAL;
goto fin;
}

error = uiomove(line, len, uio);

fin:
mutex_exit(&sc.read_lock);

return error;
}

MODULE(MODULE_CLASS_MISC, happy_mpsafe, NULL);

/*
* Initializing mutex and conditional variables for read() and open().
* when the module is being loaded.
*/
static int
happy_mpsafe_modcmd(modcmd_t cmd, void *arg __unused)
{
int cmajor = 351, bmajor = -1;

switch (cmd) {
case MODULE_CMD_INIT:
if (devsw_attach("happy_mpsafe", NULL, &bmajor, &happy_cdevsw,
&cmajor))
return ENXIO;

mutex_init(&sc.lock, MUTEX_DEFAULT, IPL_NONE);
mutex_init(&sc.read_lock, MUTEX_DEFAULT, IPL_NONE);
cv_init(&sc.cv, "example conditional variable");
return 0;
case MODULE_CMD_FINI:
mutex_destroy(&sc.lock);
mutex_destroy(&sc.read_lock);
cv_destroy(&sc.cv);
devsw_detach(NULL, &happy_cdevsw);
return 0;
default:
return ENOTTY;
}
}