Return to configure.in CVS log

Up to [Development] / xfs-cmds / dmapi

dm_handle_to_path() will now work in most cases, and in the other cases
there's just a little more grunt work that has to be done in the library.  If
the directory that contains some component of the path has never had a lookup
performed on it, then the kernel won't have that dir in its dcache.  In that
case it'll create an anonymous dentry for the filesystem's root dir, and the
library detects that this happened.

If the library detects that an anonymous dentry was created, then it returns
an error indicating that it didn't find the path.  Before I take this another
step, I'd like to know if this scenario happens in actual practice.  I'm
betting the directory of interest has almost always been loaded into the
dcache by a user process before the HSM uses dm_handle_to_path().  We'll see.

It seems that ioctl(XFS_IOC_OPEN_BY_HANDLE) would have the same restriction,
though it looks like it's never used in a case where the path hasn't already
been accessed.

This mod also removes libdm's dependence on libhandle.
Remove check for libhandle.

dnl unpacking check - this file must exist
AC_INIT(include/dmapi.h)
pkg_name="dmapi"
AC_SUBST(pkg_name)

#
# Note: the following environment variables may be set to override the
# defaults (to change paths and/or executables, build parameters, etc):
#
#   DEBUG  OPTIMIZER  MAKE  CC  LD  TAR  ZIP  RPM  AWK  SED  ECHO
#   MALLOCLIB  DISTRIBUTION  PACKAGE_BUILDER  PREFIX  ROOT_PREFIX
#

DEBUG=${DEBUG:-'-DDEBUG'}		# -DNDEBUG
OPTIMIZER=${OPTIMIZER:-'-g'}		# -O2
MALLOCLIB=${MALLOCLIB:-''}		# /usr/lib/libefence.a

dnl Debug build?
debug_build="$DEBUG"
AC_SUBST(debug_build)

dnl Optimization options?
opt_build="$OPTIMIZER"
AC_SUBST(opt_build)

dnl Alternate malloc library?
malloc_lib="$MALLOCLIB"
AC_SUBST(malloc_lib)

dnl Set version
. ./VERSION

pkg_version=${PKG_MAJOR}.${PKG_MINOR}.${PKG_REVISION}
pkg_release=$PKG_BUILD
AC_SUBST(pkg_version)
AC_SUBST(pkg_release)

pkg_distribution="SGI XFS"
test -z "$DISTRIBUTION" || pkg_distribution="$DISTRIBUTION"
AC_SUBST(pkg_distribution)

pkg_builder=`id -u -n`@`hostname`
test -z "$PACKAGE_BUILDER" || pkg_builder="$PACKAGE_BUILDER"
AC_SUBST(pkg_builder)

dnl check if user wants their own C compiler
test -z "$CC" && AC_PROG_CC
cc=$CC
AC_SUBST(cc)

dnl check if users wants their own make
test -z "$MAKE" && AC_PATH_PROG(MAKE, make, /usr/bin/make)
make=$MAKE
AC_SUBST(make)

dnl check if users wants their own linker
test -z "$LD" && AC_PATH_PROG(LD, ld, /usr/bin/ld)
ld=$LD
AC_SUBST(ld)

dnl check if the tar program is available
test -z "$TAR" && AC_PATH_PROG(TAR, tar)
tar=$TAR
AC_SUBST(tar)

dnl check if the gzip program is available
test -z "$ZIP" && AC_PATH_PROG(ZIP, gzip, /bin/gzip)
zip=$ZIP
AC_SUBST(zip)

dnl check if the rpm program is available
test -z "$RPM" && AC_PATH_PROG(RPM, rpm, /bin/rpm)
rpm=$RPM
AC_SUBST(rpm)

dnl .. and what version is rpm
rpm_version=0
test -x $RPM && \
	rpm_version=`$RPM --version | awk '{print $NF}' | awk -F. '{print $1}'`
AC_SUBST(rpm_version)

dnl check if the makedepend program is available
test -z "$MAKEDEPEND" && AC_PATH_PROG(MAKEDEPEND, makedepend, /bin/true)
makedepend=$MAKEDEPEND
AC_SUBST(makedepend)

dnl check if symbolic links are supported
AC_PROG_LN_S

dnl check if user wants their own awk, sed and echo
test -z "$AWK" && AC_PATH_PROG(AWK, awk, /bin/awk)
awk=$AWK
AC_SUBST(awk)
test -z "$SED" && AC_PATH_PROG(SED, sed, /bin/sed)
sed=$SED
AC_SUBST(sed)
test -z "$ECHO" && AC_PATH_PROG(ECHO, echo, /bin/echo)
echo=$ECHO
AC_SUBST(echo)

AC_CHECK_HEADER(xfs/handle.h,, [
	echo
	echo 'FATAL ERROR: could not find a valid XFS handle header.'
	echo 'Install either the xfsprogs-devel (rpm) or the xfslibs-dev (deb) package.'
	echo 'Alternatively, run "make install-dev" from the xfsprogs source.'
	exit 1
])

dnl ensure libtool is installed
AC_PATH_PROG(LIBTOOL, libtool,,/usr/bin)
if test "$LIBTOOL" = ""; then
	echo
	echo 'FATAL ERROR: libtool does not seem to be installed.'
	echo $pkg_name cannot be built without a working libtool installation.
	exit 1
fi
libtool=$LIBTOOL
AC_SUBST(libtool)

dnl libtool to build libraries static only?
AC_ARG_ENABLE(shared,
	[ --enable-shared=[yes/no]	Enable use of shared libraries [default=yes].],
	,
	enable_shared=yes)
AC_SUBST(enable_shared)

dnl alternate root and usr prefixes
test -z "$ROOT_PREFIX" && ROOT_PREFIX=""
root_prefix="$ROOT_PREFIX"
test -z "$PREFIX" && PREFIX="/usr"
prefix="$PREFIX"

dnl man pages (source)
dnl also check if man page source is gzipped
dnl (usually on Debian, but not Redhat pre-7.0)
pkg_man_dir=${prefix}/share/man
have_zipped_manpages=false
for d in ${prefix}/share/man ${prefix}/man ; do
    if test -f $d/man1/man.1.gz
    then
	pkg_man_dir=$d
	have_zipped_manpages=true
	break
    fi
done
AC_SUBST(pkg_man_dir)
AC_SUBST(have_zipped_manpages)

dnl binaries
pkg_bin_dir=${prefix}/bin
AC_SUBST(pkg_bin_dir)

dnl static libraries
pkg_lib_dir=${prefix}/lib
AC_SUBST(pkg_lib_dir)

dnl runtime shared system libraries
pkg_slib_dir=${root_prefix}/lib
AC_SUBST(pkg_slib_dir)

dnl system binaries
pkg_sbin_dir=${root_prefix}/bin
AC_SUBST(pkg_sbin_dir)

dnl include files
pkg_inc_dir=${prefix}/include/xfs
AC_SUBST(pkg_inc_dir)

dnl doc directory
pkg_doc_dir=${prefix}/share/doc/${pkg_name}
AC_SUBST(pkg_doc_dir)


dnl
dnl output files
dnl

AC_OUTPUT( \
dnl  Build definitions for use in Makefiles
    include/builddefs \
)