systemd: headers diff between 204 and 205 versions

	acl-util.h	acl-util.h

	skipping to change at line 27	skipping to change at line 27
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Lesser General Public License for more details.	Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public License	You should have received a copy of the GNU Lesser 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>

	int acl_find_uid(acl_t acl, uid_t uid, acl_entry_t *entry);	int acl_find_uid(acl_t acl, uid_t uid, acl_entry_t *entry);

		int calc_acl_mask_if_needed(acl_t *acl_p);
	int search_acl_groups(char*** dst, const char* path, bool* belong);	int search_acl_groups(char*** dst, const char* path, bool* belong);

End of changes. 1 change blocks.
	0 lines changed or deleted	1 lines changed or added

	bootchart.h	bootchart.h
	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/

	#pragma once	#pragma once

	/***	/***
	This file is part of systemd.	This file is part of systemd.


	Copyright (C) 2009-2013 Intel Coproration	Copyright (C) 2009-2013 Intel Corporation

	Authors:	Authors:
	Auke Kok <auke-jan.h.kok@intel.com>	Auke Kok <auke-jan.h.kok@intel.com>

	systemd is free software; you can redistribute it and/or modify it	systemd is free software; you can redistribute it and/or modify it
	under the terms of the GNU Lesser General Public License as published by	under the terms of the GNU Lesser General Public License as published by
	the Free Software Foundation; either version 2.1 of the License, or	the Free Software Foundation; either version 2.1 of the License, or
	(at your option) any later version.	(at your option) any later version.

	systemd is distributed in the hope that it will be useful, but	systemd is distributed in the hope that it will be useful, but

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	bus-control.h	bus-control.h

	skipping to change at line 26	skipping to change at line 26
	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
	Lesser General Public License for more details.	Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public License	You should have received a copy of the GNU Lesser 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 "sd-bus.h"	#include "sd-bus.h"


	int bus_add_match_internal(sd_bus bus, const char match);	int bus_add_match_internal(sd_bus bus, const char match, struct bus_match
	int bus_remove_match_internal(sd_bus bus, const char match);	_component *components, unsigned n_components, uint64_t cookie);
		int bus_remove_match_internal(sd_bus bus, const char match, uint64_t cook
		ie);

End of changes. 1 change blocks.
	0 lines changed or deleted	0 lines changed or added

	bus-errors.h	bus-errors.h

	skipping to change at line 43	skipping to change at line 43
	#define BUS_ERROR_ONLY_BY_DEPENDENCY "org.freedesktop.systemd1.OnlyByDepend ency"	#define BUS_ERROR_ONLY_BY_DEPENDENCY "org.freedesktop.systemd1.OnlyByDepend ency"
	#define BUS_ERROR_NO_ISOLATION "org.freedesktop.systemd1.NoIsolation"	#define BUS_ERROR_NO_ISOLATION "org.freedesktop.systemd1.NoIsolation"
	#define BUS_ERROR_LOAD_FAILED "org.freedesktop.systemd1.LoadFailed"	#define BUS_ERROR_LOAD_FAILED "org.freedesktop.systemd1.LoadFailed"
	#define BUS_ERROR_MASKED "org.freedesktop.systemd1.Masked"	#define BUS_ERROR_MASKED "org.freedesktop.systemd1.Masked"
	#define BUS_ERROR_JOB_TYPE_NOT_APPLICABLE "org.freedesktop.systemd1.JobType NotApplicable"	#define BUS_ERROR_JOB_TYPE_NOT_APPLICABLE "org.freedesktop.systemd1.JobType NotApplicable"
	#define BUS_ERROR_TRANSACTION_IS_DESTRUCTIVE "org.freedesktop.systemd1.Tran sactionIsDestructive"	#define BUS_ERROR_TRANSACTION_IS_DESTRUCTIVE "org.freedesktop.systemd1.Tran sactionIsDestructive"
	#define BUS_ERROR_TRANSACTION_JOBS_CONFLICTING "org.freedesktop.systemd1.Tr ansactionJobsConflicting"	#define BUS_ERROR_TRANSACTION_JOBS_CONFLICTING "org.freedesktop.systemd1.Tr ansactionJobsConflicting"
	#define BUS_ERROR_TRANSACTION_ORDER_IS_CYCLIC "org.freedesktop.systemd1.Tra nsactionOrderIsCyclic"	#define BUS_ERROR_TRANSACTION_ORDER_IS_CYCLIC "org.freedesktop.systemd1.Tra nsactionOrderIsCyclic"
	#define BUS_ERROR_SHUTTING_DOWN "org.freedesktop.systemd1.ShuttingDown"	#define BUS_ERROR_SHUTTING_DOWN "org.freedesktop.systemd1.ShuttingDown"
	#define BUS_ERROR_NO_SUCH_PROCESS "org.freedesktop.systemd1.NoSuchProcess"	#define BUS_ERROR_NO_SUCH_PROCESS "org.freedesktop.systemd1.NoSuchProcess"

		#define BUS_ERROR_JOB_FAILED "org.freedesktop.systemd1.JobFailed"

End of changes. 1 change blocks.
	0 lines changed or deleted	0 lines changed or added

	bus-internal.h	bus-internal.h

	skipping to change at line 27	skipping to change at line 27
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Lesser General Public License for more details.	Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public License	You should have received a copy of the GNU Lesser 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/socket.h>	#include <sys/socket.h>
	#include <sys/un.h>	#include <sys/un.h>
	#include <netinet/in.h>	#include <netinet/in.h>

		#include <pthread.h>

	#include "hashmap.h"	#include "hashmap.h"
	#include "prioq.h"	#include "prioq.h"
	#include "list.h"	#include "list.h"
	#include "util.h"	#include "util.h"

		#include "refcnt.h"

	#include "sd-bus.h"	#include "sd-bus.h"
	#include "bus-error.h"	#include "bus-error.h"
	#include "bus-match.h"	#include "bus-match.h"

		#include "bus-kernel.h"

	struct reply_callback {	struct reply_callback {
	sd_bus_message_handler_t callback;	sd_bus_message_handler_t callback;
	void *userdata;	void *userdata;
	usec_t timeout;	usec_t timeout;
	uint64_t serial;	uint64_t serial;
	unsigned prioq_idx;	unsigned prioq_idx;
	};	};

	struct filter_callback {	struct filter_callback {

	skipping to change at line 69	skipping to change at line 72
	bool is_fallback;	bool is_fallback;

	unsigned last_iteration;	unsigned last_iteration;
	};	};

	enum bus_state {	enum bus_state {
	BUS_UNSET,	BUS_UNSET,
	BUS_OPENING,	BUS_OPENING,
	BUS_AUTHENTICATING,	BUS_AUTHENTICATING,
	BUS_HELLO,	BUS_HELLO,

	BUS_RUNNING	BUS_RUNNING,
		BUS_CLOSED
	};	};


		static inline bool BUS_IS_OPEN(enum bus_state state) {
		return state > BUS_UNSET && state < BUS_CLOSED;
		}

	enum bus_auth {	enum bus_auth {
	_BUS_AUTH_INVALID,	_BUS_AUTH_INVALID,
	BUS_AUTH_EXTERNAL,	BUS_AUTH_EXTERNAL,
	BUS_AUTH_ANONYMOUS	BUS_AUTH_ANONYMOUS
	};	};

	struct sd_bus {	struct sd_bus {

	unsigned n_ref;	/* We use atomic ref counting here since sd_bus_message
		objects retain references to their originating sd_bus but
		we want to allow them to be processed in a different
		thread. We won't provide full thread safety, but only the
		bare minimum that makes it possible to use sd_bus and
		sd_bus_message objects independently and on different
		threads as long as each object is used only once at the
		same time. */
		RefCount n_ref;

	enum bus_state state;	enum bus_state state;
	int input_fd, output_fd;	int input_fd, output_fd;
	int message_version;	int message_version;

	bool is_kernel:1;	bool is_kernel:1;

	bool negotiate_fds:1;
	bool can_fds:1;	bool can_fds:1;
	bool bus_client:1;	bool bus_client:1;
	bool ucred_valid:1;	bool ucred_valid:1;
	bool is_server:1;	bool is_server:1;
	bool anonymous_auth:1;	bool anonymous_auth:1;
	bool prefer_readv:1;	bool prefer_readv:1;
	bool prefer_writev:1;	bool prefer_writev:1;
	bool processing:1;	bool processing:1;
	bool match_callbacks_modified:1;	bool match_callbacks_modified:1;
	bool filter_callbacks_modified:1;	bool filter_callbacks_modified:1;
	bool object_callbacks_modified:1;	bool object_callbacks_modified:1;


		int use_memfd;

	void *rbuffer;	void *rbuffer;
	size_t rbuffer_size;	size_t rbuffer_size;

	sd_bus_message **rqueue;	sd_bus_message **rqueue;
	unsigned rqueue_size;	unsigned rqueue_size;

	sd_bus_message **wqueue;	sd_bus_message **wqueue;
	unsigned wqueue_size;	unsigned wqueue_size;
	size_t windex;	size_t windex;


	skipping to change at line 153	skipping to change at line 171
	char label[NAME_MAX];	char label[NAME_MAX];

	int *fds;	int *fds;
	unsigned n_fds;	unsigned n_fds;

	char *exec_path;	char *exec_path;
	char **exec_argv;	char **exec_argv;

	uint64_t hello_serial;	uint64_t hello_serial;
	unsigned iteration_counter;	unsigned iteration_counter;


		void *kdbus_buffer;

		/* We do locking around the memfd cache, since we want to
		* allow people to process a sd_bus_message in a different
		* thread then it was generated on and free it there. Since
		* adding something to the memfd cache might happen when a
		* message is released, we hence need to protect this bit with
		* a mutex. */
		pthread_mutex_t memfd_cache_mutex;
		struct memfd_cache memfd_cache[MEMFD_CACHE_MAX];
		unsigned n_memfd_cache;

		pid_t original_pid;

		uint64_t hello_flags;

		uint64_t match_cookie;
	};	};

	static inline void bus_unrefp(sd_bus **b) {	static inline void bus_unrefp(sd_bus **b) {
	sd_bus_unref(*b);	sd_bus_unref(*b);
	}	}

	#define _cleanup_bus_unref_ __attribute__((cleanup(bus_unrefp)))	#define _cleanup_bus_unref_ __attribute__((cleanup(bus_unrefp)))
	#define _cleanup_bus_error_free_ __attribute__((cleanup(sd_bus_error_free)) )	#define _cleanup_bus_error_free_ __attribute__((cleanup(sd_bus_error_free)) )

	#define BUS_DEFAULT_TIMEOUT ((usec_t) (25 * USEC_PER_SEC))	#define BUS_DEFAULT_TIMEOUT ((usec_t) (25 * USEC_PER_SEC))

	skipping to change at line 199	skipping to change at line 235
	bool path_simple_pattern(const char pattern, const char value);	bool path_simple_pattern(const char pattern, const char value);

	int bus_message_type_from_string(const char s, uint8_t u);	int bus_message_type_from_string(const char s, uint8_t u);
	const char *bus_message_type_to_string(uint8_t u);	const char *bus_message_type_to_string(uint8_t u);

	#define error_name_is_valid interface_name_is_valid	#define error_name_is_valid interface_name_is_valid

	int bus_ensure_running(sd_bus *bus);	int bus_ensure_running(sd_bus *bus);
	int bus_start_running(sd_bus *bus);	int bus_start_running(sd_bus *bus);
	int bus_next_address(sd_bus *bus);	int bus_next_address(sd_bus *bus);


		bool bus_pid_changed(sd_bus *bus);

End of changes. 10 change blocks.
	3 lines changed or deleted	39 lines changed or added

	bus-kernel.h	bus-kernel.h

	skipping to change at line 26	skipping to change at line 26
	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
	Lesser General Public License for more details.	Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public License	You should have received a copy of the GNU Lesser 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 "sd-bus.h"	#include "sd-bus.h"


		#define KDBUS_ITEM_NEXT(item) \
		(typeof(item))(((uint8_t *)item) + ALIGN8((item)->size))

		#define KDBUS_ITEM_FOREACH(item, head)
		\
		for (item = (head)->items;
		\
		(uint8_t )(item) < (uint8_t )(head) + (head)->size;
		\
		item = KDBUS_ITEM_NEXT(item))

		#define KDBUS_ITEM_HEADER_SIZE offsetof(struct kdbus_item, data)
		#define KDBUS_ITEM_SIZE(s) ALIGN8((s) + KDBUS_ITEM_HEADER_SIZE)

		#define MEMFD_CACHE_MAX 32

		/* When we cache a memfd block for reuse, we will truncate blocks
		* longer than this in order not to keep too much data around. */
		#define MEMFD_CACHE_ITEM_SIZE_MAX (128*1024)

		/* This determines at which minimum size we prefer sending memfds over
		* sending vectors */
		#define MEMFD_MIN_SIZE (128*1024)

		/* The size of the per-connection memory pool that we set up and where
		* the kernel places our incoming messages */
		#define KDBUS_POOL_SIZE (1610241024)

		struct memfd_cache {
		int fd;
		void *address;
		size_t size;
		};

	int bus_kernel_connect(sd_bus *b);	int bus_kernel_connect(sd_bus *b);
	int bus_kernel_take_fd(sd_bus *b);	int bus_kernel_take_fd(sd_bus *b);

	int bus_kernel_write_message(sd_bus bus, sd_bus_message m);	int bus_kernel_write_message(sd_bus bus, sd_bus_message m);
	int bus_kernel_read_message(sd_bus bus, sd_bus_message *m);	int bus_kernel_read_message(sd_bus bus, sd_bus_message *m);

	int bus_kernel_create(const char name, char *s);	int bus_kernel_create(const char name, char *s);


		int bus_kernel_pop_memfd(sd_bus bus, void address, size_t size);
		void bus_kernel_push_memfd(sd_bus bus, int fd, void address, size_t size)
		;

		void bus_kernel_flush_memfd(sd_bus *bus);

		int bus_kernel_parse_unique_name(const char s, uint64_t id);

End of changes. 2 change blocks.
	0 lines changed or deleted	34 lines changed or added

	bus-match.h	bus-match.h

	skipping to change at line 64	skipping to change at line 64

	union {	union {
	struct {	struct {
	char *str;	char *str;
	uint8_t u8;	uint8_t u8;
	} value;	} value;
	struct {	struct {
	sd_bus_message_handler_t callback;	sd_bus_message_handler_t callback;
	void *userdata;	void *userdata;
	unsigned last_iteration;	unsigned last_iteration;

		uint64_t cookie;
	} leaf;	} leaf;
	struct {	struct {
	/* If this is set, then the child is NULL */	/* If this is set, then the child is NULL */
	Hashmap *children;	Hashmap *children;
	} compare;	} compare;
	};	};
	};	};


	int bus_match_run(sd_bus bus, struct bus_match_node root, int ret, sd_bus	struct bus_match_component {
	_message *m);	enum bus_match_node_type type;
		uint8_t value_u8;
		char *value_str;
		};

		int bus_match_run(sd_bus bus, struct bus_match_node root, sd_bus_message
		*m);


	int bus_match_add(struct bus_match_node root, const char match, sd_bus_me	int bus_match_add(struct bus_match_node root, struct bus_match_component
	ssage_handler_t callback, void userdata, struct bus_match_node *ret);	components, unsigned n_components, sd_bus_message_handler_t callback, void
	int bus_match_remove(struct bus_match_node root, const char match, sd_bus	userdata, uint64_t cookie, struct bus_match_node *ret);
	_message_handler_t callback, void *userdata);	int bus_match_remove(struct bus_match_node *root, struct bus_match_componen
		t *components, unsigned n_components, sd_bus_message_handler_t callback, vo
		id userdata, uint64_t cookie);

	void bus_match_free(struct bus_match_node *node);	void bus_match_free(struct bus_match_node *node);

	void bus_match_dump(struct bus_match_node *node, unsigned level);	void bus_match_dump(struct bus_match_node *node, unsigned level);

	const char* bus_match_node_type_to_string(enum bus_match_node_type t, char buf[], size_t l);	const char* bus_match_node_type_to_string(enum bus_match_node_type t, char buf[], size_t l);
	enum bus_match_node_type bus_match_node_type_from_string(const char *k, siz e_t n);	enum bus_match_node_type bus_match_node_type_from_string(const char *k, siz e_t n);


		int bus_match_parse(const char match, struct bus_match_component *_compon
		ents, unsigned *_n_components);
		void bus_match_parse_free(struct bus_match_component *components, unsigned
		n_components);

End of changes. 4 change blocks.
	6 lines changed or deleted	15 lines changed or added

	bus-message.h	bus-message.h

	skipping to change at line 36	skipping to change at line 36
	#include <sys/socket.h>	#include <sys/socket.h>

	#include "macro.h"	#include "macro.h"
	#include "sd-bus.h"	#include "sd-bus.h"
	#include "kdbus.h"	#include "kdbus.h"
	#include "time-util.h"	#include "time-util.h"

	struct bus_container {	struct bus_container {
	char enclosing;	char enclosing;


		unsigned index, saved_index;

	char *signature;	char *signature;

	unsigned index;

	uint32_t *array_size;	uint32_t *array_size;

	size_t begin;	size_t before, begin;
	};	};

	struct bus_header {	struct bus_header {
	uint8_t endian;	uint8_t endian;
	uint8_t type;	uint8_t type;
	uint8_t flags;	uint8_t flags;
	uint8_t version;	uint8_t version;
	uint32_t body_size;	uint32_t body_size;
	uint32_t serial;	uint32_t serial;
	uint32_t fields_size;	uint32_t fields_size;
	} _packed_;	} _packed_;


		struct bus_body_part {
		struct bus_body_part *next;
		void *data;
		size_t size;
		size_t mapped;
		int memfd;
		bool free_this:1;
		bool munmap_this:1;
		bool sealed:1;
		bool is_zero:1;
		};

	struct sd_bus_message {	struct sd_bus_message {
	unsigned n_ref;	unsigned n_ref;


		sd_bus *bus;

	uint32_t reply_serial;	uint32_t reply_serial;

	const char *path;	const char *path;
	const char *interface;	const char *interface;
	const char *member;	const char *member;
	const char *destination;	const char *destination;
	const char *sender;	const char *sender;

	sd_bus_error error;	sd_bus_error error;


	skipping to change at line 80	skipping to change at line 95
	usec_t pid_starttime;	usec_t pid_starttime;
	usec_t monotonic;	usec_t monotonic;
	usec_t realtime;	usec_t realtime;

	bool sealed:1;	bool sealed:1;
	bool dont_send:1;	bool dont_send:1;
	bool allow_fds:1;	bool allow_fds:1;
	bool uid_valid:1;	bool uid_valid:1;
	bool gid_valid:1;	bool gid_valid:1;
	bool free_header:1;	bool free_header:1;

	bool free_fields:1;
	bool free_body:1;
	bool free_kdbus:1;	bool free_kdbus:1;
	bool free_fds:1;	bool free_fds:1;

		bool release_kdbus:1;
		bool poisoned:1;

	struct bus_header *header;	struct bus_header *header;

	void *fields;	struct bus_body_part body;
	void *body;	struct bus_body_part *body_end;
	struct kdbus_msg *kdbus;	unsigned n_body_parts;

	char *label;	char *label;

	size_t rindex;	size_t rindex;

		struct bus_body_part *cached_rindex_part;
		size_t cached_rindex_part_begin;

	uint32_t n_fds;	uint32_t n_fds;
	int *fds;	int *fds;

	struct bus_container root_container, *containers;	struct bus_container root_container, *containers;
	unsigned n_containers;	unsigned n_containers;


	struct iovec iovec[3];	struct iovec *iovec;
		struct iovec iovec_fixed[2];
	unsigned n_iovec;	unsigned n_iovec;


		struct kdbus_msg *kdbus;

	char *peeked_signature;	char *peeked_signature;

	usec_t timeout;	usec_t timeout;

	char sender_buffer[3 + DECIMAL_STR_MAX(uint64_t) + 1];	char sender_buffer[3 + DECIMAL_STR_MAX(uint64_t) + 1];
	char destination_buffer[3 + DECIMAL_STR_MAX(uint64_t) + 1];	char destination_buffer[3 + DECIMAL_STR_MAX(uint64_t) + 1];

	const char *exe;	const char *exe;
	const char *comm;	const char *comm;
	const char *tid_comm;	const char *tid_comm;

	skipping to change at line 162	skipping to change at line 182
	return BUS_MESSAGE_BSWAP32(m, m->header->fields_size);	return BUS_MESSAGE_BSWAP32(m, m->header->fields_size);
	}	}

	static inline uint32_t BUS_MESSAGE_SIZE(sd_bus_message *m) {	static inline uint32_t BUS_MESSAGE_SIZE(sd_bus_message *m) {
	return	return
	sizeof(struct bus_header) +	sizeof(struct bus_header) +
	ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m)) +	ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m)) +
	BUS_MESSAGE_BODY_SIZE(m);	BUS_MESSAGE_BODY_SIZE(m);
	}	}


		static inline uint32_t BUS_MESSAGE_BODY_BEGIN(sd_bus_message *m) {
		return
		sizeof(struct bus_header) +
		ALIGN8(BUS_MESSAGE_FIELDS_SIZE(m));
		}

		static inline void* BUS_MESSAGE_FIELDS(sd_bus_message *m) {
		return (uint8_t*) m->header + sizeof(struct bus_header);
		}

	static inline void bus_message_unrefp(sd_bus_message **m) {	static inline void bus_message_unrefp(sd_bus_message **m) {
	sd_bus_message_unref(*m);	sd_bus_message_unref(*m);
	}	}

	#define _cleanup_bus_message_unref_ __attribute__((cleanup(bus_message_unre fp)))	#define _cleanup_bus_message_unref_ __attribute__((cleanup(bus_message_unre fp)))

	int bus_message_seal(sd_bus_message *m, uint64_t serial);	int bus_message_seal(sd_bus_message *m, uint64_t serial);
	int bus_message_dump(sd_bus_message *m);	int bus_message_dump(sd_bus_message *m);
	int bus_message_get_blob(sd_bus_message m, void buffer, size_t sz);	int bus_message_get_blob(sd_bus_message m, void buffer, size_t sz);
	int bus_message_read_strv_extend(sd_bus_message m, char **l);	int bus_message_read_strv_extend(sd_bus_message m, char **l);

	skipping to change at line 198	skipping to change at line 228
	const struct ucred *ucred,	const struct ucred *ucred,
	const char *label,	const char *label,
	sd_bus_message **ret);	sd_bus_message **ret);

	const char* bus_message_get_arg(sd_bus_message *m, unsigned i);	const char* bus_message_get_arg(sd_bus_message *m, unsigned i);

	int bus_message_append_ap(sd_bus_message m, const char types, va_list ap) ;	int bus_message_append_ap(sd_bus_message m, const char types, va_list ap) ;

	int bus_message_parse_fields(sd_bus_message *m);	int bus_message_parse_fields(sd_bus_message *m);


	int bus_header_size(struct bus_header h, size_t sum);	bool bus_header_is_complete(struct bus_header *h, size_t size);
		int bus_header_message_size(struct bus_header h, size_t sum);

		struct bus_body_part message_append_part(sd_bus_message m);

		#define MESSAGE_FOREACH_PART(part, i, m) \
		for ((i) = 0, (part) = &(m)->body; (i) < (m)->n_body_parts; (i)++,
		(part) = (part)->next)

		int bus_body_part_map(struct bus_body_part *part);
		void bus_body_part_unmap(struct bus_body_part *part);

		int bus_message_to_errno(sd_bus_message *m);

		int bus_message_new_synthetic_error(sd_bus *bus, uint64_t serial, const sd_
		bus_error e, sd_bus_message *m);

End of changes. 13 change blocks.
	8 lines changed or deleted	38 lines changed or added

	bus-type.h	bus-type.h

	skipping to change at line 32	skipping to change at line 32
	***/	***/

	#include <stdbool.h>	#include <stdbool.h>

	#include "sd-bus.h"	#include "sd-bus.h"
	#include "sd-bus-protocol.h"	#include "sd-bus-protocol.h"

	bool bus_type_is_valid(char c);	bool bus_type_is_valid(char c);
	bool bus_type_is_valid_in_signature(char c);	bool bus_type_is_valid_in_signature(char c);
	bool bus_type_is_basic(char c);	bool bus_type_is_basic(char c);

		bool bus_type_is_trivial(char c);
	bool bus_type_is_container(char c);	bool bus_type_is_container(char c);
	int bus_type_get_alignment(char c);	int bus_type_get_alignment(char c);
	int bus_type_get_size(char c);	int bus_type_get_size(char c);

