common/util.c - pub/scm/fs/xfs/xfsdump-dev - Git at Google

 /*
  * Copyright (c) 2000-2002 Silicon Graphics, Inc.
  * All Rights Reserved.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it would be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write the Free Software Foundation,
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */

 #include <unistd.h>
 #include <stdlib.h>
 #include <sys/stat.h>
 #include <sys/ioctl.h>
 #include <fcntl.h>
 #include <errno.h>
 #include <dirent.h>
 #include <assert.h>
 #include <string.h>
 #include <xfs/xfs.h>
 #include <xfs/jdm.h>

 #include "config.h"

 #include "types.h"
 #include "util.h"
 #include "mlog.h"
 #include "getdents.h"

 extern size_t pgsz;

 int
 write_buf(char *bufp,
 	   size_t bufsz,
 	   void *contextp,
 	   gwbfp_t get_write_buf_funcp,
 	   wfp_t write_funcp)
 {
 	char *mbufp;	/* buffer obtained from manager */
 	size_t mbufsz;/* size of buffer obtained from manager */

 	while (bufsz) {
 		int rval;

 		assert(bufsz > 0);
 		mbufp = (*get_write_buf_funcp)(contextp, bufsz, &mbufsz);
 		assert(mbufsz <= bufsz);
 		if (bufp) {
 			(void)memcpy((void *)mbufp, (void *)bufp, mbufsz);
 		} else {
 			(void)memset((void *)mbufp, 0, mbufsz);
 		}
 		rval = (*write_funcp)(contextp, mbufp, mbufsz);
 		if (rval) {
 			return rval;
 		}
 		if (bufp) {
 			bufp += mbufsz;
 		}
 		bufsz -= mbufsz;
 	}

 	return 0;
 }

 int
 read_buf(char *bufp,
 	  size_t bufsz,
 	  void *contextp,
 	  rfp_t read_funcp,
 	  rrbfp_t return_read_buf_funcp,
 	  int *statp)
 {
 	char *mbufp;		/* manager's buffer pointer */
 	size_t mbufsz;	/* size of manager's buffer */
 	int nread;

 	nread = 0;
 	*statp = 0;
 	while (bufsz) {
 		mbufp = (*read_funcp)(contextp, bufsz, &mbufsz, statp);
 		if (*statp) {
 			break;
 		}
 		assert(mbufsz <= bufsz);
 		if (bufp) {
 			(void)memcpy((void *)bufp, (void *)mbufp, mbufsz);
 			bufp += mbufsz;
 		}
 		bufsz -= mbufsz;
 		nread += (int)mbufsz;
 		(*return_read_buf_funcp)(contextp, mbufp, mbufsz);
 	}

 	return nread;
 }

 char
 *strncpyterm(char *s1, char *s2, size_t n)
 {
 	char *rval;

 	if (n < 1) return 0;
 	rval = strncpy(s1, s2, n);
 	s1[n - 1] = 0;
 	return rval;
 }

 int
 bigstat_iter(jdm_fshandle_t *fshandlep,
 	      int fsfd,
 	      int selector,
 	      xfs_ino_t start_ino,
 	      bstat_cbfp_t fp,
 	      void * cb_arg1,
 	      bstat_seekfp_t seekfp,
 	      void * seek_arg1,
 	      int *statp,
 	      bool_t (pfp)(int),
 	      xfs_bstat_t *buf,
 	      size_t buflenin)
 {
 	__s32 buflenout;
 	xfs_ino_t lastino;
 	int saved_errno;
 	int bulkstatcnt;
         xfs_fsop_bulkreq_t bulkreq;

 	/* stat set with return from callback func
 	 */
 	*statp = 0;

 	/* NOT COOL: open will affect root dir's access time
 	 */

 	mlog(MLOG_NITTY,
 	      "bulkstat iteration initiated: start_ino == %llu\n",
 	      start_ino);

 	/* quirk of the interface: I want to play in terms of the
 	 * ino to begin with, and ino 0 is not used. so, ...
 	 */
 	if (start_ino > 0) {
 		lastino = start_ino - 1;
 	} else {
 		lastino = 0;
 	}
 	mlog(MLOG_NITTY + 1,
 	      "calling bulkstat\n");

 	bulkstatcnt = 0;
 	bulkreq.lastip = (__u64 *)&lastino;
 	bulkreq.icount = buflenin;
 	bulkreq.ubuffer = buf;
 	bulkreq.ocount = &buflenout;
 	while (!ioctl(fsfd, XFS_IOC_FSBULKSTAT, &bulkreq)) {
 		xfs_bstat_t *p;
 		xfs_bstat_t *endp;

 		if (buflenout == 0) {
 			mlog(MLOG_NITTY + 1,
 			      "bulkstat returns buflen %d\n",
 			      buflenout);
 			return 0;
 		}
 		mlog(MLOG_NITTY + 1,
 		      "bulkstat returns buflen %d ino %llu\n",
 		      buflenout,
 		      buf->bs_ino);
 		for (p = buf, endp = buf + buflenout; p < endp; p++) {
 			int rval;

 			if (p->bs_ino == 0)
 				continue;

 			if (!p->bs_nlink || !p->bs_mode) {
 				/* inode being modified, get synced data */
 				mlog(MLOG_NITTY + 1,
 				      "ino %llu needed second bulkstat\n",
 				      p->bs_ino);

 				if(bigstat_one(fsfd, p->bs_ino, p) < 0) {
 				    mlog(MLOG_WARNING,
 					  _("failed to get bulkstat information for inode %llu\n"),
 					  p->bs_ino);
 				    continue;
 				}
 				if (!p->bs_nlink || !p->bs_mode || !p->bs_ino) {
 					mlog(MLOG_TRACE,
 					      _("failed to get valid bulkstat information for inode %llu\n"),
 					      p->bs_ino);
 					continue;
 				}
 			}

 			if ((p->bs_mode & S_IFMT) == S_IFDIR) {
 				if (!(selector & BIGSTAT_ITER_DIR)){
 					continue;
 				}
 			} else {
 				if (!(selector & BIGSTAT_ITER_NONDIR)){
 					continue;
 				}
 			}
 			rval = (*fp)(cb_arg1, fshandlep, fsfd, p);
 			if (rval) {
 				*statp = rval;
 				return 0;
 			}
 			if (pfp) (pfp)(PREEMPT_PROGRESSONLY);
 		}

 		if (pfp && (++bulkstatcnt % 10) == 0 &&
 		     (pfp)(PREEMPT_FULL)) {
 			return EINTR;
 		}

 		if (seekfp) {
 			lastino = seekfp(seek_arg1, lastino);
 			if (lastino == INO64MAX) {
 				mlog(MLOG_DEBUG,
 				      "bulkstat seeked to EOS\n");
 				return 0;
 			}

 			mlog(MLOG_DEBUG,
 			      "bulkstat seeked to %llu\n", lastino);

 			lastino = (lastino > 0) ? lastino - 1 : 0;
 		}

 		mlog(MLOG_NITTY + 1,
 		      "calling bulkstat\n");
 	}

 	saved_errno = errno;

 	mlog(MLOG_NORMAL,
 	      _("syssgi( SGI_FS_BULKSTAT ) on fsroot failed: %s\n"),
 	      strerror(saved_errno));

 	return saved_errno;
 }

 /* ARGSUSED */
 int
 bigstat_one(int fsfd,
 	     xfs_ino_t ino,
 	     xfs_bstat_t *statp)
 {
         xfs_fsop_bulkreq_t bulkreq;
 	int count = 0;

 	assert(ino > 0);
         bulkreq.lastip = (__u64 *)&ino;
         bulkreq.icount = 1;
         bulkreq.ubuffer = statp;
         bulkreq.ocount = &count;
 	return xfsctl(NULL, fsfd, XFS_IOC_FSBULKSTAT_SINGLE, &bulkreq);
 }

 /* call the given callback for each inode group in the filesystem.
  */
 #define INOGRPLEN	256
 int
 inogrp_iter(int fsfd,
 	     int (*fp)(void *arg1,
 				int fsfd,
 				xfs_inogrp_t *inogrp),
 	     void * arg1,
 	     int *statp)
 {
 	xfs_ino_t lastino;
 	int inogrpcnt;
 	xfs_inogrp_t *igrp;
         xfs_fsop_bulkreq_t bulkreq;

 	/* stat set with return from callback func */
 	*statp = 0;

 	igrp = malloc(INOGRPLEN * sizeof(xfs_inogrp_t));
 	if (!igrp) {
 		mlog(MLOG_NORMAL | MLOG_ERROR,
 		     _("malloc of stream context failed (%d bytes): %s\n"),
 		     INOGRPLEN * sizeof(xfs_inogrp_t),
 		     strerror(errno));
 		return -1;
 	}

 	lastino = 0;
 	inogrpcnt = 0;
 	bulkreq.lastip = (__u64 *)&lastino;
 	bulkreq.icount = INOGRPLEN;
 	bulkreq.ubuffer = igrp;
 	bulkreq.ocount = &inogrpcnt;
 	while (!ioctl(fsfd, XFS_IOC_FSINUMBERS, &bulkreq)) {
 		xfs_inogrp_t *p, *endp;

 		if (inogrpcnt == 0) {
 			free(igrp);
 			return 0;
 		}
 		for (p = igrp, endp = igrp + inogrpcnt; p < endp; p++) {
 			int rval;

 			rval = (*fp)(arg1, fsfd, p);
 			if (rval) {
 				*statp = rval;
 				free(igrp);
 				return 0;
 			}
 		}
 	}

 	free(igrp);
 	return errno;
 }

 /* calls the callback for every entry in the directory specified
  * by the stat buffer. supplies the callback with a file system
  * handle and a stat buffer, and the name from the dirent.
  *
  * NOTE: does NOT invoke callback for "." or ".."!
  *
  * if the callback returns non-zero, returns 1 with cbrval set to the
  * callback's return value. if syscall fails, returns -1 with errno set.
  * otherwise returns 0.
  *
  * caller may supply a dirent buffer. if not, will malloc one
  */
 int
 diriter(jdm_fshandle_t *fshandlep,
 	 int fsfd,
 	 xfs_bstat_t *statp,
 	 int (*cbfp)(void *arg1,
 			     jdm_fshandle_t *fshandlep,
 			     int fsfd,
 			     xfs_bstat_t *statp,
 			     char *namep),
 	 void *arg1,
 	 int *cbrvalp,
 	 char *usrgdp,
 	 size_t usrgdsz)
 {
 	size_t gdsz;
 	struct dirent *gdp;
 	int fd;
 	int gdcnt;
 	int scrval;
 	int cbrval;

 	if (usrgdp) {
 		assert(usrgdsz >= sizeof(struct dirent));
 		gdsz = usrgdsz;
 		gdp = (struct dirent *)usrgdp;
 	} else {
 		gdsz = pgsz;
 		gdp = (struct dirent *)malloc(gdsz);
 		assert(gdp);
 	}

 	/* open the directory
 	 */
 	fd = jdm_open(fshandlep, statp, O_RDONLY);
 	if (fd < 0) {
 		mlog(MLOG_NORMAL,
 		      _("WARNING: unable to open directory ino %llu: %s\n"),
 		      statp->bs_ino,
 		      strerror(errno));
 		*cbrvalp = 0;
 		if (!usrgdp) {
 			free((void *)gdp);
 		}
 		return -1;
 	}
 	assert((statp->bs_mode & S_IFMT) == S_IFDIR);

 	/* lots of buffering done here, to achieve OS-independence.
 	 * if proves to be to much overhead, can streamline.
 	 */
 	scrval = 0;
 	cbrval = 0;
 	for (gdcnt = 1 ; ; gdcnt++) {
 		struct dirent *p;
 		int nread;
 		register size_t reclen;

 		assert(scrval == 0);
 		assert(cbrval == 0);

 		nread = getdents_wrap(fd, (char *)gdp, gdsz);

 		/* negative count indicates something very bad happened;
 		 * try to gracefully end this dir.
 		 */
 		if (nread < 0) {
 			mlog(MLOG_NORMAL,
 			      _("WARNING: unable to read dirents (%d) for "
 			      "directory ino %llu: %s\n"),
 			      gdcnt,
 			      statp->bs_ino,
 			      strerror(errno));
 			nread = 0; /* pretend we are done */
 		}

 		/* no more directory entries: break;
 		 */
 		if (nread == 0) {
 			break;
 		}

 		/* translate and invoke cb each entry: skip "." and "..".
 		 */
 		for (p = gdp,
 		      reclen = (size_t)p->d_reclen
 		      ;
 		      nread > 0
 		      ;
 		      nread -= (int)reclen,
 		      assert(nread >= 0),
 		      p = (struct dirent *)((char *)p + reclen),
 		      reclen = (size_t)p->d_reclen) {
 			xfs_bstat_t statbuf;
 			assert(scrval == 0);
 			assert(cbrval == 0);

 			/* skip "." and ".."
 			 */
 			if (*(p->d_name + 0) == '.'
 			     &&
 			     (*(p->d_name + 1) == 0
 			       ||
 			       (*(p->d_name + 1) == '.'
 				 &&
 				 *(p->d_name + 2) == 0))) {
 				continue;
 			}

 			/* use bigstat
 			 */
 			scrval = bigstat_one(fsfd,
 					      p->d_ino,
 					      &statbuf);
 			if (scrval) {
 				mlog(MLOG_NORMAL,
 				      _("WARNING: could not stat "
 				      "dirent %s ino %llu: %s\n"),
 				      p->d_name,
 				      (xfs_ino_t)p->d_ino,
 				      strerror(errno));
 				scrval = 0;
 				continue;
 			}

 			/* if getdents64() not yet available, and ino
 			 * occupied more than 32 bits, warn and skip.
 			 */
 #ifndef __USE_LARGEFILE64
 			if (statbuf.bs_ino > (xfs_ino_t)INOMAX) {
 				mlog(MLOG_NORMAL,
 				      _("WARNING: unable to process dirent %s: "
 				      "ino %llu too large\n"),
 				      p->d_name,
 				      (xfs_ino_t)p->d_ino);
 				continue;
 			}
 #endif

 			/* invoke the callback
 			 */
 			cbrval = (*cbfp)(arg1,
 					     fshandlep,
 					     fsfd,
 					     &statbuf,
 					     p->d_name);

 			/* abort the iteration if the callback returns non-zero
 			 */
 			if (cbrval) {
 				break;
 			}
 		}

 		if (scrval || cbrval) {
 			break;
 		}
 	}

 	(void)close(fd);
 	if (!usrgdp) {
 		free((void *)gdp);
 	}

 	if (scrval) {
 		*cbrvalp = 0;
 		return -1;
 	} else if (cbrval) {
 		*cbrvalp = cbrval;
 		return 1;
 	} else {
 		*cbrvalp = 0;
 		return 0;
 	}
 }

 int
 cvtnum(int blocksize, char *s)
 {
 	int i;
 	char *sp;

 	i = (int)strtoll(s, &sp, 0);
 	if (i == 0 && sp == s)
 		return -1;
 	if (*sp == '\0')
 		return i;
 	if (*sp == 'b' && blocksize && sp[1] == '\0')
 		return i * blocksize;
 	if (*sp == 'k' && sp[1] == '\0')
 		return 1024 * i;
 	if (*sp == 'm' && sp[1] == '\0')
 		return 1024 * 1024 * i;
 	return -1;
 }
	/*
	* Copyright (c) 2000-2002 Silicon Graphics, Inc.
	* All Rights Reserved.
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU General Public License as
	* published by the Free Software Foundation.
	*
	* This program is distributed in the hope that it would be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*
	* You should have received a copy of the GNU General Public License
	* along with this program; if not, write the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	*/

	#include <unistd.h>
	#include <stdlib.h>
	#include <sys/stat.h>
	#include <sys/ioctl.h>
	#include <fcntl.h>
	#include <errno.h>
	#include <dirent.h>
	#include <assert.h>
	#include <string.h>
	#include <xfs/xfs.h>
	#include <xfs/jdm.h>

	#include "config.h"

	#include "types.h"
	#include "util.h"
	#include "mlog.h"
	#include "getdents.h"

	extern size_t pgsz;

	int
	write_buf(char *bufp,
	size_t bufsz,
	void *contextp,
	gwbfp_t get_write_buf_funcp,
	wfp_t write_funcp)
	{
	char mbufp; / buffer obtained from manager */
	size_t mbufsz;/* size of buffer obtained from manager */

	while (bufsz) {
	int rval;

	assert(bufsz > 0);
	mbufp = (*get_write_buf_funcp)(contextp, bufsz, &mbufsz);
	assert(mbufsz <= bufsz);
	if (bufp) {
	(void)memcpy((void )mbufp, (void )bufp, mbufsz);
	} else {
	(void)memset((void *)mbufp, 0, mbufsz);
	}
	rval = (*write_funcp)(contextp, mbufp, mbufsz);
	if (rval) {
	return rval;
	}
	if (bufp) {
	bufp += mbufsz;
	}
	bufsz -= mbufsz;
	}

	return 0;
	}

	int
	read_buf(char *bufp,
	size_t bufsz,
	void *contextp,
	rfp_t read_funcp,
	rrbfp_t return_read_buf_funcp,
	int *statp)
	{
	char mbufp; / manager's buffer pointer */
	size_t mbufsz; /* size of manager's buffer */
	int nread;

	nread = 0;
	*statp = 0;
	while (bufsz) {
	mbufp = (*read_funcp)(contextp, bufsz, &mbufsz, statp);
	if (*statp) {
	break;
	}
	assert(mbufsz <= bufsz);
	if (bufp) {
	(void)memcpy((void )bufp, (void )mbufp, mbufsz);
	bufp += mbufsz;
	}
	bufsz -= mbufsz;
	nread += (int)mbufsz;
	(*return_read_buf_funcp)(contextp, mbufp, mbufsz);
	}

	return nread;
	}

	char
	strncpyterm(char s1, char *s2, size_t n)
	{
	char *rval;

	if (n < 1) return 0;
	rval = strncpy(s1, s2, n);
	s1[n - 1] = 0;
	return rval;
	}

	int
	bigstat_iter(jdm_fshandle_t *fshandlep,
	int fsfd,
	int selector,
	xfs_ino_t start_ino,
	bstat_cbfp_t fp,
	void * cb_arg1,
	bstat_seekfp_t seekfp,
	void * seek_arg1,
	int *statp,
	bool_t (pfp)(int),
	xfs_bstat_t *buf,
	size_t buflenin)
	{
	__s32 buflenout;
	xfs_ino_t lastino;
	int saved_errno;
	int bulkstatcnt;
	xfs_fsop_bulkreq_t bulkreq;

	/* stat set with return from callback func
	*/
	*statp = 0;

	/* NOT COOL: open will affect root dir's access time
	*/

	mlog(MLOG_NITTY,
	"bulkstat iteration initiated: start_ino == %llu\n",
	start_ino);

	/* quirk of the interface: I want to play in terms of the
	* ino to begin with, and ino 0 is not used. so, ...
	*/
	if (start_ino > 0) {
	lastino = start_ino - 1;
	} else {
	lastino = 0;
	}
	mlog(MLOG_NITTY + 1,
	"calling bulkstat\n");

	bulkstatcnt = 0;
	bulkreq.lastip = (__u64 *)&lastino;
	bulkreq.icount = buflenin;
	bulkreq.ubuffer = buf;
	bulkreq.ocount = &buflenout;
	while (!ioctl(fsfd, XFS_IOC_FSBULKSTAT, &bulkreq)) {
	xfs_bstat_t *p;
	xfs_bstat_t *endp;

	if (buflenout == 0) {
	mlog(MLOG_NITTY + 1,
	"bulkstat returns buflen %d\n",
	buflenout);
	return 0;
	}
	mlog(MLOG_NITTY + 1,
	"bulkstat returns buflen %d ino %llu\n",
	buflenout,
	buf->bs_ino);
	for (p = buf, endp = buf + buflenout; p < endp; p++) {
	int rval;

	if (p->bs_ino == 0)
	continue;

	if (!p->bs_nlink \|\| !p->bs_mode) {
	/* inode being modified, get synced data */
	mlog(MLOG_NITTY + 1,
	"ino %llu needed second bulkstat\n",
	p->bs_ino);

	if(bigstat_one(fsfd, p->bs_ino, p) < 0) {
	mlog(MLOG_WARNING,
	_("failed to get bulkstat information for inode %llu\n"),
	p->bs_ino);
	continue;
	}
	if (!p->bs_nlink \|\| !p->bs_mode \|\| !p->bs_ino) {
	mlog(MLOG_TRACE,
	_("failed to get valid bulkstat information for inode %llu\n"),
	p->bs_ino);
	continue;
	}
	}

	if ((p->bs_mode & S_IFMT) == S_IFDIR) {
	if (!(selector & BIGSTAT_ITER_DIR)){
	continue;
	}
	} else {
	if (!(selector & BIGSTAT_ITER_NONDIR)){
	continue;
	}
	}
	rval = (*fp)(cb_arg1, fshandlep, fsfd, p);
	if (rval) {
	*statp = rval;
	return 0;
	}
	if (pfp) (pfp)(PREEMPT_PROGRESSONLY);
	}

	if (pfp && (++bulkstatcnt % 10) == 0 &&
	(pfp)(PREEMPT_FULL)) {
	return EINTR;
	}

	if (seekfp) {
	lastino = seekfp(seek_arg1, lastino);
	if (lastino == INO64MAX) {
	mlog(MLOG_DEBUG,
	"bulkstat seeked to EOS\n");
	return 0;
	}

	mlog(MLOG_DEBUG,
	"bulkstat seeked to %llu\n", lastino);

	lastino = (lastino > 0) ? lastino - 1 : 0;
	}

	mlog(MLOG_NITTY + 1,
	"calling bulkstat\n");
	}

	saved_errno = errno;

	mlog(MLOG_NORMAL,
	_("syssgi( SGI_FS_BULKSTAT ) on fsroot failed: %s\n"),
	strerror(saved_errno));

	return saved_errno;
	}

	/* ARGSUSED */
	int
	bigstat_one(int fsfd,
	xfs_ino_t ino,
	xfs_bstat_t *statp)
	{
	xfs_fsop_bulkreq_t bulkreq;
	int count = 0;

	assert(ino > 0);
	bulkreq.lastip = (__u64 *)&ino;
	bulkreq.icount = 1;
	bulkreq.ubuffer = statp;
	bulkreq.ocount = &count;
	return xfsctl(NULL, fsfd, XFS_IOC_FSBULKSTAT_SINGLE, &bulkreq);
	}

	/* call the given callback for each inode group in the filesystem.
	*/
	#define INOGRPLEN 256
	int
	inogrp_iter(int fsfd,
	int (fp)(void arg1,
	int fsfd,
	xfs_inogrp_t *inogrp),
	void * arg1,
	int *statp)
	{
	xfs_ino_t lastino;
	int inogrpcnt;
	xfs_inogrp_t *igrp;
	xfs_fsop_bulkreq_t bulkreq;

	/* stat set with return from callback func */
	*statp = 0;

	igrp = malloc(INOGRPLEN * sizeof(xfs_inogrp_t));
	if (!igrp) {
	mlog(MLOG_NORMAL \| MLOG_ERROR,
	_("malloc of stream context failed (%d bytes): %s\n"),
	INOGRPLEN * sizeof(xfs_inogrp_t),
	strerror(errno));
	return -1;
	}

	lastino = 0;
	inogrpcnt = 0;
	bulkreq.lastip = (__u64 *)&lastino;
	bulkreq.icount = INOGRPLEN;
	bulkreq.ubuffer = igrp;
	bulkreq.ocount = &inogrpcnt;
	while (!ioctl(fsfd, XFS_IOC_FSINUMBERS, &bulkreq)) {
	xfs_inogrp_t p, endp;

	if (inogrpcnt == 0) {
	free(igrp);
	return 0;
	}
	for (p = igrp, endp = igrp + inogrpcnt; p < endp; p++) {
	int rval;

	rval = (*fp)(arg1, fsfd, p);
	if (rval) {
	*statp = rval;
	free(igrp);
	return 0;
	}
	}
	}

	free(igrp);
	return errno;
	}

	/* calls the callback for every entry in the directory specified
	* by the stat buffer. supplies the callback with a file system
	* handle and a stat buffer, and the name from the dirent.
	*
	* NOTE: does NOT invoke callback for "." or ".."!
	*
	* if the callback returns non-zero, returns 1 with cbrval set to the
	* callback's return value. if syscall fails, returns -1 with errno set.
	* otherwise returns 0.
	*
	* caller may supply a dirent buffer. if not, will malloc one
	*/
	int
	diriter(jdm_fshandle_t *fshandlep,
	int fsfd,
	xfs_bstat_t *statp,
	int (cbfp)(void arg1,
	jdm_fshandle_t *fshandlep,
	int fsfd,
	xfs_bstat_t *statp,
	char *namep),
	void *arg1,
	int *cbrvalp,
	char *usrgdp,
	size_t usrgdsz)
	{
	size_t gdsz;
	struct dirent *gdp;
	int fd;
	int gdcnt;
	int scrval;
	int cbrval;

	if (usrgdp) {
	assert(usrgdsz >= sizeof(struct dirent));
	gdsz = usrgdsz;
	gdp = (struct dirent *)usrgdp;
	} else {
	gdsz = pgsz;
	gdp = (struct dirent *)malloc(gdsz);
	assert(gdp);
	}

	/* open the directory
	*/
	fd = jdm_open(fshandlep, statp, O_RDONLY);
	if (fd < 0) {
	mlog(MLOG_NORMAL,
	_("WARNING: unable to open directory ino %llu: %s\n"),
	statp->bs_ino,
	strerror(errno));
	*cbrvalp = 0;
	if (!usrgdp) {
	free((void *)gdp);
	}
	return -1;
	}
	assert((statp->bs_mode & S_IFMT) == S_IFDIR);

	/* lots of buffering done here, to achieve OS-independence.
	* if proves to be to much overhead, can streamline.
	*/
	scrval = 0;
	cbrval = 0;
	for (gdcnt = 1 ; ; gdcnt++) {
	struct dirent *p;
	int nread;
	register size_t reclen;

	assert(scrval == 0);
	assert(cbrval == 0);

	nread = getdents_wrap(fd, (char *)gdp, gdsz);

	/* negative count indicates something very bad happened;
	* try to gracefully end this dir.
	*/
	if (nread < 0) {
	mlog(MLOG_NORMAL,
	_("WARNING: unable to read dirents (%d) for "
	"directory ino %llu: %s\n"),
	gdcnt,
	statp->bs_ino,
	strerror(errno));
	nread = 0; /* pretend we are done */
	}

	/* no more directory entries: break;
	*/
	if (nread == 0) {
	break;
	}

	/* translate and invoke cb each entry: skip "." and "..".
	*/
	for (p = gdp,
	reclen = (size_t)p->d_reclen
	;
	nread > 0
	;
	nread -= (int)reclen,
	assert(nread >= 0),
	p = (struct dirent )((char )p + reclen),
	reclen = (size_t)p->d_reclen) {
	xfs_bstat_t statbuf;
	assert(scrval == 0);
	assert(cbrval == 0);

	/* skip "." and ".."
	*/
	if (*(p->d_name + 0) == '.'
	&&
	(*(p->d_name + 1) == 0
	\|\|
	(*(p->d_name + 1) == '.'
	&&
	*(p->d_name + 2) == 0))) {
	continue;
	}

	/* use bigstat
	*/
	scrval = bigstat_one(fsfd,
	p->d_ino,
	&statbuf);
	if (scrval) {
	mlog(MLOG_NORMAL,
	_("WARNING: could not stat "
	"dirent %s ino %llu: %s\n"),
	p->d_name,
	(xfs_ino_t)p->d_ino,
	strerror(errno));
	scrval = 0;
	continue;
	}

	/* if getdents64() not yet available, and ino
	* occupied more than 32 bits, warn and skip.
	*/
	#ifndef __USE_LARGEFILE64
	if (statbuf.bs_ino > (xfs_ino_t)INOMAX) {
	mlog(MLOG_NORMAL,
	_("WARNING: unable to process dirent %s: "
	"ino %llu too large\n"),
	p->d_name,
	(xfs_ino_t)p->d_ino);
	continue;
	}
	#endif

	/* invoke the callback
	*/
	cbrval = (*cbfp)(arg1,
	fshandlep,
	fsfd,
	&statbuf,
	p->d_name);

	/* abort the iteration if the callback returns non-zero
	*/
	if (cbrval) {
	break;
	}
	}

	if (scrval \|\| cbrval) {
	break;
	}
	}

	(void)close(fd);
	if (!usrgdp) {
	free((void *)gdp);
	}

	if (scrval) {
	*cbrvalp = 0;
	return -1;
	} else if (cbrval) {
	*cbrvalp = cbrval;
	return 1;
	} else {
	*cbrvalp = 0;
	return 0;
	}
	}

	int
	cvtnum(int blocksize, char *s)
	{
	int i;
	char *sp;

	i = (int)strtoll(s, &sp, 0);
	if (i == 0 && sp == s)
	return -1;
	if (*sp == '\0')
	return i;
	if (*sp == 'b' && blocksize && sp[1] == '\0')
	return i * blocksize;
	if (*sp == 'k' && sp[1] == '\0')
	return 1024 * i;
	if (*sp == 'm' && sp[1] == '\0')
	return 1024 * 1024 * i;
	return -1;
	}