automount.h		automount.h
	skipping to change at line 39		skipping to change at line 39
	typedef enum AutomountState {		typedef enum AutomountState {
	AUTOMOUNT_DEAD,		AUTOMOUNT_DEAD,
	AUTOMOUNT_WAITING,		AUTOMOUNT_WAITING,
	AUTOMOUNT_RUNNING,		AUTOMOUNT_RUNNING,
	AUTOMOUNT_FAILED,		AUTOMOUNT_FAILED,
	_AUTOMOUNT_STATE_MAX,		_AUTOMOUNT_STATE_MAX,
	_AUTOMOUNT_STATE_INVALID = -1		_AUTOMOUNT_STATE_INVALID = -1
	} AutomountState;		} AutomountState;
	struct Automount {		struct Automount {
	Meta meta;		Unit meta;
	AutomountState state, deserialized_state;		AutomountState state, deserialized_state;
	char *where;		char *where;
	UnitRef mount;		UnitRef mount;
	int pipe_fd;		int pipe_fd;
	mode_t directory_mode;		mode_t directory_mode;
	Watch pipe_watch;		Watch pipe_watch;
End of changes. 1 change blocks.
	1 lines changed or deleted		1 lines changed or added

	cgroup-show.h		cgroup-show.h
	skipping to change at line 25		skipping to change at line 25
	systemd is distributed in the hope that it will be useful, but		systemd is distributed in the hope that it will be useful, but
	WITHOUT ANY WARRANTY; without even the implied warranty of		WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU		MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	General Public License for more details.		General Public License for more details.
	You should have received a copy of the GNU General Public License		You should have received a copy of the GNU General Public License
	along with systemd; If not, see <http://www.gnu.org/licenses/>.		along with systemd; If not, see <http://www.gnu.org/licenses/>.
	***/		***/
	int show_cgroup_by_path(const char *path, const char *prefix, unsigned colu		#include <stdbool.h>
	mns);
	int show_cgroup(const char *controller, const char *path, const char *prefi		int show_cgroup_by_path(const char *path, const char *prefix, unsigned colu
	x, unsigned columns);		mns, bool kernel_threads);
			int show_cgroup(const char *controller, const char *path, const char *prefi
			x, unsigned columns, bool kernel_threads);
	#endif		#endif
End of changes. 1 change blocks.
	4 lines changed or deleted		6 lines changed or added

	cgroup-util.h		cgroup-util.h
	skipping to change at line 63		skipping to change at line 63
	int cg_trim(const char *controller, const char *path, bool delete_root);		int cg_trim(const char *controller, const char *path, bool delete_root);
	int cg_rmdir(const char *controller, const char *path, bool honour_sticky);		int cg_rmdir(const char *controller, const char *path, bool honour_sticky);
	int cg_delete(const char *controller, const char *path);		int cg_delete(const char *controller, const char *path);
	int cg_create(const char *controller, const char *path);		int cg_create(const char *controller, const char *path);
	int cg_attach(const char *controller, const char *path, pid_t pid);		int cg_attach(const char *controller, const char *path, pid_t pid);
	int cg_create_and_attach(const char *controller, const char *path, pid_t pi d);		int cg_create_and_attach(const char *controller, const char *path, pid_t pi d);
	int cg_set_group_access(const char *controller, const char *path, mode_t mo de, uid_t uid, gid_t gid);		int cg_set_group_access(const char *controller, const char *path, mode_t mo de, uid_t uid, gid_t gid);
	int cg_set_task_access(const char *controller, const char *path, mode_t mod e, uid_t uid, gid_t gid);		int cg_set_task_access(const char *controller, const char *path, mode_t mod e, uid_t uid, gid_t gid, int sticky);
	int cg_install_release_agent(const char *controller, const char *agent);		int cg_install_release_agent(const char *controller, const char *agent);
	int cg_is_empty(const char *controller, const char *path, bool ignore_self) ;		int cg_is_empty(const char *controller, const char *path, bool ignore_self) ;
	int cg_is_empty_recursive(const char *controller, const char *path, bool ig nore_self);		int cg_is_empty_recursive(const char *controller, const char *path, bool ig nore_self);
	int cg_get_user_path(char **path);		int cg_get_user_path(char **path);
	#endif		#endif
End of changes. 1 change blocks.
	1 lines changed or deleted		1 lines changed or added

	cgroup.h		cgroup.h
	skipping to change at line 56		skipping to change at line 56
	/* If we cannot create this group, or add a process to it, is this fatal? */		/* If we cannot create this group, or add a process to it, is this fatal? */
	bool essential:1;		bool essential:1;
	/* This cgroup is realized */		/* This cgroup is realized */
	bool realized:1;		bool realized:1;
	};		};
	int cgroup_bonding_realize(CGroupBonding *b);		int cgroup_bonding_realize(CGroupBonding *b);
	int cgroup_bonding_realize_list(CGroupBonding *first);		int cgroup_bonding_realize_list(CGroupBonding *first);
	void cgroup_bonding_free(CGroupBonding *b, bool remove_or_trim);		void cgroup_bonding_free(CGroupBonding *b, bool trim);
	void cgroup_bonding_free_list(CGroupBonding *first, bool remove_or_trim);		void cgroup_bonding_free_list(CGroupBonding *first, bool trim);
	int cgroup_bonding_install(CGroupBonding *b, pid_t pid);		int cgroup_bonding_install(CGroupBonding *b, pid_t pid);
	int cgroup_bonding_install_list(CGroupBonding *first, pid_t pid);		int cgroup_bonding_install_list(CGroupBonding *first, pid_t pid);
	int cgroup_bonding_set_group_access(CGroupBonding *b, mode_t mode, uid_t ui d, gid_t gid);		int cgroup_bonding_set_group_access(CGroupBonding *b, mode_t mode, uid_t ui d, gid_t gid);
	int cgroup_bonding_set_group_access_list(CGroupBonding *b, mode_t mode, uid _t uid, gid_t gid);		int cgroup_bonding_set_group_access_list(CGroupBonding *b, mode_t mode, uid _t uid, gid_t gid);
	int cgroup_bonding_set_task_access(CGroupBonding *b, mode_t mode, uid_t uid		int cgroup_bonding_set_task_access(CGroupBonding *b, mode_t mode, uid_t uid
	, gid_t gid);		, gid_t gid, int sticky);
	int cgroup_bonding_set_task_access_list(CGroupBonding *b, mode_t mode, uid_		int cgroup_bonding_set_task_access_list(CGroupBonding *b, mode_t mode, uid_
	t uid, gid_t gid);		t uid, gid_t gid, int sticky);
	int cgroup_bonding_kill(CGroupBonding *b, int sig, bool sigcont, Set *s);		int cgroup_bonding_kill(CGroupBonding *b, int sig, bool sigcont, Set *s);
	int cgroup_bonding_kill_list(CGroupBonding *first, int sig, bool sigcont, S et *s);		int cgroup_bonding_kill_list(CGroupBonding *first, int sig, bool sigcont, S et *s);
	void cgroup_bonding_trim(CGroupBonding *first, bool delete_root);		void cgroup_bonding_trim(CGroupBonding *first, bool delete_root);
	void cgroup_bonding_trim_list(CGroupBonding *first, bool delete_root);		void cgroup_bonding_trim_list(CGroupBonding *first, bool delete_root);
	int cgroup_bonding_is_empty(CGroupBonding *b);		int cgroup_bonding_is_empty(CGroupBonding *b);
	int cgroup_bonding_is_empty_list(CGroupBonding *first);		int cgroup_bonding_is_empty_list(CGroupBonding *first);