End of changes. 1 change blocks.
	0 lines changed or deleted	1 lines changed or added

	cgroup-util.h	cgroup-util.h

	skipping to change at line 31	skipping to change at line 31
	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>
	#include <stdio.h>	#include <stdio.h>
	#include <dirent.h>	#include <dirent.h>

	#include "set.h"	#include "set.h"
	#include "def.h"	#include "def.h"


		/* A bit mask of well known cgroup controllers */
		typedef enum CGroupControllerMask {
		CGROUP_CPU = 1,
		CGROUP_CPUACCT = 2,
		CGROUP_BLKIO = 4,
		CGROUP_MEMORY = 8,
		CGROUP_DEVICE = 16
		} CGroupControllerMask;

	/*	/*
	* General rules:	* General rules:
	*	*
	* We accept named hierarchies in the syntax "foo" and "name=foo".	* We accept named hierarchies in the syntax "foo" and "name=foo".
	*	*
	* We expect that named hierarchies do not conflict in name with a	* We expect that named hierarchies do not conflict in name with a
	* kernel hierarchy, modulo the "name=" prefix.	* kernel hierarchy, modulo the "name=" prefix.
	*	*
	* We always generate "normalized" controller names, i.e. without the	* We always generate "normalized" controller names, i.e. without the
	* "name=" prefix.	* "name=" prefix.
	*	*
	* We require absolute cgroup paths. When returning, we will always	* We require absolute cgroup paths. When returning, we will always
	* generate paths with multiple adjacent / removed.	* generate paths with multiple adjacent / removed.
	*/	*/

	int cg_enumerate_processes(const char controller, const char path, FILE * *_f);	int cg_enumerate_processes(const char controller, const char path, FILE * *_f);

	int cg_enumerate_tasks(const char controller, const char path, FILE **_f) ;
	int cg_read_pid(FILE f, pid_t _pid);	int cg_read_pid(FILE f, pid_t _pid);

	int cg_enumerate_subgroups(const char controller, const char path, DIR ** _d);	int cg_enumerate_subgroups(const char controller, const char path, DIR ** _d);
	int cg_read_subgroup(DIR d, char *fn);	int cg_read_subgroup(DIR d, char *fn);

	int cg_kill(const char controller, const char path, int sig, bool sigcont , bool ignore_self, Set *s);	int cg_kill(const char controller, const char path, int sig, bool sigcont , bool ignore_self, Set *s);
	int cg_kill_recursive(const char controller, const char path, int sig, bo ol sigcont, bool ignore_self, bool remove, Set *s);	int cg_kill_recursive(const char controller, const char path, int sig, bo ol sigcont, bool ignore_self, bool remove, Set *s);
	int cg_kill_recursive_and_wait(const char controller, const char path, bo ol remove);	int cg_kill_recursive_and_wait(const char controller, const char path, bo ol remove);

	int cg_migrate(const char cfrom, const char pfrom, const char cto, const char pto, bool ignore_self);	int cg_migrate(const char cfrom, const char pfrom, const char cto, const char pto, bool ignore_self);

	skipping to change at line 71	skipping to change at line 79
	int cg_join_spec(const char controller, const char path, char **spec);	int cg_join_spec(const char controller, const char path, char **spec);
	int cg_mangle_path(const char path, char *result);	int cg_mangle_path(const char path, char *result);

	int cg_get_path(const char controller, const char path, const char suffi x, char *fs);	int cg_get_path(const char controller, const char path, const char suffi x, char *fs);
	int cg_get_path_and_check(const char controller, const char path, const c har suffix, char *fs);	int cg_get_path_and_check(const char controller, const char path, const c har suffix, char *fs);

	int cg_pid_get_path(const char controller, pid_t pid, char *path);	int cg_pid_get_path(const char controller, pid_t pid, char *path);

	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);
	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, const char *suffix) ;	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_attribute(const char controller, const char path, const char *
		attribute, const char *value);

	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 sticky);	int cg_set_task_access(const char controller, const char path, mode_t mod e, uid_t uid, gid_t gid);

	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_by_spec(const char *spec, bool ignore_self);	int cg_is_empty_by_spec(const char *spec, 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_root_path(char **path);	int cg_get_root_path(char **path);

	int cg_get_system_path(char **path);
	int cg_get_user_path(char **path);
	int cg_get_machine_path(const char machine, char *path);

	int cg_path_get_session(const char path, char *session);	int cg_path_get_session(const char path, char *session);
	int cg_path_get_owner_uid(const char path, uid_t uid);	int cg_path_get_owner_uid(const char path, uid_t uid);
	int cg_path_get_unit(const char path, char *unit);	int cg_path_get_unit(const char path, char *unit);
	int cg_path_get_user_unit(const char path, char *unit);	int cg_path_get_user_unit(const char path, char *unit);
	int cg_path_get_machine_name(const char path, char *machine);	int cg_path_get_machine_name(const char path, char *machine);

		int cg_path_get_slice(const char path, char *slice);

	int cg_pid_get_path_shifted(pid_t pid, char root, char cgroup);	int cg_pid_get_path_shifted(pid_t pid, char root, char cgroup);

	int cg_pid_get_session(pid_t pid, char **session);	int cg_pid_get_session(pid_t pid, char **session);
	int cg_pid_get_owner_uid(pid_t pid, uid_t *uid);	int cg_pid_get_owner_uid(pid_t pid, uid_t *uid);
	int cg_pid_get_unit(pid_t pid, char **unit);	int cg_pid_get_unit(pid_t pid, char **unit);
	int cg_pid_get_user_unit(pid_t pid, char **unit);	int cg_pid_get_user_unit(pid_t pid, char **unit);
	int cg_pid_get_machine_name(pid_t pid, char **machine);	int cg_pid_get_machine_name(pid_t pid, char **machine);

		int cg_pid_get_slice(pid_t pid, char **slice);

	int cg_path_decode_unit(const char cgroup, char *unit);	int cg_path_decode_unit(const char cgroup, char *unit);

	char cg_shorten_controllers(char controllers);	char cg_shorten_controllers(char controllers);

	int cg_controller_from_attr(const char attr, char *controller);	int cg_controller_from_attr(const char attr, char *controller);

	char cg_escape(const char p);	char cg_escape(const char p);
	char cg_unescape(const char p) _pure_;	char cg_unescape(const char p) _pure_;

	bool cg_controller_is_valid(const char *p, bool allow_named);	bool cg_controller_is_valid(const char *p, bool allow_named);


		int cg_slice_to_path(const char unit, char *ret);

		int cg_create_with_mask(CGroupControllerMask mask, const char *path);
		int cg_attach_with_mask(CGroupControllerMask mask, const char *path, pid_t
		pid);
		int cg_attach_many_with_mask(CGroupControllerMask mask, const char *path, S
		et* pids);
		int cg_migrate_with_mask(CGroupControllerMask mask, const char *from, const
		char *to);
		int cg_trim_with_mask(CGroupControllerMask mask, const char *path, bool del
		ete_root);

		CGroupControllerMask cg_mask_supported(void);

End of changes. 10 change blocks.
	7 lines changed or deleted	17 lines changed or added

	cgroup.h	cgroup.h
	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/

	#pragma once	#pragma once

	/***	/***
	This file is part of systemd.	This file is part of systemd.


	Copyright 2010 Lennart Poettering	Copyright 2013 Lennart Poettering

	systemd is free software; you can redistribute it and/or modify it	systemd is free software; you can redistribute it and/or modify it
	under the terms of the GNU Lesser General Public License as published by	under the terms of the GNU Lesser General Public License as published by
	the Free Software Foundation; either version 2.1 of the License, or	the Free Software Foundation; either version 2.1 of the License, or
	(at your option) any later version.	(at your option) any later version.

	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
	Lesser General Public License for more details.	Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public License	You should have received a copy of the GNU Lesser 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/>.
	***/	***/


	typedef struct CGroupBonding CGroupBonding;	#include "list.h"


	#include "unit.h"	typedef struct CGroupContext CGroupContext;
		typedef struct CGroupDeviceAllow CGroupDeviceAllow;
	/* Binds a cgroup to a name */	typedef struct CGroupBlockIODeviceWeight CGroupBlockIODeviceWeight;
	struct CGroupBonding {	typedef struct CGroupBlockIODeviceBandwidth CGroupBlockIODeviceBandwidth;
	char *controller;
	char *path;


	Unit *unit;	typedef enum CGroupDevicePolicy {


	/* For the Unit::cgroup_bondings list */	/* When devices listed, will allow those, plus built-in ones,
	LIST_FIELDS(CGroupBonding, by_unit);	if none are listed will allow everything. */
		CGROUP_AUTO,


	/* For the Manager::cgroup_bondings hashmap */	/* Everything forbidden, except built-in ones and listed ones. */
	LIST_FIELDS(CGroupBonding, by_path);	CGROUP_CLOSED,


	/* When shutting down, remove cgroup? Are our own tasks the	/* Everythings forbidden, except for the listed devices */
	* only ones in this group?*/	CGROUP_STRICT,
	bool ours:1;


	/* If we cannot create this group, or add a process to it, is this	_CGROUP_DEVICE_POLICY_MAX,
	fatal? */	_CGROUP_DEVICE_POLICY_INVALID = -1
	bool essential:1;	} CGroupDevicePolicy;


	/* This cgroup is realized */	struct CGroupDeviceAllow {
	bool realized:1;	LIST_FIELDS(CGroupDeviceAllow, device_allow);
		char *path;
		bool r:1;
		bool w:1;
		bool m:1;
	};	};


	int cgroup_bonding_realize(CGroupBonding *b);	struct CGroupBlockIODeviceWeight {
	int cgroup_bonding_realize_list(CGroupBonding *first);	LIST_FIELDS(CGroupBlockIODeviceWeight, device_weights);
		char *path;
	void cgroup_bonding_free(CGroupBonding *b, bool trim);	unsigned long weight;
	void cgroup_bonding_free_list(CGroupBonding *first, bool trim);	};

	int cgroup_bonding_install(CGroupBonding b, pid_t pid, const char suffix)
	;
	int cgroup_bonding_install_list(CGroupBonding *first, pid_t pid, const char
	*suffix);


	int cgroup_bonding_migrate(CGroupBonding b, CGroupBonding list);	struct CGroupBlockIODeviceBandwidth {
	int cgroup_bonding_migrate_to(CGroupBonding b, const char target, bool re	LIST_FIELDS(CGroupBlockIODeviceBandwidth, device_bandwidths);
	m);	char *path;
		uint64_t bandwidth;
		bool read;
		};


	int cgroup_bonding_set_group_access(CGroupBonding *b, mode_t mode, uid_t ui	struct CGroupContext {
	d, gid_t gid);	bool cpu_accounting;
	int cgroup_bonding_set_group_access_list(CGroupBonding *b, mode_t mode, uid	bool blockio_accounting;
	_t uid, gid_t gid);	bool memory_accounting;

		unsigned long cpu_shares;

		unsigned long blockio_weight;
		LIST_HEAD(CGroupBlockIODeviceWeight, blockio_device_weights);
		LIST_HEAD(CGroupBlockIODeviceBandwidth, blockio_device_bandwidths);


	int cgroup_bonding_set_task_access(CGroupBonding *b, mode_t mode, uid_t uid	uint64_t memory_limit;
	, gid_t gid, int sticky);	uint64_t memory_soft_limit;
	int cgroup_bonding_set_task_access_list(CGroupBonding *b, mode_t mode, uid_
	t uid, gid_t gid, int sticky);


	int cgroup_bonding_kill(CGroupBonding *b, int sig, bool sigcont, bool rem,	CGroupDevicePolicy device_policy;
	Set s, const char suffix);	LIST_HEAD(CGroupDeviceAllow, device_allow);
	int cgroup_bonding_kill_list(CGroupBonding *first, int sig, bool sigcont, b	};
	ool rem, Set s, const char suffix);


	void cgroup_bonding_trim(CGroupBonding *first, bool delete_root);	#include "unit.h"
	void cgroup_bonding_trim_list(CGroupBonding *first, bool delete_root);	#include "manager.h"
		#include "cgroup-util.h"


	int cgroup_bonding_is_empty(CGroupBonding *b);	void cgroup_context_init(CGroupContext *c);
	int cgroup_bonding_is_empty_list(CGroupBonding *first);	void cgroup_context_done(CGroupContext *c);
		void cgroup_context_dump(CGroupContext c, FILE f, const char *prefix);
		void cgroup_context_apply(CGroupContext *c, CGroupControllerMask mask, cons
		t char *path);
		CGroupControllerMask cgroup_context_get_mask(CGroupContext *c);

		void cgroup_context_free_device_allow(CGroupContext c, CGroupDeviceAllow
		a);
		void cgroup_context_free_blockio_device_weight(CGroupContext *c, CGroupBloc
		kIODeviceWeight *w);
		void cgroup_context_free_blockio_device_bandwidth(CGroupContext *c, CGroupB
		lockIODeviceBandwidth *b);


	CGroupBonding cgroup_bonding_find_list(CGroupBonding first, const char *c	int unit_realize_cgroup(Unit *u);
	ontroller) _pure_;	void unit_destroy_cgroup(Unit *u);


	char cgroup_bonding_to_string(CGroupBonding b);	int manager_setup_cgroup(Manager *m);
		void manager_shutdown_cgroup(Manager *m, bool delete);


	pid_t cgroup_bonding_search_main_pid(CGroupBonding *b);	unsigned manager_dispatch_cgroup_queue(Manager *m);
	pid_t cgroup_bonding_search_main_pid_list(CGroupBonding *b);


	#include "manager.h"	Unit manager_get_unit_by_cgroup(Manager m, const char *cgroup);
		Unit* manager_get_unit_by_pid(Manager *m, pid_t pid);


	int manager_setup_cgroup(Manager *m);	pid_t unit_search_main_pid(Unit *u);
	void manager_shutdown_cgroup(Manager *m, bool delete);


	int cgroup_bonding_get(Manager m, const char cgroup, CGroupBonding **bond	int manager_notify_cgroup_empty(Manager m, const char group);
	ing);
	int cgroup_notify_empty(Manager m, const char group);


	Unit* cgroup_unit_by_pid(Manager *m, pid_t pid);	const char* cgroup_device_policy_to_string(CGroupDevicePolicy i) _const_;
		CGroupDevicePolicy cgroup_device_policy_from_string(const char *s) _pure_;

End of changes. 23 change blocks.
	61 lines changed or deleted	74 lines changed or added

	config.h	config.h

	skipping to change at line 89	skipping to change at line 89
	/* Define if IMA is available */	/* Define if IMA is available */
	#define HAVE_IMA 1	#define HAVE_IMA 1

	/* Define to 1 if you have the `inet_ntoa' function. */	/* Define to 1 if you have the `inet_ntoa' function. */
	#define HAVE_INET_NTOA 1	#define HAVE_INET_NTOA 1

	/* Define to 1 if you have the <inttypes.h> header file. */	/* Define to 1 if you have the <inttypes.h> header file. */
	#define HAVE_INTTYPES_H 1	#define HAVE_INTTYPES_H 1

	/* Define if kmod is available */	/* Define if kmod is available */

	#define HAVE_KMOD 1	/* #undef HAVE_KMOD */

	/* Define to 1 if you have the <libaudit.h> header file. */	/* Define to 1 if you have the <libaudit.h> header file. */
	#define HAVE_LIBAUDIT_H 1	#define HAVE_LIBAUDIT_H 1

	/* Define if libcryptsetup is available */	/* Define if libcryptsetup is available */
	/* #undef HAVE_LIBCRYPTSETUP */	/* #undef HAVE_LIBCRYPTSETUP */

	/* Have tcpwrap? */	/* Have tcpwrap? */
	#define HAVE_LIBWRAP /**/	#define HAVE_LIBWRAP /**/

	/* Logind support available */	/* Logind support available */
	#define HAVE_LOGIND 1	#define HAVE_LOGIND 1


		/* Machined support available */
		#define HAVE_MACHINED 1

	/* Define to 1 if your system has a GNU libc compatible `malloc' function, and	/* Define to 1 if your system has a GNU libc compatible `malloc' function, and
	to 0 otherwise. */	to 0 otherwise. */
	#define HAVE_MALLOC 1	#define HAVE_MALLOC 1

	/* Define to 1 if you have the <memory.h> header file. */	/* Define to 1 if you have the <memory.h> header file. */
	#define HAVE_MEMORY_H 1	#define HAVE_MEMORY_H 1

	/* Define to 1 if you have the `memset' function. */	/* Define to 1 if you have the `memset' function. */
	#define HAVE_MEMSET 1	#define HAVE_MEMSET 1


	skipping to change at line 149	skipping to change at line 152

	/* Define to 1 if you have the <security/pam_modutil.h> header file. */	/* Define to 1 if you have the <security/pam_modutil.h> header file. */
	#define HAVE_SECURITY_PAM_MODUTIL_H 1	#define HAVE_SECURITY_PAM_MODUTIL_H 1

	/* Define to 1 if you have the `select' function. */	/* Define to 1 if you have the `select' function. */
	#define HAVE_SELECT 1	#define HAVE_SELECT 1

	/* Define if SELinux is available */	/* Define if SELinux is available */
	#define HAVE_SELINUX 1	#define HAVE_SELINUX 1


		/* Define if SMACK is available */
		#define HAVE_SMACK 1

	/* Define to 1 if you have the `socket' function. */	/* Define to 1 if you have the `socket' function. */
	#define HAVE_SOCKET 1	#define HAVE_SOCKET 1

	/* Define if /bin, /sbin aren't symlinks into /usr */	/* Define if /bin, /sbin aren't symlinks into /usr */
	/* #undef HAVE_SPLIT_USR */	/* #undef HAVE_SPLIT_USR */

	/* Define to 1 if you have the <stdint.h> header file. */	/* Define to 1 if you have the <stdint.h> header file. */
	#define HAVE_STDINT_H 1	#define HAVE_STDINT_H 1

	/* Define to 1 if you have the <stdlib.h> header file. */	/* Define to 1 if you have the <stdlib.h> header file. */

	skipping to change at line 250	skipping to change at line 256
	/* 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 "http://bugs.freedesktop.org/enter_bug.cgi?produc t=systemd"	#define PACKAGE_BUGREPORT "http://bugs.freedesktop.org/enter_bug.cgi?produc t=systemd"

	/* 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 204"	#define PACKAGE_STRING "systemd 205"

	/* 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 "http://www.freedesktop.org/wiki/Software/systemd"	#define PACKAGE_URL "http://www.freedesktop.org/wiki/Software/systemd"

	/* Define to the version of this package. */	/* Define to the version of this package. */

	#define PACKAGE_VERSION "204"	#define PACKAGE_VERSION "205"

	/* Path of /etc/rc.local script */	/* Path of /etc/rc.local script */
	#define RC_LOCAL_SCRIPT_PATH_START "/etc/rc.local"	#define RC_LOCAL_SCRIPT_PATH_START "/etc/rc.local"

	/* Path of /usr/sbin/halt.local script */	/* Path of /usr/sbin/halt.local script */
	#define RC_LOCAL_SCRIPT_PATH_STOP "/usr/sbin/halt.local"	#define RC_LOCAL_SCRIPT_PATH_STOP "/usr/sbin/halt.local"

	/* Define to the type of arg 1 for `select'. */	/* Define to the type of arg 1 for `select'. */
	#define SELECT_TYPE_ARG1 int	#define SELECT_TYPE_ARG1 int


	skipping to change at line 310	skipping to change at line 316
	/* 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 "204"	#define VERSION "205"

	/* Enable large inode numbers on Mac OS X 10.5. */	/* Enable large inode numbers on Mac OS X 10.5. */
	#ifndef _DARWIN_USE_64_BIT_INODE	#ifndef _DARWIN_USE_64_BIT_INODE
	# define _DARWIN_USE_64_BIT_INODE 1	# define _DARWIN_USE_64_BIT_INODE 1
	#endif	#endif

	/* 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. */

End of changes. 6 change blocks.
	4 lines changed or deleted	10 lines changed or added

	dbus-execute.h	dbus-execute.h

	skipping to change at line 95	skipping to change at line 95
	" <property name=\"TCPWrapName\" type=\"s\" access=\"read\"/>\n" \	" <property name=\"TCPWrapName\" type=\"s\" access=\"read\"/>\n" \
	" <property name=\"PAMName\" type=\"s\" access=\"read\"/>\n" \	" <property name=\"PAMName\" type=\"s\" access=\"read\"/>\n" \
	" <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=\"PrivateNetwork\" type=\"b\" access=\"read\"/>\n " \	" <property name=\"PrivateNetwork\" type=\"b\" access=\"read\"/>\n " \
	" <property name=\"SameProcessGroup\" type=\"b\" access=\"read\"/> \n" \	" <property name=\"SameProcessGroup\" type=\"b\" 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=\"ControlGroupPersistent\" type=\"b\" access=\"re
	ad\"/>\n" \
	" <property name=\"IgnoreSIGPIPE\" type=\"b\" access=\"read\"/>\n" \	" <property name=\"IgnoreSIGPIPE\" type=\"b\" access=\"read\"/>\n" \
	" <property name=\"NoNewPrivileges\" type=\"b\" access=\"read\"/>\ n" \	" <property name=\"NoNewPrivileges\" type=\"b\" access=\"read\"/>\ n" \
	" <property name=\"SystemCallFilter\" type=\"au\" access=\"read\"/ >\n"	" <property name=\"SystemCallFilter\" type=\"au\" 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"

	extern const BusProperty bus_exec_context_properties[];	extern const BusProperty bus_exec_context_properties[];

	#define BUS_EXEC_COMMAND_PROPERTY(name, command, indirect) \	#define BUS_EXEC_COMMAND_PROPERTY(name, command, indirect) \
	{ name, bus_execute_append_command, "a(sasbttttuii)", (command), (i ndirect), NULL }	{ name, bus_execute_append_command, "a(sasbttttuii)", (command), (i ndirect), NULL }


	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_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_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_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_timer_slack_nsec(DBusMessageIter i, const char pro
	perty, void *data);
	int bus_execute_append_capabilities(DBusMessageIter i, const char propert
	y, void *data);
	int bus_execute_append_capability_bs(DBusMessageIter i, const char proper
	ty, void *data);
	int bus_execute_append_rlimits(DBusMessageIter i, const char property, vo
	id *data);
	int bus_execute_append_command(DBusMessageIter u, const char property, vo id *data);	int bus_execute_append_command(DBusMessageIter u, const char property, vo id *data);

	int bus_execute_append_env_files(DBusMessageIter i, const char property,
	void *data);
	int bus_execute_append_syscall_filter(DBusMessageIter i, const char prope
	rty, void *data);

End of changes. 3 change blocks.
	28 lines changed or deleted	0 lines changed or added

	dbus-mount.h	dbus-mount.h

	skipping to change at line 30	skipping to change at line 30
	You should have received a copy of the GNU Lesser General Public License	You should have received a copy of the GNU Lesser 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 "unit.h"	#include "unit.h"

	DBusHandlerResult bus_mount_message_handler(Unit u, DBusConnection c, DBu sMessage *message);	DBusHandlerResult bus_mount_message_handler(Unit u, DBusConnection c, DBu sMessage *message);


		int bus_mount_set_property(Unit u, const char name, DBusMessageIter *i, U
		nitSetPropertiesMode mode, DBusError *error);
		int bus_mount_commit_properties(Unit *u);

	extern const char bus_mount_interface[];	extern const char bus_mount_interface[];
	extern const char bus_mount_invalidating_properties[];	extern const char bus_mount_invalidating_properties[];

End of changes. 1 change blocks.
	0 lines changed or deleted	4 lines changed or added

	dbus-service.h	dbus-service.h

	skipping to change at line 30	skipping to change at line 30
	You should have received a copy of the GNU Lesser General Public License	You should have received a copy of the GNU Lesser 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 "unit.h"	#include "unit.h"

	DBusHandlerResult bus_service_message_handler(Unit u, DBusConnection c, D BusMessage *message);	DBusHandlerResult bus_service_message_handler(Unit u, DBusConnection c, D BusMessage *message);


		int bus_service_set_property(Unit u, const char name, DBusMessageIter *i,
		UnitSetPropertiesMode mode, DBusError *error);
		int bus_service_commit_properties(Unit *u);

	extern const char bus_service_interface[];	extern const char bus_service_interface[];
	extern const char bus_service_invalidating_properties[];	extern const char bus_service_invalidating_properties[];

End of changes. 1 change blocks.
	0 lines changed or deleted	4 lines changed or added

	dbus-socket.h	dbus-socket.h

	skipping to change at line 30	skipping to change at line 30
	You should have received a copy of the GNU Lesser General Public License	You should have received a copy of the GNU Lesser 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 "unit.h"	#include "unit.h"

	DBusHandlerResult bus_socket_message_handler(Unit u, DBusConnection c, DB usMessage *message);	DBusHandlerResult bus_socket_message_handler(Unit u, DBusConnection c, DB usMessage *message);


		int bus_socket_set_property(Unit u, const char name, DBusMessageIter *i,
		UnitSetPropertiesMode mode, DBusError *error);
		int bus_socket_commit_properties(Unit *u);

	extern const char bus_socket_interface[];	extern const char bus_socket_interface[];
	extern const char bus_socket_invalidating_properties[];	extern const char bus_socket_invalidating_properties[];

End of changes. 1 change blocks.
	0 lines changed or deleted	4 lines changed or added

	dbus-swap.h	dbus-swap.h

	skipping to change at line 31	skipping to change at line 31
	You should have received a copy of the GNU Lesser General Public License	You should have received a copy of the GNU Lesser 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 "unit.h"	#include "unit.h"

	DBusHandlerResult bus_swap_message_handler(Unit u, DBusConnection c, DBus Message *message);	DBusHandlerResult bus_swap_message_handler(Unit u, DBusConnection c, DBus Message *message);


		int bus_swap_set_property(Unit u, const char name, DBusMessageIter *i, Un
		itSetPropertiesMode mode, DBusError *error);
		int bus_swap_commit_properties(Unit *u);

	extern const char bus_swap_interface[];	extern const char bus_swap_interface[];
	extern const char bus_swap_invalidating_properties[];	extern const char bus_swap_invalidating_properties[];

End of changes. 1 change blocks.
	0 lines changed or deleted	4 lines changed or added

	dbus-unit.h	dbus-unit.h

	skipping to change at line 64	skipping to change at line 64
	" </method>\n" \	" </method>\n" \
	" <method name=\"ReloadOrTryRestart\">\n" \	" <method name=\"ReloadOrTryRestart\">\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=\"Kill\">\n" \	" <method name=\"Kill\">\n" \
	" <arg name=\"who\" type=\"s\" direction=\"in\"/>\n" \	" <arg name=\"who\" type=\"s\" direction=\"in\"/>\n" \
	" <arg name=\"signal\" type=\"i\" direction=\"in\"/>\n" \	" <arg name=\"signal\" type=\"i\" direction=\"in\"/>\n" \
	" </method>\n" \	" </method>\n" \
	" <method name=\"ResetFailed\"/>\n" \	" <method name=\"ResetFailed\"/>\n" \

		" <method name=\"SetProperties\">\n" \
		" <arg name=\"runtime\" type=\"b\" direction=\"in\"/>\n" \
		" <arg name=\"properties\" type=\"a(sv)\" direction=\"in\"/>\n" \
		" </method>\n" \
	" <property name=\"Id\" type=\"s\" access=\"read\"/>\n" \	" <property name=\"Id\" type=\"s\" access=\"read\"/>\n" \
	" <property name=\"Names\" type=\"as\" access=\"read\"/>\n" \	" <property name=\"Names\" type=\"as\" access=\"read\"/>\n" \
	" <property name=\"Following\" type=\"s\" access=\"read\"/>\n" \	" <property name=\"Following\" type=\"s\" access=\"read\"/>\n" \
	" <property name=\"Requires\" type=\"as\" access=\"read\"/>\n" \	" <property name=\"Requires\" type=\"as\" access=\"read\"/>\n" \
	" <property name=\"RequiresOverridable\" type=\"as\" access=\"read \"/>\n" \	" <property name=\"RequiresOverridable\" type=\"as\" access=\"read \"/>\n" \
	" <property name=\"Requisite\" type=\"as\" access=\"read\"/>\n" \	" <property name=\"Requisite\" type=\"as\" access=\"read\"/>\n" \
	" <property name=\"RequisiteOverridable\" type=\"as\" access=\"rea d\"/>\n" \	" <property name=\"RequisiteOverridable\" type=\"as\" access=\"rea d\"/>\n" \
	" <property name=\"Wants\" type=\"as\" access=\"read\"/>\n" \	" <property name=\"Wants\" type=\"as\" access=\"read\"/>\n" \
	" <property name=\"BindsTo\" type=\"as\" access=\"read\"/>\n" \	" <property name=\"BindsTo\" type=\"as\" access=\"read\"/>\n" \
	" <property name=\"PartOf\" type=\"as\" access=\"read\"/>\n" \	" <property name=\"PartOf\" type=\"as\" access=\"read\"/>\n" \

	skipping to change at line 125	skipping to change at line 129
	" <property name=\"DefaultDependencies\" type=\"b\" access=\"read\ "/>\n" \	" <property name=\"DefaultDependencies\" type=\"b\" access=\"read\ "/>\n" \
	" <property name=\"OnFailureIsolate\" type=\"b\" access=\"read\"/> \n" \	" <property name=\"OnFailureIsolate\" type=\"b\" access=\"read\"/> \n" \
	" <property name=\"IgnoreOnIsolate\" type=\"b\" access=\"read\"/>\ n" \	" <property name=\"IgnoreOnIsolate\" type=\"b\" access=\"read\"/>\ n" \
	" <property name=\"IgnoreOnSnapshot\" type=\"b\" access=\"read\"/> \n" \	" <property name=\"IgnoreOnSnapshot\" type=\"b\" access=\"read\"/> \n" \
	" <property name=\"NeedDaemonReload\" type=\"b\" access=\"read\"/> \n" \	" <property name=\"NeedDaemonReload\" type=\"b\" access=\"read\"/> \n" \
	" <property name=\"JobTimeoutUSec\" type=\"t\" access=\"read\"/>\n " \	" <property name=\"JobTimeoutUSec\" type=\"t\" access=\"read\"/>\n " \
	" <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" \

		" <property name=\"Transient\" type=\"b\" access=\"read\"/>\n" \
	" </interface>\n"	" </interface>\n"

	#define BUS_UNIT_CGROUP_INTERFACE \	#define BUS_UNIT_CGROUP_INTERFACE \

	" <property name=\"DefaultControlGroup\" type=\"s\" access=\"read\	" <property name=\"Slice\" type=\"s\" access=\"read\"/>\n" \
	"/>\n" \	" <property name=\"ControlGroup\" type=\"s\" access=\"read\"/>\n"
	" <property name=\"ControlGroups\" type=\"as\" access=\"read\"/>\n
	" \
	" <property name=\"ControlGroupAttributes\" type=\"a(sss)\" access
	=\"read\"/>\n" \
	" <method name=\"SetControlGroup\">\n" \
	" <arg name=\"group\" type=\"s\" direction=\"in\"/>\n" \
	" <arg name=\"mode\" type=\"s\" direction=\"in\"/>\n" \
	" </method>\n" \
	" <method name=\"UnsetControlGroup\">\n" \
	" <arg name=\"group\" type=\"s\" direction=\"in\"/>\n" \
	" <arg name=\"mode\" type=\"s\" direction=\"in\"/>\n" \
	" </method>\n" \
	" <method name=\"GetControlGroupAttribute\">\n" \
	" <arg name=\"attribute\" type=\"s\" direction=\"in\"/>\n" \
	" <arg name=\"values\" type=\"as\" direction=\"out\"/>\n" \
	" </method>\n" \
	" <method name=\"SetControlGroupAttribute\">\n" \
	" <arg name=\"attribute\" type=\"s\" direction=\"in\"/>\n" \
	" <arg name=\"values\" type=\"as\" direction=\"in\"/>\n" \
	" <arg name=\"mode\" type=\"s\" direction=\"in\"/>\n" \
	" </method>\n" \
	" <method name=\"UnsetControlGroupAttribute\">\n" \
	" <arg name=\"attribute\" type=\"s\" direction=\"in\"/>\n" \
	" <arg name=\"mode\" type=\"s\" direction=\"in\"/>\n" \
	" </method>\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"

	extern const BusProperty bus_unit_properties[];	extern const BusProperty bus_unit_properties[];
	extern const BusProperty bus_unit_cgroup_properties[];	extern const BusProperty bus_unit_cgroup_properties[];

	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);


	DBusHandlerResult bus_unit_queue_job(	DBusHandlerResult bus_unit_queue_job(DBusConnection *connection, DBusMessag
	DBusConnection *connection,	e message, Unit u, JobType type, JobMode mode, bool reload_if_possible);
	DBusMessage *message,
	Unit *u,	int bus_unit_set_properties(Unit u, DBusMessageIter i, UnitSetPropertiesM
	JobType type,	ode mode, bool commit, DBusError *error);
	JobMode mode,
	bool reload_if_possible);

	int bus_unit_cgroup_set(Unit u, DBusMessageIter iter);
	int bus_unit_cgroup_unset(Unit u, DBusMessageIter iter);
	int bus_unit_cgroup_attribute_get(Unit u, DBusMessageIter iter, char ***_
	result);
	int bus_unit_cgroup_attribute_set(Unit u, DBusMessageIter iter);
	int bus_unit_cgroup_attribute_unset(Unit u, DBusMessageIter iter);

	extern const DBusObjectPathVTable bus_unit_vtable;	extern const DBusObjectPathVTable bus_unit_vtable;

	extern const char bus_unit_interface[];	extern const char bus_unit_interface[];

