litmus-rt.git - The LITMUS^RT kernel.

diff options

author	Jonathan Nieder <jrnieder@gmail.com>	2009-11-24 10:21:56 -0500
committer	Michal Marek <mmarek@suse.cz>	2009-12-12 07:08:16 -0500
commit	db1d18657c96cc675596077cb60ef50fbe1947f8 (patch)
tree	14f38c412bb0bee19c0f536fdb22c17b1965a48b /scripts/package
parent	05ba4488a51edde95df3f89987fdcdbca7c3cebb (diff)

scripts/package: deb-pkg: use fakeroot if available

Running "make deb-pkg" requires setting KBUILD_PKG_ROOTCMD or becoming root oneself or it errors out. Unless already running as root or KBUILD_PKG_ROOTCMD is already set, use fakeroot as a good default. With this patch applied, you can run "make oldconfig deb-pkg" as an ordinary user to build a binary package for an updated kernel tree and it should just work. fakeroot is too zealous by default in treating files as owned by root. Its wrapped stat() sets st_uid and st_gid to 0 for all files, which causes Git to go on a wild goose chase if CONFIG_LOCALVERSION_AUTO is set, checking if any file's content has changed along with its stat information. Avoid this by telling fakeroot to use the actual owner and group for preexisting files, by passing it the -u option. Signed-off-by: Jonathan Nieder <jrnieder@gmail.com> Signed-off-by: Michal Marek <mmarek@suse.cz>

Diffstat (limited to 'scripts/package')

-rw-r--r--

scripts/package/Makefile

1 files changed, 19 insertions, 2 deletions


diff --git a/scripts/package/Makefile b/scripts/package/Makefile index 5c0b43aaf63b..62fcc3a7f4d3 100644 --- a/scripts/package/Makefile +++ b/scripts/package/Makefile
@@ -77,10 +77,27 @@ clean-files += $(objtree)/binkernel.spec
77		77
78	# Deb target	78	# Deb target
79	# ---------------------------------------------------------------------------	79	# ---------------------------------------------------------------------------
		80	quiet_cmd_builddeb = BUILDDEB
		81	cmd_builddeb = set -e; \
		82	test `id -u` = 0 \|\| \
		83	test -n "$(KBUILD_PKG_ROOTCMD)" \|\| { \
		84	which fakeroot >/dev/null 2>&1 && \
		85	KBUILD_PKG_ROOTCMD="fakeroot -u"; \
		86	} \|\| { \
		87	echo; \
		88	echo "builddeb must be run as root (or using fakeroot)."; \
		89	echo "KBUILD_PKG_ROOTCMD is unset and fakeroot not found."; \
		90	echo "Try setting KBUILD_PKG_ROOTCMD to a command to acquire"; \
		91	echo "root privileges (e.g., 'fakeroot -u' or 'sudo')."; \
		92	false; \
		93	} && \
		94	\
		95	$$KBUILD_PKG_ROOTCMD $(CONFIG_SHELL) \
		96	$(srctree)/scripts/package/builddeb
		97
80	deb-pkg: FORCE	98	deb-pkg: FORCE
81	$(MAKE) KBUILD_SRC=	99	$(MAKE) KBUILD_SRC=
82	$(KBUILD_PKG_ROOTCMD) $(CONFIG_SHELL) \	100	$(call cmd,builddeb)
83	$(srctree)/scripts/package/builddeb
84		101
85	clean-dirs += $(objtree)/debian/	102	clean-dirs += $(objtree)/debian/
86		103

214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267