End of changes. 2 change blocks.
	6 lines changed or deleted		6 lines changed or added

	conf-parser.h		conf-parser.h
	skipping to change at line 98		skipping to change at line 98
	bool relaxed,		bool relaxed,
	void *userdata);		void *userdata);
	/* Generic parsers */		/* Generic parsers */
	int config_parse_int(const char *filename, unsigned line, const char *secti on, const char *lvalue, int ltype, const char *rvalue, void *data, void *us erdata);		int config_parse_int(const char *filename, unsigned line, const char *secti on, const char *lvalue, int ltype, const char *rvalue, void *data, void *us erdata);
	int config_parse_unsigned(const char *filename, unsigned line, const char * section, const char *lvalue, int ltype, const char *rvalue, void *data, voi d *userdata);		int config_parse_unsigned(const char *filename, unsigned line, const char * section, const char *lvalue, int ltype, const char *rvalue, void *data, voi d *userdata);
	int config_parse_long(const char *filename, unsigned line, const char *sect ion, const char *lvalue, int ltype, const char *rvalue, void *data, void *u serdata);		int config_parse_long(const char *filename, unsigned line, const char *sect ion, const char *lvalue, int ltype, const char *rvalue, void *data, void *u serdata);
	int config_parse_uint64(const char *filename, unsigned line, const char *se ction, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata);		int config_parse_uint64(const char *filename, unsigned line, const char *se ction, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata);
	int config_parse_size(const char *filename, unsigned line, const char *sect ion, const char *lvalue, int ltype, const char *rvalue, void *data, void *u serdata);		int config_parse_size(const char *filename, unsigned line, const char *sect ion, const char *lvalue, int ltype, const char *rvalue, void *data, void *u serdata);
	int config_parse_bool(const char *filename, unsigned line, const char *sect ion, const char *lvalue, int ltype, const char *rvalue, void *data, void *u serdata);		int config_parse_bool(const char *filename, unsigned line, const char *sect ion, const char *lvalue, int ltype, const char *rvalue, void *data, void *u serdata);
			int config_parse_tristate(const char *filename, unsigned line, const char * section, const char *lvalue, int ltype, const char *rvalue, void *data, voi d *userdata);
	int config_parse_string(const char *filename, unsigned line, const char *se ction, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata);		int config_parse_string(const char *filename, unsigned line, const char *se ction, const char *lvalue, int ltype, const char *rvalue, void *data, void *userdata);
	int config_parse_path(const char *filename, unsigned line, const char *sect ion, const char *lvalue, int ltype, const char *rvalue, void *data, void *u serdata);		int config_parse_path(const char *filename, unsigned line, const char *sect ion, const char *lvalue, int ltype, const char *rvalue, void *data, void *u serdata);
	int config_parse_strv(const char *filename, unsigned line, const char *sect ion, const char *lvalue, int ltype, const char *rvalue, void *data, void *u serdata);		int config_parse_strv(const char *filename, unsigned line, const char *sect ion, const char *lvalue, int ltype, const char *rvalue, void *data, void *u serdata);
	int config_parse_path_strv(const char *filename, unsigned line, const char *section, const char *lvalue, int ltype, const char *rvalue, void *data, vo id *userdata);		int config_parse_path_strv(const char *filename, unsigned line, const char *section, const char *lvalue, int ltype, const char *rvalue, void *data, vo id *userdata);
	int config_parse_usec(const char *filename, unsigned line, const char *sect ion, const char *lvalue, int ltype, const char *rvalue, void *data, void *u serdata);		int config_parse_usec(const char *filename, unsigned line, const char *sect ion, const char *lvalue, int ltype, const char *rvalue, void *data, void *u serdata);
	int config_parse_mode(const char *filename, unsigned line, const char *sect ion, const char *lvalue, int ltype, const char *rvalue, void *data, void *u serdata);		int config_parse_mode(const char *filename, unsigned line, const char *sect ion, const char *lvalue, int ltype, const char *rvalue, void *data, void *u serdata);
	int config_parse_bytes(const char *filename, unsigned line, const char *sec tion, const char *lvalue, int ltype, const char *rvalue, void *data, void * userdata);		int config_parse_bytes(const char *filename, unsigned line, const char *sec tion, const char *lvalue, int ltype, const char *rvalue, void *data, void * userdata);
	#define DEFINE_CONFIG_PARSE_ENUM(function,name,type,msg) \		#define DEFINE_CONFIG_PARSE_ENUM(function,name,type,msg) \
	int function( \		int function( \
End of changes. 1 change blocks.
	0 lines changed or deleted		1 lines changed or added

	config.h		config.h
	skipping to change at line 108		skipping to change at line 108
	/* Name of package */		/* Name of package */
	#define PACKAGE "systemd"		#define PACKAGE "systemd"
	/* Define to the address where bug reports for this package should be sent. */		/* Define to the address where bug reports for this package should be sent. */
	#define PACKAGE_BUGREPORT "systemd-devel@lists.freedesktop.org"		#define PACKAGE_BUGREPORT "systemd-devel@lists.freedesktop.org"
	/* Define to the full name of this package. */		/* Define to the full name of this package. */
	#define PACKAGE_NAME "systemd"		#define PACKAGE_NAME "systemd"
	/* Define to the full name and version of this package. */		/* Define to the full name and version of this package. */
	#define PACKAGE_STRING "systemd 38"		#define PACKAGE_STRING "systemd 39"
	/* Define to the one symbol short name of this package. */		/* Define to the one symbol short name of this package. */
	#define PACKAGE_TARNAME "systemd"		#define PACKAGE_TARNAME "systemd"
	/* Define to the home page for this package. */		/* Define to the home page for this package. */
	#define PACKAGE_URL ""		#define PACKAGE_URL ""
	/* Define to the version of this package. */		/* Define to the version of this package. */
	#define PACKAGE_VERSION "38"		#define PACKAGE_VERSION "39"
	/* Define to 1 if you have the ANSI C header files. */		/* Define to 1 if you have the ANSI C header files. */
	#define STDC_HEADERS 1		#define STDC_HEADERS 1
	/* Target is ALTLinux */		/* Target is ALTLinux */
	/* #undef TARGET_ALTLINUX */		/* #undef TARGET_ALTLINUX */
	/* Target is Ångström */		/* Target is Ångström */
	/* #undef TARGET_ANGSTROM */		/* #undef TARGET_ANGSTROM */
	skipping to change at line 186		skipping to change at line 186
	/* Enable extensions on HP NonStop. */		/* Enable extensions on HP NonStop. */
	#ifndef _TANDEM_SOURCE		#ifndef _TANDEM_SOURCE
	# define _TANDEM_SOURCE 1		# define _TANDEM_SOURCE 1
	#endif		#endif
	/* Enable general extensions on Solaris. */		/* Enable general extensions on Solaris. */
	#ifndef __EXTENSIONS__		#ifndef __EXTENSIONS__
	# define __EXTENSIONS__ 1		# define __EXTENSIONS__ 1
	#endif		#endif
	/* Version number of package */		/* Version number of package */
	#define VERSION "38"		#define VERSION "39"
	/* Number of bits in a file offset, on hosts where this is settable. */		/* Number of bits in a file offset, on hosts where this is settable. */
	#define _FILE_OFFSET_BITS 64		#define _FILE_OFFSET_BITS 64
	/* Define for large files, on AIX-style hosts. */		/* Define for large files, on AIX-style hosts. */
	/* #undef _LARGE_FILES */		/* #undef _LARGE_FILES */
	/* Define to 1 if on MINIX. */		/* Define to 1 if on MINIX. */
	/* #undef _MINIX */		/* #undef _MINIX */
End of changes. 3 change blocks.
	3 lines changed or deleted		3 lines changed or added

	dbus-common.h		dbus-common.h
	skipping to change at line 99		skipping to change at line 99
	int bus_connect_system_ssh(const char *user, const char *host, DBusConnecti on **_bus, DBusError *error);		int bus_connect_system_ssh(const char *user, const char *host, DBusConnecti on **_bus, DBusError *error);
	int bus_connect_system_polkit(DBusConnection **_bus, DBusError *error);		int bus_connect_system_polkit(DBusConnection **_bus, DBusError *error);
	const char *bus_error_message(const DBusError *error);		const char *bus_error_message(const DBusError *error);
	typedef int (*BusPropertyCallback)(DBusMessageIter *iter, const char *prope rty, void *data);		typedef int (*BusPropertyCallback)(DBusMessageIter *iter, const char *prope rty, void *data);
	typedef int (*BusPropertySetCallback)(DBusMessageIter *iter, const char *pr operty);		typedef int (*BusPropertySetCallback)(DBusMessageIter *iter, const char *pr operty);
	typedef struct BusProperty {		typedef struct BusProperty {
	const char *interface; /* interface of the property */
	const char *property; /* name of the property */		const char *property; /* name of the property */
	BusPropertyCallback append; /* Function that is called to seri alize this property */		BusPropertyCallback append; /* Function that is called to seri alize this property */
	const char *signature;		const char *signature;
	const void *data; /* The data of this property */		const uint16_t offset; /* Offset from BusBoundProperties:
			:base address to the property data.
			* uint16_t is sufficient, because
			we have no structs too big.
			* -Werror=overflow will catch it
			if this does not hold. */
			bool indirect; /* data is indirect, ie. not base+
			offset, but *(base+offset) */
	BusPropertySetCallback set; /* Optional: Function that is call ed to set this property */		BusPropertySetCallback set; /* Optional: Function that is call ed to set this property */
	} BusProperty;		} BusProperty;
			typedef struct BusBoundProperties {
			const char *interface; /* interface of the properties */
			const BusProperty *properties; /* array of properties, ended by a
			NULL-filled element */
			const void *const base; /* base pointer to which the offse
			t must be added to reach data */
			} BusBoundProperties;
	DBusHandlerResult bus_send_error_reply(		DBusHandlerResult bus_send_error_reply(
	DBusConnection *c,		DBusConnection *c,
	DBusMessage *message,		DBusMessage *message,
	DBusError *bus_error,		DBusError *bus_error,
	int error);		int error);
	DBusHandlerResult bus_default_message_handler(		DBusHandlerResult bus_default_message_handler(
	DBusConnection *c,		DBusConnection *c,
	DBusMessage *message,		DBusMessage *message,
	const char *introspection,		const char *introspection,
	const char *interfaces,		const char *interfaces,
	const BusProperty *properties);		const BusBoundProperties *bound_properties);
	int bus_property_append_string(DBusMessageIter *i, const char *property, vo id *data);		int bus_property_append_string(DBusMessageIter *i, const char *property, vo id *data);
	int bus_property_append_strv(DBusMessageIter *i, const char *property, void *data);		int bus_property_append_strv(DBusMessageIter *i, const char *property, void *data);
	int bus_property_append_bool(DBusMessageIter *i, const char *property, void *data);		int bus_property_append_bool(DBusMessageIter *i, const char *property, void *data);
			int bus_property_append_tristate_false(DBusMessageIter *i, const char *prop erty, void *data);
	int bus_property_append_int32(DBusMessageIter *i, const char *property, voi d *data);		int bus_property_append_int32(DBusMessageIter *i, const char *property, voi d *data);
	int bus_property_append_uint32(DBusMessageIter *i, const char *property, vo id *data);		int bus_property_append_uint32(DBusMessageIter *i, const char *property, vo id *data);
	int bus_property_append_uint64(DBusMessageIter *i, const char *property, vo id *data);		int bus_property_append_uint64(DBusMessageIter *i, const char *property, vo id *data);
	int bus_property_append_size(DBusMessageIter *i, const char *property, void *data);		int bus_property_append_size(DBusMessageIter *i, const char *property, void *data);
	int bus_property_append_ul(DBusMessageIter *i, const char *property, void * data);		int bus_property_append_ul(DBusMessageIter *i, const char *property, void * data);
	int bus_property_append_long(DBusMessageIter *i, const char *property, void *data);		int bus_property_append_long(DBusMessageIter *i, const char *property, void *data);
	#define bus_property_append_int bus_property_append_int32		#define bus_property_append_int bus_property_append_int32
	#define bus_property_append_pid bus_property_append_uint32		#define bus_property_append_pid bus_property_append_uint32
	#define bus_property_append_uid bus_property_append_uint32		#define bus_property_append_uid bus_property_append_uint32
End of changes. 5 change blocks.
	3 lines changed or deleted		18 lines changed or added

	dbus-execute.h		dbus-execute.h
	skipping to change at line 28		skipping to change at line 28
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU		MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	General Public License for more details.		General Public License for more details.
	You should have received a copy of the GNU General Public License		You should have received a copy of the GNU General Public License
	along with systemd; If not, see <http://www.gnu.org/licenses/>.		along with systemd; If not, see <http://www.gnu.org/licenses/>.
	***/		***/
	#include <dbus/dbus.h>		#include <dbus/dbus.h>
	#include "manager.h"		#include "manager.h"
			#include "dbus-common.h"
	#define BUS_EXEC_STATUS_INTERFACE(prefix) \		#define BUS_EXEC_STATUS_INTERFACE(prefix) \
	" <property name=\"" prefix "StartTimestamp\" type=\"t\" access=\" read\"/>\n" \		" <property name=\"" prefix "StartTimestamp\" type=\"t\" access=\" read\"/>\n" \
	" <property name=\"" prefix "StartTimestampMonotonic\" type=\"t\" access=\"read\"/>\n" \		" <property name=\"" prefix "StartTimestampMonotonic\" type=\"t\" access=\"read\"/>\n" \
	" <property name=\"" prefix "ExitTimestamp\" type=\"t\" access=\"r ead\"/>\n" \		" <property name=\"" prefix "ExitTimestamp\" type=\"t\" access=\"r ead\"/>\n" \
	" <property name=\"" prefix "ExitTimestampMonotonic\" type=\"t\" a ccess=\"read\"/>\n" \		" <property name=\"" prefix "ExitTimestampMonotonic\" type=\"t\" a ccess=\"read\"/>\n" \
	" <property name=\"" prefix "PID\" type=\"u\" access=\"read\"/>\n" \		" <property name=\"" prefix "PID\" type=\"u\" access=\"read\"/>\n" \
	" <property name=\"" prefix "Code\" type=\"i\" access=\"read\"/>\n " \		" <property name=\"" prefix "Code\" type=\"i\" access=\"read\"/>\n " \
	" <property name=\"" prefix "Status\" type=\"i\" access=\"read\"/> \n"		" <property name=\"" prefix "Status\" type=\"i\" access=\"read\"/> \n"
	skipping to change at line 96		skipping to change at line 97
	" <property name=\"ReadWriteDirectories\" type=\"as\" access=\"rea d\"/>\n" \		" <property name=\"ReadWriteDirectories\" type=\"as\" access=\"rea d\"/>\n" \
	" <property name=\"ReadOnlyDirectories\" type=\"as\" access=\"read \"/>\n" \		" <property name=\"ReadOnlyDirectories\" type=\"as\" access=\"read \"/>\n" \
	" <property name=\"InaccessibleDirectories\" type=\"as\" access=\" read\"/>\n" \		" <property name=\"InaccessibleDirectories\" type=\"as\" access=\" read\"/>\n" \
	" <property name=\"MountFlags\" type=\"t\" access=\"read\"/>\n" \		" <property name=\"MountFlags\" type=\"t\" access=\"read\"/>\n" \
	" <property name=\"PrivateTmp\" type=\"b\" access=\"read\"/>\n" \		" <property name=\"PrivateTmp\" type=\"b\" access=\"read\"/>\n" \
	" <property name=\"SameProcessGroup\" type=\"b\" access=\"read\"/> \n" \		" <property name=\"SameProcessGroup\" type=\"b\" access=\"read\"/> \n" \
	" <property name=\"KillMode\" type=\"s\" access=\"read\"/>\n" \		" <property name=\"KillMode\" type=\"s\" access=\"read\"/>\n" \
	" <property name=\"KillSignal\" type=\"i\" access=\"read\"/>\n" \		" <property name=\"KillSignal\" type=\"i\" access=\"read\"/>\n" \
	" <property name=\"UtmpIdentifier\" type=\"s\" access=\"read\"/>\n " \		" <property name=\"UtmpIdentifier\" type=\"s\" access=\"read\"/>\n " \
	" <property name=\"ControlGroupModify\" type=\"b\" access=\"read\" />\n" \		" <property name=\"ControlGroupModify\" type=\"b\" access=\"read\" />\n" \
			" <property name=\"ControlGroupPersistent\" type=\"b\" access=\"re ad\"/>\n" \
	" <property name=\"PrivateNetwork\" type=\"b\" access=\"read\"/>\n "		" <property name=\"PrivateNetwork\" type=\"b\" access=\"read\"/>\n "
	#define BUS_EXEC_COMMAND_INTERFACE(name) \		#define BUS_EXEC_COMMAND_INTERFACE(name) \
	" <property name=\"" name "\" type=\"a(sasbttuii)\" access=\"read\ "/>\n"		" <property name=\"" name "\" type=\"a(sasbttuii)\" access=\"read\ "/>\n"
	#define BUS_EXEC_CONTEXT_PROPERTIES(interface, context) \		extern const BusProperty bus_exec_context_properties[];
	{ interface, "Environment", bus_property_append_s
	trv, "as", (context).environment }, \
	{ interface, "EnvironmentFiles", bus_execute_append_en
	v_files, "a(sb)", (context).environment_files }, \
	{ interface, "UMask", bus_property_append_m
	ode, "u", &(context).umask }, \
	{ interface, "LimitCPU", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitFSIZE", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitDATA", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitSTACK", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitCORE", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitRSS", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitNOFILE", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitAS", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitNPROC", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitMEMLOCK", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitLOCKS", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitSIGPENDING", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitMSGQUEUE", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitNICE", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitRTPRIO", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "LimitRTTIME", bus_execute_append_rl
	imits, "t", &(context) }, \
	{ interface, "WorkingDirectory", bus_property_append_s
	tring, "s", (context).working_directory }, \
	{ interface, "RootDirectory", bus_property_append_s
	tring, "s", (context).root_directory }, \
	{ interface, "OOMScoreAdjust", bus_execute_append_oo
	m_score_adjust, "i", &(context) }, \
	{ interface, "Nice", bus_execute_append_ni
	ce, "i", &(context) }, \
	{ interface, "IOScheduling", bus_execute_append_io
	prio, "i", &(context) }, \
	{ interface, "CPUSchedulingPolicy", bus_execute_append_cp
	u_sched_policy, "i", &(context) }, \
	{ interface, "CPUSchedulingPriority", bus_execute_append_cp
	u_sched_priority, "i", &(context) }, \
	{ interface, "CPUAffinity", bus_execute_append_af
	finity,"ay", &(context) }, \
	{ interface, "TimerSlackNSec", bus_execute_append_ti
	mer_slack_nsec, "t", &(context) }, \
	{ interface, "CPUSchedulingResetOnFork", bus_property_append_b
	ool, "b", &(context).cpu_sched_reset_on_fork }, \
	{ interface, "NonBlocking", bus_property_append_b
	ool, "b", &(context).non_blocking }, \
	{ interface, "StandardInput", bus_execute_append_in
	put, "s", &(context).std_input }, \
	{ interface, "StandardOutput", bus_execute_append_ou
	tput, "s", &(context).std_output }, \
	{ interface, "StandardError", bus_execute_append_ou
	tput, "s", &(context).std_error }, \
	{ interface, "TTYPath", bus_property_append_s
	tring, "s", (context).tty_path }, \
	{ interface, "TTYReset", bus_property_append_b
	ool, "b", &(context).tty_reset }, \
	{ interface, "TTYVHangup", bus_property_append_b
	ool, "b", &(context).tty_vhangup }, \
	{ interface, "TTYVTDisallocate", bus_property_append_b
	ool, "b", &(context).tty_vt_disallocate }, \
	{ interface, "SyslogPriority", bus_property_append_i
	nt, "i", &(context).syslog_priority }, \
	{ interface, "SyslogIdentifier", bus_property_append_s
	tring, "s", (context).syslog_identifier }, \
	{ interface, "SyslogLevelPrefix", bus_property_append_b
	ool, "b", &(context).syslog_level_prefix }, \
	{ interface, "Capabilities", bus_execute_append_ca
	pabilities, "s",&(context) }, \
	{ interface, "SecureBits", bus_property_append_i
	nt, "i", &(context).secure_bits }, \
	{ interface, "CapabilityBoundingSet", bus_execute_append_ca
	pability_bs, "t", &(context).capability_bounding_set_drop }, \
	{ interface, "User", bus_property_append_s
	tring, "s", (context).user }, \
	{ interface, "Group", bus_property_append_s
	tring, "s", (context).group }, \
	{ interface, "SupplementaryGroups", bus_property_append_s
	trv, "as", (context).supplementary_groups }, \
	{ interface, "TCPWrapName", bus_property_append_s
	tring, "s", (context).tcpwrap_name }, \
	{ interface, "PAMName", bus_property_append_s
	tring, "s", (context).pam_name }, \
	{ interface, "ReadWriteDirectories", bus_property_append_s
	trv, "as", (context).read_write_dirs }, \
	{ interface, "ReadOnlyDirectories", bus_property_append_s
	trv, "as", (context).read_only_dirs }, \
	{ interface, "InaccessibleDirectories", bus_property_append_s
	trv, "as", (context).inaccessible_dirs }, \
	{ interface, "MountFlags", bus_property_append_u
	l, "t", &(context).mount_flags }, \
	{ interface, "PrivateTmp", bus_property_append_b
	ool, "b", &(context).private_tmp }, \
	{ interface, "PrivateNetwork", bus_property_append_b
	ool, "b", &(context).private_network }, \
	{ interface, "SameProcessGroup", bus_property_append_b
	ool, "b", &(context).same_pgrp }, \
	{ interface, "KillMode", bus_execute_append_ki
	ll_mode, "s", &(context).kill_mode }, \
	{ interface, "KillSignal", bus_property_append_i
	nt, "i", &(context).kill_signal }, \
	{ interface, "UtmpIdentifier", bus_property_append_s
	tring, "s", (context).utmp_id }, \
	{ interface, "ControlGroupModify", bus_property_append_b
	ool, "b", &(context).control_group_modify }
	#define BUS_EXEC_STATUS_PROPERTIES(interface, estatus, prefix) \
	{ interface, prefix "StartTimestamp", bus_property_append_u
	sec, "t", &(estatus).start_timestamp.realtime }, \
	{ interface, prefix "StartTimestampMonotonic",bus_property_append_u
	sec, "t", &(estatus).start_timestamp.monotonic }, \
	{ interface, prefix "ExitTimestamp", bus_property_append_u
	sec, "t", &(estatus).start_timestamp.realtime }, \
	{ interface, prefix "ExitTimestampMonotonic", bus_property_append_u
	sec, "t", &(estatus).start_timestamp.monotonic }, \
	{ interface, prefix "PID", bus_property_append_p
	id, "u", &(estatus).pid }, \
	{ interface, prefix "Code", bus_property_append_i
	nt, "i", &(estatus).code }, \
	{ interface, prefix "Status", bus_property_append_i
	nt, "i", &(estatus).status }
	#define BUS_EXEC_COMMAND_PROPERTY(interface, command, name) \		#define BUS_EXEC_COMMAND_PROPERTY(name, command, indirect) \
	{ interface, name, bus_execute_append_command, "a(sasbttttuii)", (c		{ name, bus_execute_append_command, "a(sasbttttuii)", (command), (i
	ommand) }		ndirect), NULL }
	int bus_execute_append_output(DBusMessageIter *i, const char *property, voi d *data);		int bus_execute_append_output(DBusMessageIter *i, const char *property, voi d *data);
	int bus_execute_append_input(DBusMessageIter *i, const char *property, void *data);		int bus_execute_append_input(DBusMessageIter *i, const char *property, void *data);
	int bus_execute_append_oom_score_adjust(DBusMessageIter *i, const char *pro perty, void *data);		int bus_execute_append_oom_score_adjust(DBusMessageIter *i, const char *pro perty, void *data);
	int bus_execute_append_nice(DBusMessageIter *i, const char *property, void *data);		int bus_execute_append_nice(DBusMessageIter *i, const char *property, void *data);
	int bus_execute_append_ioprio(DBusMessageIter *i, const char *property, voi d *data);		int bus_execute_append_ioprio(DBusMessageIter *i, const char *property, voi d *data);
	int bus_execute_append_cpu_sched_policy(DBusMessageIter *i, const char *pro perty, void *data);		int bus_execute_append_cpu_sched_policy(DBusMessageIter *i, const char *pro perty, void *data);
	int bus_execute_append_cpu_sched_priority(DBusMessageIter *i, const char *p roperty, void *data);		int bus_execute_append_cpu_sched_priority(DBusMessageIter *i, const char *p roperty, void *data);
	int bus_execute_append_affinity(DBusMessageIter *i, const char *property, v oid *data);		int bus_execute_append_affinity(DBusMessageIter *i, const char *property, v oid *data);
	int bus_execute_append_timer_slack_nsec(DBusMessageIter *i, const char *pro perty, void *data);		int bus_execute_append_timer_slack_nsec(DBusMessageIter *i, const char *pro perty, void *data);
End of changes. 4 change blocks.
	138 lines changed or deleted		6 lines changed or added

	dbus-unit.h		dbus-unit.h
	skipping to change at line 28		skipping to change at line 28
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU		MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	General Public License for more details.		General Public License for more details.
	You should have received a copy of the GNU General Public License		You should have received a copy of the GNU General Public License
	along with systemd; If not, see <http://www.gnu.org/licenses/>.		along with systemd; If not, see <http://www.gnu.org/licenses/>.
	***/		***/
	#include <dbus/dbus.h>		#include <dbus/dbus.h>
	#include "manager.h"		#include "manager.h"
			#include "dbus-common.h"
	#define BUS_UNIT_INTERFACE \		#define BUS_UNIT_INTERFACE \
	" <interface name=\"org.freedesktop.systemd1.Unit\">\n" \		" <interface name=\"org.freedesktop.systemd1.Unit\">\n" \
	" <method name=\"Start\">\n" \		" <method name=\"Start\">\n" \
	" <arg name=\"mode\" type=\"s\" direction=\"in\"/>\n" \		" <arg name=\"mode\" type=\"s\" direction=\"in\"/>\n" \
	" <arg name=\"job\" type=\"o\" direction=\"out\"/>\n" \		" <arg name=\"job\" type=\"o\" direction=\"out\"/>\n" \
	" </method>\n" \		" </method>\n" \
	" <method name=\"Stop\">\n" \		" <method name=\"Stop\">\n" \
	" <arg name=\"mode\" type=\"s\" direction=\"in\"/>\n" \		" <arg name=\"mode\" type=\"s\" direction=\"in\"/>\n" \
	" <arg name=\"job\" type=\"o\" direction=\"out\"/>\n" \		" <arg name=\"job\" type=\"o\" direction=\"out\"/>\n" \
	skipping to change at line 129		skipping to change at line 130
	" <property name=\"ConditionTimestamp\" type=\"t\" access=\"read\" />\n" \		" <property name=\"ConditionTimestamp\" type=\"t\" access=\"read\" />\n" \
	" <property name=\"ConditionTimestampMonotonic\" type=\"t\" access =\"read\"/>\n" \		" <property name=\"ConditionTimestampMonotonic\" type=\"t\" access =\"read\"/>\n" \
	" <property name=\"ConditionResult\" type=\"b\" access=\"read\"/>\ n" \		" <property name=\"ConditionResult\" type=\"b\" access=\"read\"/>\ n" \
	" <property name=\"LoadError\" type=\"(ss)\" access=\"read\"/>\n" \		" <property name=\"LoadError\" type=\"(ss)\" access=\"read\"/>\n" \
	" </interface>\n"		" </interface>\n"
	#define BUS_UNIT_INTERFACES_LIST \		#define BUS_UNIT_INTERFACES_LIST \
	BUS_GENERIC_INTERFACES_LIST \		BUS_GENERIC_INTERFACES_LIST \
	"org.freedesktop.systemd1.Unit\0"		"org.freedesktop.systemd1.Unit\0"
	#define BUS_UNIT_PROPERTIES \		extern const BusProperty bus_unit_properties[];
	{ "org.freedesktop.systemd1.Unit", "Id", bus_prop
	erty_append_string, "s", u->meta.id }, \
	{ "org.freedesktop.systemd1.Unit", "Names", bus_unit
	_append_names, "as", u }, \
	{ "org.freedesktop.systemd1.Unit", "Following", bus_unit
	_append_following, "s", u }, \
	{ "org.freedesktop.systemd1.Unit", "Requires", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_REQUIRES] }, \
	{ "org.freedesktop.systemd1.Unit", "RequiresOverridable", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_REQUIRES_OVERRIDA
	BLE] }, \
	{ "org.freedesktop.systemd1.Unit", "Requisite", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_REQUISITE] }, \
	{ "org.freedesktop.systemd1.Unit", "RequisiteOverridable", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_REQUISITE_OVERRID
	ABLE] }, \
	{ "org.freedesktop.systemd1.Unit", "Wants", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_WANTS] }, \
	{ "org.freedesktop.systemd1.Unit", "BindTo", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_BIND_TO] }, \
	{ "org.freedesktop.systemd1.Unit", "RequiredBy", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_REQUIRED_BY] }, \
	{ "org.freedesktop.systemd1.Unit", "RequiredByOverridable",bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_REQUIRED_BY_OVERR
	IDABLE] }, \
	{ "org.freedesktop.systemd1.Unit", "WantedBy", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_WANTED_BY] }, \
	{ "org.freedesktop.systemd1.Unit", "BoundBy", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_BOUND_BY] }, \
	{ "org.freedesktop.systemd1.Unit", "Conflicts", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_CONFLICTS] }, \
	{ "org.freedesktop.systemd1.Unit", "ConflictedBy", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_CONFLICTED_BY] },
	\
	{ "org.freedesktop.systemd1.Unit", "Before", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_BEFORE] }, \
	{ "org.freedesktop.systemd1.Unit", "After", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_AFTER] }, \
	{ "org.freedesktop.systemd1.Unit", "OnFailure", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_ON_FAILURE] }, \
	{ "org.freedesktop.systemd1.Unit", "Triggers", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_TRIGGERS] }, \
	{ "org.freedesktop.systemd1.Unit", "TriggeredBy", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_TRIGGERED_BY] },
	\
	{ "org.freedesktop.systemd1.Unit", "PropagateReloadTo", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_PROPAGATE_RELOAD_
	TO] }, \
	{ "org.freedesktop.systemd1.Unit", "PropagateReloadFrom", bus_unit
	_append_dependencies, "as", u->meta.dependencies[UNIT_PROPAGATE_RELOAD_
	FROM] }, \
	{ "org.freedesktop.systemd1.Unit", "Description", bus_unit
	_append_description, "s", u }, \
	{ "org.freedesktop.systemd1.Unit", "LoadState", bus_unit
	_append_load_state, "s", &u->meta.load_state }, \
	{ "org.freedesktop.systemd1.Unit", "ActiveState", bus_unit
	_append_active_state, "s", u }, \
	{ "org.freedesktop.systemd1.Unit", "SubState", bus_unit
	_append_sub_state, "s", u }, \
	{ "org.freedesktop.systemd1.Unit", "FragmentPath", bus_prop
	erty_append_string, "s", u->meta.fragment_path }, \
	{ "org.freedesktop.systemd1.Unit", "UnitFileState", bus_unit
	_append_file_state, "s", u }, \
	{ "org.freedesktop.systemd1.Unit", "InactiveExitTimestamp",bus_prop
	erty_append_usec, "t", &u->meta.inactive_exit_timestamp.realtime }
	, \
	{ "org.freedesktop.systemd1.Unit", "InactiveExitTimestampMonotonic"
	,bus_property_append_usec, "t", &u->meta.inactive_exit_timestamp.monotonic
	}, \
	{ "org.freedesktop.systemd1.Unit", "ActiveEnterTimestamp", bus_prop
	erty_append_usec, "t", &u->meta.active_enter_timestamp.realtime },
	\
	{ "org.freedesktop.systemd1.Unit", "ActiveEnterTimestampMonotonic",
	bus_property_append_usec, "t", &u->meta.active_enter_timestamp.monotonic }
	, \
	{ "org.freedesktop.systemd1.Unit", "ActiveExitTimestamp", bus_prop
	erty_append_usec, "t", &u->meta.active_exit_timestamp.realtime },
	\
	{ "org.freedesktop.systemd1.Unit", "ActiveExitTimestampMonotonic",
	bus_property_append_usec, "t", &u->meta.active_exit_timestamp.monotonic },
	\
	{ "org.freedesktop.systemd1.Unit", "InactiveEnterTimestamp",bus_pro
	perty_append_usec, "t", &u->meta.inactive_enter_timestamp.realtime
	}, \
	{ "org.freedesktop.systemd1.Unit", "InactiveEnterTimestampMonotonic
	",bus_property_append_usec,"t", &u->meta.inactive_enter_timestamp.monotonic
	}, \
	{ "org.freedesktop.systemd1.Unit", "CanStart", bus_unit
	_append_can_start, "b", u }, \
	{ "org.freedesktop.systemd1.Unit", "CanStop", bus_unit
	_append_can_stop, "b", u }, \
	{ "org.freedesktop.systemd1.Unit", "CanReload", bus_unit
	_append_can_reload, "b", u }, \
	{ "org.freedesktop.systemd1.Unit", "CanIsolate", bus_unit
	_append_can_isolate, "b", u }, \
	{ "org.freedesktop.systemd1.Unit", "Job", bus_unit
	_append_job, "(uo)", u }, \
	{ "org.freedesktop.systemd1.Unit", "StopWhenUnneeded", bus_prop
	erty_append_bool, "b", &u->meta.stop_when_unneeded }, \
	{ "org.freedesktop.systemd1.Unit", "RefuseManualStart", bus_prop
	erty_append_bool, "b", &u->meta.refuse_manual_start }, \
	{ "org.freedesktop.systemd1.Unit", "RefuseManualStop", bus_prop
	erty_append_bool, "b", &u->meta.refuse_manual_stop }, \
	{ "org.freedesktop.systemd1.Unit", "AllowIsolate", bus_prop
	erty_append_bool, "b", &u->meta.allow_isolate }, \
	{ "org.freedesktop.systemd1.Unit", "DefaultDependencies", bus_prop
	erty_append_bool, "b", &u->meta.default_dependencies }, \
	{ "org.freedesktop.systemd1.Unit", "OnFailureIsolate", bus_prop
	erty_append_bool, "b", &u->meta.on_failure_isolate }, \
	{ "org.freedesktop.systemd1.Unit", "IgnoreOnIsolate", bus_prop
	erty_append_bool, "b", &u->meta.ignore_on_isolate }, \
	{ "org.freedesktop.systemd1.Unit", "IgnoreOnSnapshot", bus_prop
	erty_append_bool, "b", &u->meta.ignore_on_snapshot }, \
	{ "org.freedesktop.systemd1.Unit", "DefaultControlGroup", bus_unit
	_append_default_cgroup, "s", u }, \
	{ "org.freedesktop.systemd1.Unit", "ControlGroup", bus_unit
	_append_cgroups, "as", u }, \
	{ "org.freedesktop.systemd1.Unit", "ControlGroupAttributes", bus_un
	it_append_cgroup_attrs, "a(sss)", u }, \
	{ "org.freedesktop.systemd1.Unit", "NeedDaemonReload", bus_unit
	_append_need_daemon_reload, "b", u }, \
	{ "org.freedesktop.systemd1.Unit", "JobTimeoutUSec", bus_prop
	erty_append_usec, "t", &u->meta.job_timeout }, \
	{ "org.freedesktop.systemd1.Unit", "ConditionTimestamp", bus_prop
	erty_append_usec, "t", &u->meta.condition_timestamp.realtime }, \
	{ "org.freedesktop.systemd1.Unit", "ConditionTimestampMonotonic", b
	us_property_append_usec,"t", &u->meta.condition_timestamp.monotonic }, \
	{ "org.freedesktop.systemd1.Unit", "ConditionResult", bus_prop
	erty_append_bool, "b", &u->meta.condition_result }, \
	{ "org.freedesktop.systemd1.Unit", "LoadError", bus_unit
	_append_load_error, "(ss)", u }
	int bus_unit_append_names(DBusMessageIter *i, const char *property, void *d
	ata);
	int bus_unit_append_following(DBusMessageIter *i, const char *property, voi
	d *data);
	int bus_unit_append_dependencies(DBusMessageIter *i, const char *property,
	void *data);
	int bus_unit_append_description(DBusMessageIter *i, const char *property, v
	oid *data);
	int bus_unit_append_load_state(DBusMessageIter *i, const char *property, vo
	id *data);
	int bus_unit_append_active_state(DBusMessageIter *i, const char *property,
	void *data);
	int bus_unit_append_sub_state(DBusMessageIter *i, const char *property, voi
	d *data);
	int bus_unit_append_file_state(DBusMessageIter *i, const char *property, vo
	id *data);
	int bus_unit_append_can_start(DBusMessageIter *i, const char *property, voi
	d *data);
	int bus_unit_append_can_stop(DBusMessageIter *i, const char *property, void
	*data);
	int bus_unit_append_can_reload(DBusMessageIter *i, const char *property, vo
	id *data);
	int bus_unit_append_can_isolate(DBusMessageIter *i, const char *property, v
	oid *data);
	int bus_unit_append_job(DBusMessageIter *i, const char *property, void *dat
	a);
	int bus_unit_append_default_cgroup(DBusMessageIter *i, const char *property
	, void *data);
	int bus_unit_append_cgroups(DBusMessageIter *i, const char *property, void
	*data);
	int bus_unit_append_cgroup_attrs(DBusMessageIter *i, const char *property,
	void *data);
	int bus_unit_append_need_daemon_reload(DBusMessageIter *i, const char *prop
	erty, void *data);
	int bus_unit_append_load_error(DBusMessageIter *i, const char *property, vo
	id *data);
	void bus_unit_send_change_signal(Unit *u);		void bus_unit_send_change_signal(Unit *u);
	void bus_unit_send_removed_signal(Unit *u);		void bus_unit_send_removed_signal(Unit *u);
	extern const DBusObjectPathVTable bus_unit_vtable;		extern const DBusObjectPathVTable bus_unit_vtable;
	extern const char bus_unit_interface[];		extern const char bus_unit_interface[];
	#endif		#endif
