![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to newfs.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sbin / newfs|
Return to newfs.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sbin / newfs |
1.1 root 1: /*
2: * Copyright (c) 1983, 1989 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms are permitted provided
6: * that: (1) source distributions retain this entire copyright notice and
7: * comment, and (2) distributions including binaries display the following
8: * acknowledgement: ``This product includes software developed by the
9: * University of California, Berkeley and its contributors'' in the
10: * documentation or other materials provided with the distribution and in
11: * all advertising materials mentioning features or use of this software.
12: * Neither the name of the University nor the names of its contributors may
13: * be used to endorse or promote products derived from this software without
14: * specific prior written permission.
15: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
16: * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
17: * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
18: */
19:
20: #ifndef lint
21: static char sccsid[] = "@(#)newfs.c 6.22.1.1 (Berkeley) 12/18/90";
22: #endif /* not lint */
23:
24: #ifndef lint
25: char copyright[] =
26: "@(#) Copyright (c) 1983, 1989 Regents of the University of California.\n\
27: All rights reserved.\n";
28: #endif /* not lint */
29:
30: /*
31: * newfs: friendly front end to mkfs
32: */
33: #include <sys/param.h>
34: #include <sys/stat.h>
35: #include <ufs/fs.h>
36: #include <ufs/dir.h>
37: #include <sys/ioctl.h>
38: #include <sys/disklabel.h>
39: #include <sys/file.h>
40: #include <sys/mount.h>
41:
42: #include <stdio.h>
43: #include <ctype.h>
44: #include <paths.h>
45:
46: #define COMPAT /* allow non-labeled disks */
47:
48: /*
49: * The following two constants set the default block and fragment sizes.
50: * Both constants must be a power of 2 and meet the following constraints:
51: * MINBSIZE <= DESBLKSIZE <= MAXBSIZE
52: * sectorsize <= DESFRAGSIZE <= DESBLKSIZE
53: * DESBLKSIZE / DESFRAGSIZE <= 8
54: */
55: #define DFL_FRAGSIZE 1024
56: #define DFL_BLKSIZE 8192
57:
58: /*
59: * Cylinder groups may have up to many cylinders. The actual
60: * number used depends upon how much information can be stored
61: * on a single cylinder. The default is to use 16 cylinders
62: * per group.
63: */
64: #define DESCPG 16 /* desired fs_cpg */
65:
66: /*
67: * MINFREE gives the minimum acceptable percentage of file system
68: * blocks which may be free. If the freelist drops below this level
69: * only the superuser may continue to allocate blocks. This may
70: * be set to 0 if no reserve of free blocks is deemed necessary,
71: * however throughput drops by fifty percent if the file system
72: * is run at between 90% and 100% full; thus the default value of
73: * fs_minfree is 10%. With 10% free space, fragmentation is not a
74: * problem, so we choose to optimize for time.
75: */
76: #define MINFREE 10
77: #define DEFAULTOPT FS_OPTTIME
78:
79: /*
80: * ROTDELAY gives the minimum number of milliseconds to initiate
81: * another disk transfer on the same cylinder. It is used in
82: * determining the rotationally optimal layout for disk blocks
83: * within a file; the default of fs_rotdelay is 4ms.
84: */
85: #define ROTDELAY 4
86:
87: /*
88: * MAXCONTIG sets the default for the maximum number of blocks
89: * that may be allocated sequentially. Since UNIX drivers are
90: * not capable of scheduling multi-block transfers, this defaults
91: * to 1 (ie no contiguous blocks are allocated).
92: */
93: #define MAXCONTIG 1
94:
95: /*
96: * MAXBLKPG determines the maximum number of data blocks which are
97: * placed in a single cylinder group. The default is one indirect
98: * block worth of data blocks.
99: */
100: #define MAXBLKPG(bsize) ((bsize) / sizeof(daddr_t))
101:
102: /*
103: * Each file system has a number of inodes statically allocated.
104: * We allocate one inode slot per NFPI fragments, expecting this
105: * to be far more than we will ever need.
106: */
107: #define NFPI 4
108:
109: /*
110: * For each cylinder we keep track of the availability of blocks at different
111: * rotational positions, so that we can lay out the data to be picked
112: * up with minimum rotational latency. NRPOS is the default number of
113: * rotational positions that we distinguish. With NRPOS of 8 the resolution
114: * of our summary information is 2ms for a typical 3600 rpm drive.
115: */
116: #define NRPOS 8 /* number distinct rotational positions */
117:
118:
119: int mfs; /* run as the memory based filesystem */
120: int Nflag; /* run without writing file system */
121: int fssize; /* file system size */
122: int ntracks; /* # tracks/cylinder */
123: int nsectors; /* # sectors/track */
124: int nphyssectors; /* # sectors/track including spares */
125: int secpercyl; /* sectors per cylinder */
126: int trackspares = -1; /* spare sectors per track */
127: int cylspares = -1; /* spare sectors per cylinder */
128: int sectorsize; /* bytes/sector */
129: #ifdef tahoe
130: int realsectorsize; /* bytes/sector in hardware */
131: #endif
132: int rpm; /* revolutions/minute of drive */
133: int interleave; /* hardware sector interleave */
134: int trackskew = -1; /* sector 0 skew, per track */
135: int headswitch; /* head switch time, usec */
136: int trackseek; /* track-to-track seek, usec */
137: int fsize = 0; /* fragment size */
138: int bsize = 0; /* block size */
139: int cpg = DESCPG; /* cylinders/cylinder group */
140: int cpgflg; /* cylinders/cylinder group flag was given */
141: int minfree = MINFREE; /* free space threshold */
142: int opt = DEFAULTOPT; /* optimization preference (space or time) */
143: int density; /* number of bytes per inode */
144: int maxcontig = MAXCONTIG; /* max contiguous blocks to allocate */
145: int rotdelay = ROTDELAY; /* rotational delay between blocks */
146: int maxbpg; /* maximum blocks per file in a cyl group */
147: int nrpos = NRPOS; /* # of distinguished rotational positions */
148: int bbsize = BBSIZE; /* boot block size */
149: int sbsize = SBSIZE; /* superblock size */
150: int mntflags; /* flags to be passed to mount */
151: u_long memleft; /* virtual memory available */
152: caddr_t membase; /* start address of memory based filesystem */
153: #ifdef COMPAT
154: char *disktype;
155: int unlabelled;
156: #endif
157:
158: char device[MAXPATHLEN];
159: char *progname;
160:
161: extern int errno;
162: char *index();
163: char *rindex();
164:
165: main(argc, argv)
166: int argc;
167: char *argv[];
168: {
169: char *cp, *special, *rindex();
170: register struct partition *pp;
171: register struct disklabel *lp;
172: struct disklabel *getdisklabel();
173: struct partition oldpartition;
174: struct mfs_args args;
175: struct stat st;
176: int fsi, fso;
177: register int i;
178: int status;
179: char buf[BUFSIZ];
180:
181: if ((progname = rindex(*argv, '/') + 1) == (char *)1)
182: progname = *argv;
183: if (!strcmp(progname, "mfs")) {
184: Nflag++;
185: mfs++;
186: }
187: argc--, argv++;
188: while (argc > 0 && argv[0][0] == '-') {
189: for (cp = &argv[0][1]; *cp; cp++)
190: switch (*cp) {
191:
192: case 'F':
193: if (!mfs)
194: fatal("-F: unknown flag");
195: if (argc < 1)
196: fatal("-F: mount flags");
197: argc--, argv++;
198: mntflags = atoi(*argv);
199: if (mntflags == 0)
200: fatal("%s: bad mount flags", *argv);
201: goto next;
202:
203: case 'N':
204: Nflag++;
205: break;
206:
207: case 'S':
208: if (argc < 1)
209: fatal("-S: missing sector size");
210: argc--, argv++;
211: sectorsize = atoi(*argv);
212: if (sectorsize <= 0)
213: fatal("%s: bad sector size", *argv);
214: goto next;
215:
216: #ifdef COMPAT
217: case 'T':
218: if (argc < 1)
219: fatal("-T: missing disk type");
220: argc--, argv++;
221: disktype = *argv;
222: goto next;
223: #endif
224:
225: case 'a':
226: if (argc < 1)
227: fatal("-a: missing max contiguous blocks\n");
228: argc--, argv++;
229: maxcontig = atoi(*argv);
230: if (maxcontig <= 0)
231: fatal("%s: bad max contiguous blocks\n",
232: *argv);
233: goto next;
234:
235: case 'b':
236: if (argc < 1)
237: fatal("-b: missing block size");
238: argc--, argv++;
239: bsize = atoi(*argv);
240: if (bsize < MINBSIZE)
241: fatal("%s: bad block size", *argv);
242: goto next;
243:
244: case 'c':
245: if (argc < 1)
246: fatal("-c: missing cylinders/group");
247: argc--, argv++;
248: cpg = atoi(*argv);
249: if (cpg <= 0)
250: fatal("%s: bad cylinders/group", *argv);
251: cpgflg++;
252: goto next;
253:
254: case 'd':
255: if (argc < 1)
256: fatal("-d: missing rotational delay\n");
257: argc--, argv++;
258: rotdelay = atoi(*argv);
259: if (rotdelay < 0)
260: fatal("%s: bad rotational delay\n",
261: *argv);
262: goto next;
263:
264: case 'e':
265: if (argc < 1)
266: fatal("-e: missing blocks pre file in a cyl group\n");
267: argc--, argv++;
268: maxbpg = atoi(*argv);
269: if (maxbpg <= 0)
270: fatal("%s: bad blocks per file in a cyl group\n",
271: *argv);
272: goto next;
273:
274: case 'f':
275: if (argc < 1)
276: fatal("-f: missing frag size");
277: argc--, argv++;
278: fsize = atoi(*argv);
279: if (fsize <= 0)
280: fatal("%s: bad frag size", *argv);
281: goto next;
282:
283: case 'i':
284: if (argc < 1)
285: fatal("-i: missing bytes per inode\n");
286: argc--, argv++;
287: density = atoi(*argv);
288: if (density <= 0)
289: fatal("%s: bad bytes per inode\n",
290: *argv);
291: goto next;
292:
293: case 'k':
294: if (argc < 1)
295: fatal("-k: track skew");
296: argc--, argv++;
297: trackskew = atoi(*argv);
298: if (trackskew < 0)
299: fatal("%s: bad track skew", *argv);
300: goto next;
301:
302: case 'l':
303: if (argc < 1)
304: fatal("-l: interleave");
305: argc--, argv++;
306: interleave = atoi(*argv);
307: if (interleave <= 0)
308: fatal("%s: bad interleave", *argv);
309: goto next;
310:
311: case 'm':
312: if (argc < 1)
313: fatal("-m: missing free space %%\n");
314: argc--, argv++;
315: minfree = atoi(*argv);
316: if (minfree < 0 || minfree > 99)
317: fatal("%s: bad free space %%\n",
318: *argv);
319: goto next;
320:
321: case 'n':
322: if (argc < 1)
323: fatal("-n: missing rotational layout count\n");
324: argc--, argv++;
325: nrpos = atoi(*argv);
326: if (nrpos <= 0)
327: fatal("%s: bad rotational layout count\n",
328: *argv);
329: goto next;
330:
331: case 'o':
332: if (argc < 1)
333: fatal("-o: missing optimization preference");
334: argc--, argv++;
335: if (strcmp(*argv, "space") == 0)
336: opt = FS_OPTSPACE;
337: else if (strcmp(*argv, "time") == 0)
338: opt = FS_OPTTIME;
339: else
340: fatal("%s: bad optimization preference %s",
341: *argv,
342: "(options are `space' or `time')");
343: goto next;
344:
345: case 'p':
346: if (argc < 1)
347: fatal("-p: spare sectors per track");
348: argc--, argv++;
349: trackspares = atoi(*argv);
350: if (trackspares < 0)
351: fatal("%s: bad spare sectors per track", *argv);
352: goto next;
353:
354: case 'r':
355: if (argc < 1)
356: fatal("-r: missing revs/minute\n");
357: argc--, argv++;
358: rpm = atoi(*argv);
359: if (rpm <= 0)
360: fatal("%s: bad revs/minute\n", *argv);
361: goto next;
362:
363: case 's':
364: if (argc < 1)
365: fatal("-s: missing file system size");
366: argc--, argv++;
367: fssize = atoi(*argv);
368: if (fssize <= 0)
369: fatal("%s: bad file system size",
370: *argv);
371: goto next;
372:
373: case 't':
374: if (argc < 1)
375: fatal("-t: missing track total");
376: argc--, argv++;
377: ntracks = atoi(*argv);
378: if (ntracks <= 0)
379: fatal("%s: bad total tracks", *argv);
380: goto next;
381:
382: case 'u':
383: if (argc < 1)
384: fatal("-u: missing sectors/track");
385: argc--, argv++;
386: nsectors = atoi(*argv);
387: if (nsectors <= 0)
388: fatal("%s: bad sectors/track", *argv);
389: goto next;
390:
391: case 'x':
392: if (argc < 1)
393: fatal("-x: spare sectors per cylinder");
394: argc--, argv++;
395: cylspares = atoi(*argv);
396: if (cylspares < 0)
397: fatal("%s: bad spare sectors per cylinder", *argv);
398: goto next;
399:
400: default:
401: fatal("-%c: unknown flag", *cp);
402: }
403: next:
404: argc--, argv++;
405: }
406: if (argc < 1) {
407: if (mfs)
408: fprintf(stderr,
409: "usage: mfs [ fsoptions ] special-device %s\n",
410: "mount-point");
411: else
412: #ifdef COMPAT
413: fprintf(stderr, "usage: %s\n",
414: "newfs [ fsoptions ] special-device [device-type]");
415: #else
416: fprintf(stderr,
417: "usage: newfs [ fsoptions ] special-device\n");
418: #endif
419: fprintf(stderr, "where fsoptions are:\n");
420: fprintf(stderr, "\t-N do not create file system, %s\n",
421: "just print out parameters");
422: #ifdef COMPAT
423: fprintf(stderr, "\t-T disktype\n");
424: #endif
425: fprintf(stderr, "\t-b block size\n");
426: fprintf(stderr, "\t-f frag size\n");
427: fprintf(stderr, "\t-m minimum free space %%\n");
428: fprintf(stderr, "\t-o optimization preference %s\n",
429: "(`space' or `time')");
430: fprintf(stderr, "\t-a maximum contiguous blocks\n");
431: fprintf(stderr, "\t-d rotational delay between %s\n",
432: "contiguous blocks");
433: fprintf(stderr, "\t-e maximum blocks per file in a %s\n",
434: "cylinder group");
435: fprintf(stderr, "\t-i number of bytes per inode\n");
436: fprintf(stderr, "\t-c cylinders/group\n");
437: fprintf(stderr, "\t-n number of distinguished %s\n",
438: "rotational positions");
439: fprintf(stderr, "\t-s file system size (sectors)\n");
440: fprintf(stderr, "\t-r revolutions/minute\n");
441: fprintf(stderr, "\t-S sector size\n");
442: fprintf(stderr, "\t-u sectors/track\n");
443: fprintf(stderr, "\t-t tracks/cylinder\n");
444: fprintf(stderr, "\t-p spare sectors per track\n");
445: fprintf(stderr, "\t-x spare sectors per cylinder\n");
446: fprintf(stderr, "\t-l hardware sector interleave\n");
447: fprintf(stderr, "\t-k sector 0 skew, per track\n");
448: exit(1);
449: }
450: special = argv[0];
451: cp = rindex(special, '/');
452: if (cp != 0)
453: special = cp + 1;
454: if (*special == 'r'
455: #if defined(vax) || defined(tahoe)
456: && special[1] != 'a' && special[1] != 'b'
457: #endif
458: #if defined(hp300)
459: && special[1] != 'd'
460: #endif
461: )
462: special++;
463: (void)sprintf(device, "%s/r%s", _PATH_DEV, special);
464: special = device;
465: if (!Nflag) {
466: fso = open(special, O_WRONLY);
467: if (fso < 0) {
468: perror(special);
469: exit(2);
470: }
471: } else
472: fso = -1;
473: fsi = open(special, O_RDONLY);
474: if (fsi < 0) {
475: perror(special);
476: exit(3);
477: }
478: if (fstat(fsi, &st) < 0) {
479: fprintf(stderr, "%s: ", progname); perror(special);
480: exit(4);
481: }
482: if ((st.st_mode & S_IFMT) != S_IFCHR)
483: fatal("%s: not a character device", special);
484: cp = index(argv[0], '\0') - 1;
485: if (cp == 0 || (*cp < 'a' || *cp > 'h') && !isdigit(*cp))
486: fatal("%s: can't figure out file system partition", argv[0]);
487: #ifdef COMPAT
488: if (!mfs && disktype == NULL)
489: disktype = argv[1];
490: #endif
491: lp = getdisklabel(special, fsi);
492: if (isdigit(*cp))
493: pp = &lp->d_partitions[0];
494: else
495: pp = &lp->d_partitions[*cp - 'a'];
496: if (pp->p_size == 0)
497: fatal("%s: `%c' partition is unavailable", argv[0], *cp);
498: if (fssize == 0)
499: fssize = pp->p_size;
500: if (fssize > pp->p_size && !mfs)
501: fatal("%s: maximum file system size on the `%c' partition is %d",
502: argv[0], *cp, pp->p_size);
503: if (rpm == 0) {
504: rpm = lp->d_rpm;
505: if (rpm <= 0)
506: rpm = 3600;
507: }
508: if (ntracks == 0) {
509: ntracks = lp->d_ntracks;
510: if (ntracks <= 0)
511: fatal("%s: no default #tracks", argv[0]);
512: }
513: if (nsectors == 0) {
514: nsectors = lp->d_nsectors;
515: if (nsectors <= 0)
516: fatal("%s: no default #sectors/track", argv[0]);
517: }
518: if (sectorsize == 0) {
519: sectorsize = lp->d_secsize;
520: if (sectorsize <= 0)
521: fatal("%s: no default sector size", argv[0]);
522: }
523: if (trackskew == -1) {
524: trackskew = lp->d_trackskew;
525: if (trackskew < 0)
526: trackskew = 0;
527: }
528: if (interleave == 0) {
529: interleave = lp->d_interleave;
530: if (interleave <= 0)
531: interleave = 1;
532: }
533: if (fsize == 0) {
534: fsize = pp->p_fsize;
535: if (fsize <= 0)
536: fsize = MAX(DFL_FRAGSIZE, lp->d_secsize);
537: }
538: if (bsize == 0) {
539: bsize = pp->p_frag * pp->p_fsize;
540: if (bsize <= 0)
541: bsize = MIN(DFL_BLKSIZE, 8 * fsize);
542: }
543: if (density == 0)
544: density = NFPI * fsize;
545: if (minfree < 10 && opt != FS_OPTSPACE) {
546: fprintf(stderr, "Warning: changing optimization to space ");
547: fprintf(stderr, "because minfree is less than 10%%\n");
548: opt = FS_OPTSPACE;
549: }
550: if (trackspares == -1) {
551: trackspares = lp->d_sparespertrack;
552: if (trackspares < 0)
553: trackspares = 0;
554: }
555: nphyssectors = nsectors + trackspares;
556: if (cylspares == -1) {
557: cylspares = lp->d_sparespercyl;
558: if (cylspares < 0)
559: cylspares = 0;
560: }
561: secpercyl = nsectors * ntracks - cylspares;
562: if (secpercyl != lp->d_secpercyl)
563: fprintf(stderr, "%s (%d) %s (%d)\n",
564: "Warning: calculated sectors per cylinder", secpercyl,
565: "disagrees with disk label", lp->d_secpercyl);
566: if (maxbpg == 0)
567: maxbpg = MAXBLKPG(bsize);
568: headswitch = lp->d_headswitch;
569: trackseek = lp->d_trkseek;
570: /* Reno fix: label may be 0 if faked up by kernel */
571: #ifdef notdef
572: bbsize = lp->d_bbsize;
573: sbsize = lp->d_sbsize;
574: #endif
575: oldpartition = *pp;
576: #ifdef tahoe
577: realsectorsize = sectorsize;
578: if (sectorsize != DEV_BSIZE) { /* XXX */
579: int secperblk = DEV_BSIZE / sectorsize;
580:
581: sectorsize = DEV_BSIZE;
582: nsectors /= secperblk;
583: nphyssectors /= secperblk;
584: secpercyl /= secperblk;
585: fssize /= secperblk;
586: pp->p_size /= secperblk;
587: }
588: #endif
589: mkfs(pp, special, fsi, fso);
590: #ifdef tahoe
591: if (realsectorsize != DEV_BSIZE)
592: pp->p_size *= DEV_BSIZE / realsectorsize;
593: #endif
594: if (!Nflag && bcmp(pp, &oldpartition, sizeof(oldpartition)))
595: rewritelabel(special, fso, lp);
596: if (!Nflag)
597: close(fso);
598: close(fsi);
599: if (mfs) {
600: sprintf(buf, "mfs:%d", getpid());
601: args.name = buf;
602: args.base = membase;
603: args.size = fssize * sectorsize;
604: if (mount(MOUNT_MFS, argv[1], mntflags, &args) < 0) {
605: perror("mfs: mount");
606: exit(5);
607: }
608: }
609: exit(0);
610: }
611:
612: #ifdef COMPAT
613: char lmsg[] = "%s: can't read disk label; disk type must be specified";
614: #else
615: char lmsg[] = "%s: can't read disk label";
616: #endif
617:
618: struct disklabel *
619: getdisklabel(s, fd)
620: char *s;
621: int fd;
622: {
623: static struct disklabel lab;
624:
625: if (ioctl(fd, DIOCGDINFO, (char *)&lab) < 0) {
626: #ifdef COMPAT
627: if (disktype) {
628: struct disklabel *getdiskbyname();
629:
630: unlabelled++;
631: return (getdiskbyname(disktype));
632: }
633: #endif
634: perror("ioctl (GDINFO)");
635: fatal(lmsg, s);
636: }
637: return (&lab);
638: }
639:
640: rewritelabel(s, fd, lp)
641: char *s;
642: int fd;
643: register struct disklabel *lp;
644: {
645:
646: #ifdef COMPAT
647: if (unlabelled)
648: return;
649: #endif
650: lp->d_checksum = 0;
651: lp->d_checksum = dkcksum(lp);
652: if (ioctl(fd, DIOCWDINFO, (char *)lp) < 0) {
653: perror("ioctl (WDINFO)");
654: fatal("%s: can't rewrite disk label", s);
655: }
656: #if vax
657: if (lp->d_type == DTYPE_SMD && lp->d_flags & D_BADSECT) {
658: register i;
659: int cfd;
660: daddr_t alt;
661: char specname[64];
662: char blk[1024];
663: char *cp;
664:
665: /*
666: * Make name for 'c' partition.
667: */
668: strcpy(specname, s);
669: cp = specname + strlen(specname) - 1;
670: if (!isdigit(*cp))
671: *cp = 'c';
672: cfd = open(specname, O_WRONLY);
673: if (cfd < 0) {
674: perror(specname);
675: exit(6);
676: }
677: bzero(blk, sizeof(blk));
678: *(struct disklabel *)(blk + LABELOFFSET) = *lp;
679: alt = lp->d_ncylinders * lp->d_secpercyl - lp->d_nsectors;
680: for (i = 1; i < 11 && i < lp->d_nsectors; i += 2) {
681: if (lseek(cfd, (off_t)(alt + i) * lp->d_secsize, L_SET) == -1) {
682: perror("lseek to badsector area");
683: exit(7);
684: }
685: if (write(cfd, blk, lp->d_secsize) < lp->d_secsize) {
686: int oerrno = errno;
687: fprintf(stderr, "alternate label %d ", i/2);
688: errno = oerrno;
689: perror("write");
690: }
691: }
692: close(cfd);
693: }
694: #endif
695: }
696:
697: /*VARARGS*/
698: fatal(fmt, arg1, arg2)
699: char *fmt;
700: {
701:
702: fprintf(stderr, "%s: ", progname);
703: fprintf(stderr, fmt, arg1, arg2);
704: putc('\n', stderr);
705: exit(8);
706: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.