2 * Copyright (c) 2011-2012 The DragonFly Project. All rights reserved.
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@dragonflybsd.org>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * 3. Neither the name of The DragonFly Project nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific, prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 #include <sys/types.h>
36 #include <sys/diskslice.h>
37 #include <sys/diskmbr.h>
40 #include <sys/sysctl.h>
41 #include <vfs/hammer2/hammer2_disk.h>
55 #define hammer2_icrc32(buf, size) iscsi_crc32((buf), (size))
56 #define hammer2_icrc32c(buf, size, crc) iscsi_crc32_ext((buf), (size), (crc))
57 uint32_t iscsi_crc32(const void *buf, size_t size);
58 uint32_t iscsi_crc32_ext(const void *buf, size_t size, uint32_t ocrc);
60 static hammer2_off_t check_volume(const char *path, int *fdp);
61 static int64_t getsize(const char *str, int64_t minval, int64_t maxval, int pw);
62 static const char *sizetostr(hammer2_off_t size);
63 static uint64_t nowtime(void);
64 static void usage(void);
66 static void format_hammer2(int fd, hammer2_off_t total_space,
67 hammer2_off_t free_space);
68 static void alloc_direct(hammer2_off_t *basep, hammer2_blockref_t *bref,
70 static hammer2_key_t dirhash(const unsigned char *name, size_t len);
72 static int Hammer2Version = -1;
73 static int ForceOpt = 0;
74 static uuid_t Hammer2_FSType; /* static filesystem type id for HAMMER2 */
75 static uuid_t Hammer2_FSId; /* unique filesystem id in volu header */
76 static uuid_t Hammer2_SPFSId; /* PFS id in super-root inode */
77 static uuid_t Hammer2_RPFSId; /* PFS id in root inode */
78 static const char *Label = "ROOT";
79 static hammer2_off_t BootAreaSize;
80 static hammer2_off_t AuxAreaSize;
82 #define GIG ((hammer2_off_t)1024*1024*1024)
85 main(int ac, char **av)
88 hammer2_off_t total_space;
89 hammer2_off_t free_space;
90 hammer2_off_t reserved_space;
98 * Sanity check basic filesystem structures. No cookies for us
101 assert(sizeof(hammer2_volume_data_t) == HAMMER2_VOLUME_BYTES);
102 assert(sizeof(hammer2_inode_data_t) == HAMMER2_INODE_BYTES);
103 assert(sizeof(hammer2_blockref_t) == HAMMER2_BLOCKREF_BYTES);
106 * Generate a filesystem id and lookup the filesystem type
109 uuidgen(&Hammer2_FSId, 1);
110 uuidgen(&Hammer2_SPFSId, 1);
111 uuidgen(&Hammer2_RPFSId, 1);
112 uuid_from_string(HAMMER2_UUID_STRING, &Hammer2_FSType, &status);
113 /*uuid_name_lookup(&Hammer2_FSType, "DragonFly HAMMER2", &status);*/
114 if (status != uuid_s_ok) {
115 errx(1, "uuids file does not have the DragonFly "
116 "HAMMER filesystem type");
122 while ((ch = getopt(ac, av, "fL:b:m:r:V:")) != -1) {
129 if (strlen(Label) > HAMMER2_INODE_MAXNAME) {
130 errx(1, "Root directory label too long "
135 BootAreaSize = getsize(optarg,
137 HAMMER2_BOOT_MAX_BYTES, 2);
140 AuxAreaSize = getsize(optarg,
142 HAMMER2_REDO_MAX_BYTES, 2);
145 Hammer2Version = strtol(optarg, NULL, 0);
146 if (Hammer2Version < HAMMER2_VOL_VERSION_MIN ||
147 Hammer2Version >= HAMMER2_VOL_VERSION_WIP) {
149 "I don't understand how to format "
150 "HAMMER2 version %d\n",
160 if (Hammer2Version < 0) {
161 size_t olen = sizeof(Hammer2Version);
162 Hammer2Version = HAMMER2_VOL_VERSION_DEFAULT;
163 if (sysctlbyname("vfs.hammer2.supported_version",
164 &Hammer2Version, &olen, NULL, 0) == 0) {
165 if (Hammer2Version >= HAMMER2_VOL_VERSION_WIP) {
166 Hammer2Version = HAMMER2_VOL_VERSION_WIP - 1;
168 "newfs_hammer: WARNING: HAMMER2 VFS "
169 "supports higher version than I "
171 "using version %d\n",
176 "newfs_hammer: WARNING: HAMMER2 VFS not "
177 "loaded, cannot get version info.\n"
178 "Using version %d\n",
179 HAMMER2_VOL_VERSION_DEFAULT);
184 * Collect volume information.
190 fprintf(stderr, "Exactly one disk device must be specified\n");
193 total_space = check_volume(av[0], &fd);
196 * ~typically 8MB alignment to avoid edge cases for reserved blocks
197 * and so raid stripes (if any) operate efficiently.
199 total_space &= ~HAMMER2_VOLUME_ALIGNMASK64;
202 * Calculate defaults for the boot area size and round to the
203 * volume alignment boundary.
205 if (BootAreaSize == 0) {
206 BootAreaSize = HAMMER2_BOOT_NOM_BYTES;
207 while (BootAreaSize > total_space / 20)
209 if (BootAreaSize < HAMMER2_BOOT_MIN_BYTES)
210 BootAreaSize = HAMMER2_BOOT_MIN_BYTES;
211 } else if (BootAreaSize < HAMMER2_BOOT_MIN_BYTES) {
212 BootAreaSize = HAMMER2_BOOT_MIN_BYTES;
214 BootAreaSize = (BootAreaSize + HAMMER2_VOLUME_ALIGNMASK64) &
215 ~HAMMER2_VOLUME_ALIGNMASK64;
218 * Calculate defaults for the redo area size and round to the
219 * volume alignment boundary.
221 if (AuxAreaSize == 0) {
222 AuxAreaSize = HAMMER2_REDO_NOM_BYTES;
223 while (AuxAreaSize > total_space / 20)
225 if (AuxAreaSize < HAMMER2_REDO_MIN_BYTES)
226 AuxAreaSize = HAMMER2_REDO_MIN_BYTES;
227 } else if (AuxAreaSize < HAMMER2_REDO_MIN_BYTES) {
228 AuxAreaSize = HAMMER2_REDO_MIN_BYTES;
230 AuxAreaSize = (AuxAreaSize + HAMMER2_VOLUME_ALIGNMASK64) &
231 ~HAMMER2_VOLUME_ALIGNMASK64;
234 * We'll need to stuff this in the volume header soon.
236 uuid_to_string(&Hammer2_FSId, &fsidstr, &status);
237 uuid_to_string(&Hammer2_SPFSId, &spfsidstr, &status);
238 uuid_to_string(&Hammer2_RPFSId, &rpfsidstr, &status);
241 * Calculate the amount of reserved space. HAMMER2_ZONE_SEG (4MB)
242 * is reserved at the beginning of every 2GB of storage, rounded up.
243 * Thus a 200MB filesystem will still have a 4MB reserve area.
245 * We also include the boot and redo areas in the reserve. The
246 * reserve is used to help 'df' calculate the amount of available
249 reserved_space = ((total_space + HAMMER2_ZONE_MASK64) /
250 HAMMER2_ZONE_BYTES64) * HAMMER2_ZONE_SEG64;
252 free_space = total_space - reserved_space -
253 BootAreaSize - AuxAreaSize;
255 format_hammer2(fd, total_space, free_space);
259 printf("---------------------------------------------\n");
260 printf("total-size: %s (%jd bytes)\n",
261 sizetostr(total_space),
262 (intmax_t)total_space);
263 printf("root-label: %s\n", Label);
264 printf("version: %d\n", Hammer2Version);
265 printf("boot-area-size: %s\n", sizetostr(BootAreaSize));
266 printf("aux-area-size: %s\n", sizetostr(AuxAreaSize));
267 printf("topo-reserved: %s\n", sizetostr(reserved_space));
268 printf("free-space: %s\n", sizetostr(free_space));
269 printf("fsid: %s\n", fsidstr);
270 printf("supr-pfsid: %s\n", spfsidstr);
271 printf("root-pfsid: %s\n", rpfsidstr);
282 "usage: newfs_hammer -L label [-f] [-b bootsize] "
283 "[-r redosize] [-V version] special ...\n"
289 * Convert the size in bytes to a human readable string.
293 sizetostr(hammer2_off_t size)
297 if (size < 1024 / 2) {
298 snprintf(buf, sizeof(buf), "%6.2f", (double)size);
299 } else if (size < 1024 * 1024 / 2) {
300 snprintf(buf, sizeof(buf), "%6.2fKB",
301 (double)size / 1024);
302 } else if (size < 1024 * 1024 * 1024LL / 2) {
303 snprintf(buf, sizeof(buf), "%6.2fMB",
304 (double)size / (1024 * 1024));
305 } else if (size < 1024 * 1024 * 1024LL * 1024LL / 2) {
306 snprintf(buf, sizeof(buf), "%6.2fGB",
307 (double)size / (1024 * 1024 * 1024LL));
309 snprintf(buf, sizeof(buf), "%6.2fTB",
310 (double)size / (1024 * 1024 * 1024LL * 1024LL));
316 * Convert a string to a 64 bit signed integer with various requirements.
319 getsize(const char *str, int64_t minval, int64_t maxval, int powerof2)
324 val = strtoll(str, &ptr, 0);
343 errx(1, "Unknown suffix in number '%s'\n", str);
347 errx(1, "Unknown suffix in number '%s'\n", str);
351 errx(1, "Value too small: %s, min is %s\n",
352 str, sizetostr(minval));
356 errx(1, "Value too large: %s, max is %s\n",
357 str, sizetostr(maxval));
360 if ((powerof2 & 1) && (val ^ (val - 1)) != ((val << 1) - 1)) {
361 errx(1, "Value not power of 2: %s\n", str);
364 if ((powerof2 & 2) && (val & HAMMER2_NEWFS_ALIGNMASK)) {
365 errx(1, "Value not an integral multiple of %dK: %s",
366 HAMMER2_NEWFS_ALIGN / 1024, str);
378 gettimeofday(&tv, NULL);
379 xtime = tv.tv_sec * 1000000LL + tv.tv_usec;
384 * Figure out how big the volume is.
388 check_volume(const char *path, int *fdp)
390 struct partinfo pinfo;
395 * Get basic information about the volume
397 *fdp = open(path, O_RDWR);
399 err(1, "Unable to open %s R+W", path);
400 if (ioctl(*fdp, DIOCGPART, &pinfo) < 0) {
402 * Allow the formatting of regular files as HAMMER2 volumes
404 if (fstat(*fdp, &st) < 0)
405 err(1, "Unable to stat %s", path);
409 * When formatting a block device as a HAMMER2 volume the
410 * sector size must be compatible. HAMMER2 uses 64K
411 * filesystem buffers but logical buffers for direct I/O
412 * can be as small as HAMMER2_LOGSIZE (16KB).
414 if (pinfo.reserved_blocks) {
415 errx(1, "HAMMER cannot be placed in a partition "
416 "which overlaps the disklabel or MBR");
418 if (pinfo.media_blksize > HAMMER2_PBUFSIZE ||
419 HAMMER2_PBUFSIZE % pinfo.media_blksize) {
420 errx(1, "A media sector size of %d is not supported",
421 pinfo.media_blksize);
423 size = pinfo.media_size;
425 printf("Volume %-15s size %s\n", path, sizetostr(size));
430 * Create the volume header, the super-root directory inode, and
431 * the writable snapshot subdirectory (named via the label) which
432 * is to be the initial mount point, or at least the first mount point.
434 * [----reserved_area----][boot_area][aux_area]
435 * [[vol_hdr]... ] [sroot][root]
437 * The sroot and root inodes eat 512 bytes each. newfs labels can only be
438 * 64 bytes so the root (snapshot) inode does not need to extend past 512
439 * bytes. We use the correct hash slot correct but note that because
440 * directory hashes are chained 16x, any slot in the inode will work.
442 * Also format the allocation map.
444 * NOTE: The passed total_space is 8MB-aligned to avoid edge cases.
448 format_hammer2(int fd, hammer2_off_t total_space, hammer2_off_t free_space)
450 char *buf = malloc(HAMMER2_PBUFSIZE);
451 hammer2_volume_data_t *vol;
452 hammer2_inode_data_t *rawip;
453 hammer2_blockref_t sroot_blockref;
454 hammer2_blockref_t root_blockref;
456 hammer2_off_t volu_base = 0;
457 hammer2_off_t boot_base = HAMMER2_ZONE_SEG;
458 hammer2_off_t aux_base = boot_base + BootAreaSize;
459 hammer2_off_t alloc_base = aux_base + AuxAreaSize;
460 hammer2_off_t tmp_base;
465 * Clear the entire reserve for the first 2G segment and
466 * make sure we can write to the last block.
468 bzero(buf, HAMMER2_PBUFSIZE);
469 tmp_base = volu_base;
470 for (i = 0; i < HAMMER2_ZONE_BLOCKS_SEG; ++i) {
471 n = pwrite(fd, buf, HAMMER2_PBUFSIZE, tmp_base);
472 if (n != HAMMER2_PBUFSIZE) {
476 tmp_base += HAMMER2_PBUFSIZE;
479 n = pwrite(fd, buf, HAMMER2_PBUFSIZE,
480 volu_base + total_space - HAMMER2_PBUFSIZE);
481 if (n != HAMMER2_PBUFSIZE) {
482 perror("write (at-end-of-volume)");
487 * Make sure alloc_base won't cross the reserved area at the
488 * beginning of each 2GB zone.
490 * Reserve space for the super-root inode and the root inode.
491 * Make sure they are in the same 64K block to simplify our code.
493 assert((alloc_base & HAMMER2_PBUFMASK) == 0);
494 assert(alloc_base < HAMMER2_ZONE_BYTES64 - HAMMER2_ZONE_SEG);
496 alloc_base &= ~HAMMER2_PBUFMASK64;
497 alloc_direct(&alloc_base, &sroot_blockref, HAMMER2_INODE_BYTES);
498 alloc_direct(&alloc_base, &root_blockref, HAMMER2_INODE_BYTES);
499 assert(((sroot_blockref.data_off ^ root_blockref.data_off) &
500 HAMMER2_OFF_MASK_HI) == 0);
502 bzero(buf, HAMMER2_PBUFSIZE);
506 * Format the root directory inode, which is left empty.
508 rawip = (void *)(buf + (HAMMER2_OFF_MASK_LO & root_blockref.data_off));
509 rawip->version = HAMMER2_INODE_VERSION_ONE;
512 /* rawip->atime = now; NOT IMPL MUST BE ZERO */
514 rawip->type = HAMMER2_OBJTYPE_DIRECTORY;
516 rawip->inum = 1; /* root inode, inumber 1 */
517 rawip->nlinks = 1; /* directory link count compat */
519 rawip->name_len = strlen(Label);
520 bcopy(Label, rawip->filename, rawip->name_len);
521 rawip->name_key = dirhash(rawip->filename, rawip->name_len);
524 * Compression mode and supported copyids.
526 * Do not allow compression when creating a "boot" label
527 * (pfs-create also does the same if the pfs is named "boot")
529 if (strcmp(Label, "boot") == 0)
530 rawip->comp_algo = HAMMER2_COMP_AUTOZERO;
532 rawip->comp_algo = HAMMER2_COMP_NEWFS_DEFAULT;
534 rawip->pfs_clid = Hammer2_RPFSId;
535 rawip->pfs_type = HAMMER2_PFSTYPE_MASTER;
536 rawip->op_flags |= HAMMER2_OPFLAG_PFSROOT;
538 /* rawip->u.blockset is left empty */
541 * The root blockref will be stored in the super-root inode as
542 * the only directory entry. The copyid here is the actual copyid
543 * of the storage ref.
545 * The key field for a directory entry's blockref is essentially
546 * the name key for the entry.
548 root_blockref.key = rawip->name_key;
549 root_blockref.copyid = HAMMER2_COPYID_LOCAL;
550 root_blockref.keybits = 0;
551 root_blockref.check.iscsi32.value =
552 hammer2_icrc32(rawip, sizeof(*rawip));
553 root_blockref.type = HAMMER2_BREF_TYPE_INODE;
554 root_blockref.methods = HAMMER2_ENC_CHECK(HAMMER2_CHECK_ISCSI32) |
555 HAMMER2_ENC_COMP(HAMMER2_COMP_NONE);
558 * Format the super-root directory inode, giving it one directory
559 * entry (root_blockref) and fixup the icrc method.
561 * The superroot contains one directory entry pointing at the root
562 * inode (named via the label). Inodes contain one blockset which
563 * is fully associative so we can put the entry anywhere without
564 * having to worry about the hash. Use index 0.
566 rawip = (void *)(buf + (HAMMER2_OFF_MASK_LO & sroot_blockref.data_off));
567 rawip->version = HAMMER2_INODE_VERSION_ONE;
570 /* rawip->atime = now; NOT IMPL MUST BE ZERO */
572 rawip->type = HAMMER2_OBJTYPE_DIRECTORY;
573 rawip->mode = 0700; /* super-root - root only */
574 rawip->inum = 0; /* super root inode, inumber 0 */
575 rawip->nlinks = 2; /* directory link count compat */
577 rawip->name_len = 0; /* super-root is unnamed */
580 rawip->comp_algo = HAMMER2_COMP_AUTOZERO;
583 * The super-root is flagged as a PFS and typically given its own
584 * random FSID, making it possible to mirror an entire HAMMER2 disk
585 * snapshots and all if desired. PFS ids are used to match up
586 * mirror sources and targets and cluster copy sources and targets.
588 rawip->pfs_clid = Hammer2_SPFSId;
589 rawip->pfs_type = HAMMER2_PFSTYPE_MASTER;
590 rawip->op_flags |= HAMMER2_OPFLAG_PFSROOT;
593 * The super-root has one directory entry pointing at the named
596 rawip->u.blockset.blockref[0] = root_blockref;
599 * The sroot blockref will be stored in the volume header.
601 sroot_blockref.copyid = HAMMER2_COPYID_LOCAL;
602 sroot_blockref.keybits = 0;
603 sroot_blockref.check.iscsi32.value =
604 hammer2_icrc32(rawip, sizeof(*rawip));
605 sroot_blockref.type = HAMMER2_BREF_TYPE_INODE;
606 sroot_blockref.methods = HAMMER2_ENC_CHECK(HAMMER2_CHECK_ISCSI32) |
607 HAMMER2_ENC_COMP(HAMMER2_COMP_AUTOZERO);
611 * Write out the 64K HAMMER2 block containing the root and sroot.
613 n = pwrite(fd, buf, HAMMER2_PBUFSIZE,
614 root_blockref.data_off & HAMMER2_OFF_MASK_HI);
615 if (n != HAMMER2_PBUFSIZE) {
621 * Format the volume header.
623 * The volume header points to sroot_blockref. Also be absolutely
624 * sure that allocator_beg is set.
626 bzero(buf, HAMMER2_PBUFSIZE);
629 vol->magic = HAMMER2_VOLUME_ID_HBO;
630 vol->boot_beg = boot_base;
631 vol->boot_end = boot_base + BootAreaSize;
632 vol->aux_beg = aux_base;
633 vol->aux_end = aux_base + AuxAreaSize;
634 vol->volu_size = total_space;
635 vol->version = Hammer2Version;
638 vol->fsid = Hammer2_FSId;
639 vol->fstype = Hammer2_FSType;
641 vol->peer_type = HAMMER2_PEER_HAMMER2; /* LNK_CONN identification */
643 vol->allocator_size = free_space;
644 vol->allocator_free = free_space;
645 vol->allocator_beg = alloc_base;
647 vol->sroot_blockset.blockref[0] = sroot_blockref;
649 vol->alloc_tid = 16; /* first transaction id */
650 vol->inode_tid = 16; /* first allocatable inode number */
651 vol->icrc_sects[HAMMER2_VOL_ICRC_SECT1] =
652 hammer2_icrc32((char *)vol + HAMMER2_VOLUME_ICRC1_OFF,
653 HAMMER2_VOLUME_ICRC1_SIZE);
656 * Set ICRC_SECT0 after all remaining elements of sect0 have been
657 * populated in the volume header. Note hat ICRC_SECT* (except for
658 * SECT0) are part of sect0.
660 vol->icrc_sects[HAMMER2_VOL_ICRC_SECT0] =
661 hammer2_icrc32((char *)vol + HAMMER2_VOLUME_ICRC0_OFF,
662 HAMMER2_VOLUME_ICRC0_SIZE);
663 vol->icrc_volheader =
664 hammer2_icrc32((char *)vol + HAMMER2_VOLUME_ICRCVH_OFF,
665 HAMMER2_VOLUME_ICRCVH_SIZE);
668 * Write the volume header and all alternates.
670 for (i = 0; i < HAMMER2_NUM_VOLHDRS; ++i) {
671 if (i * HAMMER2_ZONE_BYTES64 >= total_space)
673 n = pwrite(fd, buf, HAMMER2_PBUFSIZE,
674 volu_base + i * HAMMER2_ZONE_BYTES64);
675 if (n != HAMMER2_PBUFSIZE) {
688 alloc_direct(hammer2_off_t *basep, hammer2_blockref_t *bref, size_t bytes)
694 while ((bytes & 1) == 0) {
699 if (radix < HAMMER2_MIN_RADIX)
700 radix = HAMMER2_MIN_RADIX;
702 bzero(bref, sizeof(*bref));
703 bref->data_off = *basep | radix;
704 bref->vradix = radix;
706 *basep += 1U << radix;
710 * Borrow HAMMER1's directory hash algorithm #1 with a few modifications.
711 * The filename is split into fields which are hashed separately and then
714 * Differences include: bit 63 must be set to 1 for HAMMER2 (HAMMER1 sets
715 * it to 0), this is because bit63=0 is used for hidden hardlinked inodes.
716 * (This means we do not need to do a 0-check/or-with-0x100000000 either).
718 * Also, the iscsi crc code is used instead of the old crc32 code.
721 dirhash(const unsigned char *name, size_t len)
723 const unsigned char *aname = name;
730 * Filesystem version 6 or better will create directories
731 * using the ALG1 dirhash. This hash breaks the filename
732 * up into domains separated by special characters and
733 * hashes each domain independently.
735 * We also do a simple sub-sort using the first character
736 * of the filename in the top 5-bits.
744 for (i = j = 0; i < len; ++i) {
745 if (aname[i] == '.' ||
750 crcx += hammer2_icrc32(aname + j, i - j);
755 crcx += hammer2_icrc32(aname + j, i - j);
758 * The directory hash utilizes the top 32 bits of the 64-bit key.
759 * Bit 63 must be set to 1.
762 key |= (uint64_t)crcx << 32;
765 * l16 - crc of entire filename
767 * This crc reduces degenerate hash collision conditions
769 crcx = hammer2_icrc32(aname, len);
770 crcx = crcx ^ (crcx << 16);
771 key |= crcx & 0xFFFF0000U;
774 * Set bit 15. This allows readdir to strip bit 63 so a positive
775 * 64-bit cookie/offset can always be returned, and still guarantee
776 * that the values 0x0000-0x7FFF are available for artificial entries.