End of changes. 2 change blocks.
	169 lines changed or deleted		2 lines changed or added

	device.h		device.h
	skipping to change at line 39		skipping to change at line 39
	/* We simply watch devices, we cannot plug/unplug them. That		/* We simply watch devices, we cannot plug/unplug them. That
	* simplifies the state engine greatly */		* simplifies the state engine greatly */
	typedef enum DeviceState {		typedef enum DeviceState {
	DEVICE_DEAD,		DEVICE_DEAD,
	DEVICE_PLUGGED,		DEVICE_PLUGGED,
	_DEVICE_STATE_MAX,		_DEVICE_STATE_MAX,
	_DEVICE_STATE_INVALID = -1		_DEVICE_STATE_INVALID = -1
	} DeviceState;		} DeviceState;
	struct Device {		struct Device {
	Meta meta;		Unit meta;
	char *sysfs;		char *sysfs;
	/* In order to be able to distinguish dependencies on		/* In order to be able to distinguish dependencies on
	different device nodes we might end up creating multiple		different device nodes we might end up creating multiple
	devices for the same sysfs path. We chain them up here. */		devices for the same sysfs path. We chain them up here. */
	LIST_FIELDS(struct Device, same_sysfs);		LIST_FIELDS(struct Device, same_sysfs);
	DeviceState state;		DeviceState state;
End of changes. 1 change blocks.
	1 lines changed or deleted		1 lines changed or added

	execute.h		execute.h
	skipping to change at line 166		skipping to change at line 166
	int syslog_priority;		int syslog_priority;
	char *syslog_identifier;		char *syslog_identifier;
	bool syslog_level_prefix;		bool syslog_level_prefix;
	bool cpu_sched_reset_on_fork;		bool cpu_sched_reset_on_fork;
	bool non_blocking;		bool non_blocking;
	bool private_tmp;		bool private_tmp;
	bool private_network;		bool private_network;
	bool control_group_modify;		bool control_group_modify;
			int control_group_persistent;
	/* This is not exposed to the user but available		/* This is not exposed to the user but available
	* internally. We need it to make sure that whenever we spawn		* internally. We need it to make sure that whenever we spawn
	* /bin/mount it is run in the same process group as us so		* /bin/mount it is run in the same process group as us so
	* that the autofs logic detects that it belongs to us and we		* that the autofs logic detects that it belongs to us and we
	* don't enter a trigger loop. */		* don't enter a trigger loop. */
	bool same_pgrp;		bool same_pgrp;
	bool oom_score_adjust_set:1;		bool oom_score_adjust_set:1;
	bool nice_set:1;		bool nice_set:1;
End of changes. 1 change blocks.
	0 lines changed or deleted		1 lines changed or added

	journal-file.h		journal-file.h
	skipping to change at line 80		skipping to change at line 80
	Window windows[_WINDOW_MAX];		Window windows[_WINDOW_MAX];
	uint64_t current_offset;		uint64_t current_offset;
	JournalMetrics metrics;		JournalMetrics metrics;
	bool compress;		bool compress;
	#ifdef HAVE_XZ		#ifdef HAVE_XZ
	void *compress_buffer;		void *compress_buffer;
	size_t compress_buffer_size;		uint64_t compress_buffer_size;
	#endif		#endif
	} JournalFile;		} JournalFile;
	typedef enum direction {		typedef enum direction {
	DIRECTION_UP,		DIRECTION_UP,
	DIRECTION_DOWN		DIRECTION_DOWN
	} direction_t;		} direction_t;
	int journal_file_open(const char *fname, int flags, mode_t mode, JournalFil e *template, JournalFile **ret);		int journal_file_open(const char *fname, int flags, mode_t mode, JournalFil e *template, JournalFile **ret);
	void journal_file_close(JournalFile *j);		void journal_file_close(JournalFile *j);
