int pflnet_getifaddr(const struct ifaddrs *ifa0, const char *ifname, union pfl_sockaddr *sa) { const struct ifaddrs *ifa; struct ifreq ifr; int rc, s; if (ifa0) { for (ifa = ifa0; ifa; ifa = ifa->ifa_next) if (strcmp(ifa->ifa_name, ifname) == 0 && ifa->ifa_addr->sa_family == AF_INET) { memcpy(&sa->sa, ifa->ifa_addr, sizeof(sa->sin)); return (1); } } else { psc_fatalx("broke"); strlcpy(ifr.ifr_name, ifname, sizeof(ifr.ifr_name)); s = socket(AF_INET, SOCK_DGRAM, 0); if (s == -1) psc_fatal("socket"); rc = ioctl(s, SIOCGIFADDR, &ifr); if (rc == -1) psc_fatal("ioctl SIOCGIFNAME"); close(s); // memcpy(sap, ifr.ifr_addr, ); } return (0); }
int main(int argc, char *argv[]) { struct thr *t, *threads; int rc, c, j; long l; pfl_init(); while ((c = getopt(argc, argv, "i:n:")) != -1) switch (c) { case 'i': l = strtol(optarg, NULL, 10); if (l < 0 || l > INT_MAX) errx(1, "invalid iterations: %s", optarg); iterations = (int)l; break; case 'n': l = strtol(optarg, NULL, 10); if (l < 0 || l > INT_MAX) errx(1, "invalid nthreads: %s", optarg); nthreads = (int)l; break; default: usage(); } argc -= optind; if (argc) usage(); if ((threads = calloc(nthreads, sizeof(*threads))) == NULL) err(1, "calloc"); pfl_multiwaitcond_init(&mastermlc, NULL, 0, "master"); for (j = 0, t = threads; j < nthreads; j++, t++) { pfl_multiwaitcond_init(&t->t_mlc, NULL, 0, "cond%d", j); pfl_multiwait_init(&t->t_ml, "ml%d", j); rc = pfl_multiwait_addcond(&t->t_ml, &mastermlc); if (rc) psc_fatal("addcond"); rc = pfl_multiwait_addcond(&t->t_ml, &t->t_mlc); if (rc) psc_fatal("addcond"); rc = pthread_create(&t->t_pthread, NULL, thr_main, t); if (rc) errx(1, "pthread_create: %s", strerror(rc)); sched_yield(); } for (j = 0; j < iterations; j++) { pfl_multiwaitcond_wakeup(&mastermlc); usleep(100); } exit(0); }
int zfsslash2_init(void) { struct pscfs_args args = PSCFS_ARGS_INIT(0, NULL); extern struct fuse_lowlevel_ops pscfs_fuse_ops; extern struct fuse_session *fuse_session; extern struct pollfd pflfs_fds[]; extern int newfs_fd[2], pflfs_nfds; extern char *fuse_mount_options; int rc; if (pfl_systemf("umount %s", _PATH_KSTAT) == -1) psclog_warn("umount %s", _PATH_KSTAT); if (pipe(newfs_fd) == -1) psc_fatal("pipe"); pflfs_fds[0].fd = newfs_fd[0]; pflfs_fds[0].events = POLLIN; pflfs_nfds = 1; fuse_session = fuse_lowlevel_new(&args.pfa_av, &pscfs_fuse_ops, sizeof(pscfs_fuse_ops), NULL); pscthr_init(SLMTHRT_ZFS_KSTAT, slmzfskstatmthr_main, 0, "slmzfskstatmthr"); fuse_mount_options = ""; rc = libzfs_init_fusesocket(); if (rc == 0) rc = libzfs_init(); atexit(slm_unmount_kstat); return (rc); }
/** * pflnet_getifnfordst - Obtain an interface name (e.g. eth0) for the * given destination address. * @ifa0: base of ifaddrs list to directly compare for localhost. * @sa: destination address. * @ifn: value-result interface name to fill in. */ void pflnet_getifnfordst(const struct ifaddrs *ifa0, const struct sockaddr *sa, char ifn[IFNAMSIZ]) { const struct sockaddr_in *sin; const struct ifaddrs *ifa; psc_assert(sa->sa_family == AF_INET); sin = (void *)sa; /* * Scan interfaces for addr since netlink * will always give us the lo interface. */ for (ifa = ifa0; ifa; ifa = ifa->ifa_next) if (ifa->ifa_addr->sa_family == sa->sa_family && memcmp(&sin->sin_addr, &((struct sockaddr_in *)ifa->ifa_addr)->sin_addr, sizeof(sin->sin_addr)) == 0) { strlcpy(ifn, ifa->ifa_name, IFNAMSIZ); return; } #ifdef HAVE_RTNETLINK pflnet_getifnfordst_rtnetlink(sa, ifn); #elif defined(RTM_GET) pflnet_getifnfordst_rtsock(sa, ifn); #else errno = ENOTSUP; psc_fatal("getifnfordst"); #endif }
__static int pflnet_rtexists_sysctl(const struct sockaddr *sa) { union { struct rt_msghdr *rtm; char *ch; void *p; } u; union pfl_sockaddr_ptr s, os; int rc = 0, mib[6]; char *buf = NULL; size_t len; os.cp = sa; mib[0] = CTL_NET; mib[1] = PF_ROUTE; mib[2] = 0; /* protocol */ mib[3] = AF_INET; mib[4] = NET_RT_DUMP; mib[5] = 0; /* no flags */ if (sysctl(mib, nitems(mib), NULL, &len, NULL, 0) == -1) psc_fatal("route-sysctl-estimate"); if (len) { buf = PSCALLOC(len); if (sysctl(mib, nitems(mib), buf, &len, NULL, 0) == -1) psc_fatal("actual retrieval of routing table"); } for (u.p = buf; u.ch && u.ch < buf + len; u.ch += u.rtm->rtm_msglen) { if (u.rtm->rtm_version != RTM_VERSION) continue; s.p = u.rtm + 1; if (s.s->sin.sin_addr.s_addr == os.s->sin.sin_addr.s_addr) { rc = 1; break; } } PSCFREE(buf); return (rc); }
__static void pflnet_getifname(int ifidx, char ifn[IFNAMSIZ]) { struct ifreq ifr; int rc, s; ifr.ifr_ifindex = ifidx; s = socket(AF_INET, SOCK_DGRAM, 0); if (s == -1) psc_fatal("socket"); rc = ioctl(s, SIOCGIFNAME, &ifr); if (rc == -1) psc_fatal("ioctl SIOCGIFNAME"); close(s); strlcpy(ifn, ifr.ifr_name, IFNAMSIZ); }
/** * pflnet_getifaddrs - Acquire list of network interface addresses. * @ifap: value-result base of addresses array, must be when finished. */ int pflnet_getifaddrs(struct ifaddrs **ifap) { #ifdef HAVE_GETIFADDRS return (getifaddrs(ifap)); #else int nifs, rc, s, n; struct ifconf ifc; struct ifreq *ifr; s = socket(AF_INET, SOCK_DGRAM, 0); if (s == -1) psc_fatal("socket"); ifc.ifc_buf = NULL; rc = ioctl(s, SIOCGIFCONF, &ifc); if (rc == -1) psc_fatal("ioctl SIOCGIFCONF"); /* * If an interface is being added while we are fetching, * there is no way to determine that we didn't get them * all with this API. */ ifc.ifc_buf = PSCALLOC(ifc.ifc_len); rc = ioctl(s, SIOCGIFCONF, &ifc); if (rc == -1) psc_fatal("ioctl SIOCGIFCONF"); close(s); nifs = ifc.ifc_len / sizeof(*ifr); *ifap = PSCALLOC(sizeof(**ifap) * nifs); ifr = (void *)ifc.ifc_buf; for (n = 0; n < nifs; n+++, ifr++) memcpy(*ifap + n, &ifr->ifr_addr, sizeof(**ifap)); #endif return (0); }
int zfsslash2_init(void) { struct pscfs_args args = PSCFS_ARGS_INIT(0, NULL); extern struct fuse_lowlevel_ops pscfs_fuse_ops; extern struct fuse_session *fuse_session; extern struct pollfd pscfs_fds[]; extern int newfs_fd[2], pscfs_nfds; extern char *fuse_mount_options; char buf[BUFSIZ]; int rc; rc = snprintf(buf, sizeof(buf), "umount %s", _PATH_KSTAT); if (rc == -1) psc_fatal("snprintf: umount %s", _PATH_KSTAT); if (rc >= (int)sizeof(buf)) psc_fatalx("snprintf: umount %s: too long", _PATH_KSTAT); if (system(buf) == -1) psclog_warn("system(%s)", buf); if (pipe(newfs_fd) == -1) psc_fatal("pipe"); pscfs_fds[0].fd = newfs_fd[0]; pscfs_fds[0].events = POLLIN; pscfs_nfds = 1; fuse_session = fuse_lowlevel_new(&args.pfa_av, &pscfs_fuse_ops, sizeof(pscfs_fuse_ops), NULL); pscthr_init(SLMTHRT_ZFS_KSTAT, slmzfskstatmthr_main, NULL, 0, "slmzfskstatmthr"); fuse_mount_options = ""; rc = libzfs_init_fusesocket(); if (rc == 0) rc = libzfs_init(); atexit(slm_unmount_kstat); return (rc); }
void slm_unmount_kstat(void) { char buf[BUFSIZ]; int rc; rc = snprintf(buf, sizeof(buf), "umount %s", _PATH_KSTAT); if (rc == -1) psc_fatal("snprintf: umount %s", _PATH_KSTAT); if (rc >= (int)sizeof(buf)) psc_fatalx("snprintf: umount %s: too long", _PATH_KSTAT); if (system(buf) == -1) psclog_warn("system(%s)", buf); }
int pflnet_rtexists(const struct sockaddr *sa) { int rc; #ifdef HAVE_RTNETLINK rc = pflnet_rtexists_rtnetlink(sa); #elif HAVE_RT_SYSCTL rc = pflnet_rtexists_sysctl(sa); #else (void)sa; errno = ENOTSUP; psc_fatal("rtexists"); #endif return (rc); }
void pfl_opstats_grad_init(struct pfl_opstats_grad *og, int flags, int64_t *buckets, int nbuckets, const char *fmt, ...) { const char *lower_suffix = "", *upper_suffix = ""; int64_t lower_bound, upper_bound; struct pfl_opstat_bucket *ob; char label[16]; int rc, i; og->og_buckets = PSCALLOC(nbuckets * sizeof(og->og_buckets[0])); og->og_nbuckets = nbuckets; for (i = 0, ob = og->og_buckets; i < nbuckets; i++, ob++) { if (i) pfl_assert(buckets[i - 1] < buckets[i]); else pfl_assert(buckets[i] == 0); lower_bound = buckets[i]; if (!(flags & OPSTF_BASE10)) lower_suffix = _pfl_opstats_base2_suffix( &lower_bound); if (i == nbuckets - 1) { rc = snprintf(label, sizeof(label), "%d:>=%"PRId64"%.1s", i, lower_bound, lower_suffix); } else { upper_bound = buckets[i + 1]; if (!(flags & OPSTF_BASE10)) upper_suffix = _pfl_opstats_base2_suffix( &upper_bound); rc = snprintf(label, sizeof(label), "%d:%"PRId64"%.1s-<%"PRId64"%.1s", i, lower_bound, lower_suffix, upper_bound, upper_suffix); } if (rc == -1) psc_fatal("snprintf"); ob->ob_lower_bound = buckets[i]; ob->ob_opst = pfl_opstat_initf(flags | OPSTF_BASE10, fmt, label); } }
void unmount(const char *mp) { char buf[BUFSIZ]; int rc; /* XXX do not let this hang */ rc = snprintf(buf, sizeof(buf), "umount '%s' || umount -f '%s' || umount -l '%s'", mp, mp, mp); if (rc == -1) psc_fatal("snprintf: umount %s", mp); if ((size_t)rc >= sizeof(buf)) psc_fatalx("snprintf: umount %s: too long", mp); if (system(buf) == -1) psclog_warn("system(%s)", buf); }
/** * rsx_bulkclient - Setup a source or sink for a client. * @type: GET_SOURCE lets server to pull our buffer, * PUT_SINK sets up a buffer filled in by the server * @rq: RPC request. * @descp: pointer to bulk xfer descriptor. * @ptl: portal to issue bulk xfer across. * @iov: iovec array of receive buffer. * @n: #iovecs. * Returns: 0 or negative errno on error. */ int rsx_bulkclient(struct pscrpc_request *rq, int type, int ptl, struct iovec *iov, int n) { struct pscrpc_bulk_desc *desc; int i; psc_assert(type == BULK_GET_SOURCE || type == BULK_PUT_SINK); desc = pscrpc_prep_bulk_imp(rq, n, type, ptl); if (desc == NULL) psc_fatal("NULL bulk descriptor"); desc->bd_nob = 0; desc->bd_iov_count = n; memcpy(desc->bd_iov, iov, n * sizeof(*iov)); for (i = 0; i < n; i++) desc->bd_nob += iov[i].iov_len; return (0); }
int wipefs_fidns(FTSENT *f, __unusedx void *arg) { int rc = 0, skiplevel = ion ? 7 : 6; const char *fn; fn = f->fts_path; if (f->fts_level < 1) return (0); if (f->fts_info == FTS_D || f->fts_info == FTS_DP) { if (f->fts_info == FTS_DP && rmdir(fn) == -1) psc_fatal("rmdir %s", fn); /* * Do not descend into hardlinked directories. * * MDS: * 0 -> dir * 1 -> dir/.slmd * 2 -> dir/.slmd/fidns * 3 -> dir/.slmd/fidns/0 * 4 -> dir/.slmd/fidns/0/1 * 5 -> dir/.slmd/fidns/0/1/2 * 6 -> dir/.slmd/fidns/0/1/2/3 * 7 -> dir/.slmd/fidns/0/1/2/3/file * * IO: * 0 -> dir * 1 -> dir/.slmd * 2 -> dir/.slmd/fsuuid * 3 -> dir/.slmd/fsuuid/fidns * 4 -> dir/.slmd/fsuuid/fidns/0 * 5 -> dir/.slmd/fsuuid/fidns/0/1 * 6 -> dir/.slmd/fsuuid/fidns/0/1/2 * 7 -> dir/.slmd/fsuuid/fidns/0/1/2/3 * 8 -> dir/.slmd/fsuuid/fidns/0/1/2/3/file */ else if (f->fts_level > skiplevel) pfl_fts_set(f, FTS_SKIP); } else if (unlink(fn) == -1) psclog_error("unlink %s", fn); return (rc); }
/* * Register a list cache for external access. * @plc: the list cache to register. * @name: printf(3) format of name for list. * @ap: variable argument list for printf(3) name argument. */ void lc_vregister(struct psc_listcache *plc, const char *name, va_list ap) { int rc; PLL_LOCK(&psc_listcaches); LIST_CACHE_LOCK(plc); rc = vsnprintf(plc->plc_name, sizeof(plc->plc_name), name, ap); if (rc == -1) psc_fatal("vsnprintf"); if (rc > (int)sizeof(plc->plc_name)) psc_fatalx("plc_name is too large (%s)", name); plc->plc_nseen = pfl_opstat_initf(OPSTF_BASE10, "listcache.%s.adds", plc->plc_name); plc->plc_st_removes = pfl_opstat_initf(OPSTF_BASE10, "listcache.%s.removes", plc->plc_name); pll_add_sorted(&psc_listcaches, plc, lc_cmp); LIST_CACHE_ULOCK(plc); PLL_ULOCK(&psc_listcaches); }
int wipefs_user(FTSENT *f, __unusedx void *arg) { const char *p, *fn; int rc = 0; fn = f->fts_path; if (f->fts_level < 1) return (0); if (f->fts_info == FTS_D || f->fts_info == FTS_DP) { /* skip SLASH2 internal metadata */ p = strrchr(fn, '/'); if (p) p++; else p = fn; if (strcmp(p, SL_RPATH_META_DIR) == 0) pfl_fts_set(f, FTS_SKIP); else if (f->fts_info == FTS_DP && rmdir(fn) == -1) psc_fatal("rmdir %s", fn); } else if (unlink(fn) == -1) psclog_error("unlink %s", fn); return (rc); }
int main(int argc, char *argv[]) { struct timeval tm0, tm1, tmd, tm_total, tm_last; struct stat stb; char buf[BUFSIZ]; uint64_t crc; const char *fn; int fd, pad; size_t acsz; ssize_t rc; progname = argv[0]; if (getopt(argc, argv, "") != -1) usage(); argc -= optind; argv += optind; if (argc != 1) usage(); fn = argv[0]; fd = open(fn, O_RDONLY); if (fd == -1) psc_fatal("%s", fn); if (fstat(fd, &stb) == -1) psc_fatal("fstat %s", fn); pad = snprintf(NULL, 0, "%"PSCPRIdOFFT, stb.st_size); acsz = 0; psc_crc64_init(&crc); memset(&tm_total, 0, sizeof(tm_total)); memset(&tm_last, 0, sizeof(tm_last)); for (;;) { rc = read(fd, buf, sizeof(buf)); if (rc == -1) psc_fatal("read %s", fn); if (rc == 0) break; acsz += rc; PFL_GETTIMEVAL(&tm0); psc_crc64_add(&crc, buf, rc); PFL_GETTIMEVAL(&tm1); timersub(&tm1, &tm0, &tmd); memcpy(&tm0, &tm_total, sizeof(tm0)); timeradd(&tmd, &tm0, &tm_total); timersub(&tm1, &tm_last, &tmd); if (tmd.tv_usec > 1000000 / 32) { /* 32 fps */ memcpy(&tm_last, &tm1, sizeof(tm_last)); printf("\r%*zd/%"PSCPRIdOFFT, pad, acsz, stb.st_size); fflush(stdout); } } close(fd); psc_crc64_fini(&crc); printf("\rcrc %"PSCPRIxCRC64" size %"PSCPRIdOFFT" time %.3fs\n", crc, stb.st_size, tm_total.tv_sec + tm_total.tv_usec * 1e-6); exit(0); }
int main(int argc, char *argv[]) { struct psc_vbitmap *vb, vba = VBITMAP_INIT_AUTO; int i, c, u, t; size_t elem, j; pfl_init(); progname = argv[0]; while ((c = getopt(argc, argv, "")) != -1) switch (c) { default: usage(); } argc -= optind; if (argc) usage(); for (i = 0; i < 79; i++) if (psc_vbitmap_next(&vba, &j) != 1) psc_fatalx("psc_vbitmap_next failed with auto"); else if (j != (size_t)i) psc_fatalx("elem %d is not supposed to be %zu", i, j); if ((vb = psc_vbitmap_new(213)) == NULL) psc_fatal("psc_vbitmap_new"); psc_vbitmap_setrange(vb, 13, 9); psc_vbitmap_printbin1(vb); for (i = 0; i < 13; i++) psc_assert(psc_vbitmap_get(vb, i) == 0); for (j = 0; j < 9; j++, i++) psc_assert(psc_vbitmap_get(vb, i) == 1); for (j = 0; j < 25; j++, i++) psc_assert(psc_vbitmap_get(vb, i) == 0); psc_vbitmap_clearall(vb); for (i = 0; i < 213; i++) psc_assert(psc_vbitmap_get(vb, i) == 0); psc_vbitmap_setrange(vb, 25, 3); for (i = 0; i < 25; i++) psc_assert(psc_vbitmap_get(vb, i) == 0); for (j = 0; j < 3; j++, i++) psc_assert(psc_vbitmap_get(vb, i) == 1); for (j = 0; j < 25; j++, i++) psc_assert(psc_vbitmap_get(vb, i) == 0); psc_vbitmap_clearall(vb); for (i = 0; i < 213; i++) psc_assert(psc_vbitmap_get(vb, i) == 0); for (i = 0; i < 213; i++) if (!psc_vbitmap_next(vb, &elem)) psc_fatalx("out of elements at pos %d", i); if (psc_vbitmap_next(vb, &elem)) psc_fatalx("an unexpected extra unused elem was found; pos=%zu", elem); psc_vbitmap_getstats(vb, &u, &t); if (u != 213 || t != 213) psc_fatalx("wrong size, got %d,%d want %d", u, t, 213); psc_vbitmap_unsetrange(vb, 13, 2); for (i = 0; i < 13; i++) psc_assert(psc_vbitmap_get(vb, i) == 1); for (j = 0; j < 2; j++, i++) psc_assert(psc_vbitmap_get(vb, i) == 0); for (j = 0; j < 25; j++, i++) psc_assert(psc_vbitmap_get(vb, i) == 1); if (psc_vbitmap_resize(vb, NELEM) == -1) psc_fatal("psc_vbitmap_new"); psc_assert(psc_vbitmap_getsize(vb) == NELEM); /* fill up bitmap */ for (i = 0; i < NELEM - 211; i++) if (!psc_vbitmap_next(vb, &elem)) psc_fatalx("out of elements at iter %d", i); /* try one past end of filled bitmap */ if (psc_vbitmap_next(vb, &elem)) psc_fatalx("an unexpected extra unused elem was found; pos=%zu", elem); /* free some slots */ for (i = 0, elem = 0; elem < NELEM; i++, elem += NELEM / 10) psc_vbitmap_unset(vb, elem); t = psc_vbitmap_nfree(vb); if (t != i) psc_fatalx("wrong number of free elements; has=%d want=%d", t, i); psc_vbitmap_invert(vb); t = psc_vbitmap_nfree(vb); if (t != NELEM - i) psc_fatalx("wrong number of inverted elements; has=%d want=%d", t, NELEM - i); psc_vbitmap_invert(vb); t = psc_vbitmap_nfree(vb); if (t != i) psc_fatalx("wrong number of original elements; has=%d want=%d", t, i); /* try to re-grab the freed slots */ for (i = 0; i <= 10; i++) if (!psc_vbitmap_next(vb, &elem)) psc_fatalx("out of elements, request %d/%d", i, 10); /* try one past end of filled bitmap */ if (psc_vbitmap_next(vb, &elem)) psc_fatalx("an unexpected extra unused elem was found; pos=%zu", elem); psc_vbitmap_setval_range(vb, 0, NELEM, 0); psc_assert(pfl_vbitmap_israngeset(vb, 0, 581, 371)); psc_assert(pfl_vbitmap_israngeset(vb, 1, 581, 371) == 0); psc_assert(pfl_vbitmap_israngeset(vb, 0, 581, 1)); psc_assert(pfl_vbitmap_israngeset(vb, 1, 581, 1) == 0); psc_assert(pfl_vbitmap_isempty(vb)); psc_vbitmap_setval_range(vb, 0, NELEM, 1); psc_assert(pfl_vbitmap_israngeset(vb, 1, 581, 371)); psc_assert(pfl_vbitmap_israngeset(vb, 0, 581, 371) == 0); psc_assert(pfl_vbitmap_israngeset(vb, 1, 581, 1)); psc_assert(pfl_vbitmap_israngeset(vb, 0, 581, 1) == 0); psc_assert(psc_vbitmap_isfull(vb)); psc_vbitmap_free(vb); vb = psc_vbitmap_new(0); for (i = 1; i < 101; i++) { if (psc_vbitmap_resize(vb, i) == -1) psc_fatal("psc_vbitmap_new"); psc_vbitmap_setval(vb, i - 1, i % 2); psc_assert(psc_vbitmap_get(vb, i - 1) == i % 2); } exit(0); }
/* * Initialize an on-disk journal. * @fn: file path to store journal. * @nents: number of entries journal may contain if non-zero. * @entsz: size of a journal entry. * @rs: read size. * Returns the number of entries created. */ uint32_t sl_journal_format(const char *fn, uint32_t nents, uint32_t entsz, uint32_t rs, uint64_t uuid, int block_dev) { uint32_t i, slot, max_nents; struct psc_journal_enthdr *pje; struct psc_journal pj; struct stat stb; unsigned char *jbuf; size_t numblocks; ssize_t nb; int fd; memset(&pj, 0, sizeof(pj)); fd = open(fn, O_WRONLY | O_CREAT | O_TRUNC, 0600); if (fd == -1) psc_fatal("%s", fn); if (fstat(fd, &stb) == -1) psc_fatal("stat %s", fn); /* * If the user does not specify nents, either use default or * based on the block device size. */ if (nents == 0 && !block_dev) nents = SLJ_MDS_JNENTS; if (block_dev) { if (ioctl(fd, BLKGETSIZE, &numblocks) == -1) err(1, "BLKGETSIZE: %s", fn); /* show progress, it is going to be a while */ verbose = 1; /* deal with large disks */ max_nents = MIN(numblocks, SLJ_MDS_MAX_JNENTS); /* leave room on both ends */ max_nents -= stb.st_blksize / SLJ_MDS_ENTSIZE + 16; /* efficiency */ max_nents = (max_nents / rs) * rs; if (nents) nents = MIN(nents, max_nents); else nents = max_nents; } if (nents % rs) psc_fatalx("number of slots (%u) should be a multiple of " "readsize (%u)", nents, rs); pj.pj_fd = fd; pj.pj_hdr = PSCALLOC(PSC_ALIGN(sizeof(struct psc_journal_hdr), stb.st_blksize)); pj.pj_hdr->pjh_entsz = entsz; pj.pj_hdr->pjh_nents = nents; pj.pj_hdr->pjh_version = PJH_VERSION; pj.pj_hdr->pjh_readsize = rs; pj.pj_hdr->pjh_iolen = PSC_ALIGN(sizeof(struct psc_journal_hdr), stb.st_blksize); pj.pj_hdr->pjh_magic = PJH_MAGIC; pj.pj_hdr->pjh_timestamp = time(NULL); pj.pj_hdr->pjh_fsuuid = uuid; psc_crc64_init(&pj.pj_hdr->pjh_chksum); psc_crc64_add(&pj.pj_hdr->pjh_chksum, pj.pj_hdr, offsetof(struct psc_journal_hdr, pjh_chksum)); psc_crc64_fini(&pj.pj_hdr->pjh_chksum); nb = pwrite(pj.pj_fd, pj.pj_hdr, pj.pj_hdr->pjh_iolen, 0); if ((size_t)nb != pj.pj_hdr->pjh_iolen) psc_fatalx("failed to write journal header: %s", nb == -1 ? strerror(errno) : "short write"); nb = PJ_PJESZ(&pj) * pj.pj_hdr->pjh_readsize; jbuf = psc_alloc(nb, PAF_PAGEALIGN); for (i = 0; i < rs; i++) { pje = PSC_AGP(jbuf, PJ_PJESZ(&pj) * i); pje->pje_magic = PJE_MAGIC; pje->pje_type = PJE_FORMAT; pje->pje_xid = PJE_XID_NONE; pje->pje_len = 0; psc_crc64_init(&pje->pje_chksum); psc_crc64_add(&pje->pje_chksum, pje, offsetof(struct psc_journal_enthdr, pje_chksum)); psc_crc64_add(&pje->pje_chksum, pje->pje_data, pje->pje_len); psc_crc64_fini(&pje->pje_chksum); } i = 0; /* XXX use an option to write only one entry in fast create mode */ for (slot = 0; slot < pj.pj_hdr->pjh_nents; slot += rs) { nb = pwrite(pj.pj_fd, jbuf, PJ_PJESZ(&pj) * rs, PJ_GETENTOFF(&pj, slot)); if ((size_t)nb != PJ_PJESZ(&pj) * rs) psc_fatal("failed to write slot %u (%zd)", slot, nb); if (verbose && slot % 262144 == 0) { printf("."); fflush(stdout); fsync(pj.pj_fd); if (++i == 80) { printf("\n"); i = 0; } } } if (verbose && i) printf("\n"); if (close(fd) == -1) psc_fatal("failed to close journal"); psc_free(jbuf, PAF_PAGEALIGN, PJ_PJESZ(&pj) * rs); return (nents); }
/* * Traverse a file hierarchy and perform an operation on each file * system entry. * @fn: file root. * @flags: behavorial flags. * @cmpf: optional dirent comparator for ordering. * @cbf: callback to invoke on each file. * @arg: optional argument to supply to callback. * Notes: the callback will be invoked with a fully resolved absolute * path name unless the file in question is a symbolic link. */ int pfl_filewalk(const char *fn, int flags, void *cmpf, int (*cbf)(FTSENT *, void *), void *arg) { char * const pathv[] = { (char *)fn, NULL }; int rc = 0, f_flags = 0; struct stat stb; FTSENT *f; FTS *fp; if (flags & PFL_FILEWALKF_RECURSIVE) { if (flags & PFL_FILEWALKF_NOSTAT) f_flags |= FTS_NOSTAT; if (flags & PFL_FILEWALKF_NOCHDIR) f_flags |= FTS_NOCHDIR; fp = pfl_fts_open(pathv, f_flags | FTS_COMFOLLOW | FTS_PHYSICAL, cmpf); if (fp == NULL) psc_fatal("fts_open %s", fn); while ((f = pfl_fts_read(fp)) != NULL) { switch (f->fts_info) { case FTS_NS: psclog_warnx("%s: %s", f->fts_path, strerror(f->fts_errno)); break; case FTS_F: case FTS_D: case FTS_SL: if (flags & PFL_FILEWALKF_VERBOSE) warnx("processing %s%s", fn, f->fts_info == FTS_D ? "/" : ""); case FTS_DP: rc = cbf(f, arg); if (rc) { pfl_fts_close(fp); return (rc); } break; default: if (f->fts_errno == 0) f->fts_errno = EOPNOTSUPP; psclog_warnx("%s: %s", f->fts_path, strerror(f->fts_errno)); break; } } pfl_fts_close(fp); } else { const char *basefn; size_t baselen; if (lstat(fn, &stb) == -1) err(1, "%s", fn); basefn = pfl_basename(fn); baselen = strlen(basefn); f = PSCALLOC(sizeof(*f) + baselen); f->fts_accpath = (char *)fn; f->fts_path = (char *)fn; f->fts_pathlen = strlen(fn); strlcpy(f->fts_name, basefn, baselen + 1); f->fts_namelen = baselen; f->fts_ino = stb.st_ino; f->fts_statp = &stb; switch (stb.st_mode & S_IFMT) { case S_IFDIR: f->fts_info = FTS_D; break; case S_IFREG: f->fts_info = FTS_F; break; case S_IFLNK: f->fts_info = FTS_SL; break; case S_IFBLK: f->fts_info = FTS_DEFAULT; break; default: psclog_warnx("%s: %s", fn, strerror(EOPNOTSUPP)); break; } rc = cbf(f, arg); PSCFREE(f); } return (rc); }
int main(int argc, char *argv[]) { char c, *p, *noncanon_mp, *cmd, *path_env, dir[PATH_MAX]; struct pscfs_args args = PSCFS_ARGS_INIT(0, NULL); struct psc_dynarray startup_cmds = DYNARRAY_INIT; const char *progpath = argv[0]; int rc, i, unmount_first = 0; pfl_init(); pscfs_addarg(&args, ""); /* progname/argv[0] */ pscfs_addarg(&args, "-o"); pscfs_addarg(&args, STD_MOUNT_OPTIONS); p = getenv("CTL_SOCK_FILE"); if (p) ctlsockfn = p; while ((c = getopt(argc, argv, "dL:o:S:U")) != -1) switch (c) { case 'd': pscfs_addarg(&args, "-odebug"); break; case 'L': psc_dynarray_add(&startup_cmds, optarg); break; case 'o': if (!opt_lookup(optarg)) { pscfs_addarg(&args, "-o"); pscfs_addarg(&args, optarg); } break; case 'S': ctlsockfn = optarg; break; case 'U': unmount_first = 1; break; default: usage(); } argc -= optind; argv += optind; if (argc != 1) usage(); pscthr_init(PFL_THRT_FSMGR, NULL, 0, "fsmgrthr"); noncanon_mp = argv[0]; if (unmount_first) unmount(noncanon_mp); /* canonicalize mount path */ if (realpath(noncanon_mp, mountpoint) == NULL) psc_fatal("realpath %s", noncanon_mp); pscfs_mount(mountpoint, &args); pscfs_freeargs(&args); ctlthr_spawn(); pfl_opstimerthr_spawn(PFL_THRT_OPSTIMER, "opstimerthr"); pfl_workq_init(128, 1024, 1024); pfl_wkthr_spawn(PFL_THRT_WORKER, 4, 0, "wkthr%d"); pscfs_entry_timeout = 8.; pscfs_attr_timeout = 8.; /* * Here, $p = (directory this daemon binary resides in). * Now we add the following to $PATH: * * 1) $p * 2) $p/../wokctl (for developers) */ pfl_dirname(progpath, dir); p = getenv("PATH"); rc = pfl_asprintf(&path_env, "%s:%s/../wokctl%s%s", dir, dir, p ? ":" : "", p ? p : ""); psc_assert(rc != -1); setenv("PATH", path_env, 1); /* * If wokctl (see file wokctl.c) misbehaves because it is given * a wrong arugment, it is hard to debug from our end because * we won't be receiving anything useful via the socket. This * should be changed to a native call someday. * * If the client does not come up, double/triple checkout * the name of your slash2 shared library. I wish I can * add more verbose debugging information. */ DYNARRAY_FOREACH(cmd, i, &startup_cmds) pfl_systemf("wokctl -S %s %s", ctlsockfn, cmd); exit(pscfs_main(32, "")); }
int main(int argc, char *argv[]) { struct psc_vbitmap *vb, vba = VBITMAP_INIT_AUTO; size_t elem, j, cap, len, off; int i, c, u, t; pfl_init(); while ((c = getopt(argc, argv, "")) != -1) switch (c) { default: usage(); } argc -= optind; if (argc) usage(); for (i = 0; i < 79; i++) if (psc_vbitmap_next(&vba, &j) != 1) psc_fatalx("psc_vbitmap_next failed with auto"); else if (j != (size_t)i) psc_fatalx("elem %d is not supposed to be %zu", i, j); if ((vb = psc_vbitmap_new(213)) == NULL) psc_fatal("psc_vbitmap_new"); psc_vbitmap_setrange(vb, 13, 9); psc_vbitmap_printbin1(vb); for (i = 0; i < 13; i++) pfl_assert(psc_vbitmap_get(vb, i) == 0); for (j = 0; j < 9; j++, i++) pfl_assert(psc_vbitmap_get(vb, i) == 1); for (j = 0; j < 25; j++, i++) pfl_assert(psc_vbitmap_get(vb, i) == 0); psc_vbitmap_clearall(vb); for (i = 0; i < 213; i++) pfl_assert(psc_vbitmap_get(vb, i) == 0); psc_vbitmap_setrange(vb, 25, 3); for (i = 0; i < 25; i++) pfl_assert(psc_vbitmap_get(vb, i) == 0); for (j = 0; j < 3; j++, i++) pfl_assert(psc_vbitmap_get(vb, i) == 1); for (j = 0; j < 25; j++, i++) pfl_assert(psc_vbitmap_get(vb, i) == 0); psc_vbitmap_clearall(vb); for (i = 0; i < 213; i++) pfl_assert(psc_vbitmap_get(vb, i) == 0); for (i = 0; i < 213; i++) if (!psc_vbitmap_next(vb, &elem)) psc_fatalx("out of elements at pos %d", i); if (psc_vbitmap_next(vb, &elem)) psc_fatalx("an unexpected extra unused elem was found; pos=%zu", elem); psc_vbitmap_getstats(vb, &u, &t); if (u != 213 || t != 213) psc_fatalx("wrong size, got %d,%d want %d", u, t, 213); psc_vbitmap_unsetrange(vb, 13, 2); for (i = 0; i < 13; i++) pfl_assert(psc_vbitmap_get(vb, i) == 1); for (j = 0; j < 2; j++, i++) pfl_assert(psc_vbitmap_get(vb, i) == 0); for (j = 0; j < 25; j++, i++) pfl_assert(psc_vbitmap_get(vb, i) == 1); if (psc_vbitmap_resize(vb, NELEM) == -1) psc_fatal("psc_vbitmap_resize"); pfl_assert(psc_vbitmap_getsize(vb) == NELEM); /* fill up bitmap */ for (i = 0; i < NELEM - 211; i++) if (!psc_vbitmap_next(vb, &elem)) psc_fatalx("out of elements at iter %d", i); /* try one past end of filled bitmap */ if (psc_vbitmap_next(vb, &elem)) psc_fatalx("an unexpected extra unused elem was found; pos=%zu", elem); /* free some slots */ for (i = 0, elem = 0; elem < NELEM; i++, elem += NELEM / 10) psc_vbitmap_unset(vb, elem); t = psc_vbitmap_nfree(vb); if (t != i) psc_fatalx("wrong number of free elements; has=%d want=%d", t, i); psc_vbitmap_invert(vb); t = psc_vbitmap_nfree(vb); if (t != NELEM - i) psc_fatalx("wrong number of inverted elements; has=%d want=%d", t, NELEM - i); psc_vbitmap_invert(vb); t = psc_vbitmap_nfree(vb); if (t != i) psc_fatalx("wrong number of original elements; has=%d want=%d", t, i); /* try to re-grab the freed slots */ for (i = 0; i <= 10; i++) if (!psc_vbitmap_next(vb, &elem)) psc_fatalx("out of elements, request %d/%d", i, 10); /* try one past end of filled bitmap */ if (psc_vbitmap_next(vb, &elem)) psc_fatalx("an unexpected extra unused elem was found; pos=%zu", elem); psc_vbitmap_setval_range(vb, 0, NELEM, 0); CHECK_RANGE(vb, 0, 581, 371); CHECK_RANGE(vb, 0, 581, 1); pfl_assert(pfl_vbitmap_isempty(vb)); psc_vbitmap_setval_range(vb, 0, NELEM, 1); CHECK_RANGE(vb, 1, 581, 371); CHECK_RANGE(vb, 1, 581, 1); pfl_assert(psc_vbitmap_isfull(vb)); psc_vbitmap_free(vb); vb = psc_vbitmap_newf(0, PVBF_AUTO); pfl_assert(vb); pfl_assert(pfl_vbitmap_isempty(vb)); pfl_assert(psc_vbitmap_getsize(vb) == 0); pfl_assert(psc_vbitmap_resize(vb, 6) == 0); pfl_assert(psc_vbitmap_getsize(vb) == 6); pfl_assert(pfl_vbitmap_isempty(vb)); psc_vbitmap_free(vb); vb = psc_vbitmap_newf(0, PVBF_AUTO); cap = psc_vbitmap_getsize(vb); off = 0; len = 6; if (off + len > cap) psc_vbitmap_resize(vb, off + len); psc_vbitmap_setrange(vb, off, len); ENSURE(vb, "111111"); CHECK_RANGE(vb, 1, 2, 4); psc_vbitmap_clearall(vb); pfl_assert(psc_vbitmap_setval_range(vb, 2, 4, 1) == 0); CHECK_RANGE(vb, 1, 2, 4); ENSURE(vb, "001111"); psc_vbitmap_free(vb); vb = psc_vbitmap_new(0); for (i = 1; i < 101; i++) { if (psc_vbitmap_resize(vb, i) == -1) psc_fatal("psc_vbitmap_new"); psc_vbitmap_setval(vb, i - 1, i % 2); pfl_assert(psc_vbitmap_get(vb, i - 1) == i % 2); } psc_vbitmap_free(vb); for (cap = 0; cap < 100; cap++) { for (off = 1; off < cap; off++) { for (len = 1; off + len < cap; len++) { size_t last; last = cap - off - len; vb = psc_vbitmap_new(cap); psc_vbitmap_setrange(vb, off, len); ENSURE(vb, "%0*d%*d%0*d", (int)off, 0, (int)len, 1, (int)last, 0); CHECK_RANGE(vb, 0, 0, off); CHECK_RANGE(vb, 1, off, len); CHECK_RANGE(vb, 0, off+len, last); psc_vbitmap_free(vb); } } } vb = psc_vbitmap_new(8200); pfl_assert(pfl_vbitmap_isempty(vb)); CHECK_RANGE(vb, 0, 8, 8192); psc_vbitmap_free(vb); vb = psc_vbitmap_new(16); ENSURE_ABBR(vb, "0:8,00000000"); psc_vbitmap_free(vb); vb = psc_vbitmap_new(40); psc_vbitmap_setval_range(vb, 0, 10, 0); psc_vbitmap_setval_range(vb, 10, 10, 1); ENSURE(vb, "0000000000111111111100000000000000000000"); ENSURE_ABBR(vb, "0:10,1:10,0:12,00000000"); psc_vbitmap_free(vb); vb = psc_vbitmap_new(16); ENSURE(vb, "0000000000000000"); pfl_assert(pfl_vbitmap_isempty(vb)); CHECK_RANGE(vb, 0, 8, 8); CHECK_RANGE(vb, 0, 9, 7); psc_vbitmap_setval(vb, 15, 1); ENSURE(vb, "0000000000000001"); CHECK_RANGE(vb, 0, 9, 6); CHECK_RANGE(vb, 1, 15, 1); pfl_assert(pfl_vbitmap_israngeset(vb, 0, 8, 8) == 0); pfl_assert(pfl_vbitmap_israngeset(vb, 1, 8, 8) == 0); psc_vbitmap_clearall(vb); pfl_assert(pfl_vbitmap_isempty(vb)); psc_vbitmap_free(vb); exit(0); }
__static void pflnet_getifnfordst_rtnetlink(const struct sockaddr *sa, char ifn[IFNAMSIZ]) { struct { struct nlmsghdr nmh; struct rtmsg rtm; #define RT_SPACE 8192 unsigned char buf[RT_SPACE]; } rq; const struct sockaddr_in *sin; struct nlmsghdr *nmh; struct rtattr *rta; struct rtmsg *rtm; ssize_t rc, rca; int s, ifidx; size_t nb; sin = (void *)sa; s = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE); if (s == -1) psc_fatal("socket"); memset(&rq, 0, sizeof(rq)); rq.nmh.nlmsg_len = NLMSG_SPACE(sizeof(rq.rtm)) + RTA_LENGTH(sizeof(sin->sin_addr)); rq.nmh.nlmsg_flags = NLM_F_REQUEST; rq.nmh.nlmsg_type = RTM_GETROUTE; rq.rtm.rtm_family = sa->sa_family; rq.rtm.rtm_protocol = RTPROT_UNSPEC; rq.rtm.rtm_table = RT_TABLE_MAIN; /* # bits filled in target addr */ rq.rtm.rtm_dst_len = sizeof(sin->sin_addr) * NBBY; rq.rtm.rtm_scope = RT_SCOPE_LINK; rta = (void *)((char *)&rq + NLMSG_SPACE(sizeof(rq.rtm))); rta->rta_type = RTA_DST; rta->rta_len = RTA_LENGTH(sizeof(sin->sin_addr)); memcpy(RTA_DATA(rta), &sin->sin_addr, sizeof(sin->sin_addr)); errno = 0; rc = write(s, &rq, rq.nmh.nlmsg_len); if (rc != (ssize_t)rq.nmh.nlmsg_len) psc_fatal("routing socket length mismatch"); rc = read(s, &rq, sizeof(rq)); if (rc == -1) psc_fatal("routing socket read"); close(s); switch (rq.nmh.nlmsg_type) { case NLMSG_ERROR: { struct nlmsgerr *nlerr; nlerr = NLMSG_DATA(&rq.nmh); psc_fatalx("netlink: %s", strerror(nlerr->error)); } case NLMSG_DONE: psc_fatalx("netlink: unexpected EOF"); } nmh = &rq.nmh; nb = rc; for (; NLMSG_OK(nmh, nb); nmh = NLMSG_NEXT(nmh, nb)) { rtm = NLMSG_DATA(nmh); if (rtm->rtm_table != RT_TABLE_MAIN) continue; rta = RTM_RTA(rtm); rca = RTM_PAYLOAD(nmh); for (; RTA_OK(rta, rca); rta = RTA_NEXT(rta, rca)) { switch (rta->rta_type) { case RTA_OIF: memcpy(&ifidx, RTA_DATA(rta), sizeof(ifidx)); pflnet_getifname(ifidx, ifn); return; } } } psc_fatalx("no route for addr"); }
/** * pjournal_format - Initialize an on-disk journal. * @fn: file path to store journal. * @nents: number of entries journal may contain. * @entsz: size of a journal entry. * Returns 0 on success, errno on error. */ void pjournal_format(const char *fn, uint32_t nents, uint32_t entsz, uint32_t rs, uint64_t uuid) { struct psc_journal_enthdr *pje; struct psc_journal pj; struct stat stb; unsigned char *jbuf; uint32_t i, j, slot; int rc, fd; ssize_t nb; if (nents % rs) psc_fatalx("number of slots (%u) should be a multiple of " "readsize (%u)", nents, rs); memset(&pj, 0, sizeof(struct psc_journal)); rc = 0; fd = open(fn, O_WRONLY | O_CREAT | O_TRUNC, 0600); if (fd == -1) psc_fatal("%s", fn); if (fstat(fd, &stb) == -1) psc_fatal("stat %s", fn); pj.pj_fd = fd; pj.pj_hdr = PSCALLOC(PSC_ALIGN(sizeof(struct psc_journal_hdr), stb.st_blksize)); pj.pj_hdr->pjh_entsz = entsz; pj.pj_hdr->pjh_nents = nents; pj.pj_hdr->pjh_version = PJH_VERSION; pj.pj_hdr->pjh_readsize = rs; pj.pj_hdr->pjh_iolen = PSC_ALIGN(sizeof(struct psc_journal_hdr), stb.st_blksize); pj.pj_hdr->pjh_magic = PJH_MAGIC; pj.pj_hdr->pjh_timestamp = time(NULL); pj.pj_hdr->pjh_fsuuid = uuid; psc_crc64_init(&pj.pj_hdr->pjh_chksum); psc_crc64_add(&pj.pj_hdr->pjh_chksum, pj.pj_hdr, offsetof(struct psc_journal_hdr, pjh_chksum)); psc_crc64_fini(&pj.pj_hdr->pjh_chksum); nb = pwrite(pj.pj_fd, pj.pj_hdr, pj.pj_hdr->pjh_iolen, 0); if ((size_t)nb != pj.pj_hdr->pjh_iolen) psc_fatalx("failed to write journal header: %s", nb == -1 ? strerror(errno) : "short write"); nb = PJ_PJESZ(&pj) * pj.pj_hdr->pjh_readsize; jbuf = psc_alloc(nb, PAF_PAGEALIGN); for (i = 0; i < rs; i++) { pje = PSC_AGP(jbuf, PJ_PJESZ(&pj) * i); pje->pje_magic = PJE_MAGIC; pje->pje_type = PJE_FORMAT; pje->pje_xid = PJE_XID_NONE; pje->pje_len = 0; psc_crc64_init(&pje->pje_chksum); psc_crc64_add(&pje->pje_chksum, pje, offsetof(struct psc_journal_enthdr, pje_chksum)); psc_crc64_add(&pje->pje_chksum, pje->pje_data, pje->pje_len); psc_crc64_fini(&pje->pje_chksum); } j = 0; /* XXX use an option to write only one entry in fast create mode */ for (slot = 0; slot < pj.pj_hdr->pjh_nents; slot += rs) { nb = pwrite(pj.pj_fd, jbuf, PJ_PJESZ(&pj) * rs, PJ_GETENTOFF(&pj, slot)); if ((size_t)nb != PJ_PJESZ(&pj) * rs) psc_fatal("failed to write slot %u (%zd)", slot, nb); if (verbose && slot % 262144 == 0) { printf("."); fflush(stdout); fsync(pj.pj_fd); if (++j == 80) { printf("\n"); j = 0; } } } if (verbose && j) printf("\n"); if (close(fd) == -1) psc_fatal("failed to close journal"); psc_free(jbuf, PAF_PAGEALIGN, PJ_PJESZ(&pj) * rs); psclog_info("journal %s formatted: %d slots, %d readsize, error=%d", fn, nents, rs, rc); }
/** * pjournal_dump - Dump the contents of a journal file. * @fn: journal filename to query. * @verbose: whether to report stats summary or full dump. * * Each time mds restarts, it writes log entries starting from the very * first slot of the log. Anyway, the function dumps all log entries, * some of them may be from previous incarnations of the MDS. */ void pjournal_dump(const char *fn) { int i, ntotal, nmagic, nchksum, nformat, ndump, first = 1; uint32_t slot, highest_slot = -1, lowest_slot = -1; uint64_t chksum, highest_xid = 0, lowest_xid = 0; struct psc_journal_enthdr *pje; struct psc_journal_hdr *pjh; struct psc_journal *pj; struct stat statbuf; unsigned char *jbuf; ssize_t nb, pjhlen; time_t ts; ntotal = nmagic = nchksum = nformat = ndump = 0; pj = PSCALLOC(sizeof(*pj)); strlcpy(pj->pj_name, pfl_basename(fn), sizeof(pj->pj_name)); pj->pj_fd = open(fn, O_RDWR | O_DIRECT); if (pj->pj_fd == -1) psc_fatal("failed to open journal %s", fn); if (fstat(pj->pj_fd, &statbuf) == -1) psc_fatal("failed to stat journal %s", fn); /* * O_DIRECT may impose alignment restrictions so align the * buffer and perform I/O in multiples of file system block * size. */ pjhlen = PSC_ALIGN(sizeof(*pjh), statbuf.st_blksize); pjh = psc_alloc(pjhlen, PAF_PAGEALIGN); nb = pread(pj->pj_fd, pjh, pjhlen, 0); if (nb != pjhlen) psc_fatal("failed to read journal header"); pj->pj_hdr = pjh; if (pjh->pjh_magic != PJH_MAGIC) psc_fatalx("journal header has a bad magic number " "%#"PRIx64, pjh->pjh_magic); if (pjh->pjh_version != PJH_VERSION) psc_fatalx("journal header has an invalid version " "number %d", pjh->pjh_version); psc_crc64_init(&chksum); psc_crc64_add(&chksum, pjh, offsetof(struct psc_journal_hdr, pjh_chksum)); psc_crc64_fini(&chksum); if (pjh->pjh_chksum != chksum) psc_fatalx("journal header has an invalid checksum " "value %"PSCPRIxCRC64" vs %"PSCPRIxCRC64, pjh->pjh_chksum, chksum); if (S_ISREG(statbuf.st_mode) && statbuf.st_size != (off_t)(pjhlen + pjh->pjh_nents * PJ_PJESZ(pj))) psc_fatalx("size of the journal log %"PSCPRIdOFFT"d does " "not match specs in its header", statbuf.st_size); if (pjh->pjh_nents % pjh->pjh_readsize) psc_fatalx("number of entries %d is not a multiple of the " "readsize %d", pjh->pjh_nents, pjh->pjh_readsize); ts = pjh->pjh_timestamp; printf("%s:\n" " version: %u\n" " entry size: %u\n" " number of entries: %u\n" " batch read size: %u\n" " entry start offset: %"PRId64"\n" " format time: %s" " uuid: %"PRIx64"\n" " %4s %3s %4s %4s %s\n", fn, pjh->pjh_version, PJ_PJESZ(pj), pjh->pjh_nents, pjh->pjh_readsize, pjh->pjh_start_off, ctime(&ts), pjh->pjh_fsuuid, "idx", "typ", "xid", "txg", "details"); jbuf = psc_alloc(PJ_PJESZ(pj) * pj->pj_hdr->pjh_readsize, PAF_PAGEALIGN); for (slot = 0; slot < pjh->pjh_nents; slot += pjh->pjh_readsize) { nb = pread(pj->pj_fd, jbuf, PJ_PJESZ(pj) * pjh->pjh_readsize, PJ_GETENTOFF(pj, slot)); if (nb != PJ_PJESZ(pj) * pjh->pjh_readsize) warn("failed to read %d log entries at slot %d", pjh->pjh_readsize, slot); for (i = 0; i < pjh->pjh_readsize; i++) { ntotal++; pje = (void *)&jbuf[PJ_PJESZ(pj) * i]; if (pje->pje_magic != PJE_MAGIC) { nmagic++; warnx("journal slot %d has a bad magic" "number", slot + i); continue; } /* * If we hit a new entry that is never used, we * assume that the rest of the journal is never * used. */ if (pje->pje_type == PJE_FORMAT) { nformat = nformat + pjh->pjh_nents - (slot + i); goto done; } psc_crc64_init(&chksum); psc_crc64_add(&chksum, pje, offsetof( struct psc_journal_enthdr, pje_chksum)); psc_crc64_add(&chksum, pje->pje_data, pje->pje_len); psc_crc64_fini(&chksum); if (pje->pje_chksum != chksum) { nchksum++; warnx("journal slot %d has a corrupt " "checksum", slot + i); goto done; } ndump++; if (verbose) pjournal_dump_entry(slot + i, pje); if (first) { first = 0; highest_xid = lowest_xid = pje->pje_xid; highest_slot = lowest_slot = slot + i; continue; } if (highest_xid < pje->pje_xid) { highest_xid = pje->pje_xid; highest_slot = slot + i; } if (lowest_xid > pje->pje_xid) { lowest_xid = pje->pje_xid; lowest_slot = slot + i; } } } done: if (close(pj->pj_fd) == -1) printf("failed closing journal %s", fn); psc_free(jbuf, PAF_PAGEALIGN, PJ_PJESZ(pj)); PSCFREE(pj); printf("----------------------------------------------\n" "%8d slot(s) scanned\n" "%8d in use\n" "%8d formatted\n" "%8d bad magic\n" "%8d bad checksum(s)\n" "lowest transaction ID=%#"PRIx64" (slot=%d)\n" "highest transaction ID=%#"PRIx64" (slot=%d)\n", ntotal, ndump, nformat, nmagic, nchksum, lowest_xid, lowest_slot, highest_xid, highest_slot); }
__static int pflnet_rtexists_rtnetlink(const struct sockaddr *sa) { struct { struct nlmsghdr nmh; struct rtmsg rtm; #define RT_SPACE 8192 unsigned char buf[RT_SPACE]; struct rtattr rta; struct nlmsgerr nlerr; } rq; struct sockaddr_in *sin = (void *)sa; in_addr_t cmpaddr, zero = 0; struct nlmsghdr *nmh; struct rtattr *rta; struct rtmsg *rtm; ssize_t rc, rca; int rv = 0, s; size_t nb; s = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE); if (s == -1) psc_fatal("socket"); memset(&rq, 0, sizeof(rq)); rq.nmh.nlmsg_len = NLMSG_SPACE(sizeof(rq.rtm)); rq.nmh.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP; rq.nmh.nlmsg_type = RTM_GETROUTE; rq.rtm.rtm_family = sa->sa_family; rq.rtm.rtm_protocol = RTPROT_UNSPEC; rq.rtm.rtm_table = RT_TABLE_MAIN; rq.rtm.rtm_scope = RT_SCOPE_LINK; rta = (void *)((char *)&rq.rta + NLMSG_SPACE(sizeof(rq.rtm))); rta->rta_type = RTA_DST; rta->rta_len = RTA_LENGTH(sizeof(sin->sin_addr)); memcpy(RTA_DATA(rta), &sin->sin_addr, sizeof(sin->sin_addr)); errno = 0; rc = write(s, &rq, rq.nmh.nlmsg_len); if (rc != (ssize_t)rq.nmh.nlmsg_len) psc_fatal("routing socket length mismatch"); for (;;) { rc = read(s, &rq, sizeof(rq)); if (rc == -1) psc_fatal("routing socket read"); switch (rq.nmh.nlmsg_type) { case NLMSG_ERROR: { struct nlmsgerr *nlerr; nlerr = NLMSG_DATA(&rq.nlerr); psc_fatalx("netlink: %s", strerror(nlerr->error)); } case NLMSG_DONE: goto out; } nmh = &rq.nmh; nb = rc; for (; NLMSG_OK(nmh, nb); nmh = NLMSG_NEXT(nmh, nb)) { rtm = NLMSG_DATA(nmh); if (rtm->rtm_table != RT_TABLE_MAIN) continue; rta = RTM_RTA(rtm); rca = RTM_PAYLOAD(nmh); for (; RTA_OK(rta, rca); rta = RTA_NEXT(rta, rca)) { switch (rta->rta_type) { case RTA_GATEWAY: cmpaddr = sin->sin_addr.s_addr; if (zero == cmpaddr) { rv = 1; goto out; } break; case RTA_DST: cmpaddr = sin->sin_addr.s_addr; pfl_bitstr_copy(&cmpaddr, rtm->rtm_dst_len, &zero, 0, sizeof(zero) * NBBY - rtm->rtm_dst_len); if (cmpaddr == *(in_addr_t *) RTA_DATA(rta)) { rv = 1; goto out; } break; } } } } out: close(s); return (rv); }
__static void pflnet_getifnfordst_rtsock(const struct sockaddr *sa, char ifn[IFNAMSIZ]) { struct { struct rt_msghdr rtm; #define RT_SPACE 512 unsigned char buf[RT_SPACE]; } m; struct rt_msghdr *rtm = &m.rtm; union pfl_sockaddr psa, *psap; unsigned char *p = m.buf; ssize_t len, rc; pid_t pid; int j, s; memset(&m, 0, sizeof(m)); #ifdef HAVE_SA_LEN #define ADDSOCKADDR(p, sa) \ do { \ memcpy((p), (sa), (sa)->sa_len); \ (p) += SOCKADDR_GETLEN(sa); \ } while (0) #else #define ADDSOCKADDR(p, sa) \ do { \ memcpy((p), (sa), sizeof(*(sa))); \ (p) += SOCKADDR_GETLEN(sa); \ } while (0) #endif ADDSOCKADDR(p, sa); memset(&psa, 0, sizeof(psa)); psa.sdl.sdl_family = AF_LINK; #ifdef HAVE_SA_LEN psa.sdl.sdl_len = sizeof(psa.sdl); #endif ADDSOCKADDR(p, &psa.sa); rtm->rtm_type = RTM_GET; rtm->rtm_flags = RTF_STATIC | RTF_UP | RTF_HOST | RTF_GATEWAY; rtm->rtm_version = RTM_VERSION; rtm->rtm_addrs = RTA_DST | RTA_IFP; #ifdef HAVE_RTM_HDRLEN rtm->rtm_hdrlen = sizeof(m.rtm); #endif rtm->rtm_msglen = len = p - (unsigned char *)&m; s = socket(PF_ROUTE, SOCK_RAW, 0); if (s == -1) psc_fatal("socket"); rc = write(s, &m, len); if (rc == -1) psc_fatal("writing to routing socket"); if (rc != len) psc_fatalx("writing to routing socket: short write"); pid = getpid(); do { rc = read(s, &m, sizeof(m)); } while (rc > 0 && (rtm->rtm_version != RTM_VERSION || rtm->rtm_seq || rtm->rtm_pid != pid)); if (rc == -1) psc_fatal("read from routing socket"); if (rtm->rtm_version != RTM_VERSION) psc_fatalx("routing message version mismatch; has=%d got=%d", RTM_VERSION, rtm->rtm_version); if (rtm->rtm_errno) psc_fatalx("routing error: %s", strerror(rtm->rtm_errno)); if (rtm->rtm_msglen > rc) psc_fatalx("routing message too large"); close(s); p = m.buf; for (; rtm->rtm_addrs; rtm->rtm_addrs &= ~(1 << j), p += SOCKADDR_GETLEN(&psap->sa)) { j = ffs(rtm->rtm_addrs) - 1; psap = (void *)p; switch (1 << j) { case RTA_IFP: if (psap->sdl.sdl_family == AF_LINK && psap->sdl.sdl_nlen) { strncpy(ifn, psap->sdl.sdl_data, IFNAMSIZ - 1); ifn[IFNAMSIZ - 1] = '\0'; return; } break; } } psc_fatalx("interface message not received"); }
int slm_rmm_apply_update(__unusedx struct srt_update_entry *entryp) { psc_fatal("obsolete code path"); }