End of changes. 4 change blocks.
	41 lines changed or deleted	12 lines changed or added

	def.h	def.h

	skipping to change at line 35	skipping to change at line 35

	#define DEFAULT_TIMEOUT_USEC (90*USEC_PER_SEC)	#define DEFAULT_TIMEOUT_USEC (90*USEC_PER_SEC)
	#define DEFAULT_RESTART_USEC (100*USEC_PER_MSEC)	#define DEFAULT_RESTART_USEC (100*USEC_PER_MSEC)
	#define DEFAULT_CONFIRM_USEC (30*USEC_PER_SEC)	#define DEFAULT_CONFIRM_USEC (30*USEC_PER_SEC)

	#define DEFAULT_EXIT_USEC (5*USEC_PER_MINUTE)	#define DEFAULT_EXIT_USEC (5*USEC_PER_MINUTE)

	#define SYSTEMD_CGROUP_CONTROLLER "name=systemd"	#define SYSTEMD_CGROUP_CONTROLLER "name=systemd"

	#define SIGNALS_CRASH_HANDLER SIGSEGV,SIGILL,SIGFPE,SIGBUS,SIGQUIT,SIGABRT	#define SIGNALS_CRASH_HANDLER SIGSEGV,SIGILL,SIGFPE,SIGBUS,SIGQUIT,SIGABRT

	#define SIGNALS_IGNORE SIGKILL,SIGPIPE	#define SIGNALS_IGNORE SIGPIPE

End of changes. 1 change blocks.
	0 lines changed or deleted	0 lines changed or added

	execute.h	execute.h

	skipping to change at line 36	skipping to change at line 36
	typedef struct ExecContext ExecContext;	typedef struct ExecContext ExecContext;

	#include <linux/types.h>	#include <linux/types.h>
	#include <sys/time.h>	#include <sys/time.h>
	#include <sys/resource.h>	#include <sys/resource.h>
	#include <sys/capability.h>	#include <sys/capability.h>
	#include <stdbool.h>	#include <stdbool.h>
	#include <stdio.h>	#include <stdio.h>
	#include <sched.h>	#include <sched.h>


	struct CGroupBonding;
	struct CGroupAttribute;

	typedef struct Unit Unit;

	#include "list.h"	#include "list.h"
	#include "util.h"	#include "util.h"


		typedef struct Unit Unit;

	typedef enum ExecInput {	typedef enum ExecInput {
	EXEC_INPUT_NULL,	EXEC_INPUT_NULL,
	EXEC_INPUT_TTY,	EXEC_INPUT_TTY,
	EXEC_INPUT_TTY_FORCE,	EXEC_INPUT_TTY_FORCE,
	EXEC_INPUT_TTY_FAIL,	EXEC_INPUT_TTY_FAIL,
	EXEC_INPUT_SOCKET,	EXEC_INPUT_SOCKET,
	_EXEC_INPUT_MAX,	_EXEC_INPUT_MAX,
	_EXEC_INPUT_INVALID = -1	_EXEC_INPUT_INVALID = -1
	} ExecInput;	} ExecInput;


	skipping to change at line 151	skipping to change at line 148

	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;
	char *tmp_dir;	char *tmp_dir;
	char *var_tmp_dir;	char *var_tmp_dir;

	bool no_new_privileges;	bool no_new_privileges;


	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;

	uint32_t *syscall_filter;	uint32_t *syscall_filter;

	bool oom_score_adjust_set:1;	bool oom_score_adjust_set:1;
	bool nice_set:1;	bool nice_set:1;
	bool ioprio_set:1;	bool ioprio_set:1;
	bool cpu_sched_set:1;	bool cpu_sched_set:1;
	};	};


		#include "cgroup.h"

	int exec_spawn(ExecCommand *command,	int exec_spawn(ExecCommand *command,
	char **argv,	char **argv,
	ExecContext *context,	ExecContext *context,
	int fds[], unsigned n_fds,	int fds[], unsigned n_fds,
	char **environment,	char **environment,
	bool apply_permissions,	bool apply_permissions,
	bool apply_chroot,	bool apply_chroot,
	bool apply_tty_stdin,	bool apply_tty_stdin,
	bool confirm_spawn,	bool confirm_spawn,

	struct CGroupBonding *cgroup_bondings,	CGroupControllerMask cgroup_mask,
	struct CGroupAttribute *cgroup_attributes,	const char *cgroup_path,
	const char *cgroup_suffix,
	const char *unit_id,	const char *unit_id,
	int pipe_fd[2],	int pipe_fd[2],
	pid_t *ret);	pid_t *ret);

	void exec_command_done(ExecCommand *c);	void exec_command_done(ExecCommand *c);
	void exec_command_done_array(ExecCommand *c, unsigned n);	void exec_command_done_array(ExecCommand *c, unsigned n);

	void exec_command_free_list(ExecCommand *c);	void exec_command_free_list(ExecCommand *c);
	void exec_command_free_array(ExecCommand **c, unsigned n);	void exec_command_free_array(ExecCommand **c, unsigned n);


End of changes. 5 change blocks.
	11 lines changed or deleted	6 lines changed or added

	install.h	install.h

	skipping to change at line 83	skipping to change at line 83
	char **required_by;	char **required_by;
	} InstallInfo;	} InstallInfo;

	int unit_file_enable(UnitFileScope scope, bool runtime, const char root_di r, char files[], bool force, UnitFileChange *changes, unsigned n_changes );	int unit_file_enable(UnitFileScope scope, bool runtime, const char root_di r, char files[], bool force, UnitFileChange *changes, unsigned n_changes );
	int unit_file_disable(UnitFileScope scope, bool runtime, const char root_d ir, char files[], UnitFileChange *changes, unsigned n_changes);	int unit_file_disable(UnitFileScope scope, bool runtime, const char root_d ir, char files[], UnitFileChange *changes, unsigned n_changes);
	int unit_file_reenable(UnitFileScope scope, bool runtime, const char root_ dir, char files[], bool force, UnitFileChange *changes, unsigned n_chang es);	int unit_file_reenable(UnitFileScope scope, bool runtime, const char root_ dir, char files[], bool force, UnitFileChange *changes, unsigned n_chang es);
	int unit_file_link(UnitFileScope scope, bool runtime, const char root_dir, char files[], bool force, UnitFileChange *changes, unsigned n_changes);	int unit_file_link(UnitFileScope scope, bool runtime, const char root_dir, char files[], bool force, UnitFileChange *changes, unsigned n_changes);
	int unit_file_preset(UnitFileScope scope, bool runtime, const char root_di r, char files[], bool force, UnitFileChange *changes, unsigned n_changes );	int unit_file_preset(UnitFileScope scope, bool runtime, const char root_di r, char files[], bool force, UnitFileChange *changes, unsigned n_changes );
	int unit_file_mask(UnitFileScope scope, bool runtime, const char root_dir, char files[], bool force, UnitFileChange *changes, unsigned n_changes);	int unit_file_mask(UnitFileScope scope, bool runtime, const char root_dir, char files[], bool force, UnitFileChange *changes, unsigned n_changes);
	int unit_file_unmask(UnitFileScope scope, bool runtime, const char root_di r, char files[], UnitFileChange *changes, unsigned n_changes);	int unit_file_unmask(UnitFileScope scope, bool runtime, const char root_di r, char files[], UnitFileChange *changes, unsigned n_changes);

		int unit_file_set_default(UnitFileScope scope, const char root_dir, char
		file, UnitFileChange *changes, unsigned n_changes);
		int unit_file_get_default(UnitFileScope scope, const char root_dir, char
		*name);

	UnitFileState unit_file_get_state(UnitFileScope scope, const char root_dir , const char filename);	UnitFileState unit_file_get_state(UnitFileScope scope, const char root_dir , const char filename);

	int unit_file_get_list(UnitFileScope scope, const char root_dir, Hashmap h);	int unit_file_get_list(UnitFileScope scope, const char root_dir, Hashmap h);

	void unit_file_list_free(Hashmap *h);	void unit_file_list_free(Hashmap *h);
	void unit_file_changes_free(UnitFileChange *changes, unsigned n_changes);	void unit_file_changes_free(UnitFileChange *changes, unsigned n_changes);

	int unit_file_query_preset(UnitFileScope scope, const char *name);	int unit_file_query_preset(UnitFileScope scope, const char *name);


End of changes. 1 change blocks.
	0 lines changed or deleted	4 lines changed or added

	journal-file.h	journal-file.h

	skipping to change at line 45	skipping to change at line 45
	#include "mmap-cache.h"	#include "mmap-cache.h"
	#include "hashmap.h"	#include "hashmap.h"

	typedef struct JournalMetrics {	typedef struct JournalMetrics {
	uint64_t max_use;	uint64_t max_use;
	uint64_t max_size;	uint64_t max_size;
	uint64_t min_size;	uint64_t min_size;
	uint64_t keep_free;	uint64_t keep_free;
	} JournalMetrics;	} JournalMetrics;


		typedef enum direction {
		DIRECTION_UP,
		DIRECTION_DOWN
		} direction_t;

	typedef struct JournalFile {	typedef struct JournalFile {
	int fd;	int fd;

	char *path;
	struct stat last_stat;
	mode_t mode;	mode_t mode;

	int flags;	int flags;
	int prot;	int prot;
	bool writable;	bool writable;
	bool compress;	bool compress;
	bool seal;	bool seal;

	bool tail_entry_monotonic_valid;	bool tail_entry_monotonic_valid;


		direction_t last_direction;

		char *path;
		struct stat last_stat;

	Header *header;	Header *header;
	HashItem *data_hash_table;	HashItem *data_hash_table;
	HashItem *field_hash_table;	HashItem *field_hash_table;

	uint64_t current_offset;	uint64_t current_offset;

	JournalMetrics metrics;	JournalMetrics metrics;
	MMapCache *mmap;	MMapCache *mmap;

	Hashmap *chain_cache;	Hashmap *chain_cache;

	skipping to change at line 93	skipping to change at line 102
	uint64_t fss_interval_usec;	uint64_t fss_interval_usec;

	void *fsprg_state;	void *fsprg_state;
	size_t fsprg_state_size;	size_t fsprg_state_size;

	void *fsprg_seed;	void *fsprg_seed;
	size_t fsprg_seed_size;	size_t fsprg_seed_size;
	#endif	#endif
	} JournalFile;	} JournalFile;


	typedef enum direction {
	DIRECTION_UP,
	DIRECTION_DOWN
	} direction_t;

	int journal_file_open(	int journal_file_open(
	const char *fname,	const char *fname,
	int flags,	int flags,
	mode_t mode,	mode_t mode,
	bool compress,	bool compress,
	bool seal,	bool seal,
	JournalMetrics *metrics,	JournalMetrics *metrics,
	MMapCache *mmap_cache,	MMapCache *mmap_cache,
	JournalFile *template,	JournalFile *template,
	JournalFile **ret);	JournalFile **ret);

End of changes. 4 change blocks.
	7 lines changed or deleted	11 lines changed or added

	journal-internal.h	journal-internal.h

	skipping to change at line 126	skipping to change at line 126

	Match level0, level1, *level2;	Match level0, level1, *level2;

	unsigned current_invalidate_counter, last_invalidate_counter;	unsigned current_invalidate_counter, last_invalidate_counter;

	char *unique_field;	char *unique_field;
	JournalFile *unique_file;	JournalFile *unique_file;
	uint64_t unique_offset;	uint64_t unique_offset;

	bool on_network;	bool on_network;

		bool no_new_files;

	size_t data_threshold;	size_t data_threshold;

	Set *errors;	Set *errors;

	usec_t last_process_usec;	usec_t last_process_usec;
	};	};

	char journal_make_match_string(sd_journal j);	char journal_make_match_string(sd_journal j);
	void journal_print_header(sd_journal *j);	void journal_print_header(sd_journal *j);

	static inline void journal_closep(sd_journal **j) {	static inline void journal_closep(sd_journal **j) {
	sd_journal_close(*j);	sd_journal_close(*j);
	}	}

	#define _cleanup_journal_close_ _cleanup_(journal_closep)	#define _cleanup_journal_close_ _cleanup_(journal_closep)


		#define JOURNAL_FOREACH_DATA_RETVAL(j, data, l, retval)
		\
		for (sd_journal_restart_data(j); ((retval) = sd_journal_enumerate_d
		ata((j), &(data), &(l))) > 0; )

