sockbufs: add sbreserve_locked_limit() with custom maxsockbuf limit.
ClosedPublic
Actions

Authored by melifaro on Sep 27 2022, 1:57 PM.

Details

Reviewers

Group Reviewers

Commits

rG2631a2599b8b: sockbufs: add sbreserve_locked_limit() with custom maxsockbuf limit.
rG7b660faa9e30: sockbufs: add sbreserve_locked_limit() with custom maxsockbuf limit.

Summary

Protocols such as netlink may need a large socket receive buffer,
measured in tens of megabytes. This change allows netlink to
set larger socket buffers (given the privs are in place), without
requiring user to manuall bump maxsockbuf.

Diff Detail

Repository

rG FreeBSD src repository

Lint

Lint Not Applicable

Unit

Tests Not Applicable

Event Timeline

melifaro created this revision.Sep 27 2022, 1:57 PM

Herald added a subscriber: imp. · View Herald TranscriptSep 27 2022, 1:57 PM

melifaro requested review of this revision.Sep 27 2022, 1:57 PM

Harbormaster completed remote builds in B47563: Diff 111068.Sep 27 2022, 1:57 PM

glebius accepted this revision.Sep 27 2022, 5:42 PM

This revision is now accepted and ready to land.Sep 27 2022, 5:42 PM

Closed by commit rG7b660faa9e30: sockbufs: add sbreserve_locked_limit() with custom maxsockbuf limit. (authored by melifaro). · Explain WhySep 28 2022, 10:21 AM

This revision was automatically updated to reflect the committed changes.

melifaro added a commit: rG7b660faa9e30: sockbufs: add sbreserve_locked_limit() with custom maxsockbuf limit..

melifaro added a commit: rG2631a2599b8b: sockbufs: add sbreserve_locked_limit() with custom maxsockbuf limit..Feb 9 2023, 8:52 PM

Revision Contents
Changeset List

Path

Size

sys/

kern/

uipc_sockbuf.c

22 lines

sys/

sockbuf.h

2 lines

Diff 111130

View Options

sys/kern/uipc_sockbuf.c