End of changes. 1 change blocks.
	1 lines changed or deleted		1 lines changed or added

	journald.h		journald.h
	skipping to change at line 76		skipping to change at line 76
	bool import_proc_kmsg;		bool import_proc_kmsg;
	char proc_kmsg_buffer[LINE_MAX+1];		char proc_kmsg_buffer[LINE_MAX+1];
	size_t proc_kmsg_length;		size_t proc_kmsg_length;
	uint64_t cached_available_space;		uint64_t cached_available_space;
	usec_t cached_available_space_timestamp;		usec_t cached_available_space_timestamp;
	uint64_t var_available_timestamp;		uint64_t var_available_timestamp;
			gid_t file_gid;
			bool file_gid_valid;
	LIST_HEAD(StdoutStream, stdout_streams);		LIST_HEAD(StdoutStream, stdout_streams);
	unsigned n_stdout_streams;		unsigned n_stdout_streams;
	} Server;		} Server;
	/* gperf lookup function */		/* gperf lookup function */
	const struct ConfigPerfItem* journald_gperf_lookup(const char *key, unsigne d length);		const struct ConfigPerfItem* journald_gperf_lookup(const char *key, unsigne d length);
	#endif		#endif
End of changes. 1 change blocks.
	0 lines changed or deleted		3 lines changed or added

	log.h		log.h
	skipping to change at line 30		skipping to change at line 30
	You should have received a copy of the GNU General Public License		You should have received a copy of the GNU General Public License
	along with systemd; If not, see <http://www.gnu.org/licenses/>.		along with systemd; If not, see <http://www.gnu.org/licenses/>.
	***/		***/
	#include <syslog.h>		#include <syslog.h>
	#include <stdbool.h>		#include <stdbool.h>
	#include "macro.h"		#include "macro.h"
	/* If set to SYSLOG and /dev/log can not be opened we fall back to
	* KSMG. If KMSG fails, we fall back to CONSOLE */
	typedef enum LogTarget{		typedef enum LogTarget{
	LOG_TARGET_CONSOLE,		LOG_TARGET_CONSOLE,
	LOG_TARGET_KMSG,		LOG_TARGET_KMSG,
			LOG_TARGET_JOURNAL,
			LOG_TARGET_JOURNAL_OR_KMSG,
	LOG_TARGET_SYSLOG,		LOG_TARGET_SYSLOG,
	LOG_TARGET_SYSLOG_OR_KMSG,		LOG_TARGET_SYSLOG_OR_KMSG,
	LOG_TARGET_AUTO, /* console if stderr is tty, SYSLOG_OR_KMSG otherw ise */		LOG_TARGET_AUTO, /* console if stderr is tty, JOURNAL_OR_KMSG other wise */
	LOG_TARGET_NULL,		LOG_TARGET_NULL,
	_LOG_TARGET_MAX,		_LOG_TARGET_MAX,
	_LOG_TARGET_INVALID = -1		_LOG_TARGET_INVALID = -1
	} LogTarget;		} LogTarget;
	void log_set_target(LogTarget target);		void log_set_target(LogTarget target);
	void log_set_max_level(int level);		void log_set_max_level(int level);
	int log_set_target_from_string(const char *e);		int log_set_target_from_string(const char *e);
	int log_set_max_level_from_string(const char *e);		int log_set_max_level_from_string(const char *e);
	skipping to change at line 63		skipping to change at line 63
	int log_show_location_from_string(const char *e);		int log_show_location_from_string(const char *e);
	LogTarget log_get_target(void);		LogTarget log_get_target(void);
	int log_get_max_level(void);		int log_get_max_level(void);
	int log_open(void);		int log_open(void);
	void log_close(void);		void log_close(void);
	void log_forget_fds(void);		void log_forget_fds(void);
	void log_close_syslog(void);		void log_close_syslog(void);
			void log_close_journal(void);
	void log_close_kmsg(void);		void log_close_kmsg(void);
	void log_close_console(void);		void log_close_console(void);
	void log_parse_environment(void);		void log_parse_environment(void);
	int log_meta(		int log_meta(
	int level,		int level,
	const char*file,		const char*file,
	int line,		int line,
	const char *func,		const char *func,
	const char *format, ...) _printf_attr_(5,6);		const char *format, ...) _printf_attr_(5,6);
	_noreturn_ void log_assert(		_noreturn_ void log_assert_failed(const char *text, const char *file, int l
	const char*file,		ine, const char *func);
	int line,		_noreturn_ void log_assert_failed_unreachable(const char *text, const char
	const char *func,		*file, int line, const char *func);
	const char *format, ...) _printf_attr_(4,5);
	/* This modifies the buffer passed! */		/* This modifies the buffer passed! */
	int log_dump_internal(		int log_dump_internal(
	int level,		int level,
	const char*file,		const char*file,
	int line,		int line,
	const char *func,		const char *func,
	char *buffer);		char *buffer);
	#define log_full(level, ...) log_meta(level, __FILE__, __LINE__, __func__, __VA_ARGS__)		#define log_full(level, ...) log_meta(level, __FILE__, __LINE__, __func__, __VA_ARGS__)
End of changes. 5 change blocks.
	8 lines changed or deleted		8 lines changed or added

	logs-show.h		logs-show.h
	skipping to change at line 37		skipping to change at line 37
	#include <systemd/sd-journal.h>		#include <systemd/sd-journal.h>
	#include "util.h"		#include "util.h"
	typedef enum OutputMode {		typedef enum OutputMode {
	OUTPUT_SHORT,		OUTPUT_SHORT,
	OUTPUT_SHORT_MONOTONIC,		OUTPUT_SHORT_MONOTONIC,
	OUTPUT_VERBOSE,		OUTPUT_VERBOSE,
	OUTPUT_EXPORT,		OUTPUT_EXPORT,
	OUTPUT_JSON,		OUTPUT_JSON,
			OUTPUT_CAT,
	_OUTPUT_MODE_MAX,		_OUTPUT_MODE_MAX,
	_OUTPUT_MODE_INVALID = -1		_OUTPUT_MODE_INVALID = -1
	} OutputMode;		} OutputMode;
	int output_journal(sd_journal *j, OutputMode mode, unsigned line, bool show _all);		int output_journal(sd_journal *j, OutputMode mode, unsigned line, bool show _all);
	int show_journal_by_unit(		int show_journal_by_unit(
	const char *unit,		const char *unit,
	OutputMode mode,		OutputMode mode,
	const char *prefix,		const char *prefix,
End of changes. 1 change blocks.
	0 lines changed or deleted		1 lines changed or added

	macro.h		macro.h
	skipping to change at line 94		skipping to change at line 94
	__extension__ ({ \		__extension__ ({ \
	typeof(x) _x = (x); \		typeof(x) _x = (x); \
	typeof(low) _low = (low); \		typeof(low) _low = (low); \
	typeof(high) _high = (high); \		typeof(high) _high = (high); \
	((_x > _high) ? _high : ((_x < _low) ? _low : _x)); \		((_x > _high) ? _high : ((_x < _low) ? _low : _x)); \
	})		})
	#define assert_se(expr) \		#define assert_se(expr) \
	do { \		do { \
	if (_unlikely_(!(expr))) \		if (_unlikely_(!(expr))) \
	log_assert(__FILE__, __LINE__, __PRETTY_FUNCTION__,		log_assert_failed(#expr, __FILE__, __LINE__, __PRET
	\		TY_FUNCTION__); \
	"Assertion '%s' failed at %s:%u, functio
	n %s(). Aborting.", \
	#expr , __FILE__, __LINE__, __PRETTY_FUN
	CTION__); \
	} while (false) \		} while (false) \
	/* We override the glibc assert() here. */		/* We override the glibc assert() here. */
	#undef assert		#undef assert
	#ifdef NDEBUG		#ifdef NDEBUG
	#define assert(expr) do {} while(false)		#define assert(expr) do {} while(false)
	#else		#else
	#define assert(expr) assert_se(expr)		#define assert(expr) assert_se(expr)
	#endif		#endif
	#define assert_not_reached(t) \		#define assert_not_reached(t) \
	do { \		do { \
	log_assert(__FILE__, __LINE__, __PRETTY_FUNCTION__, \		log_assert_failed_unreachable(t, __FILE__, __LINE__, __PRET
	"Code should not be reached '%s' at %s:%u, funct		TY_FUNCTION__); \
	ion %s(). Aborting.", \
	t, __FILE__, __LINE__, __PRETTY_FUNCTION__); \
	} while (false)		} while (false)
	#define assert_cc(expr) \		#define assert_cc(expr) \
	do { \		do { \
	switch (0) { \		switch (0) { \
	case 0: \		case 0: \
	case !!(expr): \		case !!(expr): \
	; \		; \
	} \		} \
	} while (false)		} while (false)
End of changes. 2 change blocks.
	10 lines changed or deleted		4 lines changed or added

	manager.h		manager.h
	skipping to change at line 77		skipping to change at line 77
	WATCH_SWAP,		WATCH_SWAP,
	WATCH_UDEV,		WATCH_UDEV,
	WATCH_DBUS_WATCH,		WATCH_DBUS_WATCH,
	WATCH_DBUS_TIMEOUT		WATCH_DBUS_TIMEOUT
	};		};
	struct Watch {		struct Watch {
	int fd;		int fd;
	WatchType type;		WatchType type;
	union {		union {
	union Unit *unit;		struct Unit *unit;
	struct Job *job;		struct Job *job;
	DBusWatch *bus_watch;		DBusWatch *bus_watch;
	DBusTimeout *bus_timeout;		DBusTimeout *bus_timeout;
	} data;		} data;
	bool fd_is_dupped:1;		bool fd_is_dupped:1;
	bool socket_accept:1;		bool socket_accept:1;
	};		};
	#include "unit.h"		#include "unit.h"
	#include "job.h"		#include "job.h"
	skipping to change at line 105		skipping to change at line 105
	/* Note that the set of units we know of is allowed to be		/* Note that the set of units we know of is allowed to be
	* inconsistent. However the subset of it that is loaded may		* inconsistent. However the subset of it that is loaded may
	* not, and the list of jobs may neither. */		* not, and the list of jobs may neither. */
	/* Active jobs and units */		/* Active jobs and units */
	Hashmap *units; /* name string => Unit object n:1 */		Hashmap *units; /* name string => Unit object n:1 */
	Hashmap *jobs; /* job id => Job object 1:1 */		Hashmap *jobs; /* job id => Job object 1:1 */
	/* To make it easy to iterate through the units of a specific		/* To make it easy to iterate through the units of a specific
	* type we maintain a per type linked list */		* type we maintain a per type linked list */
	LIST_HEAD(Meta, units_by_type[_UNIT_TYPE_MAX]);		LIST_HEAD(Unit, units_by_type[_UNIT_TYPE_MAX]);
	/* Units that need to be loaded */		/* Units that need to be loaded */
	LIST_HEAD(Meta, load_queue); /* this is actually more a stack than a queue, but uh. */		LIST_HEAD(Unit, load_queue); /* this is actually more a stack than a queue, but uh. */
	/* Jobs that need to be run */		/* Jobs that need to be run */
	LIST_HEAD(Job, run_queue); /* more a stack than a queue, too */		LIST_HEAD(Job, run_queue); /* more a stack than a queue, too */
	/* Units and jobs that have not yet been announced via		/* Units and jobs that have not yet been announced via
	* D-Bus. When something about a job changes it is added here		* D-Bus. When something about a job changes it is added here
	* if it is not in there yet. This allows easy coalescing of		* if it is not in there yet. This allows easy coalescing of
	* D-Bus change signals. */		* D-Bus change signals. */
	LIST_HEAD(Meta, dbus_unit_queue);		LIST_HEAD(Unit, dbus_unit_queue);
	LIST_HEAD(Job, dbus_job_queue);		LIST_HEAD(Job, dbus_job_queue);
	/* Units to remove */		/* Units to remove */
	LIST_HEAD(Meta, cleanup_queue);		LIST_HEAD(Unit, cleanup_queue);
	/* Units to check when doing GC */		/* Units to check when doing GC */
	LIST_HEAD(Meta, gc_queue);		LIST_HEAD(Unit, gc_queue);
	/* Jobs to be added */		/* Jobs to be added */
	Hashmap *transaction_jobs; /* Unit object => Job object list 1 :1 */		Hashmap *transaction_jobs; /* Unit object => Job object list 1 :1 */
	JobDependency *transaction_anchor;		JobDependency *transaction_anchor;
	Hashmap *watch_pids; /* pid => Unit object n:1 */		Hashmap *watch_pids; /* pid => Unit object n:1 */
	char *notify_socket;		char *notify_socket;
	Watch notify_watch;		Watch notify_watch;
	skipping to change at line 292		skipping to change at line 292
	void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success);		void manager_send_unit_audit(Manager *m, Unit *u, int type, bool success);
	void manager_send_unit_plymouth(Manager *m, Unit *u);		void manager_send_unit_plymouth(Manager *m, Unit *u);
	bool manager_unit_pending_inactive(Manager *m, const char *name);		bool manager_unit_pending_inactive(Manager *m, const char *name);
	void manager_check_finished(Manager *m);		void manager_check_finished(Manager *m);
	void manager_run_generators(Manager *m);		void manager_run_generators(Manager *m);
	void manager_undo_generators(Manager *m);		void manager_undo_generators(Manager *m);
	void manager_recheck_syslog(Manager *m);		void manager_recheck_journal(Manager *m);
	void manager_set_show_status(Manager *m, bool b);		void manager_set_show_status(Manager *m, bool b);
	bool manager_get_show_status(Manager *m);		bool manager_get_show_status(Manager *m);
	const char *manager_running_as_to_string(ManagerRunningAs i);		const char *manager_running_as_to_string(ManagerRunningAs i);
	ManagerRunningAs manager_running_as_from_string(const char *s);		ManagerRunningAs manager_running_as_from_string(const char *s);
	#endif		#endif