/* * IPV4 GSO/GRO offload support * Linux INET implementation * * Copyright (C) 2016 secunet Security Networks AG * Author: Steffen Klassert <steffen.klassert@secunet.com> * * This program is free software; you can redistribute it and/or modify it * under the terms and conditions of the GNU General Public License, * version 2, as published by the Free Software Foundation. * * ESP GRO support */ #include <linux/skbuff.h> #include <linux/init.h> #include <net/protocol.h> #include <crypto/aead.h> #include <crypto/authenc.h> #include <linux/err.h> #include <linux/module.h> #include <net/ip.h> #include <net/xfrm.h> #include <net/esp.h> #include <linux/scatterlist.h> #include <linux/kernel.h> #include <linux/slab.h> #include <linux/spinlock.h> #include <net/udp.h> static struct sk_buff **esp4_gro_receive(struct sk_buff **head, struct sk_buff *skb) { int offset = skb_gro_offset(skb); struct xfrm_offload *xo; struct xfrm_state *x; __be32 seq; __be32 spi; int err; skb_pull(skb, offset); if ((err = xfrm_parse_spi(skb, IPPROTO_ESP, &spi, &seq)) != 0) goto out; xo = xfrm_offload(skb); if (!xo || !(xo->flags & CRYPTO_DONE)) { err = secpath_set(skb); if (err) goto out; if (skb->sp->len == XFRM_MAX_DEPTH) goto out; x = xfrm_state_lookup(dev_net(skb->dev), skb->mark, (xfrm_address_t *)&ip_hdr(skb)->daddr, spi, IPPROTO_ESP, AF_INET); if (!x) goto out; skb->sp->xvec[skb->sp->len++] = x; skb->sp->olen++; xo = xfrm_offload(skb); if (!xo) { xfrm_state_put(x); goto out; } } xo->flags |= XFRM_GRO; XFRM_TUNNEL_SKB_CB(skb)->tunnel.ip4 = NULL; XFRM_SPI_SKB_CB(skb)->family = AF_INET; XFRM_SPI_SKB_CB(skb)->daddroff = offsetof(struct iphdr, daddr); XFRM_SPI_SKB_CB(skb)->seq = seq; /* We don't need to handle errors from xfrm_input, it does all * the error handling and frees the resources on error. */ xfrm_input(skb, IPPROTO_ESP, spi, -2); return ERR_PTR(-EINPROGRESS); out: skb_push(skb, offset); NAPI_GRO_CB(skb)->same_flow = 0; NAPI_GRO_CB(skb)->flush = 1; return NULL; } static void esp4_gso_encap(struct xfrm_state *x, struct sk_buff *skb) { struct ip_esp_hdr *esph; struct iphdr *iph = ip_hdr(skb); struct xfrm_offload *xo = xfrm_offload(skb); int proto = iph->protocol; skb_push(skb, -skb_network_offset(skb)); esph = ip_esp_hdr(skb); *skb_mac_header(skb) = IPPROTO_ESP; esph->spi = x->id.spi; esph->seq_no = htonl(XFRM_SKB_CB(skb)->seq.output.low); xo->proto = proto; } static struct sk_buff *esp4_gso_segment(struct sk_buff *skb, netdev_features_t features) { __u32 seq; int err = 0; struct sk_buff *skb2; struct xfrm_state *x; struct ip_esp_hdr *esph; struct crypto_aead *aead; struct sk_buff *segs = ERR_PTR(-EINVAL); netdev_features_t esp_features = features; struct xfrm_offload *xo = xfrm_offload(skb); if (!xo) goto out; seq = xo->seq.low; x = skb->sp->xvec[skb->sp->len - 1]; aead = x->data; esph = ip_esp_hdr(skb); if (esph->spi != x->id.spi) goto out; if (!pskb_may_pull(skb, sizeof(*esph) + crypto_aead_ivsize(aead))) goto out; __skb_pull(skb, sizeof(*esph) + crypto_aead_ivsize(aead)); skb->encap_hdr_csum = 1; if (!(features & NETIF_F_HW_ESP)) esp_features = features & ~(NETIF_F_SG | NETIF_F_CSUM_MASK); segs = x->outer_mode->gso_segment(x, skb, esp_features); if (IS_ERR_OR_NULL(segs)) goto out; __skb_pull(skb, skb->data - skb_mac_header(skb)); skb2 = segs; do { struct sk_buff *nskb = skb2->next; xo = xfrm_offload(skb2); xo->flags |= XFRM_GSO_SEGMENT; xo->seq.low = seq; xo->seq.hi = xfrm_replay_seqhi(x, seq); if(!(features & NETIF_F_HW_ESP)) xo->flags |= CRYPTO_FALLBACK; x->outer_mode->xmit(x, skb2); err = x->type_offload->xmit(x, skb2, esp_features); if (err) { kfree_skb_list(segs); return ERR_PTR(err); } if (!skb_is_gso(skb2)) seq++; else seq += skb_shinfo(skb2)->gso_segs; skb_push(skb2, skb2->mac_len); skb2 = nskb; } while (skb2); out: return segs; } static int esp_input_tail(struct xfrm_state *x, struct sk_buff *skb) { struct crypto_aead *aead = x->data; if (!pskb_may_pull(skb, sizeof(struct ip_esp_hdr) + crypto_aead_ivsize(aead))) return -EINVAL; skb->ip_summed = CHECKSUM_NONE; return esp_input_done2(skb, 0); } static int esp_xmit(struct xfrm_state *x, struct sk_buff *skb, netdev_features_t features) { int err; int alen; int blksize; struct xfrm_offload *xo; struct ip_esp_hdr *esph; struct crypto_aead *aead; struct esp_info esp; bool hw_offload = true; esp.inplace = true; xo = xfrm_offload(skb); if (!xo) return -EINVAL; if (!(features & NETIF_F_HW_ESP) || !x->xso.offload_handle || (x->xso.dev != skb->dev)) { xo->flags |= CRYPTO_FALLBACK; hw_offload = false; } esp.proto = xo->proto; /* skb is pure payload to encrypt */ aead = x->data; alen = crypto_aead_authsize(aead); esp.tfclen = 0; /* XXX: Add support for tfc padding here. */ blksize = ALIGN(crypto_aead_blocksize(aead), 4); esp.clen = ALIGN(skb->len + 2 + esp.tfclen, blksize); esp.plen = esp.clen - skb->len - esp.tfclen; esp.tailen = esp.tfclen + esp.plen + alen; esp.esph = ip_esp_hdr(skb); if (!hw_offload || (hw_offload && !skb_is_gso(skb))) { esp.nfrags = esp_output_head(x, skb, &esp); if (esp.nfrags < 0) return esp.nfrags; } esph = esp.esph; esph->spi = x->id.spi; skb_push(skb, -skb_network_offset(skb)); if (xo->flags & XFRM_GSO_SEGMENT) { esph->seq_no = htonl(xo->seq.low); } else { ip_hdr(skb)->tot_len = htons(skb->len); ip_send_check(ip_hdr(skb)); } if (hw_offload) return 0; esp.seqno = cpu_to_be64(xo->seq.low + ((u64)xo->seq.hi << 32)); err = esp_output_tail(x, skb, &esp); if (err < 0) return err; secpath_reset(skb); return 0; } static const struct net_offload esp4_offload = { .callbacks = { .gro_receive = esp4_gro_receive, .gso_segment = esp4_gso_segment, }, }; static const struct xfrm_type_offload esp_type_offload = { .description = "ESP4 OFFLOAD", .owner = THIS_MODULE, .proto = IPPROTO_ESP, .input_tail = esp_input_tail, .xmit = esp_xmit, .encap = esp4_gso_encap, }; static int __init esp4_offload_init(void) { if (xfrm_register_type_offload(&esp_type_offload, AF_INET) < 0) { pr_info("%s: can't add xfrm type offload\n", __func__); return -EAGAIN; } return inet_add_offload(&esp4_offload, IPPROTO_ESP); } static void __exit esp4_offload_exit(void) { if (xfrm_unregister_type_offload(&esp_type_offload, AF_INET) < 0) pr_info("%s: can't remove xfrm type offload\n", __func__); inet_del_offload(&esp4_offload, IPPROTO_ESP); } module_init(esp4_offload_init); module_exit(esp4_offload_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("Steffen Klassert <steffen.klassert@secunet.com>");


context:
space:
mode: