Index: head/emulators/virtualbox-ose/Makefile =================================================================== --- head/emulators/virtualbox-ose/Makefile (revision 446840) +++ head/emulators/virtualbox-ose/Makefile (revision 446841) @@ -1,437 +1,437 @@ # Created by: Bernhard Froehlich # $FreeBSD$ PORTNAME= virtualbox-ose -PORTVERSION= 5.1.24 +PORTVERSION= 5.1.26 CATEGORIES= emulators MASTER_SITES= http://download.virtualbox.org/virtualbox/${PORTVERSION}/ DISTFILES= VirtualBox-${PORTVERSION}${EXTRACT_SUFX} ${GUESTADDITIONS} EXTRACT_ONLY= VirtualBox-${PORTVERSION}${EXTRACT_SUFX} MAINTAINER= vbox@FreeBSD.org COMMENT= General-purpose full virtualizer for x86 hardware LICENSE= GPLv2 LICENSE_FILE= ${WRKSRC}/COPYING BUILD_DEPENDS= yasm:devel/yasm \ xsltproc:textproc/libxslt \ kmk:devel/kBuild \ gtar:archivers/gtar \ cdrecord:sysutils/cdrtools LIB_DEPENDS= libpng.so:graphics/png \ libxslt.so:textproc/libxslt \ libcurl.so:ftp/curl RUN_DEPENDS= ${LOCALBASE}/etc/rc.d/vboxnet:emulators/virtualbox-ose-kmod \ cdrecord:sysutils/cdrtools CPE_VENDOR= oracle CPE_PRODUCT= vm_virtualbox WRKSRC= ${WRKDIR}/VirtualBox-${PORTVERSION} ONLY_FOR_ARCHS= i386 amd64 USES= compiler cpe iconv pkgconfig ssl tar:bzip2 USE_GNOME= libidl libxml2 HAS_CONFIGURE= yes CONFIGURE_ARGS= --disable-java --passive-mesa CONFIGURE_ARGS+= --with-gcc="${CC}" --with-g++="${CXX}" CONFLICTS_INSTALL= virtualbox-ose-additions-* \ virtualbox-ose-devel-[0-9]* \ virtualbox-ose-legacy-[0-9]* \ virtualbox-ose-lite-[0-9]* VBOXUSER?= vboxusers VBOXWSUSER?= vboxusers VBOXGROUP?= vboxusers USERS= ${VBOXUSER} GROUPS= ${VBOXGROUP} VBOX_DIR= ${PREFIX}/${VBOX_DIR_REL} VBOX_DIR_REL= lib/virtualbox VBOX_LINKS= VBoxVRDP VBOX_PROGS= VBoxAutostart VBoxBalloonCtrl VBoxBugReport VBoxHeadless \ VBoxManage VBOX_UTILS= VBoxExtPackHelperApp VBoxNetAdpCtl VBoxNetDHCP VBoxNetNAT \ VBoxSVC VBoxXPCOMIPCD OPTIONS_DEFINE= ALSA DBUS DEBUG GUESTADDITIONS MANUAL NLS PULSEAUDIO \ PYTHON R0LOGGING UDPTUNNEL VDE VNC WEBSERVICE VPX X11 OPTIONS_DEFAULT= DBUS QT5 UDPTUNNEL VNC WEBSERVICE X11 OPTIONS_RADIO= GUI OPTIONS_RADIO_GUI= QT4 QT5 OPTIONS_SUB= yes DEBUG_DESC= Debug symbols, additional logs and assertions GUESTADDITIONS_DESC= Build with Guest Additions MANUAL_DESC= Build with user manual QT4_DESC= Build with QT4 Frontend QT5_DESC= Build with QT5 Frontend R0LOGGING_DESC= Enable R0 logging UDPTUNNEL_DESC= Build with UDP tunnel support VDE_DESC= Build with VDE support VNC_DESC= Build with VNC support VPX_DESC= Use vpx for video capturing WEBSERVICE_DESC= Build Webservice ALSA_CONFIGURE_OFF= --disable-alsa ALSA_LIB_DEPENDS= libasound.so:audio/alsa-lib DBUS_CONFIGURE_OFF= --disable-dbus DBUS_LIB_DEPENDS= libdbus-1.so:devel/dbus DEBUG_CONFIGURE_ON= --build-debug MANUAL_BUILD_DEPENDS= ${LOCALBASE}/share/xml/docbook/4.4/docbookx.dtd:textproc/docbook-xml MANUAL_CONFIGURE_OFF= --disable-docs PULSEAUDIO_CONFIGURE_OFF= --disable-pulse PULSEAUDIO_LIB_DEPENDS= libpulse.so:audio/pulseaudio PYTHON_CONFIGURE_OFF= --disable-python UDPTUNNEL_CONFIGURE_OFF= --disable-udptunnel VDE_CONFIGURE_ON= --enable-vde VDE_RUN_DEPENDS= vde_switch:net/vde2 VNC_CONFIGURE_ON= --enable-vnc VNC_LIB_DEPENDS= libvncserver.so:net/libvncserver VPX_CONFIGURE_OFF= --disable-libvpx VPX_LIB_DEPENDS= libvpx.so:multimedia/libvpx X11_CONFIGURE_OFF= --build-headless ENV= .export ENV PLIST_SUB= GUEST_VER=${PORTVERSION} \ PYTHON_VERU=${PYTHON_VER:S/./_/}${PYTHON_ABIVER} \ VBOXGROUP=${VBOXGROUP} SUB_LIST= VBOXDIR=${VBOX_DIR} \ VBOXGROUP=${VBOXGROUP} \ VBOXUSER=${VBOXUSER} \ VBOXWSUSER=${VBOXWSUSER} USE_RC_SUBR= vboxheadless vboxwatchdog .include .if ${OPSYS}${OSREL:R} == FreeBSD12 BUILD_DEPENDS+= ${LOCALBASE}/bin/ar:devel/binutils .endif .if ${SLAVE_PORT} == no CONFLICTS_INSTALL+= virtualbox-ose-nox11-[0-9]* OPTIONS_DEFAULT+= PYTHON .else CONFLICTS_INSTALL+= virtualbox-ose-[0-9]* .endif .if ${ARCH} == "amd64" _ELF32!= kldstat -q -m elf32 && echo yes || echo no .endif .if ${PORT_OPTIONS:MNLS} && empty(PORT_OPTIONS:MQT[45]) BROKEN= NLS support requires QT frontend. Run 'make config' again! .endif .if ${PORT_OPTIONS:MQT[45]} && empty(PORT_OPTIONS:MX11) BROKEN= QT frontend requires X11 support. Run 'make config' again! .endif .if ${PORT_OPTIONS:MDEBUG} KMK_BUILDTYPE= debug KMK_FLAGS+= BUILD_TYPE=debug .else KMK_BUILDTYPE= release .endif .if ${PORT_OPTIONS:MR0LOGGING} && empty(PORT_OPTIONS:MDEBUG) BROKEN= R0 logging requires debug build .endif .if ${PORT_OPTIONS:MGUESTADDITIONS} GUESTADDITIONS= VBoxGuestAdditions_${PORTVERSION}.iso RESTRICTED= for personal use only RESTRICTED_FILES= ${GUESTADDITIONS} .endif .if ${PORT_OPTIONS:MMANUAL} DBKXMLDIR= ${LOCALBASE}/share/xml/docbook/4.4 DBKXSLDIR= ${LOCALBASE}/share/xsl/docbook USE_TEX= dvipsk:build formats:build .endif .if ${PORT_OPTIONS:MPYTHON} USES+= python USE_PYTHON= distutils noegginfo PYDISTUTILS_PKGNAME= vboxapi PYDISTUTILS_PKGVERSION= 1.0 .else USES+= python:build .endif .if ${PORT_OPTIONS:MQT[45]} PLIST_SUB+= QT="" QT_NONSTANDARD= yes USE_GL= gl USE_XORG= xcb INSTALLS_ICONS= yes VBOX_PROGS+= VirtualBox VBOX_UTILS+= VBoxTestOGL VBOX_WITH_QT= 1 .if ${PORT_OPTIONS:MQT4} EXTRA_PATCHES+= ${PATCHDIR}/extrapatch-src_VBox_Frontends_VirtualBox_src_net_UIDownloaderAdditions.cpp \ ${PATCHDIR}/extrapatch-src_VBox_Frontends_VirtualBox_src_net_UIDownloaderExtensionPack.cpp \ ${PATCHDIR}/extrapatch-src_VBox_Frontends_VirtualBox_src_settings_global_UIGlobalSettingsNetworkDetailsHost.cpp \ ${PATCHDIR}/extrapatch-src_VBox_Frontends_VirtualBox_src_widgets_UIMiniToolBar.cpp \ ${PATCHDIR}/extrapatch-src_VBox_Frontends_VirtualBox_src_widgets_UIMiniToolBar.h CONFIGURE_ARGS+= --enable-qt4 USE_QT4= corelib gui linguist_build moc_build network opengl USE_QT4+= rcc_build uic_build WARNING= "Qt4 support has been deprecated by the upstream.\ This option may be removed in the future without notice." .else CONFIGURE_ARGS+= --enable-qt5 USE_QT5= buildtools_build core dbus gui linguist_build opengl USE_QT5+= printsupport widgets x11extras .endif .else CONFIGURE_ARGS+= --disable-qt PLIST_SUB+= QT="@comment " .endif .if ${PORT_OPTIONS:MWEBSERVICE} BUILD_DEPENDS+= soapcpp2:devel/gsoap USE_RC_SUBR+= vboxwebsrv VBOX_LINKS+= vboxwebsrv VBOX_UTILS+= vboxwebsrv webtest .endif .if ${PORT_OPTIONS:MX11} USE_SDL= sdl USE_XORG+= inputproto x11 xcursor xext xinerama xmu xt VBOX_PROGS+= VBoxSDL .endif .if ${PORT_OPTIONS:MPYTHON} || ${PORT_OPTIONS:MWEBSERVICE} PLIST_SUB+= SDK="" .else PLIST_SUB+= SDK="@comment " .endif .if ${ARCH} == i386 KMK_ARCH= freebsd.x86 PLIST_SUB+= I386="" .else KMK_ARCH= freebsd.${ARCH} PLIST_SUB+= I386="@comment " .endif PLIST_SUB+= ARCH="${KMK_ARCH}" KMK_BUILDDIR= ${WRKSRC}/out/${KMK_ARCH}/${KMK_BUILDTYPE} KMK_CONFIG= VBOX_LIBPATH_X11=${LOCALBASE} VBOX_FREEBSD_SRC=${SRC_BASE}/sys KMK_FLAGS+= -j${MAKE_JOBS_NUMBER} .include .if ${COMPILER_TYPE} == clang PATCH_DEPENDS+= ${LOCALBASE}/share/kBuild/tools/GXX3.kmk:devel/kBuild EXTRA_PATCHES+= ${PATCHDIR}/extrapatch-Config.kmk \ ${PATCHDIR}/extrapatch-src-VBox-Devices-PC-ipxe-Makefile.kmk \ ${PATCHDIR}/extrapatch-src-recompiler-Makefile.kmk .endif .if ${PYTHON_MAJOR_VER} >= 3 PLIST_SUB+= PYTHON_PYCDIR=/__pycache__/ \ PYTHON_PYCEXT=.cpython-${PYTHON_SUFFIX}.pyc .else PLIST_SUB+= PYTHON_PYCDIR=/ \ PYTHON_PYCEXT=.pyc .endif .if ${SSL_DEFAULT} != base CONFIGURE_ARGS+= --with-openssl-dir="${OPENSSLBASE}" .endif pre-everything:: .if ${ARCH} == "amd64" .if ${_ELF32} != yes @${ECHO} 'Requires 32-bit runtime support in kernel.' @${ECHO} 'Rebuild kernel with "options COMPAT_FREEBSD32" and reboot.' @${FALSE} .elif !exists(/usr/lib32/libc.so) @${ECHO} 'Requires 32-bit libraries installed under /usr/lib32.' @${ECHO} 'Do: cd /usr/src; make build32 install32; service ldconfig restart' @${FALSE} .endif .endif post-patch: @${ECHO} 'VBOX_PATH_APP_PRIVATE_ARCH = ${VBOX_DIR}' > \ ${WRKSRC}/LocalConfig.kmk @${ECHO} 'VBOX_PATH_DOCBOOK = ${DBKXSLDIR}' >> \ ${WRKSRC}/LocalConfig.kmk @${ECHO} 'VBOX_PATH_DOCBOOK_DTD = ${DBKXMLDIR}' >> \ ${WRKSRC}/LocalConfig.kmk @${ECHO} 'VBOX_PATH_SHARED_LIBS = ${VBOX_DIR}' >> \ ${WRKSRC}/LocalConfig.kmk @${ECHO} 'VBOX_WITH_RUNPATH = ${VBOX_DIR}' >> \ ${WRKSRC}/LocalConfig.kmk @${ECHO} 'VBOX_PATH_APP_PRIVATE = ${DATADIR}' >> \ ${WRKSRC}/LocalConfig.kmk @${ECHO} 'VBOX_PATH_APP_DOCS = ${DOCSDIR}' >> ${WRKSRC}/LocalConfig.kmk .if ${SSL_DEFAULT} != base @${ECHO} 'VBOX_WITH_ALT_HASH_CODE = 1' >> ${WRKSRC}/LocalConfig.kmk .endif @${ECHO} 'VBOX_WITH_EXTPACK_VBOXDTRACE =' >> ${WRKSRC}/LocalConfig.kmk @${ECHO} 'VBOX_WITH_INSTALLER = 1' >> ${WRKSRC}/LocalConfig.kmk @${ECHO} 'VBOX_WITH_VBOXDRV =' >> ${WRKSRC}/LocalConfig.kmk @${ECHO} 'VBOX_WITH_TESTCASES =' >> ${WRKSRC}/LocalConfig.kmk @${ECHO} 'SDK_VBOX_LIBPNG_INCS = ${PREFIX}/include/libpng' >> \ ${WRKSRC}/LocalConfig.kmk @${ECHO} 'SDK_VBOX_LIBPNG_LIBS = png' >> ${WRKSRC}/LocalConfig.kmk @${ECHO} 'VBOX_WITH_ADDITIONS =' >> ${WRKSRC}/LocalConfig.kmk @${ECHO} 'VBOX_WITH_DRAG_AND_DROP = ${VBOX_WITH_QT}' >> \ ${WRKSRC}/LocalConfig.kmk @${ECHO} 'VBOX_WITH_DRAG_AND_DROP_GH = ${VBOX_WITH_QT}' >> \ ${WRKSRC}/LocalConfig.kmk @${ECHO} 'VBOX_WITH_VALIDATIONKIT =' >> ${WRKSRC}/LocalConfig.kmk @${ECHO} 'VBOX_WITH_X11_ADDITIONS =' >> ${WRKSRC}/LocalConfig.kmk .if empty(PORT_OPTIONS:MQT5) @${ECHO} 'VBOX_WITH_QTGUI_V5 =' >> ${WRKSRC}/LocalConfig.kmk .endif .if ${PORT_OPTIONS:MR0LOGGING} @${ECHO} 'VBOX_WITH_R0_LOGGING = 1' >> ${WRKSRC}/LocalConfig.kmk .endif .if ${PORT_OPTIONS:MWEBSERVICE} @${ECHO} 'VBOX_WITH_WEBSERVICES = 1' >> ${WRKSRC}/LocalConfig.kmk @${ECHO} 'VBOX_GSOAP_INSTALLED = 1' >> ${WRKSRC}/LocalConfig.kmk @${ECHO} 'VBOX_PATH_GSOAP = ${PREFIX}/lib/gsoap' >> \ ${WRKSRC}/LocalConfig.kmk @${ECHO} 'VBOX_PATH_GSOAP_BIN = ${PREFIX}/bin' >> \ ${WRKSRC}/LocalConfig.kmk @${ECHO} 'VBOX_PATH_GSOAP_IMPORT = ${PREFIX}/share/gsoap/import' >> \ ${WRKSRC}/LocalConfig.kmk @${ECHO} 'VBOX_GCC_PEDANTIC_CXX = -Wshadow $$(VBOX_GCC_WARN) -Wno-long-long' >> \ ${WRKSRC}/LocalConfig.kmk .endif .if ${COMPILER_TYPE} == clang @${REINPLACE_CMD} -e 's| -finline-limit=8000||' \ -e 's| -mpreferred-stack-boundary=2||' ${WRKSRC}/Config.kmk @${REINPLACE_CMD} -e 's| -fpermissive||' ${WRKSRC}/Config.kmk \ ${WRKSRC}/src/VBox/Main/webservice/Makefile.kmk @${ECHO} 'VBOX_GCC_Wno-unused-parameter = -Wno-unused-parameter' >> \ ${WRKSRC}/LocalConfig.kmk @${ECHO} 'TOOL_VBoxGccFreeBSD_LD = ${CXX}' >> ${WRKSRC}/LocalConfig.kmk @${SED} -e 's|GXX3|VBoxGccFreeBSD|g' \ ${LOCALBASE}/share/kBuild/tools/GXX3.kmk > \ ${WRKSRC}/tools/kBuildTools/VBoxGccFreeBSD.kmk .endif .if ${OPSYS}${OSREL:R} == FreeBSD12 @${ECHO} 'TOOL_GXX3_AR = ${LOCALBASE}/bin/ar' >> \ ${WRKSRC}/LocalConfig.kmk .endif @${REINPLACE_CMD} -e 's|/usr/local|${LOCALBASE}|g' \ ${WRKSRC}/Config.kmk ${WRKSRC}/configure \ ${WRKSRC}/kBuild/header.kmk ${WRKSRC}/kBuild/units/qt4.kmk \ ${WRKSRC}/kBuild/units/qt5.kmk ${WRKSRC}/kBuild/sdks/LIBSDL.kmk \ ${WRKSRC}/src/libs/xpcom18a4/python/gen_python_deps.py @${REINPLACE_CMD} \ -e 's|\$$KBUILDDIR_BIN/kmk_sed|${LOCALBASE}/bin/kmk_sed|g' \ -e 's|SUPPYTHONLIBS=.*|SUPPYTHONLIBS="${PYTHON_VERSION}${PYTHON_ABIVER}"|' \ ${WRKSRC}/configure .if empty(ICONV_LIB) @${REINPLACE_CMD} -e 's|iconv||' ${WRKSRC}/Config.kmk \ ${WRKSRC}/src/VBox/Runtime/Makefile.kmk @${ECHO} 'VBOX_ICONV_DEFS = LIBICONV_PLUG' >> ${WRKSRC}/LocalConfig.kmk .endif @${REINPLACE_CMD} -e 's|/usr/local/lib/virtualbox|${VBOX_DIR}|' \ -e 's|/usr/local|${PREFIX}|' \ ${WRKSRC}/src/VBox/Installer/freebsd/VBox.sh @${REINPLACE_CMD} \ -e 's|^versions =.*|versions = ["${PYTHON_VER}${PYTHON_ABIVER}"]|' \ ${WRKSRC}/src/libs/xpcom18a4/python/gen_python_deps.py do-build: cd ${WRKSRC} && ${SH} -c '. ${WRKSRC}/env.sh && \ ${KMK_CONFIG} ${LOCALBASE}/bin/kmk ${KMK_FLAGS}' .if ${PORT_OPTIONS:MPYTHON} ${PYTHON_CMD} -mcompileall \ ${KMK_BUILDDIR}/bin/sdk/bindings/xpcom/python/xpcom .endif do-install: ${MKDIR} ${STAGEDIR}${DATADIR} cd ${KMK_BUILDDIR}/bin/sdk/bindings/xpcom && \ ${COPYTREE_SHARE} "idl samples" ${STAGEDIR}${DATADIR} ${MKDIR} ${STAGEDIR}${PREFIX}/include/virtualbox cd ${KMK_BUILDDIR}/bin/sdk/bindings/xpcom/include && \ ${COPYTREE_SHARE} "*" ${STAGEDIR}${PREFIX}/include/virtualbox ${MKDIR} ${STAGEDIR}${VBOX_DIR} cd ${KMK_BUILDDIR}/bin && ${COPYTREE_SHARE} \ "*.fd *.r0 *.rc *.so components" ${STAGEDIR}${VBOX_DIR} ${LN} -fs ${DATADIR}/sdk ${STAGEDIR}${VBOX_DIR} ${INSTALL_SCRIPT} ${WRKSRC}/src/VBox/Installer/freebsd/VBox.sh \ ${STAGEDIR}${VBOX_DIR} .for f in ${VBOX_PROGS} ${VBOX_UTILS} ${INSTALL_PROGRAM} ${KMK_BUILDDIR}/bin/${f} ${STAGEDIR}${VBOX_DIR} .endfor .for f in ${VBOX_PROGS} ${VBOX_LINKS} ${LN} -fs ../${VBOX_DIR_REL}/VBox.sh ${STAGEDIR}${PREFIX}/bin/${f} .endfor .for f in ${VBOX_PROGS} ${LN} -fs ../${VBOX_DIR_REL}/VBox.sh ${STAGEDIR}${PREFIX}/bin/${f:tl} .endfor .if ${PORT_OPTIONS:MGUESTADDITIONS} ${MKDIR} ${STAGEDIR}${VBOX_DIR}/additions ${INSTALL_DATA} ${DISTDIR}/${GUESTADDITIONS} \ ${STAGEDIR}${VBOX_DIR}/additions/ ${LN} -fs ${VBOX_DIR}/additions/${GUESTADDITIONS} \ ${STAGEDIR}${VBOX_DIR}/additions/VBoxGuestAdditions.iso .endif .if ${PORT_OPTIONS:MMANUAL} ${MKDIR} ${STAGEDIR}${DOCSDIR} ${INSTALL_DATA} ${KMK_BUILDDIR}/bin/UserManual*.pdf \ ${STAGEDIR}${DOCSDIR} .endif .if ${PORT_OPTIONS:MNLS} cd ${KMK_BUILDDIR}/obj/VirtualBox/qtnls && \ ${COPYTREE_SHARE} "*.qm" ${STAGEDIR}${DATADIR}/nls .endif .if ${PORT_OPTIONS:MPYTHON} cd ${KMK_BUILDDIR}/bin/sdk/installer && \ ${SETENV} VBOX_INSTALL_PATH="${VBOX_DIR}" \ ${PYTHON_CMD} vboxapisetup.py install --root=${STAGEDIR} @${MKDIR} ${STAGEDIR}${PYTHON_SITELIBDIR}/xpcom cd ${KMK_BUILDDIR}/bin/sdk/bindings/xpcom/python/xpcom && \ ${COPYTREE_SHARE} "*" ${STAGEDIR}${PYTHON_SITELIBDIR}/xpcom @${MKDIR} ${STAGEDIR}${DATADIR}/sdk/bindings/xpcom/python ${LN} -fs ${PYTHON_SITELIBDIR}/xpcom \ ${STAGEDIR}${DATADIR}/sdk/bindings/xpcom/python .endif .if ${PORT_OPTIONS:MQT[45]} ${INSTALL_DATA} \ ${WRKSRC}/src/VBox/Frontends/VirtualBox/images/OSE/VirtualBox_48px.png \ ${STAGEDIR}${PREFIX}/share/pixmaps/VBox.png ${INSTALL_DATA} \ ${WRKSRC}/src/VBox/Installer/freebsd/virtualbox.desktop \ ${STAGEDIR}${PREFIX}/share/applications/virtualbox.desktop .endif .if ${PORT_OPTIONS:MVNC} ${MKDIR} ${STAGEDIR}${VBOX_DIR}/ExtensionPacks/VNC/${KMK_ARCH} ${INSTALL_DATA} ${KMK_BUILDDIR}/bin/ExtensionPacks/VNC/ExtPack* \ ${STAGEDIR}${VBOX_DIR}/ExtensionPacks/VNC/ ${INSTALL_LIB} ${KMK_BUILDDIR}/bin/ExtensionPacks/VNC/${KMK_ARCH}/* \ ${STAGEDIR}${VBOX_DIR}/ExtensionPacks/VNC/${KMK_ARCH}/ .endif .if ${PORT_OPTIONS:MWEBSERVICE} ${MKDIR} ${STAGEDIR}${DATADIR}/sdk/bindings/webservice ${INSTALL_DATA} ${KMK_BUILDDIR}/obj/webservice/vboxweb.wsdl \ ${STAGEDIR}${DATADIR}/sdk/bindings/webservice/ .endif .include Index: head/emulators/virtualbox-ose/distinfo =================================================================== --- head/emulators/virtualbox-ose/distinfo (revision 446840) +++ head/emulators/virtualbox-ose/distinfo (revision 446841) @@ -1,5 +1,5 @@ -TIMESTAMP = 1500394674 -SHA256 (VirtualBox-5.1.24.tar.bz2) = ee2db169a322bf0db3c3b6d8b84aa39236f36cbf37d0a4c10ab65902a396bb60 -SIZE (VirtualBox-5.1.24.tar.bz2) = 116135442 -SHA256 (VBoxGuestAdditions_5.1.24.iso) = 01a77500df9127d8d6aa27c7d784af8f773d8e84b2b252c9e866b9038ed8bd43 -SIZE (VBoxGuestAdditions_5.1.24.iso) = 59494400 +TIMESTAMP = 1501255973 +SHA256 (VirtualBox-5.1.26.tar.bz2) = b5715035e681a11ef1475f83f9503d34a00f0276b89c572eebec363dda80c8a9 +SIZE (VirtualBox-5.1.26.tar.bz2) = 115915813 +SHA256 (VBoxGuestAdditions_5.1.26.iso) = 6df8c8ab6e7ac3a70a5e29116f8a5dcdb7dfbd0b226ef849a5cd9502e956b06f +SIZE (VBoxGuestAdditions_5.1.26.iso) = 59496448 Index: head/emulators/virtualbox-ose/files/patch-src_VBox_Additions_freebsd_vboxvfs_vboxvfs__vnops.c =================================================================== --- head/emulators/virtualbox-ose/files/patch-src_VBox_Additions_freebsd_vboxvfs_vboxvfs__vnops.c (revision 446840) +++ head/emulators/virtualbox-ose/files/patch-src_VBox_Additions_freebsd_vboxvfs_vboxvfs__vnops.c (revision 446841) @@ -1,1508 +1,1508 @@ --- src/VBox/Additions/freebsd/vboxvfs/vboxvfs_vnops.c.orig 2017-04-28 16:59:22.000000000 +0200 +++ src/VBox/Additions/freebsd/vboxvfs/vboxvfs_vnops.c 2017-07-14 14:22:09.045026515 +0200 @@ -1,10 +1,6 @@ -/* $Id: vboxvfs_vnops.c $ */ -/** @file - * Description. - */ - /* * Copyright (C) 2008-2016 Oracle Corporation + * Copyright (C) 2017 Mahdi Mokhtari * * This file is part of VirtualBox Open Source Edition (OSE), as * available from http://www.virtualbox.org. This file is free software; @@ -14,228 +9,1334 @@ * VirtualBox OSE distribution. VirtualBox OSE is distributed in the * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind. */ - -#include "vboxvfs.h" #include #include #include #include -#include +#include +#include +#include #include +#include #include -#include +#include #include -#include #include -#include -#include -#include +#include +#include +#include +#include -#include -#include +#include + +#include "vboxvfs.h" /* * Prototypes for VBOXVFS vnode operations */ -static vop_create_t vboxvfs_create; -static vop_mknod_t vboxvfs_mknod; -static vop_open_t vboxvfs_open; -static vop_close_t vboxvfs_close; -static vop_access_t vboxvfs_access; -static vop_getattr_t vboxvfs_getattr; -static vop_setattr_t vboxvfs_setattr; -static vop_read_t vboxvfs_read; -static vop_write_t vboxvfs_write; -static vop_fsync_t vboxvfs_fsync; -static vop_remove_t vboxvfs_remove; -static vop_link_t vboxvfs_link; -static vop_lookup_t vboxvfs_lookup; -static vop_rename_t vboxvfs_rename; -static vop_mkdir_t vboxvfs_mkdir; -static vop_rmdir_t vboxvfs_rmdir; -static vop_symlink_t vboxvfs_symlink; -static vop_readdir_t vboxvfs_readdir; -static vop_strategy_t vboxvfs_strategy; -static vop_print_t vboxvfs_print; -static vop_pathconf_t vboxvfs_pathconf; -static vop_advlock_t vboxvfs_advlock; -static vop_getextattr_t vboxvfs_getextattr; -static vop_ioctl_t vboxvfs_ioctl; -static vop_getpages_t vboxvfs_getpages; -static vop_inactive_t vboxvfs_inactive; -static vop_putpages_t vboxvfs_putpages; -static vop_reclaim_t vboxvfs_reclaim; - -struct vop_vector vboxvfs_vnodeops = { - .vop_default = &default_vnodeops, - - .vop_access = vboxvfs_access, - .vop_advlock = vboxvfs_advlock, - .vop_close = vboxvfs_close, - .vop_create = vboxvfs_create, - .vop_fsync = vboxvfs_fsync, - .vop_getattr = vboxvfs_getattr, - .vop_getextattr = vboxvfs_getextattr, - .vop_getpages = vboxvfs_getpages, - .vop_inactive = vboxvfs_inactive, - .vop_ioctl = vboxvfs_ioctl, - .vop_link = vboxvfs_link, - .vop_lookup = vboxvfs_lookup, - .vop_mkdir = vboxvfs_mkdir, - .vop_mknod = vboxvfs_mknod, - .vop_open = vboxvfs_open, - .vop_pathconf = vboxvfs_pathconf, - .vop_print = vboxvfs_print, - .vop_putpages = vboxvfs_putpages, - .vop_read = vboxvfs_read, - .vop_readdir = vboxvfs_readdir, - .vop_reclaim = vboxvfs_reclaim, - .vop_remove = vboxvfs_remove, - .vop_rename = vboxvfs_rename, - .vop_rmdir = vboxvfs_rmdir, - .vop_setattr = vboxvfs_setattr, - .vop_strategy = vboxvfs_strategy, - .vop_symlink = vboxvfs_symlink, - .vop_write = vboxvfs_write, +static vop_create_t vboxfs_create; +static vop_open_t vboxfs_open; +static vop_close_t vboxfs_close; +static vop_access_t vboxfs_access; +static vop_getattr_t vboxfs_getattr; +static vop_setattr_t vboxfs_setattr; +static vop_read_t vboxfs_read; +static vop_readlink_t vboxfs_readlink; +static vop_write_t vboxfs_write; +static vop_fsync_t vboxfs_fsync; +static vop_remove_t vboxfs_remove; +static vop_link_t vboxfs_link; +static vop_cachedlookup_t vboxfs_lookup; +static vop_rename_t vboxfs_rename; +static vop_mkdir_t vboxfs_mkdir; +static vop_rmdir_t vboxfs_rmdir; +static vop_symlink_t vboxfs_symlink; +static vop_readdir_t vboxfs_readdir; +static vop_print_t vboxfs_print; +static vop_pathconf_t vboxfs_pathconf; +static vop_advlock_t vboxfs_advlock; +static vop_ioctl_t vboxfs_ioctl; +static vop_inactive_t vboxfs_inactive; +static vop_reclaim_t vboxfs_reclaim; +static vop_vptofh_t vboxfs_vptofh; + +struct vop_vector vboxfs_vnodeops = { + .vop_default = &default_vnodeops, + + .vop_access = vboxfs_access, + .vop_advlock = VOP_EOPNOTSUPP, + .vop_close = vboxfs_close, + .vop_create = vboxfs_create, + .vop_fsync = vboxfs_fsync, + .vop_getattr = vboxfs_getattr, + .vop_getextattr = VOP_EOPNOTSUPP, + .vop_inactive = vboxfs_inactive, + .vop_ioctl = vboxfs_ioctl, + .vop_link = vboxfs_link, + .vop_lookup = vfs_cache_lookup, + .vop_cachedlookup = vboxfs_lookup, + .vop_mkdir = vboxfs_mkdir, + .vop_mknod = VOP_EOPNOTSUPP, + .vop_open = vboxfs_open, + .vop_pathconf = vboxfs_pathconf, + .vop_print = vboxfs_print, + .vop_read = vboxfs_read, + .vop_readdir = vboxfs_readdir, + .vop_readlink = vboxfs_readlink, + .vop_reclaim = vboxfs_reclaim, + .vop_remove = vboxfs_remove, + .vop_rename = vboxfs_rename, + .vop_rmdir = vboxfs_rmdir, + .vop_setattr = vboxfs_setattr, + .vop_vptofh = vboxfs_vptofh, + .vop_symlink = vboxfs_symlink, + .vop_write = vboxfs_write, + .vop_bmap = VOP_EOPNOTSUPP }; -static int vboxvfs_access(struct vop_access_args *ap) +static uint64_t +vsfnode_cur_time_usec(void) { - return 0; -} + struct timeval now; -static int vboxvfs_open(struct vop_open_args *ap) -{ - return 0; -} + getmicrotime(&now); -static int vboxvfs_close(struct vop_close_args *ap) -{ - return 0; + return (now.tv_sec*1000 + now.tv_usec); } -static int vboxvfs_getattr(struct vop_getattr_args *ap) +static int +vsfnode_stat_cached(struct vboxfs_node *np) { - return 0; + return (vsfnode_cur_time_usec() - np->sf_stat_time) < + np->vboxfsmp->sf_stat_ttl * 1000UL; } -static int vboxvfs_setattr(struct vop_setattr_args *ap) +static int +vsfnode_update_stat_cache(struct vboxfs_node *np) { - return 0; -} + int error; -static int vboxvfs_read(struct vop_read_args *ap) -{ - return 0; -} + error = sfprov_get_attr(np->vboxfsmp->sf_handle, np->sf_path, + &np->sf_stat); +#if 0 + if (error == ENOENT) + sfnode_make_stale(node); +#endif + if (error == 0) + np->sf_stat_time = vsfnode_cur_time_usec(); -static int vboxvfs_write(struct vop_write_args *ap) -{ - return 0; + return (error); } -static int vboxvfs_create(struct vop_create_args *ap) +/* + * Need to clear v_object for insmntque failure. + */ +static void +vboxfs_insmntque_dtr(struct vnode *vp, void *dtr_arg) { - return 0; -} -static int vboxvfs_remove(struct vop_remove_args *ap) -{ - return 0; + // XXX: vboxfs_destroy_vobject(vp, vp->v_object); + vp->v_object = NULL; + vp->v_data = NULL; + vp->v_op = &dead_vnodeops; + vgone(vp); + vput(vp); } -static int vboxvfs_rename(struct vop_rename_args *ap) -{ - return 0; -} +/* + * Allocates a new vnode for the node node or returns a new reference to + * an existing one if the node had already a vnode referencing it. The + * resulting locked vnode is returned in *vpp. + * + * Returns zero on success or an appropriate error code on failure. + */ +int +vboxfs_alloc_vp(struct mount *mp, struct vboxfs_node *node, int lkflag, + struct vnode **vpp) +{ + struct vnode *vp; + int error; + + error = 0; +loop: + VBOXFS_NODE_LOCK(node); +loop1: + if ((vp = node->sf_vnode) != NULL) { + MPASS((node->sf_vpstate & VBOXFS_VNODE_DOOMED) == 0); + VI_LOCK(vp); + if ((node->sf_type == VDIR && node->sf_parent == NULL) || + ((vp->v_iflag & VI_DOOMED) != 0 && + (lkflag & LK_NOWAIT) != 0)) { + VI_UNLOCK(vp); + VBOXFS_NODE_UNLOCK(node); + error = ENOENT; + vp = NULL; + goto out; + } + if ((vp->v_iflag & VI_DOOMED) != 0) { + VI_UNLOCK(vp); + node->sf_vpstate |= VBOXFS_VNODE_WRECLAIM; + while ((node->sf_vpstate & VBOXFS_VNODE_WRECLAIM) != 0) { + msleep(&node->sf_vnode, VBOXFS_NODE_MTX(node), + 0, "vsfE", 0); + } + goto loop1; + } + VBOXFS_NODE_UNLOCK(node); + error = vget(vp, lkflag | LK_INTERLOCK, curthread); + if (error == ENOENT) + goto loop; + if (error != 0) { + vp = NULL; + goto out; + } + + /* + * Make sure the vnode is still there after + * getting the interlock to avoid racing a free. + */ + if (node->sf_vnode == NULL || node->sf_vnode != vp) { + vput(vp); + goto loop; + } + + goto out; + } + + if ((node->sf_vpstate & VBOXFS_VNODE_DOOMED) || + (node->sf_type == VDIR && node->sf_parent == NULL)) { + VBOXFS_NODE_UNLOCK(node); + error = ENOENT; + vp = NULL; + goto out; + } + + /* + * otherwise lock the vp list while we call getnewvnode + * since that can block. + */ + if (node->sf_vpstate & VBOXFS_VNODE_ALLOCATING) { + node->sf_vpstate |= VBOXFS_VNODE_WANT; + error = msleep((caddr_t) &node->sf_vpstate, + VBOXFS_NODE_MTX(node), PDROP | PCATCH, + "vboxfs_alloc_vp", 0); + if (error) + return error; + + goto loop; + } else + node->sf_vpstate |= VBOXFS_VNODE_ALLOCATING; + + VBOXFS_NODE_UNLOCK(node); + + /* Get a new vnode and associate it with our node. */ + error = getnewvnode("vboxfs", mp, &vboxfs_vnodeops, &vp); + if (error != 0) + goto unlock; + MPASS(vp != NULL); + + /* lkflag is ignored, the lock is exclusive */ + (void) vn_lock(vp, lkflag | LK_RETRY); + + vp->v_data = node; + vp->v_type = node->sf_type; + + /* Type-specific initialization. */ + switch (node->sf_type) { + case VBLK: + /* FALLTHROUGH */ + case VCHR: + /* FALLTHROUGH */ + case VLNK: + /* FALLTHROUGH */ + case VSOCK: + /* FALLTHROUGH */ + case VFIFO: + /* FALLTHROUGH */ + case VREG: + break; + case VDIR: + MPASS(node->sf_parent != NULL); + if (node->sf_parent == node) + vp->v_vflag |= VV_ROOT; + break; + + default: + panic("vboxfs_alloc_vp: type %p %d", node, (int)node->sf_type); + } + + if (vp->v_type != VFIFO) + VN_LOCK_ASHARE(vp); + + error = insmntque1(vp, mp, vboxfs_insmntque_dtr, NULL); + if (error) + vp = NULL; + +unlock: + VBOXFS_NODE_LOCK(node); + + MPASS(node->sf_vpstate & VBOXFS_VNODE_ALLOCATING); + node->sf_vpstate &= ~VBOXFS_VNODE_ALLOCATING; + node->sf_vnode = vp; + + if (node->sf_vpstate & VBOXFS_VNODE_WANT) { + node->sf_vpstate &= ~VBOXFS_VNODE_WANT; + VBOXFS_NODE_UNLOCK(node); + wakeup((caddr_t) &node->sf_vpstate); + } else + VBOXFS_NODE_UNLOCK(node); + +out: + *vpp = vp; + +#ifdef INVARIANTS + if (error == 0) { + MPASS(*vpp != NULL && VOP_ISLOCKED(*vpp)); + VBOXFS_NODE_LOCK(node); + MPASS(*vpp == node->sf_vnode); + VBOXFS_NODE_UNLOCK(node); + } +#endif -static int vboxvfs_link(struct vop_link_args *ap) -{ - return EOPNOTSUPP; + return error; } -static int vboxvfs_symlink(struct vop_symlink_args *ap) +/* + * Destroys the association between the vnode vp and the node it + * references. + */ +void +vboxfs_free_vp(struct vnode *vp) { - return EOPNOTSUPP; -} + struct vboxfs_node *node; -static int vboxvfs_mknod(struct vop_mknod_args *ap) -{ - return EOPNOTSUPP; -} + node = VP_TO_VBOXFS_NODE(vp); -static int vboxvfs_mkdir(struct vop_mkdir_args *ap) -{ - return 0; + VBOXFS_NODE_ASSERT_LOCKED(node); + node->sf_vnode = NULL; + if ((node->sf_vpstate & VBOXFS_VNODE_WRECLAIM) != 0) + wakeup(&node->sf_vnode); + node->sf_vpstate &= ~VBOXFS_VNODE_WRECLAIM; + vp->v_data = NULL; } -static int vboxvfs_rmdir(struct vop_rmdir_args *ap) +/* + * Allocate new vboxfs_node and vnode for given file + */ +static int +vboxfs_alloc_file(struct vboxfs_mnt *vboxfsmp, const char *fullpath, + enum vtype type, mode_t mode, struct vboxfs_node *parent, + int lkflag, struct vnode **vpp) { - return 0; -} + int error; + struct vboxfs_node *unode; -static int vboxvfs_readdir(struct vop_readdir_args *ap) -{ - return 0; -} + error = vboxfs_alloc_node(vboxfsmp->sf_vfsp, vboxfsmp, fullpath, type, + vboxfsmp->sf_uid, vboxfsmp->sf_gid, mode, parent, &unode); -static int vboxvfs_fsync(struct vop_fsync_args *ap) -{ - return 0; -} + if (error) + goto out; -static int vboxvfs_print (struct vop_print_args *ap) -{ - return 0; -} + error = vboxfs_alloc_vp(vboxfsmp->sf_vfsp, unode, lkflag, vpp); + if (error) + vboxfs_free_node(vboxfsmp, unode); -static int vboxvfs_pathconf (struct vop_pathconf_args *ap) -{ - return 0; +out: + return (error); } -static int vboxvfs_strategy (struct vop_strategy_args *ap) +static int +vboxfs_vn_get_ino_alloc(struct mount *mp, void *arg, int lkflags, + struct vnode **rvp) { - return 0; -} -static int vboxvfs_ioctl(struct vop_ioctl_args *ap) -{ - return ENOTTY; + return (vboxfs_alloc_vp(mp, arg, lkflags, rvp)); } -static int vboxvfs_getextattr(struct vop_getextattr_args *ap) +/* + * Construct a new pathname given an sfnode plus an optional tail + * component of length len + * This handles ".." and "." + */ +static char * +sfnode_construct_path(struct vboxfs_node *node, char *tail, int len) { - return 0; -} + char *p; -static int vboxvfs_advlock(struct vop_advlock_args *ap) -{ - return 0; -} -+ if (strncmp(tail, ".", len) == 0 || strncmp(tail, "..", len) == 0) ++ if (len <= 2 && tail[0] == '.' && (len == 1 || tail[1] == '.')) + panic("construct path for %s", tail); + p = malloc(strlen(node->sf_path) + 1 + len + 1, M_VBOXVFS, M_WAITOK); + strcpy(p, node->sf_path); + strcat(p, "/"); + strcat(p, tail); + return (p); +} + +static int +vboxfs_access(struct vop_access_args *ap) +{ + struct vnode *vp = ap->a_vp; + accmode_t accmode = ap->a_accmode; + struct vboxfs_node *node; + int error; + mode_t m; + + MPASS(VOP_ISLOCKED(vp)); + + node = VP_TO_VBOXFS_NODE(vp); + + if ((accmode & VWRITE) && (vp->v_mount->mnt_flag & MNT_RDONLY)) { + switch (vp->v_type) { + case VDIR: + case VLNK: + case VREG: + return (EROFS); + /* NOT REACHED */ + default: + break; + } + } + + if (vsfnode_stat_cached(node)) + error = 0; + else + error = vsfnode_update_stat_cache(node); + m = (error == 0) ? node->sf_stat.sf_mode : 0; -static int vboxvfs_lookup(struct vop_lookup_args *ap) -{ - return 0; + return (vaccess(vp->v_type, m, node->vboxfsmp->sf_uid, + node->vboxfsmp->sf_gid, accmode, ap->a_cred, NULL)); } -static int vboxvfs_inactive(struct vop_inactive_args *ap) +/* + * Clears the (cached) directory listing for the node. + */ +static void +vfsnode_clear_dir_list(struct vboxfs_node *np) { - return 0; + while (np->sf_dir_list != NULL) { + sffs_dirents_t *next = np->sf_dir_list->sf_next; + free(np->sf_dir_list, M_VBOXVFS); + np->sf_dir_list = next; + } +} + +static int +vboxfs_open(struct vop_open_args *ap) +{ + struct vboxfs_node *np; + sfp_file_t *fp; + int error; + + MPASS(VOP_ISLOCKED(vp)); + + np = VP_TO_VBOXFS_NODE(ap->a_vp); + error = sfprov_open(np->vboxfsmp->sf_handle, np->sf_path, &fp); + if (error != 0) + goto out; + + np->sf_file = fp; + vnode_create_vobject(ap->a_vp, 0, ap->a_td); + +out: + MPASS(VOP_ISLOCKED(vp)); + + return (error); +} + +static void +vfsnode_invalidate_stat_cache(struct vboxfs_node *np) +{ + np->sf_stat_time = 0; +} + +static int +vboxfs_close(struct vop_close_args *ap) +{ + struct vnode *vp = ap->a_vp; + struct vboxfs_node *np; + + np = VP_TO_VBOXFS_NODE(vp); + + /* + * Free the directory entries for the node. We do this on this call + * here because the directory node may not become inactive for a long + * time after the readdir is over. Case in point, if somebody cd's into + * the directory then it won't become inactive until they cd away again. + * In such a case we would end up with the directory listing not getting + * updated (i.e. the result of 'ls' always being the same) until they + * change the working directory. + */ + vfsnode_clear_dir_list(np); + + vfsnode_invalidate_stat_cache(np); + + if (np->sf_file != NULL && vp->v_usecount <= 1) { + (void) sfprov_close(np->sf_file); + np->sf_file = NULL; + } + + return (0); +} + +static int +vboxfs_getattr(struct vop_getattr_args *ap) +{ + struct vnode *vp = ap->a_vp; + struct vattr *vap = ap->a_vap; + struct vboxfs_node *np = VP_TO_VBOXFS_NODE(vp); + struct vboxfs_mnt *mp = np->vboxfsmp; + mode_t mode; + int error = 0; + + mode = 0; + vap->va_type = vp->v_type; + + vap->va_nlink = 1; /* number of references to file */ + vap->va_uid = mp->sf_uid; /* owner user id */ + vap->va_gid = mp->sf_gid; /* owner group id */ + vap->va_rdev = NODEV; /* device the special file represents */ + vap->va_gen = VNOVAL; /* generation number of file */ + vap->va_flags = 0; /* flags defined for file */ + vap->va_filerev = 0; /* file modification number */ + vap->va_vaflags = 0; /* operations flags */ + vap->va_fileid = np->sf_ino; /* file id */ + vap->va_fsid = vp->v_mount->mnt_stat.f_fsid.val[0]; + if (vap->va_fileid == 0) + vap->va_fileid = 2; + + vap->va_atime.tv_sec = VNOVAL; + vap->va_atime.tv_nsec = VNOVAL; + vap->va_mtime.tv_sec = VNOVAL; + vap->va_mtime.tv_nsec = VNOVAL; + vap->va_ctime.tv_sec = VNOVAL; + vap->va_ctime.tv_nsec = VNOVAL; + + if (!vsfnode_stat_cached(np)) { + error = vsfnode_update_stat_cache(np); + if (error != 0) + goto done; + } + + vap->va_atime = np->sf_stat.sf_atime; + vap->va_mtime = np->sf_stat.sf_mtime; + vap->va_ctime = np->sf_stat.sf_ctime; + + mode = np->sf_stat.sf_mode; + + vap->va_mode = mode; + if (S_ISDIR(mode)) { + vap->va_type = VDIR; /* vnode type (for create) */ + vap->va_mode = mp->sf_dmode != 0 ? (mp->sf_dmode & 0777) : vap->va_mode; + vap->va_mode &= ~mp->sf_dmask; + vap->va_mode |= S_IFDIR; + } else if (S_ISREG(mode)) { + vap->va_type = VREG; + vap->va_mode = mp->sf_fmode != 0 ? (mp->sf_fmode & 0777) : vap->va_mode; + vap->va_mode &= ~mp->sf_fmask; + vap->va_mode |= S_IFREG; + } else if (S_ISFIFO(mode)) + vap->va_type = VFIFO; + else if (S_ISCHR(mode)) + vap->va_type = VCHR; + else if (S_ISBLK(mode)) + vap->va_type = VBLK; + else if (S_ISLNK(mode)) { + vap->va_type = VLNK; + vap->va_mode = mp->sf_fmode != 0 ? (mp->sf_fmode & 0777) : vap->va_mode; + vap->va_mode &= ~mp->sf_fmask; + vap->va_mode |= S_IFLNK; + } else if (S_ISSOCK(mode)) + vap->va_type = VSOCK; + + vap->va_size = np->sf_stat.sf_size; + vap->va_blocksize = 512; + /* bytes of disk space held by file */ + vap->va_bytes = (np->sf_stat.sf_alloc + 511) / 512; + +done: + return (error); +} + +static int +vboxfs_setattr(struct vop_setattr_args *ap) +{ + struct vnode *vp = ap->a_vp; + struct vattr *vap = ap->a_vap; + struct vboxfs_node *np = VP_TO_VBOXFS_NODE(vp); + int error; + mode_t mode; + + mode = vap->va_mode; + if (vp->v_type == VREG) + mode |= S_IFREG; + else if (vp->v_type == VDIR) + mode |= S_IFDIR; + else if (vp->v_type == VBLK) + mode |= S_IFBLK; + else if (vp->v_type == VCHR) + mode |= S_IFCHR; + else if (vp->v_type == VLNK) + mode |= S_IFLNK; + else if (vp->v_type == VFIFO) + mode |= S_IFIFO; + else if (vp->v_type == VSOCK) + mode |= S_IFSOCK; + + vfsnode_invalidate_stat_cache(np); + + error = sfprov_set_attr(np->vboxfsmp->sf_handle, np->sf_path, + mode, vap->va_atime, vap->va_mtime, vap->va_ctime); +#if 0 + if (error == ENOENT) + sfnode_make_stale(np); +#endif + if (vap->va_size != (u_quad_t)VNOVAL) { + switch (vp->v_type) { + case VDIR: + return (EISDIR); + case VLNK: + /* FALLTHROUGH */ + case VREG: + error = sfprov_set_size(np->vboxfsmp->sf_handle, np->sf_path, vap->va_size); + break; + case VCHR: + /* FALLTHROUGH */ + case VBLK: + /* FALLTHROUGH */ + case VSOCK: + /* FALLTHROUGH */ + case VFIFO: + /* FALLTHROUGH */ + case VNON: + /* FALLTHROUGH */ + case VBAD: + /* FALLTHROUGH */ + case VMARKER: + return (0); + } + } + + return (error); +} + +#define blkoff(vboxfsmp, loc) ((loc) & (vboxfsmp)->bmask) + +static int +vboxfs_read(struct vop_read_args *ap) +{ + struct vnode *vp = ap->a_vp; + struct uio *uio = ap->a_uio; + struct vboxfs_node *np = VP_TO_VBOXFS_NODE(vp); + int error = 0; + uint32_t bytes; + uint32_t done; + unsigned long offset; + ssize_t total; + void *tmpbuf; + + if (vp->v_type == VDIR) + return (EISDIR); + + if (vp->v_type != VREG) + return (EINVAL); + + if (uio->uio_offset < 0) + return (EINVAL); + + total = uio->uio_resid; + if (total == 0) + return (0); + + /* + * XXXGONZO: this is just to get things working + * should be optimized + */ + tmpbuf = contigmalloc(PAGE_SIZE, M_DEVBUF, M_WAITOK, 0, ~0, PAGE_SIZE, 0); + if (tmpbuf == 0) + return (ENOMEM); + + do { + offset = uio->uio_offset; + done = bytes = min(PAGE_SIZE, uio->uio_resid); + error = sfprov_read(np->sf_file, tmpbuf, + offset, &done, 0); + if (error == 0 && done > 0) + error = uiomove(tmpbuf, done, uio); + } while (error == 0 && uio->uio_resid > 0 && done > 0); + + contigfree(tmpbuf, PAGE_SIZE, M_DEVBUF); + + /* a partial read is never an error */ + if (total != uio->uio_resid) + error = 0; + + return (error); +} + +static int +vboxfs_write(struct vop_write_args *ap) +{ + struct vnode *vp = ap->a_vp; + struct uio *uio = ap->a_uio; + struct vboxfs_node *np = VP_TO_VBOXFS_NODE(vp); + int error = 0; + uint32_t bytes; + uint32_t done; + unsigned long offset; + ssize_t total; + void *tmpbuf; + + if (vp->v_type == VDIR) + return (EISDIR); + + if (vp->v_type != VREG) + return (EINVAL); + + if (uio->uio_offset < 0) + return (EINVAL); + + total = uio->uio_resid; + if (total == 0) + return (0); + + /* + * XXXGONZO: this is just to get things working + * should be optimized + */ + tmpbuf = contigmalloc(PAGE_SIZE, M_DEVBUF, M_WAITOK, 0, ~0, PAGE_SIZE, 0); + if (tmpbuf == 0) + return (ENOMEM); + + do { + offset = uio->uio_offset; + bytes = min(PAGE_SIZE, uio->uio_resid); + error = uiomove(tmpbuf, bytes, uio); + if (error != 0) + break; + done = bytes; + error = sfprov_write(np->sf_file, tmpbuf, + offset, &done, 0); + if (error != 0) + break; + total -= done; + if (done != bytes) + uio->uio_resid += bytes - done; + } while (error == 0 && uio->uio_resid > 0 && done > 0); + + contigfree(tmpbuf, PAGE_SIZE, M_DEVBUF); + + /* a partial write is never an error */ + if (total != uio->uio_resid) + error = 0; + + return (error); +} + +static int +vboxfs_create(struct vop_create_args *ap) +{ + struct vnode *dvp = ap->a_dvp; + struct vnode **vpp = ap->a_vpp; + struct componentname *cnp = ap->a_cnp; + struct vattr *vap = ap->a_vap; + sffs_stat_t stat; + char *fullpath = NULL; + struct vboxfs_node *dir = VP_TO_VBOXFS_NODE(dvp); + sfp_file_t *fp; + int error; + struct vboxfs_mnt *vboxfsmp = dir->vboxfsmp; + + MPASS(vap->va_type == VREG); + + fullpath = sfnode_construct_path(dir, cnp->cn_nameptr, cnp->cn_namelen); + error = sfprov_create(dir->vboxfsmp->sf_handle, fullpath, vap->va_mode, + &fp, &stat); + + if (error) + goto out; + + error = vboxfs_alloc_file(vboxfsmp, fullpath, VREG, vap->va_mode, dir, cnp->cn_lkflags, vpp); + +out: + if (fullpath) + free(fullpath, M_VBOXVFS); + + if (error == 0) { + vfsnode_clear_dir_list(dir); + if ((cnp->cn_flags & MAKEENTRY) != 0) + cache_enter(dvp, *vpp, cnp); + } + + return (error); +} + +static int +vboxfs_remove(struct vop_remove_args *ap) +{ + struct vnode *dvp = ap->a_dvp; + struct vnode *vp = ap->a_vp; + struct vboxfs_node *np, *dir; + + int error; + + MPASS(VOP_ISLOCKED(dvp)); + MPASS(VOP_ISLOCKED(vp)); + + error = 0; + + np = VP_TO_VBOXFS_NODE(vp); + dir = VP_TO_VBOXFS_NODE(vp); + + /* + * If anything else is using this vnode, then fail the remove. + * Why? Windows hosts can't sfprov_remove() a file that is open, + * so we have to sfprov_close() it first. + * There is no errno for this - since it's not a problem on UNIX, + * but ETXTBSY is the closest. + */ + if (np->sf_file != NULL) { + if (vp->v_usecount > 1) { + error = ETXTBSY; + goto out; + } + sfprov_close(np->sf_file); + np->sf_file = NULL; + } + + error = sfprov_remove(np->vboxfsmp->sf_handle, np->sf_path, + np->sf_type == VLNK); + +#if 0 + if (error == ENOENT || error == 0) + sfnode_make_stale(np); +#endif + + if (error == 0) + vfsnode_clear_dir_list(dir); + +out: + return (error); +} + +static int +vboxfs_rename(struct vop_rename_args *ap) +{ + struct vnode *fvp; + struct vnode *fdvp; + struct vnode *tvp; + struct vnode *tdvp; + struct componentname *fcnp; + struct componentname *tcnp; + struct vboxfs_node *np; + int ret; + + fvp = ap->a_fvp; + fdvp = ap->a_fdvp; + tvp = ap->a_tvp; + tdvp = ap->a_tdvp; + fcnp = ap->a_fcnp; + tcnp = ap->a_tcnp; + + /* Check for cross-device rename */ + if ((fvp->v_mount != tdvp->v_mount) || + (tvp && (fvp->v_mount != tvp->v_mount))) { + ret = EXDEV; + goto out; + } + np = VP_TO_VBOXFS_NODE(fvp); + if (np == NULL) + return (0); + ret = sfprov_rename(np->vboxfsmp->sf_handle, + fcnp->cn_nameptr, tcnp->cn_nameptr, fvp->v_type == VDIR); +out: + if (tdvp == tvp) + vrele(tdvp); + else + vput(tdvp); + if (tvp) + vput(tvp); + vrele(fdvp); + vrele(fvp); + return (ret); +} + +static int +vboxfs_link(struct vop_link_args *ap) +{ + return (EOPNOTSUPP); +} + +static int +vboxfs_symlink(struct vop_symlink_args *ap) +{ + struct vnode *dvp = ap->a_dvp; + struct vnode **vpp = ap->a_vpp; + struct componentname *cnp = ap->a_cnp; + struct vattr *vap = ap->a_vap; + sffs_stat_t stat; + char *fullpath = NULL; + struct vboxfs_node *dir = VP_TO_VBOXFS_NODE(dvp); + int error; + struct vboxfs_mnt *vboxfsmp = dir->vboxfsmp; + + MPASS(vap->va_type == VLNK); + + fullpath = sfnode_construct_path(dir, cnp->cn_nameptr, cnp->cn_namelen); + error = sfprov_symlink(dir->vboxfsmp->sf_handle, fullpath, ap->a_target, &stat); + + if (error) + goto out; + + error = vboxfs_alloc_file(vboxfsmp, fullpath, VLNK, vap->va_mode, dir, cnp->cn_lkflags, vpp); + +out: + if (fullpath) + free(fullpath, M_VBOXVFS); + + if (error == 0) + vfsnode_clear_dir_list(dir); + + return (error); +} + +static int +vboxfs_mkdir(struct vop_mkdir_args *ap) +{ + struct vnode *dvp = ap->a_dvp; + struct vnode **vpp = ap->a_vpp; + struct componentname *cnp = ap->a_cnp; + struct vattr *vap = ap->a_vap; + sffs_stat_t stat; + char *fullpath = NULL; + struct vboxfs_node *dir = VP_TO_VBOXFS_NODE(dvp); + sfp_file_t *fp; + int error; + struct vboxfs_mnt *vboxfsmp = dir->vboxfsmp; + + MPASS(vap->va_type == VDIR); + + fullpath = sfnode_construct_path(dir, cnp->cn_nameptr, cnp->cn_namelen); + error = sfprov_mkdir(dir->vboxfsmp->sf_handle, fullpath, vap->va_mode, + &fp, &stat); + + if (error) + goto out; + + error = vboxfs_alloc_file(vboxfsmp, fullpath, VDIR, vap->va_mode, dir, cnp->cn_lkflags, vpp); + +out: + if (fullpath) + free(fullpath, M_VBOXVFS); + + if (error == 0) + vfsnode_clear_dir_list(dir); + + return (error); +} + +static int +vboxfs_rmdir(struct vop_rmdir_args *ap) +{ + struct vnode *dvp = ap->a_dvp; + struct vnode *vp = ap->a_vp; + struct vboxfs_node *np, *dir; + + int error; + + MPASS(VOP_ISLOCKED(dvp)); + MPASS(VOP_ISLOCKED(vp)); + + error = 0; + + np = VP_TO_VBOXFS_NODE(vp); + dir = VP_TO_VBOXFS_NODE(vp); + + /* + * If anything else is using this vnode, then fail the remove. + * Why? Windows hosts can't sfprov_remove() a file that is open, + * so we have to sfprov_close() it first. + * There is no errno for this - since it's not a problem on UNIX, + * but ETXTBSY is the closest. + */ + if (np->sf_file != NULL) { + if (vp->v_usecount > 1) { + error = ETXTBSY; + goto out; + } + sfprov_close(np->sf_file); + np->sf_file = NULL; + } + + error = sfprov_rmdir(np->vboxfsmp->sf_handle, np->sf_path); + +#if 0 + if (error == ENOENT || error == 0) + sfnode_make_stale(np); +#endif + + if (error == 0) + vfsnode_clear_dir_list(dir); + +out: + return (error); +} + +static int +vboxfs_readdir(struct vop_readdir_args *ap) +{ + int *eofp = ap->a_eofflag; + struct vnode *vp = ap->a_vp; + struct uio *uio = ap->a_uio; + struct vboxfs_node *dir = VP_TO_VBOXFS_NODE(vp); + struct vboxfs_node *node; + struct sffs_dirent *dirent = NULL; + sffs_dirents_t *cur_buf; + off_t offset = 0; + off_t orig_off = uio->uio_offset; + int error = 0; + int dummy_eof; + + if (vp->v_type != VDIR) + return (ENOTDIR); + + if (eofp == NULL) + eofp = &dummy_eof; + *eofp = 0; + + /* + * Get the directory entry names from the host. This gets all + * entries. These are stored in a linked list of sffs_dirents_t + * buffers, each of which contains a list of dirent64_t's. + */ + if (dir->sf_dir_list == NULL) { + error = sfprov_readdir(dir->vboxfsmp->sf_handle, dir->sf_path, + &dir->sf_dir_list); + if (error != 0) + goto done; + } + + /* + * Validate and skip to the desired offset. + */ + cur_buf = dir->sf_dir_list; + offset = 0; + + while (cur_buf != NULL && offset + cur_buf->sf_len <= uio->uio_offset) { + offset += cur_buf->sf_len; + cur_buf = cur_buf->sf_next; + } + + if (cur_buf == NULL && offset != uio->uio_offset) { + error = EINVAL; + goto done; + } + + if (cur_buf != NULL && offset != uio->uio_offset) { + off_t off = offset; + int step; + dirent = &cur_buf->sf_entries[0]; + + while (off < uio->uio_offset) { + if (dirent->sf_off == uio->uio_offset) + break; + step = sizeof(struct sffs_dirent) + dirent->sf_entry.d_reclen; + dirent = (struct sffs_dirent *) (((char *) dirent) + step); + off += step; + } + + if (off >= uio->uio_offset) { + error = EINVAL; + goto done; + } + } + + offset = uio->uio_offset - offset; + + /* + * Lookup each of the names, so that we have ino's, and copy to + * result buffer. + */ + while (cur_buf != NULL) { + if (offset >= cur_buf->sf_len) { + cur_buf = cur_buf->sf_next; + offset = 0; + continue; + } + + dirent = (struct sffs_dirent *) + (((char *) &cur_buf->sf_entries[0]) + offset); + if (dirent->sf_entry.d_reclen > uio->uio_resid) + break; + + if (strcmp(dirent->sf_entry.d_name, ".") == 0) { + node = dir; + } else if (strcmp(dirent->sf_entry.d_name, "..") == 0) { + node = dir->sf_parent; + if (node == NULL) + node = dir; + } else { +#if 0 + node = vsfnode_lookup(dir, dirent->sf_entry.d_name, VNON, + 0, &dirent->sf_stat, vsfnode_cur_time_usec(), NULL); + if (node == NULL) + panic("sffs_readdir() lookup failed"); +#endif + } + + if (node) + dirent->sf_entry.d_fileno = node->sf_ino; + else + dirent->sf_entry.d_fileno = 0xdeadbeef; + + error = uiomove(&dirent->sf_entry, dirent->sf_entry.d_reclen, uio); + if (error != 0) + break; + + uio->uio_offset = dirent->sf_off; + offset += sizeof(struct sffs_dirent) + dirent->sf_entry.d_reclen; + } + + if (error == 0 && cur_buf == NULL) + *eofp = 1; +done: + if (error != 0) + uio->uio_offset = orig_off; + return (error); +} + +static int +vboxfs_readlink(struct vop_readlink_args *v) +{ + struct vnode *vp = v->a_vp; + struct uio *uio = v->a_uio; + + int error; + struct vboxfs_node *np; + void *tmpbuf; + + MPASS(uio->uio_offset == 0); + MPASS(vp->v_type == VLNK); + + np = VP_TO_VBOXFS_NODE(vp); + + tmpbuf = contigmalloc(MAXPATHLEN, M_DEVBUF, M_WAITOK, 0, ~0, 1, 0); + if (tmpbuf == NULL) + return (ENOMEM); + + error = sfprov_readlink(np->vboxfsmp->sf_handle, np->sf_path, tmpbuf, + MAXPATHLEN); + if (error) + goto done; + + error = uiomove(tmpbuf, strlen(tmpbuf), uio); + +done: + if (tmpbuf) + contigfree(tmpbuf, MAXPATHLEN, M_DEVBUF); + return (error); +} + +static int +vboxfs_fsync(struct vop_fsync_args *ap) +{ + struct vnode *vp; + struct vboxfs_node *np; + int ret; + + vp = ap->a_vp; + np = VP_TO_VBOXFS_NODE(vp); + if (np == NULL) + return (0); + ret = sfprov_fsync(np->sf_file); + return (ret); +} + +static int +vboxfs_print(struct vop_print_args *ap) +{ + struct vnode *vp = ap->a_vp; + struct vboxfs_node *np; + + np = VP_TO_VBOXFS_NODE(vp); + + if (np == NULL) { + printf("No vboxfs_node data\n"); + return (0); + } + + printf("\tpath = %s, parent = %p", np->sf_path, + np->sf_parent ? np->sf_parent : NULL); + printf("\n"); + return (0); +} + +static int +vboxfs_pathconf(struct vop_pathconf_args *ap) +{ + register_t *retval = ap->a_retval; + int error = 0; + + switch (ap->a_name) { + case _PC_LINK_MAX: + *retval = 65535; + break; + case _PC_NAME_MAX: + *retval = NAME_MAX; + break; + case _PC_PATH_MAX: + *retval = PATH_MAX; + break; + default: + error = EINVAL; + break; + } + return (error); } -static int vboxvfs_reclaim(struct vop_reclaim_args *ap) +/* + * File specific ioctls. + */ +static int +vboxfs_ioctl(struct vop_ioctl_args *ap) { - return 0; + return (ENOTTY); } -static int vboxvfs_getpages(struct vop_getpages_args *ap) -{ - return 0; +/* + * Lookup an entry in a directory and create a new vnode if found. + */ +static int +vboxfs_lookup(struct vop_cachedlookup_args /* { + struct vnodeop_desc *a_desc; + struct vnode *a_dvp; + struct vnode **a_vpp; + struct componentname *a_cnp; + } */ *ap) +{ + struct componentname *cnp = ap->a_cnp; + struct vnode *dvp = ap->a_dvp; /* the directory vnode */ + char *nameptr = cnp->cn_nameptr; /* the name of the file or directory */ + struct vnode **vpp = ap->a_vpp; /* the vnode we found or NULL */ + struct vnode *tdp = NULL; + struct vboxfs_node *node = VP_TO_VBOXFS_NODE(dvp); + struct vboxfs_mnt *vboxfsmp = node->vboxfsmp; + u_long nameiop = cnp->cn_nameiop; + u_long flags = cnp->cn_flags; + sffs_stat_t stat; + //long namelen; + ino_t id = 0; + int ltype, type, error = 0; + int lkflags = cnp->cn_lkflags; + char *fullpath = NULL; + + error = ENOENT; + if (cnp->cn_flags & ISDOTDOT) { + error = vn_vget_ino_gen(dvp, vboxfs_vn_get_ino_alloc, + node->sf_parent, cnp->cn_lkflags, vpp); + error = ENOENT; + if (error != 0) + goto out; + + } else if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') { + VREF(dvp); + *vpp = dvp; + error = 0; + } else { + mode_t m; + type = VNON; + fullpath = sfnode_construct_path(node, cnp->cn_nameptr, cnp->cn_namelen); + error = sfprov_get_attr(node->vboxfsmp->sf_handle, + fullpath, &stat); + // stat_time = vsfnode_cur_time_usec(); + + m = stat.sf_mode; + if (error != 0) { + /* The entry was not found in the directory. + * This is OK if we are creating or renaming an + * entry and are working on the last component of + * the path name. */ + if ((cnp->cn_flags & ISLASTCN) && + (cnp->cn_nameiop == CREATE || \ + cnp->cn_nameiop == RENAME || + (cnp->cn_nameiop == DELETE && + cnp->cn_flags & DOWHITEOUT && + cnp->cn_flags & ISWHITEOUT))) { + error = VOP_ACCESS(dvp, VWRITE, cnp->cn_cred, + cnp->cn_thread); + if (error != 0) + goto out; + + /* Keep the component name in the buffer for + * future uses. */ + cnp->cn_flags |= SAVENAME; + + error = EJUSTRETURN; + } else + error = ENOENT; + } + else { + if (S_ISDIR(m)) + type = VDIR; + else if (S_ISREG(m)) + type = VREG; + else if (S_ISLNK(m)) + type = VLNK; + error = vboxfs_alloc_file(vboxfsmp, fullpath, type, 0755, node, cnp->cn_lkflags, vpp); + } + } + + if ((cnp->cn_flags & MAKEENTRY) != 0) + cache_enter(dvp, *vpp, cnp); +out: + if (fullpath) + free(fullpath, M_VBOXVFS); + + return (error); +} + +static int +vboxfs_inactive(struct vop_inactive_args *ap) +{ + return (0); +} + +static int +vboxfs_reclaim(struct vop_reclaim_args *ap) +{ + struct vnode *vp; + struct vboxfs_node *node; + struct vboxfs_mnt *vboxfsmp; + + vp = ap->a_vp; + node = VP_TO_VBOXFS_NODE(vp); + vboxfsmp = node->vboxfsmp; + + vnode_destroy_vobject(vp); + vp->v_object = NULL; + cache_purge(vp); + + VBOXFS_NODE_LOCK(node); + VBOXFS_ASSERT_ELOCKED(node); + vboxfs_free_vp(vp); + + /* If the node referenced by this vnode was deleted by the user, + * we must free its associated data structures (now that the vnode + * is being reclaimed). */ + if ((node->sf_vpstate & VBOXFS_VNODE_ALLOCATING) == 0) { + node->sf_vpstate = VBOXFS_VNODE_DOOMED; + VBOXFS_NODE_UNLOCK(node); + vboxfs_free_node(vboxfsmp, node); + } else + VBOXFS_NODE_UNLOCK(node); + + MPASS(vp->v_data == NULL); + + return (0); } -static int vboxvfs_putpages(struct vop_putpages_args *ap) +static int +vboxfs_vptofh(struct vop_vptofh_args *ap) { - return 0; -} + return (EOPNOTSUPP); +} Index: head/emulators/virtualbox-ose-additions/Makefile =================================================================== --- head/emulators/virtualbox-ose-additions/Makefile (revision 446840) +++ head/emulators/virtualbox-ose-additions/Makefile (revision 446841) @@ -1,217 +1,217 @@ # Created by: Bernhard Froehlich # $FreeBSD$ PORTNAME= virtualbox-ose -PORTVERSION= 5.1.24 +PORTVERSION= 5.1.26 CATEGORIES= emulators MASTER_SITES= http://download.virtualbox.org/virtualbox/${PORTVERSION}/ PKGNAMESUFFIX?= -additions DISTNAME= VirtualBox-${PORTVERSION} MAINTAINER= vbox@FreeBSD.org COMMENT= VirtualBox additions for FreeBSD guests LICENSE= GPLv2 LICENSE_FILE= ${WRKSRC}/COPYING BUILD_DEPENDS= yasm:devel/yasm \ kmk:devel/kBuild CPE_VENDOR= oracle CPE_PRODUCT= vm_virtualbox PATCHDIR= ${.CURDIR}/../${PORTNAME}/files WRKSRC= ${WRKDIR}/VirtualBox-${PORTVERSION} USE_RC_SUBR= vboxguest vboxservice USES= compiler:features cpe iconv kmod python:build tar:bzip2 ONLY_FOR_ARCHS= i386 amd64 MAKE_JOBS_UNSAFE= yes HAS_CONFIGURE= yes CONFIGURE_ARGS+= --disable-alsa \ --disable-docs \ --disable-libvpx \ --disable-pulse \ --disable-python \ --disable-sdl-ttf \ --disable-xpcom CONFIGURE_ARGS+= --nofatal --with-gcc="${CC}" --with-g++="${CXX}" CONFLICTS_INSTALL= virtualbox-ose-[0-9]* \ virtualbox-ose-additions-devel-[0-9]* \ virtualbox-ose-devel-[0-9]* \ virtualbox-ose-legacy-[0-9]* \ virtualbox-ose-lite-[0-9]* \ virtualbox-ose-nox11-[0-9]* OPTIONS_DEFINE= DBUS DEBUG OPENGL X11 OPTIONS_DEFAULT= DBUS X11 OPTIONS_SUB= yes DBUS_CONFIGURE_OFF= --disable-dbus DBUS_LIB_DEPENDS= libdbus-1.so:devel/dbus OPENGL_CONFIGURE_OFF= --disable-opengl .include .if ${SLAVE_PORT} == no CONFLICTS_INSTALL+= virtualbox-ose-additions-nox11-[0-9]* .else CONFLICTS_INSTALL+= virtualbox-ose-additions-[0-9]* .endif .if ${PORT_OPTIONS:MOPENGL} && empty(PORT_OPTIONS:MX11) BROKEN= OPENGL requires X11 support. Run 'make config' again! .endif VIDEODIR= ${PREFIX}/lib/xorg/modules/drivers INPUTDIR= ${PREFIX}/lib/xorg/modules/input VBOX_BIN= ${WRKSRC}/out/${KMK_ARCH}/${KMK_BUILDTYPE}/bin/additions VBOX_SBINS= VBoxControl \ VBoxService \ mount_vboxvfs BUILD_WRKSRC= ${VBOX_BIN}/src KMK_BUILDTYPE= release KMK_CONFIG= VBOX_LIBPATH_X11=${LOCALBASE} KMK_FLAGS= .if ${PORT_OPTIONS:MDEBUG} KMK_FLAGS+= BUILD_TYPE=debug KMK_BUILDTYPE= debug MAKE_ARGS+= DEBUG_FLAGS="-O1 -g" .endif .if ${PORT_OPTIONS:MOPENGL} USE_XORG= xcomposite xdamage xfixes USE_GL= gl VBOX_LIBS= VBoxEGL.so \ VBoxOGL.so \ VBoxOGLarrayspu.so \ VBoxOGLcrutil.so \ VBoxOGLerrorspu.so \ VBoxOGLfeedbackspu.so \ VBoxOGLpackspu.so \ VBoxOGLpassthroughspu.so .endif .if ${PORT_OPTIONS:MX11} BUILD_DEPENDS+= ${LOCALBASE}/bin/X:x11-servers/xorg-server USE_XORG+= inputproto x11 xcursor xext xmu xorg-server xrandr xt USES+= pkgconfig VBOX_WITH_X11= 1 XORG_DRV_ABI= pkgconf --modversion xorg-server | \ ${SED} -E -e 's/\.[0-9]+$$//' -e 's/\.//' .else VBOX_WITH_X11= .endif .if ${ARCH} == i386 KMK_ARCH= freebsd.x86 .else KMK_ARCH= freebsd.${ARCH} .endif .include .if ${COMPILER_TYPE} == clang EXTRA_PATCHES+= ${PATCHDIR}/extrapatch-Config.kmk \ ${PATCHDIR}/extrapatch-src-VBox-Additions-x11-vboxvideo-Makefile.kmk \ ${PATCHDIR}/extrapatch-src-VBox-Additions-x11-x11include-xorg-server-1.17.1-compiler.h .if ${COMPILER_FEATURES:Mlibc++} EXTRA_PATCHES+= ${PATCHDIR}/extrapatch-src-VBox-Additions-x11-VBoxClient-Makefile.kmk .endif .endif .if ${ARCH} == "amd64" .if !exists(/usr/lib32/libc.so) pre-everything:: @${ECHO} 'Requires 32-bit libraries installed under /usr/lib32.' @${ECHO} 'Do: cd /usr/src; make build32 install32; service ldconfig restart' @${FALSE} .endif .endif post-patch: @${ECHO} 'VBOX_ONLY_ADDITIONS = 1' > ${WRKSRC}/LocalConfig.kmk @${ECHO} 'VBOX_WITH_DRAG_AND_DROP = ${VBOX_WITH_X11}' >> \ ${WRKSRC}/LocalConfig.kmk @${ECHO} 'VBOX_WITH_DRAG_AND_DROP_GH = ${VBOX_WITH_X11}' >> \ ${WRKSRC}/LocalConfig.kmk @${ECHO} 'VBOX_WITH_X11_ADDITIONS = ${VBOX_WITH_X11}' >> \ ${WRKSRC}/LocalConfig.kmk .if ${COMPILER_TYPE} == clang @${REINPLACE_CMD} -e 's| -finline-limit=8000||' \ -e 's| -fno-merge-constants||' \ -e 's| -mpreferred-stack-boundary=2||' ${WRKSRC}/Config.kmk .if ${COMPILER_FEATURES:Mlibc++} @${ECHO} 'VBOX_GCC_std = -std=c++11' >> ${WRKSRC}/LocalConfig.kmk .endif @${ECHO} 'VBOX_GCC_Wno-unused-parameter = -Wno-unused-parameter' >> \ ${WRKSRC}/LocalConfig.kmk .endif @${REINPLACE_CMD} -e 's|/usr/local|${LOCALBASE}|g' \ ${WRKSRC}/Config.kmk ${WRKSRC}/configure \ ${WRKSRC}/kBuild/header.kmk ${WRKSRC}/kBuild/units/qt4.kmk \ ${WRKSRC}/kBuild/units/qt5.kmk ${WRKSRC}/kBuild/sdks/LIBSDL.kmk \ ${WRKSRC}/src/VBox/Additions/common/crOpenGL/load.c \ ${WRKSRC}/src/VBox/Additions/x11/Installer/98vboxadd-xclient \ ${WRKSRC}/src/VBox/Additions/x11/Installer/vboxclient.desktop @${REINPLACE_CMD} \ -e 's|\$$KBUILDDIR_BIN/kmk_sed|${LOCALBASE}/bin/kmk_sed|g' \ ${WRKSRC}/configure .if empty(ICONV_LIB) @${REINPLACE_CMD} -e 's|iconv||' ${WRKSRC}/Config.kmk \ ${WRKSRC}/src/VBox/Runtime/Makefile.kmk \ ${WRKSRC}/src/VBox/Additions/x11/VBoxClient/Makefile.kmk @${ECHO} 'VBOX_ICONV_DEFS = LIBICONV_PLUG' >> ${WRKSRC}/LocalConfig.kmk .endif pre-build: cd ${WRKSRC} && ${SH} -c \ '. env.sh && ${KMK_CONFIG} ${LOCALBASE}/bin/kmk ${KMK_FLAGS}' do-install: ${MKDIR} ${STAGEDIR}${KMODDIR} ${INSTALL_KLD} ${VBOX_BIN}/src/vboxguest/vboxguest.ko \ ${STAGEDIR}${KMODDIR} ${INSTALL_KLD} ${VBOX_BIN}/vboxvfs.ko ${STAGEDIR}${KMODDIR} ${INSTALL_LIB} ${VBOX_BIN}/pam_vbox.so ${STAGEDIR}${PREFIX}/lib ${INSTALL_PROGRAM} ${VBOX_SBINS:S|^|${VBOX_BIN}/|} \ ${STAGEDIR}${PREFIX}/sbin/ do-install-DEBUG-on: ${INSTALL_KLD} ${VBOX_BIN}/src/vboxguest/vboxguest.ko.symbols \ ${STAGEDIR}${KMODDIR} do-install-X11-on: ${INSTALL_PROGRAM} ${VBOX_BIN}/VBoxClient ${STAGEDIR}${PREFIX}/bin/ ${INSTALL_SCRIPT} \ ${WRKSRC}/src/VBox/Additions/x11/Installer/98vboxadd-xclient \ ${STAGEDIR}${PREFIX}/bin/VBoxClient-all # X11 autostart ${MKDIR} ${STAGEDIR}${PREFIX}/etc/xdg/autostart/ ${INSTALL_DATA} \ ${WRKSRC}/src/VBox/Additions/x11/Installer/vboxclient.desktop \ ${STAGEDIR}${PREFIX}/etc/xdg/autostart/ # KDE autostart ${MKDIR} ${STAGEDIR}${PREFIX}/share/autostart/ ${INSTALL_DATA} \ ${WRKSRC}/src/VBox/Additions/x11/Installer/vboxclient.desktop \ ${STAGEDIR}${PREFIX}/share/autostart/ ${MKDIR} ${STAGEDIR}${VIDEODIR} ${INSTALL_DATA} ${VBOX_BIN}/vboxvideo_drv_$$(${XORG_DRV_ABI}).so \ ${STAGEDIR}${VIDEODIR}/vboxvideo_drv.so ${MKDIR} ${STAGEDIR}${INPUTDIR} ${INSTALL_DATA} ${VBOX_BIN}/vboxmouse_drv_$$(${XORG_DRV_ABI}).so \ ${STAGEDIR}${INPUTDIR}/vboxmouse_drv.so do-install-OPENGL-on: ${INSTALL_DATA} ${FILESDIR}/vboxvideo.conf \ ${STAGEDIR}${PREFIX}/etc/libmap.d/ ${INSTALL_DATA} ${VBOX_LIBS:S|^|${VBOX_BIN}/|} \ ${STAGEDIR}${PREFIX}/lib/ .include Index: head/emulators/virtualbox-ose-additions/distinfo =================================================================== --- head/emulators/virtualbox-ose-additions/distinfo (revision 446840) +++ head/emulators/virtualbox-ose-additions/distinfo (revision 446841) @@ -1,3 +1,3 @@ -TIMESTAMP = 1500394674 -SHA256 (VirtualBox-5.1.24.tar.bz2) = ee2db169a322bf0db3c3b6d8b84aa39236f36cbf37d0a4c10ab65902a396bb60 -SIZE (VirtualBox-5.1.24.tar.bz2) = 116135442 +TIMESTAMP = 1501255973 +SHA256 (VirtualBox-5.1.26.tar.bz2) = b5715035e681a11ef1475f83f9503d34a00f0276b89c572eebec363dda80c8a9 +SIZE (VirtualBox-5.1.26.tar.bz2) = 115915813 Index: head/emulators/virtualbox-ose-kmod/Makefile =================================================================== --- head/emulators/virtualbox-ose-kmod/Makefile (revision 446840) +++ head/emulators/virtualbox-ose-kmod/Makefile (revision 446841) @@ -1,111 +1,111 @@ # Created by: Bernhard Froehlich # $FreeBSD$ PORTNAME= virtualbox-ose -PORTVERSION= 5.1.24 +PORTVERSION= 5.1.26 CATEGORIES= emulators MASTER_SITES= http://download.virtualbox.org/virtualbox/${PORTVERSION}/ PKGNAMESUFFIX= -kmod DISTNAME= VirtualBox-${PORTVERSION} MAINTAINER= vbox@FreeBSD.org COMMENT= VirtualBox kernel module for FreeBSD LICENSE= GPLv2 LICENSE_FILE= ${WRKSRC}/COPYING BUILD_DEPENDS= kmk:devel/kBuild CPE_VENDOR= oracle CPE_PRODUCT= vm_virtualbox USES= cpe kmod tar:bzip2 PATCHDIR= ${.CURDIR}/../${PORTNAME}/files WRKSRC= ${WRKDIR}/VirtualBox-${PORTVERSION} USE_RC_SUBR= vboxnet ONLY_FOR_ARCHS= i386 amd64 HAS_CONFIGURE= yes CONFIGURE_ARGS+= --build-headless CONFIGURE_ARGS+= --disable-alsa \ --disable-dbus \ --disable-docs \ --disable-libvpx \ --disable-pulse \ --disable-python \ --disable-sdl-ttf \ --disable-xpcom CONFIGURE_ARGS+= --nofatal --with-gcc="${CC}" --with-g++="${CXX}" CONFLICTS_INSTALL= virtualbox-ose-kmod-devel-* \ virtualbox-ose-kmod-legacy-* OPTIONS_DEFINE= DEBUG VIMAGE OPTIONS_SUB= yes DEBUG_DESC= Debug symbols, additional logs and assertions VIMAGE_DESC= VIMAGE virtual networking support .include VBOX_BIN= ${WRKSRC}/out/${KMK_ARCH}/${KMK_BUILDTYPE}/bin/src VBOX_KMODS= vboxdrv \ vboxnetadp \ vboxnetflt BUILD_WRKSRC= ${VBOX_BIN} KMK_BUILDTYPE= release KMK_CONFIG= VBOX_LIBPATH_X11=${LOCALBASE} VBOX_FREEBSD_SRC=${SRC_BASE}/sys KMK_FLAGS= HostDrivers-scripts vboxdrv-mod VBoxNetFlt-src VBoxNetAdp-src .if ${PORT_OPTIONS:MDEBUG} KMK_FLAGS+= BUILD_TYPE=debug KMK_BUILDTYPE= debug EXTRA_PATCHES+= ${PATCHDIR}/extrapatch-Config.kmk \ ${PATCHDIR}/extrapatch-src-VBox-HostDrivers-Support-freebsd-Makefile MAKE_ARGS+= DEBUG_FLAGS="-O1 -g" .endif .if ${ARCH} == i386 KMK_ARCH= freebsd.x86 .else KMK_ARCH= freebsd.${ARCH} .endif .include .if ${OSREL:R} >= 11 SYMBOLSUFFIX= debug .else SYMBOLSUFFIX= symbols .endif PLIST_SUB+= SYMBOLSUFFIX=${SYMBOLSUFFIX} post-patch: @${ECHO} 'VBOX_WITH_VBOXDRV = 1' > ${WRKSRC}/LocalConfig.kmk @${ECHO} 'VBOX_WITH_NETFLT = 1' >> ${WRKSRC}/LocalConfig.kmk @${ECHO} 'VBOX_WITH_NETADP = 1' >> ${WRKSRC}/LocalConfig.kmk @${ECHO} 'VBOX_WITH_ADDITIONS =' >> ${WRKSRC}/LocalConfig.kmk .if ${PORT_OPTIONS:MVIMAGE} @${ECHO} 'VBOX_WITH_NETFLT_VIMAGE = 1' >> ${WRKSRC}/LocalConfig.kmk .endif @${REINPLACE_CMD} -e 's|/usr/local|${LOCALBASE}|g' \ ${WRKSRC}/Config.kmk ${WRKSRC}/configure @${REINPLACE_CMD} \ -e 's|\$$KBUILDDIR_BIN/kmk_sed|${LOCALBASE}/bin/kmk_sed|g' \ ${WRKSRC}/configure pre-build: cd ${WRKSRC}/src/VBox/HostDrivers && ${SH} -c \ '. ${WRKSRC}/env.sh && ${KMK_CONFIG} ${LOCALBASE}/bin/kmk ${KMK_FLAGS}' do-install: ${MKDIR} ${STAGEDIR}${KMODDIR} .for i in ${VBOX_KMODS} ${INSTALL_KLD} ${VBOX_BIN}/${i}/${i}.ko ${STAGEDIR}${KMODDIR} .if ${PORT_OPTIONS:MDEBUG} ${INSTALL_KLD} ${VBOX_BIN}/${i}/${i}.ko.${SYMBOLSUFFIX} ${STAGEDIR}${KMODDIR} .endif .endfor .include Index: head/emulators/virtualbox-ose-kmod/distinfo =================================================================== --- head/emulators/virtualbox-ose-kmod/distinfo (revision 446840) +++ head/emulators/virtualbox-ose-kmod/distinfo (revision 446841) @@ -1,3 +1,3 @@ -TIMESTAMP = 1500394674 -SHA256 (VirtualBox-5.1.24.tar.bz2) = ee2db169a322bf0db3c3b6d8b84aa39236f36cbf37d0a4c10ab65902a396bb60 -SIZE (VirtualBox-5.1.24.tar.bz2) = 116135442 +TIMESTAMP = 1501255973 +SHA256 (VirtualBox-5.1.26.tar.bz2) = b5715035e681a11ef1475f83f9503d34a00f0276b89c572eebec363dda80c8a9 +SIZE (VirtualBox-5.1.26.tar.bz2) = 115915813