End of changes. 7 change blocks.
	7 lines changed or deleted		7 lines changed or added

	mount.h		mount.h
	skipping to change at line 63		skipping to change at line 63
	} MountExecCommand;		} MountExecCommand;
	typedef struct MountParameters {		typedef struct MountParameters {
	char *what;		char *what;
	char *options;		char *options;
	char *fstype;		char *fstype;
	int passno;		int passno;
	} MountParameters;		} MountParameters;
	struct Mount {		struct Mount {
	Meta meta;		Unit meta;
	char *where;		char *where;
	MountParameters parameters_etc_fstab;		MountParameters parameters_etc_fstab;
	MountParameters parameters_proc_self_mountinfo;		MountParameters parameters_proc_self_mountinfo;
	MountParameters parameters_fragment;		MountParameters parameters_fragment;
	bool from_etc_fstab:1;		bool from_etc_fstab:1;
	bool from_proc_self_mountinfo:1;		bool from_proc_self_mountinfo:1;
	bool from_fragment:1;		bool from_fragment:1;
End of changes. 1 change blocks.
	1 lines changed or deleted		1 lines changed or added

	path.h		path.h
	skipping to change at line 73		skipping to change at line 73
	int path_spec_watch(PathSpec *s, Unit *u);		int path_spec_watch(PathSpec *s, Unit *u);
	void path_spec_unwatch(PathSpec *s, Unit *u);		void path_spec_unwatch(PathSpec *s, Unit *u);
	int path_spec_fd_event(PathSpec *s, uint32_t events);		int path_spec_fd_event(PathSpec *s, uint32_t events);
	void path_spec_done(PathSpec *s);		void path_spec_done(PathSpec *s);
	static inline bool path_spec_owns_inotify_fd(PathSpec *s, int fd) {		static inline bool path_spec_owns_inotify_fd(PathSpec *s, int fd) {
	return s->inotify_fd == fd;		return s->inotify_fd == fd;
	}		}
	struct Path {		struct Path {
	Meta meta;		Unit meta;
	LIST_HEAD(PathSpec, specs);		LIST_HEAD(PathSpec, specs);
	UnitRef unit;		UnitRef unit;
	PathState state, deserialized_state;		PathState state, deserialized_state;
	bool failure;		bool failure;
	bool inotify_triggered;		bool inotify_triggered;
End of changes. 1 change blocks.
	1 lines changed or deleted		1 lines changed or added

	sd-id128.h		sd-id128.h
	skipping to change at line 29		skipping to change at line 29
	General Public License for more details.		General Public License for more details.
	You should have received a copy of the GNU General Public License		You should have received a copy of the GNU General Public License
	along with systemd; If not, see <http://www.gnu.org/licenses/>.		along with systemd; If not, see <http://www.gnu.org/licenses/>.
	***/		***/
	#include <inttypes.h>		#include <inttypes.h>
	#include <stdbool.h>		#include <stdbool.h>
	#include <string.h>		#include <string.h>
			#ifdef __cplusplus
			extern "C" {
			#endif
	typedef union sd_id128 sd_id128_t;		typedef union sd_id128 sd_id128_t;
	union sd_id128 {		union sd_id128 {
	uint8_t bytes[16];		uint8_t bytes[16];
	uint64_t qwords[2];		uint64_t qwords[2];
	};		};
	char *sd_id128_to_string(sd_id128_t id, char s[33]);		char *sd_id128_to_string(sd_id128_t id, char s[33]);
	int sd_id128_from_string(const char s[33], sd_id128_t *ret);		int sd_id128_from_string(const char s[33], sd_id128_t *ret);
	skipping to change at line 61		skipping to change at line 65
	* times. It is hence not a good idea to call this macro with an		* times. It is hence not a good idea to call this macro with an
	* expensive function as paramater or an expression with side		* expensive function as paramater or an expression with side
	* effects */		* effects */
	#define SD_ID128_FORMAT_STR "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%0 2x%02x%02x%02x%02x"		#define SD_ID128_FORMAT_STR "%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%0 2x%02x%02x%02x%02x"
	#define SD_ID128_FORMAT_VAL(x) (x).bytes[0], (x).bytes[1], (x).bytes[2], (x ).bytes[3], (x).bytes[4], (x).bytes[5], (x).bytes[6], (x).bytes[7], (x).byt es[8], (x).bytes[9], (x).bytes[10], (x).bytes[11], (x).bytes[12], (x).bytes [13], (x).bytes[14], (x).bytes[15]		#define SD_ID128_FORMAT_VAL(x) (x).bytes[0], (x).bytes[1], (x).bytes[2], (x ).bytes[3], (x).bytes[4], (x).bytes[5], (x).bytes[6], (x).bytes[7], (x).byt es[8], (x).bytes[9], (x).bytes[10], (x).bytes[11], (x).bytes[12], (x).bytes [13], (x).bytes[14], (x).bytes[15]
	static inline bool sd_id128_equal(sd_id128_t a, sd_id128_t b) {		static inline bool sd_id128_equal(sd_id128_t a, sd_id128_t b) {
	return memcmp(&a, &b, 16) == 0;		return memcmp(&a, &b, 16) == 0;
	}		}
			#ifdef __cplusplus
			}
			#endif
	#endif		#endif
End of changes. 2 change blocks.
	0 lines changed or deleted		8 lines changed or added

	sd-journal.h		sd-journal.h
	skipping to change at line 32		skipping to change at line 32
	along with systemd; If not, see <http://www.gnu.org/licenses/>.		along with systemd; If not, see <http://www.gnu.org/licenses/>.
	***/		***/
	#include <inttypes.h>		#include <inttypes.h>
	#include <sys/types.h>		#include <sys/types.h>
	#include <stdarg.h>		#include <stdarg.h>
	#include <sys/uio.h>		#include <sys/uio.h>
	#include <systemd/sd-id128.h>		#include <systemd/sd-id128.h>
	/* TODO:		#ifdef __cplusplus
	*		extern "C" {
	* - OR of matches is borked...		#endif
	* - extend hash tables table as we go
	* - accelerate looking for "all hostnames" and suchlike.
	* - handle incomplete header
	*
	* - kann NTP nicht finden?
	*
	* - local deserializer
	* - http server
	* - message catalog
	*
	* - check LE/BE conversion for 8bit, 16bit, 32bit values
	* - cryptographic hash
	* - think about manipulations of header
	* - implement audit gateway
	*/
	/* Write to daemon */		/* Write to daemon */
	int sd_journal_print(int piority, const char *format, ...) __attribute__ (( format (printf, 2, 3)));		int sd_journal_print(int piority, const char *format, ...) __attribute__ (( format (printf, 2, 3)));
	int sd_journal_printv(int priority, const char *format, va_list ap);		int sd_journal_printv(int priority, const char *format, va_list ap);
	int sd_journal_send(const char *format, ...) __attribute__((sentinel));		int sd_journal_send(const char *format, ...) __attribute__((sentinel));
	int sd_journal_sendv(const struct iovec *iov, int n);		int sd_journal_sendv(const struct iovec *iov, int n);
	int sd_journal_stream_fd(const char *identifier, int priority, int level_pr efix);		int sd_journal_stream_fd(const char *identifier, int priority, int level_pr efix);
	skipping to change at line 125		skipping to change at line 110
	#define SD_JOURNAL_FOREACH_BACKWARDS(j) \		#define SD_JOURNAL_FOREACH_BACKWARDS(j) \
	if (sd_journal_seek_tail(j) >= 0) \		if (sd_journal_seek_tail(j) >= 0) \
	while (sd_journal_previous(j) > 0)		while (sd_journal_previous(j) > 0)
	#define SD_JOURNAL_FOREACH_DATA(j, data, l) \		#define SD_JOURNAL_FOREACH_DATA(j, data, l) \
	for (sd_journal_restart_data(j); sd_journal_enumerate_data((j), &(d ata), &(l)) > 0; )		for (sd_journal_restart_data(j); sd_journal_enumerate_data((j), &(d ata), &(l)) > 0; )
	#define SD_JOURNAL_FOREACH_UNIQUE(j, data, l) \		#define SD_JOURNAL_FOREACH_UNIQUE(j, data, l) \
	for (sd_journal_restart_unique(j); sd_journal_enumerate_data((j), & (data), &(l)) > 0; )		for (sd_journal_restart_unique(j); sd_journal_enumerate_data((j), & (data), &(l)) > 0; )
			#ifdef __cplusplus
			}
			#endif
	#endif		#endif
End of changes. 2 change blocks.
	18 lines changed or deleted		7 lines changed or added

	sd-login.h		sd-login.h
	skipping to change at line 27		skipping to change at line 27
	WITHOUT ANY WARRANTY; without even the implied warranty of		WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU		MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	General Public License for more details.		General Public License for more details.
	You should have received a copy of the GNU General Public License		You should have received a copy of the GNU General Public License
	along with systemd; If not, see <http://www.gnu.org/licenses/>.		along with systemd; If not, see <http://www.gnu.org/licenses/>.
	***/		***/
	#include <sys/types.h>		#include <sys/types.h>
			#ifdef __cplusplus
			extern "C" {
			#endif
	/*		/*
	* A few points:		* A few points:
	*		*
	* Instead of returning an empty string array or empty uid array, we		* Instead of returning an empty string array or empty uid array, we
	* may return NULL.		* may return NULL.
	*		*
	* Free the data we return with libc free().		* Free the data we return with libc free().
	*		*
	* We return error codes as negative errno, kernel-style. 0 or		* We return error codes as negative errno, kernel-style. 0 or
	* positive on success.		* positive on success.
	skipping to change at line 128		skipping to change at line 132
	/* Destroys the passed monitor. Returns NULL. */		/* Destroys the passed monitor. Returns NULL. */
	sd_login_monitor* sd_login_monitor_unref(sd_login_monitor *m);		sd_login_monitor* sd_login_monitor_unref(sd_login_monitor *m);
	/* Flushes the monitor */		/* Flushes the monitor */
	int sd_login_monitor_flush(sd_login_monitor *m);		int sd_login_monitor_flush(sd_login_monitor *m);
	/* Get FD from monitor */		/* Get FD from monitor */
	int sd_login_monitor_get_fd(sd_login_monitor *m);		int sd_login_monitor_get_fd(sd_login_monitor *m);
			#ifdef __cplusplus
			}
			#endif
	#endif		#endif
End of changes. 2 change blocks.
	0 lines changed or deleted		8 lines changed or added

	sd-messages.h		sd-messages.h
	skipping to change at line 27		skipping to change at line 27
	WITHOUT ANY WARRANTY; without even the implied warranty of		WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU		MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	General Public License for more details.		General Public License for more details.
	You should have received a copy of the GNU General Public License		You should have received a copy of the GNU General Public License
	along with systemd; If not, see <http://www.gnu.org/licenses/>.		along with systemd; If not, see <http://www.gnu.org/licenses/>.
	***/		***/
	#include <systemd/sd-id128.h>		#include <systemd/sd-id128.h>
			#ifdef __cplusplus
			extern "C" {
			#endif
	#define SD_MESSAGE_JOURNAL_START SD_ID128_MAKE(f7,73,79,a8,49,0b,40,8b,be ,5f,69,40,50,5a,77,7b)		#define SD_MESSAGE_JOURNAL_START SD_ID128_MAKE(f7,73,79,a8,49,0b,40,8b,be ,5f,69,40,50,5a,77,7b)
	#define SD_MESSAGE_JOURNAL_STOP SD_ID128_MAKE(d9,3f,b3,c9,c2,4d,45,1a,97 ,ce,a6,15,ce,59,c0,0b)		#define SD_MESSAGE_JOURNAL_STOP SD_ID128_MAKE(d9,3f,b3,c9,c2,4d,45,1a,97 ,ce,a6,15,ce,59,c0,0b)
	#define SD_MESSAGE_JOURNAL_DROPPED SD_ID128_MAKE(a5,96,d6,fe,7b,fa,49,94,82 ,8e,72,30,9e,95,d6,1e)		#define SD_MESSAGE_JOURNAL_DROPPED SD_ID128_MAKE(a5,96,d6,fe,7b,fa,49,94,82 ,8e,72,30,9e,95,d6,1e)
			#define SD_MESSAGE_COREDUMP SD_ID128_MAKE(fc,2e,22,bc,6e,e6,47,b6,b9
			,07,29,ab,34,a2,50,b1)
			#ifdef __cplusplus
			}
			#endif
	#endif		#endif
End of changes. 2 change blocks.
	0 lines changed or deleted		11 lines changed or added

	service.h		service.h
	skipping to change at line 92		skipping to change at line 92
	typedef enum NotifyAccess {		typedef enum NotifyAccess {
	NOTIFY_NONE,		NOTIFY_NONE,
	NOTIFY_ALL,		NOTIFY_ALL,
	NOTIFY_MAIN,		NOTIFY_MAIN,
	_NOTIFY_ACCESS_MAX,		_NOTIFY_ACCESS_MAX,
	_NOTIFY_ACCESS_INVALID = -1		_NOTIFY_ACCESS_INVALID = -1
	} NotifyAccess;		} NotifyAccess;
	struct Service {		struct Service {
	Meta meta;		Unit meta;
	ServiceType type;		ServiceType type;
	ServiceRestart restart;		ServiceRestart restart;
	/* If set we'll read the main daemon PID from this file */		/* If set we'll read the main daemon PID from this file */
	char *pid_file;		char *pid_file;
	usec_t restart_usec;		usec_t restart_usec;
	usec_t timeout_usec;		usec_t timeout_usec;
End of changes. 1 change blocks.
	1 lines changed or deleted		1 lines changed or added

	snapshot.h		snapshot.h
	skipping to change at line 37		skipping to change at line 37
	#include "unit.h"		#include "unit.h"
	typedef enum SnapshotState {		typedef enum SnapshotState {
	SNAPSHOT_DEAD,		SNAPSHOT_DEAD,
	SNAPSHOT_ACTIVE,		SNAPSHOT_ACTIVE,
	_SNAPSHOT_STATE_MAX,		_SNAPSHOT_STATE_MAX,
	_SNAPSHOT_STATE_INVALID = -1		_SNAPSHOT_STATE_INVALID = -1
	} SnapshotState;		} SnapshotState;
	struct Snapshot {		struct Snapshot {
	Meta meta;		Unit meta;
	SnapshotState state, deserialized_state;		SnapshotState state, deserialized_state;
	bool cleanup;		bool cleanup;
	bool by_snapshot_create:1;		bool by_snapshot_create:1;
	};		};
	extern const UnitVTable snapshot_vtable;		extern const UnitVTable snapshot_vtable;
	int snapshot_create(Manager *m, const char *name, bool cleanup, DBusError * e, Snapshot **s);		int snapshot_create(Manager *m, const char *name, bool cleanup, DBusError * e, Snapshot **s);
End of changes. 1 change blocks.
	1 lines changed or deleted		1 lines changed or added

	socket.h		socket.h
	skipping to change at line 80		skipping to change at line 80
	int fd;		int fd;
	SocketAddress address;		SocketAddress address;
	char *path;		char *path;
	Watch fd_watch;		Watch fd_watch;
	LIST_FIELDS(struct SocketPort, port);		LIST_FIELDS(struct SocketPort, port);
	} SocketPort;		} SocketPort;
	struct Socket {		struct Socket {
	Meta meta;		Unit meta;
	LIST_HEAD(SocketPort, ports);		LIST_HEAD(SocketPort, ports);
	unsigned n_accepted;		unsigned n_accepted;
	unsigned n_connections;		unsigned n_connections;
	unsigned max_connections;		unsigned max_connections;
	unsigned backlog;		unsigned backlog;
	usec_t timeout_usec;		usec_t timeout_usec;
End of changes. 1 change blocks.
	1 lines changed or deleted		1 lines changed or added

	swap.h		swap.h
	skipping to change at line 60		skipping to change at line 60
	typedef struct SwapParameters {		typedef struct SwapParameters {
	char *what;		char *what;
	int priority;		int priority;
	bool noauto:1;		bool noauto:1;
	bool nofail:1;		bool nofail:1;
	bool handle:1;		bool handle:1;
	} SwapParameters;		} SwapParameters;
	struct Swap {		struct Swap {
	Meta meta;		Unit meta;
	char *what;		char *what;
	SwapParameters parameters_etc_fstab;		SwapParameters parameters_etc_fstab;
	SwapParameters parameters_proc_swaps;		SwapParameters parameters_proc_swaps;
	SwapParameters parameters_fragment;		SwapParameters parameters_fragment;
	bool from_etc_fstab:1;		bool from_etc_fstab:1;
	bool from_proc_swaps:1;		bool from_proc_swaps:1;
	bool from_fragment:1;		bool from_fragment:1;
End of changes. 1 change blocks.
	1 lines changed or deleted		1 lines changed or added

	target.h		target.h
	skipping to change at line 37		skipping to change at line 37
	#include "unit.h"		#include "unit.h"
	typedef enum TargetState {		typedef enum TargetState {
	TARGET_DEAD,		TARGET_DEAD,
	TARGET_ACTIVE,		TARGET_ACTIVE,
	_TARGET_STATE_MAX,		_TARGET_STATE_MAX,
	_TARGET_STATE_INVALID = -1		_TARGET_STATE_INVALID = -1
	} TargetState;		} TargetState;
	struct Target {		struct Target {
	Meta meta;		Unit meta;
	TargetState state, deserialized_state;		TargetState state, deserialized_state;
	};		};
	extern const UnitVTable target_vtable;		extern const UnitVTable target_vtable;
	const char* target_state_to_string(TargetState i);		const char* target_state_to_string(TargetState i);
	TargetState target_state_from_string(const char *s);		TargetState target_state_from_string(const char *s);
	#endif		#endif
End of changes. 1 change blocks.
	1 lines changed or deleted		1 lines changed or added

	timer.h		timer.h
	skipping to change at line 60		skipping to change at line 60
	usec_t value;		usec_t value;
	usec_t next_elapse;		usec_t next_elapse;
	LIST_FIELDS(struct TimerValue, value);		LIST_FIELDS(struct TimerValue, value);
	TimerBase base;		TimerBase base;
	bool disabled;		bool disabled;
	} TimerValue;		} TimerValue;
	struct Timer {		struct Timer {
	Meta meta;		Unit meta;
	LIST_HEAD(TimerValue, values);		LIST_HEAD(TimerValue, values);
	usec_t next_elapse;		usec_t next_elapse;
	TimerState state, deserialized_state;		TimerState state, deserialized_state;
	UnitRef unit;		UnitRef unit;
	Watch timer_watch;		Watch timer_watch;
	bool failure;		bool failure;
End of changes. 1 change blocks.
	1 lines changed or deleted		1 lines changed or added

	unit.h		unit.h
	skipping to change at line 28		skipping to change at line 28
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU		MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	General Public License for more details.		General Public License for more details.
	You should have received a copy of the GNU General Public License		You should have received a copy of the GNU General Public License
	along with systemd; If not, see <http://www.gnu.org/licenses/>.		along with systemd; If not, see <http://www.gnu.org/licenses/>.
	***/		***/
	#include <stdbool.h>		#include <stdbool.h>
	#include <stdlib.h>		#include <stdlib.h>
	typedef union Unit Unit;		typedef struct Unit Unit;
	typedef struct Meta Meta;
	typedef struct UnitVTable UnitVTable;		typedef struct UnitVTable UnitVTable;
	typedef enum UnitType UnitType;		typedef enum UnitType UnitType;
	typedef enum UnitLoadState UnitLoadState;		typedef enum UnitLoadState UnitLoadState;
	typedef enum UnitActiveState UnitActiveState;		typedef enum UnitActiveState UnitActiveState;
	typedef enum UnitDependency UnitDependency;		typedef enum UnitDependency UnitDependency;
	typedef struct UnitRef UnitRef;		typedef struct UnitRef UnitRef;
	#include "set.h"		#include "set.h"
	#include "util.h"		#include "util.h"
	#include "list.h"		#include "list.h"
	skipping to change at line 144		skipping to change at line 143
	_UNIT_DEPENDENCY_MAX,		_UNIT_DEPENDENCY_MAX,
	_UNIT_DEPENDENCY_INVALID = -1		_UNIT_DEPENDENCY_INVALID = -1
	};		};
	#include "manager.h"		#include "manager.h"
	#include "job.h"		#include "job.h"
	#include "cgroup.h"		#include "cgroup.h"
	#include "cgroup-attr.h"		#include "cgroup-attr.h"
	struct Meta {		struct Unit {
	Manager *manager;		Manager *manager;
	UnitType type;		UnitType type;
	UnitLoadState load_state;		UnitLoadState load_state;
	Unit *merged_into;		Unit *merged_into;
	char *id; /* One name is special because we use it for identificati on. Points to an entry in the names set */		char *id; /* One name is special because we use it for identificati on. Points to an entry in the names set */
	char *instance;		char *instance;
	Set *names;		Set *names;
	skipping to change at line 186		skipping to change at line 185
	dual_timestamp inactive_exit_timestamp;		dual_timestamp inactive_exit_timestamp;
	dual_timestamp active_enter_timestamp;		dual_timestamp active_enter_timestamp;
	dual_timestamp active_exit_timestamp;		dual_timestamp active_exit_timestamp;
	dual_timestamp inactive_enter_timestamp;		dual_timestamp inactive_enter_timestamp;
	/* Counterparts in the cgroup filesystem */		/* Counterparts in the cgroup filesystem */
	CGroupBonding *cgroup_bondings;		CGroupBonding *cgroup_bondings;
	CGroupAttribute *cgroup_attributes;		CGroupAttribute *cgroup_attributes;
	/* Per type list */		/* Per type list */
	LIST_FIELDS(Meta, units_by_type);		LIST_FIELDS(Unit, units_by_type);
	/* Load queue */		/* Load queue */
	LIST_FIELDS(Meta, load_queue);		LIST_FIELDS(Unit, load_queue);
	/* D-Bus queue */		/* D-Bus queue */
	LIST_FIELDS(Meta, dbus_queue);		LIST_FIELDS(Unit, dbus_queue);
	/* Cleanup queue */		/* Cleanup queue */
	LIST_FIELDS(Meta, cleanup_queue);		LIST_FIELDS(Unit, cleanup_queue);
	/* GC queue */		/* GC queue */
	LIST_FIELDS(Meta, gc_queue);		LIST_FIELDS(Unit, gc_queue);
	/* Used during GC sweeps */		/* Used during GC sweeps */
	unsigned gc_marker;		unsigned gc_marker;
	/* When deserializing, temporarily store the job type for this		/* When deserializing, temporarily store the job type for this
	* unit here, if there was a job scheduled */		* unit here, if there was a job scheduled */
	int deserialized_job; /* This is actually of type JobType */		int deserialized_job; /* This is actually of type JobType */
	/* Error code when we didn't manage to load the unit (negative) */		/* Error code when we didn't manage to load the unit (negative) */
	int load_error;		int load_error;
	skipping to change at line 272		skipping to change at line 271
	#include "timer.h"		#include "timer.h"
	#include "socket.h"		#include "socket.h"
	#include "target.h"		#include "target.h"
	#include "device.h"		#include "device.h"
	#include "mount.h"		#include "mount.h"
	#include "automount.h"		#include "automount.h"
	#include "snapshot.h"		#include "snapshot.h"
	#include "swap.h"		#include "swap.h"
	#include "path.h"		#include "path.h"
	union Unit {
	Meta meta;
	Service service;
	Timer timer;
	Socket socket;
	Target target;
	Device device;
	Mount mount;
	Automount automount;
	Snapshot snapshot;
	Swap swap;
	Path path;
	};
	struct UnitVTable {		struct UnitVTable {
	const char *suffix;		const char *suffix;
			/* How much memory does an object of this unit type need */
			size_t object_size;
	/* Config file sections this unit type understands, separated		/* Config file sections this unit type understands, separated
	* by NUL chars */		* by NUL chars */
	const char *sections;		const char *sections;
	/* This should reset all type-specific variables. This should		/* This should reset all type-specific variables. This should
	* not allocate memory, and is called with zero-initialized		* not allocate memory, and is called with zero-initialized
	* data. It should hence only initialize variables that need		* data. It should hence only initialize variables that need
	* to be set != 0. */		* to be set != 0. */
	void (*init)(Unit *u);		void (*init)(Unit *u);
	skipping to change at line 413		skipping to change at line 401
	/* Exclude from automatic gc */		/* Exclude from automatic gc */
	bool no_gc:1;		bool no_gc:1;
	/* Show status updates on the console */		/* Show status updates on the console */
	bool show_status:1;		bool show_status:1;
	};		};
	extern const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX];		extern const UnitVTable * const unit_vtable[_UNIT_TYPE_MAX];
	#define UNIT_VTABLE(u) unit_vtable[(u)->meta.type]		#define UNIT_VTABLE(u) unit_vtable[(u)->type]
	/* For casting a unit into the various unit types */		/* For casting a unit into the various unit types */
	#define DEFINE_CAST(UPPERCASE, MixedCase) \		#define DEFINE_CAST(UPPERCASE, MixedCase) \
	static inline MixedCase* UPPERCASE(Unit *u) { \		static inline MixedCase* UPPERCASE(Unit *u) { \
	if (_unlikely_(!u || u->meta.type != UNIT_##UPPERCASE)) \		if (_unlikely_(!u || u->type != UNIT_##UPPERCASE)) \
	return NULL; \		return NULL; \
	\		\
	return (MixedCase*) u; \		return (MixedCase*) u; \
	}		}
	/* For casting the various unit types into a unit */		/* For casting the various unit types into a unit */
	#define UNIT(u) ((Unit*) (&(u)->meta))		#define UNIT(u) (&(u)->meta)
	DEFINE_CAST(SOCKET, Socket);		DEFINE_CAST(SOCKET, Socket);
	DEFINE_CAST(TIMER, Timer);		DEFINE_CAST(TIMER, Timer);
	DEFINE_CAST(SERVICE, Service);		DEFINE_CAST(SERVICE, Service);
	DEFINE_CAST(TARGET, Target);		DEFINE_CAST(TARGET, Target);
	DEFINE_CAST(DEVICE, Device);		DEFINE_CAST(DEVICE, Device);
	DEFINE_CAST(MOUNT, Mount);		DEFINE_CAST(MOUNT, Mount);
	DEFINE_CAST(AUTOMOUNT, Automount);		DEFINE_CAST(AUTOMOUNT, Automount);
	DEFINE_CAST(SNAPSHOT, Snapshot);		DEFINE_CAST(SNAPSHOT, Snapshot);
	DEFINE_CAST(SWAP, Swap);		DEFINE_CAST(SWAP, Swap);
	DEFINE_CAST(PATH, Path);		DEFINE_CAST(PATH, Path);
	Unit *unit_new(Manager *m);		Unit *unit_new(Manager *m, size_t size);
	void unit_free(Unit *u);		void unit_free(Unit *u);
	int unit_add_name(Unit *u, const char *name);		int unit_add_name(Unit *u, const char *name);
	int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_re ference);		int unit_add_dependency(Unit *u, UnitDependency d, Unit *other, bool add_re ference);
	int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference);		int unit_add_two_dependencies(Unit *u, UnitDependency d, UnitDependency e, Unit *other, bool add_reference);
	int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name , const char *filename, bool add_reference);		int unit_add_dependency_by_name(Unit *u, UnitDependency d, const char *name , const char *filename, bool add_reference);
	int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDepend ency e, const char *name, const char *path, bool add_reference);		int unit_add_two_dependencies_by_name(Unit *u, UnitDependency d, UnitDepend ency e, const char *name, const char *path, bool add_reference);
End of changes. 13 change blocks.
	26 lines changed or deleted		14 lines changed or added

	util.h		util.h
	skipping to change at line 70		skipping to change at line 70
	/* What is interpreted as whitespace? */		/* What is interpreted as whitespace? */
	#define WHITESPACE " \t\n\r"		#define WHITESPACE " \t\n\r"
	#define NEWLINE "\n\r"		#define NEWLINE "\n\r"
	#define QUOTES "\"\'"		#define QUOTES "\"\'"
	#define COMMENTS "#;\n"		#define COMMENTS "#;\n"
	#define FORMAT_TIMESTAMP_MAX 64		#define FORMAT_TIMESTAMP_MAX 64
	#define FORMAT_TIMESTAMP_PRETTY_MAX 256		#define FORMAT_TIMESTAMP_PRETTY_MAX 256
	#define FORMAT_TIMESPAN_MAX 64		#define FORMAT_TIMESPAN_MAX 64
			#define FORMAT_BYTES_MAX 8
	#define ANSI_HIGHLIGHT_ON "\x1B[1;31m"		#define ANSI_HIGHLIGHT_ON "\x1B[1;39m"
			#define ANSI_HIGHLIGHT_RED_ON "\x1B[1;31m"
	#define ANSI_HIGHLIGHT_GREEN_ON "\x1B[1;32m"		#define ANSI_HIGHLIGHT_GREEN_ON "\x1B[1;32m"
	#define ANSI_HIGHLIGHT_OFF "\x1B[0m"		#define ANSI_HIGHLIGHT_OFF "\x1B[0m"
	usec_t now(clockid_t clock);		usec_t now(clockid_t clock);
	dual_timestamp* dual_timestamp_get(dual_timestamp *ts);		dual_timestamp* dual_timestamp_get(dual_timestamp *ts);
	dual_timestamp* dual_timestamp_from_realtime(dual_timestamp *ts, usec_t u);		dual_timestamp* dual_timestamp_from_realtime(dual_timestamp *ts, usec_t u);
	#define dual_timestamp_is_set(ts) ((ts)->realtime > 0)		#define dual_timestamp_is_set(ts) ((ts)->realtime > 0)
	skipping to change at line 328		skipping to change at line 330
	int fd_nonblock(int fd, bool nonblock);		int fd_nonblock(int fd, bool nonblock);
	int fd_cloexec(int fd, bool cloexec);		int fd_cloexec(int fd, bool cloexec);
	int close_all_fds(const int except[], unsigned n_except);		int close_all_fds(const int except[], unsigned n_except);
	bool fstype_is_network(const char *fstype);		bool fstype_is_network(const char *fstype);
	int chvt(int vt);		int chvt(int vt);
	int read_one_char(FILE *f, char *ret, bool *need_nl);		int read_one_char(FILE *f, char *ret, usec_t timeout, bool *need_nl);
	int ask(char *ret, const char *replies, const char *text, ...);		int ask(char *ret, const char *replies, const char *text, ...);
	int reset_terminal_fd(int fd);		int reset_terminal_fd(int fd);
	int reset_terminal(const char *name);		int reset_terminal(const char *name);
	int open_terminal(const char *name, int mode);		int open_terminal(const char *name, int mode);
	int acquire_terminal(const char *name, bool fail, bool force, bool ignore_t iocstty_eperm);		int acquire_terminal(const char *name, bool fail, bool force, bool ignore_t iocstty_eperm);
	int release_terminal(void);		int release_terminal(void);
	int flush_fd(int fd);		int flush_fd(int fd);
	skipping to change at line 385		skipping to change at line 387
	cpu_set_t* cpu_set_malloc(unsigned *ncpus);		cpu_set_t* cpu_set_malloc(unsigned *ncpus);
	void status_vprintf(const char *status, bool ellipse, const char *format, v a_list ap);		void status_vprintf(const char *status, bool ellipse, const char *format, v a_list ap);
	void status_printf(const char *status, bool ellipse, const char *format, .. .);		void status_printf(const char *status, bool ellipse, const char *format, .. .);
	void status_welcome(void);		void status_welcome(void);
	int fd_columns(int fd);		int fd_columns(int fd);
	unsigned columns(void);		unsigned columns(void);
			int fd_lines(int fd);
			unsigned lines(void);
	int running_in_chroot(void);		int running_in_chroot(void);
	char *ellipsize(const char *s, size_t length, unsigned percent);		char *ellipsize(const char *s, size_t length, unsigned percent);
	char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, un signed percent);		char *ellipsize_mem(const char *s, size_t old_length, size_t new_length, un signed percent);
	int touch(const char *path);		int touch(const char *path);
	char *unquote(const char *s, const char *quotes);		char *unquote(const char *s, const char *quotes);
	char *normalize_env_assignment(const char *s);		char *normalize_env_assignment(const char *s);
	skipping to change at line 413		skipping to change at line 418
	DIR *xopendirat(int dirfd, const char *name, int flags);		DIR *xopendirat(int dirfd, const char *name, int flags);
	void dual_timestamp_serialize(FILE *f, const char *name, dual_timestamp *t) ;		void dual_timestamp_serialize(FILE *f, const char *name, dual_timestamp *t) ;
	void dual_timestamp_deserialize(const char *value, dual_timestamp *t);		void dual_timestamp_deserialize(const char *value, dual_timestamp *t);
	char *fstab_node_to_udev_node(const char *p);		char *fstab_node_to_udev_node(const char *p);
	void filter_environ(const char *prefix);		void filter_environ(const char *prefix);
	bool tty_is_vc(const char *tty);		bool tty_is_vc(const char *tty);
			bool tty_is_vc_resolve(const char *tty);
	int vtnr_from_tty(const char *tty);		int vtnr_from_tty(const char *tty);
	const char *default_term_for_tty(const char *tty);		const char *default_term_for_tty(const char *tty);
	void execute_directory(const char *directory, DIR *_d, char *argv[]);		void execute_directory(const char *directory, DIR *_d, char *argv[]);
	int kill_and_sigcont(pid_t pid, int sig);		int kill_and_sigcont(pid_t pid, int sig);
	bool nulstr_contains(const char*nulstr, const char *needle);		bool nulstr_contains(const char*nulstr, const char *needle);
	bool plymouth_running(void);		bool plymouth_running(void);
	skipping to change at line 478		skipping to change at line 484
	int get_files_in_directory(const char *path, char ***list);		int get_files_in_directory(const char *path, char ***list);
	char *join(const char *x, ...) _sentinel_;		char *join(const char *x, ...) _sentinel_;
	bool is_main_thread(void);		bool is_main_thread(void);
	bool in_charset(const char *s, const char* charset);		bool in_charset(const char *s, const char* charset);
	int block_get_whole_disk(dev_t d, dev_t *ret);		int block_get_whole_disk(dev_t d, dev_t *ret);
	int file_is_sticky(const char *p);		int file_is_priv_sticky(const char *p);
	int strdup_or_null(const char *a, char **b);		int strdup_or_null(const char *a, char **b);
	#define NULSTR_FOREACH(i, l) \		#define NULSTR_FOREACH(i, l) \
	for ((i) = (l); (i) && *(i); (i) = strchr((i), 0)+1)		for ((i) = (l); (i) && *(i); (i) = strchr((i), 0)+1)
	#define NULSTR_FOREACH_PAIR(i, j, l) \		#define NULSTR_FOREACH_PAIR(i, j, l) \
	for ((i) = (l), (j) = strchr((i), 0)+1; (i) && *(i); (i) = strchr(( j), 0)+1, (j) = *(i) ? strchr((i), 0)+1 : (i))		for ((i) = (l), (j) = strchr((i), 0)+1; (i) && *(i); (i) = strchr(( j), 0)+1, (j) = *(i) ? strchr((i), 0)+1 : (i))
	const char *ioprio_class_to_string(int i);		const char *ioprio_class_to_string(int i);
	skipping to change at line 525		skipping to change at line 531
	extern char **saved_argv;		extern char **saved_argv;
	bool kexec_loaded(void);		bool kexec_loaded(void);
	int prot_from_flags(int flags);		int prot_from_flags(int flags);
	unsigned long cap_last_cap(void);		unsigned long cap_last_cap(void);
	char *format_bytes(char *buf, size_t l, off_t t);		char *format_bytes(char *buf, size_t l, off_t t);
	int fd_wait_for_event(int fd, int event);		int fd_wait_for_event(int fd, int event, usec_t timeout);
	void* memdup(const void *p, size_t l);		void* memdup(const void *p, size_t l);
			int rtc_open(int flags);
			int is_kernel_thread(pid_t pid);
	#endif		#endif
End of changes. 8 change blocks.
	4 lines changed or deleted		14 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/