1 /*-
2 * SPDX-License-Identifier: (Beerware AND BSD-3-Clause)
3 *
4 * ----------------------------------------------------------------------------
5 * "THE BEER-WARE LICENSE" (Revision 42):
6 * <phk@FreeBSD.ORG> wrote this file. As long as you retain this notice you
7 * can do whatever you want with this stuff. If we meet some day, and you think
8 * this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp
9 * ----------------------------------------------------------------------------
10 *
11 */
12
13 /*-
14 * The following functions are based on the historical vn(4) driver:
15 * mdstart_swap(), mdstart_vnode(), mdcreate_swap(), mdcreate_vnode()
16 * and mddestroy(), and as such under the following copyright:
17 *
18 * Copyright (c) 1988 University of Utah.
19 * Copyright (c) 1990, 1993
20 * The Regents of the University of California. All rights reserved.
21 * Copyright (c) 2013 The FreeBSD Foundation
22 * All rights reserved.
23 *
24 * This code is derived from software contributed to Berkeley by
25 * the Systems Programming Group of the University of Utah Computer
26 * Science Department.
27 *
28 * Portions of this software were developed by Konstantin Belousov
29 * under sponsorship from the FreeBSD Foundation.
30 *
31 * Redistribution and use in source and binary forms, with or without
32 * modification, are permitted provided that the following conditions
33 * are met:
34 * 1. Redistributions of source code must retain the above copyright
35 * notice, this list of conditions and the following disclaimer.
36 * 2. Redistributions in binary form must reproduce the above copyright
37 * notice, this list of conditions and the following disclaimer in the
38 * documentation and/or other materials provided with the distribution.
39 * 3. Neither the name of the University nor the names of its contributors
40 * may be used to endorse or promote products derived from this software
41 * without specific prior written permission.
42 *
43 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
44 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
45 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
46 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
47 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
48 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
49 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
50 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
51 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
52 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
53 * SUCH DAMAGE.
54 *
55 * from: Utah Hdr: vn.c 1.13 94/04/02
56 * From: src/sys/dev/vn/vn.c,v 1.122 2000/12/16 16:06:03
57 */
58
59 #include "opt_rootdevname.h"
60 #include "opt_geom.h"
61 #include "opt_md.h"
62
63 #include <sys/param.h>
64 #include <sys/systm.h>
65 #include <sys/bio.h>
66 #include <sys/buf.h>
67 #include <sys/conf.h>
68 #include <sys/devicestat.h>
69 #include <sys/fcntl.h>
70 #include <sys/kernel.h>
71 #include <sys/kthread.h>
72 #include <sys/limits.h>
73 #include <sys/linker.h>
74 #include <sys/lock.h>
75 #include <sys/malloc.h>
76 #include <sys/mdioctl.h>
77 #include <sys/mount.h>
78 #include <sys/mutex.h>
79 #include <sys/sx.h>
80 #include <sys/namei.h>
81 #include <sys/proc.h>
82 #include <sys/queue.h>
83 #include <sys/rwlock.h>
84 #include <sys/sbuf.h>
85 #include <sys/sched.h>
86 #include <sys/sf_buf.h>
87 #include <sys/sysctl.h>
88 #include <sys/uio.h>
89 #include <sys/unistd.h>
90 #include <sys/vnode.h>
91 #include <sys/disk.h>
92 #include <sys/param.h>
93 #include <sys/bus.h>
94
95 #include <geom/geom.h>
96 #include <geom/geom_int.h>
97
98 #include <vm/vm.h>
99 #include <vm/vm_extern.h>
100 #include <vm/vm_param.h>
101 #include <vm/vm_object.h>
102 #include <vm/vm_page.h>
103 #include <vm/vm_pager.h>
104 #include <vm/swap_pager.h>
105 #include <vm/uma.h>
106
107 #include <machine/bus.h>
108
109 #define MD_MODVER 1
110
111 #define MD_SHUTDOWN 0x10000 /* Tell worker thread to terminate. */
112 #define MD_EXITING 0x20000 /* Worker thread is exiting. */
113 #define MD_PROVIDERGONE 0x40000 /* Safe to free the softc */
114
115 #ifndef MD_NSECT
116 #define MD_NSECT (10000 * 2)
117 #endif
118
119 struct md_req {
120 unsigned md_unit; /* unit number */
121 enum md_types md_type; /* type of disk */
122 off_t md_mediasize; /* size of disk in bytes */
123 unsigned md_sectorsize; /* sectorsize */
124 unsigned md_options; /* options */
125 int md_fwheads; /* firmware heads */
126 int md_fwsectors; /* firmware sectors */
127 char *md_file; /* pathname of file to mount */
128 enum uio_seg md_file_seg; /* location of md_file */
129 char *md_label; /* label of the device (userspace) */
130 int *md_units; /* pointer to units array (kernel) */
131 size_t md_units_nitems; /* items in md_units array */
132 };
133
134 #ifdef COMPAT_FREEBSD32
135 struct md_ioctl32 {
136 unsigned md_version;
137 unsigned md_unit;
138 enum md_types md_type;
139 uint32_t md_file;
140 off_t md_mediasize;
141 unsigned md_sectorsize;
142 unsigned md_options;
143 uint64_t md_base;
144 int md_fwheads;
145 int md_fwsectors;
146 uint32_t md_label;
147 int md_pad[MDNPAD];
148 }
149 #ifdef __amd64__
150 __attribute__((__packed__))
151 #endif
152 ;
153 #ifndef __amd64__
154 CTASSERT((sizeof(struct md_ioctl32)) == 440);
155 #else
156 CTASSERT((sizeof(struct md_ioctl32)) == 436);
157 #endif
158
159 #define MDIOCATTACH_32 _IOC_NEWTYPE(MDIOCATTACH, struct md_ioctl32)
160 #define MDIOCDETACH_32 _IOC_NEWTYPE(MDIOCDETACH, struct md_ioctl32)
161 #define MDIOCQUERY_32 _IOC_NEWTYPE(MDIOCQUERY, struct md_ioctl32)
162 #define MDIOCRESIZE_32 _IOC_NEWTYPE(MDIOCRESIZE, struct md_ioctl32)
163 #endif /* COMPAT_FREEBSD32 */
164
165 static MALLOC_DEFINE(M_MD, "md_disk", "Memory Disk");
166 static MALLOC_DEFINE(M_MDSECT, "md_sectors", "Memory Disk Sectors");
167
168 static int md_debug;
169 SYSCTL_INT(_debug, OID_AUTO, mddebug, CTLFLAG_RW, &md_debug, 0,
170 "Enable md(4) debug messages");
171 static int md_malloc_wait;
172 SYSCTL_INT(_vm, OID_AUTO, md_malloc_wait, CTLFLAG_RW, &md_malloc_wait, 0,
173 "Allow malloc to wait for memory allocations");
174
175 #if defined(MD_ROOT) && !defined(MD_ROOT_FSTYPE)
176 #define MD_ROOT_FSTYPE "ufs"
177 #endif
178
179 #if defined(MD_ROOT)
180 /*
181 * Preloaded image gets put here.
182 */
183 #if defined(MD_ROOT_SIZE)
184 /*
185 * We put the mfs_root symbol into the oldmfs section of the kernel object file.
186 * Applications that patch the object with the image can determine
187 * the size looking at the oldmfs section size within the kernel.
188 */
189 u_char mfs_root[MD_ROOT_SIZE*1024] __attribute__ ((section ("oldmfs")));
190 const int mfs_root_size = sizeof(mfs_root);
191 #elif defined(MD_ROOT_MEM)
192 /* MD region already mapped in the memory */
193 u_char *mfs_root;
194 int mfs_root_size;
195 #else
196 extern volatile u_char __weak_symbol mfs_root;
197 extern volatile u_char __weak_symbol mfs_root_end;
198 #define mfs_root_size ((uintptr_t)(&mfs_root_end - &mfs_root))
199 #endif
200 #endif
201
202 static g_init_t g_md_init;
203 static g_fini_t g_md_fini;
204 static g_start_t g_md_start;
205 static g_access_t g_md_access;
206 static void g_md_dumpconf(struct sbuf *sb, const char *indent,
207 struct g_geom *gp, struct g_consumer *cp __unused, struct g_provider *pp);
208 static g_provgone_t g_md_providergone;
209
210 static struct cdev *status_dev = NULL;
211 static struct sx md_sx;
212 static struct unrhdr *md_uh;
213
214 static d_ioctl_t mdctlioctl;
215
216 static struct cdevsw mdctl_cdevsw = {
217 .d_version = D_VERSION,
218 .d_ioctl = mdctlioctl,
219 .d_name = MD_NAME,
220 };
221
222 struct g_class g_md_class = {
223 .name = "MD",
224 .version = G_VERSION,
225 .init = g_md_init,
226 .fini = g_md_fini,
227 .start = g_md_start,
228 .access = g_md_access,
229 .dumpconf = g_md_dumpconf,
230 .providergone = g_md_providergone,
231 };
232
233 DECLARE_GEOM_CLASS(g_md_class, g_md);
234 MODULE_VERSION(geom_md, 0);
235
236 static LIST_HEAD(, md_s) md_softc_list = LIST_HEAD_INITIALIZER(md_softc_list);
237
238 #define NINDIR (PAGE_SIZE / sizeof(uintptr_t))
239 #define NMASK (NINDIR-1)
240 static int nshift;
241
242 struct indir {
243 uintptr_t *array;
244 u_int total;
245 u_int used;
246 u_int shift;
247 };
248
249 struct md_s {
250 int unit;
251 LIST_ENTRY(md_s) list;
252 struct bio_queue_head bio_queue;
253 struct mtx queue_mtx;
254 struct cdev *dev;
255 enum md_types type;
256 off_t mediasize;
257 unsigned sectorsize;
258 unsigned opencount;
259 unsigned fwheads;
260 unsigned fwsectors;
261 char ident[DISK_IDENT_SIZE];
262 unsigned flags;
263 char name[20];
264 struct proc *procp;
265 struct g_geom *gp;
266 struct g_provider *pp;
267 int (*start)(struct md_s *sc, struct bio *bp);
268 struct devstat *devstat;
269 struct ucred *cred;
270 char label[PATH_MAX];
271 bool candelete;
272
273 union {
274 /* MD_MALLOC related fields */
275 struct {
276 struct indir *indir;
277 uma_zone_t uma;
278 } s_malloc;
279
280 /* MD_PRELOAD related fields */
281 struct {
282 u_char *pl_ptr;
283 size_t pl_len;
284 char name[PATH_MAX];
285 } s_preload;
286
287 /* MD_VNODE related fields */
288 struct {
289 struct vnode *vnode;
290 char file[PATH_MAX];
291 vm_offset_t kva;
292 } s_vnode;
293
294 /* MD_SWAP related fields */
295 struct {
296 vm_object_t object;
297 } s_swap;
298
299 /* MD_NULL */
300 struct {
301 } s_null;
302 };
303 };
304
305 static struct indir *
new_indir(u_int shift)306 new_indir(u_int shift)
307 {
308 struct indir *ip;
309
310 ip = malloc(sizeof *ip, M_MD, (md_malloc_wait ? M_WAITOK : M_NOWAIT)
311 | M_ZERO);
312 if (ip == NULL)
313 return (NULL);
314 ip->array = malloc(sizeof(uintptr_t) * NINDIR,
315 M_MDSECT, (md_malloc_wait ? M_WAITOK : M_NOWAIT) | M_ZERO);
316 if (ip->array == NULL) {
317 free(ip, M_MD);
318 return (NULL);
319 }
320 ip->total = NINDIR;
321 ip->shift = shift;
322 return (ip);
323 }
324
325 static void
del_indir(struct indir * ip)326 del_indir(struct indir *ip)
327 {
328
329 free(ip->array, M_MDSECT);
330 free(ip, M_MD);
331 }
332
333 static void
destroy_indir(struct md_s * sc,struct indir * ip)334 destroy_indir(struct md_s *sc, struct indir *ip)
335 {
336 int i;
337
338 for (i = 0; i < NINDIR; i++) {
339 if (!ip->array[i])
340 continue;
341 if (ip->shift)
342 destroy_indir(sc, (struct indir*)(ip->array[i]));
343 else if (ip->array[i] > 255)
344 uma_zfree(sc->s_malloc.uma, (void *)(ip->array[i]));
345 }
346 del_indir(ip);
347 }
348
349 /*
350 * This function does the math and allocates the top level "indir" structure
351 * for a device of "size" sectors.
352 */
353
354 static struct indir *
dimension(off_t size)355 dimension(off_t size)
356 {
357 off_t rcnt;
358 struct indir *ip;
359 int layer;
360
361 rcnt = size;
362 layer = 0;
363 while (rcnt > NINDIR) {
364 rcnt /= NINDIR;
365 layer++;
366 }
367
368 /*
369 * XXX: the top layer is probably not fully populated, so we allocate
370 * too much space for ip->array in here.
371 */
372 ip = malloc(sizeof *ip, M_MD, M_WAITOK | M_ZERO);
373 ip->array = malloc(sizeof(uintptr_t) * NINDIR,
374 M_MDSECT, M_WAITOK | M_ZERO);
375 ip->total = NINDIR;
376 ip->shift = layer * nshift;
377 return (ip);
378 }
379
380 /*
381 * Read a given sector
382 */
383
384 static uintptr_t
s_read(struct indir * ip,off_t offset)385 s_read(struct indir *ip, off_t offset)
386 {
387 struct indir *cip;
388 int idx;
389 uintptr_t up;
390
391 if (md_debug > 1)
392 printf("s_read(%jd)\n", (intmax_t)offset);
393 up = 0;
394 for (cip = ip; cip != NULL;) {
395 if (cip->shift) {
396 idx = (offset >> cip->shift) & NMASK;
397 up = cip->array[idx];
398 cip = (struct indir *)up;
399 continue;
400 }
401 idx = offset & NMASK;
402 return (cip->array[idx]);
403 }
404 return (0);
405 }
406
407 /*
408 * Write a given sector, prune the tree if the value is 0
409 */
410
411 static int
s_write(struct indir * ip,off_t offset,uintptr_t ptr)412 s_write(struct indir *ip, off_t offset, uintptr_t ptr)
413 {
414 struct indir *cip, *lip[10];
415 int idx, li;
416 uintptr_t up;
417
418 if (md_debug > 1)
419 printf("s_write(%jd, %p)\n", (intmax_t)offset, (void *)ptr);
420 up = 0;
421 li = 0;
422 cip = ip;
423 for (;;) {
424 lip[li++] = cip;
425 if (cip->shift) {
426 idx = (offset >> cip->shift) & NMASK;
427 up = cip->array[idx];
428 if (up != 0) {
429 cip = (struct indir *)up;
430 continue;
431 }
432 /* Allocate branch */
433 cip->array[idx] =
434 (uintptr_t)new_indir(cip->shift - nshift);
435 if (cip->array[idx] == 0)
436 return (ENOSPC);
437 cip->used++;
438 up = cip->array[idx];
439 cip = (struct indir *)up;
440 continue;
441 }
442 /* leafnode */
443 idx = offset & NMASK;
444 up = cip->array[idx];
445 if (up != 0)
446 cip->used--;
447 cip->array[idx] = ptr;
448 if (ptr != 0)
449 cip->used++;
450 break;
451 }
452 if (cip->used != 0 || li == 1)
453 return (0);
454 li--;
455 while (cip->used == 0 && cip != ip) {
456 li--;
457 idx = (offset >> lip[li]->shift) & NMASK;
458 up = lip[li]->array[idx];
459 KASSERT(up == (uintptr_t)cip, ("md screwed up"));
460 del_indir(cip);
461 lip[li]->array[idx] = 0;
462 lip[li]->used--;
463 cip = lip[li];
464 }
465 return (0);
466 }
467
468 static int
g_md_access(struct g_provider * pp,int r,int w,int e)469 g_md_access(struct g_provider *pp, int r, int w, int e)
470 {
471 struct md_s *sc;
472
473 sc = pp->geom->softc;
474 if (sc == NULL) {
475 if (r <= 0 && w <= 0 && e <= 0)
476 return (0);
477 return (ENXIO);
478 }
479 r += pp->acr;
480 w += pp->acw;
481 e += pp->ace;
482 if ((sc->flags & MD_READONLY) != 0 && w > 0)
483 return (EROFS);
484 if ((pp->acr + pp->acw + pp->ace) == 0 && (r + w + e) > 0) {
485 sc->opencount = 1;
486 } else if ((pp->acr + pp->acw + pp->ace) > 0 && (r + w + e) == 0) {
487 sc->opencount = 0;
488 }
489 return (0);
490 }
491
492 static void
g_md_start(struct bio * bp)493 g_md_start(struct bio *bp)
494 {
495 struct md_s *sc;
496
497 sc = bp->bio_to->geom->softc;
498 if ((bp->bio_cmd == BIO_READ) || (bp->bio_cmd == BIO_WRITE)) {
499 devstat_start_transaction_bio(sc->devstat, bp);
500 }
501 mtx_lock(&sc->queue_mtx);
502 bioq_disksort(&sc->bio_queue, bp);
503 wakeup(sc);
504 mtx_unlock(&sc->queue_mtx);
505 }
506
507 #define MD_MALLOC_MOVE_ZERO 1
508 #define MD_MALLOC_MOVE_FILL 2
509 #define MD_MALLOC_MOVE_READ 3
510 #define MD_MALLOC_MOVE_WRITE 4
511 #define MD_MALLOC_MOVE_CMP 5
512
513 static int
md_malloc_move_ma(vm_page_t ** mp,int * ma_offs,unsigned sectorsize,void * ptr,u_char fill,int op)514 md_malloc_move_ma(vm_page_t **mp, int *ma_offs, unsigned sectorsize,
515 void *ptr, u_char fill, int op)
516 {
517 struct sf_buf *sf;
518 vm_page_t m, *mp1;
519 char *p, first;
520 off_t *uc;
521 unsigned n;
522 int error, i, ma_offs1, sz, first_read;
523
524 m = NULL;
525 error = 0;
526 sf = NULL;
527 /* if (op == MD_MALLOC_MOVE_CMP) { gcc */
528 first = 0;
529 first_read = 0;
530 uc = ptr;
531 mp1 = *mp;
532 ma_offs1 = *ma_offs;
533 /* } */
534 sched_pin();
535 for (n = sectorsize; n != 0; n -= sz) {
536 sz = imin(PAGE_SIZE - *ma_offs, n);
537 if (m != **mp) {
538 if (sf != NULL)
539 sf_buf_free(sf);
540 m = **mp;
541 sf = sf_buf_alloc(m, SFB_CPUPRIVATE |
542 (md_malloc_wait ? 0 : SFB_NOWAIT));
543 if (sf == NULL) {
544 error = ENOMEM;
545 break;
546 }
547 }
548 p = (char *)sf_buf_kva(sf) + *ma_offs;
549 switch (op) {
550 case MD_MALLOC_MOVE_ZERO:
551 bzero(p, sz);
552 break;
553 case MD_MALLOC_MOVE_FILL:
554 memset(p, fill, sz);
555 break;
556 case MD_MALLOC_MOVE_READ:
557 bcopy(ptr, p, sz);
558 cpu_flush_dcache(p, sz);
559 break;
560 case MD_MALLOC_MOVE_WRITE:
561 bcopy(p, ptr, sz);
562 break;
563 case MD_MALLOC_MOVE_CMP:
564 for (i = 0; i < sz; i++, p++) {
565 if (!first_read) {
566 *uc = (u_char)*p;
567 first = *p;
568 first_read = 1;
569 } else if (*p != first) {
570 error = EDOOFUS;
571 break;
572 }
573 }
574 break;
575 default:
576 KASSERT(0, ("md_malloc_move_ma unknown op %d\n", op));
577 break;
578 }
579 if (error != 0)
580 break;
581 *ma_offs += sz;
582 *ma_offs %= PAGE_SIZE;
583 if (*ma_offs == 0)
584 (*mp)++;
585 ptr = (char *)ptr + sz;
586 }
587
588 if (sf != NULL)
589 sf_buf_free(sf);
590 sched_unpin();
591 if (op == MD_MALLOC_MOVE_CMP && error != 0) {
592 *mp = mp1;
593 *ma_offs = ma_offs1;
594 }
595 return (error);
596 }
597
598 static int
md_malloc_move_vlist(bus_dma_segment_t ** pvlist,int * pma_offs,unsigned len,void * ptr,u_char fill,int op)599 md_malloc_move_vlist(bus_dma_segment_t **pvlist, int *pma_offs,
600 unsigned len, void *ptr, u_char fill, int op)
601 {
602 bus_dma_segment_t *vlist;
603 uint8_t *p, *end, first;
604 off_t *uc;
605 int ma_offs, seg_len;
606
607 vlist = *pvlist;
608 ma_offs = *pma_offs;
609 uc = ptr;
610
611 for (; len != 0; len -= seg_len) {
612 seg_len = imin(vlist->ds_len - ma_offs, len);
613 p = (uint8_t *)(uintptr_t)vlist->ds_addr + ma_offs;
614 switch (op) {
615 case MD_MALLOC_MOVE_ZERO:
616 bzero(p, seg_len);
617 break;
618 case MD_MALLOC_MOVE_FILL:
619 memset(p, fill, seg_len);
620 break;
621 case MD_MALLOC_MOVE_READ:
622 bcopy(ptr, p, seg_len);
623 cpu_flush_dcache(p, seg_len);
624 break;
625 case MD_MALLOC_MOVE_WRITE:
626 bcopy(p, ptr, seg_len);
627 break;
628 case MD_MALLOC_MOVE_CMP:
629 end = p + seg_len;
630 first = *uc = *p;
631 /* Confirm all following bytes match the first */
632 while (++p < end) {
633 if (*p != first)
634 return (EDOOFUS);
635 }
636 break;
637 default:
638 KASSERT(0, ("md_malloc_move_vlist unknown op %d\n", op));
639 break;
640 }
641
642 ma_offs += seg_len;
643 if (ma_offs == vlist->ds_len) {
644 ma_offs = 0;
645 vlist++;
646 }
647 ptr = (uint8_t *)ptr + seg_len;
648 }
649 *pvlist = vlist;
650 *pma_offs = ma_offs;
651
652 return (0);
653 }
654
655 static int
mdstart_malloc(struct md_s * sc,struct bio * bp)656 mdstart_malloc(struct md_s *sc, struct bio *bp)
657 {
658 u_char *dst;
659 vm_page_t *m;
660 bus_dma_segment_t *vlist;
661 int i, error, error1, ma_offs, notmapped;
662 off_t secno, nsec, uc;
663 uintptr_t sp, osp;
664
665 switch (bp->bio_cmd) {
666 case BIO_READ:
667 case BIO_WRITE:
668 case BIO_DELETE:
669 break;
670 case BIO_FLUSH:
671 return (0);
672 default:
673 return (EOPNOTSUPP);
674 }
675
676 notmapped = (bp->bio_flags & BIO_UNMAPPED) != 0;
677 vlist = (bp->bio_flags & BIO_VLIST) != 0 ?
678 (bus_dma_segment_t *)bp->bio_data : NULL;
679 if (notmapped) {
680 m = bp->bio_ma;
681 ma_offs = bp->bio_ma_offset;
682 dst = NULL;
683 KASSERT(vlist == NULL, ("vlists cannot be unmapped"));
684 } else if (vlist != NULL) {
685 ma_offs = bp->bio_ma_offset;
686 dst = NULL;
687 } else {
688 dst = bp->bio_data;
689 }
690
691 nsec = bp->bio_length / sc->sectorsize;
692 secno = bp->bio_offset / sc->sectorsize;
693 error = 0;
694 while (nsec--) {
695 osp = s_read(sc->s_malloc.indir, secno);
696 if (bp->bio_cmd == BIO_DELETE) {
697 if (osp != 0)
698 error = s_write(sc->s_malloc.indir, secno, 0);
699 } else if (bp->bio_cmd == BIO_READ) {
700 if (osp == 0) {
701 if (notmapped) {
702 error = md_malloc_move_ma(&m, &ma_offs,
703 sc->sectorsize, NULL, 0,
704 MD_MALLOC_MOVE_ZERO);
705 } else if (vlist != NULL) {
706 error = md_malloc_move_vlist(&vlist,
707 &ma_offs, sc->sectorsize, NULL, 0,
708 MD_MALLOC_MOVE_ZERO);
709 } else
710 bzero(dst, sc->sectorsize);
711 } else if (osp <= 255) {
712 if (notmapped) {
713 error = md_malloc_move_ma(&m, &ma_offs,
714 sc->sectorsize, NULL, osp,
715 MD_MALLOC_MOVE_FILL);
716 } else if (vlist != NULL) {
717 error = md_malloc_move_vlist(&vlist,
718 &ma_offs, sc->sectorsize, NULL, osp,
719 MD_MALLOC_MOVE_FILL);
720 } else
721 memset(dst, osp, sc->sectorsize);
722 } else {
723 if (notmapped) {
724 error = md_malloc_move_ma(&m, &ma_offs,
725 sc->sectorsize, (void *)osp, 0,
726 MD_MALLOC_MOVE_READ);
727 } else if (vlist != NULL) {
728 error = md_malloc_move_vlist(&vlist,
729 &ma_offs, sc->sectorsize,
730 (void *)osp, 0,
731 MD_MALLOC_MOVE_READ);
732 } else {
733 bcopy((void *)osp, dst, sc->sectorsize);
734 cpu_flush_dcache(dst, sc->sectorsize);
735 }
736 }
737 osp = 0;
738 } else if (bp->bio_cmd == BIO_WRITE) {
739 if (sc->flags & MD_COMPRESS) {
740 if (notmapped) {
741 error1 = md_malloc_move_ma(&m, &ma_offs,
742 sc->sectorsize, &uc, 0,
743 MD_MALLOC_MOVE_CMP);
744 i = error1 == 0 ? sc->sectorsize : 0;
745 } else if (vlist != NULL) {
746 error1 = md_malloc_move_vlist(&vlist,
747 &ma_offs, sc->sectorsize, &uc, 0,
748 MD_MALLOC_MOVE_CMP);
749 i = error1 == 0 ? sc->sectorsize : 0;
750 } else {
751 uc = dst[0];
752 for (i = 1; i < sc->sectorsize; i++) {
753 if (dst[i] != uc)
754 break;
755 }
756 }
757 } else {
758 i = 0;
759 uc = 0;
760 }
761 if (i == sc->sectorsize) {
762 if (osp != uc)
763 error = s_write(sc->s_malloc.indir,
764 secno, uc);
765 } else {
766 if (osp <= 255) {
767 sp = (uintptr_t)uma_zalloc(
768 sc->s_malloc.uma,
769 md_malloc_wait ? M_WAITOK :
770 M_NOWAIT);
771 if (sp == 0) {
772 error = ENOSPC;
773 break;
774 }
775 if (notmapped) {
776 error = md_malloc_move_ma(&m,
777 &ma_offs, sc->sectorsize,
778 (void *)sp, 0,
779 MD_MALLOC_MOVE_WRITE);
780 } else if (vlist != NULL) {
781 error = md_malloc_move_vlist(
782 &vlist, &ma_offs,
783 sc->sectorsize, (void *)sp,
784 0, MD_MALLOC_MOVE_WRITE);
785 } else {
786 bcopy(dst, (void *)sp,
787 sc->sectorsize);
788 }
789 error = s_write(sc->s_malloc.indir,
790 secno, sp);
791 } else {
792 if (notmapped) {
793 error = md_malloc_move_ma(&m,
794 &ma_offs, sc->sectorsize,
795 (void *)osp, 0,
796 MD_MALLOC_MOVE_WRITE);
797 } else if (vlist != NULL) {
798 error = md_malloc_move_vlist(
799 &vlist, &ma_offs,
800 sc->sectorsize, (void *)osp,
801 0, MD_MALLOC_MOVE_WRITE);
802 } else {
803 bcopy(dst, (void *)osp,
804 sc->sectorsize);
805 }
806 osp = 0;
807 }
808 }
809 } else {
810 error = EOPNOTSUPP;
811 }
812 if (osp > 255)
813 uma_zfree(sc->s_malloc.uma, (void*)osp);
814 if (error != 0)
815 break;
816 secno++;
817 if (!notmapped && vlist == NULL)
818 dst += sc->sectorsize;
819 }
820 bp->bio_resid = 0;
821 return (error);
822 }
823
824 static void
mdcopyto_vlist(void * src,bus_dma_segment_t * vlist,off_t offset,off_t len)825 mdcopyto_vlist(void *src, bus_dma_segment_t *vlist, off_t offset, off_t len)
826 {
827 off_t seg_len;
828
829 while (offset >= vlist->ds_len) {
830 offset -= vlist->ds_len;
831 vlist++;
832 }
833
834 while (len != 0) {
835 seg_len = omin(len, vlist->ds_len - offset);
836 bcopy(src, (void *)(uintptr_t)(vlist->ds_addr + offset),
837 seg_len);
838 offset = 0;
839 src = (uint8_t *)src + seg_len;
840 len -= seg_len;
841 vlist++;
842 }
843 }
844
845 static void
mdcopyfrom_vlist(bus_dma_segment_t * vlist,off_t offset,void * dst,off_t len)846 mdcopyfrom_vlist(bus_dma_segment_t *vlist, off_t offset, void *dst, off_t len)
847 {
848 off_t seg_len;
849
850 while (offset >= vlist->ds_len) {
851 offset -= vlist->ds_len;
852 vlist++;
853 }
854
855 while (len != 0) {
856 seg_len = omin(len, vlist->ds_len - offset);
857 bcopy((void *)(uintptr_t)(vlist->ds_addr + offset), dst,
858 seg_len);
859 offset = 0;
860 dst = (uint8_t *)dst + seg_len;
861 len -= seg_len;
862 vlist++;
863 }
864 }
865
866 static int
mdstart_preload(struct md_s * sc,struct bio * bp)867 mdstart_preload(struct md_s *sc, struct bio *bp)
868 {
869 uint8_t *p;
870
871 p = sc->s_preload.pl_ptr + bp->bio_offset;
872 switch (bp->bio_cmd) {
873 case BIO_READ:
874 if ((bp->bio_flags & BIO_VLIST) != 0) {
875 mdcopyto_vlist(p, (bus_dma_segment_t *)bp->bio_data,
876 bp->bio_ma_offset, bp->bio_length);
877 } else {
878 bcopy(p, bp->bio_data, bp->bio_length);
879 }
880 cpu_flush_dcache(bp->bio_data, bp->bio_length);
881 break;
882 case BIO_WRITE:
883 if ((bp->bio_flags & BIO_VLIST) != 0) {
884 mdcopyfrom_vlist((bus_dma_segment_t *)bp->bio_data,
885 bp->bio_ma_offset, p, bp->bio_length);
886 } else {
887 bcopy(bp->bio_data, p, bp->bio_length);
888 }
889 break;
890 }
891 bp->bio_resid = 0;
892 return (0);
893 }
894
895 static int
mdstart_vnode(struct md_s * sc,struct bio * bp)896 mdstart_vnode(struct md_s *sc, struct bio *bp)
897 {
898 int error;
899 struct uio auio;
900 struct iovec aiov;
901 struct iovec *piov;
902 struct mount *mp;
903 struct vnode *vp;
904 bus_dma_segment_t *vlist;
905 struct thread *td;
906 off_t iolen, iostart, off, len;
907 int ma_offs, npages;
908 bool mapped;
909
910 td = curthread;
911 vp = sc->s_vnode.vnode;
912 piov = NULL;
913 ma_offs = bp->bio_ma_offset;
914 off = bp->bio_offset;
915 len = bp->bio_length;
916 mapped = false;
917
918 /*
919 * VNODE I/O
920 *
921 * If an error occurs, we set BIO_ERROR but we do not set
922 * B_INVAL because (for a write anyway), the buffer is
923 * still valid.
924 */
925
926 switch (bp->bio_cmd) {
927 case BIO_READ:
928 auio.uio_rw = UIO_READ;
929 break;
930 case BIO_WRITE:
931 auio.uio_rw = UIO_WRITE;
932 break;
933 case BIO_FLUSH:
934 do {
935 (void)vn_start_write(vp, &mp, V_WAIT);
936 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
937 error = VOP_FSYNC(vp, MNT_WAIT, td);
938 VOP_UNLOCK(vp);
939 vn_finished_write(mp);
940 } while (error == ERELOOKUP);
941 return (error);
942 case BIO_DELETE:
943 if (sc->candelete) {
944 error = vn_deallocate(vp, &off, &len, 0,
945 sc->flags & MD_ASYNC ? 0 : IO_SYNC,
946 sc->cred, NOCRED);
947 bp->bio_resid = len;
948 return (error);
949 }
950 /* FALLTHROUGH */
951 default:
952 return (EOPNOTSUPP);
953 }
954
955 auio.uio_offset = (vm_ooffset_t)bp->bio_offset;
956 auio.uio_resid = bp->bio_length;
957 auio.uio_segflg = UIO_SYSSPACE;
958 auio.uio_td = td;
959
960 if ((bp->bio_flags & BIO_VLIST) != 0) {
961 piov = malloc(sizeof(*piov) * bp->bio_ma_n, M_MD, M_WAITOK);
962 auio.uio_iov = piov;
963 vlist = (bus_dma_segment_t *)bp->bio_data;
964 while (len > 0) {
965 piov->iov_base = (void *)(uintptr_t)(vlist->ds_addr +
966 ma_offs);
967 piov->iov_len = vlist->ds_len - ma_offs;
968 if (piov->iov_len > len)
969 piov->iov_len = len;
970 len -= piov->iov_len;
971 ma_offs = 0;
972 vlist++;
973 piov++;
974 }
975 auio.uio_iovcnt = piov - auio.uio_iov;
976 piov = auio.uio_iov;
977 } else if ((bp->bio_flags & BIO_UNMAPPED) != 0) {
978 bp->bio_resid = len;
979 unmapped_step:
980 npages = atop(min(maxphys, round_page(len + (ma_offs &
981 PAGE_MASK))));
982 iolen = min(ptoa(npages) - (ma_offs & PAGE_MASK), len);
983 KASSERT(iolen > 0, ("zero iolen"));
984 KASSERT(npages <= atop(maxphys + PAGE_SIZE),
985 ("npages %d too large", npages));
986 pmap_qenter(sc->s_vnode.kva, &bp->bio_ma[atop(ma_offs)],
987 npages);
988 aiov.iov_base = (void *)(sc->s_vnode.kva + (ma_offs &
989 PAGE_MASK));
990 aiov.iov_len = iolen;
991 auio.uio_iov = &aiov;
992 auio.uio_iovcnt = 1;
993 auio.uio_resid = iolen;
994 mapped = true;
995 } else {
996 aiov.iov_base = bp->bio_data;
997 aiov.iov_len = bp->bio_length;
998 auio.uio_iov = &aiov;
999 auio.uio_iovcnt = 1;
1000 }
1001 iostart = auio.uio_offset;
1002 if (bp->bio_cmd == BIO_READ) {
1003 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
1004 error = VOP_READ(vp, &auio, 0, sc->cred);
1005 VOP_UNLOCK(vp);
1006 } else {
1007 (void) vn_start_write(vp, &mp, V_WAIT);
1008 vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
1009 error = VOP_WRITE(vp, &auio, sc->flags & MD_ASYNC ? 0 : IO_SYNC,
1010 sc->cred);
1011 VOP_UNLOCK(vp);
1012 vn_finished_write(mp);
1013 if (error == 0)
1014 sc->flags &= ~MD_VERIFY;
1015 }
1016
1017 /* When MD_CACHE is set, try to avoid double-caching the data. */
1018 if (error == 0 && (sc->flags & MD_CACHE) == 0)
1019 VOP_ADVISE(vp, iostart, auio.uio_offset - 1,
1020 POSIX_FADV_DONTNEED);
1021
1022 if (mapped) {
1023 pmap_qremove(sc->s_vnode.kva, npages);
1024 if (error == 0) {
1025 len -= iolen;
1026 bp->bio_resid -= iolen;
1027 ma_offs += iolen;
1028 if (len > 0)
1029 goto unmapped_step;
1030 }
1031 } else {
1032 bp->bio_resid = auio.uio_resid;
1033 }
1034
1035 free(piov, M_MD);
1036 return (error);
1037 }
1038
1039 static int
mdstart_swap(struct md_s * sc,struct bio * bp)1040 mdstart_swap(struct md_s *sc, struct bio *bp)
1041 {
1042 vm_page_t m;
1043 u_char *p;
1044 vm_pindex_t i, lastp;
1045 bus_dma_segment_t *vlist;
1046 int rv, ma_offs, offs, len, lastend;
1047
1048 switch (bp->bio_cmd) {
1049 case BIO_READ:
1050 case BIO_WRITE:
1051 case BIO_DELETE:
1052 break;
1053 case BIO_FLUSH:
1054 return (0);
1055 default:
1056 return (EOPNOTSUPP);
1057 }
1058
1059 p = bp->bio_data;
1060 ma_offs = (bp->bio_flags & (BIO_UNMAPPED|BIO_VLIST)) != 0 ?
1061 bp->bio_ma_offset : 0;
1062 vlist = (bp->bio_flags & BIO_VLIST) != 0 ?
1063 (bus_dma_segment_t *)bp->bio_data : NULL;
1064
1065 /*
1066 * offs is the offset at which to start operating on the
1067 * next (ie, first) page. lastp is the last page on
1068 * which we're going to operate. lastend is the ending
1069 * position within that last page (ie, PAGE_SIZE if
1070 * we're operating on complete aligned pages).
1071 */
1072 offs = bp->bio_offset % PAGE_SIZE;
1073 lastp = (bp->bio_offset + bp->bio_length - 1) / PAGE_SIZE;
1074 lastend = (bp->bio_offset + bp->bio_length - 1) % PAGE_SIZE + 1;
1075
1076 rv = VM_PAGER_OK;
1077 vm_object_pip_add(sc->s_swap.object, 1);
1078 for (i = bp->bio_offset / PAGE_SIZE; i <= lastp; i++) {
1079 len = ((i == lastp) ? lastend : PAGE_SIZE) - offs;
1080 m = vm_page_grab_unlocked(sc->s_swap.object, i,
1081 VM_ALLOC_SYSTEM);
1082 if (bp->bio_cmd == BIO_READ) {
1083 if (vm_page_all_valid(m))
1084 rv = VM_PAGER_OK;
1085 else
1086 rv = vm_pager_get_pages(sc->s_swap.object,
1087 &m, 1, NULL, NULL);
1088 if (rv == VM_PAGER_ERROR) {
1089 VM_OBJECT_WLOCK(sc->s_swap.object);
1090 vm_page_free(m);
1091 VM_OBJECT_WUNLOCK(sc->s_swap.object);
1092 break;
1093 } else if (rv == VM_PAGER_FAIL) {
1094 /*
1095 * Pager does not have the page. Zero
1096 * the allocated page, and mark it as
1097 * valid. Do not set dirty, the page
1098 * can be recreated if thrown out.
1099 */
1100 pmap_zero_page(m);
1101 vm_page_valid(m);
1102 }
1103 if ((bp->bio_flags & BIO_UNMAPPED) != 0) {
1104 pmap_copy_pages(&m, offs, bp->bio_ma,
1105 ma_offs, len);
1106 } else if ((bp->bio_flags & BIO_VLIST) != 0) {
1107 physcopyout_vlist(VM_PAGE_TO_PHYS(m) + offs,
1108 vlist, ma_offs, len);
1109 cpu_flush_dcache(p, len);
1110 } else {
1111 physcopyout(VM_PAGE_TO_PHYS(m) + offs, p, len);
1112 cpu_flush_dcache(p, len);
1113 }
1114 } else if (bp->bio_cmd == BIO_WRITE) {
1115 if (len == PAGE_SIZE || vm_page_all_valid(m))
1116 rv = VM_PAGER_OK;
1117 else
1118 rv = vm_pager_get_pages(sc->s_swap.object,
1119 &m, 1, NULL, NULL);
1120 if (rv == VM_PAGER_ERROR) {
1121 VM_OBJECT_WLOCK(sc->s_swap.object);
1122 vm_page_free(m);
1123 VM_OBJECT_WUNLOCK(sc->s_swap.object);
1124 break;
1125 } else if (rv == VM_PAGER_FAIL)
1126 pmap_zero_page(m);
1127
1128 if ((bp->bio_flags & BIO_UNMAPPED) != 0) {
1129 pmap_copy_pages(bp->bio_ma, ma_offs, &m,
1130 offs, len);
1131 } else if ((bp->bio_flags & BIO_VLIST) != 0) {
1132 physcopyin_vlist(vlist, ma_offs,
1133 VM_PAGE_TO_PHYS(m) + offs, len);
1134 } else {
1135 physcopyin(p, VM_PAGE_TO_PHYS(m) + offs, len);
1136 }
1137
1138 vm_page_valid(m);
1139 vm_page_set_dirty(m);
1140 } else if (bp->bio_cmd == BIO_DELETE) {
1141 if (len == PAGE_SIZE || vm_page_all_valid(m))
1142 rv = VM_PAGER_OK;
1143 else
1144 rv = vm_pager_get_pages(sc->s_swap.object,
1145 &m, 1, NULL, NULL);
1146 VM_OBJECT_WLOCK(sc->s_swap.object);
1147 if (rv == VM_PAGER_ERROR) {
1148 vm_page_free(m);
1149 VM_OBJECT_WUNLOCK(sc->s_swap.object);
1150 break;
1151 } else if (rv == VM_PAGER_FAIL) {
1152 vm_page_free(m);
1153 m = NULL;
1154 } else {
1155 /* Page is valid. */
1156 if (len != PAGE_SIZE) {
1157 pmap_zero_page_area(m, offs, len);
1158 vm_page_set_dirty(m);
1159 } else {
1160 vm_pager_page_unswapped(m);
1161 vm_page_free(m);
1162 m = NULL;
1163 }
1164 }
1165 VM_OBJECT_WUNLOCK(sc->s_swap.object);
1166 }
1167 if (m != NULL) {
1168 /*
1169 * The page may be deactivated prior to setting
1170 * PGA_REFERENCED, but in this case it will be
1171 * reactivated by the page daemon.
1172 */
1173 if (vm_page_active(m))
1174 vm_page_reference(m);
1175 else
1176 vm_page_activate(m);
1177 vm_page_xunbusy(m);
1178 }
1179
1180 /* Actions on further pages start at offset 0 */
1181 p += PAGE_SIZE - offs;
1182 offs = 0;
1183 ma_offs += len;
1184 }
1185 vm_object_pip_wakeup(sc->s_swap.object);
1186 return (rv != VM_PAGER_ERROR ? 0 : ENOSPC);
1187 }
1188
1189 static int
mdstart_null(struct md_s * sc,struct bio * bp)1190 mdstart_null(struct md_s *sc, struct bio *bp)
1191 {
1192
1193 switch (bp->bio_cmd) {
1194 case BIO_READ:
1195 bzero(bp->bio_data, bp->bio_length);
1196 cpu_flush_dcache(bp->bio_data, bp->bio_length);
1197 break;
1198 case BIO_WRITE:
1199 break;
1200 }
1201 bp->bio_resid = 0;
1202 return (0);
1203 }
1204
1205 static void
md_handleattr(struct md_s * sc,struct bio * bp)1206 md_handleattr(struct md_s *sc, struct bio *bp)
1207 {
1208 if (sc->fwsectors && sc->fwheads &&
1209 (g_handleattr_int(bp, "GEOM::fwsectors", sc->fwsectors) != 0 ||
1210 g_handleattr_int(bp, "GEOM::fwheads", sc->fwheads) != 0))
1211 return;
1212 if (g_handleattr_int(bp, "GEOM::candelete", sc->candelete) != 0)
1213 return;
1214 if (sc->ident[0] != '\0' &&
1215 g_handleattr_str(bp, "GEOM::ident", sc->ident) != 0)
1216 return;
1217 if (g_handleattr_int(bp, "MNT::verified", (sc->flags & MD_VERIFY) != 0))
1218 return;
1219 g_io_deliver(bp, EOPNOTSUPP);
1220 }
1221
1222 static void
md_kthread(void * arg)1223 md_kthread(void *arg)
1224 {
1225 struct md_s *sc;
1226 struct bio *bp;
1227 int error;
1228
1229 sc = arg;
1230 thread_lock(curthread);
1231 sched_prio(curthread, PRIBIO);
1232 thread_unlock(curthread);
1233 if (sc->type == MD_VNODE)
1234 curthread->td_pflags |= TDP_NORUNNINGBUF;
1235
1236 for (;;) {
1237 mtx_lock(&sc->queue_mtx);
1238 if (sc->flags & MD_SHUTDOWN) {
1239 sc->flags |= MD_EXITING;
1240 mtx_unlock(&sc->queue_mtx);
1241 kproc_exit(0);
1242 }
1243 bp = bioq_takefirst(&sc->bio_queue);
1244 if (!bp) {
1245 msleep(sc, &sc->queue_mtx, PRIBIO | PDROP, "mdwait", 0);
1246 continue;
1247 }
1248 mtx_unlock(&sc->queue_mtx);
1249 if (bp->bio_cmd == BIO_GETATTR) {
1250 md_handleattr(sc, bp);
1251 } else {
1252 error = sc->start(sc, bp);
1253 if (bp->bio_cmd == BIO_READ || bp->bio_cmd == BIO_WRITE) {
1254 /*
1255 * Devstat uses (bio_bcount, bio_resid) for
1256 * determining the length of the completed part
1257 * of the i/o. g_io_deliver() will translate
1258 * from bio_completed to that, but it also
1259 * destroys the bio so we must do our own
1260 * translation.
1261 */
1262 bp->bio_bcount = bp->bio_length;
1263 devstat_end_transaction_bio(sc->devstat, bp);
1264 }
1265 bp->bio_completed = bp->bio_length - bp->bio_resid;
1266 g_io_deliver(bp, error);
1267 }
1268 }
1269 }
1270
1271 static struct md_s *
mdfind(int unit)1272 mdfind(int unit)
1273 {
1274 struct md_s *sc;
1275
1276 LIST_FOREACH(sc, &md_softc_list, list) {
1277 if (sc->unit == unit)
1278 break;
1279 }
1280 return (sc);
1281 }
1282
1283 static struct md_s *
mdnew(int unit,int * errp,enum md_types type)1284 mdnew(int unit, int *errp, enum md_types type)
1285 {
1286 struct md_s *sc;
1287 int error;
1288
1289 *errp = 0;
1290 if (unit == -1)
1291 unit = alloc_unr(md_uh);
1292 else
1293 unit = alloc_unr_specific(md_uh, unit);
1294
1295 if (unit == -1) {
1296 *errp = EBUSY;
1297 return (NULL);
1298 }
1299
1300 sc = malloc(sizeof(*sc), M_MD, M_WAITOK | M_ZERO);
1301 sc->type = type;
1302 bioq_init(&sc->bio_queue);
1303 mtx_init(&sc->queue_mtx, "md bio queue", NULL, MTX_DEF);
1304 sc->unit = unit;
1305 sprintf(sc->name, "md%d", unit);
1306 LIST_INSERT_HEAD(&md_softc_list, sc, list);
1307 error = kproc_create(md_kthread, sc, &sc->procp, 0, 0,"%s", sc->name);
1308 if (error == 0)
1309 return (sc);
1310 LIST_REMOVE(sc, list);
1311 mtx_destroy(&sc->queue_mtx);
1312 free_unr(md_uh, sc->unit);
1313 free(sc, M_MD);
1314 *errp = error;
1315 return (NULL);
1316 }
1317
1318 static void
mdinit(struct md_s * sc)1319 mdinit(struct md_s *sc)
1320 {
1321 struct g_geom *gp;
1322 struct g_provider *pp;
1323 unsigned remn;
1324
1325 g_topology_lock();
1326 gp = g_new_geomf(&g_md_class, "md%d", sc->unit);
1327 gp->softc = sc;
1328 pp = g_new_providerf(gp, "md%d", sc->unit);
1329 devstat_remove_entry(pp->stat);
1330 pp->stat = NULL;
1331 pp->flags |= G_PF_DIRECT_SEND | G_PF_DIRECT_RECEIVE;
1332 /* Prune off any residual fractional sector. */
1333 remn = sc->mediasize % sc->sectorsize;
1334 if (remn != 0) {
1335 printf("md%d: truncating fractional last sector by %u bytes\n",
1336 sc->unit, remn);
1337 sc->mediasize -= remn;
1338 }
1339 pp->mediasize = sc->mediasize;
1340 pp->sectorsize = sc->sectorsize;
1341 switch (sc->type) {
1342 case MD_MALLOC:
1343 case MD_VNODE:
1344 case MD_SWAP:
1345 pp->flags |= G_PF_ACCEPT_UNMAPPED;
1346 break;
1347 case MD_PRELOAD:
1348 case MD_NULL:
1349 break;
1350 }
1351 sc->gp = gp;
1352 sc->pp = pp;
1353 sc->devstat = devstat_new_entry("md", sc->unit, sc->sectorsize,
1354 DEVSTAT_ALL_SUPPORTED, DEVSTAT_TYPE_DIRECT, DEVSTAT_PRIORITY_MAX);
1355 sc->devstat->id = pp;
1356 g_error_provider(pp, 0);
1357 g_topology_unlock();
1358 }
1359
1360 static int
mdcreate_malloc(struct md_s * sc,struct md_req * mdr)1361 mdcreate_malloc(struct md_s *sc, struct md_req *mdr)
1362 {
1363 uintptr_t sp;
1364 int error;
1365 off_t u;
1366
1367 error = 0;
1368 if (mdr->md_options & ~(MD_AUTOUNIT | MD_COMPRESS | MD_RESERVE))
1369 return (EINVAL);
1370 if (mdr->md_sectorsize != 0 && !powerof2(mdr->md_sectorsize))
1371 return (EINVAL);
1372 /* Compression doesn't make sense if we have reserved space */
1373 if (mdr->md_options & MD_RESERVE)
1374 mdr->md_options &= ~MD_COMPRESS;
1375 if (mdr->md_fwsectors != 0)
1376 sc->fwsectors = mdr->md_fwsectors;
1377 if (mdr->md_fwheads != 0)
1378 sc->fwheads = mdr->md_fwheads;
1379 sc->flags = mdr->md_options & (MD_COMPRESS | MD_FORCE | MD_RESERVE);
1380 sc->s_malloc.indir = dimension(sc->mediasize / sc->sectorsize);
1381 sc->s_malloc.uma = uma_zcreate(sc->name, sc->sectorsize, NULL, NULL,
1382 NULL, NULL, 0x1ff, 0);
1383 if (mdr->md_options & MD_RESERVE) {
1384 off_t nsectors;
1385
1386 nsectors = sc->mediasize / sc->sectorsize;
1387 for (u = 0; u < nsectors; u++) {
1388 sp = (uintptr_t)uma_zalloc(sc->s_malloc.uma,
1389 (md_malloc_wait ? M_WAITOK : M_NOWAIT) | M_ZERO);
1390 if (sp != 0)
1391 error = s_write(sc->s_malloc.indir, u, sp);
1392 else
1393 error = ENOMEM;
1394 if (error != 0)
1395 break;
1396 }
1397 }
1398 return (error);
1399 }
1400
1401 static int
mdsetcred(struct md_s * sc,struct ucred * cred)1402 mdsetcred(struct md_s *sc, struct ucred *cred)
1403 {
1404 char *tmpbuf;
1405 int error = 0;
1406
1407 /*
1408 * Set credits in our softc
1409 */
1410
1411 if (sc->cred)
1412 crfree(sc->cred);
1413 sc->cred = crhold(cred);
1414
1415 /*
1416 * Horrible kludge to establish credentials for NFS XXX.
1417 */
1418
1419 if (sc->type == MD_VNODE && sc->s_vnode.vnode != NULL) {
1420 struct uio auio;
1421 struct iovec aiov;
1422
1423 tmpbuf = malloc(sc->sectorsize, M_TEMP, M_WAITOK);
1424 bzero(&auio, sizeof(auio));
1425
1426 aiov.iov_base = tmpbuf;
1427 aiov.iov_len = sc->sectorsize;
1428 auio.uio_iov = &aiov;
1429 auio.uio_iovcnt = 1;
1430 auio.uio_offset = 0;
1431 auio.uio_rw = UIO_READ;
1432 auio.uio_segflg = UIO_SYSSPACE;
1433 auio.uio_resid = aiov.iov_len;
1434 vn_lock(sc->s_vnode.vnode, LK_EXCLUSIVE | LK_RETRY);
1435 error = VOP_READ(sc->s_vnode.vnode, &auio, 0, sc->cred);
1436 VOP_UNLOCK(sc->s_vnode.vnode);
1437 free(tmpbuf, M_TEMP);
1438 }
1439 return (error);
1440 }
1441
1442 static int
mdcreate_vnode(struct md_s * sc,struct md_req * mdr,struct thread * td)1443 mdcreate_vnode(struct md_s *sc, struct md_req *mdr, struct thread *td)
1444 {
1445 struct vattr vattr;
1446 struct nameidata nd;
1447 char *fname;
1448 int error, flags;
1449 long v;
1450
1451 fname = mdr->md_file;
1452 if (mdr->md_file_seg == UIO_USERSPACE) {
1453 error = copyinstr(fname, sc->s_vnode.file,
1454 sizeof(sc->s_vnode.file), NULL);
1455 if (error != 0)
1456 return (error);
1457 } else if (mdr->md_file_seg == UIO_SYSSPACE)
1458 strlcpy(sc->s_vnode.file, fname, sizeof(sc->s_vnode.file));
1459 else
1460 return (EDOOFUS);
1461
1462 /*
1463 * If the user specified that this is a read only device, don't
1464 * set the FWRITE mask before trying to open the backing store.
1465 */
1466 flags = FREAD | ((mdr->md_options & MD_READONLY) ? 0 : FWRITE) \
1467 | ((mdr->md_options & MD_VERIFY) ? O_VERIFY : 0);
1468 NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, sc->s_vnode.file);
1469 error = vn_open(&nd, &flags, 0, NULL);
1470 if (error != 0)
1471 return (error);
1472 NDFREE_PNBUF(&nd);
1473 if (nd.ni_vp->v_type != VREG) {
1474 error = EINVAL;
1475 goto bad;
1476 }
1477 error = VOP_GETATTR(nd.ni_vp, &vattr, td->td_ucred);
1478 if (error != 0)
1479 goto bad;
1480 if ((mdr->md_options & MD_MUSTDEALLOC) != 0) {
1481 error = VOP_PATHCONF(nd.ni_vp, _PC_DEALLOC_PRESENT, &v);
1482 if (error != 0)
1483 goto bad;
1484 if (v == 0)
1485 sc->candelete = false;
1486 }
1487 if (VOP_ISLOCKED(nd.ni_vp) != LK_EXCLUSIVE) {
1488 vn_lock(nd.ni_vp, LK_UPGRADE | LK_RETRY);
1489 if (VN_IS_DOOMED(nd.ni_vp)) {
1490 /* Forced unmount. */
1491 error = EBADF;
1492 goto bad;
1493 }
1494 }
1495 nd.ni_vp->v_vflag |= VV_MD;
1496 VOP_UNLOCK(nd.ni_vp);
1497
1498 if (mdr->md_fwsectors != 0)
1499 sc->fwsectors = mdr->md_fwsectors;
1500 if (mdr->md_fwheads != 0)
1501 sc->fwheads = mdr->md_fwheads;
1502 snprintf(sc->ident, sizeof(sc->ident), "MD-DEV%ju-INO%ju",
1503 (uintmax_t)vattr.va_fsid, (uintmax_t)vattr.va_fileid);
1504 sc->flags = mdr->md_options & (MD_ASYNC | MD_CACHE | MD_FORCE |
1505 MD_VERIFY | MD_MUSTDEALLOC);
1506 if (!(flags & FWRITE))
1507 sc->flags |= MD_READONLY;
1508 sc->s_vnode.vnode = nd.ni_vp;
1509
1510 error = mdsetcred(sc, td->td_ucred);
1511 if (error != 0) {
1512 sc->s_vnode.vnode = NULL;
1513 vn_lock(nd.ni_vp, LK_EXCLUSIVE | LK_RETRY);
1514 nd.ni_vp->v_vflag &= ~VV_MD;
1515 goto bad;
1516 }
1517
1518 sc->s_vnode.kva = kva_alloc(maxphys + PAGE_SIZE);
1519 return (0);
1520 bad:
1521 VOP_UNLOCK(nd.ni_vp);
1522 (void)vn_close(nd.ni_vp, flags, td->td_ucred, td);
1523 return (error);
1524 }
1525
1526 static void
g_md_providergone(struct g_provider * pp)1527 g_md_providergone(struct g_provider *pp)
1528 {
1529 struct md_s *sc = pp->geom->softc;
1530
1531 mtx_lock(&sc->queue_mtx);
1532 sc->flags |= MD_PROVIDERGONE;
1533 wakeup(&sc->flags);
1534 mtx_unlock(&sc->queue_mtx);
1535 }
1536
1537 static int
mddestroy(struct md_s * sc,struct thread * td)1538 mddestroy(struct md_s *sc, struct thread *td)
1539 {
1540
1541 if (sc->gp) {
1542 g_topology_lock();
1543 g_wither_geom(sc->gp, ENXIO);
1544 g_topology_unlock();
1545
1546 mtx_lock(&sc->queue_mtx);
1547 while (!(sc->flags & MD_PROVIDERGONE))
1548 msleep(&sc->flags, &sc->queue_mtx, PRIBIO, "mddestroy", 0);
1549 mtx_unlock(&sc->queue_mtx);
1550 }
1551 if (sc->devstat) {
1552 devstat_remove_entry(sc->devstat);
1553 sc->devstat = NULL;
1554 }
1555 mtx_lock(&sc->queue_mtx);
1556 sc->flags |= MD_SHUTDOWN;
1557 wakeup(sc);
1558 while (!(sc->flags & MD_EXITING))
1559 msleep(sc->procp, &sc->queue_mtx, PRIBIO, "mddestroy", hz / 10);
1560 mtx_unlock(&sc->queue_mtx);
1561 mtx_destroy(&sc->queue_mtx);
1562 switch (sc->type) {
1563 case MD_VNODE:
1564 if (sc->s_vnode.vnode != NULL) {
1565 vn_lock(sc->s_vnode.vnode, LK_EXCLUSIVE | LK_RETRY);
1566 sc->s_vnode.vnode->v_vflag &= ~VV_MD;
1567 VOP_UNLOCK(sc->s_vnode.vnode);
1568 (void)vn_close(sc->s_vnode.vnode,
1569 sc->flags & MD_READONLY ? FREAD : (FREAD|FWRITE),
1570 sc->cred, td);
1571 }
1572 if (sc->s_vnode.kva != 0)
1573 kva_free(sc->s_vnode.kva, maxphys + PAGE_SIZE);
1574 break;
1575 case MD_SWAP:
1576 if (sc->s_swap.object != NULL)
1577 vm_object_deallocate(sc->s_swap.object);
1578 break;
1579 case MD_MALLOC:
1580 if (sc->s_malloc.indir != NULL)
1581 destroy_indir(sc, sc->s_malloc.indir);
1582 if (sc->s_malloc.uma != NULL)
1583 uma_zdestroy(sc->s_malloc.uma);
1584 break;
1585 case MD_PRELOAD:
1586 case MD_NULL:
1587 break;
1588 default:
1589 __assert_unreachable();
1590 }
1591 if (sc->cred != NULL)
1592 crfree(sc->cred);
1593
1594 LIST_REMOVE(sc, list);
1595 free_unr(md_uh, sc->unit);
1596 free(sc, M_MD);
1597 return (0);
1598 }
1599
1600 static int
mdresize(struct md_s * sc,struct md_req * mdr)1601 mdresize(struct md_s *sc, struct md_req *mdr)
1602 {
1603 int error, res;
1604 vm_pindex_t oldpages, newpages;
1605
1606 switch (sc->type) {
1607 case MD_VNODE:
1608 case MD_NULL:
1609 break;
1610 case MD_SWAP:
1611 if (mdr->md_mediasize <= 0 ||
1612 (mdr->md_mediasize % PAGE_SIZE) != 0)
1613 return (EDOM);
1614 oldpages = OFF_TO_IDX(sc->mediasize);
1615 newpages = OFF_TO_IDX(mdr->md_mediasize);
1616 if (newpages < oldpages) {
1617 VM_OBJECT_WLOCK(sc->s_swap.object);
1618 vm_object_page_remove(sc->s_swap.object, newpages,
1619 0, 0);
1620 swap_release_by_cred(IDX_TO_OFF(oldpages -
1621 newpages), sc->cred);
1622 sc->s_swap.object->charge = IDX_TO_OFF(newpages);
1623 sc->s_swap.object->size = newpages;
1624 VM_OBJECT_WUNLOCK(sc->s_swap.object);
1625 } else if (newpages > oldpages) {
1626 res = swap_reserve_by_cred(IDX_TO_OFF(newpages -
1627 oldpages), sc->cred);
1628 if (!res)
1629 return (ENOMEM);
1630 if ((mdr->md_options & MD_RESERVE) ||
1631 (sc->flags & MD_RESERVE)) {
1632 error = swap_pager_reserve(sc->s_swap.object,
1633 oldpages, newpages - oldpages);
1634 if (error < 0) {
1635 swap_release_by_cred(
1636 IDX_TO_OFF(newpages - oldpages),
1637 sc->cred);
1638 return (EDOM);
1639 }
1640 }
1641 VM_OBJECT_WLOCK(sc->s_swap.object);
1642 sc->s_swap.object->charge = IDX_TO_OFF(newpages);
1643 sc->s_swap.object->size = newpages;
1644 VM_OBJECT_WUNLOCK(sc->s_swap.object);
1645 }
1646 break;
1647 default:
1648 return (EOPNOTSUPP);
1649 }
1650
1651 sc->mediasize = mdr->md_mediasize;
1652
1653 g_topology_lock();
1654 g_resize_provider(sc->pp, sc->mediasize);
1655 g_topology_unlock();
1656 return (0);
1657 }
1658
1659 static int
mdcreate_swap(struct md_s * sc,struct md_req * mdr,struct thread * td)1660 mdcreate_swap(struct md_s *sc, struct md_req *mdr, struct thread *td)
1661 {
1662 vm_ooffset_t npage;
1663 int error;
1664
1665 /*
1666 * Range check. Disallow negative sizes and sizes not being
1667 * multiple of page size.
1668 */
1669 if (sc->mediasize <= 0 || (sc->mediasize % PAGE_SIZE) != 0)
1670 return (EDOM);
1671
1672 /*
1673 * Allocate an OBJT_SWAP object.
1674 *
1675 * Note the truncation.
1676 */
1677
1678 if ((mdr->md_options & MD_VERIFY) != 0)
1679 return (EINVAL);
1680 npage = mdr->md_mediasize / PAGE_SIZE;
1681 if (mdr->md_fwsectors != 0)
1682 sc->fwsectors = mdr->md_fwsectors;
1683 if (mdr->md_fwheads != 0)
1684 sc->fwheads = mdr->md_fwheads;
1685 sc->s_swap.object = vm_pager_allocate(OBJT_SWAP, NULL,
1686 PAGE_SIZE * npage, VM_PROT_DEFAULT, 0, td->td_ucred);
1687 if (sc->s_swap.object == NULL)
1688 return (ENOMEM);
1689 sc->flags = mdr->md_options & (MD_FORCE | MD_RESERVE);
1690 if (mdr->md_options & MD_RESERVE) {
1691 if (swap_pager_reserve(sc->s_swap.object, 0, npage) < 0) {
1692 error = EDOM;
1693 goto finish;
1694 }
1695 }
1696 error = mdsetcred(sc, td->td_ucred);
1697 finish:
1698 if (error != 0) {
1699 vm_object_deallocate(sc->s_swap.object);
1700 sc->s_swap.object = NULL;
1701 }
1702 return (error);
1703 }
1704
1705 static int
mdcreate_null(struct md_s * sc,struct md_req * mdr,struct thread * td)1706 mdcreate_null(struct md_s *sc, struct md_req *mdr, struct thread *td)
1707 {
1708
1709 /*
1710 * Range check. Disallow negative sizes and sizes not being
1711 * multiple of page size.
1712 */
1713 if (sc->mediasize <= 0 || (sc->mediasize % PAGE_SIZE) != 0)
1714 return (EDOM);
1715
1716 return (0);
1717 }
1718
1719 static int
kern_mdattach_locked(struct thread * td,struct md_req * mdr)1720 kern_mdattach_locked(struct thread *td, struct md_req *mdr)
1721 {
1722 struct md_s *sc;
1723 unsigned sectsize;
1724 int error;
1725
1726 sx_assert(&md_sx, SA_XLOCKED);
1727
1728 switch (mdr->md_type) {
1729 case MD_MALLOC:
1730 case MD_PRELOAD:
1731 case MD_VNODE:
1732 case MD_SWAP:
1733 case MD_NULL:
1734 break;
1735 default:
1736 return (EINVAL);
1737 }
1738 if (mdr->md_sectorsize == 0)
1739 sectsize = DEV_BSIZE;
1740 else
1741 sectsize = mdr->md_sectorsize;
1742 if (sectsize > maxphys || mdr->md_mediasize < sectsize)
1743 return (EINVAL);
1744 if (mdr->md_options & MD_AUTOUNIT)
1745 sc = mdnew(-1, &error, mdr->md_type);
1746 else {
1747 if (mdr->md_unit > INT_MAX)
1748 return (EINVAL);
1749 sc = mdnew(mdr->md_unit, &error, mdr->md_type);
1750 }
1751 if (sc == NULL)
1752 return (error);
1753 if (mdr->md_label != NULL)
1754 error = copyinstr(mdr->md_label, sc->label,
1755 sizeof(sc->label), NULL);
1756 if (error != 0)
1757 goto err_after_new;
1758 if (mdr->md_options & MD_AUTOUNIT)
1759 mdr->md_unit = sc->unit;
1760 sc->mediasize = mdr->md_mediasize;
1761 sc->sectorsize = sectsize;
1762 sc->candelete = true;
1763 error = EDOOFUS;
1764 switch (sc->type) {
1765 case MD_MALLOC:
1766 sc->start = mdstart_malloc;
1767 error = mdcreate_malloc(sc, mdr);
1768 break;
1769 case MD_PRELOAD:
1770 /*
1771 * We disallow attaching preloaded memory disks via
1772 * ioctl. Preloaded memory disks are automatically
1773 * attached in g_md_init().
1774 */
1775 error = EOPNOTSUPP;
1776 break;
1777 case MD_VNODE:
1778 sc->start = mdstart_vnode;
1779 error = mdcreate_vnode(sc, mdr, td);
1780 break;
1781 case MD_SWAP:
1782 sc->start = mdstart_swap;
1783 error = mdcreate_swap(sc, mdr, td);
1784 break;
1785 case MD_NULL:
1786 sc->start = mdstart_null;
1787 error = mdcreate_null(sc, mdr, td);
1788 break;
1789 }
1790 err_after_new:
1791 if (error != 0) {
1792 mddestroy(sc, td);
1793 return (error);
1794 }
1795
1796 mdinit(sc);
1797 return (0);
1798 }
1799
1800 static int
kern_mdattach(struct thread * td,struct md_req * mdr)1801 kern_mdattach(struct thread *td, struct md_req *mdr)
1802 {
1803 int error;
1804
1805 sx_xlock(&md_sx);
1806 error = kern_mdattach_locked(td, mdr);
1807 sx_xunlock(&md_sx);
1808 return (error);
1809 }
1810
1811 static int
kern_mddetach_locked(struct thread * td,struct md_req * mdr)1812 kern_mddetach_locked(struct thread *td, struct md_req *mdr)
1813 {
1814 struct md_s *sc;
1815
1816 sx_assert(&md_sx, SA_XLOCKED);
1817
1818 if (mdr->md_mediasize != 0 ||
1819 (mdr->md_options & ~MD_FORCE) != 0)
1820 return (EINVAL);
1821
1822 sc = mdfind(mdr->md_unit);
1823 if (sc == NULL)
1824 return (ENOENT);
1825 if (sc->opencount != 0 && !(sc->flags & MD_FORCE) &&
1826 !(mdr->md_options & MD_FORCE))
1827 return (EBUSY);
1828 return (mddestroy(sc, td));
1829 }
1830
1831 static int
kern_mddetach(struct thread * td,struct md_req * mdr)1832 kern_mddetach(struct thread *td, struct md_req *mdr)
1833 {
1834 int error;
1835
1836 sx_xlock(&md_sx);
1837 error = kern_mddetach_locked(td, mdr);
1838 sx_xunlock(&md_sx);
1839 return (error);
1840 }
1841
1842 static int
kern_mdresize_locked(struct md_req * mdr)1843 kern_mdresize_locked(struct md_req *mdr)
1844 {
1845 struct md_s *sc;
1846
1847 sx_assert(&md_sx, SA_XLOCKED);
1848
1849 if ((mdr->md_options & ~(MD_FORCE | MD_RESERVE)) != 0)
1850 return (EINVAL);
1851
1852 sc = mdfind(mdr->md_unit);
1853 if (sc == NULL)
1854 return (ENOENT);
1855 if (mdr->md_mediasize < sc->sectorsize)
1856 return (EINVAL);
1857 mdr->md_mediasize -= mdr->md_mediasize % sc->sectorsize;
1858 if (mdr->md_mediasize < sc->mediasize &&
1859 !(sc->flags & MD_FORCE) &&
1860 !(mdr->md_options & MD_FORCE))
1861 return (EBUSY);
1862 return (mdresize(sc, mdr));
1863 }
1864
1865 static int
kern_mdresize(struct md_req * mdr)1866 kern_mdresize(struct md_req *mdr)
1867 {
1868 int error;
1869
1870 sx_xlock(&md_sx);
1871 error = kern_mdresize_locked(mdr);
1872 sx_xunlock(&md_sx);
1873 return (error);
1874 }
1875
1876 static int
kern_mdquery_locked(struct md_req * mdr)1877 kern_mdquery_locked(struct md_req *mdr)
1878 {
1879 struct md_s *sc;
1880 int error;
1881
1882 sx_assert(&md_sx, SA_XLOCKED);
1883
1884 sc = mdfind(mdr->md_unit);
1885 if (sc == NULL)
1886 return (ENOENT);
1887 mdr->md_type = sc->type;
1888 mdr->md_options = sc->flags;
1889 mdr->md_mediasize = sc->mediasize;
1890 mdr->md_sectorsize = sc->sectorsize;
1891 error = 0;
1892 if (mdr->md_label != NULL) {
1893 error = copyout(sc->label, mdr->md_label,
1894 strlen(sc->label) + 1);
1895 if (error != 0)
1896 return (error);
1897 }
1898 if (sc->type == MD_VNODE) {
1899 error = copyout(sc->s_vnode.file, mdr->md_file,
1900 strlen(sc->s_vnode.file) + 1);
1901 } else if (sc->type == MD_PRELOAD && mdr->md_file != NULL) {
1902 error = copyout(sc->s_preload.name, mdr->md_file,
1903 strlen(sc->s_preload.name) + 1);
1904 }
1905 return (error);
1906 }
1907
1908 static int
kern_mdquery(struct md_req * mdr)1909 kern_mdquery(struct md_req *mdr)
1910 {
1911 int error;
1912
1913 sx_xlock(&md_sx);
1914 error = kern_mdquery_locked(mdr);
1915 sx_xunlock(&md_sx);
1916 return (error);
1917 }
1918
1919 /* Copy members that are not userspace pointers. */
1920 #define MD_IOCTL2REQ(mdio, mdr) do { \
1921 (mdr)->md_unit = (mdio)->md_unit; \
1922 (mdr)->md_type = (mdio)->md_type; \
1923 (mdr)->md_mediasize = (mdio)->md_mediasize; \
1924 (mdr)->md_sectorsize = (mdio)->md_sectorsize; \
1925 (mdr)->md_options = (mdio)->md_options; \
1926 (mdr)->md_fwheads = (mdio)->md_fwheads; \
1927 (mdr)->md_fwsectors = (mdio)->md_fwsectors; \
1928 (mdr)->md_units = &(mdio)->md_pad[0]; \
1929 (mdr)->md_units_nitems = nitems((mdio)->md_pad); \
1930 } while(0)
1931
1932 /* Copy members that might have been updated */
1933 #define MD_REQ2IOCTL(mdr, mdio) do { \
1934 (mdio)->md_unit = (mdr)->md_unit; \
1935 (mdio)->md_type = (mdr)->md_type; \
1936 (mdio)->md_mediasize = (mdr)->md_mediasize; \
1937 (mdio)->md_sectorsize = (mdr)->md_sectorsize; \
1938 (mdio)->md_options = (mdr)->md_options; \
1939 (mdio)->md_fwheads = (mdr)->md_fwheads; \
1940 (mdio)->md_fwsectors = (mdr)->md_fwsectors; \
1941 } while(0)
1942
1943 static int
mdctlioctl(struct cdev * dev,u_long cmd,caddr_t addr,int flags,struct thread * td)1944 mdctlioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flags,
1945 struct thread *td)
1946 {
1947 struct md_req mdr;
1948 int error;
1949
1950 if (md_debug)
1951 printf("mdctlioctl(%s %lx %p %x %p)\n",
1952 devtoname(dev), cmd, addr, flags, td);
1953
1954 bzero(&mdr, sizeof(mdr));
1955 switch (cmd) {
1956 case MDIOCATTACH:
1957 case MDIOCDETACH:
1958 case MDIOCRESIZE:
1959 case MDIOCQUERY: {
1960 struct md_ioctl *mdio = (struct md_ioctl *)addr;
1961 if (mdio->md_version != MDIOVERSION)
1962 return (EINVAL);
1963 MD_IOCTL2REQ(mdio, &mdr);
1964 mdr.md_file = mdio->md_file;
1965 mdr.md_file_seg = UIO_USERSPACE;
1966 /* If the file is adjacent to the md_ioctl it's in kernel. */
1967 if ((void *)mdio->md_file == (void *)(mdio + 1))
1968 mdr.md_file_seg = UIO_SYSSPACE;
1969 mdr.md_label = mdio->md_label;
1970 break;
1971 }
1972 #ifdef COMPAT_FREEBSD32
1973 case MDIOCATTACH_32:
1974 case MDIOCDETACH_32:
1975 case MDIOCRESIZE_32:
1976 case MDIOCQUERY_32: {
1977 struct md_ioctl32 *mdio = (struct md_ioctl32 *)addr;
1978 if (mdio->md_version != MDIOVERSION)
1979 return (EINVAL);
1980 MD_IOCTL2REQ(mdio, &mdr);
1981 mdr.md_file = (void *)(uintptr_t)mdio->md_file;
1982 mdr.md_file_seg = UIO_USERSPACE;
1983 mdr.md_label = (void *)(uintptr_t)mdio->md_label;
1984 break;
1985 }
1986 #endif
1987 default:
1988 /* Fall through to handler switch. */
1989 break;
1990 }
1991
1992 error = 0;
1993 switch (cmd) {
1994 case MDIOCATTACH:
1995 #ifdef COMPAT_FREEBSD32
1996 case MDIOCATTACH_32:
1997 #endif
1998 error = kern_mdattach(td, &mdr);
1999 break;
2000 case MDIOCDETACH:
2001 #ifdef COMPAT_FREEBSD32
2002 case MDIOCDETACH_32:
2003 #endif
2004 error = kern_mddetach(td, &mdr);
2005 break;
2006 case MDIOCRESIZE:
2007 #ifdef COMPAT_FREEBSD32
2008 case MDIOCRESIZE_32:
2009 #endif
2010 error = kern_mdresize(&mdr);
2011 break;
2012 case MDIOCQUERY:
2013 #ifdef COMPAT_FREEBSD32
2014 case MDIOCQUERY_32:
2015 #endif
2016 error = kern_mdquery(&mdr);
2017 break;
2018 default:
2019 error = ENOIOCTL;
2020 }
2021
2022 switch (cmd) {
2023 case MDIOCATTACH:
2024 case MDIOCQUERY: {
2025 struct md_ioctl *mdio = (struct md_ioctl *)addr;
2026 MD_REQ2IOCTL(&mdr, mdio);
2027 break;
2028 }
2029 #ifdef COMPAT_FREEBSD32
2030 case MDIOCATTACH_32:
2031 case MDIOCQUERY_32: {
2032 struct md_ioctl32 *mdio = (struct md_ioctl32 *)addr;
2033 MD_REQ2IOCTL(&mdr, mdio);
2034 break;
2035 }
2036 #endif
2037 default:
2038 /* Other commands to not alter mdr. */
2039 break;
2040 }
2041
2042 return (error);
2043 }
2044
2045 static void
md_preloaded(u_char * image,size_t length,const char * name)2046 md_preloaded(u_char *image, size_t length, const char *name)
2047 {
2048 struct md_s *sc;
2049 int error;
2050
2051 sc = mdnew(-1, &error, MD_PRELOAD);
2052 if (sc == NULL)
2053 return;
2054 sc->mediasize = length;
2055 sc->sectorsize = DEV_BSIZE;
2056 sc->s_preload.pl_ptr = image;
2057 sc->s_preload.pl_len = length;
2058 sc->start = mdstart_preload;
2059 if (name != NULL)
2060 strlcpy(sc->s_preload.name, name,
2061 sizeof(sc->s_preload.name));
2062 #ifdef MD_ROOT
2063 if (sc->unit == 0) {
2064 #ifndef ROOTDEVNAME
2065 rootdevnames[0] = MD_ROOT_FSTYPE ":/dev/md0";
2066 #endif
2067 #ifdef MD_ROOT_READONLY
2068 sc->flags |= MD_READONLY;
2069 #endif
2070 }
2071 #endif
2072 mdinit(sc);
2073 if (name != NULL) {
2074 printf("%s%d: Preloaded image <%s> %zd bytes at %p\n",
2075 MD_NAME, sc->unit, name, length, image);
2076 } else {
2077 printf("%s%d: Embedded image %zd bytes at %p\n",
2078 MD_NAME, sc->unit, length, image);
2079 }
2080 }
2081
2082 static void
g_md_init(struct g_class * mp __unused)2083 g_md_init(struct g_class *mp __unused)
2084 {
2085 caddr_t mod;
2086 u_char *ptr, *name, *type;
2087 u_char scratch[40];
2088 unsigned len;
2089 int i;
2090 vm_offset_t paddr;
2091
2092 /* figure out log2(NINDIR) */
2093 for (i = NINDIR, nshift = -1; i; nshift++)
2094 i >>= 1;
2095
2096 mod = NULL;
2097 sx_init(&md_sx, "MD config lock");
2098 g_topology_unlock();
2099 md_uh = new_unrhdr(0, INT_MAX, NULL);
2100 #ifdef MD_ROOT
2101 if (mfs_root_size != 0) {
2102 sx_xlock(&md_sx);
2103 #ifdef MD_ROOT_MEM
2104 md_preloaded(mfs_root, mfs_root_size, NULL);
2105 #else
2106 md_preloaded(__DEVOLATILE(u_char *, &mfs_root), mfs_root_size,
2107 NULL);
2108 #endif
2109 sx_xunlock(&md_sx);
2110 }
2111 #endif
2112 /* XXX: are preload_* static or do they need Giant ? */
2113 while ((mod = preload_search_next_name(mod)) != NULL) {
2114 name = (char *)preload_search_info(mod, MODINFO_NAME);
2115 if (name == NULL)
2116 continue;
2117 type = (char *)preload_search_info(mod, MODINFO_TYPE);
2118 if (type == NULL)
2119 continue;
2120 if (strcmp(type, "md_image") && strcmp(type, "mfs_root"))
2121 continue;
2122 ptr = preload_fetch_addr(mod);
2123 len = preload_fetch_size(mod);
2124 if (ptr != NULL && len != 0) {
2125 sx_xlock(&md_sx);
2126 md_preloaded(ptr, len, name);
2127 sx_xunlock(&md_sx);
2128 }
2129 }
2130
2131 /*
2132 * Load up to 32 pre-loaded disks
2133 */
2134 for (int i = 0; i < 32; i++) {
2135 if (resource_long_value("md", i, "physaddr",
2136 (long *) &paddr) != 0 ||
2137 resource_int_value("md", i, "len", &len) != 0)
2138 break;
2139 ptr = (char *)pmap_map(NULL, paddr, paddr + len, VM_PROT_READ);
2140 if (ptr != NULL && len != 0) {
2141 sprintf(scratch, "preload%d 0x%016jx", i,
2142 (uintmax_t)paddr);
2143 sx_xlock(&md_sx);
2144 md_preloaded(ptr, len, scratch);
2145 sx_xunlock(&md_sx);
2146 }
2147 }
2148
2149 status_dev = make_dev(&mdctl_cdevsw, INT_MAX, UID_ROOT, GID_WHEEL,
2150 0600, MDCTL_NAME);
2151 g_topology_lock();
2152 }
2153
2154 static void
g_md_dumpconf(struct sbuf * sb,const char * indent,struct g_geom * gp,struct g_consumer * cp __unused,struct g_provider * pp)2155 g_md_dumpconf(struct sbuf *sb, const char *indent, struct g_geom *gp,
2156 struct g_consumer *cp __unused, struct g_provider *pp)
2157 {
2158 struct md_s *mp;
2159 char *type;
2160
2161 mp = gp->softc;
2162 if (mp == NULL)
2163 return;
2164
2165 switch (mp->type) {
2166 case MD_MALLOC:
2167 type = "malloc";
2168 break;
2169 case MD_PRELOAD:
2170 type = "preload";
2171 break;
2172 case MD_VNODE:
2173 type = "vnode";
2174 break;
2175 case MD_SWAP:
2176 type = "swap";
2177 break;
2178 case MD_NULL:
2179 type = "null";
2180 break;
2181 default:
2182 type = "unknown";
2183 break;
2184 }
2185
2186 if (pp != NULL) {
2187 if (indent == NULL) {
2188 sbuf_printf(sb, " u %d", mp->unit);
2189 sbuf_printf(sb, " s %ju", (uintmax_t) mp->sectorsize);
2190 sbuf_printf(sb, " f %ju", (uintmax_t) mp->fwheads);
2191 sbuf_printf(sb, " fs %ju", (uintmax_t) mp->fwsectors);
2192 sbuf_printf(sb, " l %ju", (uintmax_t) mp->mediasize);
2193 sbuf_printf(sb, " t %s", type);
2194 if (mp->type == MD_VNODE &&
2195 mp->s_vnode.vnode != NULL)
2196 sbuf_printf(sb, " file %s", mp->s_vnode.file);
2197 if (mp->type == MD_PRELOAD &&
2198 mp->s_preload.name[0] != '\0') {
2199 sbuf_printf(sb, " file %s",
2200 mp->s_preload.name);
2201 }
2202 sbuf_printf(sb, " label %s", mp->label);
2203 } else {
2204 sbuf_printf(sb, "%s<unit>%d</unit>\n", indent,
2205 mp->unit);
2206 sbuf_printf(sb, "%s<sectorsize>%ju</sectorsize>\n",
2207 indent, (uintmax_t) mp->sectorsize);
2208 sbuf_printf(sb, "%s<fwheads>%ju</fwheads>\n",
2209 indent, (uintmax_t) mp->fwheads);
2210 sbuf_printf(sb, "%s<fwsectors>%ju</fwsectors>\n",
2211 indent, (uintmax_t) mp->fwsectors);
2212 if (mp->ident[0] != '\0') {
2213 sbuf_printf(sb, "%s<ident>", indent);
2214 g_conf_printf_escaped(sb, "%s", mp->ident);
2215 sbuf_printf(sb, "</ident>\n");
2216 }
2217 sbuf_printf(sb, "%s<length>%ju</length>\n",
2218 indent, (uintmax_t) mp->mediasize);
2219 sbuf_printf(sb, "%s<compression>%s</compression>\n", indent,
2220 (mp->flags & MD_COMPRESS) == 0 ? "off": "on");
2221 sbuf_printf(sb, "%s<access>%s</access>\n", indent,
2222 (mp->flags & MD_READONLY) == 0 ? "read-write":
2223 "read-only");
2224 sbuf_printf(sb, "%s<type>%s</type>\n", indent,
2225 type);
2226 if (mp->type == MD_VNODE) {
2227 if (mp->s_vnode.vnode != NULL) {
2228 sbuf_printf(sb, "%s<file>", indent);
2229 g_conf_printf_escaped(sb, "%s",
2230 mp->s_vnode.file);
2231 sbuf_printf(sb, "</file>\n");
2232 }
2233 sbuf_printf(sb, "%s<cache>%s</cache>\n", indent,
2234 (mp->flags & MD_CACHE) == 0 ? "off": "on");
2235 }
2236 if (mp->type == MD_PRELOAD &&
2237 mp->s_preload.name[0] != '\0') {
2238 sbuf_printf(sb, "%s<file>", indent);
2239 g_conf_printf_escaped(sb, "%s",
2240 mp->s_preload.name);
2241 sbuf_printf(sb, "</file>\n");
2242 }
2243 sbuf_printf(sb, "%s<label>", indent);
2244 g_conf_printf_escaped(sb, "%s", mp->label);
2245 sbuf_printf(sb, "</label>\n");
2246 }
2247 }
2248 }
2249
2250 static void
g_md_fini(struct g_class * mp __unused)2251 g_md_fini(struct g_class *mp __unused)
2252 {
2253
2254 sx_destroy(&md_sx);
2255 if (status_dev != NULL)
2256 destroy_dev(status_dev);
2257 delete_unrhdr(md_uh);
2258 }
2259