 @@ -1,14 +1,14 @@
-/* $NetBSD: cgd.c,v 1.61 2009/11/10 16:49:53 tron Exp $ */
+/* $NetBSD: cgd.c,v 1.62 2009/11/10 20:05:50 christos Exp $ */
 /*-
  * Copyright (c) 2002 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Roland C. Dowdeswell.
+ *
  * 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.
 @@ -20,44 +20,45 @@
  * ``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: cgd.c,v 1.61 2009/11/10 16:49:53 tron Exp $");
+__KERNEL_RCSID(0, "$NetBSD: cgd.c,v 1.62 2009/11/10 20:05:50 christos Exp $");
 #include <sys/types.h>
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/proc.h>
 #include <sys/errno.h>
 #include <sys/buf.h>
 #include <sys/bufq.h>
 #include <sys/malloc.h>
 #include <sys/pool.h>
 #include <sys/ioctl.h>
 #include <sys/device.h>
 #include <sys/disk.h>
 #include <sys/disklabel.h>
 #include <sys/fcntl.h>
 #include <sys/vnode.h>
 #include <sys/conf.h>
 #include <sys/syslog.h>
 #include <dev/dkvar.h>
 #include <dev/cgdvar.h>
 /* Entry Point Functions */
 void	cgdattach(int);
 static dev_type_open(cgdopen);
 static dev_type_close(cgdclose);
 static dev_type_read(cgdread);
 static dev_type_write(cgdwrite);
 static dev_type_ioctl(cgdioctl);
 @@ -173,35 +174,36 @@ cgdsoftc_init(struct cgd_softc *cs, int
+}
 void
 cgdattach(int num)
+{
 	int	i;
 	DPRINTF_FOLLOW(("cgdattach(%d)\n", num));
 	if (num <= 0) {
 		DIAGPANIC(("cgdattach: count <= 0"));
 		return;
+	}
-	cgd_softc = (void *)malloc(num * sizeof(*cgd_softc), M_DEVBUF, M_NOWAIT);
+	cgd_softc = malloc(num * sizeof(*cgd_softc), M_DEVBUF, M_NOWAIT);
 	if (!cgd_softc) {
-		printf("WARNING: unable to malloc(9) memory for crypt disks\n");
+		DPRINTF_FOLLOW(("WARNING: unable to malloc(9) memory for %d "
 		    "crypt disks\n", num));
 		DIAGPANIC(("cgdattach: cannot malloc(9) enough memory"));
 		return;
+	}
 	numcgd = num;
-	for (i=0; i<num; i++)
+	for (i = 0; i < num; i++)
 		cgdsoftc_init(&cgd_softc[i], i);
+}
 static int
 cgdopen(dev_t dev, int flags, int fmt, struct lwp *l)