This file was added.

				/*-
				* SPDX-License-Identifier: BSD-2-Clause
				*
				* Copyright (c) 2023-2024 Chelsio Communications, Inc.
				* Written by: John Baldwin <jhb@FreeBSD.org>
				*/

				#include <sys/disk.h>
				#include <sys/gsb_crc32.h>
				#include <sys/ioctl.h>
				#include <sys/stat.h>
				#include <net/ieee_oui.h>
				#include <err.h>
				#include <errno.h>
				#include <fcntl.h>
				#include <libnvmf.h>
				#include <libutil.h>
				#include <stdlib.h>
				#include <string.h>
				#include <unistd.h>

				#include "internal.h"

				#define RAMDISK_PREFIX "ramdisk:"

				struct backing_device {
				enum { RAMDISK, FILE, CDEV } type;
				union {
				int fd; /* FILE, CDEV */
				void mem; / RAMDISK */
				};
				u_int sector_size;
				uint64_t nlbas;
				uint64_t eui64;
				};

				static struct backing_device *devices;
				static u_int ndevices;

				static uint64_t
				generate_eui64(uint32_t low)
				{
				return (OUI_FREEBSD_NVME_LOW << 16 \| low);
				}

				static uint32_t
				crc32(const void *buf, size_t len)
				{
				return (calculate_crc32c(0xffffffff, buf, len) ^ 0xffffffff);
				}

				static void
				init_ramdisk(const char config, struct backing_device dev)
				{
				static uint32_t ramdisk_idx = 1;
				uint64_t num;

				dev->type = RAMDISK;
				dev->sector_size = 512;
				if (expand_number(config, &num))
				errx(1, "Invalid ramdisk specification: %s", config);
				if ((num % dev->sector_size) != 0)
				errx(1, "Invalid ramdisk size %ju", (uintmax_t)num);
				dev->mem = calloc(num, 1);
				dev->nlbas = num / dev->sector_size;
				dev->eui64 = generate_eui64('M' << 24 \| ramdisk_idx++);
				}

				static void
				init_filedevice(const char config, int fd, struct stat sb,
				struct backing_device *dev)
				{
				dev->type = FILE;
				dev->fd = fd;
				dev->sector_size = 512;
				if ((sb->st_size % dev->sector_size) != 0)
				errx(1, "File size is not a multiple of 512: %s", config);
				dev->nlbas = sb->st_size / dev->sector_size;
				dev->eui64 = generate_eui64('F' << 24 \|
				(crc32(config, strlen(config)) & 0xffffff));
				}
				impUnsubmitted Not Done Inline Actions I'd make this a #define... it could be 4k too, or at least it might be nice. imp: I'd make this a #define... it could be 4k too, or at least it might be nice.
				jhbAuthorUnsubmitted Done Inline Actions I guess this can use DEV_BSIZE as that is hardcoded as 512 in practice. In theory this could be a configurable knob, but the userspace controller isn't really intended for serious production use, more for testing / debugging. jhb: I guess this can use DEV_BSIZE as that is hardcoded as 512 in practice. In theory this could…

				static void
				init_chardevice(const char config, int fd, struct backing_device dev)
				{
				off_t len;

				dev->type = CDEV;
				dev->fd = fd;
				if (ioctl(fd, DIOCGSECTORSIZE, &dev->sector_size) != 0)
				err(1, "Failed to fetch sector size for %s", config);
				if (ioctl(fd, DIOCGMEDIASIZE, &len) != 0)
				err(1, "Failed to fetch sector size for %s", config);
				dev->nlbas = len / dev->sector_size;
				dev->eui64 = generate_eui64('C' << 24 \|
				(crc32(config, strlen(config)) & 0xffffff));
				}

				static void
				init_device(const char config, struct backing_device dev)
				{
				struct stat sb;
				int fd;

				/* Check for a RAM disk. */
				if (strncmp(RAMDISK_PREFIX, config, strlen(RAMDISK_PREFIX)) == 0) {
				init_ramdisk(config + strlen(RAMDISK_PREFIX), dev);
				return;
				}

				fd = open(config, O_RDWR);
				if (fd == -1)
				err(1, "Failed to open %s", config);
				if (fstat(fd, &sb) == -1)
				err(1, "fstat");
				switch (sb.st_mode & S_IFMT) {
				case S_IFCHR:
				init_chardevice(config, fd, dev);
				break;
				case S_IFREG:
				init_filedevice(config, fd, &sb, dev);
				break;
				default:
				errx(1, "Invalid file type for %s", config);
				}
				}

				void
				register_devices(int ac, char **av)
				{
				ndevices = ac;
				devices = calloc(ndevices, sizeof(*devices));

				for (int i = 0; i < ac; i++)
				init_device(av[i], &devices[i]);
				}

				u_int
				device_count(void)
				{
				return (ndevices);
				}

				static struct backing_device *
				lookup_device(uint32_t nsid)
				{
				if (nsid == 0 \|\| nsid > ndevices)
				return (NULL);
				return (&devices[nsid - 1]);
				}

				void
				device_active_nslist(uint32_t nsid, struct nvme_ns_list *nslist)
				{
				u_int count;

				memset(nslist, 0, sizeof(*nslist));
				count = 0;
				nsid++;
				while (nsid <= ndevices) {
				nslist->ns[count] = htole32(nsid);
				count++;
				if (count == nitems(nslist->ns))
				break;
				nsid++;
				}
				}

				bool
				device_identification_descriptor(uint32_t nsid, void *buf)
				{
				struct backing_device *dev;
				char *p;

				dev = lookup_device(nsid);
				if (dev == NULL)
				return (false);

				memset(buf, 0, 4096);

				p = buf;

				/* EUI64 */
				*p++ = 1;
				*p++ = 8;
				p += 2;
				be64enc(p, dev->eui64);
				return (true);
				}

				bool
				device_namespace_data(uint32_t nsid, struct nvme_namespace_data *nsdata)
				{
				struct backing_device *dev;

				dev = lookup_device(nsid);
				if (dev == NULL)
				return (false);

				memset(nsdata, 0, sizeof(*nsdata));
				nsdata->nsze = htole64(dev->nlbas);
				nsdata->ncap = nsdata->nsze;
				nsdata->nuse = nsdata->ncap;
				nsdata->nlbaf = 1 - 1;
				nsdata->flbas = NVMEF(NVME_NS_DATA_FLBAS_FORMAT, 0);
				nsdata->lbaf[0] = NVMEF(NVME_NS_DATA_LBAF_LBADS,
				ffs(dev->sector_size) - 1);

				be64enc(nsdata->eui64, dev->eui64);
				return (true);
				}

				static bool
				read_buffer(int fd, void *buf, size_t len, off_t offset)
				{
				ssize_t nread;
				char *dst;

				dst = buf;
				while (len > 0) {
				nread = pread(fd, dst, len, offset);
				if (nread == -1 && errno == EINTR)
				continue;
				if (nread <= 0)
				return (false);
				dst += nread;
				len -= nread;
				offset += nread;
				}
				return (true);
				}

				void
				device_read(uint32_t nsid, uint64_t lba, u_int nlb,
				const struct nvmf_capsule *nc)
				{
				struct backing_device *dev;
				char p, src;
				off_t off;
				size_t len;

				dev = lookup_device(nsid);
				if (dev == NULL) {
				nvmf_send_generic_error(nc,
				NVME_SC_INVALID_NAMESPACE_OR_FORMAT);
				return;
				}

				if (lba + nlb < lba \|\| lba + nlb > dev->nlbas) {
				nvmf_send_generic_error(nc, NVME_SC_LBA_OUT_OF_RANGE);
				return;
				}

				off = lba * dev->sector_size;
				len = nlb * dev->sector_size;
				if (nvmf_capsule_data_len(nc) != len) {
				nvmf_send_generic_error(nc, NVME_SC_INVALID_FIELD);
				return;
				}

				if (dev->type == RAMDISK) {
				p = NULL;
				src = (char *)dev->mem + off;
				} else {
				p = malloc(len);
				if (!read_buffer(dev->fd, p, len, off)) {
				free(p);
				nvmf_send_generic_error(nc,
				NVME_SC_INTERNAL_DEVICE_ERROR);
				return;
				}
				src = p;
				}

				nvmf_send_controller_data(nc, src, len);
				free(p);
				}

				static bool
				write_buffer(int fd, const void *buf, size_t len, off_t offset)
				{
				ssize_t nwritten;
				const char *src;

				src = buf;
				while (len > 0) {
				nwritten = pwrite(fd, src, len, offset);
				impUnsubmitted Not Done Inline Actions what happens when malloc fails? core dump? imp: what happens when malloc fails? core dump?
				jhbAuthorUnsubmitted Done Inline Actions Yep. (Again, this is only relevant when running the userspace controller, not for the production use case). jhb: Yep. (Again, this is only relevant when running the userspace controller, not for the…
				if (nwritten == -1 && errno == EINTR)
				continue;
				if (nwritten <= 0)
				return (false);
				src += nwritten;
				len -= nwritten;
				offset += nwritten;
				}
				return (true);
				}

				void
				device_write(uint32_t nsid, uint64_t lba, u_int nlb,
				const struct nvmf_capsule *nc)
				{
				struct backing_device *dev;
				char p, dst;
				off_t off;
				size_t len;
				int error;

				dev = lookup_device(nsid);
				if (dev == NULL) {
				nvmf_send_generic_error(nc,
				NVME_SC_INVALID_NAMESPACE_OR_FORMAT);
				return;
				}

				if (lba + nlb < lba \|\| lba + nlb > dev->nlbas) {
				nvmf_send_generic_error(nc, NVME_SC_LBA_OUT_OF_RANGE);
				return;
				}

				off = lba * dev->sector_size;
				len = nlb * dev->sector_size;
				if (nvmf_capsule_data_len(nc) != len) {
				nvmf_send_generic_error(nc, NVME_SC_INVALID_FIELD);
				return;
				}

				if (dev->type == RAMDISK) {
				p = NULL;
				dst = (char *)dev->mem + off;
				} else {
				p = malloc(len);
				dst = p;
				}

				error = nvmf_receive_controller_data(nc, 0, dst, len);
				if (error != 0) {
				nvmf_send_generic_error(nc, NVME_SC_TRANSIENT_TRANSPORT_ERROR);
				free(p);
				return;
				}

				if (dev->type != RAMDISK) {
				if (!write_buffer(dev->fd, p, len, off)) {
				free(p);
				nvmf_send_generic_error(nc,
				NVME_SC_INTERNAL_DEVICE_ERROR);
				return;
				}
				}
				free(p);
				nvmf_send_success(nc);
				}

				void
				device_flush(uint32_t nsid, const struct nvmf_capsule *nc)
				{
				struct backing_device *dev;

				dev = lookup_device(nsid);
				if (dev == NULL) {
				nvmf_send_generic_error(nc,
				NVME_SC_INVALID_NAMESPACE_OR_FORMAT);
				return;
				}

				switch (dev->type) {
				case RAMDISK:
				break;
				case FILE:
				if (fdatasync(dev->fd) == -1) {
				nvmf_send_error(nc, NVME_SCT_MEDIA_ERROR,
				NVME_SC_WRITE_FAULTS);
				return;
				}
				break;
				case CDEV:
				if (ioctl(dev->fd, DIOCGFLUSH) == -1) {
				nvmf_send_error(nc, NVME_SCT_MEDIA_ERROR,
				NVME_SC_WRITE_FAULTS);
				return;
				}
				}

				nvmf_send_success(nc);
				}