![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to disk_label.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / scsi|
Return to disk_label.c CVS log | Up to [GnuMach] / Gnu-Mach / scsi |
1.1 root 1: /*
2: * Copyright (c) 1996 The University of Utah and
3: * the Computer Systems Laboratory at the University of Utah (CSL).
4: * All rights reserved.
5: *
6: * Permission to use, copy, modify and distribute this software is hereby
7: * granted provided that (1) source code retains these copyright, permission,
8: * and disclaimer notices, and (2) redistributions including binaries
9: * reproduce the notices in supporting documentation, and (3) all advertising
10: * materials mentioning features or use of this software display the following
11: * acknowledgement: ``This product includes software developed by the
12: * Computer Systems Laboratory at the University of Utah.''
13: *
14: * THE UNIVERSITY OF UTAH AND CSL ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS
15: * IS" CONDITION. THE UNIVERSITY OF UTAH AND CSL DISCLAIM ANY LIABILITY OF
16: * ANY KIND FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
17: *
18: * CSL requests users of this software to return to [email protected] any
19: * improvements that they make and grant CSL redistribution rights.
20: *
21: * Author: Kevin T. Van Maren, University of Utah CSL
22: */
23:
24: /*
25: * Mach Operating System
26: * Copyright (c) 1991,1990 Carnegie Mellon University
27: * All Rights Reserved.
28: *
29: * Permission to use, copy, modify and distribute this software and its
30: * documentation is hereby granted, provided that both the copyright
31: * notice and this permission notice appear in all copies of the
32: * software, derivative works or modified versions, and any portions
33: * thereof, and that both notices appear in supporting documentation.
34: *
35: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
36: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR
37: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
38: *
39: * Carnegie Mellon requests users of this software to return to
40: *
41: * Software Distribution Coordinator or [email protected]
42: * School of Computer Science
43: * Carnegie Mellon University
44: * Pittsburgh PA 15213-3890
45: *
46: * any improvements or extensions that they make and grant Carnegie Mellon
47: * the rights to redistribute these changes.
48: */
49:
50: /*
51: * Copyright (c) 1994 Shantanu Goel
52: * All Rights Reserved.
53: *
54: * Permission to use, copy, modify and distribute this software and its
55: * documentation is hereby granted, provided that both the copyright
56: * notice and this permission notice appear in all copies of the
57: * software, derivative works or modified versions, and any portions
58: * thereof, and that both notices appear in supporting documentation.
59: *
60: * THE AUTHOR ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS"
61: * CONDITION. THE AUTHOR DISCLAIMS ANY LIABILITY OF ANY KIND FOR
62: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
63: *
64: */
65:
66: /* This file contains the partition code that is used by the Mach
67: * device drivers (ide & scsi). */
68:
69: #include <scsi/compat_30.h>
70: #include <sys/types.h>
71:
72: #include <scsi/rz_labels.h>
73: #include <i386at/disk.h> /* combine & rename these... */
74:
75: #define SECTOR_SIZE 512 /* BAD!!! */
76:
77: #define DSLICE(dev) ((dev >> 4) & 0x3f)
78: #define DPART(dev) (dev & 0xf)
79:
80: /* note: 0 will supress ALL output;
81: 1 is 'normal' output; 2 is verbose; 3 is Very verbose */
82: #define PARTITION_DEBUG 1
83:
84: #define min(x,y) (x<y?x:y)
85:
86: /*
87: * Label that is filled in with extra info
88: */
89: struct disklabel default_label =
90: {
91: DISKMAGIC, DTYPE_SCSI, 0,
92: "SCSI", "",
93: DEV_BSIZE, 1, 1, 1, 1, 1, 0, 0, 0,
94: 3600, 1, 1, 1, 0, 0, 0,
95: {0,}, {0,},
96: DISKMAGIC, 0,
97: 8, 8192, 8192,
98: {{ -1, 0, 1024, FS_BSDFFS, 8, 3 },
99: { -1, 0, 1024, FS_BSDFFS, 8, 3 },
100: { -1, 0, 1024, FS_BSDFFS, 8, 3 },
101: { -1, 0, 1024, FS_BSDFFS, 8, 3 },
102: { -1, 0, 1024, FS_BSDFFS, 8, 3 },
103: { -1, 0, 1024, FS_BSDFFS, 8, 3 },
104: { -1, 0, 1024, FS_BSDFFS, 8, 3 },
105: { -1, 0, 1024, FS_BSDFFS, 8, 3 }}
106: };
107:
108:
109:
110: /* the device driver calls this just to save some info it got from the HW */
111: /* This is a bad holdover from the disklabel days, and needs to go */
112: fudge_bsd_label(struct disklabel *label, int type, int total_secs, int heads, int sectors, int sectorsize, int n)
113: {
114: *label=default_label;
115:
116: label->d_ncylinders = total_secs/(heads*sectors);
117: label->d_ntracks = heads;
118: label->d_nsectors = sectors;
119:
120: label->d_secpercyl = heads*sectors;
121: label->d_secperunit = total_secs;
122:
123: /* this is never used, but ... */
124: label->d_partitions[MAXPARTITIONS].p_offset = 0;
125: label->d_partitions[MAXPARTITIONS].p_size = total_secs;
126:
127: /* ??
128: */
129: label->d_secsize = sectorsize;
130: label->d_type = type;
131: label->d_subtype = 0xa; /* ??? */
132:
133: label->d_npartitions = n; /* up to 'c' */
134: label->d_checksum = 0;
135:
136: /* should do a checksum on it now */
137: }
138:
139:
140:
141: /* This is placed here to
142: a. provide comparability with existing servers
143: b. allow the use of FreeBSD-style slices to access ANY disk partition
144: c. provide an easy migration path to lites-based partition code
145: by only passing the drive name to get the entire disk (sd0).
146:
147: This will be called by every routine that needs to access partition info
148: based on a device number. It is slower than the old method of indexing
149: into a disklabel, but is more flexible, and reasonably fast in the (future)
150: case where Lites will access the whole disk. An array of disklabels
151: could have been used, but this is more compact and general. The underlying
152: structure does not limit it to 2-levels, but keeping the kernel interface
153: simple does. */
154:
155:
156: /* this code and data structure based on conversation with Bryan Ford */
157: /* Note: this is called ON EVERY read or write. It makes sense to
158: optimize this for the common case. Hopefully the common case
159: will become the '0,0' case, as partitioning is moved out of the
160: kernel. (Downside is kernel can't protect filesystems from each other).
161: It is slower than indexing into a 1-D array, but not much. */
162:
163: struct diskpart *lookup_part(struct diskpart *array, int dev_number)
164: {
165: /* Note: 10 bit encoding to get partitions 0-15 (0,a-h typically), and slices
166: * 0-63
167: */
168:
169: int slice = DSLICE(dev_number);
170: int part = DPART(dev_number);
171: struct diskpart *s;
172:
173: if (slice == 0) /* compatability slice */
174: {
175: if (part == 0) /* whole disk */
176: return &array[0];
177:
178: if (array[0].type == DISKPART_DOS)
179: {
180: int i;
181: for (i = 0; i < array[0].nsubs; i++)
182: {
183: s = &array[0].subs[i];
184: if ( s->type == DISKPART_BSD
185: || s->type == DISKPART_VTOC)
186: {
187: if (part > s->nsubs)
188: return 0;
189: return (&s->subs[part-1]);
190: }
191: }
192: }
193:
194: if (part > array[0].nsubs)
195: return 0;
196: return(&array[0].subs[part-1]);
197: }
198: else
199: {
200: if ( array[0].type != DISKPART_DOS
201: || slice > array[0].nsubs)
202: return 0;
203:
204: s = &array[0].subs[slice-1];
205:
206: if (part == 0) /* whole slice */
207: return (s);
208: if (part > s->nsubs)
209: return 0;
210:
211: return (&s->subs[part-1]);
212: }
213: }
214:
215:
216:
217:
218: static inline void fill_array(struct diskpart *array, int start, int size,
219: struct diskpart *subs, int nsubs, short type, short fsys)
220: {
221: array->start=start;
222: array->size=size;
223: array->subs=subs;
224: array->nsubs=nsubs;
225: array->type=type;
226: array->fsys=fsys;
227: #if (PARTITION_DEBUG > 2)
228: printf("fill: type %d:%d, start %d, size %d, %d parts\n",type,fsys,
229: start,size,nsubs);
230: #endif
231: }
232:
233:
234:
235:
236: void print_array(struct diskpart *array, int level)
237: {
238: int i,j;
239: struct diskpart *subs;
240:
241: #if (PARTITION_DEBUG)
242: subs=array[0].subs;
243:
244: for (i=0;i<array[0].nsubs;i++) {
245: for (j=0;j<level;j++)
246: printf(" ");
247: printf("%c: %d, %d, %d, %d (%d subparts)\n",'a'+i,
248: subs[i].start, subs[i].size, subs[i].fsys,
249: subs[i].type, subs[i].nsubs);
250: if (subs[i].nsubs>0)
251: print_array(&subs[i], level+1);
252: }
253: #endif
254: }
255:
256:
257:
258: /* individual routines to find the drive labels.
259: There needs to be a function for every different method for partitioning
260: much of the following code is derived from the SCSI/IDE drivers */
261:
262: int get_dos(struct diskpart *array, char *buff, int start,
263: void *driver_info, int (*bottom_read_fun)(),
264: char *name, int max_part)
265: {
266:
267: bios_label_t *mp;
268: struct bios_partition_info *pp;
269:
270: int count, i, j;
271: int pstart, psize;
272: int ext=-1, mystart=start, mybase;
273: int first=1;
274:
275: /* note: start is added, although a start != 0 is meaningless
276: to DOS and anything else... */
277:
278: /* check the boot sector for a partition table. */
279: (*bottom_read_fun)(driver_info, start, buff); /* always in sector 0 */
280:
281: /*
282: * Check for valid partition table.
283: */
284: mp = (bios_label_t *)&buff[BIOS_LABEL_BYTE_OFFSET];
285: if (mp->magic != BIOS_LABEL_MAGIC) {
286: #if (PARTITION_DEBUG>1)
287: printf("%s invalid partition table\n", name);
288: #endif
289: return(0); /* didn't add any partitions */
290: }
291: #if (PARTITION_DEBUG>1)
292: printf("DOS partition table found\n");
293: #endif
294:
295: count=min(4,max_part); /* always 4 (primary) partitions */
296: #if (PARTITION_DEBUG)
297: if (count<4) printf("More partitions than space!\n");
298: #endif
299:
300:
301: /* fill the next 4 entries in the array */
302: for (i=0, pp=(struct bios_partition_info *)mp->partitions;
303: i<count; i++,pp++) {
304:
305: fill_array(&array[i], pp->offset, pp->n_sectors, NULL, 0,
306: DISKPART_NONE, pp->systid);
307: if ((pp->systid == DOS_EXTENDED) &&(ext<0)) {
308: mystart+=pp->offset;
309: ext=i;
310: }
311: }
312:
313: /* if there is an extended partition, find all the logical partitions */
314: /* note: logical start at '5' (extended is one of the numbered 1-4) */
315:
316: /* logical partitions 'should' be nested inside the primary, but
317: then it would be impossible to NAME a disklabel inside a logical
318: partition, which would be nice to do */
319: #if (PARTITION_DEBUG>1)
320: if (ext>=0)
321: printf("extended partition found: %d\n",ext);
322: #endif 0
323:
324: while (ext>=0) {
325: pp = &(((struct bios_partition_info *)mp->partitions)[ext]);
326:
327: /* read the EXTENDED partition table */
328: if (first) {
329: mybase=mystart;
330: first=0;
331: } else {
332: mybase=mystart+pp->offset;
333: }
334:
335: (*bottom_read_fun)(driver_info, mybase, buff);
336:
337: if (mp->magic != BIOS_LABEL_MAGIC) {
338: #if (PARTITION_DEBUG>1)
339: printf("%s invalid expanded magic\n", name);
340: #endif
341: return(count);/*don't add any more partitions*/
342: }
343:
344: /* just in case more than one partition is there...*/
345: /* search the EXTENDED partition table */
346: ext=-1;
347: for (j=0,pp=(struct bios_partition_info *)mp->partitions;
348: j<4; j++,pp++) {
349:
350: if (pp->systid && (pp->systid!=DOS_EXTENDED)) {
351: if (count<max_part) {
352: fill_array(&array[count],
353: mybase +pp->offset,
354: pp->n_sectors, NULL, 0, DISKPART_NONE,
355: pp->systid);
356: count++; }
357: else {
358: #if (PARTITION_DEBUG)
359: printf("More partitions than space!\n");
360: #endif
361: return(count);
362: }
363: } else if ((ext<0) &&(pp->systid==DOS_EXTENDED)) {
364: ext=j;
365: /* recursivly search the chain here */
366: }
367: }
368: }
369: #if (PARTITION_DEBUG>1)
370: printf("%d dos partitions\n",count);
371: #endif 0
372: return(count); /* number dos partitions found */
373:
374: }
375:
376:
377:
378: /* this should work on the bare drive, or in a dos partition */
379: int get_disklabel(struct diskpart *array, char *buff, int start,
380: void *driver_info, int (*bottom_read_fun)(),
381: char *name, int max_part)
382: {
383: struct disklabel *dlp;
384: int mybase = start + (512 * LBLLOC)/SECTOR_SIZE, i;
385: int count;
386:
387: (*bottom_read_fun)(driver_info, mybase, buff);
388:
389: dlp = (struct disklabel *)buff;
390: if (dlp->d_magic != DISKMAGIC || dlp->d_magic2 != DISKMAGIC) {
391: #if (PARTITION_DEBUG>1)
392: printf("%s no BSD label found\n",name);
393: #endif
394: return(0); /* no partitions added */
395: }
396: #if (PARTITION_DEBUG>1)
397: printf(" BSD LABEL\n");
398: #endif 0
399: /* note: BSD disklabel offsets are from start of DRIVE -- uuggh */
400:
401: count=min(8,max_part); /* always 8 in a disklabel */
402: #if (PARTITION_DEBUG)
403: if (count<8) printf("More partitions than space!\n");
404: #endif
405: /* COPY into the array */
406: for (i=0;i<count;i++)
407: fill_array(&array[i], /* mybase + */
408: dlp->d_partitions[i].p_offset,
409: dlp->d_partitions[i].p_size,
410: NULL, 0, DISKPART_NONE, dlp->d_partitions[i].p_fstype);
411:
412: /* note: p_fstype is not the same set as the DOS types */
413:
414: return(count); /* 'always' 8 partitions in disklabel -- if space */
415:
416: /* UNREACHED CODE FOLLOWS: (alternative method in scsi) */
417: #if 0
418: (*bottom_read_fun)(driver_info, (start)+LABELSECTOR, buff);
419:
420: register int j;
421: boolean_t found;
422:
423: for (j = LABELOFFSET, found = FALSE;
424: j < (SECTOR_SIZE-sizeof(struct disklabel));
425: j += sizeof(int)) {
426: search = (struct disklabel *)&buff[j];
427: if (search->d_magic == DISKMAGIC &&
428: search->d_magic2 == DISKMAGIC) {
429: found = TRUE;
430: break;
431: }
432: }
433: if (found) {
434: #if (PARTITION_DEBUG>1)
435: printf("Label found in LABELSECTOR\n");
436: #endif
437: } else {
438: search = 0;
439: }
440:
441:
442: #endif 0
443:
444: }
445:
446:
447: /* NOT TESTED! */
448: /* VTOC in sector 29 */
449: int get_vtoc(struct diskpart *array, char *buff, int start,
450: void *driver_info, int (*bottom_read_fun)(),
451: char *name, int max_part)
452: {
453: struct evtoc *evp;
454: int n,i;
455: struct disklabel lpl;
456: struct disklabel *lp = &lpl;
457:
458: #if (PARTITION_DEBUG)
459: printf("Read VTOC.\n");
460: #endif
461: (*bottom_read_fun)(driver_info, start +PDLOCATION, buff);
462: evp = (struct evtoc *)buff;
463: if (evp->sanity != VTOC_SANE) {
464: #if (PARTITION_DEBUG)
465: printf("%s evtoc corrupt or not found\n", name);
466: #endif
467: return(0);
468: }
469: n = min(evp->nparts,max_part); /* no longer DISKLABEL limitations... */
470: #if 0
471: n = (evp->nparts > MAXPARTITIONS) ? MAXPARTITIONS : evp->nparts;
472: #endif 0
473:
474: for (i = 0; i < n; i++)
475: fill_array(&array[i], /* mybase + */
476: evp->part[i].p_start,
477: evp->part[i].p_size,
478: NULL, 0, DISKPART_NONE, FS_BSDFFS);
479:
480: return(n); /* (evp->nparts) */
481: }
482:
483:
484: /* NOT TESTED! */
485: int get_omron(struct diskpart *array, char *buff, int start,
486: void *driver_info, int (*bottom_read_fun)(),
487: char *name, int max_part)
488: {
489:
490: struct disklabel *label;
491:
492: /* here look for an Omron label */
493: register omron_label_t *part;
494: int i;
495:
496: #if (PARTITION_DEBUG)
497: printf("Looking for Omron label...\n");
498: #endif
499:
500: (*bottom_read_fun)(driver_info, start+
501: OMRON_LABEL_BYTE_OFFSET/SECTOR_SIZE, buff);
502:
503: part = (omron_label_t*)&buff[OMRON_LABEL_BYTE_OFFSET%SECTOR_SIZE];
504: if (part->magic == OMRON_LABEL_MAGIC) {
505: #if (PARTITION_DEBUG)
506: printf("{Using OMRON label}");
507: #endif
508: for (i = 0; i < 8; i++) {
509: label->d_partitions[i].p_size = part->partitions[i].n_sectors;
510: label->d_partitions[i].p_offset = part->partitions[i].offset;
511: }
512: bcopy(part->packname, label->d_packname, 16);
513: label->d_ncylinders = part->ncyl;
514: label->d_acylinders = part->acyl;
515: label->d_ntracks = part->nhead;
516: label->d_nsectors = part->nsect;
517: /* Many disks have this wrong, therefore.. */
518: #if 0
519: label->d_secperunit = part->maxblk;
520: #else
521: label->d_secperunit = label->d_ncylinders * label->d_ntracks *
522: label->d_nsectors;
523: #endif 0
524:
525: return(8);
526: }
527: #if (PARTITION_DEBUG)
528: printf("No Omron label found.\n");
529: #endif
530: return(0);
531: }
532:
533:
534: /* NOT TESTED! */
535: int get_dec(struct diskpart *array, char *buff, int start,
536: void *driver_info, int (*bottom_read_fun)(),
537: char *name, int max_part)
538: {
539: struct disklabel *label;
540:
541: /* here look for a DEC label */
542: register dec_label_t *part;
543: int i;
544:
545: #if (PARTITION_DEBUG)
546: printf("Checking for dec_label...\n");
547: #endif
548:
549: (*bottom_read_fun)(driver_info, start +
550: DEC_LABEL_BYTE_OFFSET/SECTOR_SIZE, buff);
551:
552: if (part->magic == DEC_LABEL_MAGIC) {
553: #if (PARTITION_DEBUG)
554: printf("{Using DEC label}");
555: #endif
556: for (i = 0; i < 8; i++) {
557: label->d_partitions[i].p_size = part->partitions[i].n_sectors;
558: label->d_partitions[i].p_offset = part->partitions[i].offset;
559: }
560: return(8);
561: }
562: #if (PARTITION_DEBUG)
563: printf("No dec label found.\n");
564: #endif
565:
566: return(0);
567: }
568:
569:
570:
571:
572: /* array is a pointer to an array of partition_info structures */
573: /* array_size is the number of pre-allocated entries there are */
574: int get_only_partition(void *driver_info, int (*bottom_read_fun)(),
575: struct diskpart *array, int array_size,
576: int disk_size, char *drive_name)
577: {
578: char buff[SECTOR_SIZE];
579: int i,n,cnt;
580: int arrsize;
581: struct diskpart *res;
582:
583: /* first fill in the entire disk stuff */
584: /* or should the calling routine do that already? */
585:
586: fill_array(array, 0, disk_size, NULL, 0, -1, -1);
587:
588: /* while the structure does not preclude additional nestings,
589: additional ones make no sense currently, so they are not
590: checked (Mach can't handle them anyway). It might be nice
591: if for all partitions found, all types of sub-partitions
592: were looked for (unnecessary). This will be done when this
593: is moved out of ther kernel, and there is some way to name them */
594:
595: arrsize = array_size -1; /* 1 for whole disk */
596:
597: /* search for dos partition table */
598: /* find all the partitions (including logical) */
599: n=get_dos(&array[1], buff, 0,
600: driver_info, (bottom_read_fun), drive_name,
601: arrsize);
602:
603: if (n>0) {
604: fill_array(array, 0, disk_size, &array[1], n,
605: DISKPART_DOS, 256+DISKPART_DOS);
606: arrsize-=n;
607:
608:
609: /* search each one for a BSD disklabel (iff BSDOS) */
610: /* note: searchine extended and logical partitions */
611: for (i=0;i<n;i++)
612: if (array[i+1].fsys==BSDOS) {
613: #if (PARTITION_DEBUG)
614: printf("BSD OS slice: %d\n",i+1);
615: #endif
616: cnt=get_disklabel(&array[n+1], buff,
617: array[i+1].start,
618: driver_info, (bottom_read_fun),
619: drive_name,arrsize);
620:
621: if (cnt>0) {
622: arrsize-=cnt;
623: fill_array(&array[i+1],array[i+1].start,
624: array[i+1].size, &array[n+1],
625: cnt, DISKPART_BSD,
626: array[i+1].fsys);
627: }
628: n+=cnt;
629: }
630:
631: /* search for VTOC -- in a DOS partition as well */
632: for (i=0;i<n;i++)
633: if (array[i+1].fsys==UNIXOS) {
634: #if (PARTITION_DEBUG)
635: printf("UNIXOS (vtoc) partition\n");
636: #endif
637: cnt=get_vtoc(&array[n+1], buff,
638: array[i+1].start,
639: driver_info, (bottom_read_fun),
640: drive_name,arrsize);
641:
642: if (cnt>0) {
643: arrsize-=cnt;
644: fill_array(&array[i+1],array[i+1].start,
645: array[i+1].size, &array[n+1],
646: cnt, DISKPART_VTOC,
647: array[i+1].fsys);
648: }
649: n+=cnt;
650: }
651: }
652:
653: /* search for only disklabel */
654: if (n==0) {
655: fill_array(array, 0, disk_size, &array[1], n, DISKPART_BSD,
656: 256+DISKPART_BSD);
657: n=get_disklabel(&array[1], buff, 0, driver_info,
658: (bottom_read_fun), drive_name,arrsize);
659: }
660:
661: /* search for only VTOC -- NOT TESTED! */
662: if (n==0) {
663: fill_array(array, 0, disk_size, &array[1], n, DISKPART_VTOC,
664: 256+DISKPART_VTOC);
665: n=get_vtoc(&array[1], buff, 0, driver_info, (bottom_read_fun),
666: drive_name,arrsize);
667: }
668: #if 0
669: /* search for only omron -- NOT TESTED! */
670: if (n==0) {
671: fill_array(array, 0, disk_size, &array[1], n, DISKPART_OMRON,
672: 256+DISKPART_OMRON);
673: n=get_omron(&array[1], buff, 0,driver_info, (bottom_read_fun),
674: drive_name,arrsize);
675: }
676:
677: /* search for only dec -- NOT TESTED! */
678: if (n==0) {
679: fill_array(array, 0, disk_size, &array[1], n, DISKPART_DEC,
680: 256+DISKPART_DEC);
681: n=get_dec(&array[1], buff, 0, driver_info, (bottom_read_fun),
682: drive_name,arrsize);
683: }
684: #endif 0
685:
686: #if (PARTITION_DEBUG) /* print out what we found */
687: print_array(array,0);
688: #endif
689:
690: }
691:
692:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.