+{
 	struct	cgd_softc *cs;
 	DPRINTF_FOLLOW(("cgdopen(0x%"PRIx64", %d)\n", dev, flags));
 	GETCGD_SOFTC(cs, dev);
 	return dk_open(di, &cs->sc_dksc, dev, flags, fmt, l);
+}
 @@ -352,27 +354,28 @@ cgdiodone(struct buf *nbp)
 	struct	cgd_softc *cs = getcgd_softc(obp->b_dev);
 	struct	dk_softc *dksc = &cs->sc_dksc;
 	KDASSERT(cs);
 	DPRINTF_FOLLOW(("cgdiodone(%p)\n", nbp));
 	DPRINTF(CGDB_IO, ("cgdiodone: bp %p bcount %d resid %d\n",
 	    obp, obp->b_bcount, obp->b_resid));
 	DPRINTF(CGDB_IO, (" dev 0x%"PRIx64", nbp %p bn %" PRId64 " addr %p bcnt %d\n",
 	    nbp->b_dev, nbp, nbp->b_blkno, nbp->b_data,
 	    nbp->b_bcount));
 	if (nbp->b_error != 0) {
 		obp->b_error = nbp->b_error;
-		printf("%s: error %d\n", dksc->sc_xname, obp->b_error);
+		DPRINTF(CGDB_IO, ("%s: error %d\n", dksc->sc_xname,
 		    obp->b_error));
+	}
 	/* Perform the decryption if we are reading.
+	 *
 	 * Note: use the blocknumber from nbp, since it is what
 	 *       we used to encrypt the blocks.
 	 */
 	if (nbp->b_flags & B_READ)
 		cgd_cipher(cs, obp->b_data, obp->b_data, obp->b_bcount,
 		    nbp->b_blkno, DEV_BSIZE, CGD_CIPHER_DECRYPT);
 	/* If we allocated memory, free it now... */
 @@ -562,35 +565,40 @@ cgd_ioctl_set(struct cgd_softc *cs, void
 		ret = EINVAL;
 		goto bail;
+	}
 	(void)memset(inbuf, 0, MAX_KEYSIZE);
 	ret = copyin(ci->ci_key, inbuf, keybytes);
 	if (ret)
 		goto bail;
 	cs->sc_cdata.cf_blocksize = ci->ci_blocksize;
 	cs->sc_cdata.cf_mode = encblkno[i].v;
 	cs->sc_cdata.cf_priv = cs->sc_cfuncs->cf_init(ci->ci_keylen, inbuf,
 	    &cs->sc_cdata.cf_blocksize);
 	if (cs->sc_cdata.cf_blocksize > CGD_MAXBLOCKSIZE) {
 	    log(LOG_WARNING, "cgd: Disallowed cipher with blocksize %zu > %u\n",
 		cs->sc_data.cf_blocksize, CGD_MAXBLOCKSIZE);
 	    cs->sc_cdata.cf_priv = NULL;
+	}
 	/*
 	 * The blocksize is supposed to be in bytes. Unfortunately originally
 	 * it was expressed in bits. For compatibility we maintain encblkno
 	 * and encblkno8.
 	 */
 	cs->sc_cdata.cf_blocksize /= encblkno[i].d;
 	(void)memset(inbuf, 0, MAX_KEYSIZE);
 	if (!cs->sc_cdata.cf_priv) {
 		printf("cgd: unable to initialize cipher\n");
 		ret = EINVAL;		/* XXX is this the right error? */
 		goto bail;
+	}
 	free(inbuf, M_TEMP);
 	bufq_alloc(&cs->sc_dksc.sc_bufq, "fcfs", 0);
 	cs->sc_data = malloc(MAXPHYS, M_DEVBUF, M_WAITOK);
 	cs->sc_data_used = 0;
 	cs->sc_dksc.sc_flags |= DKF_INITED;
 	/* Attach the disk. */
 @@ -765,29 +773,29 @@ blkno2blkno_buf(char *sbuf, daddr_t blkn
 static void
 cgd_cipher(struct cgd_softc *cs, void *dstv, void *srcv,
     size_t len, daddr_t blkno, size_t secsize, int dir)
+{
 	char		*dst = dstv;
 	char 		*src = srcv;
 	cfunc_cipher	*cipher = cs->sc_cfuncs->cf_cipher;
 	struct uio	dstuio;
 	struct uio	srcuio;
 	struct iovec	dstiov[2];
 	struct iovec	srciov[2];
 	size_t		blocksize = cs->sc_cdata.cf_blocksize;
-	char		sink[blocksize];
+	char		sink[CGD_MAXBLOCKSIZE];
-	char		zero_iv[blocksize];
+	char		zero_iv[CGD_MAXBLOCKSIZE];
-	char		blkno_buf[blocksize];
+	char		blkno_buf[CGD_MAXBLOCKSIZE];
 	DPRINTF_FOLLOW(("cgd_cipher() dir=%d\n", dir));
 	DIAGCONDPANIC(len % blocksize != 0,
 	    ("cgd_cipher: len %% blocksize != 0"));
 	/* ensure that sizeof(daddr_t) <= blocksize (for encblkno IVing) */
 	DIAGCONDPANIC(sizeof(daddr_t) > blocksize,
 	    ("cgd_cipher: sizeof(daddr_t) > blocksize"));
 	memset(zero_iv, 0x0, sizeof(zero_iv));
 	dstuio.uio_iov = dstiov;

 @@ -1,14 +1,14 @@
-/* $NetBSD: cgdvar.h,v 1.12 2008/09/12 16:51:55 christos Exp $ */
+/* $NetBSD: cgdvar.h,v 1.13 2009/11/10 20:05:50 christos Exp $ */
 /*-
  * Copyright (c) 2002 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Roland C. Dowdeswell.
+ *
  * 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.
 @@ -77,14 +77,17 @@ struct cgd_softc {
 	void *			 sc_data;	/* emergency buffer */
 	int			 sc_data_used;	/* Really lame, we'll change */
 	size_t			 sc_tpathlen;	/* length of prior string */
 	struct cryptdata	 sc_cdata;	/* crypto data */
 	struct cryptfuncs	*sc_cfuncs;	/* encryption functions */
 	struct simplelock	 sc_slock;	/* our lock */
 };
 #endif
 /* XXX XAX XXX elric:  check these out properly. */
 #define CGDIOCSET	_IOWR('F', 18, struct cgd_ioctl)
 #define CGDIOCCLR	_IOW('F', 19, struct cgd_ioctl)
 /* Maximum block sized to be used by the ciphers */
 #define CGD_MAXBLOCKSIZE	128
 #endif /* _DEV_CGDVAR_H_ */