End of changes. 2 change blocks.
	0 lines changed or deleted	1 lines changed or added

	journald-server.h	journald-server.h

	skipping to change at line 131	skipping to change at line 131

	struct udev *udev;	struct udev *udev;

	int sync_timer_fd;	int sync_timer_fd;
	bool sync_scheduled;	bool sync_scheduled;
	} Server;	} Server;

	#define N_IOVEC_META_FIELDS 17	#define N_IOVEC_META_FIELDS 17
	#define N_IOVEC_KERNEL_FIELDS 64	#define N_IOVEC_KERNEL_FIELDS 64
	#define N_IOVEC_UDEV_FIELDS 32	#define N_IOVEC_UDEV_FIELDS 32

		#define N_IOVEC_OBJECT_FIELDS 11


	void server_dispatch_message(Server s, struct iovec iovec, unsigned n, un signed m, struct ucred ucred, struct timeval tv, const char label, size_ t label_len, const char unit_id, int priority);	void server_dispatch_message(Server s, struct iovec iovec, unsigned n, un signed m, struct ucred ucred, struct timeval tv, const char label, size_ t label_len, const char unit_id, int priority, pid_t object_pid);
	void server_driver_message(Server s, sd_id128_t message_id, const char fo rmat, ...) _printf_attr_(3,4);	void server_driver_message(Server s, sd_id128_t message_id, const char fo rmat, ...) _printf_attr_(3,4);

	/* 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);

	int config_parse_storage(const char unit, const char filename, unsigned l ine, const char section, const char lvalue, int ltype, const char rvalue , void data, void *userdata);	int config_parse_storage(const char unit, const char filename, unsigned l ine, const char section, const char lvalue, int ltype, const char rvalue , void data, void *userdata);

	const char *storage_to_string(Storage s) _const_;	const char *storage_to_string(Storage s) _const_;
	Storage storage_from_string(const char *s) _pure_;	Storage storage_from_string(const char *s) _pure_;


End of changes. 2 change blocks.
	1 lines changed or deleted	2 lines changed or added

	kdbus.h	kdbus.h

	skipping to change at line 24	skipping to change at line 24
	#ifndef _KDBUS_H_	#ifndef _KDBUS_H_
	#define _KDBUS_H_	#define _KDBUS_H_

	#ifndef __KERNEL__	#ifndef __KERNEL__
	#include <sys/ioctl.h>	#include <sys/ioctl.h>
	#include <sys/types.h>	#include <sys/types.h>
	#include <linux/types.h>	#include <linux/types.h>
	#endif	#endif

	#define KDBUS_IOC_MAGIC 0x95	#define KDBUS_IOC_MAGIC 0x95

		#define KDBUS_SRC_ID_KERNEL (0)
		#define KDBUS_DST_ID_WELL_KNOWN_NAME (0)
		#define KDBUS_MATCH_SRC_ID_ANY (~0ULL)
		#define KDBUS_DST_ID_BROADCAST (~0ULL)

		/* Common first elements in a structure which are used to iterate over
		* a list of elements. */
		#define KDBUS_PART_HEADER \
		struct { \
		__u64 size; \
		__u64 type; \
		}

	/* Message sent from kernel to userspace, when the owner or starter of	/* Message sent from kernel to userspace, when the owner or starter of
	* a well-known name changes */	* a well-known name changes */
	struct kdbus_manager_msg_name_change {	struct kdbus_manager_msg_name_change {
	__u64 old_id;	__u64 old_id;
	__u64 new_id;	__u64 new_id;
	__u64 flags; /* 0 or (possibly?) KDBUS_NAME_IN_QU EUE */	__u64 flags; /* 0 or (possibly?) KDBUS_NAME_IN_QU EUE */
	char name[0];	char name[0];
	};	};


	skipping to change at line 63	skipping to change at line 75
	struct kdbus_audit {	struct kdbus_audit {
	__u64 sessionid;	__u64 sessionid;
	__u64 loginuid;	__u64 loginuid;
	};	};

	struct kdbus_timestamp {	struct kdbus_timestamp {
	__u64 monotonic_ns;	__u64 monotonic_ns;
	__u64 realtime_ns;	__u64 realtime_ns;
	};	};


	#define KDBUS_SRC_ID_KERNEL (0)	struct kdbus_vec {
	#define KDBUS_DST_ID_WELL_KNOWN_NAME (0)	__u64 size;
	#define KDBUS_MATCH_SRC_ID_ANY (~0ULL)	union {
	#define KDBUS_DST_ID_BROADCAST (~0ULL)	__u64 address;
		__u64 offset;
		};
		};

		struct kdbus_memfd {
		__u64 size;
		int fd;
		__u32 __pad;
		};

	/* Message Item Types */	/* Message Item Types */
	enum {	enum {

	KDBUS_MSG_NULL,	_KDBUS_MSG_NULL,

	/* Filled in by userspace */	/* Filled in by userspace */

	KDBUS_MSG_PAYLOAD, /* .data, inline memory */
	KDBUS_MSG_PAYLOAD_VEC, /* .data_vec, reference to memory ar ea */	KDBUS_MSG_PAYLOAD_VEC, /* .data_vec, reference to memory ar ea */

	KDBUS_MSG_UNIX_FDS, /* .data_fds of file descriptors */	KDBUS_MSG_PAYLOAD_OFF, /* .data_vec, reference to memory ar
		ea */
		KDBUS_MSG_PAYLOAD_MEMFD, /* file descriptor of a special data
		file */
		KDBUS_MSG_FDS, /* .data_fds of file descriptors */
	KDBUS_MSG_BLOOM, /* for broadcasts, carries bloom fil ter blob in .data */	KDBUS_MSG_BLOOM, /* for broadcasts, carries bloom fil ter blob in .data */
	KDBUS_MSG_DST_NAME, /* destination's well-known name, in .str */	KDBUS_MSG_DST_NAME, /* destination's well-known name, in .str */

		KDBUS_MSG_PRIORITY, /* queue priority for message */

	/* Filled in by kernelspace */	/* Filled in by kernelspace */

	KDBUS_MSG_SRC_NAMES = 0x200,/* NUL separated string list with we ll-known names of source */	KDBUS_MSG_SRC_NAMES = 0x400,/* NUL separated string list with we ll-known names of source */
	KDBUS_MSG_TIMESTAMP, /* .timestamp */	KDBUS_MSG_TIMESTAMP, /* .timestamp */
	KDBUS_MSG_SRC_CREDS, /* .creds */	KDBUS_MSG_SRC_CREDS, /* .creds */
	KDBUS_MSG_SRC_PID_COMM, /* optional, in .str */	KDBUS_MSG_SRC_PID_COMM, /* optional, in .str */
	KDBUS_MSG_SRC_TID_COMM, /* optional, in .str */	KDBUS_MSG_SRC_TID_COMM, /* optional, in .str */
	KDBUS_MSG_SRC_EXE, /* optional, in .str */	KDBUS_MSG_SRC_EXE, /* optional, in .str */
	KDBUS_MSG_SRC_CMDLINE, /* optional, in .str (a chain of NUL str) */	KDBUS_MSG_SRC_CMDLINE, /* optional, in .str (a chain of NUL str) */
	KDBUS_MSG_SRC_CGROUP, /* optional, in .str */	KDBUS_MSG_SRC_CGROUP, /* optional, in .str */
	KDBUS_MSG_SRC_CAPS, /* caps data blob, in .data */	KDBUS_MSG_SRC_CAPS, /* caps data blob, in .data */
	KDBUS_MSG_SRC_SECLABEL, /* NUL terminated string, in .str */	KDBUS_MSG_SRC_SECLABEL, /* NUL terminated string, in .str */
	KDBUS_MSG_SRC_AUDIT, /* .audit */	KDBUS_MSG_SRC_AUDIT, /* .audit */

	/* Special messages from kernel, consisting of one and only one of t hese data blocks */	/* Special messages from kernel, consisting of one and only one of t hese data blocks */

	KDBUS_MSG_NAME_ADD = 0x400,/* .name_change */	KDBUS_MSG_NAME_ADD = 0x800,/* .name_change */
	KDBUS_MSG_NAME_REMOVE, /* .name_change */	KDBUS_MSG_NAME_REMOVE, /* .name_change */
	KDBUS_MSG_NAME_CHANGE, /* .name_change */	KDBUS_MSG_NAME_CHANGE, /* .name_change */
	KDBUS_MSG_ID_ADD, /* .id_change */	KDBUS_MSG_ID_ADD, /* .id_change */
	KDBUS_MSG_ID_REMOVE, /* .id_change */	KDBUS_MSG_ID_REMOVE, /* .id_change */
	KDBUS_MSG_REPLY_TIMEOUT, /* empty, but .reply_cookie in .kdbu s_msg is filled in */	KDBUS_MSG_REPLY_TIMEOUT, /* empty, but .reply_cookie in .kdbu s_msg is filled in */
	KDBUS_MSG_REPLY_DEAD, /* dito */	KDBUS_MSG_REPLY_DEAD, /* dito */
	};	};


	enum {
	KDBUS_VEC_ALIGNED = 1 << 0,
	};

	struct kdbus_vec {
	__u64 address;
	__u64 size;
	__u64 flags;
	};

	/**	/**
	* struct kdbus_item - chain of data blocks	* struct kdbus_item - chain of data blocks
	*	*
	* size: overall data record size	* size: overall data record size
	* type: kdbus_item type of data	* type: kdbus_item type of data
	*/	*/
	struct kdbus_item {	struct kdbus_item {

	__u64 size;	KDBUS_PART_HEADER;
	__u64 type;
	union {	union {
	/* inline data */	/* inline data */
	__u8 data[0];	__u8 data[0];
	__u32 data32[0];	__u32 data32[0];
	__u64 data64[0];	__u64 data64[0];
	char str[0];	char str[0];

	/* connection */	/* connection */
	__u64 id;	__u64 id;

	/* data vector */	/* data vector */
	struct kdbus_vec vec;	struct kdbus_vec vec;

	/* process credentials and properties*/	/* process credentials and properties*/
	struct kdbus_creds creds;	struct kdbus_creds creds;
	struct kdbus_audit audit;	struct kdbus_audit audit;
	struct kdbus_timestamp timestamp;	struct kdbus_timestamp timestamp;

	/* specific fields */	/* specific fields */

		struct kdbus_memfd memfd;
	int fds[0];	int fds[0];
	struct kdbus_manager_msg_name_change name_change;	struct kdbus_manager_msg_name_change name_change;
	struct kdbus_manager_msg_id_change id_change;	struct kdbus_manager_msg_id_change id_change;
	};	};
	};	};

	enum {	enum {
	KDBUS_MSG_FLAGS_EXPECT_REPLY = 1 << 0,	KDBUS_MSG_FLAGS_EXPECT_REPLY = 1 << 0,
	KDBUS_MSG_FLAGS_NO_AUTO_START = 1 << 1,	KDBUS_MSG_FLAGS_NO_AUTO_START = 1 << 1,
	};	};

	enum {	enum {

	KDBUS_PAYLOAD_NULL,	KDBUS_PAYLOAD_KERNEL,
	KDBUS_PAYLOAD_DBUS1 = 0x4442757356657231ULL, /* 'DBusVer1' */	KDBUS_PAYLOAD_DBUS1 = 0x4442757356657231ULL, /* 'DBusVer1' */
	KDBUS_PAYLOAD_GVARIANT = 0x4756617269616e74ULL, /* 'GVariant' */	KDBUS_PAYLOAD_GVARIANT = 0x4756617269616e74ULL, /* 'GVariant' */
	};	};

	/**	/**
	* struct kdbus_msg	* struct kdbus_msg
	*	*
	* set by userspace:	* set by userspace:
	* dst_id: destination id	* dst_id: destination id
	* flags: KDBUS_MSG_FLAGS_*	* flags: KDBUS_MSG_FLAGS_*

	skipping to change at line 183	skipping to change at line 196
	__u64 payload_type; /* 'DBusVer1', 'GVariant', ... */	__u64 payload_type; /* 'DBusVer1', 'GVariant', ... */
	__u64 cookie; /* userspace-supplied cookie */	__u64 cookie; /* userspace-supplied cookie */
	union {	union {
	__u64 cookie_reply; /* cookie we reply to */	__u64 cookie_reply; /* cookie we reply to */
	__u64 timeout_ns; /* timespan to wait for reply */	__u64 timeout_ns; /* timespan to wait for reply */
	};	};
	struct kdbus_item items[0];	struct kdbus_item items[0];
	};	};

	enum {	enum {

	KDBUS_POLICY_NULL,	_KDBUS_POLICY_NULL,
	KDBUS_POLICY_NAME,	KDBUS_POLICY_NAME,
	KDBUS_POLICY_ACCESS,	KDBUS_POLICY_ACCESS,
	};	};

	enum {	enum {

	KDBUS_POLICY_ACCESS_NULL,	_KDBUS_POLICY_ACCESS_NULL,
	KDBUS_POLICY_ACCESS_USER,	KDBUS_POLICY_ACCESS_USER,
	KDBUS_POLICY_ACCESS_GROUP,	KDBUS_POLICY_ACCESS_GROUP,
	KDBUS_POLICY_ACCESS_WORLD,	KDBUS_POLICY_ACCESS_WORLD,
	};	};

	enum {	enum {
	KDBUS_POLICY_RECV = 1 << 2,	KDBUS_POLICY_RECV = 1 << 2,
	KDBUS_POLICY_SEND = 1 << 1,	KDBUS_POLICY_SEND = 1 << 1,
	KDBUS_POLICY_OWN = 1 << 0,	KDBUS_POLICY_OWN = 1 << 0,
	};	};


		struct kdbus_policy_access {
		__u64 type; /* USER, GROUP, WORLD */
		__u64 bits; /* RECV, SEND, OWN */
		__u64 id; /* uid, gid, 0 */
		};

		//FIXME: convert access to access[]
	struct kdbus_policy {	struct kdbus_policy {

	__u64 size;	KDBUS_PART_HEADER;
	__u64 type; /* NAME or ACCESS */
	union {	union {
	char name[0];	char name[0];

	struct {	struct kdbus_policy_access access;
	__u32 type; /* USER, GROUP, WORLD */
	__u32 bits; /* RECV, SEND, OWN */
	__u64 id; /* uid, gid, 0 */
	} access;
	};	};
	};	};


		/* A series of KDBUS_POLICY_NAME, plus one or more KDBUS_POLICY_ACCESS */
	struct kdbus_cmd_policy {	struct kdbus_cmd_policy {
	__u64 size;	__u64 size;

	__u8 buffer[0]; /* a series of KDBUS_POLICY_NAME plus one or	struct kdbus_policy policies[0];
	* more KDBUS_POLICY_ACCESS each. */
	};	};

	/* Flags for struct kdbus_cmd_hello */	/* Flags for struct kdbus_cmd_hello */
	enum {	enum {
	KDBUS_HELLO_STARTER = 1 << 0,	KDBUS_HELLO_STARTER = 1 << 0,
	KDBUS_HELLO_ACCEPT_FD = 1 << 1,	KDBUS_HELLO_ACCEPT_FD = 1 << 1,

	/* The following have an effect on directed messages only --	/* The following have an effect on directed messages only --
	* not for broadcasts */	* not for broadcasts */
	KDBUS_HELLO_ATTACH_COMM = 1 << 10,	KDBUS_HELLO_ATTACH_COMM = 1 << 10,
	KDBUS_HELLO_ATTACH_EXE = 1 << 11,	KDBUS_HELLO_ATTACH_EXE = 1 << 11,
	KDBUS_HELLO_ATTACH_CMDLINE = 1 << 12,	KDBUS_HELLO_ATTACH_CMDLINE = 1 << 12,
	KDBUS_HELLO_ATTACH_CGROUP = 1 << 13,	KDBUS_HELLO_ATTACH_CGROUP = 1 << 13,
	KDBUS_HELLO_ATTACH_CAPS = 1 << 14,	KDBUS_HELLO_ATTACH_CAPS = 1 << 14,
	KDBUS_HELLO_ATTACH_SECLABEL = 1 << 15,	KDBUS_HELLO_ATTACH_SECLABEL = 1 << 15,
	KDBUS_HELLO_ATTACH_AUDIT = 1 << 16,	KDBUS_HELLO_ATTACH_AUDIT = 1 << 16,
	};	};


	/* Items to append to struct kdbus_cmd_hello */
	enum {
	KDBUS_HELLO_NULL,
	};

	struct kdbus_cmd_hello {	struct kdbus_cmd_hello {
	__u64 size;	__u64 size;

	/* userspace → kernel, kernel → userspace */	/* userspace → kernel, kernel → userspace */
	__u64 conn_flags; /* userspace specifies its	__u64 conn_flags; /* userspace specifies its
	* capabilities and more, kernel	* capabilities and more, kernel
	* returns its capabilites and	* returns its capabilites and
	* more. Kernel might refuse client's	* more. Kernel might refuse client's
	* capabilities by returning an error	* capabilities by returning an error
	* from KDBUS_HELLO */	* from KDBUS_HELLO */

	/* kernel → userspace */	/* kernel → userspace */
	__u64 bus_flags; /* this is .flags copied verbatim from	__u64 bus_flags; /* this is .flags copied verbatim from
	* from original KDBUS_CMD_BUS_MAKE	* from original KDBUS_CMD_BUS_MAKE
	* ioctl. It's intended to be useful	* ioctl. It's intended to be useful
	* to do negotiation of features of	* to do negotiation of features of
	* the payload that is transfreted. */	* the payload that is transfreted. */
	__u64 id; /* id assigned to this connection */	__u64 id; /* id assigned to this connection */
	__u64 bloom_size; /* The bloom filter size chosen by the	__u64 bloom_size; /* The bloom filter size chosen by the
	* bus owner */	* bus owner */

		__u64 pool_size; /* maximum size of pool buffer */
	struct kdbus_item items[0];	struct kdbus_item items[0];
	};	};

	/* Flags for kdbus_cmd_{bus,ep,ns}_make */	/* Flags for kdbus_cmd_{bus,ep,ns}_make */
	enum {	enum {
	KDBUS_MAKE_ACCESS_GROUP = 1 << 0,	KDBUS_MAKE_ACCESS_GROUP = 1 << 0,
	KDBUS_MAKE_ACCESS_WORLD = 1 << 1,	KDBUS_MAKE_ACCESS_WORLD = 1 << 1,
	KDBUS_MAKE_POLICY_OPEN = 1 << 2,	KDBUS_MAKE_POLICY_OPEN = 1 << 2,
	};	};

	/* Items to append to kdbus_cmd_{bus,ep,ns}_make */	/* Items to append to kdbus_cmd_{bus,ep,ns}_make */
	enum {	enum {

	KDBUS_MAKE_NULL,	_KDBUS_MAKE_NULL,
	KDBUS_MAKE_NAME,	KDBUS_MAKE_NAME,
	KDBUS_MAKE_CGROUP, /* the cgroup hierarchy ID for which to atta ch	KDBUS_MAKE_CGROUP, /* the cgroup hierarchy ID for which to atta ch

	* cgroup membership paths * to messages. */	* cgroup membership paths to messages.
		* FIXME: remove, use the hierarchy */
	KDBUS_MAKE_CRED, /* allow translator services which connect	KDBUS_MAKE_CRED, /* allow translator services which connect
	* to the bus on behalf of somebody else,	* to the bus on behalf of somebody else,

	* allow specifying the credentials of the	* allow specifiying the credentials of the
	* client to connect on behalf on. Needs	* client to connect on behalf on. Needs
	* privileges */	* privileges */
	};	};

	struct kdbus_cmd_bus_make {	struct kdbus_cmd_bus_make {
	__u64 size;	__u64 size;
	__u64 flags; /* userspace → kernel, kernel → userspace	__u64 flags; /* userspace → kernel, kernel → userspace
	* When creating a bus feature	* When creating a bus feature
	* kernel negotiation. */	* kernel negotiation. */
	__u64 bus_flags; /* userspace → kernel	__u64 bus_flags; /* userspace → kernel
	* When a bus is created this value is	* When a bus is created this value is
	* copied verbatim into the bus	* copied verbatim into the bus
	* structure and returned from	* structure and returned from
	* KDBUS_CMD_HELLO, later */	* KDBUS_CMD_HELLO, later */
	__u64 bloom_size; /* size of the bloom filter for this bus */	__u64 bloom_size; /* size of the bloom filter for this bus */
	struct kdbus_item items[0];	struct kdbus_item items[0];


	};	};

	struct kdbus_cmd_ep_make {	struct kdbus_cmd_ep_make {
	__u64 size;	__u64 size;
	__u64 flags; /* userspace → kernel, kernel → userspace	__u64 flags; /* userspace → kernel, kernel → userspace
	* When creating an entry point	* When creating an entry point
	* feature kernel negotiation done the	* feature kernel negotiation done the
	* same way as for	* same way as for
	* KDBUS_CMD_BUS_MAKE. Unused for	* KDBUS_CMD_BUS_MAKE. Unused for
	* now. */	* now. */

	skipping to change at line 331	skipping to change at line 342
	enum {	enum {
	/* userspace → kernel */	/* userspace → kernel */
	KDBUS_NAME_REPLACE_EXISTING = 1 << 0,	KDBUS_NAME_REPLACE_EXISTING = 1 << 0,
	KDBUS_NAME_QUEUE = 1 << 1,	KDBUS_NAME_QUEUE = 1 << 1,
	KDBUS_NAME_ALLOW_REPLACEMENT = 1 << 2,	KDBUS_NAME_ALLOW_REPLACEMENT = 1 << 2,

	/* kernel → userspace */	/* kernel → userspace */
	KDBUS_NAME_IN_QUEUE = 1 << 16,	KDBUS_NAME_IN_QUEUE = 1 << 16,
	};	};


		/* We allow (de)regestration of names of other peers */
	struct kdbus_cmd_name {	struct kdbus_cmd_name {
	__u64 size;	__u64 size;

	__u64 name_flags;	__u64 flags;
	__u64 id; /* We allow registration/deregestration of n	__u64 id;
	ames of other peers */
	__u64 conn_flags;	__u64 conn_flags;
	char name[0];	char name[0];
	};	};

	struct kdbus_cmd_names {	struct kdbus_cmd_names {
	__u64 size;	__u64 size;
	struct kdbus_cmd_name names[0];	struct kdbus_cmd_name names[0];
	};	};

	enum {	enum {

	KDBUS_NAME_INFO_ITEM_NULL,	_KDBUS_NAME_INFO_ITEM_NULL,
	KDBUS_NAME_INFO_ITEM_NAME, /* userspace → kernel */	KDBUS_NAME_INFO_ITEM_NAME, /* userspace → kernel */
	KDBUS_NAME_INFO_ITEM_SECLABEL, /* kernel → userspace */	KDBUS_NAME_INFO_ITEM_SECLABEL, /* kernel → userspace */
	KDBUS_NAME_INFO_ITEM_AUDIT, /* kernel → userspace */	KDBUS_NAME_INFO_ITEM_AUDIT, /* kernel → userspace */
	};	};

	struct kdbus_cmd_name_info {	struct kdbus_cmd_name_info {
	__u64 size; /* overall size of info */	__u64 size; /* overall size of info */
	__u64 flags;	__u64 flags;
	__u64 id; /* either ID, or 0 and _ITEM_NAME fo llows */	__u64 id; /* either ID, or 0 and _ITEM_NAME fo llows */
	struct kdbus_creds creds;	struct kdbus_creds creds;
	struct kdbus_item items[0]; /* list of item records */	struct kdbus_item items[0]; /* list of item records */
	};	};

	enum {	enum {

	KDBUS_MATCH_NULL,	_KDBUS_MATCH_NULL,
	KDBUS_MATCH_BLOOM, /* Matches a mask blob against KDBUS _MSG_BLOOM */	KDBUS_MATCH_BLOOM, /* Matches a mask blob against KDBUS _MSG_BLOOM */
	KDBUS_MATCH_SRC_NAME, /* Matches a name string against KDB US_MSG_SRC_NAMES */	KDBUS_MATCH_SRC_NAME, /* Matches a name string against KDB US_MSG_SRC_NAMES */
	KDBUS_MATCH_NAME_ADD, /* Matches a name string against KDB US_MSG_NAME_ADD */	KDBUS_MATCH_NAME_ADD, /* Matches a name string against KDB US_MSG_NAME_ADD */
	KDBUS_MATCH_NAME_REMOVE, /* Matches a name string against KDB US_MSG_NAME_REMOVE */	KDBUS_MATCH_NAME_REMOVE, /* Matches a name string against KDB US_MSG_NAME_REMOVE */
	KDBUS_MATCH_NAME_CHANGE, /* Matches a name string against KDB US_MSG_NAME_CHANGE */	KDBUS_MATCH_NAME_CHANGE, /* Matches a name string against KDB US_MSG_NAME_CHANGE */
	KDBUS_MATCH_ID_ADD, /* Matches an ID against KDBUS_MSG_I D_ADD */	KDBUS_MATCH_ID_ADD, /* Matches an ID against KDBUS_MSG_I D_ADD */
	KDBUS_MATCH_ID_REMOVE, /* Matches an ID against KDBUS_MSG_I D_REMOVE */	KDBUS_MATCH_ID_REMOVE, /* Matches an ID against KDBUS_MSG_I D_REMOVE */
	};	};

	struct kdbus_cmd_match {	struct kdbus_cmd_match {
	__u64 size;	__u64 size;
	__u64 id; /* We allow registration/deregestration of matches f or other peers */	__u64 id; /* We allow registration/deregestration of matches f or other peers */
	__u64 cookie; /* userspace supplied cookie; when removing; kernel deletes everything with same cookie */	__u64 cookie; /* userspace supplied cookie; when removing; kernel deletes everything with same cookie */
	__u64 src_id; /* ~0: any. other: exact unique match */	__u64 src_id; /* ~0: any. other: exact unique match */
	struct kdbus_item items[0];	struct kdbus_item items[0];
	};	};

	struct kdbus_cmd_monitor {	struct kdbus_cmd_monitor {
	__u64 id; /* We allow setting the monitor flag of othe r peers */	__u64 id; /* We allow setting the monitor flag of othe r peers */

	unsigned int enabled; /* A boolean to enable/disable monitoring */	unsigned int enable; /* A boolean to enable/disable monitoring */
		__u32 __pad;
	};	};

	/* FD states:	/* FD states:
	* control nodes: unset	* control nodes: unset
	* bus owner (via KDBUS_CMD_BUS_MAKE)	* bus owner (via KDBUS_CMD_BUS_MAKE)
	* ns owner (via KDBUS_CMD_NS_MAKE)	* ns owner (via KDBUS_CMD_NS_MAKE)
	*	*
	* ep nodes: unset	* ep nodes: unset
	* connected (via KDBUS_CMD_HELLO)	* connected (via KDBUS_CMD_HELLO)
	* starter (via KDBUS_CMD_HELLO with KDBUS_CMD_HELLO_STARTER)	* starter (via KDBUS_CMD_HELLO with KDBUS_CMD_HELLO_STARTER)
	* ep owner (via KDBUS_CMD_EP_MAKE)	* ep owner (via KDBUS_CMD_EP_MAKE)
	*/	*/

	enum kdbus_cmd {	enum {
	/* kdbus control node commands: require unset state */	/* kdbus control node commands: require unset state */

	KDBUS_CMD_BUS_MAKE = _IOWR(KDBUS_IOC_MAGIC, 0x00, struct	KDBUS_CMD_BUS_MAKE = _IOW(KDBUS_IOC_MAGIC, 0x00, struct k
	kdbus_cmd_bus_make),	dbus_cmd_bus_make),
	KDBUS_CMD_NS_MAKE = _IOWR(KDBUS_IOC_MAGIC, 0x10, struct	KDBUS_CMD_NS_MAKE = _IOR(KDBUS_IOC_MAGIC, 0x10, struct k
	kdbus_cmd_ns_make),	dbus_cmd_ns_make),

	/* kdbus ep node commands: require unset state */	/* kdbus ep node commands: require unset state */

	KDBUS_CMD_EP_MAKE = _IOWR(KDBUS_IOC_MAGIC, 0x20, struct kdbus_cmd_ep_make),	KDBUS_CMD_EP_MAKE = _IOW(KDBUS_IOC_MAGIC, 0x20, struct k dbus_cmd_ep_make),
	KDBUS_CMD_HELLO = _IOWR(KDBUS_IOC_MAGIC, 0x30, struct kdbus_cmd_hello),	KDBUS_CMD_HELLO = _IOWR(KDBUS_IOC_MAGIC, 0x30, struct kdbus_cmd_hello),

	/* kdbus ep node commands: require connected state */	/* kdbus ep node commands: require connected state */

	KDBUS_CMD_MSG_SEND = _IOWR(KDBUS_IOC_MAGIC, 0x40, struct	KDBUS_CMD_MSG_SEND = _IOW(KDBUS_IOC_MAGIC, 0x40, struct k
	kdbus_msg),	dbus_msg),
	KDBUS_CMD_MSG_RECV = _IOWR(KDBUS_IOC_MAGIC, 0x41, struct	KDBUS_CMD_MSG_RECV = _IOR(KDBUS_IOC_MAGIC, 0x41, __u64 *)
	kdbus_msg),	,
		KDBUS_CMD_MSG_RELEASE = _IOW(KDBUS_IOC_MAGIC, 0x42, __u64 *)
		,

	KDBUS_CMD_NAME_ACQUIRE = _IOWR(KDBUS_IOC_MAGIC, 0x50, struct kdbus_cmd_name),	KDBUS_CMD_NAME_ACQUIRE = _IOWR(KDBUS_IOC_MAGIC, 0x50, struct kdbus_cmd_name),

	KDBUS_CMD_NAME_RELEASE = _IOWR(KDBUS_IOC_MAGIC, 0x51, struct kdbus_cmd_name),	KDBUS_CMD_NAME_RELEASE = _IOW(KDBUS_IOC_MAGIC, 0x51, struct k dbus_cmd_name),
	KDBUS_CMD_NAME_LIST = _IOWR(KDBUS_IOC_MAGIC, 0x52, struct kdbus_cmd_names),	KDBUS_CMD_NAME_LIST = _IOWR(KDBUS_IOC_MAGIC, 0x52, struct kdbus_cmd_names),
	KDBUS_CMD_NAME_QUERY = _IOWR(KDBUS_IOC_MAGIC, 0x53, struct kdbus_cmd_name_info),	KDBUS_CMD_NAME_QUERY = _IOWR(KDBUS_IOC_MAGIC, 0x53, struct kdbus_cmd_name_info),


	KDBUS_CMD_MATCH_ADD = _IOWR(KDBUS_IOC_MAGIC, 0x60, struct	KDBUS_CMD_MATCH_ADD = _IOW(KDBUS_IOC_MAGIC, 0x60, struct k
	kdbus_cmd_match),	dbus_cmd_match),
	KDBUS_CMD_MATCH_REMOVE = _IOWR(KDBUS_IOC_MAGIC, 0x61, struct	KDBUS_CMD_MATCH_REMOVE = _IOW(KDBUS_IOC_MAGIC, 0x61, struct k
	kdbus_cmd_match),	dbus_cmd_match),
	KDBUS_CMD_MONITOR = _IOWR(KDBUS_IOC_MAGIC, 0x62, struct	KDBUS_CMD_MONITOR = _IOW(KDBUS_IOC_MAGIC, 0x62, struct k
	kdbus_cmd_monitor),	dbus_cmd_monitor),

	/* kdbus ep node commands: require ep owner state */	/* kdbus ep node commands: require ep owner state */

	KDBUS_CMD_EP_POLICY_SET = _IOWR(KDBUS_IOC_MAGIC, 0x70, struct	KDBUS_CMD_EP_POLICY_SET = _IOW(KDBUS_IOC_MAGIC, 0x70, struct k
	kdbus_cmd_policy),	dbus_cmd_policy),

		/* kdbus memfd commands: */
		KDBUS_CMD_MEMFD_NEW = _IOR(KDBUS_IOC_MAGIC, 0x80, int *),
		KDBUS_CMD_MEMFD_SIZE_GET = _IOR(KDBUS_IOC_MAGIC, 0x81, __u64 *)
		,
		KDBUS_CMD_MEMFD_SIZE_SET = _IOW(KDBUS_IOC_MAGIC, 0x82, __u64 *)
		,
		KDBUS_CMD_MEMFD_SEAL_GET = _IOR(KDBUS_IOC_MAGIC, 0x83, int *),
		KDBUS_CMD_MEMFD_SEAL_SET = _IO(KDBUS_IOC_MAGIC, 0x84),
	};	};
	#endif	#endif

End of changes. 37 change blocks.
	67 lines changed or deleted	92 lines changed or added

	keys-to-name.h	keys-to-name.h

	skipping to change at line 78	skipping to change at line 78
	[KEY_HENKAN] = "KEY_HENKAN",	[KEY_HENKAN] = "KEY_HENKAN",
	[KEY_DISPLAYTOGGLE] = "KEY_DISPLAYTOGGLE",	[KEY_DISPLAYTOGGLE] = "KEY_DISPLAYTOGGLE",
	[KEY_RIGHTALT] = "KEY_RIGHTALT",	[KEY_RIGHTALT] = "KEY_RIGHTALT",
	[KEY_SPORT] = "KEY_SPORT",	[KEY_SPORT] = "KEY_SPORT",
	[KEY_POWER] = "KEY_POWER",	[KEY_POWER] = "KEY_POWER",
	[KEY_APOSTROPHE] = "KEY_APOSTROPHE",	[KEY_APOSTROPHE] = "KEY_APOSTROPHE",
	[KEY_SCREEN] = "KEY_SCREEN",	[KEY_SCREEN] = "KEY_SCREEN",
	[KEY_RADIO] = "KEY_RADIO",	[KEY_RADIO] = "KEY_RADIO",
	[KEY_DATABASE] = "KEY_DATABASE",	[KEY_DATABASE] = "KEY_DATABASE",
	[KEY_VOLUMEDOWN] = "KEY_VOLUMEDOWN",	[KEY_VOLUMEDOWN] = "KEY_VOLUMEDOWN",

	[KEY_END] = "KEY_END",
	[KEY_SENDFILE] = "KEY_SENDFILE",	[KEY_SENDFILE] = "KEY_SENDFILE",
	[KEY_RIGHTSHIFT] = "KEY_RIGHTSHIFT",	[KEY_RIGHTSHIFT] = "KEY_RIGHTSHIFT",
	[KEY_ARCHIVE] = "KEY_ARCHIVE",	[KEY_ARCHIVE] = "KEY_ARCHIVE",
	[KEY_NUMERIC_POUND] = "KEY_NUMERIC_POUND",	[KEY_NUMERIC_POUND] = "KEY_NUMERIC_POUND",
	[KEY_EPG] = "KEY_EPG",	[KEY_EPG] = "KEY_EPG",
	[KEY_NEXTSONG] = "KEY_NEXTSONG",	[KEY_NEXTSONG] = "KEY_NEXTSONG",
	[KEY_FIRST] = "KEY_FIRST",	[KEY_FIRST] = "KEY_FIRST",
	[KEY_SPREADSHEET] = "KEY_SPREADSHEET",	[KEY_SPREADSHEET] = "KEY_SPREADSHEET",
	[KEY_KPSLASH] = "KEY_KPSLASH",	[KEY_KPSLASH] = "KEY_KPSLASH",
	[KEY_BACK] = "KEY_BACK",	[KEY_BACK] = "KEY_BACK",

	skipping to change at line 235	skipping to change at line 234
	[KEY_YEN] = "KEY_YEN",	[KEY_YEN] = "KEY_YEN",
	[KEY_PLAY] = "KEY_PLAY",	[KEY_PLAY] = "KEY_PLAY",
	[KEY_REWIND] = "KEY_REWIND",	[KEY_REWIND] = "KEY_REWIND",
	[KEY_VIDEO_NEXT] = "KEY_VIDEO_NEXT",	[KEY_VIDEO_NEXT] = "KEY_VIDEO_NEXT",
	[KEY_DIRECTION] = "KEY_DIRECTION",	[KEY_DIRECTION] = "KEY_DIRECTION",
	[KEY_TOUCHPAD_OFF] = "KEY_TOUCHPAD_OFF",	[KEY_TOUCHPAD_OFF] = "KEY_TOUCHPAD_OFF",
	[KEY_HELP] = "KEY_HELP",	[KEY_HELP] = "KEY_HELP",
	[KEY_NUMERIC_STAR] = "KEY_NUMERIC_STAR",	[KEY_NUMERIC_STAR] = "KEY_NUMERIC_STAR",
	[KEY_BACKSLASH] = "KEY_BACKSLASH",	[KEY_BACKSLASH] = "KEY_BACKSLASH",
	[KEY_SYSRQ] = "KEY_SYSRQ",	[KEY_SYSRQ] = "KEY_SYSRQ",

		[KEY_END] = "KEY_END",
	[KEY_RFKILL] = "KEY_RFKILL",	[KEY_RFKILL] = "KEY_RFKILL",
	[KEY_LEFTCTRL] = "KEY_LEFTCTRL",	[KEY_LEFTCTRL] = "KEY_LEFTCTRL",
	[KEY_KPRIGHTPAREN] = "KEY_KPRIGHTPAREN",	[KEY_KPRIGHTPAREN] = "KEY_KPRIGHTPAREN",
	[KEY_KPASTERISK] = "KEY_KPASTERISK",	[KEY_KPASTERISK] = "KEY_KPASTERISK",
	[KEY_REFRESH] = "KEY_REFRESH",	[KEY_REFRESH] = "KEY_REFRESH",
	[KEY_CLOSECD] = "KEY_CLOSECD",	[KEY_CLOSECD] = "KEY_CLOSECD",
	[KEY_RIGHTCTRL] = "KEY_RIGHTCTRL",	[KEY_RIGHTCTRL] = "KEY_RIGHTCTRL",
	[KEY_SEARCH] = "KEY_SEARCH",	[KEY_SEARCH] = "KEY_SEARCH",
	[KEY_PHONE] = "KEY_PHONE",	[KEY_PHONE] = "KEY_PHONE",
	[KEY_KBDILLUMUP] = "KEY_KBDILLUMUP",	[KEY_KBDILLUMUP] = "KEY_KBDILLUMUP",

End of changes. 2 change blocks.
	1 lines changed or deleted	1 lines changed or added

	list.h	list.h

	skipping to change at line 84	skipping to change at line 84
	/* Find the head of the list */	/* Find the head of the list */
	#define LIST_FIND_HEAD(t,name,item,head) \	#define LIST_FIND_HEAD(t,name,item,head) \
	do { \	do { \
	t *_item = (item); \	t *_item = (item); \
	assert(_item); \	assert(_item); \
	while (_item->name##_prev) \	while (_item->name##_prev) \
	_item = _item->name##_prev; \	_item = _item->name##_prev; \
	(head) = _item; \	(head) = _item; \
	} while (false)	} while (false)


	/* Find the head of the list */	/* Find the tail of the list */
	#define LIST_FIND_TAIL(t,name,item,tail) \	#define LIST_FIND_TAIL(t,name,item,tail) \
	do { \	do { \
	t *_item = (item); \	t *_item = (item); \
	assert(_item); \	assert(_item); \
	while (_item->name##_next) \	while (_item->name##_next) \
	_item = _item->name##_next; \	_item = _item->name##_next; \
	(tail) = _item; \	(tail) = _item; \
	} while (false)	} while (false)

	/* Insert an item after another one (a = where, b = what) */	/* Insert an item after another one (a = where, b = what) */

	skipping to change at line 126	skipping to change at line 126
	for ((i) = (head); (i); (i) = (i)->name##_next)	for ((i) = (head); (i); (i) = (i)->name##_next)

	#define LIST_FOREACH_SAFE(name,i,n,head) \	#define LIST_FOREACH_SAFE(name,i,n,head) \
	for ((i) = (head); (i) && (((n) = (i)->name##_next), 1); (i) = (n))	for ((i) = (head); (i) && (((n) = (i)->name##_next), 1); (i) = (n))

	#define LIST_FOREACH_BEFORE(name,i,p) \	#define LIST_FOREACH_BEFORE(name,i,p) \
	for ((i) = (p)->name##_prev; (i); (i) = (i)->name##_prev)	for ((i) = (p)->name##_prev; (i); (i) = (i)->name##_prev)

	#define LIST_FOREACH_AFTER(name,i,p) \	#define LIST_FOREACH_AFTER(name,i,p) \
	for ((i) = (p)->name##_next; (i); (i) = (i)->name##_next)	for ((i) = (p)->name##_next; (i); (i) = (i)->name##_next)


		/* Loop starting from p->next until p->prev.
		p can be adjusted meanwhile. */
		#define LIST_LOOP_BUT_ONE(name,i,head,p) \
		for ((i) = (p)->name##_next ? (p)->name##_next : (head); \
		(i) != (p); \
		(i) = (i)->name##_next ? (i)->name##_next : (head))

End of changes. 2 change blocks.
	1 lines changed or deleted	1 lines changed or added

	load-fragment.h	load-fragment.h

	skipping to change at line 58	skipping to change at line 58
	int config_parse_input(const char unit, const char filename, unsigned lin e, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);	int config_parse_input(const char unit, const char filename, unsigned lin e, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);
	int config_parse_exec_io_class(const char unit, const char filename, unsi gned line, const char section, const char lvalue, int ltype, const char * rvalue, void data, void userdata);	int config_parse_exec_io_class(const char unit, const char filename, unsi gned line, const char section, const char lvalue, int ltype, const char * rvalue, void data, void userdata);
	int config_parse_exec_io_priority(const char unit, const char filename, u nsigned line, const char section, const char lvalue, int ltype, const cha r rvalue, void data, void *userdata);	int config_parse_exec_io_priority(const char unit, const char filename, u nsigned line, const char section, const char lvalue, int ltype, const cha r rvalue, void data, void *userdata);
	int config_parse_exec_cpu_sched_policy(const char unit, const char filena me, unsigned line, const char section, const char lvalue, int ltype, cons t char rvalue, void data, void *userdata);	int config_parse_exec_cpu_sched_policy(const char unit, const char filena me, unsigned line, const char section, const char lvalue, int ltype, cons t char rvalue, void data, void *userdata);
	int config_parse_exec_cpu_sched_prio(const char unit, const char filename , unsigned line, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);	int config_parse_exec_cpu_sched_prio(const char unit, const char filename , unsigned line, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);
	int config_parse_exec_cpu_affinity(const char unit, const char filename, unsigned line, const char section, const char lvalue, int ltype, const ch ar rvalue, void data, void *userdata);	int config_parse_exec_cpu_affinity(const char unit, const char filename, unsigned line, const char section, const char lvalue, int ltype, const ch ar rvalue, void data, void *userdata);
	int config_parse_exec_capabilities(const char unit, const char filename, unsigned line, const char section, const char lvalue, int ltype, const ch ar rvalue, void data, void *userdata);	int config_parse_exec_capabilities(const char unit, const char filename, unsigned line, const char section, const char lvalue, int ltype, const ch ar rvalue, void data, void *userdata);
	int config_parse_exec_secure_bits(const char unit, const char filename, u nsigned line, const char section, const char lvalue, int ltype, const cha r rvalue, void data, void *userdata);	int config_parse_exec_secure_bits(const char unit, const char filename, u nsigned line, const char section, const char lvalue, int ltype, const cha r rvalue, void data, void *userdata);
	int config_parse_bounding_set(const char unit, const char filename, unsig ned line, const char section, const char lvalue, int ltype, const char r value, void data, void *userdata);	int config_parse_bounding_set(const char unit, const char filename, unsig ned line, const char section, const char lvalue, int ltype, const char r value, void data, void *userdata);
	int config_parse_limit(const char unit, const char filename, unsigned lin e, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);	int config_parse_limit(const char unit, const char filename, unsigned lin e, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);

	int config_parse_unit_cgroup(const char unit, const char filename, unsign ed line, const char section, const char lvalue, int ltype, const char rv alue, void data, void *userdata);
	int config_parse_sysv_priority(const char unit, const char filename, unsi gned line, const char section, const char lvalue, int ltype, const char * rvalue, void data, void userdata);	int config_parse_sysv_priority(const char unit, const char filename, unsi gned line, const char section, const char lvalue, int ltype, const char * rvalue, void data, void userdata);
	int config_parse_fsck_passno(const char unit, const char filename, unsign ed line, const char section, const char lvalue, int ltype, const char rv alue, void data, void *userdata);	int config_parse_fsck_passno(const char unit, const char filename, unsign ed line, const char section, const char lvalue, int ltype, const char rv alue, void data, void *userdata);
	int config_parse_kill_signal(const char unit, const char filename, unsign ed line, const char section, const char lvalue, int ltype, const char rv alue, void data, void *userdata);	int config_parse_kill_signal(const char unit, const char filename, unsign ed line, const char section, const char lvalue, int ltype, const char rv alue, void data, void *userdata);
	int config_parse_exec_mount_flags(const char unit, const char filename, u nsigned line, const char section, const char lvalue, int ltype, const cha r rvalue, void data, void *userdata);	int config_parse_exec_mount_flags(const char unit, const char filename, u nsigned line, const char section, const char lvalue, int ltype, const cha r rvalue, void data, void *userdata);
	int config_parse_timer(const char unit, const char filename, unsigned lin e, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);	int config_parse_timer(const char unit, const char filename, unsigned lin e, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);
	int config_parse_trigger_unit(const char unit, const char filename, unsig ned line, const char section, const char lvalue, int ltype, const char r value, void data, void *userdata);	int config_parse_trigger_unit(const char unit, const char filename, unsig ned line, const char section, const char lvalue, int ltype, const char r value, void data, void *userdata);
	int config_parse_path_spec(const char unit, const char filename, unsigned line, const char section, const char lvalue, int ltype, const char rval ue, void data, void *userdata);	int config_parse_path_spec(const char unit, const char filename, unsigned line, const char section, const char lvalue, int ltype, const char rval ue, void data, void *userdata);
	int config_parse_socket_service(const char unit, const char filename, uns igned line, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);	int config_parse_socket_service(const char unit, const char filename, uns igned line, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);
	int config_parse_service_sockets(const char unit, const char filename, un signed line, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);	int config_parse_service_sockets(const char unit, const char filename, un signed line, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);
	int config_parse_unit_env_file(const char unit, const char filename, unsi gned line, const char section, const char lvalue, int ltype, const char * rvalue, void data, void userdata);	int config_parse_unit_env_file(const char unit, const char filename, unsi gned line, const char section, const char lvalue, int ltype, const char * rvalue, void data, void userdata);
	int config_parse_ip_tos(const char unit, const char filename, unsigned li ne, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);	int config_parse_ip_tos(const char unit, const char filename, unsigned li ne, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);
	int config_parse_unit_condition_path(const char unit, const char filename , unsigned line, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);	int config_parse_unit_condition_path(const char unit, const char filename , unsigned line, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);
	int config_parse_unit_condition_string(const char unit, const char filena me, unsigned line, const char section, const char lvalue, int ltype, cons t char rvalue, void data, void *userdata);	int config_parse_unit_condition_string(const char unit, const char filena me, unsigned line, const char section, const char lvalue, int ltype, cons t char rvalue, void data, void *userdata);
	int config_parse_unit_condition_null(const char unit, const char filename , unsigned line, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);	int config_parse_unit_condition_null(const char unit, const char filename , unsigned line, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);
	int config_parse_kill_mode(const char unit, const char filename, unsigned line, const char section, const char lvalue, int ltype, const char rval ue, void data, void *userdata);	int config_parse_kill_mode(const char unit, const char filename, unsigned line, const char section, const char lvalue, int ltype, const char rval ue, void data, void *userdata);
	int config_parse_notify_access(const char unit, const char filename, unsi gned line, const char section, const char lvalue, int ltype, const char * rvalue, void data, void userdata);	int config_parse_notify_access(const char unit, const char filename, unsi gned line, const char section, const char lvalue, int ltype, const char * rvalue, void data, void userdata);
	int config_parse_start_limit_action(const char unit, const char filename, unsigned line, const char section, const char lvalue, int ltype, const c har rvalue, void data, void *userdata);	int config_parse_start_limit_action(const char unit, const char filename, unsigned line, const char section, const char lvalue, int ltype, const c har rvalue, void data, void *userdata);

	int config_parse_unit_cgroup_attr(const char unit, const char filename, u
	nsigned line, const char section, const char lvalue, int ltype, const cha
	r rvalue, void data, void *userdata);
	int config_parse_unit_cgroup_attr_pretty(const char unit, const char file
	name, unsigned line, const char section, const char lvalue, int ltype, co
	nst char rvalue, void data, void *userdata);
	int config_parse_unit_requires_mounts_for(const char unit, const char fil ename, unsigned line, const char section, const char lvalue, int ltype, c onst char rvalue, void data, void *userdata);	int config_parse_unit_requires_mounts_for(const char unit, const char fil ename, unsigned line, const char section, const char lvalue, int ltype, c onst char rvalue, void data, void *userdata);
	int config_parse_syscall_filter(const char unit, const char filename, uns igned line, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);	int config_parse_syscall_filter(const char unit, const char filename, uns igned line, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);
	int config_parse_environ(const char unit, const char filename, unsigned l ine, const char section, const char lvalue, int ltype, const char rvalue , void data, void *userdata);	int config_parse_environ(const char unit, const char filename, unsigned l ine, const char section, const char lvalue, int ltype, const char rvalue , void data, void *userdata);

		int config_parse_unit_slice(const char unit, const char filename, unsigne
		d line, const char section, const char lvalue, int ltype, const char *rva
		lue, void data, void userdata);
		int config_parse_cpu_shares(const char unit, const char filename, unsigne
		d line, const char section, const char lvalue, int ltype, const char *rva
		lue, void data, void userdata);
		int config_parse_memory_limit(const char unit, const char filename, unsig
		ned line, const char section, const char lvalue, int ltype, const char *r
		value, void data, void userdata);
		int config_parse_device_policy(const char unit, const char filename, unsi
		gned line, const char section, const char lvalue, int ltype, const char *
		rvalue, void data, void userdata);
		int config_parse_device_allow(const char unit, const char filename, unsig
		ned line, const char section, const char lvalue, int ltype, const char *r
		value, void data, void userdata);
		int config_parse_blockio_weight(const char unit, const char filename, uns
		igned line, const char section, const char lvalue, int ltype, const char
		rvalue, void data, void *userdata);
		int config_parse_blockio_bandwidth(const char unit, const char filename,
		unsigned line, const char section, const char lvalue, int ltype, const ch
		ar rvalue, void data, void *userdata);

	/* gperf prototypes */	/* gperf prototypes */
	const struct ConfigPerfItem* load_fragment_gperf_lookup(const char *key, un signed length);	const struct ConfigPerfItem* load_fragment_gperf_lookup(const char *key, un signed length);
	extern const char load_fragment_gperf_nulstr[];	extern const char load_fragment_gperf_nulstr[];

End of changes. 3 change blocks.
	7 lines changed or deleted	21 lines changed or added

	logind-session.h	logind-session.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
	Lesser General Public License for more details.	Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public License	You should have received a copy of the GNU Lesser 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/>.
	***/	***/

	typedef struct Session Session;	typedef struct Session Session;

		typedef enum KillWho KillWho;

	#include "list.h"	#include "list.h"
	#include "util.h"	#include "util.h"
	#include "logind.h"	#include "logind.h"
	#include "logind-seat.h"	#include "logind-seat.h"
	#include "logind-user.h"	#include "logind-user.h"

	typedef enum SessionState {	typedef enum SessionState {

		SESSION_OPENING, /* Session scope is being created */
	SESSION_ONLINE, /* Logged in */	SESSION_ONLINE, /* Logged in */
	SESSION_ACTIVE, /* Logged in and in the fg */	SESSION_ACTIVE, /* Logged in and in the fg */

	SESSION_CLOSING, /* Logged out, but processes still remain */	SESSION_CLOSING, /* Logged out, but scope is still there */
	_SESSION_STATE_MAX,	_SESSION_STATE_MAX,
	_SESSION_STATE_INVALID = -1	_SESSION_STATE_INVALID = -1
	} SessionState;	} SessionState;

	typedef enum SessionClass {	typedef enum SessionClass {
	SESSION_USER,	SESSION_USER,
	SESSION_GREETER,	SESSION_GREETER,
	SESSION_LOCK_SCREEN,	SESSION_LOCK_SCREEN,
	SESSION_BACKGROUND,	SESSION_BACKGROUND,
	_SESSION_CLASS_MAX,	_SESSION_CLASS_MAX,

	skipping to change at line 57	skipping to change at line 59
	} SessionClass;	} SessionClass;

	typedef enum SessionType {	typedef enum SessionType {
	SESSION_UNSPECIFIED,	SESSION_UNSPECIFIED,
	SESSION_TTY,	SESSION_TTY,
	SESSION_X11,	SESSION_X11,
	_SESSION_TYPE_MAX,	_SESSION_TYPE_MAX,
	_SESSION_TYPE_INVALID = -1	_SESSION_TYPE_INVALID = -1
	} SessionType;	} SessionType;


	typedef enum KillWho {	enum KillWho {
	KILL_LEADER,	KILL_LEADER,
	KILL_ALL,	KILL_ALL,
	_KILL_WHO_MAX,	_KILL_WHO_MAX,
	_KILL_WHO_INVALID = -1	_KILL_WHO_INVALID = -1

	} KillWho;	};

	struct Session {	struct Session {
	Manager *manager;	Manager *manager;

	char *id;	char *id;
	SessionType type;	SessionType type;
	SessionClass class;	SessionClass class;

	char *state_file;	char *state_file;

	User *user;	User *user;

	dual_timestamp timestamp;	dual_timestamp timestamp;

	char *tty;	char *tty;
	char *display;	char *display;

	bool remote;	bool remote;
	char *remote_user;	char *remote_user;
	char *remote_host;	char *remote_host;


	char *service;	char *service;


		char *scope;
		char *scope_job;

	int vtnr;	int vtnr;
	Seat *seat;	Seat *seat;

	pid_t leader;	pid_t leader;
	uint32_t audit_id;	uint32_t audit_id;

	int fifo_fd;	int fifo_fd;
	char *fifo_path;	char *fifo_path;


	char *cgroup_path;
	char controllers, reset_controllers;

	bool idle_hint;	bool idle_hint;
	dual_timestamp idle_hint_timestamp;	dual_timestamp idle_hint_timestamp;


	bool kill_processes;
	bool in_gc_queue:1;	bool in_gc_queue:1;
	bool started:1;	bool started:1;


		DBusMessage *create_message;

	LIST_FIELDS(Session, sessions_by_user);	LIST_FIELDS(Session, sessions_by_user);
	LIST_FIELDS(Session, sessions_by_seat);	LIST_FIELDS(Session, sessions_by_seat);

	LIST_FIELDS(Session, gc_queue);	LIST_FIELDS(Session, gc_queue);
	};	};


	Session session_new(Manager m, User u, const char id);	Session session_new(Manager m, const char *id);
	void session_free(Session *s);	void session_free(Session *s);

		void session_set_user(Session s, User u);
	int session_check_gc(Session *s, bool drop_not_started);	int session_check_gc(Session *s, bool drop_not_started);
	void session_add_to_gc_queue(Session *s);	void session_add_to_gc_queue(Session *s);
	int session_activate(Session *s);	int session_activate(Session *s);
	bool session_is_active(Session *s);	bool session_is_active(Session *s);
	int session_get_idle_hint(Session s, dual_timestamp t);	int session_get_idle_hint(Session s, dual_timestamp t);
	void session_set_idle_hint(Session *s, bool b);	void session_set_idle_hint(Session *s, bool b);
	int session_create_fifo(Session *s);	int session_create_fifo(Session *s);
	void session_remove_fifo(Session *s);	void session_remove_fifo(Session *s);
	int session_start(Session *s);	int session_start(Session *s);
	int session_stop(Session *s);	int session_stop(Session *s);

	skipping to change at line 138	skipping to change at line 141

	SessionState session_get_state(Session *u);	SessionState session_get_state(Session *u);

	extern const DBusObjectPathVTable bus_session_vtable;	extern const DBusObjectPathVTable bus_session_vtable;

	int session_send_signal(Session *s, bool new_session);	int session_send_signal(Session *s, bool new_session);
	int session_send_changed(Session s, const char properties);	int session_send_changed(Session s, const char properties);
	int session_send_lock(Session *s, bool lock);	int session_send_lock(Session *s, bool lock);
	int session_send_lock_all(Manager *m, bool lock);	int session_send_lock_all(Manager *m, bool lock);


		int session_send_create_reply(Session s, DBusError error);

	const char* session_state_to_string(SessionState t) _const_;	const char* session_state_to_string(SessionState t) _const_;
	SessionState session_state_from_string(const char *s) _pure_;	SessionState session_state_from_string(const char *s) _pure_;

	const char* session_type_to_string(SessionType t) _const_;	const char* session_type_to_string(SessionType t) _const_;
	SessionType session_type_from_string(const char *s) _pure_;	SessionType session_type_from_string(const char *s) _pure_;

	const char* session_class_to_string(SessionClass t) _const_;	const char* session_class_to_string(SessionClass t) _const_;
	SessionClass session_class_from_string(const char *s) _pure_;	SessionClass session_class_from_string(const char *s) _pure_;

	const char *kill_who_to_string(KillWho k) _const_;	const char *kill_who_to_string(KillWho k) _const_;

End of changes. 13 change blocks.
	9 lines changed or deleted	14 lines changed or added

	logind-user.h	logind-user.h

	skipping to change at line 33	skipping to change at line 33

	typedef struct User User;	typedef struct User User;

	#include "list.h"	#include "list.h"
	#include "util.h"	#include "util.h"
	#include "logind.h"	#include "logind.h"
	#include "logind-session.h"	#include "logind-session.h"

	typedef enum UserState {	typedef enum UserState {
	USER_OFFLINE, /* Not logged in at all */	USER_OFFLINE, /* Not logged in at all */

		USER_OPENING, /* Is logging in */
	USER_LINGERING, /* Lingering has been enabled by the admin for thi s user */	USER_LINGERING, /* Lingering has been enabled by the admin for thi s user */
	USER_ONLINE, /* User logged in */	USER_ONLINE, /* User logged in */
	USER_ACTIVE, /* User logged in and has a session in the fg */	USER_ACTIVE, /* User logged in and has a session in the fg */
	USER_CLOSING, /* User logged out, but processes still remain and lingering is not enabled */	USER_CLOSING, /* User logged out, but processes still remain and lingering is not enabled */
	_USER_STATE_MAX,	_USER_STATE_MAX,
	_USER_STATE_INVALID = -1	_USER_STATE_INVALID = -1
	} UserState;	} UserState;

	struct User {	struct User {
	Manager *manager;	Manager *manager;

	uid_t uid;	uid_t uid;
	gid_t gid;	gid_t gid;
	char *name;	char *name;

	char *state_file;	char *state_file;
	char *runtime_path;	char *runtime_path;


	char *service;	char *service;

	char *cgroup_path;	char *slice;

		char *service_job;
		char *slice_job;

	Session *display;	Session *display;

	dual_timestamp timestamp;	dual_timestamp timestamp;

	bool in_gc_queue:1;	bool in_gc_queue:1;
	bool started:1;	bool started:1;

		bool slice_created:1;
		bool service_created:1;

	LIST_HEAD(Session, sessions);	LIST_HEAD(Session, sessions);
	LIST_FIELDS(User, gc_queue);	LIST_FIELDS(User, gc_queue);
	};	};

	User* user_new(Manager m, uid_t uid, gid_t gid, const char name);	User* user_new(Manager m, uid_t uid, gid_t gid, const char name);
	void user_free(User *u);	void user_free(User *u);
	int user_check_gc(User *u, bool drop_not_started);	int user_check_gc(User *u, bool drop_not_started);
	void user_add_to_gc_queue(User *u);	void user_add_to_gc_queue(User *u);
	int user_start(User *u);	int user_start(User *u);

End of changes. 4 change blocks.
	1 lines changed or deleted	8 lines changed or added

	logind.h	logind.h

	skipping to change at line 77	skipping to change at line 77
	int bus_fd;	int bus_fd;
	int epoll_fd;	int epoll_fd;

	unsigned n_autovts;	unsigned n_autovts;

	unsigned reserve_vt;	unsigned reserve_vt;
	int reserve_vt_fd;	int reserve_vt_fd;

	Seat *vtconsole;	Seat *vtconsole;


	char *cgroup_path;
	char controllers, reset_controllers;

	char kill_only_users, kill_exclude_users;	char kill_only_users, kill_exclude_users;


	bool kill_user_processes;	bool kill_user_processes;

	unsigned long session_counter;	unsigned long session_counter;
	unsigned long inhibit_counter;	unsigned long inhibit_counter;


	Hashmap *session_cgroups;	Hashmap *session_units;
	Hashmap *user_cgroups;	Hashmap *user_units;

	Hashmap *session_fds;	Hashmap *session_fds;
	Hashmap *inhibitor_fds;	Hashmap *inhibitor_fds;
	Hashmap *button_fds;	Hashmap *button_fds;

	usec_t inhibit_delay_max;	usec_t inhibit_delay_max;

	/* If an action is currently being executed or is delayed,	/* If an action is currently being executed or is delayed,
	* this is != 0 and encodes what is being done */	* this is != 0 and encodes what is being done */
	InhibitWhat action_what;	InhibitWhat action_what;

	skipping to change at line 142	skipping to change at line 138
	FD_IDLE_ACTION,	FD_IDLE_ACTION,
	FD_OTHER_BASE	FD_OTHER_BASE
	};	};

	Manager *manager_new(void);	Manager *manager_new(void);
	void manager_free(Manager *m);	void manager_free(Manager *m);

	int manager_add_device(Manager m, const char sysfs, Device **_device);	int manager_add_device(Manager m, const char sysfs, Device **_device);
	int manager_add_button(Manager m, const char name, Button **_button);	int manager_add_button(Manager m, const char name, Button **_button);
	int manager_add_seat(Manager m, const char id, Seat **_seat);	int manager_add_seat(Manager m, const char id, Seat **_seat);

	int manager_add_session(Manager m, User u, const char id, Session *_ses sion);	int manager_add_session(Manager m, const char id, Session **_session);
	int manager_add_user(Manager m, uid_t uid, gid_t gid, const char name, Us er **_user);	int manager_add_user(Manager m, uid_t uid, gid_t gid, const char name, Us er **_user);
	int manager_add_user_by_name(Manager m, const char name, User **_user);	int manager_add_user_by_name(Manager m, const char name, User **_user);
	int manager_add_user_by_uid(Manager m, uid_t uid, User *_user);	int manager_add_user_by_uid(Manager m, uid_t uid, User *_user);
	int manager_add_inhibitor(Manager m, const char id, Inhibitor **_inhibito r);	int manager_add_inhibitor(Manager m, const char id, Inhibitor **_inhibito r);

	int manager_process_seat_device(Manager m, struct udev_device d);	int manager_process_seat_device(Manager m, struct udev_device d);
	int manager_process_button_device(Manager m, struct udev_device d);	int manager_process_button_device(Manager m, struct udev_device d);

	int manager_dispatch_seat_udev(Manager *m);	int manager_dispatch_seat_udev(Manager *m);
	int manager_dispatch_vcsa_udev(Manager *m);	int manager_dispatch_vcsa_udev(Manager *m);

	skipping to change at line 168	skipping to change at line 164
	int manager_enumerate_buttons(Manager *m);	int manager_enumerate_buttons(Manager *m);
	int manager_enumerate_seats(Manager *m);	int manager_enumerate_seats(Manager *m);
	int manager_enumerate_sessions(Manager *m);	int manager_enumerate_sessions(Manager *m);
	int manager_enumerate_users(Manager *m);	int manager_enumerate_users(Manager *m);
	int manager_enumerate_inhibitors(Manager *m);	int manager_enumerate_inhibitors(Manager *m);

	int manager_startup(Manager *m);	int manager_startup(Manager *m);
	int manager_run(Manager *m);	int manager_run(Manager *m);
	int manager_spawn_autovt(Manager *m, int vtnr);	int manager_spawn_autovt(Manager *m, int vtnr);


	void manager_cgroup_notify_empty(Manager m, const char cgroup);

	void manager_gc(Manager *m, bool drop_not_started);	void manager_gc(Manager *m, bool drop_not_started);

	int manager_get_idle_hint(Manager m, dual_timestamp t);	int manager_get_idle_hint(Manager m, dual_timestamp t);


	int manager_get_user_by_cgroup(Manager m, const char cgroup, User **user)	int manager_get_user_by_pid(Manager m, pid_t pid, User *user);
	;
	int manager_get_session_by_cgroup(Manager m, const char cgroup, Session *
	*session);
	int manager_get_session_by_pid(Manager m, pid_t pid, Session *session);	int manager_get_session_by_pid(Manager m, pid_t pid, Session *session);

	extern const DBusObjectPathVTable bus_manager_vtable;	extern const DBusObjectPathVTable bus_manager_vtable;

	DBusHandlerResult bus_message_filter(DBusConnection c, DBusMessage messag e, void *userdata);	DBusHandlerResult bus_message_filter(DBusConnection c, DBusMessage messag e, void *userdata);

	int bus_manager_shutdown_or_sleep_now_or_later(Manager m, const char unit _name, InhibitWhat w, DBusError *error);	int bus_manager_shutdown_or_sleep_now_or_later(Manager m, const char unit _name, InhibitWhat w, DBusError *error);

	int manager_send_changed(Manager manager, const char properties);	int manager_send_changed(Manager manager, const char properties);

	int manager_dispatch_delayed(Manager *manager);	int manager_dispatch_delayed(Manager *manager);


		int manager_start_scope(Manager manager, const char scope, pid_t pid, con
		st char slice, const char description, DBusError error, char *job);
		int manager_start_unit(Manager manager, const char unit, DBusError *error
		, char **job);
		int manager_stop_unit(Manager manager, const char unit, DBusError *error,
		char **job);
		int manager_kill_unit(Manager manager, const char unit, KillWho who, int
		signo, DBusError *error);
		int manager_unit_is_active(Manager manager, const char unit);

	/* gperf lookup function */	/* gperf lookup function */
	const struct ConfigPerfItem* logind_gperf_lookup(const char *key, unsigned length);	const struct ConfigPerfItem* logind_gperf_lookup(const char *key, unsigned length);

End of changes. 7 change blocks.
	13 lines changed or deleted	14 lines changed or added

	logs-show.h	logs-show.h

	skipping to change at line 40	skipping to change at line 40
	#include "util.h"	#include "util.h"
	#include "output-mode.h"	#include "output-mode.h"

	int output_journal(	int output_journal(
	FILE *f,	FILE *f,
	sd_journal *j,	sd_journal *j,
	OutputMode mode,	OutputMode mode,
	unsigned n_columns,	unsigned n_columns,
	OutputFlags flags);	OutputFlags flags);


		int add_match_this_boot(sd_journal *j);

	int add_matches_for_unit(	int add_matches_for_unit(
	sd_journal *j,	sd_journal *j,
	const char *unit);	const char *unit);

	int add_matches_for_user_unit(	int add_matches_for_user_unit(
	sd_journal *j,	sd_journal *j,
	const char *unit,	const char *unit,
	uid_t uid);	uid_t uid);

	int show_journal_by_unit(	int show_journal_by_unit(

End of changes. 1 change blocks.
	0 lines changed or deleted	2 lines changed or added

	macro.h	macro.h

	skipping to change at line 162	skipping to change at line 162
	#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)
	#endif	#endif


		#define PTR_TO_INT(p) ((int) ((intptr_t) (p)))
		#define INT_TO_PTR(u) ((void *) ((intptr_t) (u)))
	#define PTR_TO_UINT(p) ((unsigned int) ((uintptr_t) (p)))	#define PTR_TO_UINT(p) ((unsigned int) ((uintptr_t) (p)))

	#define UINT_TO_PTR(u) ((void*) ((uintptr_t) (u)))	#define UINT_TO_PTR(u) ((void *) ((uintptr_t) (u)))

	#define PTR_TO_UINT32(p) ((uint32_t) ((uintptr_t) (p)))
	#define UINT32_TO_PTR(u) ((void*) ((uintptr_t) (u)))


		#define PTR_TO_LONG(p) ((long) ((intptr_t) (p)))
		#define LONG_TO_PTR(u) ((void *) ((intptr_t) (u)))
	#define PTR_TO_ULONG(p) ((unsigned long) ((uintptr_t) (p)))	#define PTR_TO_ULONG(p) ((unsigned long) ((uintptr_t) (p)))

	#define ULONG_TO_PTR(u) ((void*) ((uintptr_t) (u)))	#define ULONG_TO_PTR(u) ((void *) ((uintptr_t) (u)))

	#define PTR_TO_INT(p) ((int) ((intptr_t) (p)))
	#define INT_TO_PTR(u) ((void*) ((intptr_t) (u)))


	#define TO_INT32(p) ((int32_t) ((intptr_t) (p)))	#define PTR_TO_INT32(p) ((int32_t) ((intptr_t) (p)))
	#define INT32_TO_PTR(u) ((void*) ((intptr_t) (u)))	#define INT32_TO_PTR(u) ((void *) ((intptr_t) (u)))
		#define PTR_TO_UINT32(p) ((uint32_t) ((uintptr_t) (p)))
		#define UINT32_TO_PTR(u) ((void *) ((uintptr_t) (u)))


	#define PTR_TO_LONG(p) ((long) ((intptr_t) (p)))	#define PTR_TO_INT64(p) ((int64_t) ((intptr_t) (p)))
	#define LONG_TO_PTR(u) ((void*) ((intptr_t) (u)))	#define INT64_TO_PTR(u) ((void *) ((intptr_t) (u)))
		#define PTR_TO_UINT64(p) ((uint64_t) ((uintptr_t) (p)))
		#define UINT64_TO_PTR(u) ((void *) ((uintptr_t) (u)))

	#define memzero(x,l) (memset((x), 0, (l)))	#define memzero(x,l) (memset((x), 0, (l)))
	#define zero(x) (memzero(&(x), sizeof(x)))	#define zero(x) (memzero(&(x), sizeof(x)))

	#define CHAR_TO_STR(x) ((char[2]) { x, 0 })	#define CHAR_TO_STR(x) ((char[2]) { x, 0 })

	#define char_array_0(x) x[sizeof(x)-1] = 0;	#define char_array_0(x) x[sizeof(x)-1] = 0;


		#define hasprefix(s, prefix) (memcmp(s, prefix, strlen(prefix)) == 0)

	#define IOVEC_SET_STRING(i, s) \	#define IOVEC_SET_STRING(i, s) \
	do { \	do { \
	struct iovec *_i = &(i); \	struct iovec *_i = &(i); \
	char _s = (char )(s); \	char _s = (char )(s); \
	_i->iov_base = _s; \	_i->iov_base = _s; \
	_i->iov_len = strlen(_s); \	_i->iov_len = strlen(_s); \
	} while(false)	} while(false)

	static inline size_t IOVEC_TOTAL_SIZE(const struct iovec *i, unsigned n) {	static inline size_t IOVEC_TOTAL_SIZE(const struct iovec *i, unsigned n) {
	unsigned j;	unsigned j;

	skipping to change at line 284	skipping to change at line 288
	/* Returns the number of chars needed to format variables of the	/* Returns the number of chars needed to format variables of the
	* specified type as a decimal string. Adds in extra space for a	* specified type as a decimal string. Adds in extra space for a
	* negative '-' prefix. */	* negative '-' prefix. */

	#define DECIMAL_STR_MAX(type) \	#define DECIMAL_STR_MAX(type) \
	(1+(sizeof(type) <= 1 ? 3 : \	(1+(sizeof(type) <= 1 ? 3 : \
	sizeof(type) <= 2 ? 5 : \	sizeof(type) <= 2 ? 5 : \
	sizeof(type) <= 4 ? 10 : \	sizeof(type) <= 4 ? 10 : \
	sizeof(type) <= 8 ? 20 : sizeof(int[-2*(sizeof(type) > 8)])))	sizeof(type) <= 8 ? 20 : sizeof(int[-2*(sizeof(type) > 8)])))


		#define SET_FLAG(v, flag, b) \
		(v) = (b) ? ((v) \| (flag)) : ((v) & ~(flag))

	#include "log.h"	#include "log.h"

End of changes. 8 change blocks.
	12 lines changed or deleted	19 lines changed or added

	manager.h	manager.h

	skipping to change at line 30	skipping to change at line 30
	You should have received a copy of the GNU Lesser General Public License	You should have received a copy of the GNU Lesser 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 <inttypes.h>	#include <inttypes.h>
	#include <stdio.h>	#include <stdio.h>
	#include <dbus/dbus.h>	#include <dbus/dbus.h>

	#include "fdset.h"	#include "fdset.h"

		#include "cgroup-util.h"

	/* Enforce upper limit how many names we allow */	/* Enforce upper limit how many names we allow */
	#define MANAGER_MAX_NAMES 131072 /* 128K */	#define MANAGER_MAX_NAMES 131072 /* 128K */

	typedef struct Manager Manager;	typedef struct Manager Manager;
	typedef enum WatchType WatchType;	typedef enum WatchType WatchType;
	typedef struct Watch Watch;	typedef struct Watch Watch;

	typedef enum ManagerExitCode {	typedef enum ManagerExitCode {
	MANAGER_RUNNING,	MANAGER_RUNNING,

	skipping to change at line 89	skipping to change at line 90
	};	};

	#include "unit.h"	#include "unit.h"
	#include "job.h"	#include "job.h"
	#include "hashmap.h"	#include "hashmap.h"
	#include "list.h"	#include "list.h"
	#include "set.h"	#include "set.h"
	#include "dbus.h"	#include "dbus.h"
	#include "path-lookup.h"	#include "path-lookup.h"
	#include "execute.h"	#include "execute.h"

		#include "unit-name.h"

	struct Manager {	struct Manager {
	/* 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 */


	skipping to change at line 125	skipping to change at line 127
	* D-Bus change signals. */	* D-Bus change signals. */
	LIST_HEAD(Unit, 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(Unit, cleanup_queue);	LIST_HEAD(Unit, cleanup_queue);

	/* Units to check when doing GC */	/* Units to check when doing GC */
	LIST_HEAD(Unit, gc_queue);	LIST_HEAD(Unit, gc_queue);


		/* Units that should be realized */
		LIST_HEAD(Unit, cgroup_queue);

	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;
	Watch signal_watch;	Watch signal_watch;
	Watch time_change_watch;	Watch time_change_watch;
	Watch jobs_in_progress_watch;	Watch jobs_in_progress_watch;

	int epoll_fd;	int epoll_fd;

	unsigned n_snapshots;	unsigned n_snapshots;

	LookupPaths lookup_paths;	LookupPaths lookup_paths;
	Set *unit_path_cache;	Set *unit_path_cache;

	char **environment;	char **environment;

	char **default_controllers;

	usec_t runtime_watchdog;	usec_t runtime_watchdog;
	usec_t shutdown_watchdog;	usec_t shutdown_watchdog;

	dual_timestamp firmware_timestamp;	dual_timestamp firmware_timestamp;
	dual_timestamp loader_timestamp;	dual_timestamp loader_timestamp;
	dual_timestamp kernel_timestamp;	dual_timestamp kernel_timestamp;
	dual_timestamp initrd_timestamp;	dual_timestamp initrd_timestamp;
	dual_timestamp userspace_timestamp;	dual_timestamp userspace_timestamp;
	dual_timestamp finish_timestamp;	dual_timestamp finish_timestamp;

		dual_timestamp generators_start_timestamp;
		dual_timestamp generators_finish_timestamp;
		dual_timestamp unitsload_start_timestamp;
		dual_timestamp unitsload_finish_timestamp;

	char *generator_unit_path;	char *generator_unit_path;
	char *generator_unit_path_early;	char *generator_unit_path_early;
	char *generator_unit_path_late;	char *generator_unit_path_late;

	/* Data specific to the device subsystem */	/* Data specific to the device subsystem */
	struct udev* udev;	struct udev* udev;
	struct udev_monitor* udev_monitor;	struct udev_monitor* udev_monitor;
	Watch udev_watch;	Watch udev_watch;
	Hashmap *devices_by_sysfs;	Hashmap *devices_by_sysfs;

	skipping to change at line 197	skipping to change at line 205
	int32_t conn_data_slot;	int32_t conn_data_slot;
	int32_t subscribed_data_slot;	int32_t subscribed_data_slot;

	uint32_t current_job_id;	uint32_t current_job_id;
	uint32_t default_unit_job_id;	uint32_t default_unit_job_id;

	/* Data specific to the Automount subsystem */	/* Data specific to the Automount subsystem */
	int dev_autofs_fd;	int dev_autofs_fd;

	/* Data specific to the cgroup subsystem */	/* Data specific to the cgroup subsystem */

	Hashmap cgroup_bondings; / path string => CGroupBonding object 1:	Hashmap *cgroup_unit;
	n */	CGroupControllerMask cgroup_supported;
	char *cgroup_hierarchy;	char *cgroup_root;


	usec_t gc_queue_timestamp;
	int gc_marker;	int gc_marker;
	unsigned n_in_gc_queue;	unsigned n_in_gc_queue;

	/* Make sure the user cannot accidentally unmount our cgroup	/* Make sure the user cannot accidentally unmount our cgroup
	* file system */	* file system */
	int pin_cgroupfs_fd;	int pin_cgroupfs_fd;

	/* Flags */	/* Flags */
	SystemdRunningAs running_as;	SystemdRunningAs running_as;
	ManagerExitCode exit_code:5;	ManagerExitCode exit_code:5;

	skipping to change at line 271	skipping to change at line 279

	void manager_dump_units(Manager s, FILE f, const char *prefix);	void manager_dump_units(Manager s, FILE f, const char *prefix);
	void manager_dump_jobs(Manager s, FILE f, const char *prefix);	void manager_dump_jobs(Manager s, FILE f, const char *prefix);

	void manager_clear_jobs(Manager *m);	void manager_clear_jobs(Manager *m);

	unsigned manager_dispatch_load_queue(Manager *m);	unsigned manager_dispatch_load_queue(Manager *m);
	unsigned manager_dispatch_run_queue(Manager *m);	unsigned manager_dispatch_run_queue(Manager *m);
	unsigned manager_dispatch_dbus_queue(Manager *m);	unsigned manager_dispatch_dbus_queue(Manager *m);


	int manager_set_default_controllers(Manager m, char *controllers);	int manager_set_default_environment(Manager m, char *environment);
	int manager_set_default_rlimits(Manager m, struct rlimit *default_rlimit) ;	int manager_set_default_rlimits(Manager m, struct rlimit *default_rlimit) ;

	int manager_loop(Manager *m);	int manager_loop(Manager *m);

	void manager_dispatch_bus_name_owner_changed(Manager m, const char name, const char* old_owner, const char *new_owner);	void manager_dispatch_bus_name_owner_changed(Manager m, const char name, const char* old_owner, const char *new_owner);
	void manager_dispatch_bus_query_pid_done(Manager m, const char name, pid_ t pid);	void manager_dispatch_bus_query_pid_done(Manager m, const char name, pid_ t pid);

	int manager_open_serialization(Manager m, FILE *_f);	int manager_open_serialization(Manager m, FILE *_f);

	int manager_serialize(Manager m, FILE f, FDSet *fds, bool switching_root) ;	int manager_serialize(Manager m, FILE f, FDSet *fds, bool switching_root) ;

End of changes. 8 change blocks.
	6 lines changed or deleted	13 lines changed or added

	missing.h	missing.h

	skipping to change at line 141	skipping to change at line 141

	#ifndef HAVE_FANOTIFY_INIT	#ifndef HAVE_FANOTIFY_INIT
	static inline int fanotify_init(unsigned int flags, unsigned int event_f_fl ags) {	static inline int fanotify_init(unsigned int flags, unsigned int event_f_fl ags) {
	return syscall(__NR_fanotify_init, flags, event_f_flags);	return syscall(__NR_fanotify_init, flags, event_f_flags);
	}	}
	#endif	#endif

	#ifndef HAVE_FANOTIFY_MARK	#ifndef HAVE_FANOTIFY_MARK
	static inline int fanotify_mark(int fanotify_fd, unsigned int flags, uint64 _t mask,	static inline int fanotify_mark(int fanotify_fd, unsigned int flags, uint64 _t mask,
	int dfd, const char *pathname) {	int dfd, const char *pathname) {

	#if defined _MIPS_SIM && _MIPS_SIM == _MIPS_SIM_ABI32 \|\| defined __powerpc_	#if defined _MIPS_SIM && _MIPS_SIM == _MIPS_SIM_ABI32 \|\| defined __powerpc_
	_ && !defined __powerpc64__	_ && !defined __powerpc64__ \
		\|\| defined __arm__ && !defined __aarch64__
	union {	union {
	uint64_t _64;	uint64_t _64;
	uint32_t _32[2];	uint32_t _32[2];
	} _mask;	} _mask;
	_mask._64 = mask;	_mask._64 = mask;

	return syscall(__NR_fanotify_mark, fanotify_fd, flags,	return syscall(__NR_fanotify_mark, fanotify_fd, flags,
	_mask._32[0], _mask._32[1], dfd, pathname);	_mask._32[0], _mask._32[1], dfd, pathname);
	#else	#else
	return syscall(__NR_fanotify_mark, fanotify_fd, flags, mask, dfd, p athname);	return syscall(__NR_fanotify_mark, fanotify_fd, flags, mask, dfd, p athname);

End of changes. 1 change blocks.
	2 lines changed or deleted	3 lines changed or added

	mount.h	mount.h

	skipping to change at line 28	skipping to change at line 28
	Lesser General Public License for more details.	Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public License	You should have received a copy of the GNU Lesser 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/>.
	***/	***/

	typedef struct Mount Mount;	typedef struct Mount Mount;

	#include "unit.h"	#include "unit.h"
	#include "kill.h"	#include "kill.h"

		#include "execute.h"
		#include "cgroup.h"

	typedef enum MountState {	typedef enum MountState {
	MOUNT_DEAD,	MOUNT_DEAD,
	MOUNT_MOUNTING, /* /bin/mount is running, but the mou nt is not done yet. */	MOUNT_MOUNTING, /* /bin/mount is running, but the mou nt is not done yet. */
	MOUNT_MOUNTING_DONE, /* /bin/mount is running, and the mou nt is done. */	MOUNT_MOUNTING_DONE, /* /bin/mount is running, and the mou nt is done. */
	MOUNT_MOUNTED,	MOUNT_MOUNTED,
	MOUNT_REMOUNTING,	MOUNT_REMOUNTING,
	MOUNT_UNMOUNTING,	MOUNT_UNMOUNTING,
	MOUNT_MOUNTING_SIGTERM,	MOUNT_MOUNTING_SIGTERM,
	MOUNT_MOUNTING_SIGKILL,	MOUNT_MOUNTING_SIGKILL,

	skipping to change at line 98	skipping to change at line 100
	bool just_changed:1;	bool just_changed:1;

	MountResult result;	MountResult result;
	MountResult reload_result;	MountResult reload_result;

	mode_t directory_mode;	mode_t directory_mode;

	usec_t timeout_usec;	usec_t timeout_usec;

	ExecCommand exec_command[_MOUNT_EXEC_COMMAND_MAX];	ExecCommand exec_command[_MOUNT_EXEC_COMMAND_MAX];


	ExecContext exec_context;	ExecContext exec_context;
	KillContext kill_context;	KillContext kill_context;

		CGroupContext cgroup_context;

	MountState state, deserialized_state;	MountState state, deserialized_state;

	ExecCommand* control_command;	ExecCommand* control_command;
	MountExecCommand control_command_id;	MountExecCommand control_command_id;
	pid_t control_pid;	pid_t control_pid;

	Watch timer_watch;	Watch timer_watch;
	};	};


End of changes. 3 change blocks.
	0 lines changed or deleted	4 lines changed or added

	pyutil.h	pyutil.h

	skipping to change at line 31	skipping to change at line 31
	along with systemd; If not, see <http://www.gnu.org/licenses/>.	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	***/	***/

	#ifndef Py_TYPE	#ifndef Py_TYPE
	/* avoid duplication warnings from errors in Python 2.7 headers */	/* avoid duplication warnings from errors in Python 2.7 headers */
	# include <Python.h>	# include <Python.h>
	#endif	#endif

	void cleanup_Py_DECREFp(PyObject **p);	void cleanup_Py_DECREFp(PyObject **p);
	PyObject* absolute_timeout(uint64_t t);	PyObject* absolute_timeout(uint64_t t);

		int set_error(int r, const char* path, const char* invalid_message);

	#define _cleanup_Py_DECREF_ __attribute__((cleanup(cleanup_Py_DECREFp)))	#define _cleanup_Py_DECREF_ __attribute__((cleanup(cleanup_Py_DECREFp)))

	#if PY_MAJOR_VERSION >=3	#if PY_MAJOR_VERSION >=3
	# define unicode_FromStringAndSize PyUnicode_FromStringAndSize	# define unicode_FromStringAndSize PyUnicode_FromStringAndSize
	# define unicode_FromString PyUnicode_FromString	# define unicode_FromString PyUnicode_FromString
	# define long_FromLong PyLong_FromLong	# define long_FromLong PyLong_FromLong
	# define long_FromSize_t PyLong_FromSize_t	# define long_FromSize_t PyLong_FromSize_t
	# define long_Check PyLong_Check	# define long_Check PyLong_Check
	# define long_AsLong PyLong_AsLong	# define long_AsLong PyLong_AsLong

End of changes. 1 change blocks.
	0 lines changed or deleted	1 lines changed or added

	sd-bus.h	sd-bus.h

	skipping to change at line 30	skipping to change at line 30

	You should have received a copy of the GNU Lesser General Public License	You should have received a copy of the GNU Lesser 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 <sys/types.h>	#include <sys/types.h>

	#include <sd-id128.h>	#include <sd-id128.h>
	#include "sd-bus-protocol.h"	#include "sd-bus-protocol.h"

		#include "sd-memfd.h"

	#ifdef __cplusplus	#ifdef __cplusplus
	extern "C" {	extern "C" {
	#endif	#endif

	#ifndef _sd_printf_attr_	#ifndef _sd_printf_attr_
	# if __GNUC__ >= 4	# if __GNUC__ >= 4
	# define _sd_printf_attr_(a,b) __attribute__ ((format (printf, a, b)))	# define _sd_printf_attr_(a,b) __attribute__ ((format (printf, a, b)))
	# else	# else
	# define _sd_printf_attr_(a,b)	# define _sd_printf_attr_(a,b)
	# endif	# endif
	#endif	#endif


	/* TODO:
	* - add page donation logic
	* - api for appending/reading fixed arrays
	* - merge busctl into systemctl or so?
	* - default policy (allow uid == 0 and our own uid)
	*
	* - enforce alignment of pointers passed in
	* - negotiation for attach attributes
	*
	* - for kernel and unix transports allow setting the unix user/access mode
	for the node
	*/

	typedef struct sd_bus sd_bus;	typedef struct sd_bus sd_bus;
	typedef struct sd_bus_message sd_bus_message;	typedef struct sd_bus_message sd_bus_message;

	typedef struct {	typedef struct {
	const char *name;	const char *name;
	const char *message;	const char *message;
	int need_free;	int need_free;
	} sd_bus_error;	} sd_bus_error;


	typedef int (sd_bus_message_handler_t)(sd_bus bus, int ret, sd_bus_messag e m, void userdata);	typedef int (sd_bus_message_handler_t)(sd_bus bus, sd_bus_message m, voi d userdata);

	/* Connections */	/* Connections */

	int sd_bus_open_system(sd_bus **ret);	int sd_bus_open_system(sd_bus **ret);
	int sd_bus_open_user(sd_bus **ret);	int sd_bus_open_user(sd_bus **ret);

	int sd_bus_new(sd_bus **ret);	int sd_bus_new(sd_bus **ret);
	int sd_bus_set_address(sd_bus bus, const char address);	int sd_bus_set_address(sd_bus bus, const char address);
	int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd);	int sd_bus_set_fd(sd_bus *bus, int input_fd, int output_fd);
	int sd_bus_set_exec(sd_bus bus, const char path, char *const argv[]);	int sd_bus_set_exec(sd_bus bus, const char path, char *const argv[]);
	int sd_bus_set_bus_client(sd_bus *bus, int b);	int sd_bus_set_bus_client(sd_bus *bus, int b);
	int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id);	int sd_bus_set_server(sd_bus *bus, int b, sd_id128_t server_id);
	int sd_bus_set_anonymous(sd_bus *bus, int b);	int sd_bus_set_anonymous(sd_bus *bus, int b);

	int sd_bus_set_negotiate_fds(sd_bus *bus, int b);	int sd_bus_negotiate_fds(sd_bus *bus, int b);
		int sd_bus_negotiate_attach_comm(sd_bus *bus, int b);
		int sd_bus_negotiate_attach_exe(sd_bus *bus, int b);
		int sd_bus_negotiate_attach_cmdline(sd_bus *bus, int b);
		int sd_bus_negotiate_attach_cgroup(sd_bus *bus, int b);
		int sd_bus_negotiate_attach_caps(sd_bus *bus, int b);
		int sd_bus_negotiate_attach_selinux_context(sd_bus *bus, int b);
		int sd_bus_negotiate_attach_audit(sd_bus *bus, int b);
	int sd_bus_start(sd_bus *ret);	int sd_bus_start(sd_bus *ret);

	void sd_bus_close(sd_bus *bus);	void sd_bus_close(sd_bus *bus);

	sd_bus sd_bus_ref(sd_bus bus);	sd_bus sd_bus_ref(sd_bus bus);
	sd_bus sd_bus_unref(sd_bus bus);	sd_bus sd_bus_unref(sd_bus bus);

	int sd_bus_is_open(sd_bus *bus);	int sd_bus_is_open(sd_bus *bus);
	int sd_bus_can_send(sd_bus *bus, char type);	int sd_bus_can_send(sd_bus *bus, char type);
	int sd_bus_get_server_id(sd_bus bus, sd_id128_t peer);	int sd_bus_get_server_id(sd_bus bus, sd_id128_t peer);

	skipping to change at line 166	skipping to change at line 162

	int sd_bus_message_is_signal(sd_bus_message m, const char interface, cons t char *member);	int sd_bus_message_is_signal(sd_bus_message m, const char interface, cons t char *member);
	int sd_bus_message_is_method_call(sd_bus_message m, const char interface, const char *member);	int sd_bus_message_is_method_call(sd_bus_message m, const char interface, const char *member);
	int sd_bus_message_is_method_error(sd_bus_message m, const char name);	int sd_bus_message_is_method_error(sd_bus_message m, const char name);

	int sd_bus_message_set_no_reply(sd_bus_message *m, int b);	int sd_bus_message_set_no_reply(sd_bus_message *m, int b);
	int sd_bus_message_set_destination(sd_bus_message m, const char destinati on);	int sd_bus_message_set_destination(sd_bus_message m, const char destinati on);

	int sd_bus_message_append(sd_bus_message m, const char types, ...);	int sd_bus_message_append(sd_bus_message m, const char types, ...);
	int sd_bus_message_append_basic(sd_bus_message m, char type, const void p );	int sd_bus_message_append_basic(sd_bus_message m, char type, const void p );

		int sd_bus_message_append_array(sd_bus_message m, char type, const void p
		tr, size_t size);
		int sd_bus_message_append_array_space(sd_bus_message *m, char type, size_t
		size, void **ptr);
		int sd_bus_message_append_array_memfd(sd_bus_message *m, char type, sd_memf
		d *memfd);
		int sd_bus_message_append_string_space(sd_bus_message *m, size_t size, char
		**s);
		int sd_bus_message_append_string_memfd(sd_bus_message m, sd_memfd memfd);
	int sd_bus_message_open_container(sd_bus_message m, char type, const char contents);	int sd_bus_message_open_container(sd_bus_message m, char type, const char contents);
	int sd_bus_message_close_container(sd_bus_message *m);	int sd_bus_message_close_container(sd_bus_message *m);

	int sd_bus_message_read(sd_bus_message m, const char types, ...);	int sd_bus_message_read(sd_bus_message m, const char types, ...);
	int sd_bus_message_read_basic(sd_bus_message m, char type, void p);	int sd_bus_message_read_basic(sd_bus_message m, char type, void p);

		int sd_bus_message_read_array(sd_bus_message m, char type, const void pt r, size_t size);
	int sd_bus_message_enter_container(sd_bus_message m, char type, const char contents);	int sd_bus_message_enter_container(sd_bus_message m, char type, const char contents);
	int sd_bus_message_exit_container(sd_bus_message *m);	int sd_bus_message_exit_container(sd_bus_message *m);
	int sd_bus_message_peek_type(sd_bus_message m, char type, const char **co ntents);	int sd_bus_message_peek_type(sd_bus_message m, char type, const char **co ntents);
	int sd_bus_message_rewind(sd_bus_message *m, int complete);	int sd_bus_message_rewind(sd_bus_message *m, int complete);

	/* Convenience calls */	/* Convenience calls */

	int sd_bus_emit_signal(sd_bus bus, const char path, const char interface , const char member, const char *types, ...);	int sd_bus_emit_signal(sd_bus bus, const char path, const char interface , const char member, const char *types, ...);
	int sd_bus_call_method(sd_bus bus, const char destination, const char pa th, const char interface, const char member, sd_bus_error error, sd_bus_ message *reply, const char types, ...);	int sd_bus_call_method(sd_bus bus, const char destination, const char pa th, const char interface, const char member, sd_bus_error error, sd_bus_ message *reply, const char types, ...);
	int sd_bus_reply_method_return(sd_bus bus, sd_bus_message call, const cha r *types, ...);	int sd_bus_reply_method_return(sd_bus bus, sd_bus_message call, const cha r *types, ...);

	skipping to change at line 206	skipping to change at line 208
	#define SD_BUS_ERROR_NULL ((sd_bus_error) {NULL, NULL, 0})	#define SD_BUS_ERROR_NULL ((sd_bus_error) {NULL, NULL, 0})
	#define SD_BUS_ERROR_MAKE(name, message) ((sd_bus_error) {(name), (message) , 0})	#define SD_BUS_ERROR_MAKE(name, message) ((sd_bus_error) {(name), (message) , 0})

	void sd_bus_error_free(sd_bus_error *e);	void sd_bus_error_free(sd_bus_error *e);
	int sd_bus_error_set(sd_bus_error e, const char name, const char *format, ...) _sd_printf_attr_(3, 0);	int sd_bus_error_set(sd_bus_error e, const char name, const char *format, ...) _sd_printf_attr_(3, 0);
	void sd_bus_error_set_const(sd_bus_error e, const char name, const char * message);	void sd_bus_error_set_const(sd_bus_error e, const char name, const char * message);
	int sd_bus_error_copy(sd_bus_error dest, const sd_bus_error e);	int sd_bus_error_copy(sd_bus_error dest, const sd_bus_error e);
	int sd_bus_error_is_set(const sd_bus_error *e);	int sd_bus_error_is_set(const sd_bus_error *e);
	int sd_bus_error_has_name(const sd_bus_error e, const char name);	int sd_bus_error_has_name(const sd_bus_error e, const char name);


		#define SD_BUS_APPEND_ID128(x) 16,
		\
		(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).bytes[8], (x).bytes[9], (x).bytes[10], (x).bytes[11],
		\
		(x).bytes[12], (x).bytes[13], (x).bytes[14], (x).bytes[15]

	#ifdef __cplusplus	#ifdef __cplusplus
	}	}
	#endif	#endif

	#endif	#endif

End of changes. 7 change blocks.
	15 lines changed or deleted	30 lines changed or added

	sd-journal.h	sd-journal.h

	skipping to change at line 89	skipping to change at line 89
	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);

	/* Browse journal stream */	/* Browse journal stream */

	typedef struct sd_journal sd_journal;	typedef struct sd_journal sd_journal;

	/* Open flags */	/* Open flags */
	enum {	enum {
	SD_JOURNAL_LOCAL_ONLY = 1,	SD_JOURNAL_LOCAL_ONLY = 1,
	SD_JOURNAL_RUNTIME_ONLY = 2,	SD_JOURNAL_RUNTIME_ONLY = 2,

	SD_JOURNAL_SYSTEM_ONLY = 4	SD_JOURNAL_SYSTEM = 4,
		SD_JOURNAL_SYSTEM_ONLY = SD_JOURNAL_SYSTEM, /* deprecated */
		SD_JOURNAL_CURRENT_USER = 8,
	};	};

	/* Wakeup event types */	/* Wakeup event types */
	enum {	enum {
	SD_JOURNAL_NOP,	SD_JOURNAL_NOP,
	SD_JOURNAL_APPEND,	SD_JOURNAL_APPEND,
	SD_JOURNAL_INVALIDATE	SD_JOURNAL_INVALIDATE
	};	};

	int sd_journal_open(sd_journal **ret, int flags);	int sd_journal_open(sd_journal **ret, int flags);
	int sd_journal_open_directory(sd_journal *ret, const char path, int flags );	int sd_journal_open_directory(sd_journal *ret, const char path, int flags );

		int sd_journal_open_files(sd_journal ret, const char paths, int flags);
	void sd_journal_close(sd_journal *j);	void sd_journal_close(sd_journal *j);

	int sd_journal_previous(sd_journal *j);	int sd_journal_previous(sd_journal *j);
	int sd_journal_next(sd_journal *j);	int sd_journal_next(sd_journal *j);

	int sd_journal_previous_skip(sd_journal *j, uint64_t skip);	int sd_journal_previous_skip(sd_journal *j, uint64_t skip);
	int sd_journal_next_skip(sd_journal *j, uint64_t skip);	int sd_journal_next_skip(sd_journal *j, uint64_t skip);

	int sd_journal_get_realtime_usec(sd_journal j, uint64_t ret);	int sd_journal_get_realtime_usec(sd_journal j, uint64_t ret);
	int sd_journal_get_monotonic_usec(sd_journal j, uint64_t ret, sd_id128_t *ret_boot_id);	int sd_journal_get_monotonic_usec(sd_journal j, uint64_t ret, sd_id128_t *ret_boot_id);

End of changes. 2 change blocks.
	1 lines changed or deleted	4 lines changed or added

	sd-messages.h	sd-messages.h

	skipping to change at line 34	skipping to change at line 34

	#include <systemd/sd-id128.h>	#include <systemd/sd-id128.h>

	#ifdef __cplusplus	#ifdef __cplusplus
	extern "C" {	extern "C" {
	#endif	#endif

	/* Hey! If you add a new message here, you must also update the	/* Hey! If you add a new message here, you must also update the
	* message catalog with an appropriate explanation */	* message catalog with an appropriate explanation */


		/* And if you add a new ID here, make sure to generate a random one
		* with journalctl --new-id128. Do not use any other IDs, and do not
		* count them up manually. */

	#define SD_MESSAGE_JOURNAL_START SD_ID128_MAKE(f7,73,79,a8,49,0b,40,8b,b e,5f,69,40,50,5a,77,7b)	#define SD_MESSAGE_JOURNAL_START SD_ID128_MAKE(f7,73,79,a8,49,0b,40,8b,b e,5f,69,40,50,5a,77,7b)
	#define SD_MESSAGE_JOURNAL_STOP SD_ID128_MAKE(d9,3f,b3,c9,c2,4d,45,1a,9 7,ce,a6,15,ce,59,c0,0b)	#define SD_MESSAGE_JOURNAL_STOP SD_ID128_MAKE(d9,3f,b3,c9,c2,4d,45,1a,9 7,ce,a6,15,ce,59,c0,0b)
	#define SD_MESSAGE_JOURNAL_DROPPED SD_ID128_MAKE(a5,96,d6,fe,7b,fa,49,94,8 2,8e,72,30,9e,95,d6,1e)	#define SD_MESSAGE_JOURNAL_DROPPED SD_ID128_MAKE(a5,96,d6,fe,7b,fa,49,94,8 2,8e,72,30,9e,95,d6,1e)
	#define SD_MESSAGE_JOURNAL_MISSED SD_ID128_MAKE(e9,bf,28,e6,e8,34,48,1b,b 6,f4,8f,54,8a,d1,36,06)	#define SD_MESSAGE_JOURNAL_MISSED SD_ID128_MAKE(e9,bf,28,e6,e8,34,48,1b,b 6,f4,8f,54,8a,d1,36,06)

		#define SD_MESSAGE_JOURNAL_USAGE SD_ID128_MAKE(ec,38,7f,57,7b,84,4b,8f,a 9,48,f3,3c,ad,9a,75,e6)

	#define SD_MESSAGE_COREDUMP SD_ID128_MAKE(fc,2e,22,bc,6e,e6,47,b6,b 9,07,29,ab,34,a2,50,b1)	#define SD_MESSAGE_COREDUMP SD_ID128_MAKE(fc,2e,22,bc,6e,e6,47,b6,b 9,07,29,ab,34,a2,50,b1)

	#define SD_MESSAGE_SESSION_START SD_ID128_MAKE(8d,45,62,0c,1a,43,48,db,b 1,74,10,da,57,c6,0c,66)	#define SD_MESSAGE_SESSION_START SD_ID128_MAKE(8d,45,62,0c,1a,43,48,db,b 1,74,10,da,57,c6,0c,66)
	#define SD_MESSAGE_SESSION_STOP SD_ID128_MAKE(33,54,93,94,24,b4,45,6d,9 8,02,ca,83,33,ed,42,4a)	#define SD_MESSAGE_SESSION_STOP SD_ID128_MAKE(33,54,93,94,24,b4,45,6d,9 8,02,ca,83,33,ed,42,4a)
	#define SD_MESSAGE_SEAT_START SD_ID128_MAKE(fc,be,fc,5d,a2,3d,42,80,9 3,f9,7c,82,a9,29,0f,7b)	#define SD_MESSAGE_SEAT_START SD_ID128_MAKE(fc,be,fc,5d,a2,3d,42,80,9 3,f9,7c,82,a9,29,0f,7b)
	#define SD_MESSAGE_SEAT_STOP SD_ID128_MAKE(e7,85,2b,fe,46,78,4e,d0,a c,cd,e0,4b,c8,64,c2,d5)	#define SD_MESSAGE_SEAT_STOP SD_ID128_MAKE(e7,85,2b,fe,46,78,4e,d0,a c,cd,e0,4b,c8,64,c2,d5)

		#define SD_MESSAGE_MACHINE_START SD_ID128_MAKE(24,d8,d4,45,25,73,40,24,9
		6,06,83,81,a6,31,2d,f2)
		#define SD_MESSAGE_MACHINE_STOP SD_ID128_MAKE(58,43,2b,d3,ba,ce,47,7c,b
		5,14,b5,63,81,b8,a7,58)

	#define SD_MESSAGE_TIME_CHANGE SD_ID128_MAKE(c7,a7,87,07,9b,35,4e,aa,a 9,e7,7b,37,18,93,cd,27)	#define SD_MESSAGE_TIME_CHANGE SD_ID128_MAKE(c7,a7,87,07,9b,35,4e,aa,a 9,e7,7b,37,18,93,cd,27)
	#define SD_MESSAGE_TIMEZONE_CHANGE SD_ID128_MAKE(45,f8,2f,4a,ef,7a,4b,bf,9 4,2c,e8,61,d1,f2,09,90)	#define SD_MESSAGE_TIMEZONE_CHANGE SD_ID128_MAKE(45,f8,2f,4a,ef,7a,4b,bf,9 4,2c,e8,61,d1,f2,09,90)

	#define SD_MESSAGE_STARTUP_FINISHED SD_ID128_MAKE(b0,7a,24,9c,d0,24,41,4a,8 2,dd,00,cd,18,13,78,ff)	#define SD_MESSAGE_STARTUP_FINISHED SD_ID128_MAKE(b0,7a,24,9c,d0,24,41,4a,8 2,dd,00,cd,18,13,78,ff)

	#define SD_MESSAGE_SLEEP_START SD_ID128_MAKE(6b,bd,95,ee,97,79,41,e4,9 7,c4,8b,e2,7c,25,41,28)	#define SD_MESSAGE_SLEEP_START SD_ID128_MAKE(6b,bd,95,ee,97,79,41,e4,9 7,c4,8b,e2,7c,25,41,28)
	#define SD_MESSAGE_SLEEP_STOP SD_ID128_MAKE(88,11,e6,df,2a,8e,40,f5,8 a,94,ce,a2,6f,8e,bf,14)	#define SD_MESSAGE_SLEEP_STOP SD_ID128_MAKE(88,11,e6,df,2a,8e,40,f5,8 a,94,ce,a2,6f,8e,bf,14)

	#define SD_MESSAGE_SHUTDOWN SD_ID128_MAKE(98,26,88,66,d1,d5,4a,49,9 c,4e,98,92,1d,93,bc,40)	#define SD_MESSAGE_SHUTDOWN SD_ID128_MAKE(98,26,88,66,d1,d5,4a,49,9 c,4e,98,92,1d,93,bc,40)

End of changes. 3 change blocks.
	0 lines changed or deleted	9 lines changed or added

	service.h	service.h

	skipping to change at line 138	skipping to change at line 138
	usec_t timeout_stop_usec;	usec_t timeout_stop_usec;

	dual_timestamp watchdog_timestamp;	dual_timestamp watchdog_timestamp;
	usec_t watchdog_usec;	usec_t watchdog_usec;
	Watch watchdog_watch;	Watch watchdog_watch;

	ExecCommand* exec_command[_SERVICE_EXEC_COMMAND_MAX];	ExecCommand* exec_command[_SERVICE_EXEC_COMMAND_MAX];

	ExecContext exec_context;	ExecContext exec_context;
	KillContext kill_context;	KillContext kill_context;

		CGroupContext cgroup_context;

	ServiceState state, deserialized_state;	ServiceState state, deserialized_state;

	/* The exit status of the real main process */	/* The exit status of the real main process */
	ExecStatus main_exec_status;	ExecStatus main_exec_status;

	/* The currently executed control process */	/* The currently executed control process */
	ExecCommand *control_command;	ExecCommand *control_command;

	/* The currently executed main process, which may be NULL if	/* The currently executed main process, which may be NULL if

End of changes. 1 change blocks.
	0 lines changed or deleted	1 lines changed or added

	snapshot.h	snapshot.h

	skipping to change at line 41	skipping to change at line 41
	_SNAPSHOT_STATE_MAX,	_SNAPSHOT_STATE_MAX,
	_SNAPSHOT_STATE_INVALID = -1	_SNAPSHOT_STATE_INVALID = -1
	} SnapshotState;	} SnapshotState;

	struct Snapshot {	struct Snapshot {
	Unit meta;	Unit meta;

	SnapshotState state, deserialized_state;	SnapshotState state, deserialized_state;

	bool cleanup;	bool cleanup;

	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);
	void snapshot_remove(Snapshot *s);	void snapshot_remove(Snapshot *s);

	const char* snapshot_state_to_string(SnapshotState i) _const_;	const char* snapshot_state_to_string(SnapshotState i) _const_;
	SnapshotState snapshot_state_from_string(const char *s) _pure_;	SnapshotState snapshot_state_from_string(const char *s) _pure_;

End of changes. 1 change blocks.
	1 lines changed or deleted	0 lines changed or added

	socket.h	socket.h

	skipping to change at line 105	skipping to change at line 105
	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;

	ExecCommand* exec_command[_SOCKET_EXEC_COMMAND_MAX];	ExecCommand* exec_command[_SOCKET_EXEC_COMMAND_MAX];
	ExecContext exec_context;	ExecContext exec_context;
	KillContext kill_context;	KillContext kill_context;

		CGroupContext cgroup_context;

	/* For Accept=no sockets refers to the one service we'll	/* For Accept=no sockets refers to the one service we'll
	activate. For Accept=yes sockets is either NULL, or filled	activate. For Accept=yes sockets is either NULL, or filled
	when the next service we spawn. */	when the next service we spawn. */
	UnitRef service;	UnitRef service;

	SocketState state, deserialized_state;	SocketState state, deserialized_state;

	Watch timer_watch;	Watch timer_watch;


End of changes. 1 change blocks.
	0 lines changed or deleted	1 lines changed or added

	special.h	special.h

	skipping to change at line 116	skipping to change at line 116
	#define SPECIAL_KBREQUEST_TARGET "kbrequest.target"	#define SPECIAL_KBREQUEST_TARGET "kbrequest.target"
	#define SPECIAL_SIGPWR_TARGET "sigpwr.target"	#define SPECIAL_SIGPWR_TARGET "sigpwr.target"
	#define SPECIAL_CTRL_ALT_DEL_TARGET "ctrl-alt-del.target"	#define SPECIAL_CTRL_ALT_DEL_TARGET "ctrl-alt-del.target"

	/* For SysV compatibility. Usually an alias for a saner target. On	/* For SysV compatibility. Usually an alias for a saner target. On
	* SysV-free systems this doesn't exist. */	* SysV-free systems this doesn't exist. */
	#define SPECIAL_RUNLEVEL2_TARGET "runlevel2.target"	#define SPECIAL_RUNLEVEL2_TARGET "runlevel2.target"
	#define SPECIAL_RUNLEVEL3_TARGET "runlevel3.target"	#define SPECIAL_RUNLEVEL3_TARGET "runlevel3.target"
	#define SPECIAL_RUNLEVEL4_TARGET "runlevel4.target"	#define SPECIAL_RUNLEVEL4_TARGET "runlevel4.target"
	#define SPECIAL_RUNLEVEL5_TARGET "runlevel5.target"	#define SPECIAL_RUNLEVEL5_TARGET "runlevel5.target"


		/* Where we add all our system units, users and machines by default */
		#define SPECIAL_SYSTEM_SLICE "system.slice"
		#define SPECIAL_USER_SLICE "user.slice"
		#define SPECIAL_MACHINE_SLICE "machine.slice"
		#define SPECIAL_ROOT_SLICE "-.slice"

End of changes. 1 change blocks.
	0 lines changed or deleted	0 lines changed or added

	store.h	store.h
	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/

	#pragma once	#pragma once

	/***	/***
	This file is part of systemd.	This file is part of systemd.


	Copyright (C) 2009-2013 Intel Coproration	Copyright (C) 2009-2013 Intel Corporation

	Authors:	Authors:
	Auke Kok <auke-jan.h.kok@intel.com>	Auke Kok <auke-jan.h.kok@intel.com>

	systemd is free software; you can redistribute it and/or modify it	systemd is free software; you can redistribute it and/or modify it
	under the terms of the GNU Lesser General Public License as published by	under the terms of the GNU Lesser General Public License as published by
	the Free Software Foundation; either version 2.1 of the License, or	the Free Software Foundation; either version 2.1 of the License, or
	(at your option) any later version.	(at your option) any later version.

	systemd is distributed in the hope that it will be useful, but	systemd is distributed in the hope that it will be useful, but

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	svg.h	svg.h
	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/

	#pragma once	#pragma once

	/***	/***
	This file is part of systemd.	This file is part of systemd.


	Copyright (C) 2009-2013 Intel Coproration	Copyright (C) 2009-2013 Intel Corporation

	Authors:	Authors:
	Auke Kok <auke-jan.h.kok@intel.com>	Auke Kok <auke-jan.h.kok@intel.com>

	systemd is free software; you can redistribute it and/or modify it	systemd is free software; you can redistribute it and/or modify it
	under the terms of the GNU Lesser General Public License as published by	under the terms of the GNU Lesser General Public License as published by
	the Free Software Foundation; either version 2.1 of the License, or	the Free Software Foundation; either version 2.1 of the License, or
	(at your option) any later version.	(at your option) any later version.

	systemd is distributed in the hope that it will be useful, but	systemd is distributed in the hope that it will be useful, but

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 91	skipping to change at line 91
	bool is_active:1;	bool is_active:1;
	bool just_activated:1;	bool just_activated:1;

	SwapResult result;	SwapResult result;

	usec_t timeout_usec;	usec_t timeout_usec;

	ExecCommand exec_command[_SWAP_EXEC_COMMAND_MAX];	ExecCommand exec_command[_SWAP_EXEC_COMMAND_MAX];
	ExecContext exec_context;	ExecContext exec_context;
	KillContext kill_context;	KillContext kill_context;

		CGroupContext cgroup_context;

	SwapState state, deserialized_state;	SwapState state, deserialized_state;

	ExecCommand* control_command;	ExecCommand* control_command;
	SwapExecCommand control_command_id;	SwapExecCommand control_command_id;
	pid_t control_pid;	pid_t control_pid;

	Watch timer_watch;	Watch timer_watch;

	/* In order to be able to distinguish dependencies on	/* In order to be able to distinguish dependencies on

End of changes. 1 change blocks.
	0 lines changed or deleted	1 lines changed or added

	unit-name.h	unit-name.h

	skipping to change at line 44	skipping to change at line 44
	UNIT_SERVICE = 0,	UNIT_SERVICE = 0,
	UNIT_SOCKET,	UNIT_SOCKET,
	UNIT_TARGET,	UNIT_TARGET,
	UNIT_DEVICE,	UNIT_DEVICE,
	UNIT_MOUNT,	UNIT_MOUNT,
	UNIT_AUTOMOUNT,	UNIT_AUTOMOUNT,
	UNIT_SNAPSHOT,	UNIT_SNAPSHOT,
	UNIT_TIMER,	UNIT_TIMER,
	UNIT_SWAP,	UNIT_SWAP,
	UNIT_PATH,	UNIT_PATH,

		UNIT_SLICE,
		UNIT_SCOPE,
	_UNIT_TYPE_MAX,	_UNIT_TYPE_MAX,
	_UNIT_TYPE_INVALID = -1	_UNIT_TYPE_INVALID = -1
	};	};

	enum UnitLoadState {	enum UnitLoadState {
	UNIT_STUB = 0,	UNIT_STUB = 0,
	UNIT_LOADED,	UNIT_LOADED,

		UNIT_NOT_FOUND,
	UNIT_ERROR,	UNIT_ERROR,
	UNIT_MERGED,	UNIT_MERGED,
	UNIT_MASKED,	UNIT_MASKED,
	_UNIT_LOAD_STATE_MAX,	_UNIT_LOAD_STATE_MAX,
	_UNIT_LOAD_STATE_INVALID = -1	_UNIT_LOAD_STATE_INVALID = -1
	};	};

	const char *unit_type_to_string(UnitType i) _const_;	const char *unit_type_to_string(UnitType i) _const_;
	UnitType unit_type_from_string(const char *s) _pure_;	UnitType unit_type_from_string(const char *s) _pure_;


	skipping to change at line 95	skipping to change at line 98

	char unit_name_replace_instance(const char f, const char *i);	char unit_name_replace_instance(const char f, const char *i);

	char unit_name_template(const char f);	char unit_name_template(const char f);

	char unit_name_from_path(const char path, const char *suffix);	char unit_name_from_path(const char path, const char *suffix);
	char unit_name_from_path_instance(const char prefix, const char path, co nst char suffix);	char unit_name_from_path_instance(const char prefix, const char path, co nst char suffix);
	char unit_name_to_path(const char name);	char unit_name_to_path(const char name);

	char unit_dbus_path_from_name(const char name);	char unit_dbus_path_from_name(const char name);

		int unit_name_from_dbus_path(const char path, char *name);

	char unit_name_mangle(const char name);	char unit_name_mangle(const char name);

	char snapshot_name_mangle(const char name);	char unit_name_mangle_with_suffix(const char name, const char *suffix);

		int build_subslice(const char slice, const charname, char **subslice);

End of changes. 4 change blocks.
	0 lines changed or deleted	4 lines changed or added

	unit.h	unit.h

	skipping to change at line 40	skipping to change at line 40
	typedef enum UnitActiveState UnitActiveState;	typedef enum UnitActiveState UnitActiveState;
	typedef enum UnitDependency UnitDependency;	typedef enum UnitDependency UnitDependency;
	typedef struct UnitRef UnitRef;	typedef struct UnitRef UnitRef;
	typedef struct UnitStatusMessageFormats UnitStatusMessageFormats;	typedef struct UnitStatusMessageFormats UnitStatusMessageFormats;

	#include "set.h"	#include "set.h"
	#include "util.h"	#include "util.h"
	#include "list.h"	#include "list.h"
	#include "socket-util.h"	#include "socket-util.h"
	#include "execute.h"	#include "execute.h"

		#include "cgroup.h"
	#include "condition.h"	#include "condition.h"
	#include "install.h"	#include "install.h"
	#include "unit-name.h"	#include "unit-name.h"

	#include "cgroup-semantics.h"

	enum UnitActiveState {	enum UnitActiveState {
	UNIT_ACTIVE,	UNIT_ACTIVE,
	UNIT_RELOADING,	UNIT_RELOADING,
	UNIT_INACTIVE,	UNIT_INACTIVE,
	UNIT_FAILED,	UNIT_FAILED,
	UNIT_ACTIVATING,	UNIT_ACTIVATING,
	UNIT_DEACTIVATING,	UNIT_DEACTIVATING,
	_UNIT_ACTIVE_STATE_MAX,	_UNIT_ACTIVE_STATE_MAX,
	_UNIT_ACTIVE_STATE_INVALID = -1	_UNIT_ACTIVE_STATE_INVALID = -1

	skipping to change at line 118	skipping to change at line 118
	/* Reference information for GC logic */	/* Reference information for GC logic */
	UNIT_REFERENCES, /* Inverse of 'references' is 'refere nced_by' */	UNIT_REFERENCES, /* Inverse of 'references' is 'refere nced_by' */
	UNIT_REFERENCED_BY,	UNIT_REFERENCED_BY,

	_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-attr.h"	struct UnitRef {
		/* Keeps tracks of references to a unit. This is useful so
		* that we can merge two units if necessary and correct all
		* references to them */

		Unit* unit;
		LIST_FIELDS(UnitRef, refs);
		};

	struct Unit {	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;

	skipping to change at line 168	skipping to change at line 175
	LIST_HEAD(Condition, conditions);	LIST_HEAD(Condition, conditions);

	dual_timestamp condition_timestamp;	dual_timestamp condition_timestamp;

	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;	char *cgroup_path;
	CGroupAttribute *cgroup_attributes;	bool cgroup_realized;
		CGroupControllerMask cgroup_mask;

		UnitRef slice;

	/* Per type list */	/* Per type list */
	LIST_FIELDS(Unit, units_by_type);	LIST_FIELDS(Unit, units_by_type);

	/* All units which have requires_mounts_for set */	/* All units which have requires_mounts_for set */
	LIST_FIELDS(Unit, has_requires_mounts_for);	LIST_FIELDS(Unit, has_requires_mounts_for);

	/* Load queue */	/* Load queue */
	LIST_FIELDS(Unit, load_queue);	LIST_FIELDS(Unit, load_queue);

	/* D-Bus queue */	/* D-Bus queue */
	LIST_FIELDS(Unit, dbus_queue);	LIST_FIELDS(Unit, dbus_queue);

	/* Cleanup queue */	/* Cleanup queue */
	LIST_FIELDS(Unit, cleanup_queue);	LIST_FIELDS(Unit, cleanup_queue);

	/* GC queue */	/* GC queue */
	LIST_FIELDS(Unit, gc_queue);	LIST_FIELDS(Unit, gc_queue);


		/* CGroup realize members queue */
		LIST_FIELDS(Unit, cgroup_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.
	* Only for deserializing from a legacy version. New style uses ful l	* Only for deserializing from a legacy version. New style uses ful l
	* serialized jobs. */	* serialized jobs. */
	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) */

	skipping to change at line 231	skipping to change at line 244

	/* Ignore this unit when isolating */	/* Ignore this unit when isolating */
	bool ignore_on_isolate;	bool ignore_on_isolate;

	/* Ignore this unit when snapshotting */	/* Ignore this unit when snapshotting */
	bool ignore_on_snapshot;	bool ignore_on_snapshot;

	/* Did the last condition check succeed? */	/* Did the last condition check succeed? */
	bool condition_result;	bool condition_result;


		/* Is this a transient unit? */
		bool transient;

	bool in_load_queue:1;	bool in_load_queue:1;
	bool in_dbus_queue:1;	bool in_dbus_queue:1;
	bool in_cleanup_queue:1;	bool in_cleanup_queue:1;
	bool in_gc_queue:1;	bool in_gc_queue:1;

		bool in_cgroup_queue:1;

	bool sent_dbus_new_signal:1;	bool sent_dbus_new_signal:1;

	bool no_gc:1;	bool no_gc:1;

	bool in_audit:1;	bool in_audit:1;
	};	};


	struct UnitRef {
	/* Keeps tracks of references to a unit. This is useful so
	* that we can merge two units if necessary and correct all
	* references to them */

	Unit* unit;
	LIST_FIELDS(UnitRef, refs);
	};

	struct UnitStatusMessageFormats {	struct UnitStatusMessageFormats {
	const char *starting_stopping[2];	const char *starting_stopping[2];
	const char *finished_start_job[_JOB_RESULT_MAX];	const char *finished_start_job[_JOB_RESULT_MAX];
	const char *finished_stop_job[_JOB_RESULT_MAX];	const char *finished_stop_job[_JOB_RESULT_MAX];
	};	};


		typedef enum UnitSetPropertiesMode {
		UNIT_CHECK = 0,
		UNIT_RUNTIME = 1,
		UNIT_PERSISTENT = 2,
		} UnitSetPropertiesMode;

	#include "service.h"	#include "service.h"
	#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"

		#include "slice.h"
		#include "scope.h"

	struct UnitVTable {	struct UnitVTable {
	/* How much memory does an object of this unit type need */	/* How much memory does an object of this unit type need */
	size_t object_size;	size_t object_size;

	/* If greater than 0, the offset into the object where	/* If greater than 0, the offset into the object where
	* ExecContext is found, if the unit type has that */	* ExecContext is found, if the unit type has that */
	size_t exec_context_offset;	size_t exec_context_offset;


	/* The name of the section with the exec settings of ExecContext */	/* If greater than 0, the offset into the object where
	const char *exec_section;	* CGroupContext is found, if the unit type has that */
		size_t cgroup_context_offset;

		/* The name of the configuration file section with the private sett
		ings of this unit*/
		const char *private_section;

	/* 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 350	skipping to change at line 370

	void (fd_event)(Unit u, int fd, uint32_t events, Watch *w);	void (fd_event)(Unit u, int fd, uint32_t events, Watch *w);
	void (sigchld_event)(Unit u, pid_t pid, int code, int status);	void (sigchld_event)(Unit u, pid_t pid, int code, int status);
	void (timer_event)(Unit u, uint64_t n_elapsed, Watch *w);	void (timer_event)(Unit u, uint64_t n_elapsed, Watch *w);

	/* Reset failed state if we are in failed state */	/* Reset failed state if we are in failed state */
	void (reset_failed)(Unit u);	void (reset_failed)(Unit u);

	/* Called whenever any of the cgroups this unit watches for	/* Called whenever any of the cgroups this unit watches for
	* ran empty */	* ran empty */

	void (cgroup_notify_empty)(Unit u);	void (notify_cgroup_empty)(Unit u);

	/* Called whenever a process of this unit sends us a message */	/* Called whenever a process of this unit sends us a message */
	void (notify_message)(Unit u, pid_t pid, char **tags);	void (notify_message)(Unit u, pid_t pid, char **tags);

	/* Called whenever a name this Unit registered for comes or	/* Called whenever a name this Unit registered for comes or
	* goes away. */	* goes away. */
	void (bus_name_owner_change)(Unit u, const char name, const char old_owner, const char *new_owner);	void (bus_name_owner_change)(Unit u, const char name, const char old_owner, const char *new_owner);

	/* Called whenever a bus PID lookup finishes */	/* Called whenever a bus PID lookup finishes */
	void (bus_query_pid_done)(Unit u, const char *name, pid_t pid);	void (bus_query_pid_done)(Unit u, const char *name, pid_t pid);

	/* Called for each message received on the bus */	/* Called for each message received on the bus */
	DBusHandlerResult (bus_message_handler)(Unit u, DBusConnection c , DBusMessage message);	DBusHandlerResult (bus_message_handler)(Unit u, DBusConnection c , DBusMessage message);


		/* Called for each property that is being set */
		int (bus_set_property)(Unit u, const char *name, DBusMessageIter
		i, UnitSetPropertiesMode mode, DBusError error);

		/* Called after at least one property got changed to apply the nece
		ssary change */
		int (bus_commit_properties)(Unit u);

	/* Return the unit this unit is following */	/* Return the unit this unit is following */
	Unit (following)(Unit *u);	Unit (following)(Unit *u);

	/* Return the set of units that are following each other */	/* Return the set of units that are following each other */
	int (following_set)(Unit u, Set **s);	int (following_set)(Unit u, Set **s);

	/* Invoked each time a unit this unit is triggering changes	/* Invoked each time a unit this unit is triggering changes
	* state or gains/loses a job */	* state or gains/loses a job */
	void (trigger_notify)(Unit u, Unit *trigger);	void (trigger_notify)(Unit u, Unit *trigger);


	skipping to change at line 406	skipping to change at line 432
	UnitStatusMessageFormats status_message_formats;	UnitStatusMessageFormats status_message_formats;

	/* Can units of this type have multiple names? */	/* Can units of this type have multiple names? */
	bool no_alias:1;	bool no_alias:1;

	/* Instances make no sense for this type */	/* Instances make no sense for this type */
	bool no_instances:1;	bool no_instances:1;

	/* Exclude from automatic gc */	/* Exclude from automatic gc */
	bool no_gc:1;	bool no_gc:1;


		/* True if transient units of this type are OK */
		bool can_transient: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)->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->type != UNIT_##UPPERCASE)) \	if (_unlikely_(!u \|\| u->type != UNIT_##UPPERCASE)) \

	skipping to change at line 436	skipping to change at line 465
	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);

		DEFINE_CAST(SLICE, Slice);
		DEFINE_CAST(SCOPE, Scope);

	Unit unit_new(Manager m, size_t size);	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);

	int unit_add_dependency_by_name_inverse(Unit u, UnitDependency d, const ch ar name, const char *filename, bool add_reference);	int unit_add_dependency_by_name_inverse(Unit u, UnitDependency d, const ch ar name, const char *filename, bool add_reference);
	int unit_add_two_dependencies_by_name_inverse(Unit u, UnitDependency d, Un itDependency e, const char name, const char *path, bool add_reference);	int unit_add_two_dependencies_by_name_inverse(Unit u, UnitDependency d, Un itDependency e, const char name, const char *path, bool add_reference);

	int unit_add_exec_dependencies(Unit u, ExecContext c);	int unit_add_exec_dependencies(Unit u, ExecContext c);


	int unit_add_cgroup_from_text(Unit u, const char name, bool overwrite, CG
	roupBonding **ret);
	int unit_add_default_cgroups(Unit *u);
	CGroupBonding* unit_get_default_cgroup(Unit *u);
	int unit_add_cgroup_attribute(Unit u, const CGroupSemantics semantics, co
	nst char controller, const char name, const char *value, CGroupAttribute
	**ret);

	int unit_choose_id(Unit u, const char name);	int unit_choose_id(Unit u, const char name);
	int unit_set_description(Unit u, const char description);	int unit_set_description(Unit u, const char description);

	bool unit_check_gc(Unit *u);	bool unit_check_gc(Unit *u);

	void unit_add_to_load_queue(Unit *u);	void unit_add_to_load_queue(Unit *u);
	void unit_add_to_dbus_queue(Unit *u);	void unit_add_to_dbus_queue(Unit *u);
	void unit_add_to_cleanup_queue(Unit *u);	void unit_add_to_cleanup_queue(Unit *u);
	void unit_add_to_gc_queue(Unit *u);	void unit_add_to_gc_queue(Unit *u);

	int unit_merge(Unit u, Unit other);	int unit_merge(Unit u, Unit other);
	int unit_merge_by_name(Unit u, const char other);	int unit_merge_by_name(Unit u, const char other);

	Unit unit_follow_merge(Unit u) _pure_;	Unit unit_follow_merge(Unit u) _pure_;

	int unit_load_fragment_and_dropin(Unit *u);	int unit_load_fragment_and_dropin(Unit *u);
	int unit_load_fragment_and_dropin_optional(Unit *u);	int unit_load_fragment_and_dropin_optional(Unit *u);
	int unit_load(Unit *unit);	int unit_load(Unit *unit);


		int unit_add_default_slice(Unit *u);

	const char unit_description(Unit u) _pure_;	const char unit_description(Unit u) _pure_;

	bool unit_has_name(Unit u, const char name);	bool unit_has_name(Unit u, const char name);

	UnitActiveState unit_active_state(Unit *u);	UnitActiveState unit_active_state(Unit *u);

	const char* unit_sub_state_to_string(Unit *u);	const char* unit_sub_state_to_string(Unit *u);

	void unit_dump(Unit u, FILE f, const char *prefix);	void unit_dump(Unit u, FILE f, const char *prefix);


	skipping to change at line 539	skipping to change at line 567
	int unit_coldplug(Unit *u);	int unit_coldplug(Unit *u);

	void unit_status_printf(Unit u, const char status, const char *unit_statu s_msg_format) _printf_attr_(3, 0);	void unit_status_printf(Unit u, const char status, const char *unit_statu s_msg_format) _printf_attr_(3, 0);

	bool unit_need_daemon_reload(Unit *u);	bool unit_need_daemon_reload(Unit *u);

	void unit_reset_failed(Unit *u);	void unit_reset_failed(Unit *u);

	Unit unit_following(Unit u);	Unit unit_following(Unit u);


		const char unit_slice_name(Unit u);

	bool unit_stop_pending(Unit *u) _pure_;	bool unit_stop_pending(Unit *u) _pure_;
	bool unit_inactive_or_pending(Unit *u) _pure_;	bool unit_inactive_or_pending(Unit *u) _pure_;
	bool unit_active_or_pending(Unit *u);	bool unit_active_or_pending(Unit *u);

	int unit_add_default_target_dependency(Unit u, Unit target);	int unit_add_default_target_dependency(Unit u, Unit target);

	char unit_default_cgroup_path(Unit u);	char unit_default_cgroup_path(Unit u);

	int unit_following_set(Unit u, Set *s);	int unit_following_set(Unit u, Set *s);


	skipping to change at line 560	skipping to change at line 590
	void unit_trigger_notify(Unit *u);	void unit_trigger_notify(Unit *u);

	bool unit_condition_test(Unit *u);	bool unit_condition_test(Unit *u);

	UnitFileState unit_get_unit_file_state(Unit *u);	UnitFileState unit_get_unit_file_state(Unit *u);

	Unit* unit_ref_set(UnitRef ref, Unit u);	Unit* unit_ref_set(UnitRef ref, Unit u);
	void unit_ref_unset(UnitRef *ref);	void unit_ref_unset(UnitRef *ref);

	#define UNIT_DEREF(ref) ((ref).unit)	#define UNIT_DEREF(ref) ((ref).unit)

		#define UNIT_ISSET(ref) (!!(ref).unit)

	int unit_add_one_mount_link(Unit u, Mount m);	int unit_add_one_mount_link(Unit u, Mount m);
	int unit_add_mount_links(Unit *u);	int unit_add_mount_links(Unit *u);

	int unit_exec_context_defaults(Unit u, ExecContext c);	int unit_exec_context_defaults(Unit u, ExecContext c);

	ExecContext unit_get_exec_context(Unit u) _pure_;	ExecContext unit_get_exec_context(Unit u) _pure_;

		CGroupContext unit_get_cgroup_context(Unit u) _pure_;


	int unit_write_drop_in(Unit u, bool runtime, const char name, const char	int unit_write_drop_in(Unit u, UnitSetPropertiesMode mode, const char nam
	*data);	e, const char *data);
	int unit_remove_drop_in(Unit u, bool runtime, const char name);	int unit_write_drop_in_private_section(Unit *u, UnitSetPropertiesMode mode,
		const char name, const char data);
		int unit_remove_drop_in(Unit u, UnitSetPropertiesMode mode, const char na
		me);

	int unit_kill_context(Unit u, KillContext c, bool sigkill, pid_t main_pid , pid_t control_pid, bool main_pid_alien);	int unit_kill_context(Unit u, KillContext c, bool sigkill, pid_t main_pid , pid_t control_pid, bool main_pid_alien);


		int unit_make_transient(Unit *u);

	const char *unit_active_state_to_string(UnitActiveState i) _const_;	const char *unit_active_state_to_string(UnitActiveState i) _const_;
	UnitActiveState unit_active_state_from_string(const char *s) _pure_;	UnitActiveState unit_active_state_from_string(const char *s) _pure_;

	const char *unit_dependency_to_string(UnitDependency i) _const_;	const char *unit_dependency_to_string(UnitDependency i) _const_;
	UnitDependency unit_dependency_from_string(const char *s) _pure_;	UnitDependency unit_dependency_from_string(const char *s) _pure_;

	/* Macros which append UNIT= or USER_UNIT= to the message */	/* Macros which append UNIT= or USER_UNIT= to the message */

	#define log_full_unit(level, unit, ...) log_meta_object(level, __FILE__, __ LINE__, __func__, getpid() == 1 ? "UNIT=" : "USER_UNIT=", unit, __VA_ARGS__ )	#define log_full_unit(level, unit, ...) log_meta_object(level, __FILE__, __ LINE__, __func__, getpid() == 1 ? "UNIT=" : "USER_UNIT=", unit, __VA_ARGS__ )
	#define log_debug_unit(unit, ...) log_full_unit(LOG_DEBUG, unit, __VA _ARGS__)	#define log_debug_unit(unit, ...) log_full_unit(LOG_DEBUG, unit, __VA _ARGS__)

End of changes. 22 change blocks.
	28 lines changed or deleted	65 lines changed or added

	util.h	util.h

	skipping to change at line 442	skipping to change at line 442
	int get_user_creds(const char *username, uid_t uid, gid_t gid, const cha r home, const char *shell);	int get_user_creds(const char *username, uid_t uid, gid_t gid, const cha r home, const char *shell);
	int get_group_creds(const char *groupname, gid_t gid);	int get_group_creds(const char *groupname, gid_t gid);

	int in_gid(gid_t gid);	int in_gid(gid_t gid);
	int in_group(const char *name);	int in_group(const char *name);

	char* uid_to_name(uid_t uid);	char* uid_to_name(uid_t uid);
	char* gid_to_name(gid_t gid);	char* gid_to_name(gid_t gid);

	int glob_exists(const char *path);	int glob_exists(const char *path);

		int glob_extend(char **strv, const char path);

	int dirent_ensure_type(DIR d, struct dirent de);	int dirent_ensure_type(DIR d, struct dirent de);

	int in_search_path(const char path, char *search);	int in_search_path(const char path, char *search);
	int get_files_in_directory(const char path, char **list);	int get_files_in_directory(const char path, char **list);

	char strjoin(const char x, ...) _sentinel_;	char strjoin(const char x, ...) _sentinel_;

	bool is_main_thread(void);	bool is_main_thread(void);


	skipping to change at line 735	skipping to change at line 736
	if (!_saved_locale_.quit) { \	if (!_saved_locale_.quit) { \
	PROTECT_ERRNO; \	PROTECT_ERRNO; \
	_saved_locale_.new_locale = newlocale((mask), (loc), (locale_t) 0); \	_saved_locale_.new_locale = newlocale((mask), (loc), (locale_t) 0); \
	if (_saved_locale_.new_locale != (locale_t) 0) \	if (_saved_locale_.new_locale != (locale_t) 0) \
	_saved_locale_.saved_locale = uselocal e(_saved_locale_.new_locale); \	_saved_locale_.saved_locale = uselocal e(_saved_locale_.new_locale); \
	} \	} \
	!_saved_locale_.quit; }) ; \	!_saved_locale_.quit; }) ; \
	_saved_locale_.quit = true)	_saved_locale_.quit = true)

	bool id128_is_valid(const char *s) _pure_;	bool id128_is_valid(const char *s) _pure_;

		void parse_user_at_host(char arg, char user, char *host);

End of changes. 2 change blocks.
	0 lines changed or deleted	1 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/

	install.h	install.h

	skipping to change at line 83	skipping to change at line 83
	char **required_by;	char **required_by;
	} InstallInfo;	} InstallInfo;

	int unit_file_enable(UnitFileScope scope, bool runtime, const char root_di r, char files[], bool force, UnitFileChange *changes, unsigned n_changes );	int unit_file_enable(UnitFileScope scope, bool runtime, const char root_di r, char files[], bool force, UnitFileChange *changes, unsigned n_changes );
	int unit_file_disable(UnitFileScope scope, bool runtime, const char root_d ir, char files[], UnitFileChange *changes, unsigned n_changes);	int unit_file_disable(UnitFileScope scope, bool runtime, const char root_d ir, char files[], UnitFileChange *changes, unsigned n_changes);
	int unit_file_reenable(UnitFileScope scope, bool runtime, const char root_ dir, char files[], bool force, UnitFileChange *changes, unsigned n_chang es);	int unit_file_reenable(UnitFileScope scope, bool runtime, const char root_ dir, char files[], bool force, UnitFileChange *changes, unsigned n_chang es);
	int unit_file_link(UnitFileScope scope, bool runtime, const char root_dir, char files[], bool force, UnitFileChange *changes, unsigned n_changes);	int unit_file_link(UnitFileScope scope, bool runtime, const char root_dir, char files[], bool force, UnitFileChange *changes, unsigned n_changes);
	int unit_file_preset(UnitFileScope scope, bool runtime, const char root_di r, char files[], bool force, UnitFileChange *changes, unsigned n_changes );	int unit_file_preset(UnitFileScope scope, bool runtime, const char root_di r, char files[], bool force, UnitFileChange *changes, unsigned n_changes );
	int unit_file_mask(UnitFileScope scope, bool runtime, const char root_dir, char files[], bool force, UnitFileChange *changes, unsigned n_changes);	int unit_file_mask(UnitFileScope scope, bool runtime, const char root_dir, char files[], bool force, UnitFileChange *changes, unsigned n_changes);
	int unit_file_unmask(UnitFileScope scope, bool runtime, const char root_di r, char files[], UnitFileChange *changes, unsigned n_changes);	int unit_file_unmask(UnitFileScope scope, bool runtime, const char root_di r, char files[], UnitFileChange *changes, unsigned n_changes);

		int unit_file_set_default(UnitFileScope scope, const char root_dir, char
		file, UnitFileChange *changes, unsigned n_changes);
		int unit_file_get_default(UnitFileScope scope, const char root_dir, char
		*name);

	UnitFileState unit_file_get_state(UnitFileScope scope, const char root_dir , const char filename);	UnitFileState unit_file_get_state(UnitFileScope scope, const char root_dir , const char filename);

	int unit_file_get_list(UnitFileScope scope, const char root_dir, Hashmap h);	int unit_file_get_list(UnitFileScope scope, const char root_dir, Hashmap h);

	void unit_file_list_free(Hashmap *h);	void unit_file_list_free(Hashmap *h);
	void unit_file_changes_free(UnitFileChange *changes, unsigned n_changes);	void unit_file_changes_free(UnitFileChange *changes, unsigned n_changes);

	int unit_file_query_preset(UnitFileScope scope, const char *name);	int unit_file_query_preset(UnitFileScope scope, const char *name);


End of changes. 1 change blocks.
	0 lines changed or deleted	4 lines changed or added

	load-fragment.h	load-fragment.h

	skipping to change at line 58	skipping to change at line 58
	int config_parse_input(const char unit, const char filename, unsigned lin e, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);	int config_parse_input(const char unit, const char filename, unsigned lin e, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);
	int config_parse_exec_io_class(const char unit, const char filename, unsi gned line, const char section, const char lvalue, int ltype, const char * rvalue, void data, void userdata);	int config_parse_exec_io_class(const char unit, const char filename, unsi gned line, const char section, const char lvalue, int ltype, const char * rvalue, void data, void userdata);
	int config_parse_exec_io_priority(const char unit, const char filename, u nsigned line, const char section, const char lvalue, int ltype, const cha r rvalue, void data, void *userdata);	int config_parse_exec_io_priority(const char unit, const char filename, u nsigned line, const char section, const char lvalue, int ltype, const cha r rvalue, void data, void *userdata);
	int config_parse_exec_cpu_sched_policy(const char unit, const char filena me, unsigned line, const char section, const char lvalue, int ltype, cons t char rvalue, void data, void *userdata);	int config_parse_exec_cpu_sched_policy(const char unit, const char filena me, unsigned line, const char section, const char lvalue, int ltype, cons t char rvalue, void data, void *userdata);
	int config_parse_exec_cpu_sched_prio(const char unit, const char filename , unsigned line, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);	int config_parse_exec_cpu_sched_prio(const char unit, const char filename , unsigned line, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);
	int config_parse_exec_cpu_affinity(const char unit, const char filename, unsigned line, const char section, const char lvalue, int ltype, const ch ar rvalue, void data, void *userdata);	int config_parse_exec_cpu_affinity(const char unit, const char filename, unsigned line, const char section, const char lvalue, int ltype, const ch ar rvalue, void data, void *userdata);
	int config_parse_exec_capabilities(const char unit, const char filename, unsigned line, const char section, const char lvalue, int ltype, const ch ar rvalue, void data, void *userdata);	int config_parse_exec_capabilities(const char unit, const char filename, unsigned line, const char section, const char lvalue, int ltype, const ch ar rvalue, void data, void *userdata);
	int config_parse_exec_secure_bits(const char unit, const char filename, u nsigned line, const char section, const char lvalue, int ltype, const cha r rvalue, void data, void *userdata);	int config_parse_exec_secure_bits(const char unit, const char filename, u nsigned line, const char section, const char lvalue, int ltype, const cha r rvalue, void data, void *userdata);
	int config_parse_bounding_set(const char unit, const char filename, unsig ned line, const char section, const char lvalue, int ltype, const char r value, void data, void *userdata);	int config_parse_bounding_set(const char unit, const char filename, unsig ned line, const char section, const char lvalue, int ltype, const char r value, void data, void *userdata);
	int config_parse_limit(const char unit, const char filename, unsigned lin e, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);	int config_parse_limit(const char unit, const char filename, unsigned lin e, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);

	int config_parse_unit_cgroup(const char unit, const char filename, unsign ed line, const char section, const char lvalue, int ltype, const char rv alue, void data, void *userdata);
	int config_parse_sysv_priority(const char unit, const char filename, unsi gned line, const char section, const char lvalue, int ltype, const char * rvalue, void data, void userdata);	int config_parse_sysv_priority(const char unit, const char filename, unsi gned line, const char section, const char lvalue, int ltype, const char * rvalue, void data, void userdata);
	int config_parse_fsck_passno(const char unit, const char filename, unsign ed line, const char section, const char lvalue, int ltype, const char rv alue, void data, void *userdata);	int config_parse_fsck_passno(const char unit, const char filename, unsign ed line, const char section, const char lvalue, int ltype, const char rv alue, void data, void *userdata);
	int config_parse_kill_signal(const char unit, const char filename, unsign ed line, const char section, const char lvalue, int ltype, const char rv alue, void data, void *userdata);	int config_parse_kill_signal(const char unit, const char filename, unsign ed line, const char section, const char lvalue, int ltype, const char rv alue, void data, void *userdata);
	int config_parse_exec_mount_flags(const char unit, const char filename, u nsigned line, const char section, const char lvalue, int ltype, const cha r rvalue, void data, void *userdata);	int config_parse_exec_mount_flags(const char unit, const char filename, u nsigned line, const char section, const char lvalue, int ltype, const cha r rvalue, void data, void *userdata);
	int config_parse_timer(const char unit, const char filename, unsigned lin e, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);	int config_parse_timer(const char unit, const char filename, unsigned lin e, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);
	int config_parse_trigger_unit(const char unit, const char filename, unsig ned line, const char section, const char lvalue, int ltype, const char r value, void data, void *userdata);	int config_parse_trigger_unit(const char unit, const char filename, unsig ned line, const char section, const char lvalue, int ltype, const char r value, void data, void *userdata);
	int config_parse_path_spec(const char unit, const char filename, unsigned line, const char section, const char lvalue, int ltype, const char rval ue, void data, void *userdata);	int config_parse_path_spec(const char unit, const char filename, unsigned line, const char section, const char lvalue, int ltype, const char rval ue, void data, void *userdata);
	int config_parse_socket_service(const char unit, const char filename, uns igned line, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);	int config_parse_socket_service(const char unit, const char filename, uns igned line, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);
	int config_parse_service_sockets(const char unit, const char filename, un signed line, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);	int config_parse_service_sockets(const char unit, const char filename, un signed line, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);
	int config_parse_unit_env_file(const char unit, const char filename, unsi gned line, const char section, const char lvalue, int ltype, const char * rvalue, void data, void userdata);	int config_parse_unit_env_file(const char unit, const char filename, unsi gned line, const char section, const char lvalue, int ltype, const char * rvalue, void data, void userdata);
	int config_parse_ip_tos(const char unit, const char filename, unsigned li ne, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);	int config_parse_ip_tos(const char unit, const char filename, unsigned li ne, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);
	int config_parse_unit_condition_path(const char unit, const char filename , unsigned line, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);	int config_parse_unit_condition_path(const char unit, const char filename , unsigned line, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);
	int config_parse_unit_condition_string(const char unit, const char filena me, unsigned line, const char section, const char lvalue, int ltype, cons t char rvalue, void data, void *userdata);	int config_parse_unit_condition_string(const char unit, const char filena me, unsigned line, const char section, const char lvalue, int ltype, cons t char rvalue, void data, void *userdata);
	int config_parse_unit_condition_null(const char unit, const char filename , unsigned line, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);	int config_parse_unit_condition_null(const char unit, const char filename , unsigned line, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);
	int config_parse_kill_mode(const char unit, const char filename, unsigned line, const char section, const char lvalue, int ltype, const char rval ue, void data, void *userdata);	int config_parse_kill_mode(const char unit, const char filename, unsigned line, const char section, const char lvalue, int ltype, const char rval ue, void data, void *userdata);
	int config_parse_notify_access(const char unit, const char filename, unsi gned line, const char section, const char lvalue, int ltype, const char * rvalue, void data, void userdata);	int config_parse_notify_access(const char unit, const char filename, unsi gned line, const char section, const char lvalue, int ltype, const char * rvalue, void data, void userdata);
	int config_parse_start_limit_action(const char unit, const char filename, unsigned line, const char section, const char lvalue, int ltype, const c har rvalue, void data, void *userdata);	int config_parse_start_limit_action(const char unit, const char filename, unsigned line, const char section, const char lvalue, int ltype, const c har rvalue, void data, void *userdata);

	int config_parse_unit_cgroup_attr(const char unit, const char filename, u
	nsigned line, const char section, const char lvalue, int ltype, const cha
	r rvalue, void data, void *userdata);
	int config_parse_unit_cgroup_attr_pretty(const char unit, const char file
	name, unsigned line, const char section, const char lvalue, int ltype, co
	nst char rvalue, void data, void *userdata);
	int config_parse_unit_requires_mounts_for(const char unit, const char fil ename, unsigned line, const char section, const char lvalue, int ltype, c onst char rvalue, void data, void *userdata);	int config_parse_unit_requires_mounts_for(const char unit, const char fil ename, unsigned line, const char section, const char lvalue, int ltype, c onst char rvalue, void data, void *userdata);
	int config_parse_syscall_filter(const char unit, const char filename, uns igned line, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);	int config_parse_syscall_filter(const char unit, const char filename, uns igned line, const char section, const char lvalue, int ltype, const char rvalue, void data, void *userdata);
	int config_parse_environ(const char unit, const char filename, unsigned l ine, const char section, const char lvalue, int ltype, const char rvalue , void data, void *userdata);	int config_parse_environ(const char unit, const char filename, unsigned l ine, const char section, const char lvalue, int ltype, const char rvalue , void data, void *userdata);

		int config_parse_unit_slice(const char unit, const char filename, unsigne
		d line, const char section, const char lvalue, int ltype, const char *rva
		lue, void data, void userdata);
		int config_parse_cpu_shares(const char unit, const char filename, unsigne
		d line, const char section, const char lvalue, int ltype, const char *rva
		lue, void data, void userdata);
		int config_parse_memory_limit(const char unit, const char filename, unsig
		ned line, const char section, const char lvalue, int ltype, const char *r
		value, void data, void userdata);
		int config_parse_device_policy(const char unit, const char filename, unsi
		gned line, const char section, const char lvalue, int ltype, const char *
		rvalue, void data, void userdata);
		int config_parse_device_allow(const char unit, const char filename, unsig
		ned line, const char section, const char lvalue, int ltype, const char *r
		value, void data, void userdata);
		int config_parse_blockio_weight(const char unit, const char filename, uns
		igned line, const char section, const char lvalue, int ltype, const char
		rvalue, void data, void *userdata);
		int config_parse_blockio_bandwidth(const char unit, const char filename,
		unsigned line, const char section, const char lvalue, int ltype, const ch
		ar rvalue, void data, void *userdata);

	/* gperf prototypes */	/* gperf prototypes */
	const struct ConfigPerfItem* load_fragment_gperf_lookup(const char *key, un signed length);	const struct ConfigPerfItem* load_fragment_gperf_lookup(const char *key, un signed length);
	extern const char load_fragment_gperf_nulstr[];	extern const char load_fragment_gperf_nulstr[];

End of changes. 3 change blocks.
	7 lines changed or deleted	21 lines changed or added

	id128-constants.h	id128-constants.h
	add_id(m, "SD_MESSAGE_JOURNAL_START", SD_MESSAGE_JOURNAL_START) JOINER	add_id(m, "SD_MESSAGE_JOURNAL_START", SD_MESSAGE_JOURNAL_START) JOINER
	add_id(m, "SD_MESSAGE_JOURNAL_STOP", SD_MESSAGE_JOURNAL_STOP) JOINER	add_id(m, "SD_MESSAGE_JOURNAL_STOP", SD_MESSAGE_JOURNAL_STOP) JOINER
	add_id(m, "SD_MESSAGE_JOURNAL_DROPPED", SD_MESSAGE_JOURNAL_DROPPED) JOINER	add_id(m, "SD_MESSAGE_JOURNAL_DROPPED", SD_MESSAGE_JOURNAL_DROPPED) JOINER
	add_id(m, "SD_MESSAGE_JOURNAL_MISSED", SD_MESSAGE_JOURNAL_MISSED) JOINER	add_id(m, "SD_MESSAGE_JOURNAL_MISSED", SD_MESSAGE_JOURNAL_MISSED) JOINER

		add_id(m, "SD_MESSAGE_JOURNAL_USAGE", SD_MESSAGE_JOURNAL_USAGE) JOINER
	add_id(m, "SD_MESSAGE_COREDUMP", SD_MESSAGE_COREDUMP) JOINER	add_id(m, "SD_MESSAGE_COREDUMP", SD_MESSAGE_COREDUMP) JOINER
	add_id(m, "SD_MESSAGE_SESSION_START", SD_MESSAGE_SESSION_START) JOINER	add_id(m, "SD_MESSAGE_SESSION_START", SD_MESSAGE_SESSION_START) JOINER
	add_id(m, "SD_MESSAGE_SESSION_STOP", SD_MESSAGE_SESSION_STOP) JOINER	add_id(m, "SD_MESSAGE_SESSION_STOP", SD_MESSAGE_SESSION_STOP) JOINER
	add_id(m, "SD_MESSAGE_SEAT_START", SD_MESSAGE_SEAT_START) JOINER	add_id(m, "SD_MESSAGE_SEAT_START", SD_MESSAGE_SEAT_START) JOINER
	add_id(m, "SD_MESSAGE_SEAT_STOP", SD_MESSAGE_SEAT_STOP) JOINER	add_id(m, "SD_MESSAGE_SEAT_STOP", SD_MESSAGE_SEAT_STOP) JOINER

		add_id(m, "SD_MESSAGE_MACHINE_START", SD_MESSAGE_MACHINE_START) JOINER
		add_id(m, "SD_MESSAGE_MACHINE_STOP", SD_MESSAGE_MACHINE_STOP) JOINER
	add_id(m, "SD_MESSAGE_TIME_CHANGE", SD_MESSAGE_TIME_CHANGE) JOINER	add_id(m, "SD_MESSAGE_TIME_CHANGE", SD_MESSAGE_TIME_CHANGE) JOINER
	add_id(m, "SD_MESSAGE_TIMEZONE_CHANGE", SD_MESSAGE_TIMEZONE_CHANGE) JOINER	add_id(m, "SD_MESSAGE_TIMEZONE_CHANGE", SD_MESSAGE_TIMEZONE_CHANGE) JOINER
	add_id(m, "SD_MESSAGE_STARTUP_FINISHED", SD_MESSAGE_STARTUP_FINISHED) JOINE R	add_id(m, "SD_MESSAGE_STARTUP_FINISHED", SD_MESSAGE_STARTUP_FINISHED) JOINE R
	add_id(m, "SD_MESSAGE_SLEEP_START", SD_MESSAGE_SLEEP_START) JOINER	add_id(m, "SD_MESSAGE_SLEEP_START", SD_MESSAGE_SLEEP_START) JOINER
	add_id(m, "SD_MESSAGE_SLEEP_STOP", SD_MESSAGE_SLEEP_STOP) JOINER	add_id(m, "SD_MESSAGE_SLEEP_STOP", SD_MESSAGE_SLEEP_STOP) JOINER
	add_id(m, "SD_MESSAGE_SHUTDOWN", SD_MESSAGE_SHUTDOWN) JOINER	add_id(m, "SD_MESSAGE_SHUTDOWN", SD_MESSAGE_SHUTDOWN) JOINER
	add_id(m, "SD_MESSAGE_UNIT_STARTING", SD_MESSAGE_UNIT_STARTING) JOINER	add_id(m, "SD_MESSAGE_UNIT_STARTING", SD_MESSAGE_UNIT_STARTING) JOINER
	add_id(m, "SD_MESSAGE_UNIT_STARTED", SD_MESSAGE_UNIT_STARTED) JOINER	add_id(m, "SD_MESSAGE_UNIT_STARTED", SD_MESSAGE_UNIT_STARTED) JOINER
	add_id(m, "SD_MESSAGE_UNIT_STOPPING", SD_MESSAGE_UNIT_STOPPING) JOINER	add_id(m, "SD_MESSAGE_UNIT_STOPPING", SD_MESSAGE_UNIT_STOPPING) JOINER
	add_id(m, "SD_MESSAGE_UNIT_STOPPED", SD_MESSAGE_UNIT_STOPPED) JOINER	add_id(m, "SD_MESSAGE_UNIT_STOPPED", SD_MESSAGE_UNIT_STOPPED) JOINER

End of changes. 2 change blocks.
	0 lines changed or deleted	3 lines changed or added

	libudev.h	libudev.h

	skipping to change at line 84	skipping to change at line 84
	*	*
	* access to sysfs/kernel devices	* access to sysfs/kernel devices
	*/	*/
	struct udev_device;	struct udev_device;
	struct udev_device udev_device_ref(struct udev_device udev_device);	struct udev_device udev_device_ref(struct udev_device udev_device);
	struct udev_device udev_device_unref(struct udev_device udev_device);	struct udev_device udev_device_unref(struct udev_device udev_device);
	struct udev udev_device_get_udev(struct udev_device udev_device);	struct udev udev_device_get_udev(struct udev_device udev_device);
	struct udev_device udev_device_new_from_syspath(struct udev udev, const c har *syspath);	struct udev_device udev_device_new_from_syspath(struct udev udev, const c har *syspath);
	struct udev_device udev_device_new_from_devnum(struct udev udev, char typ e, dev_t devnum);	struct udev_device udev_device_new_from_devnum(struct udev udev, char typ e, dev_t devnum);
	struct udev_device udev_device_new_from_subsystem_sysname(struct udev ude v, const char subsystem, const char sysname);	struct udev_device udev_device_new_from_subsystem_sysname(struct udev ude v, const char subsystem, const char sysname);

	struct udev_device udev_device_new_from_device_id(struct udev udev, char *id);	struct udev_device udev_device_new_from_device_id(struct udev udev, const char *id);
	struct udev_device udev_device_new_from_environment(struct udev udev);	struct udev_device udev_device_new_from_environment(struct udev udev);
	/* udev_device_get_parent_() does not take a reference on the returned dev ice, it is automatically unref'd with the parent /	/* udev_device_get_parent_() does not take a reference on the returned dev ice, it is automatically unref'd with the parent /
	struct udev_device udev_device_get_parent(struct udev_device udev_device) ;	struct udev_device udev_device_get_parent(struct udev_device udev_device) ;
	struct udev_device udev_device_get_parent_with_subsystem_devtype(struct ud ev_device udev_device,	struct udev_device udev_device_get_parent_with_subsystem_devtype(struct ud ev_device udev_device,
	const cha r subsystem, const char devtype);	const cha r subsystem, const char devtype);
	/* retrieve device properties */	/* retrieve device properties */
	const char udev_device_get_devpath(struct udev_device udev_device);	const char udev_device_get_devpath(struct udev_device udev_device);
	const char udev_device_get_subsystem(struct udev_device udev_device);	const char udev_device_get_subsystem(struct udev_device udev_device);
	const char udev_device_get_devtype(struct udev_device udev_device);	const char udev_device_get_devtype(struct udev_device udev_device);
	const char udev_device_get_syspath(struct udev_device udev_device);	const char udev_device_get_syspath(struct udev_device udev_device);

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added

	sd-login.h	sd-login.h

	skipping to change at line 75	skipping to change at line 75
	/* Get systemd unit (i.e. service) name from PID, for system	/* Get systemd unit (i.e. service) name from PID, for system
	* services. This will return an error for non-service processes. */	* services. This will return an error for non-service processes. */
	int sd_pid_get_unit(pid_t pid, char **unit);	int sd_pid_get_unit(pid_t pid, char **unit);

	/* Get systemd unit (i.e. service) name from PID, for user	/* Get systemd unit (i.e. service) name from PID, for user
	* services. This will return an error for non-user-service	* services. This will return an error for non-user-service
	* processes. */	* processes. */
	int sd_pid_get_user_unit(pid_t pid, char **unit);	int sd_pid_get_user_unit(pid_t pid, char **unit);

	/* Get machine name from PID, for processes assigned to VM or	/* Get machine name from PID, for processes assigned to VM or

	* container. This will return an error for non-service processes. */	* container. This will return an error for non-machine processes. */
	int sd_pid_get_machine_name(pid_t pid, char **name);	int sd_pid_get_machine_name(pid_t pid, char **name);


		/* Get slice name from PID. */
		int sd_pid_get_slice(pid_t pid, char **name);

	/* Get state from uid. Possible states: offline, lingering, online, active, closing */	/* Get state from uid. Possible states: offline, lingering, online, active, closing */
	int sd_uid_get_state(uid_t uid, char**state);	int sd_uid_get_state(uid_t uid, char**state);

	/* Return 1 if uid has session on seat. If require_active is true will	/* Return 1 if uid has session on seat. If require_active is true will
	* look for active sessions only. */	* look for active sessions only. */
	int sd_uid_is_on_seat(uid_t uid, int require_active, const char *seat);	int sd_uid_is_on_seat(uid_t uid, int require_active, const char *seat);

	/* Return sessions of user. If require_active is true will look for	/* Return sessions of user. If require_active is true will look for
	* active sessions only. Returns number of sessions as return	* active sessions only. Returns number of sessions as return
	* value. If sessions is NULL will just return number of sessions. */	* value. If sessions is NULL will just return number of sessions. */

End of changes. 2 change blocks.
	1 lines changed or deleted	4 lines changed or added

	udev.h	udev.h

	skipping to change at line 193	skipping to change at line 193
	extern const struct udev_builtin udev_builtin_uaccess;	extern const struct udev_builtin udev_builtin_uaccess;
	void udev_builtin_init(struct udev *udev);	void udev_builtin_init(struct udev *udev);
	void udev_builtin_exit(struct udev *udev);	void udev_builtin_exit(struct udev *udev);
	enum udev_builtin_cmd udev_builtin_lookup(const char *command);	enum udev_builtin_cmd udev_builtin_lookup(const char *command);
	const char *udev_builtin_name(enum udev_builtin_cmd cmd);	const char *udev_builtin_name(enum udev_builtin_cmd cmd);
	bool udev_builtin_run_once(enum udev_builtin_cmd cmd);	bool udev_builtin_run_once(enum udev_builtin_cmd cmd);
	int udev_builtin_run(struct udev_device dev, enum udev_builtin_cmd cmd, co nst char command, bool test);	int udev_builtin_run(struct udev_device dev, enum udev_builtin_cmd cmd, co nst char command, bool test);
	void udev_builtin_list(struct udev *udev);	void udev_builtin_list(struct udev *udev);
	bool udev_builtin_validate(struct udev *udev);	bool udev_builtin_validate(struct udev *udev);
	int udev_builtin_add_property(struct udev_device dev, bool test, const cha r key, const char *val);	int udev_builtin_add_property(struct udev_device dev, bool test, const cha r key, const char *val);

	int udev_builtin_hwdb_lookup(struct udev_device dev, const char modalias, bool test);	int udev_builtin_hwdb_lookup(struct udev_device dev, const char modalias, const char *filter, bool test);

	/* udev logging */	/* udev logging */
	void udev_main_log(struct udev *udev, int priority,	void udev_main_log(struct udev *udev, int priority,
	const char file, int line, const char fn,	const char file, int line, const char fn,
	const char *format, va_list args) _printf_attr_(6, 0);	const char *format, va_list args) _printf_attr_(6, 0);

	/* udevadm commands */	/* udevadm commands */
	struct udevadm_cmd {	struct udevadm_cmd {
	const char *name;	const char *name;
	int (cmd)(struct udev udev, int argc, char *argv[]);	int (cmd)(struct udev udev, int argc, char *argv[]);

End of changes. 1 change blocks.
	1 lines changed or deleted	1 lines changed or added