Split (1)

train · 7.74k rows

id stringlengths 25 30	content stringlengths 14 942k	max_stars_repo_path stringlengths 49 55
crossvul-cpp_data_good_5861_36	/* * Glue Code for AVX assembler versions of Serpent Cipher * * Copyright (C) 2012 Johannes Goetzfried * <Johannes.Goetzfried@informatik.stud.uni-erlangen.de> * * Copyright © 2011-2013 Jussi Kivilinna <jussi.kivilinna@iki.fi> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 * USA * / #include <linux/module.h> #include <linux/hardirq.h> #include <linux/types.h> #include <linux/crypto.h> #include <linux/err.h> #include <crypto/ablk_helper.h> #include <crypto/algapi.h> #include <crypto/serpent.h> #include <crypto/cryptd.h> #include <crypto/b128ops.h> #include <crypto/ctr.h> #include <crypto/lrw.h> #include <crypto/xts.h> #include <asm/xcr.h> #include <asm/xsave.h> #include <asm/crypto/serpent-avx.h> #include <asm/crypto/glue_helper.h> / 8-way parallel cipher functions / asmlinkage void serpent_ecb_enc_8way_avx(struct serpent_ctx ctx, u8 dst, const u8 src); EXPORT_SYMBOL_GPL(serpent_ecb_enc_8way_avx); asmlinkage void serpent_ecb_dec_8way_avx(struct serpent_ctx ctx, u8 dst, const u8 src); EXPORT_SYMBOL_GPL(serpent_ecb_dec_8way_avx); asmlinkage void serpent_cbc_dec_8way_avx(struct serpent_ctx ctx, u8 dst, const u8 src); EXPORT_SYMBOL_GPL(serpent_cbc_dec_8way_avx); asmlinkage void serpent_ctr_8way_avx(struct serpent_ctx ctx, u8 dst, const u8 src, le128 iv); EXPORT_SYMBOL_GPL(serpent_ctr_8way_avx); asmlinkage void serpent_xts_enc_8way_avx(struct serpent_ctx ctx, u8 dst, const u8 src, le128 iv); EXPORT_SYMBOL_GPL(serpent_xts_enc_8way_avx); asmlinkage void serpent_xts_dec_8way_avx(struct serpent_ctx ctx, u8 dst, const u8 src, le128 iv); EXPORT_SYMBOL_GPL(serpent_xts_dec_8way_avx); void __serpent_crypt_ctr(void ctx, u128 dst, const u128 src, le128 iv) { be128 ctrblk; le128_to_be128(&ctrblk, iv); le128_inc(iv); __serpent_encrypt(ctx, (u8 )&ctrblk, (u8 )&ctrblk); u128_xor(dst, src, (u128 )&ctrblk); } EXPORT_SYMBOL_GPL(__serpent_crypt_ctr); void serpent_xts_enc(void ctx, u128 dst, const u128 src, le128 iv) { glue_xts_crypt_128bit_one(ctx, dst, src, iv, GLUE_FUNC_CAST(__serpent_encrypt)); } EXPORT_SYMBOL_GPL(serpent_xts_enc); void serpent_xts_dec(void ctx, u128 dst, const u128 src, le128 iv) { glue_xts_crypt_128bit_one(ctx, dst, src, iv, GLUE_FUNC_CAST(__serpent_decrypt)); } EXPORT_SYMBOL_GPL(serpent_xts_dec); static const struct common_glue_ctx serpent_enc = { .num_funcs = 2, .fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS, .funcs = { { .num_blocks = SERPENT_PARALLEL_BLOCKS, .fn_u = { .ecb = GLUE_FUNC_CAST(serpent_ecb_enc_8way_avx) } }, { .num_blocks = 1, .fn_u = { .ecb = GLUE_FUNC_CAST(__serpent_encrypt) } } } }; static const struct common_glue_ctx serpent_ctr = { .num_funcs = 2, .fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS, .funcs = { { .num_blocks = SERPENT_PARALLEL_BLOCKS, .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(serpent_ctr_8way_avx) } }, { .num_blocks = 1, .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(__serpent_crypt_ctr) } } } }; static const struct common_glue_ctx serpent_enc_xts = { .num_funcs = 2, .fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS, .funcs = { { .num_blocks = SERPENT_PARALLEL_BLOCKS, .fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_enc_8way_avx) } }, { .num_blocks = 1, .fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_enc) } } } }; static const struct common_glue_ctx serpent_dec = { .num_funcs = 2, .fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS, .funcs = { { .num_blocks = SERPENT_PARALLEL_BLOCKS, .fn_u = { .ecb = GLUE_FUNC_CAST(serpent_ecb_dec_8way_avx) } }, { .num_blocks = 1, .fn_u = { .ecb = GLUE_FUNC_CAST(__serpent_decrypt) } } } }; static const struct common_glue_ctx serpent_dec_cbc = { .num_funcs = 2, .fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS, .funcs = { { .num_blocks = SERPENT_PARALLEL_BLOCKS, .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(serpent_cbc_dec_8way_avx) } }, { .num_blocks = 1, .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(__serpent_decrypt) } } } }; static const struct common_glue_ctx serpent_dec_xts = { .num_funcs = 2, .fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS, .funcs = { { .num_blocks = SERPENT_PARALLEL_BLOCKS, .fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_dec_8way_avx) } }, { .num_blocks = 1, .fn_u = { .xts = GLUE_XTS_FUNC_CAST(serpent_xts_dec) } } } }; static int ecb_encrypt(struct blkcipher_desc desc, struct scatterlist dst, struct scatterlist src, unsigned int nbytes) { return glue_ecb_crypt_128bit(&serpent_enc, desc, dst, src, nbytes); } static int ecb_decrypt(struct blkcipher_desc desc, struct scatterlist dst, struct scatterlist src, unsigned int nbytes) { return glue_ecb_crypt_128bit(&serpent_dec, desc, dst, src, nbytes); } static int cbc_encrypt(struct blkcipher_desc desc, struct scatterlist dst, struct scatterlist src, unsigned int nbytes) { return glue_cbc_encrypt_128bit(GLUE_FUNC_CAST(__serpent_encrypt), desc, dst, src, nbytes); } static int cbc_decrypt(struct blkcipher_desc desc, struct scatterlist dst, struct scatterlist src, unsigned int nbytes) { return glue_cbc_decrypt_128bit(&serpent_dec_cbc, desc, dst, src, nbytes); } static int ctr_crypt(struct blkcipher_desc desc, struct scatterlist dst, struct scatterlist src, unsigned int nbytes) { return glue_ctr_crypt_128bit(&serpent_ctr, desc, dst, src, nbytes); } static inline bool serpent_fpu_begin(bool fpu_enabled, unsigned int nbytes) { return glue_fpu_begin(SERPENT_BLOCK_SIZE, SERPENT_PARALLEL_BLOCKS, NULL, fpu_enabled, nbytes); } static inline void serpent_fpu_end(bool fpu_enabled) { glue_fpu_end(fpu_enabled); } struct crypt_priv { struct serpent_ctx ctx; bool fpu_enabled; }; static void encrypt_callback(void priv, u8 srcdst, unsigned int nbytes) { const unsigned int bsize = SERPENT_BLOCK_SIZE; struct crypt_priv ctx = priv; int i; ctx->fpu_enabled = serpent_fpu_begin(ctx->fpu_enabled, nbytes); if (nbytes == bsize * SERPENT_PARALLEL_BLOCKS) { serpent_ecb_enc_8way_avx(ctx->ctx, srcdst, srcdst); return; } for (i = 0; i < nbytes / bsize; i++, srcdst += bsize) __serpent_encrypt(ctx->ctx, srcdst, srcdst); } static void decrypt_callback(void priv, u8 srcdst, unsigned int nbytes) { const unsigned int bsize = SERPENT_BLOCK_SIZE; struct crypt_priv ctx = priv; int i; ctx->fpu_enabled = serpent_fpu_begin(ctx->fpu_enabled, nbytes); if (nbytes == bsize SERPENT_PARALLEL_BLOCKS) { serpent_ecb_dec_8way_avx(ctx->ctx, srcdst, srcdst); return; } for (i = 0; i < nbytes / bsize; i++, srcdst += bsize) __serpent_decrypt(ctx->ctx, srcdst, srcdst); } int lrw_serpent_setkey(struct crypto_tfm tfm, const u8 key, unsigned int keylen) { struct serpent_lrw_ctx ctx = crypto_tfm_ctx(tfm); int err; err = __serpent_setkey(&ctx->serpent_ctx, key, keylen - SERPENT_BLOCK_SIZE); if (err) return err; return lrw_init_table(&ctx->lrw_table, key + keylen - SERPENT_BLOCK_SIZE); } EXPORT_SYMBOL_GPL(lrw_serpent_setkey); static int lrw_encrypt(struct blkcipher_desc desc, struct scatterlist dst, struct scatterlist src, unsigned int nbytes) { struct serpent_lrw_ctx ctx = crypto_blkcipher_ctx(desc->tfm); be128 buf[SERPENT_PARALLEL_BLOCKS]; struct crypt_priv crypt_ctx = { .ctx = &ctx->serpent_ctx, .fpu_enabled = false, }; struct lrw_crypt_req req = { .tbuf = buf, .tbuflen = sizeof(buf), .table_ctx = &ctx->lrw_table, .crypt_ctx = &crypt_ctx, .crypt_fn = encrypt_callback, }; int ret; desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP; ret = lrw_crypt(desc, dst, src, nbytes, &req); serpent_fpu_end(crypt_ctx.fpu_enabled); return ret; } static int lrw_decrypt(struct blkcipher_desc desc, struct scatterlist dst, struct scatterlist src, unsigned int nbytes) { struct serpent_lrw_ctx ctx = crypto_blkcipher_ctx(desc->tfm); be128 buf[SERPENT_PARALLEL_BLOCKS]; struct crypt_priv crypt_ctx = { .ctx = &ctx->serpent_ctx, .fpu_enabled = false, }; struct lrw_crypt_req req = { .tbuf = buf, .tbuflen = sizeof(buf), .table_ctx = &ctx->lrw_table, .crypt_ctx = &crypt_ctx, .crypt_fn = decrypt_callback, }; int ret; desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP; ret = lrw_crypt(desc, dst, src, nbytes, &req); serpent_fpu_end(crypt_ctx.fpu_enabled); return ret; } void lrw_serpent_exit_tfm(struct crypto_tfm tfm) { struct serpent_lrw_ctx ctx = crypto_tfm_ctx(tfm); lrw_free_table(&ctx->lrw_table); } EXPORT_SYMBOL_GPL(lrw_serpent_exit_tfm); int xts_serpent_setkey(struct crypto_tfm tfm, const u8 key, unsigned int keylen) { struct serpent_xts_ctx ctx = crypto_tfm_ctx(tfm); u32 flags = &tfm->crt_flags; int err; / key consists of keys of equal size concatenated, therefore * the length must be even / if (keylen % 2) { flags \|= CRYPTO_TFM_RES_BAD_KEY_LEN; return -EINVAL; } /* first half of xts-key is for crypt / err = __serpent_setkey(&ctx->crypt_ctx, key, keylen / 2); if (err) return err; / second half of xts-key is for tweak / return __serpent_setkey(&ctx->tweak_ctx, key + keylen / 2, keylen / 2); } EXPORT_SYMBOL_GPL(xts_serpent_setkey); static int xts_encrypt(struct blkcipher_desc desc, struct scatterlist dst, struct scatterlist src, unsigned int nbytes) { struct serpent_xts_ctx ctx = crypto_blkcipher_ctx(desc->tfm); return glue_xts_crypt_128bit(&serpent_enc_xts, desc, dst, src, nbytes, XTS_TWEAK_CAST(__serpent_encrypt), &ctx->tweak_ctx, &ctx->crypt_ctx); } static int xts_decrypt(struct blkcipher_desc desc, struct scatterlist dst, struct scatterlist src, unsigned int nbytes) { struct serpent_xts_ctx ctx = crypto_blkcipher_ctx(desc->tfm); return glue_xts_crypt_128bit(&serpent_dec_xts, desc, dst, src, nbytes, XTS_TWEAK_CAST(__serpent_encrypt), &ctx->tweak_ctx, &ctx->crypt_ctx); } static struct crypto_alg serpent_algs[10] = { { .cra_name = "__ecb-serpent-avx", .cra_driver_name = "__driver-ecb-serpent-avx", .cra_priority = 0, .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, .cra_blocksize = SERPENT_BLOCK_SIZE, .cra_ctxsize = sizeof(struct serpent_ctx), .cra_alignmask = 0, .cra_type = &crypto_blkcipher_type, .cra_module = THIS_MODULE, .cra_u = { .blkcipher = { .min_keysize = SERPENT_MIN_KEY_SIZE, .max_keysize = SERPENT_MAX_KEY_SIZE, .setkey = serpent_setkey, .encrypt = ecb_encrypt, .decrypt = ecb_decrypt, }, }, }, { .cra_name = "__cbc-serpent-avx", .cra_driver_name = "__driver-cbc-serpent-avx", .cra_priority = 0, .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, .cra_blocksize = SERPENT_BLOCK_SIZE, .cra_ctxsize = sizeof(struct serpent_ctx), .cra_alignmask = 0, .cra_type = &crypto_blkcipher_type, .cra_module = THIS_MODULE, .cra_u = { .blkcipher = { .min_keysize = SERPENT_MIN_KEY_SIZE, .max_keysize = SERPENT_MAX_KEY_SIZE, .setkey = serpent_setkey, .encrypt = cbc_encrypt, .decrypt = cbc_decrypt, }, }, }, { .cra_name = "__ctr-serpent-avx", .cra_driver_name = "__driver-ctr-serpent-avx", .cra_priority = 0, .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, .cra_blocksize = 1, .cra_ctxsize = sizeof(struct serpent_ctx), .cra_alignmask = 0, .cra_type = &crypto_blkcipher_type, .cra_module = THIS_MODULE, .cra_u = { .blkcipher = { .min_keysize = SERPENT_MIN_KEY_SIZE, .max_keysize = SERPENT_MAX_KEY_SIZE, .ivsize = SERPENT_BLOCK_SIZE, .setkey = serpent_setkey, .encrypt = ctr_crypt, .decrypt = ctr_crypt, }, }, }, { .cra_name = "__lrw-serpent-avx", .cra_driver_name = "__driver-lrw-serpent-avx", .cra_priority = 0, .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, .cra_blocksize = SERPENT_BLOCK_SIZE, .cra_ctxsize = sizeof(struct serpent_lrw_ctx), .cra_alignmask = 0, .cra_type = &crypto_blkcipher_type, .cra_module = THIS_MODULE, .cra_exit = lrw_serpent_exit_tfm, .cra_u = { .blkcipher = { .min_keysize = SERPENT_MIN_KEY_SIZE + SERPENT_BLOCK_SIZE, .max_keysize = SERPENT_MAX_KEY_SIZE + SERPENT_BLOCK_SIZE, .ivsize = SERPENT_BLOCK_SIZE, .setkey = lrw_serpent_setkey, .encrypt = lrw_encrypt, .decrypt = lrw_decrypt, }, }, }, { .cra_name = "__xts-serpent-avx", .cra_driver_name = "__driver-xts-serpent-avx", .cra_priority = 0, .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, .cra_blocksize = SERPENT_BLOCK_SIZE, .cra_ctxsize = sizeof(struct serpent_xts_ctx), .cra_alignmask = 0, .cra_type = &crypto_blkcipher_type, .cra_module = THIS_MODULE, .cra_u = { .blkcipher = { .min_keysize = SERPENT_MIN_KEY_SIZE 2, .max_keysize = SERPENT_MAX_KEY_SIZE * 2, .ivsize = SERPENT_BLOCK_SIZE, .setkey = xts_serpent_setkey, .encrypt = xts_encrypt, .decrypt = xts_decrypt, }, }, }, { .cra_name = "ecb(serpent)", .cra_driver_name = "ecb-serpent-avx", .cra_priority = 500, .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \| CRYPTO_ALG_ASYNC, .cra_blocksize = SERPENT_BLOCK_SIZE, .cra_ctxsize = sizeof(struct async_helper_ctx), .cra_alignmask = 0, .cra_type = &crypto_ablkcipher_type, .cra_module = THIS_MODULE, .cra_init = ablk_init, .cra_exit = ablk_exit, .cra_u = { .ablkcipher = { .min_keysize = SERPENT_MIN_KEY_SIZE, .max_keysize = SERPENT_MAX_KEY_SIZE, .setkey = ablk_set_key, .encrypt = ablk_encrypt, .decrypt = ablk_decrypt, }, }, }, { .cra_name = "cbc(serpent)", .cra_driver_name = "cbc-serpent-avx", .cra_priority = 500, .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \| CRYPTO_ALG_ASYNC, .cra_blocksize = SERPENT_BLOCK_SIZE, .cra_ctxsize = sizeof(struct async_helper_ctx), .cra_alignmask = 0, .cra_type = &crypto_ablkcipher_type, .cra_module = THIS_MODULE, .cra_init = ablk_init, .cra_exit = ablk_exit, .cra_u = { .ablkcipher = { .min_keysize = SERPENT_MIN_KEY_SIZE, .max_keysize = SERPENT_MAX_KEY_SIZE, .ivsize = SERPENT_BLOCK_SIZE, .setkey = ablk_set_key, .encrypt = __ablk_encrypt, .decrypt = ablk_decrypt, }, }, }, { .cra_name = "ctr(serpent)", .cra_driver_name = "ctr-serpent-avx", .cra_priority = 500, .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \| CRYPTO_ALG_ASYNC, .cra_blocksize = 1, .cra_ctxsize = sizeof(struct async_helper_ctx), .cra_alignmask = 0, .cra_type = &crypto_ablkcipher_type, .cra_module = THIS_MODULE, .cra_init = ablk_init, .cra_exit = ablk_exit, .cra_u = { .ablkcipher = { .min_keysize = SERPENT_MIN_KEY_SIZE, .max_keysize = SERPENT_MAX_KEY_SIZE, .ivsize = SERPENT_BLOCK_SIZE, .setkey = ablk_set_key, .encrypt = ablk_encrypt, .decrypt = ablk_encrypt, .geniv = "chainiv", }, }, }, { .cra_name = "lrw(serpent)", .cra_driver_name = "lrw-serpent-avx", .cra_priority = 500, .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \| CRYPTO_ALG_ASYNC, .cra_blocksize = SERPENT_BLOCK_SIZE, .cra_ctxsize = sizeof(struct async_helper_ctx), .cra_alignmask = 0, .cra_type = &crypto_ablkcipher_type, .cra_module = THIS_MODULE, .cra_init = ablk_init, .cra_exit = ablk_exit, .cra_u = { .ablkcipher = { .min_keysize = SERPENT_MIN_KEY_SIZE + SERPENT_BLOCK_SIZE, .max_keysize = SERPENT_MAX_KEY_SIZE + SERPENT_BLOCK_SIZE, .ivsize = SERPENT_BLOCK_SIZE, .setkey = ablk_set_key, .encrypt = ablk_encrypt, .decrypt = ablk_decrypt, }, }, }, { .cra_name = "xts(serpent)", .cra_driver_name = "xts-serpent-avx", .cra_priority = 500, .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \| CRYPTO_ALG_ASYNC, .cra_blocksize = SERPENT_BLOCK_SIZE, .cra_ctxsize = sizeof(struct async_helper_ctx), .cra_alignmask = 0, .cra_type = &crypto_ablkcipher_type, .cra_module = THIS_MODULE, .cra_init = ablk_init, .cra_exit = ablk_exit, .cra_u = { .ablkcipher = { .min_keysize = SERPENT_MIN_KEY_SIZE * 2, .max_keysize = SERPENT_MAX_KEY_SIZE * 2, .ivsize = SERPENT_BLOCK_SIZE, .setkey = ablk_set_key, .encrypt = ablk_encrypt, .decrypt = ablk_decrypt, }, }, } }; static int __init serpent_init(void) { u64 xcr0; if (!cpu_has_avx \|\| !cpu_has_osxsave) { printk(KERN_INFO "AVX instructions are not detected.\n"); return -ENODEV; } xcr0 = xgetbv(XCR_XFEATURE_ENABLED_MASK); if ((xcr0 & (XSTATE_SSE \| XSTATE_YMM)) != (XSTATE_SSE \| XSTATE_YMM)) { printk(KERN_INFO "AVX detected but unusable.\n"); return -ENODEV; } return crypto_register_algs(serpent_algs, ARRAY_SIZE(serpent_algs)); } static void __exit serpent_exit(void) { crypto_unregister_algs(serpent_algs, ARRAY_SIZE(serpent_algs)); } module_init(serpent_init); module_exit(serpent_exit); MODULE_DESCRIPTION("Serpent Cipher Algorithm, AVX optimized"); MODULE_LICENSE("GPL"); MODULE_ALIAS_CRYPTO("serpent");	./CrossVul/dataset_final_sorted/CWE-264/c/good_5861_36
crossvul-cpp_data_bad_5078_1	/* * Packet matching code for ARP packets. * * Based heavily, if not almost entirely, upon ip_tables.c framework. * * Some ARP specific bits are: * * Copyright (C) 2002 David S. Miller (davem@redhat.com) * Copyright (C) 2006-2009 Patrick McHardy <kaber@trash.net> * / #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #include <linux/kernel.h> #include <linux/skbuff.h> #include <linux/netdevice.h> #include <linux/capability.h> #include <linux/if_arp.h> #include <linux/kmod.h> #include <linux/vmalloc.h> #include <linux/proc_fs.h> #include <linux/module.h> #include <linux/init.h> #include <linux/mutex.h> #include <linux/err.h> #include <net/compat.h> #include <net/sock.h> #include <asm/uaccess.h> #include <linux/netfilter/x_tables.h> #include <linux/netfilter_arp/arp_tables.h> #include "../../netfilter/xt_repldata.h" MODULE_LICENSE("GPL"); MODULE_AUTHOR("David S. Miller <davem@redhat.com>"); MODULE_DESCRIPTION("arptables core"); /#define DEBUG_ARP_TABLES/ /#define DEBUG_ARP_TABLES_USER/ #ifdef DEBUG_ARP_TABLES #define dprintf(format, args...) pr_debug(format, ## args) #else #define dprintf(format, args...) #endif #ifdef DEBUG_ARP_TABLES_USER #define duprintf(format, args...) pr_debug(format, ## args) #else #define duprintf(format, args...) #endif #ifdef CONFIG_NETFILTER_DEBUG #define ARP_NF_ASSERT(x) WARN_ON(!(x)) #else #define ARP_NF_ASSERT(x) #endif void arpt_alloc_initial_table(const struct xt_table info) { return xt_alloc_initial_table(arpt, ARPT); } EXPORT_SYMBOL_GPL(arpt_alloc_initial_table); static inline int arp_devaddr_compare(const struct arpt_devaddr_info ap, const char hdr_addr, int len) { int i, ret; if (len > ARPT_DEV_ADDR_LEN_MAX) len = ARPT_DEV_ADDR_LEN_MAX; ret = 0; for (i = 0; i < len; i++) ret \|= (hdr_addr[i] ^ ap->addr[i]) & ap->mask[i]; return ret != 0; } / * Unfortunately, _b and _mask are not aligned to an int (or long int) * Some arches dont care, unrolling the loop is a win on them. * For other arches, we only have a 16bit alignement. / static unsigned long ifname_compare(const char _a, const char _b, const char _mask) { #ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS unsigned long ret = ifname_compare_aligned(_a, _b, _mask); #else unsigned long ret = 0; const u16 a = (const u16 )_a; const u16 b = (const u16 )_b; const u16 mask = (const u16 )_mask; int i; for (i = 0; i < IFNAMSIZ/sizeof(u16); i++) ret \|= (a[i] ^ b[i]) & mask[i]; #endif return ret; } /* Returns whether packet matches rule or not. / static inline int arp_packet_match(const struct arphdr arphdr, struct net_device dev, const char indev, const char outdev, const struct arpt_arp arpinfo) { const char arpptr = (char )(arphdr + 1); const char src_devaddr, tgt_devaddr; __be32 src_ipaddr, tgt_ipaddr; long ret; #define FWINV(bool, invflg) ((bool) ^ !!(arpinfo->invflags & (invflg))) if (FWINV((arphdr->ar_op & arpinfo->arpop_mask) != arpinfo->arpop, ARPT_INV_ARPOP)) { dprintf("ARP operation field mismatch.\n"); dprintf("ar_op: %04x info->arpop: %04x info->arpop_mask: %04x\n", arphdr->ar_op, arpinfo->arpop, arpinfo->arpop_mask); return 0; } if (FWINV((arphdr->ar_hrd & arpinfo->arhrd_mask) != arpinfo->arhrd, ARPT_INV_ARPHRD)) { dprintf("ARP hardware address format mismatch.\n"); dprintf("ar_hrd: %04x info->arhrd: %04x info->arhrd_mask: %04x\n", arphdr->ar_hrd, arpinfo->arhrd, arpinfo->arhrd_mask); return 0; } if (FWINV((arphdr->ar_pro & arpinfo->arpro_mask) != arpinfo->arpro, ARPT_INV_ARPPRO)) { dprintf("ARP protocol address format mismatch.\n"); dprintf("ar_pro: %04x info->arpro: %04x info->arpro_mask: %04x\n", arphdr->ar_pro, arpinfo->arpro, arpinfo->arpro_mask); return 0; } if (FWINV((arphdr->ar_hln & arpinfo->arhln_mask) != arpinfo->arhln, ARPT_INV_ARPHLN)) { dprintf("ARP hardware address length mismatch.\n"); dprintf("ar_hln: %02x info->arhln: %02x info->arhln_mask: %02x\n", arphdr->ar_hln, arpinfo->arhln, arpinfo->arhln_mask); return 0; } src_devaddr = arpptr; arpptr += dev->addr_len; memcpy(&src_ipaddr, arpptr, sizeof(u32)); arpptr += sizeof(u32); tgt_devaddr = arpptr; arpptr += dev->addr_len; memcpy(&tgt_ipaddr, arpptr, sizeof(u32)); if (FWINV(arp_devaddr_compare(&arpinfo->src_devaddr, src_devaddr, dev->addr_len), ARPT_INV_SRCDEVADDR) \|\| FWINV(arp_devaddr_compare(&arpinfo->tgt_devaddr, tgt_devaddr, dev->addr_len), ARPT_INV_TGTDEVADDR)) { dprintf("Source or target device address mismatch.\n"); return 0; } if (FWINV((src_ipaddr & arpinfo->smsk.s_addr) != arpinfo->src.s_addr, ARPT_INV_SRCIP) \|\| FWINV(((tgt_ipaddr & arpinfo->tmsk.s_addr) != arpinfo->tgt.s_addr), ARPT_INV_TGTIP)) { dprintf("Source or target IP address mismatch.\n"); dprintf("SRC: %pI4. Mask: %pI4. Target: %pI4.%s\n", &src_ipaddr, &arpinfo->smsk.s_addr, &arpinfo->src.s_addr, arpinfo->invflags & ARPT_INV_SRCIP ? " (INV)" : ""); dprintf("TGT: %pI4 Mask: %pI4 Target: %pI4.%s\n", &tgt_ipaddr, &arpinfo->tmsk.s_addr, &arpinfo->tgt.s_addr, arpinfo->invflags & ARPT_INV_TGTIP ? " (INV)" : ""); return 0; } /* Look for ifname matches. / ret = ifname_compare(indev, arpinfo->iniface, arpinfo->iniface_mask); if (FWINV(ret != 0, ARPT_INV_VIA_IN)) { dprintf("VIA in mismatch (%s vs %s).%s\n", indev, arpinfo->iniface, arpinfo->invflags & ARPT_INV_VIA_IN ? " (INV)" : ""); return 0; } ret = ifname_compare(outdev, arpinfo->outiface, arpinfo->outiface_mask); if (FWINV(ret != 0, ARPT_INV_VIA_OUT)) { dprintf("VIA out mismatch (%s vs %s).%s\n", outdev, arpinfo->outiface, arpinfo->invflags & ARPT_INV_VIA_OUT ? " (INV)" : ""); return 0; } return 1; #undef FWINV } static inline int arp_checkentry(const struct arpt_arp arp) { if (arp->flags & ~ARPT_F_MASK) { duprintf("Unknown flag bits set: %08X\n", arp->flags & ~ARPT_F_MASK); return 0; } if (arp->invflags & ~ARPT_INV_MASK) { duprintf("Unknown invflag bits set: %08X\n", arp->invflags & ~ARPT_INV_MASK); return 0; } return 1; } static unsigned int arpt_error(struct sk_buff skb, const struct xt_action_param par) { net_err_ratelimited("arp_tables: error: '%s'\n", (const char )par->targinfo); return NF_DROP; } static inline const struct xt_entry_target arpt_get_target_c(const struct arpt_entry e) { return arpt_get_target((struct arpt_entry )e); } static inline struct arpt_entry * get_entry(const void base, unsigned int offset) { return (struct arpt_entry )(base + offset); } static inline struct arpt_entry arpt_next_entry(const struct arpt_entry entry) { return (void )entry + entry->next_offset; } unsigned int arpt_do_table(struct sk_buff skb, const struct nf_hook_state state, struct xt_table table) { unsigned int hook = state->hook; static const char nulldevname[IFNAMSIZ] __attribute__((aligned(sizeof(long)))); unsigned int verdict = NF_DROP; const struct arphdr arp; struct arpt_entry e, *jumpstack; const char indev, outdev; const void table_base; unsigned int cpu, stackidx = 0; const struct xt_table_info private; struct xt_action_param acpar; unsigned int addend; if (!pskb_may_pull(skb, arp_hdr_len(skb->dev))) return NF_DROP; indev = state->in ? state->in->name : nulldevname; outdev = state->out ? state->out->name : nulldevname; local_bh_disable(); addend = xt_write_recseq_begin(); private = table->private; cpu = smp_processor_id(); / * Ensure we load private-> members after we've fetched the base * pointer. / smp_read_barrier_depends(); table_base = private->entries; jumpstack = (struct arpt_entry )private->jumpstack[cpu]; / No TEE support for arptables, so no need to switch to alternate * stack. All targets that reenter must return absolute verdicts. / e = get_entry(table_base, private->hook_entry[hook]); acpar.net = state->net; acpar.in = state->in; acpar.out = state->out; acpar.hooknum = hook; acpar.family = NFPROTO_ARP; acpar.hotdrop = false; arp = arp_hdr(skb); do { const struct xt_entry_target t; struct xt_counters counter; if (!arp_packet_match(arp, skb->dev, indev, outdev, &e->arp)) { e = arpt_next_entry(e); continue; } counter = xt_get_this_cpu_counter(&e->counters); ADD_COUNTER(counter, arp_hdr_len(skb->dev), 1); t = arpt_get_target_c(e); /* Standard target? / if (!t->u.kernel.target->target) { int v; v = ((struct xt_standard_target )t)->verdict; if (v < 0) { /* Pop from stack? / if (v != XT_RETURN) { verdict = (unsigned int)(-v) - 1; break; } if (stackidx == 0) { e = get_entry(table_base, private->underflow[hook]); } else { e = jumpstack[--stackidx]; e = arpt_next_entry(e); } continue; } if (table_base + v != arpt_next_entry(e)) { jumpstack[stackidx++] = e; } e = get_entry(table_base, v); continue; } acpar.target = t->u.kernel.target; acpar.targinfo = t->data; verdict = t->u.kernel.target->target(skb, &acpar); / Target might have changed stuff. / arp = arp_hdr(skb); if (verdict == XT_CONTINUE) e = arpt_next_entry(e); else / Verdict / break; } while (!acpar.hotdrop); xt_write_recseq_end(addend); local_bh_enable(); if (acpar.hotdrop) return NF_DROP; else return verdict; } / All zeroes == unconditional rule. / static inline bool unconditional(const struct arpt_entry e) { static const struct arpt_arp uncond; return e->target_offset == sizeof(struct arpt_entry) && memcmp(&e->arp, &uncond, sizeof(uncond)) == 0; } static bool find_jump_target(const struct xt_table_info t, const struct arpt_entry target) { struct arpt_entry iter; xt_entry_foreach(iter, t->entries, t->size) { if (iter == target) return true; } return false; } / Figures out from what hook each rule can be called: returns 0 if * there are loops. Puts hook bitmask in comefrom. / static int mark_source_chains(const struct xt_table_info newinfo, unsigned int valid_hooks, void entry0) { unsigned int hook; / No recursion; use packet counter to save back ptrs (reset * to 0 as we leave), and comefrom to save source hook bitmask. / for (hook = 0; hook < NF_ARP_NUMHOOKS; hook++) { unsigned int pos = newinfo->hook_entry[hook]; struct arpt_entry e = (struct arpt_entry )(entry0 + pos); if (!(valid_hooks & (1 << hook))) continue; / Set initial back pointer. / e->counters.pcnt = pos; for (;;) { const struct xt_standard_target t = (void )arpt_get_target_c(e); int visited = e->comefrom & (1 << hook); if (e->comefrom & (1 << NF_ARP_NUMHOOKS)) { pr_notice("arptables: loop hook %u pos %u %08X.\n", hook, pos, e->comefrom); return 0; } e->comefrom \|= ((1 << hook) \| (1 << NF_ARP_NUMHOOKS)); / Unconditional return/END. / if ((unconditional(e) && (strcmp(t->target.u.user.name, XT_STANDARD_TARGET) == 0) && t->verdict < 0) \|\| visited) { unsigned int oldpos, size; if ((strcmp(t->target.u.user.name, XT_STANDARD_TARGET) == 0) && t->verdict < -NF_MAX_VERDICT - 1) { duprintf("mark_source_chains: bad " "negative verdict (%i)\n", t->verdict); return 0; } / Return: backtrack through the last * big jump. / do { e->comefrom ^= (1<<NF_ARP_NUMHOOKS); oldpos = pos; pos = e->counters.pcnt; e->counters.pcnt = 0; / We're at the start. / if (pos == oldpos) goto next; e = (struct arpt_entry ) (entry0 + pos); } while (oldpos == pos + e->next_offset); /* Move along one / size = e->next_offset; e = (struct arpt_entry ) (entry0 + pos + size); if (pos + size >= newinfo->size) return 0; e->counters.pcnt = pos; pos += size; } else { int newpos = t->verdict; if (strcmp(t->target.u.user.name, XT_STANDARD_TARGET) == 0 && newpos >= 0) { if (newpos > newinfo->size - sizeof(struct arpt_entry)) { duprintf("mark_source_chains: " "bad verdict (%i)\n", newpos); return 0; } /* This a jump; chase it. / duprintf("Jump rule %u -> %u\n", pos, newpos); e = (struct arpt_entry ) (entry0 + newpos); if (!find_jump_target(newinfo, e)) return 0; } else { /* ... this is a fallthru / newpos = pos + e->next_offset; if (newpos >= newinfo->size) return 0; } e = (struct arpt_entry ) (entry0 + newpos); e->counters.pcnt = pos; pos = newpos; } } next: duprintf("Finished chain %u\n", hook); } return 1; } static inline int check_target(struct arpt_entry e, const char name) { struct xt_entry_target t = arpt_get_target(e); int ret; struct xt_tgchk_param par = { .table = name, .entryinfo = e, .target = t->u.kernel.target, .targinfo = t->data, .hook_mask = e->comefrom, .family = NFPROTO_ARP, }; ret = xt_check_target(&par, t->u.target_size - sizeof(t), 0, false); if (ret < 0) { duprintf("arp_tables: check failed for `%s'.\n", t->u.kernel.target->name); return ret; } return 0; } static inline int find_check_entry(struct arpt_entry e, const char name, unsigned int size) { struct xt_entry_target t; struct xt_target target; int ret; e->counters.pcnt = xt_percpu_counter_alloc(); if (IS_ERR_VALUE(e->counters.pcnt)) return -ENOMEM; t = arpt_get_target(e); target = xt_request_find_target(NFPROTO_ARP, t->u.user.name, t->u.user.revision); if (IS_ERR(target)) { duprintf("find_check_entry: `%s' not found\n", t->u.user.name); ret = PTR_ERR(target); goto out; } t->u.kernel.target = target; ret = check_target(e, name); if (ret) goto err; return 0; err: module_put(t->u.kernel.target->me); out: xt_percpu_counter_free(e->counters.pcnt); return ret; } static bool check_underflow(const struct arpt_entry e) { const struct xt_entry_target t; unsigned int verdict; if (!unconditional(e)) return false; t = arpt_get_target_c(e); if (strcmp(t->u.user.name, XT_STANDARD_TARGET) != 0) return false; verdict = ((struct xt_standard_target )t)->verdict; verdict = -verdict - 1; return verdict == NF_DROP \|\| verdict == NF_ACCEPT; } static inline int check_entry_size_and_hooks(struct arpt_entry e, struct xt_table_info newinfo, const unsigned char base, const unsigned char limit, const unsigned int hook_entries, const unsigned int underflows, unsigned int valid_hooks) { unsigned int h; int err; if ((unsigned long)e % __alignof__(struct arpt_entry) != 0 \|\| (unsigned char )e + sizeof(struct arpt_entry) >= limit \|\| (unsigned char )e + e->next_offset > limit) { duprintf("Bad offset %p\n", e); return -EINVAL; } if (e->next_offset < sizeof(struct arpt_entry) + sizeof(struct xt_entry_target)) { duprintf("checking: element %p size %u\n", e, e->next_offset); return -EINVAL; } if (!arp_checkentry(&e->arp)) return -EINVAL; err = xt_check_entry_offsets(e, e->target_offset, e->next_offset); if (err) return err; / Check hooks & underflows / for (h = 0; h < NF_ARP_NUMHOOKS; h++) { if (!(valid_hooks & (1 << h))) continue; if ((unsigned char )e - base == hook_entries[h]) newinfo->hook_entry[h] = hook_entries[h]; if ((unsigned char )e - base == underflows[h]) { if (!check_underflow(e)) { pr_debug("Underflows must be unconditional and " "use the STANDARD target with " "ACCEPT/DROP\n"); return -EINVAL; } newinfo->underflow[h] = underflows[h]; } } / Clear counters and comefrom / e->counters = ((struct xt_counters) { 0, 0 }); e->comefrom = 0; return 0; } static inline void cleanup_entry(struct arpt_entry e) { struct xt_tgdtor_param par; struct xt_entry_target t; t = arpt_get_target(e); par.target = t->u.kernel.target; par.targinfo = t->data; par.family = NFPROTO_ARP; if (par.target->destroy != NULL) par.target->destroy(&par); module_put(par.target->me); xt_percpu_counter_free(e->counters.pcnt); } / Checks and translates the user-supplied table segment (held in * newinfo). / static int translate_table(struct xt_table_info newinfo, void entry0, const struct arpt_replace repl) { struct arpt_entry iter; unsigned int i; int ret = 0; newinfo->size = repl->size; newinfo->number = repl->num_entries; / Init all hooks to impossible value. / for (i = 0; i < NF_ARP_NUMHOOKS; i++) { newinfo->hook_entry[i] = 0xFFFFFFFF; newinfo->underflow[i] = 0xFFFFFFFF; } duprintf("translate_table: size %u\n", newinfo->size); i = 0; / Walk through entries, checking offsets. / xt_entry_foreach(iter, entry0, newinfo->size) { ret = check_entry_size_and_hooks(iter, newinfo, entry0, entry0 + repl->size, repl->hook_entry, repl->underflow, repl->valid_hooks); if (ret != 0) break; ++i; if (strcmp(arpt_get_target(iter)->u.user.name, XT_ERROR_TARGET) == 0) ++newinfo->stacksize; } duprintf("translate_table: ARPT_ENTRY_ITERATE gives %d\n", ret); if (ret != 0) return ret; if (i != repl->num_entries) { duprintf("translate_table: %u not %u entries\n", i, repl->num_entries); return -EINVAL; } / Check hooks all assigned / for (i = 0; i < NF_ARP_NUMHOOKS; i++) { / Only hooks which are valid / if (!(repl->valid_hooks & (1 << i))) continue; if (newinfo->hook_entry[i] == 0xFFFFFFFF) { duprintf("Invalid hook entry %u %u\n", i, repl->hook_entry[i]); return -EINVAL; } if (newinfo->underflow[i] == 0xFFFFFFFF) { duprintf("Invalid underflow %u %u\n", i, repl->underflow[i]); return -EINVAL; } } if (!mark_source_chains(newinfo, repl->valid_hooks, entry0)) return -ELOOP; / Finally, each sanity check must pass / i = 0; xt_entry_foreach(iter, entry0, newinfo->size) { ret = find_check_entry(iter, repl->name, repl->size); if (ret != 0) break; ++i; } if (ret != 0) { xt_entry_foreach(iter, entry0, newinfo->size) { if (i-- == 0) break; cleanup_entry(iter); } return ret; } return ret; } static void get_counters(const struct xt_table_info t, struct xt_counters counters[]) { struct arpt_entry iter; unsigned int cpu; unsigned int i; for_each_possible_cpu(cpu) { seqcount_t s = &per_cpu(xt_recseq, cpu); i = 0; xt_entry_foreach(iter, t->entries, t->size) { struct xt_counters tmp; u64 bcnt, pcnt; unsigned int start; tmp = xt_get_per_cpu_counter(&iter->counters, cpu); do { start = read_seqcount_begin(s); bcnt = tmp->bcnt; pcnt = tmp->pcnt; } while (read_seqcount_retry(s, start)); ADD_COUNTER(counters[i], bcnt, pcnt); ++i; } } } static struct xt_counters alloc_counters(const struct xt_table table) { unsigned int countersize; struct xt_counters counters; const struct xt_table_info private = table->private; / We need atomic snapshot of counters: rest doesn't change * (other than comefrom, which userspace doesn't care * about). / countersize = sizeof(struct xt_counters) private->number; counters = vzalloc(countersize); if (counters == NULL) return ERR_PTR(-ENOMEM); get_counters(private, counters); return counters; } static int copy_entries_to_user(unsigned int total_size, const struct xt_table table, void __user userptr) { unsigned int off, num; const struct arpt_entry e; struct xt_counters counters; struct xt_table_info private = table->private; int ret = 0; void loc_cpu_entry; counters = alloc_counters(table); if (IS_ERR(counters)) return PTR_ERR(counters); loc_cpu_entry = private->entries; /* ... then copy entire thing ... / if (copy_to_user(userptr, loc_cpu_entry, total_size) != 0) { ret = -EFAULT; goto free_counters; } / FIXME: use iterator macros --RR / / ... then go back and fix counters and names / for (off = 0, num = 0; off < total_size; off += e->next_offset, num++){ const struct xt_entry_target t; e = (struct arpt_entry )(loc_cpu_entry + off); if (copy_to_user(userptr + off + offsetof(struct arpt_entry, counters), &counters[num], sizeof(counters[num])) != 0) { ret = -EFAULT; goto free_counters; } t = arpt_get_target_c(e); if (copy_to_user(userptr + off + e->target_offset + offsetof(struct xt_entry_target, u.user.name), t->u.kernel.target->name, strlen(t->u.kernel.target->name)+1) != 0) { ret = -EFAULT; goto free_counters; } } free_counters: vfree(counters); return ret; } #ifdef CONFIG_COMPAT static void compat_standard_from_user(void dst, const void src) { int v = (compat_int_t )src; if (v > 0) v += xt_compat_calc_jump(NFPROTO_ARP, v); memcpy(dst, &v, sizeof(v)); } static int compat_standard_to_user(void __user dst, const void src) { compat_int_t cv = (int )src; if (cv > 0) cv -= xt_compat_calc_jump(NFPROTO_ARP, cv); return copy_to_user(dst, &cv, sizeof(cv)) ? -EFAULT : 0; } static int compat_calc_entry(const struct arpt_entry e, const struct xt_table_info info, const void base, struct xt_table_info newinfo) { const struct xt_entry_target t; unsigned int entry_offset; int off, i, ret; off = sizeof(struct arpt_entry) - sizeof(struct compat_arpt_entry); entry_offset = (void )e - base; t = arpt_get_target_c(e); off += xt_compat_target_offset(t->u.kernel.target); newinfo->size -= off; ret = xt_compat_add_offset(NFPROTO_ARP, entry_offset, off); if (ret) return ret; for (i = 0; i < NF_ARP_NUMHOOKS; i++) { if (info->hook_entry[i] && (e < (struct arpt_entry )(base + info->hook_entry[i]))) newinfo->hook_entry[i] -= off; if (info->underflow[i] && (e < (struct arpt_entry )(base + info->underflow[i]))) newinfo->underflow[i] -= off; } return 0; } static int compat_table_info(const struct xt_table_info info, struct xt_table_info newinfo) { struct arpt_entry iter; const void loc_cpu_entry; int ret; if (!newinfo \|\| !info) return -EINVAL; / we dont care about newinfo->entries / memcpy(newinfo, info, offsetof(struct xt_table_info, entries)); newinfo->initial_entries = 0; loc_cpu_entry = info->entries; xt_compat_init_offsets(NFPROTO_ARP, info->number); xt_entry_foreach(iter, loc_cpu_entry, info->size) { ret = compat_calc_entry(iter, info, loc_cpu_entry, newinfo); if (ret != 0) return ret; } return 0; } #endif static int get_info(struct net net, void __user user, const int len, int compat) { char name[XT_TABLE_MAXNAMELEN]; struct xt_table t; int ret; if (len != sizeof(struct arpt_getinfo)) { duprintf("length %u != %Zu\n", len, sizeof(struct arpt_getinfo)); return -EINVAL; } if (copy_from_user(name, user, sizeof(name)) != 0) return -EFAULT; name[XT_TABLE_MAXNAMELEN-1] = '\0'; #ifdef CONFIG_COMPAT if (compat) xt_compat_lock(NFPROTO_ARP); #endif t = try_then_request_module(xt_find_table_lock(net, NFPROTO_ARP, name), "arptable_%s", name); if (!IS_ERR_OR_NULL(t)) { struct arpt_getinfo info; const struct xt_table_info private = t->private; #ifdef CONFIG_COMPAT struct xt_table_info tmp; if (compat) { ret = compat_table_info(private, &tmp); xt_compat_flush_offsets(NFPROTO_ARP); private = &tmp; } #endif memset(&info, 0, sizeof(info)); info.valid_hooks = t->valid_hooks; memcpy(info.hook_entry, private->hook_entry, sizeof(info.hook_entry)); memcpy(info.underflow, private->underflow, sizeof(info.underflow)); info.num_entries = private->number; info.size = private->size; strcpy(info.name, name); if (copy_to_user(user, &info, len) != 0) ret = -EFAULT; else ret = 0; xt_table_unlock(t); module_put(t->me); } else ret = t ? PTR_ERR(t) : -ENOENT; #ifdef CONFIG_COMPAT if (compat) xt_compat_unlock(NFPROTO_ARP); #endif return ret; } static int get_entries(struct net net, struct arpt_get_entries __user uptr, const int len) { int ret; struct arpt_get_entries get; struct xt_table t; if (len < sizeof(get)) { duprintf("get_entries: %u < %Zu\n", len, sizeof(get)); return -EINVAL; } if (copy_from_user(&get, uptr, sizeof(get)) != 0) return -EFAULT; if (len != sizeof(struct arpt_get_entries) + get.size) { duprintf("get_entries: %u != %Zu\n", len, sizeof(struct arpt_get_entries) + get.size); return -EINVAL; } get.name[sizeof(get.name) - 1] = '\0'; t = xt_find_table_lock(net, NFPROTO_ARP, get.name); if (!IS_ERR_OR_NULL(t)) { const struct xt_table_info private = t->private; duprintf("t->private->number = %u\n", private->number); if (get.size == private->size) ret = copy_entries_to_user(private->size, t, uptr->entrytable); else { duprintf("get_entries: I've got %u not %u!\n", private->size, get.size); ret = -EAGAIN; } module_put(t->me); xt_table_unlock(t); } else ret = t ? PTR_ERR(t) : -ENOENT; return ret; } static int __do_replace(struct net net, const char name, unsigned int valid_hooks, struct xt_table_info newinfo, unsigned int num_counters, void __user counters_ptr) { int ret; struct xt_table t; struct xt_table_info oldinfo; struct xt_counters counters; void loc_cpu_old_entry; struct arpt_entry iter; ret = 0; counters = vzalloc(num_counters sizeof(struct xt_counters)); if (!counters) { ret = -ENOMEM; goto out; } t = try_then_request_module(xt_find_table_lock(net, NFPROTO_ARP, name), "arptable_%s", name); if (IS_ERR_OR_NULL(t)) { ret = t ? PTR_ERR(t) : -ENOENT; goto free_newinfo_counters_untrans; } /* You lied! / if (valid_hooks != t->valid_hooks) { duprintf("Valid hook crap: %08X vs %08X\n", valid_hooks, t->valid_hooks); ret = -EINVAL; goto put_module; } oldinfo = xt_replace_table(t, num_counters, newinfo, &ret); if (!oldinfo) goto put_module; / Update module usage count based on number of rules / duprintf("do_replace: oldnum=%u, initnum=%u, newnum=%u\n", oldinfo->number, oldinfo->initial_entries, newinfo->number); if ((oldinfo->number > oldinfo->initial_entries) \|\| (newinfo->number <= oldinfo->initial_entries)) module_put(t->me); if ((oldinfo->number > oldinfo->initial_entries) && (newinfo->number <= oldinfo->initial_entries)) module_put(t->me); / Get the old counters, and synchronize with replace / get_counters(oldinfo, counters); / Decrease module usage counts and free resource / loc_cpu_old_entry = oldinfo->entries; xt_entry_foreach(iter, loc_cpu_old_entry, oldinfo->size) cleanup_entry(iter); xt_free_table_info(oldinfo); if (copy_to_user(counters_ptr, counters, sizeof(struct xt_counters) num_counters) != 0) { /* Silent error, can't fail, new table is already in place / net_warn_ratelimited("arptables: counters copy to user failed while replacing table\n"); } vfree(counters); xt_table_unlock(t); return ret; put_module: module_put(t->me); xt_table_unlock(t); free_newinfo_counters_untrans: vfree(counters); out: return ret; } static int do_replace(struct net net, const void __user user, unsigned int len) { int ret; struct arpt_replace tmp; struct xt_table_info newinfo; void loc_cpu_entry; struct arpt_entry iter; if (copy_from_user(&tmp, user, sizeof(tmp)) != 0) return -EFAULT; /* overflow check / if (tmp.num_counters >= INT_MAX / sizeof(struct xt_counters)) return -ENOMEM; if (tmp.num_counters == 0) return -EINVAL; tmp.name[sizeof(tmp.name)-1] = 0; newinfo = xt_alloc_table_info(tmp.size); if (!newinfo) return -ENOMEM; loc_cpu_entry = newinfo->entries; if (copy_from_user(loc_cpu_entry, user + sizeof(tmp), tmp.size) != 0) { ret = -EFAULT; goto free_newinfo; } ret = translate_table(newinfo, loc_cpu_entry, &tmp); if (ret != 0) goto free_newinfo; duprintf("arp_tables: Translated table\n"); ret = __do_replace(net, tmp.name, tmp.valid_hooks, newinfo, tmp.num_counters, tmp.counters); if (ret) goto free_newinfo_untrans; return 0; free_newinfo_untrans: xt_entry_foreach(iter, loc_cpu_entry, newinfo->size) cleanup_entry(iter); free_newinfo: xt_free_table_info(newinfo); return ret; } static int do_add_counters(struct net net, const void __user user, unsigned int len, int compat) { unsigned int i; struct xt_counters_info tmp; struct xt_counters paddc; unsigned int num_counters; const char name; int size; void ptmp; struct xt_table t; const struct xt_table_info private; int ret = 0; struct arpt_entry iter; unsigned int addend; #ifdef CONFIG_COMPAT struct compat_xt_counters_info compat_tmp; if (compat) { ptmp = &compat_tmp; size = sizeof(struct compat_xt_counters_info); } else #endif { ptmp = &tmp; size = sizeof(struct xt_counters_info); } if (copy_from_user(ptmp, user, size) != 0) return -EFAULT; #ifdef CONFIG_COMPAT if (compat) { num_counters = compat_tmp.num_counters; name = compat_tmp.name; } else #endif { num_counters = tmp.num_counters; name = tmp.name; } if (len != size + num_counters sizeof(struct xt_counters)) return -EINVAL; paddc = vmalloc(len - size); if (!paddc) return -ENOMEM; if (copy_from_user(paddc, user + size, len - size) != 0) { ret = -EFAULT; goto free; } t = xt_find_table_lock(net, NFPROTO_ARP, name); if (IS_ERR_OR_NULL(t)) { ret = t ? PTR_ERR(t) : -ENOENT; goto free; } local_bh_disable(); private = t->private; if (private->number != num_counters) { ret = -EINVAL; goto unlock_up_free; } i = 0; addend = xt_write_recseq_begin(); xt_entry_foreach(iter, private->entries, private->size) { struct xt_counters tmp; tmp = xt_get_this_cpu_counter(&iter->counters); ADD_COUNTER(tmp, paddc[i].bcnt, paddc[i].pcnt); ++i; } xt_write_recseq_end(addend); unlock_up_free: local_bh_enable(); xt_table_unlock(t); module_put(t->me); free: vfree(paddc); return ret; } #ifdef CONFIG_COMPAT static inline void compat_release_entry(struct compat_arpt_entry e) { struct xt_entry_target t; t = compat_arpt_get_target(e); module_put(t->u.kernel.target->me); } static inline int check_compat_entry_size_and_hooks(struct compat_arpt_entry e, struct xt_table_info newinfo, unsigned int size, const unsigned char base, const unsigned char limit, const unsigned int hook_entries, const unsigned int underflows, const char name) { struct xt_entry_target t; struct xt_target target; unsigned int entry_offset; int ret, off, h; duprintf("check_compat_entry_size_and_hooks %p\n", e); if ((unsigned long)e % __alignof__(struct compat_arpt_entry) != 0 \|\| (unsigned char )e + sizeof(struct compat_arpt_entry) >= limit \|\| (unsigned char )e + e->next_offset > limit) { duprintf("Bad offset %p, limit = %p\n", e, limit); return -EINVAL; } if (e->next_offset < sizeof(struct compat_arpt_entry) + sizeof(struct compat_xt_entry_target)) { duprintf("checking: element %p size %u\n", e, e->next_offset); return -EINVAL; } if (!arp_checkentry(&e->arp)) return -EINVAL; ret = xt_compat_check_entry_offsets(e, e->target_offset, e->next_offset); if (ret) return ret; off = sizeof(struct arpt_entry) - sizeof(struct compat_arpt_entry); entry_offset = (void )e - (void )base; t = compat_arpt_get_target(e); target = xt_request_find_target(NFPROTO_ARP, t->u.user.name, t->u.user.revision); if (IS_ERR(target)) { duprintf("check_compat_entry_size_and_hooks: `%s' not found\n", t->u.user.name); ret = PTR_ERR(target); goto out; } t->u.kernel.target = target; off += xt_compat_target_offset(target); size += off; ret = xt_compat_add_offset(NFPROTO_ARP, entry_offset, off); if (ret) goto release_target; / Check hooks & underflows / for (h = 0; h < NF_ARP_NUMHOOKS; h++) { if ((unsigned char )e - base == hook_entries[h]) newinfo->hook_entry[h] = hook_entries[h]; if ((unsigned char )e - base == underflows[h]) newinfo->underflow[h] = underflows[h]; } / Clear counters and comefrom / memset(&e->counters, 0, sizeof(e->counters)); e->comefrom = 0; return 0; release_target: module_put(t->u.kernel.target->me); out: return ret; } static int compat_copy_entry_from_user(struct compat_arpt_entry e, void *dstptr, unsigned int size, const char name, struct xt_table_info newinfo, unsigned char base) { struct xt_entry_target t; struct xt_target target; struct arpt_entry de; unsigned int origsize; int ret, h; ret = 0; origsize = size; de = (struct arpt_entry )dstptr; memcpy(de, e, sizeof(struct arpt_entry)); memcpy(&de->counters, &e->counters, sizeof(e->counters)); dstptr += sizeof(struct arpt_entry); size += sizeof(struct arpt_entry) - sizeof(struct compat_arpt_entry); de->target_offset = e->target_offset - (origsize - size); t = compat_arpt_get_target(e); target = t->u.kernel.target; xt_compat_target_from_user(t, dstptr, size); de->next_offset = e->next_offset - (origsize - size); for (h = 0; h < NF_ARP_NUMHOOKS; h++) { if ((unsigned char )de - base < newinfo->hook_entry[h]) newinfo->hook_entry[h] -= origsize - size; if ((unsigned char )de - base < newinfo->underflow[h]) newinfo->underflow[h] -= origsize - size; } return ret; } static int translate_compat_table(const char name, unsigned int valid_hooks, struct xt_table_info pinfo, void pentry0, unsigned int total_size, unsigned int number, unsigned int hook_entries, unsigned int underflows) { unsigned int i, j; struct xt_table_info newinfo, info; void pos, entry0, entry1; struct compat_arpt_entry iter0; struct arpt_entry iter1; unsigned int size; int ret = 0; info = pinfo; entry0 = pentry0; size = total_size; info->number = number; / Init all hooks to impossible value. / for (i = 0; i < NF_ARP_NUMHOOKS; i++) { info->hook_entry[i] = 0xFFFFFFFF; info->underflow[i] = 0xFFFFFFFF; } duprintf("translate_compat_table: size %u\n", info->size); j = 0; xt_compat_lock(NFPROTO_ARP); xt_compat_init_offsets(NFPROTO_ARP, number); / Walk through entries, checking offsets. / xt_entry_foreach(iter0, entry0, total_size) { ret = check_compat_entry_size_and_hooks(iter0, info, &size, entry0, entry0 + total_size, hook_entries, underflows, name); if (ret != 0) goto out_unlock; ++j; } ret = -EINVAL; if (j != number) { duprintf("translate_compat_table: %u not %u entries\n", j, number); goto out_unlock; } / Check hooks all assigned / for (i = 0; i < NF_ARP_NUMHOOKS; i++) { / Only hooks which are valid / if (!(valid_hooks & (1 << i))) continue; if (info->hook_entry[i] == 0xFFFFFFFF) { duprintf("Invalid hook entry %u %u\n", i, hook_entries[i]); goto out_unlock; } if (info->underflow[i] == 0xFFFFFFFF) { duprintf("Invalid underflow %u %u\n", i, underflows[i]); goto out_unlock; } } ret = -ENOMEM; newinfo = xt_alloc_table_info(size); if (!newinfo) goto out_unlock; newinfo->number = number; for (i = 0; i < NF_ARP_NUMHOOKS; i++) { newinfo->hook_entry[i] = info->hook_entry[i]; newinfo->underflow[i] = info->underflow[i]; } entry1 = newinfo->entries; pos = entry1; size = total_size; xt_entry_foreach(iter0, entry0, total_size) { ret = compat_copy_entry_from_user(iter0, &pos, &size, name, newinfo, entry1); if (ret != 0) break; } xt_compat_flush_offsets(NFPROTO_ARP); xt_compat_unlock(NFPROTO_ARP); if (ret) goto free_newinfo; ret = -ELOOP; if (!mark_source_chains(newinfo, valid_hooks, entry1)) goto free_newinfo; i = 0; xt_entry_foreach(iter1, entry1, newinfo->size) { iter1->counters.pcnt = xt_percpu_counter_alloc(); if (IS_ERR_VALUE(iter1->counters.pcnt)) { ret = -ENOMEM; break; } ret = check_target(iter1, name); if (ret != 0) { xt_percpu_counter_free(iter1->counters.pcnt); break; } ++i; if (strcmp(arpt_get_target(iter1)->u.user.name, XT_ERROR_TARGET) == 0) ++newinfo->stacksize; } if (ret) { / * The first i matches need cleanup_entry (calls ->destroy) * because they had called ->check already. The other j-i * entries need only release. / int skip = i; j -= i; xt_entry_foreach(iter0, entry0, newinfo->size) { if (skip-- > 0) continue; if (j-- == 0) break; compat_release_entry(iter0); } xt_entry_foreach(iter1, entry1, newinfo->size) { if (i-- == 0) break; cleanup_entry(iter1); } xt_free_table_info(newinfo); return ret; } pinfo = newinfo; pentry0 = entry1; xt_free_table_info(info); return 0; free_newinfo: xt_free_table_info(newinfo); out: xt_entry_foreach(iter0, entry0, total_size) { if (j-- == 0) break; compat_release_entry(iter0); } return ret; out_unlock: xt_compat_flush_offsets(NFPROTO_ARP); xt_compat_unlock(NFPROTO_ARP); goto out; } struct compat_arpt_replace { char name[XT_TABLE_MAXNAMELEN]; u32 valid_hooks; u32 num_entries; u32 size; u32 hook_entry[NF_ARP_NUMHOOKS]; u32 underflow[NF_ARP_NUMHOOKS]; u32 num_counters; compat_uptr_t counters; struct compat_arpt_entry entries[0]; }; static int compat_do_replace(struct net net, void __user user, unsigned int len) { int ret; struct compat_arpt_replace tmp; struct xt_table_info newinfo; void loc_cpu_entry; struct arpt_entry iter; if (copy_from_user(&tmp, user, sizeof(tmp)) != 0) return -EFAULT; /* overflow check / if (tmp.size >= INT_MAX / num_possible_cpus()) return -ENOMEM; if (tmp.num_counters >= INT_MAX / sizeof(struct xt_counters)) return -ENOMEM; if (tmp.num_counters == 0) return -EINVAL; tmp.name[sizeof(tmp.name)-1] = 0; newinfo = xt_alloc_table_info(tmp.size); if (!newinfo) return -ENOMEM; loc_cpu_entry = newinfo->entries; if (copy_from_user(loc_cpu_entry, user + sizeof(tmp), tmp.size) != 0) { ret = -EFAULT; goto free_newinfo; } ret = translate_compat_table(tmp.name, tmp.valid_hooks, &newinfo, &loc_cpu_entry, tmp.size, tmp.num_entries, tmp.hook_entry, tmp.underflow); if (ret != 0) goto free_newinfo; duprintf("compat_do_replace: Translated table\n"); ret = __do_replace(net, tmp.name, tmp.valid_hooks, newinfo, tmp.num_counters, compat_ptr(tmp.counters)); if (ret) goto free_newinfo_untrans; return 0; free_newinfo_untrans: xt_entry_foreach(iter, loc_cpu_entry, newinfo->size) cleanup_entry(iter); free_newinfo: xt_free_table_info(newinfo); return ret; } static int compat_do_arpt_set_ctl(struct sock sk, int cmd, void __user user, unsigned int len) { int ret; if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN)) return -EPERM; switch (cmd) { case ARPT_SO_SET_REPLACE: ret = compat_do_replace(sock_net(sk), user, len); break; case ARPT_SO_SET_ADD_COUNTERS: ret = do_add_counters(sock_net(sk), user, len, 1); break; default: duprintf("do_arpt_set_ctl: unknown request %i\n", cmd); ret = -EINVAL; } return ret; } static int compat_copy_entry_to_user(struct arpt_entry e, void __user *dstptr, compat_uint_t size, struct xt_counters counters, unsigned int i) { struct xt_entry_target t; struct compat_arpt_entry __user ce; u_int16_t target_offset, next_offset; compat_uint_t origsize; int ret; origsize = size; ce = (struct compat_arpt_entry __user )dstptr; if (copy_to_user(ce, e, sizeof(struct arpt_entry)) != 0 \|\| copy_to_user(&ce->counters, &counters[i], sizeof(counters[i])) != 0) return -EFAULT; dstptr += sizeof(struct compat_arpt_entry); size -= sizeof(struct arpt_entry) - sizeof(struct compat_arpt_entry); target_offset = e->target_offset - (origsize - size); t = arpt_get_target(e); ret = xt_compat_target_to_user(t, dstptr, size); if (ret) return ret; next_offset = e->next_offset - (origsize - size); if (put_user(target_offset, &ce->target_offset) != 0 \|\| put_user(next_offset, &ce->next_offset) != 0) return -EFAULT; return 0; } static int compat_copy_entries_to_user(unsigned int total_size, struct xt_table table, void __user userptr) { struct xt_counters counters; const struct xt_table_info private = table->private; void __user pos; unsigned int size; int ret = 0; unsigned int i = 0; struct arpt_entry iter; counters = alloc_counters(table); if (IS_ERR(counters)) return PTR_ERR(counters); pos = userptr; size = total_size; xt_entry_foreach(iter, private->entries, total_size) { ret = compat_copy_entry_to_user(iter, &pos, &size, counters, i++); if (ret != 0) break; } vfree(counters); return ret; } struct compat_arpt_get_entries { char name[XT_TABLE_MAXNAMELEN]; compat_uint_t size; struct compat_arpt_entry entrytable[0]; }; static int compat_get_entries(struct net net, struct compat_arpt_get_entries __user uptr, int len) { int ret; struct compat_arpt_get_entries get; struct xt_table t; if (len < sizeof(get)) { duprintf("compat_get_entries: %u < %zu\n", len, sizeof(get)); return -EINVAL; } if (copy_from_user(&get, uptr, sizeof(get)) != 0) return -EFAULT; if (len != sizeof(struct compat_arpt_get_entries) + get.size) { duprintf("compat_get_entries: %u != %zu\n", len, sizeof(get) + get.size); return -EINVAL; } get.name[sizeof(get.name) - 1] = '\0'; xt_compat_lock(NFPROTO_ARP); t = xt_find_table_lock(net, NFPROTO_ARP, get.name); if (!IS_ERR_OR_NULL(t)) { const struct xt_table_info private = t->private; struct xt_table_info info; duprintf("t->private->number = %u\n", private->number); ret = compat_table_info(private, &info); if (!ret && get.size == info.size) { ret = compat_copy_entries_to_user(private->size, t, uptr->entrytable); } else if (!ret) { duprintf("compat_get_entries: I've got %u not %u!\n", private->size, get.size); ret = -EAGAIN; } xt_compat_flush_offsets(NFPROTO_ARP); module_put(t->me); xt_table_unlock(t); } else ret = t ? PTR_ERR(t) : -ENOENT; xt_compat_unlock(NFPROTO_ARP); return ret; } static int do_arpt_get_ctl(struct sock , int, void __user , int ); static int compat_do_arpt_get_ctl(struct sock sk, int cmd, void __user user, int len) { int ret; if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN)) return -EPERM; switch (cmd) { case ARPT_SO_GET_INFO: ret = get_info(sock_net(sk), user, len, 1); break; case ARPT_SO_GET_ENTRIES: ret = compat_get_entries(sock_net(sk), user, len); break; default: ret = do_arpt_get_ctl(sk, cmd, user, len); } return ret; } #endif static int do_arpt_set_ctl(struct sock sk, int cmd, void __user user, unsigned int len) { int ret; if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN)) return -EPERM; switch (cmd) { case ARPT_SO_SET_REPLACE: ret = do_replace(sock_net(sk), user, len); break; case ARPT_SO_SET_ADD_COUNTERS: ret = do_add_counters(sock_net(sk), user, len, 0); break; default: duprintf("do_arpt_set_ctl: unknown request %i\n", cmd); ret = -EINVAL; } return ret; } static int do_arpt_get_ctl(struct sock sk, int cmd, void __user user, int len) { int ret; if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN)) return -EPERM; switch (cmd) { case ARPT_SO_GET_INFO: ret = get_info(sock_net(sk), user, len, 0); break; case ARPT_SO_GET_ENTRIES: ret = get_entries(sock_net(sk), user, len); break; case ARPT_SO_GET_REVISION_TARGET: { struct xt_get_revision rev; if (len != sizeof(rev)) { ret = -EINVAL; break; } if (copy_from_user(&rev, user, sizeof(rev)) != 0) { ret = -EFAULT; break; } rev.name[sizeof(rev.name)-1] = 0; try_then_request_module(xt_find_revision(NFPROTO_ARP, rev.name, rev.revision, 1, &ret), "arpt_%s", rev.name); break; } default: duprintf("do_arpt_get_ctl: unknown request %i\n", cmd); ret = -EINVAL; } return ret; } static void __arpt_unregister_table(struct xt_table table) { struct xt_table_info private; void loc_cpu_entry; struct module table_owner = table->me; struct arpt_entry iter; private = xt_unregister_table(table); /* Decrease module usage counts and free resources / loc_cpu_entry = private->entries; xt_entry_foreach(iter, loc_cpu_entry, private->size) cleanup_entry(iter); if (private->number > private->initial_entries) module_put(table_owner); xt_free_table_info(private); } int arpt_register_table(struct net net, const struct xt_table table, const struct arpt_replace repl, const struct nf_hook_ops ops, struct xt_table res) { int ret; struct xt_table_info newinfo; struct xt_table_info bootstrap = {0}; void loc_cpu_entry; struct xt_table new_table; newinfo = xt_alloc_table_info(repl->size); if (!newinfo) return -ENOMEM; loc_cpu_entry = newinfo->entries; memcpy(loc_cpu_entry, repl->entries, repl->size); ret = translate_table(newinfo, loc_cpu_entry, repl); duprintf("arpt_register_table: translate table gives %d\n", ret); if (ret != 0) goto out_free; new_table = xt_register_table(net, table, &bootstrap, newinfo); if (IS_ERR(new_table)) { ret = PTR_ERR(new_table); goto out_free; } /* set res now, will see skbs right after nf_register_net_hooks / WRITE_ONCE(res, new_table); ret = nf_register_net_hooks(net, ops, hweight32(table->valid_hooks)); if (ret != 0) { __arpt_unregister_table(new_table); res = NULL; } return ret; out_free: xt_free_table_info(newinfo); return ret; } void arpt_unregister_table(struct net net, struct xt_table table, const struct nf_hook_ops ops) { nf_unregister_net_hooks(net, ops, hweight32(table->valid_hooks)); __arpt_unregister_table(table); } /* The built-in targets: standard (NULL) and error. / static struct xt_target arpt_builtin_tg[] __read_mostly = { { .name = XT_STANDARD_TARGET, .targetsize = sizeof(int), .family = NFPROTO_ARP, #ifdef CONFIG_COMPAT .compatsize = sizeof(compat_int_t), .compat_from_user = compat_standard_from_user, .compat_to_user = compat_standard_to_user, #endif }, { .name = XT_ERROR_TARGET, .target = arpt_error, .targetsize = XT_FUNCTION_MAXNAMELEN, .family = NFPROTO_ARP, }, }; static struct nf_sockopt_ops arpt_sockopts = { .pf = PF_INET, .set_optmin = ARPT_BASE_CTL, .set_optmax = ARPT_SO_SET_MAX+1, .set = do_arpt_set_ctl, #ifdef CONFIG_COMPAT .compat_set = compat_do_arpt_set_ctl, #endif .get_optmin = ARPT_BASE_CTL, .get_optmax = ARPT_SO_GET_MAX+1, .get = do_arpt_get_ctl, #ifdef CONFIG_COMPAT .compat_get = compat_do_arpt_get_ctl, #endif .owner = THIS_MODULE, }; static int __net_init arp_tables_net_init(struct net net) { return xt_proto_init(net, NFPROTO_ARP); } static void __net_exit arp_tables_net_exit(struct net net) { xt_proto_fini(net, NFPROTO_ARP); } static struct pernet_operations arp_tables_net_ops = { .init = arp_tables_net_init, .exit = arp_tables_net_exit, }; static int __init arp_tables_init(void) { int ret; ret = register_pernet_subsys(&arp_tables_net_ops); if (ret < 0) goto err1; / No one else will be downing sem now, so we won't sleep / ret = xt_register_targets(arpt_builtin_tg, ARRAY_SIZE(arpt_builtin_tg)); if (ret < 0) goto err2; / Register setsockopt */ ret = nf_register_sockopt(&arpt_sockopts); if (ret < 0) goto err4; pr_info("arp_tables: (C) 2002 David S. Miller\n"); return 0; err4: xt_unregister_targets(arpt_builtin_tg, ARRAY_SIZE(arpt_builtin_tg)); err2: unregister_pernet_subsys(&arp_tables_net_ops); err1: return ret; } static void __exit arp_tables_fini(void) { nf_unregister_sockopt(&arpt_sockopts); xt_unregister_targets(arpt_builtin_tg, ARRAY_SIZE(arpt_builtin_tg)); unregister_pernet_subsys(&arp_tables_net_ops); } EXPORT_SYMBOL(arpt_register_table); EXPORT_SYMBOL(arpt_unregister_table); EXPORT_SYMBOL(arpt_do_table); module_init(arp_tables_init); module_exit(arp_tables_fini);	./CrossVul/dataset_final_sorted/CWE-264/c/bad_5078_1
crossvul-cpp_data_good_2243_0	/* * linux/fs/namespace.c * * (C) Copyright Al Viro 2000, 2001 * Released under GPL v2. * * Based on code from fs/super.c, copyright Linus Torvalds and others. * Heavily rewritten. / #include <linux/syscalls.h> #include <linux/export.h> #include <linux/capability.h> #include <linux/mnt_namespace.h> #include <linux/user_namespace.h> #include <linux/namei.h> #include <linux/security.h> #include <linux/idr.h> #include <linux/acct.h> / acct_auto_close_mnt / #include <linux/init.h> / init_rootfs / #include <linux/fs_struct.h> / get_fs_root et.al. / #include <linux/fsnotify.h> / fsnotify_vfsmount_delete / #include <linux/uaccess.h> #include <linux/proc_ns.h> #include <linux/magic.h> #include <linux/bootmem.h> #include "pnode.h" #include "internal.h" static unsigned int m_hash_mask __read_mostly; static unsigned int m_hash_shift __read_mostly; static unsigned int mp_hash_mask __read_mostly; static unsigned int mp_hash_shift __read_mostly; static __initdata unsigned long mhash_entries; static int __init set_mhash_entries(char str) { if (!str) return 0; mhash_entries = simple_strtoul(str, &str, 0); return 1; } __setup("mhash_entries=", set_mhash_entries); static __initdata unsigned long mphash_entries; static int __init set_mphash_entries(char str) { if (!str) return 0; mphash_entries = simple_strtoul(str, &str, 0); return 1; } __setup("mphash_entries=", set_mphash_entries); static u64 event; static DEFINE_IDA(mnt_id_ida); static DEFINE_IDA(mnt_group_ida); static DEFINE_SPINLOCK(mnt_id_lock); static int mnt_id_start = 0; static int mnt_group_start = 1; static struct hlist_head mount_hashtable __read_mostly; static struct hlist_head mountpoint_hashtable __read_mostly; static struct kmem_cache mnt_cache __read_mostly; static DECLARE_RWSEM(namespace_sem); /* /sys/fs / struct kobject fs_kobj; EXPORT_SYMBOL_GPL(fs_kobj); /* * vfsmount lock may be taken for read to prevent changes to the * vfsmount hash, ie. during mountpoint lookups or walking back * up the tree. * * It should be taken for write in all cases where the vfsmount * tree or hash is modified or when a vfsmount structure is modified. / __cacheline_aligned_in_smp DEFINE_SEQLOCK(mount_lock); static inline struct hlist_head m_hash(struct vfsmount mnt, struct dentry dentry) { unsigned long tmp = ((unsigned long)mnt / L1_CACHE_BYTES); tmp += ((unsigned long)dentry / L1_CACHE_BYTES); tmp = tmp + (tmp >> m_hash_shift); return &mount_hashtable[tmp & m_hash_mask]; } static inline struct hlist_head mp_hash(struct dentry dentry) { unsigned long tmp = ((unsigned long)dentry / L1_CACHE_BYTES); tmp = tmp + (tmp >> mp_hash_shift); return &mountpoint_hashtable[tmp & mp_hash_mask]; } /* * allocation is serialized by namespace_sem, but we need the spinlock to * serialize with freeing. / static int mnt_alloc_id(struct mount mnt) { int res; retry: ida_pre_get(&mnt_id_ida, GFP_KERNEL); spin_lock(&mnt_id_lock); res = ida_get_new_above(&mnt_id_ida, mnt_id_start, &mnt->mnt_id); if (!res) mnt_id_start = mnt->mnt_id + 1; spin_unlock(&mnt_id_lock); if (res == -EAGAIN) goto retry; return res; } static void mnt_free_id(struct mount mnt) { int id = mnt->mnt_id; spin_lock(&mnt_id_lock); ida_remove(&mnt_id_ida, id); if (mnt_id_start > id) mnt_id_start = id; spin_unlock(&mnt_id_lock); } / * Allocate a new peer group ID * * mnt_group_ida is protected by namespace_sem / static int mnt_alloc_group_id(struct mount mnt) { int res; if (!ida_pre_get(&mnt_group_ida, GFP_KERNEL)) return -ENOMEM; res = ida_get_new_above(&mnt_group_ida, mnt_group_start, &mnt->mnt_group_id); if (!res) mnt_group_start = mnt->mnt_group_id + 1; return res; } /* * Release a peer group ID / void mnt_release_group_id(struct mount mnt) { int id = mnt->mnt_group_id; ida_remove(&mnt_group_ida, id); if (mnt_group_start > id) mnt_group_start = id; mnt->mnt_group_id = 0; } /* * vfsmount lock must be held for read / static inline void mnt_add_count(struct mount mnt, int n) { #ifdef CONFIG_SMP this_cpu_add(mnt->mnt_pcp->mnt_count, n); #else preempt_disable(); mnt->mnt_count += n; preempt_enable(); #endif } /* * vfsmount lock must be held for write / unsigned int mnt_get_count(struct mount mnt) { #ifdef CONFIG_SMP unsigned int count = 0; int cpu; for_each_possible_cpu(cpu) { count += per_cpu_ptr(mnt->mnt_pcp, cpu)->mnt_count; } return count; #else return mnt->mnt_count; #endif } static struct mount alloc_vfsmnt(const char name) { struct mount mnt = kmem_cache_zalloc(mnt_cache, GFP_KERNEL); if (mnt) { int err; err = mnt_alloc_id(mnt); if (err) goto out_free_cache; if (name) { mnt->mnt_devname = kstrdup(name, GFP_KERNEL); if (!mnt->mnt_devname) goto out_free_id; } #ifdef CONFIG_SMP mnt->mnt_pcp = alloc_percpu(struct mnt_pcp); if (!mnt->mnt_pcp) goto out_free_devname; this_cpu_add(mnt->mnt_pcp->mnt_count, 1); #else mnt->mnt_count = 1; mnt->mnt_writers = 0; #endif INIT_HLIST_NODE(&mnt->mnt_hash); INIT_LIST_HEAD(&mnt->mnt_child); INIT_LIST_HEAD(&mnt->mnt_mounts); INIT_LIST_HEAD(&mnt->mnt_list); INIT_LIST_HEAD(&mnt->mnt_expire); INIT_LIST_HEAD(&mnt->mnt_share); INIT_LIST_HEAD(&mnt->mnt_slave_list); INIT_LIST_HEAD(&mnt->mnt_slave); #ifdef CONFIG_FSNOTIFY INIT_HLIST_HEAD(&mnt->mnt_fsnotify_marks); #endif } return mnt; #ifdef CONFIG_SMP out_free_devname: kfree(mnt->mnt_devname); #endif out_free_id: mnt_free_id(mnt); out_free_cache: kmem_cache_free(mnt_cache, mnt); return NULL; } / * Most r/o checks on a fs are for operations that take * discrete amounts of time, like a write() or unlink(). * We must keep track of when those operations start * (for permission checks) and when they end, so that * we can determine when writes are able to occur to * a filesystem. / / * __mnt_is_readonly: check whether a mount is read-only * @mnt: the mount to check for its write status * * This shouldn't be used directly ouside of the VFS. * It does not guarantee that the filesystem will stay * r/w, just that it is right now. This can not and * should not be used in place of IS_RDONLY(inode). * mnt_want/drop_write() will _keep_ the filesystem * r/w. / int __mnt_is_readonly(struct vfsmount mnt) { if (mnt->mnt_flags & MNT_READONLY) return 1; if (mnt->mnt_sb->s_flags & MS_RDONLY) return 1; return 0; } EXPORT_SYMBOL_GPL(__mnt_is_readonly); static inline void mnt_inc_writers(struct mount mnt) { #ifdef CONFIG_SMP this_cpu_inc(mnt->mnt_pcp->mnt_writers); #else mnt->mnt_writers++; #endif } static inline void mnt_dec_writers(struct mount mnt) { #ifdef CONFIG_SMP this_cpu_dec(mnt->mnt_pcp->mnt_writers); #else mnt->mnt_writers--; #endif } static unsigned int mnt_get_writers(struct mount mnt) { #ifdef CONFIG_SMP unsigned int count = 0; int cpu; for_each_possible_cpu(cpu) { count += per_cpu_ptr(mnt->mnt_pcp, cpu)->mnt_writers; } return count; #else return mnt->mnt_writers; #endif } static int mnt_is_readonly(struct vfsmount mnt) { if (mnt->mnt_sb->s_readonly_remount) return 1; /* Order wrt setting s_flags/s_readonly_remount in do_remount() / smp_rmb(); return __mnt_is_readonly(mnt); } / * Most r/o & frozen checks on a fs are for operations that take discrete * amounts of time, like a write() or unlink(). We must keep track of when * those operations start (for permission checks) and when they end, so that we * can determine when writes are able to occur to a filesystem. / /* * __mnt_want_write - get write access to a mount without freeze protection * @m: the mount on which to take a write * * This tells the low-level filesystem that a write is about to be performed to * it, and makes sure that writes are allowed (mnt it read-write) before * returning success. This operation does not protect against filesystem being * frozen. When the write operation is finished, __mnt_drop_write() must be * called. This is effectively a refcount. / int __mnt_want_write(struct vfsmount m) { struct mount mnt = real_mount(m); int ret = 0; preempt_disable(); mnt_inc_writers(mnt); / * The store to mnt_inc_writers must be visible before we pass * MNT_WRITE_HOLD loop below, so that the slowpath can see our * incremented count after it has set MNT_WRITE_HOLD. / smp_mb(); while (ACCESS_ONCE(mnt->mnt.mnt_flags) & MNT_WRITE_HOLD) cpu_relax(); / * After the slowpath clears MNT_WRITE_HOLD, mnt_is_readonly will * be set to match its requirements. So we must not load that until * MNT_WRITE_HOLD is cleared. / smp_rmb(); if (mnt_is_readonly(m)) { mnt_dec_writers(mnt); ret = -EROFS; } preempt_enable(); return ret; } /* * mnt_want_write - get write access to a mount * @m: the mount on which to take a write * * This tells the low-level filesystem that a write is about to be performed to * it, and makes sure that writes are allowed (mount is read-write, filesystem * is not frozen) before returning success. When the write operation is * finished, mnt_drop_write() must be called. This is effectively a refcount. / int mnt_want_write(struct vfsmount m) { int ret; sb_start_write(m->mnt_sb); ret = __mnt_want_write(m); if (ret) sb_end_write(m->mnt_sb); return ret; } EXPORT_SYMBOL_GPL(mnt_want_write); /** * mnt_clone_write - get write access to a mount * @mnt: the mount on which to take a write * * This is effectively like mnt_want_write, except * it must only be used to take an extra write reference * on a mountpoint that we already know has a write reference * on it. This allows some optimisation. * * After finished, mnt_drop_write must be called as usual to * drop the reference. / int mnt_clone_write(struct vfsmount mnt) { /* superblock may be r/o / if (__mnt_is_readonly(mnt)) return -EROFS; preempt_disable(); mnt_inc_writers(real_mount(mnt)); preempt_enable(); return 0; } EXPORT_SYMBOL_GPL(mnt_clone_write); /* * __mnt_want_write_file - get write access to a file's mount * @file: the file who's mount on which to take a write * * This is like __mnt_want_write, but it takes a file and can * do some optimisations if the file is open for write already / int __mnt_want_write_file(struct file file) { if (!(file->f_mode & FMODE_WRITER)) return __mnt_want_write(file->f_path.mnt); else return mnt_clone_write(file->f_path.mnt); } /** * mnt_want_write_file - get write access to a file's mount * @file: the file who's mount on which to take a write * * This is like mnt_want_write, but it takes a file and can * do some optimisations if the file is open for write already / int mnt_want_write_file(struct file file) { int ret; sb_start_write(file->f_path.mnt->mnt_sb); ret = __mnt_want_write_file(file); if (ret) sb_end_write(file->f_path.mnt->mnt_sb); return ret; } EXPORT_SYMBOL_GPL(mnt_want_write_file); /** * __mnt_drop_write - give up write access to a mount * @mnt: the mount on which to give up write access * * Tells the low-level filesystem that we are done * performing writes to it. Must be matched with * __mnt_want_write() call above. / void __mnt_drop_write(struct vfsmount mnt) { preempt_disable(); mnt_dec_writers(real_mount(mnt)); preempt_enable(); } /** * mnt_drop_write - give up write access to a mount * @mnt: the mount on which to give up write access * * Tells the low-level filesystem that we are done performing writes to it and * also allows filesystem to be frozen again. Must be matched with * mnt_want_write() call above. / void mnt_drop_write(struct vfsmount mnt) { __mnt_drop_write(mnt); sb_end_write(mnt->mnt_sb); } EXPORT_SYMBOL_GPL(mnt_drop_write); void __mnt_drop_write_file(struct file file) { __mnt_drop_write(file->f_path.mnt); } void mnt_drop_write_file(struct file file) { mnt_drop_write(file->f_path.mnt); } EXPORT_SYMBOL(mnt_drop_write_file); static int mnt_make_readonly(struct mount mnt) { int ret = 0; lock_mount_hash(); mnt->mnt.mnt_flags \|= MNT_WRITE_HOLD; / * After storing MNT_WRITE_HOLD, we'll read the counters. This store * should be visible before we do. / smp_mb(); / * With writers on hold, if this value is zero, then there are * definitely no active writers (although held writers may subsequently * increment the count, they'll have to wait, and decrement it after * seeing MNT_READONLY). * * It is OK to have counter incremented on one CPU and decremented on * another: the sum will add up correctly. The danger would be when we * sum up each counter, if we read a counter before it is incremented, * but then read another CPU's count which it has been subsequently * decremented from -- we would see more decrements than we should. * MNT_WRITE_HOLD protects against this scenario, because * mnt_want_write first increments count, then smp_mb, then spins on * MNT_WRITE_HOLD, so it can't be decremented by another CPU while * we're counting up here. / if (mnt_get_writers(mnt) > 0) ret = -EBUSY; else mnt->mnt.mnt_flags \|= MNT_READONLY; / * MNT_READONLY must become visible before ~MNT_WRITE_HOLD, so writers * that become unheld will see MNT_READONLY. / smp_wmb(); mnt->mnt.mnt_flags &= ~MNT_WRITE_HOLD; unlock_mount_hash(); return ret; } static void __mnt_unmake_readonly(struct mount mnt) { lock_mount_hash(); mnt->mnt.mnt_flags &= ~MNT_READONLY; unlock_mount_hash(); } int sb_prepare_remount_readonly(struct super_block sb) { struct mount mnt; int err = 0; /* Racy optimization. Recheck the counter under MNT_WRITE_HOLD / if (atomic_long_read(&sb->s_remove_count)) return -EBUSY; lock_mount_hash(); list_for_each_entry(mnt, &sb->s_mounts, mnt_instance) { if (!(mnt->mnt.mnt_flags & MNT_READONLY)) { mnt->mnt.mnt_flags \|= MNT_WRITE_HOLD; smp_mb(); if (mnt_get_writers(mnt) > 0) { err = -EBUSY; break; } } } if (!err && atomic_long_read(&sb->s_remove_count)) err = -EBUSY; if (!err) { sb->s_readonly_remount = 1; smp_wmb(); } list_for_each_entry(mnt, &sb->s_mounts, mnt_instance) { if (mnt->mnt.mnt_flags & MNT_WRITE_HOLD) mnt->mnt.mnt_flags &= ~MNT_WRITE_HOLD; } unlock_mount_hash(); return err; } static void free_vfsmnt(struct mount mnt) { kfree(mnt->mnt_devname); #ifdef CONFIG_SMP free_percpu(mnt->mnt_pcp); #endif kmem_cache_free(mnt_cache, mnt); } static void delayed_free_vfsmnt(struct rcu_head head) { free_vfsmnt(container_of(head, struct mount, mnt_rcu)); } / call under rcu_read_lock / bool legitimize_mnt(struct vfsmount bastard, unsigned seq) { struct mount mnt; if (read_seqretry(&mount_lock, seq)) return false; if (bastard == NULL) return true; mnt = real_mount(bastard); mnt_add_count(mnt, 1); if (likely(!read_seqretry(&mount_lock, seq))) return true; if (bastard->mnt_flags & MNT_SYNC_UMOUNT) { mnt_add_count(mnt, -1); return false; } rcu_read_unlock(); mntput(bastard); rcu_read_lock(); return false; } / * find the first mount at @dentry on vfsmount @mnt. * call under rcu_read_lock() / struct mount __lookup_mnt(struct vfsmount mnt, struct dentry dentry) { struct hlist_head head = m_hash(mnt, dentry); struct mount p; hlist_for_each_entry_rcu(p, head, mnt_hash) if (&p->mnt_parent->mnt == mnt && p->mnt_mountpoint == dentry) return p; return NULL; } /* * find the last mount at @dentry on vfsmount @mnt. * mount_lock must be held. / struct mount __lookup_mnt_last(struct vfsmount mnt, struct dentry dentry) { struct mount p, res; res = p = __lookup_mnt(mnt, dentry); if (!p) goto out; hlist_for_each_entry_continue(p, mnt_hash) { if (&p->mnt_parent->mnt != mnt \|\| p->mnt_mountpoint != dentry) break; res = p; } out: return res; } /* * lookup_mnt - Return the first child mount mounted at path * * "First" means first mounted chronologically. If you create the * following mounts: * * mount /dev/sda1 /mnt * mount /dev/sda2 /mnt * mount /dev/sda3 /mnt * * Then lookup_mnt() on the base /mnt dentry in the root mount will * return successively the root dentry and vfsmount of /dev/sda1, then * /dev/sda2, then /dev/sda3, then NULL. * * lookup_mnt takes a reference to the found vfsmount. / struct vfsmount lookup_mnt(struct path path) { struct mount child_mnt; struct vfsmount m; unsigned seq; rcu_read_lock(); do { seq = read_seqbegin(&mount_lock); child_mnt = __lookup_mnt(path->mnt, path->dentry); m = child_mnt ? &child_mnt->mnt : NULL; } while (!legitimize_mnt(m, seq)); rcu_read_unlock(); return m; } static struct mountpoint new_mountpoint(struct dentry dentry) { struct hlist_head chain = mp_hash(dentry); struct mountpoint mp; int ret; hlist_for_each_entry(mp, chain, m_hash) { if (mp->m_dentry == dentry) { / might be worth a WARN_ON() / if (d_unlinked(dentry)) return ERR_PTR(-ENOENT); mp->m_count++; return mp; } } mp = kmalloc(sizeof(struct mountpoint), GFP_KERNEL); if (!mp) return ERR_PTR(-ENOMEM); ret = d_set_mounted(dentry); if (ret) { kfree(mp); return ERR_PTR(ret); } mp->m_dentry = dentry; mp->m_count = 1; hlist_add_head(&mp->m_hash, chain); return mp; } static void put_mountpoint(struct mountpoint mp) { if (!--mp->m_count) { struct dentry dentry = mp->m_dentry; spin_lock(&dentry->d_lock); dentry->d_flags &= ~DCACHE_MOUNTED; spin_unlock(&dentry->d_lock); hlist_del(&mp->m_hash); kfree(mp); } } static inline int check_mnt(struct mount mnt) { return mnt->mnt_ns == current->nsproxy->mnt_ns; } /* * vfsmount lock must be held for write / static void touch_mnt_namespace(struct mnt_namespace ns) { if (ns) { ns->event = ++event; wake_up_interruptible(&ns->poll); } } /* * vfsmount lock must be held for write / static void __touch_mnt_namespace(struct mnt_namespace ns) { if (ns && ns->event != event) { ns->event = event; wake_up_interruptible(&ns->poll); } } /* * vfsmount lock must be held for write / static void detach_mnt(struct mount mnt, struct path old_path) { old_path->dentry = mnt->mnt_mountpoint; old_path->mnt = &mnt->mnt_parent->mnt; mnt->mnt_parent = mnt; mnt->mnt_mountpoint = mnt->mnt.mnt_root; list_del_init(&mnt->mnt_child); hlist_del_init_rcu(&mnt->mnt_hash); put_mountpoint(mnt->mnt_mp); mnt->mnt_mp = NULL; } / * vfsmount lock must be held for write / void mnt_set_mountpoint(struct mount mnt, struct mountpoint mp, struct mount child_mnt) { mp->m_count++; mnt_add_count(mnt, 1); /* essentially, that's mntget / child_mnt->mnt_mountpoint = dget(mp->m_dentry); child_mnt->mnt_parent = mnt; child_mnt->mnt_mp = mp; } / * vfsmount lock must be held for write / static void attach_mnt(struct mount mnt, struct mount parent, struct mountpoint mp) { mnt_set_mountpoint(parent, mp, mnt); hlist_add_head_rcu(&mnt->mnt_hash, m_hash(&parent->mnt, mp->m_dentry)); list_add_tail(&mnt->mnt_child, &parent->mnt_mounts); } /* * vfsmount lock must be held for write / static void commit_tree(struct mount mnt, struct mount shadows) { struct mount parent = mnt->mnt_parent; struct mount m; LIST_HEAD(head); struct mnt_namespace n = parent->mnt_ns; BUG_ON(parent == mnt); list_add_tail(&head, &mnt->mnt_list); list_for_each_entry(m, &head, mnt_list) m->mnt_ns = n; list_splice(&head, n->list.prev); if (shadows) hlist_add_after_rcu(&shadows->mnt_hash, &mnt->mnt_hash); else hlist_add_head_rcu(&mnt->mnt_hash, m_hash(&parent->mnt, mnt->mnt_mountpoint)); list_add_tail(&mnt->mnt_child, &parent->mnt_mounts); touch_mnt_namespace(n); } static struct mount next_mnt(struct mount p, struct mount root) { struct list_head next = p->mnt_mounts.next; if (next == &p->mnt_mounts) { while (1) { if (p == root) return NULL; next = p->mnt_child.next; if (next != &p->mnt_parent->mnt_mounts) break; p = p->mnt_parent; } } return list_entry(next, struct mount, mnt_child); } static struct mount skip_mnt_tree(struct mount p) { struct list_head prev = p->mnt_mounts.prev; while (prev != &p->mnt_mounts) { p = list_entry(prev, struct mount, mnt_child); prev = p->mnt_mounts.prev; } return p; } struct vfsmount vfs_kern_mount(struct file_system_type type, int flags, const char name, void data) { struct mount mnt; struct dentry root; if (!type) return ERR_PTR(-ENODEV); mnt = alloc_vfsmnt(name); if (!mnt) return ERR_PTR(-ENOMEM); if (flags & MS_KERNMOUNT) mnt->mnt.mnt_flags = MNT_INTERNAL; root = mount_fs(type, flags, name, data); if (IS_ERR(root)) { mnt_free_id(mnt); free_vfsmnt(mnt); return ERR_CAST(root); } mnt->mnt.mnt_root = root; mnt->mnt.mnt_sb = root->d_sb; mnt->mnt_mountpoint = mnt->mnt.mnt_root; mnt->mnt_parent = mnt; lock_mount_hash(); list_add_tail(&mnt->mnt_instance, &root->d_sb->s_mounts); unlock_mount_hash(); return &mnt->mnt; } EXPORT_SYMBOL_GPL(vfs_kern_mount); static struct mount clone_mnt(struct mount old, struct dentry root, int flag) { struct super_block sb = old->mnt.mnt_sb; struct mount mnt; int err; mnt = alloc_vfsmnt(old->mnt_devname); if (!mnt) return ERR_PTR(-ENOMEM); if (flag & (CL_SLAVE \| CL_PRIVATE \| CL_SHARED_TO_SLAVE)) mnt->mnt_group_id = 0; /* not a peer of original / else mnt->mnt_group_id = old->mnt_group_id; if ((flag & CL_MAKE_SHARED) && !mnt->mnt_group_id) { err = mnt_alloc_group_id(mnt); if (err) goto out_free; } mnt->mnt.mnt_flags = old->mnt.mnt_flags & ~(MNT_WRITE_HOLD\|MNT_MARKED); / Don't allow unprivileged users to change mount flags / if ((flag & CL_UNPRIVILEGED) && (mnt->mnt.mnt_flags & MNT_READONLY)) mnt->mnt.mnt_flags \|= MNT_LOCK_READONLY; / Don't allow unprivileged users to reveal what is under a mount / if ((flag & CL_UNPRIVILEGED) && list_empty(&old->mnt_expire)) mnt->mnt.mnt_flags \|= MNT_LOCKED; atomic_inc(&sb->s_active); mnt->mnt.mnt_sb = sb; mnt->mnt.mnt_root = dget(root); mnt->mnt_mountpoint = mnt->mnt.mnt_root; mnt->mnt_parent = mnt; lock_mount_hash(); list_add_tail(&mnt->mnt_instance, &sb->s_mounts); unlock_mount_hash(); if ((flag & CL_SLAVE) \|\| ((flag & CL_SHARED_TO_SLAVE) && IS_MNT_SHARED(old))) { list_add(&mnt->mnt_slave, &old->mnt_slave_list); mnt->mnt_master = old; CLEAR_MNT_SHARED(mnt); } else if (!(flag & CL_PRIVATE)) { if ((flag & CL_MAKE_SHARED) \|\| IS_MNT_SHARED(old)) list_add(&mnt->mnt_share, &old->mnt_share); if (IS_MNT_SLAVE(old)) list_add(&mnt->mnt_slave, &old->mnt_slave); mnt->mnt_master = old->mnt_master; } if (flag & CL_MAKE_SHARED) set_mnt_shared(mnt); / stick the duplicate mount on the same expiry list * as the original if that was on one / if (flag & CL_EXPIRE) { if (!list_empty(&old->mnt_expire)) list_add(&mnt->mnt_expire, &old->mnt_expire); } return mnt; out_free: mnt_free_id(mnt); free_vfsmnt(mnt); return ERR_PTR(err); } static void mntput_no_expire(struct mount mnt) { put_again: rcu_read_lock(); mnt_add_count(mnt, -1); if (likely(mnt->mnt_ns)) { /* shouldn't be the last one / rcu_read_unlock(); return; } lock_mount_hash(); if (mnt_get_count(mnt)) { rcu_read_unlock(); unlock_mount_hash(); return; } if (unlikely(mnt->mnt_pinned)) { mnt_add_count(mnt, mnt->mnt_pinned + 1); mnt->mnt_pinned = 0; rcu_read_unlock(); unlock_mount_hash(); acct_auto_close_mnt(&mnt->mnt); goto put_again; } if (unlikely(mnt->mnt.mnt_flags & MNT_DOOMED)) { rcu_read_unlock(); unlock_mount_hash(); return; } mnt->mnt.mnt_flags \|= MNT_DOOMED; rcu_read_unlock(); list_del(&mnt->mnt_instance); unlock_mount_hash(); / * This probably indicates that somebody messed * up a mnt_want/drop_write() pair. If this * happens, the filesystem was probably unable * to make r/w->r/o transitions. / / * The locking used to deal with mnt_count decrement provides barriers, * so mnt_get_writers() below is safe. / WARN_ON(mnt_get_writers(mnt)); fsnotify_vfsmount_delete(&mnt->mnt); dput(mnt->mnt.mnt_root); deactivate_super(mnt->mnt.mnt_sb); mnt_free_id(mnt); call_rcu(&mnt->mnt_rcu, delayed_free_vfsmnt); } void mntput(struct vfsmount mnt) { if (mnt) { struct mount m = real_mount(mnt); / avoid cacheline pingpong, hope gcc doesn't get "smart" / if (unlikely(m->mnt_expiry_mark)) m->mnt_expiry_mark = 0; mntput_no_expire(m); } } EXPORT_SYMBOL(mntput); struct vfsmount mntget(struct vfsmount mnt) { if (mnt) mnt_add_count(real_mount(mnt), 1); return mnt; } EXPORT_SYMBOL(mntget); void mnt_pin(struct vfsmount mnt) { lock_mount_hash(); real_mount(mnt)->mnt_pinned++; unlock_mount_hash(); } EXPORT_SYMBOL(mnt_pin); void mnt_unpin(struct vfsmount m) { struct mount mnt = real_mount(m); lock_mount_hash(); if (mnt->mnt_pinned) { mnt_add_count(mnt, 1); mnt->mnt_pinned--; } unlock_mount_hash(); } EXPORT_SYMBOL(mnt_unpin); static inline void mangle(struct seq_file m, const char s) { seq_escape(m, s, " \t\n\\"); } /* * Simple .show_options callback for filesystems which don't want to * implement more complex mount option showing. * * See also save_mount_options(). / int generic_show_options(struct seq_file m, struct dentry root) { const char options; rcu_read_lock(); options = rcu_dereference(root->d_sb->s_options); if (options != NULL && options[0]) { seq_putc(m, ','); mangle(m, options); } rcu_read_unlock(); return 0; } EXPORT_SYMBOL(generic_show_options); /* * If filesystem uses generic_show_options(), this function should be * called from the fill_super() callback. * * The .remount_fs callback usually needs to be handled in a special * way, to make sure, that previous options are not overwritten if the * remount fails. * * Also note, that if the filesystem's .remount_fs function doesn't * reset all options to their default value, but changes only newly * given options, then the displayed options will not reflect reality * any more. / void save_mount_options(struct super_block sb, char options) { BUG_ON(sb->s_options); rcu_assign_pointer(sb->s_options, kstrdup(options, GFP_KERNEL)); } EXPORT_SYMBOL(save_mount_options); void replace_mount_options(struct super_block sb, char options) { char old = sb->s_options; rcu_assign_pointer(sb->s_options, options); if (old) { synchronize_rcu(); kfree(old); } } EXPORT_SYMBOL(replace_mount_options); #ifdef CONFIG_PROC_FS /* iterator; we want it to have access to namespace_sem, thus here... / static void m_start(struct seq_file m, loff_t pos) { struct proc_mounts p = proc_mounts(m); down_read(&namespace_sem); if (p->cached_event == p->ns->event) { void v = p->cached_mount; if (pos == p->cached_index) return v; if (pos == p->cached_index + 1) { v = seq_list_next(v, &p->ns->list, &p->cached_index); return p->cached_mount = v; } } p->cached_event = p->ns->event; p->cached_mount = seq_list_start(&p->ns->list, pos); p->cached_index = pos; return p->cached_mount; } static void m_next(struct seq_file m, void v, loff_t pos) { struct proc_mounts p = proc_mounts(m); p->cached_mount = seq_list_next(v, &p->ns->list, pos); p->cached_index = pos; return p->cached_mount; } static void m_stop(struct seq_file m, void v) { up_read(&namespace_sem); } static int m_show(struct seq_file m, void v) { struct proc_mounts p = proc_mounts(m); struct mount r = list_entry(v, struct mount, mnt_list); return p->show(m, &r->mnt); } const struct seq_operations mounts_op = { .start = m_start, .next = m_next, .stop = m_stop, .show = m_show, }; #endif /* CONFIG_PROC_FS / /* * may_umount_tree - check if a mount tree is busy * @mnt: root of mount tree * * This is called to check if a tree of mounts has any * open files, pwds, chroots or sub mounts that are * busy. / int may_umount_tree(struct vfsmount m) { struct mount mnt = real_mount(m); int actual_refs = 0; int minimum_refs = 0; struct mount p; BUG_ON(!m); /* write lock needed for mnt_get_count / lock_mount_hash(); for (p = mnt; p; p = next_mnt(p, mnt)) { actual_refs += mnt_get_count(p); minimum_refs += 2; } unlock_mount_hash(); if (actual_refs > minimum_refs) return 0; return 1; } EXPORT_SYMBOL(may_umount_tree); /* * may_umount - check if a mount point is busy * @mnt: root of mount * * This is called to check if a mount point has any * open files, pwds, chroots or sub mounts. If the * mount has sub mounts this will return busy * regardless of whether the sub mounts are busy. * * Doesn't take quota and stuff into account. IOW, in some cases it will * give false negatives. The main reason why it's here is that we need * a non-destructive way to look for easily umountable filesystems. / int may_umount(struct vfsmount mnt) { int ret = 1; down_read(&namespace_sem); lock_mount_hash(); if (propagate_mount_busy(real_mount(mnt), 2)) ret = 0; unlock_mount_hash(); up_read(&namespace_sem); return ret; } EXPORT_SYMBOL(may_umount); static HLIST_HEAD(unmounted); /* protected by namespace_sem / static void namespace_unlock(void) { struct mount mnt; struct hlist_head head = unmounted; if (likely(hlist_empty(&head))) { up_write(&namespace_sem); return; } head.first->pprev = &head.first; INIT_HLIST_HEAD(&unmounted); up_write(&namespace_sem); synchronize_rcu(); while (!hlist_empty(&head)) { mnt = hlist_entry(head.first, struct mount, mnt_hash); hlist_del_init(&mnt->mnt_hash); if (mnt->mnt_ex_mountpoint.mnt) path_put(&mnt->mnt_ex_mountpoint); mntput(&mnt->mnt); } } static inline void namespace_lock(void) { down_write(&namespace_sem); } /* * mount_lock must be held * namespace_sem must be held for write * how = 0 => just this tree, don't propagate * how = 1 => propagate; we know that nobody else has reference to any victims * how = 2 => lazy umount / void umount_tree(struct mount mnt, int how) { HLIST_HEAD(tmp_list); struct mount p; struct mount last = NULL; for (p = mnt; p; p = next_mnt(p, mnt)) { hlist_del_init_rcu(&p->mnt_hash); hlist_add_head(&p->mnt_hash, &tmp_list); } if (how) propagate_umount(&tmp_list); hlist_for_each_entry(p, &tmp_list, mnt_hash) { list_del_init(&p->mnt_expire); list_del_init(&p->mnt_list); __touch_mnt_namespace(p->mnt_ns); p->mnt_ns = NULL; if (how < 2) p->mnt.mnt_flags \|= MNT_SYNC_UMOUNT; list_del_init(&p->mnt_child); if (mnt_has_parent(p)) { put_mountpoint(p->mnt_mp); /* move the reference to mountpoint into ->mnt_ex_mountpoint / p->mnt_ex_mountpoint.dentry = p->mnt_mountpoint; p->mnt_ex_mountpoint.mnt = &p->mnt_parent->mnt; p->mnt_mountpoint = p->mnt.mnt_root; p->mnt_parent = p; p->mnt_mp = NULL; } change_mnt_propagation(p, MS_PRIVATE); last = p; } if (last) { last->mnt_hash.next = unmounted.first; unmounted.first = tmp_list.first; unmounted.first->pprev = &unmounted.first; } } static void shrink_submounts(struct mount mnt); static int do_umount(struct mount mnt, int flags) { struct super_block sb = mnt->mnt.mnt_sb; int retval; retval = security_sb_umount(&mnt->mnt, flags); if (retval) return retval; /* * Allow userspace to request a mountpoint be expired rather than * unmounting unconditionally. Unmount only happens if: * (1) the mark is already set (the mark is cleared by mntput()) * (2) the usage count == 1 [parent vfsmount] + 1 [sys_umount] / if (flags & MNT_EXPIRE) { if (&mnt->mnt == current->fs->root.mnt \|\| flags & (MNT_FORCE \| MNT_DETACH)) return -EINVAL; / * probably don't strictly need the lock here if we examined * all race cases, but it's a slowpath. / lock_mount_hash(); if (mnt_get_count(mnt) != 2) { unlock_mount_hash(); return -EBUSY; } unlock_mount_hash(); if (!xchg(&mnt->mnt_expiry_mark, 1)) return -EAGAIN; } / * If we may have to abort operations to get out of this * mount, and they will themselves hold resources we must * allow the fs to do things. In the Unix tradition of * 'Gee thats tricky lets do it in userspace' the umount_begin * might fail to complete on the first run through as other tasks * must return, and the like. Thats for the mount program to worry * about for the moment. / if (flags & MNT_FORCE && sb->s_op->umount_begin) { sb->s_op->umount_begin(sb); } / * No sense to grab the lock for this test, but test itself looks * somewhat bogus. Suggestions for better replacement? * Ho-hum... In principle, we might treat that as umount + switch * to rootfs. GC would eventually take care of the old vfsmount. * Actually it makes sense, especially if rootfs would contain a * /reboot - static binary that would close all descriptors and * call reboot(9). Then init(8) could umount root and exec /reboot. / if (&mnt->mnt == current->fs->root.mnt && !(flags & MNT_DETACH)) { / * Special case for "unmounting" root ... * we just try to remount it readonly. / down_write(&sb->s_umount); if (!(sb->s_flags & MS_RDONLY)) retval = do_remount_sb(sb, MS_RDONLY, NULL, 0); up_write(&sb->s_umount); return retval; } namespace_lock(); lock_mount_hash(); event++; if (flags & MNT_DETACH) { if (!list_empty(&mnt->mnt_list)) umount_tree(mnt, 2); retval = 0; } else { shrink_submounts(mnt); retval = -EBUSY; if (!propagate_mount_busy(mnt, 2)) { if (!list_empty(&mnt->mnt_list)) umount_tree(mnt, 1); retval = 0; } } unlock_mount_hash(); namespace_unlock(); return retval; } / * Is the caller allowed to modify his namespace? / static inline bool may_mount(void) { return ns_capable(current->nsproxy->mnt_ns->user_ns, CAP_SYS_ADMIN); } / * Now umount can handle mount points as well as block devices. * This is important for filesystems which use unnamed block devices. * * We now support a flag for forced unmount like the other 'big iron' * unixes. Our API is identical to OSF/1 to avoid making a mess of AMD / SYSCALL_DEFINE2(umount, char __user , name, int, flags) { struct path path; struct mount mnt; int retval; int lookup_flags = 0; if (flags & ~(MNT_FORCE \| MNT_DETACH \| MNT_EXPIRE \| UMOUNT_NOFOLLOW)) return -EINVAL; if (!may_mount()) return -EPERM; if (!(flags & UMOUNT_NOFOLLOW)) lookup_flags \|= LOOKUP_FOLLOW; retval = user_path_mountpoint_at(AT_FDCWD, name, lookup_flags, &path); if (retval) goto out; mnt = real_mount(path.mnt); retval = -EINVAL; if (path.dentry != path.mnt->mnt_root) goto dput_and_out; if (!check_mnt(mnt)) goto dput_and_out; if (mnt->mnt.mnt_flags & MNT_LOCKED) goto dput_and_out; retval = do_umount(mnt, flags); dput_and_out: / we mustn't call path_put() as that would clear mnt_expiry_mark / dput(path.dentry); mntput_no_expire(mnt); out: return retval; } #ifdef __ARCH_WANT_SYS_OLDUMOUNT / * The 2.0 compatible umount. No flags. / SYSCALL_DEFINE1(oldumount, char __user , name) { return sys_umount(name, 0); } #endif static bool is_mnt_ns_file(struct dentry dentry) { / Is this a proxy for a mount namespace? / struct inode inode = dentry->d_inode; struct proc_ns ei; if (!proc_ns_inode(inode)) return false; ei = get_proc_ns(inode); if (ei->ns_ops != &mntns_operations) return false; return true; } static bool mnt_ns_loop(struct dentry dentry) { /* Could bind mounting the mount namespace inode cause a * mount namespace loop? / struct mnt_namespace mnt_ns; if (!is_mnt_ns_file(dentry)) return false; mnt_ns = get_proc_ns(dentry->d_inode)->ns; return current->nsproxy->mnt_ns->seq >= mnt_ns->seq; } struct mount copy_tree(struct mount mnt, struct dentry dentry, int flag) { struct mount res, p, q, r, parent; if (!(flag & CL_COPY_UNBINDABLE) && IS_MNT_UNBINDABLE(mnt)) return ERR_PTR(-EINVAL); if (!(flag & CL_COPY_MNT_NS_FILE) && is_mnt_ns_file(dentry)) return ERR_PTR(-EINVAL); res = q = clone_mnt(mnt, dentry, flag); if (IS_ERR(q)) return q; q->mnt.mnt_flags &= ~MNT_LOCKED; q->mnt_mountpoint = mnt->mnt_mountpoint; p = mnt; list_for_each_entry(r, &mnt->mnt_mounts, mnt_child) { struct mount s; if (!is_subdir(r->mnt_mountpoint, dentry)) continue; for (s = r; s; s = next_mnt(s, r)) { if (!(flag & CL_COPY_UNBINDABLE) && IS_MNT_UNBINDABLE(s)) { s = skip_mnt_tree(s); continue; } if (!(flag & CL_COPY_MNT_NS_FILE) && is_mnt_ns_file(s->mnt.mnt_root)) { s = skip_mnt_tree(s); continue; } while (p != s->mnt_parent) { p = p->mnt_parent; q = q->mnt_parent; } p = s; parent = q; q = clone_mnt(p, p->mnt.mnt_root, flag); if (IS_ERR(q)) goto out; lock_mount_hash(); list_add_tail(&q->mnt_list, &res->mnt_list); attach_mnt(q, parent, p->mnt_mp); unlock_mount_hash(); } } return res; out: if (res) { lock_mount_hash(); umount_tree(res, 0); unlock_mount_hash(); } return q; } / Caller should check returned pointer for errors / struct vfsmount collect_mounts(struct path path) { struct mount tree; namespace_lock(); tree = copy_tree(real_mount(path->mnt), path->dentry, CL_COPY_ALL \| CL_PRIVATE); namespace_unlock(); if (IS_ERR(tree)) return ERR_CAST(tree); return &tree->mnt; } void drop_collected_mounts(struct vfsmount mnt) { namespace_lock(); lock_mount_hash(); umount_tree(real_mount(mnt), 0); unlock_mount_hash(); namespace_unlock(); } int iterate_mounts(int (f)(struct vfsmount , void ), void arg, struct vfsmount root) { struct mount mnt; int res = f(root, arg); if (res) return res; list_for_each_entry(mnt, &real_mount(root)->mnt_list, mnt_list) { res = f(&mnt->mnt, arg); if (res) return res; } return 0; } static void cleanup_group_ids(struct mount mnt, struct mount end) { struct mount p; for (p = mnt; p != end; p = next_mnt(p, mnt)) { if (p->mnt_group_id && !IS_MNT_SHARED(p)) mnt_release_group_id(p); } } static int invent_group_ids(struct mount mnt, bool recurse) { struct mount p; for (p = mnt; p; p = recurse ? next_mnt(p, mnt) : NULL) { if (!p->mnt_group_id && !IS_MNT_SHARED(p)) { int err = mnt_alloc_group_id(p); if (err) { cleanup_group_ids(mnt, p); return err; } } } return 0; } /* * @source_mnt : mount tree to be attached * @nd : place the mount tree @source_mnt is attached * @parent_nd : if non-null, detach the source_mnt from its parent and * store the parent mount and mountpoint dentry. * (done when source_mnt is moved) * * NOTE: in the table below explains the semantics when a source mount * of a given type is attached to a destination mount of a given type. * --------------------------------------------------------------------------- * \| BIND MOUNT OPERATION \| * \|************************************************************************** * \| source-->\| shared \| private \| slave \| unbindable \| * \| dest \| \| \| \| \| * \| \| \| \| \| \| \| * \| v \| \| \| \| \| * \|************************************************************************** * \| shared \| shared (++) \| shared (+) \| shared(+++)\| invalid \| * \| \| \| \| \| \| * \|non-shared\| shared (+) \| private \| slave () \| invalid \| *************************************************************************** * A bind operation clones the source mount and mounts the clone on the * destination mount. * * (++) the cloned mount is propagated to all the mounts in the propagation * tree of the destination mount and the cloned mount is added to * the peer group of the source mount. * (+) the cloned mount is created under the destination mount and is marked * as shared. The cloned mount is added to the peer group of the source * mount. * (+++) the mount is propagated to all the mounts in the propagation tree * of the destination mount and the cloned mount is made slave * of the same master as that of the source mount. The cloned mount * is marked as 'shared and slave'. * () the cloned mount is made a slave of the same master as that of the source mount. * * --------------------------------------------------------------------------- * \| MOVE MOUNT OPERATION \| * \|************************************************************************** * \| source-->\| shared \| private \| slave \| unbindable \| * \| dest \| \| \| \| \| * \| \| \| \| \| \| \| * \| v \| \| \| \| \| * \|************************************************************************** * \| shared \| shared (+) \| shared (+) \| shared(+++) \| invalid \| * \| \| \| \| \| \| * \|non-shared\| shared (+) \| private \| slave () \| unbindable \| * *************************************************************************** * * (+) the mount is moved to the destination. And is then propagated to * all the mounts in the propagation tree of the destination mount. * (+) the mount is moved to the destination. (+++) the mount is moved to the destination and is then propagated to * all the mounts belonging to the destination mount's propagation tree. * the mount is marked as 'shared and slave'. * () the mount continues to be a slave at the new location. * if the source mount is a tree, the operations explained above is * applied to each mount in the tree. * Must be called without spinlocks held, since this function can sleep * in allocations. / static int attach_recursive_mnt(struct mount source_mnt, struct mount dest_mnt, struct mountpoint dest_mp, struct path parent_path) { HLIST_HEAD(tree_list); struct mount child, p; struct hlist_node n; int err; if (IS_MNT_SHARED(dest_mnt)) { err = invent_group_ids(source_mnt, true); if (err) goto out; err = propagate_mnt(dest_mnt, dest_mp, source_mnt, &tree_list); lock_mount_hash(); if (err) goto out_cleanup_ids; for (p = source_mnt; p; p = next_mnt(p, source_mnt)) set_mnt_shared(p); } else { lock_mount_hash(); } if (parent_path) { detach_mnt(source_mnt, parent_path); attach_mnt(source_mnt, dest_mnt, dest_mp); touch_mnt_namespace(source_mnt->mnt_ns); } else { mnt_set_mountpoint(dest_mnt, dest_mp, source_mnt); commit_tree(source_mnt, NULL); } hlist_for_each_entry_safe(child, n, &tree_list, mnt_hash) { struct mount q; hlist_del_init(&child->mnt_hash); q = __lookup_mnt_last(&child->mnt_parent->mnt, child->mnt_mountpoint); commit_tree(child, q); } unlock_mount_hash(); return 0; out_cleanup_ids: while (!hlist_empty(&tree_list)) { child = hlist_entry(tree_list.first, struct mount, mnt_hash); umount_tree(child, 0); } unlock_mount_hash(); cleanup_group_ids(source_mnt, NULL); out: return err; } static struct mountpoint lock_mount(struct path path) { struct vfsmount mnt; struct dentry dentry = path->dentry; retry: mutex_lock(&dentry->d_inode->i_mutex); if (unlikely(cant_mount(dentry))) { mutex_unlock(&dentry->d_inode->i_mutex); return ERR_PTR(-ENOENT); } namespace_lock(); mnt = lookup_mnt(path); if (likely(!mnt)) { struct mountpoint mp = new_mountpoint(dentry); if (IS_ERR(mp)) { namespace_unlock(); mutex_unlock(&dentry->d_inode->i_mutex); return mp; } return mp; } namespace_unlock(); mutex_unlock(&path->dentry->d_inode->i_mutex); path_put(path); path->mnt = mnt; dentry = path->dentry = dget(mnt->mnt_root); goto retry; } static void unlock_mount(struct mountpoint where) { struct dentry dentry = where->m_dentry; put_mountpoint(where); namespace_unlock(); mutex_unlock(&dentry->d_inode->i_mutex); } static int graft_tree(struct mount mnt, struct mount p, struct mountpoint mp) { if (mnt->mnt.mnt_sb->s_flags & MS_NOUSER) return -EINVAL; if (S_ISDIR(mp->m_dentry->d_inode->i_mode) != S_ISDIR(mnt->mnt.mnt_root->d_inode->i_mode)) return -ENOTDIR; return attach_recursive_mnt(mnt, p, mp, NULL); } / * Sanity check the flags to change_mnt_propagation. / static int flags_to_propagation_type(int flags) { int type = flags & ~(MS_REC \| MS_SILENT); / Fail if any non-propagation flags are set / if (type & ~(MS_SHARED \| MS_PRIVATE \| MS_SLAVE \| MS_UNBINDABLE)) return 0; / Only one propagation flag should be set / if (!is_power_of_2(type)) return 0; return type; } / * recursively change the type of the mountpoint. / static int do_change_type(struct path path, int flag) { struct mount m; struct mount mnt = real_mount(path->mnt); int recurse = flag & MS_REC; int type; int err = 0; if (path->dentry != path->mnt->mnt_root) return -EINVAL; type = flags_to_propagation_type(flag); if (!type) return -EINVAL; namespace_lock(); if (type == MS_SHARED) { err = invent_group_ids(mnt, recurse); if (err) goto out_unlock; } lock_mount_hash(); for (m = mnt; m; m = (recurse ? next_mnt(m, mnt) : NULL)) change_mnt_propagation(m, type); unlock_mount_hash(); out_unlock: namespace_unlock(); return err; } static bool has_locked_children(struct mount mnt, struct dentry dentry) { struct mount child; list_for_each_entry(child, &mnt->mnt_mounts, mnt_child) { if (!is_subdir(child->mnt_mountpoint, dentry)) continue; if (child->mnt.mnt_flags & MNT_LOCKED) return true; } return false; } / * do loopback mount. / static int do_loopback(struct path path, const char old_name, int recurse) { struct path old_path; struct mount mnt = NULL, old, parent; struct mountpoint mp; int err; if (!old_name \|\| !old_name) return -EINVAL; err = kern_path(old_name, LOOKUP_FOLLOW\|LOOKUP_AUTOMOUNT, &old_path); if (err) return err; err = -EINVAL; if (mnt_ns_loop(old_path.dentry)) goto out; mp = lock_mount(path); err = PTR_ERR(mp); if (IS_ERR(mp)) goto out; old = real_mount(old_path.mnt); parent = real_mount(path->mnt); err = -EINVAL; if (IS_MNT_UNBINDABLE(old)) goto out2; if (!check_mnt(parent) \|\| !check_mnt(old)) goto out2; if (!recurse && has_locked_children(old, old_path.dentry)) goto out2; if (recurse) mnt = copy_tree(old, old_path.dentry, CL_COPY_MNT_NS_FILE); else mnt = clone_mnt(old, old_path.dentry, 0); if (IS_ERR(mnt)) { err = PTR_ERR(mnt); goto out2; } mnt->mnt.mnt_flags &= ~MNT_LOCKED; err = graft_tree(mnt, parent, mp); if (err) { lock_mount_hash(); umount_tree(mnt, 0); unlock_mount_hash(); } out2: unlock_mount(mp); out: path_put(&old_path); return err; } static int change_mount_flags(struct vfsmount mnt, int ms_flags) { int error = 0; int readonly_request = 0; if (ms_flags & MS_RDONLY) readonly_request = 1; if (readonly_request == __mnt_is_readonly(mnt)) return 0; if (mnt->mnt_flags & MNT_LOCK_READONLY) return -EPERM; if (readonly_request) error = mnt_make_readonly(real_mount(mnt)); else __mnt_unmake_readonly(real_mount(mnt)); return error; } / * change filesystem flags. dir should be a physical root of filesystem. * If you've mounted a non-root directory somewhere and want to do remount * on it - tough luck. / static int do_remount(struct path path, int flags, int mnt_flags, void data) { int err; struct super_block sb = path->mnt->mnt_sb; struct mount mnt = real_mount(path->mnt); if (!check_mnt(mnt)) return -EINVAL; if (path->dentry != path->mnt->mnt_root) return -EINVAL; err = security_sb_remount(sb, data); if (err) return err; down_write(&sb->s_umount); if (flags & MS_BIND) err = change_mount_flags(path->mnt, flags); else if (!capable(CAP_SYS_ADMIN)) err = -EPERM; else err = do_remount_sb(sb, flags, data, 0); if (!err) { lock_mount_hash(); mnt_flags \|= mnt->mnt.mnt_flags & ~MNT_USER_SETTABLE_MASK; mnt->mnt.mnt_flags = mnt_flags; touch_mnt_namespace(mnt->mnt_ns); unlock_mount_hash(); } up_write(&sb->s_umount); return err; } static inline int tree_contains_unbindable(struct mount mnt) { struct mount p; for (p = mnt; p; p = next_mnt(p, mnt)) { if (IS_MNT_UNBINDABLE(p)) return 1; } return 0; } static int do_move_mount(struct path path, const char old_name) { struct path old_path, parent_path; struct mount p; struct mount old; struct mountpoint mp; int err; if (!old_name \|\| !old_name) return -EINVAL; err = kern_path(old_name, LOOKUP_FOLLOW, &old_path); if (err) return err; mp = lock_mount(path); err = PTR_ERR(mp); if (IS_ERR(mp)) goto out; old = real_mount(old_path.mnt); p = real_mount(path->mnt); err = -EINVAL; if (!check_mnt(p) \|\| !check_mnt(old)) goto out1; if (old->mnt.mnt_flags & MNT_LOCKED) goto out1; err = -EINVAL; if (old_path.dentry != old_path.mnt->mnt_root) goto out1; if (!mnt_has_parent(old)) goto out1; if (S_ISDIR(path->dentry->d_inode->i_mode) != S_ISDIR(old_path.dentry->d_inode->i_mode)) goto out1; / * Don't move a mount residing in a shared parent. / if (IS_MNT_SHARED(old->mnt_parent)) goto out1; / * Don't move a mount tree containing unbindable mounts to a destination * mount which is shared. / if (IS_MNT_SHARED(p) && tree_contains_unbindable(old)) goto out1; err = -ELOOP; for (; mnt_has_parent(p); p = p->mnt_parent) if (p == old) goto out1; err = attach_recursive_mnt(old, real_mount(path->mnt), mp, &parent_path); if (err) goto out1; / if the mount is moved, it should no longer be expire * automatically / list_del_init(&old->mnt_expire); out1: unlock_mount(mp); out: if (!err) path_put(&parent_path); path_put(&old_path); return err; } static struct vfsmount fs_set_subtype(struct vfsmount mnt, const char fstype) { int err; const char subtype = strchr(fstype, '.'); if (subtype) { subtype++; err = -EINVAL; if (!subtype[0]) goto err; } else subtype = ""; mnt->mnt_sb->s_subtype = kstrdup(subtype, GFP_KERNEL); err = -ENOMEM; if (!mnt->mnt_sb->s_subtype) goto err; return mnt; err: mntput(mnt); return ERR_PTR(err); } / * add a mount into a namespace's mount tree / static int do_add_mount(struct mount newmnt, struct path path, int mnt_flags) { struct mountpoint mp; struct mount parent; int err; mnt_flags &= ~MNT_INTERNAL_FLAGS; mp = lock_mount(path); if (IS_ERR(mp)) return PTR_ERR(mp); parent = real_mount(path->mnt); err = -EINVAL; if (unlikely(!check_mnt(parent))) { / that's acceptable only for automounts done in private ns / if (!(mnt_flags & MNT_SHRINKABLE)) goto unlock; / ... and for those we'd better have mountpoint still alive / if (!parent->mnt_ns) goto unlock; } / Refuse the same filesystem on the same mount point / err = -EBUSY; if (path->mnt->mnt_sb == newmnt->mnt.mnt_sb && path->mnt->mnt_root == path->dentry) goto unlock; err = -EINVAL; if (S_ISLNK(newmnt->mnt.mnt_root->d_inode->i_mode)) goto unlock; newmnt->mnt.mnt_flags = mnt_flags; err = graft_tree(newmnt, parent, mp); unlock: unlock_mount(mp); return err; } / * create a new mount for userspace and request it to be added into the * namespace's tree / static int do_new_mount(struct path path, const char fstype, int flags, int mnt_flags, const char name, void data) { struct file_system_type type; struct user_namespace user_ns = current->nsproxy->mnt_ns->user_ns; struct vfsmount mnt; int err; if (!fstype) return -EINVAL; type = get_fs_type(fstype); if (!type) return -ENODEV; if (user_ns != &init_user_ns) { if (!(type->fs_flags & FS_USERNS_MOUNT)) { put_filesystem(type); return -EPERM; } /* Only in special cases allow devices from mounts * created outside the initial user namespace. / if (!(type->fs_flags & FS_USERNS_DEV_MOUNT)) { flags \|= MS_NODEV; mnt_flags \|= MNT_NODEV; } } mnt = vfs_kern_mount(type, flags, name, data); if (!IS_ERR(mnt) && (type->fs_flags & FS_HAS_SUBTYPE) && !mnt->mnt_sb->s_subtype) mnt = fs_set_subtype(mnt, fstype); put_filesystem(type); if (IS_ERR(mnt)) return PTR_ERR(mnt); err = do_add_mount(real_mount(mnt), path, mnt_flags); if (err) mntput(mnt); return err; } int finish_automount(struct vfsmount m, struct path path) { struct mount mnt = real_mount(m); int err; /* The new mount record should have at least 2 refs to prevent it being * expired before we get a chance to add it / BUG_ON(mnt_get_count(mnt) < 2); if (m->mnt_sb == path->mnt->mnt_sb && m->mnt_root == path->dentry) { err = -ELOOP; goto fail; } err = do_add_mount(mnt, path, path->mnt->mnt_flags \| MNT_SHRINKABLE); if (!err) return 0; fail: / remove m from any expiration list it may be on / if (!list_empty(&mnt->mnt_expire)) { namespace_lock(); list_del_init(&mnt->mnt_expire); namespace_unlock(); } mntput(m); mntput(m); return err; } /* * mnt_set_expiry - Put a mount on an expiration list * @mnt: The mount to list. * @expiry_list: The list to add the mount to. / void mnt_set_expiry(struct vfsmount mnt, struct list_head expiry_list) { namespace_lock(); list_add_tail(&real_mount(mnt)->mnt_expire, expiry_list); namespace_unlock(); } EXPORT_SYMBOL(mnt_set_expiry); / * process a list of expirable mountpoints with the intent of discarding any * mountpoints that aren't in use and haven't been touched since last we came * here / void mark_mounts_for_expiry(struct list_head mounts) { struct mount mnt, next; LIST_HEAD(graveyard); if (list_empty(mounts)) return; namespace_lock(); lock_mount_hash(); /* extract from the expiration list every vfsmount that matches the * following criteria: * - only referenced by its parent vfsmount * - still marked for expiry (marked on the last call here; marks are * cleared by mntput()) / list_for_each_entry_safe(mnt, next, mounts, mnt_expire) { if (!xchg(&mnt->mnt_expiry_mark, 1) \|\| propagate_mount_busy(mnt, 1)) continue; list_move(&mnt->mnt_expire, &graveyard); } while (!list_empty(&graveyard)) { mnt = list_first_entry(&graveyard, struct mount, mnt_expire); touch_mnt_namespace(mnt->mnt_ns); umount_tree(mnt, 1); } unlock_mount_hash(); namespace_unlock(); } EXPORT_SYMBOL_GPL(mark_mounts_for_expiry); / * Ripoff of 'select_parent()' * * search the list of submounts for a given mountpoint, and move any * shrinkable submounts to the 'graveyard' list. / static int select_submounts(struct mount parent, struct list_head graveyard) { struct mount this_parent = parent; struct list_head next; int found = 0; repeat: next = this_parent->mnt_mounts.next; resume: while (next != &this_parent->mnt_mounts) { struct list_head tmp = next; struct mount mnt = list_entry(tmp, struct mount, mnt_child); next = tmp->next; if (!(mnt->mnt.mnt_flags & MNT_SHRINKABLE)) continue; / * Descend a level if the d_mounts list is non-empty. / if (!list_empty(&mnt->mnt_mounts)) { this_parent = mnt; goto repeat; } if (!propagate_mount_busy(mnt, 1)) { list_move_tail(&mnt->mnt_expire, graveyard); found++; } } / * All done at this level ... ascend and resume the search / if (this_parent != parent) { next = this_parent->mnt_child.next; this_parent = this_parent->mnt_parent; goto resume; } return found; } / * process a list of expirable mountpoints with the intent of discarding any * submounts of a specific parent mountpoint * * mount_lock must be held for write / static void shrink_submounts(struct mount mnt) { LIST_HEAD(graveyard); struct mount m; / extract submounts of 'mountpoint' from the expiration list / while (select_submounts(mnt, &graveyard)) { while (!list_empty(&graveyard)) { m = list_first_entry(&graveyard, struct mount, mnt_expire); touch_mnt_namespace(m->mnt_ns); umount_tree(m, 1); } } } / * Some copy_from_user() implementations do not return the exact number of * bytes remaining to copy on a fault. But copy_mount_options() requires that. * Note that this function differs from copy_from_user() in that it will oops * on bad values of `to', rather than returning a short copy. / static long exact_copy_from_user(void to, const void __user * from, unsigned long n) { char t = to; const char __user f = from; char c; if (!access_ok(VERIFY_READ, from, n)) return n; while (n) { if (__get_user(c, f)) { memset(t, 0, n); break; } t++ = c; f++; n--; } return n; } int copy_mount_options(const void __user data, unsigned long where) { int i; unsigned long page; unsigned long size; where = 0; if (!data) return 0; if (!(page = __get_free_page(GFP_KERNEL))) return -ENOMEM; /* We only care that some data at the address the user * gave us is valid. Just in case, we'll zero * the remainder of the page. / / copy_from_user cannot cross TASK_SIZE ! / size = TASK_SIZE - (unsigned long)data; if (size > PAGE_SIZE) size = PAGE_SIZE; i = size - exact_copy_from_user((void )page, data, size); if (!i) { free_page(page); return -EFAULT; } if (i != PAGE_SIZE) memset((char )page + i, 0, PAGE_SIZE - i); where = page; return 0; } int copy_mount_string(const void __user data, char where) { char tmp; if (!data) { where = NULL; return 0; } tmp = strndup_user(data, PAGE_SIZE); if (IS_ERR(tmp)) return PTR_ERR(tmp); where = tmp; return 0; } /* * Flags is a 32-bit value that allows up to 31 non-fs dependent flags to * be given to the mount() call (ie: read-only, no-dev, no-suid etc). * * data is a (void ) that can point to any structure up to PAGE_SIZE-1 bytes, which can contain arbitrary fs-dependent * information (or be NULL). * * Pre-0.97 versions of mount() didn't have a flags word. * When the flags word was introduced its top half was required * to have the magic value 0xC0ED, and this remained so until 2.4.0-test9. * Therefore, if this magic number is present, it carries no information * and must be discarded. / long do_mount(const char dev_name, const char dir_name, const char type_page, unsigned long flags, void data_page) { struct path path; int retval = 0; int mnt_flags = 0; / Discard magic / if ((flags & MS_MGC_MSK) == MS_MGC_VAL) flags &= ~MS_MGC_MSK; / Basic sanity checks / if (!dir_name \|\| !dir_name \|\| !memchr(dir_name, 0, PAGE_SIZE)) return -EINVAL; if (data_page) ((char )data_page)[PAGE_SIZE - 1] = 0; / ... and get the mountpoint / retval = kern_path(dir_name, LOOKUP_FOLLOW, &path); if (retval) return retval; retval = security_sb_mount(dev_name, &path, type_page, flags, data_page); if (!retval && !may_mount()) retval = -EPERM; if (retval) goto dput_out; / Default to relatime unless overriden / if (!(flags & MS_NOATIME)) mnt_flags \|= MNT_RELATIME; / Separate the per-mountpoint flags / if (flags & MS_NOSUID) mnt_flags \|= MNT_NOSUID; if (flags & MS_NODEV) mnt_flags \|= MNT_NODEV; if (flags & MS_NOEXEC) mnt_flags \|= MNT_NOEXEC; if (flags & MS_NOATIME) mnt_flags \|= MNT_NOATIME; if (flags & MS_NODIRATIME) mnt_flags \|= MNT_NODIRATIME; if (flags & MS_STRICTATIME) mnt_flags &= ~(MNT_RELATIME \| MNT_NOATIME); if (flags & MS_RDONLY) mnt_flags \|= MNT_READONLY; flags &= ~(MS_NOSUID \| MS_NOEXEC \| MS_NODEV \| MS_ACTIVE \| MS_BORN \| MS_NOATIME \| MS_NODIRATIME \| MS_RELATIME\| MS_KERNMOUNT \| MS_STRICTATIME); if (flags & MS_REMOUNT) retval = do_remount(&path, flags & ~MS_REMOUNT, mnt_flags, data_page); else if (flags & MS_BIND) retval = do_loopback(&path, dev_name, flags & MS_REC); else if (flags & (MS_SHARED \| MS_PRIVATE \| MS_SLAVE \| MS_UNBINDABLE)) retval = do_change_type(&path, flags); else if (flags & MS_MOVE) retval = do_move_mount(&path, dev_name); else retval = do_new_mount(&path, type_page, flags, mnt_flags, dev_name, data_page); dput_out: path_put(&path); return retval; } static void free_mnt_ns(struct mnt_namespace ns) { proc_free_inum(ns->proc_inum); put_user_ns(ns->user_ns); kfree(ns); } /* * Assign a sequence number so we can detect when we attempt to bind * mount a reference to an older mount namespace into the current * mount namespace, preventing reference counting loops. A 64bit * number incrementing at 10Ghz will take 12,427 years to wrap which * is effectively never, so we can ignore the possibility. / static atomic64_t mnt_ns_seq = ATOMIC64_INIT(1); static struct mnt_namespace alloc_mnt_ns(struct user_namespace user_ns) { struct mnt_namespace new_ns; int ret; new_ns = kmalloc(sizeof(struct mnt_namespace), GFP_KERNEL); if (!new_ns) return ERR_PTR(-ENOMEM); ret = proc_alloc_inum(&new_ns->proc_inum); if (ret) { kfree(new_ns); return ERR_PTR(ret); } new_ns->seq = atomic64_add_return(1, &mnt_ns_seq); atomic_set(&new_ns->count, 1); new_ns->root = NULL; INIT_LIST_HEAD(&new_ns->list); init_waitqueue_head(&new_ns->poll); new_ns->event = 0; new_ns->user_ns = get_user_ns(user_ns); return new_ns; } struct mnt_namespace copy_mnt_ns(unsigned long flags, struct mnt_namespace ns, struct user_namespace user_ns, struct fs_struct new_fs) { struct mnt_namespace new_ns; struct vfsmount rootmnt = NULL, pwdmnt = NULL; struct mount p, q; struct mount old; struct mount new; int copy_flags; BUG_ON(!ns); if (likely(!(flags & CLONE_NEWNS))) { get_mnt_ns(ns); return ns; } old = ns->root; new_ns = alloc_mnt_ns(user_ns); if (IS_ERR(new_ns)) return new_ns; namespace_lock(); / First pass: copy the tree topology / copy_flags = CL_COPY_UNBINDABLE \| CL_EXPIRE; if (user_ns != ns->user_ns) copy_flags \|= CL_SHARED_TO_SLAVE \| CL_UNPRIVILEGED; new = copy_tree(old, old->mnt.mnt_root, copy_flags); if (IS_ERR(new)) { namespace_unlock(); free_mnt_ns(new_ns); return ERR_CAST(new); } new_ns->root = new; list_add_tail(&new_ns->list, &new->mnt_list); / * Second pass: switch the tsk->fs->* elements and mark new vfsmounts * as belonging to new namespace. We have already acquired a private * fs_struct, so tsk->fs->lock is not needed. / p = old; q = new; while (p) { q->mnt_ns = new_ns; if (new_fs) { if (&p->mnt == new_fs->root.mnt) { new_fs->root.mnt = mntget(&q->mnt); rootmnt = &p->mnt; } if (&p->mnt == new_fs->pwd.mnt) { new_fs->pwd.mnt = mntget(&q->mnt); pwdmnt = &p->mnt; } } p = next_mnt(p, old); q = next_mnt(q, new); if (!q) break; while (p->mnt.mnt_root != q->mnt.mnt_root) p = next_mnt(p, old); } namespace_unlock(); if (rootmnt) mntput(rootmnt); if (pwdmnt) mntput(pwdmnt); return new_ns; } /* * create_mnt_ns - creates a private namespace and adds a root filesystem * @mnt: pointer to the new root filesystem mountpoint / static struct mnt_namespace create_mnt_ns(struct vfsmount m) { struct mnt_namespace new_ns = alloc_mnt_ns(&init_user_ns); if (!IS_ERR(new_ns)) { struct mount mnt = real_mount(m); mnt->mnt_ns = new_ns; new_ns->root = mnt; list_add(&mnt->mnt_list, &new_ns->list); } else { mntput(m); } return new_ns; } struct dentry mount_subtree(struct vfsmount mnt, const char name) { struct mnt_namespace ns; struct super_block s; struct path path; int err; ns = create_mnt_ns(mnt); if (IS_ERR(ns)) return ERR_CAST(ns); err = vfs_path_lookup(mnt->mnt_root, mnt, name, LOOKUP_FOLLOW\|LOOKUP_AUTOMOUNT, &path); put_mnt_ns(ns); if (err) return ERR_PTR(err); /* trade a vfsmount reference for active sb one / s = path.mnt->mnt_sb; atomic_inc(&s->s_active); mntput(path.mnt); / lock the sucker / down_write(&s->s_umount); / ... and return the root of (sub)tree on it / return path.dentry; } EXPORT_SYMBOL(mount_subtree); SYSCALL_DEFINE5(mount, char __user , dev_name, char __user , dir_name, char __user , type, unsigned long, flags, void __user , data) { int ret; char kernel_type; struct filename kernel_dir; char kernel_dev; unsigned long data_page; ret = copy_mount_string(type, &kernel_type); if (ret < 0) goto out_type; kernel_dir = getname(dir_name); if (IS_ERR(kernel_dir)) { ret = PTR_ERR(kernel_dir); goto out_dir; } ret = copy_mount_string(dev_name, &kernel_dev); if (ret < 0) goto out_dev; ret = copy_mount_options(data, &data_page); if (ret < 0) goto out_data; ret = do_mount(kernel_dev, kernel_dir->name, kernel_type, flags, (void ) data_page); free_page(data_page); out_data: kfree(kernel_dev); out_dev: putname(kernel_dir); out_dir: kfree(kernel_type); out_type: return ret; } / * Return true if path is reachable from root * * namespace_sem or mount_lock is held / bool is_path_reachable(struct mount mnt, struct dentry dentry, const struct path root) { while (&mnt->mnt != root->mnt && mnt_has_parent(mnt)) { dentry = mnt->mnt_mountpoint; mnt = mnt->mnt_parent; } return &mnt->mnt == root->mnt && is_subdir(dentry, root->dentry); } int path_is_under(struct path path1, struct path path2) { int res; read_seqlock_excl(&mount_lock); res = is_path_reachable(real_mount(path1->mnt), path1->dentry, path2); read_sequnlock_excl(&mount_lock); return res; } EXPORT_SYMBOL(path_is_under); /* * pivot_root Semantics: * Moves the root file system of the current process to the directory put_old, * makes new_root as the new root file system of the current process, and sets * root/cwd of all processes which had them on the current root to new_root. * * Restrictions: * The new_root and put_old must be directories, and must not be on the * same file system as the current process root. The put_old must be * underneath new_root, i.e. adding a non-zero number of /.. to the string * pointed to by put_old must yield the same directory as new_root. No other * file system may be mounted on put_old. After all, new_root is a mountpoint. * * Also, the current root cannot be on the 'rootfs' (initial ramfs) filesystem. * See Documentation/filesystems/ramfs-rootfs-initramfs.txt for alternatives * in this situation. * * Notes: * - we don't move root/cwd if they are not at the root (reason: if something * cared enough to change them, it's probably wrong to force them elsewhere) * - it's okay to pick a root that isn't the root of a file system, e.g. * /nfs/my_root where /nfs is the mount point. It must be a mountpoint, * though, so you may need to say mount --bind /nfs/my_root /nfs/my_root * first. / SYSCALL_DEFINE2(pivot_root, const char __user , new_root, const char __user , put_old) { struct path new, old, parent_path, root_parent, root; struct mount new_mnt, root_mnt, old_mnt; struct mountpoint old_mp, root_mp; int error; if (!may_mount()) return -EPERM; error = user_path_dir(new_root, &new); if (error) goto out0; error = user_path_dir(put_old, &old); if (error) goto out1; error = security_sb_pivotroot(&old, &new); if (error) goto out2; get_fs_root(current->fs, &root); old_mp = lock_mount(&old); error = PTR_ERR(old_mp); if (IS_ERR(old_mp)) goto out3; error = -EINVAL; new_mnt = real_mount(new.mnt); root_mnt = real_mount(root.mnt); old_mnt = real_mount(old.mnt); if (IS_MNT_SHARED(old_mnt) \|\| IS_MNT_SHARED(new_mnt->mnt_parent) \|\| IS_MNT_SHARED(root_mnt->mnt_parent)) goto out4; if (!check_mnt(root_mnt) \|\| !check_mnt(new_mnt)) goto out4; if (new_mnt->mnt.mnt_flags & MNT_LOCKED) goto out4; error = -ENOENT; if (d_unlinked(new.dentry)) goto out4; error = -EBUSY; if (new_mnt == root_mnt \|\| old_mnt == root_mnt) goto out4; /* loop, on the same file system / error = -EINVAL; if (root.mnt->mnt_root != root.dentry) goto out4; / not a mountpoint / if (!mnt_has_parent(root_mnt)) goto out4; / not attached / root_mp = root_mnt->mnt_mp; if (new.mnt->mnt_root != new.dentry) goto out4; / not a mountpoint / if (!mnt_has_parent(new_mnt)) goto out4; / not attached / / make sure we can reach put_old from new_root / if (!is_path_reachable(old_mnt, old.dentry, &new)) goto out4; root_mp->m_count++; / pin it so it won't go away / lock_mount_hash(); detach_mnt(new_mnt, &parent_path); detach_mnt(root_mnt, &root_parent); if (root_mnt->mnt.mnt_flags & MNT_LOCKED) { new_mnt->mnt.mnt_flags \|= MNT_LOCKED; root_mnt->mnt.mnt_flags &= ~MNT_LOCKED; } / mount old root on put_old / attach_mnt(root_mnt, old_mnt, old_mp); / mount new_root on / / attach_mnt(new_mnt, real_mount(root_parent.mnt), root_mp); touch_mnt_namespace(current->nsproxy->mnt_ns); unlock_mount_hash(); chroot_fs_refs(&root, &new); put_mountpoint(root_mp); error = 0; out4: unlock_mount(old_mp); if (!error) { path_put(&root_parent); path_put(&parent_path); } out3: path_put(&root); out2: path_put(&old); out1: path_put(&new); out0: return error; } static void __init init_mount_tree(void) { struct vfsmount mnt; struct mnt_namespace ns; struct path root; struct file_system_type type; type = get_fs_type("rootfs"); if (!type) panic("Can't find rootfs type"); mnt = vfs_kern_mount(type, 0, "rootfs", NULL); put_filesystem(type); if (IS_ERR(mnt)) panic("Can't create rootfs"); ns = create_mnt_ns(mnt); if (IS_ERR(ns)) panic("Can't allocate initial namespace"); init_task.nsproxy->mnt_ns = ns; get_mnt_ns(ns); root.mnt = mnt; root.dentry = mnt->mnt_root; set_fs_pwd(current->fs, &root); set_fs_root(current->fs, &root); } void __init mnt_init(void) { unsigned u; int err; mnt_cache = kmem_cache_create("mnt_cache", sizeof(struct mount), 0, SLAB_HWCACHE_ALIGN \| SLAB_PANIC, NULL); mount_hashtable = alloc_large_system_hash("Mount-cache", sizeof(struct hlist_head), mhash_entries, 19, 0, &m_hash_shift, &m_hash_mask, 0, 0); mountpoint_hashtable = alloc_large_system_hash("Mountpoint-cache", sizeof(struct hlist_head), mphash_entries, 19, 0, &mp_hash_shift, &mp_hash_mask, 0, 0); if (!mount_hashtable \|\| !mountpoint_hashtable) panic("Failed to allocate mount hash table\n"); for (u = 0; u <= m_hash_mask; u++) INIT_HLIST_HEAD(&mount_hashtable[u]); for (u = 0; u <= mp_hash_mask; u++) INIT_HLIST_HEAD(&mountpoint_hashtable[u]); kernfs_init(); err = sysfs_init(); if (err) printk(KERN_WARNING "%s: sysfs_init error: %d\n", __func__, err); fs_kobj = kobject_create_and_add("fs", NULL); if (!fs_kobj) printk(KERN_WARNING "%s: kobj create error\n", __func__); init_rootfs(); init_mount_tree(); } void put_mnt_ns(struct mnt_namespace ns) { if (!atomic_dec_and_test(&ns->count)) return; drop_collected_mounts(&ns->root->mnt); free_mnt_ns(ns); } struct vfsmount kern_mount_data(struct file_system_type type, void data) { struct vfsmount mnt; mnt = vfs_kern_mount(type, MS_KERNMOUNT, type->name, data); if (!IS_ERR(mnt)) { / * it is a longterm mount, don't release mnt until * we unmount before file sys is unregistered / real_mount(mnt)->mnt_ns = MNT_NS_INTERNAL; } return mnt; } EXPORT_SYMBOL_GPL(kern_mount_data); void kern_unmount(struct vfsmount mnt) { /* release long term mount so mount point can be released / if (!IS_ERR_OR_NULL(mnt)) { real_mount(mnt)->mnt_ns = NULL; synchronize_rcu(); / yecchhh... / mntput(mnt); } } EXPORT_SYMBOL(kern_unmount); bool our_mnt(struct vfsmount mnt) { return check_mnt(real_mount(mnt)); } bool current_chrooted(void) { /* Does the current process have a non-standard root / struct path ns_root; struct path fs_root; bool chrooted; / Find the namespace root / ns_root.mnt = &current->nsproxy->mnt_ns->root->mnt; ns_root.dentry = ns_root.mnt->mnt_root; path_get(&ns_root); while (d_mountpoint(ns_root.dentry) && follow_down_one(&ns_root)) ; get_fs_root(current->fs, &fs_root); chrooted = !path_equal(&fs_root, &ns_root); path_put(&fs_root); path_put(&ns_root); return chrooted; } bool fs_fully_visible(struct file_system_type type) { struct mnt_namespace ns = current->nsproxy->mnt_ns; struct mount mnt; bool visible = false; if (unlikely(!ns)) return false; down_read(&namespace_sem); list_for_each_entry(mnt, &ns->list, mnt_list) { struct mount child; if (mnt->mnt.mnt_sb->s_type != type) continue; / This mount is not fully visible if there are any child mounts * that cover anything except for empty directories. / list_for_each_entry(child, &mnt->mnt_mounts, mnt_child) { struct inode inode = child->mnt_mountpoint->d_inode; if (!S_ISDIR(inode->i_mode)) goto next; if (inode->i_nlink > 2) goto next; } visible = true; goto found; next: ; } found: up_read(&namespace_sem); return visible; } static void mntns_get(struct task_struct task) { struct mnt_namespace ns = NULL; struct nsproxy nsproxy; task_lock(task); nsproxy = task->nsproxy; if (nsproxy) { ns = nsproxy->mnt_ns; get_mnt_ns(ns); } task_unlock(task); return ns; } static void mntns_put(void ns) { put_mnt_ns(ns); } static int mntns_install(struct nsproxy nsproxy, void ns) { struct fs_struct fs = current->fs; struct mnt_namespace mnt_ns = ns; struct path root; if (!ns_capable(mnt_ns->user_ns, CAP_SYS_ADMIN) \|\| !ns_capable(current_user_ns(), CAP_SYS_CHROOT) \|\| !ns_capable(current_user_ns(), CAP_SYS_ADMIN)) return -EPERM; if (fs->users != 1) return -EINVAL; get_mnt_ns(mnt_ns); put_mnt_ns(nsproxy->mnt_ns); nsproxy->mnt_ns = mnt_ns; / Find the root / root.mnt = &mnt_ns->root->mnt; root.dentry = mnt_ns->root->mnt.mnt_root; path_get(&root); while(d_mountpoint(root.dentry) && follow_down_one(&root)) ; / Update the pwd and root / set_fs_pwd(fs, &root); set_fs_root(fs, &root); path_put(&root); return 0; } static unsigned int mntns_inum(void ns) { struct mnt_namespace *mnt_ns = ns; return mnt_ns->proc_inum; } const struct proc_ns_operations mntns_operations = { .name = "mnt", .type = CLONE_NEWNS, .get = mntns_get, .put = mntns_put, .install = mntns_install, .inum = mntns_inum, };	./CrossVul/dataset_final_sorted/CWE-264/c/good_2243_0
crossvul-cpp_data_good_2423_5	/* * linux/arch/arm/kernel/traps.c * * Copyright (C) 1995-2009 Russell King * Fragments that appear the same as linux/arch/i386/kernel/traps.c (C) Linus Torvalds * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. * * 'traps.c' handles hardware exceptions after we have saved some state in * 'linux/arch/arm/lib/traps.S'. Mostly a debugging aid, but will probably * kill the offending process. / #include <linux/signal.h> #include <linux/personality.h> #include <linux/kallsyms.h> #include <linux/spinlock.h> #include <linux/uaccess.h> #include <linux/hardirq.h> #include <linux/kdebug.h> #include <linux/module.h> #include <linux/kexec.h> #include <linux/bug.h> #include <linux/delay.h> #include <linux/init.h> #include <linux/sched.h> #include <linux/atomic.h> #include <asm/cacheflush.h> #include <asm/exception.h> #include <asm/unistd.h> #include <asm/traps.h> #include <asm/unwind.h> #include <asm/tls.h> #include <asm/system_misc.h> #include "signal.h" static const char handler[]= { "prefetch abort", "data abort", "address exception", "interrupt" }; void vectors_page; #ifdef CONFIG_DEBUG_USER unsigned int user_debug; static int __init user_debug_setup(char str) { get_option(&str, &user_debug); return 1; } __setup("user_debug=", user_debug_setup); #endif static void dump_mem(const char , const char , unsigned long, unsigned long); void dump_backtrace_entry(unsigned long where, unsigned long from, unsigned long frame) { #ifdef CONFIG_KALLSYMS printk("[<%08lx>] (%pS) from [<%08lx>] (%pS)\n", where, (void )where, from, (void )from); #else printk("Function entered at [<%08lx>] from [<%08lx>]\n", where, from); #endif if (in_exception_text(where)) dump_mem("", "Exception stack", frame + 4, frame + 4 + sizeof(struct pt_regs)); } #ifndef CONFIG_ARM_UNWIND /* * Stack pointers should always be within the kernels view of * physical memory. If it is not there, then we can't dump * out any information relating to the stack. / static int verify_stack(unsigned long sp) { if (sp < PAGE_OFFSET \|\| (sp > (unsigned long)high_memory && high_memory != NULL)) return -EFAULT; return 0; } #endif / * Dump out the contents of some memory nicely... / static void dump_mem(const char lvl, const char str, unsigned long bottom, unsigned long top) { unsigned long first; mm_segment_t fs; int i; / * We need to switch to kernel mode so that we can use __get_user * to safely read from kernel space. Note that we now dump the * code first, just in case the backtrace kills us. / fs = get_fs(); set_fs(KERNEL_DS); printk("%s%s(0x%08lx to 0x%08lx)\n", lvl, str, bottom, top); for (first = bottom & ~31; first < top; first += 32) { unsigned long p; char str[sizeof(" 12345678") 8 + 1]; memset(str, ' ', sizeof(str)); str[sizeof(str) - 1] = '\0'; for (p = first, i = 0; i < 8 && p < top; i++, p += 4) { if (p >= bottom && p < top) { unsigned long val; if (__get_user(val, (unsigned long )p) == 0) sprintf(str + i 9, " %08lx", val); else sprintf(str + i * 9, " ????????"); } } printk("%s%04lx:%s\n", lvl, first & 0xffff, str); } set_fs(fs); } static void dump_instr(const char lvl, struct pt_regs regs) { unsigned long addr = instruction_pointer(regs); const int thumb = thumb_mode(regs); const int width = thumb ? 4 : 8; mm_segment_t fs; char str[sizeof("00000000 ") * 5 + 2 + 1], p = str; int i; / * We need to switch to kernel mode so that we can use __get_user * to safely read from kernel space. Note that we now dump the * code first, just in case the backtrace kills us. / fs = get_fs(); set_fs(KERNEL_DS); for (i = -4; i < 1 + !!thumb; i++) { unsigned int val, bad; if (thumb) bad = __get_user(val, &((u16 )addr)[i]); else bad = __get_user(val, &((u32 )addr)[i]); if (!bad) p += sprintf(p, i == 0 ? "(%0x) " : "%0x ", width, val); else { p += sprintf(p, "bad PC value"); break; } } printk("%sCode: %s\n", lvl, str); set_fs(fs); } #ifdef CONFIG_ARM_UNWIND static inline void dump_backtrace(struct pt_regs regs, struct task_struct tsk) { unwind_backtrace(regs, tsk); } #else static void dump_backtrace(struct pt_regs regs, struct task_struct tsk) { unsigned int fp, mode; int ok = 1; printk("Backtrace: "); if (!tsk) tsk = current; if (regs) { fp = regs->ARM_fp; mode = processor_mode(regs); } else if (tsk != current) { fp = thread_saved_fp(tsk); mode = 0x10; } else { asm("mov %0, fp" : "=r" (fp) : : "cc"); mode = 0x10; } if (!fp) { printk("no frame pointer"); ok = 0; } else if (verify_stack(fp)) { printk("invalid frame pointer 0x%08x", fp); ok = 0; } else if (fp < (unsigned long)end_of_stack(tsk)) printk("frame pointer underflow"); printk("\n"); if (ok) c_backtrace(fp, mode); } #endif void show_stack(struct task_struct tsk, unsigned long sp) { dump_backtrace(NULL, tsk); barrier(); } #ifdef CONFIG_PREEMPT #define S_PREEMPT " PREEMPT" #else #define S_PREEMPT "" #endif #ifdef CONFIG_SMP #define S_SMP " SMP" #else #define S_SMP "" #endif #ifdef CONFIG_THUMB2_KERNEL #define S_ISA " THUMB2" #else #define S_ISA " ARM" #endif static int __die(const char str, int err, struct pt_regs regs) { struct task_struct tsk = current; static int die_counter; int ret; printk(KERN_EMERG "Internal error: %s: %x [#%d]" S_PREEMPT S_SMP S_ISA "\n", str, err, ++die_counter); /* trap and error numbers are mostly meaningless on ARM / ret = notify_die(DIE_OOPS, str, regs, err, tsk->thread.trap_no, SIGSEGV); if (ret == NOTIFY_STOP) return 1; print_modules(); __show_regs(regs); printk(KERN_EMERG "Process %.s (pid: %d, stack limit = 0x%p)\n", TASK_COMM_LEN, tsk->comm, task_pid_nr(tsk), end_of_stack(tsk)); if (!user_mode(regs) \|\| in_interrupt()) { dump_mem(KERN_EMERG, "Stack: ", regs->ARM_sp, THREAD_SIZE + (unsigned long)task_stack_page(tsk)); dump_backtrace(regs, tsk); dump_instr(KERN_EMERG, regs); } return 0; } static arch_spinlock_t die_lock = __ARCH_SPIN_LOCK_UNLOCKED; static int die_owner = -1; static unsigned int die_nest_count; static unsigned long oops_begin(void) { int cpu; unsigned long flags; oops_enter(); /* racy, but better than risking deadlock. / raw_local_irq_save(flags); cpu = smp_processor_id(); if (!arch_spin_trylock(&die_lock)) { if (cpu == die_owner) / nested oops. should stop eventually /; else arch_spin_lock(&die_lock); } die_nest_count++; die_owner = cpu; console_verbose(); bust_spinlocks(1); return flags; } static void oops_end(unsigned long flags, struct pt_regs regs, int signr) { if (regs && kexec_should_crash(current)) crash_kexec(regs); bust_spinlocks(0); die_owner = -1; add_taint(TAINT_DIE, LOCKDEP_NOW_UNRELIABLE); die_nest_count--; if (!die_nest_count) /* Nest count reaches zero, release the lock. / arch_spin_unlock(&die_lock); raw_local_irq_restore(flags); oops_exit(); if (in_interrupt()) panic("Fatal exception in interrupt"); if (panic_on_oops) panic("Fatal exception"); if (signr) do_exit(signr); } / * This function is protected against re-entrancy. / void die(const char str, struct pt_regs regs, int err) { enum bug_trap_type bug_type = BUG_TRAP_TYPE_NONE; unsigned long flags = oops_begin(); int sig = SIGSEGV; if (!user_mode(regs)) bug_type = report_bug(regs->ARM_pc, regs); if (bug_type != BUG_TRAP_TYPE_NONE) str = "Oops - BUG"; if (__die(str, err, regs)) sig = 0; oops_end(flags, regs, sig); } void arm_notify_die(const char str, struct pt_regs regs, struct siginfo info, unsigned long err, unsigned long trap) { if (user_mode(regs)) { current->thread.error_code = err; current->thread.trap_no = trap; force_sig_info(info->si_signo, info, current); } else { die(str, regs, err); } } #ifdef CONFIG_GENERIC_BUG int is_valid_bugaddr(unsigned long pc) { #ifdef CONFIG_THUMB2_KERNEL unsigned short bkpt; #else unsigned long bkpt; #endif if (probe_kernel_address((unsigned )pc, bkpt)) return 0; return bkpt == BUG_INSTR_VALUE; } #endif static LIST_HEAD(undef_hook); static DEFINE_RAW_SPINLOCK(undef_lock); void register_undef_hook(struct undef_hook hook) { unsigned long flags; raw_spin_lock_irqsave(&undef_lock, flags); list_add(&hook->node, &undef_hook); raw_spin_unlock_irqrestore(&undef_lock, flags); } void unregister_undef_hook(struct undef_hook hook) { unsigned long flags; raw_spin_lock_irqsave(&undef_lock, flags); list_del(&hook->node); raw_spin_unlock_irqrestore(&undef_lock, flags); } static int call_undef_hook(struct pt_regs regs, unsigned int instr) { struct undef_hook hook; unsigned long flags; int (fn)(struct pt_regs regs, unsigned int instr) = NULL; raw_spin_lock_irqsave(&undef_lock, flags); list_for_each_entry(hook, &undef_hook, node) if ((instr & hook->instr_mask) == hook->instr_val && (regs->ARM_cpsr & hook->cpsr_mask) == hook->cpsr_val) fn = hook->fn; raw_spin_unlock_irqrestore(&undef_lock, flags); return fn ? fn(regs, instr) : 1; } asmlinkage void __exception do_undefinstr(struct pt_regs regs) { unsigned int instr; siginfo_t info; void __user pc; pc = (void __user )instruction_pointer(regs); if (processor_mode(regs) == SVC_MODE) { #ifdef CONFIG_THUMB2_KERNEL if (thumb_mode(regs)) { instr = ((u16 )pc)[0]; if (is_wide_instruction(instr)) { instr <<= 16; instr \|= ((u16 )pc)[1]; } } else #endif instr = (u32 ) pc; } else if (thumb_mode(regs)) { if (get_user(instr, (u16 __user )pc)) goto die_sig; if (is_wide_instruction(instr)) { unsigned int instr2; if (get_user(instr2, (u16 __user )pc+1)) goto die_sig; instr <<= 16; instr \|= instr2; } } else if (get_user(instr, (u32 __user )pc)) { goto die_sig; } if (call_undef_hook(regs, instr) == 0) return; die_sig: #ifdef CONFIG_DEBUG_USER if (user_debug & UDBG_UNDEFINED) { printk(KERN_INFO "%s (%d): undefined instruction: pc=%p\n", current->comm, task_pid_nr(current), pc); dump_instr(KERN_INFO, regs); } #endif info.si_signo = SIGILL; info.si_errno = 0; info.si_code = ILL_ILLOPC; info.si_addr = pc; arm_notify_die("Oops - undefined instruction", regs, &info, 0, 6); } asmlinkage void do_unexp_fiq (struct pt_regs regs) { printk("Hmm. Unexpected FIQ received, but trying to continue\n"); printk("You may have a hardware problem...\n"); } /* * bad_mode handles the impossible case in the vectors. If you see one of * these, then it's extremely serious, and could mean you have buggy hardware. * It never returns, and never tries to sync. We hope that we can at least * dump out some state information... / asmlinkage void bad_mode(struct pt_regs regs, int reason) { console_verbose(); printk(KERN_CRIT "Bad mode in %s handler detected\n", handler[reason]); die("Oops - bad mode", regs, 0); local_irq_disable(); panic("bad mode"); } static int bad_syscall(int n, struct pt_regs regs) { struct thread_info thread = current_thread_info(); siginfo_t info; if ((current->personality & PER_MASK) != PER_LINUX && thread->exec_domain->handler) { thread->exec_domain->handler(n, regs); return regs->ARM_r0; } #ifdef CONFIG_DEBUG_USER if (user_debug & UDBG_SYSCALL) { printk(KERN_ERR "[%d] %s: obsolete system call %08x.\n", task_pid_nr(current), current->comm, n); dump_instr(KERN_ERR, regs); } #endif info.si_signo = SIGILL; info.si_errno = 0; info.si_code = ILL_ILLTRP; info.si_addr = (void __user )instruction_pointer(regs) - (thumb_mode(regs) ? 2 : 4); arm_notify_die("Oops - bad syscall", regs, &info, n, 0); return regs->ARM_r0; } static inline int do_cache_op(unsigned long start, unsigned long end, int flags) { struct mm_struct mm = current->active_mm; struct vm_area_struct vma; if (end < start \|\| flags) return -EINVAL; down_read(&mm->mmap_sem); vma = find_vma(mm, start); if (vma && vma->vm_start < end) { if (start < vma->vm_start) start = vma->vm_start; if (end > vma->vm_end) end = vma->vm_end; up_read(&mm->mmap_sem); return flush_cache_user_range(start, end); } up_read(&mm->mmap_sem); return -EINVAL; } / * Handle all unrecognised system calls. * 0x9f0000 - 0x9fffff are some more esoteric system calls / #define NR(x) ((__ARM_NR_##x) - __ARM_NR_BASE) asmlinkage int arm_syscall(int no, struct pt_regs regs) { struct thread_info thread = current_thread_info(); siginfo_t info; if ((no >> 16) != (__ARM_NR_BASE>> 16)) return bad_syscall(no, regs); switch (no & 0xffff) { case 0: / branch through 0 / info.si_signo = SIGSEGV; info.si_errno = 0; info.si_code = SEGV_MAPERR; info.si_addr = NULL; arm_notify_die("branch through zero", regs, &info, 0, 0); return 0; case NR(breakpoint): / SWI BREAK_POINT / regs->ARM_pc -= thumb_mode(regs) ? 2 : 4; ptrace_break(current, regs); return regs->ARM_r0; / * Flush a region from virtual address 'r0' to virtual address 'r1' * _exclusive_. There is no alignment requirement on either address; * user space does not need to know the hardware cache layout. * * r2 contains flags. It should ALWAYS be passed as ZERO until it * is defined to be something else. For now we ignore it, but may * the fires of hell burn in your belly if you break this rule. ;) * * (at a later date, we may want to allow this call to not flush * various aspects of the cache. Passing '0' will guarantee that * everything necessary gets flushed to maintain consistency in * the specified region). / case NR(cacheflush): return do_cache_op(regs->ARM_r0, regs->ARM_r1, regs->ARM_r2); case NR(usr26): if (!(elf_hwcap & HWCAP_26BIT)) break; regs->ARM_cpsr &= ~MODE32_BIT; return regs->ARM_r0; case NR(usr32): if (!(elf_hwcap & HWCAP_26BIT)) break; regs->ARM_cpsr \|= MODE32_BIT; return regs->ARM_r0; case NR(set_tls): thread->tp_value[0] = regs->ARM_r0; if (tls_emu) return 0; if (has_tls_reg) { asm ("mcr p15, 0, %0, c13, c0, 3" : : "r" (regs->ARM_r0)); } else { / * User space must never try to access this directly. * Expect your app to break eventually if you do so. * The user helper at 0xffff0fe0 must be used instead. * (see entry-armv.S for details) / ((unsigned int )0xffff0ff0) = regs->ARM_r0; } return 0; #ifdef CONFIG_NEEDS_SYSCALL_FOR_CMPXCHG / * Atomically store r1 in r2 if r2 is equal to r0 for user space. * Return zero in r0 if MEM was changed or non-zero if no exchange happened. Also set the user C flag accordingly. * If access permissions have to be fixed up then non-zero is * returned and the operation has to be re-attempted. * * NOTE: This is a ghost syscall private to the kernel. Only the * __kuser_cmpxchg code in entry-armv.S should be aware of its * existence. Don't ever use this from user code. / case NR(cmpxchg): for (;;) { extern void do_DataAbort(unsigned long addr, unsigned int fsr, struct pt_regs regs); unsigned long val; unsigned long addr = regs->ARM_r2; struct mm_struct mm = current->mm; pgd_t pgd; pmd_t pmd; pte_t pte; spinlock_t ptl; regs->ARM_cpsr &= ~PSR_C_BIT; down_read(&mm->mmap_sem); pgd = pgd_offset(mm, addr); if (!pgd_present(pgd)) goto bad_access; pmd = pmd_offset(pgd, addr); if (!pmd_present(pmd)) goto bad_access; pte = pte_offset_map_lock(mm, pmd, addr, &ptl); if (!pte_present(pte) \|\| !pte_write(pte) \|\| !pte_dirty(pte)) { pte_unmap_unlock(pte, ptl); goto bad_access; } val = (unsigned long )addr; val -= regs->ARM_r0; if (val == 0) { (unsigned long )addr = regs->ARM_r1; regs->ARM_cpsr \|= PSR_C_BIT; } pte_unmap_unlock(pte, ptl); up_read(&mm->mmap_sem); return val; bad_access: up_read(&mm->mmap_sem); /* simulate a write access fault / do_DataAbort(addr, 15 + (1 << 11), regs); } #endif default: / Calls 9f00xx..9f07ff are defined to return -ENOSYS if not implemented, rather than raising SIGILL. This way the calling program can gracefully determine whether a feature is supported. / if ((no & 0xffff) <= 0x7ff) return -ENOSYS; break; } #ifdef CONFIG_DEBUG_USER / * experience shows that these seem to indicate that * something catastrophic has happened / if (user_debug & UDBG_SYSCALL) { printk("[%d] %s: arm syscall %d\n", task_pid_nr(current), current->comm, no); dump_instr("", regs); if (user_mode(regs)) { __show_regs(regs); c_backtrace(regs->ARM_fp, processor_mode(regs)); } } #endif info.si_signo = SIGILL; info.si_errno = 0; info.si_code = ILL_ILLTRP; info.si_addr = (void __user )instruction_pointer(regs) - (thumb_mode(regs) ? 2 : 4); arm_notify_die("Oops - bad syscall(2)", regs, &info, no, 0); return 0; } #ifdef CONFIG_TLS_REG_EMUL /* * We might be running on an ARMv6+ processor which should have the TLS * register but for some reason we can't use it, or maybe an SMP system * using a pre-ARMv6 processor (there are apparently a few prototypes like * that in existence) and therefore access to that register must be * emulated. / static int get_tp_trap(struct pt_regs regs, unsigned int instr) { int reg = (instr >> 12) & 15; if (reg == 15) return 1; regs->uregs[reg] = current_thread_info()->tp_value[0]; regs->ARM_pc += 4; return 0; } static struct undef_hook arm_mrc_hook = { .instr_mask = 0x0fff0fff, .instr_val = 0x0e1d0f70, .cpsr_mask = PSR_T_BIT, .cpsr_val = 0, .fn = get_tp_trap, }; static int __init arm_mrc_hook_init(void) { register_undef_hook(&arm_mrc_hook); return 0; } late_initcall(arm_mrc_hook_init); #endif void __bad_xchg(volatile void ptr, int size) { printk("xchg: bad data size: pc 0x%p, ptr 0x%p, size %d\n", __builtin_return_address(0), ptr, size); BUG(); } EXPORT_SYMBOL(__bad_xchg); / * A data abort trap was taken, but we did not handle the instruction. * Try to abort the user program, or panic if it was the kernel. / asmlinkage void baddataabort(int code, unsigned long instr, struct pt_regs regs) { unsigned long addr = instruction_pointer(regs); siginfo_t info; #ifdef CONFIG_DEBUG_USER if (user_debug & UDBG_BADABORT) { printk(KERN_ERR "[%d] %s: bad data abort: code %d instr 0x%08lx\n", task_pid_nr(current), current->comm, code, instr); dump_instr(KERN_ERR, regs); show_pte(current->mm, addr); } #endif info.si_signo = SIGILL; info.si_errno = 0; info.si_code = ILL_ILLOPC; info.si_addr = (void __user )addr; arm_notify_die("unknown data abort code", regs, &info, instr, 0); } void __readwrite_bug(const char fn) { printk("%s called, but not implemented\n", fn); BUG(); } EXPORT_SYMBOL(__readwrite_bug); void __pte_error(const char file, int line, pte_t pte) { printk("%s:%d: bad pte %08llx.\n", file, line, (long long)pte_val(pte)); } void __pmd_error(const char file, int line, pmd_t pmd) { printk("%s:%d: bad pmd %08llx.\n", file, line, (long long)pmd_val(pmd)); } void __pgd_error(const char file, int line, pgd_t pgd) { printk("%s:%d: bad pgd %08llx.\n", file, line, (long long)pgd_val(pgd)); } asmlinkage void __div0(void) { printk("Division by zero in kernel.\n"); dump_stack(); } EXPORT_SYMBOL(__div0); void abort(void) { BUG(); / if that doesn't kill us, halt / panic("Oops failed to kill thread"); } EXPORT_SYMBOL(abort); void __init trap_init(void) { return; } static void __init kuser_get_tls_init(unsigned long vectors) { / * vectors + 0xfe0 = __kuser_get_tls * vectors + 0xfe8 = hardware TLS instruction at 0xffff0fe8 / if (tls_emu \|\| has_tls_reg) memcpy((void )vectors + 0xfe0, (void )vectors + 0xfe8, 4); } void __init early_trap_init(void vectors_base) { unsigned long vectors = (unsigned long)vectors_base; extern char __stubs_start[], __stubs_end[]; extern char __vectors_start[], __vectors_end[]; extern char __kuser_helper_start[], __kuser_helper_end[]; int kuser_sz = __kuser_helper_end - __kuser_helper_start; vectors_page = vectors_base; /* * Copy the vectors, stubs and kuser helpers (in entry-armv.S) * into the vector page, mapped at 0xffff0000, and ensure these * are visible to the instruction stream. / memcpy((void )vectors, __vectors_start, __vectors_end - __vectors_start); memcpy((void )vectors + 0x200, __stubs_start, __stubs_end - __stubs_start); memcpy((void )vectors + 0x1000 - kuser_sz, __kuser_helper_start, kuser_sz); /* * Do processor specific fixups for the kuser helpers / kuser_get_tls_init(vectors); / * Copy signal return handlers into the vector page, and * set sigreturn to be a pointer to these. / memcpy((void )(vectors + KERN_SIGRETURN_CODE - CONFIG_VECTORS_BASE), sigreturn_codes, sizeof(sigreturn_codes)); flush_icache_range(vectors, vectors + PAGE_SIZE); modify_domain(DOMAIN_USER, DOMAIN_CLIENT); }	./CrossVul/dataset_final_sorted/CWE-264/c/good_2423_5
crossvul-cpp_data_good_5861_34	/* * Glue code for optimized assembly version of Salsa20. * * Copyright (c) 2007 Tan Swee Heng <thesweeheng@gmail.com> * * The assembly codes are public domain assembly codes written by Daniel. J. * Bernstein <djb@cr.yp.to>. The codes are modified to include indentation * and to remove extraneous comments and functions that are not needed. * - i586 version, renamed as salsa20-i586-asm_32.S * available from <http://cr.yp.to/snuffle/salsa20/x86-pm/salsa20.s> * - x86-64 version, renamed as salsa20-x86_64-asm_64.S * available from <http://cr.yp.to/snuffle/salsa20/amd64-3/salsa20.s> * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the Free * Software Foundation; either version 2 of the License, or (at your option) * any later version. * / #include <crypto/algapi.h> #include <linux/module.h> #include <linux/crypto.h> #define SALSA20_IV_SIZE 8U #define SALSA20_MIN_KEY_SIZE 16U #define SALSA20_MAX_KEY_SIZE 32U struct salsa20_ctx { u32 input[16]; }; asmlinkage void salsa20_keysetup(struct salsa20_ctx ctx, const u8 k, u32 keysize, u32 ivsize); asmlinkage void salsa20_ivsetup(struct salsa20_ctx ctx, const u8 iv); asmlinkage void salsa20_encrypt_bytes(struct salsa20_ctx ctx, const u8 src, u8 dst, u32 bytes); static int setkey(struct crypto_tfm tfm, const u8 key, unsigned int keysize) { struct salsa20_ctx ctx = crypto_tfm_ctx(tfm); salsa20_keysetup(ctx, key, keysize8, SALSA20_IV_SIZE8); return 0; } static int encrypt(struct blkcipher_desc desc, struct scatterlist dst, struct scatterlist src, unsigned int nbytes) { struct blkcipher_walk walk; struct crypto_blkcipher tfm = desc->tfm; struct salsa20_ctx ctx = crypto_blkcipher_ctx(tfm); int err; blkcipher_walk_init(&walk, dst, src, nbytes); err = blkcipher_walk_virt_block(desc, &walk, 64); salsa20_ivsetup(ctx, walk.iv); if (likely(walk.nbytes == nbytes)) { salsa20_encrypt_bytes(ctx, walk.src.virt.addr, walk.dst.virt.addr, nbytes); return blkcipher_walk_done(desc, &walk, 0); } while (walk.nbytes >= 64) { salsa20_encrypt_bytes(ctx, walk.src.virt.addr, walk.dst.virt.addr, walk.nbytes - (walk.nbytes % 64)); err = blkcipher_walk_done(desc, &walk, walk.nbytes % 64); } if (walk.nbytes) { salsa20_encrypt_bytes(ctx, walk.src.virt.addr, walk.dst.virt.addr, walk.nbytes); err = blkcipher_walk_done(desc, &walk, 0); } return err; } static struct crypto_alg alg = { .cra_name = "salsa20", .cra_driver_name = "salsa20-asm", .cra_priority = 200, .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, .cra_type = &crypto_blkcipher_type, .cra_blocksize = 1, .cra_ctxsize = sizeof(struct salsa20_ctx), .cra_alignmask = 3, .cra_module = THIS_MODULE, .cra_u = { .blkcipher = { .setkey = setkey, .encrypt = encrypt, .decrypt = encrypt, .min_keysize = SALSA20_MIN_KEY_SIZE, .max_keysize = SALSA20_MAX_KEY_SIZE, .ivsize = SALSA20_IV_SIZE, } } }; static int __init init(void) { return crypto_register_alg(&alg); } static void __exit fini(void) { crypto_unregister_alg(&alg); } module_init(init); module_exit(fini); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION ("Salsa20 stream cipher algorithm (optimized assembly version)"); MODULE_ALIAS_CRYPTO("salsa20"); MODULE_ALIAS_CRYPTO("salsa20-asm");	./CrossVul/dataset_final_sorted/CWE-264/c/good_5861_34
crossvul-cpp_data_good_1661_6	/* * Copyright (c) 1987 Regents of the University of California. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software * must display the following acknowledgement: * This product includes software developed by the University of * California, Berkeley and its contributors. * 4. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * Updated Thu Oct 12 09:56:55 1995 by faith@cs.unc.edu with security * patches from Zefram <A.Main@dcs.warwick.ac.uk> * * Updated Thu Nov 9 21:58:53 1995 by Martin Schulze * <joey@finlandia.infodrom.north.de>. Support for vigr. * * Martin Schulze's patches adapted to Util-Linux by Nicolai Langfeldt. * * 1999-02-22 Arkadiusz Miśkiewicz <misiek@pld.ORG.PL> * - added Native Language Support * Sun Mar 21 1999 - Arnaldo Carvalho de Melo <acme@conectiva.com.br> * - fixed strerr(errno) in gettext calls / #include <errno.h> #include <fcntl.h> #include <paths.h> #include <pwd.h> #include <shadow.h> #include <signal.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/file.h> #include <sys/param.h> #include <sys/resource.h> #include <sys/stat.h> #include <sys/time.h> #include <sys/types.h> #include <sys/wait.h> #include <unistd.h> #include "c.h" #include "fileutils.h" #include "closestream.h" #include "nls.h" #include "setpwnam.h" #include "strutils.h" #include "xalloc.h" #include "rpmatch.h" #ifdef HAVE_LIBSELINUX # include <selinux/selinux.h> #endif #define FILENAMELEN 67 enum { VIPW, VIGR }; int program; char orig_file[FILENAMELEN]; / original file /etc/passwd or /etc/group / char tmp_file; /* tmp file / void pw_error __P((char , int, int)); static void copyfile(int from, int to) { int nr, nw, off; char buf[8 * 1024]; while ((nr = read(from, buf, sizeof(buf))) > 0) for (off = 0; off < nr; nr -= nw, off += nw) if ((nw = write(to, buf + off, nr)) < 0) pw_error(tmp_file, 1, 1); if (nr < 0) pw_error(orig_file, 1, 1); } static void pw_init(void) { struct rlimit rlim; /* Unlimited resource limits. / rlim.rlim_cur = rlim.rlim_max = RLIM_INFINITY; (void)setrlimit(RLIMIT_CPU, &rlim); (void)setrlimit(RLIMIT_FSIZE, &rlim); (void)setrlimit(RLIMIT_STACK, &rlim); (void)setrlimit(RLIMIT_DATA, &rlim); (void)setrlimit(RLIMIT_RSS, &rlim); / Don't drop core (not really necessary, but GP's). / rlim.rlim_cur = rlim.rlim_max = 0; (void)setrlimit(RLIMIT_CORE, &rlim); / Turn off signals. / (void)signal(SIGALRM, SIG_IGN); (void)signal(SIGHUP, SIG_IGN); (void)signal(SIGINT, SIG_IGN); (void)signal(SIGPIPE, SIG_IGN); (void)signal(SIGQUIT, SIG_IGN); (void)signal(SIGTERM, SIG_IGN); (void)signal(SIGTSTP, SIG_IGN); (void)signal(SIGTTOU, SIG_IGN); / Create with exact permissions. / (void)umask(0); } static FILE pw_tmpfile(int lockfd) { FILE fd; char tmpname = NULL; if ((fd = xfmkstemp(&tmpname, "/etc", ".vipw")) == NULL) { ulckpwdf(); err(EXIT_FAILURE, _("can't open temporary file")); } copyfile(lockfd, fileno(fd)); tmp_file = tmpname; return fd; } static void pw_write(void) { char tmp[FILENAMELEN + 4]; sprintf(tmp, "%s%s", orig_file, ".OLD"); unlink(tmp); if (link(orig_file, tmp)) warn(_("%s: create a link to %s failed"), orig_file, tmp); #ifdef HAVE_LIBSELINUX if (is_selinux_enabled() > 0) { security_context_t passwd_context = NULL; int ret = 0; if (getfilecon(orig_file, &passwd_context) < 0) { warnx(_("Can't get context for %s"), orig_file); pw_error(orig_file, 1, 1); } ret = setfilecon(tmp_file, passwd_context); freecon(passwd_context); if (ret != 0) { warnx(_("Can't set context for %s"), tmp_file); pw_error(tmp_file, 1, 1); } } #endif if (rename(tmp_file, orig_file) == -1) { int errsv = errno; errx(EXIT_FAILURE, ("cannot write %s: %s (your changes are still in %s)"), orig_file, strerror(errsv), tmp_file); } unlink(tmp_file); free(tmp_file); } static void pw_edit(void) { int pstat; pid_t pid; char p, editor, tk; editor = getenv("EDITOR"); editor = xstrdup(editor ? editor : _PATH_VI); tk = strtok(editor, " \t"); if (tk && (p = strrchr(tk, '/')) != NULL) ++p; else p = editor; pid = fork(); if (pid < 0) err(EXIT_FAILURE, _("fork failed")); if (!pid) { execlp(editor, p, tmp_file, NULL); / Shouldn't get here / _exit(EXIT_FAILURE); } for (;;) { pid = waitpid(pid, &pstat, WUNTRACED); if (WIFSTOPPED(pstat)) { / the editor suspended, so suspend us as well / kill(getpid(), SIGSTOP); kill(pid, SIGCONT); } else { break; } } if (pid == -1 \|\| !WIFEXITED(pstat) \|\| WEXITSTATUS(pstat) != 0) pw_error(editor, 1, 1); free(editor); } void __attribute__((__noreturn__)) pw_error(char name, int err, int eval) { if (err) { if (name) warn("%s: ", name); else warn(NULL); } warnx(_("%s unchanged"), orig_file); unlink(tmp_file); ulckpwdf(); exit(eval); } static void edit_file(int is_shadow) { struct stat begin, end; int passwd_file, ch_ret; FILE tmp_fd; pw_init(); / acquire exclusive lock / if (lckpwdf() < 0) err(EXIT_FAILURE, _("cannot get lock")); passwd_file = open(orig_file, O_RDONLY, 0); if (passwd_file < 0) err(EXIT_FAILURE, _("cannot open %s"), orig_file); tmp_fd = pw_tmpfile(passwd_file); if (fstat(fileno(tmp_fd), &begin)) pw_error(tmp_file, 1, 1); pw_edit(); if (fstat(fileno(tmp_fd), &end)) pw_error(tmp_file, 1, 1); / Some editors, such as Vim with 'writebackup' mode enabled, * use "atomic save" in which the old file is deleted and a new * one with the same name created in its place. / if (end.st_nlink == 0) { if (close_stream(tmp_fd) != 0) err(EXIT_FAILURE, _("write error")); tmp_fd = fopen(tmp_file, "r"); if (!tmp_file) err(EXIT_FAILURE, _("cannot open %s"), tmp_file); if (fstat(fileno(tmp_fd), &end)) pw_error(tmp_file, 1, 1); } if (begin.st_mtime == end.st_mtime) { warnx(_("no changes made")); pw_error((char )NULL, 0, 0); } /* pw_tmpfile() will create the file with mode 600 / if (!is_shadow) ch_ret = fchmod(fileno(tmp_fd), 0644); else ch_ret = fchmod(fileno(tmp_fd), 0400); if (ch_ret < 0) err(EXIT_FAILURE, "%s: %s", _("cannot chmod file"), orig_file); if (close_stream(tmp_fd) != 0) err(EXIT_FAILURE, _("write error")); pw_write(); close(passwd_file); ulckpwdf(); } static void __attribute__((__noreturn__)) usage(FILE out) { fputs(USAGE_HEADER, out); fprintf(out, " %s\n", program_invocation_short_name); fputs(USAGE_SEPARATOR, out); fputs(_("Edit the password or group file.\n"), out); fputs(USAGE_OPTIONS, out); fputs(USAGE_HELP, out); fputs(USAGE_VERSION, out); fprintf(out, USAGE_MAN_TAIL("vipw(8)")); exit(out == stderr ? EXIT_FAILURE : EXIT_SUCCESS); } int main(int argc, char argv[]) { setlocale(LC_ALL, ""); bindtextdomain(PACKAGE, LOCALEDIR); textdomain(PACKAGE); atexit(close_stdout); if (!strcmp(program_invocation_short_name, "vigr")) { program = VIGR; xstrncpy(orig_file, GROUP_FILE, sizeof(orig_file)); } else { program = VIPW; xstrncpy(orig_file, PASSWD_FILE, sizeof(orig_file)); } if (1 < argc) { if (!strcmp(argv[1], "-V") \|\| !strcmp(argv[1], "--version")) { printf(UTIL_LINUX_VERSION); exit(EXIT_SUCCESS); } if (!strcmp(argv[1], "-h") \|\| !strcmp(argv[1], "--help")) usage(stdout); usage(stderr); } edit_file(0); if (program == VIGR) { strncpy(orig_file, SGROUP_FILE, FILENAMELEN - 1); } else { strncpy(orig_file, SHADOW_FILE, FILENAMELEN - 1); } if (access(orig_file, F_OK) == 0) { char response[80]; printf((program == VIGR) ? _("You are using shadow groups on this system.\n") : _("You are using shadow passwords on this system.\n")); / TRANSLATORS: this program uses for y and n rpmatch(3), * which means they can be translated. */ printf(_("Would you like to edit %s now [y/n]? "), orig_file); if (fgets(response, sizeof(response), stdin)) { if (rpmatch(response) == RPMATCH_YES) edit_file(1); } } exit(EXIT_SUCCESS); }	./CrossVul/dataset_final_sorted/CWE-264/c/good_1661_6
crossvul-cpp_data_bad_2287_8	/* file-mmu.c: ramfs MMU-based file operations * * Resizable simple ram filesystem for Linux. * * Copyright (C) 2000 Linus Torvalds. * 2000 Transmeta Corp. * * Usage limits added by David Gibson, Linuxcare Australia. * This file is released under the GPL. / / * NOTE! This filesystem is probably most useful * not as a real filesystem, but as an example of * how virtual filesystems can be written. * * It doesn't get much simpler than this. Consider * that this file implements the full semantics of * a POSIX-compliant read-write filesystem. * * Note in particular how the filesystem does not * need to implement any data structures of its own * to keep track of the virtual data: using the VFS * caches is sufficient. */ #include <linux/fs.h> #include <linux/mm.h> #include <linux/ramfs.h> #include "internal.h" const struct file_operations ramfs_file_operations = { .read = new_sync_read, .read_iter = generic_file_read_iter, .write = new_sync_write, .write_iter = generic_file_write_iter, .mmap = generic_file_mmap, .fsync = noop_fsync, .splice_read = generic_file_splice_read, .splice_write = generic_file_splice_write, .llseek = generic_file_llseek, }; const struct inode_operations ramfs_file_inode_operations = { .setattr = simple_setattr, .getattr = simple_getattr, };	./CrossVul/dataset_final_sorted/CWE-264/c/bad_2287_8
crossvul-cpp_data_bad_2033_1	/* $Id: fpm_unix.c,v 1.25.2.1 2008/12/13 03:18:23 anight Exp $ / / (c) 2007,2008 Andrei Nigmatulin / #include "fpm_config.h" #include <string.h> #include <sys/time.h> #include <sys/resource.h> #include <stdlib.h> #include <unistd.h> #include <sys/types.h> #include <pwd.h> #include <grp.h> #ifdef HAVE_PRCTL #include <sys/prctl.h> #endif #include "fpm.h" #include "fpm_conf.h" #include "fpm_cleanup.h" #include "fpm_clock.h" #include "fpm_stdio.h" #include "fpm_unix.h" #include "fpm_signals.h" #include "zlog.h" size_t fpm_pagesize; int fpm_unix_resolve_socket_premissions(struct fpm_worker_pool_s wp) /* {{{ / { struct fpm_worker_pool_config_s c = wp->config; /* uninitialized / wp->socket_uid = -1; wp->socket_gid = -1; wp->socket_mode = 0666; if (!c) { return 0; } if (c->listen_owner && c->listen_owner) { struct passwd pwd; pwd = getpwnam(c->listen_owner); if (!pwd) { zlog(ZLOG_SYSERROR, "[pool %s] cannot get uid for user '%s'", wp->config->name, c->listen_owner); return -1; } wp->socket_uid = pwd->pw_uid; wp->socket_gid = pwd->pw_gid; } if (c->listen_group && c->listen_group) { struct group grp; grp = getgrnam(c->listen_group); if (!grp) { zlog(ZLOG_SYSERROR, "[pool %s] cannot get gid for group '%s'", wp->config->name, c->listen_group); return -1; } wp->socket_gid = grp->gr_gid; } if (c->listen_mode && c->listen_mode) { wp->socket_mode = strtoul(c->listen_mode, 0, 8); } return 0; } /* }}} / static int fpm_unix_conf_wp(struct fpm_worker_pool_s wp) /* {{{ / { struct passwd pwd; int is_root = !geteuid(); if (is_root) { if (wp->config->user && wp->config->user) { if (strlen(wp->config->user) == strspn(wp->config->user, "0123456789")) { wp->set_uid = strtoul(wp->config->user, 0, 10); } else { struct passwd pwd; pwd = getpwnam(wp->config->user); if (!pwd) { zlog(ZLOG_ERROR, "[pool %s] cannot get uid for user '%s'", wp->config->name, wp->config->user); return -1; } wp->set_uid = pwd->pw_uid; wp->set_gid = pwd->pw_gid; wp->user = strdup(pwd->pw_name); wp->home = strdup(pwd->pw_dir); } } if (wp->config->group && wp->config->group) { if (strlen(wp->config->group) == strspn(wp->config->group, "0123456789")) { wp->set_gid = strtoul(wp->config->group, 0, 10); } else { struct group grp; grp = getgrnam(wp->config->group); if (!grp) { zlog(ZLOG_ERROR, "[pool %s] cannot get gid for group '%s'", wp->config->name, wp->config->group); return -1; } wp->set_gid = grp->gr_gid; } } if (!fpm_globals.run_as_root) { if (wp->set_uid == 0 \|\| wp->set_gid == 0) { zlog(ZLOG_ERROR, "[pool %s] please specify user and group other than root", wp->config->name); return -1; } } } else { /* not root / if (wp->config->user && wp->config->user) { zlog(ZLOG_NOTICE, "[pool %s] 'user' directive is ignored when FPM is not running as root", wp->config->name); } if (wp->config->group && wp->config->group) { zlog(ZLOG_NOTICE, "[pool %s] 'group' directive is ignored when FPM is not running as root", wp->config->name); } if (wp->config->chroot && wp->config->chroot) { zlog(ZLOG_NOTICE, "[pool %s] 'chroot' directive is ignored when FPM is not running as root", wp->config->name); } if (wp->config->process_priority != 64) { zlog(ZLOG_NOTICE, "[pool %s] 'process.priority' directive is ignored when FPM is not running as root", wp->config->name); } /* set up HOME and USER anyway / pwd = getpwuid(getuid()); if (pwd) { wp->user = strdup(pwd->pw_name); wp->home = strdup(pwd->pw_dir); } } return 0; } / }}} / int fpm_unix_init_child(struct fpm_worker_pool_s wp) /* {{{ / { int is_root = !geteuid(); int made_chroot = 0; if (wp->config->rlimit_files) { struct rlimit r; r.rlim_max = r.rlim_cur = (rlim_t) wp->config->rlimit_files; if (0 > setrlimit(RLIMIT_NOFILE, &r)) { zlog(ZLOG_SYSERROR, "[pool %s] failed to set rlimit_files for this pool. Please check your system limits or decrease rlimit_files. setrlimit(RLIMIT_NOFILE, %d)", wp->config->name, wp->config->rlimit_files); } } if (wp->config->rlimit_core) { struct rlimit r; r.rlim_max = r.rlim_cur = wp->config->rlimit_core == -1 ? (rlim_t) RLIM_INFINITY : (rlim_t) wp->config->rlimit_core; if (0 > setrlimit(RLIMIT_CORE, &r)) { zlog(ZLOG_SYSERROR, "[pool %s] failed to set rlimit_core for this pool. Please check your system limits or decrease rlimit_core. setrlimit(RLIMIT_CORE, %d)", wp->config->name, wp->config->rlimit_core); } } if (is_root && wp->config->chroot && wp->config->chroot) { if (0 > chroot(wp->config->chroot)) { zlog(ZLOG_SYSERROR, "[pool %s] failed to chroot(%s)", wp->config->name, wp->config->chroot); return -1; } made_chroot = 1; } if (wp->config->chdir && wp->config->chdir) { if (0 > chdir(wp->config->chdir)) { zlog(ZLOG_SYSERROR, "[pool %s] failed to chdir(%s)", wp->config->name, wp->config->chdir); return -1; } } else if (made_chroot) { chdir("/"); } if (is_root) { if (wp->config->process_priority != 64) { if (setpriority(PRIO_PROCESS, 0, wp->config->process_priority) < 0) { zlog(ZLOG_SYSERROR, "[pool %s] Unable to set priority for this new process", wp->config->name); return -1; } } if (wp->set_gid) { if (0 > setgid(wp->set_gid)) { zlog(ZLOG_SYSERROR, "[pool %s] failed to setgid(%d)", wp->config->name, wp->set_gid); return -1; } } if (wp->set_uid) { if (0 > initgroups(wp->config->user, wp->set_gid)) { zlog(ZLOG_SYSERROR, "[pool %s] failed to initgroups(%s, %d)", wp->config->name, wp->config->user, wp->set_gid); return -1; } if (0 > setuid(wp->set_uid)) { zlog(ZLOG_SYSERROR, "[pool %s] failed to setuid(%d)", wp->config->name, wp->set_uid); return -1; } } } #ifdef HAVE_PRCTL if (0 > prctl(PR_SET_DUMPABLE, 1, 0, 0, 0)) { zlog(ZLOG_SYSERROR, "[pool %s] failed to prctl(PR_SET_DUMPABLE)", wp->config->name); } #endif if (0 > fpm_clock_init()) { return -1; } return 0; } / }}} / int fpm_unix_init_main() / {{{ / { struct fpm_worker_pool_s wp; int is_root = !geteuid(); if (fpm_global_config.rlimit_files) { struct rlimit r; r.rlim_max = r.rlim_cur = (rlim_t) fpm_global_config.rlimit_files; if (0 > setrlimit(RLIMIT_NOFILE, &r)) { zlog(ZLOG_SYSERROR, "failed to set rlimit_core for this pool. Please check your system limits or decrease rlimit_files. setrlimit(RLIMIT_NOFILE, %d)", fpm_global_config.rlimit_files); return -1; } } if (fpm_global_config.rlimit_core) { struct rlimit r; r.rlim_max = r.rlim_cur = fpm_global_config.rlimit_core == -1 ? (rlim_t) RLIM_INFINITY : (rlim_t) fpm_global_config.rlimit_core; if (0 > setrlimit(RLIMIT_CORE, &r)) { zlog(ZLOG_SYSERROR, "failed to set rlimit_core for this pool. Please check your system limits or decrease rlimit_core. setrlimit(RLIMIT_CORE, %d)", fpm_global_config.rlimit_core); return -1; } } fpm_pagesize = getpagesize(); if (fpm_global_config.daemonize) { /* * If daemonize, the calling process will die soon * and the master process continues to initialize itself. * * The parent process has then to wait for the master * process to initialize to return a consistent exit * value. For this pupose, the master process will * send \"1\" into the pipe if everything went well * and \"0\" otherwise. / struct timeval tv; fd_set rfds; int ret; if (pipe(fpm_globals.send_config_pipe) == -1) { zlog(ZLOG_SYSERROR, "failed to create pipe"); return -1; } / then fork / pid_t pid = fork(); switch (pid) { case -1 : / error / zlog(ZLOG_SYSERROR, "failed to daemonize"); return -1; case 0 : / children / close(fpm_globals.send_config_pipe[0]); / close the read side of the pipe / break; default : / parent / close(fpm_globals.send_config_pipe[1]); / close the write side of the pipe / / * wait for 10s before exiting with error * the child is supposed to send 1 or 0 into the pipe to tell the parent * how it goes for it / FD_ZERO(&rfds); FD_SET(fpm_globals.send_config_pipe[0], &rfds); tv.tv_sec = 10; tv.tv_usec = 0; zlog(ZLOG_DEBUG, "The calling process is waiting for the master process to ping via fd=%d", fpm_globals.send_config_pipe[0]); ret = select(fpm_globals.send_config_pipe[0] + 1, &rfds, NULL, NULL, &tv); if (ret == -1) { zlog(ZLOG_SYSERROR, "failed to select"); exit(FPM_EXIT_SOFTWARE); } if (ret) { / data available / int readval; ret = read(fpm_globals.send_config_pipe[0], &readval, sizeof(readval)); if (ret == -1) { zlog(ZLOG_SYSERROR, "failed to read from pipe"); exit(FPM_EXIT_SOFTWARE); } if (ret == 0) { zlog(ZLOG_ERROR, "no data have been read from pipe"); exit(FPM_EXIT_SOFTWARE); } else { if (readval == 1) { zlog(ZLOG_DEBUG, "I received a valid acknoledge from the master process, I can exit without error"); fpm_cleanups_run(FPM_CLEANUP_PARENT_EXIT); exit(FPM_EXIT_OK); } else { zlog(ZLOG_DEBUG, "The master process returned an error !"); exit(FPM_EXIT_SOFTWARE); } } } else { / no date sent ! / zlog(ZLOG_ERROR, "the master process didn't send back its status (via the pipe to the calling process)"); exit(FPM_EXIT_SOFTWARE); } exit(FPM_EXIT_SOFTWARE); } } / continue as a child / setsid(); if (0 > fpm_clock_init()) { return -1; } if (fpm_global_config.process_priority != 64) { if (is_root) { if (setpriority(PRIO_PROCESS, 0, fpm_global_config.process_priority) < 0) { zlog(ZLOG_SYSERROR, "Unable to set priority for the master process"); return -1; } } else { zlog(ZLOG_NOTICE, "'process.priority' directive is ignored when FPM is not running as root"); } } fpm_globals.parent_pid = getpid(); for (wp = fpm_worker_all_pools; wp; wp = wp->next) { if (0 > fpm_unix_conf_wp(wp)) { return -1; } } zlog_set_level(fpm_globals.log_level); return 0; } / }}} */	./CrossVul/dataset_final_sorted/CWE-264/c/bad_2033_1
crossvul-cpp_data_good_5739_0	/* scm.c - Socket level control messages processing. * * Author: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru> * Alignment and value checking mods by Craig Metz * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version. / #include <linux/module.h> #include <linux/signal.h> #include <linux/capability.h> #include <linux/errno.h> #include <linux/sched.h> #include <linux/mm.h> #include <linux/kernel.h> #include <linux/stat.h> #include <linux/socket.h> #include <linux/file.h> #include <linux/fcntl.h> #include <linux/net.h> #include <linux/interrupt.h> #include <linux/netdevice.h> #include <linux/security.h> #include <linux/pid_namespace.h> #include <linux/pid.h> #include <linux/nsproxy.h> #include <linux/slab.h> #include <asm/uaccess.h> #include <net/protocol.h> #include <linux/skbuff.h> #include <net/sock.h> #include <net/compat.h> #include <net/scm.h> #include <net/cls_cgroup.h> / * Only allow a user to send credentials, that they could set with * setu(g)id. / static __inline__ int scm_check_creds(struct ucred creds) { const struct cred cred = current_cred(); kuid_t uid = make_kuid(cred->user_ns, creds->uid); kgid_t gid = make_kgid(cred->user_ns, creds->gid); if (!uid_valid(uid) \|\| !gid_valid(gid)) return -EINVAL; if ((creds->pid == task_tgid_vnr(current) \|\| ns_capable(task_active_pid_ns(current)->user_ns, CAP_SYS_ADMIN)) && ((uid_eq(uid, cred->uid) \|\| uid_eq(uid, cred->euid) \|\| uid_eq(uid, cred->suid)) \|\| nsown_capable(CAP_SETUID)) && ((gid_eq(gid, cred->gid) \|\| gid_eq(gid, cred->egid) \|\| gid_eq(gid, cred->sgid)) \|\| nsown_capable(CAP_SETGID))) { return 0; } return -EPERM; } static int scm_fp_copy(struct cmsghdr cmsg, struct scm_fp_list *fplp) { int fdp = (int)CMSG_DATA(cmsg); struct scm_fp_list fpl = fplp; struct file fpp; int i, num; num = (cmsg->cmsg_len - CMSG_ALIGN(sizeof(struct cmsghdr)))/sizeof(int); if (num <= 0) return 0; if (num > SCM_MAX_FD) return -EINVAL; if (!fpl) { fpl = kmalloc(sizeof(struct scm_fp_list), GFP_KERNEL); if (!fpl) return -ENOMEM; fplp = fpl; fpl->count = 0; fpl->max = SCM_MAX_FD; } fpp = &fpl->fp[fpl->count]; if (fpl->count + num > fpl->max) return -EINVAL; /* * Verify the descriptors and increment the usage count. / for (i=0; i< num; i++) { int fd = fdp[i]; struct file file; if (fd < 0 \|\| !(file = fget_raw(fd))) return -EBADF; fpp++ = file; fpl->count++; } return num; } void __scm_destroy(struct scm_cookie scm) { struct scm_fp_list fpl = scm->fp; int i; if (fpl) { scm->fp = NULL; for (i=fpl->count-1; i>=0; i--) fput(fpl->fp[i]); kfree(fpl); } } EXPORT_SYMBOL(__scm_destroy); int __scm_send(struct socket sock, struct msghdr msg, struct scm_cookie p) { struct cmsghdr cmsg; int err; for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) { err = -EINVAL; / Verify that cmsg_len is at least sizeof(struct cmsghdr) / / The first check was omitted in <= 2.2.5. The reasoning was that parser checks cmsg_len in any case, so that additional check would be work duplication. But if cmsg_level is not SOL_SOCKET, we do not check for too short ancillary data object at all! Oops. OK, let's add it... / if (!CMSG_OK(msg, cmsg)) goto error; if (cmsg->cmsg_level != SOL_SOCKET) continue; switch (cmsg->cmsg_type) { case SCM_RIGHTS: if (!sock->ops \|\| sock->ops->family != PF_UNIX) goto error; err=scm_fp_copy(cmsg, &p->fp); if (err<0) goto error; break; case SCM_CREDENTIALS: { struct ucred creds; kuid_t uid; kgid_t gid; if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct ucred))) goto error; memcpy(&creds, CMSG_DATA(cmsg), sizeof(struct ucred)); err = scm_check_creds(&creds); if (err) goto error; p->creds.pid = creds.pid; if (!p->pid \|\| pid_vnr(p->pid) != creds.pid) { struct pid pid; err = -ESRCH; pid = find_get_pid(creds.pid); if (!pid) goto error; put_pid(p->pid); p->pid = pid; } err = -EINVAL; uid = make_kuid(current_user_ns(), creds.uid); gid = make_kgid(current_user_ns(), creds.gid); if (!uid_valid(uid) \|\| !gid_valid(gid)) goto error; p->creds.uid = uid; p->creds.gid = gid; break; } default: goto error; } } if (p->fp && !p->fp->count) { kfree(p->fp); p->fp = NULL; } return 0; error: scm_destroy(p); return err; } EXPORT_SYMBOL(__scm_send); int put_cmsg(struct msghdr * msg, int level, int type, int len, void data) { struct cmsghdr __user cm = (__force struct cmsghdr __user )msg->msg_control; struct cmsghdr cmhdr; int cmlen = CMSG_LEN(len); int err; if (MSG_CMSG_COMPAT & msg->msg_flags) return put_cmsg_compat(msg, level, type, len, data); if (cm==NULL \|\| msg->msg_controllen < sizeof(cm)) { msg->msg_flags \|= MSG_CTRUNC; return 0; /* XXX: return error? check spec. / } if (msg->msg_controllen < cmlen) { msg->msg_flags \|= MSG_CTRUNC; cmlen = msg->msg_controllen; } cmhdr.cmsg_level = level; cmhdr.cmsg_type = type; cmhdr.cmsg_len = cmlen; err = -EFAULT; if (copy_to_user(cm, &cmhdr, sizeof cmhdr)) goto out; if (copy_to_user(CMSG_DATA(cm), data, cmlen - sizeof(struct cmsghdr))) goto out; cmlen = CMSG_SPACE(len); if (msg->msg_controllen < cmlen) cmlen = msg->msg_controllen; msg->msg_control += cmlen; msg->msg_controllen -= cmlen; err = 0; out: return err; } EXPORT_SYMBOL(put_cmsg); void scm_detach_fds(struct msghdr msg, struct scm_cookie scm) { struct cmsghdr __user cm = (__force struct cmsghdr __user)msg->msg_control; int fdmax = 0; int fdnum = scm->fp->count; struct file fp = scm->fp->fp; int __user cmfptr; int err = 0, i; if (MSG_CMSG_COMPAT & msg->msg_flags) { scm_detach_fds_compat(msg, scm); return; } if (msg->msg_controllen > sizeof(struct cmsghdr)) fdmax = ((msg->msg_controllen - sizeof(struct cmsghdr)) / sizeof(int)); if (fdnum < fdmax) fdmax = fdnum; for (i=0, cmfptr=(__force int __user )CMSG_DATA(cm); i<fdmax; i++, cmfptr++) { struct socket sock; int new_fd; err = security_file_receive(fp[i]); if (err) break; err = get_unused_fd_flags(MSG_CMSG_CLOEXEC & msg->msg_flags ? O_CLOEXEC : 0); if (err < 0) break; new_fd = err; err = put_user(new_fd, cmfptr); if (err) { put_unused_fd(new_fd); break; } /* Bump the usage count and install the file. / sock = sock_from_file(fp[i], &err); if (sock) { sock_update_netprioidx(sock->sk); sock_update_classid(sock->sk); } fd_install(new_fd, get_file(fp[i])); } if (i > 0) { int cmlen = CMSG_LEN(isizeof(int)); err = put_user(SOL_SOCKET, &cm->cmsg_level); if (!err) err = put_user(SCM_RIGHTS, &cm->cmsg_type); if (!err) err = put_user(cmlen, &cm->cmsg_len); if (!err) { cmlen = CMSG_SPACE(isizeof(int)); msg->msg_control += cmlen; msg->msg_controllen -= cmlen; } } if (i < fdnum \|\| (fdnum && fdmax <= 0)) msg->msg_flags \|= MSG_CTRUNC; / * All of the files that fit in the message have had their * usage counts incremented, so we just free the list. / __scm_destroy(scm); } EXPORT_SYMBOL(scm_detach_fds); struct scm_fp_list scm_fp_dup(struct scm_fp_list fpl) { struct scm_fp_list new_fpl; int i; if (!fpl) return NULL; new_fpl = kmemdup(fpl, offsetof(struct scm_fp_list, fp[fpl->count]), GFP_KERNEL); if (new_fpl) { for (i = 0; i < fpl->count; i++) get_file(fpl->fp[i]); new_fpl->max = new_fpl->count; } return new_fpl; } EXPORT_SYMBOL(scm_fp_dup);	./CrossVul/dataset_final_sorted/CWE-264/c/good_5739_0
crossvul-cpp_data_good_5806_0	/* * Linux INET6 implementation * Forwarding Information Database * * Authors: * Pedro Roque <roque@di.fc.ul.pt> * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version. / / * Changes: * Yuji SEKIYA @USAGI: Support default route on router node; * remove ip6_null_entry from the top of * routing table. * Ville Nuorvala: Fixed routing subtrees. / #define pr_fmt(fmt) "IPv6: " fmt #include <linux/errno.h> #include <linux/types.h> #include <linux/net.h> #include <linux/route.h> #include <linux/netdevice.h> #include <linux/in6.h> #include <linux/init.h> #include <linux/list.h> #include <linux/slab.h> #include <net/ipv6.h> #include <net/ndisc.h> #include <net/addrconf.h> #include <net/ip6_fib.h> #include <net/ip6_route.h> #define RT6_DEBUG 2 #if RT6_DEBUG >= 3 #define RT6_TRACE(x...) pr_debug(x) #else #define RT6_TRACE(x...) do { ; } while (0) #endif static struct kmem_cache fib6_node_kmem __read_mostly; enum fib_walk_state_t { #ifdef CONFIG_IPV6_SUBTREES FWS_S, #endif FWS_L, FWS_R, FWS_C, FWS_U }; struct fib6_cleaner_t { struct fib6_walker_t w; struct net net; int (func)(struct rt6_info , void arg); void arg; }; static DEFINE_RWLOCK(fib6_walker_lock); #ifdef CONFIG_IPV6_SUBTREES #define FWS_INIT FWS_S #else #define FWS_INIT FWS_L #endif static void fib6_prune_clones(struct net net, struct fib6_node fn, struct rt6_info rt); static struct rt6_info fib6_find_prefix(struct net net, struct fib6_node fn); static struct fib6_node fib6_repair_tree(struct net net, struct fib6_node fn); static int fib6_walk(struct fib6_walker_t w); static int fib6_walk_continue(struct fib6_walker_t w); /* * A routing update causes an increase of the serial number on the * affected subtree. This allows for cached routes to be asynchronously * tested when modifications are made to the destination cache as a * result of redirects, path MTU changes, etc. / static __u32 rt_sernum; static void fib6_gc_timer_cb(unsigned long arg); static LIST_HEAD(fib6_walkers); #define FOR_WALKERS(w) list_for_each_entry(w, &fib6_walkers, lh) static inline void fib6_walker_link(struct fib6_walker_t w) { write_lock_bh(&fib6_walker_lock); list_add(&w->lh, &fib6_walkers); write_unlock_bh(&fib6_walker_lock); } static inline void fib6_walker_unlink(struct fib6_walker_t w) { write_lock_bh(&fib6_walker_lock); list_del(&w->lh); write_unlock_bh(&fib6_walker_lock); } static __inline__ u32 fib6_new_sernum(void) { u32 n = ++rt_sernum; if ((__s32)n <= 0) rt_sernum = n = 1; return n; } / * Auxiliary address test functions for the radix tree. * * These assume a 32bit processor (although it will work on * 64bit processors) / / * test bit / #if defined(__LITTLE_ENDIAN) # define BITOP_BE32_SWIZZLE (0x1F & ~7) #else # define BITOP_BE32_SWIZZLE 0 #endif static __inline__ __be32 addr_bit_set(const void token, int fn_bit) { const __be32 addr = token; / * Here, * 1 << ((~fn_bit ^ BITOP_BE32_SWIZZLE) & 0x1f) * is optimized version of * htonl(1 << ((~fn_bit)&0x1F)) * See include/asm-generic/bitops/le.h. / return (__force __be32)(1 << ((~fn_bit ^ BITOP_BE32_SWIZZLE) & 0x1f)) & addr[fn_bit >> 5]; } static __inline__ struct fib6_node node_alloc(void) { struct fib6_node fn; fn = kmem_cache_zalloc(fib6_node_kmem, GFP_ATOMIC); return fn; } static __inline__ void node_free(struct fib6_node fn) { kmem_cache_free(fib6_node_kmem, fn); } static __inline__ void rt6_release(struct rt6_info rt) { if (atomic_dec_and_test(&rt->rt6i_ref)) dst_free(&rt->dst); } static void fib6_link_table(struct net net, struct fib6_table tb) { unsigned int h; / * Initialize table lock at a single place to give lockdep a key, * tables aren't visible prior to being linked to the list. / rwlock_init(&tb->tb6_lock); h = tb->tb6_id & (FIB6_TABLE_HASHSZ - 1); / * No protection necessary, this is the only list mutatation * operation, tables never disappear once they exist. / hlist_add_head_rcu(&tb->tb6_hlist, &net->ipv6.fib_table_hash[h]); } #ifdef CONFIG_IPV6_MULTIPLE_TABLES static struct fib6_table fib6_alloc_table(struct net net, u32 id) { struct fib6_table table; table = kzalloc(sizeof(table), GFP_ATOMIC); if (table) { table->tb6_id = id; table->tb6_root.leaf = net->ipv6.ip6_null_entry; table->tb6_root.fn_flags = RTN_ROOT \| RTN_TL_ROOT \| RTN_RTINFO; inet_peer_base_init(&table->tb6_peers); } return table; } struct fib6_table fib6_new_table(struct net net, u32 id) { struct fib6_table tb; if (id == 0) id = RT6_TABLE_MAIN; tb = fib6_get_table(net, id); if (tb) return tb; tb = fib6_alloc_table(net, id); if (tb) fib6_link_table(net, tb); return tb; } struct fib6_table fib6_get_table(struct net net, u32 id) { struct fib6_table tb; struct hlist_head head; unsigned int h; if (id == 0) id = RT6_TABLE_MAIN; h = id & (FIB6_TABLE_HASHSZ - 1); rcu_read_lock(); head = &net->ipv6.fib_table_hash[h]; hlist_for_each_entry_rcu(tb, head, tb6_hlist) { if (tb->tb6_id == id) { rcu_read_unlock(); return tb; } } rcu_read_unlock(); return NULL; } static void __net_init fib6_tables_init(struct net net) { fib6_link_table(net, net->ipv6.fib6_main_tbl); fib6_link_table(net, net->ipv6.fib6_local_tbl); } #else struct fib6_table fib6_new_table(struct net net, u32 id) { return fib6_get_table(net, id); } struct fib6_table fib6_get_table(struct net net, u32 id) { return net->ipv6.fib6_main_tbl; } struct dst_entry fib6_rule_lookup(struct net net, struct flowi6 fl6, int flags, pol_lookup_t lookup) { return (struct dst_entry ) lookup(net, net->ipv6.fib6_main_tbl, fl6, flags); } static void __net_init fib6_tables_init(struct net net) { fib6_link_table(net, net->ipv6.fib6_main_tbl); } #endif static int fib6_dump_node(struct fib6_walker_t w) { int res; struct rt6_info rt; for (rt = w->leaf; rt; rt = rt->dst.rt6_next) { res = rt6_dump_route(rt, w->args); if (res < 0) { /* Frame is full, suspend walking / w->leaf = rt; return 1; } WARN_ON(res == 0); } w->leaf = NULL; return 0; } static void fib6_dump_end(struct netlink_callback cb) { struct fib6_walker_t w = (void)cb->args[2]; if (w) { if (cb->args[4]) { cb->args[4] = 0; fib6_walker_unlink(w); } cb->args[2] = 0; kfree(w); } cb->done = (void)cb->args[3]; cb->args[1] = 3; } static int fib6_dump_done(struct netlink_callback cb) { fib6_dump_end(cb); return cb->done ? cb->done(cb) : 0; } static int fib6_dump_table(struct fib6_table table, struct sk_buff skb, struct netlink_callback cb) { struct fib6_walker_t w; int res; w = (void )cb->args[2]; w->root = &table->tb6_root; if (cb->args[4] == 0) { w->count = 0; w->skip = 0; read_lock_bh(&table->tb6_lock); res = fib6_walk(w); read_unlock_bh(&table->tb6_lock); if (res > 0) { cb->args[4] = 1; cb->args[5] = w->root->fn_sernum; } } else { if (cb->args[5] != w->root->fn_sernum) { / Begin at the root if the tree changed / cb->args[5] = w->root->fn_sernum; w->state = FWS_INIT; w->node = w->root; w->skip = w->count; } else w->skip = 0; read_lock_bh(&table->tb6_lock); res = fib6_walk_continue(w); read_unlock_bh(&table->tb6_lock); if (res <= 0) { fib6_walker_unlink(w); cb->args[4] = 0; } } return res; } static int inet6_dump_fib(struct sk_buff skb, struct netlink_callback cb) { struct net net = sock_net(skb->sk); unsigned int h, s_h; unsigned int e = 0, s_e; struct rt6_rtnl_dump_arg arg; struct fib6_walker_t w; struct fib6_table tb; struct hlist_head head; int res = 0; s_h = cb->args[0]; s_e = cb->args[1]; w = (void )cb->args[2]; if (!w) { /* New dump: * * 1. hook callback destructor. / cb->args[3] = (long)cb->done; cb->done = fib6_dump_done; / * 2. allocate and initialize walker. / w = kzalloc(sizeof(w), GFP_ATOMIC); if (!w) return -ENOMEM; w->func = fib6_dump_node; cb->args[2] = (long)w; } arg.skb = skb; arg.cb = cb; arg.net = net; w->args = &arg; rcu_read_lock(); for (h = s_h; h < FIB6_TABLE_HASHSZ; h++, s_e = 0) { e = 0; head = &net->ipv6.fib_table_hash[h]; hlist_for_each_entry_rcu(tb, head, tb6_hlist) { if (e < s_e) goto next; res = fib6_dump_table(tb, skb, cb); if (res != 0) goto out; next: e++; } } out: rcu_read_unlock(); cb->args[1] = e; cb->args[0] = h; res = res < 0 ? res : skb->len; if (res <= 0) fib6_dump_end(cb); return res; } /* * Routing Table * * return the appropriate node for a routing tree "add" operation * by either creating and inserting or by returning an existing * node. / static struct fib6_node fib6_add_1(struct fib6_node root, struct in6_addr addr, int plen, int offset, int allow_create, int replace_required) { struct fib6_node fn, in, ln; struct fib6_node pn = NULL; struct rt6key key; int bit; __be32 dir = 0; __u32 sernum = fib6_new_sernum(); RT6_TRACE("fib6_add_1\n"); / insert node in tree / fn = root; do { key = (struct rt6key )((u8 )fn->leaf + offset); / * Prefix match / if (plen < fn->fn_bit \|\| !ipv6_prefix_equal(&key->addr, addr, fn->fn_bit)) { if (!allow_create) { if (replace_required) { pr_warn("Can't replace route, no match found\n"); return ERR_PTR(-ENOENT); } pr_warn("NLM_F_CREATE should be set when creating new route\n"); } goto insert_above; } / * Exact match ? / if (plen == fn->fn_bit) { / clean up an intermediate node / if (!(fn->fn_flags & RTN_RTINFO)) { rt6_release(fn->leaf); fn->leaf = NULL; } fn->fn_sernum = sernum; return fn; } / * We have more bits to go / / Try to walk down on tree. / fn->fn_sernum = sernum; dir = addr_bit_set(addr, fn->fn_bit); pn = fn; fn = dir ? fn->right: fn->left; } while (fn); if (!allow_create) { / We should not create new node because * NLM_F_REPLACE was specified without NLM_F_CREATE * I assume it is safe to require NLM_F_CREATE when * REPLACE flag is used! Later we may want to remove the * check for replace_required, because according * to netlink specification, NLM_F_CREATE * MUST be specified if new route is created. * That would keep IPv6 consistent with IPv4 / if (replace_required) { pr_warn("Can't replace route, no match found\n"); return ERR_PTR(-ENOENT); } pr_warn("NLM_F_CREATE should be set when creating new route\n"); } / * We walked to the bottom of tree. * Create new leaf node without children. / ln = node_alloc(); if (!ln) return ERR_PTR(-ENOMEM); ln->fn_bit = plen; ln->parent = pn; ln->fn_sernum = sernum; if (dir) pn->right = ln; else pn->left = ln; return ln; insert_above: / * split since we don't have a common prefix anymore or * we have a less significant route. * we've to insert an intermediate node on the list * this new node will point to the one we need to create * and the current / pn = fn->parent; / find 1st bit in difference between the 2 addrs. See comment in __ipv6_addr_diff: bit may be an invalid value, but if it is >= plen, the value is ignored in any case. / bit = __ipv6_addr_diff(addr, &key->addr, sizeof(addr)); /* * (intermediate)[in] * / \ * (new leaf node)[ln] (old node)[fn] / if (plen > bit) { in = node_alloc(); ln = node_alloc(); if (!in \|\| !ln) { if (in) node_free(in); if (ln) node_free(ln); return ERR_PTR(-ENOMEM); } / * new intermediate node. * RTN_RTINFO will * be off since that an address that chooses one of * the branches would not match less specific routes * in the other branch / in->fn_bit = bit; in->parent = pn; in->leaf = fn->leaf; atomic_inc(&in->leaf->rt6i_ref); in->fn_sernum = sernum; / update parent pointer / if (dir) pn->right = in; else pn->left = in; ln->fn_bit = plen; ln->parent = in; fn->parent = in; ln->fn_sernum = sernum; if (addr_bit_set(addr, bit)) { in->right = ln; in->left = fn; } else { in->left = ln; in->right = fn; } } else { / plen <= bit / / * (new leaf node)[ln] * / \ * (old node)[fn] NULL / ln = node_alloc(); if (!ln) return ERR_PTR(-ENOMEM); ln->fn_bit = plen; ln->parent = pn; ln->fn_sernum = sernum; if (dir) pn->right = ln; else pn->left = ln; if (addr_bit_set(&key->addr, plen)) ln->right = fn; else ln->left = fn; fn->parent = ln; } return ln; } static inline bool rt6_qualify_for_ecmp(struct rt6_info rt) { return (rt->rt6i_flags & (RTF_GATEWAY\|RTF_ADDRCONF\|RTF_DYNAMIC)) == RTF_GATEWAY; } /* * Insert routing information in a node. / static int fib6_add_rt2node(struct fib6_node fn, struct rt6_info rt, struct nl_info info) { struct rt6_info iter = NULL; struct rt6_info ins; int replace = (info->nlh && (info->nlh->nlmsg_flags & NLM_F_REPLACE)); int add = (!info->nlh \|\| (info->nlh->nlmsg_flags & NLM_F_CREATE)); int found = 0; bool rt_can_ecmp = rt6_qualify_for_ecmp(rt); ins = &fn->leaf; for (iter = fn->leaf; iter; iter = iter->dst.rt6_next) { / * Search for duplicates / if (iter->rt6i_metric == rt->rt6i_metric) { / * Same priority level / if (info->nlh && (info->nlh->nlmsg_flags & NLM_F_EXCL)) return -EEXIST; if (replace) { found++; break; } if (iter->dst.dev == rt->dst.dev && iter->rt6i_idev == rt->rt6i_idev && ipv6_addr_equal(&iter->rt6i_gateway, &rt->rt6i_gateway)) { if (rt->rt6i_nsiblings) rt->rt6i_nsiblings = 0; if (!(iter->rt6i_flags & RTF_EXPIRES)) return -EEXIST; if (!(rt->rt6i_flags & RTF_EXPIRES)) rt6_clean_expires(iter); else rt6_set_expires(iter, rt->dst.expires); return -EEXIST; } / If we have the same destination and the same metric, * but not the same gateway, then the route we try to * add is sibling to this route, increment our counter * of siblings, and later we will add our route to the * list. * Only static routes (which don't have flag * RTF_EXPIRES) are used for ECMPv6. * * To avoid long list, we only had siblings if the * route have a gateway. / if (rt_can_ecmp && rt6_qualify_for_ecmp(iter)) rt->rt6i_nsiblings++; } if (iter->rt6i_metric > rt->rt6i_metric) break; ins = &iter->dst.rt6_next; } / Reset round-robin state, if necessary / if (ins == &fn->leaf) fn->rr_ptr = NULL; / Link this route to others same route. / if (rt->rt6i_nsiblings) { unsigned int rt6i_nsiblings; struct rt6_info sibling, temp_sibling; / Find the first route that have the same metric / sibling = fn->leaf; while (sibling) { if (sibling->rt6i_metric == rt->rt6i_metric && rt6_qualify_for_ecmp(sibling)) { list_add_tail(&rt->rt6i_siblings, &sibling->rt6i_siblings); break; } sibling = sibling->dst.rt6_next; } / For each sibling in the list, increment the counter of * siblings. BUG() if counters does not match, list of siblings * is broken! / rt6i_nsiblings = 0; list_for_each_entry_safe(sibling, temp_sibling, &rt->rt6i_siblings, rt6i_siblings) { sibling->rt6i_nsiblings++; BUG_ON(sibling->rt6i_nsiblings != rt->rt6i_nsiblings); rt6i_nsiblings++; } BUG_ON(rt6i_nsiblings != rt->rt6i_nsiblings); } / * insert node / if (!replace) { if (!add) pr_warn("NLM_F_CREATE should be set when creating new route\n"); add: rt->dst.rt6_next = iter; ins = rt; rt->rt6i_node = fn; atomic_inc(&rt->rt6i_ref); inet6_rt_notify(RTM_NEWROUTE, rt, info); info->nl_net->ipv6.rt6_stats->fib_rt_entries++; if (!(fn->fn_flags & RTN_RTINFO)) { info->nl_net->ipv6.rt6_stats->fib_route_nodes++; fn->fn_flags \|= RTN_RTINFO; } } else { if (!found) { if (add) goto add; pr_warn("NLM_F_REPLACE set, but no existing node found!\n"); return -ENOENT; } ins = rt; rt->rt6i_node = fn; rt->dst.rt6_next = iter->dst.rt6_next; atomic_inc(&rt->rt6i_ref); inet6_rt_notify(RTM_NEWROUTE, rt, info); rt6_release(iter); if (!(fn->fn_flags & RTN_RTINFO)) { info->nl_net->ipv6.rt6_stats->fib_route_nodes++; fn->fn_flags \|= RTN_RTINFO; } } return 0; } static __inline__ void fib6_start_gc(struct net net, struct rt6_info rt) { if (!timer_pending(&net->ipv6.ip6_fib_timer) && (rt->rt6i_flags & (RTF_EXPIRES \| RTF_CACHE))) mod_timer(&net->ipv6.ip6_fib_timer, jiffies + net->ipv6.sysctl.ip6_rt_gc_interval); } void fib6_force_start_gc(struct net net) { if (!timer_pending(&net->ipv6.ip6_fib_timer)) mod_timer(&net->ipv6.ip6_fib_timer, jiffies + net->ipv6.sysctl.ip6_rt_gc_interval); } /* * Add routing information to the routing tree. * <destination addr>/<source addr> * with source addr info in sub-trees / int fib6_add(struct fib6_node root, struct rt6_info rt, struct nl_info info) { struct fib6_node fn, pn = NULL; int err = -ENOMEM; int allow_create = 1; int replace_required = 0; if (info->nlh) { if (!(info->nlh->nlmsg_flags & NLM_F_CREATE)) allow_create = 0; if (info->nlh->nlmsg_flags & NLM_F_REPLACE) replace_required = 1; } if (!allow_create && !replace_required) pr_warn("RTM_NEWROUTE with no NLM_F_CREATE or NLM_F_REPLACE\n"); fn = fib6_add_1(root, &rt->rt6i_dst.addr, rt->rt6i_dst.plen, offsetof(struct rt6_info, rt6i_dst), allow_create, replace_required); if (IS_ERR(fn)) { err = PTR_ERR(fn); fn = NULL; goto out; } pn = fn; #ifdef CONFIG_IPV6_SUBTREES if (rt->rt6i_src.plen) { struct fib6_node sn; if (!fn->subtree) { struct fib6_node sfn; /* * Create subtree. * * fn[main tree] * \| * sfn[subtree root] * \ * sn[new leaf node] / / Create subtree root node / sfn = node_alloc(); if (!sfn) goto st_failure; sfn->leaf = info->nl_net->ipv6.ip6_null_entry; atomic_inc(&info->nl_net->ipv6.ip6_null_entry->rt6i_ref); sfn->fn_flags = RTN_ROOT; sfn->fn_sernum = fib6_new_sernum(); / Now add the first leaf node to new subtree / sn = fib6_add_1(sfn, &rt->rt6i_src.addr, rt->rt6i_src.plen, offsetof(struct rt6_info, rt6i_src), allow_create, replace_required); if (IS_ERR(sn)) { / If it is failed, discard just allocated root, and then (in st_failure) stale node in main tree. / node_free(sfn); err = PTR_ERR(sn); goto st_failure; } / Now link new subtree to main tree / sfn->parent = fn; fn->subtree = sfn; } else { sn = fib6_add_1(fn->subtree, &rt->rt6i_src.addr, rt->rt6i_src.plen, offsetof(struct rt6_info, rt6i_src), allow_create, replace_required); if (IS_ERR(sn)) { err = PTR_ERR(sn); goto st_failure; } } if (!fn->leaf) { fn->leaf = rt; atomic_inc(&rt->rt6i_ref); } fn = sn; } #endif err = fib6_add_rt2node(fn, rt, info); if (!err) { fib6_start_gc(info->nl_net, rt); if (!(rt->rt6i_flags & RTF_CACHE)) fib6_prune_clones(info->nl_net, pn, rt); } out: if (err) { #ifdef CONFIG_IPV6_SUBTREES / * If fib6_add_1 has cleared the old leaf pointer in the * super-tree leaf node we have to find a new one for it. / if (pn != fn && pn->leaf == rt) { pn->leaf = NULL; atomic_dec(&rt->rt6i_ref); } if (pn != fn && !pn->leaf && !(pn->fn_flags & RTN_RTINFO)) { pn->leaf = fib6_find_prefix(info->nl_net, pn); #if RT6_DEBUG >= 2 if (!pn->leaf) { WARN_ON(pn->leaf == NULL); pn->leaf = info->nl_net->ipv6.ip6_null_entry; } #endif atomic_inc(&pn->leaf->rt6i_ref); } #endif dst_free(&rt->dst); } return err; #ifdef CONFIG_IPV6_SUBTREES / Subtree creation failed, probably main tree node is orphan. If it is, shoot it. / st_failure: if (fn && !(fn->fn_flags & (RTN_RTINFO\|RTN_ROOT))) fib6_repair_tree(info->nl_net, fn); dst_free(&rt->dst); return err; #endif } / * Routing tree lookup * / struct lookup_args { int offset; / key offset on rt6_info / const struct in6_addr addr; /* search key / }; static struct fib6_node fib6_lookup_1(struct fib6_node root, struct lookup_args args) { struct fib6_node fn; __be32 dir; if (unlikely(args->offset == 0)) return NULL; / * Descend on a tree / fn = root; for (;;) { struct fib6_node next; dir = addr_bit_set(args->addr, fn->fn_bit); next = dir ? fn->right : fn->left; if (next) { fn = next; continue; } break; } while (fn) { if (FIB6_SUBTREE(fn) \|\| fn->fn_flags & RTN_RTINFO) { struct rt6key key; key = (struct rt6key ) ((u8 ) fn->leaf + args->offset); if (ipv6_prefix_equal(&key->addr, args->addr, key->plen)) { #ifdef CONFIG_IPV6_SUBTREES if (fn->subtree) { struct fib6_node sfn; sfn = fib6_lookup_1(fn->subtree, args + 1); if (!sfn) goto backtrack; fn = sfn; } #endif if (fn->fn_flags & RTN_RTINFO) return fn; } } #ifdef CONFIG_IPV6_SUBTREES backtrack: #endif if (fn->fn_flags & RTN_ROOT) break; fn = fn->parent; } return NULL; } struct fib6_node * fib6_lookup(struct fib6_node root, const struct in6_addr daddr, const struct in6_addr saddr) { struct fib6_node fn; struct lookup_args args[] = { { .offset = offsetof(struct rt6_info, rt6i_dst), .addr = daddr, }, #ifdef CONFIG_IPV6_SUBTREES { .offset = offsetof(struct rt6_info, rt6i_src), .addr = saddr, }, #endif { .offset = 0, /* sentinel / } }; fn = fib6_lookup_1(root, daddr ? args : args + 1); if (!fn \|\| fn->fn_flags & RTN_TL_ROOT) fn = root; return fn; } / * Get node with specified destination prefix (and source prefix, * if subtrees are used) / static struct fib6_node fib6_locate_1(struct fib6_node root, const struct in6_addr addr, int plen, int offset) { struct fib6_node fn; for (fn = root; fn ; ) { struct rt6key key = (struct rt6key )((u8 )fn->leaf + offset); /* * Prefix match / if (plen < fn->fn_bit \|\| !ipv6_prefix_equal(&key->addr, addr, fn->fn_bit)) return NULL; if (plen == fn->fn_bit) return fn; / * We have more bits to go / if (addr_bit_set(addr, fn->fn_bit)) fn = fn->right; else fn = fn->left; } return NULL; } struct fib6_node fib6_locate(struct fib6_node root, const struct in6_addr daddr, int dst_len, const struct in6_addr saddr, int src_len) { struct fib6_node fn; fn = fib6_locate_1(root, daddr, dst_len, offsetof(struct rt6_info, rt6i_dst)); #ifdef CONFIG_IPV6_SUBTREES if (src_len) { WARN_ON(saddr == NULL); if (fn && fn->subtree) fn = fib6_locate_1(fn->subtree, saddr, src_len, offsetof(struct rt6_info, rt6i_src)); } #endif if (fn && fn->fn_flags & RTN_RTINFO) return fn; return NULL; } /* * Deletion * / static struct rt6_info fib6_find_prefix(struct net net, struct fib6_node fn) { if (fn->fn_flags & RTN_ROOT) return net->ipv6.ip6_null_entry; while (fn) { if (fn->left) return fn->left->leaf; if (fn->right) return fn->right->leaf; fn = FIB6_SUBTREE(fn); } return NULL; } /* * Called to trim the tree of intermediate nodes when possible. "fn" * is the node we want to try and remove. / static struct fib6_node fib6_repair_tree(struct net net, struct fib6_node fn) { int children; int nstate; struct fib6_node child, pn; struct fib6_walker_t w; int iter = 0; for (;;) { RT6_TRACE("fixing tree: plen=%d iter=%d\n", fn->fn_bit, iter); iter++; WARN_ON(fn->fn_flags & RTN_RTINFO); WARN_ON(fn->fn_flags & RTN_TL_ROOT); WARN_ON(fn->leaf != NULL); children = 0; child = NULL; if (fn->right) child = fn->right, children \|= 1; if (fn->left) child = fn->left, children \|= 2; if (children == 3 \|\| FIB6_SUBTREE(fn) #ifdef CONFIG_IPV6_SUBTREES / Subtree root (i.e. fn) may have one child / \|\| (children && fn->fn_flags & RTN_ROOT) #endif ) { fn->leaf = fib6_find_prefix(net, fn); #if RT6_DEBUG >= 2 if (!fn->leaf) { WARN_ON(!fn->leaf); fn->leaf = net->ipv6.ip6_null_entry; } #endif atomic_inc(&fn->leaf->rt6i_ref); return fn->parent; } pn = fn->parent; #ifdef CONFIG_IPV6_SUBTREES if (FIB6_SUBTREE(pn) == fn) { WARN_ON(!(fn->fn_flags & RTN_ROOT)); FIB6_SUBTREE(pn) = NULL; nstate = FWS_L; } else { WARN_ON(fn->fn_flags & RTN_ROOT); #endif if (pn->right == fn) pn->right = child; else if (pn->left == fn) pn->left = child; #if RT6_DEBUG >= 2 else WARN_ON(1); #endif if (child) child->parent = pn; nstate = FWS_R; #ifdef CONFIG_IPV6_SUBTREES } #endif read_lock(&fib6_walker_lock); FOR_WALKERS(w) { if (!child) { if (w->root == fn) { w->root = w->node = NULL; RT6_TRACE("W %p adjusted by delroot 1\n", w); } else if (w->node == fn) { RT6_TRACE("W %p adjusted by delnode 1, s=%d/%d\n", w, w->state, nstate); w->node = pn; w->state = nstate; } } else { if (w->root == fn) { w->root = child; RT6_TRACE("W %p adjusted by delroot 2\n", w); } if (w->node == fn) { w->node = child; if (children&2) { RT6_TRACE("W %p adjusted by delnode 2, s=%d\n", w, w->state); w->state = w->state>=FWS_R ? FWS_U : FWS_INIT; } else { RT6_TRACE("W %p adjusted by delnode 2, s=%d\n", w, w->state); w->state = w->state>=FWS_C ? FWS_U : FWS_INIT; } } } } read_unlock(&fib6_walker_lock); node_free(fn); if (pn->fn_flags & RTN_RTINFO \|\| FIB6_SUBTREE(pn)) return pn; rt6_release(pn->leaf); pn->leaf = NULL; fn = pn; } } static void fib6_del_route(struct fib6_node fn, struct rt6_info *rtp, struct nl_info info) { struct fib6_walker_t w; struct rt6_info rt = rtp; struct net net = info->nl_net; RT6_TRACE("fib6_del_route\n"); /* Unlink it / rtp = rt->dst.rt6_next; rt->rt6i_node = NULL; net->ipv6.rt6_stats->fib_rt_entries--; net->ipv6.rt6_stats->fib_discarded_routes++; /* Reset round-robin state, if necessary / if (fn->rr_ptr == rt) fn->rr_ptr = NULL; / Remove this entry from other siblings / if (rt->rt6i_nsiblings) { struct rt6_info sibling, next_sibling; list_for_each_entry_safe(sibling, next_sibling, &rt->rt6i_siblings, rt6i_siblings) sibling->rt6i_nsiblings--; rt->rt6i_nsiblings = 0; list_del_init(&rt->rt6i_siblings); } / Adjust walkers / read_lock(&fib6_walker_lock); FOR_WALKERS(w) { if (w->state == FWS_C && w->leaf == rt) { RT6_TRACE("walker %p adjusted by delroute\n", w); w->leaf = rt->dst.rt6_next; if (!w->leaf) w->state = FWS_U; } } read_unlock(&fib6_walker_lock); rt->dst.rt6_next = NULL; / If it was last route, expunge its radix tree node / if (!fn->leaf) { fn->fn_flags &= ~RTN_RTINFO; net->ipv6.rt6_stats->fib_route_nodes--; fn = fib6_repair_tree(net, fn); } if (atomic_read(&rt->rt6i_ref) != 1) { / This route is used as dummy address holder in some split * nodes. It is not leaked, but it still holds other resources, * which must be released in time. So, scan ascendant nodes * and replace dummy references to this route with references * to still alive ones. / while (fn) { if (!(fn->fn_flags & RTN_RTINFO) && fn->leaf == rt) { fn->leaf = fib6_find_prefix(net, fn); atomic_inc(&fn->leaf->rt6i_ref); rt6_release(rt); } fn = fn->parent; } / No more references are possible at this point. / BUG_ON(atomic_read(&rt->rt6i_ref) != 1); } inet6_rt_notify(RTM_DELROUTE, rt, info); rt6_release(rt); } int fib6_del(struct rt6_info rt, struct nl_info info) { struct net net = info->nl_net; struct fib6_node fn = rt->rt6i_node; struct rt6_info rtp; #if RT6_DEBUG >= 2 if (rt->dst.obsolete>0) { WARN_ON(fn != NULL); return -ENOENT; } #endif if (!fn \|\| rt == net->ipv6.ip6_null_entry) return -ENOENT; WARN_ON(!(fn->fn_flags & RTN_RTINFO)); if (!(rt->rt6i_flags & RTF_CACHE)) { struct fib6_node pn = fn; #ifdef CONFIG_IPV6_SUBTREES /* clones of this route might be in another subtree / if (rt->rt6i_src.plen) { while (!(pn->fn_flags & RTN_ROOT)) pn = pn->parent; pn = pn->parent; } #endif fib6_prune_clones(info->nl_net, pn, rt); } / * Walk the leaf entries looking for ourself / for (rtp = &fn->leaf; rtp; rtp = &(rtp)->dst.rt6_next) { if (rtp == rt) { fib6_del_route(fn, rtp, info); return 0; } } return -ENOENT; } /* * Tree traversal function. * * Certainly, it is not interrupt safe. * However, it is internally reenterable wrt itself and fib6_add/fib6_del. * It means, that we can modify tree during walking * and use this function for garbage collection, clone pruning, * cleaning tree when a device goes down etc. etc. * * It guarantees that every node will be traversed, * and that it will be traversed only once. * * Callback function w->func may return: * 0 -> continue walking. * positive value -> walking is suspended (used by tree dumps, * and probably by gc, if it will be split to several slices) * negative value -> terminate walking. * * The function itself returns: * 0 -> walk is complete. * >0 -> walk is incomplete (i.e. suspended) * <0 -> walk is terminated by an error. / static int fib6_walk_continue(struct fib6_walker_t w) { struct fib6_node fn, pn; for (;;) { fn = w->node; if (!fn) return 0; if (w->prune && fn != w->root && fn->fn_flags & RTN_RTINFO && w->state < FWS_C) { w->state = FWS_C; w->leaf = fn->leaf; } switch (w->state) { #ifdef CONFIG_IPV6_SUBTREES case FWS_S: if (FIB6_SUBTREE(fn)) { w->node = FIB6_SUBTREE(fn); continue; } w->state = FWS_L; #endif case FWS_L: if (fn->left) { w->node = fn->left; w->state = FWS_INIT; continue; } w->state = FWS_R; case FWS_R: if (fn->right) { w->node = fn->right; w->state = FWS_INIT; continue; } w->state = FWS_C; w->leaf = fn->leaf; case FWS_C: if (w->leaf && fn->fn_flags & RTN_RTINFO) { int err; if (w->skip) { w->skip--; continue; } err = w->func(w); if (err) return err; w->count++; continue; } w->state = FWS_U; case FWS_U: if (fn == w->root) return 0; pn = fn->parent; w->node = pn; #ifdef CONFIG_IPV6_SUBTREES if (FIB6_SUBTREE(pn) == fn) { WARN_ON(!(fn->fn_flags & RTN_ROOT)); w->state = FWS_L; continue; } #endif if (pn->left == fn) { w->state = FWS_R; continue; } if (pn->right == fn) { w->state = FWS_C; w->leaf = w->node->leaf; continue; } #if RT6_DEBUG >= 2 WARN_ON(1); #endif } } } static int fib6_walk(struct fib6_walker_t w) { int res; w->state = FWS_INIT; w->node = w->root; fib6_walker_link(w); res = fib6_walk_continue(w); if (res <= 0) fib6_walker_unlink(w); return res; } static int fib6_clean_node(struct fib6_walker_t w) { int res; struct rt6_info rt; struct fib6_cleaner_t c = container_of(w, struct fib6_cleaner_t, w); struct nl_info info = { .nl_net = c->net, }; for (rt = w->leaf; rt; rt = rt->dst.rt6_next) { res = c->func(rt, c->arg); if (res < 0) { w->leaf = rt; res = fib6_del(rt, &info); if (res) { #if RT6_DEBUG >= 2 pr_debug("%s: del failed: rt=%p@%p err=%d\n", __func__, rt, rt->rt6i_node, res); #endif continue; } return 0; } WARN_ON(res != 0); } w->leaf = rt; return 0; } /* * Convenient frontend to tree walker. * * func is called on each route. * It may return -1 -> delete this route. * 0 -> continue walking * * prune==1 -> only immediate children of node (certainly, * ignoring pure split nodes) will be scanned. / static void fib6_clean_tree(struct net net, struct fib6_node root, int (func)(struct rt6_info , void arg), int prune, void arg) { struct fib6_cleaner_t c; c.w.root = root; c.w.func = fib6_clean_node; c.w.prune = prune; c.w.count = 0; c.w.skip = 0; c.func = func; c.arg = arg; c.net = net; fib6_walk(&c.w); } void fib6_clean_all_ro(struct net net, int (func)(struct rt6_info , void arg), int prune, void arg) { struct fib6_table table; struct hlist_head head; unsigned int h; rcu_read_lock(); for (h = 0; h < FIB6_TABLE_HASHSZ; h++) { head = &net->ipv6.fib_table_hash[h]; hlist_for_each_entry_rcu(table, head, tb6_hlist) { read_lock_bh(&table->tb6_lock); fib6_clean_tree(net, &table->tb6_root, func, prune, arg); read_unlock_bh(&table->tb6_lock); } } rcu_read_unlock(); } void fib6_clean_all(struct net net, int (func)(struct rt6_info , void arg), int prune, void arg) { struct fib6_table table; struct hlist_head head; unsigned int h; rcu_read_lock(); for (h = 0; h < FIB6_TABLE_HASHSZ; h++) { head = &net->ipv6.fib_table_hash[h]; hlist_for_each_entry_rcu(table, head, tb6_hlist) { write_lock_bh(&table->tb6_lock); fib6_clean_tree(net, &table->tb6_root, func, prune, arg); write_unlock_bh(&table->tb6_lock); } } rcu_read_unlock(); } static int fib6_prune_clone(struct rt6_info rt, void arg) { if (rt->rt6i_flags & RTF_CACHE) { RT6_TRACE("pruning clone %p\n", rt); return -1; } return 0; } static void fib6_prune_clones(struct net net, struct fib6_node fn, struct rt6_info rt) { fib6_clean_tree(net, fn, fib6_prune_clone, 1, rt); } /* * Garbage collection / static struct fib6_gc_args { int timeout; int more; } gc_args; static int fib6_age(struct rt6_info rt, void arg) { unsigned long now = jiffies; / * check addrconf expiration here. * Routes are expired even if they are in use. * * Also age clones. Note, that clones are aged out * only if they are not in use now. / if (rt->rt6i_flags & RTF_EXPIRES && rt->dst.expires) { if (time_after(now, rt->dst.expires)) { RT6_TRACE("expiring %p\n", rt); return -1; } gc_args.more++; } else if (rt->rt6i_flags & RTF_CACHE) { if (atomic_read(&rt->dst.__refcnt) == 0 && time_after_eq(now, rt->dst.lastuse + gc_args.timeout)) { RT6_TRACE("aging clone %p\n", rt); return -1; } else if (rt->rt6i_flags & RTF_GATEWAY) { struct neighbour neigh; __u8 neigh_flags = 0; neigh = dst_neigh_lookup(&rt->dst, &rt->rt6i_gateway); if (neigh) { neigh_flags = neigh->flags; neigh_release(neigh); } if (!(neigh_flags & NTF_ROUTER)) { RT6_TRACE("purging route %p via non-router but gateway\n", rt); return -1; } } gc_args.more++; } return 0; } static DEFINE_SPINLOCK(fib6_gc_lock); void fib6_run_gc(unsigned long expires, struct net net, bool force) { unsigned long now; if (force) { spin_lock_bh(&fib6_gc_lock); } else if (!spin_trylock_bh(&fib6_gc_lock)) { mod_timer(&net->ipv6.ip6_fib_timer, jiffies + HZ); return; } gc_args.timeout = expires ? (int)expires : net->ipv6.sysctl.ip6_rt_gc_interval; gc_args.more = icmp6_dst_gc(); fib6_clean_all(net, fib6_age, 0, NULL); now = jiffies; net->ipv6.ip6_rt_last_gc = now; if (gc_args.more) mod_timer(&net->ipv6.ip6_fib_timer, round_jiffies(now + net->ipv6.sysctl.ip6_rt_gc_interval)); else del_timer(&net->ipv6.ip6_fib_timer); spin_unlock_bh(&fib6_gc_lock); } static void fib6_gc_timer_cb(unsigned long arg) { fib6_run_gc(0, (struct net )arg, true); } static int __net_init fib6_net_init(struct net net) { size_t size = sizeof(struct hlist_head) FIB6_TABLE_HASHSZ; setup_timer(&net->ipv6.ip6_fib_timer, fib6_gc_timer_cb, (unsigned long)net); net->ipv6.rt6_stats = kzalloc(sizeof(net->ipv6.rt6_stats), GFP_KERNEL); if (!net->ipv6.rt6_stats) goto out_timer; / Avoid false sharing : Use at least a full cache line / size = max_t(size_t, size, L1_CACHE_BYTES); net->ipv6.fib_table_hash = kzalloc(size, GFP_KERNEL); if (!net->ipv6.fib_table_hash) goto out_rt6_stats; net->ipv6.fib6_main_tbl = kzalloc(sizeof(net->ipv6.fib6_main_tbl), GFP_KERNEL); if (!net->ipv6.fib6_main_tbl) goto out_fib_table_hash; net->ipv6.fib6_main_tbl->tb6_id = RT6_TABLE_MAIN; net->ipv6.fib6_main_tbl->tb6_root.leaf = net->ipv6.ip6_null_entry; net->ipv6.fib6_main_tbl->tb6_root.fn_flags = RTN_ROOT \| RTN_TL_ROOT \| RTN_RTINFO; inet_peer_base_init(&net->ipv6.fib6_main_tbl->tb6_peers); #ifdef CONFIG_IPV6_MULTIPLE_TABLES net->ipv6.fib6_local_tbl = kzalloc(sizeof(net->ipv6.fib6_local_tbl), GFP_KERNEL); if (!net->ipv6.fib6_local_tbl) goto out_fib6_main_tbl; net->ipv6.fib6_local_tbl->tb6_id = RT6_TABLE_LOCAL; net->ipv6.fib6_local_tbl->tb6_root.leaf = net->ipv6.ip6_null_entry; net->ipv6.fib6_local_tbl->tb6_root.fn_flags = RTN_ROOT \| RTN_TL_ROOT \| RTN_RTINFO; inet_peer_base_init(&net->ipv6.fib6_local_tbl->tb6_peers); #endif fib6_tables_init(net); return 0; #ifdef CONFIG_IPV6_MULTIPLE_TABLES out_fib6_main_tbl: kfree(net->ipv6.fib6_main_tbl); #endif out_fib_table_hash: kfree(net->ipv6.fib_table_hash); out_rt6_stats: kfree(net->ipv6.rt6_stats); out_timer: return -ENOMEM; } static void fib6_net_exit(struct net net) { rt6_ifdown(net, NULL); del_timer_sync(&net->ipv6.ip6_fib_timer); #ifdef CONFIG_IPV6_MULTIPLE_TABLES inetpeer_invalidate_tree(&net->ipv6.fib6_local_tbl->tb6_peers); kfree(net->ipv6.fib6_local_tbl); #endif inetpeer_invalidate_tree(&net->ipv6.fib6_main_tbl->tb6_peers); kfree(net->ipv6.fib6_main_tbl); kfree(net->ipv6.fib_table_hash); kfree(net->ipv6.rt6_stats); } static struct pernet_operations fib6_net_ops = { .init = fib6_net_init, .exit = fib6_net_exit, }; int __init fib6_init(void) { int ret = -ENOMEM; fib6_node_kmem = kmem_cache_create("fib6_nodes", sizeof(struct fib6_node), 0, SLAB_HWCACHE_ALIGN, NULL); if (!fib6_node_kmem) goto out; ret = register_pernet_subsys(&fib6_net_ops); if (ret) goto out_kmem_cache_create; ret = __rtnl_register(PF_INET6, RTM_GETROUTE, NULL, inet6_dump_fib, NULL); if (ret) goto out_unregister_subsys; out: return ret; out_unregister_subsys: unregister_pernet_subsys(&fib6_net_ops); out_kmem_cache_create: kmem_cache_destroy(fib6_node_kmem); goto out; } void fib6_gc_cleanup(void) { unregister_pernet_subsys(&fib6_net_ops); kmem_cache_destroy(fib6_node_kmem); }	./CrossVul/dataset_final_sorted/CWE-264/c/good_5806_0
crossvul-cpp_data_bad_3604_8	404: Not Found	./CrossVul/dataset_final_sorted/CWE-264/c/bad_3604_8
crossvul-cpp_data_bad_3524_4	/* * TUN - Universal TUN/TAP device driver. * Copyright (C) 1999-2002 Maxim Krasnyansky <maxk@qualcomm.com> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * $Id: tun.c,v 1.15 2002/03/01 02:44:24 maxk Exp $ / / * Changes: * * Mike Kershaw <dragorn@kismetwireless.net> 2005/08/14 * Add TUNSETLINK ioctl to set the link encapsulation * * Mark Smith <markzzzsmith@yahoo.com.au> * Use random_ether_addr() for tap MAC address. * * Harald Roelle <harald.roelle@ifi.lmu.de> 2004/04/20 * Fixes in packet dropping, queue length setting and queue wakeup. * Increased default tx queue length. * Added ethtool API. * Minor cleanups * * Daniel Podlejski <underley@underley.eu.org> * Modifications for 2.3.99-pre5 kernel. / #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #define DRV_NAME "tun" #define DRV_VERSION "1.6" #define DRV_DESCRIPTION "Universal TUN/TAP device driver" #define DRV_COPYRIGHT "(C) 1999-2004 Max Krasnyansky <maxk@qualcomm.com>" #include <linux/module.h> #include <linux/errno.h> #include <linux/kernel.h> #include <linux/major.h> #include <linux/slab.h> #include <linux/poll.h> #include <linux/fcntl.h> #include <linux/init.h> #include <linux/skbuff.h> #include <linux/netdevice.h> #include <linux/etherdevice.h> #include <linux/miscdevice.h> #include <linux/ethtool.h> #include <linux/rtnetlink.h> #include <linux/compat.h> #include <linux/if.h> #include <linux/if_arp.h> #include <linux/if_ether.h> #include <linux/if_tun.h> #include <linux/crc32.h> #include <linux/nsproxy.h> #include <linux/virtio_net.h> #include <linux/rcupdate.h> #include <net/net_namespace.h> #include <net/netns/generic.h> #include <net/rtnetlink.h> #include <net/sock.h> #include <asm/system.h> #include <asm/uaccess.h> / Uncomment to enable debugging / / #define TUN_DEBUG 1 / #ifdef TUN_DEBUG static int debug; #define tun_debug(level, tun, fmt, args...) \ do { \ if (tun->debug) \ netdev_printk(level, tun->dev, fmt, ##args); \ } while (0) #define DBG1(level, fmt, args...) \ do { \ if (debug == 2) \ printk(level fmt, ##args); \ } while (0) #else #define tun_debug(level, tun, fmt, args...) \ do { \ if (0) \ netdev_printk(level, tun->dev, fmt, ##args); \ } while (0) #define DBG1(level, fmt, args...) \ do { \ if (0) \ printk(level fmt, ##args); \ } while (0) #endif #define FLT_EXACT_COUNT 8 struct tap_filter { unsigned int count; / Number of addrs. Zero means disabled / u32 mask[2]; / Mask of the hashed addrs / unsigned char addr[FLT_EXACT_COUNT][ETH_ALEN]; }; struct tun_file { atomic_t count; struct tun_struct tun; struct net net; }; struct tun_sock; struct tun_struct { struct tun_file tfile; unsigned int flags; uid_t owner; gid_t group; struct net_device dev; u32 set_features; #define TUN_USER_FEATURES (NETIF_F_HW_CSUM\|NETIF_F_TSO_ECN\|NETIF_F_TSO\| \ NETIF_F_TSO6\|NETIF_F_UFO) struct fasync_struct fasync; struct tap_filter txflt; struct socket socket; struct socket_wq wq; int vnet_hdr_sz; #ifdef TUN_DEBUG int debug; #endif }; struct tun_sock { struct sock sk; struct tun_struct tun; }; static inline struct tun_sock tun_sk(struct sock sk) { return container_of(sk, struct tun_sock, sk); } static int tun_attach(struct tun_struct tun, struct file file) { struct tun_file tfile = file->private_data; int err; ASSERT_RTNL(); netif_tx_lock_bh(tun->dev); err = -EINVAL; if (tfile->tun) goto out; err = -EBUSY; if (tun->tfile) goto out; err = 0; tfile->tun = tun; tun->tfile = tfile; tun->socket.file = file; netif_carrier_on(tun->dev); dev_hold(tun->dev); sock_hold(tun->socket.sk); atomic_inc(&tfile->count); out: netif_tx_unlock_bh(tun->dev); return err; } static void __tun_detach(struct tun_struct tun) { / Detach from net device / netif_tx_lock_bh(tun->dev); netif_carrier_off(tun->dev); tun->tfile = NULL; tun->socket.file = NULL; netif_tx_unlock_bh(tun->dev); / Drop read queue / skb_queue_purge(&tun->socket.sk->sk_receive_queue); / Drop the extra count on the net device / dev_put(tun->dev); } static void tun_detach(struct tun_struct tun) { rtnl_lock(); __tun_detach(tun); rtnl_unlock(); } static struct tun_struct __tun_get(struct tun_file tfile) { struct tun_struct tun = NULL; if (atomic_inc_not_zero(&tfile->count)) tun = tfile->tun; return tun; } static struct tun_struct tun_get(struct file file) { return __tun_get(file->private_data); } static void tun_put(struct tun_struct tun) { struct tun_file tfile = tun->tfile; if (atomic_dec_and_test(&tfile->count)) tun_detach(tfile->tun); } / TAP filtering / static void addr_hash_set(u32 mask, const u8 addr) { int n = ether_crc(ETH_ALEN, addr) >> 26; mask[n >> 5] \|= (1 << (n & 31)); } static unsigned int addr_hash_test(const u32 mask, const u8 addr) { int n = ether_crc(ETH_ALEN, addr) >> 26; return mask[n >> 5] & (1 << (n & 31)); } static int update_filter(struct tap_filter filter, void __user arg) { struct { u8 u[ETH_ALEN]; } addr; struct tun_filter uf; int err, alen, n, nexact; if (copy_from_user(&uf, arg, sizeof(uf))) return -EFAULT; if (!uf.count) { /* Disabled / filter->count = 0; return 0; } alen = ETH_ALEN uf.count; addr = kmalloc(alen, GFP_KERNEL); if (!addr) return -ENOMEM; if (copy_from_user(addr, arg + sizeof(uf), alen)) { err = -EFAULT; goto done; } /* The filter is updated without holding any locks. Which is * perfectly safe. We disable it first and in the worst * case we'll accept a few undesired packets. / filter->count = 0; wmb(); / Use first set of addresses as an exact filter / for (n = 0; n < uf.count && n < FLT_EXACT_COUNT; n++) memcpy(filter->addr[n], addr[n].u, ETH_ALEN); nexact = n; / Remaining multicast addresses are hashed, * unicast will leave the filter disabled. / memset(filter->mask, 0, sizeof(filter->mask)); for (; n < uf.count; n++) { if (!is_multicast_ether_addr(addr[n].u)) { err = 0; / no filter / goto done; } addr_hash_set(filter->mask, addr[n].u); } / For ALLMULTI just set the mask to all ones. * This overrides the mask populated above. / if ((uf.flags & TUN_FLT_ALLMULTI)) memset(filter->mask, ~0, sizeof(filter->mask)); / Now enable the filter / wmb(); filter->count = nexact; / Return the number of exact filters / err = nexact; done: kfree(addr); return err; } / Returns: 0 - drop, !=0 - accept / static int run_filter(struct tap_filter filter, const struct sk_buff skb) { / Cannot use eth_hdr(skb) here because skb_mac_hdr() is incorrect * at this point. / struct ethhdr eh = (struct ethhdr ) skb->data; int i; / Exact match / for (i = 0; i < filter->count; i++) if (!compare_ether_addr(eh->h_dest, filter->addr[i])) return 1; / Inexact match (multicast only) / if (is_multicast_ether_addr(eh->h_dest)) return addr_hash_test(filter->mask, eh->h_dest); return 0; } / * Checks whether the packet is accepted or not. * Returns: 0 - drop, !=0 - accept / static int check_filter(struct tap_filter filter, const struct sk_buff skb) { if (!filter->count) return 1; return run_filter(filter, skb); } / Network device part of the driver / static const struct ethtool_ops tun_ethtool_ops; / Net device detach from fd. / static void tun_net_uninit(struct net_device dev) { struct tun_struct tun = netdev_priv(dev); struct tun_file tfile = tun->tfile; /* Inform the methods they need to stop using the dev. / if (tfile) { wake_up_all(&tun->wq.wait); if (atomic_dec_and_test(&tfile->count)) __tun_detach(tun); } } static void tun_free_netdev(struct net_device dev) { struct tun_struct tun = netdev_priv(dev); sock_put(tun->socket.sk); } / Net device open. / static int tun_net_open(struct net_device dev) { netif_start_queue(dev); return 0; } /* Net device close. / static int tun_net_close(struct net_device dev) { netif_stop_queue(dev); return 0; } /* Net device start xmit / static netdev_tx_t tun_net_xmit(struct sk_buff skb, struct net_device dev) { struct tun_struct tun = netdev_priv(dev); tun_debug(KERN_INFO, tun, "tun_net_xmit %d\n", skb->len); /* Drop packet if interface is not attached / if (!tun->tfile) goto drop; / Drop if the filter does not like it. * This is a noop if the filter is disabled. * Filter can be enabled only for the TAP devices. / if (!check_filter(&tun->txflt, skb)) goto drop; if (tun->socket.sk->sk_filter && sk_filter(tun->socket.sk, skb)) goto drop; if (skb_queue_len(&tun->socket.sk->sk_receive_queue) >= dev->tx_queue_len) { if (!(tun->flags & TUN_ONE_QUEUE)) { / Normal queueing mode. / / Packet scheduler handles dropping of further packets. / netif_stop_queue(dev); / We won't see all dropped packets individually, so overrun * error is more appropriate. / dev->stats.tx_fifo_errors++; } else { / Single queue mode. * Driver handles dropping of all packets itself. / goto drop; } } / Orphan the skb - required as we might hang on to it * for indefinite time. / skb_orphan(skb); / Enqueue packet / skb_queue_tail(&tun->socket.sk->sk_receive_queue, skb); / Notify and wake up reader process / if (tun->flags & TUN_FASYNC) kill_fasync(&tun->fasync, SIGIO, POLL_IN); wake_up_interruptible_poll(&tun->wq.wait, POLLIN \| POLLRDNORM \| POLLRDBAND); return NETDEV_TX_OK; drop: dev->stats.tx_dropped++; kfree_skb(skb); return NETDEV_TX_OK; } static void tun_net_mclist(struct net_device dev) { /* * This callback is supposed to deal with mc filter in * _rx_ path and has nothing to do with the _tx_ path. * In rx path we always accept everything userspace gives us. / } #define MIN_MTU 68 #define MAX_MTU 65535 static int tun_net_change_mtu(struct net_device dev, int new_mtu) { if (new_mtu < MIN_MTU \|\| new_mtu + dev->hard_header_len > MAX_MTU) return -EINVAL; dev->mtu = new_mtu; return 0; } static u32 tun_net_fix_features(struct net_device dev, u32 features) { struct tun_struct tun = netdev_priv(dev); return (features & tun->set_features) \| (features & ~TUN_USER_FEATURES); } #ifdef CONFIG_NET_POLL_CONTROLLER static void tun_poll_controller(struct net_device dev) { / * Tun only receives frames when: * 1) the char device endpoint gets data from user space * 2) the tun socket gets a sendmsg call from user space * Since both of those are syncronous operations, we are guaranteed * never to have pending data when we poll for it * so theres nothing to do here but return. * We need this though so netpoll recognizes us as an interface that * supports polling, which enables bridge devices in virt setups to * still use netconsole / return; } #endif static const struct net_device_ops tun_netdev_ops = { .ndo_uninit = tun_net_uninit, .ndo_open = tun_net_open, .ndo_stop = tun_net_close, .ndo_start_xmit = tun_net_xmit, .ndo_change_mtu = tun_net_change_mtu, .ndo_fix_features = tun_net_fix_features, #ifdef CONFIG_NET_POLL_CONTROLLER .ndo_poll_controller = tun_poll_controller, #endif }; static const struct net_device_ops tap_netdev_ops = { .ndo_uninit = tun_net_uninit, .ndo_open = tun_net_open, .ndo_stop = tun_net_close, .ndo_start_xmit = tun_net_xmit, .ndo_change_mtu = tun_net_change_mtu, .ndo_fix_features = tun_net_fix_features, .ndo_set_multicast_list = tun_net_mclist, .ndo_set_mac_address = eth_mac_addr, .ndo_validate_addr = eth_validate_addr, #ifdef CONFIG_NET_POLL_CONTROLLER .ndo_poll_controller = tun_poll_controller, #endif }; / Initialize net device. / static void tun_net_init(struct net_device dev) { struct tun_struct tun = netdev_priv(dev); switch (tun->flags & TUN_TYPE_MASK) { case TUN_TUN_DEV: dev->netdev_ops = &tun_netdev_ops; / Point-to-Point TUN Device / dev->hard_header_len = 0; dev->addr_len = 0; dev->mtu = 1500; / Zero header length / dev->type = ARPHRD_NONE; dev->flags = IFF_POINTOPOINT \| IFF_NOARP \| IFF_MULTICAST; dev->tx_queue_len = TUN_READQ_SIZE; / We prefer our own queue length / break; case TUN_TAP_DEV: dev->netdev_ops = &tap_netdev_ops; / Ethernet TAP Device / ether_setup(dev); random_ether_addr(dev->dev_addr); dev->tx_queue_len = TUN_READQ_SIZE; / We prefer our own queue length / break; } } / Character device part / / Poll / static unsigned int tun_chr_poll(struct file file, poll_table * wait) { struct tun_file tfile = file->private_data; struct tun_struct tun = __tun_get(tfile); struct sock sk; unsigned int mask = 0; if (!tun) return POLLERR; sk = tun->socket.sk; tun_debug(KERN_INFO, tun, "tun_chr_poll\n"); poll_wait(file, &tun->wq.wait, wait); if (!skb_queue_empty(&sk->sk_receive_queue)) mask \|= POLLIN \| POLLRDNORM; if (sock_writeable(sk) \|\| (!test_and_set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags) && sock_writeable(sk))) mask \|= POLLOUT \| POLLWRNORM; if (tun->dev->reg_state != NETREG_REGISTERED) mask = POLLERR; tun_put(tun); return mask; } / prepad is the amount to reserve at front. len is length after that. * linear is a hint as to how much to copy (usually headers). / static struct sk_buff tun_alloc_skb(struct tun_struct tun, size_t prepad, size_t len, size_t linear, int noblock) { struct sock sk = tun->socket.sk; struct sk_buff skb; int err; sock_update_classid(sk); / Under a page? Don't bother with paged skb. / if (prepad + len < PAGE_SIZE \|\| !linear) linear = len; skb = sock_alloc_send_pskb(sk, prepad + linear, len - linear, noblock, &err); if (!skb) return ERR_PTR(err); skb_reserve(skb, prepad); skb_put(skb, linear); skb->data_len = len - linear; skb->len += len - linear; return skb; } / Get packet from user space buffer / static ssize_t tun_get_user(struct tun_struct tun, const struct iovec iv, size_t count, int noblock) { struct tun_pi pi = { 0, cpu_to_be16(ETH_P_IP) }; struct sk_buff skb; size_t len = count, align = NET_SKB_PAD; struct virtio_net_hdr gso = { 0 }; int offset = 0; if (!(tun->flags & TUN_NO_PI)) { if ((len -= sizeof(pi)) > count) return -EINVAL; if (memcpy_fromiovecend((void )&pi, iv, 0, sizeof(pi))) return -EFAULT; offset += sizeof(pi); } if (tun->flags & TUN_VNET_HDR) { if ((len -= tun->vnet_hdr_sz) > count) return -EINVAL; if (memcpy_fromiovecend((void )&gso, iv, offset, sizeof(gso))) return -EFAULT; if ((gso.flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) && gso.csum_start + gso.csum_offset + 2 > gso.hdr_len) gso.hdr_len = gso.csum_start + gso.csum_offset + 2; if (gso.hdr_len > len) return -EINVAL; offset += tun->vnet_hdr_sz; } if ((tun->flags & TUN_TYPE_MASK) == TUN_TAP_DEV) { align += NET_IP_ALIGN; if (unlikely(len < ETH_HLEN \|\| (gso.hdr_len && gso.hdr_len < ETH_HLEN))) return -EINVAL; } skb = tun_alloc_skb(tun, align, len, gso.hdr_len, noblock); if (IS_ERR(skb)) { if (PTR_ERR(skb) != -EAGAIN) tun->dev->stats.rx_dropped++; return PTR_ERR(skb); } if (skb_copy_datagram_from_iovec(skb, 0, iv, offset, len)) { tun->dev->stats.rx_dropped++; kfree_skb(skb); return -EFAULT; } if (gso.flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) { if (!skb_partial_csum_set(skb, gso.csum_start, gso.csum_offset)) { tun->dev->stats.rx_frame_errors++; kfree_skb(skb); return -EINVAL; } } switch (tun->flags & TUN_TYPE_MASK) { case TUN_TUN_DEV: if (tun->flags & TUN_NO_PI) { switch (skb->data[0] & 0xf0) { case 0x40: pi.proto = htons(ETH_P_IP); break; case 0x60: pi.proto = htons(ETH_P_IPV6); break; default: tun->dev->stats.rx_dropped++; kfree_skb(skb); return -EINVAL; } } skb_reset_mac_header(skb); skb->protocol = pi.proto; skb->dev = tun->dev; break; case TUN_TAP_DEV: skb->protocol = eth_type_trans(skb, tun->dev); break; } if (gso.gso_type != VIRTIO_NET_HDR_GSO_NONE) { pr_debug("GSO!\n"); switch (gso.gso_type & ~VIRTIO_NET_HDR_GSO_ECN) { case VIRTIO_NET_HDR_GSO_TCPV4: skb_shinfo(skb)->gso_type = SKB_GSO_TCPV4; break; case VIRTIO_NET_HDR_GSO_TCPV6: skb_shinfo(skb)->gso_type = SKB_GSO_TCPV6; break; case VIRTIO_NET_HDR_GSO_UDP: skb_shinfo(skb)->gso_type = SKB_GSO_UDP; break; default: tun->dev->stats.rx_frame_errors++; kfree_skb(skb); return -EINVAL; } if (gso.gso_type & VIRTIO_NET_HDR_GSO_ECN) skb_shinfo(skb)->gso_type \|= SKB_GSO_TCP_ECN; skb_shinfo(skb)->gso_size = gso.gso_size; if (skb_shinfo(skb)->gso_size == 0) { tun->dev->stats.rx_frame_errors++; kfree_skb(skb); return -EINVAL; } /* Header must be checked, and gso_segs computed. / skb_shinfo(skb)->gso_type \|= SKB_GSO_DODGY; skb_shinfo(skb)->gso_segs = 0; } netif_rx_ni(skb); tun->dev->stats.rx_packets++; tun->dev->stats.rx_bytes += len; return count; } static ssize_t tun_chr_aio_write(struct kiocb iocb, const struct iovec iv, unsigned long count, loff_t pos) { struct file file = iocb->ki_filp; struct tun_struct tun = tun_get(file); ssize_t result; if (!tun) return -EBADFD; tun_debug(KERN_INFO, tun, "tun_chr_write %ld\n", count); result = tun_get_user(tun, iv, iov_length(iv, count), file->f_flags & O_NONBLOCK); tun_put(tun); return result; } / Put packet to the user space buffer / static ssize_t tun_put_user(struct tun_struct tun, struct sk_buff skb, const struct iovec iv, int len) { struct tun_pi pi = { 0, skb->protocol }; ssize_t total = 0; if (!(tun->flags & TUN_NO_PI)) { if ((len -= sizeof(pi)) < 0) return -EINVAL; if (len < skb->len) { /* Packet will be striped / pi.flags \|= TUN_PKT_STRIP; } if (memcpy_toiovecend(iv, (void ) &pi, 0, sizeof(pi))) return -EFAULT; total += sizeof(pi); } if (tun->flags & TUN_VNET_HDR) { struct virtio_net_hdr gso = { 0 }; /* no info leak / if ((len -= tun->vnet_hdr_sz) < 0) return -EINVAL; if (skb_is_gso(skb)) { struct skb_shared_info sinfo = skb_shinfo(skb); /* This is a hint as to how much should be linear. / gso.hdr_len = skb_headlen(skb); gso.gso_size = sinfo->gso_size; if (sinfo->gso_type & SKB_GSO_TCPV4) gso.gso_type = VIRTIO_NET_HDR_GSO_TCPV4; else if (sinfo->gso_type & SKB_GSO_TCPV6) gso.gso_type = VIRTIO_NET_HDR_GSO_TCPV6; else if (sinfo->gso_type & SKB_GSO_UDP) gso.gso_type = VIRTIO_NET_HDR_GSO_UDP; else { pr_err("unexpected GSO type: " "0x%x, gso_size %d, hdr_len %d\n", sinfo->gso_type, gso.gso_size, gso.hdr_len); print_hex_dump(KERN_ERR, "tun: ", DUMP_PREFIX_NONE, 16, 1, skb->head, min((int)gso.hdr_len, 64), true); WARN_ON_ONCE(1); return -EINVAL; } if (sinfo->gso_type & SKB_GSO_TCP_ECN) gso.gso_type \|= VIRTIO_NET_HDR_GSO_ECN; } else gso.gso_type = VIRTIO_NET_HDR_GSO_NONE; if (skb->ip_summed == CHECKSUM_PARTIAL) { gso.flags = VIRTIO_NET_HDR_F_NEEDS_CSUM; gso.csum_start = skb_checksum_start_offset(skb); gso.csum_offset = skb->csum_offset; } else if (skb->ip_summed == CHECKSUM_UNNECESSARY) { gso.flags = VIRTIO_NET_HDR_F_DATA_VALID; } / else everything is zero / if (unlikely(memcpy_toiovecend(iv, (void )&gso, total, sizeof(gso)))) return -EFAULT; total += tun->vnet_hdr_sz; } len = min_t(int, skb->len, len); skb_copy_datagram_const_iovec(skb, 0, iv, total, len); total += skb->len; tun->dev->stats.tx_packets++; tun->dev->stats.tx_bytes += len; return total; } static ssize_t tun_do_read(struct tun_struct tun, struct kiocb iocb, const struct iovec iv, ssize_t len, int noblock) { DECLARE_WAITQUEUE(wait, current); struct sk_buff skb; ssize_t ret = 0; tun_debug(KERN_INFO, tun, "tun_chr_read\n"); if (unlikely(!noblock)) add_wait_queue(&tun->wq.wait, &wait); while (len) { current->state = TASK_INTERRUPTIBLE; /* Read frames from the queue / if (!(skb=skb_dequeue(&tun->socket.sk->sk_receive_queue))) { if (noblock) { ret = -EAGAIN; break; } if (signal_pending(current)) { ret = -ERESTARTSYS; break; } if (tun->dev->reg_state != NETREG_REGISTERED) { ret = -EIO; break; } / Nothing to read, let's sleep / schedule(); continue; } netif_wake_queue(tun->dev); ret = tun_put_user(tun, skb, iv, len); kfree_skb(skb); break; } current->state = TASK_RUNNING; if (unlikely(!noblock)) remove_wait_queue(&tun->wq.wait, &wait); return ret; } static ssize_t tun_chr_aio_read(struct kiocb iocb, const struct iovec iv, unsigned long count, loff_t pos) { struct file file = iocb->ki_filp; struct tun_file tfile = file->private_data; struct tun_struct tun = __tun_get(tfile); ssize_t len, ret; if (!tun) return -EBADFD; len = iov_length(iv, count); if (len < 0) { ret = -EINVAL; goto out; } ret = tun_do_read(tun, iocb, iv, len, file->f_flags & O_NONBLOCK); ret = min_t(ssize_t, ret, len); out: tun_put(tun); return ret; } static void tun_setup(struct net_device dev) { struct tun_struct tun = netdev_priv(dev); tun->owner = -1; tun->group = -1; dev->ethtool_ops = &tun_ethtool_ops; dev->destructor = tun_free_netdev; } /* Trivial set of netlink ops to allow deleting tun or tap * device with netlink. / static int tun_validate(struct nlattr tb[], struct nlattr data[]) { return -EINVAL; } static struct rtnl_link_ops tun_link_ops __read_mostly = { .kind = DRV_NAME, .priv_size = sizeof(struct tun_struct), .setup = tun_setup, .validate = tun_validate, }; static void tun_sock_write_space(struct sock sk) { struct tun_struct tun; wait_queue_head_t wqueue; if (!sock_writeable(sk)) return; if (!test_and_clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags)) return; wqueue = sk_sleep(sk); if (wqueue && waitqueue_active(wqueue)) wake_up_interruptible_sync_poll(wqueue, POLLOUT \| POLLWRNORM \| POLLWRBAND); tun = tun_sk(sk)->tun; kill_fasync(&tun->fasync, SIGIO, POLL_OUT); } static void tun_sock_destruct(struct sock sk) { free_netdev(tun_sk(sk)->tun->dev); } static int tun_sendmsg(struct kiocb iocb, struct socket sock, struct msghdr m, size_t total_len) { struct tun_struct tun = container_of(sock, struct tun_struct, socket); return tun_get_user(tun, m->msg_iov, total_len, m->msg_flags & MSG_DONTWAIT); } static int tun_recvmsg(struct kiocb iocb, struct socket sock, struct msghdr m, size_t total_len, int flags) { struct tun_struct tun = container_of(sock, struct tun_struct, socket); int ret; if (flags & ~(MSG_DONTWAIT\|MSG_TRUNC)) return -EINVAL; ret = tun_do_read(tun, iocb, m->msg_iov, total_len, flags & MSG_DONTWAIT); if (ret > total_len) { m->msg_flags \|= MSG_TRUNC; ret = flags & MSG_TRUNC ? ret : total_len; } return ret; } / Ops structure to mimic raw sockets with tun / static const struct proto_ops tun_socket_ops = { .sendmsg = tun_sendmsg, .recvmsg = tun_recvmsg, }; static struct proto tun_proto = { .name = "tun", .owner = THIS_MODULE, .obj_size = sizeof(struct tun_sock), }; static int tun_flags(struct tun_struct tun) { int flags = 0; if (tun->flags & TUN_TUN_DEV) flags \|= IFF_TUN; else flags \|= IFF_TAP; if (tun->flags & TUN_NO_PI) flags \|= IFF_NO_PI; if (tun->flags & TUN_ONE_QUEUE) flags \|= IFF_ONE_QUEUE; if (tun->flags & TUN_VNET_HDR) flags \|= IFF_VNET_HDR; return flags; } static ssize_t tun_show_flags(struct device dev, struct device_attribute attr, char buf) { struct tun_struct tun = netdev_priv(to_net_dev(dev)); return sprintf(buf, "0x%x\n", tun_flags(tun)); } static ssize_t tun_show_owner(struct device dev, struct device_attribute attr, char buf) { struct tun_struct tun = netdev_priv(to_net_dev(dev)); return sprintf(buf, "%d\n", tun->owner); } static ssize_t tun_show_group(struct device dev, struct device_attribute attr, char buf) { struct tun_struct tun = netdev_priv(to_net_dev(dev)); return sprintf(buf, "%d\n", tun->group); } static DEVICE_ATTR(tun_flags, 0444, tun_show_flags, NULL); static DEVICE_ATTR(owner, 0444, tun_show_owner, NULL); static DEVICE_ATTR(group, 0444, tun_show_group, NULL); static int tun_set_iff(struct net net, struct file file, struct ifreq ifr) { struct sock sk; struct tun_struct tun; struct net_device dev; int err; dev = __dev_get_by_name(net, ifr->ifr_name); if (dev) { const struct cred cred = current_cred(); if (ifr->ifr_flags & IFF_TUN_EXCL) return -EBUSY; if ((ifr->ifr_flags & IFF_TUN) && dev->netdev_ops == &tun_netdev_ops) tun = netdev_priv(dev); else if ((ifr->ifr_flags & IFF_TAP) && dev->netdev_ops == &tap_netdev_ops) tun = netdev_priv(dev); else return -EINVAL; if (((tun->owner != -1 && cred->euid != tun->owner) \|\| (tun->group != -1 && !in_egroup_p(tun->group))) && !capable(CAP_NET_ADMIN)) return -EPERM; err = security_tun_dev_attach(tun->socket.sk); if (err < 0) return err; err = tun_attach(tun, file); if (err < 0) return err; } else { char name; unsigned long flags = 0; if (!capable(CAP_NET_ADMIN)) return -EPERM; err = security_tun_dev_create(); if (err < 0) return err; /* Set dev type / if (ifr->ifr_flags & IFF_TUN) { / TUN device / flags \|= TUN_TUN_DEV; name = "tun%d"; } else if (ifr->ifr_flags & IFF_TAP) { / TAP device / flags \|= TUN_TAP_DEV; name = "tap%d"; } else return -EINVAL; if (ifr->ifr_name) name = ifr->ifr_name; dev = alloc_netdev(sizeof(struct tun_struct), name, tun_setup); if (!dev) return -ENOMEM; dev_net_set(dev, net); dev->rtnl_link_ops = &tun_link_ops; tun = netdev_priv(dev); tun->dev = dev; tun->flags = flags; tun->txflt.count = 0; tun->vnet_hdr_sz = sizeof(struct virtio_net_hdr); err = -ENOMEM; sk = sk_alloc(net, AF_UNSPEC, GFP_KERNEL, &tun_proto); if (!sk) goto err_free_dev; tun->socket.wq = &tun->wq; init_waitqueue_head(&tun->wq.wait); tun->socket.ops = &tun_socket_ops; sock_init_data(&tun->socket, sk); sk->sk_write_space = tun_sock_write_space; sk->sk_sndbuf = INT_MAX; tun_sk(sk)->tun = tun; security_tun_dev_post_create(sk); tun_net_init(dev); dev->hw_features = NETIF_F_SG \| NETIF_F_FRAGLIST \| TUN_USER_FEATURES; dev->features = dev->hw_features; err = register_netdevice(tun->dev); if (err < 0) goto err_free_sk; if (device_create_file(&tun->dev->dev, &dev_attr_tun_flags) \|\| device_create_file(&tun->dev->dev, &dev_attr_owner) \|\| device_create_file(&tun->dev->dev, &dev_attr_group)) pr_err("Failed to create tun sysfs files\n"); sk->sk_destruct = tun_sock_destruct; err = tun_attach(tun, file); if (err < 0) goto failed; } tun_debug(KERN_INFO, tun, "tun_set_iff\n"); if (ifr->ifr_flags & IFF_NO_PI) tun->flags \|= TUN_NO_PI; else tun->flags &= ~TUN_NO_PI; if (ifr->ifr_flags & IFF_ONE_QUEUE) tun->flags \|= TUN_ONE_QUEUE; else tun->flags &= ~TUN_ONE_QUEUE; if (ifr->ifr_flags & IFF_VNET_HDR) tun->flags \|= TUN_VNET_HDR; else tun->flags &= ~TUN_VNET_HDR; /* Make sure persistent devices do not get stuck in * xoff state. / if (netif_running(tun->dev)) netif_wake_queue(tun->dev); strcpy(ifr->ifr_name, tun->dev->name); return 0; err_free_sk: sock_put(sk); err_free_dev: free_netdev(dev); failed: return err; } static int tun_get_iff(struct net net, struct tun_struct tun, struct ifreq ifr) { tun_debug(KERN_INFO, tun, "tun_get_iff\n"); strcpy(ifr->ifr_name, tun->dev->name); ifr->ifr_flags = tun_flags(tun); return 0; } /* This is like a cut-down ethtool ops, except done via tun fd so no * privs required. / static int set_offload(struct tun_struct tun, unsigned long arg) { u32 features = 0; if (arg & TUN_F_CSUM) { features \|= NETIF_F_HW_CSUM; arg &= ~TUN_F_CSUM; if (arg & (TUN_F_TSO4\|TUN_F_TSO6)) { if (arg & TUN_F_TSO_ECN) { features \|= NETIF_F_TSO_ECN; arg &= ~TUN_F_TSO_ECN; } if (arg & TUN_F_TSO4) features \|= NETIF_F_TSO; if (arg & TUN_F_TSO6) features \|= NETIF_F_TSO6; arg &= ~(TUN_F_TSO4\|TUN_F_TSO6); } if (arg & TUN_F_UFO) { features \|= NETIF_F_UFO; arg &= ~TUN_F_UFO; } } /* This gives the user a way to test for new features in future by * trying to set them. / if (arg) return -EINVAL; tun->set_features = features; netdev_update_features(tun->dev); return 0; } static long __tun_chr_ioctl(struct file file, unsigned int cmd, unsigned long arg, int ifreq_len) { struct tun_file tfile = file->private_data; struct tun_struct tun; void __user* argp = (void __user)arg; struct sock_fprog fprog; struct ifreq ifr; int sndbuf; int vnet_hdr_sz; int ret; if (cmd == TUNSETIFF \|\| _IOC_TYPE(cmd) == 0x89) if (copy_from_user(&ifr, argp, ifreq_len)) return -EFAULT; if (cmd == TUNGETFEATURES) { / Currently this just means: "what IFF flags are valid?". * This is needed because we never checked for invalid flags on * TUNSETIFF. / return put_user(IFF_TUN \| IFF_TAP \| IFF_NO_PI \| IFF_ONE_QUEUE \| IFF_VNET_HDR, (unsigned int __user)argp); } rtnl_lock(); tun = __tun_get(tfile); if (cmd == TUNSETIFF && !tun) { ifr.ifr_name[IFNAMSIZ-1] = '\0'; ret = tun_set_iff(tfile->net, file, &ifr); if (ret) goto unlock; if (copy_to_user(argp, &ifr, ifreq_len)) ret = -EFAULT; goto unlock; } ret = -EBADFD; if (!tun) goto unlock; tun_debug(KERN_INFO, tun, "tun_chr_ioctl cmd %d\n", cmd); ret = 0; switch (cmd) { case TUNGETIFF: ret = tun_get_iff(current->nsproxy->net_ns, tun, &ifr); if (ret) break; if (copy_to_user(argp, &ifr, ifreq_len)) ret = -EFAULT; break; case TUNSETNOCSUM: /* Disable/Enable checksum / / [unimplemented] / tun_debug(KERN_INFO, tun, "ignored: set checksum %s\n", arg ? "disabled" : "enabled"); break; case TUNSETPERSIST: / Disable/Enable persist mode / if (arg) tun->flags \|= TUN_PERSIST; else tun->flags &= ~TUN_PERSIST; tun_debug(KERN_INFO, tun, "persist %s\n", arg ? "enabled" : "disabled"); break; case TUNSETOWNER: / Set owner of the device / tun->owner = (uid_t) arg; tun_debug(KERN_INFO, tun, "owner set to %d\n", tun->owner); break; case TUNSETGROUP: / Set group of the device / tun->group= (gid_t) arg; tun_debug(KERN_INFO, tun, "group set to %d\n", tun->group); break; case TUNSETLINK: / Only allow setting the type when the interface is down / if (tun->dev->flags & IFF_UP) { tun_debug(KERN_INFO, tun, "Linktype set failed because interface is up\n"); ret = -EBUSY; } else { tun->dev->type = (int) arg; tun_debug(KERN_INFO, tun, "linktype set to %d\n", tun->dev->type); ret = 0; } break; #ifdef TUN_DEBUG case TUNSETDEBUG: tun->debug = arg; break; #endif case TUNSETOFFLOAD: ret = set_offload(tun, arg); break; case TUNSETTXFILTER: / Can be set only for TAPs / ret = -EINVAL; if ((tun->flags & TUN_TYPE_MASK) != TUN_TAP_DEV) break; ret = update_filter(&tun->txflt, (void __user )arg); break; case SIOCGIFHWADDR: /* Get hw address / memcpy(ifr.ifr_hwaddr.sa_data, tun->dev->dev_addr, ETH_ALEN); ifr.ifr_hwaddr.sa_family = tun->dev->type; if (copy_to_user(argp, &ifr, ifreq_len)) ret = -EFAULT; break; case SIOCSIFHWADDR: / Set hw address / tun_debug(KERN_DEBUG, tun, "set hw address: %pM\n", ifr.ifr_hwaddr.sa_data); ret = dev_set_mac_address(tun->dev, &ifr.ifr_hwaddr); break; case TUNGETSNDBUF: sndbuf = tun->socket.sk->sk_sndbuf; if (copy_to_user(argp, &sndbuf, sizeof(sndbuf))) ret = -EFAULT; break; case TUNSETSNDBUF: if (copy_from_user(&sndbuf, argp, sizeof(sndbuf))) { ret = -EFAULT; break; } tun->socket.sk->sk_sndbuf = sndbuf; break; case TUNGETVNETHDRSZ: vnet_hdr_sz = tun->vnet_hdr_sz; if (copy_to_user(argp, &vnet_hdr_sz, sizeof(vnet_hdr_sz))) ret = -EFAULT; break; case TUNSETVNETHDRSZ: if (copy_from_user(&vnet_hdr_sz, argp, sizeof(vnet_hdr_sz))) { ret = -EFAULT; break; } if (vnet_hdr_sz < (int)sizeof(struct virtio_net_hdr)) { ret = -EINVAL; break; } tun->vnet_hdr_sz = vnet_hdr_sz; break; case TUNATTACHFILTER: / Can be set only for TAPs / ret = -EINVAL; if ((tun->flags & TUN_TYPE_MASK) != TUN_TAP_DEV) break; ret = -EFAULT; if (copy_from_user(&fprog, argp, sizeof(fprog))) break; ret = sk_attach_filter(&fprog, tun->socket.sk); break; case TUNDETACHFILTER: / Can be set only for TAPs / ret = -EINVAL; if ((tun->flags & TUN_TYPE_MASK) != TUN_TAP_DEV) break; ret = sk_detach_filter(tun->socket.sk); break; default: ret = -EINVAL; break; } unlock: rtnl_unlock(); if (tun) tun_put(tun); return ret; } static long tun_chr_ioctl(struct file file, unsigned int cmd, unsigned long arg) { return __tun_chr_ioctl(file, cmd, arg, sizeof (struct ifreq)); } #ifdef CONFIG_COMPAT static long tun_chr_compat_ioctl(struct file file, unsigned int cmd, unsigned long arg) { switch (cmd) { case TUNSETIFF: case TUNGETIFF: case TUNSETTXFILTER: case TUNGETSNDBUF: case TUNSETSNDBUF: case SIOCGIFHWADDR: case SIOCSIFHWADDR: arg = (unsigned long)compat_ptr(arg); break; default: arg = (compat_ulong_t)arg; break; } / * compat_ifreq is shorter than ifreq, so we must not access beyond * the end of that structure. All fields that are used in this * driver are compatible though, we don't need to convert the * contents. / return __tun_chr_ioctl(file, cmd, arg, sizeof(struct compat_ifreq)); } #endif / CONFIG_COMPAT / static int tun_chr_fasync(int fd, struct file file, int on) { struct tun_struct tun = tun_get(file); int ret; if (!tun) return -EBADFD; tun_debug(KERN_INFO, tun, "tun_chr_fasync %d\n", on); if ((ret = fasync_helper(fd, file, on, &tun->fasync)) < 0) goto out; if (on) { ret = __f_setown(file, task_pid(current), PIDTYPE_PID, 0); if (ret) goto out; tun->flags \|= TUN_FASYNC; } else tun->flags &= ~TUN_FASYNC; ret = 0; out: tun_put(tun); return ret; } static int tun_chr_open(struct inode inode, struct file * file) { struct tun_file tfile; DBG1(KERN_INFO, "tunX: tun_chr_open\n"); tfile = kmalloc(sizeof(tfile), GFP_KERNEL); if (!tfile) return -ENOMEM; atomic_set(&tfile->count, 0); tfile->tun = NULL; tfile->net = get_net(current->nsproxy->net_ns); file->private_data = tfile; return 0; } static int tun_chr_close(struct inode inode, struct file file) { struct tun_file tfile = file->private_data; struct tun_struct tun; tun = __tun_get(tfile); if (tun) { struct net_device dev = tun->dev; tun_debug(KERN_INFO, tun, "tun_chr_close\n"); __tun_detach(tun); / If desirable, unregister the netdevice. / if (!(tun->flags & TUN_PERSIST)) { rtnl_lock(); if (dev->reg_state == NETREG_REGISTERED) unregister_netdevice(dev); rtnl_unlock(); } } tun = tfile->tun; if (tun) sock_put(tun->socket.sk); put_net(tfile->net); kfree(tfile); return 0; } static const struct file_operations tun_fops = { .owner = THIS_MODULE, .llseek = no_llseek, .read = do_sync_read, .aio_read = tun_chr_aio_read, .write = do_sync_write, .aio_write = tun_chr_aio_write, .poll = tun_chr_poll, .unlocked_ioctl = tun_chr_ioctl, #ifdef CONFIG_COMPAT .compat_ioctl = tun_chr_compat_ioctl, #endif .open = tun_chr_open, .release = tun_chr_close, .fasync = tun_chr_fasync }; static struct miscdevice tun_miscdev = { .minor = TUN_MINOR, .name = "tun", .nodename = "net/tun", .fops = &tun_fops, }; / ethtool interface / static int tun_get_settings(struct net_device dev, struct ethtool_cmd cmd) { cmd->supported = 0; cmd->advertising = 0; ethtool_cmd_speed_set(cmd, SPEED_10); cmd->duplex = DUPLEX_FULL; cmd->port = PORT_TP; cmd->phy_address = 0; cmd->transceiver = XCVR_INTERNAL; cmd->autoneg = AUTONEG_DISABLE; cmd->maxtxpkt = 0; cmd->maxrxpkt = 0; return 0; } static void tun_get_drvinfo(struct net_device dev, struct ethtool_drvinfo info) { struct tun_struct tun = netdev_priv(dev); strcpy(info->driver, DRV_NAME); strcpy(info->version, DRV_VERSION); strcpy(info->fw_version, "N/A"); switch (tun->flags & TUN_TYPE_MASK) { case TUN_TUN_DEV: strcpy(info->bus_info, "tun"); break; case TUN_TAP_DEV: strcpy(info->bus_info, "tap"); break; } } static u32 tun_get_msglevel(struct net_device dev) { #ifdef TUN_DEBUG struct tun_struct tun = netdev_priv(dev); return tun->debug; #else return -EOPNOTSUPP; #endif } static void tun_set_msglevel(struct net_device dev, u32 value) { #ifdef TUN_DEBUG struct tun_struct tun = netdev_priv(dev); tun->debug = value; #endif } static const struct ethtool_ops tun_ethtool_ops = { .get_settings = tun_get_settings, .get_drvinfo = tun_get_drvinfo, .get_msglevel = tun_get_msglevel, .set_msglevel = tun_set_msglevel, .get_link = ethtool_op_get_link, }; static int __init tun_init(void) { int ret = 0; pr_info("%s, %s\n", DRV_DESCRIPTION, DRV_VERSION); pr_info("%s\n", DRV_COPYRIGHT); ret = rtnl_link_register(&tun_link_ops); if (ret) { pr_err("Can't register link_ops\n"); goto err_linkops; } ret = misc_register(&tun_miscdev); if (ret) { pr_err("Can't register misc device %d\n", TUN_MINOR); goto err_misc; } return 0; err_misc: rtnl_link_unregister(&tun_link_ops); err_linkops: return ret; } static void tun_cleanup(void) { misc_deregister(&tun_miscdev); rtnl_link_unregister(&tun_link_ops); } /* Get an underlying socket object from tun file. Returns error unless file is * attached to a device. The returned object works like a packet socket, it * can be used for sock_sendmsg/sock_recvmsg. The caller is responsible for * holding a reference to the file for as long as the socket is in use. / struct socket tun_get_socket(struct file file) { struct tun_struct tun; if (file->f_op != &tun_fops) return ERR_PTR(-EINVAL); tun = tun_get(file); if (!tun) return ERR_PTR(-EBADFD); tun_put(tun); return &tun->socket; } EXPORT_SYMBOL_GPL(tun_get_socket); module_init(tun_init); module_exit(tun_cleanup); MODULE_DESCRIPTION(DRV_DESCRIPTION); MODULE_AUTHOR(DRV_COPYRIGHT); MODULE_LICENSE("GPL"); MODULE_ALIAS_MISCDEV(TUN_MINOR); MODULE_ALIAS("devname:net/tun");	./CrossVul/dataset_final_sorted/CWE-264/c/bad_3524_4
crossvul-cpp_data_good_5573_0	/* * linux/kernel/signal.c * * Copyright (C) 1991, 1992 Linus Torvalds * * 1997-11-02 Modified for POSIX.1b signals by Richard Henderson * * 2003-06-02 Jim Houston - Concurrent Computer Corp. * Changes to use preallocated sigqueue structures * to allow signals to be sent reliably. / #include <linux/slab.h> #include <linux/export.h> #include <linux/init.h> #include <linux/sched.h> #include <linux/fs.h> #include <linux/tty.h> #include <linux/binfmts.h> #include <linux/coredump.h> #include <linux/security.h> #include <linux/syscalls.h> #include <linux/ptrace.h> #include <linux/signal.h> #include <linux/signalfd.h> #include <linux/ratelimit.h> #include <linux/tracehook.h> #include <linux/capability.h> #include <linux/freezer.h> #include <linux/pid_namespace.h> #include <linux/nsproxy.h> #include <linux/user_namespace.h> #include <linux/uprobes.h> #include <linux/compat.h> #define CREATE_TRACE_POINTS #include <trace/events/signal.h> #include <asm/param.h> #include <asm/uaccess.h> #include <asm/unistd.h> #include <asm/siginfo.h> #include <asm/cacheflush.h> #include "audit.h" / audit_signal_info() / / * SLAB caches for signal bits. / static struct kmem_cache sigqueue_cachep; int print_fatal_signals __read_mostly; static void __user sig_handler(struct task_struct t, int sig) { return t->sighand->action[sig - 1].sa.sa_handler; } static int sig_handler_ignored(void __user handler, int sig) { / Is it explicitly or implicitly ignored? / return handler == SIG_IGN \|\| (handler == SIG_DFL && sig_kernel_ignore(sig)); } static int sig_task_ignored(struct task_struct t, int sig, bool force) { void __user handler; handler = sig_handler(t, sig); if (unlikely(t->signal->flags & SIGNAL_UNKILLABLE) && handler == SIG_DFL && !force) return 1; return sig_handler_ignored(handler, sig); } static int sig_ignored(struct task_struct t, int sig, bool force) { /* * Blocked signals are never ignored, since the * signal handler may change by the time it is * unblocked. / if (sigismember(&t->blocked, sig) \|\| sigismember(&t->real_blocked, sig)) return 0; if (!sig_task_ignored(t, sig, force)) return 0; / * Tracers may want to know about even ignored signals. / return !t->ptrace; } / * Re-calculate pending state from the set of locally pending * signals, globally pending signals, and blocked signals. / static inline int has_pending_signals(sigset_t signal, sigset_t blocked) { unsigned long ready; long i; switch (_NSIG_WORDS) { default: for (i = _NSIG_WORDS, ready = 0; --i >= 0 ;) ready \|= signal->sig[i] &~ blocked->sig[i]; break; case 4: ready = signal->sig[3] &~ blocked->sig[3]; ready \|= signal->sig[2] &~ blocked->sig[2]; ready \|= signal->sig[1] &~ blocked->sig[1]; ready \|= signal->sig[0] &~ blocked->sig[0]; break; case 2: ready = signal->sig[1] &~ blocked->sig[1]; ready \|= signal->sig[0] &~ blocked->sig[0]; break; case 1: ready = signal->sig[0] &~ blocked->sig[0]; } return ready != 0; } #define PENDING(p,b) has_pending_signals(&(p)->signal, (b)) static int recalc_sigpending_tsk(struct task_struct t) { if ((t->jobctl & JOBCTL_PENDING_MASK) \|\| PENDING(&t->pending, &t->blocked) \|\| PENDING(&t->signal->shared_pending, &t->blocked)) { set_tsk_thread_flag(t, TIF_SIGPENDING); return 1; } /* * We must never clear the flag in another thread, or in current * when it's possible the current syscall is returning -ERESTART. So we don't clear it here, and only callers who know they should do. / return 0; } / * After recalculating TIF_SIGPENDING, we need to make sure the task wakes up. * This is superfluous when called on current, the wakeup is a harmless no-op. / void recalc_sigpending_and_wake(struct task_struct t) { if (recalc_sigpending_tsk(t)) signal_wake_up(t, 0); } void recalc_sigpending(void) { if (!recalc_sigpending_tsk(current) && !freezing(current)) clear_thread_flag(TIF_SIGPENDING); } /* Given the mask, find the first available signal that should be serviced. / #define SYNCHRONOUS_MASK \ (sigmask(SIGSEGV) \| sigmask(SIGBUS) \| sigmask(SIGILL) \| \ sigmask(SIGTRAP) \| sigmask(SIGFPE) \| sigmask(SIGSYS)) int next_signal(struct sigpending pending, sigset_t mask) { unsigned long i, s, m, x; int sig = 0; s = pending->signal.sig; m = mask->sig; / * Handle the first word specially: it contains the * synchronous signals that need to be dequeued first. / x = s &~ m; if (x) { if (x & SYNCHRONOUS_MASK) x &= SYNCHRONOUS_MASK; sig = ffz(~x) + 1; return sig; } switch (_NSIG_WORDS) { default: for (i = 1; i < _NSIG_WORDS; ++i) { x = ++s &~ ++m; if (!x) continue; sig = ffz(~x) + i_NSIG_BPW + 1; break; } break; case 2: x = s[1] &~ m[1]; if (!x) break; sig = ffz(~x) + _NSIG_BPW + 1; break; case 1: /* Nothing to do / break; } return sig; } static inline void print_dropped_signal(int sig) { static DEFINE_RATELIMIT_STATE(ratelimit_state, 5 HZ, 10); if (!print_fatal_signals) return; if (!__ratelimit(&ratelimit_state)) return; printk(KERN_INFO "%s/%d: reached RLIMIT_SIGPENDING, dropped signal %d\n", current->comm, current->pid, sig); } /** * task_set_jobctl_pending - set jobctl pending bits * @task: target task * @mask: pending bits to set * * Clear @mask from @task->jobctl. @mask must be subset of * %JOBCTL_PENDING_MASK \| %JOBCTL_STOP_CONSUME \| %JOBCTL_STOP_SIGMASK \| * %JOBCTL_TRAPPING. If stop signo is being set, the existing signo is * cleared. If @task is already being killed or exiting, this function * becomes noop. * * CONTEXT: * Must be called with @task->sighand->siglock held. * * RETURNS: * %true if @mask is set, %false if made noop because @task was dying. / bool task_set_jobctl_pending(struct task_struct task, unsigned int mask) { BUG_ON(mask & ~(JOBCTL_PENDING_MASK \| JOBCTL_STOP_CONSUME \| JOBCTL_STOP_SIGMASK \| JOBCTL_TRAPPING)); BUG_ON((mask & JOBCTL_TRAPPING) && !(mask & JOBCTL_PENDING_MASK)); if (unlikely(fatal_signal_pending(task) \|\| (task->flags & PF_EXITING))) return false; if (mask & JOBCTL_STOP_SIGMASK) task->jobctl &= ~JOBCTL_STOP_SIGMASK; task->jobctl \|= mask; return true; } /** * task_clear_jobctl_trapping - clear jobctl trapping bit * @task: target task * * If JOBCTL_TRAPPING is set, a ptracer is waiting for us to enter TRACED. * Clear it and wake up the ptracer. Note that we don't need any further * locking. @task->siglock guarantees that @task->parent points to the * ptracer. * * CONTEXT: * Must be called with @task->sighand->siglock held. / void task_clear_jobctl_trapping(struct task_struct task) { if (unlikely(task->jobctl & JOBCTL_TRAPPING)) { task->jobctl &= ~JOBCTL_TRAPPING; wake_up_bit(&task->jobctl, JOBCTL_TRAPPING_BIT); } } /** * task_clear_jobctl_pending - clear jobctl pending bits * @task: target task * @mask: pending bits to clear * * Clear @mask from @task->jobctl. @mask must be subset of * %JOBCTL_PENDING_MASK. If %JOBCTL_STOP_PENDING is being cleared, other * STOP bits are cleared together. * * If clearing of @mask leaves no stop or trap pending, this function calls * task_clear_jobctl_trapping(). * * CONTEXT: * Must be called with @task->sighand->siglock held. / void task_clear_jobctl_pending(struct task_struct task, unsigned int mask) { BUG_ON(mask & ~JOBCTL_PENDING_MASK); if (mask & JOBCTL_STOP_PENDING) mask \|= JOBCTL_STOP_CONSUME \| JOBCTL_STOP_DEQUEUED; task->jobctl &= ~mask; if (!(task->jobctl & JOBCTL_PENDING_MASK)) task_clear_jobctl_trapping(task); } /** * task_participate_group_stop - participate in a group stop * @task: task participating in a group stop * * @task has %JOBCTL_STOP_PENDING set and is participating in a group stop. * Group stop states are cleared and the group stop count is consumed if * %JOBCTL_STOP_CONSUME was set. If the consumption completes the group * stop, the appropriate %SIGNAL_* flags are set. * * CONTEXT: * Must be called with @task->sighand->siglock held. * * RETURNS: * %true if group stop completion should be notified to the parent, %false * otherwise. / static bool task_participate_group_stop(struct task_struct task) { struct signal_struct sig = task->signal; bool consume = task->jobctl & JOBCTL_STOP_CONSUME; WARN_ON_ONCE(!(task->jobctl & JOBCTL_STOP_PENDING)); task_clear_jobctl_pending(task, JOBCTL_STOP_PENDING); if (!consume) return false; if (!WARN_ON_ONCE(sig->group_stop_count == 0)) sig->group_stop_count--; / * Tell the caller to notify completion iff we are entering into a * fresh group stop. Read comment in do_signal_stop() for details. / if (!sig->group_stop_count && !(sig->flags & SIGNAL_STOP_STOPPED)) { sig->flags = SIGNAL_STOP_STOPPED; return true; } return false; } / * allocate a new signal queue record * - this may be called without locks if and only if t == current, otherwise an * appropriate lock must be held to stop the target task from exiting / static struct sigqueue __sigqueue_alloc(int sig, struct task_struct t, gfp_t flags, int override_rlimit) { struct sigqueue q = NULL; struct user_struct user; / * Protect access to @t credentials. This can go away when all * callers hold rcu read lock. / rcu_read_lock(); user = get_uid(__task_cred(t)->user); atomic_inc(&user->sigpending); rcu_read_unlock(); if (override_rlimit \|\| atomic_read(&user->sigpending) <= task_rlimit(t, RLIMIT_SIGPENDING)) { q = kmem_cache_alloc(sigqueue_cachep, flags); } else { print_dropped_signal(sig); } if (unlikely(q == NULL)) { atomic_dec(&user->sigpending); free_uid(user); } else { INIT_LIST_HEAD(&q->list); q->flags = 0; q->user = user; } return q; } static void __sigqueue_free(struct sigqueue q) { if (q->flags & SIGQUEUE_PREALLOC) return; atomic_dec(&q->user->sigpending); free_uid(q->user); kmem_cache_free(sigqueue_cachep, q); } void flush_sigqueue(struct sigpending queue) { struct sigqueue q; sigemptyset(&queue->signal); while (!list_empty(&queue->list)) { q = list_entry(queue->list.next, struct sigqueue , list); list_del_init(&q->list); __sigqueue_free(q); } } /* * Flush all pending signals for a task. / void __flush_signals(struct task_struct t) { clear_tsk_thread_flag(t, TIF_SIGPENDING); flush_sigqueue(&t->pending); flush_sigqueue(&t->signal->shared_pending); } void flush_signals(struct task_struct t) { unsigned long flags; spin_lock_irqsave(&t->sighand->siglock, flags); __flush_signals(t); spin_unlock_irqrestore(&t->sighand->siglock, flags); } static void __flush_itimer_signals(struct sigpending pending) { sigset_t signal, retain; struct sigqueue q, n; signal = pending->signal; sigemptyset(&retain); list_for_each_entry_safe(q, n, &pending->list, list) { int sig = q->info.si_signo; if (likely(q->info.si_code != SI_TIMER)) { sigaddset(&retain, sig); } else { sigdelset(&signal, sig); list_del_init(&q->list); __sigqueue_free(q); } } sigorsets(&pending->signal, &signal, &retain); } void flush_itimer_signals(void) { struct task_struct tsk = current; unsigned long flags; spin_lock_irqsave(&tsk->sighand->siglock, flags); __flush_itimer_signals(&tsk->pending); __flush_itimer_signals(&tsk->signal->shared_pending); spin_unlock_irqrestore(&tsk->sighand->siglock, flags); } void ignore_signals(struct task_struct t) { int i; for (i = 0; i < _NSIG; ++i) t->sighand->action[i].sa.sa_handler = SIG_IGN; flush_signals(t); } /* * Flush all handlers for a task. / void flush_signal_handlers(struct task_struct t, int force_default) { int i; struct k_sigaction ka = &t->sighand->action[0]; for (i = _NSIG ; i != 0 ; i--) { if (force_default \|\| ka->sa.sa_handler != SIG_IGN) ka->sa.sa_handler = SIG_DFL; ka->sa.sa_flags = 0; #ifdef SA_RESTORER ka->sa.sa_restorer = NULL; #endif sigemptyset(&ka->sa.sa_mask); ka++; } } int unhandled_signal(struct task_struct tsk, int sig) { void __user handler = tsk->sighand->action[sig-1].sa.sa_handler; if (is_global_init(tsk)) return 1; if (handler != SIG_IGN && handler != SIG_DFL) return 0; / if ptraced, let the tracer determine / return !tsk->ptrace; } / * Notify the system that a driver wants to block all signals for this * process, and wants to be notified if any signals at all were to be * sent/acted upon. If the notifier routine returns non-zero, then the * signal will be acted upon after all. If the notifier routine returns 0, * then then signal will be blocked. Only one block per process is * allowed. priv is a pointer to private data that the notifier routine * can use to determine if the signal should be blocked or not. / void block_all_signals(int (notifier)(void priv), void priv, sigset_t mask) { unsigned long flags; spin_lock_irqsave(&current->sighand->siglock, flags); current->notifier_mask = mask; current->notifier_data = priv; current->notifier = notifier; spin_unlock_irqrestore(&current->sighand->siglock, flags); } / Notify the system that blocking has ended. / void unblock_all_signals(void) { unsigned long flags; spin_lock_irqsave(&current->sighand->siglock, flags); current->notifier = NULL; current->notifier_data = NULL; recalc_sigpending(); spin_unlock_irqrestore(&current->sighand->siglock, flags); } static void collect_signal(int sig, struct sigpending list, siginfo_t info) { struct sigqueue q, first = NULL; / * Collect the siginfo appropriate to this signal. Check if * there is another siginfo for the same signal. / list_for_each_entry(q, &list->list, list) { if (q->info.si_signo == sig) { if (first) goto still_pending; first = q; } } sigdelset(&list->signal, sig); if (first) { still_pending: list_del_init(&first->list); copy_siginfo(info, &first->info); __sigqueue_free(first); } else { / * Ok, it wasn't in the queue. This must be * a fast-pathed signal or we must have been * out of queue space. So zero out the info. / info->si_signo = sig; info->si_errno = 0; info->si_code = SI_USER; info->si_pid = 0; info->si_uid = 0; } } static int __dequeue_signal(struct sigpending pending, sigset_t mask, siginfo_t info) { int sig = next_signal(pending, mask); if (sig) { if (current->notifier) { if (sigismember(current->notifier_mask, sig)) { if (!(current->notifier)(current->notifier_data)) { clear_thread_flag(TIF_SIGPENDING); return 0; } } } collect_signal(sig, pending, info); } return sig; } /* * Dequeue a signal and return the element to the caller, which is * expected to free it. * * All callers have to hold the siglock. / int dequeue_signal(struct task_struct tsk, sigset_t mask, siginfo_t info) { int signr; /* We only dequeue private signals from ourselves, we don't let * signalfd steal them / signr = __dequeue_signal(&tsk->pending, mask, info); if (!signr) { signr = __dequeue_signal(&tsk->signal->shared_pending, mask, info); / * itimer signal ? * * itimers are process shared and we restart periodic * itimers in the signal delivery path to prevent DoS * attacks in the high resolution timer case. This is * compliant with the old way of self-restarting * itimers, as the SIGALRM is a legacy signal and only * queued once. Changing the restart behaviour to * restart the timer in the signal dequeue path is * reducing the timer noise on heavy loaded !highres * systems too. / if (unlikely(signr == SIGALRM)) { struct hrtimer tmr = &tsk->signal->real_timer; if (!hrtimer_is_queued(tmr) && tsk->signal->it_real_incr.tv64 != 0) { hrtimer_forward(tmr, tmr->base->get_time(), tsk->signal->it_real_incr); hrtimer_restart(tmr); } } } recalc_sigpending(); if (!signr) return 0; if (unlikely(sig_kernel_stop(signr))) { /* * Set a marker that we have dequeued a stop signal. Our * caller might release the siglock and then the pending * stop signal it is about to process is no longer in the * pending bitmasks, but must still be cleared by a SIGCONT * (and overruled by a SIGKILL). So those cases clear this * shared flag after we've set it. Note that this flag may * remain set after the signal we return is ignored or * handled. That doesn't matter because its only purpose * is to alert stop-signal processing code when another * processor has come along and cleared the flag. / current->jobctl \|= JOBCTL_STOP_DEQUEUED; } if ((info->si_code & __SI_MASK) == __SI_TIMER && info->si_sys_private) { / * Release the siglock to ensure proper locking order * of timer locks outside of siglocks. Note, we leave * irqs disabled here, since the posix-timers code is * about to disable them again anyway. / spin_unlock(&tsk->sighand->siglock); do_schedule_next_timer(info); spin_lock(&tsk->sighand->siglock); } return signr; } / * Tell a process that it has a new active signal.. * * NOTE! we rely on the previous spin_lock to * lock interrupts for us! We can only be called with * "siglock" held, and the local interrupt must * have been disabled when that got acquired! * * No need to set need_resched since signal event passing * goes through ->blocked / void signal_wake_up_state(struct task_struct t, unsigned int state) { set_tsk_thread_flag(t, TIF_SIGPENDING); /* * TASK_WAKEKILL also means wake it up in the stopped/traced/killable * case. We don't check t->state here because there is a race with it * executing another processor and just now entering stopped state. * By using wake_up_state, we ensure the process will wake up and * handle its death signal. / if (!wake_up_state(t, state \| TASK_INTERRUPTIBLE)) kick_process(t); } / * Remove signals in mask from the pending set and queue. * Returns 1 if any signals were found. * * All callers must be holding the siglock. * * This version takes a sigset mask and looks at all signals, * not just those in the first mask word. / static int rm_from_queue_full(sigset_t mask, struct sigpending s) { struct sigqueue q, n; sigset_t m; sigandsets(&m, mask, &s->signal); if (sigisemptyset(&m)) return 0; sigandnsets(&s->signal, &s->signal, mask); list_for_each_entry_safe(q, n, &s->list, list) { if (sigismember(mask, q->info.si_signo)) { list_del_init(&q->list); __sigqueue_free(q); } } return 1; } / * Remove signals in mask from the pending set and queue. * Returns 1 if any signals were found. * * All callers must be holding the siglock. / static int rm_from_queue(unsigned long mask, struct sigpending s) { struct sigqueue q, n; if (!sigtestsetmask(&s->signal, mask)) return 0; sigdelsetmask(&s->signal, mask); list_for_each_entry_safe(q, n, &s->list, list) { if (q->info.si_signo < SIGRTMIN && (mask & sigmask(q->info.si_signo))) { list_del_init(&q->list); __sigqueue_free(q); } } return 1; } static inline int is_si_special(const struct siginfo info) { return info <= SEND_SIG_FORCED; } static inline bool si_fromuser(const struct siginfo info) { return info == SEND_SIG_NOINFO \|\| (!is_si_special(info) && SI_FROMUSER(info)); } /* * called with RCU read lock from check_kill_permission() / static int kill_ok_by_cred(struct task_struct t) { const struct cred cred = current_cred(); const struct cred tcred = __task_cred(t); if (uid_eq(cred->euid, tcred->suid) \|\| uid_eq(cred->euid, tcred->uid) \|\| uid_eq(cred->uid, tcred->suid) \|\| uid_eq(cred->uid, tcred->uid)) return 1; if (ns_capable(tcred->user_ns, CAP_KILL)) return 1; return 0; } /* * Bad permissions for sending the signal * - the caller must hold the RCU read lock / static int check_kill_permission(int sig, struct siginfo info, struct task_struct t) { struct pid sid; int error; if (!valid_signal(sig)) return -EINVAL; if (!si_fromuser(info)) return 0; error = audit_signal_info(sig, t); /* Let audit system see the signal / if (error) return error; if (!same_thread_group(current, t) && !kill_ok_by_cred(t)) { switch (sig) { case SIGCONT: sid = task_session(t); / * We don't return the error if sid == NULL. The * task was unhashed, the caller must notice this. / if (!sid \|\| sid == task_session(current)) break; default: return -EPERM; } } return security_task_kill(t, info, sig, 0); } /* * ptrace_trap_notify - schedule trap to notify ptracer * @t: tracee wanting to notify tracer * * This function schedules sticky ptrace trap which is cleared on the next * TRAP_STOP to notify ptracer of an event. @t must have been seized by * ptracer. * * If @t is running, STOP trap will be taken. If trapped for STOP and * ptracer is listening for events, tracee is woken up so that it can * re-trap for the new event. If trapped otherwise, STOP trap will be * eventually taken without returning to userland after the existing traps * are finished by PTRACE_CONT. * * CONTEXT: * Must be called with @task->sighand->siglock held. / static void ptrace_trap_notify(struct task_struct t) { WARN_ON_ONCE(!(t->ptrace & PT_SEIZED)); assert_spin_locked(&t->sighand->siglock); task_set_jobctl_pending(t, JOBCTL_TRAP_NOTIFY); ptrace_signal_wake_up(t, t->jobctl & JOBCTL_LISTENING); } /* * Handle magic process-wide effects of stop/continue signals. Unlike * the signal actions, these happen immediately at signal-generation * time regardless of blocking, ignoring, or handling. This does the * actual continuing for SIGCONT, but not the actual stopping for stop * signals. The process stop is done as a signal action for SIG_DFL. * * Returns true if the signal should be actually delivered, otherwise * it should be dropped. / static int prepare_signal(int sig, struct task_struct p, bool force) { struct signal_struct signal = p->signal; struct task_struct t; if (unlikely(signal->flags & SIGNAL_GROUP_EXIT)) { /* * The process is in the middle of dying, nothing to do. / } else if (sig_kernel_stop(sig)) { / * This is a stop signal. Remove SIGCONT from all queues. / rm_from_queue(sigmask(SIGCONT), &signal->shared_pending); t = p; do { rm_from_queue(sigmask(SIGCONT), &t->pending); } while_each_thread(p, t); } else if (sig == SIGCONT) { unsigned int why; / * Remove all stop signals from all queues, wake all threads. / rm_from_queue(SIG_KERNEL_STOP_MASK, &signal->shared_pending); t = p; do { task_clear_jobctl_pending(t, JOBCTL_STOP_PENDING); rm_from_queue(SIG_KERNEL_STOP_MASK, &t->pending); if (likely(!(t->ptrace & PT_SEIZED))) wake_up_state(t, __TASK_STOPPED); else ptrace_trap_notify(t); } while_each_thread(p, t); / * Notify the parent with CLD_CONTINUED if we were stopped. * * If we were in the middle of a group stop, we pretend it * was already finished, and then continued. Since SIGCHLD * doesn't queue we report only CLD_STOPPED, as if the next * CLD_CONTINUED was dropped. / why = 0; if (signal->flags & SIGNAL_STOP_STOPPED) why \|= SIGNAL_CLD_CONTINUED; else if (signal->group_stop_count) why \|= SIGNAL_CLD_STOPPED; if (why) { / * The first thread which returns from do_signal_stop() * will take ->siglock, notice SIGNAL_CLD_MASK, and * notify its parent. See get_signal_to_deliver(). / signal->flags = why \| SIGNAL_STOP_CONTINUED; signal->group_stop_count = 0; signal->group_exit_code = 0; } } return !sig_ignored(p, sig, force); } / * Test if P wants to take SIG. After we've checked all threads with this, * it's equivalent to finding no threads not blocking SIG. Any threads not * blocking SIG were ruled out because they are not running and already * have pending signals. Such threads will dequeue from the shared queue * as soon as they're available, so putting the signal on the shared queue * will be equivalent to sending it to one such thread. / static inline int wants_signal(int sig, struct task_struct p) { if (sigismember(&p->blocked, sig)) return 0; if (p->flags & PF_EXITING) return 0; if (sig == SIGKILL) return 1; if (task_is_stopped_or_traced(p)) return 0; return task_curr(p) \|\| !signal_pending(p); } static void complete_signal(int sig, struct task_struct p, int group) { struct signal_struct signal = p->signal; struct task_struct t; / * Now find a thread we can wake up to take the signal off the queue. * * If the main thread wants the signal, it gets first crack. * Probably the least surprising to the average bear. / if (wants_signal(sig, p)) t = p; else if (!group \|\| thread_group_empty(p)) / * There is just one thread and it does not need to be woken. * It will dequeue unblocked signals before it runs again. / return; else { / * Otherwise try to find a suitable thread. / t = signal->curr_target; while (!wants_signal(sig, t)) { t = next_thread(t); if (t == signal->curr_target) / * No thread needs to be woken. * Any eligible threads will see * the signal in the queue soon. / return; } signal->curr_target = t; } / * Found a killable thread. If the signal will be fatal, * then start taking the whole group down immediately. / if (sig_fatal(p, sig) && !(signal->flags & (SIGNAL_UNKILLABLE \| SIGNAL_GROUP_EXIT)) && !sigismember(&t->real_blocked, sig) && (sig == SIGKILL \|\| !t->ptrace)) { / * This signal will be fatal to the whole group. / if (!sig_kernel_coredump(sig)) { / * Start a group exit and wake everybody up. * This way we don't have other threads * running and doing things after a slower * thread has the fatal signal pending. / signal->flags = SIGNAL_GROUP_EXIT; signal->group_exit_code = sig; signal->group_stop_count = 0; t = p; do { task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK); sigaddset(&t->pending.signal, SIGKILL); signal_wake_up(t, 1); } while_each_thread(p, t); return; } } / * The signal is already in the shared-pending queue. * Tell the chosen thread to wake up and dequeue it. / signal_wake_up(t, sig == SIGKILL); return; } static inline int legacy_queue(struct sigpending signals, int sig) { return (sig < SIGRTMIN) && sigismember(&signals->signal, sig); } #ifdef CONFIG_USER_NS static inline void userns_fixup_signal_uid(struct siginfo info, struct task_struct t) { if (current_user_ns() == task_cred_xxx(t, user_ns)) return; if (SI_FROMKERNEL(info)) return; rcu_read_lock(); info->si_uid = from_kuid_munged(task_cred_xxx(t, user_ns), make_kuid(current_user_ns(), info->si_uid)); rcu_read_unlock(); } #else static inline void userns_fixup_signal_uid(struct siginfo info, struct task_struct t) { return; } #endif static int __send_signal(int sig, struct siginfo info, struct task_struct t, int group, int from_ancestor_ns) { struct sigpending pending; struct sigqueue q; int override_rlimit; int ret = 0, result; assert_spin_locked(&t->sighand->siglock); result = TRACE_SIGNAL_IGNORED; if (!prepare_signal(sig, t, from_ancestor_ns \|\| (info == SEND_SIG_FORCED))) goto ret; pending = group ? &t->signal->shared_pending : &t->pending; /* * Short-circuit ignored signals and support queuing * exactly one non-rt signal, so that we can get more * detailed information about the cause of the signal. / result = TRACE_SIGNAL_ALREADY_PENDING; if (legacy_queue(pending, sig)) goto ret; result = TRACE_SIGNAL_DELIVERED; / * fast-pathed signals for kernel-internal things like SIGSTOP * or SIGKILL. / if (info == SEND_SIG_FORCED) goto out_set; / * Real-time signals must be queued if sent by sigqueue, or * some other real-time mechanism. It is implementation * defined whether kill() does so. We attempt to do so, on * the principle of least surprise, but since kill is not * allowed to fail with EAGAIN when low on memory we just * make sure at least one signal gets delivered and don't * pass on the info struct. / if (sig < SIGRTMIN) override_rlimit = (is_si_special(info) \|\| info->si_code >= 0); else override_rlimit = 0; q = __sigqueue_alloc(sig, t, GFP_ATOMIC \| __GFP_NOTRACK_FALSE_POSITIVE, override_rlimit); if (q) { list_add_tail(&q->list, &pending->list); switch ((unsigned long) info) { case (unsigned long) SEND_SIG_NOINFO: q->info.si_signo = sig; q->info.si_errno = 0; q->info.si_code = SI_USER; q->info.si_pid = task_tgid_nr_ns(current, task_active_pid_ns(t)); q->info.si_uid = from_kuid_munged(current_user_ns(), current_uid()); break; case (unsigned long) SEND_SIG_PRIV: q->info.si_signo = sig; q->info.si_errno = 0; q->info.si_code = SI_KERNEL; q->info.si_pid = 0; q->info.si_uid = 0; break; default: copy_siginfo(&q->info, info); if (from_ancestor_ns) q->info.si_pid = 0; break; } userns_fixup_signal_uid(&q->info, t); } else if (!is_si_special(info)) { if (sig >= SIGRTMIN && info->si_code != SI_USER) { / * Queue overflow, abort. We may abort if the * signal was rt and sent by user using something * other than kill(). / result = TRACE_SIGNAL_OVERFLOW_FAIL; ret = -EAGAIN; goto ret; } else { / * This is a silent loss of information. We still * send the signal, but the info bits are lost. / result = TRACE_SIGNAL_LOSE_INFO; } } out_set: signalfd_notify(t, sig); sigaddset(&pending->signal, sig); complete_signal(sig, t, group); ret: trace_signal_generate(sig, info, t, group, result); return ret; } static int send_signal(int sig, struct siginfo info, struct task_struct t, int group) { int from_ancestor_ns = 0; #ifdef CONFIG_PID_NS from_ancestor_ns = si_fromuser(info) && !task_pid_nr_ns(current, task_active_pid_ns(t)); #endif return __send_signal(sig, info, t, group, from_ancestor_ns); } static void print_fatal_signal(int signr) { struct pt_regs regs = signal_pt_regs(); printk(KERN_INFO "%s/%d: potentially unexpected fatal signal %d.\n", current->comm, task_pid_nr(current), signr); #if defined(__i386__) && !defined(__arch_um__) printk(KERN_INFO "code at %08lx: ", regs->ip); { int i; for (i = 0; i < 16; i++) { unsigned char insn; if (get_user(insn, (unsigned char )(regs->ip + i))) break; printk(KERN_CONT "%02x ", insn); } } printk(KERN_CONT "\n"); #endif preempt_disable(); show_regs(regs); preempt_enable(); } static int __init setup_print_fatal_signals(char str) { get_option (&str, &print_fatal_signals); return 1; } __setup("print-fatal-signals=", setup_print_fatal_signals); int __group_send_sig_info(int sig, struct siginfo info, struct task_struct p) { return send_signal(sig, info, p, 1); } static int specific_send_sig_info(int sig, struct siginfo info, struct task_struct t) { return send_signal(sig, info, t, 0); } int do_send_sig_info(int sig, struct siginfo info, struct task_struct p, bool group) { unsigned long flags; int ret = -ESRCH; if (lock_task_sighand(p, &flags)) { ret = send_signal(sig, info, p, group); unlock_task_sighand(p, &flags); } return ret; } / * Force a signal that the process can't ignore: if necessary * we unblock the signal and change any SIG_IGN to SIG_DFL. * * Note: If we unblock the signal, we always reset it to SIG_DFL, * since we do not want to have a signal handler that was blocked * be invoked when user space had explicitly blocked it. * * We don't want to have recursive SIGSEGV's etc, for example, * that is why we also clear SIGNAL_UNKILLABLE. / int force_sig_info(int sig, struct siginfo info, struct task_struct t) { unsigned long int flags; int ret, blocked, ignored; struct k_sigaction action; spin_lock_irqsave(&t->sighand->siglock, flags); action = &t->sighand->action[sig-1]; ignored = action->sa.sa_handler == SIG_IGN; blocked = sigismember(&t->blocked, sig); if (blocked \|\| ignored) { action->sa.sa_handler = SIG_DFL; if (blocked) { sigdelset(&t->blocked, sig); recalc_sigpending_and_wake(t); } } if (action->sa.sa_handler == SIG_DFL) t->signal->flags &= ~SIGNAL_UNKILLABLE; ret = specific_send_sig_info(sig, info, t); spin_unlock_irqrestore(&t->sighand->siglock, flags); return ret; } /* * Nuke all other threads in the group. / int zap_other_threads(struct task_struct p) { struct task_struct t = p; int count = 0; p->signal->group_stop_count = 0; while_each_thread(p, t) { task_clear_jobctl_pending(t, JOBCTL_PENDING_MASK); count++; / Don't bother with already dead threads / if (t->exit_state) continue; sigaddset(&t->pending.signal, SIGKILL); signal_wake_up(t, 1); } return count; } struct sighand_struct __lock_task_sighand(struct task_struct tsk, unsigned long flags) { struct sighand_struct sighand; for (;;) { local_irq_save(flags); rcu_read_lock(); sighand = rcu_dereference(tsk->sighand); if (unlikely(sighand == NULL)) { rcu_read_unlock(); local_irq_restore(flags); break; } spin_lock(&sighand->siglock); if (likely(sighand == tsk->sighand)) { rcu_read_unlock(); break; } spin_unlock(&sighand->siglock); rcu_read_unlock(); local_irq_restore(flags); } return sighand; } /* * send signal info to all the members of a group / int group_send_sig_info(int sig, struct siginfo info, struct task_struct p) { int ret; rcu_read_lock(); ret = check_kill_permission(sig, info, p); rcu_read_unlock(); if (!ret && sig) ret = do_send_sig_info(sig, info, p, true); return ret; } / * __kill_pgrp_info() sends a signal to a process group: this is what the tty * control characters do (^C, ^Z etc) * - the caller must hold at least a readlock on tasklist_lock / int __kill_pgrp_info(int sig, struct siginfo info, struct pid pgrp) { struct task_struct p = NULL; int retval, success; success = 0; retval = -ESRCH; do_each_pid_task(pgrp, PIDTYPE_PGID, p) { int err = group_send_sig_info(sig, info, p); success \|= !err; retval = err; } while_each_pid_task(pgrp, PIDTYPE_PGID, p); return success ? 0 : retval; } int kill_pid_info(int sig, struct siginfo info, struct pid pid) { int error = -ESRCH; struct task_struct p; rcu_read_lock(); retry: p = pid_task(pid, PIDTYPE_PID); if (p) { error = group_send_sig_info(sig, info, p); if (unlikely(error == -ESRCH)) / * The task was unhashed in between, try again. * If it is dead, pid_task() will return NULL, * if we race with de_thread() it will find the * new leader. / goto retry; } rcu_read_unlock(); return error; } int kill_proc_info(int sig, struct siginfo info, pid_t pid) { int error; rcu_read_lock(); error = kill_pid_info(sig, info, find_vpid(pid)); rcu_read_unlock(); return error; } static int kill_as_cred_perm(const struct cred cred, struct task_struct target) { const struct cred pcred = __task_cred(target); if (!uid_eq(cred->euid, pcred->suid) && !uid_eq(cred->euid, pcred->uid) && !uid_eq(cred->uid, pcred->suid) && !uid_eq(cred->uid, pcred->uid)) return 0; return 1; } / like kill_pid_info(), but doesn't use uid/euid of "current" / int kill_pid_info_as_cred(int sig, struct siginfo info, struct pid pid, const struct cred cred, u32 secid) { int ret = -EINVAL; struct task_struct p; unsigned long flags; if (!valid_signal(sig)) return ret; rcu_read_lock(); p = pid_task(pid, PIDTYPE_PID); if (!p) { ret = -ESRCH; goto out_unlock; } if (si_fromuser(info) && !kill_as_cred_perm(cred, p)) { ret = -EPERM; goto out_unlock; } ret = security_task_kill(p, info, sig, secid); if (ret) goto out_unlock; if (sig) { if (lock_task_sighand(p, &flags)) { ret = __send_signal(sig, info, p, 1, 0); unlock_task_sighand(p, &flags); } else ret = -ESRCH; } out_unlock: rcu_read_unlock(); return ret; } EXPORT_SYMBOL_GPL(kill_pid_info_as_cred); / * kill_something_info() interprets pid in interesting ways just like kill(2). * * POSIX specifies that kill(-1,sig) is unspecified, but what we have * is probably wrong. Should make it like BSD or SYSV. / static int kill_something_info(int sig, struct siginfo info, pid_t pid) { int ret; if (pid > 0) { rcu_read_lock(); ret = kill_pid_info(sig, info, find_vpid(pid)); rcu_read_unlock(); return ret; } read_lock(&tasklist_lock); if (pid != -1) { ret = __kill_pgrp_info(sig, info, pid ? find_vpid(-pid) : task_pgrp(current)); } else { int retval = 0, count = 0; struct task_struct * p; for_each_process(p) { if (task_pid_vnr(p) > 1 && !same_thread_group(p, current)) { int err = group_send_sig_info(sig, info, p); ++count; if (err != -EPERM) retval = err; } } ret = count ? retval : -ESRCH; } read_unlock(&tasklist_lock); return ret; } /* * These are for backward compatibility with the rest of the kernel source. / int send_sig_info(int sig, struct siginfo info, struct task_struct p) { / * Make sure legacy kernel users don't send in bad values * (normal paths check this in check_kill_permission). / if (!valid_signal(sig)) return -EINVAL; return do_send_sig_info(sig, info, p, false); } #define __si_special(priv) \ ((priv) ? SEND_SIG_PRIV : SEND_SIG_NOINFO) int send_sig(int sig, struct task_struct p, int priv) { return send_sig_info(sig, __si_special(priv), p); } void force_sig(int sig, struct task_struct p) { force_sig_info(sig, SEND_SIG_PRIV, p); } / * When things go south during signal handling, we * will force a SIGSEGV. And if the signal that caused * the problem was already a SIGSEGV, we'll want to * make sure we don't even try to deliver the signal.. / int force_sigsegv(int sig, struct task_struct p) { if (sig == SIGSEGV) { unsigned long flags; spin_lock_irqsave(&p->sighand->siglock, flags); p->sighand->action[sig - 1].sa.sa_handler = SIG_DFL; spin_unlock_irqrestore(&p->sighand->siglock, flags); } force_sig(SIGSEGV, p); return 0; } int kill_pgrp(struct pid pid, int sig, int priv) { int ret; read_lock(&tasklist_lock); ret = __kill_pgrp_info(sig, __si_special(priv), pid); read_unlock(&tasklist_lock); return ret; } EXPORT_SYMBOL(kill_pgrp); int kill_pid(struct pid pid, int sig, int priv) { return kill_pid_info(sig, __si_special(priv), pid); } EXPORT_SYMBOL(kill_pid); /* * These functions support sending signals using preallocated sigqueue * structures. This is needed "because realtime applications cannot * afford to lose notifications of asynchronous events, like timer * expirations or I/O completions". In the case of POSIX Timers * we allocate the sigqueue structure from the timer_create. If this * allocation fails we are able to report the failure to the application * with an EAGAIN error. / struct sigqueue sigqueue_alloc(void) { struct sigqueue q = __sigqueue_alloc(-1, current, GFP_KERNEL, 0); if (q) q->flags \|= SIGQUEUE_PREALLOC; return q; } void sigqueue_free(struct sigqueue q) { unsigned long flags; spinlock_t lock = &current->sighand->siglock; BUG_ON(!(q->flags & SIGQUEUE_PREALLOC)); / * We must hold ->siglock while testing q->list * to serialize with collect_signal() or with * __exit_signal()->flush_sigqueue(). / spin_lock_irqsave(lock, flags); q->flags &= ~SIGQUEUE_PREALLOC; / * If it is queued it will be freed when dequeued, * like the "regular" sigqueue. / if (!list_empty(&q->list)) q = NULL; spin_unlock_irqrestore(lock, flags); if (q) __sigqueue_free(q); } int send_sigqueue(struct sigqueue q, struct task_struct t, int group) { int sig = q->info.si_signo; struct sigpending pending; unsigned long flags; int ret, result; BUG_ON(!(q->flags & SIGQUEUE_PREALLOC)); ret = -1; if (!likely(lock_task_sighand(t, &flags))) goto ret; ret = 1; /* the signal is ignored / result = TRACE_SIGNAL_IGNORED; if (!prepare_signal(sig, t, false)) goto out; ret = 0; if (unlikely(!list_empty(&q->list))) { / * If an SI_TIMER entry is already queue just increment * the overrun count. / BUG_ON(q->info.si_code != SI_TIMER); q->info.si_overrun++; result = TRACE_SIGNAL_ALREADY_PENDING; goto out; } q->info.si_overrun = 0; signalfd_notify(t, sig); pending = group ? &t->signal->shared_pending : &t->pending; list_add_tail(&q->list, &pending->list); sigaddset(&pending->signal, sig); complete_signal(sig, t, group); result = TRACE_SIGNAL_DELIVERED; out: trace_signal_generate(sig, &q->info, t, group, result); unlock_task_sighand(t, &flags); ret: return ret; } / * Let a parent know about the death of a child. * For a stopped/continued status change, use do_notify_parent_cldstop instead. * * Returns true if our parent ignored us and so we've switched to * self-reaping. / bool do_notify_parent(struct task_struct tsk, int sig) { struct siginfo info; unsigned long flags; struct sighand_struct psig; bool autoreap = false; cputime_t utime, stime; BUG_ON(sig == -1); / do_notify_parent_cldstop should have been called instead. / BUG_ON(task_is_stopped_or_traced(tsk)); BUG_ON(!tsk->ptrace && (tsk->group_leader != tsk \|\| !thread_group_empty(tsk))); if (sig != SIGCHLD) { / * This is only possible if parent == real_parent. * Check if it has changed security domain. / if (tsk->parent_exec_id != tsk->parent->self_exec_id) sig = SIGCHLD; } info.si_signo = sig; info.si_errno = 0; / * We are under tasklist_lock here so our parent is tied to * us and cannot change. * * task_active_pid_ns will always return the same pid namespace * until a task passes through release_task. * * write_lock() currently calls preempt_disable() which is the * same as rcu_read_lock(), but according to Oleg, this is not * correct to rely on this / rcu_read_lock(); info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(tsk->parent)); info.si_uid = from_kuid_munged(task_cred_xxx(tsk->parent, user_ns), task_uid(tsk)); rcu_read_unlock(); task_cputime(tsk, &utime, &stime); info.si_utime = cputime_to_clock_t(utime + tsk->signal->utime); info.si_stime = cputime_to_clock_t(stime + tsk->signal->stime); info.si_status = tsk->exit_code & 0x7f; if (tsk->exit_code & 0x80) info.si_code = CLD_DUMPED; else if (tsk->exit_code & 0x7f) info.si_code = CLD_KILLED; else { info.si_code = CLD_EXITED; info.si_status = tsk->exit_code >> 8; } psig = tsk->parent->sighand; spin_lock_irqsave(&psig->siglock, flags); if (!tsk->ptrace && sig == SIGCHLD && (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN \|\| (psig->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDWAIT))) { / * We are exiting and our parent doesn't care. POSIX.1 * defines special semantics for setting SIGCHLD to SIG_IGN * or setting the SA_NOCLDWAIT flag: we should be reaped * automatically and not left for our parent's wait4 call. * Rather than having the parent do it as a magic kind of * signal handler, we just set this to tell do_exit that we * can be cleaned up without becoming a zombie. Note that * we still call __wake_up_parent in this case, because a * blocked sys_wait4 might now return -ECHILD. * * Whether we send SIGCHLD or not for SA_NOCLDWAIT * is implementation-defined: we do (if you don't want * it, just use SIG_IGN instead). / autoreap = true; if (psig->action[SIGCHLD-1].sa.sa_handler == SIG_IGN) sig = 0; } if (valid_signal(sig) && sig) __group_send_sig_info(sig, &info, tsk->parent); __wake_up_parent(tsk, tsk->parent); spin_unlock_irqrestore(&psig->siglock, flags); return autoreap; } /* * do_notify_parent_cldstop - notify parent of stopped/continued state change * @tsk: task reporting the state change * @for_ptracer: the notification is for ptracer * @why: CLD_{CONTINUED\|STOPPED\|TRAPPED} to report * * Notify @tsk's parent that the stopped/continued state has changed. If * @for_ptracer is %false, @tsk's group leader notifies to its real parent. * If %true, @tsk reports to @tsk->parent which should be the ptracer. * * CONTEXT: * Must be called with tasklist_lock at least read locked. / static void do_notify_parent_cldstop(struct task_struct tsk, bool for_ptracer, int why) { struct siginfo info; unsigned long flags; struct task_struct parent; struct sighand_struct sighand; cputime_t utime, stime; if (for_ptracer) { parent = tsk->parent; } else { tsk = tsk->group_leader; parent = tsk->real_parent; } info.si_signo = SIGCHLD; info.si_errno = 0; /* * see comment in do_notify_parent() about the following 4 lines / rcu_read_lock(); info.si_pid = task_pid_nr_ns(tsk, task_active_pid_ns(parent)); info.si_uid = from_kuid_munged(task_cred_xxx(parent, user_ns), task_uid(tsk)); rcu_read_unlock(); task_cputime(tsk, &utime, &stime); info.si_utime = cputime_to_clock_t(utime); info.si_stime = cputime_to_clock_t(stime); info.si_code = why; switch (why) { case CLD_CONTINUED: info.si_status = SIGCONT; break; case CLD_STOPPED: info.si_status = tsk->signal->group_exit_code & 0x7f; break; case CLD_TRAPPED: info.si_status = tsk->exit_code & 0x7f; break; default: BUG(); } sighand = parent->sighand; spin_lock_irqsave(&sighand->siglock, flags); if (sighand->action[SIGCHLD-1].sa.sa_handler != SIG_IGN && !(sighand->action[SIGCHLD-1].sa.sa_flags & SA_NOCLDSTOP)) __group_send_sig_info(SIGCHLD, &info, parent); / * Even if SIGCHLD is not generated, we must wake up wait4 calls. / __wake_up_parent(tsk, parent); spin_unlock_irqrestore(&sighand->siglock, flags); } static inline int may_ptrace_stop(void) { if (!likely(current->ptrace)) return 0; / * Are we in the middle of do_coredump? * If so and our tracer is also part of the coredump stopping * is a deadlock situation, and pointless because our tracer * is dead so don't allow us to stop. * If SIGKILL was already sent before the caller unlocked * ->siglock we must see ->core_state != NULL. Otherwise it * is safe to enter schedule(). * * This is almost outdated, a task with the pending SIGKILL can't * block in TASK_TRACED. But PTRACE_EVENT_EXIT can be reported * after SIGKILL was already dequeued. / if (unlikely(current->mm->core_state) && unlikely(current->mm == current->parent->mm)) return 0; return 1; } / * Return non-zero if there is a SIGKILL that should be waking us up. * Called with the siglock held. / static int sigkill_pending(struct task_struct tsk) { return sigismember(&tsk->pending.signal, SIGKILL) \|\| sigismember(&tsk->signal->shared_pending.signal, SIGKILL); } /* * This must be called with current->sighand->siglock held. * * This should be the path for all ptrace stops. * We always set current->last_siginfo while stopped here. * That makes it a way to test a stopped process for * being ptrace-stopped vs being job-control-stopped. * * If we actually decide not to stop at all because the tracer * is gone, we keep current->exit_code unless clear_code. / static void ptrace_stop(int exit_code, int why, int clear_code, siginfo_t info) __releases(&current->sighand->siglock) __acquires(&current->sighand->siglock) { bool gstop_done = false; if (arch_ptrace_stop_needed(exit_code, info)) { /* * The arch code has something special to do before a * ptrace stop. This is allowed to block, e.g. for faults * on user stack pages. We can't keep the siglock while * calling arch_ptrace_stop, so we must release it now. * To preserve proper semantics, we must do this before * any signal bookkeeping like checking group_stop_count. * Meanwhile, a SIGKILL could come in before we retake the * siglock. That must prevent us from sleeping in TASK_TRACED. * So after regaining the lock, we must check for SIGKILL. / spin_unlock_irq(&current->sighand->siglock); arch_ptrace_stop(exit_code, info); spin_lock_irq(&current->sighand->siglock); if (sigkill_pending(current)) return; } / * We're committing to trapping. TRACED should be visible before * TRAPPING is cleared; otherwise, the tracer might fail do_wait(). * Also, transition to TRACED and updates to ->jobctl should be * atomic with respect to siglock and should be done after the arch * hook as siglock is released and regrabbed across it. / set_current_state(TASK_TRACED); current->last_siginfo = info; current->exit_code = exit_code; / * If @why is CLD_STOPPED, we're trapping to participate in a group * stop. Do the bookkeeping. Note that if SIGCONT was delievered * across siglock relocks since INTERRUPT was scheduled, PENDING * could be clear now. We act as if SIGCONT is received after * TASK_TRACED is entered - ignore it. / if (why == CLD_STOPPED && (current->jobctl & JOBCTL_STOP_PENDING)) gstop_done = task_participate_group_stop(current); / any trap clears pending STOP trap, STOP trap clears NOTIFY / task_clear_jobctl_pending(current, JOBCTL_TRAP_STOP); if (info && info->si_code >> 8 == PTRACE_EVENT_STOP) task_clear_jobctl_pending(current, JOBCTL_TRAP_NOTIFY); / entering a trap, clear TRAPPING / task_clear_jobctl_trapping(current); spin_unlock_irq(&current->sighand->siglock); read_lock(&tasklist_lock); if (may_ptrace_stop()) { / * Notify parents of the stop. * * While ptraced, there are two parents - the ptracer and * the real_parent of the group_leader. The ptracer should * know about every stop while the real parent is only * interested in the completion of group stop. The states * for the two don't interact with each other. Notify * separately unless they're gonna be duplicates. / do_notify_parent_cldstop(current, true, why); if (gstop_done && ptrace_reparented(current)) do_notify_parent_cldstop(current, false, why); / * Don't want to allow preemption here, because * sys_ptrace() needs this task to be inactive. * * XXX: implement read_unlock_no_resched(). / preempt_disable(); read_unlock(&tasklist_lock); preempt_enable_no_resched(); freezable_schedule(); } else { / * By the time we got the lock, our tracer went away. * Don't drop the lock yet, another tracer may come. * * If @gstop_done, the ptracer went away between group stop * completion and here. During detach, it would have set * JOBCTL_STOP_PENDING on us and we'll re-enter * TASK_STOPPED in do_signal_stop() on return, so notifying * the real parent of the group stop completion is enough. / if (gstop_done) do_notify_parent_cldstop(current, false, why); / tasklist protects us from ptrace_freeze_traced() / __set_current_state(TASK_RUNNING); if (clear_code) current->exit_code = 0; read_unlock(&tasklist_lock); } / * We are back. Now reacquire the siglock before touching * last_siginfo, so that we are sure to have synchronized with * any signal-sending on another CPU that wants to examine it. / spin_lock_irq(&current->sighand->siglock); current->last_siginfo = NULL; / LISTENING can be set only during STOP traps, clear it / current->jobctl &= ~JOBCTL_LISTENING; / * Queued signals ignored us while we were stopped for tracing. * So check for any that we should take before resuming user mode. * This sets TIF_SIGPENDING, but never clears it. / recalc_sigpending_tsk(current); } static void ptrace_do_notify(int signr, int exit_code, int why) { siginfo_t info; memset(&info, 0, sizeof info); info.si_signo = signr; info.si_code = exit_code; info.si_pid = task_pid_vnr(current); info.si_uid = from_kuid_munged(current_user_ns(), current_uid()); / Let the debugger run. / ptrace_stop(exit_code, why, 1, &info); } void ptrace_notify(int exit_code) { BUG_ON((exit_code & (0x7f \| ~0xffff)) != SIGTRAP); if (unlikely(current->task_works)) task_work_run(); spin_lock_irq(&current->sighand->siglock); ptrace_do_notify(SIGTRAP, exit_code, CLD_TRAPPED); spin_unlock_irq(&current->sighand->siglock); } /* * do_signal_stop - handle group stop for SIGSTOP and other stop signals * @signr: signr causing group stop if initiating * * If %JOBCTL_STOP_PENDING is not set yet, initiate group stop with @signr * and participate in it. If already set, participate in the existing * group stop. If participated in a group stop (and thus slept), %true is * returned with siglock released. * * If ptraced, this function doesn't handle stop itself. Instead, * %JOBCTL_TRAP_STOP is scheduled and %false is returned with siglock * untouched. The caller must ensure that INTERRUPT trap handling takes * places afterwards. * * CONTEXT: * Must be called with @current->sighand->siglock held, which is released * on %true return. * * RETURNS: * %false if group stop is already cancelled or ptrace trap is scheduled. * %true if participated in group stop. / static bool do_signal_stop(int signr) __releases(&current->sighand->siglock) { struct signal_struct sig = current->signal; if (!(current->jobctl & JOBCTL_STOP_PENDING)) { unsigned int gstop = JOBCTL_STOP_PENDING \| JOBCTL_STOP_CONSUME; struct task_struct t; / signr will be recorded in task->jobctl for retries / WARN_ON_ONCE(signr & ~JOBCTL_STOP_SIGMASK); if (!likely(current->jobctl & JOBCTL_STOP_DEQUEUED) \|\| unlikely(signal_group_exit(sig))) return false; / * There is no group stop already in progress. We must * initiate one now. * * While ptraced, a task may be resumed while group stop is * still in effect and then receive a stop signal and * initiate another group stop. This deviates from the * usual behavior as two consecutive stop signals can't * cause two group stops when !ptraced. That is why we * also check !task_is_stopped(t) below. * * The condition can be distinguished by testing whether * SIGNAL_STOP_STOPPED is already set. Don't generate * group_exit_code in such case. * * This is not necessary for SIGNAL_STOP_CONTINUED because * an intervening stop signal is required to cause two * continued events regardless of ptrace. / if (!(sig->flags & SIGNAL_STOP_STOPPED)) sig->group_exit_code = signr; sig->group_stop_count = 0; if (task_set_jobctl_pending(current, signr \| gstop)) sig->group_stop_count++; for (t = next_thread(current); t != current; t = next_thread(t)) { / * Setting state to TASK_STOPPED for a group * stop is always done with the siglock held, * so this check has no races. / if (!task_is_stopped(t) && task_set_jobctl_pending(t, signr \| gstop)) { sig->group_stop_count++; if (likely(!(t->ptrace & PT_SEIZED))) signal_wake_up(t, 0); else ptrace_trap_notify(t); } } } if (likely(!current->ptrace)) { int notify = 0; / * If there are no other threads in the group, or if there * is a group stop in progress and we are the last to stop, * report to the parent. / if (task_participate_group_stop(current)) notify = CLD_STOPPED; __set_current_state(TASK_STOPPED); spin_unlock_irq(&current->sighand->siglock); / * Notify the parent of the group stop completion. Because * we're not holding either the siglock or tasklist_lock * here, ptracer may attach inbetween; however, this is for * group stop and should always be delivered to the real * parent of the group leader. The new ptracer will get * its notification when this task transitions into * TASK_TRACED. / if (notify) { read_lock(&tasklist_lock); do_notify_parent_cldstop(current, false, notify); read_unlock(&tasklist_lock); } / Now we don't run again until woken by SIGCONT or SIGKILL / freezable_schedule(); return true; } else { / * While ptraced, group stop is handled by STOP trap. * Schedule it and let the caller deal with it. / task_set_jobctl_pending(current, JOBCTL_TRAP_STOP); return false; } } /* * do_jobctl_trap - take care of ptrace jobctl traps * * When PT_SEIZED, it's used for both group stop and explicit * SEIZE/INTERRUPT traps. Both generate PTRACE_EVENT_STOP trap with * accompanying siginfo. If stopped, lower eight bits of exit_code contain * the stop signal; otherwise, %SIGTRAP. * * When !PT_SEIZED, it's used only for group stop trap with stop signal * number as exit_code and no siginfo. * * CONTEXT: * Must be called with @current->sighand->siglock held, which may be * released and re-acquired before returning with intervening sleep. / static void do_jobctl_trap(void) { struct signal_struct signal = current->signal; int signr = current->jobctl & JOBCTL_STOP_SIGMASK; if (current->ptrace & PT_SEIZED) { if (!signal->group_stop_count && !(signal->flags & SIGNAL_STOP_STOPPED)) signr = SIGTRAP; WARN_ON_ONCE(!signr); ptrace_do_notify(signr, signr \| (PTRACE_EVENT_STOP << 8), CLD_STOPPED); } else { WARN_ON_ONCE(!signr); ptrace_stop(signr, CLD_STOPPED, 0, NULL); current->exit_code = 0; } } static int ptrace_signal(int signr, siginfo_t info) { ptrace_signal_deliver(); / * We do not check sig_kernel_stop(signr) but set this marker * unconditionally because we do not know whether debugger will * change signr. This flag has no meaning unless we are going * to stop after return from ptrace_stop(). In this case it will * be checked in do_signal_stop(), we should only stop if it was * not cleared by SIGCONT while we were sleeping. See also the * comment in dequeue_signal(). / current->jobctl \|= JOBCTL_STOP_DEQUEUED; ptrace_stop(signr, CLD_TRAPPED, 0, info); / We're back. Did the debugger cancel the sig? / signr = current->exit_code; if (signr == 0) return signr; current->exit_code = 0; / * Update the siginfo structure if the signal has * changed. If the debugger wanted something * specific in the siginfo structure then it should * have updated info via PTRACE_SETSIGINFO. / if (signr != info->si_signo) { info->si_signo = signr; info->si_errno = 0; info->si_code = SI_USER; rcu_read_lock(); info->si_pid = task_pid_vnr(current->parent); info->si_uid = from_kuid_munged(current_user_ns(), task_uid(current->parent)); rcu_read_unlock(); } /* If the (new) signal is now blocked, requeue it. / if (sigismember(&current->blocked, signr)) { specific_send_sig_info(signr, info, current); signr = 0; } return signr; } int get_signal_to_deliver(siginfo_t info, struct k_sigaction return_ka, struct pt_regs regs, void cookie) { struct sighand_struct sighand = current->sighand; struct signal_struct signal = current->signal; int signr; if (unlikely(current->task_works)) task_work_run(); if (unlikely(uprobe_deny_signal())) return 0; / * Do this once, we can't return to user-mode if freezing() == T. * do_signal_stop() and ptrace_stop() do freezable_schedule() and * thus do not need another check after return. / try_to_freeze(); relock: spin_lock_irq(&sighand->siglock); / * Every stopped thread goes here after wakeup. Check to see if * we should notify the parent, prepare_signal(SIGCONT) encodes * the CLD_ si_code into SIGNAL_CLD_MASK bits. / if (unlikely(signal->flags & SIGNAL_CLD_MASK)) { int why; if (signal->flags & SIGNAL_CLD_CONTINUED) why = CLD_CONTINUED; else why = CLD_STOPPED; signal->flags &= ~SIGNAL_CLD_MASK; spin_unlock_irq(&sighand->siglock); / * Notify the parent that we're continuing. This event is * always per-process and doesn't make whole lot of sense * for ptracers, who shouldn't consume the state via * wait(2) either, but, for backward compatibility, notify * the ptracer of the group leader too unless it's gonna be * a duplicate. / read_lock(&tasklist_lock); do_notify_parent_cldstop(current, false, why); if (ptrace_reparented(current->group_leader)) do_notify_parent_cldstop(current->group_leader, true, why); read_unlock(&tasklist_lock); goto relock; } for (;;) { struct k_sigaction ka; if (unlikely(current->jobctl & JOBCTL_STOP_PENDING) && do_signal_stop(0)) goto relock; if (unlikely(current->jobctl & JOBCTL_TRAP_MASK)) { do_jobctl_trap(); spin_unlock_irq(&sighand->siglock); goto relock; } signr = dequeue_signal(current, &current->blocked, info); if (!signr) break; /* will return 0 / if (unlikely(current->ptrace) && signr != SIGKILL) { signr = ptrace_signal(signr, info); if (!signr) continue; } ka = &sighand->action[signr-1]; / Trace actually delivered signals. / trace_signal_deliver(signr, info, ka); if (ka->sa.sa_handler == SIG_IGN) / Do nothing. / continue; if (ka->sa.sa_handler != SIG_DFL) { / Run the handler. / return_ka = ka; if (ka->sa.sa_flags & SA_ONESHOT) ka->sa.sa_handler = SIG_DFL; break; / will return non-zero "signr" value / } / * Now we are doing the default action for this signal. / if (sig_kernel_ignore(signr)) / Default is nothing. / continue; / * Global init gets no signals it doesn't want. * Container-init gets no signals it doesn't want from same * container. * * Note that if global/container-init sees a sig_kernel_only() * signal here, the signal must have been generated internally * or must have come from an ancestor namespace. In either * case, the signal cannot be dropped. / if (unlikely(signal->flags & SIGNAL_UNKILLABLE) && !sig_kernel_only(signr)) continue; if (sig_kernel_stop(signr)) { / * The default action is to stop all threads in * the thread group. The job control signals * do nothing in an orphaned pgrp, but SIGSTOP * always works. Note that siglock needs to be * dropped during the call to is_orphaned_pgrp() * because of lock ordering with tasklist_lock. * This allows an intervening SIGCONT to be posted. * We need to check for that and bail out if necessary. / if (signr != SIGSTOP) { spin_unlock_irq(&sighand->siglock); / signals can be posted during this window / if (is_current_pgrp_orphaned()) goto relock; spin_lock_irq(&sighand->siglock); } if (likely(do_signal_stop(info->si_signo))) { / It released the siglock. / goto relock; } / * We didn't actually stop, due to a race * with SIGCONT or something like that. / continue; } spin_unlock_irq(&sighand->siglock); / * Anything else is fatal, maybe with a core dump. / current->flags \|= PF_SIGNALED; if (sig_kernel_coredump(signr)) { if (print_fatal_signals) print_fatal_signal(info->si_signo); / * If it was able to dump core, this kills all * other threads in the group and synchronizes with * their demise. If we lost the race with another * thread getting here, it set group_exit_code * first and our do_group_exit call below will use * that value and ignore the one we pass it. / do_coredump(info); } / * Death signals, no core dump. / do_group_exit(info->si_signo); / NOTREACHED / } spin_unlock_irq(&sighand->siglock); return signr; } /* * signal_delivered - * @sig: number of signal being delivered * @info: siginfo_t of signal being delivered * @ka: sigaction setting that chose the handler * @regs: user register state * @stepping: nonzero if debugger single-step or block-step in use * * This function should be called when a signal has succesfully been * delivered. It updates the blocked signals accordingly (@ka->sa.sa_mask * is always blocked, and the signal itself is blocked unless %SA_NODEFER * is set in @ka->sa.sa_flags. Tracing is notified. / void signal_delivered(int sig, siginfo_t info, struct k_sigaction ka, struct pt_regs regs, int stepping) { sigset_t blocked; /* A signal was successfully delivered, and the saved sigmask was stored on the signal frame, and will be restored by sigreturn. So we can simply clear the restore sigmask flag. / clear_restore_sigmask(); sigorsets(&blocked, &current->blocked, &ka->sa.sa_mask); if (!(ka->sa.sa_flags & SA_NODEFER)) sigaddset(&blocked, sig); set_current_blocked(&blocked); tracehook_signal_handler(sig, info, ka, regs, stepping); } void signal_setup_done(int failed, struct ksignal ksig, int stepping) { if (failed) force_sigsegv(ksig->sig, current); else signal_delivered(ksig->sig, &ksig->info, &ksig->ka, signal_pt_regs(), stepping); } /* * It could be that complete_signal() picked us to notify about the * group-wide signal. Other threads should be notified now to take * the shared signals in @which since we will not. / static void retarget_shared_pending(struct task_struct tsk, sigset_t which) { sigset_t retarget; struct task_struct t; sigandsets(&retarget, &tsk->signal->shared_pending.signal, which); if (sigisemptyset(&retarget)) return; t = tsk; while_each_thread(tsk, t) { if (t->flags & PF_EXITING) continue; if (!has_pending_signals(&retarget, &t->blocked)) continue; /* Remove the signals this thread can handle. / sigandsets(&retarget, &retarget, &t->blocked); if (!signal_pending(t)) signal_wake_up(t, 0); if (sigisemptyset(&retarget)) break; } } void exit_signals(struct task_struct tsk) { int group_stop = 0; sigset_t unblocked; /* * @tsk is about to have PF_EXITING set - lock out users which * expect stable threadgroup. / threadgroup_change_begin(tsk); if (thread_group_empty(tsk) \|\| signal_group_exit(tsk->signal)) { tsk->flags \|= PF_EXITING; threadgroup_change_end(tsk); return; } spin_lock_irq(&tsk->sighand->siglock); / * From now this task is not visible for group-wide signals, * see wants_signal(), do_signal_stop(). / tsk->flags \|= PF_EXITING; threadgroup_change_end(tsk); if (!signal_pending(tsk)) goto out; unblocked = tsk->blocked; signotset(&unblocked); retarget_shared_pending(tsk, &unblocked); if (unlikely(tsk->jobctl & JOBCTL_STOP_PENDING) && task_participate_group_stop(tsk)) group_stop = CLD_STOPPED; out: spin_unlock_irq(&tsk->sighand->siglock); / * If group stop has completed, deliver the notification. This * should always go to the real parent of the group leader. / if (unlikely(group_stop)) { read_lock(&tasklist_lock); do_notify_parent_cldstop(tsk, false, group_stop); read_unlock(&tasklist_lock); } } EXPORT_SYMBOL(recalc_sigpending); EXPORT_SYMBOL_GPL(dequeue_signal); EXPORT_SYMBOL(flush_signals); EXPORT_SYMBOL(force_sig); EXPORT_SYMBOL(send_sig); EXPORT_SYMBOL(send_sig_info); EXPORT_SYMBOL(sigprocmask); EXPORT_SYMBOL(block_all_signals); EXPORT_SYMBOL(unblock_all_signals); / * System call entry points. / /* * sys_restart_syscall - restart a system call / SYSCALL_DEFINE0(restart_syscall) { struct restart_block restart = &current_thread_info()->restart_block; return restart->fn(restart); } long do_no_restart_syscall(struct restart_block param) { return -EINTR; } static void __set_task_blocked(struct task_struct tsk, const sigset_t newset) { if (signal_pending(tsk) && !thread_group_empty(tsk)) { sigset_t newblocked; / A set of now blocked but previously unblocked signals. / sigandnsets(&newblocked, newset, &current->blocked); retarget_shared_pending(tsk, &newblocked); } tsk->blocked = newset; recalc_sigpending(); } /** * set_current_blocked - change current->blocked mask * @newset: new mask * * It is wrong to change ->blocked directly, this helper should be used * to ensure the process can't miss a shared signal we are going to block. / void set_current_blocked(sigset_t newset) { sigdelsetmask(newset, sigmask(SIGKILL) \| sigmask(SIGSTOP)); __set_current_blocked(newset); } void __set_current_blocked(const sigset_t newset) { struct task_struct tsk = current; spin_lock_irq(&tsk->sighand->siglock); __set_task_blocked(tsk, newset); spin_unlock_irq(&tsk->sighand->siglock); } /* * This is also useful for kernel threads that want to temporarily * (or permanently) block certain signals. * * NOTE! Unlike the user-mode sys_sigprocmask(), the kernel * interface happily blocks "unblockable" signals like SIGKILL * and friends. / int sigprocmask(int how, sigset_t set, sigset_t oldset) { struct task_struct tsk = current; sigset_t newset; /* Lockless, only current can change ->blocked, never from irq / if (oldset) oldset = tsk->blocked; switch (how) { case SIG_BLOCK: sigorsets(&newset, &tsk->blocked, set); break; case SIG_UNBLOCK: sigandnsets(&newset, &tsk->blocked, set); break; case SIG_SETMASK: newset = set; break; default: return -EINVAL; } __set_current_blocked(&newset); return 0; } /* * sys_rt_sigprocmask - change the list of currently blocked signals * @how: whether to add, remove, or set signals * @nset: stores pending signals * @oset: previous value of signal mask if non-null * @sigsetsize: size of sigset_t type / SYSCALL_DEFINE4(rt_sigprocmask, int, how, sigset_t __user , nset, sigset_t __user , oset, size_t, sigsetsize) { sigset_t old_set, new_set; int error; / XXX: Don't preclude handling different sized sigset_t's. / if (sigsetsize != sizeof(sigset_t)) return -EINVAL; old_set = current->blocked; if (nset) { if (copy_from_user(&new_set, nset, sizeof(sigset_t))) return -EFAULT; sigdelsetmask(&new_set, sigmask(SIGKILL)\|sigmask(SIGSTOP)); error = sigprocmask(how, &new_set, NULL); if (error) return error; } if (oset) { if (copy_to_user(oset, &old_set, sizeof(sigset_t))) return -EFAULT; } return 0; } #ifdef CONFIG_COMPAT COMPAT_SYSCALL_DEFINE4(rt_sigprocmask, int, how, compat_sigset_t __user , nset, compat_sigset_t __user , oset, compat_size_t, sigsetsize) { #ifdef __BIG_ENDIAN sigset_t old_set = current->blocked; / XXX: Don't preclude handling different sized sigset_t's. / if (sigsetsize != sizeof(sigset_t)) return -EINVAL; if (nset) { compat_sigset_t new32; sigset_t new_set; int error; if (copy_from_user(&new32, nset, sizeof(compat_sigset_t))) return -EFAULT; sigset_from_compat(&new_set, &new32); sigdelsetmask(&new_set, sigmask(SIGKILL)\|sigmask(SIGSTOP)); error = sigprocmask(how, &new_set, NULL); if (error) return error; } if (oset) { compat_sigset_t old32; sigset_to_compat(&old32, &old_set); if (copy_to_user(oset, &old32, sizeof(compat_sigset_t))) return -EFAULT; } return 0; #else return sys_rt_sigprocmask(how, (sigset_t __user )nset, (sigset_t __user )oset, sigsetsize); #endif } #endif static int do_sigpending(void set, unsigned long sigsetsize) { if (sigsetsize > sizeof(sigset_t)) return -EINVAL; spin_lock_irq(&current->sighand->siglock); sigorsets(set, &current->pending.signal, &current->signal->shared_pending.signal); spin_unlock_irq(&current->sighand->siglock); /* Outside the lock because only this thread touches it. / sigandsets(set, &current->blocked, set); return 0; } /* * sys_rt_sigpending - examine a pending signal that has been raised * while blocked * @uset: stores pending signals * @sigsetsize: size of sigset_t type or larger / SYSCALL_DEFINE2(rt_sigpending, sigset_t __user , uset, size_t, sigsetsize) { sigset_t set; int err = do_sigpending(&set, sigsetsize); if (!err && copy_to_user(uset, &set, sigsetsize)) err = -EFAULT; return err; } #ifdef CONFIG_COMPAT COMPAT_SYSCALL_DEFINE2(rt_sigpending, compat_sigset_t __user , uset, compat_size_t, sigsetsize) { #ifdef __BIG_ENDIAN sigset_t set; int err = do_sigpending(&set, sigsetsize); if (!err) { compat_sigset_t set32; sigset_to_compat(&set32, &set); / we can get here only if sigsetsize <= sizeof(set) / if (copy_to_user(uset, &set32, sigsetsize)) err = -EFAULT; } return err; #else return sys_rt_sigpending((sigset_t __user )uset, sigsetsize); #endif } #endif #ifndef HAVE_ARCH_COPY_SIGINFO_TO_USER int copy_siginfo_to_user(siginfo_t __user to, siginfo_t from) { int err; if (!access_ok (VERIFY_WRITE, to, sizeof(siginfo_t))) return -EFAULT; if (from->si_code < 0) return __copy_to_user(to, from, sizeof(siginfo_t)) ? -EFAULT : 0; /* * If you change siginfo_t structure, please be sure * this code is fixed accordingly. * Please remember to update the signalfd_copyinfo() function * inside fs/signalfd.c too, in case siginfo_t changes. * It should never copy any pad contained in the structure * to avoid security leaks, but must copy the generic * 3 ints plus the relevant union member. / err = __put_user(from->si_signo, &to->si_signo); err \|= __put_user(from->si_errno, &to->si_errno); err \|= __put_user((short)from->si_code, &to->si_code); switch (from->si_code & __SI_MASK) { case __SI_KILL: err \|= __put_user(from->si_pid, &to->si_pid); err \|= __put_user(from->si_uid, &to->si_uid); break; case __SI_TIMER: err \|= __put_user(from->si_tid, &to->si_tid); err \|= __put_user(from->si_overrun, &to->si_overrun); err \|= __put_user(from->si_ptr, &to->si_ptr); break; case __SI_POLL: err \|= __put_user(from->si_band, &to->si_band); err \|= __put_user(from->si_fd, &to->si_fd); break; case __SI_FAULT: err \|= __put_user(from->si_addr, &to->si_addr); #ifdef __ARCH_SI_TRAPNO err \|= __put_user(from->si_trapno, &to->si_trapno); #endif #ifdef BUS_MCEERR_AO / * Other callers might not initialize the si_lsb field, * so check explicitly for the right codes here. / if (from->si_code == BUS_MCEERR_AR \|\| from->si_code == BUS_MCEERR_AO) err \|= __put_user(from->si_addr_lsb, &to->si_addr_lsb); #endif break; case __SI_CHLD: err \|= __put_user(from->si_pid, &to->si_pid); err \|= __put_user(from->si_uid, &to->si_uid); err \|= __put_user(from->si_status, &to->si_status); err \|= __put_user(from->si_utime, &to->si_utime); err \|= __put_user(from->si_stime, &to->si_stime); break; case __SI_RT: / This is not generated by the kernel as of now. / case __SI_MESGQ: / But this is / err \|= __put_user(from->si_pid, &to->si_pid); err \|= __put_user(from->si_uid, &to->si_uid); err \|= __put_user(from->si_ptr, &to->si_ptr); break; #ifdef __ARCH_SIGSYS case __SI_SYS: err \|= __put_user(from->si_call_addr, &to->si_call_addr); err \|= __put_user(from->si_syscall, &to->si_syscall); err \|= __put_user(from->si_arch, &to->si_arch); break; #endif default: / this is just in case for now ... / err \|= __put_user(from->si_pid, &to->si_pid); err \|= __put_user(from->si_uid, &to->si_uid); break; } return err; } #endif /* * do_sigtimedwait - wait for queued signals specified in @which * @which: queued signals to wait for * @info: if non-null, the signal's siginfo is returned here * @ts: upper bound on process time suspension / int do_sigtimedwait(const sigset_t which, siginfo_t info, const struct timespec ts) { struct task_struct tsk = current; long timeout = MAX_SCHEDULE_TIMEOUT; sigset_t mask = which; int sig; if (ts) { if (!timespec_valid(ts)) return -EINVAL; timeout = timespec_to_jiffies(ts); /* * We can be close to the next tick, add another one * to ensure we will wait at least the time asked for. / if (ts->tv_sec \|\| ts->tv_nsec) timeout++; } / * Invert the set of allowed signals to get those we want to block. / sigdelsetmask(&mask, sigmask(SIGKILL) \| sigmask(SIGSTOP)); signotset(&mask); spin_lock_irq(&tsk->sighand->siglock); sig = dequeue_signal(tsk, &mask, info); if (!sig && timeout) { / * None ready, temporarily unblock those we're interested * while we are sleeping in so that we'll be awakened when * they arrive. Unblocking is always fine, we can avoid * set_current_blocked(). / tsk->real_blocked = tsk->blocked; sigandsets(&tsk->blocked, &tsk->blocked, &mask); recalc_sigpending(); spin_unlock_irq(&tsk->sighand->siglock); timeout = schedule_timeout_interruptible(timeout); spin_lock_irq(&tsk->sighand->siglock); __set_task_blocked(tsk, &tsk->real_blocked); siginitset(&tsk->real_blocked, 0); sig = dequeue_signal(tsk, &mask, info); } spin_unlock_irq(&tsk->sighand->siglock); if (sig) return sig; return timeout ? -EINTR : -EAGAIN; } /* * sys_rt_sigtimedwait - synchronously wait for queued signals specified * in @uthese * @uthese: queued signals to wait for * @uinfo: if non-null, the signal's siginfo is returned here * @uts: upper bound on process time suspension * @sigsetsize: size of sigset_t type / SYSCALL_DEFINE4(rt_sigtimedwait, const sigset_t __user , uthese, siginfo_t __user , uinfo, const struct timespec __user , uts, size_t, sigsetsize) { sigset_t these; struct timespec ts; siginfo_t info; int ret; /* XXX: Don't preclude handling different sized sigset_t's. / if (sigsetsize != sizeof(sigset_t)) return -EINVAL; if (copy_from_user(&these, uthese, sizeof(these))) return -EFAULT; if (uts) { if (copy_from_user(&ts, uts, sizeof(ts))) return -EFAULT; } ret = do_sigtimedwait(&these, &info, uts ? &ts : NULL); if (ret > 0 && uinfo) { if (copy_siginfo_to_user(uinfo, &info)) ret = -EFAULT; } return ret; } /* * sys_kill - send a signal to a process * @pid: the PID of the process * @sig: signal to be sent / SYSCALL_DEFINE2(kill, pid_t, pid, int, sig) { struct siginfo info; info.si_signo = sig; info.si_errno = 0; info.si_code = SI_USER; info.si_pid = task_tgid_vnr(current); info.si_uid = from_kuid_munged(current_user_ns(), current_uid()); return kill_something_info(sig, &info, pid); } static int do_send_specific(pid_t tgid, pid_t pid, int sig, struct siginfo info) { struct task_struct p; int error = -ESRCH; rcu_read_lock(); p = find_task_by_vpid(pid); if (p && (tgid <= 0 \|\| task_tgid_vnr(p) == tgid)) { error = check_kill_permission(sig, info, p); / * The null signal is a permissions and process existence * probe. No signal is actually delivered. / if (!error && sig) { error = do_send_sig_info(sig, info, p, false); / * If lock_task_sighand() failed we pretend the task * dies after receiving the signal. The window is tiny, * and the signal is private anyway. / if (unlikely(error == -ESRCH)) error = 0; } } rcu_read_unlock(); return error; } static int do_tkill(pid_t tgid, pid_t pid, int sig) { struct siginfo info; info.si_signo = sig; info.si_errno = 0; info.si_code = SI_TKILL; info.si_pid = task_tgid_vnr(current); info.si_uid = from_kuid_munged(current_user_ns(), current_uid()); return do_send_specific(tgid, pid, sig, &info); } /* * sys_tgkill - send signal to one specific thread * @tgid: the thread group ID of the thread * @pid: the PID of the thread * @sig: signal to be sent * * This syscall also checks the @tgid and returns -ESRCH even if the PID * exists but it's not belonging to the target process anymore. This * method solves the problem of threads exiting and PIDs getting reused. / SYSCALL_DEFINE3(tgkill, pid_t, tgid, pid_t, pid, int, sig) { / This is only valid for single tasks / if (pid <= 0 \|\| tgid <= 0) return -EINVAL; return do_tkill(tgid, pid, sig); } /* * sys_tkill - send signal to one specific task * @pid: the PID of the task * @sig: signal to be sent * * Send a signal to only one task, even if it's a CLONE_THREAD task. / SYSCALL_DEFINE2(tkill, pid_t, pid, int, sig) { / This is only valid for single tasks / if (pid <= 0) return -EINVAL; return do_tkill(0, pid, sig); } static int do_rt_sigqueueinfo(pid_t pid, int sig, siginfo_t info) { /* Not even root can pretend to send signals from the kernel. * Nor can they impersonate a kill()/tgkill(), which adds source info. / if ((info->si_code >= 0 \|\| info->si_code == SI_TKILL) && (task_pid_vnr(current) != pid)) { / We used to allow any < 0 si_code / WARN_ON_ONCE(info->si_code < 0); return -EPERM; } info->si_signo = sig; / POSIX.1b doesn't mention process groups. / return kill_proc_info(sig, info, pid); } /* * sys_rt_sigqueueinfo - send signal information to a signal * @pid: the PID of the thread * @sig: signal to be sent * @uinfo: signal info to be sent / SYSCALL_DEFINE3(rt_sigqueueinfo, pid_t, pid, int, sig, siginfo_t __user , uinfo) { siginfo_t info; if (copy_from_user(&info, uinfo, sizeof(siginfo_t))) return -EFAULT; return do_rt_sigqueueinfo(pid, sig, &info); } #ifdef CONFIG_COMPAT COMPAT_SYSCALL_DEFINE3(rt_sigqueueinfo, compat_pid_t, pid, int, sig, struct compat_siginfo __user , uinfo) { siginfo_t info; int ret = copy_siginfo_from_user32(&info, uinfo); if (unlikely(ret)) return ret; return do_rt_sigqueueinfo(pid, sig, &info); } #endif static int do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig, siginfo_t info) { /* This is only valid for single tasks / if (pid <= 0 \|\| tgid <= 0) return -EINVAL; / Not even root can pretend to send signals from the kernel. * Nor can they impersonate a kill()/tgkill(), which adds source info. / if (((info->si_code >= 0 \|\| info->si_code == SI_TKILL)) && (task_pid_vnr(current) != pid)) { / We used to allow any < 0 si_code / WARN_ON_ONCE(info->si_code < 0); return -EPERM; } info->si_signo = sig; return do_send_specific(tgid, pid, sig, info); } SYSCALL_DEFINE4(rt_tgsigqueueinfo, pid_t, tgid, pid_t, pid, int, sig, siginfo_t __user , uinfo) { siginfo_t info; if (copy_from_user(&info, uinfo, sizeof(siginfo_t))) return -EFAULT; return do_rt_tgsigqueueinfo(tgid, pid, sig, &info); } #ifdef CONFIG_COMPAT COMPAT_SYSCALL_DEFINE4(rt_tgsigqueueinfo, compat_pid_t, tgid, compat_pid_t, pid, int, sig, struct compat_siginfo __user , uinfo) { siginfo_t info; if (copy_siginfo_from_user32(&info, uinfo)) return -EFAULT; return do_rt_tgsigqueueinfo(tgid, pid, sig, &info); } #endif int do_sigaction(int sig, struct k_sigaction act, struct k_sigaction oact) { struct task_struct t = current; struct k_sigaction k; sigset_t mask; if (!valid_signal(sig) \|\| sig < 1 \|\| (act && sig_kernel_only(sig))) return -EINVAL; k = &t->sighand->action[sig-1]; spin_lock_irq(&current->sighand->siglock); if (oact) oact = k; if (act) { sigdelsetmask(&act->sa.sa_mask, sigmask(SIGKILL) \| sigmask(SIGSTOP)); k = act; / * POSIX 3.3.1.3: * "Setting a signal action to SIG_IGN for a signal that is * pending shall cause the pending signal to be discarded, * whether or not it is blocked." * * "Setting a signal action to SIG_DFL for a signal that is * pending and whose default action is to ignore the signal * (for example, SIGCHLD), shall cause the pending signal to * be discarded, whether or not it is blocked" / if (sig_handler_ignored(sig_handler(t, sig), sig)) { sigemptyset(&mask); sigaddset(&mask, sig); rm_from_queue_full(&mask, &t->signal->shared_pending); do { rm_from_queue_full(&mask, &t->pending); t = next_thread(t); } while (t != current); } } spin_unlock_irq(&current->sighand->siglock); return 0; } static int do_sigaltstack (const stack_t __user uss, stack_t __user uoss, unsigned long sp) { stack_t oss; int error; oss.ss_sp = (void __user ) current->sas_ss_sp; oss.ss_size = current->sas_ss_size; oss.ss_flags = sas_ss_flags(sp); if (uss) { void __user ss_sp; size_t ss_size; int ss_flags; error = -EFAULT; if (!access_ok(VERIFY_READ, uss, sizeof(uss))) goto out; error = __get_user(ss_sp, &uss->ss_sp) \| __get_user(ss_flags, &uss->ss_flags) \| __get_user(ss_size, &uss->ss_size); if (error) goto out; error = -EPERM; if (on_sig_stack(sp)) goto out; error = -EINVAL; /* * Note - this code used to test ss_flags incorrectly: * old code may have been written using ss_flags==0 * to mean ss_flags==SS_ONSTACK (as this was the only * way that worked) - this fix preserves that older * mechanism. / if (ss_flags != SS_DISABLE && ss_flags != SS_ONSTACK && ss_flags != 0) goto out; if (ss_flags == SS_DISABLE) { ss_size = 0; ss_sp = NULL; } else { error = -ENOMEM; if (ss_size < MINSIGSTKSZ) goto out; } current->sas_ss_sp = (unsigned long) ss_sp; current->sas_ss_size = ss_size; } error = 0; if (uoss) { error = -EFAULT; if (!access_ok(VERIFY_WRITE, uoss, sizeof(uoss))) goto out; error = __put_user(oss.ss_sp, &uoss->ss_sp) \| __put_user(oss.ss_size, &uoss->ss_size) \| __put_user(oss.ss_flags, &uoss->ss_flags); } out: return error; } SYSCALL_DEFINE2(sigaltstack,const stack_t __user ,uss, stack_t __user ,uoss) { return do_sigaltstack(uss, uoss, current_user_stack_pointer()); } int restore_altstack(const stack_t __user uss) { int err = do_sigaltstack(uss, NULL, current_user_stack_pointer()); / squash all but EFAULT for now / return err == -EFAULT ? err : 0; } int __save_altstack(stack_t __user uss, unsigned long sp) { struct task_struct t = current; return __put_user((void __user )t->sas_ss_sp, &uss->ss_sp) \| __put_user(sas_ss_flags(sp), &uss->ss_flags) \| __put_user(t->sas_ss_size, &uss->ss_size); } #ifdef CONFIG_COMPAT COMPAT_SYSCALL_DEFINE2(sigaltstack, const compat_stack_t __user , uss_ptr, compat_stack_t __user , uoss_ptr) { stack_t uss, uoss; int ret; mm_segment_t seg; if (uss_ptr) { compat_stack_t uss32; memset(&uss, 0, sizeof(stack_t)); if (copy_from_user(&uss32, uss_ptr, sizeof(compat_stack_t))) return -EFAULT; uss.ss_sp = compat_ptr(uss32.ss_sp); uss.ss_flags = uss32.ss_flags; uss.ss_size = uss32.ss_size; } seg = get_fs(); set_fs(KERNEL_DS); ret = do_sigaltstack((stack_t __force __user ) (uss_ptr ? &uss : NULL), (stack_t __force __user ) &uoss, compat_user_stack_pointer()); set_fs(seg); if (ret >= 0 && uoss_ptr) { if (!access_ok(VERIFY_WRITE, uoss_ptr, sizeof(compat_stack_t)) \|\| __put_user(ptr_to_compat(uoss.ss_sp), &uoss_ptr->ss_sp) \|\| __put_user(uoss.ss_flags, &uoss_ptr->ss_flags) \|\| __put_user(uoss.ss_size, &uoss_ptr->ss_size)) ret = -EFAULT; } return ret; } int compat_restore_altstack(const compat_stack_t __user uss) { int err = compat_sys_sigaltstack(uss, NULL); / squash all but -EFAULT for now / return err == -EFAULT ? err : 0; } int __compat_save_altstack(compat_stack_t __user uss, unsigned long sp) { struct task_struct t = current; return __put_user(ptr_to_compat((void __user )t->sas_ss_sp), &uss->ss_sp) \| __put_user(sas_ss_flags(sp), &uss->ss_flags) \| __put_user(t->sas_ss_size, &uss->ss_size); } #endif #ifdef __ARCH_WANT_SYS_SIGPENDING /** * sys_sigpending - examine pending signals * @set: where mask of pending signal is returned / SYSCALL_DEFINE1(sigpending, old_sigset_t __user , set) { return sys_rt_sigpending((sigset_t __user )set, sizeof(old_sigset_t)); } #endif #ifdef __ARCH_WANT_SYS_SIGPROCMASK /* * sys_sigprocmask - examine and change blocked signals * @how: whether to add, remove, or set signals * @nset: signals to add or remove (if non-null) * @oset: previous value of signal mask if non-null * * Some platforms have their own version with special arguments; * others support only sys_rt_sigprocmask. / SYSCALL_DEFINE3(sigprocmask, int, how, old_sigset_t __user , nset, old_sigset_t __user , oset) { old_sigset_t old_set, new_set; sigset_t new_blocked; old_set = current->blocked.sig[0]; if (nset) { if (copy_from_user(&new_set, nset, sizeof(nset))) return -EFAULT; new_blocked = current->blocked; switch (how) { case SIG_BLOCK: sigaddsetmask(&new_blocked, new_set); break; case SIG_UNBLOCK: sigdelsetmask(&new_blocked, new_set); break; case SIG_SETMASK: new_blocked.sig[0] = new_set; break; default: return -EINVAL; } set_current_blocked(&new_blocked); } if (oset) { if (copy_to_user(oset, &old_set, sizeof(oset))) return -EFAULT; } return 0; } #endif / __ARCH_WANT_SYS_SIGPROCMASK / #ifndef CONFIG_ODD_RT_SIGACTION /* * sys_rt_sigaction - alter an action taken by a process * @sig: signal to be sent * @act: new sigaction * @oact: used to save the previous sigaction * @sigsetsize: size of sigset_t type / SYSCALL_DEFINE4(rt_sigaction, int, sig, const struct sigaction __user , act, struct sigaction __user , oact, size_t, sigsetsize) { struct k_sigaction new_sa, old_sa; int ret = -EINVAL; / XXX: Don't preclude handling different sized sigset_t's. / if (sigsetsize != sizeof(sigset_t)) goto out; if (act) { if (copy_from_user(&new_sa.sa, act, sizeof(new_sa.sa))) return -EFAULT; } ret = do_sigaction(sig, act ? &new_sa : NULL, oact ? &old_sa : NULL); if (!ret && oact) { if (copy_to_user(oact, &old_sa.sa, sizeof(old_sa.sa))) return -EFAULT; } out: return ret; } #ifdef CONFIG_COMPAT COMPAT_SYSCALL_DEFINE4(rt_sigaction, int, sig, const struct compat_sigaction __user , act, struct compat_sigaction __user , oact, compat_size_t, sigsetsize) { struct k_sigaction new_ka, old_ka; compat_sigset_t mask; #ifdef __ARCH_HAS_SA_RESTORER compat_uptr_t restorer; #endif int ret; / XXX: Don't preclude handling different sized sigset_t's. / if (sigsetsize != sizeof(compat_sigset_t)) return -EINVAL; if (act) { compat_uptr_t handler; ret = get_user(handler, &act->sa_handler); new_ka.sa.sa_handler = compat_ptr(handler); #ifdef __ARCH_HAS_SA_RESTORER ret \|= get_user(restorer, &act->sa_restorer); new_ka.sa.sa_restorer = compat_ptr(restorer); #endif ret \|= copy_from_user(&mask, &act->sa_mask, sizeof(mask)); ret \|= __get_user(new_ka.sa.sa_flags, &act->sa_flags); if (ret) return -EFAULT; sigset_from_compat(&new_ka.sa.sa_mask, &mask); } ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); if (!ret && oact) { sigset_to_compat(&mask, &old_ka.sa.sa_mask); ret = put_user(ptr_to_compat(old_ka.sa.sa_handler), &oact->sa_handler); ret \|= copy_to_user(&oact->sa_mask, &mask, sizeof(mask)); ret \|= __put_user(old_ka.sa.sa_flags, &oact->sa_flags); #ifdef __ARCH_HAS_SA_RESTORER ret \|= put_user(ptr_to_compat(old_ka.sa.sa_restorer), &oact->sa_restorer); #endif } return ret; } #endif #endif / !CONFIG_ODD_RT_SIGACTION / #ifdef CONFIG_OLD_SIGACTION SYSCALL_DEFINE3(sigaction, int, sig, const struct old_sigaction __user , act, struct old_sigaction __user , oact) { struct k_sigaction new_ka, old_ka; int ret; if (act) { old_sigset_t mask; if (!access_ok(VERIFY_READ, act, sizeof(act)) \|\| __get_user(new_ka.sa.sa_handler, &act->sa_handler) \|\| __get_user(new_ka.sa.sa_restorer, &act->sa_restorer) \|\| __get_user(new_ka.sa.sa_flags, &act->sa_flags) \|\| __get_user(mask, &act->sa_mask)) return -EFAULT; #ifdef __ARCH_HAS_KA_RESTORER new_ka.ka_restorer = NULL; #endif siginitset(&new_ka.sa.sa_mask, mask); } ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); if (!ret && oact) { if (!access_ok(VERIFY_WRITE, oact, sizeof(oact)) \|\| __put_user(old_ka.sa.sa_handler, &oact->sa_handler) \|\| __put_user(old_ka.sa.sa_restorer, &oact->sa_restorer) \|\| __put_user(old_ka.sa.sa_flags, &oact->sa_flags) \|\| __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask)) return -EFAULT; } return ret; } #endif #ifdef CONFIG_COMPAT_OLD_SIGACTION COMPAT_SYSCALL_DEFINE3(sigaction, int, sig, const struct compat_old_sigaction __user , act, struct compat_old_sigaction __user , oact) { struct k_sigaction new_ka, old_ka; int ret; compat_old_sigset_t mask; compat_uptr_t handler, restorer; if (act) { if (!access_ok(VERIFY_READ, act, sizeof(act)) \|\| __get_user(handler, &act->sa_handler) \|\| __get_user(restorer, &act->sa_restorer) \|\| __get_user(new_ka.sa.sa_flags, &act->sa_flags) \|\| __get_user(mask, &act->sa_mask)) return -EFAULT; #ifdef __ARCH_HAS_KA_RESTORER new_ka.ka_restorer = NULL; #endif new_ka.sa.sa_handler = compat_ptr(handler); new_ka.sa.sa_restorer = compat_ptr(restorer); siginitset(&new_ka.sa.sa_mask, mask); } ret = do_sigaction(sig, act ? &new_ka : NULL, oact ? &old_ka : NULL); if (!ret && oact) { if (!access_ok(VERIFY_WRITE, oact, sizeof(oact)) \|\| __put_user(ptr_to_compat(old_ka.sa.sa_handler), &oact->sa_handler) \|\| __put_user(ptr_to_compat(old_ka.sa.sa_restorer), &oact->sa_restorer) \|\| __put_user(old_ka.sa.sa_flags, &oact->sa_flags) \|\| __put_user(old_ka.sa.sa_mask.sig[0], &oact->sa_mask)) return -EFAULT; } return ret; } #endif #ifdef __ARCH_WANT_SYS_SGETMASK / * For backwards compatibility. Functionality superseded by sigprocmask. / SYSCALL_DEFINE0(sgetmask) { / SMP safe / return current->blocked.sig[0]; } SYSCALL_DEFINE1(ssetmask, int, newmask) { int old = current->blocked.sig[0]; sigset_t newset; siginitset(&newset, newmask); set_current_blocked(&newset); return old; } #endif / __ARCH_WANT_SGETMASK / #ifdef __ARCH_WANT_SYS_SIGNAL / * For backwards compatibility. Functionality superseded by sigaction. / SYSCALL_DEFINE2(signal, int, sig, __sighandler_t, handler) { struct k_sigaction new_sa, old_sa; int ret; new_sa.sa.sa_handler = handler; new_sa.sa.sa_flags = SA_ONESHOT \| SA_NOMASK; sigemptyset(&new_sa.sa.sa_mask); ret = do_sigaction(sig, &new_sa, &old_sa); return ret ? ret : (unsigned long)old_sa.sa.sa_handler; } #endif / __ARCH_WANT_SYS_SIGNAL / #ifdef __ARCH_WANT_SYS_PAUSE SYSCALL_DEFINE0(pause) { while (!signal_pending(current)) { current->state = TASK_INTERRUPTIBLE; schedule(); } return -ERESTARTNOHAND; } #endif int sigsuspend(sigset_t set) { current->saved_sigmask = current->blocked; set_current_blocked(set); current->state = TASK_INTERRUPTIBLE; schedule(); set_restore_sigmask(); return -ERESTARTNOHAND; } /** * sys_rt_sigsuspend - replace the signal mask for a value with the * @unewset value until a signal is received * @unewset: new signal mask value * @sigsetsize: size of sigset_t type / SYSCALL_DEFINE2(rt_sigsuspend, sigset_t __user , unewset, size_t, sigsetsize) { sigset_t newset; /* XXX: Don't preclude handling different sized sigset_t's. / if (sigsetsize != sizeof(sigset_t)) return -EINVAL; if (copy_from_user(&newset, unewset, sizeof(newset))) return -EFAULT; return sigsuspend(&newset); } #ifdef CONFIG_COMPAT COMPAT_SYSCALL_DEFINE2(rt_sigsuspend, compat_sigset_t __user , unewset, compat_size_t, sigsetsize) { #ifdef __BIG_ENDIAN sigset_t newset; compat_sigset_t newset32; /* XXX: Don't preclude handling different sized sigset_t's. / if (sigsetsize != sizeof(sigset_t)) return -EINVAL; if (copy_from_user(&newset32, unewset, sizeof(compat_sigset_t))) return -EFAULT; sigset_from_compat(&newset, &newset32); return sigsuspend(&newset); #else / on little-endian bitmaps don't care about granularity / return sys_rt_sigsuspend((sigset_t __user )unewset, sigsetsize); #endif } #endif #ifdef CONFIG_OLD_SIGSUSPEND SYSCALL_DEFINE1(sigsuspend, old_sigset_t, mask) { sigset_t blocked; siginitset(&blocked, mask); return sigsuspend(&blocked); } #endif #ifdef CONFIG_OLD_SIGSUSPEND3 SYSCALL_DEFINE3(sigsuspend, int, unused1, int, unused2, old_sigset_t, mask) { sigset_t blocked; siginitset(&blocked, mask); return sigsuspend(&blocked); } #endif __attribute__((weak)) const char arch_vma_name(struct vm_area_struct vma) { return NULL; } void __init signals_init(void) { sigqueue_cachep = KMEM_CACHE(sigqueue, SLAB_PANIC); } #ifdef CONFIG_KGDB_KDB #include <linux/kdb.h> /* * kdb_send_sig_info - Allows kdb to send signals without exposing * signal internals. This function checks if the required locks are * available before calling the main signal code, to avoid kdb * deadlocks. / void kdb_send_sig_info(struct task_struct t, struct siginfo info) { static struct task_struct kdb_prev_t; int sig, new_t; if (!spin_trylock(&t->sighand->siglock)) { kdb_printf("Can't do kill command now.\n" "The sigmask lock is held somewhere else in " "kernel, try again later\n"); return; } spin_unlock(&t->sighand->siglock); new_t = kdb_prev_t != t; kdb_prev_t = t; if (t->state != TASK_RUNNING && new_t) { kdb_printf("Process is not RUNNING, sending a signal from " "kdb risks deadlock\n" "on the run queue locks. " "The signal has _not_ been sent.\n" "Reissue the kill command if you want to risk " "the deadlock.\n"); return; } sig = info->si_signo; if (send_sig_info(sig, info, t)) kdb_printf("Fail to deliver Signal %d to process %d.\n", sig, t->pid); else kdb_printf("Signal %d is sent to process %d.\n", sig, t->pid); } #endif /* CONFIG_KGDB_KDB */	./CrossVul/dataset_final_sorted/CWE-264/c/good_5573_0
crossvul-cpp_data_bad_2182_1	/* * Copyright (C) 2012 Daiki Ueno <ueno@unixuser.org> * Copyright (C) 2012 Red Hat, Inc. * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. / #include <libfep/private.h> #include <sys/socket.h> #include <sys/un.h> #include <stdlib.h> #include <stdint.h> #include <stdbool.h> #include <unistd.h> #include <errno.h> #include <stddef.h> / offsetof / #ifndef _LIBC char program_name = "libfep"; #endif /** * SECTION:client * @short_description: Client connection to FEP server / struct _FepClient { int control; FepEventFilter filter; void filter_data; bool filter_running; FepList messages; }; static const FepAttribute empty_attr = { .type = FEP_ATTR_TYPE_NONE, .value = 0, }; /* * fep_client_open: * @address: (allow-none): socket address of the FEP server * * Connect to the FEP server running at @address. If @address is * %NULL, it gets the address from the environment variable * `LIBFEP_CONTROL_SOCK`. * * Returns: a new #FepClient. / FepClient fep_client_open (const char address) { FepClient client; struct sockaddr_un sun; ssize_t sun_len; int retval; if (!address) address = getenv ("LIBFEP_CONTROL_SOCK"); if (!address) return NULL; if (strlen (address) + 1 >= sizeof(sun.sun_path)) { fep_log (FEP_LOG_LEVEL_WARNING, "unix domain socket path too long: %d + 1 >= %d", strlen (address), sizeof (sun.sun_path)); free (address); return NULL; } client = xzalloc (sizeof(FepClient)); client->filter_running = false; client->messages = NULL; memset (&sun, 0, sizeof(struct sockaddr_un)); sun.sun_family = AF_UNIX; #ifdef __linux__ sun.sun_path[0] = '\0'; memcpy (sun.sun_path + 1, address, strlen (address)); sun_len = offsetof (struct sockaddr_un, sun_path) + strlen (address) + 1; #else memcpy (sun.sun_path, address, strlen (address)); sun_len = sizeof (struct sockaddr_un); #endif client->control = socket (AF_UNIX, SOCK_STREAM, 0); if (client->control < 0) { free (client); return NULL; } retval = connect (client->control, (const struct sockaddr ) &sun, sun_len); if (retval < 0) { close (client->control); free (client); return NULL; } return client; } /* * fep_client_set_cursor_text: * @client: a #FepClient * @text: a cursor text * @attr: a #FepAttribute * * Request to display @text at the cursor position on the terminal. / void fep_client_set_cursor_text (FepClient client, const char text, FepAttribute attr) { FepControlMessage message; message.command = FEP_CONTROL_SET_CURSOR_TEXT; _fep_control_message_alloc_args (&message, 2); _fep_control_message_write_string_arg (&message, 0, text, strlen (text) + 1); _fep_control_message_write_attribute_arg (&message, 1, attr ? attr : &empty_attr); if (client->filter_running) client->messages = _fep_append_control_message (client->messages, &message); else _fep_write_control_message (client->control, &message); _fep_control_message_free_args (&message); } /** * fep_client_set_status_text: * @client: a #FepClient * @text: a status text * @attr: a #FepAttribute * * Request to display @text at the bottom of the terminal. / void fep_client_set_status_text (FepClient client, const char text, FepAttribute attr) { FepControlMessage message; message.command = FEP_CONTROL_SET_STATUS_TEXT; _fep_control_message_alloc_args (&message, 2); _fep_control_message_write_string_arg (&message, 0, text, strlen (text) + 1); _fep_control_message_write_attribute_arg (&message, 1, attr ? attr : &empty_attr); if (client->filter_running) client->messages = _fep_append_control_message (client->messages, &message); else _fep_write_control_message (client->control, &message); _fep_control_message_free_args (&message); } /** * fep_client_send_text: * @client: a #FepClient * @text: text to be sent * * Request to send @text to the child process of the FEP server. * @text will be converted from UTF-8 to the local encoding in the * server. / void fep_client_send_text (FepClient client, const char text) { FepControlMessage message; message.command = FEP_CONTROL_SEND_TEXT; _fep_control_message_alloc_args (&message, 1); _fep_control_message_write_string_arg (&message, 0, text, strlen (text) + 1); if (client->filter_running) client->messages = _fep_append_control_message (client->messages, &message); else _fep_write_control_message (client->control, &message); _fep_control_message_free_args (&message); } /* * fep_client_send_data: * @client: a #FepClient * @data: data to be sent * @length: length of @data * * Request to send @data to the child process of the FEP server. / void fep_client_send_data (FepClient client, const char data, size_t length) { FepControlMessage message; message.command = FEP_CONTROL_SEND_DATA; _fep_control_message_alloc_args (&message, 1); _fep_control_message_write_string_arg (&message, 0, data, length); if (client->filter_running) client->messages = _fep_append_control_message (client->messages, &message); else _fep_write_control_message (client->control, &message); _fep_control_message_free_args (&message); } /* * fep_client_forward_key_event: * @client: a #FepClient * @keyval: keysym value * @modifiers: modifiers * * Request to send key event to the child process of the FEP server. / void fep_client_forward_key_event (FepClient client, unsigned int keyval, FepModifierType modifiers) { FepControlMessage message; message.command = FEP_CONTROL_FORWARD_KEY_EVENT; _fep_control_message_alloc_args (&message, 2); _fep_control_message_write_uint32_arg (&message, 0, keyval); _fep_control_message_write_uint32_arg (&message, 1, modifiers); if (client->filter_running) client->messages = _fep_append_control_message (client->messages, &message); else _fep_write_control_message (client->control, &message); _fep_control_message_free_args (&message); } /** * fep_client_set_event_filter: * @client: a #FepClient * @filter: a filter function * @data: user supplied data * * Set a key event filter which will be called when client receives * key events. / void fep_client_set_event_filter (FepClient client, FepEventFilter filter, void data) { client->filter = filter; client->filter_data = data; } /* * fep_client_get_poll_fd: * @client: a #FepClient * * Get the file descriptor of the control socket which can be used by poll(). * * Returns: a file descriptor / int fep_client_get_poll_fd (FepClient client) { return client->control; } static void command_key_event (FepClient client, FepControlMessage request, FepControlMessage response) { FepEventKey event; int retval; uint32_t intval; retval = _fep_control_message_read_uint32_arg (request, 0, &intval); if (retval < 0) { fep_log (FEP_LOG_LEVEL_WARNING, "can't read keyval"); goto out; } event.keyval = intval; retval = _fep_control_message_read_uint32_arg (request, 1, &intval); if (retval < 0) { fep_log (FEP_LOG_LEVEL_WARNING, "can't read modifiers"); goto out; } event.modifiers = intval; out: response->command = FEP_CONTROL_RESPONSE; _fep_control_message_alloc_args (response, 2); _fep_control_message_write_uint8_arg (response, 0, FEP_CONTROL_KEY_EVENT); intval = retval; if (retval == 0 && client->filter) { event.event.type = FEP_KEY_PRESS; event.source = request->args[2].str; event.source_length = request->args[2].len; intval = client->filter ((FepEvent ) &event, client->filter_data); _fep_control_message_write_uint32_arg (response, 1, intval); } /* If key is not handled, send back the original input to the server. / if (intval == 0) fep_client_send_data (client, request->args[2].str, request->args[2].len); } static void command_resize_event (FepClient client, FepControlMessage request, FepControlMessage response) { FepEventResize event; int retval; uint32_t intval; retval = _fep_control_message_read_uint32_arg (request, 0, &intval); if (retval < 0) { fep_log (FEP_LOG_LEVEL_WARNING, "can't read keyval"); goto out; } event.cols = intval; retval = _fep_control_message_read_uint32_arg (request, 1, &intval); if (retval < 0) { fep_log (FEP_LOG_LEVEL_WARNING, "can't read modifiers"); goto out; } event.rows = intval; out: response->command = FEP_CONTROL_RESPONSE; _fep_control_message_alloc_args (response, 2); _fep_control_message_write_uint8_arg (response, 0, FEP_CONTROL_RESIZE_EVENT); intval = retval; if (retval == 0 && client->filter) { event.event.type = FEP_RESIZED; intval = client->filter ((FepEvent ) &event, client->filter_data); _fep_control_message_write_uint32_arg (response, 1, intval); } } /* * fep_client_dispatch: * @client: a #FepClient * * Dispatch a request from server. * * Returns: 0 on success, -1 on failure. / int fep_client_dispatch (FepClient client) { static const struct { FepControlCommand command; void (handler) (FepClient client, FepControlMessage request, FepControlMessage response); } handlers[] = { { FEP_CONTROL_KEY_EVENT, command_key_event }, { FEP_CONTROL_RESIZE_EVENT, command_resize_event }, }; FepControlMessage request, response; int retval; int i; retval = _fep_read_control_message (client->control, &request); if (retval < 0) return -1; for (i = 0; i < SIZEOF (handlers) && handlers[i].command != request.command; i++) ; if (i == SIZEOF (handlers)) { _fep_control_message_free_args (&request); fep_log (FEP_LOG_LEVEL_WARNING, "no handler defined for %d", request.command); return -1; } client->filter_running = true; handlers[i].handler (client, &request, &response); _fep_control_message_free_args (&request); _fep_write_control_message (client->control, &response); _fep_control_message_free_args (&response); client->filter_running = false; /* flush queued messages during handler is executed / while (client->messages) { FepList _head = client->messages; FepControlMessage _message = _head->data; client->messages = _head->next; _fep_write_control_message (client->control, _message); _fep_control_message_free (_message); free (_head); } return retval; } /* * fep_client_close: * @client: a FepClient * * Close the control socket and release the memory allocated for @client. / void fep_client_close (FepClient client) { close (client->control); free (client); }	./CrossVul/dataset_final_sorted/CWE-264/c/bad_2182_1
crossvul-cpp_data_good_5861_45	/* * Cryptographic API. * * AES Cipher Algorithm. * * Based on Brian Gladman's code. * * Linux developers: * Alexander Kjeldaas <astor@fast.no> * Herbert Valerio Riedel <hvr@hvrlab.org> * Kyle McMartin <kyle@debian.org> * Adam J. Richter <adam@yggdrasil.com> (conversion to 2.5 API). * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * --------------------------------------------------------------------------- * Copyright (c) 2002, Dr Brian Gladman <brg@gladman.me.uk>, Worcester, UK. * All rights reserved. * * LICENSE TERMS * * The free distribution and use of this software in both source and binary * form is allowed (with or without changes) provided that: * * 1. distributions of this source code include the above copyright * notice, this list of conditions and the following disclaimer; * * 2. distributions in binary form include the above copyright * notice, this list of conditions and the following disclaimer * in the documentation and/or other associated materials; * * 3. the copyright holder's name is not used to endorse products * built using this software without specific written permission. * * ALTERNATIVELY, provided that this notice is retained in full, this product * may be distributed under the terms of the GNU General Public License (GPL), * in which case the provisions of the GPL apply INSTEAD OF those given above. * * DISCLAIMER * * This software is provided 'as is' with no explicit or implied warranties * in respect of its properties, including, but not limited to, correctness * and/or fitness for purpose. * --------------------------------------------------------------------------- / #include <crypto/aes.h> #include <linux/module.h> #include <linux/init.h> #include <linux/types.h> #include <linux/errno.h> #include <linux/crypto.h> #include <asm/byteorder.h> static inline u8 byte(const u32 x, const unsigned n) { return x >> (n << 3); } static const u32 rco_tab[10] = { 1, 2, 4, 8, 16, 32, 64, 128, 27, 54 }; __visible const u32 crypto_ft_tab[4][256] = { { 0xa56363c6, 0x847c7cf8, 0x997777ee, 0x8d7b7bf6, 0x0df2f2ff, 0xbd6b6bd6, 0xb16f6fde, 0x54c5c591, 0x50303060, 0x03010102, 0xa96767ce, 0x7d2b2b56, 0x19fefee7, 0x62d7d7b5, 0xe6abab4d, 0x9a7676ec, 0x45caca8f, 0x9d82821f, 0x40c9c989, 0x877d7dfa, 0x15fafaef, 0xeb5959b2, 0xc947478e, 0x0bf0f0fb, 0xecadad41, 0x67d4d4b3, 0xfda2a25f, 0xeaafaf45, 0xbf9c9c23, 0xf7a4a453, 0x967272e4, 0x5bc0c09b, 0xc2b7b775, 0x1cfdfde1, 0xae93933d, 0x6a26264c, 0x5a36366c, 0x413f3f7e, 0x02f7f7f5, 0x4fcccc83, 0x5c343468, 0xf4a5a551, 0x34e5e5d1, 0x08f1f1f9, 0x937171e2, 0x73d8d8ab, 0x53313162, 0x3f15152a, 0x0c040408, 0x52c7c795, 0x65232346, 0x5ec3c39d, 0x28181830, 0xa1969637, 0x0f05050a, 0xb59a9a2f, 0x0907070e, 0x36121224, 0x9b80801b, 0x3de2e2df, 0x26ebebcd, 0x6927274e, 0xcdb2b27f, 0x9f7575ea, 0x1b090912, 0x9e83831d, 0x742c2c58, 0x2e1a1a34, 0x2d1b1b36, 0xb26e6edc, 0xee5a5ab4, 0xfba0a05b, 0xf65252a4, 0x4d3b3b76, 0x61d6d6b7, 0xceb3b37d, 0x7b292952, 0x3ee3e3dd, 0x712f2f5e, 0x97848413, 0xf55353a6, 0x68d1d1b9, 0x00000000, 0x2cededc1, 0x60202040, 0x1ffcfce3, 0xc8b1b179, 0xed5b5bb6, 0xbe6a6ad4, 0x46cbcb8d, 0xd9bebe67, 0x4b393972, 0xde4a4a94, 0xd44c4c98, 0xe85858b0, 0x4acfcf85, 0x6bd0d0bb, 0x2aefefc5, 0xe5aaaa4f, 0x16fbfbed, 0xc5434386, 0xd74d4d9a, 0x55333366, 0x94858511, 0xcf45458a, 0x10f9f9e9, 0x06020204, 0x817f7ffe, 0xf05050a0, 0x443c3c78, 0xba9f9f25, 0xe3a8a84b, 0xf35151a2, 0xfea3a35d, 0xc0404080, 0x8a8f8f05, 0xad92923f, 0xbc9d9d21, 0x48383870, 0x04f5f5f1, 0xdfbcbc63, 0xc1b6b677, 0x75dadaaf, 0x63212142, 0x30101020, 0x1affffe5, 0x0ef3f3fd, 0x6dd2d2bf, 0x4ccdcd81, 0x140c0c18, 0x35131326, 0x2fececc3, 0xe15f5fbe, 0xa2979735, 0xcc444488, 0x3917172e, 0x57c4c493, 0xf2a7a755, 0x827e7efc, 0x473d3d7a, 0xac6464c8, 0xe75d5dba, 0x2b191932, 0x957373e6, 0xa06060c0, 0x98818119, 0xd14f4f9e, 0x7fdcdca3, 0x66222244, 0x7e2a2a54, 0xab90903b, 0x8388880b, 0xca46468c, 0x29eeeec7, 0xd3b8b86b, 0x3c141428, 0x79dedea7, 0xe25e5ebc, 0x1d0b0b16, 0x76dbdbad, 0x3be0e0db, 0x56323264, 0x4e3a3a74, 0x1e0a0a14, 0xdb494992, 0x0a06060c, 0x6c242448, 0xe45c5cb8, 0x5dc2c29f, 0x6ed3d3bd, 0xefacac43, 0xa66262c4, 0xa8919139, 0xa4959531, 0x37e4e4d3, 0x8b7979f2, 0x32e7e7d5, 0x43c8c88b, 0x5937376e, 0xb76d6dda, 0x8c8d8d01, 0x64d5d5b1, 0xd24e4e9c, 0xe0a9a949, 0xb46c6cd8, 0xfa5656ac, 0x07f4f4f3, 0x25eaeacf, 0xaf6565ca, 0x8e7a7af4, 0xe9aeae47, 0x18080810, 0xd5baba6f, 0x887878f0, 0x6f25254a, 0x722e2e5c, 0x241c1c38, 0xf1a6a657, 0xc7b4b473, 0x51c6c697, 0x23e8e8cb, 0x7cdddda1, 0x9c7474e8, 0x211f1f3e, 0xdd4b4b96, 0xdcbdbd61, 0x868b8b0d, 0x858a8a0f, 0x907070e0, 0x423e3e7c, 0xc4b5b571, 0xaa6666cc, 0xd8484890, 0x05030306, 0x01f6f6f7, 0x120e0e1c, 0xa36161c2, 0x5f35356a, 0xf95757ae, 0xd0b9b969, 0x91868617, 0x58c1c199, 0x271d1d3a, 0xb99e9e27, 0x38e1e1d9, 0x13f8f8eb, 0xb398982b, 0x33111122, 0xbb6969d2, 0x70d9d9a9, 0x898e8e07, 0xa7949433, 0xb69b9b2d, 0x221e1e3c, 0x92878715, 0x20e9e9c9, 0x49cece87, 0xff5555aa, 0x78282850, 0x7adfdfa5, 0x8f8c8c03, 0xf8a1a159, 0x80898909, 0x170d0d1a, 0xdabfbf65, 0x31e6e6d7, 0xc6424284, 0xb86868d0, 0xc3414182, 0xb0999929, 0x772d2d5a, 0x110f0f1e, 0xcbb0b07b, 0xfc5454a8, 0xd6bbbb6d, 0x3a16162c, }, { 0x6363c6a5, 0x7c7cf884, 0x7777ee99, 0x7b7bf68d, 0xf2f2ff0d, 0x6b6bd6bd, 0x6f6fdeb1, 0xc5c59154, 0x30306050, 0x01010203, 0x6767cea9, 0x2b2b567d, 0xfefee719, 0xd7d7b562, 0xabab4de6, 0x7676ec9a, 0xcaca8f45, 0x82821f9d, 0xc9c98940, 0x7d7dfa87, 0xfafaef15, 0x5959b2eb, 0x47478ec9, 0xf0f0fb0b, 0xadad41ec, 0xd4d4b367, 0xa2a25ffd, 0xafaf45ea, 0x9c9c23bf, 0xa4a453f7, 0x7272e496, 0xc0c09b5b, 0xb7b775c2, 0xfdfde11c, 0x93933dae, 0x26264c6a, 0x36366c5a, 0x3f3f7e41, 0xf7f7f502, 0xcccc834f, 0x3434685c, 0xa5a551f4, 0xe5e5d134, 0xf1f1f908, 0x7171e293, 0xd8d8ab73, 0x31316253, 0x15152a3f, 0x0404080c, 0xc7c79552, 0x23234665, 0xc3c39d5e, 0x18183028, 0x969637a1, 0x05050a0f, 0x9a9a2fb5, 0x07070e09, 0x12122436, 0x80801b9b, 0xe2e2df3d, 0xebebcd26, 0x27274e69, 0xb2b27fcd, 0x7575ea9f, 0x0909121b, 0x83831d9e, 0x2c2c5874, 0x1a1a342e, 0x1b1b362d, 0x6e6edcb2, 0x5a5ab4ee, 0xa0a05bfb, 0x5252a4f6, 0x3b3b764d, 0xd6d6b761, 0xb3b37dce, 0x2929527b, 0xe3e3dd3e, 0x2f2f5e71, 0x84841397, 0x5353a6f5, 0xd1d1b968, 0x00000000, 0xededc12c, 0x20204060, 0xfcfce31f, 0xb1b179c8, 0x5b5bb6ed, 0x6a6ad4be, 0xcbcb8d46, 0xbebe67d9, 0x3939724b, 0x4a4a94de, 0x4c4c98d4, 0x5858b0e8, 0xcfcf854a, 0xd0d0bb6b, 0xefefc52a, 0xaaaa4fe5, 0xfbfbed16, 0x434386c5, 0x4d4d9ad7, 0x33336655, 0x85851194, 0x45458acf, 0xf9f9e910, 0x02020406, 0x7f7ffe81, 0x5050a0f0, 0x3c3c7844, 0x9f9f25ba, 0xa8a84be3, 0x5151a2f3, 0xa3a35dfe, 0x404080c0, 0x8f8f058a, 0x92923fad, 0x9d9d21bc, 0x38387048, 0xf5f5f104, 0xbcbc63df, 0xb6b677c1, 0xdadaaf75, 0x21214263, 0x10102030, 0xffffe51a, 0xf3f3fd0e, 0xd2d2bf6d, 0xcdcd814c, 0x0c0c1814, 0x13132635, 0xececc32f, 0x5f5fbee1, 0x979735a2, 0x444488cc, 0x17172e39, 0xc4c49357, 0xa7a755f2, 0x7e7efc82, 0x3d3d7a47, 0x6464c8ac, 0x5d5dbae7, 0x1919322b, 0x7373e695, 0x6060c0a0, 0x81811998, 0x4f4f9ed1, 0xdcdca37f, 0x22224466, 0x2a2a547e, 0x90903bab, 0x88880b83, 0x46468cca, 0xeeeec729, 0xb8b86bd3, 0x1414283c, 0xdedea779, 0x5e5ebce2, 0x0b0b161d, 0xdbdbad76, 0xe0e0db3b, 0x32326456, 0x3a3a744e, 0x0a0a141e, 0x494992db, 0x06060c0a, 0x2424486c, 0x5c5cb8e4, 0xc2c29f5d, 0xd3d3bd6e, 0xacac43ef, 0x6262c4a6, 0x919139a8, 0x959531a4, 0xe4e4d337, 0x7979f28b, 0xe7e7d532, 0xc8c88b43, 0x37376e59, 0x6d6ddab7, 0x8d8d018c, 0xd5d5b164, 0x4e4e9cd2, 0xa9a949e0, 0x6c6cd8b4, 0x5656acfa, 0xf4f4f307, 0xeaeacf25, 0x6565caaf, 0x7a7af48e, 0xaeae47e9, 0x08081018, 0xbaba6fd5, 0x7878f088, 0x25254a6f, 0x2e2e5c72, 0x1c1c3824, 0xa6a657f1, 0xb4b473c7, 0xc6c69751, 0xe8e8cb23, 0xdddda17c, 0x7474e89c, 0x1f1f3e21, 0x4b4b96dd, 0xbdbd61dc, 0x8b8b0d86, 0x8a8a0f85, 0x7070e090, 0x3e3e7c42, 0xb5b571c4, 0x6666ccaa, 0x484890d8, 0x03030605, 0xf6f6f701, 0x0e0e1c12, 0x6161c2a3, 0x35356a5f, 0x5757aef9, 0xb9b969d0, 0x86861791, 0xc1c19958, 0x1d1d3a27, 0x9e9e27b9, 0xe1e1d938, 0xf8f8eb13, 0x98982bb3, 0x11112233, 0x6969d2bb, 0xd9d9a970, 0x8e8e0789, 0x949433a7, 0x9b9b2db6, 0x1e1e3c22, 0x87871592, 0xe9e9c920, 0xcece8749, 0x5555aaff, 0x28285078, 0xdfdfa57a, 0x8c8c038f, 0xa1a159f8, 0x89890980, 0x0d0d1a17, 0xbfbf65da, 0xe6e6d731, 0x424284c6, 0x6868d0b8, 0x414182c3, 0x999929b0, 0x2d2d5a77, 0x0f0f1e11, 0xb0b07bcb, 0x5454a8fc, 0xbbbb6dd6, 0x16162c3a, }, { 0x63c6a563, 0x7cf8847c, 0x77ee9977, 0x7bf68d7b, 0xf2ff0df2, 0x6bd6bd6b, 0x6fdeb16f, 0xc59154c5, 0x30605030, 0x01020301, 0x67cea967, 0x2b567d2b, 0xfee719fe, 0xd7b562d7, 0xab4de6ab, 0x76ec9a76, 0xca8f45ca, 0x821f9d82, 0xc98940c9, 0x7dfa877d, 0xfaef15fa, 0x59b2eb59, 0x478ec947, 0xf0fb0bf0, 0xad41ecad, 0xd4b367d4, 0xa25ffda2, 0xaf45eaaf, 0x9c23bf9c, 0xa453f7a4, 0x72e49672, 0xc09b5bc0, 0xb775c2b7, 0xfde11cfd, 0x933dae93, 0x264c6a26, 0x366c5a36, 0x3f7e413f, 0xf7f502f7, 0xcc834fcc, 0x34685c34, 0xa551f4a5, 0xe5d134e5, 0xf1f908f1, 0x71e29371, 0xd8ab73d8, 0x31625331, 0x152a3f15, 0x04080c04, 0xc79552c7, 0x23466523, 0xc39d5ec3, 0x18302818, 0x9637a196, 0x050a0f05, 0x9a2fb59a, 0x070e0907, 0x12243612, 0x801b9b80, 0xe2df3de2, 0xebcd26eb, 0x274e6927, 0xb27fcdb2, 0x75ea9f75, 0x09121b09, 0x831d9e83, 0x2c58742c, 0x1a342e1a, 0x1b362d1b, 0x6edcb26e, 0x5ab4ee5a, 0xa05bfba0, 0x52a4f652, 0x3b764d3b, 0xd6b761d6, 0xb37dceb3, 0x29527b29, 0xe3dd3ee3, 0x2f5e712f, 0x84139784, 0x53a6f553, 0xd1b968d1, 0x00000000, 0xedc12ced, 0x20406020, 0xfce31ffc, 0xb179c8b1, 0x5bb6ed5b, 0x6ad4be6a, 0xcb8d46cb, 0xbe67d9be, 0x39724b39, 0x4a94de4a, 0x4c98d44c, 0x58b0e858, 0xcf854acf, 0xd0bb6bd0, 0xefc52aef, 0xaa4fe5aa, 0xfbed16fb, 0x4386c543, 0x4d9ad74d, 0x33665533, 0x85119485, 0x458acf45, 0xf9e910f9, 0x02040602, 0x7ffe817f, 0x50a0f050, 0x3c78443c, 0x9f25ba9f, 0xa84be3a8, 0x51a2f351, 0xa35dfea3, 0x4080c040, 0x8f058a8f, 0x923fad92, 0x9d21bc9d, 0x38704838, 0xf5f104f5, 0xbc63dfbc, 0xb677c1b6, 0xdaaf75da, 0x21426321, 0x10203010, 0xffe51aff, 0xf3fd0ef3, 0xd2bf6dd2, 0xcd814ccd, 0x0c18140c, 0x13263513, 0xecc32fec, 0x5fbee15f, 0x9735a297, 0x4488cc44, 0x172e3917, 0xc49357c4, 0xa755f2a7, 0x7efc827e, 0x3d7a473d, 0x64c8ac64, 0x5dbae75d, 0x19322b19, 0x73e69573, 0x60c0a060, 0x81199881, 0x4f9ed14f, 0xdca37fdc, 0x22446622, 0x2a547e2a, 0x903bab90, 0x880b8388, 0x468cca46, 0xeec729ee, 0xb86bd3b8, 0x14283c14, 0xdea779de, 0x5ebce25e, 0x0b161d0b, 0xdbad76db, 0xe0db3be0, 0x32645632, 0x3a744e3a, 0x0a141e0a, 0x4992db49, 0x060c0a06, 0x24486c24, 0x5cb8e45c, 0xc29f5dc2, 0xd3bd6ed3, 0xac43efac, 0x62c4a662, 0x9139a891, 0x9531a495, 0xe4d337e4, 0x79f28b79, 0xe7d532e7, 0xc88b43c8, 0x376e5937, 0x6ddab76d, 0x8d018c8d, 0xd5b164d5, 0x4e9cd24e, 0xa949e0a9, 0x6cd8b46c, 0x56acfa56, 0xf4f307f4, 0xeacf25ea, 0x65caaf65, 0x7af48e7a, 0xae47e9ae, 0x08101808, 0xba6fd5ba, 0x78f08878, 0x254a6f25, 0x2e5c722e, 0x1c38241c, 0xa657f1a6, 0xb473c7b4, 0xc69751c6, 0xe8cb23e8, 0xdda17cdd, 0x74e89c74, 0x1f3e211f, 0x4b96dd4b, 0xbd61dcbd, 0x8b0d868b, 0x8a0f858a, 0x70e09070, 0x3e7c423e, 0xb571c4b5, 0x66ccaa66, 0x4890d848, 0x03060503, 0xf6f701f6, 0x0e1c120e, 0x61c2a361, 0x356a5f35, 0x57aef957, 0xb969d0b9, 0x86179186, 0xc19958c1, 0x1d3a271d, 0x9e27b99e, 0xe1d938e1, 0xf8eb13f8, 0x982bb398, 0x11223311, 0x69d2bb69, 0xd9a970d9, 0x8e07898e, 0x9433a794, 0x9b2db69b, 0x1e3c221e, 0x87159287, 0xe9c920e9, 0xce8749ce, 0x55aaff55, 0x28507828, 0xdfa57adf, 0x8c038f8c, 0xa159f8a1, 0x89098089, 0x0d1a170d, 0xbf65dabf, 0xe6d731e6, 0x4284c642, 0x68d0b868, 0x4182c341, 0x9929b099, 0x2d5a772d, 0x0f1e110f, 0xb07bcbb0, 0x54a8fc54, 0xbb6dd6bb, 0x162c3a16, }, { 0xc6a56363, 0xf8847c7c, 0xee997777, 0xf68d7b7b, 0xff0df2f2, 0xd6bd6b6b, 0xdeb16f6f, 0x9154c5c5, 0x60503030, 0x02030101, 0xcea96767, 0x567d2b2b, 0xe719fefe, 0xb562d7d7, 0x4de6abab, 0xec9a7676, 0x8f45caca, 0x1f9d8282, 0x8940c9c9, 0xfa877d7d, 0xef15fafa, 0xb2eb5959, 0x8ec94747, 0xfb0bf0f0, 0x41ecadad, 0xb367d4d4, 0x5ffda2a2, 0x45eaafaf, 0x23bf9c9c, 0x53f7a4a4, 0xe4967272, 0x9b5bc0c0, 0x75c2b7b7, 0xe11cfdfd, 0x3dae9393, 0x4c6a2626, 0x6c5a3636, 0x7e413f3f, 0xf502f7f7, 0x834fcccc, 0x685c3434, 0x51f4a5a5, 0xd134e5e5, 0xf908f1f1, 0xe2937171, 0xab73d8d8, 0x62533131, 0x2a3f1515, 0x080c0404, 0x9552c7c7, 0x46652323, 0x9d5ec3c3, 0x30281818, 0x37a19696, 0x0a0f0505, 0x2fb59a9a, 0x0e090707, 0x24361212, 0x1b9b8080, 0xdf3de2e2, 0xcd26ebeb, 0x4e692727, 0x7fcdb2b2, 0xea9f7575, 0x121b0909, 0x1d9e8383, 0x58742c2c, 0x342e1a1a, 0x362d1b1b, 0xdcb26e6e, 0xb4ee5a5a, 0x5bfba0a0, 0xa4f65252, 0x764d3b3b, 0xb761d6d6, 0x7dceb3b3, 0x527b2929, 0xdd3ee3e3, 0x5e712f2f, 0x13978484, 0xa6f55353, 0xb968d1d1, 0x00000000, 0xc12ceded, 0x40602020, 0xe31ffcfc, 0x79c8b1b1, 0xb6ed5b5b, 0xd4be6a6a, 0x8d46cbcb, 0x67d9bebe, 0x724b3939, 0x94de4a4a, 0x98d44c4c, 0xb0e85858, 0x854acfcf, 0xbb6bd0d0, 0xc52aefef, 0x4fe5aaaa, 0xed16fbfb, 0x86c54343, 0x9ad74d4d, 0x66553333, 0x11948585, 0x8acf4545, 0xe910f9f9, 0x04060202, 0xfe817f7f, 0xa0f05050, 0x78443c3c, 0x25ba9f9f, 0x4be3a8a8, 0xa2f35151, 0x5dfea3a3, 0x80c04040, 0x058a8f8f, 0x3fad9292, 0x21bc9d9d, 0x70483838, 0xf104f5f5, 0x63dfbcbc, 0x77c1b6b6, 0xaf75dada, 0x42632121, 0x20301010, 0xe51affff, 0xfd0ef3f3, 0xbf6dd2d2, 0x814ccdcd, 0x18140c0c, 0x26351313, 0xc32fecec, 0xbee15f5f, 0x35a29797, 0x88cc4444, 0x2e391717, 0x9357c4c4, 0x55f2a7a7, 0xfc827e7e, 0x7a473d3d, 0xc8ac6464, 0xbae75d5d, 0x322b1919, 0xe6957373, 0xc0a06060, 0x19988181, 0x9ed14f4f, 0xa37fdcdc, 0x44662222, 0x547e2a2a, 0x3bab9090, 0x0b838888, 0x8cca4646, 0xc729eeee, 0x6bd3b8b8, 0x283c1414, 0xa779dede, 0xbce25e5e, 0x161d0b0b, 0xad76dbdb, 0xdb3be0e0, 0x64563232, 0x744e3a3a, 0x141e0a0a, 0x92db4949, 0x0c0a0606, 0x486c2424, 0xb8e45c5c, 0x9f5dc2c2, 0xbd6ed3d3, 0x43efacac, 0xc4a66262, 0x39a89191, 0x31a49595, 0xd337e4e4, 0xf28b7979, 0xd532e7e7, 0x8b43c8c8, 0x6e593737, 0xdab76d6d, 0x018c8d8d, 0xb164d5d5, 0x9cd24e4e, 0x49e0a9a9, 0xd8b46c6c, 0xacfa5656, 0xf307f4f4, 0xcf25eaea, 0xcaaf6565, 0xf48e7a7a, 0x47e9aeae, 0x10180808, 0x6fd5baba, 0xf0887878, 0x4a6f2525, 0x5c722e2e, 0x38241c1c, 0x57f1a6a6, 0x73c7b4b4, 0x9751c6c6, 0xcb23e8e8, 0xa17cdddd, 0xe89c7474, 0x3e211f1f, 0x96dd4b4b, 0x61dcbdbd, 0x0d868b8b, 0x0f858a8a, 0xe0907070, 0x7c423e3e, 0x71c4b5b5, 0xccaa6666, 0x90d84848, 0x06050303, 0xf701f6f6, 0x1c120e0e, 0xc2a36161, 0x6a5f3535, 0xaef95757, 0x69d0b9b9, 0x17918686, 0x9958c1c1, 0x3a271d1d, 0x27b99e9e, 0xd938e1e1, 0xeb13f8f8, 0x2bb39898, 0x22331111, 0xd2bb6969, 0xa970d9d9, 0x07898e8e, 0x33a79494, 0x2db69b9b, 0x3c221e1e, 0x15928787, 0xc920e9e9, 0x8749cece, 0xaaff5555, 0x50782828, 0xa57adfdf, 0x038f8c8c, 0x59f8a1a1, 0x09808989, 0x1a170d0d, 0x65dabfbf, 0xd731e6e6, 0x84c64242, 0xd0b86868, 0x82c34141, 0x29b09999, 0x5a772d2d, 0x1e110f0f, 0x7bcbb0b0, 0xa8fc5454, 0x6dd6bbbb, 0x2c3a1616, } }; __visible const u32 crypto_fl_tab[4][256] = { { 0x00000063, 0x0000007c, 0x00000077, 0x0000007b, 0x000000f2, 0x0000006b, 0x0000006f, 0x000000c5, 0x00000030, 0x00000001, 0x00000067, 0x0000002b, 0x000000fe, 0x000000d7, 0x000000ab, 0x00000076, 0x000000ca, 0x00000082, 0x000000c9, 0x0000007d, 0x000000fa, 0x00000059, 0x00000047, 0x000000f0, 0x000000ad, 0x000000d4, 0x000000a2, 0x000000af, 0x0000009c, 0x000000a4, 0x00000072, 0x000000c0, 0x000000b7, 0x000000fd, 0x00000093, 0x00000026, 0x00000036, 0x0000003f, 0x000000f7, 0x000000cc, 0x00000034, 0x000000a5, 0x000000e5, 0x000000f1, 0x00000071, 0x000000d8, 0x00000031, 0x00000015, 0x00000004, 0x000000c7, 0x00000023, 0x000000c3, 0x00000018, 0x00000096, 0x00000005, 0x0000009a, 0x00000007, 0x00000012, 0x00000080, 0x000000e2, 0x000000eb, 0x00000027, 0x000000b2, 0x00000075, 0x00000009, 0x00000083, 0x0000002c, 0x0000001a, 0x0000001b, 0x0000006e, 0x0000005a, 0x000000a0, 0x00000052, 0x0000003b, 0x000000d6, 0x000000b3, 0x00000029, 0x000000e3, 0x0000002f, 0x00000084, 0x00000053, 0x000000d1, 0x00000000, 0x000000ed, 0x00000020, 0x000000fc, 0x000000b1, 0x0000005b, 0x0000006a, 0x000000cb, 0x000000be, 0x00000039, 0x0000004a, 0x0000004c, 0x00000058, 0x000000cf, 0x000000d0, 0x000000ef, 0x000000aa, 0x000000fb, 0x00000043, 0x0000004d, 0x00000033, 0x00000085, 0x00000045, 0x000000f9, 0x00000002, 0x0000007f, 0x00000050, 0x0000003c, 0x0000009f, 0x000000a8, 0x00000051, 0x000000a3, 0x00000040, 0x0000008f, 0x00000092, 0x0000009d, 0x00000038, 0x000000f5, 0x000000bc, 0x000000b6, 0x000000da, 0x00000021, 0x00000010, 0x000000ff, 0x000000f3, 0x000000d2, 0x000000cd, 0x0000000c, 0x00000013, 0x000000ec, 0x0000005f, 0x00000097, 0x00000044, 0x00000017, 0x000000c4, 0x000000a7, 0x0000007e, 0x0000003d, 0x00000064, 0x0000005d, 0x00000019, 0x00000073, 0x00000060, 0x00000081, 0x0000004f, 0x000000dc, 0x00000022, 0x0000002a, 0x00000090, 0x00000088, 0x00000046, 0x000000ee, 0x000000b8, 0x00000014, 0x000000de, 0x0000005e, 0x0000000b, 0x000000db, 0x000000e0, 0x00000032, 0x0000003a, 0x0000000a, 0x00000049, 0x00000006, 0x00000024, 0x0000005c, 0x000000c2, 0x000000d3, 0x000000ac, 0x00000062, 0x00000091, 0x00000095, 0x000000e4, 0x00000079, 0x000000e7, 0x000000c8, 0x00000037, 0x0000006d, 0x0000008d, 0x000000d5, 0x0000004e, 0x000000a9, 0x0000006c, 0x00000056, 0x000000f4, 0x000000ea, 0x00000065, 0x0000007a, 0x000000ae, 0x00000008, 0x000000ba, 0x00000078, 0x00000025, 0x0000002e, 0x0000001c, 0x000000a6, 0x000000b4, 0x000000c6, 0x000000e8, 0x000000dd, 0x00000074, 0x0000001f, 0x0000004b, 0x000000bd, 0x0000008b, 0x0000008a, 0x00000070, 0x0000003e, 0x000000b5, 0x00000066, 0x00000048, 0x00000003, 0x000000f6, 0x0000000e, 0x00000061, 0x00000035, 0x00000057, 0x000000b9, 0x00000086, 0x000000c1, 0x0000001d, 0x0000009e, 0x000000e1, 0x000000f8, 0x00000098, 0x00000011, 0x00000069, 0x000000d9, 0x0000008e, 0x00000094, 0x0000009b, 0x0000001e, 0x00000087, 0x000000e9, 0x000000ce, 0x00000055, 0x00000028, 0x000000df, 0x0000008c, 0x000000a1, 0x00000089, 0x0000000d, 0x000000bf, 0x000000e6, 0x00000042, 0x00000068, 0x00000041, 0x00000099, 0x0000002d, 0x0000000f, 0x000000b0, 0x00000054, 0x000000bb, 0x00000016, }, { 0x00006300, 0x00007c00, 0x00007700, 0x00007b00, 0x0000f200, 0x00006b00, 0x00006f00, 0x0000c500, 0x00003000, 0x00000100, 0x00006700, 0x00002b00, 0x0000fe00, 0x0000d700, 0x0000ab00, 0x00007600, 0x0000ca00, 0x00008200, 0x0000c900, 0x00007d00, 0x0000fa00, 0x00005900, 0x00004700, 0x0000f000, 0x0000ad00, 0x0000d400, 0x0000a200, 0x0000af00, 0x00009c00, 0x0000a400, 0x00007200, 0x0000c000, 0x0000b700, 0x0000fd00, 0x00009300, 0x00002600, 0x00003600, 0x00003f00, 0x0000f700, 0x0000cc00, 0x00003400, 0x0000a500, 0x0000e500, 0x0000f100, 0x00007100, 0x0000d800, 0x00003100, 0x00001500, 0x00000400, 0x0000c700, 0x00002300, 0x0000c300, 0x00001800, 0x00009600, 0x00000500, 0x00009a00, 0x00000700, 0x00001200, 0x00008000, 0x0000e200, 0x0000eb00, 0x00002700, 0x0000b200, 0x00007500, 0x00000900, 0x00008300, 0x00002c00, 0x00001a00, 0x00001b00, 0x00006e00, 0x00005a00, 0x0000a000, 0x00005200, 0x00003b00, 0x0000d600, 0x0000b300, 0x00002900, 0x0000e300, 0x00002f00, 0x00008400, 0x00005300, 0x0000d100, 0x00000000, 0x0000ed00, 0x00002000, 0x0000fc00, 0x0000b100, 0x00005b00, 0x00006a00, 0x0000cb00, 0x0000be00, 0x00003900, 0x00004a00, 0x00004c00, 0x00005800, 0x0000cf00, 0x0000d000, 0x0000ef00, 0x0000aa00, 0x0000fb00, 0x00004300, 0x00004d00, 0x00003300, 0x00008500, 0x00004500, 0x0000f900, 0x00000200, 0x00007f00, 0x00005000, 0x00003c00, 0x00009f00, 0x0000a800, 0x00005100, 0x0000a300, 0x00004000, 0x00008f00, 0x00009200, 0x00009d00, 0x00003800, 0x0000f500, 0x0000bc00, 0x0000b600, 0x0000da00, 0x00002100, 0x00001000, 0x0000ff00, 0x0000f300, 0x0000d200, 0x0000cd00, 0x00000c00, 0x00001300, 0x0000ec00, 0x00005f00, 0x00009700, 0x00004400, 0x00001700, 0x0000c400, 0x0000a700, 0x00007e00, 0x00003d00, 0x00006400, 0x00005d00, 0x00001900, 0x00007300, 0x00006000, 0x00008100, 0x00004f00, 0x0000dc00, 0x00002200, 0x00002a00, 0x00009000, 0x00008800, 0x00004600, 0x0000ee00, 0x0000b800, 0x00001400, 0x0000de00, 0x00005e00, 0x00000b00, 0x0000db00, 0x0000e000, 0x00003200, 0x00003a00, 0x00000a00, 0x00004900, 0x00000600, 0x00002400, 0x00005c00, 0x0000c200, 0x0000d300, 0x0000ac00, 0x00006200, 0x00009100, 0x00009500, 0x0000e400, 0x00007900, 0x0000e700, 0x0000c800, 0x00003700, 0x00006d00, 0x00008d00, 0x0000d500, 0x00004e00, 0x0000a900, 0x00006c00, 0x00005600, 0x0000f400, 0x0000ea00, 0x00006500, 0x00007a00, 0x0000ae00, 0x00000800, 0x0000ba00, 0x00007800, 0x00002500, 0x00002e00, 0x00001c00, 0x0000a600, 0x0000b400, 0x0000c600, 0x0000e800, 0x0000dd00, 0x00007400, 0x00001f00, 0x00004b00, 0x0000bd00, 0x00008b00, 0x00008a00, 0x00007000, 0x00003e00, 0x0000b500, 0x00006600, 0x00004800, 0x00000300, 0x0000f600, 0x00000e00, 0x00006100, 0x00003500, 0x00005700, 0x0000b900, 0x00008600, 0x0000c100, 0x00001d00, 0x00009e00, 0x0000e100, 0x0000f800, 0x00009800, 0x00001100, 0x00006900, 0x0000d900, 0x00008e00, 0x00009400, 0x00009b00, 0x00001e00, 0x00008700, 0x0000e900, 0x0000ce00, 0x00005500, 0x00002800, 0x0000df00, 0x00008c00, 0x0000a100, 0x00008900, 0x00000d00, 0x0000bf00, 0x0000e600, 0x00004200, 0x00006800, 0x00004100, 0x00009900, 0x00002d00, 0x00000f00, 0x0000b000, 0x00005400, 0x0000bb00, 0x00001600, }, { 0x00630000, 0x007c0000, 0x00770000, 0x007b0000, 0x00f20000, 0x006b0000, 0x006f0000, 0x00c50000, 0x00300000, 0x00010000, 0x00670000, 0x002b0000, 0x00fe0000, 0x00d70000, 0x00ab0000, 0x00760000, 0x00ca0000, 0x00820000, 0x00c90000, 0x007d0000, 0x00fa0000, 0x00590000, 0x00470000, 0x00f00000, 0x00ad0000, 0x00d40000, 0x00a20000, 0x00af0000, 0x009c0000, 0x00a40000, 0x00720000, 0x00c00000, 0x00b70000, 0x00fd0000, 0x00930000, 0x00260000, 0x00360000, 0x003f0000, 0x00f70000, 0x00cc0000, 0x00340000, 0x00a50000, 0x00e50000, 0x00f10000, 0x00710000, 0x00d80000, 0x00310000, 0x00150000, 0x00040000, 0x00c70000, 0x00230000, 0x00c30000, 0x00180000, 0x00960000, 0x00050000, 0x009a0000, 0x00070000, 0x00120000, 0x00800000, 0x00e20000, 0x00eb0000, 0x00270000, 0x00b20000, 0x00750000, 0x00090000, 0x00830000, 0x002c0000, 0x001a0000, 0x001b0000, 0x006e0000, 0x005a0000, 0x00a00000, 0x00520000, 0x003b0000, 0x00d60000, 0x00b30000, 0x00290000, 0x00e30000, 0x002f0000, 0x00840000, 0x00530000, 0x00d10000, 0x00000000, 0x00ed0000, 0x00200000, 0x00fc0000, 0x00b10000, 0x005b0000, 0x006a0000, 0x00cb0000, 0x00be0000, 0x00390000, 0x004a0000, 0x004c0000, 0x00580000, 0x00cf0000, 0x00d00000, 0x00ef0000, 0x00aa0000, 0x00fb0000, 0x00430000, 0x004d0000, 0x00330000, 0x00850000, 0x00450000, 0x00f90000, 0x00020000, 0x007f0000, 0x00500000, 0x003c0000, 0x009f0000, 0x00a80000, 0x00510000, 0x00a30000, 0x00400000, 0x008f0000, 0x00920000, 0x009d0000, 0x00380000, 0x00f50000, 0x00bc0000, 0x00b60000, 0x00da0000, 0x00210000, 0x00100000, 0x00ff0000, 0x00f30000, 0x00d20000, 0x00cd0000, 0x000c0000, 0x00130000, 0x00ec0000, 0x005f0000, 0x00970000, 0x00440000, 0x00170000, 0x00c40000, 0x00a70000, 0x007e0000, 0x003d0000, 0x00640000, 0x005d0000, 0x00190000, 0x00730000, 0x00600000, 0x00810000, 0x004f0000, 0x00dc0000, 0x00220000, 0x002a0000, 0x00900000, 0x00880000, 0x00460000, 0x00ee0000, 0x00b80000, 0x00140000, 0x00de0000, 0x005e0000, 0x000b0000, 0x00db0000, 0x00e00000, 0x00320000, 0x003a0000, 0x000a0000, 0x00490000, 0x00060000, 0x00240000, 0x005c0000, 0x00c20000, 0x00d30000, 0x00ac0000, 0x00620000, 0x00910000, 0x00950000, 0x00e40000, 0x00790000, 0x00e70000, 0x00c80000, 0x00370000, 0x006d0000, 0x008d0000, 0x00d50000, 0x004e0000, 0x00a90000, 0x006c0000, 0x00560000, 0x00f40000, 0x00ea0000, 0x00650000, 0x007a0000, 0x00ae0000, 0x00080000, 0x00ba0000, 0x00780000, 0x00250000, 0x002e0000, 0x001c0000, 0x00a60000, 0x00b40000, 0x00c60000, 0x00e80000, 0x00dd0000, 0x00740000, 0x001f0000, 0x004b0000, 0x00bd0000, 0x008b0000, 0x008a0000, 0x00700000, 0x003e0000, 0x00b50000, 0x00660000, 0x00480000, 0x00030000, 0x00f60000, 0x000e0000, 0x00610000, 0x00350000, 0x00570000, 0x00b90000, 0x00860000, 0x00c10000, 0x001d0000, 0x009e0000, 0x00e10000, 0x00f80000, 0x00980000, 0x00110000, 0x00690000, 0x00d90000, 0x008e0000, 0x00940000, 0x009b0000, 0x001e0000, 0x00870000, 0x00e90000, 0x00ce0000, 0x00550000, 0x00280000, 0x00df0000, 0x008c0000, 0x00a10000, 0x00890000, 0x000d0000, 0x00bf0000, 0x00e60000, 0x00420000, 0x00680000, 0x00410000, 0x00990000, 0x002d0000, 0x000f0000, 0x00b00000, 0x00540000, 0x00bb0000, 0x00160000, }, { 0x63000000, 0x7c000000, 0x77000000, 0x7b000000, 0xf2000000, 0x6b000000, 0x6f000000, 0xc5000000, 0x30000000, 0x01000000, 0x67000000, 0x2b000000, 0xfe000000, 0xd7000000, 0xab000000, 0x76000000, 0xca000000, 0x82000000, 0xc9000000, 0x7d000000, 0xfa000000, 0x59000000, 0x47000000, 0xf0000000, 0xad000000, 0xd4000000, 0xa2000000, 0xaf000000, 0x9c000000, 0xa4000000, 0x72000000, 0xc0000000, 0xb7000000, 0xfd000000, 0x93000000, 0x26000000, 0x36000000, 0x3f000000, 0xf7000000, 0xcc000000, 0x34000000, 0xa5000000, 0xe5000000, 0xf1000000, 0x71000000, 0xd8000000, 0x31000000, 0x15000000, 0x04000000, 0xc7000000, 0x23000000, 0xc3000000, 0x18000000, 0x96000000, 0x05000000, 0x9a000000, 0x07000000, 0x12000000, 0x80000000, 0xe2000000, 0xeb000000, 0x27000000, 0xb2000000, 0x75000000, 0x09000000, 0x83000000, 0x2c000000, 0x1a000000, 0x1b000000, 0x6e000000, 0x5a000000, 0xa0000000, 0x52000000, 0x3b000000, 0xd6000000, 0xb3000000, 0x29000000, 0xe3000000, 0x2f000000, 0x84000000, 0x53000000, 0xd1000000, 0x00000000, 0xed000000, 0x20000000, 0xfc000000, 0xb1000000, 0x5b000000, 0x6a000000, 0xcb000000, 0xbe000000, 0x39000000, 0x4a000000, 0x4c000000, 0x58000000, 0xcf000000, 0xd0000000, 0xef000000, 0xaa000000, 0xfb000000, 0x43000000, 0x4d000000, 0x33000000, 0x85000000, 0x45000000, 0xf9000000, 0x02000000, 0x7f000000, 0x50000000, 0x3c000000, 0x9f000000, 0xa8000000, 0x51000000, 0xa3000000, 0x40000000, 0x8f000000, 0x92000000, 0x9d000000, 0x38000000, 0xf5000000, 0xbc000000, 0xb6000000, 0xda000000, 0x21000000, 0x10000000, 0xff000000, 0xf3000000, 0xd2000000, 0xcd000000, 0x0c000000, 0x13000000, 0xec000000, 0x5f000000, 0x97000000, 0x44000000, 0x17000000, 0xc4000000, 0xa7000000, 0x7e000000, 0x3d000000, 0x64000000, 0x5d000000, 0x19000000, 0x73000000, 0x60000000, 0x81000000, 0x4f000000, 0xdc000000, 0x22000000, 0x2a000000, 0x90000000, 0x88000000, 0x46000000, 0xee000000, 0xb8000000, 0x14000000, 0xde000000, 0x5e000000, 0x0b000000, 0xdb000000, 0xe0000000, 0x32000000, 0x3a000000, 0x0a000000, 0x49000000, 0x06000000, 0x24000000, 0x5c000000, 0xc2000000, 0xd3000000, 0xac000000, 0x62000000, 0x91000000, 0x95000000, 0xe4000000, 0x79000000, 0xe7000000, 0xc8000000, 0x37000000, 0x6d000000, 0x8d000000, 0xd5000000, 0x4e000000, 0xa9000000, 0x6c000000, 0x56000000, 0xf4000000, 0xea000000, 0x65000000, 0x7a000000, 0xae000000, 0x08000000, 0xba000000, 0x78000000, 0x25000000, 0x2e000000, 0x1c000000, 0xa6000000, 0xb4000000, 0xc6000000, 0xe8000000, 0xdd000000, 0x74000000, 0x1f000000, 0x4b000000, 0xbd000000, 0x8b000000, 0x8a000000, 0x70000000, 0x3e000000, 0xb5000000, 0x66000000, 0x48000000, 0x03000000, 0xf6000000, 0x0e000000, 0x61000000, 0x35000000, 0x57000000, 0xb9000000, 0x86000000, 0xc1000000, 0x1d000000, 0x9e000000, 0xe1000000, 0xf8000000, 0x98000000, 0x11000000, 0x69000000, 0xd9000000, 0x8e000000, 0x94000000, 0x9b000000, 0x1e000000, 0x87000000, 0xe9000000, 0xce000000, 0x55000000, 0x28000000, 0xdf000000, 0x8c000000, 0xa1000000, 0x89000000, 0x0d000000, 0xbf000000, 0xe6000000, 0x42000000, 0x68000000, 0x41000000, 0x99000000, 0x2d000000, 0x0f000000, 0xb0000000, 0x54000000, 0xbb000000, 0x16000000, } }; __visible const u32 crypto_it_tab[4][256] = { { 0x50a7f451, 0x5365417e, 0xc3a4171a, 0x965e273a, 0xcb6bab3b, 0xf1459d1f, 0xab58faac, 0x9303e34b, 0x55fa3020, 0xf66d76ad, 0x9176cc88, 0x254c02f5, 0xfcd7e54f, 0xd7cb2ac5, 0x80443526, 0x8fa362b5, 0x495ab1de, 0x671bba25, 0x980eea45, 0xe1c0fe5d, 0x02752fc3, 0x12f04c81, 0xa397468d, 0xc6f9d36b, 0xe75f8f03, 0x959c9215, 0xeb7a6dbf, 0xda595295, 0x2d83bed4, 0xd3217458, 0x2969e049, 0x44c8c98e, 0x6a89c275, 0x78798ef4, 0x6b3e5899, 0xdd71b927, 0xb64fe1be, 0x17ad88f0, 0x66ac20c9, 0xb43ace7d, 0x184adf63, 0x82311ae5, 0x60335197, 0x457f5362, 0xe07764b1, 0x84ae6bbb, 0x1ca081fe, 0x942b08f9, 0x58684870, 0x19fd458f, 0x876cde94, 0xb7f87b52, 0x23d373ab, 0xe2024b72, 0x578f1fe3, 0x2aab5566, 0x0728ebb2, 0x03c2b52f, 0x9a7bc586, 0xa50837d3, 0xf2872830, 0xb2a5bf23, 0xba6a0302, 0x5c8216ed, 0x2b1ccf8a, 0x92b479a7, 0xf0f207f3, 0xa1e2694e, 0xcdf4da65, 0xd5be0506, 0x1f6234d1, 0x8afea6c4, 0x9d532e34, 0xa055f3a2, 0x32e18a05, 0x75ebf6a4, 0x39ec830b, 0xaaef6040, 0x069f715e, 0x51106ebd, 0xf98a213e, 0x3d06dd96, 0xae053edd, 0x46bde64d, 0xb58d5491, 0x055dc471, 0x6fd40604, 0xff155060, 0x24fb9819, 0x97e9bdd6, 0xcc434089, 0x779ed967, 0xbd42e8b0, 0x888b8907, 0x385b19e7, 0xdbeec879, 0x470a7ca1, 0xe90f427c, 0xc91e84f8, 0x00000000, 0x83868009, 0x48ed2b32, 0xac70111e, 0x4e725a6c, 0xfbff0efd, 0x5638850f, 0x1ed5ae3d, 0x27392d36, 0x64d90f0a, 0x21a65c68, 0xd1545b9b, 0x3a2e3624, 0xb1670a0c, 0x0fe75793, 0xd296eeb4, 0x9e919b1b, 0x4fc5c080, 0xa220dc61, 0x694b775a, 0x161a121c, 0x0aba93e2, 0xe52aa0c0, 0x43e0223c, 0x1d171b12, 0x0b0d090e, 0xadc78bf2, 0xb9a8b62d, 0xc8a91e14, 0x8519f157, 0x4c0775af, 0xbbdd99ee, 0xfd607fa3, 0x9f2601f7, 0xbcf5725c, 0xc53b6644, 0x347efb5b, 0x7629438b, 0xdcc623cb, 0x68fcedb6, 0x63f1e4b8, 0xcadc31d7, 0x10856342, 0x40229713, 0x2011c684, 0x7d244a85, 0xf83dbbd2, 0x1132f9ae, 0x6da129c7, 0x4b2f9e1d, 0xf330b2dc, 0xec52860d, 0xd0e3c177, 0x6c16b32b, 0x99b970a9, 0xfa489411, 0x2264e947, 0xc48cfca8, 0x1a3ff0a0, 0xd82c7d56, 0xef903322, 0xc74e4987, 0xc1d138d9, 0xfea2ca8c, 0x360bd498, 0xcf81f5a6, 0x28de7aa5, 0x268eb7da, 0xa4bfad3f, 0xe49d3a2c, 0x0d927850, 0x9bcc5f6a, 0x62467e54, 0xc2138df6, 0xe8b8d890, 0x5ef7392e, 0xf5afc382, 0xbe805d9f, 0x7c93d069, 0xa92dd56f, 0xb31225cf, 0x3b99acc8, 0xa77d1810, 0x6e639ce8, 0x7bbb3bdb, 0x097826cd, 0xf418596e, 0x01b79aec, 0xa89a4f83, 0x656e95e6, 0x7ee6ffaa, 0x08cfbc21, 0xe6e815ef, 0xd99be7ba, 0xce366f4a, 0xd4099fea, 0xd67cb029, 0xafb2a431, 0x31233f2a, 0x3094a5c6, 0xc066a235, 0x37bc4e74, 0xa6ca82fc, 0xb0d090e0, 0x15d8a733, 0x4a9804f1, 0xf7daec41, 0x0e50cd7f, 0x2ff69117, 0x8dd64d76, 0x4db0ef43, 0x544daacc, 0xdf0496e4, 0xe3b5d19e, 0x1b886a4c, 0xb81f2cc1, 0x7f516546, 0x04ea5e9d, 0x5d358c01, 0x737487fa, 0x2e410bfb, 0x5a1d67b3, 0x52d2db92, 0x335610e9, 0x1347d66d, 0x8c61d79a, 0x7a0ca137, 0x8e14f859, 0x893c13eb, 0xee27a9ce, 0x35c961b7, 0xede51ce1, 0x3cb1477a, 0x59dfd29c, 0x3f73f255, 0x79ce1418, 0xbf37c773, 0xeacdf753, 0x5baafd5f, 0x146f3ddf, 0x86db4478, 0x81f3afca, 0x3ec468b9, 0x2c342438, 0x5f40a3c2, 0x72c31d16, 0x0c25e2bc, 0x8b493c28, 0x41950dff, 0x7101a839, 0xdeb30c08, 0x9ce4b4d8, 0x90c15664, 0x6184cb7b, 0x70b632d5, 0x745c6c48, 0x4257b8d0, }, { 0xa7f45150, 0x65417e53, 0xa4171ac3, 0x5e273a96, 0x6bab3bcb, 0x459d1ff1, 0x58faacab, 0x03e34b93, 0xfa302055, 0x6d76adf6, 0x76cc8891, 0x4c02f525, 0xd7e54ffc, 0xcb2ac5d7, 0x44352680, 0xa362b58f, 0x5ab1de49, 0x1bba2567, 0x0eea4598, 0xc0fe5de1, 0x752fc302, 0xf04c8112, 0x97468da3, 0xf9d36bc6, 0x5f8f03e7, 0x9c921595, 0x7a6dbfeb, 0x595295da, 0x83bed42d, 0x217458d3, 0x69e04929, 0xc8c98e44, 0x89c2756a, 0x798ef478, 0x3e58996b, 0x71b927dd, 0x4fe1beb6, 0xad88f017, 0xac20c966, 0x3ace7db4, 0x4adf6318, 0x311ae582, 0x33519760, 0x7f536245, 0x7764b1e0, 0xae6bbb84, 0xa081fe1c, 0x2b08f994, 0x68487058, 0xfd458f19, 0x6cde9487, 0xf87b52b7, 0xd373ab23, 0x024b72e2, 0x8f1fe357, 0xab55662a, 0x28ebb207, 0xc2b52f03, 0x7bc5869a, 0x0837d3a5, 0x872830f2, 0xa5bf23b2, 0x6a0302ba, 0x8216ed5c, 0x1ccf8a2b, 0xb479a792, 0xf207f3f0, 0xe2694ea1, 0xf4da65cd, 0xbe0506d5, 0x6234d11f, 0xfea6c48a, 0x532e349d, 0x55f3a2a0, 0xe18a0532, 0xebf6a475, 0xec830b39, 0xef6040aa, 0x9f715e06, 0x106ebd51, 0x8a213ef9, 0x06dd963d, 0x053eddae, 0xbde64d46, 0x8d5491b5, 0x5dc47105, 0xd406046f, 0x155060ff, 0xfb981924, 0xe9bdd697, 0x434089cc, 0x9ed96777, 0x42e8b0bd, 0x8b890788, 0x5b19e738, 0xeec879db, 0x0a7ca147, 0x0f427ce9, 0x1e84f8c9, 0x00000000, 0x86800983, 0xed2b3248, 0x70111eac, 0x725a6c4e, 0xff0efdfb, 0x38850f56, 0xd5ae3d1e, 0x392d3627, 0xd90f0a64, 0xa65c6821, 0x545b9bd1, 0x2e36243a, 0x670a0cb1, 0xe757930f, 0x96eeb4d2, 0x919b1b9e, 0xc5c0804f, 0x20dc61a2, 0x4b775a69, 0x1a121c16, 0xba93e20a, 0x2aa0c0e5, 0xe0223c43, 0x171b121d, 0x0d090e0b, 0xc78bf2ad, 0xa8b62db9, 0xa91e14c8, 0x19f15785, 0x0775af4c, 0xdd99eebb, 0x607fa3fd, 0x2601f79f, 0xf5725cbc, 0x3b6644c5, 0x7efb5b34, 0x29438b76, 0xc623cbdc, 0xfcedb668, 0xf1e4b863, 0xdc31d7ca, 0x85634210, 0x22971340, 0x11c68420, 0x244a857d, 0x3dbbd2f8, 0x32f9ae11, 0xa129c76d, 0x2f9e1d4b, 0x30b2dcf3, 0x52860dec, 0xe3c177d0, 0x16b32b6c, 0xb970a999, 0x489411fa, 0x64e94722, 0x8cfca8c4, 0x3ff0a01a, 0x2c7d56d8, 0x903322ef, 0x4e4987c7, 0xd138d9c1, 0xa2ca8cfe, 0x0bd49836, 0x81f5a6cf, 0xde7aa528, 0x8eb7da26, 0xbfad3fa4, 0x9d3a2ce4, 0x9278500d, 0xcc5f6a9b, 0x467e5462, 0x138df6c2, 0xb8d890e8, 0xf7392e5e, 0xafc382f5, 0x805d9fbe, 0x93d0697c, 0x2dd56fa9, 0x1225cfb3, 0x99acc83b, 0x7d1810a7, 0x639ce86e, 0xbb3bdb7b, 0x7826cd09, 0x18596ef4, 0xb79aec01, 0x9a4f83a8, 0x6e95e665, 0xe6ffaa7e, 0xcfbc2108, 0xe815efe6, 0x9be7bad9, 0x366f4ace, 0x099fead4, 0x7cb029d6, 0xb2a431af, 0x233f2a31, 0x94a5c630, 0x66a235c0, 0xbc4e7437, 0xca82fca6, 0xd090e0b0, 0xd8a73315, 0x9804f14a, 0xdaec41f7, 0x50cd7f0e, 0xf691172f, 0xd64d768d, 0xb0ef434d, 0x4daacc54, 0x0496e4df, 0xb5d19ee3, 0x886a4c1b, 0x1f2cc1b8, 0x5165467f, 0xea5e9d04, 0x358c015d, 0x7487fa73, 0x410bfb2e, 0x1d67b35a, 0xd2db9252, 0x5610e933, 0x47d66d13, 0x61d79a8c, 0x0ca1377a, 0x14f8598e, 0x3c13eb89, 0x27a9ceee, 0xc961b735, 0xe51ce1ed, 0xb1477a3c, 0xdfd29c59, 0x73f2553f, 0xce141879, 0x37c773bf, 0xcdf753ea, 0xaafd5f5b, 0x6f3ddf14, 0xdb447886, 0xf3afca81, 0xc468b93e, 0x3424382c, 0x40a3c25f, 0xc31d1672, 0x25e2bc0c, 0x493c288b, 0x950dff41, 0x01a83971, 0xb30c08de, 0xe4b4d89c, 0xc1566490, 0x84cb7b61, 0xb632d570, 0x5c6c4874, 0x57b8d042, }, { 0xf45150a7, 0x417e5365, 0x171ac3a4, 0x273a965e, 0xab3bcb6b, 0x9d1ff145, 0xfaacab58, 0xe34b9303, 0x302055fa, 0x76adf66d, 0xcc889176, 0x02f5254c, 0xe54ffcd7, 0x2ac5d7cb, 0x35268044, 0x62b58fa3, 0xb1de495a, 0xba25671b, 0xea45980e, 0xfe5de1c0, 0x2fc30275, 0x4c8112f0, 0x468da397, 0xd36bc6f9, 0x8f03e75f, 0x9215959c, 0x6dbfeb7a, 0x5295da59, 0xbed42d83, 0x7458d321, 0xe0492969, 0xc98e44c8, 0xc2756a89, 0x8ef47879, 0x58996b3e, 0xb927dd71, 0xe1beb64f, 0x88f017ad, 0x20c966ac, 0xce7db43a, 0xdf63184a, 0x1ae58231, 0x51976033, 0x5362457f, 0x64b1e077, 0x6bbb84ae, 0x81fe1ca0, 0x08f9942b, 0x48705868, 0x458f19fd, 0xde94876c, 0x7b52b7f8, 0x73ab23d3, 0x4b72e202, 0x1fe3578f, 0x55662aab, 0xebb20728, 0xb52f03c2, 0xc5869a7b, 0x37d3a508, 0x2830f287, 0xbf23b2a5, 0x0302ba6a, 0x16ed5c82, 0xcf8a2b1c, 0x79a792b4, 0x07f3f0f2, 0x694ea1e2, 0xda65cdf4, 0x0506d5be, 0x34d11f62, 0xa6c48afe, 0x2e349d53, 0xf3a2a055, 0x8a0532e1, 0xf6a475eb, 0x830b39ec, 0x6040aaef, 0x715e069f, 0x6ebd5110, 0x213ef98a, 0xdd963d06, 0x3eddae05, 0xe64d46bd, 0x5491b58d, 0xc471055d, 0x06046fd4, 0x5060ff15, 0x981924fb, 0xbdd697e9, 0x4089cc43, 0xd967779e, 0xe8b0bd42, 0x8907888b, 0x19e7385b, 0xc879dbee, 0x7ca1470a, 0x427ce90f, 0x84f8c91e, 0x00000000, 0x80098386, 0x2b3248ed, 0x111eac70, 0x5a6c4e72, 0x0efdfbff, 0x850f5638, 0xae3d1ed5, 0x2d362739, 0x0f0a64d9, 0x5c6821a6, 0x5b9bd154, 0x36243a2e, 0x0a0cb167, 0x57930fe7, 0xeeb4d296, 0x9b1b9e91, 0xc0804fc5, 0xdc61a220, 0x775a694b, 0x121c161a, 0x93e20aba, 0xa0c0e52a, 0x223c43e0, 0x1b121d17, 0x090e0b0d, 0x8bf2adc7, 0xb62db9a8, 0x1e14c8a9, 0xf1578519, 0x75af4c07, 0x99eebbdd, 0x7fa3fd60, 0x01f79f26, 0x725cbcf5, 0x6644c53b, 0xfb5b347e, 0x438b7629, 0x23cbdcc6, 0xedb668fc, 0xe4b863f1, 0x31d7cadc, 0x63421085, 0x97134022, 0xc6842011, 0x4a857d24, 0xbbd2f83d, 0xf9ae1132, 0x29c76da1, 0x9e1d4b2f, 0xb2dcf330, 0x860dec52, 0xc177d0e3, 0xb32b6c16, 0x70a999b9, 0x9411fa48, 0xe9472264, 0xfca8c48c, 0xf0a01a3f, 0x7d56d82c, 0x3322ef90, 0x4987c74e, 0x38d9c1d1, 0xca8cfea2, 0xd498360b, 0xf5a6cf81, 0x7aa528de, 0xb7da268e, 0xad3fa4bf, 0x3a2ce49d, 0x78500d92, 0x5f6a9bcc, 0x7e546246, 0x8df6c213, 0xd890e8b8, 0x392e5ef7, 0xc382f5af, 0x5d9fbe80, 0xd0697c93, 0xd56fa92d, 0x25cfb312, 0xacc83b99, 0x1810a77d, 0x9ce86e63, 0x3bdb7bbb, 0x26cd0978, 0x596ef418, 0x9aec01b7, 0x4f83a89a, 0x95e6656e, 0xffaa7ee6, 0xbc2108cf, 0x15efe6e8, 0xe7bad99b, 0x6f4ace36, 0x9fead409, 0xb029d67c, 0xa431afb2, 0x3f2a3123, 0xa5c63094, 0xa235c066, 0x4e7437bc, 0x82fca6ca, 0x90e0b0d0, 0xa73315d8, 0x04f14a98, 0xec41f7da, 0xcd7f0e50, 0x91172ff6, 0x4d768dd6, 0xef434db0, 0xaacc544d, 0x96e4df04, 0xd19ee3b5, 0x6a4c1b88, 0x2cc1b81f, 0x65467f51, 0x5e9d04ea, 0x8c015d35, 0x87fa7374, 0x0bfb2e41, 0x67b35a1d, 0xdb9252d2, 0x10e93356, 0xd66d1347, 0xd79a8c61, 0xa1377a0c, 0xf8598e14, 0x13eb893c, 0xa9ceee27, 0x61b735c9, 0x1ce1ede5, 0x477a3cb1, 0xd29c59df, 0xf2553f73, 0x141879ce, 0xc773bf37, 0xf753eacd, 0xfd5f5baa, 0x3ddf146f, 0x447886db, 0xafca81f3, 0x68b93ec4, 0x24382c34, 0xa3c25f40, 0x1d1672c3, 0xe2bc0c25, 0x3c288b49, 0x0dff4195, 0xa8397101, 0x0c08deb3, 0xb4d89ce4, 0x566490c1, 0xcb7b6184, 0x32d570b6, 0x6c48745c, 0xb8d04257, }, { 0x5150a7f4, 0x7e536541, 0x1ac3a417, 0x3a965e27, 0x3bcb6bab, 0x1ff1459d, 0xacab58fa, 0x4b9303e3, 0x2055fa30, 0xadf66d76, 0x889176cc, 0xf5254c02, 0x4ffcd7e5, 0xc5d7cb2a, 0x26804435, 0xb58fa362, 0xde495ab1, 0x25671bba, 0x45980eea, 0x5de1c0fe, 0xc302752f, 0x8112f04c, 0x8da39746, 0x6bc6f9d3, 0x03e75f8f, 0x15959c92, 0xbfeb7a6d, 0x95da5952, 0xd42d83be, 0x58d32174, 0x492969e0, 0x8e44c8c9, 0x756a89c2, 0xf478798e, 0x996b3e58, 0x27dd71b9, 0xbeb64fe1, 0xf017ad88, 0xc966ac20, 0x7db43ace, 0x63184adf, 0xe582311a, 0x97603351, 0x62457f53, 0xb1e07764, 0xbb84ae6b, 0xfe1ca081, 0xf9942b08, 0x70586848, 0x8f19fd45, 0x94876cde, 0x52b7f87b, 0xab23d373, 0x72e2024b, 0xe3578f1f, 0x662aab55, 0xb20728eb, 0x2f03c2b5, 0x869a7bc5, 0xd3a50837, 0x30f28728, 0x23b2a5bf, 0x02ba6a03, 0xed5c8216, 0x8a2b1ccf, 0xa792b479, 0xf3f0f207, 0x4ea1e269, 0x65cdf4da, 0x06d5be05, 0xd11f6234, 0xc48afea6, 0x349d532e, 0xa2a055f3, 0x0532e18a, 0xa475ebf6, 0x0b39ec83, 0x40aaef60, 0x5e069f71, 0xbd51106e, 0x3ef98a21, 0x963d06dd, 0xddae053e, 0x4d46bde6, 0x91b58d54, 0x71055dc4, 0x046fd406, 0x60ff1550, 0x1924fb98, 0xd697e9bd, 0x89cc4340, 0x67779ed9, 0xb0bd42e8, 0x07888b89, 0xe7385b19, 0x79dbeec8, 0xa1470a7c, 0x7ce90f42, 0xf8c91e84, 0x00000000, 0x09838680, 0x3248ed2b, 0x1eac7011, 0x6c4e725a, 0xfdfbff0e, 0x0f563885, 0x3d1ed5ae, 0x3627392d, 0x0a64d90f, 0x6821a65c, 0x9bd1545b, 0x243a2e36, 0x0cb1670a, 0x930fe757, 0xb4d296ee, 0x1b9e919b, 0x804fc5c0, 0x61a220dc, 0x5a694b77, 0x1c161a12, 0xe20aba93, 0xc0e52aa0, 0x3c43e022, 0x121d171b, 0x0e0b0d09, 0xf2adc78b, 0x2db9a8b6, 0x14c8a91e, 0x578519f1, 0xaf4c0775, 0xeebbdd99, 0xa3fd607f, 0xf79f2601, 0x5cbcf572, 0x44c53b66, 0x5b347efb, 0x8b762943, 0xcbdcc623, 0xb668fced, 0xb863f1e4, 0xd7cadc31, 0x42108563, 0x13402297, 0x842011c6, 0x857d244a, 0xd2f83dbb, 0xae1132f9, 0xc76da129, 0x1d4b2f9e, 0xdcf330b2, 0x0dec5286, 0x77d0e3c1, 0x2b6c16b3, 0xa999b970, 0x11fa4894, 0x472264e9, 0xa8c48cfc, 0xa01a3ff0, 0x56d82c7d, 0x22ef9033, 0x87c74e49, 0xd9c1d138, 0x8cfea2ca, 0x98360bd4, 0xa6cf81f5, 0xa528de7a, 0xda268eb7, 0x3fa4bfad, 0x2ce49d3a, 0x500d9278, 0x6a9bcc5f, 0x5462467e, 0xf6c2138d, 0x90e8b8d8, 0x2e5ef739, 0x82f5afc3, 0x9fbe805d, 0x697c93d0, 0x6fa92dd5, 0xcfb31225, 0xc83b99ac, 0x10a77d18, 0xe86e639c, 0xdb7bbb3b, 0xcd097826, 0x6ef41859, 0xec01b79a, 0x83a89a4f, 0xe6656e95, 0xaa7ee6ff, 0x2108cfbc, 0xefe6e815, 0xbad99be7, 0x4ace366f, 0xead4099f, 0x29d67cb0, 0x31afb2a4, 0x2a31233f, 0xc63094a5, 0x35c066a2, 0x7437bc4e, 0xfca6ca82, 0xe0b0d090, 0x3315d8a7, 0xf14a9804, 0x41f7daec, 0x7f0e50cd, 0x172ff691, 0x768dd64d, 0x434db0ef, 0xcc544daa, 0xe4df0496, 0x9ee3b5d1, 0x4c1b886a, 0xc1b81f2c, 0x467f5165, 0x9d04ea5e, 0x015d358c, 0xfa737487, 0xfb2e410b, 0xb35a1d67, 0x9252d2db, 0xe9335610, 0x6d1347d6, 0x9a8c61d7, 0x377a0ca1, 0x598e14f8, 0xeb893c13, 0xceee27a9, 0xb735c961, 0xe1ede51c, 0x7a3cb147, 0x9c59dfd2, 0x553f73f2, 0x1879ce14, 0x73bf37c7, 0x53eacdf7, 0x5f5baafd, 0xdf146f3d, 0x7886db44, 0xca81f3af, 0xb93ec468, 0x382c3424, 0xc25f40a3, 0x1672c31d, 0xbc0c25e2, 0x288b493c, 0xff41950d, 0x397101a8, 0x08deb30c, 0xd89ce4b4, 0x6490c156, 0x7b6184cb, 0xd570b632, 0x48745c6c, 0xd04257b8, } }; __visible const u32 crypto_il_tab[4][256] = { { 0x00000052, 0x00000009, 0x0000006a, 0x000000d5, 0x00000030, 0x00000036, 0x000000a5, 0x00000038, 0x000000bf, 0x00000040, 0x000000a3, 0x0000009e, 0x00000081, 0x000000f3, 0x000000d7, 0x000000fb, 0x0000007c, 0x000000e3, 0x00000039, 0x00000082, 0x0000009b, 0x0000002f, 0x000000ff, 0x00000087, 0x00000034, 0x0000008e, 0x00000043, 0x00000044, 0x000000c4, 0x000000de, 0x000000e9, 0x000000cb, 0x00000054, 0x0000007b, 0x00000094, 0x00000032, 0x000000a6, 0x000000c2, 0x00000023, 0x0000003d, 0x000000ee, 0x0000004c, 0x00000095, 0x0000000b, 0x00000042, 0x000000fa, 0x000000c3, 0x0000004e, 0x00000008, 0x0000002e, 0x000000a1, 0x00000066, 0x00000028, 0x000000d9, 0x00000024, 0x000000b2, 0x00000076, 0x0000005b, 0x000000a2, 0x00000049, 0x0000006d, 0x0000008b, 0x000000d1, 0x00000025, 0x00000072, 0x000000f8, 0x000000f6, 0x00000064, 0x00000086, 0x00000068, 0x00000098, 0x00000016, 0x000000d4, 0x000000a4, 0x0000005c, 0x000000cc, 0x0000005d, 0x00000065, 0x000000b6, 0x00000092, 0x0000006c, 0x00000070, 0x00000048, 0x00000050, 0x000000fd, 0x000000ed, 0x000000b9, 0x000000da, 0x0000005e, 0x00000015, 0x00000046, 0x00000057, 0x000000a7, 0x0000008d, 0x0000009d, 0x00000084, 0x00000090, 0x000000d8, 0x000000ab, 0x00000000, 0x0000008c, 0x000000bc, 0x000000d3, 0x0000000a, 0x000000f7, 0x000000e4, 0x00000058, 0x00000005, 0x000000b8, 0x000000b3, 0x00000045, 0x00000006, 0x000000d0, 0x0000002c, 0x0000001e, 0x0000008f, 0x000000ca, 0x0000003f, 0x0000000f, 0x00000002, 0x000000c1, 0x000000af, 0x000000bd, 0x00000003, 0x00000001, 0x00000013, 0x0000008a, 0x0000006b, 0x0000003a, 0x00000091, 0x00000011, 0x00000041, 0x0000004f, 0x00000067, 0x000000dc, 0x000000ea, 0x00000097, 0x000000f2, 0x000000cf, 0x000000ce, 0x000000f0, 0x000000b4, 0x000000e6, 0x00000073, 0x00000096, 0x000000ac, 0x00000074, 0x00000022, 0x000000e7, 0x000000ad, 0x00000035, 0x00000085, 0x000000e2, 0x000000f9, 0x00000037, 0x000000e8, 0x0000001c, 0x00000075, 0x000000df, 0x0000006e, 0x00000047, 0x000000f1, 0x0000001a, 0x00000071, 0x0000001d, 0x00000029, 0x000000c5, 0x00000089, 0x0000006f, 0x000000b7, 0x00000062, 0x0000000e, 0x000000aa, 0x00000018, 0x000000be, 0x0000001b, 0x000000fc, 0x00000056, 0x0000003e, 0x0000004b, 0x000000c6, 0x000000d2, 0x00000079, 0x00000020, 0x0000009a, 0x000000db, 0x000000c0, 0x000000fe, 0x00000078, 0x000000cd, 0x0000005a, 0x000000f4, 0x0000001f, 0x000000dd, 0x000000a8, 0x00000033, 0x00000088, 0x00000007, 0x000000c7, 0x00000031, 0x000000b1, 0x00000012, 0x00000010, 0x00000059, 0x00000027, 0x00000080, 0x000000ec, 0x0000005f, 0x00000060, 0x00000051, 0x0000007f, 0x000000a9, 0x00000019, 0x000000b5, 0x0000004a, 0x0000000d, 0x0000002d, 0x000000e5, 0x0000007a, 0x0000009f, 0x00000093, 0x000000c9, 0x0000009c, 0x000000ef, 0x000000a0, 0x000000e0, 0x0000003b, 0x0000004d, 0x000000ae, 0x0000002a, 0x000000f5, 0x000000b0, 0x000000c8, 0x000000eb, 0x000000bb, 0x0000003c, 0x00000083, 0x00000053, 0x00000099, 0x00000061, 0x00000017, 0x0000002b, 0x00000004, 0x0000007e, 0x000000ba, 0x00000077, 0x000000d6, 0x00000026, 0x000000e1, 0x00000069, 0x00000014, 0x00000063, 0x00000055, 0x00000021, 0x0000000c, 0x0000007d, }, { 0x00005200, 0x00000900, 0x00006a00, 0x0000d500, 0x00003000, 0x00003600, 0x0000a500, 0x00003800, 0x0000bf00, 0x00004000, 0x0000a300, 0x00009e00, 0x00008100, 0x0000f300, 0x0000d700, 0x0000fb00, 0x00007c00, 0x0000e300, 0x00003900, 0x00008200, 0x00009b00, 0x00002f00, 0x0000ff00, 0x00008700, 0x00003400, 0x00008e00, 0x00004300, 0x00004400, 0x0000c400, 0x0000de00, 0x0000e900, 0x0000cb00, 0x00005400, 0x00007b00, 0x00009400, 0x00003200, 0x0000a600, 0x0000c200, 0x00002300, 0x00003d00, 0x0000ee00, 0x00004c00, 0x00009500, 0x00000b00, 0x00004200, 0x0000fa00, 0x0000c300, 0x00004e00, 0x00000800, 0x00002e00, 0x0000a100, 0x00006600, 0x00002800, 0x0000d900, 0x00002400, 0x0000b200, 0x00007600, 0x00005b00, 0x0000a200, 0x00004900, 0x00006d00, 0x00008b00, 0x0000d100, 0x00002500, 0x00007200, 0x0000f800, 0x0000f600, 0x00006400, 0x00008600, 0x00006800, 0x00009800, 0x00001600, 0x0000d400, 0x0000a400, 0x00005c00, 0x0000cc00, 0x00005d00, 0x00006500, 0x0000b600, 0x00009200, 0x00006c00, 0x00007000, 0x00004800, 0x00005000, 0x0000fd00, 0x0000ed00, 0x0000b900, 0x0000da00, 0x00005e00, 0x00001500, 0x00004600, 0x00005700, 0x0000a700, 0x00008d00, 0x00009d00, 0x00008400, 0x00009000, 0x0000d800, 0x0000ab00, 0x00000000, 0x00008c00, 0x0000bc00, 0x0000d300, 0x00000a00, 0x0000f700, 0x0000e400, 0x00005800, 0x00000500, 0x0000b800, 0x0000b300, 0x00004500, 0x00000600, 0x0000d000, 0x00002c00, 0x00001e00, 0x00008f00, 0x0000ca00, 0x00003f00, 0x00000f00, 0x00000200, 0x0000c100, 0x0000af00, 0x0000bd00, 0x00000300, 0x00000100, 0x00001300, 0x00008a00, 0x00006b00, 0x00003a00, 0x00009100, 0x00001100, 0x00004100, 0x00004f00, 0x00006700, 0x0000dc00, 0x0000ea00, 0x00009700, 0x0000f200, 0x0000cf00, 0x0000ce00, 0x0000f000, 0x0000b400, 0x0000e600, 0x00007300, 0x00009600, 0x0000ac00, 0x00007400, 0x00002200, 0x0000e700, 0x0000ad00, 0x00003500, 0x00008500, 0x0000e200, 0x0000f900, 0x00003700, 0x0000e800, 0x00001c00, 0x00007500, 0x0000df00, 0x00006e00, 0x00004700, 0x0000f100, 0x00001a00, 0x00007100, 0x00001d00, 0x00002900, 0x0000c500, 0x00008900, 0x00006f00, 0x0000b700, 0x00006200, 0x00000e00, 0x0000aa00, 0x00001800, 0x0000be00, 0x00001b00, 0x0000fc00, 0x00005600, 0x00003e00, 0x00004b00, 0x0000c600, 0x0000d200, 0x00007900, 0x00002000, 0x00009a00, 0x0000db00, 0x0000c000, 0x0000fe00, 0x00007800, 0x0000cd00, 0x00005a00, 0x0000f400, 0x00001f00, 0x0000dd00, 0x0000a800, 0x00003300, 0x00008800, 0x00000700, 0x0000c700, 0x00003100, 0x0000b100, 0x00001200, 0x00001000, 0x00005900, 0x00002700, 0x00008000, 0x0000ec00, 0x00005f00, 0x00006000, 0x00005100, 0x00007f00, 0x0000a900, 0x00001900, 0x0000b500, 0x00004a00, 0x00000d00, 0x00002d00, 0x0000e500, 0x00007a00, 0x00009f00, 0x00009300, 0x0000c900, 0x00009c00, 0x0000ef00, 0x0000a000, 0x0000e000, 0x00003b00, 0x00004d00, 0x0000ae00, 0x00002a00, 0x0000f500, 0x0000b000, 0x0000c800, 0x0000eb00, 0x0000bb00, 0x00003c00, 0x00008300, 0x00005300, 0x00009900, 0x00006100, 0x00001700, 0x00002b00, 0x00000400, 0x00007e00, 0x0000ba00, 0x00007700, 0x0000d600, 0x00002600, 0x0000e100, 0x00006900, 0x00001400, 0x00006300, 0x00005500, 0x00002100, 0x00000c00, 0x00007d00, }, { 0x00520000, 0x00090000, 0x006a0000, 0x00d50000, 0x00300000, 0x00360000, 0x00a50000, 0x00380000, 0x00bf0000, 0x00400000, 0x00a30000, 0x009e0000, 0x00810000, 0x00f30000, 0x00d70000, 0x00fb0000, 0x007c0000, 0x00e30000, 0x00390000, 0x00820000, 0x009b0000, 0x002f0000, 0x00ff0000, 0x00870000, 0x00340000, 0x008e0000, 0x00430000, 0x00440000, 0x00c40000, 0x00de0000, 0x00e90000, 0x00cb0000, 0x00540000, 0x007b0000, 0x00940000, 0x00320000, 0x00a60000, 0x00c20000, 0x00230000, 0x003d0000, 0x00ee0000, 0x004c0000, 0x00950000, 0x000b0000, 0x00420000, 0x00fa0000, 0x00c30000, 0x004e0000, 0x00080000, 0x002e0000, 0x00a10000, 0x00660000, 0x00280000, 0x00d90000, 0x00240000, 0x00b20000, 0x00760000, 0x005b0000, 0x00a20000, 0x00490000, 0x006d0000, 0x008b0000, 0x00d10000, 0x00250000, 0x00720000, 0x00f80000, 0x00f60000, 0x00640000, 0x00860000, 0x00680000, 0x00980000, 0x00160000, 0x00d40000, 0x00a40000, 0x005c0000, 0x00cc0000, 0x005d0000, 0x00650000, 0x00b60000, 0x00920000, 0x006c0000, 0x00700000, 0x00480000, 0x00500000, 0x00fd0000, 0x00ed0000, 0x00b90000, 0x00da0000, 0x005e0000, 0x00150000, 0x00460000, 0x00570000, 0x00a70000, 0x008d0000, 0x009d0000, 0x00840000, 0x00900000, 0x00d80000, 0x00ab0000, 0x00000000, 0x008c0000, 0x00bc0000, 0x00d30000, 0x000a0000, 0x00f70000, 0x00e40000, 0x00580000, 0x00050000, 0x00b80000, 0x00b30000, 0x00450000, 0x00060000, 0x00d00000, 0x002c0000, 0x001e0000, 0x008f0000, 0x00ca0000, 0x003f0000, 0x000f0000, 0x00020000, 0x00c10000, 0x00af0000, 0x00bd0000, 0x00030000, 0x00010000, 0x00130000, 0x008a0000, 0x006b0000, 0x003a0000, 0x00910000, 0x00110000, 0x00410000, 0x004f0000, 0x00670000, 0x00dc0000, 0x00ea0000, 0x00970000, 0x00f20000, 0x00cf0000, 0x00ce0000, 0x00f00000, 0x00b40000, 0x00e60000, 0x00730000, 0x00960000, 0x00ac0000, 0x00740000, 0x00220000, 0x00e70000, 0x00ad0000, 0x00350000, 0x00850000, 0x00e20000, 0x00f90000, 0x00370000, 0x00e80000, 0x001c0000, 0x00750000, 0x00df0000, 0x006e0000, 0x00470000, 0x00f10000, 0x001a0000, 0x00710000, 0x001d0000, 0x00290000, 0x00c50000, 0x00890000, 0x006f0000, 0x00b70000, 0x00620000, 0x000e0000, 0x00aa0000, 0x00180000, 0x00be0000, 0x001b0000, 0x00fc0000, 0x00560000, 0x003e0000, 0x004b0000, 0x00c60000, 0x00d20000, 0x00790000, 0x00200000, 0x009a0000, 0x00db0000, 0x00c00000, 0x00fe0000, 0x00780000, 0x00cd0000, 0x005a0000, 0x00f40000, 0x001f0000, 0x00dd0000, 0x00a80000, 0x00330000, 0x00880000, 0x00070000, 0x00c70000, 0x00310000, 0x00b10000, 0x00120000, 0x00100000, 0x00590000, 0x00270000, 0x00800000, 0x00ec0000, 0x005f0000, 0x00600000, 0x00510000, 0x007f0000, 0x00a90000, 0x00190000, 0x00b50000, 0x004a0000, 0x000d0000, 0x002d0000, 0x00e50000, 0x007a0000, 0x009f0000, 0x00930000, 0x00c90000, 0x009c0000, 0x00ef0000, 0x00a00000, 0x00e00000, 0x003b0000, 0x004d0000, 0x00ae0000, 0x002a0000, 0x00f50000, 0x00b00000, 0x00c80000, 0x00eb0000, 0x00bb0000, 0x003c0000, 0x00830000, 0x00530000, 0x00990000, 0x00610000, 0x00170000, 0x002b0000, 0x00040000, 0x007e0000, 0x00ba0000, 0x00770000, 0x00d60000, 0x00260000, 0x00e10000, 0x00690000, 0x00140000, 0x00630000, 0x00550000, 0x00210000, 0x000c0000, 0x007d0000, }, { 0x52000000, 0x09000000, 0x6a000000, 0xd5000000, 0x30000000, 0x36000000, 0xa5000000, 0x38000000, 0xbf000000, 0x40000000, 0xa3000000, 0x9e000000, 0x81000000, 0xf3000000, 0xd7000000, 0xfb000000, 0x7c000000, 0xe3000000, 0x39000000, 0x82000000, 0x9b000000, 0x2f000000, 0xff000000, 0x87000000, 0x34000000, 0x8e000000, 0x43000000, 0x44000000, 0xc4000000, 0xde000000, 0xe9000000, 0xcb000000, 0x54000000, 0x7b000000, 0x94000000, 0x32000000, 0xa6000000, 0xc2000000, 0x23000000, 0x3d000000, 0xee000000, 0x4c000000, 0x95000000, 0x0b000000, 0x42000000, 0xfa000000, 0xc3000000, 0x4e000000, 0x08000000, 0x2e000000, 0xa1000000, 0x66000000, 0x28000000, 0xd9000000, 0x24000000, 0xb2000000, 0x76000000, 0x5b000000, 0xa2000000, 0x49000000, 0x6d000000, 0x8b000000, 0xd1000000, 0x25000000, 0x72000000, 0xf8000000, 0xf6000000, 0x64000000, 0x86000000, 0x68000000, 0x98000000, 0x16000000, 0xd4000000, 0xa4000000, 0x5c000000, 0xcc000000, 0x5d000000, 0x65000000, 0xb6000000, 0x92000000, 0x6c000000, 0x70000000, 0x48000000, 0x50000000, 0xfd000000, 0xed000000, 0xb9000000, 0xda000000, 0x5e000000, 0x15000000, 0x46000000, 0x57000000, 0xa7000000, 0x8d000000, 0x9d000000, 0x84000000, 0x90000000, 0xd8000000, 0xab000000, 0x00000000, 0x8c000000, 0xbc000000, 0xd3000000, 0x0a000000, 0xf7000000, 0xe4000000, 0x58000000, 0x05000000, 0xb8000000, 0xb3000000, 0x45000000, 0x06000000, 0xd0000000, 0x2c000000, 0x1e000000, 0x8f000000, 0xca000000, 0x3f000000, 0x0f000000, 0x02000000, 0xc1000000, 0xaf000000, 0xbd000000, 0x03000000, 0x01000000, 0x13000000, 0x8a000000, 0x6b000000, 0x3a000000, 0x91000000, 0x11000000, 0x41000000, 0x4f000000, 0x67000000, 0xdc000000, 0xea000000, 0x97000000, 0xf2000000, 0xcf000000, 0xce000000, 0xf0000000, 0xb4000000, 0xe6000000, 0x73000000, 0x96000000, 0xac000000, 0x74000000, 0x22000000, 0xe7000000, 0xad000000, 0x35000000, 0x85000000, 0xe2000000, 0xf9000000, 0x37000000, 0xe8000000, 0x1c000000, 0x75000000, 0xdf000000, 0x6e000000, 0x47000000, 0xf1000000, 0x1a000000, 0x71000000, 0x1d000000, 0x29000000, 0xc5000000, 0x89000000, 0x6f000000, 0xb7000000, 0x62000000, 0x0e000000, 0xaa000000, 0x18000000, 0xbe000000, 0x1b000000, 0xfc000000, 0x56000000, 0x3e000000, 0x4b000000, 0xc6000000, 0xd2000000, 0x79000000, 0x20000000, 0x9a000000, 0xdb000000, 0xc0000000, 0xfe000000, 0x78000000, 0xcd000000, 0x5a000000, 0xf4000000, 0x1f000000, 0xdd000000, 0xa8000000, 0x33000000, 0x88000000, 0x07000000, 0xc7000000, 0x31000000, 0xb1000000, 0x12000000, 0x10000000, 0x59000000, 0x27000000, 0x80000000, 0xec000000, 0x5f000000, 0x60000000, 0x51000000, 0x7f000000, 0xa9000000, 0x19000000, 0xb5000000, 0x4a000000, 0x0d000000, 0x2d000000, 0xe5000000, 0x7a000000, 0x9f000000, 0x93000000, 0xc9000000, 0x9c000000, 0xef000000, 0xa0000000, 0xe0000000, 0x3b000000, 0x4d000000, 0xae000000, 0x2a000000, 0xf5000000, 0xb0000000, 0xc8000000, 0xeb000000, 0xbb000000, 0x3c000000, 0x83000000, 0x53000000, 0x99000000, 0x61000000, 0x17000000, 0x2b000000, 0x04000000, 0x7e000000, 0xba000000, 0x77000000, 0xd6000000, 0x26000000, 0xe1000000, 0x69000000, 0x14000000, 0x63000000, 0x55000000, 0x21000000, 0x0c000000, 0x7d000000, } }; EXPORT_SYMBOL_GPL(crypto_ft_tab); EXPORT_SYMBOL_GPL(crypto_fl_tab); EXPORT_SYMBOL_GPL(crypto_it_tab); EXPORT_SYMBOL_GPL(crypto_il_tab); / initialise the key schedule from the user supplied key / #define star_x(x) (((x) & 0x7f7f7f7f) << 1) ^ ((((x) & 0x80808080) >> 7) 0x1b) #define imix_col(y, x) do { \ u = star_x(x); \ v = star_x(u); \ w = star_x(v); \ t = w ^ (x); \ (y) = u ^ v ^ w; \ (y) ^= ror32(u ^ t, 8) ^ \ ror32(v ^ t, 16) ^ \ ror32(t, 24); \ } while (0) #define ls_box(x) \ crypto_fl_tab[0][byte(x, 0)] ^ \ crypto_fl_tab[1][byte(x, 1)] ^ \ crypto_fl_tab[2][byte(x, 2)] ^ \ crypto_fl_tab[3][byte(x, 3)] #define loop4(i) do { \ t = ror32(t, 8); \ t = ls_box(t) ^ rco_tab[i]; \ t ^= ctx->key_enc[4 * i]; \ ctx->key_enc[4 * i + 4] = t; \ t ^= ctx->key_enc[4 * i + 1]; \ ctx->key_enc[4 * i + 5] = t; \ t ^= ctx->key_enc[4 * i + 2]; \ ctx->key_enc[4 * i + 6] = t; \ t ^= ctx->key_enc[4 * i + 3]; \ ctx->key_enc[4 * i + 7] = t; \ } while (0) #define loop6(i) do { \ t = ror32(t, 8); \ t = ls_box(t) ^ rco_tab[i]; \ t ^= ctx->key_enc[6 * i]; \ ctx->key_enc[6 * i + 6] = t; \ t ^= ctx->key_enc[6 * i + 1]; \ ctx->key_enc[6 * i + 7] = t; \ t ^= ctx->key_enc[6 * i + 2]; \ ctx->key_enc[6 * i + 8] = t; \ t ^= ctx->key_enc[6 * i + 3]; \ ctx->key_enc[6 * i + 9] = t; \ t ^= ctx->key_enc[6 * i + 4]; \ ctx->key_enc[6 * i + 10] = t; \ t ^= ctx->key_enc[6 * i + 5]; \ ctx->key_enc[6 * i + 11] = t; \ } while (0) #define loop8tophalf(i) do { \ t = ror32(t, 8); \ t = ls_box(t) ^ rco_tab[i]; \ t ^= ctx->key_enc[8 * i]; \ ctx->key_enc[8 * i + 8] = t; \ t ^= ctx->key_enc[8 * i + 1]; \ ctx->key_enc[8 * i + 9] = t; \ t ^= ctx->key_enc[8 * i + 2]; \ ctx->key_enc[8 * i + 10] = t; \ t ^= ctx->key_enc[8 * i + 3]; \ ctx->key_enc[8 * i + 11] = t; \ } while (0) #define loop8(i) do { \ loop8tophalf(i); \ t = ctx->key_enc[8 * i + 4] ^ ls_box(t); \ ctx->key_enc[8 * i + 12] = t; \ t ^= ctx->key_enc[8 * i + 5]; \ ctx->key_enc[8 * i + 13] = t; \ t ^= ctx->key_enc[8 * i + 6]; \ ctx->key_enc[8 * i + 14] = t; \ t ^= ctx->key_enc[8 * i + 7]; \ ctx->key_enc[8 * i + 15] = t; \ } while (0) /** * crypto_aes_expand_key - Expands the AES key as described in FIPS-197 * @ctx: The location where the computed key will be stored. * @in_key: The supplied key. * @key_len: The length of the supplied key. * * Returns 0 on success. The function fails only if an invalid key size (or * pointer) is supplied. * The expanded key size is 240 bytes (max of 14 rounds with a unique 16 bytes * key schedule plus a 16 bytes key which is used before the first round). * The decryption key is prepared for the "Equivalent Inverse Cipher" as * described in FIPS-197. The first slot (16 bytes) of each key (enc or dec) is * for the initial combination, the second slot for the first round and so on. / int crypto_aes_expand_key(struct crypto_aes_ctx ctx, const u8 in_key, unsigned int key_len) { const __le32 key = (const __le32 )in_key; u32 i, t, u, v, w, j; if (key_len != AES_KEYSIZE_128 && key_len != AES_KEYSIZE_192 && key_len != AES_KEYSIZE_256) return -EINVAL; ctx->key_length = key_len; ctx->key_dec[key_len + 24] = ctx->key_enc[0] = le32_to_cpu(key[0]); ctx->key_dec[key_len + 25] = ctx->key_enc[1] = le32_to_cpu(key[1]); ctx->key_dec[key_len + 26] = ctx->key_enc[2] = le32_to_cpu(key[2]); ctx->key_dec[key_len + 27] = ctx->key_enc[3] = le32_to_cpu(key[3]); switch (key_len) { case AES_KEYSIZE_128: t = ctx->key_enc[3]; for (i = 0; i < 10; ++i) loop4(i); break; case AES_KEYSIZE_192: ctx->key_enc[4] = le32_to_cpu(key[4]); t = ctx->key_enc[5] = le32_to_cpu(key[5]); for (i = 0; i < 8; ++i) loop6(i); break; case AES_KEYSIZE_256: ctx->key_enc[4] = le32_to_cpu(key[4]); ctx->key_enc[5] = le32_to_cpu(key[5]); ctx->key_enc[6] = le32_to_cpu(key[6]); t = ctx->key_enc[7] = le32_to_cpu(key[7]); for (i = 0; i < 6; ++i) loop8(i); loop8tophalf(i); break; } ctx->key_dec[0] = ctx->key_enc[key_len + 24]; ctx->key_dec[1] = ctx->key_enc[key_len + 25]; ctx->key_dec[2] = ctx->key_enc[key_len + 26]; ctx->key_dec[3] = ctx->key_enc[key_len + 27]; for (i = 4; i < key_len + 24; ++i) { j = key_len + 24 - (i & ~3) + (i & 3); imix_col(ctx->key_dec[j], ctx->key_enc[i]); } return 0; } EXPORT_SYMBOL_GPL(crypto_aes_expand_key); /* * crypto_aes_set_key - Set the AES key. * @tfm: The %crypto_tfm that is used in the context. * @in_key: The input key. * @key_len: The size of the key. * * Returns 0 on success, on failure the %CRYPTO_TFM_RES_BAD_KEY_LEN flag in tfm * is set. The function uses crypto_aes_expand_key() to expand the key. * &crypto_aes_ctx _must_ be the private data embedded in @tfm which is * retrieved with crypto_tfm_ctx(). / int crypto_aes_set_key(struct crypto_tfm tfm, const u8 in_key, unsigned int key_len) { struct crypto_aes_ctx ctx = crypto_tfm_ctx(tfm); u32 flags = &tfm->crt_flags; int ret; ret = crypto_aes_expand_key(ctx, in_key, key_len); if (!ret) return 0; flags \|= CRYPTO_TFM_RES_BAD_KEY_LEN; return -EINVAL; } EXPORT_SYMBOL_GPL(crypto_aes_set_key); /* encrypt a block of text / #define f_rn(bo, bi, n, k) do { \ bo[n] = crypto_ft_tab[0][byte(bi[n], 0)] ^ \ crypto_ft_tab[1][byte(bi[(n + 1) & 3], 1)] ^ \ crypto_ft_tab[2][byte(bi[(n + 2) & 3], 2)] ^ \ crypto_ft_tab[3][byte(bi[(n + 3) & 3], 3)] ^ (k + n); \ } while (0) #define f_nround(bo, bi, k) do {\ f_rn(bo, bi, 0, k); \ f_rn(bo, bi, 1, k); \ f_rn(bo, bi, 2, k); \ f_rn(bo, bi, 3, k); \ k += 4; \ } while (0) #define f_rl(bo, bi, n, k) do { \ bo[n] = crypto_fl_tab[0][byte(bi[n], 0)] ^ \ crypto_fl_tab[1][byte(bi[(n + 1) & 3], 1)] ^ \ crypto_fl_tab[2][byte(bi[(n + 2) & 3], 2)] ^ \ crypto_fl_tab[3][byte(bi[(n + 3) & 3], 3)] ^ (k + n); \ } while (0) #define f_lround(bo, bi, k) do {\ f_rl(bo, bi, 0, k); \ f_rl(bo, bi, 1, k); \ f_rl(bo, bi, 2, k); \ f_rl(bo, bi, 3, k); \ } while (0) static void aes_encrypt(struct crypto_tfm tfm, u8 out, const u8 in) { const struct crypto_aes_ctx ctx = crypto_tfm_ctx(tfm); const __le32 src = (const __le32 )in; __le32 dst = (__le32 )out; u32 b0[4], b1[4]; const u32 kp = ctx->key_enc + 4; const int key_len = ctx->key_length; b0[0] = le32_to_cpu(src[0]) ^ ctx->key_enc[0]; b0[1] = le32_to_cpu(src[1]) ^ ctx->key_enc[1]; b0[2] = le32_to_cpu(src[2]) ^ ctx->key_enc[2]; b0[3] = le32_to_cpu(src[3]) ^ ctx->key_enc[3]; if (key_len > 24) { f_nround(b1, b0, kp); f_nround(b0, b1, kp); } if (key_len > 16) { f_nround(b1, b0, kp); f_nround(b0, b1, kp); } f_nround(b1, b0, kp); f_nround(b0, b1, kp); f_nround(b1, b0, kp); f_nround(b0, b1, kp); f_nround(b1, b0, kp); f_nround(b0, b1, kp); f_nround(b1, b0, kp); f_nround(b0, b1, kp); f_nround(b1, b0, kp); f_lround(b0, b1, kp); dst[0] = cpu_to_le32(b0[0]); dst[1] = cpu_to_le32(b0[1]); dst[2] = cpu_to_le32(b0[2]); dst[3] = cpu_to_le32(b0[3]); } /* decrypt a block of text / #define i_rn(bo, bi, n, k) do { \ bo[n] = crypto_it_tab[0][byte(bi[n], 0)] ^ \ crypto_it_tab[1][byte(bi[(n + 3) & 3], 1)] ^ \ crypto_it_tab[2][byte(bi[(n + 2) & 3], 2)] ^ \ crypto_it_tab[3][byte(bi[(n + 1) & 3], 3)] ^ (k + n); \ } while (0) #define i_nround(bo, bi, k) do {\ i_rn(bo, bi, 0, k); \ i_rn(bo, bi, 1, k); \ i_rn(bo, bi, 2, k); \ i_rn(bo, bi, 3, k); \ k += 4; \ } while (0) #define i_rl(bo, bi, n, k) do { \ bo[n] = crypto_il_tab[0][byte(bi[n], 0)] ^ \ crypto_il_tab[1][byte(bi[(n + 3) & 3], 1)] ^ \ crypto_il_tab[2][byte(bi[(n + 2) & 3], 2)] ^ \ crypto_il_tab[3][byte(bi[(n + 1) & 3], 3)] ^ (k + n); \ } while (0) #define i_lround(bo, bi, k) do {\ i_rl(bo, bi, 0, k); \ i_rl(bo, bi, 1, k); \ i_rl(bo, bi, 2, k); \ i_rl(bo, bi, 3, k); \ } while (0) static void aes_decrypt(struct crypto_tfm tfm, u8 out, const u8 in) { const struct crypto_aes_ctx ctx = crypto_tfm_ctx(tfm); const __le32 src = (const __le32 )in; __le32 dst = (__le32 )out; u32 b0[4], b1[4]; const int key_len = ctx->key_length; const u32 kp = ctx->key_dec + 4; b0[0] = le32_to_cpu(src[0]) ^ ctx->key_dec[0]; b0[1] = le32_to_cpu(src[1]) ^ ctx->key_dec[1]; b0[2] = le32_to_cpu(src[2]) ^ ctx->key_dec[2]; b0[3] = le32_to_cpu(src[3]) ^ ctx->key_dec[3]; if (key_len > 24) { i_nround(b1, b0, kp); i_nround(b0, b1, kp); } if (key_len > 16) { i_nround(b1, b0, kp); i_nround(b0, b1, kp); } i_nround(b1, b0, kp); i_nround(b0, b1, kp); i_nround(b1, b0, kp); i_nround(b0, b1, kp); i_nround(b1, b0, kp); i_nround(b0, b1, kp); i_nround(b1, b0, kp); i_nround(b0, b1, kp); i_nround(b1, b0, kp); i_lround(b0, b1, kp); dst[0] = cpu_to_le32(b0[0]); dst[1] = cpu_to_le32(b0[1]); dst[2] = cpu_to_le32(b0[2]); dst[3] = cpu_to_le32(b0[3]); } static struct crypto_alg aes_alg = { .cra_name = "aes", .cra_driver_name = "aes-generic", .cra_priority = 100, .cra_flags = CRYPTO_ALG_TYPE_CIPHER, .cra_blocksize = AES_BLOCK_SIZE, .cra_ctxsize = sizeof(struct crypto_aes_ctx), .cra_alignmask = 3, .cra_module = THIS_MODULE, .cra_u = { .cipher = { .cia_min_keysize = AES_MIN_KEY_SIZE, .cia_max_keysize = AES_MAX_KEY_SIZE, .cia_setkey = crypto_aes_set_key, .cia_encrypt = aes_encrypt, .cia_decrypt = aes_decrypt } } }; static int __init aes_init(void) { return crypto_register_alg(&aes_alg); } static void __exit aes_fini(void) { crypto_unregister_alg(&aes_alg); } module_init(aes_init); module_exit(aes_fini); MODULE_DESCRIPTION("Rijndael (AES) Cipher Algorithm"); MODULE_LICENSE("Dual BSD/GPL"); MODULE_ALIAS_CRYPTO("aes");	./CrossVul/dataset_final_sorted/CWE-264/c/good_5861_45
crossvul-cpp_data_bad_5861_4	/* * aes-ccm-glue.c - AES-CCM transform for ARMv8 with Crypto Extensions * * Copyright (C) 2013 - 2014 Linaro Ltd <ard.biesheuvel@linaro.org> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. / #include <asm/neon.h> #include <asm/unaligned.h> #include <crypto/aes.h> #include <crypto/algapi.h> #include <crypto/scatterwalk.h> #include <linux/crypto.h> #include <linux/module.h> static int num_rounds(struct crypto_aes_ctx ctx) { /* * # of rounds specified by AES: * 128 bit key 10 rounds * 192 bit key 12 rounds * 256 bit key 14 rounds * => n byte key => 6 + (n/4) rounds / return 6 + ctx->key_length / 4; } asmlinkage void ce_aes_ccm_auth_data(u8 mac[], u8 const in[], u32 abytes, u32 macp, u32 const rk[], u32 rounds); asmlinkage void ce_aes_ccm_encrypt(u8 out[], u8 const in[], u32 cbytes, u32 const rk[], u32 rounds, u8 mac[], u8 ctr[]); asmlinkage void ce_aes_ccm_decrypt(u8 out[], u8 const in[], u32 cbytes, u32 const rk[], u32 rounds, u8 mac[], u8 ctr[]); asmlinkage void ce_aes_ccm_final(u8 mac[], u8 const ctr[], u32 const rk[], u32 rounds); static int ccm_setkey(struct crypto_aead tfm, const u8 in_key, unsigned int key_len) { struct crypto_aes_ctx ctx = crypto_aead_ctx(tfm); int ret; ret = crypto_aes_expand_key(ctx, in_key, key_len); if (!ret) return 0; tfm->base.crt_flags \|= CRYPTO_TFM_RES_BAD_KEY_LEN; return -EINVAL; } static int ccm_setauthsize(struct crypto_aead tfm, unsigned int authsize) { if ((authsize & 1) \|\| authsize < 4) return -EINVAL; return 0; } static int ccm_init_mac(struct aead_request req, u8 maciv[], u32 msglen) { struct crypto_aead aead = crypto_aead_reqtfm(req); __be32 n = (__be32 )&maciv[AES_BLOCK_SIZE - 8]; u32 l = req->iv[0] + 1; /* verify that CCM dimension 'L' is set correctly in the IV / if (l < 2 \|\| l > 8) return -EINVAL; / verify that msglen can in fact be represented in L bytes / if (l < 4 && msglen >> (8 l)) return -EOVERFLOW; /* * Even if the CCM spec allows L values of up to 8, the Linux cryptoapi * uses a u32 type to represent msglen so the top 4 bytes are always 0. / n[0] = 0; n[1] = cpu_to_be32(msglen); memcpy(maciv, req->iv, AES_BLOCK_SIZE - l); / * Meaning of byte 0 according to CCM spec (RFC 3610/NIST 800-38C) * - bits 0..2 : max # of bytes required to represent msglen, minus 1 * (already set by caller) * - bits 3..5 : size of auth tag (1 => 4 bytes, 2 => 6 bytes, etc) * - bit 6 : indicates presence of authenticate-only data / maciv[0] \|= (crypto_aead_authsize(aead) - 2) << 2; if (req->assoclen) maciv[0] \|= 0x40; memset(&req->iv[AES_BLOCK_SIZE - l], 0, l); return 0; } static void ccm_calculate_auth_mac(struct aead_request req, u8 mac[]) { struct crypto_aead aead = crypto_aead_reqtfm(req); struct crypto_aes_ctx ctx = crypto_aead_ctx(aead); struct __packed { __be16 l; __be32 h; u16 len; } ltag; struct scatter_walk walk; u32 len = req->assoclen; u32 macp = 0; /* prepend the AAD with a length tag / if (len < 0xff00) { ltag.l = cpu_to_be16(len); ltag.len = 2; } else { ltag.l = cpu_to_be16(0xfffe); put_unaligned_be32(len, &ltag.h); ltag.len = 6; } ce_aes_ccm_auth_data(mac, (u8 )&ltag, ltag.len, &macp, ctx->key_enc, num_rounds(ctx)); scatterwalk_start(&walk, req->assoc); do { u32 n = scatterwalk_clamp(&walk, len); u8 p; if (!n) { scatterwalk_start(&walk, sg_next(walk.sg)); n = scatterwalk_clamp(&walk, len); } p = scatterwalk_map(&walk); ce_aes_ccm_auth_data(mac, p, n, &macp, ctx->key_enc, num_rounds(ctx)); len -= n; scatterwalk_unmap(p); scatterwalk_advance(&walk, n); scatterwalk_done(&walk, 0, len); } while (len); } static int ccm_encrypt(struct aead_request req) { struct crypto_aead aead = crypto_aead_reqtfm(req); struct crypto_aes_ctx ctx = crypto_aead_ctx(aead); struct blkcipher_desc desc = { .info = req->iv }; struct blkcipher_walk walk; u8 __aligned(8) mac[AES_BLOCK_SIZE]; u8 buf[AES_BLOCK_SIZE]; u32 len = req->cryptlen; int err; err = ccm_init_mac(req, mac, len); if (err) return err; kernel_neon_begin_partial(6); if (req->assoclen) ccm_calculate_auth_mac(req, mac); /* preserve the original iv for the final round / memcpy(buf, req->iv, AES_BLOCK_SIZE); blkcipher_walk_init(&walk, req->dst, req->src, len); err = blkcipher_aead_walk_virt_block(&desc, &walk, aead, AES_BLOCK_SIZE); while (walk.nbytes) { u32 tail = walk.nbytes % AES_BLOCK_SIZE; if (walk.nbytes == len) tail = 0; ce_aes_ccm_encrypt(walk.dst.virt.addr, walk.src.virt.addr, walk.nbytes - tail, ctx->key_enc, num_rounds(ctx), mac, walk.iv); len -= walk.nbytes - tail; err = blkcipher_walk_done(&desc, &walk, tail); } if (!err) ce_aes_ccm_final(mac, buf, ctx->key_enc, num_rounds(ctx)); kernel_neon_end(); if (err) return err; / copy authtag to end of dst / scatterwalk_map_and_copy(mac, req->dst, req->cryptlen, crypto_aead_authsize(aead), 1); return 0; } static int ccm_decrypt(struct aead_request req) { struct crypto_aead aead = crypto_aead_reqtfm(req); struct crypto_aes_ctx ctx = crypto_aead_ctx(aead); unsigned int authsize = crypto_aead_authsize(aead); struct blkcipher_desc desc = { .info = req->iv }; struct blkcipher_walk walk; u8 __aligned(8) mac[AES_BLOCK_SIZE]; u8 buf[AES_BLOCK_SIZE]; u32 len = req->cryptlen - authsize; int err; err = ccm_init_mac(req, mac, len); if (err) return err; kernel_neon_begin_partial(6); if (req->assoclen) ccm_calculate_auth_mac(req, mac); /* preserve the original iv for the final round / memcpy(buf, req->iv, AES_BLOCK_SIZE); blkcipher_walk_init(&walk, req->dst, req->src, len); err = blkcipher_aead_walk_virt_block(&desc, &walk, aead, AES_BLOCK_SIZE); while (walk.nbytes) { u32 tail = walk.nbytes % AES_BLOCK_SIZE; if (walk.nbytes == len) tail = 0; ce_aes_ccm_decrypt(walk.dst.virt.addr, walk.src.virt.addr, walk.nbytes - tail, ctx->key_enc, num_rounds(ctx), mac, walk.iv); len -= walk.nbytes - tail; err = blkcipher_walk_done(&desc, &walk, tail); } if (!err) ce_aes_ccm_final(mac, buf, ctx->key_enc, num_rounds(ctx)); kernel_neon_end(); if (err) return err; / compare calculated auth tag with the stored one */ scatterwalk_map_and_copy(buf, req->src, req->cryptlen - authsize, authsize, 0); if (memcmp(mac, buf, authsize)) return -EBADMSG; return 0; } static struct crypto_alg ccm_aes_alg = { .cra_name = "ccm(aes)", .cra_driver_name = "ccm-aes-ce", .cra_priority = 300, .cra_flags = CRYPTO_ALG_TYPE_AEAD, .cra_blocksize = 1, .cra_ctxsize = sizeof(struct crypto_aes_ctx), .cra_alignmask = 7, .cra_type = &crypto_aead_type, .cra_module = THIS_MODULE, .cra_aead = { .ivsize = AES_BLOCK_SIZE, .maxauthsize = AES_BLOCK_SIZE, .setkey = ccm_setkey, .setauthsize = ccm_setauthsize, .encrypt = ccm_encrypt, .decrypt = ccm_decrypt, } }; static int __init aes_mod_init(void) { if (!(elf_hwcap & HWCAP_AES)) return -ENODEV; return crypto_register_alg(&ccm_aes_alg); } static void __exit aes_mod_exit(void) { crypto_unregister_alg(&ccm_aes_alg); } module_init(aes_mod_init); module_exit(aes_mod_exit); MODULE_DESCRIPTION("Synchronous AES in CCM mode using ARMv8 Crypto Extensions"); MODULE_AUTHOR("Ard Biesheuvel <ard.biesheuvel@linaro.org>"); MODULE_LICENSE("GPL v2"); MODULE_ALIAS("ccm(aes)");	./CrossVul/dataset_final_sorted/CWE-264/c/bad_5861_4
crossvul-cpp_data_bad_2191_0	/******************************************************************************* * Filename: target_core_rd.c * * This file contains the Storage Engine <-> Ramdisk transport * specific functions. * * (c) Copyright 2003-2013 Datera, Inc. * * Nicholas A. Bellinger <nab@kernel.org> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * *****************************************************************************/ #include <linux/string.h> #include <linux/parser.h> #include <linux/timer.h> #include <linux/slab.h> #include <linux/spinlock.h> #include <scsi/scsi.h> #include <scsi/scsi_host.h> #include <target/target_core_base.h> #include <target/target_core_backend.h> #include "target_core_rd.h" static inline struct rd_dev RD_DEV(struct se_device dev) { return container_of(dev, struct rd_dev, dev); } / rd_attach_hba(): (Part of se_subsystem_api_t template) * * / static int rd_attach_hba(struct se_hba hba, u32 host_id) { struct rd_host rd_host; rd_host = kzalloc(sizeof(struct rd_host), GFP_KERNEL); if (!rd_host) { pr_err("Unable to allocate memory for struct rd_host\n"); return -ENOMEM; } rd_host->rd_host_id = host_id; hba->hba_ptr = rd_host; pr_debug("CORE_HBA[%d] - TCM Ramdisk HBA Driver %s on" " Generic Target Core Stack %s\n", hba->hba_id, RD_HBA_VERSION, TARGET_CORE_MOD_VERSION); return 0; } static void rd_detach_hba(struct se_hba hba) { struct rd_host rd_host = hba->hba_ptr; pr_debug("CORE_HBA[%d] - Detached Ramdisk HBA: %u from" " Generic Target Core\n", hba->hba_id, rd_host->rd_host_id); kfree(rd_host); hba->hba_ptr = NULL; } / rd_release_device_space(): * * / static void rd_release_device_space(struct rd_dev rd_dev) { u32 i, j, page_count = 0, sg_per_table; struct rd_dev_sg_table sg_table; struct page pg; struct scatterlist sg; if (!rd_dev->sg_table_array \|\| !rd_dev->sg_table_count) return; sg_table = rd_dev->sg_table_array; for (i = 0; i < rd_dev->sg_table_count; i++) { sg = sg_table[i].sg_table; sg_per_table = sg_table[i].rd_sg_count; for (j = 0; j < sg_per_table; j++) { pg = sg_page(&sg[j]); if (pg) { __free_page(pg); page_count++; } } kfree(sg); } pr_debug("CORE_RD[%u] - Released device space for Ramdisk" " Device ID: %u, pages %u in %u tables total bytes %lu\n", rd_dev->rd_host->rd_host_id, rd_dev->rd_dev_id, page_count, rd_dev->sg_table_count, (unsigned long)page_count PAGE_SIZE); kfree(sg_table); rd_dev->sg_table_array = NULL; rd_dev->sg_table_count = 0; } /* rd_build_device_space(): * * / static int rd_build_device_space(struct rd_dev rd_dev) { u32 i = 0, j, page_offset = 0, sg_per_table, sg_tables, total_sg_needed; u32 max_sg_per_table = (RD_MAX_ALLOCATION_SIZE / sizeof(struct scatterlist)); struct rd_dev_sg_table sg_table; struct page pg; struct scatterlist sg; if (rd_dev->rd_page_count <= 0) { pr_err("Illegal page count: %u for Ramdisk device\n", rd_dev->rd_page_count); return -EINVAL; } / Don't need backing pages for NULLIO / if (rd_dev->rd_flags & RDF_NULLIO) return 0; total_sg_needed = rd_dev->rd_page_count; sg_tables = (total_sg_needed / max_sg_per_table) + 1; sg_table = kzalloc(sg_tables sizeof(struct rd_dev_sg_table), GFP_KERNEL); if (!sg_table) { pr_err("Unable to allocate memory for Ramdisk" " scatterlist tables\n"); return -ENOMEM; } rd_dev->sg_table_array = sg_table; rd_dev->sg_table_count = sg_tables; while (total_sg_needed) { sg_per_table = (total_sg_needed > max_sg_per_table) ? max_sg_per_table : total_sg_needed; sg = kzalloc(sg_per_table * sizeof(struct scatterlist), GFP_KERNEL); if (!sg) { pr_err("Unable to allocate scatterlist array" " for struct rd_dev\n"); return -ENOMEM; } sg_init_table(sg, sg_per_table); sg_table[i].sg_table = sg; sg_table[i].rd_sg_count = sg_per_table; sg_table[i].page_start_offset = page_offset; sg_table[i++].page_end_offset = (page_offset + sg_per_table) - 1; for (j = 0; j < sg_per_table; j++) { pg = alloc_pages(GFP_KERNEL, 0); if (!pg) { pr_err("Unable to allocate scatterlist" " pages for struct rd_dev_sg_table\n"); return -ENOMEM; } sg_assign_page(&sg[j], pg); sg[j].length = PAGE_SIZE; } page_offset += sg_per_table; total_sg_needed -= sg_per_table; } pr_debug("CORE_RD[%u] - Built Ramdisk Device ID: %u space of" " %u pages in %u tables\n", rd_dev->rd_host->rd_host_id, rd_dev->rd_dev_id, rd_dev->rd_page_count, rd_dev->sg_table_count); return 0; } static struct se_device rd_alloc_device(struct se_hba hba, const char name) { struct rd_dev rd_dev; struct rd_host rd_host = hba->hba_ptr; rd_dev = kzalloc(sizeof(struct rd_dev), GFP_KERNEL); if (!rd_dev) { pr_err("Unable to allocate memory for struct rd_dev\n"); return NULL; } rd_dev->rd_host = rd_host; return &rd_dev->dev; } static int rd_configure_device(struct se_device dev) { struct rd_dev rd_dev = RD_DEV(dev); struct rd_host rd_host = dev->se_hba->hba_ptr; int ret; if (!(rd_dev->rd_flags & RDF_HAS_PAGE_COUNT)) { pr_debug("Missing rd_pages= parameter\n"); return -EINVAL; } ret = rd_build_device_space(rd_dev); if (ret < 0) goto fail; dev->dev_attrib.hw_block_size = RD_BLOCKSIZE; dev->dev_attrib.hw_max_sectors = UINT_MAX; dev->dev_attrib.hw_queue_depth = RD_MAX_DEVICE_QUEUE_DEPTH; rd_dev->rd_dev_id = rd_host->rd_host_dev_id_count++; pr_debug("CORE_RD[%u] - Added TCM MEMCPY Ramdisk Device ID: %u of" " %u pages in %u tables, %lu total bytes\n", rd_host->rd_host_id, rd_dev->rd_dev_id, rd_dev->rd_page_count, rd_dev->sg_table_count, (unsigned long)(rd_dev->rd_page_count * PAGE_SIZE)); return 0; fail: rd_release_device_space(rd_dev); return ret; } static void rd_free_device(struct se_device dev) { struct rd_dev rd_dev = RD_DEV(dev); rd_release_device_space(rd_dev); kfree(rd_dev); } static struct rd_dev_sg_table rd_get_sg_table(struct rd_dev rd_dev, u32 page) { struct rd_dev_sg_table sg_table; u32 i, sg_per_table = (RD_MAX_ALLOCATION_SIZE / sizeof(struct scatterlist)); i = page / sg_per_table; if (i < rd_dev->sg_table_count) { sg_table = &rd_dev->sg_table_array[i]; if ((sg_table->page_start_offset <= page) && (sg_table->page_end_offset >= page)) return sg_table; } pr_err("Unable to locate struct rd_dev_sg_table for page: %u\n", page); return NULL; } static sense_reason_t rd_execute_rw(struct se_cmd cmd, struct scatterlist sgl, u32 sgl_nents, enum dma_data_direction data_direction) { struct se_device se_dev = cmd->se_dev; struct rd_dev dev = RD_DEV(se_dev); struct rd_dev_sg_table table; struct scatterlist rd_sg; struct sg_mapping_iter m; u32 rd_offset; u32 rd_size; u32 rd_page; u32 src_len; u64 tmp; if (dev->rd_flags & RDF_NULLIO) { target_complete_cmd(cmd, SAM_STAT_GOOD); return 0; } tmp = cmd->t_task_lba se_dev->dev_attrib.block_size; rd_offset = do_div(tmp, PAGE_SIZE); rd_page = tmp; rd_size = cmd->data_length; table = rd_get_sg_table(dev, rd_page); if (!table) return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; rd_sg = &table->sg_table[rd_page - table->page_start_offset]; pr_debug("RD[%u]: %s LBA: %llu, Size: %u Page: %u, Offset: %u\n", dev->rd_dev_id, data_direction == DMA_FROM_DEVICE ? "Read" : "Write", cmd->t_task_lba, rd_size, rd_page, rd_offset); src_len = PAGE_SIZE - rd_offset; sg_miter_start(&m, sgl, sgl_nents, data_direction == DMA_FROM_DEVICE ? SG_MITER_TO_SG : SG_MITER_FROM_SG); while (rd_size) { u32 len; void rd_addr; sg_miter_next(&m); if (!(u32)m.length) { pr_debug("RD[%u]: invalid sgl %p len %zu\n", dev->rd_dev_id, m.addr, m.length); sg_miter_stop(&m); return TCM_INCORRECT_AMOUNT_OF_DATA; } len = min((u32)m.length, src_len); if (len > rd_size) { pr_debug("RD[%u]: size underrun page %d offset %d " "size %d\n", dev->rd_dev_id, rd_page, rd_offset, rd_size); len = rd_size; } m.consumed = len; rd_addr = sg_virt(rd_sg) + rd_offset; if (data_direction == DMA_FROM_DEVICE) memcpy(m.addr, rd_addr, len); else memcpy(rd_addr, m.addr, len); rd_size -= len; if (!rd_size) continue; src_len -= len; if (src_len) { rd_offset += len; continue; } / rd page completed, next one please / rd_page++; rd_offset = 0; src_len = PAGE_SIZE; if (rd_page <= table->page_end_offset) { rd_sg++; continue; } table = rd_get_sg_table(dev, rd_page); if (!table) { sg_miter_stop(&m); return TCM_LOGICAL_UNIT_COMMUNICATION_FAILURE; } / since we increment, the first sg entry is correct / rd_sg = table->sg_table; } sg_miter_stop(&m); target_complete_cmd(cmd, SAM_STAT_GOOD); return 0; } enum { Opt_rd_pages, Opt_rd_nullio, Opt_err }; static match_table_t tokens = { {Opt_rd_pages, "rd_pages=%d"}, {Opt_rd_nullio, "rd_nullio=%d"}, {Opt_err, NULL} }; static ssize_t rd_set_configfs_dev_params(struct se_device dev, const char page, ssize_t count) { struct rd_dev rd_dev = RD_DEV(dev); char orig, ptr, opts; substring_t args[MAX_OPT_ARGS]; int ret = 0, arg, token; opts = kstrdup(page, GFP_KERNEL); if (!opts) return -ENOMEM; orig = opts; while ((ptr = strsep(&opts, ",\n")) != NULL) { if (!ptr) continue; token = match_token(ptr, tokens, args); switch (token) { case Opt_rd_pages: match_int(args, &arg); rd_dev->rd_page_count = arg; pr_debug("RAMDISK: Referencing Page" " Count: %u\n", rd_dev->rd_page_count); rd_dev->rd_flags \|= RDF_HAS_PAGE_COUNT; break; case Opt_rd_nullio: match_int(args, &arg); if (arg != 1) break; pr_debug("RAMDISK: Setting NULLIO flag: %d\n", arg); rd_dev->rd_flags \|= RDF_NULLIO; break; default: break; } } kfree(orig); return (!ret) ? count : ret; } static ssize_t rd_show_configfs_dev_params(struct se_device dev, char b) { struct rd_dev rd_dev = RD_DEV(dev); ssize_t bl = sprintf(b, "TCM RamDisk ID: %u RamDisk Makeup: rd_mcp\n", rd_dev->rd_dev_id); bl += sprintf(b + bl, " PAGES/PAGE_SIZE: %u%lu" " SG_table_count: %u nullio: %d\n", rd_dev->rd_page_count, PAGE_SIZE, rd_dev->sg_table_count, !!(rd_dev->rd_flags & RDF_NULLIO)); return bl; } static sector_t rd_get_blocks(struct se_device dev) { struct rd_dev rd_dev = RD_DEV(dev); unsigned long long blocks_long = ((rd_dev->rd_page_count * PAGE_SIZE) / dev->dev_attrib.block_size) - 1; return blocks_long; } static struct sbc_ops rd_sbc_ops = { .execute_rw = rd_execute_rw, }; static sense_reason_t rd_parse_cdb(struct se_cmd *cmd) { return sbc_parse_cdb(cmd, &rd_sbc_ops); } static struct se_subsystem_api rd_mcp_template = { .name = "rd_mcp", .inquiry_prod = "RAMDISK-MCP", .inquiry_rev = RD_MCP_VERSION, .transport_type = TRANSPORT_PLUGIN_VHBA_VDEV, .attach_hba = rd_attach_hba, .detach_hba = rd_detach_hba, .alloc_device = rd_alloc_device, .configure_device = rd_configure_device, .free_device = rd_free_device, .parse_cdb = rd_parse_cdb, .set_configfs_dev_params = rd_set_configfs_dev_params, .show_configfs_dev_params = rd_show_configfs_dev_params, .get_device_type = sbc_get_device_type, .get_blocks = rd_get_blocks, }; int __init rd_module_init(void) { int ret; ret = transport_subsystem_register(&rd_mcp_template); if (ret < 0) { return ret; } return 0; } void rd_module_exit(void) { transport_subsystem_release(&rd_mcp_template); }	./CrossVul/dataset_final_sorted/CWE-264/c/bad_2191_0
crossvul-cpp_data_bad_5351_0	404: Not Found	./CrossVul/dataset_final_sorted/CWE-264/c/bad_5351_0
crossvul-cpp_data_good_3438_1	/* * NET3 Protocol independent device support routines. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version. * * Derived from the non IP parts of dev.c 1.0.19 * Authors: Ross Biro * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> * Mark Evans, <evansmp@uhura.aston.ac.uk> * * Additional Authors: * Florian la Roche <rzsfl@rz.uni-sb.de> * Alan Cox <gw4pts@gw4pts.ampr.org> * David Hinds <dahinds@users.sourceforge.net> * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru> * Adam Sulmicki <adam@cfar.umd.edu> * Pekka Riikonen <priikone@poesidon.pspt.fi> * * Changes: * D.J. Barrow : Fixed bug where dev->refcnt gets set * to 2 if register_netdev gets called * before net_dev_init & also removed a * few lines of code in the process. * Alan Cox : device private ioctl copies fields back. * Alan Cox : Transmit queue code does relevant * stunts to keep the queue safe. * Alan Cox : Fixed double lock. * Alan Cox : Fixed promisc NULL pointer trap * ???????? : Support the full private ioctl range * Alan Cox : Moved ioctl permission check into * drivers * Tim Kordas : SIOCADDMULTI/SIOCDELMULTI * Alan Cox : 100 backlog just doesn't cut it when * you start doing multicast video 8) * Alan Cox : Rewrote net_bh and list manager. * Alan Cox : Fix ETH_P_ALL echoback lengths. * Alan Cox : Took out transmit every packet pass * Saved a few bytes in the ioctl handler * Alan Cox : Network driver sets packet type before * calling netif_rx. Saves a function * call a packet. * Alan Cox : Hashed net_bh() * Richard Kooijman: Timestamp fixes. * Alan Cox : Wrong field in SIOCGIFDSTADDR * Alan Cox : Device lock protection. * Alan Cox : Fixed nasty side effect of device close * changes. * Rudi Cilibrasi : Pass the right thing to * set_mac_address() * Dave Miller : 32bit quantity for the device lock to * make it work out on a Sparc. * Bjorn Ekwall : Added KERNELD hack. * Alan Cox : Cleaned up the backlog initialise. * Craig Metz : SIOCGIFCONF fix if space for under * 1 device. * Thomas Bogendoerfer : Return ENODEV for dev_open, if there * is no device open function. * Andi Kleen : Fix error reporting for SIOCGIFCONF * Michael Chastain : Fix signed/unsigned for SIOCGIFCONF * Cyrus Durgin : Cleaned for KMOD * Adam Sulmicki : Bug Fix : Network Device Unload * A network device unload needs to purge * the backlog queue. * Paul Rusty Russell : SIOCSIFNAME * Pekka Riikonen : Netdev boot-time settings code * Andrew Morton : Make unregister_netdevice wait * indefinitely on dev->refcnt * J Hadi Salim : - Backlog queue sampling * - netif_rx() feedback / #include <asm/uaccess.h> #include <asm/system.h> #include <linux/bitops.h> #include <linux/capability.h> #include <linux/cpu.h> #include <linux/types.h> #include <linux/kernel.h> #include <linux/hash.h> #include <linux/slab.h> #include <linux/sched.h> #include <linux/mutex.h> #include <linux/string.h> #include <linux/mm.h> #include <linux/socket.h> #include <linux/sockios.h> #include <linux/errno.h> #include <linux/interrupt.h> #include <linux/if_ether.h> #include <linux/netdevice.h> #include <linux/etherdevice.h> #include <linux/ethtool.h> #include <linux/notifier.h> #include <linux/skbuff.h> #include <net/net_namespace.h> #include <net/sock.h> #include <linux/rtnetlink.h> #include <linux/proc_fs.h> #include <linux/seq_file.h> #include <linux/stat.h> #include <net/dst.h> #include <net/pkt_sched.h> #include <net/checksum.h> #include <net/xfrm.h> #include <linux/highmem.h> #include <linux/init.h> #include <linux/kmod.h> #include <linux/module.h> #include <linux/netpoll.h> #include <linux/rcupdate.h> #include <linux/delay.h> #include <net/wext.h> #include <net/iw_handler.h> #include <asm/current.h> #include <linux/audit.h> #include <linux/dmaengine.h> #include <linux/err.h> #include <linux/ctype.h> #include <linux/if_arp.h> #include <linux/if_vlan.h> #include <linux/ip.h> #include <net/ip.h> #include <linux/ipv6.h> #include <linux/in.h> #include <linux/jhash.h> #include <linux/random.h> #include <trace/events/napi.h> #include <trace/events/net.h> #include <trace/events/skb.h> #include <linux/pci.h> #include <linux/inetdevice.h> #include "net-sysfs.h" / Instead of increasing this, you should create a hash table. / #define MAX_GRO_SKBS 8 / This should be increased if a protocol with a bigger head is added. / #define GRO_MAX_HEAD (MAX_HEADER + 128) / * The list of packet types we will receive (as opposed to discard) * and the routines to invoke. * * Why 16. Because with 16 the only overlap we get on a hash of the * low nibble of the protocol value is RARP/SNAP/X.25. * * NOTE: That is no longer true with the addition of VLAN tags. Not * sure which should go first, but I bet it won't make much * difference if we are running VLANs. The good news is that * this protocol won't be in the list unless compiled in, so * the average user (w/out VLANs) will not be adversely affected. * --BLG * * 0800 IP * 8100 802.1Q VLAN * 0001 802.3 * 0002 AX.25 * 0004 802.2 * 8035 RARP * 0005 SNAP * 0805 X.25 * 0806 ARP * 8137 IPX * 0009 Localtalk * 86DD IPv6 / #define PTYPE_HASH_SIZE (16) #define PTYPE_HASH_MASK (PTYPE_HASH_SIZE - 1) static DEFINE_SPINLOCK(ptype_lock); static struct list_head ptype_base[PTYPE_HASH_SIZE] __read_mostly; static struct list_head ptype_all __read_mostly; / Taps / / * The @dev_base_head list is protected by @dev_base_lock and the rtnl * semaphore. * * Pure readers hold dev_base_lock for reading, or rcu_read_lock() * * Writers must hold the rtnl semaphore while they loop through the * dev_base_head list, and hold dev_base_lock for writing when they do the * actual updates. This allows pure readers to access the list even * while a writer is preparing to update it. * * To put it another way, dev_base_lock is held for writing only to * protect against pure readers; the rtnl semaphore provides the * protection against other writers. * * See, for example usages, register_netdevice() and * unregister_netdevice(), which must be called with the rtnl * semaphore held. / DEFINE_RWLOCK(dev_base_lock); EXPORT_SYMBOL(dev_base_lock); static inline struct hlist_head dev_name_hash(struct net net, const char name) { unsigned hash = full_name_hash(name, strnlen(name, IFNAMSIZ)); return &net->dev_name_head[hash_32(hash, NETDEV_HASHBITS)]; } static inline struct hlist_head dev_index_hash(struct net net, int ifindex) { return &net->dev_index_head[ifindex & (NETDEV_HASHENTRIES - 1)]; } static inline void rps_lock(struct softnet_data sd) { #ifdef CONFIG_RPS spin_lock(&sd->input_pkt_queue.lock); #endif } static inline void rps_unlock(struct softnet_data sd) { #ifdef CONFIG_RPS spin_unlock(&sd->input_pkt_queue.lock); #endif } /* Device list insertion / static int list_netdevice(struct net_device dev) { struct net net = dev_net(dev); ASSERT_RTNL(); write_lock_bh(&dev_base_lock); list_add_tail_rcu(&dev->dev_list, &net->dev_base_head); hlist_add_head_rcu(&dev->name_hlist, dev_name_hash(net, dev->name)); hlist_add_head_rcu(&dev->index_hlist, dev_index_hash(net, dev->ifindex)); write_unlock_bh(&dev_base_lock); return 0; } / Device list removal * caller must respect a RCU grace period before freeing/reusing dev / static void unlist_netdevice(struct net_device dev) { ASSERT_RTNL(); /* Unlink dev from the device chain / write_lock_bh(&dev_base_lock); list_del_rcu(&dev->dev_list); hlist_del_rcu(&dev->name_hlist); hlist_del_rcu(&dev->index_hlist); write_unlock_bh(&dev_base_lock); } / * Our notifier list / static RAW_NOTIFIER_HEAD(netdev_chain); / * Device drivers call our routines to queue packets here. We empty the * queue in the local softnet handler. / DEFINE_PER_CPU_ALIGNED(struct softnet_data, softnet_data); EXPORT_PER_CPU_SYMBOL(softnet_data); #ifdef CONFIG_LOCKDEP / * register_netdevice() inits txq->_xmit_lock and sets lockdep class * according to dev->type / static const unsigned short netdev_lock_type[] = {ARPHRD_NETROM, ARPHRD_ETHER, ARPHRD_EETHER, ARPHRD_AX25, ARPHRD_PRONET, ARPHRD_CHAOS, ARPHRD_IEEE802, ARPHRD_ARCNET, ARPHRD_APPLETLK, ARPHRD_DLCI, ARPHRD_ATM, ARPHRD_METRICOM, ARPHRD_IEEE1394, ARPHRD_EUI64, ARPHRD_INFINIBAND, ARPHRD_SLIP, ARPHRD_CSLIP, ARPHRD_SLIP6, ARPHRD_CSLIP6, ARPHRD_RSRVD, ARPHRD_ADAPT, ARPHRD_ROSE, ARPHRD_X25, ARPHRD_HWX25, ARPHRD_PPP, ARPHRD_CISCO, ARPHRD_LAPB, ARPHRD_DDCMP, ARPHRD_RAWHDLC, ARPHRD_TUNNEL, ARPHRD_TUNNEL6, ARPHRD_FRAD, ARPHRD_SKIP, ARPHRD_LOOPBACK, ARPHRD_LOCALTLK, ARPHRD_FDDI, ARPHRD_BIF, ARPHRD_SIT, ARPHRD_IPDDP, ARPHRD_IPGRE, ARPHRD_PIMREG, ARPHRD_HIPPI, ARPHRD_ASH, ARPHRD_ECONET, ARPHRD_IRDA, ARPHRD_FCPP, ARPHRD_FCAL, ARPHRD_FCPL, ARPHRD_FCFABRIC, ARPHRD_IEEE802_TR, ARPHRD_IEEE80211, ARPHRD_IEEE80211_PRISM, ARPHRD_IEEE80211_RADIOTAP, ARPHRD_PHONET, ARPHRD_PHONET_PIPE, ARPHRD_IEEE802154, ARPHRD_VOID, ARPHRD_NONE}; static const char const netdev_lock_name[] = {"_xmit_NETROM", "_xmit_ETHER", "_xmit_EETHER", "_xmit_AX25", "_xmit_PRONET", "_xmit_CHAOS", "_xmit_IEEE802", "_xmit_ARCNET", "_xmit_APPLETLK", "_xmit_DLCI", "_xmit_ATM", "_xmit_METRICOM", "_xmit_IEEE1394", "_xmit_EUI64", "_xmit_INFINIBAND", "_xmit_SLIP", "_xmit_CSLIP", "_xmit_SLIP6", "_xmit_CSLIP6", "_xmit_RSRVD", "_xmit_ADAPT", "_xmit_ROSE", "_xmit_X25", "_xmit_HWX25", "_xmit_PPP", "_xmit_CISCO", "_xmit_LAPB", "_xmit_DDCMP", "_xmit_RAWHDLC", "_xmit_TUNNEL", "_xmit_TUNNEL6", "_xmit_FRAD", "_xmit_SKIP", "_xmit_LOOPBACK", "_xmit_LOCALTLK", "_xmit_FDDI", "_xmit_BIF", "_xmit_SIT", "_xmit_IPDDP", "_xmit_IPGRE", "_xmit_PIMREG", "_xmit_HIPPI", "_xmit_ASH", "_xmit_ECONET", "_xmit_IRDA", "_xmit_FCPP", "_xmit_FCAL", "_xmit_FCPL", "_xmit_FCFABRIC", "_xmit_IEEE802_TR", "_xmit_IEEE80211", "_xmit_IEEE80211_PRISM", "_xmit_IEEE80211_RADIOTAP", "_xmit_PHONET", "_xmit_PHONET_PIPE", "_xmit_IEEE802154", "_xmit_VOID", "_xmit_NONE"}; static struct lock_class_key netdev_xmit_lock_key[ARRAY_SIZE(netdev_lock_type)]; static struct lock_class_key netdev_addr_lock_key[ARRAY_SIZE(netdev_lock_type)]; static inline unsigned short netdev_lock_pos(unsigned short dev_type) { int i; for (i = 0; i < ARRAY_SIZE(netdev_lock_type); i++) if (netdev_lock_type[i] == dev_type) return i; /* the last key is used by default / return ARRAY_SIZE(netdev_lock_type) - 1; } static inline void netdev_set_xmit_lockdep_class(spinlock_t lock, unsigned short dev_type) { int i; i = netdev_lock_pos(dev_type); lockdep_set_class_and_name(lock, &netdev_xmit_lock_key[i], netdev_lock_name[i]); } static inline void netdev_set_addr_lockdep_class(struct net_device dev) { int i; i = netdev_lock_pos(dev->type); lockdep_set_class_and_name(&dev->addr_list_lock, &netdev_addr_lock_key[i], netdev_lock_name[i]); } #else static inline void netdev_set_xmit_lockdep_class(spinlock_t lock, unsigned short dev_type) { } static inline void netdev_set_addr_lockdep_class(struct net_device dev) { } #endif /**************************************************************************** Protocol management and registration routines ****************************************************************************/ / * Add a protocol ID to the list. Now that the input handler is * smarter we can dispense with all the messy stuff that used to be * here. * * BEWARE!!! Protocol handlers, mangling input packets, * MUST BE last in hash buckets and checking protocol handlers * MUST start from promiscuous ptype_all chain in net_bh. * It is true now, do not change it. * Explanation follows: if protocol handler, mangling packet, will * be the first on list, it is not able to sense, that packet * is cloned and should be copied-on-write, so that it will * change it and subsequent readers will get broken packet. * --ANK (980803) / static inline struct list_head ptype_head(const struct packet_type pt) { if (pt->type == htons(ETH_P_ALL)) return &ptype_all; else return &ptype_base[ntohs(pt->type) & PTYPE_HASH_MASK]; } /* * dev_add_pack - add packet handler * @pt: packet type declaration * * Add a protocol handler to the networking stack. The passed &packet_type * is linked into kernel lists and may not be freed until it has been * removed from the kernel lists. * * This call does not sleep therefore it can not * guarantee all CPU's that are in middle of receiving packets * will see the new packet type (until the next received packet). / void dev_add_pack(struct packet_type pt) { struct list_head head = ptype_head(pt); spin_lock(&ptype_lock); list_add_rcu(&pt->list, head); spin_unlock(&ptype_lock); } EXPORT_SYMBOL(dev_add_pack); /* * __dev_remove_pack - remove packet handler * @pt: packet type declaration * * Remove a protocol handler that was previously added to the kernel * protocol handlers by dev_add_pack(). The passed &packet_type is removed * from the kernel lists and can be freed or reused once this function * returns. * * The packet type might still be in use by receivers * and must not be freed until after all the CPU's have gone * through a quiescent state. / void __dev_remove_pack(struct packet_type pt) { struct list_head head = ptype_head(pt); struct packet_type pt1; spin_lock(&ptype_lock); list_for_each_entry(pt1, head, list) { if (pt == pt1) { list_del_rcu(&pt->list); goto out; } } printk(KERN_WARNING "dev_remove_pack: %p not found.\n", pt); out: spin_unlock(&ptype_lock); } EXPORT_SYMBOL(__dev_remove_pack); /** * dev_remove_pack - remove packet handler * @pt: packet type declaration * * Remove a protocol handler that was previously added to the kernel * protocol handlers by dev_add_pack(). The passed &packet_type is removed * from the kernel lists and can be freed or reused once this function * returns. * * This call sleeps to guarantee that no CPU is looking at the packet * type after return. / void dev_remove_pack(struct packet_type pt) { __dev_remove_pack(pt); synchronize_net(); } EXPORT_SYMBOL(dev_remove_pack); /**************************************************************************** Device Boot-time Settings Routines ****************************************************************************/ / Boot time configuration table / static struct netdev_boot_setup dev_boot_setup[NETDEV_BOOT_SETUP_MAX]; /* * netdev_boot_setup_add - add new setup entry * @name: name of the device * @map: configured settings for the device * * Adds new setup entry to the dev_boot_setup list. The function * returns 0 on error and 1 on success. This is a generic routine to * all netdevices. / static int netdev_boot_setup_add(char name, struct ifmap map) { struct netdev_boot_setup s; int i; s = dev_boot_setup; for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) { if (s[i].name[0] == '\0' \|\| s[i].name[0] == ' ') { memset(s[i].name, 0, sizeof(s[i].name)); strlcpy(s[i].name, name, IFNAMSIZ); memcpy(&s[i].map, map, sizeof(s[i].map)); break; } } return i >= NETDEV_BOOT_SETUP_MAX ? 0 : 1; } /** * netdev_boot_setup_check - check boot time settings * @dev: the netdevice * * Check boot time settings for the device. * The found settings are set for the device to be used * later in the device probing. * Returns 0 if no settings found, 1 if they are. / int netdev_boot_setup_check(struct net_device dev) { struct netdev_boot_setup s = dev_boot_setup; int i; for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) { if (s[i].name[0] != '\0' && s[i].name[0] != ' ' && !strcmp(dev->name, s[i].name)) { dev->irq = s[i].map.irq; dev->base_addr = s[i].map.base_addr; dev->mem_start = s[i].map.mem_start; dev->mem_end = s[i].map.mem_end; return 1; } } return 0; } EXPORT_SYMBOL(netdev_boot_setup_check); /* * netdev_boot_base - get address from boot time settings * @prefix: prefix for network device * @unit: id for network device * * Check boot time settings for the base address of device. * The found settings are set for the device to be used * later in the device probing. * Returns 0 if no settings found. / unsigned long netdev_boot_base(const char prefix, int unit) { const struct netdev_boot_setup s = dev_boot_setup; char name[IFNAMSIZ]; int i; sprintf(name, "%s%d", prefix, unit); / * If device already registered then return base of 1 * to indicate not to probe for this interface / if (__dev_get_by_name(&init_net, name)) return 1; for (i = 0; i < NETDEV_BOOT_SETUP_MAX; i++) if (!strcmp(name, s[i].name)) return s[i].map.base_addr; return 0; } / * Saves at boot time configured settings for any netdevice. / int __init netdev_boot_setup(char str) { int ints[5]; struct ifmap map; str = get_options(str, ARRAY_SIZE(ints), ints); if (!str \|\| !str) return 0; / Save settings / memset(&map, 0, sizeof(map)); if (ints[0] > 0) map.irq = ints[1]; if (ints[0] > 1) map.base_addr = ints[2]; if (ints[0] > 2) map.mem_start = ints[3]; if (ints[0] > 3) map.mem_end = ints[4]; / Add new entry to the list / return netdev_boot_setup_add(str, &map); } __setup("netdev=", netdev_boot_setup); /**************************************************************************** Device Interface Subroutines ***************************************************************************/ / * __dev_get_by_name - find a device by its name * @net: the applicable net namespace * @name: name to find * * Find an interface by name. Must be called under RTNL semaphore * or @dev_base_lock. If the name is found a pointer to the device * is returned. If the name is not found then %NULL is returned. The * reference counters are not incremented so the caller must be * careful with locks. / struct net_device __dev_get_by_name(struct net net, const char name) { struct hlist_node p; struct net_device dev; struct hlist_head head = dev_name_hash(net, name); hlist_for_each_entry(dev, p, head, name_hlist) if (!strncmp(dev->name, name, IFNAMSIZ)) return dev; return NULL; } EXPORT_SYMBOL(__dev_get_by_name); /* * dev_get_by_name_rcu - find a device by its name * @net: the applicable net namespace * @name: name to find * * Find an interface by name. * If the name is found a pointer to the device is returned. * If the name is not found then %NULL is returned. * The reference counters are not incremented so the caller must be * careful with locks. The caller must hold RCU lock. / struct net_device dev_get_by_name_rcu(struct net net, const char name) { struct hlist_node p; struct net_device dev; struct hlist_head head = dev_name_hash(net, name); hlist_for_each_entry_rcu(dev, p, head, name_hlist) if (!strncmp(dev->name, name, IFNAMSIZ)) return dev; return NULL; } EXPORT_SYMBOL(dev_get_by_name_rcu); /* * dev_get_by_name - find a device by its name * @net: the applicable net namespace * @name: name to find * * Find an interface by name. This can be called from any * context and does its own locking. The returned handle has * the usage count incremented and the caller must use dev_put() to * release it when it is no longer needed. %NULL is returned if no * matching device is found. / struct net_device dev_get_by_name(struct net net, const char name) { struct net_device dev; rcu_read_lock(); dev = dev_get_by_name_rcu(net, name); if (dev) dev_hold(dev); rcu_read_unlock(); return dev; } EXPORT_SYMBOL(dev_get_by_name); /* * __dev_get_by_index - find a device by its ifindex * @net: the applicable net namespace * @ifindex: index of device * * Search for an interface by index. Returns %NULL if the device * is not found or a pointer to the device. The device has not * had its reference counter increased so the caller must be careful * about locking. The caller must hold either the RTNL semaphore * or @dev_base_lock. / struct net_device __dev_get_by_index(struct net net, int ifindex) { struct hlist_node p; struct net_device dev; struct hlist_head head = dev_index_hash(net, ifindex); hlist_for_each_entry(dev, p, head, index_hlist) if (dev->ifindex == ifindex) return dev; return NULL; } EXPORT_SYMBOL(__dev_get_by_index); /** * dev_get_by_index_rcu - find a device by its ifindex * @net: the applicable net namespace * @ifindex: index of device * * Search for an interface by index. Returns %NULL if the device * is not found or a pointer to the device. The device has not * had its reference counter increased so the caller must be careful * about locking. The caller must hold RCU lock. / struct net_device dev_get_by_index_rcu(struct net net, int ifindex) { struct hlist_node p; struct net_device dev; struct hlist_head head = dev_index_hash(net, ifindex); hlist_for_each_entry_rcu(dev, p, head, index_hlist) if (dev->ifindex == ifindex) return dev; return NULL; } EXPORT_SYMBOL(dev_get_by_index_rcu); /** * dev_get_by_index - find a device by its ifindex * @net: the applicable net namespace * @ifindex: index of device * * Search for an interface by index. Returns NULL if the device * is not found or a pointer to the device. The device returned has * had a reference added and the pointer is safe until the user calls * dev_put to indicate they have finished with it. / struct net_device dev_get_by_index(struct net net, int ifindex) { struct net_device dev; rcu_read_lock(); dev = dev_get_by_index_rcu(net, ifindex); if (dev) dev_hold(dev); rcu_read_unlock(); return dev; } EXPORT_SYMBOL(dev_get_by_index); /** * dev_getbyhwaddr_rcu - find a device by its hardware address * @net: the applicable net namespace * @type: media type of device * @ha: hardware address * * Search for an interface by MAC address. Returns NULL if the device * is not found or a pointer to the device. * The caller must hold RCU or RTNL. * The returned device has not had its ref count increased * and the caller must therefore be careful about locking * / struct net_device dev_getbyhwaddr_rcu(struct net net, unsigned short type, const char ha) { struct net_device dev; for_each_netdev_rcu(net, dev) if (dev->type == type && !memcmp(dev->dev_addr, ha, dev->addr_len)) return dev; return NULL; } EXPORT_SYMBOL(dev_getbyhwaddr_rcu); struct net_device __dev_getfirstbyhwtype(struct net net, unsigned short type) { struct net_device dev; ASSERT_RTNL(); for_each_netdev(net, dev) if (dev->type == type) return dev; return NULL; } EXPORT_SYMBOL(__dev_getfirstbyhwtype); struct net_device dev_getfirstbyhwtype(struct net net, unsigned short type) { struct net_device dev, ret = NULL; rcu_read_lock(); for_each_netdev_rcu(net, dev) if (dev->type == type) { dev_hold(dev); ret = dev; break; } rcu_read_unlock(); return ret; } EXPORT_SYMBOL(dev_getfirstbyhwtype); /** * dev_get_by_flags_rcu - find any device with given flags * @net: the applicable net namespace * @if_flags: IFF_* values * @mask: bitmask of bits in if_flags to check * * Search for any interface with the given flags. Returns NULL if a device * is not found or a pointer to the device. Must be called inside * rcu_read_lock(), and result refcount is unchanged. / struct net_device dev_get_by_flags_rcu(struct net net, unsigned short if_flags, unsigned short mask) { struct net_device dev, ret; ret = NULL; for_each_netdev_rcu(net, dev) { if (((dev->flags ^ if_flags) & mask) == 0) { ret = dev; break; } } return ret; } EXPORT_SYMBOL(dev_get_by_flags_rcu); /* * dev_valid_name - check if name is okay for network device * @name: name string * * Network device names need to be valid file names to * to allow sysfs to work. We also disallow any kind of * whitespace. / int dev_valid_name(const char name) { if (name == '\0') return 0; if (strlen(name) >= IFNAMSIZ) return 0; if (!strcmp(name, ".") \|\| !strcmp(name, "..")) return 0; while (name) { if (name == '/' \|\| isspace(name)) return 0; name++; } return 1; } EXPORT_SYMBOL(dev_valid_name); /** * __dev_alloc_name - allocate a name for a device * @net: network namespace to allocate the device name in * @name: name format string * @buf: scratch buffer and result name string * * Passed a format string - eg "lt%d" it will try and find a suitable * id. It scans list of devices to build up a free map, then chooses * the first empty slot. The caller must hold the dev_base or rtnl lock * while allocating the name and adding the device in order to avoid * duplicates. * Limited to bits_per_byte * page size devices (ie 32K on most platforms). * Returns the number of the unit assigned or a negative errno code. / static int __dev_alloc_name(struct net net, const char name, char buf) { int i = 0; const char p; const int max_netdevices = 8PAGE_SIZE; unsigned long inuse; struct net_device d; p = strnchr(name, IFNAMSIZ-1, '%'); if (p) { /* * Verify the string as this thing may have come from * the user. There must be either one "%d" and no other "%" * characters. / if (p[1] != 'd' \|\| strchr(p + 2, '%')) return -EINVAL; / Use one page as a bit array of possible slots / inuse = (unsigned long ) get_zeroed_page(GFP_ATOMIC); if (!inuse) return -ENOMEM; for_each_netdev(net, d) { if (!sscanf(d->name, name, &i)) continue; if (i < 0 \|\| i >= max_netdevices) continue; /* avoid cases where sscanf is not exact inverse of printf / snprintf(buf, IFNAMSIZ, name, i); if (!strncmp(buf, d->name, IFNAMSIZ)) set_bit(i, inuse); } i = find_first_zero_bit(inuse, max_netdevices); free_page((unsigned long) inuse); } if (buf != name) snprintf(buf, IFNAMSIZ, name, i); if (!__dev_get_by_name(net, buf)) return i; / It is possible to run out of possible slots * when the name is long and there isn't enough space left * for the digits, or if all bits are used. / return -ENFILE; } /* * dev_alloc_name - allocate a name for a device * @dev: device * @name: name format string * * Passed a format string - eg "lt%d" it will try and find a suitable * id. It scans list of devices to build up a free map, then chooses * the first empty slot. The caller must hold the dev_base or rtnl lock * while allocating the name and adding the device in order to avoid * duplicates. * Limited to bits_per_byte * page size devices (ie 32K on most platforms). * Returns the number of the unit assigned or a negative errno code. / int dev_alloc_name(struct net_device dev, const char name) { char buf[IFNAMSIZ]; struct net net; int ret; BUG_ON(!dev_net(dev)); net = dev_net(dev); ret = __dev_alloc_name(net, name, buf); if (ret >= 0) strlcpy(dev->name, buf, IFNAMSIZ); return ret; } EXPORT_SYMBOL(dev_alloc_name); static int dev_get_valid_name(struct net_device dev, const char name, bool fmt) { struct net net; BUG_ON(!dev_net(dev)); net = dev_net(dev); if (!dev_valid_name(name)) return -EINVAL; if (fmt && strchr(name, '%')) return dev_alloc_name(dev, name); else if (__dev_get_by_name(net, name)) return -EEXIST; else if (dev->name != name) strlcpy(dev->name, name, IFNAMSIZ); return 0; } /* * dev_change_name - change name of a device * @dev: device * @newname: name (or format string) must be at least IFNAMSIZ * * Change name of a device, can pass format strings "eth%d". * for wildcarding. / int dev_change_name(struct net_device dev, const char newname) { char oldname[IFNAMSIZ]; int err = 0; int ret; struct net net; ASSERT_RTNL(); BUG_ON(!dev_net(dev)); net = dev_net(dev); if (dev->flags & IFF_UP) return -EBUSY; if (strncmp(newname, dev->name, IFNAMSIZ) == 0) return 0; memcpy(oldname, dev->name, IFNAMSIZ); err = dev_get_valid_name(dev, newname, 1); if (err < 0) return err; rollback: ret = device_rename(&dev->dev, dev->name); if (ret) { memcpy(dev->name, oldname, IFNAMSIZ); return ret; } write_lock_bh(&dev_base_lock); hlist_del(&dev->name_hlist); write_unlock_bh(&dev_base_lock); synchronize_rcu(); write_lock_bh(&dev_base_lock); hlist_add_head_rcu(&dev->name_hlist, dev_name_hash(net, dev->name)); write_unlock_bh(&dev_base_lock); ret = call_netdevice_notifiers(NETDEV_CHANGENAME, dev); ret = notifier_to_errno(ret); if (ret) { /* err >= 0 after dev_alloc_name() or stores the first errno / if (err >= 0) { err = ret; memcpy(dev->name, oldname, IFNAMSIZ); goto rollback; } else { printk(KERN_ERR "%s: name change rollback failed: %d.\n", dev->name, ret); } } return err; } /* * dev_set_alias - change ifalias of a device * @dev: device * @alias: name up to IFALIASZ * @len: limit of bytes to copy from info * * Set ifalias for a device, / int dev_set_alias(struct net_device dev, const char alias, size_t len) { ASSERT_RTNL(); if (len >= IFALIASZ) return -EINVAL; if (!len) { if (dev->ifalias) { kfree(dev->ifalias); dev->ifalias = NULL; } return 0; } dev->ifalias = krealloc(dev->ifalias, len + 1, GFP_KERNEL); if (!dev->ifalias) return -ENOMEM; strlcpy(dev->ifalias, alias, len+1); return len; } /* * netdev_features_change - device changes features * @dev: device to cause notification * * Called to indicate a device has changed features. / void netdev_features_change(struct net_device dev) { call_netdevice_notifiers(NETDEV_FEAT_CHANGE, dev); } EXPORT_SYMBOL(netdev_features_change); /** * netdev_state_change - device changes state * @dev: device to cause notification * * Called to indicate a device has changed state. This function calls * the notifier chains for netdev_chain and sends a NEWLINK message * to the routing socket. / void netdev_state_change(struct net_device dev) { if (dev->flags & IFF_UP) { call_netdevice_notifiers(NETDEV_CHANGE, dev); rtmsg_ifinfo(RTM_NEWLINK, dev, 0); } } EXPORT_SYMBOL(netdev_state_change); int netdev_bonding_change(struct net_device dev, unsigned long event) { return call_netdevice_notifiers(event, dev); } EXPORT_SYMBOL(netdev_bonding_change); /* * dev_load - load a network module * @net: the applicable net namespace * @name: name of interface * * If a network interface is not present and the process has suitable * privileges this function loads the module. If module loading is not * available in this kernel then it becomes a nop. / void dev_load(struct net net, const char name) { struct net_device dev; int no_module; rcu_read_lock(); dev = dev_get_by_name_rcu(net, name); rcu_read_unlock(); no_module = !dev; if (no_module && capable(CAP_NET_ADMIN)) no_module = request_module("netdev-%s", name); if (no_module && capable(CAP_SYS_MODULE)) { if (!request_module("%s", name)) pr_err("Loading kernel module for a network device " "with CAP_SYS_MODULE (deprecated). Use CAP_NET_ADMIN and alias netdev-%s " "instead\n", name); } } EXPORT_SYMBOL(dev_load); static int __dev_open(struct net_device dev) { const struct net_device_ops ops = dev->netdev_ops; int ret; ASSERT_RTNL(); /* * Is it even present? / if (!netif_device_present(dev)) return -ENODEV; ret = call_netdevice_notifiers(NETDEV_PRE_UP, dev); ret = notifier_to_errno(ret); if (ret) return ret; / * Call device private open method / set_bit(__LINK_STATE_START, &dev->state); if (ops->ndo_validate_addr) ret = ops->ndo_validate_addr(dev); if (!ret && ops->ndo_open) ret = ops->ndo_open(dev); / * If it went open OK then: / if (ret) clear_bit(__LINK_STATE_START, &dev->state); else { / * Set the flags. / dev->flags \|= IFF_UP; / * Enable NET_DMA / net_dmaengine_get(); / * Initialize multicasting status / dev_set_rx_mode(dev); / * Wakeup transmit queue engine / dev_activate(dev); } return ret; } /* * dev_open - prepare an interface for use. * @dev: device to open * * Takes a device from down to up state. The device's private open * function is invoked and then the multicast lists are loaded. Finally * the device is moved into the up state and a %NETDEV_UP message is * sent to the netdev notifier chain. * * Calling this function on an active interface is a nop. On a failure * a negative errno code is returned. / int dev_open(struct net_device dev) { int ret; /* * Is it already up? / if (dev->flags & IFF_UP) return 0; / * Open device / ret = __dev_open(dev); if (ret < 0) return ret; / * ... and announce new interface. / rtmsg_ifinfo(RTM_NEWLINK, dev, IFF_UP\|IFF_RUNNING); call_netdevice_notifiers(NETDEV_UP, dev); return ret; } EXPORT_SYMBOL(dev_open); static int __dev_close_many(struct list_head head) { struct net_device dev; ASSERT_RTNL(); might_sleep(); list_for_each_entry(dev, head, unreg_list) { / * Tell people we are going down, so that they can * prepare to death, when device is still operating. / call_netdevice_notifiers(NETDEV_GOING_DOWN, dev); clear_bit(__LINK_STATE_START, &dev->state); / Synchronize to scheduled poll. We cannot touch poll list, it * can be even on different cpu. So just clear netif_running(). * * dev->stop() will invoke napi_disable() on all of it's * napi_struct instances on this device. / smp_mb__after_clear_bit(); / Commit netif_running(). / } dev_deactivate_many(head); list_for_each_entry(dev, head, unreg_list) { const struct net_device_ops ops = dev->netdev_ops; /* * Call the device specific close. This cannot fail. * Only if device is UP * * We allow it to be called even after a DETACH hot-plug * event. / if (ops->ndo_stop) ops->ndo_stop(dev); / * Device is now down. / dev->flags &= ~IFF_UP; / * Shutdown NET_DMA / net_dmaengine_put(); } return 0; } static int __dev_close(struct net_device dev) { int retval; LIST_HEAD(single); list_add(&dev->unreg_list, &single); retval = __dev_close_many(&single); list_del(&single); return retval; } int dev_close_many(struct list_head head) { struct net_device dev, tmp; LIST_HEAD(tmp_list); list_for_each_entry_safe(dev, tmp, head, unreg_list) if (!(dev->flags & IFF_UP)) list_move(&dev->unreg_list, &tmp_list); __dev_close_many(head); / * Tell people we are down / list_for_each_entry(dev, head, unreg_list) { rtmsg_ifinfo(RTM_NEWLINK, dev, IFF_UP\|IFF_RUNNING); call_netdevice_notifiers(NETDEV_DOWN, dev); } / rollback_registered_many needs the complete original list / list_splice(&tmp_list, head); return 0; } /* * dev_close - shutdown an interface. * @dev: device to shutdown * * This function moves an active device into down state. A * %NETDEV_GOING_DOWN is sent to the netdev notifier chain. The device * is then deactivated and finally a %NETDEV_DOWN is sent to the notifier * chain. / int dev_close(struct net_device dev) { LIST_HEAD(single); list_add(&dev->unreg_list, &single); dev_close_many(&single); list_del(&single); return 0; } EXPORT_SYMBOL(dev_close); /** * dev_disable_lro - disable Large Receive Offload on a device * @dev: device * * Disable Large Receive Offload (LRO) on a net device. Must be * called under RTNL. This is needed if received packets may be * forwarded to another interface. / void dev_disable_lro(struct net_device dev) { if (dev->ethtool_ops && dev->ethtool_ops->get_flags && dev->ethtool_ops->set_flags) { u32 flags = dev->ethtool_ops->get_flags(dev); if (flags & ETH_FLAG_LRO) { flags &= ~ETH_FLAG_LRO; dev->ethtool_ops->set_flags(dev, flags); } } WARN_ON(dev->features & NETIF_F_LRO); } EXPORT_SYMBOL(dev_disable_lro); static int dev_boot_phase = 1; /* * Device change register/unregister. These are not inline or static * as we export them to the world. / /* * register_netdevice_notifier - register a network notifier block * @nb: notifier * * Register a notifier to be called when network device events occur. * The notifier passed is linked into the kernel structures and must * not be reused until it has been unregistered. A negative errno code * is returned on a failure. * * When registered all registration and up events are replayed * to the new notifier to allow device to have a race free * view of the network device list. / int register_netdevice_notifier(struct notifier_block nb) { struct net_device dev; struct net_device last; struct net net; int err; rtnl_lock(); err = raw_notifier_chain_register(&netdev_chain, nb); if (err) goto unlock; if (dev_boot_phase) goto unlock; for_each_net(net) { for_each_netdev(net, dev) { err = nb->notifier_call(nb, NETDEV_REGISTER, dev); err = notifier_to_errno(err); if (err) goto rollback; if (!(dev->flags & IFF_UP)) continue; nb->notifier_call(nb, NETDEV_UP, dev); } } unlock: rtnl_unlock(); return err; rollback: last = dev; for_each_net(net) { for_each_netdev(net, dev) { if (dev == last) break; if (dev->flags & IFF_UP) { nb->notifier_call(nb, NETDEV_GOING_DOWN, dev); nb->notifier_call(nb, NETDEV_DOWN, dev); } nb->notifier_call(nb, NETDEV_UNREGISTER, dev); nb->notifier_call(nb, NETDEV_UNREGISTER_BATCH, dev); } } raw_notifier_chain_unregister(&netdev_chain, nb); goto unlock; } EXPORT_SYMBOL(register_netdevice_notifier); /* * unregister_netdevice_notifier - unregister a network notifier block * @nb: notifier * * Unregister a notifier previously registered by * register_netdevice_notifier(). The notifier is unlinked into the * kernel structures and may then be reused. A negative errno code * is returned on a failure. / int unregister_netdevice_notifier(struct notifier_block nb) { int err; rtnl_lock(); err = raw_notifier_chain_unregister(&netdev_chain, nb); rtnl_unlock(); return err; } EXPORT_SYMBOL(unregister_netdevice_notifier); /** * call_netdevice_notifiers - call all network notifier blocks * @val: value passed unmodified to notifier function * @dev: net_device pointer passed unmodified to notifier function * * Call all network notifier blocks. Parameters and return value * are as for raw_notifier_call_chain(). / int call_netdevice_notifiers(unsigned long val, struct net_device dev) { ASSERT_RTNL(); return raw_notifier_call_chain(&netdev_chain, val, dev); } /* When > 0 there are consumers of rx skb time stamps / static atomic_t netstamp_needed = ATOMIC_INIT(0); void net_enable_timestamp(void) { atomic_inc(&netstamp_needed); } EXPORT_SYMBOL(net_enable_timestamp); void net_disable_timestamp(void) { atomic_dec(&netstamp_needed); } EXPORT_SYMBOL(net_disable_timestamp); static inline void net_timestamp_set(struct sk_buff skb) { if (atomic_read(&netstamp_needed)) __net_timestamp(skb); else skb->tstamp.tv64 = 0; } static inline void net_timestamp_check(struct sk_buff skb) { if (!skb->tstamp.tv64 && atomic_read(&netstamp_needed)) __net_timestamp(skb); } /* * dev_forward_skb - loopback an skb to another netif * * @dev: destination network device * @skb: buffer to forward * * return values: * NET_RX_SUCCESS (no congestion) * NET_RX_DROP (packet was dropped, but freed) * * dev_forward_skb can be used for injecting an skb from the * start_xmit function of one device into the receive queue * of another device. * * The receiving device may be in another namespace, so * we have to clear all information in the skb that could * impact namespace isolation. / int dev_forward_skb(struct net_device dev, struct sk_buff skb) { skb_orphan(skb); nf_reset(skb); if (unlikely(!(dev->flags & IFF_UP) \|\| (skb->len > (dev->mtu + dev->hard_header_len + VLAN_HLEN)))) { atomic_long_inc(&dev->rx_dropped); kfree_skb(skb); return NET_RX_DROP; } skb_set_dev(skb, dev); skb->tstamp.tv64 = 0; skb->pkt_type = PACKET_HOST; skb->protocol = eth_type_trans(skb, dev); return netif_rx(skb); } EXPORT_SYMBOL_GPL(dev_forward_skb); static inline int deliver_skb(struct sk_buff skb, struct packet_type pt_prev, struct net_device orig_dev) { atomic_inc(&skb->users); return pt_prev->func(skb, skb->dev, pt_prev, orig_dev); } /* * Support routine. Sends outgoing frames to any network * taps currently in use. / static void dev_queue_xmit_nit(struct sk_buff skb, struct net_device dev) { struct packet_type ptype; struct sk_buff skb2 = NULL; struct packet_type pt_prev = NULL; rcu_read_lock(); list_for_each_entry_rcu(ptype, &ptype_all, list) { /* Never send packets back to the socket * they originated from - MvS (miquels@drinkel.ow.org) / if ((ptype->dev == dev \|\| !ptype->dev) && (ptype->af_packet_priv == NULL \|\| (struct sock )ptype->af_packet_priv != skb->sk)) { if (pt_prev) { deliver_skb(skb2, pt_prev, skb->dev); pt_prev = ptype; continue; } skb2 = skb_clone(skb, GFP_ATOMIC); if (!skb2) break; net_timestamp_set(skb2); /* skb->nh should be correctly set by sender, so that the second statement is just protection against buggy protocols. / skb_reset_mac_header(skb2); if (skb_network_header(skb2) < skb2->data \|\| skb2->network_header > skb2->tail) { if (net_ratelimit()) printk(KERN_CRIT "protocol %04x is " "buggy, dev %s\n", ntohs(skb2->protocol), dev->name); skb_reset_network_header(skb2); } skb2->transport_header = skb2->network_header; skb2->pkt_type = PACKET_OUTGOING; pt_prev = ptype; } } if (pt_prev) pt_prev->func(skb2, skb->dev, pt_prev, skb->dev); rcu_read_unlock(); } / * Routine to help set real_num_tx_queues. To avoid skbs mapped to queues * greater then real_num_tx_queues stale skbs on the qdisc must be flushed. / int netif_set_real_num_tx_queues(struct net_device dev, unsigned int txq) { int rc; if (txq < 1 \|\| txq > dev->num_tx_queues) return -EINVAL; if (dev->reg_state == NETREG_REGISTERED) { ASSERT_RTNL(); rc = netdev_queue_update_kobjects(dev, dev->real_num_tx_queues, txq); if (rc) return rc; if (txq < dev->real_num_tx_queues) qdisc_reset_all_tx_gt(dev, txq); } dev->real_num_tx_queues = txq; return 0; } EXPORT_SYMBOL(netif_set_real_num_tx_queues); #ifdef CONFIG_RPS /** * netif_set_real_num_rx_queues - set actual number of RX queues used * @dev: Network device * @rxq: Actual number of RX queues * * This must be called either with the rtnl_lock held or before * registration of the net device. Returns 0 on success, or a * negative error code. If called before registration, it always * succeeds. / int netif_set_real_num_rx_queues(struct net_device dev, unsigned int rxq) { int rc; if (rxq < 1 \|\| rxq > dev->num_rx_queues) return -EINVAL; if (dev->reg_state == NETREG_REGISTERED) { ASSERT_RTNL(); rc = net_rx_queue_update_kobjects(dev, dev->real_num_rx_queues, rxq); if (rc) return rc; } dev->real_num_rx_queues = rxq; return 0; } EXPORT_SYMBOL(netif_set_real_num_rx_queues); #endif static inline void __netif_reschedule(struct Qdisc q) { struct softnet_data sd; unsigned long flags; local_irq_save(flags); sd = &__get_cpu_var(softnet_data); q->next_sched = NULL; sd->output_queue_tailp = q; sd->output_queue_tailp = &q->next_sched; raise_softirq_irqoff(NET_TX_SOFTIRQ); local_irq_restore(flags); } void __netif_schedule(struct Qdisc q) { if (!test_and_set_bit(__QDISC_STATE_SCHED, &q->state)) __netif_reschedule(q); } EXPORT_SYMBOL(__netif_schedule); void dev_kfree_skb_irq(struct sk_buff skb) { if (atomic_dec_and_test(&skb->users)) { struct softnet_data sd; unsigned long flags; local_irq_save(flags); sd = &__get_cpu_var(softnet_data); skb->next = sd->completion_queue; sd->completion_queue = skb; raise_softirq_irqoff(NET_TX_SOFTIRQ); local_irq_restore(flags); } } EXPORT_SYMBOL(dev_kfree_skb_irq); void dev_kfree_skb_any(struct sk_buff skb) { if (in_irq() \|\| irqs_disabled()) dev_kfree_skb_irq(skb); else dev_kfree_skb(skb); } EXPORT_SYMBOL(dev_kfree_skb_any); /* * netif_device_detach - mark device as removed * @dev: network device * * Mark device as removed from system and therefore no longer available. / void netif_device_detach(struct net_device dev) { if (test_and_clear_bit(__LINK_STATE_PRESENT, &dev->state) && netif_running(dev)) { netif_tx_stop_all_queues(dev); } } EXPORT_SYMBOL(netif_device_detach); /** * netif_device_attach - mark device as attached * @dev: network device * * Mark device as attached from system and restart if needed. / void netif_device_attach(struct net_device dev) { if (!test_and_set_bit(__LINK_STATE_PRESENT, &dev->state) && netif_running(dev)) { netif_tx_wake_all_queues(dev); __netdev_watchdog_up(dev); } } EXPORT_SYMBOL(netif_device_attach); /** * skb_dev_set -- assign a new device to a buffer * @skb: buffer for the new device * @dev: network device * * If an skb is owned by a device already, we have to reset * all data private to the namespace a device belongs to * before assigning it a new device. / #ifdef CONFIG_NET_NS void skb_set_dev(struct sk_buff skb, struct net_device dev) { skb_dst_drop(skb); if (skb->dev && !net_eq(dev_net(skb->dev), dev_net(dev))) { secpath_reset(skb); nf_reset(skb); skb_init_secmark(skb); skb->mark = 0; skb->priority = 0; skb->nf_trace = 0; skb->ipvs_property = 0; #ifdef CONFIG_NET_SCHED skb->tc_index = 0; #endif } skb->dev = dev; } EXPORT_SYMBOL(skb_set_dev); #endif / CONFIG_NET_NS / / * Invalidate hardware checksum when packet is to be mangled, and * complete checksum manually on outgoing path. / int skb_checksum_help(struct sk_buff skb) { __wsum csum; int ret = 0, offset; if (skb->ip_summed == CHECKSUM_COMPLETE) goto out_set_summed; if (unlikely(skb_shinfo(skb)->gso_size)) { /* Let GSO fix up the checksum. / goto out_set_summed; } offset = skb_checksum_start_offset(skb); BUG_ON(offset >= skb_headlen(skb)); csum = skb_checksum(skb, offset, skb->len - offset, 0); offset += skb->csum_offset; BUG_ON(offset + sizeof(__sum16) > skb_headlen(skb)); if (skb_cloned(skb) && !skb_clone_writable(skb, offset + sizeof(__sum16))) { ret = pskb_expand_head(skb, 0, 0, GFP_ATOMIC); if (ret) goto out; } (__sum16 )(skb->data + offset) = csum_fold(csum); out_set_summed: skb->ip_summed = CHECKSUM_NONE; out: return ret; } EXPORT_SYMBOL(skb_checksum_help); /* * skb_gso_segment - Perform segmentation on skb. * @skb: buffer to segment * @features: features for the output path (see dev->features) * * This function segments the given skb and returns a list of segments. * * It may return NULL if the skb requires no segmentation. This is * only possible when GSO is used for verifying header integrity. / struct sk_buff skb_gso_segment(struct sk_buff skb, int features) { struct sk_buff segs = ERR_PTR(-EPROTONOSUPPORT); struct packet_type ptype; __be16 type = skb->protocol; int vlan_depth = ETH_HLEN; int err; while (type == htons(ETH_P_8021Q)) { struct vlan_hdr vh; if (unlikely(!pskb_may_pull(skb, vlan_depth + VLAN_HLEN))) return ERR_PTR(-EINVAL); vh = (struct vlan_hdr )(skb->data + vlan_depth); type = vh->h_vlan_encapsulated_proto; vlan_depth += VLAN_HLEN; } skb_reset_mac_header(skb); skb->mac_len = skb->network_header - skb->mac_header; __skb_pull(skb, skb->mac_len); if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) { struct net_device dev = skb->dev; struct ethtool_drvinfo info = {}; if (dev && dev->ethtool_ops && dev->ethtool_ops->get_drvinfo) dev->ethtool_ops->get_drvinfo(dev, &info); WARN(1, "%s: caps=(0x%lx, 0x%lx) len=%d data_len=%d ip_summed=%d\n", info.driver, dev ? dev->features : 0L, skb->sk ? skb->sk->sk_route_caps : 0L, skb->len, skb->data_len, skb->ip_summed); if (skb_header_cloned(skb) && (err = pskb_expand_head(skb, 0, 0, GFP_ATOMIC))) return ERR_PTR(err); } rcu_read_lock(); list_for_each_entry_rcu(ptype, &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) { if (ptype->type == type && !ptype->dev && ptype->gso_segment) { if (unlikely(skb->ip_summed != CHECKSUM_PARTIAL)) { err = ptype->gso_send_check(skb); segs = ERR_PTR(err); if (err \|\| skb_gso_ok(skb, features)) break; __skb_push(skb, (skb->data - skb_network_header(skb))); } segs = ptype->gso_segment(skb, features); break; } } rcu_read_unlock(); __skb_push(skb, skb->data - skb_mac_header(skb)); return segs; } EXPORT_SYMBOL(skb_gso_segment); /* Take action when hardware reception checksum errors are detected. / #ifdef CONFIG_BUG void netdev_rx_csum_fault(struct net_device dev) { if (net_ratelimit()) { printk(KERN_ERR "%s: hw csum failure.\n", dev ? dev->name : "<unknown>"); dump_stack(); } } EXPORT_SYMBOL(netdev_rx_csum_fault); #endif /* Actually, we should eliminate this check as soon as we know, that: * 1. IOMMU is present and allows to map all the memory. * 2. No high memory really exists on this machine. / static int illegal_highdma(struct net_device dev, struct sk_buff skb) { #ifdef CONFIG_HIGHMEM int i; if (!(dev->features & NETIF_F_HIGHDMA)) { for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) if (PageHighMem(skb_shinfo(skb)->frags[i].page)) return 1; } if (PCI_DMA_BUS_IS_PHYS) { struct device pdev = dev->dev.parent; if (!pdev) return 0; for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) { dma_addr_t addr = page_to_phys(skb_shinfo(skb)->frags[i].page); if (!pdev->dma_mask \|\| addr + PAGE_SIZE - 1 > pdev->dma_mask) return 1; } } #endif return 0; } struct dev_gso_cb { void (destructor)(struct sk_buff skb); }; #define DEV_GSO_CB(skb) ((struct dev_gso_cb )(skb)->cb) static void dev_gso_skb_destructor(struct sk_buff skb) { struct dev_gso_cb cb; do { struct sk_buff nskb = skb->next; skb->next = nskb->next; nskb->next = NULL; kfree_skb(nskb); } while (skb->next); cb = DEV_GSO_CB(skb); if (cb->destructor) cb->destructor(skb); } /* * dev_gso_segment - Perform emulated hardware segmentation on skb. * @skb: buffer to segment * @features: device features as applicable to this skb * * This function segments the given skb and stores the list of segments * in skb->next. / static int dev_gso_segment(struct sk_buff skb, int features) { struct sk_buff segs; segs = skb_gso_segment(skb, features); / Verifying header integrity only. / if (!segs) return 0; if (IS_ERR(segs)) return PTR_ERR(segs); skb->next = segs; DEV_GSO_CB(skb)->destructor = skb->destructor; skb->destructor = dev_gso_skb_destructor; return 0; } / * Try to orphan skb early, right before transmission by the device. * We cannot orphan skb if tx timestamp is requested or the sk-reference * is needed on driver level for other reasons, e.g. see net/can/raw.c / static inline void skb_orphan_try(struct sk_buff skb) { struct sock sk = skb->sk; if (sk && !skb_shinfo(skb)->tx_flags) { / skb_tx_hash() wont be able to get sk. * We copy sk_hash into skb->rxhash / if (!skb->rxhash) skb->rxhash = sk->sk_hash; skb_orphan(skb); } } static bool can_checksum_protocol(unsigned long features, __be16 protocol) { return ((features & NETIF_F_GEN_CSUM) \|\| ((features & NETIF_F_V4_CSUM) && protocol == htons(ETH_P_IP)) \|\| ((features & NETIF_F_V6_CSUM) && protocol == htons(ETH_P_IPV6)) \|\| ((features & NETIF_F_FCOE_CRC) && protocol == htons(ETH_P_FCOE))); } static int harmonize_features(struct sk_buff skb, __be16 protocol, int features) { if (!can_checksum_protocol(features, protocol)) { features &= ~NETIF_F_ALL_CSUM; features &= ~NETIF_F_SG; } else if (illegal_highdma(skb->dev, skb)) { features &= ~NETIF_F_SG; } return features; } int netif_skb_features(struct sk_buff skb) { __be16 protocol = skb->protocol; int features = skb->dev->features; if (protocol == htons(ETH_P_8021Q)) { struct vlan_ethhdr veh = (struct vlan_ethhdr )skb->data; protocol = veh->h_vlan_encapsulated_proto; } else if (!vlan_tx_tag_present(skb)) { return harmonize_features(skb, protocol, features); } features &= (skb->dev->vlan_features \| NETIF_F_HW_VLAN_TX); if (protocol != htons(ETH_P_8021Q)) { return harmonize_features(skb, protocol, features); } else { features &= NETIF_F_SG \| NETIF_F_HIGHDMA \| NETIF_F_FRAGLIST \| NETIF_F_GEN_CSUM \| NETIF_F_HW_VLAN_TX; return harmonize_features(skb, protocol, features); } } EXPORT_SYMBOL(netif_skb_features); / * Returns true if either: * 1. skb has frag_list and the device doesn't support FRAGLIST, or * 2. skb is fragmented and the device does not support SG, or if * at least one of fragments is in highmem and device does not * support DMA from it. / static inline int skb_needs_linearize(struct sk_buff skb, int features) { return skb_is_nonlinear(skb) && ((skb_has_frag_list(skb) && !(features & NETIF_F_FRAGLIST)) \|\| (skb_shinfo(skb)->nr_frags && !(features & NETIF_F_SG))); } int dev_hard_start_xmit(struct sk_buff skb, struct net_device dev, struct netdev_queue txq) { const struct net_device_ops ops = dev->netdev_ops; int rc = NETDEV_TX_OK; if (likely(!skb->next)) { int features; /* * If device doesnt need skb->dst, release it right now while * its hot in this cpu cache / if (dev->priv_flags & IFF_XMIT_DST_RELEASE) skb_dst_drop(skb); if (!list_empty(&ptype_all)) dev_queue_xmit_nit(skb, dev); skb_orphan_try(skb); features = netif_skb_features(skb); if (vlan_tx_tag_present(skb) && !(features & NETIF_F_HW_VLAN_TX)) { skb = __vlan_put_tag(skb, vlan_tx_tag_get(skb)); if (unlikely(!skb)) goto out; skb->vlan_tci = 0; } if (netif_needs_gso(skb, features)) { if (unlikely(dev_gso_segment(skb, features))) goto out_kfree_skb; if (skb->next) goto gso; } else { if (skb_needs_linearize(skb, features) && __skb_linearize(skb)) goto out_kfree_skb; / If packet is not checksummed and device does not * support checksumming for this protocol, complete * checksumming here. / if (skb->ip_summed == CHECKSUM_PARTIAL) { skb_set_transport_header(skb, skb_checksum_start_offset(skb)); if (!(features & NETIF_F_ALL_CSUM) && skb_checksum_help(skb)) goto out_kfree_skb; } } rc = ops->ndo_start_xmit(skb, dev); trace_net_dev_xmit(skb, rc); if (rc == NETDEV_TX_OK) txq_trans_update(txq); return rc; } gso: do { struct sk_buff nskb = skb->next; skb->next = nskb->next; nskb->next = NULL; /* * If device doesnt need nskb->dst, release it right now while * its hot in this cpu cache / if (dev->priv_flags & IFF_XMIT_DST_RELEASE) skb_dst_drop(nskb); rc = ops->ndo_start_xmit(nskb, dev); trace_net_dev_xmit(nskb, rc); if (unlikely(rc != NETDEV_TX_OK)) { if (rc & ~NETDEV_TX_MASK) goto out_kfree_gso_skb; nskb->next = skb->next; skb->next = nskb; return rc; } txq_trans_update(txq); if (unlikely(netif_tx_queue_stopped(txq) && skb->next)) return NETDEV_TX_BUSY; } while (skb->next); out_kfree_gso_skb: if (likely(skb->next == NULL)) skb->destructor = DEV_GSO_CB(skb)->destructor; out_kfree_skb: kfree_skb(skb); out: return rc; } static u32 hashrnd __read_mostly; / * Returns a Tx hash based on the given packet descriptor a Tx queues' number * to be used as a distribution range. / u16 __skb_tx_hash(const struct net_device dev, const struct sk_buff skb, unsigned int num_tx_queues) { u32 hash; if (skb_rx_queue_recorded(skb)) { hash = skb_get_rx_queue(skb); while (unlikely(hash >= num_tx_queues)) hash -= num_tx_queues; return hash; } if (skb->sk && skb->sk->sk_hash) hash = skb->sk->sk_hash; else hash = (__force u16) skb->protocol ^ skb->rxhash; hash = jhash_1word(hash, hashrnd); return (u16) (((u64) hash num_tx_queues) >> 32); } EXPORT_SYMBOL(__skb_tx_hash); static inline u16 dev_cap_txqueue(struct net_device dev, u16 queue_index) { if (unlikely(queue_index >= dev->real_num_tx_queues)) { if (net_ratelimit()) { pr_warning("%s selects TX queue %d, but " "real number of TX queues is %d\n", dev->name, queue_index, dev->real_num_tx_queues); } return 0; } return queue_index; } static inline int get_xps_queue(struct net_device dev, struct sk_buff skb) { #ifdef CONFIG_XPS struct xps_dev_maps dev_maps; struct xps_map map; int queue_index = -1; rcu_read_lock(); dev_maps = rcu_dereference(dev->xps_maps); if (dev_maps) { map = rcu_dereference( dev_maps->cpu_map[raw_smp_processor_id()]); if (map) { if (map->len == 1) queue_index = map->queues[0]; else { u32 hash; if (skb->sk && skb->sk->sk_hash) hash = skb->sk->sk_hash; else hash = (__force u16) skb->protocol ^ skb->rxhash; hash = jhash_1word(hash, hashrnd); queue_index = map->queues[ ((u64)hash map->len) >> 32]; } if (unlikely(queue_index >= dev->real_num_tx_queues)) queue_index = -1; } } rcu_read_unlock(); return queue_index; #else return -1; #endif } static struct netdev_queue dev_pick_tx(struct net_device dev, struct sk_buff skb) { int queue_index; const struct net_device_ops ops = dev->netdev_ops; if (dev->real_num_tx_queues == 1) queue_index = 0; else if (ops->ndo_select_queue) { queue_index = ops->ndo_select_queue(dev, skb); queue_index = dev_cap_txqueue(dev, queue_index); } else { struct sock sk = skb->sk; queue_index = sk_tx_queue_get(sk); if (queue_index < 0 \|\| skb->ooo_okay \|\| queue_index >= dev->real_num_tx_queues) { int old_index = queue_index; queue_index = get_xps_queue(dev, skb); if (queue_index < 0) queue_index = skb_tx_hash(dev, skb); if (queue_index != old_index && sk) { struct dst_entry dst = rcu_dereference_check(sk->sk_dst_cache, 1); if (dst && skb_dst(skb) == dst) sk_tx_queue_set(sk, queue_index); } } } skb_set_queue_mapping(skb, queue_index); return netdev_get_tx_queue(dev, queue_index); } static inline int __dev_xmit_skb(struct sk_buff skb, struct Qdisc q, struct net_device dev, struct netdev_queue txq) { spinlock_t root_lock = qdisc_lock(q); bool contended = qdisc_is_running(q); int rc; / * Heuristic to force contended enqueues to serialize on a * separate lock before trying to get qdisc main lock. * This permits __QDISC_STATE_RUNNING owner to get the lock more often * and dequeue packets faster. / if (unlikely(contended)) spin_lock(&q->busylock); spin_lock(root_lock); if (unlikely(test_bit(__QDISC_STATE_DEACTIVATED, &q->state))) { kfree_skb(skb); rc = NET_XMIT_DROP; } else if ((q->flags & TCQ_F_CAN_BYPASS) && !qdisc_qlen(q) && qdisc_run_begin(q)) { / * This is a work-conserving queue; there are no old skbs * waiting to be sent out; and the qdisc is not running - * xmit the skb directly. / if (!(dev->priv_flags & IFF_XMIT_DST_RELEASE)) skb_dst_force(skb); qdisc_skb_cb(skb)->pkt_len = skb->len; qdisc_bstats_update(q, skb); if (sch_direct_xmit(skb, q, dev, txq, root_lock)) { if (unlikely(contended)) { spin_unlock(&q->busylock); contended = false; } __qdisc_run(q); } else qdisc_run_end(q); rc = NET_XMIT_SUCCESS; } else { skb_dst_force(skb); rc = qdisc_enqueue_root(skb, q); if (qdisc_run_begin(q)) { if (unlikely(contended)) { spin_unlock(&q->busylock); contended = false; } __qdisc_run(q); } } spin_unlock(root_lock); if (unlikely(contended)) spin_unlock(&q->busylock); return rc; } static DEFINE_PER_CPU(int, xmit_recursion); #define RECURSION_LIMIT 10 /* * dev_queue_xmit - transmit a buffer * @skb: buffer to transmit * * Queue a buffer for transmission to a network device. The caller must * have set the device and priority and built the buffer before calling * this function. The function can be called from an interrupt. * * A negative errno code is returned on a failure. A success does not * guarantee the frame will be transmitted as it may be dropped due * to congestion or traffic shaping. * * ----------------------------------------------------------------------------------- * I notice this method can also return errors from the queue disciplines, * including NET_XMIT_DROP, which is a positive value. So, errors can also * be positive. * * Regardless of the return value, the skb is consumed, so it is currently * difficult to retry a send to this method. (You can bump the ref count * before sending to hold a reference for retry if you are careful.) * * When calling this method, interrupts MUST be enabled. This is because * the BH enable code must have IRQs enabled so that it will not deadlock. * --BLG / int dev_queue_xmit(struct sk_buff skb) { struct net_device dev = skb->dev; struct netdev_queue txq; struct Qdisc q; int rc = -ENOMEM; / Disable soft irqs for various locks below. Also * stops preemption for RCU. / rcu_read_lock_bh(); txq = dev_pick_tx(dev, skb); q = rcu_dereference_bh(txq->qdisc); #ifdef CONFIG_NET_CLS_ACT skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_EGRESS); #endif trace_net_dev_queue(skb); if (q->enqueue) { rc = __dev_xmit_skb(skb, q, dev, txq); goto out; } / The device has no queue. Common case for software devices: loopback, all the sorts of tunnels... Really, it is unlikely that netif_tx_lock protection is necessary here. (f.e. loopback and IP tunnels are clean ignoring statistics counters.) However, it is possible, that they rely on protection made by us here. Check this and shot the lock. It is not prone from deadlocks. Either shot noqueue qdisc, it is even simpler 8) / if (dev->flags & IFF_UP) { int cpu = smp_processor_id(); / ok because BHs are off / if (txq->xmit_lock_owner != cpu) { if (__this_cpu_read(xmit_recursion) > RECURSION_LIMIT) goto recursion_alert; HARD_TX_LOCK(dev, txq, cpu); if (!netif_tx_queue_stopped(txq)) { __this_cpu_inc(xmit_recursion); rc = dev_hard_start_xmit(skb, dev, txq); __this_cpu_dec(xmit_recursion); if (dev_xmit_complete(rc)) { HARD_TX_UNLOCK(dev, txq); goto out; } } HARD_TX_UNLOCK(dev, txq); if (net_ratelimit()) printk(KERN_CRIT "Virtual device %s asks to " "queue packet!\n", dev->name); } else { / Recursion is detected! It is possible, * unfortunately / recursion_alert: if (net_ratelimit()) printk(KERN_CRIT "Dead loop on virtual device " "%s, fix it urgently!\n", dev->name); } } rc = -ENETDOWN; rcu_read_unlock_bh(); kfree_skb(skb); return rc; out: rcu_read_unlock_bh(); return rc; } EXPORT_SYMBOL(dev_queue_xmit); /======================================================================= Receiver routines =======================================================================/ int netdev_max_backlog __read_mostly = 1000; int netdev_tstamp_prequeue __read_mostly = 1; int netdev_budget __read_mostly = 300; int weight_p __read_mostly = 64; / old backlog weight / / Called with irq disabled / static inline void ____napi_schedule(struct softnet_data sd, struct napi_struct napi) { list_add_tail(&napi->poll_list, &sd->poll_list); __raise_softirq_irqoff(NET_RX_SOFTIRQ); } / * __skb_get_rxhash: calculate a flow hash based on src/dst addresses * and src/dst port numbers. Returns a non-zero hash number on success * and 0 on failure. / __u32 __skb_get_rxhash(struct sk_buff skb) { int nhoff, hash = 0, poff; struct ipv6hdr ip6; struct iphdr ip; u8 ip_proto; u32 addr1, addr2, ihl; union { u32 v32; u16 v16[2]; } ports; nhoff = skb_network_offset(skb); switch (skb->protocol) { case __constant_htons(ETH_P_IP): if (!pskb_may_pull(skb, sizeof(ip) + nhoff)) goto done; ip = (struct iphdr ) (skb->data + nhoff); if (ip->frag_off & htons(IP_MF \| IP_OFFSET)) ip_proto = 0; else ip_proto = ip->protocol; addr1 = (__force u32) ip->saddr; addr2 = (__force u32) ip->daddr; ihl = ip->ihl; break; case __constant_htons(ETH_P_IPV6): if (!pskb_may_pull(skb, sizeof(ip6) + nhoff)) goto done; ip6 = (struct ipv6hdr ) (skb->data + nhoff); ip_proto = ip6->nexthdr; addr1 = (__force u32) ip6->saddr.s6_addr32[3]; addr2 = (__force u32) ip6->daddr.s6_addr32[3]; ihl = (40 >> 2); break; default: goto done; } ports.v32 = 0; poff = proto_ports_offset(ip_proto); if (poff >= 0) { nhoff += ihl * 4 + poff; if (pskb_may_pull(skb, nhoff + 4)) { ports.v32 = * (__force u32 ) (skb->data + nhoff); if (ports.v16[1] < ports.v16[0]) swap(ports.v16[0], ports.v16[1]); } } / get a consistent hash (same value on both flow directions) / if (addr2 < addr1) swap(addr1, addr2); hash = jhash_3words(addr1, addr2, ports.v32, hashrnd); if (!hash) hash = 1; done: return hash; } EXPORT_SYMBOL(__skb_get_rxhash); #ifdef CONFIG_RPS / One global table that all flow-based protocols share. / struct rps_sock_flow_table __rcu rps_sock_flow_table __read_mostly; EXPORT_SYMBOL(rps_sock_flow_table); /* * get_rps_cpu is called from netif_receive_skb and returns the target * CPU from the RPS map of the receiving queue for a given skb. * rcu_read_lock must be held on entry. / static int get_rps_cpu(struct net_device dev, struct sk_buff skb, struct rps_dev_flow rflowp) { struct netdev_rx_queue rxqueue; struct rps_map map; struct rps_dev_flow_table flow_table; struct rps_sock_flow_table sock_flow_table; int cpu = -1; u16 tcpu; if (skb_rx_queue_recorded(skb)) { u16 index = skb_get_rx_queue(skb); if (unlikely(index >= dev->real_num_rx_queues)) { WARN_ONCE(dev->real_num_rx_queues > 1, "%s received packet on queue %u, but number " "of RX queues is %u\n", dev->name, index, dev->real_num_rx_queues); goto done; } rxqueue = dev->_rx + index; } else rxqueue = dev->_rx; map = rcu_dereference(rxqueue->rps_map); if (map) { if (map->len == 1 && !rcu_dereference_raw(rxqueue->rps_flow_table)) { tcpu = map->cpus[0]; if (cpu_online(tcpu)) cpu = tcpu; goto done; } } else if (!rcu_dereference_raw(rxqueue->rps_flow_table)) { goto done; } skb_reset_network_header(skb); if (!skb_get_rxhash(skb)) goto done; flow_table = rcu_dereference(rxqueue->rps_flow_table); sock_flow_table = rcu_dereference(rps_sock_flow_table); if (flow_table && sock_flow_table) { u16 next_cpu; struct rps_dev_flow rflow; rflow = &flow_table->flows[skb->rxhash & flow_table->mask]; tcpu = rflow->cpu; next_cpu = sock_flow_table->ents[skb->rxhash & sock_flow_table->mask]; /* * If the desired CPU (where last recvmsg was done) is * different from current CPU (one in the rx-queue flow * table entry), switch if one of the following holds: * - Current CPU is unset (equal to RPS_NO_CPU). * - Current CPU is offline. * - The current CPU's queue tail has advanced beyond the * last packet that was enqueued using this table entry. * This guarantees that all previous packets for the flow * have been dequeued, thus preserving in order delivery. / if (unlikely(tcpu != next_cpu) && (tcpu == RPS_NO_CPU \|\| !cpu_online(tcpu) \|\| ((int)(per_cpu(softnet_data, tcpu).input_queue_head - rflow->last_qtail)) >= 0)) { tcpu = rflow->cpu = next_cpu; if (tcpu != RPS_NO_CPU) rflow->last_qtail = per_cpu(softnet_data, tcpu).input_queue_head; } if (tcpu != RPS_NO_CPU && cpu_online(tcpu)) { rflowp = rflow; cpu = tcpu; goto done; } } if (map) { tcpu = map->cpus[((u64) skb->rxhash * map->len) >> 32]; if (cpu_online(tcpu)) { cpu = tcpu; goto done; } } done: return cpu; } /* Called from hardirq (IPI) context / static void rps_trigger_softirq(void data) { struct softnet_data sd = data; ____napi_schedule(sd, &sd->backlog); sd->received_rps++; } #endif / CONFIG_RPS / / * Check if this softnet_data structure is another cpu one * If yes, queue it to our IPI list and return 1 * If no, return 0 / static int rps_ipi_queued(struct softnet_data sd) { #ifdef CONFIG_RPS struct softnet_data mysd = &__get_cpu_var(softnet_data); if (sd != mysd) { sd->rps_ipi_next = mysd->rps_ipi_list; mysd->rps_ipi_list = sd; __raise_softirq_irqoff(NET_RX_SOFTIRQ); return 1; } #endif / CONFIG_RPS / return 0; } / * enqueue_to_backlog is called to queue an skb to a per CPU backlog * queue (may be a remote CPU queue). / static int enqueue_to_backlog(struct sk_buff skb, int cpu, unsigned int qtail) { struct softnet_data sd; unsigned long flags; sd = &per_cpu(softnet_data, cpu); local_irq_save(flags); rps_lock(sd); if (skb_queue_len(&sd->input_pkt_queue) <= netdev_max_backlog) { if (skb_queue_len(&sd->input_pkt_queue)) { enqueue: __skb_queue_tail(&sd->input_pkt_queue, skb); input_queue_tail_incr_save(sd, qtail); rps_unlock(sd); local_irq_restore(flags); return NET_RX_SUCCESS; } /* Schedule NAPI for backlog device * We can use non atomic operation since we own the queue lock / if (!__test_and_set_bit(NAPI_STATE_SCHED, &sd->backlog.state)) { if (!rps_ipi_queued(sd)) ____napi_schedule(sd, &sd->backlog); } goto enqueue; } sd->dropped++; rps_unlock(sd); local_irq_restore(flags); atomic_long_inc(&skb->dev->rx_dropped); kfree_skb(skb); return NET_RX_DROP; } /* * netif_rx - post buffer to the network code * @skb: buffer to post * * This function receives a packet from a device driver and queues it for * the upper (protocol) levels to process. It always succeeds. The buffer * may be dropped during processing for congestion control or by the * protocol layers. * * return values: * NET_RX_SUCCESS (no congestion) * NET_RX_DROP (packet was dropped) * / int netif_rx(struct sk_buff skb) { int ret; /* if netpoll wants it, pretend we never saw it / if (netpoll_rx(skb)) return NET_RX_DROP; if (netdev_tstamp_prequeue) net_timestamp_check(skb); trace_netif_rx(skb); #ifdef CONFIG_RPS { struct rps_dev_flow voidflow, rflow = &voidflow; int cpu; preempt_disable(); rcu_read_lock(); cpu = get_rps_cpu(skb->dev, skb, &rflow); if (cpu < 0) cpu = smp_processor_id(); ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail); rcu_read_unlock(); preempt_enable(); } #else { unsigned int qtail; ret = enqueue_to_backlog(skb, get_cpu(), &qtail); put_cpu(); } #endif return ret; } EXPORT_SYMBOL(netif_rx); int netif_rx_ni(struct sk_buff skb) { int err; preempt_disable(); err = netif_rx(skb); if (local_softirq_pending()) do_softirq(); preempt_enable(); return err; } EXPORT_SYMBOL(netif_rx_ni); static void net_tx_action(struct softirq_action h) { struct softnet_data sd = &__get_cpu_var(softnet_data); if (sd->completion_queue) { struct sk_buff clist; local_irq_disable(); clist = sd->completion_queue; sd->completion_queue = NULL; local_irq_enable(); while (clist) { struct sk_buff skb = clist; clist = clist->next; WARN_ON(atomic_read(&skb->users)); trace_kfree_skb(skb, net_tx_action); __kfree_skb(skb); } } if (sd->output_queue) { struct Qdisc head; local_irq_disable(); head = sd->output_queue; sd->output_queue = NULL; sd->output_queue_tailp = &sd->output_queue; local_irq_enable(); while (head) { struct Qdisc q = head; spinlock_t root_lock; head = head->next_sched; root_lock = qdisc_lock(q); if (spin_trylock(root_lock)) { smp_mb__before_clear_bit(); clear_bit(__QDISC_STATE_SCHED, &q->state); qdisc_run(q); spin_unlock(root_lock); } else { if (!test_bit(__QDISC_STATE_DEACTIVATED, &q->state)) { __netif_reschedule(q); } else { smp_mb__before_clear_bit(); clear_bit(__QDISC_STATE_SCHED, &q->state); } } } } } #if (defined(CONFIG_BRIDGE) \|\| defined(CONFIG_BRIDGE_MODULE)) && \ (defined(CONFIG_ATM_LANE) \|\| defined(CONFIG_ATM_LANE_MODULE)) /* This hook is defined here for ATM LANE / int (br_fdb_test_addr_hook)(struct net_device dev, unsigned char addr) __read_mostly; EXPORT_SYMBOL_GPL(br_fdb_test_addr_hook); #endif #ifdef CONFIG_NET_CLS_ACT /* TODO: Maybe we should just force sch_ingress to be compiled in * when CONFIG_NET_CLS_ACT is? otherwise some useless instructions * a compare and 2 stores extra right now if we dont have it on * but have CONFIG_NET_CLS_ACT * NOTE: This doesnt stop any functionality; if you dont have * the ingress scheduler, you just cant add policies on ingress. * / static int ing_filter(struct sk_buff skb, struct netdev_queue rxq) { struct net_device dev = skb->dev; u32 ttl = G_TC_RTTL(skb->tc_verd); int result = TC_ACT_OK; struct Qdisc q; if (unlikely(MAX_RED_LOOP < ttl++)) { if (net_ratelimit()) pr_warning( "Redir loop detected Dropping packet (%d->%d)\n", skb->skb_iif, dev->ifindex); return TC_ACT_SHOT; } skb->tc_verd = SET_TC_RTTL(skb->tc_verd, ttl); skb->tc_verd = SET_TC_AT(skb->tc_verd, AT_INGRESS); q = rxq->qdisc; if (q != &noop_qdisc) { spin_lock(qdisc_lock(q)); if (likely(!test_bit(__QDISC_STATE_DEACTIVATED, &q->state))) result = qdisc_enqueue_root(skb, q); spin_unlock(qdisc_lock(q)); } return result; } static inline struct sk_buff handle_ing(struct sk_buff skb, struct packet_type pt_prev, int ret, struct net_device orig_dev) { struct netdev_queue rxq = rcu_dereference(skb->dev->ingress_queue); if (!rxq \|\| rxq->qdisc == &noop_qdisc) goto out; if (pt_prev) { ret = deliver_skb(skb, pt_prev, orig_dev); pt_prev = NULL; } switch (ing_filter(skb, rxq)) { case TC_ACT_SHOT: case TC_ACT_STOLEN: kfree_skb(skb); return NULL; } out: skb->tc_verd = 0; return skb; } #endif /** * netdev_rx_handler_register - register receive handler * @dev: device to register a handler for * @rx_handler: receive handler to register * @rx_handler_data: data pointer that is used by rx handler * * Register a receive hander for a device. This handler will then be * called from __netif_receive_skb. A negative errno code is returned * on a failure. * * The caller must hold the rtnl_mutex. / int netdev_rx_handler_register(struct net_device dev, rx_handler_func_t rx_handler, void rx_handler_data) { ASSERT_RTNL(); if (dev->rx_handler) return -EBUSY; rcu_assign_pointer(dev->rx_handler_data, rx_handler_data); rcu_assign_pointer(dev->rx_handler, rx_handler); return 0; } EXPORT_SYMBOL_GPL(netdev_rx_handler_register); /** * netdev_rx_handler_unregister - unregister receive handler * @dev: device to unregister a handler from * * Unregister a receive hander from a device. * * The caller must hold the rtnl_mutex. / void netdev_rx_handler_unregister(struct net_device dev) { ASSERT_RTNL(); rcu_assign_pointer(dev->rx_handler, NULL); rcu_assign_pointer(dev->rx_handler_data, NULL); } EXPORT_SYMBOL_GPL(netdev_rx_handler_unregister); static inline void skb_bond_set_mac_by_master(struct sk_buff skb, struct net_device master) { if (skb->pkt_type == PACKET_HOST) { u16 dest = (u16 ) eth_hdr(skb)->h_dest; memcpy(dest, master->dev_addr, ETH_ALEN); } } /* On bonding slaves other than the currently active slave, suppress * duplicates except for 802.3ad ETH_P_SLOW, alb non-mcast/bcast, and * ARP on active-backup slaves with arp_validate enabled. / int __skb_bond_should_drop(struct sk_buff skb, struct net_device master) { struct net_device dev = skb->dev; if (master->priv_flags & IFF_MASTER_ARPMON) dev->last_rx = jiffies; if ((master->priv_flags & IFF_MASTER_ALB) && (master->priv_flags & IFF_BRIDGE_PORT)) { /* Do address unmangle. The local destination address * will be always the one master has. Provides the right * functionality in a bridge. / skb_bond_set_mac_by_master(skb, master); } if (dev->priv_flags & IFF_SLAVE_INACTIVE) { if ((dev->priv_flags & IFF_SLAVE_NEEDARP) && skb->protocol == __cpu_to_be16(ETH_P_ARP)) return 0; if (master->priv_flags & IFF_MASTER_ALB) { if (skb->pkt_type != PACKET_BROADCAST && skb->pkt_type != PACKET_MULTICAST) return 0; } if (master->priv_flags & IFF_MASTER_8023AD && skb->protocol == __cpu_to_be16(ETH_P_SLOW)) return 0; return 1; } return 0; } EXPORT_SYMBOL(__skb_bond_should_drop); static int __netif_receive_skb(struct sk_buff skb) { struct packet_type ptype, pt_prev; rx_handler_func_t rx_handler; struct net_device orig_dev; struct net_device master; struct net_device null_or_orig; struct net_device orig_or_bond; int ret = NET_RX_DROP; __be16 type; if (!netdev_tstamp_prequeue) net_timestamp_check(skb); trace_netif_receive_skb(skb); / if we've gotten here through NAPI, check netpoll / if (netpoll_receive_skb(skb)) return NET_RX_DROP; if (!skb->skb_iif) skb->skb_iif = skb->dev->ifindex; / * bonding note: skbs received on inactive slaves should only * be delivered to pkt handlers that are exact matches. Also * the deliver_no_wcard flag will be set. If packet handlers * are sensitive to duplicate packets these skbs will need to * be dropped at the handler. / null_or_orig = NULL; orig_dev = skb->dev; master = ACCESS_ONCE(orig_dev->master); if (skb->deliver_no_wcard) null_or_orig = orig_dev; else if (master) { if (skb_bond_should_drop(skb, master)) { skb->deliver_no_wcard = 1; null_or_orig = orig_dev; / deliver only exact match / } else skb->dev = master; } __this_cpu_inc(softnet_data.processed); skb_reset_network_header(skb); skb_reset_transport_header(skb); skb->mac_len = skb->network_header - skb->mac_header; pt_prev = NULL; rcu_read_lock(); #ifdef CONFIG_NET_CLS_ACT if (skb->tc_verd & TC_NCLS) { skb->tc_verd = CLR_TC_NCLS(skb->tc_verd); goto ncls; } #endif list_for_each_entry_rcu(ptype, &ptype_all, list) { if (ptype->dev == null_or_orig \|\| ptype->dev == skb->dev \|\| ptype->dev == orig_dev) { if (pt_prev) ret = deliver_skb(skb, pt_prev, orig_dev); pt_prev = ptype; } } #ifdef CONFIG_NET_CLS_ACT skb = handle_ing(skb, &pt_prev, &ret, orig_dev); if (!skb) goto out; ncls: #endif / Handle special case of bridge or macvlan / rx_handler = rcu_dereference(skb->dev->rx_handler); if (rx_handler) { if (pt_prev) { ret = deliver_skb(skb, pt_prev, orig_dev); pt_prev = NULL; } skb = rx_handler(skb); if (!skb) goto out; } if (vlan_tx_tag_present(skb)) { if (pt_prev) { ret = deliver_skb(skb, pt_prev, orig_dev); pt_prev = NULL; } if (vlan_hwaccel_do_receive(&skb)) { ret = __netif_receive_skb(skb); goto out; } else if (unlikely(!skb)) goto out; } / * Make sure frames received on VLAN interfaces stacked on * bonding interfaces still make their way to any base bonding * device that may have registered for a specific ptype. The * handler may have to adjust skb->dev and orig_dev. / orig_or_bond = orig_dev; if ((skb->dev->priv_flags & IFF_802_1Q_VLAN) && (vlan_dev_real_dev(skb->dev)->priv_flags & IFF_BONDING)) { orig_or_bond = vlan_dev_real_dev(skb->dev); } type = skb->protocol; list_for_each_entry_rcu(ptype, &ptype_base[ntohs(type) & PTYPE_HASH_MASK], list) { if (ptype->type == type && (ptype->dev == null_or_orig \|\| ptype->dev == skb->dev \|\| ptype->dev == orig_dev \|\| ptype->dev == orig_or_bond)) { if (pt_prev) ret = deliver_skb(skb, pt_prev, orig_dev); pt_prev = ptype; } } if (pt_prev) { ret = pt_prev->func(skb, skb->dev, pt_prev, orig_dev); } else { atomic_long_inc(&skb->dev->rx_dropped); kfree_skb(skb); / Jamal, now you will not able to escape explaining * me how you were going to use this. :-) / ret = NET_RX_DROP; } out: rcu_read_unlock(); return ret; } /* * netif_receive_skb - process receive buffer from network * @skb: buffer to process * * netif_receive_skb() is the main receive data processing function. * It always succeeds. The buffer may be dropped during processing * for congestion control or by the protocol layers. * * This function may only be called from softirq context and interrupts * should be enabled. * * Return values (usually ignored): * NET_RX_SUCCESS: no congestion * NET_RX_DROP: packet was dropped / int netif_receive_skb(struct sk_buff skb) { if (netdev_tstamp_prequeue) net_timestamp_check(skb); if (skb_defer_rx_timestamp(skb)) return NET_RX_SUCCESS; #ifdef CONFIG_RPS { struct rps_dev_flow voidflow, rflow = &voidflow; int cpu, ret; rcu_read_lock(); cpu = get_rps_cpu(skb->dev, skb, &rflow); if (cpu >= 0) { ret = enqueue_to_backlog(skb, cpu, &rflow->last_qtail); rcu_read_unlock(); } else { rcu_read_unlock(); ret = __netif_receive_skb(skb); } return ret; } #else return __netif_receive_skb(skb); #endif } EXPORT_SYMBOL(netif_receive_skb); / Network device is going away, flush any packets still pending * Called with irqs disabled. / static void flush_backlog(void arg) { struct net_device dev = arg; struct softnet_data sd = &__get_cpu_var(softnet_data); struct sk_buff skb, tmp; rps_lock(sd); skb_queue_walk_safe(&sd->input_pkt_queue, skb, tmp) { if (skb->dev == dev) { __skb_unlink(skb, &sd->input_pkt_queue); kfree_skb(skb); input_queue_head_incr(sd); } } rps_unlock(sd); skb_queue_walk_safe(&sd->process_queue, skb, tmp) { if (skb->dev == dev) { __skb_unlink(skb, &sd->process_queue); kfree_skb(skb); input_queue_head_incr(sd); } } } static int napi_gro_complete(struct sk_buff skb) { struct packet_type ptype; __be16 type = skb->protocol; struct list_head head = &ptype_base[ntohs(type) & PTYPE_HASH_MASK]; int err = -ENOENT; if (NAPI_GRO_CB(skb)->count == 1) { skb_shinfo(skb)->gso_size = 0; goto out; } rcu_read_lock(); list_for_each_entry_rcu(ptype, head, list) { if (ptype->type != type \|\| ptype->dev \|\| !ptype->gro_complete) continue; err = ptype->gro_complete(skb); break; } rcu_read_unlock(); if (err) { WARN_ON(&ptype->list == head); kfree_skb(skb); return NET_RX_SUCCESS; } out: return netif_receive_skb(skb); } inline void napi_gro_flush(struct napi_struct napi) { struct sk_buff skb, next; for (skb = napi->gro_list; skb; skb = next) { next = skb->next; skb->next = NULL; napi_gro_complete(skb); } napi->gro_count = 0; napi->gro_list = NULL; } EXPORT_SYMBOL(napi_gro_flush); enum gro_result dev_gro_receive(struct napi_struct napi, struct sk_buff skb) { struct sk_buff *pp = NULL; struct packet_type ptype; __be16 type = skb->protocol; struct list_head head = &ptype_base[ntohs(type) & PTYPE_HASH_MASK]; int same_flow; int mac_len; enum gro_result ret; if (!(skb->dev->features & NETIF_F_GRO) \|\| netpoll_rx_on(skb)) goto normal; if (skb_is_gso(skb) \|\| skb_has_frag_list(skb)) goto normal; rcu_read_lock(); list_for_each_entry_rcu(ptype, head, list) { if (ptype->type != type \|\| ptype->dev \|\| !ptype->gro_receive) continue; skb_set_network_header(skb, skb_gro_offset(skb)); mac_len = skb->network_header - skb->mac_header; skb->mac_len = mac_len; NAPI_GRO_CB(skb)->same_flow = 0; NAPI_GRO_CB(skb)->flush = 0; NAPI_GRO_CB(skb)->free = 0; pp = ptype->gro_receive(&napi->gro_list, skb); break; } rcu_read_unlock(); if (&ptype->list == head) goto normal; same_flow = NAPI_GRO_CB(skb)->same_flow; ret = NAPI_GRO_CB(skb)->free ? GRO_MERGED_FREE : GRO_MERGED; if (pp) { struct sk_buff nskb = pp; pp = nskb->next; nskb->next = NULL; napi_gro_complete(nskb); napi->gro_count--; } if (same_flow) goto ok; if (NAPI_GRO_CB(skb)->flush \|\| napi->gro_count >= MAX_GRO_SKBS) goto normal; napi->gro_count++; NAPI_GRO_CB(skb)->count = 1; skb_shinfo(skb)->gso_size = skb_gro_len(skb); skb->next = napi->gro_list; napi->gro_list = skb; ret = GRO_HELD; pull: if (skb_headlen(skb) < skb_gro_offset(skb)) { int grow = skb_gro_offset(skb) - skb_headlen(skb); BUG_ON(skb->end - skb->tail < grow); memcpy(skb_tail_pointer(skb), NAPI_GRO_CB(skb)->frag0, grow); skb->tail += grow; skb->data_len -= grow; skb_shinfo(skb)->frags[0].page_offset += grow; skb_shinfo(skb)->frags[0].size -= grow; if (unlikely(!skb_shinfo(skb)->frags[0].size)) { put_page(skb_shinfo(skb)->frags[0].page); memmove(skb_shinfo(skb)->frags, skb_shinfo(skb)->frags + 1, --skb_shinfo(skb)->nr_frags * sizeof(skb_frag_t)); } } ok: return ret; normal: ret = GRO_NORMAL; goto pull; } EXPORT_SYMBOL(dev_gro_receive); static inline gro_result_t __napi_gro_receive(struct napi_struct napi, struct sk_buff skb) { struct sk_buff p; for (p = napi->gro_list; p; p = p->next) { unsigned long diffs; diffs = (unsigned long)p->dev ^ (unsigned long)skb->dev; diffs \|= p->vlan_tci ^ skb->vlan_tci; diffs \|= compare_ether_header(skb_mac_header(p), skb_gro_mac_header(skb)); NAPI_GRO_CB(p)->same_flow = !diffs; NAPI_GRO_CB(p)->flush = 0; } return dev_gro_receive(napi, skb); } gro_result_t napi_skb_finish(gro_result_t ret, struct sk_buff skb) { switch (ret) { case GRO_NORMAL: if (netif_receive_skb(skb)) ret = GRO_DROP; break; case GRO_DROP: case GRO_MERGED_FREE: kfree_skb(skb); break; case GRO_HELD: case GRO_MERGED: break; } return ret; } EXPORT_SYMBOL(napi_skb_finish); void skb_gro_reset_offset(struct sk_buff skb) { NAPI_GRO_CB(skb)->data_offset = 0; NAPI_GRO_CB(skb)->frag0 = NULL; NAPI_GRO_CB(skb)->frag0_len = 0; if (skb->mac_header == skb->tail && !PageHighMem(skb_shinfo(skb)->frags[0].page)) { NAPI_GRO_CB(skb)->frag0 = page_address(skb_shinfo(skb)->frags[0].page) + skb_shinfo(skb)->frags[0].page_offset; NAPI_GRO_CB(skb)->frag0_len = skb_shinfo(skb)->frags[0].size; } } EXPORT_SYMBOL(skb_gro_reset_offset); gro_result_t napi_gro_receive(struct napi_struct napi, struct sk_buff skb) { skb_gro_reset_offset(skb); return napi_skb_finish(__napi_gro_receive(napi, skb), skb); } EXPORT_SYMBOL(napi_gro_receive); static void napi_reuse_skb(struct napi_struct napi, struct sk_buff skb) { __skb_pull(skb, skb_headlen(skb)); skb_reserve(skb, NET_IP_ALIGN - skb_headroom(skb)); skb->vlan_tci = 0; skb->dev = napi->dev; skb->skb_iif = 0; napi->skb = skb; } struct sk_buff napi_get_frags(struct napi_struct napi) { struct sk_buff skb = napi->skb; if (!skb) { skb = netdev_alloc_skb_ip_align(napi->dev, GRO_MAX_HEAD); if (skb) napi->skb = skb; } return skb; } EXPORT_SYMBOL(napi_get_frags); gro_result_t napi_frags_finish(struct napi_struct napi, struct sk_buff skb, gro_result_t ret) { switch (ret) { case GRO_NORMAL: case GRO_HELD: skb->protocol = eth_type_trans(skb, skb->dev); if (ret == GRO_HELD) skb_gro_pull(skb, -ETH_HLEN); else if (netif_receive_skb(skb)) ret = GRO_DROP; break; case GRO_DROP: case GRO_MERGED_FREE: napi_reuse_skb(napi, skb); break; case GRO_MERGED: break; } return ret; } EXPORT_SYMBOL(napi_frags_finish); struct sk_buff napi_frags_skb(struct napi_struct napi) { struct sk_buff skb = napi->skb; struct ethhdr eth; unsigned int hlen; unsigned int off; napi->skb = NULL; skb_reset_mac_header(skb); skb_gro_reset_offset(skb); off = skb_gro_offset(skb); hlen = off + sizeof(eth); eth = skb_gro_header_fast(skb, off); if (skb_gro_header_hard(skb, hlen)) { eth = skb_gro_header_slow(skb, hlen, off); if (unlikely(!eth)) { napi_reuse_skb(napi, skb); skb = NULL; goto out; } } skb_gro_pull(skb, sizeof(eth)); /* * This works because the only protocols we care about don't require * special handling. We'll fix it up properly at the end. / skb->protocol = eth->h_proto; out: return skb; } EXPORT_SYMBOL(napi_frags_skb); gro_result_t napi_gro_frags(struct napi_struct napi) { struct sk_buff skb = napi_frags_skb(napi); if (!skb) return GRO_DROP; return napi_frags_finish(napi, skb, __napi_gro_receive(napi, skb)); } EXPORT_SYMBOL(napi_gro_frags); / * net_rps_action sends any pending IPI's for rps. * Note: called with local irq disabled, but exits with local irq enabled. / static void net_rps_action_and_irq_enable(struct softnet_data sd) { #ifdef CONFIG_RPS struct softnet_data remsd = sd->rps_ipi_list; if (remsd) { sd->rps_ipi_list = NULL; local_irq_enable(); / Send pending IPI's to kick RPS processing on remote cpus. / while (remsd) { struct softnet_data next = remsd->rps_ipi_next; if (cpu_online(remsd->cpu)) __smp_call_function_single(remsd->cpu, &remsd->csd, 0); remsd = next; } } else #endif local_irq_enable(); } static int process_backlog(struct napi_struct napi, int quota) { int work = 0; struct softnet_data sd = container_of(napi, struct softnet_data, backlog); #ifdef CONFIG_RPS /* Check if we have pending ipi, its better to send them now, * not waiting net_rx_action() end. / if (sd->rps_ipi_list) { local_irq_disable(); net_rps_action_and_irq_enable(sd); } #endif napi->weight = weight_p; local_irq_disable(); while (work < quota) { struct sk_buff skb; unsigned int qlen; while ((skb = __skb_dequeue(&sd->process_queue))) { local_irq_enable(); __netif_receive_skb(skb); local_irq_disable(); input_queue_head_incr(sd); if (++work >= quota) { local_irq_enable(); return work; } } rps_lock(sd); qlen = skb_queue_len(&sd->input_pkt_queue); if (qlen) skb_queue_splice_tail_init(&sd->input_pkt_queue, &sd->process_queue); if (qlen < quota - work) { /* * Inline a custom version of __napi_complete(). * only current cpu owns and manipulates this napi, * and NAPI_STATE_SCHED is the only possible flag set on backlog. * we can use a plain write instead of clear_bit(), * and we dont need an smp_mb() memory barrier. / list_del(&napi->poll_list); napi->state = 0; quota = work + qlen; } rps_unlock(sd); } local_irq_enable(); return work; } /* * __napi_schedule - schedule for receive * @n: entry to schedule * * The entry's receive function will be scheduled to run / void __napi_schedule(struct napi_struct n) { unsigned long flags; local_irq_save(flags); ____napi_schedule(&__get_cpu_var(softnet_data), n); local_irq_restore(flags); } EXPORT_SYMBOL(__napi_schedule); void __napi_complete(struct napi_struct n) { BUG_ON(!test_bit(NAPI_STATE_SCHED, &n->state)); BUG_ON(n->gro_list); list_del(&n->poll_list); smp_mb__before_clear_bit(); clear_bit(NAPI_STATE_SCHED, &n->state); } EXPORT_SYMBOL(__napi_complete); void napi_complete(struct napi_struct n) { unsigned long flags; /* * don't let napi dequeue from the cpu poll list * just in case its running on a different cpu / if (unlikely(test_bit(NAPI_STATE_NPSVC, &n->state))) return; napi_gro_flush(n); local_irq_save(flags); __napi_complete(n); local_irq_restore(flags); } EXPORT_SYMBOL(napi_complete); void netif_napi_add(struct net_device dev, struct napi_struct napi, int (poll)(struct napi_struct , int), int weight) { INIT_LIST_HEAD(&napi->poll_list); napi->gro_count = 0; napi->gro_list = NULL; napi->skb = NULL; napi->poll = poll; napi->weight = weight; list_add(&napi->dev_list, &dev->napi_list); napi->dev = dev; #ifdef CONFIG_NETPOLL spin_lock_init(&napi->poll_lock); napi->poll_owner = -1; #endif set_bit(NAPI_STATE_SCHED, &napi->state); } EXPORT_SYMBOL(netif_napi_add); void netif_napi_del(struct napi_struct napi) { struct sk_buff skb, next; list_del_init(&napi->dev_list); napi_free_frags(napi); for (skb = napi->gro_list; skb; skb = next) { next = skb->next; skb->next = NULL; kfree_skb(skb); } napi->gro_list = NULL; napi->gro_count = 0; } EXPORT_SYMBOL(netif_napi_del); static void net_rx_action(struct softirq_action h) { struct softnet_data sd = &__get_cpu_var(softnet_data); unsigned long time_limit = jiffies + 2; int budget = netdev_budget; void have; local_irq_disable(); while (!list_empty(&sd->poll_list)) { struct napi_struct n; int work, weight; /* If softirq window is exhuasted then punt. * Allow this to run for 2 jiffies since which will allow * an average latency of 1.5/HZ. / if (unlikely(budget <= 0 \|\| time_after(jiffies, time_limit))) goto softnet_break; local_irq_enable(); / Even though interrupts have been re-enabled, this * access is safe because interrupts can only add new * entries to the tail of this list, and only ->poll() * calls can remove this head entry from the list. / n = list_first_entry(&sd->poll_list, struct napi_struct, poll_list); have = netpoll_poll_lock(n); weight = n->weight; / This NAPI_STATE_SCHED test is for avoiding a race * with netpoll's poll_napi(). Only the entity which * obtains the lock and sees NAPI_STATE_SCHED set will * actually make the ->poll() call. Therefore we avoid * accidently calling ->poll() when NAPI is not scheduled. / work = 0; if (test_bit(NAPI_STATE_SCHED, &n->state)) { work = n->poll(n, weight); trace_napi_poll(n); } WARN_ON_ONCE(work > weight); budget -= work; local_irq_disable(); / Drivers must not modify the NAPI state if they * consume the entire weight. In such cases this code * still "owns" the NAPI instance and therefore can * move the instance around on the list at-will. / if (unlikely(work == weight)) { if (unlikely(napi_disable_pending(n))) { local_irq_enable(); napi_complete(n); local_irq_disable(); } else list_move_tail(&n->poll_list, &sd->poll_list); } netpoll_poll_unlock(have); } out: net_rps_action_and_irq_enable(sd); #ifdef CONFIG_NET_DMA / * There may not be any more sk_buffs coming right now, so push * any pending DMA copies to hardware / dma_issue_pending_all(); #endif return; softnet_break: sd->time_squeeze++; __raise_softirq_irqoff(NET_RX_SOFTIRQ); goto out; } static gifconf_func_t gifconf_list[NPROTO]; /** * register_gifconf - register a SIOCGIF handler * @family: Address family * @gifconf: Function handler * * Register protocol dependent address dumping routines. The handler * that is passed must not be freed or reused until it has been replaced * by another handler. / int register_gifconf(unsigned int family, gifconf_func_t gifconf) { if (family >= NPROTO) return -EINVAL; gifconf_list[family] = gifconf; return 0; } EXPORT_SYMBOL(register_gifconf); /* * Map an interface index to its name (SIOCGIFNAME) / / * We need this ioctl for efficient implementation of the * if_indextoname() function required by the IPv6 API. Without * it, we would have to search all the interfaces to find a * match. --pb / static int dev_ifname(struct net net, struct ifreq __user arg) { struct net_device dev; struct ifreq ifr; /* * Fetch the caller's info block. / if (copy_from_user(&ifr, arg, sizeof(struct ifreq))) return -EFAULT; rcu_read_lock(); dev = dev_get_by_index_rcu(net, ifr.ifr_ifindex); if (!dev) { rcu_read_unlock(); return -ENODEV; } strcpy(ifr.ifr_name, dev->name); rcu_read_unlock(); if (copy_to_user(arg, &ifr, sizeof(struct ifreq))) return -EFAULT; return 0; } / * Perform a SIOCGIFCONF call. This structure will change * size eventually, and there is nothing I can do about it. * Thus we will need a 'compatibility mode'. / static int dev_ifconf(struct net net, char __user arg) { struct ifconf ifc; struct net_device dev; char __user pos; int len; int total; int i; / * Fetch the caller's info block. / if (copy_from_user(&ifc, arg, sizeof(struct ifconf))) return -EFAULT; pos = ifc.ifc_buf; len = ifc.ifc_len; / * Loop over the interfaces, and write an info block for each. / total = 0; for_each_netdev(net, dev) { for (i = 0; i < NPROTO; i++) { if (gifconf_list[i]) { int done; if (!pos) done = gifconf_list[i](dev, NULL, 0); else done = gifconf_list[i](dev, pos + total, len - total); if (done < 0) return -EFAULT; total += done; } } } / * All done. Write the updated control block back to the caller. / ifc.ifc_len = total; / * Both BSD and Solaris return 0 here, so we do too. / return copy_to_user(arg, &ifc, sizeof(struct ifconf)) ? -EFAULT : 0; } #ifdef CONFIG_PROC_FS / * This is invoked by the /proc filesystem handler to display a device * in detail. / void dev_seq_start(struct seq_file seq, loff_t pos) __acquires(RCU) { struct net net = seq_file_net(seq); loff_t off; struct net_device dev; rcu_read_lock(); if (!pos) return SEQ_START_TOKEN; off = 1; for_each_netdev_rcu(net, dev) if (off++ == pos) return dev; return NULL; } void dev_seq_next(struct seq_file seq, void v, loff_t pos) { struct net_device dev = (v == SEQ_START_TOKEN) ? first_net_device(seq_file_net(seq)) : next_net_device((struct net_device )v); ++pos; return rcu_dereference(dev); } void dev_seq_stop(struct seq_file seq, void v) __releases(RCU) { rcu_read_unlock(); } static void dev_seq_printf_stats(struct seq_file seq, struct net_device dev) { struct rtnl_link_stats64 temp; const struct rtnl_link_stats64 stats = dev_get_stats(dev, &temp); seq_printf(seq, "%6s: %7llu %7llu %4llu %4llu %4llu %5llu %10llu %9llu " "%8llu %7llu %4llu %4llu %4llu %5llu %7llu %10llu\n", dev->name, stats->rx_bytes, stats->rx_packets, stats->rx_errors, stats->rx_dropped + stats->rx_missed_errors, stats->rx_fifo_errors, stats->rx_length_errors + stats->rx_over_errors + stats->rx_crc_errors + stats->rx_frame_errors, stats->rx_compressed, stats->multicast, stats->tx_bytes, stats->tx_packets, stats->tx_errors, stats->tx_dropped, stats->tx_fifo_errors, stats->collisions, stats->tx_carrier_errors + stats->tx_aborted_errors + stats->tx_window_errors + stats->tx_heartbeat_errors, stats->tx_compressed); } /* * Called from the PROCfs module. This now uses the new arbitrary sized * /proc/net interface to create /proc/net/dev / static int dev_seq_show(struct seq_file seq, void v) { if (v == SEQ_START_TOKEN) seq_puts(seq, "Inter-\| Receive " " \| Transmit\n" " face \|bytes packets errs drop fifo frame " "compressed multicast\|bytes packets errs " "drop fifo colls carrier compressed\n"); else dev_seq_printf_stats(seq, v); return 0; } static struct softnet_data softnet_get_online(loff_t pos) { struct softnet_data sd = NULL; while (pos < nr_cpu_ids) if (cpu_online(pos)) { sd = &per_cpu(softnet_data, pos); break; } else ++pos; return sd; } static void softnet_seq_start(struct seq_file seq, loff_t pos) { return softnet_get_online(pos); } static void softnet_seq_next(struct seq_file seq, void v, loff_t pos) { ++pos; return softnet_get_online(pos); } static void softnet_seq_stop(struct seq_file seq, void v) { } static int softnet_seq_show(struct seq_file seq, void v) { struct softnet_data sd = v; seq_printf(seq, "%08x %08x %08x %08x %08x %08x %08x %08x %08x %08x\n", sd->processed, sd->dropped, sd->time_squeeze, 0, 0, 0, 0, 0, / was fastroute / sd->cpu_collision, sd->received_rps); return 0; } static const struct seq_operations dev_seq_ops = { .start = dev_seq_start, .next = dev_seq_next, .stop = dev_seq_stop, .show = dev_seq_show, }; static int dev_seq_open(struct inode inode, struct file file) { return seq_open_net(inode, file, &dev_seq_ops, sizeof(struct seq_net_private)); } static const struct file_operations dev_seq_fops = { .owner = THIS_MODULE, .open = dev_seq_open, .read = seq_read, .llseek = seq_lseek, .release = seq_release_net, }; static const struct seq_operations softnet_seq_ops = { .start = softnet_seq_start, .next = softnet_seq_next, .stop = softnet_seq_stop, .show = softnet_seq_show, }; static int softnet_seq_open(struct inode inode, struct file file) { return seq_open(file, &softnet_seq_ops); } static const struct file_operations softnet_seq_fops = { .owner = THIS_MODULE, .open = softnet_seq_open, .read = seq_read, .llseek = seq_lseek, .release = seq_release, }; static void ptype_get_idx(loff_t pos) { struct packet_type pt = NULL; loff_t i = 0; int t; list_for_each_entry_rcu(pt, &ptype_all, list) { if (i == pos) return pt; ++i; } for (t = 0; t < PTYPE_HASH_SIZE; t++) { list_for_each_entry_rcu(pt, &ptype_base[t], list) { if (i == pos) return pt; ++i; } } return NULL; } static void ptype_seq_start(struct seq_file seq, loff_t pos) __acquires(RCU) { rcu_read_lock(); return pos ? ptype_get_idx(pos - 1) : SEQ_START_TOKEN; } static void ptype_seq_next(struct seq_file seq, void v, loff_t pos) { struct packet_type pt; struct list_head nxt; int hash; ++pos; if (v == SEQ_START_TOKEN) return ptype_get_idx(0); pt = v; nxt = pt->list.next; if (pt->type == htons(ETH_P_ALL)) { if (nxt != &ptype_all) goto found; hash = 0; nxt = ptype_base[0].next; } else hash = ntohs(pt->type) & PTYPE_HASH_MASK; while (nxt == &ptype_base[hash]) { if (++hash >= PTYPE_HASH_SIZE) return NULL; nxt = ptype_base[hash].next; } found: return list_entry(nxt, struct packet_type, list); } static void ptype_seq_stop(struct seq_file seq, void v) __releases(RCU) { rcu_read_unlock(); } static int ptype_seq_show(struct seq_file seq, void v) { struct packet_type pt = v; if (v == SEQ_START_TOKEN) seq_puts(seq, "Type Device Function\n"); else if (pt->dev == NULL \|\| dev_net(pt->dev) == seq_file_net(seq)) { if (pt->type == htons(ETH_P_ALL)) seq_puts(seq, "ALL "); else seq_printf(seq, "%04x", ntohs(pt->type)); seq_printf(seq, " %-8s %pF\n", pt->dev ? pt->dev->name : "", pt->func); } return 0; } static const struct seq_operations ptype_seq_ops = { .start = ptype_seq_start, .next = ptype_seq_next, .stop = ptype_seq_stop, .show = ptype_seq_show, }; static int ptype_seq_open(struct inode inode, struct file file) { return seq_open_net(inode, file, &ptype_seq_ops, sizeof(struct seq_net_private)); } static const struct file_operations ptype_seq_fops = { .owner = THIS_MODULE, .open = ptype_seq_open, .read = seq_read, .llseek = seq_lseek, .release = seq_release_net, }; static int __net_init dev_proc_net_init(struct net net) { int rc = -ENOMEM; if (!proc_net_fops_create(net, "dev", S_IRUGO, &dev_seq_fops)) goto out; if (!proc_net_fops_create(net, "softnet_stat", S_IRUGO, &softnet_seq_fops)) goto out_dev; if (!proc_net_fops_create(net, "ptype", S_IRUGO, &ptype_seq_fops)) goto out_softnet; if (wext_proc_init(net)) goto out_ptype; rc = 0; out: return rc; out_ptype: proc_net_remove(net, "ptype"); out_softnet: proc_net_remove(net, "softnet_stat"); out_dev: proc_net_remove(net, "dev"); goto out; } static void __net_exit dev_proc_net_exit(struct net net) { wext_proc_exit(net); proc_net_remove(net, "ptype"); proc_net_remove(net, "softnet_stat"); proc_net_remove(net, "dev"); } static struct pernet_operations __net_initdata dev_proc_ops = { .init = dev_proc_net_init, .exit = dev_proc_net_exit, }; static int __init dev_proc_init(void) { return register_pernet_subsys(&dev_proc_ops); } #else #define dev_proc_init() 0 #endif /* CONFIG_PROC_FS / /* * netdev_set_master - set up master/slave pair * @slave: slave device * @master: new master device * * Changes the master device of the slave. Pass %NULL to break the * bonding. The caller must hold the RTNL semaphore. On a failure * a negative errno code is returned. On success the reference counts * are adjusted, %RTM_NEWLINK is sent to the routing socket and the * function returns zero. / int netdev_set_master(struct net_device slave, struct net_device master) { struct net_device old = slave->master; ASSERT_RTNL(); if (master) { if (old) return -EBUSY; dev_hold(master); } slave->master = master; if (old) { synchronize_net(); dev_put(old); } if (master) slave->flags \|= IFF_SLAVE; else slave->flags &= ~IFF_SLAVE; rtmsg_ifinfo(RTM_NEWLINK, slave, IFF_SLAVE); return 0; } EXPORT_SYMBOL(netdev_set_master); static void dev_change_rx_flags(struct net_device dev, int flags) { const struct net_device_ops ops = dev->netdev_ops; if ((dev->flags & IFF_UP) && ops->ndo_change_rx_flags) ops->ndo_change_rx_flags(dev, flags); } static int __dev_set_promiscuity(struct net_device dev, int inc) { unsigned short old_flags = dev->flags; uid_t uid; gid_t gid; ASSERT_RTNL(); dev->flags \|= IFF_PROMISC; dev->promiscuity += inc; if (dev->promiscuity == 0) { / * Avoid overflow. * If inc causes overflow, untouch promisc and return error. / if (inc < 0) dev->flags &= ~IFF_PROMISC; else { dev->promiscuity -= inc; printk(KERN_WARNING "%s: promiscuity touches roof, " "set promiscuity failed, promiscuity feature " "of device might be broken.\n", dev->name); return -EOVERFLOW; } } if (dev->flags != old_flags) { printk(KERN_INFO "device %s %s promiscuous mode\n", dev->name, (dev->flags & IFF_PROMISC) ? "entered" : "left"); if (audit_enabled) { current_uid_gid(&uid, &gid); audit_log(current->audit_context, GFP_ATOMIC, AUDIT_ANOM_PROMISCUOUS, "dev=%s prom=%d old_prom=%d auid=%u uid=%u gid=%u ses=%u", dev->name, (dev->flags & IFF_PROMISC), (old_flags & IFF_PROMISC), audit_get_loginuid(current), uid, gid, audit_get_sessionid(current)); } dev_change_rx_flags(dev, IFF_PROMISC); } return 0; } /* * dev_set_promiscuity - update promiscuity count on a device * @dev: device * @inc: modifier * * Add or remove promiscuity from a device. While the count in the device * remains above zero the interface remains promiscuous. Once it hits zero * the device reverts back to normal filtering operation. A negative inc * value is used to drop promiscuity on the device. * Return 0 if successful or a negative errno code on error. / int dev_set_promiscuity(struct net_device dev, int inc) { unsigned short old_flags = dev->flags; int err; err = __dev_set_promiscuity(dev, inc); if (err < 0) return err; if (dev->flags != old_flags) dev_set_rx_mode(dev); return err; } EXPORT_SYMBOL(dev_set_promiscuity); /** * dev_set_allmulti - update allmulti count on a device * @dev: device * @inc: modifier * * Add or remove reception of all multicast frames to a device. While the * count in the device remains above zero the interface remains listening * to all interfaces. Once it hits zero the device reverts back to normal * filtering operation. A negative @inc value is used to drop the counter * when releasing a resource needing all multicasts. * Return 0 if successful or a negative errno code on error. / int dev_set_allmulti(struct net_device dev, int inc) { unsigned short old_flags = dev->flags; ASSERT_RTNL(); dev->flags \|= IFF_ALLMULTI; dev->allmulti += inc; if (dev->allmulti == 0) { /* * Avoid overflow. * If inc causes overflow, untouch allmulti and return error. / if (inc < 0) dev->flags &= ~IFF_ALLMULTI; else { dev->allmulti -= inc; printk(KERN_WARNING "%s: allmulti touches roof, " "set allmulti failed, allmulti feature of " "device might be broken.\n", dev->name); return -EOVERFLOW; } } if (dev->flags ^ old_flags) { dev_change_rx_flags(dev, IFF_ALLMULTI); dev_set_rx_mode(dev); } return 0; } EXPORT_SYMBOL(dev_set_allmulti); / * Upload unicast and multicast address lists to device and * configure RX filtering. When the device doesn't support unicast * filtering it is put in promiscuous mode while unicast addresses * are present. / void __dev_set_rx_mode(struct net_device dev) { const struct net_device_ops ops = dev->netdev_ops; / dev_open will call this function so the list will stay sane. / if (!(dev->flags&IFF_UP)) return; if (!netif_device_present(dev)) return; if (ops->ndo_set_rx_mode) ops->ndo_set_rx_mode(dev); else { / Unicast addresses changes may only happen under the rtnl, * therefore calling __dev_set_promiscuity here is safe. / if (!netdev_uc_empty(dev) && !dev->uc_promisc) { __dev_set_promiscuity(dev, 1); dev->uc_promisc = 1; } else if (netdev_uc_empty(dev) && dev->uc_promisc) { __dev_set_promiscuity(dev, -1); dev->uc_promisc = 0; } if (ops->ndo_set_multicast_list) ops->ndo_set_multicast_list(dev); } } void dev_set_rx_mode(struct net_device dev) { netif_addr_lock_bh(dev); __dev_set_rx_mode(dev); netif_addr_unlock_bh(dev); } /** * dev_get_flags - get flags reported to userspace * @dev: device * * Get the combination of flag bits exported through APIs to userspace. / unsigned dev_get_flags(const struct net_device dev) { unsigned flags; flags = (dev->flags & ~(IFF_PROMISC \| IFF_ALLMULTI \| IFF_RUNNING \| IFF_LOWER_UP \| IFF_DORMANT)) \| (dev->gflags & (IFF_PROMISC \| IFF_ALLMULTI)); if (netif_running(dev)) { if (netif_oper_up(dev)) flags \|= IFF_RUNNING; if (netif_carrier_ok(dev)) flags \|= IFF_LOWER_UP; if (netif_dormant(dev)) flags \|= IFF_DORMANT; } return flags; } EXPORT_SYMBOL(dev_get_flags); int __dev_change_flags(struct net_device dev, unsigned int flags) { int old_flags = dev->flags; int ret; ASSERT_RTNL(); / * Set the flags on our device. / dev->flags = (flags & (IFF_DEBUG \| IFF_NOTRAILERS \| IFF_NOARP \| IFF_DYNAMIC \| IFF_MULTICAST \| IFF_PORTSEL \| IFF_AUTOMEDIA)) \| (dev->flags & (IFF_UP \| IFF_VOLATILE \| IFF_PROMISC \| IFF_ALLMULTI)); / * Load in the correct multicast list now the flags have changed. / if ((old_flags ^ flags) & IFF_MULTICAST) dev_change_rx_flags(dev, IFF_MULTICAST); dev_set_rx_mode(dev); / * Have we downed the interface. We handle IFF_UP ourselves * according to user attempts to set it, rather than blindly * setting it. / ret = 0; if ((old_flags ^ flags) & IFF_UP) { / Bit is different ? / ret = ((old_flags & IFF_UP) ? __dev_close : __dev_open)(dev); if (!ret) dev_set_rx_mode(dev); } if ((flags ^ dev->gflags) & IFF_PROMISC) { int inc = (flags & IFF_PROMISC) ? 1 : -1; dev->gflags ^= IFF_PROMISC; dev_set_promiscuity(dev, inc); } / NOTE: order of synchronization of IFF_PROMISC and IFF_ALLMULTI is important. Some (broken) drivers set IFF_PROMISC, when IFF_ALLMULTI is requested not asking us and not reporting. / if ((flags ^ dev->gflags) & IFF_ALLMULTI) { int inc = (flags & IFF_ALLMULTI) ? 1 : -1; dev->gflags ^= IFF_ALLMULTI; dev_set_allmulti(dev, inc); } return ret; } void __dev_notify_flags(struct net_device dev, unsigned int old_flags) { unsigned int changes = dev->flags ^ old_flags; if (changes & IFF_UP) { if (dev->flags & IFF_UP) call_netdevice_notifiers(NETDEV_UP, dev); else call_netdevice_notifiers(NETDEV_DOWN, dev); } if (dev->flags & IFF_UP && (changes & ~(IFF_UP \| IFF_PROMISC \| IFF_ALLMULTI \| IFF_VOLATILE))) call_netdevice_notifiers(NETDEV_CHANGE, dev); } /** * dev_change_flags - change device settings * @dev: device * @flags: device state flags * * Change settings on device based state flags. The flags are * in the userspace exported format. / int dev_change_flags(struct net_device dev, unsigned flags) { int ret, changes; int old_flags = dev->flags; ret = __dev_change_flags(dev, flags); if (ret < 0) return ret; changes = old_flags ^ dev->flags; if (changes) rtmsg_ifinfo(RTM_NEWLINK, dev, changes); __dev_notify_flags(dev, old_flags); return ret; } EXPORT_SYMBOL(dev_change_flags); /** * dev_set_mtu - Change maximum transfer unit * @dev: device * @new_mtu: new transfer unit * * Change the maximum transfer size of the network device. / int dev_set_mtu(struct net_device dev, int new_mtu) { const struct net_device_ops ops = dev->netdev_ops; int err; if (new_mtu == dev->mtu) return 0; / MTU must be positive. / if (new_mtu < 0) return -EINVAL; if (!netif_device_present(dev)) return -ENODEV; err = 0; if (ops->ndo_change_mtu) err = ops->ndo_change_mtu(dev, new_mtu); else dev->mtu = new_mtu; if (!err && dev->flags & IFF_UP) call_netdevice_notifiers(NETDEV_CHANGEMTU, dev); return err; } EXPORT_SYMBOL(dev_set_mtu); /* * dev_set_mac_address - Change Media Access Control Address * @dev: device * @sa: new address * * Change the hardware (MAC) address of the device / int dev_set_mac_address(struct net_device dev, struct sockaddr sa) { const struct net_device_ops ops = dev->netdev_ops; int err; if (!ops->ndo_set_mac_address) return -EOPNOTSUPP; if (sa->sa_family != dev->type) return -EINVAL; if (!netif_device_present(dev)) return -ENODEV; err = ops->ndo_set_mac_address(dev, sa); if (!err) call_netdevice_notifiers(NETDEV_CHANGEADDR, dev); return err; } EXPORT_SYMBOL(dev_set_mac_address); /* * Perform the SIOCxIFxxx calls, inside rcu_read_lock() / static int dev_ifsioc_locked(struct net net, struct ifreq ifr, unsigned int cmd) { int err; struct net_device dev = dev_get_by_name_rcu(net, ifr->ifr_name); if (!dev) return -ENODEV; switch (cmd) { case SIOCGIFFLAGS: /* Get interface flags / ifr->ifr_flags = (short) dev_get_flags(dev); return 0; case SIOCGIFMETRIC: / Get the metric on the interface (currently unused) / ifr->ifr_metric = 0; return 0; case SIOCGIFMTU: / Get the MTU of a device / ifr->ifr_mtu = dev->mtu; return 0; case SIOCGIFHWADDR: if (!dev->addr_len) memset(ifr->ifr_hwaddr.sa_data, 0, sizeof ifr->ifr_hwaddr.sa_data); else memcpy(ifr->ifr_hwaddr.sa_data, dev->dev_addr, min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len)); ifr->ifr_hwaddr.sa_family = dev->type; return 0; case SIOCGIFSLAVE: err = -EINVAL; break; case SIOCGIFMAP: ifr->ifr_map.mem_start = dev->mem_start; ifr->ifr_map.mem_end = dev->mem_end; ifr->ifr_map.base_addr = dev->base_addr; ifr->ifr_map.irq = dev->irq; ifr->ifr_map.dma = dev->dma; ifr->ifr_map.port = dev->if_port; return 0; case SIOCGIFINDEX: ifr->ifr_ifindex = dev->ifindex; return 0; case SIOCGIFTXQLEN: ifr->ifr_qlen = dev->tx_queue_len; return 0; default: / dev_ioctl() should ensure this case * is never reached / WARN_ON(1); err = -EINVAL; break; } return err; } / * Perform the SIOCxIFxxx calls, inside rtnl_lock() / static int dev_ifsioc(struct net net, struct ifreq ifr, unsigned int cmd) { int err; struct net_device dev = __dev_get_by_name(net, ifr->ifr_name); const struct net_device_ops ops; if (!dev) return -ENODEV; ops = dev->netdev_ops; switch (cmd) { case SIOCSIFFLAGS: / Set interface flags / return dev_change_flags(dev, ifr->ifr_flags); case SIOCSIFMETRIC: / Set the metric on the interface (currently unused) / return -EOPNOTSUPP; case SIOCSIFMTU: / Set the MTU of a device / return dev_set_mtu(dev, ifr->ifr_mtu); case SIOCSIFHWADDR: return dev_set_mac_address(dev, &ifr->ifr_hwaddr); case SIOCSIFHWBROADCAST: if (ifr->ifr_hwaddr.sa_family != dev->type) return -EINVAL; memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data, min(sizeof ifr->ifr_hwaddr.sa_data, (size_t) dev->addr_len)); call_netdevice_notifiers(NETDEV_CHANGEADDR, dev); return 0; case SIOCSIFMAP: if (ops->ndo_set_config) { if (!netif_device_present(dev)) return -ENODEV; return ops->ndo_set_config(dev, &ifr->ifr_map); } return -EOPNOTSUPP; case SIOCADDMULTI: if ((!ops->ndo_set_multicast_list && !ops->ndo_set_rx_mode) \|\| ifr->ifr_hwaddr.sa_family != AF_UNSPEC) return -EINVAL; if (!netif_device_present(dev)) return -ENODEV; return dev_mc_add_global(dev, ifr->ifr_hwaddr.sa_data); case SIOCDELMULTI: if ((!ops->ndo_set_multicast_list && !ops->ndo_set_rx_mode) \|\| ifr->ifr_hwaddr.sa_family != AF_UNSPEC) return -EINVAL; if (!netif_device_present(dev)) return -ENODEV; return dev_mc_del_global(dev, ifr->ifr_hwaddr.sa_data); case SIOCSIFTXQLEN: if (ifr->ifr_qlen < 0) return -EINVAL; dev->tx_queue_len = ifr->ifr_qlen; return 0; case SIOCSIFNAME: ifr->ifr_newname[IFNAMSIZ-1] = '\0'; return dev_change_name(dev, ifr->ifr_newname); / * Unknown or private ioctl / default: if ((cmd >= SIOCDEVPRIVATE && cmd <= SIOCDEVPRIVATE + 15) \|\| cmd == SIOCBONDENSLAVE \|\| cmd == SIOCBONDRELEASE \|\| cmd == SIOCBONDSETHWADDR \|\| cmd == SIOCBONDSLAVEINFOQUERY \|\| cmd == SIOCBONDINFOQUERY \|\| cmd == SIOCBONDCHANGEACTIVE \|\| cmd == SIOCGMIIPHY \|\| cmd == SIOCGMIIREG \|\| cmd == SIOCSMIIREG \|\| cmd == SIOCBRADDIF \|\| cmd == SIOCBRDELIF \|\| cmd == SIOCSHWTSTAMP \|\| cmd == SIOCWANDEV) { err = -EOPNOTSUPP; if (ops->ndo_do_ioctl) { if (netif_device_present(dev)) err = ops->ndo_do_ioctl(dev, ifr, cmd); else err = -ENODEV; } } else err = -EINVAL; } return err; } / * This function handles all "interface"-type I/O control requests. The actual * 'doing' part of this is dev_ifsioc above. / /* * dev_ioctl - network device ioctl * @net: the applicable net namespace * @cmd: command to issue * @arg: pointer to a struct ifreq in user space * * Issue ioctl functions to devices. This is normally called by the * user space syscall interfaces but can sometimes be useful for * other purposes. The return value is the return from the syscall if * positive or a negative errno code on error. / int dev_ioctl(struct net net, unsigned int cmd, void __user arg) { struct ifreq ifr; int ret; char colon; /* One special case: SIOCGIFCONF takes ifconf argument and requires shared lock, because it sleeps writing to user space. / if (cmd == SIOCGIFCONF) { rtnl_lock(); ret = dev_ifconf(net, (char __user ) arg); rtnl_unlock(); return ret; } if (cmd == SIOCGIFNAME) return dev_ifname(net, (struct ifreq __user )arg); if (copy_from_user(&ifr, arg, sizeof(struct ifreq))) return -EFAULT; ifr.ifr_name[IFNAMSIZ-1] = 0; colon = strchr(ifr.ifr_name, ':'); if (colon) colon = 0; /* * See which interface the caller is talking about. / switch (cmd) { / * These ioctl calls: * - can be done by all. * - atomic and do not require locking. * - return a value / case SIOCGIFFLAGS: case SIOCGIFMETRIC: case SIOCGIFMTU: case SIOCGIFHWADDR: case SIOCGIFSLAVE: case SIOCGIFMAP: case SIOCGIFINDEX: case SIOCGIFTXQLEN: dev_load(net, ifr.ifr_name); rcu_read_lock(); ret = dev_ifsioc_locked(net, &ifr, cmd); rcu_read_unlock(); if (!ret) { if (colon) colon = ':'; if (copy_to_user(arg, &ifr, sizeof(struct ifreq))) ret = -EFAULT; } return ret; case SIOCETHTOOL: dev_load(net, ifr.ifr_name); rtnl_lock(); ret = dev_ethtool(net, &ifr); rtnl_unlock(); if (!ret) { if (colon) colon = ':'; if (copy_to_user(arg, &ifr, sizeof(struct ifreq))) ret = -EFAULT; } return ret; / * These ioctl calls: * - require superuser power. * - require strict serialization. * - return a value / case SIOCGMIIPHY: case SIOCGMIIREG: case SIOCSIFNAME: if (!capable(CAP_NET_ADMIN)) return -EPERM; dev_load(net, ifr.ifr_name); rtnl_lock(); ret = dev_ifsioc(net, &ifr, cmd); rtnl_unlock(); if (!ret) { if (colon) colon = ':'; if (copy_to_user(arg, &ifr, sizeof(struct ifreq))) ret = -EFAULT; } return ret; /* * These ioctl calls: * - require superuser power. * - require strict serialization. * - do not return a value / case SIOCSIFFLAGS: case SIOCSIFMETRIC: case SIOCSIFMTU: case SIOCSIFMAP: case SIOCSIFHWADDR: case SIOCSIFSLAVE: case SIOCADDMULTI: case SIOCDELMULTI: case SIOCSIFHWBROADCAST: case SIOCSIFTXQLEN: case SIOCSMIIREG: case SIOCBONDENSLAVE: case SIOCBONDRELEASE: case SIOCBONDSETHWADDR: case SIOCBONDCHANGEACTIVE: case SIOCBRADDIF: case SIOCBRDELIF: case SIOCSHWTSTAMP: if (!capable(CAP_NET_ADMIN)) return -EPERM; / fall through / case SIOCBONDSLAVEINFOQUERY: case SIOCBONDINFOQUERY: dev_load(net, ifr.ifr_name); rtnl_lock(); ret = dev_ifsioc(net, &ifr, cmd); rtnl_unlock(); return ret; case SIOCGIFMEM: / Get the per device memory space. We can add this but * currently do not support it / case SIOCSIFMEM: / Set the per device memory buffer space. * Not applicable in our case / case SIOCSIFLINK: return -EINVAL; / * Unknown or private ioctl. / default: if (cmd == SIOCWANDEV \|\| (cmd >= SIOCDEVPRIVATE && cmd <= SIOCDEVPRIVATE + 15)) { dev_load(net, ifr.ifr_name); rtnl_lock(); ret = dev_ifsioc(net, &ifr, cmd); rtnl_unlock(); if (!ret && copy_to_user(arg, &ifr, sizeof(struct ifreq))) ret = -EFAULT; return ret; } / Take care of Wireless Extensions / if (cmd >= SIOCIWFIRST && cmd <= SIOCIWLAST) return wext_handle_ioctl(net, &ifr, cmd, arg); return -EINVAL; } } /* * dev_new_index - allocate an ifindex * @net: the applicable net namespace * * Returns a suitable unique value for a new device interface * number. The caller must hold the rtnl semaphore or the * dev_base_lock to be sure it remains unique. / static int dev_new_index(struct net net) { static int ifindex; for (;;) { if (++ifindex <= 0) ifindex = 1; if (!__dev_get_by_index(net, ifindex)) return ifindex; } } /* Delayed registration/unregisteration / static LIST_HEAD(net_todo_list); static void net_set_todo(struct net_device dev) { list_add_tail(&dev->todo_list, &net_todo_list); } static void rollback_registered_many(struct list_head head) { struct net_device dev, tmp; BUG_ON(dev_boot_phase); ASSERT_RTNL(); list_for_each_entry_safe(dev, tmp, head, unreg_list) { / Some devices call without registering * for initialization unwind. Remove those * devices and proceed with the remaining. / if (dev->reg_state == NETREG_UNINITIALIZED) { pr_debug("unregister_netdevice: device %s/%p never " "was registered\n", dev->name, dev); WARN_ON(1); list_del(&dev->unreg_list); continue; } BUG_ON(dev->reg_state != NETREG_REGISTERED); } / If device is running, close it first. / dev_close_many(head); list_for_each_entry(dev, head, unreg_list) { / And unlink it from device chain. / unlist_netdevice(dev); dev->reg_state = NETREG_UNREGISTERING; } synchronize_net(); list_for_each_entry(dev, head, unreg_list) { / Shutdown queueing discipline. / dev_shutdown(dev); / Notify protocols, that we are about to destroy this device. They should clean all the things. / call_netdevice_notifiers(NETDEV_UNREGISTER, dev); if (!dev->rtnl_link_ops \|\| dev->rtnl_link_state == RTNL_LINK_INITIALIZED) rtmsg_ifinfo(RTM_DELLINK, dev, ~0U); / * Flush the unicast and multicast chains / dev_uc_flush(dev); dev_mc_flush(dev); if (dev->netdev_ops->ndo_uninit) dev->netdev_ops->ndo_uninit(dev); / Notifier chain MUST detach us from master device. / WARN_ON(dev->master); / Remove entries from kobject tree / netdev_unregister_kobject(dev); } / Process any work delayed until the end of the batch / dev = list_first_entry(head, struct net_device, unreg_list); call_netdevice_notifiers(NETDEV_UNREGISTER_BATCH, dev); rcu_barrier(); list_for_each_entry(dev, head, unreg_list) dev_put(dev); } static void rollback_registered(struct net_device dev) { LIST_HEAD(single); list_add(&dev->unreg_list, &single); rollback_registered_many(&single); list_del(&single); } unsigned long netdev_fix_features(unsigned long features, const char name) { / Fix illegal SG+CSUM combinations. / if ((features & NETIF_F_SG) && !(features & NETIF_F_ALL_CSUM)) { if (name) printk(KERN_NOTICE "%s: Dropping NETIF_F_SG since no " "checksum feature.\n", name); features &= ~NETIF_F_SG; } / TSO requires that SG is present as well. / if ((features & NETIF_F_TSO) && !(features & NETIF_F_SG)) { if (name) printk(KERN_NOTICE "%s: Dropping NETIF_F_TSO since no " "SG feature.\n", name); features &= ~NETIF_F_TSO; } if (features & NETIF_F_UFO) { / maybe split UFO into V4 and V6? / if (!((features & NETIF_F_GEN_CSUM) \|\| (features & (NETIF_F_IP_CSUM\|NETIF_F_IPV6_CSUM)) == (NETIF_F_IP_CSUM\|NETIF_F_IPV6_CSUM))) { if (name) printk(KERN_ERR "%s: Dropping NETIF_F_UFO " "since no checksum offload features.\n", name); features &= ~NETIF_F_UFO; } if (!(features & NETIF_F_SG)) { if (name) printk(KERN_ERR "%s: Dropping NETIF_F_UFO " "since no NETIF_F_SG feature.\n", name); features &= ~NETIF_F_UFO; } } return features; } EXPORT_SYMBOL(netdev_fix_features); /* * netif_stacked_transfer_operstate - transfer operstate * @rootdev: the root or lower level device to transfer state from * @dev: the device to transfer operstate to * * Transfer operational state from root to device. This is normally * called when a stacking relationship exists between the root * device and the device(a leaf device). / void netif_stacked_transfer_operstate(const struct net_device rootdev, struct net_device dev) { if (rootdev->operstate == IF_OPER_DORMANT) netif_dormant_on(dev); else netif_dormant_off(dev); if (netif_carrier_ok(rootdev)) { if (!netif_carrier_ok(dev)) netif_carrier_on(dev); } else { if (netif_carrier_ok(dev)) netif_carrier_off(dev); } } EXPORT_SYMBOL(netif_stacked_transfer_operstate); #ifdef CONFIG_RPS static int netif_alloc_rx_queues(struct net_device dev) { unsigned int i, count = dev->num_rx_queues; struct netdev_rx_queue rx; BUG_ON(count < 1); rx = kcalloc(count, sizeof(struct netdev_rx_queue), GFP_KERNEL); if (!rx) { pr_err("netdev: Unable to allocate %u rx queues.\n", count); return -ENOMEM; } dev->_rx = rx; for (i = 0; i < count; i++) rx[i].dev = dev; return 0; } #endif static void netdev_init_one_queue(struct net_device dev, struct netdev_queue queue, void _unused) { /* Initialize queue lock / spin_lock_init(&queue->_xmit_lock); netdev_set_xmit_lockdep_class(&queue->_xmit_lock, dev->type); queue->xmit_lock_owner = -1; netdev_queue_numa_node_write(queue, NUMA_NO_NODE); queue->dev = dev; } static int netif_alloc_netdev_queues(struct net_device dev) { unsigned int count = dev->num_tx_queues; struct netdev_queue tx; BUG_ON(count < 1); tx = kcalloc(count, sizeof(struct netdev_queue), GFP_KERNEL); if (!tx) { pr_err("netdev: Unable to allocate %u tx queues.\n", count); return -ENOMEM; } dev->_tx = tx; netdev_for_each_tx_queue(dev, netdev_init_one_queue, NULL); spin_lock_init(&dev->tx_global_lock); return 0; } /* * register_netdevice - register a network device * @dev: device to register * * Take a completed network device structure and add it to the kernel * interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier * chain. 0 is returned on success. A negative errno code is returned * on a failure to set up the device, or if the name is a duplicate. * * Callers must hold the rtnl semaphore. You may want * register_netdev() instead of this. * * BUGS: * The locking appears insufficient to guarantee two parallel registers * will not get the same name. / int register_netdevice(struct net_device dev) { int ret; struct net net = dev_net(dev); BUG_ON(dev_boot_phase); ASSERT_RTNL(); might_sleep(); / When net_device's are persistent, this will be fatal. / BUG_ON(dev->reg_state != NETREG_UNINITIALIZED); BUG_ON(!net); spin_lock_init(&dev->addr_list_lock); netdev_set_addr_lockdep_class(dev); dev->iflink = -1; / Init, if this function is available / if (dev->netdev_ops->ndo_init) { ret = dev->netdev_ops->ndo_init(dev); if (ret) { if (ret > 0) ret = -EIO; goto out; } } ret = dev_get_valid_name(dev, dev->name, 0); if (ret) goto err_uninit; dev->ifindex = dev_new_index(net); if (dev->iflink == -1) dev->iflink = dev->ifindex; / Fix illegal checksum combinations / if ((dev->features & NETIF_F_HW_CSUM) && (dev->features & (NETIF_F_IP_CSUM\|NETIF_F_IPV6_CSUM))) { printk(KERN_NOTICE "%s: mixed HW and IP checksum settings.\n", dev->name); dev->features &= ~(NETIF_F_IP_CSUM\|NETIF_F_IPV6_CSUM); } if ((dev->features & NETIF_F_NO_CSUM) && (dev->features & (NETIF_F_HW_CSUM\|NETIF_F_IP_CSUM\|NETIF_F_IPV6_CSUM))) { printk(KERN_NOTICE "%s: mixed no checksumming and other settings.\n", dev->name); dev->features &= ~(NETIF_F_IP_CSUM\|NETIF_F_IPV6_CSUM\|NETIF_F_HW_CSUM); } dev->features = netdev_fix_features(dev->features, dev->name); / Enable software GSO if SG is supported. / if (dev->features & NETIF_F_SG) dev->features \|= NETIF_F_GSO; / Enable GRO and NETIF_F_HIGHDMA for vlans by default, * vlan_dev_init() will do the dev->features check, so these features * are enabled only if supported by underlying device. / dev->vlan_features \|= (NETIF_F_GRO \| NETIF_F_HIGHDMA); ret = call_netdevice_notifiers(NETDEV_POST_INIT, dev); ret = notifier_to_errno(ret); if (ret) goto err_uninit; ret = netdev_register_kobject(dev); if (ret) goto err_uninit; dev->reg_state = NETREG_REGISTERED; / * Default initial state at registry is that the * device is present. / set_bit(__LINK_STATE_PRESENT, &dev->state); dev_init_scheduler(dev); dev_hold(dev); list_netdevice(dev); / Notify protocols, that a new device appeared. / ret = call_netdevice_notifiers(NETDEV_REGISTER, dev); ret = notifier_to_errno(ret); if (ret) { rollback_registered(dev); dev->reg_state = NETREG_UNREGISTERED; } / * Prevent userspace races by waiting until the network * device is fully setup before sending notifications. / if (!dev->rtnl_link_ops \|\| dev->rtnl_link_state == RTNL_LINK_INITIALIZED) rtmsg_ifinfo(RTM_NEWLINK, dev, ~0U); out: return ret; err_uninit: if (dev->netdev_ops->ndo_uninit) dev->netdev_ops->ndo_uninit(dev); goto out; } EXPORT_SYMBOL(register_netdevice); /* * init_dummy_netdev - init a dummy network device for NAPI * @dev: device to init * * This takes a network device structure and initialize the minimum * amount of fields so it can be used to schedule NAPI polls without * registering a full blown interface. This is to be used by drivers * that need to tie several hardware interfaces to a single NAPI * poll scheduler due to HW limitations. / int init_dummy_netdev(struct net_device dev) { /* Clear everything. Note we don't initialize spinlocks * are they aren't supposed to be taken by any of the * NAPI code and this dummy netdev is supposed to be * only ever used for NAPI polls / memset(dev, 0, sizeof(struct net_device)); / make sure we BUG if trying to hit standard * register/unregister code path / dev->reg_state = NETREG_DUMMY; / NAPI wants this / INIT_LIST_HEAD(&dev->napi_list); / a dummy interface is started by default / set_bit(__LINK_STATE_PRESENT, &dev->state); set_bit(__LINK_STATE_START, &dev->state); / Note : We dont allocate pcpu_refcnt for dummy devices, * because users of this 'device' dont need to change * its refcount. / return 0; } EXPORT_SYMBOL_GPL(init_dummy_netdev); /* * register_netdev - register a network device * @dev: device to register * * Take a completed network device structure and add it to the kernel * interfaces. A %NETDEV_REGISTER message is sent to the netdev notifier * chain. 0 is returned on success. A negative errno code is returned * on a failure to set up the device, or if the name is a duplicate. * * This is a wrapper around register_netdevice that takes the rtnl semaphore * and expands the device name if you passed a format string to * alloc_netdev. / int register_netdev(struct net_device dev) { int err; rtnl_lock(); /* * If the name is a format string the caller wants us to do a * name allocation. / if (strchr(dev->name, '%')) { err = dev_alloc_name(dev, dev->name); if (err < 0) goto out; } err = register_netdevice(dev); out: rtnl_unlock(); return err; } EXPORT_SYMBOL(register_netdev); int netdev_refcnt_read(const struct net_device dev) { int i, refcnt = 0; for_each_possible_cpu(i) refcnt += per_cpu_ptr(dev->pcpu_refcnt, i); return refcnt; } EXPORT_SYMBOL(netdev_refcnt_read); / * netdev_wait_allrefs - wait until all references are gone. * * This is called when unregistering network devices. * * Any protocol or device that holds a reference should register * for netdevice notification, and cleanup and put back the * reference if they receive an UNREGISTER event. * We can get stuck here if buggy protocols don't correctly * call dev_put. / static void netdev_wait_allrefs(struct net_device dev) { unsigned long rebroadcast_time, warning_time; int refcnt; linkwatch_forget_dev(dev); rebroadcast_time = warning_time = jiffies; refcnt = netdev_refcnt_read(dev); while (refcnt != 0) { if (time_after(jiffies, rebroadcast_time + 1 * HZ)) { rtnl_lock(); /* Rebroadcast unregister notification / call_netdevice_notifiers(NETDEV_UNREGISTER, dev); / don't resend NETDEV_UNREGISTER_BATCH, _BATCH users * should have already handle it the first time / if (test_bit(__LINK_STATE_LINKWATCH_PENDING, &dev->state)) { / We must not have linkwatch events * pending on unregister. If this * happens, we simply run the queue * unscheduled, resulting in a noop * for this device. / linkwatch_run_queue(); } __rtnl_unlock(); rebroadcast_time = jiffies; } msleep(250); refcnt = netdev_refcnt_read(dev); if (time_after(jiffies, warning_time + 10 HZ)) { printk(KERN_EMERG "unregister_netdevice: " "waiting for %s to become free. Usage " "count = %d\n", dev->name, refcnt); warning_time = jiffies; } } } /* The sequence is: * * rtnl_lock(); * ... * register_netdevice(x1); * register_netdevice(x2); * ... * unregister_netdevice(y1); * unregister_netdevice(y2); * ... * rtnl_unlock(); * free_netdev(y1); * free_netdev(y2); * * We are invoked by rtnl_unlock(). * This allows us to deal with problems: * 1) We can delete sysfs objects which invoke hotplug * without deadlocking with linkwatch via keventd. * 2) Since we run with the RTNL semaphore not held, we can sleep * safely in order to wait for the netdev refcnt to drop to zero. * * We must not return until all unregister events added during * the interval the lock was held have been completed. / void netdev_run_todo(void) { struct list_head list; / Snapshot list, allow later requests / list_replace_init(&net_todo_list, &list); __rtnl_unlock(); while (!list_empty(&list)) { struct net_device dev = list_first_entry(&list, struct net_device, todo_list); list_del(&dev->todo_list); if (unlikely(dev->reg_state != NETREG_UNREGISTERING)) { printk(KERN_ERR "network todo '%s' but state %d\n", dev->name, dev->reg_state); dump_stack(); continue; } dev->reg_state = NETREG_UNREGISTERED; on_each_cpu(flush_backlog, dev, 1); netdev_wait_allrefs(dev); /* paranoia / BUG_ON(netdev_refcnt_read(dev)); WARN_ON(rcu_dereference_raw(dev->ip_ptr)); WARN_ON(rcu_dereference_raw(dev->ip6_ptr)); WARN_ON(dev->dn_ptr); if (dev->destructor) dev->destructor(dev); / Free network device / kobject_put(&dev->dev.kobj); } } / Convert net_device_stats to rtnl_link_stats64. They have the same * fields in the same order, with only the type differing. / static void netdev_stats_to_stats64(struct rtnl_link_stats64 stats64, const struct net_device_stats netdev_stats) { #if BITS_PER_LONG == 64 BUILD_BUG_ON(sizeof(stats64) != sizeof(netdev_stats)); memcpy(stats64, netdev_stats, sizeof(stats64)); #else size_t i, n = sizeof(stats64) / sizeof(u64); const unsigned long src = (const unsigned long )netdev_stats; u64 dst = (u64 )stats64; BUILD_BUG_ON(sizeof(netdev_stats) / sizeof(unsigned long) != sizeof(stats64) / sizeof(u64)); for (i = 0; i < n; i++) dst[i] = src[i]; #endif } /* * dev_get_stats - get network device statistics * @dev: device to get statistics from * @storage: place to store stats * * Get network statistics from device. Return @storage. * The device driver may provide its own method by setting * dev->netdev_ops->get_stats64 or dev->netdev_ops->get_stats; * otherwise the internal statistics structure is used. / struct rtnl_link_stats64 dev_get_stats(struct net_device dev, struct rtnl_link_stats64 storage) { const struct net_device_ops ops = dev->netdev_ops; if (ops->ndo_get_stats64) { memset(storage, 0, sizeof(storage)); ops->ndo_get_stats64(dev, storage); } else if (ops->ndo_get_stats) { netdev_stats_to_stats64(storage, ops->ndo_get_stats(dev)); } else { netdev_stats_to_stats64(storage, &dev->stats); } storage->rx_dropped += atomic_long_read(&dev->rx_dropped); return storage; } EXPORT_SYMBOL(dev_get_stats); struct netdev_queue dev_ingress_queue_create(struct net_device dev) { struct netdev_queue queue = dev_ingress_queue(dev); #ifdef CONFIG_NET_CLS_ACT if (queue) return queue; queue = kzalloc(sizeof(queue), GFP_KERNEL); if (!queue) return NULL; netdev_init_one_queue(dev, queue, NULL); queue->qdisc = &noop_qdisc; queue->qdisc_sleeping = &noop_qdisc; rcu_assign_pointer(dev->ingress_queue, queue); #endif return queue; } /** * alloc_netdev_mqs - allocate network device * @sizeof_priv: size of private data to allocate space for * @name: device name format string * @setup: callback to initialize device * @txqs: the number of TX subqueues to allocate * @rxqs: the number of RX subqueues to allocate * * Allocates a struct net_device with private data area for driver use * and performs basic initialization. Also allocates subquue structs * for each queue on the device. / struct net_device alloc_netdev_mqs(int sizeof_priv, const char name, void (setup)(struct net_device ), unsigned int txqs, unsigned int rxqs) { struct net_device dev; size_t alloc_size; struct net_device p; BUG_ON(strlen(name) >= sizeof(dev->name)); if (txqs < 1) { pr_err("alloc_netdev: Unable to allocate device " "with zero queues.\n"); return NULL; } #ifdef CONFIG_RPS if (rxqs < 1) { pr_err("alloc_netdev: Unable to allocate device " "with zero RX queues.\n"); return NULL; } #endif alloc_size = sizeof(struct net_device); if (sizeof_priv) { / ensure 32-byte alignment of private area / alloc_size = ALIGN(alloc_size, NETDEV_ALIGN); alloc_size += sizeof_priv; } / ensure 32-byte alignment of whole construct / alloc_size += NETDEV_ALIGN - 1; p = kzalloc(alloc_size, GFP_KERNEL); if (!p) { printk(KERN_ERR "alloc_netdev: Unable to allocate device.\n"); return NULL; } dev = PTR_ALIGN(p, NETDEV_ALIGN); dev->padded = (char )dev - (char )p; dev->pcpu_refcnt = alloc_percpu(int); if (!dev->pcpu_refcnt) goto free_p; if (dev_addr_init(dev)) goto free_pcpu; dev_mc_init(dev); dev_uc_init(dev); dev_net_set(dev, &init_net); dev->gso_max_size = GSO_MAX_SIZE; INIT_LIST_HEAD(&dev->ethtool_ntuple_list.list); dev->ethtool_ntuple_list.count = 0; INIT_LIST_HEAD(&dev->napi_list); INIT_LIST_HEAD(&dev->unreg_list); INIT_LIST_HEAD(&dev->link_watch_list); dev->priv_flags = IFF_XMIT_DST_RELEASE; setup(dev); dev->num_tx_queues = txqs; dev->real_num_tx_queues = txqs; if (netif_alloc_netdev_queues(dev)) goto free_all; #ifdef CONFIG_RPS dev->num_rx_queues = rxqs; dev->real_num_rx_queues = rxqs; if (netif_alloc_rx_queues(dev)) goto free_all; #endif strcpy(dev->name, name); return dev; free_all: free_netdev(dev); return NULL; free_pcpu: free_percpu(dev->pcpu_refcnt); kfree(dev->_tx); #ifdef CONFIG_RPS kfree(dev->_rx); #endif free_p: kfree(p); return NULL; } EXPORT_SYMBOL(alloc_netdev_mqs); /* * free_netdev - free network device * @dev: device * * This function does the last stage of destroying an allocated device * interface. The reference to the device object is released. * If this is the last reference then it will be freed. / void free_netdev(struct net_device dev) { struct napi_struct p, n; release_net(dev_net(dev)); kfree(dev->_tx); #ifdef CONFIG_RPS kfree(dev->_rx); #endif kfree(rcu_dereference_raw(dev->ingress_queue)); /* Flush device addresses / dev_addr_flush(dev); / Clear ethtool n-tuple list / ethtool_ntuple_flush(dev); list_for_each_entry_safe(p, n, &dev->napi_list, dev_list) netif_napi_del(p); free_percpu(dev->pcpu_refcnt); dev->pcpu_refcnt = NULL; / Compatibility with error handling in drivers / if (dev->reg_state == NETREG_UNINITIALIZED) { kfree((char )dev - dev->padded); return; } BUG_ON(dev->reg_state != NETREG_UNREGISTERED); dev->reg_state = NETREG_RELEASED; /* will free via device release / put_device(&dev->dev); } EXPORT_SYMBOL(free_netdev); /* * synchronize_net - Synchronize with packet receive processing * * Wait for packets currently being received to be done. * Does not block later packets from starting. / void synchronize_net(void) { might_sleep(); synchronize_rcu(); } EXPORT_SYMBOL(synchronize_net); /* * unregister_netdevice_queue - remove device from the kernel * @dev: device * @head: list * * This function shuts down a device interface and removes it * from the kernel tables. * If head not NULL, device is queued to be unregistered later. * * Callers must hold the rtnl semaphore. You may want * unregister_netdev() instead of this. / void unregister_netdevice_queue(struct net_device dev, struct list_head head) { ASSERT_RTNL(); if (head) { list_move_tail(&dev->unreg_list, head); } else { rollback_registered(dev); / Finish processing unregister after unlock / net_set_todo(dev); } } EXPORT_SYMBOL(unregister_netdevice_queue); /* * unregister_netdevice_many - unregister many devices * @head: list of devices / void unregister_netdevice_many(struct list_head head) { struct net_device dev; if (!list_empty(head)) { rollback_registered_many(head); list_for_each_entry(dev, head, unreg_list) net_set_todo(dev); } } EXPORT_SYMBOL(unregister_netdevice_many); /* * unregister_netdev - remove device from the kernel * @dev: device * * This function shuts down a device interface and removes it * from the kernel tables. * * This is just a wrapper for unregister_netdevice that takes * the rtnl semaphore. In general you want to use this and not * unregister_netdevice. / void unregister_netdev(struct net_device dev) { rtnl_lock(); unregister_netdevice(dev); rtnl_unlock(); } EXPORT_SYMBOL(unregister_netdev); /** * dev_change_net_namespace - move device to different nethost namespace * @dev: device * @net: network namespace * @pat: If not NULL name pattern to try if the current device name * is already taken in the destination network namespace. * * This function shuts down a device interface and moves it * to a new network namespace. On success 0 is returned, on * a failure a netagive errno code is returned. * * Callers must hold the rtnl semaphore. / int dev_change_net_namespace(struct net_device dev, struct net net, const char pat) { int err; ASSERT_RTNL(); /* Don't allow namespace local devices to be moved. / err = -EINVAL; if (dev->features & NETIF_F_NETNS_LOCAL) goto out; / Ensure the device has been registrered / err = -EINVAL; if (dev->reg_state != NETREG_REGISTERED) goto out; / Get out if there is nothing todo / err = 0; if (net_eq(dev_net(dev), net)) goto out; / Pick the destination device name, and ensure * we can use it in the destination network namespace. / err = -EEXIST; if (__dev_get_by_name(net, dev->name)) { / We get here if we can't use the current device name / if (!pat) goto out; if (dev_get_valid_name(dev, pat, 1)) goto out; } / * And now a mini version of register_netdevice unregister_netdevice. / / If device is running close it first. / dev_close(dev); / And unlink it from device chain / err = -ENODEV; unlist_netdevice(dev); synchronize_net(); / Shutdown queueing discipline. / dev_shutdown(dev); / Notify protocols, that we are about to destroy this device. They should clean all the things. Note that dev->reg_state stays at NETREG_REGISTERED. This is wanted because this way 8021q and macvlan know the device is just moving and can keep their slaves up. / call_netdevice_notifiers(NETDEV_UNREGISTER, dev); call_netdevice_notifiers(NETDEV_UNREGISTER_BATCH, dev); / * Flush the unicast and multicast chains / dev_uc_flush(dev); dev_mc_flush(dev); / Actually switch the network namespace / dev_net_set(dev, net); / If there is an ifindex conflict assign a new one / if (__dev_get_by_index(net, dev->ifindex)) { int iflink = (dev->iflink == dev->ifindex); dev->ifindex = dev_new_index(net); if (iflink) dev->iflink = dev->ifindex; } / Fixup kobjects / err = device_rename(&dev->dev, dev->name); WARN_ON(err); / Add the device back in the hashes / list_netdevice(dev); / Notify protocols, that a new device appeared. / call_netdevice_notifiers(NETDEV_REGISTER, dev); / * Prevent userspace races by waiting until the network * device is fully setup before sending notifications. / rtmsg_ifinfo(RTM_NEWLINK, dev, ~0U); synchronize_net(); err = 0; out: return err; } EXPORT_SYMBOL_GPL(dev_change_net_namespace); static int dev_cpu_callback(struct notifier_block nfb, unsigned long action, void ocpu) { struct sk_buff list_skb; struct sk_buff skb; unsigned int cpu, oldcpu = (unsigned long)ocpu; struct softnet_data sd, oldsd; if (action != CPU_DEAD && action != CPU_DEAD_FROZEN) return NOTIFY_OK; local_irq_disable(); cpu = smp_processor_id(); sd = &per_cpu(softnet_data, cpu); oldsd = &per_cpu(softnet_data, oldcpu); /* Find end of our completion_queue. / list_skb = &sd->completion_queue; while (list_skb) list_skb = &(list_skb)->next; / Append completion queue from offline CPU. / list_skb = oldsd->completion_queue; oldsd->completion_queue = NULL; /* Append output queue from offline CPU. / if (oldsd->output_queue) { sd->output_queue_tailp = oldsd->output_queue; sd->output_queue_tailp = oldsd->output_queue_tailp; oldsd->output_queue = NULL; oldsd->output_queue_tailp = &oldsd->output_queue; } raise_softirq_irqoff(NET_TX_SOFTIRQ); local_irq_enable(); /* Process offline CPU's input_pkt_queue / while ((skb = __skb_dequeue(&oldsd->process_queue))) { netif_rx(skb); input_queue_head_incr(oldsd); } while ((skb = __skb_dequeue(&oldsd->input_pkt_queue))) { netif_rx(skb); input_queue_head_incr(oldsd); } return NOTIFY_OK; } /* * netdev_increment_features - increment feature set by one * @all: current feature set * @one: new feature set * @mask: mask feature set * * Computes a new feature set after adding a device with feature set * @one to the master device with current feature set @all. Will not * enable anything that is off in @mask. Returns the new feature set. / unsigned long netdev_increment_features(unsigned long all, unsigned long one, unsigned long mask) { / If device needs checksumming, downgrade to it. / if (all & NETIF_F_NO_CSUM && !(one & NETIF_F_NO_CSUM)) all ^= NETIF_F_NO_CSUM \| (one & NETIF_F_ALL_CSUM); else if (mask & NETIF_F_ALL_CSUM) { / If one device supports v4/v6 checksumming, set for all. / if (one & (NETIF_F_IP_CSUM \| NETIF_F_IPV6_CSUM) && !(all & NETIF_F_GEN_CSUM)) { all &= ~NETIF_F_ALL_CSUM; all \|= one & (NETIF_F_IP_CSUM \| NETIF_F_IPV6_CSUM); } / If one device supports hw checksumming, set for all. / if (one & NETIF_F_GEN_CSUM && !(all & NETIF_F_GEN_CSUM)) { all &= ~NETIF_F_ALL_CSUM; all \|= NETIF_F_HW_CSUM; } } one \|= NETIF_F_ALL_CSUM; one \|= all & NETIF_F_ONE_FOR_ALL; all &= one \| NETIF_F_LLTX \| NETIF_F_GSO \| NETIF_F_UFO; all \|= one & mask & NETIF_F_ONE_FOR_ALL; return all; } EXPORT_SYMBOL(netdev_increment_features); static struct hlist_head netdev_create_hash(void) { int i; struct hlist_head hash; hash = kmalloc(sizeof(hash) * NETDEV_HASHENTRIES, GFP_KERNEL); if (hash != NULL) for (i = 0; i < NETDEV_HASHENTRIES; i++) INIT_HLIST_HEAD(&hash[i]); return hash; } /* Initialize per network namespace state / static int __net_init netdev_init(struct net net) { INIT_LIST_HEAD(&net->dev_base_head); net->dev_name_head = netdev_create_hash(); if (net->dev_name_head == NULL) goto err_name; net->dev_index_head = netdev_create_hash(); if (net->dev_index_head == NULL) goto err_idx; return 0; err_idx: kfree(net->dev_name_head); err_name: return -ENOMEM; } /** * netdev_drivername - network driver for the device * @dev: network device * @buffer: buffer for resulting name * @len: size of buffer * * Determine network driver for device. / char netdev_drivername(const struct net_device dev, char buffer, int len) { const struct device_driver driver; const struct device parent; if (len <= 0 \|\| !buffer) return buffer; buffer[0] = 0; parent = dev->dev.parent; if (!parent) return buffer; driver = parent->driver; if (driver && driver->name) strlcpy(buffer, driver->name, len); return buffer; } static int __netdev_printk(const char level, const struct net_device dev, struct va_format vaf) { int r; if (dev && dev->dev.parent) r = dev_printk(level, dev->dev.parent, "%s: %pV", netdev_name(dev), vaf); else if (dev) r = printk("%s%s: %pV", level, netdev_name(dev), vaf); else r = printk("%s(NULL net_device): %pV", level, vaf); return r; } int netdev_printk(const char level, const struct net_device dev, const char format, ...) { struct va_format vaf; va_list args; int r; va_start(args, format); vaf.fmt = format; vaf.va = &args; r = __netdev_printk(level, dev, &vaf); va_end(args); return r; } EXPORT_SYMBOL(netdev_printk); #define define_netdev_printk_level(func, level) \ int func(const struct net_device dev, const char fmt, ...) \ { \ int r; \ struct va_format vaf; \ va_list args; \ \ va_start(args, fmt); \ \ vaf.fmt = fmt; \ vaf.va = &args; \ \ r = __netdev_printk(level, dev, &vaf); \ va_end(args); \ \ return r; \ } \ EXPORT_SYMBOL(func); define_netdev_printk_level(netdev_emerg, KERN_EMERG); define_netdev_printk_level(netdev_alert, KERN_ALERT); define_netdev_printk_level(netdev_crit, KERN_CRIT); define_netdev_printk_level(netdev_err, KERN_ERR); define_netdev_printk_level(netdev_warn, KERN_WARNING); define_netdev_printk_level(netdev_notice, KERN_NOTICE); define_netdev_printk_level(netdev_info, KERN_INFO); static void __net_exit netdev_exit(struct net net) { kfree(net->dev_name_head); kfree(net->dev_index_head); } static struct pernet_operations __net_initdata netdev_net_ops = { .init = netdev_init, .exit = netdev_exit, }; static void __net_exit default_device_exit(struct net net) { struct net_device dev, aux; /* * Push all migratable network devices back to the * initial network namespace / rtnl_lock(); for_each_netdev_safe(net, dev, aux) { int err; char fb_name[IFNAMSIZ]; / Ignore unmoveable devices (i.e. loopback) / if (dev->features & NETIF_F_NETNS_LOCAL) continue; / Leave virtual devices for the generic cleanup / if (dev->rtnl_link_ops) continue; / Push remaing network devices to init_net / snprintf(fb_name, IFNAMSIZ, "dev%d", dev->ifindex); err = dev_change_net_namespace(dev, &init_net, fb_name); if (err) { printk(KERN_EMERG "%s: failed to move %s to init_net: %d\n", __func__, dev->name, err); BUG(); } } rtnl_unlock(); } static void __net_exit default_device_exit_batch(struct list_head net_list) { /* At exit all network devices most be removed from a network * namespace. Do this in the reverse order of registration. * Do this across as many network namespaces as possible to * improve batching efficiency. / struct net_device dev; struct net net; LIST_HEAD(dev_kill_list); rtnl_lock(); list_for_each_entry(net, net_list, exit_list) { for_each_netdev_reverse(net, dev) { if (dev->rtnl_link_ops) dev->rtnl_link_ops->dellink(dev, &dev_kill_list); else unregister_netdevice_queue(dev, &dev_kill_list); } } unregister_netdevice_many(&dev_kill_list); list_del(&dev_kill_list); rtnl_unlock(); } static struct pernet_operations __net_initdata default_device_ops = { .exit = default_device_exit, .exit_batch = default_device_exit_batch, }; / * Initialize the DEV module. At boot time this walks the device list and * unhooks any devices that fail to initialise (normally hardware not * present) and leaves us with a valid list of present and active devices. * / / * This is called single threaded during boot, so no need * to take the rtnl semaphore. / static int __init net_dev_init(void) { int i, rc = -ENOMEM; BUG_ON(!dev_boot_phase); if (dev_proc_init()) goto out; if (netdev_kobject_init()) goto out; INIT_LIST_HEAD(&ptype_all); for (i = 0; i < PTYPE_HASH_SIZE; i++) INIT_LIST_HEAD(&ptype_base[i]); if (register_pernet_subsys(&netdev_net_ops)) goto out; / * Initialise the packet receive queues. / for_each_possible_cpu(i) { struct softnet_data sd = &per_cpu(softnet_data, i); memset(sd, 0, sizeof(sd)); skb_queue_head_init(&sd->input_pkt_queue); skb_queue_head_init(&sd->process_queue); sd->completion_queue = NULL; INIT_LIST_HEAD(&sd->poll_list); sd->output_queue = NULL; sd->output_queue_tailp = &sd->output_queue; #ifdef CONFIG_RPS sd->csd.func = rps_trigger_softirq; sd->csd.info = sd; sd->csd.flags = 0; sd->cpu = i; #endif sd->backlog.poll = process_backlog; sd->backlog.weight = weight_p; sd->backlog.gro_list = NULL; sd->backlog.gro_count = 0; } dev_boot_phase = 0; / The loopback device is special if any other network devices * is present in a network namespace the loopback device must * be present. Since we now dynamically allocate and free the * loopback device ensure this invariant is maintained by * keeping the loopback device as the first device on the * list of network devices. Ensuring the loopback devices * is the first device that appears and the last network device * that disappears. */ if (register_pernet_device(&loopback_net_ops)) goto out; if (register_pernet_device(&default_device_ops)) goto out; open_softirq(NET_TX_SOFTIRQ, net_tx_action); open_softirq(NET_RX_SOFTIRQ, net_rx_action); hotcpu_notifier(dev_cpu_callback, 0); dst_init(); dev_mcast_init(); rc = 0; out: return rc; } subsys_initcall(net_dev_init); static int __init initialize_hashrnd(void) { get_random_bytes(&hashrnd, sizeof(hashrnd)); return 0; } late_initcall_sync(initialize_hashrnd);	./CrossVul/dataset_final_sorted/CWE-264/c/good_3438_1
crossvul-cpp_data_bad_2423_3	/* * linux/arch/arm/kernel/process.c * * Copyright (C) 1996-2000 Russell King - Converted to ARM. * Original Copyright (C) 1995 Linus Torvalds * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. / #include <stdarg.h> #include <linux/export.h> #include <linux/sched.h> #include <linux/kernel.h> #include <linux/mm.h> #include <linux/stddef.h> #include <linux/unistd.h> #include <linux/user.h> #include <linux/delay.h> #include <linux/reboot.h> #include <linux/interrupt.h> #include <linux/kallsyms.h> #include <linux/init.h> #include <linux/cpu.h> #include <linux/elfcore.h> #include <linux/pm.h> #include <linux/tick.h> #include <linux/utsname.h> #include <linux/uaccess.h> #include <linux/random.h> #include <linux/hw_breakpoint.h> #include <linux/cpuidle.h> #include <linux/leds.h> #include <asm/cacheflush.h> #include <asm/idmap.h> #include <asm/processor.h> #include <asm/thread_notify.h> #include <asm/stacktrace.h> #include <asm/mach/time.h> #ifdef CONFIG_CC_STACKPROTECTOR #include <linux/stackprotector.h> unsigned long __stack_chk_guard __read_mostly; EXPORT_SYMBOL(__stack_chk_guard); #endif static const char processor_modes[] = { "USER_26", "FIQ_26" , "IRQ_26" , "SVC_26" , "UK4_26" , "UK5_26" , "UK6_26" , "UK7_26" , "UK8_26" , "UK9_26" , "UK10_26", "UK11_26", "UK12_26", "UK13_26", "UK14_26", "UK15_26", "USER_32", "FIQ_32" , "IRQ_32" , "SVC_32" , "UK4_32" , "UK5_32" , "UK6_32" , "ABT_32" , "UK8_32" , "UK9_32" , "UK10_32", "UND_32" , "UK12_32", "UK13_32", "UK14_32", "SYS_32" }; static const char isa_modes[] = { "ARM" , "Thumb" , "Jazelle", "ThumbEE" }; extern void call_with_stack(void (fn)(void ), void arg, void sp); typedef void (phys_reset_t)(unsigned long); /* * A temporary stack to use for CPU reset. This is static so that we * don't clobber it with the identity mapping. When running with this * stack, any references to the current task will not work so you * should really do as little as possible before jumping to your reset * code. / static u64 soft_restart_stack[16]; static void __soft_restart(void addr) { phys_reset_t phys_reset; /* Take out a flat memory mapping. / setup_mm_for_reboot(); / Clean and invalidate caches / flush_cache_all(); / Turn off caching / cpu_proc_fin(); / Push out any further dirty data, and ensure cache is empty / flush_cache_all(); / Switch to the identity mapping. / phys_reset = (phys_reset_t)(unsigned long)virt_to_phys(cpu_reset); phys_reset((unsigned long)addr); / Should never get here. / BUG(); } void soft_restart(unsigned long addr) { u64 stack = soft_restart_stack + ARRAY_SIZE(soft_restart_stack); /* Disable interrupts first / local_irq_disable(); local_fiq_disable(); / Disable the L2 if we're the last man standing. / if (num_online_cpus() == 1) outer_disable(); / Change to the new stack and continue with the reset. / call_with_stack(__soft_restart, (void )addr, (void )stack); / Should never get here. / BUG(); } static void null_restart(char mode, const char cmd) { } /* * Function pointers to optional machine specific functions / void (pm_power_off)(void); EXPORT_SYMBOL(pm_power_off); void (arm_pm_restart)(char str, const char cmd) = null_restart; EXPORT_SYMBOL_GPL(arm_pm_restart); /* * This is our default idle handler. / void (arm_pm_idle)(void); static void default_idle(void) { if (arm_pm_idle) arm_pm_idle(); else cpu_do_idle(); local_irq_enable(); } void arch_cpu_idle_prepare(void) { local_fiq_enable(); } void arch_cpu_idle_enter(void) { ledtrig_cpu(CPU_LED_IDLE_START); #ifdef CONFIG_PL310_ERRATA_769419 wmb(); #endif } void arch_cpu_idle_exit(void) { ledtrig_cpu(CPU_LED_IDLE_END); } #ifdef CONFIG_HOTPLUG_CPU void arch_cpu_idle_dead(void) { cpu_die(); } #endif /* * Called from the core idle loop. / void arch_cpu_idle(void) { if (cpuidle_idle_call()) default_idle(); } static char reboot_mode = 'h'; int __init reboot_setup(char str) { reboot_mode = str[0]; return 1; } __setup("reboot=", reboot_setup); void machine_shutdown(void) { #ifdef CONFIG_SMP smp_send_stop(); #endif } void machine_halt(void) { machine_shutdown(); local_irq_disable(); while (1); } void machine_power_off(void) { machine_shutdown(); if (pm_power_off) pm_power_off(); } void machine_restart(char cmd) { machine_shutdown(); arm_pm_restart(reboot_mode, cmd); / Give a grace period for failure to restart of 1s / mdelay(1000); / Whoops - the platform was unable to reboot. Tell the user! / printk("Reboot failed -- System halted\n"); local_irq_disable(); while (1); } void __show_regs(struct pt_regs regs) { unsigned long flags; char buf[64]; show_regs_print_info(KERN_DEFAULT); print_symbol("PC is at %s\n", instruction_pointer(regs)); print_symbol("LR is at %s\n", regs->ARM_lr); printk("pc : [<%08lx>] lr : [<%08lx>] psr: %08lx\n" "sp : %08lx ip : %08lx fp : %08lx\n", regs->ARM_pc, regs->ARM_lr, regs->ARM_cpsr, regs->ARM_sp, regs->ARM_ip, regs->ARM_fp); printk("r10: %08lx r9 : %08lx r8 : %08lx\n", regs->ARM_r10, regs->ARM_r9, regs->ARM_r8); printk("r7 : %08lx r6 : %08lx r5 : %08lx r4 : %08lx\n", regs->ARM_r7, regs->ARM_r6, regs->ARM_r5, regs->ARM_r4); printk("r3 : %08lx r2 : %08lx r1 : %08lx r0 : %08lx\n", regs->ARM_r3, regs->ARM_r2, regs->ARM_r1, regs->ARM_r0); flags = regs->ARM_cpsr; buf[0] = flags & PSR_N_BIT ? 'N' : 'n'; buf[1] = flags & PSR_Z_BIT ? 'Z' : 'z'; buf[2] = flags & PSR_C_BIT ? 'C' : 'c'; buf[3] = flags & PSR_V_BIT ? 'V' : 'v'; buf[4] = '\0'; printk("Flags: %s IRQs o%s FIQs o%s Mode %s ISA %s Segment %s\n", buf, interrupts_enabled(regs) ? "n" : "ff", fast_interrupts_enabled(regs) ? "n" : "ff", processor_modes[processor_mode(regs)], isa_modes[isa_mode(regs)], get_fs() == get_ds() ? "kernel" : "user"); #ifdef CONFIG_CPU_CP15 { unsigned int ctrl; buf[0] = '\0'; #ifdef CONFIG_CPU_CP15_MMU { unsigned int transbase, dac; asm("mrc p15, 0, %0, c2, c0\n\t" "mrc p15, 0, %1, c3, c0\n" : "=r" (transbase), "=r" (dac)); snprintf(buf, sizeof(buf), " Table: %08x DAC: %08x", transbase, dac); } #endif asm("mrc p15, 0, %0, c1, c0\n" : "=r" (ctrl)); printk("Control: %08x%s\n", ctrl, buf); } #endif } void show_regs(struct pt_regs * regs) { printk("\n"); __show_regs(regs); dump_stack(); } ATOMIC_NOTIFIER_HEAD(thread_notify_head); EXPORT_SYMBOL_GPL(thread_notify_head); /* * Free current thread data structures etc.. / void exit_thread(void) { thread_notify(THREAD_NOTIFY_EXIT, current_thread_info()); } void flush_thread(void) { struct thread_info thread = current_thread_info(); struct task_struct tsk = current; flush_ptrace_hw_breakpoint(tsk); memset(thread->used_cp, 0, sizeof(thread->used_cp)); memset(&tsk->thread.debug, 0, sizeof(struct debug_info)); memset(&thread->fpstate, 0, sizeof(union fp_state)); thread_notify(THREAD_NOTIFY_FLUSH, thread); } void release_thread(struct task_struct dead_task) { } asmlinkage void ret_from_fork(void) __asm__("ret_from_fork"); int copy_thread(unsigned long clone_flags, unsigned long stack_start, unsigned long stk_sz, struct task_struct p) { struct thread_info thread = task_thread_info(p); struct pt_regs childregs = task_pt_regs(p); memset(&thread->cpu_context, 0, sizeof(struct cpu_context_save)); if (likely(!(p->flags & PF_KTHREAD))) { childregs = current_pt_regs(); childregs->ARM_r0 = 0; if (stack_start) childregs->ARM_sp = stack_start; } else { memset(childregs, 0, sizeof(struct pt_regs)); thread->cpu_context.r4 = stk_sz; thread->cpu_context.r5 = stack_start; childregs->ARM_cpsr = SVC_MODE; } thread->cpu_context.pc = (unsigned long)ret_from_fork; thread->cpu_context.sp = (unsigned long)childregs; clear_ptrace_hw_breakpoint(p); if (clone_flags & CLONE_SETTLS) thread->tp_value = childregs->ARM_r3; thread_notify(THREAD_NOTIFY_COPY, thread); return 0; } / * Fill in the task's elfregs structure for a core dump. / int dump_task_regs(struct task_struct t, elf_gregset_t elfregs) { elf_core_copy_regs(elfregs, task_pt_regs(t)); return 1; } / * fill in the fpe structure for a core dump... / int dump_fpu (struct pt_regs regs, struct user_fp fp) { struct thread_info thread = current_thread_info(); int used_math = thread->used_cp[1] \| thread->used_cp[2]; if (used_math) memcpy(fp, &thread->fpstate.soft, sizeof (fp)); return used_math != 0; } EXPORT_SYMBOL(dump_fpu); unsigned long get_wchan(struct task_struct p) { struct stackframe frame; int count = 0; if (!p \|\| p == current \|\| p->state == TASK_RUNNING) return 0; frame.fp = thread_saved_fp(p); frame.sp = thread_saved_sp(p); frame.lr = 0; /* recovered from the stack / frame.pc = thread_saved_pc(p); do { int ret = unwind_frame(&frame); if (ret < 0) return 0; if (!in_sched_functions(frame.pc)) return frame.pc; } while (count ++ < 16); return 0; } unsigned long arch_randomize_brk(struct mm_struct mm) { unsigned long range_end = mm->brk + 0x02000000; return randomize_range(mm->brk, range_end, 0) ? : mm->brk; } #ifdef CONFIG_MMU /* * The vectors page is always readable from user space for the * atomic helpers and the signal restart code. Insert it into the * gate_vma so that it is visible through ptrace and /proc/<pid>/mem. / static struct vm_area_struct gate_vma = { .vm_start = 0xffff0000, .vm_end = 0xffff0000 + PAGE_SIZE, .vm_flags = VM_READ \| VM_EXEC \| VM_MAYREAD \| VM_MAYEXEC, .vm_mm = &init_mm, }; static int __init gate_vma_init(void) { gate_vma.vm_page_prot = PAGE_READONLY_EXEC; return 0; } arch_initcall(gate_vma_init); struct vm_area_struct get_gate_vma(struct mm_struct mm) { return &gate_vma; } int in_gate_area(struct mm_struct mm, unsigned long addr) { return (addr >= gate_vma.vm_start) && (addr < gate_vma.vm_end); } int in_gate_area_no_mm(unsigned long addr) { return in_gate_area(NULL, addr); } const char arch_vma_name(struct vm_area_struct vma) { return (vma == &gate_vma) ? "[vectors]" : NULL; } #endif	./CrossVul/dataset_final_sorted/CWE-264/c/bad_2423_3
crossvul-cpp_data_good_5861_1	/* * Cryptographic API. * Glue code for the SHA1 Secure Hash Algorithm assembler implementation * * This file is based on sha1_generic.c and sha1_ssse3_glue.c * * Copyright (c) Alan Smithee. * Copyright (c) Andrew McDonald <andrew@mcdonald.org.uk> * Copyright (c) Jean-Francois Dive <jef@linuxbe.org> * Copyright (c) Mathias Krause <minipli@googlemail.com> * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the Free * Software Foundation; either version 2 of the License, or (at your option) * any later version. * / #include <crypto/internal/hash.h> #include <linux/init.h> #include <linux/module.h> #include <linux/cryptohash.h> #include <linux/types.h> #include <crypto/sha.h> #include <asm/byteorder.h> #include <asm/crypto/sha1.h> asmlinkage void sha1_block_data_order(u32 digest, const unsigned char data, unsigned int rounds); static int sha1_init(struct shash_desc desc) { struct sha1_state sctx = shash_desc_ctx(desc); sctx = (struct sha1_state){ .state = { SHA1_H0, SHA1_H1, SHA1_H2, SHA1_H3, SHA1_H4 }, }; return 0; } static int __sha1_update(struct sha1_state sctx, const u8 data, unsigned int len, unsigned int partial) { unsigned int done = 0; sctx->count += len; if (partial) { done = SHA1_BLOCK_SIZE - partial; memcpy(sctx->buffer + partial, data, done); sha1_block_data_order(sctx->state, sctx->buffer, 1); } if (len - done >= SHA1_BLOCK_SIZE) { const unsigned int rounds = (len - done) / SHA1_BLOCK_SIZE; sha1_block_data_order(sctx->state, data + done, rounds); done += rounds * SHA1_BLOCK_SIZE; } memcpy(sctx->buffer, data + done, len - done); return 0; } int sha1_update_arm(struct shash_desc desc, const u8 data, unsigned int len) { struct sha1_state sctx = shash_desc_ctx(desc); unsigned int partial = sctx->count % SHA1_BLOCK_SIZE; int res; / Handle the fast case right here / if (partial + len < SHA1_BLOCK_SIZE) { sctx->count += len; memcpy(sctx->buffer + partial, data, len); return 0; } res = __sha1_update(sctx, data, len, partial); return res; } EXPORT_SYMBOL_GPL(sha1_update_arm); / Add padding and return the message digest. / static int sha1_final(struct shash_desc desc, u8 out) { struct sha1_state sctx = shash_desc_ctx(desc); unsigned int i, index, padlen; __be32 dst = (__be32 )out; __be64 bits; static const u8 padding[SHA1_BLOCK_SIZE] = { 0x80, }; bits = cpu_to_be64(sctx->count << 3); /* Pad out to 56 mod 64 and append length / index = sctx->count % SHA1_BLOCK_SIZE; padlen = (index < 56) ? (56 - index) : ((SHA1_BLOCK_SIZE+56) - index); / We need to fill a whole block for __sha1_update() / if (padlen <= 56) { sctx->count += padlen; memcpy(sctx->buffer + index, padding, padlen); } else { __sha1_update(sctx, padding, padlen, index); } __sha1_update(sctx, (const u8 )&bits, sizeof(bits), 56); /* Store state in digest / for (i = 0; i < 5; i++) dst[i] = cpu_to_be32(sctx->state[i]); / Wipe context / memset(sctx, 0, sizeof(sctx)); return 0; } static int sha1_export(struct shash_desc desc, void out) { struct sha1_state sctx = shash_desc_ctx(desc); memcpy(out, sctx, sizeof(sctx)); return 0; } static int sha1_import(struct shash_desc desc, const void in) { struct sha1_state sctx = shash_desc_ctx(desc); memcpy(sctx, in, sizeof(sctx)); return 0; } static struct shash_alg alg = { .digestsize = SHA1_DIGEST_SIZE, .init = sha1_init, .update = sha1_update_arm, .final = sha1_final, .export = sha1_export, .import = sha1_import, .descsize = sizeof(struct sha1_state), .statesize = sizeof(struct sha1_state), .base = { .cra_name = "sha1", .cra_driver_name= "sha1-asm", .cra_priority = 150, .cra_flags = CRYPTO_ALG_TYPE_SHASH, .cra_blocksize = SHA1_BLOCK_SIZE, .cra_module = THIS_MODULE, } }; static int __init sha1_mod_init(void) { return crypto_register_shash(&alg); } static void __exit sha1_mod_fini(void) { crypto_unregister_shash(&alg); } module_init(sha1_mod_init); module_exit(sha1_mod_fini); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("SHA1 Secure Hash Algorithm (ARM)"); MODULE_ALIAS_CRYPTO("sha1"); MODULE_AUTHOR("David McCullough <ucdevel@gmail.com>");	./CrossVul/dataset_final_sorted/CWE-264/c/good_5861_1
crossvul-cpp_data_good_1715_0	/* Copyright (C) 2014 Daniel Dressler and contributors * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. / #include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <unistd.h> #include <getopt.h> #include <pthread.h> #include "options.h" #include "logging.h" #include "http.h" #include "tcp.h" #include "usb.h" struct service_thread_param { struct tcp_conn_t tcp; struct usb_sock_t usb_sock; pthread_t thread_handle; }; static void service_connection(void arg_void) { struct service_thread_param arg = (struct service_thread_param )arg_void; // clasify priority while (!arg->tcp->is_closed) { struct usb_conn_t usb = NULL; struct http_message_t server_msg = NULL; struct http_message_t client_msg = NULL; // Client's request client_msg = http_message_new(); if (client_msg == NULL) { ERR("Failed to create client message"); break; } NOTE("M %p: Client msg starting", client_msg); while (!client_msg->is_completed) { struct http_packet_t pkt; pkt = tcp_packet_get(arg->tcp, client_msg); if (pkt == NULL) { if (arg->tcp->is_closed) { NOTE("M %p: Client closed connection\n", client_msg); goto cleanup_subconn; } ERR("M %p: Got null packet from tcp", client_msg); goto cleanup_subconn; } if (usb == NULL && arg->usb_sock != NULL) { usb = usb_conn_acquire(arg->usb_sock, 1); if (usb == NULL) { ERR("M %p: Failed to acquire usb interface", client_msg); packet_free(pkt); goto cleanup_subconn; } NOTE("M %p: Interface #%d: acquired usb conn", client_msg, usb->interface_index); } NOTE("M %p P %p: Pkt from tcp (buffer size: %d)\n===\n%.s\n===", client_msg, pkt, pkt->filled_size, (int)pkt->filled_size, pkt->buffer); // In no-printer mode we simply ignore passing the // client message on to the printer if (arg->usb_sock != NULL) { usb_conn_packet_send(usb, pkt); NOTE("M %p P %p: Interface #%d: Client pkt done", client_msg, pkt, usb->interface_index); } packet_free(pkt); } if (usb != NULL) NOTE("M %p: Interface #%d: Client msg completed\n", client_msg, usb->interface_index); else NOTE("M %p: Client msg completed\n", client_msg); message_free(client_msg); client_msg = NULL; // Server's response server_msg = http_message_new(); if (server_msg == NULL) { ERR("Failed to create server message"); goto cleanup_subconn; } if (usb != NULL) NOTE("M %p: Interface #%d: Server msg starting", server_msg, usb->interface_index); else NOTE("M %p: Server msg starting", server_msg); while (!server_msg->is_completed) { struct http_packet_t pkt; if (arg->usb_sock != NULL) { pkt = usb_conn_packet_get(usb, server_msg); if (pkt == NULL) break; } else { // In no-printer mode we "invent" the answer // of the printer, a simple HTML message as // a pseudo web interface pkt = packet_new(server_msg); snprintf((char)(pkt->buffer), pkt->buffer_capacity - 1, "HTTP/1.1 200 OK\r\nContent-Type: text/html; name=ippusbxd.html; charset=UTF-8\r\n\r\n<html><h2>ippusbxd</h2><p>Debug/development mode without connection to IPP-over-USB printer</p></html>\r\n"); pkt->filled_size = 183; // End the TCP connection, so that a // web browser does not wait for more data server_msg->is_completed = 1; arg->tcp->is_closed = 1; } NOTE("M %p P %p: Pkt from usb (buffer size: %d)\n===\n%.s\n===", server_msg, pkt, pkt->filled_size, (int)pkt->filled_size, pkt->buffer); tcp_packet_send(arg->tcp, pkt); if (usb != NULL) NOTE("M %p P %p: Interface #%d: Server pkt done", server_msg, pkt, usb->interface_index); else NOTE("M %p P %p: Server pkt done", server_msg, pkt); packet_free(pkt); } if (usb != NULL) NOTE("M %p: Interface #%d: Server msg completed\n", server_msg, usb->interface_index); else NOTE("M %p: Server msg completed\n", server_msg); cleanup_subconn: if (client_msg != NULL) message_free(client_msg); if (server_msg != NULL) message_free(server_msg); if (usb != NULL) usb_conn_release(usb); } tcp_conn_close(arg->tcp); free(arg); return NULL; } static void start_daemon() { // Capture USB device if not in no-printer mode struct usb_sock_t usb_sock; if (g_options.noprinter_mode == 0) { usb_sock = usb_open(); if (usb_sock == NULL) goto cleanup_usb; } else usb_sock = NULL; // Capture a socket uint16_t desired_port = g_options.desired_port; struct tcp_sock_t tcp_socket = NULL, tcp6_socket = NULL; for (;;) { tcp_socket = tcp_open(desired_port); tcp6_socket = tcp6_open(desired_port); if (tcp_socket \|\| tcp6_socket \|\| g_options.only_desired_port) break; // Search for a free port desired_port ++; // We failed with 0 as port number or we reached the max // port number if (desired_port == 1 \|\| desired_port == 0) // IANA recommendation of 49152 to 65535 for ephemeral // ports // https://en.wikipedia.org/wiki/Ephemeral_port desired_port = 49152; NOTE("Access to desired port failed, trying alternative port %d", desired_port); } if (tcp_socket == NULL && tcp6_socket == NULL) goto cleanup_tcp; uint16_t real_port; if (tcp_socket) real_port = tcp_port_number_get(tcp_socket); else real_port = tcp_port_number_get(tcp6_socket); if (desired_port != 0 && g_options.only_desired_port == 1 && desired_port != real_port) { ERR("Received port number did not match requested port number." " The requested port number may be too high."); goto cleanup_tcp; } printf("%u\|", real_port); fflush(stdout); NOTE("Port: %d, IPv4 %savailable, IPv6 %savailable", real_port, tcp_socket ? "" : "not ", tcp6_socket ? "" : "not "); // Lose connection to caller uint16_t pid; if (!g_options.nofork_mode && (pid = fork()) > 0) { printf("%u\|", pid); exit(0); } // Register for unplug event if (usb_can_callback(usb_sock)) usb_register_callback(usb_sock); for (;;) { struct service_thread_param args = calloc(1, sizeof(args)); if (args == NULL) { ERR("Failed to alloc space for thread args"); goto cleanup_thread; } args->usb_sock = usb_sock; // For each request/response round we use the socket (IPv4 or // IPv6) which receives data first args->tcp = tcp_conn_select(tcp_socket, tcp6_socket); if (args->tcp == NULL) { ERR("Failed to open tcp connection"); goto cleanup_thread; } int status = pthread_create(&args->thread_handle, NULL, &service_connection, args); if (status) { ERR("Failed to spawn thread, error %d", status); goto cleanup_thread; } continue; cleanup_thread: if (args != NULL) { if (args->tcp != NULL) tcp_conn_close(args->tcp); free(args); } break; } cleanup_tcp: if (tcp_socket!= NULL) tcp_close(tcp_socket); if (tcp6_socket!= NULL) tcp_close(tcp6_socket); cleanup_usb: if (usb_sock != NULL) usb_close(usb_sock); return; } static uint16_t strto16(const char str) { unsigned long val = strtoul(str, NULL, 16); if (val > UINT16_MAX) exit(1); return (uint16_t)val; } int main(int argc, char argv[]) { int c; g_options.log_destination = LOGGING_STDERR; g_options.only_desired_port = 1; while ((c = getopt(argc, argv, "qnhdp:P:s:lv:m:N")) != -1) { switch (c) { case '?': case 'h': g_options.help_mode = 1; break; case 'p': case 'P': { long long port = 0; // Request specific port port = atoi(optarg); if (port < 0) { ERR("Port number must be non-negative"); return 1; } if (port > UINT16_MAX) { ERR("Port number must be %u or less, " "but not negative", UINT16_MAX); return 2; } g_options.desired_port = (uint16_t)port; if (c == 'p') g_options.only_desired_port = 1; else g_options.only_desired_port = 0; break; } case 'l': g_options.log_destination = LOGGING_SYSLOG; break; case 'd': g_options.nofork_mode = 1; g_options.verbose_mode = 1; break; case 'q': g_options.verbose_mode = 1; break; case 'n': g_options.nofork_mode = 1; break; case 'v': g_options.vendor_id = strto16(optarg); break; case 'm': g_options.product_id = strto16(optarg); break; case 's': g_options.serial_num = (unsigned char *)optarg; break; case 'N': g_options.noprinter_mode = 1; break; } } if (g_options.help_mode) { printf( "Usage: %s -v <vendorid> -m <productid> -p <port>\n" "Options:\n" " -h Show this help message\n" " -v <vid> Vendor ID of desired printer\n" " -m <pid> Product ID of desired printer\n" " -s <serial> Serial number of desired printer\n" " -p <portnum> Port number to bind against, error out if port already taken\n" " -P <portnum> Port number to bind against, use another port if port already\n" " taken\n" " -l Redirect logging to syslog\n" " -q Enable verbose tracing\n" " -d Debug mode for verbose output and no fork\n" " -n No-fork mode\n" " -N No-printer mode, debug/developer mode which makes ippusbxd\n" " run without IPP-over-USB printer\n" , argv[0]); return 0; } start_daemon(); return 0; }	./CrossVul/dataset_final_sorted/CWE-264/c/good_1715_0
crossvul-cpp_data_bad_2399_20	/* * Modified to interface to the Linux kernel * Copyright (c) 2009, Intel Corporation. * * 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. * * This program is distributed in the hope it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for * more details. * * You should have received a copy of the GNU General Public License along with * this program; if not, write to the Free Software Foundation, Inc., 59 Temple * Place - Suite 330, Boston, MA 02111-1307 USA. / / -------------------------------------------------------------------------- * VMAC and VHASH Implementation by Ted Krovetz (tdk@acm.org) and Wei Dai. * This implementation is herby placed in the public domain. * The authors offers no warranty. Use at your own risk. * Please send bug reports to the authors. * Last modified: 17 APR 08, 1700 PDT * ----------------------------------------------------------------------- / #include <linux/init.h> #include <linux/types.h> #include <linux/crypto.h> #include <linux/module.h> #include <linux/scatterlist.h> #include <asm/byteorder.h> #include <crypto/scatterwalk.h> #include <crypto/vmac.h> #include <crypto/internal/hash.h> / * Constants and masks / #define UINT64_C(x) x##ULL static const u64 p64 = UINT64_C(0xfffffffffffffeff); / 2^64 - 257 prime / static const u64 m62 = UINT64_C(0x3fffffffffffffff); / 62-bit mask / static const u64 m63 = UINT64_C(0x7fffffffffffffff); / 63-bit mask / static const u64 m64 = UINT64_C(0xffffffffffffffff); / 64-bit mask / static const u64 mpoly = UINT64_C(0x1fffffff1fffffff); / Poly key mask / #define pe64_to_cpup le64_to_cpup / Prefer little endian / #ifdef __LITTLE_ENDIAN #define INDEX_HIGH 1 #define INDEX_LOW 0 #else #define INDEX_HIGH 0 #define INDEX_LOW 1 #endif / * The following routines are used in this implementation. They are * written via macros to simulate zero-overhead call-by-reference. * * MUL64: 64x64->128-bit multiplication * PMUL64: assumes top bits cleared on inputs * ADD128: 128x128->128-bit addition / #define ADD128(rh, rl, ih, il) \ do { \ u64 _il = (il); \ (rl) += (_il); \ if ((rl) < (_il)) \ (rh)++; \ (rh) += (ih); \ } while (0) #define MUL32(i1, i2) ((u64)(u32)(i1)(u32)(i2)) #define PMUL64(rh, rl, i1, i2) /* Assumes m doesn't overflow / \ do { \ u64 _i1 = (i1), _i2 = (i2); \ u64 m = MUL32(_i1, _i2>>32) + MUL32(_i1>>32, _i2); \ rh = MUL32(_i1>>32, _i2>>32); \ rl = MUL32(_i1, _i2); \ ADD128(rh, rl, (m >> 32), (m << 32)); \ } while (0) #define MUL64(rh, rl, i1, i2) \ do { \ u64 _i1 = (i1), _i2 = (i2); \ u64 m1 = MUL32(_i1, _i2>>32); \ u64 m2 = MUL32(_i1>>32, _i2); \ rh = MUL32(_i1>>32, _i2>>32); \ rl = MUL32(_i1, _i2); \ ADD128(rh, rl, (m1 >> 32), (m1 << 32)); \ ADD128(rh, rl, (m2 >> 32), (m2 << 32)); \ } while (0) / * For highest performance the L1 NH and L2 polynomial hashes should be * carefully implemented to take advantage of one's target architecture. * Here these two hash functions are defined multiple time; once for * 64-bit architectures, once for 32-bit SSE2 architectures, and once * for the rest (32-bit) architectures. * For each, nh_16 must be defined (works on multiples of 16 bytes). * Optionally, nh_vmac_nhbytes can be defined (for multiples of * VMAC_NHBYTES), and nh_16_2 and nh_vmac_nhbytes_2 (versions that do two * NH computations at once). / #ifdef CONFIG_64BIT #define nh_16(mp, kp, nw, rh, rl) \ do { \ int i; u64 th, tl; \ rh = rl = 0; \ for (i = 0; i < nw; i += 2) { \ MUL64(th, tl, pe64_to_cpup((mp)+i)+(kp)[i], \ pe64_to_cpup((mp)+i+1)+(kp)[i+1]); \ ADD128(rh, rl, th, tl); \ } \ } while (0) #define nh_16_2(mp, kp, nw, rh, rl, rh1, rl1) \ do { \ int i; u64 th, tl; \ rh1 = rl1 = rh = rl = 0; \ for (i = 0; i < nw; i += 2) { \ MUL64(th, tl, pe64_to_cpup((mp)+i)+(kp)[i], \ pe64_to_cpup((mp)+i+1)+(kp)[i+1]); \ ADD128(rh, rl, th, tl); \ MUL64(th, tl, pe64_to_cpup((mp)+i)+(kp)[i+2], \ pe64_to_cpup((mp)+i+1)+(kp)[i+3]); \ ADD128(rh1, rl1, th, tl); \ } \ } while (0) #if (VMAC_NHBYTES >= 64) / These versions do 64-bytes of message at a time / #define nh_vmac_nhbytes(mp, kp, nw, rh, rl) \ do { \ int i; u64 th, tl; \ rh = rl = 0; \ for (i = 0; i < nw; i += 8) { \ MUL64(th, tl, pe64_to_cpup((mp)+i)+(kp)[i], \ pe64_to_cpup((mp)+i+1)+(kp)[i+1]); \ ADD128(rh, rl, th, tl); \ MUL64(th, tl, pe64_to_cpup((mp)+i+2)+(kp)[i+2], \ pe64_to_cpup((mp)+i+3)+(kp)[i+3]); \ ADD128(rh, rl, th, tl); \ MUL64(th, tl, pe64_to_cpup((mp)+i+4)+(kp)[i+4], \ pe64_to_cpup((mp)+i+5)+(kp)[i+5]); \ ADD128(rh, rl, th, tl); \ MUL64(th, tl, pe64_to_cpup((mp)+i+6)+(kp)[i+6], \ pe64_to_cpup((mp)+i+7)+(kp)[i+7]); \ ADD128(rh, rl, th, tl); \ } \ } while (0) #define nh_vmac_nhbytes_2(mp, kp, nw, rh, rl, rh1, rl1) \ do { \ int i; u64 th, tl; \ rh1 = rl1 = rh = rl = 0; \ for (i = 0; i < nw; i += 8) { \ MUL64(th, tl, pe64_to_cpup((mp)+i)+(kp)[i], \ pe64_to_cpup((mp)+i+1)+(kp)[i+1]); \ ADD128(rh, rl, th, tl); \ MUL64(th, tl, pe64_to_cpup((mp)+i)+(kp)[i+2], \ pe64_to_cpup((mp)+i+1)+(kp)[i+3]); \ ADD128(rh1, rl1, th, tl); \ MUL64(th, tl, pe64_to_cpup((mp)+i+2)+(kp)[i+2], \ pe64_to_cpup((mp)+i+3)+(kp)[i+3]); \ ADD128(rh, rl, th, tl); \ MUL64(th, tl, pe64_to_cpup((mp)+i+2)+(kp)[i+4], \ pe64_to_cpup((mp)+i+3)+(kp)[i+5]); \ ADD128(rh1, rl1, th, tl); \ MUL64(th, tl, pe64_to_cpup((mp)+i+4)+(kp)[i+4], \ pe64_to_cpup((mp)+i+5)+(kp)[i+5]); \ ADD128(rh, rl, th, tl); \ MUL64(th, tl, pe64_to_cpup((mp)+i+4)+(kp)[i+6], \ pe64_to_cpup((mp)+i+5)+(kp)[i+7]); \ ADD128(rh1, rl1, th, tl); \ MUL64(th, tl, pe64_to_cpup((mp)+i+6)+(kp)[i+6], \ pe64_to_cpup((mp)+i+7)+(kp)[i+7]); \ ADD128(rh, rl, th, tl); \ MUL64(th, tl, pe64_to_cpup((mp)+i+6)+(kp)[i+8], \ pe64_to_cpup((mp)+i+7)+(kp)[i+9]); \ ADD128(rh1, rl1, th, tl); \ } \ } while (0) #endif #define poly_step(ah, al, kh, kl, mh, ml) \ do { \ u64 t1h, t1l, t2h, t2l, t3h, t3l, z = 0; \ / compute abcd, put bd into result registers / \ PMUL64(t3h, t3l, al, kh); \ PMUL64(t2h, t2l, ah, kl); \ PMUL64(t1h, t1l, ah, 2kh); \ PMUL64(ah, al, al, kl); \ / add 2 * ac to result / \ ADD128(ah, al, t1h, t1l); \ / add together ad + bc / \ ADD128(t2h, t2l, t3h, t3l); \ / now (ah,al), (t2l,2t2h) need summing / \ /* first add the high registers, carrying into t2h / \ ADD128(t2h, ah, z, t2l); \ / double t2h and add top bit of ah / \ t2h = 2 t2h + (ah >> 63); \ ah &= m63; \ /* now add the low registers / \ ADD128(ah, al, mh, ml); \ ADD128(ah, al, z, t2h); \ } while (0) #else / ! CONFIG_64BIT / #ifndef nh_16 #define nh_16(mp, kp, nw, rh, rl) \ do { \ u64 t1, t2, m1, m2, t; \ int i; \ rh = rl = t = 0; \ for (i = 0; i < nw; i += 2) { \ t1 = pe64_to_cpup(mp+i) + kp[i]; \ t2 = pe64_to_cpup(mp+i+1) + kp[i+1]; \ m2 = MUL32(t1 >> 32, t2); \ m1 = MUL32(t1, t2 >> 32); \ ADD128(rh, rl, MUL32(t1 >> 32, t2 >> 32), \ MUL32(t1, t2)); \ rh += (u64)(u32)(m1 >> 32) \ + (u32)(m2 >> 32); \ t += (u64)(u32)m1 + (u32)m2; \ } \ ADD128(rh, rl, (t >> 32), (t << 32)); \ } while (0) #endif static void poly_step_func(u64 ahi, u64 alo, const u64 kh, const u64 kl, const u64 mh, const u64 ml) { #define a0 ((((u32 )alo)+INDEX_LOW)) #define a1 ((((u32 )alo)+INDEX_HIGH)) #define a2 ((((u32 )ahi)+INDEX_LOW)) #define a3 ((((u32 )ahi)+INDEX_HIGH)) #define k0 ((((u32 )kl)+INDEX_LOW)) #define k1 ((((u32 )kl)+INDEX_HIGH)) #define k2 ((((u32 )kh)+INDEX_LOW)) #define k3 ((((u32 )kh)+INDEX_HIGH)) u64 p, q, t; u32 t2; p = MUL32(a3, k3); p += p; p += (u64 )mh; p += MUL32(a0, k2); p += MUL32(a1, k1); p += MUL32(a2, k0); t = (u32)(p); p >>= 32; p += MUL32(a0, k3); p += MUL32(a1, k2); p += MUL32(a2, k1); p += MUL32(a3, k0); t \|= ((u64)((u32)p & 0x7fffffff)) << 32; p >>= 31; p += (u64)(((u32 )ml)[INDEX_LOW]); p += MUL32(a0, k0); q = MUL32(a1, k3); q += MUL32(a2, k2); q += MUL32(a3, k1); q += q; p += q; t2 = (u32)(p); p >>= 32; p += (u64)(((u32 )ml)[INDEX_HIGH]); p += MUL32(a0, k1); p += MUL32(a1, k0); q = MUL32(a2, k3); q += MUL32(a3, k2); q += q; p += q; (u64 )(alo) = (p << 32) \| t2; p >>= 32; (u64 )(ahi) = p + t; #undef a0 #undef a1 #undef a2 #undef a3 #undef k0 #undef k1 #undef k2 #undef k3 } #define poly_step(ah, al, kh, kl, mh, ml) \ poly_step_func(&(ah), &(al), &(kh), &(kl), &(mh), &(ml)) #endif / end of specialized NH and poly definitions / / At least nh_16 is defined. Defined others as needed here / #ifndef nh_16_2 #define nh_16_2(mp, kp, nw, rh, rl, rh2, rl2) \ do { \ nh_16(mp, kp, nw, rh, rl); \ nh_16(mp, ((kp)+2), nw, rh2, rl2); \ } while (0) #endif #ifndef nh_vmac_nhbytes #define nh_vmac_nhbytes(mp, kp, nw, rh, rl) \ nh_16(mp, kp, nw, rh, rl) #endif #ifndef nh_vmac_nhbytes_2 #define nh_vmac_nhbytes_2(mp, kp, nw, rh, rl, rh2, rl2) \ do { \ nh_vmac_nhbytes(mp, kp, nw, rh, rl); \ nh_vmac_nhbytes(mp, ((kp)+2), nw, rh2, rl2); \ } while (0) #endif static void vhash_abort(struct vmac_ctx ctx) { ctx->polytmp[0] = ctx->polykey[0] ; ctx->polytmp[1] = ctx->polykey[1] ; ctx->first_block_processed = 0; } static u64 l3hash(u64 p1, u64 p2, u64 k1, u64 k2, u64 len) { u64 rh, rl, t, z = 0; /* fully reduce (p1,p2)+(len,0) mod p127 / t = p1 >> 63; p1 &= m63; ADD128(p1, p2, len, t); / At this point, (p1,p2) is at most 2^127+(len<<64) / t = (p1 > m63) + ((p1 == m63) && (p2 == m64)); ADD128(p1, p2, z, t); p1 &= m63; / compute (p1,p2)/(2^64-2^32) and (p1,p2)%(2^64-2^32) / t = p1 + (p2 >> 32); t += (t >> 32); t += (u32)t > 0xfffffffeu; p1 += (t >> 32); p2 += (p1 << 32); / compute (p1+k1)%p64 and (p2+k2)%p64 / p1 += k1; p1 += (0 - (p1 < k1)) & 257; p2 += k2; p2 += (0 - (p2 < k2)) & 257; / compute (p1+k1)(p2+k2)%p64 / MUL64(rh, rl, p1, p2); t = rh >> 56; ADD128(t, rl, z, rh); rh <<= 8; ADD128(t, rl, z, rh); t += t << 8; rl += t; rl += (0 - (rl < t)) & 257; rl += (0 - (rl > p64-1)) & 257; return rl; } static void vhash_update(const unsigned char m, unsigned int mbytes, / Pos multiple of VMAC_NHBYTES / struct vmac_ctx ctx) { u64 rh, rl, mptr; const u64 kptr = (u64 )ctx->nhkey; int i; u64 ch, cl; u64 pkh = ctx->polykey[0]; u64 pkl = ctx->polykey[1]; if (!mbytes) return; BUG_ON(mbytes % VMAC_NHBYTES); mptr = (u64 )m; i = mbytes / VMAC_NHBYTES; /* Must be non-zero / ch = ctx->polytmp[0]; cl = ctx->polytmp[1]; if (!ctx->first_block_processed) { ctx->first_block_processed = 1; nh_vmac_nhbytes(mptr, kptr, VMAC_NHBYTES/8, rh, rl); rh &= m62; ADD128(ch, cl, rh, rl); mptr += (VMAC_NHBYTES/sizeof(u64)); i--; } while (i--) { nh_vmac_nhbytes(mptr, kptr, VMAC_NHBYTES/8, rh, rl); rh &= m62; poly_step(ch, cl, pkh, pkl, rh, rl); mptr += (VMAC_NHBYTES/sizeof(u64)); } ctx->polytmp[0] = ch; ctx->polytmp[1] = cl; } static u64 vhash(unsigned char m[], unsigned int mbytes, u64 tagl, struct vmac_ctx ctx) { u64 rh, rl, mptr; const u64 kptr = (u64 )ctx->nhkey; int i, remaining; u64 ch, cl; u64 pkh = ctx->polykey[0]; u64 pkl = ctx->polykey[1]; mptr = (u64 )m; i = mbytes / VMAC_NHBYTES; remaining = mbytes % VMAC_NHBYTES; if (ctx->first_block_processed) { ch = ctx->polytmp[0]; cl = ctx->polytmp[1]; } else if (i) { nh_vmac_nhbytes(mptr, kptr, VMAC_NHBYTES/8, ch, cl); ch &= m62; ADD128(ch, cl, pkh, pkl); mptr += (VMAC_NHBYTES/sizeof(u64)); i--; } else if (remaining) { nh_16(mptr, kptr, 2((remaining+15)/16), ch, cl); ch &= m62; ADD128(ch, cl, pkh, pkl); mptr += (VMAC_NHBYTES/sizeof(u64)); goto do_l3; } else {/* Empty String / ch = pkh; cl = pkl; goto do_l3; } while (i--) { nh_vmac_nhbytes(mptr, kptr, VMAC_NHBYTES/8, rh, rl); rh &= m62; poly_step(ch, cl, pkh, pkl, rh, rl); mptr += (VMAC_NHBYTES/sizeof(u64)); } if (remaining) { nh_16(mptr, kptr, 2((remaining+15)/16), rh, rl); rh &= m62; poly_step(ch, cl, pkh, pkl, rh, rl); } do_l3: vhash_abort(ctx); remaining = 8; return l3hash(ch, cl, ctx->l3key[0], ctx->l3key[1], remaining); } static u64 vmac(unsigned char m[], unsigned int mbytes, const unsigned char n[16], u64 tagl, struct vmac_ctx_t ctx) { u64 in_n, out_p; u64 p, h; int i; in_n = ctx->__vmac_ctx.cached_nonce; out_p = ctx->__vmac_ctx.cached_aes; i = n[15] & 1; if (((u64 )(n+8) != in_n[1]) \|\| ((u64 )(n) != in_n[0])) { in_n[0] = (u64 )(n); in_n[1] = (u64 )(n+8); ((unsigned char )in_n)[15] &= 0xFE; crypto_cipher_encrypt_one(ctx->child, (unsigned char )out_p, (unsigned char )in_n); ((unsigned char )in_n)[15] \|= (unsigned char)(1-i); } p = be64_to_cpup(out_p + i); h = vhash(m, mbytes, (u64 )0, &ctx->__vmac_ctx); return le64_to_cpu(p + h); } static int vmac_set_key(unsigned char user_key[], struct vmac_ctx_t ctx) { u64 in[2] = {0}, out[2]; unsigned i; int err = 0; err = crypto_cipher_setkey(ctx->child, user_key, VMAC_KEY_LEN); if (err) return err; / Fill nh key / ((unsigned char )in)[0] = 0x80; for (i = 0; i < sizeof(ctx->__vmac_ctx.nhkey)/8; i += 2) { crypto_cipher_encrypt_one(ctx->child, (unsigned char )out, (unsigned char )in); ctx->__vmac_ctx.nhkey[i] = be64_to_cpup(out); ctx->__vmac_ctx.nhkey[i+1] = be64_to_cpup(out+1); ((unsigned char )in)[15] += 1; } / Fill poly key / ((unsigned char )in)[0] = 0xC0; in[1] = 0; for (i = 0; i < sizeof(ctx->__vmac_ctx.polykey)/8; i += 2) { crypto_cipher_encrypt_one(ctx->child, (unsigned char )out, (unsigned char )in); ctx->__vmac_ctx.polytmp[i] = ctx->__vmac_ctx.polykey[i] = be64_to_cpup(out) & mpoly; ctx->__vmac_ctx.polytmp[i+1] = ctx->__vmac_ctx.polykey[i+1] = be64_to_cpup(out+1) & mpoly; ((unsigned char )in)[15] += 1; } / Fill ip key / ((unsigned char )in)[0] = 0xE0; in[1] = 0; for (i = 0; i < sizeof(ctx->__vmac_ctx.l3key)/8; i += 2) { do { crypto_cipher_encrypt_one(ctx->child, (unsigned char )out, (unsigned char )in); ctx->__vmac_ctx.l3key[i] = be64_to_cpup(out); ctx->__vmac_ctx.l3key[i+1] = be64_to_cpup(out+1); ((unsigned char )in)[15] += 1; } while (ctx->__vmac_ctx.l3key[i] >= p64 \|\| ctx->__vmac_ctx.l3key[i+1] >= p64); } / Invalidate nonce/aes cache and reset other elements / ctx->__vmac_ctx.cached_nonce[0] = (u64)-1; / Ensure illegal nonce / ctx->__vmac_ctx.cached_nonce[1] = (u64)0; / Ensure illegal nonce / ctx->__vmac_ctx.first_block_processed = 0; return err; } static int vmac_setkey(struct crypto_shash parent, const u8 key, unsigned int keylen) { struct vmac_ctx_t ctx = crypto_shash_ctx(parent); if (keylen != VMAC_KEY_LEN) { crypto_shash_set_flags(parent, CRYPTO_TFM_RES_BAD_KEY_LEN); return -EINVAL; } return vmac_set_key((u8 )key, ctx); } static int vmac_init(struct shash_desc pdesc) { return 0; } static int vmac_update(struct shash_desc pdesc, const u8 p, unsigned int len) { struct crypto_shash parent = pdesc->tfm; struct vmac_ctx_t ctx = crypto_shash_ctx(parent); int expand; int min; expand = VMAC_NHBYTES - ctx->partial_size > 0 ? VMAC_NHBYTES - ctx->partial_size : 0; min = len < expand ? len : expand; memcpy(ctx->partial + ctx->partial_size, p, min); ctx->partial_size += min; if (len < expand) return 0; vhash_update(ctx->partial, VMAC_NHBYTES, &ctx->__vmac_ctx); ctx->partial_size = 0; len -= expand; p += expand; if (len % VMAC_NHBYTES) { memcpy(ctx->partial, p + len - (len % VMAC_NHBYTES), len % VMAC_NHBYTES); ctx->partial_size = len % VMAC_NHBYTES; } vhash_update(p, len - len % VMAC_NHBYTES, &ctx->__vmac_ctx); return 0; } static int vmac_final(struct shash_desc pdesc, u8 out) { struct crypto_shash parent = pdesc->tfm; struct vmac_ctx_t ctx = crypto_shash_ctx(parent); vmac_t mac; u8 nonce[16] = {}; /* vmac() ends up accessing outside the array bounds that * we specify. In appears to access up to the next 2-word * boundary. We'll just be uber cautious and zero the * unwritten bytes in the buffer. / if (ctx->partial_size) { memset(ctx->partial + ctx->partial_size, 0, VMAC_NHBYTES - ctx->partial_size); } mac = vmac(ctx->partial, ctx->partial_size, nonce, NULL, ctx); memcpy(out, &mac, sizeof(vmac_t)); memzero_explicit(&mac, sizeof(vmac_t)); memset(&ctx->__vmac_ctx, 0, sizeof(struct vmac_ctx)); ctx->partial_size = 0; return 0; } static int vmac_init_tfm(struct crypto_tfm tfm) { struct crypto_cipher cipher; struct crypto_instance inst = (void )tfm->__crt_alg; struct crypto_spawn spawn = crypto_instance_ctx(inst); struct vmac_ctx_t ctx = crypto_tfm_ctx(tfm); cipher = crypto_spawn_cipher(spawn); if (IS_ERR(cipher)) return PTR_ERR(cipher); ctx->child = cipher; return 0; } static void vmac_exit_tfm(struct crypto_tfm tfm) { struct vmac_ctx_t ctx = crypto_tfm_ctx(tfm); crypto_free_cipher(ctx->child); } static int vmac_create(struct crypto_template tmpl, struct rtattr *tb) { struct shash_instance inst; struct crypto_alg *alg; int err; err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_SHASH); if (err) return err; alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER, CRYPTO_ALG_TYPE_MASK); if (IS_ERR(alg)) return PTR_ERR(alg); inst = shash_alloc_instance("vmac", alg); err = PTR_ERR(inst); if (IS_ERR(inst)) goto out_put_alg; err = crypto_init_spawn(shash_instance_ctx(inst), alg, shash_crypto_instance(inst), CRYPTO_ALG_TYPE_MASK); if (err) goto out_free_inst; inst->alg.base.cra_priority = alg->cra_priority; inst->alg.base.cra_blocksize = alg->cra_blocksize; inst->alg.base.cra_alignmask = alg->cra_alignmask; inst->alg.digestsize = sizeof(vmac_t); inst->alg.base.cra_ctxsize = sizeof(struct vmac_ctx_t); inst->alg.base.cra_init = vmac_init_tfm; inst->alg.base.cra_exit = vmac_exit_tfm; inst->alg.init = vmac_init; inst->alg.update = vmac_update; inst->alg.final = vmac_final; inst->alg.setkey = vmac_setkey; err = shash_register_instance(tmpl, inst); if (err) { out_free_inst: shash_free_instance(shash_crypto_instance(inst)); } out_put_alg: crypto_mod_put(alg); return err; } static struct crypto_template vmac_tmpl = { .name = "vmac", .create = vmac_create, .free = shash_free_instance, .module = THIS_MODULE, }; static int __init vmac_module_init(void) { return crypto_register_template(&vmac_tmpl); } static void __exit vmac_module_exit(void) { crypto_unregister_template(&vmac_tmpl); } module_init(vmac_module_init); module_exit(vmac_module_exit); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("VMAC hash algorithm");	./CrossVul/dataset_final_sorted/CWE-264/c/bad_2399_20
crossvul-cpp_data_good_5040_0	/* * Kernel-based Virtual Machine driver for Linux * * This module enables machines with Intel VT-x extensions to run virtual * machines without emulation or binary translation. * * Copyright (C) 2006 Qumranet, Inc. * Copyright 2010 Red Hat, Inc. and/or its affiliates. * * Authors: * Avi Kivity <avi@qumranet.com> * Yaniv Kamay <yaniv@qumranet.com> * * This work is licensed under the terms of the GNU GPL, version 2. See * the COPYING file in the top-level directory. * / #include "irq.h" #include "mmu.h" #include "cpuid.h" #include "lapic.h" #include <linux/kvm_host.h> #include <linux/module.h> #include <linux/kernel.h> #include <linux/mm.h> #include <linux/highmem.h> #include <linux/sched.h> #include <linux/moduleparam.h> #include <linux/mod_devicetable.h> #include <linux/trace_events.h> #include <linux/slab.h> #include <linux/tboot.h> #include <linux/hrtimer.h> #include "kvm_cache_regs.h" #include "x86.h" #include <asm/cpu.h> #include <asm/io.h> #include <asm/desc.h> #include <asm/vmx.h> #include <asm/virtext.h> #include <asm/mce.h> #include <asm/fpu/internal.h> #include <asm/perf_event.h> #include <asm/debugreg.h> #include <asm/kexec.h> #include <asm/apic.h> #include <asm/irq_remapping.h> #include "trace.h" #include "pmu.h" #define __ex(x) __kvm_handle_fault_on_reboot(x) #define __ex_clear(x, reg) \ ____kvm_handle_fault_on_reboot(x, "xor " reg " , " reg) MODULE_AUTHOR("Qumranet"); MODULE_LICENSE("GPL"); static const struct x86_cpu_id vmx_cpu_id[] = { X86_FEATURE_MATCH(X86_FEATURE_VMX), {} }; MODULE_DEVICE_TABLE(x86cpu, vmx_cpu_id); static bool __read_mostly enable_vpid = 1; module_param_named(vpid, enable_vpid, bool, 0444); static bool __read_mostly flexpriority_enabled = 1; module_param_named(flexpriority, flexpriority_enabled, bool, S_IRUGO); static bool __read_mostly enable_ept = 1; module_param_named(ept, enable_ept, bool, S_IRUGO); static bool __read_mostly enable_unrestricted_guest = 1; module_param_named(unrestricted_guest, enable_unrestricted_guest, bool, S_IRUGO); static bool __read_mostly enable_ept_ad_bits = 1; module_param_named(eptad, enable_ept_ad_bits, bool, S_IRUGO); static bool __read_mostly emulate_invalid_guest_state = true; module_param(emulate_invalid_guest_state, bool, S_IRUGO); static bool __read_mostly vmm_exclusive = 1; module_param(vmm_exclusive, bool, S_IRUGO); static bool __read_mostly fasteoi = 1; module_param(fasteoi, bool, S_IRUGO); static bool __read_mostly enable_apicv = 1; module_param(enable_apicv, bool, S_IRUGO); static bool __read_mostly enable_shadow_vmcs = 1; module_param_named(enable_shadow_vmcs, enable_shadow_vmcs, bool, S_IRUGO); / * If nested=1, nested virtualization is supported, i.e., guests may use * VMX and be a hypervisor for its own guests. If nested=0, guests may not * use VMX instructions. / static bool __read_mostly nested = 0; module_param(nested, bool, S_IRUGO); static u64 __read_mostly host_xss; static bool __read_mostly enable_pml = 1; module_param_named(pml, enable_pml, bool, S_IRUGO); #define KVM_VMX_TSC_MULTIPLIER_MAX 0xffffffffffffffffULL #define KVM_GUEST_CR0_MASK (X86_CR0_NW \| X86_CR0_CD) #define KVM_VM_CR0_ALWAYS_ON_UNRESTRICTED_GUEST (X86_CR0_WP \| X86_CR0_NE) #define KVM_VM_CR0_ALWAYS_ON \ (KVM_VM_CR0_ALWAYS_ON_UNRESTRICTED_GUEST \| X86_CR0_PG \| X86_CR0_PE) #define KVM_CR4_GUEST_OWNED_BITS \ (X86_CR4_PVI \| X86_CR4_DE \| X86_CR4_PCE \| X86_CR4_OSFXSR \ \| X86_CR4_OSXMMEXCPT \| X86_CR4_TSD) #define KVM_PMODE_VM_CR4_ALWAYS_ON (X86_CR4_PAE \| X86_CR4_VMXE) #define KVM_RMODE_VM_CR4_ALWAYS_ON (X86_CR4_VME \| X86_CR4_PAE \| X86_CR4_VMXE) #define RMODE_GUEST_OWNED_EFLAGS_BITS (~(X86_EFLAGS_IOPL \| X86_EFLAGS_VM)) #define VMX_MISC_EMULATED_PREEMPTION_TIMER_RATE 5 / * These 2 parameters are used to config the controls for Pause-Loop Exiting: * ple_gap: upper bound on the amount of time between two successive * executions of PAUSE in a loop. Also indicate if ple enabled. * According to test, this time is usually smaller than 128 cycles. * ple_window: upper bound on the amount of time a guest is allowed to execute * in a PAUSE loop. Tests indicate that most spinlocks are held for * less than 2^12 cycles * Time is measured based on a counter that runs at the same rate as the TSC, * refer SDM volume 3b section 21.6.13 & 22.1.3. / #define KVM_VMX_DEFAULT_PLE_GAP 128 #define KVM_VMX_DEFAULT_PLE_WINDOW 4096 #define KVM_VMX_DEFAULT_PLE_WINDOW_GROW 2 #define KVM_VMX_DEFAULT_PLE_WINDOW_SHRINK 0 #define KVM_VMX_DEFAULT_PLE_WINDOW_MAX \ INT_MAX / KVM_VMX_DEFAULT_PLE_WINDOW_GROW static int ple_gap = KVM_VMX_DEFAULT_PLE_GAP; module_param(ple_gap, int, S_IRUGO); static int ple_window = KVM_VMX_DEFAULT_PLE_WINDOW; module_param(ple_window, int, S_IRUGO); / Default doubles per-vcpu window every exit. / static int ple_window_grow = KVM_VMX_DEFAULT_PLE_WINDOW_GROW; module_param(ple_window_grow, int, S_IRUGO); / Default resets per-vcpu window every exit to ple_window. / static int ple_window_shrink = KVM_VMX_DEFAULT_PLE_WINDOW_SHRINK; module_param(ple_window_shrink, int, S_IRUGO); / Default is to compute the maximum so we can never overflow. / static int ple_window_actual_max = KVM_VMX_DEFAULT_PLE_WINDOW_MAX; static int ple_window_max = KVM_VMX_DEFAULT_PLE_WINDOW_MAX; module_param(ple_window_max, int, S_IRUGO); extern const ulong vmx_return; #define NR_AUTOLOAD_MSRS 8 #define VMCS02_POOL_SIZE 1 struct vmcs { u32 revision_id; u32 abort; char data[0]; }; / * Track a VMCS that may be loaded on a certain CPU. If it is (cpu!=-1), also * remember whether it was VMLAUNCHed, and maintain a linked list of all VMCSs * loaded on this CPU (so we can clear them if the CPU goes down). / struct loaded_vmcs { struct vmcs vmcs; int cpu; int launched; struct list_head loaded_vmcss_on_cpu_link; }; struct shared_msr_entry { unsigned index; u64 data; u64 mask; }; /* * struct vmcs12 describes the state that our guest hypervisor (L1) keeps for a * single nested guest (L2), hence the name vmcs12. Any VMX implementation has * a VMCS structure, and vmcs12 is our emulated VMX's VMCS. This structure is * stored in guest memory specified by VMPTRLD, but is opaque to the guest, * which must access it using VMREAD/VMWRITE/VMCLEAR instructions. * More than one of these structures may exist, if L1 runs multiple L2 guests. * nested_vmx_run() will use the data here to build a vmcs02: a VMCS for the * underlying hardware which will be used to run L2. * This structure is packed to ensure that its layout is identical across * machines (necessary for live migration). * If there are changes in this struct, VMCS12_REVISION must be changed. / typedef u64 natural_width; struct __packed vmcs12 { / According to the Intel spec, a VMCS region must start with the * following two fields. Then follow implementation-specific data. / u32 revision_id; u32 abort; u32 launch_state; / set to 0 by VMCLEAR, to 1 by VMLAUNCH / u32 padding[7]; / room for future expansion / u64 io_bitmap_a; u64 io_bitmap_b; u64 msr_bitmap; u64 vm_exit_msr_store_addr; u64 vm_exit_msr_load_addr; u64 vm_entry_msr_load_addr; u64 tsc_offset; u64 virtual_apic_page_addr; u64 apic_access_addr; u64 posted_intr_desc_addr; u64 ept_pointer; u64 eoi_exit_bitmap0; u64 eoi_exit_bitmap1; u64 eoi_exit_bitmap2; u64 eoi_exit_bitmap3; u64 xss_exit_bitmap; u64 guest_physical_address; u64 vmcs_link_pointer; u64 guest_ia32_debugctl; u64 guest_ia32_pat; u64 guest_ia32_efer; u64 guest_ia32_perf_global_ctrl; u64 guest_pdptr0; u64 guest_pdptr1; u64 guest_pdptr2; u64 guest_pdptr3; u64 guest_bndcfgs; u64 host_ia32_pat; u64 host_ia32_efer; u64 host_ia32_perf_global_ctrl; u64 padding64[8]; / room for future expansion / / * To allow migration of L1 (complete with its L2 guests) between * machines of different natural widths (32 or 64 bit), we cannot have * unsigned long fields with no explict size. We use u64 (aliased * natural_width) instead. Luckily, x86 is little-endian. / natural_width cr0_guest_host_mask; natural_width cr4_guest_host_mask; natural_width cr0_read_shadow; natural_width cr4_read_shadow; natural_width cr3_target_value0; natural_width cr3_target_value1; natural_width cr3_target_value2; natural_width cr3_target_value3; natural_width exit_qualification; natural_width guest_linear_address; natural_width guest_cr0; natural_width guest_cr3; natural_width guest_cr4; natural_width guest_es_base; natural_width guest_cs_base; natural_width guest_ss_base; natural_width guest_ds_base; natural_width guest_fs_base; natural_width guest_gs_base; natural_width guest_ldtr_base; natural_width guest_tr_base; natural_width guest_gdtr_base; natural_width guest_idtr_base; natural_width guest_dr7; natural_width guest_rsp; natural_width guest_rip; natural_width guest_rflags; natural_width guest_pending_dbg_exceptions; natural_width guest_sysenter_esp; natural_width guest_sysenter_eip; natural_width host_cr0; natural_width host_cr3; natural_width host_cr4; natural_width host_fs_base; natural_width host_gs_base; natural_width host_tr_base; natural_width host_gdtr_base; natural_width host_idtr_base; natural_width host_ia32_sysenter_esp; natural_width host_ia32_sysenter_eip; natural_width host_rsp; natural_width host_rip; natural_width paddingl[8]; / room for future expansion / u32 pin_based_vm_exec_control; u32 cpu_based_vm_exec_control; u32 exception_bitmap; u32 page_fault_error_code_mask; u32 page_fault_error_code_match; u32 cr3_target_count; u32 vm_exit_controls; u32 vm_exit_msr_store_count; u32 vm_exit_msr_load_count; u32 vm_entry_controls; u32 vm_entry_msr_load_count; u32 vm_entry_intr_info_field; u32 vm_entry_exception_error_code; u32 vm_entry_instruction_len; u32 tpr_threshold; u32 secondary_vm_exec_control; u32 vm_instruction_error; u32 vm_exit_reason; u32 vm_exit_intr_info; u32 vm_exit_intr_error_code; u32 idt_vectoring_info_field; u32 idt_vectoring_error_code; u32 vm_exit_instruction_len; u32 vmx_instruction_info; u32 guest_es_limit; u32 guest_cs_limit; u32 guest_ss_limit; u32 guest_ds_limit; u32 guest_fs_limit; u32 guest_gs_limit; u32 guest_ldtr_limit; u32 guest_tr_limit; u32 guest_gdtr_limit; u32 guest_idtr_limit; u32 guest_es_ar_bytes; u32 guest_cs_ar_bytes; u32 guest_ss_ar_bytes; u32 guest_ds_ar_bytes; u32 guest_fs_ar_bytes; u32 guest_gs_ar_bytes; u32 guest_ldtr_ar_bytes; u32 guest_tr_ar_bytes; u32 guest_interruptibility_info; u32 guest_activity_state; u32 guest_sysenter_cs; u32 host_ia32_sysenter_cs; u32 vmx_preemption_timer_value; u32 padding32[7]; / room for future expansion / u16 virtual_processor_id; u16 posted_intr_nv; u16 guest_es_selector; u16 guest_cs_selector; u16 guest_ss_selector; u16 guest_ds_selector; u16 guest_fs_selector; u16 guest_gs_selector; u16 guest_ldtr_selector; u16 guest_tr_selector; u16 guest_intr_status; u16 host_es_selector; u16 host_cs_selector; u16 host_ss_selector; u16 host_ds_selector; u16 host_fs_selector; u16 host_gs_selector; u16 host_tr_selector; }; / * VMCS12_REVISION is an arbitrary id that should be changed if the content or * layout of struct vmcs12 is changed. MSR_IA32_VMX_BASIC returns this id, and * VMPTRLD verifies that the VMCS region that L1 is loading contains this id. / #define VMCS12_REVISION 0x11e57ed0 / * VMCS12_SIZE is the number of bytes L1 should allocate for the VMXON region * and any VMCS region. Although only sizeof(struct vmcs12) are used by the * current implementation, 4K are reserved to avoid future complications. / #define VMCS12_SIZE 0x1000 / Used to remember the last vmcs02 used for some recently used vmcs12s / struct vmcs02_list { struct list_head list; gpa_t vmptr; struct loaded_vmcs vmcs02; }; / * The nested_vmx structure is part of vcpu_vmx, and holds information we need * for correct emulation of VMX (i.e., nested VMX) on this vcpu. / struct nested_vmx { / Has the level1 guest done vmxon? / bool vmxon; gpa_t vmxon_ptr; / The guest-physical address of the current VMCS L1 keeps for L2 / gpa_t current_vmptr; / The host-usable pointer to the above / struct page current_vmcs12_page; struct vmcs12 current_vmcs12; struct vmcs current_shadow_vmcs; /* * Indicates if the shadow vmcs must be updated with the * data hold by vmcs12 / bool sync_shadow_vmcs; / vmcs02_list cache of VMCSs recently used to run L2 guests / struct list_head vmcs02_pool; int vmcs02_num; u64 vmcs01_tsc_offset; / L2 must run next, and mustn't decide to exit to L1. / bool nested_run_pending; / * Guest pages referred to in vmcs02 with host-physical pointers, so * we must keep them pinned while L2 runs. / struct page apic_access_page; struct page virtual_apic_page; struct page pi_desc_page; struct pi_desc pi_desc; bool pi_pending; u16 posted_intr_nv; u64 msr_ia32_feature_control; struct hrtimer preemption_timer; bool preemption_timer_expired; / to migrate it to L2 if VM_ENTRY_LOAD_DEBUG_CONTROLS is off / u64 vmcs01_debugctl; u16 vpid02; u16 last_vpid; u32 nested_vmx_procbased_ctls_low; u32 nested_vmx_procbased_ctls_high; u32 nested_vmx_true_procbased_ctls_low; u32 nested_vmx_secondary_ctls_low; u32 nested_vmx_secondary_ctls_high; u32 nested_vmx_pinbased_ctls_low; u32 nested_vmx_pinbased_ctls_high; u32 nested_vmx_exit_ctls_low; u32 nested_vmx_exit_ctls_high; u32 nested_vmx_true_exit_ctls_low; u32 nested_vmx_entry_ctls_low; u32 nested_vmx_entry_ctls_high; u32 nested_vmx_true_entry_ctls_low; u32 nested_vmx_misc_low; u32 nested_vmx_misc_high; u32 nested_vmx_ept_caps; u32 nested_vmx_vpid_caps; }; #define POSTED_INTR_ON 0 #define POSTED_INTR_SN 1 / Posted-Interrupt Descriptor / struct pi_desc { u32 pir[8]; / Posted interrupt requested / union { struct { / bit 256 - Outstanding Notification / u16 on : 1, / bit 257 - Suppress Notification / sn : 1, / bit 271:258 - Reserved / rsvd_1 : 14; / bit 279:272 - Notification Vector / u8 nv; / bit 287:280 - Reserved / u8 rsvd_2; / bit 319:288 - Notification Destination / u32 ndst; }; u64 control; }; u32 rsvd[6]; } __aligned(64); static bool pi_test_and_set_on(struct pi_desc pi_desc) { return test_and_set_bit(POSTED_INTR_ON, (unsigned long )&pi_desc->control); } static bool pi_test_and_clear_on(struct pi_desc pi_desc) { return test_and_clear_bit(POSTED_INTR_ON, (unsigned long )&pi_desc->control); } static int pi_test_and_set_pir(int vector, struct pi_desc pi_desc) { return test_and_set_bit(vector, (unsigned long )pi_desc->pir); } static inline void pi_clear_sn(struct pi_desc pi_desc) { return clear_bit(POSTED_INTR_SN, (unsigned long )&pi_desc->control); } static inline void pi_set_sn(struct pi_desc pi_desc) { return set_bit(POSTED_INTR_SN, (unsigned long )&pi_desc->control); } static inline int pi_test_on(struct pi_desc pi_desc) { return test_bit(POSTED_INTR_ON, (unsigned long )&pi_desc->control); } static inline int pi_test_sn(struct pi_desc pi_desc) { return test_bit(POSTED_INTR_SN, (unsigned long )&pi_desc->control); } struct vcpu_vmx { struct kvm_vcpu vcpu; unsigned long host_rsp; u8 fail; bool nmi_known_unmasked; u32 exit_intr_info; u32 idt_vectoring_info; ulong rflags; struct shared_msr_entry guest_msrs; int nmsrs; int save_nmsrs; unsigned long host_idt_base; #ifdef CONFIG_X86_64 u64 msr_host_kernel_gs_base; u64 msr_guest_kernel_gs_base; #endif u32 vm_entry_controls_shadow; u32 vm_exit_controls_shadow; /* * loaded_vmcs points to the VMCS currently used in this vcpu. For a * non-nested (L1) guest, it always points to vmcs01. For a nested * guest (L2), it points to a different VMCS. / struct loaded_vmcs vmcs01; struct loaded_vmcs loaded_vmcs; bool __launched; /* temporary, used in vmx_vcpu_run / struct msr_autoload { unsigned nr; struct vmx_msr_entry guest[NR_AUTOLOAD_MSRS]; struct vmx_msr_entry host[NR_AUTOLOAD_MSRS]; } msr_autoload; struct { int loaded; u16 fs_sel, gs_sel, ldt_sel; #ifdef CONFIG_X86_64 u16 ds_sel, es_sel; #endif int gs_ldt_reload_needed; int fs_reload_needed; u64 msr_host_bndcfgs; unsigned long vmcs_host_cr4; / May not match real cr4 / } host_state; struct { int vm86_active; ulong save_rflags; struct kvm_segment segs[8]; } rmode; struct { u32 bitmask; / 4 bits per segment (1 bit per field) / struct kvm_save_segment { u16 selector; unsigned long base; u32 limit; u32 ar; } seg[8]; } segment_cache; int vpid; bool emulation_required; / Support for vnmi-less CPUs / int soft_vnmi_blocked; ktime_t entry_time; s64 vnmi_blocked_time; u32 exit_reason; / Posted interrupt descriptor / struct pi_desc pi_desc; / Support for a guest hypervisor (nested VMX) / struct nested_vmx nested; / Dynamic PLE window. / int ple_window; bool ple_window_dirty; / Support for PML / #define PML_ENTITY_NUM 512 struct page pml_pg; u64 current_tsc_ratio; bool guest_pkru_valid; u32 guest_pkru; u32 host_pkru; }; enum segment_cache_field { SEG_FIELD_SEL = 0, SEG_FIELD_BASE = 1, SEG_FIELD_LIMIT = 2, SEG_FIELD_AR = 3, SEG_FIELD_NR = 4 }; static inline struct vcpu_vmx to_vmx(struct kvm_vcpu vcpu) { return container_of(vcpu, struct vcpu_vmx, vcpu); } static struct pi_desc vcpu_to_pi_desc(struct kvm_vcpu vcpu) { return &(to_vmx(vcpu)->pi_desc); } #define VMCS12_OFFSET(x) offsetof(struct vmcs12, x) #define FIELD(number, name) [number] = VMCS12_OFFSET(name) #define FIELD64(number, name) [number] = VMCS12_OFFSET(name), \ [number##_HIGH] = VMCS12_OFFSET(name)+4 static unsigned long shadow_read_only_fields[] = { /* * We do NOT shadow fields that are modified when L0 * traps and emulates any vmx instruction (e.g. VMPTRLD, * VMXON...) executed by L1. * For example, VM_INSTRUCTION_ERROR is read * by L1 if a vmx instruction fails (part of the error path). * Note the code assumes this logic. If for some reason * we start shadowing these fields then we need to * force a shadow sync when L0 emulates vmx instructions * (e.g. force a sync if VM_INSTRUCTION_ERROR is modified * by nested_vmx_failValid) / VM_EXIT_REASON, VM_EXIT_INTR_INFO, VM_EXIT_INSTRUCTION_LEN, IDT_VECTORING_INFO_FIELD, IDT_VECTORING_ERROR_CODE, VM_EXIT_INTR_ERROR_CODE, EXIT_QUALIFICATION, GUEST_LINEAR_ADDRESS, GUEST_PHYSICAL_ADDRESS }; static int max_shadow_read_only_fields = ARRAY_SIZE(shadow_read_only_fields); static unsigned long shadow_read_write_fields[] = { TPR_THRESHOLD, GUEST_RIP, GUEST_RSP, GUEST_CR0, GUEST_CR3, GUEST_CR4, GUEST_INTERRUPTIBILITY_INFO, GUEST_RFLAGS, GUEST_CS_SELECTOR, GUEST_CS_AR_BYTES, GUEST_CS_LIMIT, GUEST_CS_BASE, GUEST_ES_BASE, GUEST_BNDCFGS, CR0_GUEST_HOST_MASK, CR0_READ_SHADOW, CR4_READ_SHADOW, TSC_OFFSET, EXCEPTION_BITMAP, CPU_BASED_VM_EXEC_CONTROL, VM_ENTRY_EXCEPTION_ERROR_CODE, VM_ENTRY_INTR_INFO_FIELD, VM_ENTRY_INSTRUCTION_LEN, VM_ENTRY_EXCEPTION_ERROR_CODE, HOST_FS_BASE, HOST_GS_BASE, HOST_FS_SELECTOR, HOST_GS_SELECTOR }; static int max_shadow_read_write_fields = ARRAY_SIZE(shadow_read_write_fields); static const unsigned short vmcs_field_to_offset_table[] = { FIELD(VIRTUAL_PROCESSOR_ID, virtual_processor_id), FIELD(POSTED_INTR_NV, posted_intr_nv), FIELD(GUEST_ES_SELECTOR, guest_es_selector), FIELD(GUEST_CS_SELECTOR, guest_cs_selector), FIELD(GUEST_SS_SELECTOR, guest_ss_selector), FIELD(GUEST_DS_SELECTOR, guest_ds_selector), FIELD(GUEST_FS_SELECTOR, guest_fs_selector), FIELD(GUEST_GS_SELECTOR, guest_gs_selector), FIELD(GUEST_LDTR_SELECTOR, guest_ldtr_selector), FIELD(GUEST_TR_SELECTOR, guest_tr_selector), FIELD(GUEST_INTR_STATUS, guest_intr_status), FIELD(HOST_ES_SELECTOR, host_es_selector), FIELD(HOST_CS_SELECTOR, host_cs_selector), FIELD(HOST_SS_SELECTOR, host_ss_selector), FIELD(HOST_DS_SELECTOR, host_ds_selector), FIELD(HOST_FS_SELECTOR, host_fs_selector), FIELD(HOST_GS_SELECTOR, host_gs_selector), FIELD(HOST_TR_SELECTOR, host_tr_selector), FIELD64(IO_BITMAP_A, io_bitmap_a), FIELD64(IO_BITMAP_B, io_bitmap_b), FIELD64(MSR_BITMAP, msr_bitmap), FIELD64(VM_EXIT_MSR_STORE_ADDR, vm_exit_msr_store_addr), FIELD64(VM_EXIT_MSR_LOAD_ADDR, vm_exit_msr_load_addr), FIELD64(VM_ENTRY_MSR_LOAD_ADDR, vm_entry_msr_load_addr), FIELD64(TSC_OFFSET, tsc_offset), FIELD64(VIRTUAL_APIC_PAGE_ADDR, virtual_apic_page_addr), FIELD64(APIC_ACCESS_ADDR, apic_access_addr), FIELD64(POSTED_INTR_DESC_ADDR, posted_intr_desc_addr), FIELD64(EPT_POINTER, ept_pointer), FIELD64(EOI_EXIT_BITMAP0, eoi_exit_bitmap0), FIELD64(EOI_EXIT_BITMAP1, eoi_exit_bitmap1), FIELD64(EOI_EXIT_BITMAP2, eoi_exit_bitmap2), FIELD64(EOI_EXIT_BITMAP3, eoi_exit_bitmap3), FIELD64(XSS_EXIT_BITMAP, xss_exit_bitmap), FIELD64(GUEST_PHYSICAL_ADDRESS, guest_physical_address), FIELD64(VMCS_LINK_POINTER, vmcs_link_pointer), FIELD64(GUEST_IA32_DEBUGCTL, guest_ia32_debugctl), FIELD64(GUEST_IA32_PAT, guest_ia32_pat), FIELD64(GUEST_IA32_EFER, guest_ia32_efer), FIELD64(GUEST_IA32_PERF_GLOBAL_CTRL, guest_ia32_perf_global_ctrl), FIELD64(GUEST_PDPTR0, guest_pdptr0), FIELD64(GUEST_PDPTR1, guest_pdptr1), FIELD64(GUEST_PDPTR2, guest_pdptr2), FIELD64(GUEST_PDPTR3, guest_pdptr3), FIELD64(GUEST_BNDCFGS, guest_bndcfgs), FIELD64(HOST_IA32_PAT, host_ia32_pat), FIELD64(HOST_IA32_EFER, host_ia32_efer), FIELD64(HOST_IA32_PERF_GLOBAL_CTRL, host_ia32_perf_global_ctrl), FIELD(PIN_BASED_VM_EXEC_CONTROL, pin_based_vm_exec_control), FIELD(CPU_BASED_VM_EXEC_CONTROL, cpu_based_vm_exec_control), FIELD(EXCEPTION_BITMAP, exception_bitmap), FIELD(PAGE_FAULT_ERROR_CODE_MASK, page_fault_error_code_mask), FIELD(PAGE_FAULT_ERROR_CODE_MATCH, page_fault_error_code_match), FIELD(CR3_TARGET_COUNT, cr3_target_count), FIELD(VM_EXIT_CONTROLS, vm_exit_controls), FIELD(VM_EXIT_MSR_STORE_COUNT, vm_exit_msr_store_count), FIELD(VM_EXIT_MSR_LOAD_COUNT, vm_exit_msr_load_count), FIELD(VM_ENTRY_CONTROLS, vm_entry_controls), FIELD(VM_ENTRY_MSR_LOAD_COUNT, vm_entry_msr_load_count), FIELD(VM_ENTRY_INTR_INFO_FIELD, vm_entry_intr_info_field), FIELD(VM_ENTRY_EXCEPTION_ERROR_CODE, vm_entry_exception_error_code), FIELD(VM_ENTRY_INSTRUCTION_LEN, vm_entry_instruction_len), FIELD(TPR_THRESHOLD, tpr_threshold), FIELD(SECONDARY_VM_EXEC_CONTROL, secondary_vm_exec_control), FIELD(VM_INSTRUCTION_ERROR, vm_instruction_error), FIELD(VM_EXIT_REASON, vm_exit_reason), FIELD(VM_EXIT_INTR_INFO, vm_exit_intr_info), FIELD(VM_EXIT_INTR_ERROR_CODE, vm_exit_intr_error_code), FIELD(IDT_VECTORING_INFO_FIELD, idt_vectoring_info_field), FIELD(IDT_VECTORING_ERROR_CODE, idt_vectoring_error_code), FIELD(VM_EXIT_INSTRUCTION_LEN, vm_exit_instruction_len), FIELD(VMX_INSTRUCTION_INFO, vmx_instruction_info), FIELD(GUEST_ES_LIMIT, guest_es_limit), FIELD(GUEST_CS_LIMIT, guest_cs_limit), FIELD(GUEST_SS_LIMIT, guest_ss_limit), FIELD(GUEST_DS_LIMIT, guest_ds_limit), FIELD(GUEST_FS_LIMIT, guest_fs_limit), FIELD(GUEST_GS_LIMIT, guest_gs_limit), FIELD(GUEST_LDTR_LIMIT, guest_ldtr_limit), FIELD(GUEST_TR_LIMIT, guest_tr_limit), FIELD(GUEST_GDTR_LIMIT, guest_gdtr_limit), FIELD(GUEST_IDTR_LIMIT, guest_idtr_limit), FIELD(GUEST_ES_AR_BYTES, guest_es_ar_bytes), FIELD(GUEST_CS_AR_BYTES, guest_cs_ar_bytes), FIELD(GUEST_SS_AR_BYTES, guest_ss_ar_bytes), FIELD(GUEST_DS_AR_BYTES, guest_ds_ar_bytes), FIELD(GUEST_FS_AR_BYTES, guest_fs_ar_bytes), FIELD(GUEST_GS_AR_BYTES, guest_gs_ar_bytes), FIELD(GUEST_LDTR_AR_BYTES, guest_ldtr_ar_bytes), FIELD(GUEST_TR_AR_BYTES, guest_tr_ar_bytes), FIELD(GUEST_INTERRUPTIBILITY_INFO, guest_interruptibility_info), FIELD(GUEST_ACTIVITY_STATE, guest_activity_state), FIELD(GUEST_SYSENTER_CS, guest_sysenter_cs), FIELD(HOST_IA32_SYSENTER_CS, host_ia32_sysenter_cs), FIELD(VMX_PREEMPTION_TIMER_VALUE, vmx_preemption_timer_value), FIELD(CR0_GUEST_HOST_MASK, cr0_guest_host_mask), FIELD(CR4_GUEST_HOST_MASK, cr4_guest_host_mask), FIELD(CR0_READ_SHADOW, cr0_read_shadow), FIELD(CR4_READ_SHADOW, cr4_read_shadow), FIELD(CR3_TARGET_VALUE0, cr3_target_value0), FIELD(CR3_TARGET_VALUE1, cr3_target_value1), FIELD(CR3_TARGET_VALUE2, cr3_target_value2), FIELD(CR3_TARGET_VALUE3, cr3_target_value3), FIELD(EXIT_QUALIFICATION, exit_qualification), FIELD(GUEST_LINEAR_ADDRESS, guest_linear_address), FIELD(GUEST_CR0, guest_cr0), FIELD(GUEST_CR3, guest_cr3), FIELD(GUEST_CR4, guest_cr4), FIELD(GUEST_ES_BASE, guest_es_base), FIELD(GUEST_CS_BASE, guest_cs_base), FIELD(GUEST_SS_BASE, guest_ss_base), FIELD(GUEST_DS_BASE, guest_ds_base), FIELD(GUEST_FS_BASE, guest_fs_base), FIELD(GUEST_GS_BASE, guest_gs_base), FIELD(GUEST_LDTR_BASE, guest_ldtr_base), FIELD(GUEST_TR_BASE, guest_tr_base), FIELD(GUEST_GDTR_BASE, guest_gdtr_base), FIELD(GUEST_IDTR_BASE, guest_idtr_base), FIELD(GUEST_DR7, guest_dr7), FIELD(GUEST_RSP, guest_rsp), FIELD(GUEST_RIP, guest_rip), FIELD(GUEST_RFLAGS, guest_rflags), FIELD(GUEST_PENDING_DBG_EXCEPTIONS, guest_pending_dbg_exceptions), FIELD(GUEST_SYSENTER_ESP, guest_sysenter_esp), FIELD(GUEST_SYSENTER_EIP, guest_sysenter_eip), FIELD(HOST_CR0, host_cr0), FIELD(HOST_CR3, host_cr3), FIELD(HOST_CR4, host_cr4), FIELD(HOST_FS_BASE, host_fs_base), FIELD(HOST_GS_BASE, host_gs_base), FIELD(HOST_TR_BASE, host_tr_base), FIELD(HOST_GDTR_BASE, host_gdtr_base), FIELD(HOST_IDTR_BASE, host_idtr_base), FIELD(HOST_IA32_SYSENTER_ESP, host_ia32_sysenter_esp), FIELD(HOST_IA32_SYSENTER_EIP, host_ia32_sysenter_eip), FIELD(HOST_RSP, host_rsp), FIELD(HOST_RIP, host_rip), }; static inline short vmcs_field_to_offset(unsigned long field) { BUILD_BUG_ON(ARRAY_SIZE(vmcs_field_to_offset_table) > SHRT_MAX); if (field >= ARRAY_SIZE(vmcs_field_to_offset_table) \|\| vmcs_field_to_offset_table[field] == 0) return -ENOENT; return vmcs_field_to_offset_table[field]; } static inline struct vmcs12 get_vmcs12(struct kvm_vcpu vcpu) { return to_vmx(vcpu)->nested.current_vmcs12; } static struct page nested_get_page(struct kvm_vcpu vcpu, gpa_t addr) { struct page page = kvm_vcpu_gfn_to_page(vcpu, addr >> PAGE_SHIFT); if (is_error_page(page)) return NULL; return page; } static void nested_release_page(struct page page) { kvm_release_page_dirty(page); } static void nested_release_page_clean(struct page page) { kvm_release_page_clean(page); } static unsigned long nested_ept_get_cr3(struct kvm_vcpu vcpu); static u64 construct_eptp(unsigned long root_hpa); static void kvm_cpu_vmxon(u64 addr); static void kvm_cpu_vmxoff(void); static bool vmx_xsaves_supported(void); static int vmx_set_tss_addr(struct kvm kvm, unsigned int addr); static void vmx_set_segment(struct kvm_vcpu vcpu, struct kvm_segment var, int seg); static void vmx_get_segment(struct kvm_vcpu vcpu, struct kvm_segment var, int seg); static bool guest_state_valid(struct kvm_vcpu vcpu); static u32 vmx_segment_access_rights(struct kvm_segment var); static void copy_vmcs12_to_shadow(struct vcpu_vmx vmx); static void copy_shadow_to_vmcs12(struct vcpu_vmx vmx); static int alloc_identity_pagetable(struct kvm kvm); static DEFINE_PER_CPU(struct vmcs , vmxarea); static DEFINE_PER_CPU(struct vmcs , current_vmcs); / * We maintain a per-CPU linked-list of VMCS loaded on that CPU. This is needed * when a CPU is brought down, and we need to VMCLEAR all VMCSs loaded on it. / static DEFINE_PER_CPU(struct list_head, loaded_vmcss_on_cpu); static DEFINE_PER_CPU(struct desc_ptr, host_gdt); / * We maintian a per-CPU linked-list of vCPU, so in wakeup_handler() we * can find which vCPU should be waken up. / static DEFINE_PER_CPU(struct list_head, blocked_vcpu_on_cpu); static DEFINE_PER_CPU(spinlock_t, blocked_vcpu_on_cpu_lock); static unsigned long vmx_io_bitmap_a; static unsigned long vmx_io_bitmap_b; static unsigned long vmx_msr_bitmap_legacy; static unsigned long vmx_msr_bitmap_longmode; static unsigned long vmx_msr_bitmap_legacy_x2apic; static unsigned long vmx_msr_bitmap_longmode_x2apic; static unsigned long vmx_msr_bitmap_nested; static unsigned long vmx_vmread_bitmap; static unsigned long vmx_vmwrite_bitmap; static bool cpu_has_load_ia32_efer; static bool cpu_has_load_perf_global_ctrl; static DECLARE_BITMAP(vmx_vpid_bitmap, VMX_NR_VPIDS); static DEFINE_SPINLOCK(vmx_vpid_lock); static struct vmcs_config { int size; int order; u32 revision_id; u32 pin_based_exec_ctrl; u32 cpu_based_exec_ctrl; u32 cpu_based_2nd_exec_ctrl; u32 vmexit_ctrl; u32 vmentry_ctrl; } vmcs_config; static struct vmx_capability { u32 ept; u32 vpid; } vmx_capability; #define VMX_SEGMENT_FIELD(seg) \ [VCPU_SREG_##seg] = { \ .selector = GUEST_##seg##_SELECTOR, \ .base = GUEST_##seg##_BASE, \ .limit = GUEST_##seg##_LIMIT, \ .ar_bytes = GUEST_##seg##_AR_BYTES, \ } static const struct kvm_vmx_segment_field { unsigned selector; unsigned base; unsigned limit; unsigned ar_bytes; } kvm_vmx_segment_fields[] = { VMX_SEGMENT_FIELD(CS), VMX_SEGMENT_FIELD(DS), VMX_SEGMENT_FIELD(ES), VMX_SEGMENT_FIELD(FS), VMX_SEGMENT_FIELD(GS), VMX_SEGMENT_FIELD(SS), VMX_SEGMENT_FIELD(TR), VMX_SEGMENT_FIELD(LDTR), }; static u64 host_efer; static void ept_save_pdptrs(struct kvm_vcpu vcpu); / * Keep MSR_STAR at the end, as setup_msrs() will try to optimize it * away by decrementing the array size. / static const u32 vmx_msr_index[] = { #ifdef CONFIG_X86_64 MSR_SYSCALL_MASK, MSR_LSTAR, MSR_CSTAR, #endif MSR_EFER, MSR_TSC_AUX, MSR_STAR, }; static inline bool is_exception_n(u32 intr_info, u8 vector) { return (intr_info & (INTR_INFO_INTR_TYPE_MASK \| INTR_INFO_VECTOR_MASK \| INTR_INFO_VALID_MASK)) == (INTR_TYPE_HARD_EXCEPTION \| vector \| INTR_INFO_VALID_MASK); } static inline bool is_debug(u32 intr_info) { return is_exception_n(intr_info, DB_VECTOR); } static inline bool is_breakpoint(u32 intr_info) { return is_exception_n(intr_info, BP_VECTOR); } static inline bool is_page_fault(u32 intr_info) { return is_exception_n(intr_info, PF_VECTOR); } static inline bool is_no_device(u32 intr_info) { return is_exception_n(intr_info, NM_VECTOR); } static inline bool is_invalid_opcode(u32 intr_info) { return is_exception_n(intr_info, UD_VECTOR); } static inline bool is_external_interrupt(u32 intr_info) { return (intr_info & (INTR_INFO_INTR_TYPE_MASK \| INTR_INFO_VALID_MASK)) == (INTR_TYPE_EXT_INTR \| INTR_INFO_VALID_MASK); } static inline bool is_machine_check(u32 intr_info) { return (intr_info & (INTR_INFO_INTR_TYPE_MASK \| INTR_INFO_VECTOR_MASK \| INTR_INFO_VALID_MASK)) == (INTR_TYPE_HARD_EXCEPTION \| MC_VECTOR \| INTR_INFO_VALID_MASK); } static inline bool cpu_has_vmx_msr_bitmap(void) { return vmcs_config.cpu_based_exec_ctrl & CPU_BASED_USE_MSR_BITMAPS; } static inline bool cpu_has_vmx_tpr_shadow(void) { return vmcs_config.cpu_based_exec_ctrl & CPU_BASED_TPR_SHADOW; } static inline bool cpu_need_tpr_shadow(struct kvm_vcpu vcpu) { return cpu_has_vmx_tpr_shadow() && lapic_in_kernel(vcpu); } static inline bool cpu_has_secondary_exec_ctrls(void) { return vmcs_config.cpu_based_exec_ctrl & CPU_BASED_ACTIVATE_SECONDARY_CONTROLS; } static inline bool cpu_has_vmx_virtualize_apic_accesses(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES; } static inline bool cpu_has_vmx_virtualize_x2apic_mode(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_VIRTUALIZE_X2APIC_MODE; } static inline bool cpu_has_vmx_apic_register_virt(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_APIC_REGISTER_VIRT; } static inline bool cpu_has_vmx_virtual_intr_delivery(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_VIRTUAL_INTR_DELIVERY; } static inline bool cpu_has_vmx_posted_intr(void) { return IS_ENABLED(CONFIG_X86_LOCAL_APIC) && vmcs_config.pin_based_exec_ctrl & PIN_BASED_POSTED_INTR; } static inline bool cpu_has_vmx_apicv(void) { return cpu_has_vmx_apic_register_virt() && cpu_has_vmx_virtual_intr_delivery() && cpu_has_vmx_posted_intr(); } static inline bool cpu_has_vmx_flexpriority(void) { return cpu_has_vmx_tpr_shadow() && cpu_has_vmx_virtualize_apic_accesses(); } static inline bool cpu_has_vmx_ept_execute_only(void) { return vmx_capability.ept & VMX_EPT_EXECUTE_ONLY_BIT; } static inline bool cpu_has_vmx_ept_2m_page(void) { return vmx_capability.ept & VMX_EPT_2MB_PAGE_BIT; } static inline bool cpu_has_vmx_ept_1g_page(void) { return vmx_capability.ept & VMX_EPT_1GB_PAGE_BIT; } static inline bool cpu_has_vmx_ept_4levels(void) { return vmx_capability.ept & VMX_EPT_PAGE_WALK_4_BIT; } static inline bool cpu_has_vmx_ept_ad_bits(void) { return vmx_capability.ept & VMX_EPT_AD_BIT; } static inline bool cpu_has_vmx_invept_context(void) { return vmx_capability.ept & VMX_EPT_EXTENT_CONTEXT_BIT; } static inline bool cpu_has_vmx_invept_global(void) { return vmx_capability.ept & VMX_EPT_EXTENT_GLOBAL_BIT; } static inline bool cpu_has_vmx_invvpid_single(void) { return vmx_capability.vpid & VMX_VPID_EXTENT_SINGLE_CONTEXT_BIT; } static inline bool cpu_has_vmx_invvpid_global(void) { return vmx_capability.vpid & VMX_VPID_EXTENT_GLOBAL_CONTEXT_BIT; } static inline bool cpu_has_vmx_ept(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_ENABLE_EPT; } static inline bool cpu_has_vmx_unrestricted_guest(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_UNRESTRICTED_GUEST; } static inline bool cpu_has_vmx_ple(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_PAUSE_LOOP_EXITING; } static inline bool cpu_need_virtualize_apic_accesses(struct kvm_vcpu vcpu) { return flexpriority_enabled && lapic_in_kernel(vcpu); } static inline bool cpu_has_vmx_vpid(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_ENABLE_VPID; } static inline bool cpu_has_vmx_rdtscp(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_RDTSCP; } static inline bool cpu_has_vmx_invpcid(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_ENABLE_INVPCID; } static inline bool cpu_has_virtual_nmis(void) { return vmcs_config.pin_based_exec_ctrl & PIN_BASED_VIRTUAL_NMIS; } static inline bool cpu_has_vmx_wbinvd_exit(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_WBINVD_EXITING; } static inline bool cpu_has_vmx_shadow_vmcs(void) { u64 vmx_msr; rdmsrl(MSR_IA32_VMX_MISC, vmx_msr); / check if the cpu supports writing r/o exit information fields / if (!(vmx_msr & MSR_IA32_VMX_MISC_VMWRITE_SHADOW_RO_FIELDS)) return false; return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_SHADOW_VMCS; } static inline bool cpu_has_vmx_pml(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_ENABLE_PML; } static inline bool cpu_has_vmx_tsc_scaling(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_TSC_SCALING; } static inline bool report_flexpriority(void) { return flexpriority_enabled; } static inline bool nested_cpu_has(struct vmcs12 vmcs12, u32 bit) { return vmcs12->cpu_based_vm_exec_control & bit; } static inline bool nested_cpu_has2(struct vmcs12 vmcs12, u32 bit) { return (vmcs12->cpu_based_vm_exec_control & CPU_BASED_ACTIVATE_SECONDARY_CONTROLS) && (vmcs12->secondary_vm_exec_control & bit); } static inline bool nested_cpu_has_virtual_nmis(struct vmcs12 vmcs12) { return vmcs12->pin_based_vm_exec_control & PIN_BASED_VIRTUAL_NMIS; } static inline bool nested_cpu_has_preemption_timer(struct vmcs12 vmcs12) { return vmcs12->pin_based_vm_exec_control & PIN_BASED_VMX_PREEMPTION_TIMER; } static inline int nested_cpu_has_ept(struct vmcs12 vmcs12) { return nested_cpu_has2(vmcs12, SECONDARY_EXEC_ENABLE_EPT); } static inline bool nested_cpu_has_xsaves(struct vmcs12 vmcs12) { return nested_cpu_has2(vmcs12, SECONDARY_EXEC_XSAVES) && vmx_xsaves_supported(); } static inline bool nested_cpu_has_virt_x2apic_mode(struct vmcs12 vmcs12) { return nested_cpu_has2(vmcs12, SECONDARY_EXEC_VIRTUALIZE_X2APIC_MODE); } static inline bool nested_cpu_has_vpid(struct vmcs12 vmcs12) { return nested_cpu_has2(vmcs12, SECONDARY_EXEC_ENABLE_VPID); } static inline bool nested_cpu_has_apic_reg_virt(struct vmcs12 vmcs12) { return nested_cpu_has2(vmcs12, SECONDARY_EXEC_APIC_REGISTER_VIRT); } static inline bool nested_cpu_has_vid(struct vmcs12 vmcs12) { return nested_cpu_has2(vmcs12, SECONDARY_EXEC_VIRTUAL_INTR_DELIVERY); } static inline bool nested_cpu_has_posted_intr(struct vmcs12 vmcs12) { return vmcs12->pin_based_vm_exec_control & PIN_BASED_POSTED_INTR; } static inline bool is_exception(u32 intr_info) { return (intr_info & (INTR_INFO_INTR_TYPE_MASK \| INTR_INFO_VALID_MASK)) == (INTR_TYPE_HARD_EXCEPTION \| INTR_INFO_VALID_MASK); } static void nested_vmx_vmexit(struct kvm_vcpu vcpu, u32 exit_reason, u32 exit_intr_info, unsigned long exit_qualification); static void nested_vmx_entry_failure(struct kvm_vcpu vcpu, struct vmcs12 vmcs12, u32 reason, unsigned long qualification); static int __find_msr_index(struct vcpu_vmx vmx, u32 msr) { int i; for (i = 0; i < vmx->nmsrs; ++i) if (vmx_msr_index[vmx->guest_msrs[i].index] == msr) return i; return -1; } static inline void __invvpid(int ext, u16 vpid, gva_t gva) { struct { u64 vpid : 16; u64 rsvd : 48; u64 gva; } operand = { vpid, 0, gva }; asm volatile (__ex(ASM_VMX_INVVPID) /* CF==1 or ZF==1 --> rc = -1 / "; ja 1f ; ud2 ; 1:" : : "a"(&operand), "c"(ext) : "cc", "memory"); } static inline void __invept(int ext, u64 eptp, gpa_t gpa) { struct { u64 eptp, gpa; } operand = {eptp, gpa}; asm volatile (__ex(ASM_VMX_INVEPT) / CF==1 or ZF==1 --> rc = -1 / "; ja 1f ; ud2 ; 1:\n" : : "a" (&operand), "c" (ext) : "cc", "memory"); } static struct shared_msr_entry find_msr_entry(struct vcpu_vmx vmx, u32 msr) { int i; i = __find_msr_index(vmx, msr); if (i >= 0) return &vmx->guest_msrs[i]; return NULL; } static void vmcs_clear(struct vmcs vmcs) { u64 phys_addr = __pa(vmcs); u8 error; asm volatile (__ex(ASM_VMX_VMCLEAR_RAX) "; setna %0" : "=qm"(error) : "a"(&phys_addr), "m"(phys_addr) : "cc", "memory"); if (error) printk(KERN_ERR "kvm: vmclear fail: %p/%llx\n", vmcs, phys_addr); } static inline void loaded_vmcs_init(struct loaded_vmcs loaded_vmcs) { vmcs_clear(loaded_vmcs->vmcs); loaded_vmcs->cpu = -1; loaded_vmcs->launched = 0; } static void vmcs_load(struct vmcs vmcs) { u64 phys_addr = __pa(vmcs); u8 error; asm volatile (__ex(ASM_VMX_VMPTRLD_RAX) "; setna %0" : "=qm"(error) : "a"(&phys_addr), "m"(phys_addr) : "cc", "memory"); if (error) printk(KERN_ERR "kvm: vmptrld %p/%llx failed\n", vmcs, phys_addr); } #ifdef CONFIG_KEXEC_CORE /* * This bitmap is used to indicate whether the vmclear * operation is enabled on all cpus. All disabled by * default. / static cpumask_t crash_vmclear_enabled_bitmap = CPU_MASK_NONE; static inline void crash_enable_local_vmclear(int cpu) { cpumask_set_cpu(cpu, &crash_vmclear_enabled_bitmap); } static inline void crash_disable_local_vmclear(int cpu) { cpumask_clear_cpu(cpu, &crash_vmclear_enabled_bitmap); } static inline int crash_local_vmclear_enabled(int cpu) { return cpumask_test_cpu(cpu, &crash_vmclear_enabled_bitmap); } static void crash_vmclear_local_loaded_vmcss(void) { int cpu = raw_smp_processor_id(); struct loaded_vmcs v; if (!crash_local_vmclear_enabled(cpu)) return; list_for_each_entry(v, &per_cpu(loaded_vmcss_on_cpu, cpu), loaded_vmcss_on_cpu_link) vmcs_clear(v->vmcs); } #else static inline void crash_enable_local_vmclear(int cpu) { } static inline void crash_disable_local_vmclear(int cpu) { } #endif /* CONFIG_KEXEC_CORE / static void __loaded_vmcs_clear(void arg) { struct loaded_vmcs loaded_vmcs = arg; int cpu = raw_smp_processor_id(); if (loaded_vmcs->cpu != cpu) return; / vcpu migration can race with cpu offline / if (per_cpu(current_vmcs, cpu) == loaded_vmcs->vmcs) per_cpu(current_vmcs, cpu) = NULL; crash_disable_local_vmclear(cpu); list_del(&loaded_vmcs->loaded_vmcss_on_cpu_link); / * we should ensure updating loaded_vmcs->loaded_vmcss_on_cpu_link * is before setting loaded_vmcs->vcpu to -1 which is done in * loaded_vmcs_init. Otherwise, other cpu can see vcpu = -1 fist * then adds the vmcs into percpu list before it is deleted. / smp_wmb(); loaded_vmcs_init(loaded_vmcs); crash_enable_local_vmclear(cpu); } static void loaded_vmcs_clear(struct loaded_vmcs loaded_vmcs) { int cpu = loaded_vmcs->cpu; if (cpu != -1) smp_call_function_single(cpu, __loaded_vmcs_clear, loaded_vmcs, 1); } static inline void vpid_sync_vcpu_single(int vpid) { if (vpid == 0) return; if (cpu_has_vmx_invvpid_single()) __invvpid(VMX_VPID_EXTENT_SINGLE_CONTEXT, vpid, 0); } static inline void vpid_sync_vcpu_global(void) { if (cpu_has_vmx_invvpid_global()) __invvpid(VMX_VPID_EXTENT_ALL_CONTEXT, 0, 0); } static inline void vpid_sync_context(int vpid) { if (cpu_has_vmx_invvpid_single()) vpid_sync_vcpu_single(vpid); else vpid_sync_vcpu_global(); } static inline void ept_sync_global(void) { if (cpu_has_vmx_invept_global()) __invept(VMX_EPT_EXTENT_GLOBAL, 0, 0); } static inline void ept_sync_context(u64 eptp) { if (enable_ept) { if (cpu_has_vmx_invept_context()) __invept(VMX_EPT_EXTENT_CONTEXT, eptp, 0); else ept_sync_global(); } } static __always_inline void vmcs_check16(unsigned long field) { BUILD_BUG_ON_MSG(__builtin_constant_p(field) && ((field) & 0x6001) == 0x2000, "16-bit accessor invalid for 64-bit field"); BUILD_BUG_ON_MSG(__builtin_constant_p(field) && ((field) & 0x6001) == 0x2001, "16-bit accessor invalid for 64-bit high field"); BUILD_BUG_ON_MSG(__builtin_constant_p(field) && ((field) & 0x6000) == 0x4000, "16-bit accessor invalid for 32-bit high field"); BUILD_BUG_ON_MSG(__builtin_constant_p(field) && ((field) & 0x6000) == 0x6000, "16-bit accessor invalid for natural width field"); } static __always_inline void vmcs_check32(unsigned long field) { BUILD_BUG_ON_MSG(__builtin_constant_p(field) && ((field) & 0x6000) == 0, "32-bit accessor invalid for 16-bit field"); BUILD_BUG_ON_MSG(__builtin_constant_p(field) && ((field) & 0x6000) == 0x6000, "32-bit accessor invalid for natural width field"); } static __always_inline void vmcs_check64(unsigned long field) { BUILD_BUG_ON_MSG(__builtin_constant_p(field) && ((field) & 0x6000) == 0, "64-bit accessor invalid for 16-bit field"); BUILD_BUG_ON_MSG(__builtin_constant_p(field) && ((field) & 0x6001) == 0x2001, "64-bit accessor invalid for 64-bit high field"); BUILD_BUG_ON_MSG(__builtin_constant_p(field) && ((field) & 0x6000) == 0x4000, "64-bit accessor invalid for 32-bit field"); BUILD_BUG_ON_MSG(__builtin_constant_p(field) && ((field) & 0x6000) == 0x6000, "64-bit accessor invalid for natural width field"); } static __always_inline void vmcs_checkl(unsigned long field) { BUILD_BUG_ON_MSG(__builtin_constant_p(field) && ((field) & 0x6000) == 0, "Natural width accessor invalid for 16-bit field"); BUILD_BUG_ON_MSG(__builtin_constant_p(field) && ((field) & 0x6001) == 0x2000, "Natural width accessor invalid for 64-bit field"); BUILD_BUG_ON_MSG(__builtin_constant_p(field) && ((field) & 0x6001) == 0x2001, "Natural width accessor invalid for 64-bit high field"); BUILD_BUG_ON_MSG(__builtin_constant_p(field) && ((field) & 0x6000) == 0x4000, "Natural width accessor invalid for 32-bit field"); } static __always_inline unsigned long __vmcs_readl(unsigned long field) { unsigned long value; asm volatile (__ex_clear(ASM_VMX_VMREAD_RDX_RAX, "%0") : "=a"(value) : "d"(field) : "cc"); return value; } static __always_inline u16 vmcs_read16(unsigned long field) { vmcs_check16(field); return __vmcs_readl(field); } static __always_inline u32 vmcs_read32(unsigned long field) { vmcs_check32(field); return __vmcs_readl(field); } static __always_inline u64 vmcs_read64(unsigned long field) { vmcs_check64(field); #ifdef CONFIG_X86_64 return __vmcs_readl(field); #else return __vmcs_readl(field) \| ((u64)__vmcs_readl(field+1) << 32); #endif } static __always_inline unsigned long vmcs_readl(unsigned long field) { vmcs_checkl(field); return __vmcs_readl(field); } static noinline void vmwrite_error(unsigned long field, unsigned long value) { printk(KERN_ERR "vmwrite error: reg %lx value %lx (err %d)\n", field, value, vmcs_read32(VM_INSTRUCTION_ERROR)); dump_stack(); } static __always_inline void __vmcs_writel(unsigned long field, unsigned long value) { u8 error; asm volatile (__ex(ASM_VMX_VMWRITE_RAX_RDX) "; setna %0" : "=q"(error) : "a"(value), "d"(field) : "cc"); if (unlikely(error)) vmwrite_error(field, value); } static __always_inline void vmcs_write16(unsigned long field, u16 value) { vmcs_check16(field); __vmcs_writel(field, value); } static __always_inline void vmcs_write32(unsigned long field, u32 value) { vmcs_check32(field); __vmcs_writel(field, value); } static __always_inline void vmcs_write64(unsigned long field, u64 value) { vmcs_check64(field); __vmcs_writel(field, value); #ifndef CONFIG_X86_64 asm volatile (""); __vmcs_writel(field+1, value >> 32); #endif } static __always_inline void vmcs_writel(unsigned long field, unsigned long value) { vmcs_checkl(field); __vmcs_writel(field, value); } static __always_inline void vmcs_clear_bits(unsigned long field, u32 mask) { BUILD_BUG_ON_MSG(__builtin_constant_p(field) && ((field) & 0x6000) == 0x2000, "vmcs_clear_bits does not support 64-bit fields"); __vmcs_writel(field, __vmcs_readl(field) & ~mask); } static __always_inline void vmcs_set_bits(unsigned long field, u32 mask) { BUILD_BUG_ON_MSG(__builtin_constant_p(field) && ((field) & 0x6000) == 0x2000, "vmcs_set_bits does not support 64-bit fields"); __vmcs_writel(field, __vmcs_readl(field) \| mask); } static inline void vm_entry_controls_init(struct vcpu_vmx vmx, u32 val) { vmcs_write32(VM_ENTRY_CONTROLS, val); vmx->vm_entry_controls_shadow = val; } static inline void vm_entry_controls_set(struct vcpu_vmx vmx, u32 val) { if (vmx->vm_entry_controls_shadow != val) vm_entry_controls_init(vmx, val); } static inline u32 vm_entry_controls_get(struct vcpu_vmx vmx) { return vmx->vm_entry_controls_shadow; } static inline void vm_entry_controls_setbit(struct vcpu_vmx vmx, u32 val) { vm_entry_controls_set(vmx, vm_entry_controls_get(vmx) \| val); } static inline void vm_entry_controls_clearbit(struct vcpu_vmx vmx, u32 val) { vm_entry_controls_set(vmx, vm_entry_controls_get(vmx) & ~val); } static inline void vm_exit_controls_init(struct vcpu_vmx vmx, u32 val) { vmcs_write32(VM_EXIT_CONTROLS, val); vmx->vm_exit_controls_shadow = val; } static inline void vm_exit_controls_set(struct vcpu_vmx vmx, u32 val) { if (vmx->vm_exit_controls_shadow != val) vm_exit_controls_init(vmx, val); } static inline u32 vm_exit_controls_get(struct vcpu_vmx vmx) { return vmx->vm_exit_controls_shadow; } static inline void vm_exit_controls_setbit(struct vcpu_vmx vmx, u32 val) { vm_exit_controls_set(vmx, vm_exit_controls_get(vmx) \| val); } static inline void vm_exit_controls_clearbit(struct vcpu_vmx vmx, u32 val) { vm_exit_controls_set(vmx, vm_exit_controls_get(vmx) & ~val); } static void vmx_segment_cache_clear(struct vcpu_vmx vmx) { vmx->segment_cache.bitmask = 0; } static bool vmx_segment_cache_test_set(struct vcpu_vmx vmx, unsigned seg, unsigned field) { bool ret; u32 mask = 1 << (seg * SEG_FIELD_NR + field); if (!(vmx->vcpu.arch.regs_avail & (1 << VCPU_EXREG_SEGMENTS))) { vmx->vcpu.arch.regs_avail \|= (1 << VCPU_EXREG_SEGMENTS); vmx->segment_cache.bitmask = 0; } ret = vmx->segment_cache.bitmask & mask; vmx->segment_cache.bitmask \|= mask; return ret; } static u16 vmx_read_guest_seg_selector(struct vcpu_vmx vmx, unsigned seg) { u16 p = &vmx->segment_cache.seg[seg].selector; if (!vmx_segment_cache_test_set(vmx, seg, SEG_FIELD_SEL)) p = vmcs_read16(kvm_vmx_segment_fields[seg].selector); return p; } static ulong vmx_read_guest_seg_base(struct vcpu_vmx vmx, unsigned seg) { ulong p = &vmx->segment_cache.seg[seg].base; if (!vmx_segment_cache_test_set(vmx, seg, SEG_FIELD_BASE)) p = vmcs_readl(kvm_vmx_segment_fields[seg].base); return p; } static u32 vmx_read_guest_seg_limit(struct vcpu_vmx vmx, unsigned seg) { u32 p = &vmx->segment_cache.seg[seg].limit; if (!vmx_segment_cache_test_set(vmx, seg, SEG_FIELD_LIMIT)) p = vmcs_read32(kvm_vmx_segment_fields[seg].limit); return p; } static u32 vmx_read_guest_seg_ar(struct vcpu_vmx vmx, unsigned seg) { u32 p = &vmx->segment_cache.seg[seg].ar; if (!vmx_segment_cache_test_set(vmx, seg, SEG_FIELD_AR)) p = vmcs_read32(kvm_vmx_segment_fields[seg].ar_bytes); return p; } static void update_exception_bitmap(struct kvm_vcpu vcpu) { u32 eb; eb = (1u << PF_VECTOR) \| (1u << UD_VECTOR) \| (1u << MC_VECTOR) \| (1u << NM_VECTOR) \| (1u << DB_VECTOR) \| (1u << AC_VECTOR); if ((vcpu->guest_debug & (KVM_GUESTDBG_ENABLE \| KVM_GUESTDBG_USE_SW_BP)) == (KVM_GUESTDBG_ENABLE \| KVM_GUESTDBG_USE_SW_BP)) eb \|= 1u << BP_VECTOR; if (to_vmx(vcpu)->rmode.vm86_active) eb = ~0; if (enable_ept) eb &= ~(1u << PF_VECTOR); / bypass_guest_pf = 0 / if (vcpu->fpu_active) eb &= ~(1u << NM_VECTOR); / When we are running a nested L2 guest and L1 specified for it a * certain exception bitmap, we must trap the same exceptions and pass * them to L1. When running L2, we will only handle the exceptions * specified above if L1 did not want them. / if (is_guest_mode(vcpu)) eb \|= get_vmcs12(vcpu)->exception_bitmap; vmcs_write32(EXCEPTION_BITMAP, eb); } static void clear_atomic_switch_msr_special(struct vcpu_vmx vmx, unsigned long entry, unsigned long exit) { vm_entry_controls_clearbit(vmx, entry); vm_exit_controls_clearbit(vmx, exit); } static void clear_atomic_switch_msr(struct vcpu_vmx vmx, unsigned msr) { unsigned i; struct msr_autoload m = &vmx->msr_autoload; switch (msr) { case MSR_EFER: if (cpu_has_load_ia32_efer) { clear_atomic_switch_msr_special(vmx, VM_ENTRY_LOAD_IA32_EFER, VM_EXIT_LOAD_IA32_EFER); return; } break; case MSR_CORE_PERF_GLOBAL_CTRL: if (cpu_has_load_perf_global_ctrl) { clear_atomic_switch_msr_special(vmx, VM_ENTRY_LOAD_IA32_PERF_GLOBAL_CTRL, VM_EXIT_LOAD_IA32_PERF_GLOBAL_CTRL); return; } break; } for (i = 0; i < m->nr; ++i) if (m->guest[i].index == msr) break; if (i == m->nr) return; --m->nr; m->guest[i] = m->guest[m->nr]; m->host[i] = m->host[m->nr]; vmcs_write32(VM_ENTRY_MSR_LOAD_COUNT, m->nr); vmcs_write32(VM_EXIT_MSR_LOAD_COUNT, m->nr); } static void add_atomic_switch_msr_special(struct vcpu_vmx vmx, unsigned long entry, unsigned long exit, unsigned long guest_val_vmcs, unsigned long host_val_vmcs, u64 guest_val, u64 host_val) { vmcs_write64(guest_val_vmcs, guest_val); vmcs_write64(host_val_vmcs, host_val); vm_entry_controls_setbit(vmx, entry); vm_exit_controls_setbit(vmx, exit); } static void add_atomic_switch_msr(struct vcpu_vmx vmx, unsigned msr, u64 guest_val, u64 host_val) { unsigned i; struct msr_autoload m = &vmx->msr_autoload; switch (msr) { case MSR_EFER: if (cpu_has_load_ia32_efer) { add_atomic_switch_msr_special(vmx, VM_ENTRY_LOAD_IA32_EFER, VM_EXIT_LOAD_IA32_EFER, GUEST_IA32_EFER, HOST_IA32_EFER, guest_val, host_val); return; } break; case MSR_CORE_PERF_GLOBAL_CTRL: if (cpu_has_load_perf_global_ctrl) { add_atomic_switch_msr_special(vmx, VM_ENTRY_LOAD_IA32_PERF_GLOBAL_CTRL, VM_EXIT_LOAD_IA32_PERF_GLOBAL_CTRL, GUEST_IA32_PERF_GLOBAL_CTRL, HOST_IA32_PERF_GLOBAL_CTRL, guest_val, host_val); return; } break; case MSR_IA32_PEBS_ENABLE: / PEBS needs a quiescent period after being disabled (to write * a record). Disabling PEBS through VMX MSR swapping doesn't * provide that period, so a CPU could write host's record into * guest's memory. / wrmsrl(MSR_IA32_PEBS_ENABLE, 0); } for (i = 0; i < m->nr; ++i) if (m->guest[i].index == msr) break; if (i == NR_AUTOLOAD_MSRS) { printk_once(KERN_WARNING "Not enough msr switch entries. " "Can't add msr %x\n", msr); return; } else if (i == m->nr) { ++m->nr; vmcs_write32(VM_ENTRY_MSR_LOAD_COUNT, m->nr); vmcs_write32(VM_EXIT_MSR_LOAD_COUNT, m->nr); } m->guest[i].index = msr; m->guest[i].value = guest_val; m->host[i].index = msr; m->host[i].value = host_val; } static void reload_tss(void) { / * VT restores TR but not its size. Useless. / struct desc_ptr gdt = this_cpu_ptr(&host_gdt); struct desc_struct descs; descs = (void )gdt->address; descs[GDT_ENTRY_TSS].type = 9; /* available TSS / load_TR_desc(); } static bool update_transition_efer(struct vcpu_vmx vmx, int efer_offset) { u64 guest_efer = vmx->vcpu.arch.efer; u64 ignore_bits = 0; if (!enable_ept) { /* * NX is needed to handle CR0.WP=1, CR4.SMEP=1. Testing * host CPUID is more efficient than testing guest CPUID * or CR4. Host SMEP is anyway a requirement for guest SMEP. / if (boot_cpu_has(X86_FEATURE_SMEP)) guest_efer \|= EFER_NX; else if (!(guest_efer & EFER_NX)) ignore_bits \|= EFER_NX; } / * LMA and LME handled by hardware; SCE meaningless outside long mode. / ignore_bits \|= EFER_SCE; #ifdef CONFIG_X86_64 ignore_bits \|= EFER_LMA \| EFER_LME; / SCE is meaningful only in long mode on Intel / if (guest_efer & EFER_LMA) ignore_bits &= ~(u64)EFER_SCE; #endif clear_atomic_switch_msr(vmx, MSR_EFER); / * On EPT, we can't emulate NX, so we must switch EFER atomically. * On CPUs that support "load IA32_EFER", always switch EFER * atomically, since it's faster than switching it manually. / if (cpu_has_load_ia32_efer \|\| (enable_ept && ((vmx->vcpu.arch.efer ^ host_efer) & EFER_NX))) { if (!(guest_efer & EFER_LMA)) guest_efer &= ~EFER_LME; if (guest_efer != host_efer) add_atomic_switch_msr(vmx, MSR_EFER, guest_efer, host_efer); return false; } else { guest_efer &= ~ignore_bits; guest_efer \|= host_efer & ignore_bits; vmx->guest_msrs[efer_offset].data = guest_efer; vmx->guest_msrs[efer_offset].mask = ~ignore_bits; return true; } } static unsigned long segment_base(u16 selector) { struct desc_ptr gdt = this_cpu_ptr(&host_gdt); struct desc_struct d; unsigned long table_base; unsigned long v; if (!(selector & ~3)) return 0; table_base = gdt->address; if (selector & 4) { / from ldt / u16 ldt_selector = kvm_read_ldt(); if (!(ldt_selector & ~3)) return 0; table_base = segment_base(ldt_selector); } d = (struct desc_struct )(table_base + (selector & ~7)); v = get_desc_base(d); #ifdef CONFIG_X86_64 if (d->s == 0 && (d->type == 2 \|\| d->type == 9 \|\| d->type == 11)) v \|= ((unsigned long)((struct ldttss_desc64 )d)->base3) << 32; #endif return v; } static inline unsigned long kvm_read_tr_base(void) { u16 tr; asm("str %0" : "=g"(tr)); return segment_base(tr); } static void vmx_save_host_state(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); int i; if (vmx->host_state.loaded) return; vmx->host_state.loaded = 1; / * Set host fs and gs selectors. Unfortunately, 22.2.3 does not * allow segment selectors with cpl > 0 or ti == 1. / vmx->host_state.ldt_sel = kvm_read_ldt(); vmx->host_state.gs_ldt_reload_needed = vmx->host_state.ldt_sel; savesegment(fs, vmx->host_state.fs_sel); if (!(vmx->host_state.fs_sel & 7)) { vmcs_write16(HOST_FS_SELECTOR, vmx->host_state.fs_sel); vmx->host_state.fs_reload_needed = 0; } else { vmcs_write16(HOST_FS_SELECTOR, 0); vmx->host_state.fs_reload_needed = 1; } savesegment(gs, vmx->host_state.gs_sel); if (!(vmx->host_state.gs_sel & 7)) vmcs_write16(HOST_GS_SELECTOR, vmx->host_state.gs_sel); else { vmcs_write16(HOST_GS_SELECTOR, 0); vmx->host_state.gs_ldt_reload_needed = 1; } #ifdef CONFIG_X86_64 savesegment(ds, vmx->host_state.ds_sel); savesegment(es, vmx->host_state.es_sel); #endif #ifdef CONFIG_X86_64 vmcs_writel(HOST_FS_BASE, read_msr(MSR_FS_BASE)); vmcs_writel(HOST_GS_BASE, read_msr(MSR_GS_BASE)); #else vmcs_writel(HOST_FS_BASE, segment_base(vmx->host_state.fs_sel)); vmcs_writel(HOST_GS_BASE, segment_base(vmx->host_state.gs_sel)); #endif #ifdef CONFIG_X86_64 rdmsrl(MSR_KERNEL_GS_BASE, vmx->msr_host_kernel_gs_base); if (is_long_mode(&vmx->vcpu)) wrmsrl(MSR_KERNEL_GS_BASE, vmx->msr_guest_kernel_gs_base); #endif if (boot_cpu_has(X86_FEATURE_MPX)) rdmsrl(MSR_IA32_BNDCFGS, vmx->host_state.msr_host_bndcfgs); for (i = 0; i < vmx->save_nmsrs; ++i) kvm_set_shared_msr(vmx->guest_msrs[i].index, vmx->guest_msrs[i].data, vmx->guest_msrs[i].mask); } static void __vmx_load_host_state(struct vcpu_vmx vmx) { if (!vmx->host_state.loaded) return; ++vmx->vcpu.stat.host_state_reload; vmx->host_state.loaded = 0; #ifdef CONFIG_X86_64 if (is_long_mode(&vmx->vcpu)) rdmsrl(MSR_KERNEL_GS_BASE, vmx->msr_guest_kernel_gs_base); #endif if (vmx->host_state.gs_ldt_reload_needed) { kvm_load_ldt(vmx->host_state.ldt_sel); #ifdef CONFIG_X86_64 load_gs_index(vmx->host_state.gs_sel); #else loadsegment(gs, vmx->host_state.gs_sel); #endif } if (vmx->host_state.fs_reload_needed) loadsegment(fs, vmx->host_state.fs_sel); #ifdef CONFIG_X86_64 if (unlikely(vmx->host_state.ds_sel \| vmx->host_state.es_sel)) { loadsegment(ds, vmx->host_state.ds_sel); loadsegment(es, vmx->host_state.es_sel); } #endif reload_tss(); #ifdef CONFIG_X86_64 wrmsrl(MSR_KERNEL_GS_BASE, vmx->msr_host_kernel_gs_base); #endif if (vmx->host_state.msr_host_bndcfgs) wrmsrl(MSR_IA32_BNDCFGS, vmx->host_state.msr_host_bndcfgs); /* * If the FPU is not active (through the host task or * the guest vcpu), then restore the cr0.TS bit. / if (!fpregs_active() && !vmx->vcpu.guest_fpu_loaded) stts(); load_gdt(this_cpu_ptr(&host_gdt)); } static void vmx_load_host_state(struct vcpu_vmx vmx) { preempt_disable(); __vmx_load_host_state(vmx); preempt_enable(); } static void vmx_vcpu_pi_load(struct kvm_vcpu vcpu, int cpu) { struct pi_desc pi_desc = vcpu_to_pi_desc(vcpu); struct pi_desc old, new; unsigned int dest; if (!kvm_arch_has_assigned_device(vcpu->kvm) \|\| !irq_remapping_cap(IRQ_POSTING_CAP)) return; do { old.control = new.control = pi_desc->control; /* * If 'nv' field is POSTED_INTR_WAKEUP_VECTOR, there * are two possible cases: * 1. After running 'pre_block', context switch * happened. For this case, 'sn' was set in * vmx_vcpu_put(), so we need to clear it here. * 2. After running 'pre_block', we were blocked, * and woken up by some other guy. For this case, * we don't need to do anything, 'pi_post_block' * will do everything for us. However, we cannot * check whether it is case #1 or case #2 here * (maybe, not needed), so we also clear sn here, * I think it is not a big deal. / if (pi_desc->nv != POSTED_INTR_WAKEUP_VECTOR) { if (vcpu->cpu != cpu) { dest = cpu_physical_id(cpu); if (x2apic_enabled()) new.ndst = dest; else new.ndst = (dest << 8) & 0xFF00; } / set 'NV' to 'notification vector' / new.nv = POSTED_INTR_VECTOR; } / Allow posting non-urgent interrupts / new.sn = 0; } while (cmpxchg(&pi_desc->control, old.control, new.control) != old.control); } / * Switches to specified vcpu, until a matching vcpu_put(), but assumes * vcpu mutex is already taken. / static void vmx_vcpu_load(struct kvm_vcpu vcpu, int cpu) { struct vcpu_vmx vmx = to_vmx(vcpu); u64 phys_addr = __pa(per_cpu(vmxarea, cpu)); if (!vmm_exclusive) kvm_cpu_vmxon(phys_addr); else if (vmx->loaded_vmcs->cpu != cpu) loaded_vmcs_clear(vmx->loaded_vmcs); if (per_cpu(current_vmcs, cpu) != vmx->loaded_vmcs->vmcs) { per_cpu(current_vmcs, cpu) = vmx->loaded_vmcs->vmcs; vmcs_load(vmx->loaded_vmcs->vmcs); } if (vmx->loaded_vmcs->cpu != cpu) { struct desc_ptr gdt = this_cpu_ptr(&host_gdt); unsigned long sysenter_esp; kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu); local_irq_disable(); crash_disable_local_vmclear(cpu); /* * Read loaded_vmcs->cpu should be before fetching * loaded_vmcs->loaded_vmcss_on_cpu_link. * See the comments in __loaded_vmcs_clear(). / smp_rmb(); list_add(&vmx->loaded_vmcs->loaded_vmcss_on_cpu_link, &per_cpu(loaded_vmcss_on_cpu, cpu)); crash_enable_local_vmclear(cpu); local_irq_enable(); / * Linux uses per-cpu TSS and GDT, so set these when switching * processors. / vmcs_writel(HOST_TR_BASE, kvm_read_tr_base()); / 22.2.4 / vmcs_writel(HOST_GDTR_BASE, gdt->address); / 22.2.4 / rdmsrl(MSR_IA32_SYSENTER_ESP, sysenter_esp); vmcs_writel(HOST_IA32_SYSENTER_ESP, sysenter_esp); / 22.2.3 / vmx->loaded_vmcs->cpu = cpu; } / Setup TSC multiplier / if (kvm_has_tsc_control && vmx->current_tsc_ratio != vcpu->arch.tsc_scaling_ratio) { vmx->current_tsc_ratio = vcpu->arch.tsc_scaling_ratio; vmcs_write64(TSC_MULTIPLIER, vmx->current_tsc_ratio); } vmx_vcpu_pi_load(vcpu, cpu); vmx->host_pkru = read_pkru(); } static void vmx_vcpu_pi_put(struct kvm_vcpu vcpu) { struct pi_desc pi_desc = vcpu_to_pi_desc(vcpu); if (!kvm_arch_has_assigned_device(vcpu->kvm) \|\| !irq_remapping_cap(IRQ_POSTING_CAP)) return; / Set SN when the vCPU is preempted / if (vcpu->preempted) pi_set_sn(pi_desc); } static void vmx_vcpu_put(struct kvm_vcpu vcpu) { vmx_vcpu_pi_put(vcpu); __vmx_load_host_state(to_vmx(vcpu)); if (!vmm_exclusive) { __loaded_vmcs_clear(to_vmx(vcpu)->loaded_vmcs); vcpu->cpu = -1; kvm_cpu_vmxoff(); } } static void vmx_fpu_activate(struct kvm_vcpu vcpu) { ulong cr0; if (vcpu->fpu_active) return; vcpu->fpu_active = 1; cr0 = vmcs_readl(GUEST_CR0); cr0 &= ~(X86_CR0_TS \| X86_CR0_MP); cr0 \|= kvm_read_cr0_bits(vcpu, X86_CR0_TS \| X86_CR0_MP); vmcs_writel(GUEST_CR0, cr0); update_exception_bitmap(vcpu); vcpu->arch.cr0_guest_owned_bits = X86_CR0_TS; if (is_guest_mode(vcpu)) vcpu->arch.cr0_guest_owned_bits &= ~get_vmcs12(vcpu)->cr0_guest_host_mask; vmcs_writel(CR0_GUEST_HOST_MASK, ~vcpu->arch.cr0_guest_owned_bits); } static void vmx_decache_cr0_guest_bits(struct kvm_vcpu vcpu); /* * Return the cr0 value that a nested guest would read. This is a combination * of the real cr0 used to run the guest (guest_cr0), and the bits shadowed by * its hypervisor (cr0_read_shadow). / static inline unsigned long nested_read_cr0(struct vmcs12 fields) { return (fields->guest_cr0 & ~fields->cr0_guest_host_mask) \| (fields->cr0_read_shadow & fields->cr0_guest_host_mask); } static inline unsigned long nested_read_cr4(struct vmcs12 fields) { return (fields->guest_cr4 & ~fields->cr4_guest_host_mask) \| (fields->cr4_read_shadow & fields->cr4_guest_host_mask); } static void vmx_fpu_deactivate(struct kvm_vcpu vcpu) { /* Note that there is no vcpu->fpu_active = 0 here. The caller must * set this before calling this function. / vmx_decache_cr0_guest_bits(vcpu); vmcs_set_bits(GUEST_CR0, X86_CR0_TS \| X86_CR0_MP); update_exception_bitmap(vcpu); vcpu->arch.cr0_guest_owned_bits = 0; vmcs_writel(CR0_GUEST_HOST_MASK, ~vcpu->arch.cr0_guest_owned_bits); if (is_guest_mode(vcpu)) { / * L1's specified read shadow might not contain the TS bit, * so now that we turned on shadowing of this bit, we need to * set this bit of the shadow. Like in nested_vmx_run we need * nested_read_cr0(vmcs12), but vmcs12->guest_cr0 is not yet * up-to-date here because we just decached cr0.TS (and we'll * only update vmcs12->guest_cr0 on nested exit). / struct vmcs12 vmcs12 = get_vmcs12(vcpu); vmcs12->guest_cr0 = (vmcs12->guest_cr0 & ~X86_CR0_TS) \| (vcpu->arch.cr0 & X86_CR0_TS); vmcs_writel(CR0_READ_SHADOW, nested_read_cr0(vmcs12)); } else vmcs_writel(CR0_READ_SHADOW, vcpu->arch.cr0); } static unsigned long vmx_get_rflags(struct kvm_vcpu vcpu) { unsigned long rflags, save_rflags; if (!test_bit(VCPU_EXREG_RFLAGS, (ulong )&vcpu->arch.regs_avail)) { __set_bit(VCPU_EXREG_RFLAGS, (ulong )&vcpu->arch.regs_avail); rflags = vmcs_readl(GUEST_RFLAGS); if (to_vmx(vcpu)->rmode.vm86_active) { rflags &= RMODE_GUEST_OWNED_EFLAGS_BITS; save_rflags = to_vmx(vcpu)->rmode.save_rflags; rflags \|= save_rflags & ~RMODE_GUEST_OWNED_EFLAGS_BITS; } to_vmx(vcpu)->rflags = rflags; } return to_vmx(vcpu)->rflags; } static void vmx_set_rflags(struct kvm_vcpu vcpu, unsigned long rflags) { __set_bit(VCPU_EXREG_RFLAGS, (ulong )&vcpu->arch.regs_avail); to_vmx(vcpu)->rflags = rflags; if (to_vmx(vcpu)->rmode.vm86_active) { to_vmx(vcpu)->rmode.save_rflags = rflags; rflags \|= X86_EFLAGS_IOPL \| X86_EFLAGS_VM; } vmcs_writel(GUEST_RFLAGS, rflags); } static u32 vmx_get_pkru(struct kvm_vcpu vcpu) { return to_vmx(vcpu)->guest_pkru; } static u32 vmx_get_interrupt_shadow(struct kvm_vcpu vcpu) { u32 interruptibility = vmcs_read32(GUEST_INTERRUPTIBILITY_INFO); int ret = 0; if (interruptibility & GUEST_INTR_STATE_STI) ret \|= KVM_X86_SHADOW_INT_STI; if (interruptibility & GUEST_INTR_STATE_MOV_SS) ret \|= KVM_X86_SHADOW_INT_MOV_SS; return ret; } static void vmx_set_interrupt_shadow(struct kvm_vcpu vcpu, int mask) { u32 interruptibility_old = vmcs_read32(GUEST_INTERRUPTIBILITY_INFO); u32 interruptibility = interruptibility_old; interruptibility &= ~(GUEST_INTR_STATE_STI \| GUEST_INTR_STATE_MOV_SS); if (mask & KVM_X86_SHADOW_INT_MOV_SS) interruptibility \|= GUEST_INTR_STATE_MOV_SS; else if (mask & KVM_X86_SHADOW_INT_STI) interruptibility \|= GUEST_INTR_STATE_STI; if ((interruptibility != interruptibility_old)) vmcs_write32(GUEST_INTERRUPTIBILITY_INFO, interruptibility); } static void skip_emulated_instruction(struct kvm_vcpu vcpu) { unsigned long rip; rip = kvm_rip_read(vcpu); rip += vmcs_read32(VM_EXIT_INSTRUCTION_LEN); kvm_rip_write(vcpu, rip); / skipping an emulated instruction also counts / vmx_set_interrupt_shadow(vcpu, 0); } / * KVM wants to inject page-faults which it got to the guest. This function * checks whether in a nested guest, we need to inject them to L1 or L2. / static int nested_vmx_check_exception(struct kvm_vcpu vcpu, unsigned nr) { struct vmcs12 vmcs12 = get_vmcs12(vcpu); if (!(vmcs12->exception_bitmap & (1u << nr))) return 0; nested_vmx_vmexit(vcpu, to_vmx(vcpu)->exit_reason, vmcs_read32(VM_EXIT_INTR_INFO), vmcs_readl(EXIT_QUALIFICATION)); return 1; } static void vmx_queue_exception(struct kvm_vcpu vcpu, unsigned nr, bool has_error_code, u32 error_code, bool reinject) { struct vcpu_vmx vmx = to_vmx(vcpu); u32 intr_info = nr \| INTR_INFO_VALID_MASK; if (!reinject && is_guest_mode(vcpu) && nested_vmx_check_exception(vcpu, nr)) return; if (has_error_code) { vmcs_write32(VM_ENTRY_EXCEPTION_ERROR_CODE, error_code); intr_info \|= INTR_INFO_DELIVER_CODE_MASK; } if (vmx->rmode.vm86_active) { int inc_eip = 0; if (kvm_exception_is_soft(nr)) inc_eip = vcpu->arch.event_exit_inst_len; if (kvm_inject_realmode_interrupt(vcpu, nr, inc_eip) != EMULATE_DONE) kvm_make_request(KVM_REQ_TRIPLE_FAULT, vcpu); return; } if (kvm_exception_is_soft(nr)) { vmcs_write32(VM_ENTRY_INSTRUCTION_LEN, vmx->vcpu.arch.event_exit_inst_len); intr_info \|= INTR_TYPE_SOFT_EXCEPTION; } else intr_info \|= INTR_TYPE_HARD_EXCEPTION; vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, intr_info); } static bool vmx_rdtscp_supported(void) { return cpu_has_vmx_rdtscp(); } static bool vmx_invpcid_supported(void) { return cpu_has_vmx_invpcid() && enable_ept; } / * Swap MSR entry in host/guest MSR entry array. / static void move_msr_up(struct vcpu_vmx vmx, int from, int to) { struct shared_msr_entry tmp; tmp = vmx->guest_msrs[to]; vmx->guest_msrs[to] = vmx->guest_msrs[from]; vmx->guest_msrs[from] = tmp; } static void vmx_set_msr_bitmap(struct kvm_vcpu vcpu) { unsigned long msr_bitmap; if (is_guest_mode(vcpu)) msr_bitmap = vmx_msr_bitmap_nested; else if (cpu_has_secondary_exec_ctrls() && (vmcs_read32(SECONDARY_VM_EXEC_CONTROL) & SECONDARY_EXEC_VIRTUALIZE_X2APIC_MODE)) { if (is_long_mode(vcpu)) msr_bitmap = vmx_msr_bitmap_longmode_x2apic; else msr_bitmap = vmx_msr_bitmap_legacy_x2apic; } else { if (is_long_mode(vcpu)) msr_bitmap = vmx_msr_bitmap_longmode; else msr_bitmap = vmx_msr_bitmap_legacy; } vmcs_write64(MSR_BITMAP, __pa(msr_bitmap)); } /* * Set up the vmcs to automatically save and restore system * msrs. Don't touch the 64-bit msrs if the guest is in legacy * mode, as fiddling with msrs is very expensive. / static void setup_msrs(struct vcpu_vmx vmx) { int save_nmsrs, index; save_nmsrs = 0; #ifdef CONFIG_X86_64 if (is_long_mode(&vmx->vcpu)) { index = __find_msr_index(vmx, MSR_SYSCALL_MASK); if (index >= 0) move_msr_up(vmx, index, save_nmsrs++); index = __find_msr_index(vmx, MSR_LSTAR); if (index >= 0) move_msr_up(vmx, index, save_nmsrs++); index = __find_msr_index(vmx, MSR_CSTAR); if (index >= 0) move_msr_up(vmx, index, save_nmsrs++); index = __find_msr_index(vmx, MSR_TSC_AUX); if (index >= 0 && guest_cpuid_has_rdtscp(&vmx->vcpu)) move_msr_up(vmx, index, save_nmsrs++); /* * MSR_STAR is only needed on long mode guests, and only * if efer.sce is enabled. / index = __find_msr_index(vmx, MSR_STAR); if ((index >= 0) && (vmx->vcpu.arch.efer & EFER_SCE)) move_msr_up(vmx, index, save_nmsrs++); } #endif index = __find_msr_index(vmx, MSR_EFER); if (index >= 0 && update_transition_efer(vmx, index)) move_msr_up(vmx, index, save_nmsrs++); vmx->save_nmsrs = save_nmsrs; if (cpu_has_vmx_msr_bitmap()) vmx_set_msr_bitmap(&vmx->vcpu); } / * reads and returns guest's timestamp counter "register" * guest_tsc = (host_tsc * tsc multiplier) >> 48 + tsc_offset * -- Intel TSC Scaling for Virtualization White Paper, sec 1.3 / static u64 guest_read_tsc(struct kvm_vcpu vcpu) { u64 host_tsc, tsc_offset; host_tsc = rdtsc(); tsc_offset = vmcs_read64(TSC_OFFSET); return kvm_scale_tsc(vcpu, host_tsc) + tsc_offset; } /* * Like guest_read_tsc, but always returns L1's notion of the timestamp * counter, even if a nested guest (L2) is currently running. / static u64 vmx_read_l1_tsc(struct kvm_vcpu vcpu, u64 host_tsc) { u64 tsc_offset; tsc_offset = is_guest_mode(vcpu) ? to_vmx(vcpu)->nested.vmcs01_tsc_offset : vmcs_read64(TSC_OFFSET); return host_tsc + tsc_offset; } static u64 vmx_read_tsc_offset(struct kvm_vcpu vcpu) { return vmcs_read64(TSC_OFFSET); } / * writes 'offset' into guest's timestamp counter offset register / static void vmx_write_tsc_offset(struct kvm_vcpu vcpu, u64 offset) { if (is_guest_mode(vcpu)) { /* * We're here if L1 chose not to trap WRMSR to TSC. According * to the spec, this should set L1's TSC; The offset that L1 * set for L2 remains unchanged, and still needs to be added * to the newly set TSC to get L2's TSC. / struct vmcs12 vmcs12; to_vmx(vcpu)->nested.vmcs01_tsc_offset = offset; /* recalculate vmcs02.TSC_OFFSET: / vmcs12 = get_vmcs12(vcpu); vmcs_write64(TSC_OFFSET, offset + (nested_cpu_has(vmcs12, CPU_BASED_USE_TSC_OFFSETING) ? vmcs12->tsc_offset : 0)); } else { trace_kvm_write_tsc_offset(vcpu->vcpu_id, vmcs_read64(TSC_OFFSET), offset); vmcs_write64(TSC_OFFSET, offset); } } static void vmx_adjust_tsc_offset_guest(struct kvm_vcpu vcpu, s64 adjustment) { u64 offset = vmcs_read64(TSC_OFFSET); vmcs_write64(TSC_OFFSET, offset + adjustment); if (is_guest_mode(vcpu)) { /* Even when running L2, the adjustment needs to apply to L1 / to_vmx(vcpu)->nested.vmcs01_tsc_offset += adjustment; } else trace_kvm_write_tsc_offset(vcpu->vcpu_id, offset, offset + adjustment); } static bool guest_cpuid_has_vmx(struct kvm_vcpu vcpu) { struct kvm_cpuid_entry2 best = kvm_find_cpuid_entry(vcpu, 1, 0); return best && (best->ecx & (1 << (X86_FEATURE_VMX & 31))); } / * nested_vmx_allowed() checks whether a guest should be allowed to use VMX * instructions and MSRs (i.e., nested VMX). Nested VMX is disabled for * all guests if the "nested" module option is off, and can also be disabled * for a single guest by disabling its VMX cpuid bit. / static inline bool nested_vmx_allowed(struct kvm_vcpu vcpu) { return nested && guest_cpuid_has_vmx(vcpu); } /* * nested_vmx_setup_ctls_msrs() sets up variables containing the values to be * returned for the various VMX controls MSRs when nested VMX is enabled. * The same values should also be used to verify that vmcs12 control fields are * valid during nested entry from L1 to L2. * Each of these control msrs has a low and high 32-bit half: A low bit is on * if the corresponding bit in the (32-bit) control field must be on, and a * bit in the high half is on if the corresponding bit in the control field * may be on. See also vmx_control_verify(). / static void nested_vmx_setup_ctls_msrs(struct vcpu_vmx vmx) { /* * Note that as a general rule, the high half of the MSRs (bits in * the control fields which may be 1) should be initialized by the * intersection of the underlying hardware's MSR (i.e., features which * can be supported) and the list of features we want to expose - * because they are known to be properly supported in our code. * Also, usually, the low half of the MSRs (bits which must be 1) can * be set to 0, meaning that L1 may turn off any of these bits. The * reason is that if one of these bits is necessary, it will appear * in vmcs01 and prepare_vmcs02, when it bitwise-or's the control * fields of vmcs01 and vmcs02, will turn these bits off - and * nested_vmx_exit_handled() will not pass related exits to L1. * These rules have exceptions below. / / pin-based controls / rdmsr(MSR_IA32_VMX_PINBASED_CTLS, vmx->nested.nested_vmx_pinbased_ctls_low, vmx->nested.nested_vmx_pinbased_ctls_high); vmx->nested.nested_vmx_pinbased_ctls_low \|= PIN_BASED_ALWAYSON_WITHOUT_TRUE_MSR; vmx->nested.nested_vmx_pinbased_ctls_high &= PIN_BASED_EXT_INTR_MASK \| PIN_BASED_NMI_EXITING \| PIN_BASED_VIRTUAL_NMIS; vmx->nested.nested_vmx_pinbased_ctls_high \|= PIN_BASED_ALWAYSON_WITHOUT_TRUE_MSR \| PIN_BASED_VMX_PREEMPTION_TIMER; if (kvm_vcpu_apicv_active(&vmx->vcpu)) vmx->nested.nested_vmx_pinbased_ctls_high \|= PIN_BASED_POSTED_INTR; / exit controls / rdmsr(MSR_IA32_VMX_EXIT_CTLS, vmx->nested.nested_vmx_exit_ctls_low, vmx->nested.nested_vmx_exit_ctls_high); vmx->nested.nested_vmx_exit_ctls_low = VM_EXIT_ALWAYSON_WITHOUT_TRUE_MSR; vmx->nested.nested_vmx_exit_ctls_high &= #ifdef CONFIG_X86_64 VM_EXIT_HOST_ADDR_SPACE_SIZE \| #endif VM_EXIT_LOAD_IA32_PAT \| VM_EXIT_SAVE_IA32_PAT; vmx->nested.nested_vmx_exit_ctls_high \|= VM_EXIT_ALWAYSON_WITHOUT_TRUE_MSR \| VM_EXIT_LOAD_IA32_EFER \| VM_EXIT_SAVE_IA32_EFER \| VM_EXIT_SAVE_VMX_PREEMPTION_TIMER \| VM_EXIT_ACK_INTR_ON_EXIT; if (kvm_mpx_supported()) vmx->nested.nested_vmx_exit_ctls_high \|= VM_EXIT_CLEAR_BNDCFGS; / We support free control of debug control saving. / vmx->nested.nested_vmx_true_exit_ctls_low = vmx->nested.nested_vmx_exit_ctls_low & ~VM_EXIT_SAVE_DEBUG_CONTROLS; / entry controls / rdmsr(MSR_IA32_VMX_ENTRY_CTLS, vmx->nested.nested_vmx_entry_ctls_low, vmx->nested.nested_vmx_entry_ctls_high); vmx->nested.nested_vmx_entry_ctls_low = VM_ENTRY_ALWAYSON_WITHOUT_TRUE_MSR; vmx->nested.nested_vmx_entry_ctls_high &= #ifdef CONFIG_X86_64 VM_ENTRY_IA32E_MODE \| #endif VM_ENTRY_LOAD_IA32_PAT; vmx->nested.nested_vmx_entry_ctls_high \|= (VM_ENTRY_ALWAYSON_WITHOUT_TRUE_MSR \| VM_ENTRY_LOAD_IA32_EFER); if (kvm_mpx_supported()) vmx->nested.nested_vmx_entry_ctls_high \|= VM_ENTRY_LOAD_BNDCFGS; / We support free control of debug control loading. / vmx->nested.nested_vmx_true_entry_ctls_low = vmx->nested.nested_vmx_entry_ctls_low & ~VM_ENTRY_LOAD_DEBUG_CONTROLS; / cpu-based controls / rdmsr(MSR_IA32_VMX_PROCBASED_CTLS, vmx->nested.nested_vmx_procbased_ctls_low, vmx->nested.nested_vmx_procbased_ctls_high); vmx->nested.nested_vmx_procbased_ctls_low = CPU_BASED_ALWAYSON_WITHOUT_TRUE_MSR; vmx->nested.nested_vmx_procbased_ctls_high &= CPU_BASED_VIRTUAL_INTR_PENDING \| CPU_BASED_VIRTUAL_NMI_PENDING \| CPU_BASED_USE_TSC_OFFSETING \| CPU_BASED_HLT_EXITING \| CPU_BASED_INVLPG_EXITING \| CPU_BASED_MWAIT_EXITING \| CPU_BASED_CR3_LOAD_EXITING \| CPU_BASED_CR3_STORE_EXITING \| #ifdef CONFIG_X86_64 CPU_BASED_CR8_LOAD_EXITING \| CPU_BASED_CR8_STORE_EXITING \| #endif CPU_BASED_MOV_DR_EXITING \| CPU_BASED_UNCOND_IO_EXITING \| CPU_BASED_USE_IO_BITMAPS \| CPU_BASED_MONITOR_TRAP_FLAG \| CPU_BASED_MONITOR_EXITING \| CPU_BASED_RDPMC_EXITING \| CPU_BASED_RDTSC_EXITING \| CPU_BASED_PAUSE_EXITING \| CPU_BASED_TPR_SHADOW \| CPU_BASED_ACTIVATE_SECONDARY_CONTROLS; / * We can allow some features even when not supported by the * hardware. For example, L1 can specify an MSR bitmap - and we * can use it to avoid exits to L1 - even when L0 runs L2 * without MSR bitmaps. / vmx->nested.nested_vmx_procbased_ctls_high \|= CPU_BASED_ALWAYSON_WITHOUT_TRUE_MSR \| CPU_BASED_USE_MSR_BITMAPS; / We support free control of CR3 access interception. / vmx->nested.nested_vmx_true_procbased_ctls_low = vmx->nested.nested_vmx_procbased_ctls_low & ~(CPU_BASED_CR3_LOAD_EXITING \| CPU_BASED_CR3_STORE_EXITING); / secondary cpu-based controls / rdmsr(MSR_IA32_VMX_PROCBASED_CTLS2, vmx->nested.nested_vmx_secondary_ctls_low, vmx->nested.nested_vmx_secondary_ctls_high); vmx->nested.nested_vmx_secondary_ctls_low = 0; vmx->nested.nested_vmx_secondary_ctls_high &= SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES \| SECONDARY_EXEC_RDTSCP \| SECONDARY_EXEC_VIRTUALIZE_X2APIC_MODE \| SECONDARY_EXEC_ENABLE_VPID \| SECONDARY_EXEC_APIC_REGISTER_VIRT \| SECONDARY_EXEC_VIRTUAL_INTR_DELIVERY \| SECONDARY_EXEC_WBINVD_EXITING \| SECONDARY_EXEC_XSAVES \| SECONDARY_EXEC_PCOMMIT; if (enable_ept) { / nested EPT: emulate EPT also to L1 / vmx->nested.nested_vmx_secondary_ctls_high \|= SECONDARY_EXEC_ENABLE_EPT; vmx->nested.nested_vmx_ept_caps = VMX_EPT_PAGE_WALK_4_BIT \| VMX_EPTP_WB_BIT \| VMX_EPT_2MB_PAGE_BIT \| VMX_EPT_INVEPT_BIT; vmx->nested.nested_vmx_ept_caps &= vmx_capability.ept; / * For nested guests, we don't do anything specific * for single context invalidation. Hence, only advertise * support for global context invalidation. / vmx->nested.nested_vmx_ept_caps \|= VMX_EPT_EXTENT_GLOBAL_BIT; } else vmx->nested.nested_vmx_ept_caps = 0; / * Old versions of KVM use the single-context version without * checking for support, so declare that it is supported even * though it is treated as global context. The alternative is * not failing the single-context invvpid, and it is worse. / if (enable_vpid) vmx->nested.nested_vmx_vpid_caps = VMX_VPID_INVVPID_BIT \| VMX_VPID_EXTENT_SINGLE_CONTEXT_BIT \| VMX_VPID_EXTENT_GLOBAL_CONTEXT_BIT; else vmx->nested.nested_vmx_vpid_caps = 0; if (enable_unrestricted_guest) vmx->nested.nested_vmx_secondary_ctls_high \|= SECONDARY_EXEC_UNRESTRICTED_GUEST; / miscellaneous data / rdmsr(MSR_IA32_VMX_MISC, vmx->nested.nested_vmx_misc_low, vmx->nested.nested_vmx_misc_high); vmx->nested.nested_vmx_misc_low &= VMX_MISC_SAVE_EFER_LMA; vmx->nested.nested_vmx_misc_low \|= VMX_MISC_EMULATED_PREEMPTION_TIMER_RATE \| VMX_MISC_ACTIVITY_HLT; vmx->nested.nested_vmx_misc_high = 0; } static inline bool vmx_control_verify(u32 control, u32 low, u32 high) { / * Bits 0 in high must be 0, and bits 1 in low must be 1. / return ((control & high) \| low) == control; } static inline u64 vmx_control_msr(u32 low, u32 high) { return low \| ((u64)high << 32); } / Returns 0 on success, non-0 otherwise. / static int vmx_get_vmx_msr(struct kvm_vcpu vcpu, u32 msr_index, u64 pdata) { struct vcpu_vmx vmx = to_vmx(vcpu); switch (msr_index) { case MSR_IA32_VMX_BASIC: /* * This MSR reports some information about VMX support. We * should return information about the VMX we emulate for the * guest, and the VMCS structure we give it - not about the * VMX support of the underlying hardware. / pdata = VMCS12_REVISION \| VMX_BASIC_TRUE_CTLS \| ((u64)VMCS12_SIZE << VMX_BASIC_VMCS_SIZE_SHIFT) \| (VMX_BASIC_MEM_TYPE_WB << VMX_BASIC_MEM_TYPE_SHIFT); break; case MSR_IA32_VMX_TRUE_PINBASED_CTLS: case MSR_IA32_VMX_PINBASED_CTLS: pdata = vmx_control_msr( vmx->nested.nested_vmx_pinbased_ctls_low, vmx->nested.nested_vmx_pinbased_ctls_high); break; case MSR_IA32_VMX_TRUE_PROCBASED_CTLS: pdata = vmx_control_msr( vmx->nested.nested_vmx_true_procbased_ctls_low, vmx->nested.nested_vmx_procbased_ctls_high); break; case MSR_IA32_VMX_PROCBASED_CTLS: pdata = vmx_control_msr( vmx->nested.nested_vmx_procbased_ctls_low, vmx->nested.nested_vmx_procbased_ctls_high); break; case MSR_IA32_VMX_TRUE_EXIT_CTLS: pdata = vmx_control_msr( vmx->nested.nested_vmx_true_exit_ctls_low, vmx->nested.nested_vmx_exit_ctls_high); break; case MSR_IA32_VMX_EXIT_CTLS: pdata = vmx_control_msr( vmx->nested.nested_vmx_exit_ctls_low, vmx->nested.nested_vmx_exit_ctls_high); break; case MSR_IA32_VMX_TRUE_ENTRY_CTLS: pdata = vmx_control_msr( vmx->nested.nested_vmx_true_entry_ctls_low, vmx->nested.nested_vmx_entry_ctls_high); break; case MSR_IA32_VMX_ENTRY_CTLS: pdata = vmx_control_msr( vmx->nested.nested_vmx_entry_ctls_low, vmx->nested.nested_vmx_entry_ctls_high); break; case MSR_IA32_VMX_MISC: pdata = vmx_control_msr( vmx->nested.nested_vmx_misc_low, vmx->nested.nested_vmx_misc_high); break; /* * These MSRs specify bits which the guest must keep fixed (on or off) * while L1 is in VMXON mode (in L1's root mode, or running an L2). * We picked the standard core2 setting. / #define VMXON_CR0_ALWAYSON (X86_CR0_PE \| X86_CR0_PG \| X86_CR0_NE) #define VMXON_CR4_ALWAYSON X86_CR4_VMXE case MSR_IA32_VMX_CR0_FIXED0: pdata = VMXON_CR0_ALWAYSON; break; case MSR_IA32_VMX_CR0_FIXED1: pdata = -1ULL; break; case MSR_IA32_VMX_CR4_FIXED0: pdata = VMXON_CR4_ALWAYSON; break; case MSR_IA32_VMX_CR4_FIXED1: pdata = -1ULL; break; case MSR_IA32_VMX_VMCS_ENUM: pdata = 0x2e; /* highest index: VMX_PREEMPTION_TIMER_VALUE / break; case MSR_IA32_VMX_PROCBASED_CTLS2: pdata = vmx_control_msr( vmx->nested.nested_vmx_secondary_ctls_low, vmx->nested.nested_vmx_secondary_ctls_high); break; case MSR_IA32_VMX_EPT_VPID_CAP: /* Currently, no nested vpid support / pdata = vmx->nested.nested_vmx_ept_caps \| ((u64)vmx->nested.nested_vmx_vpid_caps << 32); break; default: return 1; } return 0; } /* * Reads an msr value (of 'msr_index') into 'pdata'. * Returns 0 on success, non-0 otherwise. * Assumes vcpu_load() was already called. / static int vmx_get_msr(struct kvm_vcpu vcpu, struct msr_data msr_info) { struct shared_msr_entry msr; switch (msr_info->index) { #ifdef CONFIG_X86_64 case MSR_FS_BASE: msr_info->data = vmcs_readl(GUEST_FS_BASE); break; case MSR_GS_BASE: msr_info->data = vmcs_readl(GUEST_GS_BASE); break; case MSR_KERNEL_GS_BASE: vmx_load_host_state(to_vmx(vcpu)); msr_info->data = to_vmx(vcpu)->msr_guest_kernel_gs_base; break; #endif case MSR_EFER: return kvm_get_msr_common(vcpu, msr_info); case MSR_IA32_TSC: msr_info->data = guest_read_tsc(vcpu); break; case MSR_IA32_SYSENTER_CS: msr_info->data = vmcs_read32(GUEST_SYSENTER_CS); break; case MSR_IA32_SYSENTER_EIP: msr_info->data = vmcs_readl(GUEST_SYSENTER_EIP); break; case MSR_IA32_SYSENTER_ESP: msr_info->data = vmcs_readl(GUEST_SYSENTER_ESP); break; case MSR_IA32_BNDCFGS: if (!kvm_mpx_supported()) return 1; msr_info->data = vmcs_read64(GUEST_BNDCFGS); break; case MSR_IA32_FEATURE_CONTROL: if (!nested_vmx_allowed(vcpu)) return 1; msr_info->data = to_vmx(vcpu)->nested.msr_ia32_feature_control; break; case MSR_IA32_VMX_BASIC ... MSR_IA32_VMX_VMFUNC: if (!nested_vmx_allowed(vcpu)) return 1; return vmx_get_vmx_msr(vcpu, msr_info->index, &msr_info->data); case MSR_IA32_XSS: if (!vmx_xsaves_supported()) return 1; msr_info->data = vcpu->arch.ia32_xss; break; case MSR_TSC_AUX: if (!guest_cpuid_has_rdtscp(vcpu) && !msr_info->host_initiated) return 1; /* Otherwise falls through / default: msr = find_msr_entry(to_vmx(vcpu), msr_info->index); if (msr) { msr_info->data = msr->data; break; } return kvm_get_msr_common(vcpu, msr_info); } return 0; } static void vmx_leave_nested(struct kvm_vcpu vcpu); /* * Writes msr value into into the appropriate "register". * Returns 0 on success, non-0 otherwise. * Assumes vcpu_load() was already called. / static int vmx_set_msr(struct kvm_vcpu vcpu, struct msr_data msr_info) { struct vcpu_vmx vmx = to_vmx(vcpu); struct shared_msr_entry msr; int ret = 0; u32 msr_index = msr_info->index; u64 data = msr_info->data; switch (msr_index) { case MSR_EFER: ret = kvm_set_msr_common(vcpu, msr_info); break; #ifdef CONFIG_X86_64 case MSR_FS_BASE: vmx_segment_cache_clear(vmx); vmcs_writel(GUEST_FS_BASE, data); break; case MSR_GS_BASE: vmx_segment_cache_clear(vmx); vmcs_writel(GUEST_GS_BASE, data); break; case MSR_KERNEL_GS_BASE: vmx_load_host_state(vmx); vmx->msr_guest_kernel_gs_base = data; break; #endif case MSR_IA32_SYSENTER_CS: vmcs_write32(GUEST_SYSENTER_CS, data); break; case MSR_IA32_SYSENTER_EIP: vmcs_writel(GUEST_SYSENTER_EIP, data); break; case MSR_IA32_SYSENTER_ESP: vmcs_writel(GUEST_SYSENTER_ESP, data); break; case MSR_IA32_BNDCFGS: if (!kvm_mpx_supported()) return 1; vmcs_write64(GUEST_BNDCFGS, data); break; case MSR_IA32_TSC: kvm_write_tsc(vcpu, msr_info); break; case MSR_IA32_CR_PAT: if (vmcs_config.vmentry_ctrl & VM_ENTRY_LOAD_IA32_PAT) { if (!kvm_mtrr_valid(vcpu, MSR_IA32_CR_PAT, data)) return 1; vmcs_write64(GUEST_IA32_PAT, data); vcpu->arch.pat = data; break; } ret = kvm_set_msr_common(vcpu, msr_info); break; case MSR_IA32_TSC_ADJUST: ret = kvm_set_msr_common(vcpu, msr_info); break; case MSR_IA32_FEATURE_CONTROL: if (!nested_vmx_allowed(vcpu) \|\| (to_vmx(vcpu)->nested.msr_ia32_feature_control & FEATURE_CONTROL_LOCKED && !msr_info->host_initiated)) return 1; vmx->nested.msr_ia32_feature_control = data; if (msr_info->host_initiated && data == 0) vmx_leave_nested(vcpu); break; case MSR_IA32_VMX_BASIC ... MSR_IA32_VMX_VMFUNC: return 1; / they are read-only / case MSR_IA32_XSS: if (!vmx_xsaves_supported()) return 1; / * The only supported bit as of Skylake is bit 8, but * it is not supported on KVM. / if (data != 0) return 1; vcpu->arch.ia32_xss = data; if (vcpu->arch.ia32_xss != host_xss) add_atomic_switch_msr(vmx, MSR_IA32_XSS, vcpu->arch.ia32_xss, host_xss); else clear_atomic_switch_msr(vmx, MSR_IA32_XSS); break; case MSR_TSC_AUX: if (!guest_cpuid_has_rdtscp(vcpu) && !msr_info->host_initiated) return 1; / Check reserved bit, higher 32 bits should be zero / if ((data >> 32) != 0) return 1; / Otherwise falls through / default: msr = find_msr_entry(vmx, msr_index); if (msr) { u64 old_msr_data = msr->data; msr->data = data; if (msr - vmx->guest_msrs < vmx->save_nmsrs) { preempt_disable(); ret = kvm_set_shared_msr(msr->index, msr->data, msr->mask); preempt_enable(); if (ret) msr->data = old_msr_data; } break; } ret = kvm_set_msr_common(vcpu, msr_info); } return ret; } static void vmx_cache_reg(struct kvm_vcpu vcpu, enum kvm_reg reg) { __set_bit(reg, (unsigned long )&vcpu->arch.regs_avail); switch (reg) { case VCPU_REGS_RSP: vcpu->arch.regs[VCPU_REGS_RSP] = vmcs_readl(GUEST_RSP); break; case VCPU_REGS_RIP: vcpu->arch.regs[VCPU_REGS_RIP] = vmcs_readl(GUEST_RIP); break; case VCPU_EXREG_PDPTR: if (enable_ept) ept_save_pdptrs(vcpu); break; default: break; } } static __init int cpu_has_kvm_support(void) { return cpu_has_vmx(); } static __init int vmx_disabled_by_bios(void) { u64 msr; rdmsrl(MSR_IA32_FEATURE_CONTROL, msr); if (msr & FEATURE_CONTROL_LOCKED) { / launched w/ TXT and VMX disabled / if (!(msr & FEATURE_CONTROL_VMXON_ENABLED_INSIDE_SMX) && tboot_enabled()) return 1; / launched w/o TXT and VMX only enabled w/ TXT / if (!(msr & FEATURE_CONTROL_VMXON_ENABLED_OUTSIDE_SMX) && (msr & FEATURE_CONTROL_VMXON_ENABLED_INSIDE_SMX) && !tboot_enabled()) { printk(KERN_WARNING "kvm: disable TXT in the BIOS or " "activate TXT before enabling KVM\n"); return 1; } / launched w/o TXT and VMX disabled / if (!(msr & FEATURE_CONTROL_VMXON_ENABLED_OUTSIDE_SMX) && !tboot_enabled()) return 1; } return 0; } static void kvm_cpu_vmxon(u64 addr) { asm volatile (ASM_VMX_VMXON_RAX : : "a"(&addr), "m"(addr) : "memory", "cc"); } static int hardware_enable(void) { int cpu = raw_smp_processor_id(); u64 phys_addr = __pa(per_cpu(vmxarea, cpu)); u64 old, test_bits; if (cr4_read_shadow() & X86_CR4_VMXE) return -EBUSY; INIT_LIST_HEAD(&per_cpu(loaded_vmcss_on_cpu, cpu)); INIT_LIST_HEAD(&per_cpu(blocked_vcpu_on_cpu, cpu)); spin_lock_init(&per_cpu(blocked_vcpu_on_cpu_lock, cpu)); / * Now we can enable the vmclear operation in kdump * since the loaded_vmcss_on_cpu list on this cpu * has been initialized. * * Though the cpu is not in VMX operation now, there * is no problem to enable the vmclear operation * for the loaded_vmcss_on_cpu list is empty! / crash_enable_local_vmclear(cpu); rdmsrl(MSR_IA32_FEATURE_CONTROL, old); test_bits = FEATURE_CONTROL_LOCKED; test_bits \|= FEATURE_CONTROL_VMXON_ENABLED_OUTSIDE_SMX; if (tboot_enabled()) test_bits \|= FEATURE_CONTROL_VMXON_ENABLED_INSIDE_SMX; if ((old & test_bits) != test_bits) { / enable and lock / wrmsrl(MSR_IA32_FEATURE_CONTROL, old \| test_bits); } cr4_set_bits(X86_CR4_VMXE); if (vmm_exclusive) { kvm_cpu_vmxon(phys_addr); ept_sync_global(); } native_store_gdt(this_cpu_ptr(&host_gdt)); return 0; } static void vmclear_local_loaded_vmcss(void) { int cpu = raw_smp_processor_id(); struct loaded_vmcs v, n; list_for_each_entry_safe(v, n, &per_cpu(loaded_vmcss_on_cpu, cpu), loaded_vmcss_on_cpu_link) __loaded_vmcs_clear(v); } / Just like cpu_vmxoff(), but with the __kvm_handle_fault_on_reboot() * tricks. / static void kvm_cpu_vmxoff(void) { asm volatile (__ex(ASM_VMX_VMXOFF) : : : "cc"); } static void hardware_disable(void) { if (vmm_exclusive) { vmclear_local_loaded_vmcss(); kvm_cpu_vmxoff(); } cr4_clear_bits(X86_CR4_VMXE); } static __init int adjust_vmx_controls(u32 ctl_min, u32 ctl_opt, u32 msr, u32 result) { u32 vmx_msr_low, vmx_msr_high; u32 ctl = ctl_min \| ctl_opt; rdmsr(msr, vmx_msr_low, vmx_msr_high); ctl &= vmx_msr_high; /* bit == 0 in high word ==> must be zero / ctl \|= vmx_msr_low; / bit == 1 in low word ==> must be one / / Ensure minimum (required) set of control bits are supported. / if (ctl_min & ~ctl) return -EIO; result = ctl; return 0; } static __init bool allow_1_setting(u32 msr, u32 ctl) { u32 vmx_msr_low, vmx_msr_high; rdmsr(msr, vmx_msr_low, vmx_msr_high); return vmx_msr_high & ctl; } static __init int setup_vmcs_config(struct vmcs_config vmcs_conf) { u32 vmx_msr_low, vmx_msr_high; u32 min, opt, min2, opt2; u32 _pin_based_exec_control = 0; u32 _cpu_based_exec_control = 0; u32 _cpu_based_2nd_exec_control = 0; u32 _vmexit_control = 0; u32 _vmentry_control = 0; min = CPU_BASED_HLT_EXITING \| #ifdef CONFIG_X86_64 CPU_BASED_CR8_LOAD_EXITING \| CPU_BASED_CR8_STORE_EXITING \| #endif CPU_BASED_CR3_LOAD_EXITING \| CPU_BASED_CR3_STORE_EXITING \| CPU_BASED_USE_IO_BITMAPS \| CPU_BASED_MOV_DR_EXITING \| CPU_BASED_USE_TSC_OFFSETING \| CPU_BASED_MWAIT_EXITING \| CPU_BASED_MONITOR_EXITING \| CPU_BASED_INVLPG_EXITING \| CPU_BASED_RDPMC_EXITING; opt = CPU_BASED_TPR_SHADOW \| CPU_BASED_USE_MSR_BITMAPS \| CPU_BASED_ACTIVATE_SECONDARY_CONTROLS; if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_PROCBASED_CTLS, &_cpu_based_exec_control) < 0) return -EIO; #ifdef CONFIG_X86_64 if ((_cpu_based_exec_control & CPU_BASED_TPR_SHADOW)) _cpu_based_exec_control &= ~CPU_BASED_CR8_LOAD_EXITING & ~CPU_BASED_CR8_STORE_EXITING; #endif if (_cpu_based_exec_control & CPU_BASED_ACTIVATE_SECONDARY_CONTROLS) { min2 = 0; opt2 = SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES \| SECONDARY_EXEC_VIRTUALIZE_X2APIC_MODE \| SECONDARY_EXEC_WBINVD_EXITING \| SECONDARY_EXEC_ENABLE_VPID \| SECONDARY_EXEC_ENABLE_EPT \| SECONDARY_EXEC_UNRESTRICTED_GUEST \| SECONDARY_EXEC_PAUSE_LOOP_EXITING \| SECONDARY_EXEC_RDTSCP \| SECONDARY_EXEC_ENABLE_INVPCID \| SECONDARY_EXEC_APIC_REGISTER_VIRT \| SECONDARY_EXEC_VIRTUAL_INTR_DELIVERY \| SECONDARY_EXEC_SHADOW_VMCS \| SECONDARY_EXEC_XSAVES \| SECONDARY_EXEC_ENABLE_PML \| SECONDARY_EXEC_PCOMMIT \| SECONDARY_EXEC_TSC_SCALING; if (adjust_vmx_controls(min2, opt2, MSR_IA32_VMX_PROCBASED_CTLS2, &_cpu_based_2nd_exec_control) < 0) return -EIO; } #ifndef CONFIG_X86_64 if (!(_cpu_based_2nd_exec_control & SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES)) _cpu_based_exec_control &= ~CPU_BASED_TPR_SHADOW; #endif if (!(_cpu_based_exec_control & CPU_BASED_TPR_SHADOW)) _cpu_based_2nd_exec_control &= ~( SECONDARY_EXEC_APIC_REGISTER_VIRT \| SECONDARY_EXEC_VIRTUALIZE_X2APIC_MODE \| SECONDARY_EXEC_VIRTUAL_INTR_DELIVERY); if (_cpu_based_2nd_exec_control & SECONDARY_EXEC_ENABLE_EPT) { / CR3 accesses and invlpg don't need to cause VM Exits when EPT enabled / _cpu_based_exec_control &= ~(CPU_BASED_CR3_LOAD_EXITING \| CPU_BASED_CR3_STORE_EXITING \| CPU_BASED_INVLPG_EXITING); rdmsr(MSR_IA32_VMX_EPT_VPID_CAP, vmx_capability.ept, vmx_capability.vpid); } min = VM_EXIT_SAVE_DEBUG_CONTROLS; #ifdef CONFIG_X86_64 min \|= VM_EXIT_HOST_ADDR_SPACE_SIZE; #endif opt = VM_EXIT_SAVE_IA32_PAT \| VM_EXIT_LOAD_IA32_PAT \| VM_EXIT_ACK_INTR_ON_EXIT \| VM_EXIT_CLEAR_BNDCFGS; if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_EXIT_CTLS, &_vmexit_control) < 0) return -EIO; min = PIN_BASED_EXT_INTR_MASK \| PIN_BASED_NMI_EXITING; opt = PIN_BASED_VIRTUAL_NMIS \| PIN_BASED_POSTED_INTR; if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_PINBASED_CTLS, &_pin_based_exec_control) < 0) return -EIO; if (!(_cpu_based_2nd_exec_control & SECONDARY_EXEC_VIRTUAL_INTR_DELIVERY) \|\| !(_vmexit_control & VM_EXIT_ACK_INTR_ON_EXIT)) _pin_based_exec_control &= ~PIN_BASED_POSTED_INTR; min = VM_ENTRY_LOAD_DEBUG_CONTROLS; opt = VM_ENTRY_LOAD_IA32_PAT \| VM_ENTRY_LOAD_BNDCFGS; if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_ENTRY_CTLS, &_vmentry_control) < 0) return -EIO; rdmsr(MSR_IA32_VMX_BASIC, vmx_msr_low, vmx_msr_high); / IA-32 SDM Vol 3B: VMCS size is never greater than 4kB. / if ((vmx_msr_high & 0x1fff) > PAGE_SIZE) return -EIO; #ifdef CONFIG_X86_64 / IA-32 SDM Vol 3B: 64-bit CPUs always have VMX_BASIC_MSR[48]==0. / if (vmx_msr_high & (1u<<16)) return -EIO; #endif / Require Write-Back (WB) memory type for VMCS accesses. / if (((vmx_msr_high >> 18) & 15) != 6) return -EIO; vmcs_conf->size = vmx_msr_high & 0x1fff; vmcs_conf->order = get_order(vmcs_config.size); vmcs_conf->revision_id = vmx_msr_low; vmcs_conf->pin_based_exec_ctrl = _pin_based_exec_control; vmcs_conf->cpu_based_exec_ctrl = _cpu_based_exec_control; vmcs_conf->cpu_based_2nd_exec_ctrl = _cpu_based_2nd_exec_control; vmcs_conf->vmexit_ctrl = _vmexit_control; vmcs_conf->vmentry_ctrl = _vmentry_control; cpu_has_load_ia32_efer = allow_1_setting(MSR_IA32_VMX_ENTRY_CTLS, VM_ENTRY_LOAD_IA32_EFER) && allow_1_setting(MSR_IA32_VMX_EXIT_CTLS, VM_EXIT_LOAD_IA32_EFER); cpu_has_load_perf_global_ctrl = allow_1_setting(MSR_IA32_VMX_ENTRY_CTLS, VM_ENTRY_LOAD_IA32_PERF_GLOBAL_CTRL) && allow_1_setting(MSR_IA32_VMX_EXIT_CTLS, VM_EXIT_LOAD_IA32_PERF_GLOBAL_CTRL); / * Some cpus support VM_ENTRY_(LOAD\|SAVE)_IA32_PERF_GLOBAL_CTRL * but due to arrata below it can't be used. Workaround is to use * msr load mechanism to switch IA32_PERF_GLOBAL_CTRL. * * VM Exit May Incorrectly Clear IA32_PERF_GLOBAL_CTRL [34:32] * * AAK155 (model 26) * AAP115 (model 30) * AAT100 (model 37) * BC86,AAY89,BD102 (model 44) * BA97 (model 46) * / if (cpu_has_load_perf_global_ctrl && boot_cpu_data.x86 == 0x6) { switch (boot_cpu_data.x86_model) { case 26: case 30: case 37: case 44: case 46: cpu_has_load_perf_global_ctrl = false; printk_once(KERN_WARNING"kvm: VM_EXIT_LOAD_IA32_PERF_GLOBAL_CTRL " "does not work properly. Using workaround\n"); break; default: break; } } if (cpu_has_xsaves) rdmsrl(MSR_IA32_XSS, host_xss); return 0; } static struct vmcs alloc_vmcs_cpu(int cpu) { int node = cpu_to_node(cpu); struct page pages; struct vmcs vmcs; pages = __alloc_pages_node(node, GFP_KERNEL, vmcs_config.order); if (!pages) return NULL; vmcs = page_address(pages); memset(vmcs, 0, vmcs_config.size); vmcs->revision_id = vmcs_config.revision_id; /* vmcs revision id / return vmcs; } static struct vmcs alloc_vmcs(void) { return alloc_vmcs_cpu(raw_smp_processor_id()); } static void free_vmcs(struct vmcs vmcs) { free_pages((unsigned long)vmcs, vmcs_config.order); } / * Free a VMCS, but before that VMCLEAR it on the CPU where it was last loaded / static void free_loaded_vmcs(struct loaded_vmcs loaded_vmcs) { if (!loaded_vmcs->vmcs) return; loaded_vmcs_clear(loaded_vmcs); free_vmcs(loaded_vmcs->vmcs); loaded_vmcs->vmcs = NULL; } static void free_kvm_area(void) { int cpu; for_each_possible_cpu(cpu) { free_vmcs(per_cpu(vmxarea, cpu)); per_cpu(vmxarea, cpu) = NULL; } } static void init_vmcs_shadow_fields(void) { int i, j; /* No checks for read only fields yet / for (i = j = 0; i < max_shadow_read_write_fields; i++) { switch (shadow_read_write_fields[i]) { case GUEST_BNDCFGS: if (!kvm_mpx_supported()) continue; break; default: break; } if (j < i) shadow_read_write_fields[j] = shadow_read_write_fields[i]; j++; } max_shadow_read_write_fields = j; / shadowed fields guest access without vmexit / for (i = 0; i < max_shadow_read_write_fields; i++) { clear_bit(shadow_read_write_fields[i], vmx_vmwrite_bitmap); clear_bit(shadow_read_write_fields[i], vmx_vmread_bitmap); } for (i = 0; i < max_shadow_read_only_fields; i++) clear_bit(shadow_read_only_fields[i], vmx_vmread_bitmap); } static __init int alloc_kvm_area(void) { int cpu; for_each_possible_cpu(cpu) { struct vmcs vmcs; vmcs = alloc_vmcs_cpu(cpu); if (!vmcs) { free_kvm_area(); return -ENOMEM; } per_cpu(vmxarea, cpu) = vmcs; } return 0; } static bool emulation_required(struct kvm_vcpu vcpu) { return emulate_invalid_guest_state && !guest_state_valid(vcpu); } static void fix_pmode_seg(struct kvm_vcpu vcpu, int seg, struct kvm_segment save) { if (!emulate_invalid_guest_state) { / * CS and SS RPL should be equal during guest entry according * to VMX spec, but in reality it is not always so. Since vcpu * is in the middle of the transition from real mode to * protected mode it is safe to assume that RPL 0 is a good * default value. / if (seg == VCPU_SREG_CS \|\| seg == VCPU_SREG_SS) save->selector &= ~SEGMENT_RPL_MASK; save->dpl = save->selector & SEGMENT_RPL_MASK; save->s = 1; } vmx_set_segment(vcpu, save, seg); } static void enter_pmode(struct kvm_vcpu vcpu) { unsigned long flags; struct vcpu_vmx vmx = to_vmx(vcpu); / * Update real mode segment cache. It may be not up-to-date if sement * register was written while vcpu was in a guest mode. / vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_ES], VCPU_SREG_ES); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_DS], VCPU_SREG_DS); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_FS], VCPU_SREG_FS); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_GS], VCPU_SREG_GS); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_SS], VCPU_SREG_SS); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_CS], VCPU_SREG_CS); vmx->rmode.vm86_active = 0; vmx_segment_cache_clear(vmx); vmx_set_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_TR], VCPU_SREG_TR); flags = vmcs_readl(GUEST_RFLAGS); flags &= RMODE_GUEST_OWNED_EFLAGS_BITS; flags \|= vmx->rmode.save_rflags & ~RMODE_GUEST_OWNED_EFLAGS_BITS; vmcs_writel(GUEST_RFLAGS, flags); vmcs_writel(GUEST_CR4, (vmcs_readl(GUEST_CR4) & ~X86_CR4_VME) \| (vmcs_readl(CR4_READ_SHADOW) & X86_CR4_VME)); update_exception_bitmap(vcpu); fix_pmode_seg(vcpu, VCPU_SREG_CS, &vmx->rmode.segs[VCPU_SREG_CS]); fix_pmode_seg(vcpu, VCPU_SREG_SS, &vmx->rmode.segs[VCPU_SREG_SS]); fix_pmode_seg(vcpu, VCPU_SREG_ES, &vmx->rmode.segs[VCPU_SREG_ES]); fix_pmode_seg(vcpu, VCPU_SREG_DS, &vmx->rmode.segs[VCPU_SREG_DS]); fix_pmode_seg(vcpu, VCPU_SREG_FS, &vmx->rmode.segs[VCPU_SREG_FS]); fix_pmode_seg(vcpu, VCPU_SREG_GS, &vmx->rmode.segs[VCPU_SREG_GS]); } static void fix_rmode_seg(int seg, struct kvm_segment save) { const struct kvm_vmx_segment_field sf = &kvm_vmx_segment_fields[seg]; struct kvm_segment var = save; var.dpl = 0x3; if (seg == VCPU_SREG_CS) var.type = 0x3; if (!emulate_invalid_guest_state) { var.selector = var.base >> 4; var.base = var.base & 0xffff0; var.limit = 0xffff; var.g = 0; var.db = 0; var.present = 1; var.s = 1; var.l = 0; var.unusable = 0; var.type = 0x3; var.avl = 0; if (save->base & 0xf) printk_once(KERN_WARNING "kvm: segment base is not " "paragraph aligned when entering " "protected mode (seg=%d)", seg); } vmcs_write16(sf->selector, var.selector); vmcs_write32(sf->base, var.base); vmcs_write32(sf->limit, var.limit); vmcs_write32(sf->ar_bytes, vmx_segment_access_rights(&var)); } static void enter_rmode(struct kvm_vcpu vcpu) { unsigned long flags; struct vcpu_vmx vmx = to_vmx(vcpu); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_TR], VCPU_SREG_TR); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_ES], VCPU_SREG_ES); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_DS], VCPU_SREG_DS); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_FS], VCPU_SREG_FS); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_GS], VCPU_SREG_GS); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_SS], VCPU_SREG_SS); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_CS], VCPU_SREG_CS); vmx->rmode.vm86_active = 1; /* * Very old userspace does not call KVM_SET_TSS_ADDR before entering * vcpu. Warn the user that an update is overdue. / if (!vcpu->kvm->arch.tss_addr) printk_once(KERN_WARNING "kvm: KVM_SET_TSS_ADDR need to be " "called before entering vcpu\n"); vmx_segment_cache_clear(vmx); vmcs_writel(GUEST_TR_BASE, vcpu->kvm->arch.tss_addr); vmcs_write32(GUEST_TR_LIMIT, RMODE_TSS_SIZE - 1); vmcs_write32(GUEST_TR_AR_BYTES, 0x008b); flags = vmcs_readl(GUEST_RFLAGS); vmx->rmode.save_rflags = flags; flags \|= X86_EFLAGS_IOPL \| X86_EFLAGS_VM; vmcs_writel(GUEST_RFLAGS, flags); vmcs_writel(GUEST_CR4, vmcs_readl(GUEST_CR4) \| X86_CR4_VME); update_exception_bitmap(vcpu); fix_rmode_seg(VCPU_SREG_SS, &vmx->rmode.segs[VCPU_SREG_SS]); fix_rmode_seg(VCPU_SREG_CS, &vmx->rmode.segs[VCPU_SREG_CS]); fix_rmode_seg(VCPU_SREG_ES, &vmx->rmode.segs[VCPU_SREG_ES]); fix_rmode_seg(VCPU_SREG_DS, &vmx->rmode.segs[VCPU_SREG_DS]); fix_rmode_seg(VCPU_SREG_GS, &vmx->rmode.segs[VCPU_SREG_GS]); fix_rmode_seg(VCPU_SREG_FS, &vmx->rmode.segs[VCPU_SREG_FS]); kvm_mmu_reset_context(vcpu); } static void vmx_set_efer(struct kvm_vcpu vcpu, u64 efer) { struct vcpu_vmx vmx = to_vmx(vcpu); struct shared_msr_entry msr = find_msr_entry(vmx, MSR_EFER); if (!msr) return; /* * Force kernel_gs_base reloading before EFER changes, as control * of this msr depends on is_long_mode(). / vmx_load_host_state(to_vmx(vcpu)); vcpu->arch.efer = efer; if (efer & EFER_LMA) { vm_entry_controls_setbit(to_vmx(vcpu), VM_ENTRY_IA32E_MODE); msr->data = efer; } else { vm_entry_controls_clearbit(to_vmx(vcpu), VM_ENTRY_IA32E_MODE); msr->data = efer & ~EFER_LME; } setup_msrs(vmx); } #ifdef CONFIG_X86_64 static void enter_lmode(struct kvm_vcpu vcpu) { u32 guest_tr_ar; vmx_segment_cache_clear(to_vmx(vcpu)); guest_tr_ar = vmcs_read32(GUEST_TR_AR_BYTES); if ((guest_tr_ar & VMX_AR_TYPE_MASK) != VMX_AR_TYPE_BUSY_64_TSS) { pr_debug_ratelimited("%s: tss fixup for long mode. \n", __func__); vmcs_write32(GUEST_TR_AR_BYTES, (guest_tr_ar & ~VMX_AR_TYPE_MASK) \| VMX_AR_TYPE_BUSY_64_TSS); } vmx_set_efer(vcpu, vcpu->arch.efer \| EFER_LMA); } static void exit_lmode(struct kvm_vcpu vcpu) { vm_entry_controls_clearbit(to_vmx(vcpu), VM_ENTRY_IA32E_MODE); vmx_set_efer(vcpu, vcpu->arch.efer & ~EFER_LMA); } #endif static inline void __vmx_flush_tlb(struct kvm_vcpu vcpu, int vpid) { vpid_sync_context(vpid); if (enable_ept) { if (!VALID_PAGE(vcpu->arch.mmu.root_hpa)) return; ept_sync_context(construct_eptp(vcpu->arch.mmu.root_hpa)); } } static void vmx_flush_tlb(struct kvm_vcpu vcpu) { __vmx_flush_tlb(vcpu, to_vmx(vcpu)->vpid); } static void vmx_decache_cr0_guest_bits(struct kvm_vcpu vcpu) { ulong cr0_guest_owned_bits = vcpu->arch.cr0_guest_owned_bits; vcpu->arch.cr0 &= ~cr0_guest_owned_bits; vcpu->arch.cr0 \|= vmcs_readl(GUEST_CR0) & cr0_guest_owned_bits; } static void vmx_decache_cr3(struct kvm_vcpu vcpu) { if (enable_ept && is_paging(vcpu)) vcpu->arch.cr3 = vmcs_readl(GUEST_CR3); __set_bit(VCPU_EXREG_CR3, (ulong )&vcpu->arch.regs_avail); } static void vmx_decache_cr4_guest_bits(struct kvm_vcpu vcpu) { ulong cr4_guest_owned_bits = vcpu->arch.cr4_guest_owned_bits; vcpu->arch.cr4 &= ~cr4_guest_owned_bits; vcpu->arch.cr4 \|= vmcs_readl(GUEST_CR4) & cr4_guest_owned_bits; } static void ept_load_pdptrs(struct kvm_vcpu vcpu) { struct kvm_mmu mmu = vcpu->arch.walk_mmu; if (!test_bit(VCPU_EXREG_PDPTR, (unsigned long )&vcpu->arch.regs_dirty)) return; if (is_paging(vcpu) && is_pae(vcpu) && !is_long_mode(vcpu)) { vmcs_write64(GUEST_PDPTR0, mmu->pdptrs[0]); vmcs_write64(GUEST_PDPTR1, mmu->pdptrs[1]); vmcs_write64(GUEST_PDPTR2, mmu->pdptrs[2]); vmcs_write64(GUEST_PDPTR3, mmu->pdptrs[3]); } } static void ept_save_pdptrs(struct kvm_vcpu vcpu) { struct kvm_mmu mmu = vcpu->arch.walk_mmu; if (is_paging(vcpu) && is_pae(vcpu) && !is_long_mode(vcpu)) { mmu->pdptrs[0] = vmcs_read64(GUEST_PDPTR0); mmu->pdptrs[1] = vmcs_read64(GUEST_PDPTR1); mmu->pdptrs[2] = vmcs_read64(GUEST_PDPTR2); mmu->pdptrs[3] = vmcs_read64(GUEST_PDPTR3); } __set_bit(VCPU_EXREG_PDPTR, (unsigned long )&vcpu->arch.regs_avail); __set_bit(VCPU_EXREG_PDPTR, (unsigned long )&vcpu->arch.regs_dirty); } static int vmx_set_cr4(struct kvm_vcpu vcpu, unsigned long cr4); static void ept_update_paging_mode_cr0(unsigned long hw_cr0, unsigned long cr0, struct kvm_vcpu vcpu) { if (!test_bit(VCPU_EXREG_CR3, (ulong )&vcpu->arch.regs_avail)) vmx_decache_cr3(vcpu); if (!(cr0 & X86_CR0_PG)) { /* From paging/starting to nonpaging / vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, vmcs_read32(CPU_BASED_VM_EXEC_CONTROL) \| (CPU_BASED_CR3_LOAD_EXITING \| CPU_BASED_CR3_STORE_EXITING)); vcpu->arch.cr0 = cr0; vmx_set_cr4(vcpu, kvm_read_cr4(vcpu)); } else if (!is_paging(vcpu)) { / From nonpaging to paging / vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, vmcs_read32(CPU_BASED_VM_EXEC_CONTROL) & ~(CPU_BASED_CR3_LOAD_EXITING \| CPU_BASED_CR3_STORE_EXITING)); vcpu->arch.cr0 = cr0; vmx_set_cr4(vcpu, kvm_read_cr4(vcpu)); } if (!(cr0 & X86_CR0_WP)) hw_cr0 &= ~X86_CR0_WP; } static void vmx_set_cr0(struct kvm_vcpu vcpu, unsigned long cr0) { struct vcpu_vmx vmx = to_vmx(vcpu); unsigned long hw_cr0; hw_cr0 = (cr0 & ~KVM_GUEST_CR0_MASK); if (enable_unrestricted_guest) hw_cr0 \|= KVM_VM_CR0_ALWAYS_ON_UNRESTRICTED_GUEST; else { hw_cr0 \|= KVM_VM_CR0_ALWAYS_ON; if (vmx->rmode.vm86_active && (cr0 & X86_CR0_PE)) enter_pmode(vcpu); if (!vmx->rmode.vm86_active && !(cr0 & X86_CR0_PE)) enter_rmode(vcpu); } #ifdef CONFIG_X86_64 if (vcpu->arch.efer & EFER_LME) { if (!is_paging(vcpu) && (cr0 & X86_CR0_PG)) enter_lmode(vcpu); if (is_paging(vcpu) && !(cr0 & X86_CR0_PG)) exit_lmode(vcpu); } #endif if (enable_ept) ept_update_paging_mode_cr0(&hw_cr0, cr0, vcpu); if (!vcpu->fpu_active) hw_cr0 \|= X86_CR0_TS \| X86_CR0_MP; vmcs_writel(CR0_READ_SHADOW, cr0); vmcs_writel(GUEST_CR0, hw_cr0); vcpu->arch.cr0 = cr0; /* depends on vcpu->arch.cr0 to be set to a new value / vmx->emulation_required = emulation_required(vcpu); } static u64 construct_eptp(unsigned long root_hpa) { u64 eptp; / TODO write the value reading from MSR / eptp = VMX_EPT_DEFAULT_MT \| VMX_EPT_DEFAULT_GAW << VMX_EPT_GAW_EPTP_SHIFT; if (enable_ept_ad_bits) eptp \|= VMX_EPT_AD_ENABLE_BIT; eptp \|= (root_hpa & PAGE_MASK); return eptp; } static void vmx_set_cr3(struct kvm_vcpu vcpu, unsigned long cr3) { unsigned long guest_cr3; u64 eptp; guest_cr3 = cr3; if (enable_ept) { eptp = construct_eptp(cr3); vmcs_write64(EPT_POINTER, eptp); if (is_paging(vcpu) \|\| is_guest_mode(vcpu)) guest_cr3 = kvm_read_cr3(vcpu); else guest_cr3 = vcpu->kvm->arch.ept_identity_map_addr; ept_load_pdptrs(vcpu); } vmx_flush_tlb(vcpu); vmcs_writel(GUEST_CR3, guest_cr3); } static int vmx_set_cr4(struct kvm_vcpu vcpu, unsigned long cr4) { / * Pass through host's Machine Check Enable value to hw_cr4, which * is in force while we are in guest mode. Do not let guests control * this bit, even if host CR4.MCE == 0. / unsigned long hw_cr4 = (cr4_read_shadow() & X86_CR4_MCE) \| (cr4 & ~X86_CR4_MCE) \| (to_vmx(vcpu)->rmode.vm86_active ? KVM_RMODE_VM_CR4_ALWAYS_ON : KVM_PMODE_VM_CR4_ALWAYS_ON); if (cr4 & X86_CR4_VMXE) { / * To use VMXON (and later other VMX instructions), a guest * must first be able to turn on cr4.VMXE (see handle_vmon()). * So basically the check on whether to allow nested VMX * is here. / if (!nested_vmx_allowed(vcpu)) return 1; } if (to_vmx(vcpu)->nested.vmxon && ((cr4 & VMXON_CR4_ALWAYSON) != VMXON_CR4_ALWAYSON)) return 1; vcpu->arch.cr4 = cr4; if (enable_ept) { if (!is_paging(vcpu)) { hw_cr4 &= ~X86_CR4_PAE; hw_cr4 \|= X86_CR4_PSE; } else if (!(cr4 & X86_CR4_PAE)) { hw_cr4 &= ~X86_CR4_PAE; } } if (!enable_unrestricted_guest && !is_paging(vcpu)) / * SMEP/SMAP/PKU is disabled if CPU is in non-paging mode in * hardware. To emulate this behavior, SMEP/SMAP/PKU needs * to be manually disabled when guest switches to non-paging * mode. * * If !enable_unrestricted_guest, the CPU is always running * with CR0.PG=1 and CR4 needs to be modified. * If enable_unrestricted_guest, the CPU automatically * disables SMEP/SMAP/PKU when the guest sets CR0.PG=0. / hw_cr4 &= ~(X86_CR4_SMEP \| X86_CR4_SMAP \| X86_CR4_PKE); vmcs_writel(CR4_READ_SHADOW, cr4); vmcs_writel(GUEST_CR4, hw_cr4); return 0; } static void vmx_get_segment(struct kvm_vcpu vcpu, struct kvm_segment var, int seg) { struct vcpu_vmx vmx = to_vmx(vcpu); u32 ar; if (vmx->rmode.vm86_active && seg != VCPU_SREG_LDTR) { var = vmx->rmode.segs[seg]; if (seg == VCPU_SREG_TR \|\| var->selector == vmx_read_guest_seg_selector(vmx, seg)) return; var->base = vmx_read_guest_seg_base(vmx, seg); var->selector = vmx_read_guest_seg_selector(vmx, seg); return; } var->base = vmx_read_guest_seg_base(vmx, seg); var->limit = vmx_read_guest_seg_limit(vmx, seg); var->selector = vmx_read_guest_seg_selector(vmx, seg); ar = vmx_read_guest_seg_ar(vmx, seg); var->unusable = (ar >> 16) & 1; var->type = ar & 15; var->s = (ar >> 4) & 1; var->dpl = (ar >> 5) & 3; / * Some userspaces do not preserve unusable property. Since usable * segment has to be present according to VMX spec we can use present * property to amend userspace bug by making unusable segment always * nonpresent. vmx_segment_access_rights() already marks nonpresent * segment as unusable. / var->present = !var->unusable; var->avl = (ar >> 12) & 1; var->l = (ar >> 13) & 1; var->db = (ar >> 14) & 1; var->g = (ar >> 15) & 1; } static u64 vmx_get_segment_base(struct kvm_vcpu vcpu, int seg) { struct kvm_segment s; if (to_vmx(vcpu)->rmode.vm86_active) { vmx_get_segment(vcpu, &s, seg); return s.base; } return vmx_read_guest_seg_base(to_vmx(vcpu), seg); } static int vmx_get_cpl(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); if (unlikely(vmx->rmode.vm86_active)) return 0; else { int ar = vmx_read_guest_seg_ar(vmx, VCPU_SREG_SS); return VMX_AR_DPL(ar); } } static u32 vmx_segment_access_rights(struct kvm_segment var) { u32 ar; if (var->unusable \|\| !var->present) ar = 1 << 16; else { ar = var->type & 15; ar \|= (var->s & 1) << 4; ar \|= (var->dpl & 3) << 5; ar \|= (var->present & 1) << 7; ar \|= (var->avl & 1) << 12; ar \|= (var->l & 1) << 13; ar \|= (var->db & 1) << 14; ar \|= (var->g & 1) << 15; } return ar; } static void vmx_set_segment(struct kvm_vcpu vcpu, struct kvm_segment var, int seg) { struct vcpu_vmx vmx = to_vmx(vcpu); const struct kvm_vmx_segment_field sf = &kvm_vmx_segment_fields[seg]; vmx_segment_cache_clear(vmx); if (vmx->rmode.vm86_active && seg != VCPU_SREG_LDTR) { vmx->rmode.segs[seg] = var; if (seg == VCPU_SREG_TR) vmcs_write16(sf->selector, var->selector); else if (var->s) fix_rmode_seg(seg, &vmx->rmode.segs[seg]); goto out; } vmcs_writel(sf->base, var->base); vmcs_write32(sf->limit, var->limit); vmcs_write16(sf->selector, var->selector); /* * Fix the "Accessed" bit in AR field of segment registers for older * qemu binaries. * IA32 arch specifies that at the time of processor reset the * "Accessed" bit in the AR field of segment registers is 1. And qemu * is setting it to 0 in the userland code. This causes invalid guest * state vmexit when "unrestricted guest" mode is turned on. * Fix for this setup issue in cpu_reset is being pushed in the qemu * tree. Newer qemu binaries with that qemu fix would not need this * kvm hack. / if (enable_unrestricted_guest && (seg != VCPU_SREG_LDTR)) var->type \|= 0x1; / Accessed / vmcs_write32(sf->ar_bytes, vmx_segment_access_rights(var)); out: vmx->emulation_required = emulation_required(vcpu); } static void vmx_get_cs_db_l_bits(struct kvm_vcpu vcpu, int db, int l) { u32 ar = vmx_read_guest_seg_ar(to_vmx(vcpu), VCPU_SREG_CS); db = (ar >> 14) & 1; l = (ar >> 13) & 1; } static void vmx_get_idt(struct kvm_vcpu vcpu, struct desc_ptr dt) { dt->size = vmcs_read32(GUEST_IDTR_LIMIT); dt->address = vmcs_readl(GUEST_IDTR_BASE); } static void vmx_set_idt(struct kvm_vcpu vcpu, struct desc_ptr dt) { vmcs_write32(GUEST_IDTR_LIMIT, dt->size); vmcs_writel(GUEST_IDTR_BASE, dt->address); } static void vmx_get_gdt(struct kvm_vcpu vcpu, struct desc_ptr dt) { dt->size = vmcs_read32(GUEST_GDTR_LIMIT); dt->address = vmcs_readl(GUEST_GDTR_BASE); } static void vmx_set_gdt(struct kvm_vcpu vcpu, struct desc_ptr dt) { vmcs_write32(GUEST_GDTR_LIMIT, dt->size); vmcs_writel(GUEST_GDTR_BASE, dt->address); } static bool rmode_segment_valid(struct kvm_vcpu vcpu, int seg) { struct kvm_segment var; u32 ar; vmx_get_segment(vcpu, &var, seg); var.dpl = 0x3; if (seg == VCPU_SREG_CS) var.type = 0x3; ar = vmx_segment_access_rights(&var); if (var.base != (var.selector << 4)) return false; if (var.limit != 0xffff) return false; if (ar != 0xf3) return false; return true; } static bool code_segment_valid(struct kvm_vcpu vcpu) { struct kvm_segment cs; unsigned int cs_rpl; vmx_get_segment(vcpu, &cs, VCPU_SREG_CS); cs_rpl = cs.selector & SEGMENT_RPL_MASK; if (cs.unusable) return false; if (~cs.type & (VMX_AR_TYPE_CODE_MASK\|VMX_AR_TYPE_ACCESSES_MASK)) return false; if (!cs.s) return false; if (cs.type & VMX_AR_TYPE_WRITEABLE_MASK) { if (cs.dpl > cs_rpl) return false; } else { if (cs.dpl != cs_rpl) return false; } if (!cs.present) return false; /* TODO: Add Reserved field check, this'll require a new member in the kvm_segment_field structure / return true; } static bool stack_segment_valid(struct kvm_vcpu vcpu) { struct kvm_segment ss; unsigned int ss_rpl; vmx_get_segment(vcpu, &ss, VCPU_SREG_SS); ss_rpl = ss.selector & SEGMENT_RPL_MASK; if (ss.unusable) return true; if (ss.type != 3 && ss.type != 7) return false; if (!ss.s) return false; if (ss.dpl != ss_rpl) /* DPL != RPL / return false; if (!ss.present) return false; return true; } static bool data_segment_valid(struct kvm_vcpu vcpu, int seg) { struct kvm_segment var; unsigned int rpl; vmx_get_segment(vcpu, &var, seg); rpl = var.selector & SEGMENT_RPL_MASK; if (var.unusable) return true; if (!var.s) return false; if (!var.present) return false; if (~var.type & (VMX_AR_TYPE_CODE_MASK\|VMX_AR_TYPE_WRITEABLE_MASK)) { if (var.dpl < rpl) /* DPL < RPL / return false; } / TODO: Add other members to kvm_segment_field to allow checking for other access * rights flags / return true; } static bool tr_valid(struct kvm_vcpu vcpu) { struct kvm_segment tr; vmx_get_segment(vcpu, &tr, VCPU_SREG_TR); if (tr.unusable) return false; if (tr.selector & SEGMENT_TI_MASK) /* TI = 1 / return false; if (tr.type != 3 && tr.type != 11) / TODO: Check if guest is in IA32e mode / return false; if (!tr.present) return false; return true; } static bool ldtr_valid(struct kvm_vcpu vcpu) { struct kvm_segment ldtr; vmx_get_segment(vcpu, &ldtr, VCPU_SREG_LDTR); if (ldtr.unusable) return true; if (ldtr.selector & SEGMENT_TI_MASK) /* TI = 1 / return false; if (ldtr.type != 2) return false; if (!ldtr.present) return false; return true; } static bool cs_ss_rpl_check(struct kvm_vcpu vcpu) { struct kvm_segment cs, ss; vmx_get_segment(vcpu, &cs, VCPU_SREG_CS); vmx_get_segment(vcpu, &ss, VCPU_SREG_SS); return ((cs.selector & SEGMENT_RPL_MASK) == (ss.selector & SEGMENT_RPL_MASK)); } /* * Check if guest state is valid. Returns true if valid, false if * not. * We assume that registers are always usable / static bool guest_state_valid(struct kvm_vcpu vcpu) { if (enable_unrestricted_guest) return true; /* real mode guest state checks / if (!is_protmode(vcpu) \|\| (vmx_get_rflags(vcpu) & X86_EFLAGS_VM)) { if (!rmode_segment_valid(vcpu, VCPU_SREG_CS)) return false; if (!rmode_segment_valid(vcpu, VCPU_SREG_SS)) return false; if (!rmode_segment_valid(vcpu, VCPU_SREG_DS)) return false; if (!rmode_segment_valid(vcpu, VCPU_SREG_ES)) return false; if (!rmode_segment_valid(vcpu, VCPU_SREG_FS)) return false; if (!rmode_segment_valid(vcpu, VCPU_SREG_GS)) return false; } else { / protected mode guest state checks / if (!cs_ss_rpl_check(vcpu)) return false; if (!code_segment_valid(vcpu)) return false; if (!stack_segment_valid(vcpu)) return false; if (!data_segment_valid(vcpu, VCPU_SREG_DS)) return false; if (!data_segment_valid(vcpu, VCPU_SREG_ES)) return false; if (!data_segment_valid(vcpu, VCPU_SREG_FS)) return false; if (!data_segment_valid(vcpu, VCPU_SREG_GS)) return false; if (!tr_valid(vcpu)) return false; if (!ldtr_valid(vcpu)) return false; } / TODO: * - Add checks on RIP * - Add checks on RFLAGS / return true; } static int init_rmode_tss(struct kvm kvm) { gfn_t fn; u16 data = 0; int idx, r; idx = srcu_read_lock(&kvm->srcu); fn = kvm->arch.tss_addr >> PAGE_SHIFT; r = kvm_clear_guest_page(kvm, fn, 0, PAGE_SIZE); if (r < 0) goto out; data = TSS_BASE_SIZE + TSS_REDIRECTION_SIZE; r = kvm_write_guest_page(kvm, fn++, &data, TSS_IOPB_BASE_OFFSET, sizeof(u16)); if (r < 0) goto out; r = kvm_clear_guest_page(kvm, fn++, 0, PAGE_SIZE); if (r < 0) goto out; r = kvm_clear_guest_page(kvm, fn, 0, PAGE_SIZE); if (r < 0) goto out; data = ~0; r = kvm_write_guest_page(kvm, fn, &data, RMODE_TSS_SIZE - 2 * PAGE_SIZE - 1, sizeof(u8)); out: srcu_read_unlock(&kvm->srcu, idx); return r; } static int init_rmode_identity_map(struct kvm kvm) { int i, idx, r = 0; kvm_pfn_t identity_map_pfn; u32 tmp; if (!enable_ept) return 0; / Protect kvm->arch.ept_identity_pagetable_done. / mutex_lock(&kvm->slots_lock); if (likely(kvm->arch.ept_identity_pagetable_done)) goto out2; identity_map_pfn = kvm->arch.ept_identity_map_addr >> PAGE_SHIFT; r = alloc_identity_pagetable(kvm); if (r < 0) goto out2; idx = srcu_read_lock(&kvm->srcu); r = kvm_clear_guest_page(kvm, identity_map_pfn, 0, PAGE_SIZE); if (r < 0) goto out; / Set up identity-mapping pagetable for EPT in real mode / for (i = 0; i < PT32_ENT_PER_PAGE; i++) { tmp = (i << 22) + (_PAGE_PRESENT \| _PAGE_RW \| _PAGE_USER \| _PAGE_ACCESSED \| _PAGE_DIRTY \| _PAGE_PSE); r = kvm_write_guest_page(kvm, identity_map_pfn, &tmp, i sizeof(tmp), sizeof(tmp)); if (r < 0) goto out; } kvm->arch.ept_identity_pagetable_done = true; out: srcu_read_unlock(&kvm->srcu, idx); out2: mutex_unlock(&kvm->slots_lock); return r; } static void seg_setup(int seg) { const struct kvm_vmx_segment_field sf = &kvm_vmx_segment_fields[seg]; unsigned int ar; vmcs_write16(sf->selector, 0); vmcs_writel(sf->base, 0); vmcs_write32(sf->limit, 0xffff); ar = 0x93; if (seg == VCPU_SREG_CS) ar \|= 0x08; / code segment / vmcs_write32(sf->ar_bytes, ar); } static int alloc_apic_access_page(struct kvm kvm) { struct page page; int r = 0; mutex_lock(&kvm->slots_lock); if (kvm->arch.apic_access_page_done) goto out; r = __x86_set_memory_region(kvm, APIC_ACCESS_PAGE_PRIVATE_MEMSLOT, APIC_DEFAULT_PHYS_BASE, PAGE_SIZE); if (r) goto out; page = gfn_to_page(kvm, APIC_DEFAULT_PHYS_BASE >> PAGE_SHIFT); if (is_error_page(page)) { r = -EFAULT; goto out; } / * Do not pin the page in memory, so that memory hot-unplug * is able to migrate it. / put_page(page); kvm->arch.apic_access_page_done = true; out: mutex_unlock(&kvm->slots_lock); return r; } static int alloc_identity_pagetable(struct kvm kvm) { /* Called with kvm->slots_lock held. / int r = 0; BUG_ON(kvm->arch.ept_identity_pagetable_done); r = __x86_set_memory_region(kvm, IDENTITY_PAGETABLE_PRIVATE_MEMSLOT, kvm->arch.ept_identity_map_addr, PAGE_SIZE); return r; } static int allocate_vpid(void) { int vpid; if (!enable_vpid) return 0; spin_lock(&vmx_vpid_lock); vpid = find_first_zero_bit(vmx_vpid_bitmap, VMX_NR_VPIDS); if (vpid < VMX_NR_VPIDS) __set_bit(vpid, vmx_vpid_bitmap); else vpid = 0; spin_unlock(&vmx_vpid_lock); return vpid; } static void free_vpid(int vpid) { if (!enable_vpid \|\| vpid == 0) return; spin_lock(&vmx_vpid_lock); __clear_bit(vpid, vmx_vpid_bitmap); spin_unlock(&vmx_vpid_lock); } #define MSR_TYPE_R 1 #define MSR_TYPE_W 2 static void __vmx_disable_intercept_for_msr(unsigned long msr_bitmap, u32 msr, int type) { int f = sizeof(unsigned long); if (!cpu_has_vmx_msr_bitmap()) return; /* * See Intel PRM Vol. 3, 20.6.9 (MSR-Bitmap Address). Early manuals * have the write-low and read-high bitmap offsets the wrong way round. * We can control MSRs 0x00000000-0x00001fff and 0xc0000000-0xc0001fff. / if (msr <= 0x1fff) { if (type & MSR_TYPE_R) / read-low / __clear_bit(msr, msr_bitmap + 0x000 / f); if (type & MSR_TYPE_W) / write-low / __clear_bit(msr, msr_bitmap + 0x800 / f); } else if ((msr >= 0xc0000000) && (msr <= 0xc0001fff)) { msr &= 0x1fff; if (type & MSR_TYPE_R) / read-high / __clear_bit(msr, msr_bitmap + 0x400 / f); if (type & MSR_TYPE_W) / write-high / __clear_bit(msr, msr_bitmap + 0xc00 / f); } } static void __vmx_enable_intercept_for_msr(unsigned long msr_bitmap, u32 msr, int type) { int f = sizeof(unsigned long); if (!cpu_has_vmx_msr_bitmap()) return; /* * See Intel PRM Vol. 3, 20.6.9 (MSR-Bitmap Address). Early manuals * have the write-low and read-high bitmap offsets the wrong way round. * We can control MSRs 0x00000000-0x00001fff and 0xc0000000-0xc0001fff. / if (msr <= 0x1fff) { if (type & MSR_TYPE_R) / read-low / __set_bit(msr, msr_bitmap + 0x000 / f); if (type & MSR_TYPE_W) / write-low / __set_bit(msr, msr_bitmap + 0x800 / f); } else if ((msr >= 0xc0000000) && (msr <= 0xc0001fff)) { msr &= 0x1fff; if (type & MSR_TYPE_R) / read-high / __set_bit(msr, msr_bitmap + 0x400 / f); if (type & MSR_TYPE_W) / write-high / __set_bit(msr, msr_bitmap + 0xc00 / f); } } / * If a msr is allowed by L0, we should check whether it is allowed by L1. * The corresponding bit will be cleared unless both of L0 and L1 allow it. / static void nested_vmx_disable_intercept_for_msr(unsigned long msr_bitmap_l1, unsigned long msr_bitmap_nested, u32 msr, int type) { int f = sizeof(unsigned long); if (!cpu_has_vmx_msr_bitmap()) { WARN_ON(1); return; } / * See Intel PRM Vol. 3, 20.6.9 (MSR-Bitmap Address). Early manuals * have the write-low and read-high bitmap offsets the wrong way round. * We can control MSRs 0x00000000-0x00001fff and 0xc0000000-0xc0001fff. / if (msr <= 0x1fff) { if (type & MSR_TYPE_R && !test_bit(msr, msr_bitmap_l1 + 0x000 / f)) / read-low / __clear_bit(msr, msr_bitmap_nested + 0x000 / f); if (type & MSR_TYPE_W && !test_bit(msr, msr_bitmap_l1 + 0x800 / f)) / write-low / __clear_bit(msr, msr_bitmap_nested + 0x800 / f); } else if ((msr >= 0xc0000000) && (msr <= 0xc0001fff)) { msr &= 0x1fff; if (type & MSR_TYPE_R && !test_bit(msr, msr_bitmap_l1 + 0x400 / f)) / read-high / __clear_bit(msr, msr_bitmap_nested + 0x400 / f); if (type & MSR_TYPE_W && !test_bit(msr, msr_bitmap_l1 + 0xc00 / f)) / write-high / __clear_bit(msr, msr_bitmap_nested + 0xc00 / f); } } static void vmx_disable_intercept_for_msr(u32 msr, bool longmode_only) { if (!longmode_only) __vmx_disable_intercept_for_msr(vmx_msr_bitmap_legacy, msr, MSR_TYPE_R \| MSR_TYPE_W); __vmx_disable_intercept_for_msr(vmx_msr_bitmap_longmode, msr, MSR_TYPE_R \| MSR_TYPE_W); } static void vmx_enable_intercept_msr_read_x2apic(u32 msr) { __vmx_enable_intercept_for_msr(vmx_msr_bitmap_legacy_x2apic, msr, MSR_TYPE_R); __vmx_enable_intercept_for_msr(vmx_msr_bitmap_longmode_x2apic, msr, MSR_TYPE_R); } static void vmx_disable_intercept_msr_read_x2apic(u32 msr) { __vmx_disable_intercept_for_msr(vmx_msr_bitmap_legacy_x2apic, msr, MSR_TYPE_R); __vmx_disable_intercept_for_msr(vmx_msr_bitmap_longmode_x2apic, msr, MSR_TYPE_R); } static void vmx_disable_intercept_msr_write_x2apic(u32 msr) { __vmx_disable_intercept_for_msr(vmx_msr_bitmap_legacy_x2apic, msr, MSR_TYPE_W); __vmx_disable_intercept_for_msr(vmx_msr_bitmap_longmode_x2apic, msr, MSR_TYPE_W); } static bool vmx_get_enable_apicv(void) { return enable_apicv; } static int vmx_complete_nested_posted_interrupt(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); int max_irr; void vapic_page; u16 status; if (vmx->nested.pi_desc && vmx->nested.pi_pending) { vmx->nested.pi_pending = false; if (!pi_test_and_clear_on(vmx->nested.pi_desc)) return 0; max_irr = find_last_bit( (unsigned long )vmx->nested.pi_desc->pir, 256); if (max_irr == 256) return 0; vapic_page = kmap(vmx->nested.virtual_apic_page); if (!vapic_page) { WARN_ON(1); return -ENOMEM; } __kvm_apic_update_irr(vmx->nested.pi_desc->pir, vapic_page); kunmap(vmx->nested.virtual_apic_page); status = vmcs_read16(GUEST_INTR_STATUS); if ((u8)max_irr > ((u8)status & 0xff)) { status &= ~0xff; status \|= (u8)max_irr; vmcs_write16(GUEST_INTR_STATUS, status); } } return 0; } static inline bool kvm_vcpu_trigger_posted_interrupt(struct kvm_vcpu vcpu) { #ifdef CONFIG_SMP if (vcpu->mode == IN_GUEST_MODE) { struct vcpu_vmx vmx = to_vmx(vcpu); / * Currently, we don't support urgent interrupt, * all interrupts are recognized as non-urgent * interrupt, so we cannot post interrupts when * 'SN' is set. * * If the vcpu is in guest mode, it means it is * running instead of being scheduled out and * waiting in the run queue, and that's the only * case when 'SN' is set currently, warning if * 'SN' is set. / WARN_ON_ONCE(pi_test_sn(&vmx->pi_desc)); apic->send_IPI_mask(get_cpu_mask(vcpu->cpu), POSTED_INTR_VECTOR); return true; } #endif return false; } static int vmx_deliver_nested_posted_interrupt(struct kvm_vcpu vcpu, int vector) { struct vcpu_vmx vmx = to_vmx(vcpu); if (is_guest_mode(vcpu) && vector == vmx->nested.posted_intr_nv) { / the PIR and ON have been set by L1. / kvm_vcpu_trigger_posted_interrupt(vcpu); / * If a posted intr is not recognized by hardware, * we will accomplish it in the next vmentry. / vmx->nested.pi_pending = true; kvm_make_request(KVM_REQ_EVENT, vcpu); return 0; } return -1; } / * Send interrupt to vcpu via posted interrupt way. * 1. If target vcpu is running(non-root mode), send posted interrupt * notification to vcpu and hardware will sync PIR to vIRR atomically. * 2. If target vcpu isn't running(root mode), kick it to pick up the * interrupt from PIR in next vmentry. / static void vmx_deliver_posted_interrupt(struct kvm_vcpu vcpu, int vector) { struct vcpu_vmx vmx = to_vmx(vcpu); int r; r = vmx_deliver_nested_posted_interrupt(vcpu, vector); if (!r) return; if (pi_test_and_set_pir(vector, &vmx->pi_desc)) return; r = pi_test_and_set_on(&vmx->pi_desc); kvm_make_request(KVM_REQ_EVENT, vcpu); if (r \|\| !kvm_vcpu_trigger_posted_interrupt(vcpu)) kvm_vcpu_kick(vcpu); } static void vmx_sync_pir_to_irr(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); if (!pi_test_and_clear_on(&vmx->pi_desc)) return; kvm_apic_update_irr(vcpu, vmx->pi_desc.pir); } / * Set up the vmcs's constant host-state fields, i.e., host-state fields that * will not change in the lifetime of the guest. * Note that host-state that does change is set elsewhere. E.g., host-state * that is set differently for each CPU is set in vmx_vcpu_load(), not here. / static void vmx_set_constant_host_state(struct vcpu_vmx vmx) { u32 low32, high32; unsigned long tmpl; struct desc_ptr dt; unsigned long cr4; vmcs_writel(HOST_CR0, read_cr0() & ~X86_CR0_TS); /* 22.2.3 / vmcs_writel(HOST_CR3, read_cr3()); / 22.2.3 FIXME: shadow tables / / Save the most likely value for this task's CR4 in the VMCS. / cr4 = cr4_read_shadow(); vmcs_writel(HOST_CR4, cr4); / 22.2.3, 22.2.5 / vmx->host_state.vmcs_host_cr4 = cr4; vmcs_write16(HOST_CS_SELECTOR, __KERNEL_CS); / 22.2.4 / #ifdef CONFIG_X86_64 / * Load null selectors, so we can avoid reloading them in * __vmx_load_host_state(), in case userspace uses the null selectors * too (the expected case). / vmcs_write16(HOST_DS_SELECTOR, 0); vmcs_write16(HOST_ES_SELECTOR, 0); #else vmcs_write16(HOST_DS_SELECTOR, __KERNEL_DS); / 22.2.4 / vmcs_write16(HOST_ES_SELECTOR, __KERNEL_DS); / 22.2.4 / #endif vmcs_write16(HOST_SS_SELECTOR, __KERNEL_DS); / 22.2.4 / vmcs_write16(HOST_TR_SELECTOR, GDT_ENTRY_TSS8); /* 22.2.4 / native_store_idt(&dt); vmcs_writel(HOST_IDTR_BASE, dt.address); / 22.2.4 / vmx->host_idt_base = dt.address; vmcs_writel(HOST_RIP, vmx_return); / 22.2.5 / rdmsr(MSR_IA32_SYSENTER_CS, low32, high32); vmcs_write32(HOST_IA32_SYSENTER_CS, low32); rdmsrl(MSR_IA32_SYSENTER_EIP, tmpl); vmcs_writel(HOST_IA32_SYSENTER_EIP, tmpl); / 22.2.3 / if (vmcs_config.vmexit_ctrl & VM_EXIT_LOAD_IA32_PAT) { rdmsr(MSR_IA32_CR_PAT, low32, high32); vmcs_write64(HOST_IA32_PAT, low32 \| ((u64) high32 << 32)); } } static void set_cr4_guest_host_mask(struct vcpu_vmx vmx) { vmx->vcpu.arch.cr4_guest_owned_bits = KVM_CR4_GUEST_OWNED_BITS; if (enable_ept) vmx->vcpu.arch.cr4_guest_owned_bits \|= X86_CR4_PGE; if (is_guest_mode(&vmx->vcpu)) vmx->vcpu.arch.cr4_guest_owned_bits &= ~get_vmcs12(&vmx->vcpu)->cr4_guest_host_mask; vmcs_writel(CR4_GUEST_HOST_MASK, ~vmx->vcpu.arch.cr4_guest_owned_bits); } static u32 vmx_pin_based_exec_ctrl(struct vcpu_vmx vmx) { u32 pin_based_exec_ctrl = vmcs_config.pin_based_exec_ctrl; if (!kvm_vcpu_apicv_active(&vmx->vcpu)) pin_based_exec_ctrl &= ~PIN_BASED_POSTED_INTR; return pin_based_exec_ctrl; } static void vmx_refresh_apicv_exec_ctrl(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); vmcs_write32(PIN_BASED_VM_EXEC_CONTROL, vmx_pin_based_exec_ctrl(vmx)); if (cpu_has_secondary_exec_ctrls()) { if (kvm_vcpu_apicv_active(vcpu)) vmcs_set_bits(SECONDARY_VM_EXEC_CONTROL, SECONDARY_EXEC_APIC_REGISTER_VIRT \| SECONDARY_EXEC_VIRTUAL_INTR_DELIVERY); else vmcs_clear_bits(SECONDARY_VM_EXEC_CONTROL, SECONDARY_EXEC_APIC_REGISTER_VIRT \| SECONDARY_EXEC_VIRTUAL_INTR_DELIVERY); } if (cpu_has_vmx_msr_bitmap()) vmx_set_msr_bitmap(vcpu); } static u32 vmx_exec_control(struct vcpu_vmx vmx) { u32 exec_control = vmcs_config.cpu_based_exec_ctrl; if (vmx->vcpu.arch.switch_db_regs & KVM_DEBUGREG_WONT_EXIT) exec_control &= ~CPU_BASED_MOV_DR_EXITING; if (!cpu_need_tpr_shadow(&vmx->vcpu)) { exec_control &= ~CPU_BASED_TPR_SHADOW; #ifdef CONFIG_X86_64 exec_control \|= CPU_BASED_CR8_STORE_EXITING \| CPU_BASED_CR8_LOAD_EXITING; #endif } if (!enable_ept) exec_control \|= CPU_BASED_CR3_STORE_EXITING \| CPU_BASED_CR3_LOAD_EXITING \| CPU_BASED_INVLPG_EXITING; return exec_control; } static u32 vmx_secondary_exec_control(struct vcpu_vmx vmx) { u32 exec_control = vmcs_config.cpu_based_2nd_exec_ctrl; if (!cpu_need_virtualize_apic_accesses(&vmx->vcpu)) exec_control &= ~SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES; if (vmx->vpid == 0) exec_control &= ~SECONDARY_EXEC_ENABLE_VPID; if (!enable_ept) { exec_control &= ~SECONDARY_EXEC_ENABLE_EPT; enable_unrestricted_guest = 0; / Enable INVPCID for non-ept guests may cause performance regression. / exec_control &= ~SECONDARY_EXEC_ENABLE_INVPCID; } if (!enable_unrestricted_guest) exec_control &= ~SECONDARY_EXEC_UNRESTRICTED_GUEST; if (!ple_gap) exec_control &= ~SECONDARY_EXEC_PAUSE_LOOP_EXITING; if (!kvm_vcpu_apicv_active(&vmx->vcpu)) exec_control &= ~(SECONDARY_EXEC_APIC_REGISTER_VIRT \| SECONDARY_EXEC_VIRTUAL_INTR_DELIVERY); exec_control &= ~SECONDARY_EXEC_VIRTUALIZE_X2APIC_MODE; / SECONDARY_EXEC_SHADOW_VMCS is enabled when L1 executes VMPTRLD (handle_vmptrld). We can NOT enable shadow_vmcs here because we don't have yet a current VMCS12 / exec_control &= ~SECONDARY_EXEC_SHADOW_VMCS; if (!enable_pml) exec_control &= ~SECONDARY_EXEC_ENABLE_PML; / Currently, we allow L1 guest to directly run pcommit instruction. / exec_control &= ~SECONDARY_EXEC_PCOMMIT; return exec_control; } static void ept_set_mmio_spte_mask(void) { / * EPT Misconfigurations can be generated if the value of bits 2:0 * of an EPT paging-structure entry is 110b (write/execute). * Also, magic bits (0x3ull << 62) is set to quickly identify mmio * spte. / kvm_mmu_set_mmio_spte_mask((0x3ull << 62) \| 0x6ull); } #define VMX_XSS_EXIT_BITMAP 0 / * Sets up the vmcs for emulated real mode. / static int vmx_vcpu_setup(struct vcpu_vmx vmx) { #ifdef CONFIG_X86_64 unsigned long a; #endif int i; /* I/O / vmcs_write64(IO_BITMAP_A, __pa(vmx_io_bitmap_a)); vmcs_write64(IO_BITMAP_B, __pa(vmx_io_bitmap_b)); if (enable_shadow_vmcs) { vmcs_write64(VMREAD_BITMAP, __pa(vmx_vmread_bitmap)); vmcs_write64(VMWRITE_BITMAP, __pa(vmx_vmwrite_bitmap)); } if (cpu_has_vmx_msr_bitmap()) vmcs_write64(MSR_BITMAP, __pa(vmx_msr_bitmap_legacy)); vmcs_write64(VMCS_LINK_POINTER, -1ull); / 22.3.1.5 / / Control / vmcs_write32(PIN_BASED_VM_EXEC_CONTROL, vmx_pin_based_exec_ctrl(vmx)); vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, vmx_exec_control(vmx)); if (cpu_has_secondary_exec_ctrls()) vmcs_write32(SECONDARY_VM_EXEC_CONTROL, vmx_secondary_exec_control(vmx)); if (kvm_vcpu_apicv_active(&vmx->vcpu)) { vmcs_write64(EOI_EXIT_BITMAP0, 0); vmcs_write64(EOI_EXIT_BITMAP1, 0); vmcs_write64(EOI_EXIT_BITMAP2, 0); vmcs_write64(EOI_EXIT_BITMAP3, 0); vmcs_write16(GUEST_INTR_STATUS, 0); vmcs_write16(POSTED_INTR_NV, POSTED_INTR_VECTOR); vmcs_write64(POSTED_INTR_DESC_ADDR, __pa((&vmx->pi_desc))); } if (ple_gap) { vmcs_write32(PLE_GAP, ple_gap); vmx->ple_window = ple_window; vmx->ple_window_dirty = true; } vmcs_write32(PAGE_FAULT_ERROR_CODE_MASK, 0); vmcs_write32(PAGE_FAULT_ERROR_CODE_MATCH, 0); vmcs_write32(CR3_TARGET_COUNT, 0); / 22.2.1 / vmcs_write16(HOST_FS_SELECTOR, 0); / 22.2.4 / vmcs_write16(HOST_GS_SELECTOR, 0); / 22.2.4 / vmx_set_constant_host_state(vmx); #ifdef CONFIG_X86_64 rdmsrl(MSR_FS_BASE, a); vmcs_writel(HOST_FS_BASE, a); / 22.2.4 / rdmsrl(MSR_GS_BASE, a); vmcs_writel(HOST_GS_BASE, a); / 22.2.4 / #else vmcs_writel(HOST_FS_BASE, 0); / 22.2.4 / vmcs_writel(HOST_GS_BASE, 0); / 22.2.4 / #endif vmcs_write32(VM_EXIT_MSR_STORE_COUNT, 0); vmcs_write32(VM_EXIT_MSR_LOAD_COUNT, 0); vmcs_write64(VM_EXIT_MSR_LOAD_ADDR, __pa(vmx->msr_autoload.host)); vmcs_write32(VM_ENTRY_MSR_LOAD_COUNT, 0); vmcs_write64(VM_ENTRY_MSR_LOAD_ADDR, __pa(vmx->msr_autoload.guest)); if (vmcs_config.vmentry_ctrl & VM_ENTRY_LOAD_IA32_PAT) vmcs_write64(GUEST_IA32_PAT, vmx->vcpu.arch.pat); for (i = 0; i < ARRAY_SIZE(vmx_msr_index); ++i) { u32 index = vmx_msr_index[i]; u32 data_low, data_high; int j = vmx->nmsrs; if (rdmsr_safe(index, &data_low, &data_high) < 0) continue; if (wrmsr_safe(index, data_low, data_high) < 0) continue; vmx->guest_msrs[j].index = i; vmx->guest_msrs[j].data = 0; vmx->guest_msrs[j].mask = -1ull; ++vmx->nmsrs; } vm_exit_controls_init(vmx, vmcs_config.vmexit_ctrl); / 22.2.1, 20.8.1 / vm_entry_controls_init(vmx, vmcs_config.vmentry_ctrl); vmcs_writel(CR0_GUEST_HOST_MASK, ~0UL); set_cr4_guest_host_mask(vmx); if (vmx_xsaves_supported()) vmcs_write64(XSS_EXIT_BITMAP, VMX_XSS_EXIT_BITMAP); return 0; } static void vmx_vcpu_reset(struct kvm_vcpu vcpu, bool init_event) { struct vcpu_vmx vmx = to_vmx(vcpu); struct msr_data apic_base_msr; u64 cr0; vmx->rmode.vm86_active = 0; vmx->soft_vnmi_blocked = 0; vmx->vcpu.arch.regs[VCPU_REGS_RDX] = get_rdx_init_val(); kvm_set_cr8(vcpu, 0); if (!init_event) { apic_base_msr.data = APIC_DEFAULT_PHYS_BASE \| MSR_IA32_APICBASE_ENABLE; if (kvm_vcpu_is_reset_bsp(vcpu)) apic_base_msr.data \|= MSR_IA32_APICBASE_BSP; apic_base_msr.host_initiated = true; kvm_set_apic_base(vcpu, &apic_base_msr); } vmx_segment_cache_clear(vmx); seg_setup(VCPU_SREG_CS); vmcs_write16(GUEST_CS_SELECTOR, 0xf000); vmcs_writel(GUEST_CS_BASE, 0xffff0000ul); seg_setup(VCPU_SREG_DS); seg_setup(VCPU_SREG_ES); seg_setup(VCPU_SREG_FS); seg_setup(VCPU_SREG_GS); seg_setup(VCPU_SREG_SS); vmcs_write16(GUEST_TR_SELECTOR, 0); vmcs_writel(GUEST_TR_BASE, 0); vmcs_write32(GUEST_TR_LIMIT, 0xffff); vmcs_write32(GUEST_TR_AR_BYTES, 0x008b); vmcs_write16(GUEST_LDTR_SELECTOR, 0); vmcs_writel(GUEST_LDTR_BASE, 0); vmcs_write32(GUEST_LDTR_LIMIT, 0xffff); vmcs_write32(GUEST_LDTR_AR_BYTES, 0x00082); if (!init_event) { vmcs_write32(GUEST_SYSENTER_CS, 0); vmcs_writel(GUEST_SYSENTER_ESP, 0); vmcs_writel(GUEST_SYSENTER_EIP, 0); vmcs_write64(GUEST_IA32_DEBUGCTL, 0); } vmcs_writel(GUEST_RFLAGS, 0x02); kvm_rip_write(vcpu, 0xfff0); vmcs_writel(GUEST_GDTR_BASE, 0); vmcs_write32(GUEST_GDTR_LIMIT, 0xffff); vmcs_writel(GUEST_IDTR_BASE, 0); vmcs_write32(GUEST_IDTR_LIMIT, 0xffff); vmcs_write32(GUEST_ACTIVITY_STATE, GUEST_ACTIVITY_ACTIVE); vmcs_write32(GUEST_INTERRUPTIBILITY_INFO, 0); vmcs_writel(GUEST_PENDING_DBG_EXCEPTIONS, 0); setup_msrs(vmx); vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, 0); / 22.2.1 / if (cpu_has_vmx_tpr_shadow() && !init_event) { vmcs_write64(VIRTUAL_APIC_PAGE_ADDR, 0); if (cpu_need_tpr_shadow(vcpu)) vmcs_write64(VIRTUAL_APIC_PAGE_ADDR, __pa(vcpu->arch.apic->regs)); vmcs_write32(TPR_THRESHOLD, 0); } kvm_make_request(KVM_REQ_APIC_PAGE_RELOAD, vcpu); if (kvm_vcpu_apicv_active(vcpu)) memset(&vmx->pi_desc, 0, sizeof(struct pi_desc)); if (vmx->vpid != 0) vmcs_write16(VIRTUAL_PROCESSOR_ID, vmx->vpid); cr0 = X86_CR0_NW \| X86_CR0_CD \| X86_CR0_ET; vmx->vcpu.arch.cr0 = cr0; vmx_set_cr0(vcpu, cr0); / enter rmode / vmx_set_cr4(vcpu, 0); vmx_set_efer(vcpu, 0); vmx_fpu_activate(vcpu); update_exception_bitmap(vcpu); vpid_sync_context(vmx->vpid); } / * In nested virtualization, check if L1 asked to exit on external interrupts. * For most existing hypervisors, this will always return true. / static bool nested_exit_on_intr(struct kvm_vcpu vcpu) { return get_vmcs12(vcpu)->pin_based_vm_exec_control & PIN_BASED_EXT_INTR_MASK; } /* * In nested virtualization, check if L1 has set * VM_EXIT_ACK_INTR_ON_EXIT / static bool nested_exit_intr_ack_set(struct kvm_vcpu vcpu) { return get_vmcs12(vcpu)->vm_exit_controls & VM_EXIT_ACK_INTR_ON_EXIT; } static bool nested_exit_on_nmi(struct kvm_vcpu vcpu) { return get_vmcs12(vcpu)->pin_based_vm_exec_control & PIN_BASED_NMI_EXITING; } static void enable_irq_window(struct kvm_vcpu vcpu) { u32 cpu_based_vm_exec_control; cpu_based_vm_exec_control = vmcs_read32(CPU_BASED_VM_EXEC_CONTROL); cpu_based_vm_exec_control \|= CPU_BASED_VIRTUAL_INTR_PENDING; vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, cpu_based_vm_exec_control); } static void enable_nmi_window(struct kvm_vcpu vcpu) { u32 cpu_based_vm_exec_control; if (!cpu_has_virtual_nmis() \|\| vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) & GUEST_INTR_STATE_STI) { enable_irq_window(vcpu); return; } cpu_based_vm_exec_control = vmcs_read32(CPU_BASED_VM_EXEC_CONTROL); cpu_based_vm_exec_control \|= CPU_BASED_VIRTUAL_NMI_PENDING; vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, cpu_based_vm_exec_control); } static void vmx_inject_irq(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); uint32_t intr; int irq = vcpu->arch.interrupt.nr; trace_kvm_inj_virq(irq); ++vcpu->stat.irq_injections; if (vmx->rmode.vm86_active) { int inc_eip = 0; if (vcpu->arch.interrupt.soft) inc_eip = vcpu->arch.event_exit_inst_len; if (kvm_inject_realmode_interrupt(vcpu, irq, inc_eip) != EMULATE_DONE) kvm_make_request(KVM_REQ_TRIPLE_FAULT, vcpu); return; } intr = irq \| INTR_INFO_VALID_MASK; if (vcpu->arch.interrupt.soft) { intr \|= INTR_TYPE_SOFT_INTR; vmcs_write32(VM_ENTRY_INSTRUCTION_LEN, vmx->vcpu.arch.event_exit_inst_len); } else intr \|= INTR_TYPE_EXT_INTR; vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, intr); } static void vmx_inject_nmi(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); if (is_guest_mode(vcpu)) return; if (!cpu_has_virtual_nmis()) { / * Tracking the NMI-blocked state in software is built upon * finding the next open IRQ window. This, in turn, depends on * well-behaving guests: They have to keep IRQs disabled at * least as long as the NMI handler runs. Otherwise we may * cause NMI nesting, maybe breaking the guest. But as this is * highly unlikely, we can live with the residual risk. / vmx->soft_vnmi_blocked = 1; vmx->vnmi_blocked_time = 0; } ++vcpu->stat.nmi_injections; vmx->nmi_known_unmasked = false; if (vmx->rmode.vm86_active) { if (kvm_inject_realmode_interrupt(vcpu, NMI_VECTOR, 0) != EMULATE_DONE) kvm_make_request(KVM_REQ_TRIPLE_FAULT, vcpu); return; } vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, INTR_TYPE_NMI_INTR \| INTR_INFO_VALID_MASK \| NMI_VECTOR); } static bool vmx_get_nmi_mask(struct kvm_vcpu vcpu) { if (!cpu_has_virtual_nmis()) return to_vmx(vcpu)->soft_vnmi_blocked; if (to_vmx(vcpu)->nmi_known_unmasked) return false; return vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) & GUEST_INTR_STATE_NMI; } static void vmx_set_nmi_mask(struct kvm_vcpu vcpu, bool masked) { struct vcpu_vmx vmx = to_vmx(vcpu); if (!cpu_has_virtual_nmis()) { if (vmx->soft_vnmi_blocked != masked) { vmx->soft_vnmi_blocked = masked; vmx->vnmi_blocked_time = 0; } } else { vmx->nmi_known_unmasked = !masked; if (masked) vmcs_set_bits(GUEST_INTERRUPTIBILITY_INFO, GUEST_INTR_STATE_NMI); else vmcs_clear_bits(GUEST_INTERRUPTIBILITY_INFO, GUEST_INTR_STATE_NMI); } } static int vmx_nmi_allowed(struct kvm_vcpu vcpu) { if (to_vmx(vcpu)->nested.nested_run_pending) return 0; if (!cpu_has_virtual_nmis() && to_vmx(vcpu)->soft_vnmi_blocked) return 0; return !(vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) & (GUEST_INTR_STATE_MOV_SS \| GUEST_INTR_STATE_STI \| GUEST_INTR_STATE_NMI)); } static int vmx_interrupt_allowed(struct kvm_vcpu vcpu) { return (!to_vmx(vcpu)->nested.nested_run_pending && vmcs_readl(GUEST_RFLAGS) & X86_EFLAGS_IF) && !(vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) & (GUEST_INTR_STATE_STI \| GUEST_INTR_STATE_MOV_SS)); } static int vmx_set_tss_addr(struct kvm kvm, unsigned int addr) { int ret; ret = x86_set_memory_region(kvm, TSS_PRIVATE_MEMSLOT, addr, PAGE_SIZE 3); if (ret) return ret; kvm->arch.tss_addr = addr; return init_rmode_tss(kvm); } static bool rmode_exception(struct kvm_vcpu vcpu, int vec) { switch (vec) { case BP_VECTOR: / * Update instruction length as we may reinject the exception * from user space while in guest debugging mode. / to_vmx(vcpu)->vcpu.arch.event_exit_inst_len = vmcs_read32(VM_EXIT_INSTRUCTION_LEN); if (vcpu->guest_debug & KVM_GUESTDBG_USE_SW_BP) return false; / fall through / case DB_VECTOR: if (vcpu->guest_debug & (KVM_GUESTDBG_SINGLESTEP \| KVM_GUESTDBG_USE_HW_BP)) return false; / fall through / case DE_VECTOR: case OF_VECTOR: case BR_VECTOR: case UD_VECTOR: case DF_VECTOR: case SS_VECTOR: case GP_VECTOR: case MF_VECTOR: return true; break; } return false; } static int handle_rmode_exception(struct kvm_vcpu vcpu, int vec, u32 err_code) { /* * Instruction with address size override prefix opcode 0x67 * Cause the #SS fault with 0 error code in VM86 mode. / if (((vec == GP_VECTOR) \|\| (vec == SS_VECTOR)) && err_code == 0) { if (emulate_instruction(vcpu, 0) == EMULATE_DONE) { if (vcpu->arch.halt_request) { vcpu->arch.halt_request = 0; return kvm_vcpu_halt(vcpu); } return 1; } return 0; } / * Forward all other exceptions that are valid in real mode. * FIXME: Breaks guest debugging in real mode, needs to be fixed with * the required debugging infrastructure rework. / kvm_queue_exception(vcpu, vec); return 1; } / * Trigger machine check on the host. We assume all the MSRs are already set up * by the CPU and that we still run on the same CPU as the MCE occurred on. * We pass a fake environment to the machine check handler because we want * the guest to be always treated like user space, no matter what context * it used internally. / static void kvm_machine_check(void) { #if defined(CONFIG_X86_MCE) && defined(CONFIG_X86_64) struct pt_regs regs = { .cs = 3, / Fake ring 3 no matter what the guest ran on / .flags = X86_EFLAGS_IF, }; do_machine_check(&regs, 0); #endif } static int handle_machine_check(struct kvm_vcpu vcpu) { /* already handled by vcpu_run / return 1; } static int handle_exception(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); struct kvm_run kvm_run = vcpu->run; u32 intr_info, ex_no, error_code; unsigned long cr2, rip, dr6; u32 vect_info; enum emulation_result er; vect_info = vmx->idt_vectoring_info; intr_info = vmx->exit_intr_info; if (is_machine_check(intr_info)) return handle_machine_check(vcpu); if ((intr_info & INTR_INFO_INTR_TYPE_MASK) == INTR_TYPE_NMI_INTR) return 1; /* already handled by vmx_vcpu_run() / if (is_no_device(intr_info)) { vmx_fpu_activate(vcpu); return 1; } if (is_invalid_opcode(intr_info)) { if (is_guest_mode(vcpu)) { kvm_queue_exception(vcpu, UD_VECTOR); return 1; } er = emulate_instruction(vcpu, EMULTYPE_TRAP_UD); if (er != EMULATE_DONE) kvm_queue_exception(vcpu, UD_VECTOR); return 1; } error_code = 0; if (intr_info & INTR_INFO_DELIVER_CODE_MASK) error_code = vmcs_read32(VM_EXIT_INTR_ERROR_CODE); / * The #PF with PFEC.RSVD = 1 indicates the guest is accessing * MMIO, it is better to report an internal error. * See the comments in vmx_handle_exit. / if ((vect_info & VECTORING_INFO_VALID_MASK) && !(is_page_fault(intr_info) && !(error_code & PFERR_RSVD_MASK))) { vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR; vcpu->run->internal.suberror = KVM_INTERNAL_ERROR_SIMUL_EX; vcpu->run->internal.ndata = 3; vcpu->run->internal.data[0] = vect_info; vcpu->run->internal.data[1] = intr_info; vcpu->run->internal.data[2] = error_code; return 0; } if (is_page_fault(intr_info)) { / EPT won't cause page fault directly / BUG_ON(enable_ept); cr2 = vmcs_readl(EXIT_QUALIFICATION); trace_kvm_page_fault(cr2, error_code); if (kvm_event_needs_reinjection(vcpu)) kvm_mmu_unprotect_page_virt(vcpu, cr2); return kvm_mmu_page_fault(vcpu, cr2, error_code, NULL, 0); } ex_no = intr_info & INTR_INFO_VECTOR_MASK; if (vmx->rmode.vm86_active && rmode_exception(vcpu, ex_no)) return handle_rmode_exception(vcpu, ex_no, error_code); switch (ex_no) { case AC_VECTOR: kvm_queue_exception_e(vcpu, AC_VECTOR, error_code); return 1; case DB_VECTOR: dr6 = vmcs_readl(EXIT_QUALIFICATION); if (!(vcpu->guest_debug & (KVM_GUESTDBG_SINGLESTEP \| KVM_GUESTDBG_USE_HW_BP))) { vcpu->arch.dr6 &= ~15; vcpu->arch.dr6 \|= dr6 \| DR6_RTM; if (!(dr6 & ~DR6_RESERVED)) / icebp / skip_emulated_instruction(vcpu); kvm_queue_exception(vcpu, DB_VECTOR); return 1; } kvm_run->debug.arch.dr6 = dr6 \| DR6_FIXED_1; kvm_run->debug.arch.dr7 = vmcs_readl(GUEST_DR7); / fall through / case BP_VECTOR: / * Update instruction length as we may reinject #BP from * user space while in guest debugging mode. Reading it for * #DB as well causes no harm, it is not used in that case. / vmx->vcpu.arch.event_exit_inst_len = vmcs_read32(VM_EXIT_INSTRUCTION_LEN); kvm_run->exit_reason = KVM_EXIT_DEBUG; rip = kvm_rip_read(vcpu); kvm_run->debug.arch.pc = vmcs_readl(GUEST_CS_BASE) + rip; kvm_run->debug.arch.exception = ex_no; break; default: kvm_run->exit_reason = KVM_EXIT_EXCEPTION; kvm_run->ex.exception = ex_no; kvm_run->ex.error_code = error_code; break; } return 0; } static int handle_external_interrupt(struct kvm_vcpu vcpu) { ++vcpu->stat.irq_exits; return 1; } static int handle_triple_fault(struct kvm_vcpu vcpu) { vcpu->run->exit_reason = KVM_EXIT_SHUTDOWN; return 0; } static int handle_io(struct kvm_vcpu vcpu) { unsigned long exit_qualification; int size, in, string; unsigned port; exit_qualification = vmcs_readl(EXIT_QUALIFICATION); string = (exit_qualification & 16) != 0; in = (exit_qualification & 8) != 0; ++vcpu->stat.io_exits; if (string \|\| in) return emulate_instruction(vcpu, 0) == EMULATE_DONE; port = exit_qualification >> 16; size = (exit_qualification & 7) + 1; skip_emulated_instruction(vcpu); return kvm_fast_pio_out(vcpu, size, port); } static void vmx_patch_hypercall(struct kvm_vcpu vcpu, unsigned char hypercall) { /* * Patch in the VMCALL instruction: / hypercall[0] = 0x0f; hypercall[1] = 0x01; hypercall[2] = 0xc1; } static bool nested_cr0_valid(struct kvm_vcpu vcpu, unsigned long val) { unsigned long always_on = VMXON_CR0_ALWAYSON; struct vmcs12 vmcs12 = get_vmcs12(vcpu); if (to_vmx(vcpu)->nested.nested_vmx_secondary_ctls_high & SECONDARY_EXEC_UNRESTRICTED_GUEST && nested_cpu_has2(vmcs12, SECONDARY_EXEC_UNRESTRICTED_GUEST)) always_on &= ~(X86_CR0_PE \| X86_CR0_PG); return (val & always_on) == always_on; } / called to set cr0 as appropriate for a mov-to-cr0 exit. / static int handle_set_cr0(struct kvm_vcpu vcpu, unsigned long val) { if (is_guest_mode(vcpu)) { struct vmcs12 vmcs12 = get_vmcs12(vcpu); unsigned long orig_val = val; / * We get here when L2 changed cr0 in a way that did not change * any of L1's shadowed bits (see nested_vmx_exit_handled_cr), * but did change L0 shadowed bits. So we first calculate the * effective cr0 value that L1 would like to write into the * hardware. It consists of the L2-owned bits from the new * value combined with the L1-owned bits from L1's guest_cr0. / val = (val & ~vmcs12->cr0_guest_host_mask) \| (vmcs12->guest_cr0 & vmcs12->cr0_guest_host_mask); if (!nested_cr0_valid(vcpu, val)) return 1; if (kvm_set_cr0(vcpu, val)) return 1; vmcs_writel(CR0_READ_SHADOW, orig_val); return 0; } else { if (to_vmx(vcpu)->nested.vmxon && ((val & VMXON_CR0_ALWAYSON) != VMXON_CR0_ALWAYSON)) return 1; return kvm_set_cr0(vcpu, val); } } static int handle_set_cr4(struct kvm_vcpu vcpu, unsigned long val) { if (is_guest_mode(vcpu)) { struct vmcs12 vmcs12 = get_vmcs12(vcpu); unsigned long orig_val = val; / analogously to handle_set_cr0 / val = (val & ~vmcs12->cr4_guest_host_mask) \| (vmcs12->guest_cr4 & vmcs12->cr4_guest_host_mask); if (kvm_set_cr4(vcpu, val)) return 1; vmcs_writel(CR4_READ_SHADOW, orig_val); return 0; } else return kvm_set_cr4(vcpu, val); } / called to set cr0 as appropriate for clts instruction exit. / static void handle_clts(struct kvm_vcpu vcpu) { if (is_guest_mode(vcpu)) { /* * We get here when L2 did CLTS, and L1 didn't shadow CR0.TS * but we did (!fpu_active). We need to keep GUEST_CR0.TS on, * just pretend it's off (also in arch.cr0 for fpu_activate). / vmcs_writel(CR0_READ_SHADOW, vmcs_readl(CR0_READ_SHADOW) & ~X86_CR0_TS); vcpu->arch.cr0 &= ~X86_CR0_TS; } else vmx_set_cr0(vcpu, kvm_read_cr0_bits(vcpu, ~X86_CR0_TS)); } static int handle_cr(struct kvm_vcpu vcpu) { unsigned long exit_qualification, val; int cr; int reg; int err; exit_qualification = vmcs_readl(EXIT_QUALIFICATION); cr = exit_qualification & 15; reg = (exit_qualification >> 8) & 15; switch ((exit_qualification >> 4) & 3) { case 0: /* mov to cr / val = kvm_register_readl(vcpu, reg); trace_kvm_cr_write(cr, val); switch (cr) { case 0: err = handle_set_cr0(vcpu, val); kvm_complete_insn_gp(vcpu, err); return 1; case 3: err = kvm_set_cr3(vcpu, val); kvm_complete_insn_gp(vcpu, err); return 1; case 4: err = handle_set_cr4(vcpu, val); kvm_complete_insn_gp(vcpu, err); return 1; case 8: { u8 cr8_prev = kvm_get_cr8(vcpu); u8 cr8 = (u8)val; err = kvm_set_cr8(vcpu, cr8); kvm_complete_insn_gp(vcpu, err); if (lapic_in_kernel(vcpu)) return 1; if (cr8_prev <= cr8) return 1; vcpu->run->exit_reason = KVM_EXIT_SET_TPR; return 0; } } break; case 2: / clts / handle_clts(vcpu); trace_kvm_cr_write(0, kvm_read_cr0(vcpu)); skip_emulated_instruction(vcpu); vmx_fpu_activate(vcpu); return 1; case 1: /mov from cr/ switch (cr) { case 3: val = kvm_read_cr3(vcpu); kvm_register_write(vcpu, reg, val); trace_kvm_cr_read(cr, val); skip_emulated_instruction(vcpu); return 1; case 8: val = kvm_get_cr8(vcpu); kvm_register_write(vcpu, reg, val); trace_kvm_cr_read(cr, val); skip_emulated_instruction(vcpu); return 1; } break; case 3: / lmsw / val = (exit_qualification >> LMSW_SOURCE_DATA_SHIFT) & 0x0f; trace_kvm_cr_write(0, (kvm_read_cr0(vcpu) & ~0xful) \| val); kvm_lmsw(vcpu, val); skip_emulated_instruction(vcpu); return 1; default: break; } vcpu->run->exit_reason = 0; vcpu_unimpl(vcpu, "unhandled control register: op %d cr %d\n", (int)(exit_qualification >> 4) & 3, cr); return 0; } static int handle_dr(struct kvm_vcpu vcpu) { unsigned long exit_qualification; int dr, dr7, reg; exit_qualification = vmcs_readl(EXIT_QUALIFICATION); dr = exit_qualification & DEBUG_REG_ACCESS_NUM; /* First, if DR does not exist, trigger UD / if (!kvm_require_dr(vcpu, dr)) return 1; / Do not handle if the CPL > 0, will trigger GP on re-entry / if (!kvm_require_cpl(vcpu, 0)) return 1; dr7 = vmcs_readl(GUEST_DR7); if (dr7 & DR7_GD) { / * As the vm-exit takes precedence over the debug trap, we * need to emulate the latter, either for the host or the * guest debugging itself. / if (vcpu->guest_debug & KVM_GUESTDBG_USE_HW_BP) { vcpu->run->debug.arch.dr6 = vcpu->arch.dr6; vcpu->run->debug.arch.dr7 = dr7; vcpu->run->debug.arch.pc = kvm_get_linear_rip(vcpu); vcpu->run->debug.arch.exception = DB_VECTOR; vcpu->run->exit_reason = KVM_EXIT_DEBUG; return 0; } else { vcpu->arch.dr6 &= ~15; vcpu->arch.dr6 \|= DR6_BD \| DR6_RTM; kvm_queue_exception(vcpu, DB_VECTOR); return 1; } } if (vcpu->guest_debug == 0) { vmcs_clear_bits(CPU_BASED_VM_EXEC_CONTROL, CPU_BASED_MOV_DR_EXITING); / * No more DR vmexits; force a reload of the debug registers * and reenter on this instruction. The next vmexit will * retrieve the full state of the debug registers. / vcpu->arch.switch_db_regs \|= KVM_DEBUGREG_WONT_EXIT; return 1; } reg = DEBUG_REG_ACCESS_REG(exit_qualification); if (exit_qualification & TYPE_MOV_FROM_DR) { unsigned long val; if (kvm_get_dr(vcpu, dr, &val)) return 1; kvm_register_write(vcpu, reg, val); } else if (kvm_set_dr(vcpu, dr, kvm_register_readl(vcpu, reg))) return 1; skip_emulated_instruction(vcpu); return 1; } static u64 vmx_get_dr6(struct kvm_vcpu vcpu) { return vcpu->arch.dr6; } static void vmx_set_dr6(struct kvm_vcpu vcpu, unsigned long val) { } static void vmx_sync_dirty_debug_regs(struct kvm_vcpu vcpu) { get_debugreg(vcpu->arch.db[0], 0); get_debugreg(vcpu->arch.db[1], 1); get_debugreg(vcpu->arch.db[2], 2); get_debugreg(vcpu->arch.db[3], 3); get_debugreg(vcpu->arch.dr6, 6); vcpu->arch.dr7 = vmcs_readl(GUEST_DR7); vcpu->arch.switch_db_regs &= ~KVM_DEBUGREG_WONT_EXIT; vmcs_set_bits(CPU_BASED_VM_EXEC_CONTROL, CPU_BASED_MOV_DR_EXITING); } static void vmx_set_dr7(struct kvm_vcpu vcpu, unsigned long val) { vmcs_writel(GUEST_DR7, val); } static int handle_cpuid(struct kvm_vcpu vcpu) { kvm_emulate_cpuid(vcpu); return 1; } static int handle_rdmsr(struct kvm_vcpu vcpu) { u32 ecx = vcpu->arch.regs[VCPU_REGS_RCX]; struct msr_data msr_info; msr_info.index = ecx; msr_info.host_initiated = false; if (vmx_get_msr(vcpu, &msr_info)) { trace_kvm_msr_read_ex(ecx); kvm_inject_gp(vcpu, 0); return 1; } trace_kvm_msr_read(ecx, msr_info.data); / FIXME: handling of bits 32:63 of rax, rdx / vcpu->arch.regs[VCPU_REGS_RAX] = msr_info.data & -1u; vcpu->arch.regs[VCPU_REGS_RDX] = (msr_info.data >> 32) & -1u; skip_emulated_instruction(vcpu); return 1; } static int handle_wrmsr(struct kvm_vcpu vcpu) { struct msr_data msr; u32 ecx = vcpu->arch.regs[VCPU_REGS_RCX]; u64 data = (vcpu->arch.regs[VCPU_REGS_RAX] & -1u) \| ((u64)(vcpu->arch.regs[VCPU_REGS_RDX] & -1u) << 32); msr.data = data; msr.index = ecx; msr.host_initiated = false; if (kvm_set_msr(vcpu, &msr) != 0) { trace_kvm_msr_write_ex(ecx, data); kvm_inject_gp(vcpu, 0); return 1; } trace_kvm_msr_write(ecx, data); skip_emulated_instruction(vcpu); return 1; } static int handle_tpr_below_threshold(struct kvm_vcpu vcpu) { kvm_make_request(KVM_REQ_EVENT, vcpu); return 1; } static int handle_interrupt_window(struct kvm_vcpu vcpu) { u32 cpu_based_vm_exec_control; /* clear pending irq / cpu_based_vm_exec_control = vmcs_read32(CPU_BASED_VM_EXEC_CONTROL); cpu_based_vm_exec_control &= ~CPU_BASED_VIRTUAL_INTR_PENDING; vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, cpu_based_vm_exec_control); kvm_make_request(KVM_REQ_EVENT, vcpu); ++vcpu->stat.irq_window_exits; return 1; } static int handle_halt(struct kvm_vcpu vcpu) { return kvm_emulate_halt(vcpu); } static int handle_vmcall(struct kvm_vcpu vcpu) { return kvm_emulate_hypercall(vcpu); } static int handle_invd(struct kvm_vcpu vcpu) { return emulate_instruction(vcpu, 0) == EMULATE_DONE; } static int handle_invlpg(struct kvm_vcpu vcpu) { unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION); kvm_mmu_invlpg(vcpu, exit_qualification); skip_emulated_instruction(vcpu); return 1; } static int handle_rdpmc(struct kvm_vcpu vcpu) { int err; err = kvm_rdpmc(vcpu); kvm_complete_insn_gp(vcpu, err); return 1; } static int handle_wbinvd(struct kvm_vcpu vcpu) { kvm_emulate_wbinvd(vcpu); return 1; } static int handle_xsetbv(struct kvm_vcpu vcpu) { u64 new_bv = kvm_read_edx_eax(vcpu); u32 index = kvm_register_read(vcpu, VCPU_REGS_RCX); if (kvm_set_xcr(vcpu, index, new_bv) == 0) skip_emulated_instruction(vcpu); return 1; } static int handle_xsaves(struct kvm_vcpu vcpu) { skip_emulated_instruction(vcpu); WARN(1, "this should never happen\n"); return 1; } static int handle_xrstors(struct kvm_vcpu vcpu) { skip_emulated_instruction(vcpu); WARN(1, "this should never happen\n"); return 1; } static int handle_apic_access(struct kvm_vcpu vcpu) { if (likely(fasteoi)) { unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION); int access_type, offset; access_type = exit_qualification & APIC_ACCESS_TYPE; offset = exit_qualification & APIC_ACCESS_OFFSET; / * Sane guest uses MOV to write EOI, with written value * not cared. So make a short-circuit here by avoiding * heavy instruction emulation. / if ((access_type == TYPE_LINEAR_APIC_INST_WRITE) && (offset == APIC_EOI)) { kvm_lapic_set_eoi(vcpu); skip_emulated_instruction(vcpu); return 1; } } return emulate_instruction(vcpu, 0) == EMULATE_DONE; } static int handle_apic_eoi_induced(struct kvm_vcpu vcpu) { unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION); int vector = exit_qualification & 0xff; /* EOI-induced VM exit is trap-like and thus no need to adjust IP / kvm_apic_set_eoi_accelerated(vcpu, vector); return 1; } static int handle_apic_write(struct kvm_vcpu vcpu) { unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION); u32 offset = exit_qualification & 0xfff; /* APIC-write VM exit is trap-like and thus no need to adjust IP / kvm_apic_write_nodecode(vcpu, offset); return 1; } static int handle_task_switch(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); unsigned long exit_qualification; bool has_error_code = false; u32 error_code = 0; u16 tss_selector; int reason, type, idt_v, idt_index; idt_v = (vmx->idt_vectoring_info & VECTORING_INFO_VALID_MASK); idt_index = (vmx->idt_vectoring_info & VECTORING_INFO_VECTOR_MASK); type = (vmx->idt_vectoring_info & VECTORING_INFO_TYPE_MASK); exit_qualification = vmcs_readl(EXIT_QUALIFICATION); reason = (u32)exit_qualification >> 30; if (reason == TASK_SWITCH_GATE && idt_v) { switch (type) { case INTR_TYPE_NMI_INTR: vcpu->arch.nmi_injected = false; vmx_set_nmi_mask(vcpu, true); break; case INTR_TYPE_EXT_INTR: case INTR_TYPE_SOFT_INTR: kvm_clear_interrupt_queue(vcpu); break; case INTR_TYPE_HARD_EXCEPTION: if (vmx->idt_vectoring_info & VECTORING_INFO_DELIVER_CODE_MASK) { has_error_code = true; error_code = vmcs_read32(IDT_VECTORING_ERROR_CODE); } / fall through / case INTR_TYPE_SOFT_EXCEPTION: kvm_clear_exception_queue(vcpu); break; default: break; } } tss_selector = exit_qualification; if (!idt_v \|\| (type != INTR_TYPE_HARD_EXCEPTION && type != INTR_TYPE_EXT_INTR && type != INTR_TYPE_NMI_INTR)) skip_emulated_instruction(vcpu); if (kvm_task_switch(vcpu, tss_selector, type == INTR_TYPE_SOFT_INTR ? idt_index : -1, reason, has_error_code, error_code) == EMULATE_FAIL) { vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR; vcpu->run->internal.suberror = KVM_INTERNAL_ERROR_EMULATION; vcpu->run->internal.ndata = 0; return 0; } / * TODO: What about debug traps on tss switch? * Are we supposed to inject them and update dr6? / return 1; } static int handle_ept_violation(struct kvm_vcpu vcpu) { unsigned long exit_qualification; gpa_t gpa; u32 error_code; int gla_validity; exit_qualification = vmcs_readl(EXIT_QUALIFICATION); gla_validity = (exit_qualification >> 7) & 0x3; if (gla_validity != 0x3 && gla_validity != 0x1 && gla_validity != 0) { printk(KERN_ERR "EPT: Handling EPT violation failed!\n"); printk(KERN_ERR "EPT: GPA: 0x%lx, GVA: 0x%lx\n", (long unsigned int)vmcs_read64(GUEST_PHYSICAL_ADDRESS), vmcs_readl(GUEST_LINEAR_ADDRESS)); printk(KERN_ERR "EPT: Exit qualification is 0x%lx\n", (long unsigned int)exit_qualification); vcpu->run->exit_reason = KVM_EXIT_UNKNOWN; vcpu->run->hw.hardware_exit_reason = EXIT_REASON_EPT_VIOLATION; return 0; } /* * EPT violation happened while executing iret from NMI, * "blocked by NMI" bit has to be set before next VM entry. * There are errata that may cause this bit to not be set: * AAK134, BY25. / if (!(to_vmx(vcpu)->idt_vectoring_info & VECTORING_INFO_VALID_MASK) && cpu_has_virtual_nmis() && (exit_qualification & INTR_INFO_UNBLOCK_NMI)) vmcs_set_bits(GUEST_INTERRUPTIBILITY_INFO, GUEST_INTR_STATE_NMI); gpa = vmcs_read64(GUEST_PHYSICAL_ADDRESS); trace_kvm_page_fault(gpa, exit_qualification); / It is a write fault? / error_code = exit_qualification & PFERR_WRITE_MASK; / It is a fetch fault? / error_code \|= (exit_qualification << 2) & PFERR_FETCH_MASK; / ept page table is present? / error_code \|= (exit_qualification >> 3) & PFERR_PRESENT_MASK; vcpu->arch.exit_qualification = exit_qualification; return kvm_mmu_page_fault(vcpu, gpa, error_code, NULL, 0); } static int handle_ept_misconfig(struct kvm_vcpu vcpu) { int ret; gpa_t gpa; gpa = vmcs_read64(GUEST_PHYSICAL_ADDRESS); if (!kvm_io_bus_write(vcpu, KVM_FAST_MMIO_BUS, gpa, 0, NULL)) { skip_emulated_instruction(vcpu); trace_kvm_fast_mmio(gpa); return 1; } ret = handle_mmio_page_fault(vcpu, gpa, true); if (likely(ret == RET_MMIO_PF_EMULATE)) return x86_emulate_instruction(vcpu, gpa, 0, NULL, 0) == EMULATE_DONE; if (unlikely(ret == RET_MMIO_PF_INVALID)) return kvm_mmu_page_fault(vcpu, gpa, 0, NULL, 0); if (unlikely(ret == RET_MMIO_PF_RETRY)) return 1; /* It is the real ept misconfig / WARN_ON(1); vcpu->run->exit_reason = KVM_EXIT_UNKNOWN; vcpu->run->hw.hardware_exit_reason = EXIT_REASON_EPT_MISCONFIG; return 0; } static int handle_nmi_window(struct kvm_vcpu vcpu) { u32 cpu_based_vm_exec_control; /* clear pending NMI / cpu_based_vm_exec_control = vmcs_read32(CPU_BASED_VM_EXEC_CONTROL); cpu_based_vm_exec_control &= ~CPU_BASED_VIRTUAL_NMI_PENDING; vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, cpu_based_vm_exec_control); ++vcpu->stat.nmi_window_exits; kvm_make_request(KVM_REQ_EVENT, vcpu); return 1; } static int handle_invalid_guest_state(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); enum emulation_result err = EMULATE_DONE; int ret = 1; u32 cpu_exec_ctrl; bool intr_window_requested; unsigned count = 130; cpu_exec_ctrl = vmcs_read32(CPU_BASED_VM_EXEC_CONTROL); intr_window_requested = cpu_exec_ctrl & CPU_BASED_VIRTUAL_INTR_PENDING; while (vmx->emulation_required && count-- != 0) { if (intr_window_requested && vmx_interrupt_allowed(vcpu)) return handle_interrupt_window(&vmx->vcpu); if (test_bit(KVM_REQ_EVENT, &vcpu->requests)) return 1; err = emulate_instruction(vcpu, EMULTYPE_NO_REEXECUTE); if (err == EMULATE_USER_EXIT) { ++vcpu->stat.mmio_exits; ret = 0; goto out; } if (err != EMULATE_DONE) { vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR; vcpu->run->internal.suberror = KVM_INTERNAL_ERROR_EMULATION; vcpu->run->internal.ndata = 0; return 0; } if (vcpu->arch.halt_request) { vcpu->arch.halt_request = 0; ret = kvm_vcpu_halt(vcpu); goto out; } if (signal_pending(current)) goto out; if (need_resched()) schedule(); } out: return ret; } static int __grow_ple_window(int val) { if (ple_window_grow < 1) return ple_window; val = min(val, ple_window_actual_max); if (ple_window_grow < ple_window) val = ple_window_grow; else val += ple_window_grow; return val; } static int __shrink_ple_window(int val, int modifier, int minimum) { if (modifier < 1) return ple_window; if (modifier < ple_window) val /= modifier; else val -= modifier; return max(val, minimum); } static void grow_ple_window(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); int old = vmx->ple_window; vmx->ple_window = __grow_ple_window(old); if (vmx->ple_window != old) vmx->ple_window_dirty = true; trace_kvm_ple_window_grow(vcpu->vcpu_id, vmx->ple_window, old); } static void shrink_ple_window(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); int old = vmx->ple_window; vmx->ple_window = __shrink_ple_window(old, ple_window_shrink, ple_window); if (vmx->ple_window != old) vmx->ple_window_dirty = true; trace_kvm_ple_window_shrink(vcpu->vcpu_id, vmx->ple_window, old); } /* * ple_window_actual_max is computed to be one grow_ple_window() below * ple_window_max. (See __grow_ple_window for the reason.) * This prevents overflows, because ple_window_max is int. * ple_window_max effectively rounded down to a multiple of ple_window_grow in * this process. * ple_window_max is also prevented from setting vmx->ple_window < ple_window. / static void update_ple_window_actual_max(void) { ple_window_actual_max = __shrink_ple_window(max(ple_window_max, ple_window), ple_window_grow, INT_MIN); } / * Handler for POSTED_INTERRUPT_WAKEUP_VECTOR. / static void wakeup_handler(void) { struct kvm_vcpu vcpu; int cpu = smp_processor_id(); spin_lock(&per_cpu(blocked_vcpu_on_cpu_lock, cpu)); list_for_each_entry(vcpu, &per_cpu(blocked_vcpu_on_cpu, cpu), blocked_vcpu_list) { struct pi_desc pi_desc = vcpu_to_pi_desc(vcpu); if (pi_test_on(pi_desc) == 1) kvm_vcpu_kick(vcpu); } spin_unlock(&per_cpu(blocked_vcpu_on_cpu_lock, cpu)); } static __init int hardware_setup(void) { int r = -ENOMEM, i, msr; rdmsrl_safe(MSR_EFER, &host_efer); for (i = 0; i < ARRAY_SIZE(vmx_msr_index); ++i) kvm_define_shared_msr(i, vmx_msr_index[i]); vmx_io_bitmap_a = (unsigned long )__get_free_page(GFP_KERNEL); if (!vmx_io_bitmap_a) return r; vmx_io_bitmap_b = (unsigned long )__get_free_page(GFP_KERNEL); if (!vmx_io_bitmap_b) goto out; vmx_msr_bitmap_legacy = (unsigned long )__get_free_page(GFP_KERNEL); if (!vmx_msr_bitmap_legacy) goto out1; vmx_msr_bitmap_legacy_x2apic = (unsigned long )__get_free_page(GFP_KERNEL); if (!vmx_msr_bitmap_legacy_x2apic) goto out2; vmx_msr_bitmap_longmode = (unsigned long )__get_free_page(GFP_KERNEL); if (!vmx_msr_bitmap_longmode) goto out3; vmx_msr_bitmap_longmode_x2apic = (unsigned long )__get_free_page(GFP_KERNEL); if (!vmx_msr_bitmap_longmode_x2apic) goto out4; if (nested) { vmx_msr_bitmap_nested = (unsigned long )__get_free_page(GFP_KERNEL); if (!vmx_msr_bitmap_nested) goto out5; } vmx_vmread_bitmap = (unsigned long )__get_free_page(GFP_KERNEL); if (!vmx_vmread_bitmap) goto out6; vmx_vmwrite_bitmap = (unsigned long )__get_free_page(GFP_KERNEL); if (!vmx_vmwrite_bitmap) goto out7; memset(vmx_vmread_bitmap, 0xff, PAGE_SIZE); memset(vmx_vmwrite_bitmap, 0xff, PAGE_SIZE); /* * Allow direct access to the PC debug port (it is often used for I/O * delays, but the vmexits simply slow things down). / memset(vmx_io_bitmap_a, 0xff, PAGE_SIZE); clear_bit(0x80, vmx_io_bitmap_a); memset(vmx_io_bitmap_b, 0xff, PAGE_SIZE); memset(vmx_msr_bitmap_legacy, 0xff, PAGE_SIZE); memset(vmx_msr_bitmap_longmode, 0xff, PAGE_SIZE); if (nested) memset(vmx_msr_bitmap_nested, 0xff, PAGE_SIZE); if (setup_vmcs_config(&vmcs_config) < 0) { r = -EIO; goto out8; } if (boot_cpu_has(X86_FEATURE_NX)) kvm_enable_efer_bits(EFER_NX); if (!cpu_has_vmx_vpid()) enable_vpid = 0; if (!cpu_has_vmx_shadow_vmcs()) enable_shadow_vmcs = 0; if (enable_shadow_vmcs) init_vmcs_shadow_fields(); if (!cpu_has_vmx_ept() \|\| !cpu_has_vmx_ept_4levels()) { enable_ept = 0; enable_unrestricted_guest = 0; enable_ept_ad_bits = 0; } if (!cpu_has_vmx_ept_ad_bits()) enable_ept_ad_bits = 0; if (!cpu_has_vmx_unrestricted_guest()) enable_unrestricted_guest = 0; if (!cpu_has_vmx_flexpriority()) flexpriority_enabled = 0; / * set_apic_access_page_addr() is used to reload apic access * page upon invalidation. No need to do anything if not * using the APIC_ACCESS_ADDR VMCS field. / if (!flexpriority_enabled) kvm_x86_ops->set_apic_access_page_addr = NULL; if (!cpu_has_vmx_tpr_shadow()) kvm_x86_ops->update_cr8_intercept = NULL; if (enable_ept && !cpu_has_vmx_ept_2m_page()) kvm_disable_largepages(); if (!cpu_has_vmx_ple()) ple_gap = 0; if (!cpu_has_vmx_apicv()) enable_apicv = 0; if (cpu_has_vmx_tsc_scaling()) { kvm_has_tsc_control = true; kvm_max_tsc_scaling_ratio = KVM_VMX_TSC_MULTIPLIER_MAX; kvm_tsc_scaling_ratio_frac_bits = 48; } vmx_disable_intercept_for_msr(MSR_FS_BASE, false); vmx_disable_intercept_for_msr(MSR_GS_BASE, false); vmx_disable_intercept_for_msr(MSR_KERNEL_GS_BASE, true); vmx_disable_intercept_for_msr(MSR_IA32_SYSENTER_CS, false); vmx_disable_intercept_for_msr(MSR_IA32_SYSENTER_ESP, false); vmx_disable_intercept_for_msr(MSR_IA32_SYSENTER_EIP, false); vmx_disable_intercept_for_msr(MSR_IA32_BNDCFGS, true); memcpy(vmx_msr_bitmap_legacy_x2apic, vmx_msr_bitmap_legacy, PAGE_SIZE); memcpy(vmx_msr_bitmap_longmode_x2apic, vmx_msr_bitmap_longmode, PAGE_SIZE); set_bit(0, vmx_vpid_bitmap); / 0 is reserved for host / for (msr = 0x800; msr <= 0x8ff; msr++) vmx_disable_intercept_msr_read_x2apic(msr); / According SDM, in x2apic mode, the whole id reg is used. But in * KVM, it only use the highest eight bits. Need to intercept it / vmx_enable_intercept_msr_read_x2apic(0x802); / TMCCT / vmx_enable_intercept_msr_read_x2apic(0x839); / TPR / vmx_disable_intercept_msr_write_x2apic(0x808); / EOI / vmx_disable_intercept_msr_write_x2apic(0x80b); / SELF-IPI / vmx_disable_intercept_msr_write_x2apic(0x83f); if (enable_ept) { kvm_mmu_set_mask_ptes(0ull, (enable_ept_ad_bits) ? VMX_EPT_ACCESS_BIT : 0ull, (enable_ept_ad_bits) ? VMX_EPT_DIRTY_BIT : 0ull, 0ull, VMX_EPT_EXECUTABLE_MASK); ept_set_mmio_spte_mask(); kvm_enable_tdp(); } else kvm_disable_tdp(); update_ple_window_actual_max(); / * Only enable PML when hardware supports PML feature, and both EPT * and EPT A/D bit features are enabled -- PML depends on them to work. / if (!enable_ept \|\| !enable_ept_ad_bits \|\| !cpu_has_vmx_pml()) enable_pml = 0; if (!enable_pml) { kvm_x86_ops->slot_enable_log_dirty = NULL; kvm_x86_ops->slot_disable_log_dirty = NULL; kvm_x86_ops->flush_log_dirty = NULL; kvm_x86_ops->enable_log_dirty_pt_masked = NULL; } kvm_set_posted_intr_wakeup_handler(wakeup_handler); return alloc_kvm_area(); out8: free_page((unsigned long)vmx_vmwrite_bitmap); out7: free_page((unsigned long)vmx_vmread_bitmap); out6: if (nested) free_page((unsigned long)vmx_msr_bitmap_nested); out5: free_page((unsigned long)vmx_msr_bitmap_longmode_x2apic); out4: free_page((unsigned long)vmx_msr_bitmap_longmode); out3: free_page((unsigned long)vmx_msr_bitmap_legacy_x2apic); out2: free_page((unsigned long)vmx_msr_bitmap_legacy); out1: free_page((unsigned long)vmx_io_bitmap_b); out: free_page((unsigned long)vmx_io_bitmap_a); return r; } static __exit void hardware_unsetup(void) { free_page((unsigned long)vmx_msr_bitmap_legacy_x2apic); free_page((unsigned long)vmx_msr_bitmap_longmode_x2apic); free_page((unsigned long)vmx_msr_bitmap_legacy); free_page((unsigned long)vmx_msr_bitmap_longmode); free_page((unsigned long)vmx_io_bitmap_b); free_page((unsigned long)vmx_io_bitmap_a); free_page((unsigned long)vmx_vmwrite_bitmap); free_page((unsigned long)vmx_vmread_bitmap); if (nested) free_page((unsigned long)vmx_msr_bitmap_nested); free_kvm_area(); } / * Indicate a busy-waiting vcpu in spinlock. We do not enable the PAUSE * exiting, so only get here on cpu with PAUSE-Loop-Exiting. / static int handle_pause(struct kvm_vcpu vcpu) { if (ple_gap) grow_ple_window(vcpu); skip_emulated_instruction(vcpu); kvm_vcpu_on_spin(vcpu); return 1; } static int handle_nop(struct kvm_vcpu vcpu) { skip_emulated_instruction(vcpu); return 1; } static int handle_mwait(struct kvm_vcpu vcpu) { printk_once(KERN_WARNING "kvm: MWAIT instruction emulated as NOP!\n"); return handle_nop(vcpu); } static int handle_monitor_trap(struct kvm_vcpu vcpu) { return 1; } static int handle_monitor(struct kvm_vcpu vcpu) { printk_once(KERN_WARNING "kvm: MONITOR instruction emulated as NOP!\n"); return handle_nop(vcpu); } /* * To run an L2 guest, we need a vmcs02 based on the L1-specified vmcs12. * We could reuse a single VMCS for all the L2 guests, but we also want the * option to allocate a separate vmcs02 for each separate loaded vmcs12 - this * allows keeping them loaded on the processor, and in the future will allow * optimizations where prepare_vmcs02 doesn't need to set all the fields on * every entry if they never change. * So we keep, in vmx->nested.vmcs02_pool, a cache of size VMCS02_POOL_SIZE * (>=0) with a vmcs02 for each recently loaded vmcs12s, most recent first. * * The following functions allocate and free a vmcs02 in this pool. / / Get a VMCS from the pool to use as vmcs02 for the current vmcs12. / static struct loaded_vmcs nested_get_current_vmcs02(struct vcpu_vmx vmx) { struct vmcs02_list item; list_for_each_entry(item, &vmx->nested.vmcs02_pool, list) if (item->vmptr == vmx->nested.current_vmptr) { list_move(&item->list, &vmx->nested.vmcs02_pool); return &item->vmcs02; } if (vmx->nested.vmcs02_num >= max(VMCS02_POOL_SIZE, 1)) { /* Recycle the least recently used VMCS. / item = list_last_entry(&vmx->nested.vmcs02_pool, struct vmcs02_list, list); item->vmptr = vmx->nested.current_vmptr; list_move(&item->list, &vmx->nested.vmcs02_pool); return &item->vmcs02; } / Create a new VMCS / item = kmalloc(sizeof(struct vmcs02_list), GFP_KERNEL); if (!item) return NULL; item->vmcs02.vmcs = alloc_vmcs(); if (!item->vmcs02.vmcs) { kfree(item); return NULL; } loaded_vmcs_init(&item->vmcs02); item->vmptr = vmx->nested.current_vmptr; list_add(&(item->list), &(vmx->nested.vmcs02_pool)); vmx->nested.vmcs02_num++; return &item->vmcs02; } / Free and remove from pool a vmcs02 saved for a vmcs12 (if there is one) / static void nested_free_vmcs02(struct vcpu_vmx vmx, gpa_t vmptr) { struct vmcs02_list item; list_for_each_entry(item, &vmx->nested.vmcs02_pool, list) if (item->vmptr == vmptr) { free_loaded_vmcs(&item->vmcs02); list_del(&item->list); kfree(item); vmx->nested.vmcs02_num--; return; } } / * Free all VMCSs saved for this vcpu, except the one pointed by * vmx->loaded_vmcs. We must be running L1, so vmx->loaded_vmcs * must be &vmx->vmcs01. / static void nested_free_all_saved_vmcss(struct vcpu_vmx vmx) { struct vmcs02_list item, n; WARN_ON(vmx->loaded_vmcs != &vmx->vmcs01); list_for_each_entry_safe(item, n, &vmx->nested.vmcs02_pool, list) { /* * Something will leak if the above WARN triggers. Better than * a use-after-free. / if (vmx->loaded_vmcs == &item->vmcs02) continue; free_loaded_vmcs(&item->vmcs02); list_del(&item->list); kfree(item); vmx->nested.vmcs02_num--; } } / * The following 3 functions, nested_vmx_succeed()/failValid()/failInvalid(), * set the success or error code of an emulated VMX instruction, as specified * by Vol 2B, VMX Instruction Reference, "Conventions". / static void nested_vmx_succeed(struct kvm_vcpu vcpu) { vmx_set_rflags(vcpu, vmx_get_rflags(vcpu) & ~(X86_EFLAGS_CF \| X86_EFLAGS_PF \| X86_EFLAGS_AF \| X86_EFLAGS_ZF \| X86_EFLAGS_SF \| X86_EFLAGS_OF)); } static void nested_vmx_failInvalid(struct kvm_vcpu vcpu) { vmx_set_rflags(vcpu, (vmx_get_rflags(vcpu) & ~(X86_EFLAGS_PF \| X86_EFLAGS_AF \| X86_EFLAGS_ZF \| X86_EFLAGS_SF \| X86_EFLAGS_OF)) \| X86_EFLAGS_CF); } static void nested_vmx_failValid(struct kvm_vcpu vcpu, u32 vm_instruction_error) { if (to_vmx(vcpu)->nested.current_vmptr == -1ull) { /* * failValid writes the error number to the current VMCS, which * can't be done there isn't a current VMCS. / nested_vmx_failInvalid(vcpu); return; } vmx_set_rflags(vcpu, (vmx_get_rflags(vcpu) & ~(X86_EFLAGS_CF \| X86_EFLAGS_PF \| X86_EFLAGS_AF \| X86_EFLAGS_SF \| X86_EFLAGS_OF)) \| X86_EFLAGS_ZF); get_vmcs12(vcpu)->vm_instruction_error = vm_instruction_error; / * We don't need to force a shadow sync because * VM_INSTRUCTION_ERROR is not shadowed / } static void nested_vmx_abort(struct kvm_vcpu vcpu, u32 indicator) { /* TODO: not to reset guest simply here. / kvm_make_request(KVM_REQ_TRIPLE_FAULT, vcpu); pr_warn("kvm: nested vmx abort, indicator %d\n", indicator); } static enum hrtimer_restart vmx_preemption_timer_fn(struct hrtimer timer) { struct vcpu_vmx vmx = container_of(timer, struct vcpu_vmx, nested.preemption_timer); vmx->nested.preemption_timer_expired = true; kvm_make_request(KVM_REQ_EVENT, &vmx->vcpu); kvm_vcpu_kick(&vmx->vcpu); return HRTIMER_NORESTART; } / * Decode the memory-address operand of a vmx instruction, as recorded on an * exit caused by such an instruction (run by a guest hypervisor). * On success, returns 0. When the operand is invalid, returns 1 and throws * #UD or #GP. / static int get_vmx_mem_address(struct kvm_vcpu vcpu, unsigned long exit_qualification, u32 vmx_instruction_info, bool wr, gva_t ret) { gva_t off; bool exn; struct kvm_segment s; / * According to Vol. 3B, "Information for VM Exits Due to Instruction * Execution", on an exit, vmx_instruction_info holds most of the * addressing components of the operand. Only the displacement part * is put in exit_qualification (see 3B, "Basic VM-Exit Information"). * For how an actual address is calculated from all these components, * refer to Vol. 1, "Operand Addressing". / int scaling = vmx_instruction_info & 3; int addr_size = (vmx_instruction_info >> 7) & 7; bool is_reg = vmx_instruction_info & (1u << 10); int seg_reg = (vmx_instruction_info >> 15) & 7; int index_reg = (vmx_instruction_info >> 18) & 0xf; bool index_is_valid = !(vmx_instruction_info & (1u << 22)); int base_reg = (vmx_instruction_info >> 23) & 0xf; bool base_is_valid = !(vmx_instruction_info & (1u << 27)); if (is_reg) { kvm_queue_exception(vcpu, UD_VECTOR); return 1; } / Addr = segment_base + offset / / offset = base + [index * scale] + displacement / off = exit_qualification; / holds the displacement / if (base_is_valid) off += kvm_register_read(vcpu, base_reg); if (index_is_valid) off += kvm_register_read(vcpu, index_reg)<<scaling; vmx_get_segment(vcpu, &s, seg_reg); ret = s.base + off; if (addr_size == 1) /* 32 bit / ret &= 0xffffffff; /* Checks for #GP/#SS exceptions. / exn = false; if (is_protmode(vcpu)) { / Protected mode: apply checks for segment validity in the * following order: * - segment type check (#GP(0) may be thrown) * - usability check (#GP(0)/#SS(0)) * - limit check (#GP(0)/#SS(0)) / if (wr) / #GP(0) if the destination operand is located in a * read-only data segment or any code segment. / exn = ((s.type & 0xa) == 0 \|\| (s.type & 8)); else / #GP(0) if the source operand is located in an * execute-only code segment / exn = ((s.type & 0xa) == 8); } if (exn) { kvm_queue_exception_e(vcpu, GP_VECTOR, 0); return 1; } if (is_long_mode(vcpu)) { / Long mode: #GP(0)/#SS(0) if the memory address is in a * non-canonical form. This is an only check for long mode. / exn = is_noncanonical_address(ret); } else if (is_protmode(vcpu)) { /* Protected mode: #GP(0)/#SS(0) if the segment is unusable. / exn = (s.unusable != 0); / Protected mode: #GP(0)/#SS(0) if the memory * operand is outside the segment limit. / exn = exn \|\| (off + sizeof(u64) > s.limit); } if (exn) { kvm_queue_exception_e(vcpu, seg_reg == VCPU_SREG_SS ? SS_VECTOR : GP_VECTOR, 0); return 1; } return 0; } / * This function performs the various checks including * - if it's 4KB aligned * - No bits beyond the physical address width are set * - Returns 0 on success or else 1 * (Intel SDM Section 30.3) / static int nested_vmx_check_vmptr(struct kvm_vcpu vcpu, int exit_reason, gpa_t vmpointer) { gva_t gva; gpa_t vmptr; struct x86_exception e; struct page page; struct vcpu_vmx vmx = to_vmx(vcpu); int maxphyaddr = cpuid_maxphyaddr(vcpu); if (get_vmx_mem_address(vcpu, vmcs_readl(EXIT_QUALIFICATION), vmcs_read32(VMX_INSTRUCTION_INFO), false, &gva)) return 1; if (kvm_read_guest_virt(&vcpu->arch.emulate_ctxt, gva, &vmptr, sizeof(vmptr), &e)) { kvm_inject_page_fault(vcpu, &e); return 1; } switch (exit_reason) { case EXIT_REASON_VMON: / * SDM 3: 24.11.5 * The first 4 bytes of VMXON region contain the supported * VMCS revision identifier * * Note - IA32_VMX_BASIC[48] will never be 1 * for the nested case; * which replaces physical address width with 32 * / if (!PAGE_ALIGNED(vmptr) \|\| (vmptr >> maxphyaddr)) { nested_vmx_failInvalid(vcpu); skip_emulated_instruction(vcpu); return 1; } page = nested_get_page(vcpu, vmptr); if (page == NULL \|\| (u32 )kmap(page) != VMCS12_REVISION) { nested_vmx_failInvalid(vcpu); kunmap(page); skip_emulated_instruction(vcpu); return 1; } kunmap(page); vmx->nested.vmxon_ptr = vmptr; break; case EXIT_REASON_VMCLEAR: if (!PAGE_ALIGNED(vmptr) \|\| (vmptr >> maxphyaddr)) { nested_vmx_failValid(vcpu, VMXERR_VMCLEAR_INVALID_ADDRESS); skip_emulated_instruction(vcpu); return 1; } if (vmptr == vmx->nested.vmxon_ptr) { nested_vmx_failValid(vcpu, VMXERR_VMCLEAR_VMXON_POINTER); skip_emulated_instruction(vcpu); return 1; } break; case EXIT_REASON_VMPTRLD: if (!PAGE_ALIGNED(vmptr) \|\| (vmptr >> maxphyaddr)) { nested_vmx_failValid(vcpu, VMXERR_VMPTRLD_INVALID_ADDRESS); skip_emulated_instruction(vcpu); return 1; } if (vmptr == vmx->nested.vmxon_ptr) { nested_vmx_failValid(vcpu, VMXERR_VMCLEAR_VMXON_POINTER); skip_emulated_instruction(vcpu); return 1; } break; default: return 1; / shouldn't happen / } if (vmpointer) vmpointer = vmptr; return 0; } /* * Emulate the VMXON instruction. * Currently, we just remember that VMX is active, and do not save or even * inspect the argument to VMXON (the so-called "VMXON pointer") because we * do not currently need to store anything in that guest-allocated memory * region. Consequently, VMCLEAR and VMPTRLD also do not verify that the their * argument is different from the VMXON pointer (which the spec says they do). / static int handle_vmon(struct kvm_vcpu vcpu) { struct kvm_segment cs; struct vcpu_vmx vmx = to_vmx(vcpu); struct vmcs shadow_vmcs; const u64 VMXON_NEEDED_FEATURES = FEATURE_CONTROL_LOCKED \| FEATURE_CONTROL_VMXON_ENABLED_OUTSIDE_SMX; /* The Intel VMX Instruction Reference lists a bunch of bits that * are prerequisite to running VMXON, most notably cr4.VMXE must be * set to 1 (see vmx_set_cr4() for when we allow the guest to set this). * Otherwise, we should fail with #UD. We test these now: / if (!kvm_read_cr4_bits(vcpu, X86_CR4_VMXE) \|\| !kvm_read_cr0_bits(vcpu, X86_CR0_PE) \|\| (vmx_get_rflags(vcpu) & X86_EFLAGS_VM)) { kvm_queue_exception(vcpu, UD_VECTOR); return 1; } vmx_get_segment(vcpu, &cs, VCPU_SREG_CS); if (is_long_mode(vcpu) && !cs.l) { kvm_queue_exception(vcpu, UD_VECTOR); return 1; } if (vmx_get_cpl(vcpu)) { kvm_inject_gp(vcpu, 0); return 1; } if (nested_vmx_check_vmptr(vcpu, EXIT_REASON_VMON, NULL)) return 1; if (vmx->nested.vmxon) { nested_vmx_failValid(vcpu, VMXERR_VMXON_IN_VMX_ROOT_OPERATION); skip_emulated_instruction(vcpu); return 1; } if ((vmx->nested.msr_ia32_feature_control & VMXON_NEEDED_FEATURES) != VMXON_NEEDED_FEATURES) { kvm_inject_gp(vcpu, 0); return 1; } if (enable_shadow_vmcs) { shadow_vmcs = alloc_vmcs(); if (!shadow_vmcs) return -ENOMEM; / mark vmcs as shadow / shadow_vmcs->revision_id \|= (1u << 31); / init shadow vmcs / vmcs_clear(shadow_vmcs); vmx->nested.current_shadow_vmcs = shadow_vmcs; } INIT_LIST_HEAD(&(vmx->nested.vmcs02_pool)); vmx->nested.vmcs02_num = 0; hrtimer_init(&vmx->nested.preemption_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); vmx->nested.preemption_timer.function = vmx_preemption_timer_fn; vmx->nested.vmxon = true; skip_emulated_instruction(vcpu); nested_vmx_succeed(vcpu); return 1; } / * Intel's VMX Instruction Reference specifies a common set of prerequisites * for running VMX instructions (except VMXON, whose prerequisites are * slightly different). It also specifies what exception to inject otherwise. / static int nested_vmx_check_permission(struct kvm_vcpu vcpu) { struct kvm_segment cs; struct vcpu_vmx vmx = to_vmx(vcpu); if (!vmx->nested.vmxon) { kvm_queue_exception(vcpu, UD_VECTOR); return 0; } vmx_get_segment(vcpu, &cs, VCPU_SREG_CS); if ((vmx_get_rflags(vcpu) & X86_EFLAGS_VM) \|\| (is_long_mode(vcpu) && !cs.l)) { kvm_queue_exception(vcpu, UD_VECTOR); return 0; } if (vmx_get_cpl(vcpu)) { kvm_inject_gp(vcpu, 0); return 0; } return 1; } static inline void nested_release_vmcs12(struct vcpu_vmx vmx) { if (vmx->nested.current_vmptr == -1ull) return; /* current_vmptr and current_vmcs12 are always set/reset together / if (WARN_ON(vmx->nested.current_vmcs12 == NULL)) return; if (enable_shadow_vmcs) { / copy to memory all shadowed fields in case they were modified / copy_shadow_to_vmcs12(vmx); vmx->nested.sync_shadow_vmcs = false; vmcs_clear_bits(SECONDARY_VM_EXEC_CONTROL, SECONDARY_EXEC_SHADOW_VMCS); vmcs_write64(VMCS_LINK_POINTER, -1ull); } vmx->nested.posted_intr_nv = -1; kunmap(vmx->nested.current_vmcs12_page); nested_release_page(vmx->nested.current_vmcs12_page); vmx->nested.current_vmptr = -1ull; vmx->nested.current_vmcs12 = NULL; } / * Free whatever needs to be freed from vmx->nested when L1 goes down, or * just stops using VMX. / static void free_nested(struct vcpu_vmx vmx) { if (!vmx->nested.vmxon) return; vmx->nested.vmxon = false; free_vpid(vmx->nested.vpid02); nested_release_vmcs12(vmx); if (enable_shadow_vmcs) free_vmcs(vmx->nested.current_shadow_vmcs); /* Unpin physical memory we referred to in current vmcs02 / if (vmx->nested.apic_access_page) { nested_release_page(vmx->nested.apic_access_page); vmx->nested.apic_access_page = NULL; } if (vmx->nested.virtual_apic_page) { nested_release_page(vmx->nested.virtual_apic_page); vmx->nested.virtual_apic_page = NULL; } if (vmx->nested.pi_desc_page) { kunmap(vmx->nested.pi_desc_page); nested_release_page(vmx->nested.pi_desc_page); vmx->nested.pi_desc_page = NULL; vmx->nested.pi_desc = NULL; } nested_free_all_saved_vmcss(vmx); } / Emulate the VMXOFF instruction / static int handle_vmoff(struct kvm_vcpu vcpu) { if (!nested_vmx_check_permission(vcpu)) return 1; free_nested(to_vmx(vcpu)); skip_emulated_instruction(vcpu); nested_vmx_succeed(vcpu); return 1; } /* Emulate the VMCLEAR instruction / static int handle_vmclear(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); gpa_t vmptr; struct vmcs12 vmcs12; struct page page; if (!nested_vmx_check_permission(vcpu)) return 1; if (nested_vmx_check_vmptr(vcpu, EXIT_REASON_VMCLEAR, &vmptr)) return 1; if (vmptr == vmx->nested.current_vmptr) nested_release_vmcs12(vmx); page = nested_get_page(vcpu, vmptr); if (page == NULL) { / * For accurate processor emulation, VMCLEAR beyond available * physical memory should do nothing at all. However, it is * possible that a nested vmx bug, not a guest hypervisor bug, * resulted in this case, so let's shut down before doing any * more damage: / kvm_make_request(KVM_REQ_TRIPLE_FAULT, vcpu); return 1; } vmcs12 = kmap(page); vmcs12->launch_state = 0; kunmap(page); nested_release_page(page); nested_free_vmcs02(vmx, vmptr); skip_emulated_instruction(vcpu); nested_vmx_succeed(vcpu); return 1; } static int nested_vmx_run(struct kvm_vcpu vcpu, bool launch); /* Emulate the VMLAUNCH instruction / static int handle_vmlaunch(struct kvm_vcpu vcpu) { return nested_vmx_run(vcpu, true); } /* Emulate the VMRESUME instruction / static int handle_vmresume(struct kvm_vcpu vcpu) { return nested_vmx_run(vcpu, false); } enum vmcs_field_type { VMCS_FIELD_TYPE_U16 = 0, VMCS_FIELD_TYPE_U64 = 1, VMCS_FIELD_TYPE_U32 = 2, VMCS_FIELD_TYPE_NATURAL_WIDTH = 3 }; static inline int vmcs_field_type(unsigned long field) { if (0x1 & field) /* the _HIGH fields are all 32 bit / return VMCS_FIELD_TYPE_U32; return (field >> 13) & 0x3 ; } static inline int vmcs_field_readonly(unsigned long field) { return (((field >> 10) & 0x3) == 1); } /* * Read a vmcs12 field. Since these can have varying lengths and we return * one type, we chose the biggest type (u64) and zero-extend the return value * to that size. Note that the caller, handle_vmread, might need to use only * some of the bits we return here (e.g., on 32-bit guests, only 32 bits of * 64-bit fields are to be returned). / static inline int vmcs12_read_any(struct kvm_vcpu vcpu, unsigned long field, u64 ret) { short offset = vmcs_field_to_offset(field); char p; if (offset < 0) return offset; p = ((char )(get_vmcs12(vcpu))) + offset; switch (vmcs_field_type(field)) { case VMCS_FIELD_TYPE_NATURAL_WIDTH: ret = ((natural_width )p); return 0; case VMCS_FIELD_TYPE_U16: ret = ((u16 )p); return 0; case VMCS_FIELD_TYPE_U32: ret = ((u32 )p); return 0; case VMCS_FIELD_TYPE_U64: ret = ((u64 )p); return 0; default: WARN_ON(1); return -ENOENT; } } static inline int vmcs12_write_any(struct kvm_vcpu vcpu, unsigned long field, u64 field_value){ short offset = vmcs_field_to_offset(field); char p = ((char ) get_vmcs12(vcpu)) + offset; if (offset < 0) return offset; switch (vmcs_field_type(field)) { case VMCS_FIELD_TYPE_U16: (u16 )p = field_value; return 0; case VMCS_FIELD_TYPE_U32: (u32 )p = field_value; return 0; case VMCS_FIELD_TYPE_U64: (u64 )p = field_value; return 0; case VMCS_FIELD_TYPE_NATURAL_WIDTH: (natural_width )p = field_value; return 0; default: WARN_ON(1); return -ENOENT; } } static void copy_shadow_to_vmcs12(struct vcpu_vmx vmx) { int i; unsigned long field; u64 field_value; struct vmcs shadow_vmcs = vmx->nested.current_shadow_vmcs; const unsigned long fields = shadow_read_write_fields; const int num_fields = max_shadow_read_write_fields; preempt_disable(); vmcs_load(shadow_vmcs); for (i = 0; i < num_fields; i++) { field = fields[i]; switch (vmcs_field_type(field)) { case VMCS_FIELD_TYPE_U16: field_value = vmcs_read16(field); break; case VMCS_FIELD_TYPE_U32: field_value = vmcs_read32(field); break; case VMCS_FIELD_TYPE_U64: field_value = vmcs_read64(field); break; case VMCS_FIELD_TYPE_NATURAL_WIDTH: field_value = vmcs_readl(field); break; default: WARN_ON(1); continue; } vmcs12_write_any(&vmx->vcpu, field, field_value); } vmcs_clear(shadow_vmcs); vmcs_load(vmx->loaded_vmcs->vmcs); preempt_enable(); } static void copy_vmcs12_to_shadow(struct vcpu_vmx vmx) { const unsigned long fields[] = { shadow_read_write_fields, shadow_read_only_fields }; const int max_fields[] = { max_shadow_read_write_fields, max_shadow_read_only_fields }; int i, q; unsigned long field; u64 field_value = 0; struct vmcs shadow_vmcs = vmx->nested.current_shadow_vmcs; vmcs_load(shadow_vmcs); for (q = 0; q < ARRAY_SIZE(fields); q++) { for (i = 0; i < max_fields[q]; i++) { field = fields[q][i]; vmcs12_read_any(&vmx->vcpu, field, &field_value); switch (vmcs_field_type(field)) { case VMCS_FIELD_TYPE_U16: vmcs_write16(field, (u16)field_value); break; case VMCS_FIELD_TYPE_U32: vmcs_write32(field, (u32)field_value); break; case VMCS_FIELD_TYPE_U64: vmcs_write64(field, (u64)field_value); break; case VMCS_FIELD_TYPE_NATURAL_WIDTH: vmcs_writel(field, (long)field_value); break; default: WARN_ON(1); break; } } } vmcs_clear(shadow_vmcs); vmcs_load(vmx->loaded_vmcs->vmcs); } /* * VMX instructions which assume a current vmcs12 (i.e., that VMPTRLD was * used before) all generate the same failure when it is missing. / static int nested_vmx_check_vmcs12(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); if (vmx->nested.current_vmptr == -1ull) { nested_vmx_failInvalid(vcpu); skip_emulated_instruction(vcpu); return 0; } return 1; } static int handle_vmread(struct kvm_vcpu vcpu) { unsigned long field; u64 field_value; unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION); u32 vmx_instruction_info = vmcs_read32(VMX_INSTRUCTION_INFO); gva_t gva = 0; if (!nested_vmx_check_permission(vcpu) \|\| !nested_vmx_check_vmcs12(vcpu)) return 1; /* Decode instruction info and find the field to read / field = kvm_register_readl(vcpu, (((vmx_instruction_info) >> 28) & 0xf)); / Read the field, zero-extended to a u64 field_value / if (vmcs12_read_any(vcpu, field, &field_value) < 0) { nested_vmx_failValid(vcpu, VMXERR_UNSUPPORTED_VMCS_COMPONENT); skip_emulated_instruction(vcpu); return 1; } / * Now copy part of this value to register or memory, as requested. * Note that the number of bits actually copied is 32 or 64 depending * on the guest's mode (32 or 64 bit), not on the given field's length. / if (vmx_instruction_info & (1u << 10)) { kvm_register_writel(vcpu, (((vmx_instruction_info) >> 3) & 0xf), field_value); } else { if (get_vmx_mem_address(vcpu, exit_qualification, vmx_instruction_info, true, &gva)) return 1; / _system ok, as nested_vmx_check_permission verified cpl=0 / kvm_write_guest_virt_system(&vcpu->arch.emulate_ctxt, gva, &field_value, (is_long_mode(vcpu) ? 8 : 4), NULL); } nested_vmx_succeed(vcpu); skip_emulated_instruction(vcpu); return 1; } static int handle_vmwrite(struct kvm_vcpu vcpu) { unsigned long field; gva_t gva; unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION); u32 vmx_instruction_info = vmcs_read32(VMX_INSTRUCTION_INFO); /* The value to write might be 32 or 64 bits, depending on L1's long * mode, and eventually we need to write that into a field of several * possible lengths. The code below first zero-extends the value to 64 * bit (field_value), and then copies only the appropriate number of * bits into the vmcs12 field. / u64 field_value = 0; struct x86_exception e; if (!nested_vmx_check_permission(vcpu) \|\| !nested_vmx_check_vmcs12(vcpu)) return 1; if (vmx_instruction_info & (1u << 10)) field_value = kvm_register_readl(vcpu, (((vmx_instruction_info) >> 3) & 0xf)); else { if (get_vmx_mem_address(vcpu, exit_qualification, vmx_instruction_info, false, &gva)) return 1; if (kvm_read_guest_virt(&vcpu->arch.emulate_ctxt, gva, &field_value, (is_64_bit_mode(vcpu) ? 8 : 4), &e)) { kvm_inject_page_fault(vcpu, &e); return 1; } } field = kvm_register_readl(vcpu, (((vmx_instruction_info) >> 28) & 0xf)); if (vmcs_field_readonly(field)) { nested_vmx_failValid(vcpu, VMXERR_VMWRITE_READ_ONLY_VMCS_COMPONENT); skip_emulated_instruction(vcpu); return 1; } if (vmcs12_write_any(vcpu, field, field_value) < 0) { nested_vmx_failValid(vcpu, VMXERR_UNSUPPORTED_VMCS_COMPONENT); skip_emulated_instruction(vcpu); return 1; } nested_vmx_succeed(vcpu); skip_emulated_instruction(vcpu); return 1; } / Emulate the VMPTRLD instruction / static int handle_vmptrld(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); gpa_t vmptr; if (!nested_vmx_check_permission(vcpu)) return 1; if (nested_vmx_check_vmptr(vcpu, EXIT_REASON_VMPTRLD, &vmptr)) return 1; if (vmx->nested.current_vmptr != vmptr) { struct vmcs12 new_vmcs12; struct page page; page = nested_get_page(vcpu, vmptr); if (page == NULL) { nested_vmx_failInvalid(vcpu); skip_emulated_instruction(vcpu); return 1; } new_vmcs12 = kmap(page); if (new_vmcs12->revision_id != VMCS12_REVISION) { kunmap(page); nested_release_page_clean(page); nested_vmx_failValid(vcpu, VMXERR_VMPTRLD_INCORRECT_VMCS_REVISION_ID); skip_emulated_instruction(vcpu); return 1; } nested_release_vmcs12(vmx); vmx->nested.current_vmptr = vmptr; vmx->nested.current_vmcs12 = new_vmcs12; vmx->nested.current_vmcs12_page = page; if (enable_shadow_vmcs) { vmcs_set_bits(SECONDARY_VM_EXEC_CONTROL, SECONDARY_EXEC_SHADOW_VMCS); vmcs_write64(VMCS_LINK_POINTER, __pa(vmx->nested.current_shadow_vmcs)); vmx->nested.sync_shadow_vmcs = true; } } nested_vmx_succeed(vcpu); skip_emulated_instruction(vcpu); return 1; } / Emulate the VMPTRST instruction / static int handle_vmptrst(struct kvm_vcpu vcpu) { unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION); u32 vmx_instruction_info = vmcs_read32(VMX_INSTRUCTION_INFO); gva_t vmcs_gva; struct x86_exception e; if (!nested_vmx_check_permission(vcpu)) return 1; if (get_vmx_mem_address(vcpu, exit_qualification, vmx_instruction_info, true, &vmcs_gva)) return 1; /* ok to use _system, as nested_vmx_check_permission verified cpl=0 / if (kvm_write_guest_virt_system(&vcpu->arch.emulate_ctxt, vmcs_gva, (void )&to_vmx(vcpu)->nested.current_vmptr, sizeof(u64), &e)) { kvm_inject_page_fault(vcpu, &e); return 1; } nested_vmx_succeed(vcpu); skip_emulated_instruction(vcpu); return 1; } / Emulate the INVEPT instruction / static int handle_invept(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); u32 vmx_instruction_info, types; unsigned long type; gva_t gva; struct x86_exception e; struct { u64 eptp, gpa; } operand; if (!(vmx->nested.nested_vmx_secondary_ctls_high & SECONDARY_EXEC_ENABLE_EPT) \|\| !(vmx->nested.nested_vmx_ept_caps & VMX_EPT_INVEPT_BIT)) { kvm_queue_exception(vcpu, UD_VECTOR); return 1; } if (!nested_vmx_check_permission(vcpu)) return 1; if (!kvm_read_cr0_bits(vcpu, X86_CR0_PE)) { kvm_queue_exception(vcpu, UD_VECTOR); return 1; } vmx_instruction_info = vmcs_read32(VMX_INSTRUCTION_INFO); type = kvm_register_readl(vcpu, (vmx_instruction_info >> 28) & 0xf); types = (vmx->nested.nested_vmx_ept_caps >> VMX_EPT_EXTENT_SHIFT) & 6; if (!(types & (1UL << type))) { nested_vmx_failValid(vcpu, VMXERR_INVALID_OPERAND_TO_INVEPT_INVVPID); skip_emulated_instruction(vcpu); return 1; } / According to the Intel VMX instruction reference, the memory * operand is read even if it isn't needed (e.g., for type==global) / if (get_vmx_mem_address(vcpu, vmcs_readl(EXIT_QUALIFICATION), vmx_instruction_info, false, &gva)) return 1; if (kvm_read_guest_virt(&vcpu->arch.emulate_ctxt, gva, &operand, sizeof(operand), &e)) { kvm_inject_page_fault(vcpu, &e); return 1; } switch (type) { case VMX_EPT_EXTENT_GLOBAL: kvm_mmu_sync_roots(vcpu); kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu); nested_vmx_succeed(vcpu); break; default: / Trap single context invalidation invept calls / BUG_ON(1); break; } skip_emulated_instruction(vcpu); return 1; } static int handle_invvpid(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); u32 vmx_instruction_info; unsigned long type, types; gva_t gva; struct x86_exception e; int vpid; if (!(vmx->nested.nested_vmx_secondary_ctls_high & SECONDARY_EXEC_ENABLE_VPID) \|\| !(vmx->nested.nested_vmx_vpid_caps & VMX_VPID_INVVPID_BIT)) { kvm_queue_exception(vcpu, UD_VECTOR); return 1; } if (!nested_vmx_check_permission(vcpu)) return 1; vmx_instruction_info = vmcs_read32(VMX_INSTRUCTION_INFO); type = kvm_register_readl(vcpu, (vmx_instruction_info >> 28) & 0xf); types = (vmx->nested.nested_vmx_vpid_caps >> 8) & 0x7; if (!(types & (1UL << type))) { nested_vmx_failValid(vcpu, VMXERR_INVALID_OPERAND_TO_INVEPT_INVVPID); skip_emulated_instruction(vcpu); return 1; } / according to the intel vmx instruction reference, the memory * operand is read even if it isn't needed (e.g., for type==global) / if (get_vmx_mem_address(vcpu, vmcs_readl(EXIT_QUALIFICATION), vmx_instruction_info, false, &gva)) return 1; if (kvm_read_guest_virt(&vcpu->arch.emulate_ctxt, gva, &vpid, sizeof(u32), &e)) { kvm_inject_page_fault(vcpu, &e); return 1; } switch (type) { case VMX_VPID_EXTENT_SINGLE_CONTEXT: / * Old versions of KVM use the single-context version so we * have to support it; just treat it the same as all-context. / case VMX_VPID_EXTENT_ALL_CONTEXT: __vmx_flush_tlb(vcpu, to_vmx(vcpu)->nested.vpid02); nested_vmx_succeed(vcpu); break; default: / Trap individual address invalidation invvpid calls / BUG_ON(1); break; } skip_emulated_instruction(vcpu); return 1; } static int handle_pml_full(struct kvm_vcpu vcpu) { unsigned long exit_qualification; trace_kvm_pml_full(vcpu->vcpu_id); exit_qualification = vmcs_readl(EXIT_QUALIFICATION); /* * PML buffer FULL happened while executing iret from NMI, * "blocked by NMI" bit has to be set before next VM entry. / if (!(to_vmx(vcpu)->idt_vectoring_info & VECTORING_INFO_VALID_MASK) && cpu_has_virtual_nmis() && (exit_qualification & INTR_INFO_UNBLOCK_NMI)) vmcs_set_bits(GUEST_INTERRUPTIBILITY_INFO, GUEST_INTR_STATE_NMI); / * PML buffer already flushed at beginning of VMEXIT. Nothing to do * here.., and there's no userspace involvement needed for PML. / return 1; } static int handle_pcommit(struct kvm_vcpu vcpu) { /* we never catch pcommit instruct for L1 guest. / WARN_ON(1); return 1; } / * The exit handlers return 1 if the exit was handled fully and guest execution * may resume. Otherwise they set the kvm_run parameter to indicate what needs * to be done to userspace and return 0. / static int (const kvm_vmx_exit_handlers[])(struct kvm_vcpu vcpu) = { [EXIT_REASON_EXCEPTION_NMI] = handle_exception, [EXIT_REASON_EXTERNAL_INTERRUPT] = handle_external_interrupt, [EXIT_REASON_TRIPLE_FAULT] = handle_triple_fault, [EXIT_REASON_NMI_WINDOW] = handle_nmi_window, [EXIT_REASON_IO_INSTRUCTION] = handle_io, [EXIT_REASON_CR_ACCESS] = handle_cr, [EXIT_REASON_DR_ACCESS] = handle_dr, [EXIT_REASON_CPUID] = handle_cpuid, [EXIT_REASON_MSR_READ] = handle_rdmsr, [EXIT_REASON_MSR_WRITE] = handle_wrmsr, [EXIT_REASON_PENDING_INTERRUPT] = handle_interrupt_window, [EXIT_REASON_HLT] = handle_halt, [EXIT_REASON_INVD] = handle_invd, [EXIT_REASON_INVLPG] = handle_invlpg, [EXIT_REASON_RDPMC] = handle_rdpmc, [EXIT_REASON_VMCALL] = handle_vmcall, [EXIT_REASON_VMCLEAR] = handle_vmclear, [EXIT_REASON_VMLAUNCH] = handle_vmlaunch, [EXIT_REASON_VMPTRLD] = handle_vmptrld, [EXIT_REASON_VMPTRST] = handle_vmptrst, [EXIT_REASON_VMREAD] = handle_vmread, [EXIT_REASON_VMRESUME] = handle_vmresume, [EXIT_REASON_VMWRITE] = handle_vmwrite, [EXIT_REASON_VMOFF] = handle_vmoff, [EXIT_REASON_VMON] = handle_vmon, [EXIT_REASON_TPR_BELOW_THRESHOLD] = handle_tpr_below_threshold, [EXIT_REASON_APIC_ACCESS] = handle_apic_access, [EXIT_REASON_APIC_WRITE] = handle_apic_write, [EXIT_REASON_EOI_INDUCED] = handle_apic_eoi_induced, [EXIT_REASON_WBINVD] = handle_wbinvd, [EXIT_REASON_XSETBV] = handle_xsetbv, [EXIT_REASON_TASK_SWITCH] = handle_task_switch, [EXIT_REASON_MCE_DURING_VMENTRY] = handle_machine_check, [EXIT_REASON_EPT_VIOLATION] = handle_ept_violation, [EXIT_REASON_EPT_MISCONFIG] = handle_ept_misconfig, [EXIT_REASON_PAUSE_INSTRUCTION] = handle_pause, [EXIT_REASON_MWAIT_INSTRUCTION] = handle_mwait, [EXIT_REASON_MONITOR_TRAP_FLAG] = handle_monitor_trap, [EXIT_REASON_MONITOR_INSTRUCTION] = handle_monitor, [EXIT_REASON_INVEPT] = handle_invept, [EXIT_REASON_INVVPID] = handle_invvpid, [EXIT_REASON_XSAVES] = handle_xsaves, [EXIT_REASON_XRSTORS] = handle_xrstors, [EXIT_REASON_PML_FULL] = handle_pml_full, [EXIT_REASON_PCOMMIT] = handle_pcommit, }; static const int kvm_vmx_max_exit_handlers = ARRAY_SIZE(kvm_vmx_exit_handlers); static bool nested_vmx_exit_handled_io(struct kvm_vcpu vcpu, struct vmcs12 vmcs12) { unsigned long exit_qualification; gpa_t bitmap, last_bitmap; unsigned int port; int size; u8 b; if (!nested_cpu_has(vmcs12, CPU_BASED_USE_IO_BITMAPS)) return nested_cpu_has(vmcs12, CPU_BASED_UNCOND_IO_EXITING); exit_qualification = vmcs_readl(EXIT_QUALIFICATION); port = exit_qualification >> 16; size = (exit_qualification & 7) + 1; last_bitmap = (gpa_t)-1; b = -1; while (size > 0) { if (port < 0x8000) bitmap = vmcs12->io_bitmap_a; else if (port < 0x10000) bitmap = vmcs12->io_bitmap_b; else return true; bitmap += (port & 0x7fff) / 8; if (last_bitmap != bitmap) if (kvm_vcpu_read_guest(vcpu, bitmap, &b, 1)) return true; if (b & (1 << (port & 7))) return true; port++; size--; last_bitmap = bitmap; } return false; } / * Return 1 if we should exit from L2 to L1 to handle an MSR access access, * rather than handle it ourselves in L0. I.e., check whether L1 expressed * disinterest in the current event (read or write a specific MSR) by using an * MSR bitmap. This may be the case even when L0 doesn't use MSR bitmaps. / static bool nested_vmx_exit_handled_msr(struct kvm_vcpu vcpu, struct vmcs12 vmcs12, u32 exit_reason) { u32 msr_index = vcpu->arch.regs[VCPU_REGS_RCX]; gpa_t bitmap; if (!nested_cpu_has(vmcs12, CPU_BASED_USE_MSR_BITMAPS)) return true; / * The MSR_BITMAP page is divided into four 1024-byte bitmaps, * for the four combinations of read/write and low/high MSR numbers. * First we need to figure out which of the four to use: / bitmap = vmcs12->msr_bitmap; if (exit_reason == EXIT_REASON_MSR_WRITE) bitmap += 2048; if (msr_index >= 0xc0000000) { msr_index -= 0xc0000000; bitmap += 1024; } / Then read the msr_index'th bit from this bitmap: / if (msr_index < 10248) { unsigned char b; if (kvm_vcpu_read_guest(vcpu, bitmap + msr_index/8, &b, 1)) return true; return 1 & (b >> (msr_index & 7)); } else return true; /* let L1 handle the wrong parameter / } / * Return 1 if we should exit from L2 to L1 to handle a CR access exit, * rather than handle it ourselves in L0. I.e., check if L1 wanted to * intercept (via guest_host_mask etc.) the current event. / static bool nested_vmx_exit_handled_cr(struct kvm_vcpu vcpu, struct vmcs12 vmcs12) { unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION); int cr = exit_qualification & 15; int reg = (exit_qualification >> 8) & 15; unsigned long val = kvm_register_readl(vcpu, reg); switch ((exit_qualification >> 4) & 3) { case 0: / mov to cr / switch (cr) { case 0: if (vmcs12->cr0_guest_host_mask & (val ^ vmcs12->cr0_read_shadow)) return true; break; case 3: if ((vmcs12->cr3_target_count >= 1 && vmcs12->cr3_target_value0 == val) \|\| (vmcs12->cr3_target_count >= 2 && vmcs12->cr3_target_value1 == val) \|\| (vmcs12->cr3_target_count >= 3 && vmcs12->cr3_target_value2 == val) \|\| (vmcs12->cr3_target_count >= 4 && vmcs12->cr3_target_value3 == val)) return false; if (nested_cpu_has(vmcs12, CPU_BASED_CR3_LOAD_EXITING)) return true; break; case 4: if (vmcs12->cr4_guest_host_mask & (vmcs12->cr4_read_shadow ^ val)) return true; break; case 8: if (nested_cpu_has(vmcs12, CPU_BASED_CR8_LOAD_EXITING)) return true; break; } break; case 2: / clts / if ((vmcs12->cr0_guest_host_mask & X86_CR0_TS) && (vmcs12->cr0_read_shadow & X86_CR0_TS)) return true; break; case 1: / mov from cr / switch (cr) { case 3: if (vmcs12->cpu_based_vm_exec_control & CPU_BASED_CR3_STORE_EXITING) return true; break; case 8: if (vmcs12->cpu_based_vm_exec_control & CPU_BASED_CR8_STORE_EXITING) return true; break; } break; case 3: / lmsw / / * lmsw can change bits 1..3 of cr0, and only set bit 0 of * cr0. Other attempted changes are ignored, with no exit. / if (vmcs12->cr0_guest_host_mask & 0xe & (val ^ vmcs12->cr0_read_shadow)) return true; if ((vmcs12->cr0_guest_host_mask & 0x1) && !(vmcs12->cr0_read_shadow & 0x1) && (val & 0x1)) return true; break; } return false; } / * Return 1 if we should exit from L2 to L1 to handle an exit, or 0 if we * should handle it ourselves in L0 (and then continue L2). Only call this * when in is_guest_mode (L2). / static bool nested_vmx_exit_handled(struct kvm_vcpu vcpu) { u32 intr_info = vmcs_read32(VM_EXIT_INTR_INFO); struct vcpu_vmx vmx = to_vmx(vcpu); struct vmcs12 vmcs12 = get_vmcs12(vcpu); u32 exit_reason = vmx->exit_reason; trace_kvm_nested_vmexit(kvm_rip_read(vcpu), exit_reason, vmcs_readl(EXIT_QUALIFICATION), vmx->idt_vectoring_info, intr_info, vmcs_read32(VM_EXIT_INTR_ERROR_CODE), KVM_ISA_VMX); if (vmx->nested.nested_run_pending) return false; if (unlikely(vmx->fail)) { pr_info_ratelimited("%s failed vm entry %x\n", __func__, vmcs_read32(VM_INSTRUCTION_ERROR)); return true; } switch (exit_reason) { case EXIT_REASON_EXCEPTION_NMI: if (!is_exception(intr_info)) return false; else if (is_page_fault(intr_info)) return enable_ept; else if (is_no_device(intr_info) && !(vmcs12->guest_cr0 & X86_CR0_TS)) return false; else if (is_debug(intr_info) && vcpu->guest_debug & (KVM_GUESTDBG_SINGLESTEP \| KVM_GUESTDBG_USE_HW_BP)) return false; else if (is_breakpoint(intr_info) && vcpu->guest_debug & KVM_GUESTDBG_USE_SW_BP) return false; return vmcs12->exception_bitmap & (1u << (intr_info & INTR_INFO_VECTOR_MASK)); case EXIT_REASON_EXTERNAL_INTERRUPT: return false; case EXIT_REASON_TRIPLE_FAULT: return true; case EXIT_REASON_PENDING_INTERRUPT: return nested_cpu_has(vmcs12, CPU_BASED_VIRTUAL_INTR_PENDING); case EXIT_REASON_NMI_WINDOW: return nested_cpu_has(vmcs12, CPU_BASED_VIRTUAL_NMI_PENDING); case EXIT_REASON_TASK_SWITCH: return true; case EXIT_REASON_CPUID: if (kvm_register_read(vcpu, VCPU_REGS_RAX) == 0xa) return false; return true; case EXIT_REASON_HLT: return nested_cpu_has(vmcs12, CPU_BASED_HLT_EXITING); case EXIT_REASON_INVD: return true; case EXIT_REASON_INVLPG: return nested_cpu_has(vmcs12, CPU_BASED_INVLPG_EXITING); case EXIT_REASON_RDPMC: return nested_cpu_has(vmcs12, CPU_BASED_RDPMC_EXITING); case EXIT_REASON_RDTSC: case EXIT_REASON_RDTSCP: return nested_cpu_has(vmcs12, CPU_BASED_RDTSC_EXITING); case EXIT_REASON_VMCALL: case EXIT_REASON_VMCLEAR: case EXIT_REASON_VMLAUNCH: case EXIT_REASON_VMPTRLD: case EXIT_REASON_VMPTRST: case EXIT_REASON_VMREAD: case EXIT_REASON_VMRESUME: case EXIT_REASON_VMWRITE: case EXIT_REASON_VMOFF: case EXIT_REASON_VMON: case EXIT_REASON_INVEPT: case EXIT_REASON_INVVPID: /* * VMX instructions trap unconditionally. This allows L1 to * emulate them for its L2 guest, i.e., allows 3-level nesting! / return true; case EXIT_REASON_CR_ACCESS: return nested_vmx_exit_handled_cr(vcpu, vmcs12); case EXIT_REASON_DR_ACCESS: return nested_cpu_has(vmcs12, CPU_BASED_MOV_DR_EXITING); case EXIT_REASON_IO_INSTRUCTION: return nested_vmx_exit_handled_io(vcpu, vmcs12); case EXIT_REASON_MSR_READ: case EXIT_REASON_MSR_WRITE: return nested_vmx_exit_handled_msr(vcpu, vmcs12, exit_reason); case EXIT_REASON_INVALID_STATE: return true; case EXIT_REASON_MWAIT_INSTRUCTION: return nested_cpu_has(vmcs12, CPU_BASED_MWAIT_EXITING); case EXIT_REASON_MONITOR_TRAP_FLAG: return nested_cpu_has(vmcs12, CPU_BASED_MONITOR_TRAP_FLAG); case EXIT_REASON_MONITOR_INSTRUCTION: return nested_cpu_has(vmcs12, CPU_BASED_MONITOR_EXITING); case EXIT_REASON_PAUSE_INSTRUCTION: return nested_cpu_has(vmcs12, CPU_BASED_PAUSE_EXITING) \|\| nested_cpu_has2(vmcs12, SECONDARY_EXEC_PAUSE_LOOP_EXITING); case EXIT_REASON_MCE_DURING_VMENTRY: return false; case EXIT_REASON_TPR_BELOW_THRESHOLD: return nested_cpu_has(vmcs12, CPU_BASED_TPR_SHADOW); case EXIT_REASON_APIC_ACCESS: return nested_cpu_has2(vmcs12, SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES); case EXIT_REASON_APIC_WRITE: case EXIT_REASON_EOI_INDUCED: / apic_write and eoi_induced should exit unconditionally. / return true; case EXIT_REASON_EPT_VIOLATION: / * L0 always deals with the EPT violation. If nested EPT is * used, and the nested mmu code discovers that the address is * missing in the guest EPT table (EPT12), the EPT violation * will be injected with nested_ept_inject_page_fault() / return false; case EXIT_REASON_EPT_MISCONFIG: / * L2 never uses directly L1's EPT, but rather L0's own EPT * table (shadow on EPT) or a merged EPT table that L0 built * (EPT on EPT). So any problems with the structure of the * table is L0's fault. / return false; case EXIT_REASON_WBINVD: return nested_cpu_has2(vmcs12, SECONDARY_EXEC_WBINVD_EXITING); case EXIT_REASON_XSETBV: return true; case EXIT_REASON_XSAVES: case EXIT_REASON_XRSTORS: / * This should never happen, since it is not possible to * set XSS to a non-zero value---neither in L1 nor in L2. * If if it were, XSS would have to be checked against * the XSS exit bitmap in vmcs12. / return nested_cpu_has2(vmcs12, SECONDARY_EXEC_XSAVES); case EXIT_REASON_PCOMMIT: return nested_cpu_has2(vmcs12, SECONDARY_EXEC_PCOMMIT); default: return true; } } static void vmx_get_exit_info(struct kvm_vcpu vcpu, u64 info1, u64 info2) { info1 = vmcs_readl(EXIT_QUALIFICATION); info2 = vmcs_read32(VM_EXIT_INTR_INFO); } static int vmx_create_pml_buffer(struct vcpu_vmx vmx) { struct page pml_pg; pml_pg = alloc_page(GFP_KERNEL \| __GFP_ZERO); if (!pml_pg) return -ENOMEM; vmx->pml_pg = pml_pg; vmcs_write64(PML_ADDRESS, page_to_phys(vmx->pml_pg)); vmcs_write16(GUEST_PML_INDEX, PML_ENTITY_NUM - 1); return 0; } static void vmx_destroy_pml_buffer(struct vcpu_vmx vmx) { if (vmx->pml_pg) { __free_page(vmx->pml_pg); vmx->pml_pg = NULL; } } static void vmx_flush_pml_buffer(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); u64 pml_buf; u16 pml_idx; pml_idx = vmcs_read16(GUEST_PML_INDEX); /* Do nothing if PML buffer is empty / if (pml_idx == (PML_ENTITY_NUM - 1)) return; / PML index always points to next available PML buffer entity / if (pml_idx >= PML_ENTITY_NUM) pml_idx = 0; else pml_idx++; pml_buf = page_address(vmx->pml_pg); for (; pml_idx < PML_ENTITY_NUM; pml_idx++) { u64 gpa; gpa = pml_buf[pml_idx]; WARN_ON(gpa & (PAGE_SIZE - 1)); kvm_vcpu_mark_page_dirty(vcpu, gpa >> PAGE_SHIFT); } / reset PML index / vmcs_write16(GUEST_PML_INDEX, PML_ENTITY_NUM - 1); } / * Flush all vcpus' PML buffer and update logged GPAs to dirty_bitmap. * Called before reporting dirty_bitmap to userspace. / static void kvm_flush_pml_buffers(struct kvm kvm) { int i; struct kvm_vcpu vcpu; / * We only need to kick vcpu out of guest mode here, as PML buffer * is flushed at beginning of all VMEXITs, and it's obvious that only * vcpus running in guest are possible to have unflushed GPAs in PML * buffer. / kvm_for_each_vcpu(i, vcpu, kvm) kvm_vcpu_kick(vcpu); } static void vmx_dump_sel(char name, uint32_t sel) { pr_err("%s sel=0x%04x, attr=0x%05x, limit=0x%08x, base=0x%016lx\n", name, vmcs_read32(sel), vmcs_read32(sel + GUEST_ES_AR_BYTES - GUEST_ES_SELECTOR), vmcs_read32(sel + GUEST_ES_LIMIT - GUEST_ES_SELECTOR), vmcs_readl(sel + GUEST_ES_BASE - GUEST_ES_SELECTOR)); } static void vmx_dump_dtsel(char name, uint32_t limit) { pr_err("%s limit=0x%08x, base=0x%016lx\n", name, vmcs_read32(limit), vmcs_readl(limit + GUEST_GDTR_BASE - GUEST_GDTR_LIMIT)); } static void dump_vmcs(void) { u32 vmentry_ctl = vmcs_read32(VM_ENTRY_CONTROLS); u32 vmexit_ctl = vmcs_read32(VM_EXIT_CONTROLS); u32 cpu_based_exec_ctrl = vmcs_read32(CPU_BASED_VM_EXEC_CONTROL); u32 pin_based_exec_ctrl = vmcs_read32(PIN_BASED_VM_EXEC_CONTROL); u32 secondary_exec_control = 0; unsigned long cr4 = vmcs_readl(GUEST_CR4); u64 efer = vmcs_read64(GUEST_IA32_EFER); int i, n; if (cpu_has_secondary_exec_ctrls()) secondary_exec_control = vmcs_read32(SECONDARY_VM_EXEC_CONTROL); pr_err(" Guest State \n"); pr_err("CR0: actual=0x%016lx, shadow=0x%016lx, gh_mask=%016lx\n", vmcs_readl(GUEST_CR0), vmcs_readl(CR0_READ_SHADOW), vmcs_readl(CR0_GUEST_HOST_MASK)); pr_err("CR4: actual=0x%016lx, shadow=0x%016lx, gh_mask=%016lx\n", cr4, vmcs_readl(CR4_READ_SHADOW), vmcs_readl(CR4_GUEST_HOST_MASK)); pr_err("CR3 = 0x%016lx\n", vmcs_readl(GUEST_CR3)); if ((secondary_exec_control & SECONDARY_EXEC_ENABLE_EPT) && (cr4 & X86_CR4_PAE) && !(efer & EFER_LMA)) { pr_err("PDPTR0 = 0x%016llx PDPTR1 = 0x%016llx\n", vmcs_read64(GUEST_PDPTR0), vmcs_read64(GUEST_PDPTR1)); pr_err("PDPTR2 = 0x%016llx PDPTR3 = 0x%016llx\n", vmcs_read64(GUEST_PDPTR2), vmcs_read64(GUEST_PDPTR3)); } pr_err("RSP = 0x%016lx RIP = 0x%016lx\n", vmcs_readl(GUEST_RSP), vmcs_readl(GUEST_RIP)); pr_err("RFLAGS=0x%08lx DR7 = 0x%016lx\n", vmcs_readl(GUEST_RFLAGS), vmcs_readl(GUEST_DR7)); pr_err("Sysenter RSP=%016lx CS:RIP=%04x:%016lx\n", vmcs_readl(GUEST_SYSENTER_ESP), vmcs_read32(GUEST_SYSENTER_CS), vmcs_readl(GUEST_SYSENTER_EIP)); vmx_dump_sel("CS: ", GUEST_CS_SELECTOR); vmx_dump_sel("DS: ", GUEST_DS_SELECTOR); vmx_dump_sel("SS: ", GUEST_SS_SELECTOR); vmx_dump_sel("ES: ", GUEST_ES_SELECTOR); vmx_dump_sel("FS: ", GUEST_FS_SELECTOR); vmx_dump_sel("GS: ", GUEST_GS_SELECTOR); vmx_dump_dtsel("GDTR:", GUEST_GDTR_LIMIT); vmx_dump_sel("LDTR:", GUEST_LDTR_SELECTOR); vmx_dump_dtsel("IDTR:", GUEST_IDTR_LIMIT); vmx_dump_sel("TR: ", GUEST_TR_SELECTOR); if ((vmexit_ctl & (VM_EXIT_SAVE_IA32_PAT \| VM_EXIT_SAVE_IA32_EFER)) \|\| (vmentry_ctl & (VM_ENTRY_LOAD_IA32_PAT \| VM_ENTRY_LOAD_IA32_EFER))) pr_err("EFER = 0x%016llx PAT = 0x%016llx\n", efer, vmcs_read64(GUEST_IA32_PAT)); pr_err("DebugCtl = 0x%016llx DebugExceptions = 0x%016lx\n", vmcs_read64(GUEST_IA32_DEBUGCTL), vmcs_readl(GUEST_PENDING_DBG_EXCEPTIONS)); if (vmentry_ctl & VM_ENTRY_LOAD_IA32_PERF_GLOBAL_CTRL) pr_err("PerfGlobCtl = 0x%016llx\n", vmcs_read64(GUEST_IA32_PERF_GLOBAL_CTRL)); if (vmentry_ctl & VM_ENTRY_LOAD_BNDCFGS) pr_err("BndCfgS = 0x%016llx\n", vmcs_read64(GUEST_BNDCFGS)); pr_err("Interruptibility = %08x ActivityState = %08x\n", vmcs_read32(GUEST_INTERRUPTIBILITY_INFO), vmcs_read32(GUEST_ACTIVITY_STATE)); if (secondary_exec_control & SECONDARY_EXEC_VIRTUAL_INTR_DELIVERY) pr_err("InterruptStatus = %04x\n", vmcs_read16(GUEST_INTR_STATUS)); pr_err(" Host State \n"); pr_err("RIP = 0x%016lx RSP = 0x%016lx\n", vmcs_readl(HOST_RIP), vmcs_readl(HOST_RSP)); pr_err("CS=%04x SS=%04x DS=%04x ES=%04x FS=%04x GS=%04x TR=%04x\n", vmcs_read16(HOST_CS_SELECTOR), vmcs_read16(HOST_SS_SELECTOR), vmcs_read16(HOST_DS_SELECTOR), vmcs_read16(HOST_ES_SELECTOR), vmcs_read16(HOST_FS_SELECTOR), vmcs_read16(HOST_GS_SELECTOR), vmcs_read16(HOST_TR_SELECTOR)); pr_err("FSBase=%016lx GSBase=%016lx TRBase=%016lx\n", vmcs_readl(HOST_FS_BASE), vmcs_readl(HOST_GS_BASE), vmcs_readl(HOST_TR_BASE)); pr_err("GDTBase=%016lx IDTBase=%016lx\n", vmcs_readl(HOST_GDTR_BASE), vmcs_readl(HOST_IDTR_BASE)); pr_err("CR0=%016lx CR3=%016lx CR4=%016lx\n", vmcs_readl(HOST_CR0), vmcs_readl(HOST_CR3), vmcs_readl(HOST_CR4)); pr_err("Sysenter RSP=%016lx CS:RIP=%04x:%016lx\n", vmcs_readl(HOST_IA32_SYSENTER_ESP), vmcs_read32(HOST_IA32_SYSENTER_CS), vmcs_readl(HOST_IA32_SYSENTER_EIP)); if (vmexit_ctl & (VM_EXIT_LOAD_IA32_PAT \| VM_EXIT_LOAD_IA32_EFER)) pr_err("EFER = 0x%016llx PAT = 0x%016llx\n", vmcs_read64(HOST_IA32_EFER), vmcs_read64(HOST_IA32_PAT)); if (vmexit_ctl & VM_EXIT_LOAD_IA32_PERF_GLOBAL_CTRL) pr_err("PerfGlobCtl = 0x%016llx\n", vmcs_read64(HOST_IA32_PERF_GLOBAL_CTRL)); pr_err(" Control State \n"); pr_err("PinBased=%08x CPUBased=%08x SecondaryExec=%08x\n", pin_based_exec_ctrl, cpu_based_exec_ctrl, secondary_exec_control); pr_err("EntryControls=%08x ExitControls=%08x\n", vmentry_ctl, vmexit_ctl); pr_err("ExceptionBitmap=%08x PFECmask=%08x PFECmatch=%08x\n", vmcs_read32(EXCEPTION_BITMAP), vmcs_read32(PAGE_FAULT_ERROR_CODE_MASK), vmcs_read32(PAGE_FAULT_ERROR_CODE_MATCH)); pr_err("VMEntry: intr_info=%08x errcode=%08x ilen=%08x\n", vmcs_read32(VM_ENTRY_INTR_INFO_FIELD), vmcs_read32(VM_ENTRY_EXCEPTION_ERROR_CODE), vmcs_read32(VM_ENTRY_INSTRUCTION_LEN)); pr_err("VMExit: intr_info=%08x errcode=%08x ilen=%08x\n", vmcs_read32(VM_EXIT_INTR_INFO), vmcs_read32(VM_EXIT_INTR_ERROR_CODE), vmcs_read32(VM_EXIT_INSTRUCTION_LEN)); pr_err(" reason=%08x qualification=%016lx\n", vmcs_read32(VM_EXIT_REASON), vmcs_readl(EXIT_QUALIFICATION)); pr_err("IDTVectoring: info=%08x errcode=%08x\n", vmcs_read32(IDT_VECTORING_INFO_FIELD), vmcs_read32(IDT_VECTORING_ERROR_CODE)); pr_err("TSC Offset = 0x%016llx\n", vmcs_read64(TSC_OFFSET)); if (secondary_exec_control & SECONDARY_EXEC_TSC_SCALING) pr_err("TSC Multiplier = 0x%016llx\n", vmcs_read64(TSC_MULTIPLIER)); if (cpu_based_exec_ctrl & CPU_BASED_TPR_SHADOW) pr_err("TPR Threshold = 0x%02x\n", vmcs_read32(TPR_THRESHOLD)); if (pin_based_exec_ctrl & PIN_BASED_POSTED_INTR) pr_err("PostedIntrVec = 0x%02x\n", vmcs_read16(POSTED_INTR_NV)); if ((secondary_exec_control & SECONDARY_EXEC_ENABLE_EPT)) pr_err("EPT pointer = 0x%016llx\n", vmcs_read64(EPT_POINTER)); n = vmcs_read32(CR3_TARGET_COUNT); for (i = 0; i + 1 < n; i += 4) pr_err("CR3 target%u=%016lx target%u=%016lx\n", i, vmcs_readl(CR3_TARGET_VALUE0 + i 2), i + 1, vmcs_readl(CR3_TARGET_VALUE0 + i * 2 + 2)); if (i < n) pr_err("CR3 target%u=%016lx\n", i, vmcs_readl(CR3_TARGET_VALUE0 + i * 2)); if (secondary_exec_control & SECONDARY_EXEC_PAUSE_LOOP_EXITING) pr_err("PLE Gap=%08x Window=%08x\n", vmcs_read32(PLE_GAP), vmcs_read32(PLE_WINDOW)); if (secondary_exec_control & SECONDARY_EXEC_ENABLE_VPID) pr_err("Virtual processor ID = 0x%04x\n", vmcs_read16(VIRTUAL_PROCESSOR_ID)); } /* * The guest has exited. See if we can fix it or if we need userspace * assistance. / static int vmx_handle_exit(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); u32 exit_reason = vmx->exit_reason; u32 vectoring_info = vmx->idt_vectoring_info; trace_kvm_exit(exit_reason, vcpu, KVM_ISA_VMX); / * Flush logged GPAs PML buffer, this will make dirty_bitmap more * updated. Another good is, in kvm_vm_ioctl_get_dirty_log, before * querying dirty_bitmap, we only need to kick all vcpus out of guest * mode as if vcpus is in root mode, the PML buffer must has been * flushed already. / if (enable_pml) vmx_flush_pml_buffer(vcpu); / If guest state is invalid, start emulating / if (vmx->emulation_required) return handle_invalid_guest_state(vcpu); if (is_guest_mode(vcpu) && nested_vmx_exit_handled(vcpu)) { nested_vmx_vmexit(vcpu, exit_reason, vmcs_read32(VM_EXIT_INTR_INFO), vmcs_readl(EXIT_QUALIFICATION)); return 1; } if (exit_reason & VMX_EXIT_REASONS_FAILED_VMENTRY) { dump_vmcs(); vcpu->run->exit_reason = KVM_EXIT_FAIL_ENTRY; vcpu->run->fail_entry.hardware_entry_failure_reason = exit_reason; return 0; } if (unlikely(vmx->fail)) { vcpu->run->exit_reason = KVM_EXIT_FAIL_ENTRY; vcpu->run->fail_entry.hardware_entry_failure_reason = vmcs_read32(VM_INSTRUCTION_ERROR); return 0; } / * Note: * Do not try to fix EXIT_REASON_EPT_MISCONFIG if it caused by * delivery event since it indicates guest is accessing MMIO. * The vm-exit can be triggered again after return to guest that * will cause infinite loop. / if ((vectoring_info & VECTORING_INFO_VALID_MASK) && (exit_reason != EXIT_REASON_EXCEPTION_NMI && exit_reason != EXIT_REASON_EPT_VIOLATION && exit_reason != EXIT_REASON_TASK_SWITCH)) { vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR; vcpu->run->internal.suberror = KVM_INTERNAL_ERROR_DELIVERY_EV; vcpu->run->internal.ndata = 2; vcpu->run->internal.data[0] = vectoring_info; vcpu->run->internal.data[1] = exit_reason; return 0; } if (unlikely(!cpu_has_virtual_nmis() && vmx->soft_vnmi_blocked && !(is_guest_mode(vcpu) && nested_cpu_has_virtual_nmis( get_vmcs12(vcpu))))) { if (vmx_interrupt_allowed(vcpu)) { vmx->soft_vnmi_blocked = 0; } else if (vmx->vnmi_blocked_time > 1000000000LL && vcpu->arch.nmi_pending) { / * This CPU don't support us in finding the end of an * NMI-blocked window if the guest runs with IRQs * disabled. So we pull the trigger after 1 s of * futile waiting, but inform the user about this. / printk(KERN_WARNING "%s: Breaking out of NMI-blocked " "state on VCPU %d after 1 s timeout\n", __func__, vcpu->vcpu_id); vmx->soft_vnmi_blocked = 0; } } if (exit_reason < kvm_vmx_max_exit_handlers && kvm_vmx_exit_handlers[exit_reason]) return kvm_vmx_exit_handlers[exit_reason](vcpu); else { WARN_ONCE(1, "vmx: unexpected exit reason 0x%x\n", exit_reason); kvm_queue_exception(vcpu, UD_VECTOR); return 1; } } static void update_cr8_intercept(struct kvm_vcpu vcpu, int tpr, int irr) { struct vmcs12 vmcs12 = get_vmcs12(vcpu); if (is_guest_mode(vcpu) && nested_cpu_has(vmcs12, CPU_BASED_TPR_SHADOW)) return; if (irr == -1 \|\| tpr < irr) { vmcs_write32(TPR_THRESHOLD, 0); return; } vmcs_write32(TPR_THRESHOLD, irr); } static void vmx_set_virtual_x2apic_mode(struct kvm_vcpu vcpu, bool set) { u32 sec_exec_control; /* * There is not point to enable virtualize x2apic without enable * apicv / if (!cpu_has_vmx_virtualize_x2apic_mode() \|\| !kvm_vcpu_apicv_active(vcpu)) return; if (!cpu_need_tpr_shadow(vcpu)) return; sec_exec_control = vmcs_read32(SECONDARY_VM_EXEC_CONTROL); if (set) { sec_exec_control &= ~SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES; sec_exec_control \|= SECONDARY_EXEC_VIRTUALIZE_X2APIC_MODE; } else { sec_exec_control &= ~SECONDARY_EXEC_VIRTUALIZE_X2APIC_MODE; sec_exec_control \|= SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES; } vmcs_write32(SECONDARY_VM_EXEC_CONTROL, sec_exec_control); vmx_set_msr_bitmap(vcpu); } static void vmx_set_apic_access_page_addr(struct kvm_vcpu vcpu, hpa_t hpa) { struct vcpu_vmx vmx = to_vmx(vcpu); / * Currently we do not handle the nested case where L2 has an * APIC access page of its own; that page is still pinned. * Hence, we skip the case where the VCPU is in guest mode _and_ * L1 prepared an APIC access page for L2. * * For the case where L1 and L2 share the same APIC access page * (flexpriority=Y but SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES clear * in the vmcs12), this function will only update either the vmcs01 * or the vmcs02. If the former, the vmcs02 will be updated by * prepare_vmcs02. If the latter, the vmcs01 will be updated in * the next L2->L1 exit. / if (!is_guest_mode(vcpu) \|\| !nested_cpu_has2(vmx->nested.current_vmcs12, SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES)) vmcs_write64(APIC_ACCESS_ADDR, hpa); } static void vmx_hwapic_isr_update(struct kvm_vcpu vcpu, int max_isr) { u16 status; u8 old; if (max_isr == -1) max_isr = 0; status = vmcs_read16(GUEST_INTR_STATUS); old = status >> 8; if (max_isr != old) { status &= 0xff; status \|= max_isr << 8; vmcs_write16(GUEST_INTR_STATUS, status); } } static void vmx_set_rvi(int vector) { u16 status; u8 old; if (vector == -1) vector = 0; status = vmcs_read16(GUEST_INTR_STATUS); old = (u8)status & 0xff; if ((u8)vector != old) { status &= ~0xff; status \|= (u8)vector; vmcs_write16(GUEST_INTR_STATUS, status); } } static void vmx_hwapic_irr_update(struct kvm_vcpu vcpu, int max_irr) { if (!is_guest_mode(vcpu)) { vmx_set_rvi(max_irr); return; } if (max_irr == -1) return; / * In guest mode. If a vmexit is needed, vmx_check_nested_events * handles it. / if (nested_exit_on_intr(vcpu)) return; / * Else, fall back to pre-APICv interrupt injection since L2 * is run without virtual interrupt delivery. / if (!kvm_event_needs_reinjection(vcpu) && vmx_interrupt_allowed(vcpu)) { kvm_queue_interrupt(vcpu, max_irr, false); vmx_inject_irq(vcpu); } } static void vmx_load_eoi_exitmap(struct kvm_vcpu vcpu, u64 eoi_exit_bitmap) { if (!kvm_vcpu_apicv_active(vcpu)) return; vmcs_write64(EOI_EXIT_BITMAP0, eoi_exit_bitmap[0]); vmcs_write64(EOI_EXIT_BITMAP1, eoi_exit_bitmap[1]); vmcs_write64(EOI_EXIT_BITMAP2, eoi_exit_bitmap[2]); vmcs_write64(EOI_EXIT_BITMAP3, eoi_exit_bitmap[3]); } static void vmx_complete_atomic_exit(struct vcpu_vmx vmx) { u32 exit_intr_info; if (!(vmx->exit_reason == EXIT_REASON_MCE_DURING_VMENTRY \|\| vmx->exit_reason == EXIT_REASON_EXCEPTION_NMI)) return; vmx->exit_intr_info = vmcs_read32(VM_EXIT_INTR_INFO); exit_intr_info = vmx->exit_intr_info; /* Handle machine checks before interrupts are enabled / if (is_machine_check(exit_intr_info)) kvm_machine_check(); / We need to handle NMIs before interrupts are enabled / if ((exit_intr_info & INTR_INFO_INTR_TYPE_MASK) == INTR_TYPE_NMI_INTR && (exit_intr_info & INTR_INFO_VALID_MASK)) { kvm_before_handle_nmi(&vmx->vcpu); asm("int $2"); kvm_after_handle_nmi(&vmx->vcpu); } } static void vmx_handle_external_intr(struct kvm_vcpu vcpu) { u32 exit_intr_info = vmcs_read32(VM_EXIT_INTR_INFO); register void __sp asm(_ASM_SP); / * If external interrupt exists, IF bit is set in rflags/eflags on the * interrupt stack frame, and interrupt will be enabled on a return * from interrupt handler. / if ((exit_intr_info & (INTR_INFO_VALID_MASK \| INTR_INFO_INTR_TYPE_MASK)) == (INTR_INFO_VALID_MASK \| INTR_TYPE_EXT_INTR)) { unsigned int vector; unsigned long entry; gate_desc desc; struct vcpu_vmx vmx = to_vmx(vcpu); #ifdef CONFIG_X86_64 unsigned long tmp; #endif vector = exit_intr_info & INTR_INFO_VECTOR_MASK; desc = (gate_desc )vmx->host_idt_base + vector; entry = gate_offset(desc); asm volatile( #ifdef CONFIG_X86_64 "mov %%" _ASM_SP ", %[sp]\n\t" "and $0xfffffffffffffff0, %%" _ASM_SP "\n\t" "push $%c[ss]\n\t" "push %[sp]\n\t" #endif "pushf\n\t" "orl $0x200, (%%" _ASM_SP ")\n\t" __ASM_SIZE(push) " $%c[cs]\n\t" "call %[entry]\n\t" : #ifdef CONFIG_X86_64 [sp]"=&r"(tmp), #endif "+r"(__sp) : [entry]"r"(entry), [ss]"i"(__KERNEL_DS), [cs]"i"(__KERNEL_CS) ); } else local_irq_enable(); } static bool vmx_has_high_real_mode_segbase(void) { return enable_unrestricted_guest \|\| emulate_invalid_guest_state; } static bool vmx_mpx_supported(void) { return (vmcs_config.vmexit_ctrl & VM_EXIT_CLEAR_BNDCFGS) && (vmcs_config.vmentry_ctrl & VM_ENTRY_LOAD_BNDCFGS); } static bool vmx_xsaves_supported(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_XSAVES; } static void vmx_recover_nmi_blocking(struct vcpu_vmx vmx) { u32 exit_intr_info; bool unblock_nmi; u8 vector; bool idtv_info_valid; idtv_info_valid = vmx->idt_vectoring_info & VECTORING_INFO_VALID_MASK; if (cpu_has_virtual_nmis()) { if (vmx->nmi_known_unmasked) return; / * Can't use vmx->exit_intr_info since we're not sure what * the exit reason is. / exit_intr_info = vmcs_read32(VM_EXIT_INTR_INFO); unblock_nmi = (exit_intr_info & INTR_INFO_UNBLOCK_NMI) != 0; vector = exit_intr_info & INTR_INFO_VECTOR_MASK; / * SDM 3: 27.7.1.2 (September 2008) * Re-set bit "block by NMI" before VM entry if vmexit caused by * a guest IRET fault. * SDM 3: 23.2.2 (September 2008) * Bit 12 is undefined in any of the following cases: * If the VM exit sets the valid bit in the IDT-vectoring * information field. * If the VM exit is due to a double fault. / if ((exit_intr_info & INTR_INFO_VALID_MASK) && unblock_nmi && vector != DF_VECTOR && !idtv_info_valid) vmcs_set_bits(GUEST_INTERRUPTIBILITY_INFO, GUEST_INTR_STATE_NMI); else vmx->nmi_known_unmasked = !(vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) & GUEST_INTR_STATE_NMI); } else if (unlikely(vmx->soft_vnmi_blocked)) vmx->vnmi_blocked_time += ktime_to_ns(ktime_sub(ktime_get(), vmx->entry_time)); } static void __vmx_complete_interrupts(struct kvm_vcpu vcpu, u32 idt_vectoring_info, int instr_len_field, int error_code_field) { u8 vector; int type; bool idtv_info_valid; idtv_info_valid = idt_vectoring_info & VECTORING_INFO_VALID_MASK; vcpu->arch.nmi_injected = false; kvm_clear_exception_queue(vcpu); kvm_clear_interrupt_queue(vcpu); if (!idtv_info_valid) return; kvm_make_request(KVM_REQ_EVENT, vcpu); vector = idt_vectoring_info & VECTORING_INFO_VECTOR_MASK; type = idt_vectoring_info & VECTORING_INFO_TYPE_MASK; switch (type) { case INTR_TYPE_NMI_INTR: vcpu->arch.nmi_injected = true; /* * SDM 3: 27.7.1.2 (September 2008) * Clear bit "block by NMI" before VM entry if a NMI * delivery faulted. / vmx_set_nmi_mask(vcpu, false); break; case INTR_TYPE_SOFT_EXCEPTION: vcpu->arch.event_exit_inst_len = vmcs_read32(instr_len_field); / fall through / case INTR_TYPE_HARD_EXCEPTION: if (idt_vectoring_info & VECTORING_INFO_DELIVER_CODE_MASK) { u32 err = vmcs_read32(error_code_field); kvm_requeue_exception_e(vcpu, vector, err); } else kvm_requeue_exception(vcpu, vector); break; case INTR_TYPE_SOFT_INTR: vcpu->arch.event_exit_inst_len = vmcs_read32(instr_len_field); / fall through / case INTR_TYPE_EXT_INTR: kvm_queue_interrupt(vcpu, vector, type == INTR_TYPE_SOFT_INTR); break; default: break; } } static void vmx_complete_interrupts(struct vcpu_vmx vmx) { __vmx_complete_interrupts(&vmx->vcpu, vmx->idt_vectoring_info, VM_EXIT_INSTRUCTION_LEN, IDT_VECTORING_ERROR_CODE); } static void vmx_cancel_injection(struct kvm_vcpu vcpu) { __vmx_complete_interrupts(vcpu, vmcs_read32(VM_ENTRY_INTR_INFO_FIELD), VM_ENTRY_INSTRUCTION_LEN, VM_ENTRY_EXCEPTION_ERROR_CODE); vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, 0); } static void atomic_switch_perf_msrs(struct vcpu_vmx vmx) { int i, nr_msrs; struct perf_guest_switch_msr msrs; msrs = perf_guest_get_msrs(&nr_msrs); if (!msrs) return; for (i = 0; i < nr_msrs; i++) if (msrs[i].host == msrs[i].guest) clear_atomic_switch_msr(vmx, msrs[i].msr); else add_atomic_switch_msr(vmx, msrs[i].msr, msrs[i].guest, msrs[i].host); } static void __noclone vmx_vcpu_run(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); unsigned long debugctlmsr, cr4; / Record the guest's net vcpu time for enforced NMI injections. / if (unlikely(!cpu_has_virtual_nmis() && vmx->soft_vnmi_blocked)) vmx->entry_time = ktime_get(); / Don't enter VMX if guest state is invalid, let the exit handler start emulation until we arrive back to a valid state / if (vmx->emulation_required) return; if (vmx->ple_window_dirty) { vmx->ple_window_dirty = false; vmcs_write32(PLE_WINDOW, vmx->ple_window); } if (vmx->nested.sync_shadow_vmcs) { copy_vmcs12_to_shadow(vmx); vmx->nested.sync_shadow_vmcs = false; } if (test_bit(VCPU_REGS_RSP, (unsigned long )&vcpu->arch.regs_dirty)) vmcs_writel(GUEST_RSP, vcpu->arch.regs[VCPU_REGS_RSP]); if (test_bit(VCPU_REGS_RIP, (unsigned long )&vcpu->arch.regs_dirty)) vmcs_writel(GUEST_RIP, vcpu->arch.regs[VCPU_REGS_RIP]); cr4 = cr4_read_shadow(); if (unlikely(cr4 != vmx->host_state.vmcs_host_cr4)) { vmcs_writel(HOST_CR4, cr4); vmx->host_state.vmcs_host_cr4 = cr4; } / When single-stepping over STI and MOV SS, we must clear the * corresponding interruptibility bits in the guest state. Otherwise * vmentry fails as it then expects bit 14 (BS) in pending debug * exceptions being set, but that's not correct for the guest debugging * case. / if (vcpu->guest_debug & KVM_GUESTDBG_SINGLESTEP) vmx_set_interrupt_shadow(vcpu, 0); if (vmx->guest_pkru_valid) __write_pkru(vmx->guest_pkru); atomic_switch_perf_msrs(vmx); debugctlmsr = get_debugctlmsr(); vmx->__launched = vmx->loaded_vmcs->launched; asm( / Store host registers / "push %%" _ASM_DX "; push %%" _ASM_BP ";" "push %%" _ASM_CX " \n\t" / placeholder for guest rcx / "push %%" _ASM_CX " \n\t" "cmp %%" _ASM_SP ", %c[host_rsp](%0) \n\t" "je 1f \n\t" "mov %%" _ASM_SP ", %c[host_rsp](%0) \n\t" __ex(ASM_VMX_VMWRITE_RSP_RDX) "\n\t" "1: \n\t" / Reload cr2 if changed / "mov %c[cr2](%0), %%" _ASM_AX " \n\t" "mov %%cr2, %%" _ASM_DX " \n\t" "cmp %%" _ASM_AX ", %%" _ASM_DX " \n\t" "je 2f \n\t" "mov %%" _ASM_AX", %%cr2 \n\t" "2: \n\t" / Check if vmlaunch of vmresume is needed / "cmpl $0, %c[launched](%0) \n\t" / Load guest registers. Don't clobber flags. / "mov %c[rax](%0), %%" _ASM_AX " \n\t" "mov %c[rbx](%0), %%" _ASM_BX " \n\t" "mov %c[rdx](%0), %%" _ASM_DX " \n\t" "mov %c[rsi](%0), %%" _ASM_SI " \n\t" "mov %c[rdi](%0), %%" _ASM_DI " \n\t" "mov %c[rbp](%0), %%" _ASM_BP " \n\t" #ifdef CONFIG_X86_64 "mov %c[r8](%0), %%r8 \n\t" "mov %c[r9](%0), %%r9 \n\t" "mov %c[r10](%0), %%r10 \n\t" "mov %c[r11](%0), %%r11 \n\t" "mov %c[r12](%0), %%r12 \n\t" "mov %c[r13](%0), %%r13 \n\t" "mov %c[r14](%0), %%r14 \n\t" "mov %c[r15](%0), %%r15 \n\t" #endif "mov %c[rcx](%0), %%" _ASM_CX " \n\t" / kills %0 (ecx) / / Enter guest mode / "jne 1f \n\t" __ex(ASM_VMX_VMLAUNCH) "\n\t" "jmp 2f \n\t" "1: " __ex(ASM_VMX_VMRESUME) "\n\t" "2: " / Save guest registers, load host registers, keep flags / "mov %0, %c[wordsize](%%" _ASM_SP ") \n\t" "pop %0 \n\t" "mov %%" _ASM_AX ", %c[rax](%0) \n\t" "mov %%" _ASM_BX ", %c[rbx](%0) \n\t" __ASM_SIZE(pop) " %c[rcx](%0) \n\t" "mov %%" _ASM_DX ", %c[rdx](%0) \n\t" "mov %%" _ASM_SI ", %c[rsi](%0) \n\t" "mov %%" _ASM_DI ", %c[rdi](%0) \n\t" "mov %%" _ASM_BP ", %c[rbp](%0) \n\t" #ifdef CONFIG_X86_64 "mov %%r8, %c[r8](%0) \n\t" "mov %%r9, %c[r9](%0) \n\t" "mov %%r10, %c[r10](%0) \n\t" "mov %%r11, %c[r11](%0) \n\t" "mov %%r12, %c[r12](%0) \n\t" "mov %%r13, %c[r13](%0) \n\t" "mov %%r14, %c[r14](%0) \n\t" "mov %%r15, %c[r15](%0) \n\t" #endif "mov %%cr2, %%" _ASM_AX " \n\t" "mov %%" _ASM_AX ", %c[cr2](%0) \n\t" "pop %%" _ASM_BP "; pop %%" _ASM_DX " \n\t" "setbe %c[fail](%0) \n\t" ".pushsection .rodata \n\t" ".global vmx_return \n\t" "vmx_return: " _ASM_PTR " 2b \n\t" ".popsection" : : "c"(vmx), "d"((unsigned long)HOST_RSP), [launched]"i"(offsetof(struct vcpu_vmx, __launched)), [fail]"i"(offsetof(struct vcpu_vmx, fail)), [host_rsp]"i"(offsetof(struct vcpu_vmx, host_rsp)), [rax]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RAX])), [rbx]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RBX])), [rcx]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RCX])), [rdx]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RDX])), [rsi]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RSI])), [rdi]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RDI])), [rbp]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RBP])), #ifdef CONFIG_X86_64 [r8]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R8])), [r9]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R9])), [r10]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R10])), [r11]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R11])), [r12]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R12])), [r13]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R13])), [r14]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R14])), [r15]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R15])), #endif [cr2]"i"(offsetof(struct vcpu_vmx, vcpu.arch.cr2)), [wordsize]"i"(sizeof(ulong)) : "cc", "memory" #ifdef CONFIG_X86_64 , "rax", "rbx", "rdi", "rsi" , "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15" #else , "eax", "ebx", "edi", "esi" #endif ); / MSR_IA32_DEBUGCTLMSR is zeroed on vmexit. Restore it if needed / if (debugctlmsr) update_debugctlmsr(debugctlmsr); #ifndef CONFIG_X86_64 / * The sysexit path does not restore ds/es, so we must set them to * a reasonable value ourselves. * * We can't defer this to vmx_load_host_state() since that function * may be executed in interrupt context, which saves and restore segments * around it, nullifying its effect. / loadsegment(ds, __USER_DS); loadsegment(es, __USER_DS); #endif vcpu->arch.regs_avail = ~((1 << VCPU_REGS_RIP) \| (1 << VCPU_REGS_RSP) \| (1 << VCPU_EXREG_RFLAGS) \| (1 << VCPU_EXREG_PDPTR) \| (1 << VCPU_EXREG_SEGMENTS) \| (1 << VCPU_EXREG_CR3)); vcpu->arch.regs_dirty = 0; vmx->idt_vectoring_info = vmcs_read32(IDT_VECTORING_INFO_FIELD); vmx->loaded_vmcs->launched = 1; vmx->exit_reason = vmcs_read32(VM_EXIT_REASON); / * eager fpu is enabled if PKEY is supported and CR4 is switched * back on host, so it is safe to read guest PKRU from current * XSAVE. / if (boot_cpu_has(X86_FEATURE_OSPKE)) { vmx->guest_pkru = __read_pkru(); if (vmx->guest_pkru != vmx->host_pkru) { vmx->guest_pkru_valid = true; __write_pkru(vmx->host_pkru); } else vmx->guest_pkru_valid = false; } / * the KVM_REQ_EVENT optimization bit is only on for one entry, and if * we did not inject a still-pending event to L1 now because of * nested_run_pending, we need to re-enable this bit. / if (vmx->nested.nested_run_pending) kvm_make_request(KVM_REQ_EVENT, vcpu); vmx->nested.nested_run_pending = 0; vmx_complete_atomic_exit(vmx); vmx_recover_nmi_blocking(vmx); vmx_complete_interrupts(vmx); } static void vmx_load_vmcs01(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); int cpu; if (vmx->loaded_vmcs == &vmx->vmcs01) return; cpu = get_cpu(); vmx->loaded_vmcs = &vmx->vmcs01; vmx_vcpu_put(vcpu); vmx_vcpu_load(vcpu, cpu); vcpu->cpu = cpu; put_cpu(); } static void vmx_free_vcpu(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); if (enable_pml) vmx_destroy_pml_buffer(vmx); free_vpid(vmx->vpid); leave_guest_mode(vcpu); vmx_load_vmcs01(vcpu); free_nested(vmx); free_loaded_vmcs(vmx->loaded_vmcs); kfree(vmx->guest_msrs); kvm_vcpu_uninit(vcpu); kmem_cache_free(kvm_vcpu_cache, vmx); } static struct kvm_vcpu vmx_create_vcpu(struct kvm kvm, unsigned int id) { int err; struct vcpu_vmx vmx = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL); int cpu; if (!vmx) return ERR_PTR(-ENOMEM); vmx->vpid = allocate_vpid(); err = kvm_vcpu_init(&vmx->vcpu, kvm, id); if (err) goto free_vcpu; vmx->guest_msrs = kmalloc(PAGE_SIZE, GFP_KERNEL); BUILD_BUG_ON(ARRAY_SIZE(vmx_msr_index) * sizeof(vmx->guest_msrs[0]) > PAGE_SIZE); err = -ENOMEM; if (!vmx->guest_msrs) { goto uninit_vcpu; } vmx->loaded_vmcs = &vmx->vmcs01; vmx->loaded_vmcs->vmcs = alloc_vmcs(); if (!vmx->loaded_vmcs->vmcs) goto free_msrs; if (!vmm_exclusive) kvm_cpu_vmxon(__pa(per_cpu(vmxarea, raw_smp_processor_id()))); loaded_vmcs_init(vmx->loaded_vmcs); if (!vmm_exclusive) kvm_cpu_vmxoff(); cpu = get_cpu(); vmx_vcpu_load(&vmx->vcpu, cpu); vmx->vcpu.cpu = cpu; err = vmx_vcpu_setup(vmx); vmx_vcpu_put(&vmx->vcpu); put_cpu(); if (err) goto free_vmcs; if (cpu_need_virtualize_apic_accesses(&vmx->vcpu)) { err = alloc_apic_access_page(kvm); if (err) goto free_vmcs; } if (enable_ept) { if (!kvm->arch.ept_identity_map_addr) kvm->arch.ept_identity_map_addr = VMX_EPT_IDENTITY_PAGETABLE_ADDR; err = init_rmode_identity_map(kvm); if (err) goto free_vmcs; } if (nested) { nested_vmx_setup_ctls_msrs(vmx); vmx->nested.vpid02 = allocate_vpid(); } vmx->nested.posted_intr_nv = -1; vmx->nested.current_vmptr = -1ull; vmx->nested.current_vmcs12 = NULL; /* * If PML is turned on, failure on enabling PML just results in failure * of creating the vcpu, therefore we can simplify PML logic (by * avoiding dealing with cases, such as enabling PML partially on vcpus * for the guest, etc. / if (enable_pml) { err = vmx_create_pml_buffer(vmx); if (err) goto free_vmcs; } return &vmx->vcpu; free_vmcs: free_vpid(vmx->nested.vpid02); free_loaded_vmcs(vmx->loaded_vmcs); free_msrs: kfree(vmx->guest_msrs); uninit_vcpu: kvm_vcpu_uninit(&vmx->vcpu); free_vcpu: free_vpid(vmx->vpid); kmem_cache_free(kvm_vcpu_cache, vmx); return ERR_PTR(err); } static void __init vmx_check_processor_compat(void rtn) { struct vmcs_config vmcs_conf; (int )rtn = 0; if (setup_vmcs_config(&vmcs_conf) < 0) (int )rtn = -EIO; if (memcmp(&vmcs_config, &vmcs_conf, sizeof(struct vmcs_config)) != 0) { printk(KERN_ERR "kvm: CPU %d feature inconsistency!\n", smp_processor_id()); (int )rtn = -EIO; } } static int get_ept_level(void) { return VMX_EPT_DEFAULT_GAW + 1; } static u64 vmx_get_mt_mask(struct kvm_vcpu vcpu, gfn_t gfn, bool is_mmio) { u8 cache; u64 ipat = 0; / For VT-d and EPT combination * 1. MMIO: always map as UC * 2. EPT with VT-d: * a. VT-d without snooping control feature: can't guarantee the * result, try to trust guest. * b. VT-d with snooping control feature: snooping control feature of * VT-d engine can guarantee the cache correctness. Just set it * to WB to keep consistent with host. So the same as item 3. * 3. EPT without VT-d: always map as WB and set IPAT=1 to keep * consistent with host MTRR / if (is_mmio) { cache = MTRR_TYPE_UNCACHABLE; goto exit; } if (!kvm_arch_has_noncoherent_dma(vcpu->kvm)) { ipat = VMX_EPT_IPAT_BIT; cache = MTRR_TYPE_WRBACK; goto exit; } if (kvm_read_cr0(vcpu) & X86_CR0_CD) { ipat = VMX_EPT_IPAT_BIT; if (kvm_check_has_quirk(vcpu->kvm, KVM_X86_QUIRK_CD_NW_CLEARED)) cache = MTRR_TYPE_WRBACK; else cache = MTRR_TYPE_UNCACHABLE; goto exit; } cache = kvm_mtrr_get_guest_memory_type(vcpu, gfn); exit: return (cache << VMX_EPT_MT_EPTE_SHIFT) \| ipat; } static int vmx_get_lpage_level(void) { if (enable_ept && !cpu_has_vmx_ept_1g_page()) return PT_DIRECTORY_LEVEL; else / For shadow and EPT supported 1GB page / return PT_PDPE_LEVEL; } static void vmcs_set_secondary_exec_control(u32 new_ctl) { / * These bits in the secondary execution controls field * are dynamic, the others are mostly based on the hypervisor * architecture and the guest's CPUID. Do not touch the * dynamic bits. / u32 mask = SECONDARY_EXEC_SHADOW_VMCS \| SECONDARY_EXEC_VIRTUALIZE_X2APIC_MODE \| SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES; u32 cur_ctl = vmcs_read32(SECONDARY_VM_EXEC_CONTROL); vmcs_write32(SECONDARY_VM_EXEC_CONTROL, (new_ctl & ~mask) \| (cur_ctl & mask)); } static void vmx_cpuid_update(struct kvm_vcpu vcpu) { struct kvm_cpuid_entry2 best; struct vcpu_vmx vmx = to_vmx(vcpu); u32 secondary_exec_ctl = vmx_secondary_exec_control(vmx); if (vmx_rdtscp_supported()) { bool rdtscp_enabled = guest_cpuid_has_rdtscp(vcpu); if (!rdtscp_enabled) secondary_exec_ctl &= ~SECONDARY_EXEC_RDTSCP; if (nested) { if (rdtscp_enabled) vmx->nested.nested_vmx_secondary_ctls_high \|= SECONDARY_EXEC_RDTSCP; else vmx->nested.nested_vmx_secondary_ctls_high &= ~SECONDARY_EXEC_RDTSCP; } } /* Exposing INVPCID only when PCID is exposed / best = kvm_find_cpuid_entry(vcpu, 0x7, 0); if (vmx_invpcid_supported() && (!best \|\| !(best->ebx & bit(X86_FEATURE_INVPCID)) \|\| !guest_cpuid_has_pcid(vcpu))) { secondary_exec_ctl &= ~SECONDARY_EXEC_ENABLE_INVPCID; if (best) best->ebx &= ~bit(X86_FEATURE_INVPCID); } if (cpu_has_secondary_exec_ctrls()) vmcs_set_secondary_exec_control(secondary_exec_ctl); if (static_cpu_has(X86_FEATURE_PCOMMIT) && nested) { if (guest_cpuid_has_pcommit(vcpu)) vmx->nested.nested_vmx_secondary_ctls_high \|= SECONDARY_EXEC_PCOMMIT; else vmx->nested.nested_vmx_secondary_ctls_high &= ~SECONDARY_EXEC_PCOMMIT; } } static void vmx_set_supported_cpuid(u32 func, struct kvm_cpuid_entry2 entry) { if (func == 1 && nested) entry->ecx \|= bit(X86_FEATURE_VMX); } static void nested_ept_inject_page_fault(struct kvm_vcpu vcpu, struct x86_exception fault) { struct vmcs12 vmcs12 = get_vmcs12(vcpu); u32 exit_reason; if (fault->error_code & PFERR_RSVD_MASK) exit_reason = EXIT_REASON_EPT_MISCONFIG; else exit_reason = EXIT_REASON_EPT_VIOLATION; nested_vmx_vmexit(vcpu, exit_reason, 0, vcpu->arch.exit_qualification); vmcs12->guest_physical_address = fault->address; } / Callbacks for nested_ept_init_mmu_context: / static unsigned long nested_ept_get_cr3(struct kvm_vcpu vcpu) { /* return the page table to be shadowed - in our case, EPT12 / return get_vmcs12(vcpu)->ept_pointer; } static void nested_ept_init_mmu_context(struct kvm_vcpu vcpu) { WARN_ON(mmu_is_nested(vcpu)); kvm_init_shadow_ept_mmu(vcpu, to_vmx(vcpu)->nested.nested_vmx_ept_caps & VMX_EPT_EXECUTE_ONLY_BIT); vcpu->arch.mmu.set_cr3 = vmx_set_cr3; vcpu->arch.mmu.get_cr3 = nested_ept_get_cr3; vcpu->arch.mmu.inject_page_fault = nested_ept_inject_page_fault; vcpu->arch.walk_mmu = &vcpu->arch.nested_mmu; } static void nested_ept_uninit_mmu_context(struct kvm_vcpu vcpu) { vcpu->arch.walk_mmu = &vcpu->arch.mmu; } static bool nested_vmx_is_page_fault_vmexit(struct vmcs12 vmcs12, u16 error_code) { bool inequality, bit; bit = (vmcs12->exception_bitmap & (1u << PF_VECTOR)) != 0; inequality = (error_code & vmcs12->page_fault_error_code_mask) != vmcs12->page_fault_error_code_match; return inequality ^ bit; } static void vmx_inject_page_fault_nested(struct kvm_vcpu vcpu, struct x86_exception fault) { struct vmcs12 vmcs12 = get_vmcs12(vcpu); WARN_ON(!is_guest_mode(vcpu)); if (nested_vmx_is_page_fault_vmexit(vmcs12, fault->error_code)) nested_vmx_vmexit(vcpu, to_vmx(vcpu)->exit_reason, vmcs_read32(VM_EXIT_INTR_INFO), vmcs_readl(EXIT_QUALIFICATION)); else kvm_inject_page_fault(vcpu, fault); } static bool nested_get_vmcs12_pages(struct kvm_vcpu vcpu, struct vmcs12 vmcs12) { struct vcpu_vmx vmx = to_vmx(vcpu); int maxphyaddr = cpuid_maxphyaddr(vcpu); if (nested_cpu_has2(vmcs12, SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES)) { if (!PAGE_ALIGNED(vmcs12->apic_access_addr) \|\| vmcs12->apic_access_addr >> maxphyaddr) return false; /* * Translate L1 physical address to host physical * address for vmcs02. Keep the page pinned, so this * physical address remains valid. We keep a reference * to it so we can release it later. / if (vmx->nested.apic_access_page) / shouldn't happen / nested_release_page(vmx->nested.apic_access_page); vmx->nested.apic_access_page = nested_get_page(vcpu, vmcs12->apic_access_addr); } if (nested_cpu_has(vmcs12, CPU_BASED_TPR_SHADOW)) { if (!PAGE_ALIGNED(vmcs12->virtual_apic_page_addr) \|\| vmcs12->virtual_apic_page_addr >> maxphyaddr) return false; if (vmx->nested.virtual_apic_page) / shouldn't happen / nested_release_page(vmx->nested.virtual_apic_page); vmx->nested.virtual_apic_page = nested_get_page(vcpu, vmcs12->virtual_apic_page_addr); / * Failing the vm entry is _not_ what the processor does * but it's basically the only possibility we have. * We could still enter the guest if CR8 load exits are * enabled, CR8 store exits are enabled, and virtualize APIC * access is disabled; in this case the processor would never * use the TPR shadow and we could simply clear the bit from * the execution control. But such a configuration is useless, * so let's keep the code simple. / if (!vmx->nested.virtual_apic_page) return false; } if (nested_cpu_has_posted_intr(vmcs12)) { if (!IS_ALIGNED(vmcs12->posted_intr_desc_addr, 64) \|\| vmcs12->posted_intr_desc_addr >> maxphyaddr) return false; if (vmx->nested.pi_desc_page) { / shouldn't happen / kunmap(vmx->nested.pi_desc_page); nested_release_page(vmx->nested.pi_desc_page); } vmx->nested.pi_desc_page = nested_get_page(vcpu, vmcs12->posted_intr_desc_addr); if (!vmx->nested.pi_desc_page) return false; vmx->nested.pi_desc = (struct pi_desc )kmap(vmx->nested.pi_desc_page); if (!vmx->nested.pi_desc) { nested_release_page_clean(vmx->nested.pi_desc_page); return false; } vmx->nested.pi_desc = (struct pi_desc )((void )vmx->nested.pi_desc + (unsigned long)(vmcs12->posted_intr_desc_addr & (PAGE_SIZE - 1))); } return true; } static void vmx_start_preemption_timer(struct kvm_vcpu vcpu) { u64 preemption_timeout = get_vmcs12(vcpu)->vmx_preemption_timer_value; struct vcpu_vmx vmx = to_vmx(vcpu); if (vcpu->arch.virtual_tsc_khz == 0) return; /* Make sure short timeouts reliably trigger an immediate vmexit. * hrtimer_start does not guarantee this. / if (preemption_timeout <= 1) { vmx_preemption_timer_fn(&vmx->nested.preemption_timer); return; } preemption_timeout <<= VMX_MISC_EMULATED_PREEMPTION_TIMER_RATE; preemption_timeout = 1000000; do_div(preemption_timeout, vcpu->arch.virtual_tsc_khz); hrtimer_start(&vmx->nested.preemption_timer, ns_to_ktime(preemption_timeout), HRTIMER_MODE_REL); } static int nested_vmx_check_msr_bitmap_controls(struct kvm_vcpu vcpu, struct vmcs12 vmcs12) { int maxphyaddr; u64 addr; if (!nested_cpu_has(vmcs12, CPU_BASED_USE_MSR_BITMAPS)) return 0; if (vmcs12_read_any(vcpu, MSR_BITMAP, &addr)) { WARN_ON(1); return -EINVAL; } maxphyaddr = cpuid_maxphyaddr(vcpu); if (!PAGE_ALIGNED(vmcs12->msr_bitmap) \|\| ((addr + PAGE_SIZE) >> maxphyaddr)) return -EINVAL; return 0; } /* * Merge L0's and L1's MSR bitmap, return false to indicate that * we do not use the hardware. / static inline bool nested_vmx_merge_msr_bitmap(struct kvm_vcpu vcpu, struct vmcs12 vmcs12) { int msr; struct page page; unsigned long msr_bitmap; if (!nested_cpu_has_virt_x2apic_mode(vmcs12)) return false; page = nested_get_page(vcpu, vmcs12->msr_bitmap); if (!page) { WARN_ON(1); return false; } msr_bitmap = (unsigned long )kmap(page); if (!msr_bitmap) { nested_release_page_clean(page); WARN_ON(1); return false; } if (nested_cpu_has_virt_x2apic_mode(vmcs12)) { if (nested_cpu_has_apic_reg_virt(vmcs12)) for (msr = 0x800; msr <= 0x8ff; msr++) nested_vmx_disable_intercept_for_msr( msr_bitmap, vmx_msr_bitmap_nested, msr, MSR_TYPE_R); /* TPR is allowed / nested_vmx_disable_intercept_for_msr(msr_bitmap, vmx_msr_bitmap_nested, APIC_BASE_MSR + (APIC_TASKPRI >> 4), MSR_TYPE_R \| MSR_TYPE_W); if (nested_cpu_has_vid(vmcs12)) { / EOI and self-IPI are allowed / nested_vmx_disable_intercept_for_msr( msr_bitmap, vmx_msr_bitmap_nested, APIC_BASE_MSR + (APIC_EOI >> 4), MSR_TYPE_W); nested_vmx_disable_intercept_for_msr( msr_bitmap, vmx_msr_bitmap_nested, APIC_BASE_MSR + (APIC_SELF_IPI >> 4), MSR_TYPE_W); } } else { / * Enable reading intercept of all the x2apic * MSRs. We should not rely on vmcs12 to do any * optimizations here, it may have been modified * by L1. / for (msr = 0x800; msr <= 0x8ff; msr++) __vmx_enable_intercept_for_msr( vmx_msr_bitmap_nested, msr, MSR_TYPE_R); __vmx_enable_intercept_for_msr( vmx_msr_bitmap_nested, APIC_BASE_MSR + (APIC_TASKPRI >> 4), MSR_TYPE_W); __vmx_enable_intercept_for_msr( vmx_msr_bitmap_nested, APIC_BASE_MSR + (APIC_EOI >> 4), MSR_TYPE_W); __vmx_enable_intercept_for_msr( vmx_msr_bitmap_nested, APIC_BASE_MSR + (APIC_SELF_IPI >> 4), MSR_TYPE_W); } kunmap(page); nested_release_page_clean(page); return true; } static int nested_vmx_check_apicv_controls(struct kvm_vcpu vcpu, struct vmcs12 vmcs12) { if (!nested_cpu_has_virt_x2apic_mode(vmcs12) && !nested_cpu_has_apic_reg_virt(vmcs12) && !nested_cpu_has_vid(vmcs12) && !nested_cpu_has_posted_intr(vmcs12)) return 0; / * If virtualize x2apic mode is enabled, * virtualize apic access must be disabled. / if (nested_cpu_has_virt_x2apic_mode(vmcs12) && nested_cpu_has2(vmcs12, SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES)) return -EINVAL; / * If virtual interrupt delivery is enabled, * we must exit on external interrupts. / if (nested_cpu_has_vid(vmcs12) && !nested_exit_on_intr(vcpu)) return -EINVAL; / * bits 15:8 should be zero in posted_intr_nv, * the descriptor address has been already checked * in nested_get_vmcs12_pages. / if (nested_cpu_has_posted_intr(vmcs12) && (!nested_cpu_has_vid(vmcs12) \|\| !nested_exit_intr_ack_set(vcpu) \|\| vmcs12->posted_intr_nv & 0xff00)) return -EINVAL; / tpr shadow is needed by all apicv features. / if (!nested_cpu_has(vmcs12, CPU_BASED_TPR_SHADOW)) return -EINVAL; return 0; } static int nested_vmx_check_msr_switch(struct kvm_vcpu vcpu, unsigned long count_field, unsigned long addr_field) { int maxphyaddr; u64 count, addr; if (vmcs12_read_any(vcpu, count_field, &count) \|\| vmcs12_read_any(vcpu, addr_field, &addr)) { WARN_ON(1); return -EINVAL; } if (count == 0) return 0; maxphyaddr = cpuid_maxphyaddr(vcpu); if (!IS_ALIGNED(addr, 16) \|\| addr >> maxphyaddr \|\| (addr + count * sizeof(struct vmx_msr_entry) - 1) >> maxphyaddr) { pr_warn_ratelimited( "nVMX: invalid MSR switch (0x%lx, %d, %llu, 0x%08llx)", addr_field, maxphyaddr, count, addr); return -EINVAL; } return 0; } static int nested_vmx_check_msr_switch_controls(struct kvm_vcpu vcpu, struct vmcs12 vmcs12) { if (vmcs12->vm_exit_msr_load_count == 0 && vmcs12->vm_exit_msr_store_count == 0 && vmcs12->vm_entry_msr_load_count == 0) return 0; /* Fast path / if (nested_vmx_check_msr_switch(vcpu, VM_EXIT_MSR_LOAD_COUNT, VM_EXIT_MSR_LOAD_ADDR) \|\| nested_vmx_check_msr_switch(vcpu, VM_EXIT_MSR_STORE_COUNT, VM_EXIT_MSR_STORE_ADDR) \|\| nested_vmx_check_msr_switch(vcpu, VM_ENTRY_MSR_LOAD_COUNT, VM_ENTRY_MSR_LOAD_ADDR)) return -EINVAL; return 0; } static int nested_vmx_msr_check_common(struct kvm_vcpu vcpu, struct vmx_msr_entry e) { / x2APIC MSR accesses are not allowed / if (vcpu->arch.apic_base & X2APIC_ENABLE && e->index >> 8 == 0x8) return -EINVAL; if (e->index == MSR_IA32_UCODE_WRITE \|\| / SDM Table 35-2 / e->index == MSR_IA32_UCODE_REV) return -EINVAL; if (e->reserved != 0) return -EINVAL; return 0; } static int nested_vmx_load_msr_check(struct kvm_vcpu vcpu, struct vmx_msr_entry e) { if (e->index == MSR_FS_BASE \|\| e->index == MSR_GS_BASE \|\| e->index == MSR_IA32_SMM_MONITOR_CTL \|\| / SMM is not supported / nested_vmx_msr_check_common(vcpu, e)) return -EINVAL; return 0; } static int nested_vmx_store_msr_check(struct kvm_vcpu vcpu, struct vmx_msr_entry e) { if (e->index == MSR_IA32_SMBASE \|\| / SMM is not supported / nested_vmx_msr_check_common(vcpu, e)) return -EINVAL; return 0; } / * Load guest's/host's msr at nested entry/exit. * return 0 for success, entry index for failure. / static u32 nested_vmx_load_msr(struct kvm_vcpu vcpu, u64 gpa, u32 count) { u32 i; struct vmx_msr_entry e; struct msr_data msr; msr.host_initiated = false; for (i = 0; i < count; i++) { if (kvm_vcpu_read_guest(vcpu, gpa + i * sizeof(e), &e, sizeof(e))) { pr_warn_ratelimited( "%s cannot read MSR entry (%u, 0x%08llx)\n", __func__, i, gpa + i * sizeof(e)); goto fail; } if (nested_vmx_load_msr_check(vcpu, &e)) { pr_warn_ratelimited( "%s check failed (%u, 0x%x, 0x%x)\n", __func__, i, e.index, e.reserved); goto fail; } msr.index = e.index; msr.data = e.value; if (kvm_set_msr(vcpu, &msr)) { pr_warn_ratelimited( "%s cannot write MSR (%u, 0x%x, 0x%llx)\n", __func__, i, e.index, e.value); goto fail; } } return 0; fail: return i + 1; } static int nested_vmx_store_msr(struct kvm_vcpu vcpu, u64 gpa, u32 count) { u32 i; struct vmx_msr_entry e; for (i = 0; i < count; i++) { struct msr_data msr_info; if (kvm_vcpu_read_guest(vcpu, gpa + i sizeof(e), &e, 2 * sizeof(u32))) { pr_warn_ratelimited( "%s cannot read MSR entry (%u, 0x%08llx)\n", __func__, i, gpa + i * sizeof(e)); return -EINVAL; } if (nested_vmx_store_msr_check(vcpu, &e)) { pr_warn_ratelimited( "%s check failed (%u, 0x%x, 0x%x)\n", __func__, i, e.index, e.reserved); return -EINVAL; } msr_info.host_initiated = false; msr_info.index = e.index; if (kvm_get_msr(vcpu, &msr_info)) { pr_warn_ratelimited( "%s cannot read MSR (%u, 0x%x)\n", __func__, i, e.index); return -EINVAL; } if (kvm_vcpu_write_guest(vcpu, gpa + i * sizeof(e) + offsetof(struct vmx_msr_entry, value), &msr_info.data, sizeof(msr_info.data))) { pr_warn_ratelimited( "%s cannot write MSR (%u, 0x%x, 0x%llx)\n", __func__, i, e.index, msr_info.data); return -EINVAL; } } return 0; } /* * prepare_vmcs02 is called when the L1 guest hypervisor runs its nested * L2 guest. L1 has a vmcs for L2 (vmcs12), and this function "merges" it * with L0's requirements for its guest (a.k.a. vmcs01), so we can run the L2 * guest in a way that will both be appropriate to L1's requests, and our * needs. In addition to modifying the active vmcs (which is vmcs02), this * function also has additional necessary side-effects, like setting various * vcpu->arch fields. / static void prepare_vmcs02(struct kvm_vcpu vcpu, struct vmcs12 vmcs12) { struct vcpu_vmx vmx = to_vmx(vcpu); u32 exec_control; vmcs_write16(GUEST_ES_SELECTOR, vmcs12->guest_es_selector); vmcs_write16(GUEST_CS_SELECTOR, vmcs12->guest_cs_selector); vmcs_write16(GUEST_SS_SELECTOR, vmcs12->guest_ss_selector); vmcs_write16(GUEST_DS_SELECTOR, vmcs12->guest_ds_selector); vmcs_write16(GUEST_FS_SELECTOR, vmcs12->guest_fs_selector); vmcs_write16(GUEST_GS_SELECTOR, vmcs12->guest_gs_selector); vmcs_write16(GUEST_LDTR_SELECTOR, vmcs12->guest_ldtr_selector); vmcs_write16(GUEST_TR_SELECTOR, vmcs12->guest_tr_selector); vmcs_write32(GUEST_ES_LIMIT, vmcs12->guest_es_limit); vmcs_write32(GUEST_CS_LIMIT, vmcs12->guest_cs_limit); vmcs_write32(GUEST_SS_LIMIT, vmcs12->guest_ss_limit); vmcs_write32(GUEST_DS_LIMIT, vmcs12->guest_ds_limit); vmcs_write32(GUEST_FS_LIMIT, vmcs12->guest_fs_limit); vmcs_write32(GUEST_GS_LIMIT, vmcs12->guest_gs_limit); vmcs_write32(GUEST_LDTR_LIMIT, vmcs12->guest_ldtr_limit); vmcs_write32(GUEST_TR_LIMIT, vmcs12->guest_tr_limit); vmcs_write32(GUEST_GDTR_LIMIT, vmcs12->guest_gdtr_limit); vmcs_write32(GUEST_IDTR_LIMIT, vmcs12->guest_idtr_limit); vmcs_write32(GUEST_ES_AR_BYTES, vmcs12->guest_es_ar_bytes); vmcs_write32(GUEST_CS_AR_BYTES, vmcs12->guest_cs_ar_bytes); vmcs_write32(GUEST_SS_AR_BYTES, vmcs12->guest_ss_ar_bytes); vmcs_write32(GUEST_DS_AR_BYTES, vmcs12->guest_ds_ar_bytes); vmcs_write32(GUEST_FS_AR_BYTES, vmcs12->guest_fs_ar_bytes); vmcs_write32(GUEST_GS_AR_BYTES, vmcs12->guest_gs_ar_bytes); vmcs_write32(GUEST_LDTR_AR_BYTES, vmcs12->guest_ldtr_ar_bytes); vmcs_write32(GUEST_TR_AR_BYTES, vmcs12->guest_tr_ar_bytes); vmcs_writel(GUEST_ES_BASE, vmcs12->guest_es_base); vmcs_writel(GUEST_CS_BASE, vmcs12->guest_cs_base); vmcs_writel(GUEST_SS_BASE, vmcs12->guest_ss_base); vmcs_writel(GUEST_DS_BASE, vmcs12->guest_ds_base); vmcs_writel(GUEST_FS_BASE, vmcs12->guest_fs_base); vmcs_writel(GUEST_GS_BASE, vmcs12->guest_gs_base); vmcs_writel(GUEST_LDTR_BASE, vmcs12->guest_ldtr_base); vmcs_writel(GUEST_TR_BASE, vmcs12->guest_tr_base); vmcs_writel(GUEST_GDTR_BASE, vmcs12->guest_gdtr_base); vmcs_writel(GUEST_IDTR_BASE, vmcs12->guest_idtr_base); if (vmcs12->vm_entry_controls & VM_ENTRY_LOAD_DEBUG_CONTROLS) { kvm_set_dr(vcpu, 7, vmcs12->guest_dr7); vmcs_write64(GUEST_IA32_DEBUGCTL, vmcs12->guest_ia32_debugctl); } else { kvm_set_dr(vcpu, 7, vcpu->arch.dr7); vmcs_write64(GUEST_IA32_DEBUGCTL, vmx->nested.vmcs01_debugctl); } vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, vmcs12->vm_entry_intr_info_field); vmcs_write32(VM_ENTRY_EXCEPTION_ERROR_CODE, vmcs12->vm_entry_exception_error_code); vmcs_write32(VM_ENTRY_INSTRUCTION_LEN, vmcs12->vm_entry_instruction_len); vmcs_write32(GUEST_INTERRUPTIBILITY_INFO, vmcs12->guest_interruptibility_info); vmcs_write32(GUEST_SYSENTER_CS, vmcs12->guest_sysenter_cs); vmx_set_rflags(vcpu, vmcs12->guest_rflags); vmcs_writel(GUEST_PENDING_DBG_EXCEPTIONS, vmcs12->guest_pending_dbg_exceptions); vmcs_writel(GUEST_SYSENTER_ESP, vmcs12->guest_sysenter_esp); vmcs_writel(GUEST_SYSENTER_EIP, vmcs12->guest_sysenter_eip); if (nested_cpu_has_xsaves(vmcs12)) vmcs_write64(XSS_EXIT_BITMAP, vmcs12->xss_exit_bitmap); vmcs_write64(VMCS_LINK_POINTER, -1ull); exec_control = vmcs12->pin_based_vm_exec_control; exec_control \|= vmcs_config.pin_based_exec_ctrl; exec_control &= ~PIN_BASED_VMX_PREEMPTION_TIMER; if (nested_cpu_has_posted_intr(vmcs12)) { /* * Note that we use L0's vector here and in * vmx_deliver_nested_posted_interrupt. / vmx->nested.posted_intr_nv = vmcs12->posted_intr_nv; vmx->nested.pi_pending = false; vmcs_write16(POSTED_INTR_NV, POSTED_INTR_VECTOR); vmcs_write64(POSTED_INTR_DESC_ADDR, page_to_phys(vmx->nested.pi_desc_page) + (unsigned long)(vmcs12->posted_intr_desc_addr & (PAGE_SIZE - 1))); } else exec_control &= ~PIN_BASED_POSTED_INTR; vmcs_write32(PIN_BASED_VM_EXEC_CONTROL, exec_control); vmx->nested.preemption_timer_expired = false; if (nested_cpu_has_preemption_timer(vmcs12)) vmx_start_preemption_timer(vcpu); / * Whether page-faults are trapped is determined by a combination of * 3 settings: PFEC_MASK, PFEC_MATCH and EXCEPTION_BITMAP.PF. * If enable_ept, L0 doesn't care about page faults and we should * set all of these to L1's desires. However, if !enable_ept, L0 does * care about (at least some) page faults, and because it is not easy * (if at all possible?) to merge L0 and L1's desires, we simply ask * to exit on each and every L2 page fault. This is done by setting * MASK=MATCH=0 and (see below) EB.PF=1. * Note that below we don't need special code to set EB.PF beyond the * "or"ing of the EB of vmcs01 and vmcs12, because when enable_ept, * vmcs01's EB.PF is 0 so the "or" will take vmcs12's value, and when * !enable_ept, EB.PF is 1, so the "or" will always be 1. * * A problem with this approach (when !enable_ept) is that L1 may be * injected with more page faults than it asked for. This could have * caused problems, but in practice existing hypervisors don't care. * To fix this, we will need to emulate the PFEC checking (on the L1 * page tables), using walk_addr(), when injecting PFs to L1. / vmcs_write32(PAGE_FAULT_ERROR_CODE_MASK, enable_ept ? vmcs12->page_fault_error_code_mask : 0); vmcs_write32(PAGE_FAULT_ERROR_CODE_MATCH, enable_ept ? vmcs12->page_fault_error_code_match : 0); if (cpu_has_secondary_exec_ctrls()) { exec_control = vmx_secondary_exec_control(vmx); / Take the following fields only from vmcs12 / exec_control &= ~(SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES \| SECONDARY_EXEC_RDTSCP \| SECONDARY_EXEC_VIRTUAL_INTR_DELIVERY \| SECONDARY_EXEC_APIC_REGISTER_VIRT \| SECONDARY_EXEC_PCOMMIT); if (nested_cpu_has(vmcs12, CPU_BASED_ACTIVATE_SECONDARY_CONTROLS)) exec_control \|= vmcs12->secondary_vm_exec_control; if (exec_control & SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES) { / * If translation failed, no matter: This feature asks * to exit when accessing the given address, and if it * can never be accessed, this feature won't do * anything anyway. / if (!vmx->nested.apic_access_page) exec_control &= ~SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES; else vmcs_write64(APIC_ACCESS_ADDR, page_to_phys(vmx->nested.apic_access_page)); } else if (!(nested_cpu_has_virt_x2apic_mode(vmcs12)) && cpu_need_virtualize_apic_accesses(&vmx->vcpu)) { exec_control \|= SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES; kvm_vcpu_reload_apic_access_page(vcpu); } if (exec_control & SECONDARY_EXEC_VIRTUAL_INTR_DELIVERY) { vmcs_write64(EOI_EXIT_BITMAP0, vmcs12->eoi_exit_bitmap0); vmcs_write64(EOI_EXIT_BITMAP1, vmcs12->eoi_exit_bitmap1); vmcs_write64(EOI_EXIT_BITMAP2, vmcs12->eoi_exit_bitmap2); vmcs_write64(EOI_EXIT_BITMAP3, vmcs12->eoi_exit_bitmap3); vmcs_write16(GUEST_INTR_STATUS, vmcs12->guest_intr_status); } vmcs_write32(SECONDARY_VM_EXEC_CONTROL, exec_control); } / * Set host-state according to L0's settings (vmcs12 is irrelevant here) * Some constant fields are set here by vmx_set_constant_host_state(). * Other fields are different per CPU, and will be set later when * vmx_vcpu_load() is called, and when vmx_save_host_state() is called. / vmx_set_constant_host_state(vmx); / * HOST_RSP is normally set correctly in vmx_vcpu_run() just before * entry, but only if the current (host) sp changed from the value * we wrote last (vmx->host_rsp). This cache is no longer relevant * if we switch vmcs, and rather than hold a separate cache per vmcs, * here we just force the write to happen on entry. / vmx->host_rsp = 0; exec_control = vmx_exec_control(vmx); / L0's desires / exec_control &= ~CPU_BASED_VIRTUAL_INTR_PENDING; exec_control &= ~CPU_BASED_VIRTUAL_NMI_PENDING; exec_control &= ~CPU_BASED_TPR_SHADOW; exec_control \|= vmcs12->cpu_based_vm_exec_control; if (exec_control & CPU_BASED_TPR_SHADOW) { vmcs_write64(VIRTUAL_APIC_PAGE_ADDR, page_to_phys(vmx->nested.virtual_apic_page)); vmcs_write32(TPR_THRESHOLD, vmcs12->tpr_threshold); } if (cpu_has_vmx_msr_bitmap() && exec_control & CPU_BASED_USE_MSR_BITMAPS) { nested_vmx_merge_msr_bitmap(vcpu, vmcs12); / MSR_BITMAP will be set by following vmx_set_efer. / } else exec_control &= ~CPU_BASED_USE_MSR_BITMAPS; / * Merging of IO bitmap not currently supported. * Rather, exit every time. / exec_control &= ~CPU_BASED_USE_IO_BITMAPS; exec_control \|= CPU_BASED_UNCOND_IO_EXITING; vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, exec_control); / EXCEPTION_BITMAP and CR0_GUEST_HOST_MASK should basically be the * bitwise-or of what L1 wants to trap for L2, and what we want to * trap. Note that CR0.TS also needs updating - we do this later. / update_exception_bitmap(vcpu); vcpu->arch.cr0_guest_owned_bits &= ~vmcs12->cr0_guest_host_mask; vmcs_writel(CR0_GUEST_HOST_MASK, ~vcpu->arch.cr0_guest_owned_bits); / L2->L1 exit controls are emulated - the hardware exit is to L0 so * we should use its exit controls. Note that VM_EXIT_LOAD_IA32_EFER * bits are further modified by vmx_set_efer() below. / vmcs_write32(VM_EXIT_CONTROLS, vmcs_config.vmexit_ctrl); / vmcs12's VM_ENTRY_LOAD_IA32_EFER and VM_ENTRY_IA32E_MODE are * emulated by vmx_set_efer(), below. / vm_entry_controls_init(vmx, (vmcs12->vm_entry_controls & ~VM_ENTRY_LOAD_IA32_EFER & ~VM_ENTRY_IA32E_MODE) \| (vmcs_config.vmentry_ctrl & ~VM_ENTRY_IA32E_MODE)); if (vmcs12->vm_entry_controls & VM_ENTRY_LOAD_IA32_PAT) { vmcs_write64(GUEST_IA32_PAT, vmcs12->guest_ia32_pat); vcpu->arch.pat = vmcs12->guest_ia32_pat; } else if (vmcs_config.vmentry_ctrl & VM_ENTRY_LOAD_IA32_PAT) vmcs_write64(GUEST_IA32_PAT, vmx->vcpu.arch.pat); set_cr4_guest_host_mask(vmx); if (vmcs12->vm_entry_controls & VM_ENTRY_LOAD_BNDCFGS) vmcs_write64(GUEST_BNDCFGS, vmcs12->guest_bndcfgs); if (vmcs12->cpu_based_vm_exec_control & CPU_BASED_USE_TSC_OFFSETING) vmcs_write64(TSC_OFFSET, vmx->nested.vmcs01_tsc_offset + vmcs12->tsc_offset); else vmcs_write64(TSC_OFFSET, vmx->nested.vmcs01_tsc_offset); if (enable_vpid) { / * There is no direct mapping between vpid02 and vpid12, the * vpid02 is per-vCPU for L0 and reused while the value of * vpid12 is changed w/ one invvpid during nested vmentry. * The vpid12 is allocated by L1 for L2, so it will not * influence global bitmap(for vpid01 and vpid02 allocation) * even if spawn a lot of nested vCPUs. / if (nested_cpu_has_vpid(vmcs12) && vmx->nested.vpid02) { vmcs_write16(VIRTUAL_PROCESSOR_ID, vmx->nested.vpid02); if (vmcs12->virtual_processor_id != vmx->nested.last_vpid) { vmx->nested.last_vpid = vmcs12->virtual_processor_id; __vmx_flush_tlb(vcpu, to_vmx(vcpu)->nested.vpid02); } } else { vmcs_write16(VIRTUAL_PROCESSOR_ID, vmx->vpid); vmx_flush_tlb(vcpu); } } if (nested_cpu_has_ept(vmcs12)) { kvm_mmu_unload(vcpu); nested_ept_init_mmu_context(vcpu); } if (vmcs12->vm_entry_controls & VM_ENTRY_LOAD_IA32_EFER) vcpu->arch.efer = vmcs12->guest_ia32_efer; else if (vmcs12->vm_entry_controls & VM_ENTRY_IA32E_MODE) vcpu->arch.efer \|= (EFER_LMA \| EFER_LME); else vcpu->arch.efer &= ~(EFER_LMA \| EFER_LME); / Note: modifies VM_ENTRY/EXIT_CONTROLS and GUEST/HOST_IA32_EFER / vmx_set_efer(vcpu, vcpu->arch.efer); / * This sets GUEST_CR0 to vmcs12->guest_cr0, with possibly a modified * TS bit (for lazy fpu) and bits which we consider mandatory enabled. * The CR0_READ_SHADOW is what L2 should have expected to read given * the specifications by L1; It's not enough to take * vmcs12->cr0_read_shadow because on our cr0_guest_host_mask we we * have more bits than L1 expected. / vmx_set_cr0(vcpu, vmcs12->guest_cr0); vmcs_writel(CR0_READ_SHADOW, nested_read_cr0(vmcs12)); vmx_set_cr4(vcpu, vmcs12->guest_cr4); vmcs_writel(CR4_READ_SHADOW, nested_read_cr4(vmcs12)); / shadow page tables on either EPT or shadow page tables / kvm_set_cr3(vcpu, vmcs12->guest_cr3); kvm_mmu_reset_context(vcpu); if (!enable_ept) vcpu->arch.walk_mmu->inject_page_fault = vmx_inject_page_fault_nested; / * L1 may access the L2's PDPTR, so save them to construct vmcs12 / if (enable_ept) { vmcs_write64(GUEST_PDPTR0, vmcs12->guest_pdptr0); vmcs_write64(GUEST_PDPTR1, vmcs12->guest_pdptr1); vmcs_write64(GUEST_PDPTR2, vmcs12->guest_pdptr2); vmcs_write64(GUEST_PDPTR3, vmcs12->guest_pdptr3); } kvm_register_write(vcpu, VCPU_REGS_RSP, vmcs12->guest_rsp); kvm_register_write(vcpu, VCPU_REGS_RIP, vmcs12->guest_rip); } / * nested_vmx_run() handles a nested entry, i.e., a VMLAUNCH or VMRESUME on L1 * for running an L2 nested guest. / static int nested_vmx_run(struct kvm_vcpu vcpu, bool launch) { struct vmcs12 vmcs12; struct vcpu_vmx vmx = to_vmx(vcpu); int cpu; struct loaded_vmcs vmcs02; bool ia32e; u32 msr_entry_idx; if (!nested_vmx_check_permission(vcpu) \|\| !nested_vmx_check_vmcs12(vcpu)) return 1; skip_emulated_instruction(vcpu); vmcs12 = get_vmcs12(vcpu); if (enable_shadow_vmcs) copy_shadow_to_vmcs12(vmx); / * The nested entry process starts with enforcing various prerequisites * on vmcs12 as required by the Intel SDM, and act appropriately when * they fail: As the SDM explains, some conditions should cause the * instruction to fail, while others will cause the instruction to seem * to succeed, but return an EXIT_REASON_INVALID_STATE. * To speed up the normal (success) code path, we should avoid checking * for misconfigurations which will anyway be caught by the processor * when using the merged vmcs02. / if (vmcs12->launch_state == launch) { nested_vmx_failValid(vcpu, launch ? VMXERR_VMLAUNCH_NONCLEAR_VMCS : VMXERR_VMRESUME_NONLAUNCHED_VMCS); return 1; } if (vmcs12->guest_activity_state != GUEST_ACTIVITY_ACTIVE && vmcs12->guest_activity_state != GUEST_ACTIVITY_HLT) { nested_vmx_failValid(vcpu, VMXERR_ENTRY_INVALID_CONTROL_FIELD); return 1; } if (!nested_get_vmcs12_pages(vcpu, vmcs12)) { nested_vmx_failValid(vcpu, VMXERR_ENTRY_INVALID_CONTROL_FIELD); return 1; } if (nested_vmx_check_msr_bitmap_controls(vcpu, vmcs12)) { nested_vmx_failValid(vcpu, VMXERR_ENTRY_INVALID_CONTROL_FIELD); return 1; } if (nested_vmx_check_apicv_controls(vcpu, vmcs12)) { nested_vmx_failValid(vcpu, VMXERR_ENTRY_INVALID_CONTROL_FIELD); return 1; } if (nested_vmx_check_msr_switch_controls(vcpu, vmcs12)) { nested_vmx_failValid(vcpu, VMXERR_ENTRY_INVALID_CONTROL_FIELD); return 1; } if (!vmx_control_verify(vmcs12->cpu_based_vm_exec_control, vmx->nested.nested_vmx_true_procbased_ctls_low, vmx->nested.nested_vmx_procbased_ctls_high) \|\| !vmx_control_verify(vmcs12->secondary_vm_exec_control, vmx->nested.nested_vmx_secondary_ctls_low, vmx->nested.nested_vmx_secondary_ctls_high) \|\| !vmx_control_verify(vmcs12->pin_based_vm_exec_control, vmx->nested.nested_vmx_pinbased_ctls_low, vmx->nested.nested_vmx_pinbased_ctls_high) \|\| !vmx_control_verify(vmcs12->vm_exit_controls, vmx->nested.nested_vmx_true_exit_ctls_low, vmx->nested.nested_vmx_exit_ctls_high) \|\| !vmx_control_verify(vmcs12->vm_entry_controls, vmx->nested.nested_vmx_true_entry_ctls_low, vmx->nested.nested_vmx_entry_ctls_high)) { nested_vmx_failValid(vcpu, VMXERR_ENTRY_INVALID_CONTROL_FIELD); return 1; } if (((vmcs12->host_cr0 & VMXON_CR0_ALWAYSON) != VMXON_CR0_ALWAYSON) \|\| ((vmcs12->host_cr4 & VMXON_CR4_ALWAYSON) != VMXON_CR4_ALWAYSON)) { nested_vmx_failValid(vcpu, VMXERR_ENTRY_INVALID_HOST_STATE_FIELD); return 1; } if (!nested_cr0_valid(vcpu, vmcs12->guest_cr0) \|\| ((vmcs12->guest_cr4 & VMXON_CR4_ALWAYSON) != VMXON_CR4_ALWAYSON)) { nested_vmx_entry_failure(vcpu, vmcs12, EXIT_REASON_INVALID_STATE, ENTRY_FAIL_DEFAULT); return 1; } if (vmcs12->vmcs_link_pointer != -1ull) { nested_vmx_entry_failure(vcpu, vmcs12, EXIT_REASON_INVALID_STATE, ENTRY_FAIL_VMCS_LINK_PTR); return 1; } / * If the load IA32_EFER VM-entry control is 1, the following checks * are performed on the field for the IA32_EFER MSR: * - Bits reserved in the IA32_EFER MSR must be 0. * - Bit 10 (corresponding to IA32_EFER.LMA) must equal the value of * the IA-32e mode guest VM-exit control. It must also be identical * to bit 8 (LME) if bit 31 in the CR0 field (corresponding to * CR0.PG) is 1. / if (vmcs12->vm_entry_controls & VM_ENTRY_LOAD_IA32_EFER) { ia32e = (vmcs12->vm_entry_controls & VM_ENTRY_IA32E_MODE) != 0; if (!kvm_valid_efer(vcpu, vmcs12->guest_ia32_efer) \|\| ia32e != !!(vmcs12->guest_ia32_efer & EFER_LMA) \|\| ((vmcs12->guest_cr0 & X86_CR0_PG) && ia32e != !!(vmcs12->guest_ia32_efer & EFER_LME))) { nested_vmx_entry_failure(vcpu, vmcs12, EXIT_REASON_INVALID_STATE, ENTRY_FAIL_DEFAULT); return 1; } } / * If the load IA32_EFER VM-exit control is 1, bits reserved in the * IA32_EFER MSR must be 0 in the field for that register. In addition, * the values of the LMA and LME bits in the field must each be that of * the host address-space size VM-exit control. / if (vmcs12->vm_exit_controls & VM_EXIT_LOAD_IA32_EFER) { ia32e = (vmcs12->vm_exit_controls & VM_EXIT_HOST_ADDR_SPACE_SIZE) != 0; if (!kvm_valid_efer(vcpu, vmcs12->host_ia32_efer) \|\| ia32e != !!(vmcs12->host_ia32_efer & EFER_LMA) \|\| ia32e != !!(vmcs12->host_ia32_efer & EFER_LME)) { nested_vmx_entry_failure(vcpu, vmcs12, EXIT_REASON_INVALID_STATE, ENTRY_FAIL_DEFAULT); return 1; } } / * We're finally done with prerequisite checking, and can start with * the nested entry. / vmcs02 = nested_get_current_vmcs02(vmx); if (!vmcs02) return -ENOMEM; enter_guest_mode(vcpu); vmx->nested.vmcs01_tsc_offset = vmcs_read64(TSC_OFFSET); if (!(vmcs12->vm_entry_controls & VM_ENTRY_LOAD_DEBUG_CONTROLS)) vmx->nested.vmcs01_debugctl = vmcs_read64(GUEST_IA32_DEBUGCTL); cpu = get_cpu(); vmx->loaded_vmcs = vmcs02; vmx_vcpu_put(vcpu); vmx_vcpu_load(vcpu, cpu); vcpu->cpu = cpu; put_cpu(); vmx_segment_cache_clear(vmx); prepare_vmcs02(vcpu, vmcs12); msr_entry_idx = nested_vmx_load_msr(vcpu, vmcs12->vm_entry_msr_load_addr, vmcs12->vm_entry_msr_load_count); if (msr_entry_idx) { leave_guest_mode(vcpu); vmx_load_vmcs01(vcpu); nested_vmx_entry_failure(vcpu, vmcs12, EXIT_REASON_MSR_LOAD_FAIL, msr_entry_idx); return 1; } vmcs12->launch_state = 1; if (vmcs12->guest_activity_state == GUEST_ACTIVITY_HLT) return kvm_vcpu_halt(vcpu); vmx->nested.nested_run_pending = 1; / * Note no nested_vmx_succeed or nested_vmx_fail here. At this point * we are no longer running L1, and VMLAUNCH/VMRESUME has not yet * returned as far as L1 is concerned. It will only return (and set * the success flag) when L2 exits (see nested_vmx_vmexit()). / return 1; } / * On a nested exit from L2 to L1, vmcs12.guest_cr0 might not be up-to-date * because L2 may have changed some cr0 bits directly (CRO_GUEST_HOST_MASK). * This function returns the new value we should put in vmcs12.guest_cr0. * It's not enough to just return the vmcs02 GUEST_CR0. Rather, * 1. Bits that neither L0 nor L1 trapped, were set directly by L2 and are now * available in vmcs02 GUEST_CR0. (Note: It's enough to check that L0 * didn't trap the bit, because if L1 did, so would L0). * 2. Bits that L1 asked to trap (and therefore L0 also did) could not have * been modified by L2, and L1 knows it. So just leave the old value of * the bit from vmcs12.guest_cr0. Note that the bit from vmcs02 GUEST_CR0 * isn't relevant, because if L0 traps this bit it can set it to anything. * 3. Bits that L1 didn't trap, but L0 did. L1 believes the guest could have * changed these bits, and therefore they need to be updated, but L0 * didn't necessarily allow them to be changed in GUEST_CR0 - and rather * put them in vmcs02 CR0_READ_SHADOW. So take these bits from there. / static inline unsigned long vmcs12_guest_cr0(struct kvm_vcpu vcpu, struct vmcs12 vmcs12) { return /1/ (vmcs_readl(GUEST_CR0) & vcpu->arch.cr0_guest_owned_bits) \| /2/ (vmcs12->guest_cr0 & vmcs12->cr0_guest_host_mask) \| /3/ (vmcs_readl(CR0_READ_SHADOW) & ~(vmcs12->cr0_guest_host_mask \| vcpu->arch.cr0_guest_owned_bits)); } static inline unsigned long vmcs12_guest_cr4(struct kvm_vcpu vcpu, struct vmcs12 vmcs12) { return /1/ (vmcs_readl(GUEST_CR4) & vcpu->arch.cr4_guest_owned_bits) \| /2/ (vmcs12->guest_cr4 & vmcs12->cr4_guest_host_mask) \| /3/ (vmcs_readl(CR4_READ_SHADOW) & ~(vmcs12->cr4_guest_host_mask \| vcpu->arch.cr4_guest_owned_bits)); } static void vmcs12_save_pending_event(struct kvm_vcpu vcpu, struct vmcs12 vmcs12) { u32 idt_vectoring; unsigned int nr; if (vcpu->arch.exception.pending && vcpu->arch.exception.reinject) { nr = vcpu->arch.exception.nr; idt_vectoring = nr \| VECTORING_INFO_VALID_MASK; if (kvm_exception_is_soft(nr)) { vmcs12->vm_exit_instruction_len = vcpu->arch.event_exit_inst_len; idt_vectoring \|= INTR_TYPE_SOFT_EXCEPTION; } else idt_vectoring \|= INTR_TYPE_HARD_EXCEPTION; if (vcpu->arch.exception.has_error_code) { idt_vectoring \|= VECTORING_INFO_DELIVER_CODE_MASK; vmcs12->idt_vectoring_error_code = vcpu->arch.exception.error_code; } vmcs12->idt_vectoring_info_field = idt_vectoring; } else if (vcpu->arch.nmi_injected) { vmcs12->idt_vectoring_info_field = INTR_TYPE_NMI_INTR \| INTR_INFO_VALID_MASK \| NMI_VECTOR; } else if (vcpu->arch.interrupt.pending) { nr = vcpu->arch.interrupt.nr; idt_vectoring = nr \| VECTORING_INFO_VALID_MASK; if (vcpu->arch.interrupt.soft) { idt_vectoring \|= INTR_TYPE_SOFT_INTR; vmcs12->vm_entry_instruction_len = vcpu->arch.event_exit_inst_len; } else idt_vectoring \|= INTR_TYPE_EXT_INTR; vmcs12->idt_vectoring_info_field = idt_vectoring; } } static int vmx_check_nested_events(struct kvm_vcpu vcpu, bool external_intr) { struct vcpu_vmx vmx = to_vmx(vcpu); if (nested_cpu_has_preemption_timer(get_vmcs12(vcpu)) && vmx->nested.preemption_timer_expired) { if (vmx->nested.nested_run_pending) return -EBUSY; nested_vmx_vmexit(vcpu, EXIT_REASON_PREEMPTION_TIMER, 0, 0); return 0; } if (vcpu->arch.nmi_pending && nested_exit_on_nmi(vcpu)) { if (vmx->nested.nested_run_pending \|\| vcpu->arch.interrupt.pending) return -EBUSY; nested_vmx_vmexit(vcpu, EXIT_REASON_EXCEPTION_NMI, NMI_VECTOR \| INTR_TYPE_NMI_INTR \| INTR_INFO_VALID_MASK, 0); / * The NMI-triggered VM exit counts as injection: * clear this one and block further NMIs. / vcpu->arch.nmi_pending = 0; vmx_set_nmi_mask(vcpu, true); return 0; } if ((kvm_cpu_has_interrupt(vcpu) \|\| external_intr) && nested_exit_on_intr(vcpu)) { if (vmx->nested.nested_run_pending) return -EBUSY; nested_vmx_vmexit(vcpu, EXIT_REASON_EXTERNAL_INTERRUPT, 0, 0); return 0; } return vmx_complete_nested_posted_interrupt(vcpu); } static u32 vmx_get_preemption_timer_value(struct kvm_vcpu vcpu) { ktime_t remaining = hrtimer_get_remaining(&to_vmx(vcpu)->nested.preemption_timer); u64 value; if (ktime_to_ns(remaining) <= 0) return 0; value = ktime_to_ns(remaining) * vcpu->arch.virtual_tsc_khz; do_div(value, 1000000); return value >> VMX_MISC_EMULATED_PREEMPTION_TIMER_RATE; } /* * prepare_vmcs12 is part of what we need to do when the nested L2 guest exits * and we want to prepare to run its L1 parent. L1 keeps a vmcs for L2 (vmcs12), * and this function updates it to reflect the changes to the guest state while * L2 was running (and perhaps made some exits which were handled directly by L0 * without going back to L1), and to reflect the exit reason. * Note that we do not have to copy here all VMCS fields, just those that * could have changed by the L2 guest or the exit - i.e., the guest-state and * exit-information fields only. Other fields are modified by L1 with VMWRITE, * which already writes to vmcs12 directly. / static void prepare_vmcs12(struct kvm_vcpu vcpu, struct vmcs12 vmcs12, u32 exit_reason, u32 exit_intr_info, unsigned long exit_qualification) { / update guest state fields: / vmcs12->guest_cr0 = vmcs12_guest_cr0(vcpu, vmcs12); vmcs12->guest_cr4 = vmcs12_guest_cr4(vcpu, vmcs12); vmcs12->guest_rsp = kvm_register_read(vcpu, VCPU_REGS_RSP); vmcs12->guest_rip = kvm_register_read(vcpu, VCPU_REGS_RIP); vmcs12->guest_rflags = vmcs_readl(GUEST_RFLAGS); vmcs12->guest_es_selector = vmcs_read16(GUEST_ES_SELECTOR); vmcs12->guest_cs_selector = vmcs_read16(GUEST_CS_SELECTOR); vmcs12->guest_ss_selector = vmcs_read16(GUEST_SS_SELECTOR); vmcs12->guest_ds_selector = vmcs_read16(GUEST_DS_SELECTOR); vmcs12->guest_fs_selector = vmcs_read16(GUEST_FS_SELECTOR); vmcs12->guest_gs_selector = vmcs_read16(GUEST_GS_SELECTOR); vmcs12->guest_ldtr_selector = vmcs_read16(GUEST_LDTR_SELECTOR); vmcs12->guest_tr_selector = vmcs_read16(GUEST_TR_SELECTOR); vmcs12->guest_es_limit = vmcs_read32(GUEST_ES_LIMIT); vmcs12->guest_cs_limit = vmcs_read32(GUEST_CS_LIMIT); vmcs12->guest_ss_limit = vmcs_read32(GUEST_SS_LIMIT); vmcs12->guest_ds_limit = vmcs_read32(GUEST_DS_LIMIT); vmcs12->guest_fs_limit = vmcs_read32(GUEST_FS_LIMIT); vmcs12->guest_gs_limit = vmcs_read32(GUEST_GS_LIMIT); vmcs12->guest_ldtr_limit = vmcs_read32(GUEST_LDTR_LIMIT); vmcs12->guest_tr_limit = vmcs_read32(GUEST_TR_LIMIT); vmcs12->guest_gdtr_limit = vmcs_read32(GUEST_GDTR_LIMIT); vmcs12->guest_idtr_limit = vmcs_read32(GUEST_IDTR_LIMIT); vmcs12->guest_es_ar_bytes = vmcs_read32(GUEST_ES_AR_BYTES); vmcs12->guest_cs_ar_bytes = vmcs_read32(GUEST_CS_AR_BYTES); vmcs12->guest_ss_ar_bytes = vmcs_read32(GUEST_SS_AR_BYTES); vmcs12->guest_ds_ar_bytes = vmcs_read32(GUEST_DS_AR_BYTES); vmcs12->guest_fs_ar_bytes = vmcs_read32(GUEST_FS_AR_BYTES); vmcs12->guest_gs_ar_bytes = vmcs_read32(GUEST_GS_AR_BYTES); vmcs12->guest_ldtr_ar_bytes = vmcs_read32(GUEST_LDTR_AR_BYTES); vmcs12->guest_tr_ar_bytes = vmcs_read32(GUEST_TR_AR_BYTES); vmcs12->guest_es_base = vmcs_readl(GUEST_ES_BASE); vmcs12->guest_cs_base = vmcs_readl(GUEST_CS_BASE); vmcs12->guest_ss_base = vmcs_readl(GUEST_SS_BASE); vmcs12->guest_ds_base = vmcs_readl(GUEST_DS_BASE); vmcs12->guest_fs_base = vmcs_readl(GUEST_FS_BASE); vmcs12->guest_gs_base = vmcs_readl(GUEST_GS_BASE); vmcs12->guest_ldtr_base = vmcs_readl(GUEST_LDTR_BASE); vmcs12->guest_tr_base = vmcs_readl(GUEST_TR_BASE); vmcs12->guest_gdtr_base = vmcs_readl(GUEST_GDTR_BASE); vmcs12->guest_idtr_base = vmcs_readl(GUEST_IDTR_BASE); vmcs12->guest_interruptibility_info = vmcs_read32(GUEST_INTERRUPTIBILITY_INFO); vmcs12->guest_pending_dbg_exceptions = vmcs_readl(GUEST_PENDING_DBG_EXCEPTIONS); if (vcpu->arch.mp_state == KVM_MP_STATE_HALTED) vmcs12->guest_activity_state = GUEST_ACTIVITY_HLT; else vmcs12->guest_activity_state = GUEST_ACTIVITY_ACTIVE; if (nested_cpu_has_preemption_timer(vmcs12)) { if (vmcs12->vm_exit_controls & VM_EXIT_SAVE_VMX_PREEMPTION_TIMER) vmcs12->vmx_preemption_timer_value = vmx_get_preemption_timer_value(vcpu); hrtimer_cancel(&to_vmx(vcpu)->nested.preemption_timer); } / * In some cases (usually, nested EPT), L2 is allowed to change its * own CR3 without exiting. If it has changed it, we must keep it. * Of course, if L0 is using shadow page tables, GUEST_CR3 was defined * by L0, not L1 or L2, so we mustn't unconditionally copy it to vmcs12. * * Additionally, restore L2's PDPTR to vmcs12. / if (enable_ept) { vmcs12->guest_cr3 = vmcs_readl(GUEST_CR3); vmcs12->guest_pdptr0 = vmcs_read64(GUEST_PDPTR0); vmcs12->guest_pdptr1 = vmcs_read64(GUEST_PDPTR1); vmcs12->guest_pdptr2 = vmcs_read64(GUEST_PDPTR2); vmcs12->guest_pdptr3 = vmcs_read64(GUEST_PDPTR3); } if (nested_cpu_has_vid(vmcs12)) vmcs12->guest_intr_status = vmcs_read16(GUEST_INTR_STATUS); vmcs12->vm_entry_controls = (vmcs12->vm_entry_controls & ~VM_ENTRY_IA32E_MODE) \| (vm_entry_controls_get(to_vmx(vcpu)) & VM_ENTRY_IA32E_MODE); if (vmcs12->vm_exit_controls & VM_EXIT_SAVE_DEBUG_CONTROLS) { kvm_get_dr(vcpu, 7, (unsigned long )&vmcs12->guest_dr7); vmcs12->guest_ia32_debugctl = vmcs_read64(GUEST_IA32_DEBUGCTL); } /* TODO: These cannot have changed unless we have MSR bitmaps and * the relevant bit asks not to trap the change / if (vmcs12->vm_exit_controls & VM_EXIT_SAVE_IA32_PAT) vmcs12->guest_ia32_pat = vmcs_read64(GUEST_IA32_PAT); if (vmcs12->vm_exit_controls & VM_EXIT_SAVE_IA32_EFER) vmcs12->guest_ia32_efer = vcpu->arch.efer; vmcs12->guest_sysenter_cs = vmcs_read32(GUEST_SYSENTER_CS); vmcs12->guest_sysenter_esp = vmcs_readl(GUEST_SYSENTER_ESP); vmcs12->guest_sysenter_eip = vmcs_readl(GUEST_SYSENTER_EIP); if (kvm_mpx_supported()) vmcs12->guest_bndcfgs = vmcs_read64(GUEST_BNDCFGS); if (nested_cpu_has_xsaves(vmcs12)) vmcs12->xss_exit_bitmap = vmcs_read64(XSS_EXIT_BITMAP); / update exit information fields: / vmcs12->vm_exit_reason = exit_reason; vmcs12->exit_qualification = exit_qualification; vmcs12->vm_exit_intr_info = exit_intr_info; if ((vmcs12->vm_exit_intr_info & (INTR_INFO_VALID_MASK \| INTR_INFO_DELIVER_CODE_MASK)) == (INTR_INFO_VALID_MASK \| INTR_INFO_DELIVER_CODE_MASK)) vmcs12->vm_exit_intr_error_code = vmcs_read32(VM_EXIT_INTR_ERROR_CODE); vmcs12->idt_vectoring_info_field = 0; vmcs12->vm_exit_instruction_len = vmcs_read32(VM_EXIT_INSTRUCTION_LEN); vmcs12->vmx_instruction_info = vmcs_read32(VMX_INSTRUCTION_INFO); if (!(vmcs12->vm_exit_reason & VMX_EXIT_REASONS_FAILED_VMENTRY)) { / vm_entry_intr_info_field is cleared on exit. Emulate this * instead of reading the real value. / vmcs12->vm_entry_intr_info_field &= ~INTR_INFO_VALID_MASK; / * Transfer the event that L0 or L1 may wanted to inject into * L2 to IDT_VECTORING_INFO_FIELD. / vmcs12_save_pending_event(vcpu, vmcs12); } / * Drop what we picked up for L2 via vmx_complete_interrupts. It is * preserved above and would only end up incorrectly in L1. / vcpu->arch.nmi_injected = false; kvm_clear_exception_queue(vcpu); kvm_clear_interrupt_queue(vcpu); } / * A part of what we need to when the nested L2 guest exits and we want to * run its L1 parent, is to reset L1's guest state to the host state specified * in vmcs12. * This function is to be called not only on normal nested exit, but also on * a nested entry failure, as explained in Intel's spec, 3B.23.7 ("VM-Entry * Failures During or After Loading Guest State"). * This function should be called when the active VMCS is L1's (vmcs01). / static void load_vmcs12_host_state(struct kvm_vcpu vcpu, struct vmcs12 vmcs12) { struct kvm_segment seg; if (vmcs12->vm_exit_controls & VM_EXIT_LOAD_IA32_EFER) vcpu->arch.efer = vmcs12->host_ia32_efer; else if (vmcs12->vm_exit_controls & VM_EXIT_HOST_ADDR_SPACE_SIZE) vcpu->arch.efer \|= (EFER_LMA \| EFER_LME); else vcpu->arch.efer &= ~(EFER_LMA \| EFER_LME); vmx_set_efer(vcpu, vcpu->arch.efer); kvm_register_write(vcpu, VCPU_REGS_RSP, vmcs12->host_rsp); kvm_register_write(vcpu, VCPU_REGS_RIP, vmcs12->host_rip); vmx_set_rflags(vcpu, X86_EFLAGS_FIXED); / * Note that calling vmx_set_cr0 is important, even if cr0 hasn't * actually changed, because it depends on the current state of * fpu_active (which may have changed). * Note that vmx_set_cr0 refers to efer set above. / vmx_set_cr0(vcpu, vmcs12->host_cr0); / * If we did fpu_activate()/fpu_deactivate() during L2's run, we need * to apply the same changes to L1's vmcs. We just set cr0 correctly, * but we also need to update cr0_guest_host_mask and exception_bitmap. / update_exception_bitmap(vcpu); vcpu->arch.cr0_guest_owned_bits = (vcpu->fpu_active ? X86_CR0_TS : 0); vmcs_writel(CR0_GUEST_HOST_MASK, ~vcpu->arch.cr0_guest_owned_bits); / * Note that CR4_GUEST_HOST_MASK is already set in the original vmcs01 * (KVM doesn't change it)- no reason to call set_cr4_guest_host_mask(); / vcpu->arch.cr4_guest_owned_bits = ~vmcs_readl(CR4_GUEST_HOST_MASK); kvm_set_cr4(vcpu, vmcs12->host_cr4); nested_ept_uninit_mmu_context(vcpu); kvm_set_cr3(vcpu, vmcs12->host_cr3); kvm_mmu_reset_context(vcpu); if (!enable_ept) vcpu->arch.walk_mmu->inject_page_fault = kvm_inject_page_fault; if (enable_vpid) { / * Trivially support vpid by letting L2s share their parent * L1's vpid. TODO: move to a more elaborate solution, giving * each L2 its own vpid and exposing the vpid feature to L1. / vmx_flush_tlb(vcpu); } vmcs_write32(GUEST_SYSENTER_CS, vmcs12->host_ia32_sysenter_cs); vmcs_writel(GUEST_SYSENTER_ESP, vmcs12->host_ia32_sysenter_esp); vmcs_writel(GUEST_SYSENTER_EIP, vmcs12->host_ia32_sysenter_eip); vmcs_writel(GUEST_IDTR_BASE, vmcs12->host_idtr_base); vmcs_writel(GUEST_GDTR_BASE, vmcs12->host_gdtr_base); / If not VM_EXIT_CLEAR_BNDCFGS, the L2 value propagates to L1. / if (vmcs12->vm_exit_controls & VM_EXIT_CLEAR_BNDCFGS) vmcs_write64(GUEST_BNDCFGS, 0); if (vmcs12->vm_exit_controls & VM_EXIT_LOAD_IA32_PAT) { vmcs_write64(GUEST_IA32_PAT, vmcs12->host_ia32_pat); vcpu->arch.pat = vmcs12->host_ia32_pat; } if (vmcs12->vm_exit_controls & VM_EXIT_LOAD_IA32_PERF_GLOBAL_CTRL) vmcs_write64(GUEST_IA32_PERF_GLOBAL_CTRL, vmcs12->host_ia32_perf_global_ctrl); / Set L1 segment info according to Intel SDM 27.5.2 Loading Host Segment and Descriptor-Table Registers / seg = (struct kvm_segment) { .base = 0, .limit = 0xFFFFFFFF, .selector = vmcs12->host_cs_selector, .type = 11, .present = 1, .s = 1, .g = 1 }; if (vmcs12->vm_exit_controls & VM_EXIT_HOST_ADDR_SPACE_SIZE) seg.l = 1; else seg.db = 1; vmx_set_segment(vcpu, &seg, VCPU_SREG_CS); seg = (struct kvm_segment) { .base = 0, .limit = 0xFFFFFFFF, .type = 3, .present = 1, .s = 1, .db = 1, .g = 1 }; seg.selector = vmcs12->host_ds_selector; vmx_set_segment(vcpu, &seg, VCPU_SREG_DS); seg.selector = vmcs12->host_es_selector; vmx_set_segment(vcpu, &seg, VCPU_SREG_ES); seg.selector = vmcs12->host_ss_selector; vmx_set_segment(vcpu, &seg, VCPU_SREG_SS); seg.selector = vmcs12->host_fs_selector; seg.base = vmcs12->host_fs_base; vmx_set_segment(vcpu, &seg, VCPU_SREG_FS); seg.selector = vmcs12->host_gs_selector; seg.base = vmcs12->host_gs_base; vmx_set_segment(vcpu, &seg, VCPU_SREG_GS); seg = (struct kvm_segment) { .base = vmcs12->host_tr_base, .limit = 0x67, .selector = vmcs12->host_tr_selector, .type = 11, .present = 1 }; vmx_set_segment(vcpu, &seg, VCPU_SREG_TR); kvm_set_dr(vcpu, 7, 0x400); vmcs_write64(GUEST_IA32_DEBUGCTL, 0); if (cpu_has_vmx_msr_bitmap()) vmx_set_msr_bitmap(vcpu); if (nested_vmx_load_msr(vcpu, vmcs12->vm_exit_msr_load_addr, vmcs12->vm_exit_msr_load_count)) nested_vmx_abort(vcpu, VMX_ABORT_LOAD_HOST_MSR_FAIL); } / * Emulate an exit from nested guest (L2) to L1, i.e., prepare to run L1 * and modify vmcs12 to make it see what it would expect to see there if * L2 was its real guest. Must only be called when in L2 (is_guest_mode()) / static void nested_vmx_vmexit(struct kvm_vcpu vcpu, u32 exit_reason, u32 exit_intr_info, unsigned long exit_qualification) { struct vcpu_vmx vmx = to_vmx(vcpu); struct vmcs12 vmcs12 = get_vmcs12(vcpu); /* trying to cancel vmlaunch/vmresume is a bug / WARN_ON_ONCE(vmx->nested.nested_run_pending); leave_guest_mode(vcpu); prepare_vmcs12(vcpu, vmcs12, exit_reason, exit_intr_info, exit_qualification); if (nested_vmx_store_msr(vcpu, vmcs12->vm_exit_msr_store_addr, vmcs12->vm_exit_msr_store_count)) nested_vmx_abort(vcpu, VMX_ABORT_SAVE_GUEST_MSR_FAIL); vmx_load_vmcs01(vcpu); if ((exit_reason == EXIT_REASON_EXTERNAL_INTERRUPT) && nested_exit_intr_ack_set(vcpu)) { int irq = kvm_cpu_get_interrupt(vcpu); WARN_ON(irq < 0); vmcs12->vm_exit_intr_info = irq \| INTR_INFO_VALID_MASK \| INTR_TYPE_EXT_INTR; } trace_kvm_nested_vmexit_inject(vmcs12->vm_exit_reason, vmcs12->exit_qualification, vmcs12->idt_vectoring_info_field, vmcs12->vm_exit_intr_info, vmcs12->vm_exit_intr_error_code, KVM_ISA_VMX); vm_entry_controls_init(vmx, vmcs_read32(VM_ENTRY_CONTROLS)); vm_exit_controls_init(vmx, vmcs_read32(VM_EXIT_CONTROLS)); vmx_segment_cache_clear(vmx); / if no vmcs02 cache requested, remove the one we used / if (VMCS02_POOL_SIZE == 0) nested_free_vmcs02(vmx, vmx->nested.current_vmptr); load_vmcs12_host_state(vcpu, vmcs12); / Update TSC_OFFSET if TSC was changed while L2 ran / vmcs_write64(TSC_OFFSET, vmx->nested.vmcs01_tsc_offset); / This is needed for same reason as it was needed in prepare_vmcs02 / vmx->host_rsp = 0; / Unpin physical memory we referred to in vmcs02 / if (vmx->nested.apic_access_page) { nested_release_page(vmx->nested.apic_access_page); vmx->nested.apic_access_page = NULL; } if (vmx->nested.virtual_apic_page) { nested_release_page(vmx->nested.virtual_apic_page); vmx->nested.virtual_apic_page = NULL; } if (vmx->nested.pi_desc_page) { kunmap(vmx->nested.pi_desc_page); nested_release_page(vmx->nested.pi_desc_page); vmx->nested.pi_desc_page = NULL; vmx->nested.pi_desc = NULL; } / * We are now running in L2, mmu_notifier will force to reload the * page's hpa for L2 vmcs. Need to reload it for L1 before entering L1. / kvm_vcpu_reload_apic_access_page(vcpu); / * Exiting from L2 to L1, we're now back to L1 which thinks it just * finished a VMLAUNCH or VMRESUME instruction, so we need to set the * success or failure flag accordingly. / if (unlikely(vmx->fail)) { vmx->fail = 0; nested_vmx_failValid(vcpu, vmcs_read32(VM_INSTRUCTION_ERROR)); } else nested_vmx_succeed(vcpu); if (enable_shadow_vmcs) vmx->nested.sync_shadow_vmcs = true; / in case we halted in L2 / vcpu->arch.mp_state = KVM_MP_STATE_RUNNABLE; } / * Forcibly leave nested mode in order to be able to reset the VCPU later on. / static void vmx_leave_nested(struct kvm_vcpu vcpu) { if (is_guest_mode(vcpu)) nested_vmx_vmexit(vcpu, -1, 0, 0); free_nested(to_vmx(vcpu)); } /* * L1's failure to enter L2 is a subset of a normal exit, as explained in * 23.7 "VM-entry failures during or after loading guest state" (this also * lists the acceptable exit-reason and exit-qualification parameters). * It should only be called before L2 actually succeeded to run, and when * vmcs01 is current (it doesn't leave_guest_mode() or switch vmcss). / static void nested_vmx_entry_failure(struct kvm_vcpu vcpu, struct vmcs12 vmcs12, u32 reason, unsigned long qualification) { load_vmcs12_host_state(vcpu, vmcs12); vmcs12->vm_exit_reason = reason \| VMX_EXIT_REASONS_FAILED_VMENTRY; vmcs12->exit_qualification = qualification; nested_vmx_succeed(vcpu); if (enable_shadow_vmcs) to_vmx(vcpu)->nested.sync_shadow_vmcs = true; } static int vmx_check_intercept(struct kvm_vcpu vcpu, struct x86_instruction_info info, enum x86_intercept_stage stage) { return X86EMUL_CONTINUE; } static void vmx_sched_in(struct kvm_vcpu vcpu, int cpu) { if (ple_gap) shrink_ple_window(vcpu); } static void vmx_slot_enable_log_dirty(struct kvm kvm, struct kvm_memory_slot slot) { kvm_mmu_slot_leaf_clear_dirty(kvm, slot); kvm_mmu_slot_largepage_remove_write_access(kvm, slot); } static void vmx_slot_disable_log_dirty(struct kvm kvm, struct kvm_memory_slot slot) { kvm_mmu_slot_set_dirty(kvm, slot); } static void vmx_flush_log_dirty(struct kvm kvm) { kvm_flush_pml_buffers(kvm); } static void vmx_enable_log_dirty_pt_masked(struct kvm kvm, struct kvm_memory_slot memslot, gfn_t offset, unsigned long mask) { kvm_mmu_clear_dirty_pt_masked(kvm, memslot, offset, mask); } / * This routine does the following things for vCPU which is going * to be blocked if VT-d PI is enabled. * - Store the vCPU to the wakeup list, so when interrupts happen * we can find the right vCPU to wake up. * - Change the Posted-interrupt descriptor as below: * 'NDST' <-- vcpu->pre_pcpu * 'NV' <-- POSTED_INTR_WAKEUP_VECTOR * - If 'ON' is set during this process, which means at least one * interrupt is posted for this vCPU, we cannot block it, in * this case, return 1, otherwise, return 0. * / static int vmx_pre_block(struct kvm_vcpu vcpu) { unsigned long flags; unsigned int dest; struct pi_desc old, new; struct pi_desc pi_desc = vcpu_to_pi_desc(vcpu); if (!kvm_arch_has_assigned_device(vcpu->kvm) \|\| !irq_remapping_cap(IRQ_POSTING_CAP)) return 0; vcpu->pre_pcpu = vcpu->cpu; spin_lock_irqsave(&per_cpu(blocked_vcpu_on_cpu_lock, vcpu->pre_pcpu), flags); list_add_tail(&vcpu->blocked_vcpu_list, &per_cpu(blocked_vcpu_on_cpu, vcpu->pre_pcpu)); spin_unlock_irqrestore(&per_cpu(blocked_vcpu_on_cpu_lock, vcpu->pre_pcpu), flags); do { old.control = new.control = pi_desc->control; / * We should not block the vCPU if * an interrupt is posted for it. / if (pi_test_on(pi_desc) == 1) { spin_lock_irqsave(&per_cpu(blocked_vcpu_on_cpu_lock, vcpu->pre_pcpu), flags); list_del(&vcpu->blocked_vcpu_list); spin_unlock_irqrestore( &per_cpu(blocked_vcpu_on_cpu_lock, vcpu->pre_pcpu), flags); vcpu->pre_pcpu = -1; return 1; } WARN((pi_desc->sn == 1), "Warning: SN field of posted-interrupts " "is set before blocking\n"); / * Since vCPU can be preempted during this process, * vcpu->cpu could be different with pre_pcpu, we * need to set pre_pcpu as the destination of wakeup * notification event, then we can find the right vCPU * to wakeup in wakeup handler if interrupts happen * when the vCPU is in blocked state. / dest = cpu_physical_id(vcpu->pre_pcpu); if (x2apic_enabled()) new.ndst = dest; else new.ndst = (dest << 8) & 0xFF00; / set 'NV' to 'wakeup vector' / new.nv = POSTED_INTR_WAKEUP_VECTOR; } while (cmpxchg(&pi_desc->control, old.control, new.control) != old.control); return 0; } static void vmx_post_block(struct kvm_vcpu vcpu) { struct pi_desc pi_desc = vcpu_to_pi_desc(vcpu); struct pi_desc old, new; unsigned int dest; unsigned long flags; if (!kvm_arch_has_assigned_device(vcpu->kvm) \|\| !irq_remapping_cap(IRQ_POSTING_CAP)) return; do { old.control = new.control = pi_desc->control; dest = cpu_physical_id(vcpu->cpu); if (x2apic_enabled()) new.ndst = dest; else new.ndst = (dest << 8) & 0xFF00; / Allow posting non-urgent interrupts / new.sn = 0; / set 'NV' to 'notification vector' / new.nv = POSTED_INTR_VECTOR; } while (cmpxchg(&pi_desc->control, old.control, new.control) != old.control); if(vcpu->pre_pcpu != -1) { spin_lock_irqsave( &per_cpu(blocked_vcpu_on_cpu_lock, vcpu->pre_pcpu), flags); list_del(&vcpu->blocked_vcpu_list); spin_unlock_irqrestore( &per_cpu(blocked_vcpu_on_cpu_lock, vcpu->pre_pcpu), flags); vcpu->pre_pcpu = -1; } } / * vmx_update_pi_irte - set IRTE for Posted-Interrupts * * @kvm: kvm * @host_irq: host irq of the interrupt * @guest_irq: gsi of the interrupt * @set: set or unset PI * returns 0 on success, < 0 on failure / static int vmx_update_pi_irte(struct kvm kvm, unsigned int host_irq, uint32_t guest_irq, bool set) { struct kvm_kernel_irq_routing_entry e; struct kvm_irq_routing_table irq_rt; struct kvm_lapic_irq irq; struct kvm_vcpu vcpu; struct vcpu_data vcpu_info; int idx, ret = -EINVAL; if (!kvm_arch_has_assigned_device(kvm) \|\| !irq_remapping_cap(IRQ_POSTING_CAP)) return 0; idx = srcu_read_lock(&kvm->irq_srcu); irq_rt = srcu_dereference(kvm->irq_routing, &kvm->irq_srcu); BUG_ON(guest_irq >= irq_rt->nr_rt_entries); hlist_for_each_entry(e, &irq_rt->map[guest_irq], link) { if (e->type != KVM_IRQ_ROUTING_MSI) continue; / * VT-d PI cannot support posting multicast/broadcast * interrupts to a vCPU, we still use interrupt remapping * for these kind of interrupts. * * For lowest-priority interrupts, we only support * those with single CPU as the destination, e.g. user * configures the interrupts via /proc/irq or uses * irqbalance to make the interrupts single-CPU. * * We will support full lowest-priority interrupt later. / kvm_set_msi_irq(e, &irq); if (!kvm_intr_is_single_vcpu(kvm, &irq, &vcpu)) { / * Make sure the IRTE is in remapped mode if * we don't handle it in posted mode. / ret = irq_set_vcpu_affinity(host_irq, NULL); if (ret < 0) { printk(KERN_INFO "failed to back to remapped mode, irq: %u\n", host_irq); goto out; } continue; } vcpu_info.pi_desc_addr = __pa(vcpu_to_pi_desc(vcpu)); vcpu_info.vector = irq.vector; trace_kvm_pi_irte_update(vcpu->vcpu_id, host_irq, e->gsi, vcpu_info.vector, vcpu_info.pi_desc_addr, set); if (set) ret = irq_set_vcpu_affinity(host_irq, &vcpu_info); else { / suppress notification event before unposting */ pi_set_sn(vcpu_to_pi_desc(vcpu)); ret = irq_set_vcpu_affinity(host_irq, NULL); pi_clear_sn(vcpu_to_pi_desc(vcpu)); } if (ret < 0) { printk(KERN_INFO "%s: failed to update PI IRTE\n", __func__); goto out; } } ret = 0; out: srcu_read_unlock(&kvm->irq_srcu, idx); return ret; } static struct kvm_x86_ops vmx_x86_ops = { .cpu_has_kvm_support = cpu_has_kvm_support, .disabled_by_bios = vmx_disabled_by_bios, .hardware_setup = hardware_setup, .hardware_unsetup = hardware_unsetup, .check_processor_compatibility = vmx_check_processor_compat, .hardware_enable = hardware_enable, .hardware_disable = hardware_disable, .cpu_has_accelerated_tpr = report_flexpriority, .cpu_has_high_real_mode_segbase = vmx_has_high_real_mode_segbase, .vcpu_create = vmx_create_vcpu, .vcpu_free = vmx_free_vcpu, .vcpu_reset = vmx_vcpu_reset, .prepare_guest_switch = vmx_save_host_state, .vcpu_load = vmx_vcpu_load, .vcpu_put = vmx_vcpu_put, .update_bp_intercept = update_exception_bitmap, .get_msr = vmx_get_msr, .set_msr = vmx_set_msr, .get_segment_base = vmx_get_segment_base, .get_segment = vmx_get_segment, .set_segment = vmx_set_segment, .get_cpl = vmx_get_cpl, .get_cs_db_l_bits = vmx_get_cs_db_l_bits, .decache_cr0_guest_bits = vmx_decache_cr0_guest_bits, .decache_cr3 = vmx_decache_cr3, .decache_cr4_guest_bits = vmx_decache_cr4_guest_bits, .set_cr0 = vmx_set_cr0, .set_cr3 = vmx_set_cr3, .set_cr4 = vmx_set_cr4, .set_efer = vmx_set_efer, .get_idt = vmx_get_idt, .set_idt = vmx_set_idt, .get_gdt = vmx_get_gdt, .set_gdt = vmx_set_gdt, .get_dr6 = vmx_get_dr6, .set_dr6 = vmx_set_dr6, .set_dr7 = vmx_set_dr7, .sync_dirty_debug_regs = vmx_sync_dirty_debug_regs, .cache_reg = vmx_cache_reg, .get_rflags = vmx_get_rflags, .set_rflags = vmx_set_rflags, .get_pkru = vmx_get_pkru, .fpu_activate = vmx_fpu_activate, .fpu_deactivate = vmx_fpu_deactivate, .tlb_flush = vmx_flush_tlb, .run = vmx_vcpu_run, .handle_exit = vmx_handle_exit, .skip_emulated_instruction = skip_emulated_instruction, .set_interrupt_shadow = vmx_set_interrupt_shadow, .get_interrupt_shadow = vmx_get_interrupt_shadow, .patch_hypercall = vmx_patch_hypercall, .set_irq = vmx_inject_irq, .set_nmi = vmx_inject_nmi, .queue_exception = vmx_queue_exception, .cancel_injection = vmx_cancel_injection, .interrupt_allowed = vmx_interrupt_allowed, .nmi_allowed = vmx_nmi_allowed, .get_nmi_mask = vmx_get_nmi_mask, .set_nmi_mask = vmx_set_nmi_mask, .enable_nmi_window = enable_nmi_window, .enable_irq_window = enable_irq_window, .update_cr8_intercept = update_cr8_intercept, .set_virtual_x2apic_mode = vmx_set_virtual_x2apic_mode, .set_apic_access_page_addr = vmx_set_apic_access_page_addr, .get_enable_apicv = vmx_get_enable_apicv, .refresh_apicv_exec_ctrl = vmx_refresh_apicv_exec_ctrl, .load_eoi_exitmap = vmx_load_eoi_exitmap, .hwapic_irr_update = vmx_hwapic_irr_update, .hwapic_isr_update = vmx_hwapic_isr_update, .sync_pir_to_irr = vmx_sync_pir_to_irr, .deliver_posted_interrupt = vmx_deliver_posted_interrupt, .set_tss_addr = vmx_set_tss_addr, .get_tdp_level = get_ept_level, .get_mt_mask = vmx_get_mt_mask, .get_exit_info = vmx_get_exit_info, .get_lpage_level = vmx_get_lpage_level, .cpuid_update = vmx_cpuid_update, .rdtscp_supported = vmx_rdtscp_supported, .invpcid_supported = vmx_invpcid_supported, .set_supported_cpuid = vmx_set_supported_cpuid, .has_wbinvd_exit = cpu_has_vmx_wbinvd_exit, .read_tsc_offset = vmx_read_tsc_offset, .write_tsc_offset = vmx_write_tsc_offset, .adjust_tsc_offset_guest = vmx_adjust_tsc_offset_guest, .read_l1_tsc = vmx_read_l1_tsc, .set_tdp_cr3 = vmx_set_cr3, .check_intercept = vmx_check_intercept, .handle_external_intr = vmx_handle_external_intr, .mpx_supported = vmx_mpx_supported, .xsaves_supported = vmx_xsaves_supported, .check_nested_events = vmx_check_nested_events, .sched_in = vmx_sched_in, .slot_enable_log_dirty = vmx_slot_enable_log_dirty, .slot_disable_log_dirty = vmx_slot_disable_log_dirty, .flush_log_dirty = vmx_flush_log_dirty, .enable_log_dirty_pt_masked = vmx_enable_log_dirty_pt_masked, .pre_block = vmx_pre_block, .post_block = vmx_post_block, .pmu_ops = &intel_pmu_ops, .update_pi_irte = vmx_update_pi_irte, }; static int __init vmx_init(void) { int r = kvm_init(&vmx_x86_ops, sizeof(struct vcpu_vmx), __alignof__(struct vcpu_vmx), THIS_MODULE); if (r) return r; #ifdef CONFIG_KEXEC_CORE rcu_assign_pointer(crash_vmclear_loaded_vmcss, crash_vmclear_local_loaded_vmcss); #endif return 0; } static void __exit vmx_exit(void) { #ifdef CONFIG_KEXEC_CORE RCU_INIT_POINTER(crash_vmclear_loaded_vmcss, NULL); synchronize_rcu(); #endif kvm_exit(); } module_init(vmx_init) module_exit(vmx_exit)	./CrossVul/dataset_final_sorted/CWE-264/c/good_5040_0
crossvul-cpp_data_bad_5739_0	/* scm.c - Socket level control messages processing. * * Author: Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru> * Alignment and value checking mods by Craig Metz * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version. / #include <linux/module.h> #include <linux/signal.h> #include <linux/capability.h> #include <linux/errno.h> #include <linux/sched.h> #include <linux/mm.h> #include <linux/kernel.h> #include <linux/stat.h> #include <linux/socket.h> #include <linux/file.h> #include <linux/fcntl.h> #include <linux/net.h> #include <linux/interrupt.h> #include <linux/netdevice.h> #include <linux/security.h> #include <linux/pid_namespace.h> #include <linux/pid.h> #include <linux/nsproxy.h> #include <linux/slab.h> #include <asm/uaccess.h> #include <net/protocol.h> #include <linux/skbuff.h> #include <net/sock.h> #include <net/compat.h> #include <net/scm.h> #include <net/cls_cgroup.h> / * Only allow a user to send credentials, that they could set with * setu(g)id. / static __inline__ int scm_check_creds(struct ucred creds) { const struct cred cred = current_cred(); kuid_t uid = make_kuid(cred->user_ns, creds->uid); kgid_t gid = make_kgid(cred->user_ns, creds->gid); if (!uid_valid(uid) \|\| !gid_valid(gid)) return -EINVAL; if ((creds->pid == task_tgid_vnr(current) \|\| ns_capable(current->nsproxy->pid_ns->user_ns, CAP_SYS_ADMIN)) && ((uid_eq(uid, cred->uid) \|\| uid_eq(uid, cred->euid) \|\| uid_eq(uid, cred->suid)) \|\| nsown_capable(CAP_SETUID)) && ((gid_eq(gid, cred->gid) \|\| gid_eq(gid, cred->egid) \|\| gid_eq(gid, cred->sgid)) \|\| nsown_capable(CAP_SETGID))) { return 0; } return -EPERM; } static int scm_fp_copy(struct cmsghdr cmsg, struct scm_fp_list *fplp) { int fdp = (int)CMSG_DATA(cmsg); struct scm_fp_list fpl = fplp; struct file fpp; int i, num; num = (cmsg->cmsg_len - CMSG_ALIGN(sizeof(struct cmsghdr)))/sizeof(int); if (num <= 0) return 0; if (num > SCM_MAX_FD) return -EINVAL; if (!fpl) { fpl = kmalloc(sizeof(struct scm_fp_list), GFP_KERNEL); if (!fpl) return -ENOMEM; fplp = fpl; fpl->count = 0; fpl->max = SCM_MAX_FD; } fpp = &fpl->fp[fpl->count]; if (fpl->count + num > fpl->max) return -EINVAL; /* * Verify the descriptors and increment the usage count. / for (i=0; i< num; i++) { int fd = fdp[i]; struct file file; if (fd < 0 \|\| !(file = fget_raw(fd))) return -EBADF; fpp++ = file; fpl->count++; } return num; } void __scm_destroy(struct scm_cookie scm) { struct scm_fp_list fpl = scm->fp; int i; if (fpl) { scm->fp = NULL; for (i=fpl->count-1; i>=0; i--) fput(fpl->fp[i]); kfree(fpl); } } EXPORT_SYMBOL(__scm_destroy); int __scm_send(struct socket sock, struct msghdr msg, struct scm_cookie p) { struct cmsghdr cmsg; int err; for (cmsg = CMSG_FIRSTHDR(msg); cmsg; cmsg = CMSG_NXTHDR(msg, cmsg)) { err = -EINVAL; / Verify that cmsg_len is at least sizeof(struct cmsghdr) / / The first check was omitted in <= 2.2.5. The reasoning was that parser checks cmsg_len in any case, so that additional check would be work duplication. But if cmsg_level is not SOL_SOCKET, we do not check for too short ancillary data object at all! Oops. OK, let's add it... / if (!CMSG_OK(msg, cmsg)) goto error; if (cmsg->cmsg_level != SOL_SOCKET) continue; switch (cmsg->cmsg_type) { case SCM_RIGHTS: if (!sock->ops \|\| sock->ops->family != PF_UNIX) goto error; err=scm_fp_copy(cmsg, &p->fp); if (err<0) goto error; break; case SCM_CREDENTIALS: { struct ucred creds; kuid_t uid; kgid_t gid; if (cmsg->cmsg_len != CMSG_LEN(sizeof(struct ucred))) goto error; memcpy(&creds, CMSG_DATA(cmsg), sizeof(struct ucred)); err = scm_check_creds(&creds); if (err) goto error; p->creds.pid = creds.pid; if (!p->pid \|\| pid_vnr(p->pid) != creds.pid) { struct pid pid; err = -ESRCH; pid = find_get_pid(creds.pid); if (!pid) goto error; put_pid(p->pid); p->pid = pid; } err = -EINVAL; uid = make_kuid(current_user_ns(), creds.uid); gid = make_kgid(current_user_ns(), creds.gid); if (!uid_valid(uid) \|\| !gid_valid(gid)) goto error; p->creds.uid = uid; p->creds.gid = gid; break; } default: goto error; } } if (p->fp && !p->fp->count) { kfree(p->fp); p->fp = NULL; } return 0; error: scm_destroy(p); return err; } EXPORT_SYMBOL(__scm_send); int put_cmsg(struct msghdr * msg, int level, int type, int len, void data) { struct cmsghdr __user cm = (__force struct cmsghdr __user )msg->msg_control; struct cmsghdr cmhdr; int cmlen = CMSG_LEN(len); int err; if (MSG_CMSG_COMPAT & msg->msg_flags) return put_cmsg_compat(msg, level, type, len, data); if (cm==NULL \|\| msg->msg_controllen < sizeof(cm)) { msg->msg_flags \|= MSG_CTRUNC; return 0; /* XXX: return error? check spec. / } if (msg->msg_controllen < cmlen) { msg->msg_flags \|= MSG_CTRUNC; cmlen = msg->msg_controllen; } cmhdr.cmsg_level = level; cmhdr.cmsg_type = type; cmhdr.cmsg_len = cmlen; err = -EFAULT; if (copy_to_user(cm, &cmhdr, sizeof cmhdr)) goto out; if (copy_to_user(CMSG_DATA(cm), data, cmlen - sizeof(struct cmsghdr))) goto out; cmlen = CMSG_SPACE(len); if (msg->msg_controllen < cmlen) cmlen = msg->msg_controllen; msg->msg_control += cmlen; msg->msg_controllen -= cmlen; err = 0; out: return err; } EXPORT_SYMBOL(put_cmsg); void scm_detach_fds(struct msghdr msg, struct scm_cookie scm) { struct cmsghdr __user cm = (__force struct cmsghdr __user)msg->msg_control; int fdmax = 0; int fdnum = scm->fp->count; struct file fp = scm->fp->fp; int __user cmfptr; int err = 0, i; if (MSG_CMSG_COMPAT & msg->msg_flags) { scm_detach_fds_compat(msg, scm); return; } if (msg->msg_controllen > sizeof(struct cmsghdr)) fdmax = ((msg->msg_controllen - sizeof(struct cmsghdr)) / sizeof(int)); if (fdnum < fdmax) fdmax = fdnum; for (i=0, cmfptr=(__force int __user )CMSG_DATA(cm); i<fdmax; i++, cmfptr++) { struct socket sock; int new_fd; err = security_file_receive(fp[i]); if (err) break; err = get_unused_fd_flags(MSG_CMSG_CLOEXEC & msg->msg_flags ? O_CLOEXEC : 0); if (err < 0) break; new_fd = err; err = put_user(new_fd, cmfptr); if (err) { put_unused_fd(new_fd); break; } /* Bump the usage count and install the file. / sock = sock_from_file(fp[i], &err); if (sock) { sock_update_netprioidx(sock->sk); sock_update_classid(sock->sk); } fd_install(new_fd, get_file(fp[i])); } if (i > 0) { int cmlen = CMSG_LEN(isizeof(int)); err = put_user(SOL_SOCKET, &cm->cmsg_level); if (!err) err = put_user(SCM_RIGHTS, &cm->cmsg_type); if (!err) err = put_user(cmlen, &cm->cmsg_len); if (!err) { cmlen = CMSG_SPACE(isizeof(int)); msg->msg_control += cmlen; msg->msg_controllen -= cmlen; } } if (i < fdnum \|\| (fdnum && fdmax <= 0)) msg->msg_flags \|= MSG_CTRUNC; / * All of the files that fit in the message have had their * usage counts incremented, so we just free the list. / __scm_destroy(scm); } EXPORT_SYMBOL(scm_detach_fds); struct scm_fp_list scm_fp_dup(struct scm_fp_list fpl) { struct scm_fp_list new_fpl; int i; if (!fpl) return NULL; new_fpl = kmemdup(fpl, offsetof(struct scm_fp_list, fp[fpl->count]), GFP_KERNEL); if (new_fpl) { for (i = 0; i < fpl->count; i++) get_file(fpl->fp[i]); new_fpl->max = new_fpl->count; } return new_fpl; } EXPORT_SYMBOL(scm_fp_dup);	./CrossVul/dataset_final_sorted/CWE-264/c/bad_5739_0
crossvul-cpp_data_bad_2399_10	/* * CTS: Cipher Text Stealing mode * * COPYRIGHT (c) 2008 * The Regents of the University of Michigan * ALL RIGHTS RESERVED * * Permission is granted to use, copy, create derivative works * and redistribute this software and such derivative works * for any purpose, so long as the name of The University of * Michigan is not used in any advertising or publicity * pertaining to the use of distribution of this software * without specific, written prior authorization. If the * above copyright notice or any other identification of the * University of Michigan is included in any copy of any * portion of this software, then the disclaimer below must * also be included. * * THIS SOFTWARE IS PROVIDED AS IS, WITHOUT REPRESENTATION * FROM THE UNIVERSITY OF MICHIGAN AS TO ITS FITNESS FOR ANY * PURPOSE, AND WITHOUT WARRANTY BY THE UNIVERSITY OF * MICHIGAN OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING * WITHOUT LIMITATION THE IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE * REGENTS OF THE UNIVERSITY OF MICHIGAN SHALL NOT BE LIABLE * FOR ANY DAMAGES, INCLUDING SPECIAL, INDIRECT, INCIDENTAL, OR * CONSEQUENTIAL DAMAGES, WITH RESPECT TO ANY CLAIM ARISING * OUT OF OR IN CONNECTION WITH THE USE OF THE SOFTWARE, EVEN * IF IT HAS BEEN OR IS HEREAFTER ADVISED OF THE POSSIBILITY OF * SUCH DAMAGES. / / Derived from various: * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au> / / * This is the Cipher Text Stealing mode as described by * Section 8 of rfc2040 and referenced by rfc3962. * rfc3962 includes errata information in its Appendix A. / #include <crypto/algapi.h> #include <linux/err.h> #include <linux/init.h> #include <linux/kernel.h> #include <linux/log2.h> #include <linux/module.h> #include <linux/scatterlist.h> #include <crypto/scatterwalk.h> #include <linux/slab.h> struct crypto_cts_ctx { struct crypto_blkcipher child; }; static int crypto_cts_setkey(struct crypto_tfm parent, const u8 key, unsigned int keylen) { struct crypto_cts_ctx ctx = crypto_tfm_ctx(parent); struct crypto_blkcipher child = ctx->child; int err; crypto_blkcipher_clear_flags(child, CRYPTO_TFM_REQ_MASK); crypto_blkcipher_set_flags(child, crypto_tfm_get_flags(parent) & CRYPTO_TFM_REQ_MASK); err = crypto_blkcipher_setkey(child, key, keylen); crypto_tfm_set_flags(parent, crypto_blkcipher_get_flags(child) & CRYPTO_TFM_RES_MASK); return err; } static int cts_cbc_encrypt(struct crypto_cts_ctx ctx, struct blkcipher_desc desc, struct scatterlist dst, struct scatterlist src, unsigned int offset, unsigned int nbytes) { int bsize = crypto_blkcipher_blocksize(desc->tfm); u8 tmp[bsize], tmp2[bsize]; struct blkcipher_desc lcldesc; struct scatterlist sgsrc[1], sgdst[1]; int lastn = nbytes - bsize; u8 iv[bsize]; u8 s[bsize * 2], d[bsize * 2]; int err; if (lastn < 0) return -EINVAL; sg_init_table(sgsrc, 1); sg_init_table(sgdst, 1); memset(s, 0, sizeof(s)); scatterwalk_map_and_copy(s, src, offset, nbytes, 0); memcpy(iv, desc->info, bsize); lcldesc.tfm = ctx->child; lcldesc.info = iv; lcldesc.flags = desc->flags; sg_set_buf(&sgsrc[0], s, bsize); sg_set_buf(&sgdst[0], tmp, bsize); err = crypto_blkcipher_encrypt_iv(&lcldesc, sgdst, sgsrc, bsize); memcpy(d + bsize, tmp, lastn); lcldesc.info = tmp; sg_set_buf(&sgsrc[0], s + bsize, bsize); sg_set_buf(&sgdst[0], tmp2, bsize); err = crypto_blkcipher_encrypt_iv(&lcldesc, sgdst, sgsrc, bsize); memcpy(d, tmp2, bsize); scatterwalk_map_and_copy(d, dst, offset, nbytes, 1); memcpy(desc->info, tmp2, bsize); return err; } static int crypto_cts_encrypt(struct blkcipher_desc desc, struct scatterlist dst, struct scatterlist src, unsigned int nbytes) { struct crypto_cts_ctx ctx = crypto_blkcipher_ctx(desc->tfm); int bsize = crypto_blkcipher_blocksize(desc->tfm); int tot_blocks = (nbytes + bsize - 1) / bsize; int cbc_blocks = tot_blocks > 2 ? tot_blocks - 2 : 0; struct blkcipher_desc lcldesc; int err; lcldesc.tfm = ctx->child; lcldesc.info = desc->info; lcldesc.flags = desc->flags; if (tot_blocks == 1) { err = crypto_blkcipher_encrypt_iv(&lcldesc, dst, src, bsize); } else if (nbytes <= bsize * 2) { err = cts_cbc_encrypt(ctx, desc, dst, src, 0, nbytes); } else { /* do normal function for tot_blocks - 2 / err = crypto_blkcipher_encrypt_iv(&lcldesc, dst, src, cbc_blocks bsize); if (err == 0) { /* do cts for final two blocks / err = cts_cbc_encrypt(ctx, desc, dst, src, cbc_blocks bsize, nbytes - (cbc_blocks * bsize)); } } return err; } static int cts_cbc_decrypt(struct crypto_cts_ctx ctx, struct blkcipher_desc desc, struct scatterlist dst, struct scatterlist src, unsigned int offset, unsigned int nbytes) { int bsize = crypto_blkcipher_blocksize(desc->tfm); u8 tmp[bsize]; struct blkcipher_desc lcldesc; struct scatterlist sgsrc[1], sgdst[1]; int lastn = nbytes - bsize; u8 iv[bsize]; u8 s[bsize * 2], d[bsize * 2]; int err; if (lastn < 0) return -EINVAL; sg_init_table(sgsrc, 1); sg_init_table(sgdst, 1); scatterwalk_map_and_copy(s, src, offset, nbytes, 0); lcldesc.tfm = ctx->child; lcldesc.info = iv; lcldesc.flags = desc->flags; /* 1. Decrypt Cn-1 (s) to create Dn (tmp)/ memset(iv, 0, sizeof(iv)); sg_set_buf(&sgsrc[0], s, bsize); sg_set_buf(&sgdst[0], tmp, bsize); err = crypto_blkcipher_decrypt_iv(&lcldesc, sgdst, sgsrc, bsize); if (err) return err; / 2. Pad Cn with zeros at the end to create C of length BB / memset(iv, 0, sizeof(iv)); memcpy(iv, s + bsize, lastn); / 3. Exclusive-or Dn (tmp) with C (iv) to create Xn (tmp) / crypto_xor(tmp, iv, bsize); / 4. Select the first Ln bytes of Xn (tmp) to create Pn / memcpy(d + bsize, tmp, lastn); / 5. Append the tail (BB - Ln) bytes of Xn (tmp) to Cn to create En / memcpy(s + bsize + lastn, tmp + lastn, bsize - lastn); / 6. Decrypt En to create Pn-1 / memzero_explicit(iv, sizeof(iv)); sg_set_buf(&sgsrc[0], s + bsize, bsize); sg_set_buf(&sgdst[0], d, bsize); err = crypto_blkcipher_decrypt_iv(&lcldesc, sgdst, sgsrc, bsize); / XOR with previous block / crypto_xor(d, desc->info, bsize); scatterwalk_map_and_copy(d, dst, offset, nbytes, 1); memcpy(desc->info, s, bsize); return err; } static int crypto_cts_decrypt(struct blkcipher_desc desc, struct scatterlist dst, struct scatterlist src, unsigned int nbytes) { struct crypto_cts_ctx ctx = crypto_blkcipher_ctx(desc->tfm); int bsize = crypto_blkcipher_blocksize(desc->tfm); int tot_blocks = (nbytes + bsize - 1) / bsize; int cbc_blocks = tot_blocks > 2 ? tot_blocks - 2 : 0; struct blkcipher_desc lcldesc; int err; lcldesc.tfm = ctx->child; lcldesc.info = desc->info; lcldesc.flags = desc->flags; if (tot_blocks == 1) { err = crypto_blkcipher_decrypt_iv(&lcldesc, dst, src, bsize); } else if (nbytes <= bsize 2) { err = cts_cbc_decrypt(ctx, desc, dst, src, 0, nbytes); } else { /* do normal function for tot_blocks - 2 / err = crypto_blkcipher_decrypt_iv(&lcldesc, dst, src, cbc_blocks bsize); if (err == 0) { /* do cts for final two blocks / err = cts_cbc_decrypt(ctx, desc, dst, src, cbc_blocks bsize, nbytes - (cbc_blocks * bsize)); } } return err; } static int crypto_cts_init_tfm(struct crypto_tfm tfm) { struct crypto_instance inst = (void )tfm->__crt_alg; struct crypto_spawn spawn = crypto_instance_ctx(inst); struct crypto_cts_ctx ctx = crypto_tfm_ctx(tfm); struct crypto_blkcipher cipher; cipher = crypto_spawn_blkcipher(spawn); if (IS_ERR(cipher)) return PTR_ERR(cipher); ctx->child = cipher; return 0; } static void crypto_cts_exit_tfm(struct crypto_tfm tfm) { struct crypto_cts_ctx ctx = crypto_tfm_ctx(tfm); crypto_free_blkcipher(ctx->child); } static struct crypto_instance crypto_cts_alloc(struct rtattr tb) { struct crypto_instance inst; struct crypto_alg alg; int err; err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_BLKCIPHER); if (err) return ERR_PTR(err); alg = crypto_attr_alg(tb[1], CRYPTO_ALG_TYPE_BLKCIPHER, CRYPTO_ALG_TYPE_MASK); if (IS_ERR(alg)) return ERR_CAST(alg); inst = ERR_PTR(-EINVAL); if (!is_power_of_2(alg->cra_blocksize)) goto out_put_alg; inst = crypto_alloc_instance("cts", alg); if (IS_ERR(inst)) goto out_put_alg; inst->alg.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER; inst->alg.cra_priority = alg->cra_priority; inst->alg.cra_blocksize = alg->cra_blocksize; inst->alg.cra_alignmask = alg->cra_alignmask; inst->alg.cra_type = &crypto_blkcipher_type; / We access the data as u32s when xoring. / inst->alg.cra_alignmask \|= __alignof__(u32) - 1; inst->alg.cra_blkcipher.ivsize = alg->cra_blocksize; inst->alg.cra_blkcipher.min_keysize = alg->cra_blkcipher.min_keysize; inst->alg.cra_blkcipher.max_keysize = alg->cra_blkcipher.max_keysize; inst->alg.cra_blkcipher.geniv = "seqiv"; inst->alg.cra_ctxsize = sizeof(struct crypto_cts_ctx); inst->alg.cra_init = crypto_cts_init_tfm; inst->alg.cra_exit = crypto_cts_exit_tfm; inst->alg.cra_blkcipher.setkey = crypto_cts_setkey; inst->alg.cra_blkcipher.encrypt = crypto_cts_encrypt; inst->alg.cra_blkcipher.decrypt = crypto_cts_decrypt; out_put_alg: crypto_mod_put(alg); return inst; } static void crypto_cts_free(struct crypto_instance inst) { crypto_drop_spawn(crypto_instance_ctx(inst)); kfree(inst); } static struct crypto_template crypto_cts_tmpl = { .name = "cts", .alloc = crypto_cts_alloc, .free = crypto_cts_free, .module = THIS_MODULE, }; static int __init crypto_cts_module_init(void) { return crypto_register_template(&crypto_cts_tmpl); } static void __exit crypto_cts_module_exit(void) { crypto_unregister_template(&crypto_cts_tmpl); } module_init(crypto_cts_module_init); module_exit(crypto_cts_module_exit); MODULE_LICENSE("Dual BSD/GPL"); MODULE_DESCRIPTION("CTS-CBC CipherText Stealing for CBC");	./CrossVul/dataset_final_sorted/CWE-264/c/bad_2399_10
crossvul-cpp_data_bad_5677_0	/* * trace event based perf event profiling/tracing * * Copyright (C) 2009 Red Hat Inc, Peter Zijlstra <pzijlstr@redhat.com> * Copyright (C) 2009-2010 Frederic Weisbecker <fweisbec@gmail.com> / #include <linux/module.h> #include <linux/kprobes.h> #include "trace.h" static char __percpu perf_trace_buf[PERF_NR_CONTEXTS]; /* * Force it to be aligned to unsigned long to avoid misaligned accesses * suprises / typedef typeof(unsigned long [PERF_MAX_TRACE_SIZE / sizeof(unsigned long)]) perf_trace_t; / Count the events in use (per event id, not per instance) / static int total_ref_count; static int perf_trace_event_perm(struct ftrace_event_call tp_event, struct perf_event p_event) { / The ftrace function trace is allowed only for root. / if (ftrace_event_is_function(tp_event) && perf_paranoid_kernel() && !capable(CAP_SYS_ADMIN)) return -EPERM; / No tracing, just counting, so no obvious leak / if (!(p_event->attr.sample_type & PERF_SAMPLE_RAW)) return 0; / Some events are ok to be traced by non-root users... / if (p_event->attach_state == PERF_ATTACH_TASK) { if (tp_event->flags & TRACE_EVENT_FL_CAP_ANY) return 0; } / * ...otherwise raw tracepoint data can be a severe data leak, * only allow root to have these. / if (perf_paranoid_tracepoint_raw() && !capable(CAP_SYS_ADMIN)) return -EPERM; return 0; } static int perf_trace_event_reg(struct ftrace_event_call tp_event, struct perf_event p_event) { struct hlist_head __percpu list; int ret = -ENOMEM; int cpu; p_event->tp_event = tp_event; if (tp_event->perf_refcount++ > 0) return 0; list = alloc_percpu(struct hlist_head); if (!list) goto fail; for_each_possible_cpu(cpu) INIT_HLIST_HEAD(per_cpu_ptr(list, cpu)); tp_event->perf_events = list; if (!total_ref_count) { char __percpu buf; int i; for (i = 0; i < PERF_NR_CONTEXTS; i++) { buf = (char __percpu )alloc_percpu(perf_trace_t); if (!buf) goto fail; perf_trace_buf[i] = buf; } } ret = tp_event->class->reg(tp_event, TRACE_REG_PERF_REGISTER, NULL); if (ret) goto fail; total_ref_count++; return 0; fail: if (!total_ref_count) { int i; for (i = 0; i < PERF_NR_CONTEXTS; i++) { free_percpu(perf_trace_buf[i]); perf_trace_buf[i] = NULL; } } if (!--tp_event->perf_refcount) { free_percpu(tp_event->perf_events); tp_event->perf_events = NULL; } return ret; } static void perf_trace_event_unreg(struct perf_event p_event) { struct ftrace_event_call tp_event = p_event->tp_event; int i; if (--tp_event->perf_refcount > 0) goto out; tp_event->class->reg(tp_event, TRACE_REG_PERF_UNREGISTER, NULL); /* * Ensure our callback won't be called anymore. The buffers * will be freed after that. / tracepoint_synchronize_unregister(); free_percpu(tp_event->perf_events); tp_event->perf_events = NULL; if (!--total_ref_count) { for (i = 0; i < PERF_NR_CONTEXTS; i++) { free_percpu(perf_trace_buf[i]); perf_trace_buf[i] = NULL; } } out: module_put(tp_event->mod); } static int perf_trace_event_open(struct perf_event p_event) { struct ftrace_event_call tp_event = p_event->tp_event; return tp_event->class->reg(tp_event, TRACE_REG_PERF_OPEN, p_event); } static void perf_trace_event_close(struct perf_event p_event) { struct ftrace_event_call tp_event = p_event->tp_event; tp_event->class->reg(tp_event, TRACE_REG_PERF_CLOSE, p_event); } static int perf_trace_event_init(struct ftrace_event_call tp_event, struct perf_event p_event) { int ret; ret = perf_trace_event_perm(tp_event, p_event); if (ret) return ret; ret = perf_trace_event_reg(tp_event, p_event); if (ret) return ret; ret = perf_trace_event_open(p_event); if (ret) { perf_trace_event_unreg(p_event); return ret; } return 0; } int perf_trace_init(struct perf_event p_event) { struct ftrace_event_call tp_event; int event_id = p_event->attr.config; int ret = -EINVAL; mutex_lock(&event_mutex); list_for_each_entry(tp_event, &ftrace_events, list) { if (tp_event->event.type == event_id && tp_event->class && tp_event->class->reg && try_module_get(tp_event->mod)) { ret = perf_trace_event_init(tp_event, p_event); if (ret) module_put(tp_event->mod); break; } } mutex_unlock(&event_mutex); return ret; } void perf_trace_destroy(struct perf_event p_event) { mutex_lock(&event_mutex); perf_trace_event_close(p_event); perf_trace_event_unreg(p_event); mutex_unlock(&event_mutex); } int perf_trace_add(struct perf_event p_event, int flags) { struct ftrace_event_call tp_event = p_event->tp_event; struct hlist_head __percpu pcpu_list; struct hlist_head list; pcpu_list = tp_event->perf_events; if (WARN_ON_ONCE(!pcpu_list)) return -EINVAL; if (!(flags & PERF_EF_START)) p_event->hw.state = PERF_HES_STOPPED; list = this_cpu_ptr(pcpu_list); hlist_add_head_rcu(&p_event->hlist_entry, list); return tp_event->class->reg(tp_event, TRACE_REG_PERF_ADD, p_event); } void perf_trace_del(struct perf_event p_event, int flags) { struct ftrace_event_call tp_event = p_event->tp_event; hlist_del_rcu(&p_event->hlist_entry); tp_event->class->reg(tp_event, TRACE_REG_PERF_DEL, p_event); } __kprobes void perf_trace_buf_prepare(int size, unsigned short type, struct pt_regs regs, int rctxp) { struct trace_entry entry; unsigned long flags; char raw_data; int pc; BUILD_BUG_ON(PERF_MAX_TRACE_SIZE % sizeof(unsigned long)); if (WARN_ONCE(size > PERF_MAX_TRACE_SIZE, "perf buffer not large enough")) return NULL; pc = preempt_count(); rctxp = perf_swevent_get_recursion_context(); if (rctxp < 0) return NULL; raw_data = this_cpu_ptr(perf_trace_buf[rctxp]); /* zero the dead bytes from align to not leak stack to user / memset(&raw_data[size - sizeof(u64)], 0, sizeof(u64)); entry = (struct trace_entry )raw_data; local_save_flags(flags); tracing_generic_entry_update(entry, flags, pc); entry->type = type; return raw_data; } EXPORT_SYMBOL_GPL(perf_trace_buf_prepare); #ifdef CONFIG_FUNCTION_TRACER static void perf_ftrace_function_call(unsigned long ip, unsigned long parent_ip, struct ftrace_ops ops, struct pt_regs pt_regs) { struct ftrace_entry entry; struct hlist_head head; struct pt_regs regs; int rctx; head = this_cpu_ptr(event_function.perf_events); if (hlist_empty(head)) return; #define ENTRY_SIZE (ALIGN(sizeof(struct ftrace_entry) + sizeof(u32), \ sizeof(u64)) - sizeof(u32)) BUILD_BUG_ON(ENTRY_SIZE > PERF_MAX_TRACE_SIZE); perf_fetch_caller_regs(&regs); entry = perf_trace_buf_prepare(ENTRY_SIZE, TRACE_FN, NULL, &rctx); if (!entry) return; entry->ip = ip; entry->parent_ip = parent_ip; perf_trace_buf_submit(entry, ENTRY_SIZE, rctx, 0, 1, &regs, head, NULL); #undef ENTRY_SIZE } static int perf_ftrace_function_register(struct perf_event event) { struct ftrace_ops ops = &event->ftrace_ops; ops->flags \|= FTRACE_OPS_FL_CONTROL; ops->func = perf_ftrace_function_call; return register_ftrace_function(ops); } static int perf_ftrace_function_unregister(struct perf_event event) { struct ftrace_ops ops = &event->ftrace_ops; int ret = unregister_ftrace_function(ops); ftrace_free_filter(ops); return ret; } static void perf_ftrace_function_enable(struct perf_event event) { ftrace_function_local_enable(&event->ftrace_ops); } static void perf_ftrace_function_disable(struct perf_event event) { ftrace_function_local_disable(&event->ftrace_ops); } int perf_ftrace_event_register(struct ftrace_event_call call, enum trace_reg type, void data) { switch (type) { case TRACE_REG_REGISTER: case TRACE_REG_UNREGISTER: break; case TRACE_REG_PERF_REGISTER: case TRACE_REG_PERF_UNREGISTER: return 0; case TRACE_REG_PERF_OPEN: return perf_ftrace_function_register(data); case TRACE_REG_PERF_CLOSE: return perf_ftrace_function_unregister(data); case TRACE_REG_PERF_ADD: perf_ftrace_function_enable(data); return 0; case TRACE_REG_PERF_DEL: perf_ftrace_function_disable(data); return 0; } return -EINVAL; } #endif /* CONFIG_FUNCTION_TRACER */	./CrossVul/dataset_final_sorted/CWE-264/c/bad_5677_0
crossvul-cpp_data_good_2399_11	/* * ECB: Electronic CodeBook mode * * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au> * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the Free * Software Foundation; either version 2 of the License, or (at your option) * any later version. * / #include <crypto/algapi.h> #include <linux/err.h> #include <linux/init.h> #include <linux/kernel.h> #include <linux/module.h> #include <linux/scatterlist.h> #include <linux/slab.h> struct crypto_ecb_ctx { struct crypto_cipher child; }; static int crypto_ecb_setkey(struct crypto_tfm parent, const u8 key, unsigned int keylen) { struct crypto_ecb_ctx ctx = crypto_tfm_ctx(parent); struct crypto_cipher child = ctx->child; int err; crypto_cipher_clear_flags(child, CRYPTO_TFM_REQ_MASK); crypto_cipher_set_flags(child, crypto_tfm_get_flags(parent) & CRYPTO_TFM_REQ_MASK); err = crypto_cipher_setkey(child, key, keylen); crypto_tfm_set_flags(parent, crypto_cipher_get_flags(child) & CRYPTO_TFM_RES_MASK); return err; } static int crypto_ecb_crypt(struct blkcipher_desc desc, struct blkcipher_walk walk, struct crypto_cipher tfm, void (fn)(struct crypto_tfm , u8 , const u8 )) { int bsize = crypto_cipher_blocksize(tfm); unsigned int nbytes; int err; err = blkcipher_walk_virt(desc, walk); while ((nbytes = walk->nbytes)) { u8 wsrc = walk->src.virt.addr; u8 wdst = walk->dst.virt.addr; do { fn(crypto_cipher_tfm(tfm), wdst, wsrc); wsrc += bsize; wdst += bsize; } while ((nbytes -= bsize) >= bsize); err = blkcipher_walk_done(desc, walk, nbytes); } return err; } static int crypto_ecb_encrypt(struct blkcipher_desc desc, struct scatterlist dst, struct scatterlist src, unsigned int nbytes) { struct blkcipher_walk walk; struct crypto_blkcipher tfm = desc->tfm; struct crypto_ecb_ctx ctx = crypto_blkcipher_ctx(tfm); struct crypto_cipher child = ctx->child; blkcipher_walk_init(&walk, dst, src, nbytes); return crypto_ecb_crypt(desc, &walk, child, crypto_cipher_alg(child)->cia_encrypt); } static int crypto_ecb_decrypt(struct blkcipher_desc desc, struct scatterlist dst, struct scatterlist src, unsigned int nbytes) { struct blkcipher_walk walk; struct crypto_blkcipher tfm = desc->tfm; struct crypto_ecb_ctx ctx = crypto_blkcipher_ctx(tfm); struct crypto_cipher child = ctx->child; blkcipher_walk_init(&walk, dst, src, nbytes); return crypto_ecb_crypt(desc, &walk, child, crypto_cipher_alg(child)->cia_decrypt); } static int crypto_ecb_init_tfm(struct crypto_tfm tfm) { struct crypto_instance inst = (void )tfm->__crt_alg; struct crypto_spawn spawn = crypto_instance_ctx(inst); struct crypto_ecb_ctx ctx = crypto_tfm_ctx(tfm); struct crypto_cipher cipher; cipher = crypto_spawn_cipher(spawn); if (IS_ERR(cipher)) return PTR_ERR(cipher); ctx->child = cipher; return 0; } static void crypto_ecb_exit_tfm(struct crypto_tfm tfm) { struct crypto_ecb_ctx ctx = crypto_tfm_ctx(tfm); crypto_free_cipher(ctx->child); } static struct crypto_instance crypto_ecb_alloc(struct rtattr *tb) { struct crypto_instance inst; struct crypto_alg alg; int err; err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_BLKCIPHER); if (err) return ERR_PTR(err); alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER, CRYPTO_ALG_TYPE_MASK); if (IS_ERR(alg)) return ERR_CAST(alg); inst = crypto_alloc_instance("ecb", alg); if (IS_ERR(inst)) goto out_put_alg; inst->alg.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER; inst->alg.cra_priority = alg->cra_priority; inst->alg.cra_blocksize = alg->cra_blocksize; inst->alg.cra_alignmask = alg->cra_alignmask; inst->alg.cra_type = &crypto_blkcipher_type; inst->alg.cra_blkcipher.min_keysize = alg->cra_cipher.cia_min_keysize; inst->alg.cra_blkcipher.max_keysize = alg->cra_cipher.cia_max_keysize; inst->alg.cra_ctxsize = sizeof(struct crypto_ecb_ctx); inst->alg.cra_init = crypto_ecb_init_tfm; inst->alg.cra_exit = crypto_ecb_exit_tfm; inst->alg.cra_blkcipher.setkey = crypto_ecb_setkey; inst->alg.cra_blkcipher.encrypt = crypto_ecb_encrypt; inst->alg.cra_blkcipher.decrypt = crypto_ecb_decrypt; out_put_alg: crypto_mod_put(alg); return inst; } static void crypto_ecb_free(struct crypto_instance inst) { crypto_drop_spawn(crypto_instance_ctx(inst)); kfree(inst); } static struct crypto_template crypto_ecb_tmpl = { .name = "ecb", .alloc = crypto_ecb_alloc, .free = crypto_ecb_free, .module = THIS_MODULE, }; static int __init crypto_ecb_module_init(void) { return crypto_register_template(&crypto_ecb_tmpl); } static void __exit crypto_ecb_module_exit(void) { crypto_unregister_template(&crypto_ecb_tmpl); } module_init(crypto_ecb_module_init); module_exit(crypto_ecb_module_exit); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("ECB block cipher algorithm"); MODULE_ALIAS_CRYPTO("ecb");	./CrossVul/dataset_final_sorted/CWE-264/c/good_2399_11
crossvul-cpp_data_bad_1715_0	/* Copyright (C) 2014 Daniel Dressler and contributors * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. / #include <stdio.h> #include <stdlib.h> #include <stdint.h> #include <unistd.h> #include <getopt.h> #include <pthread.h> #include "options.h" #include "logging.h" #include "http.h" #include "tcp.h" #include "usb.h" struct service_thread_param { struct tcp_conn_t tcp; struct usb_sock_t usb_sock; pthread_t thread_handle; }; static void service_connection(void arg_void) { struct service_thread_param arg = (struct service_thread_param )arg_void; // clasify priority while (!arg->tcp->is_closed) { struct usb_conn_t usb = NULL; struct http_message_t server_msg = NULL; struct http_message_t client_msg = NULL; // Client's request client_msg = http_message_new(); if (client_msg == NULL) { ERR("Failed to create client message"); break; } NOTE("M %p: Client msg starting", client_msg); while (!client_msg->is_completed) { struct http_packet_t pkt; pkt = tcp_packet_get(arg->tcp, client_msg); if (pkt == NULL) { if (arg->tcp->is_closed) { NOTE("M %p: Client closed connection\n", client_msg); goto cleanup_subconn; } ERR("M %p: Got null packet from tcp", client_msg); goto cleanup_subconn; } if (usb == NULL && arg->usb_sock != NULL) { usb = usb_conn_acquire(arg->usb_sock, 1); if (usb == NULL) { ERR("M %p: Failed to acquire usb interface", client_msg); packet_free(pkt); goto cleanup_subconn; } NOTE("M %p: Interface #%d: acquired usb conn", client_msg, usb->interface_index); } NOTE("M %p P %p: Pkt from tcp (buffer size: %d)\n===\n%.s\n===", client_msg, pkt, pkt->filled_size, (int)pkt->filled_size, pkt->buffer); // In no-printer mode we simply ignore passing the // client message on to the printer if (arg->usb_sock != NULL) { usb_conn_packet_send(usb, pkt); NOTE("M %p P %p: Interface #%d: Client pkt done", client_msg, pkt, usb->interface_index); } packet_free(pkt); } if (usb != NULL) NOTE("M %p: Interface #%d: Client msg completed\n", client_msg, usb->interface_index); else NOTE("M %p: Client msg completed\n", client_msg); message_free(client_msg); client_msg = NULL; // Server's response server_msg = http_message_new(); if (server_msg == NULL) { ERR("Failed to create server message"); goto cleanup_subconn; } if (usb != NULL) NOTE("M %p: Interface #%d: Server msg starting", server_msg, usb->interface_index); else NOTE("M %p: Server msg starting", server_msg); while (!server_msg->is_completed) { struct http_packet_t pkt; if (arg->usb_sock != NULL) { pkt = usb_conn_packet_get(usb, server_msg); if (pkt == NULL) break; } else { // In no-printer mode we "invent" the answer // of the printer, a simple HTML message as // a pseudo web interface pkt = packet_new(server_msg); snprintf((char)(pkt->buffer), pkt->buffer_capacity - 1, "HTTP/1.1 200 OK\r\nContent-Type: text/html; name=ippusbxd.html; charset=UTF-8\r\n\r\n<html><h2>ippusbxd</h2><p>Debug/development mode without connection to IPP-over-USB printer</p></html>\r\n"); pkt->filled_size = 183; // End the TCP connection, so that a // web browser does not wait for more data server_msg->is_completed = 1; arg->tcp->is_closed = 1; } NOTE("M %p P %p: Pkt from usb (buffer size: %d)\n===\n%.s\n===", server_msg, pkt, pkt->filled_size, (int)pkt->filled_size, pkt->buffer); tcp_packet_send(arg->tcp, pkt); if (usb != NULL) NOTE("M %p P %p: Interface #%d: Server pkt done", server_msg, pkt, usb->interface_index); else NOTE("M %p P %p: Server pkt done", server_msg, pkt); packet_free(pkt); } if (usb != NULL) NOTE("M %p: Interface #%d: Server msg completed\n", server_msg, usb->interface_index); else NOTE("M %p: Server msg completed\n", server_msg); cleanup_subconn: if (client_msg != NULL) message_free(client_msg); if (server_msg != NULL) message_free(server_msg); if (usb != NULL) usb_conn_release(usb); } tcp_conn_close(arg->tcp); free(arg); return NULL; } static void start_daemon() { // Capture USB device if not in no-printer mode struct usb_sock_t usb_sock; if (g_options.noprinter_mode == 0) { usb_sock = usb_open(); if (usb_sock == NULL) goto cleanup_usb; } else usb_sock = NULL; // Capture a socket uint16_t desired_port = g_options.desired_port; struct tcp_sock_t tcp_socket; while ((tcp_socket = tcp_open(desired_port)) == NULL && g_options.only_desired_port == 0) { // Search for a free port desired_port ++; // We failed with 0 as port number or we reached the max // port number if (desired_port == 1 \|\| desired_port == 0) // IANA recommendation of 49152 to 65535 for ephemeral // ports // https://en.wikipedia.org/wiki/Ephemeral_port desired_port = 49152; } if (tcp_socket == NULL) goto cleanup_tcp; uint16_t real_port = tcp_port_number_get(tcp_socket); if (desired_port != 0 && g_options.only_desired_port == 1 && desired_port != real_port) { ERR("Received port number did not match requested port number." " The requested port number may be too high."); goto cleanup_tcp; } printf("%u\|", real_port); fflush(stdout); // Lose connection to caller uint16_t pid; if (!g_options.nofork_mode && (pid = fork()) > 0) { printf("%u\|", pid); exit(0); } // Register for unplug event if (usb_can_callback(usb_sock)) usb_register_callback(usb_sock); for (;;) { struct service_thread_param args = calloc(1, sizeof(args)); if (args == NULL) { ERR("Failed to alloc space for thread args"); goto cleanup_thread; } args->usb_sock = usb_sock; args->tcp = tcp_conn_accept(tcp_socket); if (args->tcp == NULL) { ERR("Failed to open tcp connection"); goto cleanup_thread; } int status = pthread_create(&args->thread_handle, NULL, &service_connection, args); if (status) { ERR("Failed to spawn thread, error %d", status); goto cleanup_thread; } continue; cleanup_thread: if (args != NULL) { if (args->tcp != NULL) tcp_conn_close(args->tcp); free(args); } break; } cleanup_tcp: if (tcp_socket!= NULL) tcp_close(tcp_socket); cleanup_usb: if (usb_sock != NULL) usb_close(usb_sock); return; } static uint16_t strto16(const char str) { unsigned long val = strtoul(str, NULL, 16); if (val > UINT16_MAX) exit(1); return (uint16_t)val; } int main(int argc, char argv[]) { int c; g_options.log_destination = LOGGING_STDERR; g_options.only_desired_port = 1; while ((c = getopt(argc, argv, "qnhdp:P:s:lv:m:N")) != -1) { switch (c) { case '?': case 'h': g_options.help_mode = 1; break; case 'p': case 'P': { long long port = 0; // Request specific port port = atoi(optarg); if (port < 0) { ERR("Port number must be non-negative"); return 1; } if (port > UINT16_MAX) { ERR("Port number must be %u or less, " "but not negative", UINT16_MAX); return 2; } g_options.desired_port = (uint16_t)port; if (c == 'p') g_options.only_desired_port = 1; else g_options.only_desired_port = 0; break; } case 'l': g_options.log_destination = LOGGING_SYSLOG; break; case 'd': g_options.nofork_mode = 1; g_options.verbose_mode = 1; break; case 'q': g_options.verbose_mode = 1; break; case 'n': g_options.nofork_mode = 1; break; case 'v': g_options.vendor_id = strto16(optarg); break; case 'm': g_options.product_id = strto16(optarg); break; case 's': g_options.serial_num = (unsigned char )optarg; break; case 'N': g_options.noprinter_mode = 1; break; } } if (g_options.help_mode) { printf( "Usage: %s -v <vendorid> -m <productid> -p <port>\n" "Options:\n" " -h Show this help message\n" " -v <vid> Vendor ID of desired printer\n" " -m <pid> Product ID of desired printer\n" " -s <serial> Serial number of desired printer\n" " -p <portnum> Port number to bind against, error out if port already taken\n" " -P <portnum> Port number to bind against, use another port if port already\n" " taken\n" " -l Redirect logging to syslog\n" " -q Enable verbose tracing\n" " -d Debug mode for verbose output and no fork\n" " -n No-fork mode\n" " -N No-printer mode, debug/developer mode which makes ippusbxd\n" " run without IPP-over-USB printer\n" , argv[0]); return 0; } start_daemon(); return 0; }	./CrossVul/dataset_final_sorted/CWE-264/c/bad_1715_0
crossvul-cpp_data_bad_3604_7	404: Not Found	./CrossVul/dataset_final_sorted/CWE-264/c/bad_3604_7
crossvul-cpp_data_good_2287_5	/* * fs/f2fs/file.c * * Copyright (c) 2012 Samsung Electronics Co., Ltd. * http://www.samsung.com/ * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. / #include <linux/fs.h> #include <linux/f2fs_fs.h> #include <linux/stat.h> #include <linux/buffer_head.h> #include <linux/writeback.h> #include <linux/blkdev.h> #include <linux/falloc.h> #include <linux/types.h> #include <linux/compat.h> #include <linux/uaccess.h> #include <linux/mount.h> #include "f2fs.h" #include "node.h" #include "segment.h" #include "xattr.h" #include "acl.h" #include <trace/events/f2fs.h> static int f2fs_vm_page_mkwrite(struct vm_area_struct vma, struct vm_fault vmf) { struct page page = vmf->page; struct inode inode = file_inode(vma->vm_file); struct f2fs_sb_info sbi = F2FS_SB(inode->i_sb); struct dnode_of_data dn; int err; f2fs_balance_fs(sbi); sb_start_pagefault(inode->i_sb); /* block allocation / f2fs_lock_op(sbi); set_new_dnode(&dn, inode, NULL, NULL, 0); err = f2fs_reserve_block(&dn, page->index); f2fs_unlock_op(sbi); if (err) goto out; file_update_time(vma->vm_file); lock_page(page); if (unlikely(page->mapping != inode->i_mapping \|\| page_offset(page) > i_size_read(inode) \|\| !PageUptodate(page))) { unlock_page(page); err = -EFAULT; goto out; } / * check to see if the page is mapped already (no holes) / if (PageMappedToDisk(page)) goto mapped; / page is wholly or partially inside EOF / if (((page->index + 1) << PAGE_CACHE_SHIFT) > i_size_read(inode)) { unsigned offset; offset = i_size_read(inode) & ~PAGE_CACHE_MASK; zero_user_segment(page, offset, PAGE_CACHE_SIZE); } set_page_dirty(page); SetPageUptodate(page); trace_f2fs_vm_page_mkwrite(page, DATA); mapped: / fill the page / f2fs_wait_on_page_writeback(page, DATA); out: sb_end_pagefault(inode->i_sb); return block_page_mkwrite_return(err); } static const struct vm_operations_struct f2fs_file_vm_ops = { .fault = filemap_fault, .map_pages = filemap_map_pages, .page_mkwrite = f2fs_vm_page_mkwrite, .remap_pages = generic_file_remap_pages, }; static int get_parent_ino(struct inode inode, nid_t pino) { struct dentry dentry; inode = igrab(inode); dentry = d_find_any_alias(inode); iput(inode); if (!dentry) return 0; if (update_dent_inode(inode, &dentry->d_name)) { dput(dentry); return 0; } pino = parent_ino(dentry); dput(dentry); return 1; } int f2fs_sync_file(struct file file, loff_t start, loff_t end, int datasync) { struct inode inode = file->f_mapping->host; struct f2fs_inode_info fi = F2FS_I(inode); struct f2fs_sb_info sbi = F2FS_SB(inode->i_sb); int ret = 0; bool need_cp = false; struct writeback_control wbc = { .sync_mode = WB_SYNC_ALL, .nr_to_write = LONG_MAX, .for_reclaim = 0, }; if (unlikely(f2fs_readonly(inode->i_sb))) return 0; trace_f2fs_sync_file_enter(inode); ret = filemap_write_and_wait_range(inode->i_mapping, start, end); if (ret) { trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret); return ret; } / guarantee free sections for fsync / f2fs_balance_fs(sbi); down_read(&fi->i_sem); / * Both of fdatasync() and fsync() are able to be recovered from * sudden-power-off. / if (!S_ISREG(inode->i_mode) \|\| inode->i_nlink != 1) need_cp = true; else if (file_wrong_pino(inode)) need_cp = true; else if (!space_for_roll_forward(sbi)) need_cp = true; else if (!is_checkpointed_node(sbi, F2FS_I(inode)->i_pino)) need_cp = true; else if (F2FS_I(inode)->xattr_ver == cur_cp_version(F2FS_CKPT(sbi))) need_cp = true; up_read(&fi->i_sem); if (need_cp) { nid_t pino; / all the dirty node pages should be flushed for POR / ret = f2fs_sync_fs(inode->i_sb, 1); down_write(&fi->i_sem); F2FS_I(inode)->xattr_ver = 0; if (file_wrong_pino(inode) && inode->i_nlink == 1 && get_parent_ino(inode, &pino)) { F2FS_I(inode)->i_pino = pino; file_got_pino(inode); up_write(&fi->i_sem); mark_inode_dirty_sync(inode); ret = f2fs_write_inode(inode, NULL); if (ret) goto out; } else { up_write(&fi->i_sem); } } else { / if there is no written node page, write its inode page / while (!sync_node_pages(sbi, inode->i_ino, &wbc)) { if (fsync_mark_done(sbi, inode->i_ino)) goto out; mark_inode_dirty_sync(inode); ret = f2fs_write_inode(inode, NULL); if (ret) goto out; } ret = wait_on_node_pages_writeback(sbi, inode->i_ino); if (ret) goto out; ret = f2fs_issue_flush(F2FS_SB(inode->i_sb)); } out: trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret); return ret; } static int f2fs_file_mmap(struct file file, struct vm_area_struct vma) { file_accessed(file); vma->vm_ops = &f2fs_file_vm_ops; return 0; } int truncate_data_blocks_range(struct dnode_of_data dn, int count) { int nr_free = 0, ofs = dn->ofs_in_node; struct f2fs_sb_info sbi = F2FS_SB(dn->inode->i_sb); struct f2fs_node raw_node; __le32 addr; raw_node = F2FS_NODE(dn->node_page); addr = blkaddr_in_node(raw_node) + ofs; for (; count > 0; count--, addr++, dn->ofs_in_node++) { block_t blkaddr = le32_to_cpu(addr); if (blkaddr == NULL_ADDR) continue; update_extent_cache(NULL_ADDR, dn); invalidate_blocks(sbi, blkaddr); nr_free++; } if (nr_free) { dec_valid_block_count(sbi, dn->inode, nr_free); set_page_dirty(dn->node_page); sync_inode_page(dn); } dn->ofs_in_node = ofs; trace_f2fs_truncate_data_blocks_range(dn->inode, dn->nid, dn->ofs_in_node, nr_free); return nr_free; } void truncate_data_blocks(struct dnode_of_data dn) { truncate_data_blocks_range(dn, ADDRS_PER_BLOCK); } static void truncate_partial_data_page(struct inode inode, u64 from) { unsigned offset = from & (PAGE_CACHE_SIZE - 1); struct page page; if (!offset) return; page = find_data_page(inode, from >> PAGE_CACHE_SHIFT, false); if (IS_ERR(page)) return; lock_page(page); if (unlikely(page->mapping != inode->i_mapping)) { f2fs_put_page(page, 1); return; } f2fs_wait_on_page_writeback(page, DATA); zero_user(page, offset, PAGE_CACHE_SIZE - offset); set_page_dirty(page); f2fs_put_page(page, 1); } int truncate_blocks(struct inode inode, u64 from) { struct f2fs_sb_info sbi = F2FS_SB(inode->i_sb); unsigned int blocksize = inode->i_sb->s_blocksize; struct dnode_of_data dn; pgoff_t free_from; int count = 0, err = 0; trace_f2fs_truncate_blocks_enter(inode, from); if (f2fs_has_inline_data(inode)) goto done; free_from = (pgoff_t) ((from + blocksize - 1) >> (sbi->log_blocksize)); f2fs_lock_op(sbi); set_new_dnode(&dn, inode, NULL, NULL, 0); err = get_dnode_of_data(&dn, free_from, LOOKUP_NODE); if (err) { if (err == -ENOENT) goto free_next; f2fs_unlock_op(sbi); trace_f2fs_truncate_blocks_exit(inode, err); return err; } if (IS_INODE(dn.node_page)) count = ADDRS_PER_INODE(F2FS_I(inode)); else count = ADDRS_PER_BLOCK; count -= dn.ofs_in_node; f2fs_bug_on(count < 0); if (dn.ofs_in_node \|\| IS_INODE(dn.node_page)) { truncate_data_blocks_range(&dn, count); free_from += count; } f2fs_put_dnode(&dn); free_next: err = truncate_inode_blocks(inode, free_from); f2fs_unlock_op(sbi); done: / lastly zero out the first data page / truncate_partial_data_page(inode, from); trace_f2fs_truncate_blocks_exit(inode, err); return err; } void f2fs_truncate(struct inode inode) { if (!(S_ISREG(inode->i_mode) \|\| S_ISDIR(inode->i_mode) \|\| S_ISLNK(inode->i_mode))) return; trace_f2fs_truncate(inode); if (!truncate_blocks(inode, i_size_read(inode))) { inode->i_mtime = inode->i_ctime = CURRENT_TIME; mark_inode_dirty(inode); } } int f2fs_getattr(struct vfsmount mnt, struct dentry dentry, struct kstat stat) { struct inode inode = dentry->d_inode; generic_fillattr(inode, stat); stat->blocks <<= 3; return 0; } #ifdef CONFIG_F2FS_FS_POSIX_ACL static void __setattr_copy(struct inode inode, const struct iattr attr) { struct f2fs_inode_info fi = F2FS_I(inode); unsigned int ia_valid = attr->ia_valid; if (ia_valid & ATTR_UID) inode->i_uid = attr->ia_uid; if (ia_valid & ATTR_GID) inode->i_gid = attr->ia_gid; if (ia_valid & ATTR_ATIME) inode->i_atime = timespec_trunc(attr->ia_atime, inode->i_sb->s_time_gran); if (ia_valid & ATTR_MTIME) inode->i_mtime = timespec_trunc(attr->ia_mtime, inode->i_sb->s_time_gran); if (ia_valid & ATTR_CTIME) inode->i_ctime = timespec_trunc(attr->ia_ctime, inode->i_sb->s_time_gran); if (ia_valid & ATTR_MODE) { umode_t mode = attr->ia_mode; if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID)) mode &= ~S_ISGID; set_acl_inode(fi, mode); } } #else #define __setattr_copy setattr_copy #endif int f2fs_setattr(struct dentry dentry, struct iattr attr) { struct inode inode = dentry->d_inode; struct f2fs_inode_info fi = F2FS_I(inode); int err; err = inode_change_ok(inode, attr); if (err) return err; if ((attr->ia_valid & ATTR_SIZE) && attr->ia_size != i_size_read(inode)) { err = f2fs_convert_inline_data(inode, attr->ia_size); if (err) return err; truncate_setsize(inode, attr->ia_size); f2fs_truncate(inode); f2fs_balance_fs(F2FS_SB(inode->i_sb)); } __setattr_copy(inode, attr); if (attr->ia_valid & ATTR_MODE) { err = posix_acl_chmod(inode, get_inode_mode(inode)); if (err \|\| is_inode_flag_set(fi, FI_ACL_MODE)) { inode->i_mode = fi->i_acl_mode; clear_inode_flag(fi, FI_ACL_MODE); } } mark_inode_dirty(inode); return err; } const struct inode_operations f2fs_file_inode_operations = { .getattr = f2fs_getattr, .setattr = f2fs_setattr, .get_acl = f2fs_get_acl, .set_acl = f2fs_set_acl, #ifdef CONFIG_F2FS_FS_XATTR .setxattr = generic_setxattr, .getxattr = generic_getxattr, .listxattr = f2fs_listxattr, .removexattr = generic_removexattr, #endif }; static void fill_zero(struct inode inode, pgoff_t index, loff_t start, loff_t len) { struct f2fs_sb_info sbi = F2FS_SB(inode->i_sb); struct page page; if (!len) return; f2fs_balance_fs(sbi); f2fs_lock_op(sbi); page = get_new_data_page(inode, NULL, index, false); f2fs_unlock_op(sbi); if (!IS_ERR(page)) { f2fs_wait_on_page_writeback(page, DATA); zero_user(page, start, len); set_page_dirty(page); f2fs_put_page(page, 1); } } int truncate_hole(struct inode inode, pgoff_t pg_start, pgoff_t pg_end) { pgoff_t index; int err; for (index = pg_start; index < pg_end; index++) { struct dnode_of_data dn; set_new_dnode(&dn, inode, NULL, NULL, 0); err = get_dnode_of_data(&dn, index, LOOKUP_NODE); if (err) { if (err == -ENOENT) continue; return err; } if (dn.data_blkaddr != NULL_ADDR) truncate_data_blocks_range(&dn, 1); f2fs_put_dnode(&dn); } return 0; } static int punch_hole(struct inode inode, loff_t offset, loff_t len) { pgoff_t pg_start, pg_end; loff_t off_start, off_end; int ret = 0; ret = f2fs_convert_inline_data(inode, MAX_INLINE_DATA + 1); if (ret) return ret; pg_start = ((unsigned long long) offset) >> PAGE_CACHE_SHIFT; pg_end = ((unsigned long long) offset + len) >> PAGE_CACHE_SHIFT; off_start = offset & (PAGE_CACHE_SIZE - 1); off_end = (offset + len) & (PAGE_CACHE_SIZE - 1); if (pg_start == pg_end) { fill_zero(inode, pg_start, off_start, off_end - off_start); } else { if (off_start) fill_zero(inode, pg_start++, off_start, PAGE_CACHE_SIZE - off_start); if (off_end) fill_zero(inode, pg_end, 0, off_end); if (pg_start < pg_end) { struct address_space mapping = inode->i_mapping; loff_t blk_start, blk_end; struct f2fs_sb_info sbi = F2FS_SB(inode->i_sb); f2fs_balance_fs(sbi); blk_start = pg_start << PAGE_CACHE_SHIFT; blk_end = pg_end << PAGE_CACHE_SHIFT; truncate_inode_pages_range(mapping, blk_start, blk_end - 1); f2fs_lock_op(sbi); ret = truncate_hole(inode, pg_start, pg_end); f2fs_unlock_op(sbi); } } return ret; } static int expand_inode_data(struct inode inode, loff_t offset, loff_t len, int mode) { struct f2fs_sb_info sbi = F2FS_SB(inode->i_sb); pgoff_t index, pg_start, pg_end; loff_t new_size = i_size_read(inode); loff_t off_start, off_end; int ret = 0; ret = inode_newsize_ok(inode, (len + offset)); if (ret) return ret; ret = f2fs_convert_inline_data(inode, offset + len); if (ret) return ret; pg_start = ((unsigned long long) offset) >> PAGE_CACHE_SHIFT; pg_end = ((unsigned long long) offset + len) >> PAGE_CACHE_SHIFT; off_start = offset & (PAGE_CACHE_SIZE - 1); off_end = (offset + len) & (PAGE_CACHE_SIZE - 1); for (index = pg_start; index <= pg_end; index++) { struct dnode_of_data dn; f2fs_lock_op(sbi); set_new_dnode(&dn, inode, NULL, NULL, 0); ret = f2fs_reserve_block(&dn, index); f2fs_unlock_op(sbi); if (ret) break; if (pg_start == pg_end) new_size = offset + len; else if (index == pg_start && off_start) new_size = (index + 1) << PAGE_CACHE_SHIFT; else if (index == pg_end) new_size = (index << PAGE_CACHE_SHIFT) + off_end; else new_size += PAGE_CACHE_SIZE; } if (!(mode & FALLOC_FL_KEEP_SIZE) && i_size_read(inode) < new_size) { i_size_write(inode, new_size); mark_inode_dirty(inode); } return ret; } static long f2fs_fallocate(struct file file, int mode, loff_t offset, loff_t len) { struct inode inode = file_inode(file); long ret; if (mode & ~(FALLOC_FL_KEEP_SIZE \| FALLOC_FL_PUNCH_HOLE)) return -EOPNOTSUPP; mutex_lock(&inode->i_mutex); if (mode & FALLOC_FL_PUNCH_HOLE) ret = punch_hole(inode, offset, len); else ret = expand_inode_data(inode, offset, len, mode); if (!ret) { inode->i_mtime = inode->i_ctime = CURRENT_TIME; mark_inode_dirty(inode); } mutex_unlock(&inode->i_mutex); trace_f2fs_fallocate(inode, mode, offset, len, ret); return ret; } #define F2FS_REG_FLMASK (~(FS_DIRSYNC_FL \| FS_TOPDIR_FL)) #define F2FS_OTHER_FLMASK (FS_NODUMP_FL \| FS_NOATIME_FL) static inline __u32 f2fs_mask_flags(umode_t mode, __u32 flags) { if (S_ISDIR(mode)) return flags; else if (S_ISREG(mode)) return flags & F2FS_REG_FLMASK; else return flags & F2FS_OTHER_FLMASK; } long f2fs_ioctl(struct file filp, unsigned int cmd, unsigned long arg) { struct inode inode = file_inode(filp); struct f2fs_inode_info fi = F2FS_I(inode); unsigned int flags; int ret; switch (cmd) { case F2FS_IOC_GETFLAGS: flags = fi->i_flags & FS_FL_USER_VISIBLE; return put_user(flags, (int __user ) arg); case F2FS_IOC_SETFLAGS: { unsigned int oldflags; ret = mnt_want_write_file(filp); if (ret) return ret; if (!inode_owner_or_capable(inode)) { ret = -EACCES; goto out; } if (get_user(flags, (int __user ) arg)) { ret = -EFAULT; goto out; } flags = f2fs_mask_flags(inode->i_mode, flags); mutex_lock(&inode->i_mutex); oldflags = fi->i_flags; if ((flags ^ oldflags) & (FS_APPEND_FL \| FS_IMMUTABLE_FL)) { if (!capable(CAP_LINUX_IMMUTABLE)) { mutex_unlock(&inode->i_mutex); ret = -EPERM; goto out; } } flags = flags & FS_FL_USER_MODIFIABLE; flags \|= oldflags & ~FS_FL_USER_MODIFIABLE; fi->i_flags = flags; mutex_unlock(&inode->i_mutex); f2fs_set_inode_flags(inode); inode->i_ctime = CURRENT_TIME; mark_inode_dirty(inode); out: mnt_drop_write_file(filp); return ret; } default: return -ENOTTY; } } #ifdef CONFIG_COMPAT long f2fs_compat_ioctl(struct file file, unsigned int cmd, unsigned long arg) { switch (cmd) { case F2FS_IOC32_GETFLAGS: cmd = F2FS_IOC_GETFLAGS; break; case F2FS_IOC32_SETFLAGS: cmd = F2FS_IOC_SETFLAGS; break; default: return -ENOIOCTLCMD; } return f2fs_ioctl(file, cmd, (unsigned long) compat_ptr(arg)); } #endif const struct file_operations f2fs_file_operations = { .llseek = generic_file_llseek, .read = new_sync_read, .write = new_sync_write, .read_iter = generic_file_read_iter, .write_iter = generic_file_write_iter, .open = generic_file_open, .mmap = f2fs_file_mmap, .fsync = f2fs_sync_file, .fallocate = f2fs_fallocate, .unlocked_ioctl = f2fs_ioctl, #ifdef CONFIG_COMPAT .compat_ioctl = f2fs_compat_ioctl, #endif .splice_read = generic_file_splice_read, .splice_write = iter_file_splice_write, };	./CrossVul/dataset_final_sorted/CWE-264/c/good_2287_5
crossvul-cpp_data_good_1787_2	/* user_defined.c: user defined key type * * Copyright (C) 2004 Red Hat, Inc. All Rights Reserved. * Written by David Howells (dhowells@redhat.com) * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version. / #include <linux/module.h> #include <linux/init.h> #include <linux/slab.h> #include <linux/seq_file.h> #include <linux/err.h> #include <keys/user-type.h> #include <asm/uaccess.h> #include "internal.h" static int logon_vet_description(const char desc); /* * user defined keys take an arbitrary string as the description and an * arbitrary blob of data as the payload / struct key_type key_type_user = { .name = "user", .preparse = user_preparse, .free_preparse = user_free_preparse, .instantiate = generic_key_instantiate, .update = user_update, .revoke = user_revoke, .destroy = user_destroy, .describe = user_describe, .read = user_read, }; EXPORT_SYMBOL_GPL(key_type_user); / * This key type is essentially the same as key_type_user, but it does * not define a .read op. This is suitable for storing username and * password pairs in the keyring that you do not want to be readable * from userspace. / struct key_type key_type_logon = { .name = "logon", .preparse = user_preparse, .free_preparse = user_free_preparse, .instantiate = generic_key_instantiate, .update = user_update, .revoke = user_revoke, .destroy = user_destroy, .describe = user_describe, .vet_description = logon_vet_description, }; EXPORT_SYMBOL_GPL(key_type_logon); / * Preparse a user defined key payload / int user_preparse(struct key_preparsed_payload prep) { struct user_key_payload upayload; size_t datalen = prep->datalen; if (datalen <= 0 \|\| datalen > 32767 \|\| !prep->data) return -EINVAL; upayload = kmalloc(sizeof(upayload) + datalen, GFP_KERNEL); if (!upayload) return -ENOMEM; /* attach the data / prep->quotalen = datalen; prep->payload.data[0] = upayload; upayload->datalen = datalen; memcpy(upayload->data, prep->data, datalen); return 0; } EXPORT_SYMBOL_GPL(user_preparse); / * Free a preparse of a user defined key payload / void user_free_preparse(struct key_preparsed_payload prep) { kfree(prep->payload.data[0]); } EXPORT_SYMBOL_GPL(user_free_preparse); /* * update a user defined key * - the key's semaphore is write-locked / int user_update(struct key key, struct key_preparsed_payload prep) { struct user_key_payload upayload, zap; size_t datalen = prep->datalen; int ret; ret = -EINVAL; if (datalen <= 0 \|\| datalen > 32767 \|\| !prep->data) goto error; / construct a replacement payload / ret = -ENOMEM; upayload = kmalloc(sizeof(upayload) + datalen, GFP_KERNEL); if (!upayload) goto error; upayload->datalen = datalen; memcpy(upayload->data, prep->data, datalen); /* check the quota and attach the new data / zap = upayload; ret = key_payload_reserve(key, datalen); if (ret == 0) { / attach the new data, displacing the old / if (!test_bit(KEY_FLAG_NEGATIVE, &key->flags)) zap = key->payload.data[0]; else zap = NULL; rcu_assign_keypointer(key, upayload); key->expiry = 0; } if (zap) kfree_rcu(zap, rcu); error: return ret; } EXPORT_SYMBOL_GPL(user_update); / * dispose of the links from a revoked keyring * - called with the key sem write-locked / void user_revoke(struct key key) { struct user_key_payload upayload = key->payload.data[0]; / clear the quota / key_payload_reserve(key, 0); if (upayload) { rcu_assign_keypointer(key, NULL); kfree_rcu(upayload, rcu); } } EXPORT_SYMBOL(user_revoke); / * dispose of the data dangling from the corpse of a user key / void user_destroy(struct key key) { struct user_key_payload upayload = key->payload.data[0]; kfree(upayload); } EXPORT_SYMBOL_GPL(user_destroy); / * describe the user key / void user_describe(const struct key key, struct seq_file m) { seq_puts(m, key->description); if (key_is_instantiated(key)) seq_printf(m, ": %u", key->datalen); } EXPORT_SYMBOL_GPL(user_describe); / * read the key data * - the key's semaphore is read-locked / long user_read(const struct key key, char __user buffer, size_t buflen) { const struct user_key_payload upayload; long ret; upayload = user_key_payload(key); ret = upayload->datalen; /* we can return the data as is / if (buffer && buflen > 0) { if (buflen > upayload->datalen) buflen = upayload->datalen; if (copy_to_user(buffer, upayload->data, buflen) != 0) ret = -EFAULT; } return ret; } EXPORT_SYMBOL_GPL(user_read); / Vet the description for a "logon" key / static int logon_vet_description(const char desc) { char p; / require a "qualified" description string / p = strchr(desc, ':'); if (!p) return -EINVAL; / also reject description with ':' as first char */ if (p == desc) return -EINVAL; return 0; }	./CrossVul/dataset_final_sorted/CWE-264/c/good_1787_2
crossvul-cpp_data_bad_1533_0	/* -- mode: c; c-basic-offset: 4; indent-tabs-mode: nil -- / / plugins/preauth/otp/main.c - OTP kdcpreauth module definition / / * Copyright 2011 NORDUnet A/S. All rights reserved. * Copyright 2013 Red Hat, Inc. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in * the documentation and/or other materials provided with the * distribution. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. / #include "k5-int.h" #include "k5-json.h" #include <krb5/preauth_plugin.h> #include "otp_state.h" #include <errno.h> #include <ctype.h> static krb5_preauthtype otp_pa_type_list[] = { KRB5_PADATA_OTP_REQUEST, 0 }; struct request_state { krb5_kdcpreauth_verify_respond_fn respond; void arg; }; static krb5_error_code decrypt_encdata(krb5_context context, krb5_keyblock armor_key, krb5_pa_otp_req req, krb5_data out) { krb5_error_code retval; krb5_data plaintext; if (req == NULL) return EINVAL; retval = alloc_data(&plaintext, req->enc_data.ciphertext.length); if (retval) return retval; retval = krb5_c_decrypt(context, armor_key, KRB5_KEYUSAGE_PA_OTP_REQUEST, NULL, &req->enc_data, &plaintext); if (retval != 0) { com_err("otp", retval, "Unable to decrypt encData in PA-OTP-REQUEST"); free(plaintext.data); return retval; } out = plaintext; return 0; } static krb5_error_code nonce_verify(krb5_context ctx, krb5_keyblock armor_key, const krb5_data nonce) { krb5_error_code retval; krb5_timestamp ts; krb5_data er = NULL; if (armor_key == NULL \|\| nonce->data == NULL) { retval = EINVAL; goto out; } / Decode the PA-OTP-ENC-REQUEST structure. / retval = decode_krb5_pa_otp_enc_req(nonce, &er); if (retval != 0) goto out; / Make sure the nonce is exactly the same size as the one generated. / if (er->length != armor_key->length + sizeof(krb5_timestamp)) goto out; / Check to make sure the timestamp at the beginning is still valid. / ts = load_32_be(er->data); retval = krb5_check_clockskew(ctx, ts); out: krb5_free_data(ctx, er); return retval; } static krb5_error_code timestamp_verify(krb5_context ctx, const krb5_data nonce) { krb5_error_code retval = EINVAL; krb5_pa_enc_ts et = NULL; if (nonce->data == NULL) goto out; / Decode the PA-ENC-TS-ENC structure. / retval = decode_krb5_pa_enc_ts(nonce, &et); if (retval != 0) goto out; / Check the clockskew. / retval = krb5_check_clockskew(ctx, et->patimestamp); out: krb5_free_pa_enc_ts(ctx, et); return retval; } static krb5_error_code nonce_generate(krb5_context ctx, unsigned int length, krb5_data nonce_out) { krb5_data nonce; krb5_error_code retval; krb5_timestamp now; retval = krb5_timeofday(ctx, &now); if (retval != 0) return retval; retval = alloc_data(&nonce, sizeof(now) + length); if (retval != 0) return retval; retval = krb5_c_random_make_octets(ctx, &nonce); if (retval != 0) { free(nonce.data); return retval; } store_32_be(now, nonce.data); nonce_out = nonce; return 0; } static void on_response(void data, krb5_error_code retval, otp_response response) { struct request_state rs = (struct request_state )data; free(data); if (retval == 0 && response != otp_response_success) retval = KRB5_PREAUTH_FAILED; rs.respond(rs.arg, retval, NULL, NULL, NULL); } static krb5_error_code otp_init(krb5_context context, krb5_kdcpreauth_moddata moddata_out, const char realmnames) { krb5_error_code retval; otp_state state; retval = otp_state_new(context, &state); if (retval) return retval; moddata_out = (krb5_kdcpreauth_moddata)state; return 0; } static void otp_fini(krb5_context context, krb5_kdcpreauth_moddata moddata) { otp_state_free((otp_state )moddata); } static int otp_flags(krb5_context context, krb5_preauthtype pa_type) { return PA_REPLACES_KEY; } static void otp_edata(krb5_context context, krb5_kdc_req request, krb5_kdcpreauth_callbacks cb, krb5_kdcpreauth_rock rock, krb5_kdcpreauth_moddata moddata, krb5_preauthtype pa_type, krb5_kdcpreauth_edata_respond_fn respond, void arg) { krb5_otp_tokeninfo ti, tis[2] = { &ti, NULL }; krb5_keyblock armor_key = NULL; krb5_pa_otp_challenge chl; krb5_pa_data pa = NULL; krb5_error_code retval; krb5_data encoding; char config; / Determine if otp is enabled for the user. / retval = cb->get_string(context, rock, "otp", &config); if (retval == 0 && config == NULL) retval = ENOENT; if (retval != 0) goto out; cb->free_string(context, rock, config); / Get the armor key. This indicates the length of random data to use in * the nonce. / armor_key = cb->fast_armor(context, rock); if (armor_key == NULL) { retval = ENOENT; goto out; } / Build the (mostly empty) challenge. / memset(&ti, 0, sizeof(ti)); memset(&chl, 0, sizeof(chl)); chl.tokeninfo = tis; ti.format = -1; ti.length = -1; ti.iteration_count = -1; / Generate the nonce. / retval = nonce_generate(context, armor_key->length, &chl.nonce); if (retval != 0) goto out; / Build the output pa-data. / retval = encode_krb5_pa_otp_challenge(&chl, &encoding); if (retval != 0) goto out; pa = k5alloc(sizeof(krb5_pa_data), &retval); if (pa == NULL) { krb5_free_data(context, encoding); goto out; } pa->pa_type = KRB5_PADATA_OTP_CHALLENGE; pa->contents = (krb5_octet )encoding->data; pa->length = encoding->length; free(encoding); out: (respond)(arg, retval, pa); } static void otp_verify(krb5_context context, krb5_data req_pkt, krb5_kdc_req request, krb5_enc_tkt_part enc_tkt_reply, krb5_pa_data pa, krb5_kdcpreauth_callbacks cb, krb5_kdcpreauth_rock rock, krb5_kdcpreauth_moddata moddata, krb5_kdcpreauth_verify_respond_fn respond, void arg) { krb5_keyblock armor_key = NULL; krb5_pa_otp_req req = NULL; struct request_state rs; krb5_error_code retval; krb5_data d, plaintext; char config; enc_tkt_reply->flags \|= TKT_FLG_PRE_AUTH; /* Get the FAST armor key. / armor_key = cb->fast_armor(context, rock); if (armor_key == NULL) { retval = KRB5KDC_ERR_PREAUTH_FAILED; com_err("otp", retval, "No armor key found when verifying padata"); goto error; } / Decode the request. / d = make_data(pa->contents, pa->length); retval = decode_krb5_pa_otp_req(&d, &req); if (retval != 0) { com_err("otp", retval, "Unable to decode OTP request"); goto error; } / Decrypt the nonce from the request. / retval = decrypt_encdata(context, armor_key, req, &plaintext); if (retval != 0) { com_err("otp", retval, "Unable to decrypt nonce"); goto error; } / Verify the nonce or timestamp. / retval = nonce_verify(context, armor_key, &plaintext); if (retval != 0) retval = timestamp_verify(context, &plaintext); krb5_free_data_contents(context, &plaintext); if (retval != 0) { com_err("otp", retval, "Unable to verify nonce or timestamp"); goto error; } / Create the request state. / rs = k5alloc(sizeof(struct request_state), &retval); if (rs == NULL) goto error; rs->arg = arg; rs->respond = respond; / Get the principal's OTP configuration string. / retval = cb->get_string(context, rock, "otp", &config); if (retval == 0 && config == NULL) retval = KRB5_PREAUTH_FAILED; if (retval != 0) { free(rs); goto error; } / Send the request. / otp_state_verify((otp_state )moddata, cb->event_context(context, rock), request->client, config, req, on_response, rs); cb->free_string(context, rock, config); k5_free_pa_otp_req(context, req); return; error: k5_free_pa_otp_req(context, req); (respond)(arg, retval, NULL, NULL, NULL); } static krb5_error_code otp_return_padata(krb5_context context, krb5_pa_data padata, krb5_data req_pkt, krb5_kdc_req request, krb5_kdc_rep reply, krb5_keyblock encrypting_key, krb5_pa_data *send_pa_out, krb5_kdcpreauth_callbacks cb, krb5_kdcpreauth_rock rock, krb5_kdcpreauth_moddata moddata, krb5_kdcpreauth_modreq modreq) { krb5_keyblock armor_key = NULL; if (padata->length == 0) return 0; /* Get the armor key. / armor_key = cb->fast_armor(context, rock); if (!armor_key) { com_err("otp", ENOENT, "No armor key found when returning padata"); return ENOENT; } / Replace the reply key with the FAST armor key. */ krb5_free_keyblock_contents(context, encrypting_key); return krb5_copy_keyblock_contents(context, armor_key, encrypting_key); } krb5_error_code kdcpreauth_otp_initvt(krb5_context context, int maj_ver, int min_ver, krb5_plugin_vtable vtable); krb5_error_code kdcpreauth_otp_initvt(krb5_context context, int maj_ver, int min_ver, krb5_plugin_vtable vtable) { krb5_kdcpreauth_vtable vt; if (maj_ver != 1) return KRB5_PLUGIN_VER_NOTSUPP; vt = (krb5_kdcpreauth_vtable)vtable; vt->name = "otp"; vt->pa_type_list = otp_pa_type_list; vt->init = otp_init; vt->fini = otp_fini; vt->flags = otp_flags; vt->edata = otp_edata; vt->verify = otp_verify; vt->return_padata = otp_return_padata; com_err("otp", 0, "Loaded"); return 0; }	./CrossVul/dataset_final_sorted/CWE-264/c/bad_1533_0
crossvul-cpp_data_bad_5861_33	/* * Accelerated GHASH implementation with Intel PCLMULQDQ-NI * instructions. This file contains glue code. * * Copyright (c) 2009 Intel Corp. * Author: Huang Ying <ying.huang@intel.com> * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 as published * by the Free Software Foundation. / #include <linux/err.h> #include <linux/module.h> #include <linux/init.h> #include <linux/kernel.h> #include <linux/crypto.h> #include <crypto/algapi.h> #include <crypto/cryptd.h> #include <crypto/gf128mul.h> #include <crypto/internal/hash.h> #include <asm/i387.h> #include <asm/cpu_device_id.h> #define GHASH_BLOCK_SIZE 16 #define GHASH_DIGEST_SIZE 16 void clmul_ghash_mul(char dst, const u128 shash); void clmul_ghash_update(char dst, const char src, unsigned int srclen, const u128 shash); struct ghash_async_ctx { struct cryptd_ahash cryptd_tfm; }; struct ghash_ctx { u128 shash; }; struct ghash_desc_ctx { u8 buffer[GHASH_BLOCK_SIZE]; u32 bytes; }; static int ghash_init(struct shash_desc desc) { struct ghash_desc_ctx dctx = shash_desc_ctx(desc); memset(dctx, 0, sizeof(dctx)); return 0; } static int ghash_setkey(struct crypto_shash tfm, const u8 key, unsigned int keylen) { struct ghash_ctx ctx = crypto_shash_ctx(tfm); be128 x = (be128 )key; u64 a, b; if (keylen != GHASH_BLOCK_SIZE) { crypto_shash_set_flags(tfm, CRYPTO_TFM_RES_BAD_KEY_LEN); return -EINVAL; } / perform multiplication by 'x' in GF(2^128) / a = be64_to_cpu(x->a); b = be64_to_cpu(x->b); ctx->shash.a = (b << 1) \| (a >> 63); ctx->shash.b = (a << 1) \| (b >> 63); if (a >> 63) ctx->shash.b ^= ((u64)0xc2) << 56; return 0; } static int ghash_update(struct shash_desc desc, const u8 src, unsigned int srclen) { struct ghash_desc_ctx dctx = shash_desc_ctx(desc); struct ghash_ctx ctx = crypto_shash_ctx(desc->tfm); u8 dst = dctx->buffer; kernel_fpu_begin(); if (dctx->bytes) { int n = min(srclen, dctx->bytes); u8 pos = dst + (GHASH_BLOCK_SIZE - dctx->bytes); dctx->bytes -= n; srclen -= n; while (n--) pos++ ^= src++; if (!dctx->bytes) clmul_ghash_mul(dst, &ctx->shash); } clmul_ghash_update(dst, src, srclen, &ctx->shash); kernel_fpu_end(); if (srclen & 0xf) { src += srclen - (srclen & 0xf); srclen &= 0xf; dctx->bytes = GHASH_BLOCK_SIZE - srclen; while (srclen--) dst++ ^= src++; } return 0; } static void ghash_flush(struct ghash_ctx ctx, struct ghash_desc_ctx dctx) { u8 dst = dctx->buffer; if (dctx->bytes) { u8 tmp = dst + (GHASH_BLOCK_SIZE - dctx->bytes); while (dctx->bytes--) tmp++ ^= 0; kernel_fpu_begin(); clmul_ghash_mul(dst, &ctx->shash); kernel_fpu_end(); } dctx->bytes = 0; } static int ghash_final(struct shash_desc desc, u8 dst) { struct ghash_desc_ctx dctx = shash_desc_ctx(desc); struct ghash_ctx ctx = crypto_shash_ctx(desc->tfm); u8 buf = dctx->buffer; ghash_flush(ctx, dctx); memcpy(dst, buf, GHASH_BLOCK_SIZE); return 0; } static struct shash_alg ghash_alg = { .digestsize = GHASH_DIGEST_SIZE, .init = ghash_init, .update = ghash_update, .final = ghash_final, .setkey = ghash_setkey, .descsize = sizeof(struct ghash_desc_ctx), .base = { .cra_name = "__ghash", .cra_driver_name = "__ghash-pclmulqdqni", .cra_priority = 0, .cra_flags = CRYPTO_ALG_TYPE_SHASH, .cra_blocksize = GHASH_BLOCK_SIZE, .cra_ctxsize = sizeof(struct ghash_ctx), .cra_module = THIS_MODULE, }, }; static int ghash_async_init(struct ahash_request req) { struct crypto_ahash tfm = crypto_ahash_reqtfm(req); struct ghash_async_ctx ctx = crypto_ahash_ctx(tfm); struct ahash_request cryptd_req = ahash_request_ctx(req); struct cryptd_ahash cryptd_tfm = ctx->cryptd_tfm; if (!irq_fpu_usable()) { memcpy(cryptd_req, req, sizeof(req)); ahash_request_set_tfm(cryptd_req, &cryptd_tfm->base); return crypto_ahash_init(cryptd_req); } else { struct shash_desc desc = cryptd_shash_desc(cryptd_req); struct crypto_shash child = cryptd_ahash_child(cryptd_tfm); desc->tfm = child; desc->flags = req->base.flags; return crypto_shash_init(desc); } } static int ghash_async_update(struct ahash_request req) { struct ahash_request cryptd_req = ahash_request_ctx(req); if (!irq_fpu_usable()) { struct crypto_ahash tfm = crypto_ahash_reqtfm(req); struct ghash_async_ctx ctx = crypto_ahash_ctx(tfm); struct cryptd_ahash cryptd_tfm = ctx->cryptd_tfm; memcpy(cryptd_req, req, sizeof(req)); ahash_request_set_tfm(cryptd_req, &cryptd_tfm->base); return crypto_ahash_update(cryptd_req); } else { struct shash_desc desc = cryptd_shash_desc(cryptd_req); return shash_ahash_update(req, desc); } } static int ghash_async_final(struct ahash_request req) { struct ahash_request cryptd_req = ahash_request_ctx(req); if (!irq_fpu_usable()) { struct crypto_ahash tfm = crypto_ahash_reqtfm(req); struct ghash_async_ctx ctx = crypto_ahash_ctx(tfm); struct cryptd_ahash cryptd_tfm = ctx->cryptd_tfm; memcpy(cryptd_req, req, sizeof(req)); ahash_request_set_tfm(cryptd_req, &cryptd_tfm->base); return crypto_ahash_final(cryptd_req); } else { struct shash_desc desc = cryptd_shash_desc(cryptd_req); return crypto_shash_final(desc, req->result); } } static int ghash_async_digest(struct ahash_request req) { struct crypto_ahash tfm = crypto_ahash_reqtfm(req); struct ghash_async_ctx ctx = crypto_ahash_ctx(tfm); struct ahash_request cryptd_req = ahash_request_ctx(req); struct cryptd_ahash cryptd_tfm = ctx->cryptd_tfm; if (!irq_fpu_usable()) { memcpy(cryptd_req, req, sizeof(req)); ahash_request_set_tfm(cryptd_req, &cryptd_tfm->base); return crypto_ahash_digest(cryptd_req); } else { struct shash_desc desc = cryptd_shash_desc(cryptd_req); struct crypto_shash child = cryptd_ahash_child(cryptd_tfm); desc->tfm = child; desc->flags = req->base.flags; return shash_ahash_digest(req, desc); } } static int ghash_async_setkey(struct crypto_ahash tfm, const u8 key, unsigned int keylen) { struct ghash_async_ctx ctx = crypto_ahash_ctx(tfm); struct crypto_ahash child = &ctx->cryptd_tfm->base; int err; crypto_ahash_clear_flags(child, CRYPTO_TFM_REQ_MASK); crypto_ahash_set_flags(child, crypto_ahash_get_flags(tfm) & CRYPTO_TFM_REQ_MASK); err = crypto_ahash_setkey(child, key, keylen); crypto_ahash_set_flags(tfm, crypto_ahash_get_flags(child) & CRYPTO_TFM_RES_MASK); return err; } static int ghash_async_init_tfm(struct crypto_tfm tfm) { struct cryptd_ahash cryptd_tfm; struct ghash_async_ctx ctx = crypto_tfm_ctx(tfm); cryptd_tfm = cryptd_alloc_ahash("__ghash-pclmulqdqni", 0, 0); if (IS_ERR(cryptd_tfm)) return PTR_ERR(cryptd_tfm); ctx->cryptd_tfm = cryptd_tfm; crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm), sizeof(struct ahash_request) + crypto_ahash_reqsize(&cryptd_tfm->base)); return 0; } static void ghash_async_exit_tfm(struct crypto_tfm tfm) { struct ghash_async_ctx ctx = crypto_tfm_ctx(tfm); cryptd_free_ahash(ctx->cryptd_tfm); } static struct ahash_alg ghash_async_alg = { .init = ghash_async_init, .update = ghash_async_update, .final = ghash_async_final, .setkey = ghash_async_setkey, .digest = ghash_async_digest, .halg = { .digestsize = GHASH_DIGEST_SIZE, .base = { .cra_name = "ghash", .cra_driver_name = "ghash-clmulni", .cra_priority = 400, .cra_flags = CRYPTO_ALG_TYPE_AHASH \| CRYPTO_ALG_ASYNC, .cra_blocksize = GHASH_BLOCK_SIZE, .cra_type = &crypto_ahash_type, .cra_module = THIS_MODULE, .cra_init = ghash_async_init_tfm, .cra_exit = ghash_async_exit_tfm, }, }, }; static const struct x86_cpu_id pcmul_cpu_id[] = { X86_FEATURE_MATCH(X86_FEATURE_PCLMULQDQ), /* Pickle-Mickle-Duck */ {} }; MODULE_DEVICE_TABLE(x86cpu, pcmul_cpu_id); static int __init ghash_pclmulqdqni_mod_init(void) { int err; if (!x86_match_cpu(pcmul_cpu_id)) return -ENODEV; err = crypto_register_shash(&ghash_alg); if (err) goto err_out; err = crypto_register_ahash(&ghash_async_alg); if (err) goto err_shash; return 0; err_shash: crypto_unregister_shash(&ghash_alg); err_out: return err; } static void __exit ghash_pclmulqdqni_mod_exit(void) { crypto_unregister_ahash(&ghash_async_alg); crypto_unregister_shash(&ghash_alg); } module_init(ghash_pclmulqdqni_mod_init); module_exit(ghash_pclmulqdqni_mod_exit); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("GHASH Message Digest Algorithm, " "acclerated by PCLMULQDQ-NI"); MODULE_ALIAS("ghash");	./CrossVul/dataset_final_sorted/CWE-264/c/bad_5861_33
crossvul-cpp_data_bad_2287_9	/* file-nommu.c: no-MMU version of ramfs * * Copyright (C) 2005 Red Hat, Inc. All Rights Reserved. * Written by David Howells (dhowells@redhat.com) * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version. / #include <linux/module.h> #include <linux/fs.h> #include <linux/mm.h> #include <linux/pagemap.h> #include <linux/highmem.h> #include <linux/init.h> #include <linux/string.h> #include <linux/backing-dev.h> #include <linux/ramfs.h> #include <linux/pagevec.h> #include <linux/mman.h> #include <linux/sched.h> #include <linux/slab.h> #include <asm/uaccess.h> #include "internal.h" static int ramfs_nommu_setattr(struct dentry , struct iattr ); static unsigned long ramfs_nommu_get_unmapped_area(struct file file, unsigned long addr, unsigned long len, unsigned long pgoff, unsigned long flags); static int ramfs_nommu_mmap(struct file file, struct vm_area_struct vma); const struct file_operations ramfs_file_operations = { .mmap = ramfs_nommu_mmap, .get_unmapped_area = ramfs_nommu_get_unmapped_area, .read = new_sync_read, .read_iter = generic_file_read_iter, .write = new_sync_write, .write_iter = generic_file_write_iter, .fsync = noop_fsync, .splice_read = generic_file_splice_read, .splice_write = generic_file_splice_write, .llseek = generic_file_llseek, }; const struct inode_operations ramfs_file_inode_operations = { .setattr = ramfs_nommu_setattr, .getattr = simple_getattr, }; /****************************************************************************/ / * add a contiguous set of pages into a ramfs inode when it's truncated from * size 0 on the assumption that it's going to be used for an mmap of shared * memory / int ramfs_nommu_expand_for_mapping(struct inode inode, size_t newsize) { unsigned long npages, xpages, loop; struct page pages; unsigned order; void data; int ret; /* make various checks / order = get_order(newsize); if (unlikely(order >= MAX_ORDER)) return -EFBIG; ret = inode_newsize_ok(inode, newsize); if (ret) return ret; i_size_write(inode, newsize); / allocate enough contiguous pages to be able to satisfy the * request / pages = alloc_pages(mapping_gfp_mask(inode->i_mapping), order); if (!pages) return -ENOMEM; / split the high-order page into an array of single pages / xpages = 1UL << order; npages = (newsize + PAGE_SIZE - 1) >> PAGE_SHIFT; split_page(pages, order); / trim off any pages we don't actually require / for (loop = npages; loop < xpages; loop++) __free_page(pages + loop); / clear the memory we allocated / newsize = PAGE_SIZE npages; data = page_address(pages); memset(data, 0, newsize); /* attach all the pages to the inode's address space / for (loop = 0; loop < npages; loop++) { struct page page = pages + loop; ret = add_to_page_cache_lru(page, inode->i_mapping, loop, GFP_KERNEL); if (ret < 0) goto add_error; /* prevent the page from being discarded on memory pressure / SetPageDirty(page); SetPageUptodate(page); unlock_page(page); put_page(page); } return 0; add_error: while (loop < npages) __free_page(pages + loop++); return ret; } /***************************************************************************/ / * / static int ramfs_nommu_resize(struct inode inode, loff_t newsize, loff_t size) { int ret; /* assume a truncate from zero size is going to be for the purposes of * shared mmap / if (size == 0) { if (unlikely(newsize >> 32)) return -EFBIG; return ramfs_nommu_expand_for_mapping(inode, newsize); } / check that a decrease in size doesn't cut off any shared mappings / if (newsize < size) { ret = nommu_shrink_inode_mappings(inode, size, newsize); if (ret < 0) return ret; } truncate_setsize(inode, newsize); return 0; } /***************************************************************************/ / * handle a change of attributes * - we're specifically interested in a change of size / static int ramfs_nommu_setattr(struct dentry dentry, struct iattr ia) { struct inode inode = dentry->d_inode; unsigned int old_ia_valid = ia->ia_valid; int ret = 0; /* POSIX UID/GID verification for setting inode attributes / ret = inode_change_ok(inode, ia); if (ret) return ret; / pick out size-changing events / if (ia->ia_valid & ATTR_SIZE) { loff_t size = inode->i_size; if (ia->ia_size != size) { ret = ramfs_nommu_resize(inode, ia->ia_size, size); if (ret < 0 \|\| ia->ia_valid == ATTR_SIZE) goto out; } else { / we skipped the truncate but must still update * timestamps / ia->ia_valid \|= ATTR_MTIME\|ATTR_CTIME; } } setattr_copy(inode, ia); out: ia->ia_valid = old_ia_valid; return ret; } /***************************************************************************/ / * try to determine where a shared mapping can be made * - we require that: * - the pages to be mapped must exist * - the pages be physically contiguous in sequence / static unsigned long ramfs_nommu_get_unmapped_area(struct file file, unsigned long addr, unsigned long len, unsigned long pgoff, unsigned long flags) { unsigned long maxpages, lpages, nr, loop, ret; struct inode inode = file_inode(file); struct page pages = NULL, ptr, page; loff_t isize; if (!(flags & MAP_SHARED)) return addr; /* the mapping mustn't extend beyond the EOF / lpages = (len + PAGE_SIZE - 1) >> PAGE_SHIFT; isize = i_size_read(inode); ret = -EINVAL; maxpages = (isize + PAGE_SIZE - 1) >> PAGE_SHIFT; if (pgoff >= maxpages) goto out; if (maxpages - pgoff < lpages) goto out; / gang-find the pages / ret = -ENOMEM; pages = kzalloc(lpages sizeof(struct page ), GFP_KERNEL); if (!pages) goto out_free; nr = find_get_pages(inode->i_mapping, pgoff, lpages, pages); if (nr != lpages) goto out_free_pages; / leave if some pages were missing / / check the pages for physical adjacency / ptr = pages; page = ptr++; page++; for (loop = lpages; loop > 1; loop--) if (ptr++ != page++) goto out_free_pages; / okay - all conditions fulfilled / ret = (unsigned long) page_address(pages[0]); out_free_pages: ptr = pages; for (loop = nr; loop > 0; loop--) put_page(ptr++); out_free: kfree(pages); out: return ret; } /****************************************************************************/ / * set up a mapping for shared memory segments / static int ramfs_nommu_mmap(struct file file, struct vm_area_struct *vma) { if (!(vma->vm_flags & VM_SHARED)) return -ENOSYS; file_accessed(file); vma->vm_ops = &generic_file_vm_ops; return 0; }	./CrossVul/dataset_final_sorted/CWE-264/c/bad_2287_9
crossvul-cpp_data_bad_5616_1	/* * linux/fs/pnode.c * * (C) Copyright IBM Corporation 2005. * Released under GPL v2. * Author : Ram Pai (linuxram@us.ibm.com) * / #include <linux/mnt_namespace.h> #include <linux/mount.h> #include <linux/fs.h> #include "internal.h" #include "pnode.h" / return the next shared peer mount of @p / static inline struct mount next_peer(struct mount p) { return list_entry(p->mnt_share.next, struct mount, mnt_share); } static inline struct mount first_slave(struct mount p) { return list_entry(p->mnt_slave_list.next, struct mount, mnt_slave); } static inline struct mount next_slave(struct mount p) { return list_entry(p->mnt_slave.next, struct mount, mnt_slave); } static struct mount get_peer_under_root(struct mount mnt, struct mnt_namespace ns, const struct path root) { struct mount m = mnt; do { /* Check the namespace first for optimization / if (m->mnt_ns == ns && is_path_reachable(m, m->mnt.mnt_root, root)) return m; m = next_peer(m); } while (m != mnt); return NULL; } / * Get ID of closest dominating peer group having a representative * under the given root. * * Caller must hold namespace_sem / int get_dominating_id(struct mount mnt, const struct path root) { struct mount m; for (m = mnt->mnt_master; m != NULL; m = m->mnt_master) { struct mount d = get_peer_under_root(m, mnt->mnt_ns, root); if (d) return d->mnt_group_id; } return 0; } static int do_make_slave(struct mount mnt) { struct mount peer_mnt = mnt, master = mnt->mnt_master; struct mount slave_mnt; / * slave 'mnt' to a peer mount that has the * same root dentry. If none is available then * slave it to anything that is available. / while ((peer_mnt = next_peer(peer_mnt)) != mnt && peer_mnt->mnt.mnt_root != mnt->mnt.mnt_root) ; if (peer_mnt == mnt) { peer_mnt = next_peer(mnt); if (peer_mnt == mnt) peer_mnt = NULL; } if (IS_MNT_SHARED(mnt) && list_empty(&mnt->mnt_share)) mnt_release_group_id(mnt); list_del_init(&mnt->mnt_share); mnt->mnt_group_id = 0; if (peer_mnt) master = peer_mnt; if (master) { list_for_each_entry(slave_mnt, &mnt->mnt_slave_list, mnt_slave) slave_mnt->mnt_master = master; list_move(&mnt->mnt_slave, &master->mnt_slave_list); list_splice(&mnt->mnt_slave_list, master->mnt_slave_list.prev); INIT_LIST_HEAD(&mnt->mnt_slave_list); } else { struct list_head p = &mnt->mnt_slave_list; while (!list_empty(p)) { slave_mnt = list_first_entry(p, struct mount, mnt_slave); list_del_init(&slave_mnt->mnt_slave); slave_mnt->mnt_master = NULL; } } mnt->mnt_master = master; CLEAR_MNT_SHARED(mnt); return 0; } /* * vfsmount lock must be held for write / void change_mnt_propagation(struct mount mnt, int type) { if (type == MS_SHARED) { set_mnt_shared(mnt); return; } do_make_slave(mnt); if (type != MS_SLAVE) { list_del_init(&mnt->mnt_slave); mnt->mnt_master = NULL; if (type == MS_UNBINDABLE) mnt->mnt.mnt_flags \|= MNT_UNBINDABLE; else mnt->mnt.mnt_flags &= ~MNT_UNBINDABLE; } } /* * get the next mount in the propagation tree. * @m: the mount seen last * @origin: the original mount from where the tree walk initiated * * Note that peer groups form contiguous segments of slave lists. * We rely on that in get_source() to be able to find out if * vfsmount found while iterating with propagation_next() is * a peer of one we'd found earlier. / static struct mount propagation_next(struct mount m, struct mount origin) { /* are there any slaves of this mount? / if (!IS_MNT_NEW(m) && !list_empty(&m->mnt_slave_list)) return first_slave(m); while (1) { struct mount master = m->mnt_master; if (master == origin->mnt_master) { struct mount next = next_peer(m); return (next == origin) ? NULL : next; } else if (m->mnt_slave.next != &master->mnt_slave_list) return next_slave(m); / back at master / m = master; } } / * return the source mount to be used for cloning * * @dest the current destination mount * @last_dest the last seen destination mount * @last_src the last seen source mount * @type return CL_SLAVE if the new mount has to be * cloned as a slave. / static struct mount get_source(struct mount dest, struct mount last_dest, struct mount last_src, int type) { struct mount p_last_src = NULL; struct mount p_last_dest = NULL; while (last_dest != dest->mnt_master) { p_last_dest = last_dest; p_last_src = last_src; last_dest = last_dest->mnt_master; last_src = last_src->mnt_master; } if (p_last_dest) { do { p_last_dest = next_peer(p_last_dest); } while (IS_MNT_NEW(p_last_dest)); /* is that a peer of the earlier? / if (dest == p_last_dest) { type = CL_MAKE_SHARED; return p_last_src; } } /* slave of the earlier, then / type = CL_SLAVE; /* beginning of peer group among the slaves? / if (IS_MNT_SHARED(dest)) type \|= CL_MAKE_SHARED; return last_src; } /* * mount 'source_mnt' under the destination 'dest_mnt' at * dentry 'dest_dentry'. And propagate that mount to * all the peer and slave mounts of 'dest_mnt'. * Link all the new mounts into a propagation tree headed at * source_mnt. Also link all the new mounts using ->mnt_list * headed at source_mnt's ->mnt_list * * @dest_mnt: destination mount. * @dest_dentry: destination dentry. * @source_mnt: source mount. * @tree_list : list of heads of trees to be attached. / int propagate_mnt(struct mount dest_mnt, struct dentry dest_dentry, struct mount source_mnt, struct list_head tree_list) { struct mount m, child; int ret = 0; struct mount prev_dest_mnt = dest_mnt; struct mount prev_src_mnt = source_mnt; LIST_HEAD(tmp_list); LIST_HEAD(umount_list); for (m = propagation_next(dest_mnt, dest_mnt); m; m = propagation_next(m, dest_mnt)) { int type; struct mount source; if (IS_MNT_NEW(m)) continue; source = get_source(m, prev_dest_mnt, prev_src_mnt, &type); child = copy_tree(source, source->mnt.mnt_root, type); if (IS_ERR(child)) { ret = PTR_ERR(child); list_splice(tree_list, tmp_list.prev); goto out; } if (is_subdir(dest_dentry, m->mnt.mnt_root)) { mnt_set_mountpoint(m, dest_dentry, child); list_add_tail(&child->mnt_hash, tree_list); } else { /* * This can happen if the parent mount was bind mounted * on some subdirectory of a shared/slave mount. / list_add_tail(&child->mnt_hash, &tmp_list); } prev_dest_mnt = m; prev_src_mnt = child; } out: br_write_lock(&vfsmount_lock); while (!list_empty(&tmp_list)) { child = list_first_entry(&tmp_list, struct mount, mnt_hash); umount_tree(child, 0, &umount_list); } br_write_unlock(&vfsmount_lock); release_mounts(&umount_list); return ret; } / * return true if the refcount is greater than count / static inline int do_refcount_check(struct mount mnt, int count) { int mycount = mnt_get_count(mnt) - mnt->mnt_ghosts; return (mycount > count); } /* * check if the mount 'mnt' can be unmounted successfully. * @mnt: the mount to be checked for unmount * NOTE: unmounting 'mnt' would naturally propagate to all * other mounts its parent propagates to. * Check if any of these mounts that do not have submounts * have more references than 'refcnt'. If so return busy. * * vfsmount lock must be held for write / int propagate_mount_busy(struct mount mnt, int refcnt) { struct mount m, child; struct mount parent = mnt->mnt_parent; int ret = 0; if (mnt == parent) return do_refcount_check(mnt, refcnt); / * quickly check if the current mount can be unmounted. * If not, we don't have to go checking for all other * mounts / if (!list_empty(&mnt->mnt_mounts) \|\| do_refcount_check(mnt, refcnt)) return 1; for (m = propagation_next(parent, parent); m; m = propagation_next(m, parent)) { child = __lookup_mnt(&m->mnt, mnt->mnt_mountpoint, 0); if (child && list_empty(&child->mnt_mounts) && (ret = do_refcount_check(child, 1))) break; } return ret; } / * NOTE: unmounting 'mnt' naturally propagates to all other mounts its * parent propagates to. / static void __propagate_umount(struct mount mnt) { struct mount parent = mnt->mnt_parent; struct mount m; BUG_ON(parent == mnt); for (m = propagation_next(parent, parent); m; m = propagation_next(m, parent)) { struct mount child = __lookup_mnt(&m->mnt, mnt->mnt_mountpoint, 0); / * umount the child only if the child has no * other children / if (child && list_empty(&child->mnt_mounts)) list_move_tail(&child->mnt_hash, &mnt->mnt_hash); } } / * collect all mounts that receive propagation from the mount in @list, * and return these additional mounts in the same list. * @list: the list of mounts to be unmounted. * * vfsmount lock must be held for write / int propagate_umount(struct list_head list) { struct mount *mnt; list_for_each_entry(mnt, list, mnt_hash) __propagate_umount(mnt); return 0; }	./CrossVul/dataset_final_sorted/CWE-264/c/bad_5616_1
crossvul-cpp_data_bad_2118_0	/* * ejabberd, Copyright (C) 2002-2011 ProcessOne * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation; either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA * 02111-1307 USA * / #include <stdio.h> #include <string.h> #include <erl_driver.h> #include <zlib.h> #define BUF_SIZE 1024 / * R15B changed several driver callbacks to use ErlDrvSizeT and * ErlDrvSSizeT typedefs instead of int. * This provides missing typedefs on older OTP versions. / #if ERL_DRV_EXTENDED_MAJOR_VERSION < 2 typedef int ErlDrvSizeT; typedef int ErlDrvSSizeT; #endif typedef struct { ErlDrvPort port; z_stream d_stream; z_stream i_stream; } ejabberd_zlib_data; static void zlib_alloc(void* data, unsigned int items, unsigned int size) { return (void) driver_alloc(itemssize); } static void zlib_free(void* data, void* addr) { driver_free(addr); } static ErlDrvData ejabberd_zlib_drv_start(ErlDrvPort port, char buff) { ejabberd_zlib_data d = (ejabberd_zlib_data )driver_alloc(sizeof(ejabberd_zlib_data)); d->port = port; d->d_stream = (z_stream )driver_alloc(sizeof(z_stream)); d->d_stream->zalloc = zlib_alloc; d->d_stream->zfree = zlib_free; d->d_stream->opaque = (voidpf)0; deflateInit(d->d_stream, Z_DEFAULT_COMPRESSION); d->i_stream = (z_stream )driver_alloc(sizeof(z_stream)); d->i_stream->zalloc = zlib_alloc; d->i_stream->zfree = zlib_free; d->i_stream->opaque = (voidpf)0; inflateInit(d->i_stream); set_port_control_flags(port, PORT_CONTROL_FLAG_BINARY); return (ErlDrvData)d; } static void ejabberd_zlib_drv_stop(ErlDrvData handle) { ejabberd_zlib_data d = (ejabberd_zlib_data )handle; deflateEnd(d->d_stream); driver_free(d->d_stream); inflateEnd(d->i_stream); driver_free(d->i_stream); driver_free((char )handle); } #define DEFLATE 1 #define INFLATE 2 #define die_unless(cond, errstr) \ if (!(cond)) \ { \ rlen = strlen(errstr) + 1; \ b = driver_realloc_binary(b, rlen); \ b->orig_bytes[0] = 1; \ strncpy(b->orig_bytes + 1, errstr, rlen - 1); \ rbuf = (char )b; \ return rlen; \ } static ErlDrvSSizeT ejabberd_zlib_drv_control(ErlDrvData handle, unsigned int command, char buf, ErlDrvSizeT len, char rbuf, ErlDrvSizeT rlen) { ejabberd_zlib_data d = (ejabberd_zlib_data )handle; int err; int size; ErlDrvBinary b; switch (command) { case DEFLATE: size = BUF_SIZE + 1; rlen = 1; b = driver_alloc_binary(size); b->orig_bytes[0] = 0; d->d_stream->next_in = (unsigned char )buf; d->d_stream->avail_in = len; d->d_stream->avail_out = 0; err = Z_OK; while (err == Z_OK && d->d_stream->avail_out == 0) { d->d_stream->next_out = (unsigned char )b->orig_bytes + rlen; d->d_stream->avail_out = BUF_SIZE; err = deflate(d->d_stream, Z_SYNC_FLUSH); die_unless((err == Z_OK) \|\| (err == Z_STREAM_END), "Deflate error"); rlen += (BUF_SIZE - d->d_stream->avail_out); size += (BUF_SIZE - d->d_stream->avail_out); b = driver_realloc_binary(b, size); } b = driver_realloc_binary(b, rlen); rbuf = (char )b; return rlen; case INFLATE: size = BUF_SIZE + 1; rlen = 1; b = driver_alloc_binary(size); b->orig_bytes[0] = 0; if (len > 0) { d->i_stream->next_in = (unsigned char )buf; d->i_stream->avail_in = len; d->i_stream->avail_out = 0; err = Z_OK; while (err == Z_OK && d->i_stream->avail_out == 0) { d->i_stream->next_out = (unsigned char )b->orig_bytes + rlen; d->i_stream->avail_out = BUF_SIZE; err = inflate(d->i_stream, Z_SYNC_FLUSH); die_unless((err == Z_OK) \|\| (err == Z_STREAM_END), "Inflate error"); rlen += (BUF_SIZE - d->i_stream->avail_out); size += (BUF_SIZE - d->i_stream->avail_out); b = driver_realloc_binary(b, size); } } b = driver_realloc_binary(b, rlen); rbuf = (char )b; return rlen; } b = driver_alloc_binary(1); b->orig_bytes[0] = 0; rbuf = (char )b; return 1; } ErlDrvEntry ejabberd_zlib_driver_entry = { NULL, /* F_PTR init, N/A / ejabberd_zlib_drv_start, / L_PTR start, called when port is opened / ejabberd_zlib_drv_stop, / F_PTR stop, called when port is closed / NULL, / F_PTR output, called when erlang has sent / NULL, / F_PTR ready_input, called when input descriptor ready / NULL, / F_PTR ready_output, called when output descriptor ready / "ejabberd_zlib_drv", / char driver_name, the argument to open_port / NULL, /* F_PTR finish, called when unloaded / NULL, / handle / ejabberd_zlib_drv_control, / F_PTR control, port_command callback / NULL, / F_PTR timeout, reserved / NULL, / F_PTR outputv, reserved / / Added in Erlang/OTP R15B: / NULL, / ready_async / NULL, / flush / NULL, / call / NULL, / event / ERL_DRV_EXTENDED_MARKER, / extended_marker / ERL_DRV_EXTENDED_MAJOR_VERSION, / major_version / ERL_DRV_EXTENDED_MINOR_VERSION, / minor_version / 0, / driver_flags / NULL, / handle2 / NULL, / process_exit / NULL / stop select / }; DRIVER_INIT(ejabberd_zlib_drv) / must match name in driver_entry */ { return &ejabberd_zlib_driver_entry; }	./CrossVul/dataset_final_sorted/CWE-264/c/bad_2118_0
crossvul-cpp_data_bad_2399_22	/* XTS: as defined in IEEE1619/D16 * http://grouper.ieee.org/groups/1619/email/pdf00086.pdf * (sector sizes which are not a multiple of 16 bytes are, * however currently unsupported) * * Copyright (c) 2007 Rik Snel <rsnel@cube.dyndns.org> * * Based om ecb.c * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au> * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the Free * Software Foundation; either version 2 of the License, or (at your option) * any later version. / #include <crypto/algapi.h> #include <linux/err.h> #include <linux/init.h> #include <linux/kernel.h> #include <linux/module.h> #include <linux/scatterlist.h> #include <linux/slab.h> #include <crypto/xts.h> #include <crypto/b128ops.h> #include <crypto/gf128mul.h> struct priv { struct crypto_cipher child; struct crypto_cipher tweak; }; static int setkey(struct crypto_tfm parent, const u8 key, unsigned int keylen) { struct priv ctx = crypto_tfm_ctx(parent); struct crypto_cipher child = ctx->tweak; u32 flags = &parent->crt_flags; int err; /* key consists of keys of equal size concatenated, therefore * the length must be even / if (keylen % 2) { / tell the user why there was an error / flags \|= CRYPTO_TFM_RES_BAD_KEY_LEN; return -EINVAL; } /* we need two cipher instances: one to compute the initial 'tweak' * by encrypting the IV (usually the 'plain' iv) and the other * one to encrypt and decrypt the data / / tweak cipher, uses Key2 i.e. the second half of key / crypto_cipher_clear_flags(child, CRYPTO_TFM_REQ_MASK); crypto_cipher_set_flags(child, crypto_tfm_get_flags(parent) & CRYPTO_TFM_REQ_MASK); err = crypto_cipher_setkey(child, key + keylen/2, keylen/2); if (err) return err; crypto_tfm_set_flags(parent, crypto_cipher_get_flags(child) & CRYPTO_TFM_RES_MASK); child = ctx->child; /* data cipher, uses Key1 i.e. the first half of key / crypto_cipher_clear_flags(child, CRYPTO_TFM_REQ_MASK); crypto_cipher_set_flags(child, crypto_tfm_get_flags(parent) & CRYPTO_TFM_REQ_MASK); err = crypto_cipher_setkey(child, key, keylen/2); if (err) return err; crypto_tfm_set_flags(parent, crypto_cipher_get_flags(child) & CRYPTO_TFM_RES_MASK); return 0; } struct sinfo { be128 t; struct crypto_tfm tfm; void (fn)(struct crypto_tfm , u8 , const u8 ); }; static inline void xts_round(struct sinfo s, void dst, const void src) { be128_xor(dst, s->t, src); / PP <- T xor P / s->fn(s->tfm, dst, dst); / CC <- E(Key1,PP) / be128_xor(dst, dst, s->t); / C <- T xor CC / } static int crypt(struct blkcipher_desc d, struct blkcipher_walk w, struct priv ctx, void (tw)(struct crypto_tfm , u8 , const u8 ), void (fn)(struct crypto_tfm , u8 , const u8 )) { int err; unsigned int avail; const int bs = XTS_BLOCK_SIZE; struct sinfo s = { .tfm = crypto_cipher_tfm(ctx->child), .fn = fn }; u8 wsrc; u8 wdst; err = blkcipher_walk_virt(d, w); if (!w->nbytes) return err; s.t = (be128 )w->iv; avail = w->nbytes; wsrc = w->src.virt.addr; wdst = w->dst.virt.addr; / calculate first value of T / tw(crypto_cipher_tfm(ctx->tweak), w->iv, w->iv); goto first; for (;;) { do { gf128mul_x_ble(s.t, s.t); first: xts_round(&s, wdst, wsrc); wsrc += bs; wdst += bs; } while ((avail -= bs) >= bs); err = blkcipher_walk_done(d, w, avail); if (!w->nbytes) break; avail = w->nbytes; wsrc = w->src.virt.addr; wdst = w->dst.virt.addr; } return err; } static int encrypt(struct blkcipher_desc desc, struct scatterlist dst, struct scatterlist src, unsigned int nbytes) { struct priv ctx = crypto_blkcipher_ctx(desc->tfm); struct blkcipher_walk w; blkcipher_walk_init(&w, dst, src, nbytes); return crypt(desc, &w, ctx, crypto_cipher_alg(ctx->tweak)->cia_encrypt, crypto_cipher_alg(ctx->child)->cia_encrypt); } static int decrypt(struct blkcipher_desc desc, struct scatterlist dst, struct scatterlist src, unsigned int nbytes) { struct priv ctx = crypto_blkcipher_ctx(desc->tfm); struct blkcipher_walk w; blkcipher_walk_init(&w, dst, src, nbytes); return crypt(desc, &w, ctx, crypto_cipher_alg(ctx->tweak)->cia_encrypt, crypto_cipher_alg(ctx->child)->cia_decrypt); } int xts_crypt(struct blkcipher_desc desc, struct scatterlist sdst, struct scatterlist ssrc, unsigned int nbytes, struct xts_crypt_req req) { const unsigned int bsize = XTS_BLOCK_SIZE; const unsigned int max_blks = req->tbuflen / bsize; struct blkcipher_walk walk; unsigned int nblocks; be128 src, dst, t; be128 t_buf = req->tbuf; int err, i; BUG_ON(max_blks < 1); blkcipher_walk_init(&walk, sdst, ssrc, nbytes); err = blkcipher_walk_virt(desc, &walk); nbytes = walk.nbytes; if (!nbytes) return err; nblocks = min(nbytes / bsize, max_blks); src = (be128 )walk.src.virt.addr; dst = (be128 )walk.dst.virt.addr; / calculate first value of T / req->tweak_fn(req->tweak_ctx, (u8 )&t_buf[0], walk.iv); i = 0; goto first; for (;;) { do { for (i = 0; i < nblocks; i++) { gf128mul_x_ble(&t_buf[i], t); first: t = &t_buf[i]; /* PP <- T xor P / be128_xor(dst + i, t, src + i); } / CC <- E(Key2,PP) / req->crypt_fn(req->crypt_ctx, (u8 )dst, nblocks * bsize); /* C <- T xor CC / for (i = 0; i < nblocks; i++) be128_xor(dst + i, dst + i, &t_buf[i]); src += nblocks; dst += nblocks; nbytes -= nblocks bsize; nblocks = min(nbytes / bsize, max_blks); } while (nblocks > 0); (be128 )walk.iv = t; err = blkcipher_walk_done(desc, &walk, nbytes); nbytes = walk.nbytes; if (!nbytes) break; nblocks = min(nbytes / bsize, max_blks); src = (be128 )walk.src.virt.addr; dst = (be128 )walk.dst.virt.addr; } return err; } EXPORT_SYMBOL_GPL(xts_crypt); static int init_tfm(struct crypto_tfm tfm) { struct crypto_cipher cipher; struct crypto_instance inst = (void )tfm->__crt_alg; struct crypto_spawn spawn = crypto_instance_ctx(inst); struct priv ctx = crypto_tfm_ctx(tfm); u32 flags = &tfm->crt_flags; cipher = crypto_spawn_cipher(spawn); if (IS_ERR(cipher)) return PTR_ERR(cipher); if (crypto_cipher_blocksize(cipher) != XTS_BLOCK_SIZE) { flags \|= CRYPTO_TFM_RES_BAD_BLOCK_LEN; crypto_free_cipher(cipher); return -EINVAL; } ctx->child = cipher; cipher = crypto_spawn_cipher(spawn); if (IS_ERR(cipher)) { crypto_free_cipher(ctx->child); return PTR_ERR(cipher); } / this check isn't really needed, leave it here just in case / if (crypto_cipher_blocksize(cipher) != XTS_BLOCK_SIZE) { crypto_free_cipher(cipher); crypto_free_cipher(ctx->child); flags \|= CRYPTO_TFM_RES_BAD_BLOCK_LEN; return -EINVAL; } ctx->tweak = cipher; return 0; } static void exit_tfm(struct crypto_tfm tfm) { struct priv ctx = crypto_tfm_ctx(tfm); crypto_free_cipher(ctx->child); crypto_free_cipher(ctx->tweak); } static struct crypto_instance alloc(struct rtattr tb) { struct crypto_instance inst; struct crypto_alg alg; int err; err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_BLKCIPHER); if (err) return ERR_PTR(err); alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER, CRYPTO_ALG_TYPE_MASK); if (IS_ERR(alg)) return ERR_CAST(alg); inst = crypto_alloc_instance("xts", alg); if (IS_ERR(inst)) goto out_put_alg; inst->alg.cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER; inst->alg.cra_priority = alg->cra_priority; inst->alg.cra_blocksize = alg->cra_blocksize; if (alg->cra_alignmask < 7) inst->alg.cra_alignmask = 7; else inst->alg.cra_alignmask = alg->cra_alignmask; inst->alg.cra_type = &crypto_blkcipher_type; inst->alg.cra_blkcipher.ivsize = alg->cra_blocksize; inst->alg.cra_blkcipher.min_keysize = 2 alg->cra_cipher.cia_min_keysize; inst->alg.cra_blkcipher.max_keysize = 2 * alg->cra_cipher.cia_max_keysize; inst->alg.cra_ctxsize = sizeof(struct priv); inst->alg.cra_init = init_tfm; inst->alg.cra_exit = exit_tfm; inst->alg.cra_blkcipher.setkey = setkey; inst->alg.cra_blkcipher.encrypt = encrypt; inst->alg.cra_blkcipher.decrypt = decrypt; out_put_alg: crypto_mod_put(alg); return inst; } static void free(struct crypto_instance *inst) { crypto_drop_spawn(crypto_instance_ctx(inst)); kfree(inst); } static struct crypto_template crypto_tmpl = { .name = "xts", .alloc = alloc, .free = free, .module = THIS_MODULE, }; static int __init crypto_module_init(void) { return crypto_register_template(&crypto_tmpl); } static void __exit crypto_module_exit(void) { crypto_unregister_template(&crypto_tmpl); } module_init(crypto_module_init); module_exit(crypto_module_exit); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("XTS block cipher mode");	./CrossVul/dataset_final_sorted/CWE-264/c/bad_2399_22
crossvul-cpp_data_good_3526_1	/* * Copyright (C) 2001-2003 Sistina Software (UK) Limited. * * This file is released under the GPL. / #include "dm.h" #include <linux/module.h> #include <linux/init.h> #include <linux/blkdev.h> #include <linux/bio.h> #include <linux/slab.h> #include <linux/device-mapper.h> #define DM_MSG_PREFIX "linear" / * Linear: maps a linear range of a device. / struct linear_c { struct dm_dev dev; sector_t start; }; /* * Construct a linear mapping: <dev_path> <offset> / static int linear_ctr(struct dm_target ti, unsigned int argc, char *argv) { struct linear_c lc; unsigned long long tmp; if (argc != 2) { ti->error = "Invalid argument count"; return -EINVAL; } lc = kmalloc(sizeof(lc), GFP_KERNEL); if (lc == NULL) { ti->error = "dm-linear: Cannot allocate linear context"; return -ENOMEM; } if (sscanf(argv[1], "%llu", &tmp) != 1) { ti->error = "dm-linear: Invalid device sector"; goto bad; } lc->start = tmp; if (dm_get_device(ti, argv[0], dm_table_get_mode(ti->table), &lc->dev)) { ti->error = "dm-linear: Device lookup failed"; goto bad; } ti->num_flush_requests = 1; ti->num_discard_requests = 1; ti->private = lc; return 0; bad: kfree(lc); return -EINVAL; } static void linear_dtr(struct dm_target ti) { struct linear_c lc = (struct linear_c ) ti->private; dm_put_device(ti, lc->dev); kfree(lc); } static sector_t linear_map_sector(struct dm_target ti, sector_t bi_sector) { struct linear_c lc = ti->private; return lc->start + dm_target_offset(ti, bi_sector); } static void linear_map_bio(struct dm_target ti, struct bio bio) { struct linear_c lc = ti->private; bio->bi_bdev = lc->dev->bdev; if (bio_sectors(bio)) bio->bi_sector = linear_map_sector(ti, bio->bi_sector); } static int linear_map(struct dm_target ti, struct bio bio, union map_info map_context) { linear_map_bio(ti, bio); return DM_MAPIO_REMAPPED; } static int linear_status(struct dm_target ti, status_type_t type, char result, unsigned int maxlen) { struct linear_c lc = (struct linear_c ) ti->private; switch (type) { case STATUSTYPE_INFO: result[0] = '\0'; break; case STATUSTYPE_TABLE: snprintf(result, maxlen, "%s %llu", lc->dev->name, (unsigned long long)lc->start); break; } return 0; } static int linear_ioctl(struct dm_target ti, unsigned int cmd, unsigned long arg) { struct linear_c lc = (struct linear_c ) ti->private; struct dm_dev dev = lc->dev; int r = 0; /* * Only pass ioctls through if the device sizes match exactly. / if (lc->start \|\| ti->len != i_size_read(dev->bdev->bd_inode) >> SECTOR_SHIFT) r = scsi_verify_blk_ioctl(NULL, cmd); return r ? : __blkdev_driver_ioctl(dev->bdev, dev->mode, cmd, arg); } static int linear_merge(struct dm_target ti, struct bvec_merge_data bvm, struct bio_vec biovec, int max_size) { struct linear_c lc = ti->private; struct request_queue q = bdev_get_queue(lc->dev->bdev); if (!q->merge_bvec_fn) return max_size; bvm->bi_bdev = lc->dev->bdev; bvm->bi_sector = linear_map_sector(ti, bvm->bi_sector); return min(max_size, q->merge_bvec_fn(q, bvm, biovec)); } static int linear_iterate_devices(struct dm_target ti, iterate_devices_callout_fn fn, void data) { struct linear_c *lc = ti->private; return fn(ti, lc->dev, lc->start, ti->len, data); } static struct target_type linear_target = { .name = "linear", .version = {1, 1, 0}, .module = THIS_MODULE, .ctr = linear_ctr, .dtr = linear_dtr, .map = linear_map, .status = linear_status, .ioctl = linear_ioctl, .merge = linear_merge, .iterate_devices = linear_iterate_devices, }; int __init dm_linear_init(void) { int r = dm_register_target(&linear_target); if (r < 0) DMERR("register failed %d", r); return r; } void dm_linear_exit(void) { dm_unregister_target(&linear_target); }	./CrossVul/dataset_final_sorted/CWE-264/c/good_3526_1
crossvul-cpp_data_good_2287_4	/* * linux/fs/ext4/file.c * * Copyright (C) 1992, 1993, 1994, 1995 * Remy Card (card@masi.ibp.fr) * Laboratoire MASI - Institut Blaise Pascal * Universite Pierre et Marie Curie (Paris VI) * * from * * linux/fs/minix/file.c * * Copyright (C) 1991, 1992 Linus Torvalds * * ext4 fs regular file handling primitives * * 64-bit file support on 64-bit platforms by Jakub Jelinek * (jj@sunsite.ms.mff.cuni.cz) / #include <linux/time.h> #include <linux/fs.h> #include <linux/jbd2.h> #include <linux/mount.h> #include <linux/path.h> #include <linux/aio.h> #include <linux/quotaops.h> #include <linux/pagevec.h> #include "ext4.h" #include "ext4_jbd2.h" #include "xattr.h" #include "acl.h" / * Called when an inode is released. Note that this is different * from ext4_file_open: open gets called at every open, but release * gets called only when /all/ the files are closed. / static int ext4_release_file(struct inode inode, struct file filp) { if (ext4_test_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE)) { ext4_alloc_da_blocks(inode); ext4_clear_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE); } / if we are the last writer on the inode, drop the block reservation / if ((filp->f_mode & FMODE_WRITE) && (atomic_read(&inode->i_writecount) == 1) && !EXT4_I(inode)->i_reserved_data_blocks) { down_write(&EXT4_I(inode)->i_data_sem); ext4_discard_preallocations(inode); up_write(&EXT4_I(inode)->i_data_sem); } if (is_dx(inode) && filp->private_data) ext4_htree_free_dir_info(filp->private_data); return 0; } void ext4_unwritten_wait(struct inode inode) { wait_queue_head_t wq = ext4_ioend_wq(inode); wait_event(wq, (atomic_read(&EXT4_I(inode)->i_unwritten) == 0)); } /* * This tests whether the IO in question is block-aligned or not. * Ext4 utilizes unwritten extents when hole-filling during direct IO, and they * are converted to written only after the IO is complete. Until they are * mapped, these blocks appear as holes, so dio_zero_block() will assume that * it needs to zero out portions of the start and/or end block. If 2 AIO * threads are at work on the same unwritten block, they must be synchronized * or one thread will zero the other's data, causing corruption. / static int ext4_unaligned_aio(struct inode inode, struct iov_iter from, loff_t pos) { struct super_block sb = inode->i_sb; int blockmask = sb->s_blocksize - 1; if (pos >= i_size_read(inode)) return 0; if ((pos \| iov_iter_alignment(from)) & blockmask) return 1; return 0; } static ssize_t ext4_file_write_iter(struct kiocb iocb, struct iov_iter from) { struct file file = iocb->ki_filp; struct inode inode = file_inode(iocb->ki_filp); struct mutex aio_mutex = NULL; struct blk_plug plug; int o_direct = file->f_flags & O_DIRECT; int overwrite = 0; size_t length = iov_iter_count(from); ssize_t ret; loff_t pos = iocb->ki_pos; / * Unaligned direct AIO must be serialized; see comment above * In the case of O_APPEND, assume that we must always serialize / if (o_direct && ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS) && !is_sync_kiocb(iocb) && (file->f_flags & O_APPEND \|\| ext4_unaligned_aio(inode, from, pos))) { aio_mutex = ext4_aio_mutex(inode); mutex_lock(aio_mutex); ext4_unwritten_wait(inode); } mutex_lock(&inode->i_mutex); if (file->f_flags & O_APPEND) iocb->ki_pos = pos = i_size_read(inode); / * If we have encountered a bitmap-format file, the size limit * is smaller than s_maxbytes, which is for extent-mapped files. / if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) { struct ext4_sb_info sbi = EXT4_SB(inode->i_sb); if ((pos > sbi->s_bitmap_maxbytes) \|\| (pos == sbi->s_bitmap_maxbytes && length > 0)) { mutex_unlock(&inode->i_mutex); ret = -EFBIG; goto errout; } if (pos + length > sbi->s_bitmap_maxbytes) iov_iter_truncate(from, sbi->s_bitmap_maxbytes - pos); } if (o_direct) { blk_start_plug(&plug); iocb->private = &overwrite; /* check whether we do a DIO overwrite or not / if (ext4_should_dioread_nolock(inode) && !aio_mutex && !file->f_mapping->nrpages && pos + length <= i_size_read(inode)) { struct ext4_map_blocks map; unsigned int blkbits = inode->i_blkbits; int err, len; map.m_lblk = pos >> blkbits; map.m_len = (EXT4_BLOCK_ALIGN(pos + length, blkbits) >> blkbits) - map.m_lblk; len = map.m_len; err = ext4_map_blocks(NULL, inode, &map, 0); / * 'err==len' means that all of blocks has * been preallocated no matter they are * initialized or not. For excluding * unwritten extents, we need to check * m_flags. There are two conditions that * indicate for initialized extents. 1) If we * hit extent cache, EXT4_MAP_MAPPED flag is * returned; 2) If we do a real lookup, * non-flags are returned. So we should check * these two conditions. / if (err == len && (map.m_flags & EXT4_MAP_MAPPED)) overwrite = 1; } } ret = __generic_file_write_iter(iocb, from); mutex_unlock(&inode->i_mutex); if (ret > 0) { ssize_t err; err = generic_write_sync(file, iocb->ki_pos - ret, ret); if (err < 0) ret = err; } if (o_direct) blk_finish_plug(&plug); errout: if (aio_mutex) mutex_unlock(aio_mutex); return ret; } static const struct vm_operations_struct ext4_file_vm_ops = { .fault = filemap_fault, .map_pages = filemap_map_pages, .page_mkwrite = ext4_page_mkwrite, .remap_pages = generic_file_remap_pages, }; static int ext4_file_mmap(struct file file, struct vm_area_struct vma) { struct address_space mapping = file->f_mapping; if (!mapping->a_ops->readpage) return -ENOEXEC; file_accessed(file); vma->vm_ops = &ext4_file_vm_ops; return 0; } static int ext4_file_open(struct inode * inode, struct file * filp) { struct super_block sb = inode->i_sb; struct ext4_sb_info sbi = EXT4_SB(inode->i_sb); struct vfsmount mnt = filp->f_path.mnt; struct path path; char buf[64], cp; if (unlikely(!(sbi->s_mount_flags & EXT4_MF_MNTDIR_SAMPLED) && !(sb->s_flags & MS_RDONLY))) { sbi->s_mount_flags \|= EXT4_MF_MNTDIR_SAMPLED; /* * Sample where the filesystem has been mounted and * store it in the superblock for sysadmin convenience * when trying to sort through large numbers of block * devices or filesystem images. / memset(buf, 0, sizeof(buf)); path.mnt = mnt; path.dentry = mnt->mnt_root; cp = d_path(&path, buf, sizeof(buf)); if (!IS_ERR(cp)) { handle_t handle; int err; handle = ext4_journal_start_sb(sb, EXT4_HT_MISC, 1); if (IS_ERR(handle)) return PTR_ERR(handle); err = ext4_journal_get_write_access(handle, sbi->s_sbh); if (err) { ext4_journal_stop(handle); return err; } strlcpy(sbi->s_es->s_last_mounted, cp, sizeof(sbi->s_es->s_last_mounted)); ext4_handle_dirty_super(handle, sb); ext4_journal_stop(handle); } } /* * Set up the jbd2_inode if we are opening the inode for * writing and the journal is present / if (filp->f_mode & FMODE_WRITE) { int ret = ext4_inode_attach_jinode(inode); if (ret < 0) return ret; } return dquot_file_open(inode, filp); } / * Here we use ext4_map_blocks() to get a block mapping for a extent-based * file rather than ext4_ext_walk_space() because we can introduce * SEEK_DATA/SEEK_HOLE for block-mapped and extent-mapped file at the same * function. When extent status tree has been fully implemented, it will * track all extent status for a file and we can directly use it to * retrieve the offset for SEEK_DATA/SEEK_HOLE. / / * When we retrieve the offset for SEEK_DATA/SEEK_HOLE, we would need to * lookup page cache to check whether or not there has some data between * [startoff, endoff] because, if this range contains an unwritten extent, * we determine this extent as a data or a hole according to whether the * page cache has data or not. / static int ext4_find_unwritten_pgoff(struct inode inode, int whence, struct ext4_map_blocks map, loff_t offset) { struct pagevec pvec; unsigned int blkbits; pgoff_t index; pgoff_t end; loff_t endoff; loff_t startoff; loff_t lastoff; int found = 0; blkbits = inode->i_sb->s_blocksize_bits; startoff = offset; lastoff = startoff; endoff = (loff_t)(map->m_lblk + map->m_len) << blkbits; index = startoff >> PAGE_CACHE_SHIFT; end = endoff >> PAGE_CACHE_SHIFT; pagevec_init(&pvec, 0); do { int i, num; unsigned long nr_pages; num = min_t(pgoff_t, end - index, PAGEVEC_SIZE); nr_pages = pagevec_lookup(&pvec, inode->i_mapping, index, (pgoff_t)num); if (nr_pages == 0) { if (whence == SEEK_DATA) break; BUG_ON(whence != SEEK_HOLE); / * If this is the first time to go into the loop and * offset is not beyond the end offset, it will be a * hole at this offset / if (lastoff == startoff \|\| lastoff < endoff) found = 1; break; } / * If this is the first time to go into the loop and * offset is smaller than the first page offset, it will be a * hole at this offset. / if (lastoff == startoff && whence == SEEK_HOLE && lastoff < page_offset(pvec.pages[0])) { found = 1; break; } for (i = 0; i < nr_pages; i++) { struct page page = pvec.pages[i]; struct buffer_head bh, head; /* * If the current offset is not beyond the end of given * range, it will be a hole. / if (lastoff < endoff && whence == SEEK_HOLE && page->index > end) { found = 1; offset = lastoff; goto out; } lock_page(page); if (unlikely(page->mapping != inode->i_mapping)) { unlock_page(page); continue; } if (!page_has_buffers(page)) { unlock_page(page); continue; } if (page_has_buffers(page)) { lastoff = page_offset(page); bh = head = page_buffers(page); do { if (buffer_uptodate(bh) \|\| buffer_unwritten(bh)) { if (whence == SEEK_DATA) found = 1; } else { if (whence == SEEK_HOLE) found = 1; } if (found) { offset = max_t(loff_t, startoff, lastoff); unlock_page(page); goto out; } lastoff += bh->b_size; bh = bh->b_this_page; } while (bh != head); } lastoff = page_offset(page) + PAGE_SIZE; unlock_page(page); } / * The no. of pages is less than our desired, that would be a * hole in there. / if (nr_pages < num && whence == SEEK_HOLE) { found = 1; offset = lastoff; break; } index = pvec.pages[i - 1]->index + 1; pagevec_release(&pvec); } while (index <= end); out: pagevec_release(&pvec); return found; } /* * ext4_seek_data() retrieves the offset for SEEK_DATA. / static loff_t ext4_seek_data(struct file file, loff_t offset, loff_t maxsize) { struct inode inode = file->f_mapping->host; struct ext4_map_blocks map; struct extent_status es; ext4_lblk_t start, last, end; loff_t dataoff, isize; int blkbits; int ret = 0; mutex_lock(&inode->i_mutex); isize = i_size_read(inode); if (offset >= isize) { mutex_unlock(&inode->i_mutex); return -ENXIO; } blkbits = inode->i_sb->s_blocksize_bits; start = offset >> blkbits; last = start; end = isize >> blkbits; dataoff = offset; do { map.m_lblk = last; map.m_len = end - last + 1; ret = ext4_map_blocks(NULL, inode, &map, 0); if (ret > 0 && !(map.m_flags & EXT4_MAP_UNWRITTEN)) { if (last != start) dataoff = (loff_t)last << blkbits; break; } / * If there is a delay extent at this offset, * it will be as a data. / ext4_es_find_delayed_extent_range(inode, last, last, &es); if (es.es_len != 0 && in_range(last, es.es_lblk, es.es_len)) { if (last != start) dataoff = (loff_t)last << blkbits; break; } / * If there is a unwritten extent at this offset, * it will be as a data or a hole according to page * cache that has data or not. / if (map.m_flags & EXT4_MAP_UNWRITTEN) { int unwritten; unwritten = ext4_find_unwritten_pgoff(inode, SEEK_DATA, &map, &dataoff); if (unwritten) break; } last++; dataoff = (loff_t)last << blkbits; } while (last <= end); mutex_unlock(&inode->i_mutex); if (dataoff > isize) return -ENXIO; return vfs_setpos(file, dataoff, maxsize); } / * ext4_seek_hole() retrieves the offset for SEEK_HOLE. / static loff_t ext4_seek_hole(struct file file, loff_t offset, loff_t maxsize) { struct inode inode = file->f_mapping->host; struct ext4_map_blocks map; struct extent_status es; ext4_lblk_t start, last, end; loff_t holeoff, isize; int blkbits; int ret = 0; mutex_lock(&inode->i_mutex); isize = i_size_read(inode); if (offset >= isize) { mutex_unlock(&inode->i_mutex); return -ENXIO; } blkbits = inode->i_sb->s_blocksize_bits; start = offset >> blkbits; last = start; end = isize >> blkbits; holeoff = offset; do { map.m_lblk = last; map.m_len = end - last + 1; ret = ext4_map_blocks(NULL, inode, &map, 0); if (ret > 0 && !(map.m_flags & EXT4_MAP_UNWRITTEN)) { last += ret; holeoff = (loff_t)last << blkbits; continue; } / * If there is a delay extent at this offset, * we will skip this extent. / ext4_es_find_delayed_extent_range(inode, last, last, &es); if (es.es_len != 0 && in_range(last, es.es_lblk, es.es_len)) { last = es.es_lblk + es.es_len; holeoff = (loff_t)last << blkbits; continue; } / * If there is a unwritten extent at this offset, * it will be as a data or a hole according to page * cache that has data or not. / if (map.m_flags & EXT4_MAP_UNWRITTEN) { int unwritten; unwritten = ext4_find_unwritten_pgoff(inode, SEEK_HOLE, &map, &holeoff); if (!unwritten) { last += ret; holeoff = (loff_t)last << blkbits; continue; } } / find a hole / break; } while (last <= end); mutex_unlock(&inode->i_mutex); if (holeoff > isize) holeoff = isize; return vfs_setpos(file, holeoff, maxsize); } / * ext4_llseek() handles both block-mapped and extent-mapped maxbytes values * by calling generic_file_llseek_size() with the appropriate maxbytes * value for each. / loff_t ext4_llseek(struct file file, loff_t offset, int whence) { struct inode *inode = file->f_mapping->host; loff_t maxbytes; if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) maxbytes = EXT4_SB(inode->i_sb)->s_bitmap_maxbytes; else maxbytes = inode->i_sb->s_maxbytes; switch (whence) { case SEEK_SET: case SEEK_CUR: case SEEK_END: return generic_file_llseek_size(file, offset, whence, maxbytes, i_size_read(inode)); case SEEK_DATA: return ext4_seek_data(file, offset, maxbytes); case SEEK_HOLE: return ext4_seek_hole(file, offset, maxbytes); } return -EINVAL; } const struct file_operations ext4_file_operations = { .llseek = ext4_llseek, .read = new_sync_read, .write = new_sync_write, .read_iter = generic_file_read_iter, .write_iter = ext4_file_write_iter, .unlocked_ioctl = ext4_ioctl, #ifdef CONFIG_COMPAT .compat_ioctl = ext4_compat_ioctl, #endif .mmap = ext4_file_mmap, .open = ext4_file_open, .release = ext4_release_file, .fsync = ext4_sync_file, .splice_read = generic_file_splice_read, .splice_write = iter_file_splice_write, .fallocate = ext4_fallocate, }; const struct inode_operations ext4_file_inode_operations = { .setattr = ext4_setattr, .getattr = ext4_getattr, .setxattr = generic_setxattr, .getxattr = generic_getxattr, .listxattr = ext4_listxattr, .removexattr = generic_removexattr, .get_acl = ext4_get_acl, .set_acl = ext4_set_acl, .fiemap = ext4_fiemap, };	./CrossVul/dataset_final_sorted/CWE-264/c/good_2287_4
crossvul-cpp_data_bad_2399_8	/* * Software async crypto daemon. * * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au> * * Added AEAD support to cryptd. * Authors: Tadeusz Struk (tadeusz.struk@intel.com) * Adrian Hoban <adrian.hoban@intel.com> * Gabriele Paoloni <gabriele.paoloni@intel.com> * Aidan O'Mahony (aidan.o.mahony@intel.com) * Copyright (c) 2010, Intel Corporation. * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the Free * Software Foundation; either version 2 of the License, or (at your option) * any later version. * / #include <crypto/algapi.h> #include <crypto/internal/hash.h> #include <crypto/internal/aead.h> #include <crypto/cryptd.h> #include <crypto/crypto_wq.h> #include <linux/err.h> #include <linux/init.h> #include <linux/kernel.h> #include <linux/list.h> #include <linux/module.h> #include <linux/scatterlist.h> #include <linux/sched.h> #include <linux/slab.h> #define CRYPTD_MAX_CPU_QLEN 100 struct cryptd_cpu_queue { struct crypto_queue queue; struct work_struct work; }; struct cryptd_queue { struct cryptd_cpu_queue __percpu cpu_queue; }; struct cryptd_instance_ctx { struct crypto_spawn spawn; struct cryptd_queue queue; }; struct hashd_instance_ctx { struct crypto_shash_spawn spawn; struct cryptd_queue queue; }; struct aead_instance_ctx { struct crypto_aead_spawn aead_spawn; struct cryptd_queue queue; }; struct cryptd_blkcipher_ctx { struct crypto_blkcipher child; }; struct cryptd_blkcipher_request_ctx { crypto_completion_t complete; }; struct cryptd_hash_ctx { struct crypto_shash child; }; struct cryptd_hash_request_ctx { crypto_completion_t complete; struct shash_desc desc; }; struct cryptd_aead_ctx { struct crypto_aead child; }; struct cryptd_aead_request_ctx { crypto_completion_t complete; }; static void cryptd_queue_worker(struct work_struct work); static int cryptd_init_queue(struct cryptd_queue queue, unsigned int max_cpu_qlen) { int cpu; struct cryptd_cpu_queue cpu_queue; queue->cpu_queue = alloc_percpu(struct cryptd_cpu_queue); if (!queue->cpu_queue) return -ENOMEM; for_each_possible_cpu(cpu) { cpu_queue = per_cpu_ptr(queue->cpu_queue, cpu); crypto_init_queue(&cpu_queue->queue, max_cpu_qlen); INIT_WORK(&cpu_queue->work, cryptd_queue_worker); } return 0; } static void cryptd_fini_queue(struct cryptd_queue queue) { int cpu; struct cryptd_cpu_queue cpu_queue; for_each_possible_cpu(cpu) { cpu_queue = per_cpu_ptr(queue->cpu_queue, cpu); BUG_ON(cpu_queue->queue.qlen); } free_percpu(queue->cpu_queue); } static int cryptd_enqueue_request(struct cryptd_queue queue, struct crypto_async_request request) { int cpu, err; struct cryptd_cpu_queue cpu_queue; cpu = get_cpu(); cpu_queue = this_cpu_ptr(queue->cpu_queue); err = crypto_enqueue_request(&cpu_queue->queue, request); queue_work_on(cpu, kcrypto_wq, &cpu_queue->work); put_cpu(); return err; } /* Called in workqueue context, do one real cryption work (via * req->complete) and reschedule itself if there are more work to * do. / static void cryptd_queue_worker(struct work_struct work) { struct cryptd_cpu_queue cpu_queue; struct crypto_async_request req, backlog; cpu_queue = container_of(work, struct cryptd_cpu_queue, work); / * Only handle one request at a time to avoid hogging crypto workqueue. * preempt_disable/enable is used to prevent being preempted by * cryptd_enqueue_request(). local_bh_disable/enable is used to prevent * cryptd_enqueue_request() being accessed from software interrupts. / local_bh_disable(); preempt_disable(); backlog = crypto_get_backlog(&cpu_queue->queue); req = crypto_dequeue_request(&cpu_queue->queue); preempt_enable(); local_bh_enable(); if (!req) return; if (backlog) backlog->complete(backlog, -EINPROGRESS); req->complete(req, 0); if (cpu_queue->queue.qlen) queue_work(kcrypto_wq, &cpu_queue->work); } static inline struct cryptd_queue cryptd_get_queue(struct crypto_tfm tfm) { struct crypto_instance inst = crypto_tfm_alg_instance(tfm); struct cryptd_instance_ctx ictx = crypto_instance_ctx(inst); return ictx->queue; } static int cryptd_blkcipher_setkey(struct crypto_ablkcipher parent, const u8 key, unsigned int keylen) { struct cryptd_blkcipher_ctx ctx = crypto_ablkcipher_ctx(parent); struct crypto_blkcipher child = ctx->child; int err; crypto_blkcipher_clear_flags(child, CRYPTO_TFM_REQ_MASK); crypto_blkcipher_set_flags(child, crypto_ablkcipher_get_flags(parent) & CRYPTO_TFM_REQ_MASK); err = crypto_blkcipher_setkey(child, key, keylen); crypto_ablkcipher_set_flags(parent, crypto_blkcipher_get_flags(child) & CRYPTO_TFM_RES_MASK); return err; } static void cryptd_blkcipher_crypt(struct ablkcipher_request req, struct crypto_blkcipher child, int err, int (crypt)(struct blkcipher_desc desc, struct scatterlist dst, struct scatterlist src, unsigned int len)) { struct cryptd_blkcipher_request_ctx rctx; struct blkcipher_desc desc; rctx = ablkcipher_request_ctx(req); if (unlikely(err == -EINPROGRESS)) goto out; desc.tfm = child; desc.info = req->info; desc.flags = CRYPTO_TFM_REQ_MAY_SLEEP; err = crypt(&desc, req->dst, req->src, req->nbytes); req->base.complete = rctx->complete; out: local_bh_disable(); rctx->complete(&req->base, err); local_bh_enable(); } static void cryptd_blkcipher_encrypt(struct crypto_async_request req, int err) { struct cryptd_blkcipher_ctx ctx = crypto_tfm_ctx(req->tfm); struct crypto_blkcipher child = ctx->child; cryptd_blkcipher_crypt(ablkcipher_request_cast(req), child, err, crypto_blkcipher_crt(child)->encrypt); } static void cryptd_blkcipher_decrypt(struct crypto_async_request req, int err) { struct cryptd_blkcipher_ctx ctx = crypto_tfm_ctx(req->tfm); struct crypto_blkcipher child = ctx->child; cryptd_blkcipher_crypt(ablkcipher_request_cast(req), child, err, crypto_blkcipher_crt(child)->decrypt); } static int cryptd_blkcipher_enqueue(struct ablkcipher_request req, crypto_completion_t compl) { struct cryptd_blkcipher_request_ctx rctx = ablkcipher_request_ctx(req); struct crypto_ablkcipher tfm = crypto_ablkcipher_reqtfm(req); struct cryptd_queue queue; queue = cryptd_get_queue(crypto_ablkcipher_tfm(tfm)); rctx->complete = req->base.complete; req->base.complete = compl; return cryptd_enqueue_request(queue, &req->base); } static int cryptd_blkcipher_encrypt_enqueue(struct ablkcipher_request req) { return cryptd_blkcipher_enqueue(req, cryptd_blkcipher_encrypt); } static int cryptd_blkcipher_decrypt_enqueue(struct ablkcipher_request req) { return cryptd_blkcipher_enqueue(req, cryptd_blkcipher_decrypt); } static int cryptd_blkcipher_init_tfm(struct crypto_tfm tfm) { struct crypto_instance inst = crypto_tfm_alg_instance(tfm); struct cryptd_instance_ctx ictx = crypto_instance_ctx(inst); struct crypto_spawn spawn = &ictx->spawn; struct cryptd_blkcipher_ctx ctx = crypto_tfm_ctx(tfm); struct crypto_blkcipher cipher; cipher = crypto_spawn_blkcipher(spawn); if (IS_ERR(cipher)) return PTR_ERR(cipher); ctx->child = cipher; tfm->crt_ablkcipher.reqsize = sizeof(struct cryptd_blkcipher_request_ctx); return 0; } static void cryptd_blkcipher_exit_tfm(struct crypto_tfm tfm) { struct cryptd_blkcipher_ctx ctx = crypto_tfm_ctx(tfm); crypto_free_blkcipher(ctx->child); } static void cryptd_alloc_instance(struct crypto_alg alg, unsigned int head, unsigned int tail) { char p; struct crypto_instance inst; int err; p = kzalloc(head + sizeof(inst) + tail, GFP_KERNEL); if (!p) return ERR_PTR(-ENOMEM); inst = (void )(p + head); err = -ENAMETOOLONG; if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, "cryptd(%s)", alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME) goto out_free_inst; memcpy(inst->alg.cra_name, alg->cra_name, CRYPTO_MAX_ALG_NAME); inst->alg.cra_priority = alg->cra_priority + 50; inst->alg.cra_blocksize = alg->cra_blocksize; inst->alg.cra_alignmask = alg->cra_alignmask; out: return p; out_free_inst: kfree(p); p = ERR_PTR(err); goto out; } static int cryptd_create_blkcipher(struct crypto_template tmpl, struct rtattr tb, struct cryptd_queue queue) { struct cryptd_instance_ctx ctx; struct crypto_instance inst; struct crypto_alg alg; int err; alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_BLKCIPHER, CRYPTO_ALG_TYPE_MASK); if (IS_ERR(alg)) return PTR_ERR(alg); inst = cryptd_alloc_instance(alg, 0, sizeof(ctx)); err = PTR_ERR(inst); if (IS_ERR(inst)) goto out_put_alg; ctx = crypto_instance_ctx(inst); ctx->queue = queue; err = crypto_init_spawn(&ctx->spawn, alg, inst, CRYPTO_ALG_TYPE_MASK \| CRYPTO_ALG_ASYNC); if (err) goto out_free_inst; inst->alg.cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \| CRYPTO_ALG_ASYNC; inst->alg.cra_type = &crypto_ablkcipher_type; inst->alg.cra_ablkcipher.ivsize = alg->cra_blkcipher.ivsize; inst->alg.cra_ablkcipher.min_keysize = alg->cra_blkcipher.min_keysize; inst->alg.cra_ablkcipher.max_keysize = alg->cra_blkcipher.max_keysize; inst->alg.cra_ablkcipher.geniv = alg->cra_blkcipher.geniv; inst->alg.cra_ctxsize = sizeof(struct cryptd_blkcipher_ctx); inst->alg.cra_init = cryptd_blkcipher_init_tfm; inst->alg.cra_exit = cryptd_blkcipher_exit_tfm; inst->alg.cra_ablkcipher.setkey = cryptd_blkcipher_setkey; inst->alg.cra_ablkcipher.encrypt = cryptd_blkcipher_encrypt_enqueue; inst->alg.cra_ablkcipher.decrypt = cryptd_blkcipher_decrypt_enqueue; err = crypto_register_instance(tmpl, inst); if (err) { crypto_drop_spawn(&ctx->spawn); out_free_inst: kfree(inst); } out_put_alg: crypto_mod_put(alg); return err; } static int cryptd_hash_init_tfm(struct crypto_tfm tfm) { struct crypto_instance inst = crypto_tfm_alg_instance(tfm); struct hashd_instance_ctx ictx = crypto_instance_ctx(inst); struct crypto_shash_spawn spawn = &ictx->spawn; struct cryptd_hash_ctx ctx = crypto_tfm_ctx(tfm); struct crypto_shash hash; hash = crypto_spawn_shash(spawn); if (IS_ERR(hash)) return PTR_ERR(hash); ctx->child = hash; crypto_ahash_set_reqsize(__crypto_ahash_cast(tfm), sizeof(struct cryptd_hash_request_ctx) + crypto_shash_descsize(hash)); return 0; } static void cryptd_hash_exit_tfm(struct crypto_tfm tfm) { struct cryptd_hash_ctx ctx = crypto_tfm_ctx(tfm); crypto_free_shash(ctx->child); } static int cryptd_hash_setkey(struct crypto_ahash parent, const u8 key, unsigned int keylen) { struct cryptd_hash_ctx ctx = crypto_ahash_ctx(parent); struct crypto_shash child = ctx->child; int err; crypto_shash_clear_flags(child, CRYPTO_TFM_REQ_MASK); crypto_shash_set_flags(child, crypto_ahash_get_flags(parent) & CRYPTO_TFM_REQ_MASK); err = crypto_shash_setkey(child, key, keylen); crypto_ahash_set_flags(parent, crypto_shash_get_flags(child) & CRYPTO_TFM_RES_MASK); return err; } static int cryptd_hash_enqueue(struct ahash_request req, crypto_completion_t compl) { struct cryptd_hash_request_ctx rctx = ahash_request_ctx(req); struct crypto_ahash tfm = crypto_ahash_reqtfm(req); struct cryptd_queue queue = cryptd_get_queue(crypto_ahash_tfm(tfm)); rctx->complete = req->base.complete; req->base.complete = compl; return cryptd_enqueue_request(queue, &req->base); } static void cryptd_hash_init(struct crypto_async_request req_async, int err) { struct cryptd_hash_ctx ctx = crypto_tfm_ctx(req_async->tfm); struct crypto_shash child = ctx->child; struct ahash_request req = ahash_request_cast(req_async); struct cryptd_hash_request_ctx rctx = ahash_request_ctx(req); struct shash_desc desc = &rctx->desc; if (unlikely(err == -EINPROGRESS)) goto out; desc->tfm = child; desc->flags = CRYPTO_TFM_REQ_MAY_SLEEP; err = crypto_shash_init(desc); req->base.complete = rctx->complete; out: local_bh_disable(); rctx->complete(&req->base, err); local_bh_enable(); } static int cryptd_hash_init_enqueue(struct ahash_request req) { return cryptd_hash_enqueue(req, cryptd_hash_init); } static void cryptd_hash_update(struct crypto_async_request req_async, int err) { struct ahash_request req = ahash_request_cast(req_async); struct cryptd_hash_request_ctx rctx; rctx = ahash_request_ctx(req); if (unlikely(err == -EINPROGRESS)) goto out; err = shash_ahash_update(req, &rctx->desc); req->base.complete = rctx->complete; out: local_bh_disable(); rctx->complete(&req->base, err); local_bh_enable(); } static int cryptd_hash_update_enqueue(struct ahash_request req) { return cryptd_hash_enqueue(req, cryptd_hash_update); } static void cryptd_hash_final(struct crypto_async_request req_async, int err) { struct ahash_request req = ahash_request_cast(req_async); struct cryptd_hash_request_ctx rctx = ahash_request_ctx(req); if (unlikely(err == -EINPROGRESS)) goto out; err = crypto_shash_final(&rctx->desc, req->result); req->base.complete = rctx->complete; out: local_bh_disable(); rctx->complete(&req->base, err); local_bh_enable(); } static int cryptd_hash_final_enqueue(struct ahash_request req) { return cryptd_hash_enqueue(req, cryptd_hash_final); } static void cryptd_hash_finup(struct crypto_async_request req_async, int err) { struct ahash_request req = ahash_request_cast(req_async); struct cryptd_hash_request_ctx rctx = ahash_request_ctx(req); if (unlikely(err == -EINPROGRESS)) goto out; err = shash_ahash_finup(req, &rctx->desc); req->base.complete = rctx->complete; out: local_bh_disable(); rctx->complete(&req->base, err); local_bh_enable(); } static int cryptd_hash_finup_enqueue(struct ahash_request req) { return cryptd_hash_enqueue(req, cryptd_hash_finup); } static void cryptd_hash_digest(struct crypto_async_request req_async, int err) { struct cryptd_hash_ctx ctx = crypto_tfm_ctx(req_async->tfm); struct crypto_shash child = ctx->child; struct ahash_request req = ahash_request_cast(req_async); struct cryptd_hash_request_ctx rctx = ahash_request_ctx(req); struct shash_desc desc = &rctx->desc; if (unlikely(err == -EINPROGRESS)) goto out; desc->tfm = child; desc->flags = CRYPTO_TFM_REQ_MAY_SLEEP; err = shash_ahash_digest(req, desc); req->base.complete = rctx->complete; out: local_bh_disable(); rctx->complete(&req->base, err); local_bh_enable(); } static int cryptd_hash_digest_enqueue(struct ahash_request req) { return cryptd_hash_enqueue(req, cryptd_hash_digest); } static int cryptd_hash_export(struct ahash_request req, void out) { struct cryptd_hash_request_ctx rctx = ahash_request_ctx(req); return crypto_shash_export(&rctx->desc, out); } static int cryptd_hash_import(struct ahash_request req, const void in) { struct cryptd_hash_request_ctx rctx = ahash_request_ctx(req); return crypto_shash_import(&rctx->desc, in); } static int cryptd_create_hash(struct crypto_template tmpl, struct rtattr tb, struct cryptd_queue queue) { struct hashd_instance_ctx ctx; struct ahash_instance inst; struct shash_alg salg; struct crypto_alg alg; int err; salg = shash_attr_alg(tb[1], 0, 0); if (IS_ERR(salg)) return PTR_ERR(salg); alg = &salg->base; inst = cryptd_alloc_instance(alg, ahash_instance_headroom(), sizeof(ctx)); err = PTR_ERR(inst); if (IS_ERR(inst)) goto out_put_alg; ctx = ahash_instance_ctx(inst); ctx->queue = queue; err = crypto_init_shash_spawn(&ctx->spawn, salg, ahash_crypto_instance(inst)); if (err) goto out_free_inst; inst->alg.halg.base.cra_flags = CRYPTO_ALG_ASYNC; inst->alg.halg.digestsize = salg->digestsize; inst->alg.halg.base.cra_ctxsize = sizeof(struct cryptd_hash_ctx); inst->alg.halg.base.cra_init = cryptd_hash_init_tfm; inst->alg.halg.base.cra_exit = cryptd_hash_exit_tfm; inst->alg.init = cryptd_hash_init_enqueue; inst->alg.update = cryptd_hash_update_enqueue; inst->alg.final = cryptd_hash_final_enqueue; inst->alg.finup = cryptd_hash_finup_enqueue; inst->alg.export = cryptd_hash_export; inst->alg.import = cryptd_hash_import; inst->alg.setkey = cryptd_hash_setkey; inst->alg.digest = cryptd_hash_digest_enqueue; err = ahash_register_instance(tmpl, inst); if (err) { crypto_drop_shash(&ctx->spawn); out_free_inst: kfree(inst); } out_put_alg: crypto_mod_put(alg); return err; } static void cryptd_aead_crypt(struct aead_request req, struct crypto_aead child, int err, int (crypt)(struct aead_request req)) { struct cryptd_aead_request_ctx rctx; rctx = aead_request_ctx(req); if (unlikely(err == -EINPROGRESS)) goto out; aead_request_set_tfm(req, child); err = crypt( req ); req->base.complete = rctx->complete; out: local_bh_disable(); rctx->complete(&req->base, err); local_bh_enable(); } static void cryptd_aead_encrypt(struct crypto_async_request areq, int err) { struct cryptd_aead_ctx ctx = crypto_tfm_ctx(areq->tfm); struct crypto_aead child = ctx->child; struct aead_request req; req = container_of(areq, struct aead_request, base); cryptd_aead_crypt(req, child, err, crypto_aead_crt(child)->encrypt); } static void cryptd_aead_decrypt(struct crypto_async_request areq, int err) { struct cryptd_aead_ctx ctx = crypto_tfm_ctx(areq->tfm); struct crypto_aead child = ctx->child; struct aead_request req; req = container_of(areq, struct aead_request, base); cryptd_aead_crypt(req, child, err, crypto_aead_crt(child)->decrypt); } static int cryptd_aead_enqueue(struct aead_request req, crypto_completion_t compl) { struct cryptd_aead_request_ctx rctx = aead_request_ctx(req); struct crypto_aead tfm = crypto_aead_reqtfm(req); struct cryptd_queue queue = cryptd_get_queue(crypto_aead_tfm(tfm)); rctx->complete = req->base.complete; req->base.complete = compl; return cryptd_enqueue_request(queue, &req->base); } static int cryptd_aead_encrypt_enqueue(struct aead_request req) { return cryptd_aead_enqueue(req, cryptd_aead_encrypt ); } static int cryptd_aead_decrypt_enqueue(struct aead_request req) { return cryptd_aead_enqueue(req, cryptd_aead_decrypt ); } static int cryptd_aead_init_tfm(struct crypto_tfm tfm) { struct crypto_instance inst = crypto_tfm_alg_instance(tfm); struct aead_instance_ctx ictx = crypto_instance_ctx(inst); struct crypto_aead_spawn spawn = &ictx->aead_spawn; struct cryptd_aead_ctx ctx = crypto_tfm_ctx(tfm); struct crypto_aead cipher; cipher = crypto_spawn_aead(spawn); if (IS_ERR(cipher)) return PTR_ERR(cipher); crypto_aead_set_flags(cipher, CRYPTO_TFM_REQ_MAY_SLEEP); ctx->child = cipher; tfm->crt_aead.reqsize = sizeof(struct cryptd_aead_request_ctx); return 0; } static void cryptd_aead_exit_tfm(struct crypto_tfm tfm) { struct cryptd_aead_ctx ctx = crypto_tfm_ctx(tfm); crypto_free_aead(ctx->child); } static int cryptd_create_aead(struct crypto_template tmpl, struct rtattr tb, struct cryptd_queue queue) { struct aead_instance_ctx ctx; struct crypto_instance inst; struct crypto_alg alg; int err; alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_AEAD, CRYPTO_ALG_TYPE_MASK); if (IS_ERR(alg)) return PTR_ERR(alg); inst = cryptd_alloc_instance(alg, 0, sizeof(ctx)); err = PTR_ERR(inst); if (IS_ERR(inst)) goto out_put_alg; ctx = crypto_instance_ctx(inst); ctx->queue = queue; err = crypto_init_spawn(&ctx->aead_spawn.base, alg, inst, CRYPTO_ALG_TYPE_MASK \| CRYPTO_ALG_ASYNC); if (err) goto out_free_inst; inst->alg.cra_flags = CRYPTO_ALG_TYPE_AEAD \| CRYPTO_ALG_ASYNC; inst->alg.cra_type = alg->cra_type; inst->alg.cra_ctxsize = sizeof(struct cryptd_aead_ctx); inst->alg.cra_init = cryptd_aead_init_tfm; inst->alg.cra_exit = cryptd_aead_exit_tfm; inst->alg.cra_aead.setkey = alg->cra_aead.setkey; inst->alg.cra_aead.setauthsize = alg->cra_aead.setauthsize; inst->alg.cra_aead.geniv = alg->cra_aead.geniv; inst->alg.cra_aead.ivsize = alg->cra_aead.ivsize; inst->alg.cra_aead.maxauthsize = alg->cra_aead.maxauthsize; inst->alg.cra_aead.encrypt = cryptd_aead_encrypt_enqueue; inst->alg.cra_aead.decrypt = cryptd_aead_decrypt_enqueue; inst->alg.cra_aead.givencrypt = alg->cra_aead.givencrypt; inst->alg.cra_aead.givdecrypt = alg->cra_aead.givdecrypt; err = crypto_register_instance(tmpl, inst); if (err) { crypto_drop_spawn(&ctx->aead_spawn.base); out_free_inst: kfree(inst); } out_put_alg: crypto_mod_put(alg); return err; } static struct cryptd_queue queue; static int cryptd_create(struct crypto_template tmpl, struct rtattr tb) { struct crypto_attr_type algt; algt = crypto_get_attr_type(tb); if (IS_ERR(algt)) return PTR_ERR(algt); switch (algt->type & algt->mask & CRYPTO_ALG_TYPE_MASK) { case CRYPTO_ALG_TYPE_BLKCIPHER: return cryptd_create_blkcipher(tmpl, tb, &queue); case CRYPTO_ALG_TYPE_DIGEST: return cryptd_create_hash(tmpl, tb, &queue); case CRYPTO_ALG_TYPE_AEAD: return cryptd_create_aead(tmpl, tb, &queue); } return -EINVAL; } static void cryptd_free(struct crypto_instance inst) { struct cryptd_instance_ctx ctx = crypto_instance_ctx(inst); struct hashd_instance_ctx hctx = crypto_instance_ctx(inst); struct aead_instance_ctx aead_ctx = crypto_instance_ctx(inst); switch (inst->alg.cra_flags & CRYPTO_ALG_TYPE_MASK) { case CRYPTO_ALG_TYPE_AHASH: crypto_drop_shash(&hctx->spawn); kfree(ahash_instance(inst)); return; case CRYPTO_ALG_TYPE_AEAD: crypto_drop_spawn(&aead_ctx->aead_spawn.base); kfree(inst); return; default: crypto_drop_spawn(&ctx->spawn); kfree(inst); } } static struct crypto_template cryptd_tmpl = { .name = "cryptd", .create = cryptd_create, .free = cryptd_free, .module = THIS_MODULE, }; struct cryptd_ablkcipher cryptd_alloc_ablkcipher(const char alg_name, u32 type, u32 mask) { char cryptd_alg_name[CRYPTO_MAX_ALG_NAME]; struct crypto_tfm tfm; if (snprintf(cryptd_alg_name, CRYPTO_MAX_ALG_NAME, "cryptd(%s)", alg_name) >= CRYPTO_MAX_ALG_NAME) return ERR_PTR(-EINVAL); type &= ~(CRYPTO_ALG_TYPE_MASK \| CRYPTO_ALG_GENIV); type \|= CRYPTO_ALG_TYPE_BLKCIPHER; mask &= ~CRYPTO_ALG_TYPE_MASK; mask \|= (CRYPTO_ALG_GENIV \| CRYPTO_ALG_TYPE_BLKCIPHER_MASK); tfm = crypto_alloc_base(cryptd_alg_name, type, mask); if (IS_ERR(tfm)) return ERR_CAST(tfm); if (tfm->__crt_alg->cra_module != THIS_MODULE) { crypto_free_tfm(tfm); return ERR_PTR(-EINVAL); } return __cryptd_ablkcipher_cast(__crypto_ablkcipher_cast(tfm)); } EXPORT_SYMBOL_GPL(cryptd_alloc_ablkcipher); struct crypto_blkcipher cryptd_ablkcipher_child(struct cryptd_ablkcipher tfm) { struct cryptd_blkcipher_ctx ctx = crypto_ablkcipher_ctx(&tfm->base); return ctx->child; } EXPORT_SYMBOL_GPL(cryptd_ablkcipher_child); void cryptd_free_ablkcipher(struct cryptd_ablkcipher tfm) { crypto_free_ablkcipher(&tfm->base); } EXPORT_SYMBOL_GPL(cryptd_free_ablkcipher); struct cryptd_ahash cryptd_alloc_ahash(const char alg_name, u32 type, u32 mask) { char cryptd_alg_name[CRYPTO_MAX_ALG_NAME]; struct crypto_ahash tfm; if (snprintf(cryptd_alg_name, CRYPTO_MAX_ALG_NAME, "cryptd(%s)", alg_name) >= CRYPTO_MAX_ALG_NAME) return ERR_PTR(-EINVAL); tfm = crypto_alloc_ahash(cryptd_alg_name, type, mask); if (IS_ERR(tfm)) return ERR_CAST(tfm); if (tfm->base.__crt_alg->cra_module != THIS_MODULE) { crypto_free_ahash(tfm); return ERR_PTR(-EINVAL); } return __cryptd_ahash_cast(tfm); } EXPORT_SYMBOL_GPL(cryptd_alloc_ahash); struct crypto_shash cryptd_ahash_child(struct cryptd_ahash tfm) { struct cryptd_hash_ctx ctx = crypto_ahash_ctx(&tfm->base); return ctx->child; } EXPORT_SYMBOL_GPL(cryptd_ahash_child); struct shash_desc cryptd_shash_desc(struct ahash_request req) { struct cryptd_hash_request_ctx rctx = ahash_request_ctx(req); return &rctx->desc; } EXPORT_SYMBOL_GPL(cryptd_shash_desc); void cryptd_free_ahash(struct cryptd_ahash tfm) { crypto_free_ahash(&tfm->base); } EXPORT_SYMBOL_GPL(cryptd_free_ahash); struct cryptd_aead cryptd_alloc_aead(const char alg_name, u32 type, u32 mask) { char cryptd_alg_name[CRYPTO_MAX_ALG_NAME]; struct crypto_aead tfm; if (snprintf(cryptd_alg_name, CRYPTO_MAX_ALG_NAME, "cryptd(%s)", alg_name) >= CRYPTO_MAX_ALG_NAME) return ERR_PTR(-EINVAL); tfm = crypto_alloc_aead(cryptd_alg_name, type, mask); if (IS_ERR(tfm)) return ERR_CAST(tfm); if (tfm->base.__crt_alg->cra_module != THIS_MODULE) { crypto_free_aead(tfm); return ERR_PTR(-EINVAL); } return __cryptd_aead_cast(tfm); } EXPORT_SYMBOL_GPL(cryptd_alloc_aead); struct crypto_aead cryptd_aead_child(struct cryptd_aead tfm) { struct cryptd_aead_ctx ctx; ctx = crypto_aead_ctx(&tfm->base); return ctx->child; } EXPORT_SYMBOL_GPL(cryptd_aead_child); void cryptd_free_aead(struct cryptd_aead tfm) { crypto_free_aead(&tfm->base); } EXPORT_SYMBOL_GPL(cryptd_free_aead); static int __init cryptd_init(void) { int err; err = cryptd_init_queue(&queue, CRYPTD_MAX_CPU_QLEN); if (err) return err; err = crypto_register_template(&cryptd_tmpl); if (err) cryptd_fini_queue(&queue); return err; } static void __exit cryptd_exit(void) { cryptd_fini_queue(&queue); crypto_unregister_template(&cryptd_tmpl); } subsys_initcall(cryptd_init); module_exit(cryptd_exit); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("Software async crypto daemon");	./CrossVul/dataset_final_sorted/CWE-264/c/bad_2399_8
crossvul-cpp_data_good_5801_0	/* * Adaptec AAC series RAID controller driver * (c) Copyright 2001 Red Hat Inc. * * based on the old aacraid driver that is.. * Adaptec aacraid device driver for Linux. * * Copyright (c) 2000-2010 Adaptec, Inc. * 2010 PMC-Sierra, Inc. (aacraid@pmc-sierra.com) * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2, or (at your option) * any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; see the file COPYING. If not, write to * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. * * Module Name: * linit.c * * Abstract: Linux Driver entry module for Adaptec RAID Array Controller / #include <linux/compat.h> #include <linux/blkdev.h> #include <linux/completion.h> #include <linux/init.h> #include <linux/interrupt.h> #include <linux/kernel.h> #include <linux/module.h> #include <linux/moduleparam.h> #include <linux/pci.h> #include <linux/pci-aspm.h> #include <linux/slab.h> #include <linux/mutex.h> #include <linux/spinlock.h> #include <linux/syscalls.h> #include <linux/delay.h> #include <linux/kthread.h> #include <scsi/scsi.h> #include <scsi/scsi_cmnd.h> #include <scsi/scsi_device.h> #include <scsi/scsi_host.h> #include <scsi/scsi_tcq.h> #include <scsi/scsicam.h> #include <scsi/scsi_eh.h> #include "aacraid.h" #define AAC_DRIVER_VERSION "1.2-0" #ifndef AAC_DRIVER_BRANCH #define AAC_DRIVER_BRANCH "" #endif #define AAC_DRIVERNAME "aacraid" #ifdef AAC_DRIVER_BUILD #define _str(x) #x #define str(x) _str(x) #define AAC_DRIVER_FULL_VERSION AAC_DRIVER_VERSION "[" str(AAC_DRIVER_BUILD) "]" AAC_DRIVER_BRANCH #else #define AAC_DRIVER_FULL_VERSION AAC_DRIVER_VERSION AAC_DRIVER_BRANCH #endif MODULE_AUTHOR("Red Hat Inc and Adaptec"); MODULE_DESCRIPTION("Dell PERC2, 2/Si, 3/Si, 3/Di, " "Adaptec Advanced Raid Products, " "HP NetRAID-4M, IBM ServeRAID & ICP SCSI driver"); MODULE_LICENSE("GPL"); MODULE_VERSION(AAC_DRIVER_FULL_VERSION); static DEFINE_MUTEX(aac_mutex); static LIST_HEAD(aac_devices); static int aac_cfg_major = -1; char aac_driver_version[] = AAC_DRIVER_FULL_VERSION; / * Because of the way Linux names scsi devices, the order in this table has * become important. Check for on-board Raid first, add-in cards second. * * Note: The last field is used to index into aac_drivers below. / static const struct pci_device_id aac_pci_tbl[] = { { 0x1028, 0x0001, 0x1028, 0x0001, 0, 0, 0 }, / PERC 2/Si (Iguana/PERC2Si) / { 0x1028, 0x0002, 0x1028, 0x0002, 0, 0, 1 }, / PERC 3/Di (Opal/PERC3Di) / { 0x1028, 0x0003, 0x1028, 0x0003, 0, 0, 2 }, / PERC 3/Si (SlimFast/PERC3Si / { 0x1028, 0x0004, 0x1028, 0x00d0, 0, 0, 3 }, / PERC 3/Di (Iguana FlipChip/PERC3DiF / { 0x1028, 0x0002, 0x1028, 0x00d1, 0, 0, 4 }, / PERC 3/Di (Viper/PERC3DiV) / { 0x1028, 0x0002, 0x1028, 0x00d9, 0, 0, 5 }, / PERC 3/Di (Lexus/PERC3DiL) / { 0x1028, 0x000a, 0x1028, 0x0106, 0, 0, 6 }, / PERC 3/Di (Jaguar/PERC3DiJ) / { 0x1028, 0x000a, 0x1028, 0x011b, 0, 0, 7 }, / PERC 3/Di (Dagger/PERC3DiD) / { 0x1028, 0x000a, 0x1028, 0x0121, 0, 0, 8 }, / PERC 3/Di (Boxster/PERC3DiB) / { 0x9005, 0x0283, 0x9005, 0x0283, 0, 0, 9 }, / catapult / { 0x9005, 0x0284, 0x9005, 0x0284, 0, 0, 10 }, / tomcat / { 0x9005, 0x0285, 0x9005, 0x0286, 0, 0, 11 }, / Adaptec 2120S (Crusader) / { 0x9005, 0x0285, 0x9005, 0x0285, 0, 0, 12 }, / Adaptec 2200S (Vulcan) / { 0x9005, 0x0285, 0x9005, 0x0287, 0, 0, 13 }, / Adaptec 2200S (Vulcan-2m) / { 0x9005, 0x0285, 0x17aa, 0x0286, 0, 0, 14 }, / Legend S220 (Legend Crusader) / { 0x9005, 0x0285, 0x17aa, 0x0287, 0, 0, 15 }, / Legend S230 (Legend Vulcan) / { 0x9005, 0x0285, 0x9005, 0x0288, 0, 0, 16 }, / Adaptec 3230S (Harrier) / { 0x9005, 0x0285, 0x9005, 0x0289, 0, 0, 17 }, / Adaptec 3240S (Tornado) / { 0x9005, 0x0285, 0x9005, 0x028a, 0, 0, 18 }, / ASR-2020ZCR SCSI PCI-X ZCR (Skyhawk) / { 0x9005, 0x0285, 0x9005, 0x028b, 0, 0, 19 }, / ASR-2025ZCR SCSI SO-DIMM PCI-X ZCR (Terminator) / { 0x9005, 0x0286, 0x9005, 0x028c, 0, 0, 20 }, / ASR-2230S + ASR-2230SLP PCI-X (Lancer) / { 0x9005, 0x0286, 0x9005, 0x028d, 0, 0, 21 }, / ASR-2130S (Lancer) / { 0x9005, 0x0286, 0x9005, 0x029b, 0, 0, 22 }, / AAR-2820SA (Intruder) / { 0x9005, 0x0286, 0x9005, 0x029c, 0, 0, 23 }, / AAR-2620SA (Intruder) / { 0x9005, 0x0286, 0x9005, 0x029d, 0, 0, 24 }, / AAR-2420SA (Intruder) / { 0x9005, 0x0286, 0x9005, 0x029e, 0, 0, 25 }, / ICP9024RO (Lancer) / { 0x9005, 0x0286, 0x9005, 0x029f, 0, 0, 26 }, / ICP9014RO (Lancer) / { 0x9005, 0x0286, 0x9005, 0x02a0, 0, 0, 27 }, / ICP9047MA (Lancer) / { 0x9005, 0x0286, 0x9005, 0x02a1, 0, 0, 28 }, / ICP9087MA (Lancer) / { 0x9005, 0x0286, 0x9005, 0x02a3, 0, 0, 29 }, / ICP5445AU (Hurricane44) / { 0x9005, 0x0285, 0x9005, 0x02a4, 0, 0, 30 }, / ICP9085LI (Marauder-X) / { 0x9005, 0x0285, 0x9005, 0x02a5, 0, 0, 31 }, / ICP5085BR (Marauder-E) / { 0x9005, 0x0286, 0x9005, 0x02a6, 0, 0, 32 }, / ICP9067MA (Intruder-6) / { 0x9005, 0x0287, 0x9005, 0x0800, 0, 0, 33 }, / Themisto Jupiter Platform / { 0x9005, 0x0200, 0x9005, 0x0200, 0, 0, 33 }, / Themisto Jupiter Platform / { 0x9005, 0x0286, 0x9005, 0x0800, 0, 0, 34 }, / Callisto Jupiter Platform / { 0x9005, 0x0285, 0x9005, 0x028e, 0, 0, 35 }, / ASR-2020SA SATA PCI-X ZCR (Skyhawk) / { 0x9005, 0x0285, 0x9005, 0x028f, 0, 0, 36 }, / ASR-2025SA SATA SO-DIMM PCI-X ZCR (Terminator) / { 0x9005, 0x0285, 0x9005, 0x0290, 0, 0, 37 }, / AAR-2410SA PCI SATA 4ch (Jaguar II) / { 0x9005, 0x0285, 0x1028, 0x0291, 0, 0, 38 }, / CERC SATA RAID 2 PCI SATA 6ch (DellCorsair) / { 0x9005, 0x0285, 0x9005, 0x0292, 0, 0, 39 }, / AAR-2810SA PCI SATA 8ch (Corsair-8) / { 0x9005, 0x0285, 0x9005, 0x0293, 0, 0, 40 }, / AAR-21610SA PCI SATA 16ch (Corsair-16) / { 0x9005, 0x0285, 0x9005, 0x0294, 0, 0, 41 }, / ESD SO-DIMM PCI-X SATA ZCR (Prowler) / { 0x9005, 0x0285, 0x103C, 0x3227, 0, 0, 42 }, / AAR-2610SA PCI SATA 6ch / { 0x9005, 0x0285, 0x9005, 0x0296, 0, 0, 43 }, / ASR-2240S (SabreExpress) / { 0x9005, 0x0285, 0x9005, 0x0297, 0, 0, 44 }, / ASR-4005 / { 0x9005, 0x0285, 0x1014, 0x02F2, 0, 0, 45 }, / IBM 8i (AvonPark) / { 0x9005, 0x0285, 0x1014, 0x0312, 0, 0, 45 }, / IBM 8i (AvonPark Lite) / { 0x9005, 0x0286, 0x1014, 0x9580, 0, 0, 46 }, / IBM 8k/8k-l8 (Aurora) / { 0x9005, 0x0286, 0x1014, 0x9540, 0, 0, 47 }, / IBM 8k/8k-l4 (Aurora Lite) / { 0x9005, 0x0285, 0x9005, 0x0298, 0, 0, 48 }, / ASR-4000 (BlackBird) / { 0x9005, 0x0285, 0x9005, 0x0299, 0, 0, 49 }, / ASR-4800SAS (Marauder-X) / { 0x9005, 0x0285, 0x9005, 0x029a, 0, 0, 50 }, / ASR-4805SAS (Marauder-E) / { 0x9005, 0x0286, 0x9005, 0x02a2, 0, 0, 51 }, / ASR-3800 (Hurricane44) / { 0x9005, 0x0285, 0x1028, 0x0287, 0, 0, 52 }, / Perc 320/DC/ { 0x1011, 0x0046, 0x9005, 0x0365, 0, 0, 53 }, / Adaptec 5400S (Mustang)/ { 0x1011, 0x0046, 0x9005, 0x0364, 0, 0, 54 }, / Adaptec 5400S (Mustang)/ { 0x1011, 0x0046, 0x9005, 0x1364, 0, 0, 55 }, / Dell PERC2/QC / { 0x1011, 0x0046, 0x103c, 0x10c2, 0, 0, 56 }, / HP NetRAID-4M / { 0x9005, 0x0285, 0x1028, PCI_ANY_ID, 0, 0, 57 }, / Dell Catchall / { 0x9005, 0x0285, 0x17aa, PCI_ANY_ID, 0, 0, 58 }, / Legend Catchall / { 0x9005, 0x0285, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 59 }, / Adaptec Catch All / { 0x9005, 0x0286, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 60 }, / Adaptec Rocket Catch All / { 0x9005, 0x0288, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 61 }, / Adaptec NEMER/ARK Catch All / { 0x9005, 0x028b, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 62 }, / Adaptec PMC Series 6 (Tupelo) / { 0x9005, 0x028c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 63 }, / Adaptec PMC Series 7 (Denali) / { 0x9005, 0x028d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 64 }, / Adaptec PMC Series 8 / { 0x9005, 0x028f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 65 }, / Adaptec PMC Series 9 / { 0,} }; MODULE_DEVICE_TABLE(pci, aac_pci_tbl); / * dmb - For now we add the number of channels to this structure. * In the future we should add a fib that reports the number of channels * for the card. At that time we can remove the channels from here / static struct aac_driver_ident aac_drivers[] = { { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / PERC 2/Si (Iguana/PERC2Si) / { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / PERC 3/Di (Opal/PERC3Di) / { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / PERC 3/Si (SlimFast/PERC3Si / { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / PERC 3/Di (Iguana FlipChip/PERC3DiF / { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / PERC 3/Di (Viper/PERC3DiV) / { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / PERC 3/Di (Lexus/PERC3DiL) / { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 1, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / PERC 3/Di (Jaguar/PERC3DiJ) / { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / PERC 3/Di (Dagger/PERC3DiD) / { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / PERC 3/Di (Boxster/PERC3DiB) / { aac_rx_init, "aacraid", "ADAPTEC ", "catapult ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / catapult / { aac_rx_init, "aacraid", "ADAPTEC ", "tomcat ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / tomcat / { aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 2120S ", 1, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG }, / Adaptec 2120S (Crusader) / { aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 2200S ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG }, / Adaptec 2200S (Vulcan) / { aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 2200S ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / Adaptec 2200S (Vulcan-2m) / { aac_rx_init, "aacraid", "Legend ", "Legend S220 ", 1, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / Legend S220 (Legend Crusader) / { aac_rx_init, "aacraid", "Legend ", "Legend S230 ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / Legend S230 (Legend Vulcan) / { aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 3230S ", 2 }, / Adaptec 3230S (Harrier) / { aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 3240S ", 2 }, / Adaptec 3240S (Tornado) / { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2020ZCR ", 2 }, / ASR-2020ZCR SCSI PCI-X ZCR (Skyhawk) / { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2025ZCR ", 2 }, / ASR-2025ZCR SCSI SO-DIMM PCI-X ZCR (Terminator) / { aac_rkt_init, "aacraid", "ADAPTEC ", "ASR-2230S PCI-X ", 2 }, / ASR-2230S + ASR-2230SLP PCI-X (Lancer) / { aac_rkt_init, "aacraid", "ADAPTEC ", "ASR-2130S PCI-X ", 1 }, / ASR-2130S (Lancer) / { aac_rkt_init, "aacraid", "ADAPTEC ", "AAR-2820SA ", 1 }, / AAR-2820SA (Intruder) / { aac_rkt_init, "aacraid", "ADAPTEC ", "AAR-2620SA ", 1 }, / AAR-2620SA (Intruder) / { aac_rkt_init, "aacraid", "ADAPTEC ", "AAR-2420SA ", 1 }, / AAR-2420SA (Intruder) / { aac_rkt_init, "aacraid", "ICP ", "ICP9024RO ", 2 }, / ICP9024RO (Lancer) / { aac_rkt_init, "aacraid", "ICP ", "ICP9014RO ", 1 }, / ICP9014RO (Lancer) / { aac_rkt_init, "aacraid", "ICP ", "ICP9047MA ", 1 }, / ICP9047MA (Lancer) / { aac_rkt_init, "aacraid", "ICP ", "ICP9087MA ", 1 }, / ICP9087MA (Lancer) / { aac_rkt_init, "aacraid", "ICP ", "ICP5445AU ", 1 }, / ICP5445AU (Hurricane44) / { aac_rx_init, "aacraid", "ICP ", "ICP9085LI ", 1 }, / ICP9085LI (Marauder-X) / { aac_rx_init, "aacraid", "ICP ", "ICP5085BR ", 1 }, / ICP5085BR (Marauder-E) / { aac_rkt_init, "aacraid", "ICP ", "ICP9067MA ", 1 }, / ICP9067MA (Intruder-6) / { NULL , "aacraid", "ADAPTEC ", "Themisto ", 0, AAC_QUIRK_SLAVE }, / Jupiter Platform / { aac_rkt_init, "aacraid", "ADAPTEC ", "Callisto ", 2, AAC_QUIRK_MASTER }, / Jupiter Platform / { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2020SA ", 1 }, / ASR-2020SA SATA PCI-X ZCR (Skyhawk) / { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2025SA ", 1 }, / ASR-2025SA SATA SO-DIMM PCI-X ZCR (Terminator) / { aac_rx_init, "aacraid", "ADAPTEC ", "AAR-2410SA SATA ", 1, AAC_QUIRK_17SG }, / AAR-2410SA PCI SATA 4ch (Jaguar II) / { aac_rx_init, "aacraid", "DELL ", "CERC SR2 ", 1, AAC_QUIRK_17SG }, / CERC SATA RAID 2 PCI SATA 6ch (DellCorsair) / { aac_rx_init, "aacraid", "ADAPTEC ", "AAR-2810SA SATA ", 1, AAC_QUIRK_17SG }, / AAR-2810SA PCI SATA 8ch (Corsair-8) / { aac_rx_init, "aacraid", "ADAPTEC ", "AAR-21610SA SATA", 1, AAC_QUIRK_17SG }, / AAR-21610SA PCI SATA 16ch (Corsair-16) / { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2026ZCR ", 1 }, / ESD SO-DIMM PCI-X SATA ZCR (Prowler) / { aac_rx_init, "aacraid", "ADAPTEC ", "AAR-2610SA ", 1 }, / SATA 6Ch (Bearcat) / { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2240S ", 1 }, / ASR-2240S (SabreExpress) / { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-4005 ", 1 }, / ASR-4005 / { aac_rx_init, "ServeRAID","IBM ", "ServeRAID 8i ", 1 }, / IBM 8i (AvonPark) / { aac_rkt_init, "ServeRAID","IBM ", "ServeRAID 8k-l8 ", 1 }, / IBM 8k/8k-l8 (Aurora) / { aac_rkt_init, "ServeRAID","IBM ", "ServeRAID 8k-l4 ", 1 }, / IBM 8k/8k-l4 (Aurora Lite) / { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-4000 ", 1 }, / ASR-4000 (BlackBird & AvonPark) / { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-4800SAS ", 1 }, / ASR-4800SAS (Marauder-X) / { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-4805SAS ", 1 }, / ASR-4805SAS (Marauder-E) / { aac_rkt_init, "aacraid", "ADAPTEC ", "ASR-3800 ", 1 }, / ASR-3800 (Hurricane44) / { aac_rx_init, "percraid", "DELL ", "PERC 320/DC ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG }, / Perc 320/DC/ { aac_sa_init, "aacraid", "ADAPTEC ", "Adaptec 5400S ", 4, AAC_QUIRK_34SG }, / Adaptec 5400S (Mustang)/ { aac_sa_init, "aacraid", "ADAPTEC ", "AAC-364 ", 4, AAC_QUIRK_34SG }, / Adaptec 5400S (Mustang)/ { aac_sa_init, "percraid", "DELL ", "PERCRAID ", 4, AAC_QUIRK_34SG }, / Dell PERC2/QC / { aac_sa_init, "hpnraid", "HP ", "NetRAID ", 4, AAC_QUIRK_34SG }, / HP NetRAID-4M / { aac_rx_init, "aacraid", "DELL ", "RAID ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / Dell Catchall / { aac_rx_init, "aacraid", "Legend ", "RAID ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / Legend Catchall / { aac_rx_init, "aacraid", "ADAPTEC ", "RAID ", 2 }, / Adaptec Catch All / { aac_rkt_init, "aacraid", "ADAPTEC ", "RAID ", 2 }, / Adaptec Rocket Catch All / { aac_nark_init, "aacraid", "ADAPTEC ", "RAID ", 2 }, / Adaptec NEMER/ARK Catch All / { aac_src_init, "aacraid", "ADAPTEC ", "RAID ", 2 }, / Adaptec PMC Series 6 (Tupelo) / { aac_srcv_init, "aacraid", "ADAPTEC ", "RAID ", 2 }, / Adaptec PMC Series 7 (Denali) / { aac_srcv_init, "aacraid", "ADAPTEC ", "RAID ", 2 }, / Adaptec PMC Series 8 / { aac_srcv_init, "aacraid", "ADAPTEC ", "RAID ", 2 } / Adaptec PMC Series 9 / }; /* * aac_queuecommand - queue a SCSI command * @cmd: SCSI command to queue * @done: Function to call on command completion * * Queues a command for execution by the associated Host Adapter. * * TODO: unify with aac_scsi_cmd(). / static int aac_queuecommand_lck(struct scsi_cmnd cmd, void (done)(struct scsi_cmnd )) { struct Scsi_Host host = cmd->device->host; struct aac_dev dev = (struct aac_dev )host->hostdata; u32 count = 0; cmd->scsi_done = done; for (; count < (host->can_queue + AAC_NUM_MGT_FIB); ++count) { struct fib fib = &dev->fibs[count]; struct scsi_cmnd * command; if (fib->hw_fib_va->header.XferState && ((command = fib->callback_data)) && (command == cmd) && (cmd->SCp.phase == AAC_OWNER_FIRMWARE)) return 0; /* Already owned by Adapter / } cmd->SCp.phase = AAC_OWNER_LOWLEVEL; return (aac_scsi_cmd(cmd) ? FAILED : 0); } static DEF_SCSI_QCMD(aac_queuecommand) /* * aac_info - Returns the host adapter name * @shost: Scsi host to report on * * Returns a static string describing the device in question / static const char aac_info(struct Scsi_Host shost) { struct aac_dev dev = (struct aac_dev )shost->hostdata; return aac_drivers[dev->cardtype].name; } /* * aac_get_driver_ident * @devtype: index into lookup table * * Returns a pointer to the entry in the driver lookup table. / struct aac_driver_ident aac_get_driver_ident(int devtype) { return &aac_drivers[devtype]; } /** * aac_biosparm - return BIOS parameters for disk * @sdev: The scsi device corresponding to the disk * @bdev: the block device corresponding to the disk * @capacity: the sector capacity of the disk * @geom: geometry block to fill in * * Return the Heads/Sectors/Cylinders BIOS Disk Parameters for Disk. * The default disk geometry is 64 heads, 32 sectors, and the appropriate * number of cylinders so as not to exceed drive capacity. In order for * disks equal to or larger than 1 GB to be addressable by the BIOS * without exceeding the BIOS limitation of 1024 cylinders, Extended * Translation should be enabled. With Extended Translation enabled, * drives between 1 GB inclusive and 2 GB exclusive are given a disk * geometry of 128 heads and 32 sectors, and drives above 2 GB inclusive * are given a disk geometry of 255 heads and 63 sectors. However, if * the BIOS detects that the Extended Translation setting does not match * the geometry in the partition table, then the translation inferred * from the partition table will be used by the BIOS, and a warning may * be displayed. / static int aac_biosparm(struct scsi_device sdev, struct block_device bdev, sector_t capacity, int geom) { struct diskparm param = (struct diskparm )geom; unsigned char buf; dprintk((KERN_DEBUG "aac_biosparm.\n")); / * Assuming extended translation is enabled - #REVISIT# / if (capacity >= 2 1024 * 1024) { /* 1 GB in 512 byte sectors / if(capacity >= 4 1024 * 1024) { /* 2 GB in 512 byte sectors / param->heads = 255; param->sectors = 63; } else { param->heads = 128; param->sectors = 32; } } else { param->heads = 64; param->sectors = 32; } param->cylinders = cap_to_cyls(capacity, param->heads param->sectors); /* * Read the first 1024 bytes from the disk device, if the boot * sector partition table is valid, search for a partition table * entry whose end_head matches one of the standard geometry * translations ( 64/32, 128/32, 255/63 ). / buf = scsi_bios_ptable(bdev); if (!buf) return 0; if((__le16 )(buf + 0x40) == cpu_to_le16(0xaa55)) { struct partition first = (struct partition * )buf; struct partition entry = first; int saved_cylinders = param->cylinders; int num; unsigned char end_head, end_sec; for(num = 0; num < 4; num++) { end_head = entry->end_head; end_sec = entry->end_sector & 0x3f; if(end_head == 63) { param->heads = 64; param->sectors = 32; break; } else if(end_head == 127) { param->heads = 128; param->sectors = 32; break; } else if(end_head == 254) { param->heads = 255; param->sectors = 63; break; } entry++; } if (num == 4) { end_head = first->end_head; end_sec = first->end_sector & 0x3f; } param->cylinders = cap_to_cyls(capacity, param->heads param->sectors); if (num < 4 && end_sec == param->sectors) { if (param->cylinders != saved_cylinders) dprintk((KERN_DEBUG "Adopting geometry: heads=%d, sectors=%d from partition table %d.\n", param->heads, param->sectors, num)); } else if (end_head > 0 \|\| end_sec > 0) { dprintk((KERN_DEBUG "Strange geometry: heads=%d, sectors=%d in partition table %d.\n", end_head + 1, end_sec, num)); dprintk((KERN_DEBUG "Using geometry: heads=%d, sectors=%d.\n", param->heads, param->sectors)); } } kfree(buf); return 0; } /** * aac_slave_configure - compute queue depths * @sdev: SCSI device we are considering * * Selects queue depths for each target device based on the host adapter's * total capacity and the queue depth supported by the target device. * A queue depth of one automatically disables tagged queueing. / static int aac_slave_configure(struct scsi_device sdev) { struct aac_dev aac = (struct aac_dev )sdev->host->hostdata; if (aac->jbod && (sdev->type == TYPE_DISK)) sdev->removable = 1; if ((sdev->type == TYPE_DISK) && (sdev_channel(sdev) != CONTAINER_CHANNEL) && (!aac->jbod \|\| sdev->inq_periph_qual) && (!aac->raid_scsi_mode \|\| (sdev_channel(sdev) != 2))) { if (expose_physicals == 0) return -ENXIO; if (expose_physicals < 0) sdev->no_uld_attach = 1; } if (sdev->tagged_supported && (sdev->type == TYPE_DISK) && (!aac->raid_scsi_mode \|\| (sdev_channel(sdev) != 2)) && !sdev->no_uld_attach) { struct scsi_device * dev; struct Scsi_Host host = sdev->host; unsigned num_lsu = 0; unsigned num_one = 0; unsigned depth; unsigned cid; / * Firmware has an individual device recovery time typically * of 35 seconds, give us a margin. / if (sdev->request_queue->rq_timeout < (45 HZ)) blk_queue_rq_timeout(sdev->request_queue, 45HZ); for (cid = 0; cid < aac->maximum_num_containers; ++cid) if (aac->fsa_dev[cid].valid) ++num_lsu; __shost_for_each_device(dev, host) { if (dev->tagged_supported && (dev->type == TYPE_DISK) && (!aac->raid_scsi_mode \|\| (sdev_channel(sdev) != 2)) && !dev->no_uld_attach) { if ((sdev_channel(dev) != CONTAINER_CHANNEL) \|\| !aac->fsa_dev[sdev_id(dev)].valid) ++num_lsu; } else ++num_one; } if (num_lsu == 0) ++num_lsu; depth = (host->can_queue - num_one) / num_lsu; if (depth > 256) depth = 256; else if (depth < 2) depth = 2; scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth); } else scsi_adjust_queue_depth(sdev, 0, 1); return 0; } /* * aac_change_queue_depth - alter queue depths * @sdev: SCSI device we are considering * @depth: desired queue depth * * Alters queue depths for target device based on the host adapter's * total capacity and the queue depth supported by the target device. / static int aac_change_queue_depth(struct scsi_device sdev, int depth, int reason) { if (reason != SCSI_QDEPTH_DEFAULT) return -EOPNOTSUPP; if (sdev->tagged_supported && (sdev->type == TYPE_DISK) && (sdev_channel(sdev) == CONTAINER_CHANNEL)) { struct scsi_device * dev; struct Scsi_Host host = sdev->host; unsigned num = 0; __shost_for_each_device(dev, host) { if (dev->tagged_supported && (dev->type == TYPE_DISK) && (sdev_channel(dev) == CONTAINER_CHANNEL)) ++num; ++num; } if (num >= host->can_queue) num = host->can_queue - 1; if (depth > (host->can_queue - num)) depth = host->can_queue - num; if (depth > 256) depth = 256; else if (depth < 2) depth = 2; scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth); } else scsi_adjust_queue_depth(sdev, 0, 1); return sdev->queue_depth; } static ssize_t aac_show_raid_level(struct device dev, struct device_attribute attr, char buf) { struct scsi_device sdev = to_scsi_device(dev); struct aac_dev aac = (struct aac_dev )(sdev->host->hostdata); if (sdev_channel(sdev) != CONTAINER_CHANNEL) return snprintf(buf, PAGE_SIZE, sdev->no_uld_attach ? "Hidden\n" : ((aac->jbod && (sdev->type == TYPE_DISK)) ? "JBOD\n" : "")); return snprintf(buf, PAGE_SIZE, "%s\n", get_container_type(aac->fsa_dev[sdev_id(sdev)].type)); } static struct device_attribute aac_raid_level_attr = { .attr = { .name = "level", .mode = S_IRUGO, }, .show = aac_show_raid_level }; static struct device_attribute aac_dev_attrs[] = { &aac_raid_level_attr, NULL, }; static int aac_ioctl(struct scsi_device sdev, int cmd, void __user arg) { struct aac_dev dev = (struct aac_dev )sdev->host->hostdata; if (!capable(CAP_SYS_RAWIO)) return -EPERM; return aac_do_ioctl(dev, cmd, arg); } static int aac_eh_abort(struct scsi_cmnd* cmd) { struct scsi_device * dev = cmd->device; struct Scsi_Host * host = dev->host; struct aac_dev * aac = (struct aac_dev )host->hostdata; int count; int ret = FAILED; printk(KERN_ERR "%s: Host adapter abort request (%d,%d,%d,%d)\n", AAC_DRIVERNAME, host->host_no, sdev_channel(dev), sdev_id(dev), dev->lun); switch (cmd->cmnd[0]) { case SERVICE_ACTION_IN: if (!(aac->raw_io_interface) \|\| !(aac->raw_io_64) \|\| ((cmd->cmnd[1] & 0x1f) != SAI_READ_CAPACITY_16)) break; case INQUIRY: case READ_CAPACITY: / Mark associated FIB to not complete, eh handler does this / for (count = 0; count < (host->can_queue + AAC_NUM_MGT_FIB); ++count) { struct fib fib = &aac->fibs[count]; if (fib->hw_fib_va->header.XferState && (fib->flags & FIB_CONTEXT_FLAG) && (fib->callback_data == cmd)) { fib->flags \|= FIB_CONTEXT_FLAG_TIMED_OUT; cmd->SCp.phase = AAC_OWNER_ERROR_HANDLER; ret = SUCCESS; } } break; case TEST_UNIT_READY: /* Mark associated FIB to not complete, eh handler does this / for (count = 0; count < (host->can_queue + AAC_NUM_MGT_FIB); ++count) { struct scsi_cmnd command; struct fib * fib = &aac->fibs[count]; if ((fib->hw_fib_va->header.XferState & cpu_to_le32(Async \| NoResponseExpected)) && (fib->flags & FIB_CONTEXT_FLAG) && ((command = fib->callback_data)) && (command->device == cmd->device)) { fib->flags \|= FIB_CONTEXT_FLAG_TIMED_OUT; command->SCp.phase = AAC_OWNER_ERROR_HANDLER; if (command == cmd) ret = SUCCESS; } } } return ret; } /* * aac_eh_reset - Reset command handling * @scsi_cmd: SCSI command block causing the reset * / static int aac_eh_reset(struct scsi_cmnd cmd) { struct scsi_device * dev = cmd->device; struct Scsi_Host * host = dev->host; struct scsi_cmnd * command; int count; struct aac_dev * aac = (struct aac_dev )host->hostdata; unsigned long flags; / Mark the associated FIB to not complete, eh handler does this / for (count = 0; count < (host->can_queue + AAC_NUM_MGT_FIB); ++count) { struct fib fib = &aac->fibs[count]; if (fib->hw_fib_va->header.XferState && (fib->flags & FIB_CONTEXT_FLAG) && (fib->callback_data == cmd)) { fib->flags \|= FIB_CONTEXT_FLAG_TIMED_OUT; cmd->SCp.phase = AAC_OWNER_ERROR_HANDLER; } } printk(KERN_ERR "%s: Host adapter reset request. SCSI hang ?\n", AAC_DRIVERNAME); if ((count = aac_check_health(aac))) return count; /* * Wait for all commands to complete to this specific * target (block maximum 60 seconds). / for (count = 60; count; --count) { int active = aac->in_reset; if (active == 0) __shost_for_each_device(dev, host) { spin_lock_irqsave(&dev->list_lock, flags); list_for_each_entry(command, &dev->cmd_list, list) { if ((command != cmd) && (command->SCp.phase == AAC_OWNER_FIRMWARE)) { active++; break; } } spin_unlock_irqrestore(&dev->list_lock, flags); if (active) break; } / * We can exit If all the commands are complete / if (active == 0) return SUCCESS; ssleep(1); } printk(KERN_ERR "%s: SCSI bus appears hung\n", AAC_DRIVERNAME); / * This adapter needs a blind reset, only do so for Adapters that * support a register, instead of a commanded, reset. / if (((aac->supplement_adapter_info.SupportedOptions2 & AAC_OPTION_MU_RESET) \|\| (aac->supplement_adapter_info.SupportedOptions2 & AAC_OPTION_DOORBELL_RESET)) && aac_check_reset && ((aac_check_reset != 1) \|\| !(aac->supplement_adapter_info.SupportedOptions2 & AAC_OPTION_IGNORE_RESET))) aac_reset_adapter(aac, 2); / Bypass wait for command quiesce / return SUCCESS; / Cause an immediate retry of the command with a ten second delay after successful tur / } /* * aac_cfg_open - open a configuration file * @inode: inode being opened * @file: file handle attached * * Called when the configuration device is opened. Does the needed * set up on the handle and then returns * * Bugs: This needs extending to check a given adapter is present * so we can support hot plugging, and to ref count adapters. / static int aac_cfg_open(struct inode inode, struct file file) { struct aac_dev aac; unsigned minor_number = iminor(inode); int err = -ENODEV; mutex_lock(&aac_mutex); /* BKL pushdown: nothing else protects this list / list_for_each_entry(aac, &aac_devices, entry) { if (aac->id == minor_number) { file->private_data = aac; err = 0; break; } } mutex_unlock(&aac_mutex); return err; } /* * aac_cfg_ioctl - AAC configuration request * @inode: inode of device * @file: file handle * @cmd: ioctl command code * @arg: argument * * Handles a configuration ioctl. Currently this involves wrapping it * up and feeding it into the nasty windowsalike glue layer. * * Bugs: Needs locking against parallel ioctls lower down * Bugs: Needs to handle hot plugging / static long aac_cfg_ioctl(struct file file, unsigned int cmd, unsigned long arg) { int ret; if (!capable(CAP_SYS_RAWIO)) return -EPERM; mutex_lock(&aac_mutex); ret = aac_do_ioctl(file->private_data, cmd, (void __user )arg); mutex_unlock(&aac_mutex); return ret; } #ifdef CONFIG_COMPAT static long aac_compat_do_ioctl(struct aac_dev dev, unsigned cmd, unsigned long arg) { long ret; mutex_lock(&aac_mutex); switch (cmd) { case FSACTL_MINIPORT_REV_CHECK: case FSACTL_SENDFIB: case FSACTL_OPEN_GET_ADAPTER_FIB: case FSACTL_CLOSE_GET_ADAPTER_FIB: case FSACTL_SEND_RAW_SRB: case FSACTL_GET_PCI_INFO: case FSACTL_QUERY_DISK: case FSACTL_DELETE_DISK: case FSACTL_FORCE_DELETE_DISK: case FSACTL_GET_CONTAINERS: case FSACTL_SEND_LARGE_FIB: ret = aac_do_ioctl(dev, cmd, (void __user )arg); break; case FSACTL_GET_NEXT_ADAPTER_FIB: { struct fib_ioctl __user f; f = compat_alloc_user_space(sizeof(f)); ret = 0; if (clear_user(f, sizeof(f))) ret = -EFAULT; if (copy_in_user(f, (void __user )arg, sizeof(struct fib_ioctl) - sizeof(u32))) ret = -EFAULT; if (!ret) ret = aac_do_ioctl(dev, cmd, f); break; } default: ret = -ENOIOCTLCMD; break; } mutex_unlock(&aac_mutex); return ret; } static int aac_compat_ioctl(struct scsi_device sdev, int cmd, void __user arg) { struct aac_dev dev = (struct aac_dev )sdev->host->hostdata; if (!capable(CAP_SYS_RAWIO)) return -EPERM; return aac_compat_do_ioctl(dev, cmd, (unsigned long)arg); } static long aac_compat_cfg_ioctl(struct file file, unsigned cmd, unsigned long arg) { if (!capable(CAP_SYS_RAWIO)) return -EPERM; return aac_compat_do_ioctl(file->private_data, cmd, arg); } #endif static ssize_t aac_show_model(struct device device, struct device_attribute attr, char buf) { struct aac_dev dev = (struct aac_dev)class_to_shost(device)->hostdata; int len; if (dev->supplement_adapter_info.AdapterTypeText[0]) { char cp = dev->supplement_adapter_info.AdapterTypeText; while (cp && cp != ' ') ++cp; while (cp == ' ') ++cp; len = snprintf(buf, PAGE_SIZE, "%s\n", cp); } else len = snprintf(buf, PAGE_SIZE, "%s\n", aac_drivers[dev->cardtype].model); return len; } static ssize_t aac_show_vendor(struct device device, struct device_attribute attr, char buf) { struct aac_dev dev = (struct aac_dev)class_to_shost(device)->hostdata; int len; if (dev->supplement_adapter_info.AdapterTypeText[0]) { char * cp = dev->supplement_adapter_info.AdapterTypeText; while (cp && cp != ' ') ++cp; len = snprintf(buf, PAGE_SIZE, "%.s\n", (int)(cp - (char )dev->supplement_adapter_info.AdapterTypeText), dev->supplement_adapter_info.AdapterTypeText); } else len = snprintf(buf, PAGE_SIZE, "%s\n", aac_drivers[dev->cardtype].vname); return len; } static ssize_t aac_show_flags(struct device cdev, struct device_attribute attr, char buf) { int len = 0; struct aac_dev dev = (struct aac_dev)class_to_shost(cdev)->hostdata; if (nblank(dprintk(x))) len = snprintf(buf, PAGE_SIZE, "dprintk\n"); #ifdef AAC_DETAILED_STATUS_INFO len += snprintf(buf + len, PAGE_SIZE - len, "AAC_DETAILED_STATUS_INFO\n"); #endif if (dev->raw_io_interface && dev->raw_io_64) len += snprintf(buf + len, PAGE_SIZE - len, "SAI_READ_CAPACITY_16\n"); if (dev->jbod) len += snprintf(buf + len, PAGE_SIZE - len, "SUPPORTED_JBOD\n"); if (dev->supplement_adapter_info.SupportedOptions2 & AAC_OPTION_POWER_MANAGEMENT) len += snprintf(buf + len, PAGE_SIZE - len, "SUPPORTED_POWER_MANAGEMENT\n"); if (dev->msi) len += snprintf(buf + len, PAGE_SIZE - len, "PCI_HAS_MSI\n"); return len; } static ssize_t aac_show_kernel_version(struct device device, struct device_attribute attr, char buf) { struct aac_dev dev = (struct aac_dev)class_to_shost(device)->hostdata; int len, tmp; tmp = le32_to_cpu(dev->adapter_info.kernelrev); len = snprintf(buf, PAGE_SIZE, "%d.%d-%d[%d]\n", tmp >> 24, (tmp >> 16) & 0xff, tmp & 0xff, le32_to_cpu(dev->adapter_info.kernelbuild)); return len; } static ssize_t aac_show_monitor_version(struct device device, struct device_attribute attr, char buf) { struct aac_dev dev = (struct aac_dev)class_to_shost(device)->hostdata; int len, tmp; tmp = le32_to_cpu(dev->adapter_info.monitorrev); len = snprintf(buf, PAGE_SIZE, "%d.%d-%d[%d]\n", tmp >> 24, (tmp >> 16) & 0xff, tmp & 0xff, le32_to_cpu(dev->adapter_info.monitorbuild)); return len; } static ssize_t aac_show_bios_version(struct device device, struct device_attribute attr, char buf) { struct aac_dev dev = (struct aac_dev)class_to_shost(device)->hostdata; int len, tmp; tmp = le32_to_cpu(dev->adapter_info.biosrev); len = snprintf(buf, PAGE_SIZE, "%d.%d-%d[%d]\n", tmp >> 24, (tmp >> 16) & 0xff, tmp & 0xff, le32_to_cpu(dev->adapter_info.biosbuild)); return len; } static ssize_t aac_show_serial_number(struct device device, struct device_attribute attr, char buf) { struct aac_dev dev = (struct aac_dev)class_to_shost(device)->hostdata; int len = 0; if (le32_to_cpu(dev->adapter_info.serial[0]) != 0xBAD0) len = snprintf(buf, 16, "%06X\n", le32_to_cpu(dev->adapter_info.serial[0])); if (len && !memcmp(&dev->supplement_adapter_info.MfgPcbaSerialNo[ sizeof(dev->supplement_adapter_info.MfgPcbaSerialNo)-len], buf, len-1)) len = snprintf(buf, 16, "%.s\n", (int)sizeof(dev->supplement_adapter_info.MfgPcbaSerialNo), dev->supplement_adapter_info.MfgPcbaSerialNo); return min(len, 16); } static ssize_t aac_show_max_channel(struct device device, struct device_attribute attr, char buf) { return snprintf(buf, PAGE_SIZE, "%d\n", class_to_shost(device)->max_channel); } static ssize_t aac_show_max_id(struct device device, struct device_attribute attr, char buf) { return snprintf(buf, PAGE_SIZE, "%d\n", class_to_shost(device)->max_id); } static ssize_t aac_store_reset_adapter(struct device device, struct device_attribute attr, const char buf, size_t count) { int retval = -EACCES; if (!capable(CAP_SYS_ADMIN)) return retval; retval = aac_reset_adapter((struct aac_dev)class_to_shost(device)->hostdata, buf[0] == '!'); if (retval >= 0) retval = count; return retval; } static ssize_t aac_show_reset_adapter(struct device device, struct device_attribute attr, char buf) { struct aac_dev dev = (struct aac_dev)class_to_shost(device)->hostdata; int len, tmp; tmp = aac_adapter_check_health(dev); if ((tmp == 0) && dev->in_reset) tmp = -EBUSY; len = snprintf(buf, PAGE_SIZE, "0x%x\n", tmp); return len; } static struct device_attribute aac_model = { .attr = { .name = "model", .mode = S_IRUGO, }, .show = aac_show_model, }; static struct device_attribute aac_vendor = { .attr = { .name = "vendor", .mode = S_IRUGO, }, .show = aac_show_vendor, }; static struct device_attribute aac_flags = { .attr = { .name = "flags", .mode = S_IRUGO, }, .show = aac_show_flags, }; static struct device_attribute aac_kernel_version = { .attr = { .name = "hba_kernel_version", .mode = S_IRUGO, }, .show = aac_show_kernel_version, }; static struct device_attribute aac_monitor_version = { .attr = { .name = "hba_monitor_version", .mode = S_IRUGO, }, .show = aac_show_monitor_version, }; static struct device_attribute aac_bios_version = { .attr = { .name = "hba_bios_version", .mode = S_IRUGO, }, .show = aac_show_bios_version, }; static struct device_attribute aac_serial_number = { .attr = { .name = "serial_number", .mode = S_IRUGO, }, .show = aac_show_serial_number, }; static struct device_attribute aac_max_channel = { .attr = { .name = "max_channel", .mode = S_IRUGO, }, .show = aac_show_max_channel, }; static struct device_attribute aac_max_id = { .attr = { .name = "max_id", .mode = S_IRUGO, }, .show = aac_show_max_id, }; static struct device_attribute aac_reset = { .attr = { .name = "reset_host", .mode = S_IWUSR\|S_IRUGO, }, .store = aac_store_reset_adapter, .show = aac_show_reset_adapter, }; static struct device_attribute aac_attrs[] = { &aac_model, &aac_vendor, &aac_flags, &aac_kernel_version, &aac_monitor_version, &aac_bios_version, &aac_serial_number, &aac_max_channel, &aac_max_id, &aac_reset, NULL }; ssize_t aac_get_serial_number(struct device device, char buf) { return aac_show_serial_number(device, &aac_serial_number, buf); } static const struct file_operations aac_cfg_fops = { .owner = THIS_MODULE, .unlocked_ioctl = aac_cfg_ioctl, #ifdef CONFIG_COMPAT .compat_ioctl = aac_compat_cfg_ioctl, #endif .open = aac_cfg_open, .llseek = noop_llseek, }; static struct scsi_host_template aac_driver_template = { .module = THIS_MODULE, .name = "AAC", .proc_name = AAC_DRIVERNAME, .info = aac_info, .ioctl = aac_ioctl, #ifdef CONFIG_COMPAT .compat_ioctl = aac_compat_ioctl, #endif .queuecommand = aac_queuecommand, .bios_param = aac_biosparm, .shost_attrs = aac_attrs, .slave_configure = aac_slave_configure, .change_queue_depth = aac_change_queue_depth, .sdev_attrs = aac_dev_attrs, .eh_abort_handler = aac_eh_abort, .eh_host_reset_handler = aac_eh_reset, .can_queue = AAC_NUM_IO_FIB, .this_id = MAXIMUM_NUM_CONTAINERS, .sg_tablesize = 16, .max_sectors = 128, #if (AAC_NUM_IO_FIB > 256) .cmd_per_lun = 256, #else .cmd_per_lun = AAC_NUM_IO_FIB, #endif .use_clustering = ENABLE_CLUSTERING, .emulated = 1, }; static void __aac_shutdown(struct aac_dev * aac) { if (aac->aif_thread) { int i; /* Clear out events first / for (i = 0; i < (aac->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB); i++) { struct fib fib = &aac->fibs[i]; if (!(fib->hw_fib_va->header.XferState & cpu_to_le32(NoResponseExpected \| Async)) && (fib->hw_fib_va->header.XferState & cpu_to_le32(ResponseExpected))) up(&fib->event_wait); } kthread_stop(aac->thread); } aac_send_shutdown(aac); aac_adapter_disable_int(aac); free_irq(aac->pdev->irq, aac); if (aac->msi) pci_disable_msi(aac->pdev); } static int aac_probe_one(struct pci_dev pdev, const struct pci_device_id id) { unsigned index = id->driver_data; struct Scsi_Host shost; struct aac_dev aac; struct list_head insert = &aac_devices; int error = -ENODEV; int unique_id = 0; u64 dmamask; extern int aac_sync_mode; list_for_each_entry(aac, &aac_devices, entry) { if (aac->id > unique_id) break; insert = &aac->entry; unique_id++; } pci_disable_link_state(pdev, PCIE_LINK_STATE_L0S \| PCIE_LINK_STATE_L1 \| PCIE_LINK_STATE_CLKPM); error = pci_enable_device(pdev); if (error) goto out; error = -ENODEV; / * If the quirk31 bit is set, the adapter needs adapter * to driver communication memory to be allocated below 2gig / if (aac_drivers[index].quirks & AAC_QUIRK_31BIT) dmamask = DMA_BIT_MASK(31); else dmamask = DMA_BIT_MASK(32); if (pci_set_dma_mask(pdev, dmamask) \|\| pci_set_consistent_dma_mask(pdev, dmamask)) goto out_disable_pdev; pci_set_master(pdev); shost = scsi_host_alloc(&aac_driver_template, sizeof(struct aac_dev)); if (!shost) goto out_disable_pdev; shost->irq = pdev->irq; shost->unique_id = unique_id; shost->max_cmd_len = 16; aac = (struct aac_dev )shost->hostdata; aac->base_start = pci_resource_start(pdev, 0); aac->scsi_host_ptr = shost; aac->pdev = pdev; aac->name = aac_driver_template.name; aac->id = shost->unique_id; aac->cardtype = index; INIT_LIST_HEAD(&aac->entry); aac->fibs = kzalloc(sizeof(struct fib) * (shost->can_queue + AAC_NUM_MGT_FIB), GFP_KERNEL); if (!aac->fibs) goto out_free_host; spin_lock_init(&aac->fib_lock); /* * Map in the registers from the adapter. / aac->base_size = AAC_MIN_FOOTPRINT_SIZE; if ((aac_drivers[index].init)(aac)) goto out_unmap; if (aac->sync_mode) { if (aac_sync_mode) printk(KERN_INFO "%s%d: Sync. mode enforced " "by driver parameter. This will cause " "a significant performance decrease!\n", aac->name, aac->id); else printk(KERN_INFO "%s%d: Async. mode not supported " "by current driver, sync. mode enforced." "\nPlease update driver to get full performance.\n", aac->name, aac->id); } /* * Start any kernel threads needed / aac->thread = kthread_run(aac_command_thread, aac, AAC_DRIVERNAME); if (IS_ERR(aac->thread)) { printk(KERN_ERR "aacraid: Unable to create command thread.\n"); error = PTR_ERR(aac->thread); aac->thread = NULL; goto out_deinit; } / * If we had set a smaller DMA mask earlier, set it to 4gig * now since the adapter can dma data to at least a 4gig * address space. / if (aac_drivers[index].quirks & AAC_QUIRK_31BIT) if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) goto out_deinit; aac->maximum_num_channels = aac_drivers[index].channels; error = aac_get_adapter_info(aac); if (error < 0) goto out_deinit; / * Lets override negotiations and drop the maximum SG limit to 34 / if ((aac_drivers[index].quirks & AAC_QUIRK_34SG) && (shost->sg_tablesize > 34)) { shost->sg_tablesize = 34; shost->max_sectors = (shost->sg_tablesize 8) + 112; } if ((aac_drivers[index].quirks & AAC_QUIRK_17SG) && (shost->sg_tablesize > 17)) { shost->sg_tablesize = 17; shost->max_sectors = (shost->sg_tablesize * 8) + 112; } error = pci_set_dma_max_seg_size(pdev, (aac->adapter_info.options & AAC_OPT_NEW_COMM) ? (shost->max_sectors << 9) : 65536); if (error) goto out_deinit; /* * Firmware printf works only with older firmware. / if (aac_drivers[index].quirks & AAC_QUIRK_34SG) aac->printf_enabled = 1; else aac->printf_enabled = 0; / * max channel will be the physical channels plus 1 virtual channel * all containers are on the virtual channel 0 (CONTAINER_CHANNEL) * physical channels are address by their actual physical number+1 / if (aac->nondasd_support \|\| expose_physicals \|\| aac->jbod) shost->max_channel = aac->maximum_num_channels; else shost->max_channel = 0; aac_get_config_status(aac, 0); aac_get_containers(aac); list_add(&aac->entry, insert); shost->max_id = aac->maximum_num_containers; if (shost->max_id < aac->maximum_num_physicals) shost->max_id = aac->maximum_num_physicals; if (shost->max_id < MAXIMUM_NUM_CONTAINERS) shost->max_id = MAXIMUM_NUM_CONTAINERS; else shost->this_id = shost->max_id; / * dmb - we may need to move the setting of these parms somewhere else once * we get a fib that can report the actual numbers / shost->max_lun = AAC_MAX_LUN; pci_set_drvdata(pdev, shost); error = scsi_add_host(shost, &pdev->dev); if (error) goto out_deinit; scsi_scan_host(shost); return 0; out_deinit: __aac_shutdown(aac); out_unmap: aac_fib_map_free(aac); if (aac->comm_addr) pci_free_consistent(aac->pdev, aac->comm_size, aac->comm_addr, aac->comm_phys); kfree(aac->queues); aac_adapter_ioremap(aac, 0); kfree(aac->fibs); kfree(aac->fsa_dev); out_free_host: scsi_host_put(shost); out_disable_pdev: pci_disable_device(pdev); out: return error; } static void aac_shutdown(struct pci_dev dev) { struct Scsi_Host shost = pci_get_drvdata(dev); scsi_block_requests(shost); __aac_shutdown((struct aac_dev )shost->hostdata); } static void aac_remove_one(struct pci_dev pdev) { struct Scsi_Host shost = pci_get_drvdata(pdev); struct aac_dev aac = (struct aac_dev )shost->hostdata; scsi_remove_host(shost); __aac_shutdown(aac); aac_fib_map_free(aac); pci_free_consistent(aac->pdev, aac->comm_size, aac->comm_addr, aac->comm_phys); kfree(aac->queues); aac_adapter_ioremap(aac, 0); kfree(aac->fibs); kfree(aac->fsa_dev); list_del(&aac->entry); scsi_host_put(shost); pci_disable_device(pdev); if (list_empty(&aac_devices)) { unregister_chrdev(aac_cfg_major, "aac"); aac_cfg_major = -1; } } static struct pci_driver aac_pci_driver = { .name = AAC_DRIVERNAME, .id_table = aac_pci_tbl, .probe = aac_probe_one, .remove = aac_remove_one, .shutdown = aac_shutdown, }; static int __init aac_init(void) { int error; printk(KERN_INFO "Adaptec %s driver %s\n", AAC_DRIVERNAME, aac_driver_version); error = pci_register_driver(&aac_pci_driver); if (error < 0) return error; aac_cfg_major = register_chrdev( 0, "aac", &aac_cfg_fops); if (aac_cfg_major < 0) { printk(KERN_WARNING "aacraid: unable to register \"aac\" device.\n"); } return 0; } static void __exit aac_exit(void) { if (aac_cfg_major > -1) unregister_chrdev(aac_cfg_major, "aac"); pci_unregister_driver(&aac_pci_driver); } module_init(aac_init); module_exit(aac_exit);	./CrossVul/dataset_final_sorted/CWE-264/c/good_5801_0
crossvul-cpp_data_good_2033_1	/* $Id: fpm_unix.c,v 1.25.2.1 2008/12/13 03:18:23 anight Exp $ / / (c) 2007,2008 Andrei Nigmatulin / #include "fpm_config.h" #include <string.h> #include <sys/time.h> #include <sys/resource.h> #include <stdlib.h> #include <unistd.h> #include <sys/types.h> #include <pwd.h> #include <grp.h> #ifdef HAVE_PRCTL #include <sys/prctl.h> #endif #include "fpm.h" #include "fpm_conf.h" #include "fpm_cleanup.h" #include "fpm_clock.h" #include "fpm_stdio.h" #include "fpm_unix.h" #include "fpm_signals.h" #include "zlog.h" size_t fpm_pagesize; int fpm_unix_resolve_socket_premissions(struct fpm_worker_pool_s wp) /* {{{ / { struct fpm_worker_pool_config_s c = wp->config; /* uninitialized / wp->socket_uid = -1; wp->socket_gid = -1; wp->socket_mode = 0660; if (!c) { return 0; } if (c->listen_owner && c->listen_owner) { struct passwd pwd; pwd = getpwnam(c->listen_owner); if (!pwd) { zlog(ZLOG_SYSERROR, "[pool %s] cannot get uid for user '%s'", wp->config->name, c->listen_owner); return -1; } wp->socket_uid = pwd->pw_uid; wp->socket_gid = pwd->pw_gid; } if (c->listen_group && c->listen_group) { struct group grp; grp = getgrnam(c->listen_group); if (!grp) { zlog(ZLOG_SYSERROR, "[pool %s] cannot get gid for group '%s'", wp->config->name, c->listen_group); return -1; } wp->socket_gid = grp->gr_gid; } if (c->listen_mode && c->listen_mode) { wp->socket_mode = strtoul(c->listen_mode, 0, 8); } return 0; } /* }}} / static int fpm_unix_conf_wp(struct fpm_worker_pool_s wp) /* {{{ / { struct passwd pwd; int is_root = !geteuid(); if (is_root) { if (wp->config->user && wp->config->user) { if (strlen(wp->config->user) == strspn(wp->config->user, "0123456789")) { wp->set_uid = strtoul(wp->config->user, 0, 10); } else { struct passwd pwd; pwd = getpwnam(wp->config->user); if (!pwd) { zlog(ZLOG_ERROR, "[pool %s] cannot get uid for user '%s'", wp->config->name, wp->config->user); return -1; } wp->set_uid = pwd->pw_uid; wp->set_gid = pwd->pw_gid; wp->user = strdup(pwd->pw_name); wp->home = strdup(pwd->pw_dir); } } if (wp->config->group && wp->config->group) { if (strlen(wp->config->group) == strspn(wp->config->group, "0123456789")) { wp->set_gid = strtoul(wp->config->group, 0, 10); } else { struct group grp; grp = getgrnam(wp->config->group); if (!grp) { zlog(ZLOG_ERROR, "[pool %s] cannot get gid for group '%s'", wp->config->name, wp->config->group); return -1; } wp->set_gid = grp->gr_gid; } } if (!fpm_globals.run_as_root) { if (wp->set_uid == 0 \|\| wp->set_gid == 0) { zlog(ZLOG_ERROR, "[pool %s] please specify user and group other than root", wp->config->name); return -1; } } } else { /* not root / if (wp->config->user && wp->config->user) { zlog(ZLOG_NOTICE, "[pool %s] 'user' directive is ignored when FPM is not running as root", wp->config->name); } if (wp->config->group && wp->config->group) { zlog(ZLOG_NOTICE, "[pool %s] 'group' directive is ignored when FPM is not running as root", wp->config->name); } if (wp->config->chroot && wp->config->chroot) { zlog(ZLOG_NOTICE, "[pool %s] 'chroot' directive is ignored when FPM is not running as root", wp->config->name); } if (wp->config->process_priority != 64) { zlog(ZLOG_NOTICE, "[pool %s] 'process.priority' directive is ignored when FPM is not running as root", wp->config->name); } /* set up HOME and USER anyway / pwd = getpwuid(getuid()); if (pwd) { wp->user = strdup(pwd->pw_name); wp->home = strdup(pwd->pw_dir); } } return 0; } / }}} / int fpm_unix_init_child(struct fpm_worker_pool_s wp) /* {{{ / { int is_root = !geteuid(); int made_chroot = 0; if (wp->config->rlimit_files) { struct rlimit r; r.rlim_max = r.rlim_cur = (rlim_t) wp->config->rlimit_files; if (0 > setrlimit(RLIMIT_NOFILE, &r)) { zlog(ZLOG_SYSERROR, "[pool %s] failed to set rlimit_files for this pool. Please check your system limits or decrease rlimit_files. setrlimit(RLIMIT_NOFILE, %d)", wp->config->name, wp->config->rlimit_files); } } if (wp->config->rlimit_core) { struct rlimit r; r.rlim_max = r.rlim_cur = wp->config->rlimit_core == -1 ? (rlim_t) RLIM_INFINITY : (rlim_t) wp->config->rlimit_core; if (0 > setrlimit(RLIMIT_CORE, &r)) { zlog(ZLOG_SYSERROR, "[pool %s] failed to set rlimit_core for this pool. Please check your system limits or decrease rlimit_core. setrlimit(RLIMIT_CORE, %d)", wp->config->name, wp->config->rlimit_core); } } if (is_root && wp->config->chroot && wp->config->chroot) { if (0 > chroot(wp->config->chroot)) { zlog(ZLOG_SYSERROR, "[pool %s] failed to chroot(%s)", wp->config->name, wp->config->chroot); return -1; } made_chroot = 1; } if (wp->config->chdir && wp->config->chdir) { if (0 > chdir(wp->config->chdir)) { zlog(ZLOG_SYSERROR, "[pool %s] failed to chdir(%s)", wp->config->name, wp->config->chdir); return -1; } } else if (made_chroot) { chdir("/"); } if (is_root) { if (wp->config->process_priority != 64) { if (setpriority(PRIO_PROCESS, 0, wp->config->process_priority) < 0) { zlog(ZLOG_SYSERROR, "[pool %s] Unable to set priority for this new process", wp->config->name); return -1; } } if (wp->set_gid) { if (0 > setgid(wp->set_gid)) { zlog(ZLOG_SYSERROR, "[pool %s] failed to setgid(%d)", wp->config->name, wp->set_gid); return -1; } } if (wp->set_uid) { if (0 > initgroups(wp->config->user, wp->set_gid)) { zlog(ZLOG_SYSERROR, "[pool %s] failed to initgroups(%s, %d)", wp->config->name, wp->config->user, wp->set_gid); return -1; } if (0 > setuid(wp->set_uid)) { zlog(ZLOG_SYSERROR, "[pool %s] failed to setuid(%d)", wp->config->name, wp->set_uid); return -1; } } } #ifdef HAVE_PRCTL if (0 > prctl(PR_SET_DUMPABLE, 1, 0, 0, 0)) { zlog(ZLOG_SYSERROR, "[pool %s] failed to prctl(PR_SET_DUMPABLE)", wp->config->name); } #endif if (0 > fpm_clock_init()) { return -1; } return 0; } / }}} / int fpm_unix_init_main() / {{{ / { struct fpm_worker_pool_s wp; int is_root = !geteuid(); if (fpm_global_config.rlimit_files) { struct rlimit r; r.rlim_max = r.rlim_cur = (rlim_t) fpm_global_config.rlimit_files; if (0 > setrlimit(RLIMIT_NOFILE, &r)) { zlog(ZLOG_SYSERROR, "failed to set rlimit_core for this pool. Please check your system limits or decrease rlimit_files. setrlimit(RLIMIT_NOFILE, %d)", fpm_global_config.rlimit_files); return -1; } } if (fpm_global_config.rlimit_core) { struct rlimit r; r.rlim_max = r.rlim_cur = fpm_global_config.rlimit_core == -1 ? (rlim_t) RLIM_INFINITY : (rlim_t) fpm_global_config.rlimit_core; if (0 > setrlimit(RLIMIT_CORE, &r)) { zlog(ZLOG_SYSERROR, "failed to set rlimit_core for this pool. Please check your system limits or decrease rlimit_core. setrlimit(RLIMIT_CORE, %d)", fpm_global_config.rlimit_core); return -1; } } fpm_pagesize = getpagesize(); if (fpm_global_config.daemonize) { /* * If daemonize, the calling process will die soon * and the master process continues to initialize itself. * * The parent process has then to wait for the master * process to initialize to return a consistent exit * value. For this pupose, the master process will * send \"1\" into the pipe if everything went well * and \"0\" otherwise. / struct timeval tv; fd_set rfds; int ret; if (pipe(fpm_globals.send_config_pipe) == -1) { zlog(ZLOG_SYSERROR, "failed to create pipe"); return -1; } / then fork / pid_t pid = fork(); switch (pid) { case -1 : / error / zlog(ZLOG_SYSERROR, "failed to daemonize"); return -1; case 0 : / children / close(fpm_globals.send_config_pipe[0]); / close the read side of the pipe / break; default : / parent / close(fpm_globals.send_config_pipe[1]); / close the write side of the pipe / / * wait for 10s before exiting with error * the child is supposed to send 1 or 0 into the pipe to tell the parent * how it goes for it / FD_ZERO(&rfds); FD_SET(fpm_globals.send_config_pipe[0], &rfds); tv.tv_sec = 10; tv.tv_usec = 0; zlog(ZLOG_DEBUG, "The calling process is waiting for the master process to ping via fd=%d", fpm_globals.send_config_pipe[0]); ret = select(fpm_globals.send_config_pipe[0] + 1, &rfds, NULL, NULL, &tv); if (ret == -1) { zlog(ZLOG_SYSERROR, "failed to select"); exit(FPM_EXIT_SOFTWARE); } if (ret) { / data available / int readval; ret = read(fpm_globals.send_config_pipe[0], &readval, sizeof(readval)); if (ret == -1) { zlog(ZLOG_SYSERROR, "failed to read from pipe"); exit(FPM_EXIT_SOFTWARE); } if (ret == 0) { zlog(ZLOG_ERROR, "no data have been read from pipe"); exit(FPM_EXIT_SOFTWARE); } else { if (readval == 1) { zlog(ZLOG_DEBUG, "I received a valid acknoledge from the master process, I can exit without error"); fpm_cleanups_run(FPM_CLEANUP_PARENT_EXIT); exit(FPM_EXIT_OK); } else { zlog(ZLOG_DEBUG, "The master process returned an error !"); exit(FPM_EXIT_SOFTWARE); } } } else { / no date sent ! / zlog(ZLOG_ERROR, "the master process didn't send back its status (via the pipe to the calling process)"); exit(FPM_EXIT_SOFTWARE); } exit(FPM_EXIT_SOFTWARE); } } / continue as a child / setsid(); if (0 > fpm_clock_init()) { return -1; } if (fpm_global_config.process_priority != 64) { if (is_root) { if (setpriority(PRIO_PROCESS, 0, fpm_global_config.process_priority) < 0) { zlog(ZLOG_SYSERROR, "Unable to set priority for the master process"); return -1; } } else { zlog(ZLOG_NOTICE, "'process.priority' directive is ignored when FPM is not running as root"); } } fpm_globals.parent_pid = getpid(); for (wp = fpm_worker_all_pools; wp; wp = wp->next) { if (0 > fpm_unix_conf_wp(wp)) { return -1; } } zlog_set_level(fpm_globals.log_level); return 0; } / }}} */	./CrossVul/dataset_final_sorted/CWE-264/c/good_2033_1
crossvul-cpp_data_good_2159_3	/* * Kernel-based Virtual Machine driver for Linux * * derived from drivers/kvm/kvm_main.c * * Copyright (C) 2006 Qumranet, Inc. * Copyright (C) 2008 Qumranet, Inc. * Copyright IBM Corporation, 2008 * Copyright 2010 Red Hat, Inc. and/or its affiliates. * * Authors: * Avi Kivity <avi@qumranet.com> * Yaniv Kamay <yaniv@qumranet.com> * Amit Shah <amit.shah@qumranet.com> * Ben-Ami Yassour <benami@il.ibm.com> * * This work is licensed under the terms of the GNU GPL, version 2. See * the COPYING file in the top-level directory. * / #include <linux/kvm_host.h> #include "irq.h" #include "mmu.h" #include "i8254.h" #include "tss.h" #include "kvm_cache_regs.h" #include "x86.h" #include "cpuid.h" #include <linux/clocksource.h> #include <linux/interrupt.h> #include <linux/kvm.h> #include <linux/fs.h> #include <linux/vmalloc.h> #include <linux/module.h> #include <linux/mman.h> #include <linux/highmem.h> #include <linux/iommu.h> #include <linux/intel-iommu.h> #include <linux/cpufreq.h> #include <linux/user-return-notifier.h> #include <linux/srcu.h> #include <linux/slab.h> #include <linux/perf_event.h> #include <linux/uaccess.h> #include <linux/hash.h> #include <linux/pci.h> #include <linux/timekeeper_internal.h> #include <linux/pvclock_gtod.h> #include <trace/events/kvm.h> #define CREATE_TRACE_POINTS #include "trace.h" #include <asm/debugreg.h> #include <asm/msr.h> #include <asm/desc.h> #include <asm/mtrr.h> #include <asm/mce.h> #include <asm/i387.h> #include <asm/fpu-internal.h> / Ugh! / #include <asm/xcr.h> #include <asm/pvclock.h> #include <asm/div64.h> #define MAX_IO_MSRS 256 #define KVM_MAX_MCE_BANKS 32 #define KVM_MCE_CAP_SUPPORTED (MCG_CTL_P \| MCG_SER_P) #define emul_to_vcpu(ctxt) \ container_of(ctxt, struct kvm_vcpu, arch.emulate_ctxt) / EFER defaults: * - enable syscall per default because its emulated by KVM * - enable LME and LMA per default on 64 bit KVM / #ifdef CONFIG_X86_64 static u64 __read_mostly efer_reserved_bits = ~((u64)(EFER_SCE \| EFER_LME \| EFER_LMA)); #else static u64 __read_mostly efer_reserved_bits = ~((u64)EFER_SCE); #endif #define VM_STAT(x) offsetof(struct kvm, stat.x), KVM_STAT_VM #define VCPU_STAT(x) offsetof(struct kvm_vcpu, stat.x), KVM_STAT_VCPU static void update_cr8_intercept(struct kvm_vcpu vcpu); static void process_nmi(struct kvm_vcpu vcpu); static void __kvm_set_rflags(struct kvm_vcpu vcpu, unsigned long rflags); struct kvm_x86_ops kvm_x86_ops; EXPORT_SYMBOL_GPL(kvm_x86_ops); static bool ignore_msrs = 0; module_param(ignore_msrs, bool, S_IRUGO \| S_IWUSR); unsigned int min_timer_period_us = 500; module_param(min_timer_period_us, uint, S_IRUGO \| S_IWUSR); bool kvm_has_tsc_control; EXPORT_SYMBOL_GPL(kvm_has_tsc_control); u32 kvm_max_guest_tsc_khz; EXPORT_SYMBOL_GPL(kvm_max_guest_tsc_khz); / tsc tolerance in parts per million - default to 1/2 of the NTP threshold / static u32 tsc_tolerance_ppm = 250; module_param(tsc_tolerance_ppm, uint, S_IRUGO \| S_IWUSR); static bool backwards_tsc_observed = false; #define KVM_NR_SHARED_MSRS 16 struct kvm_shared_msrs_global { int nr; u32 msrs[KVM_NR_SHARED_MSRS]; }; struct kvm_shared_msrs { struct user_return_notifier urn; bool registered; struct kvm_shared_msr_values { u64 host; u64 curr; } values[KVM_NR_SHARED_MSRS]; }; static struct kvm_shared_msrs_global __read_mostly shared_msrs_global; static struct kvm_shared_msrs __percpu shared_msrs; struct kvm_stats_debugfs_item debugfs_entries[] = { { "pf_fixed", VCPU_STAT(pf_fixed) }, { "pf_guest", VCPU_STAT(pf_guest) }, { "tlb_flush", VCPU_STAT(tlb_flush) }, { "invlpg", VCPU_STAT(invlpg) }, { "exits", VCPU_STAT(exits) }, { "io_exits", VCPU_STAT(io_exits) }, { "mmio_exits", VCPU_STAT(mmio_exits) }, { "signal_exits", VCPU_STAT(signal_exits) }, { "irq_window", VCPU_STAT(irq_window_exits) }, { "nmi_window", VCPU_STAT(nmi_window_exits) }, { "halt_exits", VCPU_STAT(halt_exits) }, { "halt_wakeup", VCPU_STAT(halt_wakeup) }, { "hypercalls", VCPU_STAT(hypercalls) }, { "request_irq", VCPU_STAT(request_irq_exits) }, { "irq_exits", VCPU_STAT(irq_exits) }, { "host_state_reload", VCPU_STAT(host_state_reload) }, { "efer_reload", VCPU_STAT(efer_reload) }, { "fpu_reload", VCPU_STAT(fpu_reload) }, { "insn_emulation", VCPU_STAT(insn_emulation) }, { "insn_emulation_fail", VCPU_STAT(insn_emulation_fail) }, { "irq_injections", VCPU_STAT(irq_injections) }, { "nmi_injections", VCPU_STAT(nmi_injections) }, { "mmu_shadow_zapped", VM_STAT(mmu_shadow_zapped) }, { "mmu_pte_write", VM_STAT(mmu_pte_write) }, { "mmu_pte_updated", VM_STAT(mmu_pte_updated) }, { "mmu_pde_zapped", VM_STAT(mmu_pde_zapped) }, { "mmu_flooded", VM_STAT(mmu_flooded) }, { "mmu_recycled", VM_STAT(mmu_recycled) }, { "mmu_cache_miss", VM_STAT(mmu_cache_miss) }, { "mmu_unsync", VM_STAT(mmu_unsync) }, { "remote_tlb_flush", VM_STAT(remote_tlb_flush) }, { "largepages", VM_STAT(lpages) }, { NULL } }; u64 __read_mostly host_xcr0; static int emulator_fix_hypercall(struct x86_emulate_ctxt ctxt); static inline void kvm_async_pf_hash_reset(struct kvm_vcpu vcpu) { int i; for (i = 0; i < roundup_pow_of_two(ASYNC_PF_PER_VCPU); i++) vcpu->arch.apf.gfns[i] = ~0; } static void kvm_on_user_return(struct user_return_notifier urn) { unsigned slot; struct kvm_shared_msrs locals = container_of(urn, struct kvm_shared_msrs, urn); struct kvm_shared_msr_values values; for (slot = 0; slot < shared_msrs_global.nr; ++slot) { values = &locals->values[slot]; if (values->host != values->curr) { wrmsrl(shared_msrs_global.msrs[slot], values->host); values->curr = values->host; } } locals->registered = false; user_return_notifier_unregister(urn); } static void shared_msr_update(unsigned slot, u32 msr) { u64 value; unsigned int cpu = smp_processor_id(); struct kvm_shared_msrs smsr = per_cpu_ptr(shared_msrs, cpu); /* only read, and nobody should modify it at this time, * so don't need lock / if (slot >= shared_msrs_global.nr) { printk(KERN_ERR "kvm: invalid MSR slot!"); return; } rdmsrl_safe(msr, &value); smsr->values[slot].host = value; smsr->values[slot].curr = value; } void kvm_define_shared_msr(unsigned slot, u32 msr) { BUG_ON(slot >= KVM_NR_SHARED_MSRS); if (slot >= shared_msrs_global.nr) shared_msrs_global.nr = slot + 1; shared_msrs_global.msrs[slot] = msr; / we need ensured the shared_msr_global have been updated / smp_wmb(); } EXPORT_SYMBOL_GPL(kvm_define_shared_msr); static void kvm_shared_msr_cpu_online(void) { unsigned i; for (i = 0; i < shared_msrs_global.nr; ++i) shared_msr_update(i, shared_msrs_global.msrs[i]); } void kvm_set_shared_msr(unsigned slot, u64 value, u64 mask) { unsigned int cpu = smp_processor_id(); struct kvm_shared_msrs smsr = per_cpu_ptr(shared_msrs, cpu); if (((value ^ smsr->values[slot].curr) & mask) == 0) return; smsr->values[slot].curr = value; wrmsrl(shared_msrs_global.msrs[slot], value); if (!smsr->registered) { smsr->urn.on_user_return = kvm_on_user_return; user_return_notifier_register(&smsr->urn); smsr->registered = true; } } EXPORT_SYMBOL_GPL(kvm_set_shared_msr); static void drop_user_return_notifiers(void) { unsigned int cpu = smp_processor_id(); struct kvm_shared_msrs smsr = per_cpu_ptr(shared_msrs, cpu); if (smsr->registered) kvm_on_user_return(&smsr->urn); } u64 kvm_get_apic_base(struct kvm_vcpu vcpu) { return vcpu->arch.apic_base; } EXPORT_SYMBOL_GPL(kvm_get_apic_base); int kvm_set_apic_base(struct kvm_vcpu vcpu, struct msr_data msr_info) { u64 old_state = vcpu->arch.apic_base & (MSR_IA32_APICBASE_ENABLE \| X2APIC_ENABLE); u64 new_state = msr_info->data & (MSR_IA32_APICBASE_ENABLE \| X2APIC_ENABLE); u64 reserved_bits = ((~0ULL) << cpuid_maxphyaddr(vcpu)) \| 0x2ff \| (guest_cpuid_has_x2apic(vcpu) ? 0 : X2APIC_ENABLE); if (!msr_info->host_initiated && ((msr_info->data & reserved_bits) != 0 \|\| new_state == X2APIC_ENABLE \|\| (new_state == MSR_IA32_APICBASE_ENABLE && old_state == (MSR_IA32_APICBASE_ENABLE \| X2APIC_ENABLE)) \|\| (new_state == (MSR_IA32_APICBASE_ENABLE \| X2APIC_ENABLE) && old_state == 0))) return 1; kvm_lapic_set_base(vcpu, msr_info->data); return 0; } EXPORT_SYMBOL_GPL(kvm_set_apic_base); asmlinkage __visible void kvm_spurious_fault(void) { /* Fault while not rebooting. We want the trace. / BUG(); } EXPORT_SYMBOL_GPL(kvm_spurious_fault); #define EXCPT_BENIGN 0 #define EXCPT_CONTRIBUTORY 1 #define EXCPT_PF 2 static int exception_class(int vector) { switch (vector) { case PF_VECTOR: return EXCPT_PF; case DE_VECTOR: case TS_VECTOR: case NP_VECTOR: case SS_VECTOR: case GP_VECTOR: return EXCPT_CONTRIBUTORY; default: break; } return EXCPT_BENIGN; } #define EXCPT_FAULT 0 #define EXCPT_TRAP 1 #define EXCPT_ABORT 2 #define EXCPT_INTERRUPT 3 static int exception_type(int vector) { unsigned int mask; if (WARN_ON(vector > 31 \|\| vector == NMI_VECTOR)) return EXCPT_INTERRUPT; mask = 1 << vector; / #DB is trap, as instruction watchpoints are handled elsewhere / if (mask & ((1 << DB_VECTOR) \| (1 << BP_VECTOR) \| (1 << OF_VECTOR))) return EXCPT_TRAP; if (mask & ((1 << DF_VECTOR) \| (1 << MC_VECTOR))) return EXCPT_ABORT; / Reserved exceptions will result in fault / return EXCPT_FAULT; } static void kvm_multiple_exception(struct kvm_vcpu vcpu, unsigned nr, bool has_error, u32 error_code, bool reinject) { u32 prev_nr; int class1, class2; kvm_make_request(KVM_REQ_EVENT, vcpu); if (!vcpu->arch.exception.pending) { queue: vcpu->arch.exception.pending = true; vcpu->arch.exception.has_error_code = has_error; vcpu->arch.exception.nr = nr; vcpu->arch.exception.error_code = error_code; vcpu->arch.exception.reinject = reinject; return; } /* to check exception / prev_nr = vcpu->arch.exception.nr; if (prev_nr == DF_VECTOR) { / triple fault -> shutdown / kvm_make_request(KVM_REQ_TRIPLE_FAULT, vcpu); return; } class1 = exception_class(prev_nr); class2 = exception_class(nr); if ((class1 == EXCPT_CONTRIBUTORY && class2 == EXCPT_CONTRIBUTORY) \|\| (class1 == EXCPT_PF && class2 != EXCPT_BENIGN)) { / generate double fault per SDM Table 5-5 / vcpu->arch.exception.pending = true; vcpu->arch.exception.has_error_code = true; vcpu->arch.exception.nr = DF_VECTOR; vcpu->arch.exception.error_code = 0; } else / replace previous exception with a new one in a hope that instruction re-execution will regenerate lost exception / goto queue; } void kvm_queue_exception(struct kvm_vcpu vcpu, unsigned nr) { kvm_multiple_exception(vcpu, nr, false, 0, false); } EXPORT_SYMBOL_GPL(kvm_queue_exception); void kvm_requeue_exception(struct kvm_vcpu vcpu, unsigned nr) { kvm_multiple_exception(vcpu, nr, false, 0, true); } EXPORT_SYMBOL_GPL(kvm_requeue_exception); void kvm_complete_insn_gp(struct kvm_vcpu vcpu, int err) { if (err) kvm_inject_gp(vcpu, 0); else kvm_x86_ops->skip_emulated_instruction(vcpu); } EXPORT_SYMBOL_GPL(kvm_complete_insn_gp); void kvm_inject_page_fault(struct kvm_vcpu vcpu, struct x86_exception fault) { ++vcpu->stat.pf_guest; vcpu->arch.cr2 = fault->address; kvm_queue_exception_e(vcpu, PF_VECTOR, fault->error_code); } EXPORT_SYMBOL_GPL(kvm_inject_page_fault); static bool kvm_propagate_fault(struct kvm_vcpu vcpu, struct x86_exception fault) { if (mmu_is_nested(vcpu) && !fault->nested_page_fault) vcpu->arch.nested_mmu.inject_page_fault(vcpu, fault); else vcpu->arch.mmu.inject_page_fault(vcpu, fault); return fault->nested_page_fault; } void kvm_inject_nmi(struct kvm_vcpu vcpu) { atomic_inc(&vcpu->arch.nmi_queued); kvm_make_request(KVM_REQ_NMI, vcpu); } EXPORT_SYMBOL_GPL(kvm_inject_nmi); void kvm_queue_exception_e(struct kvm_vcpu vcpu, unsigned nr, u32 error_code) { kvm_multiple_exception(vcpu, nr, true, error_code, false); } EXPORT_SYMBOL_GPL(kvm_queue_exception_e); void kvm_requeue_exception_e(struct kvm_vcpu vcpu, unsigned nr, u32 error_code) { kvm_multiple_exception(vcpu, nr, true, error_code, true); } EXPORT_SYMBOL_GPL(kvm_requeue_exception_e); / * Checks if cpl <= required_cpl; if true, return true. Otherwise queue * a #GP and return false. / bool kvm_require_cpl(struct kvm_vcpu vcpu, int required_cpl) { if (kvm_x86_ops->get_cpl(vcpu) <= required_cpl) return true; kvm_queue_exception_e(vcpu, GP_VECTOR, 0); return false; } EXPORT_SYMBOL_GPL(kvm_require_cpl); /* * This function will be used to read from the physical memory of the currently * running guest. The difference to kvm_read_guest_page is that this function * can read from guest physical or from the guest's guest physical memory. / int kvm_read_guest_page_mmu(struct kvm_vcpu vcpu, struct kvm_mmu mmu, gfn_t ngfn, void data, int offset, int len, u32 access) { struct x86_exception exception; gfn_t real_gfn; gpa_t ngpa; ngpa = gfn_to_gpa(ngfn); real_gfn = mmu->translate_gpa(vcpu, ngpa, access, &exception); if (real_gfn == UNMAPPED_GVA) return -EFAULT; real_gfn = gpa_to_gfn(real_gfn); return kvm_read_guest_page(vcpu->kvm, real_gfn, data, offset, len); } EXPORT_SYMBOL_GPL(kvm_read_guest_page_mmu); int kvm_read_nested_guest_page(struct kvm_vcpu vcpu, gfn_t gfn, void data, int offset, int len, u32 access) { return kvm_read_guest_page_mmu(vcpu, vcpu->arch.walk_mmu, gfn, data, offset, len, access); } /* * Load the pae pdptrs. Return true is they are all valid. / int load_pdptrs(struct kvm_vcpu vcpu, struct kvm_mmu mmu, unsigned long cr3) { gfn_t pdpt_gfn = cr3 >> PAGE_SHIFT; unsigned offset = ((cr3 & (PAGE_SIZE-1)) >> 5) << 2; int i; int ret; u64 pdpte[ARRAY_SIZE(mmu->pdptrs)]; ret = kvm_read_guest_page_mmu(vcpu, mmu, pdpt_gfn, pdpte, offset sizeof(u64), sizeof(pdpte), PFERR_USER_MASK\|PFERR_WRITE_MASK); if (ret < 0) { ret = 0; goto out; } for (i = 0; i < ARRAY_SIZE(pdpte); ++i) { if (is_present_gpte(pdpte[i]) && (pdpte[i] & vcpu->arch.mmu.rsvd_bits_mask[0][2])) { ret = 0; goto out; } } ret = 1; memcpy(mmu->pdptrs, pdpte, sizeof(mmu->pdptrs)); __set_bit(VCPU_EXREG_PDPTR, (unsigned long )&vcpu->arch.regs_avail); __set_bit(VCPU_EXREG_PDPTR, (unsigned long )&vcpu->arch.regs_dirty); out: return ret; } EXPORT_SYMBOL_GPL(load_pdptrs); static bool pdptrs_changed(struct kvm_vcpu vcpu) { u64 pdpte[ARRAY_SIZE(vcpu->arch.walk_mmu->pdptrs)]; bool changed = true; int offset; gfn_t gfn; int r; if (is_long_mode(vcpu) \|\| !is_pae(vcpu)) return false; if (!test_bit(VCPU_EXREG_PDPTR, (unsigned long )&vcpu->arch.regs_avail)) return true; gfn = (kvm_read_cr3(vcpu) & ~31u) >> PAGE_SHIFT; offset = (kvm_read_cr3(vcpu) & ~31u) & (PAGE_SIZE - 1); r = kvm_read_nested_guest_page(vcpu, gfn, pdpte, offset, sizeof(pdpte), PFERR_USER_MASK \| PFERR_WRITE_MASK); if (r < 0) goto out; changed = memcmp(pdpte, vcpu->arch.walk_mmu->pdptrs, sizeof(pdpte)) != 0; out: return changed; } int kvm_set_cr0(struct kvm_vcpu vcpu, unsigned long cr0) { unsigned long old_cr0 = kvm_read_cr0(vcpu); unsigned long update_bits = X86_CR0_PG \| X86_CR0_WP \| X86_CR0_CD \| X86_CR0_NW; cr0 \|= X86_CR0_ET; #ifdef CONFIG_X86_64 if (cr0 & 0xffffffff00000000UL) return 1; #endif cr0 &= ~CR0_RESERVED_BITS; if ((cr0 & X86_CR0_NW) && !(cr0 & X86_CR0_CD)) return 1; if ((cr0 & X86_CR0_PG) && !(cr0 & X86_CR0_PE)) return 1; if (!is_paging(vcpu) && (cr0 & X86_CR0_PG)) { #ifdef CONFIG_X86_64 if ((vcpu->arch.efer & EFER_LME)) { int cs_db, cs_l; if (!is_pae(vcpu)) return 1; kvm_x86_ops->get_cs_db_l_bits(vcpu, &cs_db, &cs_l); if (cs_l) return 1; } else #endif if (is_pae(vcpu) && !load_pdptrs(vcpu, vcpu->arch.walk_mmu, kvm_read_cr3(vcpu))) return 1; } if (!(cr0 & X86_CR0_PG) && kvm_read_cr4_bits(vcpu, X86_CR4_PCIDE)) return 1; kvm_x86_ops->set_cr0(vcpu, cr0); if ((cr0 ^ old_cr0) & X86_CR0_PG) { kvm_clear_async_pf_completion_queue(vcpu); kvm_async_pf_hash_reset(vcpu); } if ((cr0 ^ old_cr0) & update_bits) kvm_mmu_reset_context(vcpu); return 0; } EXPORT_SYMBOL_GPL(kvm_set_cr0); void kvm_lmsw(struct kvm_vcpu vcpu, unsigned long msw) { (void)kvm_set_cr0(vcpu, kvm_read_cr0_bits(vcpu, ~0x0eul) \| (msw & 0x0f)); } EXPORT_SYMBOL_GPL(kvm_lmsw); static void kvm_load_guest_xcr0(struct kvm_vcpu vcpu) { if (kvm_read_cr4_bits(vcpu, X86_CR4_OSXSAVE) && !vcpu->guest_xcr0_loaded) { / kvm_set_xcr() also depends on this / xsetbv(XCR_XFEATURE_ENABLED_MASK, vcpu->arch.xcr0); vcpu->guest_xcr0_loaded = 1; } } static void kvm_put_guest_xcr0(struct kvm_vcpu vcpu) { if (vcpu->guest_xcr0_loaded) { if (vcpu->arch.xcr0 != host_xcr0) xsetbv(XCR_XFEATURE_ENABLED_MASK, host_xcr0); vcpu->guest_xcr0_loaded = 0; } } int __kvm_set_xcr(struct kvm_vcpu vcpu, u32 index, u64 xcr) { u64 xcr0 = xcr; u64 old_xcr0 = vcpu->arch.xcr0; u64 valid_bits; / Only support XCR_XFEATURE_ENABLED_MASK(xcr0) now / if (index != XCR_XFEATURE_ENABLED_MASK) return 1; if (!(xcr0 & XSTATE_FP)) return 1; if ((xcr0 & XSTATE_YMM) && !(xcr0 & XSTATE_SSE)) return 1; / * Do not allow the guest to set bits that we do not support * saving. However, xcr0 bit 0 is always set, even if the * emulated CPU does not support XSAVE (see fx_init). / valid_bits = vcpu->arch.guest_supported_xcr0 \| XSTATE_FP; if (xcr0 & ~valid_bits) return 1; if ((!(xcr0 & XSTATE_BNDREGS)) != (!(xcr0 & XSTATE_BNDCSR))) return 1; kvm_put_guest_xcr0(vcpu); vcpu->arch.xcr0 = xcr0; if ((xcr0 ^ old_xcr0) & XSTATE_EXTEND_MASK) kvm_update_cpuid(vcpu); return 0; } int kvm_set_xcr(struct kvm_vcpu vcpu, u32 index, u64 xcr) { if (kvm_x86_ops->get_cpl(vcpu) != 0 \|\| __kvm_set_xcr(vcpu, index, xcr)) { kvm_inject_gp(vcpu, 0); return 1; } return 0; } EXPORT_SYMBOL_GPL(kvm_set_xcr); int kvm_set_cr4(struct kvm_vcpu vcpu, unsigned long cr4) { unsigned long old_cr4 = kvm_read_cr4(vcpu); unsigned long pdptr_bits = X86_CR4_PGE \| X86_CR4_PSE \| X86_CR4_PAE \| X86_CR4_SMEP; if (cr4 & CR4_RESERVED_BITS) return 1; if (!guest_cpuid_has_xsave(vcpu) && (cr4 & X86_CR4_OSXSAVE)) return 1; if (!guest_cpuid_has_smep(vcpu) && (cr4 & X86_CR4_SMEP)) return 1; if (!guest_cpuid_has_smap(vcpu) && (cr4 & X86_CR4_SMAP)) return 1; if (!guest_cpuid_has_fsgsbase(vcpu) && (cr4 & X86_CR4_FSGSBASE)) return 1; if (is_long_mode(vcpu)) { if (!(cr4 & X86_CR4_PAE)) return 1; } else if (is_paging(vcpu) && (cr4 & X86_CR4_PAE) && ((cr4 ^ old_cr4) & pdptr_bits) && !load_pdptrs(vcpu, vcpu->arch.walk_mmu, kvm_read_cr3(vcpu))) return 1; if ((cr4 & X86_CR4_PCIDE) && !(old_cr4 & X86_CR4_PCIDE)) { if (!guest_cpuid_has_pcid(vcpu)) return 1; / PCID can not be enabled when cr3[11:0]!=000H or EFER.LMA=0 / if ((kvm_read_cr3(vcpu) & X86_CR3_PCID_MASK) \|\| !is_long_mode(vcpu)) return 1; } if (kvm_x86_ops->set_cr4(vcpu, cr4)) return 1; if (((cr4 ^ old_cr4) & pdptr_bits) \|\| (!(cr4 & X86_CR4_PCIDE) && (old_cr4 & X86_CR4_PCIDE))) kvm_mmu_reset_context(vcpu); if ((cr4 ^ old_cr4) & X86_CR4_SMAP) update_permission_bitmask(vcpu, vcpu->arch.walk_mmu, false); if ((cr4 ^ old_cr4) & X86_CR4_OSXSAVE) kvm_update_cpuid(vcpu); return 0; } EXPORT_SYMBOL_GPL(kvm_set_cr4); int kvm_set_cr3(struct kvm_vcpu vcpu, unsigned long cr3) { if (cr3 == kvm_read_cr3(vcpu) && !pdptrs_changed(vcpu)) { kvm_mmu_sync_roots(vcpu); kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu); return 0; } if (is_long_mode(vcpu)) { if (cr3 & CR3_L_MODE_RESERVED_BITS) return 1; } else if (is_pae(vcpu) && is_paging(vcpu) && !load_pdptrs(vcpu, vcpu->arch.walk_mmu, cr3)) return 1; vcpu->arch.cr3 = cr3; __set_bit(VCPU_EXREG_CR3, (ulong )&vcpu->arch.regs_avail); kvm_mmu_new_cr3(vcpu); return 0; } EXPORT_SYMBOL_GPL(kvm_set_cr3); int kvm_set_cr8(struct kvm_vcpu vcpu, unsigned long cr8) { if (cr8 & CR8_RESERVED_BITS) return 1; if (irqchip_in_kernel(vcpu->kvm)) kvm_lapic_set_tpr(vcpu, cr8); else vcpu->arch.cr8 = cr8; return 0; } EXPORT_SYMBOL_GPL(kvm_set_cr8); unsigned long kvm_get_cr8(struct kvm_vcpu vcpu) { if (irqchip_in_kernel(vcpu->kvm)) return kvm_lapic_get_cr8(vcpu); else return vcpu->arch.cr8; } EXPORT_SYMBOL_GPL(kvm_get_cr8); static void kvm_update_dr6(struct kvm_vcpu vcpu) { if (!(vcpu->guest_debug & KVM_GUESTDBG_USE_HW_BP)) kvm_x86_ops->set_dr6(vcpu, vcpu->arch.dr6); } static void kvm_update_dr7(struct kvm_vcpu vcpu) { unsigned long dr7; if (vcpu->guest_debug & KVM_GUESTDBG_USE_HW_BP) dr7 = vcpu->arch.guest_debug_dr7; else dr7 = vcpu->arch.dr7; kvm_x86_ops->set_dr7(vcpu, dr7); vcpu->arch.switch_db_regs &= ~KVM_DEBUGREG_BP_ENABLED; if (dr7 & DR7_BP_EN_MASK) vcpu->arch.switch_db_regs \|= KVM_DEBUGREG_BP_ENABLED; } static u64 kvm_dr6_fixed(struct kvm_vcpu vcpu) { u64 fixed = DR6_FIXED_1; if (!guest_cpuid_has_rtm(vcpu)) fixed \|= DR6_RTM; return fixed; } static int __kvm_set_dr(struct kvm_vcpu vcpu, int dr, unsigned long val) { switch (dr) { case 0 ... 3: vcpu->arch.db[dr] = val; if (!(vcpu->guest_debug & KVM_GUESTDBG_USE_HW_BP)) vcpu->arch.eff_db[dr] = val; break; case 4: if (kvm_read_cr4_bits(vcpu, X86_CR4_DE)) return 1; / #UD / / fall through / case 6: if (val & 0xffffffff00000000ULL) return -1; / #GP / vcpu->arch.dr6 = (val & DR6_VOLATILE) \| kvm_dr6_fixed(vcpu); kvm_update_dr6(vcpu); break; case 5: if (kvm_read_cr4_bits(vcpu, X86_CR4_DE)) return 1; / #UD / / fall through / default: / 7 / if (val & 0xffffffff00000000ULL) return -1; / #GP / vcpu->arch.dr7 = (val & DR7_VOLATILE) \| DR7_FIXED_1; kvm_update_dr7(vcpu); break; } return 0; } int kvm_set_dr(struct kvm_vcpu vcpu, int dr, unsigned long val) { int res; res = __kvm_set_dr(vcpu, dr, val); if (res > 0) kvm_queue_exception(vcpu, UD_VECTOR); else if (res < 0) kvm_inject_gp(vcpu, 0); return res; } EXPORT_SYMBOL_GPL(kvm_set_dr); static int _kvm_get_dr(struct kvm_vcpu vcpu, int dr, unsigned long val) { switch (dr) { case 0 ... 3: val = vcpu->arch.db[dr]; break; case 4: if (kvm_read_cr4_bits(vcpu, X86_CR4_DE)) return 1; / fall through / case 6: if (vcpu->guest_debug & KVM_GUESTDBG_USE_HW_BP) val = vcpu->arch.dr6; else val = kvm_x86_ops->get_dr6(vcpu); break; case 5: if (kvm_read_cr4_bits(vcpu, X86_CR4_DE)) return 1; / fall through / default: / 7 / val = vcpu->arch.dr7; break; } return 0; } int kvm_get_dr(struct kvm_vcpu vcpu, int dr, unsigned long val) { if (_kvm_get_dr(vcpu, dr, val)) { kvm_queue_exception(vcpu, UD_VECTOR); return 1; } return 0; } EXPORT_SYMBOL_GPL(kvm_get_dr); bool kvm_rdpmc(struct kvm_vcpu vcpu) { u32 ecx = kvm_register_read(vcpu, VCPU_REGS_RCX); u64 data; int err; err = kvm_pmu_read_pmc(vcpu, ecx, &data); if (err) return err; kvm_register_write(vcpu, VCPU_REGS_RAX, (u32)data); kvm_register_write(vcpu, VCPU_REGS_RDX, data >> 32); return err; } EXPORT_SYMBOL_GPL(kvm_rdpmc); / * List of msr numbers which we expose to userspace through KVM_GET_MSRS * and KVM_SET_MSRS, and KVM_GET_MSR_INDEX_LIST. * * This list is modified at module load time to reflect the * capabilities of the host cpu. This capabilities test skips MSRs that are * kvm-specific. Those are put in the beginning of the list. / #define KVM_SAVE_MSRS_BEGIN 12 static u32 msrs_to_save[] = { MSR_KVM_SYSTEM_TIME, MSR_KVM_WALL_CLOCK, MSR_KVM_SYSTEM_TIME_NEW, MSR_KVM_WALL_CLOCK_NEW, HV_X64_MSR_GUEST_OS_ID, HV_X64_MSR_HYPERCALL, HV_X64_MSR_TIME_REF_COUNT, HV_X64_MSR_REFERENCE_TSC, HV_X64_MSR_APIC_ASSIST_PAGE, MSR_KVM_ASYNC_PF_EN, MSR_KVM_STEAL_TIME, MSR_KVM_PV_EOI_EN, MSR_IA32_SYSENTER_CS, MSR_IA32_SYSENTER_ESP, MSR_IA32_SYSENTER_EIP, MSR_STAR, #ifdef CONFIG_X86_64 MSR_CSTAR, MSR_KERNEL_GS_BASE, MSR_SYSCALL_MASK, MSR_LSTAR, #endif MSR_IA32_TSC, MSR_IA32_CR_PAT, MSR_VM_HSAVE_PA, MSR_IA32_FEATURE_CONTROL, MSR_IA32_BNDCFGS }; static unsigned num_msrs_to_save; static const u32 emulated_msrs[] = { MSR_IA32_TSC_ADJUST, MSR_IA32_TSCDEADLINE, MSR_IA32_MISC_ENABLE, MSR_IA32_MCG_STATUS, MSR_IA32_MCG_CTL, }; bool kvm_valid_efer(struct kvm_vcpu vcpu, u64 efer) { if (efer & efer_reserved_bits) return false; if (efer & EFER_FFXSR) { struct kvm_cpuid_entry2 feat; feat = kvm_find_cpuid_entry(vcpu, 0x80000001, 0); if (!feat \|\| !(feat->edx & bit(X86_FEATURE_FXSR_OPT))) return false; } if (efer & EFER_SVME) { struct kvm_cpuid_entry2 feat; feat = kvm_find_cpuid_entry(vcpu, 0x80000001, 0); if (!feat \|\| !(feat->ecx & bit(X86_FEATURE_SVM))) return false; } return true; } EXPORT_SYMBOL_GPL(kvm_valid_efer); static int set_efer(struct kvm_vcpu vcpu, u64 efer) { u64 old_efer = vcpu->arch.efer; if (!kvm_valid_efer(vcpu, efer)) return 1; if (is_paging(vcpu) && (vcpu->arch.efer & EFER_LME) != (efer & EFER_LME)) return 1; efer &= ~EFER_LMA; efer \|= vcpu->arch.efer & EFER_LMA; kvm_x86_ops->set_efer(vcpu, efer); / Update reserved bits / if ((efer ^ old_efer) & EFER_NX) kvm_mmu_reset_context(vcpu); return 0; } void kvm_enable_efer_bits(u64 mask) { efer_reserved_bits &= ~mask; } EXPORT_SYMBOL_GPL(kvm_enable_efer_bits); / * Writes msr value into into the appropriate "register". * Returns 0 on success, non-0 otherwise. * Assumes vcpu_load() was already called. / int kvm_set_msr(struct kvm_vcpu vcpu, struct msr_data msr) { switch (msr->index) { case MSR_FS_BASE: case MSR_GS_BASE: case MSR_KERNEL_GS_BASE: case MSR_CSTAR: case MSR_LSTAR: if (is_noncanonical_address(msr->data)) return 1; break; case MSR_IA32_SYSENTER_EIP: case MSR_IA32_SYSENTER_ESP: / * IA32_SYSENTER_ESP and IA32_SYSENTER_EIP cause #GP if * non-canonical address is written on Intel but not on * AMD (which ignores the top 32-bits, because it does * not implement 64-bit SYSENTER). * * 64-bit code should hence be able to write a non-canonical * value on AMD. Making the address canonical ensures that * vmentry does not fail on Intel after writing a non-canonical * value, and that something deterministic happens if the guest * invokes 64-bit SYSENTER. / msr->data = get_canonical(msr->data); } return kvm_x86_ops->set_msr(vcpu, msr); } EXPORT_SYMBOL_GPL(kvm_set_msr); / * Adapt set_msr() to msr_io()'s calling convention / static int do_set_msr(struct kvm_vcpu vcpu, unsigned index, u64 data) { struct msr_data msr; msr.data = data; msr.index = index; msr.host_initiated = true; return kvm_set_msr(vcpu, &msr); } #ifdef CONFIG_X86_64 struct pvclock_gtod_data { seqcount_t seq; struct { /* extract of a clocksource struct / int vclock_mode; cycle_t cycle_last; cycle_t mask; u32 mult; u32 shift; } clock; u64 boot_ns; u64 nsec_base; }; static struct pvclock_gtod_data pvclock_gtod_data; static void update_pvclock_gtod(struct timekeeper tk) { struct pvclock_gtod_data vdata = &pvclock_gtod_data; u64 boot_ns; boot_ns = ktime_to_ns(ktime_add(tk->tkr.base_mono, tk->offs_boot)); write_seqcount_begin(&vdata->seq); / copy pvclock gtod data / vdata->clock.vclock_mode = tk->tkr.clock->archdata.vclock_mode; vdata->clock.cycle_last = tk->tkr.cycle_last; vdata->clock.mask = tk->tkr.mask; vdata->clock.mult = tk->tkr.mult; vdata->clock.shift = tk->tkr.shift; vdata->boot_ns = boot_ns; vdata->nsec_base = tk->tkr.xtime_nsec; write_seqcount_end(&vdata->seq); } #endif static void kvm_write_wall_clock(struct kvm kvm, gpa_t wall_clock) { int version; int r; struct pvclock_wall_clock wc; struct timespec boot; if (!wall_clock) return; r = kvm_read_guest(kvm, wall_clock, &version, sizeof(version)); if (r) return; if (version & 1) ++version; /* first time write, random junk / ++version; kvm_write_guest(kvm, wall_clock, &version, sizeof(version)); / * The guest calculates current wall clock time by adding * system time (updated by kvm_guest_time_update below) to the * wall clock specified here. guest system time equals host * system time for us, thus we must fill in host boot time here. / getboottime(&boot); if (kvm->arch.kvmclock_offset) { struct timespec ts = ns_to_timespec(kvm->arch.kvmclock_offset); boot = timespec_sub(boot, ts); } wc.sec = boot.tv_sec; wc.nsec = boot.tv_nsec; wc.version = version; kvm_write_guest(kvm, wall_clock, &wc, sizeof(wc)); version++; kvm_write_guest(kvm, wall_clock, &version, sizeof(version)); } static uint32_t div_frac(uint32_t dividend, uint32_t divisor) { uint32_t quotient, remainder; / Don't try to replace with do_div(), this one calculates * "(dividend << 32) / divisor" / __asm__ ( "divl %4" : "=a" (quotient), "=d" (remainder) : "0" (0), "1" (dividend), "r" (divisor) ); return quotient; } static void kvm_get_time_scale(uint32_t scaled_khz, uint32_t base_khz, s8 pshift, u32 pmultiplier) { uint64_t scaled64; int32_t shift = 0; uint64_t tps64; uint32_t tps32; tps64 = base_khz 1000LL; scaled64 = scaled_khz * 1000LL; while (tps64 > scaled642 \|\| tps64 & 0xffffffff00000000ULL) { tps64 >>= 1; shift--; } tps32 = (uint32_t)tps64; while (tps32 <= scaled64 \|\| scaled64 & 0xffffffff00000000ULL) { if (scaled64 & 0xffffffff00000000ULL \|\| tps32 & 0x80000000) scaled64 >>= 1; else tps32 <<= 1; shift++; } pshift = shift; pmultiplier = div_frac(scaled64, tps32); pr_debug("%s: base_khz %u => %u, shift %d, mul %u\n", __func__, base_khz, scaled_khz, shift, pmultiplier); } static inline u64 get_kernel_ns(void) { return ktime_get_boot_ns(); } #ifdef CONFIG_X86_64 static atomic_t kvm_guest_has_master_clock = ATOMIC_INIT(0); #endif static DEFINE_PER_CPU(unsigned long, cpu_tsc_khz); unsigned long max_tsc_khz; static inline u64 nsec_to_cycles(struct kvm_vcpu vcpu, u64 nsec) { return pvclock_scale_delta(nsec, vcpu->arch.virtual_tsc_mult, vcpu->arch.virtual_tsc_shift); } static u32 adjust_tsc_khz(u32 khz, s32 ppm) { u64 v = (u64)khz (1000000 + ppm); do_div(v, 1000000); return v; } static void kvm_set_tsc_khz(struct kvm_vcpu vcpu, u32 this_tsc_khz) { u32 thresh_lo, thresh_hi; int use_scaling = 0; / tsc_khz can be zero if TSC calibration fails / if (this_tsc_khz == 0) return; / Compute a scale to convert nanoseconds in TSC cycles / kvm_get_time_scale(this_tsc_khz, NSEC_PER_SEC / 1000, &vcpu->arch.virtual_tsc_shift, &vcpu->arch.virtual_tsc_mult); vcpu->arch.virtual_tsc_khz = this_tsc_khz; / * Compute the variation in TSC rate which is acceptable * within the range of tolerance and decide if the * rate being applied is within that bounds of the hardware * rate. If so, no scaling or compensation need be done. / thresh_lo = adjust_tsc_khz(tsc_khz, -tsc_tolerance_ppm); thresh_hi = adjust_tsc_khz(tsc_khz, tsc_tolerance_ppm); if (this_tsc_khz < thresh_lo \|\| this_tsc_khz > thresh_hi) { pr_debug("kvm: requested TSC rate %u falls outside tolerance [%u,%u]\n", this_tsc_khz, thresh_lo, thresh_hi); use_scaling = 1; } kvm_x86_ops->set_tsc_khz(vcpu, this_tsc_khz, use_scaling); } static u64 compute_guest_tsc(struct kvm_vcpu vcpu, s64 kernel_ns) { u64 tsc = pvclock_scale_delta(kernel_ns-vcpu->arch.this_tsc_nsec, vcpu->arch.virtual_tsc_mult, vcpu->arch.virtual_tsc_shift); tsc += vcpu->arch.this_tsc_write; return tsc; } void kvm_track_tsc_matching(struct kvm_vcpu vcpu) { #ifdef CONFIG_X86_64 bool vcpus_matched; bool do_request = false; struct kvm_arch ka = &vcpu->kvm->arch; struct pvclock_gtod_data gtod = &pvclock_gtod_data; vcpus_matched = (ka->nr_vcpus_matched_tsc + 1 == atomic_read(&vcpu->kvm->online_vcpus)); if (vcpus_matched && gtod->clock.vclock_mode == VCLOCK_TSC) if (!ka->use_master_clock) do_request = 1; if (!vcpus_matched && ka->use_master_clock) do_request = 1; if (do_request) kvm_make_request(KVM_REQ_MASTERCLOCK_UPDATE, vcpu); trace_kvm_track_tsc(vcpu->vcpu_id, ka->nr_vcpus_matched_tsc, atomic_read(&vcpu->kvm->online_vcpus), ka->use_master_clock, gtod->clock.vclock_mode); #endif } static void update_ia32_tsc_adjust_msr(struct kvm_vcpu vcpu, s64 offset) { u64 curr_offset = kvm_x86_ops->read_tsc_offset(vcpu); vcpu->arch.ia32_tsc_adjust_msr += offset - curr_offset; } void kvm_write_tsc(struct kvm_vcpu vcpu, struct msr_data msr) { struct kvm kvm = vcpu->kvm; u64 offset, ns, elapsed; unsigned long flags; s64 usdiff; bool matched; bool already_matched; u64 data = msr->data; raw_spin_lock_irqsave(&kvm->arch.tsc_write_lock, flags); offset = kvm_x86_ops->compute_tsc_offset(vcpu, data); ns = get_kernel_ns(); elapsed = ns - kvm->arch.last_tsc_nsec; if (vcpu->arch.virtual_tsc_khz) { int faulted = 0; / n.b - signed multiplication and division required / usdiff = data - kvm->arch.last_tsc_write; #ifdef CONFIG_X86_64 usdiff = (usdiff 1000) / vcpu->arch.virtual_tsc_khz; #else /* do_div() only does unsigned / asm("1: idivl %[divisor]\n" "2: xor %%edx, %%edx\n" " movl $0, %[faulted]\n" "3:\n" ".section .fixup,\"ax\"\n" "4: movl $1, %[faulted]\n" " jmp 3b\n" ".previous\n" _ASM_EXTABLE(1b, 4b) : "=A"(usdiff), [faulted] "=r" (faulted) : "A"(usdiff 1000), [divisor] "rm"(vcpu->arch.virtual_tsc_khz)); #endif do_div(elapsed, 1000); usdiff -= elapsed; if (usdiff < 0) usdiff = -usdiff; /* idivl overflow => difference is larger than USEC_PER_SEC / if (faulted) usdiff = USEC_PER_SEC; } else usdiff = USEC_PER_SEC; / disable TSC match window below / / * Special case: TSC write with a small delta (1 second) of virtual * cycle time against real time is interpreted as an attempt to * synchronize the CPU. * * For a reliable TSC, we can match TSC offsets, and for an unstable * TSC, we add elapsed time in this computation. We could let the * compensation code attempt to catch up if we fall behind, but * it's better to try to match offsets from the beginning. / if (usdiff < USEC_PER_SEC && vcpu->arch.virtual_tsc_khz == kvm->arch.last_tsc_khz) { if (!check_tsc_unstable()) { offset = kvm->arch.cur_tsc_offset; pr_debug("kvm: matched tsc offset for %llu\n", data); } else { u64 delta = nsec_to_cycles(vcpu, elapsed); data += delta; offset = kvm_x86_ops->compute_tsc_offset(vcpu, data); pr_debug("kvm: adjusted tsc offset by %llu\n", delta); } matched = true; already_matched = (vcpu->arch.this_tsc_generation == kvm->arch.cur_tsc_generation); } else { / * We split periods of matched TSC writes into generations. * For each generation, we track the original measured * nanosecond time, offset, and write, so if TSCs are in * sync, we can match exact offset, and if not, we can match * exact software computation in compute_guest_tsc() * * These values are tracked in kvm->arch.cur_xxx variables. / kvm->arch.cur_tsc_generation++; kvm->arch.cur_tsc_nsec = ns; kvm->arch.cur_tsc_write = data; kvm->arch.cur_tsc_offset = offset; matched = false; pr_debug("kvm: new tsc generation %llu, clock %llu\n", kvm->arch.cur_tsc_generation, data); } / * We also track th most recent recorded KHZ, write and time to * allow the matching interval to be extended at each write. / kvm->arch.last_tsc_nsec = ns; kvm->arch.last_tsc_write = data; kvm->arch.last_tsc_khz = vcpu->arch.virtual_tsc_khz; vcpu->arch.last_guest_tsc = data; / Keep track of which generation this VCPU has synchronized to / vcpu->arch.this_tsc_generation = kvm->arch.cur_tsc_generation; vcpu->arch.this_tsc_nsec = kvm->arch.cur_tsc_nsec; vcpu->arch.this_tsc_write = kvm->arch.cur_tsc_write; if (guest_cpuid_has_tsc_adjust(vcpu) && !msr->host_initiated) update_ia32_tsc_adjust_msr(vcpu, offset); kvm_x86_ops->write_tsc_offset(vcpu, offset); raw_spin_unlock_irqrestore(&kvm->arch.tsc_write_lock, flags); spin_lock(&kvm->arch.pvclock_gtod_sync_lock); if (!matched) { kvm->arch.nr_vcpus_matched_tsc = 0; } else if (!already_matched) { kvm->arch.nr_vcpus_matched_tsc++; } kvm_track_tsc_matching(vcpu); spin_unlock(&kvm->arch.pvclock_gtod_sync_lock); } EXPORT_SYMBOL_GPL(kvm_write_tsc); #ifdef CONFIG_X86_64 static cycle_t read_tsc(void) { cycle_t ret; u64 last; / * Empirically, a fence (of type that depends on the CPU) * before rdtsc is enough to ensure that rdtsc is ordered * with respect to loads. The various CPU manuals are unclear * as to whether rdtsc can be reordered with later loads, * but no one has ever seen it happen. / rdtsc_barrier(); ret = (cycle_t)vget_cycles(); last = pvclock_gtod_data.clock.cycle_last; if (likely(ret >= last)) return ret; / * GCC likes to generate cmov here, but this branch is extremely * predictable (it's just a funciton of time and the likely is * very likely) and there's a data dependence, so force GCC * to generate a branch instead. I don't barrier() because * we don't actually need a barrier, and if this function * ever gets inlined it will generate worse code. / asm volatile (""); return last; } static inline u64 vgettsc(cycle_t cycle_now) { long v; struct pvclock_gtod_data gtod = &pvclock_gtod_data; cycle_now = read_tsc(); v = (cycle_now - gtod->clock.cycle_last) & gtod->clock.mask; return v gtod->clock.mult; } static int do_monotonic_boot(s64 t, cycle_t cycle_now) { struct pvclock_gtod_data gtod = &pvclock_gtod_data; unsigned long seq; int mode; u64 ns; do { seq = read_seqcount_begin(&gtod->seq); mode = gtod->clock.vclock_mode; ns = gtod->nsec_base; ns += vgettsc(cycle_now); ns >>= gtod->clock.shift; ns += gtod->boot_ns; } while (unlikely(read_seqcount_retry(&gtod->seq, seq))); t = ns; return mode; } /* returns true if host is using tsc clocksource / static bool kvm_get_time_and_clockread(s64 kernel_ns, cycle_t cycle_now) { / checked again under seqlock below / if (pvclock_gtod_data.clock.vclock_mode != VCLOCK_TSC) return false; return do_monotonic_boot(kernel_ns, cycle_now) == VCLOCK_TSC; } #endif / * * Assuming a stable TSC across physical CPUS, and a stable TSC * across virtual CPUs, the following condition is possible. * Each numbered line represents an event visible to both * CPUs at the next numbered event. * * "timespecX" represents host monotonic time. "tscX" represents * RDTSC value. * * VCPU0 on CPU0 \| VCPU1 on CPU1 * * 1. read timespec0,tsc0 * 2. \| timespec1 = timespec0 + N * \| tsc1 = tsc0 + M * 3. transition to guest \| transition to guest * 4. ret0 = timespec0 + (rdtsc - tsc0) \| * 5. \| ret1 = timespec1 + (rdtsc - tsc1) * \| ret1 = timespec0 + N + (rdtsc - (tsc0 + M)) * * Since ret0 update is visible to VCPU1 at time 5, to obey monotonicity: * * - ret0 < ret1 * - timespec0 + (rdtsc - tsc0) < timespec0 + N + (rdtsc - (tsc0 + M)) * ... * - 0 < N - M => M < N * * That is, when timespec0 != timespec1, M < N. Unfortunately that is not * always the case (the difference between two distinct xtime instances * might be smaller then the difference between corresponding TSC reads, * when updating guest vcpus pvclock areas). * * To avoid that problem, do not allow visibility of distinct * system_timestamp/tsc_timestamp values simultaneously: use a master * copy of host monotonic time values. Update that master copy * in lockstep. * * Rely on synchronization of host TSCs and guest TSCs for monotonicity. * / static void pvclock_update_vm_gtod_copy(struct kvm kvm) { #ifdef CONFIG_X86_64 struct kvm_arch ka = &kvm->arch; int vclock_mode; bool host_tsc_clocksource, vcpus_matched; vcpus_matched = (ka->nr_vcpus_matched_tsc + 1 == atomic_read(&kvm->online_vcpus)); / * If the host uses TSC clock, then passthrough TSC as stable * to the guest. / host_tsc_clocksource = kvm_get_time_and_clockread( &ka->master_kernel_ns, &ka->master_cycle_now); ka->use_master_clock = host_tsc_clocksource && vcpus_matched && !backwards_tsc_observed; if (ka->use_master_clock) atomic_set(&kvm_guest_has_master_clock, 1); vclock_mode = pvclock_gtod_data.clock.vclock_mode; trace_kvm_update_master_clock(ka->use_master_clock, vclock_mode, vcpus_matched); #endif } static void kvm_gen_update_masterclock(struct kvm kvm) { #ifdef CONFIG_X86_64 int i; struct kvm_vcpu vcpu; struct kvm_arch ka = &kvm->arch; spin_lock(&ka->pvclock_gtod_sync_lock); kvm_make_mclock_inprogress_request(kvm); /* no guest entries from this point / pvclock_update_vm_gtod_copy(kvm); kvm_for_each_vcpu(i, vcpu, kvm) kvm_make_request(KVM_REQ_CLOCK_UPDATE, vcpu); / guest entries allowed / kvm_for_each_vcpu(i, vcpu, kvm) clear_bit(KVM_REQ_MCLOCK_INPROGRESS, &vcpu->requests); spin_unlock(&ka->pvclock_gtod_sync_lock); #endif } static int kvm_guest_time_update(struct kvm_vcpu v) { unsigned long flags, this_tsc_khz; struct kvm_vcpu_arch vcpu = &v->arch; struct kvm_arch ka = &v->kvm->arch; s64 kernel_ns; u64 tsc_timestamp, host_tsc; struct pvclock_vcpu_time_info guest_hv_clock; u8 pvclock_flags; bool use_master_clock; kernel_ns = 0; host_tsc = 0; /* * If the host uses TSC clock, then passthrough TSC as stable * to the guest. / spin_lock(&ka->pvclock_gtod_sync_lock); use_master_clock = ka->use_master_clock; if (use_master_clock) { host_tsc = ka->master_cycle_now; kernel_ns = ka->master_kernel_ns; } spin_unlock(&ka->pvclock_gtod_sync_lock); / Keep irq disabled to prevent changes to the clock / local_irq_save(flags); this_tsc_khz = __this_cpu_read(cpu_tsc_khz); if (unlikely(this_tsc_khz == 0)) { local_irq_restore(flags); kvm_make_request(KVM_REQ_CLOCK_UPDATE, v); return 1; } if (!use_master_clock) { host_tsc = native_read_tsc(); kernel_ns = get_kernel_ns(); } tsc_timestamp = kvm_x86_ops->read_l1_tsc(v, host_tsc); / * We may have to catch up the TSC to match elapsed wall clock * time for two reasons, even if kvmclock is used. * 1) CPU could have been running below the maximum TSC rate * 2) Broken TSC compensation resets the base at each VCPU * entry to avoid unknown leaps of TSC even when running * again on the same CPU. This may cause apparent elapsed * time to disappear, and the guest to stand still or run * very slowly. / if (vcpu->tsc_catchup) { u64 tsc = compute_guest_tsc(v, kernel_ns); if (tsc > tsc_timestamp) { adjust_tsc_offset_guest(v, tsc - tsc_timestamp); tsc_timestamp = tsc; } } local_irq_restore(flags); if (!vcpu->pv_time_enabled) return 0; if (unlikely(vcpu->hw_tsc_khz != this_tsc_khz)) { kvm_get_time_scale(NSEC_PER_SEC / 1000, this_tsc_khz, &vcpu->hv_clock.tsc_shift, &vcpu->hv_clock.tsc_to_system_mul); vcpu->hw_tsc_khz = this_tsc_khz; } / With all the info we got, fill in the values / vcpu->hv_clock.tsc_timestamp = tsc_timestamp; vcpu->hv_clock.system_time = kernel_ns + v->kvm->arch.kvmclock_offset; vcpu->last_guest_tsc = tsc_timestamp; / * The interface expects us to write an even number signaling that the * update is finished. Since the guest won't see the intermediate * state, we just increase by 2 at the end. / vcpu->hv_clock.version += 2; if (unlikely(kvm_read_guest_cached(v->kvm, &vcpu->pv_time, &guest_hv_clock, sizeof(guest_hv_clock)))) return 0; / retain PVCLOCK_GUEST_STOPPED if set in guest copy / pvclock_flags = (guest_hv_clock.flags & PVCLOCK_GUEST_STOPPED); if (vcpu->pvclock_set_guest_stopped_request) { pvclock_flags \|= PVCLOCK_GUEST_STOPPED; vcpu->pvclock_set_guest_stopped_request = false; } / If the host uses TSC clocksource, then it is stable / if (use_master_clock) pvclock_flags \|= PVCLOCK_TSC_STABLE_BIT; vcpu->hv_clock.flags = pvclock_flags; kvm_write_guest_cached(v->kvm, &vcpu->pv_time, &vcpu->hv_clock, sizeof(vcpu->hv_clock)); return 0; } / * kvmclock updates which are isolated to a given vcpu, such as * vcpu->cpu migration, should not allow system_timestamp from * the rest of the vcpus to remain static. Otherwise ntp frequency * correction applies to one vcpu's system_timestamp but not * the others. * * So in those cases, request a kvmclock update for all vcpus. * We need to rate-limit these requests though, as they can * considerably slow guests that have a large number of vcpus. * The time for a remote vcpu to update its kvmclock is bound * by the delay we use to rate-limit the updates. / #define KVMCLOCK_UPDATE_DELAY msecs_to_jiffies(100) static void kvmclock_update_fn(struct work_struct work) { int i; struct delayed_work dwork = to_delayed_work(work); struct kvm_arch ka = container_of(dwork, struct kvm_arch, kvmclock_update_work); struct kvm kvm = container_of(ka, struct kvm, arch); struct kvm_vcpu vcpu; kvm_for_each_vcpu(i, vcpu, kvm) { kvm_make_request(KVM_REQ_CLOCK_UPDATE, vcpu); kvm_vcpu_kick(vcpu); } } static void kvm_gen_kvmclock_update(struct kvm_vcpu v) { struct kvm kvm = v->kvm; kvm_make_request(KVM_REQ_CLOCK_UPDATE, v); schedule_delayed_work(&kvm->arch.kvmclock_update_work, KVMCLOCK_UPDATE_DELAY); } #define KVMCLOCK_SYNC_PERIOD (300 * HZ) static void kvmclock_sync_fn(struct work_struct work) { struct delayed_work dwork = to_delayed_work(work); struct kvm_arch ka = container_of(dwork, struct kvm_arch, kvmclock_sync_work); struct kvm kvm = container_of(ka, struct kvm, arch); schedule_delayed_work(&kvm->arch.kvmclock_update_work, 0); schedule_delayed_work(&kvm->arch.kvmclock_sync_work, KVMCLOCK_SYNC_PERIOD); } static bool msr_mtrr_valid(unsigned msr) { switch (msr) { case 0x200 ... 0x200 + 2 * KVM_NR_VAR_MTRR - 1: case MSR_MTRRfix64K_00000: case MSR_MTRRfix16K_80000: case MSR_MTRRfix16K_A0000: case MSR_MTRRfix4K_C0000: case MSR_MTRRfix4K_C8000: case MSR_MTRRfix4K_D0000: case MSR_MTRRfix4K_D8000: case MSR_MTRRfix4K_E0000: case MSR_MTRRfix4K_E8000: case MSR_MTRRfix4K_F0000: case MSR_MTRRfix4K_F8000: case MSR_MTRRdefType: case MSR_IA32_CR_PAT: return true; case 0x2f8: return true; } return false; } static bool valid_pat_type(unsigned t) { return t < 8 && (1 << t) & 0xf3; /* 0, 1, 4, 5, 6, 7 / } static bool valid_mtrr_type(unsigned t) { return t < 8 && (1 << t) & 0x73; / 0, 1, 4, 5, 6 / } bool kvm_mtrr_valid(struct kvm_vcpu vcpu, u32 msr, u64 data) { int i; u64 mask; if (!msr_mtrr_valid(msr)) return false; if (msr == MSR_IA32_CR_PAT) { for (i = 0; i < 8; i++) if (!valid_pat_type((data >> (i * 8)) & 0xff)) return false; return true; } else if (msr == MSR_MTRRdefType) { if (data & ~0xcff) return false; return valid_mtrr_type(data & 0xff); } else if (msr >= MSR_MTRRfix64K_00000 && msr <= MSR_MTRRfix4K_F8000) { for (i = 0; i < 8 ; i++) if (!valid_mtrr_type((data >> (i * 8)) & 0xff)) return false; return true; } /* variable MTRRs / WARN_ON(!(msr >= 0x200 && msr < 0x200 + 2 KVM_NR_VAR_MTRR)); mask = (~0ULL) << cpuid_maxphyaddr(vcpu); if ((msr & 1) == 0) { /* MTRR base / if (!valid_mtrr_type(data & 0xff)) return false; mask \|= 0xf00; } else / MTRR mask / mask \|= 0x7ff; if (data & mask) { kvm_inject_gp(vcpu, 0); return false; } return true; } EXPORT_SYMBOL_GPL(kvm_mtrr_valid); static int set_msr_mtrr(struct kvm_vcpu vcpu, u32 msr, u64 data) { u64 p = (u64 )&vcpu->arch.mtrr_state.fixed_ranges; if (!kvm_mtrr_valid(vcpu, msr, data)) return 1; if (msr == MSR_MTRRdefType) { vcpu->arch.mtrr_state.def_type = data; vcpu->arch.mtrr_state.enabled = (data & 0xc00) >> 10; } else if (msr == MSR_MTRRfix64K_00000) p[0] = data; else if (msr == MSR_MTRRfix16K_80000 \|\| msr == MSR_MTRRfix16K_A0000) p[1 + msr - MSR_MTRRfix16K_80000] = data; else if (msr >= MSR_MTRRfix4K_C0000 && msr <= MSR_MTRRfix4K_F8000) p[3 + msr - MSR_MTRRfix4K_C0000] = data; else if (msr == MSR_IA32_CR_PAT) vcpu->arch.pat = data; else { /* Variable MTRRs / int idx, is_mtrr_mask; u64 pt; idx = (msr - 0x200) / 2; is_mtrr_mask = msr - 0x200 - 2 * idx; if (!is_mtrr_mask) pt = (u64 )&vcpu->arch.mtrr_state.var_ranges[idx].base_lo; else pt = (u64 )&vcpu->arch.mtrr_state.var_ranges[idx].mask_lo; pt = data; } kvm_mmu_reset_context(vcpu); return 0; } static int set_msr_mce(struct kvm_vcpu vcpu, u32 msr, u64 data) { u64 mcg_cap = vcpu->arch.mcg_cap; unsigned bank_num = mcg_cap & 0xff; switch (msr) { case MSR_IA32_MCG_STATUS: vcpu->arch.mcg_status = data; break; case MSR_IA32_MCG_CTL: if (!(mcg_cap & MCG_CTL_P)) return 1; if (data != 0 && data != ~(u64)0) return -1; vcpu->arch.mcg_ctl = data; break; default: if (msr >= MSR_IA32_MC0_CTL && msr < MSR_IA32_MCx_CTL(bank_num)) { u32 offset = msr - MSR_IA32_MC0_CTL; /* only 0 or all 1s can be written to IA32_MCi_CTL * some Linux kernels though clear bit 10 in bank 4 to * workaround a BIOS/GART TBL issue on AMD K8s, ignore * this to avoid an uncatched #GP in the guest / if ((offset & 0x3) == 0 && data != 0 && (data \| (1 << 10)) != ~(u64)0) return -1; vcpu->arch.mce_banks[offset] = data; break; } return 1; } return 0; } static int xen_hvm_config(struct kvm_vcpu vcpu, u64 data) { struct kvm kvm = vcpu->kvm; int lm = is_long_mode(vcpu); u8 blob_addr = lm ? (u8 )(long)kvm->arch.xen_hvm_config.blob_addr_64 : (u8 )(long)kvm->arch.xen_hvm_config.blob_addr_32; u8 blob_size = lm ? kvm->arch.xen_hvm_config.blob_size_64 : kvm->arch.xen_hvm_config.blob_size_32; u32 page_num = data & ~PAGE_MASK; u64 page_addr = data & PAGE_MASK; u8 page; int r; r = -E2BIG; if (page_num >= blob_size) goto out; r = -ENOMEM; page = memdup_user(blob_addr + (page_num PAGE_SIZE), PAGE_SIZE); if (IS_ERR(page)) { r = PTR_ERR(page); goto out; } if (kvm_write_guest(kvm, page_addr, page, PAGE_SIZE)) goto out_free; r = 0; out_free: kfree(page); out: return r; } static bool kvm_hv_hypercall_enabled(struct kvm kvm) { return kvm->arch.hv_hypercall & HV_X64_MSR_HYPERCALL_ENABLE; } static bool kvm_hv_msr_partition_wide(u32 msr) { bool r = false; switch (msr) { case HV_X64_MSR_GUEST_OS_ID: case HV_X64_MSR_HYPERCALL: case HV_X64_MSR_REFERENCE_TSC: case HV_X64_MSR_TIME_REF_COUNT: r = true; break; } return r; } static int set_msr_hyperv_pw(struct kvm_vcpu vcpu, u32 msr, u64 data) { struct kvm kvm = vcpu->kvm; switch (msr) { case HV_X64_MSR_GUEST_OS_ID: kvm->arch.hv_guest_os_id = data; / setting guest os id to zero disables hypercall page / if (!kvm->arch.hv_guest_os_id) kvm->arch.hv_hypercall &= ~HV_X64_MSR_HYPERCALL_ENABLE; break; case HV_X64_MSR_HYPERCALL: { u64 gfn; unsigned long addr; u8 instructions[4]; / if guest os id is not set hypercall should remain disabled / if (!kvm->arch.hv_guest_os_id) break; if (!(data & HV_X64_MSR_HYPERCALL_ENABLE)) { kvm->arch.hv_hypercall = data; break; } gfn = data >> HV_X64_MSR_HYPERCALL_PAGE_ADDRESS_SHIFT; addr = gfn_to_hva(kvm, gfn); if (kvm_is_error_hva(addr)) return 1; kvm_x86_ops->patch_hypercall(vcpu, instructions); ((unsigned char )instructions)[3] = 0xc3; /* ret / if (__copy_to_user((void __user )addr, instructions, 4)) return 1; kvm->arch.hv_hypercall = data; mark_page_dirty(kvm, gfn); break; } case HV_X64_MSR_REFERENCE_TSC: { u64 gfn; HV_REFERENCE_TSC_PAGE tsc_ref; memset(&tsc_ref, 0, sizeof(tsc_ref)); kvm->arch.hv_tsc_page = data; if (!(data & HV_X64_MSR_TSC_REFERENCE_ENABLE)) break; gfn = data >> HV_X64_MSR_TSC_REFERENCE_ADDRESS_SHIFT; if (kvm_write_guest(kvm, gfn << HV_X64_MSR_TSC_REFERENCE_ADDRESS_SHIFT, &tsc_ref, sizeof(tsc_ref))) return 1; mark_page_dirty(kvm, gfn); break; } default: vcpu_unimpl(vcpu, "HYPER-V unimplemented wrmsr: 0x%x " "data 0x%llx\n", msr, data); return 1; } return 0; } static int set_msr_hyperv(struct kvm_vcpu vcpu, u32 msr, u64 data) { switch (msr) { case HV_X64_MSR_APIC_ASSIST_PAGE: { u64 gfn; unsigned long addr; if (!(data & HV_X64_MSR_APIC_ASSIST_PAGE_ENABLE)) { vcpu->arch.hv_vapic = data; if (kvm_lapic_enable_pv_eoi(vcpu, 0)) return 1; break; } gfn = data >> HV_X64_MSR_APIC_ASSIST_PAGE_ADDRESS_SHIFT; addr = gfn_to_hva(vcpu->kvm, gfn); if (kvm_is_error_hva(addr)) return 1; if (__clear_user((void __user )addr, PAGE_SIZE)) return 1; vcpu->arch.hv_vapic = data; mark_page_dirty(vcpu->kvm, gfn); if (kvm_lapic_enable_pv_eoi(vcpu, gfn_to_gpa(gfn) \| KVM_MSR_ENABLED)) return 1; break; } case HV_X64_MSR_EOI: return kvm_hv_vapic_msr_write(vcpu, APIC_EOI, data); case HV_X64_MSR_ICR: return kvm_hv_vapic_msr_write(vcpu, APIC_ICR, data); case HV_X64_MSR_TPR: return kvm_hv_vapic_msr_write(vcpu, APIC_TASKPRI, data); default: vcpu_unimpl(vcpu, "HYPER-V unimplemented wrmsr: 0x%x " "data 0x%llx\n", msr, data); return 1; } return 0; } static int kvm_pv_enable_async_pf(struct kvm_vcpu vcpu, u64 data) { gpa_t gpa = data & ~0x3f; / Bits 2:5 are reserved, Should be zero / if (data & 0x3c) return 1; vcpu->arch.apf.msr_val = data; if (!(data & KVM_ASYNC_PF_ENABLED)) { kvm_clear_async_pf_completion_queue(vcpu); kvm_async_pf_hash_reset(vcpu); return 0; } if (kvm_gfn_to_hva_cache_init(vcpu->kvm, &vcpu->arch.apf.data, gpa, sizeof(u32))) return 1; vcpu->arch.apf.send_user_only = !(data & KVM_ASYNC_PF_SEND_ALWAYS); kvm_async_pf_wakeup_all(vcpu); return 0; } static void kvmclock_reset(struct kvm_vcpu vcpu) { vcpu->arch.pv_time_enabled = false; } static void accumulate_steal_time(struct kvm_vcpu vcpu) { u64 delta; if (!(vcpu->arch.st.msr_val & KVM_MSR_ENABLED)) return; delta = current->sched_info.run_delay - vcpu->arch.st.last_steal; vcpu->arch.st.last_steal = current->sched_info.run_delay; vcpu->arch.st.accum_steal = delta; } static void record_steal_time(struct kvm_vcpu vcpu) { if (!(vcpu->arch.st.msr_val & KVM_MSR_ENABLED)) return; if (unlikely(kvm_read_guest_cached(vcpu->kvm, &vcpu->arch.st.stime, &vcpu->arch.st.steal, sizeof(struct kvm_steal_time)))) return; vcpu->arch.st.steal.steal += vcpu->arch.st.accum_steal; vcpu->arch.st.steal.version += 2; vcpu->arch.st.accum_steal = 0; kvm_write_guest_cached(vcpu->kvm, &vcpu->arch.st.stime, &vcpu->arch.st.steal, sizeof(struct kvm_steal_time)); } int kvm_set_msr_common(struct kvm_vcpu vcpu, struct msr_data msr_info) { bool pr = false; u32 msr = msr_info->index; u64 data = msr_info->data; switch (msr) { case MSR_AMD64_NB_CFG: case MSR_IA32_UCODE_REV: case MSR_IA32_UCODE_WRITE: case MSR_VM_HSAVE_PA: case MSR_AMD64_PATCH_LOADER: case MSR_AMD64_BU_CFG2: break; case MSR_EFER: return set_efer(vcpu, data); case MSR_K7_HWCR: data &= ~(u64)0x40; /* ignore flush filter disable / data &= ~(u64)0x100; / ignore ignne emulation enable / data &= ~(u64)0x8; / ignore TLB cache disable / data &= ~(u64)0x40000; / ignore Mc status write enable / if (data != 0) { vcpu_unimpl(vcpu, "unimplemented HWCR wrmsr: 0x%llx\n", data); return 1; } break; case MSR_FAM10H_MMIO_CONF_BASE: if (data != 0) { vcpu_unimpl(vcpu, "unimplemented MMIO_CONF_BASE wrmsr: " "0x%llx\n", data); return 1; } break; case MSR_IA32_DEBUGCTLMSR: if (!data) { / We support the non-activated case already / break; } else if (data & ~(DEBUGCTLMSR_LBR \| DEBUGCTLMSR_BTF)) { / Values other than LBR and BTF are vendor-specific, thus reserved and should throw a #GP / return 1; } vcpu_unimpl(vcpu, "%s: MSR_IA32_DEBUGCTLMSR 0x%llx, nop\n", __func__, data); break; case 0x200 ... 0x2ff: return set_msr_mtrr(vcpu, msr, data); case MSR_IA32_APICBASE: return kvm_set_apic_base(vcpu, msr_info); case APIC_BASE_MSR ... APIC_BASE_MSR + 0x3ff: return kvm_x2apic_msr_write(vcpu, msr, data); case MSR_IA32_TSCDEADLINE: kvm_set_lapic_tscdeadline_msr(vcpu, data); break; case MSR_IA32_TSC_ADJUST: if (guest_cpuid_has_tsc_adjust(vcpu)) { if (!msr_info->host_initiated) { u64 adj = data - vcpu->arch.ia32_tsc_adjust_msr; kvm_x86_ops->adjust_tsc_offset(vcpu, adj, true); } vcpu->arch.ia32_tsc_adjust_msr = data; } break; case MSR_IA32_MISC_ENABLE: vcpu->arch.ia32_misc_enable_msr = data; break; case MSR_KVM_WALL_CLOCK_NEW: case MSR_KVM_WALL_CLOCK: vcpu->kvm->arch.wall_clock = data; kvm_write_wall_clock(vcpu->kvm, data); break; case MSR_KVM_SYSTEM_TIME_NEW: case MSR_KVM_SYSTEM_TIME: { u64 gpa_offset; kvmclock_reset(vcpu); vcpu->arch.time = data; kvm_make_request(KVM_REQ_GLOBAL_CLOCK_UPDATE, vcpu); / we verify if the enable bit is set... / if (!(data & 1)) break; gpa_offset = data & ~(PAGE_MASK \| 1); if (kvm_gfn_to_hva_cache_init(vcpu->kvm, &vcpu->arch.pv_time, data & ~1ULL, sizeof(struct pvclock_vcpu_time_info))) vcpu->arch.pv_time_enabled = false; else vcpu->arch.pv_time_enabled = true; break; } case MSR_KVM_ASYNC_PF_EN: if (kvm_pv_enable_async_pf(vcpu, data)) return 1; break; case MSR_KVM_STEAL_TIME: if (unlikely(!sched_info_on())) return 1; if (data & KVM_STEAL_RESERVED_MASK) return 1; if (kvm_gfn_to_hva_cache_init(vcpu->kvm, &vcpu->arch.st.stime, data & KVM_STEAL_VALID_BITS, sizeof(struct kvm_steal_time))) return 1; vcpu->arch.st.msr_val = data; if (!(data & KVM_MSR_ENABLED)) break; vcpu->arch.st.last_steal = current->sched_info.run_delay; preempt_disable(); accumulate_steal_time(vcpu); preempt_enable(); kvm_make_request(KVM_REQ_STEAL_UPDATE, vcpu); break; case MSR_KVM_PV_EOI_EN: if (kvm_lapic_enable_pv_eoi(vcpu, data)) return 1; break; case MSR_IA32_MCG_CTL: case MSR_IA32_MCG_STATUS: case MSR_IA32_MC0_CTL ... MSR_IA32_MCx_CTL(KVM_MAX_MCE_BANKS) - 1: return set_msr_mce(vcpu, msr, data); / Performance counters are not protected by a CPUID bit, * so we should check all of them in the generic path for the sake of * cross vendor migration. * Writing a zero into the event select MSRs disables them, * which we perfectly emulate ;-). Any other value should be at least * reported, some guests depend on them. / case MSR_K7_EVNTSEL0: case MSR_K7_EVNTSEL1: case MSR_K7_EVNTSEL2: case MSR_K7_EVNTSEL3: if (data != 0) vcpu_unimpl(vcpu, "unimplemented perfctr wrmsr: " "0x%x data 0x%llx\n", msr, data); break; / at least RHEL 4 unconditionally writes to the perfctr registers, * so we ignore writes to make it happy. / case MSR_K7_PERFCTR0: case MSR_K7_PERFCTR1: case MSR_K7_PERFCTR2: case MSR_K7_PERFCTR3: vcpu_unimpl(vcpu, "unimplemented perfctr wrmsr: " "0x%x data 0x%llx\n", msr, data); break; case MSR_P6_PERFCTR0: case MSR_P6_PERFCTR1: pr = true; case MSR_P6_EVNTSEL0: case MSR_P6_EVNTSEL1: if (kvm_pmu_msr(vcpu, msr)) return kvm_pmu_set_msr(vcpu, msr_info); if (pr \|\| data != 0) vcpu_unimpl(vcpu, "disabled perfctr wrmsr: " "0x%x data 0x%llx\n", msr, data); break; case MSR_K7_CLK_CTL: / * Ignore all writes to this no longer documented MSR. * Writes are only relevant for old K7 processors, * all pre-dating SVM, but a recommended workaround from * AMD for these chips. It is possible to specify the * affected processor models on the command line, hence * the need to ignore the workaround. / break; case HV_X64_MSR_GUEST_OS_ID ... HV_X64_MSR_SINT15: if (kvm_hv_msr_partition_wide(msr)) { int r; mutex_lock(&vcpu->kvm->lock); r = set_msr_hyperv_pw(vcpu, msr, data); mutex_unlock(&vcpu->kvm->lock); return r; } else return set_msr_hyperv(vcpu, msr, data); break; case MSR_IA32_BBL_CR_CTL3: / Drop writes to this legacy MSR -- see rdmsr * counterpart for further detail. / vcpu_unimpl(vcpu, "ignored wrmsr: 0x%x data %llx\n", msr, data); break; case MSR_AMD64_OSVW_ID_LENGTH: if (!guest_cpuid_has_osvw(vcpu)) return 1; vcpu->arch.osvw.length = data; break; case MSR_AMD64_OSVW_STATUS: if (!guest_cpuid_has_osvw(vcpu)) return 1; vcpu->arch.osvw.status = data; break; default: if (msr && (msr == vcpu->kvm->arch.xen_hvm_config.msr)) return xen_hvm_config(vcpu, data); if (kvm_pmu_msr(vcpu, msr)) return kvm_pmu_set_msr(vcpu, msr_info); if (!ignore_msrs) { vcpu_unimpl(vcpu, "unhandled wrmsr: 0x%x data %llx\n", msr, data); return 1; } else { vcpu_unimpl(vcpu, "ignored wrmsr: 0x%x data %llx\n", msr, data); break; } } return 0; } EXPORT_SYMBOL_GPL(kvm_set_msr_common); / * Reads an msr value (of 'msr_index') into 'pdata'. * Returns 0 on success, non-0 otherwise. * Assumes vcpu_load() was already called. / int kvm_get_msr(struct kvm_vcpu vcpu, u32 msr_index, u64 pdata) { return kvm_x86_ops->get_msr(vcpu, msr_index, pdata); } static int get_msr_mtrr(struct kvm_vcpu vcpu, u32 msr, u64 pdata) { u64 p = (u64 )&vcpu->arch.mtrr_state.fixed_ranges; if (!msr_mtrr_valid(msr)) return 1; if (msr == MSR_MTRRdefType) pdata = vcpu->arch.mtrr_state.def_type + (vcpu->arch.mtrr_state.enabled << 10); else if (msr == MSR_MTRRfix64K_00000) pdata = p[0]; else if (msr == MSR_MTRRfix16K_80000 \|\| msr == MSR_MTRRfix16K_A0000) pdata = p[1 + msr - MSR_MTRRfix16K_80000]; else if (msr >= MSR_MTRRfix4K_C0000 && msr <= MSR_MTRRfix4K_F8000) pdata = p[3 + msr - MSR_MTRRfix4K_C0000]; else if (msr == MSR_IA32_CR_PAT) pdata = vcpu->arch.pat; else { /* Variable MTRRs / int idx, is_mtrr_mask; u64 pt; idx = (msr - 0x200) / 2; is_mtrr_mask = msr - 0x200 - 2 * idx; if (!is_mtrr_mask) pt = (u64 )&vcpu->arch.mtrr_state.var_ranges[idx].base_lo; else pt = (u64 )&vcpu->arch.mtrr_state.var_ranges[idx].mask_lo; pdata = pt; } return 0; } static int get_msr_mce(struct kvm_vcpu vcpu, u32 msr, u64 pdata) { u64 data; u64 mcg_cap = vcpu->arch.mcg_cap; unsigned bank_num = mcg_cap & 0xff; switch (msr) { case MSR_IA32_P5_MC_ADDR: case MSR_IA32_P5_MC_TYPE: data = 0; break; case MSR_IA32_MCG_CAP: data = vcpu->arch.mcg_cap; break; case MSR_IA32_MCG_CTL: if (!(mcg_cap & MCG_CTL_P)) return 1; data = vcpu->arch.mcg_ctl; break; case MSR_IA32_MCG_STATUS: data = vcpu->arch.mcg_status; break; default: if (msr >= MSR_IA32_MC0_CTL && msr < MSR_IA32_MCx_CTL(bank_num)) { u32 offset = msr - MSR_IA32_MC0_CTL; data = vcpu->arch.mce_banks[offset]; break; } return 1; } pdata = data; return 0; } static int get_msr_hyperv_pw(struct kvm_vcpu vcpu, u32 msr, u64 pdata) { u64 data = 0; struct kvm kvm = vcpu->kvm; switch (msr) { case HV_X64_MSR_GUEST_OS_ID: data = kvm->arch.hv_guest_os_id; break; case HV_X64_MSR_HYPERCALL: data = kvm->arch.hv_hypercall; break; case HV_X64_MSR_TIME_REF_COUNT: { data = div_u64(get_kernel_ns() + kvm->arch.kvmclock_offset, 100); break; } case HV_X64_MSR_REFERENCE_TSC: data = kvm->arch.hv_tsc_page; break; default: vcpu_unimpl(vcpu, "Hyper-V unhandled rdmsr: 0x%x\n", msr); return 1; } pdata = data; return 0; } static int get_msr_hyperv(struct kvm_vcpu vcpu, u32 msr, u64 pdata) { u64 data = 0; switch (msr) { case HV_X64_MSR_VP_INDEX: { int r; struct kvm_vcpu v; kvm_for_each_vcpu(r, v, vcpu->kvm) { if (v == vcpu) { data = r; break; } } break; } case HV_X64_MSR_EOI: return kvm_hv_vapic_msr_read(vcpu, APIC_EOI, pdata); case HV_X64_MSR_ICR: return kvm_hv_vapic_msr_read(vcpu, APIC_ICR, pdata); case HV_X64_MSR_TPR: return kvm_hv_vapic_msr_read(vcpu, APIC_TASKPRI, pdata); case HV_X64_MSR_APIC_ASSIST_PAGE: data = vcpu->arch.hv_vapic; break; default: vcpu_unimpl(vcpu, "Hyper-V unhandled rdmsr: 0x%x\n", msr); return 1; } pdata = data; return 0; } int kvm_get_msr_common(struct kvm_vcpu vcpu, u32 msr, u64 pdata) { u64 data; switch (msr) { case MSR_IA32_PLATFORM_ID: case MSR_IA32_EBL_CR_POWERON: case MSR_IA32_DEBUGCTLMSR: case MSR_IA32_LASTBRANCHFROMIP: case MSR_IA32_LASTBRANCHTOIP: case MSR_IA32_LASTINTFROMIP: case MSR_IA32_LASTINTTOIP: case MSR_K8_SYSCFG: case MSR_K7_HWCR: case MSR_VM_HSAVE_PA: case MSR_K7_EVNTSEL0: case MSR_K7_EVNTSEL1: case MSR_K7_EVNTSEL2: case MSR_K7_EVNTSEL3: case MSR_K7_PERFCTR0: case MSR_K7_PERFCTR1: case MSR_K7_PERFCTR2: case MSR_K7_PERFCTR3: case MSR_K8_INT_PENDING_MSG: case MSR_AMD64_NB_CFG: case MSR_FAM10H_MMIO_CONF_BASE: case MSR_AMD64_BU_CFG2: data = 0; break; case MSR_P6_PERFCTR0: case MSR_P6_PERFCTR1: case MSR_P6_EVNTSEL0: case MSR_P6_EVNTSEL1: if (kvm_pmu_msr(vcpu, msr)) return kvm_pmu_get_msr(vcpu, msr, pdata); data = 0; break; case MSR_IA32_UCODE_REV: data = 0x100000000ULL; break; case MSR_MTRRcap: data = 0x500 \| KVM_NR_VAR_MTRR; break; case 0x200 ... 0x2ff: return get_msr_mtrr(vcpu, msr, pdata); case 0xcd: / fsb frequency / data = 3; break; / * MSR_EBC_FREQUENCY_ID * Conservative value valid for even the basic CPU models. * Models 0,1: 000 in bits 23:21 indicating a bus speed of * 100MHz, model 2 000 in bits 18:16 indicating 100MHz, * and 266MHz for model 3, or 4. Set Core Clock * Frequency to System Bus Frequency Ratio to 1 (bits * 31:24) even though these are only valid for CPU * models > 2, however guests may end up dividing or * multiplying by zero otherwise. / case MSR_EBC_FREQUENCY_ID: data = 1 << 24; break; case MSR_IA32_APICBASE: data = kvm_get_apic_base(vcpu); break; case APIC_BASE_MSR ... APIC_BASE_MSR + 0x3ff: return kvm_x2apic_msr_read(vcpu, msr, pdata); break; case MSR_IA32_TSCDEADLINE: data = kvm_get_lapic_tscdeadline_msr(vcpu); break; case MSR_IA32_TSC_ADJUST: data = (u64)vcpu->arch.ia32_tsc_adjust_msr; break; case MSR_IA32_MISC_ENABLE: data = vcpu->arch.ia32_misc_enable_msr; break; case MSR_IA32_PERF_STATUS: / TSC increment by tick / data = 1000ULL; / CPU multiplier / data \|= (((uint64_t)4ULL) << 40); break; case MSR_EFER: data = vcpu->arch.efer; break; case MSR_KVM_WALL_CLOCK: case MSR_KVM_WALL_CLOCK_NEW: data = vcpu->kvm->arch.wall_clock; break; case MSR_KVM_SYSTEM_TIME: case MSR_KVM_SYSTEM_TIME_NEW: data = vcpu->arch.time; break; case MSR_KVM_ASYNC_PF_EN: data = vcpu->arch.apf.msr_val; break; case MSR_KVM_STEAL_TIME: data = vcpu->arch.st.msr_val; break; case MSR_KVM_PV_EOI_EN: data = vcpu->arch.pv_eoi.msr_val; break; case MSR_IA32_P5_MC_ADDR: case MSR_IA32_P5_MC_TYPE: case MSR_IA32_MCG_CAP: case MSR_IA32_MCG_CTL: case MSR_IA32_MCG_STATUS: case MSR_IA32_MC0_CTL ... MSR_IA32_MCx_CTL(KVM_MAX_MCE_BANKS) - 1: return get_msr_mce(vcpu, msr, pdata); case MSR_K7_CLK_CTL: / * Provide expected ramp-up count for K7. All other * are set to zero, indicating minimum divisors for * every field. * * This prevents guest kernels on AMD host with CPU * type 6, model 8 and higher from exploding due to * the rdmsr failing. / data = 0x20000000; break; case HV_X64_MSR_GUEST_OS_ID ... HV_X64_MSR_SINT15: if (kvm_hv_msr_partition_wide(msr)) { int r; mutex_lock(&vcpu->kvm->lock); r = get_msr_hyperv_pw(vcpu, msr, pdata); mutex_unlock(&vcpu->kvm->lock); return r; } else return get_msr_hyperv(vcpu, msr, pdata); break; case MSR_IA32_BBL_CR_CTL3: / This legacy MSR exists but isn't fully documented in current * silicon. It is however accessed by winxp in very narrow * scenarios where it sets bit #19, itself documented as * a "reserved" bit. Best effort attempt to source coherent * read data here should the balance of the register be * interpreted by the guest: * * L2 cache control register 3: 64GB range, 256KB size, * enabled, latency 0x1, configured / data = 0xbe702111; break; case MSR_AMD64_OSVW_ID_LENGTH: if (!guest_cpuid_has_osvw(vcpu)) return 1; data = vcpu->arch.osvw.length; break; case MSR_AMD64_OSVW_STATUS: if (!guest_cpuid_has_osvw(vcpu)) return 1; data = vcpu->arch.osvw.status; break; default: if (kvm_pmu_msr(vcpu, msr)) return kvm_pmu_get_msr(vcpu, msr, pdata); if (!ignore_msrs) { vcpu_unimpl(vcpu, "unhandled rdmsr: 0x%x\n", msr); return 1; } else { vcpu_unimpl(vcpu, "ignored rdmsr: 0x%x\n", msr); data = 0; } break; } pdata = data; return 0; } EXPORT_SYMBOL_GPL(kvm_get_msr_common); /* * Read or write a bunch of msrs. All parameters are kernel addresses. * * @return number of msrs set successfully. / static int __msr_io(struct kvm_vcpu vcpu, struct kvm_msrs msrs, struct kvm_msr_entry entries, int (do_msr)(struct kvm_vcpu vcpu, unsigned index, u64 data)) { int i, idx; idx = srcu_read_lock(&vcpu->kvm->srcu); for (i = 0; i < msrs->nmsrs; ++i) if (do_msr(vcpu, entries[i].index, &entries[i].data)) break; srcu_read_unlock(&vcpu->kvm->srcu, idx); return i; } / * Read or write a bunch of msrs. Parameters are user addresses. * * @return number of msrs set successfully. / static int msr_io(struct kvm_vcpu vcpu, struct kvm_msrs __user user_msrs, int (do_msr)(struct kvm_vcpu vcpu, unsigned index, u64 data), int writeback) { struct kvm_msrs msrs; struct kvm_msr_entry entries; int r, n; unsigned size; r = -EFAULT; if (copy_from_user(&msrs, user_msrs, sizeof msrs)) goto out; r = -E2BIG; if (msrs.nmsrs >= MAX_IO_MSRS) goto out; size = sizeof(struct kvm_msr_entry) msrs.nmsrs; entries = memdup_user(user_msrs->entries, size); if (IS_ERR(entries)) { r = PTR_ERR(entries); goto out; } r = n = __msr_io(vcpu, &msrs, entries, do_msr); if (r < 0) goto out_free; r = -EFAULT; if (writeback && copy_to_user(user_msrs->entries, entries, size)) goto out_free; r = n; out_free: kfree(entries); out: return r; } int kvm_vm_ioctl_check_extension(struct kvm kvm, long ext) { int r; switch (ext) { case KVM_CAP_IRQCHIP: case KVM_CAP_HLT: case KVM_CAP_MMU_SHADOW_CACHE_CONTROL: case KVM_CAP_SET_TSS_ADDR: case KVM_CAP_EXT_CPUID: case KVM_CAP_EXT_EMUL_CPUID: case KVM_CAP_CLOCKSOURCE: case KVM_CAP_PIT: case KVM_CAP_NOP_IO_DELAY: case KVM_CAP_MP_STATE: case KVM_CAP_SYNC_MMU: case KVM_CAP_USER_NMI: case KVM_CAP_REINJECT_CONTROL: case KVM_CAP_IRQ_INJECT_STATUS: case KVM_CAP_IRQFD: case KVM_CAP_IOEVENTFD: case KVM_CAP_IOEVENTFD_NO_LENGTH: case KVM_CAP_PIT2: case KVM_CAP_PIT_STATE2: case KVM_CAP_SET_IDENTITY_MAP_ADDR: case KVM_CAP_XEN_HVM: case KVM_CAP_ADJUST_CLOCK: case KVM_CAP_VCPU_EVENTS: case KVM_CAP_HYPERV: case KVM_CAP_HYPERV_VAPIC: case KVM_CAP_HYPERV_SPIN: case KVM_CAP_PCI_SEGMENT: case KVM_CAP_DEBUGREGS: case KVM_CAP_X86_ROBUST_SINGLESTEP: case KVM_CAP_XSAVE: case KVM_CAP_ASYNC_PF: case KVM_CAP_GET_TSC_KHZ: case KVM_CAP_KVMCLOCK_CTRL: case KVM_CAP_READONLY_MEM: case KVM_CAP_HYPERV_TIME: case KVM_CAP_IOAPIC_POLARITY_IGNORED: #ifdef CONFIG_KVM_DEVICE_ASSIGNMENT case KVM_CAP_ASSIGN_DEV_IRQ: case KVM_CAP_PCI_2_3: #endif r = 1; break; case KVM_CAP_COALESCED_MMIO: r = KVM_COALESCED_MMIO_PAGE_OFFSET; break; case KVM_CAP_VAPIC: r = !kvm_x86_ops->cpu_has_accelerated_tpr(); break; case KVM_CAP_NR_VCPUS: r = KVM_SOFT_MAX_VCPUS; break; case KVM_CAP_MAX_VCPUS: r = KVM_MAX_VCPUS; break; case KVM_CAP_NR_MEMSLOTS: r = KVM_USER_MEM_SLOTS; break; case KVM_CAP_PV_MMU: / obsolete / r = 0; break; #ifdef CONFIG_KVM_DEVICE_ASSIGNMENT case KVM_CAP_IOMMU: r = iommu_present(&pci_bus_type); break; #endif case KVM_CAP_MCE: r = KVM_MAX_MCE_BANKS; break; case KVM_CAP_XCRS: r = cpu_has_xsave; break; case KVM_CAP_TSC_CONTROL: r = kvm_has_tsc_control; break; case KVM_CAP_TSC_DEADLINE_TIMER: r = boot_cpu_has(X86_FEATURE_TSC_DEADLINE_TIMER); break; default: r = 0; break; } return r; } long kvm_arch_dev_ioctl(struct file filp, unsigned int ioctl, unsigned long arg) { void __user argp = (void __user )arg; long r; switch (ioctl) { case KVM_GET_MSR_INDEX_LIST: { struct kvm_msr_list __user user_msr_list = argp; struct kvm_msr_list msr_list; unsigned n; r = -EFAULT; if (copy_from_user(&msr_list, user_msr_list, sizeof msr_list)) goto out; n = msr_list.nmsrs; msr_list.nmsrs = num_msrs_to_save + ARRAY_SIZE(emulated_msrs); if (copy_to_user(user_msr_list, &msr_list, sizeof msr_list)) goto out; r = -E2BIG; if (n < msr_list.nmsrs) goto out; r = -EFAULT; if (copy_to_user(user_msr_list->indices, &msrs_to_save, num_msrs_to_save sizeof(u32))) goto out; if (copy_to_user(user_msr_list->indices + num_msrs_to_save, &emulated_msrs, ARRAY_SIZE(emulated_msrs) * sizeof(u32))) goto out; r = 0; break; } case KVM_GET_SUPPORTED_CPUID: case KVM_GET_EMULATED_CPUID: { struct kvm_cpuid2 __user cpuid_arg = argp; struct kvm_cpuid2 cpuid; r = -EFAULT; if (copy_from_user(&cpuid, cpuid_arg, sizeof cpuid)) goto out; r = kvm_dev_ioctl_get_cpuid(&cpuid, cpuid_arg->entries, ioctl); if (r) goto out; r = -EFAULT; if (copy_to_user(cpuid_arg, &cpuid, sizeof cpuid)) goto out; r = 0; break; } case KVM_X86_GET_MCE_CAP_SUPPORTED: { u64 mce_cap; mce_cap = KVM_MCE_CAP_SUPPORTED; r = -EFAULT; if (copy_to_user(argp, &mce_cap, sizeof mce_cap)) goto out; r = 0; break; } default: r = -EINVAL; } out: return r; } static void wbinvd_ipi(void garbage) { wbinvd(); } static bool need_emulate_wbinvd(struct kvm_vcpu vcpu) { return kvm_arch_has_noncoherent_dma(vcpu->kvm); } void kvm_arch_vcpu_load(struct kvm_vcpu vcpu, int cpu) { /* Address WBINVD may be executed by guest / if (need_emulate_wbinvd(vcpu)) { if (kvm_x86_ops->has_wbinvd_exit()) cpumask_set_cpu(cpu, vcpu->arch.wbinvd_dirty_mask); else if (vcpu->cpu != -1 && vcpu->cpu != cpu) smp_call_function_single(vcpu->cpu, wbinvd_ipi, NULL, 1); } kvm_x86_ops->vcpu_load(vcpu, cpu); / Apply any externally detected TSC adjustments (due to suspend) / if (unlikely(vcpu->arch.tsc_offset_adjustment)) { adjust_tsc_offset_host(vcpu, vcpu->arch.tsc_offset_adjustment); vcpu->arch.tsc_offset_adjustment = 0; kvm_make_request(KVM_REQ_CLOCK_UPDATE, vcpu); } if (unlikely(vcpu->cpu != cpu) \|\| check_tsc_unstable()) { s64 tsc_delta = !vcpu->arch.last_host_tsc ? 0 : native_read_tsc() - vcpu->arch.last_host_tsc; if (tsc_delta < 0) mark_tsc_unstable("KVM discovered backwards TSC"); if (check_tsc_unstable()) { u64 offset = kvm_x86_ops->compute_tsc_offset(vcpu, vcpu->arch.last_guest_tsc); kvm_x86_ops->write_tsc_offset(vcpu, offset); vcpu->arch.tsc_catchup = 1; } / * On a host with synchronized TSC, there is no need to update * kvmclock on vcpu->cpu migration / if (!vcpu->kvm->arch.use_master_clock \|\| vcpu->cpu == -1) kvm_make_request(KVM_REQ_GLOBAL_CLOCK_UPDATE, vcpu); if (vcpu->cpu != cpu) kvm_migrate_timers(vcpu); vcpu->cpu = cpu; } accumulate_steal_time(vcpu); kvm_make_request(KVM_REQ_STEAL_UPDATE, vcpu); } void kvm_arch_vcpu_put(struct kvm_vcpu vcpu) { kvm_x86_ops->vcpu_put(vcpu); kvm_put_guest_fpu(vcpu); vcpu->arch.last_host_tsc = native_read_tsc(); } static int kvm_vcpu_ioctl_get_lapic(struct kvm_vcpu vcpu, struct kvm_lapic_state s) { kvm_x86_ops->sync_pir_to_irr(vcpu); memcpy(s->regs, vcpu->arch.apic->regs, sizeof s); return 0; } static int kvm_vcpu_ioctl_set_lapic(struct kvm_vcpu vcpu, struct kvm_lapic_state s) { kvm_apic_post_state_restore(vcpu, s); update_cr8_intercept(vcpu); return 0; } static int kvm_vcpu_ioctl_interrupt(struct kvm_vcpu vcpu, struct kvm_interrupt irq) { if (irq->irq >= KVM_NR_INTERRUPTS) return -EINVAL; if (irqchip_in_kernel(vcpu->kvm)) return -ENXIO; kvm_queue_interrupt(vcpu, irq->irq, false); kvm_make_request(KVM_REQ_EVENT, vcpu); return 0; } static int kvm_vcpu_ioctl_nmi(struct kvm_vcpu vcpu) { kvm_inject_nmi(vcpu); return 0; } static int vcpu_ioctl_tpr_access_reporting(struct kvm_vcpu vcpu, struct kvm_tpr_access_ctl tac) { if (tac->flags) return -EINVAL; vcpu->arch.tpr_access_reporting = !!tac->enabled; return 0; } static int kvm_vcpu_ioctl_x86_setup_mce(struct kvm_vcpu vcpu, u64 mcg_cap) { int r; unsigned bank_num = mcg_cap & 0xff, bank; r = -EINVAL; if (!bank_num \|\| bank_num >= KVM_MAX_MCE_BANKS) goto out; if (mcg_cap & ~(KVM_MCE_CAP_SUPPORTED \| 0xff \| 0xff0000)) goto out; r = 0; vcpu->arch.mcg_cap = mcg_cap; / Init IA32_MCG_CTL to all 1s / if (mcg_cap & MCG_CTL_P) vcpu->arch.mcg_ctl = ~(u64)0; / Init IA32_MCi_CTL to all 1s / for (bank = 0; bank < bank_num; bank++) vcpu->arch.mce_banks[bank4] = ~(u64)0; out: return r; } static int kvm_vcpu_ioctl_x86_set_mce(struct kvm_vcpu vcpu, struct kvm_x86_mce mce) { u64 mcg_cap = vcpu->arch.mcg_cap; unsigned bank_num = mcg_cap & 0xff; u64 banks = vcpu->arch.mce_banks; if (mce->bank >= bank_num \|\| !(mce->status & MCI_STATUS_VAL)) return -EINVAL; / * if IA32_MCG_CTL is not all 1s, the uncorrected error * reporting is disabled / if ((mce->status & MCI_STATUS_UC) && (mcg_cap & MCG_CTL_P) && vcpu->arch.mcg_ctl != ~(u64)0) return 0; banks += 4 mce->bank; /* * if IA32_MCi_CTL is not all 1s, the uncorrected error * reporting is disabled for the bank / if ((mce->status & MCI_STATUS_UC) && banks[0] != ~(u64)0) return 0; if (mce->status & MCI_STATUS_UC) { if ((vcpu->arch.mcg_status & MCG_STATUS_MCIP) \|\| !kvm_read_cr4_bits(vcpu, X86_CR4_MCE)) { kvm_make_request(KVM_REQ_TRIPLE_FAULT, vcpu); return 0; } if (banks[1] & MCI_STATUS_VAL) mce->status \|= MCI_STATUS_OVER; banks[2] = mce->addr; banks[3] = mce->misc; vcpu->arch.mcg_status = mce->mcg_status; banks[1] = mce->status; kvm_queue_exception(vcpu, MC_VECTOR); } else if (!(banks[1] & MCI_STATUS_VAL) \|\| !(banks[1] & MCI_STATUS_UC)) { if (banks[1] & MCI_STATUS_VAL) mce->status \|= MCI_STATUS_OVER; banks[2] = mce->addr; banks[3] = mce->misc; banks[1] = mce->status; } else banks[1] \|= MCI_STATUS_OVER; return 0; } static void kvm_vcpu_ioctl_x86_get_vcpu_events(struct kvm_vcpu vcpu, struct kvm_vcpu_events events) { process_nmi(vcpu); events->exception.injected = vcpu->arch.exception.pending && !kvm_exception_is_soft(vcpu->arch.exception.nr); events->exception.nr = vcpu->arch.exception.nr; events->exception.has_error_code = vcpu->arch.exception.has_error_code; events->exception.pad = 0; events->exception.error_code = vcpu->arch.exception.error_code; events->interrupt.injected = vcpu->arch.interrupt.pending && !vcpu->arch.interrupt.soft; events->interrupt.nr = vcpu->arch.interrupt.nr; events->interrupt.soft = 0; events->interrupt.shadow = kvm_x86_ops->get_interrupt_shadow(vcpu); events->nmi.injected = vcpu->arch.nmi_injected; events->nmi.pending = vcpu->arch.nmi_pending != 0; events->nmi.masked = kvm_x86_ops->get_nmi_mask(vcpu); events->nmi.pad = 0; events->sipi_vector = 0; / never valid when reporting to user space / events->flags = (KVM_VCPUEVENT_VALID_NMI_PENDING \| KVM_VCPUEVENT_VALID_SHADOW); memset(&events->reserved, 0, sizeof(events->reserved)); } static int kvm_vcpu_ioctl_x86_set_vcpu_events(struct kvm_vcpu vcpu, struct kvm_vcpu_events events) { if (events->flags & ~(KVM_VCPUEVENT_VALID_NMI_PENDING \| KVM_VCPUEVENT_VALID_SIPI_VECTOR \| KVM_VCPUEVENT_VALID_SHADOW)) return -EINVAL; process_nmi(vcpu); vcpu->arch.exception.pending = events->exception.injected; vcpu->arch.exception.nr = events->exception.nr; vcpu->arch.exception.has_error_code = events->exception.has_error_code; vcpu->arch.exception.error_code = events->exception.error_code; vcpu->arch.interrupt.pending = events->interrupt.injected; vcpu->arch.interrupt.nr = events->interrupt.nr; vcpu->arch.interrupt.soft = events->interrupt.soft; if (events->flags & KVM_VCPUEVENT_VALID_SHADOW) kvm_x86_ops->set_interrupt_shadow(vcpu, events->interrupt.shadow); vcpu->arch.nmi_injected = events->nmi.injected; if (events->flags & KVM_VCPUEVENT_VALID_NMI_PENDING) vcpu->arch.nmi_pending = events->nmi.pending; kvm_x86_ops->set_nmi_mask(vcpu, events->nmi.masked); if (events->flags & KVM_VCPUEVENT_VALID_SIPI_VECTOR && kvm_vcpu_has_lapic(vcpu)) vcpu->arch.apic->sipi_vector = events->sipi_vector; kvm_make_request(KVM_REQ_EVENT, vcpu); return 0; } static void kvm_vcpu_ioctl_x86_get_debugregs(struct kvm_vcpu vcpu, struct kvm_debugregs dbgregs) { unsigned long val; memcpy(dbgregs->db, vcpu->arch.db, sizeof(vcpu->arch.db)); _kvm_get_dr(vcpu, 6, &val); dbgregs->dr6 = val; dbgregs->dr7 = vcpu->arch.dr7; dbgregs->flags = 0; memset(&dbgregs->reserved, 0, sizeof(dbgregs->reserved)); } static int kvm_vcpu_ioctl_x86_set_debugregs(struct kvm_vcpu vcpu, struct kvm_debugregs dbgregs) { if (dbgregs->flags) return -EINVAL; memcpy(vcpu->arch.db, dbgregs->db, sizeof(vcpu->arch.db)); vcpu->arch.dr6 = dbgregs->dr6; kvm_update_dr6(vcpu); vcpu->arch.dr7 = dbgregs->dr7; kvm_update_dr7(vcpu); return 0; } static void kvm_vcpu_ioctl_x86_get_xsave(struct kvm_vcpu vcpu, struct kvm_xsave guest_xsave) { if (cpu_has_xsave) { memcpy(guest_xsave->region, &vcpu->arch.guest_fpu.state->xsave, vcpu->arch.guest_xstate_size); (u64 )&guest_xsave->region[XSAVE_HDR_OFFSET / sizeof(u32)] &= vcpu->arch.guest_supported_xcr0 \| XSTATE_FPSSE; } else { memcpy(guest_xsave->region, &vcpu->arch.guest_fpu.state->fxsave, sizeof(struct i387_fxsave_struct)); (u64 )&guest_xsave->region[XSAVE_HDR_OFFSET / sizeof(u32)] = XSTATE_FPSSE; } } static int kvm_vcpu_ioctl_x86_set_xsave(struct kvm_vcpu vcpu, struct kvm_xsave guest_xsave) { u64 xstate_bv = (u64 )&guest_xsave->region[XSAVE_HDR_OFFSET / sizeof(u32)]; if (cpu_has_xsave) { / * Here we allow setting states that are not present in * CPUID leaf 0xD, index 0, EDX:EAX. This is for compatibility * with old userspace. / if (xstate_bv & ~kvm_supported_xcr0()) return -EINVAL; memcpy(&vcpu->arch.guest_fpu.state->xsave, guest_xsave->region, vcpu->arch.guest_xstate_size); } else { if (xstate_bv & ~XSTATE_FPSSE) return -EINVAL; memcpy(&vcpu->arch.guest_fpu.state->fxsave, guest_xsave->region, sizeof(struct i387_fxsave_struct)); } return 0; } static void kvm_vcpu_ioctl_x86_get_xcrs(struct kvm_vcpu vcpu, struct kvm_xcrs guest_xcrs) { if (!cpu_has_xsave) { guest_xcrs->nr_xcrs = 0; return; } guest_xcrs->nr_xcrs = 1; guest_xcrs->flags = 0; guest_xcrs->xcrs[0].xcr = XCR_XFEATURE_ENABLED_MASK; guest_xcrs->xcrs[0].value = vcpu->arch.xcr0; } static int kvm_vcpu_ioctl_x86_set_xcrs(struct kvm_vcpu vcpu, struct kvm_xcrs guest_xcrs) { int i, r = 0; if (!cpu_has_xsave) return -EINVAL; if (guest_xcrs->nr_xcrs > KVM_MAX_XCRS \|\| guest_xcrs->flags) return -EINVAL; for (i = 0; i < guest_xcrs->nr_xcrs; i++) / Only support XCR0 currently / if (guest_xcrs->xcrs[i].xcr == XCR_XFEATURE_ENABLED_MASK) { r = __kvm_set_xcr(vcpu, XCR_XFEATURE_ENABLED_MASK, guest_xcrs->xcrs[i].value); break; } if (r) r = -EINVAL; return r; } / * kvm_set_guest_paused() indicates to the guest kernel that it has been * stopped by the hypervisor. This function will be called from the host only. * EINVAL is returned when the host attempts to set the flag for a guest that * does not support pv clocks. / static int kvm_set_guest_paused(struct kvm_vcpu vcpu) { if (!vcpu->arch.pv_time_enabled) return -EINVAL; vcpu->arch.pvclock_set_guest_stopped_request = true; kvm_make_request(KVM_REQ_CLOCK_UPDATE, vcpu); return 0; } long kvm_arch_vcpu_ioctl(struct file filp, unsigned int ioctl, unsigned long arg) { struct kvm_vcpu vcpu = filp->private_data; void __user argp = (void __user )arg; int r; union { struct kvm_lapic_state lapic; struct kvm_xsave xsave; struct kvm_xcrs xcrs; void buffer; } u; u.buffer = NULL; switch (ioctl) { case KVM_GET_LAPIC: { r = -EINVAL; if (!vcpu->arch.apic) goto out; u.lapic = kzalloc(sizeof(struct kvm_lapic_state), GFP_KERNEL); r = -ENOMEM; if (!u.lapic) goto out; r = kvm_vcpu_ioctl_get_lapic(vcpu, u.lapic); if (r) goto out; r = -EFAULT; if (copy_to_user(argp, u.lapic, sizeof(struct kvm_lapic_state))) goto out; r = 0; break; } case KVM_SET_LAPIC: { r = -EINVAL; if (!vcpu->arch.apic) goto out; u.lapic = memdup_user(argp, sizeof(u.lapic)); if (IS_ERR(u.lapic)) return PTR_ERR(u.lapic); r = kvm_vcpu_ioctl_set_lapic(vcpu, u.lapic); break; } case KVM_INTERRUPT: { struct kvm_interrupt irq; r = -EFAULT; if (copy_from_user(&irq, argp, sizeof irq)) goto out; r = kvm_vcpu_ioctl_interrupt(vcpu, &irq); break; } case KVM_NMI: { r = kvm_vcpu_ioctl_nmi(vcpu); break; } case KVM_SET_CPUID: { struct kvm_cpuid __user cpuid_arg = argp; struct kvm_cpuid cpuid; r = -EFAULT; if (copy_from_user(&cpuid, cpuid_arg, sizeof cpuid)) goto out; r = kvm_vcpu_ioctl_set_cpuid(vcpu, &cpuid, cpuid_arg->entries); break; } case KVM_SET_CPUID2: { struct kvm_cpuid2 __user cpuid_arg = argp; struct kvm_cpuid2 cpuid; r = -EFAULT; if (copy_from_user(&cpuid, cpuid_arg, sizeof cpuid)) goto out; r = kvm_vcpu_ioctl_set_cpuid2(vcpu, &cpuid, cpuid_arg->entries); break; } case KVM_GET_CPUID2: { struct kvm_cpuid2 __user cpuid_arg = argp; struct kvm_cpuid2 cpuid; r = -EFAULT; if (copy_from_user(&cpuid, cpuid_arg, sizeof cpuid)) goto out; r = kvm_vcpu_ioctl_get_cpuid2(vcpu, &cpuid, cpuid_arg->entries); if (r) goto out; r = -EFAULT; if (copy_to_user(cpuid_arg, &cpuid, sizeof cpuid)) goto out; r = 0; break; } case KVM_GET_MSRS: r = msr_io(vcpu, argp, kvm_get_msr, 1); break; case KVM_SET_MSRS: r = msr_io(vcpu, argp, do_set_msr, 0); break; case KVM_TPR_ACCESS_REPORTING: { struct kvm_tpr_access_ctl tac; r = -EFAULT; if (copy_from_user(&tac, argp, sizeof tac)) goto out; r = vcpu_ioctl_tpr_access_reporting(vcpu, &tac); if (r) goto out; r = -EFAULT; if (copy_to_user(argp, &tac, sizeof tac)) goto out; r = 0; break; }; case KVM_SET_VAPIC_ADDR: { struct kvm_vapic_addr va; r = -EINVAL; if (!irqchip_in_kernel(vcpu->kvm)) goto out; r = -EFAULT; if (copy_from_user(&va, argp, sizeof va)) goto out; r = kvm_lapic_set_vapic_addr(vcpu, va.vapic_addr); break; } case KVM_X86_SETUP_MCE: { u64 mcg_cap; r = -EFAULT; if (copy_from_user(&mcg_cap, argp, sizeof mcg_cap)) goto out; r = kvm_vcpu_ioctl_x86_setup_mce(vcpu, mcg_cap); break; } case KVM_X86_SET_MCE: { struct kvm_x86_mce mce; r = -EFAULT; if (copy_from_user(&mce, argp, sizeof mce)) goto out; r = kvm_vcpu_ioctl_x86_set_mce(vcpu, &mce); break; } case KVM_GET_VCPU_EVENTS: { struct kvm_vcpu_events events; kvm_vcpu_ioctl_x86_get_vcpu_events(vcpu, &events); r = -EFAULT; if (copy_to_user(argp, &events, sizeof(struct kvm_vcpu_events))) break; r = 0; break; } case KVM_SET_VCPU_EVENTS: { struct kvm_vcpu_events events; r = -EFAULT; if (copy_from_user(&events, argp, sizeof(struct kvm_vcpu_events))) break; r = kvm_vcpu_ioctl_x86_set_vcpu_events(vcpu, &events); break; } case KVM_GET_DEBUGREGS: { struct kvm_debugregs dbgregs; kvm_vcpu_ioctl_x86_get_debugregs(vcpu, &dbgregs); r = -EFAULT; if (copy_to_user(argp, &dbgregs, sizeof(struct kvm_debugregs))) break; r = 0; break; } case KVM_SET_DEBUGREGS: { struct kvm_debugregs dbgregs; r = -EFAULT; if (copy_from_user(&dbgregs, argp, sizeof(struct kvm_debugregs))) break; r = kvm_vcpu_ioctl_x86_set_debugregs(vcpu, &dbgregs); break; } case KVM_GET_XSAVE: { u.xsave = kzalloc(sizeof(struct kvm_xsave), GFP_KERNEL); r = -ENOMEM; if (!u.xsave) break; kvm_vcpu_ioctl_x86_get_xsave(vcpu, u.xsave); r = -EFAULT; if (copy_to_user(argp, u.xsave, sizeof(struct kvm_xsave))) break; r = 0; break; } case KVM_SET_XSAVE: { u.xsave = memdup_user(argp, sizeof(u.xsave)); if (IS_ERR(u.xsave)) return PTR_ERR(u.xsave); r = kvm_vcpu_ioctl_x86_set_xsave(vcpu, u.xsave); break; } case KVM_GET_XCRS: { u.xcrs = kzalloc(sizeof(struct kvm_xcrs), GFP_KERNEL); r = -ENOMEM; if (!u.xcrs) break; kvm_vcpu_ioctl_x86_get_xcrs(vcpu, u.xcrs); r = -EFAULT; if (copy_to_user(argp, u.xcrs, sizeof(struct kvm_xcrs))) break; r = 0; break; } case KVM_SET_XCRS: { u.xcrs = memdup_user(argp, sizeof(u.xcrs)); if (IS_ERR(u.xcrs)) return PTR_ERR(u.xcrs); r = kvm_vcpu_ioctl_x86_set_xcrs(vcpu, u.xcrs); break; } case KVM_SET_TSC_KHZ: { u32 user_tsc_khz; r = -EINVAL; user_tsc_khz = (u32)arg; if (user_tsc_khz >= kvm_max_guest_tsc_khz) goto out; if (user_tsc_khz == 0) user_tsc_khz = tsc_khz; kvm_set_tsc_khz(vcpu, user_tsc_khz); r = 0; goto out; } case KVM_GET_TSC_KHZ: { r = vcpu->arch.virtual_tsc_khz; goto out; } case KVM_KVMCLOCK_CTRL: { r = kvm_set_guest_paused(vcpu); goto out; } default: r = -EINVAL; } out: kfree(u.buffer); return r; } int kvm_arch_vcpu_fault(struct kvm_vcpu vcpu, struct vm_fault vmf) { return VM_FAULT_SIGBUS; } static int kvm_vm_ioctl_set_tss_addr(struct kvm kvm, unsigned long addr) { int ret; if (addr > (unsigned int)(-3 PAGE_SIZE)) return -EINVAL; ret = kvm_x86_ops->set_tss_addr(kvm, addr); return ret; } static int kvm_vm_ioctl_set_identity_map_addr(struct kvm kvm, u64 ident_addr) { kvm->arch.ept_identity_map_addr = ident_addr; return 0; } static int kvm_vm_ioctl_set_nr_mmu_pages(struct kvm kvm, u32 kvm_nr_mmu_pages) { if (kvm_nr_mmu_pages < KVM_MIN_ALLOC_MMU_PAGES) return -EINVAL; mutex_lock(&kvm->slots_lock); kvm_mmu_change_mmu_pages(kvm, kvm_nr_mmu_pages); kvm->arch.n_requested_mmu_pages = kvm_nr_mmu_pages; mutex_unlock(&kvm->slots_lock); return 0; } static int kvm_vm_ioctl_get_nr_mmu_pages(struct kvm kvm) { return kvm->arch.n_max_mmu_pages; } static int kvm_vm_ioctl_get_irqchip(struct kvm kvm, struct kvm_irqchip chip) { int r; r = 0; switch (chip->chip_id) { case KVM_IRQCHIP_PIC_MASTER: memcpy(&chip->chip.pic, &pic_irqchip(kvm)->pics[0], sizeof(struct kvm_pic_state)); break; case KVM_IRQCHIP_PIC_SLAVE: memcpy(&chip->chip.pic, &pic_irqchip(kvm)->pics[1], sizeof(struct kvm_pic_state)); break; case KVM_IRQCHIP_IOAPIC: r = kvm_get_ioapic(kvm, &chip->chip.ioapic); break; default: r = -EINVAL; break; } return r; } static int kvm_vm_ioctl_set_irqchip(struct kvm kvm, struct kvm_irqchip chip) { int r; r = 0; switch (chip->chip_id) { case KVM_IRQCHIP_PIC_MASTER: spin_lock(&pic_irqchip(kvm)->lock); memcpy(&pic_irqchip(kvm)->pics[0], &chip->chip.pic, sizeof(struct kvm_pic_state)); spin_unlock(&pic_irqchip(kvm)->lock); break; case KVM_IRQCHIP_PIC_SLAVE: spin_lock(&pic_irqchip(kvm)->lock); memcpy(&pic_irqchip(kvm)->pics[1], &chip->chip.pic, sizeof(struct kvm_pic_state)); spin_unlock(&pic_irqchip(kvm)->lock); break; case KVM_IRQCHIP_IOAPIC: r = kvm_set_ioapic(kvm, &chip->chip.ioapic); break; default: r = -EINVAL; break; } kvm_pic_update_irq(pic_irqchip(kvm)); return r; } static int kvm_vm_ioctl_get_pit(struct kvm kvm, struct kvm_pit_state ps) { int r = 0; mutex_lock(&kvm->arch.vpit->pit_state.lock); memcpy(ps, &kvm->arch.vpit->pit_state, sizeof(struct kvm_pit_state)); mutex_unlock(&kvm->arch.vpit->pit_state.lock); return r; } static int kvm_vm_ioctl_set_pit(struct kvm kvm, struct kvm_pit_state ps) { int r = 0; mutex_lock(&kvm->arch.vpit->pit_state.lock); memcpy(&kvm->arch.vpit->pit_state, ps, sizeof(struct kvm_pit_state)); kvm_pit_load_count(kvm, 0, ps->channels[0].count, 0); mutex_unlock(&kvm->arch.vpit->pit_state.lock); return r; } static int kvm_vm_ioctl_get_pit2(struct kvm kvm, struct kvm_pit_state2 ps) { int r = 0; mutex_lock(&kvm->arch.vpit->pit_state.lock); memcpy(ps->channels, &kvm->arch.vpit->pit_state.channels, sizeof(ps->channels)); ps->flags = kvm->arch.vpit->pit_state.flags; mutex_unlock(&kvm->arch.vpit->pit_state.lock); memset(&ps->reserved, 0, sizeof(ps->reserved)); return r; } static int kvm_vm_ioctl_set_pit2(struct kvm kvm, struct kvm_pit_state2 ps) { int r = 0, start = 0; u32 prev_legacy, cur_legacy; mutex_lock(&kvm->arch.vpit->pit_state.lock); prev_legacy = kvm->arch.vpit->pit_state.flags & KVM_PIT_FLAGS_HPET_LEGACY; cur_legacy = ps->flags & KVM_PIT_FLAGS_HPET_LEGACY; if (!prev_legacy && cur_legacy) start = 1; memcpy(&kvm->arch.vpit->pit_state.channels, &ps->channels, sizeof(kvm->arch.vpit->pit_state.channels)); kvm->arch.vpit->pit_state.flags = ps->flags; kvm_pit_load_count(kvm, 0, kvm->arch.vpit->pit_state.channels[0].count, start); mutex_unlock(&kvm->arch.vpit->pit_state.lock); return r; } static int kvm_vm_ioctl_reinject(struct kvm kvm, struct kvm_reinject_control control) { if (!kvm->arch.vpit) return -ENXIO; mutex_lock(&kvm->arch.vpit->pit_state.lock); kvm->arch.vpit->pit_state.reinject = control->pit_reinject; mutex_unlock(&kvm->arch.vpit->pit_state.lock); return 0; } /* * kvm_vm_ioctl_get_dirty_log - get and clear the log of dirty pages in a slot * @kvm: kvm instance * @log: slot id and address to which we copy the log * * We need to keep it in mind that VCPU threads can write to the bitmap * concurrently. So, to avoid losing data, we keep the following order for * each bit: * * 1. Take a snapshot of the bit and clear it if needed. * 2. Write protect the corresponding page. * 3. Flush TLB's if needed. * 4. Copy the snapshot to the userspace. * * Between 2 and 3, the guest may write to the page using the remaining TLB * entry. This is not a problem because the page will be reported dirty at * step 4 using the snapshot taken before and step 3 ensures that successive * writes will be logged for the next call. / int kvm_vm_ioctl_get_dirty_log(struct kvm kvm, struct kvm_dirty_log log) { int r; struct kvm_memory_slot memslot; unsigned long n, i; unsigned long dirty_bitmap; unsigned long dirty_bitmap_buffer; bool is_dirty = false; mutex_lock(&kvm->slots_lock); r = -EINVAL; if (log->slot >= KVM_USER_MEM_SLOTS) goto out; memslot = id_to_memslot(kvm->memslots, log->slot); dirty_bitmap = memslot->dirty_bitmap; r = -ENOENT; if (!dirty_bitmap) goto out; n = kvm_dirty_bitmap_bytes(memslot); dirty_bitmap_buffer = dirty_bitmap + n / sizeof(long); memset(dirty_bitmap_buffer, 0, n); spin_lock(&kvm->mmu_lock); for (i = 0; i < n / sizeof(long); i++) { unsigned long mask; gfn_t offset; if (!dirty_bitmap[i]) continue; is_dirty = true; mask = xchg(&dirty_bitmap[i], 0); dirty_bitmap_buffer[i] = mask; offset = i * BITS_PER_LONG; kvm_mmu_write_protect_pt_masked(kvm, memslot, offset, mask); } spin_unlock(&kvm->mmu_lock); /* See the comments in kvm_mmu_slot_remove_write_access(). / lockdep_assert_held(&kvm->slots_lock); / * All the TLBs can be flushed out of mmu lock, see the comments in * kvm_mmu_slot_remove_write_access(). / if (is_dirty) kvm_flush_remote_tlbs(kvm); r = -EFAULT; if (copy_to_user(log->dirty_bitmap, dirty_bitmap_buffer, n)) goto out; r = 0; out: mutex_unlock(&kvm->slots_lock); return r; } int kvm_vm_ioctl_irq_line(struct kvm kvm, struct kvm_irq_level irq_event, bool line_status) { if (!irqchip_in_kernel(kvm)) return -ENXIO; irq_event->status = kvm_set_irq(kvm, KVM_USERSPACE_IRQ_SOURCE_ID, irq_event->irq, irq_event->level, line_status); return 0; } long kvm_arch_vm_ioctl(struct file filp, unsigned int ioctl, unsigned long arg) { struct kvm kvm = filp->private_data; void __user argp = (void __user )arg; int r = -ENOTTY; / * This union makes it completely explicit to gcc-3.x * that these two variables' stack usage should be * combined, not added together. / union { struct kvm_pit_state ps; struct kvm_pit_state2 ps2; struct kvm_pit_config pit_config; } u; switch (ioctl) { case KVM_SET_TSS_ADDR: r = kvm_vm_ioctl_set_tss_addr(kvm, arg); break; case KVM_SET_IDENTITY_MAP_ADDR: { u64 ident_addr; r = -EFAULT; if (copy_from_user(&ident_addr, argp, sizeof ident_addr)) goto out; r = kvm_vm_ioctl_set_identity_map_addr(kvm, ident_addr); break; } case KVM_SET_NR_MMU_PAGES: r = kvm_vm_ioctl_set_nr_mmu_pages(kvm, arg); break; case KVM_GET_NR_MMU_PAGES: r = kvm_vm_ioctl_get_nr_mmu_pages(kvm); break; case KVM_CREATE_IRQCHIP: { struct kvm_pic vpic; mutex_lock(&kvm->lock); r = -EEXIST; if (kvm->arch.vpic) goto create_irqchip_unlock; r = -EINVAL; if (atomic_read(&kvm->online_vcpus)) goto create_irqchip_unlock; r = -ENOMEM; vpic = kvm_create_pic(kvm); if (vpic) { r = kvm_ioapic_init(kvm); if (r) { mutex_lock(&kvm->slots_lock); kvm_io_bus_unregister_dev(kvm, KVM_PIO_BUS, &vpic->dev_master); kvm_io_bus_unregister_dev(kvm, KVM_PIO_BUS, &vpic->dev_slave); kvm_io_bus_unregister_dev(kvm, KVM_PIO_BUS, &vpic->dev_eclr); mutex_unlock(&kvm->slots_lock); kfree(vpic); goto create_irqchip_unlock; } } else goto create_irqchip_unlock; smp_wmb(); kvm->arch.vpic = vpic; smp_wmb(); r = kvm_setup_default_irq_routing(kvm); if (r) { mutex_lock(&kvm->slots_lock); mutex_lock(&kvm->irq_lock); kvm_ioapic_destroy(kvm); kvm_destroy_pic(kvm); mutex_unlock(&kvm->irq_lock); mutex_unlock(&kvm->slots_lock); } create_irqchip_unlock: mutex_unlock(&kvm->lock); break; } case KVM_CREATE_PIT: u.pit_config.flags = KVM_PIT_SPEAKER_DUMMY; goto create_pit; case KVM_CREATE_PIT2: r = -EFAULT; if (copy_from_user(&u.pit_config, argp, sizeof(struct kvm_pit_config))) goto out; create_pit: mutex_lock(&kvm->slots_lock); r = -EEXIST; if (kvm->arch.vpit) goto create_pit_unlock; r = -ENOMEM; kvm->arch.vpit = kvm_create_pit(kvm, u.pit_config.flags); if (kvm->arch.vpit) r = 0; create_pit_unlock: mutex_unlock(&kvm->slots_lock); break; case KVM_GET_IRQCHIP: { /* 0: PIC master, 1: PIC slave, 2: IOAPIC / struct kvm_irqchip chip; chip = memdup_user(argp, sizeof(chip)); if (IS_ERR(chip)) { r = PTR_ERR(chip); goto out; } r = -ENXIO; if (!irqchip_in_kernel(kvm)) goto get_irqchip_out; r = kvm_vm_ioctl_get_irqchip(kvm, chip); if (r) goto get_irqchip_out; r = -EFAULT; if (copy_to_user(argp, chip, sizeof chip)) goto get_irqchip_out; r = 0; get_irqchip_out: kfree(chip); break; } case KVM_SET_IRQCHIP: { /* 0: PIC master, 1: PIC slave, 2: IOAPIC / struct kvm_irqchip chip; chip = memdup_user(argp, sizeof(chip)); if (IS_ERR(chip)) { r = PTR_ERR(chip); goto out; } r = -ENXIO; if (!irqchip_in_kernel(kvm)) goto set_irqchip_out; r = kvm_vm_ioctl_set_irqchip(kvm, chip); if (r) goto set_irqchip_out; r = 0; set_irqchip_out: kfree(chip); break; } case KVM_GET_PIT: { r = -EFAULT; if (copy_from_user(&u.ps, argp, sizeof(struct kvm_pit_state))) goto out; r = -ENXIO; if (!kvm->arch.vpit) goto out; r = kvm_vm_ioctl_get_pit(kvm, &u.ps); if (r) goto out; r = -EFAULT; if (copy_to_user(argp, &u.ps, sizeof(struct kvm_pit_state))) goto out; r = 0; break; } case KVM_SET_PIT: { r = -EFAULT; if (copy_from_user(&u.ps, argp, sizeof u.ps)) goto out; r = -ENXIO; if (!kvm->arch.vpit) goto out; r = kvm_vm_ioctl_set_pit(kvm, &u.ps); break; } case KVM_GET_PIT2: { r = -ENXIO; if (!kvm->arch.vpit) goto out; r = kvm_vm_ioctl_get_pit2(kvm, &u.ps2); if (r) goto out; r = -EFAULT; if (copy_to_user(argp, &u.ps2, sizeof(u.ps2))) goto out; r = 0; break; } case KVM_SET_PIT2: { r = -EFAULT; if (copy_from_user(&u.ps2, argp, sizeof(u.ps2))) goto out; r = -ENXIO; if (!kvm->arch.vpit) goto out; r = kvm_vm_ioctl_set_pit2(kvm, &u.ps2); break; } case KVM_REINJECT_CONTROL: { struct kvm_reinject_control control; r = -EFAULT; if (copy_from_user(&control, argp, sizeof(control))) goto out; r = kvm_vm_ioctl_reinject(kvm, &control); break; } case KVM_XEN_HVM_CONFIG: { r = -EFAULT; if (copy_from_user(&kvm->arch.xen_hvm_config, argp, sizeof(struct kvm_xen_hvm_config))) goto out; r = -EINVAL; if (kvm->arch.xen_hvm_config.flags) goto out; r = 0; break; } case KVM_SET_CLOCK: { struct kvm_clock_data user_ns; u64 now_ns; s64 delta; r = -EFAULT; if (copy_from_user(&user_ns, argp, sizeof(user_ns))) goto out; r = -EINVAL; if (user_ns.flags) goto out; r = 0; local_irq_disable(); now_ns = get_kernel_ns(); delta = user_ns.clock - now_ns; local_irq_enable(); kvm->arch.kvmclock_offset = delta; kvm_gen_update_masterclock(kvm); break; } case KVM_GET_CLOCK: { struct kvm_clock_data user_ns; u64 now_ns; local_irq_disable(); now_ns = get_kernel_ns(); user_ns.clock = kvm->arch.kvmclock_offset + now_ns; local_irq_enable(); user_ns.flags = 0; memset(&user_ns.pad, 0, sizeof(user_ns.pad)); r = -EFAULT; if (copy_to_user(argp, &user_ns, sizeof(user_ns))) goto out; r = 0; break; } default: ; } out: return r; } static void kvm_init_msr_list(void) { u32 dummy[2]; unsigned i, j; / skip the first msrs in the list. KVM-specific / for (i = j = KVM_SAVE_MSRS_BEGIN; i < ARRAY_SIZE(msrs_to_save); i++) { if (rdmsr_safe(msrs_to_save[i], &dummy[0], &dummy[1]) < 0) continue; / * Even MSRs that are valid in the host may not be exposed * to the guests in some cases. We could work around this * in VMX with the generic MSR save/load machinery, but it * is not really worthwhile since it will really only * happen with nested virtualization. / switch (msrs_to_save[i]) { case MSR_IA32_BNDCFGS: if (!kvm_x86_ops->mpx_supported()) continue; break; default: break; } if (j < i) msrs_to_save[j] = msrs_to_save[i]; j++; } num_msrs_to_save = j; } static int vcpu_mmio_write(struct kvm_vcpu vcpu, gpa_t addr, int len, const void v) { int handled = 0; int n; do { n = min(len, 8); if (!(vcpu->arch.apic && !kvm_iodevice_write(&vcpu->arch.apic->dev, addr, n, v)) && kvm_io_bus_write(vcpu->kvm, KVM_MMIO_BUS, addr, n, v)) break; handled += n; addr += n; len -= n; v += n; } while (len); return handled; } static int vcpu_mmio_read(struct kvm_vcpu vcpu, gpa_t addr, int len, void v) { int handled = 0; int n; do { n = min(len, 8); if (!(vcpu->arch.apic && !kvm_iodevice_read(&vcpu->arch.apic->dev, addr, n, v)) && kvm_io_bus_read(vcpu->kvm, KVM_MMIO_BUS, addr, n, v)) break; trace_kvm_mmio(KVM_TRACE_MMIO_READ, n, addr, (u64 )v); handled += n; addr += n; len -= n; v += n; } while (len); return handled; } static void kvm_set_segment(struct kvm_vcpu vcpu, struct kvm_segment var, int seg) { kvm_x86_ops->set_segment(vcpu, var, seg); } void kvm_get_segment(struct kvm_vcpu vcpu, struct kvm_segment var, int seg) { kvm_x86_ops->get_segment(vcpu, var, seg); } gpa_t translate_nested_gpa(struct kvm_vcpu vcpu, gpa_t gpa, u32 access, struct x86_exception exception) { gpa_t t_gpa; BUG_ON(!mmu_is_nested(vcpu)); / NPT walks are always user-walks / access \|= PFERR_USER_MASK; t_gpa = vcpu->arch.mmu.gva_to_gpa(vcpu, gpa, access, exception); return t_gpa; } gpa_t kvm_mmu_gva_to_gpa_read(struct kvm_vcpu vcpu, gva_t gva, struct x86_exception exception) { u32 access = (kvm_x86_ops->get_cpl(vcpu) == 3) ? PFERR_USER_MASK : 0; return vcpu->arch.walk_mmu->gva_to_gpa(vcpu, gva, access, exception); } gpa_t kvm_mmu_gva_to_gpa_fetch(struct kvm_vcpu vcpu, gva_t gva, struct x86_exception exception) { u32 access = (kvm_x86_ops->get_cpl(vcpu) == 3) ? PFERR_USER_MASK : 0; access \|= PFERR_FETCH_MASK; return vcpu->arch.walk_mmu->gva_to_gpa(vcpu, gva, access, exception); } gpa_t kvm_mmu_gva_to_gpa_write(struct kvm_vcpu vcpu, gva_t gva, struct x86_exception exception) { u32 access = (kvm_x86_ops->get_cpl(vcpu) == 3) ? PFERR_USER_MASK : 0; access \|= PFERR_WRITE_MASK; return vcpu->arch.walk_mmu->gva_to_gpa(vcpu, gva, access, exception); } / uses this to access any guest's mapped memory without checking CPL / gpa_t kvm_mmu_gva_to_gpa_system(struct kvm_vcpu vcpu, gva_t gva, struct x86_exception exception) { return vcpu->arch.walk_mmu->gva_to_gpa(vcpu, gva, 0, exception); } static int kvm_read_guest_virt_helper(gva_t addr, void val, unsigned int bytes, struct kvm_vcpu vcpu, u32 access, struct x86_exception exception) { void data = val; int r = X86EMUL_CONTINUE; while (bytes) { gpa_t gpa = vcpu->arch.walk_mmu->gva_to_gpa(vcpu, addr, access, exception); unsigned offset = addr & (PAGE_SIZE-1); unsigned toread = min(bytes, (unsigned)PAGE_SIZE - offset); int ret; if (gpa == UNMAPPED_GVA) return X86EMUL_PROPAGATE_FAULT; ret = kvm_read_guest_page(vcpu->kvm, gpa >> PAGE_SHIFT, data, offset, toread); if (ret < 0) { r = X86EMUL_IO_NEEDED; goto out; } bytes -= toread; data += toread; addr += toread; } out: return r; } / used for instruction fetching / static int kvm_fetch_guest_virt(struct x86_emulate_ctxt ctxt, gva_t addr, void val, unsigned int bytes, struct x86_exception exception) { struct kvm_vcpu vcpu = emul_to_vcpu(ctxt); u32 access = (kvm_x86_ops->get_cpl(vcpu) == 3) ? PFERR_USER_MASK : 0; unsigned offset; int ret; / Inline kvm_read_guest_virt_helper for speed. / gpa_t gpa = vcpu->arch.walk_mmu->gva_to_gpa(vcpu, addr, access\|PFERR_FETCH_MASK, exception); if (unlikely(gpa == UNMAPPED_GVA)) return X86EMUL_PROPAGATE_FAULT; offset = addr & (PAGE_SIZE-1); if (WARN_ON(offset + bytes > PAGE_SIZE)) bytes = (unsigned)PAGE_SIZE - offset; ret = kvm_read_guest_page(vcpu->kvm, gpa >> PAGE_SHIFT, val, offset, bytes); if (unlikely(ret < 0)) return X86EMUL_IO_NEEDED; return X86EMUL_CONTINUE; } int kvm_read_guest_virt(struct x86_emulate_ctxt ctxt, gva_t addr, void val, unsigned int bytes, struct x86_exception exception) { struct kvm_vcpu vcpu = emul_to_vcpu(ctxt); u32 access = (kvm_x86_ops->get_cpl(vcpu) == 3) ? PFERR_USER_MASK : 0; return kvm_read_guest_virt_helper(addr, val, bytes, vcpu, access, exception); } EXPORT_SYMBOL_GPL(kvm_read_guest_virt); static int kvm_read_guest_virt_system(struct x86_emulate_ctxt ctxt, gva_t addr, void val, unsigned int bytes, struct x86_exception exception) { struct kvm_vcpu vcpu = emul_to_vcpu(ctxt); return kvm_read_guest_virt_helper(addr, val, bytes, vcpu, 0, exception); } int kvm_write_guest_virt_system(struct x86_emulate_ctxt ctxt, gva_t addr, void val, unsigned int bytes, struct x86_exception exception) { struct kvm_vcpu vcpu = emul_to_vcpu(ctxt); void data = val; int r = X86EMUL_CONTINUE; while (bytes) { gpa_t gpa = vcpu->arch.walk_mmu->gva_to_gpa(vcpu, addr, PFERR_WRITE_MASK, exception); unsigned offset = addr & (PAGE_SIZE-1); unsigned towrite = min(bytes, (unsigned)PAGE_SIZE - offset); int ret; if (gpa == UNMAPPED_GVA) return X86EMUL_PROPAGATE_FAULT; ret = kvm_write_guest(vcpu->kvm, gpa, data, towrite); if (ret < 0) { r = X86EMUL_IO_NEEDED; goto out; } bytes -= towrite; data += towrite; addr += towrite; } out: return r; } EXPORT_SYMBOL_GPL(kvm_write_guest_virt_system); static int vcpu_mmio_gva_to_gpa(struct kvm_vcpu vcpu, unsigned long gva, gpa_t gpa, struct x86_exception exception, bool write) { u32 access = ((kvm_x86_ops->get_cpl(vcpu) == 3) ? PFERR_USER_MASK : 0) \| (write ? PFERR_WRITE_MASK : 0); if (vcpu_match_mmio_gva(vcpu, gva) && !permission_fault(vcpu, vcpu->arch.walk_mmu, vcpu->arch.access, access)) { gpa = vcpu->arch.mmio_gfn << PAGE_SHIFT \| (gva & (PAGE_SIZE - 1)); trace_vcpu_match_mmio(gva, gpa, write, false); return 1; } gpa = vcpu->arch.walk_mmu->gva_to_gpa(vcpu, gva, access, exception); if (gpa == UNMAPPED_GVA) return -1; / For APIC access vmexit / if ((gpa & PAGE_MASK) == APIC_DEFAULT_PHYS_BASE) return 1; if (vcpu_match_mmio_gpa(vcpu, gpa)) { trace_vcpu_match_mmio(gva, gpa, write, true); return 1; } return 0; } int emulator_write_phys(struct kvm_vcpu vcpu, gpa_t gpa, const void val, int bytes) { int ret; ret = kvm_write_guest(vcpu->kvm, gpa, val, bytes); if (ret < 0) return 0; kvm_mmu_pte_write(vcpu, gpa, val, bytes); return 1; } struct read_write_emulator_ops { int (read_write_prepare)(struct kvm_vcpu vcpu, void val, int bytes); int (read_write_emulate)(struct kvm_vcpu vcpu, gpa_t gpa, void val, int bytes); int (read_write_mmio)(struct kvm_vcpu vcpu, gpa_t gpa, int bytes, void val); int (read_write_exit_mmio)(struct kvm_vcpu vcpu, gpa_t gpa, void val, int bytes); bool write; }; static int read_prepare(struct kvm_vcpu vcpu, void val, int bytes) { if (vcpu->mmio_read_completed) { trace_kvm_mmio(KVM_TRACE_MMIO_READ, bytes, vcpu->mmio_fragments[0].gpa, (u64 )val); vcpu->mmio_read_completed = 0; return 1; } return 0; } static int read_emulate(struct kvm_vcpu vcpu, gpa_t gpa, void val, int bytes) { return !kvm_read_guest(vcpu->kvm, gpa, val, bytes); } static int write_emulate(struct kvm_vcpu vcpu, gpa_t gpa, void val, int bytes) { return emulator_write_phys(vcpu, gpa, val, bytes); } static int write_mmio(struct kvm_vcpu vcpu, gpa_t gpa, int bytes, void val) { trace_kvm_mmio(KVM_TRACE_MMIO_WRITE, bytes, gpa, (u64 )val); return vcpu_mmio_write(vcpu, gpa, bytes, val); } static int read_exit_mmio(struct kvm_vcpu vcpu, gpa_t gpa, void val, int bytes) { trace_kvm_mmio(KVM_TRACE_MMIO_READ_UNSATISFIED, bytes, gpa, 0); return X86EMUL_IO_NEEDED; } static int write_exit_mmio(struct kvm_vcpu vcpu, gpa_t gpa, void val, int bytes) { struct kvm_mmio_fragment frag = &vcpu->mmio_fragments[0]; memcpy(vcpu->run->mmio.data, frag->data, min(8u, frag->len)); return X86EMUL_CONTINUE; } static const struct read_write_emulator_ops read_emultor = { .read_write_prepare = read_prepare, .read_write_emulate = read_emulate, .read_write_mmio = vcpu_mmio_read, .read_write_exit_mmio = read_exit_mmio, }; static const struct read_write_emulator_ops write_emultor = { .read_write_emulate = write_emulate, .read_write_mmio = write_mmio, .read_write_exit_mmio = write_exit_mmio, .write = true, }; static int emulator_read_write_onepage(unsigned long addr, void val, unsigned int bytes, struct x86_exception exception, struct kvm_vcpu vcpu, const struct read_write_emulator_ops ops) { gpa_t gpa; int handled, ret; bool write = ops->write; struct kvm_mmio_fragment frag; ret = vcpu_mmio_gva_to_gpa(vcpu, addr, &gpa, exception, write); if (ret < 0) return X86EMUL_PROPAGATE_FAULT; /* For APIC access vmexit / if (ret) goto mmio; if (ops->read_write_emulate(vcpu, gpa, val, bytes)) return X86EMUL_CONTINUE; mmio: / * Is this MMIO handled locally? / handled = ops->read_write_mmio(vcpu, gpa, bytes, val); if (handled == bytes) return X86EMUL_CONTINUE; gpa += handled; bytes -= handled; val += handled; WARN_ON(vcpu->mmio_nr_fragments >= KVM_MAX_MMIO_FRAGMENTS); frag = &vcpu->mmio_fragments[vcpu->mmio_nr_fragments++]; frag->gpa = gpa; frag->data = val; frag->len = bytes; return X86EMUL_CONTINUE; } int emulator_read_write(struct x86_emulate_ctxt ctxt, unsigned long addr, void val, unsigned int bytes, struct x86_exception exception, const struct read_write_emulator_ops ops) { struct kvm_vcpu vcpu = emul_to_vcpu(ctxt); gpa_t gpa; int rc; if (ops->read_write_prepare && ops->read_write_prepare(vcpu, val, bytes)) return X86EMUL_CONTINUE; vcpu->mmio_nr_fragments = 0; /* Crossing a page boundary? / if (((addr + bytes - 1) ^ addr) & PAGE_MASK) { int now; now = -addr & ~PAGE_MASK; rc = emulator_read_write_onepage(addr, val, now, exception, vcpu, ops); if (rc != X86EMUL_CONTINUE) return rc; addr += now; val += now; bytes -= now; } rc = emulator_read_write_onepage(addr, val, bytes, exception, vcpu, ops); if (rc != X86EMUL_CONTINUE) return rc; if (!vcpu->mmio_nr_fragments) return rc; gpa = vcpu->mmio_fragments[0].gpa; vcpu->mmio_needed = 1; vcpu->mmio_cur_fragment = 0; vcpu->run->mmio.len = min(8u, vcpu->mmio_fragments[0].len); vcpu->run->mmio.is_write = vcpu->mmio_is_write = ops->write; vcpu->run->exit_reason = KVM_EXIT_MMIO; vcpu->run->mmio.phys_addr = gpa; return ops->read_write_exit_mmio(vcpu, gpa, val, bytes); } static int emulator_read_emulated(struct x86_emulate_ctxt ctxt, unsigned long addr, void val, unsigned int bytes, struct x86_exception exception) { return emulator_read_write(ctxt, addr, val, bytes, exception, &read_emultor); } int emulator_write_emulated(struct x86_emulate_ctxt ctxt, unsigned long addr, const void val, unsigned int bytes, struct x86_exception exception) { return emulator_read_write(ctxt, addr, (void )val, bytes, exception, &write_emultor); } #define CMPXCHG_TYPE(t, ptr, old, new) \ (cmpxchg((t )(ptr), (t )(old), (t )(new)) == (t )(old)) #ifdef CONFIG_X86_64 # define CMPXCHG64(ptr, old, new) CMPXCHG_TYPE(u64, ptr, old, new) #else # define CMPXCHG64(ptr, old, new) \ (cmpxchg64((u64 )(ptr), (u64 )(old), (u64 )(new)) == (u64 )(old)) #endif static int emulator_cmpxchg_emulated(struct x86_emulate_ctxt ctxt, unsigned long addr, const void old, const void new, unsigned int bytes, struct x86_exception exception) { struct kvm_vcpu vcpu = emul_to_vcpu(ctxt); gpa_t gpa; struct page page; char kaddr; bool exchanged; / guests cmpxchg8b have to be emulated atomically / if (bytes > 8 \|\| (bytes & (bytes - 1))) goto emul_write; gpa = kvm_mmu_gva_to_gpa_write(vcpu, addr, NULL); if (gpa == UNMAPPED_GVA \|\| (gpa & PAGE_MASK) == APIC_DEFAULT_PHYS_BASE) goto emul_write; if (((gpa + bytes - 1) & PAGE_MASK) != (gpa & PAGE_MASK)) goto emul_write; page = gfn_to_page(vcpu->kvm, gpa >> PAGE_SHIFT); if (is_error_page(page)) goto emul_write; kaddr = kmap_atomic(page); kaddr += offset_in_page(gpa); switch (bytes) { case 1: exchanged = CMPXCHG_TYPE(u8, kaddr, old, new); break; case 2: exchanged = CMPXCHG_TYPE(u16, kaddr, old, new); break; case 4: exchanged = CMPXCHG_TYPE(u32, kaddr, old, new); break; case 8: exchanged = CMPXCHG64(kaddr, old, new); break; default: BUG(); } kunmap_atomic(kaddr); kvm_release_page_dirty(page); if (!exchanged) return X86EMUL_CMPXCHG_FAILED; mark_page_dirty(vcpu->kvm, gpa >> PAGE_SHIFT); kvm_mmu_pte_write(vcpu, gpa, new, bytes); return X86EMUL_CONTINUE; emul_write: printk_once(KERN_WARNING "kvm: emulating exchange as write\n"); return emulator_write_emulated(ctxt, addr, new, bytes, exception); } static int kernel_pio(struct kvm_vcpu vcpu, void pd) { / TODO: String I/O for in kernel device / int r; if (vcpu->arch.pio.in) r = kvm_io_bus_read(vcpu->kvm, KVM_PIO_BUS, vcpu->arch.pio.port, vcpu->arch.pio.size, pd); else r = kvm_io_bus_write(vcpu->kvm, KVM_PIO_BUS, vcpu->arch.pio.port, vcpu->arch.pio.size, pd); return r; } static int emulator_pio_in_out(struct kvm_vcpu vcpu, int size, unsigned short port, void val, unsigned int count, bool in) { vcpu->arch.pio.port = port; vcpu->arch.pio.in = in; vcpu->arch.pio.count = count; vcpu->arch.pio.size = size; if (!kernel_pio(vcpu, vcpu->arch.pio_data)) { vcpu->arch.pio.count = 0; return 1; } vcpu->run->exit_reason = KVM_EXIT_IO; vcpu->run->io.direction = in ? KVM_EXIT_IO_IN : KVM_EXIT_IO_OUT; vcpu->run->io.size = size; vcpu->run->io.data_offset = KVM_PIO_PAGE_OFFSET PAGE_SIZE; vcpu->run->io.count = count; vcpu->run->io.port = port; return 0; } static int emulator_pio_in_emulated(struct x86_emulate_ctxt ctxt, int size, unsigned short port, void val, unsigned int count) { struct kvm_vcpu vcpu = emul_to_vcpu(ctxt); int ret; if (vcpu->arch.pio.count) goto data_avail; ret = emulator_pio_in_out(vcpu, size, port, val, count, true); if (ret) { data_avail: memcpy(val, vcpu->arch.pio_data, size count); trace_kvm_pio(KVM_PIO_IN, port, size, count, vcpu->arch.pio_data); vcpu->arch.pio.count = 0; return 1; } return 0; } static int emulator_pio_out_emulated(struct x86_emulate_ctxt ctxt, int size, unsigned short port, const void val, unsigned int count) { struct kvm_vcpu vcpu = emul_to_vcpu(ctxt); memcpy(vcpu->arch.pio_data, val, size count); trace_kvm_pio(KVM_PIO_OUT, port, size, count, vcpu->arch.pio_data); return emulator_pio_in_out(vcpu, size, port, (void )val, count, false); } static unsigned long get_segment_base(struct kvm_vcpu vcpu, int seg) { return kvm_x86_ops->get_segment_base(vcpu, seg); } static void emulator_invlpg(struct x86_emulate_ctxt ctxt, ulong address) { kvm_mmu_invlpg(emul_to_vcpu(ctxt), address); } int kvm_emulate_wbinvd(struct kvm_vcpu vcpu) { if (!need_emulate_wbinvd(vcpu)) return X86EMUL_CONTINUE; if (kvm_x86_ops->has_wbinvd_exit()) { int cpu = get_cpu(); cpumask_set_cpu(cpu, vcpu->arch.wbinvd_dirty_mask); smp_call_function_many(vcpu->arch.wbinvd_dirty_mask, wbinvd_ipi, NULL, 1); put_cpu(); cpumask_clear(vcpu->arch.wbinvd_dirty_mask); } else wbinvd(); return X86EMUL_CONTINUE; } EXPORT_SYMBOL_GPL(kvm_emulate_wbinvd); static void emulator_wbinvd(struct x86_emulate_ctxt ctxt) { kvm_emulate_wbinvd(emul_to_vcpu(ctxt)); } int emulator_get_dr(struct x86_emulate_ctxt ctxt, int dr, unsigned long dest) { return _kvm_get_dr(emul_to_vcpu(ctxt), dr, dest); } int emulator_set_dr(struct x86_emulate_ctxt ctxt, int dr, unsigned long value) { return __kvm_set_dr(emul_to_vcpu(ctxt), dr, value); } static u64 mk_cr_64(u64 curr_cr, u32 new_val) { return (curr_cr & ~((1ULL << 32) - 1)) \| new_val; } static unsigned long emulator_get_cr(struct x86_emulate_ctxt ctxt, int cr) { struct kvm_vcpu vcpu = emul_to_vcpu(ctxt); unsigned long value; switch (cr) { case 0: value = kvm_read_cr0(vcpu); break; case 2: value = vcpu->arch.cr2; break; case 3: value = kvm_read_cr3(vcpu); break; case 4: value = kvm_read_cr4(vcpu); break; case 8: value = kvm_get_cr8(vcpu); break; default: kvm_err("%s: unexpected cr %u\n", __func__, cr); return 0; } return value; } static int emulator_set_cr(struct x86_emulate_ctxt ctxt, int cr, ulong val) { struct kvm_vcpu vcpu = emul_to_vcpu(ctxt); int res = 0; switch (cr) { case 0: res = kvm_set_cr0(vcpu, mk_cr_64(kvm_read_cr0(vcpu), val)); break; case 2: vcpu->arch.cr2 = val; break; case 3: res = kvm_set_cr3(vcpu, val); break; case 4: res = kvm_set_cr4(vcpu, mk_cr_64(kvm_read_cr4(vcpu), val)); break; case 8: res = kvm_set_cr8(vcpu, val); break; default: kvm_err("%s: unexpected cr %u\n", __func__, cr); res = -1; } return res; } static int emulator_get_cpl(struct x86_emulate_ctxt ctxt) { return kvm_x86_ops->get_cpl(emul_to_vcpu(ctxt)); } static void emulator_get_gdt(struct x86_emulate_ctxt ctxt, struct desc_ptr dt) { kvm_x86_ops->get_gdt(emul_to_vcpu(ctxt), dt); } static void emulator_get_idt(struct x86_emulate_ctxt ctxt, struct desc_ptr dt) { kvm_x86_ops->get_idt(emul_to_vcpu(ctxt), dt); } static void emulator_set_gdt(struct x86_emulate_ctxt ctxt, struct desc_ptr dt) { kvm_x86_ops->set_gdt(emul_to_vcpu(ctxt), dt); } static void emulator_set_idt(struct x86_emulate_ctxt ctxt, struct desc_ptr dt) { kvm_x86_ops->set_idt(emul_to_vcpu(ctxt), dt); } static unsigned long emulator_get_cached_segment_base( struct x86_emulate_ctxt ctxt, int seg) { return get_segment_base(emul_to_vcpu(ctxt), seg); } static bool emulator_get_segment(struct x86_emulate_ctxt ctxt, u16 selector, struct desc_struct desc, u32 base3, int seg) { struct kvm_segment var; kvm_get_segment(emul_to_vcpu(ctxt), &var, seg); selector = var.selector; if (var.unusable) { memset(desc, 0, sizeof(desc)); return false; } if (var.g) var.limit >>= 12; set_desc_limit(desc, var.limit); set_desc_base(desc, (unsigned long)var.base); #ifdef CONFIG_X86_64 if (base3) base3 = var.base >> 32; #endif desc->type = var.type; desc->s = var.s; desc->dpl = var.dpl; desc->p = var.present; desc->avl = var.avl; desc->l = var.l; desc->d = var.db; desc->g = var.g; return true; } static void emulator_set_segment(struct x86_emulate_ctxt ctxt, u16 selector, struct desc_struct desc, u32 base3, int seg) { struct kvm_vcpu vcpu = emul_to_vcpu(ctxt); struct kvm_segment var; var.selector = selector; var.base = get_desc_base(desc); #ifdef CONFIG_X86_64 var.base \|= ((u64)base3) << 32; #endif var.limit = get_desc_limit(desc); if (desc->g) var.limit = (var.limit << 12) \| 0xfff; var.type = desc->type; var.dpl = desc->dpl; var.db = desc->d; var.s = desc->s; var.l = desc->l; var.g = desc->g; var.avl = desc->avl; var.present = desc->p; var.unusable = !var.present; var.padding = 0; kvm_set_segment(vcpu, &var, seg); return; } static int emulator_get_msr(struct x86_emulate_ctxt ctxt, u32 msr_index, u64 pdata) { return kvm_get_msr(emul_to_vcpu(ctxt), msr_index, pdata); } static int emulator_set_msr(struct x86_emulate_ctxt ctxt, u32 msr_index, u64 data) { struct msr_data msr; msr.data = data; msr.index = msr_index; msr.host_initiated = false; return kvm_set_msr(emul_to_vcpu(ctxt), &msr); } static int emulator_check_pmc(struct x86_emulate_ctxt ctxt, u32 pmc) { return kvm_pmu_check_pmc(emul_to_vcpu(ctxt), pmc); } static int emulator_read_pmc(struct x86_emulate_ctxt ctxt, u32 pmc, u64 pdata) { return kvm_pmu_read_pmc(emul_to_vcpu(ctxt), pmc, pdata); } static void emulator_halt(struct x86_emulate_ctxt ctxt) { emul_to_vcpu(ctxt)->arch.halt_request = 1; } static void emulator_get_fpu(struct x86_emulate_ctxt ctxt) { preempt_disable(); kvm_load_guest_fpu(emul_to_vcpu(ctxt)); /* * CR0.TS may reference the host fpu state, not the guest fpu state, * so it may be clear at this point. / clts(); } static void emulator_put_fpu(struct x86_emulate_ctxt ctxt) { preempt_enable(); } static int emulator_intercept(struct x86_emulate_ctxt ctxt, struct x86_instruction_info info, enum x86_intercept_stage stage) { return kvm_x86_ops->check_intercept(emul_to_vcpu(ctxt), info, stage); } static void emulator_get_cpuid(struct x86_emulate_ctxt ctxt, u32 eax, u32 ebx, u32 ecx, u32 edx) { kvm_cpuid(emul_to_vcpu(ctxt), eax, ebx, ecx, edx); } static ulong emulator_read_gpr(struct x86_emulate_ctxt ctxt, unsigned reg) { return kvm_register_read(emul_to_vcpu(ctxt), reg); } static void emulator_write_gpr(struct x86_emulate_ctxt ctxt, unsigned reg, ulong val) { kvm_register_write(emul_to_vcpu(ctxt), reg, val); } static const struct x86_emulate_ops emulate_ops = { .read_gpr = emulator_read_gpr, .write_gpr = emulator_write_gpr, .read_std = kvm_read_guest_virt_system, .write_std = kvm_write_guest_virt_system, .fetch = kvm_fetch_guest_virt, .read_emulated = emulator_read_emulated, .write_emulated = emulator_write_emulated, .cmpxchg_emulated = emulator_cmpxchg_emulated, .invlpg = emulator_invlpg, .pio_in_emulated = emulator_pio_in_emulated, .pio_out_emulated = emulator_pio_out_emulated, .get_segment = emulator_get_segment, .set_segment = emulator_set_segment, .get_cached_segment_base = emulator_get_cached_segment_base, .get_gdt = emulator_get_gdt, .get_idt = emulator_get_idt, .set_gdt = emulator_set_gdt, .set_idt = emulator_set_idt, .get_cr = emulator_get_cr, .set_cr = emulator_set_cr, .cpl = emulator_get_cpl, .get_dr = emulator_get_dr, .set_dr = emulator_set_dr, .set_msr = emulator_set_msr, .get_msr = emulator_get_msr, .check_pmc = emulator_check_pmc, .read_pmc = emulator_read_pmc, .halt = emulator_halt, .wbinvd = emulator_wbinvd, .fix_hypercall = emulator_fix_hypercall, .get_fpu = emulator_get_fpu, .put_fpu = emulator_put_fpu, .intercept = emulator_intercept, .get_cpuid = emulator_get_cpuid, }; static void toggle_interruptibility(struct kvm_vcpu vcpu, u32 mask) { u32 int_shadow = kvm_x86_ops->get_interrupt_shadow(vcpu); /* * an sti; sti; sequence only disable interrupts for the first * instruction. So, if the last instruction, be it emulated or * not, left the system with the INT_STI flag enabled, it * means that the last instruction is an sti. We should not * leave the flag on in this case. The same goes for mov ss / if (int_shadow & mask) mask = 0; if (unlikely(int_shadow \|\| mask)) { kvm_x86_ops->set_interrupt_shadow(vcpu, mask); if (!mask) kvm_make_request(KVM_REQ_EVENT, vcpu); } } static bool inject_emulated_exception(struct kvm_vcpu vcpu) { struct x86_emulate_ctxt ctxt = &vcpu->arch.emulate_ctxt; if (ctxt->exception.vector == PF_VECTOR) return kvm_propagate_fault(vcpu, &ctxt->exception); if (ctxt->exception.error_code_valid) kvm_queue_exception_e(vcpu, ctxt->exception.vector, ctxt->exception.error_code); else kvm_queue_exception(vcpu, ctxt->exception.vector); return false; } static void init_emulate_ctxt(struct kvm_vcpu vcpu) { struct x86_emulate_ctxt ctxt = &vcpu->arch.emulate_ctxt; int cs_db, cs_l; kvm_x86_ops->get_cs_db_l_bits(vcpu, &cs_db, &cs_l); ctxt->eflags = kvm_get_rflags(vcpu); ctxt->eip = kvm_rip_read(vcpu); ctxt->mode = (!is_protmode(vcpu)) ? X86EMUL_MODE_REAL : (ctxt->eflags & X86_EFLAGS_VM) ? X86EMUL_MODE_VM86 : (cs_l && is_long_mode(vcpu)) ? X86EMUL_MODE_PROT64 : cs_db ? X86EMUL_MODE_PROT32 : X86EMUL_MODE_PROT16; ctxt->guest_mode = is_guest_mode(vcpu); init_decode_cache(ctxt); vcpu->arch.emulate_regs_need_sync_from_vcpu = false; } int kvm_inject_realmode_interrupt(struct kvm_vcpu vcpu, int irq, int inc_eip) { struct x86_emulate_ctxt ctxt = &vcpu->arch.emulate_ctxt; int ret; init_emulate_ctxt(vcpu); ctxt->op_bytes = 2; ctxt->ad_bytes = 2; ctxt->_eip = ctxt->eip + inc_eip; ret = emulate_int_real(ctxt, irq); if (ret != X86EMUL_CONTINUE) return EMULATE_FAIL; ctxt->eip = ctxt->_eip; kvm_rip_write(vcpu, ctxt->eip); kvm_set_rflags(vcpu, ctxt->eflags); if (irq == NMI_VECTOR) vcpu->arch.nmi_pending = 0; else vcpu->arch.interrupt.pending = false; return EMULATE_DONE; } EXPORT_SYMBOL_GPL(kvm_inject_realmode_interrupt); static int handle_emulation_failure(struct kvm_vcpu vcpu) { int r = EMULATE_DONE; ++vcpu->stat.insn_emulation_fail; trace_kvm_emulate_insn_failed(vcpu); if (!is_guest_mode(vcpu) && kvm_x86_ops->get_cpl(vcpu) == 0) { vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR; vcpu->run->internal.suberror = KVM_INTERNAL_ERROR_EMULATION; vcpu->run->internal.ndata = 0; r = EMULATE_FAIL; } kvm_queue_exception(vcpu, UD_VECTOR); return r; } static bool reexecute_instruction(struct kvm_vcpu vcpu, gva_t cr2, bool write_fault_to_shadow_pgtable, int emulation_type) { gpa_t gpa = cr2; pfn_t pfn; if (emulation_type & EMULTYPE_NO_REEXECUTE) return false; if (!vcpu->arch.mmu.direct_map) { / * Write permission should be allowed since only * write access need to be emulated. / gpa = kvm_mmu_gva_to_gpa_write(vcpu, cr2, NULL); / * If the mapping is invalid in guest, let cpu retry * it to generate fault. / if (gpa == UNMAPPED_GVA) return true; } / * Do not retry the unhandleable instruction if it faults on the * readonly host memory, otherwise it will goto a infinite loop: * retry instruction -> write #PF -> emulation fail -> retry * instruction -> ... / pfn = gfn_to_pfn(vcpu->kvm, gpa_to_gfn(gpa)); / * If the instruction failed on the error pfn, it can not be fixed, * report the error to userspace. / if (is_error_noslot_pfn(pfn)) return false; kvm_release_pfn_clean(pfn); / The instructions are well-emulated on direct mmu. / if (vcpu->arch.mmu.direct_map) { unsigned int indirect_shadow_pages; spin_lock(&vcpu->kvm->mmu_lock); indirect_shadow_pages = vcpu->kvm->arch.indirect_shadow_pages; spin_unlock(&vcpu->kvm->mmu_lock); if (indirect_shadow_pages) kvm_mmu_unprotect_page(vcpu->kvm, gpa_to_gfn(gpa)); return true; } / * if emulation was due to access to shadowed page table * and it failed try to unshadow page and re-enter the * guest to let CPU execute the instruction. / kvm_mmu_unprotect_page(vcpu->kvm, gpa_to_gfn(gpa)); / * If the access faults on its page table, it can not * be fixed by unprotecting shadow page and it should * be reported to userspace. / return !write_fault_to_shadow_pgtable; } static bool retry_instruction(struct x86_emulate_ctxt ctxt, unsigned long cr2, int emulation_type) { struct kvm_vcpu vcpu = emul_to_vcpu(ctxt); unsigned long last_retry_eip, last_retry_addr, gpa = cr2; last_retry_eip = vcpu->arch.last_retry_eip; last_retry_addr = vcpu->arch.last_retry_addr; / * If the emulation is caused by #PF and it is non-page_table * writing instruction, it means the VM-EXIT is caused by shadow * page protected, we can zap the shadow page and retry this * instruction directly. * * Note: if the guest uses a non-page-table modifying instruction * on the PDE that points to the instruction, then we will unmap * the instruction and go to an infinite loop. So, we cache the * last retried eip and the last fault address, if we meet the eip * and the address again, we can break out of the potential infinite * loop. / vcpu->arch.last_retry_eip = vcpu->arch.last_retry_addr = 0; if (!(emulation_type & EMULTYPE_RETRY)) return false; if (x86_page_table_writing_insn(ctxt)) return false; if (ctxt->eip == last_retry_eip && last_retry_addr == cr2) return false; vcpu->arch.last_retry_eip = ctxt->eip; vcpu->arch.last_retry_addr = cr2; if (!vcpu->arch.mmu.direct_map) gpa = kvm_mmu_gva_to_gpa_write(vcpu, cr2, NULL); kvm_mmu_unprotect_page(vcpu->kvm, gpa_to_gfn(gpa)); return true; } static int complete_emulated_mmio(struct kvm_vcpu vcpu); static int complete_emulated_pio(struct kvm_vcpu vcpu); static int kvm_vcpu_check_hw_bp(unsigned long addr, u32 type, u32 dr7, unsigned long db) { u32 dr6 = 0; int i; u32 enable, rwlen; enable = dr7; rwlen = dr7 >> 16; for (i = 0; i < 4; i++, enable >>= 2, rwlen >>= 4) if ((enable & 3) && (rwlen & 15) == type && db[i] == addr) dr6 \|= (1 << i); return dr6; } static void kvm_vcpu_check_singlestep(struct kvm_vcpu vcpu, unsigned long rflags, int r) { struct kvm_run kvm_run = vcpu->run; / * rflags is the old, "raw" value of the flags. The new value has * not been saved yet. * * This is correct even for TF set by the guest, because "the * processor will not generate this exception after the instruction * that sets the TF flag". / if (unlikely(rflags & X86_EFLAGS_TF)) { if (vcpu->guest_debug & KVM_GUESTDBG_SINGLESTEP) { kvm_run->debug.arch.dr6 = DR6_BS \| DR6_FIXED_1 \| DR6_RTM; kvm_run->debug.arch.pc = vcpu->arch.singlestep_rip; kvm_run->debug.arch.exception = DB_VECTOR; kvm_run->exit_reason = KVM_EXIT_DEBUG; r = EMULATE_USER_EXIT; } else { vcpu->arch.emulate_ctxt.eflags &= ~X86_EFLAGS_TF; /* * "Certain debug exceptions may clear bit 0-3. The * remaining contents of the DR6 register are never * cleared by the processor". / vcpu->arch.dr6 &= ~15; vcpu->arch.dr6 \|= DR6_BS \| DR6_RTM; kvm_queue_exception(vcpu, DB_VECTOR); } } } static bool kvm_vcpu_check_breakpoint(struct kvm_vcpu vcpu, int r) { struct kvm_run kvm_run = vcpu->run; unsigned long eip = vcpu->arch.emulate_ctxt.eip; u32 dr6 = 0; if (unlikely(vcpu->guest_debug & KVM_GUESTDBG_USE_HW_BP) && (vcpu->arch.guest_debug_dr7 & DR7_BP_EN_MASK)) { dr6 = kvm_vcpu_check_hw_bp(eip, 0, vcpu->arch.guest_debug_dr7, vcpu->arch.eff_db); if (dr6 != 0) { kvm_run->debug.arch.dr6 = dr6 \| DR6_FIXED_1 \| DR6_RTM; kvm_run->debug.arch.pc = kvm_rip_read(vcpu) + get_segment_base(vcpu, VCPU_SREG_CS); kvm_run->debug.arch.exception = DB_VECTOR; kvm_run->exit_reason = KVM_EXIT_DEBUG; r = EMULATE_USER_EXIT; return true; } } if (unlikely(vcpu->arch.dr7 & DR7_BP_EN_MASK) && !(kvm_get_rflags(vcpu) & X86_EFLAGS_RF)) { dr6 = kvm_vcpu_check_hw_bp(eip, 0, vcpu->arch.dr7, vcpu->arch.db); if (dr6 != 0) { vcpu->arch.dr6 &= ~15; vcpu->arch.dr6 \|= dr6 \| DR6_RTM; kvm_queue_exception(vcpu, DB_VECTOR); r = EMULATE_DONE; return true; } } return false; } int x86_emulate_instruction(struct kvm_vcpu vcpu, unsigned long cr2, int emulation_type, void insn, int insn_len) { int r; struct x86_emulate_ctxt ctxt = &vcpu->arch.emulate_ctxt; bool writeback = true; bool write_fault_to_spt = vcpu->arch.write_fault_to_shadow_pgtable; / * Clear write_fault_to_shadow_pgtable here to ensure it is * never reused. / vcpu->arch.write_fault_to_shadow_pgtable = false; kvm_clear_exception_queue(vcpu); if (!(emulation_type & EMULTYPE_NO_DECODE)) { init_emulate_ctxt(vcpu); / * We will reenter on the same instruction since * we do not set complete_userspace_io. This does not * handle watchpoints yet, those would be handled in * the emulate_ops. / if (kvm_vcpu_check_breakpoint(vcpu, &r)) return r; ctxt->interruptibility = 0; ctxt->have_exception = false; ctxt->exception.vector = -1; ctxt->perm_ok = false; ctxt->ud = emulation_type & EMULTYPE_TRAP_UD; r = x86_decode_insn(ctxt, insn, insn_len); trace_kvm_emulate_insn_start(vcpu); ++vcpu->stat.insn_emulation; if (r != EMULATION_OK) { if (emulation_type & EMULTYPE_TRAP_UD) return EMULATE_FAIL; if (reexecute_instruction(vcpu, cr2, write_fault_to_spt, emulation_type)) return EMULATE_DONE; if (emulation_type & EMULTYPE_SKIP) return EMULATE_FAIL; return handle_emulation_failure(vcpu); } } if (emulation_type & EMULTYPE_SKIP) { kvm_rip_write(vcpu, ctxt->_eip); if (ctxt->eflags & X86_EFLAGS_RF) kvm_set_rflags(vcpu, ctxt->eflags & ~X86_EFLAGS_RF); return EMULATE_DONE; } if (retry_instruction(ctxt, cr2, emulation_type)) return EMULATE_DONE; / this is needed for vmware backdoor interface to work since it changes registers values during IO operation / if (vcpu->arch.emulate_regs_need_sync_from_vcpu) { vcpu->arch.emulate_regs_need_sync_from_vcpu = false; emulator_invalidate_register_cache(ctxt); } restart: r = x86_emulate_insn(ctxt); if (r == EMULATION_INTERCEPTED) return EMULATE_DONE; if (r == EMULATION_FAILED) { if (reexecute_instruction(vcpu, cr2, write_fault_to_spt, emulation_type)) return EMULATE_DONE; return handle_emulation_failure(vcpu); } if (ctxt->have_exception) { r = EMULATE_DONE; if (inject_emulated_exception(vcpu)) return r; } else if (vcpu->arch.pio.count) { if (!vcpu->arch.pio.in) { / FIXME: return into emulator if single-stepping. / vcpu->arch.pio.count = 0; } else { writeback = false; vcpu->arch.complete_userspace_io = complete_emulated_pio; } r = EMULATE_USER_EXIT; } else if (vcpu->mmio_needed) { if (!vcpu->mmio_is_write) writeback = false; r = EMULATE_USER_EXIT; vcpu->arch.complete_userspace_io = complete_emulated_mmio; } else if (r == EMULATION_RESTART) goto restart; else r = EMULATE_DONE; if (writeback) { unsigned long rflags = kvm_x86_ops->get_rflags(vcpu); toggle_interruptibility(vcpu, ctxt->interruptibility); vcpu->arch.emulate_regs_need_sync_to_vcpu = false; kvm_rip_write(vcpu, ctxt->eip); if (r == EMULATE_DONE) kvm_vcpu_check_singlestep(vcpu, rflags, &r); __kvm_set_rflags(vcpu, ctxt->eflags); / * For STI, interrupts are shadowed; so KVM_REQ_EVENT will * do nothing, and it will be requested again as soon as * the shadow expires. But we still need to check here, * because POPF has no interrupt shadow. / if (unlikely((ctxt->eflags & ~rflags) & X86_EFLAGS_IF)) kvm_make_request(KVM_REQ_EVENT, vcpu); } else vcpu->arch.emulate_regs_need_sync_to_vcpu = true; return r; } EXPORT_SYMBOL_GPL(x86_emulate_instruction); int kvm_fast_pio_out(struct kvm_vcpu vcpu, int size, unsigned short port) { unsigned long val = kvm_register_read(vcpu, VCPU_REGS_RAX); int ret = emulator_pio_out_emulated(&vcpu->arch.emulate_ctxt, size, port, &val, 1); /* do not return to emulator after return from userspace / vcpu->arch.pio.count = 0; return ret; } EXPORT_SYMBOL_GPL(kvm_fast_pio_out); static void tsc_bad(void info) { __this_cpu_write(cpu_tsc_khz, 0); } static void tsc_khz_changed(void data) { struct cpufreq_freqs freq = data; unsigned long khz = 0; if (data) khz = freq->new; else if (!boot_cpu_has(X86_FEATURE_CONSTANT_TSC)) khz = cpufreq_quick_get(raw_smp_processor_id()); if (!khz) khz = tsc_khz; __this_cpu_write(cpu_tsc_khz, khz); } static int kvmclock_cpufreq_notifier(struct notifier_block nb, unsigned long val, void data) { struct cpufreq_freqs freq = data; struct kvm kvm; struct kvm_vcpu vcpu; int i, send_ipi = 0; / * We allow guests to temporarily run on slowing clocks, * provided we notify them after, or to run on accelerating * clocks, provided we notify them before. Thus time never * goes backwards. * * However, we have a problem. We can't atomically update * the frequency of a given CPU from this function; it is * merely a notifier, which can be called from any CPU. * Changing the TSC frequency at arbitrary points in time * requires a recomputation of local variables related to * the TSC for each VCPU. We must flag these local variables * to be updated and be sure the update takes place with the * new frequency before any guests proceed. * * Unfortunately, the combination of hotplug CPU and frequency * change creates an intractable locking scenario; the order * of when these callouts happen is undefined with respect to * CPU hotplug, and they can race with each other. As such, * merely setting per_cpu(cpu_tsc_khz) = X during a hotadd is * undefined; you can actually have a CPU frequency change take * place in between the computation of X and the setting of the * variable. To protect against this problem, all updates of * the per_cpu tsc_khz variable are done in an interrupt * protected IPI, and all callers wishing to update the value * must wait for a synchronous IPI to complete (which is trivial * if the caller is on the CPU already). This establishes the * necessary total order on variable updates. * * Note that because a guest time update may take place * anytime after the setting of the VCPU's request bit, the * correct TSC value must be set before the request. However, * to ensure the update actually makes it to any guest which * starts running in hardware virtualization between the set * and the acquisition of the spinlock, we must also ping the * CPU after setting the request bit. * / if (val == CPUFREQ_PRECHANGE && freq->old > freq->new) return 0; if (val == CPUFREQ_POSTCHANGE && freq->old < freq->new) return 0; smp_call_function_single(freq->cpu, tsc_khz_changed, freq, 1); spin_lock(&kvm_lock); list_for_each_entry(kvm, &vm_list, vm_list) { kvm_for_each_vcpu(i, vcpu, kvm) { if (vcpu->cpu != freq->cpu) continue; kvm_make_request(KVM_REQ_CLOCK_UPDATE, vcpu); if (vcpu->cpu != smp_processor_id()) send_ipi = 1; } } spin_unlock(&kvm_lock); if (freq->old < freq->new && send_ipi) { / * We upscale the frequency. Must make the guest * doesn't see old kvmclock values while running with * the new frequency, otherwise we risk the guest sees * time go backwards. * * In case we update the frequency for another cpu * (which might be in guest context) send an interrupt * to kick the cpu out of guest context. Next time * guest context is entered kvmclock will be updated, * so the guest will not see stale values. / smp_call_function_single(freq->cpu, tsc_khz_changed, freq, 1); } return 0; } static struct notifier_block kvmclock_cpufreq_notifier_block = { .notifier_call = kvmclock_cpufreq_notifier }; static int kvmclock_cpu_notifier(struct notifier_block nfb, unsigned long action, void hcpu) { unsigned int cpu = (unsigned long)hcpu; switch (action) { case CPU_ONLINE: case CPU_DOWN_FAILED: smp_call_function_single(cpu, tsc_khz_changed, NULL, 1); break; case CPU_DOWN_PREPARE: smp_call_function_single(cpu, tsc_bad, NULL, 1); break; } return NOTIFY_OK; } static struct notifier_block kvmclock_cpu_notifier_block = { .notifier_call = kvmclock_cpu_notifier, .priority = -INT_MAX }; static void kvm_timer_init(void) { int cpu; max_tsc_khz = tsc_khz; cpu_notifier_register_begin(); if (!boot_cpu_has(X86_FEATURE_CONSTANT_TSC)) { #ifdef CONFIG_CPU_FREQ struct cpufreq_policy policy; memset(&policy, 0, sizeof(policy)); cpu = get_cpu(); cpufreq_get_policy(&policy, cpu); if (policy.cpuinfo.max_freq) max_tsc_khz = policy.cpuinfo.max_freq; put_cpu(); #endif cpufreq_register_notifier(&kvmclock_cpufreq_notifier_block, CPUFREQ_TRANSITION_NOTIFIER); } pr_debug("kvm: max_tsc_khz = %ld\n", max_tsc_khz); for_each_online_cpu(cpu) smp_call_function_single(cpu, tsc_khz_changed, NULL, 1); __register_hotcpu_notifier(&kvmclock_cpu_notifier_block); cpu_notifier_register_done(); } static DEFINE_PER_CPU(struct kvm_vcpu , current_vcpu); int kvm_is_in_guest(void) { return __this_cpu_read(current_vcpu) != NULL; } static int kvm_is_user_mode(void) { int user_mode = 3; if (__this_cpu_read(current_vcpu)) user_mode = kvm_x86_ops->get_cpl(__this_cpu_read(current_vcpu)); return user_mode != 0; } static unsigned long kvm_get_guest_ip(void) { unsigned long ip = 0; if (__this_cpu_read(current_vcpu)) ip = kvm_rip_read(__this_cpu_read(current_vcpu)); return ip; } static struct perf_guest_info_callbacks kvm_guest_cbs = { .is_in_guest = kvm_is_in_guest, .is_user_mode = kvm_is_user_mode, .get_guest_ip = kvm_get_guest_ip, }; void kvm_before_handle_nmi(struct kvm_vcpu vcpu) { __this_cpu_write(current_vcpu, vcpu); } EXPORT_SYMBOL_GPL(kvm_before_handle_nmi); void kvm_after_handle_nmi(struct kvm_vcpu vcpu) { __this_cpu_write(current_vcpu, NULL); } EXPORT_SYMBOL_GPL(kvm_after_handle_nmi); static void kvm_set_mmio_spte_mask(void) { u64 mask; int maxphyaddr = boot_cpu_data.x86_phys_bits; /* * Set the reserved bits and the present bit of an paging-structure * entry to generate page fault with PFER.RSV = 1. / / Mask the reserved physical address bits. / mask = rsvd_bits(maxphyaddr, 51); / Bit 62 is always reserved for 32bit host. / mask \|= 0x3ull << 62; / Set the present bit. / mask \|= 1ull; #ifdef CONFIG_X86_64 / * If reserved bit is not supported, clear the present bit to disable * mmio page fault. / if (maxphyaddr == 52) mask &= ~1ull; #endif kvm_mmu_set_mmio_spte_mask(mask); } #ifdef CONFIG_X86_64 static void pvclock_gtod_update_fn(struct work_struct work) { struct kvm kvm; struct kvm_vcpu vcpu; int i; spin_lock(&kvm_lock); list_for_each_entry(kvm, &vm_list, vm_list) kvm_for_each_vcpu(i, vcpu, kvm) kvm_make_request(KVM_REQ_MASTERCLOCK_UPDATE, vcpu); atomic_set(&kvm_guest_has_master_clock, 0); spin_unlock(&kvm_lock); } static DECLARE_WORK(pvclock_gtod_work, pvclock_gtod_update_fn); /* * Notification about pvclock gtod data update. / static int pvclock_gtod_notify(struct notifier_block nb, unsigned long unused, void priv) { struct pvclock_gtod_data gtod = &pvclock_gtod_data; struct timekeeper tk = priv; update_pvclock_gtod(tk); / disable master clock if host does not trust, or does not * use, TSC clocksource / if (gtod->clock.vclock_mode != VCLOCK_TSC && atomic_read(&kvm_guest_has_master_clock) != 0) queue_work(system_long_wq, &pvclock_gtod_work); return 0; } static struct notifier_block pvclock_gtod_notifier = { .notifier_call = pvclock_gtod_notify, }; #endif int kvm_arch_init(void opaque) { int r; struct kvm_x86_ops ops = opaque; if (kvm_x86_ops) { printk(KERN_ERR "kvm: already loaded the other module\n"); r = -EEXIST; goto out; } if (!ops->cpu_has_kvm_support()) { printk(KERN_ERR "kvm: no hardware support\n"); r = -EOPNOTSUPP; goto out; } if (ops->disabled_by_bios()) { printk(KERN_ERR "kvm: disabled by bios\n"); r = -EOPNOTSUPP; goto out; } r = -ENOMEM; shared_msrs = alloc_percpu(struct kvm_shared_msrs); if (!shared_msrs) { printk(KERN_ERR "kvm: failed to allocate percpu kvm_shared_msrs\n"); goto out; } r = kvm_mmu_module_init(); if (r) goto out_free_percpu; kvm_set_mmio_spte_mask(); kvm_x86_ops = ops; kvm_init_msr_list(); kvm_mmu_set_mask_ptes(PT_USER_MASK, PT_ACCESSED_MASK, PT_DIRTY_MASK, PT64_NX_MASK, 0); kvm_timer_init(); perf_register_guest_info_callbacks(&kvm_guest_cbs); if (cpu_has_xsave) host_xcr0 = xgetbv(XCR_XFEATURE_ENABLED_MASK); kvm_lapic_init(); #ifdef CONFIG_X86_64 pvclock_gtod_register_notifier(&pvclock_gtod_notifier); #endif return 0; out_free_percpu: free_percpu(shared_msrs); out: return r; } void kvm_arch_exit(void) { perf_unregister_guest_info_callbacks(&kvm_guest_cbs); if (!boot_cpu_has(X86_FEATURE_CONSTANT_TSC)) cpufreq_unregister_notifier(&kvmclock_cpufreq_notifier_block, CPUFREQ_TRANSITION_NOTIFIER); unregister_hotcpu_notifier(&kvmclock_cpu_notifier_block); #ifdef CONFIG_X86_64 pvclock_gtod_unregister_notifier(&pvclock_gtod_notifier); #endif kvm_x86_ops = NULL; kvm_mmu_module_exit(); free_percpu(shared_msrs); } int kvm_emulate_halt(struct kvm_vcpu vcpu) { ++vcpu->stat.halt_exits; if (irqchip_in_kernel(vcpu->kvm)) { vcpu->arch.mp_state = KVM_MP_STATE_HALTED; return 1; } else { vcpu->run->exit_reason = KVM_EXIT_HLT; return 0; } } EXPORT_SYMBOL_GPL(kvm_emulate_halt); int kvm_hv_hypercall(struct kvm_vcpu vcpu) { u64 param, ingpa, outgpa, ret; uint16_t code, rep_idx, rep_cnt, res = HV_STATUS_SUCCESS, rep_done = 0; bool fast, longmode; / * hypercall generates UD from non zero cpl and real mode * per HYPER-V spec / if (kvm_x86_ops->get_cpl(vcpu) != 0 \|\| !is_protmode(vcpu)) { kvm_queue_exception(vcpu, UD_VECTOR); return 0; } longmode = is_64_bit_mode(vcpu); if (!longmode) { param = ((u64)kvm_register_read(vcpu, VCPU_REGS_RDX) << 32) \| (kvm_register_read(vcpu, VCPU_REGS_RAX) & 0xffffffff); ingpa = ((u64)kvm_register_read(vcpu, VCPU_REGS_RBX) << 32) \| (kvm_register_read(vcpu, VCPU_REGS_RCX) & 0xffffffff); outgpa = ((u64)kvm_register_read(vcpu, VCPU_REGS_RDI) << 32) \| (kvm_register_read(vcpu, VCPU_REGS_RSI) & 0xffffffff); } #ifdef CONFIG_X86_64 else { param = kvm_register_read(vcpu, VCPU_REGS_RCX); ingpa = kvm_register_read(vcpu, VCPU_REGS_RDX); outgpa = kvm_register_read(vcpu, VCPU_REGS_R8); } #endif code = param & 0xffff; fast = (param >> 16) & 0x1; rep_cnt = (param >> 32) & 0xfff; rep_idx = (param >> 48) & 0xfff; trace_kvm_hv_hypercall(code, fast, rep_cnt, rep_idx, ingpa, outgpa); switch (code) { case HV_X64_HV_NOTIFY_LONG_SPIN_WAIT: kvm_vcpu_on_spin(vcpu); break; default: res = HV_STATUS_INVALID_HYPERCALL_CODE; break; } ret = res \| (((u64)rep_done & 0xfff) << 32); if (longmode) { kvm_register_write(vcpu, VCPU_REGS_RAX, ret); } else { kvm_register_write(vcpu, VCPU_REGS_RDX, ret >> 32); kvm_register_write(vcpu, VCPU_REGS_RAX, ret & 0xffffffff); } return 1; } / * kvm_pv_kick_cpu_op: Kick a vcpu. * * @apicid - apicid of vcpu to be kicked. / static void kvm_pv_kick_cpu_op(struct kvm kvm, unsigned long flags, int apicid) { struct kvm_lapic_irq lapic_irq; lapic_irq.shorthand = 0; lapic_irq.dest_mode = 0; lapic_irq.dest_id = apicid; lapic_irq.delivery_mode = APIC_DM_REMRD; kvm_irq_delivery_to_apic(kvm, 0, &lapic_irq, NULL); } int kvm_emulate_hypercall(struct kvm_vcpu vcpu) { unsigned long nr, a0, a1, a2, a3, ret; int op_64_bit, r = 1; if (kvm_hv_hypercall_enabled(vcpu->kvm)) return kvm_hv_hypercall(vcpu); nr = kvm_register_read(vcpu, VCPU_REGS_RAX); a0 = kvm_register_read(vcpu, VCPU_REGS_RBX); a1 = kvm_register_read(vcpu, VCPU_REGS_RCX); a2 = kvm_register_read(vcpu, VCPU_REGS_RDX); a3 = kvm_register_read(vcpu, VCPU_REGS_RSI); trace_kvm_hypercall(nr, a0, a1, a2, a3); op_64_bit = is_64_bit_mode(vcpu); if (!op_64_bit) { nr &= 0xFFFFFFFF; a0 &= 0xFFFFFFFF; a1 &= 0xFFFFFFFF; a2 &= 0xFFFFFFFF; a3 &= 0xFFFFFFFF; } if (kvm_x86_ops->get_cpl(vcpu) != 0) { ret = -KVM_EPERM; goto out; } switch (nr) { case KVM_HC_VAPIC_POLL_IRQ: ret = 0; break; case KVM_HC_KICK_CPU: kvm_pv_kick_cpu_op(vcpu->kvm, a0, a1); ret = 0; break; default: ret = -KVM_ENOSYS; break; } out: if (!op_64_bit) ret = (u32)ret; kvm_register_write(vcpu, VCPU_REGS_RAX, ret); ++vcpu->stat.hypercalls; return r; } EXPORT_SYMBOL_GPL(kvm_emulate_hypercall); static int emulator_fix_hypercall(struct x86_emulate_ctxt ctxt) { struct kvm_vcpu vcpu = emul_to_vcpu(ctxt); char instruction[3]; unsigned long rip = kvm_rip_read(vcpu); kvm_x86_ops->patch_hypercall(vcpu, instruction); return emulator_write_emulated(ctxt, rip, instruction, 3, NULL); } / * Check if userspace requested an interrupt window, and that the * interrupt window is open. * * No need to exit to userspace if we already have an interrupt queued. / static int dm_request_for_irq_injection(struct kvm_vcpu vcpu) { return (!irqchip_in_kernel(vcpu->kvm) && !kvm_cpu_has_interrupt(vcpu) && vcpu->run->request_interrupt_window && kvm_arch_interrupt_allowed(vcpu)); } static void post_kvm_run_save(struct kvm_vcpu vcpu) { struct kvm_run kvm_run = vcpu->run; kvm_run->if_flag = (kvm_get_rflags(vcpu) & X86_EFLAGS_IF) != 0; kvm_run->cr8 = kvm_get_cr8(vcpu); kvm_run->apic_base = kvm_get_apic_base(vcpu); if (irqchip_in_kernel(vcpu->kvm)) kvm_run->ready_for_interrupt_injection = 1; else kvm_run->ready_for_interrupt_injection = kvm_arch_interrupt_allowed(vcpu) && !kvm_cpu_has_interrupt(vcpu) && !kvm_event_needs_reinjection(vcpu); } static void update_cr8_intercept(struct kvm_vcpu vcpu) { int max_irr, tpr; if (!kvm_x86_ops->update_cr8_intercept) return; if (!vcpu->arch.apic) return; if (!vcpu->arch.apic->vapic_addr) max_irr = kvm_lapic_find_highest_irr(vcpu); else max_irr = -1; if (max_irr != -1) max_irr >>= 4; tpr = kvm_lapic_get_cr8(vcpu); kvm_x86_ops->update_cr8_intercept(vcpu, tpr, max_irr); } static int inject_pending_event(struct kvm_vcpu vcpu, bool req_int_win) { int r; /* try to reinject previous events if any / if (vcpu->arch.exception.pending) { trace_kvm_inj_exception(vcpu->arch.exception.nr, vcpu->arch.exception.has_error_code, vcpu->arch.exception.error_code); if (exception_type(vcpu->arch.exception.nr) == EXCPT_FAULT) __kvm_set_rflags(vcpu, kvm_get_rflags(vcpu) \| X86_EFLAGS_RF); kvm_x86_ops->queue_exception(vcpu, vcpu->arch.exception.nr, vcpu->arch.exception.has_error_code, vcpu->arch.exception.error_code, vcpu->arch.exception.reinject); return 0; } if (vcpu->arch.nmi_injected) { kvm_x86_ops->set_nmi(vcpu); return 0; } if (vcpu->arch.interrupt.pending) { kvm_x86_ops->set_irq(vcpu); return 0; } if (is_guest_mode(vcpu) && kvm_x86_ops->check_nested_events) { r = kvm_x86_ops->check_nested_events(vcpu, req_int_win); if (r != 0) return r; } / try to inject new event if pending / if (vcpu->arch.nmi_pending) { if (kvm_x86_ops->nmi_allowed(vcpu)) { --vcpu->arch.nmi_pending; vcpu->arch.nmi_injected = true; kvm_x86_ops->set_nmi(vcpu); } } else if (kvm_cpu_has_injectable_intr(vcpu)) { / * Because interrupts can be injected asynchronously, we are * calling check_nested_events again here to avoid a race condition. * See https://lkml.org/lkml/2014/7/2/60 for discussion about this * proposal and current concerns. Perhaps we should be setting * KVM_REQ_EVENT only on certain events and not unconditionally? / if (is_guest_mode(vcpu) && kvm_x86_ops->check_nested_events) { r = kvm_x86_ops->check_nested_events(vcpu, req_int_win); if (r != 0) return r; } if (kvm_x86_ops->interrupt_allowed(vcpu)) { kvm_queue_interrupt(vcpu, kvm_cpu_get_interrupt(vcpu), false); kvm_x86_ops->set_irq(vcpu); } } return 0; } static void process_nmi(struct kvm_vcpu vcpu) { unsigned limit = 2; /* * x86 is limited to one NMI running, and one NMI pending after it. * If an NMI is already in progress, limit further NMIs to just one. * Otherwise, allow two (and we'll inject the first one immediately). / if (kvm_x86_ops->get_nmi_mask(vcpu) \|\| vcpu->arch.nmi_injected) limit = 1; vcpu->arch.nmi_pending += atomic_xchg(&vcpu->arch.nmi_queued, 0); vcpu->arch.nmi_pending = min(vcpu->arch.nmi_pending, limit); kvm_make_request(KVM_REQ_EVENT, vcpu); } static void vcpu_scan_ioapic(struct kvm_vcpu vcpu) { u64 eoi_exit_bitmap[4]; u32 tmr[8]; if (!kvm_apic_hw_enabled(vcpu->arch.apic)) return; memset(eoi_exit_bitmap, 0, 32); memset(tmr, 0, 32); kvm_ioapic_scan_entry(vcpu, eoi_exit_bitmap, tmr); kvm_x86_ops->load_eoi_exitmap(vcpu, eoi_exit_bitmap); kvm_apic_update_tmr(vcpu, tmr); } static void kvm_vcpu_flush_tlb(struct kvm_vcpu vcpu) { ++vcpu->stat.tlb_flush; kvm_x86_ops->tlb_flush(vcpu); } void kvm_vcpu_reload_apic_access_page(struct kvm_vcpu vcpu) { struct page page = NULL; if (!irqchip_in_kernel(vcpu->kvm)) return; if (!kvm_x86_ops->set_apic_access_page_addr) return; page = gfn_to_page(vcpu->kvm, APIC_DEFAULT_PHYS_BASE >> PAGE_SHIFT); kvm_x86_ops->set_apic_access_page_addr(vcpu, page_to_phys(page)); / * Do not pin apic access page in memory, the MMU notifier * will call us again if it is migrated or swapped out. / put_page(page); } EXPORT_SYMBOL_GPL(kvm_vcpu_reload_apic_access_page); void kvm_arch_mmu_notifier_invalidate_page(struct kvm kvm, unsigned long address) { /* * The physical address of apic access page is stored in the VMCS. * Update it when it becomes invalid. / if (address == gfn_to_hva(kvm, APIC_DEFAULT_PHYS_BASE >> PAGE_SHIFT)) kvm_make_all_cpus_request(kvm, KVM_REQ_APIC_PAGE_RELOAD); } / * Returns 1 to let __vcpu_run() continue the guest execution loop without * exiting to the userspace. Otherwise, the value will be returned to the * userspace. / static int vcpu_enter_guest(struct kvm_vcpu vcpu) { int r; bool req_int_win = !irqchip_in_kernel(vcpu->kvm) && vcpu->run->request_interrupt_window; bool req_immediate_exit = false; if (vcpu->requests) { if (kvm_check_request(KVM_REQ_MMU_RELOAD, vcpu)) kvm_mmu_unload(vcpu); if (kvm_check_request(KVM_REQ_MIGRATE_TIMER, vcpu)) __kvm_migrate_timers(vcpu); if (kvm_check_request(KVM_REQ_MASTERCLOCK_UPDATE, vcpu)) kvm_gen_update_masterclock(vcpu->kvm); if (kvm_check_request(KVM_REQ_GLOBAL_CLOCK_UPDATE, vcpu)) kvm_gen_kvmclock_update(vcpu); if (kvm_check_request(KVM_REQ_CLOCK_UPDATE, vcpu)) { r = kvm_guest_time_update(vcpu); if (unlikely(r)) goto out; } if (kvm_check_request(KVM_REQ_MMU_SYNC, vcpu)) kvm_mmu_sync_roots(vcpu); if (kvm_check_request(KVM_REQ_TLB_FLUSH, vcpu)) kvm_vcpu_flush_tlb(vcpu); if (kvm_check_request(KVM_REQ_REPORT_TPR_ACCESS, vcpu)) { vcpu->run->exit_reason = KVM_EXIT_TPR_ACCESS; r = 0; goto out; } if (kvm_check_request(KVM_REQ_TRIPLE_FAULT, vcpu)) { vcpu->run->exit_reason = KVM_EXIT_SHUTDOWN; r = 0; goto out; } if (kvm_check_request(KVM_REQ_DEACTIVATE_FPU, vcpu)) { vcpu->fpu_active = 0; kvm_x86_ops->fpu_deactivate(vcpu); } if (kvm_check_request(KVM_REQ_APF_HALT, vcpu)) { /* Page is swapped out. Do synthetic halt / vcpu->arch.apf.halted = true; r = 1; goto out; } if (kvm_check_request(KVM_REQ_STEAL_UPDATE, vcpu)) record_steal_time(vcpu); if (kvm_check_request(KVM_REQ_NMI, vcpu)) process_nmi(vcpu); if (kvm_check_request(KVM_REQ_PMU, vcpu)) kvm_handle_pmu_event(vcpu); if (kvm_check_request(KVM_REQ_PMI, vcpu)) kvm_deliver_pmi(vcpu); if (kvm_check_request(KVM_REQ_SCAN_IOAPIC, vcpu)) vcpu_scan_ioapic(vcpu); if (kvm_check_request(KVM_REQ_APIC_PAGE_RELOAD, vcpu)) kvm_vcpu_reload_apic_access_page(vcpu); } if (kvm_check_request(KVM_REQ_EVENT, vcpu) \|\| req_int_win) { kvm_apic_accept_events(vcpu); if (vcpu->arch.mp_state == KVM_MP_STATE_INIT_RECEIVED) { r = 1; goto out; } if (inject_pending_event(vcpu, req_int_win) != 0) req_immediate_exit = true; / enable NMI/IRQ window open exits if needed / else if (vcpu->arch.nmi_pending) kvm_x86_ops->enable_nmi_window(vcpu); else if (kvm_cpu_has_injectable_intr(vcpu) \|\| req_int_win) kvm_x86_ops->enable_irq_window(vcpu); if (kvm_lapic_enabled(vcpu)) { / * Update architecture specific hints for APIC * virtual interrupt delivery. / if (kvm_x86_ops->hwapic_irr_update) kvm_x86_ops->hwapic_irr_update(vcpu, kvm_lapic_find_highest_irr(vcpu)); update_cr8_intercept(vcpu); kvm_lapic_sync_to_vapic(vcpu); } } r = kvm_mmu_reload(vcpu); if (unlikely(r)) { goto cancel_injection; } preempt_disable(); kvm_x86_ops->prepare_guest_switch(vcpu); if (vcpu->fpu_active) kvm_load_guest_fpu(vcpu); kvm_load_guest_xcr0(vcpu); vcpu->mode = IN_GUEST_MODE; srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx); / We should set ->mode before check ->requests, * see the comment in make_all_cpus_request. / smp_mb__after_srcu_read_unlock(); local_irq_disable(); if (vcpu->mode == EXITING_GUEST_MODE \|\| vcpu->requests \|\| need_resched() \|\| signal_pending(current)) { vcpu->mode = OUTSIDE_GUEST_MODE; smp_wmb(); local_irq_enable(); preempt_enable(); vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); r = 1; goto cancel_injection; } if (req_immediate_exit) smp_send_reschedule(vcpu->cpu); kvm_guest_enter(); if (unlikely(vcpu->arch.switch_db_regs)) { set_debugreg(0, 7); set_debugreg(vcpu->arch.eff_db[0], 0); set_debugreg(vcpu->arch.eff_db[1], 1); set_debugreg(vcpu->arch.eff_db[2], 2); set_debugreg(vcpu->arch.eff_db[3], 3); set_debugreg(vcpu->arch.dr6, 6); } trace_kvm_entry(vcpu->vcpu_id); kvm_x86_ops->run(vcpu); / * Do this here before restoring debug registers on the host. And * since we do this before handling the vmexit, a DR access vmexit * can (a) read the correct value of the debug registers, (b) set * KVM_DEBUGREG_WONT_EXIT again. / if (unlikely(vcpu->arch.switch_db_regs & KVM_DEBUGREG_WONT_EXIT)) { int i; WARN_ON(vcpu->guest_debug & KVM_GUESTDBG_USE_HW_BP); kvm_x86_ops->sync_dirty_debug_regs(vcpu); for (i = 0; i < KVM_NR_DB_REGS; i++) vcpu->arch.eff_db[i] = vcpu->arch.db[i]; } / * If the guest has used debug registers, at least dr7 * will be disabled while returning to the host. * If we don't have active breakpoints in the host, we don't * care about the messed up debug address registers. But if * we have some of them active, restore the old state. / if (hw_breakpoint_active()) hw_breakpoint_restore(); vcpu->arch.last_guest_tsc = kvm_x86_ops->read_l1_tsc(vcpu, native_read_tsc()); vcpu->mode = OUTSIDE_GUEST_MODE; smp_wmb(); / Interrupt is enabled by handle_external_intr() / kvm_x86_ops->handle_external_intr(vcpu); ++vcpu->stat.exits; / * We must have an instruction between local_irq_enable() and * kvm_guest_exit(), so the timer interrupt isn't delayed by * the interrupt shadow. The stat.exits increment will do nicely. * But we need to prevent reordering, hence this barrier(): / barrier(); kvm_guest_exit(); preempt_enable(); vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); / * Profile KVM exit RIPs: / if (unlikely(prof_on == KVM_PROFILING)) { unsigned long rip = kvm_rip_read(vcpu); profile_hit(KVM_PROFILING, (void )rip); } if (unlikely(vcpu->arch.tsc_always_catchup)) kvm_make_request(KVM_REQ_CLOCK_UPDATE, vcpu); if (vcpu->arch.apic_attention) kvm_lapic_sync_from_vapic(vcpu); r = kvm_x86_ops->handle_exit(vcpu); return r; cancel_injection: kvm_x86_ops->cancel_injection(vcpu); if (unlikely(vcpu->arch.apic_attention)) kvm_lapic_sync_from_vapic(vcpu); out: return r; } static int __vcpu_run(struct kvm_vcpu vcpu) { int r; struct kvm kvm = vcpu->kvm; vcpu->srcu_idx = srcu_read_lock(&kvm->srcu); r = 1; while (r > 0) { if (vcpu->arch.mp_state == KVM_MP_STATE_RUNNABLE && !vcpu->arch.apf.halted) r = vcpu_enter_guest(vcpu); else { srcu_read_unlock(&kvm->srcu, vcpu->srcu_idx); kvm_vcpu_block(vcpu); vcpu->srcu_idx = srcu_read_lock(&kvm->srcu); if (kvm_check_request(KVM_REQ_UNHALT, vcpu)) { kvm_apic_accept_events(vcpu); switch(vcpu->arch.mp_state) { case KVM_MP_STATE_HALTED: vcpu->arch.pv.pv_unhalted = false; vcpu->arch.mp_state = KVM_MP_STATE_RUNNABLE; case KVM_MP_STATE_RUNNABLE: vcpu->arch.apf.halted = false; break; case KVM_MP_STATE_INIT_RECEIVED: break; default: r = -EINTR; break; } } } if (r <= 0) break; clear_bit(KVM_REQ_PENDING_TIMER, &vcpu->requests); if (kvm_cpu_has_pending_timer(vcpu)) kvm_inject_pending_timer_irqs(vcpu); if (dm_request_for_irq_injection(vcpu)) { r = -EINTR; vcpu->run->exit_reason = KVM_EXIT_INTR; ++vcpu->stat.request_irq_exits; } kvm_check_async_pf_completion(vcpu); if (signal_pending(current)) { r = -EINTR; vcpu->run->exit_reason = KVM_EXIT_INTR; ++vcpu->stat.signal_exits; } if (need_resched()) { srcu_read_unlock(&kvm->srcu, vcpu->srcu_idx); cond_resched(); vcpu->srcu_idx = srcu_read_lock(&kvm->srcu); } } srcu_read_unlock(&kvm->srcu, vcpu->srcu_idx); return r; } static inline int complete_emulated_io(struct kvm_vcpu vcpu) { int r; vcpu->srcu_idx = srcu_read_lock(&vcpu->kvm->srcu); r = emulate_instruction(vcpu, EMULTYPE_NO_DECODE); srcu_read_unlock(&vcpu->kvm->srcu, vcpu->srcu_idx); if (r != EMULATE_DONE) return 0; return 1; } static int complete_emulated_pio(struct kvm_vcpu vcpu) { BUG_ON(!vcpu->arch.pio.count); return complete_emulated_io(vcpu); } /* * Implements the following, as a state machine: * * read: * for each fragment * for each mmio piece in the fragment * write gpa, len * exit * copy data * execute insn * * write: * for each fragment * for each mmio piece in the fragment * write gpa, len * copy data * exit / static int complete_emulated_mmio(struct kvm_vcpu vcpu) { struct kvm_run run = vcpu->run; struct kvm_mmio_fragment frag; unsigned len; BUG_ON(!vcpu->mmio_needed); /* Complete previous fragment / frag = &vcpu->mmio_fragments[vcpu->mmio_cur_fragment]; len = min(8u, frag->len); if (!vcpu->mmio_is_write) memcpy(frag->data, run->mmio.data, len); if (frag->len <= 8) { / Switch to the next fragment. / frag++; vcpu->mmio_cur_fragment++; } else { / Go forward to the next mmio piece. / frag->data += len; frag->gpa += len; frag->len -= len; } if (vcpu->mmio_cur_fragment >= vcpu->mmio_nr_fragments) { vcpu->mmio_needed = 0; / FIXME: return into emulator if single-stepping. / if (vcpu->mmio_is_write) return 1; vcpu->mmio_read_completed = 1; return complete_emulated_io(vcpu); } run->exit_reason = KVM_EXIT_MMIO; run->mmio.phys_addr = frag->gpa; if (vcpu->mmio_is_write) memcpy(run->mmio.data, frag->data, min(8u, frag->len)); run->mmio.len = min(8u, frag->len); run->mmio.is_write = vcpu->mmio_is_write; vcpu->arch.complete_userspace_io = complete_emulated_mmio; return 0; } int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu vcpu, struct kvm_run kvm_run) { int r; sigset_t sigsaved; if (!tsk_used_math(current) && init_fpu(current)) return -ENOMEM; if (vcpu->sigset_active) sigprocmask(SIG_SETMASK, &vcpu->sigset, &sigsaved); if (unlikely(vcpu->arch.mp_state == KVM_MP_STATE_UNINITIALIZED)) { kvm_vcpu_block(vcpu); kvm_apic_accept_events(vcpu); clear_bit(KVM_REQ_UNHALT, &vcpu->requests); r = -EAGAIN; goto out; } / re-sync apic's tpr / if (!irqchip_in_kernel(vcpu->kvm)) { if (kvm_set_cr8(vcpu, kvm_run->cr8) != 0) { r = -EINVAL; goto out; } } if (unlikely(vcpu->arch.complete_userspace_io)) { int (cui)(struct kvm_vcpu ) = vcpu->arch.complete_userspace_io; vcpu->arch.complete_userspace_io = NULL; r = cui(vcpu); if (r <= 0) goto out; } else WARN_ON(vcpu->arch.pio.count \|\| vcpu->mmio_needed); r = __vcpu_run(vcpu); out: post_kvm_run_save(vcpu); if (vcpu->sigset_active) sigprocmask(SIG_SETMASK, &sigsaved, NULL); return r; } int kvm_arch_vcpu_ioctl_get_regs(struct kvm_vcpu vcpu, struct kvm_regs regs) { if (vcpu->arch.emulate_regs_need_sync_to_vcpu) { / * We are here if userspace calls get_regs() in the middle of * instruction emulation. Registers state needs to be copied * back from emulation context to vcpu. Userspace shouldn't do * that usually, but some bad designed PV devices (vmware * backdoor interface) need this to work / emulator_writeback_register_cache(&vcpu->arch.emulate_ctxt); vcpu->arch.emulate_regs_need_sync_to_vcpu = false; } regs->rax = kvm_register_read(vcpu, VCPU_REGS_RAX); regs->rbx = kvm_register_read(vcpu, VCPU_REGS_RBX); regs->rcx = kvm_register_read(vcpu, VCPU_REGS_RCX); regs->rdx = kvm_register_read(vcpu, VCPU_REGS_RDX); regs->rsi = kvm_register_read(vcpu, VCPU_REGS_RSI); regs->rdi = kvm_register_read(vcpu, VCPU_REGS_RDI); regs->rsp = kvm_register_read(vcpu, VCPU_REGS_RSP); regs->rbp = kvm_register_read(vcpu, VCPU_REGS_RBP); #ifdef CONFIG_X86_64 regs->r8 = kvm_register_read(vcpu, VCPU_REGS_R8); regs->r9 = kvm_register_read(vcpu, VCPU_REGS_R9); regs->r10 = kvm_register_read(vcpu, VCPU_REGS_R10); regs->r11 = kvm_register_read(vcpu, VCPU_REGS_R11); regs->r12 = kvm_register_read(vcpu, VCPU_REGS_R12); regs->r13 = kvm_register_read(vcpu, VCPU_REGS_R13); regs->r14 = kvm_register_read(vcpu, VCPU_REGS_R14); regs->r15 = kvm_register_read(vcpu, VCPU_REGS_R15); #endif regs->rip = kvm_rip_read(vcpu); regs->rflags = kvm_get_rflags(vcpu); return 0; } int kvm_arch_vcpu_ioctl_set_regs(struct kvm_vcpu vcpu, struct kvm_regs regs) { vcpu->arch.emulate_regs_need_sync_from_vcpu = true; vcpu->arch.emulate_regs_need_sync_to_vcpu = false; kvm_register_write(vcpu, VCPU_REGS_RAX, regs->rax); kvm_register_write(vcpu, VCPU_REGS_RBX, regs->rbx); kvm_register_write(vcpu, VCPU_REGS_RCX, regs->rcx); kvm_register_write(vcpu, VCPU_REGS_RDX, regs->rdx); kvm_register_write(vcpu, VCPU_REGS_RSI, regs->rsi); kvm_register_write(vcpu, VCPU_REGS_RDI, regs->rdi); kvm_register_write(vcpu, VCPU_REGS_RSP, regs->rsp); kvm_register_write(vcpu, VCPU_REGS_RBP, regs->rbp); #ifdef CONFIG_X86_64 kvm_register_write(vcpu, VCPU_REGS_R8, regs->r8); kvm_register_write(vcpu, VCPU_REGS_R9, regs->r9); kvm_register_write(vcpu, VCPU_REGS_R10, regs->r10); kvm_register_write(vcpu, VCPU_REGS_R11, regs->r11); kvm_register_write(vcpu, VCPU_REGS_R12, regs->r12); kvm_register_write(vcpu, VCPU_REGS_R13, regs->r13); kvm_register_write(vcpu, VCPU_REGS_R14, regs->r14); kvm_register_write(vcpu, VCPU_REGS_R15, regs->r15); #endif kvm_rip_write(vcpu, regs->rip); kvm_set_rflags(vcpu, regs->rflags); vcpu->arch.exception.pending = false; kvm_make_request(KVM_REQ_EVENT, vcpu); return 0; } void kvm_get_cs_db_l_bits(struct kvm_vcpu vcpu, int db, int l) { struct kvm_segment cs; kvm_get_segment(vcpu, &cs, VCPU_SREG_CS); db = cs.db; l = cs.l; } EXPORT_SYMBOL_GPL(kvm_get_cs_db_l_bits); int kvm_arch_vcpu_ioctl_get_sregs(struct kvm_vcpu vcpu, struct kvm_sregs sregs) { struct desc_ptr dt; kvm_get_segment(vcpu, &sregs->cs, VCPU_SREG_CS); kvm_get_segment(vcpu, &sregs->ds, VCPU_SREG_DS); kvm_get_segment(vcpu, &sregs->es, VCPU_SREG_ES); kvm_get_segment(vcpu, &sregs->fs, VCPU_SREG_FS); kvm_get_segment(vcpu, &sregs->gs, VCPU_SREG_GS); kvm_get_segment(vcpu, &sregs->ss, VCPU_SREG_SS); kvm_get_segment(vcpu, &sregs->tr, VCPU_SREG_TR); kvm_get_segment(vcpu, &sregs->ldt, VCPU_SREG_LDTR); kvm_x86_ops->get_idt(vcpu, &dt); sregs->idt.limit = dt.size; sregs->idt.base = dt.address; kvm_x86_ops->get_gdt(vcpu, &dt); sregs->gdt.limit = dt.size; sregs->gdt.base = dt.address; sregs->cr0 = kvm_read_cr0(vcpu); sregs->cr2 = vcpu->arch.cr2; sregs->cr3 = kvm_read_cr3(vcpu); sregs->cr4 = kvm_read_cr4(vcpu); sregs->cr8 = kvm_get_cr8(vcpu); sregs->efer = vcpu->arch.efer; sregs->apic_base = kvm_get_apic_base(vcpu); memset(sregs->interrupt_bitmap, 0, sizeof sregs->interrupt_bitmap); if (vcpu->arch.interrupt.pending && !vcpu->arch.interrupt.soft) set_bit(vcpu->arch.interrupt.nr, (unsigned long )sregs->interrupt_bitmap); return 0; } int kvm_arch_vcpu_ioctl_get_mpstate(struct kvm_vcpu vcpu, struct kvm_mp_state mp_state) { kvm_apic_accept_events(vcpu); if (vcpu->arch.mp_state == KVM_MP_STATE_HALTED && vcpu->arch.pv.pv_unhalted) mp_state->mp_state = KVM_MP_STATE_RUNNABLE; else mp_state->mp_state = vcpu->arch.mp_state; return 0; } int kvm_arch_vcpu_ioctl_set_mpstate(struct kvm_vcpu vcpu, struct kvm_mp_state mp_state) { if (!kvm_vcpu_has_lapic(vcpu) && mp_state->mp_state != KVM_MP_STATE_RUNNABLE) return -EINVAL; if (mp_state->mp_state == KVM_MP_STATE_SIPI_RECEIVED) { vcpu->arch.mp_state = KVM_MP_STATE_INIT_RECEIVED; set_bit(KVM_APIC_SIPI, &vcpu->arch.apic->pending_events); } else vcpu->arch.mp_state = mp_state->mp_state; kvm_make_request(KVM_REQ_EVENT, vcpu); return 0; } int kvm_task_switch(struct kvm_vcpu vcpu, u16 tss_selector, int idt_index, int reason, bool has_error_code, u32 error_code) { struct x86_emulate_ctxt ctxt = &vcpu->arch.emulate_ctxt; int ret; init_emulate_ctxt(vcpu); ret = emulator_task_switch(ctxt, tss_selector, idt_index, reason, has_error_code, error_code); if (ret) return EMULATE_FAIL; kvm_rip_write(vcpu, ctxt->eip); kvm_set_rflags(vcpu, ctxt->eflags); kvm_make_request(KVM_REQ_EVENT, vcpu); return EMULATE_DONE; } EXPORT_SYMBOL_GPL(kvm_task_switch); int kvm_arch_vcpu_ioctl_set_sregs(struct kvm_vcpu vcpu, struct kvm_sregs sregs) { struct msr_data apic_base_msr; int mmu_reset_needed = 0; int pending_vec, max_bits, idx; struct desc_ptr dt; if (!guest_cpuid_has_xsave(vcpu) && (sregs->cr4 & X86_CR4_OSXSAVE)) return -EINVAL; dt.size = sregs->idt.limit; dt.address = sregs->idt.base; kvm_x86_ops->set_idt(vcpu, &dt); dt.size = sregs->gdt.limit; dt.address = sregs->gdt.base; kvm_x86_ops->set_gdt(vcpu, &dt); vcpu->arch.cr2 = sregs->cr2; mmu_reset_needed \|= kvm_read_cr3(vcpu) != sregs->cr3; vcpu->arch.cr3 = sregs->cr3; __set_bit(VCPU_EXREG_CR3, (ulong )&vcpu->arch.regs_avail); kvm_set_cr8(vcpu, sregs->cr8); mmu_reset_needed \|= vcpu->arch.efer != sregs->efer; kvm_x86_ops->set_efer(vcpu, sregs->efer); apic_base_msr.data = sregs->apic_base; apic_base_msr.host_initiated = true; kvm_set_apic_base(vcpu, &apic_base_msr); mmu_reset_needed \|= kvm_read_cr0(vcpu) != sregs->cr0; kvm_x86_ops->set_cr0(vcpu, sregs->cr0); vcpu->arch.cr0 = sregs->cr0; mmu_reset_needed \|= kvm_read_cr4(vcpu) != sregs->cr4; kvm_x86_ops->set_cr4(vcpu, sregs->cr4); if (sregs->cr4 & X86_CR4_OSXSAVE) kvm_update_cpuid(vcpu); idx = srcu_read_lock(&vcpu->kvm->srcu); if (!is_long_mode(vcpu) && is_pae(vcpu)) { load_pdptrs(vcpu, vcpu->arch.walk_mmu, kvm_read_cr3(vcpu)); mmu_reset_needed = 1; } srcu_read_unlock(&vcpu->kvm->srcu, idx); if (mmu_reset_needed) kvm_mmu_reset_context(vcpu); max_bits = KVM_NR_INTERRUPTS; pending_vec = find_first_bit( (const unsigned long )sregs->interrupt_bitmap, max_bits); if (pending_vec < max_bits) { kvm_queue_interrupt(vcpu, pending_vec, false); pr_debug("Set back pending irq %d\n", pending_vec); } kvm_set_segment(vcpu, &sregs->cs, VCPU_SREG_CS); kvm_set_segment(vcpu, &sregs->ds, VCPU_SREG_DS); kvm_set_segment(vcpu, &sregs->es, VCPU_SREG_ES); kvm_set_segment(vcpu, &sregs->fs, VCPU_SREG_FS); kvm_set_segment(vcpu, &sregs->gs, VCPU_SREG_GS); kvm_set_segment(vcpu, &sregs->ss, VCPU_SREG_SS); kvm_set_segment(vcpu, &sregs->tr, VCPU_SREG_TR); kvm_set_segment(vcpu, &sregs->ldt, VCPU_SREG_LDTR); update_cr8_intercept(vcpu); / Older userspace won't unhalt the vcpu on reset. / if (kvm_vcpu_is_bsp(vcpu) && kvm_rip_read(vcpu) == 0xfff0 && sregs->cs.selector == 0xf000 && sregs->cs.base == 0xffff0000 && !is_protmode(vcpu)) vcpu->arch.mp_state = KVM_MP_STATE_RUNNABLE; kvm_make_request(KVM_REQ_EVENT, vcpu); return 0; } int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu vcpu, struct kvm_guest_debug dbg) { unsigned long rflags; int i, r; if (dbg->control & (KVM_GUESTDBG_INJECT_DB \| KVM_GUESTDBG_INJECT_BP)) { r = -EBUSY; if (vcpu->arch.exception.pending) goto out; if (dbg->control & KVM_GUESTDBG_INJECT_DB) kvm_queue_exception(vcpu, DB_VECTOR); else kvm_queue_exception(vcpu, BP_VECTOR); } / * Read rflags as long as potentially injected trace flags are still * filtered out. / rflags = kvm_get_rflags(vcpu); vcpu->guest_debug = dbg->control; if (!(vcpu->guest_debug & KVM_GUESTDBG_ENABLE)) vcpu->guest_debug = 0; if (vcpu->guest_debug & KVM_GUESTDBG_USE_HW_BP) { for (i = 0; i < KVM_NR_DB_REGS; ++i) vcpu->arch.eff_db[i] = dbg->arch.debugreg[i]; vcpu->arch.guest_debug_dr7 = dbg->arch.debugreg[7]; } else { for (i = 0; i < KVM_NR_DB_REGS; i++) vcpu->arch.eff_db[i] = vcpu->arch.db[i]; } kvm_update_dr7(vcpu); if (vcpu->guest_debug & KVM_GUESTDBG_SINGLESTEP) vcpu->arch.singlestep_rip = kvm_rip_read(vcpu) + get_segment_base(vcpu, VCPU_SREG_CS); / * Trigger an rflags update that will inject or remove the trace * flags. / kvm_set_rflags(vcpu, rflags); kvm_x86_ops->update_db_bp_intercept(vcpu); r = 0; out: return r; } / * Translate a guest virtual address to a guest physical address. / int kvm_arch_vcpu_ioctl_translate(struct kvm_vcpu vcpu, struct kvm_translation tr) { unsigned long vaddr = tr->linear_address; gpa_t gpa; int idx; idx = srcu_read_lock(&vcpu->kvm->srcu); gpa = kvm_mmu_gva_to_gpa_system(vcpu, vaddr, NULL); srcu_read_unlock(&vcpu->kvm->srcu, idx); tr->physical_address = gpa; tr->valid = gpa != UNMAPPED_GVA; tr->writeable = 1; tr->usermode = 0; return 0; } int kvm_arch_vcpu_ioctl_get_fpu(struct kvm_vcpu vcpu, struct kvm_fpu fpu) { struct i387_fxsave_struct fxsave = &vcpu->arch.guest_fpu.state->fxsave; memcpy(fpu->fpr, fxsave->st_space, 128); fpu->fcw = fxsave->cwd; fpu->fsw = fxsave->swd; fpu->ftwx = fxsave->twd; fpu->last_opcode = fxsave->fop; fpu->last_ip = fxsave->rip; fpu->last_dp = fxsave->rdp; memcpy(fpu->xmm, fxsave->xmm_space, sizeof fxsave->xmm_space); return 0; } int kvm_arch_vcpu_ioctl_set_fpu(struct kvm_vcpu vcpu, struct kvm_fpu fpu) { struct i387_fxsave_struct fxsave = &vcpu->arch.guest_fpu.state->fxsave; memcpy(fxsave->st_space, fpu->fpr, 128); fxsave->cwd = fpu->fcw; fxsave->swd = fpu->fsw; fxsave->twd = fpu->ftwx; fxsave->fop = fpu->last_opcode; fxsave->rip = fpu->last_ip; fxsave->rdp = fpu->last_dp; memcpy(fxsave->xmm_space, fpu->xmm, sizeof fxsave->xmm_space); return 0; } int fx_init(struct kvm_vcpu vcpu) { int err; err = fpu_alloc(&vcpu->arch.guest_fpu); if (err) return err; fpu_finit(&vcpu->arch.guest_fpu); /* * Ensure guest xcr0 is valid for loading / vcpu->arch.xcr0 = XSTATE_FP; vcpu->arch.cr0 \|= X86_CR0_ET; return 0; } EXPORT_SYMBOL_GPL(fx_init); static void fx_free(struct kvm_vcpu vcpu) { fpu_free(&vcpu->arch.guest_fpu); } void kvm_load_guest_fpu(struct kvm_vcpu vcpu) { if (vcpu->guest_fpu_loaded) return; / * Restore all possible states in the guest, * and assume host would use all available bits. * Guest xcr0 would be loaded later. / kvm_put_guest_xcr0(vcpu); vcpu->guest_fpu_loaded = 1; __kernel_fpu_begin(); fpu_restore_checking(&vcpu->arch.guest_fpu); trace_kvm_fpu(1); } void kvm_put_guest_fpu(struct kvm_vcpu vcpu) { kvm_put_guest_xcr0(vcpu); if (!vcpu->guest_fpu_loaded) return; vcpu->guest_fpu_loaded = 0; fpu_save_init(&vcpu->arch.guest_fpu); __kernel_fpu_end(); ++vcpu->stat.fpu_reload; kvm_make_request(KVM_REQ_DEACTIVATE_FPU, vcpu); trace_kvm_fpu(0); } void kvm_arch_vcpu_free(struct kvm_vcpu vcpu) { kvmclock_reset(vcpu); free_cpumask_var(vcpu->arch.wbinvd_dirty_mask); fx_free(vcpu); kvm_x86_ops->vcpu_free(vcpu); } struct kvm_vcpu kvm_arch_vcpu_create(struct kvm kvm, unsigned int id) { if (check_tsc_unstable() && atomic_read(&kvm->online_vcpus) != 0) printk_once(KERN_WARNING "kvm: SMP vm created on host with unstable TSC; " "guest TSC will not be reliable\n"); return kvm_x86_ops->vcpu_create(kvm, id); } int kvm_arch_vcpu_setup(struct kvm_vcpu vcpu) { int r; vcpu->arch.mtrr_state.have_fixed = 1; r = vcpu_load(vcpu); if (r) return r; kvm_vcpu_reset(vcpu); kvm_mmu_setup(vcpu); vcpu_put(vcpu); return r; } int kvm_arch_vcpu_postcreate(struct kvm_vcpu vcpu) { int r; struct msr_data msr; struct kvm kvm = vcpu->kvm; r = vcpu_load(vcpu); if (r) return r; msr.data = 0x0; msr.index = MSR_IA32_TSC; msr.host_initiated = true; kvm_write_tsc(vcpu, &msr); vcpu_put(vcpu); schedule_delayed_work(&kvm->arch.kvmclock_sync_work, KVMCLOCK_SYNC_PERIOD); return r; } void kvm_arch_vcpu_destroy(struct kvm_vcpu vcpu) { int r; vcpu->arch.apf.msr_val = 0; r = vcpu_load(vcpu); BUG_ON(r); kvm_mmu_unload(vcpu); vcpu_put(vcpu); fx_free(vcpu); kvm_x86_ops->vcpu_free(vcpu); } void kvm_vcpu_reset(struct kvm_vcpu vcpu) { atomic_set(&vcpu->arch.nmi_queued, 0); vcpu->arch.nmi_pending = 0; vcpu->arch.nmi_injected = false; kvm_clear_interrupt_queue(vcpu); kvm_clear_exception_queue(vcpu); memset(vcpu->arch.db, 0, sizeof(vcpu->arch.db)); vcpu->arch.dr6 = DR6_INIT; kvm_update_dr6(vcpu); vcpu->arch.dr7 = DR7_FIXED_1; kvm_update_dr7(vcpu); kvm_make_request(KVM_REQ_EVENT, vcpu); vcpu->arch.apf.msr_val = 0; vcpu->arch.st.msr_val = 0; kvmclock_reset(vcpu); kvm_clear_async_pf_completion_queue(vcpu); kvm_async_pf_hash_reset(vcpu); vcpu->arch.apf.halted = false; kvm_pmu_reset(vcpu); memset(vcpu->arch.regs, 0, sizeof(vcpu->arch.regs)); vcpu->arch.regs_avail = ~0; vcpu->arch.regs_dirty = ~0; kvm_x86_ops->vcpu_reset(vcpu); } void kvm_vcpu_deliver_sipi_vector(struct kvm_vcpu vcpu, unsigned int vector) { struct kvm_segment cs; kvm_get_segment(vcpu, &cs, VCPU_SREG_CS); cs.selector = vector << 8; cs.base = vector << 12; kvm_set_segment(vcpu, &cs, VCPU_SREG_CS); kvm_rip_write(vcpu, 0); } int kvm_arch_hardware_enable(void) { struct kvm kvm; struct kvm_vcpu vcpu; int i; int ret; u64 local_tsc; u64 max_tsc = 0; bool stable, backwards_tsc = false; kvm_shared_msr_cpu_online(); ret = kvm_x86_ops->hardware_enable(); if (ret != 0) return ret; local_tsc = native_read_tsc(); stable = !check_tsc_unstable(); list_for_each_entry(kvm, &vm_list, vm_list) { kvm_for_each_vcpu(i, vcpu, kvm) { if (!stable && vcpu->cpu == smp_processor_id()) kvm_make_request(KVM_REQ_CLOCK_UPDATE, vcpu); if (stable && vcpu->arch.last_host_tsc > local_tsc) { backwards_tsc = true; if (vcpu->arch.last_host_tsc > max_tsc) max_tsc = vcpu->arch.last_host_tsc; } } } / * Sometimes, even reliable TSCs go backwards. This happens on * platforms that reset TSC during suspend or hibernate actions, but * maintain synchronization. We must compensate. Fortunately, we can * detect that condition here, which happens early in CPU bringup, * before any KVM threads can be running. Unfortunately, we can't * bring the TSCs fully up to date with real time, as we aren't yet far * enough into CPU bringup that we know how much real time has actually * elapsed; our helper function, get_kernel_ns() will be using boot * variables that haven't been updated yet. * * So we simply find the maximum observed TSC above, then record the * adjustment to TSC in each VCPU. When the VCPU later gets loaded, * the adjustment will be applied. Note that we accumulate * adjustments, in case multiple suspend cycles happen before some VCPU * gets a chance to run again. In the event that no KVM threads get a * chance to run, we will miss the entire elapsed period, as we'll have * reset last_host_tsc, so VCPUs will not have the TSC adjusted and may * loose cycle time. This isn't too big a deal, since the loss will be * uniform across all VCPUs (not to mention the scenario is extremely * unlikely). It is possible that a second hibernate recovery happens * much faster than a first, causing the observed TSC here to be * smaller; this would require additional padding adjustment, which is * why we set last_host_tsc to the local tsc observed here. * * N.B. - this code below runs only on platforms with reliable TSC, * as that is the only way backwards_tsc is set above. Also note * that this runs for ALL vcpus, which is not a bug; all VCPUs should * have the same delta_cyc adjustment applied if backwards_tsc * is detected. Note further, this adjustment is only done once, * as we reset last_host_tsc on all VCPUs to stop this from being * called multiple times (one for each physical CPU bringup). * * Platforms with unreliable TSCs don't have to deal with this, they * will be compensated by the logic in vcpu_load, which sets the TSC to * catchup mode. This will catchup all VCPUs to real time, but cannot * guarantee that they stay in perfect synchronization. / if (backwards_tsc) { u64 delta_cyc = max_tsc - local_tsc; backwards_tsc_observed = true; list_for_each_entry(kvm, &vm_list, vm_list) { kvm_for_each_vcpu(i, vcpu, kvm) { vcpu->arch.tsc_offset_adjustment += delta_cyc; vcpu->arch.last_host_tsc = local_tsc; kvm_make_request(KVM_REQ_MASTERCLOCK_UPDATE, vcpu); } / * We have to disable TSC offset matching.. if you were * booting a VM while issuing an S4 host suspend.... * you may have some problem. Solving this issue is * left as an exercise to the reader. / kvm->arch.last_tsc_nsec = 0; kvm->arch.last_tsc_write = 0; } } return 0; } void kvm_arch_hardware_disable(void) { kvm_x86_ops->hardware_disable(); drop_user_return_notifiers(); } int kvm_arch_hardware_setup(void) { return kvm_x86_ops->hardware_setup(); } void kvm_arch_hardware_unsetup(void) { kvm_x86_ops->hardware_unsetup(); } void kvm_arch_check_processor_compat(void rtn) { kvm_x86_ops->check_processor_compatibility(rtn); } bool kvm_vcpu_compatible(struct kvm_vcpu vcpu) { return irqchip_in_kernel(vcpu->kvm) == (vcpu->arch.apic != NULL); } struct static_key kvm_no_apic_vcpu __read_mostly; int kvm_arch_vcpu_init(struct kvm_vcpu vcpu) { struct page page; struct kvm kvm; int r; BUG_ON(vcpu->kvm == NULL); kvm = vcpu->kvm; vcpu->arch.pv.pv_unhalted = false; vcpu->arch.emulate_ctxt.ops = &emulate_ops; if (!irqchip_in_kernel(kvm) \|\| kvm_vcpu_is_bsp(vcpu)) vcpu->arch.mp_state = KVM_MP_STATE_RUNNABLE; else vcpu->arch.mp_state = KVM_MP_STATE_UNINITIALIZED; page = alloc_page(GFP_KERNEL \| __GFP_ZERO); if (!page) { r = -ENOMEM; goto fail; } vcpu->arch.pio_data = page_address(page); kvm_set_tsc_khz(vcpu, max_tsc_khz); r = kvm_mmu_create(vcpu); if (r < 0) goto fail_free_pio_data; if (irqchip_in_kernel(kvm)) { r = kvm_create_lapic(vcpu); if (r < 0) goto fail_mmu_destroy; } else static_key_slow_inc(&kvm_no_apic_vcpu); vcpu->arch.mce_banks = kzalloc(KVM_MAX_MCE_BANKS * sizeof(u64) * 4, GFP_KERNEL); if (!vcpu->arch.mce_banks) { r = -ENOMEM; goto fail_free_lapic; } vcpu->arch.mcg_cap = KVM_MAX_MCE_BANKS; if (!zalloc_cpumask_var(&vcpu->arch.wbinvd_dirty_mask, GFP_KERNEL)) { r = -ENOMEM; goto fail_free_mce_banks; } r = fx_init(vcpu); if (r) goto fail_free_wbinvd_dirty_mask; vcpu->arch.ia32_tsc_adjust_msr = 0x0; vcpu->arch.pv_time_enabled = false; vcpu->arch.guest_supported_xcr0 = 0; vcpu->arch.guest_xstate_size = XSAVE_HDR_SIZE + XSAVE_HDR_OFFSET; kvm_async_pf_hash_reset(vcpu); kvm_pmu_init(vcpu); return 0; fail_free_wbinvd_dirty_mask: free_cpumask_var(vcpu->arch.wbinvd_dirty_mask); fail_free_mce_banks: kfree(vcpu->arch.mce_banks); fail_free_lapic: kvm_free_lapic(vcpu); fail_mmu_destroy: kvm_mmu_destroy(vcpu); fail_free_pio_data: free_page((unsigned long)vcpu->arch.pio_data); fail: return r; } void kvm_arch_vcpu_uninit(struct kvm_vcpu vcpu) { int idx; kvm_pmu_destroy(vcpu); kfree(vcpu->arch.mce_banks); kvm_free_lapic(vcpu); idx = srcu_read_lock(&vcpu->kvm->srcu); kvm_mmu_destroy(vcpu); srcu_read_unlock(&vcpu->kvm->srcu, idx); free_page((unsigned long)vcpu->arch.pio_data); if (!irqchip_in_kernel(vcpu->kvm)) static_key_slow_dec(&kvm_no_apic_vcpu); } void kvm_arch_sched_in(struct kvm_vcpu vcpu, int cpu) { kvm_x86_ops->sched_in(vcpu, cpu); } int kvm_arch_init_vm(struct kvm kvm, unsigned long type) { if (type) return -EINVAL; INIT_LIST_HEAD(&kvm->arch.active_mmu_pages); INIT_LIST_HEAD(&kvm->arch.zapped_obsolete_pages); INIT_LIST_HEAD(&kvm->arch.assigned_dev_head); atomic_set(&kvm->arch.noncoherent_dma_count, 0); / Reserve bit 0 of irq_sources_bitmap for userspace irq source / set_bit(KVM_USERSPACE_IRQ_SOURCE_ID, &kvm->arch.irq_sources_bitmap); / Reserve bit 1 of irq_sources_bitmap for irqfd-resampler / set_bit(KVM_IRQFD_RESAMPLE_IRQ_SOURCE_ID, &kvm->arch.irq_sources_bitmap); raw_spin_lock_init(&kvm->arch.tsc_write_lock); mutex_init(&kvm->arch.apic_map_lock); spin_lock_init(&kvm->arch.pvclock_gtod_sync_lock); pvclock_update_vm_gtod_copy(kvm); INIT_DELAYED_WORK(&kvm->arch.kvmclock_update_work, kvmclock_update_fn); INIT_DELAYED_WORK(&kvm->arch.kvmclock_sync_work, kvmclock_sync_fn); return 0; } static void kvm_unload_vcpu_mmu(struct kvm_vcpu vcpu) { int r; r = vcpu_load(vcpu); BUG_ON(r); kvm_mmu_unload(vcpu); vcpu_put(vcpu); } static void kvm_free_vcpus(struct kvm kvm) { unsigned int i; struct kvm_vcpu vcpu; /* * Unpin any mmu pages first. / kvm_for_each_vcpu(i, vcpu, kvm) { kvm_clear_async_pf_completion_queue(vcpu); kvm_unload_vcpu_mmu(vcpu); } kvm_for_each_vcpu(i, vcpu, kvm) kvm_arch_vcpu_free(vcpu); mutex_lock(&kvm->lock); for (i = 0; i < atomic_read(&kvm->online_vcpus); i++) kvm->vcpus[i] = NULL; atomic_set(&kvm->online_vcpus, 0); mutex_unlock(&kvm->lock); } void kvm_arch_sync_events(struct kvm kvm) { cancel_delayed_work_sync(&kvm->arch.kvmclock_sync_work); cancel_delayed_work_sync(&kvm->arch.kvmclock_update_work); kvm_free_all_assigned_devices(kvm); kvm_free_pit(kvm); } void kvm_arch_destroy_vm(struct kvm kvm) { if (current->mm == kvm->mm) { / * Free memory regions allocated on behalf of userspace, * unless the the memory map has changed due to process exit * or fd copying. / struct kvm_userspace_memory_region mem; memset(&mem, 0, sizeof(mem)); mem.slot = APIC_ACCESS_PAGE_PRIVATE_MEMSLOT; kvm_set_memory_region(kvm, &mem); mem.slot = IDENTITY_PAGETABLE_PRIVATE_MEMSLOT; kvm_set_memory_region(kvm, &mem); mem.slot = TSS_PRIVATE_MEMSLOT; kvm_set_memory_region(kvm, &mem); } kvm_iommu_unmap_guest(kvm); kfree(kvm->arch.vpic); kfree(kvm->arch.vioapic); kvm_free_vcpus(kvm); kfree(rcu_dereference_check(kvm->arch.apic_map, 1)); } void kvm_arch_free_memslot(struct kvm kvm, struct kvm_memory_slot free, struct kvm_memory_slot dont) { int i; for (i = 0; i < KVM_NR_PAGE_SIZES; ++i) { if (!dont \|\| free->arch.rmap[i] != dont->arch.rmap[i]) { kvm_kvfree(free->arch.rmap[i]); free->arch.rmap[i] = NULL; } if (i == 0) continue; if (!dont \|\| free->arch.lpage_info[i - 1] != dont->arch.lpage_info[i - 1]) { kvm_kvfree(free->arch.lpage_info[i - 1]); free->arch.lpage_info[i - 1] = NULL; } } } int kvm_arch_create_memslot(struct kvm kvm, struct kvm_memory_slot slot, unsigned long npages) { int i; for (i = 0; i < KVM_NR_PAGE_SIZES; ++i) { unsigned long ugfn; int lpages; int level = i + 1; lpages = gfn_to_index(slot->base_gfn + npages - 1, slot->base_gfn, level) + 1; slot->arch.rmap[i] = kvm_kvzalloc(lpages * sizeof(slot->arch.rmap[i])); if (!slot->arch.rmap[i]) goto out_free; if (i == 0) continue; slot->arch.lpage_info[i - 1] = kvm_kvzalloc(lpages sizeof(slot->arch.lpage_info[i - 1])); if (!slot->arch.lpage_info[i - 1]) goto out_free; if (slot->base_gfn & (KVM_PAGES_PER_HPAGE(level) - 1)) slot->arch.lpage_info[i - 1][0].write_count = 1; if ((slot->base_gfn + npages) & (KVM_PAGES_PER_HPAGE(level) - 1)) slot->arch.lpage_info[i - 1][lpages - 1].write_count = 1; ugfn = slot->userspace_addr >> PAGE_SHIFT; / * If the gfn and userspace address are not aligned wrt each * other, or if explicitly asked to, disable large page * support for this slot / if ((slot->base_gfn ^ ugfn) & (KVM_PAGES_PER_HPAGE(level) - 1) \|\| !kvm_largepages_enabled()) { unsigned long j; for (j = 0; j < lpages; ++j) slot->arch.lpage_info[i - 1][j].write_count = 1; } } return 0; out_free: for (i = 0; i < KVM_NR_PAGE_SIZES; ++i) { kvm_kvfree(slot->arch.rmap[i]); slot->arch.rmap[i] = NULL; if (i == 0) continue; kvm_kvfree(slot->arch.lpage_info[i - 1]); slot->arch.lpage_info[i - 1] = NULL; } return -ENOMEM; } void kvm_arch_memslots_updated(struct kvm kvm) { /* * memslots->generation has been incremented. * mmio generation may have reached its maximum value. / kvm_mmu_invalidate_mmio_sptes(kvm); } int kvm_arch_prepare_memory_region(struct kvm kvm, struct kvm_memory_slot memslot, struct kvm_userspace_memory_region mem, enum kvm_mr_change change) { /* * Only private memory slots need to be mapped here since * KVM_SET_MEMORY_REGION ioctl is no longer supported. / if ((memslot->id >= KVM_USER_MEM_SLOTS) && (change == KVM_MR_CREATE)) { unsigned long userspace_addr; / * MAP_SHARED to prevent internal slot pages from being moved * by fork()/COW. / userspace_addr = vm_mmap(NULL, 0, memslot->npages PAGE_SIZE, PROT_READ \| PROT_WRITE, MAP_SHARED \| MAP_ANONYMOUS, 0); if (IS_ERR((void )userspace_addr)) return PTR_ERR((void )userspace_addr); memslot->userspace_addr = userspace_addr; } return 0; } void kvm_arch_commit_memory_region(struct kvm kvm, struct kvm_userspace_memory_region mem, const struct kvm_memory_slot old, enum kvm_mr_change change) { int nr_mmu_pages = 0; if ((mem->slot >= KVM_USER_MEM_SLOTS) && (change == KVM_MR_DELETE)) { int ret; ret = vm_munmap(old->userspace_addr, old->npages PAGE_SIZE); if (ret < 0) printk(KERN_WARNING "kvm_vm_ioctl_set_memory_region: " "failed to munmap memory\n"); } if (!kvm->arch.n_requested_mmu_pages) nr_mmu_pages = kvm_mmu_calculate_mmu_pages(kvm); if (nr_mmu_pages) kvm_mmu_change_mmu_pages(kvm, nr_mmu_pages); /* * Write protect all pages for dirty logging. * * All the sptes including the large sptes which point to this * slot are set to readonly. We can not create any new large * spte on this slot until the end of the logging. * * See the comments in fast_page_fault(). / if ((change != KVM_MR_DELETE) && (mem->flags & KVM_MEM_LOG_DIRTY_PAGES)) kvm_mmu_slot_remove_write_access(kvm, mem->slot); } void kvm_arch_flush_shadow_all(struct kvm kvm) { kvm_mmu_invalidate_zap_all_pages(kvm); } void kvm_arch_flush_shadow_memslot(struct kvm kvm, struct kvm_memory_slot slot) { kvm_mmu_invalidate_zap_all_pages(kvm); } int kvm_arch_vcpu_runnable(struct kvm_vcpu vcpu) { if (is_guest_mode(vcpu) && kvm_x86_ops->check_nested_events) kvm_x86_ops->check_nested_events(vcpu, false); return (vcpu->arch.mp_state == KVM_MP_STATE_RUNNABLE && !vcpu->arch.apf.halted) \|\| !list_empty_careful(&vcpu->async_pf.done) \|\| kvm_apic_has_events(vcpu) \|\| vcpu->arch.pv.pv_unhalted \|\| atomic_read(&vcpu->arch.nmi_queued) \|\| (kvm_arch_interrupt_allowed(vcpu) && kvm_cpu_has_interrupt(vcpu)); } int kvm_arch_vcpu_should_kick(struct kvm_vcpu vcpu) { return kvm_vcpu_exiting_guest_mode(vcpu) == IN_GUEST_MODE; } int kvm_arch_interrupt_allowed(struct kvm_vcpu vcpu) { return kvm_x86_ops->interrupt_allowed(vcpu); } bool kvm_is_linear_rip(struct kvm_vcpu vcpu, unsigned long linear_rip) { unsigned long current_rip = kvm_rip_read(vcpu) + get_segment_base(vcpu, VCPU_SREG_CS); return current_rip == linear_rip; } EXPORT_SYMBOL_GPL(kvm_is_linear_rip); unsigned long kvm_get_rflags(struct kvm_vcpu vcpu) { unsigned long rflags; rflags = kvm_x86_ops->get_rflags(vcpu); if (vcpu->guest_debug & KVM_GUESTDBG_SINGLESTEP) rflags &= ~X86_EFLAGS_TF; return rflags; } EXPORT_SYMBOL_GPL(kvm_get_rflags); static void __kvm_set_rflags(struct kvm_vcpu vcpu, unsigned long rflags) { if (vcpu->guest_debug & KVM_GUESTDBG_SINGLESTEP && kvm_is_linear_rip(vcpu, vcpu->arch.singlestep_rip)) rflags \|= X86_EFLAGS_TF; kvm_x86_ops->set_rflags(vcpu, rflags); } void kvm_set_rflags(struct kvm_vcpu vcpu, unsigned long rflags) { __kvm_set_rflags(vcpu, rflags); kvm_make_request(KVM_REQ_EVENT, vcpu); } EXPORT_SYMBOL_GPL(kvm_set_rflags); void kvm_arch_async_page_ready(struct kvm_vcpu vcpu, struct kvm_async_pf work) { int r; if ((vcpu->arch.mmu.direct_map != work->arch.direct_map) \|\| work->wakeup_all) return; r = kvm_mmu_reload(vcpu); if (unlikely(r)) return; if (!vcpu->arch.mmu.direct_map && work->arch.cr3 != vcpu->arch.mmu.get_cr3(vcpu)) return; vcpu->arch.mmu.page_fault(vcpu, work->gva, 0, true); } static inline u32 kvm_async_pf_hash_fn(gfn_t gfn) { return hash_32(gfn & 0xffffffff, order_base_2(ASYNC_PF_PER_VCPU)); } static inline u32 kvm_async_pf_next_probe(u32 key) { return (key + 1) & (roundup_pow_of_two(ASYNC_PF_PER_VCPU) - 1); } static void kvm_add_async_pf_gfn(struct kvm_vcpu vcpu, gfn_t gfn) { u32 key = kvm_async_pf_hash_fn(gfn); while (vcpu->arch.apf.gfns[key] != ~0) key = kvm_async_pf_next_probe(key); vcpu->arch.apf.gfns[key] = gfn; } static u32 kvm_async_pf_gfn_slot(struct kvm_vcpu vcpu, gfn_t gfn) { int i; u32 key = kvm_async_pf_hash_fn(gfn); for (i = 0; i < roundup_pow_of_two(ASYNC_PF_PER_VCPU) && (vcpu->arch.apf.gfns[key] != gfn && vcpu->arch.apf.gfns[key] != ~0); i++) key = kvm_async_pf_next_probe(key); return key; } bool kvm_find_async_pf_gfn(struct kvm_vcpu vcpu, gfn_t gfn) { return vcpu->arch.apf.gfns[kvm_async_pf_gfn_slot(vcpu, gfn)] == gfn; } static void kvm_del_async_pf_gfn(struct kvm_vcpu vcpu, gfn_t gfn) { u32 i, j, k; i = j = kvm_async_pf_gfn_slot(vcpu, gfn); while (true) { vcpu->arch.apf.gfns[i] = ~0; do { j = kvm_async_pf_next_probe(j); if (vcpu->arch.apf.gfns[j] == ~0) return; k = kvm_async_pf_hash_fn(vcpu->arch.apf.gfns[j]); / * k lies cyclically in ]i,j] * \| i.k.j \| * \|....j i.k.\| or \|.k..j i...\| / } while ((i <= j) ? (i < k && k <= j) : (i < k \|\| k <= j)); vcpu->arch.apf.gfns[i] = vcpu->arch.apf.gfns[j]; i = j; } } static int apf_put_user(struct kvm_vcpu vcpu, u32 val) { return kvm_write_guest_cached(vcpu->kvm, &vcpu->arch.apf.data, &val, sizeof(val)); } void kvm_arch_async_page_not_present(struct kvm_vcpu vcpu, struct kvm_async_pf work) { struct x86_exception fault; trace_kvm_async_pf_not_present(work->arch.token, work->gva); kvm_add_async_pf_gfn(vcpu, work->arch.gfn); if (!(vcpu->arch.apf.msr_val & KVM_ASYNC_PF_ENABLED) \|\| (vcpu->arch.apf.send_user_only && kvm_x86_ops->get_cpl(vcpu) == 0)) kvm_make_request(KVM_REQ_APF_HALT, vcpu); else if (!apf_put_user(vcpu, KVM_PV_REASON_PAGE_NOT_PRESENT)) { fault.vector = PF_VECTOR; fault.error_code_valid = true; fault.error_code = 0; fault.nested_page_fault = false; fault.address = work->arch.token; kvm_inject_page_fault(vcpu, &fault); } } void kvm_arch_async_page_present(struct kvm_vcpu vcpu, struct kvm_async_pf work) { struct x86_exception fault; trace_kvm_async_pf_ready(work->arch.token, work->gva); if (work->wakeup_all) work->arch.token = ~0; /* broadcast wakeup / else kvm_del_async_pf_gfn(vcpu, work->arch.gfn); if ((vcpu->arch.apf.msr_val & KVM_ASYNC_PF_ENABLED) && !apf_put_user(vcpu, KVM_PV_REASON_PAGE_READY)) { fault.vector = PF_VECTOR; fault.error_code_valid = true; fault.error_code = 0; fault.nested_page_fault = false; fault.address = work->arch.token; kvm_inject_page_fault(vcpu, &fault); } vcpu->arch.apf.halted = false; vcpu->arch.mp_state = KVM_MP_STATE_RUNNABLE; } bool kvm_arch_can_inject_async_page_present(struct kvm_vcpu vcpu) { if (!(vcpu->arch.apf.msr_val & KVM_ASYNC_PF_ENABLED)) return true; else return !kvm_event_needs_reinjection(vcpu) && kvm_x86_ops->interrupt_allowed(vcpu); } void kvm_arch_register_noncoherent_dma(struct kvm kvm) { atomic_inc(&kvm->arch.noncoherent_dma_count); } EXPORT_SYMBOL_GPL(kvm_arch_register_noncoherent_dma); void kvm_arch_unregister_noncoherent_dma(struct kvm kvm) { atomic_dec(&kvm->arch.noncoherent_dma_count); } EXPORT_SYMBOL_GPL(kvm_arch_unregister_noncoherent_dma); bool kvm_arch_has_noncoherent_dma(struct kvm *kvm) { return atomic_read(&kvm->arch.noncoherent_dma_count); } EXPORT_SYMBOL_GPL(kvm_arch_has_noncoherent_dma); EXPORT_TRACEPOINT_SYMBOL_GPL(kvm_exit); EXPORT_TRACEPOINT_SYMBOL_GPL(kvm_inj_virq); EXPORT_TRACEPOINT_SYMBOL_GPL(kvm_page_fault); EXPORT_TRACEPOINT_SYMBOL_GPL(kvm_msr); EXPORT_TRACEPOINT_SYMBOL_GPL(kvm_cr); EXPORT_TRACEPOINT_SYMBOL_GPL(kvm_nested_vmrun); EXPORT_TRACEPOINT_SYMBOL_GPL(kvm_nested_vmexit); EXPORT_TRACEPOINT_SYMBOL_GPL(kvm_nested_vmexit_inject); EXPORT_TRACEPOINT_SYMBOL_GPL(kvm_nested_intr_vmexit); EXPORT_TRACEPOINT_SYMBOL_GPL(kvm_invlpga); EXPORT_TRACEPOINT_SYMBOL_GPL(kvm_skinit); EXPORT_TRACEPOINT_SYMBOL_GPL(kvm_nested_intercepts); EXPORT_TRACEPOINT_SYMBOL_GPL(kvm_write_tsc_offset); EXPORT_TRACEPOINT_SYMBOL_GPL(kvm_ple_window);	./CrossVul/dataset_final_sorted/CWE-264/c/good_2159_3
crossvul-cpp_data_good_2287_6	/* * Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. * Copyright (C) 2004-2006 Red Hat, Inc. All rights reserved. * * This copyrighted material is made available to anyone wishing to use, * modify, copy, or redistribute it subject to the terms and conditions * of the GNU General Public License version 2. / #include <linux/slab.h> #include <linux/spinlock.h> #include <linux/completion.h> #include <linux/buffer_head.h> #include <linux/pagemap.h> #include <linux/uio.h> #include <linux/blkdev.h> #include <linux/mm.h> #include <linux/mount.h> #include <linux/fs.h> #include <linux/gfs2_ondisk.h> #include <linux/falloc.h> #include <linux/swap.h> #include <linux/crc32.h> #include <linux/writeback.h> #include <asm/uaccess.h> #include <linux/dlm.h> #include <linux/dlm_plock.h> #include <linux/aio.h> #include "gfs2.h" #include "incore.h" #include "bmap.h" #include "dir.h" #include "glock.h" #include "glops.h" #include "inode.h" #include "log.h" #include "meta_io.h" #include "quota.h" #include "rgrp.h" #include "trans.h" #include "util.h" /* * gfs2_llseek - seek to a location in a file * @file: the file * @offset: the offset * @whence: Where to seek from (SEEK_SET, SEEK_CUR, or SEEK_END) * * SEEK_END requires the glock for the file because it references the * file's size. * * Returns: The new offset, or errno / static loff_t gfs2_llseek(struct file file, loff_t offset, int whence) { struct gfs2_inode ip = GFS2_I(file->f_mapping->host); struct gfs2_holder i_gh; loff_t error; switch (whence) { case SEEK_END: / These reference inode->i_size / case SEEK_DATA: case SEEK_HOLE: error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh); if (!error) { error = generic_file_llseek(file, offset, whence); gfs2_glock_dq_uninit(&i_gh); } break; case SEEK_CUR: case SEEK_SET: error = generic_file_llseek(file, offset, whence); break; default: error = -EINVAL; } return error; } /* * gfs2_readdir - Iterator for a directory * @file: The directory to read from * @ctx: What to feed directory entries to * * Returns: errno / static int gfs2_readdir(struct file file, struct dir_context ctx) { struct inode dir = file->f_mapping->host; struct gfs2_inode dip = GFS2_I(dir); struct gfs2_holder d_gh; int error; error = gfs2_glock_nq_init(dip->i_gl, LM_ST_SHARED, 0, &d_gh); if (error) return error; error = gfs2_dir_read(dir, ctx, &file->f_ra); gfs2_glock_dq_uninit(&d_gh); return error; } /* * fsflags_cvt * @table: A table of 32 u32 flags * @val: a 32 bit value to convert * * This function can be used to convert between fsflags values and * GFS2's own flags values. * * Returns: the converted flags / static u32 fsflags_cvt(const u32 table, u32 val) { u32 res = 0; while(val) { if (val & 1) res \|= table; table++; val >>= 1; } return res; } static const u32 fsflags_to_gfs2[32] = { [3] = GFS2_DIF_SYNC, [4] = GFS2_DIF_IMMUTABLE, [5] = GFS2_DIF_APPENDONLY, [7] = GFS2_DIF_NOATIME, [12] = GFS2_DIF_EXHASH, [14] = GFS2_DIF_INHERIT_JDATA, [17] = GFS2_DIF_TOPDIR, }; static const u32 gfs2_to_fsflags[32] = { [gfs2fl_Sync] = FS_SYNC_FL, [gfs2fl_Immutable] = FS_IMMUTABLE_FL, [gfs2fl_AppendOnly] = FS_APPEND_FL, [gfs2fl_NoAtime] = FS_NOATIME_FL, [gfs2fl_ExHash] = FS_INDEX_FL, [gfs2fl_TopLevel] = FS_TOPDIR_FL, [gfs2fl_InheritJdata] = FS_JOURNAL_DATA_FL, }; static int gfs2_get_flags(struct file filp, u32 __user ptr) { struct inode inode = file_inode(filp); struct gfs2_inode ip = GFS2_I(inode); struct gfs2_holder gh; int error; u32 fsflags; gfs2_holder_init(ip->i_gl, LM_ST_SHARED, 0, &gh); error = gfs2_glock_nq(&gh); if (error) return error; fsflags = fsflags_cvt(gfs2_to_fsflags, ip->i_diskflags); if (!S_ISDIR(inode->i_mode) && ip->i_diskflags & GFS2_DIF_JDATA) fsflags \|= FS_JOURNAL_DATA_FL; if (put_user(fsflags, ptr)) error = -EFAULT; gfs2_glock_dq(&gh); gfs2_holder_uninit(&gh); return error; } void gfs2_set_inode_flags(struct inode inode) { struct gfs2_inode ip = GFS2_I(inode); unsigned int flags = inode->i_flags; flags &= ~(S_SYNC\|S_APPEND\|S_IMMUTABLE\|S_NOATIME\|S_DIRSYNC\|S_NOSEC); if ((ip->i_eattr == 0) && !is_sxid(inode->i_mode)) inode->i_flags \|= S_NOSEC; if (ip->i_diskflags & GFS2_DIF_IMMUTABLE) flags \|= S_IMMUTABLE; if (ip->i_diskflags & GFS2_DIF_APPENDONLY) flags \|= S_APPEND; if (ip->i_diskflags & GFS2_DIF_NOATIME) flags \|= S_NOATIME; if (ip->i_diskflags & GFS2_DIF_SYNC) flags \|= S_SYNC; inode->i_flags = flags; } / Flags that can be set by user space / #define GFS2_FLAGS_USER_SET (GFS2_DIF_JDATA\| \ GFS2_DIF_IMMUTABLE\| \ GFS2_DIF_APPENDONLY\| \ GFS2_DIF_NOATIME\| \ GFS2_DIF_SYNC\| \ GFS2_DIF_SYSTEM\| \ GFS2_DIF_TOPDIR\| \ GFS2_DIF_INHERIT_JDATA) /* * gfs2_set_flags - set flags on an inode * @inode: The inode * @flags: The flags to set * @mask: Indicates which flags are valid * / static int do_gfs2_set_flags(struct file filp, u32 reqflags, u32 mask) { struct inode inode = file_inode(filp); struct gfs2_inode ip = GFS2_I(inode); struct gfs2_sbd sdp = GFS2_SB(inode); struct buffer_head bh; struct gfs2_holder gh; int error; u32 new_flags, flags; error = mnt_want_write_file(filp); if (error) return error; error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh); if (error) goto out_drop_write; error = -EACCES; if (!inode_owner_or_capable(inode)) goto out; error = 0; flags = ip->i_diskflags; new_flags = (flags & ~mask) \| (reqflags & mask); if ((new_flags ^ flags) == 0) goto out; error = -EINVAL; if ((new_flags ^ flags) & ~GFS2_FLAGS_USER_SET) goto out; error = -EPERM; if (IS_IMMUTABLE(inode) && (new_flags & GFS2_DIF_IMMUTABLE)) goto out; if (IS_APPEND(inode) && (new_flags & GFS2_DIF_APPENDONLY)) goto out; if (((new_flags ^ flags) & GFS2_DIF_IMMUTABLE) && !capable(CAP_LINUX_IMMUTABLE)) goto out; if (!IS_IMMUTABLE(inode)) { error = gfs2_permission(inode, MAY_WRITE); if (error) goto out; } if ((flags ^ new_flags) & GFS2_DIF_JDATA) { if (flags & GFS2_DIF_JDATA) gfs2_log_flush(sdp, ip->i_gl); error = filemap_fdatawrite(inode->i_mapping); if (error) goto out; error = filemap_fdatawait(inode->i_mapping); if (error) goto out; } error = gfs2_trans_begin(sdp, RES_DINODE, 0); if (error) goto out; error = gfs2_meta_inode_buffer(ip, &bh); if (error) goto out_trans_end; gfs2_trans_add_meta(ip->i_gl, bh); ip->i_diskflags = new_flags; gfs2_dinode_out(ip, bh->b_data); brelse(bh); gfs2_set_inode_flags(inode); gfs2_set_aops(inode); out_trans_end: gfs2_trans_end(sdp); out: gfs2_glock_dq_uninit(&gh); out_drop_write: mnt_drop_write_file(filp); return error; } static int gfs2_set_flags(struct file filp, u32 __user ptr) { struct inode inode = file_inode(filp); u32 fsflags, gfsflags; if (get_user(fsflags, ptr)) return -EFAULT; gfsflags = fsflags_cvt(fsflags_to_gfs2, fsflags); if (!S_ISDIR(inode->i_mode)) { gfsflags &= ~GFS2_DIF_TOPDIR; if (gfsflags & GFS2_DIF_INHERIT_JDATA) gfsflags ^= (GFS2_DIF_JDATA \| GFS2_DIF_INHERIT_JDATA); return do_gfs2_set_flags(filp, gfsflags, ~0); } return do_gfs2_set_flags(filp, gfsflags, ~GFS2_DIF_JDATA); } static long gfs2_ioctl(struct file filp, unsigned int cmd, unsigned long arg) { switch(cmd) { case FS_IOC_GETFLAGS: return gfs2_get_flags(filp, (u32 __user )arg); case FS_IOC_SETFLAGS: return gfs2_set_flags(filp, (u32 __user )arg); case FITRIM: return gfs2_fitrim(filp, (void __user )arg); } return -ENOTTY; } /* * gfs2_size_hint - Give a hint to the size of a write request * @file: The struct file * @offset: The file offset of the write * @size: The length of the write * * When we are about to do a write, this function records the total * write size in order to provide a suitable hint to the lower layers * about how many blocks will be required. * / static void gfs2_size_hint(struct file filep, loff_t offset, size_t size) { struct inode inode = file_inode(filep); struct gfs2_sbd sdp = GFS2_SB(inode); struct gfs2_inode ip = GFS2_I(inode); size_t blks = (size + sdp->sd_sb.sb_bsize - 1) >> sdp->sd_sb.sb_bsize_shift; int hint = min_t(size_t, INT_MAX, blks); atomic_set(&ip->i_res->rs_sizehint, hint); } /* * gfs2_allocate_page_backing - Use bmap to allocate blocks * @page: The (locked) page to allocate backing for * * We try to allocate all the blocks required for the page in * one go. This might fail for various reasons, so we keep * trying until all the blocks to back this page are allocated. * If some of the blocks are already allocated, thats ok too. / static int gfs2_allocate_page_backing(struct page page) { struct inode inode = page->mapping->host; struct buffer_head bh; unsigned long size = PAGE_CACHE_SIZE; u64 lblock = page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits); do { bh.b_state = 0; bh.b_size = size; gfs2_block_map(inode, lblock, &bh, 1); if (!buffer_mapped(&bh)) return -EIO; size -= bh.b_size; lblock += (bh.b_size >> inode->i_blkbits); } while(size > 0); return 0; } /* * gfs2_page_mkwrite - Make a shared, mmap()ed, page writable * @vma: The virtual memory area * @page: The page which is about to become writable * * When the page becomes writable, we need to ensure that we have * blocks allocated on disk to back that page. / static int gfs2_page_mkwrite(struct vm_area_struct vma, struct vm_fault vmf) { struct page page = vmf->page; struct inode inode = file_inode(vma->vm_file); struct gfs2_inode ip = GFS2_I(inode); struct gfs2_sbd sdp = GFS2_SB(inode); struct gfs2_alloc_parms ap = { .aflags = 0, }; unsigned long last_index; u64 pos = page->index << PAGE_CACHE_SHIFT; unsigned int data_blocks, ind_blocks, rblocks; struct gfs2_holder gh; loff_t size; int ret; sb_start_pagefault(inode->i_sb); / Update file times before taking page lock / file_update_time(vma->vm_file); ret = get_write_access(inode); if (ret) goto out; ret = gfs2_rs_alloc(ip); if (ret) goto out_write_access; gfs2_size_hint(vma->vm_file, pos, PAGE_CACHE_SIZE); gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh); ret = gfs2_glock_nq(&gh); if (ret) goto out_uninit; set_bit(GLF_DIRTY, &ip->i_gl->gl_flags); set_bit(GIF_SW_PAGED, &ip->i_flags); if (!gfs2_write_alloc_required(ip, pos, PAGE_CACHE_SIZE)) { lock_page(page); if (!PageUptodate(page) \|\| page->mapping != inode->i_mapping) { ret = -EAGAIN; unlock_page(page); } goto out_unlock; } ret = gfs2_rindex_update(sdp); if (ret) goto out_unlock; ret = gfs2_quota_lock_check(ip); if (ret) goto out_unlock; gfs2_write_calc_reserv(ip, PAGE_CACHE_SIZE, &data_blocks, &ind_blocks); ap.target = data_blocks + ind_blocks; ret = gfs2_inplace_reserve(ip, &ap); if (ret) goto out_quota_unlock; rblocks = RES_DINODE + ind_blocks; if (gfs2_is_jdata(ip)) rblocks += data_blocks ? data_blocks : 1; if (ind_blocks \|\| data_blocks) { rblocks += RES_STATFS + RES_QUOTA; rblocks += gfs2_rg_blocks(ip, data_blocks + ind_blocks); } ret = gfs2_trans_begin(sdp, rblocks, 0); if (ret) goto out_trans_fail; lock_page(page); ret = -EINVAL; size = i_size_read(inode); last_index = (size - 1) >> PAGE_CACHE_SHIFT; / Check page index against inode size / if (size == 0 \|\| (page->index > last_index)) goto out_trans_end; ret = -EAGAIN; / If truncated, we must retry the operation, we may have raced * with the glock demotion code. / if (!PageUptodate(page) \|\| page->mapping != inode->i_mapping) goto out_trans_end; / Unstuff, if required, and allocate backing blocks for page / ret = 0; if (gfs2_is_stuffed(ip)) ret = gfs2_unstuff_dinode(ip, page); if (ret == 0) ret = gfs2_allocate_page_backing(page); out_trans_end: if (ret) unlock_page(page); gfs2_trans_end(sdp); out_trans_fail: gfs2_inplace_release(ip); out_quota_unlock: gfs2_quota_unlock(ip); out_unlock: gfs2_glock_dq(&gh); out_uninit: gfs2_holder_uninit(&gh); if (ret == 0) { set_page_dirty(page); wait_for_stable_page(page); } out_write_access: put_write_access(inode); out: sb_end_pagefault(inode->i_sb); return block_page_mkwrite_return(ret); } static const struct vm_operations_struct gfs2_vm_ops = { .fault = filemap_fault, .map_pages = filemap_map_pages, .page_mkwrite = gfs2_page_mkwrite, .remap_pages = generic_file_remap_pages, }; /* * gfs2_mmap - * @file: The file to map * @vma: The VMA which described the mapping * * There is no need to get a lock here unless we should be updating * atime. We ignore any locking errors since the only consequence is * a missed atime update (which will just be deferred until later). * * Returns: 0 / static int gfs2_mmap(struct file file, struct vm_area_struct vma) { struct gfs2_inode ip = GFS2_I(file->f_mapping->host); if (!(file->f_flags & O_NOATIME) && !IS_NOATIME(&ip->i_inode)) { struct gfs2_holder i_gh; int error; error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh); if (error) return error; /* grab lock to update inode / gfs2_glock_dq_uninit(&i_gh); file_accessed(file); } vma->vm_ops = &gfs2_vm_ops; return 0; } /* * gfs2_open_common - This is common to open and atomic_open * @inode: The inode being opened * @file: The file being opened * * This maybe called under a glock or not depending upon how it has * been called. We must always be called under a glock for regular * files, however. For other file types, it does not matter whether * we hold the glock or not. * * Returns: Error code or 0 for success / int gfs2_open_common(struct inode inode, struct file file) { struct gfs2_file fp; int ret; if (S_ISREG(inode->i_mode)) { ret = generic_file_open(inode, file); if (ret) return ret; } fp = kzalloc(sizeof(struct gfs2_file), GFP_NOFS); if (!fp) return -ENOMEM; mutex_init(&fp->f_fl_mutex); gfs2_assert_warn(GFS2_SB(inode), !file->private_data); file->private_data = fp; return 0; } /** * gfs2_open - open a file * @inode: the inode to open * @file: the struct file for this opening * * After atomic_open, this function is only used for opening files * which are already cached. We must still get the glock for regular * files to ensure that we have the file size uptodate for the large * file check which is in the common code. That is only an issue for * regular files though. * * Returns: errno / static int gfs2_open(struct inode inode, struct file file) { struct gfs2_inode ip = GFS2_I(inode); struct gfs2_holder i_gh; int error; bool need_unlock = false; if (S_ISREG(ip->i_inode.i_mode)) { error = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, LM_FLAG_ANY, &i_gh); if (error) return error; need_unlock = true; } error = gfs2_open_common(inode, file); if (need_unlock) gfs2_glock_dq_uninit(&i_gh); return error; } /** * gfs2_release - called to close a struct file * @inode: the inode the struct file belongs to * @file: the struct file being closed * * Returns: errno / static int gfs2_release(struct inode inode, struct file file) { struct gfs2_inode ip = GFS2_I(inode); kfree(file->private_data); file->private_data = NULL; if (!(file->f_mode & FMODE_WRITE)) return 0; gfs2_rs_delete(ip, &inode->i_writecount); return 0; } /** * gfs2_fsync - sync the dirty data for a file (across the cluster) * @file: the file that points to the dentry * @start: the start position in the file to sync * @end: the end position in the file to sync * @datasync: set if we can ignore timestamp changes * * We split the data flushing here so that we don't wait for the data * until after we've also sent the metadata to disk. Note that for * data=ordered, we will write & wait for the data at the log flush * stage anyway, so this is unlikely to make much of a difference * except in the data=writeback case. * * If the fdatawrite fails due to any reason except -EIO, we will * continue the remainder of the fsync, although we'll still report * the error at the end. This is to match filemap_write_and_wait_range() * behaviour. * * Returns: errno / static int gfs2_fsync(struct file file, loff_t start, loff_t end, int datasync) { struct address_space mapping = file->f_mapping; struct inode inode = mapping->host; int sync_state = inode->i_state & I_DIRTY; struct gfs2_inode ip = GFS2_I(inode); int ret = 0, ret1 = 0; if (mapping->nrpages) { ret1 = filemap_fdatawrite_range(mapping, start, end); if (ret1 == -EIO) return ret1; } if (!gfs2_is_jdata(ip)) sync_state &= ~I_DIRTY_PAGES; if (datasync) sync_state &= ~I_DIRTY_SYNC; if (sync_state) { ret = sync_inode_metadata(inode, 1); if (ret) return ret; if (gfs2_is_jdata(ip)) filemap_write_and_wait(mapping); gfs2_ail_flush(ip->i_gl, 1); } if (mapping->nrpages) ret = filemap_fdatawait_range(mapping, start, end); return ret ? ret : ret1; } /* * gfs2_file_write_iter - Perform a write to a file * @iocb: The io context * @iov: The data to write * @nr_segs: Number of @iov segments * @pos: The file position * * We have to do a lock/unlock here to refresh the inode size for * O_APPEND writes, otherwise we can land up writing at the wrong * offset. There is still a race, but provided the app is using its * own file locking, this will make O_APPEND work as expected. * / static ssize_t gfs2_file_write_iter(struct kiocb iocb, struct iov_iter from) { struct file file = iocb->ki_filp; struct gfs2_inode ip = GFS2_I(file_inode(file)); int ret; ret = gfs2_rs_alloc(ip); if (ret) return ret; gfs2_size_hint(file, iocb->ki_pos, iov_iter_count(from)); if (file->f_flags & O_APPEND) { struct gfs2_holder gh; ret = gfs2_glock_nq_init(ip->i_gl, LM_ST_SHARED, 0, &gh); if (ret) return ret; gfs2_glock_dq_uninit(&gh); } return generic_file_write_iter(iocb, from); } static int fallocate_chunk(struct inode inode, loff_t offset, loff_t len, int mode) { struct gfs2_inode ip = GFS2_I(inode); struct buffer_head dibh; int error; loff_t size = len; unsigned int nr_blks; sector_t lblock = offset >> inode->i_blkbits; error = gfs2_meta_inode_buffer(ip, &dibh); if (unlikely(error)) return error; gfs2_trans_add_meta(ip->i_gl, dibh); if (gfs2_is_stuffed(ip)) { error = gfs2_unstuff_dinode(ip, NULL); if (unlikely(error)) goto out; } while (len) { struct buffer_head bh_map = { .b_state = 0, .b_blocknr = 0 }; bh_map.b_size = len; set_buffer_zeronew(&bh_map); error = gfs2_block_map(inode, lblock, &bh_map, 1); if (unlikely(error)) goto out; len -= bh_map.b_size; nr_blks = bh_map.b_size >> inode->i_blkbits; lblock += nr_blks; if (!buffer_new(&bh_map)) continue; if (unlikely(!buffer_zeronew(&bh_map))) { error = -EIO; goto out; } } if (offset + size > inode->i_size && !(mode & FALLOC_FL_KEEP_SIZE)) i_size_write(inode, offset + size); mark_inode_dirty(inode); out: brelse(dibh); return error; } static void calc_max_reserv(struct gfs2_inode ip, loff_t max, loff_t len, unsigned int data_blocks, unsigned int ind_blocks) { const struct gfs2_sbd sdp = GFS2_SB(&ip->i_inode); unsigned int max_blocks = ip->i_rgd->rd_free_clone; unsigned int tmp, max_data = max_blocks - 3 (sdp->sd_max_height - 1); for (tmp = max_data; tmp > sdp->sd_diptrs;) { tmp = DIV_ROUND_UP(tmp, sdp->sd_inptrs); max_data -= tmp; } /* This calculation isn't the exact reverse of gfs2_write_calc_reserve, so it might end up with fewer data blocks / if (max_data <= data_blocks) return; data_blocks = max_data; ind_blocks = max_blocks - max_data; len = ((loff_t)max_data - 3) << sdp->sd_sb.sb_bsize_shift; if (len > max) { len = max; gfs2_write_calc_reserv(ip, max, data_blocks, ind_blocks); } } static long gfs2_fallocate(struct file file, int mode, loff_t offset, loff_t len) { struct inode inode = file_inode(file); struct gfs2_sbd sdp = GFS2_SB(inode); struct gfs2_inode ip = GFS2_I(inode); struct gfs2_alloc_parms ap = { .aflags = 0, }; unsigned int data_blocks = 0, ind_blocks = 0, rblocks; loff_t bytes, max_bytes; int error; const loff_t pos = offset; const loff_t count = len; loff_t bsize_mask = ~((loff_t)sdp->sd_sb.sb_bsize - 1); loff_t next = (offset + len - 1) >> sdp->sd_sb.sb_bsize_shift; loff_t max_chunk_size = UINT_MAX & bsize_mask; struct gfs2_holder gh; next = (next + 1) << sdp->sd_sb.sb_bsize_shift; / We only support the FALLOC_FL_KEEP_SIZE mode / if (mode & ~FALLOC_FL_KEEP_SIZE) return -EOPNOTSUPP; offset &= bsize_mask; len = next - offset; bytes = sdp->sd_max_rg_data sdp->sd_sb.sb_bsize / 2; if (!bytes) bytes = UINT_MAX; bytes &= bsize_mask; if (bytes == 0) bytes = sdp->sd_sb.sb_bsize; error = gfs2_rs_alloc(ip); if (error) return error; mutex_lock(&inode->i_mutex); gfs2_holder_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh); error = gfs2_glock_nq(&gh); if (unlikely(error)) goto out_uninit; gfs2_size_hint(file, offset, len); while (len > 0) { if (len < bytes) bytes = len; if (!gfs2_write_alloc_required(ip, offset, bytes)) { len -= bytes; offset += bytes; continue; } error = gfs2_quota_lock_check(ip); if (error) goto out_unlock; retry: gfs2_write_calc_reserv(ip, bytes, &data_blocks, &ind_blocks); ap.target = data_blocks + ind_blocks; error = gfs2_inplace_reserve(ip, &ap); if (error) { if (error == -ENOSPC && bytes > sdp->sd_sb.sb_bsize) { bytes >>= 1; bytes &= bsize_mask; if (bytes == 0) bytes = sdp->sd_sb.sb_bsize; goto retry; } goto out_qunlock; } max_bytes = bytes; calc_max_reserv(ip, (len > max_chunk_size)? max_chunk_size: len, &max_bytes, &data_blocks, &ind_blocks); rblocks = RES_DINODE + ind_blocks + RES_STATFS + RES_QUOTA + RES_RG_HDR + gfs2_rg_blocks(ip, data_blocks + ind_blocks); if (gfs2_is_jdata(ip)) rblocks += data_blocks ? data_blocks : 1; error = gfs2_trans_begin(sdp, rblocks, PAGE_CACHE_SIZE/sdp->sd_sb.sb_bsize); if (error) goto out_trans_fail; error = fallocate_chunk(inode, offset, max_bytes, mode); gfs2_trans_end(sdp); if (error) goto out_trans_fail; len -= max_bytes; offset += max_bytes; gfs2_inplace_release(ip); gfs2_quota_unlock(ip); } if (error == 0) error = generic_write_sync(file, pos, count); goto out_unlock; out_trans_fail: gfs2_inplace_release(ip); out_qunlock: gfs2_quota_unlock(ip); out_unlock: gfs2_glock_dq(&gh); out_uninit: gfs2_holder_uninit(&gh); mutex_unlock(&inode->i_mutex); return error; } #ifdef CONFIG_GFS2_FS_LOCKING_DLM /** * gfs2_setlease - acquire/release a file lease * @file: the file pointer * @arg: lease type * @fl: file lock * * We don't currently have a way to enforce a lease across the whole * cluster; until we do, disable leases (by just returning -EINVAL), * unless the administrator has requested purely local locking. * * Locking: called under i_lock * * Returns: errno / static int gfs2_setlease(struct file file, long arg, struct file_lock fl) { return -EINVAL; } / * gfs2_lock - acquire/release a posix lock on a file * @file: the file pointer * @cmd: either modify or retrieve lock state, possibly wait * @fl: type and range of lock * * Returns: errno / static int gfs2_lock(struct file file, int cmd, struct file_lock fl) { struct gfs2_inode ip = GFS2_I(file->f_mapping->host); struct gfs2_sbd sdp = GFS2_SB(file->f_mapping->host); struct lm_lockstruct ls = &sdp->sd_lockstruct; if (!(fl->fl_flags & FL_POSIX)) return -ENOLCK; if (__mandatory_lock(&ip->i_inode) && fl->fl_type != F_UNLCK) return -ENOLCK; if (cmd == F_CANCELLK) { /* Hack: / cmd = F_SETLK; fl->fl_type = F_UNLCK; } if (unlikely(test_bit(SDF_SHUTDOWN, &sdp->sd_flags))) { if (fl->fl_type == F_UNLCK) posix_lock_file_wait(file, fl); return -EIO; } if (IS_GETLK(cmd)) return dlm_posix_get(ls->ls_dlm, ip->i_no_addr, file, fl); else if (fl->fl_type == F_UNLCK) return dlm_posix_unlock(ls->ls_dlm, ip->i_no_addr, file, fl); else return dlm_posix_lock(ls->ls_dlm, ip->i_no_addr, file, cmd, fl); } static int do_flock(struct file file, int cmd, struct file_lock fl) { struct gfs2_file fp = file->private_data; struct gfs2_holder fl_gh = &fp->f_fl_gh; struct gfs2_inode ip = GFS2_I(file_inode(file)); struct gfs2_glock gl; unsigned int state; int flags; int error = 0; state = (fl->fl_type == F_WRLCK) ? LM_ST_EXCLUSIVE : LM_ST_SHARED; flags = (IS_SETLKW(cmd) ? 0 : LM_FLAG_TRY) \| GL_EXACT \| GL_NOCACHE; mutex_lock(&fp->f_fl_mutex); gl = fl_gh->gh_gl; if (gl) { if (fl_gh->gh_state == state) goto out; flock_lock_file_wait(file, &(struct file_lock){.fl_type = F_UNLCK}); gfs2_glock_dq_wait(fl_gh); gfs2_holder_reinit(state, flags, fl_gh); } else { error = gfs2_glock_get(GFS2_SB(&ip->i_inode), ip->i_no_addr, &gfs2_flock_glops, CREATE, &gl); if (error) goto out; gfs2_holder_init(gl, state, flags, fl_gh); gfs2_glock_put(gl); } error = gfs2_glock_nq(fl_gh); if (error) { gfs2_holder_uninit(fl_gh); if (error == GLR_TRYFAILED) error = -EAGAIN; } else { error = flock_lock_file_wait(file, fl); gfs2_assert_warn(GFS2_SB(&ip->i_inode), !error); } out: mutex_unlock(&fp->f_fl_mutex); return error; } static void do_unflock(struct file file, struct file_lock fl) { struct gfs2_file fp = file->private_data; struct gfs2_holder fl_gh = &fp->f_fl_gh; mutex_lock(&fp->f_fl_mutex); flock_lock_file_wait(file, fl); if (fl_gh->gh_gl) { gfs2_glock_dq_wait(fl_gh); gfs2_holder_uninit(fl_gh); } mutex_unlock(&fp->f_fl_mutex); } /* * gfs2_flock - acquire/release a flock lock on a file * @file: the file pointer * @cmd: either modify or retrieve lock state, possibly wait * @fl: type and range of lock * * Returns: errno / static int gfs2_flock(struct file file, int cmd, struct file_lock fl) { if (!(fl->fl_flags & FL_FLOCK)) return -ENOLCK; if (fl->fl_type & LOCK_MAND) return -EOPNOTSUPP; if (fl->fl_type == F_UNLCK) { do_unflock(file, fl); return 0; } else { return do_flock(file, cmd, fl); } } const struct file_operations gfs2_file_fops = { .llseek = gfs2_llseek, .read = new_sync_read, .read_iter = generic_file_read_iter, .write = new_sync_write, .write_iter = gfs2_file_write_iter, .unlocked_ioctl = gfs2_ioctl, .mmap = gfs2_mmap, .open = gfs2_open, .release = gfs2_release, .fsync = gfs2_fsync, .lock = gfs2_lock, .flock = gfs2_flock, .splice_read = generic_file_splice_read, .splice_write = iter_file_splice_write, .setlease = gfs2_setlease, .fallocate = gfs2_fallocate, }; const struct file_operations gfs2_dir_fops = { .iterate = gfs2_readdir, .unlocked_ioctl = gfs2_ioctl, .open = gfs2_open, .release = gfs2_release, .fsync = gfs2_fsync, .lock = gfs2_lock, .flock = gfs2_flock, .llseek = default_llseek, }; #endif / CONFIG_GFS2_FS_LOCKING_DLM */ const struct file_operations gfs2_file_fops_nolock = { .llseek = gfs2_llseek, .read = new_sync_read, .read_iter = generic_file_read_iter, .write = new_sync_write, .write_iter = gfs2_file_write_iter, .unlocked_ioctl = gfs2_ioctl, .mmap = gfs2_mmap, .open = gfs2_open, .release = gfs2_release, .fsync = gfs2_fsync, .splice_read = generic_file_splice_read, .splice_write = iter_file_splice_write, .setlease = generic_setlease, .fallocate = gfs2_fallocate, }; const struct file_operations gfs2_dir_fops_nolock = { .iterate = gfs2_readdir, .unlocked_ioctl = gfs2_ioctl, .open = gfs2_open, .release = gfs2_release, .fsync = gfs2_fsync, .llseek = default_llseek, };	./CrossVul/dataset_final_sorted/CWE-264/c/good_2287_6
crossvul-cpp_data_good_4821_0	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/ /* This file is part of systemd. Copyright 2010 Lennart Poettering 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 the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. systemd is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details. You should have received a copy of the GNU Lesser General Public License along with systemd; If not, see <http://www.gnu.org/licenses/>. / #include "alloc-util.h" #include "dirent-util.h" #include "fd-util.h" #include "fileio.h" #include "fs-util.h" #include "mkdir.h" #include "parse-util.h" #include "path-util.h" #include "string-util.h" #include "strv.h" #include "user-util.h" #include "util.h" int unlink_noerrno(const char path) { PROTECT_ERRNO; int r; r = unlink(path); if (r < 0) return -errno; return 0; } int rmdir_parents(const char path, const char stop) { size_t l; int r = 0; assert(path); assert(stop); l = strlen(path); /* Skip trailing slashes / while (l > 0 && path[l-1] == '/') l--; while (l > 0) { char t; /* Skip last component / while (l > 0 && path[l-1] != '/') l--; / Skip trailing slashes / while (l > 0 && path[l-1] == '/') l--; if (l <= 0) break; t = strndup(path, l); if (!t) return -ENOMEM; if (path_startswith(stop, t)) { free(t); return 0; } r = rmdir(t); free(t); if (r < 0) if (errno != ENOENT) return -errno; } return 0; } int rename_noreplace(int olddirfd, const char oldpath, int newdirfd, const char newpath) { struct stat buf; int ret; ret = renameat2(olddirfd, oldpath, newdirfd, newpath, RENAME_NOREPLACE); if (ret >= 0) return 0; / renameat2() exists since Linux 3.15, btrfs added support for it later. * If it is not implemented, fallback to another method. / if (!IN_SET(errno, EINVAL, ENOSYS)) return -errno; / The link()/unlink() fallback does not work on directories. But * renameat() without RENAME_NOREPLACE gives the same semantics on * directories, except when newpath is an empty directory. This is * good enough. / ret = fstatat(olddirfd, oldpath, &buf, AT_SYMLINK_NOFOLLOW); if (ret >= 0 && S_ISDIR(buf.st_mode)) { ret = renameat(olddirfd, oldpath, newdirfd, newpath); return ret >= 0 ? 0 : -errno; } / If it is not a directory, use the link()/unlink() fallback. / ret = linkat(olddirfd, oldpath, newdirfd, newpath, 0); if (ret < 0) return -errno; ret = unlinkat(olddirfd, oldpath, 0); if (ret < 0) { / backup errno before the following unlinkat() alters it / ret = errno; (void) unlinkat(newdirfd, newpath, 0); errno = ret; return -errno; } return 0; } int readlinkat_malloc(int fd, const char p, char *ret) { size_t l = 100; int r; assert(p); assert(ret); for (;;) { char c; ssize_t n; c = new(char, l); if (!c) return -ENOMEM; n = readlinkat(fd, p, c, l-1); if (n < 0) { r = -errno; free(c); return r; } if ((size_t) n < l-1) { c[n] = 0; ret = c; return 0; } free(c); l = 2; } } int readlink_malloc(const char p, char ret) { return readlinkat_malloc(AT_FDCWD, p, ret); } int readlink_value(const char p, char *ret) { _cleanup_free_ char link = NULL; char value; int r; r = readlink_malloc(p, &link); if (r < 0) return r; value = basename(link); if (!value) return -ENOENT; value = strdup(value); if (!value) return -ENOMEM; ret = value; return 0; } int readlink_and_make_absolute(const char p, char r) { _cleanup_free_ char target = NULL; char k; int j; assert(p); assert(r); j = readlink_malloc(p, &target); if (j < 0) return j; k = file_in_same_dir(p, target); if (!k) return -ENOMEM; r = k; return 0; } int readlink_and_canonicalize(const char p, char r) { char t, s; int j; assert(p); assert(r); j = readlink_and_make_absolute(p, &t); if (j < 0) return j; s = canonicalize_file_name(t); if (s) { free(t); r = s; } else r = t; path_kill_slashes(r); return 0; } int chmod_and_chown(const char path, mode_t mode, uid_t uid, gid_t gid) { assert(path); / Under the assumption that we are running privileged we * first change the access mode and only then hand out * ownership to avoid a window where access is too open. / if (mode != MODE_INVALID) if (chmod(path, mode) < 0) return -errno; if (uid != UID_INVALID \|\| gid != GID_INVALID) if (chown(path, uid, gid) < 0) return -errno; return 0; } int fchmod_and_fchown(int fd, mode_t mode, uid_t uid, gid_t gid) { assert(fd >= 0); / Under the assumption that we are running privileged we * first change the access mode and only then hand out * ownership to avoid a window where access is too open. / if (mode != MODE_INVALID) if (fchmod(fd, mode) < 0) return -errno; if (uid != UID_INVALID \|\| gid != GID_INVALID) if (fchown(fd, uid, gid) < 0) return -errno; return 0; } int fchmod_umask(int fd, mode_t m) { mode_t u; int r; u = umask(0777); r = fchmod(fd, m & (~u)) < 0 ? -errno : 0; umask(u); return r; } int fd_warn_permissions(const char path, int fd) { struct stat st; if (fstat(fd, &st) < 0) return -errno; if (st.st_mode & 0111) log_warning("Configuration file %s is marked executable. Please remove executable permission bits. Proceeding anyway.", path); if (st.st_mode & 0002) log_warning("Configuration file %s is marked world-writable. Please remove world writability permission bits. Proceeding anyway.", path); if (getpid() == 1 && (st.st_mode & 0044) != 0044) log_warning("Configuration file %s is marked world-inaccessible. This has no effect as configuration data is accessible via APIs without restrictions. Proceeding anyway.", path); return 0; } int touch_file(const char path, bool parents, usec_t stamp, uid_t uid, gid_t gid, mode_t mode) { _cleanup_close_ int fd; int r; assert(path); if (parents) mkdir_parents(path, 0755); fd = open(path, O_WRONLY\|O_CREAT\|O_CLOEXEC\|O_NOCTTY, mode > 0 ? mode : 0644); if (fd < 0) return -errno; if (mode != MODE_INVALID) { r = fchmod(fd, mode); if (r < 0) return -errno; } if (uid != UID_INVALID \|\| gid != GID_INVALID) { r = fchown(fd, uid, gid); if (r < 0) return -errno; } if (stamp != USEC_INFINITY) { struct timespec ts[2]; timespec_store(&ts[0], stamp); ts[1] = ts[0]; r = futimens(fd, ts); } else r = futimens(fd, NULL); if (r < 0) return -errno; return 0; } int touch(const char path) { return touch_file(path, false, USEC_INFINITY, UID_INVALID, GID_INVALID, MODE_INVALID); } int symlink_idempotent(const char from, const char to) { _cleanup_free_ char p = NULL; int r; assert(from); assert(to); if (symlink(from, to) < 0) { if (errno != EEXIST) return -errno; r = readlink_malloc(to, &p); if (r < 0) return r; if (!streq(p, from)) return -EINVAL; } return 0; } int symlink_atomic(const char from, const char to) { _cleanup_free_ char t = NULL; int r; assert(from); assert(to); r = tempfn_random(to, NULL, &t); if (r < 0) return r; if (symlink(from, t) < 0) return -errno; if (rename(t, to) < 0) { unlink_noerrno(t); return -errno; } return 0; } int mknod_atomic(const char path, mode_t mode, dev_t dev) { _cleanup_free_ char t = NULL; int r; assert(path); r = tempfn_random(path, NULL, &t); if (r < 0) return r; if (mknod(t, mode, dev) < 0) return -errno; if (rename(t, path) < 0) { unlink_noerrno(t); return -errno; } return 0; } int mkfifo_atomic(const char path, mode_t mode) { _cleanup_free_ char t = NULL; int r; assert(path); r = tempfn_random(path, NULL, &t); if (r < 0) return r; if (mkfifo(t, mode) < 0) return -errno; if (rename(t, path) < 0) { unlink_noerrno(t); return -errno; } return 0; } int get_files_in_directory(const char path, char *list) { _cleanup_closedir_ DIR d = NULL; size_t bufsize = 0, n = 0; _cleanup_strv_free_ char *l = NULL; assert(path); / Returns all files in a directory in list, and the number of files as return value. If list is NULL returns only the * number. / d = opendir(path); if (!d) return -errno; for (;;) { struct dirent de; errno = 0; de = readdir(d); if (!de && errno != 0) return -errno; if (!de) break; dirent_ensure_type(d, de); if (!dirent_is_file(de)) continue; if (list) { /* one extra slot is needed for the terminating NULL / if (!GREEDY_REALLOC(l, bufsize, n + 2)) return -ENOMEM; l[n] = strdup(de->d_name); if (!l[n]) return -ENOMEM; l[++n] = NULL; } else n++; } if (list) { list = l; l = NULL; /* avoid freeing */ } return n; }	./CrossVul/dataset_final_sorted/CWE-264/c/good_4821_0
crossvul-cpp_data_good_1795_0	/* * * Copyright (C) 2011 Novell Inc. * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 as published by * the Free Software Foundation. / #include <linux/fs.h> #include <linux/slab.h> #include <linux/xattr.h> #include "overlayfs.h" static int ovl_copy_up_last(struct dentry dentry, struct iattr attr, bool no_data) { int err; struct dentry parent; struct kstat stat; struct path lowerpath; parent = dget_parent(dentry); err = ovl_copy_up(parent); if (err) goto out_dput_parent; ovl_path_lower(dentry, &lowerpath); err = vfs_getattr(&lowerpath, &stat); if (err) goto out_dput_parent; if (no_data) stat.size = 0; err = ovl_copy_up_one(parent, dentry, &lowerpath, &stat, attr); out_dput_parent: dput(parent); return err; } int ovl_setattr(struct dentry dentry, struct iattr attr) { int err; struct dentry upperdentry; err = ovl_want_write(dentry); if (err) goto out; err = ovl_copy_up(dentry); if (!err) { upperdentry = ovl_dentry_upper(dentry); mutex_lock(&upperdentry->d_inode->i_mutex); err = notify_change(upperdentry, attr, NULL); mutex_unlock(&upperdentry->d_inode->i_mutex); } ovl_drop_write(dentry); out: return err; } static int ovl_getattr(struct vfsmount mnt, struct dentry dentry, struct kstat stat) { struct path realpath; ovl_path_real(dentry, &realpath); return vfs_getattr(&realpath, stat); } int ovl_permission(struct inode inode, int mask) { struct ovl_entry oe; struct dentry alias = NULL; struct inode realinode; struct dentry realdentry; bool is_upper; int err; if (S_ISDIR(inode->i_mode)) { oe = inode->i_private; } else if (mask & MAY_NOT_BLOCK) { return -ECHILD; } else { / * For non-directories find an alias and get the info * from there. / alias = d_find_any_alias(inode); if (WARN_ON(!alias)) return -ENOENT; oe = alias->d_fsdata; } realdentry = ovl_entry_real(oe, &is_upper); / Careful in RCU walk mode / realinode = ACCESS_ONCE(realdentry->d_inode); if (!realinode) { WARN_ON(!(mask & MAY_NOT_BLOCK)); err = -ENOENT; goto out_dput; } if (mask & MAY_WRITE) { umode_t mode = realinode->i_mode; / * Writes will always be redirected to upper layer, so * ignore lower layer being read-only. * * If the overlay itself is read-only then proceed * with the permission check, don't return EROFS. * This will only happen if this is the lower layer of * another overlayfs. * * If upper fs becomes read-only after the overlay was * constructed return EROFS to prevent modification of * upper layer. / err = -EROFS; if (is_upper && !IS_RDONLY(inode) && IS_RDONLY(realinode) && (S_ISREG(mode) \|\| S_ISDIR(mode) \|\| S_ISLNK(mode))) goto out_dput; } err = __inode_permission(realinode, mask); out_dput: dput(alias); return err; } struct ovl_link_data { struct dentry realdentry; void cookie; }; static const char ovl_follow_link(struct dentry dentry, void cookie) { struct dentry realdentry; struct inode realinode; struct ovl_link_data data = NULL; const char ret; realdentry = ovl_dentry_real(dentry); realinode = realdentry->d_inode; if (WARN_ON(!realinode->i_op->follow_link)) return ERR_PTR(-EPERM); if (realinode->i_op->put_link) { data = kmalloc(sizeof(struct ovl_link_data), GFP_KERNEL); if (!data) return ERR_PTR(-ENOMEM); data->realdentry = realdentry; } ret = realinode->i_op->follow_link(realdentry, cookie); if (IS_ERR_OR_NULL(ret)) { kfree(data); return ret; } if (data) data->cookie = cookie; cookie = data; return ret; } static void ovl_put_link(struct inode unused, void c) { struct inode realinode; struct ovl_link_data data = c; if (!data) return; realinode = data->realdentry->d_inode; realinode->i_op->put_link(realinode, data->cookie); kfree(data); } static int ovl_readlink(struct dentry dentry, char __user buf, int bufsiz) { struct path realpath; struct inode realinode; ovl_path_real(dentry, &realpath); realinode = realpath.dentry->d_inode; if (!realinode->i_op->readlink) return -EINVAL; touch_atime(&realpath); return realinode->i_op->readlink(realpath.dentry, buf, bufsiz); } static bool ovl_is_private_xattr(const char name) { return strncmp(name, OVL_XATTR_PRE_NAME, OVL_XATTR_PRE_LEN) == 0; } int ovl_setxattr(struct dentry dentry, const char name, const void value, size_t size, int flags) { int err; struct dentry upperdentry; err = ovl_want_write(dentry); if (err) goto out; err = -EPERM; if (ovl_is_private_xattr(name)) goto out_drop_write; err = ovl_copy_up(dentry); if (err) goto out_drop_write; upperdentry = ovl_dentry_upper(dentry); err = vfs_setxattr(upperdentry, name, value, size, flags); out_drop_write: ovl_drop_write(dentry); out: return err; } static bool ovl_need_xattr_filter(struct dentry dentry, enum ovl_path_type type) { if ((type & (__OVL_PATH_PURE \| __OVL_PATH_UPPER)) == __OVL_PATH_UPPER) return S_ISDIR(dentry->d_inode->i_mode); else return false; } ssize_t ovl_getxattr(struct dentry dentry, const char name, void value, size_t size) { struct path realpath; enum ovl_path_type type = ovl_path_real(dentry, &realpath); if (ovl_need_xattr_filter(dentry, type) && ovl_is_private_xattr(name)) return -ENODATA; return vfs_getxattr(realpath.dentry, name, value, size); } ssize_t ovl_listxattr(struct dentry dentry, char list, size_t size) { struct path realpath; enum ovl_path_type type = ovl_path_real(dentry, &realpath); ssize_t res; int off; res = vfs_listxattr(realpath.dentry, list, size); if (res <= 0 \|\| size == 0) return res; if (!ovl_need_xattr_filter(dentry, type)) return res; / filter out private xattrs / for (off = 0; off < res;) { char s = list + off; size_t slen = strlen(s) + 1; BUG_ON(off + slen > res); if (ovl_is_private_xattr(s)) { res -= slen; memmove(s, s + slen, res - off); } else { off += slen; } } return res; } int ovl_removexattr(struct dentry dentry, const char name) { int err; struct path realpath; enum ovl_path_type type = ovl_path_real(dentry, &realpath); err = ovl_want_write(dentry); if (err) goto out; err = -ENODATA; if (ovl_need_xattr_filter(dentry, type) && ovl_is_private_xattr(name)) goto out_drop_write; if (!OVL_TYPE_UPPER(type)) { err = vfs_getxattr(realpath.dentry, name, NULL, 0); if (err < 0) goto out_drop_write; err = ovl_copy_up(dentry); if (err) goto out_drop_write; ovl_path_upper(dentry, &realpath); } err = vfs_removexattr(realpath.dentry, name); out_drop_write: ovl_drop_write(dentry); out: return err; } static bool ovl_open_need_copy_up(int flags, enum ovl_path_type type, struct dentry realdentry) { if (OVL_TYPE_UPPER(type)) return false; if (special_file(realdentry->d_inode->i_mode)) return false; if (!(OPEN_FMODE(flags) & FMODE_WRITE) && !(flags & O_TRUNC)) return false; return true; } struct inode ovl_d_select_inode(struct dentry dentry, unsigned file_flags) { int err; struct path realpath; enum ovl_path_type type; if (d_is_dir(dentry)) return d_backing_inode(dentry); type = ovl_path_real(dentry, &realpath); if (ovl_open_need_copy_up(file_flags, type, realpath.dentry)) { err = ovl_want_write(dentry); if (err) return ERR_PTR(err); if (file_flags & O_TRUNC) err = ovl_copy_up_last(dentry, NULL, true); else err = ovl_copy_up(dentry); ovl_drop_write(dentry); if (err) return ERR_PTR(err); ovl_path_upper(dentry, &realpath); } if (realpath.dentry->d_flags & DCACHE_OP_SELECT_INODE) return realpath.dentry->d_op->d_select_inode(realpath.dentry, file_flags); return d_backing_inode(realpath.dentry); } static const struct inode_operations ovl_file_inode_operations = { .setattr = ovl_setattr, .permission = ovl_permission, .getattr = ovl_getattr, .setxattr = ovl_setxattr, .getxattr = ovl_getxattr, .listxattr = ovl_listxattr, .removexattr = ovl_removexattr, }; static const struct inode_operations ovl_symlink_inode_operations = { .setattr = ovl_setattr, .follow_link = ovl_follow_link, .put_link = ovl_put_link, .readlink = ovl_readlink, .getattr = ovl_getattr, .setxattr = ovl_setxattr, .getxattr = ovl_getxattr, .listxattr = ovl_listxattr, .removexattr = ovl_removexattr, }; struct inode ovl_new_inode(struct super_block sb, umode_t mode, struct ovl_entry oe) { struct inode *inode; inode = new_inode(sb); if (!inode) return NULL; mode &= S_IFMT; inode->i_ino = get_next_ino(); inode->i_mode = mode; inode->i_flags \|= S_NOATIME \| S_NOCMTIME; switch (mode) { case S_IFDIR: inode->i_private = oe; inode->i_op = &ovl_dir_inode_operations; inode->i_fop = &ovl_dir_operations; break; case S_IFLNK: inode->i_op = &ovl_symlink_inode_operations; break; case S_IFREG: case S_IFSOCK: case S_IFBLK: case S_IFCHR: case S_IFIFO: inode->i_op = &ovl_file_inode_operations; break; default: WARN(1, "illegal file type: %i\n", mode); iput(inode); inode = NULL; } return inode; }	./CrossVul/dataset_final_sorted/CWE-264/c/good_1795_0
crossvul-cpp_data_bad_3439_3	404: Not Found	./CrossVul/dataset_final_sorted/CWE-264/c/bad_3439_3
crossvul-cpp_data_good_5861_37	/* * Glue Code for SSE2 assembler versions of Serpent Cipher * * Copyright (c) 2011 Jussi Kivilinna <jussi.kivilinna@mbnet.fi> * * Glue code based on aesni-intel_glue.c by: * Copyright (C) 2008, Intel Corp. * Author: Huang Ying <ying.huang@intel.com> * * CBC & ECB parts based on code (crypto/cbc.c,ecb.c) by: * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au> * CTR part based on code (crypto/ctr.c) by: * (C) Copyright IBM Corp. 2007 - Joy Latten <latten@us.ibm.com> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 * USA * / #include <linux/module.h> #include <linux/hardirq.h> #include <linux/types.h> #include <linux/crypto.h> #include <linux/err.h> #include <crypto/ablk_helper.h> #include <crypto/algapi.h> #include <crypto/serpent.h> #include <crypto/cryptd.h> #include <crypto/b128ops.h> #include <crypto/ctr.h> #include <crypto/lrw.h> #include <crypto/xts.h> #include <asm/crypto/serpent-sse2.h> #include <asm/crypto/glue_helper.h> static void serpent_decrypt_cbc_xway(void ctx, u128 dst, const u128 src) { u128 ivs[SERPENT_PARALLEL_BLOCKS - 1]; unsigned int j; for (j = 0; j < SERPENT_PARALLEL_BLOCKS - 1; j++) ivs[j] = src[j]; serpent_dec_blk_xway(ctx, (u8 )dst, (u8 )src); for (j = 0; j < SERPENT_PARALLEL_BLOCKS - 1; j++) u128_xor(dst + (j + 1), dst + (j + 1), ivs + j); } static void serpent_crypt_ctr(void ctx, u128 dst, const u128 src, le128 iv) { be128 ctrblk; le128_to_be128(&ctrblk, iv); le128_inc(iv); __serpent_encrypt(ctx, (u8 )&ctrblk, (u8 )&ctrblk); u128_xor(dst, src, (u128 )&ctrblk); } static void serpent_crypt_ctr_xway(void ctx, u128 dst, const u128 src, le128 iv) { be128 ctrblks[SERPENT_PARALLEL_BLOCKS]; unsigned int i; for (i = 0; i < SERPENT_PARALLEL_BLOCKS; i++) { if (dst != src) dst[i] = src[i]; le128_to_be128(&ctrblks[i], iv); le128_inc(iv); } serpent_enc_blk_xway_xor(ctx, (u8 )dst, (u8 )ctrblks); } static const struct common_glue_ctx serpent_enc = { .num_funcs = 2, .fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS, .funcs = { { .num_blocks = SERPENT_PARALLEL_BLOCKS, .fn_u = { .ecb = GLUE_FUNC_CAST(serpent_enc_blk_xway) } }, { .num_blocks = 1, .fn_u = { .ecb = GLUE_FUNC_CAST(__serpent_encrypt) } } } }; static const struct common_glue_ctx serpent_ctr = { .num_funcs = 2, .fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS, .funcs = { { .num_blocks = SERPENT_PARALLEL_BLOCKS, .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(serpent_crypt_ctr_xway) } }, { .num_blocks = 1, .fn_u = { .ctr = GLUE_CTR_FUNC_CAST(serpent_crypt_ctr) } } } }; static const struct common_glue_ctx serpent_dec = { .num_funcs = 2, .fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS, .funcs = { { .num_blocks = SERPENT_PARALLEL_BLOCKS, .fn_u = { .ecb = GLUE_FUNC_CAST(serpent_dec_blk_xway) } }, { .num_blocks = 1, .fn_u = { .ecb = GLUE_FUNC_CAST(__serpent_decrypt) } } } }; static const struct common_glue_ctx serpent_dec_cbc = { .num_funcs = 2, .fpu_blocks_limit = SERPENT_PARALLEL_BLOCKS, .funcs = { { .num_blocks = SERPENT_PARALLEL_BLOCKS, .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(serpent_decrypt_cbc_xway) } }, { .num_blocks = 1, .fn_u = { .cbc = GLUE_CBC_FUNC_CAST(__serpent_decrypt) } } } }; static int ecb_encrypt(struct blkcipher_desc desc, struct scatterlist dst, struct scatterlist src, unsigned int nbytes) { return glue_ecb_crypt_128bit(&serpent_enc, desc, dst, src, nbytes); } static int ecb_decrypt(struct blkcipher_desc desc, struct scatterlist dst, struct scatterlist src, unsigned int nbytes) { return glue_ecb_crypt_128bit(&serpent_dec, desc, dst, src, nbytes); } static int cbc_encrypt(struct blkcipher_desc desc, struct scatterlist dst, struct scatterlist src, unsigned int nbytes) { return glue_cbc_encrypt_128bit(GLUE_FUNC_CAST(__serpent_encrypt), desc, dst, src, nbytes); } static int cbc_decrypt(struct blkcipher_desc desc, struct scatterlist dst, struct scatterlist src, unsigned int nbytes) { return glue_cbc_decrypt_128bit(&serpent_dec_cbc, desc, dst, src, nbytes); } static int ctr_crypt(struct blkcipher_desc desc, struct scatterlist dst, struct scatterlist src, unsigned int nbytes) { return glue_ctr_crypt_128bit(&serpent_ctr, desc, dst, src, nbytes); } static inline bool serpent_fpu_begin(bool fpu_enabled, unsigned int nbytes) { return glue_fpu_begin(SERPENT_BLOCK_SIZE, SERPENT_PARALLEL_BLOCKS, NULL, fpu_enabled, nbytes); } static inline void serpent_fpu_end(bool fpu_enabled) { glue_fpu_end(fpu_enabled); } struct crypt_priv { struct serpent_ctx ctx; bool fpu_enabled; }; static void encrypt_callback(void priv, u8 srcdst, unsigned int nbytes) { const unsigned int bsize = SERPENT_BLOCK_SIZE; struct crypt_priv ctx = priv; int i; ctx->fpu_enabled = serpent_fpu_begin(ctx->fpu_enabled, nbytes); if (nbytes == bsize * SERPENT_PARALLEL_BLOCKS) { serpent_enc_blk_xway(ctx->ctx, srcdst, srcdst); return; } for (i = 0; i < nbytes / bsize; i++, srcdst += bsize) __serpent_encrypt(ctx->ctx, srcdst, srcdst); } static void decrypt_callback(void priv, u8 srcdst, unsigned int nbytes) { const unsigned int bsize = SERPENT_BLOCK_SIZE; struct crypt_priv ctx = priv; int i; ctx->fpu_enabled = serpent_fpu_begin(ctx->fpu_enabled, nbytes); if (nbytes == bsize SERPENT_PARALLEL_BLOCKS) { serpent_dec_blk_xway(ctx->ctx, srcdst, srcdst); return; } for (i = 0; i < nbytes / bsize; i++, srcdst += bsize) __serpent_decrypt(ctx->ctx, srcdst, srcdst); } struct serpent_lrw_ctx { struct lrw_table_ctx lrw_table; struct serpent_ctx serpent_ctx; }; static int lrw_serpent_setkey(struct crypto_tfm tfm, const u8 key, unsigned int keylen) { struct serpent_lrw_ctx ctx = crypto_tfm_ctx(tfm); int err; err = __serpent_setkey(&ctx->serpent_ctx, key, keylen - SERPENT_BLOCK_SIZE); if (err) return err; return lrw_init_table(&ctx->lrw_table, key + keylen - SERPENT_BLOCK_SIZE); } static int lrw_encrypt(struct blkcipher_desc desc, struct scatterlist dst, struct scatterlist src, unsigned int nbytes) { struct serpent_lrw_ctx ctx = crypto_blkcipher_ctx(desc->tfm); be128 buf[SERPENT_PARALLEL_BLOCKS]; struct crypt_priv crypt_ctx = { .ctx = &ctx->serpent_ctx, .fpu_enabled = false, }; struct lrw_crypt_req req = { .tbuf = buf, .tbuflen = sizeof(buf), .table_ctx = &ctx->lrw_table, .crypt_ctx = &crypt_ctx, .crypt_fn = encrypt_callback, }; int ret; desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP; ret = lrw_crypt(desc, dst, src, nbytes, &req); serpent_fpu_end(crypt_ctx.fpu_enabled); return ret; } static int lrw_decrypt(struct blkcipher_desc desc, struct scatterlist dst, struct scatterlist src, unsigned int nbytes) { struct serpent_lrw_ctx ctx = crypto_blkcipher_ctx(desc->tfm); be128 buf[SERPENT_PARALLEL_BLOCKS]; struct crypt_priv crypt_ctx = { .ctx = &ctx->serpent_ctx, .fpu_enabled = false, }; struct lrw_crypt_req req = { .tbuf = buf, .tbuflen = sizeof(buf), .table_ctx = &ctx->lrw_table, .crypt_ctx = &crypt_ctx, .crypt_fn = decrypt_callback, }; int ret; desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP; ret = lrw_crypt(desc, dst, src, nbytes, &req); serpent_fpu_end(crypt_ctx.fpu_enabled); return ret; } static void lrw_exit_tfm(struct crypto_tfm tfm) { struct serpent_lrw_ctx ctx = crypto_tfm_ctx(tfm); lrw_free_table(&ctx->lrw_table); } struct serpent_xts_ctx { struct serpent_ctx tweak_ctx; struct serpent_ctx crypt_ctx; }; static int xts_serpent_setkey(struct crypto_tfm tfm, const u8 key, unsigned int keylen) { struct serpent_xts_ctx ctx = crypto_tfm_ctx(tfm); u32 flags = &tfm->crt_flags; int err; / key consists of keys of equal size concatenated, therefore * the length must be even / if (keylen % 2) { flags \|= CRYPTO_TFM_RES_BAD_KEY_LEN; return -EINVAL; } /* first half of xts-key is for crypt / err = __serpent_setkey(&ctx->crypt_ctx, key, keylen / 2); if (err) return err; / second half of xts-key is for tweak / return __serpent_setkey(&ctx->tweak_ctx, key + keylen / 2, keylen / 2); } static int xts_encrypt(struct blkcipher_desc desc, struct scatterlist dst, struct scatterlist src, unsigned int nbytes) { struct serpent_xts_ctx ctx = crypto_blkcipher_ctx(desc->tfm); be128 buf[SERPENT_PARALLEL_BLOCKS]; struct crypt_priv crypt_ctx = { .ctx = &ctx->crypt_ctx, .fpu_enabled = false, }; struct xts_crypt_req req = { .tbuf = buf, .tbuflen = sizeof(buf), .tweak_ctx = &ctx->tweak_ctx, .tweak_fn = XTS_TWEAK_CAST(__serpent_encrypt), .crypt_ctx = &crypt_ctx, .crypt_fn = encrypt_callback, }; int ret; desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP; ret = xts_crypt(desc, dst, src, nbytes, &req); serpent_fpu_end(crypt_ctx.fpu_enabled); return ret; } static int xts_decrypt(struct blkcipher_desc desc, struct scatterlist dst, struct scatterlist src, unsigned int nbytes) { struct serpent_xts_ctx ctx = crypto_blkcipher_ctx(desc->tfm); be128 buf[SERPENT_PARALLEL_BLOCKS]; struct crypt_priv crypt_ctx = { .ctx = &ctx->crypt_ctx, .fpu_enabled = false, }; struct xts_crypt_req req = { .tbuf = buf, .tbuflen = sizeof(buf), .tweak_ctx = &ctx->tweak_ctx, .tweak_fn = XTS_TWEAK_CAST(__serpent_encrypt), .crypt_ctx = &crypt_ctx, .crypt_fn = decrypt_callback, }; int ret; desc->flags &= ~CRYPTO_TFM_REQ_MAY_SLEEP; ret = xts_crypt(desc, dst, src, nbytes, &req); serpent_fpu_end(crypt_ctx.fpu_enabled); return ret; } static struct crypto_alg serpent_algs[10] = { { .cra_name = "__ecb-serpent-sse2", .cra_driver_name = "__driver-ecb-serpent-sse2", .cra_priority = 0, .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, .cra_blocksize = SERPENT_BLOCK_SIZE, .cra_ctxsize = sizeof(struct serpent_ctx), .cra_alignmask = 0, .cra_type = &crypto_blkcipher_type, .cra_module = THIS_MODULE, .cra_u = { .blkcipher = { .min_keysize = SERPENT_MIN_KEY_SIZE, .max_keysize = SERPENT_MAX_KEY_SIZE, .setkey = serpent_setkey, .encrypt = ecb_encrypt, .decrypt = ecb_decrypt, }, }, }, { .cra_name = "__cbc-serpent-sse2", .cra_driver_name = "__driver-cbc-serpent-sse2", .cra_priority = 0, .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, .cra_blocksize = SERPENT_BLOCK_SIZE, .cra_ctxsize = sizeof(struct serpent_ctx), .cra_alignmask = 0, .cra_type = &crypto_blkcipher_type, .cra_module = THIS_MODULE, .cra_u = { .blkcipher = { .min_keysize = SERPENT_MIN_KEY_SIZE, .max_keysize = SERPENT_MAX_KEY_SIZE, .setkey = serpent_setkey, .encrypt = cbc_encrypt, .decrypt = cbc_decrypt, }, }, }, { .cra_name = "__ctr-serpent-sse2", .cra_driver_name = "__driver-ctr-serpent-sse2", .cra_priority = 0, .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, .cra_blocksize = 1, .cra_ctxsize = sizeof(struct serpent_ctx), .cra_alignmask = 0, .cra_type = &crypto_blkcipher_type, .cra_module = THIS_MODULE, .cra_u = { .blkcipher = { .min_keysize = SERPENT_MIN_KEY_SIZE, .max_keysize = SERPENT_MAX_KEY_SIZE, .ivsize = SERPENT_BLOCK_SIZE, .setkey = serpent_setkey, .encrypt = ctr_crypt, .decrypt = ctr_crypt, }, }, }, { .cra_name = "__lrw-serpent-sse2", .cra_driver_name = "__driver-lrw-serpent-sse2", .cra_priority = 0, .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, .cra_blocksize = SERPENT_BLOCK_SIZE, .cra_ctxsize = sizeof(struct serpent_lrw_ctx), .cra_alignmask = 0, .cra_type = &crypto_blkcipher_type, .cra_module = THIS_MODULE, .cra_exit = lrw_exit_tfm, .cra_u = { .blkcipher = { .min_keysize = SERPENT_MIN_KEY_SIZE + SERPENT_BLOCK_SIZE, .max_keysize = SERPENT_MAX_KEY_SIZE + SERPENT_BLOCK_SIZE, .ivsize = SERPENT_BLOCK_SIZE, .setkey = lrw_serpent_setkey, .encrypt = lrw_encrypt, .decrypt = lrw_decrypt, }, }, }, { .cra_name = "__xts-serpent-sse2", .cra_driver_name = "__driver-xts-serpent-sse2", .cra_priority = 0, .cra_flags = CRYPTO_ALG_TYPE_BLKCIPHER, .cra_blocksize = SERPENT_BLOCK_SIZE, .cra_ctxsize = sizeof(struct serpent_xts_ctx), .cra_alignmask = 0, .cra_type = &crypto_blkcipher_type, .cra_module = THIS_MODULE, .cra_u = { .blkcipher = { .min_keysize = SERPENT_MIN_KEY_SIZE 2, .max_keysize = SERPENT_MAX_KEY_SIZE * 2, .ivsize = SERPENT_BLOCK_SIZE, .setkey = xts_serpent_setkey, .encrypt = xts_encrypt, .decrypt = xts_decrypt, }, }, }, { .cra_name = "ecb(serpent)", .cra_driver_name = "ecb-serpent-sse2", .cra_priority = 400, .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \| CRYPTO_ALG_ASYNC, .cra_blocksize = SERPENT_BLOCK_SIZE, .cra_ctxsize = sizeof(struct async_helper_ctx), .cra_alignmask = 0, .cra_type = &crypto_ablkcipher_type, .cra_module = THIS_MODULE, .cra_init = ablk_init, .cra_exit = ablk_exit, .cra_u = { .ablkcipher = { .min_keysize = SERPENT_MIN_KEY_SIZE, .max_keysize = SERPENT_MAX_KEY_SIZE, .setkey = ablk_set_key, .encrypt = ablk_encrypt, .decrypt = ablk_decrypt, }, }, }, { .cra_name = "cbc(serpent)", .cra_driver_name = "cbc-serpent-sse2", .cra_priority = 400, .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \| CRYPTO_ALG_ASYNC, .cra_blocksize = SERPENT_BLOCK_SIZE, .cra_ctxsize = sizeof(struct async_helper_ctx), .cra_alignmask = 0, .cra_type = &crypto_ablkcipher_type, .cra_module = THIS_MODULE, .cra_init = ablk_init, .cra_exit = ablk_exit, .cra_u = { .ablkcipher = { .min_keysize = SERPENT_MIN_KEY_SIZE, .max_keysize = SERPENT_MAX_KEY_SIZE, .ivsize = SERPENT_BLOCK_SIZE, .setkey = ablk_set_key, .encrypt = __ablk_encrypt, .decrypt = ablk_decrypt, }, }, }, { .cra_name = "ctr(serpent)", .cra_driver_name = "ctr-serpent-sse2", .cra_priority = 400, .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \| CRYPTO_ALG_ASYNC, .cra_blocksize = 1, .cra_ctxsize = sizeof(struct async_helper_ctx), .cra_alignmask = 0, .cra_type = &crypto_ablkcipher_type, .cra_module = THIS_MODULE, .cra_init = ablk_init, .cra_exit = ablk_exit, .cra_u = { .ablkcipher = { .min_keysize = SERPENT_MIN_KEY_SIZE, .max_keysize = SERPENT_MAX_KEY_SIZE, .ivsize = SERPENT_BLOCK_SIZE, .setkey = ablk_set_key, .encrypt = ablk_encrypt, .decrypt = ablk_encrypt, .geniv = "chainiv", }, }, }, { .cra_name = "lrw(serpent)", .cra_driver_name = "lrw-serpent-sse2", .cra_priority = 400, .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \| CRYPTO_ALG_ASYNC, .cra_blocksize = SERPENT_BLOCK_SIZE, .cra_ctxsize = sizeof(struct async_helper_ctx), .cra_alignmask = 0, .cra_type = &crypto_ablkcipher_type, .cra_module = THIS_MODULE, .cra_init = ablk_init, .cra_exit = ablk_exit, .cra_u = { .ablkcipher = { .min_keysize = SERPENT_MIN_KEY_SIZE + SERPENT_BLOCK_SIZE, .max_keysize = SERPENT_MAX_KEY_SIZE + SERPENT_BLOCK_SIZE, .ivsize = SERPENT_BLOCK_SIZE, .setkey = ablk_set_key, .encrypt = ablk_encrypt, .decrypt = ablk_decrypt, }, }, }, { .cra_name = "xts(serpent)", .cra_driver_name = "xts-serpent-sse2", .cra_priority = 400, .cra_flags = CRYPTO_ALG_TYPE_ABLKCIPHER \| CRYPTO_ALG_ASYNC, .cra_blocksize = SERPENT_BLOCK_SIZE, .cra_ctxsize = sizeof(struct async_helper_ctx), .cra_alignmask = 0, .cra_type = &crypto_ablkcipher_type, .cra_module = THIS_MODULE, .cra_init = ablk_init, .cra_exit = ablk_exit, .cra_u = { .ablkcipher = { .min_keysize = SERPENT_MIN_KEY_SIZE * 2, .max_keysize = SERPENT_MAX_KEY_SIZE * 2, .ivsize = SERPENT_BLOCK_SIZE, .setkey = ablk_set_key, .encrypt = ablk_encrypt, .decrypt = ablk_decrypt, }, }, } }; static int __init serpent_sse2_init(void) { if (!cpu_has_xmm2) { printk(KERN_INFO "SSE2 instructions are not detected.\n"); return -ENODEV; } return crypto_register_algs(serpent_algs, ARRAY_SIZE(serpent_algs)); } static void __exit serpent_sse2_exit(void) { crypto_unregister_algs(serpent_algs, ARRAY_SIZE(serpent_algs)); } module_init(serpent_sse2_init); module_exit(serpent_sse2_exit); MODULE_DESCRIPTION("Serpent Cipher Algorithm, SSE2 optimized"); MODULE_LICENSE("GPL"); MODULE_ALIAS_CRYPTO("serpent");	./CrossVul/dataset_final_sorted/CWE-264/c/good_5861_37
crossvul-cpp_data_good_2399_21	/* * Copyright (C)2006 USAGI/WIDE Project * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * * Author: * Kazunori Miyazawa <miyazawa@linux-ipv6.org> / #include <crypto/internal/hash.h> #include <linux/err.h> #include <linux/kernel.h> #include <linux/module.h> static u_int32_t ks[12] = {0x01010101, 0x01010101, 0x01010101, 0x01010101, 0x02020202, 0x02020202, 0x02020202, 0x02020202, 0x03030303, 0x03030303, 0x03030303, 0x03030303}; / * +------------------------ * \| <parent tfm> * +------------------------ * \| xcbc_tfm_ctx * +------------------------ * \| consts (block size * 2) * +------------------------ / struct xcbc_tfm_ctx { struct crypto_cipher child; u8 ctx[]; }; /* * +------------------------ * \| <shash desc> * +------------------------ * \| xcbc_desc_ctx * +------------------------ * \| odds (block size) * +------------------------ * \| prev (block size) * +------------------------ / struct xcbc_desc_ctx { unsigned int len; u8 ctx[]; }; static int crypto_xcbc_digest_setkey(struct crypto_shash parent, const u8 inkey, unsigned int keylen) { unsigned long alignmask = crypto_shash_alignmask(parent); struct xcbc_tfm_ctx ctx = crypto_shash_ctx(parent); int bs = crypto_shash_blocksize(parent); u8 consts = PTR_ALIGN(&ctx->ctx[0], alignmask + 1); int err = 0; u8 key1[bs]; if ((err = crypto_cipher_setkey(ctx->child, inkey, keylen))) return err; crypto_cipher_encrypt_one(ctx->child, consts, (u8 )ks + bs); crypto_cipher_encrypt_one(ctx->child, consts + bs, (u8 )ks + bs 2); crypto_cipher_encrypt_one(ctx->child, key1, (u8 )ks); return crypto_cipher_setkey(ctx->child, key1, bs); } static int crypto_xcbc_digest_init(struct shash_desc pdesc) { unsigned long alignmask = crypto_shash_alignmask(pdesc->tfm); struct xcbc_desc_ctx ctx = shash_desc_ctx(pdesc); int bs = crypto_shash_blocksize(pdesc->tfm); u8 prev = PTR_ALIGN(&ctx->ctx[0], alignmask + 1) + bs; ctx->len = 0; memset(prev, 0, bs); return 0; } static int crypto_xcbc_digest_update(struct shash_desc pdesc, const u8 p, unsigned int len) { struct crypto_shash parent = pdesc->tfm; unsigned long alignmask = crypto_shash_alignmask(parent); struct xcbc_tfm_ctx tctx = crypto_shash_ctx(parent); struct xcbc_desc_ctx ctx = shash_desc_ctx(pdesc); struct crypto_cipher tfm = tctx->child; int bs = crypto_shash_blocksize(parent); u8 odds = PTR_ALIGN(&ctx->ctx[0], alignmask + 1); u8 prev = odds + bs; /* checking the data can fill the block / if ((ctx->len + len) <= bs) { memcpy(odds + ctx->len, p, len); ctx->len += len; return 0; } / filling odds with new data and encrypting it / memcpy(odds + ctx->len, p, bs - ctx->len); len -= bs - ctx->len; p += bs - ctx->len; crypto_xor(prev, odds, bs); crypto_cipher_encrypt_one(tfm, prev, prev); / clearing the length / ctx->len = 0; / encrypting the rest of data / while (len > bs) { crypto_xor(prev, p, bs); crypto_cipher_encrypt_one(tfm, prev, prev); p += bs; len -= bs; } / keeping the surplus of blocksize / if (len) { memcpy(odds, p, len); ctx->len = len; } return 0; } static int crypto_xcbc_digest_final(struct shash_desc pdesc, u8 out) { struct crypto_shash parent = pdesc->tfm; unsigned long alignmask = crypto_shash_alignmask(parent); struct xcbc_tfm_ctx tctx = crypto_shash_ctx(parent); struct xcbc_desc_ctx ctx = shash_desc_ctx(pdesc); struct crypto_cipher tfm = tctx->child; int bs = crypto_shash_blocksize(parent); u8 consts = PTR_ALIGN(&tctx->ctx[0], alignmask + 1); u8 odds = PTR_ALIGN(&ctx->ctx[0], alignmask + 1); u8 prev = odds + bs; unsigned int offset = 0; if (ctx->len != bs) { unsigned int rlen; u8 p = odds + ctx->len; p = 0x80; p++; rlen = bs - ctx->len -1; if (rlen) memset(p, 0, rlen); offset += bs; } crypto_xor(prev, odds, bs); crypto_xor(prev, consts + offset, bs); crypto_cipher_encrypt_one(tfm, out, prev); return 0; } static int xcbc_init_tfm(struct crypto_tfm tfm) { struct crypto_cipher cipher; struct crypto_instance inst = (void )tfm->__crt_alg; struct crypto_spawn spawn = crypto_instance_ctx(inst); struct xcbc_tfm_ctx ctx = crypto_tfm_ctx(tfm); cipher = crypto_spawn_cipher(spawn); if (IS_ERR(cipher)) return PTR_ERR(cipher); ctx->child = cipher; return 0; }; static void xcbc_exit_tfm(struct crypto_tfm tfm) { struct xcbc_tfm_ctx ctx = crypto_tfm_ctx(tfm); crypto_free_cipher(ctx->child); } static int xcbc_create(struct crypto_template tmpl, struct rtattr tb) { struct shash_instance inst; struct crypto_alg alg; unsigned long alignmask; int err; err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_SHASH); if (err) return err; alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER, CRYPTO_ALG_TYPE_MASK); if (IS_ERR(alg)) return PTR_ERR(alg); switch(alg->cra_blocksize) { case 16: break; default: goto out_put_alg; } inst = shash_alloc_instance("xcbc", alg); err = PTR_ERR(inst); if (IS_ERR(inst)) goto out_put_alg; err = crypto_init_spawn(shash_instance_ctx(inst), alg, shash_crypto_instance(inst), CRYPTO_ALG_TYPE_MASK); if (err) goto out_free_inst; alignmask = alg->cra_alignmask \| 3; inst->alg.base.cra_alignmask = alignmask; inst->alg.base.cra_priority = alg->cra_priority; inst->alg.base.cra_blocksize = alg->cra_blocksize; inst->alg.digestsize = alg->cra_blocksize; inst->alg.descsize = ALIGN(sizeof(struct xcbc_desc_ctx), crypto_tfm_ctx_alignment()) + (alignmask & ~(crypto_tfm_ctx_alignment() - 1)) + alg->cra_blocksize 2; inst->alg.base.cra_ctxsize = ALIGN(sizeof(struct xcbc_tfm_ctx), alignmask + 1) + alg->cra_blocksize * 2; inst->alg.base.cra_init = xcbc_init_tfm; inst->alg.base.cra_exit = xcbc_exit_tfm; inst->alg.init = crypto_xcbc_digest_init; inst->alg.update = crypto_xcbc_digest_update; inst->alg.final = crypto_xcbc_digest_final; inst->alg.setkey = crypto_xcbc_digest_setkey; err = shash_register_instance(tmpl, inst); if (err) { out_free_inst: shash_free_instance(shash_crypto_instance(inst)); } out_put_alg: crypto_mod_put(alg); return err; } static struct crypto_template crypto_xcbc_tmpl = { .name = "xcbc", .create = xcbc_create, .free = shash_free_instance, .module = THIS_MODULE, }; static int __init crypto_xcbc_module_init(void) { return crypto_register_template(&crypto_xcbc_tmpl); } static void __exit crypto_xcbc_module_exit(void) { crypto_unregister_template(&crypto_xcbc_tmpl); } module_init(crypto_xcbc_module_init); module_exit(crypto_xcbc_module_exit); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("XCBC keyed hash algorithm"); MODULE_ALIAS_CRYPTO("xcbc");	./CrossVul/dataset_final_sorted/CWE-264/c/good_2399_21
crossvul-cpp_data_bad_1787_0	/* * Copyright (C) 2010 IBM Corporation * Copyright (C) 2010 Politecnico di Torino, Italy * TORSEC group -- http://security.polito.it * * Authors: * Mimi Zohar <zohar@us.ibm.com> * Roberto Sassu <roberto.sassu@polito.it> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, version 2 of the License. * * See Documentation/security/keys-trusted-encrypted.txt / #include <linux/uaccess.h> #include <linux/module.h> #include <linux/init.h> #include <linux/slab.h> #include <linux/parser.h> #include <linux/string.h> #include <linux/err.h> #include <keys/user-type.h> #include <keys/trusted-type.h> #include <keys/encrypted-type.h> #include <linux/key-type.h> #include <linux/random.h> #include <linux/rcupdate.h> #include <linux/scatterlist.h> #include <linux/crypto.h> #include <linux/ctype.h> #include <crypto/hash.h> #include <crypto/sha.h> #include <crypto/aes.h> #include "encrypted.h" #include "ecryptfs_format.h" static const char KEY_TRUSTED_PREFIX[] = "trusted:"; static const char KEY_USER_PREFIX[] = "user:"; static const char hash_alg[] = "sha256"; static const char hmac_alg[] = "hmac(sha256)"; static const char blkcipher_alg[] = "cbc(aes)"; static const char key_format_default[] = "default"; static const char key_format_ecryptfs[] = "ecryptfs"; static unsigned int ivsize; static int blksize; #define KEY_TRUSTED_PREFIX_LEN (sizeof (KEY_TRUSTED_PREFIX) - 1) #define KEY_USER_PREFIX_LEN (sizeof (KEY_USER_PREFIX) - 1) #define KEY_ECRYPTFS_DESC_LEN 16 #define HASH_SIZE SHA256_DIGEST_SIZE #define MAX_DATA_SIZE 4096 #define MIN_DATA_SIZE 20 struct sdesc { struct shash_desc shash; char ctx[]; }; static struct crypto_shash hashalg; static struct crypto_shash hmacalg; enum { Opt_err = -1, Opt_new, Opt_load, Opt_update }; enum { Opt_error = -1, Opt_default, Opt_ecryptfs }; static const match_table_t key_format_tokens = { {Opt_default, "default"}, {Opt_ecryptfs, "ecryptfs"}, {Opt_error, NULL} }; static const match_table_t key_tokens = { {Opt_new, "new"}, {Opt_load, "load"}, {Opt_update, "update"}, {Opt_err, NULL} }; static int aes_get_sizes(void) { struct crypto_blkcipher tfm; tfm = crypto_alloc_blkcipher(blkcipher_alg, 0, CRYPTO_ALG_ASYNC); if (IS_ERR(tfm)) { pr_err("encrypted_key: failed to alloc_cipher (%ld)\n", PTR_ERR(tfm)); return PTR_ERR(tfm); } ivsize = crypto_blkcipher_ivsize(tfm); blksize = crypto_blkcipher_blocksize(tfm); crypto_free_blkcipher(tfm); return 0; } /* * valid_ecryptfs_desc - verify the description of a new/loaded encrypted key * * The description of a encrypted key with format 'ecryptfs' must contain * exactly 16 hexadecimal characters. * / static int valid_ecryptfs_desc(const char ecryptfs_desc) { int i; if (strlen(ecryptfs_desc) != KEY_ECRYPTFS_DESC_LEN) { pr_err("encrypted_key: key description must be %d hexadecimal " "characters long\n", KEY_ECRYPTFS_DESC_LEN); return -EINVAL; } for (i = 0; i < KEY_ECRYPTFS_DESC_LEN; i++) { if (!isxdigit(ecryptfs_desc[i])) { pr_err("encrypted_key: key description must contain " "only hexadecimal characters\n"); return -EINVAL; } } return 0; } /* * valid_master_desc - verify the 'key-type:desc' of a new/updated master-key * * key-type:= "trusted:" \| "user:" * desc:= master-key description * * Verify that 'key-type' is valid and that 'desc' exists. On key update, * only the master key description is permitted to change, not the key-type. * The key-type remains constant. * * On success returns 0, otherwise -EINVAL. / static int valid_master_desc(const char new_desc, const char orig_desc) { if (!memcmp(new_desc, KEY_TRUSTED_PREFIX, KEY_TRUSTED_PREFIX_LEN)) { if (strlen(new_desc) == KEY_TRUSTED_PREFIX_LEN) goto out; if (orig_desc) if (memcmp(new_desc, orig_desc, KEY_TRUSTED_PREFIX_LEN)) goto out; } else if (!memcmp(new_desc, KEY_USER_PREFIX, KEY_USER_PREFIX_LEN)) { if (strlen(new_desc) == KEY_USER_PREFIX_LEN) goto out; if (orig_desc) if (memcmp(new_desc, orig_desc, KEY_USER_PREFIX_LEN)) goto out; } else goto out; return 0; out: return -EINVAL; } / * datablob_parse - parse the keyctl data * * datablob format: * new [<format>] <master-key name> <decrypted data length> * load [<format>] <master-key name> <decrypted data length> * <encrypted iv + data> * update <new-master-key name> * * Tokenizes a copy of the keyctl data, returning a pointer to each token, * which is null terminated. * * On success returns 0, otherwise -EINVAL. / static int datablob_parse(char datablob, const char format, char master_desc, char decrypted_datalen, char hex_encoded_iv) { substring_t args[MAX_OPT_ARGS]; int ret = -EINVAL; int key_cmd; int key_format; char p, keyword; keyword = strsep(&datablob, " \t"); if (!keyword) { pr_info("encrypted_key: insufficient parameters specified\n"); return ret; } key_cmd = match_token(keyword, key_tokens, args); /* Get optional format: default \| ecryptfs / p = strsep(&datablob, " \t"); if (!p) { pr_err("encrypted_key: insufficient parameters specified\n"); return ret; } key_format = match_token(p, key_format_tokens, args); switch (key_format) { case Opt_ecryptfs: case Opt_default: format = p; master_desc = strsep(&datablob, " \t"); break; case Opt_error: master_desc = p; break; } if (!master_desc) { pr_info("encrypted_key: master key parameter is missing\n"); goto out; } if (valid_master_desc(master_desc, NULL) < 0) { pr_info("encrypted_key: master key parameter \'%s\' " "is invalid\n", master_desc); goto out; } if (decrypted_datalen) { decrypted_datalen = strsep(&datablob, " \t"); if (!decrypted_datalen) { pr_info("encrypted_key: keylen parameter is missing\n"); goto out; } } switch (key_cmd) { case Opt_new: if (!decrypted_datalen) { pr_info("encrypted_key: keyword \'%s\' not allowed " "when called from .update method\n", keyword); break; } ret = 0; break; case Opt_load: if (!decrypted_datalen) { pr_info("encrypted_key: keyword \'%s\' not allowed " "when called from .update method\n", keyword); break; } hex_encoded_iv = strsep(&datablob, " \t"); if (!hex_encoded_iv) { pr_info("encrypted_key: hex blob is missing\n"); break; } ret = 0; break; case Opt_update: if (decrypted_datalen) { pr_info("encrypted_key: keyword \'%s\' not allowed " "when called from .instantiate method\n", keyword); break; } ret = 0; break; case Opt_err: pr_info("encrypted_key: keyword \'%s\' not recognized\n", keyword); break; } out: return ret; } / * datablob_format - format as an ascii string, before copying to userspace / static char datablob_format(struct encrypted_key_payload epayload, size_t asciiblob_len) { char ascii_buf, bufp; u8 iv = epayload->iv; int len; int i; ascii_buf = kmalloc(asciiblob_len + 1, GFP_KERNEL); if (!ascii_buf) goto out; ascii_buf[asciiblob_len] = '\0'; /* copy datablob master_desc and datalen strings / len = sprintf(ascii_buf, "%s %s %s ", epayload->format, epayload->master_desc, epayload->datalen); / convert the hex encoded iv, encrypted-data and HMAC to ascii / bufp = &ascii_buf[len]; for (i = 0; i < (asciiblob_len - len) / 2; i++) bufp = hex_byte_pack(bufp, iv[i]); out: return ascii_buf; } / * request_user_key - request the user key * * Use a user provided key to encrypt/decrypt an encrypted-key. / static struct key request_user_key(const char master_desc, const u8 master_key, size_t master_keylen) { const struct user_key_payload upayload; struct key ukey; ukey = request_key(&key_type_user, master_desc, NULL); if (IS_ERR(ukey)) goto error; down_read(&ukey->sem); upayload = user_key_payload(ukey); master_key = upayload->data; master_keylen = upayload->datalen; error: return ukey; } static struct sdesc alloc_sdesc(struct crypto_shash alg) { struct sdesc sdesc; int size; size = sizeof(struct shash_desc) + crypto_shash_descsize(alg); sdesc = kmalloc(size, GFP_KERNEL); if (!sdesc) return ERR_PTR(-ENOMEM); sdesc->shash.tfm = alg; sdesc->shash.flags = 0x0; return sdesc; } static int calc_hmac(u8 digest, const u8 key, unsigned int keylen, const u8 buf, unsigned int buflen) { struct sdesc sdesc; int ret; sdesc = alloc_sdesc(hmacalg); if (IS_ERR(sdesc)) { pr_info("encrypted_key: can't alloc %s\n", hmac_alg); return PTR_ERR(sdesc); } ret = crypto_shash_setkey(hmacalg, key, keylen); if (!ret) ret = crypto_shash_digest(&sdesc->shash, buf, buflen, digest); kfree(sdesc); return ret; } static int calc_hash(u8 digest, const u8 buf, unsigned int buflen) { struct sdesc sdesc; int ret; sdesc = alloc_sdesc(hashalg); if (IS_ERR(sdesc)) { pr_info("encrypted_key: can't alloc %s\n", hash_alg); return PTR_ERR(sdesc); } ret = crypto_shash_digest(&sdesc->shash, buf, buflen, digest); kfree(sdesc); return ret; } enum derived_key_type { ENC_KEY, AUTH_KEY }; /* Derive authentication/encryption key from trusted key / static int get_derived_key(u8 derived_key, enum derived_key_type key_type, const u8 master_key, size_t master_keylen) { u8 derived_buf; unsigned int derived_buf_len; int ret; derived_buf_len = strlen("AUTH_KEY") + 1 + master_keylen; if (derived_buf_len < HASH_SIZE) derived_buf_len = HASH_SIZE; derived_buf = kzalloc(derived_buf_len, GFP_KERNEL); if (!derived_buf) { pr_err("encrypted_key: out of memory\n"); return -ENOMEM; } if (key_type) strcpy(derived_buf, "AUTH_KEY"); else strcpy(derived_buf, "ENC_KEY"); memcpy(derived_buf + strlen(derived_buf) + 1, master_key, master_keylen); ret = calc_hash(derived_key, derived_buf, derived_buf_len); kfree(derived_buf); return ret; } static int init_blkcipher_desc(struct blkcipher_desc desc, const u8 key, unsigned int key_len, const u8 iv, unsigned int ivsize) { int ret; desc->tfm = crypto_alloc_blkcipher(blkcipher_alg, 0, CRYPTO_ALG_ASYNC); if (IS_ERR(desc->tfm)) { pr_err("encrypted_key: failed to load %s transform (%ld)\n", blkcipher_alg, PTR_ERR(desc->tfm)); return PTR_ERR(desc->tfm); } desc->flags = 0; ret = crypto_blkcipher_setkey(desc->tfm, key, key_len); if (ret < 0) { pr_err("encrypted_key: failed to setkey (%d)\n", ret); crypto_free_blkcipher(desc->tfm); return ret; } crypto_blkcipher_set_iv(desc->tfm, iv, ivsize); return 0; } static struct key request_master_key(struct encrypted_key_payload epayload, const u8 master_key, size_t master_keylen) { struct key mkey = NULL; if (!strncmp(epayload->master_desc, KEY_TRUSTED_PREFIX, KEY_TRUSTED_PREFIX_LEN)) { mkey = request_trusted_key(epayload->master_desc + KEY_TRUSTED_PREFIX_LEN, master_key, master_keylen); } else if (!strncmp(epayload->master_desc, KEY_USER_PREFIX, KEY_USER_PREFIX_LEN)) { mkey = request_user_key(epayload->master_desc + KEY_USER_PREFIX_LEN, master_key, master_keylen); } else goto out; if (IS_ERR(mkey)) { int ret = PTR_ERR(mkey); if (ret == -ENOTSUPP) pr_info("encrypted_key: key %s not supported", epayload->master_desc); else pr_info("encrypted_key: key %s not found", epayload->master_desc); goto out; } dump_master_key(master_key, master_keylen); out: return mkey; } / Before returning data to userspace, encrypt decrypted data. / static int derived_key_encrypt(struct encrypted_key_payload epayload, const u8 derived_key, unsigned int derived_keylen) { struct scatterlist sg_in[2]; struct scatterlist sg_out[1]; struct blkcipher_desc desc; unsigned int encrypted_datalen; unsigned int padlen; char pad[16]; int ret; encrypted_datalen = roundup(epayload->decrypted_datalen, blksize); padlen = encrypted_datalen - epayload->decrypted_datalen; ret = init_blkcipher_desc(&desc, derived_key, derived_keylen, epayload->iv, ivsize); if (ret < 0) goto out; dump_decrypted_data(epayload); memset(pad, 0, sizeof pad); sg_init_table(sg_in, 2); sg_set_buf(&sg_in[0], epayload->decrypted_data, epayload->decrypted_datalen); sg_set_buf(&sg_in[1], pad, padlen); sg_init_table(sg_out, 1); sg_set_buf(sg_out, epayload->encrypted_data, encrypted_datalen); ret = crypto_blkcipher_encrypt(&desc, sg_out, sg_in, encrypted_datalen); crypto_free_blkcipher(desc.tfm); if (ret < 0) pr_err("encrypted_key: failed to encrypt (%d)\n", ret); else dump_encrypted_data(epayload, encrypted_datalen); out: return ret; } static int datablob_hmac_append(struct encrypted_key_payload epayload, const u8 master_key, size_t master_keylen) { u8 derived_key[HASH_SIZE]; u8 digest; int ret; ret = get_derived_key(derived_key, AUTH_KEY, master_key, master_keylen); if (ret < 0) goto out; digest = epayload->format + epayload->datablob_len; ret = calc_hmac(digest, derived_key, sizeof derived_key, epayload->format, epayload->datablob_len); if (!ret) dump_hmac(NULL, digest, HASH_SIZE); out: return ret; } /* verify HMAC before decrypting encrypted key / static int datablob_hmac_verify(struct encrypted_key_payload epayload, const u8 format, const u8 master_key, size_t master_keylen) { u8 derived_key[HASH_SIZE]; u8 digest[HASH_SIZE]; int ret; char p; unsigned short len; ret = get_derived_key(derived_key, AUTH_KEY, master_key, master_keylen); if (ret < 0) goto out; len = epayload->datablob_len; if (!format) { p = epayload->master_desc; len -= strlen(epayload->format) + 1; } else p = epayload->format; ret = calc_hmac(digest, derived_key, sizeof derived_key, p, len); if (ret < 0) goto out; ret = memcmp(digest, epayload->format + epayload->datablob_len, sizeof digest); if (ret) { ret = -EINVAL; dump_hmac("datablob", epayload->format + epayload->datablob_len, HASH_SIZE); dump_hmac("calc", digest, HASH_SIZE); } out: return ret; } static int derived_key_decrypt(struct encrypted_key_payload epayload, const u8 derived_key, unsigned int derived_keylen) { struct scatterlist sg_in[1]; struct scatterlist sg_out[2]; struct blkcipher_desc desc; unsigned int encrypted_datalen; char pad[16]; int ret; encrypted_datalen = roundup(epayload->decrypted_datalen, blksize); ret = init_blkcipher_desc(&desc, derived_key, derived_keylen, epayload->iv, ivsize); if (ret < 0) goto out; dump_encrypted_data(epayload, encrypted_datalen); memset(pad, 0, sizeof pad); sg_init_table(sg_in, 1); sg_init_table(sg_out, 2); sg_set_buf(sg_in, epayload->encrypted_data, encrypted_datalen); sg_set_buf(&sg_out[0], epayload->decrypted_data, epayload->decrypted_datalen); sg_set_buf(&sg_out[1], pad, sizeof pad); ret = crypto_blkcipher_decrypt(&desc, sg_out, sg_in, encrypted_datalen); crypto_free_blkcipher(desc.tfm); if (ret < 0) goto out; dump_decrypted_data(epayload); out: return ret; } / Allocate memory for decrypted key and datablob. / static struct encrypted_key_payload encrypted_key_alloc(struct key key, const char format, const char master_desc, const char datalen) { struct encrypted_key_payload epayload = NULL; unsigned short datablob_len; unsigned short decrypted_datalen; unsigned short payload_datalen; unsigned int encrypted_datalen; unsigned int format_len; long dlen; int ret; ret = kstrtol(datalen, 10, &dlen); if (ret < 0 \|\| dlen < MIN_DATA_SIZE \|\| dlen > MAX_DATA_SIZE) return ERR_PTR(-EINVAL); format_len = (!format) ? strlen(key_format_default) : strlen(format); decrypted_datalen = dlen; payload_datalen = decrypted_datalen; if (format && !strcmp(format, key_format_ecryptfs)) { if (dlen != ECRYPTFS_MAX_KEY_BYTES) { pr_err("encrypted_key: keylen for the ecryptfs format " "must be equal to %d bytes\n", ECRYPTFS_MAX_KEY_BYTES); return ERR_PTR(-EINVAL); } decrypted_datalen = ECRYPTFS_MAX_KEY_BYTES; payload_datalen = sizeof(struct ecryptfs_auth_tok); } encrypted_datalen = roundup(decrypted_datalen, blksize); datablob_len = format_len + 1 + strlen(master_desc) + 1 + strlen(datalen) + 1 + ivsize + 1 + encrypted_datalen; ret = key_payload_reserve(key, payload_datalen + datablob_len + HASH_SIZE + 1); if (ret < 0) return ERR_PTR(ret); epayload = kzalloc(sizeof(epayload) + payload_datalen + datablob_len + HASH_SIZE + 1, GFP_KERNEL); if (!epayload) return ERR_PTR(-ENOMEM); epayload->payload_datalen = payload_datalen; epayload->decrypted_datalen = decrypted_datalen; epayload->datablob_len = datablob_len; return epayload; } static int encrypted_key_decrypt(struct encrypted_key_payload epayload, const char format, const char hex_encoded_iv) { struct key mkey; u8 derived_key[HASH_SIZE]; const u8 master_key; u8 hmac; const char hex_encoded_data; unsigned int encrypted_datalen; size_t master_keylen; size_t asciilen; int ret; encrypted_datalen = roundup(epayload->decrypted_datalen, blksize); asciilen = (ivsize + 1 + encrypted_datalen + HASH_SIZE) 2; if (strlen(hex_encoded_iv) != asciilen) return -EINVAL; hex_encoded_data = hex_encoded_iv + (2 * ivsize) + 2; ret = hex2bin(epayload->iv, hex_encoded_iv, ivsize); if (ret < 0) return -EINVAL; ret = hex2bin(epayload->encrypted_data, hex_encoded_data, encrypted_datalen); if (ret < 0) return -EINVAL; hmac = epayload->format + epayload->datablob_len; ret = hex2bin(hmac, hex_encoded_data + (encrypted_datalen * 2), HASH_SIZE); if (ret < 0) return -EINVAL; mkey = request_master_key(epayload, &master_key, &master_keylen); if (IS_ERR(mkey)) return PTR_ERR(mkey); ret = datablob_hmac_verify(epayload, format, master_key, master_keylen); if (ret < 0) { pr_err("encrypted_key: bad hmac (%d)\n", ret); goto out; } ret = get_derived_key(derived_key, ENC_KEY, master_key, master_keylen); if (ret < 0) goto out; ret = derived_key_decrypt(epayload, derived_key, sizeof derived_key); if (ret < 0) pr_err("encrypted_key: failed to decrypt key (%d)\n", ret); out: up_read(&mkey->sem); key_put(mkey); return ret; } static void __ekey_init(struct encrypted_key_payload epayload, const char format, const char master_desc, const char datalen) { unsigned int format_len; format_len = (!format) ? strlen(key_format_default) : strlen(format); epayload->format = epayload->payload_data + epayload->payload_datalen; epayload->master_desc = epayload->format + format_len + 1; epayload->datalen = epayload->master_desc + strlen(master_desc) + 1; epayload->iv = epayload->datalen + strlen(datalen) + 1; epayload->encrypted_data = epayload->iv + ivsize + 1; epayload->decrypted_data = epayload->payload_data; if (!format) memcpy(epayload->format, key_format_default, format_len); else { if (!strcmp(format, key_format_ecryptfs)) epayload->decrypted_data = ecryptfs_get_auth_tok_key((struct ecryptfs_auth_tok )epayload->payload_data); memcpy(epayload->format, format, format_len); } memcpy(epayload->master_desc, master_desc, strlen(master_desc)); memcpy(epayload->datalen, datalen, strlen(datalen)); } / * encrypted_init - initialize an encrypted key * * For a new key, use a random number for both the iv and data * itself. For an old key, decrypt the hex encoded data. / static int encrypted_init(struct encrypted_key_payload epayload, const char key_desc, const char format, const char master_desc, const char datalen, const char hex_encoded_iv) { int ret = 0; if (format && !strcmp(format, key_format_ecryptfs)) { ret = valid_ecryptfs_desc(key_desc); if (ret < 0) return ret; ecryptfs_fill_auth_tok((struct ecryptfs_auth_tok )epayload->payload_data, key_desc); } __ekey_init(epayload, format, master_desc, datalen); if (!hex_encoded_iv) { get_random_bytes(epayload->iv, ivsize); get_random_bytes(epayload->decrypted_data, epayload->decrypted_datalen); } else ret = encrypted_key_decrypt(epayload, format, hex_encoded_iv); return ret; } /* * encrypted_instantiate - instantiate an encrypted key * * Decrypt an existing encrypted datablob or create a new encrypted key * based on a kernel random number. * * On success, return 0. Otherwise return errno. / static int encrypted_instantiate(struct key key, struct key_preparsed_payload prep) { struct encrypted_key_payload epayload = NULL; char datablob = NULL; const char format = NULL; char master_desc = NULL; char decrypted_datalen = NULL; char hex_encoded_iv = NULL; size_t datalen = prep->datalen; int ret; if (datalen <= 0 \|\| datalen > 32767 \|\| !prep->data) return -EINVAL; datablob = kmalloc(datalen + 1, GFP_KERNEL); if (!datablob) return -ENOMEM; datablob[datalen] = 0; memcpy(datablob, prep->data, datalen); ret = datablob_parse(datablob, &format, &master_desc, &decrypted_datalen, &hex_encoded_iv); if (ret < 0) goto out; epayload = encrypted_key_alloc(key, format, master_desc, decrypted_datalen); if (IS_ERR(epayload)) { ret = PTR_ERR(epayload); goto out; } ret = encrypted_init(epayload, key->description, format, master_desc, decrypted_datalen, hex_encoded_iv); if (ret < 0) { kfree(epayload); goto out; } rcu_assign_keypointer(key, epayload); out: kfree(datablob); return ret; } static void encrypted_rcu_free(struct rcu_head rcu) { struct encrypted_key_payload epayload; epayload = container_of(rcu, struct encrypted_key_payload, rcu); memset(epayload->decrypted_data, 0, epayload->decrypted_datalen); kfree(epayload); } / * encrypted_update - update the master key description * * Change the master key description for an existing encrypted key. * The next read will return an encrypted datablob using the new * master key description. * * On success, return 0. Otherwise return errno. / static int encrypted_update(struct key key, struct key_preparsed_payload prep) { struct encrypted_key_payload epayload = key->payload.data[0]; struct encrypted_key_payload new_epayload; char buf; char new_master_desc = NULL; const char format = NULL; size_t datalen = prep->datalen; int ret = 0; if (datalen <= 0 \|\| datalen > 32767 \|\| !prep->data) return -EINVAL; buf = kmalloc(datalen + 1, GFP_KERNEL); if (!buf) return -ENOMEM; buf[datalen] = 0; memcpy(buf, prep->data, datalen); ret = datablob_parse(buf, &format, &new_master_desc, NULL, NULL); if (ret < 0) goto out; ret = valid_master_desc(new_master_desc, epayload->master_desc); if (ret < 0) goto out; new_epayload = encrypted_key_alloc(key, epayload->format, new_master_desc, epayload->datalen); if (IS_ERR(new_epayload)) { ret = PTR_ERR(new_epayload); goto out; } __ekey_init(new_epayload, epayload->format, new_master_desc, epayload->datalen); memcpy(new_epayload->iv, epayload->iv, ivsize); memcpy(new_epayload->payload_data, epayload->payload_data, epayload->payload_datalen); rcu_assign_keypointer(key, new_epayload); call_rcu(&epayload->rcu, encrypted_rcu_free); out: kfree(buf); return ret; } /* * encrypted_read - format and copy the encrypted data to userspace * * The resulting datablob format is: * <master-key name> <decrypted data length> <encrypted iv> <encrypted data> * * On success, return to userspace the encrypted key datablob size. / static long encrypted_read(const struct key key, char __user buffer, size_t buflen) { struct encrypted_key_payload epayload; struct key mkey; const u8 master_key; size_t master_keylen; char derived_key[HASH_SIZE]; char ascii_buf; size_t asciiblob_len; int ret; epayload = rcu_dereference_key(key); / returns the hex encoded iv, encrypted-data, and hmac as ascii / asciiblob_len = epayload->datablob_len + ivsize + 1 + roundup(epayload->decrypted_datalen, blksize) + (HASH_SIZE 2); if (!buffer \|\| buflen < asciiblob_len) return asciiblob_len; mkey = request_master_key(epayload, &master_key, &master_keylen); if (IS_ERR(mkey)) return PTR_ERR(mkey); ret = get_derived_key(derived_key, ENC_KEY, master_key, master_keylen); if (ret < 0) goto out; ret = derived_key_encrypt(epayload, derived_key, sizeof derived_key); if (ret < 0) goto out; ret = datablob_hmac_append(epayload, master_key, master_keylen); if (ret < 0) goto out; ascii_buf = datablob_format(epayload, asciiblob_len); if (!ascii_buf) { ret = -ENOMEM; goto out; } up_read(&mkey->sem); key_put(mkey); if (copy_to_user(buffer, ascii_buf, asciiblob_len) != 0) ret = -EFAULT; kfree(ascii_buf); return asciiblob_len; out: up_read(&mkey->sem); key_put(mkey); return ret; } /* * encrypted_destroy - before freeing the key, clear the decrypted data * * Before freeing the key, clear the memory containing the decrypted * key data. / static void encrypted_destroy(struct key key) { struct encrypted_key_payload *epayload = key->payload.data[0]; if (!epayload) return; memset(epayload->decrypted_data, 0, epayload->decrypted_datalen); kfree(key->payload.data[0]); } struct key_type key_type_encrypted = { .name = "encrypted", .instantiate = encrypted_instantiate, .update = encrypted_update, .destroy = encrypted_destroy, .describe = user_describe, .read = encrypted_read, }; EXPORT_SYMBOL_GPL(key_type_encrypted); static void encrypted_shash_release(void) { if (hashalg) crypto_free_shash(hashalg); if (hmacalg) crypto_free_shash(hmacalg); } static int __init encrypted_shash_alloc(void) { int ret; hmacalg = crypto_alloc_shash(hmac_alg, 0, CRYPTO_ALG_ASYNC); if (IS_ERR(hmacalg)) { pr_info("encrypted_key: could not allocate crypto %s\n", hmac_alg); return PTR_ERR(hmacalg); } hashalg = crypto_alloc_shash(hash_alg, 0, CRYPTO_ALG_ASYNC); if (IS_ERR(hashalg)) { pr_info("encrypted_key: could not allocate crypto %s\n", hash_alg); ret = PTR_ERR(hashalg); goto hashalg_fail; } return 0; hashalg_fail: crypto_free_shash(hmacalg); return ret; } static int __init init_encrypted(void) { int ret; ret = encrypted_shash_alloc(); if (ret < 0) return ret; ret = aes_get_sizes(); if (ret < 0) goto out; ret = register_key_type(&key_type_encrypted); if (ret < 0) goto out; return 0; out: encrypted_shash_release(); return ret; } static void __exit cleanup_encrypted(void) { encrypted_shash_release(); unregister_key_type(&key_type_encrypted); } late_initcall(init_encrypted); module_exit(cleanup_encrypted); MODULE_LICENSE("GPL");	./CrossVul/dataset_final_sorted/CWE-264/c/bad_1787_0
crossvul-cpp_data_good_5655_0	/* -- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -- / / Monkey HTTP Server * ================== * Copyright 2001-2014 Monkey Software LLC <eduardo@monkey.io> * Copyright 2012, Sonny Karlsson * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. / #include <stdio.h> #include <string.h> #include <sys/stat.h> #include <unistd.h> / network / #include <sys/socket.h> #include <netinet/in.h> #include <arpa/inet.h> / Monkey API / #include "MKPlugin.h" #include "mandril.h" MONKEY_PLUGIN("mandril", / shortname / "Mandril", / name / VERSION, / version / MK_PLUGIN_STAGE_10 \| MK_PLUGIN_STAGE_30); / hooks / static struct mk_config conf; /* Read database configuration parameters / static int mk_security_conf(char confdir) { int n; int ret = 0; unsigned long len; char conf_path = NULL; char _net, _mask; struct mk_secure_ip_t new_ip; struct mk_secure_url_t new_url; struct mk_secure_deny_hotlink_t new_deny_hotlink; struct mk_config_section section; struct mk_config_entry entry; struct mk_list head; / Read configuration / mk_api->str_build(&conf_path, &len, "%s/mandril.conf", confdir); conf = mk_api->config_create(conf_path); section = mk_api->config_section_get(conf, "RULES"); mk_list_foreach(head, &section->entries) { entry = mk_list_entry(head, struct mk_config_entry, _head); / Passing to internal struct / if (strcasecmp(entry->key, "IP") == 0) { new_ip = mk_api->mem_alloc(sizeof(struct mk_secure_ip_t)); n = mk_api->str_search(entry->val, "/", 1); / subnet / if (n > 0) { / split network addr and netmask / _net = mk_api->str_copy_substr(entry->val, 0, n); _mask = mk_api->str_copy_substr(entry->val, n + 1, strlen(entry->val)); / validations... / if (!_net \|\| !_mask) { mk_warn("Mandril: cannot parse entry '%s' in RULES section", entry->val); goto ip_next; } mk_info("network: '%s' mask: '%s'", _net, _mask); / convert ip string to network address / if (inet_aton(_net, &new_ip->ip) == 0) { mk_warn("Mandril: invalid ip address '%s' in RULES section", entry->val); goto ip_next; } / parse mask / new_ip->netmask = strtol(_mask, (char ) NULL, 10); if (new_ip->netmask <= 0 \|\| new_ip->netmask >= 32) { mk_warn("Mandril: invalid mask value '%s' in RULES section", entry->val); goto ip_next; } / complete struct data / new_ip->is_subnet = MK_TRUE; new_ip->network = MK_NET_NETWORK(new_ip->ip.s_addr, new_ip->netmask); new_ip->hostmin = MK_NET_HOSTMIN(new_ip->ip.s_addr, new_ip->netmask); new_ip->hostmax = MK_NET_HOSTMAX(new_ip->ip.s_addr, new_ip->netmask); / link node with main list / mk_list_add(&new_ip->_head, &mk_secure_ip); / * I know, you were instructed to hate 'goto' statements!, ok, show this * code to your teacher and let him blame :P / ip_next: if (_net) { mk_api->mem_free(_net); } if (_mask) { mk_api->mem_free(_mask); } } else { / normal IP address / / convert ip string to network address / if (inet_aton(entry->val, &new_ip->ip) == 0) { mk_warn("Mandril: invalid ip address '%s' in RULES section", entry->val); } else { new_ip->is_subnet = MK_FALSE; mk_list_add(&new_ip->_head, &mk_secure_ip); } } } else if (strcasecmp(entry->key, "URL") == 0) { / simple allcotion and data association / new_url = mk_api->mem_alloc(sizeof(struct mk_secure_url_t)); new_url->criteria = entry->val; / link node with main list / mk_list_add(&new_url->_head, &mk_secure_url); } else if (strcasecmp(entry->key, "deny_hotlink") == 0) { new_deny_hotlink = mk_api->mem_alloc(sizeof(new_deny_hotlink)); new_deny_hotlink->criteria = entry->val; mk_list_add(&new_deny_hotlink->_head, &mk_secure_deny_hotlink); } } mk_api->mem_free(conf_path); return ret; } static int mk_security_check_ip(int socket) { int network; struct mk_secure_ip_t entry; struct mk_list head; struct in_addr addr_t, addr = &addr_t; socklen_t len = sizeof(addr); if (getpeername(socket, (struct sockaddr )&addr_t, &len) < 0) { return -1; } PLUGIN_TRACE("[FD %i] Mandril validating IP address", socket); mk_list_foreach(head, &mk_secure_ip) { entry = mk_list_entry(head, struct mk_secure_ip_t, _head); if (entry->is_subnet == MK_TRUE) { /* Validate network / network = MK_NET_NETWORK(addr->s_addr, entry->netmask); if (network != entry->network) { continue; } / Validate host range / if (addr->s_addr <= entry->hostmax && addr->s_addr >= entry->hostmin) { PLUGIN_TRACE("[FD %i] Mandril closing by rule in ranges", socket); return -1; } } else { if (addr->s_addr == entry->ip.s_addr) { PLUGIN_TRACE("[FD %i] Mandril closing by rule in IP match", socket); return -1; } } } return 0; } / Check if the incoming URL is restricted for some rule / static int mk_security_check_url(mk_ptr_t url) { int n; struct mk_list head; struct mk_secure_url_t entry; mk_list_foreach(head, &mk_secure_url) { entry = mk_list_entry(head, struct mk_secure_url_t, _head); n = mk_api->str_search_n(url.data, entry->criteria, MK_STR_INSENSITIVE, url.len); if (n >= 0) { return -1; } } return 0; } mk_ptr_t parse_referer_host(mk_ptr_t ref) { unsigned int i, beginHost, endHost; mk_ptr_t host; host.data = NULL; host.len = 0; // Find end of "protocol://" for (i = 0; i < ref.len && !(ref.data[i] == '/' && ref.data[i+1] == '/'); i++); if (i == ref.len) { goto error; } beginHost = i + 2; // Find end of any "user:password@" for (; i < ref.len && ref.data[i] != '@'; i++); if (i < ref.len) { beginHost = i + 1; } // Find end of "host", (beginning of :port or /path) for (i = beginHost; i < ref.len && ref.data[i] != ':' && ref.data[i] != '/'; i++); endHost = i; host.data = ref.data + beginHost; host.len = endHost - beginHost; return host; error: host.data = NULL; host.len = 0; return host; } static int mk_security_check_hotlink(mk_ptr_t url, mk_ptr_t host, mk_ptr_t referer) { mk_ptr_t ref_host = parse_referer_host(referer); unsigned int domains_matched = 0; int i = 0; const char curA, curB; struct mk_list head; struct mk_secure_deny_hotlink_t entry; if (ref_host.data == NULL) { return 0; } else if (host.data == NULL) { mk_err("No host data."); return -1; } mk_list_foreach(head, &mk_secure_url) { entry = mk_list_entry(head, struct mk_secure_deny_hotlink_t, _head); i = mk_api->str_search_n(url.data, entry->criteria, MK_STR_INSENSITIVE, url.len); if (i >= 0) { break; } } if (i < 0) { return 0; } curA = host.data + host.len; curB = ref_host.data + ref_host.len; // Match backwards from root domain. while (curA > host.data && curB > ref_host.data) { i++; curA--; curB--; if ((curA == '.' && curB == '.') \|\| curA == host.data \|\| curB == ref_host.data) { if (i < 1) { break; } else if (curA == host.data && !(curB == ref_host.data \|\| (curB - 1) == '.')) { break; } else if (curB == ref_host.data && !(curA == host.data \|\| (curA - 1) == '.')) { break; } else if (strncasecmp(curA, curB, i)) { break; } domains_matched += 1; i = 0; } } // Block connection if none or only top domain matched. return domains_matched >= 2 ? 0 : -1; } int _mkp_init(struct plugin_api api, char confdir) { mk_api = api; / Init security lists / mk_list_init(&mk_secure_ip); mk_list_init(&mk_secure_url); mk_list_init(&mk_secure_deny_hotlink); / Read configuration / mk_security_conf(confdir); return 0; } void _mkp_exit() { } int _mkp_stage_10(unsigned int socket, struct sched_connection conx) { (void) conx; /* Validate ip address with Mandril rules / if (mk_security_check_ip(socket) != 0) { PLUGIN_TRACE("[FD %i] Mandril close connection", socket); return MK_PLUGIN_RET_CLOSE_CONX; } return MK_PLUGIN_RET_CONTINUE; } int _mkp_stage_30(struct plugin p, struct client_session cs, struct session_request sr) { mk_ptr_t referer; (void) p; (void) cs; PLUGIN_TRACE("[FD %i] Mandril validating URL", cs->socket); if (mk_security_check_url(sr->uri_processed) < 0) { PLUGIN_TRACE("[FD %i] Close connection, blocked URL", cs->socket); mk_api->header_set_http_status(sr, MK_CLIENT_FORBIDDEN); return MK_PLUGIN_RET_CLOSE_CONX; } PLUGIN_TRACE("[FD %d] Mandril validating hotlinking", cs->socket); referer = mk_api->header_get(&sr->headers_toc, "Referer", strlen("Referer")); if (mk_security_check_hotlink(sr->uri_processed, sr->host, referer) < 0) { PLUGIN_TRACE("[FD %i] Close connection, deny hotlinking.", cs->socket); mk_api->header_set_http_status(sr, MK_CLIENT_FORBIDDEN); return MK_PLUGIN_RET_CLOSE_CONX; } return MK_PLUGIN_RET_NOT_ME; }	./CrossVul/dataset_final_sorted/CWE-264/c/good_5655_0
crossvul-cpp_data_good_3429_0	/* * icall.c: * * Authors: * Dietmar Maurer (dietmar@ximian.com) * Paolo Molaro (lupus@ximian.com) * Patrik Torstensson (patrik.torstensson@labs2.com) * * Copyright 2001-2003 Ximian, Inc (http://www.ximian.com) * Copyright 2004-2009 Novell, Inc (http://www.novell.com) / #include <config.h> #include <glib.h> #include <stdarg.h> #include <string.h> #include <ctype.h> #ifdef HAVE_ALLOCA_H #include <alloca.h> #endif #ifdef HAVE_SYS_TIME_H #include <sys/time.h> #endif #ifdef HAVE_UNISTD_H #include <unistd.h> #endif #if defined (PLATFORM_WIN32) #include <stdlib.h> #endif #include "mono/utils/mono-membar.h" #include <mono/metadata/object.h> #include <mono/metadata/threads.h> #include <mono/metadata/threads-types.h> #include <mono/metadata/threadpool.h> #include <mono/metadata/monitor.h> #include <mono/metadata/reflection.h> #include <mono/metadata/assembly.h> #include <mono/metadata/tabledefs.h> #include <mono/metadata/exception.h> #include <mono/metadata/file-io.h> #include <mono/metadata/console-io.h> #include <mono/metadata/socket-io.h> #include <mono/metadata/mono-endian.h> #include <mono/metadata/tokentype.h> #include <mono/metadata/domain-internals.h> #include <mono/metadata/metadata-internals.h> #include <mono/metadata/class-internals.h> #include <mono/metadata/marshal.h> #include <mono/metadata/gc-internal.h> #include <mono/metadata/mono-gc.h> #include <mono/metadata/rand.h> #include <mono/metadata/sysmath.h> #include <mono/metadata/string-icalls.h> #include <mono/metadata/debug-helpers.h> #include <mono/metadata/process.h> #include <mono/metadata/environment.h> #include <mono/metadata/profiler-private.h> #include <mono/metadata/locales.h> #include <mono/metadata/filewatcher.h> #include <mono/metadata/char-conversions.h> #include <mono/metadata/security.h> #include <mono/metadata/mono-config.h> #include <mono/metadata/cil-coff.h> #include <mono/metadata/number-formatter.h> #include <mono/metadata/security-manager.h> #include <mono/metadata/security-core-clr.h> #include <mono/metadata/mono-perfcounters.h> #include <mono/metadata/mono-debug.h> #include <mono/metadata/verify-internals.h> #include <mono/io-layer/io-layer.h> #include <mono/utils/strtod.h> #include <mono/utils/monobitset.h> #include <mono/utils/mono-time.h> #include <mono/utils/mono-proclib.h> #include <mono/utils/mono-string.h> #include <mono/utils/mono-error-internals.h> #if defined (PLATFORM_WIN32) #include <windows.h> #include <shlobj.h> #endif #include "decimal.h" static MonoReflectionAssembly ves_icall_System_Reflection_Assembly_GetCallingAssembly (void); static MonoArray* type_array_from_modifiers (MonoImage image, MonoType type, int optional); /* This is an implementation of a growable pointer array that avoids doing memory allocations for small sizes. * It works by allocating an initial small array on stack and only going to malloc'd memory if needed. / typedef struct { void data; int size; int capacity; } MonoPtrArray; #define MONO_PTR_ARRAY_MAX_ON_STACK (16) #define mono_ptr_array_init(ARRAY, INITIAL_SIZE) do {\ (ARRAY).size = 0; \ (ARRAY).capacity = MAX (INITIAL_SIZE, MONO_PTR_ARRAY_MAX_ON_STACK); \ (ARRAY).data = INITIAL_SIZE > MONO_PTR_ARRAY_MAX_ON_STACK ? mono_gc_alloc_fixed (sizeof (void) * INITIAL_SIZE, NULL) : g_newa (void, MONO_PTR_ARRAY_MAX_ON_STACK); \ } while (0) #define mono_ptr_array_destroy(ARRAY) do {\ if ((ARRAY).capacity > MONO_PTR_ARRAY_MAX_ON_STACK) \ mono_gc_free_fixed ((ARRAY).data); \ } while (0) #define mono_ptr_array_append(ARRAY, VALUE) do { \ if ((ARRAY).size >= (ARRAY).capacity) {\ void __tmp = mono_gc_alloc_fixed (sizeof (void) (ARRAY).capacity * 2, NULL); \ memcpy (__tmp, (ARRAY).data, (ARRAY).capacity * sizeof (void)); \ if ((ARRAY).capacity > MONO_PTR_ARRAY_MAX_ON_STACK) \ mono_gc_free_fixed ((ARRAY).data); \ (ARRAY).data = __tmp; \ (ARRAY).capacity = 2;\ }\ ((ARRAY).data [(ARRAY).size++] = VALUE); \ } while (0) #define mono_ptr_array_set(ARRAY, IDX, VALUE) do { \ ((ARRAY).data [(IDX)] = VALUE); \ } while (0) #define mono_ptr_array_get(ARRAY, IDX) ((ARRAY).data [(IDX)]) #define mono_ptr_array_size(ARRAY) ((ARRAY).size) static inline MonoBoolean is_generic_parameter (MonoType type) { return !type->byref && (type->type == MONO_TYPE_VAR \|\| type->type == MONO_TYPE_MVAR); } / * We expect a pointer to a char, not a string / static gboolean mono_double_ParseImpl (char ptr, double result) { gchar endptr = NULL; result = 0.0; MONO_ARCH_SAVE_REGS; #ifdef __arm__ if (ptr) result = strtod (ptr, &endptr); #else if (ptr){ #ifdef _EGLIB_MAJOR /* Need to lock here because EGLIB (#464316) has locking defined as no-ops, and that breaks mono_strtod / EnterCriticalSection (&mono_strtod_mutex); result = mono_strtod (ptr, &endptr); LeaveCriticalSection (&mono_strtod_mutex); #else result = mono_strtod (ptr, &endptr); #endif } #endif if (!ptr \|\| (endptr && endptr)) return FALSE; return TRUE; } static MonoObject ves_icall_System_Array_GetValueImpl (MonoObject this, guint32 pos) { MonoClass ac; MonoArray ao; gint32 esize; gpointer ea; MONO_ARCH_SAVE_REGS; ao = (MonoArray )this; ac = (MonoClass )ao->obj.vtable->klass; esize = mono_array_element_size (ac); ea = (gpointer)((char)ao->vector + (pos * esize)); if (ac->element_class->valuetype) return mono_value_box (this->vtable->domain, ac->element_class, ea); else return ea; } static MonoObject ves_icall_System_Array_GetValue (MonoObject this, MonoObject idxs) { MonoClass ac, ic; MonoArray ao, io; gint32 i, pos, ind; MONO_ARCH_SAVE_REGS; MONO_CHECK_ARG_NULL (idxs); io = (MonoArray )idxs; ic = (MonoClass )io->obj.vtable->klass; ao = (MonoArray )this; ac = (MonoClass )ao->obj.vtable->klass; g_assert (ic->rank == 1); if (io->bounds != NULL \|\| io->max_length != ac->rank) mono_raise_exception (mono_get_exception_argument (NULL, NULL)); ind = (gint32 )io->vector; if (ao->bounds == NULL) { if (ind < 0 \|\| ind >= ao->max_length) mono_raise_exception (mono_get_exception_index_out_of_range ()); return ves_icall_System_Array_GetValueImpl (this, ind); } for (i = 0; i < ac->rank; i++) if ((ind [i] < ao->bounds [i].lower_bound) \|\| (ind [i] >= (mono_array_lower_bound_t)ao->bounds [i].length + ao->bounds [i].lower_bound)) mono_raise_exception (mono_get_exception_index_out_of_range ()); pos = ind [0] - ao->bounds [0].lower_bound; for (i = 1; i < ac->rank; i++) pos = posao->bounds [i].length + ind [i] - ao->bounds [i].lower_bound; return ves_icall_System_Array_GetValueImpl (this, pos); } static void ves_icall_System_Array_SetValueImpl (MonoArray this, MonoObject value, guint32 pos) { MonoClass ac, vc, ec; gint32 esize, vsize; gpointer ea, va; int et, vt; guint64 u64 = 0; gint64 i64 = 0; gdouble r64 = 0; MONO_ARCH_SAVE_REGS; if (value) vc = value->vtable->klass; else vc = NULL; ac = this->obj.vtable->klass; ec = ac->element_class; esize = mono_array_element_size (ac); ea = (gpointer)((char)this->vector + (pos esize)); va = (gpointer)((char)value + sizeof (MonoObject)); if (mono_class_is_nullable (ec)) { mono_nullable_init ((guint8)ea, value, ec); return; } if (!value) { memset (ea, 0, esize); return; } #define NO_WIDENING_CONVERSION G_STMT_START{\ mono_raise_exception (mono_get_exception_argument ( \ "value", "not a widening conversion")); \ }G_STMT_END #define CHECK_WIDENING_CONVERSION(extra) G_STMT_START{\ if (esize < vsize + (extra)) \ mono_raise_exception (mono_get_exception_argument ( \ "value", "not a widening conversion")); \ }G_STMT_END #define INVALID_CAST G_STMT_START{\ mono_raise_exception (mono_get_exception_invalid_cast ()); \ }G_STMT_END / Check element (destination) type. / switch (ec->byval_arg.type) { case MONO_TYPE_STRING: switch (vc->byval_arg.type) { case MONO_TYPE_STRING: break; default: INVALID_CAST; } break; case MONO_TYPE_BOOLEAN: switch (vc->byval_arg.type) { case MONO_TYPE_BOOLEAN: break; case MONO_TYPE_CHAR: case MONO_TYPE_U1: case MONO_TYPE_U2: case MONO_TYPE_U4: case MONO_TYPE_U8: case MONO_TYPE_I1: case MONO_TYPE_I2: case MONO_TYPE_I4: case MONO_TYPE_I8: case MONO_TYPE_R4: case MONO_TYPE_R8: NO_WIDENING_CONVERSION; default: INVALID_CAST; } break; } if (!ec->valuetype) { if (!mono_object_isinst (value, ec)) INVALID_CAST; mono_gc_wbarrier_set_arrayref (this, ea, (MonoObject)value); return; } if (mono_object_isinst (value, ec)) { if (ec->has_references) mono_value_copy (ea, (char)value + sizeof (MonoObject), ec); else memcpy (ea, (char )value + sizeof (MonoObject), esize); return; } if (!vc->valuetype) INVALID_CAST; vsize = mono_class_instance_size (vc) - sizeof (MonoObject); et = ec->byval_arg.type; if (et == MONO_TYPE_VALUETYPE && ec->byval_arg.data.klass->enumtype) et = mono_class_enum_basetype (ec->byval_arg.data.klass)->type; vt = vc->byval_arg.type; if (vt == MONO_TYPE_VALUETYPE && vc->byval_arg.data.klass->enumtype) vt = mono_class_enum_basetype (vc->byval_arg.data.klass)->type; #define ASSIGN_UNSIGNED(etype) G_STMT_START{\ switch (vt) { \ case MONO_TYPE_U1: \ case MONO_TYPE_U2: \ case MONO_TYPE_U4: \ case MONO_TYPE_U8: \ case MONO_TYPE_CHAR: \ CHECK_WIDENING_CONVERSION(0); \ (etype ) ea = (etype) u64; \ return; \ /* You can't assign a signed value to an unsigned array. / \ case MONO_TYPE_I1: \ case MONO_TYPE_I2: \ case MONO_TYPE_I4: \ case MONO_TYPE_I8: \ / You can't assign a floating point number to an integer array. / \ case MONO_TYPE_R4: \ case MONO_TYPE_R8: \ NO_WIDENING_CONVERSION; \ } \ }G_STMT_END #define ASSIGN_SIGNED(etype) G_STMT_START{\ switch (vt) { \ case MONO_TYPE_I1: \ case MONO_TYPE_I2: \ case MONO_TYPE_I4: \ case MONO_TYPE_I8: \ CHECK_WIDENING_CONVERSION(0); \ (etype ) ea = (etype) i64; \ return; \ / You can assign an unsigned value to a signed array if the array's / \ / element size is larger than the value size. / \ case MONO_TYPE_U1: \ case MONO_TYPE_U2: \ case MONO_TYPE_U4: \ case MONO_TYPE_U8: \ case MONO_TYPE_CHAR: \ CHECK_WIDENING_CONVERSION(1); \ (etype ) ea = (etype) u64; \ return; \ / You can't assign a floating point number to an integer array. / \ case MONO_TYPE_R4: \ case MONO_TYPE_R8: \ NO_WIDENING_CONVERSION; \ } \ }G_STMT_END #define ASSIGN_REAL(etype) G_STMT_START{\ switch (vt) { \ case MONO_TYPE_R4: \ case MONO_TYPE_R8: \ CHECK_WIDENING_CONVERSION(0); \ (etype ) ea = (etype) r64; \ return; \ / All integer values fit into a floating point array, so we don't / \ / need to CHECK_WIDENING_CONVERSION here. / \ case MONO_TYPE_I1: \ case MONO_TYPE_I2: \ case MONO_TYPE_I4: \ case MONO_TYPE_I8: \ (etype ) ea = (etype) i64; \ return; \ case MONO_TYPE_U1: \ case MONO_TYPE_U2: \ case MONO_TYPE_U4: \ case MONO_TYPE_U8: \ case MONO_TYPE_CHAR: \ (etype ) ea = (etype) u64; \ return; \ } \ }G_STMT_END switch (vt) { case MONO_TYPE_U1: u64 = (guint8 ) va; break; case MONO_TYPE_U2: u64 = (guint16 ) va; break; case MONO_TYPE_U4: u64 = (guint32 ) va; break; case MONO_TYPE_U8: u64 = (guint64 ) va; break; case MONO_TYPE_I1: i64 = (gint8 ) va; break; case MONO_TYPE_I2: i64 = (gint16 ) va; break; case MONO_TYPE_I4: i64 = (gint32 ) va; break; case MONO_TYPE_I8: i64 = (gint64 ) va; break; case MONO_TYPE_R4: r64 = (gfloat ) va; break; case MONO_TYPE_R8: r64 = (gdouble ) va; break; case MONO_TYPE_CHAR: u64 = (guint16 ) va; break; case MONO_TYPE_BOOLEAN: / Boolean is only compatible with itself. / switch (et) { case MONO_TYPE_CHAR: case MONO_TYPE_U1: case MONO_TYPE_U2: case MONO_TYPE_U4: case MONO_TYPE_U8: case MONO_TYPE_I1: case MONO_TYPE_I2: case MONO_TYPE_I4: case MONO_TYPE_I8: case MONO_TYPE_R4: case MONO_TYPE_R8: NO_WIDENING_CONVERSION; default: INVALID_CAST; } break; } / If we can't do a direct copy, let's try a widening conversion. / switch (et) { case MONO_TYPE_CHAR: ASSIGN_UNSIGNED (guint16); case MONO_TYPE_U1: ASSIGN_UNSIGNED (guint8); case MONO_TYPE_U2: ASSIGN_UNSIGNED (guint16); case MONO_TYPE_U4: ASSIGN_UNSIGNED (guint32); case MONO_TYPE_U8: ASSIGN_UNSIGNED (guint64); case MONO_TYPE_I1: ASSIGN_SIGNED (gint8); case MONO_TYPE_I2: ASSIGN_SIGNED (gint16); case MONO_TYPE_I4: ASSIGN_SIGNED (gint32); case MONO_TYPE_I8: ASSIGN_SIGNED (gint64); case MONO_TYPE_R4: ASSIGN_REAL (gfloat); case MONO_TYPE_R8: ASSIGN_REAL (gdouble); } INVALID_CAST; / Not reached, INVALID_CAST does not return. Just to avoid a compiler warning ... / return; #undef INVALID_CAST #undef NO_WIDENING_CONVERSION #undef CHECK_WIDENING_CONVERSION #undef ASSIGN_UNSIGNED #undef ASSIGN_SIGNED #undef ASSIGN_REAL } static void ves_icall_System_Array_SetValue (MonoArray this, MonoObject value, MonoArray idxs) { MonoClass ac, ic; gint32 i, pos, ind; MONO_ARCH_SAVE_REGS; MONO_CHECK_ARG_NULL (idxs); ic = idxs->obj.vtable->klass; ac = this->obj.vtable->klass; g_assert (ic->rank == 1); if (idxs->bounds != NULL \|\| idxs->max_length != ac->rank) mono_raise_exception (mono_get_exception_argument (NULL, NULL)); ind = (gint32 )idxs->vector; if (this->bounds == NULL) { if (ind < 0 \|\| ind >= this->max_length) mono_raise_exception (mono_get_exception_index_out_of_range ()); ves_icall_System_Array_SetValueImpl (this, value, ind); return; } for (i = 0; i < ac->rank; i++) if ((ind [i] < this->bounds [i].lower_bound) \|\| (ind [i] >= (mono_array_lower_bound_t)this->bounds [i].length + this->bounds [i].lower_bound)) mono_raise_exception (mono_get_exception_index_out_of_range ()); pos = ind [0] - this->bounds [0].lower_bound; for (i = 1; i < ac->rank; i++) pos = pos this->bounds [i].length + ind [i] - this->bounds [i].lower_bound; ves_icall_System_Array_SetValueImpl (this, value, pos); } static MonoArray * ves_icall_System_Array_CreateInstanceImpl (MonoReflectionType type, MonoArray lengths, MonoArray bounds) { MonoClass aklass; MonoArray array; mono_array_size_t sizes, i; gboolean bounded = FALSE; MONO_ARCH_SAVE_REGS; MONO_CHECK_ARG_NULL (type); MONO_CHECK_ARG_NULL (lengths); MONO_CHECK_ARG (lengths, mono_array_length (lengths) > 0); if (bounds) MONO_CHECK_ARG (bounds, mono_array_length (lengths) == mono_array_length (bounds)); for (i = 0; i < mono_array_length (lengths); i++) if (mono_array_get (lengths, gint32, i) < 0) mono_raise_exception (mono_get_exception_argument_out_of_range (NULL)); if (bounds && (mono_array_length (bounds) == 1) && (mono_array_get (bounds, gint32, 0) != 0)) /* vectors are not the same as one dimensional arrays with no-zero bounds / bounded = TRUE; else bounded = FALSE; aklass = mono_bounded_array_class_get (mono_class_from_mono_type (type->type), mono_array_length (lengths), bounded); sizes = alloca (aklass->rank sizeof(mono_array_size_t) * 2); for (i = 0; i < aklass->rank; ++i) { sizes [i] = mono_array_get (lengths, guint32, i); if (bounds) sizes [i + aklass->rank] = mono_array_get (bounds, guint32, i); else sizes [i + aklass->rank] = 0; } array = mono_array_new_full (mono_object_domain (type), aklass, sizes, sizes + aklass->rank); return array; } static MonoArray * ves_icall_System_Array_CreateInstanceImpl64 (MonoReflectionType type, MonoArray lengths, MonoArray bounds) { MonoClass aklass; MonoArray array; mono_array_size_t sizes, i; gboolean bounded = FALSE; MONO_ARCH_SAVE_REGS; MONO_CHECK_ARG_NULL (type); MONO_CHECK_ARG_NULL (lengths); MONO_CHECK_ARG (lengths, mono_array_length (lengths) > 0); if (bounds) MONO_CHECK_ARG (bounds, mono_array_length (lengths) == mono_array_length (bounds)); for (i = 0; i < mono_array_length (lengths); i++) if ((mono_array_get (lengths, gint64, i) < 0) \|\| (mono_array_get (lengths, gint64, i) > MONO_ARRAY_MAX_INDEX)) mono_raise_exception (mono_get_exception_argument_out_of_range (NULL)); if (bounds && (mono_array_length (bounds) == 1) && (mono_array_get (bounds, gint64, 0) != 0)) /* vectors are not the same as one dimensional arrays with no-zero bounds / bounded = TRUE; else bounded = FALSE; aklass = mono_bounded_array_class_get (mono_class_from_mono_type (type->type), mono_array_length (lengths), bounded); sizes = alloca (aklass->rank sizeof(mono_array_size_t) * 2); for (i = 0; i < aklass->rank; ++i) { sizes [i] = mono_array_get (lengths, guint64, i); if (bounds) sizes [i + aklass->rank] = (mono_array_size_t) mono_array_get (bounds, guint64, i); else sizes [i + aklass->rank] = 0; } array = mono_array_new_full (mono_object_domain (type), aklass, sizes, sizes + aklass->rank); return array; } static gint32 ves_icall_System_Array_GetRank (MonoObject this) { MONO_ARCH_SAVE_REGS; return this->vtable->klass->rank; } static gint32 ves_icall_System_Array_GetLength (MonoArray this, gint32 dimension) { gint32 rank = ((MonoObject )this)->vtable->klass->rank; mono_array_size_t length; MONO_ARCH_SAVE_REGS; if ((dimension < 0) \|\| (dimension >= rank)) mono_raise_exception (mono_get_exception_index_out_of_range ()); if (this->bounds == NULL) length = this->max_length; else length = this->bounds [dimension].length; #ifdef MONO_BIG_ARRAYS if (length > G_MAXINT32) mono_raise_exception (mono_get_exception_overflow ()); #endif return length; } static gint64 ves_icall_System_Array_GetLongLength (MonoArray this, gint32 dimension) { gint32 rank = ((MonoObject )this)->vtable->klass->rank; MONO_ARCH_SAVE_REGS; if ((dimension < 0) \|\| (dimension >= rank)) mono_raise_exception (mono_get_exception_index_out_of_range ()); if (this->bounds == NULL) return this->max_length; return this->bounds [dimension].length; } static gint32 ves_icall_System_Array_GetLowerBound (MonoArray this, gint32 dimension) { gint32 rank = ((MonoObject )this)->vtable->klass->rank; MONO_ARCH_SAVE_REGS; if ((dimension < 0) \|\| (dimension >= rank)) mono_raise_exception (mono_get_exception_index_out_of_range ()); if (this->bounds == NULL) return 0; return this->bounds [dimension].lower_bound; } static void ves_icall_System_Array_ClearInternal (MonoArray arr, int idx, int length) { int sz = mono_array_element_size (mono_object_class (arr)); memset (mono_array_addr_with_size (arr, sz, idx), 0, length * sz); } static gboolean ves_icall_System_Array_FastCopy (MonoArray source, int source_idx, MonoArray dest, int dest_idx, int length) { int element_size; void * dest_addr; void * source_addr; MonoClass src_class; MonoClass dest_class; int i; MONO_ARCH_SAVE_REGS; if (source->obj.vtable->klass->rank != dest->obj.vtable->klass->rank) return FALSE; if (source->bounds \|\| dest->bounds) return FALSE; /* there's no integer overflow since mono_array_length returns an unsigned integer / if ((dest_idx + length > mono_array_length (dest)) \|\| (source_idx + length > mono_array_length (source))) return FALSE; src_class = source->obj.vtable->klass->element_class; dest_class = dest->obj.vtable->klass->element_class; / * Handle common cases. / / Case1: object[] -> valuetype[] (ArrayList::ToArray) / if (src_class == mono_defaults.object_class && dest_class->valuetype) { int has_refs = dest_class->has_references; for (i = source_idx; i < source_idx + length; ++i) { MonoObject elem = mono_array_get (source, MonoObject, i); if (elem && !mono_object_isinst (elem, dest_class)) return FALSE; } element_size = mono_array_element_size (dest->obj.vtable->klass); memset (mono_array_addr_with_size (dest, element_size, dest_idx), 0, element_size length); for (i = 0; i < length; ++i) { MonoObject elem = mono_array_get (source, MonoObject, source_idx + i); void addr = mono_array_addr_with_size (dest, element_size, dest_idx + i); if (!elem) continue; if (has_refs) mono_value_copy (addr, (char )elem + sizeof (MonoObject), dest_class); else memcpy (addr, (char )elem + sizeof (MonoObject), element_size); } return TRUE; } / Check if we're copying a char[] <==> (u)short[] / if (src_class != dest_class) { if (dest_class->valuetype \|\| dest_class->enumtype \|\| src_class->valuetype \|\| src_class->enumtype) return FALSE; if (mono_class_is_subclass_of (src_class, dest_class, FALSE)) ; / Case2: object[] -> reftype[] (ArrayList::ToArray) / else if (mono_class_is_subclass_of (dest_class, src_class, FALSE)) for (i = source_idx; i < source_idx + length; ++i) { MonoObject elem = mono_array_get (source, MonoObject, i); if (elem && !mono_object_isinst (elem, dest_class)) return FALSE; } else return FALSE; } if (dest_class->valuetype) { element_size = mono_array_element_size (source->obj.vtable->klass); source_addr = mono_array_addr_with_size (source, element_size, source_idx); if (dest_class->has_references) { mono_value_copy_array (dest, dest_idx, source_addr, length); } else { dest_addr = mono_array_addr_with_size (dest, element_size, dest_idx); memmove (dest_addr, source_addr, element_size length); } } else { mono_array_memcpy_refs (dest, dest_idx, source, source_idx, length); } return TRUE; } static void ves_icall_System_Array_GetGenericValueImpl (MonoObject this, guint32 pos, gpointer value) { MonoClass ac; MonoArray ao; gint32 esize; gpointer ea; MONO_ARCH_SAVE_REGS; ao = (MonoArray )this; ac = (MonoClass )ao->obj.vtable->klass; esize = mono_array_element_size (ac); ea = (gpointer)((char)ao->vector + (pos * esize)); memcpy (value, ea, esize); } static void ves_icall_System_Array_SetGenericValueImpl (MonoObject this, guint32 pos, gpointer value) { MonoClass ac, ec; MonoArray ao; gint32 esize; gpointer ea; MONO_ARCH_SAVE_REGS; ao = (MonoArray )this; ac = (MonoClass )ao->obj.vtable->klass; ec = ac->element_class; esize = mono_array_element_size (ac); ea = (gpointer)((char)ao->vector + (pos esize)); if (MONO_TYPE_IS_REFERENCE (&ec->byval_arg)) { g_assert (esize == sizeof (gpointer)); mono_gc_wbarrier_generic_store (ea, (gpointer)value); } else { g_assert (ec->inited); if (ec->has_references) mono_gc_wbarrier_value_copy (ea, value, 1, ec); memcpy (ea, value, esize); } } static void ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_InitializeArray (MonoArray array, MonoClassField field_handle) { MonoClass klass = array->obj.vtable->klass; guint32 size = mono_array_element_size (klass); MonoType type = mono_type_get_underlying_type (&klass->element_class->byval_arg); int align; const char field_data; if (MONO_TYPE_IS_REFERENCE (type) \|\| type->type == MONO_TYPE_VALUETYPE) { MonoException exc = mono_get_exception_argument("array", "Cannot initialize array of non-primitive type."); mono_raise_exception (exc); } if (!(field_handle->type->attrs & FIELD_ATTRIBUTE_HAS_FIELD_RVA)) { MonoException exc = mono_get_exception_argument("field_handle", "Field doesn't have an RVA"); mono_raise_exception (exc); } size = array->max_length; field_data = mono_field_get_data (field_handle); if (size > mono_type_size (field_handle->type, &align)) { MonoException exc = mono_get_exception_argument("field_handle", "Field not large enough to fill array"); mono_raise_exception (exc); } #if G_BYTE_ORDER != G_LITTLE_ENDIAN #define SWAP(n) {\ guint ## n data = (guint ## n ) mono_array_addr (array, char, 0); \ guint ## n src = (guint ## n ) field_data; \ guint ## n end = (guint ## n )((char)src + size); \ \ for (; src < end; data++, src++) { \ data = read ## n (src); \ } \ } / printf ("Initialize array with elements of %s type\n", klass->element_class->name); / switch (type->type) { case MONO_TYPE_CHAR: case MONO_TYPE_I2: case MONO_TYPE_U2: SWAP (16); break; case MONO_TYPE_I4: case MONO_TYPE_U4: case MONO_TYPE_R4: SWAP (32); break; case MONO_TYPE_I8: case MONO_TYPE_U8: case MONO_TYPE_R8: SWAP (64); break; default: memcpy (mono_array_addr (array, char, 0), field_data, size); break; } #else memcpy (mono_array_addr (array, char, 0), field_data, size); #ifdef ARM_FPU_FPA if (klass->element_class->byval_arg.type == MONO_TYPE_R8) { gint i; double tmp; double data = (double)mono_array_addr (array, double, 0); for (i = 0; i < size; i++, data++) { readr8 (data, &tmp); data = tmp; } } #endif #endif } static gint ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetOffsetToStringData (void) { MONO_ARCH_SAVE_REGS; return offsetof (MonoString, chars); } static MonoObject * ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_GetObjectValue (MonoObject obj) { MONO_ARCH_SAVE_REGS; if ((obj == NULL) \|\| (! (obj->vtable->klass->valuetype))) return obj; else return mono_object_clone (obj); } static void ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunClassConstructor (MonoType handle) { MonoClass klass; MonoVTable vtable; MONO_CHECK_ARG_NULL (handle); klass = mono_class_from_mono_type (handle); MONO_CHECK_ARG (handle, klass); vtable = mono_class_vtable_full (mono_domain_get (), klass, TRUE); /* This will call the type constructor / mono_runtime_class_init (vtable); } static void ves_icall_System_Runtime_CompilerServices_RuntimeHelpers_RunModuleConstructor (MonoImage image) { MONO_ARCH_SAVE_REGS; mono_image_check_for_module_cctor (image); if (image->has_module_cctor) { MonoClass module_klass = mono_class_get (image, MONO_TOKEN_TYPE_DEF \| 1); /It's fine to raise the exception here/ mono_runtime_class_init (mono_class_vtable_full (mono_domain_get (), module_klass, TRUE)); } } static MonoObject ves_icall_System_Object_MemberwiseClone (MonoObject this) { MONO_ARCH_SAVE_REGS; return mono_object_clone (this); } static gint32 ves_icall_System_ValueType_InternalGetHashCode (MonoObject this, MonoArray *fields) { MonoClass klass; MonoObject *values = NULL; MonoObject o; int count = 0; gint32 result = 0; MonoClassField* field; gpointer iter; MONO_ARCH_SAVE_REGS; klass = mono_object_class (this); if (mono_class_num_fields (klass) == 0) return mono_object_hash (this); /* * Compute the starting value of the hashcode for fields of primitive * types, and return the remaining fields in an array to the managed side. * This way, we can avoid costly reflection operations in managed code. / iter = NULL; while ((field = mono_class_get_fields (klass, &iter))) { if (field->type->attrs & FIELD_ATTRIBUTE_STATIC) continue; if (mono_field_is_deleted (field)) continue; / FIXME: Add more types / switch (field->type->type) { case MONO_TYPE_I4: result ^= (gint32)((guint8)this + field->offset); break; case MONO_TYPE_STRING: { MonoString s; s = (MonoString*)((guint8)this + field->offset); if (s != NULL) result ^= mono_string_hash (s); break; } default: if (!values) values = g_newa (MonoObject, mono_class_num_fields (klass)); o = mono_field_get_value_object (mono_object_domain (this), field, this); values [count++] = o; } } if (values) { int i; mono_gc_wbarrier_generic_store (fields, (MonoObject) mono_array_new (mono_domain_get (), mono_defaults.object_class, count)); for (i = 0; i < count; ++i) mono_array_setref (fields, i, values [i]); } else { fields = NULL; } return result; } static MonoBoolean ves_icall_System_ValueType_Equals (MonoObject this, MonoObject that, MonoArray *fields) { MonoClass klass; MonoObject *values = NULL; MonoObject o; MonoClassField* field; gpointer iter; int count = 0; MONO_ARCH_SAVE_REGS; MONO_CHECK_ARG_NULL (that); if (this->vtable != that->vtable) return FALSE; klass = mono_object_class (this); if (klass->enumtype && mono_class_enum_basetype (klass) && mono_class_enum_basetype (klass)->type == MONO_TYPE_I4) return ((gint32)((guint8)this + sizeof (MonoObject)) == (gint32)((guint8)that + sizeof (MonoObject))); /* * Do the comparison for fields of primitive type and return a result if * possible. Otherwise, return the remaining fields in an array to the * managed side. This way, we can avoid costly reflection operations in * managed code. / fields = NULL; iter = NULL; while ((field = mono_class_get_fields (klass, &iter))) { if (field->type->attrs & FIELD_ATTRIBUTE_STATIC) continue; if (mono_field_is_deleted (field)) continue; /* FIXME: Add more types / switch (field->type->type) { case MONO_TYPE_U1: case MONO_TYPE_I1: case MONO_TYPE_BOOLEAN: if (((guint8)this + field->offset) != ((guint8)that + field->offset)) return FALSE; break; case MONO_TYPE_U2: case MONO_TYPE_I2: case MONO_TYPE_CHAR: if ((gint16)((guint8)this + field->offset) != (gint16)((guint8)that + field->offset)) return FALSE; break; case MONO_TYPE_U4: case MONO_TYPE_I4: if ((gint32)((guint8)this + field->offset) != (gint32)((guint8)that + field->offset)) return FALSE; break; case MONO_TYPE_U8: case MONO_TYPE_I8: if ((gint64)((guint8)this + field->offset) != (gint64)((guint8)that + field->offset)) return FALSE; break; case MONO_TYPE_R4: if ((float)((guint8)this + field->offset) != (float)((guint8)that + field->offset)) return FALSE; break; case MONO_TYPE_R8: if ((double)((guint8)this + field->offset) != (double)((guint8)that + field->offset)) return FALSE; break; case MONO_TYPE_STRING: { MonoString s1, s2; guint32 s1len, s2len; s1 = (MonoString*)((guint8)this + field->offset); s2 = (MonoString)((guint8)that + field->offset); if (s1 == s2) break; if ((s1 == NULL) \|\| (s2 == NULL)) return FALSE; s1len = mono_string_length (s1); s2len = mono_string_length (s2); if (s1len != s2len) return FALSE; if (memcmp (mono_string_chars (s1), mono_string_chars (s2), s1len * sizeof (gunichar2)) != 0) return FALSE; break; } default: if (!values) values = g_newa (MonoObject, mono_class_num_fields (klass) 2); o = mono_field_get_value_object (mono_object_domain (this), field, this); values [count++] = o; o = mono_field_get_value_object (mono_object_domain (this), field, that); values [count++] = o; } if (klass->enumtype) /* enums only have one non-static field / break; } if (values) { int i; mono_gc_wbarrier_generic_store (fields, (MonoObject) mono_array_new (mono_domain_get (), mono_defaults.object_class, count)); for (i = 0; i < count; ++i) mono_array_setref (fields, i, values [i]); return FALSE; } else { return TRUE; } } static MonoReflectionType ves_icall_System_Object_GetType (MonoObject obj) { MONO_ARCH_SAVE_REGS; if (obj->vtable->klass != mono_defaults.transparent_proxy_class) return mono_type_get_object (mono_object_domain (obj), &obj->vtable->klass->byval_arg); else return mono_type_get_object (mono_object_domain (obj), &((MonoTransparentProxy)obj)->remote_class->proxy_class->byval_arg); } static void mono_type_type_from_obj (MonoReflectionType mtype, MonoObject obj) { MONO_ARCH_SAVE_REGS; mtype->type = &obj->vtable->klass->byval_arg; g_assert (mtype->type->type); } static gint32 ves_icall_ModuleBuilder_getToken (MonoReflectionModuleBuilder mb, MonoObject obj) { MONO_ARCH_SAVE_REGS; MONO_CHECK_ARG_NULL (obj); return mono_image_create_token (mb->dynamic_image, obj, TRUE, TRUE); } static gint32 ves_icall_ModuleBuilder_getMethodToken (MonoReflectionModuleBuilder mb, MonoReflectionMethod method, MonoArray opt_param_types) { MONO_ARCH_SAVE_REGS; MONO_CHECK_ARG_NULL (method); return mono_image_create_method_token ( mb->dynamic_image, (MonoObject ) method, opt_param_types); } static void ves_icall_ModuleBuilder_WriteToFile (MonoReflectionModuleBuilder mb, HANDLE file) { MONO_ARCH_SAVE_REGS; mono_image_create_pefile (mb, file); } static void ves_icall_ModuleBuilder_build_metadata (MonoReflectionModuleBuilder mb) { MONO_ARCH_SAVE_REGS; mono_image_build_metadata (mb); } static void ves_icall_ModuleBuilder_RegisterToken (MonoReflectionModuleBuilder mb, MonoObject obj, guint32 token) { MONO_ARCH_SAVE_REGS; mono_image_register_token (mb->dynamic_image, token, obj); } static gboolean get_caller (MonoMethod m, gint32 no, gint32 ilo, gboolean managed, gpointer data) { MonoMethod dest = data; / skip unmanaged frames / if (!managed) return FALSE; if (m == dest) { dest = NULL; return FALSE; } if (!(dest)) { dest = m; return TRUE; } return FALSE; } static gboolean get_executing (MonoMethod m, gint32 no, gint32 ilo, gboolean managed, gpointer data) { MonoMethod *dest = data; / skip unmanaged frames / if (!managed) return FALSE; if (!(dest)) { if (!strcmp (m->klass->name_space, "System.Reflection")) return FALSE; dest = m; return TRUE; } return FALSE; } static gboolean get_caller_no_reflection (MonoMethod m, gint32 no, gint32 ilo, gboolean managed, gpointer data) { MonoMethod *dest = data; / skip unmanaged frames / if (!managed) return FALSE; if (m->wrapper_type != MONO_WRAPPER_NONE) return FALSE; if (m->klass->image == mono_defaults.corlib && !strcmp (m->klass->name_space, "System.Reflection")) return FALSE; if (m == dest) { dest = NULL; return FALSE; } if (!(dest)) { dest = m; return TRUE; } return FALSE; } static MonoReflectionType type_from_name (const char str, MonoBoolean ignoreCase) { MonoType type = NULL; MonoAssembly assembly = NULL; MonoTypeNameParse info; char temp_str = g_strdup (str); gboolean type_resolve = FALSE; MONO_ARCH_SAVE_REGS; /* mono_reflection_parse_type() mangles the string / if (!mono_reflection_parse_type (temp_str, &info)) { mono_reflection_free_type_info (&info); g_free (temp_str); return NULL; } if (info.assembly.name) { assembly = mono_assembly_load (&info.assembly, NULL, NULL); } else { MonoMethod m = mono_method_get_last_managed (); MonoMethod dest = m; mono_stack_walk_no_il (get_caller_no_reflection, &dest); if (!dest) dest = m; / * FIXME: mono_method_get_last_managed() sometimes returns NULL, thus * causing ves_icall_System_Reflection_Assembly_GetCallingAssembly() * to crash. This only seems to happen in some strange remoting * scenarios and I was unable to figure out what's happening there. * Dec 10, 2005 - Martin. / if (dest) { assembly = dest->klass->image->assembly; type_resolve = TRUE; } else { g_warning (G_STRLOC); } } if (assembly) { / When loading from the current assembly, AppDomain.TypeResolve will not be called yet / type = mono_reflection_get_type (assembly->image, &info, ignoreCase, &type_resolve); } if (!info.assembly.name && !type) / try mscorlib / type = mono_reflection_get_type (NULL, &info, ignoreCase, &type_resolve); if (assembly && !type && type_resolve) { type_resolve = FALSE; / This will invoke TypeResolve if not done in the first 'if' / type = mono_reflection_get_type (assembly->image, &info, ignoreCase, &type_resolve); } mono_reflection_free_type_info (&info); g_free (temp_str); if (!type) return NULL; return mono_type_get_object (mono_domain_get (), type); } #ifdef UNUSED MonoReflectionType mono_type_get (const char str) { char copy = g_strdup (str); MonoReflectionType type = type_from_name (copy, FALSE); g_free (copy); return type; } #endif static MonoReflectionType ves_icall_type_from_name (MonoString name, MonoBoolean throwOnError, MonoBoolean ignoreCase) { char str = mono_string_to_utf8 (name); MonoReflectionType type; type = type_from_name (str, ignoreCase); g_free (str); if (type == NULL){ MonoException e = NULL; if (throwOnError) e = mono_get_exception_type_load (name, NULL); mono_loader_clear_error (); if (e != NULL) mono_raise_exception (e); } return type; } static MonoReflectionType* ves_icall_type_from_handle (MonoType handle) { MonoDomain domain = mono_domain_get (); MonoClass klass = mono_class_from_mono_type (handle); MONO_ARCH_SAVE_REGS; mono_class_init (klass); return mono_type_get_object (domain, handle); } static MonoBoolean ves_icall_System_Type_EqualsInternal (MonoReflectionType type, MonoReflectionType c) { MONO_ARCH_SAVE_REGS; if (c && type->type && c->type) return mono_metadata_type_equal (type->type, c->type); else return (type == c) ? TRUE : FALSE; } / System.TypeCode / typedef enum { TYPECODE_EMPTY, TYPECODE_OBJECT, TYPECODE_DBNULL, TYPECODE_BOOLEAN, TYPECODE_CHAR, TYPECODE_SBYTE, TYPECODE_BYTE, TYPECODE_INT16, TYPECODE_UINT16, TYPECODE_INT32, TYPECODE_UINT32, TYPECODE_INT64, TYPECODE_UINT64, TYPECODE_SINGLE, TYPECODE_DOUBLE, TYPECODE_DECIMAL, TYPECODE_DATETIME, TYPECODE_STRING = 18 } TypeCode; static guint32 ves_icall_type_GetTypeCodeInternal (MonoReflectionType type) { int t = type->type->type; MONO_ARCH_SAVE_REGS; if (type->type->byref) return TYPECODE_OBJECT; handle_enum: switch (t) { case MONO_TYPE_VOID: return TYPECODE_OBJECT; case MONO_TYPE_BOOLEAN: return TYPECODE_BOOLEAN; case MONO_TYPE_U1: return TYPECODE_BYTE; case MONO_TYPE_I1: return TYPECODE_SBYTE; case MONO_TYPE_U2: return TYPECODE_UINT16; case MONO_TYPE_I2: return TYPECODE_INT16; case MONO_TYPE_CHAR: return TYPECODE_CHAR; case MONO_TYPE_PTR: case MONO_TYPE_U: case MONO_TYPE_I: return TYPECODE_OBJECT; case MONO_TYPE_U4: return TYPECODE_UINT32; case MONO_TYPE_I4: return TYPECODE_INT32; case MONO_TYPE_U8: return TYPECODE_UINT64; case MONO_TYPE_I8: return TYPECODE_INT64; case MONO_TYPE_R4: return TYPECODE_SINGLE; case MONO_TYPE_R8: return TYPECODE_DOUBLE; case MONO_TYPE_VALUETYPE: if (type->type->data.klass->enumtype) { t = mono_class_enum_basetype (type->type->data.klass)->type; goto handle_enum; } else { MonoClass k = type->type->data.klass; if (strcmp (k->name_space, "System") == 0) { if (strcmp (k->name, "Decimal") == 0) return TYPECODE_DECIMAL; else if (strcmp (k->name, "DateTime") == 0) return TYPECODE_DATETIME; } } return TYPECODE_OBJECT; case MONO_TYPE_STRING: return TYPECODE_STRING; case MONO_TYPE_SZARRAY: case MONO_TYPE_ARRAY: case MONO_TYPE_OBJECT: case MONO_TYPE_VAR: case MONO_TYPE_MVAR: case MONO_TYPE_TYPEDBYREF: return TYPECODE_OBJECT; case MONO_TYPE_CLASS: { MonoClass k = type->type->data.klass; if (strcmp (k->name_space, "System") == 0) { if (strcmp (k->name, "DBNull") == 0) return TYPECODE_DBNULL; } } return TYPECODE_OBJECT; case MONO_TYPE_GENERICINST: return TYPECODE_OBJECT; default: g_error ("type 0x%02x not handled in GetTypeCode()", t); } return 0; } static guint32 ves_icall_type_is_subtype_of (MonoReflectionType type, MonoReflectionType c, MonoBoolean check_interfaces) { MonoDomain domain; MonoClass klass; MonoClass klassc; MONO_ARCH_SAVE_REGS; g_assert (type != NULL); domain = ((MonoObject )type)->vtable->domain; if (!c) /* FIXME: dont know what do do here / return 0; klass = mono_class_from_mono_type (type->type); klassc = mono_class_from_mono_type (c->type); if (type->type->byref) return klassc == mono_defaults.object_class; return mono_class_is_subclass_of (klass, klassc, check_interfaces); } static guint32 ves_icall_type_is_assignable_from (MonoReflectionType type, MonoReflectionType c) { MonoDomain domain; MonoClass klass; MonoClass klassc; MONO_ARCH_SAVE_REGS; g_assert (type != NULL); domain = ((MonoObject )type)->vtable->domain; klass = mono_class_from_mono_type (type->type); klassc = mono_class_from_mono_type (c->type); if (type->type->byref && !c->type->byref) return FALSE; return mono_class_is_assignable_from (klass, klassc); } static guint32 ves_icall_type_IsInstanceOfType (MonoReflectionType type, MonoObject obj) { MonoClass klass = mono_class_from_mono_type (type->type); return mono_object_isinst (obj, klass) != NULL; } static guint32 ves_icall_get_attributes (MonoReflectionType type) { MonoClass klass = mono_class_from_mono_type (type->type); MONO_ARCH_SAVE_REGS; return klass->flags; } static MonoReflectionMarshal* ves_icall_System_Reflection_FieldInfo_GetUnmanagedMarshal (MonoReflectionField field) { MonoClass klass = field->field->parent; MonoMarshalType info; int i; if (klass->generic_container \|\| (klass->generic_class && klass->generic_class->context.class_inst->is_open)) return NULL; info = mono_marshal_load_type_info (klass); for (i = 0; i < info->num_fields; ++i) { if (info->fields [i].field == field->field) { if (!info->fields [i].mspec) return NULL; else return mono_reflection_marshal_from_marshal_spec (field->object.vtable->domain, klass, info->fields [i].mspec); } } return NULL; } static MonoReflectionField ves_icall_System_Reflection_FieldInfo_internal_from_handle_type (MonoClassField handle, MonoType type) { gboolean found = FALSE; MonoClass klass; MonoClass k; g_assert (handle); if (!type) { klass = handle->parent; } else { klass = mono_class_from_mono_type (type); /* Check that the field belongs to the class / for (k = klass; k; k = k->parent) { if (k == handle->parent) { found = TRUE; break; } } if (!found) / The managed code will throw the exception / return NULL; } return mono_field_get_object (mono_domain_get (), klass, handle); } static MonoArray ves_icall_System_Reflection_FieldInfo_GetTypeModifiers (MonoReflectionField field, MonoBoolean optional) { MonoType type = field->field->type; return type_array_from_modifiers (field->field->parent->image, type, optional); } static void ves_icall_get_method_info (MonoMethod method, MonoMethodInfo info) { MonoDomain domain = mono_domain_get (); MonoMethodSignature sig; MONO_ARCH_SAVE_REGS; sig = mono_method_signature (method); if (!sig) { g_assert (mono_loader_get_last_error ()); mono_raise_exception (mono_loader_error_prepare_exception (mono_loader_get_last_error ())); } MONO_STRUCT_SETREF (info, parent, mono_type_get_object (domain, &method->klass->byval_arg)); MONO_STRUCT_SETREF (info, ret, mono_type_get_object (domain, sig->ret)); info->attrs = method->flags; info->implattrs = method->iflags; if (sig->call_convention == MONO_CALL_DEFAULT) info->callconv = sig->sentinelpos >= 0 ? 2 : 1; else { if (sig->call_convention == MONO_CALL_VARARG \|\| sig->sentinelpos >= 0) info->callconv = 2; else info->callconv = 1; } info->callconv \|= (sig->hasthis << 5) \| (sig->explicit_this << 6); } static MonoArray* ves_icall_get_parameter_info (MonoMethod method, MonoReflectionMethod member) { MonoDomain domain = mono_domain_get (); return mono_param_get_objects_internal (domain, method, member->reftype ? mono_class_from_mono_type (member->reftype->type) : NULL); } static MonoReflectionMarshal ves_icall_System_MonoMethodInfo_get_retval_marshal (MonoMethod method) { MonoDomain domain = mono_domain_get (); MonoReflectionMarshal* res = NULL; MonoMarshalSpec *mspecs; int i; mspecs = g_new (MonoMarshalSpec, mono_method_signature (method)->param_count + 1); mono_method_get_marshal_info (method, mspecs); if (mspecs [0]) res = mono_reflection_marshal_from_marshal_spec (domain, method->klass, mspecs [0]); for (i = mono_method_signature (method)->param_count; i >= 0; i--) if (mspecs [i]) mono_metadata_free_marshal_spec (mspecs [i]); g_free (mspecs); return res; } static gint32 ves_icall_MonoField_GetFieldOffset (MonoReflectionField field) { return field->field->offset - sizeof (MonoObject); } static MonoReflectionType ves_icall_MonoField_GetParentType (MonoReflectionField field, MonoBoolean declaring) { MonoClass parent; MONO_ARCH_SAVE_REGS; parent = declaring? field->field->parent: field->klass; return mono_type_get_object (mono_object_domain (field), &parent->byval_arg); } static MonoObject * ves_icall_MonoField_GetValueInternal (MonoReflectionField field, MonoObject obj) { MonoObject o; MonoClassField cf = field->field; MonoClass klass; MonoVTable vtable; MonoType t; MonoDomain domain = mono_object_domain (field); gchar v; gboolean is_static = FALSE; gboolean is_ref = FALSE; MONO_ARCH_SAVE_REGS; if (field->klass->image->assembly->ref_only) mono_raise_exception (mono_get_exception_invalid_operation ( "It is illegal to get the value on a field on a type loaded using the ReflectionOnly methods.")); if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR) mono_security_core_clr_ensure_reflection_access_field (cf); mono_class_init (field->klass); if (cf->type->attrs & FIELD_ATTRIBUTE_STATIC) is_static = TRUE; if (obj && !is_static) { / Check that the field belongs to the object / gboolean found = FALSE; MonoClass k; for (k = obj->vtable->klass; k; k = k->parent) { if (k == cf->parent) { found = TRUE; break; } } if (!found) { char msg = g_strdup_printf ("Field '%s' defined on type '%s' is not a field on the target object which is of type '%s'.", mono_field_get_name (cf), cf->parent->name, obj->vtable->klass->name); MonoException ex = mono_get_exception_argument (NULL, msg); g_free (msg); mono_raise_exception (ex); } } t = mono_type_get_underlying_type (cf->type); switch (t->type) { case MONO_TYPE_STRING: case MONO_TYPE_OBJECT: case MONO_TYPE_CLASS: case MONO_TYPE_ARRAY: case MONO_TYPE_SZARRAY: is_ref = TRUE; break; case MONO_TYPE_U1: case MONO_TYPE_I1: case MONO_TYPE_BOOLEAN: case MONO_TYPE_U2: case MONO_TYPE_I2: case MONO_TYPE_CHAR: case MONO_TYPE_U: case MONO_TYPE_I: case MONO_TYPE_U4: case MONO_TYPE_I4: case MONO_TYPE_R4: case MONO_TYPE_U8: case MONO_TYPE_I8: case MONO_TYPE_R8: case MONO_TYPE_VALUETYPE: is_ref = t->byref; break; case MONO_TYPE_GENERICINST: if (mono_type_generic_inst_is_valuetype (t)) { is_ref = t->byref; } else { is_ref = TRUE; } break; default: g_error ("type 0x%x not handled in " "ves_icall_Monofield_GetValue", t->type); return NULL; } vtable = NULL; if (is_static) { vtable = mono_class_vtable_full (domain, cf->parent, TRUE); if (!vtable->initialized && !(cf->type->attrs & FIELD_ATTRIBUTE_LITERAL)) mono_runtime_class_init (vtable); } if (is_ref) { if (is_static) { mono_field_static_get_value (vtable, cf, &o); } else { mono_field_get_value (obj, cf, &o); } return o; } if (mono_class_is_nullable (mono_class_from_mono_type (cf->type))) { MonoClass nklass = mono_class_from_mono_type (cf->type); guint8 buf; /* Convert the Nullable structure into a boxed vtype / if (is_static) buf = (guint8)vtable->data + cf->offset; else buf = (guint8)obj + cf->offset; return mono_nullable_box (buf, nklass); } / boxed value type / klass = mono_class_from_mono_type (cf->type); o = mono_object_new (domain, klass); v = ((gchar ) o) + sizeof (MonoObject); if (is_static) { mono_field_static_get_value (vtable, cf, v); } else { mono_field_get_value (obj, cf, v); } return o; } static void ves_icall_MonoField_SetValueInternal (MonoReflectionField field, MonoObject obj, MonoObject value) { MonoClassField cf = field->field; gchar v; MONO_ARCH_SAVE_REGS; if (field->klass->image->assembly->ref_only) mono_raise_exception (mono_get_exception_invalid_operation ( "It is illegal to set the value on a field on a type loaded using the ReflectionOnly methods.")); if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR) mono_security_core_clr_ensure_reflection_access_field (cf); v = (gchar ) value; if (!cf->type->byref) { switch (cf->type->type) { case MONO_TYPE_U1: case MONO_TYPE_I1: case MONO_TYPE_BOOLEAN: case MONO_TYPE_U2: case MONO_TYPE_I2: case MONO_TYPE_CHAR: case MONO_TYPE_U: case MONO_TYPE_I: case MONO_TYPE_U4: case MONO_TYPE_I4: case MONO_TYPE_R4: case MONO_TYPE_U8: case MONO_TYPE_I8: case MONO_TYPE_R8: case MONO_TYPE_VALUETYPE: if (v != NULL) v += sizeof (MonoObject); break; case MONO_TYPE_STRING: case MONO_TYPE_OBJECT: case MONO_TYPE_CLASS: case MONO_TYPE_ARRAY: case MONO_TYPE_SZARRAY: /* Do nothing / break; case MONO_TYPE_GENERICINST: { MonoGenericClass gclass = cf->type->data.generic_class; g_assert (!gclass->context.class_inst->is_open); if (mono_class_is_nullable (mono_class_from_mono_type (cf->type))) { MonoClass nklass = mono_class_from_mono_type (cf->type); MonoObject nullable; /* * Convert the boxed vtype into a Nullable structure. * This is complicated by the fact that Nullables have * a variable structure. / nullable = mono_object_new (mono_domain_get (), nklass); mono_nullable_init (mono_object_unbox (nullable), value, nklass); v = mono_object_unbox (nullable); } else if (gclass->container_class->valuetype && (v != NULL)) v += sizeof (MonoObject); break; } default: g_error ("type 0x%x not handled in " "ves_icall_FieldInfo_SetValueInternal", cf->type->type); return; } } if (cf->type->attrs & FIELD_ATTRIBUTE_STATIC) { MonoVTable vtable = mono_class_vtable_full (mono_object_domain (field), cf->parent, TRUE); if (!vtable->initialized) mono_runtime_class_init (vtable); mono_field_static_set_value (vtable, cf, v); } else { mono_field_set_value (obj, cf, v); } } static MonoObject * ves_icall_MonoField_GetRawConstantValue (MonoReflectionField this) { MonoObject o = NULL; MonoClassField field = this->field; MonoClass klass; MonoDomain domain = mono_object_domain (this); gchar v; MonoTypeEnum def_type; const char def_value; MONO_ARCH_SAVE_REGS; mono_class_init (field->parent); if (!(field->type->attrs & FIELD_ATTRIBUTE_HAS_DEFAULT)) mono_raise_exception (mono_get_exception_invalid_operation (NULL)); if (field->parent->image->dynamic) { / FIXME: / g_assert_not_reached (); } def_value = mono_class_get_field_default_value (field, &def_type); switch (def_type) { case MONO_TYPE_U1: case MONO_TYPE_I1: case MONO_TYPE_BOOLEAN: case MONO_TYPE_U2: case MONO_TYPE_I2: case MONO_TYPE_CHAR: case MONO_TYPE_U: case MONO_TYPE_I: case MONO_TYPE_U4: case MONO_TYPE_I4: case MONO_TYPE_R4: case MONO_TYPE_U8: case MONO_TYPE_I8: case MONO_TYPE_R8: { MonoType t; /* boxed value type / t = g_new0 (MonoType, 1); t->type = def_type; klass = mono_class_from_mono_type (t); g_free (t); o = mono_object_new (domain, klass); v = ((gchar ) o) + sizeof (MonoObject); mono_get_constant_value_from_blob (domain, def_type, def_value, v); break; } case MONO_TYPE_STRING: case MONO_TYPE_CLASS: mono_get_constant_value_from_blob (domain, def_type, def_value, &o); break; default: g_assert_not_reached (); } return o; } static MonoReflectionType* ves_icall_MonoGenericMethod_get_ReflectedType (MonoReflectionGenericMethod rmethod) { MonoMethod method = rmethod->method.method; return mono_type_get_object (mono_object_domain (rmethod), &method->klass->byval_arg); } /* From MonoProperty.cs / typedef enum { PInfo_Attributes = 1, PInfo_GetMethod = 1 << 1, PInfo_SetMethod = 1 << 2, PInfo_ReflectedType = 1 << 3, PInfo_DeclaringType = 1 << 4, PInfo_Name = 1 << 5 } PInfo; static void ves_icall_get_property_info (MonoReflectionProperty property, MonoPropertyInfo info, PInfo req_info) { MonoDomain domain = mono_object_domain (property); MONO_ARCH_SAVE_REGS; if ((req_info & PInfo_ReflectedType) != 0) MONO_STRUCT_SETREF (info, parent, mono_type_get_object (domain, &property->klass->byval_arg)); else if ((req_info & PInfo_DeclaringType) != 0) MONO_STRUCT_SETREF (info, parent, mono_type_get_object (domain, &property->property->parent->byval_arg)); if ((req_info & PInfo_Name) != 0) MONO_STRUCT_SETREF (info, name, mono_string_new (domain, property->property->name)); if ((req_info & PInfo_Attributes) != 0) info->attrs = property->property->attrs; if ((req_info & PInfo_GetMethod) != 0) MONO_STRUCT_SETREF (info, get, property->property->get ? mono_method_get_object (domain, property->property->get, property->klass): NULL); if ((req_info & PInfo_SetMethod) != 0) MONO_STRUCT_SETREF (info, set, property->property->set ? mono_method_get_object (domain, property->property->set, property->klass): NULL); /* * There may be other methods defined for properties, though, it seems they are not exposed * in the reflection API / } static void ves_icall_get_event_info (MonoReflectionMonoEvent event, MonoEventInfo info) { MonoDomain domain = mono_object_domain (event); MONO_ARCH_SAVE_REGS; MONO_STRUCT_SETREF (info, reflected_type, mono_type_get_object (domain, &event->klass->byval_arg)); MONO_STRUCT_SETREF (info, declaring_type, mono_type_get_object (domain, &event->event->parent->byval_arg)); MONO_STRUCT_SETREF (info, name, mono_string_new (domain, event->event->name)); info->attrs = event->event->attrs; MONO_STRUCT_SETREF (info, add_method, event->event->add ? mono_method_get_object (domain, event->event->add, NULL): NULL); MONO_STRUCT_SETREF (info, remove_method, event->event->remove ? mono_method_get_object (domain, event->event->remove, NULL): NULL); MONO_STRUCT_SETREF (info, raise_method, event->event->raise ? mono_method_get_object (domain, event->event->raise, NULL): NULL); if (event->event->other) { int i, n = 0; while (event->event->other [n]) n++; MONO_STRUCT_SETREF (info, other_methods, mono_array_new (domain, mono_defaults.method_info_class, n)); for (i = 0; i < n; i++) mono_array_setref (info->other_methods, i, mono_method_get_object (domain, event->event->other [i], NULL)); } } static MonoArray* ves_icall_Type_GetInterfaces (MonoReflectionType* type) { MonoError error; MonoDomain domain = mono_object_domain (type); MonoArray intf; GPtrArray ifaces = NULL; int i; MonoClass class = mono_class_from_mono_type (type->type); MonoClass parent; MonoBitSet slots; MonoGenericContext context = NULL; MONO_ARCH_SAVE_REGS; if (class->generic_class && class->generic_class->context.class_inst->is_open) { context = mono_class_get_context (class); class = class->generic_class->container_class; } mono_class_setup_vtable (class); slots = mono_bitset_new (class->max_interface_id + 1, 0); for (parent = class; parent; parent = parent->parent) { GPtrArray tmp_ifaces = mono_class_get_implemented_interfaces (parent, &error); if (!mono_error_ok (&error)) { mono_bitset_free (slots); mono_error_raise_exception (&error); return NULL; } else if (tmp_ifaces) { for (i = 0; i < tmp_ifaces->len; ++i) { MonoClass ic = g_ptr_array_index (tmp_ifaces, i); if (mono_bitset_test (slots, ic->interface_id)) continue; mono_bitset_set (slots, ic->interface_id); if (ifaces == NULL) ifaces = g_ptr_array_new (); g_ptr_array_add (ifaces, ic); } g_ptr_array_free (tmp_ifaces, TRUE); } } mono_bitset_free (slots); if (!ifaces) return mono_array_new_cached (domain, mono_defaults.monotype_class, 0); intf = mono_array_new_cached (domain, mono_defaults.monotype_class, ifaces->len); for (i = 0; i < ifaces->len; ++i) { MonoClass ic = g_ptr_array_index (ifaces, i); MonoType ret = &ic->byval_arg, inflated = NULL; if (context && ic->generic_class && ic->generic_class->context.class_inst->is_open) inflated = ret = mono_class_inflate_generic_type (ret, context); mono_array_setref (intf, i, mono_type_get_object (domain, ret)); if (inflated) mono_metadata_free_type (inflated); } g_ptr_array_free (ifaces, TRUE); return intf; } static void ves_icall_Type_GetInterfaceMapData (MonoReflectionType type, MonoReflectionType iface, MonoArray targets, MonoArray methods) { MonoClass class = mono_class_from_mono_type (type->type); MonoClass iclass = mono_class_from_mono_type (iface->type); MonoReflectionMethod member; MonoMethod method; gpointer iter; int i = 0, len, ioffset; MonoDomain domain; MONO_ARCH_SAVE_REGS; mono_class_setup_vtable (class); / type doesn't implement iface: the exception is thrown in managed code / if (! MONO_CLASS_IMPLEMENTS_INTERFACE (class, iclass->interface_id)) return; len = mono_class_num_methods (iclass); ioffset = mono_class_interface_offset (class, iclass); domain = mono_object_domain (type); mono_gc_wbarrier_generic_store (targets, (MonoObject) mono_array_new (domain, mono_defaults.method_info_class, len)); mono_gc_wbarrier_generic_store (methods, (MonoObject) mono_array_new (domain, mono_defaults.method_info_class, len)); iter = NULL; while ((method = mono_class_get_methods (iclass, &iter))) { member = mono_method_get_object (domain, method, iclass); mono_array_setref (methods, i, member); member = mono_method_get_object (domain, class->vtable [i + ioffset], class); mono_array_setref (targets, i, member); i ++; } } static void ves_icall_Type_GetPacking (MonoReflectionType type, guint32 packing, guint32 size) { MonoClass klass = mono_class_from_mono_type (type->type); if (klass->image->dynamic) { MonoReflectionTypeBuilder tb = (MonoReflectionTypeBuilder)type; packing = tb->packing_size; size = tb->class_size; } else { mono_metadata_packing_from_typedef (klass->image, klass->type_token, packing, size); } } static MonoReflectionType ves_icall_MonoType_GetElementType (MonoReflectionType type) { MonoClass class; MONO_ARCH_SAVE_REGS; if (!type->type->byref && type->type->type == MONO_TYPE_SZARRAY) return mono_type_get_object (mono_object_domain (type), &type->type->data.klass->byval_arg); class = mono_class_from_mono_type (type->type); // GetElementType should only return a type for: // Array Pointer PassedByRef if (type->type->byref) return mono_type_get_object (mono_object_domain (type), &class->byval_arg); else if (class->element_class && MONO_CLASS_IS_ARRAY (class)) return mono_type_get_object (mono_object_domain (type), &class->element_class->byval_arg); else if (class->element_class && type->type->type == MONO_TYPE_PTR) return mono_type_get_object (mono_object_domain (type), &class->element_class->byval_arg); else return NULL; } static MonoReflectionType* ves_icall_get_type_parent (MonoReflectionType type) { MonoClass class = mono_class_from_mono_type (type->type); MONO_ARCH_SAVE_REGS; return class->parent ? mono_type_get_object (mono_object_domain (type), &class->parent->byval_arg): NULL; } static MonoBoolean ves_icall_type_ispointer (MonoReflectionType type) { MONO_ARCH_SAVE_REGS; return type->type->type == MONO_TYPE_PTR; } static MonoBoolean ves_icall_type_isprimitive (MonoReflectionType type) { MONO_ARCH_SAVE_REGS; return (!type->type->byref && (((type->type->type >= MONO_TYPE_BOOLEAN) && (type->type->type <= MONO_TYPE_R8)) \|\| (type->type->type == MONO_TYPE_I) \|\| (type->type->type == MONO_TYPE_U))); } static MonoBoolean ves_icall_type_isbyref (MonoReflectionType type) { MONO_ARCH_SAVE_REGS; return type->type->byref; } static MonoBoolean ves_icall_type_iscomobject (MonoReflectionType type) { MonoClass klass = mono_class_from_mono_type (type->type); MONO_ARCH_SAVE_REGS; return (klass && klass->is_com_object); } static MonoReflectionModule ves_icall_MonoType_get_Module (MonoReflectionType type) { MonoClass class = mono_class_from_mono_type (type->type); MONO_ARCH_SAVE_REGS; return mono_module_get_object (mono_object_domain (type), class->image); } static MonoReflectionAssembly* ves_icall_MonoType_get_Assembly (MonoReflectionType type) { MonoDomain domain = mono_domain_get (); MonoClass class = mono_class_from_mono_type (type->type); MONO_ARCH_SAVE_REGS; return mono_assembly_get_object (domain, class->image->assembly); } static MonoReflectionType ves_icall_MonoType_get_DeclaringType (MonoReflectionType type) { MonoDomain domain = mono_domain_get (); MonoClass class; MONO_ARCH_SAVE_REGS; if (type->type->byref) return NULL; if (type->type->type == MONO_TYPE_VAR) class = mono_type_get_generic_param_owner (type->type)->owner.klass; else if (type->type->type == MONO_TYPE_MVAR) class = mono_type_get_generic_param_owner (type->type)->owner.method->klass; else class = mono_class_from_mono_type (type->type)->nested_in; return class ? mono_type_get_object (domain, &class->byval_arg) : NULL; } static MonoReflectionType ves_icall_MonoType_get_UnderlyingSystemType (MonoReflectionType type) { MonoDomain domain = mono_domain_get (); MonoClass class = mono_class_from_mono_type (type->type); MONO_ARCH_SAVE_REGS; if (class->enumtype && mono_class_enum_basetype (class)) / types that are modified typebuilders may not have enum_basetype set / return mono_type_get_object (domain, mono_class_enum_basetype (class)); else if (class->element_class) return mono_type_get_object (domain, &class->element_class->byval_arg); else return NULL; } static MonoString ves_icall_MonoType_get_Name (MonoReflectionType type) { MonoDomain domain = mono_domain_get (); MonoClass class = mono_class_from_mono_type (type->type); MONO_ARCH_SAVE_REGS; if (type->type->byref) { char n = g_strdup_printf ("%s&", class->name); MonoString res = mono_string_new (domain, n); g_free (n); return res; } else { return mono_string_new (domain, class->name); } } static MonoString ves_icall_MonoType_get_Namespace (MonoReflectionType type) { MonoDomain domain = mono_domain_get (); MonoClass class = mono_class_from_mono_type (type->type); MONO_ARCH_SAVE_REGS; while (class->nested_in) class = class->nested_in; if (class->name_space [0] == '\0') return NULL; else return mono_string_new (domain, class->name_space); } static gint32 ves_icall_MonoType_GetArrayRank (MonoReflectionType type) { MonoClass class; if (type->type->type != MONO_TYPE_ARRAY && type->type->type != MONO_TYPE_SZARRAY) mono_raise_exception (mono_get_exception_argument ("type", "Type must be an array type")); class = mono_class_from_mono_type (type->type); return class->rank; } static MonoArray ves_icall_MonoType_GetGenericArguments (MonoReflectionType type) { MonoArray res; MonoClass klass, pklass; MonoDomain domain = mono_object_domain (type); MonoVTable array_vtable = mono_class_vtable_full (domain, mono_array_class_get_cached (mono_defaults.systemtype_class, 1), TRUE); int i; MONO_ARCH_SAVE_REGS; klass = mono_class_from_mono_type (type->type); if (klass->generic_container) { MonoGenericContainer container = klass->generic_container; res = mono_array_new_specific (array_vtable, container->type_argc); for (i = 0; i < container->type_argc; ++i) { pklass = mono_class_from_generic_parameter (mono_generic_container_get_param (container, i), klass->image, FALSE); mono_array_setref (res, i, mono_type_get_object (domain, &pklass->byval_arg)); } } else if (klass->generic_class) { MonoGenericInst inst = klass->generic_class->context.class_inst; res = mono_array_new_specific (array_vtable, inst->type_argc); for (i = 0; i < inst->type_argc; ++i) mono_array_setref (res, i, mono_type_get_object (domain, inst->type_argv [i])); } else { res = mono_array_new_specific (array_vtable, 0); } return res; } static gboolean ves_icall_Type_get_IsGenericTypeDefinition (MonoReflectionType type) { MonoClass klass; MONO_ARCH_SAVE_REGS; if (!IS_MONOTYPE (type)) return FALSE; if (type->type->byref) return FALSE; klass = mono_class_from_mono_type (type->type); return klass->generic_container != NULL; } static MonoReflectionType* ves_icall_Type_GetGenericTypeDefinition_impl (MonoReflectionType type) { MonoClass klass; MONO_ARCH_SAVE_REGS; if (type->type->byref) return NULL; klass = mono_class_from_mono_type (type->type); if (klass->generic_container) { return type; /* check this one / } if (klass->generic_class) { MonoClass generic_class = klass->generic_class->container_class; if (generic_class->wastypebuilder && generic_class->reflection_info) return generic_class->reflection_info; else return mono_type_get_object (mono_object_domain (type), &generic_class->byval_arg); } return NULL; } static MonoReflectionType* ves_icall_Type_MakeGenericType (MonoReflectionType type, MonoArray type_array) { MonoClass class; MonoType geninst, *types; int i, count; MONO_ARCH_SAVE_REGS; count = mono_array_length (type_array); types = g_new0 (MonoType , count); for (i = 0; i < count; i++) { MonoReflectionType t = mono_array_get (type_array, gpointer, i); types [i] = t->type; } geninst = mono_reflection_bind_generic_parameters (type, count, types); g_free (types); if (!geninst) return NULL; class = mono_class_from_mono_type (geninst); /we might inflate to the GTD/ if (class->generic_class && !mono_verifier_class_is_valid_generic_instantiation (class)) mono_raise_exception (mono_get_exception_argument ("method", "Invalid generic arguments")); return mono_type_get_object (mono_object_domain (type), geninst); } static gboolean ves_icall_Type_get_IsGenericInstance (MonoReflectionType type) { MonoClass klass; MONO_ARCH_SAVE_REGS; if (type->type->byref) return FALSE; klass = mono_class_from_mono_type (type->type); return klass->generic_class != NULL; } static gboolean ves_icall_Type_get_IsGenericType (MonoReflectionType type) { MonoClass klass; MONO_ARCH_SAVE_REGS; if (!IS_MONOTYPE (type)) return FALSE; if (type->type->byref) return FALSE; klass = mono_class_from_mono_type (type->type); return klass->generic_class != NULL \|\| klass->generic_container != NULL; } static gint32 ves_icall_Type_GetGenericParameterPosition (MonoReflectionType type) { MONO_ARCH_SAVE_REGS; if (!IS_MONOTYPE (type)) return -1; if (is_generic_parameter (type->type)) return mono_type_get_generic_param_num (type->type); return -1; } static GenericParameterAttributes ves_icall_Type_GetGenericParameterAttributes (MonoReflectionType type) { MONO_ARCH_SAVE_REGS; g_assert (IS_MONOTYPE (type)); g_assert (is_generic_parameter (type->type)); return mono_generic_param_info (type->type->data.generic_param)->flags; } static MonoArray ves_icall_Type_GetGenericParameterConstraints (MonoReflectionType type) { MonoGenericParamInfo param_info; MonoDomain domain; MonoClass ptr; MonoArray res; int i, count; MONO_ARCH_SAVE_REGS; g_assert (IS_MONOTYPE (type)); domain = mono_object_domain (type); param_info = mono_generic_param_info (type->type->data.generic_param); for (count = 0, ptr = param_info->constraints; ptr && ptr; ptr++, count++) ; res = mono_array_new (domain, mono_defaults.monotype_class, count); for (i = 0; i < count; i++) mono_array_setref (res, i, mono_type_get_object (domain, &param_info->constraints [i]->byval_arg)); return res; } static MonoBoolean ves_icall_MonoType_get_IsGenericParameter (MonoReflectionType type) { MONO_ARCH_SAVE_REGS; return is_generic_parameter (type->type); } static MonoBoolean ves_icall_TypeBuilder_get_IsGenericParameter (MonoReflectionTypeBuilder tb) { MONO_ARCH_SAVE_REGS; return is_generic_parameter (tb->type.type); } static void ves_icall_EnumBuilder_setup_enum_type (MonoReflectionType enumtype, MonoReflectionType t) { enumtype->type = t->type; } static MonoReflectionMethod ves_icall_MonoType_GetCorrespondingInflatedMethod (MonoReflectionType type, MonoReflectionMethod generic) { MonoDomain domain; MonoClass klass; MonoMethod method; gpointer iter; MONO_ARCH_SAVE_REGS; domain = ((MonoObject )type)->vtable->domain; klass = mono_class_from_mono_type (type->type); iter = NULL; while ((method = mono_class_get_methods (klass, &iter))) { if (method->token == generic->method->token) return mono_method_get_object (domain, method, klass); } return NULL; } static MonoReflectionMethod * ves_icall_MonoType_get_DeclaringMethod (MonoReflectionType ref_type) { MonoMethod method; MonoType type = ref_type->type; MONO_ARCH_SAVE_REGS; if (type->byref \|\| (type->type != MONO_TYPE_MVAR && type->type != MONO_TYPE_VAR)) mono_raise_exception (mono_get_exception_invalid_operation ("DeclaringMethod can only be used on generic arguments")); if (type->type == MONO_TYPE_VAR) return NULL; method = mono_type_get_generic_param_owner (type)->owner.method; g_assert (method); return mono_method_get_object (mono_object_domain (ref_type), method, method->klass); } static MonoReflectionDllImportAttribute ves_icall_MonoMethod_GetDllImportAttribute (MonoMethod method) { static MonoClass DllImportAttributeClass = NULL; MonoDomain domain = mono_domain_get (); MonoReflectionDllImportAttribute attr; MonoImage image = method->klass->image; MonoMethodPInvoke piinfo = (MonoMethodPInvoke )method; MonoTableInfo tables = image->tables; MonoTableInfo im = &tables [MONO_TABLE_IMPLMAP]; MonoTableInfo mr = &tables [MONO_TABLE_MODULEREF]; guint32 im_cols [MONO_IMPLMAP_SIZE]; guint32 scope_token; const char import = NULL; const char scope = NULL; guint32 flags; if (!(method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL)) return NULL; if (!DllImportAttributeClass) { DllImportAttributeClass = mono_class_from_name (mono_defaults.corlib, "System.Runtime.InteropServices", "DllImportAttribute"); g_assert (DllImportAttributeClass); } if (method->klass->image->dynamic) { MonoReflectionMethodAux method_aux = g_hash_table_lookup ( ((MonoDynamicImage)method->klass->image)->method_aux_hash, method); if (method_aux) { import = method_aux->dllentry; scope = method_aux->dll; } if (!import \|\| !scope) { mono_raise_exception (mono_get_exception_argument ("method", "System.Reflection.Emit method with invalid pinvoke information")); return NULL; } } else { if (piinfo->implmap_idx) { mono_metadata_decode_row (im, piinfo->implmap_idx - 1, im_cols, MONO_IMPLMAP_SIZE); piinfo->piflags = im_cols [MONO_IMPLMAP_FLAGS]; import = mono_metadata_string_heap (image, im_cols [MONO_IMPLMAP_NAME]); scope_token = mono_metadata_decode_row_col (mr, im_cols [MONO_IMPLMAP_SCOPE] - 1, MONO_MODULEREF_NAME); scope = mono_metadata_string_heap (image, scope_token); } } flags = piinfo->piflags; attr = (MonoReflectionDllImportAttribute)mono_object_new (domain, DllImportAttributeClass); MONO_OBJECT_SETREF (attr, dll, mono_string_new (domain, scope)); MONO_OBJECT_SETREF (attr, entry_point, mono_string_new (domain, import)); attr->call_conv = (flags & 0x700) >> 8; attr->charset = ((flags & 0x6) >> 1) + 1; if (attr->charset == 1) attr->charset = 2; attr->exact_spelling = (flags & 0x1) != 0; attr->set_last_error = (flags & 0x40) != 0; attr->best_fit_mapping = (flags & 0x30) == 0x10; attr->throw_on_unmappable = (flags & 0x3000) == 0x1000; attr->preserve_sig = FALSE; return attr; } static MonoReflectionMethod ves_icall_MonoMethod_GetGenericMethodDefinition (MonoReflectionMethod method) { MonoMethodInflated imethod; MonoMethod result; MONO_ARCH_SAVE_REGS; if (method->method->is_generic) return method; if (!method->method->is_inflated) return NULL; imethod = (MonoMethodInflated ) method->method; result = imethod->declaring; /* Not a generic method. / if (!result->is_generic) return NULL; if (method->method->klass->image->dynamic) { MonoDynamicImage image = (MonoDynamicImage)method->method->klass->image; MonoReflectionMethod res; /* * FIXME: Why is this stuff needed at all ? Why can't the code below work for * the dynamic case as well ? / mono_loader_lock (); res = mono_g_hash_table_lookup (image->generic_def_objects, imethod); mono_loader_unlock (); if (res) return res; } if (imethod->context.class_inst) { MonoClass klass = ((MonoMethod ) imethod)->klass; /Generic methods gets the context of the GTD./ if (mono_class_get_context (klass)) result = mono_class_inflate_generic_method_full (result, klass, mono_class_get_context (klass)); } return mono_method_get_object (mono_object_domain (method), result, NULL); } static gboolean ves_icall_MonoMethod_get_IsGenericMethod (MonoReflectionMethod method) { MONO_ARCH_SAVE_REGS; return mono_method_signature (method->method)->generic_param_count != 0; } static gboolean ves_icall_MonoMethod_get_IsGenericMethodDefinition (MonoReflectionMethod method) { MONO_ARCH_SAVE_REGS; return method->method->is_generic; } static MonoArray ves_icall_MonoMethod_GetGenericArguments (MonoReflectionMethod method) { MonoArray res; MonoDomain domain; int count, i; MONO_ARCH_SAVE_REGS; domain = mono_object_domain (method); if (method->method->is_inflated) { MonoGenericInst inst = mono_method_get_context (method->method)->method_inst; if (inst) { count = inst->type_argc; res = mono_array_new (domain, mono_defaults.systemtype_class, count); for (i = 0; i < count; i++) mono_array_setref (res, i, mono_type_get_object (domain, inst->type_argv [i])); return res; } } count = mono_method_signature (method->method)->generic_param_count; res = mono_array_new (domain, mono_defaults.systemtype_class, count); for (i = 0; i < count; i++) { MonoGenericContainer container = mono_method_get_generic_container (method->method); MonoGenericParam param = mono_generic_container_get_param (container, i); MonoClass pklass = mono_class_from_generic_parameter ( param, method->method->klass->image, TRUE); mono_array_setref (res, i, mono_type_get_object (domain, &pklass->byval_arg)); } return res; } static MonoObject ves_icall_InternalInvoke (MonoReflectionMethod method, MonoObject this, MonoArray params, MonoException exc) { / * Invoke from reflection is supposed to always be a virtual call (the API * is stupid), mono_runtime_invoke_() calls the provided method, allowing greater flexibility. / MonoMethod m = method->method; int pcount; void obj = this; MONO_ARCH_SAVE_REGS; exc = NULL; if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR) mono_security_core_clr_ensure_reflection_access_method (m); if (!(m->flags & METHOD_ATTRIBUTE_STATIC)) { if (!mono_class_vtable_full (mono_object_domain (method), m->klass, FALSE)) { mono_gc_wbarrier_generic_store (exc, (MonoObject) mono_class_get_exception_for_failure (m->klass)); return NULL; } if (this) { if (!mono_object_isinst (this, m->klass)) { mono_gc_wbarrier_generic_store (exc, (MonoObject) mono_exception_from_name_msg (mono_defaults.corlib, "System.Reflection", "TargetException", "Object does not match target type.")); return NULL; } m = mono_object_get_virtual_method (this, m); /* must pass the pointer to the value for valuetype methods / if (m->klass->valuetype) obj = mono_object_unbox (this); } else if (strcmp (m->name, ".ctor") && !m->wrapper_type) { mono_gc_wbarrier_generic_store (exc, (MonoObject) mono_exception_from_name_msg (mono_defaults.corlib, "System.Reflection", "TargetException", "Non-static method requires a target.")); return NULL; } } pcount = params? mono_array_length (params): 0; if (pcount != mono_method_signature (m)->param_count) { mono_gc_wbarrier_generic_store (exc, (MonoObject) mono_exception_from_name (mono_defaults.corlib, "System.Reflection", "TargetParameterCountException")); return NULL; } if ((m->klass->flags & TYPE_ATTRIBUTE_ABSTRACT) && !strcmp (m->name, ".ctor") && !this) { mono_gc_wbarrier_generic_store (exc, (MonoObject) mono_exception_from_name_msg (mono_defaults.corlib, "System.Reflection", "TargetException", "Cannot invoke constructor of an abstract class.")); return NULL; } if (m->klass->image->assembly->ref_only) { mono_gc_wbarrier_generic_store (exc, (MonoObject) mono_get_exception_invalid_operation ("It is illegal to invoke a method on a type loaded using the ReflectionOnly api.")); return NULL; } if (m->klass->rank && !strcmp (m->name, ".ctor")) { int i; mono_array_size_t lengths; mono_array_size_t lower_bounds; pcount = mono_array_length (params); lengths = alloca (sizeof (mono_array_size_t) pcount); for (i = 0; i < pcount; ++i) lengths [i] = (mono_array_size_t) ((char)mono_array_get (params, gpointer, i) + sizeof (MonoObject)); if (m->klass->rank == pcount) { / Only lengths provided. / lower_bounds = NULL; } else { g_assert (pcount == (m->klass->rank 2)); /* lower bounds are first. / lower_bounds = lengths; lengths += m->klass->rank; } return (MonoObject)mono_array_new_full (mono_object_domain (params), m->klass, lengths, lower_bounds); } return mono_runtime_invoke_array (m, obj, params, NULL); } static MonoObject * ves_icall_InternalExecute (MonoReflectionMethod method, MonoObject this, MonoArray params, MonoArray outArgs) { MonoDomain domain = mono_object_domain (method); MonoMethod m = method->method; MonoMethodSignature sig = mono_method_signature (m); MonoArray out_args; MonoObject result; int i, j, outarg_count = 0; MONO_ARCH_SAVE_REGS; if (m->klass == mono_defaults.object_class) { if (!strcmp (m->name, "FieldGetter")) { MonoClass k = this->vtable->klass; MonoString name; char str; / If this is a proxy, then it must be a CBO / if (k == mono_defaults.transparent_proxy_class) { MonoTransparentProxy tp = (MonoTransparentProxy) this; this = tp->rp->unwrapped_server; g_assert (this); k = this->vtable->klass; } name = mono_array_get (params, MonoString , 1); str = mono_string_to_utf8 (name); do { MonoClassField* field = mono_class_get_field_from_name (k, str); if (field) { MonoClass field_klass = mono_class_from_mono_type (field->type); if (field_klass->valuetype) result = mono_value_box (domain, field_klass, (char )this + field->offset); else result = ((gpointer )((char )this + field->offset)); out_args = mono_array_new (domain, mono_defaults.object_class, 1); mono_gc_wbarrier_generic_store (outArgs, (MonoObject) out_args); mono_array_setref (out_args, 0, result); g_free (str); return NULL; } k = k->parent; } while (k); g_free (str); g_assert_not_reached (); } else if (!strcmp (m->name, "FieldSetter")) { MonoClass k = this->vtable->klass; MonoString name; guint32 size; gint32 align; char str; / If this is a proxy, then it must be a CBO / if (k == mono_defaults.transparent_proxy_class) { MonoTransparentProxy tp = (MonoTransparentProxy) this; this = tp->rp->unwrapped_server; g_assert (this); k = this->vtable->klass; } name = mono_array_get (params, MonoString , 1); str = mono_string_to_utf8 (name); do { MonoClassField* field = mono_class_get_field_from_name (k, str); if (field) { MonoClass field_klass = mono_class_from_mono_type (field->type); MonoObject val = mono_array_get (params, gpointer, 2); if (field_klass->valuetype) { size = mono_type_size (field->type, &align); #ifdef HAVE_SGEN_GC mono_gc_wbarrier_value_copy ((char )this + field->offset, (char)val + sizeof (MonoObject), 1, field_klass); #endif memcpy ((char )this + field->offset, ((char )val) + sizeof (MonoObject), size); } else { mono_gc_wbarrier_set_field (this, (char)this + field->offset, val); } out_args = mono_array_new (domain, mono_defaults.object_class, 0); mono_gc_wbarrier_generic_store (outArgs, (MonoObject) out_args); g_free (str); return NULL; } k = k->parent; } while (k); g_free (str); g_assert_not_reached (); } } for (i = 0; i < mono_array_length (params); i++) { if (sig->params [i]->byref) outarg_count++; } out_args = mono_array_new (domain, mono_defaults.object_class, outarg_count); /* handle constructors only for objects already allocated / if (!strcmp (method->method->name, ".ctor")) g_assert (this); / This can be called only on MBR objects, so no need to unbox for valuetypes. / g_assert (!method->method->klass->valuetype); result = mono_runtime_invoke_array (method->method, this, params, NULL); for (i = 0, j = 0; i < mono_array_length (params); i++) { if (sig->params [i]->byref) { gpointer arg; arg = mono_array_get (params, gpointer, i); mono_array_setref (out_args, j, arg); j++; } } mono_gc_wbarrier_generic_store (outArgs, (MonoObject) out_args); return result; } static guint64 read_enum_value (char mem, int type) { switch (type) { case MONO_TYPE_U1: return (guint8)mem; case MONO_TYPE_I1: return (gint8)mem; case MONO_TYPE_U2: return (guint16)mem; case MONO_TYPE_I2: return (gint16)mem; case MONO_TYPE_U4: return (guint32)mem; case MONO_TYPE_I4: return (gint32)mem; case MONO_TYPE_U8: return (guint64)mem; case MONO_TYPE_I8: return (gint64)mem; default: g_assert_not_reached (); } return 0; } static void write_enum_value (char mem, int type, guint64 value) { switch (type) { case MONO_TYPE_U1: case MONO_TYPE_I1: { guint8 p = (guint8)mem; p = value; break; } case MONO_TYPE_U2: case MONO_TYPE_I2: { guint16 p = (void)mem; p = value; break; } case MONO_TYPE_U4: case MONO_TYPE_I4: { guint32 p = (void)mem; p = value; break; } case MONO_TYPE_U8: case MONO_TYPE_I8: { guint64 p = (void)mem; p = value; break; } default: g_assert_not_reached (); } return; } static MonoObject * ves_icall_System_Enum_ToObject (MonoReflectionType enumType, MonoObject value) { MonoDomain domain; MonoClass enumc, objc; MonoObject res; MonoType etype; guint64 val; MONO_ARCH_SAVE_REGS; MONO_CHECK_ARG_NULL (enumType); MONO_CHECK_ARG_NULL (value); domain = mono_object_domain (enumType); enumc = mono_class_from_mono_type (enumType->type); objc = value->vtable->klass; if (!enumc->enumtype) mono_raise_exception (mono_get_exception_argument ("enumType", "Type provided must be an Enum.")); if (!((objc->enumtype) \|\| (objc->byval_arg.type >= MONO_TYPE_I1 && objc->byval_arg.type <= MONO_TYPE_U8))) mono_raise_exception (mono_get_exception_argument ("value", "The value passed in must be an enum base or an underlying type for an enum, such as an Int32.")); etype = mono_class_enum_basetype (enumc); if (!etype) / MS throws this for typebuilders / mono_raise_exception (mono_get_exception_argument ("Type must be a type provided by the runtime.", "enumType")); res = mono_object_new (domain, enumc); val = read_enum_value ((char )value + sizeof (MonoObject), objc->enumtype? mono_class_enum_basetype (objc)->type: objc->byval_arg.type); write_enum_value ((char )res + sizeof (MonoObject), etype->type, val); return res; } static MonoObject ves_icall_System_Enum_get_value (MonoObject this) { MonoObject res; MonoClass enumc; gpointer dst; gpointer src; int size; MONO_ARCH_SAVE_REGS; if (!this) return NULL; g_assert (this->vtable->klass->enumtype); enumc = mono_class_from_mono_type (mono_class_enum_basetype (this->vtable->klass)); res = mono_object_new (mono_object_domain (this), enumc); dst = (char )res + sizeof (MonoObject); src = (char )this + sizeof (MonoObject); size = mono_class_value_size (enumc, NULL); memcpy (dst, src, size); return res; } static MonoReflectionType ves_icall_System_Enum_get_underlying_type (MonoReflectionType type) { MonoType etype; MONO_ARCH_SAVE_REGS; etype = mono_class_enum_basetype (mono_class_from_mono_type (type->type)); if (!etype) /* MS throws this for typebuilders / mono_raise_exception (mono_get_exception_argument ("Type must be a type provided by the runtime.", "enumType")); return mono_type_get_object (mono_object_domain (type), etype); } static int ves_icall_System_Enum_compare_value_to (MonoObject this, MonoObject other) { gpointer tdata = (char )this + sizeof (MonoObject); gpointer odata = (char )other + sizeof (MonoObject); MonoType basetype = mono_class_enum_basetype (this->vtable->klass); g_assert (basetype); #define COMPARE_ENUM_VALUES(ENUM_TYPE) do { \ ENUM_TYPE me = ((ENUM_TYPE)tdata); \ ENUM_TYPE other = ((ENUM_TYPE)odata); \ if (me == other) \ return 0; \ return me > other ? 1 : -1; \ } while (0) #define COMPARE_ENUM_VALUES_RANGE(ENUM_TYPE) do { \ ENUM_TYPE me = ((ENUM_TYPE)tdata); \ ENUM_TYPE other = ((ENUM_TYPE)odata); \ if (me == other) \ return 0; \ return me - other; \ } while (0) switch (basetype->type) { case MONO_TYPE_U1: COMPARE_ENUM_VALUES (guint8); case MONO_TYPE_I1: COMPARE_ENUM_VALUES (gint8); case MONO_TYPE_CHAR: case MONO_TYPE_U2: COMPARE_ENUM_VALUES_RANGE (guint16); case MONO_TYPE_I2: COMPARE_ENUM_VALUES (gint16); case MONO_TYPE_U4: COMPARE_ENUM_VALUES (guint32); case MONO_TYPE_I4: COMPARE_ENUM_VALUES (gint32); case MONO_TYPE_U8: COMPARE_ENUM_VALUES (guint64); case MONO_TYPE_I8: COMPARE_ENUM_VALUES (gint64); default: g_error ("Implement type 0x%02x in get_hashcode", basetype->type); } #undef COMPARE_ENUM_VALUES_RANGE #undef COMPARE_ENUM_VALUES return 0; } static int ves_icall_System_Enum_get_hashcode (MonoObject this) { gpointer data = (char )this + sizeof (MonoObject); MonoType basetype = mono_class_enum_basetype (this->vtable->klass); g_assert (basetype); switch (basetype->type) { case MONO_TYPE_I1: return ((gint8)data); case MONO_TYPE_U1: return ((guint8)data); case MONO_TYPE_CHAR: case MONO_TYPE_U2: return ((guint16)data); case MONO_TYPE_I2: return ((gint16)data); case MONO_TYPE_U4: return ((guint32)data); case MONO_TYPE_I4: return ((gint32)data); case MONO_TYPE_U8: case MONO_TYPE_I8: { gint64 value = ((gint64)data); return (gint)(value & 0xffffffff) ^ (int)(value >> 32); } default: g_error ("Implement type 0x%02x in get_hashcode", basetype->type); } return 0; } static void ves_icall_get_enum_info (MonoReflectionType type, MonoEnumInfo info) { MonoDomain domain = mono_object_domain (type); MonoClass enumc = mono_class_from_mono_type (type->type); guint j = 0, nvalues, crow; gpointer iter; MonoClassField field; MONO_ARCH_SAVE_REGS; MONO_STRUCT_SETREF (info, utype, mono_type_get_object (domain, mono_class_enum_basetype (enumc))); nvalues = mono_class_num_fields (enumc) ? mono_class_num_fields (enumc) - 1 : 0; MONO_STRUCT_SETREF (info, names, mono_array_new (domain, mono_defaults.string_class, nvalues)); MONO_STRUCT_SETREF (info, values, mono_array_new (domain, enumc, nvalues)); crow = -1; iter = NULL; while ((field = mono_class_get_fields (enumc, &iter))) { const char p; int len; MonoTypeEnum def_type; if (strcmp ("value__", mono_field_get_name (field)) == 0) continue; if (mono_field_is_deleted (field)) continue; mono_array_setref (info->names, j, mono_string_new (domain, mono_field_get_name (field))); p = mono_class_get_field_default_value (field, &def_type); len = mono_metadata_decode_blob_size (p, &p); switch (mono_class_enum_basetype (enumc)->type) { case MONO_TYPE_U1: case MONO_TYPE_I1: mono_array_set (info->values, gchar, j, p); break; case MONO_TYPE_CHAR: case MONO_TYPE_U2: case MONO_TYPE_I2: mono_array_set (info->values, gint16, j, read16 (p)); break; case MONO_TYPE_U4: case MONO_TYPE_I4: mono_array_set (info->values, gint32, j, read32 (p)); break; case MONO_TYPE_U8: case MONO_TYPE_I8: mono_array_set (info->values, gint64, j, read64 (p)); break; default: g_error ("Implement type 0x%02x in get_enum_info", mono_class_enum_basetype (enumc)->type); } ++j; } } enum { BFLAGS_IgnoreCase = 1, BFLAGS_DeclaredOnly = 2, BFLAGS_Instance = 4, BFLAGS_Static = 8, BFLAGS_Public = 0x10, BFLAGS_NonPublic = 0x20, BFLAGS_FlattenHierarchy = 0x40, BFLAGS_InvokeMethod = 0x100, BFLAGS_CreateInstance = 0x200, BFLAGS_GetField = 0x400, BFLAGS_SetField = 0x800, BFLAGS_GetProperty = 0x1000, BFLAGS_SetProperty = 0x2000, BFLAGS_ExactBinding = 0x10000, BFLAGS_SuppressChangeType = 0x20000, BFLAGS_OptionalParamBinding = 0x40000 }; static MonoReflectionField * ves_icall_Type_GetField (MonoReflectionType type, MonoString name, guint32 bflags) { MonoDomain domain; MonoClass startklass, klass; int match; MonoClassField field; gpointer iter; char utf8_name; int (compare_func) (const char s1, const char s2) = NULL; domain = ((MonoObject )type)->vtable->domain; klass = startklass = mono_class_from_mono_type (type->type); MONO_ARCH_SAVE_REGS; if (!name) mono_raise_exception (mono_get_exception_argument_null ("name")); if (type->type->byref) return NULL; compare_func = (bflags & BFLAGS_IgnoreCase) ? mono_utf8_strcasecmp : strcmp; handle_parent: if (klass->exception_type != MONO_EXCEPTION_NONE) mono_raise_exception (mono_class_get_exception_for_failure (klass)); iter = NULL; while ((field = mono_class_get_fields (klass, &iter))) { match = 0; if (field->type == NULL) continue; if (mono_field_is_deleted (field)) continue; if ((field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK) == FIELD_ATTRIBUTE_PUBLIC) { if (bflags & BFLAGS_Public) match++; } else if ((klass == startklass) \|\| (field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK) != FIELD_ATTRIBUTE_PRIVATE) { if (bflags & BFLAGS_NonPublic) { match++; } } if (!match) continue; match = 0; if (field->type->attrs & FIELD_ATTRIBUTE_STATIC) { if (bflags & BFLAGS_Static) if ((bflags & BFLAGS_FlattenHierarchy) \|\| (klass == startklass)) match++; } else { if (bflags & BFLAGS_Instance) match++; } if (!match) continue; utf8_name = mono_string_to_utf8 (name); if (compare_func (mono_field_get_name (field), utf8_name)) { g_free (utf8_name); continue; } g_free (utf8_name); return mono_field_get_object (domain, klass, field); } if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent)) goto handle_parent; return NULL; } static MonoArray ves_icall_Type_GetFields_internal (MonoReflectionType type, guint32 bflags, MonoReflectionType reftype) { MonoDomain domain; MonoClass startklass, klass, refklass; MonoArray res; MonoObject member; int i, match; gpointer iter; MonoClassField field; MonoPtrArray tmp_array; MONO_ARCH_SAVE_REGS; domain = ((MonoObject )type)->vtable->domain; if (type->type->byref) return mono_array_new (domain, mono_defaults.field_info_class, 0); klass = startklass = mono_class_from_mono_type (type->type); refklass = mono_class_from_mono_type (reftype->type); mono_ptr_array_init (tmp_array, 2); handle_parent: if (klass->exception_type != MONO_EXCEPTION_NONE) mono_raise_exception (mono_class_get_exception_for_failure (klass)); iter = NULL; while ((field = mono_class_get_fields (klass, &iter))) { match = 0; if (mono_field_is_deleted (field)) continue; if ((field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK) == FIELD_ATTRIBUTE_PUBLIC) { if (bflags & BFLAGS_Public) match++; } else if ((klass == startklass) \|\| (field->type->attrs & FIELD_ATTRIBUTE_FIELD_ACCESS_MASK) != FIELD_ATTRIBUTE_PRIVATE) { if (bflags & BFLAGS_NonPublic) { match++; } } if (!match) continue; match = 0; if (field->type->attrs & FIELD_ATTRIBUTE_STATIC) { if (bflags & BFLAGS_Static) if ((bflags & BFLAGS_FlattenHierarchy) \|\| (klass == startklass)) match++; } else { if (bflags & BFLAGS_Instance) match++; } if (!match) continue; member = (MonoObject)mono_field_get_object (domain, refklass, field); mono_ptr_array_append (tmp_array, member); } if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent)) goto handle_parent; res = mono_array_new_cached (domain, mono_defaults.field_info_class, mono_ptr_array_size (tmp_array)); for (i = 0; i < mono_ptr_array_size (tmp_array); ++i) mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i)); mono_ptr_array_destroy (tmp_array); return res; } static gboolean method_nonpublic (MonoMethod method, gboolean start_klass) { switch (method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) { case METHOD_ATTRIBUTE_ASSEM: return (start_klass \|\| mono_defaults.generic_ilist_class); case METHOD_ATTRIBUTE_PRIVATE: return start_klass; case METHOD_ATTRIBUTE_PUBLIC: return FALSE; default: return TRUE; } } static MonoArray* ves_icall_Type_GetMethodsByName (MonoReflectionType type, MonoString name, guint32 bflags, MonoBoolean ignore_case, MonoReflectionType reftype) { static MonoClass MethodInfo_array; MonoDomain domain; MonoClass startklass, klass, refklass; MonoArray res; MonoMethod method; gpointer iter; MonoObject member; int i, len, match, nslots; /FIXME, use MonoBitSet/ guint32 method_slots_default [8]; guint32 method_slots = NULL; gchar mname = NULL; int (compare_func) (const char s1, const char s2) = NULL; MonoVTable array_vtable; MonoException ex; MonoPtrArray tmp_array; MONO_ARCH_SAVE_REGS; mono_ptr_array_init (tmp_array, 4); if (!MethodInfo_array) { MonoClass klass = mono_array_class_get (mono_defaults.method_info_class, 1); mono_memory_barrier (); MethodInfo_array = klass; } domain = ((MonoObject )type)->vtable->domain; array_vtable = mono_class_vtable_full (domain, MethodInfo_array, TRUE); if (type->type->byref) return mono_array_new_specific (array_vtable, 0); klass = startklass = mono_class_from_mono_type (type->type); refklass = mono_class_from_mono_type (reftype->type); len = 0; if (name != NULL) { mname = mono_string_to_utf8 (name); compare_func = (ignore_case) ? mono_utf8_strcasecmp : strcmp; } /* An optimization for calls made from Delegate:CreateDelegate () / if (klass->delegate && mname && !strcmp (mname, "Invoke") && (bflags == (BFLAGS_Public \| BFLAGS_Static \| BFLAGS_Instance))) { method = mono_get_delegate_invoke (klass); if (mono_loader_get_last_error ()) goto loader_error; member = (MonoObject)mono_method_get_object (domain, method, refklass); res = mono_array_new_specific (array_vtable, 1); mono_array_setref (res, 0, member); g_free (mname); return res; } mono_class_setup_vtable (klass); if (klass->exception_type != MONO_EXCEPTION_NONE \|\| mono_loader_get_last_error ()) goto loader_error; if (is_generic_parameter (type->type)) nslots = mono_class_get_vtable_size (klass->parent); else nslots = MONO_CLASS_IS_INTERFACE (klass) ? mono_class_num_methods (klass) : mono_class_get_vtable_size (klass); if (nslots >= sizeof (method_slots_default) * 8) { method_slots = g_new0 (guint32, nslots / 32 + 1); } else { method_slots = method_slots_default; memset (method_slots, 0, sizeof (method_slots_default)); } handle_parent: mono_class_setup_vtable (klass); if (klass->exception_type != MONO_EXCEPTION_NONE \|\| mono_loader_get_last_error ()) goto loader_error; iter = NULL; while ((method = mono_class_get_methods (klass, &iter))) { match = 0; if (method->slot != -1) { g_assert (method->slot < nslots); if (method_slots [method->slot >> 5] & (1 << (method->slot & 0x1f))) continue; if (!(method->flags & METHOD_ATTRIBUTE_NEW_SLOT)) method_slots [method->slot >> 5] \|= 1 << (method->slot & 0x1f); } if (method->name [0] == '.' && (strcmp (method->name, ".ctor") == 0 \|\| strcmp (method->name, ".cctor") == 0)) continue; if ((method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PUBLIC) { if (bflags & BFLAGS_Public) match++; } else if ((bflags & BFLAGS_NonPublic) && method_nonpublic (method, (klass == startklass))) { match++; } if (!match) continue; match = 0; if (method->flags & METHOD_ATTRIBUTE_STATIC) { if (bflags & BFLAGS_Static) if ((bflags & BFLAGS_FlattenHierarchy) \|\| (klass == startklass)) match++; } else { if (bflags & BFLAGS_Instance) match++; } if (!match) continue; if (name != NULL) { if (compare_func (mname, method->name)) continue; } match = 0; member = (MonoObject)mono_method_get_object (domain, method, refklass); mono_ptr_array_append (tmp_array, member); } if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent)) goto handle_parent; g_free (mname); if (method_slots != method_slots_default) g_free (method_slots); res = mono_array_new_specific (array_vtable, mono_ptr_array_size (tmp_array)); for (i = 0; i < mono_ptr_array_size (tmp_array); ++i) mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i)); mono_ptr_array_destroy (tmp_array); return res; loader_error: g_free (mname); if (method_slots != method_slots_default) g_free (method_slots); mono_ptr_array_destroy (tmp_array); if (klass->exception_type != MONO_EXCEPTION_NONE) { ex = mono_class_get_exception_for_failure (klass); } else { ex = mono_loader_error_prepare_exception (mono_loader_get_last_error ()); mono_loader_clear_error (); } mono_raise_exception (ex); return NULL; } static MonoArray ves_icall_Type_GetConstructors_internal (MonoReflectionType type, guint32 bflags, MonoReflectionType reftype) { MonoDomain domain; static MonoClass System_Reflection_ConstructorInfo; MonoClass startklass, klass, refklass; MonoArray res; MonoMethod method; MonoObject member; int i, match; gpointer iter = NULL; MonoPtrArray tmp_array; MONO_ARCH_SAVE_REGS; mono_ptr_array_init (tmp_array, 4); /FIXME, guestimating/ domain = ((MonoObject )type)->vtable->domain; if (type->type->byref) return mono_array_new_cached (domain, mono_defaults.method_info_class, 0); klass = startklass = mono_class_from_mono_type (type->type); refklass = mono_class_from_mono_type (reftype->type); if (klass->exception_type != MONO_EXCEPTION_NONE) mono_raise_exception (mono_class_get_exception_for_failure (klass)); if (!System_Reflection_ConstructorInfo) System_Reflection_ConstructorInfo = mono_class_from_name ( mono_defaults.corlib, "System.Reflection", "ConstructorInfo"); iter = NULL; while ((method = mono_class_get_methods (klass, &iter))) { match = 0; if (strcmp (method->name, ".ctor") && strcmp (method->name, ".cctor")) continue; if ((method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PUBLIC) { if (bflags & BFLAGS_Public) match++; } else { if (bflags & BFLAGS_NonPublic) match++; } if (!match) continue; match = 0; if (method->flags & METHOD_ATTRIBUTE_STATIC) { if (bflags & BFLAGS_Static) if ((bflags & BFLAGS_FlattenHierarchy) \|\| (klass == startklass)) match++; } else { if (bflags & BFLAGS_Instance) match++; } if (!match) continue; member = (MonoObject)mono_method_get_object (domain, method, refklass); mono_ptr_array_append (tmp_array, member); } res = mono_array_new_cached (domain, System_Reflection_ConstructorInfo, mono_ptr_array_size (tmp_array)); for (i = 0; i < mono_ptr_array_size (tmp_array); ++i) mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i)); mono_ptr_array_destroy (tmp_array); return res; } static guint property_hash (gconstpointer data) { MonoProperty prop = (MonoProperty)data; return g_str_hash (prop->name); } static gboolean property_equal (MonoProperty prop1, MonoProperty prop2) { // Properties are hide-by-name-and-signature if (!g_str_equal (prop1->name, prop2->name)) return FALSE; if (prop1->get && prop2->get && !mono_metadata_signature_equal (mono_method_signature (prop1->get), mono_method_signature (prop2->get))) return FALSE; if (prop1->set && prop2->set && !mono_metadata_signature_equal (mono_method_signature (prop1->set), mono_method_signature (prop2->set))) return FALSE; return TRUE; } static gboolean property_accessor_nonpublic (MonoMethod* accessor, gboolean start_klass) { if (!accessor) return FALSE; return method_nonpublic (accessor, start_klass); } static MonoArray* ves_icall_Type_GetPropertiesByName (MonoReflectionType type, MonoString name, guint32 bflags, MonoBoolean ignore_case, MonoReflectionType reftype) { MonoDomain domain; static MonoClass System_Reflection_PropertyInfo; MonoClass startklass, klass; MonoArray res; MonoMethod method; MonoProperty prop; int i, match; guint32 flags; gchar propname = NULL; int (compare_func) (const char s1, const char s2) = NULL; gpointer iter; GHashTable properties; MonoPtrArray tmp_array; MONO_ARCH_SAVE_REGS; mono_ptr_array_init (tmp_array, 8); /This the average for ASP.NET types/ if (!System_Reflection_PropertyInfo) System_Reflection_PropertyInfo = mono_class_from_name ( mono_defaults.corlib, "System.Reflection", "PropertyInfo"); domain = ((MonoObject )type)->vtable->domain; if (type->type->byref) return mono_array_new_cached (domain, System_Reflection_PropertyInfo, 0); klass = startklass = mono_class_from_mono_type (type->type); if (name != NULL) { propname = mono_string_to_utf8 (name); compare_func = (ignore_case) ? mono_utf8_strcasecmp : strcmp; } mono_class_setup_vtable (klass); properties = g_hash_table_new (property_hash, (GEqualFunc)property_equal); handle_parent: mono_class_setup_vtable (klass); if (klass->exception_type != MONO_EXCEPTION_NONE) { g_hash_table_destroy (properties); if (name != NULL) g_free (propname); mono_raise_exception (mono_class_get_exception_for_failure (klass)); } iter = NULL; while ((prop = mono_class_get_properties (klass, &iter))) { match = 0; method = prop->get; if (!method) method = prop->set; if (method) flags = method->flags; else flags = 0; if ((prop->get && ((prop->get->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PUBLIC)) \|\| (prop->set && ((prop->set->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PUBLIC))) { if (bflags & BFLAGS_Public) match++; } else if (bflags & BFLAGS_NonPublic) { if (property_accessor_nonpublic(prop->get, startklass == klass) \|\| property_accessor_nonpublic(prop->set, startklass == klass)) { match++; } } if (!match) continue; match = 0; if (flags & METHOD_ATTRIBUTE_STATIC) { if (bflags & BFLAGS_Static) if ((bflags & BFLAGS_FlattenHierarchy) \|\| (klass == startklass)) match++; } else { if (bflags & BFLAGS_Instance) match++; } if (!match) continue; match = 0; if (name != NULL) { if (compare_func (propname, prop->name)) continue; } if (g_hash_table_lookup (properties, prop)) continue; mono_ptr_array_append (tmp_array, mono_property_get_object (domain, startklass, prop)); g_hash_table_insert (properties, prop, prop); } if ((!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent))) goto handle_parent; g_hash_table_destroy (properties); g_free (propname); res = mono_array_new_cached (domain, System_Reflection_PropertyInfo, mono_ptr_array_size (tmp_array)); for (i = 0; i < mono_ptr_array_size (tmp_array); ++i) mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i)); mono_ptr_array_destroy (tmp_array); return res; } static MonoReflectionEvent * ves_icall_MonoType_GetEvent (MonoReflectionType type, MonoString name, guint32 bflags) { MonoDomain domain; MonoClass klass, startklass; gpointer iter; MonoEvent event; MonoMethod method; gchar event_name; int (compare_func) (const char s1, const char s2) = NULL; MONO_ARCH_SAVE_REGS; event_name = mono_string_to_utf8 (name); if (type->type->byref) return NULL; klass = startklass = mono_class_from_mono_type (type->type); domain = mono_object_domain (type); compare_func = (bflags & BFLAGS_IgnoreCase) ? mono_utf8_strcasecmp : strcmp; handle_parent: if (klass->exception_type != MONO_EXCEPTION_NONE) mono_raise_exception (mono_class_get_exception_for_failure (klass)); iter = NULL; while ((event = mono_class_get_events (klass, &iter))) { if (compare_func (event->name, event_name)) continue; method = event->add; if (!method) method = event->remove; if (!method) method = event->raise; if (method) { if ((method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PUBLIC) { if (!(bflags & BFLAGS_Public)) continue; } else { if (!(bflags & BFLAGS_NonPublic)) continue; if ((klass != startklass) && (method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PRIVATE) continue; } if (method->flags & METHOD_ATTRIBUTE_STATIC) { if (!(bflags & BFLAGS_Static)) continue; if (!(bflags & BFLAGS_FlattenHierarchy) && (klass != startklass)) continue; } else { if (!(bflags & BFLAGS_Instance)) continue; } } else if (!(bflags & BFLAGS_NonPublic)) continue; g_free (event_name); return mono_event_get_object (domain, startklass, event); } if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent)) goto handle_parent; g_free (event_name); return NULL; } static MonoArray ves_icall_Type_GetEvents_internal (MonoReflectionType type, guint32 bflags, MonoReflectionType reftype) { MonoDomain domain; static MonoClass System_Reflection_EventInfo; MonoClass startklass, klass; MonoArray res; MonoMethod method; MonoEvent event; int i, match; gpointer iter; MonoPtrArray tmp_array; MONO_ARCH_SAVE_REGS; mono_ptr_array_init (tmp_array, 4); if (!System_Reflection_EventInfo) System_Reflection_EventInfo = mono_class_from_name ( mono_defaults.corlib, "System.Reflection", "EventInfo"); domain = mono_object_domain (type); if (type->type->byref) return mono_array_new_cached (domain, System_Reflection_EventInfo, 0); klass = startklass = mono_class_from_mono_type (type->type); handle_parent: if (klass->exception_type != MONO_EXCEPTION_NONE) mono_raise_exception (mono_class_get_exception_for_failure (klass)); iter = NULL; while ((event = mono_class_get_events (klass, &iter))) { match = 0; method = event->add; if (!method) method = event->remove; if (!method) method = event->raise; if (method) { if ((method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) == METHOD_ATTRIBUTE_PUBLIC) { if (bflags & BFLAGS_Public) match++; } else if ((klass == startklass) \|\| (method->flags & METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK) != METHOD_ATTRIBUTE_PRIVATE) { if (bflags & BFLAGS_NonPublic) match++; } } else if (bflags & BFLAGS_NonPublic) match ++; if (!match) continue; match = 0; if (method) { if (method->flags & METHOD_ATTRIBUTE_STATIC) { if (bflags & BFLAGS_Static) if ((bflags & BFLAGS_FlattenHierarchy) \|\| (klass == startklass)) match++; } else { if (bflags & BFLAGS_Instance) match++; } } else if (bflags & BFLAGS_Instance) match ++; if (!match) continue; mono_ptr_array_append (tmp_array, mono_event_get_object (domain, startklass, event)); } if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent)) goto handle_parent; res = mono_array_new_cached (domain, System_Reflection_EventInfo, mono_ptr_array_size (tmp_array)); for (i = 0; i < mono_ptr_array_size (tmp_array); ++i) mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i)); mono_ptr_array_destroy (tmp_array); return res; } static MonoReflectionType ves_icall_Type_GetNestedType (MonoReflectionType type, MonoString name, guint32 bflags) { MonoDomain domain; MonoClass klass; MonoClass nested; char str; gpointer iter; MONO_ARCH_SAVE_REGS; if (name == NULL) mono_raise_exception (mono_get_exception_argument_null ("name")); domain = ((MonoObject )type)->vtable->domain; if (type->type->byref) return NULL; klass = mono_class_from_mono_type (type->type); str = mono_string_to_utf8 (name); handle_parent: if (klass->exception_type != MONO_EXCEPTION_NONE) mono_raise_exception (mono_class_get_exception_for_failure (klass)); / * If a nested type is generic, return its generic type definition. * Note that this means that the return value is essentially a * nested type of the generic type definition of @klass. * * A note in MSDN claims that a generic type definition can have * nested types that aren't generic. In any case, the container of that * nested type would be the generic type definition. / if (klass->generic_class) klass = klass->generic_class->container_class; iter = NULL; while ((nested = mono_class_get_nested_types (klass, &iter))) { int match = 0; if ((nested->flags & TYPE_ATTRIBUTE_VISIBILITY_MASK) == TYPE_ATTRIBUTE_NESTED_PUBLIC) { if (bflags & BFLAGS_Public) match++; } else { if (bflags & BFLAGS_NonPublic) match++; } if (!match) continue; if (strcmp (nested->name, str) == 0){ g_free (str); return mono_type_get_object (domain, &nested->byval_arg); } } if (!(bflags & BFLAGS_DeclaredOnly) && (klass = klass->parent)) goto handle_parent; g_free (str); return NULL; } static MonoArray ves_icall_Type_GetNestedTypes (MonoReflectionType type, guint32 bflags) { MonoDomain domain; MonoClass klass; MonoArray res; MonoObject member; int i, match; MonoClass nested; gpointer iter; MonoPtrArray tmp_array; MONO_ARCH_SAVE_REGS; domain = ((MonoObject )type)->vtable->domain; if (type->type->byref) return mono_array_new (domain, mono_defaults.monotype_class, 0); klass = mono_class_from_mono_type (type->type); if (klass->exception_type != MONO_EXCEPTION_NONE) mono_raise_exception (mono_class_get_exception_for_failure (klass)); / * If a nested type is generic, return its generic type definition. * Note that this means that the return value is essentially the set * of nested types of the generic type definition of @klass. * * A note in MSDN claims that a generic type definition can have * nested types that aren't generic. In any case, the container of that * nested type would be the generic type definition. / if (klass->generic_class) klass = klass->generic_class->container_class; mono_ptr_array_init (tmp_array, 1); iter = NULL; while ((nested = mono_class_get_nested_types (klass, &iter))) { match = 0; if ((nested->flags & TYPE_ATTRIBUTE_VISIBILITY_MASK) == TYPE_ATTRIBUTE_NESTED_PUBLIC) { if (bflags & BFLAGS_Public) match++; } else { if (bflags & BFLAGS_NonPublic) match++; } if (!match) continue; member = (MonoObject)mono_type_get_object (domain, &nested->byval_arg); mono_ptr_array_append (tmp_array, member); } res = mono_array_new_cached (domain, mono_defaults.monotype_class, mono_ptr_array_size (tmp_array)); for (i = 0; i < mono_ptr_array_size (tmp_array); ++i) mono_array_setref (res, i, mono_ptr_array_get (tmp_array, i)); mono_ptr_array_destroy (tmp_array); return res; } static MonoReflectionType* ves_icall_System_Reflection_Assembly_InternalGetType (MonoReflectionAssembly assembly, MonoReflectionModule module, MonoString name, MonoBoolean throwOnError, MonoBoolean ignoreCase) { gchar str; MonoType type = NULL; MonoTypeNameParse info; gboolean type_resolve; MONO_ARCH_SAVE_REGS; / On MS.NET, this does not fire a TypeResolve event / type_resolve = TRUE; str = mono_string_to_utf8 (name); /g_print ("requested type %s in %s\n", str, assembly->assembly->aname.name);/ if (!mono_reflection_parse_type (str, &info)) { g_free (str); mono_reflection_free_type_info (&info); if (throwOnError) / uhm: this is a parse error, though... / mono_raise_exception (mono_get_exception_type_load (name, NULL)); /g_print ("failed parse\n");/ return NULL; } if (info.assembly.name) { g_free (str); mono_reflection_free_type_info (&info); if (throwOnError) { / 1.0 and 2.0 throw different exceptions / if (mono_defaults.generic_ilist_class) mono_raise_exception (mono_get_exception_argument (NULL, "Type names passed to Assembly.GetType() must not specify an assembly.")); else mono_raise_exception (mono_get_exception_type_load (name, NULL)); } return NULL; } if (module != NULL) { if (module->image) type = mono_reflection_get_type (module->image, &info, ignoreCase, &type_resolve); else type = NULL; } else if (assembly->assembly->dynamic) { / Enumerate all modules / MonoReflectionAssemblyBuilder abuilder = (MonoReflectionAssemblyBuilder)assembly; int i; type = NULL; if (abuilder->modules) { for (i = 0; i < mono_array_length (abuilder->modules); ++i) { MonoReflectionModuleBuilder mb = mono_array_get (abuilder->modules, MonoReflectionModuleBuilder, i); type = mono_reflection_get_type (&mb->dynamic_image->image, &info, ignoreCase, &type_resolve); if (type) break; } } if (!type && abuilder->loaded_modules) { for (i = 0; i < mono_array_length (abuilder->loaded_modules); ++i) { MonoReflectionModule mod = mono_array_get (abuilder->loaded_modules, MonoReflectionModule, i); type = mono_reflection_get_type (mod->image, &info, ignoreCase, &type_resolve); if (type) break; } } } else type = mono_reflection_get_type (assembly->assembly->image, &info, ignoreCase, &type_resolve); g_free (str); mono_reflection_free_type_info (&info); if (!type) { MonoException e = NULL; if (throwOnError) e = mono_get_exception_type_load (name, NULL); if (mono_loader_get_last_error () && mono_defaults.generic_ilist_class) e = mono_loader_error_prepare_exception (mono_loader_get_last_error ()); mono_loader_clear_error (); if (e != NULL) mono_raise_exception (e); return NULL; } if (type->type == MONO_TYPE_CLASS) { MonoClass klass = mono_type_get_class (type); if (mono_is_security_manager_active () && !klass->exception_type) / Some security problems are detected during generic vtable construction / mono_class_setup_vtable (klass); / need to report exceptions ? / if (throwOnError && klass->exception_type) { / report SecurityException (or others) that occured when loading the assembly / MonoException exc = mono_class_get_exception_for_failure (klass); mono_loader_clear_error (); mono_raise_exception (exc); } else if (klass->exception_type == MONO_EXCEPTION_SECURITY_INHERITANCEDEMAND) { return NULL; } } /* g_print ("got it\n"); / return mono_type_get_object (mono_object_domain (assembly), type); } static gboolean replace_shadow_path (MonoDomain domain, gchar dirname, gchar filename) { gchar content; gchar shadow_ini_file; gsize len; / Check for shadow-copied assembly / if (mono_is_shadow_copy_enabled (domain, dirname)) { shadow_ini_file = g_build_filename (dirname, "__AssemblyInfo__.ini", NULL); content = NULL; if (!g_file_get_contents (shadow_ini_file, &content, &len, NULL) \|\| !g_file_test (content, G_FILE_TEST_IS_REGULAR)) { if (content) { g_free (content); content = NULL; } } g_free (shadow_ini_file); if (content != NULL) { if (filename) g_free (filename); filename = content; return TRUE; } } return FALSE; } static MonoString * ves_icall_System_Reflection_Assembly_get_code_base (MonoReflectionAssembly assembly, MonoBoolean escaped) { MonoDomain domain = mono_object_domain (assembly); MonoAssembly mass = assembly->assembly; MonoString res = NULL; gchar uri; gchar absolute; gchar dirname; MONO_ARCH_SAVE_REGS; if (g_path_is_absolute (mass->image->name)) { absolute = g_strdup (mass->image->name); dirname = g_path_get_dirname (absolute); } else { absolute = g_build_filename (mass->basedir, mass->image->name, NULL); dirname = g_strdup (mass->basedir); } replace_shadow_path (domain, dirname, &absolute); g_free (dirname); #if PLATFORM_WIN32 { gint i; for (i = strlen (absolute) - 1; i >= 0; i--) if (absolute [i] == '\\') absolute [i] = '/'; } #endif if (escaped) { uri = g_filename_to_uri (absolute, NULL, NULL); } else { const char prepend = "file://"; #if PLATFORM_WIN32 if (absolute == '/' && (absolute + 1) == '/') { prepend = "file:"; } else { prepend = "file:///"; } #endif uri = g_strconcat (prepend, absolute, NULL); } if (uri) { res = mono_string_new (domain, uri); g_free (uri); } g_free (absolute); return res; } static MonoBoolean ves_icall_System_Reflection_Assembly_get_global_assembly_cache (MonoReflectionAssembly assembly) { MonoAssembly mass = assembly->assembly; MONO_ARCH_SAVE_REGS; return mass->in_gac; } static MonoReflectionAssembly* ves_icall_System_Reflection_Assembly_load_with_partial_name (MonoString mname, MonoObject evidence) { gchar name; MonoAssembly res; MonoImageOpenStatus status; MONO_ARCH_SAVE_REGS; name = mono_string_to_utf8 (mname); res = mono_assembly_load_with_partial_name (name, &status); g_free (name); if (res == NULL) return NULL; return mono_assembly_get_object (mono_domain_get (), res); } static MonoString * ves_icall_System_Reflection_Assembly_get_location (MonoReflectionAssembly assembly) { MonoDomain domain = mono_object_domain (assembly); MonoString res; MONO_ARCH_SAVE_REGS; res = mono_string_new (domain, mono_image_get_filename (assembly->assembly->image)); return res; } static MonoBoolean ves_icall_System_Reflection_Assembly_get_ReflectionOnly (MonoReflectionAssembly assembly) { MONO_ARCH_SAVE_REGS; return assembly->assembly->ref_only; } static MonoString * ves_icall_System_Reflection_Assembly_InternalImageRuntimeVersion (MonoReflectionAssembly assembly) { MonoDomain domain = mono_object_domain (assembly); MONO_ARCH_SAVE_REGS; return mono_string_new (domain, assembly->assembly->image->version); } static MonoReflectionMethod* ves_icall_System_Reflection_Assembly_get_EntryPoint (MonoReflectionAssembly assembly) { guint32 token = mono_image_get_entry_point (assembly->assembly->image); MONO_ARCH_SAVE_REGS; if (!token) return NULL; return mono_method_get_object (mono_object_domain (assembly), mono_get_method (assembly->assembly->image, token, NULL), NULL); } static MonoReflectionModule ves_icall_System_Reflection_Assembly_GetManifestModuleInternal (MonoReflectionAssembly assembly) { return mono_module_get_object (mono_object_domain (assembly), assembly->assembly->image); } static MonoArray ves_icall_System_Reflection_Assembly_GetManifestResourceNames (MonoReflectionAssembly assembly) { MonoTableInfo table = &assembly->assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE]; MonoArray result = mono_array_new (mono_object_domain (assembly), mono_defaults.string_class, table->rows); int i; const char val; MONO_ARCH_SAVE_REGS; for (i = 0; i < table->rows; ++i) { val = mono_metadata_string_heap (assembly->assembly->image, mono_metadata_decode_row_col (table, i, MONO_MANIFEST_NAME)); mono_array_setref (result, i, mono_string_new (mono_object_domain (assembly), val)); } return result; } static MonoObject* create_version (MonoDomain domain, guint32 major, guint32 minor, guint32 build, guint32 revision) { static MonoClass System_Version = NULL; static MonoMethod create_version = NULL; MonoObject result; gpointer args [4]; if (!System_Version) { System_Version = mono_class_from_name (mono_defaults.corlib, "System", "Version"); g_assert (System_Version); } if (!create_version) { MonoMethodDesc desc = mono_method_desc_new (":.ctor(int,int,int,int)", FALSE); create_version = mono_method_desc_search_in_class (desc, System_Version); g_assert (create_version); mono_method_desc_free (desc); } args [0] = &major; args [1] = &minor; args [2] = &build; args [3] = &revision; result = mono_object_new (domain, System_Version); mono_runtime_invoke (create_version, result, args, NULL); return result; } static MonoArray ves_icall_System_Reflection_Assembly_GetReferencedAssemblies (MonoReflectionAssembly assembly) { static MonoClass System_Reflection_AssemblyName; MonoArray result; MonoDomain domain = mono_object_domain (assembly); int i, count = 0; static MonoMethod create_culture = NULL; MonoImage image = assembly->assembly->image; MonoTableInfo t; MONO_ARCH_SAVE_REGS; if (!System_Reflection_AssemblyName) System_Reflection_AssemblyName = mono_class_from_name ( mono_defaults.corlib, "System.Reflection", "AssemblyName"); t = &assembly->assembly->image->tables [MONO_TABLE_ASSEMBLYREF]; count = t->rows; result = mono_array_new (domain, System_Reflection_AssemblyName, count); if (count > 0 && !create_culture) { MonoMethodDesc desc = mono_method_desc_new ( "System.Globalization.CultureInfo:CreateCulture(string,bool)", TRUE); create_culture = mono_method_desc_search_in_image (desc, mono_defaults.corlib); g_assert (create_culture); mono_method_desc_free (desc); } for (i = 0; i < count; i++) { MonoReflectionAssemblyName aname; guint32 cols [MONO_ASSEMBLYREF_SIZE]; mono_metadata_decode_row (t, i, cols, MONO_ASSEMBLYREF_SIZE); aname = (MonoReflectionAssemblyName ) mono_object_new ( domain, System_Reflection_AssemblyName); MONO_OBJECT_SETREF (aname, name, mono_string_new (domain, mono_metadata_string_heap (image, cols [MONO_ASSEMBLYREF_NAME]))); aname->major = cols [MONO_ASSEMBLYREF_MAJOR_VERSION]; aname->minor = cols [MONO_ASSEMBLYREF_MINOR_VERSION]; aname->build = cols [MONO_ASSEMBLYREF_BUILD_NUMBER]; aname->revision = cols [MONO_ASSEMBLYREF_REV_NUMBER]; aname->flags = cols [MONO_ASSEMBLYREF_FLAGS]; aname->versioncompat = 1; /* SameMachine (default) / aname->hashalg = ASSEMBLY_HASH_SHA1; / SHA1 (default) / MONO_OBJECT_SETREF (aname, version, create_version (domain, aname->major, aname->minor, aname->build, aname->revision)); if (create_culture) { gpointer args [2]; MonoBoolean assembly_ref = 1; args [0] = mono_string_new (domain, mono_metadata_string_heap (image, cols [MONO_ASSEMBLYREF_CULTURE])); args [1] = &assembly_ref; MONO_OBJECT_SETREF (aname, cultureInfo, mono_runtime_invoke (create_culture, NULL, args, NULL)); } if (cols [MONO_ASSEMBLYREF_PUBLIC_KEY]) { const gchar pkey_ptr = mono_metadata_blob_heap (image, cols [MONO_ASSEMBLYREF_PUBLIC_KEY]); guint32 pkey_len = mono_metadata_decode_blob_size (pkey_ptr, &pkey_ptr); if ((cols [MONO_ASSEMBLYREF_FLAGS] & ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG)) { /* public key token isn't copied - the class library will automatically generate it from the public key if required / MONO_OBJECT_SETREF (aname, publicKey, mono_array_new (domain, mono_defaults.byte_class, pkey_len)); memcpy (mono_array_addr (aname->publicKey, guint8, 0), pkey_ptr, pkey_len); } else { MONO_OBJECT_SETREF (aname, keyToken, mono_array_new (domain, mono_defaults.byte_class, pkey_len)); memcpy (mono_array_addr (aname->keyToken, guint8, 0), pkey_ptr, pkey_len); } } else { MONO_OBJECT_SETREF (aname, keyToken, mono_array_new (domain, mono_defaults.byte_class, 0)); } / note: this function doesn't return the codebase on purpose (i.e. it can be used under partial trust as path information isn't present). / mono_array_setref (result, i, aname); } return result; } typedef struct { MonoArray res; int idx; } NameSpaceInfo; static void foreach_namespace (const char* key, gconstpointer val, NameSpaceInfo info) { MonoString name = mono_string_new (mono_object_domain (info->res), key); mono_array_setref (info->res, info->idx, name); info->idx++; } static MonoArray* ves_icall_System_Reflection_Assembly_GetNamespaces (MonoReflectionAssembly assembly) { MonoImage img = assembly->assembly->image; MonoArray res; NameSpaceInfo info; int len; MONO_ARCH_SAVE_REGS; mono_image_lock (img); mono_image_init_name_cache (img); RETRY_LEN: len = g_hash_table_size (img->name_cache); mono_image_unlock (img); /we can't create objects holding the image lock / res = mono_array_new (mono_object_domain (assembly), mono_defaults.string_class, len); mono_image_lock (img); /len might have changed, create a new array/ if (len != g_hash_table_size (img->name_cache)) goto RETRY_LEN; info.res = res; info.idx = 0; g_hash_table_foreach (img->name_cache, (GHFunc)foreach_namespace, &info); mono_image_unlock (img); return res; } / move this in some file in mono/util/ / static char g_concat_dir_and_file (const char dir, const char file) { g_return_val_if_fail (dir != NULL, NULL); g_return_val_if_fail (file != NULL, NULL); /* * If the directory name doesn't have a / on the end, we need * to add one so we get a proper path to the file / if (dir [strlen(dir) - 1] != G_DIR_SEPARATOR) return g_strconcat (dir, G_DIR_SEPARATOR_S, file, NULL); else return g_strconcat (dir, file, NULL); } static void ves_icall_System_Reflection_Assembly_GetManifestResourceInternal (MonoReflectionAssembly assembly, MonoString name, gint32 size, MonoReflectionModule ref_module) { char n = mono_string_to_utf8 (name); MonoTableInfo table = &assembly->assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE]; guint32 i; guint32 cols [MONO_MANIFEST_SIZE]; guint32 impl, file_idx; const char val; MonoImage module; MONO_ARCH_SAVE_REGS; for (i = 0; i < table->rows; ++i) { mono_metadata_decode_row (table, i, cols, MONO_MANIFEST_SIZE); val = mono_metadata_string_heap (assembly->assembly->image, cols [MONO_MANIFEST_NAME]); if (strcmp (val, n) == 0) break; } g_free (n); if (i == table->rows) return NULL; / FIXME / impl = cols [MONO_MANIFEST_IMPLEMENTATION]; if (impl) { / * this code should only be called after obtaining the * ResourceInfo and handling the other cases. / g_assert ((impl & MONO_IMPLEMENTATION_MASK) == MONO_IMPLEMENTATION_FILE); file_idx = impl >> MONO_IMPLEMENTATION_BITS; module = mono_image_load_file_for_image (assembly->assembly->image, file_idx); if (!module) return NULL; } else module = assembly->assembly->image; mono_gc_wbarrier_generic_store (ref_module, (MonoObject) mono_module_get_object (mono_domain_get (), module)); return (void)mono_image_get_resource (module, cols [MONO_MANIFEST_OFFSET], (guint32)size); } static gboolean ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (MonoReflectionAssembly assembly, MonoString name, MonoManifestResourceInfo info) { MonoTableInfo table = &assembly->assembly->image->tables [MONO_TABLE_MANIFESTRESOURCE]; int i; guint32 cols [MONO_MANIFEST_SIZE]; guint32 file_cols [MONO_FILE_SIZE]; const char val; char n; MONO_ARCH_SAVE_REGS; n = mono_string_to_utf8 (name); for (i = 0; i < table->rows; ++i) { mono_metadata_decode_row (table, i, cols, MONO_MANIFEST_SIZE); val = mono_metadata_string_heap (assembly->assembly->image, cols [MONO_MANIFEST_NAME]); if (strcmp (val, n) == 0) break; } g_free (n); if (i == table->rows) return FALSE; if (!cols [MONO_MANIFEST_IMPLEMENTATION]) { info->location = RESOURCE_LOCATION_EMBEDDED \| RESOURCE_LOCATION_IN_MANIFEST; } else { switch (cols [MONO_MANIFEST_IMPLEMENTATION] & MONO_IMPLEMENTATION_MASK) { case MONO_IMPLEMENTATION_FILE: i = cols [MONO_MANIFEST_IMPLEMENTATION] >> MONO_IMPLEMENTATION_BITS; table = &assembly->assembly->image->tables [MONO_TABLE_FILE]; mono_metadata_decode_row (table, i - 1, file_cols, MONO_FILE_SIZE); val = mono_metadata_string_heap (assembly->assembly->image, file_cols [MONO_FILE_NAME]); MONO_OBJECT_SETREF (info, filename, mono_string_new (mono_object_domain (assembly), val)); if (file_cols [MONO_FILE_FLAGS] && FILE_CONTAINS_NO_METADATA) info->location = 0; else info->location = RESOURCE_LOCATION_EMBEDDED; break; case MONO_IMPLEMENTATION_ASSEMBLYREF: i = cols [MONO_MANIFEST_IMPLEMENTATION] >> MONO_IMPLEMENTATION_BITS; mono_assembly_load_reference (assembly->assembly->image, i - 1); if (assembly->assembly->image->references [i - 1] == (gpointer)-1) { char msg = g_strdup_printf ("Assembly %d referenced from assembly %s not found ", i - 1, assembly->assembly->image->name); MonoException ex = mono_get_exception_file_not_found2 (msg, NULL); g_free (msg); mono_raise_exception (ex); } MONO_OBJECT_SETREF (info, assembly, mono_assembly_get_object (mono_domain_get (), assembly->assembly->image->references [i - 1])); /* Obtain info recursively / ves_icall_System_Reflection_Assembly_GetManifestResourceInfoInternal (info->assembly, name, info); info->location \|= RESOURCE_LOCATION_ANOTHER_ASSEMBLY; break; case MONO_IMPLEMENTATION_EXP_TYPE: g_assert_not_reached (); break; } } return TRUE; } static MonoObject ves_icall_System_Reflection_Assembly_GetFilesInternal (MonoReflectionAssembly assembly, MonoString name, MonoBoolean resource_modules) { MonoTableInfo table = &assembly->assembly->image->tables [MONO_TABLE_FILE]; MonoArray result = NULL; int i, count; const char val; char n; MONO_ARCH_SAVE_REGS; /* check hash if needed / if (name) { n = mono_string_to_utf8 (name); for (i = 0; i < table->rows; ++i) { val = mono_metadata_string_heap (assembly->assembly->image, mono_metadata_decode_row_col (table, i, MONO_FILE_NAME)); if (strcmp (val, n) == 0) { MonoString fn; g_free (n); n = g_concat_dir_and_file (assembly->assembly->basedir, val); fn = mono_string_new (mono_object_domain (assembly), n); g_free (n); return (MonoObject)fn; } } g_free (n); return NULL; } count = 0; for (i = 0; i < table->rows; ++i) { if (resource_modules \|\| !(mono_metadata_decode_row_col (table, i, MONO_FILE_FLAGS) & FILE_CONTAINS_NO_METADATA)) count ++; } result = mono_array_new (mono_object_domain (assembly), mono_defaults.string_class, count); count = 0; for (i = 0; i < table->rows; ++i) { if (resource_modules \|\| !(mono_metadata_decode_row_col (table, i, MONO_FILE_FLAGS) & FILE_CONTAINS_NO_METADATA)) { val = mono_metadata_string_heap (assembly->assembly->image, mono_metadata_decode_row_col (table, i, MONO_FILE_NAME)); n = g_concat_dir_and_file (assembly->assembly->basedir, val); mono_array_setref (result, count, mono_string_new (mono_object_domain (assembly), n)); g_free (n); count ++; } } return (MonoObject)result; } static MonoArray* ves_icall_System_Reflection_Assembly_GetModulesInternal (MonoReflectionAssembly assembly) { MonoDomain domain = mono_domain_get(); MonoArray res; MonoClass klass; int i, j, file_count = 0; MonoImage *modules; guint32 module_count, real_module_count; MonoTableInfo table; guint32 cols [MONO_FILE_SIZE]; MonoImage image = assembly->assembly->image; g_assert (image != NULL); g_assert (!assembly->assembly->dynamic); table = &image->tables [MONO_TABLE_FILE]; file_count = table->rows; modules = image->modules; module_count = image->module_count; real_module_count = 0; for (i = 0; i < module_count; ++i) if (modules [i]) real_module_count ++; klass = mono_class_from_name (mono_defaults.corlib, "System.Reflection", "Module"); res = mono_array_new (domain, klass, 1 + real_module_count + file_count); mono_array_setref (res, 0, mono_module_get_object (domain, image)); j = 1; for (i = 0; i < module_count; ++i) if (modules [i]) { mono_array_setref (res, j, mono_module_get_object (domain, modules[i])); ++j; } for (i = 0; i < file_count; ++i, ++j) { mono_metadata_decode_row (table, i, cols, MONO_FILE_SIZE); if (cols [MONO_FILE_FLAGS] && FILE_CONTAINS_NO_METADATA) mono_array_setref (res, j, mono_module_file_get_object (domain, image, i)); else { MonoImage m = mono_image_load_file_for_image (image, i + 1); if (!m) { MonoString fname = mono_string_new (mono_domain_get (), mono_metadata_string_heap (image, cols [MONO_FILE_NAME])); mono_raise_exception (mono_get_exception_file_not_found2 (NULL, fname)); } mono_array_setref (res, j, mono_module_get_object (domain, m)); } } return res; } static MonoReflectionMethod ves_icall_GetCurrentMethod (void) { MonoMethod m = mono_method_get_last_managed (); MONO_ARCH_SAVE_REGS; return mono_method_get_object (mono_domain_get (), m, NULL); } static MonoMethod mono_method_get_equivalent_method (MonoMethod method, MonoClass klass) { int offset = -1, i; if (method->is_inflated && ((MonoMethodInflated)method)->context.method_inst) { MonoMethodInflated inflated = (MonoMethodInflated)method; //method is inflated, we should inflate it on the other class MonoGenericContext ctx; ctx.method_inst = inflated->context.method_inst; ctx.class_inst = inflated->context.class_inst; if (klass->generic_class) ctx.class_inst = klass->generic_class->context.class_inst; else if (klass->generic_container) ctx.class_inst = klass->generic_container->context.class_inst; return mono_class_inflate_generic_method_full (inflated->declaring, klass, &ctx); } mono_class_setup_methods (method->klass); if (method->klass->exception_type) return NULL; for (i = 0; i < method->klass->method.count; ++i) { if (method->klass->methods [i] == method) { offset = i; break; } } mono_class_setup_methods (klass); if (klass->exception_type) return NULL; g_assert (offset >= 0 && offset < klass->method.count); return klass->methods [offset]; } static MonoReflectionMethod ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternalType (MonoMethod method, MonoType type) { MonoClass klass; if (type) { klass = mono_class_from_mono_type (type); if (mono_class_get_generic_type_definition (method->klass) != mono_class_get_generic_type_definition (klass)) return NULL; if (method->klass != klass) { method = mono_method_get_equivalent_method (method, klass); if (!method) return NULL; } } else klass = method->klass; return mono_method_get_object (mono_domain_get (), method, klass); } static MonoReflectionMethod ves_icall_System_Reflection_MethodBase_GetMethodFromHandleInternal (MonoMethod method) { return mono_method_get_object (mono_domain_get (), method, NULL); } static MonoReflectionMethodBody ves_icall_System_Reflection_MethodBase_GetMethodBodyInternal (MonoMethod method) { return mono_method_body_get_object (mono_domain_get (), method); } static MonoReflectionAssembly ves_icall_System_Reflection_Assembly_GetExecutingAssembly (void) { MonoMethod dest = NULL; MONO_ARCH_SAVE_REGS; mono_stack_walk_no_il (get_executing, &dest); return mono_assembly_get_object (mono_domain_get (), dest->klass->image->assembly); } static MonoReflectionAssembly ves_icall_System_Reflection_Assembly_GetEntryAssembly (void) { MonoDomain* domain = mono_domain_get (); MONO_ARCH_SAVE_REGS; if (!domain->entry_assembly) return NULL; return mono_assembly_get_object (domain, domain->entry_assembly); } static MonoReflectionAssembly* ves_icall_System_Reflection_Assembly_GetCallingAssembly (void) { MonoMethod m; MonoMethod dest; MONO_ARCH_SAVE_REGS; dest = NULL; mono_stack_walk_no_il (get_executing, &dest); m = dest; mono_stack_walk_no_il (get_caller, &dest); if (!dest) dest = m; return mono_assembly_get_object (mono_domain_get (), dest->klass->image->assembly); } static MonoString * ves_icall_System_MonoType_getFullName (MonoReflectionType object, gboolean full_name, gboolean assembly_qualified) { MonoDomain domain = mono_object_domain (object); MonoTypeNameFormat format; MonoString res; gchar name; MONO_ARCH_SAVE_REGS; if (full_name) format = assembly_qualified ? MONO_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED : MONO_TYPE_NAME_FORMAT_FULL_NAME; else format = MONO_TYPE_NAME_FORMAT_REFLECTION; name = mono_type_get_name_full (object->type, format); if (!name) return NULL; if (full_name && (object->type->type == MONO_TYPE_VAR \|\| object->type->type == MONO_TYPE_MVAR)) { g_free (name); return NULL; } res = mono_string_new (domain, name); g_free (name); return res; } static void fill_reflection_assembly_name (MonoDomain domain, MonoReflectionAssemblyName aname, MonoAssemblyName name, const char absolute, gboolean by_default_version, gboolean default_publickey, gboolean default_token) { static MonoMethod create_culture = NULL; gpointer args [2]; guint32 pkey_len; const char pkey_ptr; gchar codebase; MonoBoolean assembly_ref = 0; MONO_ARCH_SAVE_REGS; MONO_OBJECT_SETREF (aname, name, mono_string_new (domain, name->name)); aname->major = name->major; aname->minor = name->minor; aname->build = name->build; aname->flags = name->flags; aname->revision = name->revision; aname->hashalg = name->hash_alg; aname->versioncompat = 1; / SameMachine (default) / if (by_default_version) MONO_OBJECT_SETREF (aname, version, create_version (domain, name->major, name->minor, name->build, name->revision)); codebase = NULL; if (absolute != NULL && absolute != '\0') { const gchar prepend = "file://"; gchar result; codebase = g_strdup (absolute); #if PLATFORM_WIN32 { gint i; for (i = strlen (codebase) - 1; i >= 0; i--) if (codebase [i] == '\\') codebase [i] = '/'; if (codebase == '/' && (codebase + 1) == '/') { prepend = "file:"; } else { prepend = "file:///"; } } #endif result = g_strconcat (prepend, codebase, NULL); g_free (codebase); codebase = result; } if (codebase) { MONO_OBJECT_SETREF (aname, codebase, mono_string_new (domain, codebase)); g_free (codebase); } if (!create_culture) { MonoMethodDesc desc = mono_method_desc_new ("System.Globalization.CultureInfo:CreateCulture(string,bool)", TRUE); create_culture = mono_method_desc_search_in_image (desc, mono_defaults.corlib); g_assert (create_culture); mono_method_desc_free (desc); } if (name->culture) { args [0] = mono_string_new (domain, name->culture); args [1] = &assembly_ref; MONO_OBJECT_SETREF (aname, cultureInfo, mono_runtime_invoke (create_culture, NULL, args, NULL)); } if (name->public_key) { pkey_ptr = (char)name->public_key; pkey_len = mono_metadata_decode_blob_size (pkey_ptr, &pkey_ptr); MONO_OBJECT_SETREF (aname, publicKey, mono_array_new (domain, mono_defaults.byte_class, pkey_len)); memcpy (mono_array_addr (aname->publicKey, guint8, 0), pkey_ptr, pkey_len); aname->flags \|= ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG; } else if (default_publickey) { MONO_OBJECT_SETREF (aname, publicKey, mono_array_new (domain, mono_defaults.byte_class, 0)); aname->flags \|= ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG; } /* MonoAssemblyName keeps the public key token as an hexadecimal string / if (name->public_key_token [0]) { int i, j; char p; MONO_OBJECT_SETREF (aname, keyToken, mono_array_new (domain, mono_defaults.byte_class, 8)); p = mono_array_addr (aname->keyToken, char, 0); for (i = 0, j = 0; i < 8; i++) { p = g_ascii_xdigit_value (name->public_key_token [j++]) << 4; p \|= g_ascii_xdigit_value (name->public_key_token [j++]); p++; } } else if (default_token) { MONO_OBJECT_SETREF (aname, keyToken, mono_array_new (domain, mono_defaults.byte_class, 0)); } } static MonoString * ves_icall_System_Reflection_Assembly_get_fullName (MonoReflectionAssembly assembly) { MonoDomain domain = mono_object_domain (assembly); MonoAssembly mass = assembly->assembly; MonoString res; gchar name; name = g_strdup_printf ( "%s, Version=%d.%d.%d.%d, Culture=%s, PublicKeyToken=%s%s", mass->aname.name, mass->aname.major, mass->aname.minor, mass->aname.build, mass->aname.revision, mass->aname.culture && mass->aname.culture? mass->aname.culture: "neutral", mass->aname.public_key_token [0] ? (char )mass->aname.public_key_token : "null", (mass->aname.flags & ASSEMBLYREF_RETARGETABLE_FLAG) ? ", Retargetable=Yes" : ""); res = mono_string_new (domain, name); g_free (name); return res; } static void ves_icall_System_Reflection_Assembly_FillName (MonoReflectionAssembly assembly, MonoReflectionAssemblyName aname) { gchar absolute; MonoAssembly mass = assembly->assembly; MONO_ARCH_SAVE_REGS; if (g_path_is_absolute (mass->image->name)) { fill_reflection_assembly_name (mono_object_domain (assembly), aname, &mass->aname, mass->image->name, TRUE, TRUE, mono_framework_version () >= 2); return; } absolute = g_build_filename (mass->basedir, mass->image->name, NULL); fill_reflection_assembly_name (mono_object_domain (assembly), aname, &mass->aname, absolute, TRUE, TRUE, mono_framework_version () >= 2); g_free (absolute); } static void ves_icall_System_Reflection_Assembly_InternalGetAssemblyName (MonoString fname, MonoReflectionAssemblyName aname) { char filename; MonoImageOpenStatus status = MONO_IMAGE_OK; gboolean res; MonoImage image; MonoAssemblyName name; char dirname MONO_ARCH_SAVE_REGS; filename = mono_string_to_utf8 (fname); dirname = g_path_get_dirname (filename); replace_shadow_path (mono_domain_get (), dirname, &filename); g_free (dirname); image = mono_image_open (filename, &status); if (!image){ MonoException exc; g_free (filename); if (status == MONO_IMAGE_IMAGE_INVALID) exc = mono_get_exception_bad_image_format2 (NULL, fname); else exc = mono_get_exception_file_not_found2 (NULL, fname); mono_raise_exception (exc); } res = mono_assembly_fill_assembly_name (image, &name); if (!res) { mono_image_close (image); g_free (filename); mono_raise_exception (mono_get_exception_argument ("assemblyFile", "The file does not contain a manifest")); } fill_reflection_assembly_name (mono_domain_get (), aname, &name, filename, TRUE, mono_framework_version () == 1, mono_framework_version () >= 2); g_free (filename); mono_image_close (image); } static MonoBoolean ves_icall_System_Reflection_Assembly_LoadPermissions (MonoReflectionAssembly assembly, char *minimum, guint32 minLength, char *optional, guint32 optLength, char *refused, guint32 refLength) { MonoBoolean result = FALSE; MonoDeclSecurityEntry entry; /* SecurityAction.RequestMinimum / if (mono_declsec_get_assembly_action (assembly->assembly, SECURITY_ACTION_REQMIN, &entry)) { minimum = entry.blob; minLength = entry.size; result = TRUE; } / SecurityAction.RequestOptional / if (mono_declsec_get_assembly_action (assembly->assembly, SECURITY_ACTION_REQOPT, &entry)) { optional = entry.blob; optLength = entry.size; result = TRUE; } / SecurityAction.RequestRefuse / if (mono_declsec_get_assembly_action (assembly->assembly, SECURITY_ACTION_REQREFUSE, &entry)) { refused = entry.blob; refLength = entry.size; result = TRUE; } return result; } static MonoArray mono_module_get_types (MonoDomain domain, MonoImage image, MonoArray *exceptions, MonoBoolean exportedOnly) { MonoArray res; MonoClass klass; MonoTableInfo tdef = &image->tables [MONO_TABLE_TYPEDEF]; int i, count; guint32 attrs, visibility; /* we start the count from 1 because we skip the special type <Module> / if (exportedOnly) { count = 0; for (i = 1; i < tdef->rows; ++i) { attrs = mono_metadata_decode_row_col (tdef, i, MONO_TYPEDEF_FLAGS); visibility = attrs & TYPE_ATTRIBUTE_VISIBILITY_MASK; if (visibility == TYPE_ATTRIBUTE_PUBLIC \|\| visibility == TYPE_ATTRIBUTE_NESTED_PUBLIC) count++; } } else { count = tdef->rows - 1; } res = mono_array_new (domain, mono_defaults.monotype_class, count); exceptions = mono_array_new (domain, mono_defaults.exception_class, count); count = 0; for (i = 1; i < tdef->rows; ++i) { attrs = mono_metadata_decode_row_col (tdef, i, MONO_TYPEDEF_FLAGS); visibility = attrs & TYPE_ATTRIBUTE_VISIBILITY_MASK; if (!exportedOnly \|\| (visibility == TYPE_ATTRIBUTE_PUBLIC \|\| visibility == TYPE_ATTRIBUTE_NESTED_PUBLIC)) { klass = mono_class_get (image, (i + 1) \| MONO_TOKEN_TYPE_DEF); if (klass) { mono_array_setref (res, count, mono_type_get_object (domain, &klass->byval_arg)); } else { MonoLoaderError error; MonoException ex; error = mono_loader_get_last_error (); g_assert (error != NULL); ex = mono_loader_error_prepare_exception (error); mono_array_setref (exceptions, count, ex); } if (mono_loader_get_last_error ()) mono_loader_clear_error (); count++; } } return res; } static MonoArray ves_icall_System_Reflection_Assembly_GetTypes (MonoReflectionAssembly assembly, MonoBoolean exportedOnly) { MonoArray res = NULL; MonoArray exceptions = NULL; MonoImage image = NULL; MonoTableInfo table = NULL; MonoDomain domain; GList list = NULL; int i, len, ex_count; MONO_ARCH_SAVE_REGS; domain = mono_object_domain (assembly); g_assert (!assembly->assembly->dynamic); image = assembly->assembly->image; table = &image->tables [MONO_TABLE_FILE]; res = mono_module_get_types (domain, image, &exceptions, exportedOnly); / Append data from all modules in the assembly / for (i = 0; i < table->rows; ++i) { if (!(mono_metadata_decode_row_col (table, i, MONO_FILE_FLAGS) & FILE_CONTAINS_NO_METADATA)) { MonoImage loaded_image = mono_assembly_load_module (image->assembly, i + 1); if (loaded_image) { MonoArray ex2; MonoArray res2 = mono_module_get_types (domain, loaded_image, &ex2, exportedOnly); /* Append the new types to the end of the array / if (mono_array_length (res2) > 0) { guint32 len1, len2; MonoArray res3, ex3; len1 = mono_array_length (res); len2 = mono_array_length (res2); res3 = mono_array_new (domain, mono_defaults.monotype_class, len1 + len2); mono_array_memcpy_refs (res3, 0, res, 0, len1); mono_array_memcpy_refs (res3, len1, res2, 0, len2); res = res3; ex3 = mono_array_new (domain, mono_defaults.monotype_class, len1 + len2); mono_array_memcpy_refs (ex3, 0, exceptions, 0, len1); mono_array_memcpy_refs (ex3, len1, ex2, 0, len2); exceptions = ex3; } } } } / the ReflectionTypeLoadException must have all the types (Types property), * NULL replacing types which throws an exception. The LoaderException must * contain all exceptions for NULL items. / len = mono_array_length (res); ex_count = 0; for (i = 0; i < len; i++) { MonoReflectionType t = mono_array_get (res, gpointer, i); MonoClass klass; if (t) { klass = mono_type_get_class (t->type); if ((klass != NULL) && klass->exception_type) { / keep the class in the list / list = g_list_append (list, klass); / and replace Type with NULL / mono_array_setref (res, i, NULL); } } else { ex_count ++; } } if (list \|\| ex_count) { GList tmp = NULL; MonoException exc = NULL; MonoArray exl = NULL; int j, length = g_list_length (list) + ex_count; mono_loader_clear_error (); exl = mono_array_new (domain, mono_defaults.exception_class, length); /* Types for which mono_class_get () succeeded / for (i = 0, tmp = list; tmp; i++, tmp = tmp->next) { MonoException exc = mono_class_get_exception_for_failure (tmp->data); mono_array_setref (exl, i, exc); } /* Types for which it don't / for (j = 0; j < mono_array_length (exceptions); ++j) { MonoException exc = mono_array_get (exceptions, MonoException, j); if (exc) { g_assert (i < length); mono_array_setref (exl, i, exc); i ++; } } g_list_free (list); list = NULL; exc = mono_get_exception_reflection_type_load (res, exl); mono_loader_clear_error (); mono_raise_exception (exc); } return res; } static gboolean ves_icall_System_Reflection_AssemblyName_ParseName (MonoReflectionAssemblyName name, MonoString assname) { MonoAssemblyName aname; MonoDomain domain = mono_object_domain (name); char val; gboolean is_version_defined; gboolean is_token_defined; aname.public_key = NULL; val = mono_string_to_utf8 (assname); if (!mono_assembly_name_parse_full (val, &aname, TRUE, &is_version_defined, &is_token_defined)) { g_free ((guint8) aname.public_key); g_free (val); return FALSE; } fill_reflection_assembly_name (domain, name, &aname, "", is_version_defined, FALSE, is_token_defined); mono_assembly_name_free (&aname); g_free ((guint8) aname.public_key); g_free (val); return TRUE; } static MonoReflectionType ves_icall_System_Reflection_Module_GetGlobalType (MonoReflectionModule module) { MonoDomain domain = mono_object_domain (module); MonoClass klass; MONO_ARCH_SAVE_REGS; g_assert (module->image); if (module->image->dynamic && ((MonoDynamicImage)(module->image))->initial_image) /* These images do not have a global type / return NULL; klass = mono_class_get (module->image, 1 \| MONO_TOKEN_TYPE_DEF); return mono_type_get_object (domain, &klass->byval_arg); } static void ves_icall_System_Reflection_Module_Close (MonoReflectionModule module) { /if (module->image) mono_image_close (module->image);/ } static MonoString* ves_icall_System_Reflection_Module_GetGuidInternal (MonoReflectionModule module) { MonoDomain domain = mono_object_domain (module); MONO_ARCH_SAVE_REGS; g_assert (module->image); return mono_string_new (domain, module->image->guid); } static gpointer ves_icall_System_Reflection_Module_GetHINSTANCE (MonoReflectionModule module) { #ifdef PLATFORM_WIN32 if (module->image && module->image->is_module_handle) return module->image->raw_data; #endif return (gpointer) (-1); } static void ves_icall_System_Reflection_Module_GetPEKind (MonoImage image, gint32 pe_kind, gint32 machine) { if (image->dynamic) { MonoDynamicImage dyn = (MonoDynamicImage)image; pe_kind = dyn->pe_kind; machine = dyn->machine; } else { pe_kind = ((MonoCLIImageInfo)(image->image_info))->cli_cli_header.ch_flags & 0x3; machine = ((MonoCLIImageInfo)(image->image_info))->cli_header.coff.coff_machine; } } static gint32 ves_icall_System_Reflection_Module_GetMDStreamVersion (MonoImage image) { return (image->md_version_major << 16) \| (image->md_version_minor); } static MonoArray ves_icall_System_Reflection_Module_InternalGetTypes (MonoReflectionModule module) { MonoArray exceptions; int i; MONO_ARCH_SAVE_REGS; if (!module->image) return mono_array_new (mono_object_domain (module), mono_defaults.monotype_class, 0); else { MonoArray res = mono_module_get_types (mono_object_domain (module), module->image, &exceptions, FALSE); for (i = 0; i < mono_array_length (exceptions); ++i) { MonoException ex = mono_array_get (exceptions, MonoException , i); if (ex) mono_raise_exception (ex); } return res; } } static gboolean mono_metadata_memberref_is_method (MonoImage image, guint32 token) { guint32 cols [MONO_MEMBERREF_SIZE]; const char sig; mono_metadata_decode_row (&image->tables [MONO_TABLE_MEMBERREF], mono_metadata_token_index (token) - 1, cols, MONO_MEMBERREF_SIZE); sig = mono_metadata_blob_heap (image, cols [MONO_MEMBERREF_SIGNATURE]); mono_metadata_decode_blob_size (sig, &sig); return (sig != 0x6); } static void init_generic_context_from_args (MonoGenericContext context, MonoArray type_args, MonoArray method_args) { if (type_args) context->class_inst = mono_metadata_get_generic_inst (mono_array_length (type_args), mono_array_addr (type_args, MonoType, 0)); else context->class_inst = NULL; if (method_args) context->method_inst = mono_metadata_get_generic_inst (mono_array_length (method_args), mono_array_addr (method_args, MonoType, 0)); else context->method_inst = NULL; } static MonoType ves_icall_System_Reflection_Module_ResolveTypeToken (MonoImage image, guint32 token, MonoArray type_args, MonoArray method_args, MonoResolveTokenError error) { MonoClass klass; int table = mono_metadata_token_table (token); int index = mono_metadata_token_index (token); MonoGenericContext context; error = ResolveTokenError_Other; /* Validate token / if ((table != MONO_TABLE_TYPEDEF) && (table != MONO_TABLE_TYPEREF) && (table != MONO_TABLE_TYPESPEC)) { error = ResolveTokenError_BadTable; return NULL; } if (image->dynamic) { if (type_args \|\| method_args) mono_raise_exception (mono_get_exception_not_implemented (NULL)); klass = mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL); if (!klass) return NULL; return &klass->byval_arg; } if ((index <= 0) \|\| (index > image->tables [table].rows)) { error = ResolveTokenError_OutOfRange; return NULL; } init_generic_context_from_args (&context, type_args, method_args); klass = mono_class_get_full (image, token, &context); if (mono_loader_get_last_error ()) mono_raise_exception (mono_loader_error_prepare_exception (mono_loader_get_last_error ())); if (klass) return &klass->byval_arg; else return NULL; } static MonoMethod ves_icall_System_Reflection_Module_ResolveMethodToken (MonoImage image, guint32 token, MonoArray type_args, MonoArray method_args, MonoResolveTokenError error) { int table = mono_metadata_token_table (token); int index = mono_metadata_token_index (token); MonoGenericContext context; MonoMethod method; error = ResolveTokenError_Other; /* Validate token / if ((table != MONO_TABLE_METHOD) && (table != MONO_TABLE_METHODSPEC) && (table != MONO_TABLE_MEMBERREF)) { error = ResolveTokenError_BadTable; return NULL; } if (image->dynamic) { if (type_args \|\| method_args) mono_raise_exception (mono_get_exception_not_implemented (NULL)); /* FIXME: validate memberref token type / return mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL); } if ((index <= 0) \|\| (index > image->tables [table].rows)) { error = ResolveTokenError_OutOfRange; return NULL; } if ((table == MONO_TABLE_MEMBERREF) && (!mono_metadata_memberref_is_method (image, token))) { error = ResolveTokenError_BadTable; return NULL; } init_generic_context_from_args (&context, type_args, method_args); method = mono_get_method_full (image, token, NULL, &context); if (mono_loader_get_last_error ()) mono_raise_exception (mono_loader_error_prepare_exception (mono_loader_get_last_error ())); return method; } static MonoString ves_icall_System_Reflection_Module_ResolveStringToken (MonoImage image, guint32 token, MonoResolveTokenError error) { int index = mono_metadata_token_index (token); error = ResolveTokenError_Other; / Validate token / if (mono_metadata_token_code (token) != MONO_TOKEN_STRING) { error = ResolveTokenError_BadTable; return NULL; } if (image->dynamic) return mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL); if ((index <= 0) \|\| (index >= image->heap_us.size)) { error = ResolveTokenError_OutOfRange; return NULL; } / FIXME: What to do if the index points into the middle of a string ? / return mono_ldstr (mono_domain_get (), image, index); } static MonoClassField ves_icall_System_Reflection_Module_ResolveFieldToken (MonoImage image, guint32 token, MonoArray type_args, MonoArray method_args, MonoResolveTokenError error) { MonoClass klass; int table = mono_metadata_token_table (token); int index = mono_metadata_token_index (token); MonoGenericContext context; MonoClassField field; error = ResolveTokenError_Other; / Validate token / if ((table != MONO_TABLE_FIELD) && (table != MONO_TABLE_MEMBERREF)) { error = ResolveTokenError_BadTable; return NULL; } if (image->dynamic) { if (type_args \|\| method_args) mono_raise_exception (mono_get_exception_not_implemented (NULL)); /* FIXME: validate memberref token type / return mono_lookup_dynamic_token_class (image, token, FALSE, NULL, NULL); } if ((index <= 0) \|\| (index > image->tables [table].rows)) { error = ResolveTokenError_OutOfRange; return NULL; } if ((table == MONO_TABLE_MEMBERREF) && (mono_metadata_memberref_is_method (image, token))) { error = ResolveTokenError_BadTable; return NULL; } init_generic_context_from_args (&context, type_args, method_args); field = mono_field_from_token (image, token, &klass, &context); if (mono_loader_get_last_error ()) mono_raise_exception (mono_loader_error_prepare_exception (mono_loader_get_last_error ())); return field; } static MonoObject ves_icall_System_Reflection_Module_ResolveMemberToken (MonoImage image, guint32 token, MonoArray type_args, MonoArray method_args, MonoResolveTokenError error) { int table = mono_metadata_token_table (token); error = ResolveTokenError_Other; switch (table) { case MONO_TABLE_TYPEDEF: case MONO_TABLE_TYPEREF: case MONO_TABLE_TYPESPEC: { MonoType t = ves_icall_System_Reflection_Module_ResolveTypeToken (image, token, type_args, method_args, error); if (t) return (MonoObject)mono_type_get_object (mono_domain_get (), t); else return NULL; } case MONO_TABLE_METHOD: case MONO_TABLE_METHODSPEC: { MonoMethod m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, type_args, method_args, error); if (m) return (MonoObject)mono_method_get_object (mono_domain_get (), m, m->klass); else return NULL; } case MONO_TABLE_FIELD: { MonoClassField f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, type_args, method_args, error); if (f) return (MonoObject)mono_field_get_object (mono_domain_get (), f->parent, f); else return NULL; } case MONO_TABLE_MEMBERREF: if (mono_metadata_memberref_is_method (image, token)) { MonoMethod m = ves_icall_System_Reflection_Module_ResolveMethodToken (image, token, type_args, method_args, error); if (m) return (MonoObject)mono_method_get_object (mono_domain_get (), m, m->klass); else return NULL; } else { MonoClassField f = ves_icall_System_Reflection_Module_ResolveFieldToken (image, token, type_args, method_args, error); if (f) return (MonoObject)mono_field_get_object (mono_domain_get (), f->parent, f); else return NULL; } break; default: error = ResolveTokenError_BadTable; } return NULL; } static MonoArray* ves_icall_System_Reflection_Module_ResolveSignature (MonoImage image, guint32 token, MonoResolveTokenError error) { int table = mono_metadata_token_table (token); int idx = mono_metadata_token_index (token); MonoTableInfo tables = image->tables; guint32 sig, len; const char ptr; MonoArray res; error = ResolveTokenError_OutOfRange; /* FIXME: Support other tables ? / if (table != MONO_TABLE_STANDALONESIG) return NULL; if (image->dynamic) return NULL; if ((idx == 0) \|\| (idx > tables [MONO_TABLE_STANDALONESIG].rows)) return NULL; sig = mono_metadata_decode_row_col (&tables [MONO_TABLE_STANDALONESIG], idx - 1, 0); ptr = mono_metadata_blob_heap (image, sig); len = mono_metadata_decode_blob_size (ptr, &ptr); res = mono_array_new (mono_domain_get (), mono_defaults.byte_class, len); memcpy (mono_array_addr (res, guint8, 0), ptr, len); return res; } static MonoReflectionType ves_icall_ModuleBuilder_create_modified_type (MonoReflectionTypeBuilder tb, MonoString smodifiers) { MonoClass klass; int isbyref = 0, rank; char str = mono_string_to_utf8 (smodifiers); char p; MONO_ARCH_SAVE_REGS; klass = mono_class_from_mono_type (tb->type.type); p = str; / logic taken from mono_reflection_parse_type(): keep in sync / while (p) { switch (p) { case '&': if (isbyref) { / only one level allowed by the spec / g_free (str); return NULL; } isbyref = 1; p++; g_free (str); return mono_type_get_object (mono_object_domain (tb), &klass->this_arg); break; case '': klass = mono_ptr_class_get (&klass->byval_arg); mono_class_init (klass); p++; break; case '[': rank = 1; p++; while (p) { if (p == ']') break; if (p == ',') rank++; else if (p != '') { / '' means unknown lower bound / g_free (str); return NULL; } ++p; } if (p != ']') { g_free (str); return NULL; } p++; klass = mono_array_class_get (klass, rank); mono_class_init (klass); break; default: break; } } g_free (str); return mono_type_get_object (mono_object_domain (tb), &klass->byval_arg); } static MonoBoolean ves_icall_Type_IsArrayImpl (MonoReflectionType t) { MonoType type; MonoBoolean res; MONO_ARCH_SAVE_REGS; type = t->type; res = !type->byref && (type->type == MONO_TYPE_ARRAY \|\| type->type == MONO_TYPE_SZARRAY); return res; } static void check_for_invalid_type (MonoClass klass) { char name; MonoString str; if (klass->byval_arg.type != MONO_TYPE_TYPEDBYREF) return; name = mono_type_get_full_name (klass); str = mono_string_new (mono_domain_get (), name); g_free (name); mono_raise_exception ((MonoException)mono_get_exception_type_load (str, NULL)); } static MonoReflectionType ves_icall_Type_make_array_type (MonoReflectionType type, int rank) { MonoClass klass, aklass; MONO_ARCH_SAVE_REGS; klass = mono_class_from_mono_type (type->type); check_for_invalid_type (klass); if (rank == 0) //single dimentional array aklass = mono_array_class_get (klass, 1); else aklass = mono_bounded_array_class_get (klass, rank, TRUE); return mono_type_get_object (mono_object_domain (type), &aklass->byval_arg); } static MonoReflectionType ves_icall_Type_make_byref_type (MonoReflectionType type) { MonoClass klass; MONO_ARCH_SAVE_REGS; klass = mono_class_from_mono_type (type->type); check_for_invalid_type (klass); return mono_type_get_object (mono_object_domain (type), &klass->this_arg); } static MonoReflectionType * ves_icall_Type_MakePointerType (MonoReflectionType type) { MonoClass klass, pklass; MONO_ARCH_SAVE_REGS; klass = mono_class_from_mono_type (type->type); check_for_invalid_type (klass); pklass = mono_ptr_class_get (type->type); return mono_type_get_object (mono_object_domain (type), &pklass->byval_arg); } static MonoObject ves_icall_System_Delegate_CreateDelegate_internal (MonoReflectionType type, MonoObject target, MonoReflectionMethod info, MonoBoolean throwOnBindFailure) { MonoClass delegate_class = mono_class_from_mono_type (type->type); MonoObject delegate; gpointer func; MonoMethod method = info->method; MONO_ARCH_SAVE_REGS; mono_assert (delegate_class->parent == mono_defaults.multicastdelegate_class); if (mono_security_get_mode () == MONO_SECURITY_MODE_CORE_CLR) { if (!mono_security_core_clr_ensure_delegate_creation (method, throwOnBindFailure)) return NULL; } delegate = mono_object_new (mono_object_domain (type), delegate_class); if (method->dynamic) { /* Creating a trampoline would leak memory / func = mono_compile_method (method); } else { func = mono_create_ftnptr (mono_domain_get (), mono_runtime_create_jump_trampoline (mono_domain_get (), method, TRUE)); } mono_delegate_ctor_with_method (delegate, target, func, method); return delegate; } static void ves_icall_System_Delegate_SetMulticastInvoke (MonoDelegate this) { /* Reset the invoke impl to the default one / this->invoke_impl = mono_runtime_create_delegate_trampoline (this->object.vtable->klass); } / * Magic number to convert a time which is relative to * Jan 1, 1970 into a value which is relative to Jan 1, 0001. / #define EPOCH_ADJUST ((guint64)62135596800LL) / * Magic number to convert FILETIME base Jan 1, 1601 to DateTime - base Jan, 1, 0001 / #define FILETIME_ADJUST ((guint64)504911232000000000LL) #ifdef PLATFORM_WIN32 / convert a SYSTEMTIME which is of the form "last thursday in october" to a real date / static void convert_to_absolute_date(SYSTEMTIME date) { #define IS_LEAP(y) ((y % 4) == 0 && ((y % 100) != 0 \|\| (y % 400) == 0)) static int days_in_month[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; static int leap_days_in_month[] = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}; /* from the calendar FAQ / int a = (14 - date->wMonth) / 12; int y = date->wYear - a; int m = date->wMonth + 12 a - 2; int d = (1 + y + y/4 - y/100 + y/400 + (31m)/12) % 7; / d is now the day of the week for the first of the month (0 == Sunday) / int day_of_week = date->wDayOfWeek; / set day_in_month to the first day in the month which falls on day_of_week / int day_in_month = 1 + (day_of_week - d); if (day_in_month <= 0) day_in_month += 7; / wDay is 1 for first weekday in month, 2 for 2nd ... 5 means last - so work that out allowing for days in the month / date->wDay = day_in_month + (date->wDay - 1) 7; if (date->wDay > (IS_LEAP(date->wYear) ? leap_days_in_month[date->wMonth - 1] : days_in_month[date->wMonth - 1])) date->wDay -= 7; } #endif #ifndef PLATFORM_WIN32 /* * Return's the offset from GMT of a local time. * * tm is a local time * t is the same local time as seconds. / static int gmt_offset(struct tm tm, time_t t) { #if defined (HAVE_TM_GMTOFF) return tm->tm_gmtoff; #else struct tm g; time_t t2; g = gmtime(&t); g.tm_isdst = tm->tm_isdst; t2 = mktime(&g); return (int)difftime(t, t2); #endif } #endif / * This is heavily based on zdump.c from glibc 2.2. * * * data[0]: start of daylight saving time (in DateTime ticks). * * data[1]: end of daylight saving time (in DateTime ticks). * * data[2]: utcoffset (in TimeSpan ticks). * * data[3]: additional offset when daylight saving (in TimeSpan ticks). * * name[0]: name of this timezone when not daylight saving. * * name[1]: name of this timezone when daylight saving. * * FIXME: This only works with "standard" Unix dates (years between 1900 and 2100) while * the class library allows years between 1 and 9999. * * Returns true on success and zero on failure. / static guint32 ves_icall_System_CurrentSystemTimeZone_GetTimeZoneData (guint32 year, MonoArray data, MonoArray names) { #ifndef PLATFORM_WIN32 MonoDomain domain = mono_domain_get (); struct tm start, tt; time_t t; long int gmtoff; int is_daylight = 0, day; char tzone [64]; MONO_ARCH_SAVE_REGS; MONO_CHECK_ARG_NULL (data); MONO_CHECK_ARG_NULL (names); mono_gc_wbarrier_generic_store (data, (MonoObject) mono_array_new (domain, mono_defaults.int64_class, 4)); mono_gc_wbarrier_generic_store (names, (MonoObject) mono_array_new (domain, mono_defaults.string_class, 2)); /* * no info is better than crashing: we'll need our own tz data * to make this work properly, anyway. The range is probably * reduced to 1970 .. 2037 because that is what mktime is * guaranteed to support (we get into an infinite loop * otherwise). / memset (&start, 0, sizeof (start)); start.tm_mday = 1; start.tm_year = year-1900; t = mktime (&start); if ((year < 1970) \|\| (year > 2037) \|\| (t == -1)) { t = time (NULL); tt = localtime (&t); strftime (tzone, sizeof (tzone), "%Z", &tt); mono_array_setref ((names), 0, mono_string_new (domain, tzone)); mono_array_setref ((names), 1, mono_string_new (domain, tzone)); return 1; } gmtoff = gmt_offset (&start, t); /* For each day of the year, calculate the tm_gmtoff. / for (day = 0; day < 365; day++) { t += 360024; tt = localtime (&t); / Daylight saving starts or ends here. / if (gmt_offset (&tt, t) != gmtoff) { struct tm tt1; time_t t1; / Try to find the exact hour when daylight saving starts/ends. / t1 = t; do { t1 -= 3600; tt1 = localtime (&t1); } while (gmt_offset (&tt1, t1) != gmtoff); /* Try to find the exact minute when daylight saving starts/ends. / do { t1 += 60; tt1 = localtime (&t1); } while (gmt_offset (&tt1, t1) == gmtoff); t1+=gmtoff; strftime (tzone, sizeof (tzone), "%Z", &tt); /* Write data, if we're already in daylight saving, we're done. / if (is_daylight) { mono_array_setref ((names), 0, mono_string_new (domain, tzone)); mono_array_set ((data), gint64, 1, ((gint64)t1 + EPOCH_ADJUST) 10000000L); return 1; } else { mono_array_setref ((names), 1, mono_string_new (domain, tzone)); mono_array_set ((data), gint64, 0, ((gint64)t1 + EPOCH_ADJUST) * 10000000L); is_daylight = 1; } /* This is only set once when we enter daylight saving. / mono_array_set ((data), gint64, 2, (gint64)gmtoff * 10000000L); mono_array_set ((data), gint64, 3, (gint64)(gmt_offset (&tt, t) - gmtoff) 10000000L); gmtoff = gmt_offset (&tt, t); } } if (!is_daylight) { strftime (tzone, sizeof (tzone), "%Z", &tt); mono_array_setref ((names), 0, mono_string_new (domain, tzone)); mono_array_setref ((names), 1, mono_string_new (domain, tzone)); mono_array_set ((data), gint64, 0, 0); mono_array_set ((data), gint64, 1, 0); mono_array_set ((data), gint64, 2, (gint64) gmtoff 10000000L); mono_array_set ((data), gint64, 3, 0); } return 1; #else MonoDomain domain = mono_domain_get (); TIME_ZONE_INFORMATION tz_info; FILETIME ft; int i; int err, tz_id; tz_id = GetTimeZoneInformation (&tz_info); if (tz_id == TIME_ZONE_ID_INVALID) return 0; MONO_CHECK_ARG_NULL (data); MONO_CHECK_ARG_NULL (names); mono_gc_wbarrier_generic_store (data, mono_array_new (domain, mono_defaults.int64_class, 4)); mono_gc_wbarrier_generic_store (names, mono_array_new (domain, mono_defaults.string_class, 2)); for (i = 0; i < 32; ++i) if (!tz_info.DaylightName [i]) break; mono_array_setref ((names), 1, mono_string_new_utf16 (domain, tz_info.DaylightName, i)); for (i = 0; i < 32; ++i) if (!tz_info.StandardName [i]) break; mono_array_setref ((names), 0, mono_string_new_utf16 (domain, tz_info.StandardName, i)); if ((year <= 1601) \|\| (year > 30827)) { /* * According to MSDN, the MS time functions can't handle dates outside * this interval. / return 1; } / even if the timezone has no daylight savings it may have Bias (e.g. GMT+13 it seems) / if (tz_id != TIME_ZONE_ID_UNKNOWN) { tz_info.StandardDate.wYear = year; convert_to_absolute_date(&tz_info.StandardDate); err = SystemTimeToFileTime (&tz_info.StandardDate, &ft); //g_assert(err); if (err == 0) return 0; mono_array_set ((data), gint64, 1, FILETIME_ADJUST + (((guint64)ft.dwHighDateTime<<32) \| ft.dwLowDateTime)); tz_info.DaylightDate.wYear = year; convert_to_absolute_date(&tz_info.DaylightDate); err = SystemTimeToFileTime (&tz_info.DaylightDate, &ft); //g_assert(err); if (err == 0) return 0; mono_array_set ((data), gint64, 0, FILETIME_ADJUST + (((guint64)ft.dwHighDateTime<<32) \| ft.dwLowDateTime)); } mono_array_set ((data), gint64, 2, (tz_info.Bias + tz_info.StandardBias) * -600000000LL); mono_array_set ((data), gint64, 3, (tz_info.DaylightBias - tz_info.StandardBias) -600000000LL); return 1; #endif } static gpointer ves_icall_System_Object_obj_address (MonoObject this) { MONO_ARCH_SAVE_REGS; return this; } / System.Buffer / static inline gint32 mono_array_get_byte_length (MonoArray array) { MonoClass klass; int length; int i; klass = array->obj.vtable->klass; if (array->bounds == NULL) length = array->max_length; else { length = 1; for (i = 0; i < klass->rank; ++ i) length = array->bounds [i].length; } switch (klass->element_class->byval_arg.type) { case MONO_TYPE_I1: case MONO_TYPE_U1: case MONO_TYPE_BOOLEAN: return length; case MONO_TYPE_I2: case MONO_TYPE_U2: case MONO_TYPE_CHAR: return length << 1; case MONO_TYPE_I4: case MONO_TYPE_U4: case MONO_TYPE_R4: return length << 2; case MONO_TYPE_I: case MONO_TYPE_U: return length * sizeof (gpointer); case MONO_TYPE_I8: case MONO_TYPE_U8: case MONO_TYPE_R8: return length << 3; default: return -1; } } static gint32 ves_icall_System_Buffer_ByteLengthInternal (MonoArray array) { MONO_ARCH_SAVE_REGS; return mono_array_get_byte_length (array); } static gint8 ves_icall_System_Buffer_GetByteInternal (MonoArray array, gint32 idx) { MONO_ARCH_SAVE_REGS; return mono_array_get (array, gint8, idx); } static void ves_icall_System_Buffer_SetByteInternal (MonoArray array, gint32 idx, gint8 value) { MONO_ARCH_SAVE_REGS; mono_array_set (array, gint8, idx, value); } static MonoBoolean ves_icall_System_Buffer_BlockCopyInternal (MonoArray src, gint32 src_offset, MonoArray dest, gint32 dest_offset, gint32 count) { guint8 src_buf, dest_buf; MONO_ARCH_SAVE_REGS; / watch out for integer overflow / if ((src_offset > mono_array_get_byte_length (src) - count) \|\| (dest_offset > mono_array_get_byte_length (dest) - count)) return FALSE; src_buf = (guint8 )src->vector + src_offset; dest_buf = (guint8 )dest->vector + dest_offset; if (src != dest) memcpy (dest_buf, src_buf, count); else memmove (dest_buf, src_buf, count); / Source and dest are the same array / return TRUE; } static MonoObject ves_icall_Remoting_RealProxy_GetTransparentProxy (MonoObject this, MonoString class_name) { MonoDomain domain = mono_object_domain (this); MonoObject res; MonoRealProxy rp = ((MonoRealProxy )this); MonoTransparentProxy tp; MonoType type; MonoClass klass; MONO_ARCH_SAVE_REGS; res = mono_object_new (domain, mono_defaults.transparent_proxy_class); tp = (MonoTransparentProxy) res; MONO_OBJECT_SETREF (tp, rp, rp); type = ((MonoReflectionType )rp->class_to_proxy)->type; klass = mono_class_from_mono_type (type); tp->custom_type_info = (mono_object_isinst (this, mono_defaults.iremotingtypeinfo_class) != NULL); tp->remote_class = mono_remote_class (domain, class_name, klass); res->vtable = mono_remote_class_vtable (domain, tp->remote_class, rp); return res; } static MonoReflectionType ves_icall_Remoting_RealProxy_InternalGetProxyType (MonoTransparentProxy tp) { return mono_type_get_object (mono_object_domain (tp), &tp->remote_class->proxy_class->byval_arg); } / System.Environment / MonoString ves_icall_System_Environment_get_UserName (void) { MONO_ARCH_SAVE_REGS; /* using glib is more portable / return mono_string_new (mono_domain_get (), g_get_user_name ()); } static MonoString ves_icall_System_Environment_get_MachineName (void) { #if defined (PLATFORM_WIN32) gunichar2 buf; guint32 len; MonoString result; len = MAX_COMPUTERNAME_LENGTH + 1; buf = g_new (gunichar2, len); result = NULL; if (GetComputerName (buf, (PDWORD) &len)) result = mono_string_new_utf16 (mono_domain_get (), buf, len); g_free (buf); return result; #elif !defined(DISABLE_SOCKETS) gchar buf [256]; MonoString result; if (gethostname (buf, sizeof (buf)) == 0) result = mono_string_new (mono_domain_get (), buf); else result = NULL; return result; #else return mono_string_new (mono_domain_get (), "mono"); #endif } static int ves_icall_System_Environment_get_Platform (void) { #if defined (PLATFORM_WIN32) / Win32NT / return 2; #elif defined(__MACH__) / OSX / if (mono_framework_version () < 2) return 128; // // For compatibility with our client code, this will be 4 for a while. // We will eventually move to 6 to match .NET, but it requires all client // code to be updated and the documentation everywhere to be updated // first. // return 4; #else / Unix / if (mono_framework_version () < 2) return 128; return 4; #endif } static MonoString ves_icall_System_Environment_get_NewLine (void) { MONO_ARCH_SAVE_REGS; #if defined (PLATFORM_WIN32) return mono_string_new (mono_domain_get (), "\r\n"); #else return mono_string_new (mono_domain_get (), "\n"); #endif } static MonoString * ves_icall_System_Environment_GetEnvironmentVariable (MonoString name) { const gchar value; gchar utf8_name; MONO_ARCH_SAVE_REGS; if (name == NULL) return NULL; utf8_name = mono_string_to_utf8 (name); / FIXME: this should be ascii / value = g_getenv (utf8_name); g_free (utf8_name); if (value == 0) return NULL; return mono_string_new (mono_domain_get (), value); } / * There is no standard way to get at environ. / #ifndef _MSC_VER #ifndef __MINGW32_VERSION #ifdef __APPLE__ / Apple defines this in crt_externs.h but doesn't provide that header for * arm-apple-darwin9. We'll manually define the symbol on Apple as it does * in fact exist on all implementations (so far) / gchar *_NSGetEnviron(void); #define environ (_NSGetEnviron()) #else extern char *environ; #endif #endif #endif static MonoArray ves_icall_System_Environment_GetEnvironmentVariableNames (void) { #ifdef PLATFORM_WIN32 MonoArray names; MonoDomain domain; MonoString str; WCHAR env_strings; WCHAR* env_string; WCHAR* equal_str; int n = 0; env_strings = GetEnvironmentStrings(); if (env_strings) { env_string = env_strings; while (env_string != '\0') { / weird case that MS seems to skip / if (env_string != '=') n++; while (env_string != '\0') env_string++; env_string++; } } domain = mono_domain_get (); names = mono_array_new (domain, mono_defaults.string_class, n); if (env_strings) { n = 0; env_string = env_strings; while (env_string != '\0') { /* weird case that MS seems to skip / if (env_string != '=') { equal_str = wcschr(env_string, '='); g_assert(equal_str); str = mono_string_new_utf16 (domain, env_string, equal_str-env_string); mono_array_setref (names, n, str); n++; } while (env_string != '\0') env_string++; env_string++; } FreeEnvironmentStrings (env_strings); } return names; #else MonoArray names; MonoDomain domain; MonoString str; gchar e, parts; int n; MONO_ARCH_SAVE_REGS; n = 0; for (e = environ; e != 0; ++ e) ++ n; domain = mono_domain_get (); names = mono_array_new (domain, mono_defaults.string_class, n); n = 0; for (e = environ; e != 0; ++ e) { parts = g_strsplit (e, "=", 2); if (parts != 0) { str = mono_string_new (domain, parts); mono_array_setref (names, n, str); } g_strfreev (parts); ++ n; } return names; #endif } / * If your platform lacks setenv/unsetenv, you must upgrade your glib. / #if !GLIB_CHECK_VERSION(2,4,0) #define g_setenv(a,b,c) setenv(a,b,c) #define g_unsetenv(a) unsetenv(a) #endif static void ves_icall_System_Environment_InternalSetEnvironmentVariable (MonoString name, MonoString value) { MonoError error; #ifdef PLATFORM_WIN32 gunichar2 utf16_name, utf16_value; #else gchar utf8_name, utf8_value; #endif MONO_ARCH_SAVE_REGS; #ifdef PLATFORM_WIN32 utf16_name = mono_string_to_utf16 (name); if ((value == NULL) \|\| (mono_string_length (value) == 0) \|\| (mono_string_chars (value)[0] == 0)) { SetEnvironmentVariable (utf16_name, NULL); g_free (utf16_name); return; } utf16_value = mono_string_to_utf16 (value); SetEnvironmentVariable (utf16_name, utf16_value); g_free (utf16_name); g_free (utf16_value); #else utf8_name = mono_string_to_utf8 (name); / FIXME: this should be ascii / if ((value == NULL) \|\| (mono_string_length (value) == 0) \|\| (mono_string_chars (value)[0] == 0)) { g_unsetenv (utf8_name); g_free (utf8_name); return; } utf8_value = mono_string_to_utf8_checked (value, &error); if (!mono_error_ok (&error)) { g_free (utf8_name); mono_error_raise_exception (&error); } g_setenv (utf8_name, utf8_value, TRUE); g_free (utf8_name); g_free (utf8_value); #endif } static void ves_icall_System_Environment_Exit (int result) { MONO_ARCH_SAVE_REGS; mono_threads_set_shutting_down (); mono_runtime_set_shutting_down (); / This will kill the tp threads which cannot be suspended / mono_thread_pool_cleanup (); / Suspend all managed threads since the runtime is going away / mono_thread_suspend_all_other_threads (); mono_runtime_quit (); / we may need to do some cleanup here... / exit (result); } static MonoString ves_icall_System_Environment_GetGacPath (void) { return mono_string_new (mono_domain_get (), mono_assembly_getrootdir ()); } static MonoString* ves_icall_System_Environment_GetWindowsFolderPath (int folder) { #if defined (PLATFORM_WIN32) #ifndef CSIDL_FLAG_CREATE #define CSIDL_FLAG_CREATE 0x8000 #endif WCHAR path [MAX_PATH]; /* Create directory if no existing / if (SUCCEEDED (SHGetFolderPathW (NULL, folder \| CSIDL_FLAG_CREATE, NULL, 0, path))) { int len = 0; while (path [len]) ++ len; return mono_string_new_utf16 (mono_domain_get (), path, len); } #else g_warning ("ves_icall_System_Environment_GetWindowsFolderPath should only be called on Windows!"); #endif return mono_string_new (mono_domain_get (), ""); } static MonoArray ves_icall_System_Environment_GetLogicalDrives (void) { gunichar2 buf [256], ptr, dname; gunichar2 u16; guint initial_size = 127, size = 128; gint ndrives; MonoArray result; MonoString drivestr; MonoDomain domain = mono_domain_get (); gint len; MONO_ARCH_SAVE_REGS; buf [0] = '\0'; ptr = buf; while (size > initial_size) { size = (guint) GetLogicalDriveStrings (initial_size, ptr); if (size > initial_size) { if (ptr != buf) g_free (ptr); ptr = g_malloc0 ((size + 1) * sizeof (gunichar2)); initial_size = size; size++; } } /* Count strings / dname = ptr; ndrives = 0; do { while (dname++); ndrives++; } while (dname); dname = ptr; result = mono_array_new (domain, mono_defaults.string_class, ndrives); ndrives = 0; do { len = 0; u16 = dname; while (u16) { u16++; len ++; } drivestr = mono_string_new_utf16 (domain, dname, len); mono_array_setref (result, ndrives++, drivestr); while (dname++); } while (dname); if (ptr != buf) g_free (ptr); return result; } static MonoString * ves_icall_System_Environment_InternalGetHome (void) { MONO_ARCH_SAVE_REGS; return mono_string_new (mono_domain_get (), g_get_home_dir ()); } static const char encodings [] = { (char ) 1, "ascii", "us_ascii", "us", "ansi_x3.4_1968", "ansi_x3.4_1986", "cp367", "csascii", "ibm367", "iso_ir_6", "iso646_us", "iso_646.irv:1991", (char ) 2, "utf_7", "csunicode11utf7", "unicode_1_1_utf_7", "unicode_2_0_utf_7", "x_unicode_1_1_utf_7", "x_unicode_2_0_utf_7", (char ) 3, "utf_8", "unicode_1_1_utf_8", "unicode_2_0_utf_8", "x_unicode_1_1_utf_8", "x_unicode_2_0_utf_8", (char ) 4, "utf_16", "UTF_16LE", "ucs_2", "unicode", "iso_10646_ucs2", (char ) 5, "unicodefffe", "utf_16be", (char ) 6, "iso_8859_1", (char ) 0 }; /* * Returns the internal codepage, if the value of "int_code_page" is * 1 at entry, and we can not compute a suitable code page number, * returns the code page as a string / static MonoString ves_icall_System_Text_Encoding_InternalCodePage (gint32 int_code_page) { const char cset; const char p; char c; char codepage = NULL; int code; int want_name = int_code_page; int i; int_code_page = -1; MONO_ARCH_SAVE_REGS; g_get_charset (&cset); c = codepage = strdup (cset); for (c = codepage; c; c++){ if (isascii (c) && isalpha (c)) c = tolower (c); if (c == '-') c = '_'; } /* g_print ("charset: %s\n", cset); / / handle some common aliases / p = encodings [0]; code = 0; for (i = 0; p != 0; ){ if ((gssize) p < 7){ code = (gssize) p; p = encodings [++i]; continue; } if (strcmp (p, codepage) == 0){ int_code_page = code; break; } p = encodings [++i]; } if (strstr (codepage, "utf_8") != NULL) int_code_page \|= 0x10000000; free (codepage); if (want_name && int_code_page == -1) return mono_string_new (mono_domain_get (), cset); else return NULL; } static MonoBoolean ves_icall_System_Environment_get_HasShutdownStarted (void) { if (mono_runtime_is_shutting_down ()) return TRUE; if (mono_domain_is_unloading (mono_domain_get ())) return TRUE; return FALSE; } static void ves_icall_System_Environment_BroadcastSettingChange (void) { #ifdef PLATFORM_WIN32 SendMessageTimeout (HWND_BROADCAST, WM_SETTINGCHANGE, NULL, L"Environment", SMTO_ABORTIFHUNG, 2000, 0); #endif } static void ves_icall_MonoMethodMessage_InitMessage (MonoMethodMessage this, MonoReflectionMethod method, MonoArray out_args) { MONO_ARCH_SAVE_REGS; mono_message_init (mono_object_domain (this), this, method, out_args); } static MonoBoolean ves_icall_IsTransparentProxy (MonoObject proxy) { MONO_ARCH_SAVE_REGS; if (!proxy) return 0; if (proxy->vtable->klass == mono_defaults.transparent_proxy_class) return 1; return 0; } static MonoReflectionMethod * ves_icall_Remoting_RemotingServices_GetVirtualMethod ( MonoReflectionType rtype, MonoReflectionMethod rmethod) { MonoClass klass; MonoMethod method; MonoMethod *vtable; MonoMethod res = NULL; MONO_CHECK_ARG_NULL (rtype); MONO_CHECK_ARG_NULL (rmethod); method = rmethod->method; klass = mono_class_from_mono_type (rtype->type); if (MONO_CLASS_IS_INTERFACE (klass)) return NULL; if (method->flags & METHOD_ATTRIBUTE_STATIC) return NULL; if ((method->flags & METHOD_ATTRIBUTE_FINAL) \|\| !(method->flags & METHOD_ATTRIBUTE_VIRTUAL)) { if (klass == method->klass \|\| mono_class_is_subclass_of (klass, method->klass, FALSE)) return rmethod; else return NULL; } mono_class_setup_vtable (klass); vtable = klass->vtable; if (method->klass->flags & TYPE_ATTRIBUTE_INTERFACE) { int offs = mono_class_interface_offset (klass, method->klass); if (offs >= 0) res = vtable [offs + method->slot]; } else { if (!(klass == method->klass \|\| mono_class_is_subclass_of (klass, method->klass, FALSE))) return NULL; if (method->slot != -1) res = vtable [method->slot]; } if (!res) return NULL; return mono_method_get_object (mono_domain_get (), res, NULL); } static void ves_icall_System_Runtime_Activation_ActivationServices_EnableProxyActivation (MonoReflectionType type, MonoBoolean enable) { MonoClass klass; MonoVTable* vtable; MONO_ARCH_SAVE_REGS; klass = mono_class_from_mono_type (type->type); vtable = mono_class_vtable_full (mono_domain_get (), klass, TRUE); if (enable) vtable->remote = 1; else vtable->remote = 0; } static MonoObject * ves_icall_System_Runtime_Activation_ActivationServices_AllocateUninitializedClassInstance (MonoReflectionType type) { MonoClass klass; MonoDomain domain; MONO_ARCH_SAVE_REGS; domain = mono_object_domain (type); klass = mono_class_from_mono_type (type->type); if (klass->rank >= 1) { g_assert (klass->rank == 1); return (MonoObject ) mono_array_new (domain, klass->element_class, 0); } else { /* Bypass remoting object creation check / return mono_object_new_alloc_specific (mono_class_vtable_full (domain, klass, TRUE)); } } static MonoString ves_icall_System_IO_get_temp_path (void) { MONO_ARCH_SAVE_REGS; return mono_string_new (mono_domain_get (), g_get_tmp_dir ()); } #ifndef PLATFORM_NO_DRIVEINFO static MonoBoolean ves_icall_System_IO_DriveInfo_GetDiskFreeSpace (MonoString path_name, guint64 free_bytes_avail, guint64 total_number_of_bytes, guint64 total_number_of_free_bytes, gint32 error) { gboolean result; ULARGE_INTEGER wapi_free_bytes_avail; ULARGE_INTEGER wapi_total_number_of_bytes; ULARGE_INTEGER wapi_total_number_of_free_bytes; MONO_ARCH_SAVE_REGS; error = ERROR_SUCCESS; result = GetDiskFreeSpaceEx (mono_string_chars (path_name), &wapi_free_bytes_avail, &wapi_total_number_of_bytes, &wapi_total_number_of_free_bytes); if (result) { free_bytes_avail = wapi_free_bytes_avail.QuadPart; total_number_of_bytes = wapi_total_number_of_bytes.QuadPart; total_number_of_free_bytes = wapi_total_number_of_free_bytes.QuadPart; } else { free_bytes_avail = 0; total_number_of_bytes = 0; total_number_of_free_bytes = 0; error = GetLastError (); } return result; } static guint32 ves_icall_System_IO_DriveInfo_GetDriveType (MonoString root_path_name) { MONO_ARCH_SAVE_REGS; return GetDriveType (mono_string_chars (root_path_name)); } #endif static gpointer ves_icall_RuntimeMethod_GetFunctionPointer (MonoMethod method) { MONO_ARCH_SAVE_REGS; return mono_compile_method (method); } static MonoString ves_icall_System_Configuration_DefaultConfig_get_machine_config_path (void) { MonoString mcpath; gchar path; MONO_ARCH_SAVE_REGS; path = g_build_path (G_DIR_SEPARATOR_S, mono_get_config_dir (), "mono", mono_get_runtime_info ()->framework_version, "machine.config", NULL); #if defined (PLATFORM_WIN32) /* Avoid mixing '/' and '\\' / { gint i; for (i = strlen (path) - 1; i >= 0; i--) if (path [i] == '/') path [i] = '\\'; } #endif mcpath = mono_string_new (mono_domain_get (), path); g_free (path); return mcpath; } static MonoString get_bundled_machine_config (void) { const gchar machine_config; MONO_ARCH_SAVE_REGS; machine_config = mono_get_machine_config (); if (!machine_config) return NULL; return mono_string_new (mono_domain_get (), machine_config); } static MonoString ves_icall_System_Web_Util_ICalls_get_machine_install_dir (void) { MonoString ipath; gchar path; MONO_ARCH_SAVE_REGS; path = g_path_get_dirname (mono_get_config_dir ()); #if defined (PLATFORM_WIN32) /* Avoid mixing '/' and '\\' / { gint i; for (i = strlen (path) - 1; i >= 0; i--) if (path [i] == '/') path [i] = '\\'; } #endif ipath = mono_string_new (mono_domain_get (), path); g_free (path); return ipath; } static gboolean ves_icall_get_resources_ptr (MonoReflectionAssembly assembly, gpointer result, gint32 size) { MonoPEResourceDataEntry entry; MonoImage image; MONO_ARCH_SAVE_REGS; if (!assembly \|\| !result \|\| !size) return FALSE; result = NULL; size = 0; image = assembly->assembly->image; entry = mono_image_lookup_resource (image, MONO_PE_RESOURCE_ID_ASPNET_STRING, 0, NULL); if (!entry) return FALSE; result = mono_image_rva_map (image, entry->rde_data_offset); if (!(result)) { g_free (entry); return FALSE; } size = entry->rde_size; g_free (entry); return TRUE; } static MonoBoolean ves_icall_System_Diagnostics_Debugger_IsAttached_internal (void) { return mono_debug_using_mono_debugger () \|\| mono_is_debugger_attached (); } static void ves_icall_System_Diagnostics_DefaultTraceListener_WriteWindowsDebugString (MonoString message) { #if defined (PLATFORM_WIN32) OutputDebugString (mono_string_chars (message)); #else g_warning ("WriteWindowsDebugString called and PLATFORM_WIN32 not defined!\n"); #endif } /* Only used for value types / static MonoObject ves_icall_System_Activator_CreateInstanceInternal (MonoReflectionType type) { MonoClass klass; MonoDomain domain; MONO_ARCH_SAVE_REGS; domain = mono_object_domain (type); klass = mono_class_from_mono_type (type->type); if (mono_class_is_nullable (klass)) / No arguments -> null / return NULL; return mono_object_new (domain, klass); } static MonoReflectionMethod ves_icall_MonoMethod_get_base_definition (MonoReflectionMethod m) { MonoClass klass, parent; MonoMethod method = m->method; MonoMethod result = NULL; MONO_ARCH_SAVE_REGS; if (method->klass == NULL) return m; if (!(method->flags & METHOD_ATTRIBUTE_VIRTUAL) \|\| MONO_CLASS_IS_INTERFACE (method->klass) \|\| method->flags & METHOD_ATTRIBUTE_NEW_SLOT) return m; klass = method->klass; if (klass->generic_class) klass = klass->generic_class->container_class; / At the end of the loop, klass points to the eldest class that has this virtual function slot. / for (parent = klass->parent; parent != NULL; parent = parent->parent) { mono_class_setup_vtable (parent); if (parent->vtable_size <= method->slot) break; klass = parent; } if (klass == method->klass) return m; result = klass->vtable [method->slot]; if (result == NULL) { / It is an abstract method / gpointer iter = NULL; while ((result = mono_class_get_methods (klass, &iter))) if (result->slot == method->slot) break; } if (result == NULL) return m; return mono_method_get_object (mono_domain_get (), result, NULL); } static MonoString ves_icall_MonoMethod_get_name (MonoReflectionMethod m) { MonoMethod method = m->method; MONO_OBJECT_SETREF (m, name, mono_string_new (mono_object_domain (m), method->name)); return m->name; } static void mono_ArgIterator_Setup (MonoArgIterator iter, char argsp, char* start) { MONO_ARCH_SAVE_REGS; iter->sig = (MonoMethodSignature)argsp; g_assert (iter->sig->sentinelpos <= iter->sig->param_count); g_assert (iter->sig->call_convention == MONO_CALL_VARARG); iter->next_arg = 0; / FIXME: it's not documented what start is exactly... / if (start) { iter->args = start; } else { iter->args = argsp + sizeof (gpointer); #ifndef MONO_ARCH_REGPARMS { guint32 i, arg_size; gint32 align; for (i = 0; i < iter->sig->sentinelpos; ++i) { arg_size = mono_type_stack_size (iter->sig->params [i], &align); iter->args = (char)iter->args + arg_size; } } #endif } iter->num_args = iter->sig->param_count - iter->sig->sentinelpos; /* g_print ("sig %p, param_count: %d, sent: %d\n", iter->sig, iter->sig->param_count, iter->sig->sentinelpos); / } static MonoTypedRef mono_ArgIterator_IntGetNextArg (MonoArgIterator iter) { guint32 i, arg_size; gint32 align; MonoTypedRef res; MONO_ARCH_SAVE_REGS; i = iter->sig->sentinelpos + iter->next_arg; g_assert (i < iter->sig->param_count); res.type = iter->sig->params [i]; res.klass = mono_class_from_mono_type (res.type); res.value = iter->args; arg_size = mono_type_stack_size (res.type, &align); #if G_BYTE_ORDER != G_LITTLE_ENDIAN if (arg_size <= sizeof (gpointer)) { int dummy; int padding = arg_size - mono_type_size (res.type, &dummy); res.value = (guint8)res.value + padding; } #endif iter->args = (char)iter->args + arg_size; iter->next_arg++; /* g_print ("returning arg %d, type 0x%02x of size %d at %p\n", i, res.type->type, arg_size, res.value); / return res; } static MonoTypedRef mono_ArgIterator_IntGetNextArgT (MonoArgIterator iter, MonoType type) { guint32 i, arg_size; gint32 align; MonoTypedRef res; MONO_ARCH_SAVE_REGS; i = iter->sig->sentinelpos + iter->next_arg; g_assert (i < iter->sig->param_count); while (i < iter->sig->param_count) { if (!mono_metadata_type_equal (type, iter->sig->params [i])) continue; res.type = iter->sig->params [i]; res.klass = mono_class_from_mono_type (res.type); / FIXME: endianess issue... / res.value = iter->args; arg_size = mono_type_stack_size (res.type, &align); iter->args = (char)iter->args + arg_size; iter->next_arg++; /* g_print ("returning arg %d, type 0x%02x of size %d at %p\n", i, res.type->type, arg_size, res.value); / return res; } / g_print ("arg type 0x%02x not found\n", res.type->type); / res.type = NULL; res.value = NULL; res.klass = NULL; return res; } static MonoType mono_ArgIterator_IntGetNextArgType (MonoArgIterator iter) { gint i; MONO_ARCH_SAVE_REGS; i = iter->sig->sentinelpos + iter->next_arg; g_assert (i < iter->sig->param_count); return iter->sig->params [i]; } static MonoObject mono_TypedReference_ToObject (MonoTypedRef tref) { MONO_ARCH_SAVE_REGS; if (MONO_TYPE_IS_REFERENCE (tref.type)) { MonoObject** objp = tref.value; return objp; } return mono_value_box (mono_domain_get (), tref.klass, tref.value); } static MonoObject mono_TypedReference_ToObjectInternal (MonoType type, gpointer value, MonoClass klass) { MONO_ARCH_SAVE_REGS; if (MONO_TYPE_IS_REFERENCE (type)) { MonoObject** objp = value; return objp; } return mono_value_box (mono_domain_get (), klass, value); } static void prelink_method (MonoMethod method) { const char exc_class, exc_arg; if (!(method->flags & METHOD_ATTRIBUTE_PINVOKE_IMPL)) return; mono_lookup_pinvoke_call (method, &exc_class, &exc_arg); if (exc_class) { mono_raise_exception( mono_exception_from_name_msg (mono_defaults.corlib, "System", exc_class, exc_arg ) ); } /* create the wrapper, too? / } static void ves_icall_System_Runtime_InteropServices_Marshal_Prelink (MonoReflectionMethod method) { MONO_ARCH_SAVE_REGS; prelink_method (method->method); } static void ves_icall_System_Runtime_InteropServices_Marshal_PrelinkAll (MonoReflectionType type) { MonoClass klass = mono_class_from_mono_type (type->type); MonoMethod* m; gpointer iter = NULL; MONO_ARCH_SAVE_REGS; while ((m = mono_class_get_methods (klass, &iter))) prelink_method (m); } /* These parameters are "readonly" in corlib/System/NumberFormatter.cs / static void ves_icall_System_NumberFormatter_GetFormatterTables (guint64 const mantissas, gint32 const exponents, gunichar2 const digitLowerTable, gunichar2 const digitUpperTable, gint64 const tenPowersList, gint32 const decHexDigits) { mantissas = Formatter_MantissaBitsTable; exponents = Formatter_TensExponentTable; digitLowerTable = Formatter_DigitLowerTable; digitUpperTable = Formatter_DigitUpperTable; tenPowersList = Formatter_TenPowersList; decHexDigits = Formatter_DecHexDigits; } / These parameters are "readonly" in corlib/System/Char.cs / static void ves_icall_System_Char_GetDataTablePointers (guint8 const category_data, guint8 const numeric_data, gdouble const numeric_data_values, guint16 const to_lower_data_low, guint16 const to_lower_data_high, guint16 const to_upper_data_low, guint16 const to_upper_data_high) { category_data = CategoryData; numeric_data = NumericData; numeric_data_values = NumericDataValues; to_lower_data_low = ToLowerDataLow; to_lower_data_high = ToLowerDataHigh; to_upper_data_low = ToUpperDataLow; to_upper_data_high = ToUpperDataHigh; } static gint32 ves_icall_MonoDebugger_GetMethodToken (MonoReflectionMethod method) { return method->method->token; } / * We return NULL for no modifiers so the corlib code can return Type.EmptyTypes * and avoid useless allocations. / static MonoArray type_array_from_modifiers (MonoImage image, MonoType type, int optional) { MonoArray res; int i, count = 0; for (i = 0; i < type->num_mods; ++i) { if ((optional && !type->modifiers [i].required) \|\| (!optional && type->modifiers [i].required)) count++; } if (!count) return NULL; res = mono_array_new (mono_domain_get (), mono_defaults.systemtype_class, count); count = 0; for (i = 0; i < type->num_mods; ++i) { if ((optional && !type->modifiers [i].required) \|\| (!optional && type->modifiers [i].required)) { MonoClass klass = mono_class_get (image, type->modifiers [i].token); mono_array_setref (res, count, mono_type_get_object (mono_domain_get (), &klass->byval_arg)); count++; } } return res; } static MonoArray* param_info_get_type_modifiers (MonoReflectionParameter param, MonoBoolean optional) { MonoType type = param->ClassImpl->type; MonoClass member_class = mono_object_class (param->MemberImpl); MonoMethod method = NULL; MonoImage image; int pos; MonoMethodSignature sig; if (mono_class_is_reflection_method_or_constructor (member_class)) { MonoReflectionMethod rmethod = (MonoReflectionMethod)param->MemberImpl; method = rmethod->method; } else if (member_class->image == mono_defaults.corlib && !strcmp ("MonoProperty", member_class->name)) { MonoReflectionProperty prop = (MonoReflectionProperty )param->MemberImpl; if (!(method = prop->property->get)) method = prop->property->set; g_assert (method); } else { char type_name = mono_type_get_full_name (member_class); char msg = g_strdup_printf ("Custom modifiers on a ParamInfo with member %s are not supported", type_name); MonoException ex = mono_get_exception_not_supported (msg); g_free (type_name); g_free (msg); mono_raise_exception (ex); } image = method->klass->image; pos = param->PositionImpl; sig = mono_method_signature (method); if (pos == -1) type = sig->ret; else type = sig->params [pos]; return type_array_from_modifiers (image, type, optional); } static MonoType get_property_type (MonoProperty prop) { MonoMethodSignature sig; if (prop->get) { sig = mono_method_signature (prop->get); return sig->ret; } else if (prop->set) { sig = mono_method_signature (prop->set); return sig->params [sig->param_count - 1]; } return NULL; } static MonoArray* property_info_get_type_modifiers (MonoReflectionProperty property, MonoBoolean optional) { MonoType type = get_property_type (property->property); MonoImage image = property->klass->image; if (!type) return NULL; return type_array_from_modifiers (image, type, optional); } static MonoBoolean custom_attrs_defined_internal (MonoObject obj, MonoReflectionType attr_type) { MonoCustomAttrInfo cinfo; gboolean found; cinfo = mono_reflection_get_custom_attrs_info (obj); if (!cinfo) return FALSE; found = mono_custom_attrs_has_attr (cinfo, mono_class_from_mono_type (attr_type->type)); if (!cinfo->cached) mono_custom_attrs_free (cinfo); return found; } static MonoArray* custom_attrs_get_by_type (MonoObject obj, MonoReflectionType attr_type) { MonoArray res = mono_reflection_get_custom_attrs_by_type (obj, attr_type ? mono_class_from_mono_type (attr_type->type) : NULL); if (mono_loader_get_last_error ()) { mono_raise_exception (mono_loader_error_prepare_exception (mono_loader_get_last_error ())); g_assert_not_reached (); / Not reached / return NULL; } else { return res; } } static MonoString ves_icall_Mono_Runtime_GetDisplayName (void) { char info; MonoString display_name; info = mono_get_runtime_callbacks ()->get_runtime_build_info (); display_name = mono_string_new (mono_domain_get (), info); g_free (info); return display_name; } static MonoString* ves_icall_System_ComponentModel_Win32Exception_W32ErrorMessage (guint32 code) { MonoString message; guint32 ret; gunichar2 buf[256]; ret = FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM \| FORMAT_MESSAGE_IGNORE_INSERTS, NULL, code, 0, buf, 255, NULL); if (ret == 0) { message = mono_string_new (mono_domain_get (), "Error looking up error string"); } else { message = mono_string_new_utf16 (mono_domain_get (), buf, ret); } return message; } const static guchar dbase64 [] = { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 62, 128, 128, 128, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 128, 128, 128, 0, 128, 128, 128, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 128, 128, 128, 128, 128, 128, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51 }; static MonoArray base64_to_byte_array (gunichar2 start, gint ilength, MonoBoolean allowWhitespaceOnly) { gint ignored; gint i; gunichar2 c; gunichar2 last, prev_last, prev2_last; gint olength; MonoArray result; guchar res_ptr; gint a [4], b [4]; MonoException exc; ignored = 0; last = prev_last = 0, prev2_last = 0; for (i = 0; i < ilength; i++) { c = start [i]; if (c >= sizeof (dbase64)) { exc = mono_exception_from_name_msg (mono_get_corlib (), "System", "FormatException", "Invalid character found."); mono_raise_exception (exc); } else if (isspace (c)) { ignored++; } else { prev2_last = prev_last; prev_last = last; last = c; } } olength = ilength - ignored; if (allowWhitespaceOnly && olength == 0) { return mono_array_new (mono_domain_get (), mono_defaults.byte_class, 0); } if ((olength & 3) != 0 \|\| olength <= 0) { exc = mono_exception_from_name_msg (mono_get_corlib (), "System", "FormatException", "Invalid length."); mono_raise_exception (exc); } if (prev2_last == '=') { exc = mono_exception_from_name_msg (mono_get_corlib (), "System", "FormatException", "Invalid format."); mono_raise_exception (exc); } olength = (olength * 3) / 4; if (last == '=') olength--; if (prev_last == '=') olength--; result = mono_array_new (mono_domain_get (), mono_defaults.byte_class, olength); res_ptr = mono_array_addr (result, guchar, 0); for (i = 0; i < ilength; ) { int k; for (k = 0; k < 4 && i < ilength;) { c = start [i++]; if (isspace (c)) continue; a [k] = (guchar) c; if (((b [k] = dbase64 [c]) & 0x80) != 0) { exc = mono_exception_from_name_msg (mono_get_corlib (), "System", "FormatException", "Invalid character found."); mono_raise_exception (exc); } k++; } res_ptr++ = (b [0] << 2) \| (b [1] >> 4); if (a [2] != '=') res_ptr++ = (b [1] << 4) \| (b [2] >> 2); if (a [3] != '=') res_ptr++ = (b [2] << 6) \| b [3]; while (i < ilength && isspace (start [i])) i++; } return result; } static MonoArray InternalFromBase64String (MonoString str, MonoBoolean allowWhitespaceOnly) { MONO_ARCH_SAVE_REGS; return base64_to_byte_array (mono_string_chars (str), mono_string_length (str), allowWhitespaceOnly); } static MonoArray InternalFromBase64CharArray (MonoArray input, gint offset, gint length) { MONO_ARCH_SAVE_REGS; return base64_to_byte_array (mono_array_addr (input, gunichar2, offset), length, FALSE); } #define ICALL_TYPE(id,name,first) #define ICALL(id,name,func) Icall_ ## id, enum { #include "metadata/icall-def.h" Icall_last }; #undef ICALL_TYPE #undef ICALL #define ICALL_TYPE(id,name,first) Icall_type_ ## id, #define ICALL(id,name,func) enum { #include "metadata/icall-def.h" Icall_type_num }; #undef ICALL_TYPE #undef ICALL #define ICALL_TYPE(id,name,firstic) {(Icall_ ## firstic)}, #define ICALL(id,name,func) typedef struct { guint16 first_icall; } IcallTypeDesc; static const IcallTypeDesc icall_type_descs [] = { #include "metadata/icall-def.h" {Icall_last} }; #define icall_desc_num_icalls(desc) ((desc) [1].first_icall - (desc) [0].first_icall) #undef ICALL_TYPE #define ICALL_TYPE(id,name,first) #undef ICALL #ifdef HAVE_ARRAY_ELEM_INIT #define MSGSTRFIELD(line) MSGSTRFIELD1(line) #define MSGSTRFIELD1(line) str##line static const struct msgstrtn_t { #define ICALL(id,name,func) #undef ICALL_TYPE #define ICALL_TYPE(id,name,first) char MSGSTRFIELD(__LINE__) [sizeof (name)]; #include "metadata/icall-def.h" #undef ICALL_TYPE } icall_type_names_str = { #define ICALL_TYPE(id,name,first) (name), #include "metadata/icall-def.h" #undef ICALL_TYPE }; static const guint16 icall_type_names_idx [] = { #define ICALL_TYPE(id,name,first) [Icall_type_ ## id] = offsetof (struct msgstrtn_t, MSGSTRFIELD(__LINE__)), #include "metadata/icall-def.h" #undef ICALL_TYPE }; #define icall_type_name_get(id) ((const char)&icall_type_names_str + icall_type_names_idx [(id)]) static const struct msgstr_t { #undef ICALL #define ICALL_TYPE(id,name,first) #define ICALL(id,name,func) char MSGSTRFIELD(__LINE__) [sizeof (name)]; #include "metadata/icall-def.h" #undef ICALL } icall_names_str = { #define ICALL(id,name,func) (name), #include "metadata/icall-def.h" #undef ICALL }; static const guint16 icall_names_idx [] = { #define ICALL(id,name,func) [Icall_ ## id] = offsetof (struct msgstr_t, MSGSTRFIELD(__LINE__)), #include "metadata/icall-def.h" #undef ICALL }; #define icall_name_get(id) ((const char)&icall_names_str + icall_names_idx [(id)]) #else #undef ICALL_TYPE #undef ICALL #define ICALL_TYPE(id,name,first) name, #define ICALL(id,name,func) static const char const icall_type_names [] = { #include "metadata/icall-def.h" NULL }; #define icall_type_name_get(id) (icall_type_names [(id)]) #undef ICALL_TYPE #undef ICALL #define ICALL_TYPE(id,name,first) #define ICALL(id,name,func) name, static const char* const icall_names [] = { #include "metadata/icall-def.h" NULL }; #define icall_name_get(id) icall_names [(id)] #endif /* !HAVE_ARRAY_ELEM_INIT / #undef ICALL_TYPE #undef ICALL #define ICALL_TYPE(id,name,first) #define ICALL(id,name,func) func, static const gconstpointer icall_functions [] = { #include "metadata/icall-def.h" NULL }; static GHashTable icall_hash = NULL; static GHashTable jit_icall_hash_name = NULL; static GHashTable jit_icall_hash_addr = NULL; void mono_icall_init (void) { int i = 0; /* check that tables are sorted: disable in release / if (TRUE) { int j; const char prev_class = NULL; const char prev_method; for (i = 0; i < Icall_type_num; ++i) { const IcallTypeDesc desc; int num_icalls; prev_method = NULL; if (prev_class && strcmp (prev_class, icall_type_name_get (i)) >= 0) g_print ("class %s should come before class %s\n", icall_type_name_get (i), prev_class); prev_class = icall_type_name_get (i); desc = &icall_type_descs [i]; num_icalls = icall_desc_num_icalls (desc); /g_print ("class %s has %d icalls starting at %d\n", prev_class, num_icalls, desc->first_icall);/ for (j = 0; j < num_icalls; ++j) { const char methodn = icall_name_get (desc->first_icall + j); if (prev_method && strcmp (prev_method, methodn) >= 0) g_print ("method %s should come before method %s\n", methodn, prev_method); prev_method = methodn; } } } icall_hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL); } void mono_icall_cleanup (void) { g_hash_table_destroy (icall_hash); g_hash_table_destroy (jit_icall_hash_name); g_hash_table_destroy (jit_icall_hash_addr); } void mono_add_internal_call (const char name, gconstpointer method) { mono_loader_lock (); g_hash_table_insert (icall_hash, g_strdup (name), (gpointer) method); mono_loader_unlock (); } #ifdef HAVE_ARRAY_ELEM_INIT static int compare_method_imap (const void key, const void elem) { const char* method_name = (const char)&icall_names_str + ((guint16)elem); return strcmp (key, method_name); } static gpointer find_method_icall (const IcallTypeDesc imap, const char name) { const guint16 nameslot = bsearch (name, icall_names_idx + imap->first_icall, icall_desc_num_icalls (imap), sizeof (icall_names_idx [0]), compare_method_imap); if (!nameslot) return NULL; return (gpointer)icall_functions [(nameslot - &icall_names_idx [0])]; } static int compare_class_imap (const void key, const void elem) { const char* class_name = (const char)&icall_type_names_str + ((guint16)elem); return strcmp (key, class_name); } static const IcallTypeDesc find_class_icalls (const char name) { const guint16 nameslot = bsearch (name, icall_type_names_idx, Icall_type_num, sizeof (icall_type_names_idx [0]), compare_class_imap); if (!nameslot) return NULL; return &icall_type_descs [nameslot - &icall_type_names_idx [0]]; } #else static int compare_method_imap (const void key, const void elem) { const char method_name = (const char)elem; return strcmp (key, method_name); } static gpointer find_method_icall (const IcallTypeDesc imap, const char name) { const char nameslot = bsearch (name, icall_names + imap->first_icall, icall_desc_num_icalls (imap), sizeof (icall_names [0]), compare_method_imap); if (!nameslot) return NULL; return (gpointer)icall_functions [(nameslot - icall_names)]; } static int compare_class_imap (const void key, const void elem) { const char* class_name = (const char*)elem; return strcmp (key, class_name); } static const IcallTypeDesc* find_class_icalls (const char name) { const char nameslot = bsearch (name, icall_type_names, Icall_type_num, sizeof (icall_type_names [0]), compare_class_imap); if (!nameslot) return NULL; return &icall_type_descs [nameslot - icall_type_names]; } #endif / * we should probably export this as an helper (handle nested types). * Returns the number of chars written in buf. / static int concat_class_name (char buf, int bufsize, MonoClass klass) { int nspacelen, cnamelen; nspacelen = strlen (klass->name_space); cnamelen = strlen (klass->name); if (nspacelen + cnamelen + 2 > bufsize) return 0; if (nspacelen) { memcpy (buf, klass->name_space, nspacelen); buf [nspacelen ++] = '.'; } memcpy (buf + nspacelen, klass->name, cnamelen); buf [nspacelen + cnamelen] = 0; return nspacelen + cnamelen; } gpointer mono_lookup_internal_call (MonoMethod method) { char sigstart; char tmpsig; char mname [2048]; int typelen = 0, mlen, siglen; gpointer res; const IcallTypeDesc imap; g_assert (method != NULL); if (method->is_inflated) method = ((MonoMethodInflated ) method)->declaring; if (method->klass->nested_in) { int pos = concat_class_name (mname, sizeof (mname)-2, method->klass->nested_in); if (!pos) return NULL; mname [pos++] = '/'; mname [pos] = 0; typelen = concat_class_name (mname+pos, sizeof (mname)-pos-1, method->klass); if (!typelen) return NULL; typelen += pos; } else { typelen = concat_class_name (mname, sizeof (mname), method->klass); if (!typelen) return NULL; } imap = find_class_icalls (mname); mname [typelen] = ':'; mname [typelen + 1] = ':'; mlen = strlen (method->name); memcpy (mname + typelen + 2, method->name, mlen); sigstart = mname + typelen + 2 + mlen; sigstart = 0; tmpsig = mono_signature_get_desc (mono_method_signature (method), TRUE); siglen = strlen (tmpsig); if (typelen + mlen + siglen + 6 > sizeof (mname)) return NULL; sigstart [0] = '('; memcpy (sigstart + 1, tmpsig, siglen); sigstart [siglen + 1] = ')'; sigstart [siglen + 2] = 0; g_free (tmpsig); mono_loader_lock (); res = g_hash_table_lookup (icall_hash, mname); if (res) { mono_loader_unlock (); return res; } / try without signature / sigstart = 0; res = g_hash_table_lookup (icall_hash, mname); if (res) { mono_loader_unlock (); return res; } /* it wasn't found in the static call tables / if (!imap) { mono_loader_unlock (); return NULL; } res = find_method_icall (imap, sigstart - mlen); if (res) { mono_loader_unlock (); return res; } / try _with_ signature / sigstart = '('; res = find_method_icall (imap, sigstart - mlen); if (res) { mono_loader_unlock (); return res; } g_warning ("cant resolve internal call to \"%s\" (tested without signature also)", mname); g_print ("\nYour mono runtime and class libraries are out of sync.\n"); g_print ("The out of sync library is: %s\n", method->klass->image->name); g_print ("\nWhen you update one from svn you need to update, compile and install\nthe other too.\n"); g_print ("Do not report this as a bug unless you're sure you have updated correctly:\nyou probably have a broken mono install.\n"); g_print ("If you see other errors or faults after this message they are probably related\n"); g_print ("and you need to fix your mono install first.\n"); mono_loader_unlock (); return NULL; } static MonoType* type_from_typename (char typename) { MonoClass klass = NULL; /* assignment to shut GCC warning up / if (!strcmp (typename, "int")) klass = mono_defaults.int_class; else if (!strcmp (typename, "ptr")) klass = mono_defaults.int_class; else if (!strcmp (typename, "void")) klass = mono_defaults.void_class; else if (!strcmp (typename, "int32")) klass = mono_defaults.int32_class; else if (!strcmp (typename, "uint32")) klass = mono_defaults.uint32_class; else if (!strcmp (typename, "int8")) klass = mono_defaults.sbyte_class; else if (!strcmp (typename, "uint8")) klass = mono_defaults.byte_class; else if (!strcmp (typename, "int16")) klass = mono_defaults.int16_class; else if (!strcmp (typename, "uint16")) klass = mono_defaults.uint16_class; else if (!strcmp (typename, "long")) klass = mono_defaults.int64_class; else if (!strcmp (typename, "ulong")) klass = mono_defaults.uint64_class; else if (!strcmp (typename, "float")) klass = mono_defaults.single_class; else if (!strcmp (typename, "double")) klass = mono_defaults.double_class; else if (!strcmp (typename, "object")) klass = mono_defaults.object_class; else if (!strcmp (typename, "obj")) klass = mono_defaults.object_class; else if (!strcmp (typename, "string")) klass = mono_defaults.string_class; else if (!strcmp (typename, "bool")) klass = mono_defaults.boolean_class; else if (!strcmp (typename, "boolean")) klass = mono_defaults.boolean_class; else { g_error ("%s", typename); g_assert_not_reached (); } return &klass->byval_arg; } MonoMethodSignature mono_create_icall_signature (const char sigstr) { gchar parts; int i, len; gchar tmp; MonoMethodSignature res; mono_loader_lock (); res = g_hash_table_lookup (mono_defaults.corlib->helper_signatures, sigstr); if (res) { mono_loader_unlock (); return res; } parts = g_strsplit (sigstr, " ", 256); tmp = parts; len = 0; while (tmp) { len ++; tmp ++; } res = mono_metadata_signature_alloc (mono_defaults.corlib, len - 1); res->pinvoke = 1; #ifdef PLATFORM_WIN32 / * Under windows, the default pinvoke calling convention is STDCALL but * we need CDECL. / res->call_convention = MONO_CALL_C; #endif res->ret = type_from_typename (parts [0]); for (i = 1; i < len; ++i) { res->params [i - 1] = type_from_typename (parts [i]); } g_strfreev (parts); g_hash_table_insert (mono_defaults.corlib->helper_signatures, (gpointer)sigstr, res); mono_loader_unlock (); return res; } MonoJitICallInfo mono_find_jit_icall_by_name (const char name) { MonoJitICallInfo info; g_assert (jit_icall_hash_name); mono_loader_lock (); info = g_hash_table_lookup (jit_icall_hash_name, name); mono_loader_unlock (); return info; } MonoJitICallInfo * mono_find_jit_icall_by_addr (gconstpointer addr) { MonoJitICallInfo info; g_assert (jit_icall_hash_addr); mono_loader_lock (); info = g_hash_table_lookup (jit_icall_hash_addr, (gpointer)addr); mono_loader_unlock (); return info; } / * mono_get_jit_icall_info: * * Return the hashtable mapping JIT icall names to MonoJitICallInfo structures. The * caller should access it while holding the loader lock. / GHashTable mono_get_jit_icall_info (void) { return jit_icall_hash_name; } void mono_register_jit_icall_wrapper (MonoJitICallInfo info, gconstpointer wrapper) { mono_loader_lock (); g_hash_table_insert (jit_icall_hash_addr, (gpointer)wrapper, info); mono_loader_unlock (); } MonoJitICallInfo mono_register_jit_icall (gconstpointer func, const char name, MonoMethodSignature sig, gboolean is_save) { MonoJitICallInfo *info; g_assert (func); g_assert (name); mono_loader_lock (); if (!jit_icall_hash_name) { jit_icall_hash_name = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, g_free); jit_icall_hash_addr = g_hash_table_new (NULL, NULL); } if (g_hash_table_lookup (jit_icall_hash_name, name)) { g_warning ("jit icall already defined \"%s\"\n", name); g_assert_not_reached (); } info = g_new0 (MonoJitICallInfo, 1); info->name = name; info->func = func; info->sig = sig; if (is_save) { info->wrapper = func; } else { info->wrapper = NULL; } g_hash_table_insert (jit_icall_hash_name, (gpointer)info->name, info); g_hash_table_insert (jit_icall_hash_addr, (gpointer)func, info); mono_loader_unlock (); return info; }	./CrossVul/dataset_final_sorted/CWE-264/c/good_3429_0
crossvul-cpp_data_bad_2190_2	/* * linux/fs/namei.c * * Copyright (C) 1991, 1992 Linus Torvalds / / * Some corrections by tytso. / / [Feb 1997 T. Schoebel-Theuer] Complete rewrite of the pathname * lookup logic. / / [Feb-Apr 2000, AV] Rewrite to the new namespace architecture. / #include <linux/init.h> #include <linux/export.h> #include <linux/kernel.h> #include <linux/slab.h> #include <linux/fs.h> #include <linux/namei.h> #include <linux/pagemap.h> #include <linux/fsnotify.h> #include <linux/personality.h> #include <linux/security.h> #include <linux/ima.h> #include <linux/syscalls.h> #include <linux/mount.h> #include <linux/audit.h> #include <linux/capability.h> #include <linux/file.h> #include <linux/fcntl.h> #include <linux/device_cgroup.h> #include <linux/fs_struct.h> #include <linux/posix_acl.h> #include <asm/uaccess.h> #include "internal.h" #include "mount.h" / [Feb-1997 T. Schoebel-Theuer] * Fundamental changes in the pathname lookup mechanisms (namei) * were necessary because of omirr. The reason is that omirr needs * to know the _real_ pathname, not the user-supplied one, in case * of symlinks (and also when transname replacements occur). * * The new code replaces the old recursive symlink resolution with * an iterative one (in case of non-nested symlink chains). It does * this with calls to <fs>_follow_link(). * As a side effect, dir_namei(), _namei() and follow_link() are now * replaced with a single function lookup_dentry() that can handle all * the special cases of the former code. * * With the new dcache, the pathname is stored at each inode, at least as * long as the refcount of the inode is positive. As a side effect, the * size of the dcache depends on the inode cache and thus is dynamic. * * [29-Apr-1998 C. Scott Ananian] Updated above description of symlink * resolution to correspond with current state of the code. * * Note that the symlink resolution is not completely iterative. * There is still a significant amount of tail- and mid- recursion in * the algorithm. Also, note that <fs>_readlink() is not used in * lookup_dentry(): lookup_dentry() on the result of <fs>_readlink() * may return different results than <fs>_follow_link(). Many virtual * filesystems (including /proc) exhibit this behavior. / / [24-Feb-97 T. Schoebel-Theuer] Side effects caused by new implementation: * New symlink semantics: when open() is called with flags O_CREAT \| O_EXCL * and the name already exists in form of a symlink, try to create the new * name indicated by the symlink. The old code always complained that the * name already exists, due to not following the symlink even if its target * is nonexistent. The new semantics affects also mknod() and link() when * the name is a symlink pointing to a non-existent name. * * I don't know which semantics is the right one, since I have no access * to standards. But I found by trial that HP-UX 9.0 has the full "new" * semantics implemented, while SunOS 4.1.1 and Solaris (SunOS 5.4) have the * "old" one. Personally, I think the new semantics is much more logical. * Note that "ln old new" where "new" is a symlink pointing to a non-existing * file does succeed in both HP-UX and SunOs, but not in Solaris * and in the old Linux semantics. / / [16-Dec-97 Kevin Buhr] For security reasons, we change some symlink * semantics. See the comments in "open_namei" and "do_link" below. * * [10-Sep-98 Alan Modra] Another symlink change. / / [Feb-Apr 2000 AV] Complete rewrite. Rules for symlinks: * inside the path - always follow. * in the last component in creation/removal/renaming - never follow. * if LOOKUP_FOLLOW passed - follow. * if the pathname has trailing slashes - follow. * otherwise - don't follow. * (applied in that order). * * [Jun 2000 AV] Inconsistent behaviour of open() in case if flags==O_CREAT * restored for 2.4. This is the last surviving part of old 4.2BSD bug. * During the 2.4 we need to fix the userland stuff depending on it - * hopefully we will be able to get rid of that wart in 2.5. So far only * XEmacs seems to be relying on it... / / * [Sep 2001 AV] Single-semaphore locking scheme (kudos to David Holland) * implemented. Let's see if raised priority of ->s_vfs_rename_mutex gives * any extra contention... / / In order to reduce some races, while at the same time doing additional * checking and hopefully speeding things up, we copy filenames to the * kernel data space before using them.. * * POSIX.1 2.4: an empty pathname is invalid (ENOENT). * PATH_MAX includes the nul terminator --RR. / void final_putname(struct filename name) { if (name->separate) { __putname(name->name); kfree(name); } else { __putname(name); } } #define EMBEDDED_NAME_MAX (PATH_MAX - sizeof(struct filename)) static struct filename * getname_flags(const char __user filename, int flags, int empty) { struct filename result, err; int len; long max; char kname; result = audit_reusename(filename); if (result) return result; result = __getname(); if (unlikely(!result)) return ERR_PTR(-ENOMEM); / * First, try to embed the struct filename inside the names_cache * allocation / kname = (char )result + sizeof(result); result->name = kname; result->separate = false; max = EMBEDDED_NAME_MAX; recopy: len = strncpy_from_user(kname, filename, max); if (unlikely(len < 0)) { err = ERR_PTR(len); goto error; } / * Uh-oh. We have a name that's approaching PATH_MAX. Allocate a * separate struct filename so we can dedicate the entire * names_cache allocation for the pathname, and re-do the copy from * userland. / if (len == EMBEDDED_NAME_MAX && max == EMBEDDED_NAME_MAX) { kname = (char )result; result = kzalloc(sizeof(result), GFP_KERNEL); if (!result) { err = ERR_PTR(-ENOMEM); result = (struct filename )kname; goto error; } result->name = kname; result->separate = true; max = PATH_MAX; goto recopy; } /* The empty path is special. / if (unlikely(!len)) { if (empty) empty = 1; err = ERR_PTR(-ENOENT); if (!(flags & LOOKUP_EMPTY)) goto error; } err = ERR_PTR(-ENAMETOOLONG); if (unlikely(len >= PATH_MAX)) goto error; result->uptr = filename; result->aname = NULL; audit_getname(result); return result; error: final_putname(result); return err; } struct filename * getname(const char __user * filename) { return getname_flags(filename, 0, NULL); } /* * The "getname_kernel()" interface doesn't do pathnames longer * than EMBEDDED_NAME_MAX. Deal with it - you're a kernel user. / struct filename getname_kernel(const char * filename) { struct filename result; char kname; int len; len = strlen(filename); if (len >= EMBEDDED_NAME_MAX) return ERR_PTR(-ENAMETOOLONG); result = __getname(); if (unlikely(!result)) return ERR_PTR(-ENOMEM); kname = (char )result + sizeof(result); result->name = kname; result->uptr = NULL; result->aname = NULL; result->separate = false; strlcpy(kname, filename, EMBEDDED_NAME_MAX); return result; } #ifdef CONFIG_AUDITSYSCALL void putname(struct filename name) { if (unlikely(!audit_dummy_context())) return audit_putname(name); final_putname(name); } #endif static int check_acl(struct inode inode, int mask) { #ifdef CONFIG_FS_POSIX_ACL struct posix_acl acl; if (mask & MAY_NOT_BLOCK) { acl = get_cached_acl_rcu(inode, ACL_TYPE_ACCESS); if (!acl) return -EAGAIN; / no ->get_acl() calls in RCU mode... / if (acl == ACL_NOT_CACHED) return -ECHILD; return posix_acl_permission(inode, acl, mask & ~MAY_NOT_BLOCK); } acl = get_acl(inode, ACL_TYPE_ACCESS); if (IS_ERR(acl)) return PTR_ERR(acl); if (acl) { int error = posix_acl_permission(inode, acl, mask); posix_acl_release(acl); return error; } #endif return -EAGAIN; } / * This does the basic permission checking / static int acl_permission_check(struct inode inode, int mask) { unsigned int mode = inode->i_mode; if (likely(uid_eq(current_fsuid(), inode->i_uid))) mode >>= 6; else { if (IS_POSIXACL(inode) && (mode & S_IRWXG)) { int error = check_acl(inode, mask); if (error != -EAGAIN) return error; } if (in_group_p(inode->i_gid)) mode >>= 3; } /* * If the DACs are ok we don't need any capability check. / if ((mask & ~mode & (MAY_READ \| MAY_WRITE \| MAY_EXEC)) == 0) return 0; return -EACCES; } /* * generic_permission - check for access rights on a Posix-like filesystem * @inode: inode to check access rights for * @mask: right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC, ...) * * Used to check for read/write/execute permissions on a file. * We use "fsuid" for this, letting us set arbitrary permissions * for filesystem access without changing the "normal" uids which * are used for other things. * * generic_permission is rcu-walk aware. It returns -ECHILD in case an rcu-walk * request cannot be satisfied (eg. requires blocking or too much complexity). * It would then be called again in ref-walk mode. / int generic_permission(struct inode inode, int mask) { int ret; /* * Do the basic permission checks. / ret = acl_permission_check(inode, mask); if (ret != -EACCES) return ret; if (S_ISDIR(inode->i_mode)) { / DACs are overridable for directories / if (inode_capable(inode, CAP_DAC_OVERRIDE)) return 0; if (!(mask & MAY_WRITE)) if (inode_capable(inode, CAP_DAC_READ_SEARCH)) return 0; return -EACCES; } / * Read/write DACs are always overridable. * Executable DACs are overridable when there is * at least one exec bit set. / if (!(mask & MAY_EXEC) \|\| (inode->i_mode & S_IXUGO)) if (inode_capable(inode, CAP_DAC_OVERRIDE)) return 0; / * Searching includes executable on directories, else just read. / mask &= MAY_READ \| MAY_WRITE \| MAY_EXEC; if (mask == MAY_READ) if (inode_capable(inode, CAP_DAC_READ_SEARCH)) return 0; return -EACCES; } EXPORT_SYMBOL(generic_permission); / * We _really_ want to just do "generic_permission()" without * even looking at the inode->i_op values. So we keep a cache * flag in inode->i_opflags, that says "this has not special * permission function, use the fast case". / static inline int do_inode_permission(struct inode inode, int mask) { if (unlikely(!(inode->i_opflags & IOP_FASTPERM))) { if (likely(inode->i_op->permission)) return inode->i_op->permission(inode, mask); /* This gets set once for the inode lifetime / spin_lock(&inode->i_lock); inode->i_opflags \|= IOP_FASTPERM; spin_unlock(&inode->i_lock); } return generic_permission(inode, mask); } /* * __inode_permission - Check for access rights to a given inode * @inode: Inode to check permission on * @mask: Right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC) * * Check for read/write/execute permissions on an inode. * * When checking for MAY_APPEND, MAY_WRITE must also be set in @mask. * * This does not check for a read-only file system. You probably want * inode_permission(). / int __inode_permission(struct inode inode, int mask) { int retval; if (unlikely(mask & MAY_WRITE)) { /* * Nobody gets write access to an immutable file. / if (IS_IMMUTABLE(inode)) return -EACCES; } retval = do_inode_permission(inode, mask); if (retval) return retval; retval = devcgroup_inode_permission(inode, mask); if (retval) return retval; return security_inode_permission(inode, mask); } /* * sb_permission - Check superblock-level permissions * @sb: Superblock of inode to check permission on * @inode: Inode to check permission on * @mask: Right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC) * * Separate out file-system wide checks from inode-specific permission checks. / static int sb_permission(struct super_block sb, struct inode inode, int mask) { if (unlikely(mask & MAY_WRITE)) { umode_t mode = inode->i_mode; / Nobody gets write access to a read-only fs. / if ((sb->s_flags & MS_RDONLY) && (S_ISREG(mode) \|\| S_ISDIR(mode) \|\| S_ISLNK(mode))) return -EROFS; } return 0; } /* * inode_permission - Check for access rights to a given inode * @inode: Inode to check permission on * @mask: Right to check for (%MAY_READ, %MAY_WRITE, %MAY_EXEC) * * Check for read/write/execute permissions on an inode. We use fs[ug]id for * this, letting us set arbitrary permissions for filesystem access without * changing the "normal" UIDs which are used for other things. * * When checking for MAY_APPEND, MAY_WRITE must also be set in @mask. / int inode_permission(struct inode inode, int mask) { int retval; retval = sb_permission(inode->i_sb, inode, mask); if (retval) return retval; return __inode_permission(inode, mask); } EXPORT_SYMBOL(inode_permission); /** * path_get - get a reference to a path * @path: path to get the reference to * * Given a path increment the reference count to the dentry and the vfsmount. / void path_get(const struct path path) { mntget(path->mnt); dget(path->dentry); } EXPORT_SYMBOL(path_get); /** * path_put - put a reference to a path * @path: path to put the reference to * * Given a path decrement the reference count to the dentry and the vfsmount. / void path_put(const struct path path) { dput(path->dentry); mntput(path->mnt); } EXPORT_SYMBOL(path_put); /* * Path walking has 2 modes, rcu-walk and ref-walk (see * Documentation/filesystems/path-lookup.txt). In situations when we can't * continue in RCU mode, we attempt to drop out of rcu-walk mode and grab * normal reference counts on dentries and vfsmounts to transition to rcu-walk * mode. Refcounts are grabbed at the last known good point before rcu-walk * got stuck, so ref-walk may continue from there. If this is not successful * (eg. a seqcount has changed), then failure is returned and it's up to caller * to restart the path walk from the beginning in ref-walk mode. / /* * unlazy_walk - try to switch to ref-walk mode. * @nd: nameidata pathwalk data * @dentry: child of nd->path.dentry or NULL * Returns: 0 on success, -ECHILD on failure * * unlazy_walk attempts to legitimize the current nd->path, nd->root and dentry * for ref-walk mode. @dentry must be a path found by a do_lookup call on * @nd or NULL. Must be called from rcu-walk context. / static int unlazy_walk(struct nameidata nd, struct dentry dentry) { struct fs_struct fs = current->fs; struct dentry parent = nd->path.dentry; BUG_ON(!(nd->flags & LOOKUP_RCU)); / * After legitimizing the bastards, terminate_walk() * will do the right thing for non-RCU mode, and all our * subsequent exit cases should rcu_read_unlock() * before returning. Do vfsmount first; if dentry * can't be legitimized, just set nd->path.dentry to NULL * and rely on dput(NULL) being a no-op. / if (!legitimize_mnt(nd->path.mnt, nd->m_seq)) return -ECHILD; nd->flags &= ~LOOKUP_RCU; if (!lockref_get_not_dead(&parent->d_lockref)) { nd->path.dentry = NULL; goto out; } / * For a negative lookup, the lookup sequence point is the parents * sequence point, and it only needs to revalidate the parent dentry. * * For a positive lookup, we need to move both the parent and the * dentry from the RCU domain to be properly refcounted. And the * sequence number in the dentry validates both dentry counters, * since we checked the sequence number of the parent after we got * the child sequence number. So we know the parent must still * be valid if the child sequence number is still valid. / if (!dentry) { if (read_seqcount_retry(&parent->d_seq, nd->seq)) goto out; BUG_ON(nd->inode != parent->d_inode); } else { if (!lockref_get_not_dead(&dentry->d_lockref)) goto out; if (read_seqcount_retry(&dentry->d_seq, nd->seq)) goto drop_dentry; } / * Sequence counts matched. Now make sure that the root is * still valid and get it if required. / if (nd->root.mnt && !(nd->flags & LOOKUP_ROOT)) { spin_lock(&fs->lock); if (nd->root.mnt != fs->root.mnt \|\| nd->root.dentry != fs->root.dentry) goto unlock_and_drop_dentry; path_get(&nd->root); spin_unlock(&fs->lock); } rcu_read_unlock(); return 0; unlock_and_drop_dentry: spin_unlock(&fs->lock); drop_dentry: rcu_read_unlock(); dput(dentry); goto drop_root_mnt; out: rcu_read_unlock(); drop_root_mnt: if (!(nd->flags & LOOKUP_ROOT)) nd->root.mnt = NULL; return -ECHILD; } static inline int d_revalidate(struct dentry dentry, unsigned int flags) { return dentry->d_op->d_revalidate(dentry, flags); } /** * complete_walk - successful completion of path walk * @nd: pointer nameidata * * If we had been in RCU mode, drop out of it and legitimize nd->path. * Revalidate the final result, unless we'd already done that during * the path walk or the filesystem doesn't ask for it. Return 0 on * success, -error on failure. In case of failure caller does not * need to drop nd->path. / static int complete_walk(struct nameidata nd) { struct dentry dentry = nd->path.dentry; int status; if (nd->flags & LOOKUP_RCU) { nd->flags &= ~LOOKUP_RCU; if (!(nd->flags & LOOKUP_ROOT)) nd->root.mnt = NULL; if (!legitimize_mnt(nd->path.mnt, nd->m_seq)) { rcu_read_unlock(); return -ECHILD; } if (unlikely(!lockref_get_not_dead(&dentry->d_lockref))) { rcu_read_unlock(); mntput(nd->path.mnt); return -ECHILD; } if (read_seqcount_retry(&dentry->d_seq, nd->seq)) { rcu_read_unlock(); dput(dentry); mntput(nd->path.mnt); return -ECHILD; } rcu_read_unlock(); } if (likely(!(nd->flags & LOOKUP_JUMPED))) return 0; if (likely(!(dentry->d_flags & DCACHE_OP_WEAK_REVALIDATE))) return 0; status = dentry->d_op->d_weak_revalidate(dentry, nd->flags); if (status > 0) return 0; if (!status) status = -ESTALE; path_put(&nd->path); return status; } static __always_inline void set_root(struct nameidata nd) { if (!nd->root.mnt) get_fs_root(current->fs, &nd->root); } static int link_path_walk(const char , struct nameidata ); static __always_inline void set_root_rcu(struct nameidata nd) { if (!nd->root.mnt) { struct fs_struct fs = current->fs; unsigned seq; do { seq = read_seqcount_begin(&fs->seq); nd->root = fs->root; nd->seq = __read_seqcount_begin(&nd->root.dentry->d_seq); } while (read_seqcount_retry(&fs->seq, seq)); } } static void path_put_conditional(struct path path, struct nameidata nd) { dput(path->dentry); if (path->mnt != nd->path.mnt) mntput(path->mnt); } static inline void path_to_nameidata(const struct path path, struct nameidata nd) { if (!(nd->flags & LOOKUP_RCU)) { dput(nd->path.dentry); if (nd->path.mnt != path->mnt) mntput(nd->path.mnt); } nd->path.mnt = path->mnt; nd->path.dentry = path->dentry; } /* * Helper to directly jump to a known parsed path from ->follow_link, * caller must have taken a reference to path beforehand. / void nd_jump_link(struct nameidata nd, struct path path) { path_put(&nd->path); nd->path = path; nd->inode = nd->path.dentry->d_inode; nd->flags \|= LOOKUP_JUMPED; } static inline void put_link(struct nameidata nd, struct path link, void cookie) { struct inode inode = link->dentry->d_inode; if (inode->i_op->put_link) inode->i_op->put_link(link->dentry, nd, cookie); path_put(link); } int sysctl_protected_symlinks __read_mostly = 0; int sysctl_protected_hardlinks __read_mostly = 0; /** * may_follow_link - Check symlink following for unsafe situations * @link: The path of the symlink * @nd: nameidata pathwalk data * * In the case of the sysctl_protected_symlinks sysctl being enabled, * CAP_DAC_OVERRIDE needs to be specifically ignored if the symlink is * in a sticky world-writable directory. This is to protect privileged * processes from failing races against path names that may change out * from under them by way of other users creating malicious symlinks. * It will permit symlinks to be followed only when outside a sticky * world-writable directory, or when the uid of the symlink and follower * match, or when the directory owner matches the symlink's owner. * * Returns 0 if following the symlink is allowed, -ve on error. / static inline int may_follow_link(struct path link, struct nameidata nd) { const struct inode inode; const struct inode parent; if (!sysctl_protected_symlinks) return 0; / Allowed if owner and follower match. / inode = link->dentry->d_inode; if (uid_eq(current_cred()->fsuid, inode->i_uid)) return 0; / Allowed if parent directory not sticky and world-writable. / parent = nd->path.dentry->d_inode; if ((parent->i_mode & (S_ISVTX\|S_IWOTH)) != (S_ISVTX\|S_IWOTH)) return 0; / Allowed if parent directory and link owner match. / if (uid_eq(parent->i_uid, inode->i_uid)) return 0; audit_log_link_denied("follow_link", link); path_put_conditional(link, nd); path_put(&nd->path); return -EACCES; } /* * safe_hardlink_source - Check for safe hardlink conditions * @inode: the source inode to hardlink from * * Return false if at least one of the following conditions: * - inode is not a regular file * - inode is setuid * - inode is setgid and group-exec * - access failure for read and write * * Otherwise returns true. / static bool safe_hardlink_source(struct inode inode) { umode_t mode = inode->i_mode; /* Special files should not get pinned to the filesystem. / if (!S_ISREG(mode)) return false; / Setuid files should not get pinned to the filesystem. / if (mode & S_ISUID) return false; / Executable setgid files should not get pinned to the filesystem. / if ((mode & (S_ISGID \| S_IXGRP)) == (S_ISGID \| S_IXGRP)) return false; / Hardlinking to unreadable or unwritable sources is dangerous. / if (inode_permission(inode, MAY_READ \| MAY_WRITE)) return false; return true; } /* * may_linkat - Check permissions for creating a hardlink * @link: the source to hardlink from * * Block hardlink when all of: * - sysctl_protected_hardlinks enabled * - fsuid does not match inode * - hardlink source is unsafe (see safe_hardlink_source() above) * - not CAP_FOWNER * * Returns 0 if successful, -ve on error. / static int may_linkat(struct path link) { const struct cred cred; struct inode inode; if (!sysctl_protected_hardlinks) return 0; cred = current_cred(); inode = link->dentry->d_inode; /* Source inode owner (or CAP_FOWNER) can hardlink all they like, * otherwise, it must be a safe source. / if (uid_eq(cred->fsuid, inode->i_uid) \|\| safe_hardlink_source(inode) \|\| capable(CAP_FOWNER)) return 0; audit_log_link_denied("linkat", link); return -EPERM; } static __always_inline int follow_link(struct path link, struct nameidata nd, void p) { struct dentry dentry = link->dentry; int error; char s; BUG_ON(nd->flags & LOOKUP_RCU); if (link->mnt == nd->path.mnt) mntget(link->mnt); error = -ELOOP; if (unlikely(current->total_link_count >= 40)) goto out_put_nd_path; cond_resched(); current->total_link_count++; touch_atime(link); nd_set_link(nd, NULL); error = security_inode_follow_link(link->dentry, nd); if (error) goto out_put_nd_path; nd->last_type = LAST_BIND; p = dentry->d_inode->i_op->follow_link(dentry, nd); error = PTR_ERR(p); if (IS_ERR(p)) goto out_put_nd_path; error = 0; s = nd_get_link(nd); if (s) { if (unlikely(IS_ERR(s))) { path_put(&nd->path); put_link(nd, link, p); return PTR_ERR(s); } if (s == '/') { set_root(nd); path_put(&nd->path); nd->path = nd->root; path_get(&nd->root); nd->flags \|= LOOKUP_JUMPED; } nd->inode = nd->path.dentry->d_inode; error = link_path_walk(s, nd); if (unlikely(error)) put_link(nd, link, p); } return error; out_put_nd_path: p = NULL; path_put(&nd->path); path_put(link); return error; } static int follow_up_rcu(struct path path) { struct mount mnt = real_mount(path->mnt); struct mount parent; struct dentry mountpoint; parent = mnt->mnt_parent; if (&parent->mnt == path->mnt) return 0; mountpoint = mnt->mnt_mountpoint; path->dentry = mountpoint; path->mnt = &parent->mnt; return 1; } /* * follow_up - Find the mountpoint of path's vfsmount * * Given a path, find the mountpoint of its source file system. * Replace @path with the path of the mountpoint in the parent mount. * Up is towards /. * * Return 1 if we went up a level and 0 if we were already at the * root. / int follow_up(struct path path) { struct mount mnt = real_mount(path->mnt); struct mount parent; struct dentry mountpoint; read_seqlock_excl(&mount_lock); parent = mnt->mnt_parent; if (parent == mnt) { read_sequnlock_excl(&mount_lock); return 0; } mntget(&parent->mnt); mountpoint = dget(mnt->mnt_mountpoint); read_sequnlock_excl(&mount_lock); dput(path->dentry); path->dentry = mountpoint; mntput(path->mnt); path->mnt = &parent->mnt; return 1; } EXPORT_SYMBOL(follow_up); / * Perform an automount * - return -EISDIR to tell follow_managed() to stop and return the path we * were called with. / static int follow_automount(struct path path, unsigned flags, bool need_mntput) { struct vfsmount mnt; int err; if (!path->dentry->d_op \|\| !path->dentry->d_op->d_automount) return -EREMOTE; /* We don't want to mount if someone's just doing a stat - * unless they're stat'ing a directory and appended a '/' to * the name. * * We do, however, want to mount if someone wants to open or * create a file of any type under the mountpoint, wants to * traverse through the mountpoint or wants to open the * mounted directory. Also, autofs may mark negative dentries * as being automount points. These will need the attentions * of the daemon to instantiate them before they can be used. / if (!(flags & (LOOKUP_PARENT \| LOOKUP_DIRECTORY \| LOOKUP_OPEN \| LOOKUP_CREATE \| LOOKUP_AUTOMOUNT)) && path->dentry->d_inode) return -EISDIR; current->total_link_count++; if (current->total_link_count >= 40) return -ELOOP; mnt = path->dentry->d_op->d_automount(path); if (IS_ERR(mnt)) { / * The filesystem is allowed to return -EISDIR here to indicate * it doesn't want to automount. For instance, autofs would do * this so that its userspace daemon can mount on this dentry. * * However, we can only permit this if it's a terminal point in * the path being looked up; if it wasn't then the remainder of * the path is inaccessible and we should say so. / if (PTR_ERR(mnt) == -EISDIR && (flags & LOOKUP_PARENT)) return -EREMOTE; return PTR_ERR(mnt); } if (!mnt) / mount collision / return 0; if (!need_mntput) { /* lock_mount() may release path->mnt on error / mntget(path->mnt); need_mntput = true; } err = finish_automount(mnt, path); switch (err) { case -EBUSY: /* Someone else made a mount here whilst we were busy / return 0; case 0: path_put(path); path->mnt = mnt; path->dentry = dget(mnt->mnt_root); return 0; default: return err; } } / * Handle a dentry that is managed in some way. * - Flagged for transit management (autofs) * - Flagged as mountpoint * - Flagged as automount point * * This may only be called in refwalk mode. * * Serialization is taken care of in namespace.c / static int follow_managed(struct path path, unsigned flags) { struct vfsmount mnt = path->mnt; / held by caller, must be left alone / unsigned managed; bool need_mntput = false; int ret = 0; / Given that we're not holding a lock here, we retain the value in a * local variable for each dentry as we look at it so that we don't see * the components of that value change under us / while (managed = ACCESS_ONCE(path->dentry->d_flags), managed &= DCACHE_MANAGED_DENTRY, unlikely(managed != 0)) { / Allow the filesystem to manage the transit without i_mutex * being held. / if (managed & DCACHE_MANAGE_TRANSIT) { BUG_ON(!path->dentry->d_op); BUG_ON(!path->dentry->d_op->d_manage); ret = path->dentry->d_op->d_manage(path->dentry, false); if (ret < 0) break; } / Transit to a mounted filesystem. / if (managed & DCACHE_MOUNTED) { struct vfsmount mounted = lookup_mnt(path); if (mounted) { dput(path->dentry); if (need_mntput) mntput(path->mnt); path->mnt = mounted; path->dentry = dget(mounted->mnt_root); need_mntput = true; continue; } /* Something is mounted on this dentry in another * namespace and/or whatever was mounted there in this * namespace got unmounted before lookup_mnt() could * get it / } / Handle an automount point / if (managed & DCACHE_NEED_AUTOMOUNT) { ret = follow_automount(path, flags, &need_mntput); if (ret < 0) break; continue; } / We didn't change the current path point / break; } if (need_mntput && path->mnt == mnt) mntput(path->mnt); if (ret == -EISDIR) ret = 0; return ret < 0 ? ret : need_mntput; } int follow_down_one(struct path path) { struct vfsmount mounted; mounted = lookup_mnt(path); if (mounted) { dput(path->dentry); mntput(path->mnt); path->mnt = mounted; path->dentry = dget(mounted->mnt_root); return 1; } return 0; } EXPORT_SYMBOL(follow_down_one); static inline bool managed_dentry_might_block(struct dentry dentry) { return (dentry->d_flags & DCACHE_MANAGE_TRANSIT && dentry->d_op->d_manage(dentry, true) < 0); } /* * Try to skip to top of mountpoint pile in rcuwalk mode. Fail if * we meet a managed dentry that would need blocking. / static bool __follow_mount_rcu(struct nameidata nd, struct path path, struct inode inode) { for (;;) { struct mount mounted; /* * Don't forget we might have a non-mountpoint managed dentry * that wants to block transit. / if (unlikely(managed_dentry_might_block(path->dentry))) return false; if (!d_mountpoint(path->dentry)) return true; mounted = __lookup_mnt(path->mnt, path->dentry); if (!mounted) break; path->mnt = &mounted->mnt; path->dentry = mounted->mnt.mnt_root; nd->flags \|= LOOKUP_JUMPED; nd->seq = read_seqcount_begin(&path->dentry->d_seq); / * Update the inode too. We don't need to re-check the * dentry sequence number here after this d_inode read, * because a mount-point is always pinned. / inode = path->dentry->d_inode; } return read_seqretry(&mount_lock, nd->m_seq); } static int follow_dotdot_rcu(struct nameidata nd) { set_root_rcu(nd); while (1) { if (nd->path.dentry == nd->root.dentry && nd->path.mnt == nd->root.mnt) { break; } if (nd->path.dentry != nd->path.mnt->mnt_root) { struct dentry old = nd->path.dentry; struct dentry parent = old->d_parent; unsigned seq; seq = read_seqcount_begin(&parent->d_seq); if (read_seqcount_retry(&old->d_seq, nd->seq)) goto failed; nd->path.dentry = parent; nd->seq = seq; break; } if (!follow_up_rcu(&nd->path)) break; nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq); } while (d_mountpoint(nd->path.dentry)) { struct mount mounted; mounted = __lookup_mnt(nd->path.mnt, nd->path.dentry); if (!mounted) break; nd->path.mnt = &mounted->mnt; nd->path.dentry = mounted->mnt.mnt_root; nd->seq = read_seqcount_begin(&nd->path.dentry->d_seq); if (!read_seqretry(&mount_lock, nd->m_seq)) goto failed; } nd->inode = nd->path.dentry->d_inode; return 0; failed: nd->flags &= ~LOOKUP_RCU; if (!(nd->flags & LOOKUP_ROOT)) nd->root.mnt = NULL; rcu_read_unlock(); return -ECHILD; } /* * Follow down to the covering mount currently visible to userspace. At each * point, the filesystem owning that dentry may be queried as to whether the * caller is permitted to proceed or not. / int follow_down(struct path path) { unsigned managed; int ret; while (managed = ACCESS_ONCE(path->dentry->d_flags), unlikely(managed & DCACHE_MANAGED_DENTRY)) { /* Allow the filesystem to manage the transit without i_mutex * being held. * * We indicate to the filesystem if someone is trying to mount * something here. This gives autofs the chance to deny anyone * other than its daemon the right to mount on its * superstructure. * * The filesystem may sleep at this point. / if (managed & DCACHE_MANAGE_TRANSIT) { BUG_ON(!path->dentry->d_op); BUG_ON(!path->dentry->d_op->d_manage); ret = path->dentry->d_op->d_manage( path->dentry, false); if (ret < 0) return ret == -EISDIR ? 0 : ret; } / Transit to a mounted filesystem. / if (managed & DCACHE_MOUNTED) { struct vfsmount mounted = lookup_mnt(path); if (!mounted) break; dput(path->dentry); mntput(path->mnt); path->mnt = mounted; path->dentry = dget(mounted->mnt_root); continue; } /* Don't handle automount points here / break; } return 0; } EXPORT_SYMBOL(follow_down); / * Skip to top of mountpoint pile in refwalk mode for follow_dotdot() / static void follow_mount(struct path path) { while (d_mountpoint(path->dentry)) { struct vfsmount mounted = lookup_mnt(path); if (!mounted) break; dput(path->dentry); mntput(path->mnt); path->mnt = mounted; path->dentry = dget(mounted->mnt_root); } } static void follow_dotdot(struct nameidata nd) { set_root(nd); while(1) { struct dentry old = nd->path.dentry; if (nd->path.dentry == nd->root.dentry && nd->path.mnt == nd->root.mnt) { break; } if (nd->path.dentry != nd->path.mnt->mnt_root) { / rare case of legitimate dget_parent()... / nd->path.dentry = dget_parent(nd->path.dentry); dput(old); break; } if (!follow_up(&nd->path)) break; } follow_mount(&nd->path); nd->inode = nd->path.dentry->d_inode; } / * This looks up the name in dcache, possibly revalidates the old dentry and * allocates a new one if not found or not valid. In the need_lookup argument * returns whether i_op->lookup is necessary. * * dir->d_inode->i_mutex must be held / static struct dentry lookup_dcache(struct qstr name, struct dentry dir, unsigned int flags, bool need_lookup) { struct dentry dentry; int error; need_lookup = false; dentry = d_lookup(dir, name); if (dentry) { if (dentry->d_flags & DCACHE_OP_REVALIDATE) { error = d_revalidate(dentry, flags); if (unlikely(error <= 0)) { if (error < 0) { dput(dentry); return ERR_PTR(error); } else if (!d_invalidate(dentry)) { dput(dentry); dentry = NULL; } } } } if (!dentry) { dentry = d_alloc(dir, name); if (unlikely(!dentry)) return ERR_PTR(-ENOMEM); need_lookup = true; } return dentry; } /* * Call i_op->lookup on the dentry. The dentry must be negative and * unhashed. * * dir->d_inode->i_mutex must be held / static struct dentry lookup_real(struct inode dir, struct dentry dentry, unsigned int flags) { struct dentry old; / Don't create child dentry for a dead directory. / if (unlikely(IS_DEADDIR(dir))) { dput(dentry); return ERR_PTR(-ENOENT); } old = dir->i_op->lookup(dir, dentry, flags); if (unlikely(old)) { dput(dentry); dentry = old; } return dentry; } static struct dentry __lookup_hash(struct qstr name, struct dentry base, unsigned int flags) { bool need_lookup; struct dentry dentry; dentry = lookup_dcache(name, base, flags, &need_lookup); if (!need_lookup) return dentry; return lookup_real(base->d_inode, dentry, flags); } / * It's more convoluted than I'd like it to be, but... it's still fairly * small and for now I'd prefer to have fast path as straight as possible. * It _is_ time-critical. / static int lookup_fast(struct nameidata nd, struct path path, struct inode inode) { struct vfsmount mnt = nd->path.mnt; struct dentry dentry, parent = nd->path.dentry; int need_reval = 1; int status = 1; int err; /* * Rename seqlock is not required here because in the off chance * of a false negative due to a concurrent rename, we're going to * do the non-racy lookup, below. / if (nd->flags & LOOKUP_RCU) { unsigned seq; dentry = __d_lookup_rcu(parent, &nd->last, &seq); if (!dentry) goto unlazy; / * This sequence count validates that the inode matches * the dentry name information from lookup. / inode = dentry->d_inode; if (read_seqcount_retry(&dentry->d_seq, seq)) return -ECHILD; /* * This sequence count validates that the parent had no * changes while we did the lookup of the dentry above. * * The memory barrier in read_seqcount_begin of child is * enough, we can use __read_seqcount_retry here. / if (__read_seqcount_retry(&parent->d_seq, nd->seq)) return -ECHILD; nd->seq = seq; if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE)) { status = d_revalidate(dentry, nd->flags); if (unlikely(status <= 0)) { if (status != -ECHILD) need_reval = 0; goto unlazy; } } path->mnt = mnt; path->dentry = dentry; if (unlikely(!__follow_mount_rcu(nd, path, inode))) goto unlazy; if (unlikely(path->dentry->d_flags & DCACHE_NEED_AUTOMOUNT)) goto unlazy; return 0; unlazy: if (unlazy_walk(nd, dentry)) return -ECHILD; } else { dentry = __d_lookup(parent, &nd->last); } if (unlikely(!dentry)) goto need_lookup; if (unlikely(dentry->d_flags & DCACHE_OP_REVALIDATE) && need_reval) status = d_revalidate(dentry, nd->flags); if (unlikely(status <= 0)) { if (status < 0) { dput(dentry); return status; } if (!d_invalidate(dentry)) { dput(dentry); goto need_lookup; } } path->mnt = mnt; path->dentry = dentry; err = follow_managed(path, nd->flags); if (unlikely(err < 0)) { path_put_conditional(path, nd); return err; } if (err) nd->flags \|= LOOKUP_JUMPED; inode = path->dentry->d_inode; return 0; need_lookup: return 1; } /* Fast lookup failed, do it the slow way / static int lookup_slow(struct nameidata nd, struct path path) { struct dentry dentry, parent; int err; parent = nd->path.dentry; BUG_ON(nd->inode != parent->d_inode); mutex_lock(&parent->d_inode->i_mutex); dentry = __lookup_hash(&nd->last, parent, nd->flags); mutex_unlock(&parent->d_inode->i_mutex); if (IS_ERR(dentry)) return PTR_ERR(dentry); path->mnt = nd->path.mnt; path->dentry = dentry; err = follow_managed(path, nd->flags); if (unlikely(err < 0)) { path_put_conditional(path, nd); return err; } if (err) nd->flags \|= LOOKUP_JUMPED; return 0; } static inline int may_lookup(struct nameidata nd) { if (nd->flags & LOOKUP_RCU) { int err = inode_permission(nd->inode, MAY_EXEC\|MAY_NOT_BLOCK); if (err != -ECHILD) return err; if (unlazy_walk(nd, NULL)) return -ECHILD; } return inode_permission(nd->inode, MAY_EXEC); } static inline int handle_dots(struct nameidata nd, int type) { if (type == LAST_DOTDOT) { if (nd->flags & LOOKUP_RCU) { if (follow_dotdot_rcu(nd)) return -ECHILD; } else follow_dotdot(nd); } return 0; } static void terminate_walk(struct nameidata nd) { if (!(nd->flags & LOOKUP_RCU)) { path_put(&nd->path); } else { nd->flags &= ~LOOKUP_RCU; if (!(nd->flags & LOOKUP_ROOT)) nd->root.mnt = NULL; rcu_read_unlock(); } } /* * Do we need to follow links? We _really_ want to be able * to do this check without having to look at inode->i_op, * so we keep a cache of "no, this doesn't need follow_link" * for the common case. / static inline int should_follow_link(struct dentry dentry, int follow) { return unlikely(d_is_symlink(dentry)) ? follow : 0; } static inline int walk_component(struct nameidata nd, struct path path, int follow) { struct inode inode; int err; / * "." and ".." are special - ".." especially so because it has * to be able to know about the current root directory and * parent relationships. / if (unlikely(nd->last_type != LAST_NORM)) return handle_dots(nd, nd->last_type); err = lookup_fast(nd, path, &inode); if (unlikely(err)) { if (err < 0) goto out_err; err = lookup_slow(nd, path); if (err < 0) goto out_err; inode = path->dentry->d_inode; } err = -ENOENT; if (!inode \|\| d_is_negative(path->dentry)) goto out_path_put; if (should_follow_link(path->dentry, follow)) { if (nd->flags & LOOKUP_RCU) { if (unlikely(unlazy_walk(nd, path->dentry))) { err = -ECHILD; goto out_err; } } BUG_ON(inode != path->dentry->d_inode); return 1; } path_to_nameidata(path, nd); nd->inode = inode; return 0; out_path_put: path_to_nameidata(path, nd); out_err: terminate_walk(nd); return err; } / * This limits recursive symlink follows to 8, while * limiting consecutive symlinks to 40. * * Without that kind of total limit, nasty chains of consecutive * symlinks can cause almost arbitrarily long lookups. / static inline int nested_symlink(struct path path, struct nameidata nd) { int res; if (unlikely(current->link_count >= MAX_NESTED_LINKS)) { path_put_conditional(path, nd); path_put(&nd->path); return -ELOOP; } BUG_ON(nd->depth >= MAX_NESTED_LINKS); nd->depth++; current->link_count++; do { struct path link = path; void cookie; res = follow_link(&link, nd, &cookie); if (res) break; res = walk_component(nd, path, LOOKUP_FOLLOW); put_link(nd, &link, cookie); } while (res > 0); current->link_count--; nd->depth--; return res; } / * We can do the critical dentry name comparison and hashing * operations one word at a time, but we are limited to: * * - Architectures with fast unaligned word accesses. We could * do a "get_unaligned()" if this helps and is sufficiently * fast. * * - non-CONFIG_DEBUG_PAGEALLOC configurations (so that we * do not trap on the (extremely unlikely) case of a page * crossing operation. * * - Furthermore, we need an efficient 64-bit compile for the * 64-bit case in order to generate the "number of bytes in * the final mask". Again, that could be replaced with a * efficient population count instruction or similar. / #ifdef CONFIG_DCACHE_WORD_ACCESS #include <asm/word-at-a-time.h> #ifdef CONFIG_64BIT static inline unsigned int fold_hash(unsigned long hash) { hash += hash >> (8sizeof(int)); return hash; } #else /* 32-bit case / #define fold_hash(x) (x) #endif unsigned int full_name_hash(const unsigned char name, unsigned int len) { unsigned long a, mask; unsigned long hash = 0; for (;;) { a = load_unaligned_zeropad(name); if (len < sizeof(unsigned long)) break; hash += a; hash = 9; name += sizeof(unsigned long); len -= sizeof(unsigned long); if (!len) goto done; } mask = bytemask_from_count(len); hash += mask & a; done: return fold_hash(hash); } EXPORT_SYMBOL(full_name_hash); / * Calculate the length and hash of the path component, and * return the length of the component; / static inline unsigned long hash_name(const char name, unsigned int hashp) { unsigned long a, b, adata, bdata, mask, hash, len; const struct word_at_a_time constants = WORD_AT_A_TIME_CONSTANTS; hash = a = 0; len = -sizeof(unsigned long); do { hash = (hash + a) 9; len += sizeof(unsigned long); a = load_unaligned_zeropad(name+len); b = a ^ REPEAT_BYTE('/'); } while (!(has_zero(a, &adata, &constants) \| has_zero(b, &bdata, &constants))); adata = prep_zero_mask(a, adata, &constants); bdata = prep_zero_mask(b, bdata, &constants); mask = create_zero_mask(adata \| bdata); hash += a & zero_bytemask(mask); hashp = fold_hash(hash); return len + find_zero(mask); } #else unsigned int full_name_hash(const unsigned char name, unsigned int len) { unsigned long hash = init_name_hash(); while (len--) hash = partial_name_hash(name++, hash); return end_name_hash(hash); } EXPORT_SYMBOL(full_name_hash); / * We know there's a real path component here of at least * one character. / static inline unsigned long hash_name(const char name, unsigned int hashp) { unsigned long hash = init_name_hash(); unsigned long len = 0, c; c = (unsigned char)name; do { len++; hash = partial_name_hash(c, hash); c = (unsigned char)name[len]; } while (c && c != '/'); hashp = end_name_hash(hash); return len; } #endif / * Name resolution. * This is the basic name resolution function, turning a pathname into * the final dentry. We expect 'base' to be positive and a directory. * * Returns 0 and nd will have valid dentry and mnt on success. * Returns error and drops reference to input namei data on failure. / static int link_path_walk(const char name, struct nameidata nd) { struct path next; int err; while (name=='/') name++; if (!name) return 0; / At this point we know we have a real path component. / for(;;) { struct qstr this; long len; int type; err = may_lookup(nd); if (err) break; len = hash_name(name, &this.hash); this.name = name; this.len = len; type = LAST_NORM; if (name[0] == '.') switch (len) { case 2: if (name[1] == '.') { type = LAST_DOTDOT; nd->flags \|= LOOKUP_JUMPED; } break; case 1: type = LAST_DOT; } if (likely(type == LAST_NORM)) { struct dentry parent = nd->path.dentry; nd->flags &= ~LOOKUP_JUMPED; if (unlikely(parent->d_flags & DCACHE_OP_HASH)) { err = parent->d_op->d_hash(parent, &this); if (err < 0) break; } } nd->last = this; nd->last_type = type; if (!name[len]) return 0; /* * If it wasn't NUL, we know it was '/'. Skip that * slash, and continue until no more slashes. / do { len++; } while (unlikely(name[len] == '/')); if (!name[len]) return 0; name += len; err = walk_component(nd, &next, LOOKUP_FOLLOW); if (err < 0) return err; if (err) { err = nested_symlink(&next, nd); if (err) return err; } if (!d_can_lookup(nd->path.dentry)) { err = -ENOTDIR; break; } } terminate_walk(nd); return err; } static int path_init(int dfd, const char name, unsigned int flags, struct nameidata nd, struct file fp) { int retval = 0; nd->last_type = LAST_ROOT; / if there are only slashes... / nd->flags = flags \| LOOKUP_JUMPED; nd->depth = 0; if (flags & LOOKUP_ROOT) { struct dentry root = nd->root.dentry; struct inode inode = root->d_inode; if (name) { if (!d_can_lookup(root)) return -ENOTDIR; retval = inode_permission(inode, MAY_EXEC); if (retval) return retval; } nd->path = nd->root; nd->inode = inode; if (flags & LOOKUP_RCU) { rcu_read_lock(); nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq); nd->m_seq = read_seqbegin(&mount_lock); } else { path_get(&nd->path); } return 0; } nd->root.mnt = NULL; nd->m_seq = read_seqbegin(&mount_lock); if (name=='/') { if (flags & LOOKUP_RCU) { rcu_read_lock(); set_root_rcu(nd); } else { set_root(nd); path_get(&nd->root); } nd->path = nd->root; } else if (dfd == AT_FDCWD) { if (flags & LOOKUP_RCU) { struct fs_struct fs = current->fs; unsigned seq; rcu_read_lock(); do { seq = read_seqcount_begin(&fs->seq); nd->path = fs->pwd; nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq); } while (read_seqcount_retry(&fs->seq, seq)); } else { get_fs_pwd(current->fs, &nd->path); } } else { /* Caller must check execute permissions on the starting path component / struct fd f = fdget_raw(dfd); struct dentry dentry; if (!f.file) return -EBADF; dentry = f.file->f_path.dentry; if (name) { if (!d_can_lookup(dentry)) { fdput(f); return -ENOTDIR; } } nd->path = f.file->f_path; if (flags & LOOKUP_RCU) { if (f.flags & FDPUT_FPUT) fp = f.file; nd->seq = __read_seqcount_begin(&nd->path.dentry->d_seq); rcu_read_lock(); } else { path_get(&nd->path); fdput(f); } } nd->inode = nd->path.dentry->d_inode; return 0; } static inline int lookup_last(struct nameidata nd, struct path path) { if (nd->last_type == LAST_NORM && nd->last.name[nd->last.len]) nd->flags \|= LOOKUP_FOLLOW \| LOOKUP_DIRECTORY; nd->flags &= ~LOOKUP_PARENT; return walk_component(nd, path, nd->flags & LOOKUP_FOLLOW); } /* Returns 0 and nd will be valid on success; Retuns error, otherwise. / static int path_lookupat(int dfd, const char name, unsigned int flags, struct nameidata nd) { struct file base = NULL; struct path path; int err; /* * Path walking is largely split up into 2 different synchronisation * schemes, rcu-walk and ref-walk (explained in * Documentation/filesystems/path-lookup.txt). These share much of the * path walk code, but some things particularly setup, cleanup, and * following mounts are sufficiently divergent that functions are * duplicated. Typically there is a function foo(), and its RCU * analogue, foo_rcu(). * * -ECHILD is the error number of choice (just to avoid clashes) that * is returned if some aspect of an rcu-walk fails. Such an error must * be handled by restarting a traditional ref-walk (which will always * be able to complete). / err = path_init(dfd, name, flags \| LOOKUP_PARENT, nd, &base); if (unlikely(err)) return err; current->total_link_count = 0; err = link_path_walk(name, nd); if (!err && !(flags & LOOKUP_PARENT)) { err = lookup_last(nd, &path); while (err > 0) { void cookie; struct path link = path; err = may_follow_link(&link, nd); if (unlikely(err)) break; nd->flags \|= LOOKUP_PARENT; err = follow_link(&link, nd, &cookie); if (err) break; err = lookup_last(nd, &path); put_link(nd, &link, cookie); } } if (!err) err = complete_walk(nd); if (!err && nd->flags & LOOKUP_DIRECTORY) { if (!d_can_lookup(nd->path.dentry)) { path_put(&nd->path); err = -ENOTDIR; } } if (base) fput(base); if (nd->root.mnt && !(nd->flags & LOOKUP_ROOT)) { path_put(&nd->root); nd->root.mnt = NULL; } return err; } static int filename_lookup(int dfd, struct filename name, unsigned int flags, struct nameidata nd) { int retval = path_lookupat(dfd, name->name, flags \| LOOKUP_RCU, nd); if (unlikely(retval == -ECHILD)) retval = path_lookupat(dfd, name->name, flags, nd); if (unlikely(retval == -ESTALE)) retval = path_lookupat(dfd, name->name, flags \| LOOKUP_REVAL, nd); if (likely(!retval)) audit_inode(name, nd->path.dentry, flags & LOOKUP_PARENT); return retval; } static int do_path_lookup(int dfd, const char name, unsigned int flags, struct nameidata nd) { struct filename filename = { .name = name }; return filename_lookup(dfd, &filename, flags, nd); } /* does lookup, returns the object with parent locked / struct dentry kern_path_locked(const char name, struct path path) { struct nameidata nd; struct dentry d; int err = do_path_lookup(AT_FDCWD, name, LOOKUP_PARENT, &nd); if (err) return ERR_PTR(err); if (nd.last_type != LAST_NORM) { path_put(&nd.path); return ERR_PTR(-EINVAL); } mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT); d = __lookup_hash(&nd.last, nd.path.dentry, 0); if (IS_ERR(d)) { mutex_unlock(&nd.path.dentry->d_inode->i_mutex); path_put(&nd.path); return d; } path = nd.path; return d; } int kern_path(const char name, unsigned int flags, struct path path) { struct nameidata nd; int res = do_path_lookup(AT_FDCWD, name, flags, &nd); if (!res) path = nd.path; return res; } EXPORT_SYMBOL(kern_path); /* * vfs_path_lookup - lookup a file path relative to a dentry-vfsmount pair * @dentry: pointer to dentry of the base directory * @mnt: pointer to vfs mount of the base directory * @name: pointer to file name * @flags: lookup flags * @path: pointer to struct path to fill / int vfs_path_lookup(struct dentry dentry, struct vfsmount mnt, const char name, unsigned int flags, struct path path) { struct nameidata nd; int err; nd.root.dentry = dentry; nd.root.mnt = mnt; BUG_ON(flags & LOOKUP_PARENT); / the first argument of do_path_lookup() is ignored with LOOKUP_ROOT / err = do_path_lookup(AT_FDCWD, name, flags \| LOOKUP_ROOT, &nd); if (!err) path = nd.path; return err; } EXPORT_SYMBOL(vfs_path_lookup); /* * Restricted form of lookup. Doesn't follow links, single-component only, * needs parent already locked. Doesn't follow mounts. * SMP-safe. / static struct dentry lookup_hash(struct nameidata nd) { return __lookup_hash(&nd->last, nd->path.dentry, nd->flags); } /* * lookup_one_len - filesystem helper to lookup single pathname component * @name: pathname component to lookup * @base: base directory to lookup from * @len: maximum length @len should be interpreted to * * Note that this routine is purely a helper for filesystem usage and should * not be called by generic code. Also note that by using this function the * nameidata argument is passed to the filesystem methods and a filesystem * using this helper needs to be prepared for that. / struct dentry lookup_one_len(const char name, struct dentry base, int len) { struct qstr this; unsigned int c; int err; WARN_ON_ONCE(!mutex_is_locked(&base->d_inode->i_mutex)); this.name = name; this.len = len; this.hash = full_name_hash(name, len); if (!len) return ERR_PTR(-EACCES); if (unlikely(name[0] == '.')) { if (len < 2 \|\| (len == 2 && name[1] == '.')) return ERR_PTR(-EACCES); } while (len--) { c = (const unsigned char )name++; if (c == '/' \|\| c == '\0') return ERR_PTR(-EACCES); } /* * See if the low-level filesystem might want * to use its own hash.. / if (base->d_flags & DCACHE_OP_HASH) { int err = base->d_op->d_hash(base, &this); if (err < 0) return ERR_PTR(err); } err = inode_permission(base->d_inode, MAY_EXEC); if (err) return ERR_PTR(err); return __lookup_hash(&this, base, 0); } EXPORT_SYMBOL(lookup_one_len); int user_path_at_empty(int dfd, const char __user name, unsigned flags, struct path path, int empty) { struct nameidata nd; struct filename tmp = getname_flags(name, flags, empty); int err = PTR_ERR(tmp); if (!IS_ERR(tmp)) { BUG_ON(flags & LOOKUP_PARENT); err = filename_lookup(dfd, tmp, flags, &nd); putname(tmp); if (!err) path = nd.path; } return err; } int user_path_at(int dfd, const char __user name, unsigned flags, struct path path) { return user_path_at_empty(dfd, name, flags, path, NULL); } EXPORT_SYMBOL(user_path_at); /* * NB: most callers don't do anything directly with the reference to the * to struct filename, but the nd->last pointer points into the name string * allocated by getname. So we must hold the reference to it until all * path-walking is complete. / static struct filename user_path_parent(int dfd, const char __user path, struct nameidata nd, unsigned int flags) { struct filename s = getname(path); int error; / only LOOKUP_REVAL is allowed in extra flags / flags &= LOOKUP_REVAL; if (IS_ERR(s)) return s; error = filename_lookup(dfd, s, flags \| LOOKUP_PARENT, nd); if (error) { putname(s); return ERR_PTR(error); } return s; } /* * mountpoint_last - look up last component for umount * @nd: pathwalk nameidata - currently pointing at parent directory of "last" * @path: pointer to container for result * * This is a special lookup_last function just for umount. In this case, we * need to resolve the path without doing any revalidation. * * The nameidata should be the result of doing a LOOKUP_PARENT pathwalk. Since * mountpoints are always pinned in the dcache, their ancestors are too. Thus, * in almost all cases, this lookup will be served out of the dcache. The only * cases where it won't are if nd->last refers to a symlink or the path is * bogus and it doesn't exist. * * Returns: * -error: if there was an error during lookup. This includes -ENOENT if the * lookup found a negative dentry. The nd->path reference will also be * put in this case. * * 0: if we successfully resolved nd->path and found it to not to be a * symlink that needs to be followed. "path" will also be populated. * The nd->path reference will also be put. * * 1: if we successfully resolved nd->last and found it to be a symlink * that needs to be followed. "path" will be populated with the path * to the link, and nd->path will not be put. / static int mountpoint_last(struct nameidata nd, struct path path) { int error = 0; struct dentry dentry; struct dentry dir = nd->path.dentry; / If we're in rcuwalk, drop out of it to handle last component / if (nd->flags & LOOKUP_RCU) { if (unlazy_walk(nd, NULL)) { error = -ECHILD; goto out; } } nd->flags &= ~LOOKUP_PARENT; if (unlikely(nd->last_type != LAST_NORM)) { error = handle_dots(nd, nd->last_type); if (error) goto out; dentry = dget(nd->path.dentry); goto done; } mutex_lock(&dir->d_inode->i_mutex); dentry = d_lookup(dir, &nd->last); if (!dentry) { / * No cached dentry. Mounted dentries are pinned in the cache, * so that means that this dentry is probably a symlink or the * path doesn't actually point to a mounted dentry. / dentry = d_alloc(dir, &nd->last); if (!dentry) { error = -ENOMEM; mutex_unlock(&dir->d_inode->i_mutex); goto out; } dentry = lookup_real(dir->d_inode, dentry, nd->flags); error = PTR_ERR(dentry); if (IS_ERR(dentry)) { mutex_unlock(&dir->d_inode->i_mutex); goto out; } } mutex_unlock(&dir->d_inode->i_mutex); done: if (!dentry->d_inode \|\| d_is_negative(dentry)) { error = -ENOENT; dput(dentry); goto out; } path->dentry = dentry; path->mnt = mntget(nd->path.mnt); if (should_follow_link(dentry, nd->flags & LOOKUP_FOLLOW)) return 1; follow_mount(path); error = 0; out: terminate_walk(nd); return error; } /* * path_mountpoint - look up a path to be umounted * @dfd: directory file descriptor to start walk from * @name: full pathname to walk * @path: pointer to container for result * @flags: lookup flags * * Look up the given name, but don't attempt to revalidate the last component. * Returns 0 and "path" will be valid on success; Returns error otherwise. / static int path_mountpoint(int dfd, const char name, struct path path, unsigned int flags) { struct file base = NULL; struct nameidata nd; int err; err = path_init(dfd, name, flags \| LOOKUP_PARENT, &nd, &base); if (unlikely(err)) return err; current->total_link_count = 0; err = link_path_walk(name, &nd); if (err) goto out; err = mountpoint_last(&nd, path); while (err > 0) { void cookie; struct path link = path; err = may_follow_link(&link, &nd); if (unlikely(err)) break; nd.flags \|= LOOKUP_PARENT; err = follow_link(&link, &nd, &cookie); if (err) break; err = mountpoint_last(&nd, path); put_link(&nd, &link, cookie); } out: if (base) fput(base); if (nd.root.mnt && !(nd.flags & LOOKUP_ROOT)) path_put(&nd.root); return err; } static int filename_mountpoint(int dfd, struct filename s, struct path path, unsigned int flags) { int error = path_mountpoint(dfd, s->name, path, flags \| LOOKUP_RCU); if (unlikely(error == -ECHILD)) error = path_mountpoint(dfd, s->name, path, flags); if (unlikely(error == -ESTALE)) error = path_mountpoint(dfd, s->name, path, flags \| LOOKUP_REVAL); if (likely(!error)) audit_inode(s, path->dentry, 0); return error; } /** * user_path_mountpoint_at - lookup a path from userland in order to umount it * @dfd: directory file descriptor * @name: pathname from userland * @flags: lookup flags * @path: pointer to container to hold result * * A umount is a special case for path walking. We're not actually interested * in the inode in this situation, and ESTALE errors can be a problem. We * simply want track down the dentry and vfsmount attached at the mountpoint * and avoid revalidating the last component. * * Returns 0 and populates "path" on success. / int user_path_mountpoint_at(int dfd, const char __user name, unsigned int flags, struct path path) { struct filename s = getname(name); int error; if (IS_ERR(s)) return PTR_ERR(s); error = filename_mountpoint(dfd, s, path, flags); putname(s); return error; } int kern_path_mountpoint(int dfd, const char name, struct path path, unsigned int flags) { struct filename s = {.name = name}; return filename_mountpoint(dfd, &s, path, flags); } EXPORT_SYMBOL(kern_path_mountpoint); /* * It's inline, so penalty for filesystems that don't use sticky bit is * minimal. / static inline int check_sticky(struct inode dir, struct inode inode) { kuid_t fsuid = current_fsuid(); if (!(dir->i_mode & S_ISVTX)) return 0; if (uid_eq(inode->i_uid, fsuid)) return 0; if (uid_eq(dir->i_uid, fsuid)) return 0; return !inode_capable(inode, CAP_FOWNER); } / * Check whether we can remove a link victim from directory dir, check * whether the type of victim is right. * 1. We can't do it if dir is read-only (done in permission()) * 2. We should have write and exec permissions on dir * 3. We can't remove anything from append-only dir * 4. We can't do anything with immutable dir (done in permission()) * 5. If the sticky bit on dir is set we should either * a. be owner of dir, or * b. be owner of victim, or * c. have CAP_FOWNER capability * 6. If the victim is append-only or immutable we can't do antyhing with * links pointing to it. * 7. If we were asked to remove a directory and victim isn't one - ENOTDIR. * 8. If we were asked to remove a non-directory and victim isn't one - EISDIR. * 9. We can't remove a root or mountpoint. * 10. We don't allow removal of NFS sillyrenamed files; it's handled by * nfs_async_unlink(). / static int may_delete(struct inode dir, struct dentry victim, bool isdir) { struct inode inode = victim->d_inode; int error; if (d_is_negative(victim)) return -ENOENT; BUG_ON(!inode); BUG_ON(victim->d_parent->d_inode != dir); audit_inode_child(dir, victim, AUDIT_TYPE_CHILD_DELETE); error = inode_permission(dir, MAY_WRITE \| MAY_EXEC); if (error) return error; if (IS_APPEND(dir)) return -EPERM; if (check_sticky(dir, inode) \|\| IS_APPEND(inode) \|\| IS_IMMUTABLE(inode) \|\| IS_SWAPFILE(inode)) return -EPERM; if (isdir) { if (!d_is_dir(victim)) return -ENOTDIR; if (IS_ROOT(victim)) return -EBUSY; } else if (d_is_dir(victim)) return -EISDIR; if (IS_DEADDIR(dir)) return -ENOENT; if (victim->d_flags & DCACHE_NFSFS_RENAMED) return -EBUSY; return 0; } /* Check whether we can create an object with dentry child in directory * dir. * 1. We can't do it if child already exists (open has special treatment for * this case, but since we are inlined it's OK) * 2. We can't do it if dir is read-only (done in permission()) * 3. We should have write and exec permissions on dir * 4. We can't do it if dir is immutable (done in permission()) / static inline int may_create(struct inode dir, struct dentry child) { audit_inode_child(dir, child, AUDIT_TYPE_CHILD_CREATE); if (child->d_inode) return -EEXIST; if (IS_DEADDIR(dir)) return -ENOENT; return inode_permission(dir, MAY_WRITE \| MAY_EXEC); } / * p1 and p2 should be directories on the same fs. / struct dentry lock_rename(struct dentry p1, struct dentry p2) { struct dentry p; if (p1 == p2) { mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT); return NULL; } mutex_lock(&p1->d_inode->i_sb->s_vfs_rename_mutex); p = d_ancestor(p2, p1); if (p) { mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_PARENT); mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_CHILD); return p; } p = d_ancestor(p1, p2); if (p) { mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT); mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD); return p; } mutex_lock_nested(&p1->d_inode->i_mutex, I_MUTEX_PARENT); mutex_lock_nested(&p2->d_inode->i_mutex, I_MUTEX_CHILD); return NULL; } EXPORT_SYMBOL(lock_rename); void unlock_rename(struct dentry p1, struct dentry p2) { mutex_unlock(&p1->d_inode->i_mutex); if (p1 != p2) { mutex_unlock(&p2->d_inode->i_mutex); mutex_unlock(&p1->d_inode->i_sb->s_vfs_rename_mutex); } } EXPORT_SYMBOL(unlock_rename); int vfs_create(struct inode dir, struct dentry dentry, umode_t mode, bool want_excl) { int error = may_create(dir, dentry); if (error) return error; if (!dir->i_op->create) return -EACCES; / shouldn't it be ENOSYS? / mode &= S_IALLUGO; mode \|= S_IFREG; error = security_inode_create(dir, dentry, mode); if (error) return error; error = dir->i_op->create(dir, dentry, mode, want_excl); if (!error) fsnotify_create(dir, dentry); return error; } EXPORT_SYMBOL(vfs_create); static int may_open(struct path path, int acc_mode, int flag) { struct dentry dentry = path->dentry; struct inode inode = dentry->d_inode; int error; /* O_PATH? / if (!acc_mode) return 0; if (!inode) return -ENOENT; switch (inode->i_mode & S_IFMT) { case S_IFLNK: return -ELOOP; case S_IFDIR: if (acc_mode & MAY_WRITE) return -EISDIR; break; case S_IFBLK: case S_IFCHR: if (path->mnt->mnt_flags & MNT_NODEV) return -EACCES; /FALLTHRU/ case S_IFIFO: case S_IFSOCK: flag &= ~O_TRUNC; break; } error = inode_permission(inode, acc_mode); if (error) return error; / * An append-only file must be opened in append mode for writing. / if (IS_APPEND(inode)) { if ((flag & O_ACCMODE) != O_RDONLY && !(flag & O_APPEND)) return -EPERM; if (flag & O_TRUNC) return -EPERM; } / O_NOATIME can only be set by the owner or superuser / if (flag & O_NOATIME && !inode_owner_or_capable(inode)) return -EPERM; return 0; } static int handle_truncate(struct file filp) { struct path path = &filp->f_path; struct inode inode = path->dentry->d_inode; int error = get_write_access(inode); if (error) return error; /* * Refuse to truncate files with mandatory locks held on them. / error = locks_verify_locked(filp); if (!error) error = security_path_truncate(path); if (!error) { error = do_truncate(path->dentry, 0, ATTR_MTIME\|ATTR_CTIME\|ATTR_OPEN, filp); } put_write_access(inode); return error; } static inline int open_to_namei_flags(int flag) { if ((flag & O_ACCMODE) == 3) flag--; return flag; } static int may_o_create(struct path dir, struct dentry dentry, umode_t mode) { int error = security_path_mknod(dir, dentry, mode, 0); if (error) return error; error = inode_permission(dir->dentry->d_inode, MAY_WRITE \| MAY_EXEC); if (error) return error; return security_inode_create(dir->dentry->d_inode, dentry, mode); } / * Attempt to atomically look up, create and open a file from a negative * dentry. * * Returns 0 if successful. The file will have been created and attached to * @file by the filesystem calling finish_open(). * * Returns 1 if the file was looked up only or didn't need creating. The * caller will need to perform the open themselves. @path will have been * updated to point to the new dentry. This may be negative. * * Returns an error code otherwise. / static int atomic_open(struct nameidata nd, struct dentry dentry, struct path path, struct file file, const struct open_flags op, bool got_write, bool need_lookup, int opened) { struct inode dir = nd->path.dentry->d_inode; unsigned open_flag = open_to_namei_flags(op->open_flag); umode_t mode; int error; int acc_mode; int create_error = 0; struct dentry const DENTRY_NOT_SET = (void ) -1UL; bool excl; BUG_ON(dentry->d_inode); /* Don't create child dentry for a dead directory. / if (unlikely(IS_DEADDIR(dir))) { error = -ENOENT; goto out; } mode = op->mode; if ((open_flag & O_CREAT) && !IS_POSIXACL(dir)) mode &= ~current_umask(); excl = (open_flag & (O_EXCL \| O_CREAT)) == (O_EXCL \| O_CREAT); if (excl) open_flag &= ~O_TRUNC; / * Checking write permission is tricky, bacuse we don't know if we are * going to actually need it: O_CREAT opens should work as long as the * file exists. But checking existence breaks atomicity. The trick is * to check access and if not granted clear O_CREAT from the flags. * * Another problem is returing the "right" error value (e.g. for an * O_EXCL open we want to return EEXIST not EROFS). / if (((open_flag & (O_CREAT \| O_TRUNC)) \|\| (open_flag & O_ACCMODE) != O_RDONLY) && unlikely(!got_write)) { if (!(open_flag & O_CREAT)) { / * No O_CREATE -> atomicity not a requirement -> fall * back to lookup + open / goto no_open; } else if (open_flag & (O_EXCL \| O_TRUNC)) { / Fall back and fail with the right error / create_error = -EROFS; goto no_open; } else { / No side effects, safe to clear O_CREAT / create_error = -EROFS; open_flag &= ~O_CREAT; } } if (open_flag & O_CREAT) { error = may_o_create(&nd->path, dentry, mode); if (error) { create_error = error; if (open_flag & O_EXCL) goto no_open; open_flag &= ~O_CREAT; } } if (nd->flags & LOOKUP_DIRECTORY) open_flag \|= O_DIRECTORY; file->f_path.dentry = DENTRY_NOT_SET; file->f_path.mnt = nd->path.mnt; error = dir->i_op->atomic_open(dir, dentry, file, open_flag, mode, opened); if (error < 0) { if (create_error && error == -ENOENT) error = create_error; goto out; } if (error) { / returned 1, that is / if (WARN_ON(file->f_path.dentry == DENTRY_NOT_SET)) { error = -EIO; goto out; } if (file->f_path.dentry) { dput(dentry); dentry = file->f_path.dentry; } if (opened & FILE_CREATED) fsnotify_create(dir, dentry); if (!dentry->d_inode) { WARN_ON(opened & FILE_CREATED); if (create_error) { error = create_error; goto out; } } else { if (excl && !(opened & FILE_CREATED)) { error = -EEXIST; goto out; } } goto looked_up; } /* * We didn't have the inode before the open, so check open permission * here. / acc_mode = op->acc_mode; if (opened & FILE_CREATED) { WARN_ON(!(open_flag & O_CREAT)); fsnotify_create(dir, dentry); acc_mode = MAY_OPEN; } error = may_open(&file->f_path, acc_mode, open_flag); if (error) fput(file); out: dput(dentry); return error; no_open: if (need_lookup) { dentry = lookup_real(dir, dentry, nd->flags); if (IS_ERR(dentry)) return PTR_ERR(dentry); if (create_error) { int open_flag = op->open_flag; error = create_error; if ((open_flag & O_EXCL)) { if (!dentry->d_inode) goto out; } else if (!dentry->d_inode) { goto out; } else if ((open_flag & O_TRUNC) && S_ISREG(dentry->d_inode->i_mode)) { goto out; } /* will fail later, go on to get the right error / } } looked_up: path->dentry = dentry; path->mnt = nd->path.mnt; return 1; } / * Look up and maybe create and open the last component. * * Must be called with i_mutex held on parent. * * Returns 0 if the file was successfully atomically created (if necessary) and * opened. In this case the file will be returned attached to @file. * * Returns 1 if the file was not completely opened at this time, though lookups * and creations will have been performed and the dentry returned in @path will * be positive upon return if O_CREAT was specified. If O_CREAT wasn't * specified then a negative dentry may be returned. * * An error code is returned otherwise. * * FILE_CREATE will be set in @opened if the dentry was created and will be cleared otherwise prior to returning. / static int lookup_open(struct nameidata nd, struct path path, struct file file, const struct open_flags op, bool got_write, int opened) { struct dentry dir = nd->path.dentry; struct inode dir_inode = dir->d_inode; struct dentry dentry; int error; bool need_lookup; opened &= ~FILE_CREATED; dentry = lookup_dcache(&nd->last, dir, nd->flags, &need_lookup); if (IS_ERR(dentry)) return PTR_ERR(dentry); /* Cached positive dentry: will open in f_op->open / if (!need_lookup && dentry->d_inode) goto out_no_open; if ((nd->flags & LOOKUP_OPEN) && dir_inode->i_op->atomic_open) { return atomic_open(nd, dentry, path, file, op, got_write, need_lookup, opened); } if (need_lookup) { BUG_ON(dentry->d_inode); dentry = lookup_real(dir_inode, dentry, nd->flags); if (IS_ERR(dentry)) return PTR_ERR(dentry); } / Negative dentry, just create the file / if (!dentry->d_inode && (op->open_flag & O_CREAT)) { umode_t mode = op->mode; if (!IS_POSIXACL(dir->d_inode)) mode &= ~current_umask(); / * This write is needed to ensure that a * rw->ro transition does not occur between * the time when the file is created and when * a permanent write count is taken through * the 'struct file' in finish_open(). / if (!got_write) { error = -EROFS; goto out_dput; } opened \|= FILE_CREATED; error = security_path_mknod(&nd->path, dentry, mode, 0); if (error) goto out_dput; error = vfs_create(dir->d_inode, dentry, mode, nd->flags & LOOKUP_EXCL); if (error) goto out_dput; } out_no_open: path->dentry = dentry; path->mnt = nd->path.mnt; return 1; out_dput: dput(dentry); return error; } /* * Handle the last step of open() / static int do_last(struct nameidata nd, struct path path, struct file file, const struct open_flags op, int opened, struct filename name) { struct dentry dir = nd->path.dentry; int open_flag = op->open_flag; bool will_truncate = (open_flag & O_TRUNC) != 0; bool got_write = false; int acc_mode = op->acc_mode; struct inode inode; bool symlink_ok = false; struct path save_parent = { .dentry = NULL, .mnt = NULL }; bool retried = false; int error; nd->flags &= ~LOOKUP_PARENT; nd->flags \|= op->intent; if (nd->last_type != LAST_NORM) { error = handle_dots(nd, nd->last_type); if (error) return error; goto finish_open; } if (!(open_flag & O_CREAT)) { if (nd->last.name[nd->last.len]) nd->flags \|= LOOKUP_FOLLOW \| LOOKUP_DIRECTORY; if (open_flag & O_PATH && !(nd->flags & LOOKUP_FOLLOW)) symlink_ok = true; / we _can_ be in RCU mode here / error = lookup_fast(nd, path, &inode); if (likely(!error)) goto finish_lookup; if (error < 0) goto out; BUG_ON(nd->inode != dir->d_inode); } else { / create side of things / / * This will only deal with leaving RCU mode - LOOKUP_JUMPED * has been cleared when we got to the last component we are * about to look up / error = complete_walk(nd); if (error) return error; audit_inode(name, dir, LOOKUP_PARENT); error = -EISDIR; / trailing slashes? / if (nd->last.name[nd->last.len]) goto out; } retry_lookup: if (op->open_flag & (O_CREAT \| O_TRUNC \| O_WRONLY \| O_RDWR)) { error = mnt_want_write(nd->path.mnt); if (!error) got_write = true; / * do _not_ fail yet - we might not need that or fail with * a different error; let lookup_open() decide; we'll be * dropping this one anyway. / } mutex_lock(&dir->d_inode->i_mutex); error = lookup_open(nd, path, file, op, got_write, opened); mutex_unlock(&dir->d_inode->i_mutex); if (error <= 0) { if (error) goto out; if ((opened & FILE_CREATED) \|\| !S_ISREG(file_inode(file)->i_mode)) will_truncate = false; audit_inode(name, file->f_path.dentry, 0); goto opened; } if (opened & FILE_CREATED) { / Don't check for write permission, don't truncate / open_flag &= ~O_TRUNC; will_truncate = false; acc_mode = MAY_OPEN; path_to_nameidata(path, nd); goto finish_open_created; } / * create/update audit record if it already exists. / if (d_is_positive(path->dentry)) audit_inode(name, path->dentry, 0); / * If atomic_open() acquired write access it is dropped now due to * possible mount and symlink following (this might be optimized away if * necessary...) / if (got_write) { mnt_drop_write(nd->path.mnt); got_write = false; } error = -EEXIST; if ((open_flag & (O_EXCL \| O_CREAT)) == (O_EXCL \| O_CREAT)) goto exit_dput; error = follow_managed(path, nd->flags); if (error < 0) goto exit_dput; if (error) nd->flags \|= LOOKUP_JUMPED; BUG_ON(nd->flags & LOOKUP_RCU); inode = path->dentry->d_inode; finish_lookup: / we _can_ be in RCU mode here / error = -ENOENT; if (!inode \|\| d_is_negative(path->dentry)) { path_to_nameidata(path, nd); goto out; } if (should_follow_link(path->dentry, !symlink_ok)) { if (nd->flags & LOOKUP_RCU) { if (unlikely(unlazy_walk(nd, path->dentry))) { error = -ECHILD; goto out; } } BUG_ON(inode != path->dentry->d_inode); return 1; } if ((nd->flags & LOOKUP_RCU) \|\| nd->path.mnt != path->mnt) { path_to_nameidata(path, nd); } else { save_parent.dentry = nd->path.dentry; save_parent.mnt = mntget(path->mnt); nd->path.dentry = path->dentry; } nd->inode = inode; / Why this, you ask? _Now_ we might have grown LOOKUP_JUMPED... / finish_open: error = complete_walk(nd); if (error) { path_put(&save_parent); return error; } audit_inode(name, nd->path.dentry, 0); error = -EISDIR; if ((open_flag & O_CREAT) && d_is_dir(nd->path.dentry)) goto out; error = -ENOTDIR; if ((nd->flags & LOOKUP_DIRECTORY) && !d_can_lookup(nd->path.dentry)) goto out; if (!S_ISREG(nd->inode->i_mode)) will_truncate = false; if (will_truncate) { error = mnt_want_write(nd->path.mnt); if (error) goto out; got_write = true; } finish_open_created: error = may_open(&nd->path, acc_mode, open_flag); if (error) goto out; file->f_path.mnt = nd->path.mnt; error = finish_open(file, nd->path.dentry, NULL, opened); if (error) { if (error == -EOPENSTALE) goto stale_open; goto out; } opened: error = open_check_o_direct(file); if (error) goto exit_fput; error = ima_file_check(file, op->acc_mode); if (error) goto exit_fput; if (will_truncate) { error = handle_truncate(file); if (error) goto exit_fput; } out: if (got_write) mnt_drop_write(nd->path.mnt); path_put(&save_parent); terminate_walk(nd); return error; exit_dput: path_put_conditional(path, nd); goto out; exit_fput: fput(file); goto out; stale_open: / If no saved parent or already retried then can't retry / if (!save_parent.dentry \|\| retried) goto out; BUG_ON(save_parent.dentry != dir); path_put(&nd->path); nd->path = save_parent; nd->inode = dir->d_inode; save_parent.mnt = NULL; save_parent.dentry = NULL; if (got_write) { mnt_drop_write(nd->path.mnt); got_write = false; } retried = true; goto retry_lookup; } static int do_tmpfile(int dfd, struct filename pathname, struct nameidata nd, int flags, const struct open_flags op, struct file file, int opened) { static const struct qstr name = QSTR_INIT("/", 1); struct dentry dentry, child; struct inode dir; int error = path_lookupat(dfd, pathname->name, flags \| LOOKUP_DIRECTORY, nd); if (unlikely(error)) return error; error = mnt_want_write(nd->path.mnt); if (unlikely(error)) goto out; / we want directory to be writable / error = inode_permission(nd->inode, MAY_WRITE \| MAY_EXEC); if (error) goto out2; dentry = nd->path.dentry; dir = dentry->d_inode; if (!dir->i_op->tmpfile) { error = -EOPNOTSUPP; goto out2; } child = d_alloc(dentry, &name); if (unlikely(!child)) { error = -ENOMEM; goto out2; } nd->flags &= ~LOOKUP_DIRECTORY; nd->flags \|= op->intent; dput(nd->path.dentry); nd->path.dentry = child; error = dir->i_op->tmpfile(dir, nd->path.dentry, op->mode); if (error) goto out2; audit_inode(pathname, nd->path.dentry, 0); error = may_open(&nd->path, op->acc_mode, op->open_flag); if (error) goto out2; file->f_path.mnt = nd->path.mnt; error = finish_open(file, nd->path.dentry, NULL, opened); if (error) goto out2; error = open_check_o_direct(file); if (error) { fput(file); } else if (!(op->open_flag & O_EXCL)) { struct inode inode = file_inode(file); spin_lock(&inode->i_lock); inode->i_state \|= I_LINKABLE; spin_unlock(&inode->i_lock); } out2: mnt_drop_write(nd->path.mnt); out: path_put(&nd->path); return error; } static struct file path_openat(int dfd, struct filename pathname, struct nameidata nd, const struct open_flags op, int flags) { struct file base = NULL; struct file file; struct path path; int opened = 0; int error; file = get_empty_filp(); if (IS_ERR(file)) return file; file->f_flags = op->open_flag; if (unlikely(file->f_flags & __O_TMPFILE)) { error = do_tmpfile(dfd, pathname, nd, flags, op, file, &opened); goto out; } error = path_init(dfd, pathname->name, flags \| LOOKUP_PARENT, nd, &base); if (unlikely(error)) goto out; current->total_link_count = 0; error = link_path_walk(pathname->name, nd); if (unlikely(error)) goto out; error = do_last(nd, &path, file, op, &opened, pathname); while (unlikely(error > 0)) { /* trailing symlink / struct path link = path; void cookie; if (!(nd->flags & LOOKUP_FOLLOW)) { path_put_conditional(&path, nd); path_put(&nd->path); error = -ELOOP; break; } error = may_follow_link(&link, nd); if (unlikely(error)) break; nd->flags \|= LOOKUP_PARENT; nd->flags &= ~(LOOKUP_OPEN\|LOOKUP_CREATE\|LOOKUP_EXCL); error = follow_link(&link, nd, &cookie); if (unlikely(error)) break; error = do_last(nd, &path, file, op, &opened, pathname); put_link(nd, &link, cookie); } out: if (nd->root.mnt && !(nd->flags & LOOKUP_ROOT)) path_put(&nd->root); if (base) fput(base); if (!(opened & FILE_OPENED)) { BUG_ON(!error); put_filp(file); } if (unlikely(error)) { if (error == -EOPENSTALE) { if (flags & LOOKUP_RCU) error = -ECHILD; else error = -ESTALE; } file = ERR_PTR(error); } return file; } struct file do_filp_open(int dfd, struct filename pathname, const struct open_flags op) { struct nameidata nd; int flags = op->lookup_flags; struct file filp; filp = path_openat(dfd, pathname, &nd, op, flags \| LOOKUP_RCU); if (unlikely(filp == ERR_PTR(-ECHILD))) filp = path_openat(dfd, pathname, &nd, op, flags); if (unlikely(filp == ERR_PTR(-ESTALE))) filp = path_openat(dfd, pathname, &nd, op, flags \| LOOKUP_REVAL); return filp; } struct file do_file_open_root(struct dentry dentry, struct vfsmount mnt, const char name, const struct open_flags op) { struct nameidata nd; struct file file; struct filename filename = { .name = name }; int flags = op->lookup_flags \| LOOKUP_ROOT; nd.root.mnt = mnt; nd.root.dentry = dentry; if (d_is_symlink(dentry) && op->intent & LOOKUP_OPEN) return ERR_PTR(-ELOOP); file = path_openat(-1, &filename, &nd, op, flags \| LOOKUP_RCU); if (unlikely(file == ERR_PTR(-ECHILD))) file = path_openat(-1, &filename, &nd, op, flags); if (unlikely(file == ERR_PTR(-ESTALE))) file = path_openat(-1, &filename, &nd, op, flags \| LOOKUP_REVAL); return file; } struct dentry kern_path_create(int dfd, const char pathname, struct path path, unsigned int lookup_flags) { struct dentry dentry = ERR_PTR(-EEXIST); struct nameidata nd; int err2; int error; bool is_dir = (lookup_flags & LOOKUP_DIRECTORY); /* * Note that only LOOKUP_REVAL and LOOKUP_DIRECTORY matter here. Any * other flags passed in are ignored! / lookup_flags &= LOOKUP_REVAL; error = do_path_lookup(dfd, pathname, LOOKUP_PARENT\|lookup_flags, &nd); if (error) return ERR_PTR(error); / * Yucky last component or no last component at all? * (foo/., foo/.., /////) / if (nd.last_type != LAST_NORM) goto out; nd.flags &= ~LOOKUP_PARENT; nd.flags \|= LOOKUP_CREATE \| LOOKUP_EXCL; / don't fail immediately if it's r/o, at least try to report other errors / err2 = mnt_want_write(nd.path.mnt); / * Do the final lookup. / mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT); dentry = lookup_hash(&nd); if (IS_ERR(dentry)) goto unlock; error = -EEXIST; if (d_is_positive(dentry)) goto fail; / * Special case - lookup gave negative, but... we had foo/bar/ * From the vfs_mknod() POV we just have a negative dentry - * all is fine. Let's be bastards - you had / on the end, you've * been asking for (non-existent) directory. -ENOENT for you. / if (unlikely(!is_dir && nd.last.name[nd.last.len])) { error = -ENOENT; goto fail; } if (unlikely(err2)) { error = err2; goto fail; } path = nd.path; return dentry; fail: dput(dentry); dentry = ERR_PTR(error); unlock: mutex_unlock(&nd.path.dentry->d_inode->i_mutex); if (!err2) mnt_drop_write(nd.path.mnt); out: path_put(&nd.path); return dentry; } EXPORT_SYMBOL(kern_path_create); void done_path_create(struct path path, struct dentry dentry) { dput(dentry); mutex_unlock(&path->dentry->d_inode->i_mutex); mnt_drop_write(path->mnt); path_put(path); } EXPORT_SYMBOL(done_path_create); struct dentry user_path_create(int dfd, const char __user pathname, struct path path, unsigned int lookup_flags) { struct filename tmp = getname(pathname); struct dentry res; if (IS_ERR(tmp)) return ERR_CAST(tmp); res = kern_path_create(dfd, tmp->name, path, lookup_flags); putname(tmp); return res; } EXPORT_SYMBOL(user_path_create); int vfs_mknod(struct inode dir, struct dentry dentry, umode_t mode, dev_t dev) { int error = may_create(dir, dentry); if (error) return error; if ((S_ISCHR(mode) \|\| S_ISBLK(mode)) && !capable(CAP_MKNOD)) return -EPERM; if (!dir->i_op->mknod) return -EPERM; error = devcgroup_inode_mknod(mode, dev); if (error) return error; error = security_inode_mknod(dir, dentry, mode, dev); if (error) return error; error = dir->i_op->mknod(dir, dentry, mode, dev); if (!error) fsnotify_create(dir, dentry); return error; } EXPORT_SYMBOL(vfs_mknod); static int may_mknod(umode_t mode) { switch (mode & S_IFMT) { case S_IFREG: case S_IFCHR: case S_IFBLK: case S_IFIFO: case S_IFSOCK: case 0: / zero mode translates to S_IFREG / return 0; case S_IFDIR: return -EPERM; default: return -EINVAL; } } SYSCALL_DEFINE4(mknodat, int, dfd, const char __user , filename, umode_t, mode, unsigned, dev) { struct dentry dentry; struct path path; int error; unsigned int lookup_flags = 0; error = may_mknod(mode); if (error) return error; retry: dentry = user_path_create(dfd, filename, &path, lookup_flags); if (IS_ERR(dentry)) return PTR_ERR(dentry); if (!IS_POSIXACL(path.dentry->d_inode)) mode &= ~current_umask(); error = security_path_mknod(&path, dentry, mode, dev); if (error) goto out; switch (mode & S_IFMT) { case 0: case S_IFREG: error = vfs_create(path.dentry->d_inode,dentry,mode,true); break; case S_IFCHR: case S_IFBLK: error = vfs_mknod(path.dentry->d_inode,dentry,mode, new_decode_dev(dev)); break; case S_IFIFO: case S_IFSOCK: error = vfs_mknod(path.dentry->d_inode,dentry,mode,0); break; } out: done_path_create(&path, dentry); if (retry_estale(error, lookup_flags)) { lookup_flags \|= LOOKUP_REVAL; goto retry; } return error; } SYSCALL_DEFINE3(mknod, const char __user , filename, umode_t, mode, unsigned, dev) { return sys_mknodat(AT_FDCWD, filename, mode, dev); } int vfs_mkdir(struct inode dir, struct dentry dentry, umode_t mode) { int error = may_create(dir, dentry); unsigned max_links = dir->i_sb->s_max_links; if (error) return error; if (!dir->i_op->mkdir) return -EPERM; mode &= (S_IRWXUGO\|S_ISVTX); error = security_inode_mkdir(dir, dentry, mode); if (error) return error; if (max_links && dir->i_nlink >= max_links) return -EMLINK; error = dir->i_op->mkdir(dir, dentry, mode); if (!error) fsnotify_mkdir(dir, dentry); return error; } EXPORT_SYMBOL(vfs_mkdir); SYSCALL_DEFINE3(mkdirat, int, dfd, const char __user , pathname, umode_t, mode) { struct dentry dentry; struct path path; int error; unsigned int lookup_flags = LOOKUP_DIRECTORY; retry: dentry = user_path_create(dfd, pathname, &path, lookup_flags); if (IS_ERR(dentry)) return PTR_ERR(dentry); if (!IS_POSIXACL(path.dentry->d_inode)) mode &= ~current_umask(); error = security_path_mkdir(&path, dentry, mode); if (!error) error = vfs_mkdir(path.dentry->d_inode, dentry, mode); done_path_create(&path, dentry); if (retry_estale(error, lookup_flags)) { lookup_flags \|= LOOKUP_REVAL; goto retry; } return error; } SYSCALL_DEFINE2(mkdir, const char __user , pathname, umode_t, mode) { return sys_mkdirat(AT_FDCWD, pathname, mode); } / * The dentry_unhash() helper will try to drop the dentry early: we * should have a usage count of 1 if we're the only user of this * dentry, and if that is true (possibly after pruning the dcache), * then we drop the dentry now. * * A low-level filesystem can, if it choses, legally * do a * * if (!d_unhashed(dentry)) * return -EBUSY; * * if it cannot handle the case of removing a directory * that is still in use by something else.. / void dentry_unhash(struct dentry dentry) { shrink_dcache_parent(dentry); spin_lock(&dentry->d_lock); if (dentry->d_lockref.count == 1) __d_drop(dentry); spin_unlock(&dentry->d_lock); } EXPORT_SYMBOL(dentry_unhash); int vfs_rmdir(struct inode dir, struct dentry dentry) { int error = may_delete(dir, dentry, 1); if (error) return error; if (!dir->i_op->rmdir) return -EPERM; dget(dentry); mutex_lock(&dentry->d_inode->i_mutex); error = -EBUSY; if (d_mountpoint(dentry)) goto out; error = security_inode_rmdir(dir, dentry); if (error) goto out; shrink_dcache_parent(dentry); error = dir->i_op->rmdir(dir, dentry); if (error) goto out; dentry->d_inode->i_flags \|= S_DEAD; dont_mount(dentry); out: mutex_unlock(&dentry->d_inode->i_mutex); dput(dentry); if (!error) d_delete(dentry); return error; } EXPORT_SYMBOL(vfs_rmdir); static long do_rmdir(int dfd, const char __user pathname) { int error = 0; struct filename name; struct dentry dentry; struct nameidata nd; unsigned int lookup_flags = 0; retry: name = user_path_parent(dfd, pathname, &nd, lookup_flags); if (IS_ERR(name)) return PTR_ERR(name); switch(nd.last_type) { case LAST_DOTDOT: error = -ENOTEMPTY; goto exit1; case LAST_DOT: error = -EINVAL; goto exit1; case LAST_ROOT: error = -EBUSY; goto exit1; } nd.flags &= ~LOOKUP_PARENT; error = mnt_want_write(nd.path.mnt); if (error) goto exit1; mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT); dentry = lookup_hash(&nd); error = PTR_ERR(dentry); if (IS_ERR(dentry)) goto exit2; if (!dentry->d_inode) { error = -ENOENT; goto exit3; } error = security_path_rmdir(&nd.path, dentry); if (error) goto exit3; error = vfs_rmdir(nd.path.dentry->d_inode, dentry); exit3: dput(dentry); exit2: mutex_unlock(&nd.path.dentry->d_inode->i_mutex); mnt_drop_write(nd.path.mnt); exit1: path_put(&nd.path); putname(name); if (retry_estale(error, lookup_flags)) { lookup_flags \|= LOOKUP_REVAL; goto retry; } return error; } SYSCALL_DEFINE1(rmdir, const char __user , pathname) { return do_rmdir(AT_FDCWD, pathname); } /** * vfs_unlink - unlink a filesystem object * @dir: parent directory * @dentry: victim * @delegated_inode: returns victim inode, if the inode is delegated. * * The caller must hold dir->i_mutex. * * If vfs_unlink discovers a delegation, it will return -EWOULDBLOCK and * return a reference to the inode in delegated_inode. The caller * should then break the delegation on that inode and retry. Because * breaking a delegation may take a long time, the caller should drop * dir->i_mutex before doing so. * * Alternatively, a caller may pass NULL for delegated_inode. This may * be appropriate for callers that expect the underlying filesystem not * to be NFS exported. / int vfs_unlink(struct inode dir, struct dentry dentry, struct inode delegated_inode) { struct inode target = dentry->d_inode; int error = may_delete(dir, dentry, 0); if (error) return error; if (!dir->i_op->unlink) return -EPERM; mutex_lock(&target->i_mutex); if (d_mountpoint(dentry)) error = -EBUSY; else { error = security_inode_unlink(dir, dentry); if (!error) { error = try_break_deleg(target, delegated_inode); if (error) goto out; error = dir->i_op->unlink(dir, dentry); if (!error) dont_mount(dentry); } } out: mutex_unlock(&target->i_mutex); /* We don't d_delete() NFS sillyrenamed files--they still exist. / if (!error && !(dentry->d_flags & DCACHE_NFSFS_RENAMED)) { fsnotify_link_count(target); d_delete(dentry); } return error; } EXPORT_SYMBOL(vfs_unlink); / * Make sure that the actual truncation of the file will occur outside its * directory's i_mutex. Truncate can take a long time if there is a lot of * writeout happening, and we don't want to prevent access to the directory * while waiting on the I/O. / static long do_unlinkat(int dfd, const char __user pathname) { int error; struct filename name; struct dentry dentry; struct nameidata nd; struct inode inode = NULL; struct inode delegated_inode = NULL; unsigned int lookup_flags = 0; retry: name = user_path_parent(dfd, pathname, &nd, lookup_flags); if (IS_ERR(name)) return PTR_ERR(name); error = -EISDIR; if (nd.last_type != LAST_NORM) goto exit1; nd.flags &= ~LOOKUP_PARENT; error = mnt_want_write(nd.path.mnt); if (error) goto exit1; retry_deleg: mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT); dentry = lookup_hash(&nd); error = PTR_ERR(dentry); if (!IS_ERR(dentry)) { /* Why not before? Because we want correct error value / if (nd.last.name[nd.last.len]) goto slashes; inode = dentry->d_inode; if (d_is_negative(dentry)) goto slashes; ihold(inode); error = security_path_unlink(&nd.path, dentry); if (error) goto exit2; error = vfs_unlink(nd.path.dentry->d_inode, dentry, &delegated_inode); exit2: dput(dentry); } mutex_unlock(&nd.path.dentry->d_inode->i_mutex); if (inode) iput(inode); / truncate the inode here / inode = NULL; if (delegated_inode) { error = break_deleg_wait(&delegated_inode); if (!error) goto retry_deleg; } mnt_drop_write(nd.path.mnt); exit1: path_put(&nd.path); putname(name); if (retry_estale(error, lookup_flags)) { lookup_flags \|= LOOKUP_REVAL; inode = NULL; goto retry; } return error; slashes: if (d_is_negative(dentry)) error = -ENOENT; else if (d_is_dir(dentry)) error = -EISDIR; else error = -ENOTDIR; goto exit2; } SYSCALL_DEFINE3(unlinkat, int, dfd, const char __user , pathname, int, flag) { if ((flag & ~AT_REMOVEDIR) != 0) return -EINVAL; if (flag & AT_REMOVEDIR) return do_rmdir(dfd, pathname); return do_unlinkat(dfd, pathname); } SYSCALL_DEFINE1(unlink, const char __user , pathname) { return do_unlinkat(AT_FDCWD, pathname); } int vfs_symlink(struct inode dir, struct dentry dentry, const char oldname) { int error = may_create(dir, dentry); if (error) return error; if (!dir->i_op->symlink) return -EPERM; error = security_inode_symlink(dir, dentry, oldname); if (error) return error; error = dir->i_op->symlink(dir, dentry, oldname); if (!error) fsnotify_create(dir, dentry); return error; } EXPORT_SYMBOL(vfs_symlink); SYSCALL_DEFINE3(symlinkat, const char __user , oldname, int, newdfd, const char __user , newname) { int error; struct filename from; struct dentry dentry; struct path path; unsigned int lookup_flags = 0; from = getname(oldname); if (IS_ERR(from)) return PTR_ERR(from); retry: dentry = user_path_create(newdfd, newname, &path, lookup_flags); error = PTR_ERR(dentry); if (IS_ERR(dentry)) goto out_putname; error = security_path_symlink(&path, dentry, from->name); if (!error) error = vfs_symlink(path.dentry->d_inode, dentry, from->name); done_path_create(&path, dentry); if (retry_estale(error, lookup_flags)) { lookup_flags \|= LOOKUP_REVAL; goto retry; } out_putname: putname(from); return error; } SYSCALL_DEFINE2(symlink, const char __user , oldname, const char __user , newname) { return sys_symlinkat(oldname, AT_FDCWD, newname); } /** * vfs_link - create a new link * @old_dentry: object to be linked * @dir: new parent * @new_dentry: where to create the new link * @delegated_inode: returns inode needing a delegation break * * The caller must hold dir->i_mutex * * If vfs_link discovers a delegation on the to-be-linked file in need * of breaking, it will return -EWOULDBLOCK and return a reference to the * inode in delegated_inode. The caller should then break the delegation * and retry. Because breaking a delegation may take a long time, the * caller should drop the i_mutex before doing so. * * Alternatively, a caller may pass NULL for delegated_inode. This may * be appropriate for callers that expect the underlying filesystem not * to be NFS exported. / int vfs_link(struct dentry old_dentry, struct inode dir, struct dentry new_dentry, struct inode *delegated_inode) { struct inode inode = old_dentry->d_inode; unsigned max_links = dir->i_sb->s_max_links; int error; if (!inode) return -ENOENT; error = may_create(dir, new_dentry); if (error) return error; if (dir->i_sb != inode->i_sb) return -EXDEV; /* * A link to an append-only or immutable file cannot be created. / if (IS_APPEND(inode) \|\| IS_IMMUTABLE(inode)) return -EPERM; if (!dir->i_op->link) return -EPERM; if (S_ISDIR(inode->i_mode)) return -EPERM; error = security_inode_link(old_dentry, dir, new_dentry); if (error) return error; mutex_lock(&inode->i_mutex); / Make sure we don't allow creating hardlink to an unlinked file / if (inode->i_nlink == 0 && !(inode->i_state & I_LINKABLE)) error = -ENOENT; else if (max_links && inode->i_nlink >= max_links) error = -EMLINK; else { error = try_break_deleg(inode, delegated_inode); if (!error) error = dir->i_op->link(old_dentry, dir, new_dentry); } if (!error && (inode->i_state & I_LINKABLE)) { spin_lock(&inode->i_lock); inode->i_state &= ~I_LINKABLE; spin_unlock(&inode->i_lock); } mutex_unlock(&inode->i_mutex); if (!error) fsnotify_link(dir, inode, new_dentry); return error; } EXPORT_SYMBOL(vfs_link); / * Hardlinks are often used in delicate situations. We avoid * security-related surprises by not following symlinks on the * newname. --KAB * * We don't follow them on the oldname either to be compatible * with linux 2.0, and to avoid hard-linking to directories * and other special files. --ADM / SYSCALL_DEFINE5(linkat, int, olddfd, const char __user , oldname, int, newdfd, const char __user , newname, int, flags) { struct dentry new_dentry; struct path old_path, new_path; struct inode delegated_inode = NULL; int how = 0; int error; if ((flags & ~(AT_SYMLINK_FOLLOW \| AT_EMPTY_PATH)) != 0) return -EINVAL; / * To use null names we require CAP_DAC_READ_SEARCH * This ensures that not everyone will be able to create * handlink using the passed filedescriptor. / if (flags & AT_EMPTY_PATH) { if (!capable(CAP_DAC_READ_SEARCH)) return -ENOENT; how = LOOKUP_EMPTY; } if (flags & AT_SYMLINK_FOLLOW) how \|= LOOKUP_FOLLOW; retry: error = user_path_at(olddfd, oldname, how, &old_path); if (error) return error; new_dentry = user_path_create(newdfd, newname, &new_path, (how & LOOKUP_REVAL)); error = PTR_ERR(new_dentry); if (IS_ERR(new_dentry)) goto out; error = -EXDEV; if (old_path.mnt != new_path.mnt) goto out_dput; error = may_linkat(&old_path); if (unlikely(error)) goto out_dput; error = security_path_link(old_path.dentry, &new_path, new_dentry); if (error) goto out_dput; error = vfs_link(old_path.dentry, new_path.dentry->d_inode, new_dentry, &delegated_inode); out_dput: done_path_create(&new_path, new_dentry); if (delegated_inode) { error = break_deleg_wait(&delegated_inode); if (!error) { path_put(&old_path); goto retry; } } if (retry_estale(error, how)) { path_put(&old_path); how \|= LOOKUP_REVAL; goto retry; } out: path_put(&old_path); return error; } SYSCALL_DEFINE2(link, const char __user , oldname, const char __user , newname) { return sys_linkat(AT_FDCWD, oldname, AT_FDCWD, newname, 0); } /* * vfs_rename - rename a filesystem object * @old_dir: parent of source * @old_dentry: source * @new_dir: parent of destination * @new_dentry: destination * @delegated_inode: returns an inode needing a delegation break * @flags: rename flags * * The caller must hold multiple mutexes--see lock_rename()). * * If vfs_rename discovers a delegation in need of breaking at either * the source or destination, it will return -EWOULDBLOCK and return a * reference to the inode in delegated_inode. The caller should then * break the delegation and retry. Because breaking a delegation may * take a long time, the caller should drop all locks before doing * so. * * Alternatively, a caller may pass NULL for delegated_inode. This may * be appropriate for callers that expect the underlying filesystem not * to be NFS exported. * * The worst of all namespace operations - renaming directory. "Perverted" * doesn't even start to describe it. Somebody in UCB had a heck of a trip... * Problems: * a) we can get into loop creation. Check is done in is_subdir(). * b) race potential - two innocent renames can create a loop together. * That's where 4.4 screws up. Current fix: serialization on * sb->s_vfs_rename_mutex. We might be more accurate, but that's another * story. * c) we have to lock _four_ objects - parents and victim (if it exists), * and source (if it is not a directory). * And that - after we got ->i_mutex on parents (until then we don't know * whether the target exists). Solution: try to be smart with locking * order for inodes. We rely on the fact that tree topology may change * only under ->s_vfs_rename_mutex _and_ that parent of the object we * move will be locked. Thus we can rank directories by the tree * (ancestors first) and rank all non-directories after them. * That works since everybody except rename does "lock parent, lookup, * lock child" and rename is under ->s_vfs_rename_mutex. * HOWEVER, it relies on the assumption that any object with ->lookup() * has no more than 1 dentry. If "hybrid" objects will ever appear, * we'd better make sure that there's no link(2) for them. * d) conversion from fhandle to dentry may come in the wrong moment - when * we are removing the target. Solution: we will have to grab ->i_mutex * in the fhandle_to_dentry code. [FIXME - current nfsfh.c relies on * ->i_mutex on parents, which works but leads to some truly excessive * locking]. / int vfs_rename(struct inode old_dir, struct dentry old_dentry, struct inode new_dir, struct dentry new_dentry, struct inode delegated_inode, unsigned int flags) { int error; bool is_dir = d_is_dir(old_dentry); const unsigned char old_name; struct inode source = old_dentry->d_inode; struct inode target = new_dentry->d_inode; bool new_is_dir = false; unsigned max_links = new_dir->i_sb->s_max_links; if (source == target) return 0; error = may_delete(old_dir, old_dentry, is_dir); if (error) return error; if (!target) { error = may_create(new_dir, new_dentry); } else { new_is_dir = d_is_dir(new_dentry); if (!(flags & RENAME_EXCHANGE)) error = may_delete(new_dir, new_dentry, is_dir); else error = may_delete(new_dir, new_dentry, new_is_dir); } if (error) return error; if (!old_dir->i_op->rename) return -EPERM; if (flags && !old_dir->i_op->rename2) return -EINVAL; /* * If we are going to change the parent - check write permissions, * we'll need to flip '..'. / if (new_dir != old_dir) { if (is_dir) { error = inode_permission(source, MAY_WRITE); if (error) return error; } if ((flags & RENAME_EXCHANGE) && new_is_dir) { error = inode_permission(target, MAY_WRITE); if (error) return error; } } error = security_inode_rename(old_dir, old_dentry, new_dir, new_dentry, flags); if (error) return error; old_name = fsnotify_oldname_init(old_dentry->d_name.name); dget(new_dentry); if (!is_dir \|\| (flags & RENAME_EXCHANGE)) lock_two_nondirectories(source, target); else if (target) mutex_lock(&target->i_mutex); error = -EBUSY; if (d_mountpoint(old_dentry) \|\| d_mountpoint(new_dentry)) goto out; if (max_links && new_dir != old_dir) { error = -EMLINK; if (is_dir && !new_is_dir && new_dir->i_nlink >= max_links) goto out; if ((flags & RENAME_EXCHANGE) && !is_dir && new_is_dir && old_dir->i_nlink >= max_links) goto out; } if (is_dir && !(flags & RENAME_EXCHANGE) && target) shrink_dcache_parent(new_dentry); if (!is_dir) { error = try_break_deleg(source, delegated_inode); if (error) goto out; } if (target && !new_is_dir) { error = try_break_deleg(target, delegated_inode); if (error) goto out; } if (!flags) { error = old_dir->i_op->rename(old_dir, old_dentry, new_dir, new_dentry); } else { error = old_dir->i_op->rename2(old_dir, old_dentry, new_dir, new_dentry, flags); } if (error) goto out; if (!(flags & RENAME_EXCHANGE) && target) { if (is_dir) target->i_flags \|= S_DEAD; dont_mount(new_dentry); } if (!(old_dir->i_sb->s_type->fs_flags & FS_RENAME_DOES_D_MOVE)) { if (!(flags & RENAME_EXCHANGE)) d_move(old_dentry, new_dentry); else d_exchange(old_dentry, new_dentry); } out: if (!is_dir \|\| (flags & RENAME_EXCHANGE)) unlock_two_nondirectories(source, target); else if (target) mutex_unlock(&target->i_mutex); dput(new_dentry); if (!error) { fsnotify_move(old_dir, new_dir, old_name, is_dir, !(flags & RENAME_EXCHANGE) ? target : NULL, old_dentry); if (flags & RENAME_EXCHANGE) { fsnotify_move(new_dir, old_dir, old_dentry->d_name.name, new_is_dir, NULL, new_dentry); } } fsnotify_oldname_free(old_name); return error; } EXPORT_SYMBOL(vfs_rename); SYSCALL_DEFINE5(renameat2, int, olddfd, const char __user , oldname, int, newdfd, const char __user , newname, unsigned int, flags) { struct dentry old_dir, new_dir; struct dentry old_dentry, new_dentry; struct dentry trap; struct nameidata oldnd, newnd; struct inode delegated_inode = NULL; struct filename from; struct filename to; unsigned int lookup_flags = 0; bool should_retry = false; int error; if (flags & ~(RENAME_NOREPLACE \| RENAME_EXCHANGE)) return -EINVAL; if ((flags & RENAME_NOREPLACE) && (flags & RENAME_EXCHANGE)) return -EINVAL; retry: from = user_path_parent(olddfd, oldname, &oldnd, lookup_flags); if (IS_ERR(from)) { error = PTR_ERR(from); goto exit; } to = user_path_parent(newdfd, newname, &newnd, lookup_flags); if (IS_ERR(to)) { error = PTR_ERR(to); goto exit1; } error = -EXDEV; if (oldnd.path.mnt != newnd.path.mnt) goto exit2; old_dir = oldnd.path.dentry; error = -EBUSY; if (oldnd.last_type != LAST_NORM) goto exit2; new_dir = newnd.path.dentry; if (flags & RENAME_NOREPLACE) error = -EEXIST; if (newnd.last_type != LAST_NORM) goto exit2; error = mnt_want_write(oldnd.path.mnt); if (error) goto exit2; oldnd.flags &= ~LOOKUP_PARENT; newnd.flags &= ~LOOKUP_PARENT; if (!(flags & RENAME_EXCHANGE)) newnd.flags \|= LOOKUP_RENAME_TARGET; retry_deleg: trap = lock_rename(new_dir, old_dir); old_dentry = lookup_hash(&oldnd); error = PTR_ERR(old_dentry); if (IS_ERR(old_dentry)) goto exit3; / source must exist / error = -ENOENT; if (d_is_negative(old_dentry)) goto exit4; new_dentry = lookup_hash(&newnd); error = PTR_ERR(new_dentry); if (IS_ERR(new_dentry)) goto exit4; error = -EEXIST; if ((flags & RENAME_NOREPLACE) && d_is_positive(new_dentry)) goto exit5; if (flags & RENAME_EXCHANGE) { error = -ENOENT; if (d_is_negative(new_dentry)) goto exit5; if (!d_is_dir(new_dentry)) { error = -ENOTDIR; if (newnd.last.name[newnd.last.len]) goto exit5; } } / unless the source is a directory trailing slashes give -ENOTDIR / if (!d_is_dir(old_dentry)) { error = -ENOTDIR; if (oldnd.last.name[oldnd.last.len]) goto exit5; if (!(flags & RENAME_EXCHANGE) && newnd.last.name[newnd.last.len]) goto exit5; } / source should not be ancestor of target / error = -EINVAL; if (old_dentry == trap) goto exit5; / target should not be an ancestor of source / if (!(flags & RENAME_EXCHANGE)) error = -ENOTEMPTY; if (new_dentry == trap) goto exit5; error = security_path_rename(&oldnd.path, old_dentry, &newnd.path, new_dentry, flags); if (error) goto exit5; error = vfs_rename(old_dir->d_inode, old_dentry, new_dir->d_inode, new_dentry, &delegated_inode, flags); exit5: dput(new_dentry); exit4: dput(old_dentry); exit3: unlock_rename(new_dir, old_dir); if (delegated_inode) { error = break_deleg_wait(&delegated_inode); if (!error) goto retry_deleg; } mnt_drop_write(oldnd.path.mnt); exit2: if (retry_estale(error, lookup_flags)) should_retry = true; path_put(&newnd.path); putname(to); exit1: path_put(&oldnd.path); putname(from); if (should_retry) { should_retry = false; lookup_flags \|= LOOKUP_REVAL; goto retry; } exit: return error; } SYSCALL_DEFINE4(renameat, int, olddfd, const char __user , oldname, int, newdfd, const char __user , newname) { return sys_renameat2(olddfd, oldname, newdfd, newname, 0); } SYSCALL_DEFINE2(rename, const char __user , oldname, const char __user , newname) { return sys_renameat2(AT_FDCWD, oldname, AT_FDCWD, newname, 0); } int readlink_copy(char __user buffer, int buflen, const char link) { int len = PTR_ERR(link); if (IS_ERR(link)) goto out; len = strlen(link); if (len > (unsigned) buflen) len = buflen; if (copy_to_user(buffer, link, len)) len = -EFAULT; out: return len; } EXPORT_SYMBOL(readlink_copy); / * A helper for ->readlink(). This should be used ONLY for symlinks that * have ->follow_link() touching nd only in nd_set_link(). Using (or not * using) it for any given inode is up to filesystem. / int generic_readlink(struct dentry dentry, char __user buffer, int buflen) { struct nameidata nd; void cookie; int res; nd.depth = 0; cookie = dentry->d_inode->i_op->follow_link(dentry, &nd); if (IS_ERR(cookie)) return PTR_ERR(cookie); res = readlink_copy(buffer, buflen, nd_get_link(&nd)); if (dentry->d_inode->i_op->put_link) dentry->d_inode->i_op->put_link(dentry, &nd, cookie); return res; } EXPORT_SYMBOL(generic_readlink); /* get the link contents into pagecache / static char page_getlink(struct dentry * dentry, struct page *ppage) { char kaddr; struct page page; struct address_space mapping = dentry->d_inode->i_mapping; page = read_mapping_page(mapping, 0, NULL); if (IS_ERR(page)) return (char)page; ppage = page; kaddr = kmap(page); nd_terminate_link(kaddr, dentry->d_inode->i_size, PAGE_SIZE - 1); return kaddr; } int page_readlink(struct dentry dentry, char __user buffer, int buflen) { struct page page = NULL; int res = readlink_copy(buffer, buflen, page_getlink(dentry, &page)); if (page) { kunmap(page); page_cache_release(page); } return res; } EXPORT_SYMBOL(page_readlink); void page_follow_link_light(struct dentry dentry, struct nameidata nd) { struct page page = NULL; nd_set_link(nd, page_getlink(dentry, &page)); return page; } EXPORT_SYMBOL(page_follow_link_light); void page_put_link(struct dentry dentry, struct nameidata nd, void cookie) { struct page page = cookie; if (page) { kunmap(page); page_cache_release(page); } } EXPORT_SYMBOL(page_put_link); / * The nofs argument instructs pagecache_write_begin to pass AOP_FLAG_NOFS / int __page_symlink(struct inode inode, const char symname, int len, int nofs) { struct address_space mapping = inode->i_mapping; struct page page; void fsdata; int err; char kaddr; unsigned int flags = AOP_FLAG_UNINTERRUPTIBLE; if (nofs) flags \|= AOP_FLAG_NOFS; retry: err = pagecache_write_begin(NULL, mapping, 0, len-1, flags, &page, &fsdata); if (err) goto fail; kaddr = kmap_atomic(page); memcpy(kaddr, symname, len-1); kunmap_atomic(kaddr); err = pagecache_write_end(NULL, mapping, 0, len-1, len-1, page, fsdata); if (err < 0) goto fail; if (err < len-1) goto retry; mark_inode_dirty(inode); return 0; fail: return err; } EXPORT_SYMBOL(__page_symlink); int page_symlink(struct inode inode, const char *symname, int len) { return __page_symlink(inode, symname, len, !(mapping_gfp_mask(inode->i_mapping) & __GFP_FS)); } EXPORT_SYMBOL(page_symlink); const struct inode_operations page_symlink_inode_operations = { .readlink = generic_readlink, .follow_link = page_follow_link_light, .put_link = page_put_link, }; EXPORT_SYMBOL(page_symlink_inode_operations);	./CrossVul/dataset_final_sorted/CWE-264/c/bad_2190_2
crossvul-cpp_data_bad_5861_15	/* Glue code for CRC32C optimized for sparc64 crypto opcodes. * * This is based largely upon arch/x86/crypto/crc32c-intel.c * * Copyright (C) 2008 Intel Corporation * Authors: Austin Zhang <austin_zhang@linux.intel.com> * Kent Liu <kent.liu@intel.com> / #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #include <linux/init.h> #include <linux/module.h> #include <linux/string.h> #include <linux/kernel.h> #include <linux/crc32.h> #include <crypto/internal/hash.h> #include <asm/pstate.h> #include <asm/elf.h> #include "opcodes.h" / * Setting the seed allows arbitrary accumulators and flexible XOR policy * If your algorithm starts with ~0, then XOR with ~0 before you set * the seed. / static int crc32c_sparc64_setkey(struct crypto_shash hash, const u8 key, unsigned int keylen) { u32 mctx = crypto_shash_ctx(hash); if (keylen != sizeof(u32)) { crypto_shash_set_flags(hash, CRYPTO_TFM_RES_BAD_KEY_LEN); return -EINVAL; } (__le32 )mctx = le32_to_cpup((__le32 )key); return 0; } static int crc32c_sparc64_init(struct shash_desc desc) { u32 mctx = crypto_shash_ctx(desc->tfm); u32 crcp = shash_desc_ctx(desc); crcp = mctx; return 0; } extern void crc32c_sparc64(u32 crcp, const u64 data, unsigned int len); static void crc32c_compute(u32 crcp, const u64 data, unsigned int len) { unsigned int asm_len; asm_len = len & ~7U; if (asm_len) { crc32c_sparc64(crcp, data, asm_len); data += asm_len / 8; len -= asm_len; } if (len) crcp = __crc32c_le(crcp, (const unsigned char ) data, len); } static int crc32c_sparc64_update(struct shash_desc desc, const u8 data, unsigned int len) { u32 crcp = shash_desc_ctx(desc); crc32c_compute(crcp, (const u64 ) data, len); return 0; } static int __crc32c_sparc64_finup(u32 crcp, const u8 data, unsigned int len, u8 out) { u32 tmp = crcp; crc32c_compute(&tmp, (const u64 ) data, len); (__le32 ) out = ~cpu_to_le32(tmp); return 0; } static int crc32c_sparc64_finup(struct shash_desc desc, const u8 data, unsigned int len, u8 out) { return __crc32c_sparc64_finup(shash_desc_ctx(desc), data, len, out); } static int crc32c_sparc64_final(struct shash_desc desc, u8 out) { u32 crcp = shash_desc_ctx(desc); (__le32 ) out = ~cpu_to_le32p(crcp); return 0; } static int crc32c_sparc64_digest(struct shash_desc desc, const u8 data, unsigned int len, u8 out) { return __crc32c_sparc64_finup(crypto_shash_ctx(desc->tfm), data, len, out); } static int crc32c_sparc64_cra_init(struct crypto_tfm tfm) { u32 key = crypto_tfm_ctx(tfm); key = ~0; return 0; } #define CHKSUM_BLOCK_SIZE 1 #define CHKSUM_DIGEST_SIZE 4 static struct shash_alg alg = { .setkey = crc32c_sparc64_setkey, .init = crc32c_sparc64_init, .update = crc32c_sparc64_update, .final = crc32c_sparc64_final, .finup = crc32c_sparc64_finup, .digest = crc32c_sparc64_digest, .descsize = sizeof(u32), .digestsize = CHKSUM_DIGEST_SIZE, .base = { .cra_name = "crc32c", .cra_driver_name = "crc32c-sparc64", .cra_priority = SPARC_CR_OPCODE_PRIORITY, .cra_blocksize = CHKSUM_BLOCK_SIZE, .cra_ctxsize = sizeof(u32), .cra_alignmask = 7, .cra_module = THIS_MODULE, .cra_init = crc32c_sparc64_cra_init, } }; static bool __init sparc64_has_crc32c_opcode(void) { unsigned long cfr; if (!(sparc64_elf_hwcap & HWCAP_SPARC_CRYPTO)) return false; __asm__ __volatile__("rd %%asr26, %0" : "=r" (cfr)); if (!(cfr & CFR_CRC32C)) return false; return true; } static int __init crc32c_sparc64_mod_init(void) { if (sparc64_has_crc32c_opcode()) { pr_info("Using sparc64 crc32c opcode optimized CRC32C implementation\n"); return crypto_register_shash(&alg); } pr_info("sparc64 crc32c opcode not available.\n"); return -ENODEV; } static void __exit crc32c_sparc64_mod_fini(void) { crypto_unregister_shash(&alg); } module_init(crc32c_sparc64_mod_init); module_exit(crc32c_sparc64_mod_fini); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("CRC32c (Castagnoli), sparc64 crc32c opcode accelerated"); MODULE_ALIAS("crc32c"); #include "crop_devid.c"	./CrossVul/dataset_final_sorted/CWE-264/c/bad_5861_15
crossvul-cpp_data_bad_5801_0	/* * Adaptec AAC series RAID controller driver * (c) Copyright 2001 Red Hat Inc. * * based on the old aacraid driver that is.. * Adaptec aacraid device driver for Linux. * * Copyright (c) 2000-2010 Adaptec, Inc. * 2010 PMC-Sierra, Inc. (aacraid@pmc-sierra.com) * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2, or (at your option) * any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; see the file COPYING. If not, write to * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. * * Module Name: * linit.c * * Abstract: Linux Driver entry module for Adaptec RAID Array Controller / #include <linux/compat.h> #include <linux/blkdev.h> #include <linux/completion.h> #include <linux/init.h> #include <linux/interrupt.h> #include <linux/kernel.h> #include <linux/module.h> #include <linux/moduleparam.h> #include <linux/pci.h> #include <linux/pci-aspm.h> #include <linux/slab.h> #include <linux/mutex.h> #include <linux/spinlock.h> #include <linux/syscalls.h> #include <linux/delay.h> #include <linux/kthread.h> #include <scsi/scsi.h> #include <scsi/scsi_cmnd.h> #include <scsi/scsi_device.h> #include <scsi/scsi_host.h> #include <scsi/scsi_tcq.h> #include <scsi/scsicam.h> #include <scsi/scsi_eh.h> #include "aacraid.h" #define AAC_DRIVER_VERSION "1.2-0" #ifndef AAC_DRIVER_BRANCH #define AAC_DRIVER_BRANCH "" #endif #define AAC_DRIVERNAME "aacraid" #ifdef AAC_DRIVER_BUILD #define _str(x) #x #define str(x) _str(x) #define AAC_DRIVER_FULL_VERSION AAC_DRIVER_VERSION "[" str(AAC_DRIVER_BUILD) "]" AAC_DRIVER_BRANCH #else #define AAC_DRIVER_FULL_VERSION AAC_DRIVER_VERSION AAC_DRIVER_BRANCH #endif MODULE_AUTHOR("Red Hat Inc and Adaptec"); MODULE_DESCRIPTION("Dell PERC2, 2/Si, 3/Si, 3/Di, " "Adaptec Advanced Raid Products, " "HP NetRAID-4M, IBM ServeRAID & ICP SCSI driver"); MODULE_LICENSE("GPL"); MODULE_VERSION(AAC_DRIVER_FULL_VERSION); static DEFINE_MUTEX(aac_mutex); static LIST_HEAD(aac_devices); static int aac_cfg_major = -1; char aac_driver_version[] = AAC_DRIVER_FULL_VERSION; / * Because of the way Linux names scsi devices, the order in this table has * become important. Check for on-board Raid first, add-in cards second. * * Note: The last field is used to index into aac_drivers below. / static const struct pci_device_id aac_pci_tbl[] = { { 0x1028, 0x0001, 0x1028, 0x0001, 0, 0, 0 }, / PERC 2/Si (Iguana/PERC2Si) / { 0x1028, 0x0002, 0x1028, 0x0002, 0, 0, 1 }, / PERC 3/Di (Opal/PERC3Di) / { 0x1028, 0x0003, 0x1028, 0x0003, 0, 0, 2 }, / PERC 3/Si (SlimFast/PERC3Si / { 0x1028, 0x0004, 0x1028, 0x00d0, 0, 0, 3 }, / PERC 3/Di (Iguana FlipChip/PERC3DiF / { 0x1028, 0x0002, 0x1028, 0x00d1, 0, 0, 4 }, / PERC 3/Di (Viper/PERC3DiV) / { 0x1028, 0x0002, 0x1028, 0x00d9, 0, 0, 5 }, / PERC 3/Di (Lexus/PERC3DiL) / { 0x1028, 0x000a, 0x1028, 0x0106, 0, 0, 6 }, / PERC 3/Di (Jaguar/PERC3DiJ) / { 0x1028, 0x000a, 0x1028, 0x011b, 0, 0, 7 }, / PERC 3/Di (Dagger/PERC3DiD) / { 0x1028, 0x000a, 0x1028, 0x0121, 0, 0, 8 }, / PERC 3/Di (Boxster/PERC3DiB) / { 0x9005, 0x0283, 0x9005, 0x0283, 0, 0, 9 }, / catapult / { 0x9005, 0x0284, 0x9005, 0x0284, 0, 0, 10 }, / tomcat / { 0x9005, 0x0285, 0x9005, 0x0286, 0, 0, 11 }, / Adaptec 2120S (Crusader) / { 0x9005, 0x0285, 0x9005, 0x0285, 0, 0, 12 }, / Adaptec 2200S (Vulcan) / { 0x9005, 0x0285, 0x9005, 0x0287, 0, 0, 13 }, / Adaptec 2200S (Vulcan-2m) / { 0x9005, 0x0285, 0x17aa, 0x0286, 0, 0, 14 }, / Legend S220 (Legend Crusader) / { 0x9005, 0x0285, 0x17aa, 0x0287, 0, 0, 15 }, / Legend S230 (Legend Vulcan) / { 0x9005, 0x0285, 0x9005, 0x0288, 0, 0, 16 }, / Adaptec 3230S (Harrier) / { 0x9005, 0x0285, 0x9005, 0x0289, 0, 0, 17 }, / Adaptec 3240S (Tornado) / { 0x9005, 0x0285, 0x9005, 0x028a, 0, 0, 18 }, / ASR-2020ZCR SCSI PCI-X ZCR (Skyhawk) / { 0x9005, 0x0285, 0x9005, 0x028b, 0, 0, 19 }, / ASR-2025ZCR SCSI SO-DIMM PCI-X ZCR (Terminator) / { 0x9005, 0x0286, 0x9005, 0x028c, 0, 0, 20 }, / ASR-2230S + ASR-2230SLP PCI-X (Lancer) / { 0x9005, 0x0286, 0x9005, 0x028d, 0, 0, 21 }, / ASR-2130S (Lancer) / { 0x9005, 0x0286, 0x9005, 0x029b, 0, 0, 22 }, / AAR-2820SA (Intruder) / { 0x9005, 0x0286, 0x9005, 0x029c, 0, 0, 23 }, / AAR-2620SA (Intruder) / { 0x9005, 0x0286, 0x9005, 0x029d, 0, 0, 24 }, / AAR-2420SA (Intruder) / { 0x9005, 0x0286, 0x9005, 0x029e, 0, 0, 25 }, / ICP9024RO (Lancer) / { 0x9005, 0x0286, 0x9005, 0x029f, 0, 0, 26 }, / ICP9014RO (Lancer) / { 0x9005, 0x0286, 0x9005, 0x02a0, 0, 0, 27 }, / ICP9047MA (Lancer) / { 0x9005, 0x0286, 0x9005, 0x02a1, 0, 0, 28 }, / ICP9087MA (Lancer) / { 0x9005, 0x0286, 0x9005, 0x02a3, 0, 0, 29 }, / ICP5445AU (Hurricane44) / { 0x9005, 0x0285, 0x9005, 0x02a4, 0, 0, 30 }, / ICP9085LI (Marauder-X) / { 0x9005, 0x0285, 0x9005, 0x02a5, 0, 0, 31 }, / ICP5085BR (Marauder-E) / { 0x9005, 0x0286, 0x9005, 0x02a6, 0, 0, 32 }, / ICP9067MA (Intruder-6) / { 0x9005, 0x0287, 0x9005, 0x0800, 0, 0, 33 }, / Themisto Jupiter Platform / { 0x9005, 0x0200, 0x9005, 0x0200, 0, 0, 33 }, / Themisto Jupiter Platform / { 0x9005, 0x0286, 0x9005, 0x0800, 0, 0, 34 }, / Callisto Jupiter Platform / { 0x9005, 0x0285, 0x9005, 0x028e, 0, 0, 35 }, / ASR-2020SA SATA PCI-X ZCR (Skyhawk) / { 0x9005, 0x0285, 0x9005, 0x028f, 0, 0, 36 }, / ASR-2025SA SATA SO-DIMM PCI-X ZCR (Terminator) / { 0x9005, 0x0285, 0x9005, 0x0290, 0, 0, 37 }, / AAR-2410SA PCI SATA 4ch (Jaguar II) / { 0x9005, 0x0285, 0x1028, 0x0291, 0, 0, 38 }, / CERC SATA RAID 2 PCI SATA 6ch (DellCorsair) / { 0x9005, 0x0285, 0x9005, 0x0292, 0, 0, 39 }, / AAR-2810SA PCI SATA 8ch (Corsair-8) / { 0x9005, 0x0285, 0x9005, 0x0293, 0, 0, 40 }, / AAR-21610SA PCI SATA 16ch (Corsair-16) / { 0x9005, 0x0285, 0x9005, 0x0294, 0, 0, 41 }, / ESD SO-DIMM PCI-X SATA ZCR (Prowler) / { 0x9005, 0x0285, 0x103C, 0x3227, 0, 0, 42 }, / AAR-2610SA PCI SATA 6ch / { 0x9005, 0x0285, 0x9005, 0x0296, 0, 0, 43 }, / ASR-2240S (SabreExpress) / { 0x9005, 0x0285, 0x9005, 0x0297, 0, 0, 44 }, / ASR-4005 / { 0x9005, 0x0285, 0x1014, 0x02F2, 0, 0, 45 }, / IBM 8i (AvonPark) / { 0x9005, 0x0285, 0x1014, 0x0312, 0, 0, 45 }, / IBM 8i (AvonPark Lite) / { 0x9005, 0x0286, 0x1014, 0x9580, 0, 0, 46 }, / IBM 8k/8k-l8 (Aurora) / { 0x9005, 0x0286, 0x1014, 0x9540, 0, 0, 47 }, / IBM 8k/8k-l4 (Aurora Lite) / { 0x9005, 0x0285, 0x9005, 0x0298, 0, 0, 48 }, / ASR-4000 (BlackBird) / { 0x9005, 0x0285, 0x9005, 0x0299, 0, 0, 49 }, / ASR-4800SAS (Marauder-X) / { 0x9005, 0x0285, 0x9005, 0x029a, 0, 0, 50 }, / ASR-4805SAS (Marauder-E) / { 0x9005, 0x0286, 0x9005, 0x02a2, 0, 0, 51 }, / ASR-3800 (Hurricane44) / { 0x9005, 0x0285, 0x1028, 0x0287, 0, 0, 52 }, / Perc 320/DC/ { 0x1011, 0x0046, 0x9005, 0x0365, 0, 0, 53 }, / Adaptec 5400S (Mustang)/ { 0x1011, 0x0046, 0x9005, 0x0364, 0, 0, 54 }, / Adaptec 5400S (Mustang)/ { 0x1011, 0x0046, 0x9005, 0x1364, 0, 0, 55 }, / Dell PERC2/QC / { 0x1011, 0x0046, 0x103c, 0x10c2, 0, 0, 56 }, / HP NetRAID-4M / { 0x9005, 0x0285, 0x1028, PCI_ANY_ID, 0, 0, 57 }, / Dell Catchall / { 0x9005, 0x0285, 0x17aa, PCI_ANY_ID, 0, 0, 58 }, / Legend Catchall / { 0x9005, 0x0285, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 59 }, / Adaptec Catch All / { 0x9005, 0x0286, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 60 }, / Adaptec Rocket Catch All / { 0x9005, 0x0288, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 61 }, / Adaptec NEMER/ARK Catch All / { 0x9005, 0x028b, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 62 }, / Adaptec PMC Series 6 (Tupelo) / { 0x9005, 0x028c, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 63 }, / Adaptec PMC Series 7 (Denali) / { 0x9005, 0x028d, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 64 }, / Adaptec PMC Series 8 / { 0x9005, 0x028f, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 65 }, / Adaptec PMC Series 9 / { 0,} }; MODULE_DEVICE_TABLE(pci, aac_pci_tbl); / * dmb - For now we add the number of channels to this structure. * In the future we should add a fib that reports the number of channels * for the card. At that time we can remove the channels from here / static struct aac_driver_ident aac_drivers[] = { { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / PERC 2/Si (Iguana/PERC2Si) / { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / PERC 3/Di (Opal/PERC3Di) / { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / PERC 3/Si (SlimFast/PERC3Si / { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / PERC 3/Di (Iguana FlipChip/PERC3DiF / { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / PERC 3/Di (Viper/PERC3DiV) / { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / PERC 3/Di (Lexus/PERC3DiL) / { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 1, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / PERC 3/Di (Jaguar/PERC3DiJ) / { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / PERC 3/Di (Dagger/PERC3DiD) / { aac_rx_init, "percraid", "DELL ", "PERCRAID ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / PERC 3/Di (Boxster/PERC3DiB) / { aac_rx_init, "aacraid", "ADAPTEC ", "catapult ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / catapult / { aac_rx_init, "aacraid", "ADAPTEC ", "tomcat ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / tomcat / { aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 2120S ", 1, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG }, / Adaptec 2120S (Crusader) / { aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 2200S ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG }, / Adaptec 2200S (Vulcan) / { aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 2200S ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / Adaptec 2200S (Vulcan-2m) / { aac_rx_init, "aacraid", "Legend ", "Legend S220 ", 1, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / Legend S220 (Legend Crusader) / { aac_rx_init, "aacraid", "Legend ", "Legend S230 ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / Legend S230 (Legend Vulcan) / { aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 3230S ", 2 }, / Adaptec 3230S (Harrier) / { aac_rx_init, "aacraid", "ADAPTEC ", "Adaptec 3240S ", 2 }, / Adaptec 3240S (Tornado) / { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2020ZCR ", 2 }, / ASR-2020ZCR SCSI PCI-X ZCR (Skyhawk) / { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2025ZCR ", 2 }, / ASR-2025ZCR SCSI SO-DIMM PCI-X ZCR (Terminator) / { aac_rkt_init, "aacraid", "ADAPTEC ", "ASR-2230S PCI-X ", 2 }, / ASR-2230S + ASR-2230SLP PCI-X (Lancer) / { aac_rkt_init, "aacraid", "ADAPTEC ", "ASR-2130S PCI-X ", 1 }, / ASR-2130S (Lancer) / { aac_rkt_init, "aacraid", "ADAPTEC ", "AAR-2820SA ", 1 }, / AAR-2820SA (Intruder) / { aac_rkt_init, "aacraid", "ADAPTEC ", "AAR-2620SA ", 1 }, / AAR-2620SA (Intruder) / { aac_rkt_init, "aacraid", "ADAPTEC ", "AAR-2420SA ", 1 }, / AAR-2420SA (Intruder) / { aac_rkt_init, "aacraid", "ICP ", "ICP9024RO ", 2 }, / ICP9024RO (Lancer) / { aac_rkt_init, "aacraid", "ICP ", "ICP9014RO ", 1 }, / ICP9014RO (Lancer) / { aac_rkt_init, "aacraid", "ICP ", "ICP9047MA ", 1 }, / ICP9047MA (Lancer) / { aac_rkt_init, "aacraid", "ICP ", "ICP9087MA ", 1 }, / ICP9087MA (Lancer) / { aac_rkt_init, "aacraid", "ICP ", "ICP5445AU ", 1 }, / ICP5445AU (Hurricane44) / { aac_rx_init, "aacraid", "ICP ", "ICP9085LI ", 1 }, / ICP9085LI (Marauder-X) / { aac_rx_init, "aacraid", "ICP ", "ICP5085BR ", 1 }, / ICP5085BR (Marauder-E) / { aac_rkt_init, "aacraid", "ICP ", "ICP9067MA ", 1 }, / ICP9067MA (Intruder-6) / { NULL , "aacraid", "ADAPTEC ", "Themisto ", 0, AAC_QUIRK_SLAVE }, / Jupiter Platform / { aac_rkt_init, "aacraid", "ADAPTEC ", "Callisto ", 2, AAC_QUIRK_MASTER }, / Jupiter Platform / { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2020SA ", 1 }, / ASR-2020SA SATA PCI-X ZCR (Skyhawk) / { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2025SA ", 1 }, / ASR-2025SA SATA SO-DIMM PCI-X ZCR (Terminator) / { aac_rx_init, "aacraid", "ADAPTEC ", "AAR-2410SA SATA ", 1, AAC_QUIRK_17SG }, / AAR-2410SA PCI SATA 4ch (Jaguar II) / { aac_rx_init, "aacraid", "DELL ", "CERC SR2 ", 1, AAC_QUIRK_17SG }, / CERC SATA RAID 2 PCI SATA 6ch (DellCorsair) / { aac_rx_init, "aacraid", "ADAPTEC ", "AAR-2810SA SATA ", 1, AAC_QUIRK_17SG }, / AAR-2810SA PCI SATA 8ch (Corsair-8) / { aac_rx_init, "aacraid", "ADAPTEC ", "AAR-21610SA SATA", 1, AAC_QUIRK_17SG }, / AAR-21610SA PCI SATA 16ch (Corsair-16) / { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2026ZCR ", 1 }, / ESD SO-DIMM PCI-X SATA ZCR (Prowler) / { aac_rx_init, "aacraid", "ADAPTEC ", "AAR-2610SA ", 1 }, / SATA 6Ch (Bearcat) / { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-2240S ", 1 }, / ASR-2240S (SabreExpress) / { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-4005 ", 1 }, / ASR-4005 / { aac_rx_init, "ServeRAID","IBM ", "ServeRAID 8i ", 1 }, / IBM 8i (AvonPark) / { aac_rkt_init, "ServeRAID","IBM ", "ServeRAID 8k-l8 ", 1 }, / IBM 8k/8k-l8 (Aurora) / { aac_rkt_init, "ServeRAID","IBM ", "ServeRAID 8k-l4 ", 1 }, / IBM 8k/8k-l4 (Aurora Lite) / { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-4000 ", 1 }, / ASR-4000 (BlackBird & AvonPark) / { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-4800SAS ", 1 }, / ASR-4800SAS (Marauder-X) / { aac_rx_init, "aacraid", "ADAPTEC ", "ASR-4805SAS ", 1 }, / ASR-4805SAS (Marauder-E) / { aac_rkt_init, "aacraid", "ADAPTEC ", "ASR-3800 ", 1 }, / ASR-3800 (Hurricane44) / { aac_rx_init, "percraid", "DELL ", "PERC 320/DC ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG }, / Perc 320/DC/ { aac_sa_init, "aacraid", "ADAPTEC ", "Adaptec 5400S ", 4, AAC_QUIRK_34SG }, / Adaptec 5400S (Mustang)/ { aac_sa_init, "aacraid", "ADAPTEC ", "AAC-364 ", 4, AAC_QUIRK_34SG }, / Adaptec 5400S (Mustang)/ { aac_sa_init, "percraid", "DELL ", "PERCRAID ", 4, AAC_QUIRK_34SG }, / Dell PERC2/QC / { aac_sa_init, "hpnraid", "HP ", "NetRAID ", 4, AAC_QUIRK_34SG }, / HP NetRAID-4M / { aac_rx_init, "aacraid", "DELL ", "RAID ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / Dell Catchall / { aac_rx_init, "aacraid", "Legend ", "RAID ", 2, AAC_QUIRK_31BIT \| AAC_QUIRK_34SG \| AAC_QUIRK_SCSI_32 }, / Legend Catchall / { aac_rx_init, "aacraid", "ADAPTEC ", "RAID ", 2 }, / Adaptec Catch All / { aac_rkt_init, "aacraid", "ADAPTEC ", "RAID ", 2 }, / Adaptec Rocket Catch All / { aac_nark_init, "aacraid", "ADAPTEC ", "RAID ", 2 }, / Adaptec NEMER/ARK Catch All / { aac_src_init, "aacraid", "ADAPTEC ", "RAID ", 2 }, / Adaptec PMC Series 6 (Tupelo) / { aac_srcv_init, "aacraid", "ADAPTEC ", "RAID ", 2 }, / Adaptec PMC Series 7 (Denali) / { aac_srcv_init, "aacraid", "ADAPTEC ", "RAID ", 2 }, / Adaptec PMC Series 8 / { aac_srcv_init, "aacraid", "ADAPTEC ", "RAID ", 2 } / Adaptec PMC Series 9 / }; /* * aac_queuecommand - queue a SCSI command * @cmd: SCSI command to queue * @done: Function to call on command completion * * Queues a command for execution by the associated Host Adapter. * * TODO: unify with aac_scsi_cmd(). / static int aac_queuecommand_lck(struct scsi_cmnd cmd, void (done)(struct scsi_cmnd )) { struct Scsi_Host host = cmd->device->host; struct aac_dev dev = (struct aac_dev )host->hostdata; u32 count = 0; cmd->scsi_done = done; for (; count < (host->can_queue + AAC_NUM_MGT_FIB); ++count) { struct fib fib = &dev->fibs[count]; struct scsi_cmnd * command; if (fib->hw_fib_va->header.XferState && ((command = fib->callback_data)) && (command == cmd) && (cmd->SCp.phase == AAC_OWNER_FIRMWARE)) return 0; /* Already owned by Adapter / } cmd->SCp.phase = AAC_OWNER_LOWLEVEL; return (aac_scsi_cmd(cmd) ? FAILED : 0); } static DEF_SCSI_QCMD(aac_queuecommand) /* * aac_info - Returns the host adapter name * @shost: Scsi host to report on * * Returns a static string describing the device in question / static const char aac_info(struct Scsi_Host shost) { struct aac_dev dev = (struct aac_dev )shost->hostdata; return aac_drivers[dev->cardtype].name; } /* * aac_get_driver_ident * @devtype: index into lookup table * * Returns a pointer to the entry in the driver lookup table. / struct aac_driver_ident aac_get_driver_ident(int devtype) { return &aac_drivers[devtype]; } /** * aac_biosparm - return BIOS parameters for disk * @sdev: The scsi device corresponding to the disk * @bdev: the block device corresponding to the disk * @capacity: the sector capacity of the disk * @geom: geometry block to fill in * * Return the Heads/Sectors/Cylinders BIOS Disk Parameters for Disk. * The default disk geometry is 64 heads, 32 sectors, and the appropriate * number of cylinders so as not to exceed drive capacity. In order for * disks equal to or larger than 1 GB to be addressable by the BIOS * without exceeding the BIOS limitation of 1024 cylinders, Extended * Translation should be enabled. With Extended Translation enabled, * drives between 1 GB inclusive and 2 GB exclusive are given a disk * geometry of 128 heads and 32 sectors, and drives above 2 GB inclusive * are given a disk geometry of 255 heads and 63 sectors. However, if * the BIOS detects that the Extended Translation setting does not match * the geometry in the partition table, then the translation inferred * from the partition table will be used by the BIOS, and a warning may * be displayed. / static int aac_biosparm(struct scsi_device sdev, struct block_device bdev, sector_t capacity, int geom) { struct diskparm param = (struct diskparm )geom; unsigned char buf; dprintk((KERN_DEBUG "aac_biosparm.\n")); / * Assuming extended translation is enabled - #REVISIT# / if (capacity >= 2 1024 * 1024) { /* 1 GB in 512 byte sectors / if(capacity >= 4 1024 * 1024) { /* 2 GB in 512 byte sectors / param->heads = 255; param->sectors = 63; } else { param->heads = 128; param->sectors = 32; } } else { param->heads = 64; param->sectors = 32; } param->cylinders = cap_to_cyls(capacity, param->heads param->sectors); /* * Read the first 1024 bytes from the disk device, if the boot * sector partition table is valid, search for a partition table * entry whose end_head matches one of the standard geometry * translations ( 64/32, 128/32, 255/63 ). / buf = scsi_bios_ptable(bdev); if (!buf) return 0; if((__le16 )(buf + 0x40) == cpu_to_le16(0xaa55)) { struct partition first = (struct partition * )buf; struct partition entry = first; int saved_cylinders = param->cylinders; int num; unsigned char end_head, end_sec; for(num = 0; num < 4; num++) { end_head = entry->end_head; end_sec = entry->end_sector & 0x3f; if(end_head == 63) { param->heads = 64; param->sectors = 32; break; } else if(end_head == 127) { param->heads = 128; param->sectors = 32; break; } else if(end_head == 254) { param->heads = 255; param->sectors = 63; break; } entry++; } if (num == 4) { end_head = first->end_head; end_sec = first->end_sector & 0x3f; } param->cylinders = cap_to_cyls(capacity, param->heads param->sectors); if (num < 4 && end_sec == param->sectors) { if (param->cylinders != saved_cylinders) dprintk((KERN_DEBUG "Adopting geometry: heads=%d, sectors=%d from partition table %d.\n", param->heads, param->sectors, num)); } else if (end_head > 0 \|\| end_sec > 0) { dprintk((KERN_DEBUG "Strange geometry: heads=%d, sectors=%d in partition table %d.\n", end_head + 1, end_sec, num)); dprintk((KERN_DEBUG "Using geometry: heads=%d, sectors=%d.\n", param->heads, param->sectors)); } } kfree(buf); return 0; } /** * aac_slave_configure - compute queue depths * @sdev: SCSI device we are considering * * Selects queue depths for each target device based on the host adapter's * total capacity and the queue depth supported by the target device. * A queue depth of one automatically disables tagged queueing. / static int aac_slave_configure(struct scsi_device sdev) { struct aac_dev aac = (struct aac_dev )sdev->host->hostdata; if (aac->jbod && (sdev->type == TYPE_DISK)) sdev->removable = 1; if ((sdev->type == TYPE_DISK) && (sdev_channel(sdev) != CONTAINER_CHANNEL) && (!aac->jbod \|\| sdev->inq_periph_qual) && (!aac->raid_scsi_mode \|\| (sdev_channel(sdev) != 2))) { if (expose_physicals == 0) return -ENXIO; if (expose_physicals < 0) sdev->no_uld_attach = 1; } if (sdev->tagged_supported && (sdev->type == TYPE_DISK) && (!aac->raid_scsi_mode \|\| (sdev_channel(sdev) != 2)) && !sdev->no_uld_attach) { struct scsi_device * dev; struct Scsi_Host host = sdev->host; unsigned num_lsu = 0; unsigned num_one = 0; unsigned depth; unsigned cid; / * Firmware has an individual device recovery time typically * of 35 seconds, give us a margin. / if (sdev->request_queue->rq_timeout < (45 HZ)) blk_queue_rq_timeout(sdev->request_queue, 45HZ); for (cid = 0; cid < aac->maximum_num_containers; ++cid) if (aac->fsa_dev[cid].valid) ++num_lsu; __shost_for_each_device(dev, host) { if (dev->tagged_supported && (dev->type == TYPE_DISK) && (!aac->raid_scsi_mode \|\| (sdev_channel(sdev) != 2)) && !dev->no_uld_attach) { if ((sdev_channel(dev) != CONTAINER_CHANNEL) \|\| !aac->fsa_dev[sdev_id(dev)].valid) ++num_lsu; } else ++num_one; } if (num_lsu == 0) ++num_lsu; depth = (host->can_queue - num_one) / num_lsu; if (depth > 256) depth = 256; else if (depth < 2) depth = 2; scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth); } else scsi_adjust_queue_depth(sdev, 0, 1); return 0; } /* * aac_change_queue_depth - alter queue depths * @sdev: SCSI device we are considering * @depth: desired queue depth * * Alters queue depths for target device based on the host adapter's * total capacity and the queue depth supported by the target device. / static int aac_change_queue_depth(struct scsi_device sdev, int depth, int reason) { if (reason != SCSI_QDEPTH_DEFAULT) return -EOPNOTSUPP; if (sdev->tagged_supported && (sdev->type == TYPE_DISK) && (sdev_channel(sdev) == CONTAINER_CHANNEL)) { struct scsi_device * dev; struct Scsi_Host host = sdev->host; unsigned num = 0; __shost_for_each_device(dev, host) { if (dev->tagged_supported && (dev->type == TYPE_DISK) && (sdev_channel(dev) == CONTAINER_CHANNEL)) ++num; ++num; } if (num >= host->can_queue) num = host->can_queue - 1; if (depth > (host->can_queue - num)) depth = host->can_queue - num; if (depth > 256) depth = 256; else if (depth < 2) depth = 2; scsi_adjust_queue_depth(sdev, MSG_ORDERED_TAG, depth); } else scsi_adjust_queue_depth(sdev, 0, 1); return sdev->queue_depth; } static ssize_t aac_show_raid_level(struct device dev, struct device_attribute attr, char buf) { struct scsi_device sdev = to_scsi_device(dev); struct aac_dev aac = (struct aac_dev )(sdev->host->hostdata); if (sdev_channel(sdev) != CONTAINER_CHANNEL) return snprintf(buf, PAGE_SIZE, sdev->no_uld_attach ? "Hidden\n" : ((aac->jbod && (sdev->type == TYPE_DISK)) ? "JBOD\n" : "")); return snprintf(buf, PAGE_SIZE, "%s\n", get_container_type(aac->fsa_dev[sdev_id(sdev)].type)); } static struct device_attribute aac_raid_level_attr = { .attr = { .name = "level", .mode = S_IRUGO, }, .show = aac_show_raid_level }; static struct device_attribute aac_dev_attrs[] = { &aac_raid_level_attr, NULL, }; static int aac_ioctl(struct scsi_device sdev, int cmd, void __user arg) { struct aac_dev dev = (struct aac_dev )sdev->host->hostdata; if (!capable(CAP_SYS_RAWIO)) return -EPERM; return aac_do_ioctl(dev, cmd, arg); } static int aac_eh_abort(struct scsi_cmnd* cmd) { struct scsi_device * dev = cmd->device; struct Scsi_Host * host = dev->host; struct aac_dev * aac = (struct aac_dev )host->hostdata; int count; int ret = FAILED; printk(KERN_ERR "%s: Host adapter abort request (%d,%d,%d,%d)\n", AAC_DRIVERNAME, host->host_no, sdev_channel(dev), sdev_id(dev), dev->lun); switch (cmd->cmnd[0]) { case SERVICE_ACTION_IN: if (!(aac->raw_io_interface) \|\| !(aac->raw_io_64) \|\| ((cmd->cmnd[1] & 0x1f) != SAI_READ_CAPACITY_16)) break; case INQUIRY: case READ_CAPACITY: / Mark associated FIB to not complete, eh handler does this / for (count = 0; count < (host->can_queue + AAC_NUM_MGT_FIB); ++count) { struct fib fib = &aac->fibs[count]; if (fib->hw_fib_va->header.XferState && (fib->flags & FIB_CONTEXT_FLAG) && (fib->callback_data == cmd)) { fib->flags \|= FIB_CONTEXT_FLAG_TIMED_OUT; cmd->SCp.phase = AAC_OWNER_ERROR_HANDLER; ret = SUCCESS; } } break; case TEST_UNIT_READY: /* Mark associated FIB to not complete, eh handler does this / for (count = 0; count < (host->can_queue + AAC_NUM_MGT_FIB); ++count) { struct scsi_cmnd command; struct fib * fib = &aac->fibs[count]; if ((fib->hw_fib_va->header.XferState & cpu_to_le32(Async \| NoResponseExpected)) && (fib->flags & FIB_CONTEXT_FLAG) && ((command = fib->callback_data)) && (command->device == cmd->device)) { fib->flags \|= FIB_CONTEXT_FLAG_TIMED_OUT; command->SCp.phase = AAC_OWNER_ERROR_HANDLER; if (command == cmd) ret = SUCCESS; } } } return ret; } /* * aac_eh_reset - Reset command handling * @scsi_cmd: SCSI command block causing the reset * / static int aac_eh_reset(struct scsi_cmnd cmd) { struct scsi_device * dev = cmd->device; struct Scsi_Host * host = dev->host; struct scsi_cmnd * command; int count; struct aac_dev * aac = (struct aac_dev )host->hostdata; unsigned long flags; / Mark the associated FIB to not complete, eh handler does this / for (count = 0; count < (host->can_queue + AAC_NUM_MGT_FIB); ++count) { struct fib fib = &aac->fibs[count]; if (fib->hw_fib_va->header.XferState && (fib->flags & FIB_CONTEXT_FLAG) && (fib->callback_data == cmd)) { fib->flags \|= FIB_CONTEXT_FLAG_TIMED_OUT; cmd->SCp.phase = AAC_OWNER_ERROR_HANDLER; } } printk(KERN_ERR "%s: Host adapter reset request. SCSI hang ?\n", AAC_DRIVERNAME); if ((count = aac_check_health(aac))) return count; /* * Wait for all commands to complete to this specific * target (block maximum 60 seconds). / for (count = 60; count; --count) { int active = aac->in_reset; if (active == 0) __shost_for_each_device(dev, host) { spin_lock_irqsave(&dev->list_lock, flags); list_for_each_entry(command, &dev->cmd_list, list) { if ((command != cmd) && (command->SCp.phase == AAC_OWNER_FIRMWARE)) { active++; break; } } spin_unlock_irqrestore(&dev->list_lock, flags); if (active) break; } / * We can exit If all the commands are complete / if (active == 0) return SUCCESS; ssleep(1); } printk(KERN_ERR "%s: SCSI bus appears hung\n", AAC_DRIVERNAME); / * This adapter needs a blind reset, only do so for Adapters that * support a register, instead of a commanded, reset. / if (((aac->supplement_adapter_info.SupportedOptions2 & AAC_OPTION_MU_RESET) \|\| (aac->supplement_adapter_info.SupportedOptions2 & AAC_OPTION_DOORBELL_RESET)) && aac_check_reset && ((aac_check_reset != 1) \|\| !(aac->supplement_adapter_info.SupportedOptions2 & AAC_OPTION_IGNORE_RESET))) aac_reset_adapter(aac, 2); / Bypass wait for command quiesce / return SUCCESS; / Cause an immediate retry of the command with a ten second delay after successful tur / } /* * aac_cfg_open - open a configuration file * @inode: inode being opened * @file: file handle attached * * Called when the configuration device is opened. Does the needed * set up on the handle and then returns * * Bugs: This needs extending to check a given adapter is present * so we can support hot plugging, and to ref count adapters. / static int aac_cfg_open(struct inode inode, struct file file) { struct aac_dev aac; unsigned minor_number = iminor(inode); int err = -ENODEV; mutex_lock(&aac_mutex); /* BKL pushdown: nothing else protects this list / list_for_each_entry(aac, &aac_devices, entry) { if (aac->id == minor_number) { file->private_data = aac; err = 0; break; } } mutex_unlock(&aac_mutex); return err; } /* * aac_cfg_ioctl - AAC configuration request * @inode: inode of device * @file: file handle * @cmd: ioctl command code * @arg: argument * * Handles a configuration ioctl. Currently this involves wrapping it * up and feeding it into the nasty windowsalike glue layer. * * Bugs: Needs locking against parallel ioctls lower down * Bugs: Needs to handle hot plugging / static long aac_cfg_ioctl(struct file file, unsigned int cmd, unsigned long arg) { int ret; if (!capable(CAP_SYS_RAWIO)) return -EPERM; mutex_lock(&aac_mutex); ret = aac_do_ioctl(file->private_data, cmd, (void __user )arg); mutex_unlock(&aac_mutex); return ret; } #ifdef CONFIG_COMPAT static long aac_compat_do_ioctl(struct aac_dev dev, unsigned cmd, unsigned long arg) { long ret; mutex_lock(&aac_mutex); switch (cmd) { case FSACTL_MINIPORT_REV_CHECK: case FSACTL_SENDFIB: case FSACTL_OPEN_GET_ADAPTER_FIB: case FSACTL_CLOSE_GET_ADAPTER_FIB: case FSACTL_SEND_RAW_SRB: case FSACTL_GET_PCI_INFO: case FSACTL_QUERY_DISK: case FSACTL_DELETE_DISK: case FSACTL_FORCE_DELETE_DISK: case FSACTL_GET_CONTAINERS: case FSACTL_SEND_LARGE_FIB: ret = aac_do_ioctl(dev, cmd, (void __user )arg); break; case FSACTL_GET_NEXT_ADAPTER_FIB: { struct fib_ioctl __user f; f = compat_alloc_user_space(sizeof(f)); ret = 0; if (clear_user(f, sizeof(f))) ret = -EFAULT; if (copy_in_user(f, (void __user )arg, sizeof(struct fib_ioctl) - sizeof(u32))) ret = -EFAULT; if (!ret) ret = aac_do_ioctl(dev, cmd, f); break; } default: ret = -ENOIOCTLCMD; break; } mutex_unlock(&aac_mutex); return ret; } static int aac_compat_ioctl(struct scsi_device sdev, int cmd, void __user arg) { struct aac_dev dev = (struct aac_dev )sdev->host->hostdata; return aac_compat_do_ioctl(dev, cmd, (unsigned long)arg); } static long aac_compat_cfg_ioctl(struct file file, unsigned cmd, unsigned long arg) { if (!capable(CAP_SYS_RAWIO)) return -EPERM; return aac_compat_do_ioctl(file->private_data, cmd, arg); } #endif static ssize_t aac_show_model(struct device device, struct device_attribute attr, char buf) { struct aac_dev dev = (struct aac_dev)class_to_shost(device)->hostdata; int len; if (dev->supplement_adapter_info.AdapterTypeText[0]) { char cp = dev->supplement_adapter_info.AdapterTypeText; while (cp && cp != ' ') ++cp; while (cp == ' ') ++cp; len = snprintf(buf, PAGE_SIZE, "%s\n", cp); } else len = snprintf(buf, PAGE_SIZE, "%s\n", aac_drivers[dev->cardtype].model); return len; } static ssize_t aac_show_vendor(struct device device, struct device_attribute attr, char buf) { struct aac_dev dev = (struct aac_dev)class_to_shost(device)->hostdata; int len; if (dev->supplement_adapter_info.AdapterTypeText[0]) { char * cp = dev->supplement_adapter_info.AdapterTypeText; while (cp && cp != ' ') ++cp; len = snprintf(buf, PAGE_SIZE, "%.s\n", (int)(cp - (char )dev->supplement_adapter_info.AdapterTypeText), dev->supplement_adapter_info.AdapterTypeText); } else len = snprintf(buf, PAGE_SIZE, "%s\n", aac_drivers[dev->cardtype].vname); return len; } static ssize_t aac_show_flags(struct device cdev, struct device_attribute attr, char buf) { int len = 0; struct aac_dev dev = (struct aac_dev)class_to_shost(cdev)->hostdata; if (nblank(dprintk(x))) len = snprintf(buf, PAGE_SIZE, "dprintk\n"); #ifdef AAC_DETAILED_STATUS_INFO len += snprintf(buf + len, PAGE_SIZE - len, "AAC_DETAILED_STATUS_INFO\n"); #endif if (dev->raw_io_interface && dev->raw_io_64) len += snprintf(buf + len, PAGE_SIZE - len, "SAI_READ_CAPACITY_16\n"); if (dev->jbod) len += snprintf(buf + len, PAGE_SIZE - len, "SUPPORTED_JBOD\n"); if (dev->supplement_adapter_info.SupportedOptions2 & AAC_OPTION_POWER_MANAGEMENT) len += snprintf(buf + len, PAGE_SIZE - len, "SUPPORTED_POWER_MANAGEMENT\n"); if (dev->msi) len += snprintf(buf + len, PAGE_SIZE - len, "PCI_HAS_MSI\n"); return len; } static ssize_t aac_show_kernel_version(struct device device, struct device_attribute attr, char buf) { struct aac_dev dev = (struct aac_dev)class_to_shost(device)->hostdata; int len, tmp; tmp = le32_to_cpu(dev->adapter_info.kernelrev); len = snprintf(buf, PAGE_SIZE, "%d.%d-%d[%d]\n", tmp >> 24, (tmp >> 16) & 0xff, tmp & 0xff, le32_to_cpu(dev->adapter_info.kernelbuild)); return len; } static ssize_t aac_show_monitor_version(struct device device, struct device_attribute attr, char buf) { struct aac_dev dev = (struct aac_dev)class_to_shost(device)->hostdata; int len, tmp; tmp = le32_to_cpu(dev->adapter_info.monitorrev); len = snprintf(buf, PAGE_SIZE, "%d.%d-%d[%d]\n", tmp >> 24, (tmp >> 16) & 0xff, tmp & 0xff, le32_to_cpu(dev->adapter_info.monitorbuild)); return len; } static ssize_t aac_show_bios_version(struct device device, struct device_attribute attr, char buf) { struct aac_dev dev = (struct aac_dev)class_to_shost(device)->hostdata; int len, tmp; tmp = le32_to_cpu(dev->adapter_info.biosrev); len = snprintf(buf, PAGE_SIZE, "%d.%d-%d[%d]\n", tmp >> 24, (tmp >> 16) & 0xff, tmp & 0xff, le32_to_cpu(dev->adapter_info.biosbuild)); return len; } static ssize_t aac_show_serial_number(struct device device, struct device_attribute attr, char buf) { struct aac_dev dev = (struct aac_dev)class_to_shost(device)->hostdata; int len = 0; if (le32_to_cpu(dev->adapter_info.serial[0]) != 0xBAD0) len = snprintf(buf, 16, "%06X\n", le32_to_cpu(dev->adapter_info.serial[0])); if (len && !memcmp(&dev->supplement_adapter_info.MfgPcbaSerialNo[ sizeof(dev->supplement_adapter_info.MfgPcbaSerialNo)-len], buf, len-1)) len = snprintf(buf, 16, "%.s\n", (int)sizeof(dev->supplement_adapter_info.MfgPcbaSerialNo), dev->supplement_adapter_info.MfgPcbaSerialNo); return min(len, 16); } static ssize_t aac_show_max_channel(struct device device, struct device_attribute attr, char buf) { return snprintf(buf, PAGE_SIZE, "%d\n", class_to_shost(device)->max_channel); } static ssize_t aac_show_max_id(struct device device, struct device_attribute attr, char buf) { return snprintf(buf, PAGE_SIZE, "%d\n", class_to_shost(device)->max_id); } static ssize_t aac_store_reset_adapter(struct device device, struct device_attribute attr, const char buf, size_t count) { int retval = -EACCES; if (!capable(CAP_SYS_ADMIN)) return retval; retval = aac_reset_adapter((struct aac_dev)class_to_shost(device)->hostdata, buf[0] == '!'); if (retval >= 0) retval = count; return retval; } static ssize_t aac_show_reset_adapter(struct device device, struct device_attribute attr, char buf) { struct aac_dev dev = (struct aac_dev)class_to_shost(device)->hostdata; int len, tmp; tmp = aac_adapter_check_health(dev); if ((tmp == 0) && dev->in_reset) tmp = -EBUSY; len = snprintf(buf, PAGE_SIZE, "0x%x\n", tmp); return len; } static struct device_attribute aac_model = { .attr = { .name = "model", .mode = S_IRUGO, }, .show = aac_show_model, }; static struct device_attribute aac_vendor = { .attr = { .name = "vendor", .mode = S_IRUGO, }, .show = aac_show_vendor, }; static struct device_attribute aac_flags = { .attr = { .name = "flags", .mode = S_IRUGO, }, .show = aac_show_flags, }; static struct device_attribute aac_kernel_version = { .attr = { .name = "hba_kernel_version", .mode = S_IRUGO, }, .show = aac_show_kernel_version, }; static struct device_attribute aac_monitor_version = { .attr = { .name = "hba_monitor_version", .mode = S_IRUGO, }, .show = aac_show_monitor_version, }; static struct device_attribute aac_bios_version = { .attr = { .name = "hba_bios_version", .mode = S_IRUGO, }, .show = aac_show_bios_version, }; static struct device_attribute aac_serial_number = { .attr = { .name = "serial_number", .mode = S_IRUGO, }, .show = aac_show_serial_number, }; static struct device_attribute aac_max_channel = { .attr = { .name = "max_channel", .mode = S_IRUGO, }, .show = aac_show_max_channel, }; static struct device_attribute aac_max_id = { .attr = { .name = "max_id", .mode = S_IRUGO, }, .show = aac_show_max_id, }; static struct device_attribute aac_reset = { .attr = { .name = "reset_host", .mode = S_IWUSR\|S_IRUGO, }, .store = aac_store_reset_adapter, .show = aac_show_reset_adapter, }; static struct device_attribute aac_attrs[] = { &aac_model, &aac_vendor, &aac_flags, &aac_kernel_version, &aac_monitor_version, &aac_bios_version, &aac_serial_number, &aac_max_channel, &aac_max_id, &aac_reset, NULL }; ssize_t aac_get_serial_number(struct device device, char buf) { return aac_show_serial_number(device, &aac_serial_number, buf); } static const struct file_operations aac_cfg_fops = { .owner = THIS_MODULE, .unlocked_ioctl = aac_cfg_ioctl, #ifdef CONFIG_COMPAT .compat_ioctl = aac_compat_cfg_ioctl, #endif .open = aac_cfg_open, .llseek = noop_llseek, }; static struct scsi_host_template aac_driver_template = { .module = THIS_MODULE, .name = "AAC", .proc_name = AAC_DRIVERNAME, .info = aac_info, .ioctl = aac_ioctl, #ifdef CONFIG_COMPAT .compat_ioctl = aac_compat_ioctl, #endif .queuecommand = aac_queuecommand, .bios_param = aac_biosparm, .shost_attrs = aac_attrs, .slave_configure = aac_slave_configure, .change_queue_depth = aac_change_queue_depth, .sdev_attrs = aac_dev_attrs, .eh_abort_handler = aac_eh_abort, .eh_host_reset_handler = aac_eh_reset, .can_queue = AAC_NUM_IO_FIB, .this_id = MAXIMUM_NUM_CONTAINERS, .sg_tablesize = 16, .max_sectors = 128, #if (AAC_NUM_IO_FIB > 256) .cmd_per_lun = 256, #else .cmd_per_lun = AAC_NUM_IO_FIB, #endif .use_clustering = ENABLE_CLUSTERING, .emulated = 1, }; static void __aac_shutdown(struct aac_dev * aac) { if (aac->aif_thread) { int i; /* Clear out events first / for (i = 0; i < (aac->scsi_host_ptr->can_queue + AAC_NUM_MGT_FIB); i++) { struct fib fib = &aac->fibs[i]; if (!(fib->hw_fib_va->header.XferState & cpu_to_le32(NoResponseExpected \| Async)) && (fib->hw_fib_va->header.XferState & cpu_to_le32(ResponseExpected))) up(&fib->event_wait); } kthread_stop(aac->thread); } aac_send_shutdown(aac); aac_adapter_disable_int(aac); free_irq(aac->pdev->irq, aac); if (aac->msi) pci_disable_msi(aac->pdev); } static int aac_probe_one(struct pci_dev pdev, const struct pci_device_id id) { unsigned index = id->driver_data; struct Scsi_Host shost; struct aac_dev aac; struct list_head insert = &aac_devices; int error = -ENODEV; int unique_id = 0; u64 dmamask; extern int aac_sync_mode; list_for_each_entry(aac, &aac_devices, entry) { if (aac->id > unique_id) break; insert = &aac->entry; unique_id++; } pci_disable_link_state(pdev, PCIE_LINK_STATE_L0S \| PCIE_LINK_STATE_L1 \| PCIE_LINK_STATE_CLKPM); error = pci_enable_device(pdev); if (error) goto out; error = -ENODEV; / * If the quirk31 bit is set, the adapter needs adapter * to driver communication memory to be allocated below 2gig / if (aac_drivers[index].quirks & AAC_QUIRK_31BIT) dmamask = DMA_BIT_MASK(31); else dmamask = DMA_BIT_MASK(32); if (pci_set_dma_mask(pdev, dmamask) \|\| pci_set_consistent_dma_mask(pdev, dmamask)) goto out_disable_pdev; pci_set_master(pdev); shost = scsi_host_alloc(&aac_driver_template, sizeof(struct aac_dev)); if (!shost) goto out_disable_pdev; shost->irq = pdev->irq; shost->unique_id = unique_id; shost->max_cmd_len = 16; aac = (struct aac_dev )shost->hostdata; aac->base_start = pci_resource_start(pdev, 0); aac->scsi_host_ptr = shost; aac->pdev = pdev; aac->name = aac_driver_template.name; aac->id = shost->unique_id; aac->cardtype = index; INIT_LIST_HEAD(&aac->entry); aac->fibs = kzalloc(sizeof(struct fib) * (shost->can_queue + AAC_NUM_MGT_FIB), GFP_KERNEL); if (!aac->fibs) goto out_free_host; spin_lock_init(&aac->fib_lock); /* * Map in the registers from the adapter. / aac->base_size = AAC_MIN_FOOTPRINT_SIZE; if ((aac_drivers[index].init)(aac)) goto out_unmap; if (aac->sync_mode) { if (aac_sync_mode) printk(KERN_INFO "%s%d: Sync. mode enforced " "by driver parameter. This will cause " "a significant performance decrease!\n", aac->name, aac->id); else printk(KERN_INFO "%s%d: Async. mode not supported " "by current driver, sync. mode enforced." "\nPlease update driver to get full performance.\n", aac->name, aac->id); } /* * Start any kernel threads needed / aac->thread = kthread_run(aac_command_thread, aac, AAC_DRIVERNAME); if (IS_ERR(aac->thread)) { printk(KERN_ERR "aacraid: Unable to create command thread.\n"); error = PTR_ERR(aac->thread); aac->thread = NULL; goto out_deinit; } / * If we had set a smaller DMA mask earlier, set it to 4gig * now since the adapter can dma data to at least a 4gig * address space. / if (aac_drivers[index].quirks & AAC_QUIRK_31BIT) if (pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) goto out_deinit; aac->maximum_num_channels = aac_drivers[index].channels; error = aac_get_adapter_info(aac); if (error < 0) goto out_deinit; / * Lets override negotiations and drop the maximum SG limit to 34 / if ((aac_drivers[index].quirks & AAC_QUIRK_34SG) && (shost->sg_tablesize > 34)) { shost->sg_tablesize = 34; shost->max_sectors = (shost->sg_tablesize 8) + 112; } if ((aac_drivers[index].quirks & AAC_QUIRK_17SG) && (shost->sg_tablesize > 17)) { shost->sg_tablesize = 17; shost->max_sectors = (shost->sg_tablesize * 8) + 112; } error = pci_set_dma_max_seg_size(pdev, (aac->adapter_info.options & AAC_OPT_NEW_COMM) ? (shost->max_sectors << 9) : 65536); if (error) goto out_deinit; /* * Firmware printf works only with older firmware. / if (aac_drivers[index].quirks & AAC_QUIRK_34SG) aac->printf_enabled = 1; else aac->printf_enabled = 0; / * max channel will be the physical channels plus 1 virtual channel * all containers are on the virtual channel 0 (CONTAINER_CHANNEL) * physical channels are address by their actual physical number+1 / if (aac->nondasd_support \|\| expose_physicals \|\| aac->jbod) shost->max_channel = aac->maximum_num_channels; else shost->max_channel = 0; aac_get_config_status(aac, 0); aac_get_containers(aac); list_add(&aac->entry, insert); shost->max_id = aac->maximum_num_containers; if (shost->max_id < aac->maximum_num_physicals) shost->max_id = aac->maximum_num_physicals; if (shost->max_id < MAXIMUM_NUM_CONTAINERS) shost->max_id = MAXIMUM_NUM_CONTAINERS; else shost->this_id = shost->max_id; / * dmb - we may need to move the setting of these parms somewhere else once * we get a fib that can report the actual numbers / shost->max_lun = AAC_MAX_LUN; pci_set_drvdata(pdev, shost); error = scsi_add_host(shost, &pdev->dev); if (error) goto out_deinit; scsi_scan_host(shost); return 0; out_deinit: __aac_shutdown(aac); out_unmap: aac_fib_map_free(aac); if (aac->comm_addr) pci_free_consistent(aac->pdev, aac->comm_size, aac->comm_addr, aac->comm_phys); kfree(aac->queues); aac_adapter_ioremap(aac, 0); kfree(aac->fibs); kfree(aac->fsa_dev); out_free_host: scsi_host_put(shost); out_disable_pdev: pci_disable_device(pdev); out: return error; } static void aac_shutdown(struct pci_dev dev) { struct Scsi_Host shost = pci_get_drvdata(dev); scsi_block_requests(shost); __aac_shutdown((struct aac_dev )shost->hostdata); } static void aac_remove_one(struct pci_dev pdev) { struct Scsi_Host shost = pci_get_drvdata(pdev); struct aac_dev aac = (struct aac_dev )shost->hostdata; scsi_remove_host(shost); __aac_shutdown(aac); aac_fib_map_free(aac); pci_free_consistent(aac->pdev, aac->comm_size, aac->comm_addr, aac->comm_phys); kfree(aac->queues); aac_adapter_ioremap(aac, 0); kfree(aac->fibs); kfree(aac->fsa_dev); list_del(&aac->entry); scsi_host_put(shost); pci_disable_device(pdev); if (list_empty(&aac_devices)) { unregister_chrdev(aac_cfg_major, "aac"); aac_cfg_major = -1; } } static struct pci_driver aac_pci_driver = { .name = AAC_DRIVERNAME, .id_table = aac_pci_tbl, .probe = aac_probe_one, .remove = aac_remove_one, .shutdown = aac_shutdown, }; static int __init aac_init(void) { int error; printk(KERN_INFO "Adaptec %s driver %s\n", AAC_DRIVERNAME, aac_driver_version); error = pci_register_driver(&aac_pci_driver); if (error < 0) return error; aac_cfg_major = register_chrdev( 0, "aac", &aac_cfg_fops); if (aac_cfg_major < 0) { printk(KERN_WARNING "aacraid: unable to register \"aac\" device.\n"); } return 0; } static void __exit aac_exit(void) { if (aac_cfg_major > -1) unregister_chrdev(aac_cfg_major, "aac"); pci_unregister_driver(&aac_pci_driver); } module_init(aac_init); module_exit(aac_exit);	./CrossVul/dataset_final_sorted/CWE-264/c/bad_5801_0
crossvul-cpp_data_good_2244_0	/* * linux/fs/namespace.c * * (C) Copyright Al Viro 2000, 2001 * Released under GPL v2. * * Based on code from fs/super.c, copyright Linus Torvalds and others. * Heavily rewritten. / #include <linux/syscalls.h> #include <linux/export.h> #include <linux/capability.h> #include <linux/mnt_namespace.h> #include <linux/user_namespace.h> #include <linux/namei.h> #include <linux/security.h> #include <linux/idr.h> #include <linux/acct.h> / acct_auto_close_mnt / #include <linux/init.h> / init_rootfs / #include <linux/fs_struct.h> / get_fs_root et.al. / #include <linux/fsnotify.h> / fsnotify_vfsmount_delete / #include <linux/uaccess.h> #include <linux/proc_ns.h> #include <linux/magic.h> #include <linux/bootmem.h> #include "pnode.h" #include "internal.h" static unsigned int m_hash_mask __read_mostly; static unsigned int m_hash_shift __read_mostly; static unsigned int mp_hash_mask __read_mostly; static unsigned int mp_hash_shift __read_mostly; static __initdata unsigned long mhash_entries; static int __init set_mhash_entries(char str) { if (!str) return 0; mhash_entries = simple_strtoul(str, &str, 0); return 1; } __setup("mhash_entries=", set_mhash_entries); static __initdata unsigned long mphash_entries; static int __init set_mphash_entries(char str) { if (!str) return 0; mphash_entries = simple_strtoul(str, &str, 0); return 1; } __setup("mphash_entries=", set_mphash_entries); static u64 event; static DEFINE_IDA(mnt_id_ida); static DEFINE_IDA(mnt_group_ida); static DEFINE_SPINLOCK(mnt_id_lock); static int mnt_id_start = 0; static int mnt_group_start = 1; static struct hlist_head mount_hashtable __read_mostly; static struct hlist_head mountpoint_hashtable __read_mostly; static struct kmem_cache mnt_cache __read_mostly; static DECLARE_RWSEM(namespace_sem); /* /sys/fs / struct kobject fs_kobj; EXPORT_SYMBOL_GPL(fs_kobj); /* * vfsmount lock may be taken for read to prevent changes to the * vfsmount hash, ie. during mountpoint lookups or walking back * up the tree. * * It should be taken for write in all cases where the vfsmount * tree or hash is modified or when a vfsmount structure is modified. / __cacheline_aligned_in_smp DEFINE_SEQLOCK(mount_lock); static inline struct hlist_head m_hash(struct vfsmount mnt, struct dentry dentry) { unsigned long tmp = ((unsigned long)mnt / L1_CACHE_BYTES); tmp += ((unsigned long)dentry / L1_CACHE_BYTES); tmp = tmp + (tmp >> m_hash_shift); return &mount_hashtable[tmp & m_hash_mask]; } static inline struct hlist_head mp_hash(struct dentry dentry) { unsigned long tmp = ((unsigned long)dentry / L1_CACHE_BYTES); tmp = tmp + (tmp >> mp_hash_shift); return &mountpoint_hashtable[tmp & mp_hash_mask]; } /* * allocation is serialized by namespace_sem, but we need the spinlock to * serialize with freeing. / static int mnt_alloc_id(struct mount mnt) { int res; retry: ida_pre_get(&mnt_id_ida, GFP_KERNEL); spin_lock(&mnt_id_lock); res = ida_get_new_above(&mnt_id_ida, mnt_id_start, &mnt->mnt_id); if (!res) mnt_id_start = mnt->mnt_id + 1; spin_unlock(&mnt_id_lock); if (res == -EAGAIN) goto retry; return res; } static void mnt_free_id(struct mount mnt) { int id = mnt->mnt_id; spin_lock(&mnt_id_lock); ida_remove(&mnt_id_ida, id); if (mnt_id_start > id) mnt_id_start = id; spin_unlock(&mnt_id_lock); } / * Allocate a new peer group ID * * mnt_group_ida is protected by namespace_sem / static int mnt_alloc_group_id(struct mount mnt) { int res; if (!ida_pre_get(&mnt_group_ida, GFP_KERNEL)) return -ENOMEM; res = ida_get_new_above(&mnt_group_ida, mnt_group_start, &mnt->mnt_group_id); if (!res) mnt_group_start = mnt->mnt_group_id + 1; return res; } /* * Release a peer group ID / void mnt_release_group_id(struct mount mnt) { int id = mnt->mnt_group_id; ida_remove(&mnt_group_ida, id); if (mnt_group_start > id) mnt_group_start = id; mnt->mnt_group_id = 0; } /* * vfsmount lock must be held for read / static inline void mnt_add_count(struct mount mnt, int n) { #ifdef CONFIG_SMP this_cpu_add(mnt->mnt_pcp->mnt_count, n); #else preempt_disable(); mnt->mnt_count += n; preempt_enable(); #endif } /* * vfsmount lock must be held for write / unsigned int mnt_get_count(struct mount mnt) { #ifdef CONFIG_SMP unsigned int count = 0; int cpu; for_each_possible_cpu(cpu) { count += per_cpu_ptr(mnt->mnt_pcp, cpu)->mnt_count; } return count; #else return mnt->mnt_count; #endif } static struct mount alloc_vfsmnt(const char name) { struct mount mnt = kmem_cache_zalloc(mnt_cache, GFP_KERNEL); if (mnt) { int err; err = mnt_alloc_id(mnt); if (err) goto out_free_cache; if (name) { mnt->mnt_devname = kstrdup(name, GFP_KERNEL); if (!mnt->mnt_devname) goto out_free_id; } #ifdef CONFIG_SMP mnt->mnt_pcp = alloc_percpu(struct mnt_pcp); if (!mnt->mnt_pcp) goto out_free_devname; this_cpu_add(mnt->mnt_pcp->mnt_count, 1); #else mnt->mnt_count = 1; mnt->mnt_writers = 0; #endif INIT_HLIST_NODE(&mnt->mnt_hash); INIT_LIST_HEAD(&mnt->mnt_child); INIT_LIST_HEAD(&mnt->mnt_mounts); INIT_LIST_HEAD(&mnt->mnt_list); INIT_LIST_HEAD(&mnt->mnt_expire); INIT_LIST_HEAD(&mnt->mnt_share); INIT_LIST_HEAD(&mnt->mnt_slave_list); INIT_LIST_HEAD(&mnt->mnt_slave); #ifdef CONFIG_FSNOTIFY INIT_HLIST_HEAD(&mnt->mnt_fsnotify_marks); #endif } return mnt; #ifdef CONFIG_SMP out_free_devname: kfree(mnt->mnt_devname); #endif out_free_id: mnt_free_id(mnt); out_free_cache: kmem_cache_free(mnt_cache, mnt); return NULL; } / * Most r/o checks on a fs are for operations that take * discrete amounts of time, like a write() or unlink(). * We must keep track of when those operations start * (for permission checks) and when they end, so that * we can determine when writes are able to occur to * a filesystem. / / * __mnt_is_readonly: check whether a mount is read-only * @mnt: the mount to check for its write status * * This shouldn't be used directly ouside of the VFS. * It does not guarantee that the filesystem will stay * r/w, just that it is right now. This can not and * should not be used in place of IS_RDONLY(inode). * mnt_want/drop_write() will _keep_ the filesystem * r/w. / int __mnt_is_readonly(struct vfsmount mnt) { if (mnt->mnt_flags & MNT_READONLY) return 1; if (mnt->mnt_sb->s_flags & MS_RDONLY) return 1; return 0; } EXPORT_SYMBOL_GPL(__mnt_is_readonly); static inline void mnt_inc_writers(struct mount mnt) { #ifdef CONFIG_SMP this_cpu_inc(mnt->mnt_pcp->mnt_writers); #else mnt->mnt_writers++; #endif } static inline void mnt_dec_writers(struct mount mnt) { #ifdef CONFIG_SMP this_cpu_dec(mnt->mnt_pcp->mnt_writers); #else mnt->mnt_writers--; #endif } static unsigned int mnt_get_writers(struct mount mnt) { #ifdef CONFIG_SMP unsigned int count = 0; int cpu; for_each_possible_cpu(cpu) { count += per_cpu_ptr(mnt->mnt_pcp, cpu)->mnt_writers; } return count; #else return mnt->mnt_writers; #endif } static int mnt_is_readonly(struct vfsmount mnt) { if (mnt->mnt_sb->s_readonly_remount) return 1; /* Order wrt setting s_flags/s_readonly_remount in do_remount() / smp_rmb(); return __mnt_is_readonly(mnt); } / * Most r/o & frozen checks on a fs are for operations that take discrete * amounts of time, like a write() or unlink(). We must keep track of when * those operations start (for permission checks) and when they end, so that we * can determine when writes are able to occur to a filesystem. / /* * __mnt_want_write - get write access to a mount without freeze protection * @m: the mount on which to take a write * * This tells the low-level filesystem that a write is about to be performed to * it, and makes sure that writes are allowed (mnt it read-write) before * returning success. This operation does not protect against filesystem being * frozen. When the write operation is finished, __mnt_drop_write() must be * called. This is effectively a refcount. / int __mnt_want_write(struct vfsmount m) { struct mount mnt = real_mount(m); int ret = 0; preempt_disable(); mnt_inc_writers(mnt); / * The store to mnt_inc_writers must be visible before we pass * MNT_WRITE_HOLD loop below, so that the slowpath can see our * incremented count after it has set MNT_WRITE_HOLD. / smp_mb(); while (ACCESS_ONCE(mnt->mnt.mnt_flags) & MNT_WRITE_HOLD) cpu_relax(); / * After the slowpath clears MNT_WRITE_HOLD, mnt_is_readonly will * be set to match its requirements. So we must not load that until * MNT_WRITE_HOLD is cleared. / smp_rmb(); if (mnt_is_readonly(m)) { mnt_dec_writers(mnt); ret = -EROFS; } preempt_enable(); return ret; } /* * mnt_want_write - get write access to a mount * @m: the mount on which to take a write * * This tells the low-level filesystem that a write is about to be performed to * it, and makes sure that writes are allowed (mount is read-write, filesystem * is not frozen) before returning success. When the write operation is * finished, mnt_drop_write() must be called. This is effectively a refcount. / int mnt_want_write(struct vfsmount m) { int ret; sb_start_write(m->mnt_sb); ret = __mnt_want_write(m); if (ret) sb_end_write(m->mnt_sb); return ret; } EXPORT_SYMBOL_GPL(mnt_want_write); /** * mnt_clone_write - get write access to a mount * @mnt: the mount on which to take a write * * This is effectively like mnt_want_write, except * it must only be used to take an extra write reference * on a mountpoint that we already know has a write reference * on it. This allows some optimisation. * * After finished, mnt_drop_write must be called as usual to * drop the reference. / int mnt_clone_write(struct vfsmount mnt) { /* superblock may be r/o / if (__mnt_is_readonly(mnt)) return -EROFS; preempt_disable(); mnt_inc_writers(real_mount(mnt)); preempt_enable(); return 0; } EXPORT_SYMBOL_GPL(mnt_clone_write); /* * __mnt_want_write_file - get write access to a file's mount * @file: the file who's mount on which to take a write * * This is like __mnt_want_write, but it takes a file and can * do some optimisations if the file is open for write already / int __mnt_want_write_file(struct file file) { if (!(file->f_mode & FMODE_WRITER)) return __mnt_want_write(file->f_path.mnt); else return mnt_clone_write(file->f_path.mnt); } /** * mnt_want_write_file - get write access to a file's mount * @file: the file who's mount on which to take a write * * This is like mnt_want_write, but it takes a file and can * do some optimisations if the file is open for write already / int mnt_want_write_file(struct file file) { int ret; sb_start_write(file->f_path.mnt->mnt_sb); ret = __mnt_want_write_file(file); if (ret) sb_end_write(file->f_path.mnt->mnt_sb); return ret; } EXPORT_SYMBOL_GPL(mnt_want_write_file); /** * __mnt_drop_write - give up write access to a mount * @mnt: the mount on which to give up write access * * Tells the low-level filesystem that we are done * performing writes to it. Must be matched with * __mnt_want_write() call above. / void __mnt_drop_write(struct vfsmount mnt) { preempt_disable(); mnt_dec_writers(real_mount(mnt)); preempt_enable(); } /** * mnt_drop_write - give up write access to a mount * @mnt: the mount on which to give up write access * * Tells the low-level filesystem that we are done performing writes to it and * also allows filesystem to be frozen again. Must be matched with * mnt_want_write() call above. / void mnt_drop_write(struct vfsmount mnt) { __mnt_drop_write(mnt); sb_end_write(mnt->mnt_sb); } EXPORT_SYMBOL_GPL(mnt_drop_write); void __mnt_drop_write_file(struct file file) { __mnt_drop_write(file->f_path.mnt); } void mnt_drop_write_file(struct file file) { mnt_drop_write(file->f_path.mnt); } EXPORT_SYMBOL(mnt_drop_write_file); static int mnt_make_readonly(struct mount mnt) { int ret = 0; lock_mount_hash(); mnt->mnt.mnt_flags \|= MNT_WRITE_HOLD; / * After storing MNT_WRITE_HOLD, we'll read the counters. This store * should be visible before we do. / smp_mb(); / * With writers on hold, if this value is zero, then there are * definitely no active writers (although held writers may subsequently * increment the count, they'll have to wait, and decrement it after * seeing MNT_READONLY). * * It is OK to have counter incremented on one CPU and decremented on * another: the sum will add up correctly. The danger would be when we * sum up each counter, if we read a counter before it is incremented, * but then read another CPU's count which it has been subsequently * decremented from -- we would see more decrements than we should. * MNT_WRITE_HOLD protects against this scenario, because * mnt_want_write first increments count, then smp_mb, then spins on * MNT_WRITE_HOLD, so it can't be decremented by another CPU while * we're counting up here. / if (mnt_get_writers(mnt) > 0) ret = -EBUSY; else mnt->mnt.mnt_flags \|= MNT_READONLY; / * MNT_READONLY must become visible before ~MNT_WRITE_HOLD, so writers * that become unheld will see MNT_READONLY. / smp_wmb(); mnt->mnt.mnt_flags &= ~MNT_WRITE_HOLD; unlock_mount_hash(); return ret; } static void __mnt_unmake_readonly(struct mount mnt) { lock_mount_hash(); mnt->mnt.mnt_flags &= ~MNT_READONLY; unlock_mount_hash(); } int sb_prepare_remount_readonly(struct super_block sb) { struct mount mnt; int err = 0; /* Racy optimization. Recheck the counter under MNT_WRITE_HOLD / if (atomic_long_read(&sb->s_remove_count)) return -EBUSY; lock_mount_hash(); list_for_each_entry(mnt, &sb->s_mounts, mnt_instance) { if (!(mnt->mnt.mnt_flags & MNT_READONLY)) { mnt->mnt.mnt_flags \|= MNT_WRITE_HOLD; smp_mb(); if (mnt_get_writers(mnt) > 0) { err = -EBUSY; break; } } } if (!err && atomic_long_read(&sb->s_remove_count)) err = -EBUSY; if (!err) { sb->s_readonly_remount = 1; smp_wmb(); } list_for_each_entry(mnt, &sb->s_mounts, mnt_instance) { if (mnt->mnt.mnt_flags & MNT_WRITE_HOLD) mnt->mnt.mnt_flags &= ~MNT_WRITE_HOLD; } unlock_mount_hash(); return err; } static void free_vfsmnt(struct mount mnt) { kfree(mnt->mnt_devname); #ifdef CONFIG_SMP free_percpu(mnt->mnt_pcp); #endif kmem_cache_free(mnt_cache, mnt); } static void delayed_free_vfsmnt(struct rcu_head head) { free_vfsmnt(container_of(head, struct mount, mnt_rcu)); } / call under rcu_read_lock / bool legitimize_mnt(struct vfsmount bastard, unsigned seq) { struct mount mnt; if (read_seqretry(&mount_lock, seq)) return false; if (bastard == NULL) return true; mnt = real_mount(bastard); mnt_add_count(mnt, 1); if (likely(!read_seqretry(&mount_lock, seq))) return true; if (bastard->mnt_flags & MNT_SYNC_UMOUNT) { mnt_add_count(mnt, -1); return false; } rcu_read_unlock(); mntput(bastard); rcu_read_lock(); return false; } / * find the first mount at @dentry on vfsmount @mnt. * call under rcu_read_lock() / struct mount __lookup_mnt(struct vfsmount mnt, struct dentry dentry) { struct hlist_head head = m_hash(mnt, dentry); struct mount p; hlist_for_each_entry_rcu(p, head, mnt_hash) if (&p->mnt_parent->mnt == mnt && p->mnt_mountpoint == dentry) return p; return NULL; } /* * find the last mount at @dentry on vfsmount @mnt. * mount_lock must be held. / struct mount __lookup_mnt_last(struct vfsmount mnt, struct dentry dentry) { struct mount p, res; res = p = __lookup_mnt(mnt, dentry); if (!p) goto out; hlist_for_each_entry_continue(p, mnt_hash) { if (&p->mnt_parent->mnt != mnt \|\| p->mnt_mountpoint != dentry) break; res = p; } out: return res; } /* * lookup_mnt - Return the first child mount mounted at path * * "First" means first mounted chronologically. If you create the * following mounts: * * mount /dev/sda1 /mnt * mount /dev/sda2 /mnt * mount /dev/sda3 /mnt * * Then lookup_mnt() on the base /mnt dentry in the root mount will * return successively the root dentry and vfsmount of /dev/sda1, then * /dev/sda2, then /dev/sda3, then NULL. * * lookup_mnt takes a reference to the found vfsmount. / struct vfsmount lookup_mnt(struct path path) { struct mount child_mnt; struct vfsmount m; unsigned seq; rcu_read_lock(); do { seq = read_seqbegin(&mount_lock); child_mnt = __lookup_mnt(path->mnt, path->dentry); m = child_mnt ? &child_mnt->mnt : NULL; } while (!legitimize_mnt(m, seq)); rcu_read_unlock(); return m; } static struct mountpoint new_mountpoint(struct dentry dentry) { struct hlist_head chain = mp_hash(dentry); struct mountpoint mp; int ret; hlist_for_each_entry(mp, chain, m_hash) { if (mp->m_dentry == dentry) { / might be worth a WARN_ON() / if (d_unlinked(dentry)) return ERR_PTR(-ENOENT); mp->m_count++; return mp; } } mp = kmalloc(sizeof(struct mountpoint), GFP_KERNEL); if (!mp) return ERR_PTR(-ENOMEM); ret = d_set_mounted(dentry); if (ret) { kfree(mp); return ERR_PTR(ret); } mp->m_dentry = dentry; mp->m_count = 1; hlist_add_head(&mp->m_hash, chain); return mp; } static void put_mountpoint(struct mountpoint mp) { if (!--mp->m_count) { struct dentry dentry = mp->m_dentry; spin_lock(&dentry->d_lock); dentry->d_flags &= ~DCACHE_MOUNTED; spin_unlock(&dentry->d_lock); hlist_del(&mp->m_hash); kfree(mp); } } static inline int check_mnt(struct mount mnt) { return mnt->mnt_ns == current->nsproxy->mnt_ns; } /* * vfsmount lock must be held for write / static void touch_mnt_namespace(struct mnt_namespace ns) { if (ns) { ns->event = ++event; wake_up_interruptible(&ns->poll); } } /* * vfsmount lock must be held for write / static void __touch_mnt_namespace(struct mnt_namespace ns) { if (ns && ns->event != event) { ns->event = event; wake_up_interruptible(&ns->poll); } } /* * vfsmount lock must be held for write / static void detach_mnt(struct mount mnt, struct path old_path) { old_path->dentry = mnt->mnt_mountpoint; old_path->mnt = &mnt->mnt_parent->mnt; mnt->mnt_parent = mnt; mnt->mnt_mountpoint = mnt->mnt.mnt_root; list_del_init(&mnt->mnt_child); hlist_del_init_rcu(&mnt->mnt_hash); put_mountpoint(mnt->mnt_mp); mnt->mnt_mp = NULL; } / * vfsmount lock must be held for write / void mnt_set_mountpoint(struct mount mnt, struct mountpoint mp, struct mount child_mnt) { mp->m_count++; mnt_add_count(mnt, 1); /* essentially, that's mntget / child_mnt->mnt_mountpoint = dget(mp->m_dentry); child_mnt->mnt_parent = mnt; child_mnt->mnt_mp = mp; } / * vfsmount lock must be held for write / static void attach_mnt(struct mount mnt, struct mount parent, struct mountpoint mp) { mnt_set_mountpoint(parent, mp, mnt); hlist_add_head_rcu(&mnt->mnt_hash, m_hash(&parent->mnt, mp->m_dentry)); list_add_tail(&mnt->mnt_child, &parent->mnt_mounts); } /* * vfsmount lock must be held for write / static void commit_tree(struct mount mnt, struct mount shadows) { struct mount parent = mnt->mnt_parent; struct mount m; LIST_HEAD(head); struct mnt_namespace n = parent->mnt_ns; BUG_ON(parent == mnt); list_add_tail(&head, &mnt->mnt_list); list_for_each_entry(m, &head, mnt_list) m->mnt_ns = n; list_splice(&head, n->list.prev); if (shadows) hlist_add_after_rcu(&shadows->mnt_hash, &mnt->mnt_hash); else hlist_add_head_rcu(&mnt->mnt_hash, m_hash(&parent->mnt, mnt->mnt_mountpoint)); list_add_tail(&mnt->mnt_child, &parent->mnt_mounts); touch_mnt_namespace(n); } static struct mount next_mnt(struct mount p, struct mount root) { struct list_head next = p->mnt_mounts.next; if (next == &p->mnt_mounts) { while (1) { if (p == root) return NULL; next = p->mnt_child.next; if (next != &p->mnt_parent->mnt_mounts) break; p = p->mnt_parent; } } return list_entry(next, struct mount, mnt_child); } static struct mount skip_mnt_tree(struct mount p) { struct list_head prev = p->mnt_mounts.prev; while (prev != &p->mnt_mounts) { p = list_entry(prev, struct mount, mnt_child); prev = p->mnt_mounts.prev; } return p; } struct vfsmount vfs_kern_mount(struct file_system_type type, int flags, const char name, void data) { struct mount mnt; struct dentry root; if (!type) return ERR_PTR(-ENODEV); mnt = alloc_vfsmnt(name); if (!mnt) return ERR_PTR(-ENOMEM); if (flags & MS_KERNMOUNT) mnt->mnt.mnt_flags = MNT_INTERNAL; root = mount_fs(type, flags, name, data); if (IS_ERR(root)) { mnt_free_id(mnt); free_vfsmnt(mnt); return ERR_CAST(root); } mnt->mnt.mnt_root = root; mnt->mnt.mnt_sb = root->d_sb; mnt->mnt_mountpoint = mnt->mnt.mnt_root; mnt->mnt_parent = mnt; lock_mount_hash(); list_add_tail(&mnt->mnt_instance, &root->d_sb->s_mounts); unlock_mount_hash(); return &mnt->mnt; } EXPORT_SYMBOL_GPL(vfs_kern_mount); static struct mount clone_mnt(struct mount old, struct dentry root, int flag) { struct super_block sb = old->mnt.mnt_sb; struct mount mnt; int err; mnt = alloc_vfsmnt(old->mnt_devname); if (!mnt) return ERR_PTR(-ENOMEM); if (flag & (CL_SLAVE \| CL_PRIVATE \| CL_SHARED_TO_SLAVE)) mnt->mnt_group_id = 0; /* not a peer of original / else mnt->mnt_group_id = old->mnt_group_id; if ((flag & CL_MAKE_SHARED) && !mnt->mnt_group_id) { err = mnt_alloc_group_id(mnt); if (err) goto out_free; } mnt->mnt.mnt_flags = old->mnt.mnt_flags & ~(MNT_WRITE_HOLD\|MNT_MARKED); / Don't allow unprivileged users to change mount flags / if (flag & CL_UNPRIVILEGED) { mnt->mnt.mnt_flags \|= MNT_LOCK_ATIME; if (mnt->mnt.mnt_flags & MNT_READONLY) mnt->mnt.mnt_flags \|= MNT_LOCK_READONLY; if (mnt->mnt.mnt_flags & MNT_NODEV) mnt->mnt.mnt_flags \|= MNT_LOCK_NODEV; if (mnt->mnt.mnt_flags & MNT_NOSUID) mnt->mnt.mnt_flags \|= MNT_LOCK_NOSUID; if (mnt->mnt.mnt_flags & MNT_NOEXEC) mnt->mnt.mnt_flags \|= MNT_LOCK_NOEXEC; } / Don't allow unprivileged users to reveal what is under a mount / if ((flag & CL_UNPRIVILEGED) && list_empty(&old->mnt_expire)) mnt->mnt.mnt_flags \|= MNT_LOCKED; atomic_inc(&sb->s_active); mnt->mnt.mnt_sb = sb; mnt->mnt.mnt_root = dget(root); mnt->mnt_mountpoint = mnt->mnt.mnt_root; mnt->mnt_parent = mnt; lock_mount_hash(); list_add_tail(&mnt->mnt_instance, &sb->s_mounts); unlock_mount_hash(); if ((flag & CL_SLAVE) \|\| ((flag & CL_SHARED_TO_SLAVE) && IS_MNT_SHARED(old))) { list_add(&mnt->mnt_slave, &old->mnt_slave_list); mnt->mnt_master = old; CLEAR_MNT_SHARED(mnt); } else if (!(flag & CL_PRIVATE)) { if ((flag & CL_MAKE_SHARED) \|\| IS_MNT_SHARED(old)) list_add(&mnt->mnt_share, &old->mnt_share); if (IS_MNT_SLAVE(old)) list_add(&mnt->mnt_slave, &old->mnt_slave); mnt->mnt_master = old->mnt_master; } if (flag & CL_MAKE_SHARED) set_mnt_shared(mnt); / stick the duplicate mount on the same expiry list * as the original if that was on one / if (flag & CL_EXPIRE) { if (!list_empty(&old->mnt_expire)) list_add(&mnt->mnt_expire, &old->mnt_expire); } return mnt; out_free: mnt_free_id(mnt); free_vfsmnt(mnt); return ERR_PTR(err); } static void mntput_no_expire(struct mount mnt) { put_again: rcu_read_lock(); mnt_add_count(mnt, -1); if (likely(mnt->mnt_ns)) { /* shouldn't be the last one / rcu_read_unlock(); return; } lock_mount_hash(); if (mnt_get_count(mnt)) { rcu_read_unlock(); unlock_mount_hash(); return; } if (unlikely(mnt->mnt_pinned)) { mnt_add_count(mnt, mnt->mnt_pinned + 1); mnt->mnt_pinned = 0; rcu_read_unlock(); unlock_mount_hash(); acct_auto_close_mnt(&mnt->mnt); goto put_again; } if (unlikely(mnt->mnt.mnt_flags & MNT_DOOMED)) { rcu_read_unlock(); unlock_mount_hash(); return; } mnt->mnt.mnt_flags \|= MNT_DOOMED; rcu_read_unlock(); list_del(&mnt->mnt_instance); unlock_mount_hash(); / * This probably indicates that somebody messed * up a mnt_want/drop_write() pair. If this * happens, the filesystem was probably unable * to make r/w->r/o transitions. / / * The locking used to deal with mnt_count decrement provides barriers, * so mnt_get_writers() below is safe. / WARN_ON(mnt_get_writers(mnt)); fsnotify_vfsmount_delete(&mnt->mnt); dput(mnt->mnt.mnt_root); deactivate_super(mnt->mnt.mnt_sb); mnt_free_id(mnt); call_rcu(&mnt->mnt_rcu, delayed_free_vfsmnt); } void mntput(struct vfsmount mnt) { if (mnt) { struct mount m = real_mount(mnt); / avoid cacheline pingpong, hope gcc doesn't get "smart" / if (unlikely(m->mnt_expiry_mark)) m->mnt_expiry_mark = 0; mntput_no_expire(m); } } EXPORT_SYMBOL(mntput); struct vfsmount mntget(struct vfsmount mnt) { if (mnt) mnt_add_count(real_mount(mnt), 1); return mnt; } EXPORT_SYMBOL(mntget); void mnt_pin(struct vfsmount mnt) { lock_mount_hash(); real_mount(mnt)->mnt_pinned++; unlock_mount_hash(); } EXPORT_SYMBOL(mnt_pin); void mnt_unpin(struct vfsmount m) { struct mount mnt = real_mount(m); lock_mount_hash(); if (mnt->mnt_pinned) { mnt_add_count(mnt, 1); mnt->mnt_pinned--; } unlock_mount_hash(); } EXPORT_SYMBOL(mnt_unpin); static inline void mangle(struct seq_file m, const char s) { seq_escape(m, s, " \t\n\\"); } /* * Simple .show_options callback for filesystems which don't want to * implement more complex mount option showing. * * See also save_mount_options(). / int generic_show_options(struct seq_file m, struct dentry root) { const char options; rcu_read_lock(); options = rcu_dereference(root->d_sb->s_options); if (options != NULL && options[0]) { seq_putc(m, ','); mangle(m, options); } rcu_read_unlock(); return 0; } EXPORT_SYMBOL(generic_show_options); /* * If filesystem uses generic_show_options(), this function should be * called from the fill_super() callback. * * The .remount_fs callback usually needs to be handled in a special * way, to make sure, that previous options are not overwritten if the * remount fails. * * Also note, that if the filesystem's .remount_fs function doesn't * reset all options to their default value, but changes only newly * given options, then the displayed options will not reflect reality * any more. / void save_mount_options(struct super_block sb, char options) { BUG_ON(sb->s_options); rcu_assign_pointer(sb->s_options, kstrdup(options, GFP_KERNEL)); } EXPORT_SYMBOL(save_mount_options); void replace_mount_options(struct super_block sb, char options) { char old = sb->s_options; rcu_assign_pointer(sb->s_options, options); if (old) { synchronize_rcu(); kfree(old); } } EXPORT_SYMBOL(replace_mount_options); #ifdef CONFIG_PROC_FS /* iterator; we want it to have access to namespace_sem, thus here... / static void m_start(struct seq_file m, loff_t pos) { struct proc_mounts p = proc_mounts(m); down_read(&namespace_sem); if (p->cached_event == p->ns->event) { void v = p->cached_mount; if (pos == p->cached_index) return v; if (pos == p->cached_index + 1) { v = seq_list_next(v, &p->ns->list, &p->cached_index); return p->cached_mount = v; } } p->cached_event = p->ns->event; p->cached_mount = seq_list_start(&p->ns->list, pos); p->cached_index = pos; return p->cached_mount; } static void m_next(struct seq_file m, void v, loff_t pos) { struct proc_mounts p = proc_mounts(m); p->cached_mount = seq_list_next(v, &p->ns->list, pos); p->cached_index = pos; return p->cached_mount; } static void m_stop(struct seq_file m, void v) { up_read(&namespace_sem); } static int m_show(struct seq_file m, void v) { struct proc_mounts p = proc_mounts(m); struct mount r = list_entry(v, struct mount, mnt_list); return p->show(m, &r->mnt); } const struct seq_operations mounts_op = { .start = m_start, .next = m_next, .stop = m_stop, .show = m_show, }; #endif /* CONFIG_PROC_FS / /* * may_umount_tree - check if a mount tree is busy * @mnt: root of mount tree * * This is called to check if a tree of mounts has any * open files, pwds, chroots or sub mounts that are * busy. / int may_umount_tree(struct vfsmount m) { struct mount mnt = real_mount(m); int actual_refs = 0; int minimum_refs = 0; struct mount p; BUG_ON(!m); /* write lock needed for mnt_get_count / lock_mount_hash(); for (p = mnt; p; p = next_mnt(p, mnt)) { actual_refs += mnt_get_count(p); minimum_refs += 2; } unlock_mount_hash(); if (actual_refs > minimum_refs) return 0; return 1; } EXPORT_SYMBOL(may_umount_tree); /* * may_umount - check if a mount point is busy * @mnt: root of mount * * This is called to check if a mount point has any * open files, pwds, chroots or sub mounts. If the * mount has sub mounts this will return busy * regardless of whether the sub mounts are busy. * * Doesn't take quota and stuff into account. IOW, in some cases it will * give false negatives. The main reason why it's here is that we need * a non-destructive way to look for easily umountable filesystems. / int may_umount(struct vfsmount mnt) { int ret = 1; down_read(&namespace_sem); lock_mount_hash(); if (propagate_mount_busy(real_mount(mnt), 2)) ret = 0; unlock_mount_hash(); up_read(&namespace_sem); return ret; } EXPORT_SYMBOL(may_umount); static HLIST_HEAD(unmounted); /* protected by namespace_sem / static void namespace_unlock(void) { struct mount mnt; struct hlist_head head = unmounted; if (likely(hlist_empty(&head))) { up_write(&namespace_sem); return; } head.first->pprev = &head.first; INIT_HLIST_HEAD(&unmounted); up_write(&namespace_sem); synchronize_rcu(); while (!hlist_empty(&head)) { mnt = hlist_entry(head.first, struct mount, mnt_hash); hlist_del_init(&mnt->mnt_hash); if (mnt->mnt_ex_mountpoint.mnt) path_put(&mnt->mnt_ex_mountpoint); mntput(&mnt->mnt); } } static inline void namespace_lock(void) { down_write(&namespace_sem); } /* * mount_lock must be held * namespace_sem must be held for write * how = 0 => just this tree, don't propagate * how = 1 => propagate; we know that nobody else has reference to any victims * how = 2 => lazy umount / void umount_tree(struct mount mnt, int how) { HLIST_HEAD(tmp_list); struct mount p; struct mount last = NULL; for (p = mnt; p; p = next_mnt(p, mnt)) { hlist_del_init_rcu(&p->mnt_hash); hlist_add_head(&p->mnt_hash, &tmp_list); } if (how) propagate_umount(&tmp_list); hlist_for_each_entry(p, &tmp_list, mnt_hash) { list_del_init(&p->mnt_expire); list_del_init(&p->mnt_list); __touch_mnt_namespace(p->mnt_ns); p->mnt_ns = NULL; if (how < 2) p->mnt.mnt_flags \|= MNT_SYNC_UMOUNT; list_del_init(&p->mnt_child); if (mnt_has_parent(p)) { put_mountpoint(p->mnt_mp); /* move the reference to mountpoint into ->mnt_ex_mountpoint / p->mnt_ex_mountpoint.dentry = p->mnt_mountpoint; p->mnt_ex_mountpoint.mnt = &p->mnt_parent->mnt; p->mnt_mountpoint = p->mnt.mnt_root; p->mnt_parent = p; p->mnt_mp = NULL; } change_mnt_propagation(p, MS_PRIVATE); last = p; } if (last) { last->mnt_hash.next = unmounted.first; unmounted.first = tmp_list.first; unmounted.first->pprev = &unmounted.first; } } static void shrink_submounts(struct mount mnt); static int do_umount(struct mount mnt, int flags) { struct super_block sb = mnt->mnt.mnt_sb; int retval; retval = security_sb_umount(&mnt->mnt, flags); if (retval) return retval; /* * Allow userspace to request a mountpoint be expired rather than * unmounting unconditionally. Unmount only happens if: * (1) the mark is already set (the mark is cleared by mntput()) * (2) the usage count == 1 [parent vfsmount] + 1 [sys_umount] / if (flags & MNT_EXPIRE) { if (&mnt->mnt == current->fs->root.mnt \|\| flags & (MNT_FORCE \| MNT_DETACH)) return -EINVAL; / * probably don't strictly need the lock here if we examined * all race cases, but it's a slowpath. / lock_mount_hash(); if (mnt_get_count(mnt) != 2) { unlock_mount_hash(); return -EBUSY; } unlock_mount_hash(); if (!xchg(&mnt->mnt_expiry_mark, 1)) return -EAGAIN; } / * If we may have to abort operations to get out of this * mount, and they will themselves hold resources we must * allow the fs to do things. In the Unix tradition of * 'Gee thats tricky lets do it in userspace' the umount_begin * might fail to complete on the first run through as other tasks * must return, and the like. Thats for the mount program to worry * about for the moment. / if (flags & MNT_FORCE && sb->s_op->umount_begin) { sb->s_op->umount_begin(sb); } / * No sense to grab the lock for this test, but test itself looks * somewhat bogus. Suggestions for better replacement? * Ho-hum... In principle, we might treat that as umount + switch * to rootfs. GC would eventually take care of the old vfsmount. * Actually it makes sense, especially if rootfs would contain a * /reboot - static binary that would close all descriptors and * call reboot(9). Then init(8) could umount root and exec /reboot. / if (&mnt->mnt == current->fs->root.mnt && !(flags & MNT_DETACH)) { / * Special case for "unmounting" root ... * we just try to remount it readonly. / down_write(&sb->s_umount); if (!(sb->s_flags & MS_RDONLY)) retval = do_remount_sb(sb, MS_RDONLY, NULL, 0); up_write(&sb->s_umount); return retval; } namespace_lock(); lock_mount_hash(); event++; if (flags & MNT_DETACH) { if (!list_empty(&mnt->mnt_list)) umount_tree(mnt, 2); retval = 0; } else { shrink_submounts(mnt); retval = -EBUSY; if (!propagate_mount_busy(mnt, 2)) { if (!list_empty(&mnt->mnt_list)) umount_tree(mnt, 1); retval = 0; } } unlock_mount_hash(); namespace_unlock(); return retval; } / * Is the caller allowed to modify his namespace? / static inline bool may_mount(void) { return ns_capable(current->nsproxy->mnt_ns->user_ns, CAP_SYS_ADMIN); } / * Now umount can handle mount points as well as block devices. * This is important for filesystems which use unnamed block devices. * * We now support a flag for forced unmount like the other 'big iron' * unixes. Our API is identical to OSF/1 to avoid making a mess of AMD / SYSCALL_DEFINE2(umount, char __user , name, int, flags) { struct path path; struct mount mnt; int retval; int lookup_flags = 0; if (flags & ~(MNT_FORCE \| MNT_DETACH \| MNT_EXPIRE \| UMOUNT_NOFOLLOW)) return -EINVAL; if (!may_mount()) return -EPERM; if (!(flags & UMOUNT_NOFOLLOW)) lookup_flags \|= LOOKUP_FOLLOW; retval = user_path_mountpoint_at(AT_FDCWD, name, lookup_flags, &path); if (retval) goto out; mnt = real_mount(path.mnt); retval = -EINVAL; if (path.dentry != path.mnt->mnt_root) goto dput_and_out; if (!check_mnt(mnt)) goto dput_and_out; if (mnt->mnt.mnt_flags & MNT_LOCKED) goto dput_and_out; retval = do_umount(mnt, flags); dput_and_out: / we mustn't call path_put() as that would clear mnt_expiry_mark / dput(path.dentry); mntput_no_expire(mnt); out: return retval; } #ifdef __ARCH_WANT_SYS_OLDUMOUNT / * The 2.0 compatible umount. No flags. / SYSCALL_DEFINE1(oldumount, char __user , name) { return sys_umount(name, 0); } #endif static bool is_mnt_ns_file(struct dentry dentry) { / Is this a proxy for a mount namespace? / struct inode inode = dentry->d_inode; struct proc_ns ei; if (!proc_ns_inode(inode)) return false; ei = get_proc_ns(inode); if (ei->ns_ops != &mntns_operations) return false; return true; } static bool mnt_ns_loop(struct dentry dentry) { /* Could bind mounting the mount namespace inode cause a * mount namespace loop? / struct mnt_namespace mnt_ns; if (!is_mnt_ns_file(dentry)) return false; mnt_ns = get_proc_ns(dentry->d_inode)->ns; return current->nsproxy->mnt_ns->seq >= mnt_ns->seq; } struct mount copy_tree(struct mount mnt, struct dentry dentry, int flag) { struct mount res, p, q, r, parent; if (!(flag & CL_COPY_UNBINDABLE) && IS_MNT_UNBINDABLE(mnt)) return ERR_PTR(-EINVAL); if (!(flag & CL_COPY_MNT_NS_FILE) && is_mnt_ns_file(dentry)) return ERR_PTR(-EINVAL); res = q = clone_mnt(mnt, dentry, flag); if (IS_ERR(q)) return q; q->mnt.mnt_flags &= ~MNT_LOCKED; q->mnt_mountpoint = mnt->mnt_mountpoint; p = mnt; list_for_each_entry(r, &mnt->mnt_mounts, mnt_child) { struct mount s; if (!is_subdir(r->mnt_mountpoint, dentry)) continue; for (s = r; s; s = next_mnt(s, r)) { if (!(flag & CL_COPY_UNBINDABLE) && IS_MNT_UNBINDABLE(s)) { s = skip_mnt_tree(s); continue; } if (!(flag & CL_COPY_MNT_NS_FILE) && is_mnt_ns_file(s->mnt.mnt_root)) { s = skip_mnt_tree(s); continue; } while (p != s->mnt_parent) { p = p->mnt_parent; q = q->mnt_parent; } p = s; parent = q; q = clone_mnt(p, p->mnt.mnt_root, flag); if (IS_ERR(q)) goto out; lock_mount_hash(); list_add_tail(&q->mnt_list, &res->mnt_list); attach_mnt(q, parent, p->mnt_mp); unlock_mount_hash(); } } return res; out: if (res) { lock_mount_hash(); umount_tree(res, 0); unlock_mount_hash(); } return q; } / Caller should check returned pointer for errors / struct vfsmount collect_mounts(struct path path) { struct mount tree; namespace_lock(); tree = copy_tree(real_mount(path->mnt), path->dentry, CL_COPY_ALL \| CL_PRIVATE); namespace_unlock(); if (IS_ERR(tree)) return ERR_CAST(tree); return &tree->mnt; } void drop_collected_mounts(struct vfsmount mnt) { namespace_lock(); lock_mount_hash(); umount_tree(real_mount(mnt), 0); unlock_mount_hash(); namespace_unlock(); } int iterate_mounts(int (f)(struct vfsmount , void ), void arg, struct vfsmount root) { struct mount mnt; int res = f(root, arg); if (res) return res; list_for_each_entry(mnt, &real_mount(root)->mnt_list, mnt_list) { res = f(&mnt->mnt, arg); if (res) return res; } return 0; } static void cleanup_group_ids(struct mount mnt, struct mount end) { struct mount p; for (p = mnt; p != end; p = next_mnt(p, mnt)) { if (p->mnt_group_id && !IS_MNT_SHARED(p)) mnt_release_group_id(p); } } static int invent_group_ids(struct mount mnt, bool recurse) { struct mount p; for (p = mnt; p; p = recurse ? next_mnt(p, mnt) : NULL) { if (!p->mnt_group_id && !IS_MNT_SHARED(p)) { int err = mnt_alloc_group_id(p); if (err) { cleanup_group_ids(mnt, p); return err; } } } return 0; } /* * @source_mnt : mount tree to be attached * @nd : place the mount tree @source_mnt is attached * @parent_nd : if non-null, detach the source_mnt from its parent and * store the parent mount and mountpoint dentry. * (done when source_mnt is moved) * * NOTE: in the table below explains the semantics when a source mount * of a given type is attached to a destination mount of a given type. * --------------------------------------------------------------------------- * \| BIND MOUNT OPERATION \| * \|************************************************************************** * \| source-->\| shared \| private \| slave \| unbindable \| * \| dest \| \| \| \| \| * \| \| \| \| \| \| \| * \| v \| \| \| \| \| * \|************************************************************************** * \| shared \| shared (++) \| shared (+) \| shared(+++)\| invalid \| * \| \| \| \| \| \| * \|non-shared\| shared (+) \| private \| slave () \| invalid \| *************************************************************************** * A bind operation clones the source mount and mounts the clone on the * destination mount. * * (++) the cloned mount is propagated to all the mounts in the propagation * tree of the destination mount and the cloned mount is added to * the peer group of the source mount. * (+) the cloned mount is created under the destination mount and is marked * as shared. The cloned mount is added to the peer group of the source * mount. * (+++) the mount is propagated to all the mounts in the propagation tree * of the destination mount and the cloned mount is made slave * of the same master as that of the source mount. The cloned mount * is marked as 'shared and slave'. * () the cloned mount is made a slave of the same master as that of the source mount. * * --------------------------------------------------------------------------- * \| MOVE MOUNT OPERATION \| * \|************************************************************************** * \| source-->\| shared \| private \| slave \| unbindable \| * \| dest \| \| \| \| \| * \| \| \| \| \| \| \| * \| v \| \| \| \| \| * \|************************************************************************** * \| shared \| shared (+) \| shared (+) \| shared(+++) \| invalid \| * \| \| \| \| \| \| * \|non-shared\| shared (+) \| private \| slave () \| unbindable \| * *************************************************************************** * * (+) the mount is moved to the destination. And is then propagated to * all the mounts in the propagation tree of the destination mount. * (+) the mount is moved to the destination. (+++) the mount is moved to the destination and is then propagated to * all the mounts belonging to the destination mount's propagation tree. * the mount is marked as 'shared and slave'. * () the mount continues to be a slave at the new location. * if the source mount is a tree, the operations explained above is * applied to each mount in the tree. * Must be called without spinlocks held, since this function can sleep * in allocations. / static int attach_recursive_mnt(struct mount source_mnt, struct mount dest_mnt, struct mountpoint dest_mp, struct path parent_path) { HLIST_HEAD(tree_list); struct mount child, p; struct hlist_node n; int err; if (IS_MNT_SHARED(dest_mnt)) { err = invent_group_ids(source_mnt, true); if (err) goto out; err = propagate_mnt(dest_mnt, dest_mp, source_mnt, &tree_list); lock_mount_hash(); if (err) goto out_cleanup_ids; for (p = source_mnt; p; p = next_mnt(p, source_mnt)) set_mnt_shared(p); } else { lock_mount_hash(); } if (parent_path) { detach_mnt(source_mnt, parent_path); attach_mnt(source_mnt, dest_mnt, dest_mp); touch_mnt_namespace(source_mnt->mnt_ns); } else { mnt_set_mountpoint(dest_mnt, dest_mp, source_mnt); commit_tree(source_mnt, NULL); } hlist_for_each_entry_safe(child, n, &tree_list, mnt_hash) { struct mount q; hlist_del_init(&child->mnt_hash); q = __lookup_mnt_last(&child->mnt_parent->mnt, child->mnt_mountpoint); commit_tree(child, q); } unlock_mount_hash(); return 0; out_cleanup_ids: while (!hlist_empty(&tree_list)) { child = hlist_entry(tree_list.first, struct mount, mnt_hash); umount_tree(child, 0); } unlock_mount_hash(); cleanup_group_ids(source_mnt, NULL); out: return err; } static struct mountpoint lock_mount(struct path path) { struct vfsmount mnt; struct dentry dentry = path->dentry; retry: mutex_lock(&dentry->d_inode->i_mutex); if (unlikely(cant_mount(dentry))) { mutex_unlock(&dentry->d_inode->i_mutex); return ERR_PTR(-ENOENT); } namespace_lock(); mnt = lookup_mnt(path); if (likely(!mnt)) { struct mountpoint mp = new_mountpoint(dentry); if (IS_ERR(mp)) { namespace_unlock(); mutex_unlock(&dentry->d_inode->i_mutex); return mp; } return mp; } namespace_unlock(); mutex_unlock(&path->dentry->d_inode->i_mutex); path_put(path); path->mnt = mnt; dentry = path->dentry = dget(mnt->mnt_root); goto retry; } static void unlock_mount(struct mountpoint where) { struct dentry dentry = where->m_dentry; put_mountpoint(where); namespace_unlock(); mutex_unlock(&dentry->d_inode->i_mutex); } static int graft_tree(struct mount mnt, struct mount p, struct mountpoint mp) { if (mnt->mnt.mnt_sb->s_flags & MS_NOUSER) return -EINVAL; if (S_ISDIR(mp->m_dentry->d_inode->i_mode) != S_ISDIR(mnt->mnt.mnt_root->d_inode->i_mode)) return -ENOTDIR; return attach_recursive_mnt(mnt, p, mp, NULL); } / * Sanity check the flags to change_mnt_propagation. / static int flags_to_propagation_type(int flags) { int type = flags & ~(MS_REC \| MS_SILENT); / Fail if any non-propagation flags are set / if (type & ~(MS_SHARED \| MS_PRIVATE \| MS_SLAVE \| MS_UNBINDABLE)) return 0; / Only one propagation flag should be set / if (!is_power_of_2(type)) return 0; return type; } / * recursively change the type of the mountpoint. / static int do_change_type(struct path path, int flag) { struct mount m; struct mount mnt = real_mount(path->mnt); int recurse = flag & MS_REC; int type; int err = 0; if (path->dentry != path->mnt->mnt_root) return -EINVAL; type = flags_to_propagation_type(flag); if (!type) return -EINVAL; namespace_lock(); if (type == MS_SHARED) { err = invent_group_ids(mnt, recurse); if (err) goto out_unlock; } lock_mount_hash(); for (m = mnt; m; m = (recurse ? next_mnt(m, mnt) : NULL)) change_mnt_propagation(m, type); unlock_mount_hash(); out_unlock: namespace_unlock(); return err; } static bool has_locked_children(struct mount mnt, struct dentry dentry) { struct mount child; list_for_each_entry(child, &mnt->mnt_mounts, mnt_child) { if (!is_subdir(child->mnt_mountpoint, dentry)) continue; if (child->mnt.mnt_flags & MNT_LOCKED) return true; } return false; } / * do loopback mount. / static int do_loopback(struct path path, const char old_name, int recurse) { struct path old_path; struct mount mnt = NULL, old, parent; struct mountpoint mp; int err; if (!old_name \|\| !old_name) return -EINVAL; err = kern_path(old_name, LOOKUP_FOLLOW\|LOOKUP_AUTOMOUNT, &old_path); if (err) return err; err = -EINVAL; if (mnt_ns_loop(old_path.dentry)) goto out; mp = lock_mount(path); err = PTR_ERR(mp); if (IS_ERR(mp)) goto out; old = real_mount(old_path.mnt); parent = real_mount(path->mnt); err = -EINVAL; if (IS_MNT_UNBINDABLE(old)) goto out2; if (!check_mnt(parent) \|\| !check_mnt(old)) goto out2; if (!recurse && has_locked_children(old, old_path.dentry)) goto out2; if (recurse) mnt = copy_tree(old, old_path.dentry, CL_COPY_MNT_NS_FILE); else mnt = clone_mnt(old, old_path.dentry, 0); if (IS_ERR(mnt)) { err = PTR_ERR(mnt); goto out2; } mnt->mnt.mnt_flags &= ~MNT_LOCKED; err = graft_tree(mnt, parent, mp); if (err) { lock_mount_hash(); umount_tree(mnt, 0); unlock_mount_hash(); } out2: unlock_mount(mp); out: path_put(&old_path); return err; } static int change_mount_flags(struct vfsmount mnt, int ms_flags) { int error = 0; int readonly_request = 0; if (ms_flags & MS_RDONLY) readonly_request = 1; if (readonly_request == __mnt_is_readonly(mnt)) return 0; if (readonly_request) error = mnt_make_readonly(real_mount(mnt)); else __mnt_unmake_readonly(real_mount(mnt)); return error; } / * change filesystem flags. dir should be a physical root of filesystem. * If you've mounted a non-root directory somewhere and want to do remount * on it - tough luck. / static int do_remount(struct path path, int flags, int mnt_flags, void data) { int err; struct super_block sb = path->mnt->mnt_sb; struct mount mnt = real_mount(path->mnt); if (!check_mnt(mnt)) return -EINVAL; if (path->dentry != path->mnt->mnt_root) return -EINVAL; / Don't allow changing of locked mnt flags. * * No locks need to be held here while testing the various * MNT_LOCK flags because those flags can never be cleared * once they are set. / if ((mnt->mnt.mnt_flags & MNT_LOCK_READONLY) && !(mnt_flags & MNT_READONLY)) { return -EPERM; } if ((mnt->mnt.mnt_flags & MNT_LOCK_NODEV) && !(mnt_flags & MNT_NODEV)) { return -EPERM; } if ((mnt->mnt.mnt_flags & MNT_LOCK_NOSUID) && !(mnt_flags & MNT_NOSUID)) { return -EPERM; } if ((mnt->mnt.mnt_flags & MNT_LOCK_NOEXEC) && !(mnt_flags & MNT_NOEXEC)) { return -EPERM; } if ((mnt->mnt.mnt_flags & MNT_LOCK_ATIME) && ((mnt->mnt.mnt_flags & MNT_ATIME_MASK) != (mnt_flags & MNT_ATIME_MASK))) { return -EPERM; } err = security_sb_remount(sb, data); if (err) return err; down_write(&sb->s_umount); if (flags & MS_BIND) err = change_mount_flags(path->mnt, flags); else if (!capable(CAP_SYS_ADMIN)) err = -EPERM; else err = do_remount_sb(sb, flags, data, 0); if (!err) { lock_mount_hash(); mnt_flags \|= mnt->mnt.mnt_flags & ~MNT_USER_SETTABLE_MASK; mnt->mnt.mnt_flags = mnt_flags; touch_mnt_namespace(mnt->mnt_ns); unlock_mount_hash(); } up_write(&sb->s_umount); return err; } static inline int tree_contains_unbindable(struct mount mnt) { struct mount p; for (p = mnt; p; p = next_mnt(p, mnt)) { if (IS_MNT_UNBINDABLE(p)) return 1; } return 0; } static int do_move_mount(struct path path, const char old_name) { struct path old_path, parent_path; struct mount p; struct mount old; struct mountpoint mp; int err; if (!old_name \|\| !old_name) return -EINVAL; err = kern_path(old_name, LOOKUP_FOLLOW, &old_path); if (err) return err; mp = lock_mount(path); err = PTR_ERR(mp); if (IS_ERR(mp)) goto out; old = real_mount(old_path.mnt); p = real_mount(path->mnt); err = -EINVAL; if (!check_mnt(p) \|\| !check_mnt(old)) goto out1; if (old->mnt.mnt_flags & MNT_LOCKED) goto out1; err = -EINVAL; if (old_path.dentry != old_path.mnt->mnt_root) goto out1; if (!mnt_has_parent(old)) goto out1; if (S_ISDIR(path->dentry->d_inode->i_mode) != S_ISDIR(old_path.dentry->d_inode->i_mode)) goto out1; / * Don't move a mount residing in a shared parent. / if (IS_MNT_SHARED(old->mnt_parent)) goto out1; / * Don't move a mount tree containing unbindable mounts to a destination * mount which is shared. / if (IS_MNT_SHARED(p) && tree_contains_unbindable(old)) goto out1; err = -ELOOP; for (; mnt_has_parent(p); p = p->mnt_parent) if (p == old) goto out1; err = attach_recursive_mnt(old, real_mount(path->mnt), mp, &parent_path); if (err) goto out1; / if the mount is moved, it should no longer be expire * automatically / list_del_init(&old->mnt_expire); out1: unlock_mount(mp); out: if (!err) path_put(&parent_path); path_put(&old_path); return err; } static struct vfsmount fs_set_subtype(struct vfsmount mnt, const char fstype) { int err; const char subtype = strchr(fstype, '.'); if (subtype) { subtype++; err = -EINVAL; if (!subtype[0]) goto err; } else subtype = ""; mnt->mnt_sb->s_subtype = kstrdup(subtype, GFP_KERNEL); err = -ENOMEM; if (!mnt->mnt_sb->s_subtype) goto err; return mnt; err: mntput(mnt); return ERR_PTR(err); } / * add a mount into a namespace's mount tree / static int do_add_mount(struct mount newmnt, struct path path, int mnt_flags) { struct mountpoint mp; struct mount parent; int err; mnt_flags &= ~MNT_INTERNAL_FLAGS; mp = lock_mount(path); if (IS_ERR(mp)) return PTR_ERR(mp); parent = real_mount(path->mnt); err = -EINVAL; if (unlikely(!check_mnt(parent))) { / that's acceptable only for automounts done in private ns / if (!(mnt_flags & MNT_SHRINKABLE)) goto unlock; / ... and for those we'd better have mountpoint still alive / if (!parent->mnt_ns) goto unlock; } / Refuse the same filesystem on the same mount point / err = -EBUSY; if (path->mnt->mnt_sb == newmnt->mnt.mnt_sb && path->mnt->mnt_root == path->dentry) goto unlock; err = -EINVAL; if (S_ISLNK(newmnt->mnt.mnt_root->d_inode->i_mode)) goto unlock; newmnt->mnt.mnt_flags = mnt_flags; err = graft_tree(newmnt, parent, mp); unlock: unlock_mount(mp); return err; } / * create a new mount for userspace and request it to be added into the * namespace's tree / static int do_new_mount(struct path path, const char fstype, int flags, int mnt_flags, const char name, void data) { struct file_system_type type; struct user_namespace user_ns = current->nsproxy->mnt_ns->user_ns; struct vfsmount mnt; int err; if (!fstype) return -EINVAL; type = get_fs_type(fstype); if (!type) return -ENODEV; if (user_ns != &init_user_ns) { if (!(type->fs_flags & FS_USERNS_MOUNT)) { put_filesystem(type); return -EPERM; } /* Only in special cases allow devices from mounts * created outside the initial user namespace. / if (!(type->fs_flags & FS_USERNS_DEV_MOUNT)) { flags \|= MS_NODEV; mnt_flags \|= MNT_NODEV \| MNT_LOCK_NODEV; } } mnt = vfs_kern_mount(type, flags, name, data); if (!IS_ERR(mnt) && (type->fs_flags & FS_HAS_SUBTYPE) && !mnt->mnt_sb->s_subtype) mnt = fs_set_subtype(mnt, fstype); put_filesystem(type); if (IS_ERR(mnt)) return PTR_ERR(mnt); err = do_add_mount(real_mount(mnt), path, mnt_flags); if (err) mntput(mnt); return err; } int finish_automount(struct vfsmount m, struct path path) { struct mount mnt = real_mount(m); int err; /* The new mount record should have at least 2 refs to prevent it being * expired before we get a chance to add it / BUG_ON(mnt_get_count(mnt) < 2); if (m->mnt_sb == path->mnt->mnt_sb && m->mnt_root == path->dentry) { err = -ELOOP; goto fail; } err = do_add_mount(mnt, path, path->mnt->mnt_flags \| MNT_SHRINKABLE); if (!err) return 0; fail: / remove m from any expiration list it may be on / if (!list_empty(&mnt->mnt_expire)) { namespace_lock(); list_del_init(&mnt->mnt_expire); namespace_unlock(); } mntput(m); mntput(m); return err; } /* * mnt_set_expiry - Put a mount on an expiration list * @mnt: The mount to list. * @expiry_list: The list to add the mount to. / void mnt_set_expiry(struct vfsmount mnt, struct list_head expiry_list) { namespace_lock(); list_add_tail(&real_mount(mnt)->mnt_expire, expiry_list); namespace_unlock(); } EXPORT_SYMBOL(mnt_set_expiry); / * process a list of expirable mountpoints with the intent of discarding any * mountpoints that aren't in use and haven't been touched since last we came * here / void mark_mounts_for_expiry(struct list_head mounts) { struct mount mnt, next; LIST_HEAD(graveyard); if (list_empty(mounts)) return; namespace_lock(); lock_mount_hash(); /* extract from the expiration list every vfsmount that matches the * following criteria: * - only referenced by its parent vfsmount * - still marked for expiry (marked on the last call here; marks are * cleared by mntput()) / list_for_each_entry_safe(mnt, next, mounts, mnt_expire) { if (!xchg(&mnt->mnt_expiry_mark, 1) \|\| propagate_mount_busy(mnt, 1)) continue; list_move(&mnt->mnt_expire, &graveyard); } while (!list_empty(&graveyard)) { mnt = list_first_entry(&graveyard, struct mount, mnt_expire); touch_mnt_namespace(mnt->mnt_ns); umount_tree(mnt, 1); } unlock_mount_hash(); namespace_unlock(); } EXPORT_SYMBOL_GPL(mark_mounts_for_expiry); / * Ripoff of 'select_parent()' * * search the list of submounts for a given mountpoint, and move any * shrinkable submounts to the 'graveyard' list. / static int select_submounts(struct mount parent, struct list_head graveyard) { struct mount this_parent = parent; struct list_head next; int found = 0; repeat: next = this_parent->mnt_mounts.next; resume: while (next != &this_parent->mnt_mounts) { struct list_head tmp = next; struct mount mnt = list_entry(tmp, struct mount, mnt_child); next = tmp->next; if (!(mnt->mnt.mnt_flags & MNT_SHRINKABLE)) continue; / * Descend a level if the d_mounts list is non-empty. / if (!list_empty(&mnt->mnt_mounts)) { this_parent = mnt; goto repeat; } if (!propagate_mount_busy(mnt, 1)) { list_move_tail(&mnt->mnt_expire, graveyard); found++; } } / * All done at this level ... ascend and resume the search / if (this_parent != parent) { next = this_parent->mnt_child.next; this_parent = this_parent->mnt_parent; goto resume; } return found; } / * process a list of expirable mountpoints with the intent of discarding any * submounts of a specific parent mountpoint * * mount_lock must be held for write / static void shrink_submounts(struct mount mnt) { LIST_HEAD(graveyard); struct mount m; / extract submounts of 'mountpoint' from the expiration list / while (select_submounts(mnt, &graveyard)) { while (!list_empty(&graveyard)) { m = list_first_entry(&graveyard, struct mount, mnt_expire); touch_mnt_namespace(m->mnt_ns); umount_tree(m, 1); } } } / * Some copy_from_user() implementations do not return the exact number of * bytes remaining to copy on a fault. But copy_mount_options() requires that. * Note that this function differs from copy_from_user() in that it will oops * on bad values of `to', rather than returning a short copy. / static long exact_copy_from_user(void to, const void __user * from, unsigned long n) { char t = to; const char __user f = from; char c; if (!access_ok(VERIFY_READ, from, n)) return n; while (n) { if (__get_user(c, f)) { memset(t, 0, n); break; } t++ = c; f++; n--; } return n; } int copy_mount_options(const void __user data, unsigned long where) { int i; unsigned long page; unsigned long size; where = 0; if (!data) return 0; if (!(page = __get_free_page(GFP_KERNEL))) return -ENOMEM; /* We only care that some data at the address the user * gave us is valid. Just in case, we'll zero * the remainder of the page. / / copy_from_user cannot cross TASK_SIZE ! / size = TASK_SIZE - (unsigned long)data; if (size > PAGE_SIZE) size = PAGE_SIZE; i = size - exact_copy_from_user((void )page, data, size); if (!i) { free_page(page); return -EFAULT; } if (i != PAGE_SIZE) memset((char )page + i, 0, PAGE_SIZE - i); where = page; return 0; } int copy_mount_string(const void __user data, char where) { char tmp; if (!data) { where = NULL; return 0; } tmp = strndup_user(data, PAGE_SIZE); if (IS_ERR(tmp)) return PTR_ERR(tmp); where = tmp; return 0; } /* * Flags is a 32-bit value that allows up to 31 non-fs dependent flags to * be given to the mount() call (ie: read-only, no-dev, no-suid etc). * * data is a (void ) that can point to any structure up to PAGE_SIZE-1 bytes, which can contain arbitrary fs-dependent * information (or be NULL). * * Pre-0.97 versions of mount() didn't have a flags word. * When the flags word was introduced its top half was required * to have the magic value 0xC0ED, and this remained so until 2.4.0-test9. * Therefore, if this magic number is present, it carries no information * and must be discarded. / long do_mount(const char dev_name, const char dir_name, const char type_page, unsigned long flags, void data_page) { struct path path; int retval = 0; int mnt_flags = 0; / Discard magic / if ((flags & MS_MGC_MSK) == MS_MGC_VAL) flags &= ~MS_MGC_MSK; / Basic sanity checks / if (!dir_name \|\| !dir_name \|\| !memchr(dir_name, 0, PAGE_SIZE)) return -EINVAL; if (data_page) ((char )data_page)[PAGE_SIZE - 1] = 0; / ... and get the mountpoint / retval = kern_path(dir_name, LOOKUP_FOLLOW, &path); if (retval) return retval; retval = security_sb_mount(dev_name, &path, type_page, flags, data_page); if (!retval && !may_mount()) retval = -EPERM; if (retval) goto dput_out; / Default to relatime unless overriden / if (!(flags & MS_NOATIME)) mnt_flags \|= MNT_RELATIME; / Separate the per-mountpoint flags / if (flags & MS_NOSUID) mnt_flags \|= MNT_NOSUID; if (flags & MS_NODEV) mnt_flags \|= MNT_NODEV; if (flags & MS_NOEXEC) mnt_flags \|= MNT_NOEXEC; if (flags & MS_NOATIME) mnt_flags \|= MNT_NOATIME; if (flags & MS_NODIRATIME) mnt_flags \|= MNT_NODIRATIME; if (flags & MS_STRICTATIME) mnt_flags &= ~(MNT_RELATIME \| MNT_NOATIME); if (flags & MS_RDONLY) mnt_flags \|= MNT_READONLY; flags &= ~(MS_NOSUID \| MS_NOEXEC \| MS_NODEV \| MS_ACTIVE \| MS_BORN \| MS_NOATIME \| MS_NODIRATIME \| MS_RELATIME\| MS_KERNMOUNT \| MS_STRICTATIME); if (flags & MS_REMOUNT) retval = do_remount(&path, flags & ~MS_REMOUNT, mnt_flags, data_page); else if (flags & MS_BIND) retval = do_loopback(&path, dev_name, flags & MS_REC); else if (flags & (MS_SHARED \| MS_PRIVATE \| MS_SLAVE \| MS_UNBINDABLE)) retval = do_change_type(&path, flags); else if (flags & MS_MOVE) retval = do_move_mount(&path, dev_name); else retval = do_new_mount(&path, type_page, flags, mnt_flags, dev_name, data_page); dput_out: path_put(&path); return retval; } static void free_mnt_ns(struct mnt_namespace ns) { proc_free_inum(ns->proc_inum); put_user_ns(ns->user_ns); kfree(ns); } /* * Assign a sequence number so we can detect when we attempt to bind * mount a reference to an older mount namespace into the current * mount namespace, preventing reference counting loops. A 64bit * number incrementing at 10Ghz will take 12,427 years to wrap which * is effectively never, so we can ignore the possibility. / static atomic64_t mnt_ns_seq = ATOMIC64_INIT(1); static struct mnt_namespace alloc_mnt_ns(struct user_namespace user_ns) { struct mnt_namespace new_ns; int ret; new_ns = kmalloc(sizeof(struct mnt_namespace), GFP_KERNEL); if (!new_ns) return ERR_PTR(-ENOMEM); ret = proc_alloc_inum(&new_ns->proc_inum); if (ret) { kfree(new_ns); return ERR_PTR(ret); } new_ns->seq = atomic64_add_return(1, &mnt_ns_seq); atomic_set(&new_ns->count, 1); new_ns->root = NULL; INIT_LIST_HEAD(&new_ns->list); init_waitqueue_head(&new_ns->poll); new_ns->event = 0; new_ns->user_ns = get_user_ns(user_ns); return new_ns; } struct mnt_namespace copy_mnt_ns(unsigned long flags, struct mnt_namespace ns, struct user_namespace user_ns, struct fs_struct new_fs) { struct mnt_namespace new_ns; struct vfsmount rootmnt = NULL, pwdmnt = NULL; struct mount p, q; struct mount old; struct mount new; int copy_flags; BUG_ON(!ns); if (likely(!(flags & CLONE_NEWNS))) { get_mnt_ns(ns); return ns; } old = ns->root; new_ns = alloc_mnt_ns(user_ns); if (IS_ERR(new_ns)) return new_ns; namespace_lock(); / First pass: copy the tree topology / copy_flags = CL_COPY_UNBINDABLE \| CL_EXPIRE; if (user_ns != ns->user_ns) copy_flags \|= CL_SHARED_TO_SLAVE \| CL_UNPRIVILEGED; new = copy_tree(old, old->mnt.mnt_root, copy_flags); if (IS_ERR(new)) { namespace_unlock(); free_mnt_ns(new_ns); return ERR_CAST(new); } new_ns->root = new; list_add_tail(&new_ns->list, &new->mnt_list); / * Second pass: switch the tsk->fs->* elements and mark new vfsmounts * as belonging to new namespace. We have already acquired a private * fs_struct, so tsk->fs->lock is not needed. / p = old; q = new; while (p) { q->mnt_ns = new_ns; if (new_fs) { if (&p->mnt == new_fs->root.mnt) { new_fs->root.mnt = mntget(&q->mnt); rootmnt = &p->mnt; } if (&p->mnt == new_fs->pwd.mnt) { new_fs->pwd.mnt = mntget(&q->mnt); pwdmnt = &p->mnt; } } p = next_mnt(p, old); q = next_mnt(q, new); if (!q) break; while (p->mnt.mnt_root != q->mnt.mnt_root) p = next_mnt(p, old); } namespace_unlock(); if (rootmnt) mntput(rootmnt); if (pwdmnt) mntput(pwdmnt); return new_ns; } /* * create_mnt_ns - creates a private namespace and adds a root filesystem * @mnt: pointer to the new root filesystem mountpoint / static struct mnt_namespace create_mnt_ns(struct vfsmount m) { struct mnt_namespace new_ns = alloc_mnt_ns(&init_user_ns); if (!IS_ERR(new_ns)) { struct mount mnt = real_mount(m); mnt->mnt_ns = new_ns; new_ns->root = mnt; list_add(&mnt->mnt_list, &new_ns->list); } else { mntput(m); } return new_ns; } struct dentry mount_subtree(struct vfsmount mnt, const char name) { struct mnt_namespace ns; struct super_block s; struct path path; int err; ns = create_mnt_ns(mnt); if (IS_ERR(ns)) return ERR_CAST(ns); err = vfs_path_lookup(mnt->mnt_root, mnt, name, LOOKUP_FOLLOW\|LOOKUP_AUTOMOUNT, &path); put_mnt_ns(ns); if (err) return ERR_PTR(err); /* trade a vfsmount reference for active sb one / s = path.mnt->mnt_sb; atomic_inc(&s->s_active); mntput(path.mnt); / lock the sucker / down_write(&s->s_umount); / ... and return the root of (sub)tree on it / return path.dentry; } EXPORT_SYMBOL(mount_subtree); SYSCALL_DEFINE5(mount, char __user , dev_name, char __user , dir_name, char __user , type, unsigned long, flags, void __user , data) { int ret; char kernel_type; struct filename kernel_dir; char kernel_dev; unsigned long data_page; ret = copy_mount_string(type, &kernel_type); if (ret < 0) goto out_type; kernel_dir = getname(dir_name); if (IS_ERR(kernel_dir)) { ret = PTR_ERR(kernel_dir); goto out_dir; } ret = copy_mount_string(dev_name, &kernel_dev); if (ret < 0) goto out_dev; ret = copy_mount_options(data, &data_page); if (ret < 0) goto out_data; ret = do_mount(kernel_dev, kernel_dir->name, kernel_type, flags, (void ) data_page); free_page(data_page); out_data: kfree(kernel_dev); out_dev: putname(kernel_dir); out_dir: kfree(kernel_type); out_type: return ret; } / * Return true if path is reachable from root * * namespace_sem or mount_lock is held / bool is_path_reachable(struct mount mnt, struct dentry dentry, const struct path root) { while (&mnt->mnt != root->mnt && mnt_has_parent(mnt)) { dentry = mnt->mnt_mountpoint; mnt = mnt->mnt_parent; } return &mnt->mnt == root->mnt && is_subdir(dentry, root->dentry); } int path_is_under(struct path path1, struct path path2) { int res; read_seqlock_excl(&mount_lock); res = is_path_reachable(real_mount(path1->mnt), path1->dentry, path2); read_sequnlock_excl(&mount_lock); return res; } EXPORT_SYMBOL(path_is_under); /* * pivot_root Semantics: * Moves the root file system of the current process to the directory put_old, * makes new_root as the new root file system of the current process, and sets * root/cwd of all processes which had them on the current root to new_root. * * Restrictions: * The new_root and put_old must be directories, and must not be on the * same file system as the current process root. The put_old must be * underneath new_root, i.e. adding a non-zero number of /.. to the string * pointed to by put_old must yield the same directory as new_root. No other * file system may be mounted on put_old. After all, new_root is a mountpoint. * * Also, the current root cannot be on the 'rootfs' (initial ramfs) filesystem. * See Documentation/filesystems/ramfs-rootfs-initramfs.txt for alternatives * in this situation. * * Notes: * - we don't move root/cwd if they are not at the root (reason: if something * cared enough to change them, it's probably wrong to force them elsewhere) * - it's okay to pick a root that isn't the root of a file system, e.g. * /nfs/my_root where /nfs is the mount point. It must be a mountpoint, * though, so you may need to say mount --bind /nfs/my_root /nfs/my_root * first. / SYSCALL_DEFINE2(pivot_root, const char __user , new_root, const char __user , put_old) { struct path new, old, parent_path, root_parent, root; struct mount new_mnt, root_mnt, old_mnt; struct mountpoint old_mp, root_mp; int error; if (!may_mount()) return -EPERM; error = user_path_dir(new_root, &new); if (error) goto out0; error = user_path_dir(put_old, &old); if (error) goto out1; error = security_sb_pivotroot(&old, &new); if (error) goto out2; get_fs_root(current->fs, &root); old_mp = lock_mount(&old); error = PTR_ERR(old_mp); if (IS_ERR(old_mp)) goto out3; error = -EINVAL; new_mnt = real_mount(new.mnt); root_mnt = real_mount(root.mnt); old_mnt = real_mount(old.mnt); if (IS_MNT_SHARED(old_mnt) \|\| IS_MNT_SHARED(new_mnt->mnt_parent) \|\| IS_MNT_SHARED(root_mnt->mnt_parent)) goto out4; if (!check_mnt(root_mnt) \|\| !check_mnt(new_mnt)) goto out4; if (new_mnt->mnt.mnt_flags & MNT_LOCKED) goto out4; error = -ENOENT; if (d_unlinked(new.dentry)) goto out4; error = -EBUSY; if (new_mnt == root_mnt \|\| old_mnt == root_mnt) goto out4; /* loop, on the same file system / error = -EINVAL; if (root.mnt->mnt_root != root.dentry) goto out4; / not a mountpoint / if (!mnt_has_parent(root_mnt)) goto out4; / not attached / root_mp = root_mnt->mnt_mp; if (new.mnt->mnt_root != new.dentry) goto out4; / not a mountpoint / if (!mnt_has_parent(new_mnt)) goto out4; / not attached / / make sure we can reach put_old from new_root / if (!is_path_reachable(old_mnt, old.dentry, &new)) goto out4; root_mp->m_count++; / pin it so it won't go away / lock_mount_hash(); detach_mnt(new_mnt, &parent_path); detach_mnt(root_mnt, &root_parent); if (root_mnt->mnt.mnt_flags & MNT_LOCKED) { new_mnt->mnt.mnt_flags \|= MNT_LOCKED; root_mnt->mnt.mnt_flags &= ~MNT_LOCKED; } / mount old root on put_old / attach_mnt(root_mnt, old_mnt, old_mp); / mount new_root on / / attach_mnt(new_mnt, real_mount(root_parent.mnt), root_mp); touch_mnt_namespace(current->nsproxy->mnt_ns); unlock_mount_hash(); chroot_fs_refs(&root, &new); put_mountpoint(root_mp); error = 0; out4: unlock_mount(old_mp); if (!error) { path_put(&root_parent); path_put(&parent_path); } out3: path_put(&root); out2: path_put(&old); out1: path_put(&new); out0: return error; } static void __init init_mount_tree(void) { struct vfsmount mnt; struct mnt_namespace ns; struct path root; struct file_system_type type; type = get_fs_type("rootfs"); if (!type) panic("Can't find rootfs type"); mnt = vfs_kern_mount(type, 0, "rootfs", NULL); put_filesystem(type); if (IS_ERR(mnt)) panic("Can't create rootfs"); ns = create_mnt_ns(mnt); if (IS_ERR(ns)) panic("Can't allocate initial namespace"); init_task.nsproxy->mnt_ns = ns; get_mnt_ns(ns); root.mnt = mnt; root.dentry = mnt->mnt_root; set_fs_pwd(current->fs, &root); set_fs_root(current->fs, &root); } void __init mnt_init(void) { unsigned u; int err; mnt_cache = kmem_cache_create("mnt_cache", sizeof(struct mount), 0, SLAB_HWCACHE_ALIGN \| SLAB_PANIC, NULL); mount_hashtable = alloc_large_system_hash("Mount-cache", sizeof(struct hlist_head), mhash_entries, 19, 0, &m_hash_shift, &m_hash_mask, 0, 0); mountpoint_hashtable = alloc_large_system_hash("Mountpoint-cache", sizeof(struct hlist_head), mphash_entries, 19, 0, &mp_hash_shift, &mp_hash_mask, 0, 0); if (!mount_hashtable \|\| !mountpoint_hashtable) panic("Failed to allocate mount hash table\n"); for (u = 0; u <= m_hash_mask; u++) INIT_HLIST_HEAD(&mount_hashtable[u]); for (u = 0; u <= mp_hash_mask; u++) INIT_HLIST_HEAD(&mountpoint_hashtable[u]); kernfs_init(); err = sysfs_init(); if (err) printk(KERN_WARNING "%s: sysfs_init error: %d\n", __func__, err); fs_kobj = kobject_create_and_add("fs", NULL); if (!fs_kobj) printk(KERN_WARNING "%s: kobj create error\n", __func__); init_rootfs(); init_mount_tree(); } void put_mnt_ns(struct mnt_namespace ns) { if (!atomic_dec_and_test(&ns->count)) return; drop_collected_mounts(&ns->root->mnt); free_mnt_ns(ns); } struct vfsmount kern_mount_data(struct file_system_type type, void data) { struct vfsmount mnt; mnt = vfs_kern_mount(type, MS_KERNMOUNT, type->name, data); if (!IS_ERR(mnt)) { / * it is a longterm mount, don't release mnt until * we unmount before file sys is unregistered / real_mount(mnt)->mnt_ns = MNT_NS_INTERNAL; } return mnt; } EXPORT_SYMBOL_GPL(kern_mount_data); void kern_unmount(struct vfsmount mnt) { /* release long term mount so mount point can be released / if (!IS_ERR_OR_NULL(mnt)) { real_mount(mnt)->mnt_ns = NULL; synchronize_rcu(); / yecchhh... / mntput(mnt); } } EXPORT_SYMBOL(kern_unmount); bool our_mnt(struct vfsmount mnt) { return check_mnt(real_mount(mnt)); } bool current_chrooted(void) { /* Does the current process have a non-standard root / struct path ns_root; struct path fs_root; bool chrooted; / Find the namespace root / ns_root.mnt = &current->nsproxy->mnt_ns->root->mnt; ns_root.dentry = ns_root.mnt->mnt_root; path_get(&ns_root); while (d_mountpoint(ns_root.dentry) && follow_down_one(&ns_root)) ; get_fs_root(current->fs, &fs_root); chrooted = !path_equal(&fs_root, &ns_root); path_put(&fs_root); path_put(&ns_root); return chrooted; } bool fs_fully_visible(struct file_system_type type) { struct mnt_namespace ns = current->nsproxy->mnt_ns; struct mount mnt; bool visible = false; if (unlikely(!ns)) return false; down_read(&namespace_sem); list_for_each_entry(mnt, &ns->list, mnt_list) { struct mount child; if (mnt->mnt.mnt_sb->s_type != type) continue; / This mount is not fully visible if there are any child mounts * that cover anything except for empty directories. / list_for_each_entry(child, &mnt->mnt_mounts, mnt_child) { struct inode inode = child->mnt_mountpoint->d_inode; if (!S_ISDIR(inode->i_mode)) goto next; if (inode->i_nlink > 2) goto next; } visible = true; goto found; next: ; } found: up_read(&namespace_sem); return visible; } static void mntns_get(struct task_struct task) { struct mnt_namespace ns = NULL; struct nsproxy nsproxy; task_lock(task); nsproxy = task->nsproxy; if (nsproxy) { ns = nsproxy->mnt_ns; get_mnt_ns(ns); } task_unlock(task); return ns; } static void mntns_put(void ns) { put_mnt_ns(ns); } static int mntns_install(struct nsproxy nsproxy, void ns) { struct fs_struct fs = current->fs; struct mnt_namespace mnt_ns = ns; struct path root; if (!ns_capable(mnt_ns->user_ns, CAP_SYS_ADMIN) \|\| !ns_capable(current_user_ns(), CAP_SYS_CHROOT) \|\| !ns_capable(current_user_ns(), CAP_SYS_ADMIN)) return -EPERM; if (fs->users != 1) return -EINVAL; get_mnt_ns(mnt_ns); put_mnt_ns(nsproxy->mnt_ns); nsproxy->mnt_ns = mnt_ns; / Find the root / root.mnt = &mnt_ns->root->mnt; root.dentry = mnt_ns->root->mnt.mnt_root; path_get(&root); while(d_mountpoint(root.dentry) && follow_down_one(&root)) ; / Update the pwd and root / set_fs_pwd(fs, &root); set_fs_root(fs, &root); path_put(&root); return 0; } static unsigned int mntns_inum(void ns) { struct mnt_namespace *mnt_ns = ns; return mnt_ns->proc_inum; } const struct proc_ns_operations mntns_operations = { .name = "mnt", .type = CLONE_NEWNS, .get = mntns_get, .put = mntns_put, .install = mntns_install, .inum = mntns_inum, };	./CrossVul/dataset_final_sorted/CWE-264/c/good_2244_0
crossvul-cpp_data_bad_5861_9	/* * Cryptographic API. * * s390 implementation of the GHASH algorithm for GCM (Galois/Counter Mode). * * Copyright IBM Corp. 2011 * Author(s): Gerald Schaefer <gerald.schaefer@de.ibm.com> / #include <crypto/internal/hash.h> #include <linux/module.h> #include "crypt_s390.h" #define GHASH_BLOCK_SIZE 16 #define GHASH_DIGEST_SIZE 16 struct ghash_ctx { u8 icv[16]; u8 key[16]; }; struct ghash_desc_ctx { u8 buffer[GHASH_BLOCK_SIZE]; u32 bytes; }; static int ghash_init(struct shash_desc desc) { struct ghash_desc_ctx dctx = shash_desc_ctx(desc); memset(dctx, 0, sizeof(dctx)); return 0; } static int ghash_setkey(struct crypto_shash tfm, const u8 key, unsigned int keylen) { struct ghash_ctx ctx = crypto_shash_ctx(tfm); if (keylen != GHASH_BLOCK_SIZE) { crypto_shash_set_flags(tfm, CRYPTO_TFM_RES_BAD_KEY_LEN); return -EINVAL; } memcpy(ctx->key, key, GHASH_BLOCK_SIZE); memset(ctx->icv, 0, GHASH_BLOCK_SIZE); return 0; } static int ghash_update(struct shash_desc desc, const u8 src, unsigned int srclen) { struct ghash_desc_ctx dctx = shash_desc_ctx(desc); struct ghash_ctx ctx = crypto_shash_ctx(desc->tfm); unsigned int n; u8 buf = dctx->buffer; int ret; if (dctx->bytes) { u8 pos = buf + (GHASH_BLOCK_SIZE - dctx->bytes); n = min(srclen, dctx->bytes); dctx->bytes -= n; srclen -= n; memcpy(pos, src, n); src += n; if (!dctx->bytes) { ret = crypt_s390_kimd(KIMD_GHASH, ctx, buf, GHASH_BLOCK_SIZE); if (ret != GHASH_BLOCK_SIZE) return -EIO; } } n = srclen & ~(GHASH_BLOCK_SIZE - 1); if (n) { ret = crypt_s390_kimd(KIMD_GHASH, ctx, src, n); if (ret != n) return -EIO; src += n; srclen -= n; } if (srclen) { dctx->bytes = GHASH_BLOCK_SIZE - srclen; memcpy(buf, src, srclen); } return 0; } static int ghash_flush(struct ghash_ctx ctx, struct ghash_desc_ctx dctx) { u8 buf = dctx->buffer; int ret; if (dctx->bytes) { u8 pos = buf + (GHASH_BLOCK_SIZE - dctx->bytes); memset(pos, 0, dctx->bytes); ret = crypt_s390_kimd(KIMD_GHASH, ctx, buf, GHASH_BLOCK_SIZE); if (ret != GHASH_BLOCK_SIZE) return -EIO; } dctx->bytes = 0; return 0; } static int ghash_final(struct shash_desc desc, u8 dst) { struct ghash_desc_ctx dctx = shash_desc_ctx(desc); struct ghash_ctx *ctx = crypto_shash_ctx(desc->tfm); int ret; ret = ghash_flush(ctx, dctx); if (!ret) memcpy(dst, ctx->icv, GHASH_BLOCK_SIZE); return ret; } static struct shash_alg ghash_alg = { .digestsize = GHASH_DIGEST_SIZE, .init = ghash_init, .update = ghash_update, .final = ghash_final, .setkey = ghash_setkey, .descsize = sizeof(struct ghash_desc_ctx), .base = { .cra_name = "ghash", .cra_driver_name = "ghash-s390", .cra_priority = CRYPT_S390_PRIORITY, .cra_flags = CRYPTO_ALG_TYPE_SHASH, .cra_blocksize = GHASH_BLOCK_SIZE, .cra_ctxsize = sizeof(struct ghash_ctx), .cra_module = THIS_MODULE, }, }; static int __init ghash_mod_init(void) { if (!crypt_s390_func_available(KIMD_GHASH, CRYPT_S390_MSA \| CRYPT_S390_MSA4)) return -EOPNOTSUPP; return crypto_register_shash(&ghash_alg); } static void __exit ghash_mod_exit(void) { crypto_unregister_shash(&ghash_alg); } module_init(ghash_mod_init); module_exit(ghash_mod_exit); MODULE_ALIAS("ghash"); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("GHASH Message Digest Algorithm, s390 implementation");	./CrossVul/dataset_final_sorted/CWE-264/c/bad_5861_9
crossvul-cpp_data_bad_3646_0	/* D-Link DL2000-based Gigabit Ethernet Adapter Linux driver / / Copyright (c) 2001, 2002 by D-Link Corporation Written by Edward Peng.<edward_peng@dlink.com.tw> Created 03-May-2001, base on Linux' sundance.c. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. / #define DRV_NAME "DL2000/TC902x-based linux driver" #define DRV_VERSION "v1.19" #define DRV_RELDATE "2007/08/12" #include "dl2k.h" #include <linux/dma-mapping.h> static char version[] __devinitdata = KERN_INFO DRV_NAME " " DRV_VERSION " " DRV_RELDATE "\n"; #define MAX_UNITS 8 static int mtu[MAX_UNITS]; static int vlan[MAX_UNITS]; static int jumbo[MAX_UNITS]; static char media[MAX_UNITS]; static int tx_flow=-1; static int rx_flow=-1; static int copy_thresh; static int rx_coalesce=10; /* Rx frame count each interrupt / static int rx_timeout=200; / Rx DMA wait time in 640ns increments / static int tx_coalesce=16; / HW xmit count each TxDMAComplete / MODULE_AUTHOR ("Edward Peng"); MODULE_DESCRIPTION ("D-Link DL2000-based Gigabit Ethernet Adapter"); MODULE_LICENSE("GPL"); module_param_array(mtu, int, NULL, 0); module_param_array(media, charp, NULL, 0); module_param_array(vlan, int, NULL, 0); module_param_array(jumbo, int, NULL, 0); module_param(tx_flow, int, 0); module_param(rx_flow, int, 0); module_param(copy_thresh, int, 0); module_param(rx_coalesce, int, 0); / Rx frame count each interrupt / module_param(rx_timeout, int, 0); / Rx DMA wait time in 64ns increments / module_param(tx_coalesce, int, 0); / HW xmit count each TxDMAComplete / / Enable the default interrupts / #define DEFAULT_INTR (RxDMAComplete \| HostError \| IntRequested \| TxDMAComplete\| \ UpdateStats \| LinkEvent) #define EnableInt() \ writew(DEFAULT_INTR, ioaddr + IntEnable) static const int max_intrloop = 50; static const int multicast_filter_limit = 0x40; static int rio_open (struct net_device dev); static void rio_timer (unsigned long data); static void rio_tx_timeout (struct net_device dev); static void alloc_list (struct net_device dev); static netdev_tx_t start_xmit (struct sk_buff skb, struct net_device dev); static irqreturn_t rio_interrupt (int irq, void dev_instance); static void rio_free_tx (struct net_device dev, int irq); static void tx_error (struct net_device dev, int tx_status); static int receive_packet (struct net_device dev); static void rio_error (struct net_device dev, int int_status); static int change_mtu (struct net_device dev, int new_mtu); static void set_multicast (struct net_device dev); static struct net_device_stats get_stats (struct net_device dev); static int clear_stats (struct net_device dev); static int rio_ioctl (struct net_device dev, struct ifreq rq, int cmd); static int rio_close (struct net_device dev); static int find_miiphy (struct net_device dev); static int parse_eeprom (struct net_device dev); static int read_eeprom (long ioaddr, int eep_addr); static int mii_wait_link (struct net_device dev, int wait); static int mii_set_media (struct net_device dev); static int mii_get_media (struct net_device dev); static int mii_set_media_pcs (struct net_device dev); static int mii_get_media_pcs (struct net_device dev); static int mii_read (struct net_device dev, int phy_addr, int reg_num); static int mii_write (struct net_device dev, int phy_addr, int reg_num, u16 data); static const struct ethtool_ops ethtool_ops; static const struct net_device_ops netdev_ops = { .ndo_open = rio_open, .ndo_start_xmit = start_xmit, .ndo_stop = rio_close, .ndo_get_stats = get_stats, .ndo_validate_addr = eth_validate_addr, .ndo_set_mac_address = eth_mac_addr, .ndo_set_rx_mode = set_multicast, .ndo_do_ioctl = rio_ioctl, .ndo_tx_timeout = rio_tx_timeout, .ndo_change_mtu = change_mtu, }; static int __devinit rio_probe1 (struct pci_dev pdev, const struct pci_device_id ent) { struct net_device dev; struct netdev_private np; static int card_idx; int chip_idx = ent->driver_data; int err, irq; long ioaddr; static int version_printed; void ring_space; dma_addr_t ring_dma; if (!version_printed++) printk ("%s", version); err = pci_enable_device (pdev); if (err) return err; irq = pdev->irq; err = pci_request_regions (pdev, "dl2k"); if (err) goto err_out_disable; pci_set_master (pdev); dev = alloc_etherdev (sizeof (np)); if (!dev) { err = -ENOMEM; goto err_out_res; } SET_NETDEV_DEV(dev, &pdev->dev); #ifdef MEM_MAPPING ioaddr = pci_resource_start (pdev, 1); ioaddr = (long) ioremap (ioaddr, RIO_IO_SIZE); if (!ioaddr) { err = -ENOMEM; goto err_out_dev; } #else ioaddr = pci_resource_start (pdev, 0); #endif dev->base_addr = ioaddr; dev->irq = irq; np = netdev_priv(dev); np->chip_id = chip_idx; np->pdev = pdev; spin_lock_init (&np->tx_lock); spin_lock_init (&np->rx_lock); /* Parse manual configuration / np->an_enable = 1; np->tx_coalesce = 1; if (card_idx < MAX_UNITS) { if (media[card_idx] != NULL) { np->an_enable = 0; if (strcmp (media[card_idx], "auto") == 0 \|\| strcmp (media[card_idx], "autosense") == 0 \|\| strcmp (media[card_idx], "0") == 0 ) { np->an_enable = 2; } else if (strcmp (media[card_idx], "100mbps_fd") == 0 \|\| strcmp (media[card_idx], "4") == 0) { np->speed = 100; np->full_duplex = 1; } else if (strcmp (media[card_idx], "100mbps_hd") == 0 \|\| strcmp (media[card_idx], "3") == 0) { np->speed = 100; np->full_duplex = 0; } else if (strcmp (media[card_idx], "10mbps_fd") == 0 \|\| strcmp (media[card_idx], "2") == 0) { np->speed = 10; np->full_duplex = 1; } else if (strcmp (media[card_idx], "10mbps_hd") == 0 \|\| strcmp (media[card_idx], "1") == 0) { np->speed = 10; np->full_duplex = 0; } else if (strcmp (media[card_idx], "1000mbps_fd") == 0 \|\| strcmp (media[card_idx], "6") == 0) { np->speed=1000; np->full_duplex=1; } else if (strcmp (media[card_idx], "1000mbps_hd") == 0 \|\| strcmp (media[card_idx], "5") == 0) { np->speed = 1000; np->full_duplex = 0; } else { np->an_enable = 1; } } if (jumbo[card_idx] != 0) { np->jumbo = 1; dev->mtu = MAX_JUMBO; } else { np->jumbo = 0; if (mtu[card_idx] > 0 && mtu[card_idx] < PACKET_SIZE) dev->mtu = mtu[card_idx]; } np->vlan = (vlan[card_idx] > 0 && vlan[card_idx] < 4096) ? vlan[card_idx] : 0; if (rx_coalesce > 0 && rx_timeout > 0) { np->rx_coalesce = rx_coalesce; np->rx_timeout = rx_timeout; np->coalesce = 1; } np->tx_flow = (tx_flow == 0) ? 0 : 1; np->rx_flow = (rx_flow == 0) ? 0 : 1; if (tx_coalesce < 1) tx_coalesce = 1; else if (tx_coalesce > TX_RING_SIZE-1) tx_coalesce = TX_RING_SIZE - 1; } dev->netdev_ops = &netdev_ops; dev->watchdog_timeo = TX_TIMEOUT; SET_ETHTOOL_OPS(dev, &ethtool_ops); #if 0 dev->features = NETIF_F_IP_CSUM; #endif pci_set_drvdata (pdev, dev); ring_space = pci_alloc_consistent (pdev, TX_TOTAL_SIZE, &ring_dma); if (!ring_space) goto err_out_iounmap; np->tx_ring = ring_space; np->tx_ring_dma = ring_dma; ring_space = pci_alloc_consistent (pdev, RX_TOTAL_SIZE, &ring_dma); if (!ring_space) goto err_out_unmap_tx; np->rx_ring = ring_space; np->rx_ring_dma = ring_dma; / Parse eeprom data / parse_eeprom (dev); / Find PHY address / err = find_miiphy (dev); if (err) goto err_out_unmap_rx; / Fiber device? / np->phy_media = (readw(ioaddr + ASICCtrl) & PhyMedia) ? 1 : 0; np->link_status = 0; / Set media and reset PHY / if (np->phy_media) { / default Auto-Negotiation for fiber deivices / if (np->an_enable == 2) { np->an_enable = 1; } mii_set_media_pcs (dev); } else { / Auto-Negotiation is mandatory for 1000BASE-T, IEEE 802.3ab Annex 28D page 14 / if (np->speed == 1000) np->an_enable = 1; mii_set_media (dev); } err = register_netdev (dev); if (err) goto err_out_unmap_rx; card_idx++; printk (KERN_INFO "%s: %s, %pM, IRQ %d\n", dev->name, np->name, dev->dev_addr, irq); if (tx_coalesce > 1) printk(KERN_INFO "tx_coalesce:\t%d packets\n", tx_coalesce); if (np->coalesce) printk(KERN_INFO "rx_coalesce:\t%d packets\n" "rx_timeout: \t%d ns\n", np->rx_coalesce, np->rx_timeout640); if (np->vlan) printk(KERN_INFO "vlan(id):\t%d\n", np->vlan); return 0; err_out_unmap_rx: pci_free_consistent (pdev, RX_TOTAL_SIZE, np->rx_ring, np->rx_ring_dma); err_out_unmap_tx: pci_free_consistent (pdev, TX_TOTAL_SIZE, np->tx_ring, np->tx_ring_dma); err_out_iounmap: #ifdef MEM_MAPPING iounmap ((void ) ioaddr); err_out_dev: #endif free_netdev (dev); err_out_res: pci_release_regions (pdev); err_out_disable: pci_disable_device (pdev); return err; } static int find_miiphy (struct net_device dev) { int i, phy_found = 0; struct netdev_private np; long ioaddr; np = netdev_priv(dev); ioaddr = dev->base_addr; np->phy_addr = 1; for (i = 31; i >= 0; i--) { int mii_status = mii_read (dev, i, 1); if (mii_status != 0xffff && mii_status != 0x0000) { np->phy_addr = i; phy_found++; } } if (!phy_found) { printk (KERN_ERR "%s: No MII PHY found!\n", dev->name); return -ENODEV; } return 0; } static int parse_eeprom (struct net_device dev) { int i, j; long ioaddr = dev->base_addr; u8 sromdata[256]; u8 psib; u32 crc; PSROM_t psrom = (PSROM_t) sromdata; struct netdev_private np = netdev_priv(dev); int cid, next; #ifdef MEM_MAPPING ioaddr = pci_resource_start (np->pdev, 0); #endif /* Read eeprom / for (i = 0; i < 128; i++) { ((__le16 ) sromdata)[i] = cpu_to_le16(read_eeprom (ioaddr, i)); } #ifdef MEM_MAPPING ioaddr = dev->base_addr; #endif if (np->pdev->vendor == PCI_VENDOR_ID_DLINK) { /* D-Link Only / / Check CRC / crc = ~ether_crc_le (256 - 4, sromdata); if (psrom->crc != cpu_to_le32(crc)) { printk (KERN_ERR "%s: EEPROM data CRC error.\n", dev->name); return -1; } } / Set MAC address / for (i = 0; i < 6; i++) dev->dev_addr[i] = psrom->mac_addr[i]; if (np->pdev->vendor != PCI_VENDOR_ID_DLINK) { return 0; } / Parse Software Information Block / i = 0x30; psib = (u8 ) sromdata; do { cid = psib[i++]; next = psib[i++]; if ((cid == 0 && next == 0) \|\| (cid == 0xff && next == 0xff)) { printk (KERN_ERR "Cell data error\n"); return -1; } switch (cid) { case 0: /* Format version / break; case 1: / End of cell / return 0; case 2: / Duplex Polarity / np->duplex_polarity = psib[i]; writeb (readb (ioaddr + PhyCtrl) \| psib[i], ioaddr + PhyCtrl); break; case 3: / Wake Polarity / np->wake_polarity = psib[i]; break; case 9: / Adapter description / j = (next - i > 255) ? 255 : next - i; memcpy (np->name, &(psib[i]), j); break; case 4: case 5: case 6: case 7: case 8: / Reversed / break; default: / Unknown cell / return -1; } i = next; } while (1); return 0; } static int rio_open (struct net_device dev) { struct netdev_private np = netdev_priv(dev); long ioaddr = dev->base_addr; int i; u16 macctrl; i = request_irq (dev->irq, rio_interrupt, IRQF_SHARED, dev->name, dev); if (i) return i; / Reset all logic functions / writew (GlobalReset \| DMAReset \| FIFOReset \| NetworkReset \| HostReset, ioaddr + ASICCtrl + 2); mdelay(10); / DebugCtrl bit 4, 5, 9 must set / writel (readl (ioaddr + DebugCtrl) \| 0x0230, ioaddr + DebugCtrl); / Jumbo frame / if (np->jumbo != 0) writew (MAX_JUMBO+14, ioaddr + MaxFrameSize); alloc_list (dev); / Get station address / for (i = 0; i < 6; i++) writeb (dev->dev_addr[i], ioaddr + StationAddr0 + i); set_multicast (dev); if (np->coalesce) { writel (np->rx_coalesce \| np->rx_timeout << 16, ioaddr + RxDMAIntCtrl); } / Set RIO to poll every N320nsec. / writeb (0x20, ioaddr + RxDMAPollPeriod); writeb (0xff, ioaddr + TxDMAPollPeriod); writeb (0x30, ioaddr + RxDMABurstThresh); writeb (0x30, ioaddr + RxDMAUrgentThresh); writel (0x0007ffff, ioaddr + RmonStatMask); /* clear statistics / clear_stats (dev); / VLAN supported / if (np->vlan) { / priority field in RxDMAIntCtrl / writel (readl(ioaddr + RxDMAIntCtrl) \| 0x7 << 10, ioaddr + RxDMAIntCtrl); / VLANId / writew (np->vlan, ioaddr + VLANId); / Length/Type should be 0x8100 / writel (0x8100 << 16 \| np->vlan, ioaddr + VLANTag); / Enable AutoVLANuntagging, but disable AutoVLANtagging. VLAN information tagged by TFC' VID, CFI fields. / writel (readl (ioaddr + MACCtrl) \| AutoVLANuntagging, ioaddr + MACCtrl); } init_timer (&np->timer); np->timer.expires = jiffies + 1HZ; np->timer.data = (unsigned long) dev; np->timer.function = rio_timer; add_timer (&np->timer); /* Start Tx/Rx / writel (readl (ioaddr + MACCtrl) \| StatsEnable \| RxEnable \| TxEnable, ioaddr + MACCtrl); macctrl = 0; macctrl \|= (np->vlan) ? AutoVLANuntagging : 0; macctrl \|= (np->full_duplex) ? DuplexSelect : 0; macctrl \|= (np->tx_flow) ? TxFlowControlEnable : 0; macctrl \|= (np->rx_flow) ? RxFlowControlEnable : 0; writew(macctrl, ioaddr + MACCtrl); netif_start_queue (dev); / Enable default interrupts / EnableInt (); return 0; } static void rio_timer (unsigned long data) { struct net_device dev = (struct net_device )data; struct netdev_private np = netdev_priv(dev); unsigned int entry; int next_tick = 1HZ; unsigned long flags; spin_lock_irqsave(&np->rx_lock, flags); / Recover rx ring exhausted error / if (np->cur_rx - np->old_rx >= RX_RING_SIZE) { printk(KERN_INFO "Try to recover rx ring exhausted...\n"); / Re-allocate skbuffs to fill the descriptor ring / for (; np->cur_rx - np->old_rx > 0; np->old_rx++) { struct sk_buff skb; entry = np->old_rx % RX_RING_SIZE; /* Dropped packets don't need to re-allocate / if (np->rx_skbuff[entry] == NULL) { skb = netdev_alloc_skb_ip_align(dev, np->rx_buf_sz); if (skb == NULL) { np->rx_ring[entry].fraginfo = 0; printk (KERN_INFO "%s: Still unable to re-allocate Rx skbuff.#%d\n", dev->name, entry); break; } np->rx_skbuff[entry] = skb; np->rx_ring[entry].fraginfo = cpu_to_le64 (pci_map_single (np->pdev, skb->data, np->rx_buf_sz, PCI_DMA_FROMDEVICE)); } np->rx_ring[entry].fraginfo \|= cpu_to_le64((u64)np->rx_buf_sz << 48); np->rx_ring[entry].status = 0; } / end for / } / end if / spin_unlock_irqrestore (&np->rx_lock, flags); np->timer.expires = jiffies + next_tick; add_timer(&np->timer); } static void rio_tx_timeout (struct net_device dev) { long ioaddr = dev->base_addr; printk (KERN_INFO "%s: Tx timed out (%4.4x), is buffer full?\n", dev->name, readl (ioaddr + TxStatus)); rio_free_tx(dev, 0); dev->if_port = 0; dev->trans_start = jiffies; /* prevent tx timeout / } / allocate and initialize Tx and Rx descriptors / static void alloc_list (struct net_device dev) { struct netdev_private np = netdev_priv(dev); int i; np->cur_rx = np->cur_tx = 0; np->old_rx = np->old_tx = 0; np->rx_buf_sz = (dev->mtu <= 1500 ? PACKET_SIZE : dev->mtu + 32); / Initialize Tx descriptors, TFDListPtr leaves in start_xmit(). / for (i = 0; i < TX_RING_SIZE; i++) { np->tx_skbuff[i] = NULL; np->tx_ring[i].status = cpu_to_le64 (TFDDone); np->tx_ring[i].next_desc = cpu_to_le64 (np->tx_ring_dma + ((i+1)%TX_RING_SIZE) sizeof (struct netdev_desc)); } /* Initialize Rx descriptors / for (i = 0; i < RX_RING_SIZE; i++) { np->rx_ring[i].next_desc = cpu_to_le64 (np->rx_ring_dma + ((i + 1) % RX_RING_SIZE) sizeof (struct netdev_desc)); np->rx_ring[i].status = 0; np->rx_ring[i].fraginfo = 0; np->rx_skbuff[i] = NULL; } /* Allocate the rx buffers / for (i = 0; i < RX_RING_SIZE; i++) { / Allocated fixed size of skbuff / struct sk_buff skb; skb = netdev_alloc_skb_ip_align(dev, np->rx_buf_sz); np->rx_skbuff[i] = skb; if (skb == NULL) { printk (KERN_ERR "%s: alloc_list: allocate Rx buffer error! ", dev->name); break; } /* Rubicon now supports 40 bits of addressing space. / np->rx_ring[i].fraginfo = cpu_to_le64 ( pci_map_single ( np->pdev, skb->data, np->rx_buf_sz, PCI_DMA_FROMDEVICE)); np->rx_ring[i].fraginfo \|= cpu_to_le64((u64)np->rx_buf_sz << 48); } / Set RFDListPtr / writel (np->rx_ring_dma, dev->base_addr + RFDListPtr0); writel (0, dev->base_addr + RFDListPtr1); } static netdev_tx_t start_xmit (struct sk_buff skb, struct net_device dev) { struct netdev_private np = netdev_priv(dev); struct netdev_desc txdesc; unsigned entry; u32 ioaddr; u64 tfc_vlan_tag = 0; if (np->link_status == 0) { / Link Down / dev_kfree_skb(skb); return NETDEV_TX_OK; } ioaddr = dev->base_addr; entry = np->cur_tx % TX_RING_SIZE; np->tx_skbuff[entry] = skb; txdesc = &np->tx_ring[entry]; #if 0 if (skb->ip_summed == CHECKSUM_PARTIAL) { txdesc->status \|= cpu_to_le64 (TCPChecksumEnable \| UDPChecksumEnable \| IPChecksumEnable); } #endif if (np->vlan) { tfc_vlan_tag = VLANTagInsert \| ((u64)np->vlan << 32) \| ((u64)skb->priority << 45); } txdesc->fraginfo = cpu_to_le64 (pci_map_single (np->pdev, skb->data, skb->len, PCI_DMA_TODEVICE)); txdesc->fraginfo \|= cpu_to_le64((u64)skb->len << 48); / DL2K bug: DMA fails to get next descriptor ptr in 10Mbps mode * Work around: Always use 1 descriptor in 10Mbps mode / if (entry % np->tx_coalesce == 0 \|\| np->speed == 10) txdesc->status = cpu_to_le64 (entry \| tfc_vlan_tag \| WordAlignDisable \| TxDMAIndicate \| (1 << FragCountShift)); else txdesc->status = cpu_to_le64 (entry \| tfc_vlan_tag \| WordAlignDisable \| (1 << FragCountShift)); / TxDMAPollNow / writel (readl (ioaddr + DMACtrl) \| 0x00001000, ioaddr + DMACtrl); / Schedule ISR / writel(10000, ioaddr + CountDown); np->cur_tx = (np->cur_tx + 1) % TX_RING_SIZE; if ((np->cur_tx - np->old_tx + TX_RING_SIZE) % TX_RING_SIZE < TX_QUEUE_LEN - 1 && np->speed != 10) { / do nothing / } else if (!netif_queue_stopped(dev)) { netif_stop_queue (dev); } / The first TFDListPtr / if (readl (dev->base_addr + TFDListPtr0) == 0) { writel (np->tx_ring_dma + entry sizeof (struct netdev_desc), dev->base_addr + TFDListPtr0); writel (0, dev->base_addr + TFDListPtr1); } return NETDEV_TX_OK; } static irqreturn_t rio_interrupt (int irq, void dev_instance) { struct net_device dev = dev_instance; struct netdev_private np; unsigned int_status; long ioaddr; int cnt = max_intrloop; int handled = 0; ioaddr = dev->base_addr; np = netdev_priv(dev); while (1) { int_status = readw (ioaddr + IntStatus); writew (int_status, ioaddr + IntStatus); int_status &= DEFAULT_INTR; if (int_status == 0 \|\| --cnt < 0) break; handled = 1; / Processing received packets / if (int_status & RxDMAComplete) receive_packet (dev); / TxDMAComplete interrupt / if ((int_status & (TxDMAComplete\|IntRequested))) { int tx_status; tx_status = readl (ioaddr + TxStatus); if (tx_status & 0x01) tx_error (dev, tx_status); / Free used tx skbuffs / rio_free_tx (dev, 1); } / Handle uncommon events / if (int_status & (HostError \| LinkEvent \| UpdateStats)) rio_error (dev, int_status); } if (np->cur_tx != np->old_tx) writel (100, ioaddr + CountDown); return IRQ_RETVAL(handled); } static inline dma_addr_t desc_to_dma(struct netdev_desc desc) { return le64_to_cpu(desc->fraginfo) & DMA_BIT_MASK(48); } static void rio_free_tx (struct net_device dev, int irq) { struct netdev_private np = netdev_priv(dev); int entry = np->old_tx % TX_RING_SIZE; int tx_use = 0; unsigned long flag = 0; if (irq) spin_lock(&np->tx_lock); else spin_lock_irqsave(&np->tx_lock, flag); /* Free used tx skbuffs / while (entry != np->cur_tx) { struct sk_buff skb; if (!(np->tx_ring[entry].status & cpu_to_le64(TFDDone))) break; skb = np->tx_skbuff[entry]; pci_unmap_single (np->pdev, desc_to_dma(&np->tx_ring[entry]), skb->len, PCI_DMA_TODEVICE); if (irq) dev_kfree_skb_irq (skb); else dev_kfree_skb (skb); np->tx_skbuff[entry] = NULL; entry = (entry + 1) % TX_RING_SIZE; tx_use++; } if (irq) spin_unlock(&np->tx_lock); else spin_unlock_irqrestore(&np->tx_lock, flag); np->old_tx = entry; /* If the ring is no longer full, clear tx_full and call netif_wake_queue() / if (netif_queue_stopped(dev) && ((np->cur_tx - np->old_tx + TX_RING_SIZE) % TX_RING_SIZE < TX_QUEUE_LEN - 1 \|\| np->speed == 10)) { netif_wake_queue (dev); } } static void tx_error (struct net_device dev, int tx_status) { struct netdev_private np; long ioaddr = dev->base_addr; int frame_id; int i; np = netdev_priv(dev); frame_id = (tx_status & 0xffff0000); printk (KERN_ERR "%s: Transmit error, TxStatus %4.4x, FrameId %d.\n", dev->name, tx_status, frame_id); np->stats.tx_errors++; / Ttransmit Underrun / if (tx_status & 0x10) { np->stats.tx_fifo_errors++; writew (readw (ioaddr + TxStartThresh) + 0x10, ioaddr + TxStartThresh); / Transmit Underrun need to set TxReset, DMARest, FIFOReset / writew (TxReset \| DMAReset \| FIFOReset \| NetworkReset, ioaddr + ASICCtrl + 2); / Wait for ResetBusy bit clear / for (i = 50; i > 0; i--) { if ((readw (ioaddr + ASICCtrl + 2) & ResetBusy) == 0) break; mdelay (1); } rio_free_tx (dev, 1); / Reset TFDListPtr / writel (np->tx_ring_dma + np->old_tx sizeof (struct netdev_desc), dev->base_addr + TFDListPtr0); writel (0, dev->base_addr + TFDListPtr1); /* Let TxStartThresh stay default value / } / Late Collision / if (tx_status & 0x04) { np->stats.tx_fifo_errors++; / TxReset and clear FIFO / writew (TxReset \| FIFOReset, ioaddr + ASICCtrl + 2); / Wait reset done / for (i = 50; i > 0; i--) { if ((readw (ioaddr + ASICCtrl + 2) & ResetBusy) == 0) break; mdelay (1); } / Let TxStartThresh stay default value / } / Maximum Collisions / #ifdef ETHER_STATS if (tx_status & 0x08) np->stats.collisions16++; #else if (tx_status & 0x08) np->stats.collisions++; #endif / Restart the Tx / writel (readw (dev->base_addr + MACCtrl) \| TxEnable, ioaddr + MACCtrl); } static int receive_packet (struct net_device dev) { struct netdev_private np = netdev_priv(dev); int entry = np->cur_rx % RX_RING_SIZE; int cnt = 30; / If RFDDone, FrameStart and FrameEnd set, there is a new packet in. / while (1) { struct netdev_desc desc = &np->rx_ring[entry]; int pkt_len; u64 frame_status; if (!(desc->status & cpu_to_le64(RFDDone)) \|\| !(desc->status & cpu_to_le64(FrameStart)) \|\| !(desc->status & cpu_to_le64(FrameEnd))) break; /* Chip omits the CRC. / frame_status = le64_to_cpu(desc->status); pkt_len = frame_status & 0xffff; if (--cnt < 0) break; / Update rx error statistics, drop packet. / if (frame_status & RFS_Errors) { np->stats.rx_errors++; if (frame_status & (RxRuntFrame \| RxLengthError)) np->stats.rx_length_errors++; if (frame_status & RxFCSError) np->stats.rx_crc_errors++; if (frame_status & RxAlignmentError && np->speed != 1000) np->stats.rx_frame_errors++; if (frame_status & RxFIFOOverrun) np->stats.rx_fifo_errors++; } else { struct sk_buff skb; /* Small skbuffs for short packets / if (pkt_len > copy_thresh) { pci_unmap_single (np->pdev, desc_to_dma(desc), np->rx_buf_sz, PCI_DMA_FROMDEVICE); skb_put (skb = np->rx_skbuff[entry], pkt_len); np->rx_skbuff[entry] = NULL; } else if ((skb = netdev_alloc_skb_ip_align(dev, pkt_len))) { pci_dma_sync_single_for_cpu(np->pdev, desc_to_dma(desc), np->rx_buf_sz, PCI_DMA_FROMDEVICE); skb_copy_to_linear_data (skb, np->rx_skbuff[entry]->data, pkt_len); skb_put (skb, pkt_len); pci_dma_sync_single_for_device(np->pdev, desc_to_dma(desc), np->rx_buf_sz, PCI_DMA_FROMDEVICE); } skb->protocol = eth_type_trans (skb, dev); #if 0 / Checksum done by hw, but csum value unavailable. / if (np->pdev->pci_rev_id >= 0x0c && !(frame_status & (TCPError \| UDPError \| IPError))) { skb->ip_summed = CHECKSUM_UNNECESSARY; } #endif netif_rx (skb); } entry = (entry + 1) % RX_RING_SIZE; } spin_lock(&np->rx_lock); np->cur_rx = entry; / Re-allocate skbuffs to fill the descriptor ring / entry = np->old_rx; while (entry != np->cur_rx) { struct sk_buff skb; /* Dropped packets don't need to re-allocate / if (np->rx_skbuff[entry] == NULL) { skb = netdev_alloc_skb_ip_align(dev, np->rx_buf_sz); if (skb == NULL) { np->rx_ring[entry].fraginfo = 0; printk (KERN_INFO "%s: receive_packet: " "Unable to re-allocate Rx skbuff.#%d\n", dev->name, entry); break; } np->rx_skbuff[entry] = skb; np->rx_ring[entry].fraginfo = cpu_to_le64 (pci_map_single (np->pdev, skb->data, np->rx_buf_sz, PCI_DMA_FROMDEVICE)); } np->rx_ring[entry].fraginfo \|= cpu_to_le64((u64)np->rx_buf_sz << 48); np->rx_ring[entry].status = 0; entry = (entry + 1) % RX_RING_SIZE; } np->old_rx = entry; spin_unlock(&np->rx_lock); return 0; } static void rio_error (struct net_device dev, int int_status) { long ioaddr = dev->base_addr; struct netdev_private np = netdev_priv(dev); u16 macctrl; / Link change event / if (int_status & LinkEvent) { if (mii_wait_link (dev, 10) == 0) { printk (KERN_INFO "%s: Link up\n", dev->name); if (np->phy_media) mii_get_media_pcs (dev); else mii_get_media (dev); if (np->speed == 1000) np->tx_coalesce = tx_coalesce; else np->tx_coalesce = 1; macctrl = 0; macctrl \|= (np->vlan) ? AutoVLANuntagging : 0; macctrl \|= (np->full_duplex) ? DuplexSelect : 0; macctrl \|= (np->tx_flow) ? TxFlowControlEnable : 0; macctrl \|= (np->rx_flow) ? RxFlowControlEnable : 0; writew(macctrl, ioaddr + MACCtrl); np->link_status = 1; netif_carrier_on(dev); } else { printk (KERN_INFO "%s: Link off\n", dev->name); np->link_status = 0; netif_carrier_off(dev); } } / UpdateStats statistics registers / if (int_status & UpdateStats) { get_stats (dev); } / PCI Error, a catastronphic error related to the bus interface occurs, set GlobalReset and HostReset to reset. / if (int_status & HostError) { printk (KERN_ERR "%s: HostError! IntStatus %4.4x.\n", dev->name, int_status); writew (GlobalReset \| HostReset, ioaddr + ASICCtrl + 2); mdelay (500); } } static struct net_device_stats get_stats (struct net_device dev) { long ioaddr = dev->base_addr; struct netdev_private np = netdev_priv(dev); #ifdef MEM_MAPPING int i; #endif unsigned int stat_reg; /* All statistics registers need to be acknowledged, else statistic overflow could cause problems / np->stats.rx_packets += readl (ioaddr + FramesRcvOk); np->stats.tx_packets += readl (ioaddr + FramesXmtOk); np->stats.rx_bytes += readl (ioaddr + OctetRcvOk); np->stats.tx_bytes += readl (ioaddr + OctetXmtOk); np->stats.multicast = readl (ioaddr + McstFramesRcvdOk); np->stats.collisions += readl (ioaddr + SingleColFrames) + readl (ioaddr + MultiColFrames); / detailed tx errors / stat_reg = readw (ioaddr + FramesAbortXSColls); np->stats.tx_aborted_errors += stat_reg; np->stats.tx_errors += stat_reg; stat_reg = readw (ioaddr + CarrierSenseErrors); np->stats.tx_carrier_errors += stat_reg; np->stats.tx_errors += stat_reg; / Clear all other statistic register. / readl (ioaddr + McstOctetXmtOk); readw (ioaddr + BcstFramesXmtdOk); readl (ioaddr + McstFramesXmtdOk); readw (ioaddr + BcstFramesRcvdOk); readw (ioaddr + MacControlFramesRcvd); readw (ioaddr + FrameTooLongErrors); readw (ioaddr + InRangeLengthErrors); readw (ioaddr + FramesCheckSeqErrors); readw (ioaddr + FramesLostRxErrors); readl (ioaddr + McstOctetXmtOk); readl (ioaddr + BcstOctetXmtOk); readl (ioaddr + McstFramesXmtdOk); readl (ioaddr + FramesWDeferredXmt); readl (ioaddr + LateCollisions); readw (ioaddr + BcstFramesXmtdOk); readw (ioaddr + MacControlFramesXmtd); readw (ioaddr + FramesWEXDeferal); #ifdef MEM_MAPPING for (i = 0x100; i <= 0x150; i += 4) readl (ioaddr + i); #endif readw (ioaddr + TxJumboFrames); readw (ioaddr + RxJumboFrames); readw (ioaddr + TCPCheckSumErrors); readw (ioaddr + UDPCheckSumErrors); readw (ioaddr + IPCheckSumErrors); return &np->stats; } static int clear_stats (struct net_device dev) { long ioaddr = dev->base_addr; #ifdef MEM_MAPPING int i; #endif /* All statistics registers need to be acknowledged, else statistic overflow could cause problems / readl (ioaddr + FramesRcvOk); readl (ioaddr + FramesXmtOk); readl (ioaddr + OctetRcvOk); readl (ioaddr + OctetXmtOk); readl (ioaddr + McstFramesRcvdOk); readl (ioaddr + SingleColFrames); readl (ioaddr + MultiColFrames); readl (ioaddr + LateCollisions); / detailed rx errors / readw (ioaddr + FrameTooLongErrors); readw (ioaddr + InRangeLengthErrors); readw (ioaddr + FramesCheckSeqErrors); readw (ioaddr + FramesLostRxErrors); / detailed tx errors / readw (ioaddr + FramesAbortXSColls); readw (ioaddr + CarrierSenseErrors); / Clear all other statistic register. / readl (ioaddr + McstOctetXmtOk); readw (ioaddr + BcstFramesXmtdOk); readl (ioaddr + McstFramesXmtdOk); readw (ioaddr + BcstFramesRcvdOk); readw (ioaddr + MacControlFramesRcvd); readl (ioaddr + McstOctetXmtOk); readl (ioaddr + BcstOctetXmtOk); readl (ioaddr + McstFramesXmtdOk); readl (ioaddr + FramesWDeferredXmt); readw (ioaddr + BcstFramesXmtdOk); readw (ioaddr + MacControlFramesXmtd); readw (ioaddr + FramesWEXDeferal); #ifdef MEM_MAPPING for (i = 0x100; i <= 0x150; i += 4) readl (ioaddr + i); #endif readw (ioaddr + TxJumboFrames); readw (ioaddr + RxJumboFrames); readw (ioaddr + TCPCheckSumErrors); readw (ioaddr + UDPCheckSumErrors); readw (ioaddr + IPCheckSumErrors); return 0; } static int change_mtu (struct net_device dev, int new_mtu) { struct netdev_private np = netdev_priv(dev); int max = (np->jumbo) ? MAX_JUMBO : 1536; if ((new_mtu < 68) \|\| (new_mtu > max)) { return -EINVAL; } dev->mtu = new_mtu; return 0; } static void set_multicast (struct net_device dev) { long ioaddr = dev->base_addr; u32 hash_table[2]; u16 rx_mode = 0; struct netdev_private np = netdev_priv(dev); hash_table[0] = hash_table[1] = 0; / RxFlowcontrol DA: 01-80-C2-00-00-01. Hash index=0x39 / hash_table[1] \|= 0x02000000; if (dev->flags & IFF_PROMISC) { / Receive all frames promiscuously. / rx_mode = ReceiveAllFrames; } else if ((dev->flags & IFF_ALLMULTI) \|\| (netdev_mc_count(dev) > multicast_filter_limit)) { / Receive broadcast and multicast frames / rx_mode = ReceiveBroadcast \| ReceiveMulticast \| ReceiveUnicast; } else if (!netdev_mc_empty(dev)) { struct netdev_hw_addr ha; /* Receive broadcast frames and multicast frames filtering by Hashtable / rx_mode = ReceiveBroadcast \| ReceiveMulticastHash \| ReceiveUnicast; netdev_for_each_mc_addr(ha, dev) { int bit, index = 0; int crc = ether_crc_le(ETH_ALEN, ha->addr); / The inverted high significant 6 bits of CRC are used as an index to hashtable / for (bit = 0; bit < 6; bit++) if (crc & (1 << (31 - bit))) index \|= (1 << bit); hash_table[index / 32] \|= (1 << (index % 32)); } } else { rx_mode = ReceiveBroadcast \| ReceiveUnicast; } if (np->vlan) { / ReceiveVLANMatch field in ReceiveMode / rx_mode \|= ReceiveVLANMatch; } writel (hash_table[0], ioaddr + HashTable0); writel (hash_table[1], ioaddr + HashTable1); writew (rx_mode, ioaddr + ReceiveMode); } static void rio_get_drvinfo(struct net_device dev, struct ethtool_drvinfo info) { struct netdev_private np = netdev_priv(dev); strcpy(info->driver, "dl2k"); strcpy(info->version, DRV_VERSION); strcpy(info->bus_info, pci_name(np->pdev)); } static int rio_get_settings(struct net_device dev, struct ethtool_cmd cmd) { struct netdev_private np = netdev_priv(dev); if (np->phy_media) { / fiber device / cmd->supported = SUPPORTED_Autoneg \| SUPPORTED_FIBRE; cmd->advertising= ADVERTISED_Autoneg \| ADVERTISED_FIBRE; cmd->port = PORT_FIBRE; cmd->transceiver = XCVR_INTERNAL; } else { / copper device / cmd->supported = SUPPORTED_10baseT_Half \| SUPPORTED_10baseT_Full \| SUPPORTED_100baseT_Half \| SUPPORTED_100baseT_Full \| SUPPORTED_1000baseT_Full \| SUPPORTED_Autoneg \| SUPPORTED_MII; cmd->advertising = ADVERTISED_10baseT_Half \| ADVERTISED_10baseT_Full \| ADVERTISED_100baseT_Half \| ADVERTISED_100baseT_Full \| ADVERTISED_1000baseT_Full\| ADVERTISED_Autoneg \| ADVERTISED_MII; cmd->port = PORT_MII; cmd->transceiver = XCVR_INTERNAL; } if ( np->link_status ) { ethtool_cmd_speed_set(cmd, np->speed); cmd->duplex = np->full_duplex ? DUPLEX_FULL : DUPLEX_HALF; } else { ethtool_cmd_speed_set(cmd, -1); cmd->duplex = -1; } if ( np->an_enable) cmd->autoneg = AUTONEG_ENABLE; else cmd->autoneg = AUTONEG_DISABLE; cmd->phy_address = np->phy_addr; return 0; } static int rio_set_settings(struct net_device dev, struct ethtool_cmd cmd) { struct netdev_private np = netdev_priv(dev); netif_carrier_off(dev); if (cmd->autoneg == AUTONEG_ENABLE) { if (np->an_enable) return 0; else { np->an_enable = 1; mii_set_media(dev); return 0; } } else { np->an_enable = 0; if (np->speed == 1000) { ethtool_cmd_speed_set(cmd, SPEED_100); cmd->duplex = DUPLEX_FULL; printk("Warning!! Can't disable Auto negotiation in 1000Mbps, change to Manual 100Mbps, Full duplex.\n"); } switch (ethtool_cmd_speed(cmd)) { case SPEED_10: np->speed = 10; np->full_duplex = (cmd->duplex == DUPLEX_FULL); break; case SPEED_100: np->speed = 100; np->full_duplex = (cmd->duplex == DUPLEX_FULL); break; case SPEED_1000: /* not supported / default: return -EINVAL; } mii_set_media(dev); } return 0; } static u32 rio_get_link(struct net_device dev) { struct netdev_private np = netdev_priv(dev); return np->link_status; } static const struct ethtool_ops ethtool_ops = { .get_drvinfo = rio_get_drvinfo, .get_settings = rio_get_settings, .set_settings = rio_set_settings, .get_link = rio_get_link, }; static int rio_ioctl (struct net_device dev, struct ifreq rq, int cmd) { int phy_addr; struct netdev_private np = netdev_priv(dev); struct mii_data miidata = (struct mii_data ) &rq->ifr_ifru; struct netdev_desc desc; int i; phy_addr = np->phy_addr; switch (cmd) { case SIOCDEVPRIVATE: break; case SIOCDEVPRIVATE + 1: miidata->out_value = mii_read (dev, phy_addr, miidata->reg_num); break; case SIOCDEVPRIVATE + 2: mii_write (dev, phy_addr, miidata->reg_num, miidata->in_value); break; case SIOCDEVPRIVATE + 3: break; case SIOCDEVPRIVATE + 4: break; case SIOCDEVPRIVATE + 5: netif_stop_queue (dev); break; case SIOCDEVPRIVATE + 6: netif_wake_queue (dev); break; case SIOCDEVPRIVATE + 7: printk ("tx_full=%x cur_tx=%lx old_tx=%lx cur_rx=%lx old_rx=%lx\n", netif_queue_stopped(dev), np->cur_tx, np->old_tx, np->cur_rx, np->old_rx); break; case SIOCDEVPRIVATE + 8: printk("TX ring:\n"); for (i = 0; i < TX_RING_SIZE; i++) { desc = &np->tx_ring[i]; printk ("%02x:cur:%08x next:%08x status:%08x frag1:%08x frag0:%08x", i, (u32) (np->tx_ring_dma + i sizeof (desc)), (u32)le64_to_cpu(desc->next_desc), (u32)le64_to_cpu(desc->status), (u32)(le64_to_cpu(desc->fraginfo) >> 32), (u32)le64_to_cpu(desc->fraginfo)); printk ("\n"); } printk ("\n"); break; default: return -EOPNOTSUPP; } return 0; } #define EEP_READ 0x0200 #define EEP_BUSY 0x8000 / Read the EEPROM word / / We use I/O instruction to read/write eeprom to avoid fail on some machines / static int read_eeprom (long ioaddr, int eep_addr) { int i = 1000; outw (EEP_READ \| (eep_addr & 0xff), ioaddr + EepromCtrl); while (i-- > 0) { if (!(inw (ioaddr + EepromCtrl) & EEP_BUSY)) { return inw (ioaddr + EepromData); } } return 0; } enum phy_ctrl_bits { MII_READ = 0x00, MII_CLK = 0x01, MII_DATA1 = 0x02, MII_WRITE = 0x04, MII_DUPLEX = 0x08, }; #define mii_delay() readb(ioaddr) static void mii_sendbit (struct net_device dev, u32 data) { long ioaddr = dev->base_addr + PhyCtrl; data = (data) ? MII_DATA1 : 0; data \|= MII_WRITE; data \|= (readb (ioaddr) & 0xf8) \| MII_WRITE; writeb (data, ioaddr); mii_delay (); writeb (data \| MII_CLK, ioaddr); mii_delay (); } static int mii_getbit (struct net_device dev) { long ioaddr = dev->base_addr + PhyCtrl; u8 data; data = (readb (ioaddr) & 0xf8) \| MII_READ; writeb (data, ioaddr); mii_delay (); writeb (data \| MII_CLK, ioaddr); mii_delay (); return ((readb (ioaddr) >> 1) & 1); } static void mii_send_bits (struct net_device dev, u32 data, int len) { int i; for (i = len - 1; i >= 0; i--) { mii_sendbit (dev, data & (1 << i)); } } static int mii_read (struct net_device dev, int phy_addr, int reg_num) { u32 cmd; int i; u32 retval = 0; / Preamble / mii_send_bits (dev, 0xffffffff, 32); / ST(2), OP(2), ADDR(5), REG#(5), TA(2), Data(16) total 32 bits / / ST,OP = 0110'b for read operation / cmd = (0x06 << 10 \| phy_addr << 5 \| reg_num); mii_send_bits (dev, cmd, 14); / Turnaround / if (mii_getbit (dev)) goto err_out; / Read data / for (i = 0; i < 16; i++) { retval \|= mii_getbit (dev); retval <<= 1; } / End cycle / mii_getbit (dev); return (retval >> 1) & 0xffff; err_out: return 0; } static int mii_write (struct net_device dev, int phy_addr, int reg_num, u16 data) { u32 cmd; /* Preamble / mii_send_bits (dev, 0xffffffff, 32); / ST(2), OP(2), ADDR(5), REG#(5), TA(2), Data(16) total 32 bits / / ST,OP,AAAAA,RRRRR,TA = 0101xxxxxxxxxx10'b = 0x5002 for write / cmd = (0x5002 << 16) \| (phy_addr << 23) \| (reg_num << 18) \| data; mii_send_bits (dev, cmd, 32); / End cycle / mii_getbit (dev); return 0; } static int mii_wait_link (struct net_device dev, int wait) { __u16 bmsr; int phy_addr; struct netdev_private np; np = netdev_priv(dev); phy_addr = np->phy_addr; do { bmsr = mii_read (dev, phy_addr, MII_BMSR); if (bmsr & BMSR_LSTATUS) return 0; mdelay (1); } while (--wait > 0); return -1; } static int mii_get_media (struct net_device dev) { __u16 negotiate; __u16 bmsr; __u16 mscr; __u16 mssr; int phy_addr; struct netdev_private np; np = netdev_priv(dev); phy_addr = np->phy_addr; bmsr = mii_read (dev, phy_addr, MII_BMSR); if (np->an_enable) { if (!(bmsr & BMSR_ANEGCOMPLETE)) { / Auto-Negotiation not completed / return -1; } negotiate = mii_read (dev, phy_addr, MII_ADVERTISE) & mii_read (dev, phy_addr, MII_LPA); mscr = mii_read (dev, phy_addr, MII_CTRL1000); mssr = mii_read (dev, phy_addr, MII_STAT1000); if (mscr & ADVERTISE_1000FULL && mssr & LPA_1000FULL) { np->speed = 1000; np->full_duplex = 1; printk (KERN_INFO "Auto 1000 Mbps, Full duplex\n"); } else if (mscr & ADVERTISE_1000HALF && mssr & LPA_1000HALF) { np->speed = 1000; np->full_duplex = 0; printk (KERN_INFO "Auto 1000 Mbps, Half duplex\n"); } else if (negotiate & ADVERTISE_100FULL) { np->speed = 100; np->full_duplex = 1; printk (KERN_INFO "Auto 100 Mbps, Full duplex\n"); } else if (negotiate & ADVERTISE_100HALF) { np->speed = 100; np->full_duplex = 0; printk (KERN_INFO "Auto 100 Mbps, Half duplex\n"); } else if (negotiate & ADVERTISE_10FULL) { np->speed = 10; np->full_duplex = 1; printk (KERN_INFO "Auto 10 Mbps, Full duplex\n"); } else if (negotiate & ADVERTISE_10HALF) { np->speed = 10; np->full_duplex = 0; printk (KERN_INFO "Auto 10 Mbps, Half duplex\n"); } if (negotiate & ADVERTISE_PAUSE_CAP) { np->tx_flow &= 1; np->rx_flow &= 1; } else if (negotiate & ADVERTISE_PAUSE_ASYM) { np->tx_flow = 0; np->rx_flow &= 1; } / else tx_flow, rx_flow = user select / } else { __u16 bmcr = mii_read (dev, phy_addr, MII_BMCR); switch (bmcr & (BMCR_SPEED100 \| BMCR_SPEED1000)) { case BMCR_SPEED1000: printk (KERN_INFO "Operating at 1000 Mbps, "); break; case BMCR_SPEED100: printk (KERN_INFO "Operating at 100 Mbps, "); break; case 0: printk (KERN_INFO "Operating at 10 Mbps, "); } if (bmcr & BMCR_FULLDPLX) { printk (KERN_CONT "Full duplex\n"); } else { printk (KERN_CONT "Half duplex\n"); } } if (np->tx_flow) printk(KERN_INFO "Enable Tx Flow Control\n"); else printk(KERN_INFO "Disable Tx Flow Control\n"); if (np->rx_flow) printk(KERN_INFO "Enable Rx Flow Control\n"); else printk(KERN_INFO "Disable Rx Flow Control\n"); return 0; } static int mii_set_media (struct net_device dev) { __u16 pscr; __u16 bmcr; __u16 bmsr; __u16 anar; int phy_addr; struct netdev_private np; np = netdev_priv(dev); phy_addr = np->phy_addr; / Does user set speed? / if (np->an_enable) { / Advertise capabilities / bmsr = mii_read (dev, phy_addr, MII_BMSR); anar = mii_read (dev, phy_addr, MII_ADVERTISE) & ~(ADVERTISE_100FULL \| ADVERTISE_10FULL \| ADVERTISE_100HALF \| ADVERTISE_10HALF \| ADVERTISE_100BASE4); if (bmsr & BMSR_100FULL) anar \|= ADVERTISE_100FULL; if (bmsr & BMSR_100HALF) anar \|= ADVERTISE_100HALF; if (bmsr & BMSR_100BASE4) anar \|= ADVERTISE_100BASE4; if (bmsr & BMSR_10FULL) anar \|= ADVERTISE_10FULL; if (bmsr & BMSR_10HALF) anar \|= ADVERTISE_10HALF; anar \|= ADVERTISE_PAUSE_CAP \| ADVERTISE_PAUSE_ASYM; mii_write (dev, phy_addr, MII_ADVERTISE, anar); / Enable Auto crossover / pscr = mii_read (dev, phy_addr, MII_PHY_SCR); pscr \|= 3 << 5; / 11'b / mii_write (dev, phy_addr, MII_PHY_SCR, pscr); / Soft reset PHY / mii_write (dev, phy_addr, MII_BMCR, BMCR_RESET); bmcr = BMCR_ANENABLE \| BMCR_ANRESTART \| BMCR_RESET; mii_write (dev, phy_addr, MII_BMCR, bmcr); mdelay(1); } else { / Force speed setting / / 1) Disable Auto crossover / pscr = mii_read (dev, phy_addr, MII_PHY_SCR); pscr &= ~(3 << 5); mii_write (dev, phy_addr, MII_PHY_SCR, pscr); / 2) PHY Reset / bmcr = mii_read (dev, phy_addr, MII_BMCR); bmcr \|= BMCR_RESET; mii_write (dev, phy_addr, MII_BMCR, bmcr); / 3) Power Down / bmcr = 0x1940; / must be 0x1940 / mii_write (dev, phy_addr, MII_BMCR, bmcr); mdelay (100); / wait a certain time / / 4) Advertise nothing / mii_write (dev, phy_addr, MII_ADVERTISE, 0); / 5) Set media and Power Up / bmcr = BMCR_PDOWN; if (np->speed == 100) { bmcr \|= BMCR_SPEED100; printk (KERN_INFO "Manual 100 Mbps, "); } else if (np->speed == 10) { printk (KERN_INFO "Manual 10 Mbps, "); } if (np->full_duplex) { bmcr \|= BMCR_FULLDPLX; printk (KERN_CONT "Full duplex\n"); } else { printk (KERN_CONT "Half duplex\n"); } #if 0 / Set 1000BaseT Master/Slave setting / mscr = mii_read (dev, phy_addr, MII_CTRL1000); mscr \|= MII_MSCR_CFG_ENABLE; mscr &= ~MII_MSCR_CFG_VALUE = 0; #endif mii_write (dev, phy_addr, MII_BMCR, bmcr); mdelay(10); } return 0; } static int mii_get_media_pcs (struct net_device dev) { __u16 negotiate; __u16 bmsr; int phy_addr; struct netdev_private np; np = netdev_priv(dev); phy_addr = np->phy_addr; bmsr = mii_read (dev, phy_addr, PCS_BMSR); if (np->an_enable) { if (!(bmsr & BMSR_ANEGCOMPLETE)) { / Auto-Negotiation not completed / return -1; } negotiate = mii_read (dev, phy_addr, PCS_ANAR) & mii_read (dev, phy_addr, PCS_ANLPAR); np->speed = 1000; if (negotiate & PCS_ANAR_FULL_DUPLEX) { printk (KERN_INFO "Auto 1000 Mbps, Full duplex\n"); np->full_duplex = 1; } else { printk (KERN_INFO "Auto 1000 Mbps, half duplex\n"); np->full_duplex = 0; } if (negotiate & PCS_ANAR_PAUSE) { np->tx_flow &= 1; np->rx_flow &= 1; } else if (negotiate & PCS_ANAR_ASYMMETRIC) { np->tx_flow = 0; np->rx_flow &= 1; } / else tx_flow, rx_flow = user select / } else { __u16 bmcr = mii_read (dev, phy_addr, PCS_BMCR); printk (KERN_INFO "Operating at 1000 Mbps, "); if (bmcr & BMCR_FULLDPLX) { printk (KERN_CONT "Full duplex\n"); } else { printk (KERN_CONT "Half duplex\n"); } } if (np->tx_flow) printk(KERN_INFO "Enable Tx Flow Control\n"); else printk(KERN_INFO "Disable Tx Flow Control\n"); if (np->rx_flow) printk(KERN_INFO "Enable Rx Flow Control\n"); else printk(KERN_INFO "Disable Rx Flow Control\n"); return 0; } static int mii_set_media_pcs (struct net_device dev) { __u16 bmcr; __u16 esr; __u16 anar; int phy_addr; struct netdev_private np; np = netdev_priv(dev); phy_addr = np->phy_addr; / Auto-Negotiation? / if (np->an_enable) { / Advertise capabilities / esr = mii_read (dev, phy_addr, PCS_ESR); anar = mii_read (dev, phy_addr, MII_ADVERTISE) & ~PCS_ANAR_HALF_DUPLEX & ~PCS_ANAR_FULL_DUPLEX; if (esr & (MII_ESR_1000BT_HD \| MII_ESR_1000BX_HD)) anar \|= PCS_ANAR_HALF_DUPLEX; if (esr & (MII_ESR_1000BT_FD \| MII_ESR_1000BX_FD)) anar \|= PCS_ANAR_FULL_DUPLEX; anar \|= PCS_ANAR_PAUSE \| PCS_ANAR_ASYMMETRIC; mii_write (dev, phy_addr, MII_ADVERTISE, anar); / Soft reset PHY / mii_write (dev, phy_addr, MII_BMCR, BMCR_RESET); bmcr = BMCR_ANENABLE \| BMCR_ANRESTART \| BMCR_RESET; mii_write (dev, phy_addr, MII_BMCR, bmcr); mdelay(1); } else { / Force speed setting / / PHY Reset / bmcr = BMCR_RESET; mii_write (dev, phy_addr, MII_BMCR, bmcr); mdelay(10); if (np->full_duplex) { bmcr = BMCR_FULLDPLX; printk (KERN_INFO "Manual full duplex\n"); } else { bmcr = 0; printk (KERN_INFO "Manual half duplex\n"); } mii_write (dev, phy_addr, MII_BMCR, bmcr); mdelay(10); / Advertise nothing / mii_write (dev, phy_addr, MII_ADVERTISE, 0); } return 0; } static int rio_close (struct net_device dev) { long ioaddr = dev->base_addr; struct netdev_private np = netdev_priv(dev); struct sk_buff skb; int i; netif_stop_queue (dev); /* Disable interrupts / writew (0, ioaddr + IntEnable); / Stop Tx and Rx logics / writel (TxDisable \| RxDisable \| StatsDisable, ioaddr + MACCtrl); free_irq (dev->irq, dev); del_timer_sync (&np->timer); / Free all the skbuffs in the queue. / for (i = 0; i < RX_RING_SIZE; i++) { skb = np->rx_skbuff[i]; if (skb) { pci_unmap_single(np->pdev, desc_to_dma(&np->rx_ring[i]), skb->len, PCI_DMA_FROMDEVICE); dev_kfree_skb (skb); np->rx_skbuff[i] = NULL; } np->rx_ring[i].status = 0; np->rx_ring[i].fraginfo = 0; } for (i = 0; i < TX_RING_SIZE; i++) { skb = np->tx_skbuff[i]; if (skb) { pci_unmap_single(np->pdev, desc_to_dma(&np->tx_ring[i]), skb->len, PCI_DMA_TODEVICE); dev_kfree_skb (skb); np->tx_skbuff[i] = NULL; } } return 0; } static void __devexit rio_remove1 (struct pci_dev pdev) { struct net_device dev = pci_get_drvdata (pdev); if (dev) { struct netdev_private np = netdev_priv(dev); unregister_netdev (dev); pci_free_consistent (pdev, RX_TOTAL_SIZE, np->rx_ring, np->rx_ring_dma); pci_free_consistent (pdev, TX_TOTAL_SIZE, np->tx_ring, np->tx_ring_dma); #ifdef MEM_MAPPING iounmap ((char ) (dev->base_addr)); #endif free_netdev (dev); pci_release_regions (pdev); pci_disable_device (pdev); } pci_set_drvdata (pdev, NULL); } static struct pci_driver rio_driver = { .name = "dl2k", .id_table = rio_pci_tbl, .probe = rio_probe1, .remove = __devexit_p(rio_remove1), }; static int __init rio_init (void) { return pci_register_driver(&rio_driver); } static void __exit rio_exit (void) { pci_unregister_driver (&rio_driver); } module_init (rio_init); module_exit (rio_exit); / Compile command: gcc -D__KERNEL__ -DMODULE -I/usr/src/linux/include -Wall -Wstrict-prototypes -O2 -c dl2k.c Read Documentation/networking/dl2k.txt for details. */	./CrossVul/dataset_final_sorted/CWE-264/c/bad_3646_0
crossvul-cpp_data_bad_2287_7	/* * Copyright (C) International Business Machines Corp., 2000-2002 * Portions Copyright (C) Christoph Hellwig, 2001-2002 * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See * the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA / #include <linux/mm.h> #include <linux/fs.h> #include <linux/posix_acl.h> #include <linux/quotaops.h> #include "jfs_incore.h" #include "jfs_inode.h" #include "jfs_dmap.h" #include "jfs_txnmgr.h" #include "jfs_xattr.h" #include "jfs_acl.h" #include "jfs_debug.h" int jfs_fsync(struct file file, loff_t start, loff_t end, int datasync) { struct inode inode = file->f_mapping->host; int rc = 0; rc = filemap_write_and_wait_range(inode->i_mapping, start, end); if (rc) return rc; mutex_lock(&inode->i_mutex); if (!(inode->i_state & I_DIRTY) \|\| (datasync && !(inode->i_state & I_DIRTY_DATASYNC))) { / Make sure committed changes hit the disk / jfs_flush_journal(JFS_SBI(inode->i_sb)->log, 1); mutex_unlock(&inode->i_mutex); return rc; } rc \|= jfs_commit_inode(inode, 1); mutex_unlock(&inode->i_mutex); return rc ? -EIO : 0; } static int jfs_open(struct inode inode, struct file file) { int rc; if ((rc = dquot_file_open(inode, file))) return rc; / * We attempt to allow only one "active" file open per aggregate * group. Otherwise, appending to files in parallel can cause * fragmentation within the files. * * If the file is empty, it was probably just created and going * to be written to. If it has a size, we'll hold off until the * file is actually grown. / if (S_ISREG(inode->i_mode) && file->f_mode & FMODE_WRITE && (inode->i_size == 0)) { struct jfs_inode_info ji = JFS_IP(inode); spin_lock_irq(&ji->ag_lock); if (ji->active_ag == -1) { struct jfs_sb_info jfs_sb = JFS_SBI(inode->i_sb); ji->active_ag = BLKTOAG(addressPXD(&ji->ixpxd), jfs_sb); atomic_inc( &jfs_sb->bmap->db_active[ji->active_ag]); } spin_unlock_irq(&ji->ag_lock); } return 0; } static int jfs_release(struct inode inode, struct file file) { struct jfs_inode_info ji = JFS_IP(inode); spin_lock_irq(&ji->ag_lock); if (ji->active_ag != -1) { struct bmap bmap = JFS_SBI(inode->i_sb)->bmap; atomic_dec(&bmap->db_active[ji->active_ag]); ji->active_ag = -1; } spin_unlock_irq(&ji->ag_lock); return 0; } int jfs_setattr(struct dentry dentry, struct iattr iattr) { struct inode inode = dentry->d_inode; int rc; rc = inode_change_ok(inode, iattr); if (rc) return rc; if (is_quota_modification(inode, iattr)) dquot_initialize(inode); if ((iattr->ia_valid & ATTR_UID && !uid_eq(iattr->ia_uid, inode->i_uid)) \|\| (iattr->ia_valid & ATTR_GID && !gid_eq(iattr->ia_gid, inode->i_gid))) { rc = dquot_transfer(inode, iattr); if (rc) return rc; } if ((iattr->ia_valid & ATTR_SIZE) && iattr->ia_size != i_size_read(inode)) { inode_dio_wait(inode); rc = inode_newsize_ok(inode, iattr->ia_size); if (rc) return rc; truncate_setsize(inode, iattr->ia_size); jfs_truncate(inode); } setattr_copy(inode, iattr); mark_inode_dirty(inode); if (iattr->ia_valid & ATTR_MODE) rc = posix_acl_chmod(inode, inode->i_mode); return rc; } const struct inode_operations jfs_file_inode_operations = { .setxattr = jfs_setxattr, .getxattr = jfs_getxattr, .listxattr = jfs_listxattr, .removexattr = jfs_removexattr, .setattr = jfs_setattr, #ifdef CONFIG_JFS_POSIX_ACL .get_acl = jfs_get_acl, .set_acl = jfs_set_acl, #endif }; const struct file_operations jfs_file_operations = { .open = jfs_open, .llseek = generic_file_llseek, .write = new_sync_write, .read = new_sync_read, .read_iter = generic_file_read_iter, .write_iter = generic_file_write_iter, .mmap = generic_file_mmap, .splice_read = generic_file_splice_read, .splice_write = generic_file_splice_write, .fsync = jfs_fsync, .release = jfs_release, .unlocked_ioctl = jfs_ioctl, #ifdef CONFIG_COMPAT .compat_ioctl = jfs_compat_ioctl, #endif };	./CrossVul/dataset_final_sorted/CWE-264/c/bad_2287_7
crossvul-cpp_data_good_3438_4	/* * IPv6 over IPv4 tunnel device - Simple Internet Transition (SIT) * Linux INET6 implementation * * Authors: * Pedro Roque <roque@di.fc.ul.pt> * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru> * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version. * * Changes: * Roger Venning <r.venning@telstra.com>: 6to4 support * Nate Thompson <nate@thebog.net>: 6to4 support * Fred Templin <fred.l.templin@boeing.com>: isatap support / #include <linux/module.h> #include <linux/capability.h> #include <linux/errno.h> #include <linux/types.h> #include <linux/socket.h> #include <linux/sockios.h> #include <linux/net.h> #include <linux/in6.h> #include <linux/netdevice.h> #include <linux/if_arp.h> #include <linux/icmp.h> #include <linux/slab.h> #include <asm/uaccess.h> #include <linux/init.h> #include <linux/netfilter_ipv4.h> #include <linux/if_ether.h> #include <net/sock.h> #include <net/snmp.h> #include <net/ipv6.h> #include <net/protocol.h> #include <net/transp_v6.h> #include <net/ip6_fib.h> #include <net/ip6_route.h> #include <net/ndisc.h> #include <net/addrconf.h> #include <net/ip.h> #include <net/udp.h> #include <net/icmp.h> #include <net/ipip.h> #include <net/inet_ecn.h> #include <net/xfrm.h> #include <net/dsfield.h> #include <net/net_namespace.h> #include <net/netns/generic.h> / This version of net/ipv6/sit.c is cloned of net/ipv4/ip_gre.c For comments look at net/ipv4/ip_gre.c --ANK / #define HASH_SIZE 16 #define HASH(addr) (((__force u32)addr^((__force u32)addr>>4))&0xF) static int ipip6_tunnel_init(struct net_device dev); static void ipip6_tunnel_setup(struct net_device dev); static void ipip6_dev_free(struct net_device dev); static int sit_net_id __read_mostly; struct sit_net { struct ip_tunnel __rcu tunnels_r_l[HASH_SIZE]; struct ip_tunnel __rcu tunnels_r[HASH_SIZE]; struct ip_tunnel __rcu tunnels_l[HASH_SIZE]; struct ip_tunnel __rcu tunnels_wc[1]; struct ip_tunnel __rcu *tunnels[4]; struct net_device fb_tunnel_dev; }; /* * Locking : hash tables are protected by RCU and RTNL / #define for_each_ip_tunnel_rcu(start) \ for (t = rcu_dereference(start); t; t = rcu_dereference(t->next)) / often modified stats are per cpu, other are shared (netdev->stats) / struct pcpu_tstats { unsigned long rx_packets; unsigned long rx_bytes; unsigned long tx_packets; unsigned long tx_bytes; }; static struct net_device_stats ipip6_get_stats(struct net_device dev) { struct pcpu_tstats sum = { 0 }; int i; for_each_possible_cpu(i) { const struct pcpu_tstats tstats = per_cpu_ptr(dev->tstats, i); sum.rx_packets += tstats->rx_packets; sum.rx_bytes += tstats->rx_bytes; sum.tx_packets += tstats->tx_packets; sum.tx_bytes += tstats->tx_bytes; } dev->stats.rx_packets = sum.rx_packets; dev->stats.rx_bytes = sum.rx_bytes; dev->stats.tx_packets = sum.tx_packets; dev->stats.tx_bytes = sum.tx_bytes; return &dev->stats; } /* * Must be invoked with rcu_read_lock / static struct ip_tunnel ipip6_tunnel_lookup(struct net net, struct net_device dev, __be32 remote, __be32 local) { unsigned int h0 = HASH(remote); unsigned int h1 = HASH(local); struct ip_tunnel t; struct sit_net sitn = net_generic(net, sit_net_id); for_each_ip_tunnel_rcu(sitn->tunnels_r_l[h0 ^ h1]) { if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr && (!dev \|\| !t->parms.link \|\| dev->iflink == t->parms.link) && (t->dev->flags & IFF_UP)) return t; } for_each_ip_tunnel_rcu(sitn->tunnels_r[h0]) { if (remote == t->parms.iph.daddr && (!dev \|\| !t->parms.link \|\| dev->iflink == t->parms.link) && (t->dev->flags & IFF_UP)) return t; } for_each_ip_tunnel_rcu(sitn->tunnels_l[h1]) { if (local == t->parms.iph.saddr && (!dev \|\| !t->parms.link \|\| dev->iflink == t->parms.link) && (t->dev->flags & IFF_UP)) return t; } t = rcu_dereference(sitn->tunnels_wc[0]); if ((t != NULL) && (t->dev->flags & IFF_UP)) return t; return NULL; } static struct ip_tunnel __rcu *__ipip6_bucket(struct sit_net sitn, struct ip_tunnel_parm parms) { __be32 remote = parms->iph.daddr; __be32 local = parms->iph.saddr; unsigned int h = 0; int prio = 0; if (remote) { prio \|= 2; h ^= HASH(remote); } if (local) { prio \|= 1; h ^= HASH(local); } return &sitn->tunnels[prio][h]; } static inline struct ip_tunnel __rcu ipip6_bucket(struct sit_net sitn, struct ip_tunnel t) { return __ipip6_bucket(sitn, &t->parms); } static void ipip6_tunnel_unlink(struct sit_net sitn, struct ip_tunnel t) { struct ip_tunnel __rcu tp; struct ip_tunnel iter; for (tp = ipip6_bucket(sitn, t); (iter = rtnl_dereference(tp)) != NULL; tp = &iter->next) { if (t == iter) { rcu_assign_pointer(tp, t->next); break; } } } static void ipip6_tunnel_link(struct sit_net sitn, struct ip_tunnel t) { struct ip_tunnel __rcu *tp = ipip6_bucket(sitn, t); rcu_assign_pointer(t->next, rtnl_dereference(tp)); rcu_assign_pointer(tp, t); } static void ipip6_tunnel_clone_6rd(struct net_device dev, struct sit_net sitn) { #ifdef CONFIG_IPV6_SIT_6RD struct ip_tunnel t = netdev_priv(dev); if (t->dev == sitn->fb_tunnel_dev) { ipv6_addr_set(&t->ip6rd.prefix, htonl(0x20020000), 0, 0, 0); t->ip6rd.relay_prefix = 0; t->ip6rd.prefixlen = 16; t->ip6rd.relay_prefixlen = 0; } else { struct ip_tunnel t0 = netdev_priv(sitn->fb_tunnel_dev); memcpy(&t->ip6rd, &t0->ip6rd, sizeof(t->ip6rd)); } #endif } static struct ip_tunnel ipip6_tunnel_locate(struct net net, struct ip_tunnel_parm parms, int create) { __be32 remote = parms->iph.daddr; __be32 local = parms->iph.saddr; struct ip_tunnel t, nt; struct ip_tunnel __rcu *tp; struct net_device dev; char name[IFNAMSIZ]; struct sit_net sitn = net_generic(net, sit_net_id); for (tp = __ipip6_bucket(sitn, parms); (t = rtnl_dereference(tp)) != NULL; tp = &t->next) { if (local == t->parms.iph.saddr && remote == t->parms.iph.daddr && parms->link == t->parms.link) { if (create) return NULL; else return t; } } if (!create) goto failed; if (parms->name[0]) strlcpy(name, parms->name, IFNAMSIZ); else strcpy(name, "sit%d"); dev = alloc_netdev(sizeof(t), name, ipip6_tunnel_setup); if (dev == NULL) return NULL; dev_net_set(dev, net); if (strchr(name, '%')) { if (dev_alloc_name(dev, name) < 0) goto failed_free; } nt = netdev_priv(dev); nt->parms = parms; if (ipip6_tunnel_init(dev) < 0) goto failed_free; ipip6_tunnel_clone_6rd(dev, sitn); if (parms->i_flags & SIT_ISATAP) dev->priv_flags \|= IFF_ISATAP; if (register_netdevice(dev) < 0) goto failed_free; dev_hold(dev); ipip6_tunnel_link(sitn, nt); return nt; failed_free: ipip6_dev_free(dev); failed: return NULL; } #define for_each_prl_rcu(start) \ for (prl = rcu_dereference(start); \ prl; \ prl = rcu_dereference(prl->next)) static struct ip_tunnel_prl_entry * __ipip6_tunnel_locate_prl(struct ip_tunnel t, __be32 addr) { struct ip_tunnel_prl_entry prl; for_each_prl_rcu(t->prl) if (prl->addr == addr) break; return prl; } static int ipip6_tunnel_get_prl(struct ip_tunnel t, struct ip_tunnel_prl __user a) { struct ip_tunnel_prl kprl, kp; struct ip_tunnel_prl_entry prl; unsigned int cmax, c = 0, ca, len; int ret = 0; if (copy_from_user(&kprl, a, sizeof(kprl))) return -EFAULT; cmax = kprl.datalen / sizeof(kprl); if (cmax > 1 && kprl.addr != htonl(INADDR_ANY)) cmax = 1; /* For simple GET or for root users, * we try harder to allocate. / kp = (cmax <= 1 \|\| capable(CAP_NET_ADMIN)) ? kcalloc(cmax, sizeof(kp), GFP_KERNEL) : NULL; rcu_read_lock(); ca = t->prl_count < cmax ? t->prl_count : cmax; if (!kp) { /* We don't try hard to allocate much memory for * non-root users. * For root users, retry allocating enough memory for * the answer. / kp = kcalloc(ca, sizeof(kp), GFP_ATOMIC); if (!kp) { ret = -ENOMEM; goto out; } } c = 0; for_each_prl_rcu(t->prl) { if (c >= cmax) break; if (kprl.addr != htonl(INADDR_ANY) && prl->addr != kprl.addr) continue; kp[c].addr = prl->addr; kp[c].flags = prl->flags; c++; if (kprl.addr != htonl(INADDR_ANY)) break; } out: rcu_read_unlock(); len = sizeof(kp) c; ret = 0; if ((len && copy_to_user(a + 1, kp, len)) \|\| put_user(len, &a->datalen)) ret = -EFAULT; kfree(kp); return ret; } static int ipip6_tunnel_add_prl(struct ip_tunnel t, struct ip_tunnel_prl a, int chg) { struct ip_tunnel_prl_entry p; int err = 0; if (a->addr == htonl(INADDR_ANY)) return -EINVAL; ASSERT_RTNL(); for (p = rtnl_dereference(t->prl); p; p = rtnl_dereference(p->next)) { if (p->addr == a->addr) { if (chg) { p->flags = a->flags; goto out; } err = -EEXIST; goto out; } } if (chg) { err = -ENXIO; goto out; } p = kzalloc(sizeof(struct ip_tunnel_prl_entry), GFP_KERNEL); if (!p) { err = -ENOBUFS; goto out; } p->next = t->prl; p->addr = a->addr; p->flags = a->flags; t->prl_count++; rcu_assign_pointer(t->prl, p); out: return err; } static void prl_entry_destroy_rcu(struct rcu_head head) { kfree(container_of(head, struct ip_tunnel_prl_entry, rcu_head)); } static void prl_list_destroy_rcu(struct rcu_head head) { struct ip_tunnel_prl_entry p, n; p = container_of(head, struct ip_tunnel_prl_entry, rcu_head); do { n = p->next; kfree(p); p = n; } while (p); } static int ipip6_tunnel_del_prl(struct ip_tunnel t, struct ip_tunnel_prl a) { struct ip_tunnel_prl_entry x, *p; int err = 0; ASSERT_RTNL(); if (a && a->addr != htonl(INADDR_ANY)) { for (p = &t->prl; p; p = &(p)->next) { if ((p)->addr == a->addr) { x = p; p = x->next; call_rcu(&x->rcu_head, prl_entry_destroy_rcu); t->prl_count--; goto out; } } err = -ENXIO; } else { if (t->prl) { t->prl_count = 0; x = t->prl; call_rcu(&x->rcu_head, prl_list_destroy_rcu); t->prl = NULL; } } out: return err; } static int isatap_chksrc(struct sk_buff skb, struct iphdr iph, struct ip_tunnel t) { struct ip_tunnel_prl_entry p; int ok = 1; rcu_read_lock(); p = __ipip6_tunnel_locate_prl(t, iph->saddr); if (p) { if (p->flags & PRL_DEFAULT) skb->ndisc_nodetype = NDISC_NODETYPE_DEFAULT; else skb->ndisc_nodetype = NDISC_NODETYPE_NODEFAULT; } else { struct in6_addr addr6 = &ipv6_hdr(skb)->saddr; if (ipv6_addr_is_isatap(addr6) && (addr6->s6_addr32[3] == iph->saddr) && ipv6_chk_prefix(addr6, t->dev)) skb->ndisc_nodetype = NDISC_NODETYPE_HOST; else ok = 0; } rcu_read_unlock(); return ok; } static void ipip6_tunnel_uninit(struct net_device dev) { struct net net = dev_net(dev); struct sit_net sitn = net_generic(net, sit_net_id); if (dev == sitn->fb_tunnel_dev) { rcu_assign_pointer(sitn->tunnels_wc[0], NULL); } else { ipip6_tunnel_unlink(sitn, netdev_priv(dev)); ipip6_tunnel_del_prl(netdev_priv(dev), NULL); } dev_put(dev); } static int ipip6_err(struct sk_buff skb, u32 info) { / All the routers (except for Linux) return only 8 bytes of packet payload. It means, that precise relaying of ICMP in the real Internet is absolutely infeasible. / struct iphdr iph = (struct iphdr)skb->data; const int type = icmp_hdr(skb)->type; const int code = icmp_hdr(skb)->code; struct ip_tunnel t; int err; switch (type) { default: case ICMP_PARAMETERPROB: return 0; case ICMP_DEST_UNREACH: switch (code) { case ICMP_SR_FAILED: case ICMP_PORT_UNREACH: /* Impossible event. / return 0; case ICMP_FRAG_NEEDED: / Soft state for pmtu is maintained by IP core. / return 0; default: / All others are translated to HOST_UNREACH. rfc2003 contains "deep thoughts" about NET_UNREACH, I believe they are just ether pollution. --ANK / break; } break; case ICMP_TIME_EXCEEDED: if (code != ICMP_EXC_TTL) return 0; break; } err = -ENOENT; rcu_read_lock(); t = ipip6_tunnel_lookup(dev_net(skb->dev), skb->dev, iph->daddr, iph->saddr); if (t == NULL \|\| t->parms.iph.daddr == 0) goto out; err = 0; if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED) goto out; if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO)) t->err_count++; else t->err_count = 1; t->err_time = jiffies; out: rcu_read_unlock(); return err; } static inline void ipip6_ecn_decapsulate(struct iphdr iph, struct sk_buff skb) { if (INET_ECN_is_ce(iph->tos)) IP6_ECN_set_ce(ipv6_hdr(skb)); } static int ipip6_rcv(struct sk_buff skb) { struct iphdr iph; struct ip_tunnel tunnel; if (!pskb_may_pull(skb, sizeof(struct ipv6hdr))) goto out; iph = ip_hdr(skb); rcu_read_lock(); tunnel = ipip6_tunnel_lookup(dev_net(skb->dev), skb->dev, iph->saddr, iph->daddr); if (tunnel != NULL) { struct pcpu_tstats tstats; secpath_reset(skb); skb->mac_header = skb->network_header; skb_reset_network_header(skb); IPCB(skb)->flags = 0; skb->protocol = htons(ETH_P_IPV6); skb->pkt_type = PACKET_HOST; if ((tunnel->dev->priv_flags & IFF_ISATAP) && !isatap_chksrc(skb, iph, tunnel)) { tunnel->dev->stats.rx_errors++; rcu_read_unlock(); kfree_skb(skb); return 0; } tstats = this_cpu_ptr(tunnel->dev->tstats); tstats->rx_packets++; tstats->rx_bytes += skb->len; __skb_tunnel_rx(skb, tunnel->dev); ipip6_ecn_decapsulate(iph, skb); netif_rx(skb); rcu_read_unlock(); return 0; } / no tunnel matched, let upstream know, ipsec may handle it / rcu_read_unlock(); return 1; out: kfree_skb(skb); return 0; } / * Returns the embedded IPv4 address if the IPv6 address * comes from 6rd / 6to4 (RFC 3056) addr space. / static inline __be32 try_6rd(struct in6_addr v6dst, struct ip_tunnel tunnel) { __be32 dst = 0; #ifdef CONFIG_IPV6_SIT_6RD if (ipv6_prefix_equal(v6dst, &tunnel->ip6rd.prefix, tunnel->ip6rd.prefixlen)) { unsigned int pbw0, pbi0; int pbi1; u32 d; pbw0 = tunnel->ip6rd.prefixlen >> 5; pbi0 = tunnel->ip6rd.prefixlen & 0x1f; d = (ntohl(v6dst->s6_addr32[pbw0]) << pbi0) >> tunnel->ip6rd.relay_prefixlen; pbi1 = pbi0 - tunnel->ip6rd.relay_prefixlen; if (pbi1 > 0) d \|= ntohl(v6dst->s6_addr32[pbw0 + 1]) >> (32 - pbi1); dst = tunnel->ip6rd.relay_prefix \| htonl(d); } #else if (v6dst->s6_addr16[0] == htons(0x2002)) { / 6to4 v6 addr has 16 bits prefix, 32 v4addr, 16 SLA, ... / memcpy(&dst, &v6dst->s6_addr16[1], 4); } #endif return dst; } / * This function assumes it is being called from dev_queue_xmit() * and that skb is filled properly by that function. / static netdev_tx_t ipip6_tunnel_xmit(struct sk_buff skb, struct net_device dev) { struct ip_tunnel tunnel = netdev_priv(dev); struct pcpu_tstats tstats; struct iphdr tiph = &tunnel->parms.iph; struct ipv6hdr iph6 = ipv6_hdr(skb); u8 tos = tunnel->parms.iph.tos; __be16 df = tiph->frag_off; struct rtable rt; /* Route to the other host / struct net_device tdev; /* Device to other host / struct iphdr iph; /* Our new IP header / unsigned int max_headroom; / The extra header space needed / __be32 dst = tiph->daddr; int mtu; struct in6_addr addr6; int addr_type; if (skb->protocol != htons(ETH_P_IPV6)) goto tx_error; /* ISATAP (RFC4214) - must come before 6to4 / if (dev->priv_flags & IFF_ISATAP) { struct neighbour neigh = NULL; if (skb_dst(skb)) neigh = skb_dst(skb)->neighbour; if (neigh == NULL) { if (net_ratelimit()) printk(KERN_DEBUG "sit: nexthop == NULL\n"); goto tx_error; } addr6 = (struct in6_addr)&neigh->primary_key; addr_type = ipv6_addr_type(addr6); if ((addr_type & IPV6_ADDR_UNICAST) && ipv6_addr_is_isatap(addr6)) dst = addr6->s6_addr32[3]; else goto tx_error; } if (!dst) dst = try_6rd(&iph6->daddr, tunnel); if (!dst) { struct neighbour neigh = NULL; if (skb_dst(skb)) neigh = skb_dst(skb)->neighbour; if (neigh == NULL) { if (net_ratelimit()) printk(KERN_DEBUG "sit: nexthop == NULL\n"); goto tx_error; } addr6 = (struct in6_addr)&neigh->primary_key; addr_type = ipv6_addr_type(addr6); if (addr_type == IPV6_ADDR_ANY) { addr6 = &ipv6_hdr(skb)->daddr; addr_type = ipv6_addr_type(addr6); } if ((addr_type & IPV6_ADDR_COMPATv4) == 0) goto tx_error_icmp; dst = addr6->s6_addr32[3]; } { struct flowi fl = { .fl4_dst = dst, .fl4_src = tiph->saddr, .fl4_tos = RT_TOS(tos), .oif = tunnel->parms.link, .proto = IPPROTO_IPV6 }; if (ip_route_output_key(dev_net(dev), &rt, &fl)) { dev->stats.tx_carrier_errors++; goto tx_error_icmp; } } if (rt->rt_type != RTN_UNICAST) { ip_rt_put(rt); dev->stats.tx_carrier_errors++; goto tx_error_icmp; } tdev = rt->dst.dev; if (tdev == dev) { ip_rt_put(rt); dev->stats.collisions++; goto tx_error; } if (df) { mtu = dst_mtu(&rt->dst) - sizeof(struct iphdr); if (mtu < 68) { dev->stats.collisions++; ip_rt_put(rt); goto tx_error; } if (mtu < IPV6_MIN_MTU) { mtu = IPV6_MIN_MTU; df = 0; } if (tunnel->parms.iph.daddr && skb_dst(skb)) skb_dst(skb)->ops->update_pmtu(skb_dst(skb), mtu); if (skb->len > mtu) { icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu); ip_rt_put(rt); goto tx_error; } } if (tunnel->err_count > 0) { if (time_before(jiffies, tunnel->err_time + IPTUNNEL_ERR_TIMEO)) { tunnel->err_count--; dst_link_failure(skb); } else tunnel->err_count = 0; } / * Okay, now see if we can stuff it in the buffer as-is. / max_headroom = LL_RESERVED_SPACE(tdev)+sizeof(struct iphdr); if (skb_headroom(skb) < max_headroom \|\| skb_shared(skb) \|\| (skb_cloned(skb) && !skb_clone_writable(skb, 0))) { struct sk_buff new_skb = skb_realloc_headroom(skb, max_headroom); if (!new_skb) { ip_rt_put(rt); dev->stats.tx_dropped++; dev_kfree_skb(skb); return NETDEV_TX_OK; } if (skb->sk) skb_set_owner_w(new_skb, skb->sk); dev_kfree_skb(skb); skb = new_skb; iph6 = ipv6_hdr(skb); } skb->transport_header = skb->network_header; skb_push(skb, sizeof(struct iphdr)); skb_reset_network_header(skb); memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt)); IPCB(skb)->flags = 0; skb_dst_drop(skb); skb_dst_set(skb, &rt->dst); /* * Push down and install the IPIP header. / iph = ip_hdr(skb); iph->version = 4; iph->ihl = sizeof(struct iphdr)>>2; iph->frag_off = df; iph->protocol = IPPROTO_IPV6; iph->tos = INET_ECN_encapsulate(tos, ipv6_get_dsfield(iph6)); iph->daddr = rt->rt_dst; iph->saddr = rt->rt_src; if ((iph->ttl = tiph->ttl) == 0) iph->ttl = iph6->hop_limit; nf_reset(skb); tstats = this_cpu_ptr(dev->tstats); __IPTUNNEL_XMIT(tstats, &dev->stats); return NETDEV_TX_OK; tx_error_icmp: dst_link_failure(skb); tx_error: dev->stats.tx_errors++; dev_kfree_skb(skb); return NETDEV_TX_OK; } static void ipip6_tunnel_bind_dev(struct net_device dev) { struct net_device tdev = NULL; struct ip_tunnel tunnel; struct iphdr iph; tunnel = netdev_priv(dev); iph = &tunnel->parms.iph; if (iph->daddr) { struct flowi fl = { .fl4_dst = iph->daddr, .fl4_src = iph->saddr, .fl4_tos = RT_TOS(iph->tos), .oif = tunnel->parms.link, .proto = IPPROTO_IPV6 }; struct rtable rt; if (!ip_route_output_key(dev_net(dev), &rt, &fl)) { tdev = rt->dst.dev; ip_rt_put(rt); } dev->flags \|= IFF_POINTOPOINT; } if (!tdev && tunnel->parms.link) tdev = __dev_get_by_index(dev_net(dev), tunnel->parms.link); if (tdev) { dev->hard_header_len = tdev->hard_header_len + sizeof(struct iphdr); dev->mtu = tdev->mtu - sizeof(struct iphdr); if (dev->mtu < IPV6_MIN_MTU) dev->mtu = IPV6_MIN_MTU; } dev->iflink = tunnel->parms.link; } static int ipip6_tunnel_ioctl (struct net_device dev, struct ifreq ifr, int cmd) { int err = 0; struct ip_tunnel_parm p; struct ip_tunnel_prl prl; struct ip_tunnel t; struct net net = dev_net(dev); struct sit_net sitn = net_generic(net, sit_net_id); #ifdef CONFIG_IPV6_SIT_6RD struct ip_tunnel_6rd ip6rd; #endif switch (cmd) { case SIOCGETTUNNEL: #ifdef CONFIG_IPV6_SIT_6RD case SIOCGET6RD: #endif t = NULL; if (dev == sitn->fb_tunnel_dev) { if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) { err = -EFAULT; break; } t = ipip6_tunnel_locate(net, &p, 0); } if (t == NULL) t = netdev_priv(dev); err = -EFAULT; if (cmd == SIOCGETTUNNEL) { memcpy(&p, &t->parms, sizeof(p)); if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, sizeof(p))) goto done; #ifdef CONFIG_IPV6_SIT_6RD } else { ipv6_addr_copy(&ip6rd.prefix, &t->ip6rd.prefix); ip6rd.relay_prefix = t->ip6rd.relay_prefix; ip6rd.prefixlen = t->ip6rd.prefixlen; ip6rd.relay_prefixlen = t->ip6rd.relay_prefixlen; if (copy_to_user(ifr->ifr_ifru.ifru_data, &ip6rd, sizeof(ip6rd))) goto done; #endif } err = 0; break; case SIOCADDTUNNEL: case SIOCCHGTUNNEL: err = -EPERM; if (!capable(CAP_NET_ADMIN)) goto done; err = -EFAULT; if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) goto done; err = -EINVAL; if (p.iph.version != 4 \|\| p.iph.protocol != IPPROTO_IPV6 \|\| p.iph.ihl != 5 \|\| (p.iph.frag_off&htons(~IP_DF))) goto done; if (p.iph.ttl) p.iph.frag_off \|= htons(IP_DF); t = ipip6_tunnel_locate(net, &p, cmd == SIOCADDTUNNEL); if (dev != sitn->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) { if (t != NULL) { if (t->dev != dev) { err = -EEXIST; break; } } else { if (((dev->flags&IFF_POINTOPOINT) && !p.iph.daddr) \|\| (!(dev->flags&IFF_POINTOPOINT) && p.iph.daddr)) { err = -EINVAL; break; } t = netdev_priv(dev); ipip6_tunnel_unlink(sitn, t); synchronize_net(); t->parms.iph.saddr = p.iph.saddr; t->parms.iph.daddr = p.iph.daddr; memcpy(dev->dev_addr, &p.iph.saddr, 4); memcpy(dev->broadcast, &p.iph.daddr, 4); ipip6_tunnel_link(sitn, t); netdev_state_change(dev); } } if (t) { err = 0; if (cmd == SIOCCHGTUNNEL) { t->parms.iph.ttl = p.iph.ttl; t->parms.iph.tos = p.iph.tos; if (t->parms.link != p.link) { t->parms.link = p.link; ipip6_tunnel_bind_dev(dev); netdev_state_change(dev); } } if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p))) err = -EFAULT; } else err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT); break; case SIOCDELTUNNEL: err = -EPERM; if (!capable(CAP_NET_ADMIN)) goto done; if (dev == sitn->fb_tunnel_dev) { err = -EFAULT; if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) goto done; err = -ENOENT; if ((t = ipip6_tunnel_locate(net, &p, 0)) == NULL) goto done; err = -EPERM; if (t == netdev_priv(sitn->fb_tunnel_dev)) goto done; dev = t->dev; } unregister_netdevice(dev); err = 0; break; case SIOCGETPRL: err = -EINVAL; if (dev == sitn->fb_tunnel_dev) goto done; err = -ENOENT; if (!(t = netdev_priv(dev))) goto done; err = ipip6_tunnel_get_prl(t, ifr->ifr_ifru.ifru_data); break; case SIOCADDPRL: case SIOCDELPRL: case SIOCCHGPRL: err = -EPERM; if (!capable(CAP_NET_ADMIN)) goto done; err = -EINVAL; if (dev == sitn->fb_tunnel_dev) goto done; err = -EFAULT; if (copy_from_user(&prl, ifr->ifr_ifru.ifru_data, sizeof(prl))) goto done; err = -ENOENT; if (!(t = netdev_priv(dev))) goto done; switch (cmd) { case SIOCDELPRL: err = ipip6_tunnel_del_prl(t, &prl); break; case SIOCADDPRL: case SIOCCHGPRL: err = ipip6_tunnel_add_prl(t, &prl, cmd == SIOCCHGPRL); break; } netdev_state_change(dev); break; #ifdef CONFIG_IPV6_SIT_6RD case SIOCADD6RD: case SIOCCHG6RD: case SIOCDEL6RD: err = -EPERM; if (!capable(CAP_NET_ADMIN)) goto done; err = -EFAULT; if (copy_from_user(&ip6rd, ifr->ifr_ifru.ifru_data, sizeof(ip6rd))) goto done; t = netdev_priv(dev); if (cmd != SIOCDEL6RD) { struct in6_addr prefix; __be32 relay_prefix; err = -EINVAL; if (ip6rd.relay_prefixlen > 32 \|\| ip6rd.prefixlen + (32 - ip6rd.relay_prefixlen) > 64) goto done; ipv6_addr_prefix(&prefix, &ip6rd.prefix, ip6rd.prefixlen); if (!ipv6_addr_equal(&prefix, &ip6rd.prefix)) goto done; if (ip6rd.relay_prefixlen) relay_prefix = ip6rd.relay_prefix & htonl(0xffffffffUL << (32 - ip6rd.relay_prefixlen)); else relay_prefix = 0; if (relay_prefix != ip6rd.relay_prefix) goto done; ipv6_addr_copy(&t->ip6rd.prefix, &prefix); t->ip6rd.relay_prefix = relay_prefix; t->ip6rd.prefixlen = ip6rd.prefixlen; t->ip6rd.relay_prefixlen = ip6rd.relay_prefixlen; } else ipip6_tunnel_clone_6rd(dev, sitn); err = 0; break; #endif default: err = -EINVAL; } done: return err; } static int ipip6_tunnel_change_mtu(struct net_device dev, int new_mtu) { if (new_mtu < IPV6_MIN_MTU \|\| new_mtu > 0xFFF8 - sizeof(struct iphdr)) return -EINVAL; dev->mtu = new_mtu; return 0; } static const struct net_device_ops ipip6_netdev_ops = { .ndo_uninit = ipip6_tunnel_uninit, .ndo_start_xmit = ipip6_tunnel_xmit, .ndo_do_ioctl = ipip6_tunnel_ioctl, .ndo_change_mtu = ipip6_tunnel_change_mtu, .ndo_get_stats = ipip6_get_stats, }; static void ipip6_dev_free(struct net_device dev) { free_percpu(dev->tstats); free_netdev(dev); } static void ipip6_tunnel_setup(struct net_device dev) { dev->netdev_ops = &ipip6_netdev_ops; dev->destructor = ipip6_dev_free; dev->type = ARPHRD_SIT; dev->hard_header_len = LL_MAX_HEADER + sizeof(struct iphdr); dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr); dev->flags = IFF_NOARP; dev->priv_flags &= ~IFF_XMIT_DST_RELEASE; dev->iflink = 0; dev->addr_len = 4; dev->features \|= NETIF_F_NETNS_LOCAL; dev->features \|= NETIF_F_LLTX; } static int ipip6_tunnel_init(struct net_device dev) { struct ip_tunnel tunnel = netdev_priv(dev); tunnel->dev = dev; strcpy(tunnel->parms.name, dev->name); memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4); memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4); ipip6_tunnel_bind_dev(dev); dev->tstats = alloc_percpu(struct pcpu_tstats); if (!dev->tstats) return -ENOMEM; return 0; } static int __net_init ipip6_fb_tunnel_init(struct net_device dev) { struct ip_tunnel tunnel = netdev_priv(dev); struct iphdr iph = &tunnel->parms.iph; struct net net = dev_net(dev); struct sit_net sitn = net_generic(net, sit_net_id); tunnel->dev = dev; strcpy(tunnel->parms.name, dev->name); iph->version = 4; iph->protocol = IPPROTO_IPV6; iph->ihl = 5; iph->ttl = 64; dev->tstats = alloc_percpu(struct pcpu_tstats); if (!dev->tstats) return -ENOMEM; dev_hold(dev); sitn->tunnels_wc[0] = tunnel; return 0; } static struct xfrm_tunnel sit_handler __read_mostly = { .handler = ipip6_rcv, .err_handler = ipip6_err, .priority = 1, }; static void __net_exit sit_destroy_tunnels(struct sit_net sitn, struct list_head head) { int prio; for (prio = 1; prio < 4; prio++) { int h; for (h = 0; h < HASH_SIZE; h++) { struct ip_tunnel t = sitn->tunnels[prio][h]; while (t != NULL) { unregister_netdevice_queue(t->dev, head); t = t->next; } } } } static int __net_init sit_init_net(struct net net) { struct sit_net sitn = net_generic(net, sit_net_id); int err; sitn->tunnels[0] = sitn->tunnels_wc; sitn->tunnels[1] = sitn->tunnels_l; sitn->tunnels[2] = sitn->tunnels_r; sitn->tunnels[3] = sitn->tunnels_r_l; sitn->fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel), "sit0", ipip6_tunnel_setup); if (!sitn->fb_tunnel_dev) { err = -ENOMEM; goto err_alloc_dev; } dev_net_set(sitn->fb_tunnel_dev, net); err = ipip6_fb_tunnel_init(sitn->fb_tunnel_dev); if (err) goto err_dev_free; ipip6_tunnel_clone_6rd(sitn->fb_tunnel_dev, sitn); if ((err = register_netdev(sitn->fb_tunnel_dev))) goto err_reg_dev; return 0; err_reg_dev: dev_put(sitn->fb_tunnel_dev); err_dev_free: ipip6_dev_free(sitn->fb_tunnel_dev); err_alloc_dev: return err; } static void __net_exit sit_exit_net(struct net net) { struct sit_net sitn = net_generic(net, sit_net_id); LIST_HEAD(list); rtnl_lock(); sit_destroy_tunnels(sitn, &list); unregister_netdevice_queue(sitn->fb_tunnel_dev, &list); unregister_netdevice_many(&list); rtnl_unlock(); } static struct pernet_operations sit_net_ops = { .init = sit_init_net, .exit = sit_exit_net, .id = &sit_net_id, .size = sizeof(struct sit_net), }; static void __exit sit_cleanup(void) { xfrm4_tunnel_deregister(&sit_handler, AF_INET6); unregister_pernet_device(&sit_net_ops); rcu_barrier(); /* Wait for completion of call_rcu()'s */ } static int __init sit_init(void) { int err; printk(KERN_INFO "IPv6 over IPv4 tunneling driver\n"); err = register_pernet_device(&sit_net_ops); if (err < 0) return err; err = xfrm4_tunnel_register(&sit_handler, AF_INET6); if (err < 0) { unregister_pernet_device(&sit_net_ops); printk(KERN_INFO "sit init: Can't add protocol\n"); } return err; } module_init(sit_init); module_exit(sit_cleanup); MODULE_LICENSE("GPL"); MODULE_ALIAS_NETDEV("sit0");	./CrossVul/dataset_final_sorted/CWE-264/c/good_3438_4
crossvul-cpp_data_good_2163_1	/* * Kernel-based Virtual Machine driver for Linux * * This module enables machines with Intel VT-x extensions to run virtual * machines without emulation or binary translation. * * Copyright (C) 2006 Qumranet, Inc. * Copyright 2010 Red Hat, Inc. and/or its affiliates. * * Authors: * Avi Kivity <avi@qumranet.com> * Yaniv Kamay <yaniv@qumranet.com> * * This work is licensed under the terms of the GNU GPL, version 2. See * the COPYING file in the top-level directory. * / #include "irq.h" #include "mmu.h" #include "cpuid.h" #include <linux/kvm_host.h> #include <linux/module.h> #include <linux/kernel.h> #include <linux/mm.h> #include <linux/highmem.h> #include <linux/sched.h> #include <linux/moduleparam.h> #include <linux/mod_devicetable.h> #include <linux/ftrace_event.h> #include <linux/slab.h> #include <linux/tboot.h> #include <linux/hrtimer.h> #include "kvm_cache_regs.h" #include "x86.h" #include <asm/io.h> #include <asm/desc.h> #include <asm/vmx.h> #include <asm/virtext.h> #include <asm/mce.h> #include <asm/i387.h> #include <asm/xcr.h> #include <asm/perf_event.h> #include <asm/debugreg.h> #include <asm/kexec.h> #include "trace.h" #define __ex(x) __kvm_handle_fault_on_reboot(x) #define __ex_clear(x, reg) \ ____kvm_handle_fault_on_reboot(x, "xor " reg " , " reg) MODULE_AUTHOR("Qumranet"); MODULE_LICENSE("GPL"); static const struct x86_cpu_id vmx_cpu_id[] = { X86_FEATURE_MATCH(X86_FEATURE_VMX), {} }; MODULE_DEVICE_TABLE(x86cpu, vmx_cpu_id); static bool __read_mostly enable_vpid = 1; module_param_named(vpid, enable_vpid, bool, 0444); static bool __read_mostly flexpriority_enabled = 1; module_param_named(flexpriority, flexpriority_enabled, bool, S_IRUGO); static bool __read_mostly enable_ept = 1; module_param_named(ept, enable_ept, bool, S_IRUGO); static bool __read_mostly enable_unrestricted_guest = 1; module_param_named(unrestricted_guest, enable_unrestricted_guest, bool, S_IRUGO); static bool __read_mostly enable_ept_ad_bits = 1; module_param_named(eptad, enable_ept_ad_bits, bool, S_IRUGO); static bool __read_mostly emulate_invalid_guest_state = true; module_param(emulate_invalid_guest_state, bool, S_IRUGO); static bool __read_mostly vmm_exclusive = 1; module_param(vmm_exclusive, bool, S_IRUGO); static bool __read_mostly fasteoi = 1; module_param(fasteoi, bool, S_IRUGO); static bool __read_mostly enable_apicv = 1; module_param(enable_apicv, bool, S_IRUGO); static bool __read_mostly enable_shadow_vmcs = 1; module_param_named(enable_shadow_vmcs, enable_shadow_vmcs, bool, S_IRUGO); / * If nested=1, nested virtualization is supported, i.e., guests may use * VMX and be a hypervisor for its own guests. If nested=0, guests may not * use VMX instructions. / static bool __read_mostly nested = 0; module_param(nested, bool, S_IRUGO); #define KVM_GUEST_CR0_MASK (X86_CR0_NW \| X86_CR0_CD) #define KVM_VM_CR0_ALWAYS_ON_UNRESTRICTED_GUEST (X86_CR0_WP \| X86_CR0_NE) #define KVM_VM_CR0_ALWAYS_ON \ (KVM_VM_CR0_ALWAYS_ON_UNRESTRICTED_GUEST \| X86_CR0_PG \| X86_CR0_PE) #define KVM_CR4_GUEST_OWNED_BITS \ (X86_CR4_PVI \| X86_CR4_DE \| X86_CR4_PCE \| X86_CR4_OSFXSR \ \| X86_CR4_OSXMMEXCPT) #define KVM_PMODE_VM_CR4_ALWAYS_ON (X86_CR4_PAE \| X86_CR4_VMXE) #define KVM_RMODE_VM_CR4_ALWAYS_ON (X86_CR4_VME \| X86_CR4_PAE \| X86_CR4_VMXE) #define RMODE_GUEST_OWNED_EFLAGS_BITS (~(X86_EFLAGS_IOPL \| X86_EFLAGS_VM)) #define VMX_MISC_EMULATED_PREEMPTION_TIMER_RATE 5 / * These 2 parameters are used to config the controls for Pause-Loop Exiting: * ple_gap: upper bound on the amount of time between two successive * executions of PAUSE in a loop. Also indicate if ple enabled. * According to test, this time is usually smaller than 128 cycles. * ple_window: upper bound on the amount of time a guest is allowed to execute * in a PAUSE loop. Tests indicate that most spinlocks are held for * less than 2^12 cycles * Time is measured based on a counter that runs at the same rate as the TSC, * refer SDM volume 3b section 21.6.13 & 22.1.3. / #define KVM_VMX_DEFAULT_PLE_GAP 128 #define KVM_VMX_DEFAULT_PLE_WINDOW 4096 #define KVM_VMX_DEFAULT_PLE_WINDOW_GROW 2 #define KVM_VMX_DEFAULT_PLE_WINDOW_SHRINK 0 #define KVM_VMX_DEFAULT_PLE_WINDOW_MAX \ INT_MAX / KVM_VMX_DEFAULT_PLE_WINDOW_GROW static int ple_gap = KVM_VMX_DEFAULT_PLE_GAP; module_param(ple_gap, int, S_IRUGO); static int ple_window = KVM_VMX_DEFAULT_PLE_WINDOW; module_param(ple_window, int, S_IRUGO); / Default doubles per-vcpu window every exit. / static int ple_window_grow = KVM_VMX_DEFAULT_PLE_WINDOW_GROW; module_param(ple_window_grow, int, S_IRUGO); / Default resets per-vcpu window every exit to ple_window. / static int ple_window_shrink = KVM_VMX_DEFAULT_PLE_WINDOW_SHRINK; module_param(ple_window_shrink, int, S_IRUGO); / Default is to compute the maximum so we can never overflow. / static int ple_window_actual_max = KVM_VMX_DEFAULT_PLE_WINDOW_MAX; static int ple_window_max = KVM_VMX_DEFAULT_PLE_WINDOW_MAX; module_param(ple_window_max, int, S_IRUGO); extern const ulong vmx_return; #define NR_AUTOLOAD_MSRS 8 #define VMCS02_POOL_SIZE 1 struct vmcs { u32 revision_id; u32 abort; char data[0]; }; / * Track a VMCS that may be loaded on a certain CPU. If it is (cpu!=-1), also * remember whether it was VMLAUNCHed, and maintain a linked list of all VMCSs * loaded on this CPU (so we can clear them if the CPU goes down). / struct loaded_vmcs { struct vmcs vmcs; int cpu; int launched; struct list_head loaded_vmcss_on_cpu_link; }; struct shared_msr_entry { unsigned index; u64 data; u64 mask; }; /* * struct vmcs12 describes the state that our guest hypervisor (L1) keeps for a * single nested guest (L2), hence the name vmcs12. Any VMX implementation has * a VMCS structure, and vmcs12 is our emulated VMX's VMCS. This structure is * stored in guest memory specified by VMPTRLD, but is opaque to the guest, * which must access it using VMREAD/VMWRITE/VMCLEAR instructions. * More than one of these structures may exist, if L1 runs multiple L2 guests. * nested_vmx_run() will use the data here to build a vmcs02: a VMCS for the * underlying hardware which will be used to run L2. * This structure is packed to ensure that its layout is identical across * machines (necessary for live migration). * If there are changes in this struct, VMCS12_REVISION must be changed. / typedef u64 natural_width; struct __packed vmcs12 { / According to the Intel spec, a VMCS region must start with the * following two fields. Then follow implementation-specific data. / u32 revision_id; u32 abort; u32 launch_state; / set to 0 by VMCLEAR, to 1 by VMLAUNCH / u32 padding[7]; / room for future expansion / u64 io_bitmap_a; u64 io_bitmap_b; u64 msr_bitmap; u64 vm_exit_msr_store_addr; u64 vm_exit_msr_load_addr; u64 vm_entry_msr_load_addr; u64 tsc_offset; u64 virtual_apic_page_addr; u64 apic_access_addr; u64 ept_pointer; u64 guest_physical_address; u64 vmcs_link_pointer; u64 guest_ia32_debugctl; u64 guest_ia32_pat; u64 guest_ia32_efer; u64 guest_ia32_perf_global_ctrl; u64 guest_pdptr0; u64 guest_pdptr1; u64 guest_pdptr2; u64 guest_pdptr3; u64 guest_bndcfgs; u64 host_ia32_pat; u64 host_ia32_efer; u64 host_ia32_perf_global_ctrl; u64 padding64[8]; / room for future expansion / / * To allow migration of L1 (complete with its L2 guests) between * machines of different natural widths (32 or 64 bit), we cannot have * unsigned long fields with no explict size. We use u64 (aliased * natural_width) instead. Luckily, x86 is little-endian. / natural_width cr0_guest_host_mask; natural_width cr4_guest_host_mask; natural_width cr0_read_shadow; natural_width cr4_read_shadow; natural_width cr3_target_value0; natural_width cr3_target_value1; natural_width cr3_target_value2; natural_width cr3_target_value3; natural_width exit_qualification; natural_width guest_linear_address; natural_width guest_cr0; natural_width guest_cr3; natural_width guest_cr4; natural_width guest_es_base; natural_width guest_cs_base; natural_width guest_ss_base; natural_width guest_ds_base; natural_width guest_fs_base; natural_width guest_gs_base; natural_width guest_ldtr_base; natural_width guest_tr_base; natural_width guest_gdtr_base; natural_width guest_idtr_base; natural_width guest_dr7; natural_width guest_rsp; natural_width guest_rip; natural_width guest_rflags; natural_width guest_pending_dbg_exceptions; natural_width guest_sysenter_esp; natural_width guest_sysenter_eip; natural_width host_cr0; natural_width host_cr3; natural_width host_cr4; natural_width host_fs_base; natural_width host_gs_base; natural_width host_tr_base; natural_width host_gdtr_base; natural_width host_idtr_base; natural_width host_ia32_sysenter_esp; natural_width host_ia32_sysenter_eip; natural_width host_rsp; natural_width host_rip; natural_width paddingl[8]; / room for future expansion / u32 pin_based_vm_exec_control; u32 cpu_based_vm_exec_control; u32 exception_bitmap; u32 page_fault_error_code_mask; u32 page_fault_error_code_match; u32 cr3_target_count; u32 vm_exit_controls; u32 vm_exit_msr_store_count; u32 vm_exit_msr_load_count; u32 vm_entry_controls; u32 vm_entry_msr_load_count; u32 vm_entry_intr_info_field; u32 vm_entry_exception_error_code; u32 vm_entry_instruction_len; u32 tpr_threshold; u32 secondary_vm_exec_control; u32 vm_instruction_error; u32 vm_exit_reason; u32 vm_exit_intr_info; u32 vm_exit_intr_error_code; u32 idt_vectoring_info_field; u32 idt_vectoring_error_code; u32 vm_exit_instruction_len; u32 vmx_instruction_info; u32 guest_es_limit; u32 guest_cs_limit; u32 guest_ss_limit; u32 guest_ds_limit; u32 guest_fs_limit; u32 guest_gs_limit; u32 guest_ldtr_limit; u32 guest_tr_limit; u32 guest_gdtr_limit; u32 guest_idtr_limit; u32 guest_es_ar_bytes; u32 guest_cs_ar_bytes; u32 guest_ss_ar_bytes; u32 guest_ds_ar_bytes; u32 guest_fs_ar_bytes; u32 guest_gs_ar_bytes; u32 guest_ldtr_ar_bytes; u32 guest_tr_ar_bytes; u32 guest_interruptibility_info; u32 guest_activity_state; u32 guest_sysenter_cs; u32 host_ia32_sysenter_cs; u32 vmx_preemption_timer_value; u32 padding32[7]; / room for future expansion / u16 virtual_processor_id; u16 guest_es_selector; u16 guest_cs_selector; u16 guest_ss_selector; u16 guest_ds_selector; u16 guest_fs_selector; u16 guest_gs_selector; u16 guest_ldtr_selector; u16 guest_tr_selector; u16 host_es_selector; u16 host_cs_selector; u16 host_ss_selector; u16 host_ds_selector; u16 host_fs_selector; u16 host_gs_selector; u16 host_tr_selector; }; / * VMCS12_REVISION is an arbitrary id that should be changed if the content or * layout of struct vmcs12 is changed. MSR_IA32_VMX_BASIC returns this id, and * VMPTRLD verifies that the VMCS region that L1 is loading contains this id. / #define VMCS12_REVISION 0x11e57ed0 / * VMCS12_SIZE is the number of bytes L1 should allocate for the VMXON region * and any VMCS region. Although only sizeof(struct vmcs12) are used by the * current implementation, 4K are reserved to avoid future complications. / #define VMCS12_SIZE 0x1000 / Used to remember the last vmcs02 used for some recently used vmcs12s / struct vmcs02_list { struct list_head list; gpa_t vmptr; struct loaded_vmcs vmcs02; }; / * The nested_vmx structure is part of vcpu_vmx, and holds information we need * for correct emulation of VMX (i.e., nested VMX) on this vcpu. / struct nested_vmx { / Has the level1 guest done vmxon? / bool vmxon; gpa_t vmxon_ptr; / The guest-physical address of the current VMCS L1 keeps for L2 / gpa_t current_vmptr; / The host-usable pointer to the above / struct page current_vmcs12_page; struct vmcs12 current_vmcs12; struct vmcs current_shadow_vmcs; /* * Indicates if the shadow vmcs must be updated with the * data hold by vmcs12 / bool sync_shadow_vmcs; / vmcs02_list cache of VMCSs recently used to run L2 guests / struct list_head vmcs02_pool; int vmcs02_num; u64 vmcs01_tsc_offset; / L2 must run next, and mustn't decide to exit to L1. / bool nested_run_pending; / * Guest pages referred to in vmcs02 with host-physical pointers, so * we must keep them pinned while L2 runs. / struct page apic_access_page; struct page virtual_apic_page; u64 msr_ia32_feature_control; struct hrtimer preemption_timer; bool preemption_timer_expired; / to migrate it to L2 if VM_ENTRY_LOAD_DEBUG_CONTROLS is off / u64 vmcs01_debugctl; }; #define POSTED_INTR_ON 0 / Posted-Interrupt Descriptor / struct pi_desc { u32 pir[8]; / Posted interrupt requested / u32 control; / bit 0 of control is outstanding notification bit / u32 rsvd[7]; } __aligned(64); static bool pi_test_and_set_on(struct pi_desc pi_desc) { return test_and_set_bit(POSTED_INTR_ON, (unsigned long )&pi_desc->control); } static bool pi_test_and_clear_on(struct pi_desc pi_desc) { return test_and_clear_bit(POSTED_INTR_ON, (unsigned long )&pi_desc->control); } static int pi_test_and_set_pir(int vector, struct pi_desc pi_desc) { return test_and_set_bit(vector, (unsigned long )pi_desc->pir); } struct vcpu_vmx { struct kvm_vcpu vcpu; unsigned long host_rsp; u8 fail; bool nmi_known_unmasked; u32 exit_intr_info; u32 idt_vectoring_info; ulong rflags; struct shared_msr_entry guest_msrs; int nmsrs; int save_nmsrs; unsigned long host_idt_base; #ifdef CONFIG_X86_64 u64 msr_host_kernel_gs_base; u64 msr_guest_kernel_gs_base; #endif u32 vm_entry_controls_shadow; u32 vm_exit_controls_shadow; /* * loaded_vmcs points to the VMCS currently used in this vcpu. For a * non-nested (L1) guest, it always points to vmcs01. For a nested * guest (L2), it points to a different VMCS. / struct loaded_vmcs vmcs01; struct loaded_vmcs loaded_vmcs; bool __launched; /* temporary, used in vmx_vcpu_run / struct msr_autoload { unsigned nr; struct vmx_msr_entry guest[NR_AUTOLOAD_MSRS]; struct vmx_msr_entry host[NR_AUTOLOAD_MSRS]; } msr_autoload; struct { int loaded; u16 fs_sel, gs_sel, ldt_sel; #ifdef CONFIG_X86_64 u16 ds_sel, es_sel; #endif int gs_ldt_reload_needed; int fs_reload_needed; u64 msr_host_bndcfgs; unsigned long vmcs_host_cr4; / May not match real cr4 / } host_state; struct { int vm86_active; ulong save_rflags; struct kvm_segment segs[8]; } rmode; struct { u32 bitmask; / 4 bits per segment (1 bit per field) / struct kvm_save_segment { u16 selector; unsigned long base; u32 limit; u32 ar; } seg[8]; } segment_cache; int vpid; bool emulation_required; / Support for vnmi-less CPUs / int soft_vnmi_blocked; ktime_t entry_time; s64 vnmi_blocked_time; u32 exit_reason; bool rdtscp_enabled; / Posted interrupt descriptor / struct pi_desc pi_desc; / Support for a guest hypervisor (nested VMX) / struct nested_vmx nested; / Dynamic PLE window. / int ple_window; bool ple_window_dirty; }; enum segment_cache_field { SEG_FIELD_SEL = 0, SEG_FIELD_BASE = 1, SEG_FIELD_LIMIT = 2, SEG_FIELD_AR = 3, SEG_FIELD_NR = 4 }; static inline struct vcpu_vmx to_vmx(struct kvm_vcpu vcpu) { return container_of(vcpu, struct vcpu_vmx, vcpu); } #define VMCS12_OFFSET(x) offsetof(struct vmcs12, x) #define FIELD(number, name) [number] = VMCS12_OFFSET(name) #define FIELD64(number, name) [number] = VMCS12_OFFSET(name), \ [number##_HIGH] = VMCS12_OFFSET(name)+4 static unsigned long shadow_read_only_fields[] = { / * We do NOT shadow fields that are modified when L0 * traps and emulates any vmx instruction (e.g. VMPTRLD, * VMXON...) executed by L1. * For example, VM_INSTRUCTION_ERROR is read * by L1 if a vmx instruction fails (part of the error path). * Note the code assumes this logic. If for some reason * we start shadowing these fields then we need to * force a shadow sync when L0 emulates vmx instructions * (e.g. force a sync if VM_INSTRUCTION_ERROR is modified * by nested_vmx_failValid) / VM_EXIT_REASON, VM_EXIT_INTR_INFO, VM_EXIT_INSTRUCTION_LEN, IDT_VECTORING_INFO_FIELD, IDT_VECTORING_ERROR_CODE, VM_EXIT_INTR_ERROR_CODE, EXIT_QUALIFICATION, GUEST_LINEAR_ADDRESS, GUEST_PHYSICAL_ADDRESS }; static int max_shadow_read_only_fields = ARRAY_SIZE(shadow_read_only_fields); static unsigned long shadow_read_write_fields[] = { TPR_THRESHOLD, GUEST_RIP, GUEST_RSP, GUEST_CR0, GUEST_CR3, GUEST_CR4, GUEST_INTERRUPTIBILITY_INFO, GUEST_RFLAGS, GUEST_CS_SELECTOR, GUEST_CS_AR_BYTES, GUEST_CS_LIMIT, GUEST_CS_BASE, GUEST_ES_BASE, GUEST_BNDCFGS, CR0_GUEST_HOST_MASK, CR0_READ_SHADOW, CR4_READ_SHADOW, TSC_OFFSET, EXCEPTION_BITMAP, CPU_BASED_VM_EXEC_CONTROL, VM_ENTRY_EXCEPTION_ERROR_CODE, VM_ENTRY_INTR_INFO_FIELD, VM_ENTRY_INSTRUCTION_LEN, VM_ENTRY_EXCEPTION_ERROR_CODE, HOST_FS_BASE, HOST_GS_BASE, HOST_FS_SELECTOR, HOST_GS_SELECTOR }; static int max_shadow_read_write_fields = ARRAY_SIZE(shadow_read_write_fields); static const unsigned short vmcs_field_to_offset_table[] = { FIELD(VIRTUAL_PROCESSOR_ID, virtual_processor_id), FIELD(GUEST_ES_SELECTOR, guest_es_selector), FIELD(GUEST_CS_SELECTOR, guest_cs_selector), FIELD(GUEST_SS_SELECTOR, guest_ss_selector), FIELD(GUEST_DS_SELECTOR, guest_ds_selector), FIELD(GUEST_FS_SELECTOR, guest_fs_selector), FIELD(GUEST_GS_SELECTOR, guest_gs_selector), FIELD(GUEST_LDTR_SELECTOR, guest_ldtr_selector), FIELD(GUEST_TR_SELECTOR, guest_tr_selector), FIELD(HOST_ES_SELECTOR, host_es_selector), FIELD(HOST_CS_SELECTOR, host_cs_selector), FIELD(HOST_SS_SELECTOR, host_ss_selector), FIELD(HOST_DS_SELECTOR, host_ds_selector), FIELD(HOST_FS_SELECTOR, host_fs_selector), FIELD(HOST_GS_SELECTOR, host_gs_selector), FIELD(HOST_TR_SELECTOR, host_tr_selector), FIELD64(IO_BITMAP_A, io_bitmap_a), FIELD64(IO_BITMAP_B, io_bitmap_b), FIELD64(MSR_BITMAP, msr_bitmap), FIELD64(VM_EXIT_MSR_STORE_ADDR, vm_exit_msr_store_addr), FIELD64(VM_EXIT_MSR_LOAD_ADDR, vm_exit_msr_load_addr), FIELD64(VM_ENTRY_MSR_LOAD_ADDR, vm_entry_msr_load_addr), FIELD64(TSC_OFFSET, tsc_offset), FIELD64(VIRTUAL_APIC_PAGE_ADDR, virtual_apic_page_addr), FIELD64(APIC_ACCESS_ADDR, apic_access_addr), FIELD64(EPT_POINTER, ept_pointer), FIELD64(GUEST_PHYSICAL_ADDRESS, guest_physical_address), FIELD64(VMCS_LINK_POINTER, vmcs_link_pointer), FIELD64(GUEST_IA32_DEBUGCTL, guest_ia32_debugctl), FIELD64(GUEST_IA32_PAT, guest_ia32_pat), FIELD64(GUEST_IA32_EFER, guest_ia32_efer), FIELD64(GUEST_IA32_PERF_GLOBAL_CTRL, guest_ia32_perf_global_ctrl), FIELD64(GUEST_PDPTR0, guest_pdptr0), FIELD64(GUEST_PDPTR1, guest_pdptr1), FIELD64(GUEST_PDPTR2, guest_pdptr2), FIELD64(GUEST_PDPTR3, guest_pdptr3), FIELD64(GUEST_BNDCFGS, guest_bndcfgs), FIELD64(HOST_IA32_PAT, host_ia32_pat), FIELD64(HOST_IA32_EFER, host_ia32_efer), FIELD64(HOST_IA32_PERF_GLOBAL_CTRL, host_ia32_perf_global_ctrl), FIELD(PIN_BASED_VM_EXEC_CONTROL, pin_based_vm_exec_control), FIELD(CPU_BASED_VM_EXEC_CONTROL, cpu_based_vm_exec_control), FIELD(EXCEPTION_BITMAP, exception_bitmap), FIELD(PAGE_FAULT_ERROR_CODE_MASK, page_fault_error_code_mask), FIELD(PAGE_FAULT_ERROR_CODE_MATCH, page_fault_error_code_match), FIELD(CR3_TARGET_COUNT, cr3_target_count), FIELD(VM_EXIT_CONTROLS, vm_exit_controls), FIELD(VM_EXIT_MSR_STORE_COUNT, vm_exit_msr_store_count), FIELD(VM_EXIT_MSR_LOAD_COUNT, vm_exit_msr_load_count), FIELD(VM_ENTRY_CONTROLS, vm_entry_controls), FIELD(VM_ENTRY_MSR_LOAD_COUNT, vm_entry_msr_load_count), FIELD(VM_ENTRY_INTR_INFO_FIELD, vm_entry_intr_info_field), FIELD(VM_ENTRY_EXCEPTION_ERROR_CODE, vm_entry_exception_error_code), FIELD(VM_ENTRY_INSTRUCTION_LEN, vm_entry_instruction_len), FIELD(TPR_THRESHOLD, tpr_threshold), FIELD(SECONDARY_VM_EXEC_CONTROL, secondary_vm_exec_control), FIELD(VM_INSTRUCTION_ERROR, vm_instruction_error), FIELD(VM_EXIT_REASON, vm_exit_reason), FIELD(VM_EXIT_INTR_INFO, vm_exit_intr_info), FIELD(VM_EXIT_INTR_ERROR_CODE, vm_exit_intr_error_code), FIELD(IDT_VECTORING_INFO_FIELD, idt_vectoring_info_field), FIELD(IDT_VECTORING_ERROR_CODE, idt_vectoring_error_code), FIELD(VM_EXIT_INSTRUCTION_LEN, vm_exit_instruction_len), FIELD(VMX_INSTRUCTION_INFO, vmx_instruction_info), FIELD(GUEST_ES_LIMIT, guest_es_limit), FIELD(GUEST_CS_LIMIT, guest_cs_limit), FIELD(GUEST_SS_LIMIT, guest_ss_limit), FIELD(GUEST_DS_LIMIT, guest_ds_limit), FIELD(GUEST_FS_LIMIT, guest_fs_limit), FIELD(GUEST_GS_LIMIT, guest_gs_limit), FIELD(GUEST_LDTR_LIMIT, guest_ldtr_limit), FIELD(GUEST_TR_LIMIT, guest_tr_limit), FIELD(GUEST_GDTR_LIMIT, guest_gdtr_limit), FIELD(GUEST_IDTR_LIMIT, guest_idtr_limit), FIELD(GUEST_ES_AR_BYTES, guest_es_ar_bytes), FIELD(GUEST_CS_AR_BYTES, guest_cs_ar_bytes), FIELD(GUEST_SS_AR_BYTES, guest_ss_ar_bytes), FIELD(GUEST_DS_AR_BYTES, guest_ds_ar_bytes), FIELD(GUEST_FS_AR_BYTES, guest_fs_ar_bytes), FIELD(GUEST_GS_AR_BYTES, guest_gs_ar_bytes), FIELD(GUEST_LDTR_AR_BYTES, guest_ldtr_ar_bytes), FIELD(GUEST_TR_AR_BYTES, guest_tr_ar_bytes), FIELD(GUEST_INTERRUPTIBILITY_INFO, guest_interruptibility_info), FIELD(GUEST_ACTIVITY_STATE, guest_activity_state), FIELD(GUEST_SYSENTER_CS, guest_sysenter_cs), FIELD(HOST_IA32_SYSENTER_CS, host_ia32_sysenter_cs), FIELD(VMX_PREEMPTION_TIMER_VALUE, vmx_preemption_timer_value), FIELD(CR0_GUEST_HOST_MASK, cr0_guest_host_mask), FIELD(CR4_GUEST_HOST_MASK, cr4_guest_host_mask), FIELD(CR0_READ_SHADOW, cr0_read_shadow), FIELD(CR4_READ_SHADOW, cr4_read_shadow), FIELD(CR3_TARGET_VALUE0, cr3_target_value0), FIELD(CR3_TARGET_VALUE1, cr3_target_value1), FIELD(CR3_TARGET_VALUE2, cr3_target_value2), FIELD(CR3_TARGET_VALUE3, cr3_target_value3), FIELD(EXIT_QUALIFICATION, exit_qualification), FIELD(GUEST_LINEAR_ADDRESS, guest_linear_address), FIELD(GUEST_CR0, guest_cr0), FIELD(GUEST_CR3, guest_cr3), FIELD(GUEST_CR4, guest_cr4), FIELD(GUEST_ES_BASE, guest_es_base), FIELD(GUEST_CS_BASE, guest_cs_base), FIELD(GUEST_SS_BASE, guest_ss_base), FIELD(GUEST_DS_BASE, guest_ds_base), FIELD(GUEST_FS_BASE, guest_fs_base), FIELD(GUEST_GS_BASE, guest_gs_base), FIELD(GUEST_LDTR_BASE, guest_ldtr_base), FIELD(GUEST_TR_BASE, guest_tr_base), FIELD(GUEST_GDTR_BASE, guest_gdtr_base), FIELD(GUEST_IDTR_BASE, guest_idtr_base), FIELD(GUEST_DR7, guest_dr7), FIELD(GUEST_RSP, guest_rsp), FIELD(GUEST_RIP, guest_rip), FIELD(GUEST_RFLAGS, guest_rflags), FIELD(GUEST_PENDING_DBG_EXCEPTIONS, guest_pending_dbg_exceptions), FIELD(GUEST_SYSENTER_ESP, guest_sysenter_esp), FIELD(GUEST_SYSENTER_EIP, guest_sysenter_eip), FIELD(HOST_CR0, host_cr0), FIELD(HOST_CR3, host_cr3), FIELD(HOST_CR4, host_cr4), FIELD(HOST_FS_BASE, host_fs_base), FIELD(HOST_GS_BASE, host_gs_base), FIELD(HOST_TR_BASE, host_tr_base), FIELD(HOST_GDTR_BASE, host_gdtr_base), FIELD(HOST_IDTR_BASE, host_idtr_base), FIELD(HOST_IA32_SYSENTER_ESP, host_ia32_sysenter_esp), FIELD(HOST_IA32_SYSENTER_EIP, host_ia32_sysenter_eip), FIELD(HOST_RSP, host_rsp), FIELD(HOST_RIP, host_rip), }; static const int max_vmcs_field = ARRAY_SIZE(vmcs_field_to_offset_table); static inline short vmcs_field_to_offset(unsigned long field) { if (field >= max_vmcs_field \|\| vmcs_field_to_offset_table[field] == 0) return -1; return vmcs_field_to_offset_table[field]; } static inline struct vmcs12 get_vmcs12(struct kvm_vcpu vcpu) { return to_vmx(vcpu)->nested.current_vmcs12; } static struct page nested_get_page(struct kvm_vcpu vcpu, gpa_t addr) { struct page page = gfn_to_page(vcpu->kvm, addr >> PAGE_SHIFT); if (is_error_page(page)) return NULL; return page; } static void nested_release_page(struct page page) { kvm_release_page_dirty(page); } static void nested_release_page_clean(struct page page) { kvm_release_page_clean(page); } static unsigned long nested_ept_get_cr3(struct kvm_vcpu vcpu); static u64 construct_eptp(unsigned long root_hpa); static void kvm_cpu_vmxon(u64 addr); static void kvm_cpu_vmxoff(void); static bool vmx_mpx_supported(void); static int vmx_set_tss_addr(struct kvm kvm, unsigned int addr); static void vmx_set_segment(struct kvm_vcpu vcpu, struct kvm_segment var, int seg); static void vmx_get_segment(struct kvm_vcpu vcpu, struct kvm_segment var, int seg); static bool guest_state_valid(struct kvm_vcpu vcpu); static u32 vmx_segment_access_rights(struct kvm_segment var); static void vmx_sync_pir_to_irr_dummy(struct kvm_vcpu vcpu); static void copy_vmcs12_to_shadow(struct vcpu_vmx vmx); static void copy_shadow_to_vmcs12(struct vcpu_vmx vmx); static int alloc_identity_pagetable(struct kvm kvm); static DEFINE_PER_CPU(struct vmcs , vmxarea); static DEFINE_PER_CPU(struct vmcs , current_vmcs); /* * We maintain a per-CPU linked-list of VMCS loaded on that CPU. This is needed * when a CPU is brought down, and we need to VMCLEAR all VMCSs loaded on it. / static DEFINE_PER_CPU(struct list_head, loaded_vmcss_on_cpu); static DEFINE_PER_CPU(struct desc_ptr, host_gdt); static unsigned long vmx_io_bitmap_a; static unsigned long vmx_io_bitmap_b; static unsigned long vmx_msr_bitmap_legacy; static unsigned long vmx_msr_bitmap_longmode; static unsigned long vmx_msr_bitmap_legacy_x2apic; static unsigned long vmx_msr_bitmap_longmode_x2apic; static unsigned long vmx_vmread_bitmap; static unsigned long vmx_vmwrite_bitmap; static bool cpu_has_load_ia32_efer; static bool cpu_has_load_perf_global_ctrl; static DECLARE_BITMAP(vmx_vpid_bitmap, VMX_NR_VPIDS); static DEFINE_SPINLOCK(vmx_vpid_lock); static struct vmcs_config { int size; int order; u32 revision_id; u32 pin_based_exec_ctrl; u32 cpu_based_exec_ctrl; u32 cpu_based_2nd_exec_ctrl; u32 vmexit_ctrl; u32 vmentry_ctrl; } vmcs_config; static struct vmx_capability { u32 ept; u32 vpid; } vmx_capability; #define VMX_SEGMENT_FIELD(seg) \ [VCPU_SREG_##seg] = { \ .selector = GUEST_##seg##_SELECTOR, \ .base = GUEST_##seg##_BASE, \ .limit = GUEST_##seg##_LIMIT, \ .ar_bytes = GUEST_##seg##_AR_BYTES, \ } static const struct kvm_vmx_segment_field { unsigned selector; unsigned base; unsigned limit; unsigned ar_bytes; } kvm_vmx_segment_fields[] = { VMX_SEGMENT_FIELD(CS), VMX_SEGMENT_FIELD(DS), VMX_SEGMENT_FIELD(ES), VMX_SEGMENT_FIELD(FS), VMX_SEGMENT_FIELD(GS), VMX_SEGMENT_FIELD(SS), VMX_SEGMENT_FIELD(TR), VMX_SEGMENT_FIELD(LDTR), }; static u64 host_efer; static void ept_save_pdptrs(struct kvm_vcpu vcpu); /* * Keep MSR_STAR at the end, as setup_msrs() will try to optimize it * away by decrementing the array size. / static const u32 vmx_msr_index[] = { #ifdef CONFIG_X86_64 MSR_SYSCALL_MASK, MSR_LSTAR, MSR_CSTAR, #endif MSR_EFER, MSR_TSC_AUX, MSR_STAR, }; static inline bool is_page_fault(u32 intr_info) { return (intr_info & (INTR_INFO_INTR_TYPE_MASK \| INTR_INFO_VECTOR_MASK \| INTR_INFO_VALID_MASK)) == (INTR_TYPE_HARD_EXCEPTION \| PF_VECTOR \| INTR_INFO_VALID_MASK); } static inline bool is_no_device(u32 intr_info) { return (intr_info & (INTR_INFO_INTR_TYPE_MASK \| INTR_INFO_VECTOR_MASK \| INTR_INFO_VALID_MASK)) == (INTR_TYPE_HARD_EXCEPTION \| NM_VECTOR \| INTR_INFO_VALID_MASK); } static inline bool is_invalid_opcode(u32 intr_info) { return (intr_info & (INTR_INFO_INTR_TYPE_MASK \| INTR_INFO_VECTOR_MASK \| INTR_INFO_VALID_MASK)) == (INTR_TYPE_HARD_EXCEPTION \| UD_VECTOR \| INTR_INFO_VALID_MASK); } static inline bool is_external_interrupt(u32 intr_info) { return (intr_info & (INTR_INFO_INTR_TYPE_MASK \| INTR_INFO_VALID_MASK)) == (INTR_TYPE_EXT_INTR \| INTR_INFO_VALID_MASK); } static inline bool is_machine_check(u32 intr_info) { return (intr_info & (INTR_INFO_INTR_TYPE_MASK \| INTR_INFO_VECTOR_MASK \| INTR_INFO_VALID_MASK)) == (INTR_TYPE_HARD_EXCEPTION \| MC_VECTOR \| INTR_INFO_VALID_MASK); } static inline bool cpu_has_vmx_msr_bitmap(void) { return vmcs_config.cpu_based_exec_ctrl & CPU_BASED_USE_MSR_BITMAPS; } static inline bool cpu_has_vmx_tpr_shadow(void) { return vmcs_config.cpu_based_exec_ctrl & CPU_BASED_TPR_SHADOW; } static inline bool vm_need_tpr_shadow(struct kvm kvm) { return (cpu_has_vmx_tpr_shadow()) && (irqchip_in_kernel(kvm)); } static inline bool cpu_has_secondary_exec_ctrls(void) { return vmcs_config.cpu_based_exec_ctrl & CPU_BASED_ACTIVATE_SECONDARY_CONTROLS; } static inline bool cpu_has_vmx_virtualize_apic_accesses(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES; } static inline bool cpu_has_vmx_virtualize_x2apic_mode(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_VIRTUALIZE_X2APIC_MODE; } static inline bool cpu_has_vmx_apic_register_virt(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_APIC_REGISTER_VIRT; } static inline bool cpu_has_vmx_virtual_intr_delivery(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_VIRTUAL_INTR_DELIVERY; } static inline bool cpu_has_vmx_posted_intr(void) { return vmcs_config.pin_based_exec_ctrl & PIN_BASED_POSTED_INTR; } static inline bool cpu_has_vmx_apicv(void) { return cpu_has_vmx_apic_register_virt() && cpu_has_vmx_virtual_intr_delivery() && cpu_has_vmx_posted_intr(); } static inline bool cpu_has_vmx_flexpriority(void) { return cpu_has_vmx_tpr_shadow() && cpu_has_vmx_virtualize_apic_accesses(); } static inline bool cpu_has_vmx_ept_execute_only(void) { return vmx_capability.ept & VMX_EPT_EXECUTE_ONLY_BIT; } static inline bool cpu_has_vmx_eptp_uncacheable(void) { return vmx_capability.ept & VMX_EPTP_UC_BIT; } static inline bool cpu_has_vmx_eptp_writeback(void) { return vmx_capability.ept & VMX_EPTP_WB_BIT; } static inline bool cpu_has_vmx_ept_2m_page(void) { return vmx_capability.ept & VMX_EPT_2MB_PAGE_BIT; } static inline bool cpu_has_vmx_ept_1g_page(void) { return vmx_capability.ept & VMX_EPT_1GB_PAGE_BIT; } static inline bool cpu_has_vmx_ept_4levels(void) { return vmx_capability.ept & VMX_EPT_PAGE_WALK_4_BIT; } static inline bool cpu_has_vmx_ept_ad_bits(void) { return vmx_capability.ept & VMX_EPT_AD_BIT; } static inline bool cpu_has_vmx_invept_context(void) { return vmx_capability.ept & VMX_EPT_EXTENT_CONTEXT_BIT; } static inline bool cpu_has_vmx_invept_global(void) { return vmx_capability.ept & VMX_EPT_EXTENT_GLOBAL_BIT; } static inline bool cpu_has_vmx_invvpid_single(void) { return vmx_capability.vpid & VMX_VPID_EXTENT_SINGLE_CONTEXT_BIT; } static inline bool cpu_has_vmx_invvpid_global(void) { return vmx_capability.vpid & VMX_VPID_EXTENT_GLOBAL_CONTEXT_BIT; } static inline bool cpu_has_vmx_ept(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_ENABLE_EPT; } static inline bool cpu_has_vmx_unrestricted_guest(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_UNRESTRICTED_GUEST; } static inline bool cpu_has_vmx_ple(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_PAUSE_LOOP_EXITING; } static inline bool vm_need_virtualize_apic_accesses(struct kvm kvm) { return flexpriority_enabled && irqchip_in_kernel(kvm); } static inline bool cpu_has_vmx_vpid(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_ENABLE_VPID; } static inline bool cpu_has_vmx_rdtscp(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_RDTSCP; } static inline bool cpu_has_vmx_invpcid(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_ENABLE_INVPCID; } static inline bool cpu_has_virtual_nmis(void) { return vmcs_config.pin_based_exec_ctrl & PIN_BASED_VIRTUAL_NMIS; } static inline bool cpu_has_vmx_wbinvd_exit(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_WBINVD_EXITING; } static inline bool cpu_has_vmx_shadow_vmcs(void) { u64 vmx_msr; rdmsrl(MSR_IA32_VMX_MISC, vmx_msr); / check if the cpu supports writing r/o exit information fields / if (!(vmx_msr & MSR_IA32_VMX_MISC_VMWRITE_SHADOW_RO_FIELDS)) return false; return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_SHADOW_VMCS; } static inline bool report_flexpriority(void) { return flexpriority_enabled; } static inline bool nested_cpu_has(struct vmcs12 vmcs12, u32 bit) { return vmcs12->cpu_based_vm_exec_control & bit; } static inline bool nested_cpu_has2(struct vmcs12 vmcs12, u32 bit) { return (vmcs12->cpu_based_vm_exec_control & CPU_BASED_ACTIVATE_SECONDARY_CONTROLS) && (vmcs12->secondary_vm_exec_control & bit); } static inline bool nested_cpu_has_virtual_nmis(struct vmcs12 vmcs12) { return vmcs12->pin_based_vm_exec_control & PIN_BASED_VIRTUAL_NMIS; } static inline bool nested_cpu_has_preemption_timer(struct vmcs12 vmcs12) { return vmcs12->pin_based_vm_exec_control & PIN_BASED_VMX_PREEMPTION_TIMER; } static inline int nested_cpu_has_ept(struct vmcs12 vmcs12) { return nested_cpu_has2(vmcs12, SECONDARY_EXEC_ENABLE_EPT); } static inline bool is_exception(u32 intr_info) { return (intr_info & (INTR_INFO_INTR_TYPE_MASK \| INTR_INFO_VALID_MASK)) == (INTR_TYPE_HARD_EXCEPTION \| INTR_INFO_VALID_MASK); } static void nested_vmx_vmexit(struct kvm_vcpu vcpu, u32 exit_reason, u32 exit_intr_info, unsigned long exit_qualification); static void nested_vmx_entry_failure(struct kvm_vcpu vcpu, struct vmcs12 vmcs12, u32 reason, unsigned long qualification); static int __find_msr_index(struct vcpu_vmx vmx, u32 msr) { int i; for (i = 0; i < vmx->nmsrs; ++i) if (vmx_msr_index[vmx->guest_msrs[i].index] == msr) return i; return -1; } static inline void __invvpid(int ext, u16 vpid, gva_t gva) { struct { u64 vpid : 16; u64 rsvd : 48; u64 gva; } operand = { vpid, 0, gva }; asm volatile (__ex(ASM_VMX_INVVPID) /* CF==1 or ZF==1 --> rc = -1 / "; ja 1f ; ud2 ; 1:" : : "a"(&operand), "c"(ext) : "cc", "memory"); } static inline void __invept(int ext, u64 eptp, gpa_t gpa) { struct { u64 eptp, gpa; } operand = {eptp, gpa}; asm volatile (__ex(ASM_VMX_INVEPT) / CF==1 or ZF==1 --> rc = -1 / "; ja 1f ; ud2 ; 1:\n" : : "a" (&operand), "c" (ext) : "cc", "memory"); } static struct shared_msr_entry find_msr_entry(struct vcpu_vmx vmx, u32 msr) { int i; i = __find_msr_index(vmx, msr); if (i >= 0) return &vmx->guest_msrs[i]; return NULL; } static void vmcs_clear(struct vmcs vmcs) { u64 phys_addr = __pa(vmcs); u8 error; asm volatile (__ex(ASM_VMX_VMCLEAR_RAX) "; setna %0" : "=qm"(error) : "a"(&phys_addr), "m"(phys_addr) : "cc", "memory"); if (error) printk(KERN_ERR "kvm: vmclear fail: %p/%llx\n", vmcs, phys_addr); } static inline void loaded_vmcs_init(struct loaded_vmcs loaded_vmcs) { vmcs_clear(loaded_vmcs->vmcs); loaded_vmcs->cpu = -1; loaded_vmcs->launched = 0; } static void vmcs_load(struct vmcs vmcs) { u64 phys_addr = __pa(vmcs); u8 error; asm volatile (__ex(ASM_VMX_VMPTRLD_RAX) "; setna %0" : "=qm"(error) : "a"(&phys_addr), "m"(phys_addr) : "cc", "memory"); if (error) printk(KERN_ERR "kvm: vmptrld %p/%llx failed\n", vmcs, phys_addr); } #ifdef CONFIG_KEXEC /* * This bitmap is used to indicate whether the vmclear * operation is enabled on all cpus. All disabled by * default. / static cpumask_t crash_vmclear_enabled_bitmap = CPU_MASK_NONE; static inline void crash_enable_local_vmclear(int cpu) { cpumask_set_cpu(cpu, &crash_vmclear_enabled_bitmap); } static inline void crash_disable_local_vmclear(int cpu) { cpumask_clear_cpu(cpu, &crash_vmclear_enabled_bitmap); } static inline int crash_local_vmclear_enabled(int cpu) { return cpumask_test_cpu(cpu, &crash_vmclear_enabled_bitmap); } static void crash_vmclear_local_loaded_vmcss(void) { int cpu = raw_smp_processor_id(); struct loaded_vmcs v; if (!crash_local_vmclear_enabled(cpu)) return; list_for_each_entry(v, &per_cpu(loaded_vmcss_on_cpu, cpu), loaded_vmcss_on_cpu_link) vmcs_clear(v->vmcs); } #else static inline void crash_enable_local_vmclear(int cpu) { } static inline void crash_disable_local_vmclear(int cpu) { } #endif /* CONFIG_KEXEC / static void __loaded_vmcs_clear(void arg) { struct loaded_vmcs loaded_vmcs = arg; int cpu = raw_smp_processor_id(); if (loaded_vmcs->cpu != cpu) return; / vcpu migration can race with cpu offline / if (per_cpu(current_vmcs, cpu) == loaded_vmcs->vmcs) per_cpu(current_vmcs, cpu) = NULL; crash_disable_local_vmclear(cpu); list_del(&loaded_vmcs->loaded_vmcss_on_cpu_link); / * we should ensure updating loaded_vmcs->loaded_vmcss_on_cpu_link * is before setting loaded_vmcs->vcpu to -1 which is done in * loaded_vmcs_init. Otherwise, other cpu can see vcpu = -1 fist * then adds the vmcs into percpu list before it is deleted. / smp_wmb(); loaded_vmcs_init(loaded_vmcs); crash_enable_local_vmclear(cpu); } static void loaded_vmcs_clear(struct loaded_vmcs loaded_vmcs) { int cpu = loaded_vmcs->cpu; if (cpu != -1) smp_call_function_single(cpu, __loaded_vmcs_clear, loaded_vmcs, 1); } static inline void vpid_sync_vcpu_single(struct vcpu_vmx vmx) { if (vmx->vpid == 0) return; if (cpu_has_vmx_invvpid_single()) __invvpid(VMX_VPID_EXTENT_SINGLE_CONTEXT, vmx->vpid, 0); } static inline void vpid_sync_vcpu_global(void) { if (cpu_has_vmx_invvpid_global()) __invvpid(VMX_VPID_EXTENT_ALL_CONTEXT, 0, 0); } static inline void vpid_sync_context(struct vcpu_vmx vmx) { if (cpu_has_vmx_invvpid_single()) vpid_sync_vcpu_single(vmx); else vpid_sync_vcpu_global(); } static inline void ept_sync_global(void) { if (cpu_has_vmx_invept_global()) __invept(VMX_EPT_EXTENT_GLOBAL, 0, 0); } static inline void ept_sync_context(u64 eptp) { if (enable_ept) { if (cpu_has_vmx_invept_context()) __invept(VMX_EPT_EXTENT_CONTEXT, eptp, 0); else ept_sync_global(); } } static __always_inline unsigned long vmcs_readl(unsigned long field) { unsigned long value; asm volatile (__ex_clear(ASM_VMX_VMREAD_RDX_RAX, "%0") : "=a"(value) : "d"(field) : "cc"); return value; } static __always_inline u16 vmcs_read16(unsigned long field) { return vmcs_readl(field); } static __always_inline u32 vmcs_read32(unsigned long field) { return vmcs_readl(field); } static __always_inline u64 vmcs_read64(unsigned long field) { #ifdef CONFIG_X86_64 return vmcs_readl(field); #else return vmcs_readl(field) \| ((u64)vmcs_readl(field+1) << 32); #endif } static noinline void vmwrite_error(unsigned long field, unsigned long value) { printk(KERN_ERR "vmwrite error: reg %lx value %lx (err %d)\n", field, value, vmcs_read32(VM_INSTRUCTION_ERROR)); dump_stack(); } static void vmcs_writel(unsigned long field, unsigned long value) { u8 error; asm volatile (__ex(ASM_VMX_VMWRITE_RAX_RDX) "; setna %0" : "=q"(error) : "a"(value), "d"(field) : "cc"); if (unlikely(error)) vmwrite_error(field, value); } static void vmcs_write16(unsigned long field, u16 value) { vmcs_writel(field, value); } static void vmcs_write32(unsigned long field, u32 value) { vmcs_writel(field, value); } static void vmcs_write64(unsigned long field, u64 value) { vmcs_writel(field, value); #ifndef CONFIG_X86_64 asm volatile (""); vmcs_writel(field+1, value >> 32); #endif } static void vmcs_clear_bits(unsigned long field, u32 mask) { vmcs_writel(field, vmcs_readl(field) & ~mask); } static void vmcs_set_bits(unsigned long field, u32 mask) { vmcs_writel(field, vmcs_readl(field) \| mask); } static inline void vm_entry_controls_init(struct vcpu_vmx vmx, u32 val) { vmcs_write32(VM_ENTRY_CONTROLS, val); vmx->vm_entry_controls_shadow = val; } static inline void vm_entry_controls_set(struct vcpu_vmx vmx, u32 val) { if (vmx->vm_entry_controls_shadow != val) vm_entry_controls_init(vmx, val); } static inline u32 vm_entry_controls_get(struct vcpu_vmx vmx) { return vmx->vm_entry_controls_shadow; } static inline void vm_entry_controls_setbit(struct vcpu_vmx vmx, u32 val) { vm_entry_controls_set(vmx, vm_entry_controls_get(vmx) \| val); } static inline void vm_entry_controls_clearbit(struct vcpu_vmx vmx, u32 val) { vm_entry_controls_set(vmx, vm_entry_controls_get(vmx) & ~val); } static inline void vm_exit_controls_init(struct vcpu_vmx vmx, u32 val) { vmcs_write32(VM_EXIT_CONTROLS, val); vmx->vm_exit_controls_shadow = val; } static inline void vm_exit_controls_set(struct vcpu_vmx vmx, u32 val) { if (vmx->vm_exit_controls_shadow != val) vm_exit_controls_init(vmx, val); } static inline u32 vm_exit_controls_get(struct vcpu_vmx vmx) { return vmx->vm_exit_controls_shadow; } static inline void vm_exit_controls_setbit(struct vcpu_vmx vmx, u32 val) { vm_exit_controls_set(vmx, vm_exit_controls_get(vmx) \| val); } static inline void vm_exit_controls_clearbit(struct vcpu_vmx vmx, u32 val) { vm_exit_controls_set(vmx, vm_exit_controls_get(vmx) & ~val); } static void vmx_segment_cache_clear(struct vcpu_vmx vmx) { vmx->segment_cache.bitmask = 0; } static bool vmx_segment_cache_test_set(struct vcpu_vmx vmx, unsigned seg, unsigned field) { bool ret; u32 mask = 1 << (seg * SEG_FIELD_NR + field); if (!(vmx->vcpu.arch.regs_avail & (1 << VCPU_EXREG_SEGMENTS))) { vmx->vcpu.arch.regs_avail \|= (1 << VCPU_EXREG_SEGMENTS); vmx->segment_cache.bitmask = 0; } ret = vmx->segment_cache.bitmask & mask; vmx->segment_cache.bitmask \|= mask; return ret; } static u16 vmx_read_guest_seg_selector(struct vcpu_vmx vmx, unsigned seg) { u16 p = &vmx->segment_cache.seg[seg].selector; if (!vmx_segment_cache_test_set(vmx, seg, SEG_FIELD_SEL)) p = vmcs_read16(kvm_vmx_segment_fields[seg].selector); return p; } static ulong vmx_read_guest_seg_base(struct vcpu_vmx vmx, unsigned seg) { ulong p = &vmx->segment_cache.seg[seg].base; if (!vmx_segment_cache_test_set(vmx, seg, SEG_FIELD_BASE)) p = vmcs_readl(kvm_vmx_segment_fields[seg].base); return p; } static u32 vmx_read_guest_seg_limit(struct vcpu_vmx vmx, unsigned seg) { u32 p = &vmx->segment_cache.seg[seg].limit; if (!vmx_segment_cache_test_set(vmx, seg, SEG_FIELD_LIMIT)) p = vmcs_read32(kvm_vmx_segment_fields[seg].limit); return p; } static u32 vmx_read_guest_seg_ar(struct vcpu_vmx vmx, unsigned seg) { u32 p = &vmx->segment_cache.seg[seg].ar; if (!vmx_segment_cache_test_set(vmx, seg, SEG_FIELD_AR)) p = vmcs_read32(kvm_vmx_segment_fields[seg].ar_bytes); return p; } static void update_exception_bitmap(struct kvm_vcpu vcpu) { u32 eb; eb = (1u << PF_VECTOR) \| (1u << UD_VECTOR) \| (1u << MC_VECTOR) \| (1u << NM_VECTOR) \| (1u << DB_VECTOR); if ((vcpu->guest_debug & (KVM_GUESTDBG_ENABLE \| KVM_GUESTDBG_USE_SW_BP)) == (KVM_GUESTDBG_ENABLE \| KVM_GUESTDBG_USE_SW_BP)) eb \|= 1u << BP_VECTOR; if (to_vmx(vcpu)->rmode.vm86_active) eb = ~0; if (enable_ept) eb &= ~(1u << PF_VECTOR); / bypass_guest_pf = 0 / if (vcpu->fpu_active) eb &= ~(1u << NM_VECTOR); / When we are running a nested L2 guest and L1 specified for it a * certain exception bitmap, we must trap the same exceptions and pass * them to L1. When running L2, we will only handle the exceptions * specified above if L1 did not want them. / if (is_guest_mode(vcpu)) eb \|= get_vmcs12(vcpu)->exception_bitmap; vmcs_write32(EXCEPTION_BITMAP, eb); } static void clear_atomic_switch_msr_special(struct vcpu_vmx vmx, unsigned long entry, unsigned long exit) { vm_entry_controls_clearbit(vmx, entry); vm_exit_controls_clearbit(vmx, exit); } static void clear_atomic_switch_msr(struct vcpu_vmx vmx, unsigned msr) { unsigned i; struct msr_autoload m = &vmx->msr_autoload; switch (msr) { case MSR_EFER: if (cpu_has_load_ia32_efer) { clear_atomic_switch_msr_special(vmx, VM_ENTRY_LOAD_IA32_EFER, VM_EXIT_LOAD_IA32_EFER); return; } break; case MSR_CORE_PERF_GLOBAL_CTRL: if (cpu_has_load_perf_global_ctrl) { clear_atomic_switch_msr_special(vmx, VM_ENTRY_LOAD_IA32_PERF_GLOBAL_CTRL, VM_EXIT_LOAD_IA32_PERF_GLOBAL_CTRL); return; } break; } for (i = 0; i < m->nr; ++i) if (m->guest[i].index == msr) break; if (i == m->nr) return; --m->nr; m->guest[i] = m->guest[m->nr]; m->host[i] = m->host[m->nr]; vmcs_write32(VM_ENTRY_MSR_LOAD_COUNT, m->nr); vmcs_write32(VM_EXIT_MSR_LOAD_COUNT, m->nr); } static void add_atomic_switch_msr_special(struct vcpu_vmx vmx, unsigned long entry, unsigned long exit, unsigned long guest_val_vmcs, unsigned long host_val_vmcs, u64 guest_val, u64 host_val) { vmcs_write64(guest_val_vmcs, guest_val); vmcs_write64(host_val_vmcs, host_val); vm_entry_controls_setbit(vmx, entry); vm_exit_controls_setbit(vmx, exit); } static void add_atomic_switch_msr(struct vcpu_vmx vmx, unsigned msr, u64 guest_val, u64 host_val) { unsigned i; struct msr_autoload m = &vmx->msr_autoload; switch (msr) { case MSR_EFER: if (cpu_has_load_ia32_efer) { add_atomic_switch_msr_special(vmx, VM_ENTRY_LOAD_IA32_EFER, VM_EXIT_LOAD_IA32_EFER, GUEST_IA32_EFER, HOST_IA32_EFER, guest_val, host_val); return; } break; case MSR_CORE_PERF_GLOBAL_CTRL: if (cpu_has_load_perf_global_ctrl) { add_atomic_switch_msr_special(vmx, VM_ENTRY_LOAD_IA32_PERF_GLOBAL_CTRL, VM_EXIT_LOAD_IA32_PERF_GLOBAL_CTRL, GUEST_IA32_PERF_GLOBAL_CTRL, HOST_IA32_PERF_GLOBAL_CTRL, guest_val, host_val); return; } break; } for (i = 0; i < m->nr; ++i) if (m->guest[i].index == msr) break; if (i == NR_AUTOLOAD_MSRS) { printk_once(KERN_WARNING "Not enough msr switch entries. " "Can't add msr %x\n", msr); return; } else if (i == m->nr) { ++m->nr; vmcs_write32(VM_ENTRY_MSR_LOAD_COUNT, m->nr); vmcs_write32(VM_EXIT_MSR_LOAD_COUNT, m->nr); } m->guest[i].index = msr; m->guest[i].value = guest_val; m->host[i].index = msr; m->host[i].value = host_val; } static void reload_tss(void) { / * VT restores TR but not its size. Useless. / struct desc_ptr gdt = this_cpu_ptr(&host_gdt); struct desc_struct descs; descs = (void )gdt->address; descs[GDT_ENTRY_TSS].type = 9; /* available TSS / load_TR_desc(); } static bool update_transition_efer(struct vcpu_vmx vmx, int efer_offset) { u64 guest_efer; u64 ignore_bits; guest_efer = vmx->vcpu.arch.efer; /* * NX is emulated; LMA and LME handled by hardware; SCE meaningless * outside long mode / ignore_bits = EFER_NX \| EFER_SCE; #ifdef CONFIG_X86_64 ignore_bits \|= EFER_LMA \| EFER_LME; / SCE is meaningful only in long mode on Intel / if (guest_efer & EFER_LMA) ignore_bits &= ~(u64)EFER_SCE; #endif guest_efer &= ~ignore_bits; guest_efer \|= host_efer & ignore_bits; vmx->guest_msrs[efer_offset].data = guest_efer; vmx->guest_msrs[efer_offset].mask = ~ignore_bits; clear_atomic_switch_msr(vmx, MSR_EFER); / On ept, can't emulate nx, and must switch nx atomically / if (enable_ept && ((vmx->vcpu.arch.efer ^ host_efer) & EFER_NX)) { guest_efer = vmx->vcpu.arch.efer; if (!(guest_efer & EFER_LMA)) guest_efer &= ~EFER_LME; add_atomic_switch_msr(vmx, MSR_EFER, guest_efer, host_efer); return false; } return true; } static unsigned long segment_base(u16 selector) { struct desc_ptr gdt = this_cpu_ptr(&host_gdt); struct desc_struct d; unsigned long table_base; unsigned long v; if (!(selector & ~3)) return 0; table_base = gdt->address; if (selector & 4) { / from ldt / u16 ldt_selector = kvm_read_ldt(); if (!(ldt_selector & ~3)) return 0; table_base = segment_base(ldt_selector); } d = (struct desc_struct )(table_base + (selector & ~7)); v = get_desc_base(d); #ifdef CONFIG_X86_64 if (d->s == 0 && (d->type == 2 \|\| d->type == 9 \|\| d->type == 11)) v \|= ((unsigned long)((struct ldttss_desc64 )d)->base3) << 32; #endif return v; } static inline unsigned long kvm_read_tr_base(void) { u16 tr; asm("str %0" : "=g"(tr)); return segment_base(tr); } static void vmx_save_host_state(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); int i; if (vmx->host_state.loaded) return; vmx->host_state.loaded = 1; / * Set host fs and gs selectors. Unfortunately, 22.2.3 does not * allow segment selectors with cpl > 0 or ti == 1. / vmx->host_state.ldt_sel = kvm_read_ldt(); vmx->host_state.gs_ldt_reload_needed = vmx->host_state.ldt_sel; savesegment(fs, vmx->host_state.fs_sel); if (!(vmx->host_state.fs_sel & 7)) { vmcs_write16(HOST_FS_SELECTOR, vmx->host_state.fs_sel); vmx->host_state.fs_reload_needed = 0; } else { vmcs_write16(HOST_FS_SELECTOR, 0); vmx->host_state.fs_reload_needed = 1; } savesegment(gs, vmx->host_state.gs_sel); if (!(vmx->host_state.gs_sel & 7)) vmcs_write16(HOST_GS_SELECTOR, vmx->host_state.gs_sel); else { vmcs_write16(HOST_GS_SELECTOR, 0); vmx->host_state.gs_ldt_reload_needed = 1; } #ifdef CONFIG_X86_64 savesegment(ds, vmx->host_state.ds_sel); savesegment(es, vmx->host_state.es_sel); #endif #ifdef CONFIG_X86_64 vmcs_writel(HOST_FS_BASE, read_msr(MSR_FS_BASE)); vmcs_writel(HOST_GS_BASE, read_msr(MSR_GS_BASE)); #else vmcs_writel(HOST_FS_BASE, segment_base(vmx->host_state.fs_sel)); vmcs_writel(HOST_GS_BASE, segment_base(vmx->host_state.gs_sel)); #endif #ifdef CONFIG_X86_64 rdmsrl(MSR_KERNEL_GS_BASE, vmx->msr_host_kernel_gs_base); if (is_long_mode(&vmx->vcpu)) wrmsrl(MSR_KERNEL_GS_BASE, vmx->msr_guest_kernel_gs_base); #endif if (boot_cpu_has(X86_FEATURE_MPX)) rdmsrl(MSR_IA32_BNDCFGS, vmx->host_state.msr_host_bndcfgs); for (i = 0; i < vmx->save_nmsrs; ++i) kvm_set_shared_msr(vmx->guest_msrs[i].index, vmx->guest_msrs[i].data, vmx->guest_msrs[i].mask); } static void __vmx_load_host_state(struct vcpu_vmx vmx) { if (!vmx->host_state.loaded) return; ++vmx->vcpu.stat.host_state_reload; vmx->host_state.loaded = 0; #ifdef CONFIG_X86_64 if (is_long_mode(&vmx->vcpu)) rdmsrl(MSR_KERNEL_GS_BASE, vmx->msr_guest_kernel_gs_base); #endif if (vmx->host_state.gs_ldt_reload_needed) { kvm_load_ldt(vmx->host_state.ldt_sel); #ifdef CONFIG_X86_64 load_gs_index(vmx->host_state.gs_sel); #else loadsegment(gs, vmx->host_state.gs_sel); #endif } if (vmx->host_state.fs_reload_needed) loadsegment(fs, vmx->host_state.fs_sel); #ifdef CONFIG_X86_64 if (unlikely(vmx->host_state.ds_sel \| vmx->host_state.es_sel)) { loadsegment(ds, vmx->host_state.ds_sel); loadsegment(es, vmx->host_state.es_sel); } #endif reload_tss(); #ifdef CONFIG_X86_64 wrmsrl(MSR_KERNEL_GS_BASE, vmx->msr_host_kernel_gs_base); #endif if (vmx->host_state.msr_host_bndcfgs) wrmsrl(MSR_IA32_BNDCFGS, vmx->host_state.msr_host_bndcfgs); /* * If the FPU is not active (through the host task or * the guest vcpu), then restore the cr0.TS bit. / if (!user_has_fpu() && !vmx->vcpu.guest_fpu_loaded) stts(); load_gdt(this_cpu_ptr(&host_gdt)); } static void vmx_load_host_state(struct vcpu_vmx vmx) { preempt_disable(); __vmx_load_host_state(vmx); preempt_enable(); } /* * Switches to specified vcpu, until a matching vcpu_put(), but assumes * vcpu mutex is already taken. / static void vmx_vcpu_load(struct kvm_vcpu vcpu, int cpu) { struct vcpu_vmx vmx = to_vmx(vcpu); u64 phys_addr = __pa(per_cpu(vmxarea, cpu)); if (!vmm_exclusive) kvm_cpu_vmxon(phys_addr); else if (vmx->loaded_vmcs->cpu != cpu) loaded_vmcs_clear(vmx->loaded_vmcs); if (per_cpu(current_vmcs, cpu) != vmx->loaded_vmcs->vmcs) { per_cpu(current_vmcs, cpu) = vmx->loaded_vmcs->vmcs; vmcs_load(vmx->loaded_vmcs->vmcs); } if (vmx->loaded_vmcs->cpu != cpu) { struct desc_ptr gdt = this_cpu_ptr(&host_gdt); unsigned long sysenter_esp; kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu); local_irq_disable(); crash_disable_local_vmclear(cpu); /* * Read loaded_vmcs->cpu should be before fetching * loaded_vmcs->loaded_vmcss_on_cpu_link. * See the comments in __loaded_vmcs_clear(). / smp_rmb(); list_add(&vmx->loaded_vmcs->loaded_vmcss_on_cpu_link, &per_cpu(loaded_vmcss_on_cpu, cpu)); crash_enable_local_vmclear(cpu); local_irq_enable(); / * Linux uses per-cpu TSS and GDT, so set these when switching * processors. / vmcs_writel(HOST_TR_BASE, kvm_read_tr_base()); / 22.2.4 / vmcs_writel(HOST_GDTR_BASE, gdt->address); / 22.2.4 / rdmsrl(MSR_IA32_SYSENTER_ESP, sysenter_esp); vmcs_writel(HOST_IA32_SYSENTER_ESP, sysenter_esp); / 22.2.3 / vmx->loaded_vmcs->cpu = cpu; } } static void vmx_vcpu_put(struct kvm_vcpu vcpu) { __vmx_load_host_state(to_vmx(vcpu)); if (!vmm_exclusive) { __loaded_vmcs_clear(to_vmx(vcpu)->loaded_vmcs); vcpu->cpu = -1; kvm_cpu_vmxoff(); } } static void vmx_fpu_activate(struct kvm_vcpu vcpu) { ulong cr0; if (vcpu->fpu_active) return; vcpu->fpu_active = 1; cr0 = vmcs_readl(GUEST_CR0); cr0 &= ~(X86_CR0_TS \| X86_CR0_MP); cr0 \|= kvm_read_cr0_bits(vcpu, X86_CR0_TS \| X86_CR0_MP); vmcs_writel(GUEST_CR0, cr0); update_exception_bitmap(vcpu); vcpu->arch.cr0_guest_owned_bits = X86_CR0_TS; if (is_guest_mode(vcpu)) vcpu->arch.cr0_guest_owned_bits &= ~get_vmcs12(vcpu)->cr0_guest_host_mask; vmcs_writel(CR0_GUEST_HOST_MASK, ~vcpu->arch.cr0_guest_owned_bits); } static void vmx_decache_cr0_guest_bits(struct kvm_vcpu vcpu); /* * Return the cr0 value that a nested guest would read. This is a combination * of the real cr0 used to run the guest (guest_cr0), and the bits shadowed by * its hypervisor (cr0_read_shadow). / static inline unsigned long nested_read_cr0(struct vmcs12 fields) { return (fields->guest_cr0 & ~fields->cr0_guest_host_mask) \| (fields->cr0_read_shadow & fields->cr0_guest_host_mask); } static inline unsigned long nested_read_cr4(struct vmcs12 fields) { return (fields->guest_cr4 & ~fields->cr4_guest_host_mask) \| (fields->cr4_read_shadow & fields->cr4_guest_host_mask); } static void vmx_fpu_deactivate(struct kvm_vcpu vcpu) { /* Note that there is no vcpu->fpu_active = 0 here. The caller must * set this before calling this function. / vmx_decache_cr0_guest_bits(vcpu); vmcs_set_bits(GUEST_CR0, X86_CR0_TS \| X86_CR0_MP); update_exception_bitmap(vcpu); vcpu->arch.cr0_guest_owned_bits = 0; vmcs_writel(CR0_GUEST_HOST_MASK, ~vcpu->arch.cr0_guest_owned_bits); if (is_guest_mode(vcpu)) { / * L1's specified read shadow might not contain the TS bit, * so now that we turned on shadowing of this bit, we need to * set this bit of the shadow. Like in nested_vmx_run we need * nested_read_cr0(vmcs12), but vmcs12->guest_cr0 is not yet * up-to-date here because we just decached cr0.TS (and we'll * only update vmcs12->guest_cr0 on nested exit). / struct vmcs12 vmcs12 = get_vmcs12(vcpu); vmcs12->guest_cr0 = (vmcs12->guest_cr0 & ~X86_CR0_TS) \| (vcpu->arch.cr0 & X86_CR0_TS); vmcs_writel(CR0_READ_SHADOW, nested_read_cr0(vmcs12)); } else vmcs_writel(CR0_READ_SHADOW, vcpu->arch.cr0); } static unsigned long vmx_get_rflags(struct kvm_vcpu vcpu) { unsigned long rflags, save_rflags; if (!test_bit(VCPU_EXREG_RFLAGS, (ulong )&vcpu->arch.regs_avail)) { __set_bit(VCPU_EXREG_RFLAGS, (ulong )&vcpu->arch.regs_avail); rflags = vmcs_readl(GUEST_RFLAGS); if (to_vmx(vcpu)->rmode.vm86_active) { rflags &= RMODE_GUEST_OWNED_EFLAGS_BITS; save_rflags = to_vmx(vcpu)->rmode.save_rflags; rflags \|= save_rflags & ~RMODE_GUEST_OWNED_EFLAGS_BITS; } to_vmx(vcpu)->rflags = rflags; } return to_vmx(vcpu)->rflags; } static void vmx_set_rflags(struct kvm_vcpu vcpu, unsigned long rflags) { __set_bit(VCPU_EXREG_RFLAGS, (ulong )&vcpu->arch.regs_avail); to_vmx(vcpu)->rflags = rflags; if (to_vmx(vcpu)->rmode.vm86_active) { to_vmx(vcpu)->rmode.save_rflags = rflags; rflags \|= X86_EFLAGS_IOPL \| X86_EFLAGS_VM; } vmcs_writel(GUEST_RFLAGS, rflags); } static u32 vmx_get_interrupt_shadow(struct kvm_vcpu vcpu) { u32 interruptibility = vmcs_read32(GUEST_INTERRUPTIBILITY_INFO); int ret = 0; if (interruptibility & GUEST_INTR_STATE_STI) ret \|= KVM_X86_SHADOW_INT_STI; if (interruptibility & GUEST_INTR_STATE_MOV_SS) ret \|= KVM_X86_SHADOW_INT_MOV_SS; return ret; } static void vmx_set_interrupt_shadow(struct kvm_vcpu vcpu, int mask) { u32 interruptibility_old = vmcs_read32(GUEST_INTERRUPTIBILITY_INFO); u32 interruptibility = interruptibility_old; interruptibility &= ~(GUEST_INTR_STATE_STI \| GUEST_INTR_STATE_MOV_SS); if (mask & KVM_X86_SHADOW_INT_MOV_SS) interruptibility \|= GUEST_INTR_STATE_MOV_SS; else if (mask & KVM_X86_SHADOW_INT_STI) interruptibility \|= GUEST_INTR_STATE_STI; if ((interruptibility != interruptibility_old)) vmcs_write32(GUEST_INTERRUPTIBILITY_INFO, interruptibility); } static void skip_emulated_instruction(struct kvm_vcpu vcpu) { unsigned long rip; rip = kvm_rip_read(vcpu); rip += vmcs_read32(VM_EXIT_INSTRUCTION_LEN); kvm_rip_write(vcpu, rip); /* skipping an emulated instruction also counts / vmx_set_interrupt_shadow(vcpu, 0); } / * KVM wants to inject page-faults which it got to the guest. This function * checks whether in a nested guest, we need to inject them to L1 or L2. / static int nested_vmx_check_exception(struct kvm_vcpu vcpu, unsigned nr) { struct vmcs12 vmcs12 = get_vmcs12(vcpu); if (!(vmcs12->exception_bitmap & (1u << nr))) return 0; nested_vmx_vmexit(vcpu, to_vmx(vcpu)->exit_reason, vmcs_read32(VM_EXIT_INTR_INFO), vmcs_readl(EXIT_QUALIFICATION)); return 1; } static void vmx_queue_exception(struct kvm_vcpu vcpu, unsigned nr, bool has_error_code, u32 error_code, bool reinject) { struct vcpu_vmx vmx = to_vmx(vcpu); u32 intr_info = nr \| INTR_INFO_VALID_MASK; if (!reinject && is_guest_mode(vcpu) && nested_vmx_check_exception(vcpu, nr)) return; if (has_error_code) { vmcs_write32(VM_ENTRY_EXCEPTION_ERROR_CODE, error_code); intr_info \|= INTR_INFO_DELIVER_CODE_MASK; } if (vmx->rmode.vm86_active) { int inc_eip = 0; if (kvm_exception_is_soft(nr)) inc_eip = vcpu->arch.event_exit_inst_len; if (kvm_inject_realmode_interrupt(vcpu, nr, inc_eip) != EMULATE_DONE) kvm_make_request(KVM_REQ_TRIPLE_FAULT, vcpu); return; } if (kvm_exception_is_soft(nr)) { vmcs_write32(VM_ENTRY_INSTRUCTION_LEN, vmx->vcpu.arch.event_exit_inst_len); intr_info \|= INTR_TYPE_SOFT_EXCEPTION; } else intr_info \|= INTR_TYPE_HARD_EXCEPTION; vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, intr_info); } static bool vmx_rdtscp_supported(void) { return cpu_has_vmx_rdtscp(); } static bool vmx_invpcid_supported(void) { return cpu_has_vmx_invpcid() && enable_ept; } / * Swap MSR entry in host/guest MSR entry array. / static void move_msr_up(struct vcpu_vmx vmx, int from, int to) { struct shared_msr_entry tmp; tmp = vmx->guest_msrs[to]; vmx->guest_msrs[to] = vmx->guest_msrs[from]; vmx->guest_msrs[from] = tmp; } static void vmx_set_msr_bitmap(struct kvm_vcpu vcpu) { unsigned long msr_bitmap; if (irqchip_in_kernel(vcpu->kvm) && apic_x2apic_mode(vcpu->arch.apic)) { if (is_long_mode(vcpu)) msr_bitmap = vmx_msr_bitmap_longmode_x2apic; else msr_bitmap = vmx_msr_bitmap_legacy_x2apic; } else { if (is_long_mode(vcpu)) msr_bitmap = vmx_msr_bitmap_longmode; else msr_bitmap = vmx_msr_bitmap_legacy; } vmcs_write64(MSR_BITMAP, __pa(msr_bitmap)); } /* * Set up the vmcs to automatically save and restore system * msrs. Don't touch the 64-bit msrs if the guest is in legacy * mode, as fiddling with msrs is very expensive. / static void setup_msrs(struct vcpu_vmx vmx) { int save_nmsrs, index; save_nmsrs = 0; #ifdef CONFIG_X86_64 if (is_long_mode(&vmx->vcpu)) { index = __find_msr_index(vmx, MSR_SYSCALL_MASK); if (index >= 0) move_msr_up(vmx, index, save_nmsrs++); index = __find_msr_index(vmx, MSR_LSTAR); if (index >= 0) move_msr_up(vmx, index, save_nmsrs++); index = __find_msr_index(vmx, MSR_CSTAR); if (index >= 0) move_msr_up(vmx, index, save_nmsrs++); index = __find_msr_index(vmx, MSR_TSC_AUX); if (index >= 0 && vmx->rdtscp_enabled) move_msr_up(vmx, index, save_nmsrs++); /* * MSR_STAR is only needed on long mode guests, and only * if efer.sce is enabled. / index = __find_msr_index(vmx, MSR_STAR); if ((index >= 0) && (vmx->vcpu.arch.efer & EFER_SCE)) move_msr_up(vmx, index, save_nmsrs++); } #endif index = __find_msr_index(vmx, MSR_EFER); if (index >= 0 && update_transition_efer(vmx, index)) move_msr_up(vmx, index, save_nmsrs++); vmx->save_nmsrs = save_nmsrs; if (cpu_has_vmx_msr_bitmap()) vmx_set_msr_bitmap(&vmx->vcpu); } / * reads and returns guest's timestamp counter "register" * guest_tsc = host_tsc + tsc_offset -- 21.3 / static u64 guest_read_tsc(void) { u64 host_tsc, tsc_offset; rdtscll(host_tsc); tsc_offset = vmcs_read64(TSC_OFFSET); return host_tsc + tsc_offset; } / * Like guest_read_tsc, but always returns L1's notion of the timestamp * counter, even if a nested guest (L2) is currently running. / static u64 vmx_read_l1_tsc(struct kvm_vcpu vcpu, u64 host_tsc) { u64 tsc_offset; tsc_offset = is_guest_mode(vcpu) ? to_vmx(vcpu)->nested.vmcs01_tsc_offset : vmcs_read64(TSC_OFFSET); return host_tsc + tsc_offset; } /* * Engage any workarounds for mis-matched TSC rates. Currently limited to * software catchup for faster rates on slower CPUs. / static void vmx_set_tsc_khz(struct kvm_vcpu vcpu, u32 user_tsc_khz, bool scale) { if (!scale) return; if (user_tsc_khz > tsc_khz) { vcpu->arch.tsc_catchup = 1; vcpu->arch.tsc_always_catchup = 1; } else WARN(1, "user requested TSC rate below hardware speed\n"); } static u64 vmx_read_tsc_offset(struct kvm_vcpu vcpu) { return vmcs_read64(TSC_OFFSET); } / * writes 'offset' into guest's timestamp counter offset register / static void vmx_write_tsc_offset(struct kvm_vcpu vcpu, u64 offset) { if (is_guest_mode(vcpu)) { /* * We're here if L1 chose not to trap WRMSR to TSC. According * to the spec, this should set L1's TSC; The offset that L1 * set for L2 remains unchanged, and still needs to be added * to the newly set TSC to get L2's TSC. / struct vmcs12 vmcs12; to_vmx(vcpu)->nested.vmcs01_tsc_offset = offset; /* recalculate vmcs02.TSC_OFFSET: / vmcs12 = get_vmcs12(vcpu); vmcs_write64(TSC_OFFSET, offset + (nested_cpu_has(vmcs12, CPU_BASED_USE_TSC_OFFSETING) ? vmcs12->tsc_offset : 0)); } else { trace_kvm_write_tsc_offset(vcpu->vcpu_id, vmcs_read64(TSC_OFFSET), offset); vmcs_write64(TSC_OFFSET, offset); } } static void vmx_adjust_tsc_offset(struct kvm_vcpu vcpu, s64 adjustment, bool host) { u64 offset = vmcs_read64(TSC_OFFSET); vmcs_write64(TSC_OFFSET, offset + adjustment); if (is_guest_mode(vcpu)) { /* Even when running L2, the adjustment needs to apply to L1 / to_vmx(vcpu)->nested.vmcs01_tsc_offset += adjustment; } else trace_kvm_write_tsc_offset(vcpu->vcpu_id, offset, offset + adjustment); } static u64 vmx_compute_tsc_offset(struct kvm_vcpu vcpu, u64 target_tsc) { return target_tsc - native_read_tsc(); } static bool guest_cpuid_has_vmx(struct kvm_vcpu vcpu) { struct kvm_cpuid_entry2 best = kvm_find_cpuid_entry(vcpu, 1, 0); return best && (best->ecx & (1 << (X86_FEATURE_VMX & 31))); } /* * nested_vmx_allowed() checks whether a guest should be allowed to use VMX * instructions and MSRs (i.e., nested VMX). Nested VMX is disabled for * all guests if the "nested" module option is off, and can also be disabled * for a single guest by disabling its VMX cpuid bit. / static inline bool nested_vmx_allowed(struct kvm_vcpu vcpu) { return nested && guest_cpuid_has_vmx(vcpu); } /* * nested_vmx_setup_ctls_msrs() sets up variables containing the values to be * returned for the various VMX controls MSRs when nested VMX is enabled. * The same values should also be used to verify that vmcs12 control fields are * valid during nested entry from L1 to L2. * Each of these control msrs has a low and high 32-bit half: A low bit is on * if the corresponding bit in the (32-bit) control field must be on, and a * bit in the high half is on if the corresponding bit in the control field * may be on. See also vmx_control_verify(). * TODO: allow these variables to be modified (downgraded) by module options * or other means. / static u32 nested_vmx_procbased_ctls_low, nested_vmx_procbased_ctls_high; static u32 nested_vmx_true_procbased_ctls_low; static u32 nested_vmx_secondary_ctls_low, nested_vmx_secondary_ctls_high; static u32 nested_vmx_pinbased_ctls_low, nested_vmx_pinbased_ctls_high; static u32 nested_vmx_exit_ctls_low, nested_vmx_exit_ctls_high; static u32 nested_vmx_true_exit_ctls_low; static u32 nested_vmx_entry_ctls_low, nested_vmx_entry_ctls_high; static u32 nested_vmx_true_entry_ctls_low; static u32 nested_vmx_misc_low, nested_vmx_misc_high; static u32 nested_vmx_ept_caps; static __init void nested_vmx_setup_ctls_msrs(void) { / * Note that as a general rule, the high half of the MSRs (bits in * the control fields which may be 1) should be initialized by the * intersection of the underlying hardware's MSR (i.e., features which * can be supported) and the list of features we want to expose - * because they are known to be properly supported in our code. * Also, usually, the low half of the MSRs (bits which must be 1) can * be set to 0, meaning that L1 may turn off any of these bits. The * reason is that if one of these bits is necessary, it will appear * in vmcs01 and prepare_vmcs02, when it bitwise-or's the control * fields of vmcs01 and vmcs02, will turn these bits off - and * nested_vmx_exit_handled() will not pass related exits to L1. * These rules have exceptions below. / / pin-based controls / rdmsr(MSR_IA32_VMX_PINBASED_CTLS, nested_vmx_pinbased_ctls_low, nested_vmx_pinbased_ctls_high); nested_vmx_pinbased_ctls_low \|= PIN_BASED_ALWAYSON_WITHOUT_TRUE_MSR; nested_vmx_pinbased_ctls_high &= PIN_BASED_EXT_INTR_MASK \| PIN_BASED_NMI_EXITING \| PIN_BASED_VIRTUAL_NMIS; nested_vmx_pinbased_ctls_high \|= PIN_BASED_ALWAYSON_WITHOUT_TRUE_MSR \| PIN_BASED_VMX_PREEMPTION_TIMER; / exit controls / rdmsr(MSR_IA32_VMX_EXIT_CTLS, nested_vmx_exit_ctls_low, nested_vmx_exit_ctls_high); nested_vmx_exit_ctls_low = VM_EXIT_ALWAYSON_WITHOUT_TRUE_MSR; nested_vmx_exit_ctls_high &= #ifdef CONFIG_X86_64 VM_EXIT_HOST_ADDR_SPACE_SIZE \| #endif VM_EXIT_LOAD_IA32_PAT \| VM_EXIT_SAVE_IA32_PAT; nested_vmx_exit_ctls_high \|= VM_EXIT_ALWAYSON_WITHOUT_TRUE_MSR \| VM_EXIT_LOAD_IA32_EFER \| VM_EXIT_SAVE_IA32_EFER \| VM_EXIT_SAVE_VMX_PREEMPTION_TIMER \| VM_EXIT_ACK_INTR_ON_EXIT; if (vmx_mpx_supported()) nested_vmx_exit_ctls_high \|= VM_EXIT_CLEAR_BNDCFGS; / We support free control of debug control saving. / nested_vmx_true_exit_ctls_low = nested_vmx_exit_ctls_low & ~VM_EXIT_SAVE_DEBUG_CONTROLS; / entry controls / rdmsr(MSR_IA32_VMX_ENTRY_CTLS, nested_vmx_entry_ctls_low, nested_vmx_entry_ctls_high); nested_vmx_entry_ctls_low = VM_ENTRY_ALWAYSON_WITHOUT_TRUE_MSR; nested_vmx_entry_ctls_high &= #ifdef CONFIG_X86_64 VM_ENTRY_IA32E_MODE \| #endif VM_ENTRY_LOAD_IA32_PAT; nested_vmx_entry_ctls_high \|= (VM_ENTRY_ALWAYSON_WITHOUT_TRUE_MSR \| VM_ENTRY_LOAD_IA32_EFER); if (vmx_mpx_supported()) nested_vmx_entry_ctls_high \|= VM_ENTRY_LOAD_BNDCFGS; / We support free control of debug control loading. / nested_vmx_true_entry_ctls_low = nested_vmx_entry_ctls_low & ~VM_ENTRY_LOAD_DEBUG_CONTROLS; / cpu-based controls / rdmsr(MSR_IA32_VMX_PROCBASED_CTLS, nested_vmx_procbased_ctls_low, nested_vmx_procbased_ctls_high); nested_vmx_procbased_ctls_low = CPU_BASED_ALWAYSON_WITHOUT_TRUE_MSR; nested_vmx_procbased_ctls_high &= CPU_BASED_VIRTUAL_INTR_PENDING \| CPU_BASED_VIRTUAL_NMI_PENDING \| CPU_BASED_USE_TSC_OFFSETING \| CPU_BASED_HLT_EXITING \| CPU_BASED_INVLPG_EXITING \| CPU_BASED_MWAIT_EXITING \| CPU_BASED_CR3_LOAD_EXITING \| CPU_BASED_CR3_STORE_EXITING \| #ifdef CONFIG_X86_64 CPU_BASED_CR8_LOAD_EXITING \| CPU_BASED_CR8_STORE_EXITING \| #endif CPU_BASED_MOV_DR_EXITING \| CPU_BASED_UNCOND_IO_EXITING \| CPU_BASED_USE_IO_BITMAPS \| CPU_BASED_MONITOR_EXITING \| CPU_BASED_RDPMC_EXITING \| CPU_BASED_RDTSC_EXITING \| CPU_BASED_PAUSE_EXITING \| CPU_BASED_TPR_SHADOW \| CPU_BASED_ACTIVATE_SECONDARY_CONTROLS; / * We can allow some features even when not supported by the * hardware. For example, L1 can specify an MSR bitmap - and we * can use it to avoid exits to L1 - even when L0 runs L2 * without MSR bitmaps. / nested_vmx_procbased_ctls_high \|= CPU_BASED_ALWAYSON_WITHOUT_TRUE_MSR \| CPU_BASED_USE_MSR_BITMAPS; / We support free control of CR3 access interception. / nested_vmx_true_procbased_ctls_low = nested_vmx_procbased_ctls_low & ~(CPU_BASED_CR3_LOAD_EXITING \| CPU_BASED_CR3_STORE_EXITING); / secondary cpu-based controls / rdmsr(MSR_IA32_VMX_PROCBASED_CTLS2, nested_vmx_secondary_ctls_low, nested_vmx_secondary_ctls_high); nested_vmx_secondary_ctls_low = 0; nested_vmx_secondary_ctls_high &= SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES \| SECONDARY_EXEC_UNRESTRICTED_GUEST \| SECONDARY_EXEC_WBINVD_EXITING; if (enable_ept) { / nested EPT: emulate EPT also to L1 / nested_vmx_secondary_ctls_high \|= SECONDARY_EXEC_ENABLE_EPT; nested_vmx_ept_caps = VMX_EPT_PAGE_WALK_4_BIT \| VMX_EPTP_WB_BIT \| VMX_EPT_2MB_PAGE_BIT \| VMX_EPT_INVEPT_BIT; nested_vmx_ept_caps &= vmx_capability.ept; / * For nested guests, we don't do anything specific * for single context invalidation. Hence, only advertise * support for global context invalidation. / nested_vmx_ept_caps \|= VMX_EPT_EXTENT_GLOBAL_BIT; } else nested_vmx_ept_caps = 0; / miscellaneous data / rdmsr(MSR_IA32_VMX_MISC, nested_vmx_misc_low, nested_vmx_misc_high); nested_vmx_misc_low &= VMX_MISC_SAVE_EFER_LMA; nested_vmx_misc_low \|= VMX_MISC_EMULATED_PREEMPTION_TIMER_RATE \| VMX_MISC_ACTIVITY_HLT; nested_vmx_misc_high = 0; } static inline bool vmx_control_verify(u32 control, u32 low, u32 high) { / * Bits 0 in high must be 0, and bits 1 in low must be 1. / return ((control & high) \| low) == control; } static inline u64 vmx_control_msr(u32 low, u32 high) { return low \| ((u64)high << 32); } / Returns 0 on success, non-0 otherwise. / static int vmx_get_vmx_msr(struct kvm_vcpu vcpu, u32 msr_index, u64 pdata) { switch (msr_index) { case MSR_IA32_VMX_BASIC: / * This MSR reports some information about VMX support. We * should return information about the VMX we emulate for the * guest, and the VMCS structure we give it - not about the * VMX support of the underlying hardware. / pdata = VMCS12_REVISION \| VMX_BASIC_TRUE_CTLS \| ((u64)VMCS12_SIZE << VMX_BASIC_VMCS_SIZE_SHIFT) \| (VMX_BASIC_MEM_TYPE_WB << VMX_BASIC_MEM_TYPE_SHIFT); break; case MSR_IA32_VMX_TRUE_PINBASED_CTLS: case MSR_IA32_VMX_PINBASED_CTLS: pdata = vmx_control_msr(nested_vmx_pinbased_ctls_low, nested_vmx_pinbased_ctls_high); break; case MSR_IA32_VMX_TRUE_PROCBASED_CTLS: pdata = vmx_control_msr(nested_vmx_true_procbased_ctls_low, nested_vmx_procbased_ctls_high); break; case MSR_IA32_VMX_PROCBASED_CTLS: pdata = vmx_control_msr(nested_vmx_procbased_ctls_low, nested_vmx_procbased_ctls_high); break; case MSR_IA32_VMX_TRUE_EXIT_CTLS: pdata = vmx_control_msr(nested_vmx_true_exit_ctls_low, nested_vmx_exit_ctls_high); break; case MSR_IA32_VMX_EXIT_CTLS: pdata = vmx_control_msr(nested_vmx_exit_ctls_low, nested_vmx_exit_ctls_high); break; case MSR_IA32_VMX_TRUE_ENTRY_CTLS: pdata = vmx_control_msr(nested_vmx_true_entry_ctls_low, nested_vmx_entry_ctls_high); break; case MSR_IA32_VMX_ENTRY_CTLS: pdata = vmx_control_msr(nested_vmx_entry_ctls_low, nested_vmx_entry_ctls_high); break; case MSR_IA32_VMX_MISC: pdata = vmx_control_msr(nested_vmx_misc_low, nested_vmx_misc_high); break; /* * These MSRs specify bits which the guest must keep fixed (on or off) * while L1 is in VMXON mode (in L1's root mode, or running an L2). * We picked the standard core2 setting. / #define VMXON_CR0_ALWAYSON (X86_CR0_PE \| X86_CR0_PG \| X86_CR0_NE) #define VMXON_CR4_ALWAYSON X86_CR4_VMXE case MSR_IA32_VMX_CR0_FIXED0: pdata = VMXON_CR0_ALWAYSON; break; case MSR_IA32_VMX_CR0_FIXED1: pdata = -1ULL; break; case MSR_IA32_VMX_CR4_FIXED0: pdata = VMXON_CR4_ALWAYSON; break; case MSR_IA32_VMX_CR4_FIXED1: pdata = -1ULL; break; case MSR_IA32_VMX_VMCS_ENUM: pdata = 0x2e; /* highest index: VMX_PREEMPTION_TIMER_VALUE / break; case MSR_IA32_VMX_PROCBASED_CTLS2: pdata = vmx_control_msr(nested_vmx_secondary_ctls_low, nested_vmx_secondary_ctls_high); break; case MSR_IA32_VMX_EPT_VPID_CAP: /* Currently, no nested vpid support / pdata = nested_vmx_ept_caps; break; default: return 1; } return 0; } /* * Reads an msr value (of 'msr_index') into 'pdata'. * Returns 0 on success, non-0 otherwise. * Assumes vcpu_load() was already called. / static int vmx_get_msr(struct kvm_vcpu vcpu, u32 msr_index, u64 pdata) { u64 data; struct shared_msr_entry msr; if (!pdata) { printk(KERN_ERR "BUG: get_msr called with NULL pdata\n"); return -EINVAL; } switch (msr_index) { #ifdef CONFIG_X86_64 case MSR_FS_BASE: data = vmcs_readl(GUEST_FS_BASE); break; case MSR_GS_BASE: data = vmcs_readl(GUEST_GS_BASE); break; case MSR_KERNEL_GS_BASE: vmx_load_host_state(to_vmx(vcpu)); data = to_vmx(vcpu)->msr_guest_kernel_gs_base; break; #endif case MSR_EFER: return kvm_get_msr_common(vcpu, msr_index, pdata); case MSR_IA32_TSC: data = guest_read_tsc(); break; case MSR_IA32_SYSENTER_CS: data = vmcs_read32(GUEST_SYSENTER_CS); break; case MSR_IA32_SYSENTER_EIP: data = vmcs_readl(GUEST_SYSENTER_EIP); break; case MSR_IA32_SYSENTER_ESP: data = vmcs_readl(GUEST_SYSENTER_ESP); break; case MSR_IA32_BNDCFGS: if (!vmx_mpx_supported()) return 1; data = vmcs_read64(GUEST_BNDCFGS); break; case MSR_IA32_FEATURE_CONTROL: if (!nested_vmx_allowed(vcpu)) return 1; data = to_vmx(vcpu)->nested.msr_ia32_feature_control; break; case MSR_IA32_VMX_BASIC ... MSR_IA32_VMX_VMFUNC: if (!nested_vmx_allowed(vcpu)) return 1; return vmx_get_vmx_msr(vcpu, msr_index, pdata); case MSR_TSC_AUX: if (!to_vmx(vcpu)->rdtscp_enabled) return 1; /* Otherwise falls through / default: msr = find_msr_entry(to_vmx(vcpu), msr_index); if (msr) { data = msr->data; break; } return kvm_get_msr_common(vcpu, msr_index, pdata); } pdata = data; return 0; } static void vmx_leave_nested(struct kvm_vcpu vcpu); / * Writes msr value into into the appropriate "register". * Returns 0 on success, non-0 otherwise. * Assumes vcpu_load() was already called. / static int vmx_set_msr(struct kvm_vcpu vcpu, struct msr_data msr_info) { struct vcpu_vmx vmx = to_vmx(vcpu); struct shared_msr_entry msr; int ret = 0; u32 msr_index = msr_info->index; u64 data = msr_info->data; switch (msr_index) { case MSR_EFER: ret = kvm_set_msr_common(vcpu, msr_info); break; #ifdef CONFIG_X86_64 case MSR_FS_BASE: vmx_segment_cache_clear(vmx); vmcs_writel(GUEST_FS_BASE, data); break; case MSR_GS_BASE: vmx_segment_cache_clear(vmx); vmcs_writel(GUEST_GS_BASE, data); break; case MSR_KERNEL_GS_BASE: vmx_load_host_state(vmx); vmx->msr_guest_kernel_gs_base = data; break; #endif case MSR_IA32_SYSENTER_CS: vmcs_write32(GUEST_SYSENTER_CS, data); break; case MSR_IA32_SYSENTER_EIP: vmcs_writel(GUEST_SYSENTER_EIP, data); break; case MSR_IA32_SYSENTER_ESP: vmcs_writel(GUEST_SYSENTER_ESP, data); break; case MSR_IA32_BNDCFGS: if (!vmx_mpx_supported()) return 1; vmcs_write64(GUEST_BNDCFGS, data); break; case MSR_IA32_TSC: kvm_write_tsc(vcpu, msr_info); break; case MSR_IA32_CR_PAT: if (vmcs_config.vmentry_ctrl & VM_ENTRY_LOAD_IA32_PAT) { if (!kvm_mtrr_valid(vcpu, MSR_IA32_CR_PAT, data)) return 1; vmcs_write64(GUEST_IA32_PAT, data); vcpu->arch.pat = data; break; } ret = kvm_set_msr_common(vcpu, msr_info); break; case MSR_IA32_TSC_ADJUST: ret = kvm_set_msr_common(vcpu, msr_info); break; case MSR_IA32_FEATURE_CONTROL: if (!nested_vmx_allowed(vcpu) \|\| (to_vmx(vcpu)->nested.msr_ia32_feature_control & FEATURE_CONTROL_LOCKED && !msr_info->host_initiated)) return 1; vmx->nested.msr_ia32_feature_control = data; if (msr_info->host_initiated && data == 0) vmx_leave_nested(vcpu); break; case MSR_IA32_VMX_BASIC ... MSR_IA32_VMX_VMFUNC: return 1; / they are read-only / case MSR_TSC_AUX: if (!vmx->rdtscp_enabled) return 1; / Check reserved bit, higher 32 bits should be zero / if ((data >> 32) != 0) return 1; / Otherwise falls through / default: msr = find_msr_entry(vmx, msr_index); if (msr) { u64 old_msr_data = msr->data; msr->data = data; if (msr - vmx->guest_msrs < vmx->save_nmsrs) { preempt_disable(); ret = kvm_set_shared_msr(msr->index, msr->data, msr->mask); preempt_enable(); if (ret) msr->data = old_msr_data; } break; } ret = kvm_set_msr_common(vcpu, msr_info); } return ret; } static void vmx_cache_reg(struct kvm_vcpu vcpu, enum kvm_reg reg) { __set_bit(reg, (unsigned long )&vcpu->arch.regs_avail); switch (reg) { case VCPU_REGS_RSP: vcpu->arch.regs[VCPU_REGS_RSP] = vmcs_readl(GUEST_RSP); break; case VCPU_REGS_RIP: vcpu->arch.regs[VCPU_REGS_RIP] = vmcs_readl(GUEST_RIP); break; case VCPU_EXREG_PDPTR: if (enable_ept) ept_save_pdptrs(vcpu); break; default: break; } } static __init int cpu_has_kvm_support(void) { return cpu_has_vmx(); } static __init int vmx_disabled_by_bios(void) { u64 msr; rdmsrl(MSR_IA32_FEATURE_CONTROL, msr); if (msr & FEATURE_CONTROL_LOCKED) { / launched w/ TXT and VMX disabled / if (!(msr & FEATURE_CONTROL_VMXON_ENABLED_INSIDE_SMX) && tboot_enabled()) return 1; / launched w/o TXT and VMX only enabled w/ TXT / if (!(msr & FEATURE_CONTROL_VMXON_ENABLED_OUTSIDE_SMX) && (msr & FEATURE_CONTROL_VMXON_ENABLED_INSIDE_SMX) && !tboot_enabled()) { printk(KERN_WARNING "kvm: disable TXT in the BIOS or " "activate TXT before enabling KVM\n"); return 1; } / launched w/o TXT and VMX disabled / if (!(msr & FEATURE_CONTROL_VMXON_ENABLED_OUTSIDE_SMX) && !tboot_enabled()) return 1; } return 0; } static void kvm_cpu_vmxon(u64 addr) { asm volatile (ASM_VMX_VMXON_RAX : : "a"(&addr), "m"(addr) : "memory", "cc"); } static int hardware_enable(void) { int cpu = raw_smp_processor_id(); u64 phys_addr = __pa(per_cpu(vmxarea, cpu)); u64 old, test_bits; if (read_cr4() & X86_CR4_VMXE) return -EBUSY; INIT_LIST_HEAD(&per_cpu(loaded_vmcss_on_cpu, cpu)); / * Now we can enable the vmclear operation in kdump * since the loaded_vmcss_on_cpu list on this cpu * has been initialized. * * Though the cpu is not in VMX operation now, there * is no problem to enable the vmclear operation * for the loaded_vmcss_on_cpu list is empty! / crash_enable_local_vmclear(cpu); rdmsrl(MSR_IA32_FEATURE_CONTROL, old); test_bits = FEATURE_CONTROL_LOCKED; test_bits \|= FEATURE_CONTROL_VMXON_ENABLED_OUTSIDE_SMX; if (tboot_enabled()) test_bits \|= FEATURE_CONTROL_VMXON_ENABLED_INSIDE_SMX; if ((old & test_bits) != test_bits) { / enable and lock / wrmsrl(MSR_IA32_FEATURE_CONTROL, old \| test_bits); } write_cr4(read_cr4() \| X86_CR4_VMXE); / FIXME: not cpu hotplug safe / if (vmm_exclusive) { kvm_cpu_vmxon(phys_addr); ept_sync_global(); } native_store_gdt(this_cpu_ptr(&host_gdt)); return 0; } static void vmclear_local_loaded_vmcss(void) { int cpu = raw_smp_processor_id(); struct loaded_vmcs v, n; list_for_each_entry_safe(v, n, &per_cpu(loaded_vmcss_on_cpu, cpu), loaded_vmcss_on_cpu_link) __loaded_vmcs_clear(v); } / Just like cpu_vmxoff(), but with the __kvm_handle_fault_on_reboot() * tricks. / static void kvm_cpu_vmxoff(void) { asm volatile (__ex(ASM_VMX_VMXOFF) : : : "cc"); } static void hardware_disable(void) { if (vmm_exclusive) { vmclear_local_loaded_vmcss(); kvm_cpu_vmxoff(); } write_cr4(read_cr4() & ~X86_CR4_VMXE); } static __init int adjust_vmx_controls(u32 ctl_min, u32 ctl_opt, u32 msr, u32 result) { u32 vmx_msr_low, vmx_msr_high; u32 ctl = ctl_min \| ctl_opt; rdmsr(msr, vmx_msr_low, vmx_msr_high); ctl &= vmx_msr_high; /* bit == 0 in high word ==> must be zero / ctl \|= vmx_msr_low; / bit == 1 in low word ==> must be one / / Ensure minimum (required) set of control bits are supported. / if (ctl_min & ~ctl) return -EIO; result = ctl; return 0; } static __init bool allow_1_setting(u32 msr, u32 ctl) { u32 vmx_msr_low, vmx_msr_high; rdmsr(msr, vmx_msr_low, vmx_msr_high); return vmx_msr_high & ctl; } static __init int setup_vmcs_config(struct vmcs_config vmcs_conf) { u32 vmx_msr_low, vmx_msr_high; u32 min, opt, min2, opt2; u32 _pin_based_exec_control = 0; u32 _cpu_based_exec_control = 0; u32 _cpu_based_2nd_exec_control = 0; u32 _vmexit_control = 0; u32 _vmentry_control = 0; min = CPU_BASED_HLT_EXITING \| #ifdef CONFIG_X86_64 CPU_BASED_CR8_LOAD_EXITING \| CPU_BASED_CR8_STORE_EXITING \| #endif CPU_BASED_CR3_LOAD_EXITING \| CPU_BASED_CR3_STORE_EXITING \| CPU_BASED_USE_IO_BITMAPS \| CPU_BASED_MOV_DR_EXITING \| CPU_BASED_USE_TSC_OFFSETING \| CPU_BASED_MWAIT_EXITING \| CPU_BASED_MONITOR_EXITING \| CPU_BASED_INVLPG_EXITING \| CPU_BASED_RDPMC_EXITING; opt = CPU_BASED_TPR_SHADOW \| CPU_BASED_USE_MSR_BITMAPS \| CPU_BASED_ACTIVATE_SECONDARY_CONTROLS; if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_PROCBASED_CTLS, &_cpu_based_exec_control) < 0) return -EIO; #ifdef CONFIG_X86_64 if ((_cpu_based_exec_control & CPU_BASED_TPR_SHADOW)) _cpu_based_exec_control &= ~CPU_BASED_CR8_LOAD_EXITING & ~CPU_BASED_CR8_STORE_EXITING; #endif if (_cpu_based_exec_control & CPU_BASED_ACTIVATE_SECONDARY_CONTROLS) { min2 = 0; opt2 = SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES \| SECONDARY_EXEC_VIRTUALIZE_X2APIC_MODE \| SECONDARY_EXEC_WBINVD_EXITING \| SECONDARY_EXEC_ENABLE_VPID \| SECONDARY_EXEC_ENABLE_EPT \| SECONDARY_EXEC_UNRESTRICTED_GUEST \| SECONDARY_EXEC_PAUSE_LOOP_EXITING \| SECONDARY_EXEC_RDTSCP \| SECONDARY_EXEC_ENABLE_INVPCID \| SECONDARY_EXEC_APIC_REGISTER_VIRT \| SECONDARY_EXEC_VIRTUAL_INTR_DELIVERY \| SECONDARY_EXEC_SHADOW_VMCS; if (adjust_vmx_controls(min2, opt2, MSR_IA32_VMX_PROCBASED_CTLS2, &_cpu_based_2nd_exec_control) < 0) return -EIO; } #ifndef CONFIG_X86_64 if (!(_cpu_based_2nd_exec_control & SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES)) _cpu_based_exec_control &= ~CPU_BASED_TPR_SHADOW; #endif if (!(_cpu_based_exec_control & CPU_BASED_TPR_SHADOW)) _cpu_based_2nd_exec_control &= ~( SECONDARY_EXEC_APIC_REGISTER_VIRT \| SECONDARY_EXEC_VIRTUALIZE_X2APIC_MODE \| SECONDARY_EXEC_VIRTUAL_INTR_DELIVERY); if (_cpu_based_2nd_exec_control & SECONDARY_EXEC_ENABLE_EPT) { / CR3 accesses and invlpg don't need to cause VM Exits when EPT enabled / _cpu_based_exec_control &= ~(CPU_BASED_CR3_LOAD_EXITING \| CPU_BASED_CR3_STORE_EXITING \| CPU_BASED_INVLPG_EXITING); rdmsr(MSR_IA32_VMX_EPT_VPID_CAP, vmx_capability.ept, vmx_capability.vpid); } min = VM_EXIT_SAVE_DEBUG_CONTROLS; #ifdef CONFIG_X86_64 min \|= VM_EXIT_HOST_ADDR_SPACE_SIZE; #endif opt = VM_EXIT_SAVE_IA32_PAT \| VM_EXIT_LOAD_IA32_PAT \| VM_EXIT_ACK_INTR_ON_EXIT \| VM_EXIT_CLEAR_BNDCFGS; if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_EXIT_CTLS, &_vmexit_control) < 0) return -EIO; min = PIN_BASED_EXT_INTR_MASK \| PIN_BASED_NMI_EXITING; opt = PIN_BASED_VIRTUAL_NMIS \| PIN_BASED_POSTED_INTR; if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_PINBASED_CTLS, &_pin_based_exec_control) < 0) return -EIO; if (!(_cpu_based_2nd_exec_control & SECONDARY_EXEC_VIRTUAL_INTR_DELIVERY) \|\| !(_vmexit_control & VM_EXIT_ACK_INTR_ON_EXIT)) _pin_based_exec_control &= ~PIN_BASED_POSTED_INTR; min = VM_ENTRY_LOAD_DEBUG_CONTROLS; opt = VM_ENTRY_LOAD_IA32_PAT \| VM_ENTRY_LOAD_BNDCFGS; if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_ENTRY_CTLS, &_vmentry_control) < 0) return -EIO; rdmsr(MSR_IA32_VMX_BASIC, vmx_msr_low, vmx_msr_high); / IA-32 SDM Vol 3B: VMCS size is never greater than 4kB. / if ((vmx_msr_high & 0x1fff) > PAGE_SIZE) return -EIO; #ifdef CONFIG_X86_64 / IA-32 SDM Vol 3B: 64-bit CPUs always have VMX_BASIC_MSR[48]==0. / if (vmx_msr_high & (1u<<16)) return -EIO; #endif / Require Write-Back (WB) memory type for VMCS accesses. / if (((vmx_msr_high >> 18) & 15) != 6) return -EIO; vmcs_conf->size = vmx_msr_high & 0x1fff; vmcs_conf->order = get_order(vmcs_config.size); vmcs_conf->revision_id = vmx_msr_low; vmcs_conf->pin_based_exec_ctrl = _pin_based_exec_control; vmcs_conf->cpu_based_exec_ctrl = _cpu_based_exec_control; vmcs_conf->cpu_based_2nd_exec_ctrl = _cpu_based_2nd_exec_control; vmcs_conf->vmexit_ctrl = _vmexit_control; vmcs_conf->vmentry_ctrl = _vmentry_control; cpu_has_load_ia32_efer = allow_1_setting(MSR_IA32_VMX_ENTRY_CTLS, VM_ENTRY_LOAD_IA32_EFER) && allow_1_setting(MSR_IA32_VMX_EXIT_CTLS, VM_EXIT_LOAD_IA32_EFER); cpu_has_load_perf_global_ctrl = allow_1_setting(MSR_IA32_VMX_ENTRY_CTLS, VM_ENTRY_LOAD_IA32_PERF_GLOBAL_CTRL) && allow_1_setting(MSR_IA32_VMX_EXIT_CTLS, VM_EXIT_LOAD_IA32_PERF_GLOBAL_CTRL); / * Some cpus support VM_ENTRY_(LOAD\|SAVE)_IA32_PERF_GLOBAL_CTRL * but due to arrata below it can't be used. Workaround is to use * msr load mechanism to switch IA32_PERF_GLOBAL_CTRL. * * VM Exit May Incorrectly Clear IA32_PERF_GLOBAL_CTRL [34:32] * * AAK155 (model 26) * AAP115 (model 30) * AAT100 (model 37) * BC86,AAY89,BD102 (model 44) * BA97 (model 46) * / if (cpu_has_load_perf_global_ctrl && boot_cpu_data.x86 == 0x6) { switch (boot_cpu_data.x86_model) { case 26: case 30: case 37: case 44: case 46: cpu_has_load_perf_global_ctrl = false; printk_once(KERN_WARNING"kvm: VM_EXIT_LOAD_IA32_PERF_GLOBAL_CTRL " "does not work properly. Using workaround\n"); break; default: break; } } return 0; } static struct vmcs alloc_vmcs_cpu(int cpu) { int node = cpu_to_node(cpu); struct page pages; struct vmcs vmcs; pages = alloc_pages_exact_node(node, GFP_KERNEL, vmcs_config.order); if (!pages) return NULL; vmcs = page_address(pages); memset(vmcs, 0, vmcs_config.size); vmcs->revision_id = vmcs_config.revision_id; /* vmcs revision id / return vmcs; } static struct vmcs alloc_vmcs(void) { return alloc_vmcs_cpu(raw_smp_processor_id()); } static void free_vmcs(struct vmcs vmcs) { free_pages((unsigned long)vmcs, vmcs_config.order); } / * Free a VMCS, but before that VMCLEAR it on the CPU where it was last loaded / static void free_loaded_vmcs(struct loaded_vmcs loaded_vmcs) { if (!loaded_vmcs->vmcs) return; loaded_vmcs_clear(loaded_vmcs); free_vmcs(loaded_vmcs->vmcs); loaded_vmcs->vmcs = NULL; } static void free_kvm_area(void) { int cpu; for_each_possible_cpu(cpu) { free_vmcs(per_cpu(vmxarea, cpu)); per_cpu(vmxarea, cpu) = NULL; } } static void init_vmcs_shadow_fields(void) { int i, j; /* No checks for read only fields yet / for (i = j = 0; i < max_shadow_read_write_fields; i++) { switch (shadow_read_write_fields[i]) { case GUEST_BNDCFGS: if (!vmx_mpx_supported()) continue; break; default: break; } if (j < i) shadow_read_write_fields[j] = shadow_read_write_fields[i]; j++; } max_shadow_read_write_fields = j; / shadowed fields guest access without vmexit / for (i = 0; i < max_shadow_read_write_fields; i++) { clear_bit(shadow_read_write_fields[i], vmx_vmwrite_bitmap); clear_bit(shadow_read_write_fields[i], vmx_vmread_bitmap); } for (i = 0; i < max_shadow_read_only_fields; i++) clear_bit(shadow_read_only_fields[i], vmx_vmread_bitmap); } static __init int alloc_kvm_area(void) { int cpu; for_each_possible_cpu(cpu) { struct vmcs vmcs; vmcs = alloc_vmcs_cpu(cpu); if (!vmcs) { free_kvm_area(); return -ENOMEM; } per_cpu(vmxarea, cpu) = vmcs; } return 0; } static __init int hardware_setup(void) { if (setup_vmcs_config(&vmcs_config) < 0) return -EIO; if (boot_cpu_has(X86_FEATURE_NX)) kvm_enable_efer_bits(EFER_NX); if (!cpu_has_vmx_vpid()) enable_vpid = 0; if (!cpu_has_vmx_shadow_vmcs()) enable_shadow_vmcs = 0; if (enable_shadow_vmcs) init_vmcs_shadow_fields(); if (!cpu_has_vmx_ept() \|\| !cpu_has_vmx_ept_4levels()) { enable_ept = 0; enable_unrestricted_guest = 0; enable_ept_ad_bits = 0; } if (!cpu_has_vmx_ept_ad_bits()) enable_ept_ad_bits = 0; if (!cpu_has_vmx_unrestricted_guest()) enable_unrestricted_guest = 0; if (!cpu_has_vmx_flexpriority()) { flexpriority_enabled = 0; /* * set_apic_access_page_addr() is used to reload apic access * page upon invalidation. No need to do anything if the * processor does not have the APIC_ACCESS_ADDR VMCS field. / kvm_x86_ops->set_apic_access_page_addr = NULL; } if (!cpu_has_vmx_tpr_shadow()) kvm_x86_ops->update_cr8_intercept = NULL; if (enable_ept && !cpu_has_vmx_ept_2m_page()) kvm_disable_largepages(); if (!cpu_has_vmx_ple()) ple_gap = 0; if (!cpu_has_vmx_apicv()) enable_apicv = 0; if (enable_apicv) kvm_x86_ops->update_cr8_intercept = NULL; else { kvm_x86_ops->hwapic_irr_update = NULL; kvm_x86_ops->deliver_posted_interrupt = NULL; kvm_x86_ops->sync_pir_to_irr = vmx_sync_pir_to_irr_dummy; } if (nested) nested_vmx_setup_ctls_msrs(); return alloc_kvm_area(); } static __exit void hardware_unsetup(void) { free_kvm_area(); } static bool emulation_required(struct kvm_vcpu vcpu) { return emulate_invalid_guest_state && !guest_state_valid(vcpu); } static void fix_pmode_seg(struct kvm_vcpu vcpu, int seg, struct kvm_segment save) { if (!emulate_invalid_guest_state) { /* * CS and SS RPL should be equal during guest entry according * to VMX spec, but in reality it is not always so. Since vcpu * is in the middle of the transition from real mode to * protected mode it is safe to assume that RPL 0 is a good * default value. / if (seg == VCPU_SREG_CS \|\| seg == VCPU_SREG_SS) save->selector &= ~SELECTOR_RPL_MASK; save->dpl = save->selector & SELECTOR_RPL_MASK; save->s = 1; } vmx_set_segment(vcpu, save, seg); } static void enter_pmode(struct kvm_vcpu vcpu) { unsigned long flags; struct vcpu_vmx vmx = to_vmx(vcpu); / * Update real mode segment cache. It may be not up-to-date if sement * register was written while vcpu was in a guest mode. / vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_ES], VCPU_SREG_ES); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_DS], VCPU_SREG_DS); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_FS], VCPU_SREG_FS); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_GS], VCPU_SREG_GS); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_SS], VCPU_SREG_SS); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_CS], VCPU_SREG_CS); vmx->rmode.vm86_active = 0; vmx_segment_cache_clear(vmx); vmx_set_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_TR], VCPU_SREG_TR); flags = vmcs_readl(GUEST_RFLAGS); flags &= RMODE_GUEST_OWNED_EFLAGS_BITS; flags \|= vmx->rmode.save_rflags & ~RMODE_GUEST_OWNED_EFLAGS_BITS; vmcs_writel(GUEST_RFLAGS, flags); vmcs_writel(GUEST_CR4, (vmcs_readl(GUEST_CR4) & ~X86_CR4_VME) \| (vmcs_readl(CR4_READ_SHADOW) & X86_CR4_VME)); update_exception_bitmap(vcpu); fix_pmode_seg(vcpu, VCPU_SREG_CS, &vmx->rmode.segs[VCPU_SREG_CS]); fix_pmode_seg(vcpu, VCPU_SREG_SS, &vmx->rmode.segs[VCPU_SREG_SS]); fix_pmode_seg(vcpu, VCPU_SREG_ES, &vmx->rmode.segs[VCPU_SREG_ES]); fix_pmode_seg(vcpu, VCPU_SREG_DS, &vmx->rmode.segs[VCPU_SREG_DS]); fix_pmode_seg(vcpu, VCPU_SREG_FS, &vmx->rmode.segs[VCPU_SREG_FS]); fix_pmode_seg(vcpu, VCPU_SREG_GS, &vmx->rmode.segs[VCPU_SREG_GS]); } static void fix_rmode_seg(int seg, struct kvm_segment save) { const struct kvm_vmx_segment_field sf = &kvm_vmx_segment_fields[seg]; struct kvm_segment var = save; var.dpl = 0x3; if (seg == VCPU_SREG_CS) var.type = 0x3; if (!emulate_invalid_guest_state) { var.selector = var.base >> 4; var.base = var.base & 0xffff0; var.limit = 0xffff; var.g = 0; var.db = 0; var.present = 1; var.s = 1; var.l = 0; var.unusable = 0; var.type = 0x3; var.avl = 0; if (save->base & 0xf) printk_once(KERN_WARNING "kvm: segment base is not " "paragraph aligned when entering " "protected mode (seg=%d)", seg); } vmcs_write16(sf->selector, var.selector); vmcs_write32(sf->base, var.base); vmcs_write32(sf->limit, var.limit); vmcs_write32(sf->ar_bytes, vmx_segment_access_rights(&var)); } static void enter_rmode(struct kvm_vcpu vcpu) { unsigned long flags; struct vcpu_vmx vmx = to_vmx(vcpu); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_TR], VCPU_SREG_TR); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_ES], VCPU_SREG_ES); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_DS], VCPU_SREG_DS); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_FS], VCPU_SREG_FS); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_GS], VCPU_SREG_GS); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_SS], VCPU_SREG_SS); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_CS], VCPU_SREG_CS); vmx->rmode.vm86_active = 1; /* * Very old userspace does not call KVM_SET_TSS_ADDR before entering * vcpu. Warn the user that an update is overdue. / if (!vcpu->kvm->arch.tss_addr) printk_once(KERN_WARNING "kvm: KVM_SET_TSS_ADDR need to be " "called before entering vcpu\n"); vmx_segment_cache_clear(vmx); vmcs_writel(GUEST_TR_BASE, vcpu->kvm->arch.tss_addr); vmcs_write32(GUEST_TR_LIMIT, RMODE_TSS_SIZE - 1); vmcs_write32(GUEST_TR_AR_BYTES, 0x008b); flags = vmcs_readl(GUEST_RFLAGS); vmx->rmode.save_rflags = flags; flags \|= X86_EFLAGS_IOPL \| X86_EFLAGS_VM; vmcs_writel(GUEST_RFLAGS, flags); vmcs_writel(GUEST_CR4, vmcs_readl(GUEST_CR4) \| X86_CR4_VME); update_exception_bitmap(vcpu); fix_rmode_seg(VCPU_SREG_SS, &vmx->rmode.segs[VCPU_SREG_SS]); fix_rmode_seg(VCPU_SREG_CS, &vmx->rmode.segs[VCPU_SREG_CS]); fix_rmode_seg(VCPU_SREG_ES, &vmx->rmode.segs[VCPU_SREG_ES]); fix_rmode_seg(VCPU_SREG_DS, &vmx->rmode.segs[VCPU_SREG_DS]); fix_rmode_seg(VCPU_SREG_GS, &vmx->rmode.segs[VCPU_SREG_GS]); fix_rmode_seg(VCPU_SREG_FS, &vmx->rmode.segs[VCPU_SREG_FS]); kvm_mmu_reset_context(vcpu); } static void vmx_set_efer(struct kvm_vcpu vcpu, u64 efer) { struct vcpu_vmx vmx = to_vmx(vcpu); struct shared_msr_entry msr = find_msr_entry(vmx, MSR_EFER); if (!msr) return; /* * Force kernel_gs_base reloading before EFER changes, as control * of this msr depends on is_long_mode(). / vmx_load_host_state(to_vmx(vcpu)); vcpu->arch.efer = efer; if (efer & EFER_LMA) { vm_entry_controls_setbit(to_vmx(vcpu), VM_ENTRY_IA32E_MODE); msr->data = efer; } else { vm_entry_controls_clearbit(to_vmx(vcpu), VM_ENTRY_IA32E_MODE); msr->data = efer & ~EFER_LME; } setup_msrs(vmx); } #ifdef CONFIG_X86_64 static void enter_lmode(struct kvm_vcpu vcpu) { u32 guest_tr_ar; vmx_segment_cache_clear(to_vmx(vcpu)); guest_tr_ar = vmcs_read32(GUEST_TR_AR_BYTES); if ((guest_tr_ar & AR_TYPE_MASK) != AR_TYPE_BUSY_64_TSS) { pr_debug_ratelimited("%s: tss fixup for long mode. \n", __func__); vmcs_write32(GUEST_TR_AR_BYTES, (guest_tr_ar & ~AR_TYPE_MASK) \| AR_TYPE_BUSY_64_TSS); } vmx_set_efer(vcpu, vcpu->arch.efer \| EFER_LMA); } static void exit_lmode(struct kvm_vcpu vcpu) { vm_entry_controls_clearbit(to_vmx(vcpu), VM_ENTRY_IA32E_MODE); vmx_set_efer(vcpu, vcpu->arch.efer & ~EFER_LMA); } #endif static void vmx_flush_tlb(struct kvm_vcpu vcpu) { vpid_sync_context(to_vmx(vcpu)); if (enable_ept) { if (!VALID_PAGE(vcpu->arch.mmu.root_hpa)) return; ept_sync_context(construct_eptp(vcpu->arch.mmu.root_hpa)); } } static void vmx_decache_cr0_guest_bits(struct kvm_vcpu vcpu) { ulong cr0_guest_owned_bits = vcpu->arch.cr0_guest_owned_bits; vcpu->arch.cr0 &= ~cr0_guest_owned_bits; vcpu->arch.cr0 \|= vmcs_readl(GUEST_CR0) & cr0_guest_owned_bits; } static void vmx_decache_cr3(struct kvm_vcpu vcpu) { if (enable_ept && is_paging(vcpu)) vcpu->arch.cr3 = vmcs_readl(GUEST_CR3); __set_bit(VCPU_EXREG_CR3, (ulong )&vcpu->arch.regs_avail); } static void vmx_decache_cr4_guest_bits(struct kvm_vcpu vcpu) { ulong cr4_guest_owned_bits = vcpu->arch.cr4_guest_owned_bits; vcpu->arch.cr4 &= ~cr4_guest_owned_bits; vcpu->arch.cr4 \|= vmcs_readl(GUEST_CR4) & cr4_guest_owned_bits; } static void ept_load_pdptrs(struct kvm_vcpu vcpu) { struct kvm_mmu mmu = vcpu->arch.walk_mmu; if (!test_bit(VCPU_EXREG_PDPTR, (unsigned long )&vcpu->arch.regs_dirty)) return; if (is_paging(vcpu) && is_pae(vcpu) && !is_long_mode(vcpu)) { vmcs_write64(GUEST_PDPTR0, mmu->pdptrs[0]); vmcs_write64(GUEST_PDPTR1, mmu->pdptrs[1]); vmcs_write64(GUEST_PDPTR2, mmu->pdptrs[2]); vmcs_write64(GUEST_PDPTR3, mmu->pdptrs[3]); } } static void ept_save_pdptrs(struct kvm_vcpu vcpu) { struct kvm_mmu mmu = vcpu->arch.walk_mmu; if (is_paging(vcpu) && is_pae(vcpu) && !is_long_mode(vcpu)) { mmu->pdptrs[0] = vmcs_read64(GUEST_PDPTR0); mmu->pdptrs[1] = vmcs_read64(GUEST_PDPTR1); mmu->pdptrs[2] = vmcs_read64(GUEST_PDPTR2); mmu->pdptrs[3] = vmcs_read64(GUEST_PDPTR3); } __set_bit(VCPU_EXREG_PDPTR, (unsigned long )&vcpu->arch.regs_avail); __set_bit(VCPU_EXREG_PDPTR, (unsigned long )&vcpu->arch.regs_dirty); } static int vmx_set_cr4(struct kvm_vcpu vcpu, unsigned long cr4); static void ept_update_paging_mode_cr0(unsigned long hw_cr0, unsigned long cr0, struct kvm_vcpu vcpu) { if (!test_bit(VCPU_EXREG_CR3, (ulong )&vcpu->arch.regs_avail)) vmx_decache_cr3(vcpu); if (!(cr0 & X86_CR0_PG)) { / From paging/starting to nonpaging / vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, vmcs_read32(CPU_BASED_VM_EXEC_CONTROL) \| (CPU_BASED_CR3_LOAD_EXITING \| CPU_BASED_CR3_STORE_EXITING)); vcpu->arch.cr0 = cr0; vmx_set_cr4(vcpu, kvm_read_cr4(vcpu)); } else if (!is_paging(vcpu)) { / From nonpaging to paging / vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, vmcs_read32(CPU_BASED_VM_EXEC_CONTROL) & ~(CPU_BASED_CR3_LOAD_EXITING \| CPU_BASED_CR3_STORE_EXITING)); vcpu->arch.cr0 = cr0; vmx_set_cr4(vcpu, kvm_read_cr4(vcpu)); } if (!(cr0 & X86_CR0_WP)) hw_cr0 &= ~X86_CR0_WP; } static void vmx_set_cr0(struct kvm_vcpu vcpu, unsigned long cr0) { struct vcpu_vmx vmx = to_vmx(vcpu); unsigned long hw_cr0; hw_cr0 = (cr0 & ~KVM_GUEST_CR0_MASK); if (enable_unrestricted_guest) hw_cr0 \|= KVM_VM_CR0_ALWAYS_ON_UNRESTRICTED_GUEST; else { hw_cr0 \|= KVM_VM_CR0_ALWAYS_ON; if (vmx->rmode.vm86_active && (cr0 & X86_CR0_PE)) enter_pmode(vcpu); if (!vmx->rmode.vm86_active && !(cr0 & X86_CR0_PE)) enter_rmode(vcpu); } #ifdef CONFIG_X86_64 if (vcpu->arch.efer & EFER_LME) { if (!is_paging(vcpu) && (cr0 & X86_CR0_PG)) enter_lmode(vcpu); if (is_paging(vcpu) && !(cr0 & X86_CR0_PG)) exit_lmode(vcpu); } #endif if (enable_ept) ept_update_paging_mode_cr0(&hw_cr0, cr0, vcpu); if (!vcpu->fpu_active) hw_cr0 \|= X86_CR0_TS \| X86_CR0_MP; vmcs_writel(CR0_READ_SHADOW, cr0); vmcs_writel(GUEST_CR0, hw_cr0); vcpu->arch.cr0 = cr0; /* depends on vcpu->arch.cr0 to be set to a new value / vmx->emulation_required = emulation_required(vcpu); } static u64 construct_eptp(unsigned long root_hpa) { u64 eptp; / TODO write the value reading from MSR / eptp = VMX_EPT_DEFAULT_MT \| VMX_EPT_DEFAULT_GAW << VMX_EPT_GAW_EPTP_SHIFT; if (enable_ept_ad_bits) eptp \|= VMX_EPT_AD_ENABLE_BIT; eptp \|= (root_hpa & PAGE_MASK); return eptp; } static void vmx_set_cr3(struct kvm_vcpu vcpu, unsigned long cr3) { unsigned long guest_cr3; u64 eptp; guest_cr3 = cr3; if (enable_ept) { eptp = construct_eptp(cr3); vmcs_write64(EPT_POINTER, eptp); if (is_paging(vcpu) \|\| is_guest_mode(vcpu)) guest_cr3 = kvm_read_cr3(vcpu); else guest_cr3 = vcpu->kvm->arch.ept_identity_map_addr; ept_load_pdptrs(vcpu); } vmx_flush_tlb(vcpu); vmcs_writel(GUEST_CR3, guest_cr3); } static int vmx_set_cr4(struct kvm_vcpu vcpu, unsigned long cr4) { unsigned long hw_cr4 = cr4 \| (to_vmx(vcpu)->rmode.vm86_active ? KVM_RMODE_VM_CR4_ALWAYS_ON : KVM_PMODE_VM_CR4_ALWAYS_ON); if (cr4 & X86_CR4_VMXE) { / * To use VMXON (and later other VMX instructions), a guest * must first be able to turn on cr4.VMXE (see handle_vmon()). * So basically the check on whether to allow nested VMX * is here. / if (!nested_vmx_allowed(vcpu)) return 1; } if (to_vmx(vcpu)->nested.vmxon && ((cr4 & VMXON_CR4_ALWAYSON) != VMXON_CR4_ALWAYSON)) return 1; vcpu->arch.cr4 = cr4; if (enable_ept) { if (!is_paging(vcpu)) { hw_cr4 &= ~X86_CR4_PAE; hw_cr4 \|= X86_CR4_PSE; / * SMEP/SMAP is disabled if CPU is in non-paging mode * in hardware. However KVM always uses paging mode to * emulate guest non-paging mode with TDP. * To emulate this behavior, SMEP/SMAP needs to be * manually disabled when guest switches to non-paging * mode. / hw_cr4 &= ~(X86_CR4_SMEP \| X86_CR4_SMAP); } else if (!(cr4 & X86_CR4_PAE)) { hw_cr4 &= ~X86_CR4_PAE; } } vmcs_writel(CR4_READ_SHADOW, cr4); vmcs_writel(GUEST_CR4, hw_cr4); return 0; } static void vmx_get_segment(struct kvm_vcpu vcpu, struct kvm_segment var, int seg) { struct vcpu_vmx vmx = to_vmx(vcpu); u32 ar; if (vmx->rmode.vm86_active && seg != VCPU_SREG_LDTR) { var = vmx->rmode.segs[seg]; if (seg == VCPU_SREG_TR \|\| var->selector == vmx_read_guest_seg_selector(vmx, seg)) return; var->base = vmx_read_guest_seg_base(vmx, seg); var->selector = vmx_read_guest_seg_selector(vmx, seg); return; } var->base = vmx_read_guest_seg_base(vmx, seg); var->limit = vmx_read_guest_seg_limit(vmx, seg); var->selector = vmx_read_guest_seg_selector(vmx, seg); ar = vmx_read_guest_seg_ar(vmx, seg); var->unusable = (ar >> 16) & 1; var->type = ar & 15; var->s = (ar >> 4) & 1; var->dpl = (ar >> 5) & 3; / * Some userspaces do not preserve unusable property. Since usable * segment has to be present according to VMX spec we can use present * property to amend userspace bug by making unusable segment always * nonpresent. vmx_segment_access_rights() already marks nonpresent * segment as unusable. / var->present = !var->unusable; var->avl = (ar >> 12) & 1; var->l = (ar >> 13) & 1; var->db = (ar >> 14) & 1; var->g = (ar >> 15) & 1; } static u64 vmx_get_segment_base(struct kvm_vcpu vcpu, int seg) { struct kvm_segment s; if (to_vmx(vcpu)->rmode.vm86_active) { vmx_get_segment(vcpu, &s, seg); return s.base; } return vmx_read_guest_seg_base(to_vmx(vcpu), seg); } static int vmx_get_cpl(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); if (unlikely(vmx->rmode.vm86_active)) return 0; else { int ar = vmx_read_guest_seg_ar(vmx, VCPU_SREG_SS); return AR_DPL(ar); } } static u32 vmx_segment_access_rights(struct kvm_segment var) { u32 ar; if (var->unusable \|\| !var->present) ar = 1 << 16; else { ar = var->type & 15; ar \|= (var->s & 1) << 4; ar \|= (var->dpl & 3) << 5; ar \|= (var->present & 1) << 7; ar \|= (var->avl & 1) << 12; ar \|= (var->l & 1) << 13; ar \|= (var->db & 1) << 14; ar \|= (var->g & 1) << 15; } return ar; } static void vmx_set_segment(struct kvm_vcpu vcpu, struct kvm_segment var, int seg) { struct vcpu_vmx vmx = to_vmx(vcpu); const struct kvm_vmx_segment_field sf = &kvm_vmx_segment_fields[seg]; vmx_segment_cache_clear(vmx); if (vmx->rmode.vm86_active && seg != VCPU_SREG_LDTR) { vmx->rmode.segs[seg] = var; if (seg == VCPU_SREG_TR) vmcs_write16(sf->selector, var->selector); else if (var->s) fix_rmode_seg(seg, &vmx->rmode.segs[seg]); goto out; } vmcs_writel(sf->base, var->base); vmcs_write32(sf->limit, var->limit); vmcs_write16(sf->selector, var->selector); /* * Fix the "Accessed" bit in AR field of segment registers for older * qemu binaries. * IA32 arch specifies that at the time of processor reset the * "Accessed" bit in the AR field of segment registers is 1. And qemu * is setting it to 0 in the userland code. This causes invalid guest * state vmexit when "unrestricted guest" mode is turned on. * Fix for this setup issue in cpu_reset is being pushed in the qemu * tree. Newer qemu binaries with that qemu fix would not need this * kvm hack. / if (enable_unrestricted_guest && (seg != VCPU_SREG_LDTR)) var->type \|= 0x1; / Accessed / vmcs_write32(sf->ar_bytes, vmx_segment_access_rights(var)); out: vmx->emulation_required = emulation_required(vcpu); } static void vmx_get_cs_db_l_bits(struct kvm_vcpu vcpu, int db, int l) { u32 ar = vmx_read_guest_seg_ar(to_vmx(vcpu), VCPU_SREG_CS); db = (ar >> 14) & 1; l = (ar >> 13) & 1; } static void vmx_get_idt(struct kvm_vcpu vcpu, struct desc_ptr dt) { dt->size = vmcs_read32(GUEST_IDTR_LIMIT); dt->address = vmcs_readl(GUEST_IDTR_BASE); } static void vmx_set_idt(struct kvm_vcpu vcpu, struct desc_ptr dt) { vmcs_write32(GUEST_IDTR_LIMIT, dt->size); vmcs_writel(GUEST_IDTR_BASE, dt->address); } static void vmx_get_gdt(struct kvm_vcpu vcpu, struct desc_ptr dt) { dt->size = vmcs_read32(GUEST_GDTR_LIMIT); dt->address = vmcs_readl(GUEST_GDTR_BASE); } static void vmx_set_gdt(struct kvm_vcpu vcpu, struct desc_ptr dt) { vmcs_write32(GUEST_GDTR_LIMIT, dt->size); vmcs_writel(GUEST_GDTR_BASE, dt->address); } static bool rmode_segment_valid(struct kvm_vcpu vcpu, int seg) { struct kvm_segment var; u32 ar; vmx_get_segment(vcpu, &var, seg); var.dpl = 0x3; if (seg == VCPU_SREG_CS) var.type = 0x3; ar = vmx_segment_access_rights(&var); if (var.base != (var.selector << 4)) return false; if (var.limit != 0xffff) return false; if (ar != 0xf3) return false; return true; } static bool code_segment_valid(struct kvm_vcpu vcpu) { struct kvm_segment cs; unsigned int cs_rpl; vmx_get_segment(vcpu, &cs, VCPU_SREG_CS); cs_rpl = cs.selector & SELECTOR_RPL_MASK; if (cs.unusable) return false; if (~cs.type & (AR_TYPE_CODE_MASK\|AR_TYPE_ACCESSES_MASK)) return false; if (!cs.s) return false; if (cs.type & AR_TYPE_WRITEABLE_MASK) { if (cs.dpl > cs_rpl) return false; } else { if (cs.dpl != cs_rpl) return false; } if (!cs.present) return false; /* TODO: Add Reserved field check, this'll require a new member in the kvm_segment_field structure / return true; } static bool stack_segment_valid(struct kvm_vcpu vcpu) { struct kvm_segment ss; unsigned int ss_rpl; vmx_get_segment(vcpu, &ss, VCPU_SREG_SS); ss_rpl = ss.selector & SELECTOR_RPL_MASK; if (ss.unusable) return true; if (ss.type != 3 && ss.type != 7) return false; if (!ss.s) return false; if (ss.dpl != ss_rpl) /* DPL != RPL / return false; if (!ss.present) return false; return true; } static bool data_segment_valid(struct kvm_vcpu vcpu, int seg) { struct kvm_segment var; unsigned int rpl; vmx_get_segment(vcpu, &var, seg); rpl = var.selector & SELECTOR_RPL_MASK; if (var.unusable) return true; if (!var.s) return false; if (!var.present) return false; if (~var.type & (AR_TYPE_CODE_MASK\|AR_TYPE_WRITEABLE_MASK)) { if (var.dpl < rpl) /* DPL < RPL / return false; } / TODO: Add other members to kvm_segment_field to allow checking for other access * rights flags / return true; } static bool tr_valid(struct kvm_vcpu vcpu) { struct kvm_segment tr; vmx_get_segment(vcpu, &tr, VCPU_SREG_TR); if (tr.unusable) return false; if (tr.selector & SELECTOR_TI_MASK) /* TI = 1 / return false; if (tr.type != 3 && tr.type != 11) / TODO: Check if guest is in IA32e mode / return false; if (!tr.present) return false; return true; } static bool ldtr_valid(struct kvm_vcpu vcpu) { struct kvm_segment ldtr; vmx_get_segment(vcpu, &ldtr, VCPU_SREG_LDTR); if (ldtr.unusable) return true; if (ldtr.selector & SELECTOR_TI_MASK) /* TI = 1 / return false; if (ldtr.type != 2) return false; if (!ldtr.present) return false; return true; } static bool cs_ss_rpl_check(struct kvm_vcpu vcpu) { struct kvm_segment cs, ss; vmx_get_segment(vcpu, &cs, VCPU_SREG_CS); vmx_get_segment(vcpu, &ss, VCPU_SREG_SS); return ((cs.selector & SELECTOR_RPL_MASK) == (ss.selector & SELECTOR_RPL_MASK)); } /* * Check if guest state is valid. Returns true if valid, false if * not. * We assume that registers are always usable / static bool guest_state_valid(struct kvm_vcpu vcpu) { if (enable_unrestricted_guest) return true; /* real mode guest state checks / if (!is_protmode(vcpu) \|\| (vmx_get_rflags(vcpu) & X86_EFLAGS_VM)) { if (!rmode_segment_valid(vcpu, VCPU_SREG_CS)) return false; if (!rmode_segment_valid(vcpu, VCPU_SREG_SS)) return false; if (!rmode_segment_valid(vcpu, VCPU_SREG_DS)) return false; if (!rmode_segment_valid(vcpu, VCPU_SREG_ES)) return false; if (!rmode_segment_valid(vcpu, VCPU_SREG_FS)) return false; if (!rmode_segment_valid(vcpu, VCPU_SREG_GS)) return false; } else { / protected mode guest state checks / if (!cs_ss_rpl_check(vcpu)) return false; if (!code_segment_valid(vcpu)) return false; if (!stack_segment_valid(vcpu)) return false; if (!data_segment_valid(vcpu, VCPU_SREG_DS)) return false; if (!data_segment_valid(vcpu, VCPU_SREG_ES)) return false; if (!data_segment_valid(vcpu, VCPU_SREG_FS)) return false; if (!data_segment_valid(vcpu, VCPU_SREG_GS)) return false; if (!tr_valid(vcpu)) return false; if (!ldtr_valid(vcpu)) return false; } / TODO: * - Add checks on RIP * - Add checks on RFLAGS / return true; } static int init_rmode_tss(struct kvm kvm) { gfn_t fn; u16 data = 0; int idx, r; idx = srcu_read_lock(&kvm->srcu); fn = kvm->arch.tss_addr >> PAGE_SHIFT; r = kvm_clear_guest_page(kvm, fn, 0, PAGE_SIZE); if (r < 0) goto out; data = TSS_BASE_SIZE + TSS_REDIRECTION_SIZE; r = kvm_write_guest_page(kvm, fn++, &data, TSS_IOPB_BASE_OFFSET, sizeof(u16)); if (r < 0) goto out; r = kvm_clear_guest_page(kvm, fn++, 0, PAGE_SIZE); if (r < 0) goto out; r = kvm_clear_guest_page(kvm, fn, 0, PAGE_SIZE); if (r < 0) goto out; data = ~0; r = kvm_write_guest_page(kvm, fn, &data, RMODE_TSS_SIZE - 2 * PAGE_SIZE - 1, sizeof(u8)); out: srcu_read_unlock(&kvm->srcu, idx); return r; } static int init_rmode_identity_map(struct kvm kvm) { int i, idx, r = 0; pfn_t identity_map_pfn; u32 tmp; if (!enable_ept) return 0; / Protect kvm->arch.ept_identity_pagetable_done. / mutex_lock(&kvm->slots_lock); if (likely(kvm->arch.ept_identity_pagetable_done)) goto out2; identity_map_pfn = kvm->arch.ept_identity_map_addr >> PAGE_SHIFT; r = alloc_identity_pagetable(kvm); if (r < 0) goto out2; idx = srcu_read_lock(&kvm->srcu); r = kvm_clear_guest_page(kvm, identity_map_pfn, 0, PAGE_SIZE); if (r < 0) goto out; / Set up identity-mapping pagetable for EPT in real mode / for (i = 0; i < PT32_ENT_PER_PAGE; i++) { tmp = (i << 22) + (_PAGE_PRESENT \| _PAGE_RW \| _PAGE_USER \| _PAGE_ACCESSED \| _PAGE_DIRTY \| _PAGE_PSE); r = kvm_write_guest_page(kvm, identity_map_pfn, &tmp, i sizeof(tmp), sizeof(tmp)); if (r < 0) goto out; } kvm->arch.ept_identity_pagetable_done = true; out: srcu_read_unlock(&kvm->srcu, idx); out2: mutex_unlock(&kvm->slots_lock); return r; } static void seg_setup(int seg) { const struct kvm_vmx_segment_field sf = &kvm_vmx_segment_fields[seg]; unsigned int ar; vmcs_write16(sf->selector, 0); vmcs_writel(sf->base, 0); vmcs_write32(sf->limit, 0xffff); ar = 0x93; if (seg == VCPU_SREG_CS) ar \|= 0x08; / code segment / vmcs_write32(sf->ar_bytes, ar); } static int alloc_apic_access_page(struct kvm kvm) { struct page page; struct kvm_userspace_memory_region kvm_userspace_mem; int r = 0; mutex_lock(&kvm->slots_lock); if (kvm->arch.apic_access_page_done) goto out; kvm_userspace_mem.slot = APIC_ACCESS_PAGE_PRIVATE_MEMSLOT; kvm_userspace_mem.flags = 0; kvm_userspace_mem.guest_phys_addr = APIC_DEFAULT_PHYS_BASE; kvm_userspace_mem.memory_size = PAGE_SIZE; r = __kvm_set_memory_region(kvm, &kvm_userspace_mem); if (r) goto out; page = gfn_to_page(kvm, APIC_DEFAULT_PHYS_BASE >> PAGE_SHIFT); if (is_error_page(page)) { r = -EFAULT; goto out; } / * Do not pin the page in memory, so that memory hot-unplug * is able to migrate it. / put_page(page); kvm->arch.apic_access_page_done = true; out: mutex_unlock(&kvm->slots_lock); return r; } static int alloc_identity_pagetable(struct kvm kvm) { /* Called with kvm->slots_lock held. / struct kvm_userspace_memory_region kvm_userspace_mem; int r = 0; BUG_ON(kvm->arch.ept_identity_pagetable_done); kvm_userspace_mem.slot = IDENTITY_PAGETABLE_PRIVATE_MEMSLOT; kvm_userspace_mem.flags = 0; kvm_userspace_mem.guest_phys_addr = kvm->arch.ept_identity_map_addr; kvm_userspace_mem.memory_size = PAGE_SIZE; r = __kvm_set_memory_region(kvm, &kvm_userspace_mem); return r; } static void allocate_vpid(struct vcpu_vmx vmx) { int vpid; vmx->vpid = 0; if (!enable_vpid) return; spin_lock(&vmx_vpid_lock); vpid = find_first_zero_bit(vmx_vpid_bitmap, VMX_NR_VPIDS); if (vpid < VMX_NR_VPIDS) { vmx->vpid = vpid; __set_bit(vpid, vmx_vpid_bitmap); } spin_unlock(&vmx_vpid_lock); } static void free_vpid(struct vcpu_vmx vmx) { if (!enable_vpid) return; spin_lock(&vmx_vpid_lock); if (vmx->vpid != 0) __clear_bit(vmx->vpid, vmx_vpid_bitmap); spin_unlock(&vmx_vpid_lock); } #define MSR_TYPE_R 1 #define MSR_TYPE_W 2 static void __vmx_disable_intercept_for_msr(unsigned long msr_bitmap, u32 msr, int type) { int f = sizeof(unsigned long); if (!cpu_has_vmx_msr_bitmap()) return; /* * See Intel PRM Vol. 3, 20.6.9 (MSR-Bitmap Address). Early manuals * have the write-low and read-high bitmap offsets the wrong way round. * We can control MSRs 0x00000000-0x00001fff and 0xc0000000-0xc0001fff. / if (msr <= 0x1fff) { if (type & MSR_TYPE_R) / read-low / __clear_bit(msr, msr_bitmap + 0x000 / f); if (type & MSR_TYPE_W) / write-low / __clear_bit(msr, msr_bitmap + 0x800 / f); } else if ((msr >= 0xc0000000) && (msr <= 0xc0001fff)) { msr &= 0x1fff; if (type & MSR_TYPE_R) / read-high / __clear_bit(msr, msr_bitmap + 0x400 / f); if (type & MSR_TYPE_W) / write-high / __clear_bit(msr, msr_bitmap + 0xc00 / f); } } static void __vmx_enable_intercept_for_msr(unsigned long msr_bitmap, u32 msr, int type) { int f = sizeof(unsigned long); if (!cpu_has_vmx_msr_bitmap()) return; /* * See Intel PRM Vol. 3, 20.6.9 (MSR-Bitmap Address). Early manuals * have the write-low and read-high bitmap offsets the wrong way round. * We can control MSRs 0x00000000-0x00001fff and 0xc0000000-0xc0001fff. / if (msr <= 0x1fff) { if (type & MSR_TYPE_R) / read-low / __set_bit(msr, msr_bitmap + 0x000 / f); if (type & MSR_TYPE_W) / write-low / __set_bit(msr, msr_bitmap + 0x800 / f); } else if ((msr >= 0xc0000000) && (msr <= 0xc0001fff)) { msr &= 0x1fff; if (type & MSR_TYPE_R) / read-high / __set_bit(msr, msr_bitmap + 0x400 / f); if (type & MSR_TYPE_W) / write-high / __set_bit(msr, msr_bitmap + 0xc00 / f); } } static void vmx_disable_intercept_for_msr(u32 msr, bool longmode_only) { if (!longmode_only) __vmx_disable_intercept_for_msr(vmx_msr_bitmap_legacy, msr, MSR_TYPE_R \| MSR_TYPE_W); __vmx_disable_intercept_for_msr(vmx_msr_bitmap_longmode, msr, MSR_TYPE_R \| MSR_TYPE_W); } static void vmx_enable_intercept_msr_read_x2apic(u32 msr) { __vmx_enable_intercept_for_msr(vmx_msr_bitmap_legacy_x2apic, msr, MSR_TYPE_R); __vmx_enable_intercept_for_msr(vmx_msr_bitmap_longmode_x2apic, msr, MSR_TYPE_R); } static void vmx_disable_intercept_msr_read_x2apic(u32 msr) { __vmx_disable_intercept_for_msr(vmx_msr_bitmap_legacy_x2apic, msr, MSR_TYPE_R); __vmx_disable_intercept_for_msr(vmx_msr_bitmap_longmode_x2apic, msr, MSR_TYPE_R); } static void vmx_disable_intercept_msr_write_x2apic(u32 msr) { __vmx_disable_intercept_for_msr(vmx_msr_bitmap_legacy_x2apic, msr, MSR_TYPE_W); __vmx_disable_intercept_for_msr(vmx_msr_bitmap_longmode_x2apic, msr, MSR_TYPE_W); } static int vmx_vm_has_apicv(struct kvm kvm) { return enable_apicv && irqchip_in_kernel(kvm); } /* * Send interrupt to vcpu via posted interrupt way. * 1. If target vcpu is running(non-root mode), send posted interrupt * notification to vcpu and hardware will sync PIR to vIRR atomically. * 2. If target vcpu isn't running(root mode), kick it to pick up the * interrupt from PIR in next vmentry. / static void vmx_deliver_posted_interrupt(struct kvm_vcpu vcpu, int vector) { struct vcpu_vmx vmx = to_vmx(vcpu); int r; if (pi_test_and_set_pir(vector, &vmx->pi_desc)) return; r = pi_test_and_set_on(&vmx->pi_desc); kvm_make_request(KVM_REQ_EVENT, vcpu); #ifdef CONFIG_SMP if (!r && (vcpu->mode == IN_GUEST_MODE)) apic->send_IPI_mask(get_cpu_mask(vcpu->cpu), POSTED_INTR_VECTOR); else #endif kvm_vcpu_kick(vcpu); } static void vmx_sync_pir_to_irr(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); if (!pi_test_and_clear_on(&vmx->pi_desc)) return; kvm_apic_update_irr(vcpu, vmx->pi_desc.pir); } static void vmx_sync_pir_to_irr_dummy(struct kvm_vcpu vcpu) { return; } /* * Set up the vmcs's constant host-state fields, i.e., host-state fields that * will not change in the lifetime of the guest. * Note that host-state that does change is set elsewhere. E.g., host-state * that is set differently for each CPU is set in vmx_vcpu_load(), not here. / static void vmx_set_constant_host_state(struct vcpu_vmx vmx) { u32 low32, high32; unsigned long tmpl; struct desc_ptr dt; unsigned long cr4; vmcs_writel(HOST_CR0, read_cr0() & ~X86_CR0_TS); /* 22.2.3 / vmcs_writel(HOST_CR3, read_cr3()); / 22.2.3 FIXME: shadow tables / / Save the most likely value for this task's CR4 in the VMCS. / cr4 = read_cr4(); vmcs_writel(HOST_CR4, cr4); / 22.2.3, 22.2.5 / vmx->host_state.vmcs_host_cr4 = cr4; vmcs_write16(HOST_CS_SELECTOR, __KERNEL_CS); / 22.2.4 / #ifdef CONFIG_X86_64 / * Load null selectors, so we can avoid reloading them in * __vmx_load_host_state(), in case userspace uses the null selectors * too (the expected case). / vmcs_write16(HOST_DS_SELECTOR, 0); vmcs_write16(HOST_ES_SELECTOR, 0); #else vmcs_write16(HOST_DS_SELECTOR, __KERNEL_DS); / 22.2.4 / vmcs_write16(HOST_ES_SELECTOR, __KERNEL_DS); / 22.2.4 / #endif vmcs_write16(HOST_SS_SELECTOR, __KERNEL_DS); / 22.2.4 / vmcs_write16(HOST_TR_SELECTOR, GDT_ENTRY_TSS8); /* 22.2.4 / native_store_idt(&dt); vmcs_writel(HOST_IDTR_BASE, dt.address); / 22.2.4 / vmx->host_idt_base = dt.address; vmcs_writel(HOST_RIP, vmx_return); / 22.2.5 / rdmsr(MSR_IA32_SYSENTER_CS, low32, high32); vmcs_write32(HOST_IA32_SYSENTER_CS, low32); rdmsrl(MSR_IA32_SYSENTER_EIP, tmpl); vmcs_writel(HOST_IA32_SYSENTER_EIP, tmpl); / 22.2.3 / if (vmcs_config.vmexit_ctrl & VM_EXIT_LOAD_IA32_PAT) { rdmsr(MSR_IA32_CR_PAT, low32, high32); vmcs_write64(HOST_IA32_PAT, low32 \| ((u64) high32 << 32)); } } static void set_cr4_guest_host_mask(struct vcpu_vmx vmx) { vmx->vcpu.arch.cr4_guest_owned_bits = KVM_CR4_GUEST_OWNED_BITS; if (enable_ept) vmx->vcpu.arch.cr4_guest_owned_bits \|= X86_CR4_PGE; if (is_guest_mode(&vmx->vcpu)) vmx->vcpu.arch.cr4_guest_owned_bits &= ~get_vmcs12(&vmx->vcpu)->cr4_guest_host_mask; vmcs_writel(CR4_GUEST_HOST_MASK, ~vmx->vcpu.arch.cr4_guest_owned_bits); } static u32 vmx_pin_based_exec_ctrl(struct vcpu_vmx vmx) { u32 pin_based_exec_ctrl = vmcs_config.pin_based_exec_ctrl; if (!vmx_vm_has_apicv(vmx->vcpu.kvm)) pin_based_exec_ctrl &= ~PIN_BASED_POSTED_INTR; return pin_based_exec_ctrl; } static u32 vmx_exec_control(struct vcpu_vmx vmx) { u32 exec_control = vmcs_config.cpu_based_exec_ctrl; if (vmx->vcpu.arch.switch_db_regs & KVM_DEBUGREG_WONT_EXIT) exec_control &= ~CPU_BASED_MOV_DR_EXITING; if (!vm_need_tpr_shadow(vmx->vcpu.kvm)) { exec_control &= ~CPU_BASED_TPR_SHADOW; #ifdef CONFIG_X86_64 exec_control \|= CPU_BASED_CR8_STORE_EXITING \| CPU_BASED_CR8_LOAD_EXITING; #endif } if (!enable_ept) exec_control \|= CPU_BASED_CR3_STORE_EXITING \| CPU_BASED_CR3_LOAD_EXITING \| CPU_BASED_INVLPG_EXITING; return exec_control; } static u32 vmx_secondary_exec_control(struct vcpu_vmx vmx) { u32 exec_control = vmcs_config.cpu_based_2nd_exec_ctrl; if (!vm_need_virtualize_apic_accesses(vmx->vcpu.kvm)) exec_control &= ~SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES; if (vmx->vpid == 0) exec_control &= ~SECONDARY_EXEC_ENABLE_VPID; if (!enable_ept) { exec_control &= ~SECONDARY_EXEC_ENABLE_EPT; enable_unrestricted_guest = 0; / Enable INVPCID for non-ept guests may cause performance regression. / exec_control &= ~SECONDARY_EXEC_ENABLE_INVPCID; } if (!enable_unrestricted_guest) exec_control &= ~SECONDARY_EXEC_UNRESTRICTED_GUEST; if (!ple_gap) exec_control &= ~SECONDARY_EXEC_PAUSE_LOOP_EXITING; if (!vmx_vm_has_apicv(vmx->vcpu.kvm)) exec_control &= ~(SECONDARY_EXEC_APIC_REGISTER_VIRT \| SECONDARY_EXEC_VIRTUAL_INTR_DELIVERY); exec_control &= ~SECONDARY_EXEC_VIRTUALIZE_X2APIC_MODE; / SECONDARY_EXEC_SHADOW_VMCS is enabled when L1 executes VMPTRLD (handle_vmptrld). We can NOT enable shadow_vmcs here because we don't have yet a current VMCS12 / exec_control &= ~SECONDARY_EXEC_SHADOW_VMCS; return exec_control; } static void ept_set_mmio_spte_mask(void) { / * EPT Misconfigurations can be generated if the value of bits 2:0 * of an EPT paging-structure entry is 110b (write/execute). * Also, magic bits (0x3ull << 62) is set to quickly identify mmio * spte. / kvm_mmu_set_mmio_spte_mask((0x3ull << 62) \| 0x6ull); } / * Sets up the vmcs for emulated real mode. / static int vmx_vcpu_setup(struct vcpu_vmx vmx) { #ifdef CONFIG_X86_64 unsigned long a; #endif int i; /* I/O / vmcs_write64(IO_BITMAP_A, __pa(vmx_io_bitmap_a)); vmcs_write64(IO_BITMAP_B, __pa(vmx_io_bitmap_b)); if (enable_shadow_vmcs) { vmcs_write64(VMREAD_BITMAP, __pa(vmx_vmread_bitmap)); vmcs_write64(VMWRITE_BITMAP, __pa(vmx_vmwrite_bitmap)); } if (cpu_has_vmx_msr_bitmap()) vmcs_write64(MSR_BITMAP, __pa(vmx_msr_bitmap_legacy)); vmcs_write64(VMCS_LINK_POINTER, -1ull); / 22.3.1.5 / / Control / vmcs_write32(PIN_BASED_VM_EXEC_CONTROL, vmx_pin_based_exec_ctrl(vmx)); vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, vmx_exec_control(vmx)); if (cpu_has_secondary_exec_ctrls()) { vmcs_write32(SECONDARY_VM_EXEC_CONTROL, vmx_secondary_exec_control(vmx)); } if (vmx_vm_has_apicv(vmx->vcpu.kvm)) { vmcs_write64(EOI_EXIT_BITMAP0, 0); vmcs_write64(EOI_EXIT_BITMAP1, 0); vmcs_write64(EOI_EXIT_BITMAP2, 0); vmcs_write64(EOI_EXIT_BITMAP3, 0); vmcs_write16(GUEST_INTR_STATUS, 0); vmcs_write64(POSTED_INTR_NV, POSTED_INTR_VECTOR); vmcs_write64(POSTED_INTR_DESC_ADDR, __pa((&vmx->pi_desc))); } if (ple_gap) { vmcs_write32(PLE_GAP, ple_gap); vmx->ple_window = ple_window; vmx->ple_window_dirty = true; } vmcs_write32(PAGE_FAULT_ERROR_CODE_MASK, 0); vmcs_write32(PAGE_FAULT_ERROR_CODE_MATCH, 0); vmcs_write32(CR3_TARGET_COUNT, 0); / 22.2.1 / vmcs_write16(HOST_FS_SELECTOR, 0); / 22.2.4 / vmcs_write16(HOST_GS_SELECTOR, 0); / 22.2.4 / vmx_set_constant_host_state(vmx); #ifdef CONFIG_X86_64 rdmsrl(MSR_FS_BASE, a); vmcs_writel(HOST_FS_BASE, a); / 22.2.4 / rdmsrl(MSR_GS_BASE, a); vmcs_writel(HOST_GS_BASE, a); / 22.2.4 / #else vmcs_writel(HOST_FS_BASE, 0); / 22.2.4 / vmcs_writel(HOST_GS_BASE, 0); / 22.2.4 / #endif vmcs_write32(VM_EXIT_MSR_STORE_COUNT, 0); vmcs_write32(VM_EXIT_MSR_LOAD_COUNT, 0); vmcs_write64(VM_EXIT_MSR_LOAD_ADDR, __pa(vmx->msr_autoload.host)); vmcs_write32(VM_ENTRY_MSR_LOAD_COUNT, 0); vmcs_write64(VM_ENTRY_MSR_LOAD_ADDR, __pa(vmx->msr_autoload.guest)); if (vmcs_config.vmentry_ctrl & VM_ENTRY_LOAD_IA32_PAT) { u32 msr_low, msr_high; u64 host_pat; rdmsr(MSR_IA32_CR_PAT, msr_low, msr_high); host_pat = msr_low \| ((u64) msr_high << 32); / Write the default value follow host pat / vmcs_write64(GUEST_IA32_PAT, host_pat); / Keep arch.pat sync with GUEST_IA32_PAT / vmx->vcpu.arch.pat = host_pat; } for (i = 0; i < ARRAY_SIZE(vmx_msr_index); ++i) { u32 index = vmx_msr_index[i]; u32 data_low, data_high; int j = vmx->nmsrs; if (rdmsr_safe(index, &data_low, &data_high) < 0) continue; if (wrmsr_safe(index, data_low, data_high) < 0) continue; vmx->guest_msrs[j].index = i; vmx->guest_msrs[j].data = 0; vmx->guest_msrs[j].mask = -1ull; ++vmx->nmsrs; } vm_exit_controls_init(vmx, vmcs_config.vmexit_ctrl); / 22.2.1, 20.8.1 / vm_entry_controls_init(vmx, vmcs_config.vmentry_ctrl); vmcs_writel(CR0_GUEST_HOST_MASK, ~0UL); set_cr4_guest_host_mask(vmx); return 0; } static void vmx_vcpu_reset(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); struct msr_data apic_base_msr; vmx->rmode.vm86_active = 0; vmx->soft_vnmi_blocked = 0; vmx->vcpu.arch.regs[VCPU_REGS_RDX] = get_rdx_init_val(); kvm_set_cr8(&vmx->vcpu, 0); apic_base_msr.data = APIC_DEFAULT_PHYS_BASE \| MSR_IA32_APICBASE_ENABLE; if (kvm_vcpu_is_bsp(&vmx->vcpu)) apic_base_msr.data \|= MSR_IA32_APICBASE_BSP; apic_base_msr.host_initiated = true; kvm_set_apic_base(&vmx->vcpu, &apic_base_msr); vmx_segment_cache_clear(vmx); seg_setup(VCPU_SREG_CS); vmcs_write16(GUEST_CS_SELECTOR, 0xf000); vmcs_write32(GUEST_CS_BASE, 0xffff0000); seg_setup(VCPU_SREG_DS); seg_setup(VCPU_SREG_ES); seg_setup(VCPU_SREG_FS); seg_setup(VCPU_SREG_GS); seg_setup(VCPU_SREG_SS); vmcs_write16(GUEST_TR_SELECTOR, 0); vmcs_writel(GUEST_TR_BASE, 0); vmcs_write32(GUEST_TR_LIMIT, 0xffff); vmcs_write32(GUEST_TR_AR_BYTES, 0x008b); vmcs_write16(GUEST_LDTR_SELECTOR, 0); vmcs_writel(GUEST_LDTR_BASE, 0); vmcs_write32(GUEST_LDTR_LIMIT, 0xffff); vmcs_write32(GUEST_LDTR_AR_BYTES, 0x00082); vmcs_write32(GUEST_SYSENTER_CS, 0); vmcs_writel(GUEST_SYSENTER_ESP, 0); vmcs_writel(GUEST_SYSENTER_EIP, 0); vmcs_writel(GUEST_RFLAGS, 0x02); kvm_rip_write(vcpu, 0xfff0); vmcs_writel(GUEST_GDTR_BASE, 0); vmcs_write32(GUEST_GDTR_LIMIT, 0xffff); vmcs_writel(GUEST_IDTR_BASE, 0); vmcs_write32(GUEST_IDTR_LIMIT, 0xffff); vmcs_write32(GUEST_ACTIVITY_STATE, GUEST_ACTIVITY_ACTIVE); vmcs_write32(GUEST_INTERRUPTIBILITY_INFO, 0); vmcs_write32(GUEST_PENDING_DBG_EXCEPTIONS, 0); / Special registers / vmcs_write64(GUEST_IA32_DEBUGCTL, 0); setup_msrs(vmx); vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, 0); / 22.2.1 / if (cpu_has_vmx_tpr_shadow()) { vmcs_write64(VIRTUAL_APIC_PAGE_ADDR, 0); if (vm_need_tpr_shadow(vmx->vcpu.kvm)) vmcs_write64(VIRTUAL_APIC_PAGE_ADDR, __pa(vmx->vcpu.arch.apic->regs)); vmcs_write32(TPR_THRESHOLD, 0); } kvm_vcpu_reload_apic_access_page(vcpu); if (vmx_vm_has_apicv(vcpu->kvm)) memset(&vmx->pi_desc, 0, sizeof(struct pi_desc)); if (vmx->vpid != 0) vmcs_write16(VIRTUAL_PROCESSOR_ID, vmx->vpid); vmx->vcpu.arch.cr0 = X86_CR0_NW \| X86_CR0_CD \| X86_CR0_ET; vmx_set_cr0(&vmx->vcpu, kvm_read_cr0(vcpu)); / enter rmode / vmx_set_cr4(&vmx->vcpu, 0); vmx_set_efer(&vmx->vcpu, 0); vmx_fpu_activate(&vmx->vcpu); update_exception_bitmap(&vmx->vcpu); vpid_sync_context(vmx); } / * In nested virtualization, check if L1 asked to exit on external interrupts. * For most existing hypervisors, this will always return true. / static bool nested_exit_on_intr(struct kvm_vcpu vcpu) { return get_vmcs12(vcpu)->pin_based_vm_exec_control & PIN_BASED_EXT_INTR_MASK; } /* * In nested virtualization, check if L1 has set * VM_EXIT_ACK_INTR_ON_EXIT / static bool nested_exit_intr_ack_set(struct kvm_vcpu vcpu) { return get_vmcs12(vcpu)->vm_exit_controls & VM_EXIT_ACK_INTR_ON_EXIT; } static bool nested_exit_on_nmi(struct kvm_vcpu vcpu) { return get_vmcs12(vcpu)->pin_based_vm_exec_control & PIN_BASED_NMI_EXITING; } static void enable_irq_window(struct kvm_vcpu vcpu) { u32 cpu_based_vm_exec_control; cpu_based_vm_exec_control = vmcs_read32(CPU_BASED_VM_EXEC_CONTROL); cpu_based_vm_exec_control \|= CPU_BASED_VIRTUAL_INTR_PENDING; vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, cpu_based_vm_exec_control); } static void enable_nmi_window(struct kvm_vcpu vcpu) { u32 cpu_based_vm_exec_control; if (!cpu_has_virtual_nmis() \|\| vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) & GUEST_INTR_STATE_STI) { enable_irq_window(vcpu); return; } cpu_based_vm_exec_control = vmcs_read32(CPU_BASED_VM_EXEC_CONTROL); cpu_based_vm_exec_control \|= CPU_BASED_VIRTUAL_NMI_PENDING; vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, cpu_based_vm_exec_control); } static void vmx_inject_irq(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); uint32_t intr; int irq = vcpu->arch.interrupt.nr; trace_kvm_inj_virq(irq); ++vcpu->stat.irq_injections; if (vmx->rmode.vm86_active) { int inc_eip = 0; if (vcpu->arch.interrupt.soft) inc_eip = vcpu->arch.event_exit_inst_len; if (kvm_inject_realmode_interrupt(vcpu, irq, inc_eip) != EMULATE_DONE) kvm_make_request(KVM_REQ_TRIPLE_FAULT, vcpu); return; } intr = irq \| INTR_INFO_VALID_MASK; if (vcpu->arch.interrupt.soft) { intr \|= INTR_TYPE_SOFT_INTR; vmcs_write32(VM_ENTRY_INSTRUCTION_LEN, vmx->vcpu.arch.event_exit_inst_len); } else intr \|= INTR_TYPE_EXT_INTR; vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, intr); } static void vmx_inject_nmi(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); if (is_guest_mode(vcpu)) return; if (!cpu_has_virtual_nmis()) { / * Tracking the NMI-blocked state in software is built upon * finding the next open IRQ window. This, in turn, depends on * well-behaving guests: They have to keep IRQs disabled at * least as long as the NMI handler runs. Otherwise we may * cause NMI nesting, maybe breaking the guest. But as this is * highly unlikely, we can live with the residual risk. / vmx->soft_vnmi_blocked = 1; vmx->vnmi_blocked_time = 0; } ++vcpu->stat.nmi_injections; vmx->nmi_known_unmasked = false; if (vmx->rmode.vm86_active) { if (kvm_inject_realmode_interrupt(vcpu, NMI_VECTOR, 0) != EMULATE_DONE) kvm_make_request(KVM_REQ_TRIPLE_FAULT, vcpu); return; } vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, INTR_TYPE_NMI_INTR \| INTR_INFO_VALID_MASK \| NMI_VECTOR); } static bool vmx_get_nmi_mask(struct kvm_vcpu vcpu) { if (!cpu_has_virtual_nmis()) return to_vmx(vcpu)->soft_vnmi_blocked; if (to_vmx(vcpu)->nmi_known_unmasked) return false; return vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) & GUEST_INTR_STATE_NMI; } static void vmx_set_nmi_mask(struct kvm_vcpu vcpu, bool masked) { struct vcpu_vmx vmx = to_vmx(vcpu); if (!cpu_has_virtual_nmis()) { if (vmx->soft_vnmi_blocked != masked) { vmx->soft_vnmi_blocked = masked; vmx->vnmi_blocked_time = 0; } } else { vmx->nmi_known_unmasked = !masked; if (masked) vmcs_set_bits(GUEST_INTERRUPTIBILITY_INFO, GUEST_INTR_STATE_NMI); else vmcs_clear_bits(GUEST_INTERRUPTIBILITY_INFO, GUEST_INTR_STATE_NMI); } } static int vmx_nmi_allowed(struct kvm_vcpu vcpu) { if (to_vmx(vcpu)->nested.nested_run_pending) return 0; if (!cpu_has_virtual_nmis() && to_vmx(vcpu)->soft_vnmi_blocked) return 0; return !(vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) & (GUEST_INTR_STATE_MOV_SS \| GUEST_INTR_STATE_STI \| GUEST_INTR_STATE_NMI)); } static int vmx_interrupt_allowed(struct kvm_vcpu vcpu) { return (!to_vmx(vcpu)->nested.nested_run_pending && vmcs_readl(GUEST_RFLAGS) & X86_EFLAGS_IF) && !(vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) & (GUEST_INTR_STATE_STI \| GUEST_INTR_STATE_MOV_SS)); } static int vmx_set_tss_addr(struct kvm kvm, unsigned int addr) { int ret; struct kvm_userspace_memory_region tss_mem = { .slot = TSS_PRIVATE_MEMSLOT, .guest_phys_addr = addr, .memory_size = PAGE_SIZE 3, .flags = 0, }; ret = kvm_set_memory_region(kvm, &tss_mem); if (ret) return ret; kvm->arch.tss_addr = addr; return init_rmode_tss(kvm); } static bool rmode_exception(struct kvm_vcpu vcpu, int vec) { switch (vec) { case BP_VECTOR: / * Update instruction length as we may reinject the exception * from user space while in guest debugging mode. / to_vmx(vcpu)->vcpu.arch.event_exit_inst_len = vmcs_read32(VM_EXIT_INSTRUCTION_LEN); if (vcpu->guest_debug & KVM_GUESTDBG_USE_SW_BP) return false; / fall through / case DB_VECTOR: if (vcpu->guest_debug & (KVM_GUESTDBG_SINGLESTEP \| KVM_GUESTDBG_USE_HW_BP)) return false; / fall through / case DE_VECTOR: case OF_VECTOR: case BR_VECTOR: case UD_VECTOR: case DF_VECTOR: case SS_VECTOR: case GP_VECTOR: case MF_VECTOR: return true; break; } return false; } static int handle_rmode_exception(struct kvm_vcpu vcpu, int vec, u32 err_code) { /* * Instruction with address size override prefix opcode 0x67 * Cause the #SS fault with 0 error code in VM86 mode. / if (((vec == GP_VECTOR) \|\| (vec == SS_VECTOR)) && err_code == 0) { if (emulate_instruction(vcpu, 0) == EMULATE_DONE) { if (vcpu->arch.halt_request) { vcpu->arch.halt_request = 0; return kvm_emulate_halt(vcpu); } return 1; } return 0; } / * Forward all other exceptions that are valid in real mode. * FIXME: Breaks guest debugging in real mode, needs to be fixed with * the required debugging infrastructure rework. / kvm_queue_exception(vcpu, vec); return 1; } / * Trigger machine check on the host. We assume all the MSRs are already set up * by the CPU and that we still run on the same CPU as the MCE occurred on. * We pass a fake environment to the machine check handler because we want * the guest to be always treated like user space, no matter what context * it used internally. / static void kvm_machine_check(void) { #if defined(CONFIG_X86_MCE) && defined(CONFIG_X86_64) struct pt_regs regs = { .cs = 3, / Fake ring 3 no matter what the guest ran on / .flags = X86_EFLAGS_IF, }; do_machine_check(&regs, 0); #endif } static int handle_machine_check(struct kvm_vcpu vcpu) { /* already handled by vcpu_run / return 1; } static int handle_exception(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); struct kvm_run kvm_run = vcpu->run; u32 intr_info, ex_no, error_code; unsigned long cr2, rip, dr6; u32 vect_info; enum emulation_result er; vect_info = vmx->idt_vectoring_info; intr_info = vmx->exit_intr_info; if (is_machine_check(intr_info)) return handle_machine_check(vcpu); if ((intr_info & INTR_INFO_INTR_TYPE_MASK) == INTR_TYPE_NMI_INTR) return 1; /* already handled by vmx_vcpu_run() / if (is_no_device(intr_info)) { vmx_fpu_activate(vcpu); return 1; } if (is_invalid_opcode(intr_info)) { er = emulate_instruction(vcpu, EMULTYPE_TRAP_UD); if (er != EMULATE_DONE) kvm_queue_exception(vcpu, UD_VECTOR); return 1; } error_code = 0; if (intr_info & INTR_INFO_DELIVER_CODE_MASK) error_code = vmcs_read32(VM_EXIT_INTR_ERROR_CODE); / * The #PF with PFEC.RSVD = 1 indicates the guest is accessing * MMIO, it is better to report an internal error. * See the comments in vmx_handle_exit. / if ((vect_info & VECTORING_INFO_VALID_MASK) && !(is_page_fault(intr_info) && !(error_code & PFERR_RSVD_MASK))) { vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR; vcpu->run->internal.suberror = KVM_INTERNAL_ERROR_SIMUL_EX; vcpu->run->internal.ndata = 2; vcpu->run->internal.data[0] = vect_info; vcpu->run->internal.data[1] = intr_info; return 0; } if (is_page_fault(intr_info)) { / EPT won't cause page fault directly / BUG_ON(enable_ept); cr2 = vmcs_readl(EXIT_QUALIFICATION); trace_kvm_page_fault(cr2, error_code); if (kvm_event_needs_reinjection(vcpu)) kvm_mmu_unprotect_page_virt(vcpu, cr2); return kvm_mmu_page_fault(vcpu, cr2, error_code, NULL, 0); } ex_no = intr_info & INTR_INFO_VECTOR_MASK; if (vmx->rmode.vm86_active && rmode_exception(vcpu, ex_no)) return handle_rmode_exception(vcpu, ex_no, error_code); switch (ex_no) { case DB_VECTOR: dr6 = vmcs_readl(EXIT_QUALIFICATION); if (!(vcpu->guest_debug & (KVM_GUESTDBG_SINGLESTEP \| KVM_GUESTDBG_USE_HW_BP))) { vcpu->arch.dr6 &= ~15; vcpu->arch.dr6 \|= dr6 \| DR6_RTM; if (!(dr6 & ~DR6_RESERVED)) / icebp / skip_emulated_instruction(vcpu); kvm_queue_exception(vcpu, DB_VECTOR); return 1; } kvm_run->debug.arch.dr6 = dr6 \| DR6_FIXED_1; kvm_run->debug.arch.dr7 = vmcs_readl(GUEST_DR7); / fall through / case BP_VECTOR: / * Update instruction length as we may reinject #BP from * user space while in guest debugging mode. Reading it for * #DB as well causes no harm, it is not used in that case. / vmx->vcpu.arch.event_exit_inst_len = vmcs_read32(VM_EXIT_INSTRUCTION_LEN); kvm_run->exit_reason = KVM_EXIT_DEBUG; rip = kvm_rip_read(vcpu); kvm_run->debug.arch.pc = vmcs_readl(GUEST_CS_BASE) + rip; kvm_run->debug.arch.exception = ex_no; break; default: kvm_run->exit_reason = KVM_EXIT_EXCEPTION; kvm_run->ex.exception = ex_no; kvm_run->ex.error_code = error_code; break; } return 0; } static int handle_external_interrupt(struct kvm_vcpu vcpu) { ++vcpu->stat.irq_exits; return 1; } static int handle_triple_fault(struct kvm_vcpu vcpu) { vcpu->run->exit_reason = KVM_EXIT_SHUTDOWN; return 0; } static int handle_io(struct kvm_vcpu vcpu) { unsigned long exit_qualification; int size, in, string; unsigned port; exit_qualification = vmcs_readl(EXIT_QUALIFICATION); string = (exit_qualification & 16) != 0; in = (exit_qualification & 8) != 0; ++vcpu->stat.io_exits; if (string \|\| in) return emulate_instruction(vcpu, 0) == EMULATE_DONE; port = exit_qualification >> 16; size = (exit_qualification & 7) + 1; skip_emulated_instruction(vcpu); return kvm_fast_pio_out(vcpu, size, port); } static void vmx_patch_hypercall(struct kvm_vcpu vcpu, unsigned char hypercall) { /* * Patch in the VMCALL instruction: / hypercall[0] = 0x0f; hypercall[1] = 0x01; hypercall[2] = 0xc1; } static bool nested_cr0_valid(struct vmcs12 vmcs12, unsigned long val) { unsigned long always_on = VMXON_CR0_ALWAYSON; if (nested_vmx_secondary_ctls_high & SECONDARY_EXEC_UNRESTRICTED_GUEST && nested_cpu_has2(vmcs12, SECONDARY_EXEC_UNRESTRICTED_GUEST)) always_on &= ~(X86_CR0_PE \| X86_CR0_PG); return (val & always_on) == always_on; } /* called to set cr0 as appropriate for a mov-to-cr0 exit. / static int handle_set_cr0(struct kvm_vcpu vcpu, unsigned long val) { if (is_guest_mode(vcpu)) { struct vmcs12 vmcs12 = get_vmcs12(vcpu); unsigned long orig_val = val; / * We get here when L2 changed cr0 in a way that did not change * any of L1's shadowed bits (see nested_vmx_exit_handled_cr), * but did change L0 shadowed bits. So we first calculate the * effective cr0 value that L1 would like to write into the * hardware. It consists of the L2-owned bits from the new * value combined with the L1-owned bits from L1's guest_cr0. / val = (val & ~vmcs12->cr0_guest_host_mask) \| (vmcs12->guest_cr0 & vmcs12->cr0_guest_host_mask); if (!nested_cr0_valid(vmcs12, val)) return 1; if (kvm_set_cr0(vcpu, val)) return 1; vmcs_writel(CR0_READ_SHADOW, orig_val); return 0; } else { if (to_vmx(vcpu)->nested.vmxon && ((val & VMXON_CR0_ALWAYSON) != VMXON_CR0_ALWAYSON)) return 1; return kvm_set_cr0(vcpu, val); } } static int handle_set_cr4(struct kvm_vcpu vcpu, unsigned long val) { if (is_guest_mode(vcpu)) { struct vmcs12 vmcs12 = get_vmcs12(vcpu); unsigned long orig_val = val; / analogously to handle_set_cr0 / val = (val & ~vmcs12->cr4_guest_host_mask) \| (vmcs12->guest_cr4 & vmcs12->cr4_guest_host_mask); if (kvm_set_cr4(vcpu, val)) return 1; vmcs_writel(CR4_READ_SHADOW, orig_val); return 0; } else return kvm_set_cr4(vcpu, val); } / called to set cr0 as approriate for clts instruction exit. / static void handle_clts(struct kvm_vcpu vcpu) { if (is_guest_mode(vcpu)) { /* * We get here when L2 did CLTS, and L1 didn't shadow CR0.TS * but we did (!fpu_active). We need to keep GUEST_CR0.TS on, * just pretend it's off (also in arch.cr0 for fpu_activate). / vmcs_writel(CR0_READ_SHADOW, vmcs_readl(CR0_READ_SHADOW) & ~X86_CR0_TS); vcpu->arch.cr0 &= ~X86_CR0_TS; } else vmx_set_cr0(vcpu, kvm_read_cr0_bits(vcpu, ~X86_CR0_TS)); } static int handle_cr(struct kvm_vcpu vcpu) { unsigned long exit_qualification, val; int cr; int reg; int err; exit_qualification = vmcs_readl(EXIT_QUALIFICATION); cr = exit_qualification & 15; reg = (exit_qualification >> 8) & 15; switch ((exit_qualification >> 4) & 3) { case 0: /* mov to cr / val = kvm_register_readl(vcpu, reg); trace_kvm_cr_write(cr, val); switch (cr) { case 0: err = handle_set_cr0(vcpu, val); kvm_complete_insn_gp(vcpu, err); return 1; case 3: err = kvm_set_cr3(vcpu, val); kvm_complete_insn_gp(vcpu, err); return 1; case 4: err = handle_set_cr4(vcpu, val); kvm_complete_insn_gp(vcpu, err); return 1; case 8: { u8 cr8_prev = kvm_get_cr8(vcpu); u8 cr8 = (u8)val; err = kvm_set_cr8(vcpu, cr8); kvm_complete_insn_gp(vcpu, err); if (irqchip_in_kernel(vcpu->kvm)) return 1; if (cr8_prev <= cr8) return 1; vcpu->run->exit_reason = KVM_EXIT_SET_TPR; return 0; } } break; case 2: / clts / handle_clts(vcpu); trace_kvm_cr_write(0, kvm_read_cr0(vcpu)); skip_emulated_instruction(vcpu); vmx_fpu_activate(vcpu); return 1; case 1: /mov from cr/ switch (cr) { case 3: val = kvm_read_cr3(vcpu); kvm_register_write(vcpu, reg, val); trace_kvm_cr_read(cr, val); skip_emulated_instruction(vcpu); return 1; case 8: val = kvm_get_cr8(vcpu); kvm_register_write(vcpu, reg, val); trace_kvm_cr_read(cr, val); skip_emulated_instruction(vcpu); return 1; } break; case 3: / lmsw / val = (exit_qualification >> LMSW_SOURCE_DATA_SHIFT) & 0x0f; trace_kvm_cr_write(0, (kvm_read_cr0(vcpu) & ~0xful) \| val); kvm_lmsw(vcpu, val); skip_emulated_instruction(vcpu); return 1; default: break; } vcpu->run->exit_reason = 0; vcpu_unimpl(vcpu, "unhandled control register: op %d cr %d\n", (int)(exit_qualification >> 4) & 3, cr); return 0; } static int handle_dr(struct kvm_vcpu vcpu) { unsigned long exit_qualification; int dr, reg; /* Do not handle if the CPL > 0, will trigger GP on re-entry / if (!kvm_require_cpl(vcpu, 0)) return 1; dr = vmcs_readl(GUEST_DR7); if (dr & DR7_GD) { / * As the vm-exit takes precedence over the debug trap, we * need to emulate the latter, either for the host or the * guest debugging itself. / if (vcpu->guest_debug & KVM_GUESTDBG_USE_HW_BP) { vcpu->run->debug.arch.dr6 = vcpu->arch.dr6; vcpu->run->debug.arch.dr7 = dr; vcpu->run->debug.arch.pc = vmcs_readl(GUEST_CS_BASE) + vmcs_readl(GUEST_RIP); vcpu->run->debug.arch.exception = DB_VECTOR; vcpu->run->exit_reason = KVM_EXIT_DEBUG; return 0; } else { vcpu->arch.dr7 &= ~DR7_GD; vcpu->arch.dr6 \|= DR6_BD \| DR6_RTM; vmcs_writel(GUEST_DR7, vcpu->arch.dr7); kvm_queue_exception(vcpu, DB_VECTOR); return 1; } } if (vcpu->guest_debug == 0) { u32 cpu_based_vm_exec_control; cpu_based_vm_exec_control = vmcs_read32(CPU_BASED_VM_EXEC_CONTROL); cpu_based_vm_exec_control &= ~CPU_BASED_MOV_DR_EXITING; vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, cpu_based_vm_exec_control); / * No more DR vmexits; force a reload of the debug registers * and reenter on this instruction. The next vmexit will * retrieve the full state of the debug registers. / vcpu->arch.switch_db_regs \|= KVM_DEBUGREG_WONT_EXIT; return 1; } exit_qualification = vmcs_readl(EXIT_QUALIFICATION); dr = exit_qualification & DEBUG_REG_ACCESS_NUM; reg = DEBUG_REG_ACCESS_REG(exit_qualification); if (exit_qualification & TYPE_MOV_FROM_DR) { unsigned long val; if (kvm_get_dr(vcpu, dr, &val)) return 1; kvm_register_write(vcpu, reg, val); } else if (kvm_set_dr(vcpu, dr, kvm_register_readl(vcpu, reg))) return 1; skip_emulated_instruction(vcpu); return 1; } static u64 vmx_get_dr6(struct kvm_vcpu vcpu) { return vcpu->arch.dr6; } static void vmx_set_dr6(struct kvm_vcpu vcpu, unsigned long val) { } static void vmx_sync_dirty_debug_regs(struct kvm_vcpu vcpu) { u32 cpu_based_vm_exec_control; get_debugreg(vcpu->arch.db[0], 0); get_debugreg(vcpu->arch.db[1], 1); get_debugreg(vcpu->arch.db[2], 2); get_debugreg(vcpu->arch.db[3], 3); get_debugreg(vcpu->arch.dr6, 6); vcpu->arch.dr7 = vmcs_readl(GUEST_DR7); vcpu->arch.switch_db_regs &= ~KVM_DEBUGREG_WONT_EXIT; cpu_based_vm_exec_control = vmcs_read32(CPU_BASED_VM_EXEC_CONTROL); cpu_based_vm_exec_control \|= CPU_BASED_MOV_DR_EXITING; vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, cpu_based_vm_exec_control); } static void vmx_set_dr7(struct kvm_vcpu vcpu, unsigned long val) { vmcs_writel(GUEST_DR7, val); } static int handle_cpuid(struct kvm_vcpu vcpu) { kvm_emulate_cpuid(vcpu); return 1; } static int handle_rdmsr(struct kvm_vcpu vcpu) { u32 ecx = vcpu->arch.regs[VCPU_REGS_RCX]; u64 data; if (vmx_get_msr(vcpu, ecx, &data)) { trace_kvm_msr_read_ex(ecx); kvm_inject_gp(vcpu, 0); return 1; } trace_kvm_msr_read(ecx, data); / FIXME: handling of bits 32:63 of rax, rdx / vcpu->arch.regs[VCPU_REGS_RAX] = data & -1u; vcpu->arch.regs[VCPU_REGS_RDX] = (data >> 32) & -1u; skip_emulated_instruction(vcpu); return 1; } static int handle_wrmsr(struct kvm_vcpu vcpu) { struct msr_data msr; u32 ecx = vcpu->arch.regs[VCPU_REGS_RCX]; u64 data = (vcpu->arch.regs[VCPU_REGS_RAX] & -1u) \| ((u64)(vcpu->arch.regs[VCPU_REGS_RDX] & -1u) << 32); msr.data = data; msr.index = ecx; msr.host_initiated = false; if (kvm_set_msr(vcpu, &msr) != 0) { trace_kvm_msr_write_ex(ecx, data); kvm_inject_gp(vcpu, 0); return 1; } trace_kvm_msr_write(ecx, data); skip_emulated_instruction(vcpu); return 1; } static int handle_tpr_below_threshold(struct kvm_vcpu vcpu) { kvm_make_request(KVM_REQ_EVENT, vcpu); return 1; } static int handle_interrupt_window(struct kvm_vcpu vcpu) { u32 cpu_based_vm_exec_control; /* clear pending irq / cpu_based_vm_exec_control = vmcs_read32(CPU_BASED_VM_EXEC_CONTROL); cpu_based_vm_exec_control &= ~CPU_BASED_VIRTUAL_INTR_PENDING; vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, cpu_based_vm_exec_control); kvm_make_request(KVM_REQ_EVENT, vcpu); ++vcpu->stat.irq_window_exits; / * If the user space waits to inject interrupts, exit as soon as * possible / if (!irqchip_in_kernel(vcpu->kvm) && vcpu->run->request_interrupt_window && !kvm_cpu_has_interrupt(vcpu)) { vcpu->run->exit_reason = KVM_EXIT_IRQ_WINDOW_OPEN; return 0; } return 1; } static int handle_halt(struct kvm_vcpu vcpu) { skip_emulated_instruction(vcpu); return kvm_emulate_halt(vcpu); } static int handle_vmcall(struct kvm_vcpu vcpu) { skip_emulated_instruction(vcpu); kvm_emulate_hypercall(vcpu); return 1; } static int handle_invd(struct kvm_vcpu vcpu) { return emulate_instruction(vcpu, 0) == EMULATE_DONE; } static int handle_invlpg(struct kvm_vcpu vcpu) { unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION); kvm_mmu_invlpg(vcpu, exit_qualification); skip_emulated_instruction(vcpu); return 1; } static int handle_rdpmc(struct kvm_vcpu vcpu) { int err; err = kvm_rdpmc(vcpu); kvm_complete_insn_gp(vcpu, err); return 1; } static int handle_wbinvd(struct kvm_vcpu vcpu) { skip_emulated_instruction(vcpu); kvm_emulate_wbinvd(vcpu); return 1; } static int handle_xsetbv(struct kvm_vcpu vcpu) { u64 new_bv = kvm_read_edx_eax(vcpu); u32 index = kvm_register_read(vcpu, VCPU_REGS_RCX); if (kvm_set_xcr(vcpu, index, new_bv) == 0) skip_emulated_instruction(vcpu); return 1; } static int handle_apic_access(struct kvm_vcpu vcpu) { if (likely(fasteoi)) { unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION); int access_type, offset; access_type = exit_qualification & APIC_ACCESS_TYPE; offset = exit_qualification & APIC_ACCESS_OFFSET; / * Sane guest uses MOV to write EOI, with written value * not cared. So make a short-circuit here by avoiding * heavy instruction emulation. / if ((access_type == TYPE_LINEAR_APIC_INST_WRITE) && (offset == APIC_EOI)) { kvm_lapic_set_eoi(vcpu); skip_emulated_instruction(vcpu); return 1; } } return emulate_instruction(vcpu, 0) == EMULATE_DONE; } static int handle_apic_eoi_induced(struct kvm_vcpu vcpu) { unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION); int vector = exit_qualification & 0xff; /* EOI-induced VM exit is trap-like and thus no need to adjust IP / kvm_apic_set_eoi_accelerated(vcpu, vector); return 1; } static int handle_apic_write(struct kvm_vcpu vcpu) { unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION); u32 offset = exit_qualification & 0xfff; /* APIC-write VM exit is trap-like and thus no need to adjust IP / kvm_apic_write_nodecode(vcpu, offset); return 1; } static int handle_task_switch(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); unsigned long exit_qualification; bool has_error_code = false; u32 error_code = 0; u16 tss_selector; int reason, type, idt_v, idt_index; idt_v = (vmx->idt_vectoring_info & VECTORING_INFO_VALID_MASK); idt_index = (vmx->idt_vectoring_info & VECTORING_INFO_VECTOR_MASK); type = (vmx->idt_vectoring_info & VECTORING_INFO_TYPE_MASK); exit_qualification = vmcs_readl(EXIT_QUALIFICATION); reason = (u32)exit_qualification >> 30; if (reason == TASK_SWITCH_GATE && idt_v) { switch (type) { case INTR_TYPE_NMI_INTR: vcpu->arch.nmi_injected = false; vmx_set_nmi_mask(vcpu, true); break; case INTR_TYPE_EXT_INTR: case INTR_TYPE_SOFT_INTR: kvm_clear_interrupt_queue(vcpu); break; case INTR_TYPE_HARD_EXCEPTION: if (vmx->idt_vectoring_info & VECTORING_INFO_DELIVER_CODE_MASK) { has_error_code = true; error_code = vmcs_read32(IDT_VECTORING_ERROR_CODE); } / fall through / case INTR_TYPE_SOFT_EXCEPTION: kvm_clear_exception_queue(vcpu); break; default: break; } } tss_selector = exit_qualification; if (!idt_v \|\| (type != INTR_TYPE_HARD_EXCEPTION && type != INTR_TYPE_EXT_INTR && type != INTR_TYPE_NMI_INTR)) skip_emulated_instruction(vcpu); if (kvm_task_switch(vcpu, tss_selector, type == INTR_TYPE_SOFT_INTR ? idt_index : -1, reason, has_error_code, error_code) == EMULATE_FAIL) { vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR; vcpu->run->internal.suberror = KVM_INTERNAL_ERROR_EMULATION; vcpu->run->internal.ndata = 0; return 0; } / clear all local breakpoint enable flags / vmcs_writel(GUEST_DR7, vmcs_readl(GUEST_DR7) & ~0x55); / * TODO: What about debug traps on tss switch? * Are we supposed to inject them and update dr6? / return 1; } static int handle_ept_violation(struct kvm_vcpu vcpu) { unsigned long exit_qualification; gpa_t gpa; u32 error_code; int gla_validity; exit_qualification = vmcs_readl(EXIT_QUALIFICATION); gla_validity = (exit_qualification >> 7) & 0x3; if (gla_validity != 0x3 && gla_validity != 0x1 && gla_validity != 0) { printk(KERN_ERR "EPT: Handling EPT violation failed!\n"); printk(KERN_ERR "EPT: GPA: 0x%lx, GVA: 0x%lx\n", (long unsigned int)vmcs_read64(GUEST_PHYSICAL_ADDRESS), vmcs_readl(GUEST_LINEAR_ADDRESS)); printk(KERN_ERR "EPT: Exit qualification is 0x%lx\n", (long unsigned int)exit_qualification); vcpu->run->exit_reason = KVM_EXIT_UNKNOWN; vcpu->run->hw.hardware_exit_reason = EXIT_REASON_EPT_VIOLATION; return 0; } /* * EPT violation happened while executing iret from NMI, * "blocked by NMI" bit has to be set before next VM entry. * There are errata that may cause this bit to not be set: * AAK134, BY25. / if (!(to_vmx(vcpu)->idt_vectoring_info & VECTORING_INFO_VALID_MASK) && cpu_has_virtual_nmis() && (exit_qualification & INTR_INFO_UNBLOCK_NMI)) vmcs_set_bits(GUEST_INTERRUPTIBILITY_INFO, GUEST_INTR_STATE_NMI); gpa = vmcs_read64(GUEST_PHYSICAL_ADDRESS); trace_kvm_page_fault(gpa, exit_qualification); / It is a write fault? / error_code = exit_qualification & (1U << 1); / It is a fetch fault? / error_code \|= (exit_qualification & (1U << 2)) << 2; / ept page table is present? / error_code \|= (exit_qualification >> 3) & 0x1; vcpu->arch.exit_qualification = exit_qualification; return kvm_mmu_page_fault(vcpu, gpa, error_code, NULL, 0); } static u64 ept_rsvd_mask(u64 spte, int level) { int i; u64 mask = 0; for (i = 51; i > boot_cpu_data.x86_phys_bits; i--) mask \|= (1ULL << i); if (level == 4) / bits 7:3 reserved / mask \|= 0xf8; else if (spte & (1ULL << 7)) / * 1GB/2MB page, bits 29:12 or 20:12 reserved respectively, * level == 1 if the hypervisor is using the ignored bit 7. / mask \|= (PAGE_SIZE << ((level - 1) 9)) - PAGE_SIZE; else if (level > 1) /* bits 6:3 reserved / mask \|= 0x78; return mask; } static void ept_misconfig_inspect_spte(struct kvm_vcpu vcpu, u64 spte, int level) { printk(KERN_ERR "%s: spte 0x%llx level %d\n", __func__, spte, level); /* 010b (write-only) / WARN_ON((spte & 0x7) == 0x2); / 110b (write/execute) / WARN_ON((spte & 0x7) == 0x6); / 100b (execute-only) and value not supported by logical processor / if (!cpu_has_vmx_ept_execute_only()) WARN_ON((spte & 0x7) == 0x4); / not 000b / if ((spte & 0x7)) { u64 rsvd_bits = spte & ept_rsvd_mask(spte, level); if (rsvd_bits != 0) { printk(KERN_ERR "%s: rsvd_bits = 0x%llx\n", __func__, rsvd_bits); WARN_ON(1); } / bits 5:3 are _not_ reserved for large page or leaf page / if ((rsvd_bits & 0x38) == 0) { u64 ept_mem_type = (spte & 0x38) >> 3; if (ept_mem_type == 2 \|\| ept_mem_type == 3 \|\| ept_mem_type == 7) { printk(KERN_ERR "%s: ept_mem_type=0x%llx\n", __func__, ept_mem_type); WARN_ON(1); } } } } static int handle_ept_misconfig(struct kvm_vcpu vcpu) { u64 sptes[4]; int nr_sptes, i, ret; gpa_t gpa; gpa = vmcs_read64(GUEST_PHYSICAL_ADDRESS); if (!kvm_io_bus_write(vcpu->kvm, KVM_FAST_MMIO_BUS, gpa, 0, NULL)) { skip_emulated_instruction(vcpu); return 1; } ret = handle_mmio_page_fault_common(vcpu, gpa, true); if (likely(ret == RET_MMIO_PF_EMULATE)) return x86_emulate_instruction(vcpu, gpa, 0, NULL, 0) == EMULATE_DONE; if (unlikely(ret == RET_MMIO_PF_INVALID)) return kvm_mmu_page_fault(vcpu, gpa, 0, NULL, 0); if (unlikely(ret == RET_MMIO_PF_RETRY)) return 1; /* It is the real ept misconfig / printk(KERN_ERR "EPT: Misconfiguration.\n"); printk(KERN_ERR "EPT: GPA: 0x%llx\n", gpa); nr_sptes = kvm_mmu_get_spte_hierarchy(vcpu, gpa, sptes); for (i = PT64_ROOT_LEVEL; i > PT64_ROOT_LEVEL - nr_sptes; --i) ept_misconfig_inspect_spte(vcpu, sptes[i-1], i); vcpu->run->exit_reason = KVM_EXIT_UNKNOWN; vcpu->run->hw.hardware_exit_reason = EXIT_REASON_EPT_MISCONFIG; return 0; } static int handle_nmi_window(struct kvm_vcpu vcpu) { u32 cpu_based_vm_exec_control; /* clear pending NMI / cpu_based_vm_exec_control = vmcs_read32(CPU_BASED_VM_EXEC_CONTROL); cpu_based_vm_exec_control &= ~CPU_BASED_VIRTUAL_NMI_PENDING; vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, cpu_based_vm_exec_control); ++vcpu->stat.nmi_window_exits; kvm_make_request(KVM_REQ_EVENT, vcpu); return 1; } static int handle_invalid_guest_state(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); enum emulation_result err = EMULATE_DONE; int ret = 1; u32 cpu_exec_ctrl; bool intr_window_requested; unsigned count = 130; cpu_exec_ctrl = vmcs_read32(CPU_BASED_VM_EXEC_CONTROL); intr_window_requested = cpu_exec_ctrl & CPU_BASED_VIRTUAL_INTR_PENDING; while (vmx->emulation_required && count-- != 0) { if (intr_window_requested && vmx_interrupt_allowed(vcpu)) return handle_interrupt_window(&vmx->vcpu); if (test_bit(KVM_REQ_EVENT, &vcpu->requests)) return 1; err = emulate_instruction(vcpu, EMULTYPE_NO_REEXECUTE); if (err == EMULATE_USER_EXIT) { ++vcpu->stat.mmio_exits; ret = 0; goto out; } if (err != EMULATE_DONE) { vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR; vcpu->run->internal.suberror = KVM_INTERNAL_ERROR_EMULATION; vcpu->run->internal.ndata = 0; return 0; } if (vcpu->arch.halt_request) { vcpu->arch.halt_request = 0; ret = kvm_emulate_halt(vcpu); goto out; } if (signal_pending(current)) goto out; if (need_resched()) schedule(); } out: return ret; } static int __grow_ple_window(int val) { if (ple_window_grow < 1) return ple_window; val = min(val, ple_window_actual_max); if (ple_window_grow < ple_window) val = ple_window_grow; else val += ple_window_grow; return val; } static int __shrink_ple_window(int val, int modifier, int minimum) { if (modifier < 1) return ple_window; if (modifier < ple_window) val /= modifier; else val -= modifier; return max(val, minimum); } static void grow_ple_window(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); int old = vmx->ple_window; vmx->ple_window = __grow_ple_window(old); if (vmx->ple_window != old) vmx->ple_window_dirty = true; trace_kvm_ple_window_grow(vcpu->vcpu_id, vmx->ple_window, old); } static void shrink_ple_window(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); int old = vmx->ple_window; vmx->ple_window = __shrink_ple_window(old, ple_window_shrink, ple_window); if (vmx->ple_window != old) vmx->ple_window_dirty = true; trace_kvm_ple_window_shrink(vcpu->vcpu_id, vmx->ple_window, old); } /* * ple_window_actual_max is computed to be one grow_ple_window() below * ple_window_max. (See __grow_ple_window for the reason.) * This prevents overflows, because ple_window_max is int. * ple_window_max effectively rounded down to a multiple of ple_window_grow in * this process. * ple_window_max is also prevented from setting vmx->ple_window < ple_window. / static void update_ple_window_actual_max(void) { ple_window_actual_max = __shrink_ple_window(max(ple_window_max, ple_window), ple_window_grow, INT_MIN); } / * Indicate a busy-waiting vcpu in spinlock. We do not enable the PAUSE * exiting, so only get here on cpu with PAUSE-Loop-Exiting. / static int handle_pause(struct kvm_vcpu vcpu) { if (ple_gap) grow_ple_window(vcpu); skip_emulated_instruction(vcpu); kvm_vcpu_on_spin(vcpu); return 1; } static int handle_nop(struct kvm_vcpu vcpu) { skip_emulated_instruction(vcpu); return 1; } static int handle_mwait(struct kvm_vcpu vcpu) { printk_once(KERN_WARNING "kvm: MWAIT instruction emulated as NOP!\n"); return handle_nop(vcpu); } static int handle_monitor(struct kvm_vcpu vcpu) { printk_once(KERN_WARNING "kvm: MONITOR instruction emulated as NOP!\n"); return handle_nop(vcpu); } / * To run an L2 guest, we need a vmcs02 based on the L1-specified vmcs12. * We could reuse a single VMCS for all the L2 guests, but we also want the * option to allocate a separate vmcs02 for each separate loaded vmcs12 - this * allows keeping them loaded on the processor, and in the future will allow * optimizations where prepare_vmcs02 doesn't need to set all the fields on * every entry if they never change. * So we keep, in vmx->nested.vmcs02_pool, a cache of size VMCS02_POOL_SIZE * (>=0) with a vmcs02 for each recently loaded vmcs12s, most recent first. * * The following functions allocate and free a vmcs02 in this pool. / / Get a VMCS from the pool to use as vmcs02 for the current vmcs12. / static struct loaded_vmcs nested_get_current_vmcs02(struct vcpu_vmx vmx) { struct vmcs02_list item; list_for_each_entry(item, &vmx->nested.vmcs02_pool, list) if (item->vmptr == vmx->nested.current_vmptr) { list_move(&item->list, &vmx->nested.vmcs02_pool); return &item->vmcs02; } if (vmx->nested.vmcs02_num >= max(VMCS02_POOL_SIZE, 1)) { /* Recycle the least recently used VMCS. / item = list_entry(vmx->nested.vmcs02_pool.prev, struct vmcs02_list, list); item->vmptr = vmx->nested.current_vmptr; list_move(&item->list, &vmx->nested.vmcs02_pool); return &item->vmcs02; } / Create a new VMCS / item = kmalloc(sizeof(struct vmcs02_list), GFP_KERNEL); if (!item) return NULL; item->vmcs02.vmcs = alloc_vmcs(); if (!item->vmcs02.vmcs) { kfree(item); return NULL; } loaded_vmcs_init(&item->vmcs02); item->vmptr = vmx->nested.current_vmptr; list_add(&(item->list), &(vmx->nested.vmcs02_pool)); vmx->nested.vmcs02_num++; return &item->vmcs02; } / Free and remove from pool a vmcs02 saved for a vmcs12 (if there is one) / static void nested_free_vmcs02(struct vcpu_vmx vmx, gpa_t vmptr) { struct vmcs02_list item; list_for_each_entry(item, &vmx->nested.vmcs02_pool, list) if (item->vmptr == vmptr) { free_loaded_vmcs(&item->vmcs02); list_del(&item->list); kfree(item); vmx->nested.vmcs02_num--; return; } } / * Free all VMCSs saved for this vcpu, except the one pointed by * vmx->loaded_vmcs. We must be running L1, so vmx->loaded_vmcs * must be &vmx->vmcs01. / static void nested_free_all_saved_vmcss(struct vcpu_vmx vmx) { struct vmcs02_list item, n; WARN_ON(vmx->loaded_vmcs != &vmx->vmcs01); list_for_each_entry_safe(item, n, &vmx->nested.vmcs02_pool, list) { /* * Something will leak if the above WARN triggers. Better than * a use-after-free. / if (vmx->loaded_vmcs == &item->vmcs02) continue; free_loaded_vmcs(&item->vmcs02); list_del(&item->list); kfree(item); vmx->nested.vmcs02_num--; } } / * The following 3 functions, nested_vmx_succeed()/failValid()/failInvalid(), * set the success or error code of an emulated VMX instruction, as specified * by Vol 2B, VMX Instruction Reference, "Conventions". / static void nested_vmx_succeed(struct kvm_vcpu vcpu) { vmx_set_rflags(vcpu, vmx_get_rflags(vcpu) & ~(X86_EFLAGS_CF \| X86_EFLAGS_PF \| X86_EFLAGS_AF \| X86_EFLAGS_ZF \| X86_EFLAGS_SF \| X86_EFLAGS_OF)); } static void nested_vmx_failInvalid(struct kvm_vcpu vcpu) { vmx_set_rflags(vcpu, (vmx_get_rflags(vcpu) & ~(X86_EFLAGS_PF \| X86_EFLAGS_AF \| X86_EFLAGS_ZF \| X86_EFLAGS_SF \| X86_EFLAGS_OF)) \| X86_EFLAGS_CF); } static void nested_vmx_failValid(struct kvm_vcpu vcpu, u32 vm_instruction_error) { if (to_vmx(vcpu)->nested.current_vmptr == -1ull) { /* * failValid writes the error number to the current VMCS, which * can't be done there isn't a current VMCS. / nested_vmx_failInvalid(vcpu); return; } vmx_set_rflags(vcpu, (vmx_get_rflags(vcpu) & ~(X86_EFLAGS_CF \| X86_EFLAGS_PF \| X86_EFLAGS_AF \| X86_EFLAGS_SF \| X86_EFLAGS_OF)) \| X86_EFLAGS_ZF); get_vmcs12(vcpu)->vm_instruction_error = vm_instruction_error; / * We don't need to force a shadow sync because * VM_INSTRUCTION_ERROR is not shadowed / } static enum hrtimer_restart vmx_preemption_timer_fn(struct hrtimer timer) { struct vcpu_vmx vmx = container_of(timer, struct vcpu_vmx, nested.preemption_timer); vmx->nested.preemption_timer_expired = true; kvm_make_request(KVM_REQ_EVENT, &vmx->vcpu); kvm_vcpu_kick(&vmx->vcpu); return HRTIMER_NORESTART; } / * Decode the memory-address operand of a vmx instruction, as recorded on an * exit caused by such an instruction (run by a guest hypervisor). * On success, returns 0. When the operand is invalid, returns 1 and throws * #UD or #GP. / static int get_vmx_mem_address(struct kvm_vcpu vcpu, unsigned long exit_qualification, u32 vmx_instruction_info, gva_t ret) { / * According to Vol. 3B, "Information for VM Exits Due to Instruction * Execution", on an exit, vmx_instruction_info holds most of the * addressing components of the operand. Only the displacement part * is put in exit_qualification (see 3B, "Basic VM-Exit Information"). * For how an actual address is calculated from all these components, * refer to Vol. 1, "Operand Addressing". / int scaling = vmx_instruction_info & 3; int addr_size = (vmx_instruction_info >> 7) & 7; bool is_reg = vmx_instruction_info & (1u << 10); int seg_reg = (vmx_instruction_info >> 15) & 7; int index_reg = (vmx_instruction_info >> 18) & 0xf; bool index_is_valid = !(vmx_instruction_info & (1u << 22)); int base_reg = (vmx_instruction_info >> 23) & 0xf; bool base_is_valid = !(vmx_instruction_info & (1u << 27)); if (is_reg) { kvm_queue_exception(vcpu, UD_VECTOR); return 1; } / Addr = segment_base + offset / / offset = base + [index * scale] + displacement / ret = vmx_get_segment_base(vcpu, seg_reg); if (base_is_valid) ret += kvm_register_read(vcpu, base_reg); if (index_is_valid) ret += kvm_register_read(vcpu, index_reg)<<scaling; ret += exit_qualification; / holds the displacement / if (addr_size == 1) / 32 bit / ret &= 0xffffffff; /* * TODO: throw #GP (and return 1) in various cases that the VM* * instructions require it - e.g., offset beyond segment limit, * unusable or unreadable/unwritable segment, non-canonical 64-bit * address, and so on. Currently these are not checked. / return 0; } / * This function performs the various checks including * - if it's 4KB aligned * - No bits beyond the physical address width are set * - Returns 0 on success or else 1 * (Intel SDM Section 30.3) / static int nested_vmx_check_vmptr(struct kvm_vcpu vcpu, int exit_reason, gpa_t vmpointer) { gva_t gva; gpa_t vmptr; struct x86_exception e; struct page page; struct vcpu_vmx vmx = to_vmx(vcpu); int maxphyaddr = cpuid_maxphyaddr(vcpu); if (get_vmx_mem_address(vcpu, vmcs_readl(EXIT_QUALIFICATION), vmcs_read32(VMX_INSTRUCTION_INFO), &gva)) return 1; if (kvm_read_guest_virt(&vcpu->arch.emulate_ctxt, gva, &vmptr, sizeof(vmptr), &e)) { kvm_inject_page_fault(vcpu, &e); return 1; } switch (exit_reason) { case EXIT_REASON_VMON: / * SDM 3: 24.11.5 * The first 4 bytes of VMXON region contain the supported * VMCS revision identifier * * Note - IA32_VMX_BASIC[48] will never be 1 * for the nested case; * which replaces physical address width with 32 * / if (!PAGE_ALIGNED(vmptr) \|\| (vmptr >> maxphyaddr)) { nested_vmx_failInvalid(vcpu); skip_emulated_instruction(vcpu); return 1; } page = nested_get_page(vcpu, vmptr); if (page == NULL \|\| (u32 )kmap(page) != VMCS12_REVISION) { nested_vmx_failInvalid(vcpu); kunmap(page); skip_emulated_instruction(vcpu); return 1; } kunmap(page); vmx->nested.vmxon_ptr = vmptr; break; case EXIT_REASON_VMCLEAR: if (!PAGE_ALIGNED(vmptr) \|\| (vmptr >> maxphyaddr)) { nested_vmx_failValid(vcpu, VMXERR_VMCLEAR_INVALID_ADDRESS); skip_emulated_instruction(vcpu); return 1; } if (vmptr == vmx->nested.vmxon_ptr) { nested_vmx_failValid(vcpu, VMXERR_VMCLEAR_VMXON_POINTER); skip_emulated_instruction(vcpu); return 1; } break; case EXIT_REASON_VMPTRLD: if (!PAGE_ALIGNED(vmptr) \|\| (vmptr >> maxphyaddr)) { nested_vmx_failValid(vcpu, VMXERR_VMPTRLD_INVALID_ADDRESS); skip_emulated_instruction(vcpu); return 1; } if (vmptr == vmx->nested.vmxon_ptr) { nested_vmx_failValid(vcpu, VMXERR_VMCLEAR_VMXON_POINTER); skip_emulated_instruction(vcpu); return 1; } break; default: return 1; / shouldn't happen / } if (vmpointer) vmpointer = vmptr; return 0; } /* * Emulate the VMXON instruction. * Currently, we just remember that VMX is active, and do not save or even * inspect the argument to VMXON (the so-called "VMXON pointer") because we * do not currently need to store anything in that guest-allocated memory * region. Consequently, VMCLEAR and VMPTRLD also do not verify that the their * argument is different from the VMXON pointer (which the spec says they do). / static int handle_vmon(struct kvm_vcpu vcpu) { struct kvm_segment cs; struct vcpu_vmx vmx = to_vmx(vcpu); struct vmcs shadow_vmcs; const u64 VMXON_NEEDED_FEATURES = FEATURE_CONTROL_LOCKED \| FEATURE_CONTROL_VMXON_ENABLED_OUTSIDE_SMX; /* The Intel VMX Instruction Reference lists a bunch of bits that * are prerequisite to running VMXON, most notably cr4.VMXE must be * set to 1 (see vmx_set_cr4() for when we allow the guest to set this). * Otherwise, we should fail with #UD. We test these now: / if (!kvm_read_cr4_bits(vcpu, X86_CR4_VMXE) \|\| !kvm_read_cr0_bits(vcpu, X86_CR0_PE) \|\| (vmx_get_rflags(vcpu) & X86_EFLAGS_VM)) { kvm_queue_exception(vcpu, UD_VECTOR); return 1; } vmx_get_segment(vcpu, &cs, VCPU_SREG_CS); if (is_long_mode(vcpu) && !cs.l) { kvm_queue_exception(vcpu, UD_VECTOR); return 1; } if (vmx_get_cpl(vcpu)) { kvm_inject_gp(vcpu, 0); return 1; } if (nested_vmx_check_vmptr(vcpu, EXIT_REASON_VMON, NULL)) return 1; if (vmx->nested.vmxon) { nested_vmx_failValid(vcpu, VMXERR_VMXON_IN_VMX_ROOT_OPERATION); skip_emulated_instruction(vcpu); return 1; } if ((vmx->nested.msr_ia32_feature_control & VMXON_NEEDED_FEATURES) != VMXON_NEEDED_FEATURES) { kvm_inject_gp(vcpu, 0); return 1; } if (enable_shadow_vmcs) { shadow_vmcs = alloc_vmcs(); if (!shadow_vmcs) return -ENOMEM; / mark vmcs as shadow / shadow_vmcs->revision_id \|= (1u << 31); / init shadow vmcs / vmcs_clear(shadow_vmcs); vmx->nested.current_shadow_vmcs = shadow_vmcs; } INIT_LIST_HEAD(&(vmx->nested.vmcs02_pool)); vmx->nested.vmcs02_num = 0; hrtimer_init(&vmx->nested.preemption_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); vmx->nested.preemption_timer.function = vmx_preemption_timer_fn; vmx->nested.vmxon = true; skip_emulated_instruction(vcpu); nested_vmx_succeed(vcpu); return 1; } / * Intel's VMX Instruction Reference specifies a common set of prerequisites * for running VMX instructions (except VMXON, whose prerequisites are * slightly different). It also specifies what exception to inject otherwise. / static int nested_vmx_check_permission(struct kvm_vcpu vcpu) { struct kvm_segment cs; struct vcpu_vmx vmx = to_vmx(vcpu); if (!vmx->nested.vmxon) { kvm_queue_exception(vcpu, UD_VECTOR); return 0; } vmx_get_segment(vcpu, &cs, VCPU_SREG_CS); if ((vmx_get_rflags(vcpu) & X86_EFLAGS_VM) \|\| (is_long_mode(vcpu) && !cs.l)) { kvm_queue_exception(vcpu, UD_VECTOR); return 0; } if (vmx_get_cpl(vcpu)) { kvm_inject_gp(vcpu, 0); return 0; } return 1; } static inline void nested_release_vmcs12(struct vcpu_vmx vmx) { u32 exec_control; if (vmx->nested.current_vmptr == -1ull) return; /* current_vmptr and current_vmcs12 are always set/reset together / if (WARN_ON(vmx->nested.current_vmcs12 == NULL)) return; if (enable_shadow_vmcs) { / copy to memory all shadowed fields in case they were modified / copy_shadow_to_vmcs12(vmx); vmx->nested.sync_shadow_vmcs = false; exec_control = vmcs_read32(SECONDARY_VM_EXEC_CONTROL); exec_control &= ~SECONDARY_EXEC_SHADOW_VMCS; vmcs_write32(SECONDARY_VM_EXEC_CONTROL, exec_control); vmcs_write64(VMCS_LINK_POINTER, -1ull); } kunmap(vmx->nested.current_vmcs12_page); nested_release_page(vmx->nested.current_vmcs12_page); vmx->nested.current_vmptr = -1ull; vmx->nested.current_vmcs12 = NULL; } / * Free whatever needs to be freed from vmx->nested when L1 goes down, or * just stops using VMX. / static void free_nested(struct vcpu_vmx vmx) { if (!vmx->nested.vmxon) return; vmx->nested.vmxon = false; nested_release_vmcs12(vmx); if (enable_shadow_vmcs) free_vmcs(vmx->nested.current_shadow_vmcs); /* Unpin physical memory we referred to in current vmcs02 / if (vmx->nested.apic_access_page) { nested_release_page(vmx->nested.apic_access_page); vmx->nested.apic_access_page = NULL; } if (vmx->nested.virtual_apic_page) { nested_release_page(vmx->nested.virtual_apic_page); vmx->nested.virtual_apic_page = NULL; } nested_free_all_saved_vmcss(vmx); } / Emulate the VMXOFF instruction / static int handle_vmoff(struct kvm_vcpu vcpu) { if (!nested_vmx_check_permission(vcpu)) return 1; free_nested(to_vmx(vcpu)); skip_emulated_instruction(vcpu); nested_vmx_succeed(vcpu); return 1; } /* Emulate the VMCLEAR instruction / static int handle_vmclear(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); gpa_t vmptr; struct vmcs12 vmcs12; struct page page; if (!nested_vmx_check_permission(vcpu)) return 1; if (nested_vmx_check_vmptr(vcpu, EXIT_REASON_VMCLEAR, &vmptr)) return 1; if (vmptr == vmx->nested.current_vmptr) nested_release_vmcs12(vmx); page = nested_get_page(vcpu, vmptr); if (page == NULL) { / * For accurate processor emulation, VMCLEAR beyond available * physical memory should do nothing at all. However, it is * possible that a nested vmx bug, not a guest hypervisor bug, * resulted in this case, so let's shut down before doing any * more damage: / kvm_make_request(KVM_REQ_TRIPLE_FAULT, vcpu); return 1; } vmcs12 = kmap(page); vmcs12->launch_state = 0; kunmap(page); nested_release_page(page); nested_free_vmcs02(vmx, vmptr); skip_emulated_instruction(vcpu); nested_vmx_succeed(vcpu); return 1; } static int nested_vmx_run(struct kvm_vcpu vcpu, bool launch); /* Emulate the VMLAUNCH instruction / static int handle_vmlaunch(struct kvm_vcpu vcpu) { return nested_vmx_run(vcpu, true); } /* Emulate the VMRESUME instruction / static int handle_vmresume(struct kvm_vcpu vcpu) { return nested_vmx_run(vcpu, false); } enum vmcs_field_type { VMCS_FIELD_TYPE_U16 = 0, VMCS_FIELD_TYPE_U64 = 1, VMCS_FIELD_TYPE_U32 = 2, VMCS_FIELD_TYPE_NATURAL_WIDTH = 3 }; static inline int vmcs_field_type(unsigned long field) { if (0x1 & field) /* the _HIGH fields are all 32 bit / return VMCS_FIELD_TYPE_U32; return (field >> 13) & 0x3 ; } static inline int vmcs_field_readonly(unsigned long field) { return (((field >> 10) & 0x3) == 1); } /* * Read a vmcs12 field. Since these can have varying lengths and we return * one type, we chose the biggest type (u64) and zero-extend the return value * to that size. Note that the caller, handle_vmread, might need to use only * some of the bits we return here (e.g., on 32-bit guests, only 32 bits of * 64-bit fields are to be returned). / static inline bool vmcs12_read_any(struct kvm_vcpu vcpu, unsigned long field, u64 ret) { short offset = vmcs_field_to_offset(field); char p; if (offset < 0) return 0; p = ((char )(get_vmcs12(vcpu))) + offset; switch (vmcs_field_type(field)) { case VMCS_FIELD_TYPE_NATURAL_WIDTH: ret = ((natural_width )p); return 1; case VMCS_FIELD_TYPE_U16: ret = ((u16 )p); return 1; case VMCS_FIELD_TYPE_U32: ret = ((u32 )p); return 1; case VMCS_FIELD_TYPE_U64: ret = ((u64 )p); return 1; default: return 0; / can never happen. / } } static inline bool vmcs12_write_any(struct kvm_vcpu vcpu, unsigned long field, u64 field_value){ short offset = vmcs_field_to_offset(field); char p = ((char ) get_vmcs12(vcpu)) + offset; if (offset < 0) return false; switch (vmcs_field_type(field)) { case VMCS_FIELD_TYPE_U16: (u16 )p = field_value; return true; case VMCS_FIELD_TYPE_U32: (u32 )p = field_value; return true; case VMCS_FIELD_TYPE_U64: (u64 )p = field_value; return true; case VMCS_FIELD_TYPE_NATURAL_WIDTH: (natural_width )p = field_value; return true; default: return false; /* can never happen. / } } static void copy_shadow_to_vmcs12(struct vcpu_vmx vmx) { int i; unsigned long field; u64 field_value; struct vmcs shadow_vmcs = vmx->nested.current_shadow_vmcs; const unsigned long fields = shadow_read_write_fields; const int num_fields = max_shadow_read_write_fields; vmcs_load(shadow_vmcs); for (i = 0; i < num_fields; i++) { field = fields[i]; switch (vmcs_field_type(field)) { case VMCS_FIELD_TYPE_U16: field_value = vmcs_read16(field); break; case VMCS_FIELD_TYPE_U32: field_value = vmcs_read32(field); break; case VMCS_FIELD_TYPE_U64: field_value = vmcs_read64(field); break; case VMCS_FIELD_TYPE_NATURAL_WIDTH: field_value = vmcs_readl(field); break; } vmcs12_write_any(&vmx->vcpu, field, field_value); } vmcs_clear(shadow_vmcs); vmcs_load(vmx->loaded_vmcs->vmcs); } static void copy_vmcs12_to_shadow(struct vcpu_vmx vmx) { const unsigned long fields[] = { shadow_read_write_fields, shadow_read_only_fields }; const int max_fields[] = { max_shadow_read_write_fields, max_shadow_read_only_fields }; int i, q; unsigned long field; u64 field_value = 0; struct vmcs shadow_vmcs = vmx->nested.current_shadow_vmcs; vmcs_load(shadow_vmcs); for (q = 0; q < ARRAY_SIZE(fields); q++) { for (i = 0; i < max_fields[q]; i++) { field = fields[q][i]; vmcs12_read_any(&vmx->vcpu, field, &field_value); switch (vmcs_field_type(field)) { case VMCS_FIELD_TYPE_U16: vmcs_write16(field, (u16)field_value); break; case VMCS_FIELD_TYPE_U32: vmcs_write32(field, (u32)field_value); break; case VMCS_FIELD_TYPE_U64: vmcs_write64(field, (u64)field_value); break; case VMCS_FIELD_TYPE_NATURAL_WIDTH: vmcs_writel(field, (long)field_value); break; } } } vmcs_clear(shadow_vmcs); vmcs_load(vmx->loaded_vmcs->vmcs); } / * VMX instructions which assume a current vmcs12 (i.e., that VMPTRLD was * used before) all generate the same failure when it is missing. / static int nested_vmx_check_vmcs12(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); if (vmx->nested.current_vmptr == -1ull) { nested_vmx_failInvalid(vcpu); skip_emulated_instruction(vcpu); return 0; } return 1; } static int handle_vmread(struct kvm_vcpu vcpu) { unsigned long field; u64 field_value; unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION); u32 vmx_instruction_info = vmcs_read32(VMX_INSTRUCTION_INFO); gva_t gva = 0; if (!nested_vmx_check_permission(vcpu) \|\| !nested_vmx_check_vmcs12(vcpu)) return 1; /* Decode instruction info and find the field to read / field = kvm_register_readl(vcpu, (((vmx_instruction_info) >> 28) & 0xf)); / Read the field, zero-extended to a u64 field_value / if (!vmcs12_read_any(vcpu, field, &field_value)) { nested_vmx_failValid(vcpu, VMXERR_UNSUPPORTED_VMCS_COMPONENT); skip_emulated_instruction(vcpu); return 1; } / * Now copy part of this value to register or memory, as requested. * Note that the number of bits actually copied is 32 or 64 depending * on the guest's mode (32 or 64 bit), not on the given field's length. / if (vmx_instruction_info & (1u << 10)) { kvm_register_writel(vcpu, (((vmx_instruction_info) >> 3) & 0xf), field_value); } else { if (get_vmx_mem_address(vcpu, exit_qualification, vmx_instruction_info, &gva)) return 1; / _system ok, as nested_vmx_check_permission verified cpl=0 / kvm_write_guest_virt_system(&vcpu->arch.emulate_ctxt, gva, &field_value, (is_long_mode(vcpu) ? 8 : 4), NULL); } nested_vmx_succeed(vcpu); skip_emulated_instruction(vcpu); return 1; } static int handle_vmwrite(struct kvm_vcpu vcpu) { unsigned long field; gva_t gva; unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION); u32 vmx_instruction_info = vmcs_read32(VMX_INSTRUCTION_INFO); /* The value to write might be 32 or 64 bits, depending on L1's long * mode, and eventually we need to write that into a field of several * possible lengths. The code below first zero-extends the value to 64 * bit (field_value), and then copies only the approriate number of * bits into the vmcs12 field. / u64 field_value = 0; struct x86_exception e; if (!nested_vmx_check_permission(vcpu) \|\| !nested_vmx_check_vmcs12(vcpu)) return 1; if (vmx_instruction_info & (1u << 10)) field_value = kvm_register_readl(vcpu, (((vmx_instruction_info) >> 3) & 0xf)); else { if (get_vmx_mem_address(vcpu, exit_qualification, vmx_instruction_info, &gva)) return 1; if (kvm_read_guest_virt(&vcpu->arch.emulate_ctxt, gva, &field_value, (is_64_bit_mode(vcpu) ? 8 : 4), &e)) { kvm_inject_page_fault(vcpu, &e); return 1; } } field = kvm_register_readl(vcpu, (((vmx_instruction_info) >> 28) & 0xf)); if (vmcs_field_readonly(field)) { nested_vmx_failValid(vcpu, VMXERR_VMWRITE_READ_ONLY_VMCS_COMPONENT); skip_emulated_instruction(vcpu); return 1; } if (!vmcs12_write_any(vcpu, field, field_value)) { nested_vmx_failValid(vcpu, VMXERR_UNSUPPORTED_VMCS_COMPONENT); skip_emulated_instruction(vcpu); return 1; } nested_vmx_succeed(vcpu); skip_emulated_instruction(vcpu); return 1; } / Emulate the VMPTRLD instruction / static int handle_vmptrld(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); gpa_t vmptr; u32 exec_control; if (!nested_vmx_check_permission(vcpu)) return 1; if (nested_vmx_check_vmptr(vcpu, EXIT_REASON_VMPTRLD, &vmptr)) return 1; if (vmx->nested.current_vmptr != vmptr) { struct vmcs12 new_vmcs12; struct page page; page = nested_get_page(vcpu, vmptr); if (page == NULL) { nested_vmx_failInvalid(vcpu); skip_emulated_instruction(vcpu); return 1; } new_vmcs12 = kmap(page); if (new_vmcs12->revision_id != VMCS12_REVISION) { kunmap(page); nested_release_page_clean(page); nested_vmx_failValid(vcpu, VMXERR_VMPTRLD_INCORRECT_VMCS_REVISION_ID); skip_emulated_instruction(vcpu); return 1; } nested_release_vmcs12(vmx); vmx->nested.current_vmptr = vmptr; vmx->nested.current_vmcs12 = new_vmcs12; vmx->nested.current_vmcs12_page = page; if (enable_shadow_vmcs) { exec_control = vmcs_read32(SECONDARY_VM_EXEC_CONTROL); exec_control \|= SECONDARY_EXEC_SHADOW_VMCS; vmcs_write32(SECONDARY_VM_EXEC_CONTROL, exec_control); vmcs_write64(VMCS_LINK_POINTER, __pa(vmx->nested.current_shadow_vmcs)); vmx->nested.sync_shadow_vmcs = true; } } nested_vmx_succeed(vcpu); skip_emulated_instruction(vcpu); return 1; } / Emulate the VMPTRST instruction / static int handle_vmptrst(struct kvm_vcpu vcpu) { unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION); u32 vmx_instruction_info = vmcs_read32(VMX_INSTRUCTION_INFO); gva_t vmcs_gva; struct x86_exception e; if (!nested_vmx_check_permission(vcpu)) return 1; if (get_vmx_mem_address(vcpu, exit_qualification, vmx_instruction_info, &vmcs_gva)) return 1; /* ok to use _system, as nested_vmx_check_permission verified cpl=0 / if (kvm_write_guest_virt_system(&vcpu->arch.emulate_ctxt, vmcs_gva, (void )&to_vmx(vcpu)->nested.current_vmptr, sizeof(u64), &e)) { kvm_inject_page_fault(vcpu, &e); return 1; } nested_vmx_succeed(vcpu); skip_emulated_instruction(vcpu); return 1; } / Emulate the INVEPT instruction / static int handle_invept(struct kvm_vcpu vcpu) { u32 vmx_instruction_info, types; unsigned long type; gva_t gva; struct x86_exception e; struct { u64 eptp, gpa; } operand; if (!(nested_vmx_secondary_ctls_high & SECONDARY_EXEC_ENABLE_EPT) \|\| !(nested_vmx_ept_caps & VMX_EPT_INVEPT_BIT)) { kvm_queue_exception(vcpu, UD_VECTOR); return 1; } if (!nested_vmx_check_permission(vcpu)) return 1; if (!kvm_read_cr0_bits(vcpu, X86_CR0_PE)) { kvm_queue_exception(vcpu, UD_VECTOR); return 1; } vmx_instruction_info = vmcs_read32(VMX_INSTRUCTION_INFO); type = kvm_register_readl(vcpu, (vmx_instruction_info >> 28) & 0xf); types = (nested_vmx_ept_caps >> VMX_EPT_EXTENT_SHIFT) & 6; if (!(types & (1UL << type))) { nested_vmx_failValid(vcpu, VMXERR_INVALID_OPERAND_TO_INVEPT_INVVPID); return 1; } /* According to the Intel VMX instruction reference, the memory * operand is read even if it isn't needed (e.g., for type==global) / if (get_vmx_mem_address(vcpu, vmcs_readl(EXIT_QUALIFICATION), vmx_instruction_info, &gva)) return 1; if (kvm_read_guest_virt(&vcpu->arch.emulate_ctxt, gva, &operand, sizeof(operand), &e)) { kvm_inject_page_fault(vcpu, &e); return 1; } switch (type) { case VMX_EPT_EXTENT_GLOBAL: kvm_mmu_sync_roots(vcpu); kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu); nested_vmx_succeed(vcpu); break; default: / Trap single context invalidation invept calls / BUG_ON(1); break; } skip_emulated_instruction(vcpu); return 1; } static int handle_invvpid(struct kvm_vcpu vcpu) { kvm_queue_exception(vcpu, UD_VECTOR); return 1; } /* * The exit handlers return 1 if the exit was handled fully and guest execution * may resume. Otherwise they set the kvm_run parameter to indicate what needs * to be done to userspace and return 0. / static int (const kvm_vmx_exit_handlers[])(struct kvm_vcpu vcpu) = { [EXIT_REASON_EXCEPTION_NMI] = handle_exception, [EXIT_REASON_EXTERNAL_INTERRUPT] = handle_external_interrupt, [EXIT_REASON_TRIPLE_FAULT] = handle_triple_fault, [EXIT_REASON_NMI_WINDOW] = handle_nmi_window, [EXIT_REASON_IO_INSTRUCTION] = handle_io, [EXIT_REASON_CR_ACCESS] = handle_cr, [EXIT_REASON_DR_ACCESS] = handle_dr, [EXIT_REASON_CPUID] = handle_cpuid, [EXIT_REASON_MSR_READ] = handle_rdmsr, [EXIT_REASON_MSR_WRITE] = handle_wrmsr, [EXIT_REASON_PENDING_INTERRUPT] = handle_interrupt_window, [EXIT_REASON_HLT] = handle_halt, [EXIT_REASON_INVD] = handle_invd, [EXIT_REASON_INVLPG] = handle_invlpg, [EXIT_REASON_RDPMC] = handle_rdpmc, [EXIT_REASON_VMCALL] = handle_vmcall, [EXIT_REASON_VMCLEAR] = handle_vmclear, [EXIT_REASON_VMLAUNCH] = handle_vmlaunch, [EXIT_REASON_VMPTRLD] = handle_vmptrld, [EXIT_REASON_VMPTRST] = handle_vmptrst, [EXIT_REASON_VMREAD] = handle_vmread, [EXIT_REASON_VMRESUME] = handle_vmresume, [EXIT_REASON_VMWRITE] = handle_vmwrite, [EXIT_REASON_VMOFF] = handle_vmoff, [EXIT_REASON_VMON] = handle_vmon, [EXIT_REASON_TPR_BELOW_THRESHOLD] = handle_tpr_below_threshold, [EXIT_REASON_APIC_ACCESS] = handle_apic_access, [EXIT_REASON_APIC_WRITE] = handle_apic_write, [EXIT_REASON_EOI_INDUCED] = handle_apic_eoi_induced, [EXIT_REASON_WBINVD] = handle_wbinvd, [EXIT_REASON_XSETBV] = handle_xsetbv, [EXIT_REASON_TASK_SWITCH] = handle_task_switch, [EXIT_REASON_MCE_DURING_VMENTRY] = handle_machine_check, [EXIT_REASON_EPT_VIOLATION] = handle_ept_violation, [EXIT_REASON_EPT_MISCONFIG] = handle_ept_misconfig, [EXIT_REASON_PAUSE_INSTRUCTION] = handle_pause, [EXIT_REASON_MWAIT_INSTRUCTION] = handle_mwait, [EXIT_REASON_MONITOR_INSTRUCTION] = handle_monitor, [EXIT_REASON_INVEPT] = handle_invept, [EXIT_REASON_INVVPID] = handle_invvpid, }; static const int kvm_vmx_max_exit_handlers = ARRAY_SIZE(kvm_vmx_exit_handlers); static bool nested_vmx_exit_handled_io(struct kvm_vcpu vcpu, struct vmcs12 vmcs12) { unsigned long exit_qualification; gpa_t bitmap, last_bitmap; unsigned int port; int size; u8 b; if (!nested_cpu_has(vmcs12, CPU_BASED_USE_IO_BITMAPS)) return nested_cpu_has(vmcs12, CPU_BASED_UNCOND_IO_EXITING); exit_qualification = vmcs_readl(EXIT_QUALIFICATION); port = exit_qualification >> 16; size = (exit_qualification & 7) + 1; last_bitmap = (gpa_t)-1; b = -1; while (size > 0) { if (port < 0x8000) bitmap = vmcs12->io_bitmap_a; else if (port < 0x10000) bitmap = vmcs12->io_bitmap_b; else return 1; bitmap += (port & 0x7fff) / 8; if (last_bitmap != bitmap) if (kvm_read_guest(vcpu->kvm, bitmap, &b, 1)) return 1; if (b & (1 << (port & 7))) return 1; port++; size--; last_bitmap = bitmap; } return 0; } / * Return 1 if we should exit from L2 to L1 to handle an MSR access access, * rather than handle it ourselves in L0. I.e., check whether L1 expressed * disinterest in the current event (read or write a specific MSR) by using an * MSR bitmap. This may be the case even when L0 doesn't use MSR bitmaps. / static bool nested_vmx_exit_handled_msr(struct kvm_vcpu vcpu, struct vmcs12 vmcs12, u32 exit_reason) { u32 msr_index = vcpu->arch.regs[VCPU_REGS_RCX]; gpa_t bitmap; if (!nested_cpu_has(vmcs12, CPU_BASED_USE_MSR_BITMAPS)) return 1; / * The MSR_BITMAP page is divided into four 1024-byte bitmaps, * for the four combinations of read/write and low/high MSR numbers. * First we need to figure out which of the four to use: / bitmap = vmcs12->msr_bitmap; if (exit_reason == EXIT_REASON_MSR_WRITE) bitmap += 2048; if (msr_index >= 0xc0000000) { msr_index -= 0xc0000000; bitmap += 1024; } / Then read the msr_index'th bit from this bitmap: / if (msr_index < 10248) { unsigned char b; if (kvm_read_guest(vcpu->kvm, bitmap + msr_index/8, &b, 1)) return 1; return 1 & (b >> (msr_index & 7)); } else return 1; /* let L1 handle the wrong parameter / } / * Return 1 if we should exit from L2 to L1 to handle a CR access exit, * rather than handle it ourselves in L0. I.e., check if L1 wanted to * intercept (via guest_host_mask etc.) the current event. / static bool nested_vmx_exit_handled_cr(struct kvm_vcpu vcpu, struct vmcs12 vmcs12) { unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION); int cr = exit_qualification & 15; int reg = (exit_qualification >> 8) & 15; unsigned long val = kvm_register_readl(vcpu, reg); switch ((exit_qualification >> 4) & 3) { case 0: / mov to cr / switch (cr) { case 0: if (vmcs12->cr0_guest_host_mask & (val ^ vmcs12->cr0_read_shadow)) return 1; break; case 3: if ((vmcs12->cr3_target_count >= 1 && vmcs12->cr3_target_value0 == val) \|\| (vmcs12->cr3_target_count >= 2 && vmcs12->cr3_target_value1 == val) \|\| (vmcs12->cr3_target_count >= 3 && vmcs12->cr3_target_value2 == val) \|\| (vmcs12->cr3_target_count >= 4 && vmcs12->cr3_target_value3 == val)) return 0; if (nested_cpu_has(vmcs12, CPU_BASED_CR3_LOAD_EXITING)) return 1; break; case 4: if (vmcs12->cr4_guest_host_mask & (vmcs12->cr4_read_shadow ^ val)) return 1; break; case 8: if (nested_cpu_has(vmcs12, CPU_BASED_CR8_LOAD_EXITING)) return 1; break; } break; case 2: / clts / if ((vmcs12->cr0_guest_host_mask & X86_CR0_TS) && (vmcs12->cr0_read_shadow & X86_CR0_TS)) return 1; break; case 1: / mov from cr / switch (cr) { case 3: if (vmcs12->cpu_based_vm_exec_control & CPU_BASED_CR3_STORE_EXITING) return 1; break; case 8: if (vmcs12->cpu_based_vm_exec_control & CPU_BASED_CR8_STORE_EXITING) return 1; break; } break; case 3: / lmsw / / * lmsw can change bits 1..3 of cr0, and only set bit 0 of * cr0. Other attempted changes are ignored, with no exit. / if (vmcs12->cr0_guest_host_mask & 0xe & (val ^ vmcs12->cr0_read_shadow)) return 1; if ((vmcs12->cr0_guest_host_mask & 0x1) && !(vmcs12->cr0_read_shadow & 0x1) && (val & 0x1)) return 1; break; } return 0; } / * Return 1 if we should exit from L2 to L1 to handle an exit, or 0 if we * should handle it ourselves in L0 (and then continue L2). Only call this * when in is_guest_mode (L2). / static bool nested_vmx_exit_handled(struct kvm_vcpu vcpu) { u32 intr_info = vmcs_read32(VM_EXIT_INTR_INFO); struct vcpu_vmx vmx = to_vmx(vcpu); struct vmcs12 vmcs12 = get_vmcs12(vcpu); u32 exit_reason = vmx->exit_reason; trace_kvm_nested_vmexit(kvm_rip_read(vcpu), exit_reason, vmcs_readl(EXIT_QUALIFICATION), vmx->idt_vectoring_info, intr_info, vmcs_read32(VM_EXIT_INTR_ERROR_CODE), KVM_ISA_VMX); if (vmx->nested.nested_run_pending) return 0; if (unlikely(vmx->fail)) { pr_info_ratelimited("%s failed vm entry %x\n", __func__, vmcs_read32(VM_INSTRUCTION_ERROR)); return 1; } switch (exit_reason) { case EXIT_REASON_EXCEPTION_NMI: if (!is_exception(intr_info)) return 0; else if (is_page_fault(intr_info)) return enable_ept; else if (is_no_device(intr_info) && !(vmcs12->guest_cr0 & X86_CR0_TS)) return 0; return vmcs12->exception_bitmap & (1u << (intr_info & INTR_INFO_VECTOR_MASK)); case EXIT_REASON_EXTERNAL_INTERRUPT: return 0; case EXIT_REASON_TRIPLE_FAULT: return 1; case EXIT_REASON_PENDING_INTERRUPT: return nested_cpu_has(vmcs12, CPU_BASED_VIRTUAL_INTR_PENDING); case EXIT_REASON_NMI_WINDOW: return nested_cpu_has(vmcs12, CPU_BASED_VIRTUAL_NMI_PENDING); case EXIT_REASON_TASK_SWITCH: return 1; case EXIT_REASON_CPUID: if (kvm_register_read(vcpu, VCPU_REGS_RAX) == 0xa) return 0; return 1; case EXIT_REASON_HLT: return nested_cpu_has(vmcs12, CPU_BASED_HLT_EXITING); case EXIT_REASON_INVD: return 1; case EXIT_REASON_INVLPG: return nested_cpu_has(vmcs12, CPU_BASED_INVLPG_EXITING); case EXIT_REASON_RDPMC: return nested_cpu_has(vmcs12, CPU_BASED_RDPMC_EXITING); case EXIT_REASON_RDTSC: return nested_cpu_has(vmcs12, CPU_BASED_RDTSC_EXITING); case EXIT_REASON_VMCALL: case EXIT_REASON_VMCLEAR: case EXIT_REASON_VMLAUNCH: case EXIT_REASON_VMPTRLD: case EXIT_REASON_VMPTRST: case EXIT_REASON_VMREAD: case EXIT_REASON_VMRESUME: case EXIT_REASON_VMWRITE: case EXIT_REASON_VMOFF: case EXIT_REASON_VMON: case EXIT_REASON_INVEPT: case EXIT_REASON_INVVPID: /* * VMX instructions trap unconditionally. This allows L1 to * emulate them for its L2 guest, i.e., allows 3-level nesting! / return 1; case EXIT_REASON_CR_ACCESS: return nested_vmx_exit_handled_cr(vcpu, vmcs12); case EXIT_REASON_DR_ACCESS: return nested_cpu_has(vmcs12, CPU_BASED_MOV_DR_EXITING); case EXIT_REASON_IO_INSTRUCTION: return nested_vmx_exit_handled_io(vcpu, vmcs12); case EXIT_REASON_MSR_READ: case EXIT_REASON_MSR_WRITE: return nested_vmx_exit_handled_msr(vcpu, vmcs12, exit_reason); case EXIT_REASON_INVALID_STATE: return 1; case EXIT_REASON_MWAIT_INSTRUCTION: return nested_cpu_has(vmcs12, CPU_BASED_MWAIT_EXITING); case EXIT_REASON_MONITOR_INSTRUCTION: return nested_cpu_has(vmcs12, CPU_BASED_MONITOR_EXITING); case EXIT_REASON_PAUSE_INSTRUCTION: return nested_cpu_has(vmcs12, CPU_BASED_PAUSE_EXITING) \|\| nested_cpu_has2(vmcs12, SECONDARY_EXEC_PAUSE_LOOP_EXITING); case EXIT_REASON_MCE_DURING_VMENTRY: return 0; case EXIT_REASON_TPR_BELOW_THRESHOLD: return nested_cpu_has(vmcs12, CPU_BASED_TPR_SHADOW); case EXIT_REASON_APIC_ACCESS: return nested_cpu_has2(vmcs12, SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES); case EXIT_REASON_EPT_VIOLATION: / * L0 always deals with the EPT violation. If nested EPT is * used, and the nested mmu code discovers that the address is * missing in the guest EPT table (EPT12), the EPT violation * will be injected with nested_ept_inject_page_fault() / return 0; case EXIT_REASON_EPT_MISCONFIG: / * L2 never uses directly L1's EPT, but rather L0's own EPT * table (shadow on EPT) or a merged EPT table that L0 built * (EPT on EPT). So any problems with the structure of the * table is L0's fault. / return 0; case EXIT_REASON_WBINVD: return nested_cpu_has2(vmcs12, SECONDARY_EXEC_WBINVD_EXITING); case EXIT_REASON_XSETBV: return 1; default: return 1; } } static void vmx_get_exit_info(struct kvm_vcpu vcpu, u64 info1, u64 info2) { info1 = vmcs_readl(EXIT_QUALIFICATION); info2 = vmcs_read32(VM_EXIT_INTR_INFO); } /* * The guest has exited. See if we can fix it or if we need userspace * assistance. / static int vmx_handle_exit(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); u32 exit_reason = vmx->exit_reason; u32 vectoring_info = vmx->idt_vectoring_info; / If guest state is invalid, start emulating / if (vmx->emulation_required) return handle_invalid_guest_state(vcpu); if (is_guest_mode(vcpu) && nested_vmx_exit_handled(vcpu)) { nested_vmx_vmexit(vcpu, exit_reason, vmcs_read32(VM_EXIT_INTR_INFO), vmcs_readl(EXIT_QUALIFICATION)); return 1; } if (exit_reason & VMX_EXIT_REASONS_FAILED_VMENTRY) { vcpu->run->exit_reason = KVM_EXIT_FAIL_ENTRY; vcpu->run->fail_entry.hardware_entry_failure_reason = exit_reason; return 0; } if (unlikely(vmx->fail)) { vcpu->run->exit_reason = KVM_EXIT_FAIL_ENTRY; vcpu->run->fail_entry.hardware_entry_failure_reason = vmcs_read32(VM_INSTRUCTION_ERROR); return 0; } / * Note: * Do not try to fix EXIT_REASON_EPT_MISCONFIG if it caused by * delivery event since it indicates guest is accessing MMIO. * The vm-exit can be triggered again after return to guest that * will cause infinite loop. / if ((vectoring_info & VECTORING_INFO_VALID_MASK) && (exit_reason != EXIT_REASON_EXCEPTION_NMI && exit_reason != EXIT_REASON_EPT_VIOLATION && exit_reason != EXIT_REASON_TASK_SWITCH)) { vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR; vcpu->run->internal.suberror = KVM_INTERNAL_ERROR_DELIVERY_EV; vcpu->run->internal.ndata = 2; vcpu->run->internal.data[0] = vectoring_info; vcpu->run->internal.data[1] = exit_reason; return 0; } if (unlikely(!cpu_has_virtual_nmis() && vmx->soft_vnmi_blocked && !(is_guest_mode(vcpu) && nested_cpu_has_virtual_nmis( get_vmcs12(vcpu))))) { if (vmx_interrupt_allowed(vcpu)) { vmx->soft_vnmi_blocked = 0; } else if (vmx->vnmi_blocked_time > 1000000000LL && vcpu->arch.nmi_pending) { / * This CPU don't support us in finding the end of an * NMI-blocked window if the guest runs with IRQs * disabled. So we pull the trigger after 1 s of * futile waiting, but inform the user about this. / printk(KERN_WARNING "%s: Breaking out of NMI-blocked " "state on VCPU %d after 1 s timeout\n", __func__, vcpu->vcpu_id); vmx->soft_vnmi_blocked = 0; } } if (exit_reason < kvm_vmx_max_exit_handlers && kvm_vmx_exit_handlers[exit_reason]) return kvm_vmx_exit_handlers[exit_reason](vcpu); else { vcpu->run->exit_reason = KVM_EXIT_UNKNOWN; vcpu->run->hw.hardware_exit_reason = exit_reason; } return 0; } static void update_cr8_intercept(struct kvm_vcpu vcpu, int tpr, int irr) { struct vmcs12 vmcs12 = get_vmcs12(vcpu); if (is_guest_mode(vcpu) && nested_cpu_has(vmcs12, CPU_BASED_TPR_SHADOW)) return; if (irr == -1 \|\| tpr < irr) { vmcs_write32(TPR_THRESHOLD, 0); return; } vmcs_write32(TPR_THRESHOLD, irr); } static void vmx_set_virtual_x2apic_mode(struct kvm_vcpu vcpu, bool set) { u32 sec_exec_control; /* * There is not point to enable virtualize x2apic without enable * apicv / if (!cpu_has_vmx_virtualize_x2apic_mode() \|\| !vmx_vm_has_apicv(vcpu->kvm)) return; if (!vm_need_tpr_shadow(vcpu->kvm)) return; sec_exec_control = vmcs_read32(SECONDARY_VM_EXEC_CONTROL); if (set) { sec_exec_control &= ~SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES; sec_exec_control \|= SECONDARY_EXEC_VIRTUALIZE_X2APIC_MODE; } else { sec_exec_control &= ~SECONDARY_EXEC_VIRTUALIZE_X2APIC_MODE; sec_exec_control \|= SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES; } vmcs_write32(SECONDARY_VM_EXEC_CONTROL, sec_exec_control); vmx_set_msr_bitmap(vcpu); } static void vmx_set_apic_access_page_addr(struct kvm_vcpu vcpu, hpa_t hpa) { struct vcpu_vmx vmx = to_vmx(vcpu); / * Currently we do not handle the nested case where L2 has an * APIC access page of its own; that page is still pinned. * Hence, we skip the case where the VCPU is in guest mode _and_ * L1 prepared an APIC access page for L2. * * For the case where L1 and L2 share the same APIC access page * (flexpriority=Y but SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES clear * in the vmcs12), this function will only update either the vmcs01 * or the vmcs02. If the former, the vmcs02 will be updated by * prepare_vmcs02. If the latter, the vmcs01 will be updated in * the next L2->L1 exit. / if (!is_guest_mode(vcpu) \|\| !nested_cpu_has2(vmx->nested.current_vmcs12, SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES)) vmcs_write64(APIC_ACCESS_ADDR, hpa); } static void vmx_hwapic_isr_update(struct kvm kvm, int isr) { u16 status; u8 old; if (!vmx_vm_has_apicv(kvm)) return; if (isr == -1) isr = 0; status = vmcs_read16(GUEST_INTR_STATUS); old = status >> 8; if (isr != old) { status &= 0xff; status \|= isr << 8; vmcs_write16(GUEST_INTR_STATUS, status); } } static void vmx_set_rvi(int vector) { u16 status; u8 old; status = vmcs_read16(GUEST_INTR_STATUS); old = (u8)status & 0xff; if ((u8)vector != old) { status &= ~0xff; status \|= (u8)vector; vmcs_write16(GUEST_INTR_STATUS, status); } } static void vmx_hwapic_irr_update(struct kvm_vcpu vcpu, int max_irr) { if (max_irr == -1) return; / * If a vmexit is needed, vmx_check_nested_events handles it. / if (is_guest_mode(vcpu) && nested_exit_on_intr(vcpu)) return; if (!is_guest_mode(vcpu)) { vmx_set_rvi(max_irr); return; } / * Fall back to pre-APICv interrupt injection since L2 * is run without virtual interrupt delivery. / if (!kvm_event_needs_reinjection(vcpu) && vmx_interrupt_allowed(vcpu)) { kvm_queue_interrupt(vcpu, max_irr, false); vmx_inject_irq(vcpu); } } static void vmx_load_eoi_exitmap(struct kvm_vcpu vcpu, u64 eoi_exit_bitmap) { if (!vmx_vm_has_apicv(vcpu->kvm)) return; vmcs_write64(EOI_EXIT_BITMAP0, eoi_exit_bitmap[0]); vmcs_write64(EOI_EXIT_BITMAP1, eoi_exit_bitmap[1]); vmcs_write64(EOI_EXIT_BITMAP2, eoi_exit_bitmap[2]); vmcs_write64(EOI_EXIT_BITMAP3, eoi_exit_bitmap[3]); } static void vmx_complete_atomic_exit(struct vcpu_vmx vmx) { u32 exit_intr_info; if (!(vmx->exit_reason == EXIT_REASON_MCE_DURING_VMENTRY \|\| vmx->exit_reason == EXIT_REASON_EXCEPTION_NMI)) return; vmx->exit_intr_info = vmcs_read32(VM_EXIT_INTR_INFO); exit_intr_info = vmx->exit_intr_info; /* Handle machine checks before interrupts are enabled / if (is_machine_check(exit_intr_info)) kvm_machine_check(); / We need to handle NMIs before interrupts are enabled / if ((exit_intr_info & INTR_INFO_INTR_TYPE_MASK) == INTR_TYPE_NMI_INTR && (exit_intr_info & INTR_INFO_VALID_MASK)) { kvm_before_handle_nmi(&vmx->vcpu); asm("int $2"); kvm_after_handle_nmi(&vmx->vcpu); } } static void vmx_handle_external_intr(struct kvm_vcpu vcpu) { u32 exit_intr_info = vmcs_read32(VM_EXIT_INTR_INFO); /* * If external interrupt exists, IF bit is set in rflags/eflags on the * interrupt stack frame, and interrupt will be enabled on a return * from interrupt handler. / if ((exit_intr_info & (INTR_INFO_VALID_MASK \| INTR_INFO_INTR_TYPE_MASK)) == (INTR_INFO_VALID_MASK \| INTR_TYPE_EXT_INTR)) { unsigned int vector; unsigned long entry; gate_desc desc; struct vcpu_vmx vmx = to_vmx(vcpu); #ifdef CONFIG_X86_64 unsigned long tmp; #endif vector = exit_intr_info & INTR_INFO_VECTOR_MASK; desc = (gate_desc )vmx->host_idt_base + vector; entry = gate_offset(desc); asm volatile( #ifdef CONFIG_X86_64 "mov %%" _ASM_SP ", %[sp]\n\t" "and $0xfffffffffffffff0, %%" _ASM_SP "\n\t" "push $%c[ss]\n\t" "push %[sp]\n\t" #endif "pushf\n\t" "orl $0x200, (%%" _ASM_SP ")\n\t" __ASM_SIZE(push) " $%c[cs]\n\t" "call %[entry]\n\t" : #ifdef CONFIG_X86_64 [sp]"=&r"(tmp) #endif : [entry]"r"(entry), [ss]"i"(__KERNEL_DS), [cs]"i"(__KERNEL_CS) ); } else local_irq_enable(); } static bool vmx_mpx_supported(void) { return (vmcs_config.vmexit_ctrl & VM_EXIT_CLEAR_BNDCFGS) && (vmcs_config.vmentry_ctrl & VM_ENTRY_LOAD_BNDCFGS); } static void vmx_recover_nmi_blocking(struct vcpu_vmx vmx) { u32 exit_intr_info; bool unblock_nmi; u8 vector; bool idtv_info_valid; idtv_info_valid = vmx->idt_vectoring_info & VECTORING_INFO_VALID_MASK; if (cpu_has_virtual_nmis()) { if (vmx->nmi_known_unmasked) return; / * Can't use vmx->exit_intr_info since we're not sure what * the exit reason is. / exit_intr_info = vmcs_read32(VM_EXIT_INTR_INFO); unblock_nmi = (exit_intr_info & INTR_INFO_UNBLOCK_NMI) != 0; vector = exit_intr_info & INTR_INFO_VECTOR_MASK; / * SDM 3: 27.7.1.2 (September 2008) * Re-set bit "block by NMI" before VM entry if vmexit caused by * a guest IRET fault. * SDM 3: 23.2.2 (September 2008) * Bit 12 is undefined in any of the following cases: * If the VM exit sets the valid bit in the IDT-vectoring * information field. * If the VM exit is due to a double fault. / if ((exit_intr_info & INTR_INFO_VALID_MASK) && unblock_nmi && vector != DF_VECTOR && !idtv_info_valid) vmcs_set_bits(GUEST_INTERRUPTIBILITY_INFO, GUEST_INTR_STATE_NMI); else vmx->nmi_known_unmasked = !(vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) & GUEST_INTR_STATE_NMI); } else if (unlikely(vmx->soft_vnmi_blocked)) vmx->vnmi_blocked_time += ktime_to_ns(ktime_sub(ktime_get(), vmx->entry_time)); } static void __vmx_complete_interrupts(struct kvm_vcpu vcpu, u32 idt_vectoring_info, int instr_len_field, int error_code_field) { u8 vector; int type; bool idtv_info_valid; idtv_info_valid = idt_vectoring_info & VECTORING_INFO_VALID_MASK; vcpu->arch.nmi_injected = false; kvm_clear_exception_queue(vcpu); kvm_clear_interrupt_queue(vcpu); if (!idtv_info_valid) return; kvm_make_request(KVM_REQ_EVENT, vcpu); vector = idt_vectoring_info & VECTORING_INFO_VECTOR_MASK; type = idt_vectoring_info & VECTORING_INFO_TYPE_MASK; switch (type) { case INTR_TYPE_NMI_INTR: vcpu->arch.nmi_injected = true; /* * SDM 3: 27.7.1.2 (September 2008) * Clear bit "block by NMI" before VM entry if a NMI * delivery faulted. / vmx_set_nmi_mask(vcpu, false); break; case INTR_TYPE_SOFT_EXCEPTION: vcpu->arch.event_exit_inst_len = vmcs_read32(instr_len_field); / fall through / case INTR_TYPE_HARD_EXCEPTION: if (idt_vectoring_info & VECTORING_INFO_DELIVER_CODE_MASK) { u32 err = vmcs_read32(error_code_field); kvm_requeue_exception_e(vcpu, vector, err); } else kvm_requeue_exception(vcpu, vector); break; case INTR_TYPE_SOFT_INTR: vcpu->arch.event_exit_inst_len = vmcs_read32(instr_len_field); / fall through / case INTR_TYPE_EXT_INTR: kvm_queue_interrupt(vcpu, vector, type == INTR_TYPE_SOFT_INTR); break; default: break; } } static void vmx_complete_interrupts(struct vcpu_vmx vmx) { __vmx_complete_interrupts(&vmx->vcpu, vmx->idt_vectoring_info, VM_EXIT_INSTRUCTION_LEN, IDT_VECTORING_ERROR_CODE); } static void vmx_cancel_injection(struct kvm_vcpu vcpu) { __vmx_complete_interrupts(vcpu, vmcs_read32(VM_ENTRY_INTR_INFO_FIELD), VM_ENTRY_INSTRUCTION_LEN, VM_ENTRY_EXCEPTION_ERROR_CODE); vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, 0); } static void atomic_switch_perf_msrs(struct vcpu_vmx vmx) { int i, nr_msrs; struct perf_guest_switch_msr msrs; msrs = perf_guest_get_msrs(&nr_msrs); if (!msrs) return; for (i = 0; i < nr_msrs; i++) if (msrs[i].host == msrs[i].guest) clear_atomic_switch_msr(vmx, msrs[i].msr); else add_atomic_switch_msr(vmx, msrs[i].msr, msrs[i].guest, msrs[i].host); } static void __noclone vmx_vcpu_run(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); unsigned long debugctlmsr, cr4; / Record the guest's net vcpu time for enforced NMI injections. / if (unlikely(!cpu_has_virtual_nmis() && vmx->soft_vnmi_blocked)) vmx->entry_time = ktime_get(); / Don't enter VMX if guest state is invalid, let the exit handler start emulation until we arrive back to a valid state / if (vmx->emulation_required) return; if (vmx->ple_window_dirty) { vmx->ple_window_dirty = false; vmcs_write32(PLE_WINDOW, vmx->ple_window); } if (vmx->nested.sync_shadow_vmcs) { copy_vmcs12_to_shadow(vmx); vmx->nested.sync_shadow_vmcs = false; } if (test_bit(VCPU_REGS_RSP, (unsigned long )&vcpu->arch.regs_dirty)) vmcs_writel(GUEST_RSP, vcpu->arch.regs[VCPU_REGS_RSP]); if (test_bit(VCPU_REGS_RIP, (unsigned long )&vcpu->arch.regs_dirty)) vmcs_writel(GUEST_RIP, vcpu->arch.regs[VCPU_REGS_RIP]); cr4 = read_cr4(); if (unlikely(cr4 != vmx->host_state.vmcs_host_cr4)) { vmcs_writel(HOST_CR4, cr4); vmx->host_state.vmcs_host_cr4 = cr4; } / When single-stepping over STI and MOV SS, we must clear the * corresponding interruptibility bits in the guest state. Otherwise * vmentry fails as it then expects bit 14 (BS) in pending debug * exceptions being set, but that's not correct for the guest debugging * case. / if (vcpu->guest_debug & KVM_GUESTDBG_SINGLESTEP) vmx_set_interrupt_shadow(vcpu, 0); atomic_switch_perf_msrs(vmx); debugctlmsr = get_debugctlmsr(); vmx->__launched = vmx->loaded_vmcs->launched; asm( / Store host registers / "push %%" _ASM_DX "; push %%" _ASM_BP ";" "push %%" _ASM_CX " \n\t" / placeholder for guest rcx / "push %%" _ASM_CX " \n\t" "cmp %%" _ASM_SP ", %c[host_rsp](%0) \n\t" "je 1f \n\t" "mov %%" _ASM_SP ", %c[host_rsp](%0) \n\t" __ex(ASM_VMX_VMWRITE_RSP_RDX) "\n\t" "1: \n\t" / Reload cr2 if changed / "mov %c[cr2](%0), %%" _ASM_AX " \n\t" "mov %%cr2, %%" _ASM_DX " \n\t" "cmp %%" _ASM_AX ", %%" _ASM_DX " \n\t" "je 2f \n\t" "mov %%" _ASM_AX", %%cr2 \n\t" "2: \n\t" / Check if vmlaunch of vmresume is needed / "cmpl $0, %c[launched](%0) \n\t" / Load guest registers. Don't clobber flags. / "mov %c[rax](%0), %%" _ASM_AX " \n\t" "mov %c[rbx](%0), %%" _ASM_BX " \n\t" "mov %c[rdx](%0), %%" _ASM_DX " \n\t" "mov %c[rsi](%0), %%" _ASM_SI " \n\t" "mov %c[rdi](%0), %%" _ASM_DI " \n\t" "mov %c[rbp](%0), %%" _ASM_BP " \n\t" #ifdef CONFIG_X86_64 "mov %c[r8](%0), %%r8 \n\t" "mov %c[r9](%0), %%r9 \n\t" "mov %c[r10](%0), %%r10 \n\t" "mov %c[r11](%0), %%r11 \n\t" "mov %c[r12](%0), %%r12 \n\t" "mov %c[r13](%0), %%r13 \n\t" "mov %c[r14](%0), %%r14 \n\t" "mov %c[r15](%0), %%r15 \n\t" #endif "mov %c[rcx](%0), %%" _ASM_CX " \n\t" / kills %0 (ecx) / / Enter guest mode / "jne 1f \n\t" __ex(ASM_VMX_VMLAUNCH) "\n\t" "jmp 2f \n\t" "1: " __ex(ASM_VMX_VMRESUME) "\n\t" "2: " / Save guest registers, load host registers, keep flags / "mov %0, %c[wordsize](%%" _ASM_SP ") \n\t" "pop %0 \n\t" "mov %%" _ASM_AX ", %c[rax](%0) \n\t" "mov %%" _ASM_BX ", %c[rbx](%0) \n\t" __ASM_SIZE(pop) " %c[rcx](%0) \n\t" "mov %%" _ASM_DX ", %c[rdx](%0) \n\t" "mov %%" _ASM_SI ", %c[rsi](%0) \n\t" "mov %%" _ASM_DI ", %c[rdi](%0) \n\t" "mov %%" _ASM_BP ", %c[rbp](%0) \n\t" #ifdef CONFIG_X86_64 "mov %%r8, %c[r8](%0) \n\t" "mov %%r9, %c[r9](%0) \n\t" "mov %%r10, %c[r10](%0) \n\t" "mov %%r11, %c[r11](%0) \n\t" "mov %%r12, %c[r12](%0) \n\t" "mov %%r13, %c[r13](%0) \n\t" "mov %%r14, %c[r14](%0) \n\t" "mov %%r15, %c[r15](%0) \n\t" #endif "mov %%cr2, %%" _ASM_AX " \n\t" "mov %%" _ASM_AX ", %c[cr2](%0) \n\t" "pop %%" _ASM_BP "; pop %%" _ASM_DX " \n\t" "setbe %c[fail](%0) \n\t" ".pushsection .rodata \n\t" ".global vmx_return \n\t" "vmx_return: " _ASM_PTR " 2b \n\t" ".popsection" : : "c"(vmx), "d"((unsigned long)HOST_RSP), [launched]"i"(offsetof(struct vcpu_vmx, __launched)), [fail]"i"(offsetof(struct vcpu_vmx, fail)), [host_rsp]"i"(offsetof(struct vcpu_vmx, host_rsp)), [rax]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RAX])), [rbx]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RBX])), [rcx]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RCX])), [rdx]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RDX])), [rsi]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RSI])), [rdi]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RDI])), [rbp]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RBP])), #ifdef CONFIG_X86_64 [r8]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R8])), [r9]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R9])), [r10]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R10])), [r11]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R11])), [r12]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R12])), [r13]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R13])), [r14]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R14])), [r15]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R15])), #endif [cr2]"i"(offsetof(struct vcpu_vmx, vcpu.arch.cr2)), [wordsize]"i"(sizeof(ulong)) : "cc", "memory" #ifdef CONFIG_X86_64 , "rax", "rbx", "rdi", "rsi" , "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15" #else , "eax", "ebx", "edi", "esi" #endif ); / MSR_IA32_DEBUGCTLMSR is zeroed on vmexit. Restore it if needed / if (debugctlmsr) update_debugctlmsr(debugctlmsr); #ifndef CONFIG_X86_64 / * The sysexit path does not restore ds/es, so we must set them to * a reasonable value ourselves. * * We can't defer this to vmx_load_host_state() since that function * may be executed in interrupt context, which saves and restore segments * around it, nullifying its effect. / loadsegment(ds, __USER_DS); loadsegment(es, __USER_DS); #endif vcpu->arch.regs_avail = ~((1 << VCPU_REGS_RIP) \| (1 << VCPU_REGS_RSP) \| (1 << VCPU_EXREG_RFLAGS) \| (1 << VCPU_EXREG_PDPTR) \| (1 << VCPU_EXREG_SEGMENTS) \| (1 << VCPU_EXREG_CR3)); vcpu->arch.regs_dirty = 0; vmx->idt_vectoring_info = vmcs_read32(IDT_VECTORING_INFO_FIELD); vmx->loaded_vmcs->launched = 1; vmx->exit_reason = vmcs_read32(VM_EXIT_REASON); trace_kvm_exit(vmx->exit_reason, vcpu, KVM_ISA_VMX); / * the KVM_REQ_EVENT optimization bit is only on for one entry, and if * we did not inject a still-pending event to L1 now because of * nested_run_pending, we need to re-enable this bit. / if (vmx->nested.nested_run_pending) kvm_make_request(KVM_REQ_EVENT, vcpu); vmx->nested.nested_run_pending = 0; vmx_complete_atomic_exit(vmx); vmx_recover_nmi_blocking(vmx); vmx_complete_interrupts(vmx); } static void vmx_load_vmcs01(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); int cpu; if (vmx->loaded_vmcs == &vmx->vmcs01) return; cpu = get_cpu(); vmx->loaded_vmcs = &vmx->vmcs01; vmx_vcpu_put(vcpu); vmx_vcpu_load(vcpu, cpu); vcpu->cpu = cpu; put_cpu(); } static void vmx_free_vcpu(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); free_vpid(vmx); leave_guest_mode(vcpu); vmx_load_vmcs01(vcpu); free_nested(vmx); free_loaded_vmcs(vmx->loaded_vmcs); kfree(vmx->guest_msrs); kvm_vcpu_uninit(vcpu); kmem_cache_free(kvm_vcpu_cache, vmx); } static struct kvm_vcpu vmx_create_vcpu(struct kvm kvm, unsigned int id) { int err; struct vcpu_vmx vmx = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL); int cpu; if (!vmx) return ERR_PTR(-ENOMEM); allocate_vpid(vmx); err = kvm_vcpu_init(&vmx->vcpu, kvm, id); if (err) goto free_vcpu; vmx->guest_msrs = kmalloc(PAGE_SIZE, GFP_KERNEL); BUILD_BUG_ON(ARRAY_SIZE(vmx_msr_index) * sizeof(vmx->guest_msrs[0]) > PAGE_SIZE); err = -ENOMEM; if (!vmx->guest_msrs) { goto uninit_vcpu; } vmx->loaded_vmcs = &vmx->vmcs01; vmx->loaded_vmcs->vmcs = alloc_vmcs(); if (!vmx->loaded_vmcs->vmcs) goto free_msrs; if (!vmm_exclusive) kvm_cpu_vmxon(__pa(per_cpu(vmxarea, raw_smp_processor_id()))); loaded_vmcs_init(vmx->loaded_vmcs); if (!vmm_exclusive) kvm_cpu_vmxoff(); cpu = get_cpu(); vmx_vcpu_load(&vmx->vcpu, cpu); vmx->vcpu.cpu = cpu; err = vmx_vcpu_setup(vmx); vmx_vcpu_put(&vmx->vcpu); put_cpu(); if (err) goto free_vmcs; if (vm_need_virtualize_apic_accesses(kvm)) { err = alloc_apic_access_page(kvm); if (err) goto free_vmcs; } if (enable_ept) { if (!kvm->arch.ept_identity_map_addr) kvm->arch.ept_identity_map_addr = VMX_EPT_IDENTITY_PAGETABLE_ADDR; err = init_rmode_identity_map(kvm); if (err) goto free_vmcs; } vmx->nested.current_vmptr = -1ull; vmx->nested.current_vmcs12 = NULL; return &vmx->vcpu; free_vmcs: free_loaded_vmcs(vmx->loaded_vmcs); free_msrs: kfree(vmx->guest_msrs); uninit_vcpu: kvm_vcpu_uninit(&vmx->vcpu); free_vcpu: free_vpid(vmx); kmem_cache_free(kvm_vcpu_cache, vmx); return ERR_PTR(err); } static void __init vmx_check_processor_compat(void rtn) { struct vmcs_config vmcs_conf; (int )rtn = 0; if (setup_vmcs_config(&vmcs_conf) < 0) (int )rtn = -EIO; if (memcmp(&vmcs_config, &vmcs_conf, sizeof(struct vmcs_config)) != 0) { printk(KERN_ERR "kvm: CPU %d feature inconsistency!\n", smp_processor_id()); (int )rtn = -EIO; } } static int get_ept_level(void) { return VMX_EPT_DEFAULT_GAW + 1; } static u64 vmx_get_mt_mask(struct kvm_vcpu vcpu, gfn_t gfn, bool is_mmio) { u64 ret; /* For VT-d and EPT combination * 1. MMIO: always map as UC * 2. EPT with VT-d: * a. VT-d without snooping control feature: can't guarantee the * result, try to trust guest. * b. VT-d with snooping control feature: snooping control feature of * VT-d engine can guarantee the cache correctness. Just set it * to WB to keep consistent with host. So the same as item 3. * 3. EPT without VT-d: always map as WB and set IPAT=1 to keep * consistent with host MTRR / if (is_mmio) ret = MTRR_TYPE_UNCACHABLE << VMX_EPT_MT_EPTE_SHIFT; else if (kvm_arch_has_noncoherent_dma(vcpu->kvm)) ret = kvm_get_guest_memory_type(vcpu, gfn) << VMX_EPT_MT_EPTE_SHIFT; else ret = (MTRR_TYPE_WRBACK << VMX_EPT_MT_EPTE_SHIFT) \| VMX_EPT_IPAT_BIT; return ret; } static int vmx_get_lpage_level(void) { if (enable_ept && !cpu_has_vmx_ept_1g_page()) return PT_DIRECTORY_LEVEL; else / For shadow and EPT supported 1GB page / return PT_PDPE_LEVEL; } static void vmx_cpuid_update(struct kvm_vcpu vcpu) { struct kvm_cpuid_entry2 best; struct vcpu_vmx vmx = to_vmx(vcpu); u32 exec_control; vmx->rdtscp_enabled = false; if (vmx_rdtscp_supported()) { exec_control = vmcs_read32(SECONDARY_VM_EXEC_CONTROL); if (exec_control & SECONDARY_EXEC_RDTSCP) { best = kvm_find_cpuid_entry(vcpu, 0x80000001, 0); if (best && (best->edx & bit(X86_FEATURE_RDTSCP))) vmx->rdtscp_enabled = true; else { exec_control &= ~SECONDARY_EXEC_RDTSCP; vmcs_write32(SECONDARY_VM_EXEC_CONTROL, exec_control); } } } /* Exposing INVPCID only when PCID is exposed / best = kvm_find_cpuid_entry(vcpu, 0x7, 0); if (vmx_invpcid_supported() && best && (best->ebx & bit(X86_FEATURE_INVPCID)) && guest_cpuid_has_pcid(vcpu)) { exec_control = vmcs_read32(SECONDARY_VM_EXEC_CONTROL); exec_control \|= SECONDARY_EXEC_ENABLE_INVPCID; vmcs_write32(SECONDARY_VM_EXEC_CONTROL, exec_control); } else { if (cpu_has_secondary_exec_ctrls()) { exec_control = vmcs_read32(SECONDARY_VM_EXEC_CONTROL); exec_control &= ~SECONDARY_EXEC_ENABLE_INVPCID; vmcs_write32(SECONDARY_VM_EXEC_CONTROL, exec_control); } if (best) best->ebx &= ~bit(X86_FEATURE_INVPCID); } } static void vmx_set_supported_cpuid(u32 func, struct kvm_cpuid_entry2 entry) { if (func == 1 && nested) entry->ecx \|= bit(X86_FEATURE_VMX); } static void nested_ept_inject_page_fault(struct kvm_vcpu vcpu, struct x86_exception fault) { struct vmcs12 vmcs12 = get_vmcs12(vcpu); u32 exit_reason; if (fault->error_code & PFERR_RSVD_MASK) exit_reason = EXIT_REASON_EPT_MISCONFIG; else exit_reason = EXIT_REASON_EPT_VIOLATION; nested_vmx_vmexit(vcpu, exit_reason, 0, vcpu->arch.exit_qualification); vmcs12->guest_physical_address = fault->address; } / Callbacks for nested_ept_init_mmu_context: / static unsigned long nested_ept_get_cr3(struct kvm_vcpu vcpu) { /* return the page table to be shadowed - in our case, EPT12 / return get_vmcs12(vcpu)->ept_pointer; } static void nested_ept_init_mmu_context(struct kvm_vcpu vcpu) { kvm_init_shadow_ept_mmu(vcpu, &vcpu->arch.mmu, nested_vmx_ept_caps & VMX_EPT_EXECUTE_ONLY_BIT); vcpu->arch.mmu.set_cr3 = vmx_set_cr3; vcpu->arch.mmu.get_cr3 = nested_ept_get_cr3; vcpu->arch.mmu.inject_page_fault = nested_ept_inject_page_fault; vcpu->arch.walk_mmu = &vcpu->arch.nested_mmu; } static void nested_ept_uninit_mmu_context(struct kvm_vcpu vcpu) { vcpu->arch.walk_mmu = &vcpu->arch.mmu; } static void vmx_inject_page_fault_nested(struct kvm_vcpu vcpu, struct x86_exception fault) { struct vmcs12 vmcs12 = get_vmcs12(vcpu); WARN_ON(!is_guest_mode(vcpu)); /* TODO: also check PFEC_MATCH/MASK, not just EB.PF. / if (vmcs12->exception_bitmap & (1u << PF_VECTOR)) nested_vmx_vmexit(vcpu, to_vmx(vcpu)->exit_reason, vmcs_read32(VM_EXIT_INTR_INFO), vmcs_readl(EXIT_QUALIFICATION)); else kvm_inject_page_fault(vcpu, fault); } static bool nested_get_vmcs12_pages(struct kvm_vcpu vcpu, struct vmcs12 vmcs12) { struct vcpu_vmx vmx = to_vmx(vcpu); if (nested_cpu_has2(vmcs12, SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES)) { /* TODO: Also verify bits beyond physical address width are 0 / if (!PAGE_ALIGNED(vmcs12->apic_access_addr)) return false; / * Translate L1 physical address to host physical * address for vmcs02. Keep the page pinned, so this * physical address remains valid. We keep a reference * to it so we can release it later. / if (vmx->nested.apic_access_page) / shouldn't happen / nested_release_page(vmx->nested.apic_access_page); vmx->nested.apic_access_page = nested_get_page(vcpu, vmcs12->apic_access_addr); } if (nested_cpu_has(vmcs12, CPU_BASED_TPR_SHADOW)) { / TODO: Also verify bits beyond physical address width are 0 / if (!PAGE_ALIGNED(vmcs12->virtual_apic_page_addr)) return false; if (vmx->nested.virtual_apic_page) / shouldn't happen / nested_release_page(vmx->nested.virtual_apic_page); vmx->nested.virtual_apic_page = nested_get_page(vcpu, vmcs12->virtual_apic_page_addr); / * Failing the vm entry is _not_ what the processor does * but it's basically the only possibility we have. * We could still enter the guest if CR8 load exits are * enabled, CR8 store exits are enabled, and virtualize APIC * access is disabled; in this case the processor would never * use the TPR shadow and we could simply clear the bit from * the execution control. But such a configuration is useless, * so let's keep the code simple. / if (!vmx->nested.virtual_apic_page) return false; } return true; } static void vmx_start_preemption_timer(struct kvm_vcpu vcpu) { u64 preemption_timeout = get_vmcs12(vcpu)->vmx_preemption_timer_value; struct vcpu_vmx vmx = to_vmx(vcpu); if (vcpu->arch.virtual_tsc_khz == 0) return; / Make sure short timeouts reliably trigger an immediate vmexit. * hrtimer_start does not guarantee this. / if (preemption_timeout <= 1) { vmx_preemption_timer_fn(&vmx->nested.preemption_timer); return; } preemption_timeout <<= VMX_MISC_EMULATED_PREEMPTION_TIMER_RATE; preemption_timeout = 1000000; do_div(preemption_timeout, vcpu->arch.virtual_tsc_khz); hrtimer_start(&vmx->nested.preemption_timer, ns_to_ktime(preemption_timeout), HRTIMER_MODE_REL); } /* * prepare_vmcs02 is called when the L1 guest hypervisor runs its nested * L2 guest. L1 has a vmcs for L2 (vmcs12), and this function "merges" it * with L0's requirements for its guest (a.k.a. vmcs01), so we can run the L2 * guest in a way that will both be appropriate to L1's requests, and our * needs. In addition to modifying the active vmcs (which is vmcs02), this * function also has additional necessary side-effects, like setting various * vcpu->arch fields. / static void prepare_vmcs02(struct kvm_vcpu vcpu, struct vmcs12 vmcs12) { struct vcpu_vmx vmx = to_vmx(vcpu); u32 exec_control; vmcs_write16(GUEST_ES_SELECTOR, vmcs12->guest_es_selector); vmcs_write16(GUEST_CS_SELECTOR, vmcs12->guest_cs_selector); vmcs_write16(GUEST_SS_SELECTOR, vmcs12->guest_ss_selector); vmcs_write16(GUEST_DS_SELECTOR, vmcs12->guest_ds_selector); vmcs_write16(GUEST_FS_SELECTOR, vmcs12->guest_fs_selector); vmcs_write16(GUEST_GS_SELECTOR, vmcs12->guest_gs_selector); vmcs_write16(GUEST_LDTR_SELECTOR, vmcs12->guest_ldtr_selector); vmcs_write16(GUEST_TR_SELECTOR, vmcs12->guest_tr_selector); vmcs_write32(GUEST_ES_LIMIT, vmcs12->guest_es_limit); vmcs_write32(GUEST_CS_LIMIT, vmcs12->guest_cs_limit); vmcs_write32(GUEST_SS_LIMIT, vmcs12->guest_ss_limit); vmcs_write32(GUEST_DS_LIMIT, vmcs12->guest_ds_limit); vmcs_write32(GUEST_FS_LIMIT, vmcs12->guest_fs_limit); vmcs_write32(GUEST_GS_LIMIT, vmcs12->guest_gs_limit); vmcs_write32(GUEST_LDTR_LIMIT, vmcs12->guest_ldtr_limit); vmcs_write32(GUEST_TR_LIMIT, vmcs12->guest_tr_limit); vmcs_write32(GUEST_GDTR_LIMIT, vmcs12->guest_gdtr_limit); vmcs_write32(GUEST_IDTR_LIMIT, vmcs12->guest_idtr_limit); vmcs_write32(GUEST_ES_AR_BYTES, vmcs12->guest_es_ar_bytes); vmcs_write32(GUEST_CS_AR_BYTES, vmcs12->guest_cs_ar_bytes); vmcs_write32(GUEST_SS_AR_BYTES, vmcs12->guest_ss_ar_bytes); vmcs_write32(GUEST_DS_AR_BYTES, vmcs12->guest_ds_ar_bytes); vmcs_write32(GUEST_FS_AR_BYTES, vmcs12->guest_fs_ar_bytes); vmcs_write32(GUEST_GS_AR_BYTES, vmcs12->guest_gs_ar_bytes); vmcs_write32(GUEST_LDTR_AR_BYTES, vmcs12->guest_ldtr_ar_bytes); vmcs_write32(GUEST_TR_AR_BYTES, vmcs12->guest_tr_ar_bytes); vmcs_writel(GUEST_ES_BASE, vmcs12->guest_es_base); vmcs_writel(GUEST_CS_BASE, vmcs12->guest_cs_base); vmcs_writel(GUEST_SS_BASE, vmcs12->guest_ss_base); vmcs_writel(GUEST_DS_BASE, vmcs12->guest_ds_base); vmcs_writel(GUEST_FS_BASE, vmcs12->guest_fs_base); vmcs_writel(GUEST_GS_BASE, vmcs12->guest_gs_base); vmcs_writel(GUEST_LDTR_BASE, vmcs12->guest_ldtr_base); vmcs_writel(GUEST_TR_BASE, vmcs12->guest_tr_base); vmcs_writel(GUEST_GDTR_BASE, vmcs12->guest_gdtr_base); vmcs_writel(GUEST_IDTR_BASE, vmcs12->guest_idtr_base); if (vmcs12->vm_entry_controls & VM_ENTRY_LOAD_DEBUG_CONTROLS) { kvm_set_dr(vcpu, 7, vmcs12->guest_dr7); vmcs_write64(GUEST_IA32_DEBUGCTL, vmcs12->guest_ia32_debugctl); } else { kvm_set_dr(vcpu, 7, vcpu->arch.dr7); vmcs_write64(GUEST_IA32_DEBUGCTL, vmx->nested.vmcs01_debugctl); } vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, vmcs12->vm_entry_intr_info_field); vmcs_write32(VM_ENTRY_EXCEPTION_ERROR_CODE, vmcs12->vm_entry_exception_error_code); vmcs_write32(VM_ENTRY_INSTRUCTION_LEN, vmcs12->vm_entry_instruction_len); vmcs_write32(GUEST_INTERRUPTIBILITY_INFO, vmcs12->guest_interruptibility_info); vmcs_write32(GUEST_SYSENTER_CS, vmcs12->guest_sysenter_cs); vmx_set_rflags(vcpu, vmcs12->guest_rflags); vmcs_writel(GUEST_PENDING_DBG_EXCEPTIONS, vmcs12->guest_pending_dbg_exceptions); vmcs_writel(GUEST_SYSENTER_ESP, vmcs12->guest_sysenter_esp); vmcs_writel(GUEST_SYSENTER_EIP, vmcs12->guest_sysenter_eip); vmcs_write64(VMCS_LINK_POINTER, -1ull); exec_control = vmcs12->pin_based_vm_exec_control; exec_control \|= vmcs_config.pin_based_exec_ctrl; exec_control &= ~(PIN_BASED_VMX_PREEMPTION_TIMER \| PIN_BASED_POSTED_INTR); vmcs_write32(PIN_BASED_VM_EXEC_CONTROL, exec_control); vmx->nested.preemption_timer_expired = false; if (nested_cpu_has_preemption_timer(vmcs12)) vmx_start_preemption_timer(vcpu); /* * Whether page-faults are trapped is determined by a combination of * 3 settings: PFEC_MASK, PFEC_MATCH and EXCEPTION_BITMAP.PF. * If enable_ept, L0 doesn't care about page faults and we should * set all of these to L1's desires. However, if !enable_ept, L0 does * care about (at least some) page faults, and because it is not easy * (if at all possible?) to merge L0 and L1's desires, we simply ask * to exit on each and every L2 page fault. This is done by setting * MASK=MATCH=0 and (see below) EB.PF=1. * Note that below we don't need special code to set EB.PF beyond the * "or"ing of the EB of vmcs01 and vmcs12, because when enable_ept, * vmcs01's EB.PF is 0 so the "or" will take vmcs12's value, and when * !enable_ept, EB.PF is 1, so the "or" will always be 1. * * A problem with this approach (when !enable_ept) is that L1 may be * injected with more page faults than it asked for. This could have * caused problems, but in practice existing hypervisors don't care. * To fix this, we will need to emulate the PFEC checking (on the L1 * page tables), using walk_addr(), when injecting PFs to L1. / vmcs_write32(PAGE_FAULT_ERROR_CODE_MASK, enable_ept ? vmcs12->page_fault_error_code_mask : 0); vmcs_write32(PAGE_FAULT_ERROR_CODE_MATCH, enable_ept ? vmcs12->page_fault_error_code_match : 0); if (cpu_has_secondary_exec_ctrls()) { exec_control = vmx_secondary_exec_control(vmx); if (!vmx->rdtscp_enabled) exec_control &= ~SECONDARY_EXEC_RDTSCP; / Take the following fields only from vmcs12 / exec_control &= ~(SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES \| SECONDARY_EXEC_VIRTUAL_INTR_DELIVERY \| SECONDARY_EXEC_APIC_REGISTER_VIRT); if (nested_cpu_has(vmcs12, CPU_BASED_ACTIVATE_SECONDARY_CONTROLS)) exec_control \|= vmcs12->secondary_vm_exec_control; if (exec_control & SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES) { / * If translation failed, no matter: This feature asks * to exit when accessing the given address, and if it * can never be accessed, this feature won't do * anything anyway. / if (!vmx->nested.apic_access_page) exec_control &= ~SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES; else vmcs_write64(APIC_ACCESS_ADDR, page_to_phys(vmx->nested.apic_access_page)); } else if (vm_need_virtualize_apic_accesses(vmx->vcpu.kvm)) { exec_control \|= SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES; kvm_vcpu_reload_apic_access_page(vcpu); } vmcs_write32(SECONDARY_VM_EXEC_CONTROL, exec_control); } / * Set host-state according to L0's settings (vmcs12 is irrelevant here) * Some constant fields are set here by vmx_set_constant_host_state(). * Other fields are different per CPU, and will be set later when * vmx_vcpu_load() is called, and when vmx_save_host_state() is called. / vmx_set_constant_host_state(vmx); / * HOST_RSP is normally set correctly in vmx_vcpu_run() just before * entry, but only if the current (host) sp changed from the value * we wrote last (vmx->host_rsp). This cache is no longer relevant * if we switch vmcs, and rather than hold a separate cache per vmcs, * here we just force the write to happen on entry. / vmx->host_rsp = 0; exec_control = vmx_exec_control(vmx); / L0's desires / exec_control &= ~CPU_BASED_VIRTUAL_INTR_PENDING; exec_control &= ~CPU_BASED_VIRTUAL_NMI_PENDING; exec_control &= ~CPU_BASED_TPR_SHADOW; exec_control \|= vmcs12->cpu_based_vm_exec_control; if (exec_control & CPU_BASED_TPR_SHADOW) { vmcs_write64(VIRTUAL_APIC_PAGE_ADDR, page_to_phys(vmx->nested.virtual_apic_page)); vmcs_write32(TPR_THRESHOLD, vmcs12->tpr_threshold); } / * Merging of IO and MSR bitmaps not currently supported. * Rather, exit every time. / exec_control &= ~CPU_BASED_USE_MSR_BITMAPS; exec_control &= ~CPU_BASED_USE_IO_BITMAPS; exec_control \|= CPU_BASED_UNCOND_IO_EXITING; vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, exec_control); / EXCEPTION_BITMAP and CR0_GUEST_HOST_MASK should basically be the * bitwise-or of what L1 wants to trap for L2, and what we want to * trap. Note that CR0.TS also needs updating - we do this later. / update_exception_bitmap(vcpu); vcpu->arch.cr0_guest_owned_bits &= ~vmcs12->cr0_guest_host_mask; vmcs_writel(CR0_GUEST_HOST_MASK, ~vcpu->arch.cr0_guest_owned_bits); / L2->L1 exit controls are emulated - the hardware exit is to L0 so * we should use its exit controls. Note that VM_EXIT_LOAD_IA32_EFER * bits are further modified by vmx_set_efer() below. / vmcs_write32(VM_EXIT_CONTROLS, vmcs_config.vmexit_ctrl); / vmcs12's VM_ENTRY_LOAD_IA32_EFER and VM_ENTRY_IA32E_MODE are * emulated by vmx_set_efer(), below. / vm_entry_controls_init(vmx, (vmcs12->vm_entry_controls & ~VM_ENTRY_LOAD_IA32_EFER & ~VM_ENTRY_IA32E_MODE) \| (vmcs_config.vmentry_ctrl & ~VM_ENTRY_IA32E_MODE)); if (vmcs12->vm_entry_controls & VM_ENTRY_LOAD_IA32_PAT) { vmcs_write64(GUEST_IA32_PAT, vmcs12->guest_ia32_pat); vcpu->arch.pat = vmcs12->guest_ia32_pat; } else if (vmcs_config.vmentry_ctrl & VM_ENTRY_LOAD_IA32_PAT) vmcs_write64(GUEST_IA32_PAT, vmx->vcpu.arch.pat); set_cr4_guest_host_mask(vmx); if (vmcs12->vm_entry_controls & VM_ENTRY_LOAD_BNDCFGS) vmcs_write64(GUEST_BNDCFGS, vmcs12->guest_bndcfgs); if (vmcs12->cpu_based_vm_exec_control & CPU_BASED_USE_TSC_OFFSETING) vmcs_write64(TSC_OFFSET, vmx->nested.vmcs01_tsc_offset + vmcs12->tsc_offset); else vmcs_write64(TSC_OFFSET, vmx->nested.vmcs01_tsc_offset); if (enable_vpid) { / * Trivially support vpid by letting L2s share their parent * L1's vpid. TODO: move to a more elaborate solution, giving * each L2 its own vpid and exposing the vpid feature to L1. / vmcs_write16(VIRTUAL_PROCESSOR_ID, vmx->vpid); vmx_flush_tlb(vcpu); } if (nested_cpu_has_ept(vmcs12)) { kvm_mmu_unload(vcpu); nested_ept_init_mmu_context(vcpu); } if (vmcs12->vm_entry_controls & VM_ENTRY_LOAD_IA32_EFER) vcpu->arch.efer = vmcs12->guest_ia32_efer; else if (vmcs12->vm_entry_controls & VM_ENTRY_IA32E_MODE) vcpu->arch.efer \|= (EFER_LMA \| EFER_LME); else vcpu->arch.efer &= ~(EFER_LMA \| EFER_LME); / Note: modifies VM_ENTRY/EXIT_CONTROLS and GUEST/HOST_IA32_EFER / vmx_set_efer(vcpu, vcpu->arch.efer); / * This sets GUEST_CR0 to vmcs12->guest_cr0, with possibly a modified * TS bit (for lazy fpu) and bits which we consider mandatory enabled. * The CR0_READ_SHADOW is what L2 should have expected to read given * the specifications by L1; It's not enough to take * vmcs12->cr0_read_shadow because on our cr0_guest_host_mask we we * have more bits than L1 expected. / vmx_set_cr0(vcpu, vmcs12->guest_cr0); vmcs_writel(CR0_READ_SHADOW, nested_read_cr0(vmcs12)); vmx_set_cr4(vcpu, vmcs12->guest_cr4); vmcs_writel(CR4_READ_SHADOW, nested_read_cr4(vmcs12)); / shadow page tables on either EPT or shadow page tables / kvm_set_cr3(vcpu, vmcs12->guest_cr3); kvm_mmu_reset_context(vcpu); if (!enable_ept) vcpu->arch.walk_mmu->inject_page_fault = vmx_inject_page_fault_nested; / * L1 may access the L2's PDPTR, so save them to construct vmcs12 / if (enable_ept) { vmcs_write64(GUEST_PDPTR0, vmcs12->guest_pdptr0); vmcs_write64(GUEST_PDPTR1, vmcs12->guest_pdptr1); vmcs_write64(GUEST_PDPTR2, vmcs12->guest_pdptr2); vmcs_write64(GUEST_PDPTR3, vmcs12->guest_pdptr3); } kvm_register_write(vcpu, VCPU_REGS_RSP, vmcs12->guest_rsp); kvm_register_write(vcpu, VCPU_REGS_RIP, vmcs12->guest_rip); } / * nested_vmx_run() handles a nested entry, i.e., a VMLAUNCH or VMRESUME on L1 * for running an L2 nested guest. / static int nested_vmx_run(struct kvm_vcpu vcpu, bool launch) { struct vmcs12 vmcs12; struct vcpu_vmx vmx = to_vmx(vcpu); int cpu; struct loaded_vmcs vmcs02; bool ia32e; if (!nested_vmx_check_permission(vcpu) \|\| !nested_vmx_check_vmcs12(vcpu)) return 1; skip_emulated_instruction(vcpu); vmcs12 = get_vmcs12(vcpu); if (enable_shadow_vmcs) copy_shadow_to_vmcs12(vmx); / * The nested entry process starts with enforcing various prerequisites * on vmcs12 as required by the Intel SDM, and act appropriately when * they fail: As the SDM explains, some conditions should cause the * instruction to fail, while others will cause the instruction to seem * to succeed, but return an EXIT_REASON_INVALID_STATE. * To speed up the normal (success) code path, we should avoid checking * for misconfigurations which will anyway be caught by the processor * when using the merged vmcs02. / if (vmcs12->launch_state == launch) { nested_vmx_failValid(vcpu, launch ? VMXERR_VMLAUNCH_NONCLEAR_VMCS : VMXERR_VMRESUME_NONLAUNCHED_VMCS); return 1; } if (vmcs12->guest_activity_state != GUEST_ACTIVITY_ACTIVE && vmcs12->guest_activity_state != GUEST_ACTIVITY_HLT) { nested_vmx_failValid(vcpu, VMXERR_ENTRY_INVALID_CONTROL_FIELD); return 1; } if ((vmcs12->cpu_based_vm_exec_control & CPU_BASED_USE_MSR_BITMAPS) && !PAGE_ALIGNED(vmcs12->msr_bitmap)) { /TODO: Also verify bits beyond physical address width are 0/ nested_vmx_failValid(vcpu, VMXERR_ENTRY_INVALID_CONTROL_FIELD); return 1; } if (!nested_get_vmcs12_pages(vcpu, vmcs12)) { /TODO: Also verify bits beyond physical address width are 0/ nested_vmx_failValid(vcpu, VMXERR_ENTRY_INVALID_CONTROL_FIELD); return 1; } if (vmcs12->vm_entry_msr_load_count > 0 \|\| vmcs12->vm_exit_msr_load_count > 0 \|\| vmcs12->vm_exit_msr_store_count > 0) { pr_warn_ratelimited("%s: VMCS MSR_{LOAD,STORE} unsupported\n", __func__); nested_vmx_failValid(vcpu, VMXERR_ENTRY_INVALID_CONTROL_FIELD); return 1; } if (!vmx_control_verify(vmcs12->cpu_based_vm_exec_control, nested_vmx_true_procbased_ctls_low, nested_vmx_procbased_ctls_high) \|\| !vmx_control_verify(vmcs12->secondary_vm_exec_control, nested_vmx_secondary_ctls_low, nested_vmx_secondary_ctls_high) \|\| !vmx_control_verify(vmcs12->pin_based_vm_exec_control, nested_vmx_pinbased_ctls_low, nested_vmx_pinbased_ctls_high) \|\| !vmx_control_verify(vmcs12->vm_exit_controls, nested_vmx_true_exit_ctls_low, nested_vmx_exit_ctls_high) \|\| !vmx_control_verify(vmcs12->vm_entry_controls, nested_vmx_true_entry_ctls_low, nested_vmx_entry_ctls_high)) { nested_vmx_failValid(vcpu, VMXERR_ENTRY_INVALID_CONTROL_FIELD); return 1; } if (((vmcs12->host_cr0 & VMXON_CR0_ALWAYSON) != VMXON_CR0_ALWAYSON) \|\| ((vmcs12->host_cr4 & VMXON_CR4_ALWAYSON) != VMXON_CR4_ALWAYSON)) { nested_vmx_failValid(vcpu, VMXERR_ENTRY_INVALID_HOST_STATE_FIELD); return 1; } if (!nested_cr0_valid(vmcs12, vmcs12->guest_cr0) \|\| ((vmcs12->guest_cr4 & VMXON_CR4_ALWAYSON) != VMXON_CR4_ALWAYSON)) { nested_vmx_entry_failure(vcpu, vmcs12, EXIT_REASON_INVALID_STATE, ENTRY_FAIL_DEFAULT); return 1; } if (vmcs12->vmcs_link_pointer != -1ull) { nested_vmx_entry_failure(vcpu, vmcs12, EXIT_REASON_INVALID_STATE, ENTRY_FAIL_VMCS_LINK_PTR); return 1; } / * If the load IA32_EFER VM-entry control is 1, the following checks * are performed on the field for the IA32_EFER MSR: * - Bits reserved in the IA32_EFER MSR must be 0. * - Bit 10 (corresponding to IA32_EFER.LMA) must equal the value of * the IA-32e mode guest VM-exit control. It must also be identical * to bit 8 (LME) if bit 31 in the CR0 field (corresponding to * CR0.PG) is 1. / if (vmcs12->vm_entry_controls & VM_ENTRY_LOAD_IA32_EFER) { ia32e = (vmcs12->vm_entry_controls & VM_ENTRY_IA32E_MODE) != 0; if (!kvm_valid_efer(vcpu, vmcs12->guest_ia32_efer) \|\| ia32e != !!(vmcs12->guest_ia32_efer & EFER_LMA) \|\| ((vmcs12->guest_cr0 & X86_CR0_PG) && ia32e != !!(vmcs12->guest_ia32_efer & EFER_LME))) { nested_vmx_entry_failure(vcpu, vmcs12, EXIT_REASON_INVALID_STATE, ENTRY_FAIL_DEFAULT); return 1; } } / * If the load IA32_EFER VM-exit control is 1, bits reserved in the * IA32_EFER MSR must be 0 in the field for that register. In addition, * the values of the LMA and LME bits in the field must each be that of * the host address-space size VM-exit control. / if (vmcs12->vm_exit_controls & VM_EXIT_LOAD_IA32_EFER) { ia32e = (vmcs12->vm_exit_controls & VM_EXIT_HOST_ADDR_SPACE_SIZE) != 0; if (!kvm_valid_efer(vcpu, vmcs12->host_ia32_efer) \|\| ia32e != !!(vmcs12->host_ia32_efer & EFER_LMA) \|\| ia32e != !!(vmcs12->host_ia32_efer & EFER_LME)) { nested_vmx_entry_failure(vcpu, vmcs12, EXIT_REASON_INVALID_STATE, ENTRY_FAIL_DEFAULT); return 1; } } / * We're finally done with prerequisite checking, and can start with * the nested entry. / vmcs02 = nested_get_current_vmcs02(vmx); if (!vmcs02) return -ENOMEM; enter_guest_mode(vcpu); vmx->nested.vmcs01_tsc_offset = vmcs_read64(TSC_OFFSET); if (!(vmcs12->vm_entry_controls & VM_ENTRY_LOAD_DEBUG_CONTROLS)) vmx->nested.vmcs01_debugctl = vmcs_read64(GUEST_IA32_DEBUGCTL); cpu = get_cpu(); vmx->loaded_vmcs = vmcs02; vmx_vcpu_put(vcpu); vmx_vcpu_load(vcpu, cpu); vcpu->cpu = cpu; put_cpu(); vmx_segment_cache_clear(vmx); vmcs12->launch_state = 1; prepare_vmcs02(vcpu, vmcs12); if (vmcs12->guest_activity_state == GUEST_ACTIVITY_HLT) return kvm_emulate_halt(vcpu); vmx->nested.nested_run_pending = 1; / * Note no nested_vmx_succeed or nested_vmx_fail here. At this point * we are no longer running L1, and VMLAUNCH/VMRESUME has not yet * returned as far as L1 is concerned. It will only return (and set * the success flag) when L2 exits (see nested_vmx_vmexit()). / return 1; } / * On a nested exit from L2 to L1, vmcs12.guest_cr0 might not be up-to-date * because L2 may have changed some cr0 bits directly (CRO_GUEST_HOST_MASK). * This function returns the new value we should put in vmcs12.guest_cr0. * It's not enough to just return the vmcs02 GUEST_CR0. Rather, * 1. Bits that neither L0 nor L1 trapped, were set directly by L2 and are now * available in vmcs02 GUEST_CR0. (Note: It's enough to check that L0 * didn't trap the bit, because if L1 did, so would L0). * 2. Bits that L1 asked to trap (and therefore L0 also did) could not have * been modified by L2, and L1 knows it. So just leave the old value of * the bit from vmcs12.guest_cr0. Note that the bit from vmcs02 GUEST_CR0 * isn't relevant, because if L0 traps this bit it can set it to anything. * 3. Bits that L1 didn't trap, but L0 did. L1 believes the guest could have * changed these bits, and therefore they need to be updated, but L0 * didn't necessarily allow them to be changed in GUEST_CR0 - and rather * put them in vmcs02 CR0_READ_SHADOW. So take these bits from there. / static inline unsigned long vmcs12_guest_cr0(struct kvm_vcpu vcpu, struct vmcs12 vmcs12) { return /1/ (vmcs_readl(GUEST_CR0) & vcpu->arch.cr0_guest_owned_bits) \| /2/ (vmcs12->guest_cr0 & vmcs12->cr0_guest_host_mask) \| /3/ (vmcs_readl(CR0_READ_SHADOW) & ~(vmcs12->cr0_guest_host_mask \| vcpu->arch.cr0_guest_owned_bits)); } static inline unsigned long vmcs12_guest_cr4(struct kvm_vcpu vcpu, struct vmcs12 vmcs12) { return /1/ (vmcs_readl(GUEST_CR4) & vcpu->arch.cr4_guest_owned_bits) \| /2/ (vmcs12->guest_cr4 & vmcs12->cr4_guest_host_mask) \| /3/ (vmcs_readl(CR4_READ_SHADOW) & ~(vmcs12->cr4_guest_host_mask \| vcpu->arch.cr4_guest_owned_bits)); } static void vmcs12_save_pending_event(struct kvm_vcpu vcpu, struct vmcs12 vmcs12) { u32 idt_vectoring; unsigned int nr; if (vcpu->arch.exception.pending && vcpu->arch.exception.reinject) { nr = vcpu->arch.exception.nr; idt_vectoring = nr \| VECTORING_INFO_VALID_MASK; if (kvm_exception_is_soft(nr)) { vmcs12->vm_exit_instruction_len = vcpu->arch.event_exit_inst_len; idt_vectoring \|= INTR_TYPE_SOFT_EXCEPTION; } else idt_vectoring \|= INTR_TYPE_HARD_EXCEPTION; if (vcpu->arch.exception.has_error_code) { idt_vectoring \|= VECTORING_INFO_DELIVER_CODE_MASK; vmcs12->idt_vectoring_error_code = vcpu->arch.exception.error_code; } vmcs12->idt_vectoring_info_field = idt_vectoring; } else if (vcpu->arch.nmi_injected) { vmcs12->idt_vectoring_info_field = INTR_TYPE_NMI_INTR \| INTR_INFO_VALID_MASK \| NMI_VECTOR; } else if (vcpu->arch.interrupt.pending) { nr = vcpu->arch.interrupt.nr; idt_vectoring = nr \| VECTORING_INFO_VALID_MASK; if (vcpu->arch.interrupt.soft) { idt_vectoring \|= INTR_TYPE_SOFT_INTR; vmcs12->vm_entry_instruction_len = vcpu->arch.event_exit_inst_len; } else idt_vectoring \|= INTR_TYPE_EXT_INTR; vmcs12->idt_vectoring_info_field = idt_vectoring; } } static int vmx_check_nested_events(struct kvm_vcpu vcpu, bool external_intr) { struct vcpu_vmx vmx = to_vmx(vcpu); if (nested_cpu_has_preemption_timer(get_vmcs12(vcpu)) && vmx->nested.preemption_timer_expired) { if (vmx->nested.nested_run_pending) return -EBUSY; nested_vmx_vmexit(vcpu, EXIT_REASON_PREEMPTION_TIMER, 0, 0); return 0; } if (vcpu->arch.nmi_pending && nested_exit_on_nmi(vcpu)) { if (vmx->nested.nested_run_pending \|\| vcpu->arch.interrupt.pending) return -EBUSY; nested_vmx_vmexit(vcpu, EXIT_REASON_EXCEPTION_NMI, NMI_VECTOR \| INTR_TYPE_NMI_INTR \| INTR_INFO_VALID_MASK, 0); / * The NMI-triggered VM exit counts as injection: * clear this one and block further NMIs. / vcpu->arch.nmi_pending = 0; vmx_set_nmi_mask(vcpu, true); return 0; } if ((kvm_cpu_has_interrupt(vcpu) \|\| external_intr) && nested_exit_on_intr(vcpu)) { if (vmx->nested.nested_run_pending) return -EBUSY; nested_vmx_vmexit(vcpu, EXIT_REASON_EXTERNAL_INTERRUPT, 0, 0); } return 0; } static u32 vmx_get_preemption_timer_value(struct kvm_vcpu vcpu) { ktime_t remaining = hrtimer_get_remaining(&to_vmx(vcpu)->nested.preemption_timer); u64 value; if (ktime_to_ns(remaining) <= 0) return 0; value = ktime_to_ns(remaining) * vcpu->arch.virtual_tsc_khz; do_div(value, 1000000); return value >> VMX_MISC_EMULATED_PREEMPTION_TIMER_RATE; } /* * prepare_vmcs12 is part of what we need to do when the nested L2 guest exits * and we want to prepare to run its L1 parent. L1 keeps a vmcs for L2 (vmcs12), * and this function updates it to reflect the changes to the guest state while * L2 was running (and perhaps made some exits which were handled directly by L0 * without going back to L1), and to reflect the exit reason. * Note that we do not have to copy here all VMCS fields, just those that * could have changed by the L2 guest or the exit - i.e., the guest-state and * exit-information fields only. Other fields are modified by L1 with VMWRITE, * which already writes to vmcs12 directly. / static void prepare_vmcs12(struct kvm_vcpu vcpu, struct vmcs12 vmcs12, u32 exit_reason, u32 exit_intr_info, unsigned long exit_qualification) { / update guest state fields: / vmcs12->guest_cr0 = vmcs12_guest_cr0(vcpu, vmcs12); vmcs12->guest_cr4 = vmcs12_guest_cr4(vcpu, vmcs12); vmcs12->guest_rsp = kvm_register_read(vcpu, VCPU_REGS_RSP); vmcs12->guest_rip = kvm_register_read(vcpu, VCPU_REGS_RIP); vmcs12->guest_rflags = vmcs_readl(GUEST_RFLAGS); vmcs12->guest_es_selector = vmcs_read16(GUEST_ES_SELECTOR); vmcs12->guest_cs_selector = vmcs_read16(GUEST_CS_SELECTOR); vmcs12->guest_ss_selector = vmcs_read16(GUEST_SS_SELECTOR); vmcs12->guest_ds_selector = vmcs_read16(GUEST_DS_SELECTOR); vmcs12->guest_fs_selector = vmcs_read16(GUEST_FS_SELECTOR); vmcs12->guest_gs_selector = vmcs_read16(GUEST_GS_SELECTOR); vmcs12->guest_ldtr_selector = vmcs_read16(GUEST_LDTR_SELECTOR); vmcs12->guest_tr_selector = vmcs_read16(GUEST_TR_SELECTOR); vmcs12->guest_es_limit = vmcs_read32(GUEST_ES_LIMIT); vmcs12->guest_cs_limit = vmcs_read32(GUEST_CS_LIMIT); vmcs12->guest_ss_limit = vmcs_read32(GUEST_SS_LIMIT); vmcs12->guest_ds_limit = vmcs_read32(GUEST_DS_LIMIT); vmcs12->guest_fs_limit = vmcs_read32(GUEST_FS_LIMIT); vmcs12->guest_gs_limit = vmcs_read32(GUEST_GS_LIMIT); vmcs12->guest_ldtr_limit = vmcs_read32(GUEST_LDTR_LIMIT); vmcs12->guest_tr_limit = vmcs_read32(GUEST_TR_LIMIT); vmcs12->guest_gdtr_limit = vmcs_read32(GUEST_GDTR_LIMIT); vmcs12->guest_idtr_limit = vmcs_read32(GUEST_IDTR_LIMIT); vmcs12->guest_es_ar_bytes = vmcs_read32(GUEST_ES_AR_BYTES); vmcs12->guest_cs_ar_bytes = vmcs_read32(GUEST_CS_AR_BYTES); vmcs12->guest_ss_ar_bytes = vmcs_read32(GUEST_SS_AR_BYTES); vmcs12->guest_ds_ar_bytes = vmcs_read32(GUEST_DS_AR_BYTES); vmcs12->guest_fs_ar_bytes = vmcs_read32(GUEST_FS_AR_BYTES); vmcs12->guest_gs_ar_bytes = vmcs_read32(GUEST_GS_AR_BYTES); vmcs12->guest_ldtr_ar_bytes = vmcs_read32(GUEST_LDTR_AR_BYTES); vmcs12->guest_tr_ar_bytes = vmcs_read32(GUEST_TR_AR_BYTES); vmcs12->guest_es_base = vmcs_readl(GUEST_ES_BASE); vmcs12->guest_cs_base = vmcs_readl(GUEST_CS_BASE); vmcs12->guest_ss_base = vmcs_readl(GUEST_SS_BASE); vmcs12->guest_ds_base = vmcs_readl(GUEST_DS_BASE); vmcs12->guest_fs_base = vmcs_readl(GUEST_FS_BASE); vmcs12->guest_gs_base = vmcs_readl(GUEST_GS_BASE); vmcs12->guest_ldtr_base = vmcs_readl(GUEST_LDTR_BASE); vmcs12->guest_tr_base = vmcs_readl(GUEST_TR_BASE); vmcs12->guest_gdtr_base = vmcs_readl(GUEST_GDTR_BASE); vmcs12->guest_idtr_base = vmcs_readl(GUEST_IDTR_BASE); vmcs12->guest_interruptibility_info = vmcs_read32(GUEST_INTERRUPTIBILITY_INFO); vmcs12->guest_pending_dbg_exceptions = vmcs_readl(GUEST_PENDING_DBG_EXCEPTIONS); if (vcpu->arch.mp_state == KVM_MP_STATE_HALTED) vmcs12->guest_activity_state = GUEST_ACTIVITY_HLT; else vmcs12->guest_activity_state = GUEST_ACTIVITY_ACTIVE; if (nested_cpu_has_preemption_timer(vmcs12)) { if (vmcs12->vm_exit_controls & VM_EXIT_SAVE_VMX_PREEMPTION_TIMER) vmcs12->vmx_preemption_timer_value = vmx_get_preemption_timer_value(vcpu); hrtimer_cancel(&to_vmx(vcpu)->nested.preemption_timer); } / * In some cases (usually, nested EPT), L2 is allowed to change its * own CR3 without exiting. If it has changed it, we must keep it. * Of course, if L0 is using shadow page tables, GUEST_CR3 was defined * by L0, not L1 or L2, so we mustn't unconditionally copy it to vmcs12. * * Additionally, restore L2's PDPTR to vmcs12. / if (enable_ept) { vmcs12->guest_cr3 = vmcs_read64(GUEST_CR3); vmcs12->guest_pdptr0 = vmcs_read64(GUEST_PDPTR0); vmcs12->guest_pdptr1 = vmcs_read64(GUEST_PDPTR1); vmcs12->guest_pdptr2 = vmcs_read64(GUEST_PDPTR2); vmcs12->guest_pdptr3 = vmcs_read64(GUEST_PDPTR3); } vmcs12->vm_entry_controls = (vmcs12->vm_entry_controls & ~VM_ENTRY_IA32E_MODE) \| (vm_entry_controls_get(to_vmx(vcpu)) & VM_ENTRY_IA32E_MODE); if (vmcs12->vm_exit_controls & VM_EXIT_SAVE_DEBUG_CONTROLS) { kvm_get_dr(vcpu, 7, (unsigned long )&vmcs12->guest_dr7); vmcs12->guest_ia32_debugctl = vmcs_read64(GUEST_IA32_DEBUGCTL); } /* TODO: These cannot have changed unless we have MSR bitmaps and * the relevant bit asks not to trap the change / if (vmcs12->vm_exit_controls & VM_EXIT_SAVE_IA32_PAT) vmcs12->guest_ia32_pat = vmcs_read64(GUEST_IA32_PAT); if (vmcs12->vm_exit_controls & VM_EXIT_SAVE_IA32_EFER) vmcs12->guest_ia32_efer = vcpu->arch.efer; vmcs12->guest_sysenter_cs = vmcs_read32(GUEST_SYSENTER_CS); vmcs12->guest_sysenter_esp = vmcs_readl(GUEST_SYSENTER_ESP); vmcs12->guest_sysenter_eip = vmcs_readl(GUEST_SYSENTER_EIP); if (vmx_mpx_supported()) vmcs12->guest_bndcfgs = vmcs_read64(GUEST_BNDCFGS); / update exit information fields: / vmcs12->vm_exit_reason = exit_reason; vmcs12->exit_qualification = exit_qualification; vmcs12->vm_exit_intr_info = exit_intr_info; if ((vmcs12->vm_exit_intr_info & (INTR_INFO_VALID_MASK \| INTR_INFO_DELIVER_CODE_MASK)) == (INTR_INFO_VALID_MASK \| INTR_INFO_DELIVER_CODE_MASK)) vmcs12->vm_exit_intr_error_code = vmcs_read32(VM_EXIT_INTR_ERROR_CODE); vmcs12->idt_vectoring_info_field = 0; vmcs12->vm_exit_instruction_len = vmcs_read32(VM_EXIT_INSTRUCTION_LEN); vmcs12->vmx_instruction_info = vmcs_read32(VMX_INSTRUCTION_INFO); if (!(vmcs12->vm_exit_reason & VMX_EXIT_REASONS_FAILED_VMENTRY)) { / vm_entry_intr_info_field is cleared on exit. Emulate this * instead of reading the real value. / vmcs12->vm_entry_intr_info_field &= ~INTR_INFO_VALID_MASK; / * Transfer the event that L0 or L1 may wanted to inject into * L2 to IDT_VECTORING_INFO_FIELD. / vmcs12_save_pending_event(vcpu, vmcs12); } / * Drop what we picked up for L2 via vmx_complete_interrupts. It is * preserved above and would only end up incorrectly in L1. / vcpu->arch.nmi_injected = false; kvm_clear_exception_queue(vcpu); kvm_clear_interrupt_queue(vcpu); } / * A part of what we need to when the nested L2 guest exits and we want to * run its L1 parent, is to reset L1's guest state to the host state specified * in vmcs12. * This function is to be called not only on normal nested exit, but also on * a nested entry failure, as explained in Intel's spec, 3B.23.7 ("VM-Entry * Failures During or After Loading Guest State"). * This function should be called when the active VMCS is L1's (vmcs01). / static void load_vmcs12_host_state(struct kvm_vcpu vcpu, struct vmcs12 vmcs12) { struct kvm_segment seg; if (vmcs12->vm_exit_controls & VM_EXIT_LOAD_IA32_EFER) vcpu->arch.efer = vmcs12->host_ia32_efer; else if (vmcs12->vm_exit_controls & VM_EXIT_HOST_ADDR_SPACE_SIZE) vcpu->arch.efer \|= (EFER_LMA \| EFER_LME); else vcpu->arch.efer &= ~(EFER_LMA \| EFER_LME); vmx_set_efer(vcpu, vcpu->arch.efer); kvm_register_write(vcpu, VCPU_REGS_RSP, vmcs12->host_rsp); kvm_register_write(vcpu, VCPU_REGS_RIP, vmcs12->host_rip); vmx_set_rflags(vcpu, X86_EFLAGS_FIXED); / * Note that calling vmx_set_cr0 is important, even if cr0 hasn't * actually changed, because it depends on the current state of * fpu_active (which may have changed). * Note that vmx_set_cr0 refers to efer set above. / vmx_set_cr0(vcpu, vmcs12->host_cr0); / * If we did fpu_activate()/fpu_deactivate() during L2's run, we need * to apply the same changes to L1's vmcs. We just set cr0 correctly, * but we also need to update cr0_guest_host_mask and exception_bitmap. / update_exception_bitmap(vcpu); vcpu->arch.cr0_guest_owned_bits = (vcpu->fpu_active ? X86_CR0_TS : 0); vmcs_writel(CR0_GUEST_HOST_MASK, ~vcpu->arch.cr0_guest_owned_bits); / * Note that CR4_GUEST_HOST_MASK is already set in the original vmcs01 * (KVM doesn't change it)- no reason to call set_cr4_guest_host_mask(); / vcpu->arch.cr4_guest_owned_bits = ~vmcs_readl(CR4_GUEST_HOST_MASK); kvm_set_cr4(vcpu, vmcs12->host_cr4); nested_ept_uninit_mmu_context(vcpu); kvm_set_cr3(vcpu, vmcs12->host_cr3); kvm_mmu_reset_context(vcpu); if (!enable_ept) vcpu->arch.walk_mmu->inject_page_fault = kvm_inject_page_fault; if (enable_vpid) { / * Trivially support vpid by letting L2s share their parent * L1's vpid. TODO: move to a more elaborate solution, giving * each L2 its own vpid and exposing the vpid feature to L1. / vmx_flush_tlb(vcpu); } vmcs_write32(GUEST_SYSENTER_CS, vmcs12->host_ia32_sysenter_cs); vmcs_writel(GUEST_SYSENTER_ESP, vmcs12->host_ia32_sysenter_esp); vmcs_writel(GUEST_SYSENTER_EIP, vmcs12->host_ia32_sysenter_eip); vmcs_writel(GUEST_IDTR_BASE, vmcs12->host_idtr_base); vmcs_writel(GUEST_GDTR_BASE, vmcs12->host_gdtr_base); / If not VM_EXIT_CLEAR_BNDCFGS, the L2 value propagates to L1. / if (vmcs12->vm_exit_controls & VM_EXIT_CLEAR_BNDCFGS) vmcs_write64(GUEST_BNDCFGS, 0); if (vmcs12->vm_exit_controls & VM_EXIT_LOAD_IA32_PAT) { vmcs_write64(GUEST_IA32_PAT, vmcs12->host_ia32_pat); vcpu->arch.pat = vmcs12->host_ia32_pat; } if (vmcs12->vm_exit_controls & VM_EXIT_LOAD_IA32_PERF_GLOBAL_CTRL) vmcs_write64(GUEST_IA32_PERF_GLOBAL_CTRL, vmcs12->host_ia32_perf_global_ctrl); / Set L1 segment info according to Intel SDM 27.5.2 Loading Host Segment and Descriptor-Table Registers / seg = (struct kvm_segment) { .base = 0, .limit = 0xFFFFFFFF, .selector = vmcs12->host_cs_selector, .type = 11, .present = 1, .s = 1, .g = 1 }; if (vmcs12->vm_exit_controls & VM_EXIT_HOST_ADDR_SPACE_SIZE) seg.l = 1; else seg.db = 1; vmx_set_segment(vcpu, &seg, VCPU_SREG_CS); seg = (struct kvm_segment) { .base = 0, .limit = 0xFFFFFFFF, .type = 3, .present = 1, .s = 1, .db = 1, .g = 1 }; seg.selector = vmcs12->host_ds_selector; vmx_set_segment(vcpu, &seg, VCPU_SREG_DS); seg.selector = vmcs12->host_es_selector; vmx_set_segment(vcpu, &seg, VCPU_SREG_ES); seg.selector = vmcs12->host_ss_selector; vmx_set_segment(vcpu, &seg, VCPU_SREG_SS); seg.selector = vmcs12->host_fs_selector; seg.base = vmcs12->host_fs_base; vmx_set_segment(vcpu, &seg, VCPU_SREG_FS); seg.selector = vmcs12->host_gs_selector; seg.base = vmcs12->host_gs_base; vmx_set_segment(vcpu, &seg, VCPU_SREG_GS); seg = (struct kvm_segment) { .base = vmcs12->host_tr_base, .limit = 0x67, .selector = vmcs12->host_tr_selector, .type = 11, .present = 1 }; vmx_set_segment(vcpu, &seg, VCPU_SREG_TR); kvm_set_dr(vcpu, 7, 0x400); vmcs_write64(GUEST_IA32_DEBUGCTL, 0); } / * Emulate an exit from nested guest (L2) to L1, i.e., prepare to run L1 * and modify vmcs12 to make it see what it would expect to see there if * L2 was its real guest. Must only be called when in L2 (is_guest_mode()) / static void nested_vmx_vmexit(struct kvm_vcpu vcpu, u32 exit_reason, u32 exit_intr_info, unsigned long exit_qualification) { struct vcpu_vmx vmx = to_vmx(vcpu); struct vmcs12 vmcs12 = get_vmcs12(vcpu); /* trying to cancel vmlaunch/vmresume is a bug / WARN_ON_ONCE(vmx->nested.nested_run_pending); leave_guest_mode(vcpu); prepare_vmcs12(vcpu, vmcs12, exit_reason, exit_intr_info, exit_qualification); vmx_load_vmcs01(vcpu); if ((exit_reason == EXIT_REASON_EXTERNAL_INTERRUPT) && nested_exit_intr_ack_set(vcpu)) { int irq = kvm_cpu_get_interrupt(vcpu); WARN_ON(irq < 0); vmcs12->vm_exit_intr_info = irq \| INTR_INFO_VALID_MASK \| INTR_TYPE_EXT_INTR; } trace_kvm_nested_vmexit_inject(vmcs12->vm_exit_reason, vmcs12->exit_qualification, vmcs12->idt_vectoring_info_field, vmcs12->vm_exit_intr_info, vmcs12->vm_exit_intr_error_code, KVM_ISA_VMX); vm_entry_controls_init(vmx, vmcs_read32(VM_ENTRY_CONTROLS)); vm_exit_controls_init(vmx, vmcs_read32(VM_EXIT_CONTROLS)); vmx_segment_cache_clear(vmx); / if no vmcs02 cache requested, remove the one we used / if (VMCS02_POOL_SIZE == 0) nested_free_vmcs02(vmx, vmx->nested.current_vmptr); load_vmcs12_host_state(vcpu, vmcs12); / Update TSC_OFFSET if TSC was changed while L2 ran / vmcs_write64(TSC_OFFSET, vmx->nested.vmcs01_tsc_offset); / This is needed for same reason as it was needed in prepare_vmcs02 / vmx->host_rsp = 0; / Unpin physical memory we referred to in vmcs02 / if (vmx->nested.apic_access_page) { nested_release_page(vmx->nested.apic_access_page); vmx->nested.apic_access_page = NULL; } if (vmx->nested.virtual_apic_page) { nested_release_page(vmx->nested.virtual_apic_page); vmx->nested.virtual_apic_page = NULL; } / * We are now running in L2, mmu_notifier will force to reload the * page's hpa for L2 vmcs. Need to reload it for L1 before entering L1. / kvm_vcpu_reload_apic_access_page(vcpu); / * Exiting from L2 to L1, we're now back to L1 which thinks it just * finished a VMLAUNCH or VMRESUME instruction, so we need to set the * success or failure flag accordingly. / if (unlikely(vmx->fail)) { vmx->fail = 0; nested_vmx_failValid(vcpu, vmcs_read32(VM_INSTRUCTION_ERROR)); } else nested_vmx_succeed(vcpu); if (enable_shadow_vmcs) vmx->nested.sync_shadow_vmcs = true; / in case we halted in L2 / vcpu->arch.mp_state = KVM_MP_STATE_RUNNABLE; } / * Forcibly leave nested mode in order to be able to reset the VCPU later on. / static void vmx_leave_nested(struct kvm_vcpu vcpu) { if (is_guest_mode(vcpu)) nested_vmx_vmexit(vcpu, -1, 0, 0); free_nested(to_vmx(vcpu)); } /* * L1's failure to enter L2 is a subset of a normal exit, as explained in * 23.7 "VM-entry failures during or after loading guest state" (this also * lists the acceptable exit-reason and exit-qualification parameters). * It should only be called before L2 actually succeeded to run, and when * vmcs01 is current (it doesn't leave_guest_mode() or switch vmcss). / static void nested_vmx_entry_failure(struct kvm_vcpu vcpu, struct vmcs12 vmcs12, u32 reason, unsigned long qualification) { load_vmcs12_host_state(vcpu, vmcs12); vmcs12->vm_exit_reason = reason \| VMX_EXIT_REASONS_FAILED_VMENTRY; vmcs12->exit_qualification = qualification; nested_vmx_succeed(vcpu); if (enable_shadow_vmcs) to_vmx(vcpu)->nested.sync_shadow_vmcs = true; } static int vmx_check_intercept(struct kvm_vcpu vcpu, struct x86_instruction_info info, enum x86_intercept_stage stage) { return X86EMUL_CONTINUE; } static void vmx_sched_in(struct kvm_vcpu vcpu, int cpu) { if (ple_gap) shrink_ple_window(vcpu); } static struct kvm_x86_ops vmx_x86_ops = { .cpu_has_kvm_support = cpu_has_kvm_support, .disabled_by_bios = vmx_disabled_by_bios, .hardware_setup = hardware_setup, .hardware_unsetup = hardware_unsetup, .check_processor_compatibility = vmx_check_processor_compat, .hardware_enable = hardware_enable, .hardware_disable = hardware_disable, .cpu_has_accelerated_tpr = report_flexpriority, .vcpu_create = vmx_create_vcpu, .vcpu_free = vmx_free_vcpu, .vcpu_reset = vmx_vcpu_reset, .prepare_guest_switch = vmx_save_host_state, .vcpu_load = vmx_vcpu_load, .vcpu_put = vmx_vcpu_put, .update_db_bp_intercept = update_exception_bitmap, .get_msr = vmx_get_msr, .set_msr = vmx_set_msr, .get_segment_base = vmx_get_segment_base, .get_segment = vmx_get_segment, .set_segment = vmx_set_segment, .get_cpl = vmx_get_cpl, .get_cs_db_l_bits = vmx_get_cs_db_l_bits, .decache_cr0_guest_bits = vmx_decache_cr0_guest_bits, .decache_cr3 = vmx_decache_cr3, .decache_cr4_guest_bits = vmx_decache_cr4_guest_bits, .set_cr0 = vmx_set_cr0, .set_cr3 = vmx_set_cr3, .set_cr4 = vmx_set_cr4, .set_efer = vmx_set_efer, .get_idt = vmx_get_idt, .set_idt = vmx_set_idt, .get_gdt = vmx_get_gdt, .set_gdt = vmx_set_gdt, .get_dr6 = vmx_get_dr6, .set_dr6 = vmx_set_dr6, .set_dr7 = vmx_set_dr7, .sync_dirty_debug_regs = vmx_sync_dirty_debug_regs, .cache_reg = vmx_cache_reg, .get_rflags = vmx_get_rflags, .set_rflags = vmx_set_rflags, .fpu_deactivate = vmx_fpu_deactivate, .tlb_flush = vmx_flush_tlb, .run = vmx_vcpu_run, .handle_exit = vmx_handle_exit, .skip_emulated_instruction = skip_emulated_instruction, .set_interrupt_shadow = vmx_set_interrupt_shadow, .get_interrupt_shadow = vmx_get_interrupt_shadow, .patch_hypercall = vmx_patch_hypercall, .set_irq = vmx_inject_irq, .set_nmi = vmx_inject_nmi, .queue_exception = vmx_queue_exception, .cancel_injection = vmx_cancel_injection, .interrupt_allowed = vmx_interrupt_allowed, .nmi_allowed = vmx_nmi_allowed, .get_nmi_mask = vmx_get_nmi_mask, .set_nmi_mask = vmx_set_nmi_mask, .enable_nmi_window = enable_nmi_window, .enable_irq_window = enable_irq_window, .update_cr8_intercept = update_cr8_intercept, .set_virtual_x2apic_mode = vmx_set_virtual_x2apic_mode, .set_apic_access_page_addr = vmx_set_apic_access_page_addr, .vm_has_apicv = vmx_vm_has_apicv, .load_eoi_exitmap = vmx_load_eoi_exitmap, .hwapic_irr_update = vmx_hwapic_irr_update, .hwapic_isr_update = vmx_hwapic_isr_update, .sync_pir_to_irr = vmx_sync_pir_to_irr, .deliver_posted_interrupt = vmx_deliver_posted_interrupt, .set_tss_addr = vmx_set_tss_addr, .get_tdp_level = get_ept_level, .get_mt_mask = vmx_get_mt_mask, .get_exit_info = vmx_get_exit_info, .get_lpage_level = vmx_get_lpage_level, .cpuid_update = vmx_cpuid_update, .rdtscp_supported = vmx_rdtscp_supported, .invpcid_supported = vmx_invpcid_supported, .set_supported_cpuid = vmx_set_supported_cpuid, .has_wbinvd_exit = cpu_has_vmx_wbinvd_exit, .set_tsc_khz = vmx_set_tsc_khz, .read_tsc_offset = vmx_read_tsc_offset, .write_tsc_offset = vmx_write_tsc_offset, .adjust_tsc_offset = vmx_adjust_tsc_offset, .compute_tsc_offset = vmx_compute_tsc_offset, .read_l1_tsc = vmx_read_l1_tsc, .set_tdp_cr3 = vmx_set_cr3, .check_intercept = vmx_check_intercept, .handle_external_intr = vmx_handle_external_intr, .mpx_supported = vmx_mpx_supported, .check_nested_events = vmx_check_nested_events, .sched_in = vmx_sched_in, }; static int __init vmx_init(void) { int r, i, msr; rdmsrl_safe(MSR_EFER, &host_efer); for (i = 0; i < ARRAY_SIZE(vmx_msr_index); ++i) kvm_define_shared_msr(i, vmx_msr_index[i]); vmx_io_bitmap_a = (unsigned long )__get_free_page(GFP_KERNEL); if (!vmx_io_bitmap_a) return -ENOMEM; r = -ENOMEM; vmx_io_bitmap_b = (unsigned long )__get_free_page(GFP_KERNEL); if (!vmx_io_bitmap_b) goto out; vmx_msr_bitmap_legacy = (unsigned long )__get_free_page(GFP_KERNEL); if (!vmx_msr_bitmap_legacy) goto out1; vmx_msr_bitmap_legacy_x2apic = (unsigned long )__get_free_page(GFP_KERNEL); if (!vmx_msr_bitmap_legacy_x2apic) goto out2; vmx_msr_bitmap_longmode = (unsigned long )__get_free_page(GFP_KERNEL); if (!vmx_msr_bitmap_longmode) goto out3; vmx_msr_bitmap_longmode_x2apic = (unsigned long )__get_free_page(GFP_KERNEL); if (!vmx_msr_bitmap_longmode_x2apic) goto out4; vmx_vmread_bitmap = (unsigned long )__get_free_page(GFP_KERNEL); if (!vmx_vmread_bitmap) goto out5; vmx_vmwrite_bitmap = (unsigned long )__get_free_page(GFP_KERNEL); if (!vmx_vmwrite_bitmap) goto out6; memset(vmx_vmread_bitmap, 0xff, PAGE_SIZE); memset(vmx_vmwrite_bitmap, 0xff, PAGE_SIZE); /* * Allow direct access to the PC debug port (it is often used for I/O * delays, but the vmexits simply slow things down). / memset(vmx_io_bitmap_a, 0xff, PAGE_SIZE); clear_bit(0x80, vmx_io_bitmap_a); memset(vmx_io_bitmap_b, 0xff, PAGE_SIZE); memset(vmx_msr_bitmap_legacy, 0xff, PAGE_SIZE); memset(vmx_msr_bitmap_longmode, 0xff, PAGE_SIZE); set_bit(0, vmx_vpid_bitmap); / 0 is reserved for host / r = kvm_init(&vmx_x86_ops, sizeof(struct vcpu_vmx), __alignof__(struct vcpu_vmx), THIS_MODULE); if (r) goto out7; #ifdef CONFIG_KEXEC rcu_assign_pointer(crash_vmclear_loaded_vmcss, crash_vmclear_local_loaded_vmcss); #endif vmx_disable_intercept_for_msr(MSR_FS_BASE, false); vmx_disable_intercept_for_msr(MSR_GS_BASE, false); vmx_disable_intercept_for_msr(MSR_KERNEL_GS_BASE, true); vmx_disable_intercept_for_msr(MSR_IA32_SYSENTER_CS, false); vmx_disable_intercept_for_msr(MSR_IA32_SYSENTER_ESP, false); vmx_disable_intercept_for_msr(MSR_IA32_SYSENTER_EIP, false); vmx_disable_intercept_for_msr(MSR_IA32_BNDCFGS, true); memcpy(vmx_msr_bitmap_legacy_x2apic, vmx_msr_bitmap_legacy, PAGE_SIZE); memcpy(vmx_msr_bitmap_longmode_x2apic, vmx_msr_bitmap_longmode, PAGE_SIZE); if (enable_apicv) { for (msr = 0x800; msr <= 0x8ff; msr++) vmx_disable_intercept_msr_read_x2apic(msr); / According SDM, in x2apic mode, the whole id reg is used. * But in KVM, it only use the highest eight bits. Need to * intercept it / vmx_enable_intercept_msr_read_x2apic(0x802); / TMCCT / vmx_enable_intercept_msr_read_x2apic(0x839); / TPR / vmx_disable_intercept_msr_write_x2apic(0x808); / EOI / vmx_disable_intercept_msr_write_x2apic(0x80b); / SELF-IPI */ vmx_disable_intercept_msr_write_x2apic(0x83f); } if (enable_ept) { kvm_mmu_set_mask_ptes(0ull, (enable_ept_ad_bits) ? VMX_EPT_ACCESS_BIT : 0ull, (enable_ept_ad_bits) ? VMX_EPT_DIRTY_BIT : 0ull, 0ull, VMX_EPT_EXECUTABLE_MASK); ept_set_mmio_spte_mask(); kvm_enable_tdp(); } else kvm_disable_tdp(); update_ple_window_actual_max(); return 0; out7: free_page((unsigned long)vmx_vmwrite_bitmap); out6: free_page((unsigned long)vmx_vmread_bitmap); out5: free_page((unsigned long)vmx_msr_bitmap_longmode_x2apic); out4: free_page((unsigned long)vmx_msr_bitmap_longmode); out3: free_page((unsigned long)vmx_msr_bitmap_legacy_x2apic); out2: free_page((unsigned long)vmx_msr_bitmap_legacy); out1: free_page((unsigned long)vmx_io_bitmap_b); out: free_page((unsigned long)vmx_io_bitmap_a); return r; } static void __exit vmx_exit(void) { free_page((unsigned long)vmx_msr_bitmap_legacy_x2apic); free_page((unsigned long)vmx_msr_bitmap_longmode_x2apic); free_page((unsigned long)vmx_msr_bitmap_legacy); free_page((unsigned long)vmx_msr_bitmap_longmode); free_page((unsigned long)vmx_io_bitmap_b); free_page((unsigned long)vmx_io_bitmap_a); free_page((unsigned long)vmx_vmwrite_bitmap); free_page((unsigned long)vmx_vmread_bitmap); #ifdef CONFIG_KEXEC RCU_INIT_POINTER(crash_vmclear_loaded_vmcss, NULL); synchronize_rcu(); #endif kvm_exit(); } module_init(vmx_init) module_exit(vmx_exit)	./CrossVul/dataset_final_sorted/CWE-264/c/good_2163_1
crossvul-cpp_data_good_5557_0	/* ----------------------------------------------------------------------- * * * Copyright 2000-2008 H. Peter Anvin - All Rights Reserved * Copyright 2009 Intel Corporation; author: H. Peter Anvin * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, Inc., 675 Mass Ave, Cambridge MA 02139, * USA; either version 2 of the License, or (at your option) any later * version; incorporated herein by reference. * * ----------------------------------------------------------------------- / / * x86 MSR access device * * This device is accessed by lseek() to the appropriate register number * and then read/write in chunks of 8 bytes. A larger size means multiple * reads or writes of the same register. * * This driver uses /dev/cpu/%d/msr where %d is the minor number, and on * an SMP box will direct the access to CPU %d. / #include <linux/module.h> #include <linux/types.h> #include <linux/errno.h> #include <linux/fcntl.h> #include <linux/init.h> #include <linux/poll.h> #include <linux/smp.h> #include <linux/major.h> #include <linux/fs.h> #include <linux/device.h> #include <linux/cpu.h> #include <linux/notifier.h> #include <linux/uaccess.h> #include <linux/gfp.h> #include <asm/processor.h> #include <asm/msr.h> static struct class msr_class; static loff_t msr_seek(struct file file, loff_t offset, int orig) { loff_t ret; struct inode inode = file->f_mapping->host; mutex_lock(&inode->i_mutex); switch (orig) { case 0: file->f_pos = offset; ret = file->f_pos; break; case 1: file->f_pos += offset; ret = file->f_pos; break; default: ret = -EINVAL; } mutex_unlock(&inode->i_mutex); return ret; } static ssize_t msr_read(struct file file, char __user buf, size_t count, loff_t ppos) { u32 __user tmp = (u32 __user ) buf; u32 data[2]; u32 reg = ppos; int cpu = iminor(file->f_path.dentry->d_inode); int err = 0; ssize_t bytes = 0; if (count % 8) return -EINVAL; /* Invalid chunk size / for (; count; count -= 8) { err = rdmsr_safe_on_cpu(cpu, reg, &data[0], &data[1]); if (err) break; if (copy_to_user(tmp, &data, 8)) { err = -EFAULT; break; } tmp += 2; bytes += 8; } return bytes ? bytes : err; } static ssize_t msr_write(struct file file, const char __user buf, size_t count, loff_t ppos) { const u32 __user tmp = (const u32 __user )buf; u32 data[2]; u32 reg = ppos; int cpu = iminor(file->f_path.dentry->d_inode); int err = 0; ssize_t bytes = 0; if (count % 8) return -EINVAL; / Invalid chunk size / for (; count; count -= 8) { if (copy_from_user(&data, tmp, 8)) { err = -EFAULT; break; } err = wrmsr_safe_on_cpu(cpu, reg, data[0], data[1]); if (err) break; tmp += 2; bytes += 8; } return bytes ? bytes : err; } static long msr_ioctl(struct file file, unsigned int ioc, unsigned long arg) { u32 __user uregs = (u32 __user )arg; u32 regs[8]; int cpu = iminor(file->f_path.dentry->d_inode); int err; switch (ioc) { case X86_IOC_RDMSR_REGS: if (!(file->f_mode & FMODE_READ)) { err = -EBADF; break; } if (copy_from_user(&regs, uregs, sizeof regs)) { err = -EFAULT; break; } err = rdmsr_safe_regs_on_cpu(cpu, regs); if (err) break; if (copy_to_user(uregs, &regs, sizeof regs)) err = -EFAULT; break; case X86_IOC_WRMSR_REGS: if (!(file->f_mode & FMODE_WRITE)) { err = -EBADF; break; } if (copy_from_user(&regs, uregs, sizeof regs)) { err = -EFAULT; break; } err = wrmsr_safe_regs_on_cpu(cpu, regs); if (err) break; if (copy_to_user(uregs, &regs, sizeof regs)) err = -EFAULT; break; default: err = -ENOTTY; break; } return err; } static int msr_open(struct inode inode, struct file file) { unsigned int cpu; struct cpuinfo_x86 c; if (!capable(CAP_SYS_RAWIO)) return -EPERM; cpu = iminor(file->f_path.dentry->d_inode); if (cpu >= nr_cpu_ids \|\| !cpu_online(cpu)) return -ENXIO; / No such CPU / c = &cpu_data(cpu); if (!cpu_has(c, X86_FEATURE_MSR)) return -EIO; / MSR not supported / return 0; } / * File operations we support / static const struct file_operations msr_fops = { .owner = THIS_MODULE, .llseek = msr_seek, .read = msr_read, .write = msr_write, .open = msr_open, .unlocked_ioctl = msr_ioctl, .compat_ioctl = msr_ioctl, }; static int __cpuinit msr_device_create(int cpu) { struct device dev; dev = device_create(msr_class, NULL, MKDEV(MSR_MAJOR, cpu), NULL, "msr%d", cpu); return IS_ERR(dev) ? PTR_ERR(dev) : 0; } static void msr_device_destroy(int cpu) { device_destroy(msr_class, MKDEV(MSR_MAJOR, cpu)); } static int __cpuinit msr_class_cpu_callback(struct notifier_block nfb, unsigned long action, void hcpu) { unsigned int cpu = (unsigned long)hcpu; int err = 0; switch (action) { case CPU_UP_PREPARE: err = msr_device_create(cpu); break; case CPU_UP_CANCELED: case CPU_UP_CANCELED_FROZEN: case CPU_DEAD: msr_device_destroy(cpu); break; } return notifier_from_errno(err); } static struct notifier_block __refdata msr_class_cpu_notifier = { .notifier_call = msr_class_cpu_callback, }; static char msr_devnode(struct device dev, umode_t *mode) { return kasprintf(GFP_KERNEL, "cpu/%u/msr", MINOR(dev->devt)); } static int __init msr_init(void) { int i, err = 0; i = 0; if (__register_chrdev(MSR_MAJOR, 0, NR_CPUS, "cpu/msr", &msr_fops)) { printk(KERN_ERR "msr: unable to get major %d for msr\n", MSR_MAJOR); err = -EBUSY; goto out; } msr_class = class_create(THIS_MODULE, "msr"); if (IS_ERR(msr_class)) { err = PTR_ERR(msr_class); goto out_chrdev; } msr_class->devnode = msr_devnode; get_online_cpus(); for_each_online_cpu(i) { err = msr_device_create(i); if (err != 0) goto out_class; } register_hotcpu_notifier(&msr_class_cpu_notifier); put_online_cpus(); err = 0; goto out; out_class: i = 0; for_each_online_cpu(i) msr_device_destroy(i); put_online_cpus(); class_destroy(msr_class); out_chrdev: __unregister_chrdev(MSR_MAJOR, 0, NR_CPUS, "cpu/msr"); out: return err; } static void __exit msr_exit(void) { int cpu = 0; get_online_cpus(); for_each_online_cpu(cpu) msr_device_destroy(cpu); class_destroy(msr_class); __unregister_chrdev(MSR_MAJOR, 0, NR_CPUS, "cpu/msr"); unregister_hotcpu_notifier(&msr_class_cpu_notifier); put_online_cpus(); } module_init(msr_init); module_exit(msr_exit) MODULE_AUTHOR("H. Peter Anvin <hpa@zytor.com>"); MODULE_DESCRIPTION("x86 generic MSR driver"); MODULE_LICENSE("GPL");	./CrossVul/dataset_final_sorted/CWE-264/c/good_5557_0
crossvul-cpp_data_good_3524_6	/* * Generic HDLC support routines for Linux * Frame Relay support * * Copyright (C) 1999 - 2006 Krzysztof Halasa <khc@pm.waw.pl> * * This program is free software; you can redistribute it and/or modify it * under the terms of version 2 of the GNU General Public License * as published by the Free Software Foundation. * Theory of PVC state DCE mode: (exist,new) -> 0,0 when "PVC create" or if "link unreliable" 0,x -> 1,1 if "link reliable" when sending FULL STATUS 1,1 -> 1,0 if received FULL STATUS ACK (active) -> 0 when "ifconfig PVC down" or "link unreliable" or "PVC create" -> 1 when "PVC up" and (exist,new) = 1,0 DTE mode: (exist,new,active) = FULL STATUS if "link reliable" = 0, 0, 0 if "link unreliable" No LMI: active = open and "link reliable" exist = new = not used CCITT LMI: ITU-T Q.933 Annex A ANSI LMI: ANSI T1.617 Annex D CISCO LMI: the original, aka "Gang of Four" LMI / #include <linux/errno.h> #include <linux/etherdevice.h> #include <linux/hdlc.h> #include <linux/if_arp.h> #include <linux/inetdevice.h> #include <linux/init.h> #include <linux/kernel.h> #include <linux/module.h> #include <linux/pkt_sched.h> #include <linux/poll.h> #include <linux/rtnetlink.h> #include <linux/skbuff.h> #include <linux/slab.h> #undef DEBUG_PKT #undef DEBUG_ECN #undef DEBUG_LINK #undef DEBUG_PROTO #undef DEBUG_PVC #define FR_UI 0x03 #define FR_PAD 0x00 #define NLPID_IP 0xCC #define NLPID_IPV6 0x8E #define NLPID_SNAP 0x80 #define NLPID_PAD 0x00 #define NLPID_CCITT_ANSI_LMI 0x08 #define NLPID_CISCO_LMI 0x09 #define LMI_CCITT_ANSI_DLCI 0 / LMI DLCI / #define LMI_CISCO_DLCI 1023 #define LMI_CALLREF 0x00 / Call Reference / #define LMI_ANSI_LOCKSHIFT 0x95 / ANSI locking shift / #define LMI_ANSI_CISCO_REPTYPE 0x01 / report type / #define LMI_CCITT_REPTYPE 0x51 #define LMI_ANSI_CISCO_ALIVE 0x03 / keep alive / #define LMI_CCITT_ALIVE 0x53 #define LMI_ANSI_CISCO_PVCSTAT 0x07 / PVC status / #define LMI_CCITT_PVCSTAT 0x57 #define LMI_FULLREP 0x00 / full report / #define LMI_INTEGRITY 0x01 / link integrity report / #define LMI_SINGLE 0x02 / single PVC report / #define LMI_STATUS_ENQUIRY 0x75 #define LMI_STATUS 0x7D / reply / #define LMI_REPT_LEN 1 / report type element length / #define LMI_INTEG_LEN 2 / link integrity element length / #define LMI_CCITT_CISCO_LENGTH 13 / LMI frame lengths / #define LMI_ANSI_LENGTH 14 typedef struct { #if defined(__LITTLE_ENDIAN_BITFIELD) unsigned ea1: 1; unsigned cr: 1; unsigned dlcih: 6; unsigned ea2: 1; unsigned de: 1; unsigned becn: 1; unsigned fecn: 1; unsigned dlcil: 4; #else unsigned dlcih: 6; unsigned cr: 1; unsigned ea1: 1; unsigned dlcil: 4; unsigned fecn: 1; unsigned becn: 1; unsigned de: 1; unsigned ea2: 1; #endif }__packed fr_hdr; typedef struct pvc_device_struct { struct net_device frad; struct net_device main; struct net_device ether; /* bridged Ethernet interface / struct pvc_device_struct next; /* Sorted in ascending DLCI order / int dlci; int open_count; struct { unsigned int new: 1; unsigned int active: 1; unsigned int exist: 1; unsigned int deleted: 1; unsigned int fecn: 1; unsigned int becn: 1; unsigned int bandwidth; / Cisco LMI reporting only / }state; }pvc_device; struct frad_state { fr_proto settings; pvc_device first_pvc; int dce_pvc_count; struct timer_list timer; unsigned long last_poll; int reliable; int dce_changed; int request; int fullrep_sent; u32 last_errors; /* last errors bit list / u8 n391cnt; u8 txseq; / TX sequence number / u8 rxseq; / RX sequence number / }; static int fr_ioctl(struct net_device dev, struct ifreq ifr); static inline u16 q922_to_dlci(u8 hdr) { return ((hdr[0] & 0xFC) << 2) \| ((hdr[1] & 0xF0) >> 4); } static inline void dlci_to_q922(u8 hdr, u16 dlci) { hdr[0] = (dlci >> 2) & 0xFC; hdr[1] = ((dlci << 4) & 0xF0) \| 0x01; } static inline struct frad_state state(hdlc_device hdlc) { return(struct frad_state )(hdlc->state); } static inline pvc_device* find_pvc(hdlc_device hdlc, u16 dlci) { pvc_device pvc = state(hdlc)->first_pvc; while (pvc) { if (pvc->dlci == dlci) return pvc; if (pvc->dlci > dlci) return NULL; /* the list is sorted / pvc = pvc->next; } return NULL; } static pvc_device add_pvc(struct net_device dev, u16 dlci) { hdlc_device hdlc = dev_to_hdlc(dev); pvc_device pvc, pvc_p = &state(hdlc)->first_pvc; while (pvc_p) { if ((pvc_p)->dlci == dlci) return pvc_p; if ((pvc_p)->dlci > dlci) break; / the list is sorted / pvc_p = &(pvc_p)->next; } pvc = kzalloc(sizeof(pvc_device), GFP_ATOMIC); #ifdef DEBUG_PVC printk(KERN_DEBUG "add_pvc: allocated pvc %p, frad %p\n", pvc, dev); #endif if (!pvc) return NULL; pvc->dlci = dlci; pvc->frad = dev; pvc->next = pvc_p; / Put it in the chain / pvc_p = pvc; return pvc; } static inline int pvc_is_used(pvc_device pvc) { return pvc->main \|\| pvc->ether; } static inline void pvc_carrier(int on, pvc_device pvc) { if (on) { if (pvc->main) if (!netif_carrier_ok(pvc->main)) netif_carrier_on(pvc->main); if (pvc->ether) if (!netif_carrier_ok(pvc->ether)) netif_carrier_on(pvc->ether); } else { if (pvc->main) if (netif_carrier_ok(pvc->main)) netif_carrier_off(pvc->main); if (pvc->ether) if (netif_carrier_ok(pvc->ether)) netif_carrier_off(pvc->ether); } } static inline void delete_unused_pvcs(hdlc_device hdlc) { pvc_device pvc_p = &state(hdlc)->first_pvc; while (pvc_p) { if (!pvc_is_used(pvc_p)) { pvc_device pvc = pvc_p; #ifdef DEBUG_PVC printk(KERN_DEBUG "freeing unused pvc: %p\n", pvc); #endif pvc_p = pvc->next; kfree(pvc); continue; } pvc_p = &(pvc_p)->next; } } static inline struct net_device* get_dev_p(pvc_device pvc, int type) { if (type == ARPHRD_ETHER) return &pvc->ether; else return &pvc->main; } static int fr_hard_header(struct sk_buff skb_p, u16 dlci) { u16 head_len; struct sk_buff skb = skb_p; switch (skb->protocol) { case cpu_to_be16(NLPID_CCITT_ANSI_LMI): head_len = 4; skb_push(skb, head_len); skb->data[3] = NLPID_CCITT_ANSI_LMI; break; case cpu_to_be16(NLPID_CISCO_LMI): head_len = 4; skb_push(skb, head_len); skb->data[3] = NLPID_CISCO_LMI; break; case cpu_to_be16(ETH_P_IP): head_len = 4; skb_push(skb, head_len); skb->data[3] = NLPID_IP; break; case cpu_to_be16(ETH_P_IPV6): head_len = 4; skb_push(skb, head_len); skb->data[3] = NLPID_IPV6; break; case cpu_to_be16(ETH_P_802_3): head_len = 10; if (skb_headroom(skb) < head_len) { struct sk_buff skb2 = skb_realloc_headroom(skb, head_len); if (!skb2) return -ENOBUFS; dev_kfree_skb(skb); skb = skb_p = skb2; } skb_push(skb, head_len); skb->data[3] = FR_PAD; skb->data[4] = NLPID_SNAP; skb->data[5] = FR_PAD; skb->data[6] = 0x80; skb->data[7] = 0xC2; skb->data[8] = 0x00; skb->data[9] = 0x07; / bridged Ethernet frame w/out FCS / break; default: head_len = 10; skb_push(skb, head_len); skb->data[3] = FR_PAD; skb->data[4] = NLPID_SNAP; skb->data[5] = FR_PAD; skb->data[6] = FR_PAD; skb->data[7] = FR_PAD; (__be16)(skb->data + 8) = skb->protocol; } dlci_to_q922(skb->data, dlci); skb->data[2] = FR_UI; return 0; } static int pvc_open(struct net_device dev) { pvc_device pvc = dev->ml_priv; if ((pvc->frad->flags & IFF_UP) == 0) return -EIO; / Frad must be UP in order to activate PVC / if (pvc->open_count++ == 0) { hdlc_device hdlc = dev_to_hdlc(pvc->frad); if (state(hdlc)->settings.lmi == LMI_NONE) pvc->state.active = netif_carrier_ok(pvc->frad); pvc_carrier(pvc->state.active, pvc); state(hdlc)->dce_changed = 1; } return 0; } static int pvc_close(struct net_device dev) { pvc_device pvc = dev->ml_priv; if (--pvc->open_count == 0) { hdlc_device hdlc = dev_to_hdlc(pvc->frad); if (state(hdlc)->settings.lmi == LMI_NONE) pvc->state.active = 0; if (state(hdlc)->settings.dce) { state(hdlc)->dce_changed = 1; pvc->state.active = 0; } } return 0; } static int pvc_ioctl(struct net_device dev, struct ifreq ifr, int cmd) { pvc_device pvc = dev->ml_priv; fr_proto_pvc_info info; if (ifr->ifr_settings.type == IF_GET_PROTO) { if (dev->type == ARPHRD_ETHER) ifr->ifr_settings.type = IF_PROTO_FR_ETH_PVC; else ifr->ifr_settings.type = IF_PROTO_FR_PVC; if (ifr->ifr_settings.size < sizeof(info)) { /* data size wanted / ifr->ifr_settings.size = sizeof(info); return -ENOBUFS; } info.dlci = pvc->dlci; memcpy(info.master, pvc->frad->name, IFNAMSIZ); if (copy_to_user(ifr->ifr_settings.ifs_ifsu.fr_pvc_info, &info, sizeof(info))) return -EFAULT; return 0; } return -EINVAL; } static netdev_tx_t pvc_xmit(struct sk_buff skb, struct net_device dev) { pvc_device pvc = dev->ml_priv; if (pvc->state.active) { if (dev->type == ARPHRD_ETHER) { int pad = ETH_ZLEN - skb->len; if (pad > 0) { /* Pad the frame with zeros / int len = skb->len; if (skb_tailroom(skb) < pad) if (pskb_expand_head(skb, 0, pad, GFP_ATOMIC)) { dev->stats.tx_dropped++; dev_kfree_skb(skb); return NETDEV_TX_OK; } skb_put(skb, pad); memset(skb->data + len, 0, pad); } skb->protocol = cpu_to_be16(ETH_P_802_3); } if (!fr_hard_header(&skb, pvc->dlci)) { dev->stats.tx_bytes += skb->len; dev->stats.tx_packets++; if (pvc->state.fecn) / TX Congestion counter / dev->stats.tx_compressed++; skb->dev = pvc->frad; dev_queue_xmit(skb); return NETDEV_TX_OK; } } dev->stats.tx_dropped++; dev_kfree_skb(skb); return NETDEV_TX_OK; } static inline void fr_log_dlci_active(pvc_device pvc) { netdev_info(pvc->frad, "DLCI %d [%s%s%s]%s %s\n", pvc->dlci, pvc->main ? pvc->main->name : "", pvc->main && pvc->ether ? " " : "", pvc->ether ? pvc->ether->name : "", pvc->state.new ? " new" : "", !pvc->state.exist ? "deleted" : pvc->state.active ? "active" : "inactive"); } static inline u8 fr_lmi_nextseq(u8 x) { x++; return x ? x : 1; } static void fr_lmi_send(struct net_device dev, int fullrep) { hdlc_device hdlc = dev_to_hdlc(dev); struct sk_buff skb; pvc_device pvc = state(hdlc)->first_pvc; int lmi = state(hdlc)->settings.lmi; int dce = state(hdlc)->settings.dce; int len = lmi == LMI_ANSI ? LMI_ANSI_LENGTH : LMI_CCITT_CISCO_LENGTH; int stat_len = (lmi == LMI_CISCO) ? 6 : 3; u8 data; int i = 0; if (dce && fullrep) { len += state(hdlc)->dce_pvc_count (2 + stat_len); if (len > HDLC_MAX_MRU) { netdev_warn(dev, "Too many PVCs while sending LMI full report\n"); return; } } skb = dev_alloc_skb(len); if (!skb) { netdev_warn(dev, "Memory squeeze on fr_lmi_send()\n"); return; } memset(skb->data, 0, len); skb_reserve(skb, 4); if (lmi == LMI_CISCO) { skb->protocol = cpu_to_be16(NLPID_CISCO_LMI); fr_hard_header(&skb, LMI_CISCO_DLCI); } else { skb->protocol = cpu_to_be16(NLPID_CCITT_ANSI_LMI); fr_hard_header(&skb, LMI_CCITT_ANSI_DLCI); } data = skb_tail_pointer(skb); data[i++] = LMI_CALLREF; data[i++] = dce ? LMI_STATUS : LMI_STATUS_ENQUIRY; if (lmi == LMI_ANSI) data[i++] = LMI_ANSI_LOCKSHIFT; data[i++] = lmi == LMI_CCITT ? LMI_CCITT_REPTYPE : LMI_ANSI_CISCO_REPTYPE; data[i++] = LMI_REPT_LEN; data[i++] = fullrep ? LMI_FULLREP : LMI_INTEGRITY; data[i++] = lmi == LMI_CCITT ? LMI_CCITT_ALIVE : LMI_ANSI_CISCO_ALIVE; data[i++] = LMI_INTEG_LEN; data[i++] = state(hdlc)->txseq = fr_lmi_nextseq(state(hdlc)->txseq); data[i++] = state(hdlc)->rxseq; if (dce && fullrep) { while (pvc) { data[i++] = lmi == LMI_CCITT ? LMI_CCITT_PVCSTAT : LMI_ANSI_CISCO_PVCSTAT; data[i++] = stat_len; /* LMI start/restart / if (state(hdlc)->reliable && !pvc->state.exist) { pvc->state.exist = pvc->state.new = 1; fr_log_dlci_active(pvc); } / ifconfig PVC up / if (pvc->open_count && !pvc->state.active && pvc->state.exist && !pvc->state.new) { pvc_carrier(1, pvc); pvc->state.active = 1; fr_log_dlci_active(pvc); } if (lmi == LMI_CISCO) { data[i] = pvc->dlci >> 8; data[i + 1] = pvc->dlci & 0xFF; } else { data[i] = (pvc->dlci >> 4) & 0x3F; data[i + 1] = ((pvc->dlci << 3) & 0x78) \| 0x80; data[i + 2] = 0x80; } if (pvc->state.new) data[i + 2] \|= 0x08; else if (pvc->state.active) data[i + 2] \|= 0x02; i += stat_len; pvc = pvc->next; } } skb_put(skb, i); skb->priority = TC_PRIO_CONTROL; skb->dev = dev; skb_reset_network_header(skb); dev_queue_xmit(skb); } static void fr_set_link_state(int reliable, struct net_device dev) { hdlc_device hdlc = dev_to_hdlc(dev); pvc_device pvc = state(hdlc)->first_pvc; state(hdlc)->reliable = reliable; if (reliable) { netif_dormant_off(dev); state(hdlc)->n391cnt = 0; /* Request full status / state(hdlc)->dce_changed = 1; if (state(hdlc)->settings.lmi == LMI_NONE) { while (pvc) { / Activate all PVCs / pvc_carrier(1, pvc); pvc->state.exist = pvc->state.active = 1; pvc->state.new = 0; pvc = pvc->next; } } } else { netif_dormant_on(dev); while (pvc) { / Deactivate all PVCs / pvc_carrier(0, pvc); pvc->state.exist = pvc->state.active = 0; pvc->state.new = 0; if (!state(hdlc)->settings.dce) pvc->state.bandwidth = 0; pvc = pvc->next; } } } static void fr_timer(unsigned long arg) { struct net_device dev = (struct net_device )arg; hdlc_device hdlc = dev_to_hdlc(dev); int i, cnt = 0, reliable; u32 list; if (state(hdlc)->settings.dce) { reliable = state(hdlc)->request && time_before(jiffies, state(hdlc)->last_poll + state(hdlc)->settings.t392 * HZ); state(hdlc)->request = 0; } else { state(hdlc)->last_errors <<= 1; /* Shift the list / if (state(hdlc)->request) { if (state(hdlc)->reliable) netdev_info(dev, "No LMI status reply received\n"); state(hdlc)->last_errors \|= 1; } list = state(hdlc)->last_errors; for (i = 0; i < state(hdlc)->settings.n393; i++, list >>= 1) cnt += (list & 1); / errors count / reliable = (cnt < state(hdlc)->settings.n392); } if (state(hdlc)->reliable != reliable) { netdev_info(dev, "Link %sreliable\n", reliable ? "" : "un"); fr_set_link_state(reliable, dev); } if (state(hdlc)->settings.dce) state(hdlc)->timer.expires = jiffies + state(hdlc)->settings.t392 HZ; else { if (state(hdlc)->n391cnt) state(hdlc)->n391cnt--; fr_lmi_send(dev, state(hdlc)->n391cnt == 0); state(hdlc)->last_poll = jiffies; state(hdlc)->request = 1; state(hdlc)->timer.expires = jiffies + state(hdlc)->settings.t391 * HZ; } state(hdlc)->timer.function = fr_timer; state(hdlc)->timer.data = arg; add_timer(&state(hdlc)->timer); } static int fr_lmi_recv(struct net_device dev, struct sk_buff skb) { hdlc_device hdlc = dev_to_hdlc(dev); pvc_device pvc; u8 rxseq, txseq; int lmi = state(hdlc)->settings.lmi; int dce = state(hdlc)->settings.dce; int stat_len = (lmi == LMI_CISCO) ? 6 : 3, reptype, error, no_ram, i; if (skb->len < (lmi == LMI_ANSI ? LMI_ANSI_LENGTH : LMI_CCITT_CISCO_LENGTH)) { netdev_info(dev, "Short LMI frame\n"); return 1; } if (skb->data[3] != (lmi == LMI_CISCO ? NLPID_CISCO_LMI : NLPID_CCITT_ANSI_LMI)) { netdev_info(dev, "Received non-LMI frame with LMI DLCI\n"); return 1; } if (skb->data[4] != LMI_CALLREF) { netdev_info(dev, "Invalid LMI Call reference (0x%02X)\n", skb->data[4]); return 1; } if (skb->data[5] != (dce ? LMI_STATUS_ENQUIRY : LMI_STATUS)) { netdev_info(dev, "Invalid LMI Message type (0x%02X)\n", skb->data[5]); return 1; } if (lmi == LMI_ANSI) { if (skb->data[6] != LMI_ANSI_LOCKSHIFT) { netdev_info(dev, "Not ANSI locking shift in LMI message (0x%02X)\n", skb->data[6]); return 1; } i = 7; } else i = 6; if (skb->data[i] != (lmi == LMI_CCITT ? LMI_CCITT_REPTYPE : LMI_ANSI_CISCO_REPTYPE)) { netdev_info(dev, "Not an LMI Report type IE (0x%02X)\n", skb->data[i]); return 1; } if (skb->data[++i] != LMI_REPT_LEN) { netdev_info(dev, "Invalid LMI Report type IE length (%u)\n", skb->data[i]); return 1; } reptype = skb->data[++i]; if (reptype != LMI_INTEGRITY && reptype != LMI_FULLREP) { netdev_info(dev, "Unsupported LMI Report type (0x%02X)\n", reptype); return 1; } if (skb->data[++i] != (lmi == LMI_CCITT ? LMI_CCITT_ALIVE : LMI_ANSI_CISCO_ALIVE)) { netdev_info(dev, "Not an LMI Link integrity verification IE (0x%02X)\n", skb->data[i]); return 1; } if (skb->data[++i] != LMI_INTEG_LEN) { netdev_info(dev, "Invalid LMI Link integrity verification IE length (%u)\n", skb->data[i]); return 1; } i++; state(hdlc)->rxseq = skb->data[i++]; /* TX sequence from peer / rxseq = skb->data[i++]; / Should confirm our sequence / txseq = state(hdlc)->txseq; if (dce) state(hdlc)->last_poll = jiffies; error = 0; if (!state(hdlc)->reliable) error = 1; if (rxseq == 0 \|\| rxseq != txseq) { / Ask for full report next time / state(hdlc)->n391cnt = 0; error = 1; } if (dce) { if (state(hdlc)->fullrep_sent && !error) { / Stop sending full report - the last one has been confirmed by DTE / state(hdlc)->fullrep_sent = 0; pvc = state(hdlc)->first_pvc; while (pvc) { if (pvc->state.new) { pvc->state.new = 0; / Tell DTE that new PVC is now active / state(hdlc)->dce_changed = 1; } pvc = pvc->next; } } if (state(hdlc)->dce_changed) { reptype = LMI_FULLREP; state(hdlc)->fullrep_sent = 1; state(hdlc)->dce_changed = 0; } state(hdlc)->request = 1; / got request / fr_lmi_send(dev, reptype == LMI_FULLREP ? 1 : 0); return 0; } / DTE / state(hdlc)->request = 0; / got response, no request pending / if (error) return 0; if (reptype != LMI_FULLREP) return 0; pvc = state(hdlc)->first_pvc; while (pvc) { pvc->state.deleted = 1; pvc = pvc->next; } no_ram = 0; while (skb->len >= i + 2 + stat_len) { u16 dlci; u32 bw; unsigned int active, new; if (skb->data[i] != (lmi == LMI_CCITT ? LMI_CCITT_PVCSTAT : LMI_ANSI_CISCO_PVCSTAT)) { netdev_info(dev, "Not an LMI PVC status IE (0x%02X)\n", skb->data[i]); return 1; } if (skb->data[++i] != stat_len) { netdev_info(dev, "Invalid LMI PVC status IE length (%u)\n", skb->data[i]); return 1; } i++; new = !! (skb->data[i + 2] & 0x08); active = !! (skb->data[i + 2] & 0x02); if (lmi == LMI_CISCO) { dlci = (skb->data[i] << 8) \| skb->data[i + 1]; bw = (skb->data[i + 3] << 16) \| (skb->data[i + 4] << 8) \| (skb->data[i + 5]); } else { dlci = ((skb->data[i] & 0x3F) << 4) \| ((skb->data[i + 1] & 0x78) >> 3); bw = 0; } pvc = add_pvc(dev, dlci); if (!pvc && !no_ram) { netdev_warn(dev, "Memory squeeze on fr_lmi_recv()\n"); no_ram = 1; } if (pvc) { pvc->state.exist = 1; pvc->state.deleted = 0; if (active != pvc->state.active \|\| new != pvc->state.new \|\| bw != pvc->state.bandwidth \|\| !pvc->state.exist) { pvc->state.new = new; pvc->state.active = active; pvc->state.bandwidth = bw; pvc_carrier(active, pvc); fr_log_dlci_active(pvc); } } i += stat_len; } pvc = state(hdlc)->first_pvc; while (pvc) { if (pvc->state.deleted && pvc->state.exist) { pvc_carrier(0, pvc); pvc->state.active = pvc->state.new = 0; pvc->state.exist = 0; pvc->state.bandwidth = 0; fr_log_dlci_active(pvc); } pvc = pvc->next; } / Next full report after N391 polls / state(hdlc)->n391cnt = state(hdlc)->settings.n391; return 0; } static int fr_rx(struct sk_buff skb) { struct net_device frad = skb->dev; hdlc_device hdlc = dev_to_hdlc(frad); fr_hdr fh = (fr_hdr)skb->data; u8 data = skb->data; u16 dlci; pvc_device pvc; struct net_device dev = NULL; if (skb->len <= 4 \|\| fh->ea1 \|\| data[2] != FR_UI) goto rx_error; dlci = q922_to_dlci(skb->data); if ((dlci == LMI_CCITT_ANSI_DLCI && (state(hdlc)->settings.lmi == LMI_ANSI \|\| state(hdlc)->settings.lmi == LMI_CCITT)) \|\| (dlci == LMI_CISCO_DLCI && state(hdlc)->settings.lmi == LMI_CISCO)) { if (fr_lmi_recv(frad, skb)) goto rx_error; dev_kfree_skb_any(skb); return NET_RX_SUCCESS; } pvc = find_pvc(hdlc, dlci); if (!pvc) { #ifdef DEBUG_PKT netdev_info(frad, "No PVC for received frame's DLCI %d\n", dlci); #endif dev_kfree_skb_any(skb); return NET_RX_DROP; } if (pvc->state.fecn != fh->fecn) { #ifdef DEBUG_ECN printk(KERN_DEBUG "%s: DLCI %d FECN O%s\n", frad->name, dlci, fh->fecn ? "N" : "FF"); #endif pvc->state.fecn ^= 1; } if (pvc->state.becn != fh->becn) { #ifdef DEBUG_ECN printk(KERN_DEBUG "%s: DLCI %d BECN O%s\n", frad->name, dlci, fh->becn ? "N" : "FF"); #endif pvc->state.becn ^= 1; } if ((skb = skb_share_check(skb, GFP_ATOMIC)) == NULL) { frad->stats.rx_dropped++; return NET_RX_DROP; } if (data[3] == NLPID_IP) { skb_pull(skb, 4); / Remove 4-byte header (hdr, UI, NLPID) / dev = pvc->main; skb->protocol = htons(ETH_P_IP); } else if (data[3] == NLPID_IPV6) { skb_pull(skb, 4); / Remove 4-byte header (hdr, UI, NLPID) / dev = pvc->main; skb->protocol = htons(ETH_P_IPV6); } else if (skb->len > 10 && data[3] == FR_PAD && data[4] == NLPID_SNAP && data[5] == FR_PAD) { u16 oui = ntohs((__be16)(data + 6)); u16 pid = ntohs((__be16)(data + 8)); skb_pull(skb, 10); switch ((((u32)oui) << 16) \| pid) { case ETH_P_ARP: / routed frame with SNAP / case ETH_P_IPX: case ETH_P_IP: / a long variant / case ETH_P_IPV6: dev = pvc->main; skb->protocol = htons(pid); break; case 0x80C20007: / bridged Ethernet frame / if ((dev = pvc->ether) != NULL) skb->protocol = eth_type_trans(skb, dev); break; default: netdev_info(frad, "Unsupported protocol, OUI=%x PID=%x\n", oui, pid); dev_kfree_skb_any(skb); return NET_RX_DROP; } } else { netdev_info(frad, "Unsupported protocol, NLPID=%x length=%i\n", data[3], skb->len); dev_kfree_skb_any(skb); return NET_RX_DROP; } if (dev) { dev->stats.rx_packets++; / PVC traffic / dev->stats.rx_bytes += skb->len; if (pvc->state.becn) dev->stats.rx_compressed++; skb->dev = dev; netif_rx(skb); return NET_RX_SUCCESS; } else { dev_kfree_skb_any(skb); return NET_RX_DROP; } rx_error: frad->stats.rx_errors++; / Mark error / dev_kfree_skb_any(skb); return NET_RX_DROP; } static void fr_start(struct net_device dev) { hdlc_device hdlc = dev_to_hdlc(dev); #ifdef DEBUG_LINK printk(KERN_DEBUG "fr_start\n"); #endif if (state(hdlc)->settings.lmi != LMI_NONE) { state(hdlc)->reliable = 0; state(hdlc)->dce_changed = 1; state(hdlc)->request = 0; state(hdlc)->fullrep_sent = 0; state(hdlc)->last_errors = 0xFFFFFFFF; state(hdlc)->n391cnt = 0; state(hdlc)->txseq = state(hdlc)->rxseq = 0; init_timer(&state(hdlc)->timer); / First poll after 1 s / state(hdlc)->timer.expires = jiffies + HZ; state(hdlc)->timer.function = fr_timer; state(hdlc)->timer.data = (unsigned long)dev; add_timer(&state(hdlc)->timer); } else fr_set_link_state(1, dev); } static void fr_stop(struct net_device dev) { hdlc_device hdlc = dev_to_hdlc(dev); #ifdef DEBUG_LINK printk(KERN_DEBUG "fr_stop\n"); #endif if (state(hdlc)->settings.lmi != LMI_NONE) del_timer_sync(&state(hdlc)->timer); fr_set_link_state(0, dev); } static void fr_close(struct net_device dev) { hdlc_device hdlc = dev_to_hdlc(dev); pvc_device pvc = state(hdlc)->first_pvc; while (pvc) { /* Shutdown all PVCs for this FRAD / if (pvc->main) dev_close(pvc->main); if (pvc->ether) dev_close(pvc->ether); pvc = pvc->next; } } static void pvc_setup(struct net_device dev) { dev->type = ARPHRD_DLCI; dev->flags = IFF_POINTOPOINT; dev->hard_header_len = 10; dev->addr_len = 2; dev->priv_flags &= ~IFF_XMIT_DST_RELEASE; } static const struct net_device_ops pvc_ops = { .ndo_open = pvc_open, .ndo_stop = pvc_close, .ndo_change_mtu = hdlc_change_mtu, .ndo_start_xmit = pvc_xmit, .ndo_do_ioctl = pvc_ioctl, }; static int fr_add_pvc(struct net_device frad, unsigned int dlci, int type) { hdlc_device hdlc = dev_to_hdlc(frad); pvc_device pvc; struct net_device dev; int used; if ((pvc = add_pvc(frad, dlci)) == NULL) { netdev_warn(frad, "Memory squeeze on fr_add_pvc()\n"); return -ENOBUFS; } if (get_dev_p(pvc, type)) return -EEXIST; used = pvc_is_used(pvc); if (type == ARPHRD_ETHER) { dev = alloc_netdev(0, "pvceth%d", ether_setup); dev->priv_flags &= ~IFF_TX_SKB_SHARING; } else dev = alloc_netdev(0, "pvc%d", pvc_setup); if (!dev) { netdev_warn(frad, "Memory squeeze on fr_pvc()\n"); delete_unused_pvcs(hdlc); return -ENOBUFS; } if (type == ARPHRD_ETHER) random_ether_addr(dev->dev_addr); else { (__be16)dev->dev_addr = htons(dlci); dlci_to_q922(dev->broadcast, dlci); } dev->netdev_ops = &pvc_ops; dev->mtu = HDLC_MAX_MTU; dev->tx_queue_len = 0; dev->ml_priv = pvc; if (register_netdevice(dev) != 0) { free_netdev(dev); delete_unused_pvcs(hdlc); return -EIO; } dev->destructor = free_netdev; get_dev_p(pvc, type) = dev; if (!used) { state(hdlc)->dce_changed = 1; state(hdlc)->dce_pvc_count++; } return 0; } static int fr_del_pvc(hdlc_device hdlc, unsigned int dlci, int type) { pvc_device pvc; struct net_device dev; if ((pvc = find_pvc(hdlc, dlci)) == NULL) return -ENOENT; if ((dev = get_dev_p(pvc, type)) == NULL) return -ENOENT; if (dev->flags & IFF_UP) return -EBUSY; /* PVC in use / unregister_netdevice(dev); / the destructor will free_netdev(dev) / get_dev_p(pvc, type) = NULL; if (!pvc_is_used(pvc)) { state(hdlc)->dce_pvc_count--; state(hdlc)->dce_changed = 1; } delete_unused_pvcs(hdlc); return 0; } static void fr_destroy(struct net_device frad) { hdlc_device hdlc = dev_to_hdlc(frad); pvc_device pvc = state(hdlc)->first_pvc; state(hdlc)->first_pvc = NULL; / All PVCs destroyed / state(hdlc)->dce_pvc_count = 0; state(hdlc)->dce_changed = 1; while (pvc) { pvc_device next = pvc->next; /* destructors will free_netdev() main and ether / if (pvc->main) unregister_netdevice(pvc->main); if (pvc->ether) unregister_netdevice(pvc->ether); kfree(pvc); pvc = next; } } static struct hdlc_proto proto = { .close = fr_close, .start = fr_start, .stop = fr_stop, .detach = fr_destroy, .ioctl = fr_ioctl, .netif_rx = fr_rx, .module = THIS_MODULE, }; static int fr_ioctl(struct net_device dev, struct ifreq ifr) { fr_proto __user fr_s = ifr->ifr_settings.ifs_ifsu.fr; const size_t size = sizeof(fr_proto); fr_proto new_settings; hdlc_device hdlc = dev_to_hdlc(dev); fr_proto_pvc pvc; int result; switch (ifr->ifr_settings.type) { case IF_GET_PROTO: if (dev_to_hdlc(dev)->proto != &proto) / Different proto / return -EINVAL; ifr->ifr_settings.type = IF_PROTO_FR; if (ifr->ifr_settings.size < size) { ifr->ifr_settings.size = size; / data size wanted / return -ENOBUFS; } if (copy_to_user(fr_s, &state(hdlc)->settings, size)) return -EFAULT; return 0; case IF_PROTO_FR: if (!capable(CAP_NET_ADMIN)) return -EPERM; if (dev->flags & IFF_UP) return -EBUSY; if (copy_from_user(&new_settings, fr_s, size)) return -EFAULT; if (new_settings.lmi == LMI_DEFAULT) new_settings.lmi = LMI_ANSI; if ((new_settings.lmi != LMI_NONE && new_settings.lmi != LMI_ANSI && new_settings.lmi != LMI_CCITT && new_settings.lmi != LMI_CISCO) \|\| new_settings.t391 < 1 \|\| new_settings.t392 < 2 \|\| new_settings.n391 < 1 \|\| new_settings.n392 < 1 \|\| new_settings.n393 < new_settings.n392 \|\| new_settings.n393 > 32 \|\| (new_settings.dce != 0 && new_settings.dce != 1)) return -EINVAL; result=hdlc->attach(dev, ENCODING_NRZ,PARITY_CRC16_PR1_CCITT); if (result) return result; if (dev_to_hdlc(dev)->proto != &proto) { / Different proto / result = attach_hdlc_protocol(dev, &proto, sizeof(struct frad_state)); if (result) return result; state(hdlc)->first_pvc = NULL; state(hdlc)->dce_pvc_count = 0; } memcpy(&state(hdlc)->settings, &new_settings, size); dev->type = ARPHRD_FRAD; return 0; case IF_PROTO_FR_ADD_PVC: case IF_PROTO_FR_DEL_PVC: case IF_PROTO_FR_ADD_ETH_PVC: case IF_PROTO_FR_DEL_ETH_PVC: if (dev_to_hdlc(dev)->proto != &proto) / Different proto / return -EINVAL; if (!capable(CAP_NET_ADMIN)) return -EPERM; if (copy_from_user(&pvc, ifr->ifr_settings.ifs_ifsu.fr_pvc, sizeof(fr_proto_pvc))) return -EFAULT; if (pvc.dlci <= 0 \|\| pvc.dlci >= 1024) return -EINVAL; / Only 10 bits, DLCI 0 reserved / if (ifr->ifr_settings.type == IF_PROTO_FR_ADD_ETH_PVC \|\| ifr->ifr_settings.type == IF_PROTO_FR_DEL_ETH_PVC) result = ARPHRD_ETHER; / bridged Ethernet device */ else result = ARPHRD_DLCI; if (ifr->ifr_settings.type == IF_PROTO_FR_ADD_PVC \|\| ifr->ifr_settings.type == IF_PROTO_FR_ADD_ETH_PVC) return fr_add_pvc(dev, pvc.dlci, result); else return fr_del_pvc(hdlc, pvc.dlci, result); } return -EINVAL; } static int __init mod_init(void) { register_hdlc_protocol(&proto); return 0; } static void __exit mod_exit(void) { unregister_hdlc_protocol(&proto); } module_init(mod_init); module_exit(mod_exit); MODULE_AUTHOR("Krzysztof Halasa <khc@pm.waw.pl>"); MODULE_DESCRIPTION("Frame-Relay protocol support for generic HDLC"); MODULE_LICENSE("GPL v2");	./CrossVul/dataset_final_sorted/CWE-264/c/good_3524_6
crossvul-cpp_data_bad_2438_1	/* * * Copyright (C) 2011 Novell Inc. * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 as published by * the Free Software Foundation. / #include <linux/fs.h> #include <linux/namei.h> #include <linux/xattr.h> #include <linux/security.h> #include <linux/mount.h> #include <linux/slab.h> #include <linux/parser.h> #include <linux/module.h> #include <linux/sched.h> #include <linux/statfs.h> #include <linux/seq_file.h> #include "overlayfs.h" MODULE_AUTHOR("Miklos Szeredi <miklos@szeredi.hu>"); MODULE_DESCRIPTION("Overlay filesystem"); MODULE_LICENSE("GPL"); #define OVERLAYFS_SUPER_MAGIC 0x794c764f struct ovl_config { char lowerdir; char upperdir; char workdir; }; /* private information held for overlayfs's superblock / struct ovl_fs { struct vfsmount upper_mnt; struct vfsmount lower_mnt; struct dentry workdir; long lower_namelen; /* pathnames of lower and upper dirs, for show_options / struct ovl_config config; }; struct ovl_dir_cache; / private information held for every overlayfs dentry / struct ovl_entry { struct dentry __upperdentry; struct dentry lowerdentry; struct ovl_dir_cache cache; union { struct { u64 version; bool opaque; }; struct rcu_head rcu; }; }; const char ovl_opaque_xattr = "trusted.overlay.opaque"; enum ovl_path_type ovl_path_type(struct dentry dentry) { struct ovl_entry oe = dentry->d_fsdata; if (oe->__upperdentry) { if (oe->lowerdentry) { if (S_ISDIR(dentry->d_inode->i_mode)) return OVL_PATH_MERGE; else return OVL_PATH_UPPER; } else { if (oe->opaque) return OVL_PATH_UPPER; else return OVL_PATH_PURE_UPPER; } } else { return OVL_PATH_LOWER; } } static struct dentry ovl_upperdentry_dereference(struct ovl_entry oe) { struct dentry upperdentry = ACCESS_ONCE(oe->__upperdentry); /* * Make sure to order reads to upperdentry wrt ovl_dentry_update() / smp_read_barrier_depends(); return upperdentry; } void ovl_path_upper(struct dentry dentry, struct path path) { struct ovl_fs ofs = dentry->d_sb->s_fs_info; struct ovl_entry oe = dentry->d_fsdata; path->mnt = ofs->upper_mnt; path->dentry = ovl_upperdentry_dereference(oe); } enum ovl_path_type ovl_path_real(struct dentry dentry, struct path path) { enum ovl_path_type type = ovl_path_type(dentry); if (type == OVL_PATH_LOWER) ovl_path_lower(dentry, path); else ovl_path_upper(dentry, path); return type; } struct dentry ovl_dentry_upper(struct dentry dentry) { struct ovl_entry oe = dentry->d_fsdata; return ovl_upperdentry_dereference(oe); } struct dentry ovl_dentry_lower(struct dentry dentry) { struct ovl_entry oe = dentry->d_fsdata; return oe->lowerdentry; } struct dentry ovl_dentry_real(struct dentry dentry) { struct ovl_entry oe = dentry->d_fsdata; struct dentry realdentry; realdentry = ovl_upperdentry_dereference(oe); if (!realdentry) realdentry = oe->lowerdentry; return realdentry; } struct dentry ovl_entry_real(struct ovl_entry oe, bool is_upper) { struct dentry realdentry; realdentry = ovl_upperdentry_dereference(oe); if (realdentry) { is_upper = true; } else { realdentry = oe->lowerdentry; is_upper = false; } return realdentry; } struct ovl_dir_cache ovl_dir_cache(struct dentry dentry) { struct ovl_entry oe = dentry->d_fsdata; return oe->cache; } void ovl_set_dir_cache(struct dentry dentry, struct ovl_dir_cache cache) { struct ovl_entry oe = dentry->d_fsdata; oe->cache = cache; } void ovl_path_lower(struct dentry dentry, struct path path) { struct ovl_fs ofs = dentry->d_sb->s_fs_info; struct ovl_entry oe = dentry->d_fsdata; path->mnt = ofs->lower_mnt; path->dentry = oe->lowerdentry; } int ovl_want_write(struct dentry dentry) { struct ovl_fs ofs = dentry->d_sb->s_fs_info; return mnt_want_write(ofs->upper_mnt); } void ovl_drop_write(struct dentry dentry) { struct ovl_fs ofs = dentry->d_sb->s_fs_info; mnt_drop_write(ofs->upper_mnt); } struct dentry ovl_workdir(struct dentry dentry) { struct ovl_fs ofs = dentry->d_sb->s_fs_info; return ofs->workdir; } bool ovl_dentry_is_opaque(struct dentry dentry) { struct ovl_entry oe = dentry->d_fsdata; return oe->opaque; } void ovl_dentry_set_opaque(struct dentry dentry, bool opaque) { struct ovl_entry oe = dentry->d_fsdata; oe->opaque = opaque; } void ovl_dentry_update(struct dentry dentry, struct dentry upperdentry) { struct ovl_entry oe = dentry->d_fsdata; WARN_ON(!mutex_is_locked(&upperdentry->d_parent->d_inode->i_mutex)); WARN_ON(oe->__upperdentry); BUG_ON(!upperdentry->d_inode); / * Make sure upperdentry is consistent before making it visible to * ovl_upperdentry_dereference(). / smp_wmb(); oe->__upperdentry = upperdentry; } void ovl_dentry_version_inc(struct dentry dentry) { struct ovl_entry oe = dentry->d_fsdata; WARN_ON(!mutex_is_locked(&dentry->d_inode->i_mutex)); oe->version++; } u64 ovl_dentry_version_get(struct dentry dentry) { struct ovl_entry oe = dentry->d_fsdata; WARN_ON(!mutex_is_locked(&dentry->d_inode->i_mutex)); return oe->version; } bool ovl_is_whiteout(struct dentry dentry) { struct inode inode = dentry->d_inode; return inode && IS_WHITEOUT(inode); } static bool ovl_is_opaquedir(struct dentry dentry) { int res; char val; struct inode inode = dentry->d_inode; if (!S_ISDIR(inode->i_mode) \|\| !inode->i_op->getxattr) return false; res = inode->i_op->getxattr(dentry, ovl_opaque_xattr, &val, 1); if (res == 1 && val == 'y') return true; return false; } static void ovl_dentry_release(struct dentry dentry) { struct ovl_entry oe = dentry->d_fsdata; if (oe) { dput(oe->__upperdentry); dput(oe->lowerdentry); kfree_rcu(oe, rcu); } } static const struct dentry_operations ovl_dentry_operations = { .d_release = ovl_dentry_release, }; static struct ovl_entry ovl_alloc_entry(void) { return kzalloc(sizeof(struct ovl_entry), GFP_KERNEL); } static inline struct dentry ovl_lookup_real(struct dentry dir, struct qstr name) { struct dentry dentry; mutex_lock(&dir->d_inode->i_mutex); dentry = lookup_one_len(name->name, dir, name->len); mutex_unlock(&dir->d_inode->i_mutex); if (IS_ERR(dentry)) { if (PTR_ERR(dentry) == -ENOENT) dentry = NULL; } else if (!dentry->d_inode) { dput(dentry); dentry = NULL; } return dentry; } struct dentry ovl_lookup(struct inode dir, struct dentry dentry, unsigned int flags) { struct ovl_entry oe; struct dentry upperdir; struct dentry lowerdir; struct dentry upperdentry = NULL; struct dentry lowerdentry = NULL; struct inode inode = NULL; int err; err = -ENOMEM; oe = ovl_alloc_entry(); if (!oe) goto out; upperdir = ovl_dentry_upper(dentry->d_parent); lowerdir = ovl_dentry_lower(dentry->d_parent); if (upperdir) { upperdentry = ovl_lookup_real(upperdir, &dentry->d_name); err = PTR_ERR(upperdentry); if (IS_ERR(upperdentry)) goto out_put_dir; if (lowerdir && upperdentry) { if (ovl_is_whiteout(upperdentry)) { dput(upperdentry); upperdentry = NULL; oe->opaque = true; } else if (ovl_is_opaquedir(upperdentry)) { oe->opaque = true; } } } if (lowerdir && !oe->opaque) { lowerdentry = ovl_lookup_real(lowerdir, &dentry->d_name); err = PTR_ERR(lowerdentry); if (IS_ERR(lowerdentry)) goto out_dput_upper; } if (lowerdentry && upperdentry && (!S_ISDIR(upperdentry->d_inode->i_mode) \|\| !S_ISDIR(lowerdentry->d_inode->i_mode))) { dput(lowerdentry); lowerdentry = NULL; oe->opaque = true; } if (lowerdentry \|\| upperdentry) { struct dentry realdentry; realdentry = upperdentry ? upperdentry : lowerdentry; err = -ENOMEM; inode = ovl_new_inode(dentry->d_sb, realdentry->d_inode->i_mode, oe); if (!inode) goto out_dput; ovl_copyattr(realdentry->d_inode, inode); } oe->__upperdentry = upperdentry; oe->lowerdentry = lowerdentry; dentry->d_fsdata = oe; d_add(dentry, inode); return NULL; out_dput: dput(lowerdentry); out_dput_upper: dput(upperdentry); out_put_dir: kfree(oe); out: return ERR_PTR(err); } struct file ovl_path_open(struct path path, int flags) { return dentry_open(path, flags, current_cred()); } static void ovl_put_super(struct super_block sb) { struct ovl_fs ufs = sb->s_fs_info; dput(ufs->workdir); mntput(ufs->upper_mnt); mntput(ufs->lower_mnt); kfree(ufs->config.lowerdir); kfree(ufs->config.upperdir); kfree(ufs->config.workdir); kfree(ufs); } /** * ovl_statfs * @sb: The overlayfs super block * @buf: The struct kstatfs to fill in with stats * * Get the filesystem statistics. As writes always target the upper layer * filesystem pass the statfs to the same filesystem. / static int ovl_statfs(struct dentry dentry, struct kstatfs buf) { struct ovl_fs ofs = dentry->d_sb->s_fs_info; struct dentry root_dentry = dentry->d_sb->s_root; struct path path; int err; ovl_path_upper(root_dentry, &path); err = vfs_statfs(&path, buf); if (!err) { buf->f_namelen = max(buf->f_namelen, ofs->lower_namelen); buf->f_type = OVERLAYFS_SUPER_MAGIC; } return err; } /* * ovl_show_options * * Prints the mount options for a given superblock. * Returns zero; does not fail. / static int ovl_show_options(struct seq_file m, struct dentry dentry) { struct super_block sb = dentry->d_sb; struct ovl_fs ufs = sb->s_fs_info; seq_printf(m, ",lowerdir=%s", ufs->config.lowerdir); seq_printf(m, ",upperdir=%s", ufs->config.upperdir); seq_printf(m, ",workdir=%s", ufs->config.workdir); return 0; } static const struct super_operations ovl_super_operations = { .put_super = ovl_put_super, .statfs = ovl_statfs, .show_options = ovl_show_options, }; enum { OPT_LOWERDIR, OPT_UPPERDIR, OPT_WORKDIR, OPT_ERR, }; static const match_table_t ovl_tokens = { {OPT_LOWERDIR, "lowerdir=%s"}, {OPT_UPPERDIR, "upperdir=%s"}, {OPT_WORKDIR, "workdir=%s"}, {OPT_ERR, NULL} }; static int ovl_parse_opt(char opt, struct ovl_config config) { char p; while ((p = strsep(&opt, ",")) != NULL) { int token; substring_t args[MAX_OPT_ARGS]; if (!p) continue; token = match_token(p, ovl_tokens, args); switch (token) { case OPT_UPPERDIR: kfree(config->upperdir); config->upperdir = match_strdup(&args[0]); if (!config->upperdir) return -ENOMEM; break; case OPT_LOWERDIR: kfree(config->lowerdir); config->lowerdir = match_strdup(&args[0]); if (!config->lowerdir) return -ENOMEM; break; case OPT_WORKDIR: kfree(config->workdir); config->workdir = match_strdup(&args[0]); if (!config->workdir) return -ENOMEM; break; default: return -EINVAL; } } return 0; } #define OVL_WORKDIR_NAME "work" static struct dentry ovl_workdir_create(struct vfsmount mnt, struct dentry dentry) { struct inode dir = dentry->d_inode; struct dentry work; int err; bool retried = false; err = mnt_want_write(mnt); if (err) return ERR_PTR(err); mutex_lock_nested(&dir->i_mutex, I_MUTEX_PARENT); retry: work = lookup_one_len(OVL_WORKDIR_NAME, dentry, strlen(OVL_WORKDIR_NAME)); if (!IS_ERR(work)) { struct kstat stat = { .mode = S_IFDIR \| 0, }; if (work->d_inode) { err = -EEXIST; if (retried) goto out_dput; retried = true; ovl_cleanup(dir, work); dput(work); goto retry; } err = ovl_create_real(dir, work, &stat, NULL, NULL, true); if (err) goto out_dput; } out_unlock: mutex_unlock(&dir->i_mutex); mnt_drop_write(mnt); return work; out_dput: dput(work); work = ERR_PTR(err); goto out_unlock; } static int ovl_mount_dir(const char name, struct path path) { int err; err = kern_path(name, LOOKUP_FOLLOW, path); if (err) { pr_err("overlayfs: failed to resolve '%s': %i\n", name, err); err = -EINVAL; } return err; } static bool ovl_is_allowed_fs_type(struct dentry root) { const struct dentry_operations dop = root->d_op; /* * We don't support: * - automount filesystems * - filesystems with revalidate (FIXME for lower layer) * - filesystems with case insensitive names / if (dop && (dop->d_manage \|\| dop->d_automount \|\| dop->d_revalidate \|\| dop->d_weak_revalidate \|\| dop->d_compare \|\| dop->d_hash)) { return false; } return true; } / Workdir should not be subdir of upperdir and vice versa / static bool ovl_workdir_ok(struct dentry workdir, struct dentry upperdir) { bool ok = false; if (workdir != upperdir) { ok = (lock_rename(workdir, upperdir) == NULL); unlock_rename(workdir, upperdir); } return ok; } static int ovl_fill_super(struct super_block sb, void data, int silent) { struct path lowerpath; struct path upperpath; struct path workpath; struct inode root_inode; struct dentry root_dentry; struct ovl_entry oe; struct ovl_fs ufs; struct kstatfs statfs; int err; err = -ENOMEM; ufs = kzalloc(sizeof(struct ovl_fs), GFP_KERNEL); if (!ufs) goto out; err = ovl_parse_opt((char ) data, &ufs->config); if (err) goto out_free_config; /* FIXME: workdir is not needed for a R/O mount / err = -EINVAL; if (!ufs->config.upperdir \|\| !ufs->config.lowerdir \|\| !ufs->config.workdir) { pr_err("overlayfs: missing upperdir or lowerdir or workdir\n"); goto out_free_config; } err = -ENOMEM; oe = ovl_alloc_entry(); if (oe == NULL) goto out_free_config; err = ovl_mount_dir(ufs->config.upperdir, &upperpath); if (err) goto out_free_oe; err = ovl_mount_dir(ufs->config.lowerdir, &lowerpath); if (err) goto out_put_upperpath; err = ovl_mount_dir(ufs->config.workdir, &workpath); if (err) goto out_put_lowerpath; err = -EINVAL; if (!S_ISDIR(upperpath.dentry->d_inode->i_mode) \|\| !S_ISDIR(lowerpath.dentry->d_inode->i_mode) \|\| !S_ISDIR(workpath.dentry->d_inode->i_mode)) { pr_err("overlayfs: upperdir or lowerdir or workdir not a directory\n"); goto out_put_workpath; } if (upperpath.mnt != workpath.mnt) { pr_err("overlayfs: workdir and upperdir must reside under the same mount\n"); goto out_put_workpath; } if (!ovl_workdir_ok(workpath.dentry, upperpath.dentry)) { pr_err("overlayfs: workdir and upperdir must be separate subtrees\n"); goto out_put_workpath; } if (!ovl_is_allowed_fs_type(upperpath.dentry)) { pr_err("overlayfs: filesystem of upperdir is not supported\n"); goto out_put_workpath; } if (!ovl_is_allowed_fs_type(lowerpath.dentry)) { pr_err("overlayfs: filesystem of lowerdir is not supported\n"); goto out_put_workpath; } err = vfs_statfs(&lowerpath, &statfs); if (err) { pr_err("overlayfs: statfs failed on lowerpath\n"); goto out_put_workpath; } ufs->lower_namelen = statfs.f_namelen; ufs->upper_mnt = clone_private_mount(&upperpath); err = PTR_ERR(ufs->upper_mnt); if (IS_ERR(ufs->upper_mnt)) { pr_err("overlayfs: failed to clone upperpath\n"); goto out_put_workpath; } ufs->lower_mnt = clone_private_mount(&lowerpath); err = PTR_ERR(ufs->lower_mnt); if (IS_ERR(ufs->lower_mnt)) { pr_err("overlayfs: failed to clone lowerpath\n"); goto out_put_upper_mnt; } ufs->workdir = ovl_workdir_create(ufs->upper_mnt, workpath.dentry); err = PTR_ERR(ufs->workdir); if (IS_ERR(ufs->workdir)) { pr_err("overlayfs: failed to create directory %s/%s\n", ufs->config.workdir, OVL_WORKDIR_NAME); goto out_put_lower_mnt; } / * Make lower_mnt R/O. That way fchmod/fchown on lower file * will fail instead of modifying lower fs. / ufs->lower_mnt->mnt_flags \|= MNT_READONLY; / If the upper fs is r/o, we mark overlayfs r/o too / if (ufs->upper_mnt->mnt_sb->s_flags & MS_RDONLY) sb->s_flags \|= MS_RDONLY; sb->s_d_op = &ovl_dentry_operations; err = -ENOMEM; root_inode = ovl_new_inode(sb, S_IFDIR, oe); if (!root_inode) goto out_put_workdir; root_dentry = d_make_root(root_inode); if (!root_dentry) goto out_put_workdir; mntput(upperpath.mnt); mntput(lowerpath.mnt); path_put(&workpath); oe->__upperdentry = upperpath.dentry; oe->lowerdentry = lowerpath.dentry; root_dentry->d_fsdata = oe; sb->s_magic = OVERLAYFS_SUPER_MAGIC; sb->s_op = &ovl_super_operations; sb->s_root = root_dentry; sb->s_fs_info = ufs; return 0; out_put_workdir: dput(ufs->workdir); out_put_lower_mnt: mntput(ufs->lower_mnt); out_put_upper_mnt: mntput(ufs->upper_mnt); out_put_workpath: path_put(&workpath); out_put_lowerpath: path_put(&lowerpath); out_put_upperpath: path_put(&upperpath); out_free_oe: kfree(oe); out_free_config: kfree(ufs->config.lowerdir); kfree(ufs->config.upperdir); kfree(ufs->config.workdir); kfree(ufs); out: return err; } static struct dentry ovl_mount(struct file_system_type fs_type, int flags, const char dev_name, void *raw_data) { return mount_nodev(fs_type, flags, raw_data, ovl_fill_super); } static struct file_system_type ovl_fs_type = { .owner = THIS_MODULE, .name = "overlayfs", .mount = ovl_mount, .kill_sb = kill_anon_super, }; MODULE_ALIAS_FS("overlayfs"); static int __init ovl_init(void) { return register_filesystem(&ovl_fs_type); } static void __exit ovl_exit(void) { unregister_filesystem(&ovl_fs_type); } module_init(ovl_init); module_exit(ovl_exit);	./CrossVul/dataset_final_sorted/CWE-264/c/bad_2438_1
crossvul-cpp_data_bad_5018_1	404: Not Found	./CrossVul/dataset_final_sorted/CWE-264/c/bad_5018_1
crossvul-cpp_data_bad_5616_0	/* * linux/fs/namespace.c * * (C) Copyright Al Viro 2000, 2001 * Released under GPL v2. * * Based on code from fs/super.c, copyright Linus Torvalds and others. * Heavily rewritten. / #include <linux/syscalls.h> #include <linux/export.h> #include <linux/capability.h> #include <linux/mnt_namespace.h> #include <linux/user_namespace.h> #include <linux/namei.h> #include <linux/security.h> #include <linux/idr.h> #include <linux/acct.h> / acct_auto_close_mnt / #include <linux/ramfs.h> / init_rootfs / #include <linux/fs_struct.h> / get_fs_root et.al. / #include <linux/fsnotify.h> / fsnotify_vfsmount_delete / #include <linux/uaccess.h> #include <linux/proc_fs.h> #include "pnode.h" #include "internal.h" #define HASH_SHIFT ilog2(PAGE_SIZE / sizeof(struct list_head)) #define HASH_SIZE (1UL << HASH_SHIFT) static int event; static DEFINE_IDA(mnt_id_ida); static DEFINE_IDA(mnt_group_ida); static DEFINE_SPINLOCK(mnt_id_lock); static int mnt_id_start = 0; static int mnt_group_start = 1; static struct list_head mount_hashtable __read_mostly; static struct kmem_cache mnt_cache __read_mostly; static struct rw_semaphore namespace_sem; / /sys/fs / struct kobject fs_kobj; EXPORT_SYMBOL_GPL(fs_kobj); /* * vfsmount lock may be taken for read to prevent changes to the * vfsmount hash, ie. during mountpoint lookups or walking back * up the tree. * * It should be taken for write in all cases where the vfsmount * tree or hash is modified or when a vfsmount structure is modified. / DEFINE_BRLOCK(vfsmount_lock); static inline unsigned long hash(struct vfsmount mnt, struct dentry dentry) { unsigned long tmp = ((unsigned long)mnt / L1_CACHE_BYTES); tmp += ((unsigned long)dentry / L1_CACHE_BYTES); tmp = tmp + (tmp >> HASH_SHIFT); return tmp & (HASH_SIZE - 1); } #define MNT_WRITER_UNDERFLOW_LIMIT -(1<<16) / * allocation is serialized by namespace_sem, but we need the spinlock to * serialize with freeing. / static int mnt_alloc_id(struct mount mnt) { int res; retry: ida_pre_get(&mnt_id_ida, GFP_KERNEL); spin_lock(&mnt_id_lock); res = ida_get_new_above(&mnt_id_ida, mnt_id_start, &mnt->mnt_id); if (!res) mnt_id_start = mnt->mnt_id + 1; spin_unlock(&mnt_id_lock); if (res == -EAGAIN) goto retry; return res; } static void mnt_free_id(struct mount mnt) { int id = mnt->mnt_id; spin_lock(&mnt_id_lock); ida_remove(&mnt_id_ida, id); if (mnt_id_start > id) mnt_id_start = id; spin_unlock(&mnt_id_lock); } / * Allocate a new peer group ID * * mnt_group_ida is protected by namespace_sem / static int mnt_alloc_group_id(struct mount mnt) { int res; if (!ida_pre_get(&mnt_group_ida, GFP_KERNEL)) return -ENOMEM; res = ida_get_new_above(&mnt_group_ida, mnt_group_start, &mnt->mnt_group_id); if (!res) mnt_group_start = mnt->mnt_group_id + 1; return res; } /* * Release a peer group ID / void mnt_release_group_id(struct mount mnt) { int id = mnt->mnt_group_id; ida_remove(&mnt_group_ida, id); if (mnt_group_start > id) mnt_group_start = id; mnt->mnt_group_id = 0; } /* * vfsmount lock must be held for read / static inline void mnt_add_count(struct mount mnt, int n) { #ifdef CONFIG_SMP this_cpu_add(mnt->mnt_pcp->mnt_count, n); #else preempt_disable(); mnt->mnt_count += n; preempt_enable(); #endif } /* * vfsmount lock must be held for write / unsigned int mnt_get_count(struct mount mnt) { #ifdef CONFIG_SMP unsigned int count = 0; int cpu; for_each_possible_cpu(cpu) { count += per_cpu_ptr(mnt->mnt_pcp, cpu)->mnt_count; } return count; #else return mnt->mnt_count; #endif } static struct mount alloc_vfsmnt(const char name) { struct mount mnt = kmem_cache_zalloc(mnt_cache, GFP_KERNEL); if (mnt) { int err; err = mnt_alloc_id(mnt); if (err) goto out_free_cache; if (name) { mnt->mnt_devname = kstrdup(name, GFP_KERNEL); if (!mnt->mnt_devname) goto out_free_id; } #ifdef CONFIG_SMP mnt->mnt_pcp = alloc_percpu(struct mnt_pcp); if (!mnt->mnt_pcp) goto out_free_devname; this_cpu_add(mnt->mnt_pcp->mnt_count, 1); #else mnt->mnt_count = 1; mnt->mnt_writers = 0; #endif INIT_LIST_HEAD(&mnt->mnt_hash); INIT_LIST_HEAD(&mnt->mnt_child); INIT_LIST_HEAD(&mnt->mnt_mounts); INIT_LIST_HEAD(&mnt->mnt_list); INIT_LIST_HEAD(&mnt->mnt_expire); INIT_LIST_HEAD(&mnt->mnt_share); INIT_LIST_HEAD(&mnt->mnt_slave_list); INIT_LIST_HEAD(&mnt->mnt_slave); #ifdef CONFIG_FSNOTIFY INIT_HLIST_HEAD(&mnt->mnt_fsnotify_marks); #endif } return mnt; #ifdef CONFIG_SMP out_free_devname: kfree(mnt->mnt_devname); #endif out_free_id: mnt_free_id(mnt); out_free_cache: kmem_cache_free(mnt_cache, mnt); return NULL; } / * Most r/o checks on a fs are for operations that take * discrete amounts of time, like a write() or unlink(). * We must keep track of when those operations start * (for permission checks) and when they end, so that * we can determine when writes are able to occur to * a filesystem. / / * __mnt_is_readonly: check whether a mount is read-only * @mnt: the mount to check for its write status * * This shouldn't be used directly ouside of the VFS. * It does not guarantee that the filesystem will stay * r/w, just that it is right now. This can not and * should not be used in place of IS_RDONLY(inode). * mnt_want/drop_write() will _keep_ the filesystem * r/w. / int __mnt_is_readonly(struct vfsmount mnt) { if (mnt->mnt_flags & MNT_READONLY) return 1; if (mnt->mnt_sb->s_flags & MS_RDONLY) return 1; return 0; } EXPORT_SYMBOL_GPL(__mnt_is_readonly); static inline void mnt_inc_writers(struct mount mnt) { #ifdef CONFIG_SMP this_cpu_inc(mnt->mnt_pcp->mnt_writers); #else mnt->mnt_writers++; #endif } static inline void mnt_dec_writers(struct mount mnt) { #ifdef CONFIG_SMP this_cpu_dec(mnt->mnt_pcp->mnt_writers); #else mnt->mnt_writers--; #endif } static unsigned int mnt_get_writers(struct mount mnt) { #ifdef CONFIG_SMP unsigned int count = 0; int cpu; for_each_possible_cpu(cpu) { count += per_cpu_ptr(mnt->mnt_pcp, cpu)->mnt_writers; } return count; #else return mnt->mnt_writers; #endif } static int mnt_is_readonly(struct vfsmount mnt) { if (mnt->mnt_sb->s_readonly_remount) return 1; /* Order wrt setting s_flags/s_readonly_remount in do_remount() / smp_rmb(); return __mnt_is_readonly(mnt); } / * Most r/o & frozen checks on a fs are for operations that take discrete * amounts of time, like a write() or unlink(). We must keep track of when * those operations start (for permission checks) and when they end, so that we * can determine when writes are able to occur to a filesystem. / /* * __mnt_want_write - get write access to a mount without freeze protection * @m: the mount on which to take a write * * This tells the low-level filesystem that a write is about to be performed to * it, and makes sure that writes are allowed (mnt it read-write) before * returning success. This operation does not protect against filesystem being * frozen. When the write operation is finished, __mnt_drop_write() must be * called. This is effectively a refcount. / int __mnt_want_write(struct vfsmount m) { struct mount mnt = real_mount(m); int ret = 0; preempt_disable(); mnt_inc_writers(mnt); / * The store to mnt_inc_writers must be visible before we pass * MNT_WRITE_HOLD loop below, so that the slowpath can see our * incremented count after it has set MNT_WRITE_HOLD. / smp_mb(); while (ACCESS_ONCE(mnt->mnt.mnt_flags) & MNT_WRITE_HOLD) cpu_relax(); / * After the slowpath clears MNT_WRITE_HOLD, mnt_is_readonly will * be set to match its requirements. So we must not load that until * MNT_WRITE_HOLD is cleared. / smp_rmb(); if (mnt_is_readonly(m)) { mnt_dec_writers(mnt); ret = -EROFS; } preempt_enable(); return ret; } /* * mnt_want_write - get write access to a mount * @m: the mount on which to take a write * * This tells the low-level filesystem that a write is about to be performed to * it, and makes sure that writes are allowed (mount is read-write, filesystem * is not frozen) before returning success. When the write operation is * finished, mnt_drop_write() must be called. This is effectively a refcount. / int mnt_want_write(struct vfsmount m) { int ret; sb_start_write(m->mnt_sb); ret = __mnt_want_write(m); if (ret) sb_end_write(m->mnt_sb); return ret; } EXPORT_SYMBOL_GPL(mnt_want_write); /** * mnt_clone_write - get write access to a mount * @mnt: the mount on which to take a write * * This is effectively like mnt_want_write, except * it must only be used to take an extra write reference * on a mountpoint that we already know has a write reference * on it. This allows some optimisation. * * After finished, mnt_drop_write must be called as usual to * drop the reference. / int mnt_clone_write(struct vfsmount mnt) { /* superblock may be r/o / if (__mnt_is_readonly(mnt)) return -EROFS; preempt_disable(); mnt_inc_writers(real_mount(mnt)); preempt_enable(); return 0; } EXPORT_SYMBOL_GPL(mnt_clone_write); /* * __mnt_want_write_file - get write access to a file's mount * @file: the file who's mount on which to take a write * * This is like __mnt_want_write, but it takes a file and can * do some optimisations if the file is open for write already / int __mnt_want_write_file(struct file file) { struct inode inode = file_inode(file); if (!(file->f_mode & FMODE_WRITE) \|\| special_file(inode->i_mode)) return __mnt_want_write(file->f_path.mnt); else return mnt_clone_write(file->f_path.mnt); } /* * mnt_want_write_file - get write access to a file's mount * @file: the file who's mount on which to take a write * * This is like mnt_want_write, but it takes a file and can * do some optimisations if the file is open for write already / int mnt_want_write_file(struct file file) { int ret; sb_start_write(file->f_path.mnt->mnt_sb); ret = __mnt_want_write_file(file); if (ret) sb_end_write(file->f_path.mnt->mnt_sb); return ret; } EXPORT_SYMBOL_GPL(mnt_want_write_file); /** * __mnt_drop_write - give up write access to a mount * @mnt: the mount on which to give up write access * * Tells the low-level filesystem that we are done * performing writes to it. Must be matched with * __mnt_want_write() call above. / void __mnt_drop_write(struct vfsmount mnt) { preempt_disable(); mnt_dec_writers(real_mount(mnt)); preempt_enable(); } /** * mnt_drop_write - give up write access to a mount * @mnt: the mount on which to give up write access * * Tells the low-level filesystem that we are done performing writes to it and * also allows filesystem to be frozen again. Must be matched with * mnt_want_write() call above. / void mnt_drop_write(struct vfsmount mnt) { __mnt_drop_write(mnt); sb_end_write(mnt->mnt_sb); } EXPORT_SYMBOL_GPL(mnt_drop_write); void __mnt_drop_write_file(struct file file) { __mnt_drop_write(file->f_path.mnt); } void mnt_drop_write_file(struct file file) { mnt_drop_write(file->f_path.mnt); } EXPORT_SYMBOL(mnt_drop_write_file); static int mnt_make_readonly(struct mount mnt) { int ret = 0; br_write_lock(&vfsmount_lock); mnt->mnt.mnt_flags \|= MNT_WRITE_HOLD; / * After storing MNT_WRITE_HOLD, we'll read the counters. This store * should be visible before we do. / smp_mb(); / * With writers on hold, if this value is zero, then there are * definitely no active writers (although held writers may subsequently * increment the count, they'll have to wait, and decrement it after * seeing MNT_READONLY). * * It is OK to have counter incremented on one CPU and decremented on * another: the sum will add up correctly. The danger would be when we * sum up each counter, if we read a counter before it is incremented, * but then read another CPU's count which it has been subsequently * decremented from -- we would see more decrements than we should. * MNT_WRITE_HOLD protects against this scenario, because * mnt_want_write first increments count, then smp_mb, then spins on * MNT_WRITE_HOLD, so it can't be decremented by another CPU while * we're counting up here. / if (mnt_get_writers(mnt) > 0) ret = -EBUSY; else mnt->mnt.mnt_flags \|= MNT_READONLY; / * MNT_READONLY must become visible before ~MNT_WRITE_HOLD, so writers * that become unheld will see MNT_READONLY. / smp_wmb(); mnt->mnt.mnt_flags &= ~MNT_WRITE_HOLD; br_write_unlock(&vfsmount_lock); return ret; } static void __mnt_unmake_readonly(struct mount mnt) { br_write_lock(&vfsmount_lock); mnt->mnt.mnt_flags &= ~MNT_READONLY; br_write_unlock(&vfsmount_lock); } int sb_prepare_remount_readonly(struct super_block sb) { struct mount mnt; int err = 0; /* Racy optimization. Recheck the counter under MNT_WRITE_HOLD / if (atomic_long_read(&sb->s_remove_count)) return -EBUSY; br_write_lock(&vfsmount_lock); list_for_each_entry(mnt, &sb->s_mounts, mnt_instance) { if (!(mnt->mnt.mnt_flags & MNT_READONLY)) { mnt->mnt.mnt_flags \|= MNT_WRITE_HOLD; smp_mb(); if (mnt_get_writers(mnt) > 0) { err = -EBUSY; break; } } } if (!err && atomic_long_read(&sb->s_remove_count)) err = -EBUSY; if (!err) { sb->s_readonly_remount = 1; smp_wmb(); } list_for_each_entry(mnt, &sb->s_mounts, mnt_instance) { if (mnt->mnt.mnt_flags & MNT_WRITE_HOLD) mnt->mnt.mnt_flags &= ~MNT_WRITE_HOLD; } br_write_unlock(&vfsmount_lock); return err; } static void free_vfsmnt(struct mount mnt) { kfree(mnt->mnt_devname); mnt_free_id(mnt); #ifdef CONFIG_SMP free_percpu(mnt->mnt_pcp); #endif kmem_cache_free(mnt_cache, mnt); } /* * find the first or last mount at @dentry on vfsmount @mnt depending on * @dir. If @dir is set return the first mount else return the last mount. * vfsmount_lock must be held for read or write. / struct mount __lookup_mnt(struct vfsmount mnt, struct dentry dentry, int dir) { struct list_head head = mount_hashtable + hash(mnt, dentry); struct list_head tmp = head; struct mount p, found = NULL; for (;;) { tmp = dir ? tmp->next : tmp->prev; p = NULL; if (tmp == head) break; p = list_entry(tmp, struct mount, mnt_hash); if (&p->mnt_parent->mnt == mnt && p->mnt_mountpoint == dentry) { found = p; break; } } return found; } /* * lookup_mnt - Return the first child mount mounted at path * * "First" means first mounted chronologically. If you create the * following mounts: * * mount /dev/sda1 /mnt * mount /dev/sda2 /mnt * mount /dev/sda3 /mnt * * Then lookup_mnt() on the base /mnt dentry in the root mount will * return successively the root dentry and vfsmount of /dev/sda1, then * /dev/sda2, then /dev/sda3, then NULL. * * lookup_mnt takes a reference to the found vfsmount. / struct vfsmount lookup_mnt(struct path path) { struct mount child_mnt; br_read_lock(&vfsmount_lock); child_mnt = __lookup_mnt(path->mnt, path->dentry, 1); if (child_mnt) { mnt_add_count(child_mnt, 1); br_read_unlock(&vfsmount_lock); return &child_mnt->mnt; } else { br_read_unlock(&vfsmount_lock); return NULL; } } static inline int check_mnt(struct mount mnt) { return mnt->mnt_ns == current->nsproxy->mnt_ns; } / * vfsmount lock must be held for write / static void touch_mnt_namespace(struct mnt_namespace ns) { if (ns) { ns->event = ++event; wake_up_interruptible(&ns->poll); } } /* * vfsmount lock must be held for write / static void __touch_mnt_namespace(struct mnt_namespace ns) { if (ns && ns->event != event) { ns->event = event; wake_up_interruptible(&ns->poll); } } /* * Clear dentry's mounted state if it has no remaining mounts. * vfsmount_lock must be held for write. / static void dentry_reset_mounted(struct dentry dentry) { unsigned u; for (u = 0; u < HASH_SIZE; u++) { struct mount p; list_for_each_entry(p, &mount_hashtable[u], mnt_hash) { if (p->mnt_mountpoint == dentry) return; } } spin_lock(&dentry->d_lock); dentry->d_flags &= ~DCACHE_MOUNTED; spin_unlock(&dentry->d_lock); } / * vfsmount lock must be held for write / static void detach_mnt(struct mount mnt, struct path old_path) { old_path->dentry = mnt->mnt_mountpoint; old_path->mnt = &mnt->mnt_parent->mnt; mnt->mnt_parent = mnt; mnt->mnt_mountpoint = mnt->mnt.mnt_root; list_del_init(&mnt->mnt_child); list_del_init(&mnt->mnt_hash); dentry_reset_mounted(old_path->dentry); } / * vfsmount lock must be held for write / void mnt_set_mountpoint(struct mount mnt, struct dentry dentry, struct mount child_mnt) { mnt_add_count(mnt, 1); /* essentially, that's mntget / child_mnt->mnt_mountpoint = dget(dentry); child_mnt->mnt_parent = mnt; spin_lock(&dentry->d_lock); dentry->d_flags \|= DCACHE_MOUNTED; spin_unlock(&dentry->d_lock); } / * vfsmount lock must be held for write / static void attach_mnt(struct mount mnt, struct path path) { mnt_set_mountpoint(real_mount(path->mnt), path->dentry, mnt); list_add_tail(&mnt->mnt_hash, mount_hashtable + hash(path->mnt, path->dentry)); list_add_tail(&mnt->mnt_child, &real_mount(path->mnt)->mnt_mounts); } / * vfsmount lock must be held for write / static void commit_tree(struct mount mnt) { struct mount parent = mnt->mnt_parent; struct mount m; LIST_HEAD(head); struct mnt_namespace n = parent->mnt_ns; BUG_ON(parent == mnt); list_add_tail(&head, &mnt->mnt_list); list_for_each_entry(m, &head, mnt_list) m->mnt_ns = n; list_splice(&head, n->list.prev); list_add_tail(&mnt->mnt_hash, mount_hashtable + hash(&parent->mnt, mnt->mnt_mountpoint)); list_add_tail(&mnt->mnt_child, &parent->mnt_mounts); touch_mnt_namespace(n); } static struct mount next_mnt(struct mount p, struct mount root) { struct list_head next = p->mnt_mounts.next; if (next == &p->mnt_mounts) { while (1) { if (p == root) return NULL; next = p->mnt_child.next; if (next != &p->mnt_parent->mnt_mounts) break; p = p->mnt_parent; } } return list_entry(next, struct mount, mnt_child); } static struct mount skip_mnt_tree(struct mount p) { struct list_head prev = p->mnt_mounts.prev; while (prev != &p->mnt_mounts) { p = list_entry(prev, struct mount, mnt_child); prev = p->mnt_mounts.prev; } return p; } struct vfsmount * vfs_kern_mount(struct file_system_type type, int flags, const char name, void data) { struct mount mnt; struct dentry root; if (!type) return ERR_PTR(-ENODEV); mnt = alloc_vfsmnt(name); if (!mnt) return ERR_PTR(-ENOMEM); if (flags & MS_KERNMOUNT) mnt->mnt.mnt_flags = MNT_INTERNAL; root = mount_fs(type, flags, name, data); if (IS_ERR(root)) { free_vfsmnt(mnt); return ERR_CAST(root); } mnt->mnt.mnt_root = root; mnt->mnt.mnt_sb = root->d_sb; mnt->mnt_mountpoint = mnt->mnt.mnt_root; mnt->mnt_parent = mnt; br_write_lock(&vfsmount_lock); list_add_tail(&mnt->mnt_instance, &root->d_sb->s_mounts); br_write_unlock(&vfsmount_lock); return &mnt->mnt; } EXPORT_SYMBOL_GPL(vfs_kern_mount); static struct mount clone_mnt(struct mount old, struct dentry root, int flag) { struct super_block sb = old->mnt.mnt_sb; struct mount mnt; int err; mnt = alloc_vfsmnt(old->mnt_devname); if (!mnt) return ERR_PTR(-ENOMEM); if (flag & (CL_SLAVE \| CL_PRIVATE \| CL_SHARED_TO_SLAVE)) mnt->mnt_group_id = 0; /* not a peer of original / else mnt->mnt_group_id = old->mnt_group_id; if ((flag & CL_MAKE_SHARED) && !mnt->mnt_group_id) { err = mnt_alloc_group_id(mnt); if (err) goto out_free; } mnt->mnt.mnt_flags = old->mnt.mnt_flags & ~MNT_WRITE_HOLD; atomic_inc(&sb->s_active); mnt->mnt.mnt_sb = sb; mnt->mnt.mnt_root = dget(root); mnt->mnt_mountpoint = mnt->mnt.mnt_root; mnt->mnt_parent = mnt; br_write_lock(&vfsmount_lock); list_add_tail(&mnt->mnt_instance, &sb->s_mounts); br_write_unlock(&vfsmount_lock); if ((flag & CL_SLAVE) \|\| ((flag & CL_SHARED_TO_SLAVE) && IS_MNT_SHARED(old))) { list_add(&mnt->mnt_slave, &old->mnt_slave_list); mnt->mnt_master = old; CLEAR_MNT_SHARED(mnt); } else if (!(flag & CL_PRIVATE)) { if ((flag & CL_MAKE_SHARED) \|\| IS_MNT_SHARED(old)) list_add(&mnt->mnt_share, &old->mnt_share); if (IS_MNT_SLAVE(old)) list_add(&mnt->mnt_slave, &old->mnt_slave); mnt->mnt_master = old->mnt_master; } if (flag & CL_MAKE_SHARED) set_mnt_shared(mnt); / stick the duplicate mount on the same expiry list * as the original if that was on one / if (flag & CL_EXPIRE) { if (!list_empty(&old->mnt_expire)) list_add(&mnt->mnt_expire, &old->mnt_expire); } return mnt; out_free: free_vfsmnt(mnt); return ERR_PTR(err); } static inline void mntfree(struct mount mnt) { struct vfsmount m = &mnt->mnt; struct super_block sb = m->mnt_sb; /* * This probably indicates that somebody messed * up a mnt_want/drop_write() pair. If this * happens, the filesystem was probably unable * to make r/w->r/o transitions. / / * The locking used to deal with mnt_count decrement provides barriers, * so mnt_get_writers() below is safe. / WARN_ON(mnt_get_writers(mnt)); fsnotify_vfsmount_delete(m); dput(m->mnt_root); free_vfsmnt(mnt); deactivate_super(sb); } static void mntput_no_expire(struct mount mnt) { put_again: #ifdef CONFIG_SMP br_read_lock(&vfsmount_lock); if (likely(mnt->mnt_ns)) { /* shouldn't be the last one / mnt_add_count(mnt, -1); br_read_unlock(&vfsmount_lock); return; } br_read_unlock(&vfsmount_lock); br_write_lock(&vfsmount_lock); mnt_add_count(mnt, -1); if (mnt_get_count(mnt)) { br_write_unlock(&vfsmount_lock); return; } #else mnt_add_count(mnt, -1); if (likely(mnt_get_count(mnt))) return; br_write_lock(&vfsmount_lock); #endif if (unlikely(mnt->mnt_pinned)) { mnt_add_count(mnt, mnt->mnt_pinned + 1); mnt->mnt_pinned = 0; br_write_unlock(&vfsmount_lock); acct_auto_close_mnt(&mnt->mnt); goto put_again; } list_del(&mnt->mnt_instance); br_write_unlock(&vfsmount_lock); mntfree(mnt); } void mntput(struct vfsmount mnt) { if (mnt) { struct mount m = real_mount(mnt); / avoid cacheline pingpong, hope gcc doesn't get "smart" / if (unlikely(m->mnt_expiry_mark)) m->mnt_expiry_mark = 0; mntput_no_expire(m); } } EXPORT_SYMBOL(mntput); struct vfsmount mntget(struct vfsmount mnt) { if (mnt) mnt_add_count(real_mount(mnt), 1); return mnt; } EXPORT_SYMBOL(mntget); void mnt_pin(struct vfsmount mnt) { br_write_lock(&vfsmount_lock); real_mount(mnt)->mnt_pinned++; br_write_unlock(&vfsmount_lock); } EXPORT_SYMBOL(mnt_pin); void mnt_unpin(struct vfsmount m) { struct mount mnt = real_mount(m); br_write_lock(&vfsmount_lock); if (mnt->mnt_pinned) { mnt_add_count(mnt, 1); mnt->mnt_pinned--; } br_write_unlock(&vfsmount_lock); } EXPORT_SYMBOL(mnt_unpin); static inline void mangle(struct seq_file m, const char s) { seq_escape(m, s, " \t\n\\"); } /* * Simple .show_options callback for filesystems which don't want to * implement more complex mount option showing. * * See also save_mount_options(). / int generic_show_options(struct seq_file m, struct dentry root) { const char options; rcu_read_lock(); options = rcu_dereference(root->d_sb->s_options); if (options != NULL && options[0]) { seq_putc(m, ','); mangle(m, options); } rcu_read_unlock(); return 0; } EXPORT_SYMBOL(generic_show_options); /* * If filesystem uses generic_show_options(), this function should be * called from the fill_super() callback. * * The .remount_fs callback usually needs to be handled in a special * way, to make sure, that previous options are not overwritten if the * remount fails. * * Also note, that if the filesystem's .remount_fs function doesn't * reset all options to their default value, but changes only newly * given options, then the displayed options will not reflect reality * any more. / void save_mount_options(struct super_block sb, char options) { BUG_ON(sb->s_options); rcu_assign_pointer(sb->s_options, kstrdup(options, GFP_KERNEL)); } EXPORT_SYMBOL(save_mount_options); void replace_mount_options(struct super_block sb, char options) { char old = sb->s_options; rcu_assign_pointer(sb->s_options, options); if (old) { synchronize_rcu(); kfree(old); } } EXPORT_SYMBOL(replace_mount_options); #ifdef CONFIG_PROC_FS /* iterator; we want it to have access to namespace_sem, thus here... / static void m_start(struct seq_file m, loff_t pos) { struct proc_mounts p = proc_mounts(m); down_read(&namespace_sem); return seq_list_start(&p->ns->list, pos); } static void m_next(struct seq_file m, void v, loff_t pos) { struct proc_mounts p = proc_mounts(m); return seq_list_next(v, &p->ns->list, pos); } static void m_stop(struct seq_file m, void v) { up_read(&namespace_sem); } static int m_show(struct seq_file m, void v) { struct proc_mounts p = proc_mounts(m); struct mount r = list_entry(v, struct mount, mnt_list); return p->show(m, &r->mnt); } const struct seq_operations mounts_op = { .start = m_start, .next = m_next, .stop = m_stop, .show = m_show, }; #endif / CONFIG_PROC_FS / /* * may_umount_tree - check if a mount tree is busy * @mnt: root of mount tree * * This is called to check if a tree of mounts has any * open files, pwds, chroots or sub mounts that are * busy. / int may_umount_tree(struct vfsmount m) { struct mount mnt = real_mount(m); int actual_refs = 0; int minimum_refs = 0; struct mount p; BUG_ON(!m); /* write lock needed for mnt_get_count / br_write_lock(&vfsmount_lock); for (p = mnt; p; p = next_mnt(p, mnt)) { actual_refs += mnt_get_count(p); minimum_refs += 2; } br_write_unlock(&vfsmount_lock); if (actual_refs > minimum_refs) return 0; return 1; } EXPORT_SYMBOL(may_umount_tree); /* * may_umount - check if a mount point is busy * @mnt: root of mount * * This is called to check if a mount point has any * open files, pwds, chroots or sub mounts. If the * mount has sub mounts this will return busy * regardless of whether the sub mounts are busy. * * Doesn't take quota and stuff into account. IOW, in some cases it will * give false negatives. The main reason why it's here is that we need * a non-destructive way to look for easily umountable filesystems. / int may_umount(struct vfsmount mnt) { int ret = 1; down_read(&namespace_sem); br_write_lock(&vfsmount_lock); if (propagate_mount_busy(real_mount(mnt), 2)) ret = 0; br_write_unlock(&vfsmount_lock); up_read(&namespace_sem); return ret; } EXPORT_SYMBOL(may_umount); void release_mounts(struct list_head head) { struct mount mnt; while (!list_empty(head)) { mnt = list_first_entry(head, struct mount, mnt_hash); list_del_init(&mnt->mnt_hash); if (mnt_has_parent(mnt)) { struct dentry dentry; struct mount m; br_write_lock(&vfsmount_lock); dentry = mnt->mnt_mountpoint; m = mnt->mnt_parent; mnt->mnt_mountpoint = mnt->mnt.mnt_root; mnt->mnt_parent = mnt; m->mnt_ghosts--; br_write_unlock(&vfsmount_lock); dput(dentry); mntput(&m->mnt); } mntput(&mnt->mnt); } } /* * vfsmount lock must be held for write * namespace_sem must be held for write / void umount_tree(struct mount mnt, int propagate, struct list_head kill) { LIST_HEAD(tmp_list); struct mount p; for (p = mnt; p; p = next_mnt(p, mnt)) list_move(&p->mnt_hash, &tmp_list); if (propagate) propagate_umount(&tmp_list); list_for_each_entry(p, &tmp_list, mnt_hash) { list_del_init(&p->mnt_expire); list_del_init(&p->mnt_list); __touch_mnt_namespace(p->mnt_ns); p->mnt_ns = NULL; list_del_init(&p->mnt_child); if (mnt_has_parent(p)) { p->mnt_parent->mnt_ghosts++; dentry_reset_mounted(p->mnt_mountpoint); } change_mnt_propagation(p, MS_PRIVATE); } list_splice(&tmp_list, kill); } static void shrink_submounts(struct mount mnt, struct list_head umounts); static int do_umount(struct mount mnt, int flags) { struct super_block sb = mnt->mnt.mnt_sb; int retval; LIST_HEAD(umount_list); retval = security_sb_umount(&mnt->mnt, flags); if (retval) return retval; /* * Allow userspace to request a mountpoint be expired rather than * unmounting unconditionally. Unmount only happens if: * (1) the mark is already set (the mark is cleared by mntput()) * (2) the usage count == 1 [parent vfsmount] + 1 [sys_umount] / if (flags & MNT_EXPIRE) { if (&mnt->mnt == current->fs->root.mnt \|\| flags & (MNT_FORCE \| MNT_DETACH)) return -EINVAL; / * probably don't strictly need the lock here if we examined * all race cases, but it's a slowpath. / br_write_lock(&vfsmount_lock); if (mnt_get_count(mnt) != 2) { br_write_unlock(&vfsmount_lock); return -EBUSY; } br_write_unlock(&vfsmount_lock); if (!xchg(&mnt->mnt_expiry_mark, 1)) return -EAGAIN; } / * If we may have to abort operations to get out of this * mount, and they will themselves hold resources we must * allow the fs to do things. In the Unix tradition of * 'Gee thats tricky lets do it in userspace' the umount_begin * might fail to complete on the first run through as other tasks * must return, and the like. Thats for the mount program to worry * about for the moment. / if (flags & MNT_FORCE && sb->s_op->umount_begin) { sb->s_op->umount_begin(sb); } / * No sense to grab the lock for this test, but test itself looks * somewhat bogus. Suggestions for better replacement? * Ho-hum... In principle, we might treat that as umount + switch * to rootfs. GC would eventually take care of the old vfsmount. * Actually it makes sense, especially if rootfs would contain a * /reboot - static binary that would close all descriptors and * call reboot(9). Then init(8) could umount root and exec /reboot. / if (&mnt->mnt == current->fs->root.mnt && !(flags & MNT_DETACH)) { / * Special case for "unmounting" root ... * we just try to remount it readonly. / down_write(&sb->s_umount); if (!(sb->s_flags & MS_RDONLY)) retval = do_remount_sb(sb, MS_RDONLY, NULL, 0); up_write(&sb->s_umount); return retval; } down_write(&namespace_sem); br_write_lock(&vfsmount_lock); event++; if (!(flags & MNT_DETACH)) shrink_submounts(mnt, &umount_list); retval = -EBUSY; if (flags & MNT_DETACH \|\| !propagate_mount_busy(mnt, 2)) { if (!list_empty(&mnt->mnt_list)) umount_tree(mnt, 1, &umount_list); retval = 0; } br_write_unlock(&vfsmount_lock); up_write(&namespace_sem); release_mounts(&umount_list); return retval; } / * Is the caller allowed to modify his namespace? / static inline bool may_mount(void) { return ns_capable(current->nsproxy->mnt_ns->user_ns, CAP_SYS_ADMIN); } / * Now umount can handle mount points as well as block devices. * This is important for filesystems which use unnamed block devices. * * We now support a flag for forced unmount like the other 'big iron' * unixes. Our API is identical to OSF/1 to avoid making a mess of AMD / SYSCALL_DEFINE2(umount, char __user , name, int, flags) { struct path path; struct mount mnt; int retval; int lookup_flags = 0; if (flags & ~(MNT_FORCE \| MNT_DETACH \| MNT_EXPIRE \| UMOUNT_NOFOLLOW)) return -EINVAL; if (!may_mount()) return -EPERM; if (!(flags & UMOUNT_NOFOLLOW)) lookup_flags \|= LOOKUP_FOLLOW; retval = user_path_at(AT_FDCWD, name, lookup_flags, &path); if (retval) goto out; mnt = real_mount(path.mnt); retval = -EINVAL; if (path.dentry != path.mnt->mnt_root) goto dput_and_out; if (!check_mnt(mnt)) goto dput_and_out; retval = do_umount(mnt, flags); dput_and_out: / we mustn't call path_put() as that would clear mnt_expiry_mark / dput(path.dentry); mntput_no_expire(mnt); out: return retval; } #ifdef __ARCH_WANT_SYS_OLDUMOUNT / * The 2.0 compatible umount. No flags. / SYSCALL_DEFINE1(oldumount, char __user , name) { return sys_umount(name, 0); } #endif static bool mnt_ns_loop(struct path path) { / Could bind mounting the mount namespace inode cause a * mount namespace loop? / struct inode inode = path->dentry->d_inode; struct proc_inode ei; struct mnt_namespace mnt_ns; if (!proc_ns_inode(inode)) return false; ei = PROC_I(inode); if (ei->ns_ops != &mntns_operations) return false; mnt_ns = ei->ns; return current->nsproxy->mnt_ns->seq >= mnt_ns->seq; } struct mount copy_tree(struct mount mnt, struct dentry dentry, int flag) { struct mount res, p, q, r; struct path path; if (!(flag & CL_COPY_ALL) && IS_MNT_UNBINDABLE(mnt)) return ERR_PTR(-EINVAL); res = q = clone_mnt(mnt, dentry, flag); if (IS_ERR(q)) return q; q->mnt_mountpoint = mnt->mnt_mountpoint; p = mnt; list_for_each_entry(r, &mnt->mnt_mounts, mnt_child) { struct mount s; if (!is_subdir(r->mnt_mountpoint, dentry)) continue; for (s = r; s; s = next_mnt(s, r)) { if (!(flag & CL_COPY_ALL) && IS_MNT_UNBINDABLE(s)) { s = skip_mnt_tree(s); continue; } while (p != s->mnt_parent) { p = p->mnt_parent; q = q->mnt_parent; } p = s; path.mnt = &q->mnt; path.dentry = p->mnt_mountpoint; q = clone_mnt(p, p->mnt.mnt_root, flag); if (IS_ERR(q)) goto out; br_write_lock(&vfsmount_lock); list_add_tail(&q->mnt_list, &res->mnt_list); attach_mnt(q, &path); br_write_unlock(&vfsmount_lock); } } return res; out: if (res) { LIST_HEAD(umount_list); br_write_lock(&vfsmount_lock); umount_tree(res, 0, &umount_list); br_write_unlock(&vfsmount_lock); release_mounts(&umount_list); } return q; } /* Caller should check returned pointer for errors / struct vfsmount collect_mounts(struct path path) { struct mount tree; down_write(&namespace_sem); tree = copy_tree(real_mount(path->mnt), path->dentry, CL_COPY_ALL \| CL_PRIVATE); up_write(&namespace_sem); if (IS_ERR(tree)) return NULL; return &tree->mnt; } void drop_collected_mounts(struct vfsmount mnt) { LIST_HEAD(umount_list); down_write(&namespace_sem); br_write_lock(&vfsmount_lock); umount_tree(real_mount(mnt), 0, &umount_list); br_write_unlock(&vfsmount_lock); up_write(&namespace_sem); release_mounts(&umount_list); } int iterate_mounts(int (f)(struct vfsmount , void ), void arg, struct vfsmount root) { struct mount mnt; int res = f(root, arg); if (res) return res; list_for_each_entry(mnt, &real_mount(root)->mnt_list, mnt_list) { res = f(&mnt->mnt, arg); if (res) return res; } return 0; } static void cleanup_group_ids(struct mount mnt, struct mount end) { struct mount p; for (p = mnt; p != end; p = next_mnt(p, mnt)) { if (p->mnt_group_id && !IS_MNT_SHARED(p)) mnt_release_group_id(p); } } static int invent_group_ids(struct mount mnt, bool recurse) { struct mount p; for (p = mnt; p; p = recurse ? next_mnt(p, mnt) : NULL) { if (!p->mnt_group_id && !IS_MNT_SHARED(p)) { int err = mnt_alloc_group_id(p); if (err) { cleanup_group_ids(mnt, p); return err; } } } return 0; } /* * @source_mnt : mount tree to be attached * @nd : place the mount tree @source_mnt is attached * @parent_nd : if non-null, detach the source_mnt from its parent and * store the parent mount and mountpoint dentry. * (done when source_mnt is moved) * * NOTE: in the table below explains the semantics when a source mount * of a given type is attached to a destination mount of a given type. * --------------------------------------------------------------------------- * \| BIND MOUNT OPERATION \| * \|************************************************************************** * \| source-->\| shared \| private \| slave \| unbindable \| * \| dest \| \| \| \| \| * \| \| \| \| \| \| \| * \| v \| \| \| \| \| * \|************************************************************************** * \| shared \| shared (++) \| shared (+) \| shared(+++)\| invalid \| * \| \| \| \| \| \| * \|non-shared\| shared (+) \| private \| slave () \| invalid \| *************************************************************************** * A bind operation clones the source mount and mounts the clone on the * destination mount. * * (++) the cloned mount is propagated to all the mounts in the propagation * tree of the destination mount and the cloned mount is added to * the peer group of the source mount. * (+) the cloned mount is created under the destination mount and is marked * as shared. The cloned mount is added to the peer group of the source * mount. * (+++) the mount is propagated to all the mounts in the propagation tree * of the destination mount and the cloned mount is made slave * of the same master as that of the source mount. The cloned mount * is marked as 'shared and slave'. * () the cloned mount is made a slave of the same master as that of the source mount. * * --------------------------------------------------------------------------- * \| MOVE MOUNT OPERATION \| * \|************************************************************************** * \| source-->\| shared \| private \| slave \| unbindable \| * \| dest \| \| \| \| \| * \| \| \| \| \| \| \| * \| v \| \| \| \| \| * \|************************************************************************** * \| shared \| shared (+) \| shared (+) \| shared(+++) \| invalid \| * \| \| \| \| \| \| * \|non-shared\| shared (+) \| private \| slave () \| unbindable \| * *************************************************************************** * * (+) the mount is moved to the destination. And is then propagated to * all the mounts in the propagation tree of the destination mount. * (+) the mount is moved to the destination. (+++) the mount is moved to the destination and is then propagated to * all the mounts belonging to the destination mount's propagation tree. * the mount is marked as 'shared and slave'. * () the mount continues to be a slave at the new location. * if the source mount is a tree, the operations explained above is * applied to each mount in the tree. * Must be called without spinlocks held, since this function can sleep * in allocations. / static int attach_recursive_mnt(struct mount source_mnt, struct path path, struct path parent_path) { LIST_HEAD(tree_list); struct mount dest_mnt = real_mount(path->mnt); struct dentry dest_dentry = path->dentry; struct mount child, p; int err; if (IS_MNT_SHARED(dest_mnt)) { err = invent_group_ids(source_mnt, true); if (err) goto out; } err = propagate_mnt(dest_mnt, dest_dentry, source_mnt, &tree_list); if (err) goto out_cleanup_ids; br_write_lock(&vfsmount_lock); if (IS_MNT_SHARED(dest_mnt)) { for (p = source_mnt; p; p = next_mnt(p, source_mnt)) set_mnt_shared(p); } if (parent_path) { detach_mnt(source_mnt, parent_path); attach_mnt(source_mnt, path); touch_mnt_namespace(source_mnt->mnt_ns); } else { mnt_set_mountpoint(dest_mnt, dest_dentry, source_mnt); commit_tree(source_mnt); } list_for_each_entry_safe(child, p, &tree_list, mnt_hash) { list_del_init(&child->mnt_hash); commit_tree(child); } br_write_unlock(&vfsmount_lock); return 0; out_cleanup_ids: if (IS_MNT_SHARED(dest_mnt)) cleanup_group_ids(source_mnt, NULL); out: return err; } static int lock_mount(struct path path) { struct vfsmount mnt; retry: mutex_lock(&path->dentry->d_inode->i_mutex); if (unlikely(cant_mount(path->dentry))) { mutex_unlock(&path->dentry->d_inode->i_mutex); return -ENOENT; } down_write(&namespace_sem); mnt = lookup_mnt(path); if (likely(!mnt)) return 0; up_write(&namespace_sem); mutex_unlock(&path->dentry->d_inode->i_mutex); path_put(path); path->mnt = mnt; path->dentry = dget(mnt->mnt_root); goto retry; } static void unlock_mount(struct path path) { up_write(&namespace_sem); mutex_unlock(&path->dentry->d_inode->i_mutex); } static int graft_tree(struct mount mnt, struct path path) { if (mnt->mnt.mnt_sb->s_flags & MS_NOUSER) return -EINVAL; if (S_ISDIR(path->dentry->d_inode->i_mode) != S_ISDIR(mnt->mnt.mnt_root->d_inode->i_mode)) return -ENOTDIR; if (d_unlinked(path->dentry)) return -ENOENT; return attach_recursive_mnt(mnt, path, NULL); } / * Sanity check the flags to change_mnt_propagation. / static int flags_to_propagation_type(int flags) { int type = flags & ~(MS_REC \| MS_SILENT); / Fail if any non-propagation flags are set / if (type & ~(MS_SHARED \| MS_PRIVATE \| MS_SLAVE \| MS_UNBINDABLE)) return 0; / Only one propagation flag should be set / if (!is_power_of_2(type)) return 0; return type; } / * recursively change the type of the mountpoint. / static int do_change_type(struct path path, int flag) { struct mount m; struct mount mnt = real_mount(path->mnt); int recurse = flag & MS_REC; int type; int err = 0; if (path->dentry != path->mnt->mnt_root) return -EINVAL; type = flags_to_propagation_type(flag); if (!type) return -EINVAL; down_write(&namespace_sem); if (type == MS_SHARED) { err = invent_group_ids(mnt, recurse); if (err) goto out_unlock; } br_write_lock(&vfsmount_lock); for (m = mnt; m; m = (recurse ? next_mnt(m, mnt) : NULL)) change_mnt_propagation(m, type); br_write_unlock(&vfsmount_lock); out_unlock: up_write(&namespace_sem); return err; } /* * do loopback mount. / static int do_loopback(struct path path, const char old_name, int recurse) { LIST_HEAD(umount_list); struct path old_path; struct mount mnt = NULL, old; int err; if (!old_name \|\| !old_name) return -EINVAL; err = kern_path(old_name, LOOKUP_FOLLOW\|LOOKUP_AUTOMOUNT, &old_path); if (err) return err; err = -EINVAL; if (mnt_ns_loop(&old_path)) goto out; err = lock_mount(path); if (err) goto out; old = real_mount(old_path.mnt); err = -EINVAL; if (IS_MNT_UNBINDABLE(old)) goto out2; if (!check_mnt(real_mount(path->mnt)) \|\| !check_mnt(old)) goto out2; if (recurse) mnt = copy_tree(old, old_path.dentry, 0); else mnt = clone_mnt(old, old_path.dentry, 0); if (IS_ERR(mnt)) { err = PTR_ERR(mnt); goto out; } err = graft_tree(mnt, path); if (err) { br_write_lock(&vfsmount_lock); umount_tree(mnt, 0, &umount_list); br_write_unlock(&vfsmount_lock); } out2: unlock_mount(path); release_mounts(&umount_list); out: path_put(&old_path); return err; } static int change_mount_flags(struct vfsmount mnt, int ms_flags) { int error = 0; int readonly_request = 0; if (ms_flags & MS_RDONLY) readonly_request = 1; if (readonly_request == __mnt_is_readonly(mnt)) return 0; if (mnt->mnt_flags & MNT_LOCK_READONLY) return -EPERM; if (readonly_request) error = mnt_make_readonly(real_mount(mnt)); else __mnt_unmake_readonly(real_mount(mnt)); return error; } / * change filesystem flags. dir should be a physical root of filesystem. * If you've mounted a non-root directory somewhere and want to do remount * on it - tough luck. / static int do_remount(struct path path, int flags, int mnt_flags, void data) { int err; struct super_block sb = path->mnt->mnt_sb; struct mount mnt = real_mount(path->mnt); if (!check_mnt(mnt)) return -EINVAL; if (path->dentry != path->mnt->mnt_root) return -EINVAL; err = security_sb_remount(sb, data); if (err) return err; down_write(&sb->s_umount); if (flags & MS_BIND) err = change_mount_flags(path->mnt, flags); else if (!capable(CAP_SYS_ADMIN)) err = -EPERM; else err = do_remount_sb(sb, flags, data, 0); if (!err) { br_write_lock(&vfsmount_lock); mnt_flags \|= mnt->mnt.mnt_flags & MNT_PROPAGATION_MASK; mnt->mnt.mnt_flags = mnt_flags; br_write_unlock(&vfsmount_lock); } up_write(&sb->s_umount); if (!err) { br_write_lock(&vfsmount_lock); touch_mnt_namespace(mnt->mnt_ns); br_write_unlock(&vfsmount_lock); } return err; } static inline int tree_contains_unbindable(struct mount mnt) { struct mount p; for (p = mnt; p; p = next_mnt(p, mnt)) { if (IS_MNT_UNBINDABLE(p)) return 1; } return 0; } static int do_move_mount(struct path path, const char old_name) { struct path old_path, parent_path; struct mount p; struct mount old; int err; if (!old_name \|\| !old_name) return -EINVAL; err = kern_path(old_name, LOOKUP_FOLLOW, &old_path); if (err) return err; err = lock_mount(path); if (err < 0) goto out; old = real_mount(old_path.mnt); p = real_mount(path->mnt); err = -EINVAL; if (!check_mnt(p) \|\| !check_mnt(old)) goto out1; if (d_unlinked(path->dentry)) goto out1; err = -EINVAL; if (old_path.dentry != old_path.mnt->mnt_root) goto out1; if (!mnt_has_parent(old)) goto out1; if (S_ISDIR(path->dentry->d_inode->i_mode) != S_ISDIR(old_path.dentry->d_inode->i_mode)) goto out1; /* * Don't move a mount residing in a shared parent. / if (IS_MNT_SHARED(old->mnt_parent)) goto out1; / * Don't move a mount tree containing unbindable mounts to a destination * mount which is shared. / if (IS_MNT_SHARED(p) && tree_contains_unbindable(old)) goto out1; err = -ELOOP; for (; mnt_has_parent(p); p = p->mnt_parent) if (p == old) goto out1; err = attach_recursive_mnt(old, path, &parent_path); if (err) goto out1; / if the mount is moved, it should no longer be expire * automatically / list_del_init(&old->mnt_expire); out1: unlock_mount(path); out: if (!err) path_put(&parent_path); path_put(&old_path); return err; } static struct vfsmount fs_set_subtype(struct vfsmount mnt, const char fstype) { int err; const char subtype = strchr(fstype, '.'); if (subtype) { subtype++; err = -EINVAL; if (!subtype[0]) goto err; } else subtype = ""; mnt->mnt_sb->s_subtype = kstrdup(subtype, GFP_KERNEL); err = -ENOMEM; if (!mnt->mnt_sb->s_subtype) goto err; return mnt; err: mntput(mnt); return ERR_PTR(err); } / * add a mount into a namespace's mount tree / static int do_add_mount(struct mount newmnt, struct path path, int mnt_flags) { int err; mnt_flags &= ~(MNT_SHARED \| MNT_WRITE_HOLD \| MNT_INTERNAL); err = lock_mount(path); if (err) return err; err = -EINVAL; if (unlikely(!check_mnt(real_mount(path->mnt)))) { / that's acceptable only for automounts done in private ns / if (!(mnt_flags & MNT_SHRINKABLE)) goto unlock; / ... and for those we'd better have mountpoint still alive / if (!real_mount(path->mnt)->mnt_ns) goto unlock; } / Refuse the same filesystem on the same mount point / err = -EBUSY; if (path->mnt->mnt_sb == newmnt->mnt.mnt_sb && path->mnt->mnt_root == path->dentry) goto unlock; err = -EINVAL; if (S_ISLNK(newmnt->mnt.mnt_root->d_inode->i_mode)) goto unlock; newmnt->mnt.mnt_flags = mnt_flags; err = graft_tree(newmnt, path); unlock: unlock_mount(path); return err; } / * create a new mount for userspace and request it to be added into the * namespace's tree / static int do_new_mount(struct path path, const char fstype, int flags, int mnt_flags, const char name, void data) { struct file_system_type type; struct user_namespace user_ns = current->nsproxy->mnt_ns->user_ns; struct vfsmount mnt; int err; if (!fstype) return -EINVAL; type = get_fs_type(fstype); if (!type) return -ENODEV; if (user_ns != &init_user_ns) { if (!(type->fs_flags & FS_USERNS_MOUNT)) { put_filesystem(type); return -EPERM; } /* Only in special cases allow devices from mounts * created outside the initial user namespace. / if (!(type->fs_flags & FS_USERNS_DEV_MOUNT)) { flags \|= MS_NODEV; mnt_flags \|= MNT_NODEV; } } mnt = vfs_kern_mount(type, flags, name, data); if (!IS_ERR(mnt) && (type->fs_flags & FS_HAS_SUBTYPE) && !mnt->mnt_sb->s_subtype) mnt = fs_set_subtype(mnt, fstype); put_filesystem(type); if (IS_ERR(mnt)) return PTR_ERR(mnt); err = do_add_mount(real_mount(mnt), path, mnt_flags); if (err) mntput(mnt); return err; } int finish_automount(struct vfsmount m, struct path path) { struct mount mnt = real_mount(m); int err; /* The new mount record should have at least 2 refs to prevent it being * expired before we get a chance to add it / BUG_ON(mnt_get_count(mnt) < 2); if (m->mnt_sb == path->mnt->mnt_sb && m->mnt_root == path->dentry) { err = -ELOOP; goto fail; } err = do_add_mount(mnt, path, path->mnt->mnt_flags \| MNT_SHRINKABLE); if (!err) return 0; fail: / remove m from any expiration list it may be on / if (!list_empty(&mnt->mnt_expire)) { down_write(&namespace_sem); br_write_lock(&vfsmount_lock); list_del_init(&mnt->mnt_expire); br_write_unlock(&vfsmount_lock); up_write(&namespace_sem); } mntput(m); mntput(m); return err; } /* * mnt_set_expiry - Put a mount on an expiration list * @mnt: The mount to list. * @expiry_list: The list to add the mount to. / void mnt_set_expiry(struct vfsmount mnt, struct list_head expiry_list) { down_write(&namespace_sem); br_write_lock(&vfsmount_lock); list_add_tail(&real_mount(mnt)->mnt_expire, expiry_list); br_write_unlock(&vfsmount_lock); up_write(&namespace_sem); } EXPORT_SYMBOL(mnt_set_expiry); / * process a list of expirable mountpoints with the intent of discarding any * mountpoints that aren't in use and haven't been touched since last we came * here / void mark_mounts_for_expiry(struct list_head mounts) { struct mount mnt, next; LIST_HEAD(graveyard); LIST_HEAD(umounts); if (list_empty(mounts)) return; down_write(&namespace_sem); br_write_lock(&vfsmount_lock); /* extract from the expiration list every vfsmount that matches the * following criteria: * - only referenced by its parent vfsmount * - still marked for expiry (marked on the last call here; marks are * cleared by mntput()) / list_for_each_entry_safe(mnt, next, mounts, mnt_expire) { if (!xchg(&mnt->mnt_expiry_mark, 1) \|\| propagate_mount_busy(mnt, 1)) continue; list_move(&mnt->mnt_expire, &graveyard); } while (!list_empty(&graveyard)) { mnt = list_first_entry(&graveyard, struct mount, mnt_expire); touch_mnt_namespace(mnt->mnt_ns); umount_tree(mnt, 1, &umounts); } br_write_unlock(&vfsmount_lock); up_write(&namespace_sem); release_mounts(&umounts); } EXPORT_SYMBOL_GPL(mark_mounts_for_expiry); / * Ripoff of 'select_parent()' * * search the list of submounts for a given mountpoint, and move any * shrinkable submounts to the 'graveyard' list. / static int select_submounts(struct mount parent, struct list_head graveyard) { struct mount this_parent = parent; struct list_head next; int found = 0; repeat: next = this_parent->mnt_mounts.next; resume: while (next != &this_parent->mnt_mounts) { struct list_head tmp = next; struct mount mnt = list_entry(tmp, struct mount, mnt_child); next = tmp->next; if (!(mnt->mnt.mnt_flags & MNT_SHRINKABLE)) continue; / * Descend a level if the d_mounts list is non-empty. / if (!list_empty(&mnt->mnt_mounts)) { this_parent = mnt; goto repeat; } if (!propagate_mount_busy(mnt, 1)) { list_move_tail(&mnt->mnt_expire, graveyard); found++; } } / * All done at this level ... ascend and resume the search / if (this_parent != parent) { next = this_parent->mnt_child.next; this_parent = this_parent->mnt_parent; goto resume; } return found; } / * process a list of expirable mountpoints with the intent of discarding any * submounts of a specific parent mountpoint * * vfsmount_lock must be held for write / static void shrink_submounts(struct mount mnt, struct list_head umounts) { LIST_HEAD(graveyard); struct mount m; /* extract submounts of 'mountpoint' from the expiration list / while (select_submounts(mnt, &graveyard)) { while (!list_empty(&graveyard)) { m = list_first_entry(&graveyard, struct mount, mnt_expire); touch_mnt_namespace(m->mnt_ns); umount_tree(m, 1, umounts); } } } / * Some copy_from_user() implementations do not return the exact number of * bytes remaining to copy on a fault. But copy_mount_options() requires that. * Note that this function differs from copy_from_user() in that it will oops * on bad values of `to', rather than returning a short copy. / static long exact_copy_from_user(void to, const void __user * from, unsigned long n) { char t = to; const char __user f = from; char c; if (!access_ok(VERIFY_READ, from, n)) return n; while (n) { if (__get_user(c, f)) { memset(t, 0, n); break; } t++ = c; f++; n--; } return n; } int copy_mount_options(const void __user data, unsigned long where) { int i; unsigned long page; unsigned long size; where = 0; if (!data) return 0; if (!(page = __get_free_page(GFP_KERNEL))) return -ENOMEM; /* We only care that some data at the address the user * gave us is valid. Just in case, we'll zero * the remainder of the page. / / copy_from_user cannot cross TASK_SIZE ! / size = TASK_SIZE - (unsigned long)data; if (size > PAGE_SIZE) size = PAGE_SIZE; i = size - exact_copy_from_user((void )page, data, size); if (!i) { free_page(page); return -EFAULT; } if (i != PAGE_SIZE) memset((char )page + i, 0, PAGE_SIZE - i); where = page; return 0; } int copy_mount_string(const void __user data, char where) { char tmp; if (!data) { where = NULL; return 0; } tmp = strndup_user(data, PAGE_SIZE); if (IS_ERR(tmp)) return PTR_ERR(tmp); where = tmp; return 0; } /* * Flags is a 32-bit value that allows up to 31 non-fs dependent flags to * be given to the mount() call (ie: read-only, no-dev, no-suid etc). * * data is a (void ) that can point to any structure up to PAGE_SIZE-1 bytes, which can contain arbitrary fs-dependent * information (or be NULL). * * Pre-0.97 versions of mount() didn't have a flags word. * When the flags word was introduced its top half was required * to have the magic value 0xC0ED, and this remained so until 2.4.0-test9. * Therefore, if this magic number is present, it carries no information * and must be discarded. / long do_mount(const char dev_name, const char dir_name, const char type_page, unsigned long flags, void data_page) { struct path path; int retval = 0; int mnt_flags = 0; / Discard magic / if ((flags & MS_MGC_MSK) == MS_MGC_VAL) flags &= ~MS_MGC_MSK; / Basic sanity checks / if (!dir_name \|\| !dir_name \|\| !memchr(dir_name, 0, PAGE_SIZE)) return -EINVAL; if (data_page) ((char )data_page)[PAGE_SIZE - 1] = 0; / ... and get the mountpoint / retval = kern_path(dir_name, LOOKUP_FOLLOW, &path); if (retval) return retval; retval = security_sb_mount(dev_name, &path, type_page, flags, data_page); if (retval) goto dput_out; if (!may_mount()) return -EPERM; / Default to relatime unless overriden / if (!(flags & MS_NOATIME)) mnt_flags \|= MNT_RELATIME; / Separate the per-mountpoint flags / if (flags & MS_NOSUID) mnt_flags \|= MNT_NOSUID; if (flags & MS_NODEV) mnt_flags \|= MNT_NODEV; if (flags & MS_NOEXEC) mnt_flags \|= MNT_NOEXEC; if (flags & MS_NOATIME) mnt_flags \|= MNT_NOATIME; if (flags & MS_NODIRATIME) mnt_flags \|= MNT_NODIRATIME; if (flags & MS_STRICTATIME) mnt_flags &= ~(MNT_RELATIME \| MNT_NOATIME); if (flags & MS_RDONLY) mnt_flags \|= MNT_READONLY; flags &= ~(MS_NOSUID \| MS_NOEXEC \| MS_NODEV \| MS_ACTIVE \| MS_BORN \| MS_NOATIME \| MS_NODIRATIME \| MS_RELATIME\| MS_KERNMOUNT \| MS_STRICTATIME); if (flags & MS_REMOUNT) retval = do_remount(&path, flags & ~MS_REMOUNT, mnt_flags, data_page); else if (flags & MS_BIND) retval = do_loopback(&path, dev_name, flags & MS_REC); else if (flags & (MS_SHARED \| MS_PRIVATE \| MS_SLAVE \| MS_UNBINDABLE)) retval = do_change_type(&path, flags); else if (flags & MS_MOVE) retval = do_move_mount(&path, dev_name); else retval = do_new_mount(&path, type_page, flags, mnt_flags, dev_name, data_page); dput_out: path_put(&path); return retval; } static void free_mnt_ns(struct mnt_namespace ns) { proc_free_inum(ns->proc_inum); put_user_ns(ns->user_ns); kfree(ns); } /* * Assign a sequence number so we can detect when we attempt to bind * mount a reference to an older mount namespace into the current * mount namespace, preventing reference counting loops. A 64bit * number incrementing at 10Ghz will take 12,427 years to wrap which * is effectively never, so we can ignore the possibility. / static atomic64_t mnt_ns_seq = ATOMIC64_INIT(1); static struct mnt_namespace alloc_mnt_ns(struct user_namespace user_ns) { struct mnt_namespace new_ns; int ret; new_ns = kmalloc(sizeof(struct mnt_namespace), GFP_KERNEL); if (!new_ns) return ERR_PTR(-ENOMEM); ret = proc_alloc_inum(&new_ns->proc_inum); if (ret) { kfree(new_ns); return ERR_PTR(ret); } new_ns->seq = atomic64_add_return(1, &mnt_ns_seq); atomic_set(&new_ns->count, 1); new_ns->root = NULL; INIT_LIST_HEAD(&new_ns->list); init_waitqueue_head(&new_ns->poll); new_ns->event = 0; new_ns->user_ns = get_user_ns(user_ns); return new_ns; } /* * Allocate a new namespace structure and populate it with contents * copied from the namespace of the passed in task structure. / static struct mnt_namespace dup_mnt_ns(struct mnt_namespace mnt_ns, struct user_namespace user_ns, struct fs_struct fs) { struct mnt_namespace new_ns; struct vfsmount rootmnt = NULL, pwdmnt = NULL; struct mount p, q; struct mount old = mnt_ns->root; struct mount new; int copy_flags; new_ns = alloc_mnt_ns(user_ns); if (IS_ERR(new_ns)) return new_ns; down_write(&namespace_sem); /* First pass: copy the tree topology / copy_flags = CL_COPY_ALL \| CL_EXPIRE; if (user_ns != mnt_ns->user_ns) copy_flags \|= CL_SHARED_TO_SLAVE; new = copy_tree(old, old->mnt.mnt_root, copy_flags); if (IS_ERR(new)) { up_write(&namespace_sem); free_mnt_ns(new_ns); return ERR_CAST(new); } new_ns->root = new; br_write_lock(&vfsmount_lock); list_add_tail(&new_ns->list, &new->mnt_list); br_write_unlock(&vfsmount_lock); / * Second pass: switch the tsk->fs->* elements and mark new vfsmounts * as belonging to new namespace. We have already acquired a private * fs_struct, so tsk->fs->lock is not needed. / p = old; q = new; while (p) { q->mnt_ns = new_ns; if (fs) { if (&p->mnt == fs->root.mnt) { fs->root.mnt = mntget(&q->mnt); rootmnt = &p->mnt; } if (&p->mnt == fs->pwd.mnt) { fs->pwd.mnt = mntget(&q->mnt); pwdmnt = &p->mnt; } } p = next_mnt(p, old); q = next_mnt(q, new); } up_write(&namespace_sem); if (rootmnt) mntput(rootmnt); if (pwdmnt) mntput(pwdmnt); return new_ns; } struct mnt_namespace copy_mnt_ns(unsigned long flags, struct mnt_namespace ns, struct user_namespace user_ns, struct fs_struct new_fs) { struct mnt_namespace new_ns; BUG_ON(!ns); get_mnt_ns(ns); if (!(flags & CLONE_NEWNS)) return ns; new_ns = dup_mnt_ns(ns, user_ns, new_fs); put_mnt_ns(ns); return new_ns; } /** * create_mnt_ns - creates a private namespace and adds a root filesystem * @mnt: pointer to the new root filesystem mountpoint / static struct mnt_namespace create_mnt_ns(struct vfsmount m) { struct mnt_namespace new_ns = alloc_mnt_ns(&init_user_ns); if (!IS_ERR(new_ns)) { struct mount mnt = real_mount(m); mnt->mnt_ns = new_ns; new_ns->root = mnt; list_add(&new_ns->list, &mnt->mnt_list); } else { mntput(m); } return new_ns; } struct dentry mount_subtree(struct vfsmount mnt, const char name) { struct mnt_namespace ns; struct super_block s; struct path path; int err; ns = create_mnt_ns(mnt); if (IS_ERR(ns)) return ERR_CAST(ns); err = vfs_path_lookup(mnt->mnt_root, mnt, name, LOOKUP_FOLLOW\|LOOKUP_AUTOMOUNT, &path); put_mnt_ns(ns); if (err) return ERR_PTR(err); /* trade a vfsmount reference for active sb one / s = path.mnt->mnt_sb; atomic_inc(&s->s_active); mntput(path.mnt); / lock the sucker / down_write(&s->s_umount); / ... and return the root of (sub)tree on it / return path.dentry; } EXPORT_SYMBOL(mount_subtree); SYSCALL_DEFINE5(mount, char __user , dev_name, char __user , dir_name, char __user , type, unsigned long, flags, void __user , data) { int ret; char kernel_type; struct filename kernel_dir; char kernel_dev; unsigned long data_page; ret = copy_mount_string(type, &kernel_type); if (ret < 0) goto out_type; kernel_dir = getname(dir_name); if (IS_ERR(kernel_dir)) { ret = PTR_ERR(kernel_dir); goto out_dir; } ret = copy_mount_string(dev_name, &kernel_dev); if (ret < 0) goto out_dev; ret = copy_mount_options(data, &data_page); if (ret < 0) goto out_data; ret = do_mount(kernel_dev, kernel_dir->name, kernel_type, flags, (void ) data_page); free_page(data_page); out_data: kfree(kernel_dev); out_dev: putname(kernel_dir); out_dir: kfree(kernel_type); out_type: return ret; } / * Return true if path is reachable from root * * namespace_sem or vfsmount_lock is held / bool is_path_reachable(struct mount mnt, struct dentry dentry, const struct path root) { while (&mnt->mnt != root->mnt && mnt_has_parent(mnt)) { dentry = mnt->mnt_mountpoint; mnt = mnt->mnt_parent; } return &mnt->mnt == root->mnt && is_subdir(dentry, root->dentry); } int path_is_under(struct path path1, struct path path2) { int res; br_read_lock(&vfsmount_lock); res = is_path_reachable(real_mount(path1->mnt), path1->dentry, path2); br_read_unlock(&vfsmount_lock); return res; } EXPORT_SYMBOL(path_is_under); /* * pivot_root Semantics: * Moves the root file system of the current process to the directory put_old, * makes new_root as the new root file system of the current process, and sets * root/cwd of all processes which had them on the current root to new_root. * * Restrictions: * The new_root and put_old must be directories, and must not be on the * same file system as the current process root. The put_old must be * underneath new_root, i.e. adding a non-zero number of /.. to the string * pointed to by put_old must yield the same directory as new_root. No other * file system may be mounted on put_old. After all, new_root is a mountpoint. * * Also, the current root cannot be on the 'rootfs' (initial ramfs) filesystem. * See Documentation/filesystems/ramfs-rootfs-initramfs.txt for alternatives * in this situation. * * Notes: * - we don't move root/cwd if they are not at the root (reason: if something * cared enough to change them, it's probably wrong to force them elsewhere) * - it's okay to pick a root that isn't the root of a file system, e.g. * /nfs/my_root where /nfs is the mount point. It must be a mountpoint, * though, so you may need to say mount --bind /nfs/my_root /nfs/my_root * first. / SYSCALL_DEFINE2(pivot_root, const char __user , new_root, const char __user , put_old) { struct path new, old, parent_path, root_parent, root; struct mount new_mnt, root_mnt; int error; if (!may_mount()) return -EPERM; error = user_path_dir(new_root, &new); if (error) goto out0; error = user_path_dir(put_old, &old); if (error) goto out1; error = security_sb_pivotroot(&old, &new); if (error) goto out2; get_fs_root(current->fs, &root); error = lock_mount(&old); if (error) goto out3; error = -EINVAL; new_mnt = real_mount(new.mnt); root_mnt = real_mount(root.mnt); if (IS_MNT_SHARED(real_mount(old.mnt)) \|\| IS_MNT_SHARED(new_mnt->mnt_parent) \|\| IS_MNT_SHARED(root_mnt->mnt_parent)) goto out4; if (!check_mnt(root_mnt) \|\| !check_mnt(new_mnt)) goto out4; error = -ENOENT; if (d_unlinked(new.dentry)) goto out4; if (d_unlinked(old.dentry)) goto out4; error = -EBUSY; if (new.mnt == root.mnt \|\| old.mnt == root.mnt) goto out4; / loop, on the same file system / error = -EINVAL; if (root.mnt->mnt_root != root.dentry) goto out4; / not a mountpoint / if (!mnt_has_parent(root_mnt)) goto out4; / not attached / if (new.mnt->mnt_root != new.dentry) goto out4; / not a mountpoint / if (!mnt_has_parent(new_mnt)) goto out4; / not attached / / make sure we can reach put_old from new_root / if (!is_path_reachable(real_mount(old.mnt), old.dentry, &new)) goto out4; br_write_lock(&vfsmount_lock); detach_mnt(new_mnt, &parent_path); detach_mnt(root_mnt, &root_parent); / mount old root on put_old / attach_mnt(root_mnt, &old); / mount new_root on / / attach_mnt(new_mnt, &root_parent); touch_mnt_namespace(current->nsproxy->mnt_ns); br_write_unlock(&vfsmount_lock); chroot_fs_refs(&root, &new); error = 0; out4: unlock_mount(&old); if (!error) { path_put(&root_parent); path_put(&parent_path); } out3: path_put(&root); out2: path_put(&old); out1: path_put(&new); out0: return error; } static void __init init_mount_tree(void) { struct vfsmount mnt; struct mnt_namespace ns; struct path root; struct file_system_type type; type = get_fs_type("rootfs"); if (!type) panic("Can't find rootfs type"); mnt = vfs_kern_mount(type, 0, "rootfs", NULL); put_filesystem(type); if (IS_ERR(mnt)) panic("Can't create rootfs"); ns = create_mnt_ns(mnt); if (IS_ERR(ns)) panic("Can't allocate initial namespace"); init_task.nsproxy->mnt_ns = ns; get_mnt_ns(ns); root.mnt = mnt; root.dentry = mnt->mnt_root; set_fs_pwd(current->fs, &root); set_fs_root(current->fs, &root); } void __init mnt_init(void) { unsigned u; int err; init_rwsem(&namespace_sem); mnt_cache = kmem_cache_create("mnt_cache", sizeof(struct mount), 0, SLAB_HWCACHE_ALIGN \| SLAB_PANIC, NULL); mount_hashtable = (struct list_head )__get_free_page(GFP_ATOMIC); if (!mount_hashtable) panic("Failed to allocate mount hash table\n"); printk(KERN_INFO "Mount-cache hash table entries: %lu\n", HASH_SIZE); for (u = 0; u < HASH_SIZE; u++) INIT_LIST_HEAD(&mount_hashtable[u]); br_lock_init(&vfsmount_lock); err = sysfs_init(); if (err) printk(KERN_WARNING "%s: sysfs_init error: %d\n", __func__, err); fs_kobj = kobject_create_and_add("fs", NULL); if (!fs_kobj) printk(KERN_WARNING "%s: kobj create error\n", __func__); init_rootfs(); init_mount_tree(); } void put_mnt_ns(struct mnt_namespace ns) { LIST_HEAD(umount_list); if (!atomic_dec_and_test(&ns->count)) return; down_write(&namespace_sem); br_write_lock(&vfsmount_lock); umount_tree(ns->root, 0, &umount_list); br_write_unlock(&vfsmount_lock); up_write(&namespace_sem); release_mounts(&umount_list); free_mnt_ns(ns); } struct vfsmount kern_mount_data(struct file_system_type type, void data) { struct vfsmount mnt; mnt = vfs_kern_mount(type, MS_KERNMOUNT, type->name, data); if (!IS_ERR(mnt)) { /* * it is a longterm mount, don't release mnt until * we unmount before file sys is unregistered / real_mount(mnt)->mnt_ns = MNT_NS_INTERNAL; } return mnt; } EXPORT_SYMBOL_GPL(kern_mount_data); void kern_unmount(struct vfsmount mnt) { /* release long term mount so mount point can be released / if (!IS_ERR_OR_NULL(mnt)) { br_write_lock(&vfsmount_lock); real_mount(mnt)->mnt_ns = NULL; br_write_unlock(&vfsmount_lock); mntput(mnt); } } EXPORT_SYMBOL(kern_unmount); bool our_mnt(struct vfsmount mnt) { return check_mnt(real_mount(mnt)); } bool current_chrooted(void) { /* Does the current process have a non-standard root / struct path ns_root; struct path fs_root; bool chrooted; / Find the namespace root / ns_root.mnt = &current->nsproxy->mnt_ns->root->mnt; ns_root.dentry = ns_root.mnt->mnt_root; path_get(&ns_root); while (d_mountpoint(ns_root.dentry) && follow_down_one(&ns_root)) ; get_fs_root(current->fs, &fs_root); chrooted = !path_equal(&fs_root, &ns_root); path_put(&fs_root); path_put(&ns_root); return chrooted; } static void mntns_get(struct task_struct task) { struct mnt_namespace ns = NULL; struct nsproxy nsproxy; rcu_read_lock(); nsproxy = task_nsproxy(task); if (nsproxy) { ns = nsproxy->mnt_ns; get_mnt_ns(ns); } rcu_read_unlock(); return ns; } static void mntns_put(void ns) { put_mnt_ns(ns); } static int mntns_install(struct nsproxy nsproxy, void ns) { struct fs_struct fs = current->fs; struct mnt_namespace mnt_ns = ns; struct path root; if (!ns_capable(mnt_ns->user_ns, CAP_SYS_ADMIN) \|\| !nsown_capable(CAP_SYS_CHROOT) \|\| !nsown_capable(CAP_SYS_ADMIN)) return -EPERM; if (fs->users != 1) return -EINVAL; get_mnt_ns(mnt_ns); put_mnt_ns(nsproxy->mnt_ns); nsproxy->mnt_ns = mnt_ns; /* Find the root / root.mnt = &mnt_ns->root->mnt; root.dentry = mnt_ns->root->mnt.mnt_root; path_get(&root); while(d_mountpoint(root.dentry) && follow_down_one(&root)) ; / Update the pwd and root / set_fs_pwd(fs, &root); set_fs_root(fs, &root); path_put(&root); return 0; } static unsigned int mntns_inum(void ns) { struct mnt_namespace *mnt_ns = ns; return mnt_ns->proc_inum; } const struct proc_ns_operations mntns_operations = { .name = "mnt", .type = CLONE_NEWNS, .get = mntns_get, .put = mntns_put, .install = mntns_install, .inum = mntns_inum, };	./CrossVul/dataset_final_sorted/CWE-264/c/bad_5616_0
crossvul-cpp_data_bad_1719_0	/* $OpenBSD: monitor.c,v 1.150 2015/06/22 23:42:16 djm Exp $ / / * Copyright 2002 Niels Provos <provos@citi.umich.edu> * Copyright 2002 Markus Friedl <markus@openbsd.org> * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. / #include "includes.h" #include <sys/types.h> #include <sys/socket.h> #include "openbsd-compat/sys-tree.h" #include <sys/wait.h> #include <errno.h> #include <fcntl.h> #ifdef HAVE_PATHS_H #include <paths.h> #endif #include <pwd.h> #include <signal.h> #ifdef HAVE_STDINT_H #include <stdint.h> #endif #include <stdlib.h> #include <string.h> #include <stdarg.h> #include <stdio.h> #include <unistd.h> #ifdef HAVE_POLL_H #include <poll.h> #else # ifdef HAVE_SYS_POLL_H # include <sys/poll.h> # endif #endif #ifdef SKEY #include <skey.h> #endif #ifdef WITH_OPENSSL #include <openssl/dh.h> #endif #include "openbsd-compat/sys-queue.h" #include "atomicio.h" #include "xmalloc.h" #include "ssh.h" #include "key.h" #include "buffer.h" #include "hostfile.h" #include "auth.h" #include "cipher.h" #include "kex.h" #include "dh.h" #ifdef TARGET_OS_MAC / XXX Broken krb5 headers on Mac / #undef TARGET_OS_MAC #include "zlib.h" #define TARGET_OS_MAC 1 #else #include "zlib.h" #endif #include "packet.h" #include "auth-options.h" #include "sshpty.h" #include "channels.h" #include "session.h" #include "sshlogin.h" #include "canohost.h" #include "log.h" #include "misc.h" #include "servconf.h" #include "monitor.h" #include "monitor_mm.h" #ifdef GSSAPI #include "ssh-gss.h" #endif #include "monitor_wrap.h" #include "monitor_fdpass.h" #include "compat.h" #include "ssh2.h" #include "roaming.h" #include "authfd.h" #include "match.h" #include "ssherr.h" #ifdef GSSAPI static Gssctxt gsscontext = NULL; #endif /* Imports / extern ServerOptions options; extern u_int utmp_len; extern u_char session_id[]; extern Buffer auth_debug; extern int auth_debug_init; extern Buffer loginmsg; / State exported from the child / static struct sshbuf child_state; /* Functions on the monitor that answer unprivileged requests / int mm_answer_moduli(int, Buffer ); int mm_answer_sign(int, Buffer ); int mm_answer_pwnamallow(int, Buffer ); int mm_answer_auth2_read_banner(int, Buffer ); int mm_answer_authserv(int, Buffer ); int mm_answer_authpassword(int, Buffer ); int mm_answer_bsdauthquery(int, Buffer ); int mm_answer_bsdauthrespond(int, Buffer ); int mm_answer_skeyquery(int, Buffer ); int mm_answer_skeyrespond(int, Buffer ); int mm_answer_keyallowed(int, Buffer ); int mm_answer_keyverify(int, Buffer ); int mm_answer_pty(int, Buffer ); int mm_answer_pty_cleanup(int, Buffer ); int mm_answer_term(int, Buffer ); int mm_answer_rsa_keyallowed(int, Buffer ); int mm_answer_rsa_challenge(int, Buffer ); int mm_answer_rsa_response(int, Buffer ); int mm_answer_sesskey(int, Buffer ); int mm_answer_sessid(int, Buffer ); #ifdef USE_PAM int mm_answer_pam_start(int, Buffer ); int mm_answer_pam_account(int, Buffer ); int mm_answer_pam_init_ctx(int, Buffer ); int mm_answer_pam_query(int, Buffer ); int mm_answer_pam_respond(int, Buffer ); int mm_answer_pam_free_ctx(int, Buffer ); #endif #ifdef GSSAPI int mm_answer_gss_setup_ctx(int, Buffer ); int mm_answer_gss_accept_ctx(int, Buffer ); int mm_answer_gss_userok(int, Buffer ); int mm_answer_gss_checkmic(int, Buffer ); #endif #ifdef SSH_AUDIT_EVENTS int mm_answer_audit_event(int, Buffer ); int mm_answer_audit_command(int, Buffer ); #endif static int monitor_read_log(struct monitor ); static Authctxt authctxt; #ifdef WITH_SSH1 static BIGNUM ssh1_challenge = NULL; /* used for ssh1 rsa auth / #endif / local state for key verify / static u_char key_blob = NULL; static u_int key_bloblen = 0; static int key_blobtype = MM_NOKEY; static char hostbased_cuser = NULL; static char hostbased_chost = NULL; static char auth_method = "unknown"; static char auth_submethod = NULL; static u_int session_id2_len = 0; static u_char session_id2 = NULL; static pid_t monitor_child_pid; struct mon_table { enum monitor_reqtype type; int flags; int (f)(int, Buffer ); }; #define MON_ISAUTH 0x0004 / Required for Authentication / #define MON_AUTHDECIDE 0x0008 / Decides Authentication / #define MON_ONCE 0x0010 / Disable after calling / #define MON_ALOG 0x0020 / Log auth attempt without authenticating / #define MON_AUTH (MON_ISAUTH\|MON_AUTHDECIDE) #define MON_PERMIT 0x1000 / Request is permitted / struct mon_table mon_dispatch_proto20[] = { #ifdef WITH_OPENSSL {MONITOR_REQ_MODULI, MON_ONCE, mm_answer_moduli}, #endif {MONITOR_REQ_SIGN, MON_ONCE, mm_answer_sign}, {MONITOR_REQ_PWNAM, MON_ONCE, mm_answer_pwnamallow}, {MONITOR_REQ_AUTHSERV, MON_ONCE, mm_answer_authserv}, {MONITOR_REQ_AUTH2_READ_BANNER, MON_ONCE, mm_answer_auth2_read_banner}, {MONITOR_REQ_AUTHPASSWORD, MON_AUTH, mm_answer_authpassword}, #ifdef USE_PAM {MONITOR_REQ_PAM_START, MON_ONCE, mm_answer_pam_start}, {MONITOR_REQ_PAM_ACCOUNT, 0, mm_answer_pam_account}, {MONITOR_REQ_PAM_INIT_CTX, MON_ISAUTH, mm_answer_pam_init_ctx}, {MONITOR_REQ_PAM_QUERY, MON_ISAUTH, mm_answer_pam_query}, {MONITOR_REQ_PAM_RESPOND, MON_ISAUTH, mm_answer_pam_respond}, {MONITOR_REQ_PAM_FREE_CTX, MON_ONCE\|MON_AUTHDECIDE, mm_answer_pam_free_ctx}, #endif #ifdef SSH_AUDIT_EVENTS {MONITOR_REQ_AUDIT_EVENT, MON_PERMIT, mm_answer_audit_event}, #endif #ifdef BSD_AUTH {MONITOR_REQ_BSDAUTHQUERY, MON_ISAUTH, mm_answer_bsdauthquery}, {MONITOR_REQ_BSDAUTHRESPOND, MON_AUTH, mm_answer_bsdauthrespond}, #endif #ifdef SKEY {MONITOR_REQ_SKEYQUERY, MON_ISAUTH, mm_answer_skeyquery}, {MONITOR_REQ_SKEYRESPOND, MON_AUTH, mm_answer_skeyrespond}, #endif {MONITOR_REQ_KEYALLOWED, MON_ISAUTH, mm_answer_keyallowed}, {MONITOR_REQ_KEYVERIFY, MON_AUTH, mm_answer_keyverify}, #ifdef GSSAPI {MONITOR_REQ_GSSSETUP, MON_ISAUTH, mm_answer_gss_setup_ctx}, {MONITOR_REQ_GSSSTEP, MON_ISAUTH, mm_answer_gss_accept_ctx}, {MONITOR_REQ_GSSUSEROK, MON_AUTH, mm_answer_gss_userok}, {MONITOR_REQ_GSSCHECKMIC, MON_ISAUTH, mm_answer_gss_checkmic}, #endif {0, 0, NULL} }; struct mon_table mon_dispatch_postauth20[] = { #ifdef WITH_OPENSSL {MONITOR_REQ_MODULI, 0, mm_answer_moduli}, #endif {MONITOR_REQ_SIGN, 0, mm_answer_sign}, {MONITOR_REQ_PTY, 0, mm_answer_pty}, {MONITOR_REQ_PTYCLEANUP, 0, mm_answer_pty_cleanup}, {MONITOR_REQ_TERM, 0, mm_answer_term}, #ifdef SSH_AUDIT_EVENTS {MONITOR_REQ_AUDIT_EVENT, MON_PERMIT, mm_answer_audit_event}, {MONITOR_REQ_AUDIT_COMMAND, MON_PERMIT, mm_answer_audit_command}, #endif {0, 0, NULL} }; struct mon_table mon_dispatch_proto15[] = { #ifdef WITH_SSH1 {MONITOR_REQ_PWNAM, MON_ONCE, mm_answer_pwnamallow}, {MONITOR_REQ_SESSKEY, MON_ONCE, mm_answer_sesskey}, {MONITOR_REQ_SESSID, MON_ONCE, mm_answer_sessid}, {MONITOR_REQ_AUTHPASSWORD, MON_AUTH, mm_answer_authpassword}, {MONITOR_REQ_RSAKEYALLOWED, MON_ISAUTH\|MON_ALOG, mm_answer_rsa_keyallowed}, {MONITOR_REQ_KEYALLOWED, MON_ISAUTH\|MON_ALOG, mm_answer_keyallowed}, {MONITOR_REQ_RSACHALLENGE, MON_ONCE, mm_answer_rsa_challenge}, {MONITOR_REQ_RSARESPONSE, MON_ONCE\|MON_AUTHDECIDE, mm_answer_rsa_response}, #ifdef BSD_AUTH {MONITOR_REQ_BSDAUTHQUERY, MON_ISAUTH, mm_answer_bsdauthquery}, {MONITOR_REQ_BSDAUTHRESPOND, MON_AUTH, mm_answer_bsdauthrespond}, #endif #ifdef SKEY {MONITOR_REQ_SKEYQUERY, MON_ISAUTH, mm_answer_skeyquery}, {MONITOR_REQ_SKEYRESPOND, MON_AUTH, mm_answer_skeyrespond}, #endif #ifdef USE_PAM {MONITOR_REQ_PAM_START, MON_ONCE, mm_answer_pam_start}, {MONITOR_REQ_PAM_ACCOUNT, 0, mm_answer_pam_account}, {MONITOR_REQ_PAM_INIT_CTX, MON_ISAUTH, mm_answer_pam_init_ctx}, {MONITOR_REQ_PAM_QUERY, MON_ISAUTH, mm_answer_pam_query}, {MONITOR_REQ_PAM_RESPOND, MON_ISAUTH, mm_answer_pam_respond}, {MONITOR_REQ_PAM_FREE_CTX, MON_ONCE\|MON_AUTHDECIDE, mm_answer_pam_free_ctx}, #endif #ifdef SSH_AUDIT_EVENTS {MONITOR_REQ_AUDIT_EVENT, MON_PERMIT, mm_answer_audit_event}, #endif #endif / WITH_SSH1 / {0, 0, NULL} }; struct mon_table mon_dispatch_postauth15[] = { #ifdef WITH_SSH1 {MONITOR_REQ_PTY, MON_ONCE, mm_answer_pty}, {MONITOR_REQ_PTYCLEANUP, MON_ONCE, mm_answer_pty_cleanup}, {MONITOR_REQ_TERM, 0, mm_answer_term}, #ifdef SSH_AUDIT_EVENTS {MONITOR_REQ_AUDIT_EVENT, MON_PERMIT, mm_answer_audit_event}, {MONITOR_REQ_AUDIT_COMMAND, MON_PERMIT\|MON_ONCE, mm_answer_audit_command}, #endif #endif / WITH_SSH1 / {0, 0, NULL} }; struct mon_table mon_dispatch; /* Specifies if a certain message is allowed at the moment / static void monitor_permit(struct mon_table ent, enum monitor_reqtype type, int permit) { while (ent->f != NULL) { if (ent->type == type) { ent->flags &= ~MON_PERMIT; ent->flags \|= permit ? MON_PERMIT : 0; return; } ent++; } } static void monitor_permit_authentications(int permit) { struct mon_table ent = mon_dispatch; while (ent->f != NULL) { if (ent->flags & MON_AUTH) { ent->flags &= ~MON_PERMIT; ent->flags \|= permit ? MON_PERMIT : 0; } ent++; } } void monitor_child_preauth(Authctxt _authctxt, struct monitor pmonitor) { struct mon_table ent; int authenticated = 0, partial = 0; debug3("preauth child monitor started"); close(pmonitor->m_recvfd); close(pmonitor->m_log_sendfd); pmonitor->m_log_sendfd = pmonitor->m_recvfd = -1; authctxt = _authctxt; memset(authctxt, 0, sizeof(authctxt)); authctxt->loginmsg = &loginmsg; if (compat20) { mon_dispatch = mon_dispatch_proto20; / Permit requests for moduli and signatures / monitor_permit(mon_dispatch, MONITOR_REQ_MODULI, 1); monitor_permit(mon_dispatch, MONITOR_REQ_SIGN, 1); } else { mon_dispatch = mon_dispatch_proto15; monitor_permit(mon_dispatch, MONITOR_REQ_SESSKEY, 1); } / The first few requests do not require asynchronous access / while (!authenticated) { partial = 0; auth_method = "unknown"; auth_submethod = NULL; authenticated = (monitor_read(pmonitor, mon_dispatch, &ent) == 1); / Special handling for multiple required authentications / if (options.num_auth_methods != 0) { if (!compat20) fatal("AuthenticationMethods is not supported" "with SSH protocol 1"); if (authenticated && !auth2_update_methods_lists(authctxt, auth_method, auth_submethod)) { debug3("%s: method %s: partial", __func__, auth_method); authenticated = 0; partial = 1; } } if (authenticated) { if (!(ent->flags & MON_AUTHDECIDE)) fatal("%s: unexpected authentication from %d", __func__, ent->type); if (authctxt->pw->pw_uid == 0 && !auth_root_allowed(auth_method)) authenticated = 0; #ifdef USE_PAM / PAM needs to perform account checks after auth / if (options.use_pam && authenticated) { Buffer m; buffer_init(&m); mm_request_receive_expect(pmonitor->m_sendfd, MONITOR_REQ_PAM_ACCOUNT, &m); authenticated = mm_answer_pam_account(pmonitor->m_sendfd, &m); buffer_free(&m); } #endif } if (ent->flags & (MON_AUTHDECIDE\|MON_ALOG)) { auth_log(authctxt, authenticated, partial, auth_method, auth_submethod); if (!partial && !authenticated) authctxt->failures++; } } if (!authctxt->valid) fatal("%s: authenticated invalid user", __func__); if (strcmp(auth_method, "unknown") == 0) fatal("%s: authentication method name unknown", __func__); debug("%s: %s has been authenticated by privileged process", __func__, authctxt->user); mm_get_keystate(pmonitor); / Drain any buffered messages from the child / while (pmonitor->m_log_recvfd != -1 && monitor_read_log(pmonitor) == 0) ; close(pmonitor->m_sendfd); close(pmonitor->m_log_recvfd); pmonitor->m_sendfd = pmonitor->m_log_recvfd = -1; } static void monitor_set_child_handler(pid_t pid) { monitor_child_pid = pid; } static void monitor_child_handler(int sig) { kill(monitor_child_pid, sig); } void monitor_child_postauth(struct monitor pmonitor) { close(pmonitor->m_recvfd); pmonitor->m_recvfd = -1; monitor_set_child_handler(pmonitor->m_pid); signal(SIGHUP, &monitor_child_handler); signal(SIGTERM, &monitor_child_handler); signal(SIGINT, &monitor_child_handler); #ifdef SIGXFSZ signal(SIGXFSZ, SIG_IGN); #endif if (compat20) { mon_dispatch = mon_dispatch_postauth20; /* Permit requests for moduli and signatures / monitor_permit(mon_dispatch, MONITOR_REQ_MODULI, 1); monitor_permit(mon_dispatch, MONITOR_REQ_SIGN, 1); monitor_permit(mon_dispatch, MONITOR_REQ_TERM, 1); } else { mon_dispatch = mon_dispatch_postauth15; monitor_permit(mon_dispatch, MONITOR_REQ_TERM, 1); } if (!no_pty_flag) { monitor_permit(mon_dispatch, MONITOR_REQ_PTY, 1); monitor_permit(mon_dispatch, MONITOR_REQ_PTYCLEANUP, 1); } for (;;) monitor_read(pmonitor, mon_dispatch, NULL); } void monitor_sync(struct monitor pmonitor) { if (options.compression) { /* The member allocation is not visible, so sync it / mm_share_sync(&pmonitor->m_zlib, &pmonitor->m_zback); } } / Allocation functions for zlib / static void mm_zalloc(struct mm_master mm, u_int ncount, u_int size) { size_t len = (size_t) size ncount; void address; if (len == 0 \|\| ncount > SIZE_MAX / size) fatal("%s: mm_zalloc(%u, %u)", __func__, ncount, size); address = mm_malloc(mm, len); return (address); } static void mm_zfree(struct mm_master mm, void address) { mm_free(mm, address); } static int monitor_read_log(struct monitor pmonitor) { Buffer logmsg; u_int len, level; char msg; buffer_init(&logmsg); / Read length / buffer_append_space(&logmsg, 4); if (atomicio(read, pmonitor->m_log_recvfd, buffer_ptr(&logmsg), buffer_len(&logmsg)) != buffer_len(&logmsg)) { if (errno == EPIPE) { buffer_free(&logmsg); debug("%s: child log fd closed", __func__); close(pmonitor->m_log_recvfd); pmonitor->m_log_recvfd = -1; return -1; } fatal("%s: log fd read: %s", __func__, strerror(errno)); } len = buffer_get_int(&logmsg); if (len <= 4 \|\| len > 8192) fatal("%s: invalid log message length %u", __func__, len); / Read severity, message / buffer_clear(&logmsg); buffer_append_space(&logmsg, len); if (atomicio(read, pmonitor->m_log_recvfd, buffer_ptr(&logmsg), buffer_len(&logmsg)) != buffer_len(&logmsg)) fatal("%s: log fd read: %s", __func__, strerror(errno)); / Log it / level = buffer_get_int(&logmsg); msg = buffer_get_string(&logmsg, NULL); if (log_level_name(level) == NULL) fatal("%s: invalid log level %u (corrupted message?)", __func__, level); do_log2(level, "%s [preauth]", msg); buffer_free(&logmsg); free(msg); return 0; } int monitor_read(struct monitor pmonitor, struct mon_table ent, struct mon_table pent) { Buffer m; int ret; u_char type; struct pollfd pfd[2]; for (;;) { memset(&pfd, 0, sizeof(pfd)); pfd[0].fd = pmonitor->m_sendfd; pfd[0].events = POLLIN; pfd[1].fd = pmonitor->m_log_recvfd; pfd[1].events = pfd[1].fd == -1 ? 0 : POLLIN; if (poll(pfd, pfd[1].fd == -1 ? 1 : 2, -1) == -1) { if (errno == EINTR \|\| errno == EAGAIN) continue; fatal("%s: poll: %s", __func__, strerror(errno)); } if (pfd[1].revents) { / * Drain all log messages before processing next * monitor request. / monitor_read_log(pmonitor); continue; } if (pfd[0].revents) break; / Continues below / } buffer_init(&m); mm_request_receive(pmonitor->m_sendfd, &m); type = buffer_get_char(&m); debug3("%s: checking request %d", __func__, type); while (ent->f != NULL) { if (ent->type == type) break; ent++; } if (ent->f != NULL) { if (!(ent->flags & MON_PERMIT)) fatal("%s: unpermitted request %d", __func__, type); ret = (ent->f)(pmonitor->m_sendfd, &m); buffer_free(&m); /* The child may use this request only once, disable it / if (ent->flags & MON_ONCE) { debug2("%s: %d used once, disabling now", __func__, type); ent->flags &= ~MON_PERMIT; } if (pent != NULL) pent = ent; return ret; } fatal("%s: unsupported request: %d", __func__, type); /* NOTREACHED / return (-1); } / allowed key state / static int monitor_allowed_key(u_char blob, u_int bloblen) { /* make sure key is allowed / if (key_blob == NULL \|\| key_bloblen != bloblen \|\| timingsafe_bcmp(key_blob, blob, key_bloblen)) return (0); return (1); } static void monitor_reset_key_state(void) { / reset state / free(key_blob); free(hostbased_cuser); free(hostbased_chost); key_blob = NULL; key_bloblen = 0; key_blobtype = MM_NOKEY; hostbased_cuser = NULL; hostbased_chost = NULL; } #ifdef WITH_OPENSSL int mm_answer_moduli(int sock, Buffer m) { DH dh; int min, want, max; min = buffer_get_int(m); want = buffer_get_int(m); max = buffer_get_int(m); debug3("%s: got parameters: %d %d %d", __func__, min, want, max); / We need to check here, too, in case the child got corrupted / if (max < min \|\| want < min \|\| max < want) fatal("%s: bad parameters: %d %d %d", __func__, min, want, max); buffer_clear(m); dh = choose_dh(min, want, max); if (dh == NULL) { buffer_put_char(m, 0); return (0); } else { / Send first bignum / buffer_put_char(m, 1); buffer_put_bignum2(m, dh->p); buffer_put_bignum2(m, dh->g); DH_free(dh); } mm_request_send(sock, MONITOR_ANS_MODULI, m); return (0); } #endif int mm_answer_sign(int sock, Buffer m) { struct ssh ssh = active_state; / XXX / extern int auth_sock; / XXX move to state struct? / struct sshkey key; struct sshbuf sigbuf; u_char p; u_char signature; size_t datlen, siglen; int r, keyid, is_proof = 0; const char proof_req[] = "hostkeys-prove-00@openssh.com"; debug3("%s", __func__); if ((r = sshbuf_get_u32(m, &keyid)) != 0 \|\| (r = sshbuf_get_string(m, &p, &datlen)) != 0) fatal("%s: buffer error: %s", __func__, ssh_err(r)); / * Supported KEX types use SHA1 (20 bytes), SHA256 (32 bytes), * SHA384 (48 bytes) and SHA512 (64 bytes). * * Otherwise, verify the signature request is for a hostkey * proof. * * XXX perform similar check for KEX signature requests too? * it's not trivial, since what is signed is the hash, rather * than the full kex structure... / if (datlen != 20 && datlen != 32 && datlen != 48 && datlen != 64) { / * Construct expected hostkey proof and compare it to what * the client sent us. / if (session_id2_len == 0) / hostkeys is never first / fatal("%s: bad data length: %zu", __func__, datlen); if ((key = get_hostkey_public_by_index(keyid, ssh)) == NULL) fatal("%s: no hostkey for index %d", __func__, keyid); if ((sigbuf = sshbuf_new()) == NULL) fatal("%s: sshbuf_new", __func__); if ((r = sshbuf_put_cstring(sigbuf, proof_req)) != 0 \|\| (r = sshbuf_put_string(sigbuf, session_id2, session_id2_len) != 0) \|\| (r = sshkey_puts(key, sigbuf)) != 0) fatal("%s: couldn't prepare private key " "proof buffer: %s", __func__, ssh_err(r)); if (datlen != sshbuf_len(sigbuf) \|\| memcmp(p, sshbuf_ptr(sigbuf), sshbuf_len(sigbuf)) != 0) fatal("%s: bad data length: %zu, hostkey proof len %zu", __func__, datlen, sshbuf_len(sigbuf)); sshbuf_free(sigbuf); is_proof = 1; } / save session id, it will be passed on the first call / if (session_id2_len == 0) { session_id2_len = datlen; session_id2 = xmalloc(session_id2_len); memcpy(session_id2, p, session_id2_len); } if ((key = get_hostkey_by_index(keyid)) != NULL) { if ((r = sshkey_sign(key, &signature, &siglen, p, datlen, datafellows)) != 0) fatal("%s: sshkey_sign failed: %s", __func__, ssh_err(r)); } else if ((key = get_hostkey_public_by_index(keyid, ssh)) != NULL && auth_sock > 0) { if ((r = ssh_agent_sign(auth_sock, key, &signature, &siglen, p, datlen, datafellows)) != 0) { fatal("%s: ssh_agent_sign failed: %s", __func__, ssh_err(r)); } } else fatal("%s: no hostkey from index %d", __func__, keyid); debug3("%s: %s signature %p(%zu)", __func__, is_proof ? "KEX" : "hostkey proof", signature, siglen); sshbuf_reset(m); if ((r = sshbuf_put_string(m, signature, siglen)) != 0) fatal("%s: buffer error: %s", __func__, ssh_err(r)); free(p); free(signature); mm_request_send(sock, MONITOR_ANS_SIGN, m); / Turn on permissions for getpwnam / monitor_permit(mon_dispatch, MONITOR_REQ_PWNAM, 1); return (0); } / Retrieves the password entry and also checks if the user is permitted / int mm_answer_pwnamallow(int sock, Buffer m) { char username; struct passwd pwent; int allowed = 0; u_int i; debug3("%s", __func__); if (authctxt->attempt++ != 0) fatal("%s: multiple attempts for getpwnam", __func__); username = buffer_get_string(m, NULL); pwent = getpwnamallow(username); authctxt->user = xstrdup(username); setproctitle("%s [priv]", pwent ? username : "unknown"); free(username); buffer_clear(m); if (pwent == NULL) { buffer_put_char(m, 0); authctxt->pw = fakepw(); goto out; } allowed = 1; authctxt->pw = pwent; authctxt->valid = 1; buffer_put_char(m, 1); buffer_put_string(m, pwent, sizeof(struct passwd)); buffer_put_cstring(m, pwent->pw_name); buffer_put_cstring(m, ""); #ifdef HAVE_STRUCT_PASSWD_PW_GECOS buffer_put_cstring(m, pwent->pw_gecos); #endif #ifdef HAVE_STRUCT_PASSWD_PW_CLASS buffer_put_cstring(m, pwent->pw_class); #endif buffer_put_cstring(m, pwent->pw_dir); buffer_put_cstring(m, pwent->pw_shell); out: buffer_put_string(m, &options, sizeof(options)); #define M_CP_STROPT(x) do { \ if (options.x != NULL) \ buffer_put_cstring(m, options.x); \ } while (0) #define M_CP_STRARRAYOPT(x, nx) do { \ for (i = 0; i < options.nx; i++) \ buffer_put_cstring(m, options.x[i]); \ } while (0) / See comment in servconf.h / COPY_MATCH_STRING_OPTS(); #undef M_CP_STROPT #undef M_CP_STRARRAYOPT / Create valid auth method lists / if (compat20 && auth2_setup_methods_lists(authctxt) != 0) { / * The monitor will continue long enough to let the child * run to it's packet_disconnect(), but it must not allow any * authentication to succeed. / debug("%s: no valid authentication method lists", __func__); } debug3("%s: sending MONITOR_ANS_PWNAM: %d", __func__, allowed); mm_request_send(sock, MONITOR_ANS_PWNAM, m); / For SSHv1 allow authentication now / if (!compat20) monitor_permit_authentications(1); else { / Allow service/style information on the auth context / monitor_permit(mon_dispatch, MONITOR_REQ_AUTHSERV, 1); monitor_permit(mon_dispatch, MONITOR_REQ_AUTH2_READ_BANNER, 1); } #ifdef USE_PAM if (options.use_pam) monitor_permit(mon_dispatch, MONITOR_REQ_PAM_START, 1); #endif return (0); } int mm_answer_auth2_read_banner(int sock, Buffer m) { char banner; buffer_clear(m); banner = auth2_read_banner(); buffer_put_cstring(m, banner != NULL ? banner : ""); mm_request_send(sock, MONITOR_ANS_AUTH2_READ_BANNER, m); free(banner); return (0); } int mm_answer_authserv(int sock, Buffer m) { monitor_permit_authentications(1); authctxt->service = buffer_get_string(m, NULL); authctxt->style = buffer_get_string(m, NULL); debug3("%s: service=%s, style=%s", __func__, authctxt->service, authctxt->style); if (strlen(authctxt->style) == 0) { free(authctxt->style); authctxt->style = NULL; } return (0); } int mm_answer_authpassword(int sock, Buffer m) { static int call_count; char passwd; int authenticated; u_int plen; passwd = buffer_get_string(m, &plen); /* Only authenticate if the context is valid / authenticated = options.password_authentication && auth_password(authctxt, passwd); explicit_bzero(passwd, strlen(passwd)); free(passwd); buffer_clear(m); buffer_put_int(m, authenticated); debug3("%s: sending result %d", __func__, authenticated); mm_request_send(sock, MONITOR_ANS_AUTHPASSWORD, m); call_count++; if (plen == 0 && call_count == 1) auth_method = "none"; else auth_method = "password"; / Causes monitor loop to terminate if authenticated / return (authenticated); } #ifdef BSD_AUTH int mm_answer_bsdauthquery(int sock, Buffer m) { char name, infotxt; u_int numprompts; u_int echo_on; char prompts; u_int success; success = bsdauth_query(authctxt, &name, &infotxt, &numprompts, &prompts, &echo_on) < 0 ? 0 : 1; buffer_clear(m); buffer_put_int(m, success); if (success) buffer_put_cstring(m, prompts[0]); debug3("%s: sending challenge success: %u", __func__, success); mm_request_send(sock, MONITOR_ANS_BSDAUTHQUERY, m); if (success) { free(name); free(infotxt); free(prompts); free(echo_on); } return (0); } int mm_answer_bsdauthrespond(int sock, Buffer m) { char response; int authok; if (authctxt->as == 0) fatal("%s: no bsd auth session", __func__); response = buffer_get_string(m, NULL); authok = options.challenge_response_authentication && auth_userresponse(authctxt->as, response, 0); authctxt->as = NULL; debug3("%s: <%s> = <%d>", __func__, response, authok); free(response); buffer_clear(m); buffer_put_int(m, authok); debug3("%s: sending authenticated: %d", __func__, authok); mm_request_send(sock, MONITOR_ANS_BSDAUTHRESPOND, m); if (compat20) { auth_method = "keyboard-interactive"; auth_submethod = "bsdauth"; } else auth_method = "bsdauth"; return (authok != 0); } #endif #ifdef SKEY int mm_answer_skeyquery(int sock, Buffer m) { struct skey skey; char challenge[1024]; u_int success; success = _compat_skeychallenge(&skey, authctxt->user, challenge, sizeof(challenge)) < 0 ? 0 : 1; buffer_clear(m); buffer_put_int(m, success); if (success) buffer_put_cstring(m, challenge); debug3("%s: sending challenge success: %u", __func__, success); mm_request_send(sock, MONITOR_ANS_SKEYQUERY, m); return (0); } int mm_answer_skeyrespond(int sock, Buffer m) { char response; int authok; response = buffer_get_string(m, NULL); authok = (options.challenge_response_authentication && authctxt->valid && skey_haskey(authctxt->pw->pw_name) == 0 && skey_passcheck(authctxt->pw->pw_name, response) != -1); free(response); buffer_clear(m); buffer_put_int(m, authok); debug3("%s: sending authenticated: %d", __func__, authok); mm_request_send(sock, MONITOR_ANS_SKEYRESPOND, m); auth_method = "skey"; return (authok != 0); } #endif #ifdef USE_PAM int mm_answer_pam_start(int sock, Buffer m) { if (!options.use_pam) fatal("UsePAM not set, but ended up in %s anyway", __func__); start_pam(authctxt); monitor_permit(mon_dispatch, MONITOR_REQ_PAM_ACCOUNT, 1); return (0); } int mm_answer_pam_account(int sock, Buffer m) { u_int ret; if (!options.use_pam) fatal("UsePAM not set, but ended up in %s anyway", __func__); ret = do_pam_account(); buffer_put_int(m, ret); buffer_put_string(m, buffer_ptr(&loginmsg), buffer_len(&loginmsg)); mm_request_send(sock, MONITOR_ANS_PAM_ACCOUNT, m); return (ret); } static void sshpam_ctxt, sshpam_authok; extern KbdintDevice sshpam_device; int mm_answer_pam_init_ctx(int sock, Buffer m) { debug3("%s", __func__); sshpam_ctxt = (sshpam_device.init_ctx)(authctxt); sshpam_authok = NULL; buffer_clear(m); if (sshpam_ctxt != NULL) { monitor_permit(mon_dispatch, MONITOR_REQ_PAM_FREE_CTX, 1); buffer_put_int(m, 1); } else { buffer_put_int(m, 0); } mm_request_send(sock, MONITOR_ANS_PAM_INIT_CTX, m); return (0); } int mm_answer_pam_query(int sock, Buffer m) { char name = NULL, info = NULL, *prompts = NULL; u_int i, num = 0, echo_on = 0; int ret; debug3("%s", __func__); sshpam_authok = NULL; ret = (sshpam_device.query)(sshpam_ctxt, &name, &info, &num, &prompts, &echo_on); if (ret == 0 && num == 0) sshpam_authok = sshpam_ctxt; if (num > 1 \|\| name == NULL \|\| info == NULL) ret = -1; buffer_clear(m); buffer_put_int(m, ret); buffer_put_cstring(m, name); free(name); buffer_put_cstring(m, info); free(info); buffer_put_int(m, num); for (i = 0; i < num; ++i) { buffer_put_cstring(m, prompts[i]); free(prompts[i]); buffer_put_int(m, echo_on[i]); } free(prompts); free(echo_on); auth_method = "keyboard-interactive"; auth_submethod = "pam"; mm_request_send(sock, MONITOR_ANS_PAM_QUERY, m); return (0); } int mm_answer_pam_respond(int sock, Buffer m) { char resp; u_int i, num; int ret; debug3("%s", __func__); sshpam_authok = NULL; num = buffer_get_int(m); if (num > 0) { resp = xcalloc(num, sizeof(char )); for (i = 0; i < num; ++i) resp[i] = buffer_get_string(m, NULL); ret = (sshpam_device.respond)(sshpam_ctxt, num, resp); for (i = 0; i < num; ++i) free(resp[i]); free(resp); } else { ret = (sshpam_device.respond)(sshpam_ctxt, num, NULL); } buffer_clear(m); buffer_put_int(m, ret); mm_request_send(sock, MONITOR_ANS_PAM_RESPOND, m); auth_method = "keyboard-interactive"; auth_submethod = "pam"; if (ret == 0) sshpam_authok = sshpam_ctxt; return (0); } int mm_answer_pam_free_ctx(int sock, Buffer m) { debug3("%s", __func__); (sshpam_device.free_ctx)(sshpam_ctxt); buffer_clear(m); mm_request_send(sock, MONITOR_ANS_PAM_FREE_CTX, m); auth_method = "keyboard-interactive"; auth_submethod = "pam"; return (sshpam_authok == sshpam_ctxt); } #endif int mm_answer_keyallowed(int sock, Buffer m) { Key key; char cuser, chost; u_char blob; u_int bloblen, pubkey_auth_attempt; enum mm_keytype type = 0; int allowed = 0; debug3("%s entering", __func__); type = buffer_get_int(m); cuser = buffer_get_string(m, NULL); chost = buffer_get_string(m, NULL); blob = buffer_get_string(m, &bloblen); pubkey_auth_attempt = buffer_get_int(m); key = key_from_blob(blob, bloblen); if ((compat20 && type == MM_RSAHOSTKEY) \|\| (!compat20 && type != MM_RSAHOSTKEY)) fatal("%s: key type and protocol mismatch", __func__); debug3("%s: key_from_blob: %p", __func__, key); if (key != NULL && authctxt->valid) { /* These should not make it past the privsep child / if (key_type_plain(key->type) == KEY_RSA && (datafellows & SSH_BUG_RSASIGMD5) != 0) fatal("%s: passed a SSH_BUG_RSASIGMD5 key", __func__); switch (type) { case MM_USERKEY: allowed = options.pubkey_authentication && !auth2_userkey_already_used(authctxt, key) && match_pattern_list(sshkey_ssh_name(key), options.pubkey_key_types, 0) == 1 && user_key_allowed(authctxt->pw, key, pubkey_auth_attempt); pubkey_auth_info(authctxt, key, NULL); auth_method = "publickey"; if (options.pubkey_authentication && (!pubkey_auth_attempt \|\| allowed != 1)) auth_clear_options(); break; case MM_HOSTKEY: allowed = options.hostbased_authentication && match_pattern_list(sshkey_ssh_name(key), options.hostbased_key_types, 0) == 1 && hostbased_key_allowed(authctxt->pw, cuser, chost, key); pubkey_auth_info(authctxt, key, "client user \"%.100s\", client host \"%.100s\"", cuser, chost); auth_method = "hostbased"; break; #ifdef WITH_SSH1 case MM_RSAHOSTKEY: key->type = KEY_RSA1; / XXX / allowed = options.rhosts_rsa_authentication && auth_rhosts_rsa_key_allowed(authctxt->pw, cuser, chost, key); if (options.rhosts_rsa_authentication && allowed != 1) auth_clear_options(); auth_method = "rsa"; break; #endif default: fatal("%s: unknown key type %d", __func__, type); break; } } if (key != NULL) key_free(key); / clear temporarily storage (used by verify) / monitor_reset_key_state(); if (allowed) { / Save temporarily for comparison in verify / key_blob = blob; key_bloblen = bloblen; key_blobtype = type; hostbased_cuser = cuser; hostbased_chost = chost; } else { / Log failed attempt / auth_log(authctxt, 0, 0, auth_method, NULL); free(blob); free(cuser); free(chost); } debug3("%s: key %p is %s", __func__, key, allowed ? "allowed" : "not allowed"); buffer_clear(m); buffer_put_int(m, allowed); buffer_put_int(m, forced_command != NULL); mm_request_send(sock, MONITOR_ANS_KEYALLOWED, m); if (type == MM_RSAHOSTKEY) monitor_permit(mon_dispatch, MONITOR_REQ_RSACHALLENGE, allowed); return (0); } static int monitor_valid_userblob(u_char data, u_int datalen) { Buffer b; char p, userstyle; u_int len; int fail = 0; buffer_init(&b); buffer_append(&b, data, datalen); if (datafellows & SSH_OLD_SESSIONID) { p = buffer_ptr(&b); len = buffer_len(&b); if ((session_id2 == NULL) \|\| (len < session_id2_len) \|\| (timingsafe_bcmp(p, session_id2, session_id2_len) != 0)) fail++; buffer_consume(&b, session_id2_len); } else { p = buffer_get_string(&b, &len); if ((session_id2 == NULL) \|\| (len != session_id2_len) \|\| (timingsafe_bcmp(p, session_id2, session_id2_len) != 0)) fail++; free(p); } if (buffer_get_char(&b) != SSH2_MSG_USERAUTH_REQUEST) fail++; p = buffer_get_cstring(&b, NULL); xasprintf(&userstyle, "%s%s%s", authctxt->user, authctxt->style ? ":" : "", authctxt->style ? authctxt->style : ""); if (strcmp(userstyle, p) != 0) { logit("wrong user name passed to monitor: expected %s != %.100s", userstyle, p); fail++; } free(userstyle); free(p); buffer_skip_string(&b); if (datafellows & SSH_BUG_PKAUTH) { if (!buffer_get_char(&b)) fail++; } else { p = buffer_get_cstring(&b, NULL); if (strcmp("publickey", p) != 0) fail++; free(p); if (!buffer_get_char(&b)) fail++; buffer_skip_string(&b); } buffer_skip_string(&b); if (buffer_len(&b) != 0) fail++; buffer_free(&b); return (fail == 0); } static int monitor_valid_hostbasedblob(u_char data, u_int datalen, char cuser, char chost) { Buffer b; char p, userstyle; u_int len; int fail = 0; buffer_init(&b); buffer_append(&b, data, datalen); p = buffer_get_string(&b, &len); if ((session_id2 == NULL) \|\| (len != session_id2_len) \|\| (timingsafe_bcmp(p, session_id2, session_id2_len) != 0)) fail++; free(p); if (buffer_get_char(&b) != SSH2_MSG_USERAUTH_REQUEST) fail++; p = buffer_get_cstring(&b, NULL); xasprintf(&userstyle, "%s%s%s", authctxt->user, authctxt->style ? ":" : "", authctxt->style ? authctxt->style : ""); if (strcmp(userstyle, p) != 0) { logit("wrong user name passed to monitor: expected %s != %.100s", userstyle, p); fail++; } free(userstyle); free(p); buffer_skip_string(&b); / service / p = buffer_get_cstring(&b, NULL); if (strcmp(p, "hostbased") != 0) fail++; free(p); buffer_skip_string(&b); / pkalg / buffer_skip_string(&b); / pkblob / / verify client host, strip trailing dot if necessary / p = buffer_get_string(&b, NULL); if (((len = strlen(p)) > 0) && p[len - 1] == '.') p[len - 1] = '\0'; if (strcmp(p, chost) != 0) fail++; free(p); / verify client user / p = buffer_get_string(&b, NULL); if (strcmp(p, cuser) != 0) fail++; free(p); if (buffer_len(&b) != 0) fail++; buffer_free(&b); return (fail == 0); } int mm_answer_keyverify(int sock, Buffer m) { Key key; u_char signature, data, blob; u_int signaturelen, datalen, bloblen; int verified = 0; int valid_data = 0; blob = buffer_get_string(m, &bloblen); signature = buffer_get_string(m, &signaturelen); data = buffer_get_string(m, &datalen); if (hostbased_cuser == NULL \|\| hostbased_chost == NULL \|\| !monitor_allowed_key(blob, bloblen)) fatal("%s: bad key, not previously allowed", __func__); key = key_from_blob(blob, bloblen); if (key == NULL) fatal("%s: bad public key blob", __func__); switch (key_blobtype) { case MM_USERKEY: valid_data = monitor_valid_userblob(data, datalen); break; case MM_HOSTKEY: valid_data = monitor_valid_hostbasedblob(data, datalen, hostbased_cuser, hostbased_chost); break; default: valid_data = 0; break; } if (!valid_data) fatal("%s: bad signature data blob", __func__); verified = key_verify(key, signature, signaturelen, data, datalen); debug3("%s: key %p signature %s", __func__, key, (verified == 1) ? "verified" : "unverified"); /* If auth was successful then record key to ensure it isn't reused / if (verified == 1) auth2_record_userkey(authctxt, key); else key_free(key); free(blob); free(signature); free(data); auth_method = key_blobtype == MM_USERKEY ? "publickey" : "hostbased"; monitor_reset_key_state(); buffer_clear(m); buffer_put_int(m, verified); mm_request_send(sock, MONITOR_ANS_KEYVERIFY, m); return (verified == 1); } static void mm_record_login(Session s, struct passwd pw) { socklen_t fromlen; struct sockaddr_storage from; if (options.use_login) return; / * Get IP address of client. If the connection is not a socket, let * the address be 0.0.0.0. / memset(&from, 0, sizeof(from)); fromlen = sizeof(from); if (packet_connection_is_on_socket()) { if (getpeername(packet_get_connection_in(), (struct sockaddr )&from, &fromlen) < 0) { debug("getpeername: %.100s", strerror(errno)); cleanup_exit(255); } } /* Record that there was a login on that tty from the remote host. / record_login(s->pid, s->tty, pw->pw_name, pw->pw_uid, get_remote_name_or_ip(utmp_len, options.use_dns), (struct sockaddr )&from, fromlen); } static void mm_session_close(Session s) { debug3("%s: session %d pid %ld", __func__, s->self, (long)s->pid); if (s->ttyfd != -1) { debug3("%s: tty %s ptyfd %d", __func__, s->tty, s->ptyfd); session_pty_cleanup2(s); } session_unused(s->self); } int mm_answer_pty(int sock, Buffer m) { extern struct monitor pmonitor; Session s; int res, fd0; debug3("%s entering", __func__); buffer_clear(m); s = session_new(); if (s == NULL) goto error; s->authctxt = authctxt; s->pw = authctxt->pw; s->pid = pmonitor->m_pid; res = pty_allocate(&s->ptyfd, &s->ttyfd, s->tty, sizeof(s->tty)); if (res == 0) goto error; pty_setowner(authctxt->pw, s->tty); buffer_put_int(m, 1); buffer_put_cstring(m, s->tty); /* We need to trick ttyslot / if (dup2(s->ttyfd, 0) == -1) fatal("%s: dup2", __func__); mm_record_login(s, authctxt->pw); / Now we can close the file descriptor again / close(0); / send messages generated by record_login / buffer_put_string(m, buffer_ptr(&loginmsg), buffer_len(&loginmsg)); buffer_clear(&loginmsg); mm_request_send(sock, MONITOR_ANS_PTY, m); if (mm_send_fd(sock, s->ptyfd) == -1 \|\| mm_send_fd(sock, s->ttyfd) == -1) fatal("%s: send fds failed", __func__); / make sure nothing uses fd 0 / if ((fd0 = open(_PATH_DEVNULL, O_RDONLY)) < 0) fatal("%s: open(/dev/null): %s", __func__, strerror(errno)); if (fd0 != 0) error("%s: fd0 %d != 0", __func__, fd0); / slave is not needed / close(s->ttyfd); s->ttyfd = s->ptyfd; / no need to dup() because nobody closes ptyfd / s->ptymaster = s->ptyfd; debug3("%s: tty %s ptyfd %d", __func__, s->tty, s->ttyfd); return (0); error: if (s != NULL) mm_session_close(s); buffer_put_int(m, 0); mm_request_send(sock, MONITOR_ANS_PTY, m); return (0); } int mm_answer_pty_cleanup(int sock, Buffer m) { Session s; char tty; debug3("%s entering", __func__); tty = buffer_get_string(m, NULL); if ((s = session_by_tty(tty)) != NULL) mm_session_close(s); buffer_clear(m); free(tty); return (0); } #ifdef WITH_SSH1 int mm_answer_sesskey(int sock, Buffer m) { BIGNUM p; int rsafail; /* Turn off permissions / monitor_permit(mon_dispatch, MONITOR_REQ_SESSKEY, 0); if ((p = BN_new()) == NULL) fatal("%s: BN_new", __func__); buffer_get_bignum2(m, p); rsafail = ssh1_session_key(p); buffer_clear(m); buffer_put_int(m, rsafail); buffer_put_bignum2(m, p); BN_clear_free(p); mm_request_send(sock, MONITOR_ANS_SESSKEY, m); / Turn on permissions for sessid passing / monitor_permit(mon_dispatch, MONITOR_REQ_SESSID, 1); return (0); } int mm_answer_sessid(int sock, Buffer m) { int i; debug3("%s entering", __func__); if (buffer_len(m) != 16) fatal("%s: bad ssh1 session id", __func__); for (i = 0; i < 16; i++) session_id[i] = buffer_get_char(m); /* Turn on permissions for getpwnam / monitor_permit(mon_dispatch, MONITOR_REQ_PWNAM, 1); return (0); } int mm_answer_rsa_keyallowed(int sock, Buffer m) { BIGNUM client_n; Key key = NULL; u_char blob = NULL; u_int blen = 0; int allowed = 0; debug3("%s entering", __func__); auth_method = "rsa"; if (options.rsa_authentication && authctxt->valid) { if ((client_n = BN_new()) == NULL) fatal("%s: BN_new", __func__); buffer_get_bignum2(m, client_n); allowed = auth_rsa_key_allowed(authctxt->pw, client_n, &key); BN_clear_free(client_n); } buffer_clear(m); buffer_put_int(m, allowed); buffer_put_int(m, forced_command != NULL); / clear temporarily storage (used by generate challenge) / monitor_reset_key_state(); if (allowed && key != NULL) { key->type = KEY_RSA; / cheat for key_to_blob / if (key_to_blob(key, &blob, &blen) == 0) fatal("%s: key_to_blob failed", __func__); buffer_put_string(m, blob, blen); / Save temporarily for comparison in verify / key_blob = blob; key_bloblen = blen; key_blobtype = MM_RSAUSERKEY; } if (key != NULL) key_free(key); mm_request_send(sock, MONITOR_ANS_RSAKEYALLOWED, m); monitor_permit(mon_dispatch, MONITOR_REQ_RSACHALLENGE, allowed); monitor_permit(mon_dispatch, MONITOR_REQ_RSARESPONSE, 0); return (0); } int mm_answer_rsa_challenge(int sock, Buffer m) { Key key = NULL; u_char blob; u_int blen; debug3("%s entering", __func__); if (!authctxt->valid) fatal("%s: authctxt not valid", __func__); blob = buffer_get_string(m, &blen); if (!monitor_allowed_key(blob, blen)) fatal("%s: bad key, not previously allowed", __func__); if (key_blobtype != MM_RSAUSERKEY && key_blobtype != MM_RSAHOSTKEY) fatal("%s: key type mismatch", __func__); if ((key = key_from_blob(blob, blen)) == NULL) fatal("%s: received bad key", __func__); if (key->type != KEY_RSA) fatal("%s: received bad key type %d", __func__, key->type); key->type = KEY_RSA1; if (ssh1_challenge) BN_clear_free(ssh1_challenge); ssh1_challenge = auth_rsa_generate_challenge(key); buffer_clear(m); buffer_put_bignum2(m, ssh1_challenge); debug3("%s sending reply", __func__); mm_request_send(sock, MONITOR_ANS_RSACHALLENGE, m); monitor_permit(mon_dispatch, MONITOR_REQ_RSARESPONSE, 1); free(blob); key_free(key); return (0); } int mm_answer_rsa_response(int sock, Buffer m) { Key key = NULL; u_char blob, response; u_int blen, len; int success; debug3("%s entering", __func__); if (!authctxt->valid) fatal("%s: authctxt not valid", __func__); if (ssh1_challenge == NULL) fatal("%s: no ssh1_challenge", __func__); blob = buffer_get_string(m, &blen); if (!monitor_allowed_key(blob, blen)) fatal("%s: bad key, not previously allowed", __func__); if (key_blobtype != MM_RSAUSERKEY && key_blobtype != MM_RSAHOSTKEY) fatal("%s: key type mismatch: %d", __func__, key_blobtype); if ((key = key_from_blob(blob, blen)) == NULL) fatal("%s: received bad key", __func__); response = buffer_get_string(m, &len); if (len != 16) fatal("%s: received bad response to challenge", __func__); success = auth_rsa_verify_response(key, ssh1_challenge, response); free(blob); key_free(key); free(response); auth_method = key_blobtype == MM_RSAUSERKEY ? "rsa" : "rhosts-rsa"; /* reset state / BN_clear_free(ssh1_challenge); ssh1_challenge = NULL; monitor_reset_key_state(); buffer_clear(m); buffer_put_int(m, success); mm_request_send(sock, MONITOR_ANS_RSARESPONSE, m); return (success); } #endif int mm_answer_term(int sock, Buffer req) { extern struct monitor pmonitor; int res, status; debug3("%s: tearing down sessions", __func__); / The child is terminating / session_destroy_all(&mm_session_close); #ifdef USE_PAM if (options.use_pam) sshpam_cleanup(); #endif while (waitpid(pmonitor->m_pid, &status, 0) == -1) if (errno != EINTR) exit(1); res = WIFEXITED(status) ? WEXITSTATUS(status) : 1; / Terminate process / exit(res); } #ifdef SSH_AUDIT_EVENTS / Report that an audit event occurred / int mm_answer_audit_event(int socket, Buffer m) { ssh_audit_event_t event; debug3("%s entering", __func__); event = buffer_get_int(m); switch(event) { case SSH_AUTH_FAIL_PUBKEY: case SSH_AUTH_FAIL_HOSTBASED: case SSH_AUTH_FAIL_GSSAPI: case SSH_LOGIN_EXCEED_MAXTRIES: case SSH_LOGIN_ROOT_DENIED: case SSH_CONNECTION_CLOSE: case SSH_INVALID_USER: audit_event(event); break; default: fatal("Audit event type %d not permitted", event); } return (0); } int mm_answer_audit_command(int socket, Buffer m) { u_int len; char cmd; debug3("%s entering", __func__); cmd = buffer_get_string(m, &len); /* sanity check command, if so how? / audit_run_command(cmd); free(cmd); return (0); } #endif / SSH_AUDIT_EVENTS / void monitor_apply_keystate(struct monitor pmonitor) { struct ssh ssh = active_state; / XXX / struct kex kex; int r; debug3("%s: packet_set_state", __func__); if ((r = ssh_packet_set_state(ssh, child_state)) != 0) fatal("%s: packet_set_state: %s", __func__, ssh_err(r)); sshbuf_free(child_state); child_state = NULL; if ((kex = ssh->kex) != 0) { /* XXX set callbacks / #ifdef WITH_OPENSSL kex->kex[KEX_DH_GRP1_SHA1] = kexdh_server; kex->kex[KEX_DH_GRP14_SHA1] = kexdh_server; kex->kex[KEX_DH_GEX_SHA1] = kexgex_server; kex->kex[KEX_DH_GEX_SHA256] = kexgex_server; # ifdef OPENSSL_HAS_ECC kex->kex[KEX_ECDH_SHA2] = kexecdh_server; # endif #endif / WITH_OPENSSL / kex->kex[KEX_C25519_SHA256] = kexc25519_server; kex->load_host_public_key=&get_hostkey_public_by_type; kex->load_host_private_key=&get_hostkey_private_by_type; kex->host_key_index=&get_hostkey_index; kex->sign = sshd_hostkey_sign; } / Update with new address / if (options.compression) { ssh_packet_set_compress_hooks(ssh, pmonitor->m_zlib, (ssh_packet_comp_alloc_func )mm_zalloc, (ssh_packet_comp_free_func )mm_zfree); } } / This function requries careful sanity checking / void mm_get_keystate(struct monitor pmonitor) { debug3("%s: Waiting for new keys", __func__); if ((child_state = sshbuf_new()) == NULL) fatal("%s: sshbuf_new failed", __func__); mm_request_receive_expect(pmonitor->m_sendfd, MONITOR_REQ_KEYEXPORT, child_state); debug3("%s: GOT new keys", __func__); } /* XXX / #define FD_CLOSEONEXEC(x) do { \ if (fcntl(x, F_SETFD, FD_CLOEXEC) == -1) \ fatal("fcntl(%d, F_SETFD)", x); \ } while (0) static void monitor_openfds(struct monitor mon, int do_logfds) { int pair[2]; if (socketpair(AF_UNIX, SOCK_STREAM, 0, pair) == -1) fatal("%s: socketpair: %s", __func__, strerror(errno)); FD_CLOSEONEXEC(pair[0]); FD_CLOSEONEXEC(pair[1]); mon->m_recvfd = pair[0]; mon->m_sendfd = pair[1]; if (do_logfds) { if (pipe(pair) == -1) fatal("%s: pipe: %s", __func__, strerror(errno)); FD_CLOSEONEXEC(pair[0]); FD_CLOSEONEXEC(pair[1]); mon->m_log_recvfd = pair[0]; mon->m_log_sendfd = pair[1]; } else mon->m_log_recvfd = mon->m_log_sendfd = -1; } #define MM_MEMSIZE 65536 struct monitor * monitor_init(void) { struct ssh ssh = active_state; / XXX / struct monitor mon; mon = xcalloc(1, sizeof(mon)); monitor_openfds(mon, 1); / Used to share zlib space across processes / if (options.compression) { mon->m_zback = mm_create(NULL, MM_MEMSIZE); mon->m_zlib = mm_create(mon->m_zback, 20 MM_MEMSIZE); /* Compression needs to share state across borders / ssh_packet_set_compress_hooks(ssh, mon->m_zlib, (ssh_packet_comp_alloc_func )mm_zalloc, (ssh_packet_comp_free_func )mm_zfree); } return mon; } void monitor_reinit(struct monitor mon) { monitor_openfds(mon, 0); } #ifdef GSSAPI int mm_answer_gss_setup_ctx(int sock, Buffer m) { gss_OID_desc goid; OM_uint32 major; u_int len; goid.elements = buffer_get_string(m, &len); goid.length = len; major = ssh_gssapi_server_ctx(&gsscontext, &goid); free(goid.elements); buffer_clear(m); buffer_put_int(m, major); mm_request_send(sock, MONITOR_ANS_GSSSETUP, m); / Now we have a context, enable the step / monitor_permit(mon_dispatch, MONITOR_REQ_GSSSTEP, 1); return (0); } int mm_answer_gss_accept_ctx(int sock, Buffer m) { gss_buffer_desc in; gss_buffer_desc out = GSS_C_EMPTY_BUFFER; OM_uint32 major, minor; OM_uint32 flags = 0; /* GSI needs this / u_int len; in.value = buffer_get_string(m, &len); in.length = len; major = ssh_gssapi_accept_ctx(gsscontext, &in, &out, &flags); free(in.value); buffer_clear(m); buffer_put_int(m, major); buffer_put_string(m, out.value, out.length); buffer_put_int(m, flags); mm_request_send(sock, MONITOR_ANS_GSSSTEP, m); gss_release_buffer(&minor, &out); if (major == GSS_S_COMPLETE) { monitor_permit(mon_dispatch, MONITOR_REQ_GSSSTEP, 0); monitor_permit(mon_dispatch, MONITOR_REQ_GSSUSEROK, 1); monitor_permit(mon_dispatch, MONITOR_REQ_GSSCHECKMIC, 1); } return (0); } int mm_answer_gss_checkmic(int sock, Buffer m) { gss_buffer_desc gssbuf, mic; OM_uint32 ret; u_int len; gssbuf.value = buffer_get_string(m, &len); gssbuf.length = len; mic.value = buffer_get_string(m, &len); mic.length = len; ret = ssh_gssapi_checkmic(gsscontext, &gssbuf, &mic); free(gssbuf.value); free(mic.value); buffer_clear(m); buffer_put_int(m, ret); mm_request_send(sock, MONITOR_ANS_GSSCHECKMIC, m); if (!GSS_ERROR(ret)) monitor_permit(mon_dispatch, MONITOR_REQ_GSSUSEROK, 1); return (0); } int mm_answer_gss_userok(int sock, Buffer m) { int authenticated; authenticated = authctxt->valid && ssh_gssapi_userok(authctxt->user); buffer_clear(m); buffer_put_int(m, authenticated); debug3("%s: sending result %d", __func__, authenticated); mm_request_send(sock, MONITOR_ANS_GSSUSEROK, m); auth_method = "gssapi-with-mic"; / Monitor loop will terminate if authenticated / return (authenticated); } #endif / GSSAPI */	./CrossVul/dataset_final_sorted/CWE-264/c/bad_1719_0
crossvul-cpp_data_good_3517_0	/* * sysctl.c: General linux system control interface * * Begun 24 March 1995, Stephen Tweedie * Added /proc support, Dec 1995 * Added bdflush entry and intvec min/max checking, 2/23/96, Tom Dyas. * Added hooks for /proc/sys/net (minor, minor patch), 96/4/1, Mike Shaver. * Added kernel/java-{interpreter,appletviewer}, 96/5/10, Mike Shaver. * Dynamic registration fixes, Stephen Tweedie. * Added kswapd-interval, ctrl-alt-del, printk stuff, 1/8/97, Chris Horn. * Made sysctl support optional via CONFIG_SYSCTL, 1/10/97, Chris * Horn. * Added proc_doulongvec_ms_jiffies_minmax, 09/08/99, Carlos H. Bauer. * Added proc_doulongvec_minmax, 09/08/99, Carlos H. Bauer. * Changed linked lists to use list.h instead of lists.h, 02/24/00, Bill * Wendling. * The list_for_each() macro wasn't appropriate for the sysctl loop. * Removed it and replaced it with older style, 03/23/00, Bill Wendling / #include <linux/module.h> #include <linux/mm.h> #include <linux/swap.h> #include <linux/slab.h> #include <linux/sysctl.h> #include <linux/signal.h> #include <linux/printk.h> #include <linux/proc_fs.h> #include <linux/security.h> #include <linux/ctype.h> #include <linux/kmemcheck.h> #include <linux/fs.h> #include <linux/init.h> #include <linux/kernel.h> #include <linux/kobject.h> #include <linux/net.h> #include <linux/sysrq.h> #include <linux/highuid.h> #include <linux/writeback.h> #include <linux/ratelimit.h> #include <linux/compaction.h> #include <linux/hugetlb.h> #include <linux/initrd.h> #include <linux/key.h> #include <linux/times.h> #include <linux/limits.h> #include <linux/dcache.h> #include <linux/dnotify.h> #include <linux/syscalls.h> #include <linux/vmstat.h> #include <linux/nfs_fs.h> #include <linux/acpi.h> #include <linux/reboot.h> #include <linux/ftrace.h> #include <linux/perf_event.h> #include <linux/kprobes.h> #include <linux/pipe_fs_i.h> #include <linux/oom.h> #include <asm/uaccess.h> #include <asm/processor.h> #ifdef CONFIG_X86 #include <asm/nmi.h> #include <asm/stacktrace.h> #include <asm/io.h> #endif #ifdef CONFIG_BSD_PROCESS_ACCT #include <linux/acct.h> #endif #ifdef CONFIG_RT_MUTEXES #include <linux/rtmutex.h> #endif #if defined(CONFIG_PROVE_LOCKING) \|\| defined(CONFIG_LOCK_STAT) #include <linux/lockdep.h> #endif #ifdef CONFIG_CHR_DEV_SG #include <scsi/sg.h> #endif #ifdef CONFIG_LOCKUP_DETECTOR #include <linux/nmi.h> #endif #if defined(CONFIG_SYSCTL) / External variables not in a header file. / extern int sysctl_overcommit_memory; extern int sysctl_overcommit_ratio; extern int max_threads; extern int core_uses_pid; extern int suid_dumpable; extern char core_pattern[]; extern unsigned int core_pipe_limit; extern int pid_max; extern int min_free_kbytes; extern int pid_max_min, pid_max_max; extern int sysctl_drop_caches; extern int percpu_pagelist_fraction; extern int compat_log; extern int latencytop_enabled; extern int sysctl_nr_open_min, sysctl_nr_open_max; #ifndef CONFIG_MMU extern int sysctl_nr_trim_pages; #endif #ifdef CONFIG_BLOCK extern int blk_iopoll_enabled; #endif / Constants used for minimum and maximum / #ifdef CONFIG_LOCKUP_DETECTOR static int sixty = 60; static int neg_one = -1; #endif static int zero; static int __maybe_unused one = 1; static int __maybe_unused two = 2; static int __maybe_unused three = 3; static unsigned long one_ul = 1; static int one_hundred = 100; #ifdef CONFIG_PRINTK static int ten_thousand = 10000; #endif / this is needed for the proc_doulongvec_minmax of vm_dirty_bytes / static unsigned long dirty_bytes_min = 2 PAGE_SIZE; /* this is needed for the proc_dointvec_minmax for [fs_]overflow UID and GID / static int maxolduid = 65535; static int minolduid; static int min_percpu_pagelist_fract = 8; static int ngroups_max = NGROUPS_MAX; #ifdef CONFIG_INOTIFY_USER #include <linux/inotify.h> #endif #ifdef CONFIG_SPARC #include <asm/system.h> #endif #ifdef CONFIG_SPARC64 extern int sysctl_tsb_ratio; #endif #ifdef __hppa__ extern int pwrsw_enabled; extern int unaligned_enabled; #endif #ifdef CONFIG_S390 #ifdef CONFIG_MATHEMU extern int sysctl_ieee_emulation_warnings; #endif extern int sysctl_userprocess_debug; extern int spin_retry; #endif #ifdef CONFIG_IA64 extern int no_unaligned_warning; extern int unaligned_dump_stack; #endif #ifdef CONFIG_PROC_SYSCTL static int proc_do_cad_pid(struct ctl_table table, int write, void __user buffer, size_t lenp, loff_t ppos); static int proc_taint(struct ctl_table table, int write, void __user buffer, size_t lenp, loff_t ppos); #endif #ifdef CONFIG_PRINTK static int proc_dmesg_restrict(struct ctl_table table, int write, void __user buffer, size_t lenp, loff_t ppos); #endif #ifdef CONFIG_MAGIC_SYSRQ / Note: sysrq code uses it's own private copy / static int __sysrq_enabled = SYSRQ_DEFAULT_ENABLE; static int sysrq_sysctl_handler(ctl_table table, int write, void __user buffer, size_t lenp, loff_t ppos) { int error; error = proc_dointvec(table, write, buffer, lenp, ppos); if (error) return error; if (write) sysrq_toggle_support(__sysrq_enabled); return 0; } #endif static struct ctl_table root_table[]; static struct ctl_table_root sysctl_table_root; static struct ctl_table_header root_table_header = { {{.count = 1, .ctl_table = root_table, .ctl_entry = LIST_HEAD_INIT(sysctl_table_root.default_set.list),}}, .root = &sysctl_table_root, .set = &sysctl_table_root.default_set, }; static struct ctl_table_root sysctl_table_root = { .root_list = LIST_HEAD_INIT(sysctl_table_root.root_list), .default_set.list = LIST_HEAD_INIT(root_table_header.ctl_entry), }; static struct ctl_table kern_table[]; static struct ctl_table vm_table[]; static struct ctl_table fs_table[]; static struct ctl_table debug_table[]; static struct ctl_table dev_table[]; extern struct ctl_table random_table[]; #ifdef CONFIG_EPOLL extern struct ctl_table epoll_table[]; #endif #ifdef HAVE_ARCH_PICK_MMAP_LAYOUT int sysctl_legacy_va_layout; #endif / The default sysctl tables: / static struct ctl_table root_table[] = { { .procname = "kernel", .mode = 0555, .child = kern_table, }, { .procname = "vm", .mode = 0555, .child = vm_table, }, { .procname = "fs", .mode = 0555, .child = fs_table, }, { .procname = "debug", .mode = 0555, .child = debug_table, }, { .procname = "dev", .mode = 0555, .child = dev_table, }, { } }; #ifdef CONFIG_SCHED_DEBUG static int min_sched_granularity_ns = 100000; / 100 usecs / static int max_sched_granularity_ns = NSEC_PER_SEC; / 1 second / static int min_wakeup_granularity_ns; / 0 usecs / static int max_wakeup_granularity_ns = NSEC_PER_SEC; / 1 second / static int min_sched_tunable_scaling = SCHED_TUNABLESCALING_NONE; static int max_sched_tunable_scaling = SCHED_TUNABLESCALING_END-1; #endif #ifdef CONFIG_COMPACTION static int min_extfrag_threshold; static int max_extfrag_threshold = 1000; #endif static struct ctl_table kern_table[] = { { .procname = "sched_child_runs_first", .data = &sysctl_sched_child_runs_first, .maxlen = sizeof(unsigned int), .mode = 0644, .proc_handler = proc_dointvec, }, #ifdef CONFIG_SCHED_DEBUG { .procname = "sched_min_granularity_ns", .data = &sysctl_sched_min_granularity, .maxlen = sizeof(unsigned int), .mode = 0644, .proc_handler = sched_proc_update_handler, .extra1 = &min_sched_granularity_ns, .extra2 = &max_sched_granularity_ns, }, { .procname = "sched_latency_ns", .data = &sysctl_sched_latency, .maxlen = sizeof(unsigned int), .mode = 0644, .proc_handler = sched_proc_update_handler, .extra1 = &min_sched_granularity_ns, .extra2 = &max_sched_granularity_ns, }, { .procname = "sched_wakeup_granularity_ns", .data = &sysctl_sched_wakeup_granularity, .maxlen = sizeof(unsigned int), .mode = 0644, .proc_handler = sched_proc_update_handler, .extra1 = &min_wakeup_granularity_ns, .extra2 = &max_wakeup_granularity_ns, }, { .procname = "sched_tunable_scaling", .data = &sysctl_sched_tunable_scaling, .maxlen = sizeof(enum sched_tunable_scaling), .mode = 0644, .proc_handler = sched_proc_update_handler, .extra1 = &min_sched_tunable_scaling, .extra2 = &max_sched_tunable_scaling, }, { .procname = "sched_migration_cost", .data = &sysctl_sched_migration_cost, .maxlen = sizeof(unsigned int), .mode = 0644, .proc_handler = proc_dointvec, }, { .procname = "sched_nr_migrate", .data = &sysctl_sched_nr_migrate, .maxlen = sizeof(unsigned int), .mode = 0644, .proc_handler = proc_dointvec, }, { .procname = "sched_time_avg", .data = &sysctl_sched_time_avg, .maxlen = sizeof(unsigned int), .mode = 0644, .proc_handler = proc_dointvec, }, { .procname = "sched_shares_window", .data = &sysctl_sched_shares_window, .maxlen = sizeof(unsigned int), .mode = 0644, .proc_handler = proc_dointvec, }, { .procname = "timer_migration", .data = &sysctl_timer_migration, .maxlen = sizeof(unsigned int), .mode = 0644, .proc_handler = proc_dointvec_minmax, .extra1 = &zero, .extra2 = &one, }, #endif { .procname = "sched_rt_period_us", .data = &sysctl_sched_rt_period, .maxlen = sizeof(unsigned int), .mode = 0644, .proc_handler = sched_rt_handler, }, { .procname = "sched_rt_runtime_us", .data = &sysctl_sched_rt_runtime, .maxlen = sizeof(int), .mode = 0644, .proc_handler = sched_rt_handler, }, #ifdef CONFIG_SCHED_AUTOGROUP { .procname = "sched_autogroup_enabled", .data = &sysctl_sched_autogroup_enabled, .maxlen = sizeof(unsigned int), .mode = 0644, .proc_handler = proc_dointvec_minmax, .extra1 = &zero, .extra2 = &one, }, #endif #ifdef CONFIG_PROVE_LOCKING { .procname = "prove_locking", .data = &prove_locking, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec, }, #endif #ifdef CONFIG_LOCK_STAT { .procname = "lock_stat", .data = &lock_stat, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec, }, #endif { .procname = "panic", .data = &panic_timeout, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec, }, { .procname = "core_uses_pid", .data = &core_uses_pid, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec, }, { .procname = "core_pattern", .data = core_pattern, .maxlen = CORENAME_MAX_SIZE, .mode = 0644, .proc_handler = proc_dostring, }, { .procname = "core_pipe_limit", .data = &core_pipe_limit, .maxlen = sizeof(unsigned int), .mode = 0644, .proc_handler = proc_dointvec, }, #ifdef CONFIG_PROC_SYSCTL { .procname = "tainted", .maxlen = sizeof(long), .mode = 0644, .proc_handler = proc_taint, }, #endif #ifdef CONFIG_LATENCYTOP { .procname = "latencytop", .data = &latencytop_enabled, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec, }, #endif #ifdef CONFIG_BLK_DEV_INITRD { .procname = "real-root-dev", .data = &real_root_dev, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec, }, #endif { .procname = "print-fatal-signals", .data = &print_fatal_signals, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec, }, #ifdef CONFIG_SPARC { .procname = "reboot-cmd", .data = reboot_command, .maxlen = 256, .mode = 0644, .proc_handler = proc_dostring, }, { .procname = "stop-a", .data = &stop_a_enabled, .maxlen = sizeof (int), .mode = 0644, .proc_handler = proc_dointvec, }, { .procname = "scons-poweroff", .data = &scons_pwroff, .maxlen = sizeof (int), .mode = 0644, .proc_handler = proc_dointvec, }, #endif #ifdef CONFIG_SPARC64 { .procname = "tsb-ratio", .data = &sysctl_tsb_ratio, .maxlen = sizeof (int), .mode = 0644, .proc_handler = proc_dointvec, }, #endif #ifdef __hppa__ { .procname = "soft-power", .data = &pwrsw_enabled, .maxlen = sizeof (int), .mode = 0644, .proc_handler = proc_dointvec, }, { .procname = "unaligned-trap", .data = &unaligned_enabled, .maxlen = sizeof (int), .mode = 0644, .proc_handler = proc_dointvec, }, #endif { .procname = "ctrl-alt-del", .data = &C_A_D, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec, }, #ifdef CONFIG_FUNCTION_TRACER { .procname = "ftrace_enabled", .data = &ftrace_enabled, .maxlen = sizeof(int), .mode = 0644, .proc_handler = ftrace_enable_sysctl, }, #endif #ifdef CONFIG_STACK_TRACER { .procname = "stack_tracer_enabled", .data = &stack_tracer_enabled, .maxlen = sizeof(int), .mode = 0644, .proc_handler = stack_trace_sysctl, }, #endif #ifdef CONFIG_TRACING { .procname = "ftrace_dump_on_oops", .data = &ftrace_dump_on_oops, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec, }, #endif #ifdef CONFIG_MODULES { .procname = "modprobe", .data = &modprobe_path, .maxlen = KMOD_PATH_LEN, .mode = 0644, .proc_handler = proc_dostring, }, { .procname = "modules_disabled", .data = &modules_disabled, .maxlen = sizeof(int), .mode = 0644, / only handle a transition from default "0" to "1" / .proc_handler = proc_dointvec_minmax, .extra1 = &one, .extra2 = &one, }, #endif #ifdef CONFIG_HOTPLUG { .procname = "hotplug", .data = &uevent_helper, .maxlen = UEVENT_HELPER_PATH_LEN, .mode = 0644, .proc_handler = proc_dostring, }, #endif #ifdef CONFIG_CHR_DEV_SG { .procname = "sg-big-buff", .data = &sg_big_buff, .maxlen = sizeof (int), .mode = 0444, .proc_handler = proc_dointvec, }, #endif #ifdef CONFIG_BSD_PROCESS_ACCT { .procname = "acct", .data = &acct_parm, .maxlen = 3sizeof(int), .mode = 0644, .proc_handler = proc_dointvec, }, #endif #ifdef CONFIG_MAGIC_SYSRQ { .procname = "sysrq", .data = &__sysrq_enabled, .maxlen = sizeof (int), .mode = 0644, .proc_handler = sysrq_sysctl_handler, }, #endif #ifdef CONFIG_PROC_SYSCTL { .procname = "cad_pid", .data = NULL, .maxlen = sizeof (int), .mode = 0600, .proc_handler = proc_do_cad_pid, }, #endif { .procname = "threads-max", .data = &max_threads, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec, }, { .procname = "random", .mode = 0555, .child = random_table, }, { .procname = "overflowuid", .data = &overflowuid, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec_minmax, .extra1 = &minolduid, .extra2 = &maxolduid, }, { .procname = "overflowgid", .data = &overflowgid, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec_minmax, .extra1 = &minolduid, .extra2 = &maxolduid, }, #ifdef CONFIG_S390 #ifdef CONFIG_MATHEMU { .procname = "ieee_emulation_warnings", .data = &sysctl_ieee_emulation_warnings, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec, }, #endif { .procname = "userprocess_debug", .data = &show_unhandled_signals, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec, }, #endif { .procname = "pid_max", .data = &pid_max, .maxlen = sizeof (int), .mode = 0644, .proc_handler = proc_dointvec_minmax, .extra1 = &pid_max_min, .extra2 = &pid_max_max, }, { .procname = "panic_on_oops", .data = &panic_on_oops, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec, }, #if defined CONFIG_PRINTK { .procname = "printk", .data = &console_loglevel, .maxlen = 4sizeof(int), .mode = 0644, .proc_handler = proc_dointvec, }, { .procname = "printk_ratelimit", .data = &printk_ratelimit_state.interval, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec_jiffies, }, { .procname = "printk_ratelimit_burst", .data = &printk_ratelimit_state.burst, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec, }, { .procname = "printk_delay", .data = &printk_delay_msec, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec_minmax, .extra1 = &zero, .extra2 = &ten_thousand, }, { .procname = "dmesg_restrict", .data = &dmesg_restrict, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec_minmax, .extra1 = &zero, .extra2 = &one, }, { .procname = "kptr_restrict", .data = &kptr_restrict, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dmesg_restrict, .extra1 = &zero, .extra2 = &two, }, #endif { .procname = "ngroups_max", .data = &ngroups_max, .maxlen = sizeof (int), .mode = 0444, .proc_handler = proc_dointvec, }, #if defined(CONFIG_LOCKUP_DETECTOR) { .procname = "watchdog", .data = &watchdog_enabled, .maxlen = sizeof (int), .mode = 0644, .proc_handler = proc_dowatchdog_enabled, }, { .procname = "watchdog_thresh", .data = &softlockup_thresh, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dowatchdog_thresh, .extra1 = &neg_one, .extra2 = &sixty, }, { .procname = "softlockup_panic", .data = &softlockup_panic, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec_minmax, .extra1 = &zero, .extra2 = &one, }, { .procname = "nmi_watchdog", .data = &watchdog_enabled, .maxlen = sizeof (int), .mode = 0644, .proc_handler = proc_dowatchdog_enabled, }, #endif #if defined(CONFIG_X86_LOCAL_APIC) && defined(CONFIG_X86) { .procname = "unknown_nmi_panic", .data = &unknown_nmi_panic, .maxlen = sizeof (int), .mode = 0644, .proc_handler = proc_dointvec, }, #endif #if defined(CONFIG_X86) { .procname = "panic_on_unrecovered_nmi", .data = &panic_on_unrecovered_nmi, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec, }, { .procname = "panic_on_io_nmi", .data = &panic_on_io_nmi, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec, }, { .procname = "bootloader_type", .data = &bootloader_type, .maxlen = sizeof (int), .mode = 0444, .proc_handler = proc_dointvec, }, { .procname = "bootloader_version", .data = &bootloader_version, .maxlen = sizeof (int), .mode = 0444, .proc_handler = proc_dointvec, }, { .procname = "kstack_depth_to_print", .data = &kstack_depth_to_print, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec, }, { .procname = "io_delay_type", .data = &io_delay_type, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec, }, #endif #if defined(CONFIG_MMU) { .procname = "randomize_va_space", .data = &randomize_va_space, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec, }, #endif #if defined(CONFIG_S390) && defined(CONFIG_SMP) { .procname = "spin_retry", .data = &spin_retry, .maxlen = sizeof (int), .mode = 0644, .proc_handler = proc_dointvec, }, #endif #if defined(CONFIG_ACPI_SLEEP) && defined(CONFIG_X86) { .procname = "acpi_video_flags", .data = &acpi_realmode_flags, .maxlen = sizeof (unsigned long), .mode = 0644, .proc_handler = proc_doulongvec_minmax, }, #endif #ifdef CONFIG_IA64 { .procname = "ignore-unaligned-usertrap", .data = &no_unaligned_warning, .maxlen = sizeof (int), .mode = 0644, .proc_handler = proc_dointvec, }, { .procname = "unaligned-dump-stack", .data = &unaligned_dump_stack, .maxlen = sizeof (int), .mode = 0644, .proc_handler = proc_dointvec, }, #endif #ifdef CONFIG_DETECT_HUNG_TASK { .procname = "hung_task_panic", .data = &sysctl_hung_task_panic, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec_minmax, .extra1 = &zero, .extra2 = &one, }, { .procname = "hung_task_check_count", .data = &sysctl_hung_task_check_count, .maxlen = sizeof(unsigned long), .mode = 0644, .proc_handler = proc_doulongvec_minmax, }, { .procname = "hung_task_timeout_secs", .data = &sysctl_hung_task_timeout_secs, .maxlen = sizeof(unsigned long), .mode = 0644, .proc_handler = proc_dohung_task_timeout_secs, }, { .procname = "hung_task_warnings", .data = &sysctl_hung_task_warnings, .maxlen = sizeof(unsigned long), .mode = 0644, .proc_handler = proc_doulongvec_minmax, }, #endif #ifdef CONFIG_COMPAT { .procname = "compat-log", .data = &compat_log, .maxlen = sizeof (int), .mode = 0644, .proc_handler = proc_dointvec, }, #endif #ifdef CONFIG_RT_MUTEXES { .procname = "max_lock_depth", .data = &max_lock_depth, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec, }, #endif { .procname = "poweroff_cmd", .data = &poweroff_cmd, .maxlen = POWEROFF_CMD_PATH_LEN, .mode = 0644, .proc_handler = proc_dostring, }, #ifdef CONFIG_KEYS { .procname = "keys", .mode = 0555, .child = key_sysctls, }, #endif #ifdef CONFIG_RCU_TORTURE_TEST { .procname = "rcutorture_runnable", .data = &rcutorture_runnable, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec, }, #endif #ifdef CONFIG_PERF_EVENTS { .procname = "perf_event_paranoid", .data = &sysctl_perf_event_paranoid, .maxlen = sizeof(sysctl_perf_event_paranoid), .mode = 0644, .proc_handler = proc_dointvec, }, { .procname = "perf_event_mlock_kb", .data = &sysctl_perf_event_mlock, .maxlen = sizeof(sysctl_perf_event_mlock), .mode = 0644, .proc_handler = proc_dointvec, }, { .procname = "perf_event_max_sample_rate", .data = &sysctl_perf_event_sample_rate, .maxlen = sizeof(sysctl_perf_event_sample_rate), .mode = 0644, .proc_handler = perf_proc_update_handler, }, #endif #ifdef CONFIG_KMEMCHECK { .procname = "kmemcheck", .data = &kmemcheck_enabled, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec, }, #endif #ifdef CONFIG_BLOCK { .procname = "blk_iopoll", .data = &blk_iopoll_enabled, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec, }, #endif { } }; static struct ctl_table vm_table[] = { { .procname = "overcommit_memory", .data = &sysctl_overcommit_memory, .maxlen = sizeof(sysctl_overcommit_memory), .mode = 0644, .proc_handler = proc_dointvec_minmax, .extra1 = &zero, .extra2 = &two, }, { .procname = "panic_on_oom", .data = &sysctl_panic_on_oom, .maxlen = sizeof(sysctl_panic_on_oom), .mode = 0644, .proc_handler = proc_dointvec_minmax, .extra1 = &zero, .extra2 = &two, }, { .procname = "oom_kill_allocating_task", .data = &sysctl_oom_kill_allocating_task, .maxlen = sizeof(sysctl_oom_kill_allocating_task), .mode = 0644, .proc_handler = proc_dointvec, }, { .procname = "oom_dump_tasks", .data = &sysctl_oom_dump_tasks, .maxlen = sizeof(sysctl_oom_dump_tasks), .mode = 0644, .proc_handler = proc_dointvec, }, { .procname = "overcommit_ratio", .data = &sysctl_overcommit_ratio, .maxlen = sizeof(sysctl_overcommit_ratio), .mode = 0644, .proc_handler = proc_dointvec, }, { .procname = "page-cluster", .data = &page_cluster, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec_minmax, .extra1 = &zero, }, { .procname = "dirty_background_ratio", .data = &dirty_background_ratio, .maxlen = sizeof(dirty_background_ratio), .mode = 0644, .proc_handler = dirty_background_ratio_handler, .extra1 = &zero, .extra2 = &one_hundred, }, { .procname = "dirty_background_bytes", .data = &dirty_background_bytes, .maxlen = sizeof(dirty_background_bytes), .mode = 0644, .proc_handler = dirty_background_bytes_handler, .extra1 = &one_ul, }, { .procname = "dirty_ratio", .data = &vm_dirty_ratio, .maxlen = sizeof(vm_dirty_ratio), .mode = 0644, .proc_handler = dirty_ratio_handler, .extra1 = &zero, .extra2 = &one_hundred, }, { .procname = "dirty_bytes", .data = &vm_dirty_bytes, .maxlen = sizeof(vm_dirty_bytes), .mode = 0644, .proc_handler = dirty_bytes_handler, .extra1 = &dirty_bytes_min, }, { .procname = "dirty_writeback_centisecs", .data = &dirty_writeback_interval, .maxlen = sizeof(dirty_writeback_interval), .mode = 0644, .proc_handler = dirty_writeback_centisecs_handler, }, { .procname = "dirty_expire_centisecs", .data = &dirty_expire_interval, .maxlen = sizeof(dirty_expire_interval), .mode = 0644, .proc_handler = proc_dointvec_minmax, .extra1 = &zero, }, { .procname = "nr_pdflush_threads", .data = &nr_pdflush_threads, .maxlen = sizeof nr_pdflush_threads, .mode = 0444 / read-only/, .proc_handler = proc_dointvec, }, { .procname = "swappiness", .data = &vm_swappiness, .maxlen = sizeof(vm_swappiness), .mode = 0644, .proc_handler = proc_dointvec_minmax, .extra1 = &zero, .extra2 = &one_hundred, }, #ifdef CONFIG_HUGETLB_PAGE { .procname = "nr_hugepages", .data = NULL, .maxlen = sizeof(unsigned long), .mode = 0644, .proc_handler = hugetlb_sysctl_handler, .extra1 = (void )&hugetlb_zero, .extra2 = (void )&hugetlb_infinity, }, #ifdef CONFIG_NUMA { .procname = "nr_hugepages_mempolicy", .data = NULL, .maxlen = sizeof(unsigned long), .mode = 0644, .proc_handler = &hugetlb_mempolicy_sysctl_handler, .extra1 = (void )&hugetlb_zero, .extra2 = (void )&hugetlb_infinity, }, #endif { .procname = "hugetlb_shm_group", .data = &sysctl_hugetlb_shm_group, .maxlen = sizeof(gid_t), .mode = 0644, .proc_handler = proc_dointvec, }, { .procname = "hugepages_treat_as_movable", .data = &hugepages_treat_as_movable, .maxlen = sizeof(int), .mode = 0644, .proc_handler = hugetlb_treat_movable_handler, }, { .procname = "nr_overcommit_hugepages", .data = NULL, .maxlen = sizeof(unsigned long), .mode = 0644, .proc_handler = hugetlb_overcommit_handler, .extra1 = (void )&hugetlb_zero, .extra2 = (void )&hugetlb_infinity, }, #endif { .procname = "lowmem_reserve_ratio", .data = &sysctl_lowmem_reserve_ratio, .maxlen = sizeof(sysctl_lowmem_reserve_ratio), .mode = 0644, .proc_handler = lowmem_reserve_ratio_sysctl_handler, }, { .procname = "drop_caches", .data = &sysctl_drop_caches, .maxlen = sizeof(int), .mode = 0644, .proc_handler = drop_caches_sysctl_handler, .extra1 = &one, .extra2 = &three, }, #ifdef CONFIG_COMPACTION { .procname = "compact_memory", .data = &sysctl_compact_memory, .maxlen = sizeof(int), .mode = 0200, .proc_handler = sysctl_compaction_handler, }, { .procname = "extfrag_threshold", .data = &sysctl_extfrag_threshold, .maxlen = sizeof(int), .mode = 0644, .proc_handler = sysctl_extfrag_handler, .extra1 = &min_extfrag_threshold, .extra2 = &max_extfrag_threshold, }, #endif / CONFIG_COMPACTION / { .procname = "min_free_kbytes", .data = &min_free_kbytes, .maxlen = sizeof(min_free_kbytes), .mode = 0644, .proc_handler = min_free_kbytes_sysctl_handler, .extra1 = &zero, }, { .procname = "percpu_pagelist_fraction", .data = &percpu_pagelist_fraction, .maxlen = sizeof(percpu_pagelist_fraction), .mode = 0644, .proc_handler = percpu_pagelist_fraction_sysctl_handler, .extra1 = &min_percpu_pagelist_fract, }, #ifdef CONFIG_MMU { .procname = "max_map_count", .data = &sysctl_max_map_count, .maxlen = sizeof(sysctl_max_map_count), .mode = 0644, .proc_handler = proc_dointvec_minmax, .extra1 = &zero, }, #else { .procname = "nr_trim_pages", .data = &sysctl_nr_trim_pages, .maxlen = sizeof(sysctl_nr_trim_pages), .mode = 0644, .proc_handler = proc_dointvec_minmax, .extra1 = &zero, }, #endif { .procname = "laptop_mode", .data = &laptop_mode, .maxlen = sizeof(laptop_mode), .mode = 0644, .proc_handler = proc_dointvec_jiffies, }, { .procname = "block_dump", .data = &block_dump, .maxlen = sizeof(block_dump), .mode = 0644, .proc_handler = proc_dointvec, .extra1 = &zero, }, { .procname = "vfs_cache_pressure", .data = &sysctl_vfs_cache_pressure, .maxlen = sizeof(sysctl_vfs_cache_pressure), .mode = 0644, .proc_handler = proc_dointvec, .extra1 = &zero, }, #ifdef HAVE_ARCH_PICK_MMAP_LAYOUT { .procname = "legacy_va_layout", .data = &sysctl_legacy_va_layout, .maxlen = sizeof(sysctl_legacy_va_layout), .mode = 0644, .proc_handler = proc_dointvec, .extra1 = &zero, }, #endif #ifdef CONFIG_NUMA { .procname = "zone_reclaim_mode", .data = &zone_reclaim_mode, .maxlen = sizeof(zone_reclaim_mode), .mode = 0644, .proc_handler = proc_dointvec, .extra1 = &zero, }, { .procname = "min_unmapped_ratio", .data = &sysctl_min_unmapped_ratio, .maxlen = sizeof(sysctl_min_unmapped_ratio), .mode = 0644, .proc_handler = sysctl_min_unmapped_ratio_sysctl_handler, .extra1 = &zero, .extra2 = &one_hundred, }, { .procname = "min_slab_ratio", .data = &sysctl_min_slab_ratio, .maxlen = sizeof(sysctl_min_slab_ratio), .mode = 0644, .proc_handler = sysctl_min_slab_ratio_sysctl_handler, .extra1 = &zero, .extra2 = &one_hundred, }, #endif #ifdef CONFIG_SMP { .procname = "stat_interval", .data = &sysctl_stat_interval, .maxlen = sizeof(sysctl_stat_interval), .mode = 0644, .proc_handler = proc_dointvec_jiffies, }, #endif #ifdef CONFIG_MMU { .procname = "mmap_min_addr", .data = &dac_mmap_min_addr, .maxlen = sizeof(unsigned long), .mode = 0644, .proc_handler = mmap_min_addr_handler, }, #endif #ifdef CONFIG_NUMA { .procname = "numa_zonelist_order", .data = &numa_zonelist_order, .maxlen = NUMA_ZONELIST_ORDER_LEN, .mode = 0644, .proc_handler = numa_zonelist_order_handler, }, #endif #if (defined(CONFIG_X86_32) && !defined(CONFIG_UML))\|\| \ (defined(CONFIG_SUPERH) && defined(CONFIG_VSYSCALL)) { .procname = "vdso_enabled", .data = &vdso_enabled, .maxlen = sizeof(vdso_enabled), .mode = 0644, .proc_handler = proc_dointvec, .extra1 = &zero, }, #endif #ifdef CONFIG_HIGHMEM { .procname = "highmem_is_dirtyable", .data = &vm_highmem_is_dirtyable, .maxlen = sizeof(vm_highmem_is_dirtyable), .mode = 0644, .proc_handler = proc_dointvec_minmax, .extra1 = &zero, .extra2 = &one, }, #endif { .procname = "scan_unevictable_pages", .data = &scan_unevictable_pages, .maxlen = sizeof(scan_unevictable_pages), .mode = 0644, .proc_handler = scan_unevictable_handler, }, #ifdef CONFIG_MEMORY_FAILURE { .procname = "memory_failure_early_kill", .data = &sysctl_memory_failure_early_kill, .maxlen = sizeof(sysctl_memory_failure_early_kill), .mode = 0644, .proc_handler = proc_dointvec_minmax, .extra1 = &zero, .extra2 = &one, }, { .procname = "memory_failure_recovery", .data = &sysctl_memory_failure_recovery, .maxlen = sizeof(sysctl_memory_failure_recovery), .mode = 0644, .proc_handler = proc_dointvec_minmax, .extra1 = &zero, .extra2 = &one, }, #endif { } }; #if defined(CONFIG_BINFMT_MISC) \|\| defined(CONFIG_BINFMT_MISC_MODULE) static struct ctl_table binfmt_misc_table[] = { { } }; #endif static struct ctl_table fs_table[] = { { .procname = "inode-nr", .data = &inodes_stat, .maxlen = 2sizeof(int), .mode = 0444, .proc_handler = proc_nr_inodes, }, { .procname = "inode-state", .data = &inodes_stat, .maxlen = 7sizeof(int), .mode = 0444, .proc_handler = proc_nr_inodes, }, { .procname = "file-nr", .data = &files_stat, .maxlen = sizeof(files_stat), .mode = 0444, .proc_handler = proc_nr_files, }, { .procname = "file-max", .data = &files_stat.max_files, .maxlen = sizeof(files_stat.max_files), .mode = 0644, .proc_handler = proc_doulongvec_minmax, }, { .procname = "nr_open", .data = &sysctl_nr_open, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec_minmax, .extra1 = &sysctl_nr_open_min, .extra2 = &sysctl_nr_open_max, }, { .procname = "dentry-state", .data = &dentry_stat, .maxlen = 6sizeof(int), .mode = 0444, .proc_handler = proc_nr_dentry, }, { .procname = "overflowuid", .data = &fs_overflowuid, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec_minmax, .extra1 = &minolduid, .extra2 = &maxolduid, }, { .procname = "overflowgid", .data = &fs_overflowgid, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec_minmax, .extra1 = &minolduid, .extra2 = &maxolduid, }, #ifdef CONFIG_FILE_LOCKING { .procname = "leases-enable", .data = &leases_enable, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec, }, #endif #ifdef CONFIG_DNOTIFY { .procname = "dir-notify-enable", .data = &dir_notify_enable, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec, }, #endif #ifdef CONFIG_MMU #ifdef CONFIG_FILE_LOCKING { .procname = "lease-break-time", .data = &lease_break_time, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec, }, #endif #ifdef CONFIG_AIO { .procname = "aio-nr", .data = &aio_nr, .maxlen = sizeof(aio_nr), .mode = 0444, .proc_handler = proc_doulongvec_minmax, }, { .procname = "aio-max-nr", .data = &aio_max_nr, .maxlen = sizeof(aio_max_nr), .mode = 0644, .proc_handler = proc_doulongvec_minmax, }, #endif /* CONFIG_AIO / #ifdef CONFIG_INOTIFY_USER { .procname = "inotify", .mode = 0555, .child = inotify_table, }, #endif #ifdef CONFIG_EPOLL { .procname = "epoll", .mode = 0555, .child = epoll_table, }, #endif #endif { .procname = "suid_dumpable", .data = &suid_dumpable, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec_minmax, .extra1 = &zero, .extra2 = &two, }, #if defined(CONFIG_BINFMT_MISC) \|\| defined(CONFIG_BINFMT_MISC_MODULE) { .procname = "binfmt_misc", .mode = 0555, .child = binfmt_misc_table, }, #endif { .procname = "pipe-max-size", .data = &pipe_max_size, .maxlen = sizeof(int), .mode = 0644, .proc_handler = &pipe_proc_fn, .extra1 = &pipe_min_size, }, { } }; static struct ctl_table debug_table[] = { #if defined(CONFIG_X86) \|\| defined(CONFIG_PPC) \|\| defined(CONFIG_SPARC) \|\| \ defined(CONFIG_S390) { .procname = "exception-trace", .data = &show_unhandled_signals, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_dointvec }, #endif #if defined(CONFIG_OPTPROBES) { .procname = "kprobes-optimization", .data = &sysctl_kprobes_optimization, .maxlen = sizeof(int), .mode = 0644, .proc_handler = proc_kprobes_optimization_handler, .extra1 = &zero, .extra2 = &one, }, #endif { } }; static struct ctl_table dev_table[] = { { } }; static DEFINE_SPINLOCK(sysctl_lock); / called under sysctl_lock / static int use_table(struct ctl_table_header p) { if (unlikely(p->unregistering)) return 0; p->used++; return 1; } /* called under sysctl_lock / static void unuse_table(struct ctl_table_header p) { if (!--p->used) if (unlikely(p->unregistering)) complete(p->unregistering); } /* called under sysctl_lock, will reacquire if has to wait / static void start_unregistering(struct ctl_table_header p) { /* * if p->used is 0, nobody will ever touch that entry again; * we'll eliminate all paths to it before dropping sysctl_lock / if (unlikely(p->used)) { struct completion wait; init_completion(&wait); p->unregistering = &wait; spin_unlock(&sysctl_lock); wait_for_completion(&wait); spin_lock(&sysctl_lock); } else { / anything non-NULL; we'll never dereference it / p->unregistering = ERR_PTR(-EINVAL); } / * do not remove from the list until nobody holds it; walking the * list in do_sysctl() relies on that. / list_del_init(&p->ctl_entry); } void sysctl_head_get(struct ctl_table_header head) { spin_lock(&sysctl_lock); head->count++; spin_unlock(&sysctl_lock); } static void free_head(struct rcu_head rcu) { kfree(container_of(rcu, struct ctl_table_header, rcu)); } void sysctl_head_put(struct ctl_table_header head) { spin_lock(&sysctl_lock); if (!--head->count) call_rcu(&head->rcu, free_head); spin_unlock(&sysctl_lock); } struct ctl_table_header sysctl_head_grab(struct ctl_table_header head) { if (!head) BUG(); spin_lock(&sysctl_lock); if (!use_table(head)) head = ERR_PTR(-ENOENT); spin_unlock(&sysctl_lock); return head; } void sysctl_head_finish(struct ctl_table_header head) { if (!head) return; spin_lock(&sysctl_lock); unuse_table(head); spin_unlock(&sysctl_lock); } static struct ctl_table_set lookup_header_set(struct ctl_table_root root, struct nsproxy namespaces) { struct ctl_table_set set = &root->default_set; if (root->lookup) set = root->lookup(root, namespaces); return set; } static struct list_head lookup_header_list(struct ctl_table_root root, struct nsproxy namespaces) { struct ctl_table_set set = lookup_header_set(root, namespaces); return &set->list; } struct ctl_table_header __sysctl_head_next(struct nsproxy namespaces, struct ctl_table_header prev) { struct ctl_table_root root; struct list_head header_list; struct ctl_table_header head; struct list_head tmp; spin_lock(&sysctl_lock); if (prev) { head = prev; tmp = &prev->ctl_entry; unuse_table(prev); goto next; } tmp = &root_table_header.ctl_entry; for (;;) { head = list_entry(tmp, struct ctl_table_header, ctl_entry); if (!use_table(head)) goto next; spin_unlock(&sysctl_lock); return head; next: root = head->root; tmp = tmp->next; header_list = lookup_header_list(root, namespaces); if (tmp != header_list) continue; do { root = list_entry(root->root_list.next, struct ctl_table_root, root_list); if (root == &sysctl_table_root) goto out; header_list = lookup_header_list(root, namespaces); } while (list_empty(header_list)); tmp = header_list->next; } out: spin_unlock(&sysctl_lock); return NULL; } struct ctl_table_header sysctl_head_next(struct ctl_table_header prev) { return __sysctl_head_next(current->nsproxy, prev); } void register_sysctl_root(struct ctl_table_root root) { spin_lock(&sysctl_lock); list_add_tail(&root->root_list, &sysctl_table_root.root_list); spin_unlock(&sysctl_lock); } / * sysctl_perm does NOT grant the superuser all rights automatically, because * some sysctl variables are readonly even to root. / static int test_perm(int mode, int op) { if (!current_euid()) mode >>= 6; else if (in_egroup_p(0)) mode >>= 3; if ((op & ~mode & (MAY_READ\|MAY_WRITE\|MAY_EXEC)) == 0) return 0; return -EACCES; } int sysctl_perm(struct ctl_table_root root, struct ctl_table table, int op) { int mode; if (root->permissions) mode = root->permissions(root, current->nsproxy, table); else mode = table->mode; return test_perm(mode, op); } static void sysctl_set_parent(struct ctl_table parent, struct ctl_table table) { for (; table->procname; table++) { table->parent = parent; if (table->child) sysctl_set_parent(table, table->child); } } static __init int sysctl_init(void) { sysctl_set_parent(NULL, root_table); #ifdef CONFIG_SYSCTL_SYSCALL_CHECK sysctl_check_table(current->nsproxy, root_table); #endif return 0; } core_initcall(sysctl_init); static struct ctl_table is_branch_in(struct ctl_table branch, struct ctl_table table) { struct ctl_table p; const char s = branch->procname; /* branch should have named subdirectory as its first element / if (!s \|\| !branch->child) return NULL; / ... and nothing else / if (branch[1].procname) return NULL; / table should contain subdirectory with the same name / for (p = table; p->procname; p++) { if (!p->child) continue; if (p->procname && strcmp(p->procname, s) == 0) return p; } return NULL; } / see if attaching q to p would be an improvement / static void try_attach(struct ctl_table_header p, struct ctl_table_header q) { struct ctl_table to = p->ctl_table, by = q->ctl_table; struct ctl_table next; int is_better = 0; int not_in_parent = !p->attached_by; while ((next = is_branch_in(by, to)) != NULL) { if (by == q->attached_by) is_better = 1; if (to == p->attached_by) not_in_parent = 1; by = by->child; to = next->child; } if (is_better && not_in_parent) { q->attached_by = by; q->attached_to = to; q->parent = p; } } /** * __register_sysctl_paths - register a sysctl hierarchy * @root: List of sysctl headers to register on * @namespaces: Data to compute which lists of sysctl entries are visible * @path: The path to the directory the sysctl table is in. * @table: the top-level table structure * * Register a sysctl table hierarchy. @table should be a filled in ctl_table * array. A completely 0 filled entry terminates the table. * * The members of the &struct ctl_table structure are used as follows: * * procname - the name of the sysctl file under /proc/sys. Set to %NULL to not * enter a sysctl file * * data - a pointer to data for use by proc_handler * * maxlen - the maximum size in bytes of the data * * mode - the file permissions for the /proc/sys file, and for sysctl(2) * * child - a pointer to the child sysctl table if this entry is a directory, or * %NULL. * * proc_handler - the text handler routine (described below) * * de - for internal use by the sysctl routines * * extra1, extra2 - extra pointers usable by the proc handler routines * * Leaf nodes in the sysctl tree will be represented by a single file * under /proc; non-leaf nodes will be represented by directories. * * sysctl(2) can automatically manage read and write requests through * the sysctl table. The data and maxlen fields of the ctl_table * struct enable minimal validation of the values being written to be * performed, and the mode field allows minimal authentication. * * There must be a proc_handler routine for any terminal nodes * mirrored under /proc/sys (non-terminals are handled by a built-in * directory handler). Several default handlers are available to * cover common cases - * * proc_dostring(), proc_dointvec(), proc_dointvec_jiffies(), * proc_dointvec_userhz_jiffies(), proc_dointvec_minmax(), * proc_doulongvec_ms_jiffies_minmax(), proc_doulongvec_minmax() * * It is the handler's job to read the input buffer from user memory * and process it. The handler should return 0 on success. * * This routine returns %NULL on a failure to register, and a pointer * to the table header on success. / struct ctl_table_header __register_sysctl_paths( struct ctl_table_root root, struct nsproxy namespaces, const struct ctl_path path, struct ctl_table table) { struct ctl_table_header header; struct ctl_table new, *prevp; unsigned int n, npath; struct ctl_table_set set; /* Count the path components / for (npath = 0; path[npath].procname; ++npath) ; / * For each path component, allocate a 2-element ctl_table array. * The first array element will be filled with the sysctl entry * for this, the second will be the sentinel (procname == 0). * * We allocate everything in one go so that we don't have to * worry about freeing additional memory in unregister_sysctl_table. / header = kzalloc(sizeof(struct ctl_table_header) + (2 npath * sizeof(struct ctl_table)), GFP_KERNEL); if (!header) return NULL; new = (struct ctl_table ) (header + 1); / Now connect the dots / prevp = &header->ctl_table; for (n = 0; n < npath; ++n, ++path) { / Copy the procname / new->procname = path->procname; new->mode = 0555; prevp = new; prevp = &new->child; new += 2; } prevp = table; header->ctl_table_arg = table; INIT_LIST_HEAD(&header->ctl_entry); header->used = 0; header->unregistering = NULL; header->root = root; sysctl_set_parent(NULL, header->ctl_table); header->count = 1; #ifdef CONFIG_SYSCTL_SYSCALL_CHECK if (sysctl_check_table(namespaces, header->ctl_table)) { kfree(header); return NULL; } #endif spin_lock(&sysctl_lock); header->set = lookup_header_set(root, namespaces); header->attached_by = header->ctl_table; header->attached_to = root_table; header->parent = &root_table_header; for (set = header->set; set; set = set->parent) { struct ctl_table_header p; list_for_each_entry(p, &set->list, ctl_entry) { if (p->unregistering) continue; try_attach(p, header); } } header->parent->count++; list_add_tail(&header->ctl_entry, &header->set->list); spin_unlock(&sysctl_lock); return header; } /** * register_sysctl_table_path - register a sysctl table hierarchy * @path: The path to the directory the sysctl table is in. * @table: the top-level table structure * * Register a sysctl table hierarchy. @table should be a filled in ctl_table * array. A completely 0 filled entry terminates the table. * * See __register_sysctl_paths for more details. / struct ctl_table_header register_sysctl_paths(const struct ctl_path path, struct ctl_table table) { return __register_sysctl_paths(&sysctl_table_root, current->nsproxy, path, table); } /** * register_sysctl_table - register a sysctl table hierarchy * @table: the top-level table structure * * Register a sysctl table hierarchy. @table should be a filled in ctl_table * array. A completely 0 filled entry terminates the table. * * See register_sysctl_paths for more details. / struct ctl_table_header register_sysctl_table(struct ctl_table table) { static const struct ctl_path null_path[] = { {} }; return register_sysctl_paths(null_path, table); } /* * unregister_sysctl_table - unregister a sysctl table hierarchy * @header: the header returned from register_sysctl_table * * Unregisters the sysctl table and all children. proc entries may not * actually be removed until they are no longer used by anyone. / void unregister_sysctl_table(struct ctl_table_header header) { might_sleep(); if (header == NULL) return; spin_lock(&sysctl_lock); start_unregistering(header); if (!--header->parent->count) { WARN_ON(1); call_rcu(&header->parent->rcu, free_head); } if (!--header->count) call_rcu(&header->rcu, free_head); spin_unlock(&sysctl_lock); } int sysctl_is_seen(struct ctl_table_header p) { struct ctl_table_set set = p->set; int res; spin_lock(&sysctl_lock); if (p->unregistering) res = 0; else if (!set->is_seen) res = 1; else res = set->is_seen(set); spin_unlock(&sysctl_lock); return res; } void setup_sysctl_set(struct ctl_table_set p, struct ctl_table_set parent, int (is_seen)(struct ctl_table_set )) { INIT_LIST_HEAD(&p->list); p->parent = parent ? parent : &sysctl_table_root.default_set; p->is_seen = is_seen; } #else /* !CONFIG_SYSCTL / struct ctl_table_header register_sysctl_table(struct ctl_table * table) { return NULL; } struct ctl_table_header register_sysctl_paths(const struct ctl_path path, struct ctl_table table) { return NULL; } void unregister_sysctl_table(struct ctl_table_header table) { } void setup_sysctl_set(struct ctl_table_set p, struct ctl_table_set parent, int (is_seen)(struct ctl_table_set )) { } void sysctl_head_put(struct ctl_table_header head) { } #endif / CONFIG_SYSCTL / / * /proc/sys support / #ifdef CONFIG_PROC_SYSCTL static int _proc_do_string(void data, int maxlen, int write, void __user buffer, size_t lenp, loff_t ppos) { size_t len; char __user p; char c; if (!data \|\| !maxlen \|\| !lenp) { lenp = 0; return 0; } if (write) { len = 0; p = buffer; while (len < lenp) { if (get_user(c, p++)) return -EFAULT; if (c == 0 \|\| c == '\n') break; len++; } if (len >= maxlen) len = maxlen-1; if(copy_from_user(data, buffer, len)) return -EFAULT; ((char ) data)[len] = 0; ppos += lenp; } else { len = strlen(data); if (len > maxlen) len = maxlen; if (ppos > len) { lenp = 0; return 0; } data += ppos; len -= ppos; if (len > lenp) len = lenp; if (len) if(copy_to_user(buffer, data, len)) return -EFAULT; if (len < lenp) { if(put_user('\n', ((char __user ) buffer) + len)) return -EFAULT; len++; } lenp = len; ppos += len; } return 0; } /** * proc_dostring - read a string sysctl * @table: the sysctl table * @write: %TRUE if this is a write to the sysctl file * @buffer: the user buffer * @lenp: the size of the user buffer * @ppos: file position * * Reads/writes a string from/to the user buffer. If the kernel * buffer provided is not large enough to hold the string, the * string is truncated. The copied string is %NULL-terminated. * If the string is being read by the user process, it is copied * and a newline '\n' is added. It is truncated if the buffer is * not large enough. * * Returns 0 on success. / int proc_dostring(struct ctl_table table, int write, void __user buffer, size_t lenp, loff_t ppos) { return _proc_do_string(table->data, table->maxlen, write, buffer, lenp, ppos); } static size_t proc_skip_spaces(char buf) { size_t ret; char tmp = skip_spaces(buf); ret = tmp - buf; buf = tmp; return ret; } static void proc_skip_char(char buf, size_t size, const char v) { while (size) { if (buf != v) break; (size)--; (buf)++; } } #define TMPBUFLEN 22 /* * proc_get_long - reads an ASCII formatted integer from a user buffer * * @buf: a kernel buffer * @size: size of the kernel buffer * @val: this is where the number will be stored * @neg: set to %TRUE if number is negative * @perm_tr: a vector which contains the allowed trailers * @perm_tr_len: size of the perm_tr vector * @tr: pointer to store the trailer character * * In case of success %0 is returned and @buf and @size are updated with * the amount of bytes read. If @tr is non-NULL and a trailing * character exists (size is non-zero after returning from this * function), @tr is updated with the trailing character. / static int proc_get_long(char buf, size_t size, unsigned long val, bool neg, const char perm_tr, unsigned perm_tr_len, char tr) { int len; char p, tmp[TMPBUFLEN]; if (!size) return -EINVAL; len = size; if (len > TMPBUFLEN - 1) len = TMPBUFLEN - 1; memcpy(tmp, buf, len); tmp[len] = 0; p = tmp; if (p == '-' && size > 1) { neg = true; p++; } else neg = false; if (!isdigit(p)) return -EINVAL; val = simple_strtoul(p, &p, 0); len = p - tmp; /* We don't know if the next char is whitespace thus we may accept * invalid integers (e.g. 1234...a) or two integers instead of one * (e.g. 123...1). So lets not allow such large numbers. / if (len == TMPBUFLEN - 1) return -EINVAL; if (len < size && perm_tr_len && !memchr(perm_tr, p, perm_tr_len)) return -EINVAL; if (tr && (len < size)) tr = p; buf += len; size -= len; return 0; } /** * proc_put_long - converts an integer to a decimal ASCII formatted string * * @buf: the user buffer * @size: the size of the user buffer * @val: the integer to be converted * @neg: sign of the number, %TRUE for negative * * In case of success %0 is returned and @buf and @size are updated with * the amount of bytes written. / static int proc_put_long(void __user buf, size_t size, unsigned long val, bool neg) { int len; char tmp[TMPBUFLEN], p = tmp; sprintf(p, "%s%lu", neg ? "-" : "", val); len = strlen(tmp); if (len > size) len = size; if (copy_to_user(buf, tmp, len)) return -EFAULT; size -= len; buf += len; return 0; } #undef TMPBUFLEN static int proc_put_char(void __user *buf, size_t size, char c) { if (size) { char __user buffer = (char __user )buf; if (put_user(c, buffer)) return -EFAULT; (size)--, (buffer)++; buf = buffer; } return 0; } static int do_proc_dointvec_conv(bool negp, unsigned long lvalp, int valp, int write, void data) { if (write) { valp = negp ? -lvalp : lvalp; } else { int val = valp; if (val < 0) { negp = true; lvalp = (unsigned long)-val; } else { negp = false; lvalp = (unsigned long)val; } } return 0; } static const char proc_wspace_sep[] = { ' ', '\t', '\n' }; static int __do_proc_dointvec(void tbl_data, struct ctl_table table, int write, void __user buffer, size_t lenp, loff_t ppos, int (conv)(bool negp, unsigned long lvalp, int valp, int write, void data), void data) { int i, vleft, first = 1, err = 0; unsigned long page = 0; size_t left; char kbuf; if (!tbl_data \|\| !table->maxlen \|\| !lenp \|\| (ppos && !write)) { lenp = 0; return 0; } i = (int ) tbl_data; vleft = table->maxlen / sizeof(i); left = lenp; if (!conv) conv = do_proc_dointvec_conv; if (write) { if (left > PAGE_SIZE - 1) left = PAGE_SIZE - 1; page = __get_free_page(GFP_TEMPORARY); kbuf = (char ) page; if (!kbuf) return -ENOMEM; if (copy_from_user(kbuf, buffer, left)) { err = -EFAULT; goto free; } kbuf[left] = 0; } for (; left && vleft--; i++, first=0) { unsigned long lval; bool neg; if (write) { left -= proc_skip_spaces(&kbuf); if (!left) break; err = proc_get_long(&kbuf, &left, &lval, &neg, proc_wspace_sep, sizeof(proc_wspace_sep), NULL); if (err) break; if (conv(&neg, &lval, i, 1, data)) { err = -EINVAL; break; } } else { if (conv(&neg, &lval, i, 0, data)) { err = -EINVAL; break; } if (!first) err = proc_put_char(&buffer, &left, '\t'); if (err) break; err = proc_put_long(&buffer, &left, lval, neg); if (err) break; } } if (!write && !first && left && !err) err = proc_put_char(&buffer, &left, '\n'); if (write && !err && left) left -= proc_skip_spaces(&kbuf); free: if (write) { free_page(page); if (first) return err ? : -EINVAL; } lenp -= left; ppos += lenp; return err; } static int do_proc_dointvec(struct ctl_table table, int write, void __user buffer, size_t lenp, loff_t ppos, int (conv)(bool negp, unsigned long lvalp, int valp, int write, void data), void data) { return __do_proc_dointvec(table->data, table, write, buffer, lenp, ppos, conv, data); } /** * proc_dointvec - read a vector of integers * @table: the sysctl table * @write: %TRUE if this is a write to the sysctl file * @buffer: the user buffer * @lenp: the size of the user buffer * @ppos: file position * * Reads/writes up to table->maxlen/sizeof(unsigned int) integer * values from/to the user buffer, treated as an ASCII string. * * Returns 0 on success. / int proc_dointvec(struct ctl_table table, int write, void __user buffer, size_t lenp, loff_t ppos) { return do_proc_dointvec(table,write,buffer,lenp,ppos, NULL,NULL); } / * Taint values can only be increased * This means we can safely use a temporary. / static int proc_taint(struct ctl_table table, int write, void __user buffer, size_t lenp, loff_t ppos) { struct ctl_table t; unsigned long tmptaint = get_taint(); int err; if (write && !capable(CAP_SYS_ADMIN)) return -EPERM; t = table; t.data = &tmptaint; err = proc_doulongvec_minmax(&t, write, buffer, lenp, ppos); if (err < 0) return err; if (write) { /* * Poor man's atomic or. Not worth adding a primitive * to everyone's atomic.h for this / int i; for (i = 0; i < BITS_PER_LONG && tmptaint >> i; i++) { if ((tmptaint >> i) & 1) add_taint(i); } } return err; } #ifdef CONFIG_PRINTK static int proc_dmesg_restrict(struct ctl_table table, int write, void __user buffer, size_t lenp, loff_t ppos) { if (write && !capable(CAP_SYS_ADMIN)) return -EPERM; return proc_dointvec_minmax(table, write, buffer, lenp, ppos); } #endif struct do_proc_dointvec_minmax_conv_param { int min; int max; }; static int do_proc_dointvec_minmax_conv(bool negp, unsigned long lvalp, int valp, int write, void data) { struct do_proc_dointvec_minmax_conv_param param = data; if (write) { int val = negp ? -lvalp : lvalp; if ((param->min && param->min > val) \|\| (param->max && param->max < val)) return -EINVAL; valp = val; } else { int val = valp; if (val < 0) { negp = true; lvalp = (unsigned long)-val; } else { negp = false; lvalp = (unsigned long)val; } } return 0; } /* * proc_dointvec_minmax - read a vector of integers with min/max values * @table: the sysctl table * @write: %TRUE if this is a write to the sysctl file * @buffer: the user buffer * @lenp: the size of the user buffer * @ppos: file position * * Reads/writes up to table->maxlen/sizeof(unsigned int) integer * values from/to the user buffer, treated as an ASCII string. * * This routine will ensure the values are within the range specified by * table->extra1 (min) and table->extra2 (max). * * Returns 0 on success. / int proc_dointvec_minmax(struct ctl_table table, int write, void __user buffer, size_t lenp, loff_t ppos) { struct do_proc_dointvec_minmax_conv_param param = { .min = (int ) table->extra1, .max = (int ) table->extra2, }; return do_proc_dointvec(table, write, buffer, lenp, ppos, do_proc_dointvec_minmax_conv, &param); } static int __do_proc_doulongvec_minmax(void data, struct ctl_table table, int write, void __user buffer, size_t lenp, loff_t ppos, unsigned long convmul, unsigned long convdiv) { unsigned long i, min, max; int vleft, first = 1, err = 0; unsigned long page = 0; size_t left; char kbuf; if (!data \|\| !table->maxlen \|\| !lenp \|\| (ppos && !write)) { lenp = 0; return 0; } i = (unsigned long ) data; min = (unsigned long ) table->extra1; max = (unsigned long ) table->extra2; vleft = table->maxlen / sizeof(unsigned long); left = lenp; if (write) { if (left > PAGE_SIZE - 1) left = PAGE_SIZE - 1; page = __get_free_page(GFP_TEMPORARY); kbuf = (char ) page; if (!kbuf) return -ENOMEM; if (copy_from_user(kbuf, buffer, left)) { err = -EFAULT; goto free; } kbuf[left] = 0; } for (; left && vleft--; i++, first = 0) { unsigned long val; if (write) { bool neg; left -= proc_skip_spaces(&kbuf); err = proc_get_long(&kbuf, &left, &val, &neg, proc_wspace_sep, sizeof(proc_wspace_sep), NULL); if (err) break; if (neg) continue; if ((min && val < min) \|\| (max && val > max)) continue; i = val; } else { val = convdiv (i) / convmul; if (!first) err = proc_put_char(&buffer, &left, '\t'); err = proc_put_long(&buffer, &left, val, false); if (err) break; } } if (!write && !first && left && !err) err = proc_put_char(&buffer, &left, '\n'); if (write && !err) left -= proc_skip_spaces(&kbuf); free: if (write) { free_page(page); if (first) return err ? : -EINVAL; } lenp -= left; ppos += lenp; return err; } static int do_proc_doulongvec_minmax(struct ctl_table table, int write, void __user buffer, size_t lenp, loff_t ppos, unsigned long convmul, unsigned long convdiv) { return __do_proc_doulongvec_minmax(table->data, table, write, buffer, lenp, ppos, convmul, convdiv); } /** * proc_doulongvec_minmax - read a vector of long integers with min/max values * @table: the sysctl table * @write: %TRUE if this is a write to the sysctl file * @buffer: the user buffer * @lenp: the size of the user buffer * @ppos: file position * * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long * values from/to the user buffer, treated as an ASCII string. * * This routine will ensure the values are within the range specified by * table->extra1 (min) and table->extra2 (max). * * Returns 0 on success. / int proc_doulongvec_minmax(struct ctl_table table, int write, void __user buffer, size_t lenp, loff_t ppos) { return do_proc_doulongvec_minmax(table, write, buffer, lenp, ppos, 1l, 1l); } /* * proc_doulongvec_ms_jiffies_minmax - read a vector of millisecond values with min/max values * @table: the sysctl table * @write: %TRUE if this is a write to the sysctl file * @buffer: the user buffer * @lenp: the size of the user buffer * @ppos: file position * * Reads/writes up to table->maxlen/sizeof(unsigned long) unsigned long * values from/to the user buffer, treated as an ASCII string. The values * are treated as milliseconds, and converted to jiffies when they are stored. * * This routine will ensure the values are within the range specified by * table->extra1 (min) and table->extra2 (max). * * Returns 0 on success. / int proc_doulongvec_ms_jiffies_minmax(struct ctl_table table, int write, void __user buffer, size_t lenp, loff_t ppos) { return do_proc_doulongvec_minmax(table, write, buffer, lenp, ppos, HZ, 1000l); } static int do_proc_dointvec_jiffies_conv(bool negp, unsigned long lvalp, int valp, int write, void data) { if (write) { if (lvalp > LONG_MAX / HZ) return 1; valp = negp ? -(lvalpHZ) : (lvalpHZ); } else { int val = valp; unsigned long lval; if (val < 0) { negp = true; lval = (unsigned long)-val; } else { negp = false; lval = (unsigned long)val; } lvalp = lval / HZ; } return 0; } static int do_proc_dointvec_userhz_jiffies_conv(bool negp, unsigned long lvalp, int valp, int write, void data) { if (write) { if (USER_HZ < HZ && lvalp > (LONG_MAX / HZ) USER_HZ) return 1; valp = clock_t_to_jiffies(negp ? -lvalp : lvalp); } else { int val = valp; unsigned long lval; if (val < 0) { negp = true; lval = (unsigned long)-val; } else { negp = false; lval = (unsigned long)val; } lvalp = jiffies_to_clock_t(lval); } return 0; } static int do_proc_dointvec_ms_jiffies_conv(bool negp, unsigned long lvalp, int valp, int write, void data) { if (write) { valp = msecs_to_jiffies(negp ? -lvalp : lvalp); } else { int val = valp; unsigned long lval; if (val < 0) { negp = true; lval = (unsigned long)-val; } else { negp = false; lval = (unsigned long)val; } lvalp = jiffies_to_msecs(lval); } return 0; } /** * proc_dointvec_jiffies - read a vector of integers as seconds * @table: the sysctl table * @write: %TRUE if this is a write to the sysctl file * @buffer: the user buffer * @lenp: the size of the user buffer * @ppos: file position * * Reads/writes up to table->maxlen/sizeof(unsigned int) integer * values from/to the user buffer, treated as an ASCII string. * The values read are assumed to be in seconds, and are converted into * jiffies. * * Returns 0 on success. / int proc_dointvec_jiffies(struct ctl_table table, int write, void __user buffer, size_t lenp, loff_t ppos) { return do_proc_dointvec(table,write,buffer,lenp,ppos, do_proc_dointvec_jiffies_conv,NULL); } /* * proc_dointvec_userhz_jiffies - read a vector of integers as 1/USER_HZ seconds * @table: the sysctl table * @write: %TRUE if this is a write to the sysctl file * @buffer: the user buffer * @lenp: the size of the user buffer * @ppos: pointer to the file position * * Reads/writes up to table->maxlen/sizeof(unsigned int) integer * values from/to the user buffer, treated as an ASCII string. * The values read are assumed to be in 1/USER_HZ seconds, and * are converted into jiffies. * * Returns 0 on success. / int proc_dointvec_userhz_jiffies(struct ctl_table table, int write, void __user buffer, size_t lenp, loff_t ppos) { return do_proc_dointvec(table,write,buffer,lenp,ppos, do_proc_dointvec_userhz_jiffies_conv,NULL); } /* * proc_dointvec_ms_jiffies - read a vector of integers as 1 milliseconds * @table: the sysctl table * @write: %TRUE if this is a write to the sysctl file * @buffer: the user buffer * @lenp: the size of the user buffer * @ppos: file position * @ppos: the current position in the file * * Reads/writes up to table->maxlen/sizeof(unsigned int) integer * values from/to the user buffer, treated as an ASCII string. * The values read are assumed to be in 1/1000 seconds, and * are converted into jiffies. * * Returns 0 on success. / int proc_dointvec_ms_jiffies(struct ctl_table table, int write, void __user buffer, size_t lenp, loff_t ppos) { return do_proc_dointvec(table, write, buffer, lenp, ppos, do_proc_dointvec_ms_jiffies_conv, NULL); } static int proc_do_cad_pid(struct ctl_table table, int write, void __user buffer, size_t lenp, loff_t ppos) { struct pid new_pid; pid_t tmp; int r; tmp = pid_vnr(cad_pid); r = __do_proc_dointvec(&tmp, table, write, buffer, lenp, ppos, NULL, NULL); if (r \|\| !write) return r; new_pid = find_get_pid(tmp); if (!new_pid) return -ESRCH; put_pid(xchg(&cad_pid, new_pid)); return 0; } /** * proc_do_large_bitmap - read/write from/to a large bitmap * @table: the sysctl table * @write: %TRUE if this is a write to the sysctl file * @buffer: the user buffer * @lenp: the size of the user buffer * @ppos: file position * * The bitmap is stored at table->data and the bitmap length (in bits) * in table->maxlen. * * We use a range comma separated format (e.g. 1,3-4,10-10) so that * large bitmaps may be represented in a compact manner. Writing into * the file will clear the bitmap then update it with the given input. * * Returns 0 on success. / int proc_do_large_bitmap(struct ctl_table table, int write, void __user buffer, size_t lenp, loff_t ppos) { int err = 0; bool first = 1; size_t left = lenp; unsigned long bitmap_len = table->maxlen; unsigned long bitmap = (unsigned long ) table->data; unsigned long tmp_bitmap = NULL; char tr_a[] = { '-', ',', '\n' }, tr_b[] = { ',', '\n', 0 }, c; if (!bitmap_len \|\| !left \|\| (ppos && !write)) { lenp = 0; return 0; } if (write) { unsigned long page = 0; char kbuf; if (left > PAGE_SIZE - 1) left = PAGE_SIZE - 1; page = __get_free_page(GFP_TEMPORARY); kbuf = (char ) page; if (!kbuf) return -ENOMEM; if (copy_from_user(kbuf, buffer, left)) { free_page(page); return -EFAULT; } kbuf[left] = 0; tmp_bitmap = kzalloc(BITS_TO_LONGS(bitmap_len) sizeof(unsigned long), GFP_KERNEL); if (!tmp_bitmap) { free_page(page); return -ENOMEM; } proc_skip_char(&kbuf, &left, '\n'); while (!err && left) { unsigned long val_a, val_b; bool neg; err = proc_get_long(&kbuf, &left, &val_a, &neg, tr_a, sizeof(tr_a), &c); if (err) break; if (val_a >= bitmap_len \|\| neg) { err = -EINVAL; break; } val_b = val_a; if (left) { kbuf++; left--; } if (c == '-') { err = proc_get_long(&kbuf, &left, &val_b, &neg, tr_b, sizeof(tr_b), &c); if (err) break; if (val_b >= bitmap_len \|\| neg \|\| val_a > val_b) { err = -EINVAL; break; } if (left) { kbuf++; left--; } } while (val_a <= val_b) set_bit(val_a++, tmp_bitmap); first = 0; proc_skip_char(&kbuf, &left, '\n'); } free_page(page); } else { unsigned long bit_a, bit_b = 0; while (left) { bit_a = find_next_bit(bitmap, bitmap_len, bit_b); if (bit_a >= bitmap_len) break; bit_b = find_next_zero_bit(bitmap, bitmap_len, bit_a + 1) - 1; if (!first) { err = proc_put_char(&buffer, &left, ','); if (err) break; } err = proc_put_long(&buffer, &left, bit_a, false); if (err) break; if (bit_a != bit_b) { err = proc_put_char(&buffer, &left, '-'); if (err) break; err = proc_put_long(&buffer, &left, bit_b, false); if (err) break; } first = 0; bit_b++; } if (!err) err = proc_put_char(&buffer, &left, '\n'); } if (!err) { if (write) { if (ppos) bitmap_or(bitmap, bitmap, tmp_bitmap, bitmap_len); else memcpy(bitmap, tmp_bitmap, BITS_TO_LONGS(bitmap_len) sizeof(unsigned long)); } kfree(tmp_bitmap); lenp -= left; ppos += lenp; return 0; } else { kfree(tmp_bitmap); return err; } } #else / CONFIG_PROC_SYSCTL / int proc_dostring(struct ctl_table table, int write, void __user buffer, size_t lenp, loff_t ppos) { return -ENOSYS; } int proc_dointvec(struct ctl_table table, int write, void __user buffer, size_t lenp, loff_t ppos) { return -ENOSYS; } int proc_dointvec_minmax(struct ctl_table table, int write, void __user buffer, size_t lenp, loff_t ppos) { return -ENOSYS; } int proc_dointvec_jiffies(struct ctl_table table, int write, void __user buffer, size_t lenp, loff_t ppos) { return -ENOSYS; } int proc_dointvec_userhz_jiffies(struct ctl_table table, int write, void __user buffer, size_t lenp, loff_t ppos) { return -ENOSYS; } int proc_dointvec_ms_jiffies(struct ctl_table table, int write, void __user buffer, size_t lenp, loff_t ppos) { return -ENOSYS; } int proc_doulongvec_minmax(struct ctl_table table, int write, void __user buffer, size_t lenp, loff_t ppos) { return -ENOSYS; } int proc_doulongvec_ms_jiffies_minmax(struct ctl_table table, int write, void __user buffer, size_t lenp, loff_t ppos) { return -ENOSYS; } #endif / CONFIG_PROC_SYSCTL / / * No sense putting this after each symbol definition, twice, * exception granted :-) */ EXPORT_SYMBOL(proc_dointvec); EXPORT_SYMBOL(proc_dointvec_jiffies); EXPORT_SYMBOL(proc_dointvec_minmax); EXPORT_SYMBOL(proc_dointvec_userhz_jiffies); EXPORT_SYMBOL(proc_dointvec_ms_jiffies); EXPORT_SYMBOL(proc_dostring); EXPORT_SYMBOL(proc_doulongvec_minmax); EXPORT_SYMBOL(proc_doulongvec_ms_jiffies_minmax); EXPORT_SYMBOL(register_sysctl_table); EXPORT_SYMBOL(register_sysctl_paths); EXPORT_SYMBOL(unregister_sysctl_table);	./CrossVul/dataset_final_sorted/CWE-264/c/good_3517_0
crossvul-cpp_data_bad_3525_1	/* * sd.c Copyright (C) 1992 Drew Eckhardt * Copyright (C) 1993, 1994, 1995, 1999 Eric Youngdale * * Linux scsi disk driver * Initial versions: Drew Eckhardt * Subsequent revisions: Eric Youngdale * Modification history: * - Drew Eckhardt <drew@colorado.edu> original * - Eric Youngdale <eric@andante.org> add scatter-gather, multiple * outstanding request, and other enhancements. * Support loadable low-level scsi drivers. * - Jirka Hanika <geo@ff.cuni.cz> support more scsi disks using * eight major numbers. * - Richard Gooch <rgooch@atnf.csiro.au> support devfs. * - Torben Mathiasen <tmm@image.dk> Resource allocation fixes in * sd_init and cleanups. * - Alex Davis <letmein@erols.com> Fix problem where partition info * not being read in sd_open. Fix problem where removable media * could be ejected after sd_open. * - Douglas Gilbert <dgilbert@interlog.com> cleanup for lk 2.5.x * - Badari Pulavarty <pbadari@us.ibm.com>, Matthew Wilcox * <willy@debian.org>, Kurt Garloff <garloff@suse.de>: * Support 32k/1M disks. * * Logging policy (needs CONFIG_SCSI_LOGGING defined): * - setting up transfer: SCSI_LOG_HLQUEUE levels 1 and 2 * - end of transfer (bh + scsi_lib): SCSI_LOG_HLCOMPLETE level 1 * - entering sd_ioctl: SCSI_LOG_IOCTL level 1 * - entering other commands: SCSI_LOG_HLQUEUE level 3 * Note: when the logging level is set by the user, it must be greater * than the level indicated above to trigger output. / #include <linux/module.h> #include <linux/fs.h> #include <linux/kernel.h> #include <linux/mm.h> #include <linux/bio.h> #include <linux/genhd.h> #include <linux/hdreg.h> #include <linux/errno.h> #include <linux/idr.h> #include <linux/interrupt.h> #include <linux/init.h> #include <linux/blkdev.h> #include <linux/blkpg.h> #include <linux/delay.h> #include <linux/mutex.h> #include <linux/string_helpers.h> #include <linux/async.h> #include <linux/slab.h> #include <linux/pm_runtime.h> #include <asm/uaccess.h> #include <asm/unaligned.h> #include <scsi/scsi.h> #include <scsi/scsi_cmnd.h> #include <scsi/scsi_dbg.h> #include <scsi/scsi_device.h> #include <scsi/scsi_driver.h> #include <scsi/scsi_eh.h> #include <scsi/scsi_host.h> #include <scsi/scsi_ioctl.h> #include <scsi/scsicam.h> #include "sd.h" #include "scsi_logging.h" MODULE_AUTHOR("Eric Youngdale"); MODULE_DESCRIPTION("SCSI disk (sd) driver"); MODULE_LICENSE("GPL"); MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK0_MAJOR); MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK1_MAJOR); MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK2_MAJOR); MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK3_MAJOR); MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK4_MAJOR); MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK5_MAJOR); MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK6_MAJOR); MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK7_MAJOR); MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK8_MAJOR); MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK9_MAJOR); MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK10_MAJOR); MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK11_MAJOR); MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK12_MAJOR); MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK13_MAJOR); MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK14_MAJOR); MODULE_ALIAS_BLOCKDEV_MAJOR(SCSI_DISK15_MAJOR); MODULE_ALIAS_SCSI_DEVICE(TYPE_DISK); MODULE_ALIAS_SCSI_DEVICE(TYPE_MOD); MODULE_ALIAS_SCSI_DEVICE(TYPE_RBC); #if !defined(CONFIG_DEBUG_BLOCK_EXT_DEVT) #define SD_MINORS 16 #else #define SD_MINORS 0 #endif static void sd_config_discard(struct scsi_disk , unsigned int); static int sd_revalidate_disk(struct gendisk ); static void sd_unlock_native_capacity(struct gendisk disk); static int sd_probe(struct device ); static int sd_remove(struct device ); static void sd_shutdown(struct device ); static int sd_suspend(struct device , pm_message_t state); static int sd_resume(struct device ); static void sd_rescan(struct device ); static int sd_done(struct scsi_cmnd ); static void sd_read_capacity(struct scsi_disk sdkp, unsigned char buffer); static void scsi_disk_release(struct device cdev); static void sd_print_sense_hdr(struct scsi_disk , struct scsi_sense_hdr ); static void sd_print_result(struct scsi_disk , int); static DEFINE_SPINLOCK(sd_index_lock); static DEFINE_IDA(sd_index_ida); / This semaphore is used to mediate the 0->1 reference get in the * face of object destruction (i.e. we can't allow a get on an * object after last put) / static DEFINE_MUTEX(sd_ref_mutex); static struct kmem_cache sd_cdb_cache; static mempool_t sd_cdb_pool; static const char sd_cache_types[] = { "write through", "none", "write back", "write back, no read (daft)" }; static ssize_t sd_store_cache_type(struct device dev, struct device_attribute attr, const char buf, size_t count) { int i, ct = -1, rcd, wce, sp; struct scsi_disk sdkp = to_scsi_disk(dev); struct scsi_device sdp = sdkp->device; char buffer[64]; char buffer_data; struct scsi_mode_data data; struct scsi_sense_hdr sshdr; int len; if (sdp->type != TYPE_DISK) /* no cache control on RBC devices; theoretically they * can do it, but there's probably so many exceptions * it's not worth the risk / return -EINVAL; for (i = 0; i < ARRAY_SIZE(sd_cache_types); i++) { len = strlen(sd_cache_types[i]); if (strncmp(sd_cache_types[i], buf, len) == 0 && buf[len] == '\n') { ct = i; break; } } if (ct < 0) return -EINVAL; rcd = ct & 0x01 ? 1 : 0; wce = ct & 0x02 ? 1 : 0; if (scsi_mode_sense(sdp, 0x08, 8, buffer, sizeof(buffer), SD_TIMEOUT, SD_MAX_RETRIES, &data, NULL)) return -EINVAL; len = min_t(size_t, sizeof(buffer), data.length - data.header_length - data.block_descriptor_length); buffer_data = buffer + data.header_length + data.block_descriptor_length; buffer_data[2] &= ~0x05; buffer_data[2] \|= wce << 2 \| rcd; sp = buffer_data[0] & 0x80 ? 1 : 0; if (scsi_mode_select(sdp, 1, sp, 8, buffer_data, len, SD_TIMEOUT, SD_MAX_RETRIES, &data, &sshdr)) { if (scsi_sense_valid(&sshdr)) sd_print_sense_hdr(sdkp, &sshdr); return -EINVAL; } revalidate_disk(sdkp->disk); return count; } static ssize_t sd_store_manage_start_stop(struct device dev, struct device_attribute attr, const char buf, size_t count) { struct scsi_disk sdkp = to_scsi_disk(dev); struct scsi_device sdp = sdkp->device; if (!capable(CAP_SYS_ADMIN)) return -EACCES; sdp->manage_start_stop = simple_strtoul(buf, NULL, 10); return count; } static ssize_t sd_store_allow_restart(struct device dev, struct device_attribute attr, const char buf, size_t count) { struct scsi_disk sdkp = to_scsi_disk(dev); struct scsi_device sdp = sdkp->device; if (!capable(CAP_SYS_ADMIN)) return -EACCES; if (sdp->type != TYPE_DISK) return -EINVAL; sdp->allow_restart = simple_strtoul(buf, NULL, 10); return count; } static ssize_t sd_show_cache_type(struct device dev, struct device_attribute attr, char buf) { struct scsi_disk sdkp = to_scsi_disk(dev); int ct = sdkp->RCD + 2sdkp->WCE; return snprintf(buf, 40, "%s\n", sd_cache_types[ct]); } static ssize_t sd_show_fua(struct device dev, struct device_attribute attr, char buf) { struct scsi_disk sdkp = to_scsi_disk(dev); return snprintf(buf, 20, "%u\n", sdkp->DPOFUA); } static ssize_t sd_show_manage_start_stop(struct device dev, struct device_attribute attr, char buf) { struct scsi_disk sdkp = to_scsi_disk(dev); struct scsi_device sdp = sdkp->device; return snprintf(buf, 20, "%u\n", sdp->manage_start_stop); } static ssize_t sd_show_allow_restart(struct device dev, struct device_attribute attr, char buf) { struct scsi_disk sdkp = to_scsi_disk(dev); return snprintf(buf, 40, "%d\n", sdkp->device->allow_restart); } static ssize_t sd_show_protection_type(struct device dev, struct device_attribute attr, char buf) { struct scsi_disk sdkp = to_scsi_disk(dev); return snprintf(buf, 20, "%u\n", sdkp->protection_type); } static ssize_t sd_show_protection_mode(struct device dev, struct device_attribute attr, char buf) { struct scsi_disk sdkp = to_scsi_disk(dev); struct scsi_device sdp = sdkp->device; unsigned int dif, dix; dif = scsi_host_dif_capable(sdp->host, sdkp->protection_type); dix = scsi_host_dix_capable(sdp->host, sdkp->protection_type); if (!dix && scsi_host_dix_capable(sdp->host, SD_DIF_TYPE0_PROTECTION)) { dif = 0; dix = 1; } if (!dif && !dix) return snprintf(buf, 20, "none\n"); return snprintf(buf, 20, "%s%u\n", dix ? "dix" : "dif", dif); } static ssize_t sd_show_app_tag_own(struct device dev, struct device_attribute attr, char buf) { struct scsi_disk sdkp = to_scsi_disk(dev); return snprintf(buf, 20, "%u\n", sdkp->ATO); } static ssize_t sd_show_thin_provisioning(struct device dev, struct device_attribute attr, char buf) { struct scsi_disk sdkp = to_scsi_disk(dev); return snprintf(buf, 20, "%u\n", sdkp->lbpme); } static const char lbp_mode[] = { [SD_LBP_FULL] = "full", [SD_LBP_UNMAP] = "unmap", [SD_LBP_WS16] = "writesame_16", [SD_LBP_WS10] = "writesame_10", [SD_LBP_ZERO] = "writesame_zero", [SD_LBP_DISABLE] = "disabled", }; static ssize_t sd_show_provisioning_mode(struct device dev, struct device_attribute attr, char buf) { struct scsi_disk sdkp = to_scsi_disk(dev); return snprintf(buf, 20, "%s\n", lbp_mode[sdkp->provisioning_mode]); } static ssize_t sd_store_provisioning_mode(struct device dev, struct device_attribute attr, const char buf, size_t count) { struct scsi_disk sdkp = to_scsi_disk(dev); struct scsi_device sdp = sdkp->device; if (!capable(CAP_SYS_ADMIN)) return -EACCES; if (sdp->type != TYPE_DISK) return -EINVAL; if (!strncmp(buf, lbp_mode[SD_LBP_UNMAP], 20)) sd_config_discard(sdkp, SD_LBP_UNMAP); else if (!strncmp(buf, lbp_mode[SD_LBP_WS16], 20)) sd_config_discard(sdkp, SD_LBP_WS16); else if (!strncmp(buf, lbp_mode[SD_LBP_WS10], 20)) sd_config_discard(sdkp, SD_LBP_WS10); else if (!strncmp(buf, lbp_mode[SD_LBP_ZERO], 20)) sd_config_discard(sdkp, SD_LBP_ZERO); else if (!strncmp(buf, lbp_mode[SD_LBP_DISABLE], 20)) sd_config_discard(sdkp, SD_LBP_DISABLE); else return -EINVAL; return count; } static struct device_attribute sd_disk_attrs[] = { __ATTR(cache_type, S_IRUGO\|S_IWUSR, sd_show_cache_type, sd_store_cache_type), __ATTR(FUA, S_IRUGO, sd_show_fua, NULL), __ATTR(allow_restart, S_IRUGO\|S_IWUSR, sd_show_allow_restart, sd_store_allow_restart), __ATTR(manage_start_stop, S_IRUGO\|S_IWUSR, sd_show_manage_start_stop, sd_store_manage_start_stop), __ATTR(protection_type, S_IRUGO, sd_show_protection_type, NULL), __ATTR(protection_mode, S_IRUGO, sd_show_protection_mode, NULL), __ATTR(app_tag_own, S_IRUGO, sd_show_app_tag_own, NULL), __ATTR(thin_provisioning, S_IRUGO, sd_show_thin_provisioning, NULL), __ATTR(provisioning_mode, S_IRUGO\|S_IWUSR, sd_show_provisioning_mode, sd_store_provisioning_mode), __ATTR_NULL, }; static struct class sd_disk_class = { .name = "scsi_disk", .owner = THIS_MODULE, .dev_release = scsi_disk_release, .dev_attrs = sd_disk_attrs, }; static struct scsi_driver sd_template = { .owner = THIS_MODULE, .gendrv = { .name = "sd", .probe = sd_probe, .remove = sd_remove, .suspend = sd_suspend, .resume = sd_resume, .shutdown = sd_shutdown, }, .rescan = sd_rescan, .done = sd_done, }; /* * Device no to disk mapping: * * major disc2 disc p1 * \|............\|.............\|....\|....\| <- dev_t * 31 20 19 8 7 4 3 0 * * Inside a major, we have 16k disks, however mapped non- * contiguously. The first 16 disks are for major0, the next * ones with major1, ... Disk 256 is for major0 again, disk 272 * for major1, ... * As we stay compatible with our numbering scheme, we can reuse * the well-know SCSI majors 8, 65--71, 136--143. / static int sd_major(int major_idx) { switch (major_idx) { case 0: return SCSI_DISK0_MAJOR; case 1 ... 7: return SCSI_DISK1_MAJOR + major_idx - 1; case 8 ... 15: return SCSI_DISK8_MAJOR + major_idx - 8; default: BUG(); return 0; / shut up gcc / } } static struct scsi_disk __scsi_disk_get(struct gendisk disk) { struct scsi_disk sdkp = NULL; if (disk->private_data) { sdkp = scsi_disk(disk); if (scsi_device_get(sdkp->device) == 0) get_device(&sdkp->dev); else sdkp = NULL; } return sdkp; } static struct scsi_disk scsi_disk_get(struct gendisk disk) { struct scsi_disk sdkp; mutex_lock(&sd_ref_mutex); sdkp = __scsi_disk_get(disk); mutex_unlock(&sd_ref_mutex); return sdkp; } static struct scsi_disk scsi_disk_get_from_dev(struct device dev) { struct scsi_disk sdkp; mutex_lock(&sd_ref_mutex); sdkp = dev_get_drvdata(dev); if (sdkp) sdkp = __scsi_disk_get(sdkp->disk); mutex_unlock(&sd_ref_mutex); return sdkp; } static void scsi_disk_put(struct scsi_disk sdkp) { struct scsi_device sdev = sdkp->device; mutex_lock(&sd_ref_mutex); put_device(&sdkp->dev); scsi_device_put(sdev); mutex_unlock(&sd_ref_mutex); } static void sd_prot_op(struct scsi_cmnd scmd, unsigned int dif) { unsigned int prot_op = SCSI_PROT_NORMAL; unsigned int dix = scsi_prot_sg_count(scmd); if (scmd->sc_data_direction == DMA_FROM_DEVICE) { if (dif && dix) prot_op = SCSI_PROT_READ_PASS; else if (dif && !dix) prot_op = SCSI_PROT_READ_STRIP; else if (!dif && dix) prot_op = SCSI_PROT_READ_INSERT; } else { if (dif && dix) prot_op = SCSI_PROT_WRITE_PASS; else if (dif && !dix) prot_op = SCSI_PROT_WRITE_INSERT; else if (!dif && dix) prot_op = SCSI_PROT_WRITE_STRIP; } scsi_set_prot_op(scmd, prot_op); scsi_set_prot_type(scmd, dif); } static void sd_config_discard(struct scsi_disk sdkp, unsigned int mode) { struct request_queue q = sdkp->disk->queue; unsigned int logical_block_size = sdkp->device->sector_size; unsigned int max_blocks = 0; q->limits.discard_zeroes_data = sdkp->lbprz; q->limits.discard_alignment = sdkp->unmap_alignment logical_block_size; q->limits.discard_granularity = max(sdkp->physical_block_size, sdkp->unmap_granularity * logical_block_size); switch (mode) { case SD_LBP_DISABLE: q->limits.max_discard_sectors = 0; queue_flag_clear_unlocked(QUEUE_FLAG_DISCARD, q); return; case SD_LBP_UNMAP: max_blocks = min_not_zero(sdkp->max_unmap_blocks, 0xffffffff); break; case SD_LBP_WS16: max_blocks = min_not_zero(sdkp->max_ws_blocks, 0xffffffff); break; case SD_LBP_WS10: max_blocks = min_not_zero(sdkp->max_ws_blocks, (u32)0xffff); break; case SD_LBP_ZERO: max_blocks = min_not_zero(sdkp->max_ws_blocks, (u32)0xffff); q->limits.discard_zeroes_data = 1; break; } q->limits.max_discard_sectors = max_blocks * (logical_block_size >> 9); queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, q); sdkp->provisioning_mode = mode; } /** * scsi_setup_discard_cmnd - unmap blocks on thinly provisioned device * @sdp: scsi device to operate one * @rq: Request to prepare * * Will issue either UNMAP or WRITE SAME(16) depending on preference * indicated by target device. */ static int scsi_setup_discard_cmnd(struct scsi_device sdp, struct request rq) { struct scsi_disk sdkp = scsi_disk(rq->rq_disk); struct bio bio = rq->bio; sector_t sector = bio->bi_sector; unsigned int nr_sectors = bio_sectors(bio); unsigned int len; int ret; char buf; struct page page; if (sdkp->device->sector_size == 4096) { sector >>= 3; nr_sectors >>= 3; } rq->timeout = SD_TIMEOUT; memset(rq->cmd, 0, rq->cmd_len); page = alloc_page(GFP_ATOMIC \| __GFP_ZERO); if (!page) return BLKPREP_DEFER; switch (sdkp->provisioning_mode) { case SD_LBP_UNMAP: buf = page_address(page); rq->cmd_len = 10; rq->cmd[0] = UNMAP; rq->cmd[8] = 24; put_unaligned_be16(6 + 16, &buf[0]); put_unaligned_be16(16, &buf[2]); put_unaligned_be64(sector, &buf[8]); put_unaligned_be32(nr_sectors, &buf[16]); len = 24; break; case SD_LBP_WS16: rq->cmd_len = 16; rq->cmd[0] = WRITE_SAME_16; rq->cmd[1] = 0x8; / UNMAP / put_unaligned_be64(sector, &rq->cmd[2]); put_unaligned_be32(nr_sectors, &rq->cmd[10]); len = sdkp->device->sector_size; break; case SD_LBP_WS10: case SD_LBP_ZERO: rq->cmd_len = 10; rq->cmd[0] = WRITE_SAME; if (sdkp->provisioning_mode == SD_LBP_WS10) rq->cmd[1] = 0x8; / UNMAP / put_unaligned_be32(sector, &rq->cmd[2]); put_unaligned_be16(nr_sectors, &rq->cmd[7]); len = sdkp->device->sector_size; break; default: ret = BLKPREP_KILL; goto out; } blk_add_request_payload(rq, page, len); ret = scsi_setup_blk_pc_cmnd(sdp, rq); rq->buffer = page_address(page); out: if (ret != BLKPREP_OK) { __free_page(page); rq->buffer = NULL; } return ret; } static int scsi_setup_flush_cmnd(struct scsi_device sdp, struct request rq) { rq->timeout = SD_FLUSH_TIMEOUT; rq->retries = SD_MAX_RETRIES; rq->cmd[0] = SYNCHRONIZE_CACHE; rq->cmd_len = 10; return scsi_setup_blk_pc_cmnd(sdp, rq); } static void sd_unprep_fn(struct request_queue q, struct request rq) { if (rq->cmd_flags & REQ_DISCARD) { free_page((unsigned long)rq->buffer); rq->buffer = NULL; } } /* * sd_init_command - build a scsi (read or write) command from * information in the request structure. * @SCpnt: pointer to mid-level's per scsi command structure that * contains request and into which the scsi command is written * * Returns 1 if successful and 0 if error (or cannot be done now). */ static int sd_prep_fn(struct request_queue q, struct request rq) { struct scsi_cmnd SCpnt; struct scsi_device sdp = q->queuedata; struct gendisk disk = rq->rq_disk; struct scsi_disk sdkp; sector_t block = blk_rq_pos(rq); sector_t threshold; unsigned int this_count = blk_rq_sectors(rq); int ret, host_dif; unsigned char protect; / * Discard request come in as REQ_TYPE_FS but we turn them into * block PC requests to make life easier. / if (rq->cmd_flags & REQ_DISCARD) { ret = scsi_setup_discard_cmnd(sdp, rq); goto out; } else if (rq->cmd_flags & REQ_FLUSH) { ret = scsi_setup_flush_cmnd(sdp, rq); goto out; } else if (rq->cmd_type == REQ_TYPE_BLOCK_PC) { ret = scsi_setup_blk_pc_cmnd(sdp, rq); goto out; } else if (rq->cmd_type != REQ_TYPE_FS) { ret = BLKPREP_KILL; goto out; } ret = scsi_setup_fs_cmnd(sdp, rq); if (ret != BLKPREP_OK) goto out; SCpnt = rq->special; sdkp = scsi_disk(disk); / from here on until we're complete, any goto out * is used for a killable error condition / ret = BLKPREP_KILL; SCSI_LOG_HLQUEUE(1, scmd_printk(KERN_INFO, SCpnt, "sd_init_command: block=%llu, " "count=%d\n", (unsigned long long)block, this_count)); if (!sdp \|\| !scsi_device_online(sdp) \|\| block + blk_rq_sectors(rq) > get_capacity(disk)) { SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt, "Finishing %u sectors\n", blk_rq_sectors(rq))); SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt, "Retry with 0x%p\n", SCpnt)); goto out; } if (sdp->changed) { / * quietly refuse to do anything to a changed disc until * the changed bit has been reset / / printk("SCSI disk has been changed or is not present. Prohibiting further I/O.\n"); / goto out; } / * Some SD card readers can't handle multi-sector accesses which touch * the last one or two hardware sectors. Split accesses as needed. / threshold = get_capacity(disk) - SD_LAST_BUGGY_SECTORS (sdp->sector_size / 512); if (unlikely(sdp->last_sector_bug && block + this_count > threshold)) { if (block < threshold) { /* Access up to the threshold but not beyond / this_count = threshold - block; } else { / Access only a single hardware sector / this_count = sdp->sector_size / 512; } } SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt, "block=%llu\n", (unsigned long long)block)); / * If we have a 1K hardware sectorsize, prevent access to single * 512 byte sectors. In theory we could handle this - in fact * the scsi cdrom driver must be able to handle this because * we typically use 1K blocksizes, and cdroms typically have * 2K hardware sectorsizes. Of course, things are simpler * with the cdrom, since it is read-only. For performance * reasons, the filesystems should be able to handle this * and not force the scsi disk driver to use bounce buffers * for this. / if (sdp->sector_size == 1024) { if ((block & 1) \|\| (blk_rq_sectors(rq) & 1)) { scmd_printk(KERN_ERR, SCpnt, "Bad block number requested\n"); goto out; } else { block = block >> 1; this_count = this_count >> 1; } } if (sdp->sector_size == 2048) { if ((block & 3) \|\| (blk_rq_sectors(rq) & 3)) { scmd_printk(KERN_ERR, SCpnt, "Bad block number requested\n"); goto out; } else { block = block >> 2; this_count = this_count >> 2; } } if (sdp->sector_size == 4096) { if ((block & 7) \|\| (blk_rq_sectors(rq) & 7)) { scmd_printk(KERN_ERR, SCpnt, "Bad block number requested\n"); goto out; } else { block = block >> 3; this_count = this_count >> 3; } } if (rq_data_dir(rq) == WRITE) { if (!sdp->writeable) { goto out; } SCpnt->cmnd[0] = WRITE_6; SCpnt->sc_data_direction = DMA_TO_DEVICE; if (blk_integrity_rq(rq) && sd_dif_prepare(rq, block, sdp->sector_size) == -EIO) goto out; } else if (rq_data_dir(rq) == READ) { SCpnt->cmnd[0] = READ_6; SCpnt->sc_data_direction = DMA_FROM_DEVICE; } else { scmd_printk(KERN_ERR, SCpnt, "Unknown command %x\n", rq->cmd_flags); goto out; } SCSI_LOG_HLQUEUE(2, scmd_printk(KERN_INFO, SCpnt, "%s %d/%u 512 byte blocks.\n", (rq_data_dir(rq) == WRITE) ? "writing" : "reading", this_count, blk_rq_sectors(rq))); / Set RDPROTECT/WRPROTECT if disk is formatted with DIF / host_dif = scsi_host_dif_capable(sdp->host, sdkp->protection_type); if (host_dif) protect = 1 << 5; else protect = 0; if (host_dif == SD_DIF_TYPE2_PROTECTION) { SCpnt->cmnd = mempool_alloc(sd_cdb_pool, GFP_ATOMIC); if (unlikely(SCpnt->cmnd == NULL)) { ret = BLKPREP_DEFER; goto out; } SCpnt->cmd_len = SD_EXT_CDB_SIZE; memset(SCpnt->cmnd, 0, SCpnt->cmd_len); SCpnt->cmnd[0] = VARIABLE_LENGTH_CMD; SCpnt->cmnd[7] = 0x18; SCpnt->cmnd[9] = (rq_data_dir(rq) == READ) ? READ_32 : WRITE_32; SCpnt->cmnd[10] = protect \| ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0); / LBA / SCpnt->cmnd[12] = sizeof(block) > 4 ? (unsigned char) (block >> 56) & 0xff : 0; SCpnt->cmnd[13] = sizeof(block) > 4 ? (unsigned char) (block >> 48) & 0xff : 0; SCpnt->cmnd[14] = sizeof(block) > 4 ? (unsigned char) (block >> 40) & 0xff : 0; SCpnt->cmnd[15] = sizeof(block) > 4 ? (unsigned char) (block >> 32) & 0xff : 0; SCpnt->cmnd[16] = (unsigned char) (block >> 24) & 0xff; SCpnt->cmnd[17] = (unsigned char) (block >> 16) & 0xff; SCpnt->cmnd[18] = (unsigned char) (block >> 8) & 0xff; SCpnt->cmnd[19] = (unsigned char) block & 0xff; / Expected Indirect LBA / SCpnt->cmnd[20] = (unsigned char) (block >> 24) & 0xff; SCpnt->cmnd[21] = (unsigned char) (block >> 16) & 0xff; SCpnt->cmnd[22] = (unsigned char) (block >> 8) & 0xff; SCpnt->cmnd[23] = (unsigned char) block & 0xff; / Transfer length / SCpnt->cmnd[28] = (unsigned char) (this_count >> 24) & 0xff; SCpnt->cmnd[29] = (unsigned char) (this_count >> 16) & 0xff; SCpnt->cmnd[30] = (unsigned char) (this_count >> 8) & 0xff; SCpnt->cmnd[31] = (unsigned char) this_count & 0xff; } else if (block > 0xffffffff) { SCpnt->cmnd[0] += READ_16 - READ_6; SCpnt->cmnd[1] = protect \| ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0); SCpnt->cmnd[2] = sizeof(block) > 4 ? (unsigned char) (block >> 56) & 0xff : 0; SCpnt->cmnd[3] = sizeof(block) > 4 ? (unsigned char) (block >> 48) & 0xff : 0; SCpnt->cmnd[4] = sizeof(block) > 4 ? (unsigned char) (block >> 40) & 0xff : 0; SCpnt->cmnd[5] = sizeof(block) > 4 ? (unsigned char) (block >> 32) & 0xff : 0; SCpnt->cmnd[6] = (unsigned char) (block >> 24) & 0xff; SCpnt->cmnd[7] = (unsigned char) (block >> 16) & 0xff; SCpnt->cmnd[8] = (unsigned char) (block >> 8) & 0xff; SCpnt->cmnd[9] = (unsigned char) block & 0xff; SCpnt->cmnd[10] = (unsigned char) (this_count >> 24) & 0xff; SCpnt->cmnd[11] = (unsigned char) (this_count >> 16) & 0xff; SCpnt->cmnd[12] = (unsigned char) (this_count >> 8) & 0xff; SCpnt->cmnd[13] = (unsigned char) this_count & 0xff; SCpnt->cmnd[14] = SCpnt->cmnd[15] = 0; } else if ((this_count > 0xff) \|\| (block > 0x1fffff) \|\| scsi_device_protection(SCpnt->device) \|\| SCpnt->device->use_10_for_rw) { if (this_count > 0xffff) this_count = 0xffff; SCpnt->cmnd[0] += READ_10 - READ_6; SCpnt->cmnd[1] = protect \| ((rq->cmd_flags & REQ_FUA) ? 0x8 : 0); SCpnt->cmnd[2] = (unsigned char) (block >> 24) & 0xff; SCpnt->cmnd[3] = (unsigned char) (block >> 16) & 0xff; SCpnt->cmnd[4] = (unsigned char) (block >> 8) & 0xff; SCpnt->cmnd[5] = (unsigned char) block & 0xff; SCpnt->cmnd[6] = SCpnt->cmnd[9] = 0; SCpnt->cmnd[7] = (unsigned char) (this_count >> 8) & 0xff; SCpnt->cmnd[8] = (unsigned char) this_count & 0xff; } else { if (unlikely(rq->cmd_flags & REQ_FUA)) { / * This happens only if this drive failed * 10byte rw command with ILLEGAL_REQUEST * during operation and thus turned off * use_10_for_rw. / scmd_printk(KERN_ERR, SCpnt, "FUA write on READ/WRITE(6) drive\n"); goto out; } SCpnt->cmnd[1] \|= (unsigned char) ((block >> 16) & 0x1f); SCpnt->cmnd[2] = (unsigned char) ((block >> 8) & 0xff); SCpnt->cmnd[3] = (unsigned char) block & 0xff; SCpnt->cmnd[4] = (unsigned char) this_count; SCpnt->cmnd[5] = 0; } SCpnt->sdb.length = this_count sdp->sector_size; /* If DIF or DIX is enabled, tell HBA how to handle request / if (host_dif \|\| scsi_prot_sg_count(SCpnt)) sd_prot_op(SCpnt, host_dif); / * We shouldn't disconnect in the middle of a sector, so with a dumb * host adapter, it's safe to assume that we can at least transfer * this many bytes between each connect / disconnect. / SCpnt->transfersize = sdp->sector_size; SCpnt->underflow = this_count << 9; SCpnt->allowed = SD_MAX_RETRIES; / * This indicates that the command is ready from our end to be * queued. / ret = BLKPREP_OK; out: return scsi_prep_return(q, rq, ret); } /* * sd_open - open a scsi disk device * @inode: only i_rdev member may be used * @filp: only f_mode and f_flags may be used * * Returns 0 if successful. Returns a negated errno value in case * of error. * * Note: This can be called from a user context (e.g. fsck(1) ) * or from within the kernel (e.g. as a result of a mount(1) ). * In the latter case @inode and @filp carry an abridged amount * of information as noted above. * * Locking: called with bdev->bd_mutex held. */ static int sd_open(struct block_device bdev, fmode_t mode) { struct scsi_disk sdkp = scsi_disk_get(bdev->bd_disk); struct scsi_device sdev; int retval; if (!sdkp) return -ENXIO; SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_open\n")); sdev = sdkp->device; retval = scsi_autopm_get_device(sdev); if (retval) goto error_autopm; /* * If the device is in error recovery, wait until it is done. * If the device is offline, then disallow any access to it. / retval = -ENXIO; if (!scsi_block_when_processing_errors(sdev)) goto error_out; if (sdev->removable \|\| sdkp->write_prot) check_disk_change(bdev); / * If the drive is empty, just let the open fail. / retval = -ENOMEDIUM; if (sdev->removable && !sdkp->media_present && !(mode & FMODE_NDELAY)) goto error_out; / * If the device has the write protect tab set, have the open fail * if the user expects to be able to write to the thing. / retval = -EROFS; if (sdkp->write_prot && (mode & FMODE_WRITE)) goto error_out; / * It is possible that the disk changing stuff resulted in * the device being taken offline. If this is the case, * report this to the user, and don't pretend that the * open actually succeeded. / retval = -ENXIO; if (!scsi_device_online(sdev)) goto error_out; if ((atomic_inc_return(&sdkp->openers) == 1) && sdev->removable) { if (scsi_block_when_processing_errors(sdev)) scsi_set_medium_removal(sdev, SCSI_REMOVAL_PREVENT); } return 0; error_out: scsi_autopm_put_device(sdev); error_autopm: scsi_disk_put(sdkp); return retval; } /* * sd_release - invoked when the (last) close(2) is called on this * scsi disk. * @inode: only i_rdev member may be used * @filp: only f_mode and f_flags may be used * * Returns 0. * * Note: may block (uninterruptible) if error recovery is underway * on this disk. * * Locking: called with bdev->bd_mutex held. */ static int sd_release(struct gendisk disk, fmode_t mode) { struct scsi_disk sdkp = scsi_disk(disk); struct scsi_device sdev = sdkp->device; SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_release\n")); if (atomic_dec_return(&sdkp->openers) == 0 && sdev->removable) { if (scsi_block_when_processing_errors(sdev)) scsi_set_medium_removal(sdev, SCSI_REMOVAL_ALLOW); } /* * XXX and what if there are packets in flight and this close() * XXX is followed by a "rmmod sd_mod"? / scsi_autopm_put_device(sdev); scsi_disk_put(sdkp); return 0; } static int sd_getgeo(struct block_device bdev, struct hd_geometry geo) { struct scsi_disk sdkp = scsi_disk(bdev->bd_disk); struct scsi_device sdp = sdkp->device; struct Scsi_Host host = sdp->host; int diskinfo[4]; /* default to most commonly used values / diskinfo[0] = 0x40; / 1 << 6 / diskinfo[1] = 0x20; / 1 << 5 / diskinfo[2] = sdkp->capacity >> 11; / override with calculated, extended default, or driver values / if (host->hostt->bios_param) host->hostt->bios_param(sdp, bdev, sdkp->capacity, diskinfo); else scsicam_bios_param(bdev, sdkp->capacity, diskinfo); geo->heads = diskinfo[0]; geo->sectors = diskinfo[1]; geo->cylinders = diskinfo[2]; return 0; } /* * sd_ioctl - process an ioctl * @inode: only i_rdev/i_bdev members may be used * @filp: only f_mode and f_flags may be used * @cmd: ioctl command number * @arg: this is third argument given to ioctl(2) system call. * Often contains a pointer. * * Returns 0 if successful (some ioctls return positive numbers on * success as well). Returns a negated errno value in case of error. * * Note: most ioctls are forward onto the block subsystem or further * down in the scsi subsystem. */ static int sd_ioctl(struct block_device bdev, fmode_t mode, unsigned int cmd, unsigned long arg) { struct gendisk disk = bdev->bd_disk; struct scsi_disk sdkp = scsi_disk(disk); struct scsi_device sdp = sdkp->device; void __user p = (void __user )arg; int error; SCSI_LOG_IOCTL(1, sd_printk(KERN_INFO, sdkp, "sd_ioctl: disk=%s, " "cmd=0x%x\n", disk->disk_name, cmd)); / * If we are in the middle of error recovery, don't let anyone * else try and use this device. Also, if error recovery fails, it * may try and take the device offline, in which case all further * access to the device is prohibited. / error = scsi_nonblockable_ioctl(sdp, cmd, p, (mode & FMODE_NDELAY) != 0); if (!scsi_block_when_processing_errors(sdp) \|\| !error) goto out; / * Send SCSI addressing ioctls directly to mid level, send other * ioctls to block level and then onto mid level if they can't be * resolved. / switch (cmd) { case SCSI_IOCTL_GET_IDLUN: case SCSI_IOCTL_GET_BUS_NUMBER: error = scsi_ioctl(sdp, cmd, p); break; default: error = scsi_cmd_blk_ioctl(bdev, mode, cmd, p); if (error != -ENOTTY) break; error = scsi_ioctl(sdp, cmd, p); break; } out: return error; } static void set_media_not_present(struct scsi_disk sdkp) { if (sdkp->media_present) sdkp->device->changed = 1; if (sdkp->device->removable) { sdkp->media_present = 0; sdkp->capacity = 0; } } static int media_not_present(struct scsi_disk sdkp, struct scsi_sense_hdr sshdr) { if (!scsi_sense_valid(sshdr)) return 0; /* not invoked for commands that could return deferred errors / switch (sshdr->sense_key) { case UNIT_ATTENTION: case NOT_READY: / medium not present / if (sshdr->asc == 0x3A) { set_media_not_present(sdkp); return 1; } } return 0; } /* * sd_check_events - check media events * @disk: kernel device descriptor * @clearing: disk events currently being cleared * * Returns mask of DISK_EVENT_. * Note: this function is invoked from the block subsystem. */ static unsigned int sd_check_events(struct gendisk disk, unsigned int clearing) { struct scsi_disk sdkp = scsi_disk(disk); struct scsi_device sdp = sdkp->device; struct scsi_sense_hdr sshdr = NULL; int retval; SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_check_events\n")); / * If the device is offline, don't send any commands - just pretend as * if the command failed. If the device ever comes back online, we * can deal with it then. It is only because of unrecoverable errors * that we would ever take a device offline in the first place. / if (!scsi_device_online(sdp)) { set_media_not_present(sdkp); goto out; } / * Using TEST_UNIT_READY enables differentiation between drive with * no cartridge loaded - NOT READY, drive with changed cartridge - * UNIT ATTENTION, or with same cartridge - GOOD STATUS. * * Drives that auto spin down. eg iomega jaz 1G, will be started * by sd_spinup_disk() from sd_revalidate_disk(), which happens whenever * sd_revalidate() is called. / retval = -ENODEV; if (scsi_block_when_processing_errors(sdp)) { sshdr = kzalloc(sizeof(sshdr), GFP_KERNEL); retval = scsi_test_unit_ready(sdp, SD_TIMEOUT, SD_MAX_RETRIES, sshdr); } /* failed to execute TUR, assume media not present / if (host_byte(retval)) { set_media_not_present(sdkp); goto out; } if (media_not_present(sdkp, sshdr)) goto out; / * For removable scsi disk we have to recognise the presence * of a disk in the drive. / if (!sdkp->media_present) sdp->changed = 1; sdkp->media_present = 1; out: / * sdp->changed is set under the following conditions: * * Medium present state has changed in either direction. * Device has indicated UNIT_ATTENTION. / kfree(sshdr); retval = sdp->changed ? DISK_EVENT_MEDIA_CHANGE : 0; sdp->changed = 0; return retval; } static int sd_sync_cache(struct scsi_disk sdkp) { int retries, res; struct scsi_device sdp = sdkp->device; struct scsi_sense_hdr sshdr; if (!scsi_device_online(sdp)) return -ENODEV; for (retries = 3; retries > 0; --retries) { unsigned char cmd[10] = { 0 }; cmd[0] = SYNCHRONIZE_CACHE; / * Leave the rest of the command zero to indicate * flush everything. / res = scsi_execute_req(sdp, cmd, DMA_NONE, NULL, 0, &sshdr, SD_FLUSH_TIMEOUT, SD_MAX_RETRIES, NULL); if (res == 0) break; } if (res) { sd_print_result(sdkp, res); if (driver_byte(res) & DRIVER_SENSE) sd_print_sense_hdr(sdkp, &sshdr); } if (res) return -EIO; return 0; } static void sd_rescan(struct device dev) { struct scsi_disk sdkp = scsi_disk_get_from_dev(dev); if (sdkp) { revalidate_disk(sdkp->disk); scsi_disk_put(sdkp); } } #ifdef CONFIG_COMPAT / * This gets directly called from VFS. When the ioctl * is not recognized we go back to the other translation paths. / static int sd_compat_ioctl(struct block_device bdev, fmode_t mode, unsigned int cmd, unsigned long arg) { struct scsi_device sdev = scsi_disk(bdev->bd_disk)->device; / * If we are in the middle of error recovery, don't let anyone * else try and use this device. Also, if error recovery fails, it * may try and take the device offline, in which case all further * access to the device is prohibited. / if (!scsi_block_when_processing_errors(sdev)) return -ENODEV; if (sdev->host->hostt->compat_ioctl) { int ret; ret = sdev->host->hostt->compat_ioctl(sdev, cmd, (void __user )arg); return ret; } /* * Let the static ioctl translation table take care of it. / return -ENOIOCTLCMD; } #endif static const struct block_device_operations sd_fops = { .owner = THIS_MODULE, .open = sd_open, .release = sd_release, .ioctl = sd_ioctl, .getgeo = sd_getgeo, #ifdef CONFIG_COMPAT .compat_ioctl = sd_compat_ioctl, #endif .check_events = sd_check_events, .revalidate_disk = sd_revalidate_disk, .unlock_native_capacity = sd_unlock_native_capacity, }; static unsigned int sd_completed_bytes(struct scsi_cmnd scmd) { u64 start_lba = blk_rq_pos(scmd->request); u64 end_lba = blk_rq_pos(scmd->request) + (scsi_bufflen(scmd) / 512); u64 bad_lba; int info_valid; /* * resid is optional but mostly filled in. When it's unused, * its value is zero, so we assume the whole buffer transferred / unsigned int transferred = scsi_bufflen(scmd) - scsi_get_resid(scmd); unsigned int good_bytes; if (scmd->request->cmd_type != REQ_TYPE_FS) return 0; info_valid = scsi_get_sense_info_fld(scmd->sense_buffer, SCSI_SENSE_BUFFERSIZE, &bad_lba); if (!info_valid) return 0; if (scsi_bufflen(scmd) <= scmd->device->sector_size) return 0; if (scmd->device->sector_size < 512) { / only legitimate sector_size here is 256 / start_lba <<= 1; end_lba <<= 1; } else { / be careful ... don't want any overflows / u64 factor = scmd->device->sector_size / 512; do_div(start_lba, factor); do_div(end_lba, factor); } / The bad lba was reported incorrectly, we have no idea where * the error is. / if (bad_lba < start_lba \|\| bad_lba >= end_lba) return 0; / This computation should always be done in terms of * the resolution of the device's medium. / good_bytes = (bad_lba - start_lba) scmd->device->sector_size; return min(good_bytes, transferred); } /** * sd_done - bottom half handler: called when the lower level * driver has completed (successfully or otherwise) a scsi command. * @SCpnt: mid-level's per command structure. * * Note: potentially run from within an ISR. Must not block. */ static int sd_done(struct scsi_cmnd SCpnt) { int result = SCpnt->result; unsigned int good_bytes = result ? 0 : scsi_bufflen(SCpnt); struct scsi_sense_hdr sshdr; struct scsi_disk sdkp = scsi_disk(SCpnt->request->rq_disk); int sense_valid = 0; int sense_deferred = 0; unsigned char op = SCpnt->cmnd[0]; if ((SCpnt->request->cmd_flags & REQ_DISCARD) && !result) scsi_set_resid(SCpnt, 0); if (result) { sense_valid = scsi_command_normalize_sense(SCpnt, &sshdr); if (sense_valid) sense_deferred = scsi_sense_is_deferred(&sshdr); } #ifdef CONFIG_SCSI_LOGGING SCSI_LOG_HLCOMPLETE(1, scsi_print_result(SCpnt)); if (sense_valid) { SCSI_LOG_HLCOMPLETE(1, scmd_printk(KERN_INFO, SCpnt, "sd_done: sb[respc,sk,asc," "ascq]=%x,%x,%x,%x\n", sshdr.response_code, sshdr.sense_key, sshdr.asc, sshdr.ascq)); } #endif if (driver_byte(result) != DRIVER_SENSE && (!sense_valid \|\| sense_deferred)) goto out; switch (sshdr.sense_key) { case HARDWARE_ERROR: case MEDIUM_ERROR: good_bytes = sd_completed_bytes(SCpnt); break; case RECOVERED_ERROR: good_bytes = scsi_bufflen(SCpnt); break; case NO_SENSE: / This indicates a false check condition, so ignore it. An * unknown amount of data was transferred so treat it as an * error. / scsi_print_sense("sd", SCpnt); SCpnt->result = 0; memset(SCpnt->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE); break; case ABORTED_COMMAND: if (sshdr.asc == 0x10) / DIF: Target detected corruption / good_bytes = sd_completed_bytes(SCpnt); break; case ILLEGAL_REQUEST: if (sshdr.asc == 0x10) / DIX: Host detected corruption / good_bytes = sd_completed_bytes(SCpnt); / INVALID COMMAND OPCODE or INVALID FIELD IN CDB / if ((sshdr.asc == 0x20 \|\| sshdr.asc == 0x24) && (op == UNMAP \|\| op == WRITE_SAME_16 \|\| op == WRITE_SAME)) sd_config_discard(sdkp, SD_LBP_DISABLE); break; default: break; } out: if (rq_data_dir(SCpnt->request) == READ && scsi_prot_sg_count(SCpnt)) sd_dif_complete(SCpnt, good_bytes); if (scsi_host_dif_capable(sdkp->device->host, sdkp->protection_type) == SD_DIF_TYPE2_PROTECTION && SCpnt->cmnd != SCpnt->request->cmd) { / We have to print a failed command here as the * extended CDB gets freed before scsi_io_completion() * is called. / if (result) scsi_print_command(SCpnt); mempool_free(SCpnt->cmnd, sd_cdb_pool); SCpnt->cmnd = NULL; SCpnt->cmd_len = 0; } return good_bytes; } / * spinup disk - called only in sd_revalidate_disk() / static void sd_spinup_disk(struct scsi_disk sdkp) { unsigned char cmd[10]; unsigned long spintime_expire = 0; int retries, spintime; unsigned int the_result; struct scsi_sense_hdr sshdr; int sense_valid = 0; spintime = 0; /* Spin up drives, as required. Only do this at boot time / / Spinup needs to be done for module loads too. / do { retries = 0; do { cmd[0] = TEST_UNIT_READY; memset((void ) &cmd[1], 0, 9); the_result = scsi_execute_req(sdkp->device, cmd, DMA_NONE, NULL, 0, &sshdr, SD_TIMEOUT, SD_MAX_RETRIES, NULL); /* * If the drive has indicated to us that it * doesn't have any media in it, don't bother * with any more polling. / if (media_not_present(sdkp, &sshdr)) return; if (the_result) sense_valid = scsi_sense_valid(&sshdr); retries++; } while (retries < 3 && (!scsi_status_is_good(the_result) \|\| ((driver_byte(the_result) & DRIVER_SENSE) && sense_valid && sshdr.sense_key == UNIT_ATTENTION))); if ((driver_byte(the_result) & DRIVER_SENSE) == 0) { / no sense, TUR either succeeded or failed * with a status error / if(!spintime && !scsi_status_is_good(the_result)) { sd_printk(KERN_NOTICE, sdkp, "Unit Not Ready\n"); sd_print_result(sdkp, the_result); } break; } / * The device does not want the automatic start to be issued. / if (sdkp->device->no_start_on_add) break; if (sense_valid && sshdr.sense_key == NOT_READY) { if (sshdr.asc == 4 && sshdr.ascq == 3) break; / manual intervention required / if (sshdr.asc == 4 && sshdr.ascq == 0xb) break; / standby / if (sshdr.asc == 4 && sshdr.ascq == 0xc) break; / unavailable / / * Issue command to spin up drive when not ready / if (!spintime) { sd_printk(KERN_NOTICE, sdkp, "Spinning up disk..."); cmd[0] = START_STOP; cmd[1] = 1; / Return immediately / memset((void ) &cmd[2], 0, 8); cmd[4] = 1; /* Start spin cycle / if (sdkp->device->start_stop_pwr_cond) cmd[4] \|= 1 << 4; scsi_execute_req(sdkp->device, cmd, DMA_NONE, NULL, 0, &sshdr, SD_TIMEOUT, SD_MAX_RETRIES, NULL); spintime_expire = jiffies + 100 HZ; spintime = 1; } /* Wait 1 second for next try / msleep(1000); printk("."); / * Wait for USB flash devices with slow firmware. * Yes, this sense key/ASC combination shouldn't * occur here. It's characteristic of these devices. / } else if (sense_valid && sshdr.sense_key == UNIT_ATTENTION && sshdr.asc == 0x28) { if (!spintime) { spintime_expire = jiffies + 5 HZ; spintime = 1; } /* Wait 1 second for next try / msleep(1000); } else { / we don't understand the sense code, so it's * probably pointless to loop / if(!spintime) { sd_printk(KERN_NOTICE, sdkp, "Unit Not Ready\n"); sd_print_sense_hdr(sdkp, &sshdr); } break; } } while (spintime && time_before_eq(jiffies, spintime_expire)); if (spintime) { if (scsi_status_is_good(the_result)) printk("ready\n"); else printk("not responding...\n"); } } / * Determine whether disk supports Data Integrity Field. / static void sd_read_protection_type(struct scsi_disk sdkp, unsigned char buffer) { struct scsi_device sdp = sdkp->device; u8 type; if (scsi_device_protection(sdp) == 0 \|\| (buffer[12] & 1) == 0) return; type = ((buffer[12] >> 1) & 7) + 1; /* P_TYPE 0 = Type 1 / if (type == sdkp->protection_type \|\| !sdkp->first_scan) return; sdkp->protection_type = type; if (type > SD_DIF_TYPE3_PROTECTION) { sd_printk(KERN_ERR, sdkp, "formatted with unsupported " \ "protection type %u. Disabling disk!\n", type); sdkp->capacity = 0; return; } if (scsi_host_dif_capable(sdp->host, type)) sd_printk(KERN_NOTICE, sdkp, "Enabling DIF Type %u protection\n", type); else sd_printk(KERN_NOTICE, sdkp, "Disabling DIF Type %u protection\n", type); } static void read_capacity_error(struct scsi_disk sdkp, struct scsi_device sdp, struct scsi_sense_hdr sshdr, int sense_valid, int the_result) { sd_print_result(sdkp, the_result); if (driver_byte(the_result) & DRIVER_SENSE) sd_print_sense_hdr(sdkp, sshdr); else sd_printk(KERN_NOTICE, sdkp, "Sense not available.\n"); /* * Set dirty bit for removable devices if not ready - * sometimes drives will not report this properly. / if (sdp->removable && sense_valid && sshdr->sense_key == NOT_READY) set_media_not_present(sdkp); / * We used to set media_present to 0 here to indicate no media * in the drive, but some drives fail read capacity even with * media present, so we can't do that. / sdkp->capacity = 0; / unknown mapped to zero - as usual / } #define RC16_LEN 32 #if RC16_LEN > SD_BUF_SIZE #error RC16_LEN must not be more than SD_BUF_SIZE #endif #define READ_CAPACITY_RETRIES_ON_RESET 10 static int read_capacity_16(struct scsi_disk sdkp, struct scsi_device sdp, unsigned char buffer) { unsigned char cmd[16]; struct scsi_sense_hdr sshdr; int sense_valid = 0; int the_result; int retries = 3, reset_retries = READ_CAPACITY_RETRIES_ON_RESET; unsigned int alignment; unsigned long long lba; unsigned sector_size; if (sdp->no_read_capacity_16) return -EINVAL; do { memset(cmd, 0, 16); cmd[0] = SERVICE_ACTION_IN; cmd[1] = SAI_READ_CAPACITY_16; cmd[13] = RC16_LEN; memset(buffer, 0, RC16_LEN); the_result = scsi_execute_req(sdp, cmd, DMA_FROM_DEVICE, buffer, RC16_LEN, &sshdr, SD_TIMEOUT, SD_MAX_RETRIES, NULL); if (media_not_present(sdkp, &sshdr)) return -ENODEV; if (the_result) { sense_valid = scsi_sense_valid(&sshdr); if (sense_valid && sshdr.sense_key == ILLEGAL_REQUEST && (sshdr.asc == 0x20 \|\| sshdr.asc == 0x24) && sshdr.ascq == 0x00) /* Invalid Command Operation Code or * Invalid Field in CDB, just retry * silently with RC10 / return -EINVAL; if (sense_valid && sshdr.sense_key == UNIT_ATTENTION && sshdr.asc == 0x29 && sshdr.ascq == 0x00) / Device reset might occur several times, * give it one more chance / if (--reset_retries > 0) continue; } retries--; } while (the_result && retries); if (the_result) { sd_printk(KERN_NOTICE, sdkp, "READ CAPACITY(16) failed\n"); read_capacity_error(sdkp, sdp, &sshdr, sense_valid, the_result); return -EINVAL; } sector_size = get_unaligned_be32(&buffer[8]); lba = get_unaligned_be64(&buffer[0]); sd_read_protection_type(sdkp, buffer); if ((sizeof(sdkp->capacity) == 4) && (lba >= 0xffffffffULL)) { sd_printk(KERN_ERR, sdkp, "Too big for this kernel. Use a " "kernel compiled with support for large block " "devices.\n"); sdkp->capacity = 0; return -EOVERFLOW; } / Logical blocks per physical block exponent / sdkp->physical_block_size = (1 << (buffer[13] & 0xf)) sector_size; /* Lowest aligned logical block / alignment = ((buffer[14] & 0x3f) << 8 \| buffer[15]) sector_size; blk_queue_alignment_offset(sdp->request_queue, alignment); if (alignment && sdkp->first_scan) sd_printk(KERN_NOTICE, sdkp, "physical block alignment offset: %u\n", alignment); if (buffer[14] & 0x80) { /* LBPME / sdkp->lbpme = 1; if (buffer[14] & 0x40) / LBPRZ / sdkp->lbprz = 1; sd_config_discard(sdkp, SD_LBP_WS16); } sdkp->capacity = lba + 1; return sector_size; } static int read_capacity_10(struct scsi_disk sdkp, struct scsi_device sdp, unsigned char buffer) { unsigned char cmd[16]; struct scsi_sense_hdr sshdr; int sense_valid = 0; int the_result; int retries = 3, reset_retries = READ_CAPACITY_RETRIES_ON_RESET; sector_t lba; unsigned sector_size; do { cmd[0] = READ_CAPACITY; memset(&cmd[1], 0, 9); memset(buffer, 0, 8); the_result = scsi_execute_req(sdp, cmd, DMA_FROM_DEVICE, buffer, 8, &sshdr, SD_TIMEOUT, SD_MAX_RETRIES, NULL); if (media_not_present(sdkp, &sshdr)) return -ENODEV; if (the_result) { sense_valid = scsi_sense_valid(&sshdr); if (sense_valid && sshdr.sense_key == UNIT_ATTENTION && sshdr.asc == 0x29 && sshdr.ascq == 0x00) /* Device reset might occur several times, * give it one more chance / if (--reset_retries > 0) continue; } retries--; } while (the_result && retries); if (the_result) { sd_printk(KERN_NOTICE, sdkp, "READ CAPACITY failed\n"); read_capacity_error(sdkp, sdp, &sshdr, sense_valid, the_result); return -EINVAL; } sector_size = get_unaligned_be32(&buffer[4]); lba = get_unaligned_be32(&buffer[0]); if (sdp->no_read_capacity_16 && (lba == 0xffffffff)) { / Some buggy (usb cardreader) devices return an lba of 0xffffffff when the want to report a size of 0 (with which they really mean no media is present) / sdkp->capacity = 0; sdkp->physical_block_size = sector_size; return sector_size; } if ((sizeof(sdkp->capacity) == 4) && (lba == 0xffffffff)) { sd_printk(KERN_ERR, sdkp, "Too big for this kernel. Use a " "kernel compiled with support for large block " "devices.\n"); sdkp->capacity = 0; return -EOVERFLOW; } sdkp->capacity = lba + 1; sdkp->physical_block_size = sector_size; return sector_size; } static int sd_try_rc16_first(struct scsi_device sdp) { if (sdp->host->max_cmd_len < 16) return 0; if (sdp->scsi_level > SCSI_SPC_2) return 1; if (scsi_device_protection(sdp)) return 1; return 0; } /* * read disk capacity / static void sd_read_capacity(struct scsi_disk sdkp, unsigned char buffer) { int sector_size; struct scsi_device sdp = sdkp->device; sector_t old_capacity = sdkp->capacity; if (sd_try_rc16_first(sdp)) { sector_size = read_capacity_16(sdkp, sdp, buffer); if (sector_size == -EOVERFLOW) goto got_data; if (sector_size == -ENODEV) return; if (sector_size < 0) sector_size = read_capacity_10(sdkp, sdp, buffer); if (sector_size < 0) return; } else { sector_size = read_capacity_10(sdkp, sdp, buffer); if (sector_size == -EOVERFLOW) goto got_data; if (sector_size < 0) return; if ((sizeof(sdkp->capacity) > 4) && (sdkp->capacity > 0xffffffffULL)) { int old_sector_size = sector_size; sd_printk(KERN_NOTICE, sdkp, "Very big device. " "Trying to use READ CAPACITY(16).\n"); sector_size = read_capacity_16(sdkp, sdp, buffer); if (sector_size < 0) { sd_printk(KERN_NOTICE, sdkp, "Using 0xffffffff as device size\n"); sdkp->capacity = 1 + (sector_t) 0xffffffff; sector_size = old_sector_size; goto got_data; } } } /* Some devices are known to return the total number of blocks, * not the highest block number. Some devices have versions * which do this and others which do not. Some devices we might * suspect of doing this but we don't know for certain. * * If we know the reported capacity is wrong, decrement it. If * we can only guess, then assume the number of blocks is even * (usually true but not always) and err on the side of lowering * the capacity. / if (sdp->fix_capacity \|\| (sdp->guess_capacity && (sdkp->capacity & 0x01))) { sd_printk(KERN_INFO, sdkp, "Adjusting the sector count " "from its reported value: %llu\n", (unsigned long long) sdkp->capacity); --sdkp->capacity; } got_data: if (sector_size == 0) { sector_size = 512; sd_printk(KERN_NOTICE, sdkp, "Sector size 0 reported, " "assuming 512.\n"); } if (sector_size != 512 && sector_size != 1024 && sector_size != 2048 && sector_size != 4096 && sector_size != 256) { sd_printk(KERN_NOTICE, sdkp, "Unsupported sector size %d.\n", sector_size); / * The user might want to re-format the drive with * a supported sectorsize. Once this happens, it * would be relatively trivial to set the thing up. * For this reason, we leave the thing in the table. / sdkp->capacity = 0; / * set a bogus sector size so the normal read/write * logic in the block layer will eventually refuse any * request on this device without tripping over power * of two sector size assumptions / sector_size = 512; } blk_queue_logical_block_size(sdp->request_queue, sector_size); { char cap_str_2[10], cap_str_10[10]; u64 sz = (u64)sdkp->capacity << ilog2(sector_size); string_get_size(sz, STRING_UNITS_2, cap_str_2, sizeof(cap_str_2)); string_get_size(sz, STRING_UNITS_10, cap_str_10, sizeof(cap_str_10)); if (sdkp->first_scan \|\| old_capacity != sdkp->capacity) { sd_printk(KERN_NOTICE, sdkp, "%llu %d-byte logical blocks: (%s/%s)\n", (unsigned long long)sdkp->capacity, sector_size, cap_str_10, cap_str_2); if (sdkp->physical_block_size != sector_size) sd_printk(KERN_NOTICE, sdkp, "%u-byte physical blocks\n", sdkp->physical_block_size); } } / Rescale capacity to 512-byte units / if (sector_size == 4096) sdkp->capacity <<= 3; else if (sector_size == 2048) sdkp->capacity <<= 2; else if (sector_size == 1024) sdkp->capacity <<= 1; else if (sector_size == 256) sdkp->capacity >>= 1; blk_queue_physical_block_size(sdp->request_queue, sdkp->physical_block_size); sdkp->device->sector_size = sector_size; } / called with buffer of length 512 / static inline int sd_do_mode_sense(struct scsi_device sdp, int dbd, int modepage, unsigned char buffer, int len, struct scsi_mode_data data, struct scsi_sense_hdr sshdr) { return scsi_mode_sense(sdp, dbd, modepage, buffer, len, SD_TIMEOUT, SD_MAX_RETRIES, data, sshdr); } / * read write protect setting, if possible - called only in sd_revalidate_disk() * called with buffer of length SD_BUF_SIZE / static void sd_read_write_protect_flag(struct scsi_disk sdkp, unsigned char buffer) { int res; struct scsi_device sdp = sdkp->device; struct scsi_mode_data data; int old_wp = sdkp->write_prot; set_disk_ro(sdkp->disk, 0); if (sdp->skip_ms_page_3f) { sd_printk(KERN_NOTICE, sdkp, "Assuming Write Enabled\n"); return; } if (sdp->use_192_bytes_for_3f) { res = sd_do_mode_sense(sdp, 0, 0x3F, buffer, 192, &data, NULL); } else { /* * First attempt: ask for all pages (0x3F), but only 4 bytes. * We have to start carefully: some devices hang if we ask * for more than is available. / res = sd_do_mode_sense(sdp, 0, 0x3F, buffer, 4, &data, NULL); / * Second attempt: ask for page 0 When only page 0 is * implemented, a request for page 3F may return Sense Key * 5: Illegal Request, Sense Code 24: Invalid field in * CDB. / if (!scsi_status_is_good(res)) res = sd_do_mode_sense(sdp, 0, 0, buffer, 4, &data, NULL); / * Third attempt: ask 255 bytes, as we did earlier. / if (!scsi_status_is_good(res)) res = sd_do_mode_sense(sdp, 0, 0x3F, buffer, 255, &data, NULL); } if (!scsi_status_is_good(res)) { sd_printk(KERN_WARNING, sdkp, "Test WP failed, assume Write Enabled\n"); } else { sdkp->write_prot = ((data.device_specific & 0x80) != 0); set_disk_ro(sdkp->disk, sdkp->write_prot); if (sdkp->first_scan \|\| old_wp != sdkp->write_prot) { sd_printk(KERN_NOTICE, sdkp, "Write Protect is %s\n", sdkp->write_prot ? "on" : "off"); sd_printk(KERN_DEBUG, sdkp, "Mode Sense: %02x %02x %02x %02x\n", buffer[0], buffer[1], buffer[2], buffer[3]); } } } / * sd_read_cache_type - called only from sd_revalidate_disk() * called with buffer of length SD_BUF_SIZE / static void sd_read_cache_type(struct scsi_disk sdkp, unsigned char buffer) { int len = 0, res; struct scsi_device sdp = sdkp->device; int dbd; int modepage; int first_len; struct scsi_mode_data data; struct scsi_sense_hdr sshdr; int old_wce = sdkp->WCE; int old_rcd = sdkp->RCD; int old_dpofua = sdkp->DPOFUA; first_len = 4; if (sdp->skip_ms_page_8) { if (sdp->type == TYPE_RBC) goto defaults; else { if (sdp->skip_ms_page_3f) goto defaults; modepage = 0x3F; if (sdp->use_192_bytes_for_3f) first_len = 192; dbd = 0; } } else if (sdp->type == TYPE_RBC) { modepage = 6; dbd = 8; } else { modepage = 8; dbd = 0; } /* cautiously ask / res = sd_do_mode_sense(sdp, dbd, modepage, buffer, first_len, &data, &sshdr); if (!scsi_status_is_good(res)) goto bad_sense; if (!data.header_length) { modepage = 6; first_len = 0; sd_printk(KERN_ERR, sdkp, "Missing header in MODE_SENSE response\n"); } / that went OK, now ask for the proper length / len = data.length; / * We're only interested in the first three bytes, actually. * But the data cache page is defined for the first 20. / if (len < 3) goto bad_sense; else if (len > SD_BUF_SIZE) { sd_printk(KERN_NOTICE, sdkp, "Truncating mode parameter " "data from %d to %d bytes\n", len, SD_BUF_SIZE); len = SD_BUF_SIZE; } if (modepage == 0x3F && sdp->use_192_bytes_for_3f) len = 192; / Get the data / if (len > first_len) res = sd_do_mode_sense(sdp, dbd, modepage, buffer, len, &data, &sshdr); if (scsi_status_is_good(res)) { int offset = data.header_length + data.block_descriptor_length; while (offset < len) { u8 page_code = buffer[offset] & 0x3F; u8 spf = buffer[offset] & 0x40; if (page_code == 8 \|\| page_code == 6) { / We're interested only in the first 3 bytes. / if (len - offset <= 2) { sd_printk(KERN_ERR, sdkp, "Incomplete " "mode parameter data\n"); goto defaults; } else { modepage = page_code; goto Page_found; } } else { / Go to the next page / if (spf && len - offset > 3) offset += 4 + (buffer[offset+2] << 8) + buffer[offset+3]; else if (!spf && len - offset > 1) offset += 2 + buffer[offset+1]; else { sd_printk(KERN_ERR, sdkp, "Incomplete " "mode parameter data\n"); goto defaults; } } } if (modepage == 0x3F) { sd_printk(KERN_ERR, sdkp, "No Caching mode page " "present\n"); goto defaults; } else if ((buffer[offset] & 0x3f) != modepage) { sd_printk(KERN_ERR, sdkp, "Got wrong page\n"); goto defaults; } Page_found: if (modepage == 8) { sdkp->WCE = ((buffer[offset + 2] & 0x04) != 0); sdkp->RCD = ((buffer[offset + 2] & 0x01) != 0); } else { sdkp->WCE = ((buffer[offset + 2] & 0x01) == 0); sdkp->RCD = 0; } sdkp->DPOFUA = (data.device_specific & 0x10) != 0; if (sdkp->DPOFUA && !sdkp->device->use_10_for_rw) { sd_printk(KERN_NOTICE, sdkp, "Uses READ/WRITE(6), disabling FUA\n"); sdkp->DPOFUA = 0; } if (sdkp->first_scan \|\| old_wce != sdkp->WCE \|\| old_rcd != sdkp->RCD \|\| old_dpofua != sdkp->DPOFUA) sd_printk(KERN_NOTICE, sdkp, "Write cache: %s, read cache: %s, %s\n", sdkp->WCE ? "enabled" : "disabled", sdkp->RCD ? "disabled" : "enabled", sdkp->DPOFUA ? "supports DPO and FUA" : "doesn't support DPO or FUA"); return; } bad_sense: if (scsi_sense_valid(&sshdr) && sshdr.sense_key == ILLEGAL_REQUEST && sshdr.asc == 0x24 && sshdr.ascq == 0x0) / Invalid field in CDB / sd_printk(KERN_NOTICE, sdkp, "Cache data unavailable\n"); else sd_printk(KERN_ERR, sdkp, "Asking for cache data failed\n"); defaults: sd_printk(KERN_ERR, sdkp, "Assuming drive cache: write through\n"); sdkp->WCE = 0; sdkp->RCD = 0; sdkp->DPOFUA = 0; } / * The ATO bit indicates whether the DIF application tag is available * for use by the operating system. / static void sd_read_app_tag_own(struct scsi_disk sdkp, unsigned char buffer) { int res, offset; struct scsi_device sdp = sdkp->device; struct scsi_mode_data data; struct scsi_sense_hdr sshdr; if (sdp->type != TYPE_DISK) return; if (sdkp->protection_type == 0) return; res = scsi_mode_sense(sdp, 1, 0x0a, buffer, 36, SD_TIMEOUT, SD_MAX_RETRIES, &data, &sshdr); if (!scsi_status_is_good(res) \|\| !data.header_length \|\| data.length < 6) { sd_printk(KERN_WARNING, sdkp, "getting Control mode page failed, assume no ATO\n"); if (scsi_sense_valid(&sshdr)) sd_print_sense_hdr(sdkp, &sshdr); return; } offset = data.header_length + data.block_descriptor_length; if ((buffer[offset] & 0x3f) != 0x0a) { sd_printk(KERN_ERR, sdkp, "ATO Got wrong page\n"); return; } if ((buffer[offset + 5] & 0x80) == 0) return; sdkp->ATO = 1; return; } /** * sd_read_block_limits - Query disk device for preferred I/O sizes. * @disk: disk to query / static void sd_read_block_limits(struct scsi_disk sdkp) { unsigned int sector_sz = sdkp->device->sector_size; const int vpd_len = 64; unsigned char buffer = kmalloc(vpd_len, GFP_KERNEL); if (!buffer \|\| / Block Limits VPD / scsi_get_vpd_page(sdkp->device, 0xb0, buffer, vpd_len)) goto out; blk_queue_io_min(sdkp->disk->queue, get_unaligned_be16(&buffer[6]) sector_sz); blk_queue_io_opt(sdkp->disk->queue, get_unaligned_be32(&buffer[12]) * sector_sz); if (buffer[3] == 0x3c) { unsigned int lba_count, desc_count; sdkp->max_ws_blocks = (u32) min_not_zero(get_unaligned_be64(&buffer[36]), (u64)0xffffffff); if (!sdkp->lbpme) goto out; lba_count = get_unaligned_be32(&buffer[20]); desc_count = get_unaligned_be32(&buffer[24]); if (lba_count && desc_count) sdkp->max_unmap_blocks = lba_count; sdkp->unmap_granularity = get_unaligned_be32(&buffer[28]); if (buffer[32] & 0x80) sdkp->unmap_alignment = get_unaligned_be32(&buffer[32]) & ~(1 << 31); if (!sdkp->lbpvpd) { /* LBP VPD page not provided / if (sdkp->max_unmap_blocks) sd_config_discard(sdkp, SD_LBP_UNMAP); else sd_config_discard(sdkp, SD_LBP_WS16); } else { / LBP VPD page tells us what to use / if (sdkp->lbpu && sdkp->max_unmap_blocks) sd_config_discard(sdkp, SD_LBP_UNMAP); else if (sdkp->lbpws) sd_config_discard(sdkp, SD_LBP_WS16); else if (sdkp->lbpws10) sd_config_discard(sdkp, SD_LBP_WS10); else sd_config_discard(sdkp, SD_LBP_DISABLE); } } out: kfree(buffer); } /* * sd_read_block_characteristics - Query block dev. characteristics * @disk: disk to query / static void sd_read_block_characteristics(struct scsi_disk sdkp) { unsigned char buffer; u16 rot; const int vpd_len = 64; buffer = kmalloc(vpd_len, GFP_KERNEL); if (!buffer \|\| / Block Device Characteristics VPD / scsi_get_vpd_page(sdkp->device, 0xb1, buffer, vpd_len)) goto out; rot = get_unaligned_be16(&buffer[4]); if (rot == 1) queue_flag_set_unlocked(QUEUE_FLAG_NONROT, sdkp->disk->queue); out: kfree(buffer); } /* * sd_read_block_provisioning - Query provisioning VPD page * @disk: disk to query / static void sd_read_block_provisioning(struct scsi_disk sdkp) { unsigned char buffer; const int vpd_len = 8; if (sdkp->lbpme == 0) return; buffer = kmalloc(vpd_len, GFP_KERNEL); if (!buffer \|\| scsi_get_vpd_page(sdkp->device, 0xb2, buffer, vpd_len)) goto out; sdkp->lbpvpd = 1; sdkp->lbpu = (buffer[5] >> 7) & 1; / UNMAP / sdkp->lbpws = (buffer[5] >> 6) & 1; / WRITE SAME(16) with UNMAP / sdkp->lbpws10 = (buffer[5] >> 5) & 1; / WRITE SAME(10) with UNMAP / out: kfree(buffer); } static int sd_try_extended_inquiry(struct scsi_device sdp) { /* * Although VPD inquiries can go to SCSI-2 type devices, * some USB ones crash on receiving them, and the pages * we currently ask for are for SPC-3 and beyond / if (sdp->scsi_level > SCSI_SPC_2) return 1; return 0; } /* * sd_revalidate_disk - called the first time a new disk is seen, * performs disk spin up, read_capacity, etc. * @disk: struct gendisk we care about */ static int sd_revalidate_disk(struct gendisk disk) { struct scsi_disk sdkp = scsi_disk(disk); struct scsi_device sdp = sdkp->device; unsigned char buffer; unsigned flush = 0; SCSI_LOG_HLQUEUE(3, sd_printk(KERN_INFO, sdkp, "sd_revalidate_disk\n")); / * If the device is offline, don't try and read capacity or any * of the other niceties. / if (!scsi_device_online(sdp)) goto out; buffer = kmalloc(SD_BUF_SIZE, GFP_KERNEL); if (!buffer) { sd_printk(KERN_WARNING, sdkp, "sd_revalidate_disk: Memory " "allocation failure.\n"); goto out; } sd_spinup_disk(sdkp); / * Without media there is no reason to ask; moreover, some devices * react badly if we do. / if (sdkp->media_present) { sd_read_capacity(sdkp, buffer); if (sd_try_extended_inquiry(sdp)) { sd_read_block_provisioning(sdkp); sd_read_block_limits(sdkp); sd_read_block_characteristics(sdkp); } sd_read_write_protect_flag(sdkp, buffer); sd_read_cache_type(sdkp, buffer); sd_read_app_tag_own(sdkp, buffer); } sdkp->first_scan = 0; / * We now have all cache related info, determine how we deal * with flush requests. / if (sdkp->WCE) { flush \|= REQ_FLUSH; if (sdkp->DPOFUA) flush \|= REQ_FUA; } blk_queue_flush(sdkp->disk->queue, flush); set_capacity(disk, sdkp->capacity); kfree(buffer); out: return 0; } /* * sd_unlock_native_capacity - unlock native capacity * @disk: struct gendisk to set capacity for * * Block layer calls this function if it detects that partitions * on @disk reach beyond the end of the device. If the SCSI host * implements ->unlock_native_capacity() method, it's invoked to * give it a chance to adjust the device capacity. * * CONTEXT: * Defined by block layer. Might sleep. / static void sd_unlock_native_capacity(struct gendisk disk) { struct scsi_device sdev = scsi_disk(disk)->device; if (sdev->host->hostt->unlock_native_capacity) sdev->host->hostt->unlock_native_capacity(sdev); } /* * sd_format_disk_name - format disk name * @prefix: name prefix - ie. "sd" for SCSI disks * @index: index of the disk to format name for * @buf: output buffer * @buflen: length of the output buffer * * SCSI disk names starts at sda. The 26th device is sdz and the * 27th is sdaa. The last one for two lettered suffix is sdzz * which is followed by sdaaa. * * This is basically 26 base counting with one extra 'nil' entry * at the beginning from the second digit on and can be * determined using similar method as 26 base conversion with the * index shifted -1 after each digit is computed. * * CONTEXT: * Don't care. * * RETURNS: * 0 on success, -errno on failure. / static int sd_format_disk_name(char prefix, int index, char buf, int buflen) { const int base = 'z' - 'a' + 1; char begin = buf + strlen(prefix); char end = buf + buflen; char p; int unit; p = end - 1; p = '\0'; unit = base; do { if (p == begin) return -EINVAL; --p = 'a' + (index % unit); index = (index / unit) - 1; } while (index >= 0); memmove(begin, p, end - p); memcpy(buf, prefix, strlen(prefix)); return 0; } /* * The asynchronous part of sd_probe / static void sd_probe_async(void data, async_cookie_t cookie) { struct scsi_disk sdkp = data; struct scsi_device sdp; struct gendisk gd; u32 index; struct device dev; sdp = sdkp->device; gd = sdkp->disk; index = sdkp->index; dev = &sdp->sdev_gendev; gd->major = sd_major((index & 0xf0) >> 4); gd->first_minor = ((index & 0xf) << 4) \| (index & 0xfff00); gd->minors = SD_MINORS; gd->fops = &sd_fops; gd->private_data = &sdkp->driver; gd->queue = sdkp->device->request_queue; /* defaults, until the device tells us otherwise / sdp->sector_size = 512; sdkp->capacity = 0; sdkp->media_present = 1; sdkp->write_prot = 0; sdkp->WCE = 0; sdkp->RCD = 0; sdkp->ATO = 0; sdkp->first_scan = 1; sd_revalidate_disk(gd); blk_queue_prep_rq(sdp->request_queue, sd_prep_fn); blk_queue_unprep_rq(sdp->request_queue, sd_unprep_fn); gd->driverfs_dev = &sdp->sdev_gendev; gd->flags = GENHD_FL_EXT_DEVT; if (sdp->removable) { gd->flags \|= GENHD_FL_REMOVABLE; gd->events \|= DISK_EVENT_MEDIA_CHANGE; } add_disk(gd); sd_dif_config_host(sdkp); sd_revalidate_disk(gd); sd_printk(KERN_NOTICE, sdkp, "Attached SCSI %sdisk\n", sdp->removable ? "removable " : ""); scsi_autopm_put_device(sdp); put_device(&sdkp->dev); } /* * sd_probe - called during driver initialization and whenever a * new scsi device is attached to the system. It is called once * for each scsi device (not just disks) present. * @dev: pointer to device object * * Returns 0 if successful (or not interested in this scsi device * (e.g. scanner)); 1 when there is an error. * * Note: this function is invoked from the scsi mid-level. * This function sets up the mapping between a given * <host,channel,id,lun> (found in sdp) and new device name * (e.g. /dev/sda). More precisely it is the block device major * and minor number that is chosen here. * * Assume sd_attach is not re-entrant (for time being) * Also think about sd_attach() and sd_remove() running coincidentally. */ static int sd_probe(struct device dev) { struct scsi_device sdp = to_scsi_device(dev); struct scsi_disk sdkp; struct gendisk gd; int index; int error; error = -ENODEV; if (sdp->type != TYPE_DISK && sdp->type != TYPE_MOD && sdp->type != TYPE_RBC) goto out; SCSI_LOG_HLQUEUE(3, sdev_printk(KERN_INFO, sdp, "sd_attach\n")); error = -ENOMEM; sdkp = kzalloc(sizeof(sdkp), GFP_KERNEL); if (!sdkp) goto out; gd = alloc_disk(SD_MINORS); if (!gd) goto out_free; do { if (!ida_pre_get(&sd_index_ida, GFP_KERNEL)) goto out_put; spin_lock(&sd_index_lock); error = ida_get_new(&sd_index_ida, &index); spin_unlock(&sd_index_lock); } while (error == -EAGAIN); if (error) { sdev_printk(KERN_WARNING, sdp, "sd_probe: memory exhausted.\n"); goto out_put; } error = sd_format_disk_name("sd", index, gd->disk_name, DISK_NAME_LEN); if (error) { sdev_printk(KERN_WARNING, sdp, "SCSI disk (sd) name length exceeded.\n"); goto out_free_index; } sdkp->device = sdp; sdkp->driver = &sd_template; sdkp->disk = gd; sdkp->index = index; atomic_set(&sdkp->openers, 0); if (!sdp->request_queue->rq_timeout) { if (sdp->type != TYPE_MOD) blk_queue_rq_timeout(sdp->request_queue, SD_TIMEOUT); else blk_queue_rq_timeout(sdp->request_queue, SD_MOD_TIMEOUT); } device_initialize(&sdkp->dev); sdkp->dev.parent = dev; sdkp->dev.class = &sd_disk_class; dev_set_name(&sdkp->dev, dev_name(dev)); if (device_add(&sdkp->dev)) goto out_free_index; get_device(dev); dev_set_drvdata(dev, sdkp); get_device(&sdkp->dev); /* prevent release before async_schedule / async_schedule(sd_probe_async, sdkp); return 0; out_free_index: spin_lock(&sd_index_lock); ida_remove(&sd_index_ida, index); spin_unlock(&sd_index_lock); out_put: put_disk(gd); out_free: kfree(sdkp); out: return error; } /* * sd_remove - called whenever a scsi disk (previously recognized by * sd_probe) is detached from the system. It is called (potentially * multiple times) during sd module unload. * @sdp: pointer to mid level scsi device object * * Note: this function is invoked from the scsi mid-level. * This function potentially frees up a device name (e.g. /dev/sdc) * that could be re-used by a subsequent sd_probe(). * This function is not called when the built-in sd driver is "exit-ed". */ static int sd_remove(struct device dev) { struct scsi_disk sdkp; sdkp = dev_get_drvdata(dev); scsi_autopm_get_device(sdkp->device); async_synchronize_full(); blk_queue_prep_rq(sdkp->device->request_queue, scsi_prep_fn); blk_queue_unprep_rq(sdkp->device->request_queue, NULL); device_del(&sdkp->dev); del_gendisk(sdkp->disk); sd_shutdown(dev); mutex_lock(&sd_ref_mutex); dev_set_drvdata(dev, NULL); put_device(&sdkp->dev); mutex_unlock(&sd_ref_mutex); return 0; } /* * scsi_disk_release - Called to free the scsi_disk structure * @dev: pointer to embedded class device * * sd_ref_mutex must be held entering this routine. Because it is * called on last put, you should always use the scsi_disk_get() * scsi_disk_put() helpers which manipulate the semaphore directly * and never do a direct put_device. */ static void scsi_disk_release(struct device dev) { struct scsi_disk sdkp = to_scsi_disk(dev); struct gendisk disk = sdkp->disk; spin_lock(&sd_index_lock); ida_remove(&sd_index_ida, sdkp->index); spin_unlock(&sd_index_lock); disk->private_data = NULL; put_disk(disk); put_device(&sdkp->device->sdev_gendev); kfree(sdkp); } static int sd_start_stop_device(struct scsi_disk sdkp, int start) { unsigned char cmd[6] = { START_STOP }; / START_VALID / struct scsi_sense_hdr sshdr; struct scsi_device sdp = sdkp->device; int res; if (start) cmd[4] \|= 1; /* START / if (sdp->start_stop_pwr_cond) cmd[4] \|= start ? 1 << 4 : 3 << 4; / Active or Standby / if (!scsi_device_online(sdp)) return -ENODEV; res = scsi_execute_req(sdp, cmd, DMA_NONE, NULL, 0, &sshdr, SD_TIMEOUT, SD_MAX_RETRIES, NULL); if (res) { sd_printk(KERN_WARNING, sdkp, "START_STOP FAILED\n"); sd_print_result(sdkp, res); if (driver_byte(res) & DRIVER_SENSE) sd_print_sense_hdr(sdkp, &sshdr); } return res; } / * Send a SYNCHRONIZE CACHE instruction down to the device through * the normal SCSI command structure. Wait for the command to * complete. / static void sd_shutdown(struct device dev) { struct scsi_disk sdkp = scsi_disk_get_from_dev(dev); if (!sdkp) return; / this can happen / if (pm_runtime_suspended(dev)) goto exit; if (sdkp->WCE) { sd_printk(KERN_NOTICE, sdkp, "Synchronizing SCSI cache\n"); sd_sync_cache(sdkp); } if (system_state != SYSTEM_RESTART && sdkp->device->manage_start_stop) { sd_printk(KERN_NOTICE, sdkp, "Stopping disk\n"); sd_start_stop_device(sdkp, 0); } exit: scsi_disk_put(sdkp); } static int sd_suspend(struct device dev, pm_message_t mesg) { struct scsi_disk sdkp = scsi_disk_get_from_dev(dev); int ret = 0; if (!sdkp) return 0; / this can happen / if (sdkp->WCE) { sd_printk(KERN_NOTICE, sdkp, "Synchronizing SCSI cache\n"); ret = sd_sync_cache(sdkp); if (ret) goto done; } if ((mesg.event & PM_EVENT_SLEEP) && sdkp->device->manage_start_stop) { sd_printk(KERN_NOTICE, sdkp, "Stopping disk\n"); ret = sd_start_stop_device(sdkp, 0); } done: scsi_disk_put(sdkp); return ret; } static int sd_resume(struct device dev) { struct scsi_disk sdkp = scsi_disk_get_from_dev(dev); int ret = 0; if (!sdkp->device->manage_start_stop) goto done; sd_printk(KERN_NOTICE, sdkp, "Starting disk\n"); ret = sd_start_stop_device(sdkp, 1); done: scsi_disk_put(sdkp); return ret; } /* * init_sd - entry point for this driver (both when built in or when * a module). * * Note: this function registers this driver with the scsi mid-level. / static int __init init_sd(void) { int majors = 0, i, err; SCSI_LOG_HLQUEUE(3, printk("init_sd: sd driver entry point\n")); for (i = 0; i < SD_MAJORS; i++) if (register_blkdev(sd_major(i), "sd") == 0) majors++; if (!majors) return -ENODEV; err = class_register(&sd_disk_class); if (err) goto err_out; err = scsi_register_driver(&sd_template.gendrv); if (err) goto err_out_class; sd_cdb_cache = kmem_cache_create("sd_ext_cdb", SD_EXT_CDB_SIZE, 0, 0, NULL); if (!sd_cdb_cache) { printk(KERN_ERR "sd: can't init extended cdb cache\n"); goto err_out_class; } sd_cdb_pool = mempool_create_slab_pool(SD_MEMPOOL_SIZE, sd_cdb_cache); if (!sd_cdb_pool) { printk(KERN_ERR "sd: can't init extended cdb pool\n"); goto err_out_cache; } return 0; err_out_cache: kmem_cache_destroy(sd_cdb_cache); err_out_class: class_unregister(&sd_disk_class); err_out: for (i = 0; i < SD_MAJORS; i++) unregister_blkdev(sd_major(i), "sd"); return err; } / * exit_sd - exit point for this driver (when it is a module). * * Note: this function unregisters this driver from the scsi mid-level. */ static void __exit exit_sd(void) { int i; SCSI_LOG_HLQUEUE(3, printk("exit_sd: exiting sd driver\n")); mempool_destroy(sd_cdb_pool); kmem_cache_destroy(sd_cdb_cache); scsi_unregister_driver(&sd_template.gendrv); class_unregister(&sd_disk_class); for (i = 0; i < SD_MAJORS; i++) unregister_blkdev(sd_major(i), "sd"); } module_init(init_sd); module_exit(exit_sd); static void sd_print_sense_hdr(struct scsi_disk sdkp, struct scsi_sense_hdr sshdr) { sd_printk(KERN_INFO, sdkp, " "); scsi_show_sense_hdr(sshdr); sd_printk(KERN_INFO, sdkp, " "); scsi_show_extd_sense(sshdr->asc, sshdr->ascq); } static void sd_print_result(struct scsi_disk sdkp, int result) { sd_printk(KERN_INFO, sdkp, " "); scsi_show_result(result); }	./CrossVul/dataset_final_sorted/CWE-264/c/bad_3525_1
crossvul-cpp_data_good_1455_0	/* Copyright Joyent, Inc. and other Node contributors. All rights reserved. * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to * deal in the Software without restriction, including without limitation the * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or * sell copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS * IN THE SOFTWARE. / #include "uv.h" #include "internal.h" #include <stdio.h> #include <stdlib.h> #include <assert.h> #include <errno.h> #include <sys/types.h> #include <sys/wait.h> #include <unistd.h> #include <fcntl.h> #include <poll.h> #if defined(__APPLE__) && !TARGET_OS_IPHONE # include <crt_externs.h> # define environ (_NSGetEnviron()) #else extern char *environ; #endif static QUEUE uv__process_queue(uv_loop_t* loop, int pid) { assert(pid > 0); return loop->process_handles + pid % ARRAY_SIZE(loop->process_handles); } static void uv__chld(uv_signal_t* handle, int signum) { uv_process_t* process; uv_loop_t* loop; int exit_status; int term_signal; unsigned int i; int status; pid_t pid; QUEUE pending; QUEUE* h; QUEUE* q; assert(signum == SIGCHLD); QUEUE_INIT(&pending); loop = handle->loop; for (i = 0; i < ARRAY_SIZE(loop->process_handles); i++) { h = loop->process_handles + i; q = QUEUE_HEAD(h); while (q != h) { process = QUEUE_DATA(q, uv_process_t, queue); q = QUEUE_NEXT(q); do pid = waitpid(process->pid, &status, WNOHANG); while (pid == -1 && errno == EINTR); if (pid == 0) continue; if (pid == -1) { if (errno != ECHILD) abort(); continue; } process->status = status; QUEUE_REMOVE(&process->queue); QUEUE_INSERT_TAIL(&pending, &process->queue); } while (!QUEUE_EMPTY(&pending)) { q = QUEUE_HEAD(&pending); QUEUE_REMOVE(q); QUEUE_INIT(q); process = QUEUE_DATA(q, uv_process_t, queue); uv__handle_stop(process); if (process->exit_cb == NULL) continue; exit_status = 0; if (WIFEXITED(process->status)) exit_status = WEXITSTATUS(process->status); term_signal = 0; if (WIFSIGNALED(process->status)) term_signal = WTERMSIG(process->status); process->exit_cb(process, exit_status, term_signal); } } } int uv__make_socketpair(int fds[2], int flags) { #if defined(__linux__) static int no_cloexec; if (no_cloexec) goto skip; if (socketpair(AF_UNIX, SOCK_STREAM \| UV__SOCK_CLOEXEC \| flags, 0, fds) == 0) return 0; /* Retry on EINVAL, it means SOCK_CLOEXEC is not supported. * Anything else is a genuine error. / if (errno != EINVAL) return -errno; no_cloexec = 1; skip: #endif if (socketpair(AF_UNIX, SOCK_STREAM, 0, fds)) return -errno; uv__cloexec(fds[0], 1); uv__cloexec(fds[1], 1); if (flags & UV__F_NONBLOCK) { uv__nonblock(fds[0], 1); uv__nonblock(fds[1], 1); } return 0; } int uv__make_pipe(int fds[2], int flags) { #if defined(__linux__) static int no_pipe2; if (no_pipe2) goto skip; if (uv__pipe2(fds, flags \| UV__O_CLOEXEC) == 0) return 0; if (errno != ENOSYS) return -errno; no_pipe2 = 1; skip: #endif if (pipe(fds)) return -errno; uv__cloexec(fds[0], 1); uv__cloexec(fds[1], 1); if (flags & UV__F_NONBLOCK) { uv__nonblock(fds[0], 1); uv__nonblock(fds[1], 1); } return 0; } / * Used for initializing stdio streams like options.stdin_stream. Returns * zero on success. See also the cleanup section in uv_spawn(). / static int uv__process_init_stdio(uv_stdio_container_t container, int fds[2]) { int mask; int fd; mask = UV_IGNORE \| UV_CREATE_PIPE \| UV_INHERIT_FD \| UV_INHERIT_STREAM; switch (container->flags & mask) { case UV_IGNORE: return 0; case UV_CREATE_PIPE: assert(container->data.stream != NULL); if (container->data.stream->type != UV_NAMED_PIPE) return -EINVAL; else return uv__make_socketpair(fds, 0); case UV_INHERIT_FD: case UV_INHERIT_STREAM: if (container->flags & UV_INHERIT_FD) fd = container->data.fd; else fd = uv__stream_fd(container->data.stream); if (fd == -1) return -EINVAL; fds[1] = fd; return 0; default: assert(0 && "Unexpected flags"); return -EINVAL; } } static int uv__process_open_stream(uv_stdio_container_t* container, int pipefds[2], int writable) { int flags; if (!(container->flags & UV_CREATE_PIPE) \|\| pipefds[0] < 0) return 0; if (uv__close(pipefds[1])) if (errno != EINTR && errno != EINPROGRESS) abort(); pipefds[1] = -1; uv__nonblock(pipefds[0], 1); if (container->data.stream->type == UV_NAMED_PIPE && ((uv_pipe_t)container->data.stream)->ipc) flags = UV_STREAM_READABLE \| UV_STREAM_WRITABLE; else if (writable) flags = UV_STREAM_WRITABLE; else flags = UV_STREAM_READABLE; return uv__stream_open(container->data.stream, pipefds[0], flags); } static void uv__process_close_stream(uv_stdio_container_t container) { if (!(container->flags & UV_CREATE_PIPE)) return; uv__stream_close((uv_stream_t)container->data.stream); } static void uv__write_int(int fd, int val) { ssize_t n; do n = write(fd, &val, sizeof(val)); while (n == -1 && errno == EINTR); if (n == -1 && errno == EPIPE) return; / parent process has quit / assert(n == sizeof(val)); } static void uv__process_child_init(const uv_process_options_t options, int stdio_count, int (pipes)[2], int error_fd) { int close_fd; int use_fd; int fd; if (options->flags & UV_PROCESS_DETACHED) setsid(); for (fd = 0; fd < stdio_count; fd++) { close_fd = pipes[fd][0]; use_fd = pipes[fd][1]; if (use_fd < 0) { if (fd >= 3) continue; else { / redirect stdin, stdout and stderr to /dev/null even if UV_IGNORE is * set / use_fd = open("/dev/null", fd == 0 ? O_RDONLY : O_RDWR); close_fd = use_fd; if (use_fd == -1) { uv__write_int(error_fd, -errno); perror("failed to open stdio"); _exit(127); } } } if (fd == use_fd) uv__cloexec(use_fd, 0); else dup2(use_fd, fd); if (fd <= 2) uv__nonblock(fd, 0); if (close_fd != -1) uv__close(close_fd); } for (fd = 0; fd < stdio_count; fd++) { use_fd = pipes[fd][1]; if (use_fd >= 0 && fd != use_fd) close(use_fd); } if (options->cwd != NULL && chdir(options->cwd)) { uv__write_int(error_fd, -errno); perror("chdir()"); _exit(127); } if (options->flags & (UV_PROCESS_SETUID \| UV_PROCESS_SETGID)) { / When dropping privileges from root, the `setgroups` call will * remove any extraneous groups. If we don't call this, then * even though our uid has dropped, we may still have groups * that enable us to do super-user things. This will fail if we * aren't root, so don't bother checking the return value, this * is just done as an optimistic privilege dropping function. / SAVE_ERRNO(setgroups(0, NULL)); } if ((options->flags & UV_PROCESS_SETGID) && setgid(options->gid)) { uv__write_int(error_fd, -errno); perror("setgid()"); _exit(127); } if ((options->flags & UV_PROCESS_SETUID) && setuid(options->uid)) { uv__write_int(error_fd, -errno); perror("setuid()"); _exit(127); } if (options->env != NULL) { environ = options->env; } execvp(options->file, options->args); uv__write_int(error_fd, -errno); perror("execvp()"); _exit(127); } int uv_spawn(uv_loop_t loop, uv_process_t* process, const uv_process_options_t* options) { int signal_pipe[2] = { -1, -1 }; int (pipes)[2]; int stdio_count; QUEUE q; ssize_t r; pid_t pid; int err; int exec_errorno; int i; assert(options->file != NULL); assert(!(options->flags & ~(UV_PROCESS_DETACHED \| UV_PROCESS_SETGID \| UV_PROCESS_SETUID \| UV_PROCESS_WINDOWS_HIDE \| UV_PROCESS_WINDOWS_VERBATIM_ARGUMENTS))); uv__handle_init(loop, (uv_handle_t)process, UV_PROCESS); QUEUE_INIT(&process->queue); stdio_count = options->stdio_count; if (stdio_count < 3) stdio_count = 3; err = -ENOMEM; pipes = malloc(stdio_count sizeof(pipes)); if (pipes == NULL) goto error; for (i = 0; i < stdio_count; i++) { pipes[i][0] = -1; pipes[i][1] = -1; } for (i = 0; i < options->stdio_count; i++) { err = uv__process_init_stdio(options->stdio + i, pipes[i]); if (err) goto error; } / This pipe is used by the parent to wait until * the child has called `execve()`. We need this * to avoid the following race condition: * * if ((pid = fork()) > 0) { * kill(pid, SIGTERM); * } * else if (pid == 0) { * execve("/bin/cat", argp, envp); * } * * The parent sends a signal immediately after forking. * Since the child may not have called `execve()` yet, * there is no telling what process receives the signal, * our fork or /bin/cat. * * To avoid ambiguity, we create a pipe with both ends * marked close-on-exec. Then, after the call to `fork()`, * the parent polls the read end until it EOFs or errors with EPIPE. / err = uv__make_pipe(signal_pipe, 0); if (err) goto error; uv_signal_start(&loop->child_watcher, uv__chld, SIGCHLD); / Acquire write lock to prevent opening new fds in worker threads / uv_rwlock_wrlock(&loop->cloexec_lock); pid = fork(); if (pid == -1) { err = -errno; uv_rwlock_wrunlock(&loop->cloexec_lock); uv__close(signal_pipe[0]); uv__close(signal_pipe[1]); goto error; } if (pid == 0) { uv__process_child_init(options, stdio_count, pipes, signal_pipe[1]); abort(); } / Release lock in parent process / uv_rwlock_wrunlock(&loop->cloexec_lock); uv__close(signal_pipe[1]); process->status = 0; exec_errorno = 0; do r = read(signal_pipe[0], &exec_errorno, sizeof(exec_errorno)); while (r == -1 && errno == EINTR); if (r == 0) ; / okay, EOF / else if (r == sizeof(exec_errorno)) ; / okay, read errorno / else if (r == -1 && errno == EPIPE) ; / okay, got EPIPE / else abort(); uv__close(signal_pipe[0]); for (i = 0; i < options->stdio_count; i++) { err = uv__process_open_stream(options->stdio + i, pipes[i], i == 0); if (err == 0) continue; while (i--) uv__process_close_stream(options->stdio + i); goto error; } / Only activate this handle if exec() happened successfully / if (exec_errorno == 0) { q = uv__process_queue(loop, pid); QUEUE_INSERT_TAIL(q, &process->queue); uv__handle_start(process); } process->pid = pid; process->exit_cb = options->exit_cb; free(pipes); return exec_errorno; error: if (pipes != NULL) { for (i = 0; i < stdio_count; i++) { if (i < options->stdio_count) if (options->stdio[i].flags & (UV_INHERIT_FD \| UV_INHERIT_STREAM)) continue; if (pipes[i][0] != -1) close(pipes[i][0]); if (pipes[i][1] != -1) close(pipes[i][1]); } free(pipes); } return err; } int uv_process_kill(uv_process_t process, int signum) { return uv_kill(process->pid, signum); } int uv_kill(int pid, int signum) { if (kill(pid, signum)) return -errno; else return 0; } void uv__process_close(uv_process_t* handle) { /* TODO stop signal watcher when this is the last handle */ QUEUE_REMOVE(&handle->queue); uv__handle_stop(handle); }	./CrossVul/dataset_final_sorted/CWE-264/c/good_1455_0
crossvul-cpp_data_good_1661_3	/* * chsh.c -- change your login shell * (c) 1994 by salvatore valente <svalente@athena.mit.edu> * (c) 2012 by Cody Maloney <cmaloney@theoreticalchaos.com> * * this program is free software. you can redistribute it and * modify it under the terms of the gnu general public license. * there is no warranty. * * $Author: aebr $ * $Revision: 1.19 $ * $Date: 1998/06/11 22:30:14 $ * * Updated Thu Oct 12 09:33:15 1995 by faith@cs.unc.edu with security * patches from Zefram <A.Main@dcs.warwick.ac.uk> * * Updated Mon Jul 1 18:46:22 1996 by janl@math.uio.no with security * suggestion from Zefram. Disallowing users with shells not in /etc/shells * from changing their shell. * * 1999-02-22 Arkadiusz Miśkiewicz <misiek@pld.ORG.PL> * - added Native Language Support / #include <ctype.h> #include <errno.h> #include <getopt.h> #include <pwd.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <sys/types.h> #include <unistd.h> #include "c.h" #include "env.h" #include "closestream.h" #include "islocal.h" #include "nls.h" #include "pathnames.h" #include "setpwnam.h" #include "strutils.h" #include "xalloc.h" #include "ch-common.h" #ifdef HAVE_LIBSELINUX # include <selinux/selinux.h> # include <selinux/av_permissions.h> # include "selinux_utils.h" #endif #ifdef HAVE_LIBUSER # include <libuser/user.h> # include "libuser.h" #elif CHFN_CHSH_PASSWORD # include "auth.h" #endif struct sinfo { char username; char shell; }; static void __attribute__((__noreturn__)) usage (FILE fp) { fputs(USAGE_HEADER, fp); fprintf(fp, _(" %s [options] [<username>]\n"), program_invocation_short_name); fputs(USAGE_SEPARATOR, fp); fputs(_("Change your login shell.\n"), fp); fputs(USAGE_OPTIONS, fp); fputs(_(" -s, --shell <shell> specify login shell\n"), fp); fputs(_(" -l, --list-shells print list of shells and exit\n"), fp); fputs(USAGE_SEPARATOR, fp); fputs(_(" -u, --help display this help and exit\n"), fp); fputs(_(" -v, --version output version information and exit\n"), fp); fprintf(fp, USAGE_MAN_TAIL("chsh(1)")); exit(fp == stderr ? EXIT_FAILURE : EXIT_SUCCESS); } /* * get_shell_list () -- if the given shell appears in /etc/shells, * return true. if not, return false. * if the given shell is NULL, /etc/shells is outputted to stdout. / static int get_shell_list(const char shell_name) { FILE fp; int found = 0; char buf = NULL; size_t sz = 0; ssize_t len; fp = fopen(_PATH_SHELLS, "r"); if (!fp) { if (!shell_name) warnx(_("No known shells.")); return 0; } while ((len = getline(&buf, &sz, fp)) != -1) { /* ignore comments and blank lines / if (buf == '#' \|\| len < 2) continue; /* strip the ending newline / if (buf[len - 1] == '\n') buf[len - 1] = 0; / check or output the shell / if (shell_name) { if (!strcmp(shell_name, buf)) { found = 1; break; } } else printf("%s\n", buf); } fclose(fp); free(buf); return found; } / * parse_argv () -- * parse the command line arguments, and fill in "pinfo" with any * information from the command line. / static void parse_argv(int argc, char argv, struct sinfo pinfo) { static const struct option long_options[] = { {"shell", required_argument, 0, 's'}, {"list-shells", no_argument, 0, 'l'}, {"help", no_argument, 0, 'u'}, {"version", no_argument, 0, 'v'}, {NULL, no_argument, 0, '0'}, }; int c; while ((c = getopt_long(argc, argv, "s:luv", long_options, NULL)) != -1) { switch (c) { case 'v': printf(UTIL_LINUX_VERSION); exit(EXIT_SUCCESS); case 'u': usage(stdout); case 'l': get_shell_list(NULL); exit(EXIT_SUCCESS); case 's': if (!optarg) usage(stderr); pinfo->shell = optarg; break; default: usage(stderr); } } /* done parsing arguments. check for a username. / if (optind < argc) { if (optind + 1 < argc) usage(stderr); pinfo->username = argv[optind]; } } / * ask_new_shell () -- * ask the user for a shell and return it. / static char ask_new_shell(char question, char oldshell) { int len; char ans = NULL; size_t dummy = 0; ssize_t sz; if (!oldshell) oldshell = ""; printf("%s [%s]: ", question, oldshell); sz = getline(&ans, &dummy, stdin); if (sz == -1) return NULL; / remove the newline at the end of ans. / ltrim_whitespace((unsigned char ) ans); len = rtrim_whitespace((unsigned char ) ans); if (len == 0) return NULL; return ans; } / * check_shell () -- if the shell is completely invalid, print * an error and exit. / static void check_shell(const char shell) { if (shell != '/') errx(EXIT_FAILURE, _("shell must be a full path name")); if (access(shell, F_OK) < 0) errx(EXIT_FAILURE, _("\"%s\" does not exist"), shell); if (access(shell, X_OK) < 0) errx(EXIT_FAILURE, _("\"%s\" is not executable"), shell); if (illegal_passwd_chars(shell)) errx(EXIT_FAILURE, _("%s: has illegal characters"), shell); if (!get_shell_list(shell)) { #ifdef ONLY_LISTED_SHELLS if (!getuid()) warnx(_("Warning: \"%s\" is not listed in %s."), shell, _PATH_SHELLS); else errx(EXIT_FAILURE, _("\"%s\" is not listed in %s.\n" "Use %s -l to see list."), shell, _PATH_SHELLS, program_invocation_short_name); #else warnx(_("\"%s\" is not listed in %s.\n" "Use %s -l to see list."), shell, _PATH_SHELLS, program_invocation_short_name); #endif } } int main(int argc, char argv) { char oldshell; int nullshell = 0; const uid_t uid = getuid(); struct sinfo info = { 0 }; struct passwd pw; sanitize_env(); setlocale(LC_ALL, ""); bindtextdomain(PACKAGE, LOCALEDIR); textdomain(PACKAGE); atexit(close_stdout); parse_argv(argc, argv, &info); if (!info.username) { pw = getpwuid(uid); if (!pw) errx(EXIT_FAILURE, _("you (user %d) don't exist."), uid); } else { pw = getpwnam(info.username); if (!pw) errx(EXIT_FAILURE, _("user \"%s\" does not exist."), info.username); } #ifndef HAVE_LIBUSER if (!(is_local(pw->pw_name))) errx(EXIT_FAILURE, _("can only change local entries")); #endif #ifdef HAVE_LIBSELINUX if (is_selinux_enabled() > 0) { if (uid == 0) { if (checkAccess(pw->pw_name, PASSWD__CHSH) != 0) { security_context_t user_context; if (getprevcon(&user_context) < 0) user_context = (security_context_t) NULL; errx(EXIT_FAILURE, _("%s is not authorized to change the shell of %s"), user_context ? : _("Unknown user context"), pw->pw_name); } } if (setupDefaultContext(_PATH_PASSWD) != 0) errx(EXIT_FAILURE, _("can't set default context for %s"), _PATH_PASSWD); } #endif oldshell = pw->pw_shell; if (oldshell == NULL \|\| oldshell == '\0') { oldshell = _PATH_BSHELL; /* default / nullshell = 1; } / reality check / #ifdef HAVE_LIBUSER / If we're setuid and not really root, disallow the password change. / if (geteuid() != getuid() && uid != pw->pw_uid) { #else if (uid != 0 && uid != pw->pw_uid) { #endif errno = EACCES; err(EXIT_FAILURE, _("running UID doesn't match UID of user we're " "altering, shell change denied")); } if (uid != 0 && !get_shell_list(oldshell)) { errno = EACCES; err(EXIT_FAILURE, _("your shell is not in %s, " "shell change denied"), _PATH_SHELLS); } printf(_("Changing shell for %s.\n"), pw->pw_name); #if !defined(HAVE_LIBUSER) && defined(CHFN_CHSH_PASSWORD) if (!auth_pam("chsh", uid, pw->pw_name)) { return EXIT_FAILURE; } #endif if (!info.shell) { info.shell = ask_new_shell(_("New shell"), oldshell); if (!info.shell) return EXIT_SUCCESS; } check_shell(info.shell); if (!nullshell && strcmp(oldshell, info.shell) == 0) errx(EXIT_SUCCESS, _("Shell not changed.")); #ifdef HAVE_LIBUSER if (set_value_libuser("chsh", pw->pw_name, uid, LU_LOGINSHELL, info.shell) < 0) errx(EXIT_FAILURE, _("Shell NOT* changed. Try again later.")); #else pw->pw_shell = info.shell; if (setpwnam(pw, ".chsh") < 0) err(EXIT_FAILURE, _("setpwnam failed\n" "Shell NOT changed. Try again later.")); #endif printf(_("Shell changed.\n")); return EXIT_SUCCESS; }	./CrossVul/dataset_final_sorted/CWE-264/c/good_1661_3
crossvul-cpp_data_bad_2399_19	/* * seqiv: Sequence Number IV Generator * * This generator generates an IV based on a sequence number by xoring it * with a salt. This algorithm is mainly useful for CTR and similar modes. * * Copyright (c) 2007 Herbert Xu <herbert@gondor.apana.org.au> * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the Free * Software Foundation; either version 2 of the License, or (at your option) * any later version. * / #include <crypto/internal/aead.h> #include <crypto/internal/skcipher.h> #include <crypto/rng.h> #include <linux/err.h> #include <linux/init.h> #include <linux/kernel.h> #include <linux/module.h> #include <linux/slab.h> #include <linux/spinlock.h> #include <linux/string.h> struct seqiv_ctx { spinlock_t lock; u8 salt[] __attribute__ ((aligned(__alignof__(u32)))); }; static void seqiv_complete2(struct skcipher_givcrypt_request req, int err) { struct ablkcipher_request subreq = skcipher_givcrypt_reqctx(req); struct crypto_ablkcipher geniv; if (err == -EINPROGRESS) return; if (err) goto out; geniv = skcipher_givcrypt_reqtfm(req); memcpy(req->creq.info, subreq->info, crypto_ablkcipher_ivsize(geniv)); out: kfree(subreq->info); } static void seqiv_complete(struct crypto_async_request base, int err) { struct skcipher_givcrypt_request req = base->data; seqiv_complete2(req, err); skcipher_givcrypt_complete(req, err); } static void seqiv_aead_complete2(struct aead_givcrypt_request req, int err) { struct aead_request subreq = aead_givcrypt_reqctx(req); struct crypto_aead geniv; if (err == -EINPROGRESS) return; if (err) goto out; geniv = aead_givcrypt_reqtfm(req); memcpy(req->areq.iv, subreq->iv, crypto_aead_ivsize(geniv)); out: kfree(subreq->iv); } static void seqiv_aead_complete(struct crypto_async_request base, int err) { struct aead_givcrypt_request req = base->data; seqiv_aead_complete2(req, err); aead_givcrypt_complete(req, err); } static void seqiv_geniv(struct seqiv_ctx ctx, u8 info, u64 seq, unsigned int ivsize) { unsigned int len = ivsize; if (ivsize > sizeof(u64)) { memset(info, 0, ivsize - sizeof(u64)); len = sizeof(u64); } seq = cpu_to_be64(seq); memcpy(info + ivsize - len, &seq, len); crypto_xor(info, ctx->salt, ivsize); } static int seqiv_givencrypt(struct skcipher_givcrypt_request req) { struct crypto_ablkcipher geniv = skcipher_givcrypt_reqtfm(req); struct seqiv_ctx ctx = crypto_ablkcipher_ctx(geniv); struct ablkcipher_request subreq = skcipher_givcrypt_reqctx(req); crypto_completion_t compl; void data; u8 info; unsigned int ivsize; int err; ablkcipher_request_set_tfm(subreq, skcipher_geniv_cipher(geniv)); compl = req->creq.base.complete; data = req->creq.base.data; info = req->creq.info; ivsize = crypto_ablkcipher_ivsize(geniv); if (unlikely(!IS_ALIGNED((unsigned long)info, crypto_ablkcipher_alignmask(geniv) + 1))) { info = kmalloc(ivsize, req->creq.base.flags & CRYPTO_TFM_REQ_MAY_SLEEP ? GFP_KERNEL: GFP_ATOMIC); if (!info) return -ENOMEM; compl = seqiv_complete; data = req; } ablkcipher_request_set_callback(subreq, req->creq.base.flags, compl, data); ablkcipher_request_set_crypt(subreq, req->creq.src, req->creq.dst, req->creq.nbytes, info); seqiv_geniv(ctx, info, req->seq, ivsize); memcpy(req->giv, info, ivsize); err = crypto_ablkcipher_encrypt(subreq); if (unlikely(info != req->creq.info)) seqiv_complete2(req, err); return err; } static int seqiv_aead_givencrypt(struct aead_givcrypt_request req) { struct crypto_aead geniv = aead_givcrypt_reqtfm(req); struct seqiv_ctx ctx = crypto_aead_ctx(geniv); struct aead_request areq = &req->areq; struct aead_request subreq = aead_givcrypt_reqctx(req); crypto_completion_t compl; void data; u8 info; unsigned int ivsize; int err; aead_request_set_tfm(subreq, aead_geniv_base(geniv)); compl = areq->base.complete; data = areq->base.data; info = areq->iv; ivsize = crypto_aead_ivsize(geniv); if (unlikely(!IS_ALIGNED((unsigned long)info, crypto_aead_alignmask(geniv) + 1))) { info = kmalloc(ivsize, areq->base.flags & CRYPTO_TFM_REQ_MAY_SLEEP ? GFP_KERNEL: GFP_ATOMIC); if (!info) return -ENOMEM; compl = seqiv_aead_complete; data = req; } aead_request_set_callback(subreq, areq->base.flags, compl, data); aead_request_set_crypt(subreq, areq->src, areq->dst, areq->cryptlen, info); aead_request_set_assoc(subreq, areq->assoc, areq->assoclen); seqiv_geniv(ctx, info, req->seq, ivsize); memcpy(req->giv, info, ivsize); err = crypto_aead_encrypt(subreq); if (unlikely(info != areq->iv)) seqiv_aead_complete2(req, err); return err; } static int seqiv_givencrypt_first(struct skcipher_givcrypt_request req) { struct crypto_ablkcipher geniv = skcipher_givcrypt_reqtfm(req); struct seqiv_ctx ctx = crypto_ablkcipher_ctx(geniv); int err = 0; spin_lock_bh(&ctx->lock); if (crypto_ablkcipher_crt(geniv)->givencrypt != seqiv_givencrypt_first) goto unlock; crypto_ablkcipher_crt(geniv)->givencrypt = seqiv_givencrypt; err = crypto_rng_get_bytes(crypto_default_rng, ctx->salt, crypto_ablkcipher_ivsize(geniv)); unlock: spin_unlock_bh(&ctx->lock); if (err) return err; return seqiv_givencrypt(req); } static int seqiv_aead_givencrypt_first(struct aead_givcrypt_request req) { struct crypto_aead geniv = aead_givcrypt_reqtfm(req); struct seqiv_ctx ctx = crypto_aead_ctx(geniv); int err = 0; spin_lock_bh(&ctx->lock); if (crypto_aead_crt(geniv)->givencrypt != seqiv_aead_givencrypt_first) goto unlock; crypto_aead_crt(geniv)->givencrypt = seqiv_aead_givencrypt; err = crypto_rng_get_bytes(crypto_default_rng, ctx->salt, crypto_aead_ivsize(geniv)); unlock: spin_unlock_bh(&ctx->lock); if (err) return err; return seqiv_aead_givencrypt(req); } static int seqiv_init(struct crypto_tfm tfm) { struct crypto_ablkcipher geniv = __crypto_ablkcipher_cast(tfm); struct seqiv_ctx ctx = crypto_ablkcipher_ctx(geniv); spin_lock_init(&ctx->lock); tfm->crt_ablkcipher.reqsize = sizeof(struct ablkcipher_request); return skcipher_geniv_init(tfm); } static int seqiv_aead_init(struct crypto_tfm tfm) { struct crypto_aead geniv = __crypto_aead_cast(tfm); struct seqiv_ctx ctx = crypto_aead_ctx(geniv); spin_lock_init(&ctx->lock); tfm->crt_aead.reqsize = sizeof(struct aead_request); return aead_geniv_init(tfm); } static struct crypto_template seqiv_tmpl; static struct crypto_instance seqiv_ablkcipher_alloc(struct rtattr tb) { struct crypto_instance inst; inst = skcipher_geniv_alloc(&seqiv_tmpl, tb, 0, 0); if (IS_ERR(inst)) goto out; inst->alg.cra_ablkcipher.givencrypt = seqiv_givencrypt_first; inst->alg.cra_init = seqiv_init; inst->alg.cra_exit = skcipher_geniv_exit; inst->alg.cra_ctxsize += inst->alg.cra_ablkcipher.ivsize; out: return inst; } static struct crypto_instance seqiv_aead_alloc(struct rtattr tb) { struct crypto_instance inst; inst = aead_geniv_alloc(&seqiv_tmpl, tb, 0, 0); if (IS_ERR(inst)) goto out; inst->alg.cra_aead.givencrypt = seqiv_aead_givencrypt_first; inst->alg.cra_init = seqiv_aead_init; inst->alg.cra_exit = aead_geniv_exit; inst->alg.cra_ctxsize = inst->alg.cra_aead.ivsize; out: return inst; } static struct crypto_instance seqiv_alloc(struct rtattr tb) { struct crypto_attr_type algt; struct crypto_instance inst; int err; algt = crypto_get_attr_type(tb); if (IS_ERR(algt)) return ERR_CAST(algt); err = crypto_get_default_rng(); if (err) return ERR_PTR(err); if ((algt->type ^ CRYPTO_ALG_TYPE_AEAD) & CRYPTO_ALG_TYPE_MASK) inst = seqiv_ablkcipher_alloc(tb); else inst = seqiv_aead_alloc(tb); if (IS_ERR(inst)) goto put_rng; inst->alg.cra_alignmask \|= __alignof__(u32) - 1; inst->alg.cra_ctxsize += sizeof(struct seqiv_ctx); out: return inst; put_rng: crypto_put_default_rng(); goto out; } static void seqiv_free(struct crypto_instance inst) { if ((inst->alg.cra_flags ^ CRYPTO_ALG_TYPE_AEAD) & CRYPTO_ALG_TYPE_MASK) skcipher_geniv_free(inst); else aead_geniv_free(inst); crypto_put_default_rng(); } static struct crypto_template seqiv_tmpl = { .name = "seqiv", .alloc = seqiv_alloc, .free = seqiv_free, .module = THIS_MODULE, }; static int __init seqiv_module_init(void) { return crypto_register_template(&seqiv_tmpl); } static void __exit seqiv_module_exit(void) { crypto_unregister_template(&seqiv_tmpl); } module_init(seqiv_module_init); module_exit(seqiv_module_exit); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("Sequence Number IV Generator");	./CrossVul/dataset_final_sorted/CWE-264/c/bad_2399_19
crossvul-cpp_data_good_3647_0	/* * linux/fs/hfsplus/catalog.c * * Copyright (C) 2001 * Brad Boyer (flar@allandria.com) * (C) 2003 Ardis Technologies <roman@ardistech.com> * * Handling of catalog records / #include "hfsplus_fs.h" #include "hfsplus_raw.h" int hfsplus_cat_case_cmp_key(const hfsplus_btree_key k1, const hfsplus_btree_key k2) { __be32 k1p, k2p; k1p = k1->cat.parent; k2p = k2->cat.parent; if (k1p != k2p) return be32_to_cpu(k1p) < be32_to_cpu(k2p) ? -1 : 1; return hfsplus_strcasecmp(&k1->cat.name, &k2->cat.name); } int hfsplus_cat_bin_cmp_key(const hfsplus_btree_key k1, const hfsplus_btree_key k2) { __be32 k1p, k2p; k1p = k1->cat.parent; k2p = k2->cat.parent; if (k1p != k2p) return be32_to_cpu(k1p) < be32_to_cpu(k2p) ? -1 : 1; return hfsplus_strcmp(&k1->cat.name, &k2->cat.name); } void hfsplus_cat_build_key(struct super_block sb, hfsplus_btree_key key, u32 parent, struct qstr str) { int len; key->cat.parent = cpu_to_be32(parent); if (str) { hfsplus_asc2uni(sb, &key->cat.name, str->name, str->len); len = be16_to_cpu(key->cat.name.length); } else { key->cat.name.length = 0; len = 0; } key->key_len = cpu_to_be16(6 + 2 * len); } static void hfsplus_cat_build_key_uni(hfsplus_btree_key key, u32 parent, struct hfsplus_unistr name) { int ustrlen; ustrlen = be16_to_cpu(name->length); key->cat.parent = cpu_to_be32(parent); key->cat.name.length = cpu_to_be16(ustrlen); ustrlen = 2; memcpy(key->cat.name.unicode, name->unicode, ustrlen); key->key_len = cpu_to_be16(6 + ustrlen); } void hfsplus_cat_set_perms(struct inode inode, struct hfsplus_perm perms) { if (inode->i_flags & S_IMMUTABLE) perms->rootflags \|= HFSPLUS_FLG_IMMUTABLE; else perms->rootflags &= ~HFSPLUS_FLG_IMMUTABLE; if (inode->i_flags & S_APPEND) perms->rootflags \|= HFSPLUS_FLG_APPEND; else perms->rootflags &= ~HFSPLUS_FLG_APPEND; perms->userflags = HFSPLUS_I(inode)->userflags; perms->mode = cpu_to_be16(inode->i_mode); perms->owner = cpu_to_be32(inode->i_uid); perms->group = cpu_to_be32(inode->i_gid); if (S_ISREG(inode->i_mode)) perms->dev = cpu_to_be32(inode->i_nlink); else if (S_ISBLK(inode->i_mode) \|\| S_ISCHR(inode->i_mode)) perms->dev = cpu_to_be32(inode->i_rdev); else perms->dev = 0; } static int hfsplus_cat_build_record(hfsplus_cat_entry entry, u32 cnid, struct inode inode) { struct hfsplus_sb_info sbi = HFSPLUS_SB(inode->i_sb); if (S_ISDIR(inode->i_mode)) { struct hfsplus_cat_folder folder; folder = &entry->folder; memset(folder, 0, sizeof(folder)); folder->type = cpu_to_be16(HFSPLUS_FOLDER); folder->id = cpu_to_be32(inode->i_ino); HFSPLUS_I(inode)->create_date = folder->create_date = folder->content_mod_date = folder->attribute_mod_date = folder->access_date = hfsp_now2mt(); hfsplus_cat_set_perms(inode, &folder->permissions); if (inode == sbi->hidden_dir) /* invisible and namelocked / folder->user_info.frFlags = cpu_to_be16(0x5000); return sizeof(folder); } else { struct hfsplus_cat_file file; file = &entry->file; memset(file, 0, sizeof(file)); file->type = cpu_to_be16(HFSPLUS_FILE); file->flags = cpu_to_be16(HFSPLUS_FILE_THREAD_EXISTS); file->id = cpu_to_be32(cnid); HFSPLUS_I(inode)->create_date = file->create_date = file->content_mod_date = file->attribute_mod_date = file->access_date = hfsp_now2mt(); if (cnid == inode->i_ino) { hfsplus_cat_set_perms(inode, &file->permissions); if (S_ISLNK(inode->i_mode)) { file->user_info.fdType = cpu_to_be32(HFSP_SYMLINK_TYPE); file->user_info.fdCreator = cpu_to_be32(HFSP_SYMLINK_CREATOR); } else { file->user_info.fdType = cpu_to_be32(sbi->type); file->user_info.fdCreator = cpu_to_be32(sbi->creator); } if (HFSPLUS_FLG_IMMUTABLE & (file->permissions.rootflags \| file->permissions.userflags)) file->flags \|= cpu_to_be16(HFSPLUS_FILE_LOCKED); } else { file->user_info.fdType = cpu_to_be32(HFSP_HARDLINK_TYPE); file->user_info.fdCreator = cpu_to_be32(HFSP_HFSPLUS_CREATOR); file->user_info.fdFlags = cpu_to_be16(0x100); file->create_date = HFSPLUS_I(sbi->hidden_dir)->create_date; file->permissions.dev = cpu_to_be32(HFSPLUS_I(inode)->linkid); } return sizeof(file); } } static int hfsplus_fill_cat_thread(struct super_block sb, hfsplus_cat_entry entry, int type, u32 parentid, struct qstr str) { entry->type = cpu_to_be16(type); entry->thread.reserved = 0; entry->thread.parentID = cpu_to_be32(parentid); hfsplus_asc2uni(sb, &entry->thread.nodeName, str->name, str->len); return 10 + be16_to_cpu(entry->thread.nodeName.length) * 2; } /* Try to get a catalog entry for given catalog id / int hfsplus_find_cat(struct super_block sb, u32 cnid, struct hfs_find_data fd) { hfsplus_cat_entry tmp; int err; u16 type; hfsplus_cat_build_key(sb, fd->search_key, cnid, NULL); err = hfs_brec_read(fd, &tmp, sizeof(hfsplus_cat_entry)); if (err) return err; type = be16_to_cpu(tmp.type); if (type != HFSPLUS_FOLDER_THREAD && type != HFSPLUS_FILE_THREAD) { printk(KERN_ERR "hfs: found bad thread record in catalog\n"); return -EIO; } if (be16_to_cpu(tmp.thread.nodeName.length) > 255) { printk(KERN_ERR "hfs: catalog name length corrupted\n"); return -EIO; } hfsplus_cat_build_key_uni(fd->search_key, be32_to_cpu(tmp.thread.parentID), &tmp.thread.nodeName); return hfs_brec_find(fd); } int hfsplus_create_cat(u32 cnid, struct inode dir, struct qstr str, struct inode inode) { struct super_block sb = dir->i_sb; struct hfs_find_data fd; hfsplus_cat_entry entry; int entry_size; int err; dprint(DBG_CAT_MOD, "create_cat: %s,%u(%d)\n", str->name, cnid, inode->i_nlink); err = hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &fd); if (err) return err; hfsplus_cat_build_key(sb, fd.search_key, cnid, NULL); entry_size = hfsplus_fill_cat_thread(sb, &entry, S_ISDIR(inode->i_mode) ? HFSPLUS_FOLDER_THREAD : HFSPLUS_FILE_THREAD, dir->i_ino, str); err = hfs_brec_find(&fd); if (err != -ENOENT) { if (!err) err = -EEXIST; goto err2; } err = hfs_brec_insert(&fd, &entry, entry_size); if (err) goto err2; hfsplus_cat_build_key(sb, fd.search_key, dir->i_ino, str); entry_size = hfsplus_cat_build_record(&entry, cnid, inode); err = hfs_brec_find(&fd); if (err != -ENOENT) { / panic? / if (!err) err = -EEXIST; goto err1; } err = hfs_brec_insert(&fd, &entry, entry_size); if (err) goto err1; dir->i_size++; dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC; hfsplus_mark_inode_dirty(dir, HFSPLUS_I_CAT_DIRTY); hfs_find_exit(&fd); return 0; err1: hfsplus_cat_build_key(sb, fd.search_key, cnid, NULL); if (!hfs_brec_find(&fd)) hfs_brec_remove(&fd); err2: hfs_find_exit(&fd); return err; } int hfsplus_delete_cat(u32 cnid, struct inode dir, struct qstr str) { struct super_block sb = dir->i_sb; struct hfs_find_data fd; struct hfsplus_fork_raw fork; struct list_head pos; int err, off; u16 type; dprint(DBG_CAT_MOD, "delete_cat: %s,%u\n", str ? str->name : NULL, cnid); err = hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &fd); if (err) return err; if (!str) { int len; hfsplus_cat_build_key(sb, fd.search_key, cnid, NULL); err = hfs_brec_find(&fd); if (err) goto out; off = fd.entryoffset + offsetof(struct hfsplus_cat_thread, nodeName); fd.search_key->cat.parent = cpu_to_be32(dir->i_ino); hfs_bnode_read(fd.bnode, &fd.search_key->cat.name.length, off, 2); len = be16_to_cpu(fd.search_key->cat.name.length) 2; hfs_bnode_read(fd.bnode, &fd.search_key->cat.name.unicode, off + 2, len); fd.search_key->key_len = cpu_to_be16(6 + len); } else hfsplus_cat_build_key(sb, fd.search_key, dir->i_ino, str); err = hfs_brec_find(&fd); if (err) goto out; type = hfs_bnode_read_u16(fd.bnode, fd.entryoffset); if (type == HFSPLUS_FILE) { #if 0 off = fd.entryoffset + offsetof(hfsplus_cat_file, data_fork); hfs_bnode_read(fd.bnode, &fork, off, sizeof(fork)); hfsplus_free_fork(sb, cnid, &fork, HFSPLUS_TYPE_DATA); #endif off = fd.entryoffset + offsetof(struct hfsplus_cat_file, rsrc_fork); hfs_bnode_read(fd.bnode, &fork, off, sizeof(fork)); hfsplus_free_fork(sb, cnid, &fork, HFSPLUS_TYPE_RSRC); } list_for_each(pos, &HFSPLUS_I(dir)->open_dir_list) { struct hfsplus_readdir_data rd = list_entry(pos, struct hfsplus_readdir_data, list); if (fd.tree->keycmp(fd.search_key, (void )&rd->key) < 0) rd->file->f_pos--; } err = hfs_brec_remove(&fd); if (err) goto out; hfsplus_cat_build_key(sb, fd.search_key, cnid, NULL); err = hfs_brec_find(&fd); if (err) goto out; err = hfs_brec_remove(&fd); if (err) goto out; dir->i_size--; dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC; hfsplus_mark_inode_dirty(dir, HFSPLUS_I_CAT_DIRTY); out: hfs_find_exit(&fd); return err; } int hfsplus_rename_cat(u32 cnid, struct inode src_dir, struct qstr src_name, struct inode dst_dir, struct qstr dst_name) { struct super_block sb = src_dir->i_sb; struct hfs_find_data src_fd, dst_fd; hfsplus_cat_entry entry; int entry_size, type; int err; dprint(DBG_CAT_MOD, "rename_cat: %u - %lu,%s - %lu,%s\n", cnid, src_dir->i_ino, src_name->name, dst_dir->i_ino, dst_name->name); err = hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &src_fd); if (err) return err; dst_fd = src_fd; / find the old dir entry and read the data / hfsplus_cat_build_key(sb, src_fd.search_key, src_dir->i_ino, src_name); err = hfs_brec_find(&src_fd); if (err) goto out; if (src_fd.entrylength > sizeof(entry) \|\| src_fd.entrylength < 0) { err = -EIO; goto out; } hfs_bnode_read(src_fd.bnode, &entry, src_fd.entryoffset, src_fd.entrylength); / create new dir entry with the data from the old entry / hfsplus_cat_build_key(sb, dst_fd.search_key, dst_dir->i_ino, dst_name); err = hfs_brec_find(&dst_fd); if (err != -ENOENT) { if (!err) err = -EEXIST; goto out; } err = hfs_brec_insert(&dst_fd, &entry, src_fd.entrylength); if (err) goto out; dst_dir->i_size++; dst_dir->i_mtime = dst_dir->i_ctime = CURRENT_TIME_SEC; / finally remove the old entry / hfsplus_cat_build_key(sb, src_fd.search_key, src_dir->i_ino, src_name); err = hfs_brec_find(&src_fd); if (err) goto out; err = hfs_brec_remove(&src_fd); if (err) goto out; src_dir->i_size--; src_dir->i_mtime = src_dir->i_ctime = CURRENT_TIME_SEC; / remove old thread entry / hfsplus_cat_build_key(sb, src_fd.search_key, cnid, NULL); err = hfs_brec_find(&src_fd); if (err) goto out; type = hfs_bnode_read_u16(src_fd.bnode, src_fd.entryoffset); err = hfs_brec_remove(&src_fd); if (err) goto out; / create new thread entry */ hfsplus_cat_build_key(sb, dst_fd.search_key, cnid, NULL); entry_size = hfsplus_fill_cat_thread(sb, &entry, type, dst_dir->i_ino, dst_name); err = hfs_brec_find(&dst_fd); if (err != -ENOENT) { if (!err) err = -EEXIST; goto out; } err = hfs_brec_insert(&dst_fd, &entry, entry_size); hfsplus_mark_inode_dirty(dst_dir, HFSPLUS_I_CAT_DIRTY); hfsplus_mark_inode_dirty(src_dir, HFSPLUS_I_CAT_DIRTY); out: hfs_bnode_put(dst_fd.bnode); hfs_find_exit(&src_fd); return err; }	./CrossVul/dataset_final_sorted/CWE-264/c/good_3647_0
crossvul-cpp_data_bad_4698_2	/* -- c-basic-offset: 4; -- / // Original code taken from the example webkit-gtk+ application. see notice below. // Modified code is licensed under the GPL 3. See LICENSE file. / * Copyright (C) 2006, 2007 Apple Inc. * Copyright (C) 2007 Alp Toker <alp@atoker.com> * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. / #include "uzbl-core.h" #include "callbacks.h" #include "events.h" #include "inspector.h" #include "config.h" UzblCore uzbl; / commandline arguments (set initial values for the state variables) / const GOptionEntry entries[] = { { "uri", 'u', 0, G_OPTION_ARG_STRING, &uzbl.state.uri, "Uri to load at startup (equivalent to 'uzbl <uri>' or 'set uri = URI' after uzbl has launched)", "URI" }, { "verbose", 'v', 0, G_OPTION_ARG_NONE, &uzbl.state.verbose, "Whether to print all messages or just errors.", NULL }, { "name", 'n', 0, G_OPTION_ARG_STRING, &uzbl.state.instance_name, "Name of the current instance (defaults to Xorg window id or random for GtkSocket mode)", "NAME" }, { "config", 'c', 0, G_OPTION_ARG_STRING, &uzbl.state.config_file, "Path to config file or '-' for stdin", "FILE" }, { "socket", 's', 0, G_OPTION_ARG_INT, &uzbl.state.socket_id, "Socket ID", "SOCKET" }, { "connect-socket", 0, 0, G_OPTION_ARG_STRING_ARRAY, &uzbl.state.connect_socket_names, "Connect to server socket", "CSOCKET" }, { "geometry", 'g', 0, G_OPTION_ARG_STRING, &uzbl.gui.geometry, "Set window geometry (format: WIDTHxHEIGHT+-X+-Y or maximized)", "GEOMETRY" }, { "version", 'V', 0, G_OPTION_ARG_NONE, &uzbl.behave.print_version, "Print the version and exit", NULL }, { NULL, 0, 0, 0, NULL, NULL, NULL } }; XDG_Var XDG[] = { { "XDG_CONFIG_HOME", "~/.config" }, { "XDG_DATA_HOME", "~/.local/share" }, { "XDG_CACHE_HOME", "~/.cache" }, { "XDG_CONFIG_DIRS", "/etc/xdg" }, { "XDG_DATA_DIRS", "/usr/local/share/:/usr/share/" }, }; / abbreviations to help keep the table's width humane / #define PTR_V_STR(var, d, fun) { .ptr.s = &(var), .type = TYPE_STR, .dump = d, .writeable = 1, .func = fun } #define PTR_V_INT(var, d, fun) { .ptr.i = (int)&(var), .type = TYPE_INT, .dump = d, .writeable = 1, .func = fun } #define PTR_V_FLOAT(var, d, fun) { .ptr.f = &(var), .type = TYPE_FLOAT, .dump = d, .writeable = 1, .func = fun } #define PTR_C_STR(var, fun) { .ptr.s = &(var), .type = TYPE_STR, .dump = 0, .writeable = 0, .func = fun } #define PTR_C_INT(var, fun) { .ptr.i = (int)&(var), .type = TYPE_INT, .dump = 0, .writeable = 0, .func = fun } #define PTR_C_FLOAT(var, fun) { .ptr.f = &(var), .type = TYPE_FLOAT, .dump = 0, .writeable = 0, .func = fun } const struct var_name_to_ptr_t { const char name; uzbl_cmdprop cp; } var_name_to_ptr[] = { /* variable name pointer to variable in code dump callback function / / ---------------------------------------------------------------------------------------------- / { "uri", PTR_V_STR(uzbl.state.uri, 1, cmd_load_uri)}, { "verbose", PTR_V_INT(uzbl.state.verbose, 1, NULL)}, { "inject_html", PTR_V_STR(uzbl.behave.inject_html, 0, cmd_inject_html)}, { "geometry", PTR_V_STR(uzbl.gui.geometry, 1, cmd_set_geometry)}, { "keycmd", PTR_V_STR(uzbl.state.keycmd, 1, NULL)}, { "show_status", PTR_V_INT(uzbl.behave.show_status, 1, cmd_set_status)}, { "status_top", PTR_V_INT(uzbl.behave.status_top, 1, move_statusbar)}, { "status_format", PTR_V_STR(uzbl.behave.status_format, 1, NULL)}, { "status_background", PTR_V_STR(uzbl.behave.status_background, 1, NULL)}, { "title_format_long", PTR_V_STR(uzbl.behave.title_format_long, 1, NULL)}, { "title_format_short", PTR_V_STR(uzbl.behave.title_format_short, 1, NULL)}, { "icon", PTR_V_STR(uzbl.gui.icon, 1, set_icon)}, { "forward_keys", PTR_V_INT(uzbl.behave.forward_keys, 1, NULL)}, { "download_handler", PTR_V_STR(uzbl.behave.download_handler, 1, NULL)}, { "cookie_handler", PTR_V_STR(uzbl.behave.cookie_handler, 1, NULL)}, { "new_window", PTR_V_STR(uzbl.behave.new_window, 1, NULL)}, { "scheme_handler", PTR_V_STR(uzbl.behave.scheme_handler, 1, NULL)}, { "fifo_dir", PTR_V_STR(uzbl.behave.fifo_dir, 1, cmd_fifo_dir)}, { "socket_dir", PTR_V_STR(uzbl.behave.socket_dir, 1, cmd_socket_dir)}, { "http_debug", PTR_V_INT(uzbl.behave.http_debug, 1, cmd_http_debug)}, { "shell_cmd", PTR_V_STR(uzbl.behave.shell_cmd, 1, NULL)}, { "proxy_url", PTR_V_STR(uzbl.net.proxy_url, 1, set_proxy_url)}, { "max_conns", PTR_V_INT(uzbl.net.max_conns, 1, cmd_max_conns)}, { "max_conns_host", PTR_V_INT(uzbl.net.max_conns_host, 1, cmd_max_conns_host)}, { "useragent", PTR_V_STR(uzbl.net.useragent, 1, cmd_useragent)}, / requires webkit >=1.1.14 / { "view_source", PTR_V_INT(uzbl.behave.view_source, 0, cmd_view_source)}, / exported WebKitWebSettings properties / { "zoom_level", PTR_V_FLOAT(uzbl.behave.zoom_level, 1, cmd_zoom_level)}, { "zoom_type", PTR_V_INT(uzbl.behave.zoom_type, 1, cmd_set_zoom_type)}, { "font_size", PTR_V_INT(uzbl.behave.font_size, 1, cmd_font_size)}, { "default_font_family", PTR_V_STR(uzbl.behave.default_font_family, 1, cmd_default_font_family)}, { "monospace_font_family", PTR_V_STR(uzbl.behave.monospace_font_family, 1, cmd_monospace_font_family)}, { "cursive_font_family", PTR_V_STR(uzbl.behave.cursive_font_family, 1, cmd_cursive_font_family)}, { "sans_serif_font_family", PTR_V_STR(uzbl.behave.sans_serif_font_family, 1, cmd_sans_serif_font_family)}, { "serif_font_family", PTR_V_STR(uzbl.behave.serif_font_family, 1, cmd_serif_font_family)}, { "fantasy_font_family", PTR_V_STR(uzbl.behave.fantasy_font_family, 1, cmd_fantasy_font_family)}, { "monospace_size", PTR_V_INT(uzbl.behave.monospace_size, 1, cmd_font_size)}, { "minimum_font_size", PTR_V_INT(uzbl.behave.minimum_font_size, 1, cmd_minimum_font_size)}, { "disable_plugins", PTR_V_INT(uzbl.behave.disable_plugins, 1, cmd_disable_plugins)}, { "disable_scripts", PTR_V_INT(uzbl.behave.disable_scripts, 1, cmd_disable_scripts)}, { "autoload_images", PTR_V_INT(uzbl.behave.autoload_img, 1, cmd_autoload_img)}, { "autoshrink_images", PTR_V_INT(uzbl.behave.autoshrink_img, 1, cmd_autoshrink_img)}, { "enable_spellcheck", PTR_V_INT(uzbl.behave.enable_spellcheck, 1, cmd_enable_spellcheck)}, { "enable_private", PTR_V_INT(uzbl.behave.enable_private, 1, cmd_enable_private)}, { "print_backgrounds", PTR_V_INT(uzbl.behave.print_bg, 1, cmd_print_bg)}, { "stylesheet_uri", PTR_V_STR(uzbl.behave.style_uri, 1, cmd_style_uri)}, { "resizable_text_areas", PTR_V_INT(uzbl.behave.resizable_txt, 1, cmd_resizable_txt)}, { "default_encoding", PTR_V_STR(uzbl.behave.default_encoding, 1, cmd_default_encoding)}, { "enforce_96_dpi", PTR_V_INT(uzbl.behave.enforce_96dpi, 1, cmd_enforce_96dpi)}, { "caret_browsing", PTR_V_INT(uzbl.behave.caret_browsing, 1, cmd_caret_browsing)}, / constants (not dumpable or writeable) / { "WEBKIT_MAJOR", PTR_C_INT(uzbl.info.webkit_major, NULL)}, { "WEBKIT_MINOR", PTR_C_INT(uzbl.info.webkit_minor, NULL)}, { "WEBKIT_MICRO", PTR_C_INT(uzbl.info.webkit_micro, NULL)}, { "ARCH_UZBL", PTR_C_STR(uzbl.info.arch, NULL)}, { "COMMIT", PTR_C_STR(uzbl.info.commit, NULL)}, { "TITLE", PTR_C_STR(uzbl.gui.main_title, NULL)}, { "SELECTED_URI", PTR_C_STR(uzbl.state.selected_url, NULL)}, { "NAME", PTR_C_STR(uzbl.state.instance_name, NULL)}, { "PID", PTR_C_STR(uzbl.info.pid_str, NULL)}, { NULL, {.ptr.s = NULL, .type = TYPE_INT, .dump = 0, .writeable = 0, .func = NULL}} }; / construct a hash from the var_name_to_ptr array for quick access / void create_var_to_name_hash() { const struct var_name_to_ptr_t n2v_p = var_name_to_ptr; uzbl.comm.proto_var = g_hash_table_new(g_str_hash, g_str_equal); while(n2v_p->name) { g_hash_table_insert(uzbl.comm.proto_var, (gpointer) n2v_p->name, (gpointer) &n2v_p->cp); n2v_p++; } } /* --- UTILITY FUNCTIONS --- / enum exp_type {EXP_ERR, EXP_SIMPLE_VAR, EXP_BRACED_VAR, EXP_EXPR, EXP_JS, EXP_ESCAPE}; enum exp_type get_exp_type(const gchar s) { /* variables / if((s+1) == '(') return EXP_EXPR; else if((s+1) == '{') return EXP_BRACED_VAR; else if((s+1) == '<') return EXP_JS; else if((s+1) == '[') return EXP_ESCAPE; else return EXP_SIMPLE_VAR; /@notreached@/ return EXP_ERR; } / * recurse == 1: don't expand '@(command)@' * recurse == 2: don't expand '@<java script>@' / gchar expand(const char s, guint recurse) { uzbl_cmdprop c; enum exp_type etype; char end_simple_var = "^°!\"§$%&/()=?'`'+~'#-.:,;@<>\| \\{}[]¹²³¼½"; char ret = NULL; char vend = NULL; GError err = NULL; gchar cmd_stdout = NULL; gchar mycmd = NULL; GString buf = g_string_new(""); GString js_ret = g_string_new(""); while(s && s) { switch(s) { case '\\': g_string_append_c(buf, ++s); s++; break; case '@': etype = get_exp_type(s); s++; switch(etype) { case EXP_SIMPLE_VAR: vend = strpbrk(s, end_simple_var); if(!vend) vend = strchr(s, '\0'); break; case EXP_BRACED_VAR: s++; vend = strchr(s, '}'); if(!vend) vend = strchr(s, '\0'); break; case EXP_EXPR: s++; vend = strstr(s, ")@"); if(!vend) vend = strchr(s, '\0'); break; case EXP_JS: s++; vend = strstr(s, ">@"); if(!vend) vend = strchr(s, '\0'); break; case EXP_ESCAPE: s++; vend = strstr(s, "]@"); if(!vend) vend = strchr(s, '\0'); break; /@notreached@/ case EXP_ERR: break; } assert(vend); ret = g_strndup(s, vend-s); if(etype == EXP_SIMPLE_VAR \|\| etype == EXP_BRACED_VAR) { if( (c = g_hash_table_lookup(uzbl.comm.proto_var, ret)) ) { if(c->type == TYPE_STR && c->ptr.s != NULL) { g_string_append(buf, (gchar )c->ptr.s); } else if(c->type == TYPE_INT) { g_string_append_printf(buf, "%d", c->ptr.i); } else if(c->type == TYPE_FLOAT) { g_string_append_printf(buf, "%f", c->ptr.f); } } if(etype == EXP_SIMPLE_VAR) s = vend; else s = vend+1; } else if(recurse != 1 && etype == EXP_EXPR) { / execute program directly / if(ret[0] == '+') { mycmd = expand(ret+1, 1); g_spawn_command_line_sync(mycmd, &cmd_stdout, NULL, NULL, &err); g_free(mycmd); } / execute program through shell, quote it first / else { mycmd = expand(ret, 1); gchar quoted = g_shell_quote(mycmd); gchar tmp = g_strdup_printf("%s %s", uzbl.behave.shell_cmd?uzbl.behave.shell_cmd:"/bin/sh -c", quoted); g_spawn_command_line_sync(tmp, &cmd_stdout, NULL, NULL, &err); g_free(mycmd); g_free(quoted); g_free(tmp); } if (err) { g_printerr("error on running command: %s\n", err->message); g_error_free (err); } else if (cmd_stdout) { size_t len = strlen(cmd_stdout); if(len > 0 && cmd_stdout[len-1] == '\n') cmd_stdout[--len] = '\0'; /* strip trailing newline / g_string_append(buf, cmd_stdout); g_free(cmd_stdout); } s = vend+2; } else if(recurse != 2 && etype == EXP_JS) { / read JS from file / if(ret[0] == '+') { GArray tmp = g_array_new(TRUE, FALSE, sizeof(gchar )); mycmd = expand(ret+1, 2); g_array_append_val(tmp, mycmd); run_external_js(uzbl.gui.web_view, tmp, js_ret); g_array_free(tmp, TRUE); } / JS from string / else { mycmd = expand(ret, 2); eval_js(uzbl.gui.web_view, mycmd, js_ret); g_free(mycmd); } if(js_ret->str) { g_string_append(buf, js_ret->str); g_string_free(js_ret, TRUE); js_ret = g_string_new(""); } s = vend+2; } else if(etype == EXP_ESCAPE) { mycmd = expand(ret, 0); char escaped = g_markup_escape_text(mycmd, strlen(mycmd)); g_string_append(buf, escaped); g_free(escaped); g_free(mycmd); s = vend+2; } g_free(ret); ret = NULL; break; default: g_string_append_c(buf, s); s++; break; } } g_string_free(js_ret, TRUE); return g_string_free(buf, FALSE); } char itos(int val) { char tmp[20]; snprintf(tmp, sizeof(tmp), "%i", val); return g_strdup(tmp); } gchar* strfree(gchar str) { g_free(str); return NULL; } gchar argv_idx(const GArray a, const guint idx) { return g_array_index(a, gchar, idx); } char * str_replace (const char* search, const char* replace, const char* string) { gchar *buf; char ret; if(!string) return NULL; buf = g_strsplit (string, search, -1); ret = g_strjoinv (replace, buf); g_strfreev(buf); return ret; } GArray* read_file_by_line (const gchar path) { GIOChannel chan = NULL; gchar readbuf = NULL; gsize len; GArray lines = g_array_new(TRUE, FALSE, sizeof(gchar)); int i = 0; chan = g_io_channel_new_file(path, "r", NULL); if (chan) { while (g_io_channel_read_line(chan, &readbuf, &len, NULL, NULL) == G_IO_STATUS_NORMAL) { const gchar val = g_strdup (readbuf); g_array_append_val (lines, val); g_free (readbuf); i ++; } g_io_channel_unref (chan); } else { gchar tmp = g_strdup_printf("File %s can not be read.", path); send_event(COMMAND_ERROR, tmp, NULL); g_free(tmp); } return lines; } / search a PATH style string for an existing file+path combination / gchar find_existing_file(gchar* path_list) { int i=0; int cnt; gchar *split; gchar tmp = NULL; gchar executable; if(!path_list) return NULL; split = g_strsplit(path_list, ":", 0); while(split[i]) i++; if(i<=1) { tmp = g_strdup(split[0]); g_strfreev(split); return tmp; } else cnt = i-1; i=0; tmp = g_strdup(split[cnt]); g_strstrip(tmp); if(tmp[0] == '/') executable = g_strdup_printf("%s", tmp+1); else executable = g_strdup(tmp); g_free(tmp); while(i<cnt) { tmp = g_strconcat(g_strstrip(split[i]), "/", executable, NULL); if(g_file_test(tmp, G_FILE_TEST_EXISTS)) { g_strfreev(split); return tmp; } else g_free(tmp); i++; } g_free(executable); g_strfreev(split); return NULL; } / Returns a new string with environment $variables expanded / gchar parseenv (gchar* string) { extern char** environ; gchar* tmpstr = NULL, * out; int i = 0; if(!string) return NULL; out = g_strdup(string); while (environ[i] != NULL) { gchar** env = g_strsplit (environ[i], "=", 2); gchar* envname = g_strconcat ("$", env[0], NULL); if (g_strrstr (string, envname) != NULL) { tmpstr = out; out = str_replace(envname, env[1], out); g_free (tmpstr); } g_free (envname); g_strfreev (env); // somebody said this breaks uzbl i++; } return out; } void clean_up(void) { send_event(INSTANCE_EXIT, uzbl.info.pid_str, NULL); g_free(uzbl.info.pid_str); g_free(uzbl.state.executable_path); g_hash_table_destroy(uzbl.behave.commands); if(uzbl.state.event_buffer) g_ptr_array_free(uzbl.state.event_buffer, TRUE); if (uzbl.behave.fifo_dir) unlink (uzbl.comm.fifo_path); if (uzbl.behave.socket_dir) unlink (uzbl.comm.socket_path); } gint get_click_context() { GUI g = &uzbl.gui; WebKitHitTestResult ht; guint context; if(!uzbl.state.last_button) return -1; ht = webkit_web_view_get_hit_test_result(g->web_view, uzbl.state.last_button); g_object_get(ht, "context", &context, NULL); return (gint)context; } /* --- SIGNALS --- / int sigs[] = {SIGTERM, SIGINT, SIGSEGV, SIGILL, SIGFPE, SIGQUIT, SIGALRM, 0}; sigfunc setup_signal(int signr, sigfunc shandler) { struct sigaction nh, oh; nh.sa_handler = shandler; sigemptyset(&nh.sa_mask); nh.sa_flags = 0; if(sigaction(signr, &nh, &oh) < 0) return SIG_ERR; return NULL; } void catch_signal(int s) { if(s == SIGTERM \|\| s == SIGINT \|\| s == SIGILL \|\| s == SIGFPE \|\| s == SIGQUIT) { clean_up(); exit(EXIT_SUCCESS); } else if(s == SIGSEGV) { clean_up(); fprintf(stderr, "Program aborted, segmentation fault!\nAttempting to clean up...\n"); exit(EXIT_FAILURE); } else if(s == SIGALRM && uzbl.state.event_buffer) { g_ptr_array_free(uzbl.state.event_buffer, TRUE); uzbl.state.event_buffer = NULL; } } / scroll a bar in a given direction / void scroll (GtkAdjustment bar, gchar amount_str) { gchar end; gdouble max_value; gdouble page_size = gtk_adjustment_get_page_size(bar); gdouble value = gtk_adjustment_get_value(bar); gdouble amount = g_ascii_strtod(amount_str, &end); if (end == '%') value += page_size amount * 0.01; else value += amount; max_value = gtk_adjustment_get_upper(bar) - page_size; if (value > max_value) value = max_value; /* don't scroll past the end of the page / gtk_adjustment_set_value (bar, value); } / * scroll vertical 20 * scroll vertical 20% * scroll vertical -40 * scroll vertical begin * scroll vertical end * scroll horizontal 10 * scroll horizontal -500 * scroll horizontal begin * scroll horizontal end / void scroll_cmd(WebKitWebView page, GArray argv, GString result) { (void) page; (void) result; gchar direction = g_array_index(argv, gchar, 0); gchar argv1 = g_array_index(argv, gchar, 1); if (g_strcmp0(direction, "horizontal") == 0) { if (g_strcmp0(argv1, "begin") == 0) gtk_adjustment_set_value(uzbl.gui.bar_h, gtk_adjustment_get_lower(uzbl.gui.bar_h)); else if (g_strcmp0(argv1, "end") == 0) gtk_adjustment_set_value (uzbl.gui.bar_h, gtk_adjustment_get_upper(uzbl.gui.bar_h) - gtk_adjustment_get_page_size(uzbl.gui.bar_h)); else scroll(uzbl.gui.bar_h, argv1); } else if (g_strcmp0(direction, "vertical") == 0) { if (g_strcmp0(argv1, "begin") == 0) gtk_adjustment_set_value(uzbl.gui.bar_v, gtk_adjustment_get_lower(uzbl.gui.bar_v)); else if (g_strcmp0(argv1, "end") == 0) gtk_adjustment_set_value (uzbl.gui.bar_v, gtk_adjustment_get_upper(uzbl.gui.bar_v) - gtk_adjustment_get_page_size(uzbl.gui.bar_v)); else scroll(uzbl.gui.bar_v, argv1); } else if(uzbl.state.verbose) puts("Unrecognized scroll format"); } /* VIEW funcs (little webkit wrappers) / #define VIEWFUNC(name) void view_##name(WebKitWebView page, GArray argv, GString result){(void)argv; (void)result; webkit_web_view_##name(page);} VIEWFUNC(reload) VIEWFUNC(reload_bypass_cache) VIEWFUNC(stop_loading) VIEWFUNC(zoom_in) VIEWFUNC(zoom_out) VIEWFUNC(go_back) VIEWFUNC(go_forward) #undef VIEWFUNC /* -- command to callback/function map for things we cannot attach to any signals / struct {const char key; CommandInfo value;} cmdlist[] = { /* key function no_split / { "back", {view_go_back, 0} }, { "forward", {view_go_forward, 0} }, { "scroll", {scroll_cmd, 0} }, { "reload", {view_reload, 0}, }, { "reload_ign_cache", {view_reload_bypass_cache, 0} }, { "stop", {view_stop_loading, 0}, }, { "zoom_in", {view_zoom_in, 0}, }, //Can crash (when max zoom reached?). { "zoom_out", {view_zoom_out, 0}, }, { "toggle_zoom_type", {toggle_zoom_type, 0}, }, { "uri", {load_uri, TRUE} }, { "js", {run_js, TRUE} }, { "script", {run_external_js, 0} }, { "toggle_status", {toggle_status_cb, 0} }, { "spawn", {spawn, 0} }, { "sync_spawn", {spawn_sync, 0} }, // needed for cookie handler { "sh", {spawn_sh, 0} }, { "sync_sh", {spawn_sh_sync, 0} }, // needed for cookie handler { "talk_to_socket", {talk_to_socket, 0} }, { "exit", {close_uzbl, 0} }, { "search", {search_forward_text, TRUE} }, { "search_reverse", {search_reverse_text, TRUE} }, { "search_clear", {search_clear, TRUE} }, { "dehilight", {dehilight, 0} }, { "set", {set_var, TRUE} }, { "dump_config", {act_dump_config, 0} }, { "dump_config_as_events", {act_dump_config_as_events, 0} }, { "chain", {chain, 0} }, { "print", {print, TRUE} }, { "event", {event, TRUE} }, { "request", {event, TRUE} }, { "menu_add", {menu_add, TRUE} }, { "menu_link_add", {menu_add_link, TRUE} }, { "menu_image_add", {menu_add_image, TRUE} }, { "menu_editable_add", {menu_add_edit, TRUE} }, { "menu_separator", {menu_add_separator, TRUE} }, { "menu_link_separator", {menu_add_separator_link, TRUE} }, { "menu_image_separator", {menu_add_separator_image, TRUE}}, { "menu_editable_separator", {menu_add_separator_edit, TRUE} }, { "menu_remove", {menu_remove, TRUE} }, { "menu_link_remove", {menu_remove_link, TRUE} }, { "menu_image_remove", {menu_remove_image, TRUE} }, { "menu_editable_remove", {menu_remove_edit, TRUE} }, { "hardcopy", {hardcopy, TRUE} }, { "include", {include, TRUE} } }; void commands_hash(void) { unsigned int i; uzbl.behave.commands = g_hash_table_new(g_str_hash, g_str_equal); for (i = 0; i < LENGTH(cmdlist); i++) g_hash_table_insert(uzbl.behave.commands, (gpointer) cmdlist[i].key, &cmdlist[i].value); } void builtins() { unsigned int i, len = LENGTH(cmdlist); GString command_list = g_string_new(""); for (i = 0; i < len; i++) { g_string_append(command_list, cmdlist[i].key); g_string_append_c(command_list, ' '); } send_event(BUILTINS, command_list->str, NULL); g_string_free(command_list, TRUE); } /* -- CORE FUNCTIONS -- / bool file_exists (const char filename) { return (access(filename, F_OK) == 0); } void set_var(WebKitWebView page, GArray argv, GString result) { (void) page; (void) result; if(!argv_idx(argv, 0)) return; gchar split = g_strsplit(argv_idx(argv, 0), "=", 2); if (split[0] != NULL) { gchar value = parseenv(split[1] ? g_strchug(split[1]) : " "); set_var_value(g_strstrip(split[0]), value); g_free(value); } g_strfreev(split); } void add_to_menu(GArray argv, guint context) { GUI g = &uzbl.gui; MenuItem m; gchar item_cmd = NULL; if(!argv_idx(argv, 0)) return; gchar *split = g_strsplit(argv_idx(argv, 0), "=", 2); if(!g->menu_items) g->menu_items = g_ptr_array_new(); if(split[1]) item_cmd = g_strdup(split[1]); if(split[0]) { m = malloc(sizeof(MenuItem)); m->name = g_strdup(split[0]); m->cmd = g_strdup(item_cmd?item_cmd:""); m->context = context; m->issep = FALSE; g_ptr_array_add(g->menu_items, m); } else g_free(item_cmd); g_strfreev(split); } void menu_add(WebKitWebView page, GArray argv, GString result) { (void) page; (void) result; add_to_menu(argv, WEBKIT_HIT_TEST_RESULT_CONTEXT_DOCUMENT); } void menu_add_link(WebKitWebView page, GArray argv, GString result) { (void) page; (void) result; add_to_menu(argv, WEBKIT_HIT_TEST_RESULT_CONTEXT_LINK); } void menu_add_image(WebKitWebView page, GArray argv, GString result) { (void) page; (void) result; add_to_menu(argv, WEBKIT_HIT_TEST_RESULT_CONTEXT_IMAGE); } void menu_add_edit(WebKitWebView page, GArray argv, GString result) { (void) page; (void) result; add_to_menu(argv, WEBKIT_HIT_TEST_RESULT_CONTEXT_EDITABLE); } void add_separator_to_menu(GArray argv, guint context) { GUI g = &uzbl.gui; MenuItem m; gchar sep_name; if(!g->menu_items) g->menu_items = g_ptr_array_new(); if(!argv_idx(argv, 0)) return; else sep_name = argv_idx(argv, 0); m = malloc(sizeof(MenuItem)); m->name = g_strdup(sep_name); m->cmd = NULL; m->context = context; m->issep = TRUE; g_ptr_array_add(g->menu_items, m); } void menu_add_separator(WebKitWebView page, GArray argv, GString result) { (void) page; (void) result; add_separator_to_menu(argv, WEBKIT_HIT_TEST_RESULT_CONTEXT_DOCUMENT); } void menu_add_separator_link(WebKitWebView page, GArray argv, GString result) { (void) page; (void) result; add_separator_to_menu(argv, WEBKIT_HIT_TEST_RESULT_CONTEXT_LINK); } void menu_add_separator_image(WebKitWebView page, GArray argv, GString result) { (void) page; (void) result; add_separator_to_menu(argv, WEBKIT_HIT_TEST_RESULT_CONTEXT_IMAGE); } void menu_add_separator_edit(WebKitWebView page, GArray argv, GString result) { (void) page; (void) result; add_separator_to_menu(argv, WEBKIT_HIT_TEST_RESULT_CONTEXT_EDITABLE); } void remove_from_menu(GArray argv, guint context) { GUI g = &uzbl.gui; MenuItem mi; gchar name = NULL; guint i=0; if(!g->menu_items) return; if(!argv_idx(argv, 0)) return; else name = argv_idx(argv, 0); for(i=0; i < g->menu_items->len; i++) { mi = g_ptr_array_index(g->menu_items, i); if((context == mi->context) && !strcmp(name, mi->name)) { g_free(mi->name); g_free(mi->cmd); g_free(mi); g_ptr_array_remove_index(g->menu_items, i); } } } void menu_remove(WebKitWebView page, GArray argv, GString result) { (void) page; (void) result; remove_from_menu(argv, WEBKIT_HIT_TEST_RESULT_CONTEXT_DOCUMENT); } void menu_remove_link(WebKitWebView page, GArray argv, GString result) { (void) page; (void) result; remove_from_menu(argv, WEBKIT_HIT_TEST_RESULT_CONTEXT_LINK); } void menu_remove_image(WebKitWebView page, GArray argv, GString result) { (void) page; (void) result; remove_from_menu(argv, WEBKIT_HIT_TEST_RESULT_CONTEXT_IMAGE); } void menu_remove_edit(WebKitWebView page, GArray argv, GString result) { (void) page; (void) result; remove_from_menu(argv, WEBKIT_HIT_TEST_RESULT_CONTEXT_EDITABLE); } void event(WebKitWebView page, GArray argv, GString result) { (void) page; (void) result; GString event_name; gchar split = NULL; if(!argv_idx(argv, 0)) return; split = g_strsplit(argv_idx(argv, 0), " ", 2); if(split[0]) event_name = g_string_ascii_up(g_string_new(split[0])); else return; send_event(0, split[1]?split[1]:"", event_name->str); g_string_free(event_name, TRUE); g_strfreev(split); } void print(WebKitWebView page, GArray argv, GString result) { (void) page; (void) result; gchar* buf; buf = expand(argv_idx(argv, 0), 0); g_string_assign(result, buf); g_free(buf); } void hardcopy(WebKitWebView page, GArray argv, GString result) { (void) argv; (void) result; webkit_web_frame_print(webkit_web_view_get_main_frame(page)); } void include(WebKitWebView page, GArray argv, GString result) { (void) page; (void) result; gchar pe = NULL, path = NULL, line; int i=0; if(!argv_idx(argv, 0)) return; pe = parseenv(argv_idx(argv, 0)); if((path = find_existing_file(pe))) { GArray lines = read_file_by_line(path); while ((line = g_array_index(lines, gchar, i))) { parse_cmd_line (line, NULL); i++; g_free (line); } g_array_free (lines, TRUE); send_event(FILE_INCLUDED, path, NULL); g_free(path); } g_free(pe); } void act_dump_config() { dump_config(); } void act_dump_config_as_events() { dump_config_as_events(); } void load_uri (WebKitWebView web_view, GArray argv, GString result) { (void) web_view; (void) result; load_uri_imp (argv_idx (argv, 0)); } /* Javascript/ JSValueRef js_run_command (JSContextRef ctx, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef exception) { (void) function; (void) thisObject; (void) exception; JSStringRef js_result_string; GString result = g_string_new(""); if (argumentCount >= 1) { JSStringRef arg = JSValueToStringCopy(ctx, arguments[0], NULL); size_t arg_size = JSStringGetMaximumUTF8CStringSize(arg); char ctl_line[arg_size]; JSStringGetUTF8CString(arg, ctl_line, arg_size); parse_cmd_line(ctl_line, result); JSStringRelease(arg); } js_result_string = JSStringCreateWithUTF8CString(result->str); g_string_free(result, TRUE); return JSValueMakeString(ctx, js_result_string); } JSStaticFunction js_static_functions[] = { {"run", js_run_command, kJSPropertyAttributeNone}, }; void js_init() { / This function creates the class and its definition, only once / if (!uzbl.js.initialized) { / it would be pretty cool to make this dynamic / uzbl.js.classdef = kJSClassDefinitionEmpty; uzbl.js.classdef.staticFunctions = js_static_functions; uzbl.js.classref = JSClassCreate(&uzbl.js.classdef); } } void eval_js(WebKitWebView web_view, gchar script, GString result) { WebKitWebFrame frame; JSGlobalContextRef context; JSObjectRef globalobject; JSStringRef var_name; JSStringRef js_script; JSValueRef js_result; JSStringRef js_result_string; size_t js_result_size; js_init(); frame = webkit_web_view_get_main_frame(WEBKIT_WEB_VIEW(web_view)); context = webkit_web_frame_get_global_context(frame); globalobject = JSContextGetGlobalObject(context); / uzbl javascript namespace / var_name = JSStringCreateWithUTF8CString("Uzbl"); JSObjectSetProperty(context, globalobject, var_name, JSObjectMake(context, uzbl.js.classref, NULL), kJSClassAttributeNone, NULL); / evaluate the script and get return value/ js_script = JSStringCreateWithUTF8CString(script); js_result = JSEvaluateScript(context, js_script, globalobject, NULL, 0, NULL); if (js_result && !JSValueIsUndefined(context, js_result)) { js_result_string = JSValueToStringCopy(context, js_result, NULL); js_result_size = JSStringGetMaximumUTF8CStringSize(js_result_string); if (js_result_size) { char js_result_utf8[js_result_size]; JSStringGetUTF8CString(js_result_string, js_result_utf8, js_result_size); g_string_assign(result, js_result_utf8); } JSStringRelease(js_result_string); } / cleanup / JSObjectDeleteProperty(context, globalobject, var_name, NULL); JSStringRelease(var_name); JSStringRelease(js_script); } void run_js (WebKitWebView web_view, GArray argv, GString result) { if (argv_idx(argv, 0)) eval_js(web_view, argv_idx(argv, 0), result); } void run_external_js (WebKitWebView * web_view, GArray argv, GString result) { (void) result; gchar path = NULL; if (argv_idx(argv, 0) && ((path = find_existing_file(argv_idx(argv, 0)))) ) { GArray lines = read_file_by_line (path); gchar* js = NULL; int i = 0; gchar* line; while ((line = g_array_index(lines, gchar, i))) { if (js == NULL) { js = g_strdup (line); } else { gchar newjs = g_strconcat (js, line, NULL); js = newjs; } i ++; g_free (line); } if (uzbl.state.verbose) printf ("External JavaScript file %s loaded\n", argv_idx(argv, 0)); gchar* newjs = str_replace("%s", argv_idx (argv, 1)?argv_idx (argv, 1):"", js); g_free (js); js = newjs; eval_js (web_view, js, result); g_free (js); g_array_free (lines, TRUE); g_free(path); } } void search_text (WebKitWebView page, GArray argv, const gboolean forward) { if (argv_idx(argv, 0) && (argv_idx(argv, 0) != '\0')) { if (g_strcmp0 (uzbl.state.searchtx, argv_idx(argv, 0)) != 0) { webkit_web_view_unmark_text_matches (page); webkit_web_view_mark_text_matches (page, argv_idx(argv, 0), FALSE, 0); uzbl.state.searchtx = g_strdup(argv_idx(argv, 0)); } } if (uzbl.state.searchtx) { if (uzbl.state.verbose) printf ("Searching: %s\n", uzbl.state.searchtx); webkit_web_view_set_highlight_text_matches (page, TRUE); webkit_web_view_search_text (page, uzbl.state.searchtx, FALSE, forward, TRUE); } } void search_clear(WebKitWebView page, GArray argv, GString result) { (void) argv; (void) result; webkit_web_view_unmark_text_matches (page); if(uzbl.state.searchtx) { g_free(uzbl.state.searchtx); uzbl.state.searchtx = NULL; } } void search_forward_text (WebKitWebView page, GArray argv, GString result) { (void) result; search_text(page, argv, TRUE); } void search_reverse_text (WebKitWebView page, GArray argv, GString result) { (void) result; search_text(page, argv, FALSE); } void dehilight (WebKitWebView page, GArray argv, GString result) { (void) argv; (void) result; webkit_web_view_set_highlight_text_matches (page, FALSE); } void new_window_load_uri (const gchar uri) { if (uzbl.behave.new_window) { GString s = g_string_new (""); g_string_printf(s, "'%s'", uri); run_handler(uzbl.behave.new_window, s->str); send_event(NEW_WINDOW, s->str, NULL); return; } GString to_execute = g_string_new (""); g_string_append_printf (to_execute, "%s --uri '%s'", uzbl.state.executable_path, uri); int i; for (i = 0; entries[i].long_name != NULL; i++) { if ((entries[i].arg == G_OPTION_ARG_STRING) && !strcmp(entries[i].long_name,"uri") && !strcmp(entries[i].long_name,"name")) { gchar str = (gchar)entries[i].arg_data; if (str!=NULL) g_string_append_printf (to_execute, " --%s '%s'", entries[i].long_name, str); } else if(entries[i].arg == G_OPTION_ARG_STRING_ARRAY) { int j; gchar *str = ((gchar **)entries[i].arg_data); for(j=0; str[j]; j++) g_string_append_printf(to_execute, " --%s '%s'", entries[i].long_name, str[j]); } } if (uzbl.state.verbose) printf("\n%s\n", to_execute->str); g_spawn_command_line_async (to_execute->str, NULL); / TODO: should we just report the uri as event detail? / send_event(NEW_WINDOW, to_execute->str, NULL); g_string_free (to_execute, TRUE); } void chain (WebKitWebView page, GArray argv, GString result) { (void) page; (void) result; gchar a = NULL; gchar parts = NULL; guint i = 0; while ((a = argv_idx(argv, i++))) { parts = g_strsplit (a, " ", 2); if (parts[0]) parse_command(parts[0], parts[1], result); g_strfreev (parts); } } void close_uzbl (WebKitWebView page, GArray argv, GString result) { (void)page; (void)argv; (void)result; gtk_main_quit (); } void sharg_append(GArray a, const gchar str) { const gchar s = (str ? str : ""); g_array_append_val(a, s); } // make sure that the args string you pass can properly be interpreted (eg properly escaped against whitespace, quotes etc) gboolean run_command (const gchar command, const guint npre, const gchar args, const gboolean sync, char output_stdout) { //command <uzbl conf> <uzbl pid> <uzbl win id> <uzbl fifo file> <uzbl socket file> [args] GError err = NULL; GArray a = g_array_new (TRUE, FALSE, sizeof(gchar)); gchar pid = itos(getpid()); gchar xwin = itos(uzbl.xwin); guint i; sharg_append(a, command); for (i = 0; i < npre; i++) / add n args before the default vars / sharg_append(a, args[i]); sharg_append(a, uzbl.state.config_file); sharg_append(a, pid); sharg_append(a, xwin); sharg_append(a, uzbl.comm.fifo_path); sharg_append(a, uzbl.comm.socket_path); sharg_append(a, uzbl.state.uri); sharg_append(a, uzbl.gui.main_title); for (i = npre; i < g_strv_length((gchar)args); i++) sharg_append(a, args[i]); gboolean result; if (sync) { if (output_stdout) output_stdout = strfree(output_stdout); result = g_spawn_sync(NULL, (gchar )a->data, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, output_stdout, NULL, NULL, &err); } else result = g_spawn_async(NULL, (gchar )a->data, NULL, G_SPAWN_SEARCH_PATH, NULL, NULL, NULL, &err); if (uzbl.state.verbose) { GString s = g_string_new("spawned:"); for (i = 0; i < (a->len); i++) { gchar qarg = g_shell_quote(g_array_index(a, gchar, i)); g_string_append_printf(s, " %s", qarg); g_free (qarg); } g_string_append_printf(s, " -- result: %s", (result ? "true" : "false")); printf("%s\n", s->str); g_string_free(s, TRUE); if(output_stdout) { printf("Stdout: %s\n", output_stdout); } } if (err) { g_printerr("error on run_command: %s\n", err->message); g_error_free (err); } g_free (pid); g_free (xwin); g_array_free (a, TRUE); return result; } /@null@/ gchar** split_quoted(const gchar* src, const gboolean unquote) { /* split on unquoted space, return array of strings; remove a layer of quotes and backslashes if unquote / if (!src) return NULL; gboolean dq = FALSE; gboolean sq = FALSE; GArray a = g_array_new (TRUE, FALSE, sizeof(gchar)); GString s = g_string_new (""); const gchar p; gchar ret; gchar dup; for (p = src; p != '\0'; p++) { if ((p == '\\') && unquote) g_string_append_c(s, ++p); else if (p == '\\') { g_string_append_c(s, p++); g_string_append_c(s, p); } else if ((p == '"') && unquote && !sq) dq = !dq; else if (p == '"' && !sq) { g_string_append_c(s, p); dq = !dq; } else if ((p == '\'') && unquote && !dq) sq = !sq; else if (p == '\'' && !dq) { g_string_append_c(s, p); sq = ! sq; } else if ((p == ' ') && !dq && !sq) { dup = g_strdup(s->str); g_array_append_val(a, dup); g_string_truncate(s, 0); } else g_string_append_c(s, p); } dup = g_strdup(s->str); g_array_append_val(a, dup); ret = (gchar*)a->data; g_array_free (a, FALSE); g_string_free (s, TRUE); return ret; } void spawn(WebKitWebView web_view, GArray argv, GString result) { (void)web_view; (void)result; gchar path = NULL; //TODO: allow more control over argument order so that users can have some arguments before the default ones from run_command, and some after if (argv_idx(argv, 0) && ((path = find_existing_file(argv_idx(argv, 0)))) ) { run_command(path, 0, ((const gchar ) (argv->data + sizeof(gchar))), FALSE, NULL); g_free(path); } } void spawn_sync(WebKitWebView web_view, GArray argv, GString result) { (void)web_view; (void)result; gchar path = NULL; if (argv_idx(argv, 0) && ((path = find_existing_file(argv_idx(argv, 0)))) ) { run_command(path, 0, ((const gchar *) (argv->data + sizeof(gchar))), TRUE, &uzbl.comm.sync_stdout); g_free(path); } } void spawn_sh(WebKitWebView web_view, GArray argv, GString result) { (void)web_view; (void)result; if (!uzbl.behave.shell_cmd) { g_printerr ("spawn_sh: shell_cmd is not set!\n"); return; } guint i; gchar spacer = g_strdup(""); g_array_insert_val(argv, 1, spacer); gchar cmd = split_quoted(uzbl.behave.shell_cmd, TRUE); for (i = 1; i < g_strv_length(cmd); i++) g_array_prepend_val(argv, cmd[i]); if (cmd) run_command(cmd[0], g_strv_length(cmd) + 1, (const gchar ) argv->data, FALSE, NULL); g_free (spacer); g_strfreev (cmd); } void spawn_sh_sync(WebKitWebView web_view, GArray argv, GString result) { (void)web_view; (void)result; if (!uzbl.behave.shell_cmd) { g_printerr ("spawn_sh_sync: shell_cmd is not set!\n"); return; } guint i; gchar spacer = g_strdup(""); g_array_insert_val(argv, 1, spacer); gchar cmd = split_quoted(uzbl.behave.shell_cmd, TRUE); for (i = 1; i < g_strv_length(cmd); i++) g_array_prepend_val(argv, cmd[i]); if (cmd) run_command(cmd[0], g_strv_length(cmd) + 1, (const gchar ) argv->data, TRUE, &uzbl.comm.sync_stdout); g_free (spacer); g_strfreev (cmd); } void talk_to_socket(WebKitWebView web_view, GArray argv, GString result) { (void)web_view; (void)result; int fd, len; struct sockaddr_un sa; char sockpath; ssize_t ret; struct pollfd pfd; struct iovec* iov; guint i; if(uzbl.comm.sync_stdout) uzbl.comm.sync_stdout = strfree(uzbl.comm.sync_stdout); /* This function could be optimised by storing a hash table of socket paths and associated connected file descriptors rather than closing and re-opening for every call. Also we could launch a script if socket connect fails. / / First element argv[0] is path to socket. Following elements are tokens to write to the socket. We write them as a single packet with each token separated by an ASCII nul (\0). / if(argv->len < 2) { g_printerr("talk_to_socket called with only %d args (need at least two).\n", (int)argv->len); return; } / copy socket path, null terminate result / sockpath = g_array_index(argv, char, 0); g_strlcpy(sa.sun_path, sockpath, sizeof(sa.sun_path)); sa.sun_family = AF_UNIX; /* create socket file descriptor and connect it to path / fd = socket(AF_UNIX, SOCK_SEQPACKET, 0); if(fd == -1) { g_printerr("talk_to_socket: creating socket failed (%s)\n", strerror(errno)); return; } if(connect(fd, (struct sockaddr)&sa, sizeof(sa))) { g_printerr("talk_to_socket: connect failed (%s)\n", strerror(errno)); close(fd); return; } /* build request vector / iov = g_malloc(sizeof(struct iovec) (argv->len - 1)); if(!iov) { g_printerr("talk_to_socket: unable to allocated memory for token vector\n"); close(fd); return; } for(i = 1; i < argv->len; ++i) { iov[i - 1].iov_base = g_array_index(argv, char, i); iov[i - 1].iov_len = strlen(iov[i - 1].iov_base) + 1; / string plus \0 / } / write request / ret = writev(fd, iov, argv->len - 1); g_free(iov); if(ret == -1) { g_printerr("talk_to_socket: write failed (%s)\n", strerror(errno)); close(fd); return; } / wait for a response, with a 500ms timeout / pfd.fd = fd; pfd.events = POLLIN; while(1) { ret = poll(&pfd, 1, 500); if(ret == 1) break; if(ret == 0) errno = ETIMEDOUT; if(errno == EINTR) continue; g_printerr("talk_to_socket: poll failed while waiting for input (%s)\n", strerror(errno)); close(fd); return; } / get length of response / if(ioctl(fd, FIONREAD, &len) == -1) { g_printerr("talk_to_socket: cannot find daemon response length, " "ioctl failed (%s)\n", strerror(errno)); close(fd); return; } / if there is a response, read it / if(len) { uzbl.comm.sync_stdout = g_malloc(len + 1); if(!uzbl.comm.sync_stdout) { g_printerr("talk_to_socket: failed to allocate %d bytes\n", len); close(fd); return; } uzbl.comm.sync_stdout[len] = 0; / ensure result is null terminated / ret = read(fd, uzbl.comm.sync_stdout, len); if(ret == -1) { g_printerr("talk_to_socket: failed to read from socket (%s)\n", strerror(errno)); close(fd); return; } } / clean up / close(fd); return; } void parse_command(const char cmd, const char param, GString result) { CommandInfo c; GString tmp = g_string_new(""); if ((c = g_hash_table_lookup(uzbl.behave.commands, cmd))) { guint i; gchar *par = split_quoted(param, TRUE); GArray a = g_array_new (TRUE, FALSE, sizeof(gchar)); if (c->no_split) { / don't split / sharg_append(a, param); } else if (par) { for (i = 0; i < g_strv_length(par); i++) sharg_append(a, par[i]); } if (result == NULL) { GString result_print = g_string_new(""); c->function(uzbl.gui.web_view, a, result_print); if (result_print->len) printf("%s\n", (int)result_print->len, result_print->str); g_string_free(result_print, TRUE); } else { c->function(uzbl.gui.web_view, a, result); } g_strfreev (par); g_array_free (a, TRUE); if(strcmp("set", cmd) && strcmp("event", cmd) && strcmp("request", cmd)) { g_string_printf(tmp, "%s %s", cmd, param?param:""); send_event(COMMAND_EXECUTED, tmp->str, NULL); g_string_free(tmp, TRUE); } } else { gchar tmp = g_strdup_printf("%s %s", cmd, param?param:""); send_event(COMMAND_ERROR, tmp, NULL); g_free(tmp); } } void move_statusbar() { if (!uzbl.gui.scrolled_win && !uzbl.gui.mainbar) return; g_object_ref(uzbl.gui.scrolled_win); g_object_ref(uzbl.gui.mainbar); gtk_container_remove(GTK_CONTAINER(uzbl.gui.vbox), uzbl.gui.scrolled_win); gtk_container_remove(GTK_CONTAINER(uzbl.gui.vbox), uzbl.gui.mainbar); if(uzbl.behave.status_top) { gtk_box_pack_start (GTK_BOX (uzbl.gui.vbox), uzbl.gui.mainbar, FALSE, TRUE, 0); gtk_box_pack_start (GTK_BOX (uzbl.gui.vbox), uzbl.gui.scrolled_win, TRUE, TRUE, 0); } else { gtk_box_pack_start (GTK_BOX (uzbl.gui.vbox), uzbl.gui.scrolled_win, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (uzbl.gui.vbox), uzbl.gui.mainbar, FALSE, TRUE, 0); } g_object_unref(uzbl.gui.scrolled_win); g_object_unref(uzbl.gui.mainbar); gtk_widget_grab_focus (GTK_WIDGET (uzbl.gui.web_view)); return; } gboolean set_var_value(const gchar name, gchar val) { uzbl_cmdprop c = NULL; char endp = NULL; char buf = NULL; char invalid_chars = "^°!\"§$%&/()=?'`'+~'#-.:,;@<>\| \\{}[]¹²³¼½"; GString msg; if( (c = g_hash_table_lookup(uzbl.comm.proto_var, name)) ) { if(!c->writeable) return FALSE; msg = g_string_new(name); /* check for the variable type / if (c->type == TYPE_STR) { buf = g_strdup(val); g_free(c->ptr.s); c->ptr.s = buf; g_string_append_printf(msg, " str %s", buf); } else if(c->type == TYPE_INT) { c->ptr.i = (int)strtoul(val, &endp, 10); g_string_append_printf(msg, " int %d", c->ptr.i); } else if (c->type == TYPE_FLOAT) { c->ptr.f = strtod(val, &endp); g_string_append_printf(msg, " float %f", c->ptr.f); } send_event(VARIABLE_SET, msg->str, NULL); g_string_free(msg,TRUE); / invoke a command specific function / if(c->func) c->func(); } else { / check wether name violates our naming scheme / if(strpbrk(name, invalid_chars)) { if (uzbl.state.verbose) printf("Invalid variable name\n"); return FALSE; } / custom vars / c = g_malloc(sizeof(uzbl_cmdprop)); c->type = TYPE_STR; c->dump = 0; c->func = NULL; c->writeable = 1; buf = g_strdup(val); c->ptr.s = g_malloc(sizeof(char )); c->ptr.s = buf; g_hash_table_insert(uzbl.comm.proto_var, g_strdup(name), (gpointer) c); msg = g_string_new(name); g_string_append_printf(msg, " str %s", buf); send_event(VARIABLE_SET, msg->str, NULL); g_string_free(msg,TRUE); } update_title(); return TRUE; } void parse_cmd_line(const char ctl_line, GString result) { size_t len=0; gchar ctlstrip = NULL; gchar exp_line = NULL; gchar work_string = NULL; work_string = g_strdup(ctl_line); /* strip trailing newline / len = strlen(ctl_line); if (work_string[len - 1] == '\n') ctlstrip = g_strndup(work_string, len - 1); else ctlstrip = g_strdup(work_string); g_free(work_string); if( strcmp(g_strchug(ctlstrip), "") && strcmp(exp_line = expand(ctlstrip, 0), "") ) { / ignore comments / if((exp_line[0] == '#')) ; / parse a command / else { gchar tokens = NULL; tokens = g_strsplit(exp_line, " ", 2); parse_command(tokens[0], tokens[1], result); g_strfreev(tokens); } g_free(exp_line); } g_free(ctlstrip); } /@null@/ gchar build_stream_name(int type, const gchar* dir) { State s = &uzbl.state; gchar str = NULL; if (type == FIFO) { str = g_strdup_printf ("%s/uzbl_fifo_%s", dir, s->instance_name); } else if (type == SOCKET) { str = g_strdup_printf ("%s/uzbl_socket_%s", dir, s->instance_name); } return str; } gboolean control_fifo(GIOChannel gio, GIOCondition condition) { if (uzbl.state.verbose) printf("triggered\n"); gchar ctl_line; GIOStatus ret; GError err = NULL; if (condition & G_IO_HUP) g_error ("Fifo: Read end of pipe died!\n"); if(!gio) g_error ("Fifo: GIOChannel broke\n"); ret = g_io_channel_read_line(gio, &ctl_line, NULL, NULL, &err); if (ret == G_IO_STATUS_ERROR) { g_error ("Fifo: Error reading: %s\n", err->message); g_error_free (err); } parse_cmd_line(ctl_line, NULL); g_free(ctl_line); return TRUE; } /@null@/ gchar init_fifo(gchar dir) { / return dir or, on error, free dir and return NULL / if (uzbl.comm.fifo_path) { / get rid of the old fifo if one exists / if (unlink(uzbl.comm.fifo_path) == -1) g_warning ("Fifo: Can't unlink old fifo at %s\n", uzbl.comm.fifo_path); g_free(uzbl.comm.fifo_path); uzbl.comm.fifo_path = NULL; } GIOChannel chan = NULL; GError error = NULL; gchar path = build_stream_name(FIFO, dir); if (!file_exists(path)) { if (mkfifo (path, 0666) == 0) { // we don't really need to write to the file, but if we open the file as 'r' we will block here, waiting for a writer to open the file. chan = g_io_channel_new_file(path, "r+", &error); if (chan) { if (g_io_add_watch(chan, G_IO_IN\|G_IO_HUP, (GIOFunc) control_fifo, NULL)) { if (uzbl.state.verbose) printf ("init_fifo: created successfully as %s\n", path); send_event(FIFO_SET, path, NULL); uzbl.comm.fifo_path = path; return dir; } else g_warning ("init_fifo: could not add watch on %s\n", path); } else g_warning ("init_fifo: can't open: %s\n", error->message); } else g_warning ("init_fifo: can't create %s: %s\n", path, strerror(errno)); } else g_warning ("init_fifo: can't create %s: file exists\n", path); /* if we got this far, there was an error; cleanup / if (error) g_error_free (error); g_free(dir); g_free(path); return NULL; } gboolean control_stdin(GIOChannel gio, GIOCondition condition) { (void) condition; gchar ctl_line = NULL; GIOStatus ret; ret = g_io_channel_read_line(gio, &ctl_line, NULL, NULL, NULL); if ( (ret == G_IO_STATUS_ERROR) \|\| (ret == G_IO_STATUS_EOF) ) return FALSE; parse_cmd_line(ctl_line, NULL); g_free(ctl_line); return TRUE; } void create_stdin () { GIOChannel chan = NULL; GError error = NULL; chan = g_io_channel_unix_new(fileno(stdin)); if (chan) { if (!g_io_add_watch(chan, G_IO_IN\|G_IO_HUP, (GIOFunc) control_stdin, NULL)) { g_error ("Stdin: could not add watch\n"); } else { if (uzbl.state.verbose) printf ("Stdin: watch added successfully\n"); } } else { g_error ("Stdin: Error while opening: %s\n", error->message); } if (error) g_error_free (error); } gboolean remove_socket_from_array(GIOChannel chan) { gboolean ret = 0; /* TODO: Do wee need to manually free the IO channel or is this * happening implicitly on unref? / ret = g_ptr_array_remove_fast(uzbl.comm.connect_chan, chan); if(!ret) ret = g_ptr_array_remove_fast(uzbl.comm.client_chan, chan); return ret; } gboolean control_socket(GIOChannel chan) { struct sockaddr_un remote; unsigned int t = sizeof(remote); GIOChannel iochan; int clientsock; clientsock = accept (g_io_channel_unix_get_fd(chan), (struct sockaddr ) &remote, &t); if(!uzbl.comm.client_chan) uzbl.comm.client_chan = g_ptr_array_new(); if ((iochan = g_io_channel_unix_new(clientsock))) { g_io_channel_set_encoding(iochan, NULL, NULL); g_io_add_watch(iochan, G_IO_IN\|G_IO_HUP, (GIOFunc) control_client_socket, iochan); g_ptr_array_add(uzbl.comm.client_chan, (gpointer)iochan); } return TRUE; } void init_connect_socket() { int sockfd, replay = 0; struct sockaddr_un local; GIOChannel chan; gchar name = NULL; if(!uzbl.comm.connect_chan) uzbl.comm.connect_chan = g_ptr_array_new(); name = uzbl.state.connect_socket_names; while(name && name) { sockfd = socket (AF_UNIX, SOCK_STREAM, 0); local.sun_family = AF_UNIX; strcpy (local.sun_path, name); if(!connect(sockfd, (struct sockaddr ) &local, sizeof(local))) { if ((chan = g_io_channel_unix_new(sockfd))) { g_io_channel_set_encoding(chan, NULL, NULL); g_io_add_watch(chan, G_IO_IN\|G_IO_HUP, (GIOFunc) control_client_socket, chan); g_ptr_array_add(uzbl.comm.connect_chan, (gpointer)chan); replay++; } } else g_warning("Error connecting to socket: %s\n", name); name++; } / replay buffered events / if(replay) send_event_socket(NULL); } gboolean control_client_socket(GIOChannel clientchan) { char ctl_line; GString result = g_string_new(""); GError error = NULL; GIOStatus ret; gsize len; ret = g_io_channel_read_line(clientchan, &ctl_line, &len, NULL, &error); if (ret == G_IO_STATUS_ERROR) { g_warning ("Error reading: %s\n", error->message); remove_socket_from_array(clientchan); g_io_channel_shutdown(clientchan, TRUE, &error); return FALSE; } else if (ret == G_IO_STATUS_EOF) { remove_socket_from_array(clientchan); / shutdown and remove channel watch from main loop / g_io_channel_shutdown(clientchan, TRUE, &error); return FALSE; } if (ctl_line) { parse_cmd_line (ctl_line, result); g_string_append_c(result, '\n'); ret = g_io_channel_write_chars (clientchan, result->str, result->len, &len, &error); if (ret == G_IO_STATUS_ERROR) { g_warning ("Error writing: %s", error->message); } g_io_channel_flush(clientchan, &error); } if (error) g_error_free (error); g_string_free(result, TRUE); g_free(ctl_line); return TRUE; } /@null@/ gchar init_socket(gchar dir) { / return dir or, on error, free dir and return NULL / if (uzbl.comm.socket_path) { / remove an existing socket should one exist / if (unlink(uzbl.comm.socket_path) == -1) g_warning ("init_socket: couldn't unlink socket at %s\n", uzbl.comm.socket_path); g_free(uzbl.comm.socket_path); uzbl.comm.socket_path = NULL; } if (dir == ' ') { g_free(dir); return NULL; } GIOChannel chan = NULL; int sock, len; struct sockaddr_un local; gchar path = build_stream_name(SOCKET, dir); sock = socket (AF_UNIX, SOCK_STREAM, 0); local.sun_family = AF_UNIX; strcpy (local.sun_path, path); unlink (local.sun_path); len = strlen (local.sun_path) + sizeof (local.sun_family); if (bind (sock, (struct sockaddr ) &local, len) != -1) { if (uzbl.state.verbose) printf ("init_socket: opened in %s\n", path); listen (sock, 5); if( (chan = g_io_channel_unix_new(sock)) ) { g_io_add_watch(chan, G_IO_IN\|G_IO_HUP, (GIOFunc) control_socket, chan); uzbl.comm.socket_path = path; send_event(SOCKET_SET, path, NULL); return dir; } } else g_warning ("init_socket: could not open in %s: %s\n", path, strerror(errno)); / if we got this far, there was an error; cleanup / g_free(path); g_free(dir); return NULL; } / NOTE: we want to keep variables like b->title_format_long in their "unprocessed" state it will probably improve performance if we would "cache" the processed variant, but for now it works well enough... / // this function may be called very early when the templates are not set (yet), hence the checks void update_title (void) { Behaviour b = &uzbl.behave; gchar parsed; if (b->show_status) { if (b->title_format_short) { parsed = expand(b->title_format_short, 0); if (uzbl.gui.main_window) gtk_window_set_title (GTK_WINDOW(uzbl.gui.main_window), parsed); g_free(parsed); } if (b->status_format) { parsed = expand(b->status_format, 0); gtk_label_set_markup(GTK_LABEL(uzbl.gui.mainbar_label), parsed); g_free(parsed); } if (b->status_background) { GdkColor color; gdk_color_parse (b->status_background, &color); //labels and hboxes do not draw their own background. applying this on the vbox/main_window is ok as the statusbar is the only affected widget. (if not, we could also use GtkEventBox) if (uzbl.gui.main_window) gtk_widget_modify_bg (uzbl.gui.main_window, GTK_STATE_NORMAL, &color); else if (uzbl.gui.plug) gtk_widget_modify_bg (GTK_WIDGET(uzbl.gui.plug), GTK_STATE_NORMAL, &color); } } else { if (b->title_format_long) { parsed = expand(b->title_format_long, 0); if (uzbl.gui.main_window) gtk_window_set_title (GTK_WINDOW(uzbl.gui.main_window), parsed); g_free(parsed); } } } void create_browser () { GUI g = &uzbl.gui; g->web_view = WEBKIT_WEB_VIEW (webkit_web_view_new ()); g_object_connect((GObject)g->web_view, "signal::key-press-event", (GCallback)key_press_cb, NULL, "signal::key-release-event", (GCallback)key_release_cb, NULL, "signal::button-press-event", (GCallback)button_press_cb, NULL, "signal::button-release-event", (GCallback)button_release_cb, NULL, "signal::title-changed", (GCallback)title_change_cb, NULL, "signal::selection-changed", (GCallback)selection_changed_cb, NULL, "signal::load-progress-changed", (GCallback)progress_change_cb, NULL, "signal::load-committed", (GCallback)load_commit_cb, NULL, "signal::load-started", (GCallback)load_start_cb, NULL, "signal::load-finished", (GCallback)load_finish_cb, NULL, "signal::load-error", (GCallback)load_error_cb, NULL, "signal::hovering-over-link", (GCallback)link_hover_cb, NULL, "signal::navigation-policy-decision-requested", (GCallback)navigation_decision_cb, NULL, "signal::new-window-policy-decision-requested", (GCallback)new_window_cb, NULL, "signal::download-requested", (GCallback)download_cb, NULL, "signal::create-web-view", (GCallback)create_web_view_cb, NULL, "signal::mime-type-policy-decision-requested", (GCallback)mime_policy_cb, NULL, "signal::populate-popup", (GCallback)populate_popup_cb, NULL, "signal::focus-in-event", (GCallback)focus_cb, NULL, "signal::focus-out-event", (GCallback)focus_cb, NULL, NULL); } GtkWidget create_mainbar () { GUI g = &uzbl.gui; g->mainbar = gtk_hbox_new (FALSE, 0); g->mainbar_label = gtk_label_new (""); gtk_label_set_selectable((GtkLabel )g->mainbar_label, TRUE); gtk_label_set_ellipsize(GTK_LABEL(g->mainbar_label), PANGO_ELLIPSIZE_END); gtk_misc_set_alignment (GTK_MISC(g->mainbar_label), 0, 0); gtk_misc_set_padding (GTK_MISC(g->mainbar_label), 2, 2); gtk_box_pack_start (GTK_BOX (g->mainbar), g->mainbar_label, TRUE, TRUE, 0); g_object_connect((GObject)g->mainbar, "signal::key-press-event", (GCallback)key_press_cb, NULL, "signal::key-release-event", (GCallback)key_release_cb, NULL, NULL); return g->mainbar; } GtkWidget create_window () { GtkWidget* window = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_default_size (GTK_WINDOW (window), 800, 600); gtk_widget_set_name (window, "Uzbl browser"); g_signal_connect (G_OBJECT (window), "destroy", G_CALLBACK (destroy_cb), NULL); g_signal_connect (G_OBJECT (window), "configure-event", G_CALLBACK (configure_event_cb), NULL); return window; } GtkPlug* create_plug () { GtkPlug* plug = GTK_PLUG (gtk_plug_new (uzbl.state.socket_id)); g_signal_connect (G_OBJECT (plug), "destroy", G_CALLBACK (destroy_cb), NULL); g_signal_connect (G_OBJECT (plug), "key-press-event", G_CALLBACK (key_press_cb), NULL); g_signal_connect (G_OBJECT (plug), "key-release-event", G_CALLBACK (key_release_cb), NULL); return plug; } gchar** inject_handler_args(const gchar actname, const gchar origargs, const gchar newargs) { / If actname is one that calls an external command, this function will inject newargs in front of the user-provided args in that command line. They will come become after the body of the script (in sh) or after the name of the command to execute (in spawn). i.e. sh <body> <userargs> becomes sh <body> <ARGS> <userargs> and spawn <command> <userargs> becomes spawn <command> <ARGS> <userargs>. The return value consist of two strings: the action (sh, ...) and its args. If act is not one that calls an external command, then the given action merely gets duplicated. / GArray rets = g_array_new(TRUE, FALSE, sizeof(gchar)); / Arrr! Here be memory leaks / gchar actdup = g_strdup(actname); g_array_append_val(rets, actdup); if ((g_strcmp0(actname, "spawn") == 0) \|\| (g_strcmp0(actname, "sh") == 0) \|\| (g_strcmp0(actname, "sync_spawn") == 0) \|\| (g_strcmp0(actname, "sync_sh") == 0) \|\| (g_strcmp0(actname, "talk_to_socket") == 0)) { guint i; GString a = g_string_new(""); gchar spawnparts = split_quoted(origargs, FALSE); g_string_append_printf(a, "%s", spawnparts[0]); / sh body or script name / if (newargs) g_string_append_printf(a, " %s", newargs); / handler args / for (i = 1; i < g_strv_length(spawnparts); i++) / user args / if (spawnparts[i]) g_string_append_printf(a, " %s", spawnparts[i]); g_array_append_val(rets, a->str); g_string_free(a, FALSE); g_strfreev(spawnparts); } else { gchar origdup = g_strdup(origargs); g_array_append_val(rets, origdup); } return (gchar*)g_array_free(rets, FALSE); } void run_handler (const gchar act, const gchar args) { / Consider this code a temporary hack to make the handlers usable. In practice, all this splicing, injection, and reconstruction is inefficient, annoying and hard to manage. Potential pitfalls arise when the handler specific args 1) are not quoted (the handler callbacks should take care of this) 2) are quoted but interfere with the users' own quotation. A more ideal solution is to refactor parse_command so that it doesn't just take a string and execute it; rather than that, we should have a function which returns the argument vector parsed from the string. This vector could be modified (e.g. insert additional args into it) before passing it to the next function that actually executes it. Though it still isn't perfect for chain actions.. will reconsider & re- factor when I have the time. -duc / if (!act) return; char parts = g_strsplit(act, " ", 2); if (!parts \|\| !parts[0]) return; if (g_strcmp0(parts[0], "chain") == 0) { GString newargs = g_string_new(""); gchar *chainparts = split_quoted(parts[1], FALSE); / for every argument in the chain, inject the handler args and make sure the new parts are wrapped in quotes / gchar cp = chainparts; gchar quot = '\''; gchar quotless = NULL; gchar spliced_quotless = NULL; // sigh -_-; gchar inpart = NULL; while (cp) { if ((cp == '\'') \|\| (cp == '\"')) { / strip old quotes / quot = cp; quotless = g_strndup(&(cp)[1], strlen(cp) - 2); } else quotless = g_strdup(cp); spliced_quotless = g_strsplit(quotless, " ", 2); inpart = inject_handler_args(spliced_quotless[0], spliced_quotless[1], args); g_strfreev(spliced_quotless); g_string_append_printf(newargs, " %c%s %s%c", quot, inpart[0], inpart[1], quot); g_free(quotless); g_strfreev(inpart); cp++; } parse_command(parts[0], &(newargs->str[1]), NULL); g_string_free(newargs, TRUE); g_strfreev(chainparts); } else { gchar *inparts; gchar inparts_[2]; if (parts[1]) { /* expand the user-specified arguments / gchar expanded = expand(parts[1], 0); inparts = inject_handler_args(parts[0], expanded, args); g_free(expanded); } else { inparts_[0] = parts[0]; inparts_[1] = g_strdup(args); inparts = inparts_; } parse_command(inparts[0], inparts[1], NULL); if (inparts != inparts_) { g_free(inparts[0]); g_free(inparts[1]); } else g_free(inparts[1]); } g_strfreev(parts); } /@null@/ gchar* get_xdg_var (XDG_Var xdg) { const gchar* actual_value = getenv (xdg.environmental); const gchar* home = getenv ("HOME"); gchar* return_value; if (! actual_value \|\| strcmp (actual_value, "") == 0) { if (xdg.default_value) { return_value = str_replace ("~", home, xdg.default_value); } else { return_value = NULL; } } else { return_value = str_replace("~", home, actual_value); } return return_value; } /@null@/ gchar* find_xdg_file (int xdg_type, const char* filename) { /* xdg_type = 0 => config xdg_type = 1 => data xdg_type = 2 => cache/ gchar xdgv = get_xdg_var (XDG[xdg_type]); gchar* temporary_file = g_strconcat (xdgv, filename, NULL); g_free (xdgv); gchar* temporary_string; char* saveptr; char* buf; if (! file_exists (temporary_file) && xdg_type != 2) { buf = get_xdg_var (XDG[3 + xdg_type]); temporary_string = (char ) strtok_r (buf, ":", &saveptr); g_free(buf); while ((temporary_string = (char ) strtok_r (NULL, ":", &saveptr)) && ! file_exists (temporary_file)) { g_free (temporary_file); temporary_file = g_strconcat (temporary_string, filename, NULL); } } //g_free (temporary_string); - segfaults. if (file_exists (temporary_file)) { return temporary_file; } else { g_free(temporary_file); return NULL; } } void settings_init () { State s = &uzbl.state; Network n = &uzbl.net; int i; for (i = 0; default_config[i].command != NULL; i++) { parse_cmd_line(default_config[i].command, NULL); } if (g_strcmp0(s->config_file, "-") == 0) { s->config_file = NULL; create_stdin(); } else if (!s->config_file) { s->config_file = find_xdg_file (0, "/uzbl/config"); } if (s->config_file) { GArray* lines = read_file_by_line (s->config_file); int i = 0; gchar* line; while ((line = g_array_index(lines, gchar, i))) { parse_cmd_line (line, NULL); i ++; g_free (line); } g_array_free (lines, TRUE); } else { if (uzbl.state.verbose) printf ("No configuration file loaded.\n"); } if(s->connect_socket_names) init_connect_socket(); g_signal_connect_after(n->soup_session, "request-started", G_CALLBACK(handle_cookies), NULL); } void handle_cookies (SoupSession session, SoupMessage msg, gpointer user_data){ (void) session; (void) user_data; //if (!uzbl.behave.cookie_handler) // return; soup_message_add_header_handler(msg, "got-headers", "Set-Cookie", G_CALLBACK(save_cookies), NULL); GString s = g_string_new (""); SoupURI * soup_uri = soup_message_get_uri(msg); g_string_printf(s, "GET '%s' '%s' '%s'", soup_uri->scheme, soup_uri->host, soup_uri->path); if(uzbl.behave.cookie_handler) run_handler(uzbl.behave.cookie_handler, s->str); if(uzbl.behave.cookie_handler && uzbl.comm.sync_stdout && strcmp (uzbl.comm.sync_stdout, "") != 0) { char p = strchr(uzbl.comm.sync_stdout, '\n' ); if ( p != NULL ) p = '\0'; soup_message_headers_replace (msg->request_headers, "Cookie", (const char ) uzbl.comm.sync_stdout); } if (uzbl.comm.sync_stdout) uzbl.comm.sync_stdout = strfree(uzbl.comm.sync_stdout); g_string_free(s, TRUE); } void save_cookies (SoupMessage msg, gpointer user_data){ (void) user_data; GSList ck; char cookie; for (ck = soup_cookies_from_response(msg); ck; ck = ck->next){ cookie = soup_cookie_to_set_cookie_header(ck->data); SoupURI * soup_uri = soup_message_get_uri(msg); GString s = g_string_new (""); g_string_printf(s, "PUT '%s' '%s' '%s' '%s'", soup_uri->scheme, soup_uri->host, soup_uri->path, cookie); run_handler(uzbl.behave.cookie_handler, s->str); g_free (cookie); g_string_free(s, TRUE); } g_slist_free(ck); } void dump_var_hash(gpointer k, gpointer v, gpointer ud) { (void) ud; uzbl_cmdprop c = v; if(!c->dump) return; if(c->type == TYPE_STR) printf("set %s = %s\n", (char )k, c->ptr.s ? c->ptr.s : " "); else if(c->type == TYPE_INT) printf("set %s = %d\n", (char )k, c->ptr.i); else if(c->type == TYPE_FLOAT) printf("set %s = %f\n", (char )k, c->ptr.f); } void dump_config() { g_hash_table_foreach(uzbl.comm.proto_var, dump_var_hash, NULL); } void dump_var_hash_as_event(gpointer k, gpointer v, gpointer ud) { (void) ud; uzbl_cmdprop c = v; GString msg; if(!c->dump) return; / check for the variable type / msg = g_string_new((char )k); if (c->type == TYPE_STR) { g_string_append_printf(msg, " str %s", c->ptr.s ? c->ptr.s : " "); } else if(c->type == TYPE_INT) { g_string_append_printf(msg, " int %d", c->ptr.i); } else if (c->type == TYPE_FLOAT) { g_string_append_printf(msg, " float %f", c->ptr.f); } send_event(VARIABLE_SET, msg->str, NULL); g_string_free(msg, TRUE); } void dump_config_as_events() { g_hash_table_foreach(uzbl.comm.proto_var, dump_var_hash_as_event, NULL); } void retrieve_geometry() { int w, h, x, y; GString buf = g_string_new(""); gtk_window_get_size(GTK_WINDOW(uzbl.gui.main_window), &w, &h); gtk_window_get_position(GTK_WINDOW(uzbl.gui.main_window), &x, &y); g_string_printf(buf, "%dx%d+%d+%d", w, h, x, y); if(uzbl.gui.geometry) g_free(uzbl.gui.geometry); uzbl.gui.geometry = g_string_free(buf, FALSE); } / set up gtk, gobject, variable defaults and other things that tests and other * external applications need to do anyhow / void initialize(int argc, char argv[]) { int i; for(i=0; i<argc; ++i) { if(!strcmp(argv[i], "-s") \|\| !strcmp(argv[i], "--socket")) { uzbl.state.plug_mode = TRUE; break; } } if (!g_thread_supported ()) g_thread_init (NULL); gtk_init (&argc, &argv); uzbl.state.executable_path = g_strdup(argv[0]); uzbl.state.selected_url = NULL; uzbl.state.searchtx = NULL; GOptionContext* context = g_option_context_new ("[ uri ] - load a uri by default"); g_option_context_add_main_entries (context, entries, NULL); g_option_context_add_group (context, gtk_get_option_group (TRUE)); g_option_context_parse (context, &argc, &argv, NULL); g_option_context_free(context); if (uzbl.behave.print_version) { printf("Commit: %s\n", COMMIT); exit(EXIT_SUCCESS); } uzbl.net.soup_session = webkit_get_default_session(); uzbl.state.keycmd = g_strdup(""); for(i=0; sigs[i]; i++) { if(setup_signal(sigs[i], catch_signal) == SIG_ERR) fprintf(stderr, "uzbl: error hooking %d: %s\n", sigs[i], strerror(errno)); } event_buffer_timeout(10); uzbl.info.webkit_major = WEBKIT_MAJOR_VERSION; uzbl.info.webkit_minor = WEBKIT_MINOR_VERSION; uzbl.info.webkit_micro = WEBKIT_MICRO_VERSION; uzbl.info.arch = ARCH; uzbl.info.commit = COMMIT; commands_hash (); create_var_to_name_hash(); create_mainbar(); create_browser(); } void load_uri_imp(gchar uri) { GString newuri; if (g_strstr_len (uri, 11, "javascript:") != NULL) { eval_js(uzbl.gui.web_view, uri, NULL); return; } newuri = g_string_new (uri); if (!soup_uri_new(uri)) { GString* fullpath = g_string_new (""); if (g_path_is_absolute (newuri->str)) g_string_assign (fullpath, newuri->str); else { gchar* wd; wd = g_get_current_dir (); g_string_assign (fullpath, g_build_filename (wd, newuri->str, NULL)); free(wd); } struct stat stat_result; if (! g_stat(fullpath->str, &stat_result)) { g_string_prepend (fullpath, "file://"); g_string_assign (newuri, fullpath->str); } else g_string_prepend (newuri, "http://"); g_string_free (fullpath, TRUE); } /* if we do handle cookies, ask our handler for them / webkit_web_view_load_uri (uzbl.gui.web_view, newuri->str); g_string_free (newuri, TRUE); } #ifndef UZBL_LIBRARY /* -- MAIN -- */ int main (int argc, char argv[]) { initialize(argc, argv); uzbl.gui.scrolled_win = gtk_scrolled_window_new (NULL, NULL); gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (uzbl.gui.scrolled_win), GTK_POLICY_NEVER, GTK_POLICY_NEVER); gtk_container_add (GTK_CONTAINER (uzbl.gui.scrolled_win), GTK_WIDGET (uzbl.gui.web_view)); uzbl.gui.vbox = gtk_vbox_new (FALSE, 0); /* initial packing / gtk_box_pack_start (GTK_BOX (uzbl.gui.vbox), uzbl.gui.scrolled_win, TRUE, TRUE, 0); gtk_box_pack_start (GTK_BOX (uzbl.gui.vbox), uzbl.gui.mainbar, FALSE, TRUE, 0); if (uzbl.state.plug_mode) { uzbl.gui.plug = create_plug (); gtk_container_add (GTK_CONTAINER (uzbl.gui.plug), uzbl.gui.vbox); gtk_widget_show_all (GTK_WIDGET (uzbl.gui.plug)); / in xembed mode the window has no unique id and thus * socket/fifo names aren't unique either. * we use a custom randomizer to create a random id / struct timeval tv; gettimeofday(&tv, NULL); srand((unsigned int)tv.tv_sectv.tv_usec); uzbl.xwin = rand(); } else { uzbl.gui.main_window = create_window (); gtk_container_add (GTK_CONTAINER (uzbl.gui.main_window), uzbl.gui.vbox); gtk_widget_show_all (uzbl.gui.main_window); uzbl.xwin = GDK_WINDOW_XID (GTK_WIDGET (uzbl.gui.main_window)->window); } uzbl.gui.scbar_v = (GtkScrollbar) gtk_vscrollbar_new (NULL); uzbl.gui.bar_v = gtk_range_get_adjustment((GtkRange) uzbl.gui.scbar_v); uzbl.gui.scbar_h = (GtkScrollbar) gtk_hscrollbar_new (NULL); uzbl.gui.bar_h = gtk_range_get_adjustment((GtkRange) uzbl.gui.scbar_h); gtk_widget_set_scroll_adjustments ((GtkWidget) uzbl.gui.web_view, uzbl.gui.bar_h, uzbl.gui.bar_v); if(!uzbl.state.instance_name) uzbl.state.instance_name = itos((int)uzbl.xwin); GString tmp = g_string_new(""); g_string_printf(tmp, "%d", getpid()); uzbl.info.pid_str = g_string_free(tmp, FALSE); send_event(INSTANCE_START, uzbl.info.pid_str, NULL); if(uzbl.state.plug_mode) { char t = itos(gtk_plug_get_id(uzbl.gui.plug)); send_event(PLUG_CREATED, t, NULL); g_free(t); } / generate an event with a list of built in commands / builtins(); gtk_widget_grab_focus (GTK_WIDGET (uzbl.gui.web_view)); if (uzbl.state.verbose) { printf("Uzbl start location: %s\n", argv[0]); if (uzbl.state.socket_id) printf("plug_id %i\n", gtk_plug_get_id(uzbl.gui.plug)); else printf("window_id %i\n",(int) uzbl.xwin); printf("pid %i\n", getpid ()); printf("name: %s\n", uzbl.state.instance_name); printf("commit: %s\n", uzbl.info.commit); } / Check uzbl is in window mode before getting/setting geometry / if (uzbl.gui.main_window) { if(uzbl.gui.geometry) cmd_set_geometry(); else retrieve_geometry(); } gchar uri_override = (uzbl.state.uri ? g_strdup(uzbl.state.uri) : NULL); if (argc > 1 && !uzbl.state.uri) uri_override = g_strdup(argv[1]); gboolean verbose_override = uzbl.state.verbose; settings_init (); if (!uzbl.behave.show_status) gtk_widget_hide(uzbl.gui.mainbar); else update_title(); /* WebInspector / set_up_inspector(); if (verbose_override > uzbl.state.verbose) uzbl.state.verbose = verbose_override; if (uri_override) { set_var_value("uri", uri_override); g_free(uri_override); } gtk_main (); clean_up(); return EXIT_SUCCESS; } #endif / vi: set et ts=4: */	./CrossVul/dataset_final_sorted/CWE-264/c/bad_4698_2
crossvul-cpp_data_good_3524_11	/* BNEP implementation for Linux Bluetooth stack (BlueZ). Copyright (C) 2001-2002 Inventel Systemes Written 2001-2002 by Clément Moreau <clement.moreau@inventel.fr> David Libault <david.libault@inventel.fr> Copyright (C) 2002 Maxim Krasnyansky <maxk@qualcomm.com> This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License version 2 as published by the Free Software Foundation; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS SOFTWARE IS DISCLAIMED. / #include <linux/module.h> #include <linux/slab.h> #include <linux/socket.h> #include <linux/netdevice.h> #include <linux/etherdevice.h> #include <linux/skbuff.h> #include <linux/wait.h> #include <asm/unaligned.h> #include <net/bluetooth/bluetooth.h> #include <net/bluetooth/hci_core.h> #include <net/bluetooth/l2cap.h> #include "bnep.h" #define BNEP_TX_QUEUE_LEN 20 static int bnep_net_open(struct net_device dev) { netif_start_queue(dev); return 0; } static int bnep_net_close(struct net_device dev) { netif_stop_queue(dev); return 0; } static void bnep_net_set_mc_list(struct net_device dev) { #ifdef CONFIG_BT_BNEP_MC_FILTER struct bnep_session s = netdev_priv(dev); struct sock sk = s->sock->sk; struct bnep_set_filter_req r; struct sk_buff skb; int size; BT_DBG("%s mc_count %d", dev->name, netdev_mc_count(dev)); size = sizeof(r) + (BNEP_MAX_MULTICAST_FILTERS + 1) ETH_ALEN * 2; skb = alloc_skb(size, GFP_ATOMIC); if (!skb) { BT_ERR("%s Multicast list allocation failed", dev->name); return; } r = (void ) skb->data; __skb_put(skb, sizeof(r)); r->type = BNEP_CONTROL; r->ctrl = BNEP_FILTER_MULTI_ADDR_SET; if (dev->flags & (IFF_PROMISC \| IFF_ALLMULTI)) { u8 start[ETH_ALEN] = { 0x01 }; /* Request all addresses / memcpy(__skb_put(skb, ETH_ALEN), start, ETH_ALEN); memcpy(__skb_put(skb, ETH_ALEN), dev->broadcast, ETH_ALEN); r->len = htons(ETH_ALEN 2); } else { struct netdev_hw_addr ha; int i, len = skb->len; if (dev->flags & IFF_BROADCAST) { memcpy(__skb_put(skb, ETH_ALEN), dev->broadcast, ETH_ALEN); memcpy(__skb_put(skb, ETH_ALEN), dev->broadcast, ETH_ALEN); } / FIXME: We should group addresses here. / i = 0; netdev_for_each_mc_addr(ha, dev) { if (i == BNEP_MAX_MULTICAST_FILTERS) break; memcpy(__skb_put(skb, ETH_ALEN), ha->addr, ETH_ALEN); memcpy(__skb_put(skb, ETH_ALEN), ha->addr, ETH_ALEN); i++; } r->len = htons(skb->len - len); } skb_queue_tail(&sk->sk_write_queue, skb); wake_up_interruptible(sk_sleep(sk)); #endif } static int bnep_net_set_mac_addr(struct net_device dev, void arg) { BT_DBG("%s", dev->name); return 0; } static void bnep_net_timeout(struct net_device dev) { BT_DBG("net_timeout"); netif_wake_queue(dev); } #ifdef CONFIG_BT_BNEP_MC_FILTER static inline int bnep_net_mc_filter(struct sk_buff skb, struct bnep_session s) { struct ethhdr eh = (void ) skb->data; if ((eh->h_dest[0] & 1) && !test_bit(bnep_mc_hash(eh->h_dest), (ulong ) &s->mc_filter)) return 1; return 0; } #endif #ifdef CONFIG_BT_BNEP_PROTO_FILTER / Determine ether protocol. Based on eth_type_trans. / static inline u16 bnep_net_eth_proto(struct sk_buff skb) { struct ethhdr eh = (void ) skb->data; u16 proto = ntohs(eh->h_proto); if (proto >= 1536) return proto; if (get_unaligned((__be16 ) skb->data) == htons(0xFFFF)) return ETH_P_802_3; return ETH_P_802_2; } static inline int bnep_net_proto_filter(struct sk_buff skb, struct bnep_session s) { u16 proto = bnep_net_eth_proto(skb); struct bnep_proto_filter f = s->proto_filter; int i; for (i = 0; i < BNEP_MAX_PROTO_FILTERS && f[i].end; i++) { if (proto >= f[i].start && proto <= f[i].end) return 0; } BT_DBG("BNEP: filtered skb %p, proto 0x%.4x", skb, proto); return 1; } #endif static netdev_tx_t bnep_net_xmit(struct sk_buff skb, struct net_device dev) { struct bnep_session s = netdev_priv(dev); struct sock sk = s->sock->sk; BT_DBG("skb %p, dev %p", skb, dev); #ifdef CONFIG_BT_BNEP_MC_FILTER if (bnep_net_mc_filter(skb, s)) { kfree_skb(skb); return NETDEV_TX_OK; } #endif #ifdef CONFIG_BT_BNEP_PROTO_FILTER if (bnep_net_proto_filter(skb, s)) { kfree_skb(skb); return NETDEV_TX_OK; } #endif /* * We cannot send L2CAP packets from here as we are potentially in a bh. * So we have to queue them and wake up session thread which is sleeping * on the sk_sleep(sk). / dev->trans_start = jiffies; skb_queue_tail(&sk->sk_write_queue, skb); wake_up_interruptible(sk_sleep(sk)); if (skb_queue_len(&sk->sk_write_queue) >= BNEP_TX_QUEUE_LEN) { BT_DBG("tx queue is full"); / Stop queuing. * Session thread will do netif_wake_queue() / netif_stop_queue(dev); } return NETDEV_TX_OK; } static const struct net_device_ops bnep_netdev_ops = { .ndo_open = bnep_net_open, .ndo_stop = bnep_net_close, .ndo_start_xmit = bnep_net_xmit, .ndo_validate_addr = eth_validate_addr, .ndo_set_multicast_list = bnep_net_set_mc_list, .ndo_set_mac_address = bnep_net_set_mac_addr, .ndo_tx_timeout = bnep_net_timeout, .ndo_change_mtu = eth_change_mtu, }; void bnep_net_setup(struct net_device dev) { memset(dev->broadcast, 0xff, ETH_ALEN); dev->addr_len = ETH_ALEN; ether_setup(dev); dev->priv_flags &= ~IFF_TX_SKB_SHARING; dev->netdev_ops = &bnep_netdev_ops; dev->watchdog_timeo = HZ * 2; }	./CrossVul/dataset_final_sorted/CWE-264/c/good_3524_11
crossvul-cpp_data_good_3524_12	/* * L2TPv3 ethernet pseudowire driver * * Copyright (c) 2008,2009,2010 Katalix Systems Ltd * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version. / #include <linux/module.h> #include <linux/skbuff.h> #include <linux/socket.h> #include <linux/hash.h> #include <linux/l2tp.h> #include <linux/in.h> #include <linux/etherdevice.h> #include <linux/spinlock.h> #include <net/sock.h> #include <net/ip.h> #include <net/icmp.h> #include <net/udp.h> #include <net/inet_common.h> #include <net/inet_hashtables.h> #include <net/tcp_states.h> #include <net/protocol.h> #include <net/xfrm.h> #include <net/net_namespace.h> #include <net/netns/generic.h> #include "l2tp_core.h" / Default device name. May be overridden by name specified by user / #define L2TP_ETH_DEV_NAME "l2tpeth%d" / via netdev_priv() / struct l2tp_eth { struct net_device dev; struct sock tunnel_sock; struct l2tp_session session; struct list_head list; }; /* via l2tp_session_priv() / struct l2tp_eth_sess { struct net_device dev; }; /* per-net private data for this module / static unsigned int l2tp_eth_net_id; struct l2tp_eth_net { struct list_head l2tp_eth_dev_list; spinlock_t l2tp_eth_lock; }; static inline struct l2tp_eth_net l2tp_eth_pernet(struct net net) { return net_generic(net, l2tp_eth_net_id); } static int l2tp_eth_dev_init(struct net_device dev) { struct l2tp_eth priv = netdev_priv(dev); priv->dev = dev; random_ether_addr(dev->dev_addr); memset(&dev->broadcast[0], 0xff, 6); return 0; } static void l2tp_eth_dev_uninit(struct net_device dev) { struct l2tp_eth priv = netdev_priv(dev); struct l2tp_eth_net pn = l2tp_eth_pernet(dev_net(dev)); spin_lock(&pn->l2tp_eth_lock); list_del_init(&priv->list); spin_unlock(&pn->l2tp_eth_lock); dev_put(dev); } static int l2tp_eth_dev_xmit(struct sk_buff skb, struct net_device dev) { struct l2tp_eth priv = netdev_priv(dev); struct l2tp_session session = priv->session; l2tp_xmit_skb(session, skb, session->hdr_len); dev->stats.tx_bytes += skb->len; dev->stats.tx_packets++; return 0; } static struct net_device_ops l2tp_eth_netdev_ops = { .ndo_init = l2tp_eth_dev_init, .ndo_uninit = l2tp_eth_dev_uninit, .ndo_start_xmit = l2tp_eth_dev_xmit, }; static void l2tp_eth_dev_setup(struct net_device dev) { ether_setup(dev); dev->priv_flags &= ~IFF_TX_SKB_SHARING; dev->netdev_ops = &l2tp_eth_netdev_ops; dev->destructor = free_netdev; } static void l2tp_eth_dev_recv(struct l2tp_session session, struct sk_buff skb, int data_len) { struct l2tp_eth_sess spriv = l2tp_session_priv(session); struct net_device dev = spriv->dev; if (session->debug & L2TP_MSG_DATA) { unsigned int length; int offset; u8 ptr = skb->data; length = min(32u, skb->len); if (!pskb_may_pull(skb, length)) goto error; printk(KERN_DEBUG "%s: eth recv: ", session->name); offset = 0; do { printk(" %02X", ptr[offset]); } while (++offset < length); printk("\n"); } if (!pskb_may_pull(skb, sizeof(ETH_HLEN))) goto error; secpath_reset(skb); /* checksums verified by L2TP / skb->ip_summed = CHECKSUM_NONE; skb_dst_drop(skb); nf_reset(skb); if (dev_forward_skb(dev, skb) == NET_RX_SUCCESS) { dev->stats.rx_packets++; dev->stats.rx_bytes += data_len; } else dev->stats.rx_errors++; return; error: dev->stats.rx_errors++; kfree_skb(skb); } static void l2tp_eth_delete(struct l2tp_session session) { struct l2tp_eth_sess spriv; struct net_device dev; if (session) { spriv = l2tp_session_priv(session); dev = spriv->dev; if (dev) { unregister_netdev(dev); spriv->dev = NULL; } } } #if defined(CONFIG_L2TP_DEBUGFS) \|\| defined(CONFIG_L2TP_DEBUGFS_MODULE) static void l2tp_eth_show(struct seq_file m, void arg) { struct l2tp_session session = arg; struct l2tp_eth_sess spriv = l2tp_session_priv(session); struct net_device dev = spriv->dev; seq_printf(m, " interface %s\n", dev->name); } #endif static int l2tp_eth_create(struct net net, u32 tunnel_id, u32 session_id, u32 peer_session_id, struct l2tp_session_cfg cfg) { struct net_device dev; char name[IFNAMSIZ]; struct l2tp_tunnel tunnel; struct l2tp_session session; struct l2tp_eth priv; struct l2tp_eth_sess spriv; int rc; struct l2tp_eth_net pn; tunnel = l2tp_tunnel_find(net, tunnel_id); if (!tunnel) { rc = -ENODEV; goto out; } session = l2tp_session_find(net, tunnel, session_id); if (session) { rc = -EEXIST; goto out; } if (cfg->ifname) { dev = dev_get_by_name(net, cfg->ifname); if (dev) { dev_put(dev); rc = -EEXIST; goto out; } strlcpy(name, cfg->ifname, IFNAMSIZ); } else strcpy(name, L2TP_ETH_DEV_NAME); session = l2tp_session_create(sizeof(spriv), tunnel, session_id, peer_session_id, cfg); if (!session) { rc = -ENOMEM; goto out; } dev = alloc_netdev(sizeof(priv), name, l2tp_eth_dev_setup); if (!dev) { rc = -ENOMEM; goto out_del_session; } dev_net_set(dev, net); if (session->mtu == 0) session->mtu = dev->mtu - session->hdr_len; dev->mtu = session->mtu; dev->needed_headroom += session->hdr_len; priv = netdev_priv(dev); priv->dev = dev; priv->session = session; INIT_LIST_HEAD(&priv->list); priv->tunnel_sock = tunnel->sock; session->recv_skb = l2tp_eth_dev_recv; session->session_close = l2tp_eth_delete; #if defined(CONFIG_L2TP_DEBUGFS) \|\| defined(CONFIG_L2TP_DEBUGFS_MODULE) session->show = l2tp_eth_show; #endif spriv = l2tp_session_priv(session); spriv->dev = dev; rc = register_netdev(dev); if (rc < 0) goto out_del_dev; / Must be done after register_netdev() / strlcpy(session->ifname, dev->name, IFNAMSIZ); dev_hold(dev); pn = l2tp_eth_pernet(dev_net(dev)); spin_lock(&pn->l2tp_eth_lock); list_add(&priv->list, &pn->l2tp_eth_dev_list); spin_unlock(&pn->l2tp_eth_lock); return 0; out_del_dev: free_netdev(dev); out_del_session: l2tp_session_delete(session); out: return rc; } static __net_init int l2tp_eth_init_net(struct net net) { struct l2tp_eth_net *pn = net_generic(net, l2tp_eth_net_id); INIT_LIST_HEAD(&pn->l2tp_eth_dev_list); spin_lock_init(&pn->l2tp_eth_lock); return 0; } static struct pernet_operations l2tp_eth_net_ops = { .init = l2tp_eth_init_net, .id = &l2tp_eth_net_id, .size = sizeof(struct l2tp_eth_net), }; static const struct l2tp_nl_cmd_ops l2tp_eth_nl_cmd_ops = { .session_create = l2tp_eth_create, .session_delete = l2tp_session_delete, }; static int __init l2tp_eth_init(void) { int err = 0; err = l2tp_nl_register_ops(L2TP_PWTYPE_ETH, &l2tp_eth_nl_cmd_ops); if (err) goto out; err = register_pernet_device(&l2tp_eth_net_ops); if (err) goto out_unreg; printk(KERN_INFO "L2TP ethernet pseudowire support (L2TPv3)\n"); return 0; out_unreg: l2tp_nl_unregister_ops(L2TP_PWTYPE_ETH); out: return err; } static void __exit l2tp_eth_exit(void) { unregister_pernet_device(&l2tp_eth_net_ops); l2tp_nl_unregister_ops(L2TP_PWTYPE_ETH); } module_init(l2tp_eth_init); module_exit(l2tp_eth_exit); MODULE_LICENSE("GPL"); MODULE_AUTHOR("James Chapman <jchapman@katalix.com>"); MODULE_DESCRIPTION("L2TP ethernet pseudowire driver"); MODULE_VERSION("1.0");	./CrossVul/dataset_final_sorted/CWE-264/c/good_3524_12
crossvul-cpp_data_bad_2399_1	/* * Cryptographic API for algorithms (i.e., low-level API). * * Copyright (c) 2006 Herbert Xu <herbert@gondor.apana.org.au> * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the Free * Software Foundation; either version 2 of the License, or (at your option) * any later version. * / #include <linux/err.h> #include <linux/errno.h> #include <linux/init.h> #include <linux/kernel.h> #include <linux/list.h> #include <linux/module.h> #include <linux/rtnetlink.h> #include <linux/slab.h> #include <linux/string.h> #include "internal.h" static LIST_HEAD(crypto_template_list); static inline int crypto_set_driver_name(struct crypto_alg alg) { static const char suffix[] = "-generic"; char driver_name = alg->cra_driver_name; int len; if (driver_name) return 0; len = strlcpy(driver_name, alg->cra_name, CRYPTO_MAX_ALG_NAME); if (len + sizeof(suffix) > CRYPTO_MAX_ALG_NAME) return -ENAMETOOLONG; memcpy(driver_name + len, suffix, sizeof(suffix)); return 0; } static inline void crypto_check_module_sig(struct module mod) { #ifdef CONFIG_CRYPTO_FIPS if (fips_enabled && mod && !mod->sig_ok) panic("Module %s signature verification failed in FIPS mode\n", mod->name); #endif return; } static int crypto_check_alg(struct crypto_alg alg) { crypto_check_module_sig(alg->cra_module); if (alg->cra_alignmask & (alg->cra_alignmask + 1)) return -EINVAL; if (alg->cra_blocksize > PAGE_SIZE / 8) return -EINVAL; if (alg->cra_priority < 0) return -EINVAL; return crypto_set_driver_name(alg); } static void crypto_destroy_instance(struct crypto_alg alg) { struct crypto_instance inst = (void )alg; struct crypto_template tmpl = inst->tmpl; tmpl->free(inst); crypto_tmpl_put(tmpl); } static struct list_head crypto_more_spawns(struct crypto_alg alg, struct list_head stack, struct list_head top, struct list_head secondary_spawns) { struct crypto_spawn spawn, n; if (list_empty(stack)) return NULL; spawn = list_first_entry(stack, struct crypto_spawn, list); n = list_entry(spawn->list.next, struct crypto_spawn, list); if (spawn->alg && &n->list != stack && !n->alg) n->alg = (n->list.next == stack) ? alg : &list_entry(n->list.next, struct crypto_spawn, list)->inst->alg; list_move(&spawn->list, secondary_spawns); return &n->list == stack ? top : &n->inst->alg.cra_users; } static void crypto_remove_spawn(struct crypto_spawn spawn, struct list_head list) { struct crypto_instance inst = spawn->inst; struct crypto_template tmpl = inst->tmpl; if (crypto_is_dead(&inst->alg)) return; inst->alg.cra_flags \|= CRYPTO_ALG_DEAD; if (hlist_unhashed(&inst->list)) return; if (!tmpl \|\| !crypto_tmpl_get(tmpl)) return; crypto_notify(CRYPTO_MSG_ALG_UNREGISTER, &inst->alg); list_move(&inst->alg.cra_list, list); hlist_del(&inst->list); inst->alg.cra_destroy = crypto_destroy_instance; BUG_ON(!list_empty(&inst->alg.cra_users)); } void crypto_remove_spawns(struct crypto_alg alg, struct list_head list, struct crypto_alg nalg) { u32 new_type = (nalg ?: alg)->cra_flags; struct crypto_spawn spawn, n; LIST_HEAD(secondary_spawns); struct list_head spawns; LIST_HEAD(stack); LIST_HEAD(top); spawns = &alg->cra_users; list_for_each_entry_safe(spawn, n, spawns, list) { if ((spawn->alg->cra_flags ^ new_type) & spawn->mask) continue; list_move(&spawn->list, &top); } spawns = &top; do { while (!list_empty(spawns)) { struct crypto_instance inst; spawn = list_first_entry(spawns, struct crypto_spawn, list); inst = spawn->inst; BUG_ON(&inst->alg == alg); list_move(&spawn->list, &stack); if (&inst->alg == nalg) break; spawn->alg = NULL; spawns = &inst->alg.cra_users; } } while ((spawns = crypto_more_spawns(alg, &stack, &top, &secondary_spawns))); list_for_each_entry_safe(spawn, n, &secondary_spawns, list) { if (spawn->alg) list_move(&spawn->list, &spawn->alg->cra_users); else crypto_remove_spawn(spawn, list); } } EXPORT_SYMBOL_GPL(crypto_remove_spawns); static struct crypto_larval __crypto_register_alg(struct crypto_alg alg) { struct crypto_alg q; struct crypto_larval larval; int ret = -EAGAIN; if (crypto_is_dead(alg)) goto err; INIT_LIST_HEAD(&alg->cra_users); /* No cheating! / alg->cra_flags &= ~CRYPTO_ALG_TESTED; ret = -EEXIST; atomic_set(&alg->cra_refcnt, 1); list_for_each_entry(q, &crypto_alg_list, cra_list) { if (q == alg) goto err; if (crypto_is_moribund(q)) continue; if (crypto_is_larval(q)) { if (!strcmp(alg->cra_driver_name, q->cra_driver_name)) goto err; continue; } if (!strcmp(q->cra_driver_name, alg->cra_name) \|\| !strcmp(q->cra_name, alg->cra_driver_name)) goto err; } larval = crypto_larval_alloc(alg->cra_name, alg->cra_flags \| CRYPTO_ALG_TESTED, 0); if (IS_ERR(larval)) goto out; ret = -ENOENT; larval->adult = crypto_mod_get(alg); if (!larval->adult) goto free_larval; atomic_set(&larval->alg.cra_refcnt, 1); memcpy(larval->alg.cra_driver_name, alg->cra_driver_name, CRYPTO_MAX_ALG_NAME); larval->alg.cra_priority = alg->cra_priority; list_add(&alg->cra_list, &crypto_alg_list); list_add(&larval->alg.cra_list, &crypto_alg_list); out: return larval; free_larval: kfree(larval); err: larval = ERR_PTR(ret); goto out; } void crypto_alg_tested(const char name, int err) { struct crypto_larval test; struct crypto_alg alg; struct crypto_alg q; LIST_HEAD(list); down_write(&crypto_alg_sem); list_for_each_entry(q, &crypto_alg_list, cra_list) { if (crypto_is_moribund(q) \|\| !crypto_is_larval(q)) continue; test = (struct crypto_larval )q; if (!strcmp(q->cra_driver_name, name)) goto found; } printk(KERN_ERR "alg: Unexpected test result for %s: %d\n", name, err); goto unlock; found: q->cra_flags \|= CRYPTO_ALG_DEAD; alg = test->adult; if (err \|\| list_empty(&alg->cra_list)) goto complete; alg->cra_flags \|= CRYPTO_ALG_TESTED; list_for_each_entry(q, &crypto_alg_list, cra_list) { if (q == alg) continue; if (crypto_is_moribund(q)) continue; if (crypto_is_larval(q)) { struct crypto_larval larval = (void )q; /* * Check to see if either our generic name or * specific name can satisfy the name requested * by the larval entry q. / if (strcmp(alg->cra_name, q->cra_name) && strcmp(alg->cra_driver_name, q->cra_name)) continue; if (larval->adult) continue; if ((q->cra_flags ^ alg->cra_flags) & larval->mask) continue; if (!crypto_mod_get(alg)) continue; larval->adult = alg; continue; } if (strcmp(alg->cra_name, q->cra_name)) continue; if (strcmp(alg->cra_driver_name, q->cra_driver_name) && q->cra_priority > alg->cra_priority) continue; crypto_remove_spawns(q, &list, alg); } complete: complete_all(&test->completion); unlock: up_write(&crypto_alg_sem); crypto_remove_final(&list); } EXPORT_SYMBOL_GPL(crypto_alg_tested); void crypto_remove_final(struct list_head list) { struct crypto_alg alg; struct crypto_alg n; list_for_each_entry_safe(alg, n, list, cra_list) { list_del_init(&alg->cra_list); crypto_alg_put(alg); } } EXPORT_SYMBOL_GPL(crypto_remove_final); static void crypto_wait_for_test(struct crypto_larval larval) { int err; err = crypto_probing_notify(CRYPTO_MSG_ALG_REGISTER, larval->adult); if (err != NOTIFY_STOP) { if (WARN_ON(err != NOTIFY_DONE)) goto out; crypto_alg_tested(larval->alg.cra_driver_name, 0); } err = wait_for_completion_interruptible(&larval->completion); WARN_ON(err); out: crypto_larval_kill(&larval->alg); } int crypto_register_alg(struct crypto_alg alg) { struct crypto_larval larval; int err; err = crypto_check_alg(alg); if (err) return err; down_write(&crypto_alg_sem); larval = __crypto_register_alg(alg); up_write(&crypto_alg_sem); if (IS_ERR(larval)) return PTR_ERR(larval); crypto_wait_for_test(larval); return 0; } EXPORT_SYMBOL_GPL(crypto_register_alg); static int crypto_remove_alg(struct crypto_alg alg, struct list_head list) { if (unlikely(list_empty(&alg->cra_list))) return -ENOENT; alg->cra_flags \|= CRYPTO_ALG_DEAD; crypto_notify(CRYPTO_MSG_ALG_UNREGISTER, alg); list_del_init(&alg->cra_list); crypto_remove_spawns(alg, list, NULL); return 0; } int crypto_unregister_alg(struct crypto_alg alg) { int ret; LIST_HEAD(list); down_write(&crypto_alg_sem); ret = crypto_remove_alg(alg, &list); up_write(&crypto_alg_sem); if (ret) return ret; BUG_ON(atomic_read(&alg->cra_refcnt) != 1); if (alg->cra_destroy) alg->cra_destroy(alg); crypto_remove_final(&list); return 0; } EXPORT_SYMBOL_GPL(crypto_unregister_alg); int crypto_register_algs(struct crypto_alg algs, int count) { int i, ret; for (i = 0; i < count; i++) { ret = crypto_register_alg(&algs[i]); if (ret) goto err; } return 0; err: for (--i; i >= 0; --i) crypto_unregister_alg(&algs[i]); return ret; } EXPORT_SYMBOL_GPL(crypto_register_algs); int crypto_unregister_algs(struct crypto_alg algs, int count) { int i, ret; for (i = 0; i < count; i++) { ret = crypto_unregister_alg(&algs[i]); if (ret) pr_err("Failed to unregister %s %s: %d\n", algs[i].cra_driver_name, algs[i].cra_name, ret); } return 0; } EXPORT_SYMBOL_GPL(crypto_unregister_algs); int crypto_register_template(struct crypto_template tmpl) { struct crypto_template q; int err = -EEXIST; down_write(&crypto_alg_sem); crypto_check_module_sig(tmpl->module); list_for_each_entry(q, &crypto_template_list, list) { if (q == tmpl) goto out; } list_add(&tmpl->list, &crypto_template_list); crypto_notify(CRYPTO_MSG_TMPL_REGISTER, tmpl); err = 0; out: up_write(&crypto_alg_sem); return err; } EXPORT_SYMBOL_GPL(crypto_register_template); void crypto_unregister_template(struct crypto_template tmpl) { struct crypto_instance inst; struct hlist_node n; struct hlist_head list; LIST_HEAD(users); down_write(&crypto_alg_sem); BUG_ON(list_empty(&tmpl->list)); list_del_init(&tmpl->list); list = &tmpl->instances; hlist_for_each_entry(inst, list, list) { int err = crypto_remove_alg(&inst->alg, &users); BUG_ON(err); } crypto_notify(CRYPTO_MSG_TMPL_UNREGISTER, tmpl); up_write(&crypto_alg_sem); hlist_for_each_entry_safe(inst, n, list, list) { BUG_ON(atomic_read(&inst->alg.cra_refcnt) != 1); tmpl->free(inst); } crypto_remove_final(&users); } EXPORT_SYMBOL_GPL(crypto_unregister_template); static struct crypto_template __crypto_lookup_template(const char name) { struct crypto_template q, tmpl = NULL; down_read(&crypto_alg_sem); list_for_each_entry(q, &crypto_template_list, list) { if (strcmp(q->name, name)) continue; if (unlikely(!crypto_tmpl_get(q))) continue; tmpl = q; break; } up_read(&crypto_alg_sem); return tmpl; } struct crypto_template crypto_lookup_template(const char name) { return try_then_request_module(__crypto_lookup_template(name), "%s", name); } EXPORT_SYMBOL_GPL(crypto_lookup_template); int crypto_register_instance(struct crypto_template tmpl, struct crypto_instance inst) { struct crypto_larval larval; int err; err = crypto_check_alg(&inst->alg); if (err) goto err; inst->alg.cra_module = tmpl->module; inst->alg.cra_flags \|= CRYPTO_ALG_INSTANCE; down_write(&crypto_alg_sem); larval = __crypto_register_alg(&inst->alg); if (IS_ERR(larval)) goto unlock; hlist_add_head(&inst->list, &tmpl->instances); inst->tmpl = tmpl; unlock: up_write(&crypto_alg_sem); err = PTR_ERR(larval); if (IS_ERR(larval)) goto err; crypto_wait_for_test(larval); err = 0; err: return err; } EXPORT_SYMBOL_GPL(crypto_register_instance); int crypto_unregister_instance(struct crypto_alg alg) { int err; struct crypto_instance inst = (void )alg; struct crypto_template tmpl = inst->tmpl; LIST_HEAD(users); if (!(alg->cra_flags & CRYPTO_ALG_INSTANCE)) return -EINVAL; BUG_ON(atomic_read(&alg->cra_refcnt) != 1); down_write(&crypto_alg_sem); hlist_del_init(&inst->list); err = crypto_remove_alg(alg, &users); up_write(&crypto_alg_sem); if (err) return err; tmpl->free(inst); crypto_remove_final(&users); return 0; } EXPORT_SYMBOL_GPL(crypto_unregister_instance); int crypto_init_spawn(struct crypto_spawn spawn, struct crypto_alg alg, struct crypto_instance inst, u32 mask) { int err = -EAGAIN; spawn->inst = inst; spawn->mask = mask; down_write(&crypto_alg_sem); if (!crypto_is_moribund(alg)) { list_add(&spawn->list, &alg->cra_users); spawn->alg = alg; err = 0; } up_write(&crypto_alg_sem); return err; } EXPORT_SYMBOL_GPL(crypto_init_spawn); int crypto_init_spawn2(struct crypto_spawn spawn, struct crypto_alg alg, struct crypto_instance inst, const struct crypto_type frontend) { int err = -EINVAL; if ((alg->cra_flags ^ frontend->type) & frontend->maskset) goto out; spawn->frontend = frontend; err = crypto_init_spawn(spawn, alg, inst, frontend->maskset); out: return err; } EXPORT_SYMBOL_GPL(crypto_init_spawn2); void crypto_drop_spawn(struct crypto_spawn spawn) { if (!spawn->alg) return; down_write(&crypto_alg_sem); list_del(&spawn->list); up_write(&crypto_alg_sem); } EXPORT_SYMBOL_GPL(crypto_drop_spawn); static struct crypto_alg crypto_spawn_alg(struct crypto_spawn spawn) { struct crypto_alg alg; struct crypto_alg alg2; down_read(&crypto_alg_sem); alg = spawn->alg; alg2 = alg; if (alg2) alg2 = crypto_mod_get(alg2); up_read(&crypto_alg_sem); if (!alg2) { if (alg) crypto_shoot_alg(alg); return ERR_PTR(-EAGAIN); } return alg; } struct crypto_tfm crypto_spawn_tfm(struct crypto_spawn spawn, u32 type, u32 mask) { struct crypto_alg alg; struct crypto_tfm tfm; alg = crypto_spawn_alg(spawn); if (IS_ERR(alg)) return ERR_CAST(alg); tfm = ERR_PTR(-EINVAL); if (unlikely((alg->cra_flags ^ type) & mask)) goto out_put_alg; tfm = __crypto_alloc_tfm(alg, type, mask); if (IS_ERR(tfm)) goto out_put_alg; return tfm; out_put_alg: crypto_mod_put(alg); return tfm; } EXPORT_SYMBOL_GPL(crypto_spawn_tfm); void crypto_spawn_tfm2(struct crypto_spawn spawn) { struct crypto_alg alg; struct crypto_tfm tfm; alg = crypto_spawn_alg(spawn); if (IS_ERR(alg)) return ERR_CAST(alg); tfm = crypto_create_tfm(alg, spawn->frontend); if (IS_ERR(tfm)) goto out_put_alg; return tfm; out_put_alg: crypto_mod_put(alg); return tfm; } EXPORT_SYMBOL_GPL(crypto_spawn_tfm2); int crypto_register_notifier(struct notifier_block nb) { return blocking_notifier_chain_register(&crypto_chain, nb); } EXPORT_SYMBOL_GPL(crypto_register_notifier); int crypto_unregister_notifier(struct notifier_block nb) { return blocking_notifier_chain_unregister(&crypto_chain, nb); } EXPORT_SYMBOL_GPL(crypto_unregister_notifier); struct crypto_attr_type crypto_get_attr_type(struct rtattr *tb) { struct rtattr rta = tb[0]; struct crypto_attr_type algt; if (!rta) return ERR_PTR(-ENOENT); if (RTA_PAYLOAD(rta) < sizeof(algt)) return ERR_PTR(-EINVAL); if (rta->rta_type != CRYPTOA_TYPE) return ERR_PTR(-EINVAL); algt = RTA_DATA(rta); return algt; } EXPORT_SYMBOL_GPL(crypto_get_attr_type); int crypto_check_attr_type(struct rtattr *tb, u32 type) { struct crypto_attr_type algt; algt = crypto_get_attr_type(tb); if (IS_ERR(algt)) return PTR_ERR(algt); if ((algt->type ^ type) & algt->mask) return -EINVAL; return 0; } EXPORT_SYMBOL_GPL(crypto_check_attr_type); const char crypto_attr_alg_name(struct rtattr rta) { struct crypto_attr_alg alga; if (!rta) return ERR_PTR(-ENOENT); if (RTA_PAYLOAD(rta) < sizeof(alga)) return ERR_PTR(-EINVAL); if (rta->rta_type != CRYPTOA_ALG) return ERR_PTR(-EINVAL); alga = RTA_DATA(rta); alga->name[CRYPTO_MAX_ALG_NAME - 1] = 0; return alga->name; } EXPORT_SYMBOL_GPL(crypto_attr_alg_name); struct crypto_alg crypto_attr_alg2(struct rtattr rta, const struct crypto_type frontend, u32 type, u32 mask) { const char name; name = crypto_attr_alg_name(rta); if (IS_ERR(name)) return ERR_CAST(name); return crypto_find_alg(name, frontend, type, mask); } EXPORT_SYMBOL_GPL(crypto_attr_alg2); int crypto_attr_u32(struct rtattr rta, u32 num) { struct crypto_attr_u32 nu32; if (!rta) return -ENOENT; if (RTA_PAYLOAD(rta) < sizeof(nu32)) return -EINVAL; if (rta->rta_type != CRYPTOA_U32) return -EINVAL; nu32 = RTA_DATA(rta); num = nu32->num; return 0; } EXPORT_SYMBOL_GPL(crypto_attr_u32); void crypto_alloc_instance2(const char name, struct crypto_alg alg, unsigned int head) { struct crypto_instance inst; char p; int err; p = kzalloc(head + sizeof(inst) + sizeof(struct crypto_spawn), GFP_KERNEL); if (!p) return ERR_PTR(-ENOMEM); inst = (void )(p + head); err = -ENAMETOOLONG; if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, "%s(%s)", name, alg->cra_name) >= CRYPTO_MAX_ALG_NAME) goto err_free_inst; if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, "%s(%s)", name, alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME) goto err_free_inst; return p; err_free_inst: kfree(p); return ERR_PTR(err); } EXPORT_SYMBOL_GPL(crypto_alloc_instance2); struct crypto_instance crypto_alloc_instance(const char name, struct crypto_alg alg) { struct crypto_instance inst; struct crypto_spawn spawn; int err; inst = crypto_alloc_instance2(name, alg, 0); if (IS_ERR(inst)) goto out; spawn = crypto_instance_ctx(inst); err = crypto_init_spawn(spawn, alg, inst, CRYPTO_ALG_TYPE_MASK \| CRYPTO_ALG_ASYNC); if (err) goto err_free_inst; return inst; err_free_inst: kfree(inst); inst = ERR_PTR(err); out: return inst; } EXPORT_SYMBOL_GPL(crypto_alloc_instance); void crypto_init_queue(struct crypto_queue queue, unsigned int max_qlen) { INIT_LIST_HEAD(&queue->list); queue->backlog = &queue->list; queue->qlen = 0; queue->max_qlen = max_qlen; } EXPORT_SYMBOL_GPL(crypto_init_queue); int crypto_enqueue_request(struct crypto_queue queue, struct crypto_async_request request) { int err = -EINPROGRESS; if (unlikely(queue->qlen >= queue->max_qlen)) { err = -EBUSY; if (!(request->flags & CRYPTO_TFM_REQ_MAY_BACKLOG)) goto out; if (queue->backlog == &queue->list) queue->backlog = &request->list; } queue->qlen++; list_add_tail(&request->list, &queue->list); out: return err; } EXPORT_SYMBOL_GPL(crypto_enqueue_request); void __crypto_dequeue_request(struct crypto_queue queue, unsigned int offset) { struct list_head request; if (unlikely(!queue->qlen)) return NULL; queue->qlen--; if (queue->backlog != &queue->list) queue->backlog = queue->backlog->next; request = queue->list.next; list_del(request); return (char )list_entry(request, struct crypto_async_request, list) - offset; } EXPORT_SYMBOL_GPL(__crypto_dequeue_request); struct crypto_async_request crypto_dequeue_request(struct crypto_queue queue) { return __crypto_dequeue_request(queue, 0); } EXPORT_SYMBOL_GPL(crypto_dequeue_request); int crypto_tfm_in_queue(struct crypto_queue queue, struct crypto_tfm tfm) { struct crypto_async_request req; list_for_each_entry(req, &queue->list, list) { if (req->tfm == tfm) return 1; } return 0; } EXPORT_SYMBOL_GPL(crypto_tfm_in_queue); static inline void crypto_inc_byte(u8 a, unsigned int size) { u8 b = (a + size); u8 c; for (; size; size--) { c = --b + 1; b = c; if (c) break; } } void crypto_inc(u8 a, unsigned int size) { __be32 b = (__be32 )(a + size); u32 c; for (; size >= 4; size -= 4) { c = be32_to_cpu(--b) + 1; b = cpu_to_be32(c); if (c) return; } crypto_inc_byte(a, size); } EXPORT_SYMBOL_GPL(crypto_inc); static inline void crypto_xor_byte(u8 a, const u8 b, unsigned int size) { for (; size; size--) a++ ^= b++; } void crypto_xor(u8 dst, const u8 src, unsigned int size) { u32 a = (u32 )dst; u32 b = (u32 )src; for (; size >= 4; size -= 4) a++ ^= b++; crypto_xor_byte((u8 )a, (u8 )b, size); } EXPORT_SYMBOL_GPL(crypto_xor); static int __init crypto_algapi_init(void) { crypto_init_proc(); return 0; } static void __exit crypto_algapi_exit(void) { crypto_exit_proc(); } module_init(crypto_algapi_init); module_exit(crypto_algapi_exit); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("Cryptographic algorithms API");	./CrossVul/dataset_final_sorted/CWE-264/c/bad_2399_1
crossvul-cpp_data_bad_2399_13	/* * GCM: Galois/Counter Mode. * * Copyright (c) 2007 Nokia Siemens Networks - Mikko Herranen <mh1@iki.fi> * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 as published * by the Free Software Foundation. / #include <crypto/gf128mul.h> #include <crypto/internal/aead.h> #include <crypto/internal/skcipher.h> #include <crypto/internal/hash.h> #include <crypto/scatterwalk.h> #include <crypto/hash.h> #include "internal.h" #include <linux/completion.h> #include <linux/err.h> #include <linux/init.h> #include <linux/kernel.h> #include <linux/module.h> #include <linux/slab.h> struct gcm_instance_ctx { struct crypto_skcipher_spawn ctr; struct crypto_ahash_spawn ghash; }; struct crypto_gcm_ctx { struct crypto_ablkcipher ctr; struct crypto_ahash ghash; }; struct crypto_rfc4106_ctx { struct crypto_aead child; u8 nonce[4]; }; struct crypto_rfc4543_instance_ctx { struct crypto_aead_spawn aead; struct crypto_skcipher_spawn null; }; struct crypto_rfc4543_ctx { struct crypto_aead child; struct crypto_blkcipher null; u8 nonce[4]; }; struct crypto_rfc4543_req_ctx { u8 auth_tag[16]; u8 assocbuf[32]; struct scatterlist cipher[1]; struct scatterlist payload[2]; struct scatterlist assoc[2]; struct aead_request subreq; }; struct crypto_gcm_ghash_ctx { unsigned int cryptlen; struct scatterlist src; void (complete)(struct aead_request req, int err); }; struct crypto_gcm_req_priv_ctx { u8 auth_tag[16]; u8 iauth_tag[16]; struct scatterlist src[2]; struct scatterlist dst[2]; struct crypto_gcm_ghash_ctx ghash_ctx; union { struct ahash_request ahreq; struct ablkcipher_request abreq; } u; }; struct crypto_gcm_setkey_result { int err; struct completion completion; }; static void gcm_zeroes; static inline struct crypto_gcm_req_priv_ctx crypto_gcm_reqctx( struct aead_request req) { unsigned long align = crypto_aead_alignmask(crypto_aead_reqtfm(req)); return (void )PTR_ALIGN((u8 )aead_request_ctx(req), align + 1); } static void crypto_gcm_setkey_done(struct crypto_async_request req, int err) { struct crypto_gcm_setkey_result result = req->data; if (err == -EINPROGRESS) return; result->err = err; complete(&result->completion); } static int crypto_gcm_setkey(struct crypto_aead aead, const u8 key, unsigned int keylen) { struct crypto_gcm_ctx ctx = crypto_aead_ctx(aead); struct crypto_ahash ghash = ctx->ghash; struct crypto_ablkcipher ctr = ctx->ctr; struct { be128 hash; u8 iv[8]; struct crypto_gcm_setkey_result result; struct scatterlist sg[1]; struct ablkcipher_request req; } data; int err; crypto_ablkcipher_clear_flags(ctr, CRYPTO_TFM_REQ_MASK); crypto_ablkcipher_set_flags(ctr, crypto_aead_get_flags(aead) & CRYPTO_TFM_REQ_MASK); err = crypto_ablkcipher_setkey(ctr, key, keylen); if (err) return err; crypto_aead_set_flags(aead, crypto_ablkcipher_get_flags(ctr) & CRYPTO_TFM_RES_MASK); data = kzalloc(sizeof(data) + crypto_ablkcipher_reqsize(ctr), GFP_KERNEL); if (!data) return -ENOMEM; init_completion(&data->result.completion); sg_init_one(data->sg, &data->hash, sizeof(data->hash)); ablkcipher_request_set_tfm(&data->req, ctr); ablkcipher_request_set_callback(&data->req, CRYPTO_TFM_REQ_MAY_SLEEP \| CRYPTO_TFM_REQ_MAY_BACKLOG, crypto_gcm_setkey_done, &data->result); ablkcipher_request_set_crypt(&data->req, data->sg, data->sg, sizeof(data->hash), data->iv); err = crypto_ablkcipher_encrypt(&data->req); if (err == -EINPROGRESS \|\| err == -EBUSY) { err = wait_for_completion_interruptible( &data->result.completion); if (!err) err = data->result.err; } if (err) goto out; crypto_ahash_clear_flags(ghash, CRYPTO_TFM_REQ_MASK); crypto_ahash_set_flags(ghash, crypto_aead_get_flags(aead) & CRYPTO_TFM_REQ_MASK); err = crypto_ahash_setkey(ghash, (u8 )&data->hash, sizeof(be128)); crypto_aead_set_flags(aead, crypto_ahash_get_flags(ghash) & CRYPTO_TFM_RES_MASK); out: kfree(data); return err; } static int crypto_gcm_setauthsize(struct crypto_aead tfm, unsigned int authsize) { switch (authsize) { case 4: case 8: case 12: case 13: case 14: case 15: case 16: break; default: return -EINVAL; } return 0; } static void crypto_gcm_init_crypt(struct ablkcipher_request ablk_req, struct aead_request req, unsigned int cryptlen) { struct crypto_aead aead = crypto_aead_reqtfm(req); struct crypto_gcm_ctx ctx = crypto_aead_ctx(aead); struct crypto_gcm_req_priv_ctx pctx = crypto_gcm_reqctx(req); struct scatterlist dst; __be32 counter = cpu_to_be32(1); memset(pctx->auth_tag, 0, sizeof(pctx->auth_tag)); memcpy(req->iv + 12, &counter, 4); sg_init_table(pctx->src, 2); sg_set_buf(pctx->src, pctx->auth_tag, sizeof(pctx->auth_tag)); scatterwalk_sg_chain(pctx->src, 2, req->src); dst = pctx->src; if (req->src != req->dst) { sg_init_table(pctx->dst, 2); sg_set_buf(pctx->dst, pctx->auth_tag, sizeof(pctx->auth_tag)); scatterwalk_sg_chain(pctx->dst, 2, req->dst); dst = pctx->dst; } ablkcipher_request_set_tfm(ablk_req, ctx->ctr); ablkcipher_request_set_crypt(ablk_req, pctx->src, dst, cryptlen + sizeof(pctx->auth_tag), req->iv); } static inline unsigned int gcm_remain(unsigned int len) { len &= 0xfU; return len ? 16 - len : 0; } static void gcm_hash_len_done(struct crypto_async_request areq, int err); static void gcm_hash_final_done(struct crypto_async_request areq, int err); static int gcm_hash_update(struct aead_request req, struct crypto_gcm_req_priv_ctx pctx, crypto_completion_t compl, struct scatterlist src, unsigned int len) { struct ahash_request ahreq = &pctx->u.ahreq; ahash_request_set_callback(ahreq, aead_request_flags(req), compl, req); ahash_request_set_crypt(ahreq, src, NULL, len); return crypto_ahash_update(ahreq); } static int gcm_hash_remain(struct aead_request req, struct crypto_gcm_req_priv_ctx pctx, unsigned int remain, crypto_completion_t compl) { struct ahash_request ahreq = &pctx->u.ahreq; ahash_request_set_callback(ahreq, aead_request_flags(req), compl, req); sg_init_one(pctx->src, gcm_zeroes, remain); ahash_request_set_crypt(ahreq, pctx->src, NULL, remain); return crypto_ahash_update(ahreq); } static int gcm_hash_len(struct aead_request req, struct crypto_gcm_req_priv_ctx pctx) { struct ahash_request ahreq = &pctx->u.ahreq; struct crypto_gcm_ghash_ctx gctx = &pctx->ghash_ctx; u128 lengths; lengths.a = cpu_to_be64(req->assoclen * 8); lengths.b = cpu_to_be64(gctx->cryptlen * 8); memcpy(pctx->iauth_tag, &lengths, 16); sg_init_one(pctx->src, pctx->iauth_tag, 16); ahash_request_set_callback(ahreq, aead_request_flags(req), gcm_hash_len_done, req); ahash_request_set_crypt(ahreq, pctx->src, NULL, sizeof(lengths)); return crypto_ahash_update(ahreq); } static int gcm_hash_final(struct aead_request req, struct crypto_gcm_req_priv_ctx pctx) { struct ahash_request ahreq = &pctx->u.ahreq; ahash_request_set_callback(ahreq, aead_request_flags(req), gcm_hash_final_done, req); ahash_request_set_crypt(ahreq, NULL, pctx->iauth_tag, 0); return crypto_ahash_final(ahreq); } static void __gcm_hash_final_done(struct aead_request req, int err) { struct crypto_gcm_req_priv_ctx pctx = crypto_gcm_reqctx(req); struct crypto_gcm_ghash_ctx gctx = &pctx->ghash_ctx; if (!err) crypto_xor(pctx->auth_tag, pctx->iauth_tag, 16); gctx->complete(req, err); } static void gcm_hash_final_done(struct crypto_async_request areq, int err) { struct aead_request req = areq->data; __gcm_hash_final_done(req, err); } static void __gcm_hash_len_done(struct aead_request req, int err) { struct crypto_gcm_req_priv_ctx pctx = crypto_gcm_reqctx(req); if (!err) { err = gcm_hash_final(req, pctx); if (err == -EINPROGRESS \|\| err == -EBUSY) return; } __gcm_hash_final_done(req, err); } static void gcm_hash_len_done(struct crypto_async_request areq, int err) { struct aead_request req = areq->data; __gcm_hash_len_done(req, err); } static void __gcm_hash_crypt_remain_done(struct aead_request req, int err) { struct crypto_gcm_req_priv_ctx pctx = crypto_gcm_reqctx(req); if (!err) { err = gcm_hash_len(req, pctx); if (err == -EINPROGRESS \|\| err == -EBUSY) return; } __gcm_hash_len_done(req, err); } static void gcm_hash_crypt_remain_done(struct crypto_async_request areq, int err) { struct aead_request req = areq->data; __gcm_hash_crypt_remain_done(req, err); } static void __gcm_hash_crypt_done(struct aead_request req, int err) { struct crypto_gcm_req_priv_ctx pctx = crypto_gcm_reqctx(req); struct crypto_gcm_ghash_ctx gctx = &pctx->ghash_ctx; unsigned int remain; if (!err) { remain = gcm_remain(gctx->cryptlen); BUG_ON(!remain); err = gcm_hash_remain(req, pctx, remain, gcm_hash_crypt_remain_done); if (err == -EINPROGRESS \|\| err == -EBUSY) return; } __gcm_hash_crypt_remain_done(req, err); } static void gcm_hash_crypt_done(struct crypto_async_request areq, int err) { struct aead_request req = areq->data; __gcm_hash_crypt_done(req, err); } static void __gcm_hash_assoc_remain_done(struct aead_request req, int err) { struct crypto_gcm_req_priv_ctx pctx = crypto_gcm_reqctx(req); struct crypto_gcm_ghash_ctx gctx = &pctx->ghash_ctx; crypto_completion_t compl; unsigned int remain = 0; if (!err && gctx->cryptlen) { remain = gcm_remain(gctx->cryptlen); compl = remain ? gcm_hash_crypt_done : gcm_hash_crypt_remain_done; err = gcm_hash_update(req, pctx, compl, gctx->src, gctx->cryptlen); if (err == -EINPROGRESS \|\| err == -EBUSY) return; } if (remain) __gcm_hash_crypt_done(req, err); else __gcm_hash_crypt_remain_done(req, err); } static void gcm_hash_assoc_remain_done(struct crypto_async_request areq, int err) { struct aead_request req = areq->data; __gcm_hash_assoc_remain_done(req, err); } static void __gcm_hash_assoc_done(struct aead_request req, int err) { struct crypto_gcm_req_priv_ctx pctx = crypto_gcm_reqctx(req); unsigned int remain; if (!err) { remain = gcm_remain(req->assoclen); BUG_ON(!remain); err = gcm_hash_remain(req, pctx, remain, gcm_hash_assoc_remain_done); if (err == -EINPROGRESS \|\| err == -EBUSY) return; } __gcm_hash_assoc_remain_done(req, err); } static void gcm_hash_assoc_done(struct crypto_async_request areq, int err) { struct aead_request req = areq->data; __gcm_hash_assoc_done(req, err); } static void __gcm_hash_init_done(struct aead_request req, int err) { struct crypto_gcm_req_priv_ctx pctx = crypto_gcm_reqctx(req); crypto_completion_t compl; unsigned int remain = 0; if (!err && req->assoclen) { remain = gcm_remain(req->assoclen); compl = remain ? gcm_hash_assoc_done : gcm_hash_assoc_remain_done; err = gcm_hash_update(req, pctx, compl, req->assoc, req->assoclen); if (err == -EINPROGRESS \|\| err == -EBUSY) return; } if (remain) __gcm_hash_assoc_done(req, err); else __gcm_hash_assoc_remain_done(req, err); } static void gcm_hash_init_done(struct crypto_async_request areq, int err) { struct aead_request req = areq->data; __gcm_hash_init_done(req, err); } static int gcm_hash(struct aead_request req, struct crypto_gcm_req_priv_ctx pctx) { struct ahash_request ahreq = &pctx->u.ahreq; struct crypto_gcm_ghash_ctx gctx = &pctx->ghash_ctx; struct crypto_gcm_ctx ctx = crypto_tfm_ctx(req->base.tfm); unsigned int remain; crypto_completion_t compl; int err; ahash_request_set_tfm(ahreq, ctx->ghash); ahash_request_set_callback(ahreq, aead_request_flags(req), gcm_hash_init_done, req); err = crypto_ahash_init(ahreq); if (err) return err; remain = gcm_remain(req->assoclen); compl = remain ? gcm_hash_assoc_done : gcm_hash_assoc_remain_done; err = gcm_hash_update(req, pctx, compl, req->assoc, req->assoclen); if (err) return err; if (remain) { err = gcm_hash_remain(req, pctx, remain, gcm_hash_assoc_remain_done); if (err) return err; } remain = gcm_remain(gctx->cryptlen); compl = remain ? gcm_hash_crypt_done : gcm_hash_crypt_remain_done; err = gcm_hash_update(req, pctx, compl, gctx->src, gctx->cryptlen); if (err) return err; if (remain) { err = gcm_hash_remain(req, pctx, remain, gcm_hash_crypt_remain_done); if (err) return err; } err = gcm_hash_len(req, pctx); if (err) return err; err = gcm_hash_final(req, pctx); if (err) return err; return 0; } static void gcm_enc_copy_hash(struct aead_request req, struct crypto_gcm_req_priv_ctx pctx) { struct crypto_aead aead = crypto_aead_reqtfm(req); u8 auth_tag = pctx->auth_tag; scatterwalk_map_and_copy(auth_tag, req->dst, req->cryptlen, crypto_aead_authsize(aead), 1); } static void gcm_enc_hash_done(struct aead_request req, int err) { struct crypto_gcm_req_priv_ctx pctx = crypto_gcm_reqctx(req); if (!err) gcm_enc_copy_hash(req, pctx); aead_request_complete(req, err); } static void gcm_encrypt_done(struct crypto_async_request areq, int err) { struct aead_request req = areq->data; struct crypto_gcm_req_priv_ctx pctx = crypto_gcm_reqctx(req); if (!err) { err = gcm_hash(req, pctx); if (err == -EINPROGRESS \|\| err == -EBUSY) return; else if (!err) { crypto_xor(pctx->auth_tag, pctx->iauth_tag, 16); gcm_enc_copy_hash(req, pctx); } } aead_request_complete(req, err); } static int crypto_gcm_encrypt(struct aead_request req) { struct crypto_gcm_req_priv_ctx pctx = crypto_gcm_reqctx(req); struct ablkcipher_request abreq = &pctx->u.abreq; struct crypto_gcm_ghash_ctx gctx = &pctx->ghash_ctx; int err; crypto_gcm_init_crypt(abreq, req, req->cryptlen); ablkcipher_request_set_callback(abreq, aead_request_flags(req), gcm_encrypt_done, req); gctx->src = req->dst; gctx->cryptlen = req->cryptlen; gctx->complete = gcm_enc_hash_done; err = crypto_ablkcipher_encrypt(abreq); if (err) return err; err = gcm_hash(req, pctx); if (err) return err; crypto_xor(pctx->auth_tag, pctx->iauth_tag, 16); gcm_enc_copy_hash(req, pctx); return 0; } static int crypto_gcm_verify(struct aead_request req, struct crypto_gcm_req_priv_ctx pctx) { struct crypto_aead aead = crypto_aead_reqtfm(req); u8 auth_tag = pctx->auth_tag; u8 iauth_tag = pctx->iauth_tag; unsigned int authsize = crypto_aead_authsize(aead); unsigned int cryptlen = req->cryptlen - authsize; crypto_xor(auth_tag, iauth_tag, 16); scatterwalk_map_and_copy(iauth_tag, req->src, cryptlen, authsize, 0); return crypto_memneq(iauth_tag, auth_tag, authsize) ? -EBADMSG : 0; } static void gcm_decrypt_done(struct crypto_async_request areq, int err) { struct aead_request req = areq->data; struct crypto_gcm_req_priv_ctx pctx = crypto_gcm_reqctx(req); if (!err) err = crypto_gcm_verify(req, pctx); aead_request_complete(req, err); } static void gcm_dec_hash_done(struct aead_request req, int err) { struct crypto_gcm_req_priv_ctx pctx = crypto_gcm_reqctx(req); struct ablkcipher_request abreq = &pctx->u.abreq; struct crypto_gcm_ghash_ctx gctx = &pctx->ghash_ctx; if (!err) { ablkcipher_request_set_callback(abreq, aead_request_flags(req), gcm_decrypt_done, req); crypto_gcm_init_crypt(abreq, req, gctx->cryptlen); err = crypto_ablkcipher_decrypt(abreq); if (err == -EINPROGRESS \|\| err == -EBUSY) return; else if (!err) err = crypto_gcm_verify(req, pctx); } aead_request_complete(req, err); } static int crypto_gcm_decrypt(struct aead_request req) { struct crypto_aead aead = crypto_aead_reqtfm(req); struct crypto_gcm_req_priv_ctx pctx = crypto_gcm_reqctx(req); struct ablkcipher_request abreq = &pctx->u.abreq; struct crypto_gcm_ghash_ctx gctx = &pctx->ghash_ctx; unsigned int authsize = crypto_aead_authsize(aead); unsigned int cryptlen = req->cryptlen; int err; if (cryptlen < authsize) return -EINVAL; cryptlen -= authsize; gctx->src = req->src; gctx->cryptlen = cryptlen; gctx->complete = gcm_dec_hash_done; err = gcm_hash(req, pctx); if (err) return err; ablkcipher_request_set_callback(abreq, aead_request_flags(req), gcm_decrypt_done, req); crypto_gcm_init_crypt(abreq, req, cryptlen); err = crypto_ablkcipher_decrypt(abreq); if (err) return err; return crypto_gcm_verify(req, pctx); } static int crypto_gcm_init_tfm(struct crypto_tfm tfm) { struct crypto_instance inst = (void )tfm->__crt_alg; struct gcm_instance_ctx ictx = crypto_instance_ctx(inst); struct crypto_gcm_ctx ctx = crypto_tfm_ctx(tfm); struct crypto_ablkcipher ctr; struct crypto_ahash ghash; unsigned long align; int err; ghash = crypto_spawn_ahash(&ictx->ghash); if (IS_ERR(ghash)) return PTR_ERR(ghash); ctr = crypto_spawn_skcipher(&ictx->ctr); err = PTR_ERR(ctr); if (IS_ERR(ctr)) goto err_free_hash; ctx->ctr = ctr; ctx->ghash = ghash; align = crypto_tfm_alg_alignmask(tfm); align &= ~(crypto_tfm_ctx_alignment() - 1); tfm->crt_aead.reqsize = align + offsetof(struct crypto_gcm_req_priv_ctx, u) + max(sizeof(struct ablkcipher_request) + crypto_ablkcipher_reqsize(ctr), sizeof(struct ahash_request) + crypto_ahash_reqsize(ghash)); return 0; err_free_hash: crypto_free_ahash(ghash); return err; } static void crypto_gcm_exit_tfm(struct crypto_tfm tfm) { struct crypto_gcm_ctx ctx = crypto_tfm_ctx(tfm); crypto_free_ahash(ctx->ghash); crypto_free_ablkcipher(ctx->ctr); } static struct crypto_instance crypto_gcm_alloc_common(struct rtattr tb, const char full_name, const char ctr_name, const char ghash_name) { struct crypto_attr_type algt; struct crypto_instance inst; struct crypto_alg ctr; struct crypto_alg ghash_alg; struct ahash_alg ghash_ahash_alg; struct gcm_instance_ctx ctx; int err; algt = crypto_get_attr_type(tb); if (IS_ERR(algt)) return ERR_CAST(algt); if ((algt->type ^ CRYPTO_ALG_TYPE_AEAD) & algt->mask) return ERR_PTR(-EINVAL); ghash_alg = crypto_find_alg(ghash_name, &crypto_ahash_type, CRYPTO_ALG_TYPE_HASH, CRYPTO_ALG_TYPE_AHASH_MASK); if (IS_ERR(ghash_alg)) return ERR_CAST(ghash_alg); err = -ENOMEM; inst = kzalloc(sizeof(inst) + sizeof(ctx), GFP_KERNEL); if (!inst) goto out_put_ghash; ctx = crypto_instance_ctx(inst); ghash_ahash_alg = container_of(ghash_alg, struct ahash_alg, halg.base); err = crypto_init_ahash_spawn(&ctx->ghash, &ghash_ahash_alg->halg, inst); if (err) goto err_free_inst; crypto_set_skcipher_spawn(&ctx->ctr, inst); err = crypto_grab_skcipher(&ctx->ctr, ctr_name, 0, crypto_requires_sync(algt->type, algt->mask)); if (err) goto err_drop_ghash; ctr = crypto_skcipher_spawn_alg(&ctx->ctr); /* We only support 16-byte blocks. / if (ctr->cra_ablkcipher.ivsize != 16) goto out_put_ctr; / Not a stream cipher? / err = -EINVAL; if (ctr->cra_blocksize != 1) goto out_put_ctr; err = -ENAMETOOLONG; if (snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, "gcm_base(%s,%s)", ctr->cra_driver_name, ghash_alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME) goto out_put_ctr; memcpy(inst->alg.cra_name, full_name, CRYPTO_MAX_ALG_NAME); inst->alg.cra_flags = CRYPTO_ALG_TYPE_AEAD; inst->alg.cra_flags \|= ctr->cra_flags & CRYPTO_ALG_ASYNC; inst->alg.cra_priority = ctr->cra_priority; inst->alg.cra_blocksize = 1; inst->alg.cra_alignmask = ctr->cra_alignmask \| (__alignof__(u64) - 1); inst->alg.cra_type = &crypto_aead_type; inst->alg.cra_aead.ivsize = 16; inst->alg.cra_aead.maxauthsize = 16; inst->alg.cra_ctxsize = sizeof(struct crypto_gcm_ctx); inst->alg.cra_init = crypto_gcm_init_tfm; inst->alg.cra_exit = crypto_gcm_exit_tfm; inst->alg.cra_aead.setkey = crypto_gcm_setkey; inst->alg.cra_aead.setauthsize = crypto_gcm_setauthsize; inst->alg.cra_aead.encrypt = crypto_gcm_encrypt; inst->alg.cra_aead.decrypt = crypto_gcm_decrypt; out: crypto_mod_put(ghash_alg); return inst; out_put_ctr: crypto_drop_skcipher(&ctx->ctr); err_drop_ghash: crypto_drop_ahash(&ctx->ghash); err_free_inst: kfree(inst); out_put_ghash: inst = ERR_PTR(err); goto out; } static struct crypto_instance crypto_gcm_alloc(struct rtattr *tb) { const char cipher_name; char ctr_name[CRYPTO_MAX_ALG_NAME]; char full_name[CRYPTO_MAX_ALG_NAME]; cipher_name = crypto_attr_alg_name(tb[1]); if (IS_ERR(cipher_name)) return ERR_CAST(cipher_name); if (snprintf(ctr_name, CRYPTO_MAX_ALG_NAME, "ctr(%s)", cipher_name) >= CRYPTO_MAX_ALG_NAME) return ERR_PTR(-ENAMETOOLONG); if (snprintf(full_name, CRYPTO_MAX_ALG_NAME, "gcm(%s)", cipher_name) >= CRYPTO_MAX_ALG_NAME) return ERR_PTR(-ENAMETOOLONG); return crypto_gcm_alloc_common(tb, full_name, ctr_name, "ghash"); } static void crypto_gcm_free(struct crypto_instance inst) { struct gcm_instance_ctx ctx = crypto_instance_ctx(inst); crypto_drop_skcipher(&ctx->ctr); crypto_drop_ahash(&ctx->ghash); kfree(inst); } static struct crypto_template crypto_gcm_tmpl = { .name = "gcm", .alloc = crypto_gcm_alloc, .free = crypto_gcm_free, .module = THIS_MODULE, }; static struct crypto_instance crypto_gcm_base_alloc(struct rtattr tb) { const char ctr_name; const char ghash_name; char full_name[CRYPTO_MAX_ALG_NAME]; ctr_name = crypto_attr_alg_name(tb[1]); if (IS_ERR(ctr_name)) return ERR_CAST(ctr_name); ghash_name = crypto_attr_alg_name(tb[2]); if (IS_ERR(ghash_name)) return ERR_CAST(ghash_name); if (snprintf(full_name, CRYPTO_MAX_ALG_NAME, "gcm_base(%s,%s)", ctr_name, ghash_name) >= CRYPTO_MAX_ALG_NAME) return ERR_PTR(-ENAMETOOLONG); return crypto_gcm_alloc_common(tb, full_name, ctr_name, ghash_name); } static struct crypto_template crypto_gcm_base_tmpl = { .name = "gcm_base", .alloc = crypto_gcm_base_alloc, .free = crypto_gcm_free, .module = THIS_MODULE, }; static int crypto_rfc4106_setkey(struct crypto_aead parent, const u8 key, unsigned int keylen) { struct crypto_rfc4106_ctx ctx = crypto_aead_ctx(parent); struct crypto_aead child = ctx->child; int err; if (keylen < 4) return -EINVAL; keylen -= 4; memcpy(ctx->nonce, key + keylen, 4); crypto_aead_clear_flags(child, CRYPTO_TFM_REQ_MASK); crypto_aead_set_flags(child, crypto_aead_get_flags(parent) & CRYPTO_TFM_REQ_MASK); err = crypto_aead_setkey(child, key, keylen); crypto_aead_set_flags(parent, crypto_aead_get_flags(child) & CRYPTO_TFM_RES_MASK); return err; } static int crypto_rfc4106_setauthsize(struct crypto_aead parent, unsigned int authsize) { struct crypto_rfc4106_ctx ctx = crypto_aead_ctx(parent); switch (authsize) { case 8: case 12: case 16: break; default: return -EINVAL; } return crypto_aead_setauthsize(ctx->child, authsize); } static struct aead_request crypto_rfc4106_crypt(struct aead_request req) { struct aead_request subreq = aead_request_ctx(req); struct crypto_aead aead = crypto_aead_reqtfm(req); struct crypto_rfc4106_ctx ctx = crypto_aead_ctx(aead); struct crypto_aead child = ctx->child; u8 iv = PTR_ALIGN((u8 )(subreq + 1) + crypto_aead_reqsize(child), crypto_aead_alignmask(child) + 1); memcpy(iv, ctx->nonce, 4); memcpy(iv + 4, req->iv, 8); aead_request_set_tfm(subreq, child); aead_request_set_callback(subreq, req->base.flags, req->base.complete, req->base.data); aead_request_set_crypt(subreq, req->src, req->dst, req->cryptlen, iv); aead_request_set_assoc(subreq, req->assoc, req->assoclen); return subreq; } static int crypto_rfc4106_encrypt(struct aead_request req) { req = crypto_rfc4106_crypt(req); return crypto_aead_encrypt(req); } static int crypto_rfc4106_decrypt(struct aead_request req) { req = crypto_rfc4106_crypt(req); return crypto_aead_decrypt(req); } static int crypto_rfc4106_init_tfm(struct crypto_tfm tfm) { struct crypto_instance inst = (void )tfm->__crt_alg; struct crypto_aead_spawn spawn = crypto_instance_ctx(inst); struct crypto_rfc4106_ctx ctx = crypto_tfm_ctx(tfm); struct crypto_aead aead; unsigned long align; aead = crypto_spawn_aead(spawn); if (IS_ERR(aead)) return PTR_ERR(aead); ctx->child = aead; align = crypto_aead_alignmask(aead); align &= ~(crypto_tfm_ctx_alignment() - 1); tfm->crt_aead.reqsize = sizeof(struct aead_request) + ALIGN(crypto_aead_reqsize(aead), crypto_tfm_ctx_alignment()) + align + 16; return 0; } static void crypto_rfc4106_exit_tfm(struct crypto_tfm tfm) { struct crypto_rfc4106_ctx ctx = crypto_tfm_ctx(tfm); crypto_free_aead(ctx->child); } static struct crypto_instance crypto_rfc4106_alloc(struct rtattr *tb) { struct crypto_attr_type algt; struct crypto_instance inst; struct crypto_aead_spawn spawn; struct crypto_alg alg; const char ccm_name; int err; algt = crypto_get_attr_type(tb); if (IS_ERR(algt)) return ERR_CAST(algt); if ((algt->type ^ CRYPTO_ALG_TYPE_AEAD) & algt->mask) return ERR_PTR(-EINVAL); ccm_name = crypto_attr_alg_name(tb[1]); if (IS_ERR(ccm_name)) return ERR_CAST(ccm_name); inst = kzalloc(sizeof(inst) + sizeof(spawn), GFP_KERNEL); if (!inst) return ERR_PTR(-ENOMEM); spawn = crypto_instance_ctx(inst); crypto_set_aead_spawn(spawn, inst); err = crypto_grab_aead(spawn, ccm_name, 0, crypto_requires_sync(algt->type, algt->mask)); if (err) goto out_free_inst; alg = crypto_aead_spawn_alg(spawn); err = -EINVAL; /* We only support 16-byte blocks. / if (alg->cra_aead.ivsize != 16) goto out_drop_alg; / Not a stream cipher? / if (alg->cra_blocksize != 1) goto out_drop_alg; err = -ENAMETOOLONG; if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, "rfc4106(%s)", alg->cra_name) >= CRYPTO_MAX_ALG_NAME \|\| snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, "rfc4106(%s)", alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME) goto out_drop_alg; inst->alg.cra_flags = CRYPTO_ALG_TYPE_AEAD; inst->alg.cra_flags \|= alg->cra_flags & CRYPTO_ALG_ASYNC; inst->alg.cra_priority = alg->cra_priority; inst->alg.cra_blocksize = 1; inst->alg.cra_alignmask = alg->cra_alignmask; inst->alg.cra_type = &crypto_nivaead_type; inst->alg.cra_aead.ivsize = 8; inst->alg.cra_aead.maxauthsize = 16; inst->alg.cra_ctxsize = sizeof(struct crypto_rfc4106_ctx); inst->alg.cra_init = crypto_rfc4106_init_tfm; inst->alg.cra_exit = crypto_rfc4106_exit_tfm; inst->alg.cra_aead.setkey = crypto_rfc4106_setkey; inst->alg.cra_aead.setauthsize = crypto_rfc4106_setauthsize; inst->alg.cra_aead.encrypt = crypto_rfc4106_encrypt; inst->alg.cra_aead.decrypt = crypto_rfc4106_decrypt; inst->alg.cra_aead.geniv = "seqiv"; out: return inst; out_drop_alg: crypto_drop_aead(spawn); out_free_inst: kfree(inst); inst = ERR_PTR(err); goto out; } static void crypto_rfc4106_free(struct crypto_instance inst) { crypto_drop_spawn(crypto_instance_ctx(inst)); kfree(inst); } static struct crypto_template crypto_rfc4106_tmpl = { .name = "rfc4106", .alloc = crypto_rfc4106_alloc, .free = crypto_rfc4106_free, .module = THIS_MODULE, }; static inline struct crypto_rfc4543_req_ctx crypto_rfc4543_reqctx( struct aead_request req) { unsigned long align = crypto_aead_alignmask(crypto_aead_reqtfm(req)); return (void )PTR_ALIGN((u8 )aead_request_ctx(req), align + 1); } static int crypto_rfc4543_setkey(struct crypto_aead parent, const u8 key, unsigned int keylen) { struct crypto_rfc4543_ctx ctx = crypto_aead_ctx(parent); struct crypto_aead child = ctx->child; int err; if (keylen < 4) return -EINVAL; keylen -= 4; memcpy(ctx->nonce, key + keylen, 4); crypto_aead_clear_flags(child, CRYPTO_TFM_REQ_MASK); crypto_aead_set_flags(child, crypto_aead_get_flags(parent) & CRYPTO_TFM_REQ_MASK); err = crypto_aead_setkey(child, key, keylen); crypto_aead_set_flags(parent, crypto_aead_get_flags(child) & CRYPTO_TFM_RES_MASK); return err; } static int crypto_rfc4543_setauthsize(struct crypto_aead parent, unsigned int authsize) { struct crypto_rfc4543_ctx ctx = crypto_aead_ctx(parent); if (authsize != 16) return -EINVAL; return crypto_aead_setauthsize(ctx->child, authsize); } static void crypto_rfc4543_done(struct crypto_async_request areq, int err) { struct aead_request req = areq->data; struct crypto_aead aead = crypto_aead_reqtfm(req); struct crypto_rfc4543_req_ctx rctx = crypto_rfc4543_reqctx(req); if (!err) { scatterwalk_map_and_copy(rctx->auth_tag, req->dst, req->cryptlen, crypto_aead_authsize(aead), 1); } aead_request_complete(req, err); } static struct aead_request crypto_rfc4543_crypt(struct aead_request req, bool enc) { struct crypto_aead aead = crypto_aead_reqtfm(req); struct crypto_rfc4543_ctx ctx = crypto_aead_ctx(aead); struct crypto_rfc4543_req_ctx rctx = crypto_rfc4543_reqctx(req); struct aead_request subreq = &rctx->subreq; struct scatterlist src = req->src; struct scatterlist cipher = rctx->cipher; struct scatterlist payload = rctx->payload; struct scatterlist assoc = rctx->assoc; unsigned int authsize = crypto_aead_authsize(aead); unsigned int assoclen = req->assoclen; struct page srcp; u8 vsrc; u8 iv = PTR_ALIGN((u8 )(rctx + 1) + crypto_aead_reqsize(ctx->child), crypto_aead_alignmask(ctx->child) + 1); memcpy(iv, ctx->nonce, 4); memcpy(iv + 4, req->iv, 8); /* construct cipher/plaintext / if (enc) memset(rctx->auth_tag, 0, authsize); else scatterwalk_map_and_copy(rctx->auth_tag, src, req->cryptlen - authsize, authsize, 0); sg_init_one(cipher, rctx->auth_tag, authsize); / construct the aad / srcp = sg_page(src); vsrc = PageHighMem(srcp) ? NULL : page_address(srcp) + src->offset; sg_init_table(payload, 2); sg_set_buf(payload, req->iv, 8); scatterwalk_crypto_chain(payload, src, vsrc == req->iv + 8, 2); assoclen += 8 + req->cryptlen - (enc ? 0 : authsize); if (req->assoc->length == req->assoclen) { sg_init_table(assoc, 2); sg_set_page(assoc, sg_page(req->assoc), req->assoc->length, req->assoc->offset); } else { BUG_ON(req->assoclen > sizeof(rctx->assocbuf)); scatterwalk_map_and_copy(rctx->assocbuf, req->assoc, 0, req->assoclen, 0); sg_init_table(assoc, 2); sg_set_buf(assoc, rctx->assocbuf, req->assoclen); } scatterwalk_crypto_chain(assoc, payload, 0, 2); aead_request_set_tfm(subreq, ctx->child); aead_request_set_callback(subreq, req->base.flags, crypto_rfc4543_done, req); aead_request_set_crypt(subreq, cipher, cipher, enc ? 0 : authsize, iv); aead_request_set_assoc(subreq, assoc, assoclen); return subreq; } static int crypto_rfc4543_copy_src_to_dst(struct aead_request req, bool enc) { struct crypto_aead aead = crypto_aead_reqtfm(req); struct crypto_rfc4543_ctx ctx = crypto_aead_ctx(aead); unsigned int authsize = crypto_aead_authsize(aead); unsigned int nbytes = req->cryptlen - (enc ? 0 : authsize); struct blkcipher_desc desc = { .tfm = ctx->null, }; return crypto_blkcipher_encrypt(&desc, req->dst, req->src, nbytes); } static int crypto_rfc4543_encrypt(struct aead_request req) { struct crypto_aead aead = crypto_aead_reqtfm(req); struct crypto_rfc4543_req_ctx rctx = crypto_rfc4543_reqctx(req); struct aead_request subreq; int err; if (req->src != req->dst) { err = crypto_rfc4543_copy_src_to_dst(req, true); if (err) return err; } subreq = crypto_rfc4543_crypt(req, true); err = crypto_aead_encrypt(subreq); if (err) return err; scatterwalk_map_and_copy(rctx->auth_tag, req->dst, req->cryptlen, crypto_aead_authsize(aead), 1); return 0; } static int crypto_rfc4543_decrypt(struct aead_request req) { int err; if (req->src != req->dst) { err = crypto_rfc4543_copy_src_to_dst(req, false); if (err) return err; } req = crypto_rfc4543_crypt(req, false); return crypto_aead_decrypt(req); } static int crypto_rfc4543_init_tfm(struct crypto_tfm tfm) { struct crypto_instance inst = (void )tfm->__crt_alg; struct crypto_rfc4543_instance_ctx ictx = crypto_instance_ctx(inst); struct crypto_aead_spawn spawn = &ictx->aead; struct crypto_rfc4543_ctx ctx = crypto_tfm_ctx(tfm); struct crypto_aead aead; struct crypto_blkcipher null; unsigned long align; int err = 0; aead = crypto_spawn_aead(spawn); if (IS_ERR(aead)) return PTR_ERR(aead); null = crypto_spawn_blkcipher(&ictx->null.base); err = PTR_ERR(null); if (IS_ERR(null)) goto err_free_aead; ctx->child = aead; ctx->null = null; align = crypto_aead_alignmask(aead); align &= ~(crypto_tfm_ctx_alignment() - 1); tfm->crt_aead.reqsize = sizeof(struct crypto_rfc4543_req_ctx) + ALIGN(crypto_aead_reqsize(aead), crypto_tfm_ctx_alignment()) + align + 16; return 0; err_free_aead: crypto_free_aead(aead); return err; } static void crypto_rfc4543_exit_tfm(struct crypto_tfm tfm) { struct crypto_rfc4543_ctx ctx = crypto_tfm_ctx(tfm); crypto_free_aead(ctx->child); crypto_free_blkcipher(ctx->null); } static struct crypto_instance crypto_rfc4543_alloc(struct rtattr *tb) { struct crypto_attr_type algt; struct crypto_instance inst; struct crypto_aead_spawn spawn; struct crypto_alg alg; struct crypto_rfc4543_instance_ctx ctx; const char ccm_name; int err; algt = crypto_get_attr_type(tb); if (IS_ERR(algt)) return ERR_CAST(algt); if ((algt->type ^ CRYPTO_ALG_TYPE_AEAD) & algt->mask) return ERR_PTR(-EINVAL); ccm_name = crypto_attr_alg_name(tb[1]); if (IS_ERR(ccm_name)) return ERR_CAST(ccm_name); inst = kzalloc(sizeof(inst) + sizeof(ctx), GFP_KERNEL); if (!inst) return ERR_PTR(-ENOMEM); ctx = crypto_instance_ctx(inst); spawn = &ctx->aead; crypto_set_aead_spawn(spawn, inst); err = crypto_grab_aead(spawn, ccm_name, 0, crypto_requires_sync(algt->type, algt->mask)); if (err) goto out_free_inst; alg = crypto_aead_spawn_alg(spawn); crypto_set_skcipher_spawn(&ctx->null, inst); err = crypto_grab_skcipher(&ctx->null, "ecb(cipher_null)", 0, CRYPTO_ALG_ASYNC); if (err) goto out_drop_alg; crypto_skcipher_spawn_alg(&ctx->null); err = -EINVAL; / We only support 16-byte blocks. / if (alg->cra_aead.ivsize != 16) goto out_drop_ecbnull; / Not a stream cipher? / if (alg->cra_blocksize != 1) goto out_drop_ecbnull; err = -ENAMETOOLONG; if (snprintf(inst->alg.cra_name, CRYPTO_MAX_ALG_NAME, "rfc4543(%s)", alg->cra_name) >= CRYPTO_MAX_ALG_NAME \|\| snprintf(inst->alg.cra_driver_name, CRYPTO_MAX_ALG_NAME, "rfc4543(%s)", alg->cra_driver_name) >= CRYPTO_MAX_ALG_NAME) goto out_drop_ecbnull; inst->alg.cra_flags = CRYPTO_ALG_TYPE_AEAD; inst->alg.cra_flags \|= alg->cra_flags & CRYPTO_ALG_ASYNC; inst->alg.cra_priority = alg->cra_priority; inst->alg.cra_blocksize = 1; inst->alg.cra_alignmask = alg->cra_alignmask; inst->alg.cra_type = &crypto_nivaead_type; inst->alg.cra_aead.ivsize = 8; inst->alg.cra_aead.maxauthsize = 16; inst->alg.cra_ctxsize = sizeof(struct crypto_rfc4543_ctx); inst->alg.cra_init = crypto_rfc4543_init_tfm; inst->alg.cra_exit = crypto_rfc4543_exit_tfm; inst->alg.cra_aead.setkey = crypto_rfc4543_setkey; inst->alg.cra_aead.setauthsize = crypto_rfc4543_setauthsize; inst->alg.cra_aead.encrypt = crypto_rfc4543_encrypt; inst->alg.cra_aead.decrypt = crypto_rfc4543_decrypt; inst->alg.cra_aead.geniv = "seqiv"; out: return inst; out_drop_ecbnull: crypto_drop_skcipher(&ctx->null); out_drop_alg: crypto_drop_aead(spawn); out_free_inst: kfree(inst); inst = ERR_PTR(err); goto out; } static void crypto_rfc4543_free(struct crypto_instance inst) { struct crypto_rfc4543_instance_ctx *ctx = crypto_instance_ctx(inst); crypto_drop_aead(&ctx->aead); crypto_drop_skcipher(&ctx->null); kfree(inst); } static struct crypto_template crypto_rfc4543_tmpl = { .name = "rfc4543", .alloc = crypto_rfc4543_alloc, .free = crypto_rfc4543_free, .module = THIS_MODULE, }; static int __init crypto_gcm_module_init(void) { int err; gcm_zeroes = kzalloc(16, GFP_KERNEL); if (!gcm_zeroes) return -ENOMEM; err = crypto_register_template(&crypto_gcm_base_tmpl); if (err) goto out; err = crypto_register_template(&crypto_gcm_tmpl); if (err) goto out_undo_base; err = crypto_register_template(&crypto_rfc4106_tmpl); if (err) goto out_undo_gcm; err = crypto_register_template(&crypto_rfc4543_tmpl); if (err) goto out_undo_rfc4106; return 0; out_undo_rfc4106: crypto_unregister_template(&crypto_rfc4106_tmpl); out_undo_gcm: crypto_unregister_template(&crypto_gcm_tmpl); out_undo_base: crypto_unregister_template(&crypto_gcm_base_tmpl); out: kfree(gcm_zeroes); return err; } static void __exit crypto_gcm_module_exit(void) { kfree(gcm_zeroes); crypto_unregister_template(&crypto_rfc4543_tmpl); crypto_unregister_template(&crypto_rfc4106_tmpl); crypto_unregister_template(&crypto_gcm_tmpl); crypto_unregister_template(&crypto_gcm_base_tmpl); } module_init(crypto_gcm_module_init); module_exit(crypto_gcm_module_exit); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("Galois/Counter Mode"); MODULE_AUTHOR("Mikko Herranen <mh1@iki.fi>"); MODULE_ALIAS_CRYPTO("gcm_base"); MODULE_ALIAS_CRYPTO("rfc4106"); MODULE_ALIAS_CRYPTO("rfc4543");	./CrossVul/dataset_final_sorted/CWE-264/c/bad_2399_13
crossvul-cpp_data_good_2399_20	/* * Modified to interface to the Linux kernel * Copyright (c) 2009, Intel Corporation. * * 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. * * This program is distributed in the hope it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for * more details. * * You should have received a copy of the GNU General Public License along with * this program; if not, write to the Free Software Foundation, Inc., 59 Temple * Place - Suite 330, Boston, MA 02111-1307 USA. / / -------------------------------------------------------------------------- * VMAC and VHASH Implementation by Ted Krovetz (tdk@acm.org) and Wei Dai. * This implementation is herby placed in the public domain. * The authors offers no warranty. Use at your own risk. * Please send bug reports to the authors. * Last modified: 17 APR 08, 1700 PDT * ----------------------------------------------------------------------- / #include <linux/init.h> #include <linux/types.h> #include <linux/crypto.h> #include <linux/module.h> #include <linux/scatterlist.h> #include <asm/byteorder.h> #include <crypto/scatterwalk.h> #include <crypto/vmac.h> #include <crypto/internal/hash.h> / * Constants and masks / #define UINT64_C(x) x##ULL static const u64 p64 = UINT64_C(0xfffffffffffffeff); / 2^64 - 257 prime / static const u64 m62 = UINT64_C(0x3fffffffffffffff); / 62-bit mask / static const u64 m63 = UINT64_C(0x7fffffffffffffff); / 63-bit mask / static const u64 m64 = UINT64_C(0xffffffffffffffff); / 64-bit mask / static const u64 mpoly = UINT64_C(0x1fffffff1fffffff); / Poly key mask / #define pe64_to_cpup le64_to_cpup / Prefer little endian / #ifdef __LITTLE_ENDIAN #define INDEX_HIGH 1 #define INDEX_LOW 0 #else #define INDEX_HIGH 0 #define INDEX_LOW 1 #endif / * The following routines are used in this implementation. They are * written via macros to simulate zero-overhead call-by-reference. * * MUL64: 64x64->128-bit multiplication * PMUL64: assumes top bits cleared on inputs * ADD128: 128x128->128-bit addition / #define ADD128(rh, rl, ih, il) \ do { \ u64 _il = (il); \ (rl) += (_il); \ if ((rl) < (_il)) \ (rh)++; \ (rh) += (ih); \ } while (0) #define MUL32(i1, i2) ((u64)(u32)(i1)(u32)(i2)) #define PMUL64(rh, rl, i1, i2) /* Assumes m doesn't overflow / \ do { \ u64 _i1 = (i1), _i2 = (i2); \ u64 m = MUL32(_i1, _i2>>32) + MUL32(_i1>>32, _i2); \ rh = MUL32(_i1>>32, _i2>>32); \ rl = MUL32(_i1, _i2); \ ADD128(rh, rl, (m >> 32), (m << 32)); \ } while (0) #define MUL64(rh, rl, i1, i2) \ do { \ u64 _i1 = (i1), _i2 = (i2); \ u64 m1 = MUL32(_i1, _i2>>32); \ u64 m2 = MUL32(_i1>>32, _i2); \ rh = MUL32(_i1>>32, _i2>>32); \ rl = MUL32(_i1, _i2); \ ADD128(rh, rl, (m1 >> 32), (m1 << 32)); \ ADD128(rh, rl, (m2 >> 32), (m2 << 32)); \ } while (0) / * For highest performance the L1 NH and L2 polynomial hashes should be * carefully implemented to take advantage of one's target architecture. * Here these two hash functions are defined multiple time; once for * 64-bit architectures, once for 32-bit SSE2 architectures, and once * for the rest (32-bit) architectures. * For each, nh_16 must be defined (works on multiples of 16 bytes). * Optionally, nh_vmac_nhbytes can be defined (for multiples of * VMAC_NHBYTES), and nh_16_2 and nh_vmac_nhbytes_2 (versions that do two * NH computations at once). / #ifdef CONFIG_64BIT #define nh_16(mp, kp, nw, rh, rl) \ do { \ int i; u64 th, tl; \ rh = rl = 0; \ for (i = 0; i < nw; i += 2) { \ MUL64(th, tl, pe64_to_cpup((mp)+i)+(kp)[i], \ pe64_to_cpup((mp)+i+1)+(kp)[i+1]); \ ADD128(rh, rl, th, tl); \ } \ } while (0) #define nh_16_2(mp, kp, nw, rh, rl, rh1, rl1) \ do { \ int i; u64 th, tl; \ rh1 = rl1 = rh = rl = 0; \ for (i = 0; i < nw; i += 2) { \ MUL64(th, tl, pe64_to_cpup((mp)+i)+(kp)[i], \ pe64_to_cpup((mp)+i+1)+(kp)[i+1]); \ ADD128(rh, rl, th, tl); \ MUL64(th, tl, pe64_to_cpup((mp)+i)+(kp)[i+2], \ pe64_to_cpup((mp)+i+1)+(kp)[i+3]); \ ADD128(rh1, rl1, th, tl); \ } \ } while (0) #if (VMAC_NHBYTES >= 64) / These versions do 64-bytes of message at a time / #define nh_vmac_nhbytes(mp, kp, nw, rh, rl) \ do { \ int i; u64 th, tl; \ rh = rl = 0; \ for (i = 0; i < nw; i += 8) { \ MUL64(th, tl, pe64_to_cpup((mp)+i)+(kp)[i], \ pe64_to_cpup((mp)+i+1)+(kp)[i+1]); \ ADD128(rh, rl, th, tl); \ MUL64(th, tl, pe64_to_cpup((mp)+i+2)+(kp)[i+2], \ pe64_to_cpup((mp)+i+3)+(kp)[i+3]); \ ADD128(rh, rl, th, tl); \ MUL64(th, tl, pe64_to_cpup((mp)+i+4)+(kp)[i+4], \ pe64_to_cpup((mp)+i+5)+(kp)[i+5]); \ ADD128(rh, rl, th, tl); \ MUL64(th, tl, pe64_to_cpup((mp)+i+6)+(kp)[i+6], \ pe64_to_cpup((mp)+i+7)+(kp)[i+7]); \ ADD128(rh, rl, th, tl); \ } \ } while (0) #define nh_vmac_nhbytes_2(mp, kp, nw, rh, rl, rh1, rl1) \ do { \ int i; u64 th, tl; \ rh1 = rl1 = rh = rl = 0; \ for (i = 0; i < nw; i += 8) { \ MUL64(th, tl, pe64_to_cpup((mp)+i)+(kp)[i], \ pe64_to_cpup((mp)+i+1)+(kp)[i+1]); \ ADD128(rh, rl, th, tl); \ MUL64(th, tl, pe64_to_cpup((mp)+i)+(kp)[i+2], \ pe64_to_cpup((mp)+i+1)+(kp)[i+3]); \ ADD128(rh1, rl1, th, tl); \ MUL64(th, tl, pe64_to_cpup((mp)+i+2)+(kp)[i+2], \ pe64_to_cpup((mp)+i+3)+(kp)[i+3]); \ ADD128(rh, rl, th, tl); \ MUL64(th, tl, pe64_to_cpup((mp)+i+2)+(kp)[i+4], \ pe64_to_cpup((mp)+i+3)+(kp)[i+5]); \ ADD128(rh1, rl1, th, tl); \ MUL64(th, tl, pe64_to_cpup((mp)+i+4)+(kp)[i+4], \ pe64_to_cpup((mp)+i+5)+(kp)[i+5]); \ ADD128(rh, rl, th, tl); \ MUL64(th, tl, pe64_to_cpup((mp)+i+4)+(kp)[i+6], \ pe64_to_cpup((mp)+i+5)+(kp)[i+7]); \ ADD128(rh1, rl1, th, tl); \ MUL64(th, tl, pe64_to_cpup((mp)+i+6)+(kp)[i+6], \ pe64_to_cpup((mp)+i+7)+(kp)[i+7]); \ ADD128(rh, rl, th, tl); \ MUL64(th, tl, pe64_to_cpup((mp)+i+6)+(kp)[i+8], \ pe64_to_cpup((mp)+i+7)+(kp)[i+9]); \ ADD128(rh1, rl1, th, tl); \ } \ } while (0) #endif #define poly_step(ah, al, kh, kl, mh, ml) \ do { \ u64 t1h, t1l, t2h, t2l, t3h, t3l, z = 0; \ / compute abcd, put bd into result registers / \ PMUL64(t3h, t3l, al, kh); \ PMUL64(t2h, t2l, ah, kl); \ PMUL64(t1h, t1l, ah, 2kh); \ PMUL64(ah, al, al, kl); \ / add 2 * ac to result / \ ADD128(ah, al, t1h, t1l); \ / add together ad + bc / \ ADD128(t2h, t2l, t3h, t3l); \ / now (ah,al), (t2l,2t2h) need summing / \ /* first add the high registers, carrying into t2h / \ ADD128(t2h, ah, z, t2l); \ / double t2h and add top bit of ah / \ t2h = 2 t2h + (ah >> 63); \ ah &= m63; \ /* now add the low registers / \ ADD128(ah, al, mh, ml); \ ADD128(ah, al, z, t2h); \ } while (0) #else / ! CONFIG_64BIT / #ifndef nh_16 #define nh_16(mp, kp, nw, rh, rl) \ do { \ u64 t1, t2, m1, m2, t; \ int i; \ rh = rl = t = 0; \ for (i = 0; i < nw; i += 2) { \ t1 = pe64_to_cpup(mp+i) + kp[i]; \ t2 = pe64_to_cpup(mp+i+1) + kp[i+1]; \ m2 = MUL32(t1 >> 32, t2); \ m1 = MUL32(t1, t2 >> 32); \ ADD128(rh, rl, MUL32(t1 >> 32, t2 >> 32), \ MUL32(t1, t2)); \ rh += (u64)(u32)(m1 >> 32) \ + (u32)(m2 >> 32); \ t += (u64)(u32)m1 + (u32)m2; \ } \ ADD128(rh, rl, (t >> 32), (t << 32)); \ } while (0) #endif static void poly_step_func(u64 ahi, u64 alo, const u64 kh, const u64 kl, const u64 mh, const u64 ml) { #define a0 ((((u32 )alo)+INDEX_LOW)) #define a1 ((((u32 )alo)+INDEX_HIGH)) #define a2 ((((u32 )ahi)+INDEX_LOW)) #define a3 ((((u32 )ahi)+INDEX_HIGH)) #define k0 ((((u32 )kl)+INDEX_LOW)) #define k1 ((((u32 )kl)+INDEX_HIGH)) #define k2 ((((u32 )kh)+INDEX_LOW)) #define k3 ((((u32 )kh)+INDEX_HIGH)) u64 p, q, t; u32 t2; p = MUL32(a3, k3); p += p; p += (u64 )mh; p += MUL32(a0, k2); p += MUL32(a1, k1); p += MUL32(a2, k0); t = (u32)(p); p >>= 32; p += MUL32(a0, k3); p += MUL32(a1, k2); p += MUL32(a2, k1); p += MUL32(a3, k0); t \|= ((u64)((u32)p & 0x7fffffff)) << 32; p >>= 31; p += (u64)(((u32 )ml)[INDEX_LOW]); p += MUL32(a0, k0); q = MUL32(a1, k3); q += MUL32(a2, k2); q += MUL32(a3, k1); q += q; p += q; t2 = (u32)(p); p >>= 32; p += (u64)(((u32 )ml)[INDEX_HIGH]); p += MUL32(a0, k1); p += MUL32(a1, k0); q = MUL32(a2, k3); q += MUL32(a3, k2); q += q; p += q; (u64 )(alo) = (p << 32) \| t2; p >>= 32; (u64 )(ahi) = p + t; #undef a0 #undef a1 #undef a2 #undef a3 #undef k0 #undef k1 #undef k2 #undef k3 } #define poly_step(ah, al, kh, kl, mh, ml) \ poly_step_func(&(ah), &(al), &(kh), &(kl), &(mh), &(ml)) #endif / end of specialized NH and poly definitions / / At least nh_16 is defined. Defined others as needed here / #ifndef nh_16_2 #define nh_16_2(mp, kp, nw, rh, rl, rh2, rl2) \ do { \ nh_16(mp, kp, nw, rh, rl); \ nh_16(mp, ((kp)+2), nw, rh2, rl2); \ } while (0) #endif #ifndef nh_vmac_nhbytes #define nh_vmac_nhbytes(mp, kp, nw, rh, rl) \ nh_16(mp, kp, nw, rh, rl) #endif #ifndef nh_vmac_nhbytes_2 #define nh_vmac_nhbytes_2(mp, kp, nw, rh, rl, rh2, rl2) \ do { \ nh_vmac_nhbytes(mp, kp, nw, rh, rl); \ nh_vmac_nhbytes(mp, ((kp)+2), nw, rh2, rl2); \ } while (0) #endif static void vhash_abort(struct vmac_ctx ctx) { ctx->polytmp[0] = ctx->polykey[0] ; ctx->polytmp[1] = ctx->polykey[1] ; ctx->first_block_processed = 0; } static u64 l3hash(u64 p1, u64 p2, u64 k1, u64 k2, u64 len) { u64 rh, rl, t, z = 0; /* fully reduce (p1,p2)+(len,0) mod p127 / t = p1 >> 63; p1 &= m63; ADD128(p1, p2, len, t); / At this point, (p1,p2) is at most 2^127+(len<<64) / t = (p1 > m63) + ((p1 == m63) && (p2 == m64)); ADD128(p1, p2, z, t); p1 &= m63; / compute (p1,p2)/(2^64-2^32) and (p1,p2)%(2^64-2^32) / t = p1 + (p2 >> 32); t += (t >> 32); t += (u32)t > 0xfffffffeu; p1 += (t >> 32); p2 += (p1 << 32); / compute (p1+k1)%p64 and (p2+k2)%p64 / p1 += k1; p1 += (0 - (p1 < k1)) & 257; p2 += k2; p2 += (0 - (p2 < k2)) & 257; / compute (p1+k1)(p2+k2)%p64 / MUL64(rh, rl, p1, p2); t = rh >> 56; ADD128(t, rl, z, rh); rh <<= 8; ADD128(t, rl, z, rh); t += t << 8; rl += t; rl += (0 - (rl < t)) & 257; rl += (0 - (rl > p64-1)) & 257; return rl; } static void vhash_update(const unsigned char m, unsigned int mbytes, / Pos multiple of VMAC_NHBYTES / struct vmac_ctx ctx) { u64 rh, rl, mptr; const u64 kptr = (u64 )ctx->nhkey; int i; u64 ch, cl; u64 pkh = ctx->polykey[0]; u64 pkl = ctx->polykey[1]; if (!mbytes) return; BUG_ON(mbytes % VMAC_NHBYTES); mptr = (u64 )m; i = mbytes / VMAC_NHBYTES; /* Must be non-zero / ch = ctx->polytmp[0]; cl = ctx->polytmp[1]; if (!ctx->first_block_processed) { ctx->first_block_processed = 1; nh_vmac_nhbytes(mptr, kptr, VMAC_NHBYTES/8, rh, rl); rh &= m62; ADD128(ch, cl, rh, rl); mptr += (VMAC_NHBYTES/sizeof(u64)); i--; } while (i--) { nh_vmac_nhbytes(mptr, kptr, VMAC_NHBYTES/8, rh, rl); rh &= m62; poly_step(ch, cl, pkh, pkl, rh, rl); mptr += (VMAC_NHBYTES/sizeof(u64)); } ctx->polytmp[0] = ch; ctx->polytmp[1] = cl; } static u64 vhash(unsigned char m[], unsigned int mbytes, u64 tagl, struct vmac_ctx ctx) { u64 rh, rl, mptr; const u64 kptr = (u64 )ctx->nhkey; int i, remaining; u64 ch, cl; u64 pkh = ctx->polykey[0]; u64 pkl = ctx->polykey[1]; mptr = (u64 )m; i = mbytes / VMAC_NHBYTES; remaining = mbytes % VMAC_NHBYTES; if (ctx->first_block_processed) { ch = ctx->polytmp[0]; cl = ctx->polytmp[1]; } else if (i) { nh_vmac_nhbytes(mptr, kptr, VMAC_NHBYTES/8, ch, cl); ch &= m62; ADD128(ch, cl, pkh, pkl); mptr += (VMAC_NHBYTES/sizeof(u64)); i--; } else if (remaining) { nh_16(mptr, kptr, 2((remaining+15)/16), ch, cl); ch &= m62; ADD128(ch, cl, pkh, pkl); mptr += (VMAC_NHBYTES/sizeof(u64)); goto do_l3; } else {/* Empty String / ch = pkh; cl = pkl; goto do_l3; } while (i--) { nh_vmac_nhbytes(mptr, kptr, VMAC_NHBYTES/8, rh, rl); rh &= m62; poly_step(ch, cl, pkh, pkl, rh, rl); mptr += (VMAC_NHBYTES/sizeof(u64)); } if (remaining) { nh_16(mptr, kptr, 2((remaining+15)/16), rh, rl); rh &= m62; poly_step(ch, cl, pkh, pkl, rh, rl); } do_l3: vhash_abort(ctx); remaining = 8; return l3hash(ch, cl, ctx->l3key[0], ctx->l3key[1], remaining); } static u64 vmac(unsigned char m[], unsigned int mbytes, const unsigned char n[16], u64 tagl, struct vmac_ctx_t ctx) { u64 in_n, out_p; u64 p, h; int i; in_n = ctx->__vmac_ctx.cached_nonce; out_p = ctx->__vmac_ctx.cached_aes; i = n[15] & 1; if (((u64 )(n+8) != in_n[1]) \|\| ((u64 )(n) != in_n[0])) { in_n[0] = (u64 )(n); in_n[1] = (u64 )(n+8); ((unsigned char )in_n)[15] &= 0xFE; crypto_cipher_encrypt_one(ctx->child, (unsigned char )out_p, (unsigned char )in_n); ((unsigned char )in_n)[15] \|= (unsigned char)(1-i); } p = be64_to_cpup(out_p + i); h = vhash(m, mbytes, (u64 )0, &ctx->__vmac_ctx); return le64_to_cpu(p + h); } static int vmac_set_key(unsigned char user_key[], struct vmac_ctx_t ctx) { u64 in[2] = {0}, out[2]; unsigned i; int err = 0; err = crypto_cipher_setkey(ctx->child, user_key, VMAC_KEY_LEN); if (err) return err; / Fill nh key / ((unsigned char )in)[0] = 0x80; for (i = 0; i < sizeof(ctx->__vmac_ctx.nhkey)/8; i += 2) { crypto_cipher_encrypt_one(ctx->child, (unsigned char )out, (unsigned char )in); ctx->__vmac_ctx.nhkey[i] = be64_to_cpup(out); ctx->__vmac_ctx.nhkey[i+1] = be64_to_cpup(out+1); ((unsigned char )in)[15] += 1; } / Fill poly key / ((unsigned char )in)[0] = 0xC0; in[1] = 0; for (i = 0; i < sizeof(ctx->__vmac_ctx.polykey)/8; i += 2) { crypto_cipher_encrypt_one(ctx->child, (unsigned char )out, (unsigned char )in); ctx->__vmac_ctx.polytmp[i] = ctx->__vmac_ctx.polykey[i] = be64_to_cpup(out) & mpoly; ctx->__vmac_ctx.polytmp[i+1] = ctx->__vmac_ctx.polykey[i+1] = be64_to_cpup(out+1) & mpoly; ((unsigned char )in)[15] += 1; } / Fill ip key / ((unsigned char )in)[0] = 0xE0; in[1] = 0; for (i = 0; i < sizeof(ctx->__vmac_ctx.l3key)/8; i += 2) { do { crypto_cipher_encrypt_one(ctx->child, (unsigned char )out, (unsigned char )in); ctx->__vmac_ctx.l3key[i] = be64_to_cpup(out); ctx->__vmac_ctx.l3key[i+1] = be64_to_cpup(out+1); ((unsigned char )in)[15] += 1; } while (ctx->__vmac_ctx.l3key[i] >= p64 \|\| ctx->__vmac_ctx.l3key[i+1] >= p64); } / Invalidate nonce/aes cache and reset other elements / ctx->__vmac_ctx.cached_nonce[0] = (u64)-1; / Ensure illegal nonce / ctx->__vmac_ctx.cached_nonce[1] = (u64)0; / Ensure illegal nonce / ctx->__vmac_ctx.first_block_processed = 0; return err; } static int vmac_setkey(struct crypto_shash parent, const u8 key, unsigned int keylen) { struct vmac_ctx_t ctx = crypto_shash_ctx(parent); if (keylen != VMAC_KEY_LEN) { crypto_shash_set_flags(parent, CRYPTO_TFM_RES_BAD_KEY_LEN); return -EINVAL; } return vmac_set_key((u8 )key, ctx); } static int vmac_init(struct shash_desc pdesc) { return 0; } static int vmac_update(struct shash_desc pdesc, const u8 p, unsigned int len) { struct crypto_shash parent = pdesc->tfm; struct vmac_ctx_t ctx = crypto_shash_ctx(parent); int expand; int min; expand = VMAC_NHBYTES - ctx->partial_size > 0 ? VMAC_NHBYTES - ctx->partial_size : 0; min = len < expand ? len : expand; memcpy(ctx->partial + ctx->partial_size, p, min); ctx->partial_size += min; if (len < expand) return 0; vhash_update(ctx->partial, VMAC_NHBYTES, &ctx->__vmac_ctx); ctx->partial_size = 0; len -= expand; p += expand; if (len % VMAC_NHBYTES) { memcpy(ctx->partial, p + len - (len % VMAC_NHBYTES), len % VMAC_NHBYTES); ctx->partial_size = len % VMAC_NHBYTES; } vhash_update(p, len - len % VMAC_NHBYTES, &ctx->__vmac_ctx); return 0; } static int vmac_final(struct shash_desc pdesc, u8 out) { struct crypto_shash parent = pdesc->tfm; struct vmac_ctx_t ctx = crypto_shash_ctx(parent); vmac_t mac; u8 nonce[16] = {}; /* vmac() ends up accessing outside the array bounds that * we specify. In appears to access up to the next 2-word * boundary. We'll just be uber cautious and zero the * unwritten bytes in the buffer. / if (ctx->partial_size) { memset(ctx->partial + ctx->partial_size, 0, VMAC_NHBYTES - ctx->partial_size); } mac = vmac(ctx->partial, ctx->partial_size, nonce, NULL, ctx); memcpy(out, &mac, sizeof(vmac_t)); memzero_explicit(&mac, sizeof(vmac_t)); memset(&ctx->__vmac_ctx, 0, sizeof(struct vmac_ctx)); ctx->partial_size = 0; return 0; } static int vmac_init_tfm(struct crypto_tfm tfm) { struct crypto_cipher cipher; struct crypto_instance inst = (void )tfm->__crt_alg; struct crypto_spawn spawn = crypto_instance_ctx(inst); struct vmac_ctx_t ctx = crypto_tfm_ctx(tfm); cipher = crypto_spawn_cipher(spawn); if (IS_ERR(cipher)) return PTR_ERR(cipher); ctx->child = cipher; return 0; } static void vmac_exit_tfm(struct crypto_tfm tfm) { struct vmac_ctx_t ctx = crypto_tfm_ctx(tfm); crypto_free_cipher(ctx->child); } static int vmac_create(struct crypto_template tmpl, struct rtattr *tb) { struct shash_instance inst; struct crypto_alg *alg; int err; err = crypto_check_attr_type(tb, CRYPTO_ALG_TYPE_SHASH); if (err) return err; alg = crypto_get_attr_alg(tb, CRYPTO_ALG_TYPE_CIPHER, CRYPTO_ALG_TYPE_MASK); if (IS_ERR(alg)) return PTR_ERR(alg); inst = shash_alloc_instance("vmac", alg); err = PTR_ERR(inst); if (IS_ERR(inst)) goto out_put_alg; err = crypto_init_spawn(shash_instance_ctx(inst), alg, shash_crypto_instance(inst), CRYPTO_ALG_TYPE_MASK); if (err) goto out_free_inst; inst->alg.base.cra_priority = alg->cra_priority; inst->alg.base.cra_blocksize = alg->cra_blocksize; inst->alg.base.cra_alignmask = alg->cra_alignmask; inst->alg.digestsize = sizeof(vmac_t); inst->alg.base.cra_ctxsize = sizeof(struct vmac_ctx_t); inst->alg.base.cra_init = vmac_init_tfm; inst->alg.base.cra_exit = vmac_exit_tfm; inst->alg.init = vmac_init; inst->alg.update = vmac_update; inst->alg.final = vmac_final; inst->alg.setkey = vmac_setkey; err = shash_register_instance(tmpl, inst); if (err) { out_free_inst: shash_free_instance(shash_crypto_instance(inst)); } out_put_alg: crypto_mod_put(alg); return err; } static struct crypto_template vmac_tmpl = { .name = "vmac", .create = vmac_create, .free = shash_free_instance, .module = THIS_MODULE, }; static int __init vmac_module_init(void) { return crypto_register_template(&vmac_tmpl); } static void __exit vmac_module_exit(void) { crypto_unregister_template(&vmac_tmpl); } module_init(vmac_module_init); module_exit(vmac_module_exit); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("VMAC hash algorithm"); MODULE_ALIAS_CRYPTO("vmac");	./CrossVul/dataset_final_sorted/CWE-264/c/good_2399_20
crossvul-cpp_data_bad_1513_0	/* * PCI Backend - Functions for creating a virtual configuration space for * exported PCI Devices. * It's dangerous to allow PCI Driver Domains to change their * device's resources (memory, i/o ports, interrupts). We need to * restrict changes to certain PCI Configuration registers: * BARs, INTERRUPT_PIN, most registers in the header... * * Author: Ryan Wilson <hap9@epoch.ncsc.mil> / #include <linux/kernel.h> #include <linux/module.h> #include <linux/pci.h> #include "pciback.h" #include "conf_space.h" #include "conf_space_quirks.h" static bool permissive; module_param(permissive, bool, 0644); / This is where xen_pcibk_read_config_byte, xen_pcibk_read_config_word, * xen_pcibk_write_config_word, and xen_pcibk_write_config_byte are created. / #define DEFINE_PCI_CONFIG(op, size, type) \ int xen_pcibk_##op##_config_##size \ (struct pci_dev dev, int offset, type value, void data) \ { \ return pci_##op##_config_##size(dev, offset, value); \ } DEFINE_PCI_CONFIG(read, byte, u8 ) DEFINE_PCI_CONFIG(read, word, u16 ) DEFINE_PCI_CONFIG(read, dword, u32 ) DEFINE_PCI_CONFIG(write, byte, u8) DEFINE_PCI_CONFIG(write, word, u16) DEFINE_PCI_CONFIG(write, dword, u32) static int conf_space_read(struct pci_dev dev, const struct config_field_entry entry, int offset, u32 value) { int ret = 0; const struct config_field field = entry->field; value = 0; switch (field->size) { case 1: if (field->u.b.read) ret = field->u.b.read(dev, offset, (u8 ) value, entry->data); break; case 2: if (field->u.w.read) ret = field->u.w.read(dev, offset, (u16 ) value, entry->data); break; case 4: if (field->u.dw.read) ret = field->u.dw.read(dev, offset, value, entry->data); break; } return ret; } static int conf_space_write(struct pci_dev dev, const struct config_field_entry entry, int offset, u32 value) { int ret = 0; const struct config_field field = entry->field; switch (field->size) { case 1: if (field->u.b.write) ret = field->u.b.write(dev, offset, (u8) value, entry->data); break; case 2: if (field->u.w.write) ret = field->u.w.write(dev, offset, (u16) value, entry->data); break; case 4: if (field->u.dw.write) ret = field->u.dw.write(dev, offset, value, entry->data); break; } return ret; } static inline u32 get_mask(int size) { if (size == 1) return 0xff; else if (size == 2) return 0xffff; else return 0xffffffff; } static inline int valid_request(int offset, int size) { /* Validate request (no un-aligned requests) / if ((size == 1 \|\| size == 2 \|\| size == 4) && (offset % size) == 0) return 1; return 0; } static inline u32 merge_value(u32 val, u32 new_val, u32 new_val_mask, int offset) { if (offset >= 0) { new_val_mask <<= (offset 8); new_val <<= (offset * 8); } else { new_val_mask >>= (offset * -8); new_val >>= (offset * -8); } val = (val & ~new_val_mask) \| (new_val & new_val_mask); return val; } static int xen_pcibios_err_to_errno(int err) { switch (err) { case PCIBIOS_SUCCESSFUL: return XEN_PCI_ERR_success; case PCIBIOS_DEVICE_NOT_FOUND: return XEN_PCI_ERR_dev_not_found; case PCIBIOS_BAD_REGISTER_NUMBER: return XEN_PCI_ERR_invalid_offset; case PCIBIOS_FUNC_NOT_SUPPORTED: return XEN_PCI_ERR_not_implemented; case PCIBIOS_SET_FAILED: return XEN_PCI_ERR_access_denied; } return err; } int xen_pcibk_config_read(struct pci_dev dev, int offset, int size, u32 ret_val) { int err = 0; struct xen_pcibk_dev_data dev_data = pci_get_drvdata(dev); const struct config_field_entry cfg_entry; const struct config_field field; int req_start, req_end, field_start, field_end; / if read fails for any reason, return 0 * (as if device didn't respond) / u32 value = 0, tmp_val; if (unlikely(verbose_request)) printk(KERN_DEBUG DRV_NAME ": %s: read %d bytes at 0x%x\n", pci_name(dev), size, offset); if (!valid_request(offset, size)) { err = XEN_PCI_ERR_invalid_offset; goto out; } / Get the real value first, then modify as appropriate / switch (size) { case 1: err = pci_read_config_byte(dev, offset, (u8 ) &value); break; case 2: err = pci_read_config_word(dev, offset, (u16 ) &value); break; case 4: err = pci_read_config_dword(dev, offset, &value); break; } list_for_each_entry(cfg_entry, &dev_data->config_fields, list) { field = cfg_entry->field; req_start = offset; req_end = offset + size; field_start = OFFSET(cfg_entry); field_end = OFFSET(cfg_entry) + field->size; if ((req_start >= field_start && req_start < field_end) \|\| (req_end > field_start && req_end <= field_end)) { err = conf_space_read(dev, cfg_entry, field_start, &tmp_val); if (err) goto out; value = merge_value(value, tmp_val, get_mask(field->size), field_start - req_start); } } out: if (unlikely(verbose_request)) printk(KERN_DEBUG DRV_NAME ": %s: read %d bytes at 0x%x = %x\n", pci_name(dev), size, offset, value); ret_val = value; return xen_pcibios_err_to_errno(err); } int xen_pcibk_config_write(struct pci_dev dev, int offset, int size, u32 value) { int err = 0, handled = 0; struct xen_pcibk_dev_data dev_data = pci_get_drvdata(dev); const struct config_field_entry cfg_entry; const struct config_field field; u32 tmp_val; int req_start, req_end, field_start, field_end; if (unlikely(verbose_request)) printk(KERN_DEBUG DRV_NAME ": %s: write request %d bytes at 0x%x = %x\n", pci_name(dev), size, offset, value); if (!valid_request(offset, size)) return XEN_PCI_ERR_invalid_offset; list_for_each_entry(cfg_entry, &dev_data->config_fields, list) { field = cfg_entry->field; req_start = offset; req_end = offset + size; field_start = OFFSET(cfg_entry); field_end = OFFSET(cfg_entry) + field->size; if ((req_start >= field_start && req_start < field_end) \|\| (req_end > field_start && req_end <= field_end)) { tmp_val = 0; err = xen_pcibk_config_read(dev, field_start, field->size, &tmp_val); if (err) break; tmp_val = merge_value(tmp_val, value, get_mask(size), req_start - field_start); err = conf_space_write(dev, cfg_entry, field_start, tmp_val); /* handled is set true here, but not every byte * may have been written! Properly detecting if * every byte is handled is unnecessary as the * flag is used to detect devices that need * special helpers to work correctly. / handled = 1; } } if (!handled && !err) { / By default, anything not specificially handled above is * read-only. The permissive flag changes this behavior so * that anything not specifically handled above is writable. * This means that some fields may still be read-only because * they have entries in the config_field list that intercept * the write and do nothing. / if (dev_data->permissive \|\| permissive) { switch (size) { case 1: err = pci_write_config_byte(dev, offset, (u8) value); break; case 2: err = pci_write_config_word(dev, offset, (u16) value); break; case 4: err = pci_write_config_dword(dev, offset, (u32) value); break; } } else if (!dev_data->warned_on_write) { dev_data->warned_on_write = 1; dev_warn(&dev->dev, "Driver tried to write to a " "read-only configuration space field at offset" " 0x%x, size %d. This may be harmless, but if " "you have problems with your device:\n" "1) see permissive attribute in sysfs\n" "2) report problems to the xen-devel " "mailing list along with details of your " "device obtained from lspci.\n", offset, size); } } return xen_pcibios_err_to_errno(err); } void xen_pcibk_config_free_dyn_fields(struct pci_dev dev) { struct xen_pcibk_dev_data dev_data = pci_get_drvdata(dev); struct config_field_entry cfg_entry, t; const struct config_field field; dev_dbg(&dev->dev, "free-ing dynamically allocated virtual " "configuration space fields\n"); if (!dev_data) return; list_for_each_entry_safe(cfg_entry, t, &dev_data->config_fields, list) { field = cfg_entry->field; if (field->clean) { field->clean((struct config_field )field); kfree(cfg_entry->data); list_del(&cfg_entry->list); kfree(cfg_entry); } } } void xen_pcibk_config_reset_dev(struct pci_dev dev) { struct xen_pcibk_dev_data dev_data = pci_get_drvdata(dev); const struct config_field_entry cfg_entry; const struct config_field field; dev_dbg(&dev->dev, "resetting virtual configuration space\n"); if (!dev_data) return; list_for_each_entry(cfg_entry, &dev_data->config_fields, list) { field = cfg_entry->field; if (field->reset) field->reset(dev, OFFSET(cfg_entry), cfg_entry->data); } } void xen_pcibk_config_free_dev(struct pci_dev dev) { struct xen_pcibk_dev_data dev_data = pci_get_drvdata(dev); struct config_field_entry cfg_entry, t; const struct config_field field; dev_dbg(&dev->dev, "free-ing virtual configuration space fields\n"); if (!dev_data) return; list_for_each_entry_safe(cfg_entry, t, &dev_data->config_fields, list) { list_del(&cfg_entry->list); field = cfg_entry->field; if (field->release) field->release(dev, OFFSET(cfg_entry), cfg_entry->data); kfree(cfg_entry); } } int xen_pcibk_config_add_field_offset(struct pci_dev dev, const struct config_field field, unsigned int base_offset) { int err = 0; struct xen_pcibk_dev_data dev_data = pci_get_drvdata(dev); struct config_field_entry cfg_entry; void tmp; cfg_entry = kmalloc(sizeof(cfg_entry), GFP_KERNEL); if (!cfg_entry) { err = -ENOMEM; goto out; } cfg_entry->data = NULL; cfg_entry->field = field; cfg_entry->base_offset = base_offset; /* silently ignore duplicate fields / err = xen_pcibk_field_is_dup(dev, OFFSET(cfg_entry)); if (err) goto out; if (field->init) { tmp = field->init(dev, OFFSET(cfg_entry)); if (IS_ERR(tmp)) { err = PTR_ERR(tmp); goto out; } cfg_entry->data = tmp; } dev_dbg(&dev->dev, "added config field at offset 0x%02x\n", OFFSET(cfg_entry)); list_add_tail(&cfg_entry->list, &dev_data->config_fields); out: if (err) kfree(cfg_entry); return err; } / This sets up the device's virtual configuration space to keep track of * certain registers (like the base address registers (BARs) so that we can * keep the client from manipulating them directly. / int xen_pcibk_config_init_dev(struct pci_dev dev) { int err = 0; struct xen_pcibk_dev_data *dev_data = pci_get_drvdata(dev); dev_dbg(&dev->dev, "initializing virtual configuration space\n"); INIT_LIST_HEAD(&dev_data->config_fields); err = xen_pcibk_config_header_add_fields(dev); if (err) goto out; err = xen_pcibk_config_capability_add_fields(dev); if (err) goto out; err = xen_pcibk_config_quirks_init(dev); out: return err; } int xen_pcibk_config_init(void) { return xen_pcibk_config_capability_init(); }	./CrossVul/dataset_final_sorted/CWE-264/c/bad_1513_0
crossvul-cpp_data_bad_3482_1	/* * INET An implementation of the TCP/IP protocol suite for the LINUX * operating system. INET is implemented using the BSD Socket * interface as the means of communication with the user level. * * PACKET - implements raw packet sockets. * * Authors: Ross Biro * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG> * Alan Cox, <gw4pts@gw4pts.ampr.org> * * Fixes: * Alan Cox : verify_area() now used correctly * Alan Cox : new skbuff lists, look ma no backlogs! * Alan Cox : tidied skbuff lists. * Alan Cox : Now uses generic datagram routines I * added. Also fixed the peek/read crash * from all old Linux datagram code. * Alan Cox : Uses the improved datagram code. * Alan Cox : Added NULL's for socket options. * Alan Cox : Re-commented the code. * Alan Cox : Use new kernel side addressing * Rob Janssen : Correct MTU usage. * Dave Platt : Counter leaks caused by incorrect * interrupt locking and some slightly * dubious gcc output. Can you read * compiler: it said _VOLATILE_ * Richard Kooijman : Timestamp fixes. * Alan Cox : New buffers. Use sk->mac.raw. * Alan Cox : sendmsg/recvmsg support. * Alan Cox : Protocol setting support * Alexey Kuznetsov : Untied from IPv4 stack. * Cyrus Durgin : Fixed kerneld for kmod. * Michal Ostrowski : Module initialization cleanup. * Ulises Alonso : Frame number limit removal and * packet_set_ring memory leak. * Eric Biederman : Allow for > 8 byte hardware addresses. * The convention is that longer addresses * will simply extend the hardware address * byte arrays at the end of sockaddr_ll * and packet_mreq. * Johann Baudy : Added TX RING. * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License * as published by the Free Software Foundation; either version * 2 of the License, or (at your option) any later version. * / #include <linux/types.h> #include <linux/mm.h> #include <linux/capability.h> #include <linux/fcntl.h> #include <linux/socket.h> #include <linux/in.h> #include <linux/inet.h> #include <linux/netdevice.h> #include <linux/if_packet.h> #include <linux/wireless.h> #include <linux/kernel.h> #include <linux/kmod.h> #include <linux/slab.h> #include <linux/vmalloc.h> #include <net/net_namespace.h> #include <net/ip.h> #include <net/protocol.h> #include <linux/skbuff.h> #include <net/sock.h> #include <linux/errno.h> #include <linux/timer.h> #include <asm/system.h> #include <asm/uaccess.h> #include <asm/ioctls.h> #include <asm/page.h> #include <asm/cacheflush.h> #include <asm/io.h> #include <linux/proc_fs.h> #include <linux/seq_file.h> #include <linux/poll.h> #include <linux/module.h> #include <linux/init.h> #include <linux/mutex.h> #include <linux/if_vlan.h> #include <linux/virtio_net.h> #include <linux/errqueue.h> #include <linux/net_tstamp.h> #ifdef CONFIG_INET #include <net/inet_common.h> #endif / Assumptions: - if device has no dev->hard_header routine, it adds and removes ll header inside itself. In this case ll header is invisible outside of device, but higher levels still should reserve dev->hard_header_len. Some devices are enough clever to reallocate skb, when header will not fit to reserved space (tunnel), another ones are silly (PPP). - packet socket receives packets with pulled ll header, so that SOCK_RAW should push it back. On receive: ----------- Incoming, dev->hard_header!=NULL mac_header -> ll header data -> data Outgoing, dev->hard_header!=NULL mac_header -> ll header data -> ll header Incoming, dev->hard_header==NULL mac_header -> UNKNOWN position. It is very likely, that it points to ll header. PPP makes it, that is wrong, because introduce assymetry between rx and tx paths. data -> data Outgoing, dev->hard_header==NULL mac_header -> data. ll header is still not built! data -> data Resume If dev->hard_header==NULL we are unlikely to restore sensible ll header. On transmit: ------------ dev->hard_header != NULL mac_header -> ll header data -> ll header dev->hard_header == NULL (ll header is added by device, we cannot control it) mac_header -> data data -> data We should set nh.raw on output to correct posistion, packet classifier depends on it. / / Private packet socket structures. / struct packet_mclist { struct packet_mclist next; int ifindex; int count; unsigned short type; unsigned short alen; unsigned char addr[MAX_ADDR_LEN]; }; /* identical to struct packet_mreq except it has * a longer address field. / struct packet_mreq_max { int mr_ifindex; unsigned short mr_type; unsigned short mr_alen; unsigned char mr_address[MAX_ADDR_LEN]; }; static int packet_set_ring(struct sock sk, struct tpacket_req req, int closing, int tx_ring); struct pgv { char buffer; }; struct packet_ring_buffer { struct pgv pg_vec; unsigned int head; unsigned int frames_per_block; unsigned int frame_size; unsigned int frame_max; unsigned int pg_vec_order; unsigned int pg_vec_pages; unsigned int pg_vec_len; atomic_t pending; }; struct packet_sock; static int tpacket_snd(struct packet_sock po, struct msghdr msg); static void packet_flush_mclist(struct sock sk); struct packet_sock { /* struct sock has to be the first member of packet_sock / struct sock sk; struct tpacket_stats stats; struct packet_ring_buffer rx_ring; struct packet_ring_buffer tx_ring; int copy_thresh; spinlock_t bind_lock; struct mutex pg_vec_lock; unsigned int running:1, / prot_hook is attached/ auxdata:1, origdev:1, has_vnet_hdr:1; int ifindex; / bound device / __be16 num; struct packet_mclist mclist; atomic_t mapped; enum tpacket_versions tp_version; unsigned int tp_hdrlen; unsigned int tp_reserve; unsigned int tp_loss:1; unsigned int tp_tstamp; struct packet_type prot_hook ____cacheline_aligned_in_smp; }; struct packet_skb_cb { unsigned int origlen; union { struct sockaddr_pkt pkt; struct sockaddr_ll ll; } sa; }; #define PACKET_SKB_CB(__skb) ((struct packet_skb_cb )((__skb)->cb)) static inline __pure struct page pgv_to_page(void addr) { if (is_vmalloc_addr(addr)) return vmalloc_to_page(addr); return virt_to_page(addr); } static void __packet_set_status(struct packet_sock po, void frame, int status) { union { struct tpacket_hdr h1; struct tpacket2_hdr h2; void raw; } h; h.raw = frame; switch (po->tp_version) { case TPACKET_V1: h.h1->tp_status = status; flush_dcache_page(pgv_to_page(&h.h1->tp_status)); break; case TPACKET_V2: h.h2->tp_status = status; flush_dcache_page(pgv_to_page(&h.h2->tp_status)); break; default: pr_err("TPACKET version not supported\n"); BUG(); } smp_wmb(); } static int __packet_get_status(struct packet_sock po, void frame) { union { struct tpacket_hdr h1; struct tpacket2_hdr h2; void raw; } h; smp_rmb(); h.raw = frame; switch (po->tp_version) { case TPACKET_V1: flush_dcache_page(pgv_to_page(&h.h1->tp_status)); return h.h1->tp_status; case TPACKET_V2: flush_dcache_page(pgv_to_page(&h.h2->tp_status)); return h.h2->tp_status; default: pr_err("TPACKET version not supported\n"); BUG(); return 0; } } static void packet_lookup_frame(struct packet_sock po, struct packet_ring_buffer rb, unsigned int position, int status) { unsigned int pg_vec_pos, frame_offset; union { struct tpacket_hdr h1; struct tpacket2_hdr h2; void raw; } h; pg_vec_pos = position / rb->frames_per_block; frame_offset = position % rb->frames_per_block; h.raw = rb->pg_vec[pg_vec_pos].buffer + (frame_offset rb->frame_size); if (status != __packet_get_status(po, h.raw)) return NULL; return h.raw; } static inline void packet_current_frame(struct packet_sock po, struct packet_ring_buffer rb, int status) { return packet_lookup_frame(po, rb, rb->head, status); } static inline void packet_previous_frame(struct packet_sock po, struct packet_ring_buffer rb, int status) { unsigned int previous = rb->head ? rb->head - 1 : rb->frame_max; return packet_lookup_frame(po, rb, previous, status); } static inline void packet_increment_head(struct packet_ring_buffer buff) { buff->head = buff->head != buff->frame_max ? buff->head+1 : 0; } static inline struct packet_sock pkt_sk(struct sock sk) { return (struct packet_sock )sk; } static void packet_sock_destruct(struct sock sk) { skb_queue_purge(&sk->sk_error_queue); WARN_ON(atomic_read(&sk->sk_rmem_alloc)); WARN_ON(atomic_read(&sk->sk_wmem_alloc)); if (!sock_flag(sk, SOCK_DEAD)) { pr_err("Attempt to release alive packet socket: %p\n", sk); return; } sk_refcnt_debug_dec(sk); } static const struct proto_ops packet_ops; static const struct proto_ops packet_ops_spkt; static int packet_rcv_spkt(struct sk_buff skb, struct net_device dev, struct packet_type pt, struct net_device orig_dev) { struct sock sk; struct sockaddr_pkt spkt; / * When we registered the protocol we saved the socket in the data * field for just this event. / sk = pt->af_packet_priv; / * Yank back the headers [hope the device set this * right or kerboom...] * * Incoming packets have ll header pulled, * push it back. * * For outgoing ones skb->data == skb_mac_header(skb) * so that this procedure is noop. / if (skb->pkt_type == PACKET_LOOPBACK) goto out; if (!net_eq(dev_net(dev), sock_net(sk))) goto out; skb = skb_share_check(skb, GFP_ATOMIC); if (skb == NULL) goto oom; / drop any routing info / skb_dst_drop(skb); / drop conntrack reference / nf_reset(skb); spkt = &PACKET_SKB_CB(skb)->sa.pkt; skb_push(skb, skb->data - skb_mac_header(skb)); / * The SOCK_PACKET socket receives _all_ frames. / spkt->spkt_family = dev->type; strlcpy(spkt->spkt_device, dev->name, sizeof(spkt->spkt_device)); spkt->spkt_protocol = skb->protocol; / * Charge the memory to the socket. This is done specifically * to prevent sockets using all the memory up. / if (sock_queue_rcv_skb(sk, skb) == 0) return 0; out: kfree_skb(skb); oom: return 0; } / * Output a raw packet to a device layer. This bypasses all the other * protocol layers and you must therefore supply it with a complete frame / static int packet_sendmsg_spkt(struct kiocb iocb, struct socket sock, struct msghdr msg, size_t len) { struct sock sk = sock->sk; struct sockaddr_pkt saddr = (struct sockaddr_pkt )msg->msg_name; struct sk_buff skb = NULL; struct net_device dev; __be16 proto = 0; int err; / * Get and verify the address. / if (saddr) { if (msg->msg_namelen < sizeof(struct sockaddr)) return -EINVAL; if (msg->msg_namelen == sizeof(struct sockaddr_pkt)) proto = saddr->spkt_protocol; } else return -ENOTCONN; / SOCK_PACKET must be sent giving an address / / * Find the device first to size check it / saddr->spkt_device[13] = 0; retry: rcu_read_lock(); dev = dev_get_by_name_rcu(sock_net(sk), saddr->spkt_device); err = -ENODEV; if (dev == NULL) goto out_unlock; err = -ENETDOWN; if (!(dev->flags & IFF_UP)) goto out_unlock; / * You may not queue a frame bigger than the mtu. This is the lowest level * raw protocol and you must do your own fragmentation at this level. / err = -EMSGSIZE; if (len > dev->mtu + dev->hard_header_len + VLAN_HLEN) goto out_unlock; if (!skb) { size_t reserved = LL_RESERVED_SPACE(dev); unsigned int hhlen = dev->header_ops ? dev->hard_header_len : 0; rcu_read_unlock(); skb = sock_wmalloc(sk, len + reserved, 0, GFP_KERNEL); if (skb == NULL) return -ENOBUFS; / FIXME: Save some space for broken drivers that write a hard * header at transmission time by themselves. PPP is the notable * one here. This should really be fixed at the driver level. / skb_reserve(skb, reserved); skb_reset_network_header(skb); / Try to align data part correctly / if (hhlen) { skb->data -= hhlen; skb->tail -= hhlen; if (len < hhlen) skb_reset_network_header(skb); } err = memcpy_fromiovec(skb_put(skb, len), msg->msg_iov, len); if (err) goto out_free; goto retry; } if (len > (dev->mtu + dev->hard_header_len)) { / Earlier code assumed this would be a VLAN pkt, * double-check this now that we have the actual * packet in hand. / struct ethhdr ehdr; skb_reset_mac_header(skb); ehdr = eth_hdr(skb); if (ehdr->h_proto != htons(ETH_P_8021Q)) { err = -EMSGSIZE; goto out_unlock; } } skb->protocol = proto; skb->dev = dev; skb->priority = sk->sk_priority; skb->mark = sk->sk_mark; err = sock_tx_timestamp(sk, &skb_shinfo(skb)->tx_flags); if (err < 0) goto out_unlock; dev_queue_xmit(skb); rcu_read_unlock(); return len; out_unlock: rcu_read_unlock(); out_free: kfree_skb(skb); return err; } static inline unsigned int run_filter(const struct sk_buff skb, const struct sock sk, unsigned int res) { struct sk_filter filter; rcu_read_lock(); filter = rcu_dereference(sk->sk_filter); if (filter != NULL) res = SK_RUN_FILTER(filter, skb); rcu_read_unlock(); return res; } / * This function makes lazy skb cloning in hope that most of packets * are discarded by BPF. * * Note tricky part: we DO mangle shared skb! skb->data, skb->len * and skb->cb are mangled. It works because (and until) packets * falling here are owned by current CPU. Output packets are cloned * by dev_queue_xmit_nit(), input packets are processed by net_bh * sequencially, so that if we return skb to original state on exit, * we will not harm anyone. / static int packet_rcv(struct sk_buff skb, struct net_device dev, struct packet_type pt, struct net_device orig_dev) { struct sock sk; struct sockaddr_ll sll; struct packet_sock po; u8 skb_head = skb->data; int skb_len = skb->len; unsigned int snaplen, res; if (skb->pkt_type == PACKET_LOOPBACK) goto drop; sk = pt->af_packet_priv; po = pkt_sk(sk); if (!net_eq(dev_net(dev), sock_net(sk))) goto drop; skb->dev = dev; if (dev->header_ops) { / The device has an explicit notion of ll header, * exported to higher levels. * * Otherwise, the device hides details of its frame * structure, so that corresponding packet head is * never delivered to user. / if (sk->sk_type != SOCK_DGRAM) skb_push(skb, skb->data - skb_mac_header(skb)); else if (skb->pkt_type == PACKET_OUTGOING) { / Special case: outgoing packets have ll header at head / skb_pull(skb, skb_network_offset(skb)); } } snaplen = skb->len; res = run_filter(skb, sk, snaplen); if (!res) goto drop_n_restore; if (snaplen > res) snaplen = res; if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >= (unsigned)sk->sk_rcvbuf) goto drop_n_acct; if (skb_shared(skb)) { struct sk_buff nskb = skb_clone(skb, GFP_ATOMIC); if (nskb == NULL) goto drop_n_acct; if (skb_head != skb->data) { skb->data = skb_head; skb->len = skb_len; } kfree_skb(skb); skb = nskb; } BUILD_BUG_ON(sizeof(PACKET_SKB_CB(skb)) + MAX_ADDR_LEN - 8 > sizeof(skb->cb)); sll = &PACKET_SKB_CB(skb)->sa.ll; sll->sll_family = AF_PACKET; sll->sll_hatype = dev->type; sll->sll_protocol = skb->protocol; sll->sll_pkttype = skb->pkt_type; if (unlikely(po->origdev)) sll->sll_ifindex = orig_dev->ifindex; else sll->sll_ifindex = dev->ifindex; sll->sll_halen = dev_parse_header(skb, sll->sll_addr); PACKET_SKB_CB(skb)->origlen = skb->len; if (pskb_trim(skb, snaplen)) goto drop_n_acct; skb_set_owner_r(skb, sk); skb->dev = NULL; skb_dst_drop(skb); / drop conntrack reference / nf_reset(skb); spin_lock(&sk->sk_receive_queue.lock); po->stats.tp_packets++; skb->dropcount = atomic_read(&sk->sk_drops); __skb_queue_tail(&sk->sk_receive_queue, skb); spin_unlock(&sk->sk_receive_queue.lock); sk->sk_data_ready(sk, skb->len); return 0; drop_n_acct: po->stats.tp_drops = atomic_inc_return(&sk->sk_drops); drop_n_restore: if (skb_head != skb->data && skb_shared(skb)) { skb->data = skb_head; skb->len = skb_len; } drop: consume_skb(skb); return 0; } static int tpacket_rcv(struct sk_buff skb, struct net_device dev, struct packet_type pt, struct net_device orig_dev) { struct sock sk; struct packet_sock po; struct sockaddr_ll sll; union { struct tpacket_hdr h1; struct tpacket2_hdr h2; void raw; } h; u8 skb_head = skb->data; int skb_len = skb->len; unsigned int snaplen, res; unsigned long status = TP_STATUS_LOSING\|TP_STATUS_USER; unsigned short macoff, netoff, hdrlen; struct sk_buff copy_skb = NULL; struct timeval tv; struct timespec ts; struct skb_shared_hwtstamps shhwtstamps = skb_hwtstamps(skb); if (skb->pkt_type == PACKET_LOOPBACK) goto drop; sk = pt->af_packet_priv; po = pkt_sk(sk); if (!net_eq(dev_net(dev), sock_net(sk))) goto drop; if (dev->header_ops) { if (sk->sk_type != SOCK_DGRAM) skb_push(skb, skb->data - skb_mac_header(skb)); else if (skb->pkt_type == PACKET_OUTGOING) { /* Special case: outgoing packets have ll header at head / skb_pull(skb, skb_network_offset(skb)); } } if (skb->ip_summed == CHECKSUM_PARTIAL) status \|= TP_STATUS_CSUMNOTREADY; snaplen = skb->len; res = run_filter(skb, sk, snaplen); if (!res) goto drop_n_restore; if (snaplen > res) snaplen = res; if (sk->sk_type == SOCK_DGRAM) { macoff = netoff = TPACKET_ALIGN(po->tp_hdrlen) + 16 + po->tp_reserve; } else { unsigned maclen = skb_network_offset(skb); netoff = TPACKET_ALIGN(po->tp_hdrlen + (maclen < 16 ? 16 : maclen)) + po->tp_reserve; macoff = netoff - maclen; } if (macoff + snaplen > po->rx_ring.frame_size) { if (po->copy_thresh && atomic_read(&sk->sk_rmem_alloc) + skb->truesize < (unsigned)sk->sk_rcvbuf) { if (skb_shared(skb)) { copy_skb = skb_clone(skb, GFP_ATOMIC); } else { copy_skb = skb_get(skb); skb_head = skb->data; } if (copy_skb) skb_set_owner_r(copy_skb, sk); } snaplen = po->rx_ring.frame_size - macoff; if ((int)snaplen < 0) snaplen = 0; } spin_lock(&sk->sk_receive_queue.lock); h.raw = packet_current_frame(po, &po->rx_ring, TP_STATUS_KERNEL); if (!h.raw) goto ring_is_full; packet_increment_head(&po->rx_ring); po->stats.tp_packets++; if (copy_skb) { status \|= TP_STATUS_COPY; __skb_queue_tail(&sk->sk_receive_queue, copy_skb); } if (!po->stats.tp_drops) status &= ~TP_STATUS_LOSING; spin_unlock(&sk->sk_receive_queue.lock); skb_copy_bits(skb, 0, h.raw + macoff, snaplen); switch (po->tp_version) { case TPACKET_V1: h.h1->tp_len = skb->len; h.h1->tp_snaplen = snaplen; h.h1->tp_mac = macoff; h.h1->tp_net = netoff; if ((po->tp_tstamp & SOF_TIMESTAMPING_SYS_HARDWARE) && shhwtstamps->syststamp.tv64) tv = ktime_to_timeval(shhwtstamps->syststamp); else if ((po->tp_tstamp & SOF_TIMESTAMPING_RAW_HARDWARE) && shhwtstamps->hwtstamp.tv64) tv = ktime_to_timeval(shhwtstamps->hwtstamp); else if (skb->tstamp.tv64) tv = ktime_to_timeval(skb->tstamp); else do_gettimeofday(&tv); h.h1->tp_sec = tv.tv_sec; h.h1->tp_usec = tv.tv_usec; hdrlen = sizeof(h.h1); break; case TPACKET_V2: h.h2->tp_len = skb->len; h.h2->tp_snaplen = snaplen; h.h2->tp_mac = macoff; h.h2->tp_net = netoff; if ((po->tp_tstamp & SOF_TIMESTAMPING_SYS_HARDWARE) && shhwtstamps->syststamp.tv64) ts = ktime_to_timespec(shhwtstamps->syststamp); else if ((po->tp_tstamp & SOF_TIMESTAMPING_RAW_HARDWARE) && shhwtstamps->hwtstamp.tv64) ts = ktime_to_timespec(shhwtstamps->hwtstamp); else if (skb->tstamp.tv64) ts = ktime_to_timespec(skb->tstamp); else getnstimeofday(&ts); h.h2->tp_sec = ts.tv_sec; h.h2->tp_nsec = ts.tv_nsec; if (vlan_tx_tag_present(skb)) { h.h2->tp_vlan_tci = vlan_tx_tag_get(skb); status \|= TP_STATUS_VLAN_VALID; } else { h.h2->tp_vlan_tci = 0; } hdrlen = sizeof(h.h2); break; default: BUG(); } sll = h.raw + TPACKET_ALIGN(hdrlen); sll->sll_halen = dev_parse_header(skb, sll->sll_addr); sll->sll_family = AF_PACKET; sll->sll_hatype = dev->type; sll->sll_protocol = skb->protocol; sll->sll_pkttype = skb->pkt_type; if (unlikely(po->origdev)) sll->sll_ifindex = orig_dev->ifindex; else sll->sll_ifindex = dev->ifindex; __packet_set_status(po, h.raw, status); smp_mb(); #if ARCH_IMPLEMENTS_FLUSH_DCACHE_PAGE == 1 { u8 start, end; end = (u8 )PAGE_ALIGN((unsigned long)h.raw + macoff + snaplen); for (start = h.raw; start < end; start += PAGE_SIZE) flush_dcache_page(pgv_to_page(start)); } #endif sk->sk_data_ready(sk, 0); drop_n_restore: if (skb_head != skb->data && skb_shared(skb)) { skb->data = skb_head; skb->len = skb_len; } drop: kfree_skb(skb); return 0; ring_is_full: po->stats.tp_drops++; spin_unlock(&sk->sk_receive_queue.lock); sk->sk_data_ready(sk, 0); kfree_skb(copy_skb); goto drop_n_restore; } static void tpacket_destruct_skb(struct sk_buff skb) { struct packet_sock po = pkt_sk(skb->sk); void ph; BUG_ON(skb == NULL); if (likely(po->tx_ring.pg_vec)) { ph = skb_shinfo(skb)->destructor_arg; BUG_ON(__packet_get_status(po, ph) != TP_STATUS_SENDING); BUG_ON(atomic_read(&po->tx_ring.pending) == 0); atomic_dec(&po->tx_ring.pending); __packet_set_status(po, ph, TP_STATUS_AVAILABLE); } sock_wfree(skb); } static int tpacket_fill_skb(struct packet_sock po, struct sk_buff skb, void frame, struct net_device dev, int size_max, __be16 proto, unsigned char addr) { union { struct tpacket_hdr h1; struct tpacket2_hdr h2; void raw; } ph; int to_write, offset, len, tp_len, nr_frags, len_max; struct socket sock = po->sk.sk_socket; struct page page; void data; int err; ph.raw = frame; skb->protocol = proto; skb->dev = dev; skb->priority = po->sk.sk_priority; skb->mark = po->sk.sk_mark; skb_shinfo(skb)->destructor_arg = ph.raw; switch (po->tp_version) { case TPACKET_V2: tp_len = ph.h2->tp_len; break; default: tp_len = ph.h1->tp_len; break; } if (unlikely(tp_len > size_max)) { pr_err("packet size is too long (%d > %d)\n", tp_len, size_max); return -EMSGSIZE; } skb_reserve(skb, LL_RESERVED_SPACE(dev)); skb_reset_network_header(skb); data = ph.raw + po->tp_hdrlen - sizeof(struct sockaddr_ll); to_write = tp_len; if (sock->type == SOCK_DGRAM) { err = dev_hard_header(skb, dev, ntohs(proto), addr, NULL, tp_len); if (unlikely(err < 0)) return -EINVAL; } else if (dev->hard_header_len) { /* net device doesn't like empty head / if (unlikely(tp_len <= dev->hard_header_len)) { pr_err("packet size is too short (%d < %d)\n", tp_len, dev->hard_header_len); return -EINVAL; } skb_push(skb, dev->hard_header_len); err = skb_store_bits(skb, 0, data, dev->hard_header_len); if (unlikely(err)) return err; data += dev->hard_header_len; to_write -= dev->hard_header_len; } err = -EFAULT; offset = offset_in_page(data); len_max = PAGE_SIZE - offset; len = ((to_write > len_max) ? len_max : to_write); skb->data_len = to_write; skb->len += to_write; skb->truesize += to_write; atomic_add(to_write, &po->sk.sk_wmem_alloc); while (likely(to_write)) { nr_frags = skb_shinfo(skb)->nr_frags; if (unlikely(nr_frags >= MAX_SKB_FRAGS)) { pr_err("Packet exceed the number of skb frags(%lu)\n", MAX_SKB_FRAGS); return -EFAULT; } page = pgv_to_page(data); data += len; flush_dcache_page(page); get_page(page); skb_fill_page_desc(skb, nr_frags, page, offset, len); to_write -= len; offset = 0; len_max = PAGE_SIZE; len = ((to_write > len_max) ? len_max : to_write); } return tp_len; } static int tpacket_snd(struct packet_sock po, struct msghdr msg) { struct sk_buff skb; struct net_device dev; __be16 proto; int ifindex, err, reserve = 0; void ph; struct sockaddr_ll saddr = (struct sockaddr_ll )msg->msg_name; int tp_len, size_max; unsigned char addr; int len_sum = 0; int status = 0; mutex_lock(&po->pg_vec_lock); err = -EBUSY; if (saddr == NULL) { ifindex = po->ifindex; proto = po->num; addr = NULL; } else { err = -EINVAL; if (msg->msg_namelen < sizeof(struct sockaddr_ll)) goto out; if (msg->msg_namelen < (saddr->sll_halen + offsetof(struct sockaddr_ll, sll_addr))) goto out; ifindex = saddr->sll_ifindex; proto = saddr->sll_protocol; addr = saddr->sll_addr; } dev = dev_get_by_index(sock_net(&po->sk), ifindex); err = -ENXIO; if (unlikely(dev == NULL)) goto out; reserve = dev->hard_header_len; err = -ENETDOWN; if (unlikely(!(dev->flags & IFF_UP))) goto out_put; size_max = po->tx_ring.frame_size - (po->tp_hdrlen - sizeof(struct sockaddr_ll)); if (size_max > dev->mtu + reserve) size_max = dev->mtu + reserve; do { ph = packet_current_frame(po, &po->tx_ring, TP_STATUS_SEND_REQUEST); if (unlikely(ph == NULL)) { schedule(); continue; } status = TP_STATUS_SEND_REQUEST; skb = sock_alloc_send_skb(&po->sk, LL_ALLOCATED_SPACE(dev) + sizeof(struct sockaddr_ll), 0, &err); if (unlikely(skb == NULL)) goto out_status; tp_len = tpacket_fill_skb(po, skb, ph, dev, size_max, proto, addr); if (unlikely(tp_len < 0)) { if (po->tp_loss) { __packet_set_status(po, ph, TP_STATUS_AVAILABLE); packet_increment_head(&po->tx_ring); kfree_skb(skb); continue; } else { status = TP_STATUS_WRONG_FORMAT; err = tp_len; goto out_status; } } skb->destructor = tpacket_destruct_skb; __packet_set_status(po, ph, TP_STATUS_SENDING); atomic_inc(&po->tx_ring.pending); status = TP_STATUS_SEND_REQUEST; err = dev_queue_xmit(skb); if (unlikely(err > 0)) { err = net_xmit_errno(err); if (err && __packet_get_status(po, ph) == TP_STATUS_AVAILABLE) { / skb was destructed already / skb = NULL; goto out_status; } / * skb was dropped but not destructed yet; * let's treat it like congestion or err < 0 / err = 0; } packet_increment_head(&po->tx_ring); len_sum += tp_len; } while (likely((ph != NULL) \|\| ((!(msg->msg_flags & MSG_DONTWAIT)) && (atomic_read(&po->tx_ring.pending)))) ); err = len_sum; goto out_put; out_status: __packet_set_status(po, ph, status); kfree_skb(skb); out_put: dev_put(dev); out: mutex_unlock(&po->pg_vec_lock); return err; } static inline struct sk_buff packet_alloc_skb(struct sock sk, size_t prepad, size_t reserve, size_t len, size_t linear, int noblock, int err) { struct sk_buff skb; / Under a page? Don't bother with paged skb. / if (prepad + len < PAGE_SIZE \|\| !linear) linear = len; skb = sock_alloc_send_pskb(sk, prepad + linear, len - linear, noblock, err); if (!skb) return NULL; skb_reserve(skb, reserve); skb_put(skb, linear); skb->data_len = len - linear; skb->len += len - linear; return skb; } static int packet_snd(struct socket sock, struct msghdr msg, size_t len) { struct sock sk = sock->sk; struct sockaddr_ll saddr = (struct sockaddr_ll )msg->msg_name; struct sk_buff skb; struct net_device dev; __be16 proto; unsigned char addr; int ifindex, err, reserve = 0; struct virtio_net_hdr vnet_hdr = { 0 }; int offset = 0; int vnet_hdr_len; struct packet_sock po = pkt_sk(sk); unsigned short gso_type = 0; /* * Get and verify the address. / if (saddr == NULL) { ifindex = po->ifindex; proto = po->num; addr = NULL; } else { err = -EINVAL; if (msg->msg_namelen < sizeof(struct sockaddr_ll)) goto out; if (msg->msg_namelen < (saddr->sll_halen + offsetof(struct sockaddr_ll, sll_addr))) goto out; ifindex = saddr->sll_ifindex; proto = saddr->sll_protocol; addr = saddr->sll_addr; } dev = dev_get_by_index(sock_net(sk), ifindex); err = -ENXIO; if (dev == NULL) goto out_unlock; if (sock->type == SOCK_RAW) reserve = dev->hard_header_len; err = -ENETDOWN; if (!(dev->flags & IFF_UP)) goto out_unlock; if (po->has_vnet_hdr) { vnet_hdr_len = sizeof(vnet_hdr); err = -EINVAL; if (len < vnet_hdr_len) goto out_unlock; len -= vnet_hdr_len; err = memcpy_fromiovec((void )&vnet_hdr, msg->msg_iov, vnet_hdr_len); if (err < 0) goto out_unlock; if ((vnet_hdr.flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) && (vnet_hdr.csum_start + vnet_hdr.csum_offset + 2 > vnet_hdr.hdr_len)) vnet_hdr.hdr_len = vnet_hdr.csum_start + vnet_hdr.csum_offset + 2; err = -EINVAL; if (vnet_hdr.hdr_len > len) goto out_unlock; if (vnet_hdr.gso_type != VIRTIO_NET_HDR_GSO_NONE) { switch (vnet_hdr.gso_type & ~VIRTIO_NET_HDR_GSO_ECN) { case VIRTIO_NET_HDR_GSO_TCPV4: gso_type = SKB_GSO_TCPV4; break; case VIRTIO_NET_HDR_GSO_TCPV6: gso_type = SKB_GSO_TCPV6; break; case VIRTIO_NET_HDR_GSO_UDP: gso_type = SKB_GSO_UDP; break; default: goto out_unlock; } if (vnet_hdr.gso_type & VIRTIO_NET_HDR_GSO_ECN) gso_type \|= SKB_GSO_TCP_ECN; if (vnet_hdr.gso_size == 0) goto out_unlock; } } err = -EMSGSIZE; if (!gso_type && (len > dev->mtu + reserve + VLAN_HLEN)) goto out_unlock; err = -ENOBUFS; skb = packet_alloc_skb(sk, LL_ALLOCATED_SPACE(dev), LL_RESERVED_SPACE(dev), len, vnet_hdr.hdr_len, msg->msg_flags & MSG_DONTWAIT, &err); if (skb == NULL) goto out_unlock; skb_set_network_header(skb, reserve); err = -EINVAL; if (sock->type == SOCK_DGRAM && (offset = dev_hard_header(skb, dev, ntohs(proto), addr, NULL, len)) < 0) goto out_free; /* Returns -EFAULT on error / err = skb_copy_datagram_from_iovec(skb, offset, msg->msg_iov, 0, len); if (err) goto out_free; err = sock_tx_timestamp(sk, &skb_shinfo(skb)->tx_flags); if (err < 0) goto out_free; if (!gso_type && (len > dev->mtu + reserve)) { / Earlier code assumed this would be a VLAN pkt, * double-check this now that we have the actual * packet in hand. / struct ethhdr ehdr; skb_reset_mac_header(skb); ehdr = eth_hdr(skb); if (ehdr->h_proto != htons(ETH_P_8021Q)) { err = -EMSGSIZE; goto out_free; } } skb->protocol = proto; skb->dev = dev; skb->priority = sk->sk_priority; skb->mark = sk->sk_mark; if (po->has_vnet_hdr) { if (vnet_hdr.flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) { if (!skb_partial_csum_set(skb, vnet_hdr.csum_start, vnet_hdr.csum_offset)) { err = -EINVAL; goto out_free; } } skb_shinfo(skb)->gso_size = vnet_hdr.gso_size; skb_shinfo(skb)->gso_type = gso_type; /* Header must be checked, and gso_segs computed. / skb_shinfo(skb)->gso_type \|= SKB_GSO_DODGY; skb_shinfo(skb)->gso_segs = 0; len += vnet_hdr_len; } / * Now send it / err = dev_queue_xmit(skb); if (err > 0 && (err = net_xmit_errno(err)) != 0) goto out_unlock; dev_put(dev); return len; out_free: kfree_skb(skb); out_unlock: if (dev) dev_put(dev); out: return err; } static int packet_sendmsg(struct kiocb iocb, struct socket sock, struct msghdr msg, size_t len) { struct sock sk = sock->sk; struct packet_sock po = pkt_sk(sk); if (po->tx_ring.pg_vec) return tpacket_snd(po, msg); else return packet_snd(sock, msg, len); } /* * Close a PACKET socket. This is fairly simple. We immediately go * to 'closed' state and remove our protocol entry in the device list. / static int packet_release(struct socket sock) { struct sock sk = sock->sk; struct packet_sock po; struct net net; struct tpacket_req req; if (!sk) return 0; net = sock_net(sk); po = pkt_sk(sk); spin_lock_bh(&net->packet.sklist_lock); sk_del_node_init_rcu(sk); sock_prot_inuse_add(net, sk->sk_prot, -1); spin_unlock_bh(&net->packet.sklist_lock); spin_lock(&po->bind_lock); if (po->running) { / * Remove from protocol table / po->running = 0; po->num = 0; __dev_remove_pack(&po->prot_hook); __sock_put(sk); } spin_unlock(&po->bind_lock); packet_flush_mclist(sk); memset(&req, 0, sizeof(req)); if (po->rx_ring.pg_vec) packet_set_ring(sk, &req, 1, 0); if (po->tx_ring.pg_vec) packet_set_ring(sk, &req, 1, 1); synchronize_net(); / * Now the socket is dead. No more input will appear. / sock_orphan(sk); sock->sk = NULL; / Purge queues / skb_queue_purge(&sk->sk_receive_queue); sk_refcnt_debug_release(sk); sock_put(sk); return 0; } / * Attach a packet hook. / static int packet_do_bind(struct sock sk, struct net_device dev, __be16 protocol) { struct packet_sock po = pkt_sk(sk); /* * Detach an existing hook if present. / lock_sock(sk); spin_lock(&po->bind_lock); if (po->running) { __sock_put(sk); po->running = 0; po->num = 0; spin_unlock(&po->bind_lock); dev_remove_pack(&po->prot_hook); spin_lock(&po->bind_lock); } po->num = protocol; po->prot_hook.type = protocol; po->prot_hook.dev = dev; po->ifindex = dev ? dev->ifindex : 0; if (protocol == 0) goto out_unlock; if (!dev \|\| (dev->flags & IFF_UP)) { dev_add_pack(&po->prot_hook); sock_hold(sk); po->running = 1; } else { sk->sk_err = ENETDOWN; if (!sock_flag(sk, SOCK_DEAD)) sk->sk_error_report(sk); } out_unlock: spin_unlock(&po->bind_lock); release_sock(sk); return 0; } / * Bind a packet socket to a device / static int packet_bind_spkt(struct socket sock, struct sockaddr uaddr, int addr_len) { struct sock sk = sock->sk; char name[15]; struct net_device dev; int err = -ENODEV; / * Check legality / if (addr_len != sizeof(struct sockaddr)) return -EINVAL; strlcpy(name, uaddr->sa_data, sizeof(name)); dev = dev_get_by_name(sock_net(sk), name); if (dev) { err = packet_do_bind(sk, dev, pkt_sk(sk)->num); dev_put(dev); } return err; } static int packet_bind(struct socket sock, struct sockaddr uaddr, int addr_len) { struct sockaddr_ll sll = (struct sockaddr_ll )uaddr; struct sock sk = sock->sk; struct net_device dev = NULL; int err; / * Check legality / if (addr_len < sizeof(struct sockaddr_ll)) return -EINVAL; if (sll->sll_family != AF_PACKET) return -EINVAL; if (sll->sll_ifindex) { err = -ENODEV; dev = dev_get_by_index(sock_net(sk), sll->sll_ifindex); if (dev == NULL) goto out; } err = packet_do_bind(sk, dev, sll->sll_protocol ? : pkt_sk(sk)->num); if (dev) dev_put(dev); out: return err; } static struct proto packet_proto = { .name = "PACKET", .owner = THIS_MODULE, .obj_size = sizeof(struct packet_sock), }; / * Create a packet of type SOCK_PACKET. / static int packet_create(struct net net, struct socket sock, int protocol, int kern) { struct sock sk; struct packet_sock po; __be16 proto = (__force __be16)protocol; / weird, but documented / int err; if (!capable(CAP_NET_RAW)) return -EPERM; if (sock->type != SOCK_DGRAM && sock->type != SOCK_RAW && sock->type != SOCK_PACKET) return -ESOCKTNOSUPPORT; sock->state = SS_UNCONNECTED; err = -ENOBUFS; sk = sk_alloc(net, PF_PACKET, GFP_KERNEL, &packet_proto); if (sk == NULL) goto out; sock->ops = &packet_ops; if (sock->type == SOCK_PACKET) sock->ops = &packet_ops_spkt; sock_init_data(sock, sk); po = pkt_sk(sk); sk->sk_family = PF_PACKET; po->num = proto; sk->sk_destruct = packet_sock_destruct; sk_refcnt_debug_inc(sk); / * Attach a protocol block / spin_lock_init(&po->bind_lock); mutex_init(&po->pg_vec_lock); po->prot_hook.func = packet_rcv; if (sock->type == SOCK_PACKET) po->prot_hook.func = packet_rcv_spkt; po->prot_hook.af_packet_priv = sk; if (proto) { po->prot_hook.type = proto; dev_add_pack(&po->prot_hook); sock_hold(sk); po->running = 1; } spin_lock_bh(&net->packet.sklist_lock); sk_add_node_rcu(sk, &net->packet.sklist); sock_prot_inuse_add(net, &packet_proto, 1); spin_unlock_bh(&net->packet.sklist_lock); return 0; out: return err; } static int packet_recv_error(struct sock sk, struct msghdr msg, int len) { struct sock_exterr_skb serr; struct sk_buff skb, skb2; int copied, err; err = -EAGAIN; skb = skb_dequeue(&sk->sk_error_queue); if (skb == NULL) goto out; copied = skb->len; if (copied > len) { msg->msg_flags \|= MSG_TRUNC; copied = len; } err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied); if (err) goto out_free_skb; sock_recv_timestamp(msg, sk, skb); serr = SKB_EXT_ERR(skb); put_cmsg(msg, SOL_PACKET, PACKET_TX_TIMESTAMP, sizeof(serr->ee), &serr->ee); msg->msg_flags \|= MSG_ERRQUEUE; err = copied; /* Reset and regenerate socket error / spin_lock_bh(&sk->sk_error_queue.lock); sk->sk_err = 0; if ((skb2 = skb_peek(&sk->sk_error_queue)) != NULL) { sk->sk_err = SKB_EXT_ERR(skb2)->ee.ee_errno; spin_unlock_bh(&sk->sk_error_queue.lock); sk->sk_error_report(sk); } else spin_unlock_bh(&sk->sk_error_queue.lock); out_free_skb: kfree_skb(skb); out: return err; } / * Pull a packet from our receive queue and hand it to the user. * If necessary we block. / static int packet_recvmsg(struct kiocb iocb, struct socket sock, struct msghdr msg, size_t len, int flags) { struct sock sk = sock->sk; struct sk_buff skb; int copied, err; struct sockaddr_ll sll; int vnet_hdr_len = 0; err = -EINVAL; if (flags & ~(MSG_PEEK\|MSG_DONTWAIT\|MSG_TRUNC\|MSG_CMSG_COMPAT\|MSG_ERRQUEUE)) goto out; #if 0 / What error should we return now? EUNATTACH? / if (pkt_sk(sk)->ifindex < 0) return -ENODEV; #endif if (flags & MSG_ERRQUEUE) { err = packet_recv_error(sk, msg, len); goto out; } / * Call the generic datagram receiver. This handles all sorts * of horrible races and re-entrancy so we can forget about it * in the protocol layers. * * Now it will return ENETDOWN, if device have just gone down, * but then it will block. / skb = skb_recv_datagram(sk, flags, flags & MSG_DONTWAIT, &err); / * An error occurred so return it. Because skb_recv_datagram() * handles the blocking we don't see and worry about blocking * retries. / if (skb == NULL) goto out; if (pkt_sk(sk)->has_vnet_hdr) { struct virtio_net_hdr vnet_hdr = { 0 }; err = -EINVAL; vnet_hdr_len = sizeof(vnet_hdr); if (len < vnet_hdr_len) goto out_free; len -= vnet_hdr_len; if (skb_is_gso(skb)) { struct skb_shared_info sinfo = skb_shinfo(skb); /* This is a hint as to how much should be linear. / vnet_hdr.hdr_len = skb_headlen(skb); vnet_hdr.gso_size = sinfo->gso_size; if (sinfo->gso_type & SKB_GSO_TCPV4) vnet_hdr.gso_type = VIRTIO_NET_HDR_GSO_TCPV4; else if (sinfo->gso_type & SKB_GSO_TCPV6) vnet_hdr.gso_type = VIRTIO_NET_HDR_GSO_TCPV6; else if (sinfo->gso_type & SKB_GSO_UDP) vnet_hdr.gso_type = VIRTIO_NET_HDR_GSO_UDP; else if (sinfo->gso_type & SKB_GSO_FCOE) goto out_free; else BUG(); if (sinfo->gso_type & SKB_GSO_TCP_ECN) vnet_hdr.gso_type \|= VIRTIO_NET_HDR_GSO_ECN; } else vnet_hdr.gso_type = VIRTIO_NET_HDR_GSO_NONE; if (skb->ip_summed == CHECKSUM_PARTIAL) { vnet_hdr.flags = VIRTIO_NET_HDR_F_NEEDS_CSUM; vnet_hdr.csum_start = skb_checksum_start_offset(skb); vnet_hdr.csum_offset = skb->csum_offset; } / else everything is zero / err = memcpy_toiovec(msg->msg_iov, (void )&vnet_hdr, vnet_hdr_len); if (err < 0) goto out_free; } /* * If the address length field is there to be filled in, we fill * it in now. / sll = &PACKET_SKB_CB(skb)->sa.ll; if (sock->type == SOCK_PACKET) msg->msg_namelen = sizeof(struct sockaddr_pkt); else msg->msg_namelen = sll->sll_halen + offsetof(struct sockaddr_ll, sll_addr); / * You lose any data beyond the buffer you gave. If it worries a * user program they can ask the device for its MTU anyway. / copied = skb->len; if (copied > len) { copied = len; msg->msg_flags \|= MSG_TRUNC; } err = skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied); if (err) goto out_free; sock_recv_ts_and_drops(msg, sk, skb); if (msg->msg_name) memcpy(msg->msg_name, &PACKET_SKB_CB(skb)->sa, msg->msg_namelen); if (pkt_sk(sk)->auxdata) { struct tpacket_auxdata aux; aux.tp_status = TP_STATUS_USER; if (skb->ip_summed == CHECKSUM_PARTIAL) aux.tp_status \|= TP_STATUS_CSUMNOTREADY; aux.tp_len = PACKET_SKB_CB(skb)->origlen; aux.tp_snaplen = skb->len; aux.tp_mac = 0; aux.tp_net = skb_network_offset(skb); if (vlan_tx_tag_present(skb)) { aux.tp_vlan_tci = vlan_tx_tag_get(skb); aux.tp_status \|= TP_STATUS_VLAN_VALID; } else { aux.tp_vlan_tci = 0; } put_cmsg(msg, SOL_PACKET, PACKET_AUXDATA, sizeof(aux), &aux); } / * Free or return the buffer as appropriate. Again this * hides all the races and re-entrancy issues from us. / err = vnet_hdr_len + ((flags&MSG_TRUNC) ? skb->len : copied); out_free: skb_free_datagram(sk, skb); out: return err; } static int packet_getname_spkt(struct socket sock, struct sockaddr uaddr, int uaddr_len, int peer) { struct net_device dev; struct sock sk = sock->sk; if (peer) return -EOPNOTSUPP; uaddr->sa_family = AF_PACKET; rcu_read_lock(); dev = dev_get_by_index_rcu(sock_net(sk), pkt_sk(sk)->ifindex); if (dev) strncpy(uaddr->sa_data, dev->name, 14); else memset(uaddr->sa_data, 0, 14); rcu_read_unlock(); uaddr_len = sizeof(uaddr); return 0; } static int packet_getname(struct socket sock, struct sockaddr uaddr, int uaddr_len, int peer) { struct net_device dev; struct sock sk = sock->sk; struct packet_sock po = pkt_sk(sk); DECLARE_SOCKADDR(struct sockaddr_ll , sll, uaddr); if (peer) return -EOPNOTSUPP; sll->sll_family = AF_PACKET; sll->sll_ifindex = po->ifindex; sll->sll_protocol = po->num; sll->sll_pkttype = 0; rcu_read_lock(); dev = dev_get_by_index_rcu(sock_net(sk), po->ifindex); if (dev) { sll->sll_hatype = dev->type; sll->sll_halen = dev->addr_len; memcpy(sll->sll_addr, dev->dev_addr, dev->addr_len); } else { sll->sll_hatype = 0; / Bad: we have no ARPHRD_UNSPEC / sll->sll_halen = 0; } rcu_read_unlock(); uaddr_len = offsetof(struct sockaddr_ll, sll_addr) + sll->sll_halen; return 0; } static int packet_dev_mc(struct net_device dev, struct packet_mclist i, int what) { switch (i->type) { case PACKET_MR_MULTICAST: if (i->alen != dev->addr_len) return -EINVAL; if (what > 0) return dev_mc_add(dev, i->addr); else return dev_mc_del(dev, i->addr); break; case PACKET_MR_PROMISC: return dev_set_promiscuity(dev, what); break; case PACKET_MR_ALLMULTI: return dev_set_allmulti(dev, what); break; case PACKET_MR_UNICAST: if (i->alen != dev->addr_len) return -EINVAL; if (what > 0) return dev_uc_add(dev, i->addr); else return dev_uc_del(dev, i->addr); break; default: break; } return 0; } static void packet_dev_mclist(struct net_device dev, struct packet_mclist i, int what) { for ( ; i; i = i->next) { if (i->ifindex == dev->ifindex) packet_dev_mc(dev, i, what); } } static int packet_mc_add(struct sock sk, struct packet_mreq_max mreq) { struct packet_sock po = pkt_sk(sk); struct packet_mclist ml, i; struct net_device dev; int err; rtnl_lock(); err = -ENODEV; dev = __dev_get_by_index(sock_net(sk), mreq->mr_ifindex); if (!dev) goto done; err = -EINVAL; if (mreq->mr_alen > dev->addr_len) goto done; err = -ENOBUFS; i = kmalloc(sizeof(i), GFP_KERNEL); if (i == NULL) goto done; err = 0; for (ml = po->mclist; ml; ml = ml->next) { if (ml->ifindex == mreq->mr_ifindex && ml->type == mreq->mr_type && ml->alen == mreq->mr_alen && memcmp(ml->addr, mreq->mr_address, ml->alen) == 0) { ml->count++; / Free the new element ... / kfree(i); goto done; } } i->type = mreq->mr_type; i->ifindex = mreq->mr_ifindex; i->alen = mreq->mr_alen; memcpy(i->addr, mreq->mr_address, i->alen); i->count = 1; i->next = po->mclist; po->mclist = i; err = packet_dev_mc(dev, i, 1); if (err) { po->mclist = i->next; kfree(i); } done: rtnl_unlock(); return err; } static int packet_mc_drop(struct sock sk, struct packet_mreq_max mreq) { struct packet_mclist ml, *mlp; rtnl_lock(); for (mlp = &pkt_sk(sk)->mclist; (ml = mlp) != NULL; mlp = &ml->next) { if (ml->ifindex == mreq->mr_ifindex && ml->type == mreq->mr_type && ml->alen == mreq->mr_alen && memcmp(ml->addr, mreq->mr_address, ml->alen) == 0) { if (--ml->count == 0) { struct net_device dev; mlp = ml->next; dev = __dev_get_by_index(sock_net(sk), ml->ifindex); if (dev) packet_dev_mc(dev, ml, -1); kfree(ml); } rtnl_unlock(); return 0; } } rtnl_unlock(); return -EADDRNOTAVAIL; } static void packet_flush_mclist(struct sock sk) { struct packet_sock po = pkt_sk(sk); struct packet_mclist ml; if (!po->mclist) return; rtnl_lock(); while ((ml = po->mclist) != NULL) { struct net_device dev; po->mclist = ml->next; dev = __dev_get_by_index(sock_net(sk), ml->ifindex); if (dev != NULL) packet_dev_mc(dev, ml, -1); kfree(ml); } rtnl_unlock(); } static int packet_setsockopt(struct socket sock, int level, int optname, char __user optval, unsigned int optlen) { struct sock sk = sock->sk; struct packet_sock po = pkt_sk(sk); int ret; if (level != SOL_PACKET) return -ENOPROTOOPT; switch (optname) { case PACKET_ADD_MEMBERSHIP: case PACKET_DROP_MEMBERSHIP: { struct packet_mreq_max mreq; int len = optlen; memset(&mreq, 0, sizeof(mreq)); if (len < sizeof(struct packet_mreq)) return -EINVAL; if (len > sizeof(mreq)) len = sizeof(mreq); if (copy_from_user(&mreq, optval, len)) return -EFAULT; if (len < (mreq.mr_alen + offsetof(struct packet_mreq, mr_address))) return -EINVAL; if (optname == PACKET_ADD_MEMBERSHIP) ret = packet_mc_add(sk, &mreq); else ret = packet_mc_drop(sk, &mreq); return ret; } case PACKET_RX_RING: case PACKET_TX_RING: { struct tpacket_req req; if (optlen < sizeof(req)) return -EINVAL; if (pkt_sk(sk)->has_vnet_hdr) return -EINVAL; if (copy_from_user(&req, optval, sizeof(req))) return -EFAULT; return packet_set_ring(sk, &req, 0, optname == PACKET_TX_RING); } case PACKET_COPY_THRESH: { int val; if (optlen != sizeof(val)) return -EINVAL; if (copy_from_user(&val, optval, sizeof(val))) return -EFAULT; pkt_sk(sk)->copy_thresh = val; return 0; } case PACKET_VERSION: { int val; if (optlen != sizeof(val)) return -EINVAL; if (po->rx_ring.pg_vec \|\| po->tx_ring.pg_vec) return -EBUSY; if (copy_from_user(&val, optval, sizeof(val))) return -EFAULT; switch (val) { case TPACKET_V1: case TPACKET_V2: po->tp_version = val; return 0; default: return -EINVAL; } } case PACKET_RESERVE: { unsigned int val; if (optlen != sizeof(val)) return -EINVAL; if (po->rx_ring.pg_vec \|\| po->tx_ring.pg_vec) return -EBUSY; if (copy_from_user(&val, optval, sizeof(val))) return -EFAULT; po->tp_reserve = val; return 0; } case PACKET_LOSS: { unsigned int val; if (optlen != sizeof(val)) return -EINVAL; if (po->rx_ring.pg_vec \|\| po->tx_ring.pg_vec) return -EBUSY; if (copy_from_user(&val, optval, sizeof(val))) return -EFAULT; po->tp_loss = !!val; return 0; } case PACKET_AUXDATA: { int val; if (optlen < sizeof(val)) return -EINVAL; if (copy_from_user(&val, optval, sizeof(val))) return -EFAULT; po->auxdata = !!val; return 0; } case PACKET_ORIGDEV: { int val; if (optlen < sizeof(val)) return -EINVAL; if (copy_from_user(&val, optval, sizeof(val))) return -EFAULT; po->origdev = !!val; return 0; } case PACKET_VNET_HDR: { int val; if (sock->type != SOCK_RAW) return -EINVAL; if (po->rx_ring.pg_vec \|\| po->tx_ring.pg_vec) return -EBUSY; if (optlen < sizeof(val)) return -EINVAL; if (copy_from_user(&val, optval, sizeof(val))) return -EFAULT; po->has_vnet_hdr = !!val; return 0; } case PACKET_TIMESTAMP: { int val; if (optlen != sizeof(val)) return -EINVAL; if (copy_from_user(&val, optval, sizeof(val))) return -EFAULT; po->tp_tstamp = val; return 0; } default: return -ENOPROTOOPT; } } static int packet_getsockopt(struct socket sock, int level, int optname, char __user optval, int __user optlen) { int len; int val; struct sock sk = sock->sk; struct packet_sock po = pkt_sk(sk); void data; struct tpacket_stats st; if (level != SOL_PACKET) return -ENOPROTOOPT; if (get_user(len, optlen)) return -EFAULT; if (len < 0) return -EINVAL; switch (optname) { case PACKET_STATISTICS: if (len > sizeof(struct tpacket_stats)) len = sizeof(struct tpacket_stats); spin_lock_bh(&sk->sk_receive_queue.lock); st = po->stats; memset(&po->stats, 0, sizeof(st)); spin_unlock_bh(&sk->sk_receive_queue.lock); st.tp_packets += st.tp_drops; data = &st; break; case PACKET_AUXDATA: if (len > sizeof(int)) len = sizeof(int); val = po->auxdata; data = &val; break; case PACKET_ORIGDEV: if (len > sizeof(int)) len = sizeof(int); val = po->origdev; data = &val; break; case PACKET_VNET_HDR: if (len > sizeof(int)) len = sizeof(int); val = po->has_vnet_hdr; data = &val; break; case PACKET_VERSION: if (len > sizeof(int)) len = sizeof(int); val = po->tp_version; data = &val; break; case PACKET_HDRLEN: if (len > sizeof(int)) len = sizeof(int); if (copy_from_user(&val, optval, len)) return -EFAULT; switch (val) { case TPACKET_V1: val = sizeof(struct tpacket_hdr); break; case TPACKET_V2: val = sizeof(struct tpacket2_hdr); break; default: return -EINVAL; } data = &val; break; case PACKET_RESERVE: if (len > sizeof(unsigned int)) len = sizeof(unsigned int); val = po->tp_reserve; data = &val; break; case PACKET_LOSS: if (len > sizeof(unsigned int)) len = sizeof(unsigned int); val = po->tp_loss; data = &val; break; case PACKET_TIMESTAMP: if (len > sizeof(int)) len = sizeof(int); val = po->tp_tstamp; data = &val; break; default: return -ENOPROTOOPT; } if (put_user(len, optlen)) return -EFAULT; if (copy_to_user(optval, data, len)) return -EFAULT; return 0; } static int packet_notifier(struct notifier_block this, unsigned long msg, void data) { struct sock sk; struct hlist_node node; struct net_device dev = data; struct net net = dev_net(dev); rcu_read_lock(); sk_for_each_rcu(sk, node, &net->packet.sklist) { struct packet_sock po = pkt_sk(sk); switch (msg) { case NETDEV_UNREGISTER: if (po->mclist) packet_dev_mclist(dev, po->mclist, -1); / fallthrough / case NETDEV_DOWN: if (dev->ifindex == po->ifindex) { spin_lock(&po->bind_lock); if (po->running) { __dev_remove_pack(&po->prot_hook); __sock_put(sk); po->running = 0; sk->sk_err = ENETDOWN; if (!sock_flag(sk, SOCK_DEAD)) sk->sk_error_report(sk); } if (msg == NETDEV_UNREGISTER) { po->ifindex = -1; po->prot_hook.dev = NULL; } spin_unlock(&po->bind_lock); } break; case NETDEV_UP: if (dev->ifindex == po->ifindex) { spin_lock(&po->bind_lock); if (po->num && !po->running) { dev_add_pack(&po->prot_hook); sock_hold(sk); po->running = 1; } spin_unlock(&po->bind_lock); } break; } } rcu_read_unlock(); return NOTIFY_DONE; } static int packet_ioctl(struct socket sock, unsigned int cmd, unsigned long arg) { struct sock sk = sock->sk; switch (cmd) { case SIOCOUTQ: { int amount = sk_wmem_alloc_get(sk); return put_user(amount, (int __user )arg); } case SIOCINQ: { struct sk_buff skb; int amount = 0; spin_lock_bh(&sk->sk_receive_queue.lock); skb = skb_peek(&sk->sk_receive_queue); if (skb) amount = skb->len; spin_unlock_bh(&sk->sk_receive_queue.lock); return put_user(amount, (int __user )arg); } case SIOCGSTAMP: return sock_get_timestamp(sk, (struct timeval __user )arg); case SIOCGSTAMPNS: return sock_get_timestampns(sk, (struct timespec __user )arg); #ifdef CONFIG_INET case SIOCADDRT: case SIOCDELRT: case SIOCDARP: case SIOCGARP: case SIOCSARP: case SIOCGIFADDR: case SIOCSIFADDR: case SIOCGIFBRDADDR: case SIOCSIFBRDADDR: case SIOCGIFNETMASK: case SIOCSIFNETMASK: case SIOCGIFDSTADDR: case SIOCSIFDSTADDR: case SIOCSIFFLAGS: return inet_dgram_ops.ioctl(sock, cmd, arg); #endif default: return -ENOIOCTLCMD; } return 0; } static unsigned int packet_poll(struct file file, struct socket sock, poll_table wait) { struct sock sk = sock->sk; struct packet_sock po = pkt_sk(sk); unsigned int mask = datagram_poll(file, sock, wait); spin_lock_bh(&sk->sk_receive_queue.lock); if (po->rx_ring.pg_vec) { if (!packet_previous_frame(po, &po->rx_ring, TP_STATUS_KERNEL)) mask \|= POLLIN \| POLLRDNORM; } spin_unlock_bh(&sk->sk_receive_queue.lock); spin_lock_bh(&sk->sk_write_queue.lock); if (po->tx_ring.pg_vec) { if (packet_current_frame(po, &po->tx_ring, TP_STATUS_AVAILABLE)) mask \|= POLLOUT \| POLLWRNORM; } spin_unlock_bh(&sk->sk_write_queue.lock); return mask; } / Dirty? Well, I still did not learn better way to account * for user mmaps. / static void packet_mm_open(struct vm_area_struct vma) { struct file file = vma->vm_file; struct socket sock = file->private_data; struct sock sk = sock->sk; if (sk) atomic_inc(&pkt_sk(sk)->mapped); } static void packet_mm_close(struct vm_area_struct vma) { struct file file = vma->vm_file; struct socket sock = file->private_data; struct sock sk = sock->sk; if (sk) atomic_dec(&pkt_sk(sk)->mapped); } static const struct vm_operations_struct packet_mmap_ops = { .open = packet_mm_open, .close = packet_mm_close, }; static void free_pg_vec(struct pgv pg_vec, unsigned int order, unsigned int len) { int i; for (i = 0; i < len; i++) { if (likely(pg_vec[i].buffer)) { if (is_vmalloc_addr(pg_vec[i].buffer)) vfree(pg_vec[i].buffer); else free_pages((unsigned long)pg_vec[i].buffer, order); pg_vec[i].buffer = NULL; } } kfree(pg_vec); } static inline char alloc_one_pg_vec_page(unsigned long order) { char buffer = NULL; gfp_t gfp_flags = GFP_KERNEL \| __GFP_COMP \| __GFP_ZERO \| __GFP_NOWARN \| __GFP_NORETRY; buffer = (char ) __get_free_pages(gfp_flags, order); if (buffer) return buffer; / * __get_free_pages failed, fall back to vmalloc / buffer = vzalloc((1 << order) PAGE_SIZE); if (buffer) return buffer; /* * vmalloc failed, lets dig into swap here / gfp_flags &= ~__GFP_NORETRY; buffer = (char )__get_free_pages(gfp_flags, order); if (buffer) return buffer; /* * complete and utter failure / return NULL; } static struct pgv alloc_pg_vec(struct tpacket_req req, int order) { unsigned int block_nr = req->tp_block_nr; struct pgv pg_vec; int i; pg_vec = kcalloc(block_nr, sizeof(struct pgv), GFP_KERNEL); if (unlikely(!pg_vec)) goto out; for (i = 0; i < block_nr; i++) { pg_vec[i].buffer = alloc_one_pg_vec_page(order); if (unlikely(!pg_vec[i].buffer)) goto out_free_pgvec; } out: return pg_vec; out_free_pgvec: free_pg_vec(pg_vec, order, block_nr); pg_vec = NULL; goto out; } static int packet_set_ring(struct sock sk, struct tpacket_req req, int closing, int tx_ring) { struct pgv pg_vec = NULL; struct packet_sock po = pkt_sk(sk); int was_running, order = 0; struct packet_ring_buffer rb; struct sk_buff_head rb_queue; __be16 num; int err; rb = tx_ring ? &po->tx_ring : &po->rx_ring; rb_queue = tx_ring ? &sk->sk_write_queue : &sk->sk_receive_queue; err = -EBUSY; if (!closing) { if (atomic_read(&po->mapped)) goto out; if (atomic_read(&rb->pending)) goto out; } if (req->tp_block_nr) { /* Sanity tests and some calculations / err = -EBUSY; if (unlikely(rb->pg_vec)) goto out; switch (po->tp_version) { case TPACKET_V1: po->tp_hdrlen = TPACKET_HDRLEN; break; case TPACKET_V2: po->tp_hdrlen = TPACKET2_HDRLEN; break; } err = -EINVAL; if (unlikely((int)req->tp_block_size <= 0)) goto out; if (unlikely(req->tp_block_size & (PAGE_SIZE - 1))) goto out; if (unlikely(req->tp_frame_size < po->tp_hdrlen + po->tp_reserve)) goto out; if (unlikely(req->tp_frame_size & (TPACKET_ALIGNMENT - 1))) goto out; rb->frames_per_block = req->tp_block_size/req->tp_frame_size; if (unlikely(rb->frames_per_block <= 0)) goto out; if (unlikely((rb->frames_per_block req->tp_block_nr) != req->tp_frame_nr)) goto out; err = -ENOMEM; order = get_order(req->tp_block_size); pg_vec = alloc_pg_vec(req, order); if (unlikely(!pg_vec)) goto out; } /* Done / else { err = -EINVAL; if (unlikely(req->tp_frame_nr)) goto out; } lock_sock(sk); / Detach socket from network / spin_lock(&po->bind_lock); was_running = po->running; num = po->num; if (was_running) { __dev_remove_pack(&po->prot_hook); po->num = 0; po->running = 0; __sock_put(sk); } spin_unlock(&po->bind_lock); synchronize_net(); err = -EBUSY; mutex_lock(&po->pg_vec_lock); if (closing \|\| atomic_read(&po->mapped) == 0) { err = 0; spin_lock_bh(&rb_queue->lock); swap(rb->pg_vec, pg_vec); rb->frame_max = (req->tp_frame_nr - 1); rb->head = 0; rb->frame_size = req->tp_frame_size; spin_unlock_bh(&rb_queue->lock); swap(rb->pg_vec_order, order); swap(rb->pg_vec_len, req->tp_block_nr); rb->pg_vec_pages = req->tp_block_size/PAGE_SIZE; po->prot_hook.func = (po->rx_ring.pg_vec) ? tpacket_rcv : packet_rcv; skb_queue_purge(rb_queue); if (atomic_read(&po->mapped)) pr_err("packet_mmap: vma is busy: %d\n", atomic_read(&po->mapped)); } mutex_unlock(&po->pg_vec_lock); spin_lock(&po->bind_lock); if (was_running && !po->running) { sock_hold(sk); po->running = 1; po->num = num; dev_add_pack(&po->prot_hook); } spin_unlock(&po->bind_lock); release_sock(sk); if (pg_vec) free_pg_vec(pg_vec, order, req->tp_block_nr); out: return err; } static int packet_mmap(struct file file, struct socket sock, struct vm_area_struct vma) { struct sock sk = sock->sk; struct packet_sock po = pkt_sk(sk); unsigned long size, expected_size; struct packet_ring_buffer rb; unsigned long start; int err = -EINVAL; int i; if (vma->vm_pgoff) return -EINVAL; mutex_lock(&po->pg_vec_lock); expected_size = 0; for (rb = &po->rx_ring; rb <= &po->tx_ring; rb++) { if (rb->pg_vec) { expected_size += rb->pg_vec_len rb->pg_vec_pages * PAGE_SIZE; } } if (expected_size == 0) goto out; size = vma->vm_end - vma->vm_start; if (size != expected_size) goto out; start = vma->vm_start; for (rb = &po->rx_ring; rb <= &po->tx_ring; rb++) { if (rb->pg_vec == NULL) continue; for (i = 0; i < rb->pg_vec_len; i++) { struct page page; void kaddr = rb->pg_vec[i].buffer; int pg_num; for (pg_num = 0; pg_num < rb->pg_vec_pages; pg_num++) { page = pgv_to_page(kaddr); err = vm_insert_page(vma, start, page); if (unlikely(err)) goto out; start += PAGE_SIZE; kaddr += PAGE_SIZE; } } } atomic_inc(&po->mapped); vma->vm_ops = &packet_mmap_ops; err = 0; out: mutex_unlock(&po->pg_vec_lock); return err; } static const struct proto_ops packet_ops_spkt = { .family = PF_PACKET, .owner = THIS_MODULE, .release = packet_release, .bind = packet_bind_spkt, .connect = sock_no_connect, .socketpair = sock_no_socketpair, .accept = sock_no_accept, .getname = packet_getname_spkt, .poll = datagram_poll, .ioctl = packet_ioctl, .listen = sock_no_listen, .shutdown = sock_no_shutdown, .setsockopt = sock_no_setsockopt, .getsockopt = sock_no_getsockopt, .sendmsg = packet_sendmsg_spkt, .recvmsg = packet_recvmsg, .mmap = sock_no_mmap, .sendpage = sock_no_sendpage, }; static const struct proto_ops packet_ops = { .family = PF_PACKET, .owner = THIS_MODULE, .release = packet_release, .bind = packet_bind, .connect = sock_no_connect, .socketpair = sock_no_socketpair, .accept = sock_no_accept, .getname = packet_getname, .poll = packet_poll, .ioctl = packet_ioctl, .listen = sock_no_listen, .shutdown = sock_no_shutdown, .setsockopt = packet_setsockopt, .getsockopt = packet_getsockopt, .sendmsg = packet_sendmsg, .recvmsg = packet_recvmsg, .mmap = packet_mmap, .sendpage = sock_no_sendpage, }; static const struct net_proto_family packet_family_ops = { .family = PF_PACKET, .create = packet_create, .owner = THIS_MODULE, }; static struct notifier_block packet_netdev_notifier = { .notifier_call = packet_notifier, }; #ifdef CONFIG_PROC_FS static void packet_seq_start(struct seq_file seq, loff_t pos) __acquires(RCU) { struct net net = seq_file_net(seq); rcu_read_lock(); return seq_hlist_start_head_rcu(&net->packet.sklist, pos); } static void packet_seq_next(struct seq_file seq, void v, loff_t pos) { struct net net = seq_file_net(seq); return seq_hlist_next_rcu(v, &net->packet.sklist, pos); } static void packet_seq_stop(struct seq_file seq, void v) __releases(RCU) { rcu_read_unlock(); } static int packet_seq_show(struct seq_file seq, void v) { if (v == SEQ_START_TOKEN) seq_puts(seq, "sk RefCnt Type Proto Iface R Rmem User Inode\n"); else { struct sock s = sk_entry(v); const struct packet_sock po = pkt_sk(s); seq_printf(seq, "%pK %-6d %-4d %04x %-5d %1d %-6u %-6u %-6lu\n", s, atomic_read(&s->sk_refcnt), s->sk_type, ntohs(po->num), po->ifindex, po->running, atomic_read(&s->sk_rmem_alloc), sock_i_uid(s), sock_i_ino(s)); } return 0; } static const struct seq_operations packet_seq_ops = { .start = packet_seq_start, .next = packet_seq_next, .stop = packet_seq_stop, .show = packet_seq_show, }; static int packet_seq_open(struct inode inode, struct file file) { return seq_open_net(inode, file, &packet_seq_ops, sizeof(struct seq_net_private)); } static const struct file_operations packet_seq_fops = { .owner = THIS_MODULE, .open = packet_seq_open, .read = seq_read, .llseek = seq_lseek, .release = seq_release_net, }; #endif static int __net_init packet_net_init(struct net net) { spin_lock_init(&net->packet.sklist_lock); INIT_HLIST_HEAD(&net->packet.sklist); if (!proc_net_fops_create(net, "packet", 0, &packet_seq_fops)) return -ENOMEM; return 0; } static void __net_exit packet_net_exit(struct net net) { proc_net_remove(net, "packet"); } static struct pernet_operations packet_net_ops = { .init = packet_net_init, .exit = packet_net_exit, }; static void __exit packet_exit(void) { unregister_netdevice_notifier(&packet_netdev_notifier); unregister_pernet_subsys(&packet_net_ops); sock_unregister(PF_PACKET); proto_unregister(&packet_proto); } static int __init packet_init(void) { int rc = proto_register(&packet_proto, 0); if (rc != 0) goto out; sock_register(&packet_family_ops); register_pernet_subsys(&packet_net_ops); register_netdevice_notifier(&packet_netdev_notifier); out: return rc; } module_init(packet_init); module_exit(packet_exit); MODULE_LICENSE("GPL"); MODULE_ALIAS_NETPROTO(PF_PACKET);	./CrossVul/dataset_final_sorted/CWE-264/c/bad_3482_1
crossvul-cpp_data_bad_5618_0	/* * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as * published by the Free Software Foundation, version 2 of the * License. / #include <linux/export.h> #include <linux/nsproxy.h> #include <linux/slab.h> #include <linux/user_namespace.h> #include <linux/proc_fs.h> #include <linux/highuid.h> #include <linux/cred.h> #include <linux/securebits.h> #include <linux/keyctl.h> #include <linux/key-type.h> #include <keys/user-type.h> #include <linux/seq_file.h> #include <linux/fs.h> #include <linux/uaccess.h> #include <linux/ctype.h> #include <linux/projid.h> #include <linux/fs_struct.h> static struct kmem_cache user_ns_cachep __read_mostly; static bool new_idmap_permitted(struct user_namespace ns, int cap_setid, struct uid_gid_map map); static void set_cred_user_ns(struct cred cred, struct user_namespace user_ns) { /* Start with the same capabilities as init but useless for doing * anything as the capabilities are bound to the new user namespace. / cred->securebits = SECUREBITS_DEFAULT; cred->cap_inheritable = CAP_EMPTY_SET; cred->cap_permitted = CAP_FULL_SET; cred->cap_effective = CAP_FULL_SET; cred->cap_bset = CAP_FULL_SET; #ifdef CONFIG_KEYS key_put(cred->request_key_auth); cred->request_key_auth = NULL; #endif / tgcred will be cleared in our caller bc CLONE_THREAD won't be set / cred->user_ns = user_ns; } / * Create a new user namespace, deriving the creator from the user in the * passed credentials, and replacing that user with the new root user for the * new namespace. * * This is called by copy_creds(), which will finish setting the target task's * credentials. / int create_user_ns(struct cred new) { struct user_namespace ns, parent_ns = new->user_ns; kuid_t owner = new->euid; kgid_t group = new->egid; int ret; /* * Verify that we can not violate the policy of which files * may be accessed that is specified by the root directory, * by verifing that the root directory is at the root of the * mount namespace which allows all files to be accessed. / if (current_chrooted()) return -EPERM; / The creator needs a mapping in the parent user namespace * or else we won't be able to reasonably tell userspace who * created a user_namespace. / if (!kuid_has_mapping(parent_ns, owner) \|\| !kgid_has_mapping(parent_ns, group)) return -EPERM; ns = kmem_cache_zalloc(user_ns_cachep, GFP_KERNEL); if (!ns) return -ENOMEM; ret = proc_alloc_inum(&ns->proc_inum); if (ret) { kmem_cache_free(user_ns_cachep, ns); return ret; } atomic_set(&ns->count, 1); / Leave the new->user_ns reference with the new user namespace. / ns->parent = parent_ns; ns->owner = owner; ns->group = group; set_cred_user_ns(new, ns); update_mnt_policy(ns); return 0; } int unshare_userns(unsigned long unshare_flags, struct cred new_cred) { struct cred cred; if (!(unshare_flags & CLONE_NEWUSER)) return 0; cred = prepare_creds(); if (!cred) return -ENOMEM; new_cred = cred; return create_user_ns(cred); } void free_user_ns(struct user_namespace ns) { struct user_namespace parent; do { parent = ns->parent; proc_free_inum(ns->proc_inum); kmem_cache_free(user_ns_cachep, ns); ns = parent; } while (atomic_dec_and_test(&parent->count)); } EXPORT_SYMBOL(free_user_ns); static u32 map_id_range_down(struct uid_gid_map map, u32 id, u32 count) { unsigned idx, extents; u32 first, last, id2; id2 = id + count - 1; /* Find the matching extent / extents = map->nr_extents; smp_read_barrier_depends(); for (idx = 0; idx < extents; idx++) { first = map->extent[idx].first; last = first + map->extent[idx].count - 1; if (id >= first && id <= last && (id2 >= first && id2 <= last)) break; } / Map the id or note failure / if (idx < extents) id = (id - first) + map->extent[idx].lower_first; else id = (u32) -1; return id; } static u32 map_id_down(struct uid_gid_map map, u32 id) { unsigned idx, extents; u32 first, last; /* Find the matching extent / extents = map->nr_extents; smp_read_barrier_depends(); for (idx = 0; idx < extents; idx++) { first = map->extent[idx].first; last = first + map->extent[idx].count - 1; if (id >= first && id <= last) break; } / Map the id or note failure / if (idx < extents) id = (id - first) + map->extent[idx].lower_first; else id = (u32) -1; return id; } static u32 map_id_up(struct uid_gid_map map, u32 id) { unsigned idx, extents; u32 first, last; /* Find the matching extent / extents = map->nr_extents; smp_read_barrier_depends(); for (idx = 0; idx < extents; idx++) { first = map->extent[idx].lower_first; last = first + map->extent[idx].count - 1; if (id >= first && id <= last) break; } / Map the id or note failure / if (idx < extents) id = (id - first) + map->extent[idx].first; else id = (u32) -1; return id; } /* * make_kuid - Map a user-namespace uid pair into a kuid. * @ns: User namespace that the uid is in * @uid: User identifier * * Maps a user-namespace uid pair into a kernel internal kuid, * and returns that kuid. * * When there is no mapping defined for the user-namespace uid * pair INVALID_UID is returned. Callers are expected to test * for and handle handle INVALID_UID being returned. INVALID_UID * may be tested for using uid_valid(). / kuid_t make_kuid(struct user_namespace ns, uid_t uid) { /* Map the uid to a global kernel uid / return KUIDT_INIT(map_id_down(&ns->uid_map, uid)); } EXPORT_SYMBOL(make_kuid); /* * from_kuid - Create a uid from a kuid user-namespace pair. * @targ: The user namespace we want a uid in. * @kuid: The kernel internal uid to start with. * * Map @kuid into the user-namespace specified by @targ and * return the resulting uid. * * There is always a mapping into the initial user_namespace. * * If @kuid has no mapping in @targ (uid_t)-1 is returned. / uid_t from_kuid(struct user_namespace targ, kuid_t kuid) { /* Map the uid from a global kernel uid / return map_id_up(&targ->uid_map, __kuid_val(kuid)); } EXPORT_SYMBOL(from_kuid); /* * from_kuid_munged - Create a uid from a kuid user-namespace pair. * @targ: The user namespace we want a uid in. * @kuid: The kernel internal uid to start with. * * Map @kuid into the user-namespace specified by @targ and * return the resulting uid. * * There is always a mapping into the initial user_namespace. * * Unlike from_kuid from_kuid_munged never fails and always * returns a valid uid. This makes from_kuid_munged appropriate * for use in syscalls like stat and getuid where failing the * system call and failing to provide a valid uid are not an * options. * * If @kuid has no mapping in @targ overflowuid is returned. / uid_t from_kuid_munged(struct user_namespace targ, kuid_t kuid) { uid_t uid; uid = from_kuid(targ, kuid); if (uid == (uid_t) -1) uid = overflowuid; return uid; } EXPORT_SYMBOL(from_kuid_munged); /** * make_kgid - Map a user-namespace gid pair into a kgid. * @ns: User namespace that the gid is in * @uid: group identifier * * Maps a user-namespace gid pair into a kernel internal kgid, * and returns that kgid. * * When there is no mapping defined for the user-namespace gid * pair INVALID_GID is returned. Callers are expected to test * for and handle INVALID_GID being returned. INVALID_GID may be * tested for using gid_valid(). / kgid_t make_kgid(struct user_namespace ns, gid_t gid) { /* Map the gid to a global kernel gid / return KGIDT_INIT(map_id_down(&ns->gid_map, gid)); } EXPORT_SYMBOL(make_kgid); /* * from_kgid - Create a gid from a kgid user-namespace pair. * @targ: The user namespace we want a gid in. * @kgid: The kernel internal gid to start with. * * Map @kgid into the user-namespace specified by @targ and * return the resulting gid. * * There is always a mapping into the initial user_namespace. * * If @kgid has no mapping in @targ (gid_t)-1 is returned. / gid_t from_kgid(struct user_namespace targ, kgid_t kgid) { /* Map the gid from a global kernel gid / return map_id_up(&targ->gid_map, __kgid_val(kgid)); } EXPORT_SYMBOL(from_kgid); /* * from_kgid_munged - Create a gid from a kgid user-namespace pair. * @targ: The user namespace we want a gid in. * @kgid: The kernel internal gid to start with. * * Map @kgid into the user-namespace specified by @targ and * return the resulting gid. * * There is always a mapping into the initial user_namespace. * * Unlike from_kgid from_kgid_munged never fails and always * returns a valid gid. This makes from_kgid_munged appropriate * for use in syscalls like stat and getgid where failing the * system call and failing to provide a valid gid are not options. * * If @kgid has no mapping in @targ overflowgid is returned. / gid_t from_kgid_munged(struct user_namespace targ, kgid_t kgid) { gid_t gid; gid = from_kgid(targ, kgid); if (gid == (gid_t) -1) gid = overflowgid; return gid; } EXPORT_SYMBOL(from_kgid_munged); /** * make_kprojid - Map a user-namespace projid pair into a kprojid. * @ns: User namespace that the projid is in * @projid: Project identifier * * Maps a user-namespace uid pair into a kernel internal kuid, * and returns that kuid. * * When there is no mapping defined for the user-namespace projid * pair INVALID_PROJID is returned. Callers are expected to test * for and handle handle INVALID_PROJID being returned. INVALID_PROJID * may be tested for using projid_valid(). / kprojid_t make_kprojid(struct user_namespace ns, projid_t projid) { /* Map the uid to a global kernel uid / return KPROJIDT_INIT(map_id_down(&ns->projid_map, projid)); } EXPORT_SYMBOL(make_kprojid); /* * from_kprojid - Create a projid from a kprojid user-namespace pair. * @targ: The user namespace we want a projid in. * @kprojid: The kernel internal project identifier to start with. * * Map @kprojid into the user-namespace specified by @targ and * return the resulting projid. * * There is always a mapping into the initial user_namespace. * * If @kprojid has no mapping in @targ (projid_t)-1 is returned. / projid_t from_kprojid(struct user_namespace targ, kprojid_t kprojid) { /* Map the uid from a global kernel uid / return map_id_up(&targ->projid_map, __kprojid_val(kprojid)); } EXPORT_SYMBOL(from_kprojid); /* * from_kprojid_munged - Create a projiid from a kprojid user-namespace pair. * @targ: The user namespace we want a projid in. * @kprojid: The kernel internal projid to start with. * * Map @kprojid into the user-namespace specified by @targ and * return the resulting projid. * * There is always a mapping into the initial user_namespace. * * Unlike from_kprojid from_kprojid_munged never fails and always * returns a valid projid. This makes from_kprojid_munged * appropriate for use in syscalls like stat and where * failing the system call and failing to provide a valid projid are * not an options. * * If @kprojid has no mapping in @targ OVERFLOW_PROJID is returned. / projid_t from_kprojid_munged(struct user_namespace targ, kprojid_t kprojid) { projid_t projid; projid = from_kprojid(targ, kprojid); if (projid == (projid_t) -1) projid = OVERFLOW_PROJID; return projid; } EXPORT_SYMBOL(from_kprojid_munged); static int uid_m_show(struct seq_file seq, void v) { struct user_namespace ns = seq->private; struct uid_gid_extent extent = v; struct user_namespace lower_ns; uid_t lower; lower_ns = seq_user_ns(seq); if ((lower_ns == ns) && lower_ns->parent) lower_ns = lower_ns->parent; lower = from_kuid(lower_ns, KUIDT_INIT(extent->lower_first)); seq_printf(seq, "%10u %10u %10u\n", extent->first, lower, extent->count); return 0; } static int gid_m_show(struct seq_file seq, void v) { struct user_namespace ns = seq->private; struct uid_gid_extent extent = v; struct user_namespace lower_ns; gid_t lower; lower_ns = seq_user_ns(seq); if ((lower_ns == ns) && lower_ns->parent) lower_ns = lower_ns->parent; lower = from_kgid(lower_ns, KGIDT_INIT(extent->lower_first)); seq_printf(seq, "%10u %10u %10u\n", extent->first, lower, extent->count); return 0; } static int projid_m_show(struct seq_file seq, void v) { struct user_namespace ns = seq->private; struct uid_gid_extent extent = v; struct user_namespace lower_ns; projid_t lower; lower_ns = seq_user_ns(seq); if ((lower_ns == ns) && lower_ns->parent) lower_ns = lower_ns->parent; lower = from_kprojid(lower_ns, KPROJIDT_INIT(extent->lower_first)); seq_printf(seq, "%10u %10u %10u\n", extent->first, lower, extent->count); return 0; } static void m_start(struct seq_file seq, loff_t ppos, struct uid_gid_map map) { struct uid_gid_extent extent = NULL; loff_t pos = ppos; if (pos < map->nr_extents) extent = &map->extent[pos]; return extent; } static void uid_m_start(struct seq_file seq, loff_t ppos) { struct user_namespace ns = seq->private; return m_start(seq, ppos, &ns->uid_map); } static void gid_m_start(struct seq_file seq, loff_t ppos) { struct user_namespace ns = seq->private; return m_start(seq, ppos, &ns->gid_map); } static void projid_m_start(struct seq_file seq, loff_t ppos) { struct user_namespace ns = seq->private; return m_start(seq, ppos, &ns->projid_map); } static void m_next(struct seq_file seq, void v, loff_t pos) { (pos)++; return seq->op->start(seq, pos); } static void m_stop(struct seq_file seq, void v) { return; } struct seq_operations proc_uid_seq_operations = { .start = uid_m_start, .stop = m_stop, .next = m_next, .show = uid_m_show, }; struct seq_operations proc_gid_seq_operations = { .start = gid_m_start, .stop = m_stop, .next = m_next, .show = gid_m_show, }; struct seq_operations proc_projid_seq_operations = { .start = projid_m_start, .stop = m_stop, .next = m_next, .show = projid_m_show, }; static bool mappings_overlap(struct uid_gid_map new_map, struct uid_gid_extent extent) { u32 upper_first, lower_first, upper_last, lower_last; unsigned idx; upper_first = extent->first; lower_first = extent->lower_first; upper_last = upper_first + extent->count - 1; lower_last = lower_first + extent->count - 1; for (idx = 0; idx < new_map->nr_extents; idx++) { u32 prev_upper_first, prev_lower_first; u32 prev_upper_last, prev_lower_last; struct uid_gid_extent prev; prev = &new_map->extent[idx]; prev_upper_first = prev->first; prev_lower_first = prev->lower_first; prev_upper_last = prev_upper_first + prev->count - 1; prev_lower_last = prev_lower_first + prev->count - 1; / Does the upper range intersect a previous extent? / if ((prev_upper_first <= upper_last) && (prev_upper_last >= upper_first)) return true; / Does the lower range intersect a previous extent? / if ((prev_lower_first <= lower_last) && (prev_lower_last >= lower_first)) return true; } return false; } static DEFINE_MUTEX(id_map_mutex); static ssize_t map_write(struct file file, const char __user buf, size_t count, loff_t ppos, int cap_setid, struct uid_gid_map map, struct uid_gid_map parent_map) { struct seq_file seq = file->private_data; struct user_namespace ns = seq->private; struct uid_gid_map new_map; unsigned idx; struct uid_gid_extent extent = NULL; unsigned long page = 0; char kbuf, pos, next_line; ssize_t ret = -EINVAL; /* * The id_map_mutex serializes all writes to any given map. * * Any map is only ever written once. * * An id map fits within 1 cache line on most architectures. * * On read nothing needs to be done unless you are on an * architecture with a crazy cache coherency model like alpha. * * There is a one time data dependency between reading the * count of the extents and the values of the extents. The * desired behavior is to see the values of the extents that * were written before the count of the extents. * * To achieve this smp_wmb() is used on guarantee the write * order and smp_read_barrier_depends() is guaranteed that we * don't have crazy architectures returning stale data. * / mutex_lock(&id_map_mutex); ret = -EPERM; / Only allow one successful write to the map / if (map->nr_extents != 0) goto out; / Require the appropriate privilege CAP_SETUID or CAP_SETGID * over the user namespace in order to set the id mapping. / if (cap_valid(cap_setid) && !ns_capable(ns, cap_setid)) goto out; / Get a buffer / ret = -ENOMEM; page = __get_free_page(GFP_TEMPORARY); kbuf = (char ) page; if (!page) goto out; /* Only allow <= page size writes at the beginning of the file / ret = -EINVAL; if ((ppos != 0) \|\| (count >= PAGE_SIZE)) goto out; /* Slurp in the user data / ret = -EFAULT; if (copy_from_user(kbuf, buf, count)) goto out; kbuf[count] = '\0'; / Parse the user data / ret = -EINVAL; pos = kbuf; new_map.nr_extents = 0; for (;pos; pos = next_line) { extent = &new_map.extent[new_map.nr_extents]; / Find the end of line and ensure I don't look past it / next_line = strchr(pos, '\n'); if (next_line) { next_line = '\0'; next_line++; if (next_line == '\0') next_line = NULL; } pos = skip_spaces(pos); extent->first = simple_strtoul(pos, &pos, 10); if (!isspace(pos)) goto out; pos = skip_spaces(pos); extent->lower_first = simple_strtoul(pos, &pos, 10); if (!isspace(pos)) goto out; pos = skip_spaces(pos); extent->count = simple_strtoul(pos, &pos, 10); if (pos && !isspace(pos)) goto out; / Verify there is not trailing junk on the line / pos = skip_spaces(pos); if (pos != '\0') goto out; /* Verify we have been given valid starting values / if ((extent->first == (u32) -1) \|\| (extent->lower_first == (u32) -1 )) goto out; / Verify count is not zero and does not cause the extent to wrap / if ((extent->first + extent->count) <= extent->first) goto out; if ((extent->lower_first + extent->count) <= extent->lower_first) goto out; / Do the ranges in extent overlap any previous extents? / if (mappings_overlap(&new_map, extent)) goto out; new_map.nr_extents++; / Fail if the file contains too many extents / if ((new_map.nr_extents == UID_GID_MAP_MAX_EXTENTS) && (next_line != NULL)) goto out; } / Be very certaint the new map actually exists / if (new_map.nr_extents == 0) goto out; ret = -EPERM; / Validate the user is allowed to use user id's mapped to. / if (!new_idmap_permitted(ns, cap_setid, &new_map)) goto out; / Map the lower ids from the parent user namespace to the * kernel global id space. / for (idx = 0; idx < new_map.nr_extents; idx++) { u32 lower_first; extent = &new_map.extent[idx]; lower_first = map_id_range_down(parent_map, extent->lower_first, extent->count); / Fail if we can not map the specified extent to * the kernel global id space. / if (lower_first == (u32) -1) goto out; extent->lower_first = lower_first; } / Install the map / memcpy(map->extent, new_map.extent, new_map.nr_extentssizeof(new_map.extent[0])); smp_wmb(); map->nr_extents = new_map.nr_extents; ppos = count; ret = count; out: mutex_unlock(&id_map_mutex); if (page) free_page(page); return ret; } ssize_t proc_uid_map_write(struct file file, const char __user buf, size_t size, loff_t ppos) { struct seq_file seq = file->private_data; struct user_namespace ns = seq->private; struct user_namespace seq_ns = seq_user_ns(seq); if (!ns->parent) return -EPERM; if ((seq_ns != ns) && (seq_ns != ns->parent)) return -EPERM; return map_write(file, buf, size, ppos, CAP_SETUID, &ns->uid_map, &ns->parent->uid_map); } ssize_t proc_gid_map_write(struct file file, const char __user buf, size_t size, loff_t ppos) { struct seq_file seq = file->private_data; struct user_namespace ns = seq->private; struct user_namespace seq_ns = seq_user_ns(seq); if (!ns->parent) return -EPERM; if ((seq_ns != ns) && (seq_ns != ns->parent)) return -EPERM; return map_write(file, buf, size, ppos, CAP_SETGID, &ns->gid_map, &ns->parent->gid_map); } ssize_t proc_projid_map_write(struct file file, const char __user buf, size_t size, loff_t ppos) { struct seq_file seq = file->private_data; struct user_namespace ns = seq->private; struct user_namespace seq_ns = seq_user_ns(seq); if (!ns->parent) return -EPERM; if ((seq_ns != ns) && (seq_ns != ns->parent)) return -EPERM; / Anyone can set any valid project id no capability needed / return map_write(file, buf, size, ppos, -1, &ns->projid_map, &ns->parent->projid_map); } static bool new_idmap_permitted(struct user_namespace ns, int cap_setid, struct uid_gid_map new_map) { / Allow mapping to your own filesystem ids / if ((new_map->nr_extents == 1) && (new_map->extent[0].count == 1)) { u32 id = new_map->extent[0].lower_first; if (cap_setid == CAP_SETUID) { kuid_t uid = make_kuid(ns->parent, id); if (uid_eq(uid, current_fsuid())) return true; } else if (cap_setid == CAP_SETGID) { kgid_t gid = make_kgid(ns->parent, id); if (gid_eq(gid, current_fsgid())) return true; } } / Allow anyone to set a mapping that doesn't require privilege / if (!cap_valid(cap_setid)) return true; / Allow the specified ids if we have the appropriate capability * (CAP_SETUID or CAP_SETGID) over the parent user namespace. / if (ns_capable(ns->parent, cap_setid)) return true; return false; } static void userns_get(struct task_struct task) { struct user_namespace user_ns; rcu_read_lock(); user_ns = get_user_ns(__task_cred(task)->user_ns); rcu_read_unlock(); return user_ns; } static void userns_put(void ns) { put_user_ns(ns); } static int userns_install(struct nsproxy nsproxy, void ns) { struct user_namespace user_ns = ns; struct cred cred; / Don't allow gaining capabilities by reentering * the same user namespace. / if (user_ns == current_user_ns()) return -EINVAL; / Threaded processes may not enter a different user namespace / if (atomic_read(&current->mm->mm_users) > 1) return -EINVAL; if (current->fs->users != 1) return -EINVAL; if (!ns_capable(user_ns, CAP_SYS_ADMIN)) return -EPERM; cred = prepare_creds(); if (!cred) return -ENOMEM; put_user_ns(cred->user_ns); set_cred_user_ns(cred, get_user_ns(user_ns)); return commit_creds(cred); } static unsigned int userns_inum(void ns) { struct user_namespace *user_ns = ns; return user_ns->proc_inum; } const struct proc_ns_operations userns_operations = { .name = "user", .type = CLONE_NEWUSER, .get = userns_get, .put = userns_put, .install = userns_install, .inum = userns_inum, }; static __init int user_namespaces_init(void) { user_ns_cachep = KMEM_CACHE(user_namespace, SLAB_PANIC); return 0; } module_init(user_namespaces_init);	./CrossVul/dataset_final_sorted/CWE-264/c/bad_5618_0
crossvul-cpp_data_good_1504_0	/* * Copyright (C) 2004 Andrew Beekhof <andrew@beekhof.net> * * This library is free software; you can redistribute it and/or * modify it 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 (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA / #include <crm_internal.h> #include <sys/param.h> #include <stdio.h> #include <sys/types.h> #include <sys/stat.h> #include <unistd.h> #include <time.h> #include <string.h> #include <dirent.h> #include <stdlib.h> #include <errno.h> #include <fcntl.h> #include <ctype.h> #include <math.h> #include <crm/crm.h> #include <crm/msg_xml.h> #include <crm/common/xml.h> #include <libxml/xmlreader.h> #if HAVE_BZLIB_H # include <bzlib.h> #endif #if HAVE_LIBXML2 # include <libxml/parser.h> # include <libxml/tree.h> # include <libxml/relaxng.h> #endif #if HAVE_LIBXSLT # include <libxslt/xslt.h> # include <libxslt/transform.h> #endif #define XML_BUFFER_SIZE 4096 #define XML_PARSER_DEBUG 0 void xml_log(int priority, const char fmt, ...) G_GNUC_PRINTF(2, 3); static inline int __get_prefix(const char prefix, xmlNode xml, char buffer, int offset); void xml_log(int priority, const char fmt, ...) { va_list ap; va_start(ap, fmt); qb_log_from_external_source_va(__FUNCTION__, __FILE__, fmt, priority, __LINE__, 0, ap); va_end(ap); } typedef struct { xmlRelaxNGPtr rng; xmlRelaxNGValidCtxtPtr valid; xmlRelaxNGParserCtxtPtr parser; } relaxng_ctx_cache_t; struct schema_s { int type; float version; char name; char location; char transform; int after_transform; void cache; }; typedef struct { int found; const char string; } filter_t; enum xml_private_flags { xpf_none = 0x0000, xpf_dirty = 0x0001, xpf_deleted = 0x0002, xpf_created = 0x0004, xpf_modified = 0x0008, xpf_tracking = 0x0010, xpf_processed = 0x0020, xpf_skip = 0x0040, xpf_moved = 0x0080, xpf_acl_enabled = 0x0100, xpf_acl_read = 0x0200, xpf_acl_write = 0x0400, xpf_acl_deny = 0x0800, xpf_acl_create = 0x1000, xpf_acl_denied = 0x2000, }; typedef struct xml_private_s { long check; uint32_t flags; char user; GListPtr acls; GListPtr deleted_paths; } xml_private_t; typedef struct xml_acl_s { enum xml_private_flags mode; char xpath; } xml_acl_t; / INDENT-OFF / static filter_t filter[] = { { 0, XML_ATTR_ORIGIN }, { 0, XML_CIB_ATTR_WRITTEN }, { 0, XML_ATTR_UPDATE_ORIG }, { 0, XML_ATTR_UPDATE_CLIENT }, { 0, XML_ATTR_UPDATE_USER }, }; / INDENT-ON / static struct schema_s known_schemas = NULL; static int xml_schema_max = 0; static xmlNode subtract_xml_comment(xmlNode parent, xmlNode * left, xmlNode * right, gboolean * changed); static xmlNode find_xml_comment(xmlNode root, xmlNode * search_comment); static int add_xml_comment(xmlNode * parent, xmlNode * target, xmlNode * update); static bool __xml_acl_check(xmlNode xml, const char name, enum xml_private_flags mode); const char __xml_acl_to_text(enum xml_private_flags flags); static int xml_latest_schema_index(void) { return xml_schema_max - 4; } static int xml_minimum_schema_index(void) { static int best = 0; if(best == 0) { int lpc = 0; float target = 0.0; best = xml_latest_schema_index(); target = floor(known_schemas[best].version); for(lpc = best; lpc > 0; lpc--) { if(known_schemas[lpc].version < target) { return best; } else { best = lpc; } } best = xml_latest_schema_index(); } return best; } const char xml_latest_schema(void) { return get_schema_name(xml_latest_schema_index()); } #define CHUNK_SIZE 1024 static inline bool TRACKING_CHANGES(xmlNode xml) { if(xml == NULL \|\| xml->doc == NULL \|\| xml->doc->_private == NULL) { return FALSE; } else if(is_set(((xml_private_t )xml->doc->_private)->flags, xpf_tracking)) { return TRUE; } return FALSE; } #define buffer_print(buffer, max, offset, fmt, args...) do { \ int rc = (max); \ if(buffer) { \ rc = snprintf((buffer) + (offset), (max) - (offset), fmt, ##args); \ } \ if(buffer && rc < 0) { \ crm_perror(LOG_ERR, "snprintf failed at offset %d", offset); \ (buffer)[(offset)] = 0; \ } else if(rc >= ((max) - (offset))) { \ char tmp = NULL; \ (max) = QB_MAX(CHUNK_SIZE, (max) 2); \ tmp = realloc_safe((buffer), (max) + 1); \ CRM_ASSERT(tmp); \ (buffer) = tmp; \ } else { \ offset += rc; \ break; \ } \ } while(1); static void insert_prefix(int options, char *buffer, int offset, int max, int depth) { if (options & xml_log_option_formatted) { size_t spaces = 2 depth; if ((buffer) == NULL \|\| spaces >= ((max) - (offset))) { (max) = QB_MAX(CHUNK_SIZE, (max) 2); (buffer) = realloc_safe((buffer), (max) + 1); } memset((buffer) + (offset), ' ', spaces); (offset) += spaces; } } static const char * get_schema_root(void) { static const char base = NULL; if (base == NULL) { base = getenv("PCMK_schema_directory"); } if (base == NULL \|\| strlen(base) == 0) { base = CRM_DTD_DIRECTORY; } return base; } static char get_schema_path(const char name, const char file) { const char base = get_schema_root(); if(file) { return crm_strdup_printf("%s/%s", base, file); } return crm_strdup_printf("%s/%s.rng", base, name); } static int schema_filter(const struct dirent a) { int rc = 0; float version = 0; if(strstr(a->d_name, "pacemaker-") != a->d_name) { /* crm_trace("%s - wrong prefix", a->d_name); / } else if(strstr(a->d_name, ".rng") == NULL) { / crm_trace("%s - wrong suffix", a->d_name); / } else if(sscanf(a->d_name, "pacemaker-%f.rng", &version) == 0) { / crm_trace("%s - wrong format", a->d_name); / } else if(strcmp(a->d_name, "pacemaker-1.1.rng") == 0) { / crm_trace("%s - hack", a->d_name); / } else { / crm_debug("%s - candidate", a->d_name); / rc = 1; } return rc; } static int schema_sort(const struct dirent * a, const struct dirent *b) { int rc = 0; float a_version = 0.0; float b_version = 0.0; sscanf(a[0]->d_name, "pacemaker-%f.rng", &a_version); sscanf(b[0]->d_name, "pacemaker-%f.rng", &b_version); if(a_version > b_version) { rc = 1; } else if(a_version < b_version) { rc = -1; } / crm_trace("%s (%f) vs. %s (%f) : %d", a[0]->d_name, a_version, b[0]->d_name, b_version, rc); / return rc; } static void __xml_schema_add( int type, float version, const char name, const char location, const char transform, int after_transform) { int last = xml_schema_max; xml_schema_max++; known_schemas = realloc_safe(known_schemas, xml_schema_maxsizeof(struct schema_s)); CRM_ASSERT(known_schemas != NULL); memset(known_schemas+last, 0, sizeof(struct schema_s)); known_schemas[last].type = type; known_schemas[last].after_transform = after_transform; if(version > 0.0) { known_schemas[last].version = version; known_schemas[last].name = crm_strdup_printf("pacemaker-%.1f", version); known_schemas[last].location = crm_strdup_printf("%s.rng", known_schemas[last].name); } else { char dummy[1024]; CRM_ASSERT(name); CRM_ASSERT(location); sscanf(name, "%[^-]-%f", dummy, &version); known_schemas[last].version = version; known_schemas[last].name = strdup(name); known_schemas[last].location = strdup(location); } if(transform) { known_schemas[last].transform = strdup(transform); } if(after_transform == 0) { after_transform = xml_schema_max; } known_schemas[last].after_transform = after_transform; if(known_schemas[last].after_transform < 0) { crm_debug("Added supported schema %d: %s (%s)", last, known_schemas[last].name, known_schemas[last].location); } else if(known_schemas[last].transform) { crm_debug("Added supported schema %d: %s (%s upgrades to %d with %s)", last, known_schemas[last].name, known_schemas[last].location, known_schemas[last].after_transform, known_schemas[last].transform); } else { crm_debug("Added supported schema %d: %s (%s upgrades to %d)", last, known_schemas[last].name, known_schemas[last].location, known_schemas[last].after_transform); } } static int __xml_build_schema_list(void) { int lpc, max; const char base = get_schema_root(); struct dirent *namelist = NULL; max = scandir(base, &namelist, schema_filter, schema_sort); __xml_schema_add(1, 0.0, "pacemaker-0.6", "crm.dtd", "upgrade06.xsl", 3); __xml_schema_add(1, 0.0, "transitional-0.6", "crm-transitional.dtd", "upgrade06.xsl", 3); __xml_schema_add(2, 0.0, "pacemaker-0.7", "pacemaker-1.0.rng", NULL, 0); if (max < 0) { crm_notice("scandir(%s) failed: %s (%d)", base, strerror(errno), errno); } else { for (lpc = 0; lpc < max; lpc++) { int next = 0; float version = 0.0; char transform = NULL; sscanf(namelist[lpc]->d_name, "pacemaker-%f.rng", &version); if((lpc + 1) < max) { float next_version = 0.0; sscanf(namelist[lpc+1]->d_name, "pacemaker-%f.rng", &next_version); if(floor(version) < floor(next_version)) { struct stat s; char xslt = NULL; transform = crm_strdup_printf("upgrade-%.1f.xsl", version); xslt = get_schema_path(NULL, transform); if(stat(xslt, &s) != 0) { crm_err("Transform %s not found", xslt); free(xslt); __xml_schema_add(2, version, NULL, NULL, NULL, -1); break; } else { free(xslt); } } } else { next = -1; } __xml_schema_add(2, version, NULL, NULL, transform, next); free(namelist[lpc]); free(transform); } } / 1.1 was the old name for -next / __xml_schema_add(2, 0.0, "pacemaker-1.1", "pacemaker-next.rng", NULL, 0); __xml_schema_add(2, 0.0, "pacemaker-next", "pacemaker-next.rng", NULL, -1); __xml_schema_add(0, 0.0, "none", "N/A", NULL, -1); free(namelist); return TRUE; } static void set_parent_flag(xmlNode xml, long flag) { for(; xml; xml = xml->parent) { xml_private_t p = xml->_private; if(p == NULL) { / During calls to xmlDocCopyNode(), _private will be unset for parent nodes / } else { p->flags \|= flag; / crm_trace("Setting flag %x due to %s[@id=%s]", flag, xml->name, ID(xml)); / } } } static void set_doc_flag(xmlNode xml, long flag) { if(xml && xml->doc && xml->doc->_private){ /* During calls to xmlDocCopyNode(), xml->doc may be unset / xml_private_t p = xml->doc->_private; p->flags \|= flag; /* crm_trace("Setting flag %x due to %s[@id=%s]", flag, xml->name, ID(xml)); / } } static void __xml_node_dirty(xmlNode xml) { set_doc_flag(xml, xpf_dirty); set_parent_flag(xml, xpf_dirty); } static void __xml_node_clean(xmlNode xml) { xmlNode cIter = NULL; xml_private_t p = xml->_private; if(p) { p->flags = 0; } for (cIter = __xml_first_child(xml); cIter != NULL; cIter = __xml_next(cIter)) { __xml_node_clean(cIter); } } static void crm_node_created(xmlNode xml) { xmlNode cIter = NULL; xml_private_t p = xml->_private; if(p && TRACKING_CHANGES(xml)) { if(is_not_set(p->flags, xpf_created)) { p->flags \|= xpf_created; __xml_node_dirty(xml); } for (cIter = __xml_first_child(xml); cIter != NULL; cIter = __xml_next(cIter)) { crm_node_created(cIter); } } } static void crm_attr_dirty(xmlAttr a) { xmlNode parent = a->parent; xml_private_t p = NULL; p = a->_private; p->flags \|= (xpf_dirty\|xpf_modified); p->flags = (p->flags & ~xpf_deleted); / crm_trace("Setting flag %x due to %s[@id=%s, @%s=%s]", / / xpf_dirty, parent?parent->name:NULL, ID(parent), a->name, a->children->content); / __xml_node_dirty(parent); } int get_tag_name(const char input, size_t offset, size_t max); int get_attr_name(const char input, size_t offset, size_t max); int get_attr_value(const char input, size_t offset, size_t max); gboolean can_prune_leaf(xmlNode * xml_node); void diff_filter_context(int context, int upper_bound, int lower_bound, xmlNode * xml_node, xmlNode * parent); int in_upper_context(int depth, int context, xmlNode * xml_node); int add_xml_object(xmlNode * parent, xmlNode * target, xmlNode * update, gboolean as_diff); static inline const char * crm_attr_value(xmlAttr * attr) { if (attr == NULL \|\| attr->children == NULL) { return NULL; } return (const char )attr->children->content; } static inline xmlAttr crm_first_attr(xmlNode * xml) { if (xml == NULL) { return NULL; } return xml->properties; } #define XML_PRIVATE_MAGIC (long) 0x81726354 static void __xml_acl_free(void data) { if(data) { xml_acl_t acl = data; free(acl->xpath); free(acl); } } static void __xml_private_clean(xml_private_t p) { if(p) { CRM_ASSERT(p->check == XML_PRIVATE_MAGIC); free(p->user); p->user = NULL; if(p->acls) { g_list_free_full(p->acls, __xml_acl_free); p->acls = NULL; } if(p->deleted_paths) { g_list_free_full(p->deleted_paths, free); p->deleted_paths = NULL; } } } static void __xml_private_free(xml_private_t p) { __xml_private_clean(p); free(p); } static void pcmkDeregisterNode(xmlNodePtr node) { __xml_private_free(node->_private); } static void pcmkRegisterNode(xmlNodePtr node) { xml_private_t p = NULL; switch(node->type) { case XML_ELEMENT_NODE: case XML_DOCUMENT_NODE: case XML_ATTRIBUTE_NODE: case XML_COMMENT_NODE: p = calloc(1, sizeof(xml_private_t)); p->check = XML_PRIVATE_MAGIC; / Flags will be reset if necessary when tracking is enabled / p->flags \|= (xpf_dirty\|xpf_created); node->_private = p; break; case XML_TEXT_NODE: case XML_DTD_NODE: break; default: / Ignore / crm_trace("Ignoring %p %d", node, node->type); CRM_LOG_ASSERT(node->type == XML_ELEMENT_NODE); break; } if(p && TRACKING_CHANGES(node)) { / XML_ELEMENT_NODE doesn't get picked up here, node->doc is * not hooked up at the point we are called / set_doc_flag(node, xpf_dirty); __xml_node_dirty(node); } } static xml_acl_t __xml_acl_create(xmlNode * xml, xmlNode target, enum xml_private_flags mode) { xml_acl_t acl = NULL; xml_private_t p = NULL; const char tag = crm_element_value(xml, XML_ACL_ATTR_TAG); const char ref = crm_element_value(xml, XML_ACL_ATTR_REF); const char xpath = crm_element_value(xml, XML_ACL_ATTR_XPATH); if(tag == NULL) { /* Compatability handling for pacemaker < 1.1.12 / tag = crm_element_value(xml, XML_ACL_ATTR_TAGv1); } if(ref == NULL) { / Compatability handling for pacemaker < 1.1.12 / ref = crm_element_value(xml, XML_ACL_ATTR_REFv1); } if(target == NULL \|\| target->doc == NULL \|\| target->doc->_private == NULL){ CRM_ASSERT(target); CRM_ASSERT(target->doc); CRM_ASSERT(target->doc->_private); return NULL; } else if (tag == NULL && ref == NULL && xpath == NULL) { crm_trace("No criteria %p", xml); return NULL; } p = target->doc->_private; acl = calloc(1, sizeof(xml_acl_t)); if (acl) { const char attr = crm_element_value(xml, XML_ACL_ATTR_ATTRIBUTE); acl->mode = mode; if(xpath) { acl->xpath = strdup(xpath); crm_trace("Using xpath: %s", acl->xpath); } else { int offset = 0; char buffer[XML_BUFFER_SIZE]; if(tag) { offset += snprintf(buffer + offset, XML_BUFFER_SIZE - offset, "//%s", tag); } else { offset += snprintf(buffer + offset, XML_BUFFER_SIZE - offset, "//"); } if(ref \|\| attr) { offset += snprintf(buffer + offset, XML_BUFFER_SIZE - offset, "["); } if(ref) { offset += snprintf(buffer + offset, XML_BUFFER_SIZE - offset, "@id='%s'", ref); } if(ref && attr) { offset += snprintf(buffer + offset, XML_BUFFER_SIZE - offset, " and "); } if(attr) { offset += snprintf(buffer + offset, XML_BUFFER_SIZE - offset, "@%s", attr); } if(ref \|\| attr) { offset += snprintf(buffer + offset, XML_BUFFER_SIZE - offset, "]"); } CRM_LOG_ASSERT(offset > 0); acl->xpath = strdup(buffer); crm_trace("Built xpath: %s", acl->xpath); } p->acls = g_list_append(p->acls, acl); } return acl; } static gboolean __xml_acl_parse_entry(xmlNode acl_top, xmlNode * acl_entry, xmlNode target) { xmlNode child = NULL; for (child = __xml_first_child(acl_entry); child; child = __xml_next(child)) { const char tag = crm_element_name(child); const char kind = crm_element_value(child, XML_ACL_ATTR_KIND); if (strcmp(XML_ACL_TAG_PERMISSION, tag) == 0){ tag = kind; } crm_trace("Processing %s %p", tag, child); if(tag == NULL) { CRM_ASSERT(tag != NULL); } else if (strcmp(XML_ACL_TAG_ROLE_REF, tag) == 0 \|\| strcmp(XML_ACL_TAG_ROLE_REFv1, tag) == 0) { const char ref_role = crm_element_value(child, XML_ATTR_ID); if (ref_role) { xmlNode role = NULL; for (role = __xml_first_child(acl_top); role; role = __xml_next(role)) { if (strcmp(XML_ACL_TAG_ROLE, (const char )role->name) == 0) { const char role_id = crm_element_value(role, XML_ATTR_ID); if (role_id && strcmp(ref_role, role_id) == 0) { crm_debug("Unpacking referenced role: %s", role_id); __xml_acl_parse_entry(acl_top, role, target); break; } } } } } else if (strcmp(XML_ACL_TAG_READ, tag) == 0) { __xml_acl_create(child, target, xpf_acl_read); } else if (strcmp(XML_ACL_TAG_WRITE, tag) == 0) { __xml_acl_create(child, target, xpf_acl_write); } else if (strcmp(XML_ACL_TAG_DENY, tag) == 0) { __xml_acl_create(child, target, xpf_acl_deny); } else { crm_warn("Unknown ACL entry: %s/%s", tag, kind); } } return TRUE; } /* <acls> <acl_target id="l33t-haxor"><role id="auto-l33t-haxor"/></acl_target> <acl_role id="auto-l33t-haxor"> <acl_permission id="crook-nothing" kind="deny" xpath="/cib"/> </acl_role> <acl_target id="niceguy"> <role id="observer"/> </acl_target> <acl_role id="observer"> <acl_permission id="observer-read-1" kind="read" xpath="/cib"/> <acl_permission id="observer-write-1" kind="write" xpath="//nvpair[@name='stonith-enabled']"/> <acl_permission id="observer-write-2" kind="write" xpath="//nvpair[@name='target-role']"/> </acl_role> <acl_target id="badidea"><role id="auto-badidea"/></acl_target> <acl_role id="auto-badidea"> <acl_permission id="badidea-resources" kind="read" xpath="//meta_attributes"/> <acl_permission id="badidea-resources-2" kind="deny" reference="dummy-meta_attributes"/> </acl_role> </acls> / const char __xml_acl_to_text(enum xml_private_flags flags) { if(is_set(flags, xpf_acl_deny)) { return "deny"; } if(is_set(flags, xpf_acl_write)) { return "read/write"; } if(is_set(flags, xpf_acl_read)) { return "read"; } return "none"; } static void __xml_acl_apply(xmlNode xml) { GListPtr aIter = NULL; xml_private_t p = NULL; xmlXPathObjectPtr xpathObj = NULL; if(xml_acl_enabled(xml) == FALSE) { p = xml->doc->_private; crm_trace("Not applying ACLs for %s", p->user); return; } p = xml->doc->_private; for(aIter = p->acls; aIter != NULL; aIter = aIter->next) { int max = 0, lpc = 0; xml_acl_t acl = aIter->data; xpathObj = xpath_search(xml, acl->xpath); max = numXpathResults(xpathObj); for(lpc = 0; lpc < max; lpc++) { xmlNode match = getXpathResult(xpathObj, lpc); char path = xml_get_path(match); p = match->_private; crm_trace("Applying %x to %s for %s", acl->mode, path, acl->xpath); #ifdef SUSE_ACL_COMPAT if(is_not_set(p->flags, acl->mode)) { if(is_set(p->flags, xpf_acl_read) \|\| is_set(p->flags, xpf_acl_write) \|\| is_set(p->flags, xpf_acl_deny)) { crm_config_warn("Configuration element %s is matched by multiple ACL rules, only the first applies ('%s' wins over '%s')", path, __xml_acl_to_text(p->flags), __xml_acl_to_text(acl->mode)); free(path); continue; } } #endif p->flags \|= acl->mode; free(path); } crm_trace("Now enforcing ACL: %s (%d matches)", acl->xpath, max); freeXpathObject(xpathObj); } p = xml->_private; if(is_not_set(p->flags, xpf_acl_read) && is_not_set(p->flags, xpf_acl_write)) { p->flags \|= xpf_acl_deny; p = xml->doc->_private; crm_info("Enforcing default ACL for %s to %s", p->user, crm_element_name(xml)); } } static void __xml_acl_unpack(xmlNode source, xmlNode target, const char user) { #if ENABLE_ACL xml_private_t p = NULL; if(target == NULL \|\| target->doc == NULL \|\| target->doc->_private == NULL) { return; } p = target->doc->_private; if(pcmk_acl_required(user) == FALSE) { crm_trace("no acls needed for '%s'", user); } else if(p->acls == NULL) { xmlNode acls = get_xpath_object("//"XML_CIB_TAG_ACLS, source, LOG_TRACE); free(p->user); p->user = strdup(user); if(acls) { xmlNode child = NULL; for (child = __xml_first_child(acls); child; child = __xml_next(child)) { const char tag = crm_element_name(child); if (strcmp(tag, XML_ACL_TAG_USER) == 0 \|\| strcmp(tag, XML_ACL_TAG_USERv1) == 0) { const char id = crm_element_value(child, XML_ATTR_ID); if(id && strcmp(id, user) == 0) { crm_debug("Unpacking ACLs for %s", id); __xml_acl_parse_entry(acls, child, target); } } } } } #endif } static inline bool __xml_acl_mode_test(enum xml_private_flags allowed, enum xml_private_flags requested) { if(is_set(allowed, xpf_acl_deny)) { return FALSE; } else if(is_set(allowed, requested)) { return TRUE; } else if(is_set(requested, xpf_acl_read) && is_set(allowed, xpf_acl_write)) { return TRUE; } else if(is_set(requested, xpf_acl_create) && is_set(allowed, xpf_acl_write)) { return TRUE; } else if(is_set(requested, xpf_acl_create) && is_set(allowed, xpf_created)) { return TRUE; } return FALSE; } / rc = TRUE if orig_cib has been filtered * That means 'result' rather than 'xml' should be exploited afterwards / static bool __xml_purge_attributes(xmlNode xml) { xmlNode child = NULL; xmlAttr xIter = NULL; bool readable_children = FALSE; xml_private_t p = xml->_private; if(__xml_acl_mode_test(p->flags, xpf_acl_read)) { crm_trace("%s is readable", crm_element_name(xml), ID(xml)); return TRUE; } xIter = crm_first_attr(xml); while(xIter != NULL) { xmlAttr tmp = xIter; const char prop_name = (const char )xIter->name; xIter = xIter->next; if (strcmp(prop_name, XML_ATTR_ID) == 0) { continue; } xmlUnsetProp(xml, tmp->name); } child = __xml_first_child(xml); while ( child != NULL ) { xmlNode tmp = child; child = __xml_next(child); readable_children \|= __xml_purge_attributes(tmp); } if(readable_children == FALSE) { free_xml(xml); /* Nothing readable under here, purge completely / } return readable_children; } bool xml_acl_filtered_copy(const char user, xmlNode* acl_source, xmlNode xml, xmlNode * result) { GListPtr aIter = NULL; xmlNode target = NULL; xml_private_t p = NULL; xml_private_t doc = NULL; result = NULL; if(xml == NULL \|\| pcmk_acl_required(user) == FALSE) { crm_trace("no acls needed for '%s'", user); return FALSE; } crm_trace("filtering copy of %p for '%s'", xml, user); target = copy_xml(xml); if(target == NULL) { return TRUE; } __xml_acl_unpack(acl_source, target, user); set_doc_flag(target, xpf_acl_enabled); __xml_acl_apply(target); doc = target->doc->_private; for(aIter = doc->acls; aIter != NULL && target; aIter = aIter->next) { int max = 0; xml_acl_t acl = aIter->data; if(acl->mode != xpf_acl_deny) { / Nothing to do / } else if(acl->xpath) { int lpc = 0; xmlXPathObjectPtr xpathObj = xpath_search(target, acl->xpath); max = numXpathResults(xpathObj); for(lpc = 0; lpc < max; lpc++) { xmlNode match = getXpathResult(xpathObj, lpc); crm_trace("Purging attributes from %s", acl->xpath); if(__xml_purge_attributes(match) == FALSE && match == target) { crm_trace("No access to the entire document for %s", user); freeXpathObject(xpathObj); return TRUE; } } crm_trace("Enforced ACL %s (%d matches)", acl->xpath, max); freeXpathObject(xpathObj); } } p = target->_private; if(is_set(p->flags, xpf_acl_deny) && __xml_purge_attributes(target) == FALSE) { crm_trace("No access to the entire document for %s", user); return TRUE; } if(doc->acls) { g_list_free_full(doc->acls, __xml_acl_free); doc->acls = NULL; } else { crm_trace("Ordinary user '%s' cannot access the CIB without any defined ACLs", doc->user); free_xml(target); target = NULL; } if(target) { result = target; } return TRUE; } static void __xml_acl_post_process(xmlNode xml) { xmlNode cIter = __xml_first_child(xml); xml_private_t p = xml->_private; if(is_set(p->flags, xpf_created)) { xmlAttr xIter = NULL; char path = xml_get_path(xml); /* Always allow new scaffolding, ie. node with no attributes or only an 'id' * Except in the ACLs section / for (xIter = crm_first_attr(xml); xIter != NULL; xIter = xIter->next) { const char prop_name = (const char )xIter->name; if (strcmp(prop_name, XML_ATTR_ID) == 0 && strstr(path, "/"XML_CIB_TAG_ACLS"/") == NULL) { / Delay the acl check / continue; } else if(__xml_acl_check(xml, NULL, xpf_acl_write)) { crm_trace("Creation of %s=%s is allowed", crm_element_name(xml), ID(xml)); break; } else { crm_trace("Cannot add new node %s at %s", crm_element_name(xml), path); if(xml != xmlDocGetRootElement(xml->doc)) { xmlUnlinkNode(xml); xmlFreeNode(xml); } free(path); return; } } free(path); } while (cIter != NULL) { xmlNode child = cIter; cIter = __xml_next(cIter); /* In case it is free'd / __xml_acl_post_process(child); } } bool xml_acl_denied(xmlNode xml) { if(xml && xml->doc && xml->doc->_private){ xml_private_t p = xml->doc->_private; return is_set(p->flags, xpf_acl_denied); } return FALSE; } void xml_acl_disable(xmlNode xml) { if(xml_acl_enabled(xml)) { xml_private_t p = xml->doc->_private; / Catch anything that was created but shouldn't have been / __xml_acl_apply(xml); __xml_acl_post_process(xml); clear_bit(p->flags, xpf_acl_enabled); } } bool xml_acl_enabled(xmlNode xml) { if(xml && xml->doc && xml->doc->_private){ xml_private_t p = xml->doc->_private; return is_set(p->flags, xpf_acl_enabled); } return FALSE; } void xml_track_changes(xmlNode xml, const char user, xmlNode acl_source, bool enforce_acls) { xml_accept_changes(xml); crm_trace("Tracking changes%s to %p", enforce_acls?" with ACLs":"", xml); set_doc_flag(xml, xpf_tracking); if(enforce_acls) { if(acl_source == NULL) { acl_source = xml; } set_doc_flag(xml, xpf_acl_enabled); __xml_acl_unpack(acl_source, xml, user); __xml_acl_apply(xml); } } bool xml_tracking_changes(xmlNode * xml) { if(xml == NULL) { return FALSE; } else if(is_set(((xml_private_t )xml->doc->_private)->flags, xpf_tracking)) { return TRUE; } return FALSE; } bool xml_document_dirty(xmlNode xml) { if(xml != NULL && xml->doc && xml->doc->_private) { xml_private_t doc = xml->doc->_private; return is_set(doc->flags, xpf_dirty); } return FALSE; } / <diff format="2.0"> <version> <source admin_epoch="1" epoch="2" num_updates="3"/> <target admin_epoch="1" epoch="3" num_updates="0"/> </version> <change operation="add" xpath="/cib/configuration/nodes"> <node id="node2" uname="node2" description="foo"/> </change> <change operation="add" xpath="/cib/configuration/nodes/node[node2]"> <instance_attributes id="nodes-node"><!-- NOTE: can be a full tree --> <nvpair id="nodes-node2-ram" name="ram" value="1024M"/> </instance_attributes> </change> <change operation="update" xpath="/cib/configuration/nodes[@id='node2']"> <change-list> <change-attr operation="set" name="type" value="member"/> <change-attr operation="unset" name="description"/> </change-list> <change-result> <node id="node2" uname="node2" type="member"/><!-- NOTE: not recursive --> </change-result> </change> <change operation="delete" xpath="/cib/configuration/nodes/node[@id='node3'] /"> <change operation="update" xpath="/cib/configuration/resources/group[@id='g1']"> <change-list> <change-attr operation="set" name="description" value="some grabage here"/> </change-list> <change-result> <group id="g1" description="some grabage here"/><!-- NOTE: not recursive --> </change-result> </change> <change operation="update" xpath="/cib/status/node_state[@id='node2]/lrm[@id='node2']/lrm_resources/lrm_resource[@id='Fence']"> <change-list> <change-attr operation="set" name="oper" value="member"/> <change-attr operation="set" name="operation_key" value="Fence_start_0"/> <change-attr operation="set" name="operation" value="start"/> <change-attr operation="set" name="transition-key" value="2:-1:0:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"/> <change-attr operation="set" name="transition-magic" value="0:0;2:-1:0:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"/> <change-attr operation="set" name="call-id" value="2"/> <change-attr operation="set" name="rc-code" value="0"/> </change-list> <change-result> <lrm_rsc_op id="Fence_last_0" operation_key="Fence_start_0" operation="start" crm-debug-origin="crm_simulate" transition-key="2:-1:0:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" transition-magic="0:0;2:-1:0:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" call-id="2" rc-code="0" op-status="0" interval="0" exec-time="0" queue-time="0" op-digest="f2317cad3d54cec5d7d7aa7d0bf35cf8"/> </change-result> </change> </diff> / static int __xml_offset(xmlNode xml) { int position = 0; xmlNode cIter = NULL; for(cIter = xml; cIter->prev; cIter = cIter->prev) { xml_private_t p = ((xmlNode)cIter->prev)->_private; if(is_not_set(p->flags, xpf_skip)) { position++; } } return position; } static int __xml_offset_no_deletions(xmlNode xml) { int position = 0; xmlNode cIter = NULL; for(cIter = xml; cIter->prev; cIter = cIter->prev) { xml_private_t p = ((xmlNode)cIter->prev)->_private; if(is_not_set(p->flags, xpf_deleted)) { position++; } } return position; } static void __xml_build_changes(xmlNode xml, xmlNode patchset) { xmlNode cIter = NULL; xmlAttr pIter = NULL; xmlNode change = NULL; xml_private_t p = xml->_private; if(patchset && is_set(p->flags, xpf_created)) { int offset = 0; char buffer[XML_BUFFER_SIZE]; if(__get_prefix(NULL, xml->parent, buffer, offset) > 0) { int position = __xml_offset_no_deletions(xml); change = create_xml_node(patchset, XML_DIFF_CHANGE); crm_xml_add(change, XML_DIFF_OP, "create"); crm_xml_add(change, XML_DIFF_PATH, buffer); crm_xml_add_int(change, XML_DIFF_POSITION, position); add_node_copy(change, xml); } return; } for (pIter = crm_first_attr(xml); pIter != NULL; pIter = pIter->next) { xmlNode attr = NULL; p = pIter->_private; if(is_not_set(p->flags, xpf_deleted) && is_not_set(p->flags, xpf_dirty)) { continue; } if(change == NULL) { int offset = 0; char buffer[XML_BUFFER_SIZE]; if(__get_prefix(NULL, xml, buffer, offset) > 0) { change = create_xml_node(patchset, XML_DIFF_CHANGE); crm_xml_add(change, XML_DIFF_OP, "modify"); crm_xml_add(change, XML_DIFF_PATH, buffer); change = create_xml_node(change, XML_DIFF_LIST); } } attr = create_xml_node(change, XML_DIFF_ATTR); crm_xml_add(attr, XML_NVPAIR_ATTR_NAME, (const char )pIter->name); if(p->flags & xpf_deleted) { crm_xml_add(attr, XML_DIFF_OP, "unset"); } else { const char value = crm_element_value(xml, (const char )pIter->name); crm_xml_add(attr, XML_DIFF_OP, "set"); crm_xml_add(attr, XML_NVPAIR_ATTR_VALUE, value); } } if(change) { xmlNode result = NULL; change = create_xml_node(change->parent, XML_DIFF_RESULT); result = create_xml_node(change, (const char )xml->name); for (pIter = crm_first_attr(xml); pIter != NULL; pIter = pIter->next) { const char value = crm_element_value(xml, (const char )pIter->name); p = pIter->_private; if (is_not_set(p->flags, xpf_deleted)) { crm_xml_add(result, (const char )pIter->name, value); } } } for (cIter = __xml_first_child(xml); cIter != NULL; cIter = __xml_next(cIter)) { __xml_build_changes(cIter, patchset); } p = xml->_private; if(patchset && is_set(p->flags, xpf_moved)) { int offset = 0; char buffer[XML_BUFFER_SIZE]; crm_trace("%s.%s moved to position %d", xml->name, ID(xml), __xml_offset(xml)); if(__get_prefix(NULL, xml, buffer, offset) > 0) { change = create_xml_node(patchset, XML_DIFF_CHANGE); crm_xml_add(change, XML_DIFF_OP, "move"); crm_xml_add(change, XML_DIFF_PATH, buffer); crm_xml_add_int(change, XML_DIFF_POSITION, __xml_offset_no_deletions(xml)); } } } static void __xml_accept_changes(xmlNode * xml) { xmlNode cIter = NULL; xmlAttr pIter = NULL; xml_private_t p = xml->_private; p->flags = xpf_none; pIter = crm_first_attr(xml); while (pIter != NULL) { const xmlChar name = pIter->name; p = pIter->_private; pIter = pIter->next; if(p->flags & xpf_deleted) { xml_remove_prop(xml, (const char )name); } else { p->flags = xpf_none; } } for (cIter = __xml_first_child(xml); cIter != NULL; cIter = __xml_next(cIter)) { __xml_accept_changes(cIter); } } static bool is_config_change(xmlNode xml) { GListPtr gIter = NULL; xml_private_t p = NULL; xmlNode config = first_named_child(xml, XML_CIB_TAG_CONFIGURATION); if(config) { p = config->_private; } if(p && is_set(p->flags, xpf_dirty)) { return TRUE; } if(xml->doc && xml->doc->_private) { p = xml->doc->_private; for(gIter = p->deleted_paths; gIter; gIter = gIter->next) { char path = gIter->data; if(strstr(path, "/"XML_TAG_CIB"/"XML_CIB_TAG_CONFIGURATION) != NULL) { return TRUE; } } } return FALSE; } static void xml_repair_v1_diff(xmlNode last, xmlNode * next, xmlNode * local_diff, gboolean changed) { int lpc = 0; xmlNode cib = NULL; xmlNode diff_child = NULL; const char tag = NULL; const char vfields[] = { XML_ATTR_GENERATION_ADMIN, XML_ATTR_GENERATION, XML_ATTR_NUMUPDATES, }; if (local_diff == NULL) { crm_trace("Nothing to do"); return; } tag = "diff-removed"; diff_child = find_xml_node(local_diff, tag, FALSE); if (diff_child == NULL) { diff_child = create_xml_node(local_diff, tag); } tag = XML_TAG_CIB; cib = find_xml_node(diff_child, tag, FALSE); if (cib == NULL) { cib = create_xml_node(diff_child, tag); } for(lpc = 0; last && lpc < DIMOF(vfields); lpc++){ const char value = crm_element_value(last, vfields[lpc]); crm_xml_add(diff_child, vfields[lpc], value); if(changed \|\| lpc == 2) { crm_xml_add(cib, vfields[lpc], value); } } tag = "diff-added"; diff_child = find_xml_node(local_diff, tag, FALSE); if (diff_child == NULL) { diff_child = create_xml_node(local_diff, tag); } tag = XML_TAG_CIB; cib = find_xml_node(diff_child, tag, FALSE); if (cib == NULL) { cib = create_xml_node(diff_child, tag); } for(lpc = 0; next && lpc < DIMOF(vfields); lpc++){ const char value = crm_element_value(next, vfields[lpc]); crm_xml_add(diff_child, vfields[lpc], value); } if (next) { xmlAttrPtr xIter = NULL; for (xIter = next->properties; xIter; xIter = xIter->next) { const char p_name = (const char )xIter->name; const char p_value = crm_element_value(next, p_name); xmlSetProp(cib, (const xmlChar )p_name, (const xmlChar )p_value); } } crm_log_xml_explicit(local_diff, "Repaired-diff"); } static xmlNode xml_create_patchset_v1(xmlNode source, xmlNode target, bool config, bool with_digest) { xmlNode patchset = diff_xml_object(source, target, !with_digest); if(patchset) { CRM_LOG_ASSERT(xml_document_dirty(target)); xml_repair_v1_diff(source, target, patchset, config); crm_xml_add(patchset, "format", "1"); } return patchset; } static xmlNode xml_create_patchset_v2(xmlNode source, xmlNode target) { int lpc = 0; GListPtr gIter = NULL; xml_private_t doc = NULL; xmlNode v = NULL; xmlNode version = NULL; xmlNode patchset = NULL; const char vfields[] = { XML_ATTR_GENERATION_ADMIN, XML_ATTR_GENERATION, XML_ATTR_NUMUPDATES, }; CRM_ASSERT(target); if(xml_document_dirty(target) == FALSE) { return NULL; } CRM_ASSERT(target->doc); doc = target->doc->_private; patchset = create_xml_node(NULL, XML_TAG_DIFF); crm_xml_add_int(patchset, "format", 2); version = create_xml_node(patchset, XML_DIFF_VERSION); v = create_xml_node(version, XML_DIFF_VSOURCE); for(lpc = 0; lpc < DIMOF(vfields); lpc++){ const char value = crm_element_value(source, vfields[lpc]); if(value == NULL) { value = "1"; } crm_xml_add(v, vfields[lpc], value); } v = create_xml_node(version, XML_DIFF_VTARGET); for(lpc = 0; lpc < DIMOF(vfields); lpc++){ const char value = crm_element_value(target, vfields[lpc]); if(value == NULL) { value = "1"; } crm_xml_add(v, vfields[lpc], value); } for(gIter = doc->deleted_paths; gIter; gIter = gIter->next) { xmlNode change = create_xml_node(patchset, XML_DIFF_CHANGE); crm_xml_add(change, XML_DIFF_OP, "delete"); crm_xml_add(change, XML_DIFF_PATH, gIter->data); } __xml_build_changes(target, patchset); return patchset; } static gboolean patch_legacy_mode(void) { static gboolean init = TRUE; static gboolean legacy = FALSE; if(init) { init = FALSE; legacy = daemon_option_enabled("cib", "legacy"); if(legacy) { crm_notice("Enabled legacy mode"); } } return legacy; } xmlNode * xml_create_patchset(int format, xmlNode source, xmlNode target, bool config_changed, bool manage_version, bool with_digest) { int counter = 0; bool config = FALSE; xmlNode patch = NULL; const char version = crm_element_value(source, XML_ATTR_CRM_VERSION); xml_acl_disable(target); if(xml_document_dirty(target) == FALSE) { crm_trace("No change %d", format); return NULL; / No change / } config = is_config_change(target); if(config_changed) { config_changed = config; } if(manage_version && config) { crm_trace("Config changed %d", format); crm_xml_add(target, XML_ATTR_NUMUPDATES, "0"); crm_element_value_int(target, XML_ATTR_GENERATION, &counter); crm_xml_add_int(target, XML_ATTR_GENERATION, counter+1); } else if(manage_version) { crm_trace("Status changed %d", format); crm_element_value_int(target, XML_ATTR_NUMUPDATES, &counter); crm_xml_add_int(target, XML_ATTR_NUMUPDATES, counter+1); } if(format == 0) { if(patch_legacy_mode()) { format = 1; } else if(compare_version("3.0.8", version) < 0) { format = 2; } else { format = 1; } crm_trace("Using patch format %d for version: %s", format, version); } switch(format) { case 1: with_digest = TRUE; patch = xml_create_patchset_v1(source, target, config, with_digest); break; case 2: patch = xml_create_patchset_v2(source, target); break; default: crm_err("Unknown patch format: %d", format); return NULL; } if(patch && with_digest) { char digest = calculate_xml_versioned_digest(target, FALSE, TRUE, version); crm_xml_add(patch, XML_ATTR_DIGEST, digest); free(digest); } return patch; } static void __xml_log_element(int log_level, const char file, const char function, int line, const char prefix, xmlNode * data, int depth, int options); void xml_log_patchset(uint8_t log_level, const char function, xmlNode patchset) { int format = 1; xmlNode child = NULL; xmlNode added = NULL; xmlNode removed = NULL; gboolean is_first = TRUE; int add[] = { 0, 0, 0 }; int del[] = { 0, 0, 0 }; const char fmt = NULL; const char digest = NULL; int options = xml_log_option_formatted; static struct qb_log_callsite patchset_cs = NULL; if (patchset_cs == NULL) { patchset_cs = qb_log_callsite_get(function, __FILE__, "xml-patchset", log_level, __LINE__, 0); } if (patchset == NULL) { crm_trace("Empty patch"); return; } else if (log_level == 0) { /* Log to stdout / } else if (crm_is_callsite_active(patchset_cs, log_level, 0) == FALSE) { return; } xml_patch_versions(patchset, add, del); fmt = crm_element_value(patchset, "format"); digest = crm_element_value(patchset, XML_ATTR_DIGEST); if (add[2] != del[2] \|\| add[1] != del[1] \|\| add[0] != del[0]) { do_crm_log_alias(log_level, __FILE__, function, __LINE__, "Diff: --- %d.%d.%d %s", del[0], del[1], del[2], fmt); do_crm_log_alias(log_level, __FILE__, function, __LINE__, "Diff: +++ %d.%d.%d %s", add[0], add[1], add[2], digest); } else if (patchset != NULL && (add[0] \|\| add[1] \|\| add[2])) { do_crm_log_alias(log_level, __FILE__, function, __LINE__, "%s: Local-only Change: %d.%d.%d", function ? function : "", add[0], add[1], add[2]); } crm_element_value_int(patchset, "format", &format); if(format == 2) { xmlNode change = NULL; for (change = __xml_first_child(patchset); change != NULL; change = __xml_next(change)) { const char op = crm_element_value(change, XML_DIFF_OP); const char xpath = crm_element_value(change, XML_DIFF_PATH); if(op == NULL) { } else if(strcmp(op, "create") == 0) { int lpc = 0, max = 0; char prefix = crm_strdup_printf("++ %s: ", xpath); max = strlen(prefix); __xml_log_element(log_level, __FILE__, function, __LINE__, prefix, change->children, 0, xml_log_option_formatted\|xml_log_option_open); for(lpc = 2; lpc < max; lpc++) { prefix[lpc] = ' '; } __xml_log_element(log_level, __FILE__, function, __LINE__, prefix, change->children, 0, xml_log_option_formatted\|xml_log_option_close\|xml_log_option_children); free(prefix); } else if(strcmp(op, "move") == 0) { do_crm_log_alias(log_level, __FILE__, function, __LINE__, "+~ %s moved to offset %s", xpath, crm_element_value(change, XML_DIFF_POSITION)); } else if(strcmp(op, "modify") == 0) { xmlNode clist = first_named_child(change, XML_DIFF_LIST); char buffer_set[XML_BUFFER_SIZE]; char buffer_unset[XML_BUFFER_SIZE]; int o_set = 0; int o_unset = 0; buffer_set[0] = 0; buffer_unset[0] = 0; for (child = __xml_first_child(clist); child != NULL; child = __xml_next(child)) { const char name = crm_element_value(child, "name"); op = crm_element_value(child, XML_DIFF_OP); if(op == NULL) { } else if(strcmp(op, "set") == 0) { const char value = crm_element_value(child, "value"); if(o_set > 0) { o_set += snprintf(buffer_set + o_set, XML_BUFFER_SIZE - o_set, ", "); } o_set += snprintf(buffer_set + o_set, XML_BUFFER_SIZE - o_set, "@%s=%s", name, value); } else if(strcmp(op, "unset") == 0) { if(o_unset > 0) { o_unset += snprintf(buffer_unset + o_unset, XML_BUFFER_SIZE - o_unset, ", "); } o_unset += snprintf(buffer_unset + o_unset, XML_BUFFER_SIZE - o_unset, "@%s", name); } } if(o_set) { do_crm_log_alias(log_level, __FILE__, function, __LINE__, "+ %s: %s", xpath, buffer_set); } if(o_unset) { do_crm_log_alias(log_level, __FILE__, function, __LINE__, "-- %s: %s", xpath, buffer_unset); } } else if(strcmp(op, "delete") == 0) { do_crm_log_alias(log_level, __FILE__, function, __LINE__, "-- %s", xpath); } } return; } if (log_level < LOG_DEBUG \|\| function == NULL) { options \|= xml_log_option_diff_short; } removed = find_xml_node(patchset, "diff-removed", FALSE); for (child = __xml_first_child(removed); child != NULL; child = __xml_next(child)) { log_data_element(log_level, __FILE__, function, __LINE__, "- ", child, 0, options \| xml_log_option_diff_minus); if (is_first) { is_first = FALSE; } else { do_crm_log_alias(log_level, __FILE__, function, __LINE__, " --- "); } } is_first = TRUE; added = find_xml_node(patchset, "diff-added", FALSE); for (child = __xml_first_child(added); child != NULL; child = __xml_next(child)) { log_data_element(log_level, __FILE__, function, __LINE__, "+ ", child, 0, options \| xml_log_option_diff_plus); if (is_first) { is_first = FALSE; } else { do_crm_log_alias(log_level, __FILE__, function, __LINE__, " +++ "); } } } void xml_log_changes(uint8_t log_level, const char function, xmlNode xml) { GListPtr gIter = NULL; xml_private_t doc = NULL; CRM_ASSERT(xml); CRM_ASSERT(xml->doc); doc = xml->doc->_private; if(is_not_set(doc->flags, xpf_dirty)) { return; } for(gIter = doc->deleted_paths; gIter; gIter = gIter->next) { do_crm_log_alias(log_level, __FILE__, function, __LINE__, "-- %s", (char)gIter->data); } log_data_element(log_level, __FILE__, function, __LINE__, "+ ", xml, 0, xml_log_option_formatted\|xml_log_option_dirty_add); } void xml_accept_changes(xmlNode * xml) { xmlNode top = NULL; xml_private_t doc = NULL; if(xml == NULL) { return; } crm_trace("Accepting changes to %p", xml); doc = xml->doc->_private; top = xmlDocGetRootElement(xml->doc); __xml_private_clean(xml->doc->_private); if(is_not_set(doc->flags, xpf_dirty)) { doc->flags = xpf_none; return; } doc->flags = xpf_none; __xml_accept_changes(top); } /* Simplified version for applying v1-style XML patches / static void __subtract_xml_object(xmlNode target, xmlNode * patch) { xmlNode patch_child = NULL; xmlNode cIter = NULL; xmlAttrPtr xIter = NULL; char id = NULL; const char name = NULL; const char value = NULL; if (target == NULL \|\| patch == NULL) { return; } if (target->type == XML_COMMENT_NODE) { gboolean dummy; subtract_xml_comment(target->parent, target, patch, &dummy); } name = crm_element_name(target); CRM_CHECK(name != NULL, return); CRM_CHECK(safe_str_eq(crm_element_name(target), crm_element_name(patch)), return); CRM_CHECK(safe_str_eq(ID(target), ID(patch)), return); / check for XML_DIFF_MARKER in a child / id = crm_element_value_copy(target, XML_ATTR_ID); value = crm_element_value(patch, XML_DIFF_MARKER); if (value != NULL && strcmp(value, "removed:top") == 0) { crm_trace("We are the root of the deletion: %s.id=%s", name, id); free_xml(target); free(id); return; } for (xIter = crm_first_attr(patch); xIter != NULL; xIter = xIter->next) { const char p_name = (const char )xIter->name; / Removing and then restoring the id field would change the ordering of properties / if (safe_str_neq(p_name, XML_ATTR_ID)) { xml_remove_prop(target, p_name); } } / changes to child objects / cIter = __xml_first_child(target); while (cIter) { xmlNode target_child = cIter; cIter = __xml_next(cIter); if (target_child->type == XML_COMMENT_NODE) { patch_child = find_xml_comment(patch, target_child); } else { patch_child = find_entity(patch, crm_element_name(target_child), ID(target_child)); } __subtract_xml_object(target_child, patch_child); } free(id); } static void __add_xml_object(xmlNode * parent, xmlNode * target, xmlNode * patch) { xmlNode patch_child = NULL; xmlNode target_child = NULL; xmlAttrPtr xIter = NULL; const char id = NULL; const char name = NULL; const char value = NULL; if (patch == NULL) { return; } else if (parent == NULL && target == NULL) { return; } / check for XML_DIFF_MARKER in a child / value = crm_element_value(patch, XML_DIFF_MARKER); if (target == NULL && value != NULL && strcmp(value, "added:top") == 0) { id = ID(patch); name = crm_element_name(patch); crm_trace("We are the root of the addition: %s.id=%s", name, id); add_node_copy(parent, patch); return; } else if(target == NULL) { id = ID(patch); name = crm_element_name(patch); crm_err("Could not locate: %s.id=%s", name, id); return; } if (target->type == XML_COMMENT_NODE) { add_xml_comment(parent, target, patch); } name = crm_element_name(target); CRM_CHECK(name != NULL, return); CRM_CHECK(safe_str_eq(crm_element_name(target), crm_element_name(patch)), return); CRM_CHECK(safe_str_eq(ID(target), ID(patch)), return); for (xIter = crm_first_attr(patch); xIter != NULL; xIter = xIter->next) { const char p_name = (const char )xIter->name; const char p_value = crm_element_value(patch, p_name); xml_remove_prop(target, p_name); /* Preserve the patch order / crm_xml_add(target, p_name, p_value); } / changes to child objects / for (patch_child = __xml_first_child(patch); patch_child != NULL; patch_child = __xml_next(patch_child)) { if (patch_child->type == XML_COMMENT_NODE) { target_child = find_xml_comment(target, patch_child); } else { target_child = find_entity(target, crm_element_name(patch_child), ID(patch_child)); } __add_xml_object(target, target_child, patch_child); } } bool xml_patch_versions(xmlNode patchset, int add[3], int del[3]) { int lpc = 0; int format = 1; xmlNode tmp = NULL; const char vfields[] = { XML_ATTR_GENERATION_ADMIN, XML_ATTR_GENERATION, XML_ATTR_NUMUPDATES, }; crm_element_value_int(patchset, "format", &format); switch(format) { case 1: tmp = find_xml_node(patchset, "diff-removed", FALSE); tmp = find_xml_node(tmp, "cib", FALSE); if(tmp == NULL) { /* Revert to the diff-removed line / tmp = find_xml_node(patchset, "diff-removed", FALSE); } break; case 2: tmp = find_xml_node(patchset, "version", FALSE); tmp = find_xml_node(tmp, "source", FALSE); break; default: crm_warn("Unknown patch format: %d", format); return -EINVAL; } if (tmp) { for(lpc = 0; lpc < DIMOF(vfields); lpc++) { crm_element_value_int(tmp, vfields[lpc], &(del[lpc])); crm_trace("Got %d for del[%s]", del[lpc], vfields[lpc]); } } switch(format) { case 1: tmp = find_xml_node(patchset, "diff-added", FALSE); tmp = find_xml_node(tmp, "cib", FALSE); if(tmp == NULL) { / Revert to the diff-added line / tmp = find_xml_node(patchset, "diff-added", FALSE); } break; case 2: tmp = find_xml_node(patchset, "version", FALSE); tmp = find_xml_node(tmp, "target", FALSE); break; default: crm_warn("Unknown patch format: %d", format); return -EINVAL; } if (tmp) { for(lpc = 0; lpc < DIMOF(vfields); lpc++) { crm_element_value_int(tmp, vfields[lpc], &(add[lpc])); crm_trace("Got %d for add[%s]", add[lpc], vfields[lpc]); } } return pcmk_ok; } static int xml_patch_version_check(xmlNode xml, xmlNode patchset, int format) { int lpc = 0; bool changed = FALSE; int this[] = { 0, 0, 0 }; int add[] = { 0, 0, 0 }; int del[] = { 0, 0, 0 }; const char vfields[] = { XML_ATTR_GENERATION_ADMIN, XML_ATTR_GENERATION, XML_ATTR_NUMUPDATES, }; for(lpc = 0; lpc < DIMOF(vfields); lpc++) { crm_element_value_int(xml, vfields[lpc], &(this[lpc])); crm_trace("Got %d for this[%s]", this[lpc], vfields[lpc]); if (this[lpc] < 0) { this[lpc] = 0; } } /* Set some defaults in case nothing is present / add[0] = this[0]; add[1] = this[1]; add[2] = this[2] + 1; for(lpc = 0; lpc < DIMOF(vfields); lpc++) { del[lpc] = this[lpc]; } xml_patch_versions(patchset, add, del); for(lpc = 0; lpc < DIMOF(vfields); lpc++) { if(this[lpc] < del[lpc]) { crm_debug("Current %s is too low (%d < %d)", vfields[lpc], this[lpc], del[lpc]); return -pcmk_err_diff_resync; } else if(this[lpc] > del[lpc]) { crm_info("Current %s is too high (%d > %d)", vfields[lpc], this[lpc], del[lpc]); return -pcmk_err_old_data; } } for(lpc = 0; lpc < DIMOF(vfields); lpc++) { if(add[lpc] > del[lpc]) { changed = TRUE; } } if(changed == FALSE) { crm_notice("Versions did not change in patch %d.%d.%d", add[0], add[1], add[2]); return -pcmk_err_old_data; } crm_debug("Can apply patch %d.%d.%d to %d.%d.%d", add[0], add[1], add[2], this[0], this[1], this[2]); return pcmk_ok; } static int xml_apply_patchset_v1(xmlNode xml, xmlNode patchset, bool check_version) { int rc = pcmk_ok; int root_nodes_seen = 0; char version = crm_element_value_copy(xml, XML_ATTR_CRM_VERSION); xmlNode child_diff = NULL; xmlNode added = find_xml_node(patchset, "diff-added", FALSE); xmlNode removed = find_xml_node(patchset, "diff-removed", FALSE); xmlNode old = copy_xml(xml); crm_trace("Substraction Phase"); for (child_diff = __xml_first_child(removed); child_diff != NULL; child_diff = __xml_next(child_diff)) { CRM_CHECK(root_nodes_seen == 0, rc = FALSE); if (root_nodes_seen == 0) { __subtract_xml_object(xml, child_diff); } root_nodes_seen++; } if (root_nodes_seen > 1) { crm_err("(-) Diffs cannot contain more than one change set... saw %d", root_nodes_seen); rc = -ENOTUNIQ; } root_nodes_seen = 0; crm_trace("Addition Phase"); if (rc == pcmk_ok) { xmlNode child_diff = NULL; for (child_diff = __xml_first_child(added); child_diff != NULL; child_diff = __xml_next(child_diff)) { CRM_CHECK(root_nodes_seen == 0, rc = FALSE); if (root_nodes_seen == 0) { __add_xml_object(NULL, xml, child_diff); } root_nodes_seen++; } } if (root_nodes_seen > 1) { crm_err("(+) Diffs cannot contain more than one change set... saw %d", root_nodes_seen); rc = -ENOTUNIQ; } purge_diff_markers(xml); / Purge prior to checking the digest / free_xml(old); free(version); return rc; } static xmlNode __first_xml_child_match(xmlNode parent, const char name, const char id) { xmlNode cIter = NULL; for (cIter = __xml_first_child(parent); cIter != NULL; cIter = __xml_next(cIter)) { if(strcmp((const char )cIter->name, name) != 0) { continue; } else if(id) { const char cid = ID(cIter); if(cid == NULL \|\| strcmp(cid, id) != 0) { continue; } } return cIter; } return NULL; } static xmlNode * __xml_find_path(xmlNode top, const char key) { xmlNode target = (xmlNode)top->doc; char id = malloc(XML_BUFFER_SIZE); char tag = malloc(XML_BUFFER_SIZE); char section = malloc(XML_BUFFER_SIZE); char current = strdup(key); char remainder = malloc(XML_BUFFER_SIZE); int rc = 0; while(current) { rc = sscanf (current, "/%[^/]%s", section, remainder); if(rc <= 0) { crm_trace("Done"); break; } else if(rc > 2) { crm_trace("Aborting on %s", current); target = NULL; break; } else if(tag && section) { int f = sscanf (section, "%[^[][@id='%[^']", tag, id); switch(f) { case 1: target = __first_xml_child_match(target, tag, NULL); break; case 2: target = __first_xml_child_match(target, tag, id); break; default: crm_trace("Aborting on %s", section); target = NULL; break; } if(rc == 1 \|\| target == NULL) { crm_trace("Done"); break; } else { char tmp = current; current = remainder; remainder = tmp; } } } if(target) { char path = (char )xmlGetNodePath(target); crm_trace("Found %s for %s", path, key); free(path); } else { crm_debug("No match for %s", key); } free(remainder); free(current); free(section); free(tag); free(id); return target; } static int xml_apply_patchset_v2(xmlNode xml, xmlNode patchset, bool check_version) { int rc = pcmk_ok; xmlNode change = NULL; for (change = __xml_first_child(patchset); change != NULL; change = __xml_next(change)) { xmlNode match = NULL; const char op = crm_element_value(change, XML_DIFF_OP); const char xpath = crm_element_value(change, XML_DIFF_PATH); crm_trace("Processing %s %s", change->name, op); if(op == NULL) { continue; } #if 0 match = get_xpath_object(xpath, xml, LOG_TRACE); #else match = __xml_find_path(xml, xpath); #endif crm_trace("Performing %s on %s with %p", op, xpath, match); if(match == NULL && strcmp(op, "delete") == 0) { crm_debug("No %s match for %s in %p", op, xpath, xml->doc); continue; } else if(match == NULL) { crm_err("No %s match for %s in %p", op, xpath, xml->doc); rc = -pcmk_err_diff_failed; continue; } else if(strcmp(op, "create") == 0) { int position = 0; xmlNode child = NULL; xmlNode match_child = NULL; match_child = match->children; crm_element_value_int(change, XML_DIFF_POSITION, &position); while(match_child && position != __xml_offset(match_child)) { match_child = match_child->next; } child = xmlDocCopyNode(change->children, match->doc, 1); if(match_child) { crm_trace("Adding %s at position %d", child->name, position); xmlAddPrevSibling(match_child, child); } else if(match->last) { /* Add to the end / crm_trace("Adding %s at position %d (end)", child->name, position); xmlAddNextSibling(match->last, child); } else { crm_trace("Adding %s at position %d (first)", child->name, position); CRM_LOG_ASSERT(position == 0); xmlAddChild(match, child); } crm_node_created(child); } else if(strcmp(op, "move") == 0) { int position = 0; crm_element_value_int(change, XML_DIFF_POSITION, &position); if(position != __xml_offset(match)) { xmlNode match_child = NULL; int p = position; if(p > __xml_offset(match)) { p++; /* Skip ourselves / } CRM_ASSERT(match->parent != NULL); match_child = match->parent->children; while(match_child && p != __xml_offset(match_child)) { match_child = match_child->next; } crm_trace("Moving %s to position %d (was %d, prev %p, %s %p)", match->name, position, __xml_offset(match), match->prev, match_child?"next":"last", match_child?match_child:match->parent->last); if(match_child) { xmlAddPrevSibling(match_child, match); } else { CRM_ASSERT(match->parent->last != NULL); xmlAddNextSibling(match->parent->last, match); } } else { crm_trace("%s is already in position %d", match->name, position); } if(position != __xml_offset(match)) { crm_err("Moved %s.%d to position %d instead of %d (%p)", match->name, ID(match), __xml_offset(match), position, match->prev); rc = -pcmk_err_diff_failed; } } else if(strcmp(op, "delete") == 0) { free_xml(match); } else if(strcmp(op, "modify") == 0) { xmlAttr pIter = crm_first_attr(match); xmlNode attrs = __xml_first_child(first_named_child(change, XML_DIFF_RESULT)); if(attrs == NULL) { rc = -ENOMSG; continue; } while(pIter != NULL) { const char name = (const char )pIter->name; pIter = pIter->next; xml_remove_prop(match, name); } for (pIter = crm_first_attr(attrs); pIter != NULL; pIter = pIter->next) { const char name = (const char )pIter->name; const char value = crm_element_value(attrs, name); crm_xml_add(match, name, value); } } else { crm_err("Unknown operation: %s", op); } } return rc; } int xml_apply_patchset(xmlNode xml, xmlNode patchset, bool check_version) { int format = 1; int rc = pcmk_ok; xmlNode old = NULL; const char digest = crm_element_value(patchset, XML_ATTR_DIGEST); if(patchset == NULL) { return rc; } xml_log_patchset(LOG_TRACE, __FUNCTION__, patchset); crm_element_value_int(patchset, "format", &format); if(check_version) { rc = xml_patch_version_check(xml, patchset, format); if(rc != pcmk_ok) { return rc; } } if(digest) { /* Make it available for logging if the result doesn't have the expected digest / old = copy_xml(xml); } if(rc == pcmk_ok) { switch(format) { case 1: rc = xml_apply_patchset_v1(xml, patchset, check_version); break; case 2: rc = xml_apply_patchset_v2(xml, patchset, check_version); break; default: crm_err("Unknown patch format: %d", format); rc = -EINVAL; } } if(rc == pcmk_ok && digest) { static struct qb_log_callsite digest_cs = NULL; char new_digest = NULL; char version = crm_element_value_copy(xml, XML_ATTR_CRM_VERSION); if (digest_cs == NULL) { digest_cs = qb_log_callsite_get(__func__, __FILE__, "diff-digest", LOG_TRACE, __LINE__, crm_trace_nonlog); } new_digest = calculate_xml_versioned_digest(xml, FALSE, TRUE, version); if (safe_str_neq(new_digest, digest)) { crm_info("v%d digest mis-match: expected %s, calculated %s", format, digest, new_digest); rc = -pcmk_err_diff_failed; if (digest_cs && digest_cs->targets) { save_xml_to_file(old, "PatchDigest:input", NULL); save_xml_to_file(xml, "PatchDigest:result", NULL); save_xml_to_file(patchset,"PatchDigest:diff", NULL); } else { crm_trace("%p %0.6x", digest_cs, digest_cs ? digest_cs->targets : 0); } } else { crm_trace("v%d digest matched: expected %s, calculated %s", format, digest, new_digest); } free(new_digest); free(version); } free_xml(old); return rc; } xmlNode * find_xml_node(xmlNode * root, const char search_path, gboolean must_find) { xmlNode a_child = NULL; const char name = "NULL"; if (root != NULL) { name = crm_element_name(root); } if (search_path == NULL) { crm_warn("Will never find <NULL>"); return NULL; } for (a_child = __xml_first_child(root); a_child != NULL; a_child = __xml_next(a_child)) { if (strcmp((const char )a_child->name, search_path) == 0) { /* crm_trace("returning node (%s).", crm_element_name(a_child)); / return a_child; } } if (must_find) { crm_warn("Could not find %s in %s.", search_path, name); } else if (root != NULL) { crm_trace("Could not find %s in %s.", search_path, name); } else { crm_trace("Could not find %s in <NULL>.", search_path); } return NULL; } xmlNode find_entity(xmlNode * parent, const char node_name, const char id) { xmlNode a_child = NULL; for (a_child = __xml_first_child(parent); a_child != NULL; a_child = __xml_next(a_child)) { / Uncertain if node_name == NULL check is strictly necessary here / if (node_name == NULL \|\| strcmp((const char )a_child->name, node_name) == 0) { const char cid = ID(a_child); if (id == NULL \|\| (cid != NULL && strcmp(id, cid) == 0)) { return a_child; } } } crm_trace("node <%s id=%s> not found in %s.", node_name, id, crm_element_name(parent)); return NULL; } void copy_in_properties(xmlNode target, xmlNode * src) { if (src == NULL) { crm_warn("No node to copy properties from"); } else if (target == NULL) { crm_err("No node to copy properties into"); } else { xmlAttrPtr pIter = NULL; for (pIter = crm_first_attr(src); pIter != NULL; pIter = pIter->next) { const char p_name = (const char )pIter->name; const char p_value = crm_attr_value(pIter); expand_plus_plus(target, p_name, p_value); } } return; } void fix_plus_plus_recursive(xmlNode target) { /* TODO: Remove recursion and use xpath searches for value++ / xmlNode child = NULL; xmlAttrPtr pIter = NULL; for (pIter = crm_first_attr(target); pIter != NULL; pIter = pIter->next) { const char p_name = (const char )pIter->name; const char p_value = crm_attr_value(pIter); expand_plus_plus(target, p_name, p_value); } for (child = __xml_first_child(target); child != NULL; child = __xml_next(child)) { fix_plus_plus_recursive(child); } } void expand_plus_plus(xmlNode target, const char name, const char value) { int offset = 1; int name_len = 0; int int_value = 0; int value_len = 0; const char old_value = NULL; if (value == NULL \|\| name == NULL) { return; } old_value = crm_element_value(target, name); if (old_value == NULL) { / if no previous value, set unexpanded / goto set_unexpanded; } else if (strstr(value, name) != value) { goto set_unexpanded; } name_len = strlen(name); value_len = strlen(value); if (value_len < (name_len + 2) \|\| value[name_len] != '+' \|\| (value[name_len + 1] != '+' && value[name_len + 1] != '=')) { goto set_unexpanded; } / if we are expanding ourselves, * then no previous value was set and leave int_value as 0 / if (old_value != value) { int_value = char2score(old_value); } if (value[name_len + 1] != '+') { const char offset_s = value + (name_len + 2); offset = char2score(offset_s); } int_value += offset; if (int_value > INFINITY) { int_value = (int)INFINITY; } crm_xml_add_int(target, name, int_value); return; set_unexpanded: if (old_value == value) { /* the old value is already set, nothing to do / return; } crm_xml_add(target, name, value); return; } xmlDoc getDocPtr(xmlNode * node) { xmlDoc doc = NULL; CRM_CHECK(node != NULL, return NULL); doc = node->doc; if (doc == NULL) { doc = xmlNewDoc((const xmlChar )"1.0"); xmlDocSetRootElement(doc, node); xmlSetTreeDoc(node, doc); } return doc; } xmlNode * add_node_copy(xmlNode * parent, xmlNode * src_node) { xmlNode child = NULL; xmlDoc doc = getDocPtr(parent); CRM_CHECK(src_node != NULL, return NULL); child = xmlDocCopyNode(src_node, doc, 1); xmlAddChild(parent, child); crm_node_created(child); return child; } int add_node_nocopy(xmlNode * parent, const char name, xmlNode child) { add_node_copy(parent, child); free_xml(child); return 1; } static bool __xml_acl_check(xmlNode xml, const char name, enum xml_private_flags mode) { CRM_ASSERT(xml); CRM_ASSERT(xml->doc); CRM_ASSERT(xml->doc->_private); #if ENABLE_ACL { if(TRACKING_CHANGES(xml) && xml_acl_enabled(xml)) { int offset = 0; xmlNode parent = xml; char buffer[XML_BUFFER_SIZE]; xml_private_t docp = xml->doc->_private; if(docp->acls == NULL) { crm_trace("Ordinary user %s cannot access the CIB without any defined ACLs", docp->user); set_doc_flag(xml, xpf_acl_denied); return FALSE; } offset = __get_prefix(NULL, xml, buffer, offset); if(name) { offset += snprintf(buffer + offset, XML_BUFFER_SIZE - offset, "[@%s]", name); } CRM_LOG_ASSERT(offset > 0); /* Walk the tree upwards looking for xml_acl_* flags * - Creating an attribute requires write permissions for the node * - Creating a child requires write permissions for the parent / if(name) { xmlAttr attr = xmlHasProp(xml, (const xmlChar )name); if(attr && mode == xpf_acl_create) { mode = xpf_acl_write; } } while(parent && parent->_private) { xml_private_t p = parent->_private; if(__xml_acl_mode_test(p->flags, mode)) { return TRUE; } else if(is_set(p->flags, xpf_acl_deny)) { crm_trace("%x access denied to %s: parent", mode, buffer); set_doc_flag(xml, xpf_acl_denied); return FALSE; } parent = parent->parent; } crm_trace("%x access denied to %s: default", mode, buffer); set_doc_flag(xml, xpf_acl_denied); return FALSE; } } #endif return TRUE; } const char * crm_xml_add(xmlNode * node, const char name, const char value) { bool dirty = FALSE; xmlAttr attr = NULL; CRM_CHECK(node != NULL, return NULL); CRM_CHECK(name != NULL, return NULL); if (value == NULL) { return NULL; } #if XML_PARANOIA_CHECKS { const char old_value = NULL; old_value = crm_element_value(node, name); /* Could be re-setting the same value / CRM_CHECK(old_value != value, crm_err("Cannot reset %s with crm_xml_add(%s)", name, value); return value); } #endif if(TRACKING_CHANGES(node)) { const char old = crm_element_value(node, name); if(old == NULL \|\| value == NULL \|\| strcmp(old, value) != 0) { dirty = TRUE; } } if(dirty && __xml_acl_check(node, name, xpf_acl_create) == FALSE) { crm_trace("Cannot add %s=%s to %s", name, value, node->name); return NULL; } attr = xmlSetProp(node, (const xmlChar )name, (const xmlChar )value); if(dirty) { crm_attr_dirty(attr); } CRM_CHECK(attr && attr->children && attr->children->content, return NULL); return (char )attr->children->content; } const char crm_xml_replace(xmlNode * node, const char name, const char value) { bool dirty = FALSE; xmlAttr attr = NULL; const char old_value = NULL; CRM_CHECK(node != NULL, return NULL); CRM_CHECK(name != NULL && name[0] != 0, return NULL); old_value = crm_element_value(node, name); /* Could be re-setting the same value / CRM_CHECK(old_value != value, return value); if(__xml_acl_check(node, name, xpf_acl_write) == FALSE) { / Create a fake object linked to doc->_private instead? / crm_trace("Cannot replace %s=%s to %s", name, value, node->name); return NULL; } else if (old_value != NULL && value == NULL) { xml_remove_prop(node, name); return NULL; } else if (value == NULL) { return NULL; } if(TRACKING_CHANGES(node)) { if(old_value == NULL \|\| value == NULL \|\| strcmp(old_value, value) != 0) { dirty = TRUE; } } attr = xmlSetProp(node, (const xmlChar )name, (const xmlChar )value); if(dirty) { crm_attr_dirty(attr); } CRM_CHECK(attr && attr->children && attr->children->content, return NULL); return (char )attr->children->content; } const char * crm_xml_add_int(xmlNode * node, const char name, int value) { char number = crm_itoa(value); const char added = crm_xml_add(node, name, number); free(number); return added; } xmlNode create_xml_node(xmlNode * parent, const char name) { xmlDoc doc = NULL; xmlNode node = NULL; if (name == NULL \|\| name[0] == 0) { CRM_CHECK(name != NULL && name[0] == 0, return NULL); return NULL; } if (parent == NULL) { doc = xmlNewDoc((const xmlChar )"1.0"); node = xmlNewDocRawNode(doc, NULL, (const xmlChar )name, NULL); xmlDocSetRootElement(doc, node); } else { doc = getDocPtr(parent); node = xmlNewDocRawNode(doc, NULL, (const xmlChar )name, NULL); xmlAddChild(parent, node); } crm_node_created(node); return node; } static inline int __get_prefix(const char prefix, xmlNode xml, char buffer, int offset) { const char id = ID(xml); if(offset == 0 && prefix == NULL && xml->parent) { offset = __get_prefix(NULL, xml->parent, buffer, offset); } if(id) { offset += snprintf(buffer + offset, XML_BUFFER_SIZE - offset, "/%s[@id='%s']", (const char )xml->name, id); } else if(xml->name) { offset += snprintf(buffer + offset, XML_BUFFER_SIZE - offset, "/%s", (const char )xml->name); } return offset; } char * xml_get_path(xmlNode xml) { int offset = 0; char buffer[XML_BUFFER_SIZE]; if(__get_prefix(NULL, xml, buffer, offset) > 0) { return strdup(buffer); } return NULL; } void free_xml(xmlNode child) { if (child != NULL) { xmlNode top = NULL; xmlDoc doc = child->doc; xml_private_t p = child->_private; if (doc != NULL) { top = xmlDocGetRootElement(doc); } if (doc != NULL && top == child) { / Free everything / xmlFreeDoc(doc); } else if(__xml_acl_check(child, NULL, xpf_acl_write) == FALSE) { int offset = 0; char buffer[XML_BUFFER_SIZE]; __get_prefix(NULL, child, buffer, offset); crm_trace("Cannot remove %s %x", buffer, p->flags); return; } else { if(doc && TRACKING_CHANGES(child) && is_not_set(p->flags, xpf_created)) { int offset = 0; char buffer[XML_BUFFER_SIZE]; if(__get_prefix(NULL, child, buffer, offset) > 0) { crm_trace("Deleting %s %p from %p", buffer, child, doc); p = doc->_private; p->deleted_paths = g_list_append(p->deleted_paths, strdup(buffer)); set_doc_flag(child, xpf_dirty); } } / Free this particular subtree * Make sure to unlink it from the parent first / xmlUnlinkNode(child); xmlFreeNode(child); } } } xmlNode copy_xml(xmlNode * src) { xmlDoc doc = xmlNewDoc((const xmlChar )"1.0"); xmlNode copy = xmlDocCopyNode(src, doc, 1); xmlDocSetRootElement(doc, copy); xmlSetTreeDoc(copy, doc); return copy; } static void crm_xml_err(void ctx, const char msg, ...) G_GNUC_PRINTF(2, 3); static void crm_xml_err(void ctx, const char msg, ...) { int len = 0; va_list args; char buf = NULL; static int buffer_len = 0; static char buffer = NULL; static struct qb_log_callsite xml_error_cs = NULL; va_start(args, msg); len = vasprintf(&buf, msg, args); if(xml_error_cs == NULL) { xml_error_cs = qb_log_callsite_get( __func__, __FILE__, "xml library error", LOG_TRACE, __LINE__, crm_trace_nonlog); } if (strchr(buf, '\n')) { buf[len - 1] = 0; if (buffer) { crm_err("XML Error: %s%s", buffer, buf); free(buffer); } else { crm_err("XML Error: %s", buf); } if (xml_error_cs && xml_error_cs->targets) { crm_abort(__FILE__, __PRETTY_FUNCTION__, __LINE__, "xml library error", TRUE, TRUE); } buffer = NULL; buffer_len = 0; } else if (buffer == NULL) { buffer_len = len; buffer = buf; buf = NULL; } else { buffer = realloc_safe(buffer, 1 + buffer_len + len); memcpy(buffer + buffer_len, buf, len); buffer_len += len; buffer[buffer_len] = 0; } va_end(args); free(buf); } xmlNode * string2xml(const char input) { xmlNode xml = NULL; xmlDocPtr output = NULL; xmlParserCtxtPtr ctxt = NULL; xmlErrorPtr last_error = NULL; if (input == NULL) { crm_err("Can't parse NULL input"); return NULL; } /* create a parser context / ctxt = xmlNewParserCtxt(); CRM_CHECK(ctxt != NULL, return NULL); / xmlCtxtUseOptions(ctxt, XML_PARSE_NOBLANKS\|XML_PARSE_RECOVER); / xmlCtxtResetLastError(ctxt); xmlSetGenericErrorFunc(ctxt, crm_xml_err); / initGenericErrorDefaultFunc(crm_xml_err); / output = xmlCtxtReadDoc(ctxt, (const xmlChar )input, NULL, NULL, XML_PARSE_NOBLANKS \| XML_PARSE_RECOVER); if (output) { xml = xmlDocGetRootElement(output); } last_error = xmlCtxtGetLastError(ctxt); if (last_error && last_error->code != XML_ERR_OK) { /* crm_abort(__FILE__,__FUNCTION__,__LINE__, "last_error->code != XML_ERR_OK", TRUE, TRUE); / / * http://xmlsoft.org/html/libxml-xmlerror.html#xmlErrorLevel * http://xmlsoft.org/html/libxml-xmlerror.html#xmlParserErrors / crm_warn("Parsing failed (domain=%d, level=%d, code=%d): %s", last_error->domain, last_error->level, last_error->code, last_error->message); if (last_error->code == XML_ERR_DOCUMENT_EMPTY) { CRM_LOG_ASSERT("Cannot parse an empty string"); } else if (last_error->code != XML_ERR_DOCUMENT_END) { crm_err("Couldn't%s parse %d chars: %s", xml ? " fully" : "", (int)strlen(input), input); if (xml != NULL) { crm_log_xml_err(xml, "Partial"); } } else { int len = strlen(input); int lpc = 0; while(lpc < len) { crm_warn("Parse error[+%.3d]: %.80s", lpc, input+lpc); lpc += 80; } CRM_LOG_ASSERT("String parsing error"); } } xmlFreeParserCtxt(ctxt); return xml; } xmlNode stdin2xml(void) { size_t data_length = 0; size_t read_chars = 0; char xml_buffer = NULL; xmlNode xml_obj = NULL; do { size_t next = XML_BUFFER_SIZE + data_length + 1; if(next <= 0) { crm_err("Buffer size exceeded at: %l + %d", data_length, XML_BUFFER_SIZE); break; } xml_buffer = realloc_safe(xml_buffer, next); read_chars = fread(xml_buffer + data_length, 1, XML_BUFFER_SIZE, stdin); data_length += read_chars; } while (read_chars > 0); if (data_length == 0) { crm_warn("No XML supplied on stdin"); free(xml_buffer); return NULL; } xml_buffer[data_length] = '\0'; xml_obj = string2xml(xml_buffer); free(xml_buffer); crm_log_xml_trace(xml_obj, "Created fragment"); return xml_obj; } static char * decompress_file(const char filename) { char buffer = NULL; #if HAVE_BZLIB_H int rc = 0; size_t length = 0, read_len = 0; BZFILE bz_file = NULL; FILE input = fopen(filename, "r"); if (input == NULL) { crm_perror(LOG_ERR, "Could not open %s for reading", filename); return NULL; } bz_file = BZ2_bzReadOpen(&rc, input, 0, 0, NULL, 0); if (rc != BZ_OK) { BZ2_bzReadClose(&rc, bz_file); return NULL; } rc = BZ_OK; while (rc == BZ_OK) { buffer = realloc_safe(buffer, XML_BUFFER_SIZE + length + 1); read_len = BZ2_bzRead(&rc, bz_file, buffer + length, XML_BUFFER_SIZE); crm_trace("Read %ld bytes from file: %d", (long)read_len, rc); if (rc == BZ_OK \|\| rc == BZ_STREAM_END) { length += read_len; } } buffer[length] = '\0'; if (rc != BZ_STREAM_END) { crm_err("Couldnt read compressed xml from file"); free(buffer); buffer = NULL; } BZ2_bzReadClose(&rc, bz_file); fclose(input); #else crm_err("Cannot read compressed files:" " bzlib was not available at compile time"); #endif return buffer; } void strip_text_nodes(xmlNode * xml) { xmlNode iter = xml->children; while (iter) { xmlNode next = iter->next; switch (iter->type) { case XML_TEXT_NODE: /* Remove it / xmlUnlinkNode(iter); xmlFreeNode(iter); break; case XML_ELEMENT_NODE: / Search it / strip_text_nodes(iter); break; default: / Leave it / break; } iter = next; } } xmlNode filename2xml(const char filename) { xmlNode xml = NULL; xmlDocPtr output = NULL; const char match = NULL; xmlParserCtxtPtr ctxt = NULL; xmlErrorPtr last_error = NULL; static int xml_options = XML_PARSE_NOBLANKS \| XML_PARSE_RECOVER; / create a parser context / ctxt = xmlNewParserCtxt(); CRM_CHECK(ctxt != NULL, return NULL); / xmlCtxtUseOptions(ctxt, XML_PARSE_NOBLANKS\|XML_PARSE_RECOVER); / xmlCtxtResetLastError(ctxt); xmlSetGenericErrorFunc(ctxt, crm_xml_err); / initGenericErrorDefaultFunc(crm_xml_err); / if (filename) { match = strstr(filename, ".bz2"); } if (filename == NULL) { / STDIN_FILENO == fileno(stdin) / output = xmlCtxtReadFd(ctxt, STDIN_FILENO, "unknown.xml", NULL, xml_options); } else if (match == NULL \|\| match[4] != 0) { output = xmlCtxtReadFile(ctxt, filename, NULL, xml_options); } else { char input = decompress_file(filename); output = xmlCtxtReadDoc(ctxt, (const xmlChar )input, NULL, NULL, xml_options); free(input); } if (output && (xml = xmlDocGetRootElement(output))) { strip_text_nodes(xml); } last_error = xmlCtxtGetLastError(ctxt); if (last_error && last_error->code != XML_ERR_OK) { / crm_abort(__FILE__,__FUNCTION__,__LINE__, "last_error->code != XML_ERR_OK", TRUE, TRUE); / / * http://xmlsoft.org/html/libxml-xmlerror.html#xmlErrorLevel * http://xmlsoft.org/html/libxml-xmlerror.html#xmlParserErrors / crm_err("Parsing failed (domain=%d, level=%d, code=%d): %s", last_error->domain, last_error->level, last_error->code, last_error->message); if (last_error && last_error->code != XML_ERR_OK) { crm_err("Couldn't%s parse %s", xml ? " fully" : "", filename); if (xml != NULL) { crm_log_xml_err(xml, "Partial"); } } } xmlFreeParserCtxt(ctxt); return xml; } /! * \internal * \brief Add a "last written" attribute to an XML node, set to current time * * \param[in] xml_node XML node to get attribute * * \return Value that was set, or NULL on error / const char crm_xml_add_last_written(xmlNode xml_node) { time_t now = time(NULL); char now_str = ctime(&now); now_str[24] = EOS; /* replace the newline / return crm_xml_add(xml_node, XML_CIB_ATTR_WRITTEN, now_str); } static int write_xml_stream(xmlNode xml_node, const char filename, FILE stream, gboolean compress) { int res = 0; char buffer = NULL; unsigned int out = 0; CRM_CHECK(stream != NULL, return -1); crm_trace("Writing XML out to %s", filename); if (xml_node == NULL) { crm_err("Cannot write NULL to %s", filename); fclose(stream); return -1; } crm_log_xml_trace(xml_node, "Writing out"); buffer = dump_xml_formatted(xml_node); CRM_CHECK(buffer != NULL && strlen(buffer) > 0, crm_log_xml_warn(xml_node, "dump:failed"); goto bail); if (compress) { #if HAVE_BZLIB_H int rc = BZ_OK; unsigned int in = 0; BZFILE bz_file = NULL; bz_file = BZ2_bzWriteOpen(&rc, stream, 5, 0, 30); if (rc != BZ_OK) { crm_err("bzWriteOpen failed: %d", rc); } else { BZ2_bzWrite(&rc, bz_file, buffer, strlen(buffer)); if (rc != BZ_OK) { crm_err("bzWrite() failed: %d", rc); } } if (rc == BZ_OK) { BZ2_bzWriteClose(&rc, bz_file, 0, &in, &out); if (rc != BZ_OK) { crm_err("bzWriteClose() failed: %d", rc); out = -1; } else { crm_trace("%s: In: %d, out: %d", filename, in, out); } } #else crm_err("Cannot write compressed files:" " bzlib was not available at compile time"); #endif } if (out <= 0) { res = fprintf(stream, "%s", buffer); if (res < 0) { crm_perror(LOG_ERR, "Cannot write output to %s", filename); goto bail; } } bail: if (fflush(stream) != 0) { crm_perror(LOG_ERR, "fflush for %s failed:", filename); res = -1; } if (fsync(fileno(stream)) < 0) { crm_perror(LOG_ERR, "fsync for %s failed:", filename); res = -1; } fclose(stream); crm_trace("Saved %d bytes to the Cib as XML", res); free(buffer); return res; } int write_xml_fd(xmlNode * xml_node, const char filename, int fd, gboolean compress) { FILE stream = NULL; CRM_CHECK(fd > 0, return -1); stream = fdopen(fd, "w"); return write_xml_stream(xml_node, filename, stream, compress); } int write_xml_file(xmlNode * xml_node, const char filename, gboolean compress) { FILE stream = NULL; stream = fopen(filename, "w"); return write_xml_stream(xml_node, filename, stream, compress); } xmlNode * get_message_xml(xmlNode * msg, const char field) { xmlNode tmp = first_named_child(msg, field); return __xml_first_child(tmp); } gboolean add_message_xml(xmlNode * msg, const char field, xmlNode xml) { xmlNode holder = create_xml_node(msg, field); add_node_copy(holder, xml); return TRUE; } static char crm_xml_escape_shuffle(char text, int start, int length, const char replace) { int lpc; int offset = strlen(replace) - 1; / We have space for 1 char already / length += offset; text = realloc_safe(text, length); for (lpc = (length) - 1; lpc > (start + offset); lpc--) { text[lpc] = text[lpc - offset]; } memcpy(text + start, replace, offset + 1); return text; } char * crm_xml_escape(const char text) { int index; int changes = 0; int length = 1 + strlen(text); char copy = strdup(text); /* * When xmlCtxtReadDoc() parses < and friends in a * value, it converts them to their human readable * form. * * If one uses xmlNodeDump() to convert it back to a * string, all is well, because special characters are * converted back to their escape sequences. * * However xmlNodeDump() is randomly dog slow, even with the same * input. So we need to replicate the escapeing in our custom * version so that the result can be re-parsed by xmlCtxtReadDoc() * when necessary. / for (index = 0; index < length; index++) { switch (copy[index]) { case 0: break; case '<': copy = crm_xml_escape_shuffle(copy, index, &length, "<"); changes++; break; case '>': copy = crm_xml_escape_shuffle(copy, index, &length, ">"); changes++; break; case '"': copy = crm_xml_escape_shuffle(copy, index, &length, """); changes++; break; case '\'': copy = crm_xml_escape_shuffle(copy, index, &length, "'"); changes++; break; case '&': copy = crm_xml_escape_shuffle(copy, index, &length, "&"); changes++; break; case '\t': / Might as well just expand to a few spaces... / copy = crm_xml_escape_shuffle(copy, index, &length, " "); changes++; break; case '\n': / crm_trace("Convert: \\%.3o", copy[index]); / copy = crm_xml_escape_shuffle(copy, index, &length, "\\n"); changes++; break; case '\r': copy = crm_xml_escape_shuffle(copy, index, &length, "\\r"); changes++; break; / For debugging... case '\\': crm_trace("Passthrough: \\%c", copy[index+1]); break; / default: / Check for and replace non-printing characters with their octal equivalent / if(copy[index] < ' ' \|\| copy[index] > '~') { char replace = crm_strdup_printf("\\%.3o", copy[index]); /* crm_trace("Convert to octal: \\%.3o", copy[index]); / copy = crm_xml_escape_shuffle(copy, index, &length, replace); free(replace); changes++; } } } if (changes) { crm_trace("Dumped '%s'", copy); } return copy; } static inline void dump_xml_attr(xmlAttrPtr attr, int options, char buffer, int offset, int max) { char p_value = NULL; const char p_name = NULL; CRM_ASSERT(buffer != NULL); if (attr == NULL \|\| attr->children == NULL) { return; } p_name = (const char )attr->name; p_value = crm_xml_escape((const char )attr->children->content); buffer_print(buffer, max, offset, " %s=\"%s\"", p_name, p_value); free(p_value); } static void __xml_log_element(int log_level, const char file, const char function, int line, const char prefix, xmlNode data, int depth, int options) { int max = 0; int offset = 0; const char name = NULL; const char hidden = NULL; xmlNode child = NULL; xmlAttrPtr pIter = NULL; if(data == NULL) { return; } name = crm_element_name(data); if(is_set(options, xml_log_option_open)) { char buffer = NULL; insert_prefix(options, &buffer, &offset, &max, depth); if(data->type == XML_COMMENT_NODE) { buffer_print(buffer, max, offset, "<!--"); buffer_print(buffer, max, offset, "%s", data->content); buffer_print(buffer, max, offset, "-->"); } else { buffer_print(buffer, max, offset, "<%s", name); } hidden = crm_element_value(data, "hidden"); for (pIter = crm_first_attr(data); pIter != NULL; pIter = pIter->next) { xml_private_t p = pIter->_private; const char p_name = (const char )pIter->name; const char p_value = crm_attr_value(pIter); char p_copy = NULL; if(is_set(p->flags, xpf_deleted)) { continue; } else if ((is_set(options, xml_log_option_diff_plus) \|\| is_set(options, xml_log_option_diff_minus)) && strcmp(XML_DIFF_MARKER, p_name) == 0) { continue; } else if (hidden != NULL && p_name[0] != 0 && strstr(hidden, p_name) != NULL) { p_copy = strdup("***"); } else { p_copy = crm_xml_escape(p_value); } buffer_print(buffer, max, offset, " %s=\"%s\"", p_name, p_copy); free(p_copy); } if(xml_has_children(data) == FALSE) { buffer_print(buffer, max, offset, "/>"); } else if(is_set(options, xml_log_option_children)) { buffer_print(buffer, max, offset, ">"); } else { buffer_print(buffer, max, offset, "/>"); } do_crm_log_alias(log_level, file, function, line, "%s %s", prefix, buffer); free(buffer); } if(data->type == XML_COMMENT_NODE) { return; } else if(xml_has_children(data) == FALSE) { return; } else if(is_set(options, xml_log_option_children)) { offset = 0; max = 0; for (child = __xml_first_child(data); child != NULL; child = __xml_next(child)) { __xml_log_element(log_level, file, function, line, prefix, child, depth + 1, options\|xml_log_option_open\|xml_log_option_close); } } if(is_set(options, xml_log_option_close)) { char buffer = NULL; insert_prefix(options, &buffer, &offset, &max, depth); buffer_print(buffer, max, offset, "</%s>", name); do_crm_log_alias(log_level, file, function, line, "%s %s", prefix, buffer); free(buffer); } } static void __xml_log_change_element(int log_level, const char file, const char function, int line, const char prefix, xmlNode data, int depth, int options) { xml_private_t p; char prefix_m = NULL; xmlNode child = NULL; xmlAttrPtr pIter = NULL; if(data == NULL) { return; } p = data->_private; prefix_m = strdup(prefix); prefix_m[1] = '+'; if(is_set(p->flags, xpf_dirty) && is_set(p->flags, xpf_created)) { / Continue and log full subtree / __xml_log_element(log_level, file, function, line, prefix_m, data, depth, options\|xml_log_option_open\|xml_log_option_close\|xml_log_option_children); } else if(is_set(p->flags, xpf_dirty)) { char spaces = calloc(80, 1); int s_count = 0, s_max = 80; char prefix_del = NULL; char prefix_moved = NULL; const char flags = prefix; insert_prefix(options, &spaces, &s_count, &s_max, depth); prefix_del = strdup(prefix); prefix_del[0] = '-'; prefix_del[1] = '-'; prefix_moved = strdup(prefix); prefix_moved[1] = '~'; if(is_set(p->flags, xpf_moved)) { flags = prefix_moved; } else { flags = prefix; } __xml_log_element(log_level, file, function, line, flags, data, depth, options\|xml_log_option_open); for (pIter = crm_first_attr(data); pIter != NULL; pIter = pIter->next) { const char aname = (const char)pIter->name; p = pIter->_private; if(is_set(p->flags, xpf_deleted)) { const char value = crm_element_value(data, aname); flags = prefix_del; do_crm_log_alias(log_level, file, function, line, "%s %s @%s=%s", flags, spaces, aname, value); } else if(is_set(p->flags, xpf_dirty)) { const char value = crm_element_value(data, aname); if(is_set(p->flags, xpf_created)) { flags = prefix_m; } else if(is_set(p->flags, xpf_modified)) { flags = prefix; } else if(is_set(p->flags, xpf_moved)) { flags = prefix_moved; } else { flags = prefix; } do_crm_log_alias(log_level, file, function, line, "%s %s @%s=%s", flags, spaces, aname, value); } } free(prefix_moved); free(prefix_del); free(spaces); for (child = __xml_first_child(data); child != NULL; child = __xml_next(child)) { __xml_log_change_element(log_level, file, function, line, prefix, child, depth + 1, options); } __xml_log_element(log_level, file, function, line, prefix, data, depth, options\|xml_log_option_close); } else { for (child = __xml_first_child(data); child != NULL; child = __xml_next(child)) { __xml_log_change_element(log_level, file, function, line, prefix, child, depth + 1, options); } } free(prefix_m); } void log_data_element(int log_level, const char file, const char function, int line, const char prefix, xmlNode * data, int depth, int options) { xmlNode a_child = NULL; char prefix_m = NULL; if (prefix == NULL) { prefix = ""; } /* Since we use the same file and line, to avoid confusing libqb, we need to use the same format strings / if (data == NULL) { do_crm_log_alias(log_level, file, function, line, "%s: %s", prefix, "No data to dump as XML"); return; } if(is_set(options, xml_log_option_dirty_add) \|\| is_set(options, xml_log_option_dirty_add)) { __xml_log_change_element(log_level, file, function, line, prefix, data, depth, options); return; } if (is_set(options, xml_log_option_formatted)) { if (is_set(options, xml_log_option_diff_plus) && (data->children == NULL \|\| crm_element_value(data, XML_DIFF_MARKER))) { options \|= xml_log_option_diff_all; prefix_m = strdup(prefix); prefix_m[1] = '+'; prefix = prefix_m; } else if (is_set(options, xml_log_option_diff_minus) && (data->children == NULL \|\| crm_element_value(data, XML_DIFF_MARKER))) { options \|= xml_log_option_diff_all; prefix_m = strdup(prefix); prefix_m[1] = '-'; prefix = prefix_m; } } if (is_set(options, xml_log_option_diff_short) && is_not_set(options, xml_log_option_diff_all)) { / Still searching for the actual change / for (a_child = __xml_first_child(data); a_child != NULL; a_child = __xml_next(a_child)) { log_data_element(log_level, file, function, line, prefix, a_child, depth + 1, options); } return; } __xml_log_element(log_level, file, function, line, prefix, data, depth, options\|xml_log_option_open\|xml_log_option_close\|xml_log_option_children); free(prefix_m); } static void dump_filtered_xml(xmlNode data, int options, char *buffer, int offset, int max) { int lpc; xmlAttrPtr xIter = NULL; static int filter_len = DIMOF(filter); for (lpc = 0; options && lpc < filter_len; lpc++) { filter[lpc].found = FALSE; } for (xIter = crm_first_attr(data); xIter != NULL; xIter = xIter->next) { bool skip = FALSE; const char p_name = (const char )xIter->name; for (lpc = 0; skip == FALSE && lpc < filter_len; lpc++) { if (filter[lpc].found == FALSE && strcmp(p_name, filter[lpc].string) == 0) { filter[lpc].found = TRUE; skip = TRUE; break; } } if (skip == FALSE) { dump_xml_attr(xIter, options, buffer, offset, max); } } } static void dump_xml_element(xmlNode data, int options, char *buffer, int offset, int max, int depth) { const char name = NULL; CRM_ASSERT(max != NULL); CRM_ASSERT(offset != NULL); CRM_ASSERT(buffer != NULL); if (data == NULL) { crm_trace("Nothing to dump"); return; } if (buffer == NULL) { offset = 0; max = 0; } name = crm_element_name(data); CRM_ASSERT(name != NULL); insert_prefix(options, buffer, offset, max, depth); buffer_print(buffer, max, offset, "<%s", name); if (options & xml_log_option_filtered) { dump_filtered_xml(data, options, buffer, offset, max); } else { xmlAttrPtr xIter = NULL; for (xIter = crm_first_attr(data); xIter != NULL; xIter = xIter->next) { dump_xml_attr(xIter, options, buffer, offset, max); } } if (data->children == NULL) { buffer_print(buffer, max, offset, "/>"); } else { buffer_print(buffer, max, offset, ">"); } if (options & xml_log_option_formatted) { buffer_print(buffer, max, offset, "\n"); } if (data->children) { xmlNode xChild = NULL; for (xChild = __xml_first_child(data); xChild != NULL; xChild = __xml_next(xChild)) { crm_xml_dump(xChild, options, buffer, offset, max, depth + 1); } insert_prefix(options, buffer, offset, max, depth); buffer_print(buffer, max, offset, "</%s>", name); if (options & xml_log_option_formatted) { buffer_print(buffer, max, offset, "\n"); } } } static void dump_xml_comment(xmlNode * data, int options, char *buffer, int offset, int max, int depth) { CRM_ASSERT(max != NULL); CRM_ASSERT(offset != NULL); CRM_ASSERT(buffer != NULL); if (data == NULL) { crm_trace("Nothing to dump"); return; } if (buffer == NULL) { offset = 0; max = 0; } insert_prefix(options, buffer, offset, max, depth); buffer_print(buffer, max, offset, "<!--"); buffer_print(buffer, max, offset, "%s", data->content); buffer_print(buffer, max, offset, "-->"); if (options & xml_log_option_formatted) { buffer_print(buffer, max, offset, "\n"); } } void crm_xml_dump(xmlNode * data, int options, char *buffer, int offset, int max, int depth) { #if 0 if (is_not_set(options, xml_log_option_filtered)) { / Turning this code on also changes the PE tests for some reason * (not just newlines). Figure out why before considering to * enable this permanently. * * It exists to help debug slowness in xmlNodeDump() and * potentially if we ever want to go back to it. * * In theory its a good idea (reuse) but our custom version does * better for the filtered case and avoids the final strdup() for * everything / time_t now, next; xmlDoc doc = NULL; xmlBuffer xml_buffer = NULL; buffer = NULL; doc = getDocPtr(data); /* doc will only be NULL if data is / CRM_CHECK(doc != NULL, return); now = time(NULL); xml_buffer = xmlBufferCreate(); CRM_ASSERT(xml_buffer != NULL); / The default allocator XML_BUFFER_ALLOC_EXACT does far too many * realloc()s and it can take upwards of 18 seconds (yes, seconds) * to dump a 28kb tree which XML_BUFFER_ALLOC_DOUBLEIT can do in * less than 1 second. * * We could also use xmlBufferCreateSize() to start with a * sane-ish initial size and avoid the first few doubles. / xmlBufferSetAllocationScheme(xml_buffer, XML_BUFFER_ALLOC_DOUBLEIT); max = xmlNodeDump(xml_buffer, doc, data, 0, (options & xml_log_option_formatted)); if (max > 0) { buffer = strdup((char )xml_buffer->content); } next = time(NULL); if ((now + 1) < next) { crm_log_xml_trace(data, "Long time"); crm_err("xmlNodeDump() -> %dbytes took %ds", max, next - now); } xmlBufferFree(xml_buffer); return; } #endif switch(data->type) { case XML_ELEMENT_NODE: /* Handle below / dump_xml_element(data, options, buffer, offset, max, depth); break; case XML_TEXT_NODE: / Ignore / return; case XML_COMMENT_NODE: dump_xml_comment(data, options, buffer, offset, max, depth); break; default: crm_warn("Unhandled type: %d", data->type); return; / XML_ATTRIBUTE_NODE = 2 XML_CDATA_SECTION_NODE = 4 XML_ENTITY_REF_NODE = 5 XML_ENTITY_NODE = 6 XML_PI_NODE = 7 XML_DOCUMENT_NODE = 9 XML_DOCUMENT_TYPE_NODE = 10 XML_DOCUMENT_FRAG_NODE = 11 XML_NOTATION_NODE = 12 XML_HTML_DOCUMENT_NODE = 13 XML_DTD_NODE = 14 XML_ELEMENT_DECL = 15 XML_ATTRIBUTE_DECL = 16 XML_ENTITY_DECL = 17 XML_NAMESPACE_DECL = 18 XML_XINCLUDE_START = 19 XML_XINCLUDE_END = 20 XML_DOCB_DOCUMENT_NODE = 21 / } } void crm_buffer_add_char(char buffer, int offset, int max, char c) { buffer_print(buffer, max, offset, "%c", c); } char * dump_xml_formatted(xmlNode * an_xml_node) { char buffer = NULL; int offset = 0, max = 0; crm_xml_dump(an_xml_node, xml_log_option_formatted, &buffer, &offset, &max, 0); return buffer; } char dump_xml_unformatted(xmlNode * an_xml_node) { char buffer = NULL; int offset = 0, max = 0; crm_xml_dump(an_xml_node, 0, &buffer, &offset, &max, 0); return buffer; } gboolean xml_has_children(const xmlNode xml_root) { if (xml_root != NULL && xml_root->children != NULL) { return TRUE; } return FALSE; } int crm_element_value_int(xmlNode * data, const char name, int dest) { const char value = crm_element_value(data, name); CRM_CHECK(dest != NULL, return -1); if (value) { dest = crm_int_helper(value, NULL); return 0; } return -1; } int crm_element_value_const_int(const xmlNode * data, const char name, int dest) { return crm_element_value_int((xmlNode ) data, name, dest); } const char crm_element_value_const(const xmlNode * data, const char name) { return crm_element_value((xmlNode ) data, name); } char * crm_element_value_copy(xmlNode * data, const char name) { char value_copy = NULL; const char value = crm_element_value(data, name); if (value != NULL) { value_copy = strdup(value); } return value_copy; } void xml_remove_prop(xmlNode obj, const char name) { if(__xml_acl_check(obj, NULL, xpf_acl_write) == FALSE) { crm_trace("Cannot remove %s from %s", name, obj->name); } else if(TRACKING_CHANGES(obj)) { / Leave in place (marked for removal) until after the diff is calculated / xml_private_t p = NULL; xmlAttr attr = xmlHasProp(obj, (const xmlChar )name); p = attr->_private; set_parent_flag(obj, xpf_dirty); p->flags \|= xpf_deleted; /* crm_trace("Setting flag %x due to %s[@id=%s].%s", xpf_dirty, obj->name, ID(obj), name); / } else { xmlUnsetProp(obj, (const xmlChar )name); } } void purge_diff_markers(xmlNode * a_node) { xmlNode child = NULL; CRM_CHECK(a_node != NULL, return); xml_remove_prop(a_node, XML_DIFF_MARKER); for (child = __xml_first_child(a_node); child != NULL; child = __xml_next(child)) { purge_diff_markers(child); } } void save_xml_to_file(xmlNode xml, const char desc, const char filename) { char f = NULL; if (filename == NULL) { char uuid = crm_generate_uuid(); f = crm_strdup_printf("/tmp/%s", uuid); filename = f; free(uuid); } crm_info("Saving %s to %s", desc, filename); write_xml_file(xml, filename, FALSE); free(f); } gboolean apply_xml_diff(xmlNode * old, xmlNode * diff, xmlNode ** new) { gboolean result = TRUE; int root_nodes_seen = 0; static struct qb_log_callsite digest_cs = NULL; const char digest = crm_element_value(diff, XML_ATTR_DIGEST); const char version = crm_element_value(diff, XML_ATTR_CRM_VERSION); xmlNode child_diff = NULL; xmlNode added = find_xml_node(diff, "diff-added", FALSE); xmlNode removed = find_xml_node(diff, "diff-removed", FALSE); CRM_CHECK(new != NULL, return FALSE); if (digest_cs == NULL) { digest_cs = qb_log_callsite_get(__func__, __FILE__, "diff-digest", LOG_TRACE, __LINE__, crm_trace_nonlog); } crm_trace("Substraction Phase"); for (child_diff = __xml_first_child(removed); child_diff != NULL; child_diff = __xml_next(child_diff)) { CRM_CHECK(root_nodes_seen == 0, result = FALSE); if (root_nodes_seen == 0) { new = subtract_xml_object(NULL, old, child_diff, FALSE, NULL, NULL); } root_nodes_seen++; } if (root_nodes_seen == 0) { new = copy_xml(old); } else if (root_nodes_seen > 1) { crm_err("(-) Diffs cannot contain more than one change set..." " saw %d", root_nodes_seen); result = FALSE; } root_nodes_seen = 0; crm_trace("Addition Phase"); if (result) { xmlNode child_diff = NULL; for (child_diff = __xml_first_child(added); child_diff != NULL; child_diff = __xml_next(child_diff)) { CRM_CHECK(root_nodes_seen == 0, result = FALSE); if (root_nodes_seen == 0) { add_xml_object(NULL, new, child_diff, TRUE); } root_nodes_seen++; } } if (root_nodes_seen > 1) { crm_err("(+) Diffs cannot contain more than one change set..." " saw %d", root_nodes_seen); result = FALSE; } else if (result && digest) { char new_digest = NULL; purge_diff_markers(new); /* Purge now so the diff is ok / new_digest = calculate_xml_versioned_digest(new, FALSE, TRUE, version); if (safe_str_neq(new_digest, digest)) { crm_info("Digest mis-match: expected %s, calculated %s", digest, new_digest); result = FALSE; crm_trace("%p %0.6x", digest_cs, digest_cs ? digest_cs->targets : 0); if (digest_cs && digest_cs->targets) { save_xml_to_file(old, "diff:original", NULL); save_xml_to_file(diff, "diff:input", NULL); save_xml_to_file(new, "diff:new", NULL); } } else { crm_trace("Digest matched: expected %s, calculated %s", digest, new_digest); } free(new_digest); } else if (result) { purge_diff_markers(new); /* Purge now so the diff is ok / } return result; } static void __xml_diff_object(xmlNode old, xmlNode * new) { xmlNode cIter = NULL; xmlAttr pIter = NULL; CRM_CHECK(new != NULL, return); if(old == NULL) { crm_node_created(new); __xml_acl_post_process(new); /* Check creation is allowed / return; } else { xml_private_t p = new->_private; if(p->flags & xpf_processed) { /* Avoid re-comparing nodes / return; } p->flags \|= xpf_processed; } for (pIter = crm_first_attr(new); pIter != NULL; pIter = pIter->next) { xml_private_t p = pIter->_private; /* Assume everything was just created and take it from there / p->flags \|= xpf_created; } for (pIter = crm_first_attr(old); pIter != NULL; ) { xmlAttr prop = pIter; xml_private_t p = NULL; const char name = (const char )pIter->name; const char old_value = crm_element_value(old, name); xmlAttr exists = xmlHasProp(new, pIter->name); pIter = pIter->next; if(exists == NULL) { p = new->doc->_private; / Prevent the dirty flag being set recursively upwards / clear_bit(p->flags, xpf_tracking); exists = xmlSetProp(new, (const xmlChar )name, (const xmlChar )old_value); set_bit(p->flags, xpf_tracking); p = exists->_private; p->flags = 0; crm_trace("Lost %s@%s=%s", old->name, name, old_value); xml_remove_prop(new, name); } else { int p_new = __xml_offset((xmlNode)exists); int p_old = __xml_offset((xmlNode)prop); const char value = crm_element_value(new, name); p = exists->_private; p->flags = (p->flags & ~xpf_created); if(strcmp(value, old_value) != 0) { /* Restore the original value, so we can call crm_xml_add() whcih checks ACLs / char vcopy = crm_element_value_copy(new, name); crm_trace("Modified %s@%s %s->%s", old->name, name, old_value, vcopy); xmlSetProp(new, prop->name, (const xmlChar )old_value); crm_xml_add(new, name, vcopy); free(vcopy); } else if(p_old != p_new) { crm_info("Moved %s@%s (%d -> %d)", old->name, name, p_old, p_new); __xml_node_dirty(new); p->flags \|= xpf_dirty\|xpf_moved; if(p_old > p_new) { p = prop->_private; p->flags \|= xpf_skip; } else { p = exists->_private; p->flags \|= xpf_skip; } } } } for (pIter = crm_first_attr(new); pIter != NULL; ) { xmlAttr prop = pIter; xml_private_t p = pIter->_private; pIter = pIter->next; if(is_set(p->flags, xpf_created)) { char name = strdup((const char )prop->name); char value = crm_element_value_copy(new, name); crm_trace("Created %s@%s=%s", new->name, name, value); /* Remove plus create wont work as it will modify the relative attribute ordering / if(__xml_acl_check(new, name, xpf_acl_write)) { crm_attr_dirty(prop); } else { xmlUnsetProp(new, prop->name); / Remove - change not allowed / } free(value); free(name); } } for (cIter = __xml_first_child(old); cIter != NULL; ) { xmlNode old_child = cIter; xmlNode new_child = find_entity(new, crm_element_name(cIter), ID(cIter)); cIter = __xml_next(cIter); if(new_child) { __xml_diff_object(old_child, new_child); } else { xml_private_t p = old_child->_private; /* Create then free (which will check the acls if necessary) / xmlNode candidate = add_node_copy(new, old_child); xmlNode top = xmlDocGetRootElement(candidate->doc); __xml_node_clean(candidate); __xml_acl_apply(top); / Make sure any ACLs are applied to 'candidate' / free_xml(candidate); if(NULL == find_entity(new, crm_element_name(old_child), ID(old_child))) { p->flags \|= xpf_skip; } } } for (cIter = __xml_first_child(new); cIter != NULL; ) { xmlNode new_child = cIter; xmlNode old_child = find_entity(old, crm_element_name(cIter), ID(cIter)); cIter = __xml_next(cIter); if(old_child == NULL) { xml_private_t p = new_child->_private; p->flags \|= xpf_skip; __xml_diff_object(old_child, new_child); } else { /* Check for movement, we already checked for differences / int p_new = __xml_offset(new_child); int p_old = __xml_offset(old_child); xml_private_t p = new_child->_private; if(p_old != p_new) { crm_info("%s.%s moved from %d to %d - %d", new_child->name, ID(new_child), p_old, p_new); p->flags \|= xpf_moved; if(p_old > p_new) { p = old_child->_private; p->flags \|= xpf_skip; } else { p = new_child->_private; p->flags \|= xpf_skip; } } } } } void xml_calculate_changes(xmlNode * old, xmlNode * new) { CRM_CHECK(safe_str_eq(crm_element_name(old), crm_element_name(new)), return); CRM_CHECK(safe_str_eq(ID(old), ID(new)), return); if(xml_tracking_changes(new) == FALSE) { xml_track_changes(new, NULL, NULL, FALSE); } __xml_diff_object(old, new); } xmlNode * diff_xml_object(xmlNode * old, xmlNode * new, gboolean suppress) { xmlNode tmp1 = NULL; xmlNode diff = create_xml_node(NULL, "diff"); xmlNode removed = create_xml_node(diff, "diff-removed"); xmlNode added = create_xml_node(diff, "diff-added"); crm_xml_add(diff, XML_ATTR_CRM_VERSION, CRM_FEATURE_SET); tmp1 = subtract_xml_object(removed, old, new, FALSE, NULL, "removed:top"); if (suppress && tmp1 != NULL && can_prune_leaf(tmp1)) { free_xml(tmp1); } tmp1 = subtract_xml_object(added, new, old, TRUE, NULL, "added:top"); if (suppress && tmp1 != NULL && can_prune_leaf(tmp1)) { free_xml(tmp1); } if (added->children == NULL && removed->children == NULL) { free_xml(diff); diff = NULL; } return diff; } gboolean can_prune_leaf(xmlNode * xml_node) { xmlNode cIter = NULL; xmlAttrPtr pIter = NULL; gboolean can_prune = TRUE; const char name = crm_element_name(xml_node); if (safe_str_eq(name, XML_TAG_RESOURCE_REF) \|\| safe_str_eq(name, XML_CIB_TAG_OBJ_REF) \|\| safe_str_eq(name, XML_ACL_TAG_ROLE_REF) \|\| safe_str_eq(name, XML_ACL_TAG_ROLE_REFv1)) { return FALSE; } for (pIter = crm_first_attr(xml_node); pIter != NULL; pIter = pIter->next) { const char p_name = (const char )pIter->name; if (strcmp(p_name, XML_ATTR_ID) == 0) { continue; } can_prune = FALSE; } cIter = __xml_first_child(xml_node); while (cIter) { xmlNode child = cIter; cIter = __xml_next(cIter); if (can_prune_leaf(child)) { free_xml(child); } else { can_prune = FALSE; } } return can_prune; } void diff_filter_context(int context, int upper_bound, int lower_bound, xmlNode xml_node, xmlNode * parent) { xmlNode us = NULL; xmlNode child = NULL; xmlAttrPtr pIter = NULL; xmlNode new_parent = parent; const char name = crm_element_name(xml_node); CRM_CHECK(xml_node != NULL && name != NULL, return); us = create_xml_node(parent, name); for (pIter = crm_first_attr(xml_node); pIter != NULL; pIter = pIter->next) { const char p_name = (const char )pIter->name; const char p_value = crm_attr_value(pIter); lower_bound = context; crm_xml_add(us, p_name, p_value); } if (lower_bound >= 0 \|\| upper_bound >= 0) { crm_xml_add(us, XML_ATTR_ID, ID(xml_node)); new_parent = us; } else { upper_bound = in_upper_context(0, context, xml_node); if (upper_bound >= 0) { crm_xml_add(us, XML_ATTR_ID, ID(xml_node)); new_parent = us; } else { free_xml(us); us = NULL; } } for (child = __xml_first_child(us); child != NULL; child = __xml_next(child)) { diff_filter_context(context, upper_bound - 1, lower_bound - 1, child, new_parent); } } int in_upper_context(int depth, int context, xmlNode xml_node) { if (context == 0) { return 0; } if (xml_node->properties) { return depth; } else if (depth < context) { xmlNode child = NULL; for (child = __xml_first_child(xml_node); child != NULL; child = __xml_next(child)) { if (in_upper_context(depth + 1, context, child)) { return depth; } } } return 0; } static xmlNode find_xml_comment(xmlNode * root, xmlNode * search_comment) { xmlNode a_child = NULL; CRM_CHECK(search_comment->type == XML_COMMENT_NODE, return NULL); for (a_child = __xml_first_child(root); a_child != NULL; a_child = __xml_next(a_child)) { if (a_child->type != XML_COMMENT_NODE) { continue; } if (safe_str_eq((const char )a_child->content, (const char )search_comment->content)) { return a_child; } } return NULL; } static xmlNode subtract_xml_comment(xmlNode * parent, xmlNode * left, xmlNode * right, gboolean * changed) { CRM_CHECK(left != NULL, return NULL); CRM_CHECK(left->type == XML_COMMENT_NODE, return NULL); if (right == NULL \|\| safe_str_neq((const char )left->content, (const char )right->content)) { xmlNode deleted = NULL; deleted = add_node_copy(parent, left); changed = TRUE; return deleted; } return NULL; } xmlNode * subtract_xml_object(xmlNode * parent, xmlNode * left, xmlNode * right, gboolean full, gboolean * changed, const char marker) { gboolean dummy = FALSE; gboolean skip = FALSE; xmlNode diff = NULL; xmlNode right_child = NULL; xmlNode left_child = NULL; xmlAttrPtr xIter = NULL; const char id = NULL; const char name = NULL; const char value = NULL; const char right_val = NULL; int lpc = 0; static int filter_len = DIMOF(filter); if (changed == NULL) { changed = &dummy; } if (left == NULL) { return NULL; } if (left->type == XML_COMMENT_NODE) { return subtract_xml_comment(parent, left, right, changed); } id = ID(left); if (right == NULL) { xmlNode deleted = NULL; crm_trace("Processing <%s id=%s> (complete copy)", crm_element_name(left), id); deleted = add_node_copy(parent, left); crm_xml_add(deleted, XML_DIFF_MARKER, marker); changed = TRUE; return deleted; } name = crm_element_name(left); CRM_CHECK(name != NULL, return NULL); CRM_CHECK(safe_str_eq(crm_element_name(left), crm_element_name(right)), return NULL); /* check for XML_DIFF_MARKER in a child / value = crm_element_value(right, XML_DIFF_MARKER); if (value != NULL && strcmp(value, "removed:top") == 0) { crm_trace("We are the root of the deletion: %s.id=%s", name, id); changed = TRUE; return NULL; } /* Avoiding creating the full heirarchy would save even more work here / diff = create_xml_node(parent, name); / Reset filter / for (lpc = 0; lpc < filter_len; lpc++) { filter[lpc].found = FALSE; } / changes to child objects / for (left_child = __xml_first_child(left); left_child != NULL; left_child = __xml_next(left_child)) { gboolean child_changed = FALSE; if (left_child->type == XML_COMMENT_NODE) { right_child = find_xml_comment(right, left_child); } else { right_child = find_entity(right, crm_element_name(left_child), ID(left_child)); } subtract_xml_object(diff, left_child, right_child, full, &child_changed, marker); if (child_changed) { changed = TRUE; } } if (changed == FALSE) { / Nothing to do / } else if (full) { xmlAttrPtr pIter = NULL; for (pIter = crm_first_attr(left); pIter != NULL; pIter = pIter->next) { const char p_name = (const char )pIter->name; const char p_value = crm_attr_value(pIter); xmlSetProp(diff, (const xmlChar )p_name, (const xmlChar )p_value); } /* We already have everything we need... / goto done; } else if (id) { xmlSetProp(diff, (const xmlChar )XML_ATTR_ID, (const xmlChar )id); } / changes to name/value pairs / for (xIter = crm_first_attr(left); xIter != NULL; xIter = xIter->next) { const char prop_name = (const char )xIter->name; if (strcmp(prop_name, XML_ATTR_ID) == 0) { continue; } skip = FALSE; for (lpc = 0; skip == FALSE && lpc < filter_len; lpc++) { if (filter[lpc].found == FALSE && strcmp(prop_name, filter[lpc].string) == 0) { filter[lpc].found = TRUE; skip = TRUE; break; } } if (skip) { continue; } right_val = crm_element_value(right, prop_name); if (right_val == NULL) { / new / changed = TRUE; if (full) { xmlAttrPtr pIter = NULL; for (pIter = crm_first_attr(left); pIter != NULL; pIter = pIter->next) { const char p_name = (const char )pIter->name; const char p_value = crm_attr_value(pIter); xmlSetProp(diff, (const xmlChar )p_name, (const xmlChar )p_value); } break; } else { const char left_value = crm_element_value(left, prop_name); xmlSetProp(diff, (const xmlChar )prop_name, (const xmlChar )value); crm_xml_add(diff, prop_name, left_value); } } else { /* Only now do we need the left value / const char left_value = crm_element_value(left, prop_name); if (strcmp(left_value, right_val) == 0) { /* unchanged / } else { changed = TRUE; if (full) { xmlAttrPtr pIter = NULL; crm_trace("Changes detected to %s in <%s id=%s>", prop_name, crm_element_name(left), id); for (pIter = crm_first_attr(left); pIter != NULL; pIter = pIter->next) { const char p_name = (const char )pIter->name; const char p_value = crm_attr_value(pIter); xmlSetProp(diff, (const xmlChar )p_name, (const xmlChar )p_value); } break; } else { crm_trace("Changes detected to %s (%s -> %s) in <%s id=%s>", prop_name, left_value, right_val, crm_element_name(left), id); crm_xml_add(diff, prop_name, left_value); } } } } if (changed == FALSE) { free_xml(diff); return NULL; } else if (full == FALSE && id) { crm_xml_add(diff, XML_ATTR_ID, id); } done: return diff; } static int add_xml_comment(xmlNode * parent, xmlNode * target, xmlNode * update) { CRM_CHECK(update != NULL, return 0); CRM_CHECK(update->type == XML_COMMENT_NODE, return 0); if (target == NULL) { target = find_xml_comment(parent, update); } if (target == NULL) { add_node_copy(parent, update); /* We wont reach here currently / } else if (safe_str_neq((const char )target->content, (const char )update->content)) { xmlFree(target->content); target->content = xmlStrdup(update->content); } return 0; } int add_xml_object(xmlNode parent, xmlNode * target, xmlNode * update, gboolean as_diff) { xmlNode a_child = NULL; const char object_id = NULL; const char object_name = NULL; #if XML_PARSE_DEBUG crm_log_xml_trace("update:", update); crm_log_xml_trace("target:", target); #endif CRM_CHECK(update != NULL, return 0); if (update->type == XML_COMMENT_NODE) { return add_xml_comment(parent, target, update); } object_name = crm_element_name(update); object_id = ID(update); CRM_CHECK(object_name != NULL, return 0); if (target == NULL && object_id == NULL) { / placeholder object / target = find_xml_node(parent, object_name, FALSE); } else if (target == NULL) { target = find_entity(parent, object_name, object_id); } if (target == NULL) { target = create_xml_node(parent, object_name); CRM_CHECK(target != NULL, return 0); #if XML_PARSER_DEBUG crm_trace("Added <%s%s%s/>", crm_str(object_name), object_id ? " id=" : "", object_id ? object_id : ""); } else { crm_trace("Found node <%s%s%s/> to update", crm_str(object_name), object_id ? " id=" : "", object_id ? object_id : ""); #endif } CRM_CHECK(safe_str_eq(crm_element_name(target), crm_element_name(update)), return 0); if (as_diff == FALSE) { / So that expand_plus_plus() gets called / copy_in_properties(target, update); } else { / No need for expand_plus_plus(), just raw speed / xmlAttrPtr pIter = NULL; for (pIter = crm_first_attr(update); pIter != NULL; pIter = pIter->next) { const char p_name = (const char )pIter->name; const char p_value = crm_attr_value(pIter); /* Remove it first so the ordering of the update is preserved / xmlUnsetProp(target, (const xmlChar )p_name); xmlSetProp(target, (const xmlChar )p_name, (const xmlChar )p_value); } } for (a_child = __xml_first_child(update); a_child != NULL; a_child = __xml_next(a_child)) { #if XML_PARSER_DEBUG crm_trace("Updating child <%s id=%s>", crm_element_name(a_child), ID(a_child)); #endif add_xml_object(target, NULL, a_child, as_diff); } #if XML_PARSER_DEBUG crm_trace("Finished with <%s id=%s>", crm_str(object_name), crm_str(object_id)); #endif return 0; } gboolean update_xml_child(xmlNode * child, xmlNode * to_update) { gboolean can_update = TRUE; xmlNode child_of_child = NULL; CRM_CHECK(child != NULL, return FALSE); CRM_CHECK(to_update != NULL, return FALSE); if (safe_str_neq(crm_element_name(to_update), crm_element_name(child))) { can_update = FALSE; } else if (safe_str_neq(ID(to_update), ID(child))) { can_update = FALSE; } else if (can_update) { #if XML_PARSER_DEBUG crm_log_xml_trace(child, "Update match found..."); #endif add_xml_object(NULL, child, to_update, FALSE); } for (child_of_child = __xml_first_child(child); child_of_child != NULL; child_of_child = __xml_next(child_of_child)) { / only update the first one / if (can_update) { break; } can_update = update_xml_child(child_of_child, to_update); } return can_update; } int find_xml_children(xmlNode * children, xmlNode * root, const char tag, const char field, const char value, gboolean search_matches) { int match_found = 0; CRM_CHECK(root != NULL, return FALSE); CRM_CHECK(children != NULL, return FALSE); if (tag != NULL && safe_str_neq(tag, crm_element_name(root))) { } else if (value != NULL && safe_str_neq(value, crm_element_value(root, field))) { } else { if (children == NULL) { children = create_xml_node(NULL, __FUNCTION__); } add_node_copy(children, root); match_found = 1; } if (search_matches \|\| match_found == 0) { xmlNode child = NULL; for (child = __xml_first_child(root); child != NULL; child = __xml_next(child)) { match_found += find_xml_children(children, child, tag, field, value, search_matches); } } return match_found; } gboolean replace_xml_child(xmlNode parent, xmlNode * child, xmlNode * update, gboolean delete_only) { gboolean can_delete = FALSE; xmlNode child_of_child = NULL; const char up_id = NULL; const char child_id = NULL; const char right_val = NULL; CRM_CHECK(child != NULL, return FALSE); CRM_CHECK(update != NULL, return FALSE); up_id = ID(update); child_id = ID(child); if (up_id == NULL \|\| (child_id && strcmp(child_id, up_id) == 0)) { can_delete = TRUE; } if (safe_str_neq(crm_element_name(update), crm_element_name(child))) { can_delete = FALSE; } if (can_delete && delete_only) { xmlAttrPtr pIter = NULL; for (pIter = crm_first_attr(update); pIter != NULL; pIter = pIter->next) { const char p_name = (const char )pIter->name; const char p_value = crm_attr_value(pIter); right_val = crm_element_value(child, p_name); if (safe_str_neq(p_value, right_val)) { can_delete = FALSE; } } } if (can_delete && parent != NULL) { crm_log_xml_trace(child, "Delete match found..."); if (delete_only \|\| update == NULL) { free_xml(child); } else { xmlNode tmp = copy_xml(update); xmlDoc doc = tmp->doc; xmlNode old = NULL; xml_accept_changes(tmp); old = xmlReplaceNode(child, tmp); if(xml_tracking_changes(tmp)) { /* Replaced sections may have included relevant ACLs / __xml_acl_apply(tmp); } xml_calculate_changes(old, tmp); xmlDocSetRootElement(doc, old); free_xml(old); } child = NULL; return TRUE; } else if (can_delete) { crm_log_xml_debug(child, "Cannot delete the search root"); can_delete = FALSE; } child_of_child = __xml_first_child(child); while (child_of_child) { xmlNode next = __xml_next(child_of_child); can_delete = replace_xml_child(child, child_of_child, update, delete_only); /* only delete the first one / if (can_delete) { child_of_child = NULL; } else { child_of_child = next; } } return can_delete; } void hash2nvpair(gpointer key, gpointer value, gpointer user_data) { const char name = key; const char s_value = value; xmlNode xml_node = user_data; xmlNode xml_child = create_xml_node(xml_node, XML_CIB_TAG_NVPAIR); crm_xml_add(xml_child, XML_ATTR_ID, name); crm_xml_add(xml_child, XML_NVPAIR_ATTR_NAME, name); crm_xml_add(xml_child, XML_NVPAIR_ATTR_VALUE, s_value); crm_trace("dumped: name=%s value=%s", name, s_value); } void hash2smartfield(gpointer key, gpointer value, gpointer user_data) { const char name = key; const char s_value = value; xmlNode xml_node = user_data; if (isdigit(name[0])) { xmlNode tmp = create_xml_node(xml_node, XML_TAG_PARAM); crm_xml_add(tmp, XML_NVPAIR_ATTR_NAME, name); crm_xml_add(tmp, XML_NVPAIR_ATTR_VALUE, s_value); } else if (crm_element_value(xml_node, name) == NULL) { crm_xml_add(xml_node, name, s_value); crm_trace("dumped: %s=%s", name, s_value); } else { crm_trace("duplicate: %s=%s", name, s_value); } } void hash2field(gpointer key, gpointer value, gpointer user_data) { const char name = key; const char s_value = value; xmlNode xml_node = user_data; if (crm_element_value(xml_node, name) == NULL) { crm_xml_add(xml_node, name, s_value); } else { crm_trace("duplicate: %s=%s", name, s_value); } } void hash2metafield(gpointer key, gpointer value, gpointer user_data) { char crm_name = NULL; if (key == NULL \|\| value == NULL) { return; } else if (((char )key)[0] == '#') { return; } else if (strstr(key, ":")) { return; } crm_name = crm_meta_name(key); hash2field(crm_name, value, user_data); free(crm_name); } GHashTable * xml2list(xmlNode * parent) { xmlNode child = NULL; xmlAttrPtr pIter = NULL; xmlNode nvpair_list = NULL; GHashTable nvpair_hash = g_hash_table_new_full(crm_str_hash, g_str_equal, g_hash_destroy_str, g_hash_destroy_str); CRM_CHECK(parent != NULL, return nvpair_hash); nvpair_list = find_xml_node(parent, XML_TAG_ATTRS, FALSE); if (nvpair_list == NULL) { crm_trace("No attributes in %s", crm_element_name(parent)); crm_log_xml_trace(parent, "No attributes for resource op"); } crm_log_xml_trace(nvpair_list, "Unpacking"); for (pIter = crm_first_attr(nvpair_list); pIter != NULL; pIter = pIter->next) { const char p_name = (const char )pIter->name; const char p_value = crm_attr_value(pIter); crm_trace("Added %s=%s", p_name, p_value); g_hash_table_insert(nvpair_hash, strdup(p_name), strdup(p_value)); } for (child = __xml_first_child(nvpair_list); child != NULL; child = __xml_next(child)) { if (strcmp((const char )child->name, XML_TAG_PARAM) == 0) { const char key = crm_element_value(child, XML_NVPAIR_ATTR_NAME); const char value = crm_element_value(child, XML_NVPAIR_ATTR_VALUE); crm_trace("Added %s=%s", key, value); if (key != NULL && value != NULL) { g_hash_table_insert(nvpair_hash, strdup(key), strdup(value)); } } } return nvpair_hash; } typedef struct name_value_s { const char name; const void value; } name_value_t; static gint sort_pairs(gconstpointer a, gconstpointer b) { int rc = 0; const name_value_t pair_a = a; const name_value_t pair_b = b; CRM_ASSERT(a != NULL); CRM_ASSERT(pair_a->name != NULL); CRM_ASSERT(b != NULL); CRM_ASSERT(pair_b->name != NULL); rc = strcmp(pair_a->name, pair_b->name); if (rc < 0) { return -1; } else if (rc > 0) { return 1; } return 0; } static void dump_pair(gpointer data, gpointer user_data) { name_value_t pair = data; xmlNode parent = user_data; crm_xml_add(parent, pair->name, pair->value); } xmlNode sorted_xml(xmlNode * input, xmlNode * parent, gboolean recursive) { xmlNode child = NULL; GListPtr sorted = NULL; GListPtr unsorted = NULL; name_value_t pair = NULL; xmlNode result = NULL; const char name = NULL; xmlAttrPtr pIter = NULL; CRM_CHECK(input != NULL, return NULL); name = crm_element_name(input); CRM_CHECK(name != NULL, return NULL); result = create_xml_node(parent, name); for (pIter = crm_first_attr(input); pIter != NULL; pIter = pIter->next) { const char p_name = (const char )pIter->name; const char p_value = crm_attr_value(pIter); pair = calloc(1, sizeof(name_value_t)); pair->name = p_name; pair->value = p_value; unsorted = g_list_prepend(unsorted, pair); pair = NULL; } sorted = g_list_sort(unsorted, sort_pairs); g_list_foreach(sorted, dump_pair, result); g_list_free_full(sorted, free); for (child = __xml_first_child(input); child != NULL; child = __xml_next(child)) { if (recursive) { sorted_xml(child, result, recursive); } else { add_node_copy(result, child); } } return result; } static gboolean validate_with_dtd(xmlDocPtr doc, gboolean to_logs, const char dtd_file) { gboolean valid = TRUE; xmlDtdPtr dtd = NULL; xmlValidCtxtPtr cvp = NULL; CRM_CHECK(doc != NULL, return FALSE); CRM_CHECK(dtd_file != NULL, return FALSE); dtd = xmlParseDTD(NULL, (const xmlChar )dtd_file); if(dtd == NULL) { crm_err("Could not locate/parse DTD: %s", dtd_file); return TRUE; } cvp = xmlNewValidCtxt(); if(cvp) { if (to_logs) { cvp->userData = (void )LOG_ERR; cvp->error = (xmlValidityErrorFunc) xml_log; cvp->warning = (xmlValidityWarningFunc) xml_log; } else { cvp->userData = (void )stderr; cvp->error = (xmlValidityErrorFunc) fprintf; cvp->warning = (xmlValidityWarningFunc) fprintf; } if (!xmlValidateDtd(cvp, doc, dtd)) { valid = FALSE; } xmlFreeValidCtxt(cvp); } else { crm_err("Internal error: No valid context"); } xmlFreeDtd(dtd); return valid; } xmlNode first_named_child(xmlNode * parent, const char name) { xmlNode match = NULL; for (match = __xml_first_child(parent); match != NULL; match = __xml_next(match)) { /* * name == NULL gives first child regardless of name; this is * semantically incorrect in this funciton, but may be necessary * due to prior use of xml_child_iter_filter / if (name == NULL \|\| strcmp((const char )match->name, name) == 0) { return match; } } return NULL; } #if 0 static void relaxng_invalid_stderr(void userData, xmlErrorPtr error) { / Structure xmlError struct _xmlError { int domain : What part of the library raised this er int code : The error code, e.g. an xmlParserError char * message : human-readable informative error messag xmlErrorLevel level : how consequent is the error char * file : the filename int line : the line number if available char * str1 : extra string information char * str2 : extra string information char * str3 : extra string information int int1 : extra number information int int2 : column number of the error or 0 if N/A void * ctxt : the parser context if available void * node : the node in the tree } / crm_err("Structured error: line=%d, level=%d %s", error->line, error->level, error->message); } #endif static gboolean validate_with_relaxng(xmlDocPtr doc, gboolean to_logs, const char relaxng_file, relaxng_ctx_cache_t ** cached_ctx) { int rc = 0; gboolean valid = TRUE; relaxng_ctx_cache_t ctx = NULL; CRM_CHECK(doc != NULL, return FALSE); CRM_CHECK(relaxng_file != NULL, return FALSE); if (cached_ctx && cached_ctx) { ctx = cached_ctx; } else { crm_info("Creating RNG parser context"); ctx = calloc(1, sizeof(relaxng_ctx_cache_t)); xmlLoadExtDtdDefaultValue = 1; ctx->parser = xmlRelaxNGNewParserCtxt(relaxng_file); CRM_CHECK(ctx->parser != NULL, goto cleanup); if (to_logs) { xmlRelaxNGSetParserErrors(ctx->parser, (xmlRelaxNGValidityErrorFunc) xml_log, (xmlRelaxNGValidityWarningFunc) xml_log, GUINT_TO_POINTER(LOG_ERR)); } else { xmlRelaxNGSetParserErrors(ctx->parser, (xmlRelaxNGValidityErrorFunc) fprintf, (xmlRelaxNGValidityWarningFunc) fprintf, stderr); } ctx->rng = xmlRelaxNGParse(ctx->parser); CRM_CHECK(ctx->rng != NULL, crm_err("Could not find/parse %s", relaxng_file); goto cleanup); ctx->valid = xmlRelaxNGNewValidCtxt(ctx->rng); CRM_CHECK(ctx->valid != NULL, goto cleanup); if (to_logs) { xmlRelaxNGSetValidErrors(ctx->valid, (xmlRelaxNGValidityErrorFunc) xml_log, (xmlRelaxNGValidityWarningFunc) xml_log, GUINT_TO_POINTER(LOG_ERR)); } else { xmlRelaxNGSetValidErrors(ctx->valid, (xmlRelaxNGValidityErrorFunc) fprintf, (xmlRelaxNGValidityWarningFunc) fprintf, stderr); } } / xmlRelaxNGSetValidStructuredErrors( / / valid, relaxng_invalid_stderr, valid); / xmlLineNumbersDefault(1); rc = xmlRelaxNGValidateDoc(ctx->valid, doc); if (rc > 0) { valid = FALSE; } else if (rc < 0) { crm_err("Internal libxml error during validation\n"); } cleanup: if (cached_ctx) { cached_ctx = ctx; } else { if (ctx->parser != NULL) { xmlRelaxNGFreeParserCtxt(ctx->parser); } if (ctx->valid != NULL) { xmlRelaxNGFreeValidCtxt(ctx->valid); } if (ctx->rng != NULL) { xmlRelaxNGFree(ctx->rng); } free(ctx); } return valid; } void crm_xml_init(void) { static bool init = TRUE; if(init) { init = FALSE; /* The default allocator XML_BUFFER_ALLOC_EXACT does far too many * realloc_safe()s and it can take upwards of 18 seconds (yes, seconds) * to dump a 28kb tree which XML_BUFFER_ALLOC_DOUBLEIT can do in * less than 1 second. / xmlSetBufferAllocationScheme(XML_BUFFER_ALLOC_DOUBLEIT); / Populate and free the _private field when nodes are created and destroyed / xmlDeregisterNodeDefault(pcmkDeregisterNode); xmlRegisterNodeDefault(pcmkRegisterNode); __xml_build_schema_list(); } } void crm_xml_cleanup(void) { int lpc = 0; relaxng_ctx_cache_t ctx = NULL; crm_info("Cleaning up memory from libxml2"); for (; lpc < xml_schema_max; lpc++) { switch (known_schemas[lpc].type) { case 0: /* None / break; case 1: / DTD - Not cached / break; case 2: / RNG - Cached / ctx = (relaxng_ctx_cache_t ) known_schemas[lpc].cache; if (ctx == NULL) { break; } if (ctx->parser != NULL) { xmlRelaxNGFreeParserCtxt(ctx->parser); } if (ctx->valid != NULL) { xmlRelaxNGFreeValidCtxt(ctx->valid); } if (ctx->rng != NULL) { xmlRelaxNGFree(ctx->rng); } free(ctx); known_schemas[lpc].cache = NULL; break; default: break; } free(known_schemas[lpc].name); free(known_schemas[lpc].location); free(known_schemas[lpc].transform); } free(known_schemas); xsltCleanupGlobals(); xmlCleanupParser(); } static gboolean validate_with(xmlNode * xml, int method, gboolean to_logs) { xmlDocPtr doc = NULL; gboolean valid = FALSE; int type = 0; char file = NULL; if(method < 0) { return FALSE; } type = known_schemas[method].type; if(type == 0) { return TRUE; } CRM_CHECK(xml != NULL, return FALSE); doc = getDocPtr(xml); file = get_schema_path(known_schemas[method].name, known_schemas[method].location); crm_trace("Validating with: %s (type=%d)", crm_str(file), type); switch (type) { case 1: valid = validate_with_dtd(doc, to_logs, file); break; case 2: valid = validate_with_relaxng(doc, to_logs, file, (relaxng_ctx_cache_t ) & (known_schemas[method].cache)); break; default: crm_err("Unknown validator type: %d", type); break; } free(file); return valid; } #include <stdio.h> static void dump_file(const char filename) { FILE fp = NULL; int ch, line = 0; CRM_CHECK(filename != NULL, return); fp = fopen(filename, "r"); CRM_CHECK(fp != NULL, return); fprintf(stderr, "%4d ", ++line); do { ch = getc(fp); if (ch == EOF) { putc('\n', stderr); break; } else if (ch == '\n') { fprintf(stderr, "\n%4d ", ++line); } else { putc(ch, stderr); } } while (1); fclose(fp); } gboolean validate_xml_verbose(xmlNode xml_blob) { int fd = 0; xmlDoc doc = NULL; xmlNode xml = NULL; gboolean rc = FALSE; char filename = strdup(CRM_STATE_DIR "/cib-invalid.XXXXXX"); umask(S_IWGRP \| S_IWOTH \| S_IROTH); fd = mkstemp(filename); write_xml_fd(xml_blob, filename, fd, FALSE); dump_file(filename); doc = xmlParseFile(filename); xml = xmlDocGetRootElement(doc); rc = validate_xml(xml, NULL, FALSE); free_xml(xml); unlink(filename); free(filename); return rc; } gboolean validate_xml(xmlNode xml_blob, const char validation, gboolean to_logs) { int version = 0; if (validation == NULL) { validation = crm_element_value(xml_blob, XML_ATTR_VALIDATION); } if (validation == NULL) { int lpc = 0; bool valid = FALSE; validation = crm_element_value(xml_blob, "ignore-dtd"); if (crm_is_true(validation)) { / Legacy compatibilty / crm_xml_add(xml_blob, XML_ATTR_VALIDATION, "none"); return TRUE; } / Work it out / for (lpc = 0; lpc < xml_schema_max; lpc++) { if(validate_with(xml_blob, lpc, FALSE)) { valid = TRUE; crm_xml_add(xml_blob, XML_ATTR_VALIDATION, known_schemas[lpc].name); crm_info("XML validated against %s", known_schemas[lpc].name); if(known_schemas[lpc].after_transform == 0) { break; } } } return valid; } version = get_schema_version(validation); if (strcmp(validation, "none") == 0) { return TRUE; } else if(version < xml_schema_max) { return validate_with(xml_blob, version, to_logs); } crm_err("Unknown validator: %s", validation); return FALSE; } #if HAVE_LIBXSLT static xmlNode apply_transformation(xmlNode * xml, const char transform) { char xform = NULL; xmlNode out = NULL; xmlDocPtr res = NULL; xmlDocPtr doc = NULL; xsltStylesheet xslt = NULL; CRM_CHECK(xml != NULL, return FALSE); doc = getDocPtr(xml); xform = get_schema_path(NULL, transform); xmlLoadExtDtdDefaultValue = 1; xmlSubstituteEntitiesDefault(1); xslt = xsltParseStylesheetFile((const xmlChar )xform); CRM_CHECK(xslt != NULL, goto cleanup); res = xsltApplyStylesheet(xslt, doc, NULL); CRM_CHECK(res != NULL, goto cleanup); out = xmlDocGetRootElement(res); cleanup: if (xslt) { xsltFreeStylesheet(xslt); } free(xform); return out; } #endif const char get_schema_name(int version) { if (version < 0 \|\| version >= xml_schema_max) { return "unknown"; } return known_schemas[version].name; } int get_schema_version(const char name) { int lpc = 0; if(name == NULL) { name = "none"; } for (; lpc < xml_schema_max; lpc++) { if (safe_str_eq(name, known_schemas[lpc].name)) { return lpc; } } return -1; } / set which validation to use / #include <crm/cib.h> int update_validation(xmlNode * xml_blob, int best, int max, gboolean transform, gboolean to_logs) { xmlNode xml = NULL; char value = NULL; int max_stable_schemas = xml_latest_schema_index(); int lpc = 0, match = -1, rc = pcmk_ok; CRM_CHECK(best != NULL, return -EINVAL); CRM_CHECK(xml_blob != NULL, return -EINVAL); CRM_CHECK(xml_blob != NULL, return -EINVAL); best = 0; xml = xml_blob; value = crm_element_value_copy(xml, XML_ATTR_VALIDATION); if (value != NULL) { match = get_schema_version(value); lpc = match; if (lpc >= 0 && transform == FALSE) { lpc++; } else if (lpc < 0) { crm_debug("Unknown validation type"); lpc = 0; } } if (match >= max_stable_schemas) { /* nothing to do / free(value); best = match; return pcmk_ok; } while(lpc <= max_stable_schemas) { gboolean valid = TRUE; crm_debug("Testing '%s' validation (%d of %d)", known_schemas[lpc].name ? known_schemas[lpc].name : "<unset>", lpc, max_stable_schemas); valid = validate_with(xml, lpc, to_logs); if (valid) { best = lpc; } else { crm_trace("%s validation failed", known_schemas[lpc].name ? known_schemas[lpc].name : "<unset>"); } if (valid && transform) { xmlNode upgrade = NULL; int next = known_schemas[lpc].after_transform; if (next < 0) { crm_trace("Stopping at %s", known_schemas[lpc].name); break; } else if (max > 0 && lpc == max) { crm_trace("Upgrade limit reached at %s (lpc=%d, next=%d, max=%d)", known_schemas[lpc].name, lpc, next, max); break; } else if (max > 0 && next > max) { crm_debug("Upgrade limit reached at %s (lpc=%d, next=%d, max=%d)", known_schemas[lpc].name, lpc, next, max); break; } else if (known_schemas[lpc].transform == NULL) { crm_notice("%s-style configuration is also valid for %s", known_schemas[lpc].name, known_schemas[next].name); if (validate_with(xml, next, to_logs)) { crm_debug("Configuration valid for schema: %s", known_schemas[next].name); lpc = next; best = next; rc = pcmk_ok; } else { crm_info("Configuration not valid for schema: %s", known_schemas[next].name); } } else { crm_debug("Upgrading %s-style configuration to %s with %s", known_schemas[lpc].name, known_schemas[next].name, known_schemas[lpc].transform ? known_schemas[lpc].transform : "no-op"); #if HAVE_LIBXSLT upgrade = apply_transformation(xml, known_schemas[lpc].transform); #endif if (upgrade == NULL) { crm_err("Transformation %s failed", known_schemas[lpc].transform); rc = -pcmk_err_transform_failed; } else if (validate_with(upgrade, next, to_logs)) { crm_info("Transformation %s successful", known_schemas[lpc].transform); lpc = next; best = next; free_xml(xml); xml = upgrade; rc = pcmk_ok; } else { crm_err("Transformation %s did not produce a valid configuration", known_schemas[lpc].transform); crm_log_xml_info(upgrade, "transform:bad"); free_xml(upgrade); rc = -pcmk_err_schema_validation; } } } } if (best > match) { crm_info("%s the configuration from %s to %s", transform?"Transformed":"Upgraded", value ? value : "<none>", known_schemas[best].name); crm_xml_add(xml, XML_ATTR_VALIDATION, known_schemas[best].name); } xml_blob = xml; free(value); return rc; } /* * From xpath2.c * * All the elements returned by an XPath query are pointers to * elements from the tree except namespace nodes where the XPath * semantic is different from the implementation in libxml2 tree. * As a result when a returned node set is freed when * xmlXPathFreeObject() is called, that routine must check the * element type. But node from the returned set may have been removed * by xmlNodeSetContent() resulting in access to freed data. * * This can be exercised by running * valgrind xpath2 test3.xml '//discarded' discarded * * There is 2 ways around it: * - make a copy of the pointers to the nodes from the result set * then call xmlXPathFreeObject() and then modify the nodes * or * - remove the references from the node set, if they are not namespace nodes, before calling xmlXPathFreeObject(). / void freeXpathObject(xmlXPathObjectPtr xpathObj) { int lpc, max = numXpathResults(xpathObj); if(xpathObj == NULL) { return; } for(lpc = 0; lpc < max; lpc++) { if (xpathObj->nodesetval->nodeTab[lpc] && xpathObj->nodesetval->nodeTab[lpc]->type != XML_NAMESPACE_DECL) { xpathObj->nodesetval->nodeTab[lpc] = NULL; } } / _Now_ its safe to free it / xmlXPathFreeObject(xpathObj); } xmlNode getXpathResult(xmlXPathObjectPtr xpathObj, int index) { xmlNode match = NULL; int max = numXpathResults(xpathObj); CRM_CHECK(index >= 0, return NULL); CRM_CHECK(xpathObj != NULL, return NULL); if (index >= max) { crm_err("Requested index %d of only %d items", index, max); return NULL; } else if(xpathObj->nodesetval->nodeTab[index] == NULL) { / Previously requested / return NULL; } match = xpathObj->nodesetval->nodeTab[index]; CRM_CHECK(match != NULL, return NULL); if (xpathObj->nodesetval->nodeTab[index]->type != XML_NAMESPACE_DECL) { / See the comment for freeXpathObject() / xpathObj->nodesetval->nodeTab[index] = NULL; } if (match->type == XML_DOCUMENT_NODE) { / Will happen if section = '/' / match = match->children; } else if (match->type != XML_ELEMENT_NODE && match->parent && match->parent->type == XML_ELEMENT_NODE) { / reurning the parent instead / match = match->parent; } else if (match->type != XML_ELEMENT_NODE) { / We only support searching nodes / crm_err("We only support %d not %d", XML_ELEMENT_NODE, match->type); match = NULL; } return match; } / the caller needs to check if the result contains a xmlDocPtr or xmlNodePtr / xmlXPathObjectPtr xpath_search(xmlNode xml_top, const char path) { xmlDocPtr doc = NULL; xmlXPathObjectPtr xpathObj = NULL; xmlXPathContextPtr xpathCtx = NULL; const xmlChar xpathExpr = (const xmlChar )path; CRM_CHECK(path != NULL, return NULL); CRM_CHECK(xml_top != NULL, return NULL); CRM_CHECK(strlen(path) > 0, return NULL); doc = getDocPtr(xml_top); xpathCtx = xmlXPathNewContext(doc); CRM_ASSERT(xpathCtx != NULL); xpathObj = xmlXPathEvalExpression(xpathExpr, xpathCtx); xmlXPathFreeContext(xpathCtx); return xpathObj; } gboolean cli_config_update(xmlNode * xml, int best_version, gboolean to_logs) { gboolean rc = TRUE; const char value = crm_element_value(xml, XML_ATTR_VALIDATION); int version = get_schema_version(value); int min_version = xml_minimum_schema_index(); if (version < min_version) { xmlNode converted = NULL; converted = copy_xml(xml); update_validation(&converted, &version, 0, TRUE, to_logs); value = crm_element_value(converted, XML_ATTR_VALIDATION); if (version < min_version) { if (to_logs) { crm_config_err("Your current configuration could only be upgraded to %s... " "the minimum requirement is %s.\n", crm_str(value), get_schema_name(min_version)); } else { fprintf(stderr, "Your current configuration could only be upgraded to %s... " "the minimum requirement is %s.\n", crm_str(value), get_schema_name(min_version)); } free_xml(converted); converted = NULL; rc = FALSE; } else { free_xml(xml); xml = converted; if (version < xml_latest_schema_index()) { crm_config_warn("Your configuration was internally updated to %s... " "which is acceptable but not the most recent", get_schema_name(version)); } else if (to_logs) { crm_info("Your configuration was internally updated to the latest version (%s)", get_schema_name(version)); } } } else if (version >= get_schema_version("none")) { if (to_logs) { crm_config_warn("Configuration validation is currently disabled." " It is highly encouraged and prevents many common cluster issues."); } else { fprintf(stderr, "Configuration validation is currently disabled." " It is highly encouraged and prevents many common cluster issues.\n"); } } if (best_version) { best_version = version; } return rc; } xmlNode * expand_idref(xmlNode * input, xmlNode * top) { const char tag = NULL; const char ref = NULL; xmlNode result = input; char xpath_string = NULL; if (result == NULL) { return NULL; } else if (top == NULL) { top = input; } tag = crm_element_name(result); ref = crm_element_value(result, XML_ATTR_IDREF); if (ref != NULL) { int xpath_max = 512, offset = 0; xpath_string = calloc(1, xpath_max); offset += snprintf(xpath_string + offset, xpath_max - offset, "//%s[@id='%s']", tag, ref); CRM_LOG_ASSERT(offset > 0); result = get_xpath_object(xpath_string, top, LOG_ERR); if (result == NULL) { char nodePath = (char )xmlGetNodePath(top); crm_err("No match for %s found in %s: Invalid configuration", xpath_string, crm_str(nodePath)); free(nodePath); } } free(xpath_string); return result; } xmlNode * get_xpath_object_relative(const char xpath, xmlNode xml_obj, int error_level) { int len = 0; xmlNode result = NULL; char xpath_full = NULL; char xpath_prefix = NULL; if (xml_obj == NULL \|\| xpath == NULL) { return NULL; } xpath_prefix = (char )xmlGetNodePath(xml_obj); len += strlen(xpath_prefix); len += strlen(xpath); xpath_full = strdup(xpath_prefix); xpath_full = realloc_safe(xpath_full, len + 1); strncat(xpath_full, xpath, len); result = get_xpath_object(xpath_full, xml_obj, error_level); free(xpath_prefix); free(xpath_full); return result; } xmlNode * get_xpath_object(const char xpath, xmlNode xml_obj, int error_level) { int max; xmlNode result = NULL; xmlXPathObjectPtr xpathObj = NULL; char nodePath = NULL; char matchNodePath = NULL; if (xpath == NULL) { return xml_obj; / or return NULL? / } xpathObj = xpath_search(xml_obj, xpath); nodePath = (char )xmlGetNodePath(xml_obj); max = numXpathResults(xpathObj); if (max < 1) { do_crm_log(error_level, "No match for %s in %s", xpath, crm_str(nodePath)); crm_log_xml_explicit(xml_obj, "Unexpected Input"); } else if (max > 1) { int lpc = 0; do_crm_log(error_level, "Too many matches for %s in %s", xpath, crm_str(nodePath)); for (lpc = 0; lpc < max; lpc++) { xmlNode match = getXpathResult(xpathObj, lpc); CRM_LOG_ASSERT(match != NULL); if(match != NULL) { matchNodePath = (char )xmlGetNodePath(match); do_crm_log(error_level, "%s[%d] = %s", xpath, lpc, crm_str(matchNodePath)); free(matchNodePath); } } crm_log_xml_explicit(xml_obj, "Bad Input"); } else { result = getXpathResult(xpathObj, 0); } freeXpathObject(xpathObj); free(nodePath); return result; } const char * crm_element_value(xmlNode * data, const char name) { xmlAttr attr = NULL; if (data == NULL) { crm_err("Couldn't find %s in NULL", name ? name : "<null>"); CRM_LOG_ASSERT(data != NULL); return NULL; } else if (name == NULL) { crm_err("Couldn't find NULL in %s", crm_element_name(data)); return NULL; } attr = xmlHasProp(data, (const xmlChar )name); if (attr == NULL \|\| attr->children == NULL) { return NULL; } return (const char )attr->children->content; }	./CrossVul/dataset_final_sorted/CWE-264/c/good_1504_0
crossvul-cpp_data_good_5018_1	/* * acpi_osl.c - OS-dependent functions ($Revision: 83 $) * * Copyright (C) 2000 Andrew Henroid * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com> * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com> * Copyright (c) 2008 Intel Corporation * Author: Matthew Wilcox <willy@linux.intel.com> * * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ * / #include <linux/module.h> #include <linux/kernel.h> #include <linux/slab.h> #include <linux/mm.h> #include <linux/highmem.h> #include <linux/pci.h> #include <linux/interrupt.h> #include <linux/kmod.h> #include <linux/delay.h> #include <linux/workqueue.h> #include <linux/nmi.h> #include <linux/acpi.h> #include <linux/efi.h> #include <linux/ioport.h> #include <linux/list.h> #include <linux/jiffies.h> #include <linux/semaphore.h> #include <linux/security.h> #include <asm/io.h> #include <asm/uaccess.h> #include <linux/io-64-nonatomic-lo-hi.h> #include "internal.h" #define _COMPONENT ACPI_OS_SERVICES ACPI_MODULE_NAME("osl"); struct acpi_os_dpc { acpi_osd_exec_callback function; void context; struct work_struct work; }; #ifdef CONFIG_ACPI_CUSTOM_DSDT #include CONFIG_ACPI_CUSTOM_DSDT_FILE #endif #ifdef ENABLE_DEBUGGER #include <linux/kdb.h> /* stuff for debugger support / int acpi_in_debugger; EXPORT_SYMBOL(acpi_in_debugger); #endif /ENABLE_DEBUGGER / static int (__acpi_os_prepare_sleep)(u8 sleep_state, u32 pm1a_ctrl, u32 pm1b_ctrl); static int (__acpi_os_prepare_extended_sleep)(u8 sleep_state, u32 val_a, u32 val_b); static acpi_osd_handler acpi_irq_handler; static void acpi_irq_context; static struct workqueue_struct kacpid_wq; static struct workqueue_struct kacpi_notify_wq; static struct workqueue_struct kacpi_hotplug_wq; static bool acpi_os_initialized; unsigned int acpi_sci_irq = INVALID_ACPI_IRQ; / * This list of permanent mappings is for memory that may be accessed from * interrupt context, where we can't do the ioremap(). / struct acpi_ioremap { struct list_head list; void __iomem virt; acpi_physical_address phys; acpi_size size; unsigned long refcount; }; static LIST_HEAD(acpi_ioremaps); static DEFINE_MUTEX(acpi_ioremap_lock); static void __init acpi_osi_setup_late(void); /* * The story of _OSI(Linux) * * From pre-history through Linux-2.6.22, * Linux responded TRUE upon a BIOS OSI(Linux) query. * * Unfortunately, reference BIOS writers got wind of this * and put OSI(Linux) in their example code, quickly exposing * this string as ill-conceived and opening the door to * an un-bounded number of BIOS incompatibilities. * * For example, OSI(Linux) was used on resume to re-POST a * video card on one system, because Linux at that time * could not do a speedy restore in its native driver. * But then upon gaining quick native restore capability, * Linux has no way to tell the BIOS to skip the time-consuming * POST -- putting Linux at a permanent performance disadvantage. * On another system, the BIOS writer used OSI(Linux) * to infer native OS support for IPMI! On other systems, * OSI(Linux) simply got in the way of Linux claiming to * be compatible with other operating systems, exposing * BIOS issues such as skipped device initialization. * * So "Linux" turned out to be a really poor chose of * OSI string, and from Linux-2.6.23 onward we respond FALSE. * * BIOS writers should NOT query _OSI(Linux) on future systems. * Linux will complain on the console when it sees it, and return FALSE. * To get Linux to return TRUE for your system will require * a kernel source update to add a DMI entry, * or boot with "acpi_osi=Linux" / static struct osi_linux { unsigned int enable:1; unsigned int dmi:1; unsigned int cmdline:1; unsigned int default_disabling:1; } osi_linux = {0, 0, 0, 0}; static u32 acpi_osi_handler(acpi_string interface, u32 supported) { if (!strcmp("Linux", interface)) { printk_once(KERN_NOTICE FW_BUG PREFIX "BIOS _OSI(Linux) query %s%s\n", osi_linux.enable ? "honored" : "ignored", osi_linux.cmdline ? " via cmdline" : osi_linux.dmi ? " via DMI" : ""); } if (!strcmp("Darwin", interface)) { / * Apple firmware will behave poorly if it receives positive * answers to "Darwin" and any other OS. Respond positively * to Darwin and then disable all other vendor strings. / acpi_update_interfaces(ACPI_DISABLE_ALL_VENDOR_STRINGS); supported = ACPI_UINT32_MAX; } return supported; } static void __init acpi_request_region (struct acpi_generic_address gas, unsigned int length, char desc) { u64 addr; / Handle possible alignment issues / memcpy(&addr, &gas->address, sizeof(addr)); if (!addr \|\| !length) return; / Resources are never freed / if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_IO) request_region(addr, length, desc); else if (gas->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY) request_mem_region(addr, length, desc); } static int __init acpi_reserve_resources(void) { acpi_request_region(&acpi_gbl_FADT.xpm1a_event_block, acpi_gbl_FADT.pm1_event_length, "ACPI PM1a_EVT_BLK"); acpi_request_region(&acpi_gbl_FADT.xpm1b_event_block, acpi_gbl_FADT.pm1_event_length, "ACPI PM1b_EVT_BLK"); acpi_request_region(&acpi_gbl_FADT.xpm1a_control_block, acpi_gbl_FADT.pm1_control_length, "ACPI PM1a_CNT_BLK"); acpi_request_region(&acpi_gbl_FADT.xpm1b_control_block, acpi_gbl_FADT.pm1_control_length, "ACPI PM1b_CNT_BLK"); if (acpi_gbl_FADT.pm_timer_length == 4) acpi_request_region(&acpi_gbl_FADT.xpm_timer_block, 4, "ACPI PM_TMR"); acpi_request_region(&acpi_gbl_FADT.xpm2_control_block, acpi_gbl_FADT.pm2_control_length, "ACPI PM2_CNT_BLK"); / Length of GPE blocks must be a non-negative multiple of 2 / if (!(acpi_gbl_FADT.gpe0_block_length & 0x1)) acpi_request_region(&acpi_gbl_FADT.xgpe0_block, acpi_gbl_FADT.gpe0_block_length, "ACPI GPE0_BLK"); if (!(acpi_gbl_FADT.gpe1_block_length & 0x1)) acpi_request_region(&acpi_gbl_FADT.xgpe1_block, acpi_gbl_FADT.gpe1_block_length, "ACPI GPE1_BLK"); return 0; } fs_initcall_sync(acpi_reserve_resources); void acpi_os_printf(const char fmt, ...) { va_list args; va_start(args, fmt); acpi_os_vprintf(fmt, args); va_end(args); } EXPORT_SYMBOL(acpi_os_printf); void acpi_os_vprintf(const char fmt, va_list args) { static char buffer[512]; vsprintf(buffer, fmt, args); #ifdef ENABLE_DEBUGGER if (acpi_in_debugger) { kdb_printf("%s", buffer); } else { printk(KERN_CONT "%s", buffer); } #else if (acpi_debugger_write_log(buffer) < 0) printk(KERN_CONT "%s", buffer); #endif } #ifdef CONFIG_KEXEC static unsigned long acpi_rsdp; static int __init setup_acpi_rsdp(char arg) { if (kstrtoul(arg, 16, &acpi_rsdp)) return -EINVAL; return 0; } early_param("acpi_rsdp", setup_acpi_rsdp); #endif acpi_physical_address __init acpi_os_get_root_pointer(void) { #ifdef CONFIG_KEXEC if (acpi_rsdp && (get_securelevel() <= 0)) return acpi_rsdp; #endif if (efi_enabled(EFI_CONFIG_TABLES)) { if (efi.acpi20 != EFI_INVALID_TABLE_ADDR) return efi.acpi20; else if (efi.acpi != EFI_INVALID_TABLE_ADDR) return efi.acpi; else { printk(KERN_ERR PREFIX "System description tables not found\n"); return 0; } } else if (IS_ENABLED(CONFIG_ACPI_LEGACY_TABLES_LOOKUP)) { acpi_physical_address pa = 0; acpi_find_root_pointer(&pa); return pa; } return 0; } /* Must be called with 'acpi_ioremap_lock' or RCU read lock held. / static struct acpi_ioremap acpi_map_lookup(acpi_physical_address phys, acpi_size size) { struct acpi_ioremap map; list_for_each_entry_rcu(map, &acpi_ioremaps, list) if (map->phys <= phys && phys + size <= map->phys + map->size) return map; return NULL; } / Must be called with 'acpi_ioremap_lock' or RCU read lock held. / static void __iomem acpi_map_vaddr_lookup(acpi_physical_address phys, unsigned int size) { struct acpi_ioremap map; map = acpi_map_lookup(phys, size); if (map) return map->virt + (phys - map->phys); return NULL; } void __iomem acpi_os_get_iomem(acpi_physical_address phys, unsigned int size) { struct acpi_ioremap map; void __iomem virt = NULL; mutex_lock(&acpi_ioremap_lock); map = acpi_map_lookup(phys, size); if (map) { virt = map->virt + (phys - map->phys); map->refcount++; } mutex_unlock(&acpi_ioremap_lock); return virt; } EXPORT_SYMBOL_GPL(acpi_os_get_iomem); /* Must be called with 'acpi_ioremap_lock' or RCU read lock held. / static struct acpi_ioremap acpi_map_lookup_virt(void __iomem virt, acpi_size size) { struct acpi_ioremap map; list_for_each_entry_rcu(map, &acpi_ioremaps, list) if (map->virt <= virt && virt + size <= map->virt + map->size) return map; return NULL; } #if defined(CONFIG_IA64) \|\| defined(CONFIG_ARM64) /* ioremap will take care of cache attributes / #define should_use_kmap(pfn) 0 #else #define should_use_kmap(pfn) page_is_ram(pfn) #endif static void __iomem acpi_map(acpi_physical_address pg_off, unsigned long pg_sz) { unsigned long pfn; pfn = pg_off >> PAGE_SHIFT; if (should_use_kmap(pfn)) { if (pg_sz > PAGE_SIZE) return NULL; return (void __iomem __force )kmap(pfn_to_page(pfn)); } else return acpi_os_ioremap(pg_off, pg_sz); } static void acpi_unmap(acpi_physical_address pg_off, void __iomem vaddr) { unsigned long pfn; pfn = pg_off >> PAGE_SHIFT; if (should_use_kmap(pfn)) kunmap(pfn_to_page(pfn)); else iounmap(vaddr); } /** * acpi_os_map_iomem - Get a virtual address for a given physical address range. * @phys: Start of the physical address range to map. * @size: Size of the physical address range to map. * * Look up the given physical address range in the list of existing ACPI memory * mappings. If found, get a reference to it and return a pointer to it (its * virtual address). If not found, map it, add it to that list and return a * pointer to it. * * During early init (when acpi_gbl_permanent_mmap has not been set yet) this * routine simply calls __acpi_map_table() to get the job done. / void __iomem __init_refok acpi_os_map_iomem(acpi_physical_address phys, acpi_size size) { struct acpi_ioremap map; void __iomem virt; acpi_physical_address pg_off; acpi_size pg_sz; if (phys > ULONG_MAX) { printk(KERN_ERR PREFIX "Cannot map memory that high\n"); return NULL; } if (!acpi_gbl_permanent_mmap) return __acpi_map_table((unsigned long)phys, size); mutex_lock(&acpi_ioremap_lock); /* Check if there's a suitable mapping already. / map = acpi_map_lookup(phys, size); if (map) { map->refcount++; goto out; } map = kzalloc(sizeof(map), GFP_KERNEL); if (!map) { mutex_unlock(&acpi_ioremap_lock); return NULL; } pg_off = round_down(phys, PAGE_SIZE); pg_sz = round_up(phys + size, PAGE_SIZE) - pg_off; virt = acpi_map(pg_off, pg_sz); if (!virt) { mutex_unlock(&acpi_ioremap_lock); kfree(map); return NULL; } INIT_LIST_HEAD(&map->list); map->virt = virt; map->phys = pg_off; map->size = pg_sz; map->refcount = 1; list_add_tail_rcu(&map->list, &acpi_ioremaps); out: mutex_unlock(&acpi_ioremap_lock); return map->virt + (phys - map->phys); } EXPORT_SYMBOL_GPL(acpi_os_map_iomem); void __init_refok acpi_os_map_memory(acpi_physical_address phys, acpi_size size) { return (void )acpi_os_map_iomem(phys, size); } EXPORT_SYMBOL_GPL(acpi_os_map_memory); static void acpi_os_drop_map_ref(struct acpi_ioremap map) { if (!--map->refcount) list_del_rcu(&map->list); } static void acpi_os_map_cleanup(struct acpi_ioremap map) { if (!map->refcount) { synchronize_rcu_expedited(); acpi_unmap(map->phys, map->virt); kfree(map); } } /** * acpi_os_unmap_iomem - Drop a memory mapping reference. * @virt: Start of the address range to drop a reference to. * @size: Size of the address range to drop a reference to. * * Look up the given virtual address range in the list of existing ACPI memory * mappings, drop a reference to it and unmap it if there are no more active * references to it. * * During early init (when acpi_gbl_permanent_mmap has not been set yet) this * routine simply calls __acpi_unmap_table() to get the job done. Since * __acpi_unmap_table() is an __init function, the __ref annotation is needed * here. / void __ref acpi_os_unmap_iomem(void __iomem virt, acpi_size size) { struct acpi_ioremap map; if (!acpi_gbl_permanent_mmap) { __acpi_unmap_table(virt, size); return; } mutex_lock(&acpi_ioremap_lock); map = acpi_map_lookup_virt(virt, size); if (!map) { mutex_unlock(&acpi_ioremap_lock); WARN(true, PREFIX "%s: bad address %p\n", __func__, virt); return; } acpi_os_drop_map_ref(map); mutex_unlock(&acpi_ioremap_lock); acpi_os_map_cleanup(map); } EXPORT_SYMBOL_GPL(acpi_os_unmap_iomem); void __ref acpi_os_unmap_memory(void virt, acpi_size size) { return acpi_os_unmap_iomem((void __iomem )virt, size); } EXPORT_SYMBOL_GPL(acpi_os_unmap_memory); void __init early_acpi_os_unmap_memory(void __iomem virt, acpi_size size) { if (!acpi_gbl_permanent_mmap) __acpi_unmap_table(virt, size); } int acpi_os_map_generic_address(struct acpi_generic_address gas) { u64 addr; void __iomem virt; if (gas->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY) return 0; /* Handle possible alignment issues / memcpy(&addr, &gas->address, sizeof(addr)); if (!addr \|\| !gas->bit_width) return -EINVAL; virt = acpi_os_map_iomem(addr, gas->bit_width / 8); if (!virt) return -EIO; return 0; } EXPORT_SYMBOL(acpi_os_map_generic_address); void acpi_os_unmap_generic_address(struct acpi_generic_address gas) { u64 addr; struct acpi_ioremap map; if (gas->space_id != ACPI_ADR_SPACE_SYSTEM_MEMORY) return; / Handle possible alignment issues / memcpy(&addr, &gas->address, sizeof(addr)); if (!addr \|\| !gas->bit_width) return; mutex_lock(&acpi_ioremap_lock); map = acpi_map_lookup(addr, gas->bit_width / 8); if (!map) { mutex_unlock(&acpi_ioremap_lock); return; } acpi_os_drop_map_ref(map); mutex_unlock(&acpi_ioremap_lock); acpi_os_map_cleanup(map); } EXPORT_SYMBOL(acpi_os_unmap_generic_address); #ifdef ACPI_FUTURE_USAGE acpi_status acpi_os_get_physical_address(void virt, acpi_physical_address * phys) { if (!phys \|\| !virt) return AE_BAD_PARAMETER; phys = virt_to_phys(virt); return AE_OK; } #endif #ifdef CONFIG_ACPI_REV_OVERRIDE_POSSIBLE static bool acpi_rev_override; int __init acpi_rev_override_setup(char str) { acpi_rev_override = true; return 1; } __setup("acpi_rev_override", acpi_rev_override_setup); #else #define acpi_rev_override false #endif #define ACPI_MAX_OVERRIDE_LEN 100 static char acpi_os_name[ACPI_MAX_OVERRIDE_LEN]; acpi_status acpi_os_predefined_override(const struct acpi_predefined_names init_val, char new_val) { if (!init_val \|\| !new_val) return AE_BAD_PARAMETER; new_val = NULL; if (!memcmp(init_val->name, "_OS_", 4) && strlen(acpi_os_name)) { printk(KERN_INFO PREFIX "Overriding _OS definition to '%s'\n", acpi_os_name); new_val = acpi_os_name; } if (!memcmp(init_val->name, "_REV", 4) && acpi_rev_override) { printk(KERN_INFO PREFIX "Overriding _REV return value to 5\n"); new_val = (char )5; } return AE_OK; } static void acpi_table_taint(struct acpi_table_header table) { pr_warn(PREFIX "Override [%4.4s-%8.8s], this is unsafe: tainting kernel\n", table->signature, table->oem_table_id); add_taint(TAINT_OVERRIDDEN_ACPI_TABLE, LOCKDEP_NOW_UNRELIABLE); } #ifdef CONFIG_ACPI_INITRD_TABLE_OVERRIDE #include <linux/earlycpio.h> #include <linux/memblock.h> static u64 acpi_tables_addr; static int all_tables_size; /* Copied from acpica/tbutils.c:acpi_tb_checksum() / static u8 __init acpi_table_checksum(u8 buffer, u32 length) { u8 sum = 0; u8 end = buffer + length; while (buffer < end) sum = (u8) (sum + (buffer++)); return sum; } /* All but ACPI_SIG_RSDP and ACPI_SIG_FACS: / static const char const table_sigs[] = { ACPI_SIG_BERT, ACPI_SIG_CPEP, ACPI_SIG_ECDT, ACPI_SIG_EINJ, ACPI_SIG_ERST, ACPI_SIG_HEST, ACPI_SIG_MADT, ACPI_SIG_MSCT, ACPI_SIG_SBST, ACPI_SIG_SLIT, ACPI_SIG_SRAT, ACPI_SIG_ASF, ACPI_SIG_BOOT, ACPI_SIG_DBGP, ACPI_SIG_DMAR, ACPI_SIG_HPET, ACPI_SIG_IBFT, ACPI_SIG_IVRS, ACPI_SIG_MCFG, ACPI_SIG_MCHI, ACPI_SIG_SLIC, ACPI_SIG_SPCR, ACPI_SIG_SPMI, ACPI_SIG_TCPA, ACPI_SIG_UEFI, ACPI_SIG_WAET, ACPI_SIG_WDAT, ACPI_SIG_WDDT, ACPI_SIG_WDRT, ACPI_SIG_DSDT, ACPI_SIG_FADT, ACPI_SIG_PSDT, ACPI_SIG_RSDT, ACPI_SIG_XSDT, ACPI_SIG_SSDT, NULL }; #define ACPI_HEADER_SIZE sizeof(struct acpi_table_header) #define ACPI_OVERRIDE_TABLES 64 static struct cpio_data __initdata acpi_initrd_files[ACPI_OVERRIDE_TABLES]; static DECLARE_BITMAP(acpi_initrd_installed, ACPI_OVERRIDE_TABLES); #define MAP_CHUNK_SIZE (NR_FIX_BTMAPS << PAGE_SHIFT) void __init acpi_initrd_override(void data, size_t size) { int sig, no, table_nr = 0, total_offset = 0; long offset = 0; struct acpi_table_header table; char cpio_path[32] = "kernel/firmware/acpi/"; struct cpio_data file; if (data == NULL \|\| size == 0) return; for (no = 0; no < ACPI_OVERRIDE_TABLES; no++) { file = find_cpio_data(cpio_path, data, size, &offset); if (!file.data) break; data += offset; size -= offset; if (file.size < sizeof(struct acpi_table_header)) { pr_err("ACPI OVERRIDE: Table smaller than ACPI header [%s%s]\n", cpio_path, file.name); continue; } table = file.data; for (sig = 0; table_sigs[sig]; sig++) if (!memcmp(table->signature, table_sigs[sig], 4)) break; if (!table_sigs[sig]) { pr_err("ACPI OVERRIDE: Unknown signature [%s%s]\n", cpio_path, file.name); continue; } if (file.size != table->length) { pr_err("ACPI OVERRIDE: File length does not match table length [%s%s]\n", cpio_path, file.name); continue; } if (acpi_table_checksum(file.data, table->length)) { pr_err("ACPI OVERRIDE: Bad table checksum [%s%s]\n", cpio_path, file.name); continue; } pr_info("%4.4s ACPI table found in initrd [%s%s][0x%x]\n", table->signature, cpio_path, file.name, table->length); all_tables_size += table->length; acpi_initrd_files[table_nr].data = file.data; acpi_initrd_files[table_nr].size = file.size; table_nr++; } if (table_nr == 0) return; if (get_securelevel() > 0) { pr_notice(PREFIX "securelevel enabled, ignoring table override\n"); return; } acpi_tables_addr = memblock_find_in_range(0, max_low_pfn_mapped << PAGE_SHIFT, all_tables_size, PAGE_SIZE); if (!acpi_tables_addr) { WARN_ON(1); return; } /* * Only calling e820_add_reserve does not work and the * tables are invalid (memory got used) later. * memblock_reserve works as expected and the tables won't get modified. * But it's not enough on X86 because ioremap will * complain later (used by acpi_os_map_memory) that the pages * that should get mapped are not marked "reserved". * Both memblock_reserve and e820_add_region (via arch_reserve_mem_area) * works fine. / memblock_reserve(acpi_tables_addr, all_tables_size); arch_reserve_mem_area(acpi_tables_addr, all_tables_size); / * early_ioremap only can remap 256k one time. If we map all * tables one time, we will hit the limit. Need to map chunks * one by one during copying the same as that in relocate_initrd(). / for (no = 0; no < table_nr; no++) { unsigned char src_p = acpi_initrd_files[no].data; phys_addr_t size = acpi_initrd_files[no].size; phys_addr_t dest_addr = acpi_tables_addr + total_offset; phys_addr_t slop, clen; char dest_p; total_offset += size; while (size) { slop = dest_addr & ~PAGE_MASK; clen = size; if (clen > MAP_CHUNK_SIZE - slop) clen = MAP_CHUNK_SIZE - slop; dest_p = early_ioremap(dest_addr & PAGE_MASK, clen + slop); memcpy(dest_p + slop, src_p, clen); early_iounmap(dest_p, clen + slop); src_p += clen; dest_addr += clen; size -= clen; } } } acpi_status acpi_os_physical_table_override(struct acpi_table_header existing_table, acpi_physical_address address, u32 length) { int table_offset = 0; int table_index = 0; struct acpi_table_header table; u32 table_length; length = 0; address = 0; if (!acpi_tables_addr) return AE_OK; while (table_offset + ACPI_HEADER_SIZE <= all_tables_size) { table = acpi_os_map_memory(acpi_tables_addr + table_offset, ACPI_HEADER_SIZE); if (table_offset + table->length > all_tables_size) { acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); WARN_ON(1); return AE_OK; } table_length = table->length; / Only override tables matched / if (test_bit(table_index, acpi_initrd_installed) \|\| memcmp(existing_table->signature, table->signature, 4) \|\| memcmp(table->oem_table_id, existing_table->oem_table_id, ACPI_OEM_TABLE_ID_SIZE)) { acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); goto next_table; } length = table_length; address = acpi_tables_addr + table_offset; acpi_table_taint(existing_table); acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); set_bit(table_index, acpi_initrd_installed); break; next_table: table_offset += table_length; table_index++; } return AE_OK; } void __init acpi_initrd_initialize_tables(void) { int table_offset = 0; int table_index = 0; u32 table_length; struct acpi_table_header table; if (!acpi_tables_addr) return; while (table_offset + ACPI_HEADER_SIZE <= all_tables_size) { table = acpi_os_map_memory(acpi_tables_addr + table_offset, ACPI_HEADER_SIZE); if (table_offset + table->length > all_tables_size) { acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); WARN_ON(1); return; } table_length = table->length; /* Skip RSDT/XSDT which should only be used for override / if (test_bit(table_index, acpi_initrd_installed) \|\| ACPI_COMPARE_NAME(table->signature, ACPI_SIG_RSDT) \|\| ACPI_COMPARE_NAME(table->signature, ACPI_SIG_XSDT)) { acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); goto next_table; } acpi_table_taint(table); acpi_os_unmap_memory(table, ACPI_HEADER_SIZE); acpi_install_table(acpi_tables_addr + table_offset, TRUE); set_bit(table_index, acpi_initrd_installed); next_table: table_offset += table_length; table_index++; } } #else acpi_status acpi_os_physical_table_override(struct acpi_table_header existing_table, acpi_physical_address address, u32 table_length) { table_length = 0; address = 0; return AE_OK; } void __init acpi_initrd_initialize_tables(void) { } #endif /* CONFIG_ACPI_INITRD_TABLE_OVERRIDE / acpi_status acpi_os_table_override(struct acpi_table_header existing_table, struct acpi_table_header *new_table) { if (!existing_table \|\| !new_table) return AE_BAD_PARAMETER; new_table = NULL; #ifdef CONFIG_ACPI_CUSTOM_DSDT if (strncmp(existing_table->signature, "DSDT", 4) == 0) new_table = (struct acpi_table_header )AmlCode; #endif if (new_table != NULL) acpi_table_taint(existing_table); return AE_OK; } static irqreturn_t acpi_irq(int irq, void dev_id) { u32 handled; handled = (acpi_irq_handler) (acpi_irq_context); if (handled) { acpi_irq_handled++; return IRQ_HANDLED; } else { acpi_irq_not_handled++; return IRQ_NONE; } } acpi_status acpi_os_install_interrupt_handler(u32 gsi, acpi_osd_handler handler, void context) { unsigned int irq; acpi_irq_stats_init(); /* * ACPI interrupts different from the SCI in our copy of the FADT are * not supported. / if (gsi != acpi_gbl_FADT.sci_interrupt) return AE_BAD_PARAMETER; if (acpi_irq_handler) return AE_ALREADY_ACQUIRED; if (acpi_gsi_to_irq(gsi, &irq) < 0) { printk(KERN_ERR PREFIX "SCI (ACPI GSI %d) not registered\n", gsi); return AE_OK; } acpi_irq_handler = handler; acpi_irq_context = context; if (request_irq(irq, acpi_irq, IRQF_SHARED, "acpi", acpi_irq)) { printk(KERN_ERR PREFIX "SCI (IRQ%d) allocation failed\n", irq); acpi_irq_handler = NULL; return AE_NOT_ACQUIRED; } acpi_sci_irq = irq; return AE_OK; } acpi_status acpi_os_remove_interrupt_handler(u32 gsi, acpi_osd_handler handler) { if (gsi != acpi_gbl_FADT.sci_interrupt \|\| !acpi_sci_irq_valid()) return AE_BAD_PARAMETER; free_irq(acpi_sci_irq, acpi_irq); acpi_irq_handler = NULL; acpi_sci_irq = INVALID_ACPI_IRQ; return AE_OK; } / * Running in interpreter thread context, safe to sleep / void acpi_os_sleep(u64 ms) { msleep(ms); } void acpi_os_stall(u32 us) { while (us) { u32 delay = 1000; if (delay > us) delay = us; udelay(delay); touch_nmi_watchdog(); us -= delay; } } / * Support ACPI 3.0 AML Timer operand * Returns 64-bit free-running, monotonically increasing timer * with 100ns granularity / u64 acpi_os_get_timer(void) { u64 time_ns = ktime_to_ns(ktime_get()); do_div(time_ns, 100); return time_ns; } acpi_status acpi_os_read_port(acpi_io_address port, u32 value, u32 width) { u32 dummy; if (!value) value = &dummy; value = 0; if (width <= 8) { (u8 ) value = inb(port); } else if (width <= 16) { (u16 ) value = inw(port); } else if (width <= 32) { (u32 ) value = inl(port); } else { BUG(); } return AE_OK; } EXPORT_SYMBOL(acpi_os_read_port); acpi_status acpi_os_write_port(acpi_io_address port, u32 value, u32 width) { if (width <= 8) { outb(value, port); } else if (width <= 16) { outw(value, port); } else if (width <= 32) { outl(value, port); } else { BUG(); } return AE_OK; } EXPORT_SYMBOL(acpi_os_write_port); acpi_status acpi_os_read_memory(acpi_physical_address phys_addr, u64 value, u32 width) { void __iomem virt_addr; unsigned int size = width / 8; bool unmap = false; u64 dummy; rcu_read_lock(); virt_addr = acpi_map_vaddr_lookup(phys_addr, size); if (!virt_addr) { rcu_read_unlock(); virt_addr = acpi_os_ioremap(phys_addr, size); if (!virt_addr) return AE_BAD_ADDRESS; unmap = true; } if (!value) value = &dummy; switch (width) { case 8: (u8 ) value = readb(virt_addr); break; case 16: (u16 ) value = readw(virt_addr); break; case 32: (u32 ) value = readl(virt_addr); break; case 64: (u64 ) value = readq(virt_addr); break; default: BUG(); } if (unmap) iounmap(virt_addr); else rcu_read_unlock(); return AE_OK; } acpi_status acpi_os_write_memory(acpi_physical_address phys_addr, u64 value, u32 width) { void __iomem virt_addr; unsigned int size = width / 8; bool unmap = false; rcu_read_lock(); virt_addr = acpi_map_vaddr_lookup(phys_addr, size); if (!virt_addr) { rcu_read_unlock(); virt_addr = acpi_os_ioremap(phys_addr, size); if (!virt_addr) return AE_BAD_ADDRESS; unmap = true; } switch (width) { case 8: writeb(value, virt_addr); break; case 16: writew(value, virt_addr); break; case 32: writel(value, virt_addr); break; case 64: writeq(value, virt_addr); break; default: BUG(); } if (unmap) iounmap(virt_addr); else rcu_read_unlock(); return AE_OK; } acpi_status acpi_os_read_pci_configuration(struct acpi_pci_id * pci_id, u32 reg, u64 value, u32 width) { int result, size; u32 value32; if (!value) return AE_BAD_PARAMETER; switch (width) { case 8: size = 1; break; case 16: size = 2; break; case 32: size = 4; break; default: return AE_ERROR; } result = raw_pci_read(pci_id->segment, pci_id->bus, PCI_DEVFN(pci_id->device, pci_id->function), reg, size, &value32); value = value32; return (result ? AE_ERROR : AE_OK); } acpi_status acpi_os_write_pci_configuration(struct acpi_pci_id * pci_id, u32 reg, u64 value, u32 width) { int result, size; switch (width) { case 8: size = 1; break; case 16: size = 2; break; case 32: size = 4; break; default: return AE_ERROR; } result = raw_pci_write(pci_id->segment, pci_id->bus, PCI_DEVFN(pci_id->device, pci_id->function), reg, size, value); return (result ? AE_ERROR : AE_OK); } static void acpi_os_execute_deferred(struct work_struct work) { struct acpi_os_dpc dpc = container_of(work, struct acpi_os_dpc, work); dpc->function(dpc->context); kfree(dpc); } #ifdef CONFIG_ACPI_DEBUGGER static struct acpi_debugger acpi_debugger; static bool acpi_debugger_initialized; int acpi_register_debugger(struct module owner, const struct acpi_debugger_ops ops) { int ret = 0; mutex_lock(&acpi_debugger.lock); if (acpi_debugger.ops) { ret = -EBUSY; goto err_lock; } acpi_debugger.owner = owner; acpi_debugger.ops = ops; err_lock: mutex_unlock(&acpi_debugger.lock); return ret; } EXPORT_SYMBOL(acpi_register_debugger); void acpi_unregister_debugger(const struct acpi_debugger_ops ops) { mutex_lock(&acpi_debugger.lock); if (ops == acpi_debugger.ops) { acpi_debugger.ops = NULL; acpi_debugger.owner = NULL; } mutex_unlock(&acpi_debugger.lock); } EXPORT_SYMBOL(acpi_unregister_debugger); int acpi_debugger_create_thread(acpi_osd_exec_callback function, void context) { int ret; int (func)(acpi_osd_exec_callback, void ); struct module owner; if (!acpi_debugger_initialized) return -ENODEV; mutex_lock(&acpi_debugger.lock); if (!acpi_debugger.ops) { ret = -ENODEV; goto err_lock; } if (!try_module_get(acpi_debugger.owner)) { ret = -ENODEV; goto err_lock; } func = acpi_debugger.ops->create_thread; owner = acpi_debugger.owner; mutex_unlock(&acpi_debugger.lock); ret = func(function, context); mutex_lock(&acpi_debugger.lock); module_put(owner); err_lock: mutex_unlock(&acpi_debugger.lock); return ret; } ssize_t acpi_debugger_write_log(const char msg) { ssize_t ret; ssize_t (func)(const char ); struct module owner; if (!acpi_debugger_initialized) return -ENODEV; mutex_lock(&acpi_debugger.lock); if (!acpi_debugger.ops) { ret = -ENODEV; goto err_lock; } if (!try_module_get(acpi_debugger.owner)) { ret = -ENODEV; goto err_lock; } func = acpi_debugger.ops->write_log; owner = acpi_debugger.owner; mutex_unlock(&acpi_debugger.lock); ret = func(msg); mutex_lock(&acpi_debugger.lock); module_put(owner); err_lock: mutex_unlock(&acpi_debugger.lock); return ret; } ssize_t acpi_debugger_read_cmd(char buffer, size_t buffer_length) { ssize_t ret; ssize_t (func)(char , size_t); struct module owner; if (!acpi_debugger_initialized) return -ENODEV; mutex_lock(&acpi_debugger.lock); if (!acpi_debugger.ops) { ret = -ENODEV; goto err_lock; } if (!try_module_get(acpi_debugger.owner)) { ret = -ENODEV; goto err_lock; } func = acpi_debugger.ops->read_cmd; owner = acpi_debugger.owner; mutex_unlock(&acpi_debugger.lock); ret = func(buffer, buffer_length); mutex_lock(&acpi_debugger.lock); module_put(owner); err_lock: mutex_unlock(&acpi_debugger.lock); return ret; } int acpi_debugger_wait_command_ready(void) { int ret; int (func)(bool, char , size_t); struct module owner; if (!acpi_debugger_initialized) return -ENODEV; mutex_lock(&acpi_debugger.lock); if (!acpi_debugger.ops) { ret = -ENODEV; goto err_lock; } if (!try_module_get(acpi_debugger.owner)) { ret = -ENODEV; goto err_lock; } func = acpi_debugger.ops->wait_command_ready; owner = acpi_debugger.owner; mutex_unlock(&acpi_debugger.lock); ret = func(acpi_gbl_method_executing, acpi_gbl_db_line_buf, ACPI_DB_LINE_BUFFER_SIZE); mutex_lock(&acpi_debugger.lock); module_put(owner); err_lock: mutex_unlock(&acpi_debugger.lock); return ret; } int acpi_debugger_notify_command_complete(void) { int ret; int (func)(void); struct module owner; if (!acpi_debugger_initialized) return -ENODEV; mutex_lock(&acpi_debugger.lock); if (!acpi_debugger.ops) { ret = -ENODEV; goto err_lock; } if (!try_module_get(acpi_debugger.owner)) { ret = -ENODEV; goto err_lock; } func = acpi_debugger.ops->notify_command_complete; owner = acpi_debugger.owner; mutex_unlock(&acpi_debugger.lock); ret = func(); mutex_lock(&acpi_debugger.lock); module_put(owner); err_lock: mutex_unlock(&acpi_debugger.lock); return ret; } int __init acpi_debugger_init(void) { mutex_init(&acpi_debugger.lock); acpi_debugger_initialized = true; return 0; } #endif /******************************************************************************* * * FUNCTION: acpi_os_execute * * PARAMETERS: Type - Type of the callback * Function - Function to be executed * Context - Function parameters * * RETURN: Status * * DESCRIPTION: Depending on type, either queues function for deferred execution or * immediately executes function on a separate thread. * *****************************************************************************/ acpi_status acpi_os_execute(acpi_execute_type type, acpi_osd_exec_callback function, void context) { acpi_status status = AE_OK; struct acpi_os_dpc dpc; struct workqueue_struct queue; int ret; ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Scheduling function [%p(%p)] for deferred execution.\n", function, context)); if (type == OSL_DEBUGGER_MAIN_THREAD) { ret = acpi_debugger_create_thread(function, context); if (ret) { pr_err("Call to kthread_create() failed.\n"); status = AE_ERROR; } goto out_thread; } /* * Allocate/initialize DPC structure. Note that this memory will be * freed by the callee. The kernel handles the work_struct list in a * way that allows us to also free its memory inside the callee. * Because we may want to schedule several tasks with different * parameters we can't use the approach some kernel code uses of * having a static work_struct. / dpc = kzalloc(sizeof(struct acpi_os_dpc), GFP_ATOMIC); if (!dpc) return AE_NO_MEMORY; dpc->function = function; dpc->context = context; / * To prevent lockdep from complaining unnecessarily, make sure that * there is a different static lockdep key for each workqueue by using * INIT_WORK() for each of them separately. / if (type == OSL_NOTIFY_HANDLER) { queue = kacpi_notify_wq; INIT_WORK(&dpc->work, acpi_os_execute_deferred); } else if (type == OSL_GPE_HANDLER) { queue = kacpid_wq; INIT_WORK(&dpc->work, acpi_os_execute_deferred); } else { pr_err("Unsupported os_execute type %d.\n", type); status = AE_ERROR; } if (ACPI_FAILURE(status)) goto err_workqueue; / * On some machines, a software-initiated SMI causes corruption unless * the SMI runs on CPU 0. An SMI can be initiated by any AML, but * typically it's done in GPE-related methods that are run via * workqueues, so we can avoid the known corruption cases by always * queueing on CPU 0. / ret = queue_work_on(0, queue, &dpc->work); if (!ret) { printk(KERN_ERR PREFIX "Call to queue_work() failed.\n"); status = AE_ERROR; } err_workqueue: if (ACPI_FAILURE(status)) kfree(dpc); out_thread: return status; } EXPORT_SYMBOL(acpi_os_execute); void acpi_os_wait_events_complete(void) { / * Make sure the GPE handler or the fixed event handler is not used * on another CPU after removal. / if (acpi_sci_irq_valid()) synchronize_hardirq(acpi_sci_irq); flush_workqueue(kacpid_wq); flush_workqueue(kacpi_notify_wq); } struct acpi_hp_work { struct work_struct work; struct acpi_device adev; u32 src; }; static void acpi_hotplug_work_fn(struct work_struct work) { struct acpi_hp_work hpw = container_of(work, struct acpi_hp_work, work); acpi_os_wait_events_complete(); acpi_device_hotplug(hpw->adev, hpw->src); kfree(hpw); } acpi_status acpi_hotplug_schedule(struct acpi_device adev, u32 src) { struct acpi_hp_work hpw; ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "Scheduling hotplug event (%p, %u) for deferred execution.\n", adev, src)); hpw = kmalloc(sizeof(hpw), GFP_KERNEL); if (!hpw) return AE_NO_MEMORY; INIT_WORK(&hpw->work, acpi_hotplug_work_fn); hpw->adev = adev; hpw->src = src; / * We can't run hotplug code in kacpid_wq/kacpid_notify_wq etc., because * the hotplug code may call driver .remove() functions, which may * invoke flush_scheduled_work()/acpi_os_wait_events_complete() to flush * these workqueues. / if (!queue_work(kacpi_hotplug_wq, &hpw->work)) { kfree(hpw); return AE_ERROR; } return AE_OK; } bool acpi_queue_hotplug_work(struct work_struct work) { return queue_work(kacpi_hotplug_wq, work); } acpi_status acpi_os_create_semaphore(u32 max_units, u32 initial_units, acpi_handle * handle) { struct semaphore sem = NULL; sem = acpi_os_allocate_zeroed(sizeof(struct semaphore)); if (!sem) return AE_NO_MEMORY; sema_init(sem, initial_units); handle = (acpi_handle ) sem; ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Creating semaphore[%p\|%d].\n", handle, initial_units)); return AE_OK; } /* * TODO: A better way to delete semaphores? Linux doesn't have a * 'delete_semaphore()' function -- may result in an invalid * pointer dereference for non-synchronized consumers. Should * we at least check for blocked threads and signal/cancel them? / acpi_status acpi_os_delete_semaphore(acpi_handle handle) { struct semaphore sem = (struct semaphore )handle; if (!sem) return AE_BAD_PARAMETER; ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Deleting semaphore[%p].\n", handle)); BUG_ON(!list_empty(&sem->wait_list)); kfree(sem); sem = NULL; return AE_OK; } / * TODO: Support for units > 1? / acpi_status acpi_os_wait_semaphore(acpi_handle handle, u32 units, u16 timeout) { acpi_status status = AE_OK; struct semaphore sem = (struct semaphore )handle; long jiffies; int ret = 0; if (!acpi_os_initialized) return AE_OK; if (!sem \|\| (units < 1)) return AE_BAD_PARAMETER; if (units > 1) return AE_SUPPORT; ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Waiting for semaphore[%p\|%d\|%d]\n", handle, units, timeout)); if (timeout == ACPI_WAIT_FOREVER) jiffies = MAX_SCHEDULE_TIMEOUT; else jiffies = msecs_to_jiffies(timeout); ret = down_timeout(sem, jiffies); if (ret) status = AE_TIME; if (ACPI_FAILURE(status)) { ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Failed to acquire semaphore[%p\|%d\|%d], %s", handle, units, timeout, acpi_format_exception(status))); } else { ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Acquired semaphore[%p\|%d\|%d]", handle, units, timeout)); } return status; } / * TODO: Support for units > 1? / acpi_status acpi_os_signal_semaphore(acpi_handle handle, u32 units) { struct semaphore sem = (struct semaphore )handle; if (!acpi_os_initialized) return AE_OK; if (!sem \|\| (units < 1)) return AE_BAD_PARAMETER; if (units > 1) return AE_SUPPORT; ACPI_DEBUG_PRINT((ACPI_DB_MUTEX, "Signaling semaphore[%p\|%d]\n", handle, units)); up(sem); return AE_OK; } acpi_status acpi_os_get_line(char buffer, u32 buffer_length, u32 bytes_read) { #ifdef ENABLE_DEBUGGER if (acpi_in_debugger) { u32 chars; kdb_read(buffer, buffer_length); / remove the CR kdb includes / chars = strlen(buffer) - 1; buffer[chars] = '\0'; } #else int ret; ret = acpi_debugger_read_cmd(buffer, buffer_length); if (ret < 0) return AE_ERROR; if (bytes_read) bytes_read = ret; #endif return AE_OK; } EXPORT_SYMBOL(acpi_os_get_line); acpi_status acpi_os_wait_command_ready(void) { int ret; ret = acpi_debugger_wait_command_ready(); if (ret < 0) return AE_ERROR; return AE_OK; } acpi_status acpi_os_notify_command_complete(void) { int ret; ret = acpi_debugger_notify_command_complete(); if (ret < 0) return AE_ERROR; return AE_OK; } acpi_status acpi_os_signal(u32 function, void info) { switch (function) { case ACPI_SIGNAL_FATAL: printk(KERN_ERR PREFIX "Fatal opcode executed\n"); break; case ACPI_SIGNAL_BREAKPOINT: / * AML Breakpoint * ACPI spec. says to treat it as a NOP unless * you are debugging. So if/when we integrate * AML debugger into the kernel debugger its * hook will go here. But until then it is * not useful to print anything on breakpoints. / break; default: break; } return AE_OK; } static int __init acpi_os_name_setup(char str) { char p = acpi_os_name; int count = ACPI_MAX_OVERRIDE_LEN - 1; if (!str \|\| !str) return 0; for (; count-- && str; str++) { if (isalnum(str) \|\| str == ' ' \|\| str == ':') p++ = str; else if (str == '\'' \|\| str == '"') continue; else break; } p = 0; return 1; } __setup("acpi_os_name=", acpi_os_name_setup); #define OSI_STRING_LENGTH_MAX 64 / arbitrary / #define OSI_STRING_ENTRIES_MAX 16 / arbitrary / struct osi_setup_entry { char string[OSI_STRING_LENGTH_MAX]; bool enable; }; static struct osi_setup_entry osi_setup_entries[OSI_STRING_ENTRIES_MAX] __initdata = { {"Module Device", true}, {"Processor Device", true}, {"3.0 _SCP Extensions", true}, {"Processor Aggregator Device", true}, }; void __init acpi_osi_setup(char str) { struct osi_setup_entry osi; bool enable = true; int i; if (!acpi_gbl_create_osi_method) return; if (str == NULL \|\| str == '\0') { printk(KERN_INFO PREFIX "_OSI method disabled\n"); acpi_gbl_create_osi_method = FALSE; return; } if (str == '!') { str++; if (str == '\0') { osi_linux.default_disabling = 1; return; } else if (str == '') { acpi_update_interfaces(ACPI_DISABLE_ALL_STRINGS); for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) { osi = &osi_setup_entries[i]; osi->enable = false; } return; } enable = false; } for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) { osi = &osi_setup_entries[i]; if (!strcmp(osi->string, str)) { osi->enable = enable; break; } else if (osi->string[0] == '\0') { osi->enable = enable; strncpy(osi->string, str, OSI_STRING_LENGTH_MAX); break; } } } static void __init set_osi_linux(unsigned int enable) { if (osi_linux.enable != enable) osi_linux.enable = enable; if (osi_linux.enable) acpi_osi_setup("Linux"); else acpi_osi_setup("!Linux"); return; } static void __init acpi_cmdline_osi_linux(unsigned int enable) { osi_linux.cmdline = 1; /* cmdline set the default and override DMI / osi_linux.dmi = 0; set_osi_linux(enable); return; } void __init acpi_dmi_osi_linux(int enable, const struct dmi_system_id d) { printk(KERN_NOTICE PREFIX "DMI detected: %s\n", d->ident); if (enable == -1) return; osi_linux.dmi = 1; /* DMI knows that this box asks OSI(Linux) / set_osi_linux(enable); return; } / * Modify the list of "OS Interfaces" reported to BIOS via _OSI * * empty string disables _OSI * string starting with '!' disables that string * otherwise string is added to list, augmenting built-in strings / static void __init acpi_osi_setup_late(void) { struct osi_setup_entry osi; char str; int i; acpi_status status; if (osi_linux.default_disabling) { status = acpi_update_interfaces(ACPI_DISABLE_ALL_VENDOR_STRINGS); if (ACPI_SUCCESS(status)) printk(KERN_INFO PREFIX "Disabled all _OSI OS vendors\n"); } for (i = 0; i < OSI_STRING_ENTRIES_MAX; i++) { osi = &osi_setup_entries[i]; str = osi->string; if (str == '\0') break; if (osi->enable) { status = acpi_install_interface(str); if (ACPI_SUCCESS(status)) printk(KERN_INFO PREFIX "Added _OSI(%s)\n", str); } else { status = acpi_remove_interface(str); if (ACPI_SUCCESS(status)) printk(KERN_INFO PREFIX "Deleted _OSI(%s)\n", str); } } } static int __init osi_setup(char str) { if (str && !strcmp("Linux", str)) acpi_cmdline_osi_linux(1); else if (str && !strcmp("!Linux", str)) acpi_cmdline_osi_linux(0); else acpi_osi_setup(str); return 1; } __setup("acpi_osi=", osi_setup); / * Disable the auto-serialization of named objects creation methods. * * This feature is enabled by default. It marks the AML control methods * that contain the opcodes to create named objects as "Serialized". / static int __init acpi_no_auto_serialize_setup(char str) { acpi_gbl_auto_serialize_methods = FALSE; pr_info("ACPI: auto-serialization disabled\n"); return 1; } __setup("acpi_no_auto_serialize", acpi_no_auto_serialize_setup); /* Check of resource interference between native drivers and ACPI * OperationRegions (SystemIO and System Memory only). * IO ports and memory declared in ACPI might be used by the ACPI subsystem * in arbitrary AML code and can interfere with legacy drivers. * acpi_enforce_resources= can be set to: * * - strict (default) (2) * -> further driver trying to access the resources will not load * - lax (1) * -> further driver trying to access the resources will load, but you * get a system message that something might go wrong... * * - no (0) * -> ACPI Operation Region resources will not be registered * / #define ENFORCE_RESOURCES_STRICT 2 #define ENFORCE_RESOURCES_LAX 1 #define ENFORCE_RESOURCES_NO 0 static unsigned int acpi_enforce_resources = ENFORCE_RESOURCES_STRICT; static int __init acpi_enforce_resources_setup(char str) { if (str == NULL \|\| str == '\0') return 0; if (!strcmp("strict", str)) acpi_enforce_resources = ENFORCE_RESOURCES_STRICT; else if (!strcmp("lax", str)) acpi_enforce_resources = ENFORCE_RESOURCES_LAX; else if (!strcmp("no", str)) acpi_enforce_resources = ENFORCE_RESOURCES_NO; return 1; } __setup("acpi_enforce_resources=", acpi_enforce_resources_setup); / Check for resource conflicts between ACPI OperationRegions and native * drivers / int acpi_check_resource_conflict(const struct resource res) { acpi_adr_space_type space_id; acpi_size length; u8 warn = 0; int clash = 0; if (acpi_enforce_resources == ENFORCE_RESOURCES_NO) return 0; if (!(res->flags & IORESOURCE_IO) && !(res->flags & IORESOURCE_MEM)) return 0; if (res->flags & IORESOURCE_IO) space_id = ACPI_ADR_SPACE_SYSTEM_IO; else space_id = ACPI_ADR_SPACE_SYSTEM_MEMORY; length = resource_size(res); if (acpi_enforce_resources != ENFORCE_RESOURCES_NO) warn = 1; clash = acpi_check_address_range(space_id, res->start, length, warn); if (clash) { if (acpi_enforce_resources != ENFORCE_RESOURCES_NO) { if (acpi_enforce_resources == ENFORCE_RESOURCES_LAX) printk(KERN_NOTICE "ACPI: This conflict may" " cause random problems and system" " instability\n"); printk(KERN_INFO "ACPI: If an ACPI driver is available" " for this device, you should use it instead of" " the native driver\n"); } if (acpi_enforce_resources == ENFORCE_RESOURCES_STRICT) return -EBUSY; } return 0; } EXPORT_SYMBOL(acpi_check_resource_conflict); int acpi_check_region(resource_size_t start, resource_size_t n, const char name) { struct resource res = { .start = start, .end = start + n - 1, .name = name, .flags = IORESOURCE_IO, }; return acpi_check_resource_conflict(&res); } EXPORT_SYMBOL(acpi_check_region); / * Let drivers know whether the resource checks are effective / int acpi_resources_are_enforced(void) { return acpi_enforce_resources == ENFORCE_RESOURCES_STRICT; } EXPORT_SYMBOL(acpi_resources_are_enforced); bool acpi_osi_is_win8(void) { return acpi_gbl_osi_data >= ACPI_OSI_WIN_8; } EXPORT_SYMBOL(acpi_osi_is_win8); / * Deallocate the memory for a spinlock. / void acpi_os_delete_lock(acpi_spinlock handle) { ACPI_FREE(handle); } / * Acquire a spinlock. * * handle is a pointer to the spinlock_t. / acpi_cpu_flags acpi_os_acquire_lock(acpi_spinlock lockp) { acpi_cpu_flags flags; spin_lock_irqsave(lockp, flags); return flags; } / * Release a spinlock. See above. / void acpi_os_release_lock(acpi_spinlock lockp, acpi_cpu_flags flags) { spin_unlock_irqrestore(lockp, flags); } #ifndef ACPI_USE_LOCAL_CACHE /****************************************************************************** * * FUNCTION: acpi_os_create_cache * * PARAMETERS: name - Ascii name for the cache * size - Size of each cached object * depth - Maximum depth of the cache (in objects) <ignored> * cache - Where the new cache object is returned * * RETURN: status * * DESCRIPTION: Create a cache object * *****************************************************************************/ acpi_status acpi_os_create_cache(char name, u16 size, u16 depth, acpi_cache_t ** cache) { cache = kmem_cache_create(name, size, 0, 0, NULL); if (cache == NULL) return AE_ERROR; else return AE_OK; } /******************************************************************************* * * FUNCTION: acpi_os_purge_cache * * PARAMETERS: Cache - Handle to cache object * * RETURN: Status * * DESCRIPTION: Free all objects within the requested cache. * *****************************************************************************/ acpi_status acpi_os_purge_cache(acpi_cache_t cache) { kmem_cache_shrink(cache); return (AE_OK); } /******************************************************************************* * * FUNCTION: acpi_os_delete_cache * * PARAMETERS: Cache - Handle to cache object * * RETURN: Status * * DESCRIPTION: Free all objects within the requested cache and delete the * cache object. * *****************************************************************************/ acpi_status acpi_os_delete_cache(acpi_cache_t cache) { kmem_cache_destroy(cache); return (AE_OK); } /******************************************************************************* * * FUNCTION: acpi_os_release_object * * PARAMETERS: Cache - Handle to cache object * Object - The object to be released * * RETURN: None * * DESCRIPTION: Release an object to the specified cache. If cache is full, * the object is deleted. * *****************************************************************************/ acpi_status acpi_os_release_object(acpi_cache_t cache, void object) { kmem_cache_free(cache, object); return (AE_OK); } #endif static int __init acpi_no_static_ssdt_setup(char s) { acpi_gbl_disable_ssdt_table_install = TRUE; pr_info("ACPI: static SSDT installation disabled\n"); return 0; } early_param("acpi_no_static_ssdt", acpi_no_static_ssdt_setup); static int __init acpi_disable_return_repair(char s) { printk(KERN_NOTICE PREFIX "ACPI: Predefined validation mechanism disabled\n"); acpi_gbl_disable_auto_repair = TRUE; return 1; } __setup("acpica_no_return_repair", acpi_disable_return_repair); acpi_status __init acpi_os_initialize(void) { acpi_os_map_generic_address(&acpi_gbl_FADT.xpm1a_event_block); acpi_os_map_generic_address(&acpi_gbl_FADT.xpm1b_event_block); acpi_os_map_generic_address(&acpi_gbl_FADT.xgpe0_block); acpi_os_map_generic_address(&acpi_gbl_FADT.xgpe1_block); if (acpi_gbl_FADT.flags & ACPI_FADT_RESET_REGISTER) { / * Use acpi_os_map_generic_address to pre-map the reset * register if it's in system memory. / int rv; rv = acpi_os_map_generic_address(&acpi_gbl_FADT.reset_register); pr_debug(PREFIX "%s: map reset_reg status %d\n", __func__, rv); } acpi_os_initialized = true; return AE_OK; } acpi_status __init acpi_os_initialize1(void) { kacpid_wq = alloc_workqueue("kacpid", 0, 1); kacpi_notify_wq = alloc_workqueue("kacpi_notify", 0, 1); kacpi_hotplug_wq = alloc_ordered_workqueue("kacpi_hotplug", 0); BUG_ON(!kacpid_wq); BUG_ON(!kacpi_notify_wq); BUG_ON(!kacpi_hotplug_wq); acpi_install_interface_handler(acpi_osi_handler); acpi_osi_setup_late(); return AE_OK; } acpi_status acpi_os_terminate(void) { if (acpi_irq_handler) { acpi_os_remove_interrupt_handler(acpi_gbl_FADT.sci_interrupt, acpi_irq_handler); } acpi_os_unmap_generic_address(&acpi_gbl_FADT.xgpe1_block); acpi_os_unmap_generic_address(&acpi_gbl_FADT.xgpe0_block); acpi_os_unmap_generic_address(&acpi_gbl_FADT.xpm1b_event_block); acpi_os_unmap_generic_address(&acpi_gbl_FADT.xpm1a_event_block); if (acpi_gbl_FADT.flags & ACPI_FADT_RESET_REGISTER) acpi_os_unmap_generic_address(&acpi_gbl_FADT.reset_register); destroy_workqueue(kacpid_wq); destroy_workqueue(kacpi_notify_wq); destroy_workqueue(kacpi_hotplug_wq); return AE_OK; } acpi_status acpi_os_prepare_sleep(u8 sleep_state, u32 pm1a_control, u32 pm1b_control) { int rc = 0; if (__acpi_os_prepare_sleep) rc = __acpi_os_prepare_sleep(sleep_state, pm1a_control, pm1b_control); if (rc < 0) return AE_ERROR; else if (rc > 0) return AE_CTRL_SKIP; return AE_OK; } void acpi_os_set_prepare_sleep(int (func)(u8 sleep_state, u32 pm1a_ctrl, u32 pm1b_ctrl)) { __acpi_os_prepare_sleep = func; } acpi_status acpi_os_prepare_extended_sleep(u8 sleep_state, u32 val_a, u32 val_b) { int rc = 0; if (__acpi_os_prepare_extended_sleep) rc = __acpi_os_prepare_extended_sleep(sleep_state, val_a, val_b); if (rc < 0) return AE_ERROR; else if (rc > 0) return AE_CTRL_SKIP; return AE_OK; } void acpi_os_set_prepare_extended_sleep(int (*func)(u8 sleep_state, u32 val_a, u32 val_b)) { __acpi_os_prepare_extended_sleep = func; }	./CrossVul/dataset_final_sorted/CWE-264/c/good_5018_1
crossvul-cpp_data_bad_3564_1	/* * linux/kernel/fork.c * * Copyright (C) 1991, 1992 Linus Torvalds / / * 'fork.c' contains the help-routines for the 'fork' system call * (see also entry.S and others). * Fork is rather simple, once you get the hang of it, but the memory * management can be a bitch. See 'mm/memory.c': 'copy_page_range()' / #include <linux/slab.h> #include <linux/init.h> #include <linux/unistd.h> #include <linux/module.h> #include <linux/vmalloc.h> #include <linux/completion.h> #include <linux/mnt_namespace.h> #include <linux/personality.h> #include <linux/mempolicy.h> #include <linux/sem.h> #include <linux/file.h> #include <linux/fdtable.h> #include <linux/iocontext.h> #include <linux/key.h> #include <linux/binfmts.h> #include <linux/mman.h> #include <linux/mmu_notifier.h> #include <linux/fs.h> #include <linux/nsproxy.h> #include <linux/capability.h> #include <linux/cpu.h> #include <linux/cgroup.h> #include <linux/security.h> #include <linux/hugetlb.h> #include <linux/swap.h> #include <linux/syscalls.h> #include <linux/jiffies.h> #include <linux/tracehook.h> #include <linux/futex.h> #include <linux/task_io_accounting_ops.h> #include <linux/rcupdate.h> #include <linux/ptrace.h> #include <linux/mount.h> #include <linux/audit.h> #include <linux/memcontrol.h> #include <linux/profile.h> #include <linux/rmap.h> #include <linux/acct.h> #include <linux/tsacct_kern.h> #include <linux/cn_proc.h> #include <linux/freezer.h> #include <linux/delayacct.h> #include <linux/taskstats_kern.h> #include <linux/random.h> #include <linux/tty.h> #include <linux/proc_fs.h> #include <linux/blkdev.h> #include <trace/sched.h> #include <asm/pgtable.h> #include <asm/pgalloc.h> #include <asm/uaccess.h> #include <asm/mmu_context.h> #include <asm/cacheflush.h> #include <asm/tlbflush.h> / * Protected counters by write_lock_irq(&tasklist_lock) / unsigned long total_forks; / Handle normal Linux uptimes. / int nr_threads; / The idle threads do not count.. / int max_threads; / tunable limit on nr_threads / DEFINE_PER_CPU(unsigned long, process_counts) = 0; __cacheline_aligned DEFINE_RWLOCK(tasklist_lock); / outer / int nr_processes(void) { int cpu; int total = 0; for_each_online_cpu(cpu) total += per_cpu(process_counts, cpu); return total; } #ifndef __HAVE_ARCH_TASK_STRUCT_ALLOCATOR # define alloc_task_struct() kmem_cache_alloc(task_struct_cachep, GFP_KERNEL) # define free_task_struct(tsk) kmem_cache_free(task_struct_cachep, (tsk)) static struct kmem_cache task_struct_cachep; #endif #ifndef __HAVE_ARCH_THREAD_INFO_ALLOCATOR static inline struct thread_info alloc_thread_info(struct task_struct tsk) { #ifdef CONFIG_DEBUG_STACK_USAGE gfp_t mask = GFP_KERNEL \| __GFP_ZERO; #else gfp_t mask = GFP_KERNEL; #endif return (struct thread_info )__get_free_pages(mask, THREAD_SIZE_ORDER); } static inline void free_thread_info(struct thread_info ti) { free_pages((unsigned long)ti, THREAD_SIZE_ORDER); } #endif /* SLAB cache for signal_struct structures (tsk->signal) / static struct kmem_cache signal_cachep; /* SLAB cache for sighand_struct structures (tsk->sighand) / struct kmem_cache sighand_cachep; /* SLAB cache for files_struct structures (tsk->files) / struct kmem_cache files_cachep; /* SLAB cache for fs_struct structures (tsk->fs) / struct kmem_cache fs_cachep; /* SLAB cache for vm_area_struct structures / struct kmem_cache vm_area_cachep; /* SLAB cache for mm_struct structures (tsk->mm) / static struct kmem_cache mm_cachep; void free_task(struct task_struct tsk) { prop_local_destroy_single(&tsk->dirties); free_thread_info(tsk->stack); rt_mutex_debug_task_free(tsk); free_task_struct(tsk); } EXPORT_SYMBOL(free_task); void __put_task_struct(struct task_struct tsk) { WARN_ON(!tsk->exit_state); WARN_ON(atomic_read(&tsk->usage)); WARN_ON(tsk == current); security_task_free(tsk); free_uid(tsk->user); put_group_info(tsk->group_info); delayacct_tsk_free(tsk); if (!profile_handoff_task(tsk)) free_task(tsk); } /* * macro override instead of weak attribute alias, to workaround * gcc 4.1.0 and 4.1.1 bugs with weak attribute and empty functions. / #ifndef arch_task_cache_init #define arch_task_cache_init() #endif void __init fork_init(unsigned long mempages) { #ifndef __HAVE_ARCH_TASK_STRUCT_ALLOCATOR #ifndef ARCH_MIN_TASKALIGN #define ARCH_MIN_TASKALIGN L1_CACHE_BYTES #endif / create a slab on which task_structs can be allocated / task_struct_cachep = kmem_cache_create("task_struct", sizeof(struct task_struct), ARCH_MIN_TASKALIGN, SLAB_PANIC, NULL); #endif / do the arch specific task caches init / arch_task_cache_init(); / * The default maximum number of threads is set to a safe * value: the thread structures can take up at most half * of memory. / max_threads = mempages / (8 THREAD_SIZE / PAGE_SIZE); /* * we need to allow at least 20 threads to boot a system / if(max_threads < 20) max_threads = 20; init_task.signal->rlim[RLIMIT_NPROC].rlim_cur = max_threads/2; init_task.signal->rlim[RLIMIT_NPROC].rlim_max = max_threads/2; init_task.signal->rlim[RLIMIT_SIGPENDING] = init_task.signal->rlim[RLIMIT_NPROC]; } int __attribute__((weak)) arch_dup_task_struct(struct task_struct dst, struct task_struct src) { dst = src; return 0; } static struct task_struct dup_task_struct(struct task_struct orig) { struct task_struct tsk; struct thread_info ti; int err; prepare_to_copy(orig); tsk = alloc_task_struct(); if (!tsk) return NULL; ti = alloc_thread_info(tsk); if (!ti) { free_task_struct(tsk); return NULL; } err = arch_dup_task_struct(tsk, orig); if (err) goto out; tsk->stack = ti; err = prop_local_init_single(&tsk->dirties); if (err) goto out; setup_thread_stack(tsk, orig); #ifdef CONFIG_CC_STACKPROTECTOR tsk->stack_canary = get_random_int(); #endif / One for us, one for whoever does the "release_task()" (usually parent) / atomic_set(&tsk->usage,2); atomic_set(&tsk->fs_excl, 0); #ifdef CONFIG_BLK_DEV_IO_TRACE tsk->btrace_seq = 0; #endif tsk->splice_pipe = NULL; return tsk; out: free_thread_info(ti); free_task_struct(tsk); return NULL; } #ifdef CONFIG_MMU static int dup_mmap(struct mm_struct mm, struct mm_struct oldmm) { struct vm_area_struct mpnt, tmp, pprev; struct rb_node rb_link, rb_parent; int retval; unsigned long charge; struct mempolicy pol; down_write(&oldmm->mmap_sem); flush_cache_dup_mm(oldmm); / * Not linked in yet - no deadlock potential: / down_write_nested(&mm->mmap_sem, SINGLE_DEPTH_NESTING); mm->locked_vm = 0; mm->mmap = NULL; mm->mmap_cache = NULL; mm->free_area_cache = oldmm->mmap_base; mm->cached_hole_size = ~0UL; mm->map_count = 0; cpus_clear(mm->cpu_vm_mask); mm->mm_rb = RB_ROOT; rb_link = &mm->mm_rb.rb_node; rb_parent = NULL; pprev = &mm->mmap; for (mpnt = oldmm->mmap; mpnt; mpnt = mpnt->vm_next) { struct file file; if (mpnt->vm_flags & VM_DONTCOPY) { long pages = vma_pages(mpnt); mm->total_vm -= pages; vm_stat_account(mm, mpnt->vm_flags, mpnt->vm_file, -pages); continue; } charge = 0; if (mpnt->vm_flags & VM_ACCOUNT) { unsigned int len = (mpnt->vm_end - mpnt->vm_start) >> PAGE_SHIFT; if (security_vm_enough_memory(len)) goto fail_nomem; charge = len; } tmp = kmem_cache_alloc(vm_area_cachep, GFP_KERNEL); if (!tmp) goto fail_nomem; tmp = mpnt; pol = mpol_dup(vma_policy(mpnt)); retval = PTR_ERR(pol); if (IS_ERR(pol)) goto fail_nomem_policy; vma_set_policy(tmp, pol); tmp->vm_flags &= ~VM_LOCKED; tmp->vm_mm = mm; tmp->vm_next = NULL; anon_vma_link(tmp); file = tmp->vm_file; if (file) { struct inode inode = file->f_path.dentry->d_inode; get_file(file); if (tmp->vm_flags & VM_DENYWRITE) atomic_dec(&inode->i_writecount); / insert tmp into the share list, just after mpnt / spin_lock(&file->f_mapping->i_mmap_lock); tmp->vm_truncate_count = mpnt->vm_truncate_count; flush_dcache_mmap_lock(file->f_mapping); vma_prio_tree_add(tmp, mpnt); flush_dcache_mmap_unlock(file->f_mapping); spin_unlock(&file->f_mapping->i_mmap_lock); } / * Clear hugetlb-related page reserves for children. This only * affects MAP_PRIVATE mappings. Faults generated by the child * are not guaranteed to succeed, even if read-only / if (is_vm_hugetlb_page(tmp)) reset_vma_resv_huge_pages(tmp); / * Link in the new vma and copy the page table entries. / pprev = tmp; pprev = &tmp->vm_next; __vma_link_rb(mm, tmp, rb_link, rb_parent); rb_link = &tmp->vm_rb.rb_right; rb_parent = &tmp->vm_rb; mm->map_count++; retval = copy_page_range(mm, oldmm, mpnt); if (tmp->vm_ops && tmp->vm_ops->open) tmp->vm_ops->open(tmp); if (retval) goto out; } /* a new mm has just been created / arch_dup_mmap(oldmm, mm); retval = 0; out: up_write(&mm->mmap_sem); flush_tlb_mm(oldmm); up_write(&oldmm->mmap_sem); return retval; fail_nomem_policy: kmem_cache_free(vm_area_cachep, tmp); fail_nomem: retval = -ENOMEM; vm_unacct_memory(charge); goto out; } static inline int mm_alloc_pgd(struct mm_struct mm) { mm->pgd = pgd_alloc(mm); if (unlikely(!mm->pgd)) return -ENOMEM; return 0; } static inline void mm_free_pgd(struct mm_struct * mm) { pgd_free(mm, mm->pgd); } #else #define dup_mmap(mm, oldmm) (0) #define mm_alloc_pgd(mm) (0) #define mm_free_pgd(mm) #endif /* CONFIG_MMU / __cacheline_aligned_in_smp DEFINE_SPINLOCK(mmlist_lock); #define allocate_mm() (kmem_cache_alloc(mm_cachep, GFP_KERNEL)) #define free_mm(mm) (kmem_cache_free(mm_cachep, (mm))) #include <linux/init_task.h> static struct mm_struct mm_init(struct mm_struct * mm, struct task_struct p) { atomic_set(&mm->mm_users, 1); atomic_set(&mm->mm_count, 1); init_rwsem(&mm->mmap_sem); INIT_LIST_HEAD(&mm->mmlist); mm->flags = (current->mm) ? current->mm->flags : MMF_DUMP_FILTER_DEFAULT; mm->core_state = NULL; mm->nr_ptes = 0; set_mm_counter(mm, file_rss, 0); set_mm_counter(mm, anon_rss, 0); spin_lock_init(&mm->page_table_lock); rwlock_init(&mm->ioctx_list_lock); mm->ioctx_list = NULL; mm->free_area_cache = TASK_UNMAPPED_BASE; mm->cached_hole_size = ~0UL; mm_init_owner(mm, p); if (likely(!mm_alloc_pgd(mm))) { mm->def_flags = 0; mmu_notifier_mm_init(mm); return mm; } free_mm(mm); return NULL; } / * Allocate and initialize an mm_struct. / struct mm_struct mm_alloc(void) { struct mm_struct * mm; mm = allocate_mm(); if (mm) { memset(mm, 0, sizeof(mm)); mm = mm_init(mm, current); } return mm; } / * Called when the last reference to the mm * is dropped: either by a lazy thread or by * mmput. Free the page directory and the mm. / void __mmdrop(struct mm_struct mm) { BUG_ON(mm == &init_mm); mm_free_pgd(mm); destroy_context(mm); mmu_notifier_mm_destroy(mm); free_mm(mm); } EXPORT_SYMBOL_GPL(__mmdrop); /* * Decrement the use count and release all resources for an mm. / void mmput(struct mm_struct mm) { might_sleep(); if (atomic_dec_and_test(&mm->mm_users)) { exit_aio(mm); exit_mmap(mm); set_mm_exe_file(mm, NULL); if (!list_empty(&mm->mmlist)) { spin_lock(&mmlist_lock); list_del(&mm->mmlist); spin_unlock(&mmlist_lock); } put_swap_token(mm); mmdrop(mm); } } EXPORT_SYMBOL_GPL(mmput); /** * get_task_mm - acquire a reference to the task's mm * * Returns %NULL if the task has no mm. Checks PF_KTHREAD (meaning * this kernel workthread has transiently adopted a user mm with use_mm, * to do its AIO) is not set and if so returns a reference to it, after * bumping up the use count. User must release the mm via mmput() * after use. Typically used by /proc and ptrace. / struct mm_struct get_task_mm(struct task_struct task) { struct mm_struct mm; task_lock(task); mm = task->mm; if (mm) { if (task->flags & PF_KTHREAD) mm = NULL; else atomic_inc(&mm->mm_users); } task_unlock(task); return mm; } EXPORT_SYMBOL_GPL(get_task_mm); /* Please note the differences between mmput and mm_release. * mmput is called whenever we stop holding onto a mm_struct, * error success whatever. * * mm_release is called after a mm_struct has been removed * from the current process. * * This difference is important for error handling, when we * only half set up a mm_struct for a new process and need to restore * the old one. Because we mmput the new mm_struct before * restoring the old one. . . * Eric Biederman 10 January 1998 / void mm_release(struct task_struct tsk, struct mm_struct mm) { struct completion vfork_done = tsk->vfork_done; /* Get rid of any cached register state / deactivate_mm(tsk, mm); / notify parent sleeping on vfork() / if (vfork_done) { tsk->vfork_done = NULL; complete(vfork_done); } / * If we're exiting normally, clear a user-space tid field if * requested. We leave this alone when dying by signal, to leave * the value intact in a core dump, and to save the unnecessary * trouble otherwise. Userland only wants this done for a sys_exit. / if (tsk->clear_child_tid && !(tsk->flags & PF_SIGNALED) && atomic_read(&mm->mm_users) > 1) { u32 __user tidptr = tsk->clear_child_tid; tsk->clear_child_tid = NULL; /* * We don't check the error code - if userspace has * not set up a proper pointer then tough luck. / put_user(0, tidptr); sys_futex(tidptr, FUTEX_WAKE, 1, NULL, NULL, 0); } } / * Allocate a new mm structure and copy contents from the * mm structure of the passed in task structure. / struct mm_struct dup_mm(struct task_struct tsk) { struct mm_struct mm, oldmm = current->mm; int err; if (!oldmm) return NULL; mm = allocate_mm(); if (!mm) goto fail_nomem; memcpy(mm, oldmm, sizeof(mm)); /* Initializing for Swap token stuff / mm->token_priority = 0; mm->last_interval = 0; if (!mm_init(mm, tsk)) goto fail_nomem; if (init_new_context(tsk, mm)) goto fail_nocontext; dup_mm_exe_file(oldmm, mm); err = dup_mmap(mm, oldmm); if (err) goto free_pt; mm->hiwater_rss = get_mm_rss(mm); mm->hiwater_vm = mm->total_vm; return mm; free_pt: mmput(mm); fail_nomem: return NULL; fail_nocontext: / * If init_new_context() failed, we cannot use mmput() to free the mm * because it calls destroy_context() / mm_free_pgd(mm); free_mm(mm); return NULL; } static int copy_mm(unsigned long clone_flags, struct task_struct tsk) { struct mm_struct * mm, oldmm; int retval; tsk->min_flt = tsk->maj_flt = 0; tsk->nvcsw = tsk->nivcsw = 0; tsk->mm = NULL; tsk->active_mm = NULL; / * Are we cloning a kernel thread? * * We need to steal a active VM for that.. / oldmm = current->mm; if (!oldmm) return 0; if (clone_flags & CLONE_VM) { atomic_inc(&oldmm->mm_users); mm = oldmm; goto good_mm; } retval = -ENOMEM; mm = dup_mm(tsk); if (!mm) goto fail_nomem; good_mm: / Initializing for Swap token stuff / mm->token_priority = 0; mm->last_interval = 0; tsk->mm = mm; tsk->active_mm = mm; return 0; fail_nomem: return retval; } static struct fs_struct __copy_fs_struct(struct fs_struct old) { struct fs_struct fs = kmem_cache_alloc(fs_cachep, GFP_KERNEL); /* We don't need to lock fs - think why ;-) / if (fs) { atomic_set(&fs->count, 1); rwlock_init(&fs->lock); fs->umask = old->umask; read_lock(&old->lock); fs->root = old->root; path_get(&old->root); fs->pwd = old->pwd; path_get(&old->pwd); read_unlock(&old->lock); } return fs; } struct fs_struct copy_fs_struct(struct fs_struct old) { return __copy_fs_struct(old); } EXPORT_SYMBOL_GPL(copy_fs_struct); static int copy_fs(unsigned long clone_flags, struct task_struct tsk) { if (clone_flags & CLONE_FS) { atomic_inc(&current->fs->count); return 0; } tsk->fs = __copy_fs_struct(current->fs); if (!tsk->fs) return -ENOMEM; return 0; } static int copy_files(unsigned long clone_flags, struct task_struct * tsk) { struct files_struct oldf, newf; int error = 0; /* * A background process may not have any files ... / oldf = current->files; if (!oldf) goto out; if (clone_flags & CLONE_FILES) { atomic_inc(&oldf->count); goto out; } newf = dup_fd(oldf, &error); if (!newf) goto out; tsk->files = newf; error = 0; out: return error; } static int copy_io(unsigned long clone_flags, struct task_struct tsk) { #ifdef CONFIG_BLOCK struct io_context ioc = current->io_context; if (!ioc) return 0; / * Share io context with parent, if CLONE_IO is set / if (clone_flags & CLONE_IO) { tsk->io_context = ioc_task_link(ioc); if (unlikely(!tsk->io_context)) return -ENOMEM; } else if (ioprio_valid(ioc->ioprio)) { tsk->io_context = alloc_io_context(GFP_KERNEL, -1); if (unlikely(!tsk->io_context)) return -ENOMEM; tsk->io_context->ioprio = ioc->ioprio; } #endif return 0; } static int copy_sighand(unsigned long clone_flags, struct task_struct tsk) { struct sighand_struct sig; if (clone_flags & (CLONE_SIGHAND \| CLONE_THREAD)) { atomic_inc(&current->sighand->count); return 0; } sig = kmem_cache_alloc(sighand_cachep, GFP_KERNEL); rcu_assign_pointer(tsk->sighand, sig); if (!sig) return -ENOMEM; atomic_set(&sig->count, 1); memcpy(sig->action, current->sighand->action, sizeof(sig->action)); return 0; } void __cleanup_sighand(struct sighand_struct sighand) { if (atomic_dec_and_test(&sighand->count)) kmem_cache_free(sighand_cachep, sighand); } /* * Initialize POSIX timer handling for a thread group. / static void posix_cpu_timers_init_group(struct signal_struct sig) { /* Thread group counters. / thread_group_cputime_init(sig); / Expiration times and increments. / sig->it_virt_expires = cputime_zero; sig->it_virt_incr = cputime_zero; sig->it_prof_expires = cputime_zero; sig->it_prof_incr = cputime_zero; / Cached expiration times. / sig->cputime_expires.prof_exp = cputime_zero; sig->cputime_expires.virt_exp = cputime_zero; sig->cputime_expires.sched_exp = 0; / The timer lists. / INIT_LIST_HEAD(&sig->cpu_timers[0]); INIT_LIST_HEAD(&sig->cpu_timers[1]); INIT_LIST_HEAD(&sig->cpu_timers[2]); } static int copy_signal(unsigned long clone_flags, struct task_struct tsk) { struct signal_struct sig; int ret; if (clone_flags & CLONE_THREAD) { ret = thread_group_cputime_clone_thread(current); if (likely(!ret)) { atomic_inc(&current->signal->count); atomic_inc(&current->signal->live); } return ret; } sig = kmem_cache_alloc(signal_cachep, GFP_KERNEL); tsk->signal = sig; if (!sig) return -ENOMEM; ret = copy_thread_group_keys(tsk); if (ret < 0) { kmem_cache_free(signal_cachep, sig); return ret; } atomic_set(&sig->count, 1); atomic_set(&sig->live, 1); init_waitqueue_head(&sig->wait_chldexit); sig->flags = 0; sig->group_exit_code = 0; sig->group_exit_task = NULL; sig->group_stop_count = 0; sig->curr_target = tsk; init_sigpending(&sig->shared_pending); INIT_LIST_HEAD(&sig->posix_timers); hrtimer_init(&sig->real_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); sig->it_real_incr.tv64 = 0; sig->real_timer.function = it_real_fn; sig->leader = 0; / session leadership doesn't inherit / sig->tty_old_pgrp = NULL; sig->tty = NULL; sig->cutime = sig->cstime = cputime_zero; sig->gtime = cputime_zero; sig->cgtime = cputime_zero; sig->nvcsw = sig->nivcsw = sig->cnvcsw = sig->cnivcsw = 0; sig->min_flt = sig->maj_flt = sig->cmin_flt = sig->cmaj_flt = 0; sig->inblock = sig->oublock = sig->cinblock = sig->coublock = 0; task_io_accounting_init(&sig->ioac); taskstats_tgid_init(sig); task_lock(current->group_leader); memcpy(sig->rlim, current->signal->rlim, sizeof sig->rlim); task_unlock(current->group_leader); posix_cpu_timers_init_group(sig); acct_init_pacct(&sig->pacct); tty_audit_fork(sig); return 0; } void __cleanup_signal(struct signal_struct sig) { thread_group_cputime_free(sig); exit_thread_group_keys(sig); tty_kref_put(sig->tty); kmem_cache_free(signal_cachep, sig); } static void cleanup_signal(struct task_struct tsk) { struct signal_struct sig = tsk->signal; atomic_dec(&sig->live); if (atomic_dec_and_test(&sig->count)) __cleanup_signal(sig); } static void copy_flags(unsigned long clone_flags, struct task_struct p) { unsigned long new_flags = p->flags; new_flags &= ~PF_SUPERPRIV; new_flags \|= PF_FORKNOEXEC; new_flags \|= PF_STARTING; p->flags = new_flags; clear_freeze_flag(p); } asmlinkage long sys_set_tid_address(int __user tidptr) { current->clear_child_tid = tidptr; return task_pid_vnr(current); } static void rt_mutex_init_task(struct task_struct p) { spin_lock_init(&p->pi_lock); #ifdef CONFIG_RT_MUTEXES plist_head_init(&p->pi_waiters, &p->pi_lock); p->pi_blocked_on = NULL; #endif } #ifdef CONFIG_MM_OWNER void mm_init_owner(struct mm_struct mm, struct task_struct p) { mm->owner = p; } #endif / CONFIG_MM_OWNER / / * Initialize POSIX timer handling for a single task. / static void posix_cpu_timers_init(struct task_struct tsk) { tsk->cputime_expires.prof_exp = cputime_zero; tsk->cputime_expires.virt_exp = cputime_zero; tsk->cputime_expires.sched_exp = 0; INIT_LIST_HEAD(&tsk->cpu_timers[0]); INIT_LIST_HEAD(&tsk->cpu_timers[1]); INIT_LIST_HEAD(&tsk->cpu_timers[2]); } /* * This creates a new process as a copy of the old one, * but does not actually start it yet. * * It copies the registers, and all the appropriate * parts of the process environment (as per the clone * flags). The actual kick-off is left to the caller. / static struct task_struct copy_process(unsigned long clone_flags, unsigned long stack_start, struct pt_regs regs, unsigned long stack_size, int __user child_tidptr, struct pid pid, int trace) { int retval; struct task_struct p; int cgroup_callbacks_done = 0; if ((clone_flags & (CLONE_NEWNS\|CLONE_FS)) == (CLONE_NEWNS\|CLONE_FS)) return ERR_PTR(-EINVAL); /* * Thread groups must share signals as well, and detached threads * can only be started up within the thread group. / if ((clone_flags & CLONE_THREAD) && !(clone_flags & CLONE_SIGHAND)) return ERR_PTR(-EINVAL); / * Shared signal handlers imply shared VM. By way of the above, * thread groups also imply shared VM. Blocking this case allows * for various simplifications in other code. / if ((clone_flags & CLONE_SIGHAND) && !(clone_flags & CLONE_VM)) return ERR_PTR(-EINVAL); retval = security_task_create(clone_flags); if (retval) goto fork_out; retval = -ENOMEM; p = dup_task_struct(current); if (!p) goto fork_out; rt_mutex_init_task(p); #ifdef CONFIG_PROVE_LOCKING DEBUG_LOCKS_WARN_ON(!p->hardirqs_enabled); DEBUG_LOCKS_WARN_ON(!p->softirqs_enabled); #endif retval = -EAGAIN; if (atomic_read(&p->user->processes) >= p->signal->rlim[RLIMIT_NPROC].rlim_cur) { if (!capable(CAP_SYS_ADMIN) && !capable(CAP_SYS_RESOURCE) && p->user != current->nsproxy->user_ns->root_user) goto bad_fork_free; } atomic_inc(&p->user->__count); atomic_inc(&p->user->processes); get_group_info(p->group_info); / * If multiple threads are within copy_process(), then this check * triggers too late. This doesn't hurt, the check is only there * to stop root fork bombs. / if (nr_threads >= max_threads) goto bad_fork_cleanup_count; if (!try_module_get(task_thread_info(p)->exec_domain->module)) goto bad_fork_cleanup_count; if (p->binfmt && !try_module_get(p->binfmt->module)) goto bad_fork_cleanup_put_domain; p->did_exec = 0; delayacct_tsk_init(p); / Must remain after dup_task_struct() / copy_flags(clone_flags, p); INIT_LIST_HEAD(&p->children); INIT_LIST_HEAD(&p->sibling); #ifdef CONFIG_PREEMPT_RCU p->rcu_read_lock_nesting = 0; p->rcu_flipctr_idx = 0; #endif / #ifdef CONFIG_PREEMPT_RCU / p->vfork_done = NULL; spin_lock_init(&p->alloc_lock); clear_tsk_thread_flag(p, TIF_SIGPENDING); init_sigpending(&p->pending); p->utime = cputime_zero; p->stime = cputime_zero; p->gtime = cputime_zero; p->utimescaled = cputime_zero; p->stimescaled = cputime_zero; p->prev_utime = cputime_zero; p->prev_stime = cputime_zero; p->default_timer_slack_ns = current->timer_slack_ns; #ifdef CONFIG_DETECT_SOFTLOCKUP p->last_switch_count = 0; p->last_switch_timestamp = 0; #endif task_io_accounting_init(&p->ioac); acct_clear_integrals(p); posix_cpu_timers_init(p); p->lock_depth = -1; / -1 = no lock / do_posix_clock_monotonic_gettime(&p->start_time); p->real_start_time = p->start_time; monotonic_to_bootbased(&p->real_start_time); #ifdef CONFIG_SECURITY p->security = NULL; #endif p->cap_bset = current->cap_bset; p->io_context = NULL; p->audit_context = NULL; cgroup_fork(p); #ifdef CONFIG_NUMA p->mempolicy = mpol_dup(p->mempolicy); if (IS_ERR(p->mempolicy)) { retval = PTR_ERR(p->mempolicy); p->mempolicy = NULL; goto bad_fork_cleanup_cgroup; } mpol_fix_fork_child_flag(p); #endif #ifdef CONFIG_TRACE_IRQFLAGS p->irq_events = 0; #ifdef __ARCH_WANT_INTERRUPTS_ON_CTXSW p->hardirqs_enabled = 1; #else p->hardirqs_enabled = 0; #endif p->hardirq_enable_ip = 0; p->hardirq_enable_event = 0; p->hardirq_disable_ip = _THIS_IP_; p->hardirq_disable_event = 0; p->softirqs_enabled = 1; p->softirq_enable_ip = _THIS_IP_; p->softirq_enable_event = 0; p->softirq_disable_ip = 0; p->softirq_disable_event = 0; p->hardirq_context = 0; p->softirq_context = 0; #endif #ifdef CONFIG_LOCKDEP p->lockdep_depth = 0; / no locks held yet / p->curr_chain_key = 0; p->lockdep_recursion = 0; #endif #ifdef CONFIG_DEBUG_MUTEXES p->blocked_on = NULL; / not blocked yet / #endif / Perform scheduler related setup. Assign this task to a CPU. / sched_fork(p, clone_flags); if ((retval = security_task_alloc(p))) goto bad_fork_cleanup_policy; if ((retval = audit_alloc(p))) goto bad_fork_cleanup_security; / copy all the process information / if ((retval = copy_semundo(clone_flags, p))) goto bad_fork_cleanup_audit; if ((retval = copy_files(clone_flags, p))) goto bad_fork_cleanup_semundo; if ((retval = copy_fs(clone_flags, p))) goto bad_fork_cleanup_files; if ((retval = copy_sighand(clone_flags, p))) goto bad_fork_cleanup_fs; if ((retval = copy_signal(clone_flags, p))) goto bad_fork_cleanup_sighand; if ((retval = copy_mm(clone_flags, p))) goto bad_fork_cleanup_signal; if ((retval = copy_keys(clone_flags, p))) goto bad_fork_cleanup_mm; if ((retval = copy_namespaces(clone_flags, p))) goto bad_fork_cleanup_keys; if ((retval = copy_io(clone_flags, p))) goto bad_fork_cleanup_namespaces; retval = copy_thread(0, clone_flags, stack_start, stack_size, p, regs); if (retval) goto bad_fork_cleanup_io; if (pid != &init_struct_pid) { retval = -ENOMEM; pid = alloc_pid(task_active_pid_ns(p)); if (!pid) goto bad_fork_cleanup_io; if (clone_flags & CLONE_NEWPID) { retval = pid_ns_prepare_proc(task_active_pid_ns(p)); if (retval < 0) goto bad_fork_free_pid; } } p->pid = pid_nr(pid); p->tgid = p->pid; if (clone_flags & CLONE_THREAD) p->tgid = current->tgid; if (current->nsproxy != p->nsproxy) { retval = ns_cgroup_clone(p, pid); if (retval) goto bad_fork_free_pid; } p->set_child_tid = (clone_flags & CLONE_CHILD_SETTID) ? child_tidptr : NULL; / * Clear TID on mm_release()? / p->clear_child_tid = (clone_flags & CLONE_CHILD_CLEARTID) ? child_tidptr: NULL; #ifdef CONFIG_FUTEX p->robust_list = NULL; #ifdef CONFIG_COMPAT p->compat_robust_list = NULL; #endif INIT_LIST_HEAD(&p->pi_state_list); p->pi_state_cache = NULL; #endif / * sigaltstack should be cleared when sharing the same VM / if ((clone_flags & (CLONE_VM\|CLONE_VFORK)) == CLONE_VM) p->sas_ss_sp = p->sas_ss_size = 0; / * Syscall tracing should be turned off in the child regardless * of CLONE_PTRACE. / clear_tsk_thread_flag(p, TIF_SYSCALL_TRACE); #ifdef TIF_SYSCALL_EMU clear_tsk_thread_flag(p, TIF_SYSCALL_EMU); #endif clear_all_latency_tracing(p); / Our parent execution domain becomes current domain These must match for thread signalling to apply / p->parent_exec_id = p->self_exec_id; / ok, now we should be set up.. / p->exit_signal = (clone_flags & CLONE_THREAD) ? -1 : (clone_flags & CSIGNAL); p->pdeath_signal = 0; p->exit_state = 0; / * Ok, make it visible to the rest of the system. * We dont wake it up yet. / p->group_leader = p; INIT_LIST_HEAD(&p->thread_group); / Now that the task is set up, run cgroup callbacks if * necessary. We need to run them before the task is visible * on the tasklist. / cgroup_fork_callbacks(p); cgroup_callbacks_done = 1; / Need tasklist lock for parent etc handling! / write_lock_irq(&tasklist_lock); / * The task hasn't been attached yet, so its cpus_allowed mask will * not be changed, nor will its assigned CPU. * * The cpus_allowed mask of the parent may have changed after it was * copied first time - so re-copy it here, then check the child's CPU * to ensure it is on a valid CPU (and if not, just force it back to * parent's CPU). This avoids alot of nasty races. / p->cpus_allowed = current->cpus_allowed; p->rt.nr_cpus_allowed = current->rt.nr_cpus_allowed; if (unlikely(!cpu_isset(task_cpu(p), p->cpus_allowed) \|\| !cpu_online(task_cpu(p)))) set_task_cpu(p, smp_processor_id()); / CLONE_PARENT re-uses the old parent / if (clone_flags & (CLONE_PARENT\|CLONE_THREAD)) p->real_parent = current->real_parent; else p->real_parent = current; spin_lock(&current->sighand->siglock); / * Process group and session signals need to be delivered to just the * parent before the fork or both the parent and the child after the * fork. Restart if a signal comes in before we add the new process to * it's process group. * A fatal signal pending means that current will exit, so the new * thread can't slip out of an OOM kill (or normal SIGKILL). / recalc_sigpending(); if (signal_pending(current)) { spin_unlock(&current->sighand->siglock); write_unlock_irq(&tasklist_lock); retval = -ERESTARTNOINTR; goto bad_fork_free_pid; } if (clone_flags & CLONE_THREAD) { p->group_leader = current->group_leader; list_add_tail_rcu(&p->thread_group, &p->group_leader->thread_group); } if (likely(p->pid)) { list_add_tail(&p->sibling, &p->real_parent->children); tracehook_finish_clone(p, clone_flags, trace); if (thread_group_leader(p)) { if (clone_flags & CLONE_NEWPID) p->nsproxy->pid_ns->child_reaper = p; p->signal->leader_pid = pid; tty_kref_put(p->signal->tty); p->signal->tty = tty_kref_get(current->signal->tty); set_task_pgrp(p, task_pgrp_nr(current)); set_task_session(p, task_session_nr(current)); attach_pid(p, PIDTYPE_PGID, task_pgrp(current)); attach_pid(p, PIDTYPE_SID, task_session(current)); list_add_tail_rcu(&p->tasks, &init_task.tasks); __get_cpu_var(process_counts)++; } attach_pid(p, PIDTYPE_PID, pid); nr_threads++; } total_forks++; spin_unlock(&current->sighand->siglock); write_unlock_irq(&tasklist_lock); proc_fork_connector(p); cgroup_post_fork(p); return p; bad_fork_free_pid: if (pid != &init_struct_pid) free_pid(pid); bad_fork_cleanup_io: put_io_context(p->io_context); bad_fork_cleanup_namespaces: exit_task_namespaces(p); bad_fork_cleanup_keys: exit_keys(p); bad_fork_cleanup_mm: if (p->mm) mmput(p->mm); bad_fork_cleanup_signal: cleanup_signal(p); bad_fork_cleanup_sighand: __cleanup_sighand(p->sighand); bad_fork_cleanup_fs: exit_fs(p); / blocking / bad_fork_cleanup_files: exit_files(p); / blocking / bad_fork_cleanup_semundo: exit_sem(p); bad_fork_cleanup_audit: audit_free(p); bad_fork_cleanup_security: security_task_free(p); bad_fork_cleanup_policy: #ifdef CONFIG_NUMA mpol_put(p->mempolicy); bad_fork_cleanup_cgroup: #endif cgroup_exit(p, cgroup_callbacks_done); delayacct_tsk_free(p); if (p->binfmt) module_put(p->binfmt->module); bad_fork_cleanup_put_domain: module_put(task_thread_info(p)->exec_domain->module); bad_fork_cleanup_count: put_group_info(p->group_info); atomic_dec(&p->user->processes); free_uid(p->user); bad_fork_free: free_task(p); fork_out: return ERR_PTR(retval); } noinline struct pt_regs __cpuinit __attribute__((weak)) idle_regs(struct pt_regs regs) { memset(regs, 0, sizeof(struct pt_regs)); return regs; } struct task_struct __cpuinit fork_idle(int cpu) { struct task_struct task; struct pt_regs regs; task = copy_process(CLONE_VM, 0, idle_regs(&regs), 0, NULL, &init_struct_pid, 0); if (!IS_ERR(task)) init_idle(task, cpu); return task; } / * Ok, this is the main fork-routine. * * It copies the process, and if successful kick-starts * it and waits for it to finish using the VM if required. / long do_fork(unsigned long clone_flags, unsigned long stack_start, struct pt_regs regs, unsigned long stack_size, int __user parent_tidptr, int __user child_tidptr) { struct task_struct p; int trace = 0; long nr; / * We hope to recycle these flags after 2.6.26 / if (unlikely(clone_flags & CLONE_STOPPED)) { static int __read_mostly count = 100; if (count > 0 && printk_ratelimit()) { char comm[TASK_COMM_LEN]; count--; printk(KERN_INFO "fork(): process `%s' used deprecated " "clone flags 0x%lx\n", get_task_comm(comm, current), clone_flags & CLONE_STOPPED); } } / * When called from kernel_thread, don't do user tracing stuff. / if (likely(user_mode(regs))) trace = tracehook_prepare_clone(clone_flags); p = copy_process(clone_flags, stack_start, regs, stack_size, child_tidptr, NULL, trace); / * Do this prior waking up the new thread - the thread pointer * might get invalid after that point, if the thread exits quickly. / if (!IS_ERR(p)) { struct completion vfork; trace_sched_process_fork(current, p); nr = task_pid_vnr(p); if (clone_flags & CLONE_PARENT_SETTID) put_user(nr, parent_tidptr); if (clone_flags & CLONE_VFORK) { p->vfork_done = &vfork; init_completion(&vfork); } tracehook_report_clone(trace, regs, clone_flags, nr, p); / * We set PF_STARTING at creation in case tracing wants to * use this to distinguish a fully live task from one that * hasn't gotten to tracehook_report_clone() yet. Now we * clear it and set the child going. / p->flags &= ~PF_STARTING; if (unlikely(clone_flags & CLONE_STOPPED)) { / * We'll start up with an immediate SIGSTOP. / sigaddset(&p->pending.signal, SIGSTOP); set_tsk_thread_flag(p, TIF_SIGPENDING); __set_task_state(p, TASK_STOPPED); } else { wake_up_new_task(p, clone_flags); } tracehook_report_clone_complete(trace, regs, clone_flags, nr, p); if (clone_flags & CLONE_VFORK) { freezer_do_not_count(); wait_for_completion(&vfork); freezer_count(); tracehook_report_vfork_done(p, nr); } } else { nr = PTR_ERR(p); } return nr; } #ifndef ARCH_MIN_MMSTRUCT_ALIGN #define ARCH_MIN_MMSTRUCT_ALIGN 0 #endif static void sighand_ctor(void data) { struct sighand_struct sighand = data; spin_lock_init(&sighand->siglock); init_waitqueue_head(&sighand->signalfd_wqh); } void __init proc_caches_init(void) { sighand_cachep = kmem_cache_create("sighand_cache", sizeof(struct sighand_struct), 0, SLAB_HWCACHE_ALIGN\|SLAB_PANIC\|SLAB_DESTROY_BY_RCU, sighand_ctor); signal_cachep = kmem_cache_create("signal_cache", sizeof(struct signal_struct), 0, SLAB_HWCACHE_ALIGN\|SLAB_PANIC, NULL); files_cachep = kmem_cache_create("files_cache", sizeof(struct files_struct), 0, SLAB_HWCACHE_ALIGN\|SLAB_PANIC, NULL); fs_cachep = kmem_cache_create("fs_cache", sizeof(struct fs_struct), 0, SLAB_HWCACHE_ALIGN\|SLAB_PANIC, NULL); vm_area_cachep = kmem_cache_create("vm_area_struct", sizeof(struct vm_area_struct), 0, SLAB_PANIC, NULL); mm_cachep = kmem_cache_create("mm_struct", sizeof(struct mm_struct), ARCH_MIN_MMSTRUCT_ALIGN, SLAB_HWCACHE_ALIGN\|SLAB_PANIC, NULL); } / * Check constraints on flags passed to the unshare system call and * force unsharing of additional process context as appropriate. / static void check_unshare_flags(unsigned long flags_ptr) { /* * If unsharing a thread from a thread group, must also * unshare vm. / if (flags_ptr & CLONE_THREAD) flags_ptr \|= CLONE_VM; / * If unsharing vm, must also unshare signal handlers. / if (flags_ptr & CLONE_VM) flags_ptr \|= CLONE_SIGHAND; / * If unsharing signal handlers and the task was created * using CLONE_THREAD, then must unshare the thread / if ((flags_ptr & CLONE_SIGHAND) && (atomic_read(&current->signal->count) > 1)) flags_ptr \|= CLONE_THREAD; / * If unsharing namespace, must also unshare filesystem information. / if (flags_ptr & CLONE_NEWNS) flags_ptr \|= CLONE_FS; } / * Unsharing of tasks created with CLONE_THREAD is not supported yet / static int unshare_thread(unsigned long unshare_flags) { if (unshare_flags & CLONE_THREAD) return -EINVAL; return 0; } / * Unshare the filesystem structure if it is being shared / static int unshare_fs(unsigned long unshare_flags, struct fs_struct new_fsp) { struct fs_struct fs = current->fs; if ((unshare_flags & CLONE_FS) && (fs && atomic_read(&fs->count) > 1)) { new_fsp = __copy_fs_struct(current->fs); if (!new_fsp) return -ENOMEM; } return 0; } /* * Unsharing of sighand is not supported yet / static int unshare_sighand(unsigned long unshare_flags, struct sighand_struct new_sighp) { struct sighand_struct sigh = current->sighand; if ((unshare_flags & CLONE_SIGHAND) && atomic_read(&sigh->count) > 1) return -EINVAL; else return 0; } /* * Unshare vm if it is being shared / static int unshare_vm(unsigned long unshare_flags, struct mm_struct new_mmp) { struct mm_struct mm = current->mm; if ((unshare_flags & CLONE_VM) && (mm && atomic_read(&mm->mm_users) > 1)) { return -EINVAL; } return 0; } /* * Unshare file descriptor table if it is being shared / static int unshare_fd(unsigned long unshare_flags, struct files_struct new_fdp) { struct files_struct fd = current->files; int error = 0; if ((unshare_flags & CLONE_FILES) && (fd && atomic_read(&fd->count) > 1)) { new_fdp = dup_fd(fd, &error); if (!new_fdp) return error; } return 0; } /* * unshare allows a process to 'unshare' part of the process * context which was originally shared using clone. copy_* * functions used by do_fork() cannot be used here directly * because they modify an inactive task_struct that is being * constructed. Here we are modifying the current, active, * task_struct. / asmlinkage long sys_unshare(unsigned long unshare_flags) { int err = 0; struct fs_struct fs, new_fs = NULL; struct sighand_struct new_sigh = NULL; struct mm_struct mm, new_mm = NULL, active_mm = NULL; struct files_struct fd, new_fd = NULL; struct nsproxy new_nsproxy = NULL; int do_sysvsem = 0; check_unshare_flags(&unshare_flags); /* Return -EINVAL for all unsupported flags / err = -EINVAL; if (unshare_flags & ~(CLONE_THREAD\|CLONE_FS\|CLONE_NEWNS\|CLONE_SIGHAND\| CLONE_VM\|CLONE_FILES\|CLONE_SYSVSEM\| CLONE_NEWUTS\|CLONE_NEWIPC\|CLONE_NEWUSER\| CLONE_NEWNET)) goto bad_unshare_out; / * CLONE_NEWIPC must also detach from the undolist: after switching * to a new ipc namespace, the semaphore arrays from the old * namespace are unreachable. / if (unshare_flags & (CLONE_NEWIPC\|CLONE_SYSVSEM)) do_sysvsem = 1; if ((err = unshare_thread(unshare_flags))) goto bad_unshare_out; if ((err = unshare_fs(unshare_flags, &new_fs))) goto bad_unshare_cleanup_thread; if ((err = unshare_sighand(unshare_flags, &new_sigh))) goto bad_unshare_cleanup_fs; if ((err = unshare_vm(unshare_flags, &new_mm))) goto bad_unshare_cleanup_sigh; if ((err = unshare_fd(unshare_flags, &new_fd))) goto bad_unshare_cleanup_vm; if ((err = unshare_nsproxy_namespaces(unshare_flags, &new_nsproxy, new_fs))) goto bad_unshare_cleanup_fd; if (new_fs \|\| new_mm \|\| new_fd \|\| do_sysvsem \|\| new_nsproxy) { if (do_sysvsem) { / * CLONE_SYSVSEM is equivalent to sys_exit(). / exit_sem(current); } if (new_nsproxy) { switch_task_namespaces(current, new_nsproxy); new_nsproxy = NULL; } task_lock(current); if (new_fs) { fs = current->fs; current->fs = new_fs; new_fs = fs; } if (new_mm) { mm = current->mm; active_mm = current->active_mm; current->mm = new_mm; current->active_mm = new_mm; activate_mm(active_mm, new_mm); new_mm = mm; } if (new_fd) { fd = current->files; current->files = new_fd; new_fd = fd; } task_unlock(current); } if (new_nsproxy) put_nsproxy(new_nsproxy); bad_unshare_cleanup_fd: if (new_fd) put_files_struct(new_fd); bad_unshare_cleanup_vm: if (new_mm) mmput(new_mm); bad_unshare_cleanup_sigh: if (new_sigh) if (atomic_dec_and_test(&new_sigh->count)) kmem_cache_free(sighand_cachep, new_sigh); bad_unshare_cleanup_fs: if (new_fs) put_fs_struct(new_fs); bad_unshare_cleanup_thread: bad_unshare_out: return err; } / * Helper to unshare the files of the current task. * We don't want to expose copy_files internals to * the exec layer of the kernel. / int unshare_files(struct files_struct displaced) { struct task_struct task = current; struct files_struct copy = NULL; int error; error = unshare_fd(CLONE_FILES, &copy); if (error \|\| !copy) { displaced = NULL; return error; } *displaced = task->files; task_lock(task); task->files = copy; task_unlock(task); return 0; }	./CrossVul/dataset_final_sorted/CWE-264/c/bad_3564_1
crossvul-cpp_data_bad_2287_5	/* * fs/f2fs/file.c * * Copyright (c) 2012 Samsung Electronics Co., Ltd. * http://www.samsung.com/ * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. / #include <linux/fs.h> #include <linux/f2fs_fs.h> #include <linux/stat.h> #include <linux/buffer_head.h> #include <linux/writeback.h> #include <linux/blkdev.h> #include <linux/falloc.h> #include <linux/types.h> #include <linux/compat.h> #include <linux/uaccess.h> #include <linux/mount.h> #include "f2fs.h" #include "node.h" #include "segment.h" #include "xattr.h" #include "acl.h" #include <trace/events/f2fs.h> static int f2fs_vm_page_mkwrite(struct vm_area_struct vma, struct vm_fault vmf) { struct page page = vmf->page; struct inode inode = file_inode(vma->vm_file); struct f2fs_sb_info sbi = F2FS_SB(inode->i_sb); struct dnode_of_data dn; int err; f2fs_balance_fs(sbi); sb_start_pagefault(inode->i_sb); /* block allocation / f2fs_lock_op(sbi); set_new_dnode(&dn, inode, NULL, NULL, 0); err = f2fs_reserve_block(&dn, page->index); f2fs_unlock_op(sbi); if (err) goto out; file_update_time(vma->vm_file); lock_page(page); if (unlikely(page->mapping != inode->i_mapping \|\| page_offset(page) > i_size_read(inode) \|\| !PageUptodate(page))) { unlock_page(page); err = -EFAULT; goto out; } / * check to see if the page is mapped already (no holes) / if (PageMappedToDisk(page)) goto mapped; / page is wholly or partially inside EOF / if (((page->index + 1) << PAGE_CACHE_SHIFT) > i_size_read(inode)) { unsigned offset; offset = i_size_read(inode) & ~PAGE_CACHE_MASK; zero_user_segment(page, offset, PAGE_CACHE_SIZE); } set_page_dirty(page); SetPageUptodate(page); trace_f2fs_vm_page_mkwrite(page, DATA); mapped: / fill the page / f2fs_wait_on_page_writeback(page, DATA); out: sb_end_pagefault(inode->i_sb); return block_page_mkwrite_return(err); } static const struct vm_operations_struct f2fs_file_vm_ops = { .fault = filemap_fault, .map_pages = filemap_map_pages, .page_mkwrite = f2fs_vm_page_mkwrite, .remap_pages = generic_file_remap_pages, }; static int get_parent_ino(struct inode inode, nid_t pino) { struct dentry dentry; inode = igrab(inode); dentry = d_find_any_alias(inode); iput(inode); if (!dentry) return 0; if (update_dent_inode(inode, &dentry->d_name)) { dput(dentry); return 0; } pino = parent_ino(dentry); dput(dentry); return 1; } int f2fs_sync_file(struct file file, loff_t start, loff_t end, int datasync) { struct inode inode = file->f_mapping->host; struct f2fs_inode_info fi = F2FS_I(inode); struct f2fs_sb_info sbi = F2FS_SB(inode->i_sb); int ret = 0; bool need_cp = false; struct writeback_control wbc = { .sync_mode = WB_SYNC_ALL, .nr_to_write = LONG_MAX, .for_reclaim = 0, }; if (unlikely(f2fs_readonly(inode->i_sb))) return 0; trace_f2fs_sync_file_enter(inode); ret = filemap_write_and_wait_range(inode->i_mapping, start, end); if (ret) { trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret); return ret; } / guarantee free sections for fsync / f2fs_balance_fs(sbi); down_read(&fi->i_sem); / * Both of fdatasync() and fsync() are able to be recovered from * sudden-power-off. / if (!S_ISREG(inode->i_mode) \|\| inode->i_nlink != 1) need_cp = true; else if (file_wrong_pino(inode)) need_cp = true; else if (!space_for_roll_forward(sbi)) need_cp = true; else if (!is_checkpointed_node(sbi, F2FS_I(inode)->i_pino)) need_cp = true; else if (F2FS_I(inode)->xattr_ver == cur_cp_version(F2FS_CKPT(sbi))) need_cp = true; up_read(&fi->i_sem); if (need_cp) { nid_t pino; / all the dirty node pages should be flushed for POR / ret = f2fs_sync_fs(inode->i_sb, 1); down_write(&fi->i_sem); F2FS_I(inode)->xattr_ver = 0; if (file_wrong_pino(inode) && inode->i_nlink == 1 && get_parent_ino(inode, &pino)) { F2FS_I(inode)->i_pino = pino; file_got_pino(inode); up_write(&fi->i_sem); mark_inode_dirty_sync(inode); ret = f2fs_write_inode(inode, NULL); if (ret) goto out; } else { up_write(&fi->i_sem); } } else { / if there is no written node page, write its inode page / while (!sync_node_pages(sbi, inode->i_ino, &wbc)) { if (fsync_mark_done(sbi, inode->i_ino)) goto out; mark_inode_dirty_sync(inode); ret = f2fs_write_inode(inode, NULL); if (ret) goto out; } ret = wait_on_node_pages_writeback(sbi, inode->i_ino); if (ret) goto out; ret = f2fs_issue_flush(F2FS_SB(inode->i_sb)); } out: trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret); return ret; } static int f2fs_file_mmap(struct file file, struct vm_area_struct vma) { file_accessed(file); vma->vm_ops = &f2fs_file_vm_ops; return 0; } int truncate_data_blocks_range(struct dnode_of_data dn, int count) { int nr_free = 0, ofs = dn->ofs_in_node; struct f2fs_sb_info sbi = F2FS_SB(dn->inode->i_sb); struct f2fs_node raw_node; __le32 addr; raw_node = F2FS_NODE(dn->node_page); addr = blkaddr_in_node(raw_node) + ofs; for (; count > 0; count--, addr++, dn->ofs_in_node++) { block_t blkaddr = le32_to_cpu(addr); if (blkaddr == NULL_ADDR) continue; update_extent_cache(NULL_ADDR, dn); invalidate_blocks(sbi, blkaddr); nr_free++; } if (nr_free) { dec_valid_block_count(sbi, dn->inode, nr_free); set_page_dirty(dn->node_page); sync_inode_page(dn); } dn->ofs_in_node = ofs; trace_f2fs_truncate_data_blocks_range(dn->inode, dn->nid, dn->ofs_in_node, nr_free); return nr_free; } void truncate_data_blocks(struct dnode_of_data dn) { truncate_data_blocks_range(dn, ADDRS_PER_BLOCK); } static void truncate_partial_data_page(struct inode inode, u64 from) { unsigned offset = from & (PAGE_CACHE_SIZE - 1); struct page page; if (!offset) return; page = find_data_page(inode, from >> PAGE_CACHE_SHIFT, false); if (IS_ERR(page)) return; lock_page(page); if (unlikely(page->mapping != inode->i_mapping)) { f2fs_put_page(page, 1); return; } f2fs_wait_on_page_writeback(page, DATA); zero_user(page, offset, PAGE_CACHE_SIZE - offset); set_page_dirty(page); f2fs_put_page(page, 1); } int truncate_blocks(struct inode inode, u64 from) { struct f2fs_sb_info sbi = F2FS_SB(inode->i_sb); unsigned int blocksize = inode->i_sb->s_blocksize; struct dnode_of_data dn; pgoff_t free_from; int count = 0, err = 0; trace_f2fs_truncate_blocks_enter(inode, from); if (f2fs_has_inline_data(inode)) goto done; free_from = (pgoff_t) ((from + blocksize - 1) >> (sbi->log_blocksize)); f2fs_lock_op(sbi); set_new_dnode(&dn, inode, NULL, NULL, 0); err = get_dnode_of_data(&dn, free_from, LOOKUP_NODE); if (err) { if (err == -ENOENT) goto free_next; f2fs_unlock_op(sbi); trace_f2fs_truncate_blocks_exit(inode, err); return err; } if (IS_INODE(dn.node_page)) count = ADDRS_PER_INODE(F2FS_I(inode)); else count = ADDRS_PER_BLOCK; count -= dn.ofs_in_node; f2fs_bug_on(count < 0); if (dn.ofs_in_node \|\| IS_INODE(dn.node_page)) { truncate_data_blocks_range(&dn, count); free_from += count; } f2fs_put_dnode(&dn); free_next: err = truncate_inode_blocks(inode, free_from); f2fs_unlock_op(sbi); done: / lastly zero out the first data page / truncate_partial_data_page(inode, from); trace_f2fs_truncate_blocks_exit(inode, err); return err; } void f2fs_truncate(struct inode inode) { if (!(S_ISREG(inode->i_mode) \|\| S_ISDIR(inode->i_mode) \|\| S_ISLNK(inode->i_mode))) return; trace_f2fs_truncate(inode); if (!truncate_blocks(inode, i_size_read(inode))) { inode->i_mtime = inode->i_ctime = CURRENT_TIME; mark_inode_dirty(inode); } } int f2fs_getattr(struct vfsmount mnt, struct dentry dentry, struct kstat stat) { struct inode inode = dentry->d_inode; generic_fillattr(inode, stat); stat->blocks <<= 3; return 0; } #ifdef CONFIG_F2FS_FS_POSIX_ACL static void __setattr_copy(struct inode inode, const struct iattr attr) { struct f2fs_inode_info fi = F2FS_I(inode); unsigned int ia_valid = attr->ia_valid; if (ia_valid & ATTR_UID) inode->i_uid = attr->ia_uid; if (ia_valid & ATTR_GID) inode->i_gid = attr->ia_gid; if (ia_valid & ATTR_ATIME) inode->i_atime = timespec_trunc(attr->ia_atime, inode->i_sb->s_time_gran); if (ia_valid & ATTR_MTIME) inode->i_mtime = timespec_trunc(attr->ia_mtime, inode->i_sb->s_time_gran); if (ia_valid & ATTR_CTIME) inode->i_ctime = timespec_trunc(attr->ia_ctime, inode->i_sb->s_time_gran); if (ia_valid & ATTR_MODE) { umode_t mode = attr->ia_mode; if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID)) mode &= ~S_ISGID; set_acl_inode(fi, mode); } } #else #define __setattr_copy setattr_copy #endif int f2fs_setattr(struct dentry dentry, struct iattr attr) { struct inode inode = dentry->d_inode; struct f2fs_inode_info fi = F2FS_I(inode); int err; err = inode_change_ok(inode, attr); if (err) return err; if ((attr->ia_valid & ATTR_SIZE) && attr->ia_size != i_size_read(inode)) { err = f2fs_convert_inline_data(inode, attr->ia_size); if (err) return err; truncate_setsize(inode, attr->ia_size); f2fs_truncate(inode); f2fs_balance_fs(F2FS_SB(inode->i_sb)); } __setattr_copy(inode, attr); if (attr->ia_valid & ATTR_MODE) { err = posix_acl_chmod(inode, get_inode_mode(inode)); if (err \|\| is_inode_flag_set(fi, FI_ACL_MODE)) { inode->i_mode = fi->i_acl_mode; clear_inode_flag(fi, FI_ACL_MODE); } } mark_inode_dirty(inode); return err; } const struct inode_operations f2fs_file_inode_operations = { .getattr = f2fs_getattr, .setattr = f2fs_setattr, .get_acl = f2fs_get_acl, .set_acl = f2fs_set_acl, #ifdef CONFIG_F2FS_FS_XATTR .setxattr = generic_setxattr, .getxattr = generic_getxattr, .listxattr = f2fs_listxattr, .removexattr = generic_removexattr, #endif }; static void fill_zero(struct inode inode, pgoff_t index, loff_t start, loff_t len) { struct f2fs_sb_info sbi = F2FS_SB(inode->i_sb); struct page page; if (!len) return; f2fs_balance_fs(sbi); f2fs_lock_op(sbi); page = get_new_data_page(inode, NULL, index, false); f2fs_unlock_op(sbi); if (!IS_ERR(page)) { f2fs_wait_on_page_writeback(page, DATA); zero_user(page, start, len); set_page_dirty(page); f2fs_put_page(page, 1); } } int truncate_hole(struct inode inode, pgoff_t pg_start, pgoff_t pg_end) { pgoff_t index; int err; for (index = pg_start; index < pg_end; index++) { struct dnode_of_data dn; set_new_dnode(&dn, inode, NULL, NULL, 0); err = get_dnode_of_data(&dn, index, LOOKUP_NODE); if (err) { if (err == -ENOENT) continue; return err; } if (dn.data_blkaddr != NULL_ADDR) truncate_data_blocks_range(&dn, 1); f2fs_put_dnode(&dn); } return 0; } static int punch_hole(struct inode inode, loff_t offset, loff_t len) { pgoff_t pg_start, pg_end; loff_t off_start, off_end; int ret = 0; ret = f2fs_convert_inline_data(inode, MAX_INLINE_DATA + 1); if (ret) return ret; pg_start = ((unsigned long long) offset) >> PAGE_CACHE_SHIFT; pg_end = ((unsigned long long) offset + len) >> PAGE_CACHE_SHIFT; off_start = offset & (PAGE_CACHE_SIZE - 1); off_end = (offset + len) & (PAGE_CACHE_SIZE - 1); if (pg_start == pg_end) { fill_zero(inode, pg_start, off_start, off_end - off_start); } else { if (off_start) fill_zero(inode, pg_start++, off_start, PAGE_CACHE_SIZE - off_start); if (off_end) fill_zero(inode, pg_end, 0, off_end); if (pg_start < pg_end) { struct address_space mapping = inode->i_mapping; loff_t blk_start, blk_end; struct f2fs_sb_info sbi = F2FS_SB(inode->i_sb); f2fs_balance_fs(sbi); blk_start = pg_start << PAGE_CACHE_SHIFT; blk_end = pg_end << PAGE_CACHE_SHIFT; truncate_inode_pages_range(mapping, blk_start, blk_end - 1); f2fs_lock_op(sbi); ret = truncate_hole(inode, pg_start, pg_end); f2fs_unlock_op(sbi); } } return ret; } static int expand_inode_data(struct inode inode, loff_t offset, loff_t len, int mode) { struct f2fs_sb_info sbi = F2FS_SB(inode->i_sb); pgoff_t index, pg_start, pg_end; loff_t new_size = i_size_read(inode); loff_t off_start, off_end; int ret = 0; ret = inode_newsize_ok(inode, (len + offset)); if (ret) return ret; ret = f2fs_convert_inline_data(inode, offset + len); if (ret) return ret; pg_start = ((unsigned long long) offset) >> PAGE_CACHE_SHIFT; pg_end = ((unsigned long long) offset + len) >> PAGE_CACHE_SHIFT; off_start = offset & (PAGE_CACHE_SIZE - 1); off_end = (offset + len) & (PAGE_CACHE_SIZE - 1); for (index = pg_start; index <= pg_end; index++) { struct dnode_of_data dn; f2fs_lock_op(sbi); set_new_dnode(&dn, inode, NULL, NULL, 0); ret = f2fs_reserve_block(&dn, index); f2fs_unlock_op(sbi); if (ret) break; if (pg_start == pg_end) new_size = offset + len; else if (index == pg_start && off_start) new_size = (index + 1) << PAGE_CACHE_SHIFT; else if (index == pg_end) new_size = (index << PAGE_CACHE_SHIFT) + off_end; else new_size += PAGE_CACHE_SIZE; } if (!(mode & FALLOC_FL_KEEP_SIZE) && i_size_read(inode) < new_size) { i_size_write(inode, new_size); mark_inode_dirty(inode); } return ret; } static long f2fs_fallocate(struct file file, int mode, loff_t offset, loff_t len) { struct inode inode = file_inode(file); long ret; if (mode & ~(FALLOC_FL_KEEP_SIZE \| FALLOC_FL_PUNCH_HOLE)) return -EOPNOTSUPP; mutex_lock(&inode->i_mutex); if (mode & FALLOC_FL_PUNCH_HOLE) ret = punch_hole(inode, offset, len); else ret = expand_inode_data(inode, offset, len, mode); if (!ret) { inode->i_mtime = inode->i_ctime = CURRENT_TIME; mark_inode_dirty(inode); } mutex_unlock(&inode->i_mutex); trace_f2fs_fallocate(inode, mode, offset, len, ret); return ret; } #define F2FS_REG_FLMASK (~(FS_DIRSYNC_FL \| FS_TOPDIR_FL)) #define F2FS_OTHER_FLMASK (FS_NODUMP_FL \| FS_NOATIME_FL) static inline __u32 f2fs_mask_flags(umode_t mode, __u32 flags) { if (S_ISDIR(mode)) return flags; else if (S_ISREG(mode)) return flags & F2FS_REG_FLMASK; else return flags & F2FS_OTHER_FLMASK; } long f2fs_ioctl(struct file filp, unsigned int cmd, unsigned long arg) { struct inode inode = file_inode(filp); struct f2fs_inode_info fi = F2FS_I(inode); unsigned int flags; int ret; switch (cmd) { case F2FS_IOC_GETFLAGS: flags = fi->i_flags & FS_FL_USER_VISIBLE; return put_user(flags, (int __user ) arg); case F2FS_IOC_SETFLAGS: { unsigned int oldflags; ret = mnt_want_write_file(filp); if (ret) return ret; if (!inode_owner_or_capable(inode)) { ret = -EACCES; goto out; } if (get_user(flags, (int __user ) arg)) { ret = -EFAULT; goto out; } flags = f2fs_mask_flags(inode->i_mode, flags); mutex_lock(&inode->i_mutex); oldflags = fi->i_flags; if ((flags ^ oldflags) & (FS_APPEND_FL \| FS_IMMUTABLE_FL)) { if (!capable(CAP_LINUX_IMMUTABLE)) { mutex_unlock(&inode->i_mutex); ret = -EPERM; goto out; } } flags = flags & FS_FL_USER_MODIFIABLE; flags \|= oldflags & ~FS_FL_USER_MODIFIABLE; fi->i_flags = flags; mutex_unlock(&inode->i_mutex); f2fs_set_inode_flags(inode); inode->i_ctime = CURRENT_TIME; mark_inode_dirty(inode); out: mnt_drop_write_file(filp); return ret; } default: return -ENOTTY; } } #ifdef CONFIG_COMPAT long f2fs_compat_ioctl(struct file file, unsigned int cmd, unsigned long arg) { switch (cmd) { case F2FS_IOC32_GETFLAGS: cmd = F2FS_IOC_GETFLAGS; break; case F2FS_IOC32_SETFLAGS: cmd = F2FS_IOC_SETFLAGS; break; default: return -ENOIOCTLCMD; } return f2fs_ioctl(file, cmd, (unsigned long) compat_ptr(arg)); } #endif const struct file_operations f2fs_file_operations = { .llseek = generic_file_llseek, .read = new_sync_read, .write = new_sync_write, .read_iter = generic_file_read_iter, .write_iter = generic_file_write_iter, .open = generic_file_open, .mmap = f2fs_file_mmap, .fsync = f2fs_sync_file, .fallocate = f2fs_fallocate, .unlocked_ioctl = f2fs_ioctl, #ifdef CONFIG_COMPAT .compat_ioctl = f2fs_compat_ioctl, #endif .splice_read = generic_file_splice_read, .splice_write = generic_file_splice_write, };	./CrossVul/dataset_final_sorted/CWE-264/c/bad_2287_5
crossvul-cpp_data_good_3470_0	/* * npw-rpc.c - Remote Procedure Calls (NPAPI specialisation) * * nspluginwrapper (C) 2005-2009 Gwenole Beauchesne * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. / #include "sysdeps.h" #include <assert.h> #include "utils.h" #include "npw-common.h" #define DEBUG 1 #include "debug.h" / * RPC types of NPP/NPN variables / int rpc_type_of_NPNVariable(int variable) { int type; switch (variable) { case NPNVjavascriptEnabledBool: case NPNVasdEnabledBool: case NPNVisOfflineBool: case NPNVSupportsXEmbedBool: case NPNVSupportsWindowless: case NPNVprivateModeBool: case NPNVsupportsAdvancedKeyHandling: type = RPC_TYPE_BOOLEAN; break; case NPNVToolkit: case NPNVnetscapeWindow: type = RPC_TYPE_UINT32; break; case NPNVWindowNPObject: case NPNVPluginElementNPObject: type = RPC_TYPE_NP_OBJECT; break; default: type = RPC_ERROR_GENERIC; break; } return type; } int rpc_type_of_NPPVariable(int variable) { int type; switch (variable) { case NPPVpluginNameString: case NPPVpluginDescriptionString: case NPPVformValue: // byte values of 0 does not appear in the UTF-8 encoding but for U+0000 case NPPVpluginNativeAccessibleAtkPlugId: type = RPC_TYPE_STRING; break; case NPPVpluginWindowSize: case NPPVpluginTimerInterval: type = RPC_TYPE_INT32; break; case NPPVpluginNeedsXEmbed: case NPPVpluginWindowBool: case NPPVpluginTransparentBool: case NPPVjavascriptPushCallerBool: case NPPVpluginKeepLibraryInMemory: case NPPVpluginUrlRequestsDisplayedBool: case NPPVpluginWantsAllNetworkStreams: case NPPVpluginCancelSrcStream: case NPPVSupportsAdvancedKeyHandling: type = RPC_TYPE_BOOLEAN; break; case NPPVpluginScriptableNPObject: type = RPC_TYPE_NP_OBJECT; break; default: type = RPC_ERROR_GENERIC; break; } return type; } / * Process NPW_PluginInstance objects / static int do_send_NPW_PluginInstance(rpc_message_t message, void p_value) { NPW_PluginInstance plugin = (NPW_PluginInstance )p_value; uint32_t instance_id = 0; if (plugin) instance_id = plugin->instance_id; return rpc_message_send_uint32(message, instance_id); } static int do_recv_NPW_PluginInstance(rpc_message_t message, void p_value) { int error; uint32_t instance_id; if ((error = rpc_message_recv_uint32(message, &instance_id)) < 0) return error; NPW_PluginInstance plugin = id_lookup(instance_id); if (instance_id && plugin == NULL) npw_printf("ERROR: no valid NPP -> PluginInstance mapping found\n"); else if (plugin && plugin->instance == NULL) npw_printf("ERROR: no valid PluginInstance -> NPP mapping found\n"); else if (plugin && !npw_plugin_instance_is_valid(plugin)) npw_printf("ERROR: received PluginInstance was invalidated earlier\n"); ((NPW_PluginInstance )p_value) = plugin; return RPC_ERROR_NO_ERROR; } / * Process NPP objects / static int do_send_NPP(rpc_message_t message, void p_value) { NPP instance = (NPP)p_value; NPW_PluginInstance plugin = NULL; if (instance) plugin = NPW_PLUGIN_INSTANCE(instance); return do_send_NPW_PluginInstance(message, plugin); } static int do_recv_NPP(rpc_message_t message, void p_value) { int error; NPW_PluginInstance plugin; if ((error = do_recv_NPW_PluginInstance(message, &plugin)) < 0) return error; ((NPP )p_value) = plugin ? plugin->instance : NULL; return RPC_ERROR_NO_ERROR; } / * Process NPStream objects / static int do_send_NPStream(rpc_message_t message, void p_value) { uint32_t stream_id = 0; NPStream stream = (NPStream )p_value; if (stream) { NPW_StreamInstance sip = NPW_STREAM_INSTANCE(stream); if (sip) stream_id = sip->stream_id; } return rpc_message_send_uint32(message, stream_id); } static int do_recv_NPStream(rpc_message_t message, void p_value) { int error; uint32_t stream_id; if ((error = rpc_message_recv_uint32(message, &stream_id)) < 0) return error; NPW_StreamInstance stream = id_lookup(stream_id); ((NPStream *)p_value) = stream ? stream->stream : NULL; return RPC_ERROR_NO_ERROR; } / * Process NPByteRange objects / static int do_send_NPByteRange(rpc_message_t message, void p_value) { NPByteRange range = (NPByteRange )p_value; while (range) { int error; if ((error = rpc_message_send_uint32(message, 1)) < 0) return error; if ((error = rpc_message_send_int32(message, range->offset)) < 0) return error; if ((error = rpc_message_send_uint32(message, range->length)) < 0) return error; range = range->next; } return rpc_message_send_uint32(message, 0); } static int do_recv_NPByteRange(rpc_message_t message, void p_value) { NPByteRange rangeListPtr = (NPByteRange )p_value; if (rangeListPtr == NULL) return RPC_ERROR_MESSAGE_ARGUMENT_INVALID; rangeListPtr = NULL; for (;;) { int error; uint32_t cont; if ((error = rpc_message_recv_uint32(message, &cont)) < 0) return error; if (!cont) break; NPByteRange range = malloc(sizeof(range)); if (range == NULL) return RPC_ERROR_NO_MEMORY; range->next = NULL; if ((error = rpc_message_recv_int32(message, &range->offset)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &range->length)) < 0) return error; rangeListPtr = range; rangeListPtr = &range->next; } return RPC_ERROR_NO_ERROR; } / * Process NPSavedData objects / static int do_send_NPSavedData(rpc_message_t message, void p_value) { NPSavedData save_area = (NPSavedData )p_value; int error; if (save_area == NULL) { if ((error = rpc_message_send_int32(message, 0)) < 0) return error; } else { if ((error = rpc_message_send_int32(message, save_area->len)) < 0) return error; if ((error = rpc_message_send_bytes(message, save_area->buf, save_area->len)) < 0) return error; } return RPC_ERROR_NO_ERROR; } static int do_recv_NPSavedData(rpc_message_t message, void p_value) { NPSavedData save_area; int error; int32_t len; unsigned char buf; if ((error = rpc_message_recv_int32(message, &len)) < 0) return error; if (len == 0) save_area = NULL; else { if ((save_area = NPN_MemAlloc(sizeof(save_area))) == NULL) return RPC_ERROR_NO_MEMORY; if ((buf = NPN_MemAlloc(len)) == NULL) return RPC_ERROR_NO_MEMORY; if ((error = rpc_message_recv_bytes(message, buf, len)) < 0) return error; save_area->len = len; save_area->buf = buf; } if (p_value) ((NPSavedData )p_value) = save_area; else if (save_area) { NPN_MemFree(save_area->buf); NPN_MemFree(save_area); } return RPC_ERROR_NO_ERROR; } / * Process NotifyData objects / // Rationale: NotifyData objects are allocated on the plugin side // only. IDs are passed through to the browser, and they have no // meaning on that side as they are only used to get passed back to // the plugin side // // XXX 64-bit viewers in 32-bit wrappers are not supported static int do_send_NotifyData(rpc_message_t message, void p_value) { void notifyData = (void )p_value; return rpc_message_send_uint64(message, (uintptr_t)notifyData); } static int do_recv_NotifyData(rpc_message_t message, void p_value) { int error; uint64_t id; if ((error = rpc_message_recv_uint64(message, &id)) < 0) return error; if (sizeof(void ) == 4 && ((uint32_t)(id >> 32)) != 0) { npw_printf("ERROR: 64-bit viewers in 32-bit wrappers are not supported\n"); abort(); } ((void )p_value) = (void )(uintptr_t)id; return RPC_ERROR_NO_ERROR; } /* * Process NPRect objects / static int do_send_NPRect(rpc_message_t message, void p_value) { NPRect rect = (NPRect )p_value; int error; if ((error = rpc_message_send_uint32(message, rect->top)) < 0) return error; if ((error = rpc_message_send_uint32(message, rect->left)) < 0) return error; if ((error = rpc_message_send_uint32(message, rect->bottom)) < 0) return error; if ((error = rpc_message_send_uint32(message, rect->right)) < 0) return error; return RPC_ERROR_NO_ERROR; } static int do_recv_NPRect(rpc_message_t message, void p_value) { NPRect rect = (NPRect )p_value; uint32_t top, left, bottom, right; int error; if ((error = rpc_message_recv_uint32(message, &top)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &left)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &bottom)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &right)) < 0) return error; rect->top = top; rect->left = left; rect->bottom = bottom; rect->right = right; return RPC_ERROR_NO_ERROR; } / * Process NPWindow objects / static int do_send_NPSetWindowCallbackStruct(rpc_message_t message, void p_value) { NPSetWindowCallbackStruct ws_info = (NPSetWindowCallbackStruct )p_value; int error; if (ws_info) { if ((error = rpc_message_send_uint32(message, 1)) < 0) return error; if ((error = rpc_message_send_int32(message, ws_info->type)) < 0) return error; if ((error = rpc_message_send_uint32(message, ws_info->visual ? XVisualIDFromVisual(ws_info->visual) : 0)) < 0) return error; if ((error = rpc_message_send_uint32(message, ws_info->colormap)) < 0) return error; if ((error = rpc_message_send_uint32(message, ws_info->depth)) < 0) return error; } else { if ((error = rpc_message_send_uint32(message, 0)) < 0) return error; } return RPC_ERROR_NO_ERROR; } static int do_recv_NPSetWindowCallbackStruct(rpc_message_t message, void p_value) { NPSetWindowCallbackStruct ws_info_p = (NPSetWindowCallbackStruct )p_value; NPSetWindowCallbackStruct ws_info; int32_t type; uint32_t has_ws_info, visual_id, colormap, depth; int error; if (ws_info_p) ws_info_p = NULL; if ((error = rpc_message_recv_uint32(message, &has_ws_info)) < 0) return error; if (has_ws_info) { if ((error = rpc_message_recv_int32(message, &type)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &visual_id)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &colormap)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &depth)) < 0) return error; if (ws_info_p) { if ((ws_info = calloc(1, sizeof(ws_info))) == NULL) return RPC_ERROR_NO_MEMORY; ws_info->type = type; // display shall be filled in by the plugin // visual shall be reconstructed by the plugin based on the visualID ws_info->visual = (void )(uintptr_t)visual_id; ws_info->colormap = colormap; ws_info->depth = depth; ws_info_p = ws_info; } } return RPC_ERROR_NO_ERROR; } static int do_send_NPWindowData(rpc_message_t message, void p_value) { NPWindow window = (NPWindow )p_value; int error; if (window == NULL) return RPC_ERROR_MESSAGE_ARGUMENT_INVALID; if ((error = rpc_message_send_uint32(message, (Window)window->window)) < 0) return error; if ((error = rpc_message_send_int32(message, window->x)) < 0) return error; if ((error = rpc_message_send_int32(message, window->y)) < 0) return error; if ((error = rpc_message_send_uint32(message, window->width)) < 0) return error; if ((error = rpc_message_send_uint32(message, window->height)) < 0) return error; if ((error = do_send_NPRect(message, &window->clipRect)) < 0) return error; if ((error = rpc_message_send_int32(message, window->type)) < 0) return error; if ((error = do_send_NPSetWindowCallbackStruct(message, window->ws_info)) < 0) return 0; return RPC_ERROR_NO_ERROR; } static int do_recv_NPWindowData(rpc_message_t message, void p_value) { NPWindow window = (NPWindow )p_value; NPSetWindowCallbackStruct ws_info; uint32_t window_id; int32_t window_type; int error; if (window == NULL) return RPC_ERROR_MESSAGE_ARGUMENT_INVALID; if ((error = rpc_message_recv_uint32(message, &window_id)) < 0) return error; if ((error = rpc_message_recv_int32(message, &window->x)) < 0) return error; if ((error = rpc_message_recv_int32(message, &window->y)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &window->width)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &window->height)) < 0) return error; if ((error = do_recv_NPRect(message, &window->clipRect)) < 0) return error; if ((error = rpc_message_recv_int32(message, &window_type)) < 0) return error; if ((error = do_recv_NPSetWindowCallbackStruct(message, &ws_info)) < 0) return error; window->type = window_type; window->window = (void )(Window)window_id; window->ws_info = ws_info; return RPC_ERROR_NO_ERROR; } static int do_send_NPWindow(rpc_message_t message, void p_value) { NPWindow window = (NPWindow )p_value; int error; if (window == NULL) { if ((error = rpc_message_send_uint32(message, 0)) < 0) return error; } else { if ((error = rpc_message_send_uint32(message, 1)) < 0) return error; if ((error = do_send_NPWindowData(message, window)) < 0) return error; } return RPC_ERROR_NO_ERROR; } static int do_recv_NPWindow(rpc_message_t message, void p_value) { NPWindow window_p = (NPWindow )p_value; NPWindow window; uint32_t window_valid; int error; if (window_p) window_p = NULL; if ((error = rpc_message_recv_uint32(message, &window_valid)) < 0) return error; if (window_valid) { if ((window = malloc(sizeof(NPWindow))) == NULL) return RPC_ERROR_NO_MEMORY; if ((error = do_recv_NPWindowData(message, window)) < 0) { free(window); return error; } if (window_p) window_p = window; } return RPC_ERROR_NO_ERROR; } / * Process NPEvent objects / // XXX: those are not real XEvent generated by the X server, i.e. some // fields can be optimized out, which is what Firefox does static bool is_valid_NPEvent_type(NPEvent event) { switch (event->type) { case GraphicsExpose: case FocusIn: case FocusOut: case EnterNotify: case LeaveNotify: case MotionNotify: case ButtonPress: case ButtonRelease: case KeyPress: case KeyRelease: return true; default: break; } return false; } static int do_send_XAnyEvent(rpc_message_t message, XEvent xevent) { int error; if ((error = rpc_message_send_uint32(message, xevent->xany.serial)) < 0) return error; if ((error = rpc_message_send_uint32(message, xevent->xany.send_event)) < 0) return error; if ((error = rpc_message_send_uint32(message, xevent->xany.window)) < 0) return error; return RPC_ERROR_NO_ERROR; } static int do_send_XGraphicsExposeEvent(rpc_message_t message, XEvent xevent) { int error; if ((error = do_send_XAnyEvent(message, xevent)) < 0) return error; if ((error = rpc_message_send_int32(message, xevent->xgraphicsexpose.x)) < 0) return error; if ((error = rpc_message_send_int32(message, xevent->xgraphicsexpose.y)) < 0) return error; if ((error = rpc_message_send_uint32(message, xevent->xgraphicsexpose.width)) < 0) return error; if ((error = rpc_message_send_uint32(message, xevent->xgraphicsexpose.height)) < 0) return error; return RPC_ERROR_NO_ERROR; } static int do_send_XFocusChangeEvent(rpc_message_t message, XEvent xevent) { return RPC_ERROR_NO_ERROR; } static int do_send_XCrossingEvent(rpc_message_t message, XEvent xevent) { int error; if ((error = do_send_XAnyEvent(message, xevent)) < 0) return error; if ((error = rpc_message_send_uint32(message, xevent->xcrossing.root)) < 0) return error; if ((error = rpc_message_send_uint32(message, xevent->xcrossing.subwindow)) < 0) return error; if ((error = rpc_message_send_uint32(message, xevent->xcrossing.time)) < 0) return error; if ((error = rpc_message_send_int32(message, xevent->xcrossing.x)) < 0) return error; if ((error = rpc_message_send_int32(message, xevent->xcrossing.y)) < 0) return error; if ((error = rpc_message_send_int32(message, xevent->xcrossing.x_root)) < 0) return error; if ((error = rpc_message_send_int32(message, xevent->xcrossing.y_root)) < 0) return error; if ((error = rpc_message_send_int32(message, xevent->xcrossing.mode)) < 0) return error; if ((error = rpc_message_send_int32(message, xevent->xcrossing.detail)) < 0) return error; if ((error = rpc_message_send_int32(message, xevent->xcrossing.same_screen)) < 0) return error; if ((error = rpc_message_send_int32(message, xevent->xcrossing.focus)) < 0) return error; if ((error = rpc_message_send_uint32(message, xevent->xcrossing.state)) < 0) return error; return RPC_ERROR_NO_ERROR; } static int do_send_XMotionEvent(rpc_message_t message, XEvent xevent) { int error; if ((error = do_send_XAnyEvent(message, xevent)) < 0) return error; if ((error = rpc_message_send_uint32(message, xevent->xmotion.root)) < 0) return error; if ((error = rpc_message_send_uint32(message, xevent->xmotion.subwindow)) < 0) return error; if ((error = rpc_message_send_uint32(message, xevent->xmotion.time)) < 0) return error; if ((error = rpc_message_send_int32(message, xevent->xmotion.x)) < 0) return error; if ((error = rpc_message_send_int32(message, xevent->xmotion.y)) < 0) return error; if ((error = rpc_message_send_int32(message, xevent->xmotion.x_root)) < 0) return error; if ((error = rpc_message_send_int32(message, xevent->xmotion.y_root)) < 0) return error; if ((error = rpc_message_send_uint32(message, xevent->xmotion.state)) < 0) return error; if ((error = rpc_message_send_char(message, xevent->xmotion.is_hint)) < 0) return error; if ((error = rpc_message_send_int32(message, xevent->xmotion.same_screen)) < 0) return error; return RPC_ERROR_NO_ERROR; } static int do_send_XButtonEvent(rpc_message_t message, XEvent xevent) { int error; if ((error = do_send_XAnyEvent(message, xevent)) < 0) return error; if ((error = rpc_message_send_uint32(message, xevent->xbutton.root)) < 0) return error; if ((error = rpc_message_send_uint32(message, xevent->xbutton.subwindow)) < 0) return error; if ((error = rpc_message_send_uint32(message, xevent->xbutton.time)) < 0) return error; if ((error = rpc_message_send_int32(message, xevent->xbutton.x)) < 0) return error; if ((error = rpc_message_send_int32(message, xevent->xbutton.y)) < 0) return error; if ((error = rpc_message_send_int32(message, xevent->xbutton.x_root)) < 0) return error; if ((error = rpc_message_send_int32(message, xevent->xbutton.y_root)) < 0) return error; if ((error = rpc_message_send_uint32(message, xevent->xbutton.state)) < 0) return error; if ((error = rpc_message_send_uint32(message, xevent->xbutton.button)) < 0) return error; if ((error = rpc_message_send_int32(message, xevent->xbutton.same_screen)) < 0) return error; return RPC_ERROR_NO_ERROR; } static int do_send_XKeyEvent(rpc_message_t message, XEvent xevent) { int error; if ((error = do_send_XAnyEvent(message, xevent)) < 0) return error; if ((error = rpc_message_send_uint32(message, xevent->xkey.root)) < 0) return error; if ((error = rpc_message_send_uint32(message, xevent->xkey.subwindow)) < 0) return error; if ((error = rpc_message_send_uint32(message, xevent->xkey.time)) < 0) return error; if ((error = rpc_message_send_int32(message, xevent->xkey.x)) < 0) return error; if ((error = rpc_message_send_int32(message, xevent->xkey.y)) < 0) return error; if ((error = rpc_message_send_int32(message, xevent->xkey.x_root)) < 0) return error; if ((error = rpc_message_send_int32(message, xevent->xkey.y_root)) < 0) return error; if ((error = rpc_message_send_uint32(message, xevent->xkey.state)) < 0) return error; if ((error = rpc_message_send_uint32(message, xevent->xkey.keycode)) < 0) return error; if ((error = rpc_message_send_int32(message, xevent->xkey.same_screen)) < 0) return error; return RPC_ERROR_NO_ERROR; } static int do_send_NPEvent(rpc_message_t message, void p_value) { NPEvent event = (NPEvent )p_value; int error; if (event == NULL \|\| !is_valid_NPEvent_type(event)) return RPC_ERROR_MESSAGE_ARGUMENT_INVALID; if ((error = rpc_message_send_int32(message, event->type)) < 0) return error; switch (event->type) { case GraphicsExpose: if ((error = do_send_XGraphicsExposeEvent(message, event)) < 0) return error; break; case FocusIn: case FocusOut: if ((error = do_send_XFocusChangeEvent(message, event)) < 0) return error; break; case EnterNotify: case LeaveNotify: if ((error = do_send_XCrossingEvent(message, event)) < 0) return error; break; case MotionNotify: if ((error = do_send_XMotionEvent(message, event)) < 0) return error; break; case ButtonPress: case ButtonRelease: if ((error = do_send_XButtonEvent(message, event)) < 0) return error; break; case KeyPress: case KeyRelease: if ((error = do_send_XKeyEvent(message, event)) < 0) return error; break; default: return RPC_ERROR_GENERIC; } return RPC_ERROR_NO_ERROR; } static int do_recv_XAnyEvent(rpc_message_t message, XEvent xevent) { uint32_t serial, send_event, window; int error; if ((error = rpc_message_recv_uint32(message, &serial)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &send_event)) < 0) return error; // display shall be filled in by the plugin if ((error = rpc_message_recv_uint32(message, &window)) < 0) return error; xevent->xany.serial = serial; xevent->xany.send_event = send_event; xevent->xany.window = window; return RPC_ERROR_NO_ERROR; } static int do_recv_XGraphicsExposeEvent(rpc_message_t message, XEvent xevent) { int32_t x, y; uint32_t width, height; int error; if ((error = do_recv_XAnyEvent(message, xevent)) < 0) return error; if ((error = rpc_message_recv_int32(message, &x)) < 0) return error; if ((error = rpc_message_recv_int32(message, &y)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &width)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &height)) < 0) return error; xevent->xgraphicsexpose.x = x; xevent->xgraphicsexpose.y = y; xevent->xgraphicsexpose.width = width; xevent->xgraphicsexpose.height = height; return RPC_ERROR_NO_ERROR; } static int do_recv_XFocusChangeEvent(rpc_message_t message, XEvent xevent) { return RPC_ERROR_NO_ERROR; } static int do_recv_XCrossingEvent(rpc_message_t message, XEvent xevent) { int32_t x, y, x_root, y_root, mode, detail, same_screen, focus; uint32_t root, subwindow, time, state; int error; if ((error = do_recv_XAnyEvent(message, xevent)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &root)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &subwindow)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &time)) < 0) return error; if ((error = rpc_message_recv_int32(message, &x)) < 0) return error; if ((error = rpc_message_recv_int32(message, &y)) < 0) return error; if ((error = rpc_message_recv_int32(message, &x_root)) < 0) return error; if ((error = rpc_message_recv_int32(message, &y_root)) < 0) return error; if ((error = rpc_message_recv_int32(message, &mode)) < 0) return error; if ((error = rpc_message_recv_int32(message, &detail)) < 0) return error; if ((error = rpc_message_recv_int32(message, &same_screen)) < 0) return error; if ((error = rpc_message_recv_int32(message, &focus)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &state)) < 0) return error; xevent->xcrossing.root = root; xevent->xcrossing.subwindow = subwindow; xevent->xcrossing.time = time; xevent->xcrossing.x = x; xevent->xcrossing.y = y; xevent->xcrossing.x_root = x_root; xevent->xcrossing.y_root = y_root; xevent->xcrossing.mode = mode; xevent->xcrossing.detail = detail; xevent->xcrossing.same_screen = same_screen; xevent->xcrossing.focus = focus; xevent->xcrossing.state = state; return RPC_ERROR_NO_ERROR; } static int do_recv_XMotionEvent(rpc_message_t message, XEvent xevent) { char is_hint; int32_t x, y, x_root, y_root, same_screen; uint32_t root, subwindow, time, state; int error; if ((error = do_recv_XAnyEvent(message, xevent)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &root)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &subwindow)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &time)) < 0) return error; if ((error = rpc_message_recv_int32(message, &x)) < 0) return error; if ((error = rpc_message_recv_int32(message, &y)) < 0) return error; if ((error = rpc_message_recv_int32(message, &x_root)) < 0) return error; if ((error = rpc_message_recv_int32(message, &y_root)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &state)) < 0) return error; if ((error = rpc_message_recv_char(message, &is_hint)) < 0) return error; if ((error = rpc_message_recv_int32(message, &same_screen)) < 0) return error; xevent->xmotion.root = root; xevent->xmotion.subwindow = subwindow; xevent->xmotion.time = time; xevent->xmotion.x = x; xevent->xmotion.y = y; xevent->xmotion.x_root = x_root; xevent->xmotion.y_root = y_root; xevent->xmotion.state = state; xevent->xmotion.is_hint = is_hint; xevent->xmotion.same_screen = same_screen; return RPC_ERROR_NO_ERROR; } static int do_recv_XButtonEvent(rpc_message_t message, XEvent xevent) { int32_t x, y, x_root, y_root, same_screen; uint32_t root, subwindow, time, state, button; int error; if ((error = do_recv_XAnyEvent(message, xevent)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &root)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &subwindow)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &time)) < 0) return error; if ((error = rpc_message_recv_int32(message, &x)) < 0) return error; if ((error = rpc_message_recv_int32(message, &y)) < 0) return error; if ((error = rpc_message_recv_int32(message, &x_root)) < 0) return error; if ((error = rpc_message_recv_int32(message, &y_root)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &state)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &button)) < 0) return error; if ((error = rpc_message_recv_int32(message, &same_screen)) < 0) return error; xevent->xbutton.root = root; xevent->xbutton.subwindow = subwindow; xevent->xbutton.time = time; xevent->xbutton.x = x; xevent->xbutton.y = y; xevent->xbutton.x_root = x_root; xevent->xbutton.y_root = y_root; xevent->xbutton.state = state; xevent->xbutton.button = button; xevent->xbutton.same_screen = same_screen; return RPC_ERROR_NO_ERROR; } static int do_recv_XKeyEvent(rpc_message_t message, XEvent xevent) { int32_t x, y, x_root, y_root, same_screen; uint32_t root, subwindow, time, state, keycode; int error; if ((error = do_recv_XAnyEvent(message, xevent)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &root)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &subwindow)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &time)) < 0) return error; if ((error = rpc_message_recv_int32(message, &x)) < 0) return error; if ((error = rpc_message_recv_int32(message, &y)) < 0) return error; if ((error = rpc_message_recv_int32(message, &x_root)) < 0) return error; if ((error = rpc_message_recv_int32(message, &y_root)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &state)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &keycode)) < 0) return error; if ((error = rpc_message_recv_int32(message, &same_screen)) < 0) return error; xevent->xkey.root = root; xevent->xkey.subwindow = subwindow; xevent->xkey.time = time; xevent->xkey.x = x; xevent->xkey.y = y; xevent->xkey.x_root = x_root; xevent->xkey.y_root = y_root; xevent->xkey.state = state; xevent->xkey.keycode = keycode; xevent->xkey.same_screen = same_screen; return RPC_ERROR_NO_ERROR; } static int do_recv_NPEvent(rpc_message_t message, void p_value) { NPEvent event = (NPEvent )p_value; int32_t event_type; int error; if ((error = rpc_message_recv_int32(message, &event_type)) < 0) return error; memset(event, 0, sizeof(event)); event->type = event_type; switch (event->type) { case GraphicsExpose: if ((error = do_recv_XGraphicsExposeEvent(message, event)) < 0) return error; break; case FocusIn: case FocusOut: if ((error = do_recv_XFocusChangeEvent(message, event)) < 0) return error; break; case EnterNotify: case LeaveNotify: if ((error = do_recv_XCrossingEvent(message, event)) < 0) return error; break; case MotionNotify: if ((error = do_recv_XMotionEvent(message, event)) < 0) return error; break; case ButtonPress: case ButtonRelease: if ((error = do_recv_XButtonEvent(message, event)) < 0) return error; break; case KeyPress: case KeyRelease: if ((error = do_recv_XKeyEvent(message, event)) < 0) return error; break; default: return RPC_ERROR_GENERIC; } return RPC_ERROR_NO_ERROR; } / * Process NPFullPrint objects / static int do_send_NPFullPrint(rpc_message_t message, void p_value) { NPFullPrint fullPrint = (NPFullPrint )p_value; int error; if ((error = rpc_message_send_uint32(message, fullPrint->pluginPrinted)) < 0) return error; if ((error = rpc_message_send_uint32(message, fullPrint->printOne)) < 0) return error; return RPC_ERROR_NO_ERROR; } static int do_recv_NPFullPrint(rpc_message_t message, void p_value) { NPFullPrint fullPrint = (NPFullPrint )p_value; uint32_t pluginPrinted, printOne; int error; if ((error = rpc_message_recv_uint32(message, &pluginPrinted)) < 0) return error; if ((error = rpc_message_recv_uint32(message, &printOne)) < 0) return error; fullPrint->pluginPrinted = pluginPrinted; fullPrint->printOne = printOne; fullPrint->platformPrint = NULL; // to be filled in by the plugin return RPC_ERROR_NO_ERROR; } / * Process NPEmbedPrint objects / static int do_send_NPEmbedPrint(rpc_message_t message, void p_value) { NPEmbedPrint embedPrint = (NPEmbedPrint )p_value; int error; if ((error = do_send_NPWindowData(message, &embedPrint->window)) < 0) return error; return RPC_ERROR_NO_ERROR; } static int do_recv_NPEmbedPrint(rpc_message_t message, void p_value) { NPEmbedPrint embedPrint = (NPEmbedPrint )p_value; int error; if ((error = do_recv_NPWindowData(message, &embedPrint->window)) < 0) return error; embedPrint->platformPrint = NULL; // to be filled in by the plugin return RPC_ERROR_NO_ERROR; } / * Process NPPrint objects / static int do_send_NPPrint(rpc_message_t message, void p_value) { NPPrint printInfo = (NPPrint )p_value; int error; if ((error = rpc_message_send_uint32(message, printInfo->mode)) < 0) return error; switch (printInfo->mode) { case NP_FULL: if ((error = do_send_NPFullPrint(message, &printInfo->print.fullPrint)) < 0) return error; break; case NP_EMBED: if ((error = do_send_NPEmbedPrint(message, &printInfo->print.embedPrint)) < 0) return error; break; default: return RPC_ERROR_GENERIC; } return RPC_ERROR_NO_ERROR; } static int do_recv_NPPrint(rpc_message_t message, void p_value) { NPPrint printInfo = (NPPrint )p_value; uint32_t print_mode; int error; if ((error = rpc_message_recv_uint32(message, &print_mode)) < 0) return error; switch (print_mode) { case NP_FULL: if ((error = do_recv_NPFullPrint(message, &printInfo->print.fullPrint)) < 0) return error; break; case NP_EMBED: if ((error = do_recv_NPEmbedPrint(message, &printInfo->print.embedPrint)) < 0) return error; break; default: return RPC_ERROR_GENERIC; } printInfo->mode = print_mode; return RPC_ERROR_NO_ERROR; } / * Process NPPrintData objects / static int do_send_NPPrintData(rpc_message_t message, void p_value) { NPPrintData printData = (NPPrintData )p_value; int error; if ((error = rpc_message_send_uint32(message, printData->size)) < 0) return error; if ((error = rpc_message_send_bytes(message, printData->data, printData->size)) < 0) return error; return RPC_ERROR_NO_ERROR; } static int do_recv_NPPrintData(rpc_message_t message, void p_value) { NPPrintData printData = (NPPrintData )p_value; int error; if ((error = rpc_message_recv_uint32(message, &printData->size)) < 0) return error; if ((error = rpc_message_recv_bytes(message, printData->data, printData->size)) < 0) return error; return RPC_ERROR_NO_ERROR; } / * Process NPObject objects / static int do_send_NPObject(rpc_message_t message, void p_value) { uint32_t npobj_id = 0; NPObject npobj = (NPObject )p_value; if (npobj) { NPObjectInfo npobj_info = npobject_info_lookup(npobj); if (npobj_info) npobj_id = npobj_info->npobj_id; #ifdef BUILD_WRAPPER else { // create a new mapping (browser-side) if ((npobj_info = npobject_info_new(npobj)) == NULL) return RPC_ERROR_NO_MEMORY; npobj_id = npobj_info->npobj_id; npobject_associate(npobj, npobj_info); } #endif assert(npobj_id != 0); } int error = rpc_message_send_uint32(message, npobj_id); if (error < 0) return error; #ifdef BUILD_WRAPPER // synchronize referenceCount if (npobj) { if ((error = rpc_message_send_uint32(message, npobj->referenceCount)) < 0) return error; } #endif return RPC_ERROR_NO_ERROR; } static int do_recv_NPObject(rpc_message_t message, void p_value) { int error; uint32_t npobj_id; if ((error = rpc_message_recv_uint32(message, &npobj_id)) < 0) return error; NPObject npobj = NULL; if (npobj_id) { npobj = npobject_lookup(npobj_id); #ifdef BUILD_VIEWER // create a new mapping (plugin-side) if (npobj == NULL) { if ((npobj = npobject_new(npobj_id, NULL, NULL)) == NULL) return RPC_ERROR_NO_MEMORY; } #endif assert(npobj != NULL); #ifdef BUILD_VIEWER // synchronize referenceCount uint32_t referenceCount; if ((error = rpc_message_recv_uint32(message, &referenceCount)) < 0) return error; if (npobj->referenceCount != referenceCount) { D(bug("synchronize NPObject::referenceCount (%d -> %d)\n", npobj->referenceCount, referenceCount)); npobj->referenceCount = referenceCount; } #endif } ((NPObject *)p_value) = npobj; return RPC_ERROR_NO_ERROR; } / * Process NPIdentifier objects / // Rationale: NPIdentifiers are allocated on the browser side // only. IDs are passed through to the viewer, and they have no // meaning on that side as they are only used to get passed back to // the browser side static int do_send_NPIdentifier(rpc_message_t message, void p_value) { NPIdentifier ident = (NPIdentifier )p_value; int id = 0; if (ident) { #ifdef BUILD_WRAPPER id = id_lookup_value(ident); if (id < 0) id = id_create(ident); #endif #ifdef BUILD_VIEWER id = (uintptr_t)ident; #endif assert(id != 0); } return rpc_message_send_uint32(message, id); } static int do_recv_NPIdentifier(rpc_message_t message, void p_value) { int error; uint32_t id; if ((error = rpc_message_recv_uint32(message, &id)) < 0) return error; NPIdentifier ident = NULL; if (id) { #ifdef BUILD_WRAPPER ident = id_lookup(id); #endif #ifdef BUILD_VIEWER ident = (void )(uintptr_t)id; #endif assert(ident != NULL); } ((NPIdentifier )p_value) = ident; return RPC_ERROR_NO_ERROR; } /* * Process NPUTF8 strings / static int do_send_NPUTF8(rpc_message_t message, void p_value) { NPUTF8 string = (NPUTF8 )p_value; if (string == NULL) return RPC_ERROR_MESSAGE_ARGUMENT_INVALID; int len = strlen(string) + 1; int error = rpc_message_send_uint32(message, len); if (error < 0) return error; if (len > 0) return rpc_message_send_bytes(message, (unsigned char )string, len); return RPC_ERROR_NO_ERROR; } static int do_recv_NPUTF8(rpc_message_t message, void p_value) { NPUTF8 string_p = (NPUTF8 )p_value; NPUTF8 string = NULL; uint32_t len; int error = rpc_message_recv_uint32(message, &len); if (error < 0) return error; if ((string = NPN_MemAlloc(len)) == NULL) return RPC_ERROR_NO_MEMORY; if (len > 0) { if ((error = rpc_message_recv_bytes(message, (unsigned char )string, len)) < 0) return error; } if (string_p) string_p = string; else if (string) NPN_MemFree(string); return RPC_ERROR_NO_ERROR; } / * Process NPString objects / static int do_send_NPString(rpc_message_t message, void p_value) { NPString string = (NPString )p_value; if (string == NULL) return RPC_ERROR_MESSAGE_ARGUMENT_INVALID; int error = rpc_message_send_uint32(message, string->UTF8Length); if (error < 0) return error; if (string->UTF8Length && string->UTF8Characters) return rpc_message_send_bytes(message, (unsigned char )string->UTF8Characters, string->UTF8Length); return RPC_ERROR_NO_ERROR; } static int do_recv_NPString(rpc_message_t message, void p_value) { NPString string = (NPString )p_value; if (string == NULL) return RPC_ERROR_MESSAGE_ARGUMENT_INVALID; string->UTF8Length = 0; string->UTF8Characters = NULL; int error = rpc_message_recv_uint32(message, &string->UTF8Length); if (error < 0) return error; if ((string->UTF8Characters = NPN_MemAlloc(string->UTF8Length + 1)) == NULL) return RPC_ERROR_NO_MEMORY; if (string->UTF8Length > 0) { if ((error = rpc_message_recv_bytes(message, (unsigned char )string->UTF8Characters, string->UTF8Length)) < 0) return error; } ((char )string->UTF8Characters)[string->UTF8Length] = '\0'; return RPC_ERROR_NO_ERROR; } /* * Process NPVariant objects / static int do_send_NPVariant(rpc_message_t message, void p_value) { NPVariant variant = (NPVariant )p_value; if (variant == NULL) return RPC_ERROR_MESSAGE_ARGUMENT_INVALID; int error = rpc_message_send_uint32(message, variant->type); if (error < 0) return error; switch (variant->type) { case NPVariantType_Void: case NPVariantType_Null: // nothing to do (initialized in receiver) break; case NPVariantType_Bool: if ((error = rpc_message_send_uint32(message, variant->value.boolValue)) < 0) return error; break; case NPVariantType_Int32: if ((error = rpc_message_send_int32(message, variant->value.intValue)) < 0) return error; break; case NPVariantType_Double: if ((error = rpc_message_send_double(message, variant->value.doubleValue)) < 0) return error; break; case NPVariantType_String: if ((error = do_send_NPString(message, &variant->value.stringValue)) < 0) return error; break; case NPVariantType_Object: if (NPW_IS_BROWSER) { / Note: when we pass an NPObject to the plugin, it's supposed to be released once it's done with processing the RPC args. i.e. NPN_ReleaseVariantValue() is called for any NPVariant we received through rpc_method_get_args(). / NPN_RetainObject(variant->value.objectValue); } if ((error = do_send_NPObject(message, variant->value.objectValue)) < 0) return error; break; } return RPC_ERROR_NO_ERROR; } static int do_recv_NPVariant(rpc_message_t message, void p_value) { NPVariant variant = (NPVariant )p_value; if (variant) VOID_TO_NPVARIANT(variant); uint32_t type; int error = rpc_message_recv_uint32(message, &type); if (error < 0) return error; NPVariant result; VOID_TO_NPVARIANT(result); switch (type) { case NPVariantType_Void: VOID_TO_NPVARIANT(result); break; case NPVariantType_Null: NULL_TO_NPVARIANT(result); break; case NPVariantType_Bool: { uint32_t value; if ((error = rpc_message_recv_uint32(message, &value)) < 0) return error; result.value.boolValue = value; break; } case NPVariantType_Int32: if ((error = rpc_message_recv_int32(message, &result.value.intValue)) < 0) return error; break; case NPVariantType_Double: if ((error = rpc_message_recv_double(message, &result.value.doubleValue)) < 0) return error; break; case NPVariantType_String: if ((error = do_recv_NPString(message, &result.value.stringValue)) < 0) return error; break; case NPVariantType_Object: if ((error = do_recv_NPObject(message, &result.value.objectValue)) < 0) return error; if (NPW_IS_BROWSER) { /* Note: it's not necessary to propagate the refcount back to the plugin-side since the object will be unref'ed through NPN_ReleaseVariantValue() once we are done with processing the RPC args. / NPN_RetainObject(result.value.objectValue); } break; } if (variant) { variant = result; variant->type = type; } return RPC_ERROR_NO_ERROR; } /* * Initialize marshalers for NPAPI types / static const rpc_message_descriptor_t message_descs[] = { { RPC_TYPE_NPP, sizeof(NPP), do_send_NPP, do_recv_NPP }, { RPC_TYPE_NPW_PLUGIN_INSTANCE, sizeof(NPW_PluginInstance ), do_send_NPW_PluginInstance, do_recv_NPW_PluginInstance }, { RPC_TYPE_NP_STREAM, sizeof(NPStream ), do_send_NPStream, do_recv_NPStream }, { RPC_TYPE_NP_BYTE_RANGE, sizeof(NPByteRange ), do_send_NPByteRange, do_recv_NPByteRange }, { RPC_TYPE_NP_SAVED_DATA, sizeof(NPSavedData ), do_send_NPSavedData, do_recv_NPSavedData }, { RPC_TYPE_NP_NOTIFY_DATA, sizeof(void ), do_send_NotifyData, do_recv_NotifyData }, { RPC_TYPE_NP_RECT, sizeof(NPRect), do_send_NPRect, do_recv_NPRect }, { RPC_TYPE_NP_WINDOW, sizeof(NPWindow ), do_send_NPWindow, do_recv_NPWindow }, { RPC_TYPE_NP_EVENT, sizeof(NPEvent), do_send_NPEvent, do_recv_NPEvent }, { RPC_TYPE_NP_PRINT, sizeof(NPPrint), do_send_NPPrint, do_recv_NPPrint }, { RPC_TYPE_NP_FULL_PRINT, sizeof(NPFullPrint), do_send_NPFullPrint, do_recv_NPFullPrint }, { RPC_TYPE_NP_EMBED_PRINT, sizeof(NPEmbedPrint), do_send_NPEmbedPrint, do_recv_NPEmbedPrint }, { RPC_TYPE_NP_PRINT_DATA, sizeof(NPPrintData), do_send_NPPrintData, do_recv_NPPrintData }, { RPC_TYPE_NP_OBJECT, sizeof(NPObject ), do_send_NPObject, do_recv_NPObject }, { RPC_TYPE_NP_IDENTIFIER, sizeof(NPIdentifier), do_send_NPIdentifier, do_recv_NPIdentifier }, { RPC_TYPE_NP_UTF8, sizeof(NPUTF8 ), do_send_NPUTF8, do_recv_NPUTF8 }, { RPC_TYPE_NP_STRING, sizeof(NPString), do_send_NPString, do_recv_NPString }, { RPC_TYPE_NP_VARIANT, sizeof(NPVariant), do_send_NPVariant, do_recv_NPVariant } }; int rpc_add_np_marshalers(rpc_connection_t connection) { return rpc_connection_add_message_descriptors(connection, message_descs, sizeof(message_descs) / sizeof(message_descs[0])); }	./CrossVul/dataset_final_sorted/CWE-264/c/good_3470_0
crossvul-cpp_data_good_2182_0	/* * Copyright (C) 2012 Daiki Ueno <ueno@unixuser.org> * Copyright (C) 2012 Red Hat, Inc. * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see <http://www.gnu.org/licenses/>. / #include "private.h" #include <sys/types.h> #include <sys/socket.h> #include <sys/un.h> #include <string.h> #include <stdlib.h> #include <stddef.h> / offsetof / #include <assert.h> static char create_socket_name (const char template) { char name, p; size_t len; / Prepend the tmp directory to the template. / p = getenv ("TMPDIR"); if (!p \|\| !p) p = "/tmp"; len = strlen (p) + strlen (template) + 2; name = xcharalloc (len); memset (name, 0, len); memcpy (name, p, strlen (p)); if (p[strlen (p) - 1] != '/') name = strcat (name, "/"); name = strcat (name, template); p = strrchr (name, '/'); p = '\0'; if (!mkdtemp (name)) { free (name); return NULL; } p = '/'; return name; } static void remove_control_socket (const char path) { char _path = xstrdup (path), p; unlink (_path); p = strrchr (_path, '/'); assert (p != NULL); p = '\0'; rmdir (_path); free (_path); } int _fep_open_control_socket (Fep fep) { struct sockaddr_un sun; char path; int fd; ssize_t sun_len; fd = socket (AF_UNIX, SOCK_STREAM, 0); if (fd < 0) { perror ("socket"); return -1; } path = create_socket_name ("fep-XXXXXX/control"); if (strlen (path) + 1 >= sizeof(sun.sun_path)) { fep_log (FEP_LOG_LEVEL_WARNING, "unix domain socket path too long: %d + 1 >= %d", strlen (path), sizeof (sun.sun_path)); free (path); return -1; } memset (&sun, 0, sizeof(sun)); sun.sun_family = AF_UNIX; memcpy (sun.sun_path, path, strlen (path)); sun_len = sizeof (struct sockaddr_un); if (bind (fd, (const struct sockaddr ) &sun, sun_len) < 0) { perror ("bind"); free (path); close (fd); return -1; } if (listen (fd, 5) < 0) { perror ("listen"); free (path); close (fd); return -1; } fep->server = fd; fep->control_socket_path = path; return 0; } void _fep_close_control_socket (Fep fep) { if (fep->server >= 0) close (fep->server); remove_control_socket (fep->control_socket_path); free (fep->control_socket_path); } static void command_set_cursor_text (Fep fep, FepControlMessage request) { FepAttribute attr; if (_fep_control_message_read_attribute_arg (request, 1, &attr) == 0) _fep_output_cursor_text (fep, request->args[0].str, &attr); } static void command_set_status_text (Fep fep, FepControlMessage request) { FepAttribute attr; if (_fep_control_message_read_attribute_arg (request, 1, &attr) == 0) _fep_output_status_text (fep, request->args[0].str, &attr); } static void command_send_text (Fep fep, FepControlMessage request) { _fep_output_send_text (fep, request->args[0].str); } static void command_send_data (Fep fep, FepControlMessage request) { ssize_t total = 0; while (total < request->args[0].len) { ssize_t bytes_sent = _fep_output_send_data (fep, request->args[0].str + total, request->args[0].len - total); if (bytes_sent < 0) break; total += bytes_sent; } } static void command_forward_key_event (Fep fep, FepControlMessage request) { uint32_t keyval, modifiers; if (_fep_control_message_read_uint32_arg (request, 0, &keyval) == 0 && _fep_control_message_read_uint32_arg (request, 1, &modifiers) == 0) { size_t length; char data = _fep_key_to_string (keyval, modifiers, &length); if (data) { _fep_output_send_data (fep, data, length); free (data); } } } int _fep_read_control_message_from_fd (Fep fep, int fd, FepControlMessage message) { int i; if (_fep_read_control_message (fd, message) < 0) { for (i = 0; i < fep->n_clients; i++) if (fep->clients[i] == fd) { close (fd); if (i + 1 < fep->n_clients) memmove (&fep->clients[i], &fep->clients[i + 1], fep->n_clients - (i + 1)); fep->clients[--fep->n_clients] = -1; break; } return -1; } return 0; } int _fep_dispatch_control_message (Fep fep, FepControlMessage message) { static const struct { int command; void (handler) (Fep fep, FepControlMessage request); } handlers[] = { { FEP_CONTROL_SET_CURSOR_TEXT, command_set_cursor_text }, { FEP_CONTROL_SET_STATUS_TEXT, command_set_status_text }, { FEP_CONTROL_SEND_TEXT, command_send_text }, { FEP_CONTROL_SEND_DATA, command_send_data }, { FEP_CONTROL_FORWARD_KEY_EVENT, command_forward_key_event } }; int i; for (i = 0; i < SIZEOF (handlers) && handlers[i].command != message->command; i++) ; if (i == SIZEOF (handlers)) { fep_log (FEP_LOG_LEVEL_WARNING, "no handler defined for %d", message->command); return -1; } handlers[i].handler (fep, message); return 0; } int _fep_transceive_control_message (Fep fep, int fd, FepControlMessage request, FepControlMessage response) { FepList messages = NULL; int retval = 0; retval = _fep_write_control_message (fd, request); if (retval < 0) return retval; while (true) { FepControlMessage message; retval = _fep_read_control_message (fd, &message); if (retval < 0) goto out; if (message.command == FEP_CONTROL_RESPONSE) { memcpy (response, &message, sizeof (FepControlMessage)); break; } fep_log (FEP_LOG_LEVEL_DEBUG, "not a control response %d", message.command); messages = _fep_append_control_message (messages, &message); } if (response->n_args == 0) { _fep_control_message_free_args (response); fep_log (FEP_LOG_LEVEL_WARNING, "too few arguments for RESPONSE"); retval = -1; goto out; } if (response->args[0].len != 1) { _fep_control_message_free_args (response); fep_log (FEP_LOG_LEVEL_WARNING, "can't extract command from RESPONSE"); retval = -1; goto out; } if (response->args[0].str != request->command) { _fep_control_message_free_args (response); fep_log (FEP_LOG_LEVEL_WARNING, "commands do not match (%d != %d)", response->args[0].str, request->command); retval = -1; goto out; } out: /* flush queued messages received during waiting for response / while (messages) { FepList _head = messages; FepControlMessage *_message = _head->data; messages = _head->next; _fep_dispatch_control_message (fep, _message); _fep_control_message_free (_message); free (_head); } return retval; }	./CrossVul/dataset_final_sorted/CWE-264/c/good_2182_0
crossvul-cpp_data_good_2159_2	/* * Kernel-based Virtual Machine driver for Linux * * This module enables machines with Intel VT-x extensions to run virtual * machines without emulation or binary translation. * * Copyright (C) 2006 Qumranet, Inc. * Copyright 2010 Red Hat, Inc. and/or its affiliates. * * Authors: * Avi Kivity <avi@qumranet.com> * Yaniv Kamay <yaniv@qumranet.com> * * This work is licensed under the terms of the GNU GPL, version 2. See * the COPYING file in the top-level directory. * / #include "irq.h" #include "mmu.h" #include "cpuid.h" #include <linux/kvm_host.h> #include <linux/module.h> #include <linux/kernel.h> #include <linux/mm.h> #include <linux/highmem.h> #include <linux/sched.h> #include <linux/moduleparam.h> #include <linux/mod_devicetable.h> #include <linux/ftrace_event.h> #include <linux/slab.h> #include <linux/tboot.h> #include <linux/hrtimer.h> #include "kvm_cache_regs.h" #include "x86.h" #include <asm/io.h> #include <asm/desc.h> #include <asm/vmx.h> #include <asm/virtext.h> #include <asm/mce.h> #include <asm/i387.h> #include <asm/xcr.h> #include <asm/perf_event.h> #include <asm/debugreg.h> #include <asm/kexec.h> #include "trace.h" #define __ex(x) __kvm_handle_fault_on_reboot(x) #define __ex_clear(x, reg) \ ____kvm_handle_fault_on_reboot(x, "xor " reg " , " reg) MODULE_AUTHOR("Qumranet"); MODULE_LICENSE("GPL"); static const struct x86_cpu_id vmx_cpu_id[] = { X86_FEATURE_MATCH(X86_FEATURE_VMX), {} }; MODULE_DEVICE_TABLE(x86cpu, vmx_cpu_id); static bool __read_mostly enable_vpid = 1; module_param_named(vpid, enable_vpid, bool, 0444); static bool __read_mostly flexpriority_enabled = 1; module_param_named(flexpriority, flexpriority_enabled, bool, S_IRUGO); static bool __read_mostly enable_ept = 1; module_param_named(ept, enable_ept, bool, S_IRUGO); static bool __read_mostly enable_unrestricted_guest = 1; module_param_named(unrestricted_guest, enable_unrestricted_guest, bool, S_IRUGO); static bool __read_mostly enable_ept_ad_bits = 1; module_param_named(eptad, enable_ept_ad_bits, bool, S_IRUGO); static bool __read_mostly emulate_invalid_guest_state = true; module_param(emulate_invalid_guest_state, bool, S_IRUGO); static bool __read_mostly vmm_exclusive = 1; module_param(vmm_exclusive, bool, S_IRUGO); static bool __read_mostly fasteoi = 1; module_param(fasteoi, bool, S_IRUGO); static bool __read_mostly enable_apicv = 1; module_param(enable_apicv, bool, S_IRUGO); static bool __read_mostly enable_shadow_vmcs = 1; module_param_named(enable_shadow_vmcs, enable_shadow_vmcs, bool, S_IRUGO); / * If nested=1, nested virtualization is supported, i.e., guests may use * VMX and be a hypervisor for its own guests. If nested=0, guests may not * use VMX instructions. / static bool __read_mostly nested = 0; module_param(nested, bool, S_IRUGO); #define KVM_GUEST_CR0_MASK (X86_CR0_NW \| X86_CR0_CD) #define KVM_VM_CR0_ALWAYS_ON_UNRESTRICTED_GUEST (X86_CR0_WP \| X86_CR0_NE) #define KVM_VM_CR0_ALWAYS_ON \ (KVM_VM_CR0_ALWAYS_ON_UNRESTRICTED_GUEST \| X86_CR0_PG \| X86_CR0_PE) #define KVM_CR4_GUEST_OWNED_BITS \ (X86_CR4_PVI \| X86_CR4_DE \| X86_CR4_PCE \| X86_CR4_OSFXSR \ \| X86_CR4_OSXMMEXCPT) #define KVM_PMODE_VM_CR4_ALWAYS_ON (X86_CR4_PAE \| X86_CR4_VMXE) #define KVM_RMODE_VM_CR4_ALWAYS_ON (X86_CR4_VME \| X86_CR4_PAE \| X86_CR4_VMXE) #define RMODE_GUEST_OWNED_EFLAGS_BITS (~(X86_EFLAGS_IOPL \| X86_EFLAGS_VM)) #define VMX_MISC_EMULATED_PREEMPTION_TIMER_RATE 5 / * These 2 parameters are used to config the controls for Pause-Loop Exiting: * ple_gap: upper bound on the amount of time between two successive * executions of PAUSE in a loop. Also indicate if ple enabled. * According to test, this time is usually smaller than 128 cycles. * ple_window: upper bound on the amount of time a guest is allowed to execute * in a PAUSE loop. Tests indicate that most spinlocks are held for * less than 2^12 cycles * Time is measured based on a counter that runs at the same rate as the TSC, * refer SDM volume 3b section 21.6.13 & 22.1.3. / #define KVM_VMX_DEFAULT_PLE_GAP 128 #define KVM_VMX_DEFAULT_PLE_WINDOW 4096 #define KVM_VMX_DEFAULT_PLE_WINDOW_GROW 2 #define KVM_VMX_DEFAULT_PLE_WINDOW_SHRINK 0 #define KVM_VMX_DEFAULT_PLE_WINDOW_MAX \ INT_MAX / KVM_VMX_DEFAULT_PLE_WINDOW_GROW static int ple_gap = KVM_VMX_DEFAULT_PLE_GAP; module_param(ple_gap, int, S_IRUGO); static int ple_window = KVM_VMX_DEFAULT_PLE_WINDOW; module_param(ple_window, int, S_IRUGO); / Default doubles per-vcpu window every exit. / static int ple_window_grow = KVM_VMX_DEFAULT_PLE_WINDOW_GROW; module_param(ple_window_grow, int, S_IRUGO); / Default resets per-vcpu window every exit to ple_window. / static int ple_window_shrink = KVM_VMX_DEFAULT_PLE_WINDOW_SHRINK; module_param(ple_window_shrink, int, S_IRUGO); / Default is to compute the maximum so we can never overflow. / static int ple_window_actual_max = KVM_VMX_DEFAULT_PLE_WINDOW_MAX; static int ple_window_max = KVM_VMX_DEFAULT_PLE_WINDOW_MAX; module_param(ple_window_max, int, S_IRUGO); extern const ulong vmx_return; #define NR_AUTOLOAD_MSRS 8 #define VMCS02_POOL_SIZE 1 struct vmcs { u32 revision_id; u32 abort; char data[0]; }; / * Track a VMCS that may be loaded on a certain CPU. If it is (cpu!=-1), also * remember whether it was VMLAUNCHed, and maintain a linked list of all VMCSs * loaded on this CPU (so we can clear them if the CPU goes down). / struct loaded_vmcs { struct vmcs vmcs; int cpu; int launched; struct list_head loaded_vmcss_on_cpu_link; }; struct shared_msr_entry { unsigned index; u64 data; u64 mask; }; /* * struct vmcs12 describes the state that our guest hypervisor (L1) keeps for a * single nested guest (L2), hence the name vmcs12. Any VMX implementation has * a VMCS structure, and vmcs12 is our emulated VMX's VMCS. This structure is * stored in guest memory specified by VMPTRLD, but is opaque to the guest, * which must access it using VMREAD/VMWRITE/VMCLEAR instructions. * More than one of these structures may exist, if L1 runs multiple L2 guests. * nested_vmx_run() will use the data here to build a vmcs02: a VMCS for the * underlying hardware which will be used to run L2. * This structure is packed to ensure that its layout is identical across * machines (necessary for live migration). * If there are changes in this struct, VMCS12_REVISION must be changed. / typedef u64 natural_width; struct __packed vmcs12 { / According to the Intel spec, a VMCS region must start with the * following two fields. Then follow implementation-specific data. / u32 revision_id; u32 abort; u32 launch_state; / set to 0 by VMCLEAR, to 1 by VMLAUNCH / u32 padding[7]; / room for future expansion / u64 io_bitmap_a; u64 io_bitmap_b; u64 msr_bitmap; u64 vm_exit_msr_store_addr; u64 vm_exit_msr_load_addr; u64 vm_entry_msr_load_addr; u64 tsc_offset; u64 virtual_apic_page_addr; u64 apic_access_addr; u64 ept_pointer; u64 guest_physical_address; u64 vmcs_link_pointer; u64 guest_ia32_debugctl; u64 guest_ia32_pat; u64 guest_ia32_efer; u64 guest_ia32_perf_global_ctrl; u64 guest_pdptr0; u64 guest_pdptr1; u64 guest_pdptr2; u64 guest_pdptr3; u64 guest_bndcfgs; u64 host_ia32_pat; u64 host_ia32_efer; u64 host_ia32_perf_global_ctrl; u64 padding64[8]; / room for future expansion / / * To allow migration of L1 (complete with its L2 guests) between * machines of different natural widths (32 or 64 bit), we cannot have * unsigned long fields with no explict size. We use u64 (aliased * natural_width) instead. Luckily, x86 is little-endian. / natural_width cr0_guest_host_mask; natural_width cr4_guest_host_mask; natural_width cr0_read_shadow; natural_width cr4_read_shadow; natural_width cr3_target_value0; natural_width cr3_target_value1; natural_width cr3_target_value2; natural_width cr3_target_value3; natural_width exit_qualification; natural_width guest_linear_address; natural_width guest_cr0; natural_width guest_cr3; natural_width guest_cr4; natural_width guest_es_base; natural_width guest_cs_base; natural_width guest_ss_base; natural_width guest_ds_base; natural_width guest_fs_base; natural_width guest_gs_base; natural_width guest_ldtr_base; natural_width guest_tr_base; natural_width guest_gdtr_base; natural_width guest_idtr_base; natural_width guest_dr7; natural_width guest_rsp; natural_width guest_rip; natural_width guest_rflags; natural_width guest_pending_dbg_exceptions; natural_width guest_sysenter_esp; natural_width guest_sysenter_eip; natural_width host_cr0; natural_width host_cr3; natural_width host_cr4; natural_width host_fs_base; natural_width host_gs_base; natural_width host_tr_base; natural_width host_gdtr_base; natural_width host_idtr_base; natural_width host_ia32_sysenter_esp; natural_width host_ia32_sysenter_eip; natural_width host_rsp; natural_width host_rip; natural_width paddingl[8]; / room for future expansion / u32 pin_based_vm_exec_control; u32 cpu_based_vm_exec_control; u32 exception_bitmap; u32 page_fault_error_code_mask; u32 page_fault_error_code_match; u32 cr3_target_count; u32 vm_exit_controls; u32 vm_exit_msr_store_count; u32 vm_exit_msr_load_count; u32 vm_entry_controls; u32 vm_entry_msr_load_count; u32 vm_entry_intr_info_field; u32 vm_entry_exception_error_code; u32 vm_entry_instruction_len; u32 tpr_threshold; u32 secondary_vm_exec_control; u32 vm_instruction_error; u32 vm_exit_reason; u32 vm_exit_intr_info; u32 vm_exit_intr_error_code; u32 idt_vectoring_info_field; u32 idt_vectoring_error_code; u32 vm_exit_instruction_len; u32 vmx_instruction_info; u32 guest_es_limit; u32 guest_cs_limit; u32 guest_ss_limit; u32 guest_ds_limit; u32 guest_fs_limit; u32 guest_gs_limit; u32 guest_ldtr_limit; u32 guest_tr_limit; u32 guest_gdtr_limit; u32 guest_idtr_limit; u32 guest_es_ar_bytes; u32 guest_cs_ar_bytes; u32 guest_ss_ar_bytes; u32 guest_ds_ar_bytes; u32 guest_fs_ar_bytes; u32 guest_gs_ar_bytes; u32 guest_ldtr_ar_bytes; u32 guest_tr_ar_bytes; u32 guest_interruptibility_info; u32 guest_activity_state; u32 guest_sysenter_cs; u32 host_ia32_sysenter_cs; u32 vmx_preemption_timer_value; u32 padding32[7]; / room for future expansion / u16 virtual_processor_id; u16 guest_es_selector; u16 guest_cs_selector; u16 guest_ss_selector; u16 guest_ds_selector; u16 guest_fs_selector; u16 guest_gs_selector; u16 guest_ldtr_selector; u16 guest_tr_selector; u16 host_es_selector; u16 host_cs_selector; u16 host_ss_selector; u16 host_ds_selector; u16 host_fs_selector; u16 host_gs_selector; u16 host_tr_selector; }; / * VMCS12_REVISION is an arbitrary id that should be changed if the content or * layout of struct vmcs12 is changed. MSR_IA32_VMX_BASIC returns this id, and * VMPTRLD verifies that the VMCS region that L1 is loading contains this id. / #define VMCS12_REVISION 0x11e57ed0 / * VMCS12_SIZE is the number of bytes L1 should allocate for the VMXON region * and any VMCS region. Although only sizeof(struct vmcs12) are used by the * current implementation, 4K are reserved to avoid future complications. / #define VMCS12_SIZE 0x1000 / Used to remember the last vmcs02 used for some recently used vmcs12s / struct vmcs02_list { struct list_head list; gpa_t vmptr; struct loaded_vmcs vmcs02; }; / * The nested_vmx structure is part of vcpu_vmx, and holds information we need * for correct emulation of VMX (i.e., nested VMX) on this vcpu. / struct nested_vmx { / Has the level1 guest done vmxon? / bool vmxon; gpa_t vmxon_ptr; / The guest-physical address of the current VMCS L1 keeps for L2 / gpa_t current_vmptr; / The host-usable pointer to the above / struct page current_vmcs12_page; struct vmcs12 current_vmcs12; struct vmcs current_shadow_vmcs; /* * Indicates if the shadow vmcs must be updated with the * data hold by vmcs12 / bool sync_shadow_vmcs; / vmcs02_list cache of VMCSs recently used to run L2 guests / struct list_head vmcs02_pool; int vmcs02_num; u64 vmcs01_tsc_offset; / L2 must run next, and mustn't decide to exit to L1. / bool nested_run_pending; / * Guest pages referred to in vmcs02 with host-physical pointers, so * we must keep them pinned while L2 runs. / struct page apic_access_page; struct page virtual_apic_page; u64 msr_ia32_feature_control; struct hrtimer preemption_timer; bool preemption_timer_expired; / to migrate it to L2 if VM_ENTRY_LOAD_DEBUG_CONTROLS is off / u64 vmcs01_debugctl; }; #define POSTED_INTR_ON 0 / Posted-Interrupt Descriptor / struct pi_desc { u32 pir[8]; / Posted interrupt requested / u32 control; / bit 0 of control is outstanding notification bit / u32 rsvd[7]; } __aligned(64); static bool pi_test_and_set_on(struct pi_desc pi_desc) { return test_and_set_bit(POSTED_INTR_ON, (unsigned long )&pi_desc->control); } static bool pi_test_and_clear_on(struct pi_desc pi_desc) { return test_and_clear_bit(POSTED_INTR_ON, (unsigned long )&pi_desc->control); } static int pi_test_and_set_pir(int vector, struct pi_desc pi_desc) { return test_and_set_bit(vector, (unsigned long )pi_desc->pir); } struct vcpu_vmx { struct kvm_vcpu vcpu; unsigned long host_rsp; u8 fail; bool nmi_known_unmasked; u32 exit_intr_info; u32 idt_vectoring_info; ulong rflags; struct shared_msr_entry guest_msrs; int nmsrs; int save_nmsrs; unsigned long host_idt_base; #ifdef CONFIG_X86_64 u64 msr_host_kernel_gs_base; u64 msr_guest_kernel_gs_base; #endif u32 vm_entry_controls_shadow; u32 vm_exit_controls_shadow; /* * loaded_vmcs points to the VMCS currently used in this vcpu. For a * non-nested (L1) guest, it always points to vmcs01. For a nested * guest (L2), it points to a different VMCS. / struct loaded_vmcs vmcs01; struct loaded_vmcs loaded_vmcs; bool __launched; /* temporary, used in vmx_vcpu_run / struct msr_autoload { unsigned nr; struct vmx_msr_entry guest[NR_AUTOLOAD_MSRS]; struct vmx_msr_entry host[NR_AUTOLOAD_MSRS]; } msr_autoload; struct { int loaded; u16 fs_sel, gs_sel, ldt_sel; #ifdef CONFIG_X86_64 u16 ds_sel, es_sel; #endif int gs_ldt_reload_needed; int fs_reload_needed; u64 msr_host_bndcfgs; unsigned long vmcs_host_cr4; / May not match real cr4 / } host_state; struct { int vm86_active; ulong save_rflags; struct kvm_segment segs[8]; } rmode; struct { u32 bitmask; / 4 bits per segment (1 bit per field) / struct kvm_save_segment { u16 selector; unsigned long base; u32 limit; u32 ar; } seg[8]; } segment_cache; int vpid; bool emulation_required; / Support for vnmi-less CPUs / int soft_vnmi_blocked; ktime_t entry_time; s64 vnmi_blocked_time; u32 exit_reason; bool rdtscp_enabled; / Posted interrupt descriptor / struct pi_desc pi_desc; / Support for a guest hypervisor (nested VMX) / struct nested_vmx nested; / Dynamic PLE window. / int ple_window; bool ple_window_dirty; }; enum segment_cache_field { SEG_FIELD_SEL = 0, SEG_FIELD_BASE = 1, SEG_FIELD_LIMIT = 2, SEG_FIELD_AR = 3, SEG_FIELD_NR = 4 }; static inline struct vcpu_vmx to_vmx(struct kvm_vcpu vcpu) { return container_of(vcpu, struct vcpu_vmx, vcpu); } #define VMCS12_OFFSET(x) offsetof(struct vmcs12, x) #define FIELD(number, name) [number] = VMCS12_OFFSET(name) #define FIELD64(number, name) [number] = VMCS12_OFFSET(name), \ [number##_HIGH] = VMCS12_OFFSET(name)+4 static unsigned long shadow_read_only_fields[] = { / * We do NOT shadow fields that are modified when L0 * traps and emulates any vmx instruction (e.g. VMPTRLD, * VMXON...) executed by L1. * For example, VM_INSTRUCTION_ERROR is read * by L1 if a vmx instruction fails (part of the error path). * Note the code assumes this logic. If for some reason * we start shadowing these fields then we need to * force a shadow sync when L0 emulates vmx instructions * (e.g. force a sync if VM_INSTRUCTION_ERROR is modified * by nested_vmx_failValid) / VM_EXIT_REASON, VM_EXIT_INTR_INFO, VM_EXIT_INSTRUCTION_LEN, IDT_VECTORING_INFO_FIELD, IDT_VECTORING_ERROR_CODE, VM_EXIT_INTR_ERROR_CODE, EXIT_QUALIFICATION, GUEST_LINEAR_ADDRESS, GUEST_PHYSICAL_ADDRESS }; static int max_shadow_read_only_fields = ARRAY_SIZE(shadow_read_only_fields); static unsigned long shadow_read_write_fields[] = { TPR_THRESHOLD, GUEST_RIP, GUEST_RSP, GUEST_CR0, GUEST_CR3, GUEST_CR4, GUEST_INTERRUPTIBILITY_INFO, GUEST_RFLAGS, GUEST_CS_SELECTOR, GUEST_CS_AR_BYTES, GUEST_CS_LIMIT, GUEST_CS_BASE, GUEST_ES_BASE, GUEST_BNDCFGS, CR0_GUEST_HOST_MASK, CR0_READ_SHADOW, CR4_READ_SHADOW, TSC_OFFSET, EXCEPTION_BITMAP, CPU_BASED_VM_EXEC_CONTROL, VM_ENTRY_EXCEPTION_ERROR_CODE, VM_ENTRY_INTR_INFO_FIELD, VM_ENTRY_INSTRUCTION_LEN, VM_ENTRY_EXCEPTION_ERROR_CODE, HOST_FS_BASE, HOST_GS_BASE, HOST_FS_SELECTOR, HOST_GS_SELECTOR }; static int max_shadow_read_write_fields = ARRAY_SIZE(shadow_read_write_fields); static const unsigned short vmcs_field_to_offset_table[] = { FIELD(VIRTUAL_PROCESSOR_ID, virtual_processor_id), FIELD(GUEST_ES_SELECTOR, guest_es_selector), FIELD(GUEST_CS_SELECTOR, guest_cs_selector), FIELD(GUEST_SS_SELECTOR, guest_ss_selector), FIELD(GUEST_DS_SELECTOR, guest_ds_selector), FIELD(GUEST_FS_SELECTOR, guest_fs_selector), FIELD(GUEST_GS_SELECTOR, guest_gs_selector), FIELD(GUEST_LDTR_SELECTOR, guest_ldtr_selector), FIELD(GUEST_TR_SELECTOR, guest_tr_selector), FIELD(HOST_ES_SELECTOR, host_es_selector), FIELD(HOST_CS_SELECTOR, host_cs_selector), FIELD(HOST_SS_SELECTOR, host_ss_selector), FIELD(HOST_DS_SELECTOR, host_ds_selector), FIELD(HOST_FS_SELECTOR, host_fs_selector), FIELD(HOST_GS_SELECTOR, host_gs_selector), FIELD(HOST_TR_SELECTOR, host_tr_selector), FIELD64(IO_BITMAP_A, io_bitmap_a), FIELD64(IO_BITMAP_B, io_bitmap_b), FIELD64(MSR_BITMAP, msr_bitmap), FIELD64(VM_EXIT_MSR_STORE_ADDR, vm_exit_msr_store_addr), FIELD64(VM_EXIT_MSR_LOAD_ADDR, vm_exit_msr_load_addr), FIELD64(VM_ENTRY_MSR_LOAD_ADDR, vm_entry_msr_load_addr), FIELD64(TSC_OFFSET, tsc_offset), FIELD64(VIRTUAL_APIC_PAGE_ADDR, virtual_apic_page_addr), FIELD64(APIC_ACCESS_ADDR, apic_access_addr), FIELD64(EPT_POINTER, ept_pointer), FIELD64(GUEST_PHYSICAL_ADDRESS, guest_physical_address), FIELD64(VMCS_LINK_POINTER, vmcs_link_pointer), FIELD64(GUEST_IA32_DEBUGCTL, guest_ia32_debugctl), FIELD64(GUEST_IA32_PAT, guest_ia32_pat), FIELD64(GUEST_IA32_EFER, guest_ia32_efer), FIELD64(GUEST_IA32_PERF_GLOBAL_CTRL, guest_ia32_perf_global_ctrl), FIELD64(GUEST_PDPTR0, guest_pdptr0), FIELD64(GUEST_PDPTR1, guest_pdptr1), FIELD64(GUEST_PDPTR2, guest_pdptr2), FIELD64(GUEST_PDPTR3, guest_pdptr3), FIELD64(GUEST_BNDCFGS, guest_bndcfgs), FIELD64(HOST_IA32_PAT, host_ia32_pat), FIELD64(HOST_IA32_EFER, host_ia32_efer), FIELD64(HOST_IA32_PERF_GLOBAL_CTRL, host_ia32_perf_global_ctrl), FIELD(PIN_BASED_VM_EXEC_CONTROL, pin_based_vm_exec_control), FIELD(CPU_BASED_VM_EXEC_CONTROL, cpu_based_vm_exec_control), FIELD(EXCEPTION_BITMAP, exception_bitmap), FIELD(PAGE_FAULT_ERROR_CODE_MASK, page_fault_error_code_mask), FIELD(PAGE_FAULT_ERROR_CODE_MATCH, page_fault_error_code_match), FIELD(CR3_TARGET_COUNT, cr3_target_count), FIELD(VM_EXIT_CONTROLS, vm_exit_controls), FIELD(VM_EXIT_MSR_STORE_COUNT, vm_exit_msr_store_count), FIELD(VM_EXIT_MSR_LOAD_COUNT, vm_exit_msr_load_count), FIELD(VM_ENTRY_CONTROLS, vm_entry_controls), FIELD(VM_ENTRY_MSR_LOAD_COUNT, vm_entry_msr_load_count), FIELD(VM_ENTRY_INTR_INFO_FIELD, vm_entry_intr_info_field), FIELD(VM_ENTRY_EXCEPTION_ERROR_CODE, vm_entry_exception_error_code), FIELD(VM_ENTRY_INSTRUCTION_LEN, vm_entry_instruction_len), FIELD(TPR_THRESHOLD, tpr_threshold), FIELD(SECONDARY_VM_EXEC_CONTROL, secondary_vm_exec_control), FIELD(VM_INSTRUCTION_ERROR, vm_instruction_error), FIELD(VM_EXIT_REASON, vm_exit_reason), FIELD(VM_EXIT_INTR_INFO, vm_exit_intr_info), FIELD(VM_EXIT_INTR_ERROR_CODE, vm_exit_intr_error_code), FIELD(IDT_VECTORING_INFO_FIELD, idt_vectoring_info_field), FIELD(IDT_VECTORING_ERROR_CODE, idt_vectoring_error_code), FIELD(VM_EXIT_INSTRUCTION_LEN, vm_exit_instruction_len), FIELD(VMX_INSTRUCTION_INFO, vmx_instruction_info), FIELD(GUEST_ES_LIMIT, guest_es_limit), FIELD(GUEST_CS_LIMIT, guest_cs_limit), FIELD(GUEST_SS_LIMIT, guest_ss_limit), FIELD(GUEST_DS_LIMIT, guest_ds_limit), FIELD(GUEST_FS_LIMIT, guest_fs_limit), FIELD(GUEST_GS_LIMIT, guest_gs_limit), FIELD(GUEST_LDTR_LIMIT, guest_ldtr_limit), FIELD(GUEST_TR_LIMIT, guest_tr_limit), FIELD(GUEST_GDTR_LIMIT, guest_gdtr_limit), FIELD(GUEST_IDTR_LIMIT, guest_idtr_limit), FIELD(GUEST_ES_AR_BYTES, guest_es_ar_bytes), FIELD(GUEST_CS_AR_BYTES, guest_cs_ar_bytes), FIELD(GUEST_SS_AR_BYTES, guest_ss_ar_bytes), FIELD(GUEST_DS_AR_BYTES, guest_ds_ar_bytes), FIELD(GUEST_FS_AR_BYTES, guest_fs_ar_bytes), FIELD(GUEST_GS_AR_BYTES, guest_gs_ar_bytes), FIELD(GUEST_LDTR_AR_BYTES, guest_ldtr_ar_bytes), FIELD(GUEST_TR_AR_BYTES, guest_tr_ar_bytes), FIELD(GUEST_INTERRUPTIBILITY_INFO, guest_interruptibility_info), FIELD(GUEST_ACTIVITY_STATE, guest_activity_state), FIELD(GUEST_SYSENTER_CS, guest_sysenter_cs), FIELD(HOST_IA32_SYSENTER_CS, host_ia32_sysenter_cs), FIELD(VMX_PREEMPTION_TIMER_VALUE, vmx_preemption_timer_value), FIELD(CR0_GUEST_HOST_MASK, cr0_guest_host_mask), FIELD(CR4_GUEST_HOST_MASK, cr4_guest_host_mask), FIELD(CR0_READ_SHADOW, cr0_read_shadow), FIELD(CR4_READ_SHADOW, cr4_read_shadow), FIELD(CR3_TARGET_VALUE0, cr3_target_value0), FIELD(CR3_TARGET_VALUE1, cr3_target_value1), FIELD(CR3_TARGET_VALUE2, cr3_target_value2), FIELD(CR3_TARGET_VALUE3, cr3_target_value3), FIELD(EXIT_QUALIFICATION, exit_qualification), FIELD(GUEST_LINEAR_ADDRESS, guest_linear_address), FIELD(GUEST_CR0, guest_cr0), FIELD(GUEST_CR3, guest_cr3), FIELD(GUEST_CR4, guest_cr4), FIELD(GUEST_ES_BASE, guest_es_base), FIELD(GUEST_CS_BASE, guest_cs_base), FIELD(GUEST_SS_BASE, guest_ss_base), FIELD(GUEST_DS_BASE, guest_ds_base), FIELD(GUEST_FS_BASE, guest_fs_base), FIELD(GUEST_GS_BASE, guest_gs_base), FIELD(GUEST_LDTR_BASE, guest_ldtr_base), FIELD(GUEST_TR_BASE, guest_tr_base), FIELD(GUEST_GDTR_BASE, guest_gdtr_base), FIELD(GUEST_IDTR_BASE, guest_idtr_base), FIELD(GUEST_DR7, guest_dr7), FIELD(GUEST_RSP, guest_rsp), FIELD(GUEST_RIP, guest_rip), FIELD(GUEST_RFLAGS, guest_rflags), FIELD(GUEST_PENDING_DBG_EXCEPTIONS, guest_pending_dbg_exceptions), FIELD(GUEST_SYSENTER_ESP, guest_sysenter_esp), FIELD(GUEST_SYSENTER_EIP, guest_sysenter_eip), FIELD(HOST_CR0, host_cr0), FIELD(HOST_CR3, host_cr3), FIELD(HOST_CR4, host_cr4), FIELD(HOST_FS_BASE, host_fs_base), FIELD(HOST_GS_BASE, host_gs_base), FIELD(HOST_TR_BASE, host_tr_base), FIELD(HOST_GDTR_BASE, host_gdtr_base), FIELD(HOST_IDTR_BASE, host_idtr_base), FIELD(HOST_IA32_SYSENTER_ESP, host_ia32_sysenter_esp), FIELD(HOST_IA32_SYSENTER_EIP, host_ia32_sysenter_eip), FIELD(HOST_RSP, host_rsp), FIELD(HOST_RIP, host_rip), }; static const int max_vmcs_field = ARRAY_SIZE(vmcs_field_to_offset_table); static inline short vmcs_field_to_offset(unsigned long field) { if (field >= max_vmcs_field \|\| vmcs_field_to_offset_table[field] == 0) return -1; return vmcs_field_to_offset_table[field]; } static inline struct vmcs12 get_vmcs12(struct kvm_vcpu vcpu) { return to_vmx(vcpu)->nested.current_vmcs12; } static struct page nested_get_page(struct kvm_vcpu vcpu, gpa_t addr) { struct page page = gfn_to_page(vcpu->kvm, addr >> PAGE_SHIFT); if (is_error_page(page)) return NULL; return page; } static void nested_release_page(struct page page) { kvm_release_page_dirty(page); } static void nested_release_page_clean(struct page page) { kvm_release_page_clean(page); } static unsigned long nested_ept_get_cr3(struct kvm_vcpu vcpu); static u64 construct_eptp(unsigned long root_hpa); static void kvm_cpu_vmxon(u64 addr); static void kvm_cpu_vmxoff(void); static bool vmx_mpx_supported(void); static int vmx_set_tss_addr(struct kvm kvm, unsigned int addr); static void vmx_set_segment(struct kvm_vcpu vcpu, struct kvm_segment var, int seg); static void vmx_get_segment(struct kvm_vcpu vcpu, struct kvm_segment var, int seg); static bool guest_state_valid(struct kvm_vcpu vcpu); static u32 vmx_segment_access_rights(struct kvm_segment var); static void vmx_sync_pir_to_irr_dummy(struct kvm_vcpu vcpu); static void copy_vmcs12_to_shadow(struct vcpu_vmx vmx); static void copy_shadow_to_vmcs12(struct vcpu_vmx vmx); static int alloc_identity_pagetable(struct kvm kvm); static DEFINE_PER_CPU(struct vmcs , vmxarea); static DEFINE_PER_CPU(struct vmcs , current_vmcs); /* * We maintain a per-CPU linked-list of VMCS loaded on that CPU. This is needed * when a CPU is brought down, and we need to VMCLEAR all VMCSs loaded on it. / static DEFINE_PER_CPU(struct list_head, loaded_vmcss_on_cpu); static DEFINE_PER_CPU(struct desc_ptr, host_gdt); static unsigned long vmx_io_bitmap_a; static unsigned long vmx_io_bitmap_b; static unsigned long vmx_msr_bitmap_legacy; static unsigned long vmx_msr_bitmap_longmode; static unsigned long vmx_msr_bitmap_legacy_x2apic; static unsigned long vmx_msr_bitmap_longmode_x2apic; static unsigned long vmx_vmread_bitmap; static unsigned long vmx_vmwrite_bitmap; static bool cpu_has_load_ia32_efer; static bool cpu_has_load_perf_global_ctrl; static DECLARE_BITMAP(vmx_vpid_bitmap, VMX_NR_VPIDS); static DEFINE_SPINLOCK(vmx_vpid_lock); static struct vmcs_config { int size; int order; u32 revision_id; u32 pin_based_exec_ctrl; u32 cpu_based_exec_ctrl; u32 cpu_based_2nd_exec_ctrl; u32 vmexit_ctrl; u32 vmentry_ctrl; } vmcs_config; static struct vmx_capability { u32 ept; u32 vpid; } vmx_capability; #define VMX_SEGMENT_FIELD(seg) \ [VCPU_SREG_##seg] = { \ .selector = GUEST_##seg##_SELECTOR, \ .base = GUEST_##seg##_BASE, \ .limit = GUEST_##seg##_LIMIT, \ .ar_bytes = GUEST_##seg##_AR_BYTES, \ } static const struct kvm_vmx_segment_field { unsigned selector; unsigned base; unsigned limit; unsigned ar_bytes; } kvm_vmx_segment_fields[] = { VMX_SEGMENT_FIELD(CS), VMX_SEGMENT_FIELD(DS), VMX_SEGMENT_FIELD(ES), VMX_SEGMENT_FIELD(FS), VMX_SEGMENT_FIELD(GS), VMX_SEGMENT_FIELD(SS), VMX_SEGMENT_FIELD(TR), VMX_SEGMENT_FIELD(LDTR), }; static u64 host_efer; static void ept_save_pdptrs(struct kvm_vcpu vcpu); /* * Keep MSR_STAR at the end, as setup_msrs() will try to optimize it * away by decrementing the array size. / static const u32 vmx_msr_index[] = { #ifdef CONFIG_X86_64 MSR_SYSCALL_MASK, MSR_LSTAR, MSR_CSTAR, #endif MSR_EFER, MSR_TSC_AUX, MSR_STAR, }; static inline bool is_page_fault(u32 intr_info) { return (intr_info & (INTR_INFO_INTR_TYPE_MASK \| INTR_INFO_VECTOR_MASK \| INTR_INFO_VALID_MASK)) == (INTR_TYPE_HARD_EXCEPTION \| PF_VECTOR \| INTR_INFO_VALID_MASK); } static inline bool is_no_device(u32 intr_info) { return (intr_info & (INTR_INFO_INTR_TYPE_MASK \| INTR_INFO_VECTOR_MASK \| INTR_INFO_VALID_MASK)) == (INTR_TYPE_HARD_EXCEPTION \| NM_VECTOR \| INTR_INFO_VALID_MASK); } static inline bool is_invalid_opcode(u32 intr_info) { return (intr_info & (INTR_INFO_INTR_TYPE_MASK \| INTR_INFO_VECTOR_MASK \| INTR_INFO_VALID_MASK)) == (INTR_TYPE_HARD_EXCEPTION \| UD_VECTOR \| INTR_INFO_VALID_MASK); } static inline bool is_external_interrupt(u32 intr_info) { return (intr_info & (INTR_INFO_INTR_TYPE_MASK \| INTR_INFO_VALID_MASK)) == (INTR_TYPE_EXT_INTR \| INTR_INFO_VALID_MASK); } static inline bool is_machine_check(u32 intr_info) { return (intr_info & (INTR_INFO_INTR_TYPE_MASK \| INTR_INFO_VECTOR_MASK \| INTR_INFO_VALID_MASK)) == (INTR_TYPE_HARD_EXCEPTION \| MC_VECTOR \| INTR_INFO_VALID_MASK); } static inline bool cpu_has_vmx_msr_bitmap(void) { return vmcs_config.cpu_based_exec_ctrl & CPU_BASED_USE_MSR_BITMAPS; } static inline bool cpu_has_vmx_tpr_shadow(void) { return vmcs_config.cpu_based_exec_ctrl & CPU_BASED_TPR_SHADOW; } static inline bool vm_need_tpr_shadow(struct kvm kvm) { return (cpu_has_vmx_tpr_shadow()) && (irqchip_in_kernel(kvm)); } static inline bool cpu_has_secondary_exec_ctrls(void) { return vmcs_config.cpu_based_exec_ctrl & CPU_BASED_ACTIVATE_SECONDARY_CONTROLS; } static inline bool cpu_has_vmx_virtualize_apic_accesses(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES; } static inline bool cpu_has_vmx_virtualize_x2apic_mode(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_VIRTUALIZE_X2APIC_MODE; } static inline bool cpu_has_vmx_apic_register_virt(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_APIC_REGISTER_VIRT; } static inline bool cpu_has_vmx_virtual_intr_delivery(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_VIRTUAL_INTR_DELIVERY; } static inline bool cpu_has_vmx_posted_intr(void) { return vmcs_config.pin_based_exec_ctrl & PIN_BASED_POSTED_INTR; } static inline bool cpu_has_vmx_apicv(void) { return cpu_has_vmx_apic_register_virt() && cpu_has_vmx_virtual_intr_delivery() && cpu_has_vmx_posted_intr(); } static inline bool cpu_has_vmx_flexpriority(void) { return cpu_has_vmx_tpr_shadow() && cpu_has_vmx_virtualize_apic_accesses(); } static inline bool cpu_has_vmx_ept_execute_only(void) { return vmx_capability.ept & VMX_EPT_EXECUTE_ONLY_BIT; } static inline bool cpu_has_vmx_eptp_uncacheable(void) { return vmx_capability.ept & VMX_EPTP_UC_BIT; } static inline bool cpu_has_vmx_eptp_writeback(void) { return vmx_capability.ept & VMX_EPTP_WB_BIT; } static inline bool cpu_has_vmx_ept_2m_page(void) { return vmx_capability.ept & VMX_EPT_2MB_PAGE_BIT; } static inline bool cpu_has_vmx_ept_1g_page(void) { return vmx_capability.ept & VMX_EPT_1GB_PAGE_BIT; } static inline bool cpu_has_vmx_ept_4levels(void) { return vmx_capability.ept & VMX_EPT_PAGE_WALK_4_BIT; } static inline bool cpu_has_vmx_ept_ad_bits(void) { return vmx_capability.ept & VMX_EPT_AD_BIT; } static inline bool cpu_has_vmx_invept_context(void) { return vmx_capability.ept & VMX_EPT_EXTENT_CONTEXT_BIT; } static inline bool cpu_has_vmx_invept_global(void) { return vmx_capability.ept & VMX_EPT_EXTENT_GLOBAL_BIT; } static inline bool cpu_has_vmx_invvpid_single(void) { return vmx_capability.vpid & VMX_VPID_EXTENT_SINGLE_CONTEXT_BIT; } static inline bool cpu_has_vmx_invvpid_global(void) { return vmx_capability.vpid & VMX_VPID_EXTENT_GLOBAL_CONTEXT_BIT; } static inline bool cpu_has_vmx_ept(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_ENABLE_EPT; } static inline bool cpu_has_vmx_unrestricted_guest(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_UNRESTRICTED_GUEST; } static inline bool cpu_has_vmx_ple(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_PAUSE_LOOP_EXITING; } static inline bool vm_need_virtualize_apic_accesses(struct kvm kvm) { return flexpriority_enabled && irqchip_in_kernel(kvm); } static inline bool cpu_has_vmx_vpid(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_ENABLE_VPID; } static inline bool cpu_has_vmx_rdtscp(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_RDTSCP; } static inline bool cpu_has_vmx_invpcid(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_ENABLE_INVPCID; } static inline bool cpu_has_virtual_nmis(void) { return vmcs_config.pin_based_exec_ctrl & PIN_BASED_VIRTUAL_NMIS; } static inline bool cpu_has_vmx_wbinvd_exit(void) { return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_WBINVD_EXITING; } static inline bool cpu_has_vmx_shadow_vmcs(void) { u64 vmx_msr; rdmsrl(MSR_IA32_VMX_MISC, vmx_msr); / check if the cpu supports writing r/o exit information fields / if (!(vmx_msr & MSR_IA32_VMX_MISC_VMWRITE_SHADOW_RO_FIELDS)) return false; return vmcs_config.cpu_based_2nd_exec_ctrl & SECONDARY_EXEC_SHADOW_VMCS; } static inline bool report_flexpriority(void) { return flexpriority_enabled; } static inline bool nested_cpu_has(struct vmcs12 vmcs12, u32 bit) { return vmcs12->cpu_based_vm_exec_control & bit; } static inline bool nested_cpu_has2(struct vmcs12 vmcs12, u32 bit) { return (vmcs12->cpu_based_vm_exec_control & CPU_BASED_ACTIVATE_SECONDARY_CONTROLS) && (vmcs12->secondary_vm_exec_control & bit); } static inline bool nested_cpu_has_virtual_nmis(struct vmcs12 vmcs12) { return vmcs12->pin_based_vm_exec_control & PIN_BASED_VIRTUAL_NMIS; } static inline bool nested_cpu_has_preemption_timer(struct vmcs12 vmcs12) { return vmcs12->pin_based_vm_exec_control & PIN_BASED_VMX_PREEMPTION_TIMER; } static inline int nested_cpu_has_ept(struct vmcs12 vmcs12) { return nested_cpu_has2(vmcs12, SECONDARY_EXEC_ENABLE_EPT); } static inline bool is_exception(u32 intr_info) { return (intr_info & (INTR_INFO_INTR_TYPE_MASK \| INTR_INFO_VALID_MASK)) == (INTR_TYPE_HARD_EXCEPTION \| INTR_INFO_VALID_MASK); } static void nested_vmx_vmexit(struct kvm_vcpu vcpu, u32 exit_reason, u32 exit_intr_info, unsigned long exit_qualification); static void nested_vmx_entry_failure(struct kvm_vcpu vcpu, struct vmcs12 vmcs12, u32 reason, unsigned long qualification); static int __find_msr_index(struct vcpu_vmx vmx, u32 msr) { int i; for (i = 0; i < vmx->nmsrs; ++i) if (vmx_msr_index[vmx->guest_msrs[i].index] == msr) return i; return -1; } static inline void __invvpid(int ext, u16 vpid, gva_t gva) { struct { u64 vpid : 16; u64 rsvd : 48; u64 gva; } operand = { vpid, 0, gva }; asm volatile (__ex(ASM_VMX_INVVPID) /* CF==1 or ZF==1 --> rc = -1 / "; ja 1f ; ud2 ; 1:" : : "a"(&operand), "c"(ext) : "cc", "memory"); } static inline void __invept(int ext, u64 eptp, gpa_t gpa) { struct { u64 eptp, gpa; } operand = {eptp, gpa}; asm volatile (__ex(ASM_VMX_INVEPT) / CF==1 or ZF==1 --> rc = -1 / "; ja 1f ; ud2 ; 1:\n" : : "a" (&operand), "c" (ext) : "cc", "memory"); } static struct shared_msr_entry find_msr_entry(struct vcpu_vmx vmx, u32 msr) { int i; i = __find_msr_index(vmx, msr); if (i >= 0) return &vmx->guest_msrs[i]; return NULL; } static void vmcs_clear(struct vmcs vmcs) { u64 phys_addr = __pa(vmcs); u8 error; asm volatile (__ex(ASM_VMX_VMCLEAR_RAX) "; setna %0" : "=qm"(error) : "a"(&phys_addr), "m"(phys_addr) : "cc", "memory"); if (error) printk(KERN_ERR "kvm: vmclear fail: %p/%llx\n", vmcs, phys_addr); } static inline void loaded_vmcs_init(struct loaded_vmcs loaded_vmcs) { vmcs_clear(loaded_vmcs->vmcs); loaded_vmcs->cpu = -1; loaded_vmcs->launched = 0; } static void vmcs_load(struct vmcs vmcs) { u64 phys_addr = __pa(vmcs); u8 error; asm volatile (__ex(ASM_VMX_VMPTRLD_RAX) "; setna %0" : "=qm"(error) : "a"(&phys_addr), "m"(phys_addr) : "cc", "memory"); if (error) printk(KERN_ERR "kvm: vmptrld %p/%llx failed\n", vmcs, phys_addr); } #ifdef CONFIG_KEXEC /* * This bitmap is used to indicate whether the vmclear * operation is enabled on all cpus. All disabled by * default. / static cpumask_t crash_vmclear_enabled_bitmap = CPU_MASK_NONE; static inline void crash_enable_local_vmclear(int cpu) { cpumask_set_cpu(cpu, &crash_vmclear_enabled_bitmap); } static inline void crash_disable_local_vmclear(int cpu) { cpumask_clear_cpu(cpu, &crash_vmclear_enabled_bitmap); } static inline int crash_local_vmclear_enabled(int cpu) { return cpumask_test_cpu(cpu, &crash_vmclear_enabled_bitmap); } static void crash_vmclear_local_loaded_vmcss(void) { int cpu = raw_smp_processor_id(); struct loaded_vmcs v; if (!crash_local_vmclear_enabled(cpu)) return; list_for_each_entry(v, &per_cpu(loaded_vmcss_on_cpu, cpu), loaded_vmcss_on_cpu_link) vmcs_clear(v->vmcs); } #else static inline void crash_enable_local_vmclear(int cpu) { } static inline void crash_disable_local_vmclear(int cpu) { } #endif /* CONFIG_KEXEC / static void __loaded_vmcs_clear(void arg) { struct loaded_vmcs loaded_vmcs = arg; int cpu = raw_smp_processor_id(); if (loaded_vmcs->cpu != cpu) return; / vcpu migration can race with cpu offline / if (per_cpu(current_vmcs, cpu) == loaded_vmcs->vmcs) per_cpu(current_vmcs, cpu) = NULL; crash_disable_local_vmclear(cpu); list_del(&loaded_vmcs->loaded_vmcss_on_cpu_link); / * we should ensure updating loaded_vmcs->loaded_vmcss_on_cpu_link * is before setting loaded_vmcs->vcpu to -1 which is done in * loaded_vmcs_init. Otherwise, other cpu can see vcpu = -1 fist * then adds the vmcs into percpu list before it is deleted. / smp_wmb(); loaded_vmcs_init(loaded_vmcs); crash_enable_local_vmclear(cpu); } static void loaded_vmcs_clear(struct loaded_vmcs loaded_vmcs) { int cpu = loaded_vmcs->cpu; if (cpu != -1) smp_call_function_single(cpu, __loaded_vmcs_clear, loaded_vmcs, 1); } static inline void vpid_sync_vcpu_single(struct vcpu_vmx vmx) { if (vmx->vpid == 0) return; if (cpu_has_vmx_invvpid_single()) __invvpid(VMX_VPID_EXTENT_SINGLE_CONTEXT, vmx->vpid, 0); } static inline void vpid_sync_vcpu_global(void) { if (cpu_has_vmx_invvpid_global()) __invvpid(VMX_VPID_EXTENT_ALL_CONTEXT, 0, 0); } static inline void vpid_sync_context(struct vcpu_vmx vmx) { if (cpu_has_vmx_invvpid_single()) vpid_sync_vcpu_single(vmx); else vpid_sync_vcpu_global(); } static inline void ept_sync_global(void) { if (cpu_has_vmx_invept_global()) __invept(VMX_EPT_EXTENT_GLOBAL, 0, 0); } static inline void ept_sync_context(u64 eptp) { if (enable_ept) { if (cpu_has_vmx_invept_context()) __invept(VMX_EPT_EXTENT_CONTEXT, eptp, 0); else ept_sync_global(); } } static __always_inline unsigned long vmcs_readl(unsigned long field) { unsigned long value; asm volatile (__ex_clear(ASM_VMX_VMREAD_RDX_RAX, "%0") : "=a"(value) : "d"(field) : "cc"); return value; } static __always_inline u16 vmcs_read16(unsigned long field) { return vmcs_readl(field); } static __always_inline u32 vmcs_read32(unsigned long field) { return vmcs_readl(field); } static __always_inline u64 vmcs_read64(unsigned long field) { #ifdef CONFIG_X86_64 return vmcs_readl(field); #else return vmcs_readl(field) \| ((u64)vmcs_readl(field+1) << 32); #endif } static noinline void vmwrite_error(unsigned long field, unsigned long value) { printk(KERN_ERR "vmwrite error: reg %lx value %lx (err %d)\n", field, value, vmcs_read32(VM_INSTRUCTION_ERROR)); dump_stack(); } static void vmcs_writel(unsigned long field, unsigned long value) { u8 error; asm volatile (__ex(ASM_VMX_VMWRITE_RAX_RDX) "; setna %0" : "=q"(error) : "a"(value), "d"(field) : "cc"); if (unlikely(error)) vmwrite_error(field, value); } static void vmcs_write16(unsigned long field, u16 value) { vmcs_writel(field, value); } static void vmcs_write32(unsigned long field, u32 value) { vmcs_writel(field, value); } static void vmcs_write64(unsigned long field, u64 value) { vmcs_writel(field, value); #ifndef CONFIG_X86_64 asm volatile (""); vmcs_writel(field+1, value >> 32); #endif } static void vmcs_clear_bits(unsigned long field, u32 mask) { vmcs_writel(field, vmcs_readl(field) & ~mask); } static void vmcs_set_bits(unsigned long field, u32 mask) { vmcs_writel(field, vmcs_readl(field) \| mask); } static inline void vm_entry_controls_init(struct vcpu_vmx vmx, u32 val) { vmcs_write32(VM_ENTRY_CONTROLS, val); vmx->vm_entry_controls_shadow = val; } static inline void vm_entry_controls_set(struct vcpu_vmx vmx, u32 val) { if (vmx->vm_entry_controls_shadow != val) vm_entry_controls_init(vmx, val); } static inline u32 vm_entry_controls_get(struct vcpu_vmx vmx) { return vmx->vm_entry_controls_shadow; } static inline void vm_entry_controls_setbit(struct vcpu_vmx vmx, u32 val) { vm_entry_controls_set(vmx, vm_entry_controls_get(vmx) \| val); } static inline void vm_entry_controls_clearbit(struct vcpu_vmx vmx, u32 val) { vm_entry_controls_set(vmx, vm_entry_controls_get(vmx) & ~val); } static inline void vm_exit_controls_init(struct vcpu_vmx vmx, u32 val) { vmcs_write32(VM_EXIT_CONTROLS, val); vmx->vm_exit_controls_shadow = val; } static inline void vm_exit_controls_set(struct vcpu_vmx vmx, u32 val) { if (vmx->vm_exit_controls_shadow != val) vm_exit_controls_init(vmx, val); } static inline u32 vm_exit_controls_get(struct vcpu_vmx vmx) { return vmx->vm_exit_controls_shadow; } static inline void vm_exit_controls_setbit(struct vcpu_vmx vmx, u32 val) { vm_exit_controls_set(vmx, vm_exit_controls_get(vmx) \| val); } static inline void vm_exit_controls_clearbit(struct vcpu_vmx vmx, u32 val) { vm_exit_controls_set(vmx, vm_exit_controls_get(vmx) & ~val); } static void vmx_segment_cache_clear(struct vcpu_vmx vmx) { vmx->segment_cache.bitmask = 0; } static bool vmx_segment_cache_test_set(struct vcpu_vmx vmx, unsigned seg, unsigned field) { bool ret; u32 mask = 1 << (seg * SEG_FIELD_NR + field); if (!(vmx->vcpu.arch.regs_avail & (1 << VCPU_EXREG_SEGMENTS))) { vmx->vcpu.arch.regs_avail \|= (1 << VCPU_EXREG_SEGMENTS); vmx->segment_cache.bitmask = 0; } ret = vmx->segment_cache.bitmask & mask; vmx->segment_cache.bitmask \|= mask; return ret; } static u16 vmx_read_guest_seg_selector(struct vcpu_vmx vmx, unsigned seg) { u16 p = &vmx->segment_cache.seg[seg].selector; if (!vmx_segment_cache_test_set(vmx, seg, SEG_FIELD_SEL)) p = vmcs_read16(kvm_vmx_segment_fields[seg].selector); return p; } static ulong vmx_read_guest_seg_base(struct vcpu_vmx vmx, unsigned seg) { ulong p = &vmx->segment_cache.seg[seg].base; if (!vmx_segment_cache_test_set(vmx, seg, SEG_FIELD_BASE)) p = vmcs_readl(kvm_vmx_segment_fields[seg].base); return p; } static u32 vmx_read_guest_seg_limit(struct vcpu_vmx vmx, unsigned seg) { u32 p = &vmx->segment_cache.seg[seg].limit; if (!vmx_segment_cache_test_set(vmx, seg, SEG_FIELD_LIMIT)) p = vmcs_read32(kvm_vmx_segment_fields[seg].limit); return p; } static u32 vmx_read_guest_seg_ar(struct vcpu_vmx vmx, unsigned seg) { u32 p = &vmx->segment_cache.seg[seg].ar; if (!vmx_segment_cache_test_set(vmx, seg, SEG_FIELD_AR)) p = vmcs_read32(kvm_vmx_segment_fields[seg].ar_bytes); return p; } static void update_exception_bitmap(struct kvm_vcpu vcpu) { u32 eb; eb = (1u << PF_VECTOR) \| (1u << UD_VECTOR) \| (1u << MC_VECTOR) \| (1u << NM_VECTOR) \| (1u << DB_VECTOR); if ((vcpu->guest_debug & (KVM_GUESTDBG_ENABLE \| KVM_GUESTDBG_USE_SW_BP)) == (KVM_GUESTDBG_ENABLE \| KVM_GUESTDBG_USE_SW_BP)) eb \|= 1u << BP_VECTOR; if (to_vmx(vcpu)->rmode.vm86_active) eb = ~0; if (enable_ept) eb &= ~(1u << PF_VECTOR); / bypass_guest_pf = 0 / if (vcpu->fpu_active) eb &= ~(1u << NM_VECTOR); / When we are running a nested L2 guest and L1 specified for it a * certain exception bitmap, we must trap the same exceptions and pass * them to L1. When running L2, we will only handle the exceptions * specified above if L1 did not want them. / if (is_guest_mode(vcpu)) eb \|= get_vmcs12(vcpu)->exception_bitmap; vmcs_write32(EXCEPTION_BITMAP, eb); } static void clear_atomic_switch_msr_special(struct vcpu_vmx vmx, unsigned long entry, unsigned long exit) { vm_entry_controls_clearbit(vmx, entry); vm_exit_controls_clearbit(vmx, exit); } static void clear_atomic_switch_msr(struct vcpu_vmx vmx, unsigned msr) { unsigned i; struct msr_autoload m = &vmx->msr_autoload; switch (msr) { case MSR_EFER: if (cpu_has_load_ia32_efer) { clear_atomic_switch_msr_special(vmx, VM_ENTRY_LOAD_IA32_EFER, VM_EXIT_LOAD_IA32_EFER); return; } break; case MSR_CORE_PERF_GLOBAL_CTRL: if (cpu_has_load_perf_global_ctrl) { clear_atomic_switch_msr_special(vmx, VM_ENTRY_LOAD_IA32_PERF_GLOBAL_CTRL, VM_EXIT_LOAD_IA32_PERF_GLOBAL_CTRL); return; } break; } for (i = 0; i < m->nr; ++i) if (m->guest[i].index == msr) break; if (i == m->nr) return; --m->nr; m->guest[i] = m->guest[m->nr]; m->host[i] = m->host[m->nr]; vmcs_write32(VM_ENTRY_MSR_LOAD_COUNT, m->nr); vmcs_write32(VM_EXIT_MSR_LOAD_COUNT, m->nr); } static void add_atomic_switch_msr_special(struct vcpu_vmx vmx, unsigned long entry, unsigned long exit, unsigned long guest_val_vmcs, unsigned long host_val_vmcs, u64 guest_val, u64 host_val) { vmcs_write64(guest_val_vmcs, guest_val); vmcs_write64(host_val_vmcs, host_val); vm_entry_controls_setbit(vmx, entry); vm_exit_controls_setbit(vmx, exit); } static void add_atomic_switch_msr(struct vcpu_vmx vmx, unsigned msr, u64 guest_val, u64 host_val) { unsigned i; struct msr_autoload m = &vmx->msr_autoload; switch (msr) { case MSR_EFER: if (cpu_has_load_ia32_efer) { add_atomic_switch_msr_special(vmx, VM_ENTRY_LOAD_IA32_EFER, VM_EXIT_LOAD_IA32_EFER, GUEST_IA32_EFER, HOST_IA32_EFER, guest_val, host_val); return; } break; case MSR_CORE_PERF_GLOBAL_CTRL: if (cpu_has_load_perf_global_ctrl) { add_atomic_switch_msr_special(vmx, VM_ENTRY_LOAD_IA32_PERF_GLOBAL_CTRL, VM_EXIT_LOAD_IA32_PERF_GLOBAL_CTRL, GUEST_IA32_PERF_GLOBAL_CTRL, HOST_IA32_PERF_GLOBAL_CTRL, guest_val, host_val); return; } break; } for (i = 0; i < m->nr; ++i) if (m->guest[i].index == msr) break; if (i == NR_AUTOLOAD_MSRS) { printk_once(KERN_WARNING "Not enough msr switch entries. " "Can't add msr %x\n", msr); return; } else if (i == m->nr) { ++m->nr; vmcs_write32(VM_ENTRY_MSR_LOAD_COUNT, m->nr); vmcs_write32(VM_EXIT_MSR_LOAD_COUNT, m->nr); } m->guest[i].index = msr; m->guest[i].value = guest_val; m->host[i].index = msr; m->host[i].value = host_val; } static void reload_tss(void) { / * VT restores TR but not its size. Useless. / struct desc_ptr gdt = this_cpu_ptr(&host_gdt); struct desc_struct descs; descs = (void )gdt->address; descs[GDT_ENTRY_TSS].type = 9; /* available TSS / load_TR_desc(); } static bool update_transition_efer(struct vcpu_vmx vmx, int efer_offset) { u64 guest_efer; u64 ignore_bits; guest_efer = vmx->vcpu.arch.efer; /* * NX is emulated; LMA and LME handled by hardware; SCE meaningless * outside long mode / ignore_bits = EFER_NX \| EFER_SCE; #ifdef CONFIG_X86_64 ignore_bits \|= EFER_LMA \| EFER_LME; / SCE is meaningful only in long mode on Intel / if (guest_efer & EFER_LMA) ignore_bits &= ~(u64)EFER_SCE; #endif guest_efer &= ~ignore_bits; guest_efer \|= host_efer & ignore_bits; vmx->guest_msrs[efer_offset].data = guest_efer; vmx->guest_msrs[efer_offset].mask = ~ignore_bits; clear_atomic_switch_msr(vmx, MSR_EFER); / On ept, can't emulate nx, and must switch nx atomically / if (enable_ept && ((vmx->vcpu.arch.efer ^ host_efer) & EFER_NX)) { guest_efer = vmx->vcpu.arch.efer; if (!(guest_efer & EFER_LMA)) guest_efer &= ~EFER_LME; add_atomic_switch_msr(vmx, MSR_EFER, guest_efer, host_efer); return false; } return true; } static unsigned long segment_base(u16 selector) { struct desc_ptr gdt = this_cpu_ptr(&host_gdt); struct desc_struct d; unsigned long table_base; unsigned long v; if (!(selector & ~3)) return 0; table_base = gdt->address; if (selector & 4) { / from ldt / u16 ldt_selector = kvm_read_ldt(); if (!(ldt_selector & ~3)) return 0; table_base = segment_base(ldt_selector); } d = (struct desc_struct )(table_base + (selector & ~7)); v = get_desc_base(d); #ifdef CONFIG_X86_64 if (d->s == 0 && (d->type == 2 \|\| d->type == 9 \|\| d->type == 11)) v \|= ((unsigned long)((struct ldttss_desc64 )d)->base3) << 32; #endif return v; } static inline unsigned long kvm_read_tr_base(void) { u16 tr; asm("str %0" : "=g"(tr)); return segment_base(tr); } static void vmx_save_host_state(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); int i; if (vmx->host_state.loaded) return; vmx->host_state.loaded = 1; / * Set host fs and gs selectors. Unfortunately, 22.2.3 does not * allow segment selectors with cpl > 0 or ti == 1. / vmx->host_state.ldt_sel = kvm_read_ldt(); vmx->host_state.gs_ldt_reload_needed = vmx->host_state.ldt_sel; savesegment(fs, vmx->host_state.fs_sel); if (!(vmx->host_state.fs_sel & 7)) { vmcs_write16(HOST_FS_SELECTOR, vmx->host_state.fs_sel); vmx->host_state.fs_reload_needed = 0; } else { vmcs_write16(HOST_FS_SELECTOR, 0); vmx->host_state.fs_reload_needed = 1; } savesegment(gs, vmx->host_state.gs_sel); if (!(vmx->host_state.gs_sel & 7)) vmcs_write16(HOST_GS_SELECTOR, vmx->host_state.gs_sel); else { vmcs_write16(HOST_GS_SELECTOR, 0); vmx->host_state.gs_ldt_reload_needed = 1; } #ifdef CONFIG_X86_64 savesegment(ds, vmx->host_state.ds_sel); savesegment(es, vmx->host_state.es_sel); #endif #ifdef CONFIG_X86_64 vmcs_writel(HOST_FS_BASE, read_msr(MSR_FS_BASE)); vmcs_writel(HOST_GS_BASE, read_msr(MSR_GS_BASE)); #else vmcs_writel(HOST_FS_BASE, segment_base(vmx->host_state.fs_sel)); vmcs_writel(HOST_GS_BASE, segment_base(vmx->host_state.gs_sel)); #endif #ifdef CONFIG_X86_64 rdmsrl(MSR_KERNEL_GS_BASE, vmx->msr_host_kernel_gs_base); if (is_long_mode(&vmx->vcpu)) wrmsrl(MSR_KERNEL_GS_BASE, vmx->msr_guest_kernel_gs_base); #endif if (boot_cpu_has(X86_FEATURE_MPX)) rdmsrl(MSR_IA32_BNDCFGS, vmx->host_state.msr_host_bndcfgs); for (i = 0; i < vmx->save_nmsrs; ++i) kvm_set_shared_msr(vmx->guest_msrs[i].index, vmx->guest_msrs[i].data, vmx->guest_msrs[i].mask); } static void __vmx_load_host_state(struct vcpu_vmx vmx) { if (!vmx->host_state.loaded) return; ++vmx->vcpu.stat.host_state_reload; vmx->host_state.loaded = 0; #ifdef CONFIG_X86_64 if (is_long_mode(&vmx->vcpu)) rdmsrl(MSR_KERNEL_GS_BASE, vmx->msr_guest_kernel_gs_base); #endif if (vmx->host_state.gs_ldt_reload_needed) { kvm_load_ldt(vmx->host_state.ldt_sel); #ifdef CONFIG_X86_64 load_gs_index(vmx->host_state.gs_sel); #else loadsegment(gs, vmx->host_state.gs_sel); #endif } if (vmx->host_state.fs_reload_needed) loadsegment(fs, vmx->host_state.fs_sel); #ifdef CONFIG_X86_64 if (unlikely(vmx->host_state.ds_sel \| vmx->host_state.es_sel)) { loadsegment(ds, vmx->host_state.ds_sel); loadsegment(es, vmx->host_state.es_sel); } #endif reload_tss(); #ifdef CONFIG_X86_64 wrmsrl(MSR_KERNEL_GS_BASE, vmx->msr_host_kernel_gs_base); #endif if (vmx->host_state.msr_host_bndcfgs) wrmsrl(MSR_IA32_BNDCFGS, vmx->host_state.msr_host_bndcfgs); /* * If the FPU is not active (through the host task or * the guest vcpu), then restore the cr0.TS bit. / if (!user_has_fpu() && !vmx->vcpu.guest_fpu_loaded) stts(); load_gdt(this_cpu_ptr(&host_gdt)); } static void vmx_load_host_state(struct vcpu_vmx vmx) { preempt_disable(); __vmx_load_host_state(vmx); preempt_enable(); } /* * Switches to specified vcpu, until a matching vcpu_put(), but assumes * vcpu mutex is already taken. / static void vmx_vcpu_load(struct kvm_vcpu vcpu, int cpu) { struct vcpu_vmx vmx = to_vmx(vcpu); u64 phys_addr = __pa(per_cpu(vmxarea, cpu)); if (!vmm_exclusive) kvm_cpu_vmxon(phys_addr); else if (vmx->loaded_vmcs->cpu != cpu) loaded_vmcs_clear(vmx->loaded_vmcs); if (per_cpu(current_vmcs, cpu) != vmx->loaded_vmcs->vmcs) { per_cpu(current_vmcs, cpu) = vmx->loaded_vmcs->vmcs; vmcs_load(vmx->loaded_vmcs->vmcs); } if (vmx->loaded_vmcs->cpu != cpu) { struct desc_ptr gdt = this_cpu_ptr(&host_gdt); unsigned long sysenter_esp; kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu); local_irq_disable(); crash_disable_local_vmclear(cpu); /* * Read loaded_vmcs->cpu should be before fetching * loaded_vmcs->loaded_vmcss_on_cpu_link. * See the comments in __loaded_vmcs_clear(). / smp_rmb(); list_add(&vmx->loaded_vmcs->loaded_vmcss_on_cpu_link, &per_cpu(loaded_vmcss_on_cpu, cpu)); crash_enable_local_vmclear(cpu); local_irq_enable(); / * Linux uses per-cpu TSS and GDT, so set these when switching * processors. / vmcs_writel(HOST_TR_BASE, kvm_read_tr_base()); / 22.2.4 / vmcs_writel(HOST_GDTR_BASE, gdt->address); / 22.2.4 / rdmsrl(MSR_IA32_SYSENTER_ESP, sysenter_esp); vmcs_writel(HOST_IA32_SYSENTER_ESP, sysenter_esp); / 22.2.3 / vmx->loaded_vmcs->cpu = cpu; } } static void vmx_vcpu_put(struct kvm_vcpu vcpu) { __vmx_load_host_state(to_vmx(vcpu)); if (!vmm_exclusive) { __loaded_vmcs_clear(to_vmx(vcpu)->loaded_vmcs); vcpu->cpu = -1; kvm_cpu_vmxoff(); } } static void vmx_fpu_activate(struct kvm_vcpu vcpu) { ulong cr0; if (vcpu->fpu_active) return; vcpu->fpu_active = 1; cr0 = vmcs_readl(GUEST_CR0); cr0 &= ~(X86_CR0_TS \| X86_CR0_MP); cr0 \|= kvm_read_cr0_bits(vcpu, X86_CR0_TS \| X86_CR0_MP); vmcs_writel(GUEST_CR0, cr0); update_exception_bitmap(vcpu); vcpu->arch.cr0_guest_owned_bits = X86_CR0_TS; if (is_guest_mode(vcpu)) vcpu->arch.cr0_guest_owned_bits &= ~get_vmcs12(vcpu)->cr0_guest_host_mask; vmcs_writel(CR0_GUEST_HOST_MASK, ~vcpu->arch.cr0_guest_owned_bits); } static void vmx_decache_cr0_guest_bits(struct kvm_vcpu vcpu); /* * Return the cr0 value that a nested guest would read. This is a combination * of the real cr0 used to run the guest (guest_cr0), and the bits shadowed by * its hypervisor (cr0_read_shadow). / static inline unsigned long nested_read_cr0(struct vmcs12 fields) { return (fields->guest_cr0 & ~fields->cr0_guest_host_mask) \| (fields->cr0_read_shadow & fields->cr0_guest_host_mask); } static inline unsigned long nested_read_cr4(struct vmcs12 fields) { return (fields->guest_cr4 & ~fields->cr4_guest_host_mask) \| (fields->cr4_read_shadow & fields->cr4_guest_host_mask); } static void vmx_fpu_deactivate(struct kvm_vcpu vcpu) { /* Note that there is no vcpu->fpu_active = 0 here. The caller must * set this before calling this function. / vmx_decache_cr0_guest_bits(vcpu); vmcs_set_bits(GUEST_CR0, X86_CR0_TS \| X86_CR0_MP); update_exception_bitmap(vcpu); vcpu->arch.cr0_guest_owned_bits = 0; vmcs_writel(CR0_GUEST_HOST_MASK, ~vcpu->arch.cr0_guest_owned_bits); if (is_guest_mode(vcpu)) { / * L1's specified read shadow might not contain the TS bit, * so now that we turned on shadowing of this bit, we need to * set this bit of the shadow. Like in nested_vmx_run we need * nested_read_cr0(vmcs12), but vmcs12->guest_cr0 is not yet * up-to-date here because we just decached cr0.TS (and we'll * only update vmcs12->guest_cr0 on nested exit). / struct vmcs12 vmcs12 = get_vmcs12(vcpu); vmcs12->guest_cr0 = (vmcs12->guest_cr0 & ~X86_CR0_TS) \| (vcpu->arch.cr0 & X86_CR0_TS); vmcs_writel(CR0_READ_SHADOW, nested_read_cr0(vmcs12)); } else vmcs_writel(CR0_READ_SHADOW, vcpu->arch.cr0); } static unsigned long vmx_get_rflags(struct kvm_vcpu vcpu) { unsigned long rflags, save_rflags; if (!test_bit(VCPU_EXREG_RFLAGS, (ulong )&vcpu->arch.regs_avail)) { __set_bit(VCPU_EXREG_RFLAGS, (ulong )&vcpu->arch.regs_avail); rflags = vmcs_readl(GUEST_RFLAGS); if (to_vmx(vcpu)->rmode.vm86_active) { rflags &= RMODE_GUEST_OWNED_EFLAGS_BITS; save_rflags = to_vmx(vcpu)->rmode.save_rflags; rflags \|= save_rflags & ~RMODE_GUEST_OWNED_EFLAGS_BITS; } to_vmx(vcpu)->rflags = rflags; } return to_vmx(vcpu)->rflags; } static void vmx_set_rflags(struct kvm_vcpu vcpu, unsigned long rflags) { __set_bit(VCPU_EXREG_RFLAGS, (ulong )&vcpu->arch.regs_avail); to_vmx(vcpu)->rflags = rflags; if (to_vmx(vcpu)->rmode.vm86_active) { to_vmx(vcpu)->rmode.save_rflags = rflags; rflags \|= X86_EFLAGS_IOPL \| X86_EFLAGS_VM; } vmcs_writel(GUEST_RFLAGS, rflags); } static u32 vmx_get_interrupt_shadow(struct kvm_vcpu vcpu) { u32 interruptibility = vmcs_read32(GUEST_INTERRUPTIBILITY_INFO); int ret = 0; if (interruptibility & GUEST_INTR_STATE_STI) ret \|= KVM_X86_SHADOW_INT_STI; if (interruptibility & GUEST_INTR_STATE_MOV_SS) ret \|= KVM_X86_SHADOW_INT_MOV_SS; return ret; } static void vmx_set_interrupt_shadow(struct kvm_vcpu vcpu, int mask) { u32 interruptibility_old = vmcs_read32(GUEST_INTERRUPTIBILITY_INFO); u32 interruptibility = interruptibility_old; interruptibility &= ~(GUEST_INTR_STATE_STI \| GUEST_INTR_STATE_MOV_SS); if (mask & KVM_X86_SHADOW_INT_MOV_SS) interruptibility \|= GUEST_INTR_STATE_MOV_SS; else if (mask & KVM_X86_SHADOW_INT_STI) interruptibility \|= GUEST_INTR_STATE_STI; if ((interruptibility != interruptibility_old)) vmcs_write32(GUEST_INTERRUPTIBILITY_INFO, interruptibility); } static void skip_emulated_instruction(struct kvm_vcpu vcpu) { unsigned long rip; rip = kvm_rip_read(vcpu); rip += vmcs_read32(VM_EXIT_INSTRUCTION_LEN); kvm_rip_write(vcpu, rip); /* skipping an emulated instruction also counts / vmx_set_interrupt_shadow(vcpu, 0); } / * KVM wants to inject page-faults which it got to the guest. This function * checks whether in a nested guest, we need to inject them to L1 or L2. / static int nested_vmx_check_exception(struct kvm_vcpu vcpu, unsigned nr) { struct vmcs12 vmcs12 = get_vmcs12(vcpu); if (!(vmcs12->exception_bitmap & (1u << nr))) return 0; nested_vmx_vmexit(vcpu, to_vmx(vcpu)->exit_reason, vmcs_read32(VM_EXIT_INTR_INFO), vmcs_readl(EXIT_QUALIFICATION)); return 1; } static void vmx_queue_exception(struct kvm_vcpu vcpu, unsigned nr, bool has_error_code, u32 error_code, bool reinject) { struct vcpu_vmx vmx = to_vmx(vcpu); u32 intr_info = nr \| INTR_INFO_VALID_MASK; if (!reinject && is_guest_mode(vcpu) && nested_vmx_check_exception(vcpu, nr)) return; if (has_error_code) { vmcs_write32(VM_ENTRY_EXCEPTION_ERROR_CODE, error_code); intr_info \|= INTR_INFO_DELIVER_CODE_MASK; } if (vmx->rmode.vm86_active) { int inc_eip = 0; if (kvm_exception_is_soft(nr)) inc_eip = vcpu->arch.event_exit_inst_len; if (kvm_inject_realmode_interrupt(vcpu, nr, inc_eip) != EMULATE_DONE) kvm_make_request(KVM_REQ_TRIPLE_FAULT, vcpu); return; } if (kvm_exception_is_soft(nr)) { vmcs_write32(VM_ENTRY_INSTRUCTION_LEN, vmx->vcpu.arch.event_exit_inst_len); intr_info \|= INTR_TYPE_SOFT_EXCEPTION; } else intr_info \|= INTR_TYPE_HARD_EXCEPTION; vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, intr_info); } static bool vmx_rdtscp_supported(void) { return cpu_has_vmx_rdtscp(); } static bool vmx_invpcid_supported(void) { return cpu_has_vmx_invpcid() && enable_ept; } / * Swap MSR entry in host/guest MSR entry array. / static void move_msr_up(struct vcpu_vmx vmx, int from, int to) { struct shared_msr_entry tmp; tmp = vmx->guest_msrs[to]; vmx->guest_msrs[to] = vmx->guest_msrs[from]; vmx->guest_msrs[from] = tmp; } static void vmx_set_msr_bitmap(struct kvm_vcpu vcpu) { unsigned long msr_bitmap; if (irqchip_in_kernel(vcpu->kvm) && apic_x2apic_mode(vcpu->arch.apic)) { if (is_long_mode(vcpu)) msr_bitmap = vmx_msr_bitmap_longmode_x2apic; else msr_bitmap = vmx_msr_bitmap_legacy_x2apic; } else { if (is_long_mode(vcpu)) msr_bitmap = vmx_msr_bitmap_longmode; else msr_bitmap = vmx_msr_bitmap_legacy; } vmcs_write64(MSR_BITMAP, __pa(msr_bitmap)); } /* * Set up the vmcs to automatically save and restore system * msrs. Don't touch the 64-bit msrs if the guest is in legacy * mode, as fiddling with msrs is very expensive. / static void setup_msrs(struct vcpu_vmx vmx) { int save_nmsrs, index; save_nmsrs = 0; #ifdef CONFIG_X86_64 if (is_long_mode(&vmx->vcpu)) { index = __find_msr_index(vmx, MSR_SYSCALL_MASK); if (index >= 0) move_msr_up(vmx, index, save_nmsrs++); index = __find_msr_index(vmx, MSR_LSTAR); if (index >= 0) move_msr_up(vmx, index, save_nmsrs++); index = __find_msr_index(vmx, MSR_CSTAR); if (index >= 0) move_msr_up(vmx, index, save_nmsrs++); index = __find_msr_index(vmx, MSR_TSC_AUX); if (index >= 0 && vmx->rdtscp_enabled) move_msr_up(vmx, index, save_nmsrs++); /* * MSR_STAR is only needed on long mode guests, and only * if efer.sce is enabled. / index = __find_msr_index(vmx, MSR_STAR); if ((index >= 0) && (vmx->vcpu.arch.efer & EFER_SCE)) move_msr_up(vmx, index, save_nmsrs++); } #endif index = __find_msr_index(vmx, MSR_EFER); if (index >= 0 && update_transition_efer(vmx, index)) move_msr_up(vmx, index, save_nmsrs++); vmx->save_nmsrs = save_nmsrs; if (cpu_has_vmx_msr_bitmap()) vmx_set_msr_bitmap(&vmx->vcpu); } / * reads and returns guest's timestamp counter "register" * guest_tsc = host_tsc + tsc_offset -- 21.3 / static u64 guest_read_tsc(void) { u64 host_tsc, tsc_offset; rdtscll(host_tsc); tsc_offset = vmcs_read64(TSC_OFFSET); return host_tsc + tsc_offset; } / * Like guest_read_tsc, but always returns L1's notion of the timestamp * counter, even if a nested guest (L2) is currently running. / static u64 vmx_read_l1_tsc(struct kvm_vcpu vcpu, u64 host_tsc) { u64 tsc_offset; tsc_offset = is_guest_mode(vcpu) ? to_vmx(vcpu)->nested.vmcs01_tsc_offset : vmcs_read64(TSC_OFFSET); return host_tsc + tsc_offset; } /* * Engage any workarounds for mis-matched TSC rates. Currently limited to * software catchup for faster rates on slower CPUs. / static void vmx_set_tsc_khz(struct kvm_vcpu vcpu, u32 user_tsc_khz, bool scale) { if (!scale) return; if (user_tsc_khz > tsc_khz) { vcpu->arch.tsc_catchup = 1; vcpu->arch.tsc_always_catchup = 1; } else WARN(1, "user requested TSC rate below hardware speed\n"); } static u64 vmx_read_tsc_offset(struct kvm_vcpu vcpu) { return vmcs_read64(TSC_OFFSET); } / * writes 'offset' into guest's timestamp counter offset register / static void vmx_write_tsc_offset(struct kvm_vcpu vcpu, u64 offset) { if (is_guest_mode(vcpu)) { /* * We're here if L1 chose not to trap WRMSR to TSC. According * to the spec, this should set L1's TSC; The offset that L1 * set for L2 remains unchanged, and still needs to be added * to the newly set TSC to get L2's TSC. / struct vmcs12 vmcs12; to_vmx(vcpu)->nested.vmcs01_tsc_offset = offset; /* recalculate vmcs02.TSC_OFFSET: / vmcs12 = get_vmcs12(vcpu); vmcs_write64(TSC_OFFSET, offset + (nested_cpu_has(vmcs12, CPU_BASED_USE_TSC_OFFSETING) ? vmcs12->tsc_offset : 0)); } else { trace_kvm_write_tsc_offset(vcpu->vcpu_id, vmcs_read64(TSC_OFFSET), offset); vmcs_write64(TSC_OFFSET, offset); } } static void vmx_adjust_tsc_offset(struct kvm_vcpu vcpu, s64 adjustment, bool host) { u64 offset = vmcs_read64(TSC_OFFSET); vmcs_write64(TSC_OFFSET, offset + adjustment); if (is_guest_mode(vcpu)) { /* Even when running L2, the adjustment needs to apply to L1 / to_vmx(vcpu)->nested.vmcs01_tsc_offset += adjustment; } else trace_kvm_write_tsc_offset(vcpu->vcpu_id, offset, offset + adjustment); } static u64 vmx_compute_tsc_offset(struct kvm_vcpu vcpu, u64 target_tsc) { return target_tsc - native_read_tsc(); } static bool guest_cpuid_has_vmx(struct kvm_vcpu vcpu) { struct kvm_cpuid_entry2 best = kvm_find_cpuid_entry(vcpu, 1, 0); return best && (best->ecx & (1 << (X86_FEATURE_VMX & 31))); } /* * nested_vmx_allowed() checks whether a guest should be allowed to use VMX * instructions and MSRs (i.e., nested VMX). Nested VMX is disabled for * all guests if the "nested" module option is off, and can also be disabled * for a single guest by disabling its VMX cpuid bit. / static inline bool nested_vmx_allowed(struct kvm_vcpu vcpu) { return nested && guest_cpuid_has_vmx(vcpu); } /* * nested_vmx_setup_ctls_msrs() sets up variables containing the values to be * returned for the various VMX controls MSRs when nested VMX is enabled. * The same values should also be used to verify that vmcs12 control fields are * valid during nested entry from L1 to L2. * Each of these control msrs has a low and high 32-bit half: A low bit is on * if the corresponding bit in the (32-bit) control field must be on, and a * bit in the high half is on if the corresponding bit in the control field * may be on. See also vmx_control_verify(). * TODO: allow these variables to be modified (downgraded) by module options * or other means. / static u32 nested_vmx_procbased_ctls_low, nested_vmx_procbased_ctls_high; static u32 nested_vmx_true_procbased_ctls_low; static u32 nested_vmx_secondary_ctls_low, nested_vmx_secondary_ctls_high; static u32 nested_vmx_pinbased_ctls_low, nested_vmx_pinbased_ctls_high; static u32 nested_vmx_exit_ctls_low, nested_vmx_exit_ctls_high; static u32 nested_vmx_true_exit_ctls_low; static u32 nested_vmx_entry_ctls_low, nested_vmx_entry_ctls_high; static u32 nested_vmx_true_entry_ctls_low; static u32 nested_vmx_misc_low, nested_vmx_misc_high; static u32 nested_vmx_ept_caps; static __init void nested_vmx_setup_ctls_msrs(void) { / * Note that as a general rule, the high half of the MSRs (bits in * the control fields which may be 1) should be initialized by the * intersection of the underlying hardware's MSR (i.e., features which * can be supported) and the list of features we want to expose - * because they are known to be properly supported in our code. * Also, usually, the low half of the MSRs (bits which must be 1) can * be set to 0, meaning that L1 may turn off any of these bits. The * reason is that if one of these bits is necessary, it will appear * in vmcs01 and prepare_vmcs02, when it bitwise-or's the control * fields of vmcs01 and vmcs02, will turn these bits off - and * nested_vmx_exit_handled() will not pass related exits to L1. * These rules have exceptions below. / / pin-based controls / rdmsr(MSR_IA32_VMX_PINBASED_CTLS, nested_vmx_pinbased_ctls_low, nested_vmx_pinbased_ctls_high); nested_vmx_pinbased_ctls_low \|= PIN_BASED_ALWAYSON_WITHOUT_TRUE_MSR; nested_vmx_pinbased_ctls_high &= PIN_BASED_EXT_INTR_MASK \| PIN_BASED_NMI_EXITING \| PIN_BASED_VIRTUAL_NMIS; nested_vmx_pinbased_ctls_high \|= PIN_BASED_ALWAYSON_WITHOUT_TRUE_MSR \| PIN_BASED_VMX_PREEMPTION_TIMER; / exit controls / rdmsr(MSR_IA32_VMX_EXIT_CTLS, nested_vmx_exit_ctls_low, nested_vmx_exit_ctls_high); nested_vmx_exit_ctls_low = VM_EXIT_ALWAYSON_WITHOUT_TRUE_MSR; nested_vmx_exit_ctls_high &= #ifdef CONFIG_X86_64 VM_EXIT_HOST_ADDR_SPACE_SIZE \| #endif VM_EXIT_LOAD_IA32_PAT \| VM_EXIT_SAVE_IA32_PAT; nested_vmx_exit_ctls_high \|= VM_EXIT_ALWAYSON_WITHOUT_TRUE_MSR \| VM_EXIT_LOAD_IA32_EFER \| VM_EXIT_SAVE_IA32_EFER \| VM_EXIT_SAVE_VMX_PREEMPTION_TIMER \| VM_EXIT_ACK_INTR_ON_EXIT; if (vmx_mpx_supported()) nested_vmx_exit_ctls_high \|= VM_EXIT_CLEAR_BNDCFGS; / We support free control of debug control saving. / nested_vmx_true_exit_ctls_low = nested_vmx_exit_ctls_low & ~VM_EXIT_SAVE_DEBUG_CONTROLS; / entry controls / rdmsr(MSR_IA32_VMX_ENTRY_CTLS, nested_vmx_entry_ctls_low, nested_vmx_entry_ctls_high); nested_vmx_entry_ctls_low = VM_ENTRY_ALWAYSON_WITHOUT_TRUE_MSR; nested_vmx_entry_ctls_high &= #ifdef CONFIG_X86_64 VM_ENTRY_IA32E_MODE \| #endif VM_ENTRY_LOAD_IA32_PAT; nested_vmx_entry_ctls_high \|= (VM_ENTRY_ALWAYSON_WITHOUT_TRUE_MSR \| VM_ENTRY_LOAD_IA32_EFER); if (vmx_mpx_supported()) nested_vmx_entry_ctls_high \|= VM_ENTRY_LOAD_BNDCFGS; / We support free control of debug control loading. / nested_vmx_true_entry_ctls_low = nested_vmx_entry_ctls_low & ~VM_ENTRY_LOAD_DEBUG_CONTROLS; / cpu-based controls / rdmsr(MSR_IA32_VMX_PROCBASED_CTLS, nested_vmx_procbased_ctls_low, nested_vmx_procbased_ctls_high); nested_vmx_procbased_ctls_low = CPU_BASED_ALWAYSON_WITHOUT_TRUE_MSR; nested_vmx_procbased_ctls_high &= CPU_BASED_VIRTUAL_INTR_PENDING \| CPU_BASED_VIRTUAL_NMI_PENDING \| CPU_BASED_USE_TSC_OFFSETING \| CPU_BASED_HLT_EXITING \| CPU_BASED_INVLPG_EXITING \| CPU_BASED_MWAIT_EXITING \| CPU_BASED_CR3_LOAD_EXITING \| CPU_BASED_CR3_STORE_EXITING \| #ifdef CONFIG_X86_64 CPU_BASED_CR8_LOAD_EXITING \| CPU_BASED_CR8_STORE_EXITING \| #endif CPU_BASED_MOV_DR_EXITING \| CPU_BASED_UNCOND_IO_EXITING \| CPU_BASED_USE_IO_BITMAPS \| CPU_BASED_MONITOR_EXITING \| CPU_BASED_RDPMC_EXITING \| CPU_BASED_RDTSC_EXITING \| CPU_BASED_PAUSE_EXITING \| CPU_BASED_TPR_SHADOW \| CPU_BASED_ACTIVATE_SECONDARY_CONTROLS; / * We can allow some features even when not supported by the * hardware. For example, L1 can specify an MSR bitmap - and we * can use it to avoid exits to L1 - even when L0 runs L2 * without MSR bitmaps. / nested_vmx_procbased_ctls_high \|= CPU_BASED_ALWAYSON_WITHOUT_TRUE_MSR \| CPU_BASED_USE_MSR_BITMAPS; / We support free control of CR3 access interception. / nested_vmx_true_procbased_ctls_low = nested_vmx_procbased_ctls_low & ~(CPU_BASED_CR3_LOAD_EXITING \| CPU_BASED_CR3_STORE_EXITING); / secondary cpu-based controls / rdmsr(MSR_IA32_VMX_PROCBASED_CTLS2, nested_vmx_secondary_ctls_low, nested_vmx_secondary_ctls_high); nested_vmx_secondary_ctls_low = 0; nested_vmx_secondary_ctls_high &= SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES \| SECONDARY_EXEC_UNRESTRICTED_GUEST \| SECONDARY_EXEC_WBINVD_EXITING; if (enable_ept) { / nested EPT: emulate EPT also to L1 / nested_vmx_secondary_ctls_high \|= SECONDARY_EXEC_ENABLE_EPT; nested_vmx_ept_caps = VMX_EPT_PAGE_WALK_4_BIT \| VMX_EPTP_WB_BIT \| VMX_EPT_2MB_PAGE_BIT \| VMX_EPT_INVEPT_BIT; nested_vmx_ept_caps &= vmx_capability.ept; / * For nested guests, we don't do anything specific * for single context invalidation. Hence, only advertise * support for global context invalidation. / nested_vmx_ept_caps \|= VMX_EPT_EXTENT_GLOBAL_BIT; } else nested_vmx_ept_caps = 0; / miscellaneous data / rdmsr(MSR_IA32_VMX_MISC, nested_vmx_misc_low, nested_vmx_misc_high); nested_vmx_misc_low &= VMX_MISC_SAVE_EFER_LMA; nested_vmx_misc_low \|= VMX_MISC_EMULATED_PREEMPTION_TIMER_RATE \| VMX_MISC_ACTIVITY_HLT; nested_vmx_misc_high = 0; } static inline bool vmx_control_verify(u32 control, u32 low, u32 high) { / * Bits 0 in high must be 0, and bits 1 in low must be 1. / return ((control & high) \| low) == control; } static inline u64 vmx_control_msr(u32 low, u32 high) { return low \| ((u64)high << 32); } / Returns 0 on success, non-0 otherwise. / static int vmx_get_vmx_msr(struct kvm_vcpu vcpu, u32 msr_index, u64 pdata) { switch (msr_index) { case MSR_IA32_VMX_BASIC: / * This MSR reports some information about VMX support. We * should return information about the VMX we emulate for the * guest, and the VMCS structure we give it - not about the * VMX support of the underlying hardware. / pdata = VMCS12_REVISION \| VMX_BASIC_TRUE_CTLS \| ((u64)VMCS12_SIZE << VMX_BASIC_VMCS_SIZE_SHIFT) \| (VMX_BASIC_MEM_TYPE_WB << VMX_BASIC_MEM_TYPE_SHIFT); break; case MSR_IA32_VMX_TRUE_PINBASED_CTLS: case MSR_IA32_VMX_PINBASED_CTLS: pdata = vmx_control_msr(nested_vmx_pinbased_ctls_low, nested_vmx_pinbased_ctls_high); break; case MSR_IA32_VMX_TRUE_PROCBASED_CTLS: pdata = vmx_control_msr(nested_vmx_true_procbased_ctls_low, nested_vmx_procbased_ctls_high); break; case MSR_IA32_VMX_PROCBASED_CTLS: pdata = vmx_control_msr(nested_vmx_procbased_ctls_low, nested_vmx_procbased_ctls_high); break; case MSR_IA32_VMX_TRUE_EXIT_CTLS: pdata = vmx_control_msr(nested_vmx_true_exit_ctls_low, nested_vmx_exit_ctls_high); break; case MSR_IA32_VMX_EXIT_CTLS: pdata = vmx_control_msr(nested_vmx_exit_ctls_low, nested_vmx_exit_ctls_high); break; case MSR_IA32_VMX_TRUE_ENTRY_CTLS: pdata = vmx_control_msr(nested_vmx_true_entry_ctls_low, nested_vmx_entry_ctls_high); break; case MSR_IA32_VMX_ENTRY_CTLS: pdata = vmx_control_msr(nested_vmx_entry_ctls_low, nested_vmx_entry_ctls_high); break; case MSR_IA32_VMX_MISC: pdata = vmx_control_msr(nested_vmx_misc_low, nested_vmx_misc_high); break; /* * These MSRs specify bits which the guest must keep fixed (on or off) * while L1 is in VMXON mode (in L1's root mode, or running an L2). * We picked the standard core2 setting. / #define VMXON_CR0_ALWAYSON (X86_CR0_PE \| X86_CR0_PG \| X86_CR0_NE) #define VMXON_CR4_ALWAYSON X86_CR4_VMXE case MSR_IA32_VMX_CR0_FIXED0: pdata = VMXON_CR0_ALWAYSON; break; case MSR_IA32_VMX_CR0_FIXED1: pdata = -1ULL; break; case MSR_IA32_VMX_CR4_FIXED0: pdata = VMXON_CR4_ALWAYSON; break; case MSR_IA32_VMX_CR4_FIXED1: pdata = -1ULL; break; case MSR_IA32_VMX_VMCS_ENUM: pdata = 0x2e; /* highest index: VMX_PREEMPTION_TIMER_VALUE / break; case MSR_IA32_VMX_PROCBASED_CTLS2: pdata = vmx_control_msr(nested_vmx_secondary_ctls_low, nested_vmx_secondary_ctls_high); break; case MSR_IA32_VMX_EPT_VPID_CAP: /* Currently, no nested vpid support / pdata = nested_vmx_ept_caps; break; default: return 1; } return 0; } /* * Reads an msr value (of 'msr_index') into 'pdata'. * Returns 0 on success, non-0 otherwise. * Assumes vcpu_load() was already called. / static int vmx_get_msr(struct kvm_vcpu vcpu, u32 msr_index, u64 pdata) { u64 data; struct shared_msr_entry msr; if (!pdata) { printk(KERN_ERR "BUG: get_msr called with NULL pdata\n"); return -EINVAL; } switch (msr_index) { #ifdef CONFIG_X86_64 case MSR_FS_BASE: data = vmcs_readl(GUEST_FS_BASE); break; case MSR_GS_BASE: data = vmcs_readl(GUEST_GS_BASE); break; case MSR_KERNEL_GS_BASE: vmx_load_host_state(to_vmx(vcpu)); data = to_vmx(vcpu)->msr_guest_kernel_gs_base; break; #endif case MSR_EFER: return kvm_get_msr_common(vcpu, msr_index, pdata); case MSR_IA32_TSC: data = guest_read_tsc(); break; case MSR_IA32_SYSENTER_CS: data = vmcs_read32(GUEST_SYSENTER_CS); break; case MSR_IA32_SYSENTER_EIP: data = vmcs_readl(GUEST_SYSENTER_EIP); break; case MSR_IA32_SYSENTER_ESP: data = vmcs_readl(GUEST_SYSENTER_ESP); break; case MSR_IA32_BNDCFGS: if (!vmx_mpx_supported()) return 1; data = vmcs_read64(GUEST_BNDCFGS); break; case MSR_IA32_FEATURE_CONTROL: if (!nested_vmx_allowed(vcpu)) return 1; data = to_vmx(vcpu)->nested.msr_ia32_feature_control; break; case MSR_IA32_VMX_BASIC ... MSR_IA32_VMX_VMFUNC: if (!nested_vmx_allowed(vcpu)) return 1; return vmx_get_vmx_msr(vcpu, msr_index, pdata); case MSR_TSC_AUX: if (!to_vmx(vcpu)->rdtscp_enabled) return 1; /* Otherwise falls through / default: msr = find_msr_entry(to_vmx(vcpu), msr_index); if (msr) { data = msr->data; break; } return kvm_get_msr_common(vcpu, msr_index, pdata); } pdata = data; return 0; } static void vmx_leave_nested(struct kvm_vcpu vcpu); / * Writes msr value into into the appropriate "register". * Returns 0 on success, non-0 otherwise. * Assumes vcpu_load() was already called. / static int vmx_set_msr(struct kvm_vcpu vcpu, struct msr_data msr_info) { struct vcpu_vmx vmx = to_vmx(vcpu); struct shared_msr_entry msr; int ret = 0; u32 msr_index = msr_info->index; u64 data = msr_info->data; switch (msr_index) { case MSR_EFER: ret = kvm_set_msr_common(vcpu, msr_info); break; #ifdef CONFIG_X86_64 case MSR_FS_BASE: vmx_segment_cache_clear(vmx); vmcs_writel(GUEST_FS_BASE, data); break; case MSR_GS_BASE: vmx_segment_cache_clear(vmx); vmcs_writel(GUEST_GS_BASE, data); break; case MSR_KERNEL_GS_BASE: vmx_load_host_state(vmx); vmx->msr_guest_kernel_gs_base = data; break; #endif case MSR_IA32_SYSENTER_CS: vmcs_write32(GUEST_SYSENTER_CS, data); break; case MSR_IA32_SYSENTER_EIP: vmcs_writel(GUEST_SYSENTER_EIP, data); break; case MSR_IA32_SYSENTER_ESP: vmcs_writel(GUEST_SYSENTER_ESP, data); break; case MSR_IA32_BNDCFGS: if (!vmx_mpx_supported()) return 1; vmcs_write64(GUEST_BNDCFGS, data); break; case MSR_IA32_TSC: kvm_write_tsc(vcpu, msr_info); break; case MSR_IA32_CR_PAT: if (vmcs_config.vmentry_ctrl & VM_ENTRY_LOAD_IA32_PAT) { if (!kvm_mtrr_valid(vcpu, MSR_IA32_CR_PAT, data)) return 1; vmcs_write64(GUEST_IA32_PAT, data); vcpu->arch.pat = data; break; } ret = kvm_set_msr_common(vcpu, msr_info); break; case MSR_IA32_TSC_ADJUST: ret = kvm_set_msr_common(vcpu, msr_info); break; case MSR_IA32_FEATURE_CONTROL: if (!nested_vmx_allowed(vcpu) \|\| (to_vmx(vcpu)->nested.msr_ia32_feature_control & FEATURE_CONTROL_LOCKED && !msr_info->host_initiated)) return 1; vmx->nested.msr_ia32_feature_control = data; if (msr_info->host_initiated && data == 0) vmx_leave_nested(vcpu); break; case MSR_IA32_VMX_BASIC ... MSR_IA32_VMX_VMFUNC: return 1; / they are read-only / case MSR_TSC_AUX: if (!vmx->rdtscp_enabled) return 1; / Check reserved bit, higher 32 bits should be zero / if ((data >> 32) != 0) return 1; / Otherwise falls through / default: msr = find_msr_entry(vmx, msr_index); if (msr) { msr->data = data; if (msr - vmx->guest_msrs < vmx->save_nmsrs) { preempt_disable(); kvm_set_shared_msr(msr->index, msr->data, msr->mask); preempt_enable(); } break; } ret = kvm_set_msr_common(vcpu, msr_info); } return ret; } static void vmx_cache_reg(struct kvm_vcpu vcpu, enum kvm_reg reg) { __set_bit(reg, (unsigned long )&vcpu->arch.regs_avail); switch (reg) { case VCPU_REGS_RSP: vcpu->arch.regs[VCPU_REGS_RSP] = vmcs_readl(GUEST_RSP); break; case VCPU_REGS_RIP: vcpu->arch.regs[VCPU_REGS_RIP] = vmcs_readl(GUEST_RIP); break; case VCPU_EXREG_PDPTR: if (enable_ept) ept_save_pdptrs(vcpu); break; default: break; } } static __init int cpu_has_kvm_support(void) { return cpu_has_vmx(); } static __init int vmx_disabled_by_bios(void) { u64 msr; rdmsrl(MSR_IA32_FEATURE_CONTROL, msr); if (msr & FEATURE_CONTROL_LOCKED) { / launched w/ TXT and VMX disabled / if (!(msr & FEATURE_CONTROL_VMXON_ENABLED_INSIDE_SMX) && tboot_enabled()) return 1; / launched w/o TXT and VMX only enabled w/ TXT / if (!(msr & FEATURE_CONTROL_VMXON_ENABLED_OUTSIDE_SMX) && (msr & FEATURE_CONTROL_VMXON_ENABLED_INSIDE_SMX) && !tboot_enabled()) { printk(KERN_WARNING "kvm: disable TXT in the BIOS or " "activate TXT before enabling KVM\n"); return 1; } / launched w/o TXT and VMX disabled / if (!(msr & FEATURE_CONTROL_VMXON_ENABLED_OUTSIDE_SMX) && !tboot_enabled()) return 1; } return 0; } static void kvm_cpu_vmxon(u64 addr) { asm volatile (ASM_VMX_VMXON_RAX : : "a"(&addr), "m"(addr) : "memory", "cc"); } static int hardware_enable(void) { int cpu = raw_smp_processor_id(); u64 phys_addr = __pa(per_cpu(vmxarea, cpu)); u64 old, test_bits; if (read_cr4() & X86_CR4_VMXE) return -EBUSY; INIT_LIST_HEAD(&per_cpu(loaded_vmcss_on_cpu, cpu)); / * Now we can enable the vmclear operation in kdump * since the loaded_vmcss_on_cpu list on this cpu * has been initialized. * * Though the cpu is not in VMX operation now, there * is no problem to enable the vmclear operation * for the loaded_vmcss_on_cpu list is empty! / crash_enable_local_vmclear(cpu); rdmsrl(MSR_IA32_FEATURE_CONTROL, old); test_bits = FEATURE_CONTROL_LOCKED; test_bits \|= FEATURE_CONTROL_VMXON_ENABLED_OUTSIDE_SMX; if (tboot_enabled()) test_bits \|= FEATURE_CONTROL_VMXON_ENABLED_INSIDE_SMX; if ((old & test_bits) != test_bits) { / enable and lock / wrmsrl(MSR_IA32_FEATURE_CONTROL, old \| test_bits); } write_cr4(read_cr4() \| X86_CR4_VMXE); / FIXME: not cpu hotplug safe / if (vmm_exclusive) { kvm_cpu_vmxon(phys_addr); ept_sync_global(); } native_store_gdt(this_cpu_ptr(&host_gdt)); return 0; } static void vmclear_local_loaded_vmcss(void) { int cpu = raw_smp_processor_id(); struct loaded_vmcs v, n; list_for_each_entry_safe(v, n, &per_cpu(loaded_vmcss_on_cpu, cpu), loaded_vmcss_on_cpu_link) __loaded_vmcs_clear(v); } / Just like cpu_vmxoff(), but with the __kvm_handle_fault_on_reboot() * tricks. / static void kvm_cpu_vmxoff(void) { asm volatile (__ex(ASM_VMX_VMXOFF) : : : "cc"); } static void hardware_disable(void) { if (vmm_exclusive) { vmclear_local_loaded_vmcss(); kvm_cpu_vmxoff(); } write_cr4(read_cr4() & ~X86_CR4_VMXE); } static __init int adjust_vmx_controls(u32 ctl_min, u32 ctl_opt, u32 msr, u32 result) { u32 vmx_msr_low, vmx_msr_high; u32 ctl = ctl_min \| ctl_opt; rdmsr(msr, vmx_msr_low, vmx_msr_high); ctl &= vmx_msr_high; /* bit == 0 in high word ==> must be zero / ctl \|= vmx_msr_low; / bit == 1 in low word ==> must be one / / Ensure minimum (required) set of control bits are supported. / if (ctl_min & ~ctl) return -EIO; result = ctl; return 0; } static __init bool allow_1_setting(u32 msr, u32 ctl) { u32 vmx_msr_low, vmx_msr_high; rdmsr(msr, vmx_msr_low, vmx_msr_high); return vmx_msr_high & ctl; } static __init int setup_vmcs_config(struct vmcs_config vmcs_conf) { u32 vmx_msr_low, vmx_msr_high; u32 min, opt, min2, opt2; u32 _pin_based_exec_control = 0; u32 _cpu_based_exec_control = 0; u32 _cpu_based_2nd_exec_control = 0; u32 _vmexit_control = 0; u32 _vmentry_control = 0; min = CPU_BASED_HLT_EXITING \| #ifdef CONFIG_X86_64 CPU_BASED_CR8_LOAD_EXITING \| CPU_BASED_CR8_STORE_EXITING \| #endif CPU_BASED_CR3_LOAD_EXITING \| CPU_BASED_CR3_STORE_EXITING \| CPU_BASED_USE_IO_BITMAPS \| CPU_BASED_MOV_DR_EXITING \| CPU_BASED_USE_TSC_OFFSETING \| CPU_BASED_MWAIT_EXITING \| CPU_BASED_MONITOR_EXITING \| CPU_BASED_INVLPG_EXITING \| CPU_BASED_RDPMC_EXITING; opt = CPU_BASED_TPR_SHADOW \| CPU_BASED_USE_MSR_BITMAPS \| CPU_BASED_ACTIVATE_SECONDARY_CONTROLS; if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_PROCBASED_CTLS, &_cpu_based_exec_control) < 0) return -EIO; #ifdef CONFIG_X86_64 if ((_cpu_based_exec_control & CPU_BASED_TPR_SHADOW)) _cpu_based_exec_control &= ~CPU_BASED_CR8_LOAD_EXITING & ~CPU_BASED_CR8_STORE_EXITING; #endif if (_cpu_based_exec_control & CPU_BASED_ACTIVATE_SECONDARY_CONTROLS) { min2 = 0; opt2 = SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES \| SECONDARY_EXEC_VIRTUALIZE_X2APIC_MODE \| SECONDARY_EXEC_WBINVD_EXITING \| SECONDARY_EXEC_ENABLE_VPID \| SECONDARY_EXEC_ENABLE_EPT \| SECONDARY_EXEC_UNRESTRICTED_GUEST \| SECONDARY_EXEC_PAUSE_LOOP_EXITING \| SECONDARY_EXEC_RDTSCP \| SECONDARY_EXEC_ENABLE_INVPCID \| SECONDARY_EXEC_APIC_REGISTER_VIRT \| SECONDARY_EXEC_VIRTUAL_INTR_DELIVERY \| SECONDARY_EXEC_SHADOW_VMCS; if (adjust_vmx_controls(min2, opt2, MSR_IA32_VMX_PROCBASED_CTLS2, &_cpu_based_2nd_exec_control) < 0) return -EIO; } #ifndef CONFIG_X86_64 if (!(_cpu_based_2nd_exec_control & SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES)) _cpu_based_exec_control &= ~CPU_BASED_TPR_SHADOW; #endif if (!(_cpu_based_exec_control & CPU_BASED_TPR_SHADOW)) _cpu_based_2nd_exec_control &= ~( SECONDARY_EXEC_APIC_REGISTER_VIRT \| SECONDARY_EXEC_VIRTUALIZE_X2APIC_MODE \| SECONDARY_EXEC_VIRTUAL_INTR_DELIVERY); if (_cpu_based_2nd_exec_control & SECONDARY_EXEC_ENABLE_EPT) { / CR3 accesses and invlpg don't need to cause VM Exits when EPT enabled / _cpu_based_exec_control &= ~(CPU_BASED_CR3_LOAD_EXITING \| CPU_BASED_CR3_STORE_EXITING \| CPU_BASED_INVLPG_EXITING); rdmsr(MSR_IA32_VMX_EPT_VPID_CAP, vmx_capability.ept, vmx_capability.vpid); } min = VM_EXIT_SAVE_DEBUG_CONTROLS; #ifdef CONFIG_X86_64 min \|= VM_EXIT_HOST_ADDR_SPACE_SIZE; #endif opt = VM_EXIT_SAVE_IA32_PAT \| VM_EXIT_LOAD_IA32_PAT \| VM_EXIT_ACK_INTR_ON_EXIT \| VM_EXIT_CLEAR_BNDCFGS; if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_EXIT_CTLS, &_vmexit_control) < 0) return -EIO; min = PIN_BASED_EXT_INTR_MASK \| PIN_BASED_NMI_EXITING; opt = PIN_BASED_VIRTUAL_NMIS \| PIN_BASED_POSTED_INTR; if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_PINBASED_CTLS, &_pin_based_exec_control) < 0) return -EIO; if (!(_cpu_based_2nd_exec_control & SECONDARY_EXEC_VIRTUAL_INTR_DELIVERY) \|\| !(_vmexit_control & VM_EXIT_ACK_INTR_ON_EXIT)) _pin_based_exec_control &= ~PIN_BASED_POSTED_INTR; min = VM_ENTRY_LOAD_DEBUG_CONTROLS; opt = VM_ENTRY_LOAD_IA32_PAT \| VM_ENTRY_LOAD_BNDCFGS; if (adjust_vmx_controls(min, opt, MSR_IA32_VMX_ENTRY_CTLS, &_vmentry_control) < 0) return -EIO; rdmsr(MSR_IA32_VMX_BASIC, vmx_msr_low, vmx_msr_high); / IA-32 SDM Vol 3B: VMCS size is never greater than 4kB. / if ((vmx_msr_high & 0x1fff) > PAGE_SIZE) return -EIO; #ifdef CONFIG_X86_64 / IA-32 SDM Vol 3B: 64-bit CPUs always have VMX_BASIC_MSR[48]==0. / if (vmx_msr_high & (1u<<16)) return -EIO; #endif / Require Write-Back (WB) memory type for VMCS accesses. / if (((vmx_msr_high >> 18) & 15) != 6) return -EIO; vmcs_conf->size = vmx_msr_high & 0x1fff; vmcs_conf->order = get_order(vmcs_config.size); vmcs_conf->revision_id = vmx_msr_low; vmcs_conf->pin_based_exec_ctrl = _pin_based_exec_control; vmcs_conf->cpu_based_exec_ctrl = _cpu_based_exec_control; vmcs_conf->cpu_based_2nd_exec_ctrl = _cpu_based_2nd_exec_control; vmcs_conf->vmexit_ctrl = _vmexit_control; vmcs_conf->vmentry_ctrl = _vmentry_control; cpu_has_load_ia32_efer = allow_1_setting(MSR_IA32_VMX_ENTRY_CTLS, VM_ENTRY_LOAD_IA32_EFER) && allow_1_setting(MSR_IA32_VMX_EXIT_CTLS, VM_EXIT_LOAD_IA32_EFER); cpu_has_load_perf_global_ctrl = allow_1_setting(MSR_IA32_VMX_ENTRY_CTLS, VM_ENTRY_LOAD_IA32_PERF_GLOBAL_CTRL) && allow_1_setting(MSR_IA32_VMX_EXIT_CTLS, VM_EXIT_LOAD_IA32_PERF_GLOBAL_CTRL); / * Some cpus support VM_ENTRY_(LOAD\|SAVE)_IA32_PERF_GLOBAL_CTRL * but due to arrata below it can't be used. Workaround is to use * msr load mechanism to switch IA32_PERF_GLOBAL_CTRL. * * VM Exit May Incorrectly Clear IA32_PERF_GLOBAL_CTRL [34:32] * * AAK155 (model 26) * AAP115 (model 30) * AAT100 (model 37) * BC86,AAY89,BD102 (model 44) * BA97 (model 46) * / if (cpu_has_load_perf_global_ctrl && boot_cpu_data.x86 == 0x6) { switch (boot_cpu_data.x86_model) { case 26: case 30: case 37: case 44: case 46: cpu_has_load_perf_global_ctrl = false; printk_once(KERN_WARNING"kvm: VM_EXIT_LOAD_IA32_PERF_GLOBAL_CTRL " "does not work properly. Using workaround\n"); break; default: break; } } return 0; } static struct vmcs alloc_vmcs_cpu(int cpu) { int node = cpu_to_node(cpu); struct page pages; struct vmcs vmcs; pages = alloc_pages_exact_node(node, GFP_KERNEL, vmcs_config.order); if (!pages) return NULL; vmcs = page_address(pages); memset(vmcs, 0, vmcs_config.size); vmcs->revision_id = vmcs_config.revision_id; /* vmcs revision id / return vmcs; } static struct vmcs alloc_vmcs(void) { return alloc_vmcs_cpu(raw_smp_processor_id()); } static void free_vmcs(struct vmcs vmcs) { free_pages((unsigned long)vmcs, vmcs_config.order); } / * Free a VMCS, but before that VMCLEAR it on the CPU where it was last loaded / static void free_loaded_vmcs(struct loaded_vmcs loaded_vmcs) { if (!loaded_vmcs->vmcs) return; loaded_vmcs_clear(loaded_vmcs); free_vmcs(loaded_vmcs->vmcs); loaded_vmcs->vmcs = NULL; } static void free_kvm_area(void) { int cpu; for_each_possible_cpu(cpu) { free_vmcs(per_cpu(vmxarea, cpu)); per_cpu(vmxarea, cpu) = NULL; } } static void init_vmcs_shadow_fields(void) { int i, j; /* No checks for read only fields yet / for (i = j = 0; i < max_shadow_read_write_fields; i++) { switch (shadow_read_write_fields[i]) { case GUEST_BNDCFGS: if (!vmx_mpx_supported()) continue; break; default: break; } if (j < i) shadow_read_write_fields[j] = shadow_read_write_fields[i]; j++; } max_shadow_read_write_fields = j; / shadowed fields guest access without vmexit / for (i = 0; i < max_shadow_read_write_fields; i++) { clear_bit(shadow_read_write_fields[i], vmx_vmwrite_bitmap); clear_bit(shadow_read_write_fields[i], vmx_vmread_bitmap); } for (i = 0; i < max_shadow_read_only_fields; i++) clear_bit(shadow_read_only_fields[i], vmx_vmread_bitmap); } static __init int alloc_kvm_area(void) { int cpu; for_each_possible_cpu(cpu) { struct vmcs vmcs; vmcs = alloc_vmcs_cpu(cpu); if (!vmcs) { free_kvm_area(); return -ENOMEM; } per_cpu(vmxarea, cpu) = vmcs; } return 0; } static __init int hardware_setup(void) { if (setup_vmcs_config(&vmcs_config) < 0) return -EIO; if (boot_cpu_has(X86_FEATURE_NX)) kvm_enable_efer_bits(EFER_NX); if (!cpu_has_vmx_vpid()) enable_vpid = 0; if (!cpu_has_vmx_shadow_vmcs()) enable_shadow_vmcs = 0; if (enable_shadow_vmcs) init_vmcs_shadow_fields(); if (!cpu_has_vmx_ept() \|\| !cpu_has_vmx_ept_4levels()) { enable_ept = 0; enable_unrestricted_guest = 0; enable_ept_ad_bits = 0; } if (!cpu_has_vmx_ept_ad_bits()) enable_ept_ad_bits = 0; if (!cpu_has_vmx_unrestricted_guest()) enable_unrestricted_guest = 0; if (!cpu_has_vmx_flexpriority()) { flexpriority_enabled = 0; /* * set_apic_access_page_addr() is used to reload apic access * page upon invalidation. No need to do anything if the * processor does not have the APIC_ACCESS_ADDR VMCS field. / kvm_x86_ops->set_apic_access_page_addr = NULL; } if (!cpu_has_vmx_tpr_shadow()) kvm_x86_ops->update_cr8_intercept = NULL; if (enable_ept && !cpu_has_vmx_ept_2m_page()) kvm_disable_largepages(); if (!cpu_has_vmx_ple()) ple_gap = 0; if (!cpu_has_vmx_apicv()) enable_apicv = 0; if (enable_apicv) kvm_x86_ops->update_cr8_intercept = NULL; else { kvm_x86_ops->hwapic_irr_update = NULL; kvm_x86_ops->deliver_posted_interrupt = NULL; kvm_x86_ops->sync_pir_to_irr = vmx_sync_pir_to_irr_dummy; } if (nested) nested_vmx_setup_ctls_msrs(); return alloc_kvm_area(); } static __exit void hardware_unsetup(void) { free_kvm_area(); } static bool emulation_required(struct kvm_vcpu vcpu) { return emulate_invalid_guest_state && !guest_state_valid(vcpu); } static void fix_pmode_seg(struct kvm_vcpu vcpu, int seg, struct kvm_segment save) { if (!emulate_invalid_guest_state) { /* * CS and SS RPL should be equal during guest entry according * to VMX spec, but in reality it is not always so. Since vcpu * is in the middle of the transition from real mode to * protected mode it is safe to assume that RPL 0 is a good * default value. / if (seg == VCPU_SREG_CS \|\| seg == VCPU_SREG_SS) save->selector &= ~SELECTOR_RPL_MASK; save->dpl = save->selector & SELECTOR_RPL_MASK; save->s = 1; } vmx_set_segment(vcpu, save, seg); } static void enter_pmode(struct kvm_vcpu vcpu) { unsigned long flags; struct vcpu_vmx vmx = to_vmx(vcpu); / * Update real mode segment cache. It may be not up-to-date if sement * register was written while vcpu was in a guest mode. / vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_ES], VCPU_SREG_ES); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_DS], VCPU_SREG_DS); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_FS], VCPU_SREG_FS); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_GS], VCPU_SREG_GS); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_SS], VCPU_SREG_SS); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_CS], VCPU_SREG_CS); vmx->rmode.vm86_active = 0; vmx_segment_cache_clear(vmx); vmx_set_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_TR], VCPU_SREG_TR); flags = vmcs_readl(GUEST_RFLAGS); flags &= RMODE_GUEST_OWNED_EFLAGS_BITS; flags \|= vmx->rmode.save_rflags & ~RMODE_GUEST_OWNED_EFLAGS_BITS; vmcs_writel(GUEST_RFLAGS, flags); vmcs_writel(GUEST_CR4, (vmcs_readl(GUEST_CR4) & ~X86_CR4_VME) \| (vmcs_readl(CR4_READ_SHADOW) & X86_CR4_VME)); update_exception_bitmap(vcpu); fix_pmode_seg(vcpu, VCPU_SREG_CS, &vmx->rmode.segs[VCPU_SREG_CS]); fix_pmode_seg(vcpu, VCPU_SREG_SS, &vmx->rmode.segs[VCPU_SREG_SS]); fix_pmode_seg(vcpu, VCPU_SREG_ES, &vmx->rmode.segs[VCPU_SREG_ES]); fix_pmode_seg(vcpu, VCPU_SREG_DS, &vmx->rmode.segs[VCPU_SREG_DS]); fix_pmode_seg(vcpu, VCPU_SREG_FS, &vmx->rmode.segs[VCPU_SREG_FS]); fix_pmode_seg(vcpu, VCPU_SREG_GS, &vmx->rmode.segs[VCPU_SREG_GS]); } static void fix_rmode_seg(int seg, struct kvm_segment save) { const struct kvm_vmx_segment_field sf = &kvm_vmx_segment_fields[seg]; struct kvm_segment var = save; var.dpl = 0x3; if (seg == VCPU_SREG_CS) var.type = 0x3; if (!emulate_invalid_guest_state) { var.selector = var.base >> 4; var.base = var.base & 0xffff0; var.limit = 0xffff; var.g = 0; var.db = 0; var.present = 1; var.s = 1; var.l = 0; var.unusable = 0; var.type = 0x3; var.avl = 0; if (save->base & 0xf) printk_once(KERN_WARNING "kvm: segment base is not " "paragraph aligned when entering " "protected mode (seg=%d)", seg); } vmcs_write16(sf->selector, var.selector); vmcs_write32(sf->base, var.base); vmcs_write32(sf->limit, var.limit); vmcs_write32(sf->ar_bytes, vmx_segment_access_rights(&var)); } static void enter_rmode(struct kvm_vcpu vcpu) { unsigned long flags; struct vcpu_vmx vmx = to_vmx(vcpu); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_TR], VCPU_SREG_TR); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_ES], VCPU_SREG_ES); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_DS], VCPU_SREG_DS); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_FS], VCPU_SREG_FS); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_GS], VCPU_SREG_GS); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_SS], VCPU_SREG_SS); vmx_get_segment(vcpu, &vmx->rmode.segs[VCPU_SREG_CS], VCPU_SREG_CS); vmx->rmode.vm86_active = 1; /* * Very old userspace does not call KVM_SET_TSS_ADDR before entering * vcpu. Warn the user that an update is overdue. / if (!vcpu->kvm->arch.tss_addr) printk_once(KERN_WARNING "kvm: KVM_SET_TSS_ADDR need to be " "called before entering vcpu\n"); vmx_segment_cache_clear(vmx); vmcs_writel(GUEST_TR_BASE, vcpu->kvm->arch.tss_addr); vmcs_write32(GUEST_TR_LIMIT, RMODE_TSS_SIZE - 1); vmcs_write32(GUEST_TR_AR_BYTES, 0x008b); flags = vmcs_readl(GUEST_RFLAGS); vmx->rmode.save_rflags = flags; flags \|= X86_EFLAGS_IOPL \| X86_EFLAGS_VM; vmcs_writel(GUEST_RFLAGS, flags); vmcs_writel(GUEST_CR4, vmcs_readl(GUEST_CR4) \| X86_CR4_VME); update_exception_bitmap(vcpu); fix_rmode_seg(VCPU_SREG_SS, &vmx->rmode.segs[VCPU_SREG_SS]); fix_rmode_seg(VCPU_SREG_CS, &vmx->rmode.segs[VCPU_SREG_CS]); fix_rmode_seg(VCPU_SREG_ES, &vmx->rmode.segs[VCPU_SREG_ES]); fix_rmode_seg(VCPU_SREG_DS, &vmx->rmode.segs[VCPU_SREG_DS]); fix_rmode_seg(VCPU_SREG_GS, &vmx->rmode.segs[VCPU_SREG_GS]); fix_rmode_seg(VCPU_SREG_FS, &vmx->rmode.segs[VCPU_SREG_FS]); kvm_mmu_reset_context(vcpu); } static void vmx_set_efer(struct kvm_vcpu vcpu, u64 efer) { struct vcpu_vmx vmx = to_vmx(vcpu); struct shared_msr_entry msr = find_msr_entry(vmx, MSR_EFER); if (!msr) return; /* * Force kernel_gs_base reloading before EFER changes, as control * of this msr depends on is_long_mode(). / vmx_load_host_state(to_vmx(vcpu)); vcpu->arch.efer = efer; if (efer & EFER_LMA) { vm_entry_controls_setbit(to_vmx(vcpu), VM_ENTRY_IA32E_MODE); msr->data = efer; } else { vm_entry_controls_clearbit(to_vmx(vcpu), VM_ENTRY_IA32E_MODE); msr->data = efer & ~EFER_LME; } setup_msrs(vmx); } #ifdef CONFIG_X86_64 static void enter_lmode(struct kvm_vcpu vcpu) { u32 guest_tr_ar; vmx_segment_cache_clear(to_vmx(vcpu)); guest_tr_ar = vmcs_read32(GUEST_TR_AR_BYTES); if ((guest_tr_ar & AR_TYPE_MASK) != AR_TYPE_BUSY_64_TSS) { pr_debug_ratelimited("%s: tss fixup for long mode. \n", __func__); vmcs_write32(GUEST_TR_AR_BYTES, (guest_tr_ar & ~AR_TYPE_MASK) \| AR_TYPE_BUSY_64_TSS); } vmx_set_efer(vcpu, vcpu->arch.efer \| EFER_LMA); } static void exit_lmode(struct kvm_vcpu vcpu) { vm_entry_controls_clearbit(to_vmx(vcpu), VM_ENTRY_IA32E_MODE); vmx_set_efer(vcpu, vcpu->arch.efer & ~EFER_LMA); } #endif static void vmx_flush_tlb(struct kvm_vcpu vcpu) { vpid_sync_context(to_vmx(vcpu)); if (enable_ept) { if (!VALID_PAGE(vcpu->arch.mmu.root_hpa)) return; ept_sync_context(construct_eptp(vcpu->arch.mmu.root_hpa)); } } static void vmx_decache_cr0_guest_bits(struct kvm_vcpu vcpu) { ulong cr0_guest_owned_bits = vcpu->arch.cr0_guest_owned_bits; vcpu->arch.cr0 &= ~cr0_guest_owned_bits; vcpu->arch.cr0 \|= vmcs_readl(GUEST_CR0) & cr0_guest_owned_bits; } static void vmx_decache_cr3(struct kvm_vcpu vcpu) { if (enable_ept && is_paging(vcpu)) vcpu->arch.cr3 = vmcs_readl(GUEST_CR3); __set_bit(VCPU_EXREG_CR3, (ulong )&vcpu->arch.regs_avail); } static void vmx_decache_cr4_guest_bits(struct kvm_vcpu vcpu) { ulong cr4_guest_owned_bits = vcpu->arch.cr4_guest_owned_bits; vcpu->arch.cr4 &= ~cr4_guest_owned_bits; vcpu->arch.cr4 \|= vmcs_readl(GUEST_CR4) & cr4_guest_owned_bits; } static void ept_load_pdptrs(struct kvm_vcpu vcpu) { struct kvm_mmu mmu = vcpu->arch.walk_mmu; if (!test_bit(VCPU_EXREG_PDPTR, (unsigned long )&vcpu->arch.regs_dirty)) return; if (is_paging(vcpu) && is_pae(vcpu) && !is_long_mode(vcpu)) { vmcs_write64(GUEST_PDPTR0, mmu->pdptrs[0]); vmcs_write64(GUEST_PDPTR1, mmu->pdptrs[1]); vmcs_write64(GUEST_PDPTR2, mmu->pdptrs[2]); vmcs_write64(GUEST_PDPTR3, mmu->pdptrs[3]); } } static void ept_save_pdptrs(struct kvm_vcpu vcpu) { struct kvm_mmu mmu = vcpu->arch.walk_mmu; if (is_paging(vcpu) && is_pae(vcpu) && !is_long_mode(vcpu)) { mmu->pdptrs[0] = vmcs_read64(GUEST_PDPTR0); mmu->pdptrs[1] = vmcs_read64(GUEST_PDPTR1); mmu->pdptrs[2] = vmcs_read64(GUEST_PDPTR2); mmu->pdptrs[3] = vmcs_read64(GUEST_PDPTR3); } __set_bit(VCPU_EXREG_PDPTR, (unsigned long )&vcpu->arch.regs_avail); __set_bit(VCPU_EXREG_PDPTR, (unsigned long )&vcpu->arch.regs_dirty); } static int vmx_set_cr4(struct kvm_vcpu vcpu, unsigned long cr4); static void ept_update_paging_mode_cr0(unsigned long hw_cr0, unsigned long cr0, struct kvm_vcpu vcpu) { if (!test_bit(VCPU_EXREG_CR3, (ulong )&vcpu->arch.regs_avail)) vmx_decache_cr3(vcpu); if (!(cr0 & X86_CR0_PG)) { / From paging/starting to nonpaging / vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, vmcs_read32(CPU_BASED_VM_EXEC_CONTROL) \| (CPU_BASED_CR3_LOAD_EXITING \| CPU_BASED_CR3_STORE_EXITING)); vcpu->arch.cr0 = cr0; vmx_set_cr4(vcpu, kvm_read_cr4(vcpu)); } else if (!is_paging(vcpu)) { / From nonpaging to paging / vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, vmcs_read32(CPU_BASED_VM_EXEC_CONTROL) & ~(CPU_BASED_CR3_LOAD_EXITING \| CPU_BASED_CR3_STORE_EXITING)); vcpu->arch.cr0 = cr0; vmx_set_cr4(vcpu, kvm_read_cr4(vcpu)); } if (!(cr0 & X86_CR0_WP)) hw_cr0 &= ~X86_CR0_WP; } static void vmx_set_cr0(struct kvm_vcpu vcpu, unsigned long cr0) { struct vcpu_vmx vmx = to_vmx(vcpu); unsigned long hw_cr0; hw_cr0 = (cr0 & ~KVM_GUEST_CR0_MASK); if (enable_unrestricted_guest) hw_cr0 \|= KVM_VM_CR0_ALWAYS_ON_UNRESTRICTED_GUEST; else { hw_cr0 \|= KVM_VM_CR0_ALWAYS_ON; if (vmx->rmode.vm86_active && (cr0 & X86_CR0_PE)) enter_pmode(vcpu); if (!vmx->rmode.vm86_active && !(cr0 & X86_CR0_PE)) enter_rmode(vcpu); } #ifdef CONFIG_X86_64 if (vcpu->arch.efer & EFER_LME) { if (!is_paging(vcpu) && (cr0 & X86_CR0_PG)) enter_lmode(vcpu); if (is_paging(vcpu) && !(cr0 & X86_CR0_PG)) exit_lmode(vcpu); } #endif if (enable_ept) ept_update_paging_mode_cr0(&hw_cr0, cr0, vcpu); if (!vcpu->fpu_active) hw_cr0 \|= X86_CR0_TS \| X86_CR0_MP; vmcs_writel(CR0_READ_SHADOW, cr0); vmcs_writel(GUEST_CR0, hw_cr0); vcpu->arch.cr0 = cr0; /* depends on vcpu->arch.cr0 to be set to a new value / vmx->emulation_required = emulation_required(vcpu); } static u64 construct_eptp(unsigned long root_hpa) { u64 eptp; / TODO write the value reading from MSR / eptp = VMX_EPT_DEFAULT_MT \| VMX_EPT_DEFAULT_GAW << VMX_EPT_GAW_EPTP_SHIFT; if (enable_ept_ad_bits) eptp \|= VMX_EPT_AD_ENABLE_BIT; eptp \|= (root_hpa & PAGE_MASK); return eptp; } static void vmx_set_cr3(struct kvm_vcpu vcpu, unsigned long cr3) { unsigned long guest_cr3; u64 eptp; guest_cr3 = cr3; if (enable_ept) { eptp = construct_eptp(cr3); vmcs_write64(EPT_POINTER, eptp); if (is_paging(vcpu) \|\| is_guest_mode(vcpu)) guest_cr3 = kvm_read_cr3(vcpu); else guest_cr3 = vcpu->kvm->arch.ept_identity_map_addr; ept_load_pdptrs(vcpu); } vmx_flush_tlb(vcpu); vmcs_writel(GUEST_CR3, guest_cr3); } static int vmx_set_cr4(struct kvm_vcpu vcpu, unsigned long cr4) { unsigned long hw_cr4 = cr4 \| (to_vmx(vcpu)->rmode.vm86_active ? KVM_RMODE_VM_CR4_ALWAYS_ON : KVM_PMODE_VM_CR4_ALWAYS_ON); if (cr4 & X86_CR4_VMXE) { / * To use VMXON (and later other VMX instructions), a guest * must first be able to turn on cr4.VMXE (see handle_vmon()). * So basically the check on whether to allow nested VMX * is here. / if (!nested_vmx_allowed(vcpu)) return 1; } if (to_vmx(vcpu)->nested.vmxon && ((cr4 & VMXON_CR4_ALWAYSON) != VMXON_CR4_ALWAYSON)) return 1; vcpu->arch.cr4 = cr4; if (enable_ept) { if (!is_paging(vcpu)) { hw_cr4 &= ~X86_CR4_PAE; hw_cr4 \|= X86_CR4_PSE; / * SMEP/SMAP is disabled if CPU is in non-paging mode * in hardware. However KVM always uses paging mode to * emulate guest non-paging mode with TDP. * To emulate this behavior, SMEP/SMAP needs to be * manually disabled when guest switches to non-paging * mode. / hw_cr4 &= ~(X86_CR4_SMEP \| X86_CR4_SMAP); } else if (!(cr4 & X86_CR4_PAE)) { hw_cr4 &= ~X86_CR4_PAE; } } vmcs_writel(CR4_READ_SHADOW, cr4); vmcs_writel(GUEST_CR4, hw_cr4); return 0; } static void vmx_get_segment(struct kvm_vcpu vcpu, struct kvm_segment var, int seg) { struct vcpu_vmx vmx = to_vmx(vcpu); u32 ar; if (vmx->rmode.vm86_active && seg != VCPU_SREG_LDTR) { var = vmx->rmode.segs[seg]; if (seg == VCPU_SREG_TR \|\| var->selector == vmx_read_guest_seg_selector(vmx, seg)) return; var->base = vmx_read_guest_seg_base(vmx, seg); var->selector = vmx_read_guest_seg_selector(vmx, seg); return; } var->base = vmx_read_guest_seg_base(vmx, seg); var->limit = vmx_read_guest_seg_limit(vmx, seg); var->selector = vmx_read_guest_seg_selector(vmx, seg); ar = vmx_read_guest_seg_ar(vmx, seg); var->unusable = (ar >> 16) & 1; var->type = ar & 15; var->s = (ar >> 4) & 1; var->dpl = (ar >> 5) & 3; / * Some userspaces do not preserve unusable property. Since usable * segment has to be present according to VMX spec we can use present * property to amend userspace bug by making unusable segment always * nonpresent. vmx_segment_access_rights() already marks nonpresent * segment as unusable. / var->present = !var->unusable; var->avl = (ar >> 12) & 1; var->l = (ar >> 13) & 1; var->db = (ar >> 14) & 1; var->g = (ar >> 15) & 1; } static u64 vmx_get_segment_base(struct kvm_vcpu vcpu, int seg) { struct kvm_segment s; if (to_vmx(vcpu)->rmode.vm86_active) { vmx_get_segment(vcpu, &s, seg); return s.base; } return vmx_read_guest_seg_base(to_vmx(vcpu), seg); } static int vmx_get_cpl(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); if (unlikely(vmx->rmode.vm86_active)) return 0; else { int ar = vmx_read_guest_seg_ar(vmx, VCPU_SREG_SS); return AR_DPL(ar); } } static u32 vmx_segment_access_rights(struct kvm_segment var) { u32 ar; if (var->unusable \|\| !var->present) ar = 1 << 16; else { ar = var->type & 15; ar \|= (var->s & 1) << 4; ar \|= (var->dpl & 3) << 5; ar \|= (var->present & 1) << 7; ar \|= (var->avl & 1) << 12; ar \|= (var->l & 1) << 13; ar \|= (var->db & 1) << 14; ar \|= (var->g & 1) << 15; } return ar; } static void vmx_set_segment(struct kvm_vcpu vcpu, struct kvm_segment var, int seg) { struct vcpu_vmx vmx = to_vmx(vcpu); const struct kvm_vmx_segment_field sf = &kvm_vmx_segment_fields[seg]; vmx_segment_cache_clear(vmx); if (vmx->rmode.vm86_active && seg != VCPU_SREG_LDTR) { vmx->rmode.segs[seg] = var; if (seg == VCPU_SREG_TR) vmcs_write16(sf->selector, var->selector); else if (var->s) fix_rmode_seg(seg, &vmx->rmode.segs[seg]); goto out; } vmcs_writel(sf->base, var->base); vmcs_write32(sf->limit, var->limit); vmcs_write16(sf->selector, var->selector); /* * Fix the "Accessed" bit in AR field of segment registers for older * qemu binaries. * IA32 arch specifies that at the time of processor reset the * "Accessed" bit in the AR field of segment registers is 1. And qemu * is setting it to 0 in the userland code. This causes invalid guest * state vmexit when "unrestricted guest" mode is turned on. * Fix for this setup issue in cpu_reset is being pushed in the qemu * tree. Newer qemu binaries with that qemu fix would not need this * kvm hack. / if (enable_unrestricted_guest && (seg != VCPU_SREG_LDTR)) var->type \|= 0x1; / Accessed / vmcs_write32(sf->ar_bytes, vmx_segment_access_rights(var)); out: vmx->emulation_required = emulation_required(vcpu); } static void vmx_get_cs_db_l_bits(struct kvm_vcpu vcpu, int db, int l) { u32 ar = vmx_read_guest_seg_ar(to_vmx(vcpu), VCPU_SREG_CS); db = (ar >> 14) & 1; l = (ar >> 13) & 1; } static void vmx_get_idt(struct kvm_vcpu vcpu, struct desc_ptr dt) { dt->size = vmcs_read32(GUEST_IDTR_LIMIT); dt->address = vmcs_readl(GUEST_IDTR_BASE); } static void vmx_set_idt(struct kvm_vcpu vcpu, struct desc_ptr dt) { vmcs_write32(GUEST_IDTR_LIMIT, dt->size); vmcs_writel(GUEST_IDTR_BASE, dt->address); } static void vmx_get_gdt(struct kvm_vcpu vcpu, struct desc_ptr dt) { dt->size = vmcs_read32(GUEST_GDTR_LIMIT); dt->address = vmcs_readl(GUEST_GDTR_BASE); } static void vmx_set_gdt(struct kvm_vcpu vcpu, struct desc_ptr dt) { vmcs_write32(GUEST_GDTR_LIMIT, dt->size); vmcs_writel(GUEST_GDTR_BASE, dt->address); } static bool rmode_segment_valid(struct kvm_vcpu vcpu, int seg) { struct kvm_segment var; u32 ar; vmx_get_segment(vcpu, &var, seg); var.dpl = 0x3; if (seg == VCPU_SREG_CS) var.type = 0x3; ar = vmx_segment_access_rights(&var); if (var.base != (var.selector << 4)) return false; if (var.limit != 0xffff) return false; if (ar != 0xf3) return false; return true; } static bool code_segment_valid(struct kvm_vcpu vcpu) { struct kvm_segment cs; unsigned int cs_rpl; vmx_get_segment(vcpu, &cs, VCPU_SREG_CS); cs_rpl = cs.selector & SELECTOR_RPL_MASK; if (cs.unusable) return false; if (~cs.type & (AR_TYPE_CODE_MASK\|AR_TYPE_ACCESSES_MASK)) return false; if (!cs.s) return false; if (cs.type & AR_TYPE_WRITEABLE_MASK) { if (cs.dpl > cs_rpl) return false; } else { if (cs.dpl != cs_rpl) return false; } if (!cs.present) return false; /* TODO: Add Reserved field check, this'll require a new member in the kvm_segment_field structure / return true; } static bool stack_segment_valid(struct kvm_vcpu vcpu) { struct kvm_segment ss; unsigned int ss_rpl; vmx_get_segment(vcpu, &ss, VCPU_SREG_SS); ss_rpl = ss.selector & SELECTOR_RPL_MASK; if (ss.unusable) return true; if (ss.type != 3 && ss.type != 7) return false; if (!ss.s) return false; if (ss.dpl != ss_rpl) /* DPL != RPL / return false; if (!ss.present) return false; return true; } static bool data_segment_valid(struct kvm_vcpu vcpu, int seg) { struct kvm_segment var; unsigned int rpl; vmx_get_segment(vcpu, &var, seg); rpl = var.selector & SELECTOR_RPL_MASK; if (var.unusable) return true; if (!var.s) return false; if (!var.present) return false; if (~var.type & (AR_TYPE_CODE_MASK\|AR_TYPE_WRITEABLE_MASK)) { if (var.dpl < rpl) /* DPL < RPL / return false; } / TODO: Add other members to kvm_segment_field to allow checking for other access * rights flags / return true; } static bool tr_valid(struct kvm_vcpu vcpu) { struct kvm_segment tr; vmx_get_segment(vcpu, &tr, VCPU_SREG_TR); if (tr.unusable) return false; if (tr.selector & SELECTOR_TI_MASK) /* TI = 1 / return false; if (tr.type != 3 && tr.type != 11) / TODO: Check if guest is in IA32e mode / return false; if (!tr.present) return false; return true; } static bool ldtr_valid(struct kvm_vcpu vcpu) { struct kvm_segment ldtr; vmx_get_segment(vcpu, &ldtr, VCPU_SREG_LDTR); if (ldtr.unusable) return true; if (ldtr.selector & SELECTOR_TI_MASK) /* TI = 1 / return false; if (ldtr.type != 2) return false; if (!ldtr.present) return false; return true; } static bool cs_ss_rpl_check(struct kvm_vcpu vcpu) { struct kvm_segment cs, ss; vmx_get_segment(vcpu, &cs, VCPU_SREG_CS); vmx_get_segment(vcpu, &ss, VCPU_SREG_SS); return ((cs.selector & SELECTOR_RPL_MASK) == (ss.selector & SELECTOR_RPL_MASK)); } /* * Check if guest state is valid. Returns true if valid, false if * not. * We assume that registers are always usable / static bool guest_state_valid(struct kvm_vcpu vcpu) { if (enable_unrestricted_guest) return true; /* real mode guest state checks / if (!is_protmode(vcpu) \|\| (vmx_get_rflags(vcpu) & X86_EFLAGS_VM)) { if (!rmode_segment_valid(vcpu, VCPU_SREG_CS)) return false; if (!rmode_segment_valid(vcpu, VCPU_SREG_SS)) return false; if (!rmode_segment_valid(vcpu, VCPU_SREG_DS)) return false; if (!rmode_segment_valid(vcpu, VCPU_SREG_ES)) return false; if (!rmode_segment_valid(vcpu, VCPU_SREG_FS)) return false; if (!rmode_segment_valid(vcpu, VCPU_SREG_GS)) return false; } else { / protected mode guest state checks / if (!cs_ss_rpl_check(vcpu)) return false; if (!code_segment_valid(vcpu)) return false; if (!stack_segment_valid(vcpu)) return false; if (!data_segment_valid(vcpu, VCPU_SREG_DS)) return false; if (!data_segment_valid(vcpu, VCPU_SREG_ES)) return false; if (!data_segment_valid(vcpu, VCPU_SREG_FS)) return false; if (!data_segment_valid(vcpu, VCPU_SREG_GS)) return false; if (!tr_valid(vcpu)) return false; if (!ldtr_valid(vcpu)) return false; } / TODO: * - Add checks on RIP * - Add checks on RFLAGS / return true; } static int init_rmode_tss(struct kvm kvm) { gfn_t fn; u16 data = 0; int idx, r; idx = srcu_read_lock(&kvm->srcu); fn = kvm->arch.tss_addr >> PAGE_SHIFT; r = kvm_clear_guest_page(kvm, fn, 0, PAGE_SIZE); if (r < 0) goto out; data = TSS_BASE_SIZE + TSS_REDIRECTION_SIZE; r = kvm_write_guest_page(kvm, fn++, &data, TSS_IOPB_BASE_OFFSET, sizeof(u16)); if (r < 0) goto out; r = kvm_clear_guest_page(kvm, fn++, 0, PAGE_SIZE); if (r < 0) goto out; r = kvm_clear_guest_page(kvm, fn, 0, PAGE_SIZE); if (r < 0) goto out; data = ~0; r = kvm_write_guest_page(kvm, fn, &data, RMODE_TSS_SIZE - 2 * PAGE_SIZE - 1, sizeof(u8)); out: srcu_read_unlock(&kvm->srcu, idx); return r; } static int init_rmode_identity_map(struct kvm kvm) { int i, idx, r = 0; pfn_t identity_map_pfn; u32 tmp; if (!enable_ept) return 0; / Protect kvm->arch.ept_identity_pagetable_done. / mutex_lock(&kvm->slots_lock); if (likely(kvm->arch.ept_identity_pagetable_done)) goto out2; identity_map_pfn = kvm->arch.ept_identity_map_addr >> PAGE_SHIFT; r = alloc_identity_pagetable(kvm); if (r < 0) goto out2; idx = srcu_read_lock(&kvm->srcu); r = kvm_clear_guest_page(kvm, identity_map_pfn, 0, PAGE_SIZE); if (r < 0) goto out; / Set up identity-mapping pagetable for EPT in real mode / for (i = 0; i < PT32_ENT_PER_PAGE; i++) { tmp = (i << 22) + (_PAGE_PRESENT \| _PAGE_RW \| _PAGE_USER \| _PAGE_ACCESSED \| _PAGE_DIRTY \| _PAGE_PSE); r = kvm_write_guest_page(kvm, identity_map_pfn, &tmp, i sizeof(tmp), sizeof(tmp)); if (r < 0) goto out; } kvm->arch.ept_identity_pagetable_done = true; out: srcu_read_unlock(&kvm->srcu, idx); out2: mutex_unlock(&kvm->slots_lock); return r; } static void seg_setup(int seg) { const struct kvm_vmx_segment_field sf = &kvm_vmx_segment_fields[seg]; unsigned int ar; vmcs_write16(sf->selector, 0); vmcs_writel(sf->base, 0); vmcs_write32(sf->limit, 0xffff); ar = 0x93; if (seg == VCPU_SREG_CS) ar \|= 0x08; / code segment / vmcs_write32(sf->ar_bytes, ar); } static int alloc_apic_access_page(struct kvm kvm) { struct page page; struct kvm_userspace_memory_region kvm_userspace_mem; int r = 0; mutex_lock(&kvm->slots_lock); if (kvm->arch.apic_access_page_done) goto out; kvm_userspace_mem.slot = APIC_ACCESS_PAGE_PRIVATE_MEMSLOT; kvm_userspace_mem.flags = 0; kvm_userspace_mem.guest_phys_addr = APIC_DEFAULT_PHYS_BASE; kvm_userspace_mem.memory_size = PAGE_SIZE; r = __kvm_set_memory_region(kvm, &kvm_userspace_mem); if (r) goto out; page = gfn_to_page(kvm, APIC_DEFAULT_PHYS_BASE >> PAGE_SHIFT); if (is_error_page(page)) { r = -EFAULT; goto out; } / * Do not pin the page in memory, so that memory hot-unplug * is able to migrate it. / put_page(page); kvm->arch.apic_access_page_done = true; out: mutex_unlock(&kvm->slots_lock); return r; } static int alloc_identity_pagetable(struct kvm kvm) { /* Called with kvm->slots_lock held. / struct kvm_userspace_memory_region kvm_userspace_mem; int r = 0; BUG_ON(kvm->arch.ept_identity_pagetable_done); kvm_userspace_mem.slot = IDENTITY_PAGETABLE_PRIVATE_MEMSLOT; kvm_userspace_mem.flags = 0; kvm_userspace_mem.guest_phys_addr = kvm->arch.ept_identity_map_addr; kvm_userspace_mem.memory_size = PAGE_SIZE; r = __kvm_set_memory_region(kvm, &kvm_userspace_mem); return r; } static void allocate_vpid(struct vcpu_vmx vmx) { int vpid; vmx->vpid = 0; if (!enable_vpid) return; spin_lock(&vmx_vpid_lock); vpid = find_first_zero_bit(vmx_vpid_bitmap, VMX_NR_VPIDS); if (vpid < VMX_NR_VPIDS) { vmx->vpid = vpid; __set_bit(vpid, vmx_vpid_bitmap); } spin_unlock(&vmx_vpid_lock); } static void free_vpid(struct vcpu_vmx vmx) { if (!enable_vpid) return; spin_lock(&vmx_vpid_lock); if (vmx->vpid != 0) __clear_bit(vmx->vpid, vmx_vpid_bitmap); spin_unlock(&vmx_vpid_lock); } #define MSR_TYPE_R 1 #define MSR_TYPE_W 2 static void __vmx_disable_intercept_for_msr(unsigned long msr_bitmap, u32 msr, int type) { int f = sizeof(unsigned long); if (!cpu_has_vmx_msr_bitmap()) return; /* * See Intel PRM Vol. 3, 20.6.9 (MSR-Bitmap Address). Early manuals * have the write-low and read-high bitmap offsets the wrong way round. * We can control MSRs 0x00000000-0x00001fff and 0xc0000000-0xc0001fff. / if (msr <= 0x1fff) { if (type & MSR_TYPE_R) / read-low / __clear_bit(msr, msr_bitmap + 0x000 / f); if (type & MSR_TYPE_W) / write-low / __clear_bit(msr, msr_bitmap + 0x800 / f); } else if ((msr >= 0xc0000000) && (msr <= 0xc0001fff)) { msr &= 0x1fff; if (type & MSR_TYPE_R) / read-high / __clear_bit(msr, msr_bitmap + 0x400 / f); if (type & MSR_TYPE_W) / write-high / __clear_bit(msr, msr_bitmap + 0xc00 / f); } } static void __vmx_enable_intercept_for_msr(unsigned long msr_bitmap, u32 msr, int type) { int f = sizeof(unsigned long); if (!cpu_has_vmx_msr_bitmap()) return; /* * See Intel PRM Vol. 3, 20.6.9 (MSR-Bitmap Address). Early manuals * have the write-low and read-high bitmap offsets the wrong way round. * We can control MSRs 0x00000000-0x00001fff and 0xc0000000-0xc0001fff. / if (msr <= 0x1fff) { if (type & MSR_TYPE_R) / read-low / __set_bit(msr, msr_bitmap + 0x000 / f); if (type & MSR_TYPE_W) / write-low / __set_bit(msr, msr_bitmap + 0x800 / f); } else if ((msr >= 0xc0000000) && (msr <= 0xc0001fff)) { msr &= 0x1fff; if (type & MSR_TYPE_R) / read-high / __set_bit(msr, msr_bitmap + 0x400 / f); if (type & MSR_TYPE_W) / write-high / __set_bit(msr, msr_bitmap + 0xc00 / f); } } static void vmx_disable_intercept_for_msr(u32 msr, bool longmode_only) { if (!longmode_only) __vmx_disable_intercept_for_msr(vmx_msr_bitmap_legacy, msr, MSR_TYPE_R \| MSR_TYPE_W); __vmx_disable_intercept_for_msr(vmx_msr_bitmap_longmode, msr, MSR_TYPE_R \| MSR_TYPE_W); } static void vmx_enable_intercept_msr_read_x2apic(u32 msr) { __vmx_enable_intercept_for_msr(vmx_msr_bitmap_legacy_x2apic, msr, MSR_TYPE_R); __vmx_enable_intercept_for_msr(vmx_msr_bitmap_longmode_x2apic, msr, MSR_TYPE_R); } static void vmx_disable_intercept_msr_read_x2apic(u32 msr) { __vmx_disable_intercept_for_msr(vmx_msr_bitmap_legacy_x2apic, msr, MSR_TYPE_R); __vmx_disable_intercept_for_msr(vmx_msr_bitmap_longmode_x2apic, msr, MSR_TYPE_R); } static void vmx_disable_intercept_msr_write_x2apic(u32 msr) { __vmx_disable_intercept_for_msr(vmx_msr_bitmap_legacy_x2apic, msr, MSR_TYPE_W); __vmx_disable_intercept_for_msr(vmx_msr_bitmap_longmode_x2apic, msr, MSR_TYPE_W); } static int vmx_vm_has_apicv(struct kvm kvm) { return enable_apicv && irqchip_in_kernel(kvm); } /* * Send interrupt to vcpu via posted interrupt way. * 1. If target vcpu is running(non-root mode), send posted interrupt * notification to vcpu and hardware will sync PIR to vIRR atomically. * 2. If target vcpu isn't running(root mode), kick it to pick up the * interrupt from PIR in next vmentry. / static void vmx_deliver_posted_interrupt(struct kvm_vcpu vcpu, int vector) { struct vcpu_vmx vmx = to_vmx(vcpu); int r; if (pi_test_and_set_pir(vector, &vmx->pi_desc)) return; r = pi_test_and_set_on(&vmx->pi_desc); kvm_make_request(KVM_REQ_EVENT, vcpu); #ifdef CONFIG_SMP if (!r && (vcpu->mode == IN_GUEST_MODE)) apic->send_IPI_mask(get_cpu_mask(vcpu->cpu), POSTED_INTR_VECTOR); else #endif kvm_vcpu_kick(vcpu); } static void vmx_sync_pir_to_irr(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); if (!pi_test_and_clear_on(&vmx->pi_desc)) return; kvm_apic_update_irr(vcpu, vmx->pi_desc.pir); } static void vmx_sync_pir_to_irr_dummy(struct kvm_vcpu vcpu) { return; } /* * Set up the vmcs's constant host-state fields, i.e., host-state fields that * will not change in the lifetime of the guest. * Note that host-state that does change is set elsewhere. E.g., host-state * that is set differently for each CPU is set in vmx_vcpu_load(), not here. / static void vmx_set_constant_host_state(struct vcpu_vmx vmx) { u32 low32, high32; unsigned long tmpl; struct desc_ptr dt; unsigned long cr4; vmcs_writel(HOST_CR0, read_cr0() & ~X86_CR0_TS); /* 22.2.3 / vmcs_writel(HOST_CR3, read_cr3()); / 22.2.3 FIXME: shadow tables / / Save the most likely value for this task's CR4 in the VMCS. / cr4 = read_cr4(); vmcs_writel(HOST_CR4, cr4); / 22.2.3, 22.2.5 / vmx->host_state.vmcs_host_cr4 = cr4; vmcs_write16(HOST_CS_SELECTOR, __KERNEL_CS); / 22.2.4 / #ifdef CONFIG_X86_64 / * Load null selectors, so we can avoid reloading them in * __vmx_load_host_state(), in case userspace uses the null selectors * too (the expected case). / vmcs_write16(HOST_DS_SELECTOR, 0); vmcs_write16(HOST_ES_SELECTOR, 0); #else vmcs_write16(HOST_DS_SELECTOR, __KERNEL_DS); / 22.2.4 / vmcs_write16(HOST_ES_SELECTOR, __KERNEL_DS); / 22.2.4 / #endif vmcs_write16(HOST_SS_SELECTOR, __KERNEL_DS); / 22.2.4 / vmcs_write16(HOST_TR_SELECTOR, GDT_ENTRY_TSS8); /* 22.2.4 / native_store_idt(&dt); vmcs_writel(HOST_IDTR_BASE, dt.address); / 22.2.4 / vmx->host_idt_base = dt.address; vmcs_writel(HOST_RIP, vmx_return); / 22.2.5 / rdmsr(MSR_IA32_SYSENTER_CS, low32, high32); vmcs_write32(HOST_IA32_SYSENTER_CS, low32); rdmsrl(MSR_IA32_SYSENTER_EIP, tmpl); vmcs_writel(HOST_IA32_SYSENTER_EIP, tmpl); / 22.2.3 / if (vmcs_config.vmexit_ctrl & VM_EXIT_LOAD_IA32_PAT) { rdmsr(MSR_IA32_CR_PAT, low32, high32); vmcs_write64(HOST_IA32_PAT, low32 \| ((u64) high32 << 32)); } } static void set_cr4_guest_host_mask(struct vcpu_vmx vmx) { vmx->vcpu.arch.cr4_guest_owned_bits = KVM_CR4_GUEST_OWNED_BITS; if (enable_ept) vmx->vcpu.arch.cr4_guest_owned_bits \|= X86_CR4_PGE; if (is_guest_mode(&vmx->vcpu)) vmx->vcpu.arch.cr4_guest_owned_bits &= ~get_vmcs12(&vmx->vcpu)->cr4_guest_host_mask; vmcs_writel(CR4_GUEST_HOST_MASK, ~vmx->vcpu.arch.cr4_guest_owned_bits); } static u32 vmx_pin_based_exec_ctrl(struct vcpu_vmx vmx) { u32 pin_based_exec_ctrl = vmcs_config.pin_based_exec_ctrl; if (!vmx_vm_has_apicv(vmx->vcpu.kvm)) pin_based_exec_ctrl &= ~PIN_BASED_POSTED_INTR; return pin_based_exec_ctrl; } static u32 vmx_exec_control(struct vcpu_vmx vmx) { u32 exec_control = vmcs_config.cpu_based_exec_ctrl; if (vmx->vcpu.arch.switch_db_regs & KVM_DEBUGREG_WONT_EXIT) exec_control &= ~CPU_BASED_MOV_DR_EXITING; if (!vm_need_tpr_shadow(vmx->vcpu.kvm)) { exec_control &= ~CPU_BASED_TPR_SHADOW; #ifdef CONFIG_X86_64 exec_control \|= CPU_BASED_CR8_STORE_EXITING \| CPU_BASED_CR8_LOAD_EXITING; #endif } if (!enable_ept) exec_control \|= CPU_BASED_CR3_STORE_EXITING \| CPU_BASED_CR3_LOAD_EXITING \| CPU_BASED_INVLPG_EXITING; return exec_control; } static u32 vmx_secondary_exec_control(struct vcpu_vmx vmx) { u32 exec_control = vmcs_config.cpu_based_2nd_exec_ctrl; if (!vm_need_virtualize_apic_accesses(vmx->vcpu.kvm)) exec_control &= ~SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES; if (vmx->vpid == 0) exec_control &= ~SECONDARY_EXEC_ENABLE_VPID; if (!enable_ept) { exec_control &= ~SECONDARY_EXEC_ENABLE_EPT; enable_unrestricted_guest = 0; / Enable INVPCID for non-ept guests may cause performance regression. / exec_control &= ~SECONDARY_EXEC_ENABLE_INVPCID; } if (!enable_unrestricted_guest) exec_control &= ~SECONDARY_EXEC_UNRESTRICTED_GUEST; if (!ple_gap) exec_control &= ~SECONDARY_EXEC_PAUSE_LOOP_EXITING; if (!vmx_vm_has_apicv(vmx->vcpu.kvm)) exec_control &= ~(SECONDARY_EXEC_APIC_REGISTER_VIRT \| SECONDARY_EXEC_VIRTUAL_INTR_DELIVERY); exec_control &= ~SECONDARY_EXEC_VIRTUALIZE_X2APIC_MODE; / SECONDARY_EXEC_SHADOW_VMCS is enabled when L1 executes VMPTRLD (handle_vmptrld). We can NOT enable shadow_vmcs here because we don't have yet a current VMCS12 / exec_control &= ~SECONDARY_EXEC_SHADOW_VMCS; return exec_control; } static void ept_set_mmio_spte_mask(void) { / * EPT Misconfigurations can be generated if the value of bits 2:0 * of an EPT paging-structure entry is 110b (write/execute). * Also, magic bits (0x3ull << 62) is set to quickly identify mmio * spte. / kvm_mmu_set_mmio_spte_mask((0x3ull << 62) \| 0x6ull); } / * Sets up the vmcs for emulated real mode. / static int vmx_vcpu_setup(struct vcpu_vmx vmx) { #ifdef CONFIG_X86_64 unsigned long a; #endif int i; /* I/O / vmcs_write64(IO_BITMAP_A, __pa(vmx_io_bitmap_a)); vmcs_write64(IO_BITMAP_B, __pa(vmx_io_bitmap_b)); if (enable_shadow_vmcs) { vmcs_write64(VMREAD_BITMAP, __pa(vmx_vmread_bitmap)); vmcs_write64(VMWRITE_BITMAP, __pa(vmx_vmwrite_bitmap)); } if (cpu_has_vmx_msr_bitmap()) vmcs_write64(MSR_BITMAP, __pa(vmx_msr_bitmap_legacy)); vmcs_write64(VMCS_LINK_POINTER, -1ull); / 22.3.1.5 / / Control / vmcs_write32(PIN_BASED_VM_EXEC_CONTROL, vmx_pin_based_exec_ctrl(vmx)); vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, vmx_exec_control(vmx)); if (cpu_has_secondary_exec_ctrls()) { vmcs_write32(SECONDARY_VM_EXEC_CONTROL, vmx_secondary_exec_control(vmx)); } if (vmx_vm_has_apicv(vmx->vcpu.kvm)) { vmcs_write64(EOI_EXIT_BITMAP0, 0); vmcs_write64(EOI_EXIT_BITMAP1, 0); vmcs_write64(EOI_EXIT_BITMAP2, 0); vmcs_write64(EOI_EXIT_BITMAP3, 0); vmcs_write16(GUEST_INTR_STATUS, 0); vmcs_write64(POSTED_INTR_NV, POSTED_INTR_VECTOR); vmcs_write64(POSTED_INTR_DESC_ADDR, __pa((&vmx->pi_desc))); } if (ple_gap) { vmcs_write32(PLE_GAP, ple_gap); vmx->ple_window = ple_window; vmx->ple_window_dirty = true; } vmcs_write32(PAGE_FAULT_ERROR_CODE_MASK, 0); vmcs_write32(PAGE_FAULT_ERROR_CODE_MATCH, 0); vmcs_write32(CR3_TARGET_COUNT, 0); / 22.2.1 / vmcs_write16(HOST_FS_SELECTOR, 0); / 22.2.4 / vmcs_write16(HOST_GS_SELECTOR, 0); / 22.2.4 / vmx_set_constant_host_state(vmx); #ifdef CONFIG_X86_64 rdmsrl(MSR_FS_BASE, a); vmcs_writel(HOST_FS_BASE, a); / 22.2.4 / rdmsrl(MSR_GS_BASE, a); vmcs_writel(HOST_GS_BASE, a); / 22.2.4 / #else vmcs_writel(HOST_FS_BASE, 0); / 22.2.4 / vmcs_writel(HOST_GS_BASE, 0); / 22.2.4 / #endif vmcs_write32(VM_EXIT_MSR_STORE_COUNT, 0); vmcs_write32(VM_EXIT_MSR_LOAD_COUNT, 0); vmcs_write64(VM_EXIT_MSR_LOAD_ADDR, __pa(vmx->msr_autoload.host)); vmcs_write32(VM_ENTRY_MSR_LOAD_COUNT, 0); vmcs_write64(VM_ENTRY_MSR_LOAD_ADDR, __pa(vmx->msr_autoload.guest)); if (vmcs_config.vmentry_ctrl & VM_ENTRY_LOAD_IA32_PAT) { u32 msr_low, msr_high; u64 host_pat; rdmsr(MSR_IA32_CR_PAT, msr_low, msr_high); host_pat = msr_low \| ((u64) msr_high << 32); / Write the default value follow host pat / vmcs_write64(GUEST_IA32_PAT, host_pat); / Keep arch.pat sync with GUEST_IA32_PAT / vmx->vcpu.arch.pat = host_pat; } for (i = 0; i < ARRAY_SIZE(vmx_msr_index); ++i) { u32 index = vmx_msr_index[i]; u32 data_low, data_high; int j = vmx->nmsrs; if (rdmsr_safe(index, &data_low, &data_high) < 0) continue; if (wrmsr_safe(index, data_low, data_high) < 0) continue; vmx->guest_msrs[j].index = i; vmx->guest_msrs[j].data = 0; vmx->guest_msrs[j].mask = -1ull; ++vmx->nmsrs; } vm_exit_controls_init(vmx, vmcs_config.vmexit_ctrl); / 22.2.1, 20.8.1 / vm_entry_controls_init(vmx, vmcs_config.vmentry_ctrl); vmcs_writel(CR0_GUEST_HOST_MASK, ~0UL); set_cr4_guest_host_mask(vmx); return 0; } static void vmx_vcpu_reset(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); struct msr_data apic_base_msr; vmx->rmode.vm86_active = 0; vmx->soft_vnmi_blocked = 0; vmx->vcpu.arch.regs[VCPU_REGS_RDX] = get_rdx_init_val(); kvm_set_cr8(&vmx->vcpu, 0); apic_base_msr.data = APIC_DEFAULT_PHYS_BASE \| MSR_IA32_APICBASE_ENABLE; if (kvm_vcpu_is_bsp(&vmx->vcpu)) apic_base_msr.data \|= MSR_IA32_APICBASE_BSP; apic_base_msr.host_initiated = true; kvm_set_apic_base(&vmx->vcpu, &apic_base_msr); vmx_segment_cache_clear(vmx); seg_setup(VCPU_SREG_CS); vmcs_write16(GUEST_CS_SELECTOR, 0xf000); vmcs_write32(GUEST_CS_BASE, 0xffff0000); seg_setup(VCPU_SREG_DS); seg_setup(VCPU_SREG_ES); seg_setup(VCPU_SREG_FS); seg_setup(VCPU_SREG_GS); seg_setup(VCPU_SREG_SS); vmcs_write16(GUEST_TR_SELECTOR, 0); vmcs_writel(GUEST_TR_BASE, 0); vmcs_write32(GUEST_TR_LIMIT, 0xffff); vmcs_write32(GUEST_TR_AR_BYTES, 0x008b); vmcs_write16(GUEST_LDTR_SELECTOR, 0); vmcs_writel(GUEST_LDTR_BASE, 0); vmcs_write32(GUEST_LDTR_LIMIT, 0xffff); vmcs_write32(GUEST_LDTR_AR_BYTES, 0x00082); vmcs_write32(GUEST_SYSENTER_CS, 0); vmcs_writel(GUEST_SYSENTER_ESP, 0); vmcs_writel(GUEST_SYSENTER_EIP, 0); vmcs_writel(GUEST_RFLAGS, 0x02); kvm_rip_write(vcpu, 0xfff0); vmcs_writel(GUEST_GDTR_BASE, 0); vmcs_write32(GUEST_GDTR_LIMIT, 0xffff); vmcs_writel(GUEST_IDTR_BASE, 0); vmcs_write32(GUEST_IDTR_LIMIT, 0xffff); vmcs_write32(GUEST_ACTIVITY_STATE, GUEST_ACTIVITY_ACTIVE); vmcs_write32(GUEST_INTERRUPTIBILITY_INFO, 0); vmcs_write32(GUEST_PENDING_DBG_EXCEPTIONS, 0); / Special registers / vmcs_write64(GUEST_IA32_DEBUGCTL, 0); setup_msrs(vmx); vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, 0); / 22.2.1 / if (cpu_has_vmx_tpr_shadow()) { vmcs_write64(VIRTUAL_APIC_PAGE_ADDR, 0); if (vm_need_tpr_shadow(vmx->vcpu.kvm)) vmcs_write64(VIRTUAL_APIC_PAGE_ADDR, __pa(vmx->vcpu.arch.apic->regs)); vmcs_write32(TPR_THRESHOLD, 0); } kvm_vcpu_reload_apic_access_page(vcpu); if (vmx_vm_has_apicv(vcpu->kvm)) memset(&vmx->pi_desc, 0, sizeof(struct pi_desc)); if (vmx->vpid != 0) vmcs_write16(VIRTUAL_PROCESSOR_ID, vmx->vpid); vmx->vcpu.arch.cr0 = X86_CR0_NW \| X86_CR0_CD \| X86_CR0_ET; vmx_set_cr0(&vmx->vcpu, kvm_read_cr0(vcpu)); / enter rmode / vmx_set_cr4(&vmx->vcpu, 0); vmx_set_efer(&vmx->vcpu, 0); vmx_fpu_activate(&vmx->vcpu); update_exception_bitmap(&vmx->vcpu); vpid_sync_context(vmx); } / * In nested virtualization, check if L1 asked to exit on external interrupts. * For most existing hypervisors, this will always return true. / static bool nested_exit_on_intr(struct kvm_vcpu vcpu) { return get_vmcs12(vcpu)->pin_based_vm_exec_control & PIN_BASED_EXT_INTR_MASK; } /* * In nested virtualization, check if L1 has set * VM_EXIT_ACK_INTR_ON_EXIT / static bool nested_exit_intr_ack_set(struct kvm_vcpu vcpu) { return get_vmcs12(vcpu)->vm_exit_controls & VM_EXIT_ACK_INTR_ON_EXIT; } static bool nested_exit_on_nmi(struct kvm_vcpu vcpu) { return get_vmcs12(vcpu)->pin_based_vm_exec_control & PIN_BASED_NMI_EXITING; } static void enable_irq_window(struct kvm_vcpu vcpu) { u32 cpu_based_vm_exec_control; cpu_based_vm_exec_control = vmcs_read32(CPU_BASED_VM_EXEC_CONTROL); cpu_based_vm_exec_control \|= CPU_BASED_VIRTUAL_INTR_PENDING; vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, cpu_based_vm_exec_control); } static void enable_nmi_window(struct kvm_vcpu vcpu) { u32 cpu_based_vm_exec_control; if (!cpu_has_virtual_nmis() \|\| vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) & GUEST_INTR_STATE_STI) { enable_irq_window(vcpu); return; } cpu_based_vm_exec_control = vmcs_read32(CPU_BASED_VM_EXEC_CONTROL); cpu_based_vm_exec_control \|= CPU_BASED_VIRTUAL_NMI_PENDING; vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, cpu_based_vm_exec_control); } static void vmx_inject_irq(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); uint32_t intr; int irq = vcpu->arch.interrupt.nr; trace_kvm_inj_virq(irq); ++vcpu->stat.irq_injections; if (vmx->rmode.vm86_active) { int inc_eip = 0; if (vcpu->arch.interrupt.soft) inc_eip = vcpu->arch.event_exit_inst_len; if (kvm_inject_realmode_interrupt(vcpu, irq, inc_eip) != EMULATE_DONE) kvm_make_request(KVM_REQ_TRIPLE_FAULT, vcpu); return; } intr = irq \| INTR_INFO_VALID_MASK; if (vcpu->arch.interrupt.soft) { intr \|= INTR_TYPE_SOFT_INTR; vmcs_write32(VM_ENTRY_INSTRUCTION_LEN, vmx->vcpu.arch.event_exit_inst_len); } else intr \|= INTR_TYPE_EXT_INTR; vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, intr); } static void vmx_inject_nmi(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); if (is_guest_mode(vcpu)) return; if (!cpu_has_virtual_nmis()) { / * Tracking the NMI-blocked state in software is built upon * finding the next open IRQ window. This, in turn, depends on * well-behaving guests: They have to keep IRQs disabled at * least as long as the NMI handler runs. Otherwise we may * cause NMI nesting, maybe breaking the guest. But as this is * highly unlikely, we can live with the residual risk. / vmx->soft_vnmi_blocked = 1; vmx->vnmi_blocked_time = 0; } ++vcpu->stat.nmi_injections; vmx->nmi_known_unmasked = false; if (vmx->rmode.vm86_active) { if (kvm_inject_realmode_interrupt(vcpu, NMI_VECTOR, 0) != EMULATE_DONE) kvm_make_request(KVM_REQ_TRIPLE_FAULT, vcpu); return; } vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, INTR_TYPE_NMI_INTR \| INTR_INFO_VALID_MASK \| NMI_VECTOR); } static bool vmx_get_nmi_mask(struct kvm_vcpu vcpu) { if (!cpu_has_virtual_nmis()) return to_vmx(vcpu)->soft_vnmi_blocked; if (to_vmx(vcpu)->nmi_known_unmasked) return false; return vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) & GUEST_INTR_STATE_NMI; } static void vmx_set_nmi_mask(struct kvm_vcpu vcpu, bool masked) { struct vcpu_vmx vmx = to_vmx(vcpu); if (!cpu_has_virtual_nmis()) { if (vmx->soft_vnmi_blocked != masked) { vmx->soft_vnmi_blocked = masked; vmx->vnmi_blocked_time = 0; } } else { vmx->nmi_known_unmasked = !masked; if (masked) vmcs_set_bits(GUEST_INTERRUPTIBILITY_INFO, GUEST_INTR_STATE_NMI); else vmcs_clear_bits(GUEST_INTERRUPTIBILITY_INFO, GUEST_INTR_STATE_NMI); } } static int vmx_nmi_allowed(struct kvm_vcpu vcpu) { if (to_vmx(vcpu)->nested.nested_run_pending) return 0; if (!cpu_has_virtual_nmis() && to_vmx(vcpu)->soft_vnmi_blocked) return 0; return !(vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) & (GUEST_INTR_STATE_MOV_SS \| GUEST_INTR_STATE_STI \| GUEST_INTR_STATE_NMI)); } static int vmx_interrupt_allowed(struct kvm_vcpu vcpu) { return (!to_vmx(vcpu)->nested.nested_run_pending && vmcs_readl(GUEST_RFLAGS) & X86_EFLAGS_IF) && !(vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) & (GUEST_INTR_STATE_STI \| GUEST_INTR_STATE_MOV_SS)); } static int vmx_set_tss_addr(struct kvm kvm, unsigned int addr) { int ret; struct kvm_userspace_memory_region tss_mem = { .slot = TSS_PRIVATE_MEMSLOT, .guest_phys_addr = addr, .memory_size = PAGE_SIZE 3, .flags = 0, }; ret = kvm_set_memory_region(kvm, &tss_mem); if (ret) return ret; kvm->arch.tss_addr = addr; return init_rmode_tss(kvm); } static bool rmode_exception(struct kvm_vcpu vcpu, int vec) { switch (vec) { case BP_VECTOR: / * Update instruction length as we may reinject the exception * from user space while in guest debugging mode. / to_vmx(vcpu)->vcpu.arch.event_exit_inst_len = vmcs_read32(VM_EXIT_INSTRUCTION_LEN); if (vcpu->guest_debug & KVM_GUESTDBG_USE_SW_BP) return false; / fall through / case DB_VECTOR: if (vcpu->guest_debug & (KVM_GUESTDBG_SINGLESTEP \| KVM_GUESTDBG_USE_HW_BP)) return false; / fall through / case DE_VECTOR: case OF_VECTOR: case BR_VECTOR: case UD_VECTOR: case DF_VECTOR: case SS_VECTOR: case GP_VECTOR: case MF_VECTOR: return true; break; } return false; } static int handle_rmode_exception(struct kvm_vcpu vcpu, int vec, u32 err_code) { /* * Instruction with address size override prefix opcode 0x67 * Cause the #SS fault with 0 error code in VM86 mode. / if (((vec == GP_VECTOR) \|\| (vec == SS_VECTOR)) && err_code == 0) { if (emulate_instruction(vcpu, 0) == EMULATE_DONE) { if (vcpu->arch.halt_request) { vcpu->arch.halt_request = 0; return kvm_emulate_halt(vcpu); } return 1; } return 0; } / * Forward all other exceptions that are valid in real mode. * FIXME: Breaks guest debugging in real mode, needs to be fixed with * the required debugging infrastructure rework. / kvm_queue_exception(vcpu, vec); return 1; } / * Trigger machine check on the host. We assume all the MSRs are already set up * by the CPU and that we still run on the same CPU as the MCE occurred on. * We pass a fake environment to the machine check handler because we want * the guest to be always treated like user space, no matter what context * it used internally. / static void kvm_machine_check(void) { #if defined(CONFIG_X86_MCE) && defined(CONFIG_X86_64) struct pt_regs regs = { .cs = 3, / Fake ring 3 no matter what the guest ran on / .flags = X86_EFLAGS_IF, }; do_machine_check(&regs, 0); #endif } static int handle_machine_check(struct kvm_vcpu vcpu) { /* already handled by vcpu_run / return 1; } static int handle_exception(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); struct kvm_run kvm_run = vcpu->run; u32 intr_info, ex_no, error_code; unsigned long cr2, rip, dr6; u32 vect_info; enum emulation_result er; vect_info = vmx->idt_vectoring_info; intr_info = vmx->exit_intr_info; if (is_machine_check(intr_info)) return handle_machine_check(vcpu); if ((intr_info & INTR_INFO_INTR_TYPE_MASK) == INTR_TYPE_NMI_INTR) return 1; /* already handled by vmx_vcpu_run() / if (is_no_device(intr_info)) { vmx_fpu_activate(vcpu); return 1; } if (is_invalid_opcode(intr_info)) { er = emulate_instruction(vcpu, EMULTYPE_TRAP_UD); if (er != EMULATE_DONE) kvm_queue_exception(vcpu, UD_VECTOR); return 1; } error_code = 0; if (intr_info & INTR_INFO_DELIVER_CODE_MASK) error_code = vmcs_read32(VM_EXIT_INTR_ERROR_CODE); / * The #PF with PFEC.RSVD = 1 indicates the guest is accessing * MMIO, it is better to report an internal error. * See the comments in vmx_handle_exit. / if ((vect_info & VECTORING_INFO_VALID_MASK) && !(is_page_fault(intr_info) && !(error_code & PFERR_RSVD_MASK))) { vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR; vcpu->run->internal.suberror = KVM_INTERNAL_ERROR_SIMUL_EX; vcpu->run->internal.ndata = 2; vcpu->run->internal.data[0] = vect_info; vcpu->run->internal.data[1] = intr_info; return 0; } if (is_page_fault(intr_info)) { / EPT won't cause page fault directly / BUG_ON(enable_ept); cr2 = vmcs_readl(EXIT_QUALIFICATION); trace_kvm_page_fault(cr2, error_code); if (kvm_event_needs_reinjection(vcpu)) kvm_mmu_unprotect_page_virt(vcpu, cr2); return kvm_mmu_page_fault(vcpu, cr2, error_code, NULL, 0); } ex_no = intr_info & INTR_INFO_VECTOR_MASK; if (vmx->rmode.vm86_active && rmode_exception(vcpu, ex_no)) return handle_rmode_exception(vcpu, ex_no, error_code); switch (ex_no) { case DB_VECTOR: dr6 = vmcs_readl(EXIT_QUALIFICATION); if (!(vcpu->guest_debug & (KVM_GUESTDBG_SINGLESTEP \| KVM_GUESTDBG_USE_HW_BP))) { vcpu->arch.dr6 &= ~15; vcpu->arch.dr6 \|= dr6 \| DR6_RTM; if (!(dr6 & ~DR6_RESERVED)) / icebp / skip_emulated_instruction(vcpu); kvm_queue_exception(vcpu, DB_VECTOR); return 1; } kvm_run->debug.arch.dr6 = dr6 \| DR6_FIXED_1; kvm_run->debug.arch.dr7 = vmcs_readl(GUEST_DR7); / fall through / case BP_VECTOR: / * Update instruction length as we may reinject #BP from * user space while in guest debugging mode. Reading it for * #DB as well causes no harm, it is not used in that case. / vmx->vcpu.arch.event_exit_inst_len = vmcs_read32(VM_EXIT_INSTRUCTION_LEN); kvm_run->exit_reason = KVM_EXIT_DEBUG; rip = kvm_rip_read(vcpu); kvm_run->debug.arch.pc = vmcs_readl(GUEST_CS_BASE) + rip; kvm_run->debug.arch.exception = ex_no; break; default: kvm_run->exit_reason = KVM_EXIT_EXCEPTION; kvm_run->ex.exception = ex_no; kvm_run->ex.error_code = error_code; break; } return 0; } static int handle_external_interrupt(struct kvm_vcpu vcpu) { ++vcpu->stat.irq_exits; return 1; } static int handle_triple_fault(struct kvm_vcpu vcpu) { vcpu->run->exit_reason = KVM_EXIT_SHUTDOWN; return 0; } static int handle_io(struct kvm_vcpu vcpu) { unsigned long exit_qualification; int size, in, string; unsigned port; exit_qualification = vmcs_readl(EXIT_QUALIFICATION); string = (exit_qualification & 16) != 0; in = (exit_qualification & 8) != 0; ++vcpu->stat.io_exits; if (string \|\| in) return emulate_instruction(vcpu, 0) == EMULATE_DONE; port = exit_qualification >> 16; size = (exit_qualification & 7) + 1; skip_emulated_instruction(vcpu); return kvm_fast_pio_out(vcpu, size, port); } static void vmx_patch_hypercall(struct kvm_vcpu vcpu, unsigned char hypercall) { /* * Patch in the VMCALL instruction: / hypercall[0] = 0x0f; hypercall[1] = 0x01; hypercall[2] = 0xc1; } static bool nested_cr0_valid(struct vmcs12 vmcs12, unsigned long val) { unsigned long always_on = VMXON_CR0_ALWAYSON; if (nested_vmx_secondary_ctls_high & SECONDARY_EXEC_UNRESTRICTED_GUEST && nested_cpu_has2(vmcs12, SECONDARY_EXEC_UNRESTRICTED_GUEST)) always_on &= ~(X86_CR0_PE \| X86_CR0_PG); return (val & always_on) == always_on; } /* called to set cr0 as appropriate for a mov-to-cr0 exit. / static int handle_set_cr0(struct kvm_vcpu vcpu, unsigned long val) { if (is_guest_mode(vcpu)) { struct vmcs12 vmcs12 = get_vmcs12(vcpu); unsigned long orig_val = val; / * We get here when L2 changed cr0 in a way that did not change * any of L1's shadowed bits (see nested_vmx_exit_handled_cr), * but did change L0 shadowed bits. So we first calculate the * effective cr0 value that L1 would like to write into the * hardware. It consists of the L2-owned bits from the new * value combined with the L1-owned bits from L1's guest_cr0. / val = (val & ~vmcs12->cr0_guest_host_mask) \| (vmcs12->guest_cr0 & vmcs12->cr0_guest_host_mask); if (!nested_cr0_valid(vmcs12, val)) return 1; if (kvm_set_cr0(vcpu, val)) return 1; vmcs_writel(CR0_READ_SHADOW, orig_val); return 0; } else { if (to_vmx(vcpu)->nested.vmxon && ((val & VMXON_CR0_ALWAYSON) != VMXON_CR0_ALWAYSON)) return 1; return kvm_set_cr0(vcpu, val); } } static int handle_set_cr4(struct kvm_vcpu vcpu, unsigned long val) { if (is_guest_mode(vcpu)) { struct vmcs12 vmcs12 = get_vmcs12(vcpu); unsigned long orig_val = val; / analogously to handle_set_cr0 / val = (val & ~vmcs12->cr4_guest_host_mask) \| (vmcs12->guest_cr4 & vmcs12->cr4_guest_host_mask); if (kvm_set_cr4(vcpu, val)) return 1; vmcs_writel(CR4_READ_SHADOW, orig_val); return 0; } else return kvm_set_cr4(vcpu, val); } / called to set cr0 as approriate for clts instruction exit. / static void handle_clts(struct kvm_vcpu vcpu) { if (is_guest_mode(vcpu)) { /* * We get here when L2 did CLTS, and L1 didn't shadow CR0.TS * but we did (!fpu_active). We need to keep GUEST_CR0.TS on, * just pretend it's off (also in arch.cr0 for fpu_activate). / vmcs_writel(CR0_READ_SHADOW, vmcs_readl(CR0_READ_SHADOW) & ~X86_CR0_TS); vcpu->arch.cr0 &= ~X86_CR0_TS; } else vmx_set_cr0(vcpu, kvm_read_cr0_bits(vcpu, ~X86_CR0_TS)); } static int handle_cr(struct kvm_vcpu vcpu) { unsigned long exit_qualification, val; int cr; int reg; int err; exit_qualification = vmcs_readl(EXIT_QUALIFICATION); cr = exit_qualification & 15; reg = (exit_qualification >> 8) & 15; switch ((exit_qualification >> 4) & 3) { case 0: /* mov to cr / val = kvm_register_readl(vcpu, reg); trace_kvm_cr_write(cr, val); switch (cr) { case 0: err = handle_set_cr0(vcpu, val); kvm_complete_insn_gp(vcpu, err); return 1; case 3: err = kvm_set_cr3(vcpu, val); kvm_complete_insn_gp(vcpu, err); return 1; case 4: err = handle_set_cr4(vcpu, val); kvm_complete_insn_gp(vcpu, err); return 1; case 8: { u8 cr8_prev = kvm_get_cr8(vcpu); u8 cr8 = (u8)val; err = kvm_set_cr8(vcpu, cr8); kvm_complete_insn_gp(vcpu, err); if (irqchip_in_kernel(vcpu->kvm)) return 1; if (cr8_prev <= cr8) return 1; vcpu->run->exit_reason = KVM_EXIT_SET_TPR; return 0; } } break; case 2: / clts / handle_clts(vcpu); trace_kvm_cr_write(0, kvm_read_cr0(vcpu)); skip_emulated_instruction(vcpu); vmx_fpu_activate(vcpu); return 1; case 1: /mov from cr/ switch (cr) { case 3: val = kvm_read_cr3(vcpu); kvm_register_write(vcpu, reg, val); trace_kvm_cr_read(cr, val); skip_emulated_instruction(vcpu); return 1; case 8: val = kvm_get_cr8(vcpu); kvm_register_write(vcpu, reg, val); trace_kvm_cr_read(cr, val); skip_emulated_instruction(vcpu); return 1; } break; case 3: / lmsw / val = (exit_qualification >> LMSW_SOURCE_DATA_SHIFT) & 0x0f; trace_kvm_cr_write(0, (kvm_read_cr0(vcpu) & ~0xful) \| val); kvm_lmsw(vcpu, val); skip_emulated_instruction(vcpu); return 1; default: break; } vcpu->run->exit_reason = 0; vcpu_unimpl(vcpu, "unhandled control register: op %d cr %d\n", (int)(exit_qualification >> 4) & 3, cr); return 0; } static int handle_dr(struct kvm_vcpu vcpu) { unsigned long exit_qualification; int dr, reg; /* Do not handle if the CPL > 0, will trigger GP on re-entry / if (!kvm_require_cpl(vcpu, 0)) return 1; dr = vmcs_readl(GUEST_DR7); if (dr & DR7_GD) { / * As the vm-exit takes precedence over the debug trap, we * need to emulate the latter, either for the host or the * guest debugging itself. / if (vcpu->guest_debug & KVM_GUESTDBG_USE_HW_BP) { vcpu->run->debug.arch.dr6 = vcpu->arch.dr6; vcpu->run->debug.arch.dr7 = dr; vcpu->run->debug.arch.pc = vmcs_readl(GUEST_CS_BASE) + vmcs_readl(GUEST_RIP); vcpu->run->debug.arch.exception = DB_VECTOR; vcpu->run->exit_reason = KVM_EXIT_DEBUG; return 0; } else { vcpu->arch.dr7 &= ~DR7_GD; vcpu->arch.dr6 \|= DR6_BD \| DR6_RTM; vmcs_writel(GUEST_DR7, vcpu->arch.dr7); kvm_queue_exception(vcpu, DB_VECTOR); return 1; } } if (vcpu->guest_debug == 0) { u32 cpu_based_vm_exec_control; cpu_based_vm_exec_control = vmcs_read32(CPU_BASED_VM_EXEC_CONTROL); cpu_based_vm_exec_control &= ~CPU_BASED_MOV_DR_EXITING; vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, cpu_based_vm_exec_control); / * No more DR vmexits; force a reload of the debug registers * and reenter on this instruction. The next vmexit will * retrieve the full state of the debug registers. / vcpu->arch.switch_db_regs \|= KVM_DEBUGREG_WONT_EXIT; return 1; } exit_qualification = vmcs_readl(EXIT_QUALIFICATION); dr = exit_qualification & DEBUG_REG_ACCESS_NUM; reg = DEBUG_REG_ACCESS_REG(exit_qualification); if (exit_qualification & TYPE_MOV_FROM_DR) { unsigned long val; if (kvm_get_dr(vcpu, dr, &val)) return 1; kvm_register_write(vcpu, reg, val); } else if (kvm_set_dr(vcpu, dr, kvm_register_readl(vcpu, reg))) return 1; skip_emulated_instruction(vcpu); return 1; } static u64 vmx_get_dr6(struct kvm_vcpu vcpu) { return vcpu->arch.dr6; } static void vmx_set_dr6(struct kvm_vcpu vcpu, unsigned long val) { } static void vmx_sync_dirty_debug_regs(struct kvm_vcpu vcpu) { u32 cpu_based_vm_exec_control; get_debugreg(vcpu->arch.db[0], 0); get_debugreg(vcpu->arch.db[1], 1); get_debugreg(vcpu->arch.db[2], 2); get_debugreg(vcpu->arch.db[3], 3); get_debugreg(vcpu->arch.dr6, 6); vcpu->arch.dr7 = vmcs_readl(GUEST_DR7); vcpu->arch.switch_db_regs &= ~KVM_DEBUGREG_WONT_EXIT; cpu_based_vm_exec_control = vmcs_read32(CPU_BASED_VM_EXEC_CONTROL); cpu_based_vm_exec_control \|= CPU_BASED_MOV_DR_EXITING; vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, cpu_based_vm_exec_control); } static void vmx_set_dr7(struct kvm_vcpu vcpu, unsigned long val) { vmcs_writel(GUEST_DR7, val); } static int handle_cpuid(struct kvm_vcpu vcpu) { kvm_emulate_cpuid(vcpu); return 1; } static int handle_rdmsr(struct kvm_vcpu vcpu) { u32 ecx = vcpu->arch.regs[VCPU_REGS_RCX]; u64 data; if (vmx_get_msr(vcpu, ecx, &data)) { trace_kvm_msr_read_ex(ecx); kvm_inject_gp(vcpu, 0); return 1; } trace_kvm_msr_read(ecx, data); / FIXME: handling of bits 32:63 of rax, rdx / vcpu->arch.regs[VCPU_REGS_RAX] = data & -1u; vcpu->arch.regs[VCPU_REGS_RDX] = (data >> 32) & -1u; skip_emulated_instruction(vcpu); return 1; } static int handle_wrmsr(struct kvm_vcpu vcpu) { struct msr_data msr; u32 ecx = vcpu->arch.regs[VCPU_REGS_RCX]; u64 data = (vcpu->arch.regs[VCPU_REGS_RAX] & -1u) \| ((u64)(vcpu->arch.regs[VCPU_REGS_RDX] & -1u) << 32); msr.data = data; msr.index = ecx; msr.host_initiated = false; if (kvm_set_msr(vcpu, &msr) != 0) { trace_kvm_msr_write_ex(ecx, data); kvm_inject_gp(vcpu, 0); return 1; } trace_kvm_msr_write(ecx, data); skip_emulated_instruction(vcpu); return 1; } static int handle_tpr_below_threshold(struct kvm_vcpu vcpu) { kvm_make_request(KVM_REQ_EVENT, vcpu); return 1; } static int handle_interrupt_window(struct kvm_vcpu vcpu) { u32 cpu_based_vm_exec_control; /* clear pending irq / cpu_based_vm_exec_control = vmcs_read32(CPU_BASED_VM_EXEC_CONTROL); cpu_based_vm_exec_control &= ~CPU_BASED_VIRTUAL_INTR_PENDING; vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, cpu_based_vm_exec_control); kvm_make_request(KVM_REQ_EVENT, vcpu); ++vcpu->stat.irq_window_exits; / * If the user space waits to inject interrupts, exit as soon as * possible / if (!irqchip_in_kernel(vcpu->kvm) && vcpu->run->request_interrupt_window && !kvm_cpu_has_interrupt(vcpu)) { vcpu->run->exit_reason = KVM_EXIT_IRQ_WINDOW_OPEN; return 0; } return 1; } static int handle_halt(struct kvm_vcpu vcpu) { skip_emulated_instruction(vcpu); return kvm_emulate_halt(vcpu); } static int handle_vmcall(struct kvm_vcpu vcpu) { skip_emulated_instruction(vcpu); kvm_emulate_hypercall(vcpu); return 1; } static int handle_invd(struct kvm_vcpu vcpu) { return emulate_instruction(vcpu, 0) == EMULATE_DONE; } static int handle_invlpg(struct kvm_vcpu vcpu) { unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION); kvm_mmu_invlpg(vcpu, exit_qualification); skip_emulated_instruction(vcpu); return 1; } static int handle_rdpmc(struct kvm_vcpu vcpu) { int err; err = kvm_rdpmc(vcpu); kvm_complete_insn_gp(vcpu, err); return 1; } static int handle_wbinvd(struct kvm_vcpu vcpu) { skip_emulated_instruction(vcpu); kvm_emulate_wbinvd(vcpu); return 1; } static int handle_xsetbv(struct kvm_vcpu vcpu) { u64 new_bv = kvm_read_edx_eax(vcpu); u32 index = kvm_register_read(vcpu, VCPU_REGS_RCX); if (kvm_set_xcr(vcpu, index, new_bv) == 0) skip_emulated_instruction(vcpu); return 1; } static int handle_apic_access(struct kvm_vcpu vcpu) { if (likely(fasteoi)) { unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION); int access_type, offset; access_type = exit_qualification & APIC_ACCESS_TYPE; offset = exit_qualification & APIC_ACCESS_OFFSET; / * Sane guest uses MOV to write EOI, with written value * not cared. So make a short-circuit here by avoiding * heavy instruction emulation. / if ((access_type == TYPE_LINEAR_APIC_INST_WRITE) && (offset == APIC_EOI)) { kvm_lapic_set_eoi(vcpu); skip_emulated_instruction(vcpu); return 1; } } return emulate_instruction(vcpu, 0) == EMULATE_DONE; } static int handle_apic_eoi_induced(struct kvm_vcpu vcpu) { unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION); int vector = exit_qualification & 0xff; /* EOI-induced VM exit is trap-like and thus no need to adjust IP / kvm_apic_set_eoi_accelerated(vcpu, vector); return 1; } static int handle_apic_write(struct kvm_vcpu vcpu) { unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION); u32 offset = exit_qualification & 0xfff; /* APIC-write VM exit is trap-like and thus no need to adjust IP / kvm_apic_write_nodecode(vcpu, offset); return 1; } static int handle_task_switch(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); unsigned long exit_qualification; bool has_error_code = false; u32 error_code = 0; u16 tss_selector; int reason, type, idt_v, idt_index; idt_v = (vmx->idt_vectoring_info & VECTORING_INFO_VALID_MASK); idt_index = (vmx->idt_vectoring_info & VECTORING_INFO_VECTOR_MASK); type = (vmx->idt_vectoring_info & VECTORING_INFO_TYPE_MASK); exit_qualification = vmcs_readl(EXIT_QUALIFICATION); reason = (u32)exit_qualification >> 30; if (reason == TASK_SWITCH_GATE && idt_v) { switch (type) { case INTR_TYPE_NMI_INTR: vcpu->arch.nmi_injected = false; vmx_set_nmi_mask(vcpu, true); break; case INTR_TYPE_EXT_INTR: case INTR_TYPE_SOFT_INTR: kvm_clear_interrupt_queue(vcpu); break; case INTR_TYPE_HARD_EXCEPTION: if (vmx->idt_vectoring_info & VECTORING_INFO_DELIVER_CODE_MASK) { has_error_code = true; error_code = vmcs_read32(IDT_VECTORING_ERROR_CODE); } / fall through / case INTR_TYPE_SOFT_EXCEPTION: kvm_clear_exception_queue(vcpu); break; default: break; } } tss_selector = exit_qualification; if (!idt_v \|\| (type != INTR_TYPE_HARD_EXCEPTION && type != INTR_TYPE_EXT_INTR && type != INTR_TYPE_NMI_INTR)) skip_emulated_instruction(vcpu); if (kvm_task_switch(vcpu, tss_selector, type == INTR_TYPE_SOFT_INTR ? idt_index : -1, reason, has_error_code, error_code) == EMULATE_FAIL) { vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR; vcpu->run->internal.suberror = KVM_INTERNAL_ERROR_EMULATION; vcpu->run->internal.ndata = 0; return 0; } / clear all local breakpoint enable flags / vmcs_writel(GUEST_DR7, vmcs_readl(GUEST_DR7) & ~0x55); / * TODO: What about debug traps on tss switch? * Are we supposed to inject them and update dr6? / return 1; } static int handle_ept_violation(struct kvm_vcpu vcpu) { unsigned long exit_qualification; gpa_t gpa; u32 error_code; int gla_validity; exit_qualification = vmcs_readl(EXIT_QUALIFICATION); gla_validity = (exit_qualification >> 7) & 0x3; if (gla_validity != 0x3 && gla_validity != 0x1 && gla_validity != 0) { printk(KERN_ERR "EPT: Handling EPT violation failed!\n"); printk(KERN_ERR "EPT: GPA: 0x%lx, GVA: 0x%lx\n", (long unsigned int)vmcs_read64(GUEST_PHYSICAL_ADDRESS), vmcs_readl(GUEST_LINEAR_ADDRESS)); printk(KERN_ERR "EPT: Exit qualification is 0x%lx\n", (long unsigned int)exit_qualification); vcpu->run->exit_reason = KVM_EXIT_UNKNOWN; vcpu->run->hw.hardware_exit_reason = EXIT_REASON_EPT_VIOLATION; return 0; } /* * EPT violation happened while executing iret from NMI, * "blocked by NMI" bit has to be set before next VM entry. * There are errata that may cause this bit to not be set: * AAK134, BY25. / if (!(to_vmx(vcpu)->idt_vectoring_info & VECTORING_INFO_VALID_MASK) && cpu_has_virtual_nmis() && (exit_qualification & INTR_INFO_UNBLOCK_NMI)) vmcs_set_bits(GUEST_INTERRUPTIBILITY_INFO, GUEST_INTR_STATE_NMI); gpa = vmcs_read64(GUEST_PHYSICAL_ADDRESS); trace_kvm_page_fault(gpa, exit_qualification); / It is a write fault? / error_code = exit_qualification & (1U << 1); / It is a fetch fault? / error_code \|= (exit_qualification & (1U << 2)) << 2; / ept page table is present? / error_code \|= (exit_qualification >> 3) & 0x1; vcpu->arch.exit_qualification = exit_qualification; return kvm_mmu_page_fault(vcpu, gpa, error_code, NULL, 0); } static u64 ept_rsvd_mask(u64 spte, int level) { int i; u64 mask = 0; for (i = 51; i > boot_cpu_data.x86_phys_bits; i--) mask \|= (1ULL << i); if (level == 4) / bits 7:3 reserved / mask \|= 0xf8; else if (spte & (1ULL << 7)) / * 1GB/2MB page, bits 29:12 or 20:12 reserved respectively, * level == 1 if the hypervisor is using the ignored bit 7. / mask \|= (PAGE_SIZE << ((level - 1) 9)) - PAGE_SIZE; else if (level > 1) /* bits 6:3 reserved / mask \|= 0x78; return mask; } static void ept_misconfig_inspect_spte(struct kvm_vcpu vcpu, u64 spte, int level) { printk(KERN_ERR "%s: spte 0x%llx level %d\n", __func__, spte, level); /* 010b (write-only) / WARN_ON((spte & 0x7) == 0x2); / 110b (write/execute) / WARN_ON((spte & 0x7) == 0x6); / 100b (execute-only) and value not supported by logical processor / if (!cpu_has_vmx_ept_execute_only()) WARN_ON((spte & 0x7) == 0x4); / not 000b / if ((spte & 0x7)) { u64 rsvd_bits = spte & ept_rsvd_mask(spte, level); if (rsvd_bits != 0) { printk(KERN_ERR "%s: rsvd_bits = 0x%llx\n", __func__, rsvd_bits); WARN_ON(1); } / bits 5:3 are _not_ reserved for large page or leaf page / if ((rsvd_bits & 0x38) == 0) { u64 ept_mem_type = (spte & 0x38) >> 3; if (ept_mem_type == 2 \|\| ept_mem_type == 3 \|\| ept_mem_type == 7) { printk(KERN_ERR "%s: ept_mem_type=0x%llx\n", __func__, ept_mem_type); WARN_ON(1); } } } } static int handle_ept_misconfig(struct kvm_vcpu vcpu) { u64 sptes[4]; int nr_sptes, i, ret; gpa_t gpa; gpa = vmcs_read64(GUEST_PHYSICAL_ADDRESS); if (!kvm_io_bus_write(vcpu->kvm, KVM_FAST_MMIO_BUS, gpa, 0, NULL)) { skip_emulated_instruction(vcpu); return 1; } ret = handle_mmio_page_fault_common(vcpu, gpa, true); if (likely(ret == RET_MMIO_PF_EMULATE)) return x86_emulate_instruction(vcpu, gpa, 0, NULL, 0) == EMULATE_DONE; if (unlikely(ret == RET_MMIO_PF_INVALID)) return kvm_mmu_page_fault(vcpu, gpa, 0, NULL, 0); if (unlikely(ret == RET_MMIO_PF_RETRY)) return 1; /* It is the real ept misconfig / printk(KERN_ERR "EPT: Misconfiguration.\n"); printk(KERN_ERR "EPT: GPA: 0x%llx\n", gpa); nr_sptes = kvm_mmu_get_spte_hierarchy(vcpu, gpa, sptes); for (i = PT64_ROOT_LEVEL; i > PT64_ROOT_LEVEL - nr_sptes; --i) ept_misconfig_inspect_spte(vcpu, sptes[i-1], i); vcpu->run->exit_reason = KVM_EXIT_UNKNOWN; vcpu->run->hw.hardware_exit_reason = EXIT_REASON_EPT_MISCONFIG; return 0; } static int handle_nmi_window(struct kvm_vcpu vcpu) { u32 cpu_based_vm_exec_control; /* clear pending NMI / cpu_based_vm_exec_control = vmcs_read32(CPU_BASED_VM_EXEC_CONTROL); cpu_based_vm_exec_control &= ~CPU_BASED_VIRTUAL_NMI_PENDING; vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, cpu_based_vm_exec_control); ++vcpu->stat.nmi_window_exits; kvm_make_request(KVM_REQ_EVENT, vcpu); return 1; } static int handle_invalid_guest_state(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); enum emulation_result err = EMULATE_DONE; int ret = 1; u32 cpu_exec_ctrl; bool intr_window_requested; unsigned count = 130; cpu_exec_ctrl = vmcs_read32(CPU_BASED_VM_EXEC_CONTROL); intr_window_requested = cpu_exec_ctrl & CPU_BASED_VIRTUAL_INTR_PENDING; while (vmx->emulation_required && count-- != 0) { if (intr_window_requested && vmx_interrupt_allowed(vcpu)) return handle_interrupt_window(&vmx->vcpu); if (test_bit(KVM_REQ_EVENT, &vcpu->requests)) return 1; err = emulate_instruction(vcpu, EMULTYPE_NO_REEXECUTE); if (err == EMULATE_USER_EXIT) { ++vcpu->stat.mmio_exits; ret = 0; goto out; } if (err != EMULATE_DONE) { vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR; vcpu->run->internal.suberror = KVM_INTERNAL_ERROR_EMULATION; vcpu->run->internal.ndata = 0; return 0; } if (vcpu->arch.halt_request) { vcpu->arch.halt_request = 0; ret = kvm_emulate_halt(vcpu); goto out; } if (signal_pending(current)) goto out; if (need_resched()) schedule(); } out: return ret; } static int __grow_ple_window(int val) { if (ple_window_grow < 1) return ple_window; val = min(val, ple_window_actual_max); if (ple_window_grow < ple_window) val = ple_window_grow; else val += ple_window_grow; return val; } static int __shrink_ple_window(int val, int modifier, int minimum) { if (modifier < 1) return ple_window; if (modifier < ple_window) val /= modifier; else val -= modifier; return max(val, minimum); } static void grow_ple_window(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); int old = vmx->ple_window; vmx->ple_window = __grow_ple_window(old); if (vmx->ple_window != old) vmx->ple_window_dirty = true; trace_kvm_ple_window_grow(vcpu->vcpu_id, vmx->ple_window, old); } static void shrink_ple_window(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); int old = vmx->ple_window; vmx->ple_window = __shrink_ple_window(old, ple_window_shrink, ple_window); if (vmx->ple_window != old) vmx->ple_window_dirty = true; trace_kvm_ple_window_shrink(vcpu->vcpu_id, vmx->ple_window, old); } /* * ple_window_actual_max is computed to be one grow_ple_window() below * ple_window_max. (See __grow_ple_window for the reason.) * This prevents overflows, because ple_window_max is int. * ple_window_max effectively rounded down to a multiple of ple_window_grow in * this process. * ple_window_max is also prevented from setting vmx->ple_window < ple_window. / static void update_ple_window_actual_max(void) { ple_window_actual_max = __shrink_ple_window(max(ple_window_max, ple_window), ple_window_grow, INT_MIN); } / * Indicate a busy-waiting vcpu in spinlock. We do not enable the PAUSE * exiting, so only get here on cpu with PAUSE-Loop-Exiting. / static int handle_pause(struct kvm_vcpu vcpu) { if (ple_gap) grow_ple_window(vcpu); skip_emulated_instruction(vcpu); kvm_vcpu_on_spin(vcpu); return 1; } static int handle_nop(struct kvm_vcpu vcpu) { skip_emulated_instruction(vcpu); return 1; } static int handle_mwait(struct kvm_vcpu vcpu) { printk_once(KERN_WARNING "kvm: MWAIT instruction emulated as NOP!\n"); return handle_nop(vcpu); } static int handle_monitor(struct kvm_vcpu vcpu) { printk_once(KERN_WARNING "kvm: MONITOR instruction emulated as NOP!\n"); return handle_nop(vcpu); } / * To run an L2 guest, we need a vmcs02 based on the L1-specified vmcs12. * We could reuse a single VMCS for all the L2 guests, but we also want the * option to allocate a separate vmcs02 for each separate loaded vmcs12 - this * allows keeping them loaded on the processor, and in the future will allow * optimizations where prepare_vmcs02 doesn't need to set all the fields on * every entry if they never change. * So we keep, in vmx->nested.vmcs02_pool, a cache of size VMCS02_POOL_SIZE * (>=0) with a vmcs02 for each recently loaded vmcs12s, most recent first. * * The following functions allocate and free a vmcs02 in this pool. / / Get a VMCS from the pool to use as vmcs02 for the current vmcs12. / static struct loaded_vmcs nested_get_current_vmcs02(struct vcpu_vmx vmx) { struct vmcs02_list item; list_for_each_entry(item, &vmx->nested.vmcs02_pool, list) if (item->vmptr == vmx->nested.current_vmptr) { list_move(&item->list, &vmx->nested.vmcs02_pool); return &item->vmcs02; } if (vmx->nested.vmcs02_num >= max(VMCS02_POOL_SIZE, 1)) { /* Recycle the least recently used VMCS. / item = list_entry(vmx->nested.vmcs02_pool.prev, struct vmcs02_list, list); item->vmptr = vmx->nested.current_vmptr; list_move(&item->list, &vmx->nested.vmcs02_pool); return &item->vmcs02; } / Create a new VMCS / item = kmalloc(sizeof(struct vmcs02_list), GFP_KERNEL); if (!item) return NULL; item->vmcs02.vmcs = alloc_vmcs(); if (!item->vmcs02.vmcs) { kfree(item); return NULL; } loaded_vmcs_init(&item->vmcs02); item->vmptr = vmx->nested.current_vmptr; list_add(&(item->list), &(vmx->nested.vmcs02_pool)); vmx->nested.vmcs02_num++; return &item->vmcs02; } / Free and remove from pool a vmcs02 saved for a vmcs12 (if there is one) / static void nested_free_vmcs02(struct vcpu_vmx vmx, gpa_t vmptr) { struct vmcs02_list item; list_for_each_entry(item, &vmx->nested.vmcs02_pool, list) if (item->vmptr == vmptr) { free_loaded_vmcs(&item->vmcs02); list_del(&item->list); kfree(item); vmx->nested.vmcs02_num--; return; } } / * Free all VMCSs saved for this vcpu, except the one pointed by * vmx->loaded_vmcs. We must be running L1, so vmx->loaded_vmcs * must be &vmx->vmcs01. / static void nested_free_all_saved_vmcss(struct vcpu_vmx vmx) { struct vmcs02_list item, n; WARN_ON(vmx->loaded_vmcs != &vmx->vmcs01); list_for_each_entry_safe(item, n, &vmx->nested.vmcs02_pool, list) { /* * Something will leak if the above WARN triggers. Better than * a use-after-free. / if (vmx->loaded_vmcs == &item->vmcs02) continue; free_loaded_vmcs(&item->vmcs02); list_del(&item->list); kfree(item); vmx->nested.vmcs02_num--; } } / * The following 3 functions, nested_vmx_succeed()/failValid()/failInvalid(), * set the success or error code of an emulated VMX instruction, as specified * by Vol 2B, VMX Instruction Reference, "Conventions". / static void nested_vmx_succeed(struct kvm_vcpu vcpu) { vmx_set_rflags(vcpu, vmx_get_rflags(vcpu) & ~(X86_EFLAGS_CF \| X86_EFLAGS_PF \| X86_EFLAGS_AF \| X86_EFLAGS_ZF \| X86_EFLAGS_SF \| X86_EFLAGS_OF)); } static void nested_vmx_failInvalid(struct kvm_vcpu vcpu) { vmx_set_rflags(vcpu, (vmx_get_rflags(vcpu) & ~(X86_EFLAGS_PF \| X86_EFLAGS_AF \| X86_EFLAGS_ZF \| X86_EFLAGS_SF \| X86_EFLAGS_OF)) \| X86_EFLAGS_CF); } static void nested_vmx_failValid(struct kvm_vcpu vcpu, u32 vm_instruction_error) { if (to_vmx(vcpu)->nested.current_vmptr == -1ull) { /* * failValid writes the error number to the current VMCS, which * can't be done there isn't a current VMCS. / nested_vmx_failInvalid(vcpu); return; } vmx_set_rflags(vcpu, (vmx_get_rflags(vcpu) & ~(X86_EFLAGS_CF \| X86_EFLAGS_PF \| X86_EFLAGS_AF \| X86_EFLAGS_SF \| X86_EFLAGS_OF)) \| X86_EFLAGS_ZF); get_vmcs12(vcpu)->vm_instruction_error = vm_instruction_error; / * We don't need to force a shadow sync because * VM_INSTRUCTION_ERROR is not shadowed / } static enum hrtimer_restart vmx_preemption_timer_fn(struct hrtimer timer) { struct vcpu_vmx vmx = container_of(timer, struct vcpu_vmx, nested.preemption_timer); vmx->nested.preemption_timer_expired = true; kvm_make_request(KVM_REQ_EVENT, &vmx->vcpu); kvm_vcpu_kick(&vmx->vcpu); return HRTIMER_NORESTART; } / * Decode the memory-address operand of a vmx instruction, as recorded on an * exit caused by such an instruction (run by a guest hypervisor). * On success, returns 0. When the operand is invalid, returns 1 and throws * #UD or #GP. / static int get_vmx_mem_address(struct kvm_vcpu vcpu, unsigned long exit_qualification, u32 vmx_instruction_info, gva_t ret) { / * According to Vol. 3B, "Information for VM Exits Due to Instruction * Execution", on an exit, vmx_instruction_info holds most of the * addressing components of the operand. Only the displacement part * is put in exit_qualification (see 3B, "Basic VM-Exit Information"). * For how an actual address is calculated from all these components, * refer to Vol. 1, "Operand Addressing". / int scaling = vmx_instruction_info & 3; int addr_size = (vmx_instruction_info >> 7) & 7; bool is_reg = vmx_instruction_info & (1u << 10); int seg_reg = (vmx_instruction_info >> 15) & 7; int index_reg = (vmx_instruction_info >> 18) & 0xf; bool index_is_valid = !(vmx_instruction_info & (1u << 22)); int base_reg = (vmx_instruction_info >> 23) & 0xf; bool base_is_valid = !(vmx_instruction_info & (1u << 27)); if (is_reg) { kvm_queue_exception(vcpu, UD_VECTOR); return 1; } / Addr = segment_base + offset / / offset = base + [index * scale] + displacement / ret = vmx_get_segment_base(vcpu, seg_reg); if (base_is_valid) ret += kvm_register_read(vcpu, base_reg); if (index_is_valid) ret += kvm_register_read(vcpu, index_reg)<<scaling; ret += exit_qualification; / holds the displacement / if (addr_size == 1) / 32 bit / ret &= 0xffffffff; /* * TODO: throw #GP (and return 1) in various cases that the VM* * instructions require it - e.g., offset beyond segment limit, * unusable or unreadable/unwritable segment, non-canonical 64-bit * address, and so on. Currently these are not checked. / return 0; } / * This function performs the various checks including * - if it's 4KB aligned * - No bits beyond the physical address width are set * - Returns 0 on success or else 1 * (Intel SDM Section 30.3) / static int nested_vmx_check_vmptr(struct kvm_vcpu vcpu, int exit_reason, gpa_t vmpointer) { gva_t gva; gpa_t vmptr; struct x86_exception e; struct page page; struct vcpu_vmx vmx = to_vmx(vcpu); int maxphyaddr = cpuid_maxphyaddr(vcpu); if (get_vmx_mem_address(vcpu, vmcs_readl(EXIT_QUALIFICATION), vmcs_read32(VMX_INSTRUCTION_INFO), &gva)) return 1; if (kvm_read_guest_virt(&vcpu->arch.emulate_ctxt, gva, &vmptr, sizeof(vmptr), &e)) { kvm_inject_page_fault(vcpu, &e); return 1; } switch (exit_reason) { case EXIT_REASON_VMON: / * SDM 3: 24.11.5 * The first 4 bytes of VMXON region contain the supported * VMCS revision identifier * * Note - IA32_VMX_BASIC[48] will never be 1 * for the nested case; * which replaces physical address width with 32 * / if (!PAGE_ALIGNED(vmptr) \|\| (vmptr >> maxphyaddr)) { nested_vmx_failInvalid(vcpu); skip_emulated_instruction(vcpu); return 1; } page = nested_get_page(vcpu, vmptr); if (page == NULL \|\| (u32 )kmap(page) != VMCS12_REVISION) { nested_vmx_failInvalid(vcpu); kunmap(page); skip_emulated_instruction(vcpu); return 1; } kunmap(page); vmx->nested.vmxon_ptr = vmptr; break; case EXIT_REASON_VMCLEAR: if (!PAGE_ALIGNED(vmptr) \|\| (vmptr >> maxphyaddr)) { nested_vmx_failValid(vcpu, VMXERR_VMCLEAR_INVALID_ADDRESS); skip_emulated_instruction(vcpu); return 1; } if (vmptr == vmx->nested.vmxon_ptr) { nested_vmx_failValid(vcpu, VMXERR_VMCLEAR_VMXON_POINTER); skip_emulated_instruction(vcpu); return 1; } break; case EXIT_REASON_VMPTRLD: if (!PAGE_ALIGNED(vmptr) \|\| (vmptr >> maxphyaddr)) { nested_vmx_failValid(vcpu, VMXERR_VMPTRLD_INVALID_ADDRESS); skip_emulated_instruction(vcpu); return 1; } if (vmptr == vmx->nested.vmxon_ptr) { nested_vmx_failValid(vcpu, VMXERR_VMCLEAR_VMXON_POINTER); skip_emulated_instruction(vcpu); return 1; } break; default: return 1; / shouldn't happen / } if (vmpointer) vmpointer = vmptr; return 0; } /* * Emulate the VMXON instruction. * Currently, we just remember that VMX is active, and do not save or even * inspect the argument to VMXON (the so-called "VMXON pointer") because we * do not currently need to store anything in that guest-allocated memory * region. Consequently, VMCLEAR and VMPTRLD also do not verify that the their * argument is different from the VMXON pointer (which the spec says they do). / static int handle_vmon(struct kvm_vcpu vcpu) { struct kvm_segment cs; struct vcpu_vmx vmx = to_vmx(vcpu); struct vmcs shadow_vmcs; const u64 VMXON_NEEDED_FEATURES = FEATURE_CONTROL_LOCKED \| FEATURE_CONTROL_VMXON_ENABLED_OUTSIDE_SMX; /* The Intel VMX Instruction Reference lists a bunch of bits that * are prerequisite to running VMXON, most notably cr4.VMXE must be * set to 1 (see vmx_set_cr4() for when we allow the guest to set this). * Otherwise, we should fail with #UD. We test these now: / if (!kvm_read_cr4_bits(vcpu, X86_CR4_VMXE) \|\| !kvm_read_cr0_bits(vcpu, X86_CR0_PE) \|\| (vmx_get_rflags(vcpu) & X86_EFLAGS_VM)) { kvm_queue_exception(vcpu, UD_VECTOR); return 1; } vmx_get_segment(vcpu, &cs, VCPU_SREG_CS); if (is_long_mode(vcpu) && !cs.l) { kvm_queue_exception(vcpu, UD_VECTOR); return 1; } if (vmx_get_cpl(vcpu)) { kvm_inject_gp(vcpu, 0); return 1; } if (nested_vmx_check_vmptr(vcpu, EXIT_REASON_VMON, NULL)) return 1; if (vmx->nested.vmxon) { nested_vmx_failValid(vcpu, VMXERR_VMXON_IN_VMX_ROOT_OPERATION); skip_emulated_instruction(vcpu); return 1; } if ((vmx->nested.msr_ia32_feature_control & VMXON_NEEDED_FEATURES) != VMXON_NEEDED_FEATURES) { kvm_inject_gp(vcpu, 0); return 1; } if (enable_shadow_vmcs) { shadow_vmcs = alloc_vmcs(); if (!shadow_vmcs) return -ENOMEM; / mark vmcs as shadow / shadow_vmcs->revision_id \|= (1u << 31); / init shadow vmcs / vmcs_clear(shadow_vmcs); vmx->nested.current_shadow_vmcs = shadow_vmcs; } INIT_LIST_HEAD(&(vmx->nested.vmcs02_pool)); vmx->nested.vmcs02_num = 0; hrtimer_init(&vmx->nested.preemption_timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); vmx->nested.preemption_timer.function = vmx_preemption_timer_fn; vmx->nested.vmxon = true; skip_emulated_instruction(vcpu); nested_vmx_succeed(vcpu); return 1; } / * Intel's VMX Instruction Reference specifies a common set of prerequisites * for running VMX instructions (except VMXON, whose prerequisites are * slightly different). It also specifies what exception to inject otherwise. / static int nested_vmx_check_permission(struct kvm_vcpu vcpu) { struct kvm_segment cs; struct vcpu_vmx vmx = to_vmx(vcpu); if (!vmx->nested.vmxon) { kvm_queue_exception(vcpu, UD_VECTOR); return 0; } vmx_get_segment(vcpu, &cs, VCPU_SREG_CS); if ((vmx_get_rflags(vcpu) & X86_EFLAGS_VM) \|\| (is_long_mode(vcpu) && !cs.l)) { kvm_queue_exception(vcpu, UD_VECTOR); return 0; } if (vmx_get_cpl(vcpu)) { kvm_inject_gp(vcpu, 0); return 0; } return 1; } static inline void nested_release_vmcs12(struct vcpu_vmx vmx) { u32 exec_control; if (vmx->nested.current_vmptr == -1ull) return; /* current_vmptr and current_vmcs12 are always set/reset together / if (WARN_ON(vmx->nested.current_vmcs12 == NULL)) return; if (enable_shadow_vmcs) { / copy to memory all shadowed fields in case they were modified / copy_shadow_to_vmcs12(vmx); vmx->nested.sync_shadow_vmcs = false; exec_control = vmcs_read32(SECONDARY_VM_EXEC_CONTROL); exec_control &= ~SECONDARY_EXEC_SHADOW_VMCS; vmcs_write32(SECONDARY_VM_EXEC_CONTROL, exec_control); vmcs_write64(VMCS_LINK_POINTER, -1ull); } kunmap(vmx->nested.current_vmcs12_page); nested_release_page(vmx->nested.current_vmcs12_page); vmx->nested.current_vmptr = -1ull; vmx->nested.current_vmcs12 = NULL; } / * Free whatever needs to be freed from vmx->nested when L1 goes down, or * just stops using VMX. / static void free_nested(struct vcpu_vmx vmx) { if (!vmx->nested.vmxon) return; vmx->nested.vmxon = false; nested_release_vmcs12(vmx); if (enable_shadow_vmcs) free_vmcs(vmx->nested.current_shadow_vmcs); /* Unpin physical memory we referred to in current vmcs02 / if (vmx->nested.apic_access_page) { nested_release_page(vmx->nested.apic_access_page); vmx->nested.apic_access_page = NULL; } if (vmx->nested.virtual_apic_page) { nested_release_page(vmx->nested.virtual_apic_page); vmx->nested.virtual_apic_page = NULL; } nested_free_all_saved_vmcss(vmx); } / Emulate the VMXOFF instruction / static int handle_vmoff(struct kvm_vcpu vcpu) { if (!nested_vmx_check_permission(vcpu)) return 1; free_nested(to_vmx(vcpu)); skip_emulated_instruction(vcpu); nested_vmx_succeed(vcpu); return 1; } /* Emulate the VMCLEAR instruction / static int handle_vmclear(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); gpa_t vmptr; struct vmcs12 vmcs12; struct page page; if (!nested_vmx_check_permission(vcpu)) return 1; if (nested_vmx_check_vmptr(vcpu, EXIT_REASON_VMCLEAR, &vmptr)) return 1; if (vmptr == vmx->nested.current_vmptr) nested_release_vmcs12(vmx); page = nested_get_page(vcpu, vmptr); if (page == NULL) { / * For accurate processor emulation, VMCLEAR beyond available * physical memory should do nothing at all. However, it is * possible that a nested vmx bug, not a guest hypervisor bug, * resulted in this case, so let's shut down before doing any * more damage: / kvm_make_request(KVM_REQ_TRIPLE_FAULT, vcpu); return 1; } vmcs12 = kmap(page); vmcs12->launch_state = 0; kunmap(page); nested_release_page(page); nested_free_vmcs02(vmx, vmptr); skip_emulated_instruction(vcpu); nested_vmx_succeed(vcpu); return 1; } static int nested_vmx_run(struct kvm_vcpu vcpu, bool launch); /* Emulate the VMLAUNCH instruction / static int handle_vmlaunch(struct kvm_vcpu vcpu) { return nested_vmx_run(vcpu, true); } /* Emulate the VMRESUME instruction / static int handle_vmresume(struct kvm_vcpu vcpu) { return nested_vmx_run(vcpu, false); } enum vmcs_field_type { VMCS_FIELD_TYPE_U16 = 0, VMCS_FIELD_TYPE_U64 = 1, VMCS_FIELD_TYPE_U32 = 2, VMCS_FIELD_TYPE_NATURAL_WIDTH = 3 }; static inline int vmcs_field_type(unsigned long field) { if (0x1 & field) /* the _HIGH fields are all 32 bit / return VMCS_FIELD_TYPE_U32; return (field >> 13) & 0x3 ; } static inline int vmcs_field_readonly(unsigned long field) { return (((field >> 10) & 0x3) == 1); } /* * Read a vmcs12 field. Since these can have varying lengths and we return * one type, we chose the biggest type (u64) and zero-extend the return value * to that size. Note that the caller, handle_vmread, might need to use only * some of the bits we return here (e.g., on 32-bit guests, only 32 bits of * 64-bit fields are to be returned). / static inline bool vmcs12_read_any(struct kvm_vcpu vcpu, unsigned long field, u64 ret) { short offset = vmcs_field_to_offset(field); char p; if (offset < 0) return 0; p = ((char )(get_vmcs12(vcpu))) + offset; switch (vmcs_field_type(field)) { case VMCS_FIELD_TYPE_NATURAL_WIDTH: ret = ((natural_width )p); return 1; case VMCS_FIELD_TYPE_U16: ret = ((u16 )p); return 1; case VMCS_FIELD_TYPE_U32: ret = ((u32 )p); return 1; case VMCS_FIELD_TYPE_U64: ret = ((u64 )p); return 1; default: return 0; / can never happen. / } } static inline bool vmcs12_write_any(struct kvm_vcpu vcpu, unsigned long field, u64 field_value){ short offset = vmcs_field_to_offset(field); char p = ((char ) get_vmcs12(vcpu)) + offset; if (offset < 0) return false; switch (vmcs_field_type(field)) { case VMCS_FIELD_TYPE_U16: (u16 )p = field_value; return true; case VMCS_FIELD_TYPE_U32: (u32 )p = field_value; return true; case VMCS_FIELD_TYPE_U64: (u64 )p = field_value; return true; case VMCS_FIELD_TYPE_NATURAL_WIDTH: (natural_width )p = field_value; return true; default: return false; /* can never happen. / } } static void copy_shadow_to_vmcs12(struct vcpu_vmx vmx) { int i; unsigned long field; u64 field_value; struct vmcs shadow_vmcs = vmx->nested.current_shadow_vmcs; const unsigned long fields = shadow_read_write_fields; const int num_fields = max_shadow_read_write_fields; vmcs_load(shadow_vmcs); for (i = 0; i < num_fields; i++) { field = fields[i]; switch (vmcs_field_type(field)) { case VMCS_FIELD_TYPE_U16: field_value = vmcs_read16(field); break; case VMCS_FIELD_TYPE_U32: field_value = vmcs_read32(field); break; case VMCS_FIELD_TYPE_U64: field_value = vmcs_read64(field); break; case VMCS_FIELD_TYPE_NATURAL_WIDTH: field_value = vmcs_readl(field); break; } vmcs12_write_any(&vmx->vcpu, field, field_value); } vmcs_clear(shadow_vmcs); vmcs_load(vmx->loaded_vmcs->vmcs); } static void copy_vmcs12_to_shadow(struct vcpu_vmx vmx) { const unsigned long fields[] = { shadow_read_write_fields, shadow_read_only_fields }; const int max_fields[] = { max_shadow_read_write_fields, max_shadow_read_only_fields }; int i, q; unsigned long field; u64 field_value = 0; struct vmcs shadow_vmcs = vmx->nested.current_shadow_vmcs; vmcs_load(shadow_vmcs); for (q = 0; q < ARRAY_SIZE(fields); q++) { for (i = 0; i < max_fields[q]; i++) { field = fields[q][i]; vmcs12_read_any(&vmx->vcpu, field, &field_value); switch (vmcs_field_type(field)) { case VMCS_FIELD_TYPE_U16: vmcs_write16(field, (u16)field_value); break; case VMCS_FIELD_TYPE_U32: vmcs_write32(field, (u32)field_value); break; case VMCS_FIELD_TYPE_U64: vmcs_write64(field, (u64)field_value); break; case VMCS_FIELD_TYPE_NATURAL_WIDTH: vmcs_writel(field, (long)field_value); break; } } } vmcs_clear(shadow_vmcs); vmcs_load(vmx->loaded_vmcs->vmcs); } / * VMX instructions which assume a current vmcs12 (i.e., that VMPTRLD was * used before) all generate the same failure when it is missing. / static int nested_vmx_check_vmcs12(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); if (vmx->nested.current_vmptr == -1ull) { nested_vmx_failInvalid(vcpu); skip_emulated_instruction(vcpu); return 0; } return 1; } static int handle_vmread(struct kvm_vcpu vcpu) { unsigned long field; u64 field_value; unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION); u32 vmx_instruction_info = vmcs_read32(VMX_INSTRUCTION_INFO); gva_t gva = 0; if (!nested_vmx_check_permission(vcpu) \|\| !nested_vmx_check_vmcs12(vcpu)) return 1; /* Decode instruction info and find the field to read / field = kvm_register_readl(vcpu, (((vmx_instruction_info) >> 28) & 0xf)); / Read the field, zero-extended to a u64 field_value / if (!vmcs12_read_any(vcpu, field, &field_value)) { nested_vmx_failValid(vcpu, VMXERR_UNSUPPORTED_VMCS_COMPONENT); skip_emulated_instruction(vcpu); return 1; } / * Now copy part of this value to register or memory, as requested. * Note that the number of bits actually copied is 32 or 64 depending * on the guest's mode (32 or 64 bit), not on the given field's length. / if (vmx_instruction_info & (1u << 10)) { kvm_register_writel(vcpu, (((vmx_instruction_info) >> 3) & 0xf), field_value); } else { if (get_vmx_mem_address(vcpu, exit_qualification, vmx_instruction_info, &gva)) return 1; / _system ok, as nested_vmx_check_permission verified cpl=0 / kvm_write_guest_virt_system(&vcpu->arch.emulate_ctxt, gva, &field_value, (is_long_mode(vcpu) ? 8 : 4), NULL); } nested_vmx_succeed(vcpu); skip_emulated_instruction(vcpu); return 1; } static int handle_vmwrite(struct kvm_vcpu vcpu) { unsigned long field; gva_t gva; unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION); u32 vmx_instruction_info = vmcs_read32(VMX_INSTRUCTION_INFO); /* The value to write might be 32 or 64 bits, depending on L1's long * mode, and eventually we need to write that into a field of several * possible lengths. The code below first zero-extends the value to 64 * bit (field_value), and then copies only the approriate number of * bits into the vmcs12 field. / u64 field_value = 0; struct x86_exception e; if (!nested_vmx_check_permission(vcpu) \|\| !nested_vmx_check_vmcs12(vcpu)) return 1; if (vmx_instruction_info & (1u << 10)) field_value = kvm_register_readl(vcpu, (((vmx_instruction_info) >> 3) & 0xf)); else { if (get_vmx_mem_address(vcpu, exit_qualification, vmx_instruction_info, &gva)) return 1; if (kvm_read_guest_virt(&vcpu->arch.emulate_ctxt, gva, &field_value, (is_64_bit_mode(vcpu) ? 8 : 4), &e)) { kvm_inject_page_fault(vcpu, &e); return 1; } } field = kvm_register_readl(vcpu, (((vmx_instruction_info) >> 28) & 0xf)); if (vmcs_field_readonly(field)) { nested_vmx_failValid(vcpu, VMXERR_VMWRITE_READ_ONLY_VMCS_COMPONENT); skip_emulated_instruction(vcpu); return 1; } if (!vmcs12_write_any(vcpu, field, field_value)) { nested_vmx_failValid(vcpu, VMXERR_UNSUPPORTED_VMCS_COMPONENT); skip_emulated_instruction(vcpu); return 1; } nested_vmx_succeed(vcpu); skip_emulated_instruction(vcpu); return 1; } / Emulate the VMPTRLD instruction / static int handle_vmptrld(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); gpa_t vmptr; u32 exec_control; if (!nested_vmx_check_permission(vcpu)) return 1; if (nested_vmx_check_vmptr(vcpu, EXIT_REASON_VMPTRLD, &vmptr)) return 1; if (vmx->nested.current_vmptr != vmptr) { struct vmcs12 new_vmcs12; struct page page; page = nested_get_page(vcpu, vmptr); if (page == NULL) { nested_vmx_failInvalid(vcpu); skip_emulated_instruction(vcpu); return 1; } new_vmcs12 = kmap(page); if (new_vmcs12->revision_id != VMCS12_REVISION) { kunmap(page); nested_release_page_clean(page); nested_vmx_failValid(vcpu, VMXERR_VMPTRLD_INCORRECT_VMCS_REVISION_ID); skip_emulated_instruction(vcpu); return 1; } nested_release_vmcs12(vmx); vmx->nested.current_vmptr = vmptr; vmx->nested.current_vmcs12 = new_vmcs12; vmx->nested.current_vmcs12_page = page; if (enable_shadow_vmcs) { exec_control = vmcs_read32(SECONDARY_VM_EXEC_CONTROL); exec_control \|= SECONDARY_EXEC_SHADOW_VMCS; vmcs_write32(SECONDARY_VM_EXEC_CONTROL, exec_control); vmcs_write64(VMCS_LINK_POINTER, __pa(vmx->nested.current_shadow_vmcs)); vmx->nested.sync_shadow_vmcs = true; } } nested_vmx_succeed(vcpu); skip_emulated_instruction(vcpu); return 1; } / Emulate the VMPTRST instruction / static int handle_vmptrst(struct kvm_vcpu vcpu) { unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION); u32 vmx_instruction_info = vmcs_read32(VMX_INSTRUCTION_INFO); gva_t vmcs_gva; struct x86_exception e; if (!nested_vmx_check_permission(vcpu)) return 1; if (get_vmx_mem_address(vcpu, exit_qualification, vmx_instruction_info, &vmcs_gva)) return 1; /* ok to use _system, as nested_vmx_check_permission verified cpl=0 / if (kvm_write_guest_virt_system(&vcpu->arch.emulate_ctxt, vmcs_gva, (void )&to_vmx(vcpu)->nested.current_vmptr, sizeof(u64), &e)) { kvm_inject_page_fault(vcpu, &e); return 1; } nested_vmx_succeed(vcpu); skip_emulated_instruction(vcpu); return 1; } / Emulate the INVEPT instruction / static int handle_invept(struct kvm_vcpu vcpu) { u32 vmx_instruction_info, types; unsigned long type; gva_t gva; struct x86_exception e; struct { u64 eptp, gpa; } operand; if (!(nested_vmx_secondary_ctls_high & SECONDARY_EXEC_ENABLE_EPT) \|\| !(nested_vmx_ept_caps & VMX_EPT_INVEPT_BIT)) { kvm_queue_exception(vcpu, UD_VECTOR); return 1; } if (!nested_vmx_check_permission(vcpu)) return 1; if (!kvm_read_cr0_bits(vcpu, X86_CR0_PE)) { kvm_queue_exception(vcpu, UD_VECTOR); return 1; } vmx_instruction_info = vmcs_read32(VMX_INSTRUCTION_INFO); type = kvm_register_readl(vcpu, (vmx_instruction_info >> 28) & 0xf); types = (nested_vmx_ept_caps >> VMX_EPT_EXTENT_SHIFT) & 6; if (!(types & (1UL << type))) { nested_vmx_failValid(vcpu, VMXERR_INVALID_OPERAND_TO_INVEPT_INVVPID); return 1; } /* According to the Intel VMX instruction reference, the memory * operand is read even if it isn't needed (e.g., for type==global) / if (get_vmx_mem_address(vcpu, vmcs_readl(EXIT_QUALIFICATION), vmx_instruction_info, &gva)) return 1; if (kvm_read_guest_virt(&vcpu->arch.emulate_ctxt, gva, &operand, sizeof(operand), &e)) { kvm_inject_page_fault(vcpu, &e); return 1; } switch (type) { case VMX_EPT_EXTENT_GLOBAL: kvm_mmu_sync_roots(vcpu); kvm_make_request(KVM_REQ_TLB_FLUSH, vcpu); nested_vmx_succeed(vcpu); break; default: / Trap single context invalidation invept calls / BUG_ON(1); break; } skip_emulated_instruction(vcpu); return 1; } / * The exit handlers return 1 if the exit was handled fully and guest execution * may resume. Otherwise they set the kvm_run parameter to indicate what needs * to be done to userspace and return 0. / static int (const kvm_vmx_exit_handlers[])(struct kvm_vcpu vcpu) = { [EXIT_REASON_EXCEPTION_NMI] = handle_exception, [EXIT_REASON_EXTERNAL_INTERRUPT] = handle_external_interrupt, [EXIT_REASON_TRIPLE_FAULT] = handle_triple_fault, [EXIT_REASON_NMI_WINDOW] = handle_nmi_window, [EXIT_REASON_IO_INSTRUCTION] = handle_io, [EXIT_REASON_CR_ACCESS] = handle_cr, [EXIT_REASON_DR_ACCESS] = handle_dr, [EXIT_REASON_CPUID] = handle_cpuid, [EXIT_REASON_MSR_READ] = handle_rdmsr, [EXIT_REASON_MSR_WRITE] = handle_wrmsr, [EXIT_REASON_PENDING_INTERRUPT] = handle_interrupt_window, [EXIT_REASON_HLT] = handle_halt, [EXIT_REASON_INVD] = handle_invd, [EXIT_REASON_INVLPG] = handle_invlpg, [EXIT_REASON_RDPMC] = handle_rdpmc, [EXIT_REASON_VMCALL] = handle_vmcall, [EXIT_REASON_VMCLEAR] = handle_vmclear, [EXIT_REASON_VMLAUNCH] = handle_vmlaunch, [EXIT_REASON_VMPTRLD] = handle_vmptrld, [EXIT_REASON_VMPTRST] = handle_vmptrst, [EXIT_REASON_VMREAD] = handle_vmread, [EXIT_REASON_VMRESUME] = handle_vmresume, [EXIT_REASON_VMWRITE] = handle_vmwrite, [EXIT_REASON_VMOFF] = handle_vmoff, [EXIT_REASON_VMON] = handle_vmon, [EXIT_REASON_TPR_BELOW_THRESHOLD] = handle_tpr_below_threshold, [EXIT_REASON_APIC_ACCESS] = handle_apic_access, [EXIT_REASON_APIC_WRITE] = handle_apic_write, [EXIT_REASON_EOI_INDUCED] = handle_apic_eoi_induced, [EXIT_REASON_WBINVD] = handle_wbinvd, [EXIT_REASON_XSETBV] = handle_xsetbv, [EXIT_REASON_TASK_SWITCH] = handle_task_switch, [EXIT_REASON_MCE_DURING_VMENTRY] = handle_machine_check, [EXIT_REASON_EPT_VIOLATION] = handle_ept_violation, [EXIT_REASON_EPT_MISCONFIG] = handle_ept_misconfig, [EXIT_REASON_PAUSE_INSTRUCTION] = handle_pause, [EXIT_REASON_MWAIT_INSTRUCTION] = handle_mwait, [EXIT_REASON_MONITOR_INSTRUCTION] = handle_monitor, [EXIT_REASON_INVEPT] = handle_invept, }; static const int kvm_vmx_max_exit_handlers = ARRAY_SIZE(kvm_vmx_exit_handlers); static bool nested_vmx_exit_handled_io(struct kvm_vcpu vcpu, struct vmcs12 vmcs12) { unsigned long exit_qualification; gpa_t bitmap, last_bitmap; unsigned int port; int size; u8 b; if (!nested_cpu_has(vmcs12, CPU_BASED_USE_IO_BITMAPS)) return nested_cpu_has(vmcs12, CPU_BASED_UNCOND_IO_EXITING); exit_qualification = vmcs_readl(EXIT_QUALIFICATION); port = exit_qualification >> 16; size = (exit_qualification & 7) + 1; last_bitmap = (gpa_t)-1; b = -1; while (size > 0) { if (port < 0x8000) bitmap = vmcs12->io_bitmap_a; else if (port < 0x10000) bitmap = vmcs12->io_bitmap_b; else return 1; bitmap += (port & 0x7fff) / 8; if (last_bitmap != bitmap) if (kvm_read_guest(vcpu->kvm, bitmap, &b, 1)) return 1; if (b & (1 << (port & 7))) return 1; port++; size--; last_bitmap = bitmap; } return 0; } / * Return 1 if we should exit from L2 to L1 to handle an MSR access access, * rather than handle it ourselves in L0. I.e., check whether L1 expressed * disinterest in the current event (read or write a specific MSR) by using an * MSR bitmap. This may be the case even when L0 doesn't use MSR bitmaps. / static bool nested_vmx_exit_handled_msr(struct kvm_vcpu vcpu, struct vmcs12 vmcs12, u32 exit_reason) { u32 msr_index = vcpu->arch.regs[VCPU_REGS_RCX]; gpa_t bitmap; if (!nested_cpu_has(vmcs12, CPU_BASED_USE_MSR_BITMAPS)) return 1; / * The MSR_BITMAP page is divided into four 1024-byte bitmaps, * for the four combinations of read/write and low/high MSR numbers. * First we need to figure out which of the four to use: / bitmap = vmcs12->msr_bitmap; if (exit_reason == EXIT_REASON_MSR_WRITE) bitmap += 2048; if (msr_index >= 0xc0000000) { msr_index -= 0xc0000000; bitmap += 1024; } / Then read the msr_index'th bit from this bitmap: / if (msr_index < 10248) { unsigned char b; if (kvm_read_guest(vcpu->kvm, bitmap + msr_index/8, &b, 1)) return 1; return 1 & (b >> (msr_index & 7)); } else return 1; /* let L1 handle the wrong parameter / } / * Return 1 if we should exit from L2 to L1 to handle a CR access exit, * rather than handle it ourselves in L0. I.e., check if L1 wanted to * intercept (via guest_host_mask etc.) the current event. / static bool nested_vmx_exit_handled_cr(struct kvm_vcpu vcpu, struct vmcs12 vmcs12) { unsigned long exit_qualification = vmcs_readl(EXIT_QUALIFICATION); int cr = exit_qualification & 15; int reg = (exit_qualification >> 8) & 15; unsigned long val = kvm_register_readl(vcpu, reg); switch ((exit_qualification >> 4) & 3) { case 0: / mov to cr / switch (cr) { case 0: if (vmcs12->cr0_guest_host_mask & (val ^ vmcs12->cr0_read_shadow)) return 1; break; case 3: if ((vmcs12->cr3_target_count >= 1 && vmcs12->cr3_target_value0 == val) \|\| (vmcs12->cr3_target_count >= 2 && vmcs12->cr3_target_value1 == val) \|\| (vmcs12->cr3_target_count >= 3 && vmcs12->cr3_target_value2 == val) \|\| (vmcs12->cr3_target_count >= 4 && vmcs12->cr3_target_value3 == val)) return 0; if (nested_cpu_has(vmcs12, CPU_BASED_CR3_LOAD_EXITING)) return 1; break; case 4: if (vmcs12->cr4_guest_host_mask & (vmcs12->cr4_read_shadow ^ val)) return 1; break; case 8: if (nested_cpu_has(vmcs12, CPU_BASED_CR8_LOAD_EXITING)) return 1; break; } break; case 2: / clts / if ((vmcs12->cr0_guest_host_mask & X86_CR0_TS) && (vmcs12->cr0_read_shadow & X86_CR0_TS)) return 1; break; case 1: / mov from cr / switch (cr) { case 3: if (vmcs12->cpu_based_vm_exec_control & CPU_BASED_CR3_STORE_EXITING) return 1; break; case 8: if (vmcs12->cpu_based_vm_exec_control & CPU_BASED_CR8_STORE_EXITING) return 1; break; } break; case 3: / lmsw / / * lmsw can change bits 1..3 of cr0, and only set bit 0 of * cr0. Other attempted changes are ignored, with no exit. / if (vmcs12->cr0_guest_host_mask & 0xe & (val ^ vmcs12->cr0_read_shadow)) return 1; if ((vmcs12->cr0_guest_host_mask & 0x1) && !(vmcs12->cr0_read_shadow & 0x1) && (val & 0x1)) return 1; break; } return 0; } / * Return 1 if we should exit from L2 to L1 to handle an exit, or 0 if we * should handle it ourselves in L0 (and then continue L2). Only call this * when in is_guest_mode (L2). / static bool nested_vmx_exit_handled(struct kvm_vcpu vcpu) { u32 intr_info = vmcs_read32(VM_EXIT_INTR_INFO); struct vcpu_vmx vmx = to_vmx(vcpu); struct vmcs12 vmcs12 = get_vmcs12(vcpu); u32 exit_reason = vmx->exit_reason; trace_kvm_nested_vmexit(kvm_rip_read(vcpu), exit_reason, vmcs_readl(EXIT_QUALIFICATION), vmx->idt_vectoring_info, intr_info, vmcs_read32(VM_EXIT_INTR_ERROR_CODE), KVM_ISA_VMX); if (vmx->nested.nested_run_pending) return 0; if (unlikely(vmx->fail)) { pr_info_ratelimited("%s failed vm entry %x\n", __func__, vmcs_read32(VM_INSTRUCTION_ERROR)); return 1; } switch (exit_reason) { case EXIT_REASON_EXCEPTION_NMI: if (!is_exception(intr_info)) return 0; else if (is_page_fault(intr_info)) return enable_ept; else if (is_no_device(intr_info) && !(vmcs12->guest_cr0 & X86_CR0_TS)) return 0; return vmcs12->exception_bitmap & (1u << (intr_info & INTR_INFO_VECTOR_MASK)); case EXIT_REASON_EXTERNAL_INTERRUPT: return 0; case EXIT_REASON_TRIPLE_FAULT: return 1; case EXIT_REASON_PENDING_INTERRUPT: return nested_cpu_has(vmcs12, CPU_BASED_VIRTUAL_INTR_PENDING); case EXIT_REASON_NMI_WINDOW: return nested_cpu_has(vmcs12, CPU_BASED_VIRTUAL_NMI_PENDING); case EXIT_REASON_TASK_SWITCH: return 1; case EXIT_REASON_CPUID: if (kvm_register_read(vcpu, VCPU_REGS_RAX) == 0xa) return 0; return 1; case EXIT_REASON_HLT: return nested_cpu_has(vmcs12, CPU_BASED_HLT_EXITING); case EXIT_REASON_INVD: return 1; case EXIT_REASON_INVLPG: return nested_cpu_has(vmcs12, CPU_BASED_INVLPG_EXITING); case EXIT_REASON_RDPMC: return nested_cpu_has(vmcs12, CPU_BASED_RDPMC_EXITING); case EXIT_REASON_RDTSC: return nested_cpu_has(vmcs12, CPU_BASED_RDTSC_EXITING); case EXIT_REASON_VMCALL: case EXIT_REASON_VMCLEAR: case EXIT_REASON_VMLAUNCH: case EXIT_REASON_VMPTRLD: case EXIT_REASON_VMPTRST: case EXIT_REASON_VMREAD: case EXIT_REASON_VMRESUME: case EXIT_REASON_VMWRITE: case EXIT_REASON_VMOFF: case EXIT_REASON_VMON: case EXIT_REASON_INVEPT: /* * VMX instructions trap unconditionally. This allows L1 to * emulate them for its L2 guest, i.e., allows 3-level nesting! / return 1; case EXIT_REASON_CR_ACCESS: return nested_vmx_exit_handled_cr(vcpu, vmcs12); case EXIT_REASON_DR_ACCESS: return nested_cpu_has(vmcs12, CPU_BASED_MOV_DR_EXITING); case EXIT_REASON_IO_INSTRUCTION: return nested_vmx_exit_handled_io(vcpu, vmcs12); case EXIT_REASON_MSR_READ: case EXIT_REASON_MSR_WRITE: return nested_vmx_exit_handled_msr(vcpu, vmcs12, exit_reason); case EXIT_REASON_INVALID_STATE: return 1; case EXIT_REASON_MWAIT_INSTRUCTION: return nested_cpu_has(vmcs12, CPU_BASED_MWAIT_EXITING); case EXIT_REASON_MONITOR_INSTRUCTION: return nested_cpu_has(vmcs12, CPU_BASED_MONITOR_EXITING); case EXIT_REASON_PAUSE_INSTRUCTION: return nested_cpu_has(vmcs12, CPU_BASED_PAUSE_EXITING) \|\| nested_cpu_has2(vmcs12, SECONDARY_EXEC_PAUSE_LOOP_EXITING); case EXIT_REASON_MCE_DURING_VMENTRY: return 0; case EXIT_REASON_TPR_BELOW_THRESHOLD: return nested_cpu_has(vmcs12, CPU_BASED_TPR_SHADOW); case EXIT_REASON_APIC_ACCESS: return nested_cpu_has2(vmcs12, SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES); case EXIT_REASON_EPT_VIOLATION: / * L0 always deals with the EPT violation. If nested EPT is * used, and the nested mmu code discovers that the address is * missing in the guest EPT table (EPT12), the EPT violation * will be injected with nested_ept_inject_page_fault() / return 0; case EXIT_REASON_EPT_MISCONFIG: / * L2 never uses directly L1's EPT, but rather L0's own EPT * table (shadow on EPT) or a merged EPT table that L0 built * (EPT on EPT). So any problems with the structure of the * table is L0's fault. / return 0; case EXIT_REASON_WBINVD: return nested_cpu_has2(vmcs12, SECONDARY_EXEC_WBINVD_EXITING); case EXIT_REASON_XSETBV: return 1; default: return 1; } } static void vmx_get_exit_info(struct kvm_vcpu vcpu, u64 info1, u64 info2) { info1 = vmcs_readl(EXIT_QUALIFICATION); info2 = vmcs_read32(VM_EXIT_INTR_INFO); } /* * The guest has exited. See if we can fix it or if we need userspace * assistance. / static int vmx_handle_exit(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); u32 exit_reason = vmx->exit_reason; u32 vectoring_info = vmx->idt_vectoring_info; / If guest state is invalid, start emulating / if (vmx->emulation_required) return handle_invalid_guest_state(vcpu); if (is_guest_mode(vcpu) && nested_vmx_exit_handled(vcpu)) { nested_vmx_vmexit(vcpu, exit_reason, vmcs_read32(VM_EXIT_INTR_INFO), vmcs_readl(EXIT_QUALIFICATION)); return 1; } if (exit_reason & VMX_EXIT_REASONS_FAILED_VMENTRY) { vcpu->run->exit_reason = KVM_EXIT_FAIL_ENTRY; vcpu->run->fail_entry.hardware_entry_failure_reason = exit_reason; return 0; } if (unlikely(vmx->fail)) { vcpu->run->exit_reason = KVM_EXIT_FAIL_ENTRY; vcpu->run->fail_entry.hardware_entry_failure_reason = vmcs_read32(VM_INSTRUCTION_ERROR); return 0; } / * Note: * Do not try to fix EXIT_REASON_EPT_MISCONFIG if it caused by * delivery event since it indicates guest is accessing MMIO. * The vm-exit can be triggered again after return to guest that * will cause infinite loop. / if ((vectoring_info & VECTORING_INFO_VALID_MASK) && (exit_reason != EXIT_REASON_EXCEPTION_NMI && exit_reason != EXIT_REASON_EPT_VIOLATION && exit_reason != EXIT_REASON_TASK_SWITCH)) { vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR; vcpu->run->internal.suberror = KVM_INTERNAL_ERROR_DELIVERY_EV; vcpu->run->internal.ndata = 2; vcpu->run->internal.data[0] = vectoring_info; vcpu->run->internal.data[1] = exit_reason; return 0; } if (unlikely(!cpu_has_virtual_nmis() && vmx->soft_vnmi_blocked && !(is_guest_mode(vcpu) && nested_cpu_has_virtual_nmis( get_vmcs12(vcpu))))) { if (vmx_interrupt_allowed(vcpu)) { vmx->soft_vnmi_blocked = 0; } else if (vmx->vnmi_blocked_time > 1000000000LL && vcpu->arch.nmi_pending) { / * This CPU don't support us in finding the end of an * NMI-blocked window if the guest runs with IRQs * disabled. So we pull the trigger after 1 s of * futile waiting, but inform the user about this. / printk(KERN_WARNING "%s: Breaking out of NMI-blocked " "state on VCPU %d after 1 s timeout\n", __func__, vcpu->vcpu_id); vmx->soft_vnmi_blocked = 0; } } if (exit_reason < kvm_vmx_max_exit_handlers && kvm_vmx_exit_handlers[exit_reason]) return kvm_vmx_exit_handlers[exit_reason](vcpu); else { vcpu->run->exit_reason = KVM_EXIT_UNKNOWN; vcpu->run->hw.hardware_exit_reason = exit_reason; } return 0; } static void update_cr8_intercept(struct kvm_vcpu vcpu, int tpr, int irr) { struct vmcs12 vmcs12 = get_vmcs12(vcpu); if (is_guest_mode(vcpu) && nested_cpu_has(vmcs12, CPU_BASED_TPR_SHADOW)) return; if (irr == -1 \|\| tpr < irr) { vmcs_write32(TPR_THRESHOLD, 0); return; } vmcs_write32(TPR_THRESHOLD, irr); } static void vmx_set_virtual_x2apic_mode(struct kvm_vcpu vcpu, bool set) { u32 sec_exec_control; /* * There is not point to enable virtualize x2apic without enable * apicv / if (!cpu_has_vmx_virtualize_x2apic_mode() \|\| !vmx_vm_has_apicv(vcpu->kvm)) return; if (!vm_need_tpr_shadow(vcpu->kvm)) return; sec_exec_control = vmcs_read32(SECONDARY_VM_EXEC_CONTROL); if (set) { sec_exec_control &= ~SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES; sec_exec_control \|= SECONDARY_EXEC_VIRTUALIZE_X2APIC_MODE; } else { sec_exec_control &= ~SECONDARY_EXEC_VIRTUALIZE_X2APIC_MODE; sec_exec_control \|= SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES; } vmcs_write32(SECONDARY_VM_EXEC_CONTROL, sec_exec_control); vmx_set_msr_bitmap(vcpu); } static void vmx_set_apic_access_page_addr(struct kvm_vcpu vcpu, hpa_t hpa) { struct vcpu_vmx vmx = to_vmx(vcpu); / * Currently we do not handle the nested case where L2 has an * APIC access page of its own; that page is still pinned. * Hence, we skip the case where the VCPU is in guest mode _and_ * L1 prepared an APIC access page for L2. * * For the case where L1 and L2 share the same APIC access page * (flexpriority=Y but SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES clear * in the vmcs12), this function will only update either the vmcs01 * or the vmcs02. If the former, the vmcs02 will be updated by * prepare_vmcs02. If the latter, the vmcs01 will be updated in * the next L2->L1 exit. / if (!is_guest_mode(vcpu) \|\| !nested_cpu_has2(vmx->nested.current_vmcs12, SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES)) vmcs_write64(APIC_ACCESS_ADDR, hpa); } static void vmx_hwapic_isr_update(struct kvm kvm, int isr) { u16 status; u8 old; if (!vmx_vm_has_apicv(kvm)) return; if (isr == -1) isr = 0; status = vmcs_read16(GUEST_INTR_STATUS); old = status >> 8; if (isr != old) { status &= 0xff; status \|= isr << 8; vmcs_write16(GUEST_INTR_STATUS, status); } } static void vmx_set_rvi(int vector) { u16 status; u8 old; status = vmcs_read16(GUEST_INTR_STATUS); old = (u8)status & 0xff; if ((u8)vector != old) { status &= ~0xff; status \|= (u8)vector; vmcs_write16(GUEST_INTR_STATUS, status); } } static void vmx_hwapic_irr_update(struct kvm_vcpu vcpu, int max_irr) { if (max_irr == -1) return; / * If a vmexit is needed, vmx_check_nested_events handles it. / if (is_guest_mode(vcpu) && nested_exit_on_intr(vcpu)) return; if (!is_guest_mode(vcpu)) { vmx_set_rvi(max_irr); return; } / * Fall back to pre-APICv interrupt injection since L2 * is run without virtual interrupt delivery. / if (!kvm_event_needs_reinjection(vcpu) && vmx_interrupt_allowed(vcpu)) { kvm_queue_interrupt(vcpu, max_irr, false); vmx_inject_irq(vcpu); } } static void vmx_load_eoi_exitmap(struct kvm_vcpu vcpu, u64 eoi_exit_bitmap) { if (!vmx_vm_has_apicv(vcpu->kvm)) return; vmcs_write64(EOI_EXIT_BITMAP0, eoi_exit_bitmap[0]); vmcs_write64(EOI_EXIT_BITMAP1, eoi_exit_bitmap[1]); vmcs_write64(EOI_EXIT_BITMAP2, eoi_exit_bitmap[2]); vmcs_write64(EOI_EXIT_BITMAP3, eoi_exit_bitmap[3]); } static void vmx_complete_atomic_exit(struct vcpu_vmx vmx) { u32 exit_intr_info; if (!(vmx->exit_reason == EXIT_REASON_MCE_DURING_VMENTRY \|\| vmx->exit_reason == EXIT_REASON_EXCEPTION_NMI)) return; vmx->exit_intr_info = vmcs_read32(VM_EXIT_INTR_INFO); exit_intr_info = vmx->exit_intr_info; /* Handle machine checks before interrupts are enabled / if (is_machine_check(exit_intr_info)) kvm_machine_check(); / We need to handle NMIs before interrupts are enabled / if ((exit_intr_info & INTR_INFO_INTR_TYPE_MASK) == INTR_TYPE_NMI_INTR && (exit_intr_info & INTR_INFO_VALID_MASK)) { kvm_before_handle_nmi(&vmx->vcpu); asm("int $2"); kvm_after_handle_nmi(&vmx->vcpu); } } static void vmx_handle_external_intr(struct kvm_vcpu vcpu) { u32 exit_intr_info = vmcs_read32(VM_EXIT_INTR_INFO); /* * If external interrupt exists, IF bit is set in rflags/eflags on the * interrupt stack frame, and interrupt will be enabled on a return * from interrupt handler. / if ((exit_intr_info & (INTR_INFO_VALID_MASK \| INTR_INFO_INTR_TYPE_MASK)) == (INTR_INFO_VALID_MASK \| INTR_TYPE_EXT_INTR)) { unsigned int vector; unsigned long entry; gate_desc desc; struct vcpu_vmx vmx = to_vmx(vcpu); #ifdef CONFIG_X86_64 unsigned long tmp; #endif vector = exit_intr_info & INTR_INFO_VECTOR_MASK; desc = (gate_desc )vmx->host_idt_base + vector; entry = gate_offset(desc); asm volatile( #ifdef CONFIG_X86_64 "mov %%" _ASM_SP ", %[sp]\n\t" "and $0xfffffffffffffff0, %%" _ASM_SP "\n\t" "push $%c[ss]\n\t" "push %[sp]\n\t" #endif "pushf\n\t" "orl $0x200, (%%" _ASM_SP ")\n\t" __ASM_SIZE(push) " $%c[cs]\n\t" "call %[entry]\n\t" : #ifdef CONFIG_X86_64 [sp]"=&r"(tmp) #endif : [entry]"r"(entry), [ss]"i"(__KERNEL_DS), [cs]"i"(__KERNEL_CS) ); } else local_irq_enable(); } static bool vmx_mpx_supported(void) { return (vmcs_config.vmexit_ctrl & VM_EXIT_CLEAR_BNDCFGS) && (vmcs_config.vmentry_ctrl & VM_ENTRY_LOAD_BNDCFGS); } static void vmx_recover_nmi_blocking(struct vcpu_vmx vmx) { u32 exit_intr_info; bool unblock_nmi; u8 vector; bool idtv_info_valid; idtv_info_valid = vmx->idt_vectoring_info & VECTORING_INFO_VALID_MASK; if (cpu_has_virtual_nmis()) { if (vmx->nmi_known_unmasked) return; / * Can't use vmx->exit_intr_info since we're not sure what * the exit reason is. / exit_intr_info = vmcs_read32(VM_EXIT_INTR_INFO); unblock_nmi = (exit_intr_info & INTR_INFO_UNBLOCK_NMI) != 0; vector = exit_intr_info & INTR_INFO_VECTOR_MASK; / * SDM 3: 27.7.1.2 (September 2008) * Re-set bit "block by NMI" before VM entry if vmexit caused by * a guest IRET fault. * SDM 3: 23.2.2 (September 2008) * Bit 12 is undefined in any of the following cases: * If the VM exit sets the valid bit in the IDT-vectoring * information field. * If the VM exit is due to a double fault. / if ((exit_intr_info & INTR_INFO_VALID_MASK) && unblock_nmi && vector != DF_VECTOR && !idtv_info_valid) vmcs_set_bits(GUEST_INTERRUPTIBILITY_INFO, GUEST_INTR_STATE_NMI); else vmx->nmi_known_unmasked = !(vmcs_read32(GUEST_INTERRUPTIBILITY_INFO) & GUEST_INTR_STATE_NMI); } else if (unlikely(vmx->soft_vnmi_blocked)) vmx->vnmi_blocked_time += ktime_to_ns(ktime_sub(ktime_get(), vmx->entry_time)); } static void __vmx_complete_interrupts(struct kvm_vcpu vcpu, u32 idt_vectoring_info, int instr_len_field, int error_code_field) { u8 vector; int type; bool idtv_info_valid; idtv_info_valid = idt_vectoring_info & VECTORING_INFO_VALID_MASK; vcpu->arch.nmi_injected = false; kvm_clear_exception_queue(vcpu); kvm_clear_interrupt_queue(vcpu); if (!idtv_info_valid) return; kvm_make_request(KVM_REQ_EVENT, vcpu); vector = idt_vectoring_info & VECTORING_INFO_VECTOR_MASK; type = idt_vectoring_info & VECTORING_INFO_TYPE_MASK; switch (type) { case INTR_TYPE_NMI_INTR: vcpu->arch.nmi_injected = true; /* * SDM 3: 27.7.1.2 (September 2008) * Clear bit "block by NMI" before VM entry if a NMI * delivery faulted. / vmx_set_nmi_mask(vcpu, false); break; case INTR_TYPE_SOFT_EXCEPTION: vcpu->arch.event_exit_inst_len = vmcs_read32(instr_len_field); / fall through / case INTR_TYPE_HARD_EXCEPTION: if (idt_vectoring_info & VECTORING_INFO_DELIVER_CODE_MASK) { u32 err = vmcs_read32(error_code_field); kvm_requeue_exception_e(vcpu, vector, err); } else kvm_requeue_exception(vcpu, vector); break; case INTR_TYPE_SOFT_INTR: vcpu->arch.event_exit_inst_len = vmcs_read32(instr_len_field); / fall through / case INTR_TYPE_EXT_INTR: kvm_queue_interrupt(vcpu, vector, type == INTR_TYPE_SOFT_INTR); break; default: break; } } static void vmx_complete_interrupts(struct vcpu_vmx vmx) { __vmx_complete_interrupts(&vmx->vcpu, vmx->idt_vectoring_info, VM_EXIT_INSTRUCTION_LEN, IDT_VECTORING_ERROR_CODE); } static void vmx_cancel_injection(struct kvm_vcpu vcpu) { __vmx_complete_interrupts(vcpu, vmcs_read32(VM_ENTRY_INTR_INFO_FIELD), VM_ENTRY_INSTRUCTION_LEN, VM_ENTRY_EXCEPTION_ERROR_CODE); vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, 0); } static void atomic_switch_perf_msrs(struct vcpu_vmx vmx) { int i, nr_msrs; struct perf_guest_switch_msr msrs; msrs = perf_guest_get_msrs(&nr_msrs); if (!msrs) return; for (i = 0; i < nr_msrs; i++) if (msrs[i].host == msrs[i].guest) clear_atomic_switch_msr(vmx, msrs[i].msr); else add_atomic_switch_msr(vmx, msrs[i].msr, msrs[i].guest, msrs[i].host); } static void __noclone vmx_vcpu_run(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); unsigned long debugctlmsr, cr4; / Record the guest's net vcpu time for enforced NMI injections. / if (unlikely(!cpu_has_virtual_nmis() && vmx->soft_vnmi_blocked)) vmx->entry_time = ktime_get(); / Don't enter VMX if guest state is invalid, let the exit handler start emulation until we arrive back to a valid state / if (vmx->emulation_required) return; if (vmx->ple_window_dirty) { vmx->ple_window_dirty = false; vmcs_write32(PLE_WINDOW, vmx->ple_window); } if (vmx->nested.sync_shadow_vmcs) { copy_vmcs12_to_shadow(vmx); vmx->nested.sync_shadow_vmcs = false; } if (test_bit(VCPU_REGS_RSP, (unsigned long )&vcpu->arch.regs_dirty)) vmcs_writel(GUEST_RSP, vcpu->arch.regs[VCPU_REGS_RSP]); if (test_bit(VCPU_REGS_RIP, (unsigned long )&vcpu->arch.regs_dirty)) vmcs_writel(GUEST_RIP, vcpu->arch.regs[VCPU_REGS_RIP]); cr4 = read_cr4(); if (unlikely(cr4 != vmx->host_state.vmcs_host_cr4)) { vmcs_writel(HOST_CR4, cr4); vmx->host_state.vmcs_host_cr4 = cr4; } / When single-stepping over STI and MOV SS, we must clear the * corresponding interruptibility bits in the guest state. Otherwise * vmentry fails as it then expects bit 14 (BS) in pending debug * exceptions being set, but that's not correct for the guest debugging * case. / if (vcpu->guest_debug & KVM_GUESTDBG_SINGLESTEP) vmx_set_interrupt_shadow(vcpu, 0); atomic_switch_perf_msrs(vmx); debugctlmsr = get_debugctlmsr(); vmx->__launched = vmx->loaded_vmcs->launched; asm( / Store host registers / "push %%" _ASM_DX "; push %%" _ASM_BP ";" "push %%" _ASM_CX " \n\t" / placeholder for guest rcx / "push %%" _ASM_CX " \n\t" "cmp %%" _ASM_SP ", %c[host_rsp](%0) \n\t" "je 1f \n\t" "mov %%" _ASM_SP ", %c[host_rsp](%0) \n\t" __ex(ASM_VMX_VMWRITE_RSP_RDX) "\n\t" "1: \n\t" / Reload cr2 if changed / "mov %c[cr2](%0), %%" _ASM_AX " \n\t" "mov %%cr2, %%" _ASM_DX " \n\t" "cmp %%" _ASM_AX ", %%" _ASM_DX " \n\t" "je 2f \n\t" "mov %%" _ASM_AX", %%cr2 \n\t" "2: \n\t" / Check if vmlaunch of vmresume is needed / "cmpl $0, %c[launched](%0) \n\t" / Load guest registers. Don't clobber flags. / "mov %c[rax](%0), %%" _ASM_AX " \n\t" "mov %c[rbx](%0), %%" _ASM_BX " \n\t" "mov %c[rdx](%0), %%" _ASM_DX " \n\t" "mov %c[rsi](%0), %%" _ASM_SI " \n\t" "mov %c[rdi](%0), %%" _ASM_DI " \n\t" "mov %c[rbp](%0), %%" _ASM_BP " \n\t" #ifdef CONFIG_X86_64 "mov %c[r8](%0), %%r8 \n\t" "mov %c[r9](%0), %%r9 \n\t" "mov %c[r10](%0), %%r10 \n\t" "mov %c[r11](%0), %%r11 \n\t" "mov %c[r12](%0), %%r12 \n\t" "mov %c[r13](%0), %%r13 \n\t" "mov %c[r14](%0), %%r14 \n\t" "mov %c[r15](%0), %%r15 \n\t" #endif "mov %c[rcx](%0), %%" _ASM_CX " \n\t" / kills %0 (ecx) / / Enter guest mode / "jne 1f \n\t" __ex(ASM_VMX_VMLAUNCH) "\n\t" "jmp 2f \n\t" "1: " __ex(ASM_VMX_VMRESUME) "\n\t" "2: " / Save guest registers, load host registers, keep flags / "mov %0, %c[wordsize](%%" _ASM_SP ") \n\t" "pop %0 \n\t" "mov %%" _ASM_AX ", %c[rax](%0) \n\t" "mov %%" _ASM_BX ", %c[rbx](%0) \n\t" __ASM_SIZE(pop) " %c[rcx](%0) \n\t" "mov %%" _ASM_DX ", %c[rdx](%0) \n\t" "mov %%" _ASM_SI ", %c[rsi](%0) \n\t" "mov %%" _ASM_DI ", %c[rdi](%0) \n\t" "mov %%" _ASM_BP ", %c[rbp](%0) \n\t" #ifdef CONFIG_X86_64 "mov %%r8, %c[r8](%0) \n\t" "mov %%r9, %c[r9](%0) \n\t" "mov %%r10, %c[r10](%0) \n\t" "mov %%r11, %c[r11](%0) \n\t" "mov %%r12, %c[r12](%0) \n\t" "mov %%r13, %c[r13](%0) \n\t" "mov %%r14, %c[r14](%0) \n\t" "mov %%r15, %c[r15](%0) \n\t" #endif "mov %%cr2, %%" _ASM_AX " \n\t" "mov %%" _ASM_AX ", %c[cr2](%0) \n\t" "pop %%" _ASM_BP "; pop %%" _ASM_DX " \n\t" "setbe %c[fail](%0) \n\t" ".pushsection .rodata \n\t" ".global vmx_return \n\t" "vmx_return: " _ASM_PTR " 2b \n\t" ".popsection" : : "c"(vmx), "d"((unsigned long)HOST_RSP), [launched]"i"(offsetof(struct vcpu_vmx, __launched)), [fail]"i"(offsetof(struct vcpu_vmx, fail)), [host_rsp]"i"(offsetof(struct vcpu_vmx, host_rsp)), [rax]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RAX])), [rbx]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RBX])), [rcx]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RCX])), [rdx]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RDX])), [rsi]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RSI])), [rdi]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RDI])), [rbp]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_RBP])), #ifdef CONFIG_X86_64 [r8]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R8])), [r9]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R9])), [r10]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R10])), [r11]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R11])), [r12]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R12])), [r13]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R13])), [r14]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R14])), [r15]"i"(offsetof(struct vcpu_vmx, vcpu.arch.regs[VCPU_REGS_R15])), #endif [cr2]"i"(offsetof(struct vcpu_vmx, vcpu.arch.cr2)), [wordsize]"i"(sizeof(ulong)) : "cc", "memory" #ifdef CONFIG_X86_64 , "rax", "rbx", "rdi", "rsi" , "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15" #else , "eax", "ebx", "edi", "esi" #endif ); / MSR_IA32_DEBUGCTLMSR is zeroed on vmexit. Restore it if needed / if (debugctlmsr) update_debugctlmsr(debugctlmsr); #ifndef CONFIG_X86_64 / * The sysexit path does not restore ds/es, so we must set them to * a reasonable value ourselves. * * We can't defer this to vmx_load_host_state() since that function * may be executed in interrupt context, which saves and restore segments * around it, nullifying its effect. / loadsegment(ds, __USER_DS); loadsegment(es, __USER_DS); #endif vcpu->arch.regs_avail = ~((1 << VCPU_REGS_RIP) \| (1 << VCPU_REGS_RSP) \| (1 << VCPU_EXREG_RFLAGS) \| (1 << VCPU_EXREG_PDPTR) \| (1 << VCPU_EXREG_SEGMENTS) \| (1 << VCPU_EXREG_CR3)); vcpu->arch.regs_dirty = 0; vmx->idt_vectoring_info = vmcs_read32(IDT_VECTORING_INFO_FIELD); vmx->loaded_vmcs->launched = 1; vmx->exit_reason = vmcs_read32(VM_EXIT_REASON); trace_kvm_exit(vmx->exit_reason, vcpu, KVM_ISA_VMX); / * the KVM_REQ_EVENT optimization bit is only on for one entry, and if * we did not inject a still-pending event to L1 now because of * nested_run_pending, we need to re-enable this bit. / if (vmx->nested.nested_run_pending) kvm_make_request(KVM_REQ_EVENT, vcpu); vmx->nested.nested_run_pending = 0; vmx_complete_atomic_exit(vmx); vmx_recover_nmi_blocking(vmx); vmx_complete_interrupts(vmx); } static void vmx_load_vmcs01(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); int cpu; if (vmx->loaded_vmcs == &vmx->vmcs01) return; cpu = get_cpu(); vmx->loaded_vmcs = &vmx->vmcs01; vmx_vcpu_put(vcpu); vmx_vcpu_load(vcpu, cpu); vcpu->cpu = cpu; put_cpu(); } static void vmx_free_vcpu(struct kvm_vcpu vcpu) { struct vcpu_vmx vmx = to_vmx(vcpu); free_vpid(vmx); leave_guest_mode(vcpu); vmx_load_vmcs01(vcpu); free_nested(vmx); free_loaded_vmcs(vmx->loaded_vmcs); kfree(vmx->guest_msrs); kvm_vcpu_uninit(vcpu); kmem_cache_free(kvm_vcpu_cache, vmx); } static struct kvm_vcpu vmx_create_vcpu(struct kvm kvm, unsigned int id) { int err; struct vcpu_vmx vmx = kmem_cache_zalloc(kvm_vcpu_cache, GFP_KERNEL); int cpu; if (!vmx) return ERR_PTR(-ENOMEM); allocate_vpid(vmx); err = kvm_vcpu_init(&vmx->vcpu, kvm, id); if (err) goto free_vcpu; vmx->guest_msrs = kmalloc(PAGE_SIZE, GFP_KERNEL); BUILD_BUG_ON(ARRAY_SIZE(vmx_msr_index) * sizeof(vmx->guest_msrs[0]) > PAGE_SIZE); err = -ENOMEM; if (!vmx->guest_msrs) { goto uninit_vcpu; } vmx->loaded_vmcs = &vmx->vmcs01; vmx->loaded_vmcs->vmcs = alloc_vmcs(); if (!vmx->loaded_vmcs->vmcs) goto free_msrs; if (!vmm_exclusive) kvm_cpu_vmxon(__pa(per_cpu(vmxarea, raw_smp_processor_id()))); loaded_vmcs_init(vmx->loaded_vmcs); if (!vmm_exclusive) kvm_cpu_vmxoff(); cpu = get_cpu(); vmx_vcpu_load(&vmx->vcpu, cpu); vmx->vcpu.cpu = cpu; err = vmx_vcpu_setup(vmx); vmx_vcpu_put(&vmx->vcpu); put_cpu(); if (err) goto free_vmcs; if (vm_need_virtualize_apic_accesses(kvm)) { err = alloc_apic_access_page(kvm); if (err) goto free_vmcs; } if (enable_ept) { if (!kvm->arch.ept_identity_map_addr) kvm->arch.ept_identity_map_addr = VMX_EPT_IDENTITY_PAGETABLE_ADDR; err = init_rmode_identity_map(kvm); if (err) goto free_vmcs; } vmx->nested.current_vmptr = -1ull; vmx->nested.current_vmcs12 = NULL; return &vmx->vcpu; free_vmcs: free_loaded_vmcs(vmx->loaded_vmcs); free_msrs: kfree(vmx->guest_msrs); uninit_vcpu: kvm_vcpu_uninit(&vmx->vcpu); free_vcpu: free_vpid(vmx); kmem_cache_free(kvm_vcpu_cache, vmx); return ERR_PTR(err); } static void __init vmx_check_processor_compat(void rtn) { struct vmcs_config vmcs_conf; (int )rtn = 0; if (setup_vmcs_config(&vmcs_conf) < 0) (int )rtn = -EIO; if (memcmp(&vmcs_config, &vmcs_conf, sizeof(struct vmcs_config)) != 0) { printk(KERN_ERR "kvm: CPU %d feature inconsistency!\n", smp_processor_id()); (int )rtn = -EIO; } } static int get_ept_level(void) { return VMX_EPT_DEFAULT_GAW + 1; } static u64 vmx_get_mt_mask(struct kvm_vcpu vcpu, gfn_t gfn, bool is_mmio) { u64 ret; /* For VT-d and EPT combination * 1. MMIO: always map as UC * 2. EPT with VT-d: * a. VT-d without snooping control feature: can't guarantee the * result, try to trust guest. * b. VT-d with snooping control feature: snooping control feature of * VT-d engine can guarantee the cache correctness. Just set it * to WB to keep consistent with host. So the same as item 3. * 3. EPT without VT-d: always map as WB and set IPAT=1 to keep * consistent with host MTRR / if (is_mmio) ret = MTRR_TYPE_UNCACHABLE << VMX_EPT_MT_EPTE_SHIFT; else if (kvm_arch_has_noncoherent_dma(vcpu->kvm)) ret = kvm_get_guest_memory_type(vcpu, gfn) << VMX_EPT_MT_EPTE_SHIFT; else ret = (MTRR_TYPE_WRBACK << VMX_EPT_MT_EPTE_SHIFT) \| VMX_EPT_IPAT_BIT; return ret; } static int vmx_get_lpage_level(void) { if (enable_ept && !cpu_has_vmx_ept_1g_page()) return PT_DIRECTORY_LEVEL; else / For shadow and EPT supported 1GB page / return PT_PDPE_LEVEL; } static void vmx_cpuid_update(struct kvm_vcpu vcpu) { struct kvm_cpuid_entry2 best; struct vcpu_vmx vmx = to_vmx(vcpu); u32 exec_control; vmx->rdtscp_enabled = false; if (vmx_rdtscp_supported()) { exec_control = vmcs_read32(SECONDARY_VM_EXEC_CONTROL); if (exec_control & SECONDARY_EXEC_RDTSCP) { best = kvm_find_cpuid_entry(vcpu, 0x80000001, 0); if (best && (best->edx & bit(X86_FEATURE_RDTSCP))) vmx->rdtscp_enabled = true; else { exec_control &= ~SECONDARY_EXEC_RDTSCP; vmcs_write32(SECONDARY_VM_EXEC_CONTROL, exec_control); } } } /* Exposing INVPCID only when PCID is exposed / best = kvm_find_cpuid_entry(vcpu, 0x7, 0); if (vmx_invpcid_supported() && best && (best->ebx & bit(X86_FEATURE_INVPCID)) && guest_cpuid_has_pcid(vcpu)) { exec_control = vmcs_read32(SECONDARY_VM_EXEC_CONTROL); exec_control \|= SECONDARY_EXEC_ENABLE_INVPCID; vmcs_write32(SECONDARY_VM_EXEC_CONTROL, exec_control); } else { if (cpu_has_secondary_exec_ctrls()) { exec_control = vmcs_read32(SECONDARY_VM_EXEC_CONTROL); exec_control &= ~SECONDARY_EXEC_ENABLE_INVPCID; vmcs_write32(SECONDARY_VM_EXEC_CONTROL, exec_control); } if (best) best->ebx &= ~bit(X86_FEATURE_INVPCID); } } static void vmx_set_supported_cpuid(u32 func, struct kvm_cpuid_entry2 entry) { if (func == 1 && nested) entry->ecx \|= bit(X86_FEATURE_VMX); } static void nested_ept_inject_page_fault(struct kvm_vcpu vcpu, struct x86_exception fault) { struct vmcs12 vmcs12 = get_vmcs12(vcpu); u32 exit_reason; if (fault->error_code & PFERR_RSVD_MASK) exit_reason = EXIT_REASON_EPT_MISCONFIG; else exit_reason = EXIT_REASON_EPT_VIOLATION; nested_vmx_vmexit(vcpu, exit_reason, 0, vcpu->arch.exit_qualification); vmcs12->guest_physical_address = fault->address; } / Callbacks for nested_ept_init_mmu_context: / static unsigned long nested_ept_get_cr3(struct kvm_vcpu vcpu) { /* return the page table to be shadowed - in our case, EPT12 / return get_vmcs12(vcpu)->ept_pointer; } static void nested_ept_init_mmu_context(struct kvm_vcpu vcpu) { kvm_init_shadow_ept_mmu(vcpu, &vcpu->arch.mmu, nested_vmx_ept_caps & VMX_EPT_EXECUTE_ONLY_BIT); vcpu->arch.mmu.set_cr3 = vmx_set_cr3; vcpu->arch.mmu.get_cr3 = nested_ept_get_cr3; vcpu->arch.mmu.inject_page_fault = nested_ept_inject_page_fault; vcpu->arch.walk_mmu = &vcpu->arch.nested_mmu; } static void nested_ept_uninit_mmu_context(struct kvm_vcpu vcpu) { vcpu->arch.walk_mmu = &vcpu->arch.mmu; } static void vmx_inject_page_fault_nested(struct kvm_vcpu vcpu, struct x86_exception fault) { struct vmcs12 vmcs12 = get_vmcs12(vcpu); WARN_ON(!is_guest_mode(vcpu)); /* TODO: also check PFEC_MATCH/MASK, not just EB.PF. / if (vmcs12->exception_bitmap & (1u << PF_VECTOR)) nested_vmx_vmexit(vcpu, to_vmx(vcpu)->exit_reason, vmcs_read32(VM_EXIT_INTR_INFO), vmcs_readl(EXIT_QUALIFICATION)); else kvm_inject_page_fault(vcpu, fault); } static bool nested_get_vmcs12_pages(struct kvm_vcpu vcpu, struct vmcs12 vmcs12) { struct vcpu_vmx vmx = to_vmx(vcpu); if (nested_cpu_has2(vmcs12, SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES)) { /* TODO: Also verify bits beyond physical address width are 0 / if (!PAGE_ALIGNED(vmcs12->apic_access_addr)) return false; / * Translate L1 physical address to host physical * address for vmcs02. Keep the page pinned, so this * physical address remains valid. We keep a reference * to it so we can release it later. / if (vmx->nested.apic_access_page) / shouldn't happen / nested_release_page(vmx->nested.apic_access_page); vmx->nested.apic_access_page = nested_get_page(vcpu, vmcs12->apic_access_addr); } if (nested_cpu_has(vmcs12, CPU_BASED_TPR_SHADOW)) { / TODO: Also verify bits beyond physical address width are 0 / if (!PAGE_ALIGNED(vmcs12->virtual_apic_page_addr)) return false; if (vmx->nested.virtual_apic_page) / shouldn't happen / nested_release_page(vmx->nested.virtual_apic_page); vmx->nested.virtual_apic_page = nested_get_page(vcpu, vmcs12->virtual_apic_page_addr); / * Failing the vm entry is _not_ what the processor does * but it's basically the only possibility we have. * We could still enter the guest if CR8 load exits are * enabled, CR8 store exits are enabled, and virtualize APIC * access is disabled; in this case the processor would never * use the TPR shadow and we could simply clear the bit from * the execution control. But such a configuration is useless, * so let's keep the code simple. / if (!vmx->nested.virtual_apic_page) return false; } return true; } static void vmx_start_preemption_timer(struct kvm_vcpu vcpu) { u64 preemption_timeout = get_vmcs12(vcpu)->vmx_preemption_timer_value; struct vcpu_vmx vmx = to_vmx(vcpu); if (vcpu->arch.virtual_tsc_khz == 0) return; / Make sure short timeouts reliably trigger an immediate vmexit. * hrtimer_start does not guarantee this. / if (preemption_timeout <= 1) { vmx_preemption_timer_fn(&vmx->nested.preemption_timer); return; } preemption_timeout <<= VMX_MISC_EMULATED_PREEMPTION_TIMER_RATE; preemption_timeout = 1000000; do_div(preemption_timeout, vcpu->arch.virtual_tsc_khz); hrtimer_start(&vmx->nested.preemption_timer, ns_to_ktime(preemption_timeout), HRTIMER_MODE_REL); } /* * prepare_vmcs02 is called when the L1 guest hypervisor runs its nested * L2 guest. L1 has a vmcs for L2 (vmcs12), and this function "merges" it * with L0's requirements for its guest (a.k.a. vmcs01), so we can run the L2 * guest in a way that will both be appropriate to L1's requests, and our * needs. In addition to modifying the active vmcs (which is vmcs02), this * function also has additional necessary side-effects, like setting various * vcpu->arch fields. / static void prepare_vmcs02(struct kvm_vcpu vcpu, struct vmcs12 vmcs12) { struct vcpu_vmx vmx = to_vmx(vcpu); u32 exec_control; vmcs_write16(GUEST_ES_SELECTOR, vmcs12->guest_es_selector); vmcs_write16(GUEST_CS_SELECTOR, vmcs12->guest_cs_selector); vmcs_write16(GUEST_SS_SELECTOR, vmcs12->guest_ss_selector); vmcs_write16(GUEST_DS_SELECTOR, vmcs12->guest_ds_selector); vmcs_write16(GUEST_FS_SELECTOR, vmcs12->guest_fs_selector); vmcs_write16(GUEST_GS_SELECTOR, vmcs12->guest_gs_selector); vmcs_write16(GUEST_LDTR_SELECTOR, vmcs12->guest_ldtr_selector); vmcs_write16(GUEST_TR_SELECTOR, vmcs12->guest_tr_selector); vmcs_write32(GUEST_ES_LIMIT, vmcs12->guest_es_limit); vmcs_write32(GUEST_CS_LIMIT, vmcs12->guest_cs_limit); vmcs_write32(GUEST_SS_LIMIT, vmcs12->guest_ss_limit); vmcs_write32(GUEST_DS_LIMIT, vmcs12->guest_ds_limit); vmcs_write32(GUEST_FS_LIMIT, vmcs12->guest_fs_limit); vmcs_write32(GUEST_GS_LIMIT, vmcs12->guest_gs_limit); vmcs_write32(GUEST_LDTR_LIMIT, vmcs12->guest_ldtr_limit); vmcs_write32(GUEST_TR_LIMIT, vmcs12->guest_tr_limit); vmcs_write32(GUEST_GDTR_LIMIT, vmcs12->guest_gdtr_limit); vmcs_write32(GUEST_IDTR_LIMIT, vmcs12->guest_idtr_limit); vmcs_write32(GUEST_ES_AR_BYTES, vmcs12->guest_es_ar_bytes); vmcs_write32(GUEST_CS_AR_BYTES, vmcs12->guest_cs_ar_bytes); vmcs_write32(GUEST_SS_AR_BYTES, vmcs12->guest_ss_ar_bytes); vmcs_write32(GUEST_DS_AR_BYTES, vmcs12->guest_ds_ar_bytes); vmcs_write32(GUEST_FS_AR_BYTES, vmcs12->guest_fs_ar_bytes); vmcs_write32(GUEST_GS_AR_BYTES, vmcs12->guest_gs_ar_bytes); vmcs_write32(GUEST_LDTR_AR_BYTES, vmcs12->guest_ldtr_ar_bytes); vmcs_write32(GUEST_TR_AR_BYTES, vmcs12->guest_tr_ar_bytes); vmcs_writel(GUEST_ES_BASE, vmcs12->guest_es_base); vmcs_writel(GUEST_CS_BASE, vmcs12->guest_cs_base); vmcs_writel(GUEST_SS_BASE, vmcs12->guest_ss_base); vmcs_writel(GUEST_DS_BASE, vmcs12->guest_ds_base); vmcs_writel(GUEST_FS_BASE, vmcs12->guest_fs_base); vmcs_writel(GUEST_GS_BASE, vmcs12->guest_gs_base); vmcs_writel(GUEST_LDTR_BASE, vmcs12->guest_ldtr_base); vmcs_writel(GUEST_TR_BASE, vmcs12->guest_tr_base); vmcs_writel(GUEST_GDTR_BASE, vmcs12->guest_gdtr_base); vmcs_writel(GUEST_IDTR_BASE, vmcs12->guest_idtr_base); if (vmcs12->vm_entry_controls & VM_ENTRY_LOAD_DEBUG_CONTROLS) { kvm_set_dr(vcpu, 7, vmcs12->guest_dr7); vmcs_write64(GUEST_IA32_DEBUGCTL, vmcs12->guest_ia32_debugctl); } else { kvm_set_dr(vcpu, 7, vcpu->arch.dr7); vmcs_write64(GUEST_IA32_DEBUGCTL, vmx->nested.vmcs01_debugctl); } vmcs_write32(VM_ENTRY_INTR_INFO_FIELD, vmcs12->vm_entry_intr_info_field); vmcs_write32(VM_ENTRY_EXCEPTION_ERROR_CODE, vmcs12->vm_entry_exception_error_code); vmcs_write32(VM_ENTRY_INSTRUCTION_LEN, vmcs12->vm_entry_instruction_len); vmcs_write32(GUEST_INTERRUPTIBILITY_INFO, vmcs12->guest_interruptibility_info); vmcs_write32(GUEST_SYSENTER_CS, vmcs12->guest_sysenter_cs); vmx_set_rflags(vcpu, vmcs12->guest_rflags); vmcs_writel(GUEST_PENDING_DBG_EXCEPTIONS, vmcs12->guest_pending_dbg_exceptions); vmcs_writel(GUEST_SYSENTER_ESP, vmcs12->guest_sysenter_esp); vmcs_writel(GUEST_SYSENTER_EIP, vmcs12->guest_sysenter_eip); vmcs_write64(VMCS_LINK_POINTER, -1ull); exec_control = vmcs12->pin_based_vm_exec_control; exec_control \|= vmcs_config.pin_based_exec_ctrl; exec_control &= ~(PIN_BASED_VMX_PREEMPTION_TIMER \| PIN_BASED_POSTED_INTR); vmcs_write32(PIN_BASED_VM_EXEC_CONTROL, exec_control); vmx->nested.preemption_timer_expired = false; if (nested_cpu_has_preemption_timer(vmcs12)) vmx_start_preemption_timer(vcpu); /* * Whether page-faults are trapped is determined by a combination of * 3 settings: PFEC_MASK, PFEC_MATCH and EXCEPTION_BITMAP.PF. * If enable_ept, L0 doesn't care about page faults and we should * set all of these to L1's desires. However, if !enable_ept, L0 does * care about (at least some) page faults, and because it is not easy * (if at all possible?) to merge L0 and L1's desires, we simply ask * to exit on each and every L2 page fault. This is done by setting * MASK=MATCH=0 and (see below) EB.PF=1. * Note that below we don't need special code to set EB.PF beyond the * "or"ing of the EB of vmcs01 and vmcs12, because when enable_ept, * vmcs01's EB.PF is 0 so the "or" will take vmcs12's value, and when * !enable_ept, EB.PF is 1, so the "or" will always be 1. * * A problem with this approach (when !enable_ept) is that L1 may be * injected with more page faults than it asked for. This could have * caused problems, but in practice existing hypervisors don't care. * To fix this, we will need to emulate the PFEC checking (on the L1 * page tables), using walk_addr(), when injecting PFs to L1. / vmcs_write32(PAGE_FAULT_ERROR_CODE_MASK, enable_ept ? vmcs12->page_fault_error_code_mask : 0); vmcs_write32(PAGE_FAULT_ERROR_CODE_MATCH, enable_ept ? vmcs12->page_fault_error_code_match : 0); if (cpu_has_secondary_exec_ctrls()) { exec_control = vmx_secondary_exec_control(vmx); if (!vmx->rdtscp_enabled) exec_control &= ~SECONDARY_EXEC_RDTSCP; / Take the following fields only from vmcs12 / exec_control &= ~(SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES \| SECONDARY_EXEC_VIRTUAL_INTR_DELIVERY \| SECONDARY_EXEC_APIC_REGISTER_VIRT); if (nested_cpu_has(vmcs12, CPU_BASED_ACTIVATE_SECONDARY_CONTROLS)) exec_control \|= vmcs12->secondary_vm_exec_control; if (exec_control & SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES) { / * If translation failed, no matter: This feature asks * to exit when accessing the given address, and if it * can never be accessed, this feature won't do * anything anyway. / if (!vmx->nested.apic_access_page) exec_control &= ~SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES; else vmcs_write64(APIC_ACCESS_ADDR, page_to_phys(vmx->nested.apic_access_page)); } else if (vm_need_virtualize_apic_accesses(vmx->vcpu.kvm)) { exec_control \|= SECONDARY_EXEC_VIRTUALIZE_APIC_ACCESSES; kvm_vcpu_reload_apic_access_page(vcpu); } vmcs_write32(SECONDARY_VM_EXEC_CONTROL, exec_control); } / * Set host-state according to L0's settings (vmcs12 is irrelevant here) * Some constant fields are set here by vmx_set_constant_host_state(). * Other fields are different per CPU, and will be set later when * vmx_vcpu_load() is called, and when vmx_save_host_state() is called. / vmx_set_constant_host_state(vmx); / * HOST_RSP is normally set correctly in vmx_vcpu_run() just before * entry, but only if the current (host) sp changed from the value * we wrote last (vmx->host_rsp). This cache is no longer relevant * if we switch vmcs, and rather than hold a separate cache per vmcs, * here we just force the write to happen on entry. / vmx->host_rsp = 0; exec_control = vmx_exec_control(vmx); / L0's desires / exec_control &= ~CPU_BASED_VIRTUAL_INTR_PENDING; exec_control &= ~CPU_BASED_VIRTUAL_NMI_PENDING; exec_control &= ~CPU_BASED_TPR_SHADOW; exec_control \|= vmcs12->cpu_based_vm_exec_control; if (exec_control & CPU_BASED_TPR_SHADOW) { vmcs_write64(VIRTUAL_APIC_PAGE_ADDR, page_to_phys(vmx->nested.virtual_apic_page)); vmcs_write32(TPR_THRESHOLD, vmcs12->tpr_threshold); } / * Merging of IO and MSR bitmaps not currently supported. * Rather, exit every time. / exec_control &= ~CPU_BASED_USE_MSR_BITMAPS; exec_control &= ~CPU_BASED_USE_IO_BITMAPS; exec_control \|= CPU_BASED_UNCOND_IO_EXITING; vmcs_write32(CPU_BASED_VM_EXEC_CONTROL, exec_control); / EXCEPTION_BITMAP and CR0_GUEST_HOST_MASK should basically be the * bitwise-or of what L1 wants to trap for L2, and what we want to * trap. Note that CR0.TS also needs updating - we do this later. / update_exception_bitmap(vcpu); vcpu->arch.cr0_guest_owned_bits &= ~vmcs12->cr0_guest_host_mask; vmcs_writel(CR0_GUEST_HOST_MASK, ~vcpu->arch.cr0_guest_owned_bits); / L2->L1 exit controls are emulated - the hardware exit is to L0 so * we should use its exit controls. Note that VM_EXIT_LOAD_IA32_EFER * bits are further modified by vmx_set_efer() below. / vmcs_write32(VM_EXIT_CONTROLS, vmcs_config.vmexit_ctrl); / vmcs12's VM_ENTRY_LOAD_IA32_EFER and VM_ENTRY_IA32E_MODE are * emulated by vmx_set_efer(), below. / vm_entry_controls_init(vmx, (vmcs12->vm_entry_controls & ~VM_ENTRY_LOAD_IA32_EFER & ~VM_ENTRY_IA32E_MODE) \| (vmcs_config.vmentry_ctrl & ~VM_ENTRY_IA32E_MODE)); if (vmcs12->vm_entry_controls & VM_ENTRY_LOAD_IA32_PAT) { vmcs_write64(GUEST_IA32_PAT, vmcs12->guest_ia32_pat); vcpu->arch.pat = vmcs12->guest_ia32_pat; } else if (vmcs_config.vmentry_ctrl & VM_ENTRY_LOAD_IA32_PAT) vmcs_write64(GUEST_IA32_PAT, vmx->vcpu.arch.pat); set_cr4_guest_host_mask(vmx); if (vmcs12->vm_entry_controls & VM_ENTRY_LOAD_BNDCFGS) vmcs_write64(GUEST_BNDCFGS, vmcs12->guest_bndcfgs); if (vmcs12->cpu_based_vm_exec_control & CPU_BASED_USE_TSC_OFFSETING) vmcs_write64(TSC_OFFSET, vmx->nested.vmcs01_tsc_offset + vmcs12->tsc_offset); else vmcs_write64(TSC_OFFSET, vmx->nested.vmcs01_tsc_offset); if (enable_vpid) { / * Trivially support vpid by letting L2s share their parent * L1's vpid. TODO: move to a more elaborate solution, giving * each L2 its own vpid and exposing the vpid feature to L1. / vmcs_write16(VIRTUAL_PROCESSOR_ID, vmx->vpid); vmx_flush_tlb(vcpu); } if (nested_cpu_has_ept(vmcs12)) { kvm_mmu_unload(vcpu); nested_ept_init_mmu_context(vcpu); } if (vmcs12->vm_entry_controls & VM_ENTRY_LOAD_IA32_EFER) vcpu->arch.efer = vmcs12->guest_ia32_efer; else if (vmcs12->vm_entry_controls & VM_ENTRY_IA32E_MODE) vcpu->arch.efer \|= (EFER_LMA \| EFER_LME); else vcpu->arch.efer &= ~(EFER_LMA \| EFER_LME); / Note: modifies VM_ENTRY/EXIT_CONTROLS and GUEST/HOST_IA32_EFER / vmx_set_efer(vcpu, vcpu->arch.efer); / * This sets GUEST_CR0 to vmcs12->guest_cr0, with possibly a modified * TS bit (for lazy fpu) and bits which we consider mandatory enabled. * The CR0_READ_SHADOW is what L2 should have expected to read given * the specifications by L1; It's not enough to take * vmcs12->cr0_read_shadow because on our cr0_guest_host_mask we we * have more bits than L1 expected. / vmx_set_cr0(vcpu, vmcs12->guest_cr0); vmcs_writel(CR0_READ_SHADOW, nested_read_cr0(vmcs12)); vmx_set_cr4(vcpu, vmcs12->guest_cr4); vmcs_writel(CR4_READ_SHADOW, nested_read_cr4(vmcs12)); / shadow page tables on either EPT or shadow page tables / kvm_set_cr3(vcpu, vmcs12->guest_cr3); kvm_mmu_reset_context(vcpu); if (!enable_ept) vcpu->arch.walk_mmu->inject_page_fault = vmx_inject_page_fault_nested; / * L1 may access the L2's PDPTR, so save them to construct vmcs12 / if (enable_ept) { vmcs_write64(GUEST_PDPTR0, vmcs12->guest_pdptr0); vmcs_write64(GUEST_PDPTR1, vmcs12->guest_pdptr1); vmcs_write64(GUEST_PDPTR2, vmcs12->guest_pdptr2); vmcs_write64(GUEST_PDPTR3, vmcs12->guest_pdptr3); } kvm_register_write(vcpu, VCPU_REGS_RSP, vmcs12->guest_rsp); kvm_register_write(vcpu, VCPU_REGS_RIP, vmcs12->guest_rip); } / * nested_vmx_run() handles a nested entry, i.e., a VMLAUNCH or VMRESUME on L1 * for running an L2 nested guest. / static int nested_vmx_run(struct kvm_vcpu vcpu, bool launch) { struct vmcs12 vmcs12; struct vcpu_vmx vmx = to_vmx(vcpu); int cpu; struct loaded_vmcs vmcs02; bool ia32e; if (!nested_vmx_check_permission(vcpu) \|\| !nested_vmx_check_vmcs12(vcpu)) return 1; skip_emulated_instruction(vcpu); vmcs12 = get_vmcs12(vcpu); if (enable_shadow_vmcs) copy_shadow_to_vmcs12(vmx); / * The nested entry process starts with enforcing various prerequisites * on vmcs12 as required by the Intel SDM, and act appropriately when * they fail: As the SDM explains, some conditions should cause the * instruction to fail, while others will cause the instruction to seem * to succeed, but return an EXIT_REASON_INVALID_STATE. * To speed up the normal (success) code path, we should avoid checking * for misconfigurations which will anyway be caught by the processor * when using the merged vmcs02. / if (vmcs12->launch_state == launch) { nested_vmx_failValid(vcpu, launch ? VMXERR_VMLAUNCH_NONCLEAR_VMCS : VMXERR_VMRESUME_NONLAUNCHED_VMCS); return 1; } if (vmcs12->guest_activity_state != GUEST_ACTIVITY_ACTIVE && vmcs12->guest_activity_state != GUEST_ACTIVITY_HLT) { nested_vmx_failValid(vcpu, VMXERR_ENTRY_INVALID_CONTROL_FIELD); return 1; } if ((vmcs12->cpu_based_vm_exec_control & CPU_BASED_USE_MSR_BITMAPS) && !PAGE_ALIGNED(vmcs12->msr_bitmap)) { /TODO: Also verify bits beyond physical address width are 0/ nested_vmx_failValid(vcpu, VMXERR_ENTRY_INVALID_CONTROL_FIELD); return 1; } if (!nested_get_vmcs12_pages(vcpu, vmcs12)) { /TODO: Also verify bits beyond physical address width are 0/ nested_vmx_failValid(vcpu, VMXERR_ENTRY_INVALID_CONTROL_FIELD); return 1; } if (vmcs12->vm_entry_msr_load_count > 0 \|\| vmcs12->vm_exit_msr_load_count > 0 \|\| vmcs12->vm_exit_msr_store_count > 0) { pr_warn_ratelimited("%s: VMCS MSR_{LOAD,STORE} unsupported\n", __func__); nested_vmx_failValid(vcpu, VMXERR_ENTRY_INVALID_CONTROL_FIELD); return 1; } if (!vmx_control_verify(vmcs12->cpu_based_vm_exec_control, nested_vmx_true_procbased_ctls_low, nested_vmx_procbased_ctls_high) \|\| !vmx_control_verify(vmcs12->secondary_vm_exec_control, nested_vmx_secondary_ctls_low, nested_vmx_secondary_ctls_high) \|\| !vmx_control_verify(vmcs12->pin_based_vm_exec_control, nested_vmx_pinbased_ctls_low, nested_vmx_pinbased_ctls_high) \|\| !vmx_control_verify(vmcs12->vm_exit_controls, nested_vmx_true_exit_ctls_low, nested_vmx_exit_ctls_high) \|\| !vmx_control_verify(vmcs12->vm_entry_controls, nested_vmx_true_entry_ctls_low, nested_vmx_entry_ctls_high)) { nested_vmx_failValid(vcpu, VMXERR_ENTRY_INVALID_CONTROL_FIELD); return 1; } if (((vmcs12->host_cr0 & VMXON_CR0_ALWAYSON) != VMXON_CR0_ALWAYSON) \|\| ((vmcs12->host_cr4 & VMXON_CR4_ALWAYSON) != VMXON_CR4_ALWAYSON)) { nested_vmx_failValid(vcpu, VMXERR_ENTRY_INVALID_HOST_STATE_FIELD); return 1; } if (!nested_cr0_valid(vmcs12, vmcs12->guest_cr0) \|\| ((vmcs12->guest_cr4 & VMXON_CR4_ALWAYSON) != VMXON_CR4_ALWAYSON)) { nested_vmx_entry_failure(vcpu, vmcs12, EXIT_REASON_INVALID_STATE, ENTRY_FAIL_DEFAULT); return 1; } if (vmcs12->vmcs_link_pointer != -1ull) { nested_vmx_entry_failure(vcpu, vmcs12, EXIT_REASON_INVALID_STATE, ENTRY_FAIL_VMCS_LINK_PTR); return 1; } / * If the load IA32_EFER VM-entry control is 1, the following checks * are performed on the field for the IA32_EFER MSR: * - Bits reserved in the IA32_EFER MSR must be 0. * - Bit 10 (corresponding to IA32_EFER.LMA) must equal the value of * the IA-32e mode guest VM-exit control. It must also be identical * to bit 8 (LME) if bit 31 in the CR0 field (corresponding to * CR0.PG) is 1. / if (vmcs12->vm_entry_controls & VM_ENTRY_LOAD_IA32_EFER) { ia32e = (vmcs12->vm_entry_controls & VM_ENTRY_IA32E_MODE) != 0; if (!kvm_valid_efer(vcpu, vmcs12->guest_ia32_efer) \|\| ia32e != !!(vmcs12->guest_ia32_efer & EFER_LMA) \|\| ((vmcs12->guest_cr0 & X86_CR0_PG) && ia32e != !!(vmcs12->guest_ia32_efer & EFER_LME))) { nested_vmx_entry_failure(vcpu, vmcs12, EXIT_REASON_INVALID_STATE, ENTRY_FAIL_DEFAULT); return 1; } } / * If the load IA32_EFER VM-exit control is 1, bits reserved in the * IA32_EFER MSR must be 0 in the field for that register. In addition, * the values of the LMA and LME bits in the field must each be that of * the host address-space size VM-exit control. / if (vmcs12->vm_exit_controls & VM_EXIT_LOAD_IA32_EFER) { ia32e = (vmcs12->vm_exit_controls & VM_EXIT_HOST_ADDR_SPACE_SIZE) != 0; if (!kvm_valid_efer(vcpu, vmcs12->host_ia32_efer) \|\| ia32e != !!(vmcs12->host_ia32_efer & EFER_LMA) \|\| ia32e != !!(vmcs12->host_ia32_efer & EFER_LME)) { nested_vmx_entry_failure(vcpu, vmcs12, EXIT_REASON_INVALID_STATE, ENTRY_FAIL_DEFAULT); return 1; } } / * We're finally done with prerequisite checking, and can start with * the nested entry. / vmcs02 = nested_get_current_vmcs02(vmx); if (!vmcs02) return -ENOMEM; enter_guest_mode(vcpu); vmx->nested.vmcs01_tsc_offset = vmcs_read64(TSC_OFFSET); if (!(vmcs12->vm_entry_controls & VM_ENTRY_LOAD_DEBUG_CONTROLS)) vmx->nested.vmcs01_debugctl = vmcs_read64(GUEST_IA32_DEBUGCTL); cpu = get_cpu(); vmx->loaded_vmcs = vmcs02; vmx_vcpu_put(vcpu); vmx_vcpu_load(vcpu, cpu); vcpu->cpu = cpu; put_cpu(); vmx_segment_cache_clear(vmx); vmcs12->launch_state = 1; prepare_vmcs02(vcpu, vmcs12); if (vmcs12->guest_activity_state == GUEST_ACTIVITY_HLT) return kvm_emulate_halt(vcpu); vmx->nested.nested_run_pending = 1; / * Note no nested_vmx_succeed or nested_vmx_fail here. At this point * we are no longer running L1, and VMLAUNCH/VMRESUME has not yet * returned as far as L1 is concerned. It will only return (and set * the success flag) when L2 exits (see nested_vmx_vmexit()). / return 1; } / * On a nested exit from L2 to L1, vmcs12.guest_cr0 might not be up-to-date * because L2 may have changed some cr0 bits directly (CRO_GUEST_HOST_MASK). * This function returns the new value we should put in vmcs12.guest_cr0. * It's not enough to just return the vmcs02 GUEST_CR0. Rather, * 1. Bits that neither L0 nor L1 trapped, were set directly by L2 and are now * available in vmcs02 GUEST_CR0. (Note: It's enough to check that L0 * didn't trap the bit, because if L1 did, so would L0). * 2. Bits that L1 asked to trap (and therefore L0 also did) could not have * been modified by L2, and L1 knows it. So just leave the old value of * the bit from vmcs12.guest_cr0. Note that the bit from vmcs02 GUEST_CR0 * isn't relevant, because if L0 traps this bit it can set it to anything. * 3. Bits that L1 didn't trap, but L0 did. L1 believes the guest could have * changed these bits, and therefore they need to be updated, but L0 * didn't necessarily allow them to be changed in GUEST_CR0 - and rather * put them in vmcs02 CR0_READ_SHADOW. So take these bits from there. / static inline unsigned long vmcs12_guest_cr0(struct kvm_vcpu vcpu, struct vmcs12 vmcs12) { return /1/ (vmcs_readl(GUEST_CR0) & vcpu->arch.cr0_guest_owned_bits) \| /2/ (vmcs12->guest_cr0 & vmcs12->cr0_guest_host_mask) \| /3/ (vmcs_readl(CR0_READ_SHADOW) & ~(vmcs12->cr0_guest_host_mask \| vcpu->arch.cr0_guest_owned_bits)); } static inline unsigned long vmcs12_guest_cr4(struct kvm_vcpu vcpu, struct vmcs12 vmcs12) { return /1/ (vmcs_readl(GUEST_CR4) & vcpu->arch.cr4_guest_owned_bits) \| /2/ (vmcs12->guest_cr4 & vmcs12->cr4_guest_host_mask) \| /3/ (vmcs_readl(CR4_READ_SHADOW) & ~(vmcs12->cr4_guest_host_mask \| vcpu->arch.cr4_guest_owned_bits)); } static void vmcs12_save_pending_event(struct kvm_vcpu vcpu, struct vmcs12 vmcs12) { u32 idt_vectoring; unsigned int nr; if (vcpu->arch.exception.pending && vcpu->arch.exception.reinject) { nr = vcpu->arch.exception.nr; idt_vectoring = nr \| VECTORING_INFO_VALID_MASK; if (kvm_exception_is_soft(nr)) { vmcs12->vm_exit_instruction_len = vcpu->arch.event_exit_inst_len; idt_vectoring \|= INTR_TYPE_SOFT_EXCEPTION; } else idt_vectoring \|= INTR_TYPE_HARD_EXCEPTION; if (vcpu->arch.exception.has_error_code) { idt_vectoring \|= VECTORING_INFO_DELIVER_CODE_MASK; vmcs12->idt_vectoring_error_code = vcpu->arch.exception.error_code; } vmcs12->idt_vectoring_info_field = idt_vectoring; } else if (vcpu->arch.nmi_injected) { vmcs12->idt_vectoring_info_field = INTR_TYPE_NMI_INTR \| INTR_INFO_VALID_MASK \| NMI_VECTOR; } else if (vcpu->arch.interrupt.pending) { nr = vcpu->arch.interrupt.nr; idt_vectoring = nr \| VECTORING_INFO_VALID_MASK; if (vcpu->arch.interrupt.soft) { idt_vectoring \|= INTR_TYPE_SOFT_INTR; vmcs12->vm_entry_instruction_len = vcpu->arch.event_exit_inst_len; } else idt_vectoring \|= INTR_TYPE_EXT_INTR; vmcs12->idt_vectoring_info_field = idt_vectoring; } } static int vmx_check_nested_events(struct kvm_vcpu vcpu, bool external_intr) { struct vcpu_vmx vmx = to_vmx(vcpu); if (nested_cpu_has_preemption_timer(get_vmcs12(vcpu)) && vmx->nested.preemption_timer_expired) { if (vmx->nested.nested_run_pending) return -EBUSY; nested_vmx_vmexit(vcpu, EXIT_REASON_PREEMPTION_TIMER, 0, 0); return 0; } if (vcpu->arch.nmi_pending && nested_exit_on_nmi(vcpu)) { if (vmx->nested.nested_run_pending \|\| vcpu->arch.interrupt.pending) return -EBUSY; nested_vmx_vmexit(vcpu, EXIT_REASON_EXCEPTION_NMI, NMI_VECTOR \| INTR_TYPE_NMI_INTR \| INTR_INFO_VALID_MASK, 0); / * The NMI-triggered VM exit counts as injection: * clear this one and block further NMIs. / vcpu->arch.nmi_pending = 0; vmx_set_nmi_mask(vcpu, true); return 0; } if ((kvm_cpu_has_interrupt(vcpu) \|\| external_intr) && nested_exit_on_intr(vcpu)) { if (vmx->nested.nested_run_pending) return -EBUSY; nested_vmx_vmexit(vcpu, EXIT_REASON_EXTERNAL_INTERRUPT, 0, 0); } return 0; } static u32 vmx_get_preemption_timer_value(struct kvm_vcpu vcpu) { ktime_t remaining = hrtimer_get_remaining(&to_vmx(vcpu)->nested.preemption_timer); u64 value; if (ktime_to_ns(remaining) <= 0) return 0; value = ktime_to_ns(remaining) * vcpu->arch.virtual_tsc_khz; do_div(value, 1000000); return value >> VMX_MISC_EMULATED_PREEMPTION_TIMER_RATE; } /* * prepare_vmcs12 is part of what we need to do when the nested L2 guest exits * and we want to prepare to run its L1 parent. L1 keeps a vmcs for L2 (vmcs12), * and this function updates it to reflect the changes to the guest state while * L2 was running (and perhaps made some exits which were handled directly by L0 * without going back to L1), and to reflect the exit reason. * Note that we do not have to copy here all VMCS fields, just those that * could have changed by the L2 guest or the exit - i.e., the guest-state and * exit-information fields only. Other fields are modified by L1 with VMWRITE, * which already writes to vmcs12 directly. / static void prepare_vmcs12(struct kvm_vcpu vcpu, struct vmcs12 vmcs12, u32 exit_reason, u32 exit_intr_info, unsigned long exit_qualification) { / update guest state fields: / vmcs12->guest_cr0 = vmcs12_guest_cr0(vcpu, vmcs12); vmcs12->guest_cr4 = vmcs12_guest_cr4(vcpu, vmcs12); vmcs12->guest_rsp = kvm_register_read(vcpu, VCPU_REGS_RSP); vmcs12->guest_rip = kvm_register_read(vcpu, VCPU_REGS_RIP); vmcs12->guest_rflags = vmcs_readl(GUEST_RFLAGS); vmcs12->guest_es_selector = vmcs_read16(GUEST_ES_SELECTOR); vmcs12->guest_cs_selector = vmcs_read16(GUEST_CS_SELECTOR); vmcs12->guest_ss_selector = vmcs_read16(GUEST_SS_SELECTOR); vmcs12->guest_ds_selector = vmcs_read16(GUEST_DS_SELECTOR); vmcs12->guest_fs_selector = vmcs_read16(GUEST_FS_SELECTOR); vmcs12->guest_gs_selector = vmcs_read16(GUEST_GS_SELECTOR); vmcs12->guest_ldtr_selector = vmcs_read16(GUEST_LDTR_SELECTOR); vmcs12->guest_tr_selector = vmcs_read16(GUEST_TR_SELECTOR); vmcs12->guest_es_limit = vmcs_read32(GUEST_ES_LIMIT); vmcs12->guest_cs_limit = vmcs_read32(GUEST_CS_LIMIT); vmcs12->guest_ss_limit = vmcs_read32(GUEST_SS_LIMIT); vmcs12->guest_ds_limit = vmcs_read32(GUEST_DS_LIMIT); vmcs12->guest_fs_limit = vmcs_read32(GUEST_FS_LIMIT); vmcs12->guest_gs_limit = vmcs_read32(GUEST_GS_LIMIT); vmcs12->guest_ldtr_limit = vmcs_read32(GUEST_LDTR_LIMIT); vmcs12->guest_tr_limit = vmcs_read32(GUEST_TR_LIMIT); vmcs12->guest_gdtr_limit = vmcs_read32(GUEST_GDTR_LIMIT); vmcs12->guest_idtr_limit = vmcs_read32(GUEST_IDTR_LIMIT); vmcs12->guest_es_ar_bytes = vmcs_read32(GUEST_ES_AR_BYTES); vmcs12->guest_cs_ar_bytes = vmcs_read32(GUEST_CS_AR_BYTES); vmcs12->guest_ss_ar_bytes = vmcs_read32(GUEST_SS_AR_BYTES); vmcs12->guest_ds_ar_bytes = vmcs_read32(GUEST_DS_AR_BYTES); vmcs12->guest_fs_ar_bytes = vmcs_read32(GUEST_FS_AR_BYTES); vmcs12->guest_gs_ar_bytes = vmcs_read32(GUEST_GS_AR_BYTES); vmcs12->guest_ldtr_ar_bytes = vmcs_read32(GUEST_LDTR_AR_BYTES); vmcs12->guest_tr_ar_bytes = vmcs_read32(GUEST_TR_AR_BYTES); vmcs12->guest_es_base = vmcs_readl(GUEST_ES_BASE); vmcs12->guest_cs_base = vmcs_readl(GUEST_CS_BASE); vmcs12->guest_ss_base = vmcs_readl(GUEST_SS_BASE); vmcs12->guest_ds_base = vmcs_readl(GUEST_DS_BASE); vmcs12->guest_fs_base = vmcs_readl(GUEST_FS_BASE); vmcs12->guest_gs_base = vmcs_readl(GUEST_GS_BASE); vmcs12->guest_ldtr_base = vmcs_readl(GUEST_LDTR_BASE); vmcs12->guest_tr_base = vmcs_readl(GUEST_TR_BASE); vmcs12->guest_gdtr_base = vmcs_readl(GUEST_GDTR_BASE); vmcs12->guest_idtr_base = vmcs_readl(GUEST_IDTR_BASE); vmcs12->guest_interruptibility_info = vmcs_read32(GUEST_INTERRUPTIBILITY_INFO); vmcs12->guest_pending_dbg_exceptions = vmcs_readl(GUEST_PENDING_DBG_EXCEPTIONS); if (vcpu->arch.mp_state == KVM_MP_STATE_HALTED) vmcs12->guest_activity_state = GUEST_ACTIVITY_HLT; else vmcs12->guest_activity_state = GUEST_ACTIVITY_ACTIVE; if (nested_cpu_has_preemption_timer(vmcs12)) { if (vmcs12->vm_exit_controls & VM_EXIT_SAVE_VMX_PREEMPTION_TIMER) vmcs12->vmx_preemption_timer_value = vmx_get_preemption_timer_value(vcpu); hrtimer_cancel(&to_vmx(vcpu)->nested.preemption_timer); } / * In some cases (usually, nested EPT), L2 is allowed to change its * own CR3 without exiting. If it has changed it, we must keep it. * Of course, if L0 is using shadow page tables, GUEST_CR3 was defined * by L0, not L1 or L2, so we mustn't unconditionally copy it to vmcs12. * * Additionally, restore L2's PDPTR to vmcs12. / if (enable_ept) { vmcs12->guest_cr3 = vmcs_read64(GUEST_CR3); vmcs12->guest_pdptr0 = vmcs_read64(GUEST_PDPTR0); vmcs12->guest_pdptr1 = vmcs_read64(GUEST_PDPTR1); vmcs12->guest_pdptr2 = vmcs_read64(GUEST_PDPTR2); vmcs12->guest_pdptr3 = vmcs_read64(GUEST_PDPTR3); } vmcs12->vm_entry_controls = (vmcs12->vm_entry_controls & ~VM_ENTRY_IA32E_MODE) \| (vm_entry_controls_get(to_vmx(vcpu)) & VM_ENTRY_IA32E_MODE); if (vmcs12->vm_exit_controls & VM_EXIT_SAVE_DEBUG_CONTROLS) { kvm_get_dr(vcpu, 7, (unsigned long )&vmcs12->guest_dr7); vmcs12->guest_ia32_debugctl = vmcs_read64(GUEST_IA32_DEBUGCTL); } /* TODO: These cannot have changed unless we have MSR bitmaps and * the relevant bit asks not to trap the change / if (vmcs12->vm_exit_controls & VM_EXIT_SAVE_IA32_PAT) vmcs12->guest_ia32_pat = vmcs_read64(GUEST_IA32_PAT); if (vmcs12->vm_exit_controls & VM_EXIT_SAVE_IA32_EFER) vmcs12->guest_ia32_efer = vcpu->arch.efer; vmcs12->guest_sysenter_cs = vmcs_read32(GUEST_SYSENTER_CS); vmcs12->guest_sysenter_esp = vmcs_readl(GUEST_SYSENTER_ESP); vmcs12->guest_sysenter_eip = vmcs_readl(GUEST_SYSENTER_EIP); if (vmx_mpx_supported()) vmcs12->guest_bndcfgs = vmcs_read64(GUEST_BNDCFGS); / update exit information fields: / vmcs12->vm_exit_reason = exit_reason; vmcs12->exit_qualification = exit_qualification; vmcs12->vm_exit_intr_info = exit_intr_info; if ((vmcs12->vm_exit_intr_info & (INTR_INFO_VALID_MASK \| INTR_INFO_DELIVER_CODE_MASK)) == (INTR_INFO_VALID_MASK \| INTR_INFO_DELIVER_CODE_MASK)) vmcs12->vm_exit_intr_error_code = vmcs_read32(VM_EXIT_INTR_ERROR_CODE); vmcs12->idt_vectoring_info_field = 0; vmcs12->vm_exit_instruction_len = vmcs_read32(VM_EXIT_INSTRUCTION_LEN); vmcs12->vmx_instruction_info = vmcs_read32(VMX_INSTRUCTION_INFO); if (!(vmcs12->vm_exit_reason & VMX_EXIT_REASONS_FAILED_VMENTRY)) { / vm_entry_intr_info_field is cleared on exit. Emulate this * instead of reading the real value. / vmcs12->vm_entry_intr_info_field &= ~INTR_INFO_VALID_MASK; / * Transfer the event that L0 or L1 may wanted to inject into * L2 to IDT_VECTORING_INFO_FIELD. / vmcs12_save_pending_event(vcpu, vmcs12); } / * Drop what we picked up for L2 via vmx_complete_interrupts. It is * preserved above and would only end up incorrectly in L1. / vcpu->arch.nmi_injected = false; kvm_clear_exception_queue(vcpu); kvm_clear_interrupt_queue(vcpu); } / * A part of what we need to when the nested L2 guest exits and we want to * run its L1 parent, is to reset L1's guest state to the host state specified * in vmcs12. * This function is to be called not only on normal nested exit, but also on * a nested entry failure, as explained in Intel's spec, 3B.23.7 ("VM-Entry * Failures During or After Loading Guest State"). * This function should be called when the active VMCS is L1's (vmcs01). / static void load_vmcs12_host_state(struct kvm_vcpu vcpu, struct vmcs12 vmcs12) { struct kvm_segment seg; if (vmcs12->vm_exit_controls & VM_EXIT_LOAD_IA32_EFER) vcpu->arch.efer = vmcs12->host_ia32_efer; else if (vmcs12->vm_exit_controls & VM_EXIT_HOST_ADDR_SPACE_SIZE) vcpu->arch.efer \|= (EFER_LMA \| EFER_LME); else vcpu->arch.efer &= ~(EFER_LMA \| EFER_LME); vmx_set_efer(vcpu, vcpu->arch.efer); kvm_register_write(vcpu, VCPU_REGS_RSP, vmcs12->host_rsp); kvm_register_write(vcpu, VCPU_REGS_RIP, vmcs12->host_rip); vmx_set_rflags(vcpu, X86_EFLAGS_FIXED); / * Note that calling vmx_set_cr0 is important, even if cr0 hasn't * actually changed, because it depends on the current state of * fpu_active (which may have changed). * Note that vmx_set_cr0 refers to efer set above. / vmx_set_cr0(vcpu, vmcs12->host_cr0); / * If we did fpu_activate()/fpu_deactivate() during L2's run, we need * to apply the same changes to L1's vmcs. We just set cr0 correctly, * but we also need to update cr0_guest_host_mask and exception_bitmap. / update_exception_bitmap(vcpu); vcpu->arch.cr0_guest_owned_bits = (vcpu->fpu_active ? X86_CR0_TS : 0); vmcs_writel(CR0_GUEST_HOST_MASK, ~vcpu->arch.cr0_guest_owned_bits); / * Note that CR4_GUEST_HOST_MASK is already set in the original vmcs01 * (KVM doesn't change it)- no reason to call set_cr4_guest_host_mask(); / vcpu->arch.cr4_guest_owned_bits = ~vmcs_readl(CR4_GUEST_HOST_MASK); kvm_set_cr4(vcpu, vmcs12->host_cr4); nested_ept_uninit_mmu_context(vcpu); kvm_set_cr3(vcpu, vmcs12->host_cr3); kvm_mmu_reset_context(vcpu); if (!enable_ept) vcpu->arch.walk_mmu->inject_page_fault = kvm_inject_page_fault; if (enable_vpid) { / * Trivially support vpid by letting L2s share their parent * L1's vpid. TODO: move to a more elaborate solution, giving * each L2 its own vpid and exposing the vpid feature to L1. / vmx_flush_tlb(vcpu); } vmcs_write32(GUEST_SYSENTER_CS, vmcs12->host_ia32_sysenter_cs); vmcs_writel(GUEST_SYSENTER_ESP, vmcs12->host_ia32_sysenter_esp); vmcs_writel(GUEST_SYSENTER_EIP, vmcs12->host_ia32_sysenter_eip); vmcs_writel(GUEST_IDTR_BASE, vmcs12->host_idtr_base); vmcs_writel(GUEST_GDTR_BASE, vmcs12->host_gdtr_base); / If not VM_EXIT_CLEAR_BNDCFGS, the L2 value propagates to L1. / if (vmcs12->vm_exit_controls & VM_EXIT_CLEAR_BNDCFGS) vmcs_write64(GUEST_BNDCFGS, 0); if (vmcs12->vm_exit_controls & VM_EXIT_LOAD_IA32_PAT) { vmcs_write64(GUEST_IA32_PAT, vmcs12->host_ia32_pat); vcpu->arch.pat = vmcs12->host_ia32_pat; } if (vmcs12->vm_exit_controls & VM_EXIT_LOAD_IA32_PERF_GLOBAL_CTRL) vmcs_write64(GUEST_IA32_PERF_GLOBAL_CTRL, vmcs12->host_ia32_perf_global_ctrl); / Set L1 segment info according to Intel SDM 27.5.2 Loading Host Segment and Descriptor-Table Registers / seg = (struct kvm_segment) { .base = 0, .limit = 0xFFFFFFFF, .selector = vmcs12->host_cs_selector, .type = 11, .present = 1, .s = 1, .g = 1 }; if (vmcs12->vm_exit_controls & VM_EXIT_HOST_ADDR_SPACE_SIZE) seg.l = 1; else seg.db = 1; vmx_set_segment(vcpu, &seg, VCPU_SREG_CS); seg = (struct kvm_segment) { .base = 0, .limit = 0xFFFFFFFF, .type = 3, .present = 1, .s = 1, .db = 1, .g = 1 }; seg.selector = vmcs12->host_ds_selector; vmx_set_segment(vcpu, &seg, VCPU_SREG_DS); seg.selector = vmcs12->host_es_selector; vmx_set_segment(vcpu, &seg, VCPU_SREG_ES); seg.selector = vmcs12->host_ss_selector; vmx_set_segment(vcpu, &seg, VCPU_SREG_SS); seg.selector = vmcs12->host_fs_selector; seg.base = vmcs12->host_fs_base; vmx_set_segment(vcpu, &seg, VCPU_SREG_FS); seg.selector = vmcs12->host_gs_selector; seg.base = vmcs12->host_gs_base; vmx_set_segment(vcpu, &seg, VCPU_SREG_GS); seg = (struct kvm_segment) { .base = vmcs12->host_tr_base, .limit = 0x67, .selector = vmcs12->host_tr_selector, .type = 11, .present = 1 }; vmx_set_segment(vcpu, &seg, VCPU_SREG_TR); kvm_set_dr(vcpu, 7, 0x400); vmcs_write64(GUEST_IA32_DEBUGCTL, 0); } / * Emulate an exit from nested guest (L2) to L1, i.e., prepare to run L1 * and modify vmcs12 to make it see what it would expect to see there if * L2 was its real guest. Must only be called when in L2 (is_guest_mode()) / static void nested_vmx_vmexit(struct kvm_vcpu vcpu, u32 exit_reason, u32 exit_intr_info, unsigned long exit_qualification) { struct vcpu_vmx vmx = to_vmx(vcpu); struct vmcs12 vmcs12 = get_vmcs12(vcpu); /* trying to cancel vmlaunch/vmresume is a bug / WARN_ON_ONCE(vmx->nested.nested_run_pending); leave_guest_mode(vcpu); prepare_vmcs12(vcpu, vmcs12, exit_reason, exit_intr_info, exit_qualification); vmx_load_vmcs01(vcpu); if ((exit_reason == EXIT_REASON_EXTERNAL_INTERRUPT) && nested_exit_intr_ack_set(vcpu)) { int irq = kvm_cpu_get_interrupt(vcpu); WARN_ON(irq < 0); vmcs12->vm_exit_intr_info = irq \| INTR_INFO_VALID_MASK \| INTR_TYPE_EXT_INTR; } trace_kvm_nested_vmexit_inject(vmcs12->vm_exit_reason, vmcs12->exit_qualification, vmcs12->idt_vectoring_info_field, vmcs12->vm_exit_intr_info, vmcs12->vm_exit_intr_error_code, KVM_ISA_VMX); vm_entry_controls_init(vmx, vmcs_read32(VM_ENTRY_CONTROLS)); vm_exit_controls_init(vmx, vmcs_read32(VM_EXIT_CONTROLS)); vmx_segment_cache_clear(vmx); / if no vmcs02 cache requested, remove the one we used / if (VMCS02_POOL_SIZE == 0) nested_free_vmcs02(vmx, vmx->nested.current_vmptr); load_vmcs12_host_state(vcpu, vmcs12); / Update TSC_OFFSET if TSC was changed while L2 ran / vmcs_write64(TSC_OFFSET, vmx->nested.vmcs01_tsc_offset); / This is needed for same reason as it was needed in prepare_vmcs02 / vmx->host_rsp = 0; / Unpin physical memory we referred to in vmcs02 / if (vmx->nested.apic_access_page) { nested_release_page(vmx->nested.apic_access_page); vmx->nested.apic_access_page = NULL; } if (vmx->nested.virtual_apic_page) { nested_release_page(vmx->nested.virtual_apic_page); vmx->nested.virtual_apic_page = NULL; } / * We are now running in L2, mmu_notifier will force to reload the * page's hpa for L2 vmcs. Need to reload it for L1 before entering L1. / kvm_vcpu_reload_apic_access_page(vcpu); / * Exiting from L2 to L1, we're now back to L1 which thinks it just * finished a VMLAUNCH or VMRESUME instruction, so we need to set the * success or failure flag accordingly. / if (unlikely(vmx->fail)) { vmx->fail = 0; nested_vmx_failValid(vcpu, vmcs_read32(VM_INSTRUCTION_ERROR)); } else nested_vmx_succeed(vcpu); if (enable_shadow_vmcs) vmx->nested.sync_shadow_vmcs = true; / in case we halted in L2 / vcpu->arch.mp_state = KVM_MP_STATE_RUNNABLE; } / * Forcibly leave nested mode in order to be able to reset the VCPU later on. / static void vmx_leave_nested(struct kvm_vcpu vcpu) { if (is_guest_mode(vcpu)) nested_vmx_vmexit(vcpu, -1, 0, 0); free_nested(to_vmx(vcpu)); } /* * L1's failure to enter L2 is a subset of a normal exit, as explained in * 23.7 "VM-entry failures during or after loading guest state" (this also * lists the acceptable exit-reason and exit-qualification parameters). * It should only be called before L2 actually succeeded to run, and when * vmcs01 is current (it doesn't leave_guest_mode() or switch vmcss). / static void nested_vmx_entry_failure(struct kvm_vcpu vcpu, struct vmcs12 vmcs12, u32 reason, unsigned long qualification) { load_vmcs12_host_state(vcpu, vmcs12); vmcs12->vm_exit_reason = reason \| VMX_EXIT_REASONS_FAILED_VMENTRY; vmcs12->exit_qualification = qualification; nested_vmx_succeed(vcpu); if (enable_shadow_vmcs) to_vmx(vcpu)->nested.sync_shadow_vmcs = true; } static int vmx_check_intercept(struct kvm_vcpu vcpu, struct x86_instruction_info info, enum x86_intercept_stage stage) { return X86EMUL_CONTINUE; } static void vmx_sched_in(struct kvm_vcpu vcpu, int cpu) { if (ple_gap) shrink_ple_window(vcpu); } static struct kvm_x86_ops vmx_x86_ops = { .cpu_has_kvm_support = cpu_has_kvm_support, .disabled_by_bios = vmx_disabled_by_bios, .hardware_setup = hardware_setup, .hardware_unsetup = hardware_unsetup, .check_processor_compatibility = vmx_check_processor_compat, .hardware_enable = hardware_enable, .hardware_disable = hardware_disable, .cpu_has_accelerated_tpr = report_flexpriority, .vcpu_create = vmx_create_vcpu, .vcpu_free = vmx_free_vcpu, .vcpu_reset = vmx_vcpu_reset, .prepare_guest_switch = vmx_save_host_state, .vcpu_load = vmx_vcpu_load, .vcpu_put = vmx_vcpu_put, .update_db_bp_intercept = update_exception_bitmap, .get_msr = vmx_get_msr, .set_msr = vmx_set_msr, .get_segment_base = vmx_get_segment_base, .get_segment = vmx_get_segment, .set_segment = vmx_set_segment, .get_cpl = vmx_get_cpl, .get_cs_db_l_bits = vmx_get_cs_db_l_bits, .decache_cr0_guest_bits = vmx_decache_cr0_guest_bits, .decache_cr3 = vmx_decache_cr3, .decache_cr4_guest_bits = vmx_decache_cr4_guest_bits, .set_cr0 = vmx_set_cr0, .set_cr3 = vmx_set_cr3, .set_cr4 = vmx_set_cr4, .set_efer = vmx_set_efer, .get_idt = vmx_get_idt, .set_idt = vmx_set_idt, .get_gdt = vmx_get_gdt, .set_gdt = vmx_set_gdt, .get_dr6 = vmx_get_dr6, .set_dr6 = vmx_set_dr6, .set_dr7 = vmx_set_dr7, .sync_dirty_debug_regs = vmx_sync_dirty_debug_regs, .cache_reg = vmx_cache_reg, .get_rflags = vmx_get_rflags, .set_rflags = vmx_set_rflags, .fpu_deactivate = vmx_fpu_deactivate, .tlb_flush = vmx_flush_tlb, .run = vmx_vcpu_run, .handle_exit = vmx_handle_exit, .skip_emulated_instruction = skip_emulated_instruction, .set_interrupt_shadow = vmx_set_interrupt_shadow, .get_interrupt_shadow = vmx_get_interrupt_shadow, .patch_hypercall = vmx_patch_hypercall, .set_irq = vmx_inject_irq, .set_nmi = vmx_inject_nmi, .queue_exception = vmx_queue_exception, .cancel_injection = vmx_cancel_injection, .interrupt_allowed = vmx_interrupt_allowed, .nmi_allowed = vmx_nmi_allowed, .get_nmi_mask = vmx_get_nmi_mask, .set_nmi_mask = vmx_set_nmi_mask, .enable_nmi_window = enable_nmi_window, .enable_irq_window = enable_irq_window, .update_cr8_intercept = update_cr8_intercept, .set_virtual_x2apic_mode = vmx_set_virtual_x2apic_mode, .set_apic_access_page_addr = vmx_set_apic_access_page_addr, .vm_has_apicv = vmx_vm_has_apicv, .load_eoi_exitmap = vmx_load_eoi_exitmap, .hwapic_irr_update = vmx_hwapic_irr_update, .hwapic_isr_update = vmx_hwapic_isr_update, .sync_pir_to_irr = vmx_sync_pir_to_irr, .deliver_posted_interrupt = vmx_deliver_posted_interrupt, .set_tss_addr = vmx_set_tss_addr, .get_tdp_level = get_ept_level, .get_mt_mask = vmx_get_mt_mask, .get_exit_info = vmx_get_exit_info, .get_lpage_level = vmx_get_lpage_level, .cpuid_update = vmx_cpuid_update, .rdtscp_supported = vmx_rdtscp_supported, .invpcid_supported = vmx_invpcid_supported, .set_supported_cpuid = vmx_set_supported_cpuid, .has_wbinvd_exit = cpu_has_vmx_wbinvd_exit, .set_tsc_khz = vmx_set_tsc_khz, .read_tsc_offset = vmx_read_tsc_offset, .write_tsc_offset = vmx_write_tsc_offset, .adjust_tsc_offset = vmx_adjust_tsc_offset, .compute_tsc_offset = vmx_compute_tsc_offset, .read_l1_tsc = vmx_read_l1_tsc, .set_tdp_cr3 = vmx_set_cr3, .check_intercept = vmx_check_intercept, .handle_external_intr = vmx_handle_external_intr, .mpx_supported = vmx_mpx_supported, .check_nested_events = vmx_check_nested_events, .sched_in = vmx_sched_in, }; static int __init vmx_init(void) { int r, i, msr; rdmsrl_safe(MSR_EFER, &host_efer); for (i = 0; i < ARRAY_SIZE(vmx_msr_index); ++i) kvm_define_shared_msr(i, vmx_msr_index[i]); vmx_io_bitmap_a = (unsigned long )__get_free_page(GFP_KERNEL); if (!vmx_io_bitmap_a) return -ENOMEM; r = -ENOMEM; vmx_io_bitmap_b = (unsigned long )__get_free_page(GFP_KERNEL); if (!vmx_io_bitmap_b) goto out; vmx_msr_bitmap_legacy = (unsigned long )__get_free_page(GFP_KERNEL); if (!vmx_msr_bitmap_legacy) goto out1; vmx_msr_bitmap_legacy_x2apic = (unsigned long )__get_free_page(GFP_KERNEL); if (!vmx_msr_bitmap_legacy_x2apic) goto out2; vmx_msr_bitmap_longmode = (unsigned long )__get_free_page(GFP_KERNEL); if (!vmx_msr_bitmap_longmode) goto out3; vmx_msr_bitmap_longmode_x2apic = (unsigned long )__get_free_page(GFP_KERNEL); if (!vmx_msr_bitmap_longmode_x2apic) goto out4; vmx_vmread_bitmap = (unsigned long )__get_free_page(GFP_KERNEL); if (!vmx_vmread_bitmap) goto out5; vmx_vmwrite_bitmap = (unsigned long )__get_free_page(GFP_KERNEL); if (!vmx_vmwrite_bitmap) goto out6; memset(vmx_vmread_bitmap, 0xff, PAGE_SIZE); memset(vmx_vmwrite_bitmap, 0xff, PAGE_SIZE); /* * Allow direct access to the PC debug port (it is often used for I/O * delays, but the vmexits simply slow things down). / memset(vmx_io_bitmap_a, 0xff, PAGE_SIZE); clear_bit(0x80, vmx_io_bitmap_a); memset(vmx_io_bitmap_b, 0xff, PAGE_SIZE); memset(vmx_msr_bitmap_legacy, 0xff, PAGE_SIZE); memset(vmx_msr_bitmap_longmode, 0xff, PAGE_SIZE); set_bit(0, vmx_vpid_bitmap); / 0 is reserved for host / r = kvm_init(&vmx_x86_ops, sizeof(struct vcpu_vmx), __alignof__(struct vcpu_vmx), THIS_MODULE); if (r) goto out7; #ifdef CONFIG_KEXEC rcu_assign_pointer(crash_vmclear_loaded_vmcss, crash_vmclear_local_loaded_vmcss); #endif vmx_disable_intercept_for_msr(MSR_FS_BASE, false); vmx_disable_intercept_for_msr(MSR_GS_BASE, false); vmx_disable_intercept_for_msr(MSR_KERNEL_GS_BASE, true); vmx_disable_intercept_for_msr(MSR_IA32_SYSENTER_CS, false); vmx_disable_intercept_for_msr(MSR_IA32_SYSENTER_ESP, false); vmx_disable_intercept_for_msr(MSR_IA32_SYSENTER_EIP, false); vmx_disable_intercept_for_msr(MSR_IA32_BNDCFGS, true); memcpy(vmx_msr_bitmap_legacy_x2apic, vmx_msr_bitmap_legacy, PAGE_SIZE); memcpy(vmx_msr_bitmap_longmode_x2apic, vmx_msr_bitmap_longmode, PAGE_SIZE); if (enable_apicv) { for (msr = 0x800; msr <= 0x8ff; msr++) vmx_disable_intercept_msr_read_x2apic(msr); / According SDM, in x2apic mode, the whole id reg is used. * But in KVM, it only use the highest eight bits. Need to * intercept it / vmx_enable_intercept_msr_read_x2apic(0x802); / TMCCT / vmx_enable_intercept_msr_read_x2apic(0x839); / TPR / vmx_disable_intercept_msr_write_x2apic(0x808); / EOI / vmx_disable_intercept_msr_write_x2apic(0x80b); / SELF-IPI */ vmx_disable_intercept_msr_write_x2apic(0x83f); } if (enable_ept) { kvm_mmu_set_mask_ptes(0ull, (enable_ept_ad_bits) ? VMX_EPT_ACCESS_BIT : 0ull, (enable_ept_ad_bits) ? VMX_EPT_DIRTY_BIT : 0ull, 0ull, VMX_EPT_EXECUTABLE_MASK); ept_set_mmio_spte_mask(); kvm_enable_tdp(); } else kvm_disable_tdp(); update_ple_window_actual_max(); return 0; out7: free_page((unsigned long)vmx_vmwrite_bitmap); out6: free_page((unsigned long)vmx_vmread_bitmap); out5: free_page((unsigned long)vmx_msr_bitmap_longmode_x2apic); out4: free_page((unsigned long)vmx_msr_bitmap_longmode); out3: free_page((unsigned long)vmx_msr_bitmap_legacy_x2apic); out2: free_page((unsigned long)vmx_msr_bitmap_legacy); out1: free_page((unsigned long)vmx_io_bitmap_b); out: free_page((unsigned long)vmx_io_bitmap_a); return r; } static void __exit vmx_exit(void) { free_page((unsigned long)vmx_msr_bitmap_legacy_x2apic); free_page((unsigned long)vmx_msr_bitmap_longmode_x2apic); free_page((unsigned long)vmx_msr_bitmap_legacy); free_page((unsigned long)vmx_msr_bitmap_longmode); free_page((unsigned long)vmx_io_bitmap_b); free_page((unsigned long)vmx_io_bitmap_a); free_page((unsigned long)vmx_vmwrite_bitmap); free_page((unsigned long)vmx_vmread_bitmap); #ifdef CONFIG_KEXEC RCU_INIT_POINTER(crash_vmclear_loaded_vmcss, NULL); synchronize_rcu(); #endif kvm_exit(); } module_init(vmx_init) module_exit(vmx_exit)	./CrossVul/dataset_final_sorted/CWE-264/c/good_2159_2
crossvul-cpp_data_bad_5861_19	/* Glue code for SHA256 hashing optimized for sparc64 crypto opcodes. * * This is based largely upon crypto/sha256_generic.c * * Copyright (c) Jean-Luc Cooke <jlcooke@certainkey.com> * Copyright (c) Andrew McDonald <andrew@mcdonald.org.uk> * Copyright (c) 2002 James Morris <jmorris@intercode.com.au> * SHA224 Support Copyright 2007 Intel Corporation <jonathan.lynch@intel.com> / #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt #include <crypto/internal/hash.h> #include <linux/init.h> #include <linux/module.h> #include <linux/mm.h> #include <linux/cryptohash.h> #include <linux/types.h> #include <crypto/sha.h> #include <asm/pstate.h> #include <asm/elf.h> #include "opcodes.h" asmlinkage void sha256_sparc64_transform(u32 digest, const char data, unsigned int rounds); static int sha224_sparc64_init(struct shash_desc desc) { struct sha256_state sctx = shash_desc_ctx(desc); sctx->state[0] = SHA224_H0; sctx->state[1] = SHA224_H1; sctx->state[2] = SHA224_H2; sctx->state[3] = SHA224_H3; sctx->state[4] = SHA224_H4; sctx->state[5] = SHA224_H5; sctx->state[6] = SHA224_H6; sctx->state[7] = SHA224_H7; sctx->count = 0; return 0; } static int sha256_sparc64_init(struct shash_desc desc) { struct sha256_state sctx = shash_desc_ctx(desc); sctx->state[0] = SHA256_H0; sctx->state[1] = SHA256_H1; sctx->state[2] = SHA256_H2; sctx->state[3] = SHA256_H3; sctx->state[4] = SHA256_H4; sctx->state[5] = SHA256_H5; sctx->state[6] = SHA256_H6; sctx->state[7] = SHA256_H7; sctx->count = 0; return 0; } static void __sha256_sparc64_update(struct sha256_state sctx, const u8 data, unsigned int len, unsigned int partial) { unsigned int done = 0; sctx->count += len; if (partial) { done = SHA256_BLOCK_SIZE - partial; memcpy(sctx->buf + partial, data, done); sha256_sparc64_transform(sctx->state, sctx->buf, 1); } if (len - done >= SHA256_BLOCK_SIZE) { const unsigned int rounds = (len - done) / SHA256_BLOCK_SIZE; sha256_sparc64_transform(sctx->state, data + done, rounds); done += rounds SHA256_BLOCK_SIZE; } memcpy(sctx->buf, data + done, len - done); } static int sha256_sparc64_update(struct shash_desc desc, const u8 data, unsigned int len) { struct sha256_state sctx = shash_desc_ctx(desc); unsigned int partial = sctx->count % SHA256_BLOCK_SIZE; / Handle the fast case right here / if (partial + len < SHA256_BLOCK_SIZE) { sctx->count += len; memcpy(sctx->buf + partial, data, len); } else __sha256_sparc64_update(sctx, data, len, partial); return 0; } static int sha256_sparc64_final(struct shash_desc desc, u8 out) { struct sha256_state sctx = shash_desc_ctx(desc); unsigned int i, index, padlen; __be32 dst = (__be32 )out; __be64 bits; static const u8 padding[SHA256_BLOCK_SIZE] = { 0x80, }; bits = cpu_to_be64(sctx->count << 3); /* Pad out to 56 mod 64 and append length / index = sctx->count % SHA256_BLOCK_SIZE; padlen = (index < 56) ? (56 - index) : ((SHA256_BLOCK_SIZE+56) - index); / We need to fill a whole block for __sha256_sparc64_update() / if (padlen <= 56) { sctx->count += padlen; memcpy(sctx->buf + index, padding, padlen); } else { __sha256_sparc64_update(sctx, padding, padlen, index); } __sha256_sparc64_update(sctx, (const u8 )&bits, sizeof(bits), 56); /* Store state in digest / for (i = 0; i < 8; i++) dst[i] = cpu_to_be32(sctx->state[i]); / Wipe context / memset(sctx, 0, sizeof(sctx)); return 0; } static int sha224_sparc64_final(struct shash_desc desc, u8 hash) { u8 D[SHA256_DIGEST_SIZE]; sha256_sparc64_final(desc, D); memcpy(hash, D, SHA224_DIGEST_SIZE); memset(D, 0, SHA256_DIGEST_SIZE); return 0; } static int sha256_sparc64_export(struct shash_desc desc, void out) { struct sha256_state sctx = shash_desc_ctx(desc); memcpy(out, sctx, sizeof(sctx)); return 0; } static int sha256_sparc64_import(struct shash_desc desc, const void in) { struct sha256_state sctx = shash_desc_ctx(desc); memcpy(sctx, in, sizeof(sctx)); return 0; } static struct shash_alg sha256 = { .digestsize = SHA256_DIGEST_SIZE, .init = sha256_sparc64_init, .update = sha256_sparc64_update, .final = sha256_sparc64_final, .export = sha256_sparc64_export, .import = sha256_sparc64_import, .descsize = sizeof(struct sha256_state), .statesize = sizeof(struct sha256_state), .base = { .cra_name = "sha256", .cra_driver_name= "sha256-sparc64", .cra_priority = SPARC_CR_OPCODE_PRIORITY, .cra_flags = CRYPTO_ALG_TYPE_SHASH, .cra_blocksize = SHA256_BLOCK_SIZE, .cra_module = THIS_MODULE, } }; static struct shash_alg sha224 = { .digestsize = SHA224_DIGEST_SIZE, .init = sha224_sparc64_init, .update = sha256_sparc64_update, .final = sha224_sparc64_final, .descsize = sizeof(struct sha256_state), .base = { .cra_name = "sha224", .cra_driver_name= "sha224-sparc64", .cra_priority = SPARC_CR_OPCODE_PRIORITY, .cra_flags = CRYPTO_ALG_TYPE_SHASH, .cra_blocksize = SHA224_BLOCK_SIZE, .cra_module = THIS_MODULE, } }; static bool __init sparc64_has_sha256_opcode(void) { unsigned long cfr; if (!(sparc64_elf_hwcap & HWCAP_SPARC_CRYPTO)) return false; __asm__ __volatile__("rd %%asr26, %0" : "=r" (cfr)); if (!(cfr & CFR_SHA256)) return false; return true; } static int __init sha256_sparc64_mod_init(void) { if (sparc64_has_sha256_opcode()) { int ret = crypto_register_shash(&sha224); if (ret < 0) return ret; ret = crypto_register_shash(&sha256); if (ret < 0) { crypto_unregister_shash(&sha224); return ret; } pr_info("Using sparc64 sha256 opcode optimized SHA-256/SHA-224 implementation\n"); return 0; } pr_info("sparc64 sha256 opcode not available.\n"); return -ENODEV; } static void __exit sha256_sparc64_mod_fini(void) { crypto_unregister_shash(&sha224); crypto_unregister_shash(&sha256); } module_init(sha256_sparc64_mod_init); module_exit(sha256_sparc64_mod_fini); MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("SHA-224 and SHA-256 Secure Hash Algorithm, sparc64 sha256 opcode accelerated"); MODULE_ALIAS("sha224"); MODULE_ALIAS("sha256"); #include "crop_devid.c"	./CrossVul/dataset_final_sorted/CWE-264/c/bad_5861_19
crossvul-cpp_data_bad_3423_0	/* * Copyright (C) 2008 IBM Corporation * Author: Mimi Zohar <zohar@us.ibm.com> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation, version 2 of the License. * * ima_policy.c * - initialize default measure policy rules * / #include <linux/module.h> #include <linux/list.h> #include <linux/security.h> #include <linux/magic.h> #include <linux/parser.h> #include <linux/slab.h> #include "ima.h" / flags definitions / #define IMA_FUNC 0x0001 #define IMA_MASK 0x0002 #define IMA_FSMAGIC 0x0004 #define IMA_UID 0x0008 enum ima_action { UNKNOWN = -1, DONT_MEASURE = 0, MEASURE }; #define MAX_LSM_RULES 6 enum lsm_rule_types { LSM_OBJ_USER, LSM_OBJ_ROLE, LSM_OBJ_TYPE, LSM_SUBJ_USER, LSM_SUBJ_ROLE, LSM_SUBJ_TYPE }; struct ima_measure_rule_entry { struct list_head list; enum ima_action action; unsigned int flags; enum ima_hooks func; int mask; unsigned long fsmagic; uid_t uid; struct { void rule; /* LSM file metadata specific / int type; / audit type / } lsm[MAX_LSM_RULES]; }; / * Without LSM specific knowledge, the default policy can only be * written in terms of .action, .func, .mask, .fsmagic, and .uid / / * The minimum rule set to allow for full TCB coverage. Measures all files * opened or mmap for exec and everything read by root. Dangerous because * normal users can easily run the machine out of memory simply building * and running executables. / static struct ima_measure_rule_entry default_rules[] = { {.action = DONT_MEASURE,.fsmagic = PROC_SUPER_MAGIC,.flags = IMA_FSMAGIC}, {.action = DONT_MEASURE,.fsmagic = SYSFS_MAGIC,.flags = IMA_FSMAGIC}, {.action = DONT_MEASURE,.fsmagic = DEBUGFS_MAGIC,.flags = IMA_FSMAGIC}, {.action = DONT_MEASURE,.fsmagic = TMPFS_MAGIC,.flags = IMA_FSMAGIC}, {.action = DONT_MEASURE,.fsmagic = SECURITYFS_MAGIC,.flags = IMA_FSMAGIC}, {.action = DONT_MEASURE,.fsmagic = SELINUX_MAGIC,.flags = IMA_FSMAGIC}, {.action = MEASURE,.func = FILE_MMAP,.mask = MAY_EXEC, .flags = IMA_FUNC \| IMA_MASK}, {.action = MEASURE,.func = BPRM_CHECK,.mask = MAY_EXEC, .flags = IMA_FUNC \| IMA_MASK}, {.action = MEASURE,.func = FILE_CHECK,.mask = MAY_READ,.uid = 0, .flags = IMA_FUNC \| IMA_MASK \| IMA_UID}, }; static LIST_HEAD(measure_default_rules); static LIST_HEAD(measure_policy_rules); static struct list_head ima_measure; static DEFINE_MUTEX(ima_measure_mutex); static bool ima_use_tcb __initdata; static int __init default_policy_setup(char str) { ima_use_tcb = 1; return 1; } __setup("ima_tcb", default_policy_setup); /* * ima_match_rules - determine whether an inode matches the measure rule. * @rule: a pointer to a rule * @inode: a pointer to an inode * @func: LIM hook identifier * @mask: requested action (MAY_READ \| MAY_WRITE \| MAY_APPEND \| MAY_EXEC) * * Returns true on rule match, false on failure. / static bool ima_match_rules(struct ima_measure_rule_entry rule, struct inode inode, enum ima_hooks func, int mask) { struct task_struct tsk = current; int i; if ((rule->flags & IMA_FUNC) && rule->func != func) return false; if ((rule->flags & IMA_MASK) && rule->mask != mask) return false; if ((rule->flags & IMA_FSMAGIC) && rule->fsmagic != inode->i_sb->s_magic) return false; if ((rule->flags & IMA_UID) && rule->uid != tsk->cred->uid) return false; for (i = 0; i < MAX_LSM_RULES; i++) { int rc = 0; u32 osid, sid; if (!rule->lsm[i].rule) continue; switch (i) { case LSM_OBJ_USER: case LSM_OBJ_ROLE: case LSM_OBJ_TYPE: security_inode_getsecid(inode, &osid); rc = security_filter_rule_match(osid, rule->lsm[i].type, Audit_equal, rule->lsm[i].rule, NULL); break; case LSM_SUBJ_USER: case LSM_SUBJ_ROLE: case LSM_SUBJ_TYPE: security_task_getsecid(tsk, &sid); rc = security_filter_rule_match(sid, rule->lsm[i].type, Audit_equal, rule->lsm[i].rule, NULL); default: break; } if (!rc) return false; } return true; } /** * ima_match_policy - decision based on LSM and other conditions * @inode: pointer to an inode for which the policy decision is being made * @func: IMA hook identifier * @mask: requested action (MAY_READ \| MAY_WRITE \| MAY_APPEND \| MAY_EXEC) * * Measure decision based on func/mask/fsmagic and LSM(subj/obj/type) * conditions. * * (There is no need for locking when walking the policy list, * as elements in the list are never deleted, nor does the list * change.) / int ima_match_policy(struct inode inode, enum ima_hooks func, int mask) { struct ima_measure_rule_entry entry; list_for_each_entry(entry, ima_measure, list) { bool rc; rc = ima_match_rules(entry, inode, func, mask); if (rc) return entry->action; } return 0; } /* * ima_init_policy - initialize the default measure rules. * * ima_measure points to either the measure_default_rules or the * the new measure_policy_rules. / void __init ima_init_policy(void) { int i, entries; / if !ima_use_tcb set entries = 0 so we load NO default rules / if (ima_use_tcb) entries = ARRAY_SIZE(default_rules); else entries = 0; for (i = 0; i < entries; i++) list_add_tail(&default_rules[i].list, &measure_default_rules); ima_measure = &measure_default_rules; } /* * ima_update_policy - update default_rules with new measure rules * * Called on file .release to update the default rules with a complete new * policy. Once updated, the policy is locked, no additional rules can be * added to the policy. / void ima_update_policy(void) { const char op = "policy_update"; const char cause = "already exists"; int result = 1; int audit_info = 0; if (ima_measure == &measure_default_rules) { ima_measure = &measure_policy_rules; cause = "complete"; result = 0; } integrity_audit_msg(AUDIT_INTEGRITY_STATUS, NULL, NULL, op, cause, result, audit_info); } enum { Opt_err = -1, Opt_measure = 1, Opt_dont_measure, Opt_obj_user, Opt_obj_role, Opt_obj_type, Opt_subj_user, Opt_subj_role, Opt_subj_type, Opt_func, Opt_mask, Opt_fsmagic, Opt_uid }; static match_table_t policy_tokens = { {Opt_measure, "measure"}, {Opt_dont_measure, "dont_measure"}, {Opt_obj_user, "obj_user=%s"}, {Opt_obj_role, "obj_role=%s"}, {Opt_obj_type, "obj_type=%s"}, {Opt_subj_user, "subj_user=%s"}, {Opt_subj_role, "subj_role=%s"}, {Opt_subj_type, "subj_type=%s"}, {Opt_func, "func=%s"}, {Opt_mask, "mask=%s"}, {Opt_fsmagic, "fsmagic=%s"}, {Opt_uid, "uid=%s"}, {Opt_err, NULL} }; static int ima_lsm_rule_init(struct ima_measure_rule_entry entry, char args, int lsm_rule, int audit_type) { int result; if (entry->lsm[lsm_rule].rule) return -EINVAL; entry->lsm[lsm_rule].type = audit_type; result = security_filter_rule_init(entry->lsm[lsm_rule].type, Audit_equal, args, &entry->lsm[lsm_rule].rule); return result; } static void ima_log_string(struct audit_buffer ab, char key, char value) { audit_log_format(ab, "%s=", key); audit_log_untrustedstring(ab, value); audit_log_format(ab, " "); } static int ima_parse_rule(char rule, struct ima_measure_rule_entry entry) { struct audit_buffer ab; char p; int result = 0; ab = audit_log_start(NULL, GFP_KERNEL, AUDIT_INTEGRITY_RULE); entry->uid = -1; entry->action = UNKNOWN; while ((p = strsep(&rule, " \t")) != NULL) { substring_t args[MAX_OPT_ARGS]; int token; unsigned long lnum; if (result < 0) break; if ((p == '\0') \|\| (p == ' ') \|\| (p == '\t')) continue; token = match_token(p, policy_tokens, args); switch (token) { case Opt_measure: ima_log_string(ab, "action", "measure"); if (entry->action != UNKNOWN) result = -EINVAL; entry->action = MEASURE; break; case Opt_dont_measure: ima_log_string(ab, "action", "dont_measure"); if (entry->action != UNKNOWN) result = -EINVAL; entry->action = DONT_MEASURE; break; case Opt_func: ima_log_string(ab, "func", args[0].from); if (entry->func) result = -EINVAL; if (strcmp(args[0].from, "FILE_CHECK") == 0) entry->func = FILE_CHECK; / PATH_CHECK is for backwards compat / else if (strcmp(args[0].from, "PATH_CHECK") == 0) entry->func = FILE_CHECK; else if (strcmp(args[0].from, "FILE_MMAP") == 0) entry->func = FILE_MMAP; else if (strcmp(args[0].from, "BPRM_CHECK") == 0) entry->func = BPRM_CHECK; else result = -EINVAL; if (!result) entry->flags \|= IMA_FUNC; break; case Opt_mask: ima_log_string(ab, "mask", args[0].from); if (entry->mask) result = -EINVAL; if ((strcmp(args[0].from, "MAY_EXEC")) == 0) entry->mask = MAY_EXEC; else if (strcmp(args[0].from, "MAY_WRITE") == 0) entry->mask = MAY_WRITE; else if (strcmp(args[0].from, "MAY_READ") == 0) entry->mask = MAY_READ; else if (strcmp(args[0].from, "MAY_APPEND") == 0) entry->mask = MAY_APPEND; else result = -EINVAL; if (!result) entry->flags \|= IMA_MASK; break; case Opt_fsmagic: ima_log_string(ab, "fsmagic", args[0].from); if (entry->fsmagic) { result = -EINVAL; break; } result = strict_strtoul(args[0].from, 16, &entry->fsmagic); if (!result) entry->flags \|= IMA_FSMAGIC; break; case Opt_uid: ima_log_string(ab, "uid", args[0].from); if (entry->uid != -1) { result = -EINVAL; break; } result = strict_strtoul(args[0].from, 10, &lnum); if (!result) { entry->uid = (uid_t) lnum; if (entry->uid != lnum) result = -EINVAL; else entry->flags \|= IMA_UID; } break; case Opt_obj_user: ima_log_string(ab, "obj_user", args[0].from); result = ima_lsm_rule_init(entry, args[0].from, LSM_OBJ_USER, AUDIT_OBJ_USER); break; case Opt_obj_role: ima_log_string(ab, "obj_role", args[0].from); result = ima_lsm_rule_init(entry, args[0].from, LSM_OBJ_ROLE, AUDIT_OBJ_ROLE); break; case Opt_obj_type: ima_log_string(ab, "obj_type", args[0].from); result = ima_lsm_rule_init(entry, args[0].from, LSM_OBJ_TYPE, AUDIT_OBJ_TYPE); break; case Opt_subj_user: ima_log_string(ab, "subj_user", args[0].from); result = ima_lsm_rule_init(entry, args[0].from, LSM_SUBJ_USER, AUDIT_SUBJ_USER); break; case Opt_subj_role: ima_log_string(ab, "subj_role", args[0].from); result = ima_lsm_rule_init(entry, args[0].from, LSM_SUBJ_ROLE, AUDIT_SUBJ_ROLE); break; case Opt_subj_type: ima_log_string(ab, "subj_type", args[0].from); result = ima_lsm_rule_init(entry, args[0].from, LSM_SUBJ_TYPE, AUDIT_SUBJ_TYPE); break; case Opt_err: ima_log_string(ab, "UNKNOWN", p); result = -EINVAL; break; } } if (!result && (entry->action == UNKNOWN)) result = -EINVAL; audit_log_format(ab, "res=%d", !!result); audit_log_end(ab); return result; } /* * ima_parse_add_rule - add a rule to measure_policy_rules * @rule - ima measurement policy rule * * Uses a mutex to protect the policy list from multiple concurrent writers. * Returns the length of the rule parsed, an error code on failure / ssize_t ima_parse_add_rule(char rule) { const char op = "update_policy"; char p; struct ima_measure_rule_entry entry; ssize_t result, len; int audit_info = 0; / Prevent installed policy from changing / if (ima_measure != &measure_default_rules) { integrity_audit_msg(AUDIT_INTEGRITY_STATUS, NULL, NULL, op, "already exists", -EACCES, audit_info); return -EACCES; } entry = kzalloc(sizeof(entry), GFP_KERNEL); if (!entry) { integrity_audit_msg(AUDIT_INTEGRITY_STATUS, NULL, NULL, op, "-ENOMEM", -ENOMEM, audit_info); return -ENOMEM; } INIT_LIST_HEAD(&entry->list); p = strsep(&rule, "\n"); len = strlen(p) + 1; if (p == '#') { kfree(entry); return len; } result = ima_parse_rule(p, entry); if (result) { kfree(entry); integrity_audit_msg(AUDIT_INTEGRITY_STATUS, NULL, NULL, op, "invalid policy", result, audit_info); return result; } mutex_lock(&ima_measure_mutex); list_add_tail(&entry->list, &measure_policy_rules); mutex_unlock(&ima_measure_mutex); return len; } / ima_delete_rules called to cleanup invalid policy / void ima_delete_rules(void) { struct ima_measure_rule_entry entry, *tmp; mutex_lock(&ima_measure_mutex); list_for_each_entry_safe(entry, tmp, &measure_policy_rules, list) { list_del(&entry->list); kfree(entry); } mutex_unlock(&ima_measure_mutex); }	./CrossVul/dataset_final_sorted/CWE-264/c/bad_3423_0
crossvul-cpp_data_bad_2164_0	/****************************************************************************** * emulate.c * * Generic x86 (32-bit and 64-bit) instruction decoder and emulator. * * Copyright (c) 2005 Keir Fraser * * Linux coding style, mod r/m decoder, segment base fixes, real-mode * privileged instructions: * * Copyright (C) 2006 Qumranet * Copyright 2010 Red Hat, Inc. and/or its affiliates. * * Avi Kivity <avi@qumranet.com> * Yaniv Kamay <yaniv@qumranet.com> * * This work is licensed under the terms of the GNU GPL, version 2. See * the COPYING file in the top-level directory. * * From: xen-unstable 10676:af9809f51f81a3c43f276f00c81a52ef558afda4 / #include <linux/kvm_host.h> #include "kvm_cache_regs.h" #include <linux/module.h> #include <asm/kvm_emulate.h> #include <linux/stringify.h> #include "x86.h" #include "tss.h" / * Operand types / #define OpNone 0ull #define OpImplicit 1ull / No generic decode / #define OpReg 2ull / Register / #define OpMem 3ull / Memory / #define OpAcc 4ull / Accumulator: AL/AX/EAX/RAX / #define OpDI 5ull / ES:DI/EDI/RDI / #define OpMem64 6ull / Memory, 64-bit / #define OpImmUByte 7ull / Zero-extended 8-bit immediate / #define OpDX 8ull / DX register / #define OpCL 9ull / CL register (for shifts) / #define OpImmByte 10ull / 8-bit sign extended immediate / #define OpOne 11ull / Implied 1 / #define OpImm 12ull / Sign extended up to 32-bit immediate / #define OpMem16 13ull / Memory operand (16-bit). / #define OpMem32 14ull / Memory operand (32-bit). / #define OpImmU 15ull / Immediate operand, zero extended / #define OpSI 16ull / SI/ESI/RSI / #define OpImmFAddr 17ull / Immediate far address / #define OpMemFAddr 18ull / Far address in memory / #define OpImmU16 19ull / Immediate operand, 16 bits, zero extended / #define OpES 20ull / ES / #define OpCS 21ull / CS / #define OpSS 22ull / SS / #define OpDS 23ull / DS / #define OpFS 24ull / FS / #define OpGS 25ull / GS / #define OpMem8 26ull / 8-bit zero extended memory operand / #define OpImm64 27ull / Sign extended 16/32/64-bit immediate / #define OpXLat 28ull / memory at BX/EBX/RBX + zero-extended AL / #define OpAccLo 29ull / Low part of extended acc (AX/AX/EAX/RAX) / #define OpAccHi 30ull / High part of extended acc (-/DX/EDX/RDX) / #define OpBits 5 / Width of operand field / #define OpMask ((1ull << OpBits) - 1) / * Opcode effective-address decode tables. * Note that we only emulate instructions that have at least one memory * operand (excluding implicit stack references). We assume that stack * references and instruction fetches will never occur in special memory * areas that require emulation. So, for example, 'mov <imm>,<reg>' need * not be handled. / / Operand sizes: 8-bit operands or specified/overridden size. / #define ByteOp (1<<0) / 8-bit operands. / / Destination operand type. / #define DstShift 1 #define ImplicitOps (OpImplicit << DstShift) #define DstReg (OpReg << DstShift) #define DstMem (OpMem << DstShift) #define DstAcc (OpAcc << DstShift) #define DstDI (OpDI << DstShift) #define DstMem64 (OpMem64 << DstShift) #define DstImmUByte (OpImmUByte << DstShift) #define DstDX (OpDX << DstShift) #define DstAccLo (OpAccLo << DstShift) #define DstMask (OpMask << DstShift) / Source operand type. / #define SrcShift 6 #define SrcNone (OpNone << SrcShift) #define SrcReg (OpReg << SrcShift) #define SrcMem (OpMem << SrcShift) #define SrcMem16 (OpMem16 << SrcShift) #define SrcMem32 (OpMem32 << SrcShift) #define SrcImm (OpImm << SrcShift) #define SrcImmByte (OpImmByte << SrcShift) #define SrcOne (OpOne << SrcShift) #define SrcImmUByte (OpImmUByte << SrcShift) #define SrcImmU (OpImmU << SrcShift) #define SrcSI (OpSI << SrcShift) #define SrcXLat (OpXLat << SrcShift) #define SrcImmFAddr (OpImmFAddr << SrcShift) #define SrcMemFAddr (OpMemFAddr << SrcShift) #define SrcAcc (OpAcc << SrcShift) #define SrcImmU16 (OpImmU16 << SrcShift) #define SrcImm64 (OpImm64 << SrcShift) #define SrcDX (OpDX << SrcShift) #define SrcMem8 (OpMem8 << SrcShift) #define SrcAccHi (OpAccHi << SrcShift) #define SrcMask (OpMask << SrcShift) #define BitOp (1<<11) #define MemAbs (1<<12) / Memory operand is absolute displacement / #define String (1<<13) / String instruction (rep capable) / #define Stack (1<<14) / Stack instruction (push/pop) / #define GroupMask (7<<15) / Opcode uses one of the group mechanisms / #define Group (1<<15) / Bits 3:5 of modrm byte extend opcode / #define GroupDual (2<<15) / Alternate decoding of mod == 3 / #define Prefix (3<<15) / Instruction varies with 66/f2/f3 prefix / #define RMExt (4<<15) / Opcode extension in ModRM r/m if mod == 3 / #define Escape (5<<15) / Escape to coprocessor instruction / #define Sse (1<<18) / SSE Vector instruction / / Generic ModRM decode. / #define ModRM (1<<19) / Destination is only written; never read. / #define Mov (1<<20) / Misc flags / #define Prot (1<<21) / instruction generates #UD if not in prot-mode / #define EmulateOnUD (1<<22) / Emulate if unsupported by the host / #define NoAccess (1<<23) / Don't access memory (lea/invlpg/verr etc) / #define Op3264 (1<<24) / Operand is 64b in long mode, 32b otherwise / #define Undefined (1<<25) / No Such Instruction / #define Lock (1<<26) / lock prefix is allowed for the instruction / #define Priv (1<<27) / instruction generates #GP if current CPL != 0 / #define No64 (1<<28) #define PageTable (1 << 29) / instruction used to write page table / #define NotImpl (1 << 30) / instruction is not implemented / / Source 2 operand type / #define Src2Shift (31) #define Src2None (OpNone << Src2Shift) #define Src2Mem (OpMem << Src2Shift) #define Src2CL (OpCL << Src2Shift) #define Src2ImmByte (OpImmByte << Src2Shift) #define Src2One (OpOne << Src2Shift) #define Src2Imm (OpImm << Src2Shift) #define Src2ES (OpES << Src2Shift) #define Src2CS (OpCS << Src2Shift) #define Src2SS (OpSS << Src2Shift) #define Src2DS (OpDS << Src2Shift) #define Src2FS (OpFS << Src2Shift) #define Src2GS (OpGS << Src2Shift) #define Src2Mask (OpMask << Src2Shift) #define Mmx ((u64)1 << 40) / MMX Vector instruction / #define Aligned ((u64)1 << 41) / Explicitly aligned (e.g. MOVDQA) / #define Unaligned ((u64)1 << 42) / Explicitly unaligned (e.g. MOVDQU) / #define Avx ((u64)1 << 43) / Advanced Vector Extensions / #define Fastop ((u64)1 << 44) / Use opcode::u.fastop / #define NoWrite ((u64)1 << 45) / No writeback / #define SrcWrite ((u64)1 << 46) / Write back src operand / #define NoMod ((u64)1 << 47) / Mod field is ignored / #define Intercept ((u64)1 << 48) / Has valid intercept field / #define CheckPerm ((u64)1 << 49) / Has valid check_perm field / #define NoBigReal ((u64)1 << 50) / No big real mode / #define PrivUD ((u64)1 << 51) / #UD instead of #GP on CPL > 0 / #define DstXacc (DstAccLo \| SrcAccHi \| SrcWrite) #define X2(x...) x, x #define X3(x...) X2(x), x #define X4(x...) X2(x), X2(x) #define X5(x...) X4(x), x #define X6(x...) X4(x), X2(x) #define X7(x...) X4(x), X3(x) #define X8(x...) X4(x), X4(x) #define X16(x...) X8(x), X8(x) #define NR_FASTOP (ilog2(sizeof(ulong)) + 1) #define FASTOP_SIZE 8 / * fastop functions have a special calling convention: * * dst: rax (in/out) * src: rdx (in/out) * src2: rcx (in) * flags: rflags (in/out) * ex: rsi (in:fastop pointer, out:zero if exception) * * Moreover, they are all exactly FASTOP_SIZE bytes long, so functions for * different operand sizes can be reached by calculation, rather than a jump * table (which would be bigger than the code). * * fastop functions are declared as taking a never-defined fastop parameter, * so they can't be called from C directly. / struct fastop; struct opcode { u64 flags : 56; u64 intercept : 8; union { int (execute)(struct x86_emulate_ctxt ctxt); const struct opcode group; const struct group_dual gdual; const struct gprefix gprefix; const struct escape esc; void (fastop)(struct fastop fake); } u; int (check_perm)(struct x86_emulate_ctxt ctxt); }; struct group_dual { struct opcode mod012[8]; struct opcode mod3[8]; }; struct gprefix { struct opcode pfx_no; struct opcode pfx_66; struct opcode pfx_f2; struct opcode pfx_f3; }; struct escape { struct opcode op[8]; struct opcode high[64]; }; / EFLAGS bit definitions. / #define EFLG_ID (1<<21) #define EFLG_VIP (1<<20) #define EFLG_VIF (1<<19) #define EFLG_AC (1<<18) #define EFLG_VM (1<<17) #define EFLG_RF (1<<16) #define EFLG_IOPL (3<<12) #define EFLG_NT (1<<14) #define EFLG_OF (1<<11) #define EFLG_DF (1<<10) #define EFLG_IF (1<<9) #define EFLG_TF (1<<8) #define EFLG_SF (1<<7) #define EFLG_ZF (1<<6) #define EFLG_AF (1<<4) #define EFLG_PF (1<<2) #define EFLG_CF (1<<0) #define EFLG_RESERVED_ZEROS_MASK 0xffc0802a #define EFLG_RESERVED_ONE_MASK 2 static ulong reg_read(struct x86_emulate_ctxt ctxt, unsigned nr) { if (!(ctxt->regs_valid & (1 << nr))) { ctxt->regs_valid \|= 1 << nr; ctxt->_regs[nr] = ctxt->ops->read_gpr(ctxt, nr); } return ctxt->_regs[nr]; } static ulong reg_write(struct x86_emulate_ctxt ctxt, unsigned nr) { ctxt->regs_valid \|= 1 << nr; ctxt->regs_dirty \|= 1 << nr; return &ctxt->_regs[nr]; } static ulong reg_rmw(struct x86_emulate_ctxt ctxt, unsigned nr) { reg_read(ctxt, nr); return reg_write(ctxt, nr); } static void writeback_registers(struct x86_emulate_ctxt ctxt) { unsigned reg; for_each_set_bit(reg, (ulong )&ctxt->regs_dirty, 16) ctxt->ops->write_gpr(ctxt, reg, ctxt->_regs[reg]); } static void invalidate_registers(struct x86_emulate_ctxt ctxt) { ctxt->regs_dirty = 0; ctxt->regs_valid = 0; } / * These EFLAGS bits are restored from saved value during emulation, and * any changes are written back to the saved value after emulation. / #define EFLAGS_MASK (EFLG_OF\|EFLG_SF\|EFLG_ZF\|EFLG_AF\|EFLG_PF\|EFLG_CF) #ifdef CONFIG_X86_64 #define ON64(x) x #else #define ON64(x) #endif static int fastop(struct x86_emulate_ctxt ctxt, void (fop)(struct fastop )); #define FOP_ALIGN ".align " __stringify(FASTOP_SIZE) " \n\t" #define FOP_RET "ret \n\t" #define FOP_START(op) \ extern void em_##op(struct fastop fake); \ asm(".pushsection .text, \"ax\" \n\t" \ ".global em_" #op " \n\t" \ FOP_ALIGN \ "em_" #op ": \n\t" #define FOP_END \ ".popsection") #define FOPNOP() FOP_ALIGN FOP_RET #define FOP1E(op, dst) \ FOP_ALIGN "10: " #op " %" #dst " \n\t" FOP_RET #define FOP1EEX(op, dst) \ FOP1E(op, dst) _ASM_EXTABLE(10b, kvm_fastop_exception) #define FASTOP1(op) \ FOP_START(op) \ FOP1E(op##b, al) \ FOP1E(op##w, ax) \ FOP1E(op##l, eax) \ ON64(FOP1E(op##q, rax)) \ FOP_END / 1-operand, using src2 (for MUL/DIV r/m) / #define FASTOP1SRC2(op, name) \ FOP_START(name) \ FOP1E(op, cl) \ FOP1E(op, cx) \ FOP1E(op, ecx) \ ON64(FOP1E(op, rcx)) \ FOP_END / 1-operand, using src2 (for MUL/DIV r/m), with exceptions / #define FASTOP1SRC2EX(op, name) \ FOP_START(name) \ FOP1EEX(op, cl) \ FOP1EEX(op, cx) \ FOP1EEX(op, ecx) \ ON64(FOP1EEX(op, rcx)) \ FOP_END #define FOP2E(op, dst, src) \ FOP_ALIGN #op " %" #src ", %" #dst " \n\t" FOP_RET #define FASTOP2(op) \ FOP_START(op) \ FOP2E(op##b, al, dl) \ FOP2E(op##w, ax, dx) \ FOP2E(op##l, eax, edx) \ ON64(FOP2E(op##q, rax, rdx)) \ FOP_END / 2 operand, word only / #define FASTOP2W(op) \ FOP_START(op) \ FOPNOP() \ FOP2E(op##w, ax, dx) \ FOP2E(op##l, eax, edx) \ ON64(FOP2E(op##q, rax, rdx)) \ FOP_END / 2 operand, src is CL / #define FASTOP2CL(op) \ FOP_START(op) \ FOP2E(op##b, al, cl) \ FOP2E(op##w, ax, cl) \ FOP2E(op##l, eax, cl) \ ON64(FOP2E(op##q, rax, cl)) \ FOP_END #define FOP3E(op, dst, src, src2) \ FOP_ALIGN #op " %" #src2 ", %" #src ", %" #dst " \n\t" FOP_RET / 3-operand, word-only, src2=cl / #define FASTOP3WCL(op) \ FOP_START(op) \ FOPNOP() \ FOP3E(op##w, ax, dx, cl) \ FOP3E(op##l, eax, edx, cl) \ ON64(FOP3E(op##q, rax, rdx, cl)) \ FOP_END / Special case for SETcc - 1 instruction per cc / #define FOP_SETCC(op) ".align 4; " #op " %al; ret \n\t" asm(".global kvm_fastop_exception \n" "kvm_fastop_exception: xor %esi, %esi; ret"); FOP_START(setcc) FOP_SETCC(seto) FOP_SETCC(setno) FOP_SETCC(setc) FOP_SETCC(setnc) FOP_SETCC(setz) FOP_SETCC(setnz) FOP_SETCC(setbe) FOP_SETCC(setnbe) FOP_SETCC(sets) FOP_SETCC(setns) FOP_SETCC(setp) FOP_SETCC(setnp) FOP_SETCC(setl) FOP_SETCC(setnl) FOP_SETCC(setle) FOP_SETCC(setnle) FOP_END; FOP_START(salc) "pushf; sbb %al, %al; popf \n\t" FOP_RET FOP_END; static int emulator_check_intercept(struct x86_emulate_ctxt ctxt, enum x86_intercept intercept, enum x86_intercept_stage stage) { struct x86_instruction_info info = { .intercept = intercept, .rep_prefix = ctxt->rep_prefix, .modrm_mod = ctxt->modrm_mod, .modrm_reg = ctxt->modrm_reg, .modrm_rm = ctxt->modrm_rm, .src_val = ctxt->src.val64, .dst_val = ctxt->dst.val64, .src_bytes = ctxt->src.bytes, .dst_bytes = ctxt->dst.bytes, .ad_bytes = ctxt->ad_bytes, .next_rip = ctxt->eip, }; return ctxt->ops->intercept(ctxt, &info, stage); } static void assign_masked(ulong dest, ulong src, ulong mask) { dest = (dest & ~mask) \| (src & mask); } static inline unsigned long ad_mask(struct x86_emulate_ctxt ctxt) { return (1UL << (ctxt->ad_bytes << 3)) - 1; } static ulong stack_mask(struct x86_emulate_ctxt ctxt) { u16 sel; struct desc_struct ss; if (ctxt->mode == X86EMUL_MODE_PROT64) return ~0UL; ctxt->ops->get_segment(ctxt, &sel, &ss, NULL, VCPU_SREG_SS); return ~0U >> ((ss.d ^ 1) 16); /* d=0: 0xffff; d=1: 0xffffffff / } static int stack_size(struct x86_emulate_ctxt ctxt) { return (__fls(stack_mask(ctxt)) + 1) >> 3; } /* Access/update address held in a register, based on addressing mode. / static inline unsigned long address_mask(struct x86_emulate_ctxt ctxt, unsigned long reg) { if (ctxt->ad_bytes == sizeof(unsigned long)) return reg; else return reg & ad_mask(ctxt); } static inline unsigned long register_address(struct x86_emulate_ctxt ctxt, unsigned long reg) { return address_mask(ctxt, reg); } static void masked_increment(ulong reg, ulong mask, int inc) { assign_masked(reg, reg + inc, mask); } static inline void register_address_increment(struct x86_emulate_ctxt ctxt, unsigned long reg, int inc) { ulong mask; if (ctxt->ad_bytes == sizeof(unsigned long)) mask = ~0UL; else mask = ad_mask(ctxt); masked_increment(reg, mask, inc); } static void rsp_increment(struct x86_emulate_ctxt ctxt, int inc) { masked_increment(reg_rmw(ctxt, VCPU_REGS_RSP), stack_mask(ctxt), inc); } static u32 desc_limit_scaled(struct desc_struct desc) { u32 limit = get_desc_limit(desc); return desc->g ? (limit << 12) \| 0xfff : limit; } static unsigned long seg_base(struct x86_emulate_ctxt ctxt, int seg) { if (ctxt->mode == X86EMUL_MODE_PROT64 && seg < VCPU_SREG_FS) return 0; return ctxt->ops->get_cached_segment_base(ctxt, seg); } static int emulate_exception(struct x86_emulate_ctxt ctxt, int vec, u32 error, bool valid) { WARN_ON(vec > 0x1f); ctxt->exception.vector = vec; ctxt->exception.error_code = error; ctxt->exception.error_code_valid = valid; return X86EMUL_PROPAGATE_FAULT; } static int emulate_db(struct x86_emulate_ctxt ctxt) { return emulate_exception(ctxt, DB_VECTOR, 0, false); } static int emulate_gp(struct x86_emulate_ctxt ctxt, int err) { return emulate_exception(ctxt, GP_VECTOR, err, true); } static int emulate_ss(struct x86_emulate_ctxt ctxt, int err) { return emulate_exception(ctxt, SS_VECTOR, err, true); } static int emulate_ud(struct x86_emulate_ctxt ctxt) { return emulate_exception(ctxt, UD_VECTOR, 0, false); } static int emulate_ts(struct x86_emulate_ctxt ctxt, int err) { return emulate_exception(ctxt, TS_VECTOR, err, true); } static int emulate_de(struct x86_emulate_ctxt ctxt) { return emulate_exception(ctxt, DE_VECTOR, 0, false); } static int emulate_nm(struct x86_emulate_ctxt ctxt) { return emulate_exception(ctxt, NM_VECTOR, 0, false); } static inline void assign_eip_near(struct x86_emulate_ctxt ctxt, ulong dst) { switch (ctxt->op_bytes) { case 2: ctxt->_eip = (u16)dst; break; case 4: ctxt->_eip = (u32)dst; break; case 8: ctxt->_eip = dst; break; default: WARN(1, "unsupported eip assignment size\n"); } } static inline void jmp_rel(struct x86_emulate_ctxt ctxt, int rel) { assign_eip_near(ctxt, ctxt->_eip + rel); } static u16 get_segment_selector(struct x86_emulate_ctxt ctxt, unsigned seg) { u16 selector; struct desc_struct desc; ctxt->ops->get_segment(ctxt, &selector, &desc, NULL, seg); return selector; } static void set_segment_selector(struct x86_emulate_ctxt ctxt, u16 selector, unsigned seg) { u16 dummy; u32 base3; struct desc_struct desc; ctxt->ops->get_segment(ctxt, &dummy, &desc, &base3, seg); ctxt->ops->set_segment(ctxt, selector, &desc, base3, seg); } /* * x86 defines three classes of vector instructions: explicitly * aligned, explicitly unaligned, and the rest, which change behaviour * depending on whether they're AVX encoded or not. * * Also included is CMPXCHG16B which is not a vector instruction, yet it is * subject to the same check. / static bool insn_aligned(struct x86_emulate_ctxt ctxt, unsigned size) { if (likely(size < 16)) return false; if (ctxt->d & Aligned) return true; else if (ctxt->d & Unaligned) return false; else if (ctxt->d & Avx) return false; else return true; } static int __linearize(struct x86_emulate_ctxt ctxt, struct segmented_address addr, unsigned size, bool write, bool fetch, ulong linear) { struct desc_struct desc; bool usable; ulong la; u32 lim; u16 sel; unsigned cpl; la = seg_base(ctxt, addr.seg) + addr.ea; switch (ctxt->mode) { case X86EMUL_MODE_PROT64: if (((signed long)la << 16) >> 16 != la) return emulate_gp(ctxt, 0); break; default: usable = ctxt->ops->get_segment(ctxt, &sel, &desc, NULL, addr.seg); if (!usable) goto bad; /* code segment in protected mode or read-only data segment / if ((((ctxt->mode != X86EMUL_MODE_REAL) && (desc.type & 8)) \|\| !(desc.type & 2)) && write) goto bad; / unreadable code segment / if (!fetch && (desc.type & 8) && !(desc.type & 2)) goto bad; lim = desc_limit_scaled(&desc); if ((ctxt->mode == X86EMUL_MODE_REAL) && !fetch && (ctxt->d & NoBigReal)) { / la is between zero and 0xffff / if (la > 0xffff \|\| (u32)(la + size - 1) > 0xffff) goto bad; } else if ((desc.type & 8) \|\| !(desc.type & 4)) { / expand-up segment / if (addr.ea > lim \|\| (u32)(addr.ea + size - 1) > lim) goto bad; } else { / expand-down segment / if (addr.ea <= lim \|\| (u32)(addr.ea + size - 1) <= lim) goto bad; lim = desc.d ? 0xffffffff : 0xffff; if (addr.ea > lim \|\| (u32)(addr.ea + size - 1) > lim) goto bad; } cpl = ctxt->ops->cpl(ctxt); if (!(desc.type & 8)) { / data segment / if (cpl > desc.dpl) goto bad; } else if ((desc.type & 8) && !(desc.type & 4)) { / nonconforming code segment / if (cpl != desc.dpl) goto bad; } else if ((desc.type & 8) && (desc.type & 4)) { / conforming code segment / if (cpl < desc.dpl) goto bad; } break; } if (fetch ? ctxt->mode != X86EMUL_MODE_PROT64 : ctxt->ad_bytes != 8) la &= (u32)-1; if (insn_aligned(ctxt, size) && ((la & (size - 1)) != 0)) return emulate_gp(ctxt, 0); linear = la; return X86EMUL_CONTINUE; bad: if (addr.seg == VCPU_SREG_SS) return emulate_ss(ctxt, sel); else return emulate_gp(ctxt, sel); } static int linearize(struct x86_emulate_ctxt ctxt, struct segmented_address addr, unsigned size, bool write, ulong linear) { return __linearize(ctxt, addr, size, write, false, linear); } static int segmented_read_std(struct x86_emulate_ctxt ctxt, struct segmented_address addr, void data, unsigned size) { int rc; ulong linear; rc = linearize(ctxt, addr, size, false, &linear); if (rc != X86EMUL_CONTINUE) return rc; return ctxt->ops->read_std(ctxt, linear, data, size, &ctxt->exception); } /* * Prefetch the remaining bytes of the instruction without crossing page * boundary if they are not in fetch_cache yet. / static int __do_insn_fetch_bytes(struct x86_emulate_ctxt ctxt, int op_size) { int rc; unsigned size; unsigned long linear; int cur_size = ctxt->fetch.end - ctxt->fetch.data; struct segmented_address addr = { .seg = VCPU_SREG_CS, .ea = ctxt->eip + cur_size }; size = 15UL ^ cur_size; rc = __linearize(ctxt, addr, size, false, true, &linear); if (unlikely(rc != X86EMUL_CONTINUE)) return rc; size = min_t(unsigned, size, PAGE_SIZE - offset_in_page(linear)); /* * One instruction can only straddle two pages, * and one has been loaded at the beginning of * x86_decode_insn. So, if not enough bytes * still, we must have hit the 15-byte boundary. / if (unlikely(size < op_size)) return X86EMUL_UNHANDLEABLE; rc = ctxt->ops->fetch(ctxt, linear, ctxt->fetch.end, size, &ctxt->exception); if (unlikely(rc != X86EMUL_CONTINUE)) return rc; ctxt->fetch.end += size; return X86EMUL_CONTINUE; } static __always_inline int do_insn_fetch_bytes(struct x86_emulate_ctxt ctxt, unsigned size) { if (unlikely(ctxt->fetch.end - ctxt->fetch.ptr < size)) return __do_insn_fetch_bytes(ctxt, size); else return X86EMUL_CONTINUE; } /* Fetch next part of the instruction being emulated. / #define insn_fetch(_type, _ctxt) \ ({ _type _x; \ \ rc = do_insn_fetch_bytes(_ctxt, sizeof(_type)); \ if (rc != X86EMUL_CONTINUE) \ goto done; \ ctxt->_eip += sizeof(_type); \ _x = (_type __aligned(1) ) ctxt->fetch.ptr; \ ctxt->fetch.ptr += sizeof(_type); \ _x; \ }) #define insn_fetch_arr(_arr, _size, _ctxt) \ ({ \ rc = do_insn_fetch_bytes(_ctxt, _size); \ if (rc != X86EMUL_CONTINUE) \ goto done; \ ctxt->_eip += (_size); \ memcpy(_arr, ctxt->fetch.ptr, _size); \ ctxt->fetch.ptr += (_size); \ }) / * Given the 'reg' portion of a ModRM byte, and a register block, return a * pointer into the block that addresses the relevant register. * @highbyte_regs specifies whether to decode AH,CH,DH,BH. / static void decode_register(struct x86_emulate_ctxt ctxt, u8 modrm_reg, int byteop) { void p; int highbyte_regs = (ctxt->rex_prefix == 0) && byteop; if (highbyte_regs && modrm_reg >= 4 && modrm_reg < 8) p = (unsigned char )reg_rmw(ctxt, modrm_reg & 3) + 1; else p = reg_rmw(ctxt, modrm_reg); return p; } static int read_descriptor(struct x86_emulate_ctxt ctxt, struct segmented_address addr, u16 size, unsigned long address, int op_bytes) { int rc; if (op_bytes == 2) op_bytes = 3; address = 0; rc = segmented_read_std(ctxt, addr, size, 2); if (rc != X86EMUL_CONTINUE) return rc; addr.ea += 2; rc = segmented_read_std(ctxt, addr, address, op_bytes); return rc; } FASTOP2(add); FASTOP2(or); FASTOP2(adc); FASTOP2(sbb); FASTOP2(and); FASTOP2(sub); FASTOP2(xor); FASTOP2(cmp); FASTOP2(test); FASTOP1SRC2(mul, mul_ex); FASTOP1SRC2(imul, imul_ex); FASTOP1SRC2EX(div, div_ex); FASTOP1SRC2EX(idiv, idiv_ex); FASTOP3WCL(shld); FASTOP3WCL(shrd); FASTOP2W(imul); FASTOP1(not); FASTOP1(neg); FASTOP1(inc); FASTOP1(dec); FASTOP2CL(rol); FASTOP2CL(ror); FASTOP2CL(rcl); FASTOP2CL(rcr); FASTOP2CL(shl); FASTOP2CL(shr); FASTOP2CL(sar); FASTOP2W(bsf); FASTOP2W(bsr); FASTOP2W(bt); FASTOP2W(bts); FASTOP2W(btr); FASTOP2W(btc); FASTOP2(xadd); static u8 test_cc(unsigned int condition, unsigned long flags) { u8 rc; void (fop)(void) = (void )em_setcc + 4 (condition & 0xf); flags = (flags & EFLAGS_MASK) \| X86_EFLAGS_IF; asm("push %[flags]; popf; call %[fastop]" : "=a"(rc) : [fastop]"r"(fop), [flags]"r"(flags)); return rc; } static void fetch_register_operand(struct operand op) { switch (op->bytes) { case 1: op->val = (u8 )op->addr.reg; break; case 2: op->val = (u16 )op->addr.reg; break; case 4: op->val = (u32 )op->addr.reg; break; case 8: op->val = (u64 )op->addr.reg; break; } } static void read_sse_reg(struct x86_emulate_ctxt ctxt, sse128_t data, int reg) { ctxt->ops->get_fpu(ctxt); switch (reg) { case 0: asm("movdqa %%xmm0, %0" : "=m"(data)); break; case 1: asm("movdqa %%xmm1, %0" : "=m"(data)); break; case 2: asm("movdqa %%xmm2, %0" : "=m"(data)); break; case 3: asm("movdqa %%xmm3, %0" : "=m"(data)); break; case 4: asm("movdqa %%xmm4, %0" : "=m"(data)); break; case 5: asm("movdqa %%xmm5, %0" : "=m"(data)); break; case 6: asm("movdqa %%xmm6, %0" : "=m"(data)); break; case 7: asm("movdqa %%xmm7, %0" : "=m"(data)); break; #ifdef CONFIG_X86_64 case 8: asm("movdqa %%xmm8, %0" : "=m"(data)); break; case 9: asm("movdqa %%xmm9, %0" : "=m"(data)); break; case 10: asm("movdqa %%xmm10, %0" : "=m"(data)); break; case 11: asm("movdqa %%xmm11, %0" : "=m"(data)); break; case 12: asm("movdqa %%xmm12, %0" : "=m"(data)); break; case 13: asm("movdqa %%xmm13, %0" : "=m"(data)); break; case 14: asm("movdqa %%xmm14, %0" : "=m"(data)); break; case 15: asm("movdqa %%xmm15, %0" : "=m"(data)); break; #endif default: BUG(); } ctxt->ops->put_fpu(ctxt); } static void write_sse_reg(struct x86_emulate_ctxt ctxt, sse128_t data, int reg) { ctxt->ops->get_fpu(ctxt); switch (reg) { case 0: asm("movdqa %0, %%xmm0" : : "m"(data)); break; case 1: asm("movdqa %0, %%xmm1" : : "m"(data)); break; case 2: asm("movdqa %0, %%xmm2" : : "m"(data)); break; case 3: asm("movdqa %0, %%xmm3" : : "m"(data)); break; case 4: asm("movdqa %0, %%xmm4" : : "m"(data)); break; case 5: asm("movdqa %0, %%xmm5" : : "m"(data)); break; case 6: asm("movdqa %0, %%xmm6" : : "m"(data)); break; case 7: asm("movdqa %0, %%xmm7" : : "m"(data)); break; #ifdef CONFIG_X86_64 case 8: asm("movdqa %0, %%xmm8" : : "m"(data)); break; case 9: asm("movdqa %0, %%xmm9" : : "m"(data)); break; case 10: asm("movdqa %0, %%xmm10" : : "m"(data)); break; case 11: asm("movdqa %0, %%xmm11" : : "m"(data)); break; case 12: asm("movdqa %0, %%xmm12" : : "m"(data)); break; case 13: asm("movdqa %0, %%xmm13" : : "m"(data)); break; case 14: asm("movdqa %0, %%xmm14" : : "m"(data)); break; case 15: asm("movdqa %0, %%xmm15" : : "m"(data)); break; #endif default: BUG(); } ctxt->ops->put_fpu(ctxt); } static void read_mmx_reg(struct x86_emulate_ctxt ctxt, u64 data, int reg) { ctxt->ops->get_fpu(ctxt); switch (reg) { case 0: asm("movq %%mm0, %0" : "=m"(data)); break; case 1: asm("movq %%mm1, %0" : "=m"(data)); break; case 2: asm("movq %%mm2, %0" : "=m"(data)); break; case 3: asm("movq %%mm3, %0" : "=m"(data)); break; case 4: asm("movq %%mm4, %0" : "=m"(data)); break; case 5: asm("movq %%mm5, %0" : "=m"(data)); break; case 6: asm("movq %%mm6, %0" : "=m"(data)); break; case 7: asm("movq %%mm7, %0" : "=m"(data)); break; default: BUG(); } ctxt->ops->put_fpu(ctxt); } static void write_mmx_reg(struct x86_emulate_ctxt ctxt, u64 data, int reg) { ctxt->ops->get_fpu(ctxt); switch (reg) { case 0: asm("movq %0, %%mm0" : : "m"(data)); break; case 1: asm("movq %0, %%mm1" : : "m"(data)); break; case 2: asm("movq %0, %%mm2" : : "m"(data)); break; case 3: asm("movq %0, %%mm3" : : "m"(data)); break; case 4: asm("movq %0, %%mm4" : : "m"(data)); break; case 5: asm("movq %0, %%mm5" : : "m"(data)); break; case 6: asm("movq %0, %%mm6" : : "m"(data)); break; case 7: asm("movq %0, %%mm7" : : "m"(data)); break; default: BUG(); } ctxt->ops->put_fpu(ctxt); } static int em_fninit(struct x86_emulate_ctxt ctxt) { if (ctxt->ops->get_cr(ctxt, 0) & (X86_CR0_TS \| X86_CR0_EM)) return emulate_nm(ctxt); ctxt->ops->get_fpu(ctxt); asm volatile("fninit"); ctxt->ops->put_fpu(ctxt); return X86EMUL_CONTINUE; } static int em_fnstcw(struct x86_emulate_ctxt ctxt) { u16 fcw; if (ctxt->ops->get_cr(ctxt, 0) & (X86_CR0_TS \| X86_CR0_EM)) return emulate_nm(ctxt); ctxt->ops->get_fpu(ctxt); asm volatile("fnstcw %0": "+m"(fcw)); ctxt->ops->put_fpu(ctxt); /* force 2 byte destination / ctxt->dst.bytes = 2; ctxt->dst.val = fcw; return X86EMUL_CONTINUE; } static int em_fnstsw(struct x86_emulate_ctxt ctxt) { u16 fsw; if (ctxt->ops->get_cr(ctxt, 0) & (X86_CR0_TS \| X86_CR0_EM)) return emulate_nm(ctxt); ctxt->ops->get_fpu(ctxt); asm volatile("fnstsw %0": "+m"(fsw)); ctxt->ops->put_fpu(ctxt); /* force 2 byte destination / ctxt->dst.bytes = 2; ctxt->dst.val = fsw; return X86EMUL_CONTINUE; } static void decode_register_operand(struct x86_emulate_ctxt ctxt, struct operand op) { unsigned reg = ctxt->modrm_reg; if (!(ctxt->d & ModRM)) reg = (ctxt->b & 7) \| ((ctxt->rex_prefix & 1) << 3); if (ctxt->d & Sse) { op->type = OP_XMM; op->bytes = 16; op->addr.xmm = reg; read_sse_reg(ctxt, &op->vec_val, reg); return; } if (ctxt->d & Mmx) { reg &= 7; op->type = OP_MM; op->bytes = 8; op->addr.mm = reg; return; } op->type = OP_REG; op->bytes = (ctxt->d & ByteOp) ? 1 : ctxt->op_bytes; op->addr.reg = decode_register(ctxt, reg, ctxt->d & ByteOp); fetch_register_operand(op); op->orig_val = op->val; } static void adjust_modrm_seg(struct x86_emulate_ctxt ctxt, int base_reg) { if (base_reg == VCPU_REGS_RSP \|\| base_reg == VCPU_REGS_RBP) ctxt->modrm_seg = VCPU_SREG_SS; } static int decode_modrm(struct x86_emulate_ctxt ctxt, struct operand op) { u8 sib; int index_reg, base_reg, scale; int rc = X86EMUL_CONTINUE; ulong modrm_ea = 0; ctxt->modrm_reg = ((ctxt->rex_prefix << 1) & 8); /* REX.R / index_reg = (ctxt->rex_prefix << 2) & 8; / REX.X / base_reg = (ctxt->rex_prefix << 3) & 8; / REX.B / ctxt->modrm_mod = (ctxt->modrm & 0xc0) >> 6; ctxt->modrm_reg \|= (ctxt->modrm & 0x38) >> 3; ctxt->modrm_rm = base_reg \| (ctxt->modrm & 0x07); ctxt->modrm_seg = VCPU_SREG_DS; if (ctxt->modrm_mod == 3 \|\| (ctxt->d & NoMod)) { op->type = OP_REG; op->bytes = (ctxt->d & ByteOp) ? 1 : ctxt->op_bytes; op->addr.reg = decode_register(ctxt, ctxt->modrm_rm, ctxt->d & ByteOp); if (ctxt->d & Sse) { op->type = OP_XMM; op->bytes = 16; op->addr.xmm = ctxt->modrm_rm; read_sse_reg(ctxt, &op->vec_val, ctxt->modrm_rm); return rc; } if (ctxt->d & Mmx) { op->type = OP_MM; op->bytes = 8; op->addr.mm = ctxt->modrm_rm & 7; return rc; } fetch_register_operand(op); return rc; } op->type = OP_MEM; if (ctxt->ad_bytes == 2) { unsigned bx = reg_read(ctxt, VCPU_REGS_RBX); unsigned bp = reg_read(ctxt, VCPU_REGS_RBP); unsigned si = reg_read(ctxt, VCPU_REGS_RSI); unsigned di = reg_read(ctxt, VCPU_REGS_RDI); / 16-bit ModR/M decode. / switch (ctxt->modrm_mod) { case 0: if (ctxt->modrm_rm == 6) modrm_ea += insn_fetch(u16, ctxt); break; case 1: modrm_ea += insn_fetch(s8, ctxt); break; case 2: modrm_ea += insn_fetch(u16, ctxt); break; } switch (ctxt->modrm_rm) { case 0: modrm_ea += bx + si; break; case 1: modrm_ea += bx + di; break; case 2: modrm_ea += bp + si; break; case 3: modrm_ea += bp + di; break; case 4: modrm_ea += si; break; case 5: modrm_ea += di; break; case 6: if (ctxt->modrm_mod != 0) modrm_ea += bp; break; case 7: modrm_ea += bx; break; } if (ctxt->modrm_rm == 2 \|\| ctxt->modrm_rm == 3 \|\| (ctxt->modrm_rm == 6 && ctxt->modrm_mod != 0)) ctxt->modrm_seg = VCPU_SREG_SS; modrm_ea = (u16)modrm_ea; } else { / 32/64-bit ModR/M decode. / if ((ctxt->modrm_rm & 7) == 4) { sib = insn_fetch(u8, ctxt); index_reg \|= (sib >> 3) & 7; base_reg \|= sib & 7; scale = sib >> 6; if ((base_reg & 7) == 5 && ctxt->modrm_mod == 0) modrm_ea += insn_fetch(s32, ctxt); else { modrm_ea += reg_read(ctxt, base_reg); adjust_modrm_seg(ctxt, base_reg); } if (index_reg != 4) modrm_ea += reg_read(ctxt, index_reg) << scale; } else if ((ctxt->modrm_rm & 7) == 5 && ctxt->modrm_mod == 0) { if (ctxt->mode == X86EMUL_MODE_PROT64) ctxt->rip_relative = 1; } else { base_reg = ctxt->modrm_rm; modrm_ea += reg_read(ctxt, base_reg); adjust_modrm_seg(ctxt, base_reg); } switch (ctxt->modrm_mod) { case 0: if (ctxt->modrm_rm == 5) modrm_ea += insn_fetch(s32, ctxt); break; case 1: modrm_ea += insn_fetch(s8, ctxt); break; case 2: modrm_ea += insn_fetch(s32, ctxt); break; } } op->addr.mem.ea = modrm_ea; if (ctxt->ad_bytes != 8) ctxt->memop.addr.mem.ea = (u32)ctxt->memop.addr.mem.ea; done: return rc; } static int decode_abs(struct x86_emulate_ctxt ctxt, struct operand op) { int rc = X86EMUL_CONTINUE; op->type = OP_MEM; switch (ctxt->ad_bytes) { case 2: op->addr.mem.ea = insn_fetch(u16, ctxt); break; case 4: op->addr.mem.ea = insn_fetch(u32, ctxt); break; case 8: op->addr.mem.ea = insn_fetch(u64, ctxt); break; } done: return rc; } static void fetch_bit_operand(struct x86_emulate_ctxt ctxt) { long sv = 0, mask; if (ctxt->dst.type == OP_MEM && ctxt->src.type == OP_REG) { mask = ~((long)ctxt->dst.bytes * 8 - 1); if (ctxt->src.bytes == 2) sv = (s16)ctxt->src.val & (s16)mask; else if (ctxt->src.bytes == 4) sv = (s32)ctxt->src.val & (s32)mask; else sv = (s64)ctxt->src.val & (s64)mask; ctxt->dst.addr.mem.ea += (sv >> 3); } /* only subword offset / ctxt->src.val &= (ctxt->dst.bytes << 3) - 1; } static int read_emulated(struct x86_emulate_ctxt ctxt, unsigned long addr, void dest, unsigned size) { int rc; struct read_cache mc = &ctxt->mem_read; if (mc->pos < mc->end) goto read_cached; WARN_ON((mc->end + size) >= sizeof(mc->data)); rc = ctxt->ops->read_emulated(ctxt, addr, mc->data + mc->end, size, &ctxt->exception); if (rc != X86EMUL_CONTINUE) return rc; mc->end += size; read_cached: memcpy(dest, mc->data + mc->pos, size); mc->pos += size; return X86EMUL_CONTINUE; } static int segmented_read(struct x86_emulate_ctxt ctxt, struct segmented_address addr, void data, unsigned size) { int rc; ulong linear; rc = linearize(ctxt, addr, size, false, &linear); if (rc != X86EMUL_CONTINUE) return rc; return read_emulated(ctxt, linear, data, size); } static int segmented_write(struct x86_emulate_ctxt ctxt, struct segmented_address addr, const void data, unsigned size) { int rc; ulong linear; rc = linearize(ctxt, addr, size, true, &linear); if (rc != X86EMUL_CONTINUE) return rc; return ctxt->ops->write_emulated(ctxt, linear, data, size, &ctxt->exception); } static int segmented_cmpxchg(struct x86_emulate_ctxt ctxt, struct segmented_address addr, const void orig_data, const void data, unsigned size) { int rc; ulong linear; rc = linearize(ctxt, addr, size, true, &linear); if (rc != X86EMUL_CONTINUE) return rc; return ctxt->ops->cmpxchg_emulated(ctxt, linear, orig_data, data, size, &ctxt->exception); } static int pio_in_emulated(struct x86_emulate_ctxt ctxt, unsigned int size, unsigned short port, void dest) { struct read_cache rc = &ctxt->io_read; if (rc->pos == rc->end) { /* refill pio read ahead / unsigned int in_page, n; unsigned int count = ctxt->rep_prefix ? address_mask(ctxt, reg_read(ctxt, VCPU_REGS_RCX)) : 1; in_page = (ctxt->eflags & EFLG_DF) ? offset_in_page(reg_read(ctxt, VCPU_REGS_RDI)) : PAGE_SIZE - offset_in_page(reg_read(ctxt, VCPU_REGS_RDI)); n = min3(in_page, (unsigned int)sizeof(rc->data) / size, count); if (n == 0) n = 1; rc->pos = rc->end = 0; if (!ctxt->ops->pio_in_emulated(ctxt, size, port, rc->data, n)) return 0; rc->end = n size; } if (ctxt->rep_prefix && (ctxt->d & String) && !(ctxt->eflags & EFLG_DF)) { ctxt->dst.data = rc->data + rc->pos; ctxt->dst.type = OP_MEM_STR; ctxt->dst.count = (rc->end - rc->pos) / size; rc->pos = rc->end; } else { memcpy(dest, rc->data + rc->pos, size); rc->pos += size; } return 1; } static int read_interrupt_descriptor(struct x86_emulate_ctxt ctxt, u16 index, struct desc_struct desc) { struct desc_ptr dt; ulong addr; ctxt->ops->get_idt(ctxt, &dt); if (dt.size < index * 8 + 7) return emulate_gp(ctxt, index << 3 \| 0x2); addr = dt.address + index * 8; return ctxt->ops->read_std(ctxt, addr, desc, sizeof desc, &ctxt->exception); } static void get_descriptor_table_ptr(struct x86_emulate_ctxt ctxt, u16 selector, struct desc_ptr dt) { const struct x86_emulate_ops ops = ctxt->ops; u32 base3 = 0; if (selector & 1 << 2) { struct desc_struct desc; u16 sel; memset (dt, 0, sizeof dt); if (!ops->get_segment(ctxt, &sel, &desc, &base3, VCPU_SREG_LDTR)) return; dt->size = desc_limit_scaled(&desc); / what if limit > 65535? / dt->address = get_desc_base(&desc) \| ((u64)base3 << 32); } else ops->get_gdt(ctxt, dt); } / allowed just for 8 bytes segments / static int read_segment_descriptor(struct x86_emulate_ctxt ctxt, u16 selector, struct desc_struct desc, ulong desc_addr_p) { struct desc_ptr dt; u16 index = selector >> 3; ulong addr; get_descriptor_table_ptr(ctxt, selector, &dt); if (dt.size < index * 8 + 7) return emulate_gp(ctxt, selector & 0xfffc); desc_addr_p = addr = dt.address + index 8; return ctxt->ops->read_std(ctxt, addr, desc, sizeof desc, &ctxt->exception); } / allowed just for 8 bytes segments / static int write_segment_descriptor(struct x86_emulate_ctxt ctxt, u16 selector, struct desc_struct desc) { struct desc_ptr dt; u16 index = selector >> 3; ulong addr; get_descriptor_table_ptr(ctxt, selector, &dt); if (dt.size < index 8 + 7) return emulate_gp(ctxt, selector & 0xfffc); addr = dt.address + index * 8; return ctxt->ops->write_std(ctxt, addr, desc, sizeof desc, &ctxt->exception); } / Does not support long mode / static int __load_segment_descriptor(struct x86_emulate_ctxt ctxt, u16 selector, int seg, u8 cpl, bool in_task_switch) { struct desc_struct seg_desc, old_desc; u8 dpl, rpl; unsigned err_vec = GP_VECTOR; u32 err_code = 0; bool null_selector = !(selector & ~0x3); /* 0000-0003 are null / ulong desc_addr; int ret; u16 dummy; u32 base3 = 0; memset(&seg_desc, 0, sizeof seg_desc); if (ctxt->mode == X86EMUL_MODE_REAL) { / set real mode segment descriptor (keep limit etc. for * unreal mode) / ctxt->ops->get_segment(ctxt, &dummy, &seg_desc, NULL, seg); set_desc_base(&seg_desc, selector << 4); goto load; } else if (seg <= VCPU_SREG_GS && ctxt->mode == X86EMUL_MODE_VM86) { / VM86 needs a clean new segment descriptor / set_desc_base(&seg_desc, selector << 4); set_desc_limit(&seg_desc, 0xffff); seg_desc.type = 3; seg_desc.p = 1; seg_desc.s = 1; seg_desc.dpl = 3; goto load; } rpl = selector & 3; / NULL selector is not valid for TR, CS and SS (except for long mode) / if ((seg == VCPU_SREG_CS \|\| (seg == VCPU_SREG_SS && (ctxt->mode != X86EMUL_MODE_PROT64 \|\| rpl != cpl)) \|\| seg == VCPU_SREG_TR) && null_selector) goto exception; / TR should be in GDT only / if (seg == VCPU_SREG_TR && (selector & (1 << 2))) goto exception; if (null_selector) / for NULL selector skip all following checks / goto load; ret = read_segment_descriptor(ctxt, selector, &seg_desc, &desc_addr); if (ret != X86EMUL_CONTINUE) return ret; err_code = selector & 0xfffc; err_vec = in_task_switch ? TS_VECTOR : GP_VECTOR; / can't load system descriptor into segment selector / if (seg <= VCPU_SREG_GS && !seg_desc.s) goto exception; if (!seg_desc.p) { err_vec = (seg == VCPU_SREG_SS) ? SS_VECTOR : NP_VECTOR; goto exception; } dpl = seg_desc.dpl; switch (seg) { case VCPU_SREG_SS: / * segment is not a writable data segment or segment * selector's RPL != CPL or segment selector's RPL != CPL / if (rpl != cpl \|\| (seg_desc.type & 0xa) != 0x2 \|\| dpl != cpl) goto exception; break; case VCPU_SREG_CS: if (!(seg_desc.type & 8)) goto exception; if (seg_desc.type & 4) { / conforming / if (dpl > cpl) goto exception; } else { / nonconforming / if (rpl > cpl \|\| dpl != cpl) goto exception; } / in long-mode d/b must be clear if l is set / if (seg_desc.d && seg_desc.l) { u64 efer = 0; ctxt->ops->get_msr(ctxt, MSR_EFER, &efer); if (efer & EFER_LMA) goto exception; } / CS(RPL) <- CPL / selector = (selector & 0xfffc) \| cpl; break; case VCPU_SREG_TR: if (seg_desc.s \|\| (seg_desc.type != 1 && seg_desc.type != 9)) goto exception; old_desc = seg_desc; seg_desc.type \|= 2; / busy / ret = ctxt->ops->cmpxchg_emulated(ctxt, desc_addr, &old_desc, &seg_desc, sizeof(seg_desc), &ctxt->exception); if (ret != X86EMUL_CONTINUE) return ret; break; case VCPU_SREG_LDTR: if (seg_desc.s \|\| seg_desc.type != 2) goto exception; break; default: / DS, ES, FS, or GS / / * segment is not a data or readable code segment or * ((segment is a data or nonconforming code segment) * and (both RPL and CPL > DPL)) / if ((seg_desc.type & 0xa) == 0x8 \|\| (((seg_desc.type & 0xc) != 0xc) && (rpl > dpl && cpl > dpl))) goto exception; break; } if (seg_desc.s) { / mark segment as accessed / seg_desc.type \|= 1; ret = write_segment_descriptor(ctxt, selector, &seg_desc); if (ret != X86EMUL_CONTINUE) return ret; } else if (ctxt->mode == X86EMUL_MODE_PROT64) { ret = ctxt->ops->read_std(ctxt, desc_addr+8, &base3, sizeof(base3), &ctxt->exception); if (ret != X86EMUL_CONTINUE) return ret; } load: ctxt->ops->set_segment(ctxt, selector, &seg_desc, base3, seg); return X86EMUL_CONTINUE; exception: return emulate_exception(ctxt, err_vec, err_code, true); } static int load_segment_descriptor(struct x86_emulate_ctxt ctxt, u16 selector, int seg) { u8 cpl = ctxt->ops->cpl(ctxt); return __load_segment_descriptor(ctxt, selector, seg, cpl, false); } static void write_register_operand(struct operand op) { / The 4-byte case is correct: in 64-bit mode we zero-extend. / switch (op->bytes) { case 1: (u8 )op->addr.reg = (u8)op->val; break; case 2: (u16 )op->addr.reg = (u16)op->val; break; case 4: op->addr.reg = (u32)op->val; break; /* 64b: zero-extend / case 8: op->addr.reg = op->val; break; } } static int writeback(struct x86_emulate_ctxt ctxt, struct operand op) { switch (op->type) { case OP_REG: write_register_operand(op); break; case OP_MEM: if (ctxt->lock_prefix) return segmented_cmpxchg(ctxt, op->addr.mem, &op->orig_val, &op->val, op->bytes); else return segmented_write(ctxt, op->addr.mem, &op->val, op->bytes); break; case OP_MEM_STR: return segmented_write(ctxt, op->addr.mem, op->data, op->bytes * op->count); break; case OP_XMM: write_sse_reg(ctxt, &op->vec_val, op->addr.xmm); break; case OP_MM: write_mmx_reg(ctxt, &op->mm_val, op->addr.mm); break; case OP_NONE: /* no writeback / break; default: break; } return X86EMUL_CONTINUE; } static int push(struct x86_emulate_ctxt ctxt, void data, int bytes) { struct segmented_address addr; rsp_increment(ctxt, -bytes); addr.ea = reg_read(ctxt, VCPU_REGS_RSP) & stack_mask(ctxt); addr.seg = VCPU_SREG_SS; return segmented_write(ctxt, addr, data, bytes); } static int em_push(struct x86_emulate_ctxt ctxt) { /* Disable writeback. / ctxt->dst.type = OP_NONE; return push(ctxt, &ctxt->src.val, ctxt->op_bytes); } static int emulate_pop(struct x86_emulate_ctxt ctxt, void dest, int len) { int rc; struct segmented_address addr; addr.ea = reg_read(ctxt, VCPU_REGS_RSP) & stack_mask(ctxt); addr.seg = VCPU_SREG_SS; rc = segmented_read(ctxt, addr, dest, len); if (rc != X86EMUL_CONTINUE) return rc; rsp_increment(ctxt, len); return rc; } static int em_pop(struct x86_emulate_ctxt ctxt) { return emulate_pop(ctxt, &ctxt->dst.val, ctxt->op_bytes); } static int emulate_popf(struct x86_emulate_ctxt ctxt, void dest, int len) { int rc; unsigned long val, change_mask; int iopl = (ctxt->eflags & X86_EFLAGS_IOPL) >> IOPL_SHIFT; int cpl = ctxt->ops->cpl(ctxt); rc = emulate_pop(ctxt, &val, len); if (rc != X86EMUL_CONTINUE) return rc; change_mask = EFLG_CF \| EFLG_PF \| EFLG_AF \| EFLG_ZF \| EFLG_SF \| EFLG_OF \| EFLG_TF \| EFLG_DF \| EFLG_NT \| EFLG_AC \| EFLG_ID; switch(ctxt->mode) { case X86EMUL_MODE_PROT64: case X86EMUL_MODE_PROT32: case X86EMUL_MODE_PROT16: if (cpl == 0) change_mask \|= EFLG_IOPL; if (cpl <= iopl) change_mask \|= EFLG_IF; break; case X86EMUL_MODE_VM86: if (iopl < 3) return emulate_gp(ctxt, 0); change_mask \|= EFLG_IF; break; default: /* real mode / change_mask \|= (EFLG_IOPL \| EFLG_IF); break; } (unsigned long )dest = (ctxt->eflags & ~change_mask) \| (val & change_mask); return rc; } static int em_popf(struct x86_emulate_ctxt ctxt) { ctxt->dst.type = OP_REG; ctxt->dst.addr.reg = &ctxt->eflags; ctxt->dst.bytes = ctxt->op_bytes; return emulate_popf(ctxt, &ctxt->dst.val, ctxt->op_bytes); } static int em_enter(struct x86_emulate_ctxt ctxt) { int rc; unsigned frame_size = ctxt->src.val; unsigned nesting_level = ctxt->src2.val & 31; ulong rbp; if (nesting_level) return X86EMUL_UNHANDLEABLE; rbp = reg_read(ctxt, VCPU_REGS_RBP); rc = push(ctxt, &rbp, stack_size(ctxt)); if (rc != X86EMUL_CONTINUE) return rc; assign_masked(reg_rmw(ctxt, VCPU_REGS_RBP), reg_read(ctxt, VCPU_REGS_RSP), stack_mask(ctxt)); assign_masked(reg_rmw(ctxt, VCPU_REGS_RSP), reg_read(ctxt, VCPU_REGS_RSP) - frame_size, stack_mask(ctxt)); return X86EMUL_CONTINUE; } static int em_leave(struct x86_emulate_ctxt ctxt) { assign_masked(reg_rmw(ctxt, VCPU_REGS_RSP), reg_read(ctxt, VCPU_REGS_RBP), stack_mask(ctxt)); return emulate_pop(ctxt, reg_rmw(ctxt, VCPU_REGS_RBP), ctxt->op_bytes); } static int em_push_sreg(struct x86_emulate_ctxt ctxt) { int seg = ctxt->src2.val; ctxt->src.val = get_segment_selector(ctxt, seg); return em_push(ctxt); } static int em_pop_sreg(struct x86_emulate_ctxt ctxt) { int seg = ctxt->src2.val; unsigned long selector; int rc; rc = emulate_pop(ctxt, &selector, ctxt->op_bytes); if (rc != X86EMUL_CONTINUE) return rc; if (ctxt->modrm_reg == VCPU_SREG_SS) ctxt->interruptibility = KVM_X86_SHADOW_INT_MOV_SS; rc = load_segment_descriptor(ctxt, (u16)selector, seg); return rc; } static int em_pusha(struct x86_emulate_ctxt ctxt) { unsigned long old_esp = reg_read(ctxt, VCPU_REGS_RSP); int rc = X86EMUL_CONTINUE; int reg = VCPU_REGS_RAX; while (reg <= VCPU_REGS_RDI) { (reg == VCPU_REGS_RSP) ? (ctxt->src.val = old_esp) : (ctxt->src.val = reg_read(ctxt, reg)); rc = em_push(ctxt); if (rc != X86EMUL_CONTINUE) return rc; ++reg; } return rc; } static int em_pushf(struct x86_emulate_ctxt ctxt) { ctxt->src.val = (unsigned long)ctxt->eflags; return em_push(ctxt); } static int em_popa(struct x86_emulate_ctxt ctxt) { int rc = X86EMUL_CONTINUE; int reg = VCPU_REGS_RDI; while (reg >= VCPU_REGS_RAX) { if (reg == VCPU_REGS_RSP) { rsp_increment(ctxt, ctxt->op_bytes); --reg; } rc = emulate_pop(ctxt, reg_rmw(ctxt, reg), ctxt->op_bytes); if (rc != X86EMUL_CONTINUE) break; --reg; } return rc; } static int __emulate_int_real(struct x86_emulate_ctxt ctxt, int irq) { const struct x86_emulate_ops ops = ctxt->ops; int rc; struct desc_ptr dt; gva_t cs_addr; gva_t eip_addr; u16 cs, eip; / TODO: Add limit checks / ctxt->src.val = ctxt->eflags; rc = em_push(ctxt); if (rc != X86EMUL_CONTINUE) return rc; ctxt->eflags &= ~(EFLG_IF \| EFLG_TF \| EFLG_AC); ctxt->src.val = get_segment_selector(ctxt, VCPU_SREG_CS); rc = em_push(ctxt); if (rc != X86EMUL_CONTINUE) return rc; ctxt->src.val = ctxt->_eip; rc = em_push(ctxt); if (rc != X86EMUL_CONTINUE) return rc; ops->get_idt(ctxt, &dt); eip_addr = dt.address + (irq << 2); cs_addr = dt.address + (irq << 2) + 2; rc = ops->read_std(ctxt, cs_addr, &cs, 2, &ctxt->exception); if (rc != X86EMUL_CONTINUE) return rc; rc = ops->read_std(ctxt, eip_addr, &eip, 2, &ctxt->exception); if (rc != X86EMUL_CONTINUE) return rc; rc = load_segment_descriptor(ctxt, cs, VCPU_SREG_CS); if (rc != X86EMUL_CONTINUE) return rc; ctxt->_eip = eip; return rc; } int emulate_int_real(struct x86_emulate_ctxt ctxt, int irq) { int rc; invalidate_registers(ctxt); rc = __emulate_int_real(ctxt, irq); if (rc == X86EMUL_CONTINUE) writeback_registers(ctxt); return rc; } static int emulate_int(struct x86_emulate_ctxt ctxt, int irq) { switch(ctxt->mode) { case X86EMUL_MODE_REAL: return __emulate_int_real(ctxt, irq); case X86EMUL_MODE_VM86: case X86EMUL_MODE_PROT16: case X86EMUL_MODE_PROT32: case X86EMUL_MODE_PROT64: default: / Protected mode interrupts unimplemented yet / return X86EMUL_UNHANDLEABLE; } } static int emulate_iret_real(struct x86_emulate_ctxt ctxt) { int rc = X86EMUL_CONTINUE; unsigned long temp_eip = 0; unsigned long temp_eflags = 0; unsigned long cs = 0; unsigned long mask = EFLG_CF \| EFLG_PF \| EFLG_AF \| EFLG_ZF \| EFLG_SF \| EFLG_TF \| EFLG_IF \| EFLG_DF \| EFLG_OF \| EFLG_IOPL \| EFLG_NT \| EFLG_RF \| EFLG_AC \| EFLG_ID \| (1 << 1); /* Last one is the reserved bit / unsigned long vm86_mask = EFLG_VM \| EFLG_VIF \| EFLG_VIP; / TODO: Add stack limit check / rc = emulate_pop(ctxt, &temp_eip, ctxt->op_bytes); if (rc != X86EMUL_CONTINUE) return rc; if (temp_eip & ~0xffff) return emulate_gp(ctxt, 0); rc = emulate_pop(ctxt, &cs, ctxt->op_bytes); if (rc != X86EMUL_CONTINUE) return rc; rc = emulate_pop(ctxt, &temp_eflags, ctxt->op_bytes); if (rc != X86EMUL_CONTINUE) return rc; rc = load_segment_descriptor(ctxt, (u16)cs, VCPU_SREG_CS); if (rc != X86EMUL_CONTINUE) return rc; ctxt->_eip = temp_eip; if (ctxt->op_bytes == 4) ctxt->eflags = ((temp_eflags & mask) \| (ctxt->eflags & vm86_mask)); else if (ctxt->op_bytes == 2) { ctxt->eflags &= ~0xffff; ctxt->eflags \|= temp_eflags; } ctxt->eflags &= ~EFLG_RESERVED_ZEROS_MASK; / Clear reserved zeros / ctxt->eflags \|= EFLG_RESERVED_ONE_MASK; return rc; } static int em_iret(struct x86_emulate_ctxt ctxt) { switch(ctxt->mode) { case X86EMUL_MODE_REAL: return emulate_iret_real(ctxt); case X86EMUL_MODE_VM86: case X86EMUL_MODE_PROT16: case X86EMUL_MODE_PROT32: case X86EMUL_MODE_PROT64: default: /* iret from protected mode unimplemented yet / return X86EMUL_UNHANDLEABLE; } } static int em_jmp_far(struct x86_emulate_ctxt ctxt) { int rc; unsigned short sel; memcpy(&sel, ctxt->src.valptr + ctxt->op_bytes, 2); rc = load_segment_descriptor(ctxt, sel, VCPU_SREG_CS); if (rc != X86EMUL_CONTINUE) return rc; ctxt->_eip = 0; memcpy(&ctxt->_eip, ctxt->src.valptr, ctxt->op_bytes); return X86EMUL_CONTINUE; } static int em_grp45(struct x86_emulate_ctxt ctxt) { int rc = X86EMUL_CONTINUE; switch (ctxt->modrm_reg) { case 2: / call near abs / { long int old_eip; old_eip = ctxt->_eip; ctxt->_eip = ctxt->src.val; ctxt->src.val = old_eip; rc = em_push(ctxt); break; } case 4: / jmp abs / ctxt->_eip = ctxt->src.val; break; case 5: / jmp far / rc = em_jmp_far(ctxt); break; case 6: / push / rc = em_push(ctxt); break; } return rc; } static int em_cmpxchg8b(struct x86_emulate_ctxt ctxt) { u64 old = ctxt->dst.orig_val64; if (ctxt->dst.bytes == 16) return X86EMUL_UNHANDLEABLE; if (((u32) (old >> 0) != (u32) reg_read(ctxt, VCPU_REGS_RAX)) \|\| ((u32) (old >> 32) != (u32) reg_read(ctxt, VCPU_REGS_RDX))) { reg_write(ctxt, VCPU_REGS_RAX) = (u32) (old >> 0); reg_write(ctxt, VCPU_REGS_RDX) = (u32) (old >> 32); ctxt->eflags &= ~EFLG_ZF; } else { ctxt->dst.val64 = ((u64)reg_read(ctxt, VCPU_REGS_RCX) << 32) \| (u32) reg_read(ctxt, VCPU_REGS_RBX); ctxt->eflags \|= EFLG_ZF; } return X86EMUL_CONTINUE; } static int em_ret(struct x86_emulate_ctxt ctxt) { ctxt->dst.type = OP_REG; ctxt->dst.addr.reg = &ctxt->_eip; ctxt->dst.bytes = ctxt->op_bytes; return em_pop(ctxt); } static int em_ret_far(struct x86_emulate_ctxt ctxt) { int rc; unsigned long cs; int cpl = ctxt->ops->cpl(ctxt); rc = emulate_pop(ctxt, &ctxt->_eip, ctxt->op_bytes); if (rc != X86EMUL_CONTINUE) return rc; if (ctxt->op_bytes == 4) ctxt->_eip = (u32)ctxt->_eip; rc = emulate_pop(ctxt, &cs, ctxt->op_bytes); if (rc != X86EMUL_CONTINUE) return rc; /* Outer-privilege level return is not implemented / if (ctxt->mode >= X86EMUL_MODE_PROT16 && (cs & 3) > cpl) return X86EMUL_UNHANDLEABLE; rc = load_segment_descriptor(ctxt, (u16)cs, VCPU_SREG_CS); return rc; } static int em_ret_far_imm(struct x86_emulate_ctxt ctxt) { int rc; rc = em_ret_far(ctxt); if (rc != X86EMUL_CONTINUE) return rc; rsp_increment(ctxt, ctxt->src.val); return X86EMUL_CONTINUE; } static int em_cmpxchg(struct x86_emulate_ctxt ctxt) { / Save real source value, then compare EAX against destination. / ctxt->dst.orig_val = ctxt->dst.val; ctxt->dst.val = reg_read(ctxt, VCPU_REGS_RAX); ctxt->src.orig_val = ctxt->src.val; ctxt->src.val = ctxt->dst.orig_val; fastop(ctxt, em_cmp); if (ctxt->eflags & EFLG_ZF) { / Success: write back to memory. / ctxt->dst.val = ctxt->src.orig_val; } else { / Failure: write the value we saw to EAX. / ctxt->dst.type = OP_REG; ctxt->dst.addr.reg = reg_rmw(ctxt, VCPU_REGS_RAX); ctxt->dst.val = ctxt->dst.orig_val; } return X86EMUL_CONTINUE; } static int em_lseg(struct x86_emulate_ctxt ctxt) { int seg = ctxt->src2.val; unsigned short sel; int rc; memcpy(&sel, ctxt->src.valptr + ctxt->op_bytes, 2); rc = load_segment_descriptor(ctxt, sel, seg); if (rc != X86EMUL_CONTINUE) return rc; ctxt->dst.val = ctxt->src.val; return rc; } static void setup_syscalls_segments(struct x86_emulate_ctxt ctxt, struct desc_struct cs, struct desc_struct ss) { cs->l = 0; / will be adjusted later / set_desc_base(cs, 0); / flat segment / cs->g = 1; / 4kb granularity / set_desc_limit(cs, 0xfffff); / 4GB limit / cs->type = 0x0b; / Read, Execute, Accessed / cs->s = 1; cs->dpl = 0; / will be adjusted later / cs->p = 1; cs->d = 1; cs->avl = 0; set_desc_base(ss, 0); / flat segment / set_desc_limit(ss, 0xfffff); / 4GB limit / ss->g = 1; / 4kb granularity / ss->s = 1; ss->type = 0x03; / Read/Write, Accessed / ss->d = 1; / 32bit stack segment / ss->dpl = 0; ss->p = 1; ss->l = 0; ss->avl = 0; } static bool vendor_intel(struct x86_emulate_ctxt ctxt) { u32 eax, ebx, ecx, edx; eax = ecx = 0; ctxt->ops->get_cpuid(ctxt, &eax, &ebx, &ecx, &edx); return ebx == X86EMUL_CPUID_VENDOR_GenuineIntel_ebx && ecx == X86EMUL_CPUID_VENDOR_GenuineIntel_ecx && edx == X86EMUL_CPUID_VENDOR_GenuineIntel_edx; } static bool em_syscall_is_enabled(struct x86_emulate_ctxt ctxt) { const struct x86_emulate_ops ops = ctxt->ops; u32 eax, ebx, ecx, edx; /* * syscall should always be enabled in longmode - so only become * vendor specific (cpuid) if other modes are active... / if (ctxt->mode == X86EMUL_MODE_PROT64) return true; eax = 0x00000000; ecx = 0x00000000; ops->get_cpuid(ctxt, &eax, &ebx, &ecx, &edx); / * Intel ("GenuineIntel") * remark: Intel CPUs only support "syscall" in 64bit * longmode. Also an 64bit guest with a * 32bit compat-app running will #UD !! While this * behaviour can be fixed (by emulating) into AMD * response - CPUs of AMD can't behave like Intel. / if (ebx == X86EMUL_CPUID_VENDOR_GenuineIntel_ebx && ecx == X86EMUL_CPUID_VENDOR_GenuineIntel_ecx && edx == X86EMUL_CPUID_VENDOR_GenuineIntel_edx) return false; / AMD ("AuthenticAMD") / if (ebx == X86EMUL_CPUID_VENDOR_AuthenticAMD_ebx && ecx == X86EMUL_CPUID_VENDOR_AuthenticAMD_ecx && edx == X86EMUL_CPUID_VENDOR_AuthenticAMD_edx) return true; / AMD ("AMDisbetter!") / if (ebx == X86EMUL_CPUID_VENDOR_AMDisbetterI_ebx && ecx == X86EMUL_CPUID_VENDOR_AMDisbetterI_ecx && edx == X86EMUL_CPUID_VENDOR_AMDisbetterI_edx) return true; / default: (not Intel, not AMD), apply Intel's stricter rules... / return false; } static int em_syscall(struct x86_emulate_ctxt ctxt) { const struct x86_emulate_ops ops = ctxt->ops; struct desc_struct cs, ss; u64 msr_data; u16 cs_sel, ss_sel; u64 efer = 0; / syscall is not available in real mode / if (ctxt->mode == X86EMUL_MODE_REAL \|\| ctxt->mode == X86EMUL_MODE_VM86) return emulate_ud(ctxt); if (!(em_syscall_is_enabled(ctxt))) return emulate_ud(ctxt); ops->get_msr(ctxt, MSR_EFER, &efer); setup_syscalls_segments(ctxt, &cs, &ss); if (!(efer & EFER_SCE)) return emulate_ud(ctxt); ops->get_msr(ctxt, MSR_STAR, &msr_data); msr_data >>= 32; cs_sel = (u16)(msr_data & 0xfffc); ss_sel = (u16)(msr_data + 8); if (efer & EFER_LMA) { cs.d = 0; cs.l = 1; } ops->set_segment(ctxt, cs_sel, &cs, 0, VCPU_SREG_CS); ops->set_segment(ctxt, ss_sel, &ss, 0, VCPU_SREG_SS); reg_write(ctxt, VCPU_REGS_RCX) = ctxt->_eip; if (efer & EFER_LMA) { #ifdef CONFIG_X86_64 reg_write(ctxt, VCPU_REGS_R11) = ctxt->eflags; ops->get_msr(ctxt, ctxt->mode == X86EMUL_MODE_PROT64 ? MSR_LSTAR : MSR_CSTAR, &msr_data); ctxt->_eip = msr_data; ops->get_msr(ctxt, MSR_SYSCALL_MASK, &msr_data); ctxt->eflags &= ~msr_data; #endif } else { / legacy mode / ops->get_msr(ctxt, MSR_STAR, &msr_data); ctxt->_eip = (u32)msr_data; ctxt->eflags &= ~(EFLG_VM \| EFLG_IF); } return X86EMUL_CONTINUE; } static int em_sysenter(struct x86_emulate_ctxt ctxt) { const struct x86_emulate_ops ops = ctxt->ops; struct desc_struct cs, ss; u64 msr_data; u16 cs_sel, ss_sel; u64 efer = 0; ops->get_msr(ctxt, MSR_EFER, &efer); / inject #GP if in real mode / if (ctxt->mode == X86EMUL_MODE_REAL) return emulate_gp(ctxt, 0); / * Not recognized on AMD in compat mode (but is recognized in legacy * mode). / if ((ctxt->mode == X86EMUL_MODE_PROT32) && (efer & EFER_LMA) && !vendor_intel(ctxt)) return emulate_ud(ctxt); / XXX sysenter/sysexit have not been tested in 64bit mode. * Therefore, we inject an #UD. / if (ctxt->mode == X86EMUL_MODE_PROT64) return emulate_ud(ctxt); setup_syscalls_segments(ctxt, &cs, &ss); ops->get_msr(ctxt, MSR_IA32_SYSENTER_CS, &msr_data); switch (ctxt->mode) { case X86EMUL_MODE_PROT32: if ((msr_data & 0xfffc) == 0x0) return emulate_gp(ctxt, 0); break; case X86EMUL_MODE_PROT64: if (msr_data == 0x0) return emulate_gp(ctxt, 0); break; default: break; } ctxt->eflags &= ~(EFLG_VM \| EFLG_IF); cs_sel = (u16)msr_data; cs_sel &= ~SELECTOR_RPL_MASK; ss_sel = cs_sel + 8; ss_sel &= ~SELECTOR_RPL_MASK; if (ctxt->mode == X86EMUL_MODE_PROT64 \|\| (efer & EFER_LMA)) { cs.d = 0; cs.l = 1; } ops->set_segment(ctxt, cs_sel, &cs, 0, VCPU_SREG_CS); ops->set_segment(ctxt, ss_sel, &ss, 0, VCPU_SREG_SS); ops->get_msr(ctxt, MSR_IA32_SYSENTER_EIP, &msr_data); ctxt->_eip = msr_data; ops->get_msr(ctxt, MSR_IA32_SYSENTER_ESP, &msr_data); reg_write(ctxt, VCPU_REGS_RSP) = msr_data; return X86EMUL_CONTINUE; } static int em_sysexit(struct x86_emulate_ctxt ctxt) { const struct x86_emulate_ops ops = ctxt->ops; struct desc_struct cs, ss; u64 msr_data; int usermode; u16 cs_sel = 0, ss_sel = 0; /* inject #GP if in real mode or Virtual 8086 mode / if (ctxt->mode == X86EMUL_MODE_REAL \|\| ctxt->mode == X86EMUL_MODE_VM86) return emulate_gp(ctxt, 0); setup_syscalls_segments(ctxt, &cs, &ss); if ((ctxt->rex_prefix & 0x8) != 0x0) usermode = X86EMUL_MODE_PROT64; else usermode = X86EMUL_MODE_PROT32; cs.dpl = 3; ss.dpl = 3; ops->get_msr(ctxt, MSR_IA32_SYSENTER_CS, &msr_data); switch (usermode) { case X86EMUL_MODE_PROT32: cs_sel = (u16)(msr_data + 16); if ((msr_data & 0xfffc) == 0x0) return emulate_gp(ctxt, 0); ss_sel = (u16)(msr_data + 24); break; case X86EMUL_MODE_PROT64: cs_sel = (u16)(msr_data + 32); if (msr_data == 0x0) return emulate_gp(ctxt, 0); ss_sel = cs_sel + 8; cs.d = 0; cs.l = 1; break; } cs_sel \|= SELECTOR_RPL_MASK; ss_sel \|= SELECTOR_RPL_MASK; ops->set_segment(ctxt, cs_sel, &cs, 0, VCPU_SREG_CS); ops->set_segment(ctxt, ss_sel, &ss, 0, VCPU_SREG_SS); ctxt->_eip = reg_read(ctxt, VCPU_REGS_RDX); reg_write(ctxt, VCPU_REGS_RSP) = reg_read(ctxt, VCPU_REGS_RCX); return X86EMUL_CONTINUE; } static bool emulator_bad_iopl(struct x86_emulate_ctxt ctxt) { int iopl; if (ctxt->mode == X86EMUL_MODE_REAL) return false; if (ctxt->mode == X86EMUL_MODE_VM86) return true; iopl = (ctxt->eflags & X86_EFLAGS_IOPL) >> IOPL_SHIFT; return ctxt->ops->cpl(ctxt) > iopl; } static bool emulator_io_port_access_allowed(struct x86_emulate_ctxt ctxt, u16 port, u16 len) { const struct x86_emulate_ops ops = ctxt->ops; struct desc_struct tr_seg; u32 base3; int r; u16 tr, io_bitmap_ptr, perm, bit_idx = port & 0x7; unsigned mask = (1 << len) - 1; unsigned long base; ops->get_segment(ctxt, &tr, &tr_seg, &base3, VCPU_SREG_TR); if (!tr_seg.p) return false; if (desc_limit_scaled(&tr_seg) < 103) return false; base = get_desc_base(&tr_seg); #ifdef CONFIG_X86_64 base \|= ((u64)base3) << 32; #endif r = ops->read_std(ctxt, base + 102, &io_bitmap_ptr, 2, NULL); if (r != X86EMUL_CONTINUE) return false; if (io_bitmap_ptr + port/8 > desc_limit_scaled(&tr_seg)) return false; r = ops->read_std(ctxt, base + io_bitmap_ptr + port/8, &perm, 2, NULL); if (r != X86EMUL_CONTINUE) return false; if ((perm >> bit_idx) & mask) return false; return true; } static bool emulator_io_permited(struct x86_emulate_ctxt ctxt, u16 port, u16 len) { if (ctxt->perm_ok) return true; if (emulator_bad_iopl(ctxt)) if (!emulator_io_port_access_allowed(ctxt, port, len)) return false; ctxt->perm_ok = true; return true; } static void save_state_to_tss16(struct x86_emulate_ctxt ctxt, struct tss_segment_16 tss) { tss->ip = ctxt->_eip; tss->flag = ctxt->eflags; tss->ax = reg_read(ctxt, VCPU_REGS_RAX); tss->cx = reg_read(ctxt, VCPU_REGS_RCX); tss->dx = reg_read(ctxt, VCPU_REGS_RDX); tss->bx = reg_read(ctxt, VCPU_REGS_RBX); tss->sp = reg_read(ctxt, VCPU_REGS_RSP); tss->bp = reg_read(ctxt, VCPU_REGS_RBP); tss->si = reg_read(ctxt, VCPU_REGS_RSI); tss->di = reg_read(ctxt, VCPU_REGS_RDI); tss->es = get_segment_selector(ctxt, VCPU_SREG_ES); tss->cs = get_segment_selector(ctxt, VCPU_SREG_CS); tss->ss = get_segment_selector(ctxt, VCPU_SREG_SS); tss->ds = get_segment_selector(ctxt, VCPU_SREG_DS); tss->ldt = get_segment_selector(ctxt, VCPU_SREG_LDTR); } static int load_state_from_tss16(struct x86_emulate_ctxt ctxt, struct tss_segment_16 tss) { int ret; u8 cpl; ctxt->_eip = tss->ip; ctxt->eflags = tss->flag \| 2; reg_write(ctxt, VCPU_REGS_RAX) = tss->ax; reg_write(ctxt, VCPU_REGS_RCX) = tss->cx; reg_write(ctxt, VCPU_REGS_RDX) = tss->dx; reg_write(ctxt, VCPU_REGS_RBX) = tss->bx; reg_write(ctxt, VCPU_REGS_RSP) = tss->sp; reg_write(ctxt, VCPU_REGS_RBP) = tss->bp; reg_write(ctxt, VCPU_REGS_RSI) = tss->si; reg_write(ctxt, VCPU_REGS_RDI) = tss->di; /* * SDM says that segment selectors are loaded before segment * descriptors / set_segment_selector(ctxt, tss->ldt, VCPU_SREG_LDTR); set_segment_selector(ctxt, tss->es, VCPU_SREG_ES); set_segment_selector(ctxt, tss->cs, VCPU_SREG_CS); set_segment_selector(ctxt, tss->ss, VCPU_SREG_SS); set_segment_selector(ctxt, tss->ds, VCPU_SREG_DS); cpl = tss->cs & 3; / * Now load segment descriptors. If fault happens at this stage * it is handled in a context of new task / ret = __load_segment_descriptor(ctxt, tss->ldt, VCPU_SREG_LDTR, cpl, true); if (ret != X86EMUL_CONTINUE) return ret; ret = __load_segment_descriptor(ctxt, tss->es, VCPU_SREG_ES, cpl, true); if (ret != X86EMUL_CONTINUE) return ret; ret = __load_segment_descriptor(ctxt, tss->cs, VCPU_SREG_CS, cpl, true); if (ret != X86EMUL_CONTINUE) return ret; ret = __load_segment_descriptor(ctxt, tss->ss, VCPU_SREG_SS, cpl, true); if (ret != X86EMUL_CONTINUE) return ret; ret = __load_segment_descriptor(ctxt, tss->ds, VCPU_SREG_DS, cpl, true); if (ret != X86EMUL_CONTINUE) return ret; return X86EMUL_CONTINUE; } static int task_switch_16(struct x86_emulate_ctxt ctxt, u16 tss_selector, u16 old_tss_sel, ulong old_tss_base, struct desc_struct new_desc) { const struct x86_emulate_ops ops = ctxt->ops; struct tss_segment_16 tss_seg; int ret; u32 new_tss_base = get_desc_base(new_desc); ret = ops->read_std(ctxt, old_tss_base, &tss_seg, sizeof tss_seg, &ctxt->exception); if (ret != X86EMUL_CONTINUE) /* FIXME: need to provide precise fault address / return ret; save_state_to_tss16(ctxt, &tss_seg); ret = ops->write_std(ctxt, old_tss_base, &tss_seg, sizeof tss_seg, &ctxt->exception); if (ret != X86EMUL_CONTINUE) / FIXME: need to provide precise fault address / return ret; ret = ops->read_std(ctxt, new_tss_base, &tss_seg, sizeof tss_seg, &ctxt->exception); if (ret != X86EMUL_CONTINUE) / FIXME: need to provide precise fault address / return ret; if (old_tss_sel != 0xffff) { tss_seg.prev_task_link = old_tss_sel; ret = ops->write_std(ctxt, new_tss_base, &tss_seg.prev_task_link, sizeof tss_seg.prev_task_link, &ctxt->exception); if (ret != X86EMUL_CONTINUE) / FIXME: need to provide precise fault address / return ret; } return load_state_from_tss16(ctxt, &tss_seg); } static void save_state_to_tss32(struct x86_emulate_ctxt ctxt, struct tss_segment_32 tss) { / CR3 and ldt selector are not saved intentionally / tss->eip = ctxt->_eip; tss->eflags = ctxt->eflags; tss->eax = reg_read(ctxt, VCPU_REGS_RAX); tss->ecx = reg_read(ctxt, VCPU_REGS_RCX); tss->edx = reg_read(ctxt, VCPU_REGS_RDX); tss->ebx = reg_read(ctxt, VCPU_REGS_RBX); tss->esp = reg_read(ctxt, VCPU_REGS_RSP); tss->ebp = reg_read(ctxt, VCPU_REGS_RBP); tss->esi = reg_read(ctxt, VCPU_REGS_RSI); tss->edi = reg_read(ctxt, VCPU_REGS_RDI); tss->es = get_segment_selector(ctxt, VCPU_SREG_ES); tss->cs = get_segment_selector(ctxt, VCPU_SREG_CS); tss->ss = get_segment_selector(ctxt, VCPU_SREG_SS); tss->ds = get_segment_selector(ctxt, VCPU_SREG_DS); tss->fs = get_segment_selector(ctxt, VCPU_SREG_FS); tss->gs = get_segment_selector(ctxt, VCPU_SREG_GS); } static int load_state_from_tss32(struct x86_emulate_ctxt ctxt, struct tss_segment_32 tss) { int ret; u8 cpl; if (ctxt->ops->set_cr(ctxt, 3, tss->cr3)) return emulate_gp(ctxt, 0); ctxt->_eip = tss->eip; ctxt->eflags = tss->eflags \| 2; / General purpose registers / reg_write(ctxt, VCPU_REGS_RAX) = tss->eax; reg_write(ctxt, VCPU_REGS_RCX) = tss->ecx; reg_write(ctxt, VCPU_REGS_RDX) = tss->edx; reg_write(ctxt, VCPU_REGS_RBX) = tss->ebx; reg_write(ctxt, VCPU_REGS_RSP) = tss->esp; reg_write(ctxt, VCPU_REGS_RBP) = tss->ebp; reg_write(ctxt, VCPU_REGS_RSI) = tss->esi; reg_write(ctxt, VCPU_REGS_RDI) = tss->edi; / * SDM says that segment selectors are loaded before segment * descriptors. This is important because CPL checks will * use CS.RPL. / set_segment_selector(ctxt, tss->ldt_selector, VCPU_SREG_LDTR); set_segment_selector(ctxt, tss->es, VCPU_SREG_ES); set_segment_selector(ctxt, tss->cs, VCPU_SREG_CS); set_segment_selector(ctxt, tss->ss, VCPU_SREG_SS); set_segment_selector(ctxt, tss->ds, VCPU_SREG_DS); set_segment_selector(ctxt, tss->fs, VCPU_SREG_FS); set_segment_selector(ctxt, tss->gs, VCPU_SREG_GS); / * If we're switching between Protected Mode and VM86, we need to make * sure to update the mode before loading the segment descriptors so * that the selectors are interpreted correctly. / if (ctxt->eflags & X86_EFLAGS_VM) { ctxt->mode = X86EMUL_MODE_VM86; cpl = 3; } else { ctxt->mode = X86EMUL_MODE_PROT32; cpl = tss->cs & 3; } / * Now load segment descriptors. If fault happenes at this stage * it is handled in a context of new task / ret = __load_segment_descriptor(ctxt, tss->ldt_selector, VCPU_SREG_LDTR, cpl, true); if (ret != X86EMUL_CONTINUE) return ret; ret = __load_segment_descriptor(ctxt, tss->es, VCPU_SREG_ES, cpl, true); if (ret != X86EMUL_CONTINUE) return ret; ret = __load_segment_descriptor(ctxt, tss->cs, VCPU_SREG_CS, cpl, true); if (ret != X86EMUL_CONTINUE) return ret; ret = __load_segment_descriptor(ctxt, tss->ss, VCPU_SREG_SS, cpl, true); if (ret != X86EMUL_CONTINUE) return ret; ret = __load_segment_descriptor(ctxt, tss->ds, VCPU_SREG_DS, cpl, true); if (ret != X86EMUL_CONTINUE) return ret; ret = __load_segment_descriptor(ctxt, tss->fs, VCPU_SREG_FS, cpl, true); if (ret != X86EMUL_CONTINUE) return ret; ret = __load_segment_descriptor(ctxt, tss->gs, VCPU_SREG_GS, cpl, true); if (ret != X86EMUL_CONTINUE) return ret; return X86EMUL_CONTINUE; } static int task_switch_32(struct x86_emulate_ctxt ctxt, u16 tss_selector, u16 old_tss_sel, ulong old_tss_base, struct desc_struct new_desc) { const struct x86_emulate_ops ops = ctxt->ops; struct tss_segment_32 tss_seg; int ret; u32 new_tss_base = get_desc_base(new_desc); u32 eip_offset = offsetof(struct tss_segment_32, eip); u32 ldt_sel_offset = offsetof(struct tss_segment_32, ldt_selector); ret = ops->read_std(ctxt, old_tss_base, &tss_seg, sizeof tss_seg, &ctxt->exception); if (ret != X86EMUL_CONTINUE) /* FIXME: need to provide precise fault address / return ret; save_state_to_tss32(ctxt, &tss_seg); / Only GP registers and segment selectors are saved / ret = ops->write_std(ctxt, old_tss_base + eip_offset, &tss_seg.eip, ldt_sel_offset - eip_offset, &ctxt->exception); if (ret != X86EMUL_CONTINUE) / FIXME: need to provide precise fault address / return ret; ret = ops->read_std(ctxt, new_tss_base, &tss_seg, sizeof tss_seg, &ctxt->exception); if (ret != X86EMUL_CONTINUE) / FIXME: need to provide precise fault address / return ret; if (old_tss_sel != 0xffff) { tss_seg.prev_task_link = old_tss_sel; ret = ops->write_std(ctxt, new_tss_base, &tss_seg.prev_task_link, sizeof tss_seg.prev_task_link, &ctxt->exception); if (ret != X86EMUL_CONTINUE) / FIXME: need to provide precise fault address / return ret; } return load_state_from_tss32(ctxt, &tss_seg); } static int emulator_do_task_switch(struct x86_emulate_ctxt ctxt, u16 tss_selector, int idt_index, int reason, bool has_error_code, u32 error_code) { const struct x86_emulate_ops ops = ctxt->ops; struct desc_struct curr_tss_desc, next_tss_desc; int ret; u16 old_tss_sel = get_segment_selector(ctxt, VCPU_SREG_TR); ulong old_tss_base = ops->get_cached_segment_base(ctxt, VCPU_SREG_TR); u32 desc_limit; ulong desc_addr; / FIXME: old_tss_base == ~0 ? / ret = read_segment_descriptor(ctxt, tss_selector, &next_tss_desc, &desc_addr); if (ret != X86EMUL_CONTINUE) return ret; ret = read_segment_descriptor(ctxt, old_tss_sel, &curr_tss_desc, &desc_addr); if (ret != X86EMUL_CONTINUE) return ret; / FIXME: check that next_tss_desc is tss / / * Check privileges. The three cases are task switch caused by... * * 1. jmp/call/int to task gate: Check against DPL of the task gate * 2. Exception/IRQ/iret: No check is performed * 3. jmp/call to TSS: Check against DPL of the TSS / if (reason == TASK_SWITCH_GATE) { if (idt_index != -1) { / Software interrupts / struct desc_struct task_gate_desc; int dpl; ret = read_interrupt_descriptor(ctxt, idt_index, &task_gate_desc); if (ret != X86EMUL_CONTINUE) return ret; dpl = task_gate_desc.dpl; if ((tss_selector & 3) > dpl \|\| ops->cpl(ctxt) > dpl) return emulate_gp(ctxt, (idt_index << 3) \| 0x2); } } else if (reason != TASK_SWITCH_IRET) { int dpl = next_tss_desc.dpl; if ((tss_selector & 3) > dpl \|\| ops->cpl(ctxt) > dpl) return emulate_gp(ctxt, tss_selector); } desc_limit = desc_limit_scaled(&next_tss_desc); if (!next_tss_desc.p \|\| ((desc_limit < 0x67 && (next_tss_desc.type & 8)) \|\| desc_limit < 0x2b)) { return emulate_ts(ctxt, tss_selector & 0xfffc); } if (reason == TASK_SWITCH_IRET \|\| reason == TASK_SWITCH_JMP) { curr_tss_desc.type &= ~(1 << 1); / clear busy flag / write_segment_descriptor(ctxt, old_tss_sel, &curr_tss_desc); } if (reason == TASK_SWITCH_IRET) ctxt->eflags = ctxt->eflags & ~X86_EFLAGS_NT; / set back link to prev task only if NT bit is set in eflags note that old_tss_sel is not used after this point / if (reason != TASK_SWITCH_CALL && reason != TASK_SWITCH_GATE) old_tss_sel = 0xffff; if (next_tss_desc.type & 8) ret = task_switch_32(ctxt, tss_selector, old_tss_sel, old_tss_base, &next_tss_desc); else ret = task_switch_16(ctxt, tss_selector, old_tss_sel, old_tss_base, &next_tss_desc); if (ret != X86EMUL_CONTINUE) return ret; if (reason == TASK_SWITCH_CALL \|\| reason == TASK_SWITCH_GATE) ctxt->eflags = ctxt->eflags \| X86_EFLAGS_NT; if (reason != TASK_SWITCH_IRET) { next_tss_desc.type \|= (1 << 1); / set busy flag / write_segment_descriptor(ctxt, tss_selector, &next_tss_desc); } ops->set_cr(ctxt, 0, ops->get_cr(ctxt, 0) \| X86_CR0_TS); ops->set_segment(ctxt, tss_selector, &next_tss_desc, 0, VCPU_SREG_TR); if (has_error_code) { ctxt->op_bytes = ctxt->ad_bytes = (next_tss_desc.type & 8) ? 4 : 2; ctxt->lock_prefix = 0; ctxt->src.val = (unsigned long) error_code; ret = em_push(ctxt); } return ret; } int emulator_task_switch(struct x86_emulate_ctxt ctxt, u16 tss_selector, int idt_index, int reason, bool has_error_code, u32 error_code) { int rc; invalidate_registers(ctxt); ctxt->_eip = ctxt->eip; ctxt->dst.type = OP_NONE; rc = emulator_do_task_switch(ctxt, tss_selector, idt_index, reason, has_error_code, error_code); if (rc == X86EMUL_CONTINUE) { ctxt->eip = ctxt->_eip; writeback_registers(ctxt); } return (rc == X86EMUL_UNHANDLEABLE) ? EMULATION_FAILED : EMULATION_OK; } static void string_addr_inc(struct x86_emulate_ctxt ctxt, int reg, struct operand op) { int df = (ctxt->eflags & EFLG_DF) ? -op->count : op->count; register_address_increment(ctxt, reg_rmw(ctxt, reg), df * op->bytes); op->addr.mem.ea = register_address(ctxt, reg_read(ctxt, reg)); } static int em_das(struct x86_emulate_ctxt ctxt) { u8 al, old_al; bool af, cf, old_cf; cf = ctxt->eflags & X86_EFLAGS_CF; al = ctxt->dst.val; old_al = al; old_cf = cf; cf = false; af = ctxt->eflags & X86_EFLAGS_AF; if ((al & 0x0f) > 9 \|\| af) { al -= 6; cf = old_cf \| (al >= 250); af = true; } else { af = false; } if (old_al > 0x99 \|\| old_cf) { al -= 0x60; cf = true; } ctxt->dst.val = al; / Set PF, ZF, SF / ctxt->src.type = OP_IMM; ctxt->src.val = 0; ctxt->src.bytes = 1; fastop(ctxt, em_or); ctxt->eflags &= ~(X86_EFLAGS_AF \| X86_EFLAGS_CF); if (cf) ctxt->eflags \|= X86_EFLAGS_CF; if (af) ctxt->eflags \|= X86_EFLAGS_AF; return X86EMUL_CONTINUE; } static int em_aam(struct x86_emulate_ctxt ctxt) { u8 al, ah; if (ctxt->src.val == 0) return emulate_de(ctxt); al = ctxt->dst.val & 0xff; ah = al / ctxt->src.val; al %= ctxt->src.val; ctxt->dst.val = (ctxt->dst.val & 0xffff0000) \| al \| (ah << 8); /* Set PF, ZF, SF / ctxt->src.type = OP_IMM; ctxt->src.val = 0; ctxt->src.bytes = 1; fastop(ctxt, em_or); return X86EMUL_CONTINUE; } static int em_aad(struct x86_emulate_ctxt ctxt) { u8 al = ctxt->dst.val & 0xff; u8 ah = (ctxt->dst.val >> 8) & 0xff; al = (al + (ah * ctxt->src.val)) & 0xff; ctxt->dst.val = (ctxt->dst.val & 0xffff0000) \| al; /* Set PF, ZF, SF / ctxt->src.type = OP_IMM; ctxt->src.val = 0; ctxt->src.bytes = 1; fastop(ctxt, em_or); return X86EMUL_CONTINUE; } static int em_call(struct x86_emulate_ctxt ctxt) { long rel = ctxt->src.val; ctxt->src.val = (unsigned long)ctxt->_eip; jmp_rel(ctxt, rel); return em_push(ctxt); } static int em_call_far(struct x86_emulate_ctxt ctxt) { u16 sel, old_cs; ulong old_eip; int rc; old_cs = get_segment_selector(ctxt, VCPU_SREG_CS); old_eip = ctxt->_eip; memcpy(&sel, ctxt->src.valptr + ctxt->op_bytes, 2); if (load_segment_descriptor(ctxt, sel, VCPU_SREG_CS)) return X86EMUL_CONTINUE; ctxt->_eip = 0; memcpy(&ctxt->_eip, ctxt->src.valptr, ctxt->op_bytes); ctxt->src.val = old_cs; rc = em_push(ctxt); if (rc != X86EMUL_CONTINUE) return rc; ctxt->src.val = old_eip; return em_push(ctxt); } static int em_ret_near_imm(struct x86_emulate_ctxt ctxt) { int rc; ctxt->dst.type = OP_REG; ctxt->dst.addr.reg = &ctxt->_eip; ctxt->dst.bytes = ctxt->op_bytes; rc = emulate_pop(ctxt, &ctxt->dst.val, ctxt->op_bytes); if (rc != X86EMUL_CONTINUE) return rc; rsp_increment(ctxt, ctxt->src.val); return X86EMUL_CONTINUE; } static int em_xchg(struct x86_emulate_ctxt ctxt) { / Write back the register source. / ctxt->src.val = ctxt->dst.val; write_register_operand(&ctxt->src); / Write back the memory destination with implicit LOCK prefix. / ctxt->dst.val = ctxt->src.orig_val; ctxt->lock_prefix = 1; return X86EMUL_CONTINUE; } static int em_imul_3op(struct x86_emulate_ctxt ctxt) { ctxt->dst.val = ctxt->src2.val; return fastop(ctxt, em_imul); } static int em_cwd(struct x86_emulate_ctxt ctxt) { ctxt->dst.type = OP_REG; ctxt->dst.bytes = ctxt->src.bytes; ctxt->dst.addr.reg = reg_rmw(ctxt, VCPU_REGS_RDX); ctxt->dst.val = ~((ctxt->src.val >> (ctxt->src.bytes 8 - 1)) - 1); return X86EMUL_CONTINUE; } static int em_rdtsc(struct x86_emulate_ctxt ctxt) { u64 tsc = 0; ctxt->ops->get_msr(ctxt, MSR_IA32_TSC, &tsc); reg_write(ctxt, VCPU_REGS_RAX) = (u32)tsc; reg_write(ctxt, VCPU_REGS_RDX) = tsc >> 32; return X86EMUL_CONTINUE; } static int em_rdpmc(struct x86_emulate_ctxt ctxt) { u64 pmc; if (ctxt->ops->read_pmc(ctxt, reg_read(ctxt, VCPU_REGS_RCX), &pmc)) return emulate_gp(ctxt, 0); reg_write(ctxt, VCPU_REGS_RAX) = (u32)pmc; reg_write(ctxt, VCPU_REGS_RDX) = pmc >> 32; return X86EMUL_CONTINUE; } static int em_mov(struct x86_emulate_ctxt ctxt) { memcpy(ctxt->dst.valptr, ctxt->src.valptr, sizeof(ctxt->src.valptr)); return X86EMUL_CONTINUE; } #define FFL(x) bit(X86_FEATURE_##x) static int em_movbe(struct x86_emulate_ctxt ctxt) { u32 ebx, ecx, edx, eax = 1; u16 tmp; /* * Check MOVBE is set in the guest-visible CPUID leaf. / ctxt->ops->get_cpuid(ctxt, &eax, &ebx, &ecx, &edx); if (!(ecx & FFL(MOVBE))) return emulate_ud(ctxt); switch (ctxt->op_bytes) { case 2: / * From MOVBE definition: "...When the operand size is 16 bits, * the upper word of the destination register remains unchanged * ..." * * Both casting ->valptr and ->val to u16 breaks strict aliasing * rules so we have to do the operation almost per hand. / tmp = (u16)ctxt->src.val; ctxt->dst.val &= ~0xffffUL; ctxt->dst.val \|= (unsigned long)swab16(tmp); break; case 4: ctxt->dst.val = swab32((u32)ctxt->src.val); break; case 8: ctxt->dst.val = swab64(ctxt->src.val); break; default: BUG(); } return X86EMUL_CONTINUE; } static int em_cr_write(struct x86_emulate_ctxt ctxt) { if (ctxt->ops->set_cr(ctxt, ctxt->modrm_reg, ctxt->src.val)) return emulate_gp(ctxt, 0); /* Disable writeback. / ctxt->dst.type = OP_NONE; return X86EMUL_CONTINUE; } static int em_dr_write(struct x86_emulate_ctxt ctxt) { unsigned long val; if (ctxt->mode == X86EMUL_MODE_PROT64) val = ctxt->src.val & ~0ULL; else val = ctxt->src.val & ~0U; /* #UD condition is already handled. / if (ctxt->ops->set_dr(ctxt, ctxt->modrm_reg, val) < 0) return emulate_gp(ctxt, 0); / Disable writeback. / ctxt->dst.type = OP_NONE; return X86EMUL_CONTINUE; } static int em_wrmsr(struct x86_emulate_ctxt ctxt) { u64 msr_data; msr_data = (u32)reg_read(ctxt, VCPU_REGS_RAX) \| ((u64)reg_read(ctxt, VCPU_REGS_RDX) << 32); if (ctxt->ops->set_msr(ctxt, reg_read(ctxt, VCPU_REGS_RCX), msr_data)) return emulate_gp(ctxt, 0); return X86EMUL_CONTINUE; } static int em_rdmsr(struct x86_emulate_ctxt ctxt) { u64 msr_data; if (ctxt->ops->get_msr(ctxt, reg_read(ctxt, VCPU_REGS_RCX), &msr_data)) return emulate_gp(ctxt, 0); reg_write(ctxt, VCPU_REGS_RAX) = (u32)msr_data; reg_write(ctxt, VCPU_REGS_RDX) = msr_data >> 32; return X86EMUL_CONTINUE; } static int em_mov_rm_sreg(struct x86_emulate_ctxt ctxt) { if (ctxt->modrm_reg > VCPU_SREG_GS) return emulate_ud(ctxt); ctxt->dst.val = get_segment_selector(ctxt, ctxt->modrm_reg); return X86EMUL_CONTINUE; } static int em_mov_sreg_rm(struct x86_emulate_ctxt ctxt) { u16 sel = ctxt->src.val; if (ctxt->modrm_reg == VCPU_SREG_CS \|\| ctxt->modrm_reg > VCPU_SREG_GS) return emulate_ud(ctxt); if (ctxt->modrm_reg == VCPU_SREG_SS) ctxt->interruptibility = KVM_X86_SHADOW_INT_MOV_SS; / Disable writeback. / ctxt->dst.type = OP_NONE; return load_segment_descriptor(ctxt, sel, ctxt->modrm_reg); } static int em_lldt(struct x86_emulate_ctxt ctxt) { u16 sel = ctxt->src.val; /* Disable writeback. / ctxt->dst.type = OP_NONE; return load_segment_descriptor(ctxt, sel, VCPU_SREG_LDTR); } static int em_ltr(struct x86_emulate_ctxt ctxt) { u16 sel = ctxt->src.val; /* Disable writeback. / ctxt->dst.type = OP_NONE; return load_segment_descriptor(ctxt, sel, VCPU_SREG_TR); } static int em_invlpg(struct x86_emulate_ctxt ctxt) { int rc; ulong linear; rc = linearize(ctxt, ctxt->src.addr.mem, 1, false, &linear); if (rc == X86EMUL_CONTINUE) ctxt->ops->invlpg(ctxt, linear); /* Disable writeback. / ctxt->dst.type = OP_NONE; return X86EMUL_CONTINUE; } static int em_clts(struct x86_emulate_ctxt ctxt) { ulong cr0; cr0 = ctxt->ops->get_cr(ctxt, 0); cr0 &= ~X86_CR0_TS; ctxt->ops->set_cr(ctxt, 0, cr0); return X86EMUL_CONTINUE; } static int em_vmcall(struct x86_emulate_ctxt ctxt) { int rc = ctxt->ops->fix_hypercall(ctxt); if (rc != X86EMUL_CONTINUE) return rc; / Let the processor re-execute the fixed hypercall / ctxt->_eip = ctxt->eip; / Disable writeback. / ctxt->dst.type = OP_NONE; return X86EMUL_CONTINUE; } static int emulate_store_desc_ptr(struct x86_emulate_ctxt ctxt, void (get)(struct x86_emulate_ctxt ctxt, struct desc_ptr ptr)) { struct desc_ptr desc_ptr; if (ctxt->mode == X86EMUL_MODE_PROT64) ctxt->op_bytes = 8; get(ctxt, &desc_ptr); if (ctxt->op_bytes == 2) { ctxt->op_bytes = 4; desc_ptr.address &= 0x00ffffff; } / Disable writeback. / ctxt->dst.type = OP_NONE; return segmented_write(ctxt, ctxt->dst.addr.mem, &desc_ptr, 2 + ctxt->op_bytes); } static int em_sgdt(struct x86_emulate_ctxt ctxt) { return emulate_store_desc_ptr(ctxt, ctxt->ops->get_gdt); } static int em_sidt(struct x86_emulate_ctxt ctxt) { return emulate_store_desc_ptr(ctxt, ctxt->ops->get_idt); } static int em_lgdt(struct x86_emulate_ctxt ctxt) { struct desc_ptr desc_ptr; int rc; if (ctxt->mode == X86EMUL_MODE_PROT64) ctxt->op_bytes = 8; rc = read_descriptor(ctxt, ctxt->src.addr.mem, &desc_ptr.size, &desc_ptr.address, ctxt->op_bytes); if (rc != X86EMUL_CONTINUE) return rc; ctxt->ops->set_gdt(ctxt, &desc_ptr); /* Disable writeback. / ctxt->dst.type = OP_NONE; return X86EMUL_CONTINUE; } static int em_vmmcall(struct x86_emulate_ctxt ctxt) { int rc; rc = ctxt->ops->fix_hypercall(ctxt); /* Disable writeback. / ctxt->dst.type = OP_NONE; return rc; } static int em_lidt(struct x86_emulate_ctxt ctxt) { struct desc_ptr desc_ptr; int rc; if (ctxt->mode == X86EMUL_MODE_PROT64) ctxt->op_bytes = 8; rc = read_descriptor(ctxt, ctxt->src.addr.mem, &desc_ptr.size, &desc_ptr.address, ctxt->op_bytes); if (rc != X86EMUL_CONTINUE) return rc; ctxt->ops->set_idt(ctxt, &desc_ptr); /* Disable writeback. / ctxt->dst.type = OP_NONE; return X86EMUL_CONTINUE; } static int em_smsw(struct x86_emulate_ctxt ctxt) { if (ctxt->dst.type == OP_MEM) ctxt->dst.bytes = 2; ctxt->dst.val = ctxt->ops->get_cr(ctxt, 0); return X86EMUL_CONTINUE; } static int em_lmsw(struct x86_emulate_ctxt ctxt) { ctxt->ops->set_cr(ctxt, 0, (ctxt->ops->get_cr(ctxt, 0) & ~0x0eul) \| (ctxt->src.val & 0x0f)); ctxt->dst.type = OP_NONE; return X86EMUL_CONTINUE; } static int em_loop(struct x86_emulate_ctxt ctxt) { register_address_increment(ctxt, reg_rmw(ctxt, VCPU_REGS_RCX), -1); if ((address_mask(ctxt, reg_read(ctxt, VCPU_REGS_RCX)) != 0) && (ctxt->b == 0xe2 \|\| test_cc(ctxt->b ^ 0x5, ctxt->eflags))) jmp_rel(ctxt, ctxt->src.val); return X86EMUL_CONTINUE; } static int em_jcxz(struct x86_emulate_ctxt ctxt) { if (address_mask(ctxt, reg_read(ctxt, VCPU_REGS_RCX)) == 0) jmp_rel(ctxt, ctxt->src.val); return X86EMUL_CONTINUE; } static int em_in(struct x86_emulate_ctxt ctxt) { if (!pio_in_emulated(ctxt, ctxt->dst.bytes, ctxt->src.val, &ctxt->dst.val)) return X86EMUL_IO_NEEDED; return X86EMUL_CONTINUE; } static int em_out(struct x86_emulate_ctxt ctxt) { ctxt->ops->pio_out_emulated(ctxt, ctxt->src.bytes, ctxt->dst.val, &ctxt->src.val, 1); / Disable writeback. / ctxt->dst.type = OP_NONE; return X86EMUL_CONTINUE; } static int em_cli(struct x86_emulate_ctxt ctxt) { if (emulator_bad_iopl(ctxt)) return emulate_gp(ctxt, 0); ctxt->eflags &= ~X86_EFLAGS_IF; return X86EMUL_CONTINUE; } static int em_sti(struct x86_emulate_ctxt ctxt) { if (emulator_bad_iopl(ctxt)) return emulate_gp(ctxt, 0); ctxt->interruptibility = KVM_X86_SHADOW_INT_STI; ctxt->eflags \|= X86_EFLAGS_IF; return X86EMUL_CONTINUE; } static int em_cpuid(struct x86_emulate_ctxt ctxt) { u32 eax, ebx, ecx, edx; eax = reg_read(ctxt, VCPU_REGS_RAX); ecx = reg_read(ctxt, VCPU_REGS_RCX); ctxt->ops->get_cpuid(ctxt, &eax, &ebx, &ecx, &edx); reg_write(ctxt, VCPU_REGS_RAX) = eax; reg_write(ctxt, VCPU_REGS_RBX) = ebx; reg_write(ctxt, VCPU_REGS_RCX) = ecx; reg_write(ctxt, VCPU_REGS_RDX) = edx; return X86EMUL_CONTINUE; } static int em_sahf(struct x86_emulate_ctxt ctxt) { u32 flags; flags = EFLG_CF \| EFLG_PF \| EFLG_AF \| EFLG_ZF \| EFLG_SF; flags &= reg_rmw(ctxt, VCPU_REGS_RAX) >> 8; ctxt->eflags &= ~0xffUL; ctxt->eflags \|= flags \| X86_EFLAGS_FIXED; return X86EMUL_CONTINUE; } static int em_lahf(struct x86_emulate_ctxt ctxt) { reg_rmw(ctxt, VCPU_REGS_RAX) &= ~0xff00UL; reg_rmw(ctxt, VCPU_REGS_RAX) \|= (ctxt->eflags & 0xff) << 8; return X86EMUL_CONTINUE; } static int em_bswap(struct x86_emulate_ctxt ctxt) { switch (ctxt->op_bytes) { #ifdef CONFIG_X86_64 case 8: asm("bswap %0" : "+r"(ctxt->dst.val)); break; #endif default: asm("bswap %0" : "+r"((u32 )&ctxt->dst.val)); break; } return X86EMUL_CONTINUE; } static bool valid_cr(int nr) { switch (nr) { case 0: case 2 ... 4: case 8: return true; default: return false; } } static int check_cr_read(struct x86_emulate_ctxt ctxt) { if (!valid_cr(ctxt->modrm_reg)) return emulate_ud(ctxt); return X86EMUL_CONTINUE; } static int check_cr_write(struct x86_emulate_ctxt ctxt) { u64 new_val = ctxt->src.val64; int cr = ctxt->modrm_reg; u64 efer = 0; static u64 cr_reserved_bits[] = { 0xffffffff00000000ULL, 0, 0, 0, /* CR3 checked later / CR4_RESERVED_BITS, 0, 0, 0, CR8_RESERVED_BITS, }; if (!valid_cr(cr)) return emulate_ud(ctxt); if (new_val & cr_reserved_bits[cr]) return emulate_gp(ctxt, 0); switch (cr) { case 0: { u64 cr4; if (((new_val & X86_CR0_PG) && !(new_val & X86_CR0_PE)) \|\| ((new_val & X86_CR0_NW) && !(new_val & X86_CR0_CD))) return emulate_gp(ctxt, 0); cr4 = ctxt->ops->get_cr(ctxt, 4); ctxt->ops->get_msr(ctxt, MSR_EFER, &efer); if ((new_val & X86_CR0_PG) && (efer & EFER_LME) && !(cr4 & X86_CR4_PAE)) return emulate_gp(ctxt, 0); break; } case 3: { u64 rsvd = 0; ctxt->ops->get_msr(ctxt, MSR_EFER, &efer); if (efer & EFER_LMA) rsvd = CR3_L_MODE_RESERVED_BITS; if (new_val & rsvd) return emulate_gp(ctxt, 0); break; } case 4: { ctxt->ops->get_msr(ctxt, MSR_EFER, &efer); if ((efer & EFER_LMA) && !(new_val & X86_CR4_PAE)) return emulate_gp(ctxt, 0); break; } } return X86EMUL_CONTINUE; } static int check_dr7_gd(struct x86_emulate_ctxt ctxt) { unsigned long dr7; ctxt->ops->get_dr(ctxt, 7, &dr7); /* Check if DR7.Global_Enable is set / return dr7 & (1 << 13); } static int check_dr_read(struct x86_emulate_ctxt ctxt) { int dr = ctxt->modrm_reg; u64 cr4; if (dr > 7) return emulate_ud(ctxt); cr4 = ctxt->ops->get_cr(ctxt, 4); if ((cr4 & X86_CR4_DE) && (dr == 4 \|\| dr == 5)) return emulate_ud(ctxt); if (check_dr7_gd(ctxt)) return emulate_db(ctxt); return X86EMUL_CONTINUE; } static int check_dr_write(struct x86_emulate_ctxt ctxt) { u64 new_val = ctxt->src.val64; int dr = ctxt->modrm_reg; if ((dr == 6 \|\| dr == 7) && (new_val & 0xffffffff00000000ULL)) return emulate_gp(ctxt, 0); return check_dr_read(ctxt); } static int check_svme(struct x86_emulate_ctxt ctxt) { u64 efer; ctxt->ops->get_msr(ctxt, MSR_EFER, &efer); if (!(efer & EFER_SVME)) return emulate_ud(ctxt); return X86EMUL_CONTINUE; } static int check_svme_pa(struct x86_emulate_ctxt ctxt) { u64 rax = reg_read(ctxt, VCPU_REGS_RAX); / Valid physical address? / if (rax & 0xffff000000000000ULL) return emulate_gp(ctxt, 0); return check_svme(ctxt); } static int check_rdtsc(struct x86_emulate_ctxt ctxt) { u64 cr4 = ctxt->ops->get_cr(ctxt, 4); if (cr4 & X86_CR4_TSD && ctxt->ops->cpl(ctxt)) return emulate_ud(ctxt); return X86EMUL_CONTINUE; } static int check_rdpmc(struct x86_emulate_ctxt ctxt) { u64 cr4 = ctxt->ops->get_cr(ctxt, 4); u64 rcx = reg_read(ctxt, VCPU_REGS_RCX); if ((!(cr4 & X86_CR4_PCE) && ctxt->ops->cpl(ctxt)) \|\| ctxt->ops->check_pmc(ctxt, rcx)) return emulate_gp(ctxt, 0); return X86EMUL_CONTINUE; } static int check_perm_in(struct x86_emulate_ctxt ctxt) { ctxt->dst.bytes = min(ctxt->dst.bytes, 4u); if (!emulator_io_permited(ctxt, ctxt->src.val, ctxt->dst.bytes)) return emulate_gp(ctxt, 0); return X86EMUL_CONTINUE; } static int check_perm_out(struct x86_emulate_ctxt ctxt) { ctxt->src.bytes = min(ctxt->src.bytes, 4u); if (!emulator_io_permited(ctxt, ctxt->dst.val, ctxt->src.bytes)) return emulate_gp(ctxt, 0); return X86EMUL_CONTINUE; } #define D(_y) { .flags = (_y) } #define DI(_y, _i) { .flags = (_y)\|Intercept, .intercept = x86_intercept_##_i } #define DIP(_y, _i, _p) { .flags = (_y)\|Intercept\|CheckPerm, \ .intercept = x86_intercept_##_i, .check_perm = (_p) } #define N D(NotImpl) #define EXT(_f, _e) { .flags = ((_f) \| RMExt), .u.group = (_e) } #define G(_f, _g) { .flags = ((_f) \| Group \| ModRM), .u.group = (_g) } #define GD(_f, _g) { .flags = ((_f) \| GroupDual \| ModRM), .u.gdual = (_g) } #define E(_f, _e) { .flags = ((_f) \| Escape \| ModRM), .u.esc = (_e) } #define I(_f, _e) { .flags = (_f), .u.execute = (_e) } #define F(_f, _e) { .flags = (_f) \| Fastop, .u.fastop = (_e) } #define II(_f, _e, _i) \ { .flags = (_f)\|Intercept, .u.execute = (_e), .intercept = x86_intercept_##_i } #define IIP(_f, _e, _i, _p) \ { .flags = (_f)\|Intercept\|CheckPerm, .u.execute = (_e), \ .intercept = x86_intercept_##_i, .check_perm = (_p) } #define GP(_f, _g) { .flags = ((_f) \| Prefix), .u.gprefix = (_g) } #define D2bv(_f) D((_f) \| ByteOp), D(_f) #define D2bvIP(_f, _i, _p) DIP((_f) \| ByteOp, _i, _p), DIP(_f, _i, _p) #define I2bv(_f, _e) I((_f) \| ByteOp, _e), I(_f, _e) #define F2bv(_f, _e) F((_f) \| ByteOp, _e), F(_f, _e) #define I2bvIP(_f, _e, _i, _p) \ IIP((_f) \| ByteOp, _e, _i, _p), IIP(_f, _e, _i, _p) #define F6ALU(_f, _e) F2bv((_f) \| DstMem \| SrcReg \| ModRM, _e), \ F2bv(((_f) \| DstReg \| SrcMem \| ModRM) & ~Lock, _e), \ F2bv(((_f) & ~Lock) \| DstAcc \| SrcImm, _e) static const struct opcode group7_rm0[] = { N, I(SrcNone \| Priv \| EmulateOnUD, em_vmcall), N, N, N, N, N, N, }; static const struct opcode group7_rm1[] = { DI(SrcNone \| Priv, monitor), DI(SrcNone \| Priv, mwait), N, N, N, N, N, N, }; static const struct opcode group7_rm3[] = { DIP(SrcNone \| Prot \| Priv, vmrun, check_svme_pa), II(SrcNone \| Prot \| EmulateOnUD, em_vmmcall, vmmcall), DIP(SrcNone \| Prot \| Priv, vmload, check_svme_pa), DIP(SrcNone \| Prot \| Priv, vmsave, check_svme_pa), DIP(SrcNone \| Prot \| Priv, stgi, check_svme), DIP(SrcNone \| Prot \| Priv, clgi, check_svme), DIP(SrcNone \| Prot \| Priv, skinit, check_svme), DIP(SrcNone \| Prot \| Priv, invlpga, check_svme), }; static const struct opcode group7_rm7[] = { N, DIP(SrcNone, rdtscp, check_rdtsc), N, N, N, N, N, N, }; static const struct opcode group1[] = { F(Lock, em_add), F(Lock \| PageTable, em_or), F(Lock, em_adc), F(Lock, em_sbb), F(Lock \| PageTable, em_and), F(Lock, em_sub), F(Lock, em_xor), F(NoWrite, em_cmp), }; static const struct opcode group1A[] = { I(DstMem \| SrcNone \| Mov \| Stack, em_pop), N, N, N, N, N, N, N, }; static const struct opcode group2[] = { F(DstMem \| ModRM, em_rol), F(DstMem \| ModRM, em_ror), F(DstMem \| ModRM, em_rcl), F(DstMem \| ModRM, em_rcr), F(DstMem \| ModRM, em_shl), F(DstMem \| ModRM, em_shr), F(DstMem \| ModRM, em_shl), F(DstMem \| ModRM, em_sar), }; static const struct opcode group3[] = { F(DstMem \| SrcImm \| NoWrite, em_test), F(DstMem \| SrcImm \| NoWrite, em_test), F(DstMem \| SrcNone \| Lock, em_not), F(DstMem \| SrcNone \| Lock, em_neg), F(DstXacc \| Src2Mem, em_mul_ex), F(DstXacc \| Src2Mem, em_imul_ex), F(DstXacc \| Src2Mem, em_div_ex), F(DstXacc \| Src2Mem, em_idiv_ex), }; static const struct opcode group4[] = { F(ByteOp \| DstMem \| SrcNone \| Lock, em_inc), F(ByteOp \| DstMem \| SrcNone \| Lock, em_dec), N, N, N, N, N, N, }; static const struct opcode group5[] = { F(DstMem \| SrcNone \| Lock, em_inc), F(DstMem \| SrcNone \| Lock, em_dec), I(SrcMem \| Stack, em_grp45), I(SrcMemFAddr \| ImplicitOps \| Stack, em_call_far), I(SrcMem \| Stack, em_grp45), I(SrcMemFAddr \| ImplicitOps, em_grp45), I(SrcMem \| Stack, em_grp45), D(Undefined), }; static const struct opcode group6[] = { DI(Prot, sldt), DI(Prot, str), II(Prot \| Priv \| SrcMem16, em_lldt, lldt), II(Prot \| Priv \| SrcMem16, em_ltr, ltr), N, N, N, N, }; static const struct group_dual group7 = { { II(Mov \| DstMem, em_sgdt, sgdt), II(Mov \| DstMem, em_sidt, sidt), II(SrcMem \| Priv, em_lgdt, lgdt), II(SrcMem \| Priv, em_lidt, lidt), II(SrcNone \| DstMem \| Mov, em_smsw, smsw), N, II(SrcMem16 \| Mov \| Priv, em_lmsw, lmsw), II(SrcMem \| ByteOp \| Priv \| NoAccess, em_invlpg, invlpg), }, { EXT(0, group7_rm0), EXT(0, group7_rm1), N, EXT(0, group7_rm3), II(SrcNone \| DstMem \| Mov, em_smsw, smsw), N, II(SrcMem16 \| Mov \| Priv, em_lmsw, lmsw), EXT(0, group7_rm7), } }; static const struct opcode group8[] = { N, N, N, N, F(DstMem \| SrcImmByte \| NoWrite, em_bt), F(DstMem \| SrcImmByte \| Lock \| PageTable, em_bts), F(DstMem \| SrcImmByte \| Lock, em_btr), F(DstMem \| SrcImmByte \| Lock \| PageTable, em_btc), }; static const struct group_dual group9 = { { N, I(DstMem64 \| Lock \| PageTable, em_cmpxchg8b), N, N, N, N, N, N, }, { N, N, N, N, N, N, N, N, } }; static const struct opcode group11[] = { I(DstMem \| SrcImm \| Mov \| PageTable, em_mov), X7(D(Undefined)), }; static const struct gprefix pfx_0f_6f_0f_7f = { I(Mmx, em_mov), I(Sse \| Aligned, em_mov), N, I(Sse \| Unaligned, em_mov), }; static const struct gprefix pfx_0f_2b = { I(0, em_mov), I(0, em_mov), N, N, }; static const struct gprefix pfx_0f_28_0f_29 = { I(Aligned, em_mov), I(Aligned, em_mov), N, N, }; static const struct gprefix pfx_0f_e7 = { N, I(Sse, em_mov), N, N, }; static const struct escape escape_d9 = { { N, N, N, N, N, N, N, I(DstMem, em_fnstcw), }, { / 0xC0 - 0xC7 / N, N, N, N, N, N, N, N, / 0xC8 - 0xCF / N, N, N, N, N, N, N, N, / 0xD0 - 0xC7 / N, N, N, N, N, N, N, N, / 0xD8 - 0xDF / N, N, N, N, N, N, N, N, / 0xE0 - 0xE7 / N, N, N, N, N, N, N, N, / 0xE8 - 0xEF / N, N, N, N, N, N, N, N, / 0xF0 - 0xF7 / N, N, N, N, N, N, N, N, / 0xF8 - 0xFF / N, N, N, N, N, N, N, N, } }; static const struct escape escape_db = { { N, N, N, N, N, N, N, N, }, { / 0xC0 - 0xC7 / N, N, N, N, N, N, N, N, / 0xC8 - 0xCF / N, N, N, N, N, N, N, N, / 0xD0 - 0xC7 / N, N, N, N, N, N, N, N, / 0xD8 - 0xDF / N, N, N, N, N, N, N, N, / 0xE0 - 0xE7 / N, N, N, I(ImplicitOps, em_fninit), N, N, N, N, / 0xE8 - 0xEF / N, N, N, N, N, N, N, N, / 0xF0 - 0xF7 / N, N, N, N, N, N, N, N, / 0xF8 - 0xFF / N, N, N, N, N, N, N, N, } }; static const struct escape escape_dd = { { N, N, N, N, N, N, N, I(DstMem, em_fnstsw), }, { / 0xC0 - 0xC7 / N, N, N, N, N, N, N, N, / 0xC8 - 0xCF / N, N, N, N, N, N, N, N, / 0xD0 - 0xC7 / N, N, N, N, N, N, N, N, / 0xD8 - 0xDF / N, N, N, N, N, N, N, N, / 0xE0 - 0xE7 / N, N, N, N, N, N, N, N, / 0xE8 - 0xEF / N, N, N, N, N, N, N, N, / 0xF0 - 0xF7 / N, N, N, N, N, N, N, N, / 0xF8 - 0xFF / N, N, N, N, N, N, N, N, } }; static const struct opcode opcode_table[256] = { / 0x00 - 0x07 / F6ALU(Lock, em_add), I(ImplicitOps \| Stack \| No64 \| Src2ES, em_push_sreg), I(ImplicitOps \| Stack \| No64 \| Src2ES, em_pop_sreg), / 0x08 - 0x0F / F6ALU(Lock \| PageTable, em_or), I(ImplicitOps \| Stack \| No64 \| Src2CS, em_push_sreg), N, / 0x10 - 0x17 / F6ALU(Lock, em_adc), I(ImplicitOps \| Stack \| No64 \| Src2SS, em_push_sreg), I(ImplicitOps \| Stack \| No64 \| Src2SS, em_pop_sreg), / 0x18 - 0x1F / F6ALU(Lock, em_sbb), I(ImplicitOps \| Stack \| No64 \| Src2DS, em_push_sreg), I(ImplicitOps \| Stack \| No64 \| Src2DS, em_pop_sreg), / 0x20 - 0x27 / F6ALU(Lock \| PageTable, em_and), N, N, / 0x28 - 0x2F / F6ALU(Lock, em_sub), N, I(ByteOp \| DstAcc \| No64, em_das), / 0x30 - 0x37 / F6ALU(Lock, em_xor), N, N, / 0x38 - 0x3F / F6ALU(NoWrite, em_cmp), N, N, / 0x40 - 0x4F / X8(F(DstReg, em_inc)), X8(F(DstReg, em_dec)), / 0x50 - 0x57 / X8(I(SrcReg \| Stack, em_push)), / 0x58 - 0x5F / X8(I(DstReg \| Stack, em_pop)), / 0x60 - 0x67 / I(ImplicitOps \| Stack \| No64, em_pusha), I(ImplicitOps \| Stack \| No64, em_popa), N, D(DstReg \| SrcMem32 \| ModRM \| Mov) / movsxd (x86/64) / , N, N, N, N, / 0x68 - 0x6F / I(SrcImm \| Mov \| Stack, em_push), I(DstReg \| SrcMem \| ModRM \| Src2Imm, em_imul_3op), I(SrcImmByte \| Mov \| Stack, em_push), I(DstReg \| SrcMem \| ModRM \| Src2ImmByte, em_imul_3op), I2bvIP(DstDI \| SrcDX \| Mov \| String \| Unaligned, em_in, ins, check_perm_in), / insb, insw/insd / I2bvIP(SrcSI \| DstDX \| String, em_out, outs, check_perm_out), / outsb, outsw/outsd / / 0x70 - 0x7F / X16(D(SrcImmByte)), / 0x80 - 0x87 / G(ByteOp \| DstMem \| SrcImm, group1), G(DstMem \| SrcImm, group1), G(ByteOp \| DstMem \| SrcImm \| No64, group1), G(DstMem \| SrcImmByte, group1), F2bv(DstMem \| SrcReg \| ModRM \| NoWrite, em_test), I2bv(DstMem \| SrcReg \| ModRM \| Lock \| PageTable, em_xchg), / 0x88 - 0x8F / I2bv(DstMem \| SrcReg \| ModRM \| Mov \| PageTable, em_mov), I2bv(DstReg \| SrcMem \| ModRM \| Mov, em_mov), I(DstMem \| SrcNone \| ModRM \| Mov \| PageTable, em_mov_rm_sreg), D(ModRM \| SrcMem \| NoAccess \| DstReg), I(ImplicitOps \| SrcMem16 \| ModRM, em_mov_sreg_rm), G(0, group1A), / 0x90 - 0x97 / DI(SrcAcc \| DstReg, pause), X7(D(SrcAcc \| DstReg)), / 0x98 - 0x9F / D(DstAcc \| SrcNone), I(ImplicitOps \| SrcAcc, em_cwd), I(SrcImmFAddr \| No64, em_call_far), N, II(ImplicitOps \| Stack, em_pushf, pushf), II(ImplicitOps \| Stack, em_popf, popf), I(ImplicitOps, em_sahf), I(ImplicitOps, em_lahf), / 0xA0 - 0xA7 / I2bv(DstAcc \| SrcMem \| Mov \| MemAbs, em_mov), I2bv(DstMem \| SrcAcc \| Mov \| MemAbs \| PageTable, em_mov), I2bv(SrcSI \| DstDI \| Mov \| String, em_mov), F2bv(SrcSI \| DstDI \| String \| NoWrite, em_cmp), / 0xA8 - 0xAF / F2bv(DstAcc \| SrcImm \| NoWrite, em_test), I2bv(SrcAcc \| DstDI \| Mov \| String, em_mov), I2bv(SrcSI \| DstAcc \| Mov \| String, em_mov), F2bv(SrcAcc \| DstDI \| String \| NoWrite, em_cmp), / 0xB0 - 0xB7 / X8(I(ByteOp \| DstReg \| SrcImm \| Mov, em_mov)), / 0xB8 - 0xBF / X8(I(DstReg \| SrcImm64 \| Mov, em_mov)), / 0xC0 - 0xC7 / G(ByteOp \| Src2ImmByte, group2), G(Src2ImmByte, group2), I(ImplicitOps \| Stack \| SrcImmU16, em_ret_near_imm), I(ImplicitOps \| Stack, em_ret), I(DstReg \| SrcMemFAddr \| ModRM \| No64 \| Src2ES, em_lseg), I(DstReg \| SrcMemFAddr \| ModRM \| No64 \| Src2DS, em_lseg), G(ByteOp, group11), G(0, group11), / 0xC8 - 0xCF / I(Stack \| SrcImmU16 \| Src2ImmByte, em_enter), I(Stack, em_leave), I(ImplicitOps \| Stack \| SrcImmU16, em_ret_far_imm), I(ImplicitOps \| Stack, em_ret_far), D(ImplicitOps), DI(SrcImmByte, intn), D(ImplicitOps \| No64), II(ImplicitOps, em_iret, iret), / 0xD0 - 0xD7 / G(Src2One \| ByteOp, group2), G(Src2One, group2), G(Src2CL \| ByteOp, group2), G(Src2CL, group2), I(DstAcc \| SrcImmUByte \| No64, em_aam), I(DstAcc \| SrcImmUByte \| No64, em_aad), F(DstAcc \| ByteOp \| No64, em_salc), I(DstAcc \| SrcXLat \| ByteOp, em_mov), / 0xD8 - 0xDF / N, E(0, &escape_d9), N, E(0, &escape_db), N, E(0, &escape_dd), N, N, / 0xE0 - 0xE7 / X3(I(SrcImmByte, em_loop)), I(SrcImmByte, em_jcxz), I2bvIP(SrcImmUByte \| DstAcc, em_in, in, check_perm_in), I2bvIP(SrcAcc \| DstImmUByte, em_out, out, check_perm_out), / 0xE8 - 0xEF / I(SrcImm \| Stack, em_call), D(SrcImm \| ImplicitOps), I(SrcImmFAddr \| No64, em_jmp_far), D(SrcImmByte \| ImplicitOps), I2bvIP(SrcDX \| DstAcc, em_in, in, check_perm_in), I2bvIP(SrcAcc \| DstDX, em_out, out, check_perm_out), / 0xF0 - 0xF7 / N, DI(ImplicitOps, icebp), N, N, DI(ImplicitOps \| Priv, hlt), D(ImplicitOps), G(ByteOp, group3), G(0, group3), / 0xF8 - 0xFF / D(ImplicitOps), D(ImplicitOps), I(ImplicitOps, em_cli), I(ImplicitOps, em_sti), D(ImplicitOps), D(ImplicitOps), G(0, group4), G(0, group5), }; static const struct opcode twobyte_table[256] = { / 0x00 - 0x0F / G(0, group6), GD(0, &group7), N, N, N, I(ImplicitOps \| EmulateOnUD, em_syscall), II(ImplicitOps \| Priv, em_clts, clts), N, DI(ImplicitOps \| Priv, invd), DI(ImplicitOps \| Priv, wbinvd), N, N, N, D(ImplicitOps \| ModRM), N, N, / 0x10 - 0x1F / N, N, N, N, N, N, N, N, D(ImplicitOps \| ModRM), N, N, N, N, N, N, D(ImplicitOps \| ModRM), / 0x20 - 0x2F / DIP(ModRM \| DstMem \| Priv \| Op3264 \| NoMod, cr_read, check_cr_read), DIP(ModRM \| DstMem \| Priv \| Op3264 \| NoMod, dr_read, check_dr_read), IIP(ModRM \| SrcMem \| Priv \| Op3264 \| NoMod, em_cr_write, cr_write, check_cr_write), IIP(ModRM \| SrcMem \| Priv \| Op3264 \| NoMod, em_dr_write, dr_write, check_dr_write), N, N, N, N, GP(ModRM \| DstReg \| SrcMem \| Mov \| Sse, &pfx_0f_28_0f_29), GP(ModRM \| DstMem \| SrcReg \| Mov \| Sse, &pfx_0f_28_0f_29), N, GP(ModRM \| DstMem \| SrcReg \| Mov \| Sse, &pfx_0f_2b), N, N, N, N, / 0x30 - 0x3F / II(ImplicitOps \| Priv, em_wrmsr, wrmsr), IIP(ImplicitOps, em_rdtsc, rdtsc, check_rdtsc), II(ImplicitOps \| Priv, em_rdmsr, rdmsr), IIP(ImplicitOps, em_rdpmc, rdpmc, check_rdpmc), I(ImplicitOps \| EmulateOnUD, em_sysenter), I(ImplicitOps \| Priv \| EmulateOnUD, em_sysexit), N, N, N, N, N, N, N, N, N, N, / 0x40 - 0x4F / X16(D(DstReg \| SrcMem \| ModRM)), / 0x50 - 0x5F / N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, / 0x60 - 0x6F / N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, GP(SrcMem \| DstReg \| ModRM \| Mov, &pfx_0f_6f_0f_7f), / 0x70 - 0x7F / N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, GP(SrcReg \| DstMem \| ModRM \| Mov, &pfx_0f_6f_0f_7f), / 0x80 - 0x8F / X16(D(SrcImm)), / 0x90 - 0x9F / X16(D(ByteOp \| DstMem \| SrcNone \| ModRM\| Mov)), / 0xA0 - 0xA7 / I(Stack \| Src2FS, em_push_sreg), I(Stack \| Src2FS, em_pop_sreg), II(ImplicitOps, em_cpuid, cpuid), F(DstMem \| SrcReg \| ModRM \| BitOp \| NoWrite, em_bt), F(DstMem \| SrcReg \| Src2ImmByte \| ModRM, em_shld), F(DstMem \| SrcReg \| Src2CL \| ModRM, em_shld), N, N, / 0xA8 - 0xAF / I(Stack \| Src2GS, em_push_sreg), I(Stack \| Src2GS, em_pop_sreg), DI(ImplicitOps, rsm), F(DstMem \| SrcReg \| ModRM \| BitOp \| Lock \| PageTable, em_bts), F(DstMem \| SrcReg \| Src2ImmByte \| ModRM, em_shrd), F(DstMem \| SrcReg \| Src2CL \| ModRM, em_shrd), D(ModRM), F(DstReg \| SrcMem \| ModRM, em_imul), / 0xB0 - 0xB7 / I2bv(DstMem \| SrcReg \| ModRM \| Lock \| PageTable, em_cmpxchg), I(DstReg \| SrcMemFAddr \| ModRM \| Src2SS, em_lseg), F(DstMem \| SrcReg \| ModRM \| BitOp \| Lock, em_btr), I(DstReg \| SrcMemFAddr \| ModRM \| Src2FS, em_lseg), I(DstReg \| SrcMemFAddr \| ModRM \| Src2GS, em_lseg), D(DstReg \| SrcMem8 \| ModRM \| Mov), D(DstReg \| SrcMem16 \| ModRM \| Mov), / 0xB8 - 0xBF / N, N, G(BitOp, group8), F(DstMem \| SrcReg \| ModRM \| BitOp \| Lock \| PageTable, em_btc), F(DstReg \| SrcMem \| ModRM, em_bsf), F(DstReg \| SrcMem \| ModRM, em_bsr), D(DstReg \| SrcMem8 \| ModRM \| Mov), D(DstReg \| SrcMem16 \| ModRM \| Mov), / 0xC0 - 0xC7 / F2bv(DstMem \| SrcReg \| ModRM \| SrcWrite \| Lock, em_xadd), N, D(DstMem \| SrcReg \| ModRM \| Mov), N, N, N, GD(0, &group9), / 0xC8 - 0xCF / X8(I(DstReg, em_bswap)), / 0xD0 - 0xDF / N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, / 0xE0 - 0xEF / N, N, N, N, N, N, N, GP(SrcReg \| DstMem \| ModRM \| Mov, &pfx_0f_e7), N, N, N, N, N, N, N, N, / 0xF0 - 0xFF / N, N, N, N, N, N, N, N, N, N, N, N, N, N, N, N }; static const struct gprefix three_byte_0f_38_f0 = { I(DstReg \| SrcMem \| Mov, em_movbe), N, N, N }; static const struct gprefix three_byte_0f_38_f1 = { I(DstMem \| SrcReg \| Mov, em_movbe), N, N, N }; / * Insns below are selected by the prefix which indexed by the third opcode * byte. / static const struct opcode opcode_map_0f_38[256] = { / 0x00 - 0x7f / X16(N), X16(N), X16(N), X16(N), X16(N), X16(N), X16(N), X16(N), / 0x80 - 0xef / X16(N), X16(N), X16(N), X16(N), X16(N), X16(N), X16(N), / 0xf0 - 0xf1 / GP(EmulateOnUD \| ModRM \| Prefix, &three_byte_0f_38_f0), GP(EmulateOnUD \| ModRM \| Prefix, &three_byte_0f_38_f1), / 0xf2 - 0xff / N, N, X4(N), X8(N) }; #undef D #undef N #undef G #undef GD #undef I #undef GP #undef EXT #undef D2bv #undef D2bvIP #undef I2bv #undef I2bvIP #undef I6ALU static unsigned imm_size(struct x86_emulate_ctxt ctxt) { unsigned size; size = (ctxt->d & ByteOp) ? 1 : ctxt->op_bytes; if (size == 8) size = 4; return size; } static int decode_imm(struct x86_emulate_ctxt ctxt, struct operand op, unsigned size, bool sign_extension) { int rc = X86EMUL_CONTINUE; op->type = OP_IMM; op->bytes = size; op->addr.mem.ea = ctxt->_eip; /* NB. Immediates are sign-extended as necessary. / switch (op->bytes) { case 1: op->val = insn_fetch(s8, ctxt); break; case 2: op->val = insn_fetch(s16, ctxt); break; case 4: op->val = insn_fetch(s32, ctxt); break; case 8: op->val = insn_fetch(s64, ctxt); break; } if (!sign_extension) { switch (op->bytes) { case 1: op->val &= 0xff; break; case 2: op->val &= 0xffff; break; case 4: op->val &= 0xffffffff; break; } } done: return rc; } static int decode_operand(struct x86_emulate_ctxt ctxt, struct operand op, unsigned d) { int rc = X86EMUL_CONTINUE; switch (d) { case OpReg: decode_register_operand(ctxt, op); break; case OpImmUByte: rc = decode_imm(ctxt, op, 1, false); break; case OpMem: ctxt->memop.bytes = (ctxt->d & ByteOp) ? 1 : ctxt->op_bytes; mem_common: op = ctxt->memop; ctxt->memopp = op; if (ctxt->d & BitOp) fetch_bit_operand(ctxt); op->orig_val = op->val; break; case OpMem64: ctxt->memop.bytes = (ctxt->op_bytes == 8) ? 16 : 8; goto mem_common; case OpAcc: op->type = OP_REG; op->bytes = (ctxt->d & ByteOp) ? 1 : ctxt->op_bytes; op->addr.reg = reg_rmw(ctxt, VCPU_REGS_RAX); fetch_register_operand(op); op->orig_val = op->val; break; case OpAccLo: op->type = OP_REG; op->bytes = (ctxt->d & ByteOp) ? 2 : ctxt->op_bytes; op->addr.reg = reg_rmw(ctxt, VCPU_REGS_RAX); fetch_register_operand(op); op->orig_val = op->val; break; case OpAccHi: if (ctxt->d & ByteOp) { op->type = OP_NONE; break; } op->type = OP_REG; op->bytes = ctxt->op_bytes; op->addr.reg = reg_rmw(ctxt, VCPU_REGS_RDX); fetch_register_operand(op); op->orig_val = op->val; break; case OpDI: op->type = OP_MEM; op->bytes = (ctxt->d & ByteOp) ? 1 : ctxt->op_bytes; op->addr.mem.ea = register_address(ctxt, reg_read(ctxt, VCPU_REGS_RDI)); op->addr.mem.seg = VCPU_SREG_ES; op->val = 0; op->count = 1; break; case OpDX: op->type = OP_REG; op->bytes = 2; op->addr.reg = reg_rmw(ctxt, VCPU_REGS_RDX); fetch_register_operand(op); break; case OpCL: op->bytes = 1; op->val = reg_read(ctxt, VCPU_REGS_RCX) & 0xff; break; case OpImmByte: rc = decode_imm(ctxt, op, 1, true); break; case OpOne: op->bytes = 1; op->val = 1; break; case OpImm: rc = decode_imm(ctxt, op, imm_size(ctxt), true); break; case OpImm64: rc = decode_imm(ctxt, op, ctxt->op_bytes, true); break; case OpMem8: ctxt->memop.bytes = 1; if (ctxt->memop.type == OP_REG) { ctxt->memop.addr.reg = decode_register(ctxt, ctxt->modrm_rm, true); fetch_register_operand(&ctxt->memop); } goto mem_common; case OpMem16: ctxt->memop.bytes = 2; goto mem_common; case OpMem32: ctxt->memop.bytes = 4; goto mem_common; case OpImmU16: rc = decode_imm(ctxt, op, 2, false); break; case OpImmU: rc = decode_imm(ctxt, op, imm_size(ctxt), false); break; case OpSI: op->type = OP_MEM; op->bytes = (ctxt->d & ByteOp) ? 1 : ctxt->op_bytes; op->addr.mem.ea = register_address(ctxt, reg_read(ctxt, VCPU_REGS_RSI)); op->addr.mem.seg = ctxt->seg_override; op->val = 0; op->count = 1; break; case OpXLat: op->type = OP_MEM; op->bytes = (ctxt->d & ByteOp) ? 1 : ctxt->op_bytes; op->addr.mem.ea = register_address(ctxt, reg_read(ctxt, VCPU_REGS_RBX) + (reg_read(ctxt, VCPU_REGS_RAX) & 0xff)); op->addr.mem.seg = ctxt->seg_override; op->val = 0; break; case OpImmFAddr: op->type = OP_IMM; op->addr.mem.ea = ctxt->_eip; op->bytes = ctxt->op_bytes + 2; insn_fetch_arr(op->valptr, op->bytes, ctxt); break; case OpMemFAddr: ctxt->memop.bytes = ctxt->op_bytes + 2; goto mem_common; case OpES: op->val = VCPU_SREG_ES; break; case OpCS: op->val = VCPU_SREG_CS; break; case OpSS: op->val = VCPU_SREG_SS; break; case OpDS: op->val = VCPU_SREG_DS; break; case OpFS: op->val = VCPU_SREG_FS; break; case OpGS: op->val = VCPU_SREG_GS; break; case OpImplicit: /* Special instructions do their own operand decoding. / default: op->type = OP_NONE; / Disable writeback. / break; } done: return rc; } int x86_decode_insn(struct x86_emulate_ctxt ctxt, void insn, int insn_len) { int rc = X86EMUL_CONTINUE; int mode = ctxt->mode; int def_op_bytes, def_ad_bytes, goffset, simd_prefix; bool op_prefix = false; bool has_seg_override = false; struct opcode opcode; ctxt->memop.type = OP_NONE; ctxt->memopp = NULL; ctxt->_eip = ctxt->eip; ctxt->fetch.ptr = ctxt->fetch.data; ctxt->fetch.end = ctxt->fetch.data + insn_len; ctxt->opcode_len = 1; if (insn_len > 0) memcpy(ctxt->fetch.data, insn, insn_len); else { rc = __do_insn_fetch_bytes(ctxt, 1); if (rc != X86EMUL_CONTINUE) return rc; } switch (mode) { case X86EMUL_MODE_REAL: case X86EMUL_MODE_VM86: case X86EMUL_MODE_PROT16: def_op_bytes = def_ad_bytes = 2; break; case X86EMUL_MODE_PROT32: def_op_bytes = def_ad_bytes = 4; break; #ifdef CONFIG_X86_64 case X86EMUL_MODE_PROT64: def_op_bytes = 4; def_ad_bytes = 8; break; #endif default: return EMULATION_FAILED; } ctxt->op_bytes = def_op_bytes; ctxt->ad_bytes = def_ad_bytes; / Legacy prefixes. / for (;;) { switch (ctxt->b = insn_fetch(u8, ctxt)) { case 0x66: / operand-size override / op_prefix = true; / switch between 2/4 bytes / ctxt->op_bytes = def_op_bytes ^ 6; break; case 0x67: / address-size override / if (mode == X86EMUL_MODE_PROT64) / switch between 4/8 bytes / ctxt->ad_bytes = def_ad_bytes ^ 12; else / switch between 2/4 bytes / ctxt->ad_bytes = def_ad_bytes ^ 6; break; case 0x26: / ES override / case 0x2e: / CS override / case 0x36: / SS override / case 0x3e: / DS override / has_seg_override = true; ctxt->seg_override = (ctxt->b >> 3) & 3; break; case 0x64: / FS override / case 0x65: / GS override / has_seg_override = true; ctxt->seg_override = ctxt->b & 7; break; case 0x40 ... 0x4f: / REX / if (mode != X86EMUL_MODE_PROT64) goto done_prefixes; ctxt->rex_prefix = ctxt->b; continue; case 0xf0: / LOCK / ctxt->lock_prefix = 1; break; case 0xf2: / REPNE/REPNZ / case 0xf3: / REP/REPE/REPZ / ctxt->rep_prefix = ctxt->b; break; default: goto done_prefixes; } / Any legacy prefix after a REX prefix nullifies its effect. / ctxt->rex_prefix = 0; } done_prefixes: / REX prefix. / if (ctxt->rex_prefix & 8) ctxt->op_bytes = 8; / REX.W / / Opcode byte(s). / opcode = opcode_table[ctxt->b]; / Two-byte opcode? / if (ctxt->b == 0x0f) { ctxt->opcode_len = 2; ctxt->b = insn_fetch(u8, ctxt); opcode = twobyte_table[ctxt->b]; / 0F_38 opcode map / if (ctxt->b == 0x38) { ctxt->opcode_len = 3; ctxt->b = insn_fetch(u8, ctxt); opcode = opcode_map_0f_38[ctxt->b]; } } ctxt->d = opcode.flags; if (ctxt->d & ModRM) ctxt->modrm = insn_fetch(u8, ctxt); / vex-prefix instructions are not implemented / if (ctxt->opcode_len == 1 && (ctxt->b == 0xc5 \|\| ctxt->b == 0xc4) && (mode == X86EMUL_MODE_PROT64 \|\| (mode >= X86EMUL_MODE_PROT16 && (ctxt->modrm & 0x80)))) { ctxt->d = NotImpl; } while (ctxt->d & GroupMask) { switch (ctxt->d & GroupMask) { case Group: goffset = (ctxt->modrm >> 3) & 7; opcode = opcode.u.group[goffset]; break; case GroupDual: goffset = (ctxt->modrm >> 3) & 7; if ((ctxt->modrm >> 6) == 3) opcode = opcode.u.gdual->mod3[goffset]; else opcode = opcode.u.gdual->mod012[goffset]; break; case RMExt: goffset = ctxt->modrm & 7; opcode = opcode.u.group[goffset]; break; case Prefix: if (ctxt->rep_prefix && op_prefix) return EMULATION_FAILED; simd_prefix = op_prefix ? 0x66 : ctxt->rep_prefix; switch (simd_prefix) { case 0x00: opcode = opcode.u.gprefix->pfx_no; break; case 0x66: opcode = opcode.u.gprefix->pfx_66; break; case 0xf2: opcode = opcode.u.gprefix->pfx_f2; break; case 0xf3: opcode = opcode.u.gprefix->pfx_f3; break; } break; case Escape: if (ctxt->modrm > 0xbf) opcode = opcode.u.esc->high[ctxt->modrm - 0xc0]; else opcode = opcode.u.esc->op[(ctxt->modrm >> 3) & 7]; break; default: return EMULATION_FAILED; } ctxt->d &= ~(u64)GroupMask; ctxt->d \|= opcode.flags; } / Unrecognised? / if (ctxt->d == 0) return EMULATION_FAILED; ctxt->execute = opcode.u.execute; if (unlikely(ctxt->ud) && likely(!(ctxt->d & EmulateOnUD))) return EMULATION_FAILED; if (unlikely(ctxt->d & (NotImpl\|Stack\|Op3264\|Sse\|Mmx\|Intercept\|CheckPerm))) { / * These are copied unconditionally here, and checked unconditionally * in x86_emulate_insn. / ctxt->check_perm = opcode.check_perm; ctxt->intercept = opcode.intercept; if (ctxt->d & NotImpl) return EMULATION_FAILED; if (mode == X86EMUL_MODE_PROT64 && (ctxt->d & Stack)) ctxt->op_bytes = 8; if (ctxt->d & Op3264) { if (mode == X86EMUL_MODE_PROT64) ctxt->op_bytes = 8; else ctxt->op_bytes = 4; } if (ctxt->d & Sse) ctxt->op_bytes = 16; else if (ctxt->d & Mmx) ctxt->op_bytes = 8; } / ModRM and SIB bytes. / if (ctxt->d & ModRM) { rc = decode_modrm(ctxt, &ctxt->memop); if (!has_seg_override) { has_seg_override = true; ctxt->seg_override = ctxt->modrm_seg; } } else if (ctxt->d & MemAbs) rc = decode_abs(ctxt, &ctxt->memop); if (rc != X86EMUL_CONTINUE) goto done; if (!has_seg_override) ctxt->seg_override = VCPU_SREG_DS; ctxt->memop.addr.mem.seg = ctxt->seg_override; / * Decode and fetch the source operand: register, memory * or immediate. / rc = decode_operand(ctxt, &ctxt->src, (ctxt->d >> SrcShift) & OpMask); if (rc != X86EMUL_CONTINUE) goto done; / * Decode and fetch the second source operand: register, memory * or immediate. / rc = decode_operand(ctxt, &ctxt->src2, (ctxt->d >> Src2Shift) & OpMask); if (rc != X86EMUL_CONTINUE) goto done; / Decode and fetch the destination operand: register or memory. / rc = decode_operand(ctxt, &ctxt->dst, (ctxt->d >> DstShift) & OpMask); done: if (ctxt->rip_relative) ctxt->memopp->addr.mem.ea += ctxt->_eip; return (rc != X86EMUL_CONTINUE) ? EMULATION_FAILED : EMULATION_OK; } bool x86_page_table_writing_insn(struct x86_emulate_ctxt ctxt) { return ctxt->d & PageTable; } static bool string_insn_completed(struct x86_emulate_ctxt ctxt) { / The second termination condition only applies for REPE * and REPNE. Test if the repeat string operation prefix is * REPE/REPZ or REPNE/REPNZ and if it's the case it tests the * corresponding termination condition according to: * - if REPE/REPZ and ZF = 0 then done * - if REPNE/REPNZ and ZF = 1 then done / if (((ctxt->b == 0xa6) \|\| (ctxt->b == 0xa7) \|\| (ctxt->b == 0xae) \|\| (ctxt->b == 0xaf)) && (((ctxt->rep_prefix == REPE_PREFIX) && ((ctxt->eflags & EFLG_ZF) == 0)) \|\| ((ctxt->rep_prefix == REPNE_PREFIX) && ((ctxt->eflags & EFLG_ZF) == EFLG_ZF)))) return true; return false; } static int flush_pending_x87_faults(struct x86_emulate_ctxt ctxt) { bool fault = false; ctxt->ops->get_fpu(ctxt); asm volatile("1: fwait \n\t" "2: \n\t" ".pushsection .fixup,\"ax\" \n\t" "3: \n\t" "movb $1, %[fault] \n\t" "jmp 2b \n\t" ".popsection \n\t" _ASM_EXTABLE(1b, 3b) : [fault]"+qm"(fault)); ctxt->ops->put_fpu(ctxt); if (unlikely(fault)) return emulate_exception(ctxt, MF_VECTOR, 0, false); return X86EMUL_CONTINUE; } static void fetch_possible_mmx_operand(struct x86_emulate_ctxt ctxt, struct operand op) { if (op->type == OP_MM) read_mmx_reg(ctxt, &op->mm_val, op->addr.mm); } static int fastop(struct x86_emulate_ctxt ctxt, void (fop)(struct fastop )) { ulong flags = (ctxt->eflags & EFLAGS_MASK) \| X86_EFLAGS_IF; if (!(ctxt->d & ByteOp)) fop += __ffs(ctxt->dst.bytes) FASTOP_SIZE; asm("push %[flags]; popf; call %[fastop]; pushf; pop %[flags]\n" : "+a"(ctxt->dst.val), "+d"(ctxt->src.val), [flags]"+D"(flags), [fastop]"+S"(fop) : "c"(ctxt->src2.val)); ctxt->eflags = (ctxt->eflags & ~EFLAGS_MASK) \| (flags & EFLAGS_MASK); if (!fop) / exception is returned in fop variable / return emulate_de(ctxt); return X86EMUL_CONTINUE; } void init_decode_cache(struct x86_emulate_ctxt ctxt) { memset(&ctxt->rip_relative, 0, (void )&ctxt->modrm - (void )&ctxt->rip_relative); ctxt->io_read.pos = 0; ctxt->io_read.end = 0; ctxt->mem_read.end = 0; } int x86_emulate_insn(struct x86_emulate_ctxt ctxt) { const struct x86_emulate_ops ops = ctxt->ops; int rc = X86EMUL_CONTINUE; int saved_dst_type = ctxt->dst.type; ctxt->mem_read.pos = 0; /* LOCK prefix is allowed only with some instructions / if (ctxt->lock_prefix && (!(ctxt->d & Lock) \|\| ctxt->dst.type != OP_MEM)) { rc = emulate_ud(ctxt); goto done; } if ((ctxt->d & SrcMask) == SrcMemFAddr && ctxt->src.type != OP_MEM) { rc = emulate_ud(ctxt); goto done; } if (unlikely(ctxt->d & (No64\|Undefined\|Sse\|Mmx\|Intercept\|CheckPerm\|Priv\|Prot\|String))) { if ((ctxt->mode == X86EMUL_MODE_PROT64 && (ctxt->d & No64)) \|\| (ctxt->d & Undefined)) { rc = emulate_ud(ctxt); goto done; } if (((ctxt->d & (Sse\|Mmx)) && ((ops->get_cr(ctxt, 0) & X86_CR0_EM))) \|\| ((ctxt->d & Sse) && !(ops->get_cr(ctxt, 4) & X86_CR4_OSFXSR))) { rc = emulate_ud(ctxt); goto done; } if ((ctxt->d & (Sse\|Mmx)) && (ops->get_cr(ctxt, 0) & X86_CR0_TS)) { rc = emulate_nm(ctxt); goto done; } if (ctxt->d & Mmx) { rc = flush_pending_x87_faults(ctxt); if (rc != X86EMUL_CONTINUE) goto done; / * Now that we know the fpu is exception safe, we can fetch * operands from it. / fetch_possible_mmx_operand(ctxt, &ctxt->src); fetch_possible_mmx_operand(ctxt, &ctxt->src2); if (!(ctxt->d & Mov)) fetch_possible_mmx_operand(ctxt, &ctxt->dst); } if (unlikely(ctxt->guest_mode) && (ctxt->d & Intercept)) { rc = emulator_check_intercept(ctxt, ctxt->intercept, X86_ICPT_PRE_EXCEPT); if (rc != X86EMUL_CONTINUE) goto done; } / Privileged instruction can be executed only in CPL=0 / if ((ctxt->d & Priv) && ops->cpl(ctxt)) { if (ctxt->d & PrivUD) rc = emulate_ud(ctxt); else rc = emulate_gp(ctxt, 0); goto done; } / Instruction can only be executed in protected mode / if ((ctxt->d & Prot) && ctxt->mode < X86EMUL_MODE_PROT16) { rc = emulate_ud(ctxt); goto done; } / Do instruction specific permission checks / if (ctxt->d & CheckPerm) { rc = ctxt->check_perm(ctxt); if (rc != X86EMUL_CONTINUE) goto done; } if (unlikely(ctxt->guest_mode) && (ctxt->d & Intercept)) { rc = emulator_check_intercept(ctxt, ctxt->intercept, X86_ICPT_POST_EXCEPT); if (rc != X86EMUL_CONTINUE) goto done; } if (ctxt->rep_prefix && (ctxt->d & String)) { / All REP prefixes have the same first termination condition / if (address_mask(ctxt, reg_read(ctxt, VCPU_REGS_RCX)) == 0) { ctxt->eip = ctxt->_eip; ctxt->eflags &= ~EFLG_RF; goto done; } } } if ((ctxt->src.type == OP_MEM) && !(ctxt->d & NoAccess)) { rc = segmented_read(ctxt, ctxt->src.addr.mem, ctxt->src.valptr, ctxt->src.bytes); if (rc != X86EMUL_CONTINUE) goto done; ctxt->src.orig_val64 = ctxt->src.val64; } if (ctxt->src2.type == OP_MEM) { rc = segmented_read(ctxt, ctxt->src2.addr.mem, &ctxt->src2.val, ctxt->src2.bytes); if (rc != X86EMUL_CONTINUE) goto done; } if ((ctxt->d & DstMask) == ImplicitOps) goto special_insn; if ((ctxt->dst.type == OP_MEM) && !(ctxt->d & Mov)) { / optimisation - avoid slow emulated read if Mov / rc = segmented_read(ctxt, ctxt->dst.addr.mem, &ctxt->dst.val, ctxt->dst.bytes); if (rc != X86EMUL_CONTINUE) goto done; } ctxt->dst.orig_val = ctxt->dst.val; special_insn: if (unlikely(ctxt->guest_mode) && (ctxt->d & Intercept)) { rc = emulator_check_intercept(ctxt, ctxt->intercept, X86_ICPT_POST_MEMACCESS); if (rc != X86EMUL_CONTINUE) goto done; } if (ctxt->rep_prefix && (ctxt->d & String)) ctxt->eflags \|= EFLG_RF; else ctxt->eflags &= ~EFLG_RF; if (ctxt->execute) { if (ctxt->d & Fastop) { void (fop)(struct fastop ) = (void )ctxt->execute; rc = fastop(ctxt, fop); if (rc != X86EMUL_CONTINUE) goto done; goto writeback; } rc = ctxt->execute(ctxt); if (rc != X86EMUL_CONTINUE) goto done; goto writeback; } if (ctxt->opcode_len == 2) goto twobyte_insn; else if (ctxt->opcode_len == 3) goto threebyte_insn; switch (ctxt->b) { case 0x63: /* movsxd / if (ctxt->mode != X86EMUL_MODE_PROT64) goto cannot_emulate; ctxt->dst.val = (s32) ctxt->src.val; break; case 0x70 ... 0x7f: / jcc (short) / if (test_cc(ctxt->b, ctxt->eflags)) jmp_rel(ctxt, ctxt->src.val); break; case 0x8d: / lea r16/r32, m / ctxt->dst.val = ctxt->src.addr.mem.ea; break; case 0x90 ... 0x97: / nop / xchg reg, rax / if (ctxt->dst.addr.reg == reg_rmw(ctxt, VCPU_REGS_RAX)) ctxt->dst.type = OP_NONE; else rc = em_xchg(ctxt); break; case 0x98: / cbw/cwde/cdqe / switch (ctxt->op_bytes) { case 2: ctxt->dst.val = (s8)ctxt->dst.val; break; case 4: ctxt->dst.val = (s16)ctxt->dst.val; break; case 8: ctxt->dst.val = (s32)ctxt->dst.val; break; } break; case 0xcc: / int3 / rc = emulate_int(ctxt, 3); break; case 0xcd: / int n / rc = emulate_int(ctxt, ctxt->src.val); break; case 0xce: / into / if (ctxt->eflags & EFLG_OF) rc = emulate_int(ctxt, 4); break; case 0xe9: / jmp rel / case 0xeb: / jmp rel short / jmp_rel(ctxt, ctxt->src.val); ctxt->dst.type = OP_NONE; / Disable writeback. / break; case 0xf4: / hlt / ctxt->ops->halt(ctxt); break; case 0xf5: / cmc / / complement carry flag from eflags reg / ctxt->eflags ^= EFLG_CF; break; case 0xf8: / clc / ctxt->eflags &= ~EFLG_CF; break; case 0xf9: / stc / ctxt->eflags \|= EFLG_CF; break; case 0xfc: / cld / ctxt->eflags &= ~EFLG_DF; break; case 0xfd: / std / ctxt->eflags \|= EFLG_DF; break; default: goto cannot_emulate; } if (rc != X86EMUL_CONTINUE) goto done; writeback: if (ctxt->d & SrcWrite) { BUG_ON(ctxt->src.type == OP_MEM \|\| ctxt->src.type == OP_MEM_STR); rc = writeback(ctxt, &ctxt->src); if (rc != X86EMUL_CONTINUE) goto done; } if (!(ctxt->d & NoWrite)) { rc = writeback(ctxt, &ctxt->dst); if (rc != X86EMUL_CONTINUE) goto done; } / * restore dst type in case the decoding will be reused * (happens for string instruction ) / ctxt->dst.type = saved_dst_type; if ((ctxt->d & SrcMask) == SrcSI) string_addr_inc(ctxt, VCPU_REGS_RSI, &ctxt->src); if ((ctxt->d & DstMask) == DstDI) string_addr_inc(ctxt, VCPU_REGS_RDI, &ctxt->dst); if (ctxt->rep_prefix && (ctxt->d & String)) { unsigned int count; struct read_cache r = &ctxt->io_read; if ((ctxt->d & SrcMask) == SrcSI) count = ctxt->src.count; else count = ctxt->dst.count; register_address_increment(ctxt, reg_rmw(ctxt, VCPU_REGS_RCX), -count); if (!string_insn_completed(ctxt)) { /* * Re-enter guest when pio read ahead buffer is empty * or, if it is not used, after each 1024 iteration. / if ((r->end != 0 \|\| reg_read(ctxt, VCPU_REGS_RCX) & 0x3ff) && (r->end == 0 \|\| r->end != r->pos)) { / * Reset read cache. Usually happens before * decode, but since instruction is restarted * we have to do it here. / ctxt->mem_read.end = 0; writeback_registers(ctxt); return EMULATION_RESTART; } goto done; / skip rip writeback / } ctxt->eflags &= ~EFLG_RF; } ctxt->eip = ctxt->_eip; done: if (rc == X86EMUL_PROPAGATE_FAULT) { WARN_ON(ctxt->exception.vector > 0x1f); ctxt->have_exception = true; } if (rc == X86EMUL_INTERCEPTED) return EMULATION_INTERCEPTED; if (rc == X86EMUL_CONTINUE) writeback_registers(ctxt); return (rc == X86EMUL_UNHANDLEABLE) ? EMULATION_FAILED : EMULATION_OK; twobyte_insn: switch (ctxt->b) { case 0x09: / wbinvd / (ctxt->ops->wbinvd)(ctxt); break; case 0x08: / invd / case 0x0d: / GrpP (prefetch) / case 0x18: / Grp16 (prefetch/nop) / case 0x1f: / nop / break; case 0x20: / mov cr, reg / ctxt->dst.val = ops->get_cr(ctxt, ctxt->modrm_reg); break; case 0x21: / mov from dr to reg / ops->get_dr(ctxt, ctxt->modrm_reg, &ctxt->dst.val); break; case 0x40 ... 0x4f: / cmov / if (test_cc(ctxt->b, ctxt->eflags)) ctxt->dst.val = ctxt->src.val; else if (ctxt->mode != X86EMUL_MODE_PROT64 \|\| ctxt->op_bytes != 4) ctxt->dst.type = OP_NONE; / no writeback / break; case 0x80 ... 0x8f: / jnz rel, etc/ if (test_cc(ctxt->b, ctxt->eflags)) jmp_rel(ctxt, ctxt->src.val); break; case 0x90 ... 0x9f: / setcc r/m8 / ctxt->dst.val = test_cc(ctxt->b, ctxt->eflags); break; case 0xae: / clflush / break; case 0xb6 ... 0xb7: / movzx / ctxt->dst.bytes = ctxt->op_bytes; ctxt->dst.val = (ctxt->src.bytes == 1) ? (u8) ctxt->src.val : (u16) ctxt->src.val; break; case 0xbe ... 0xbf: / movsx / ctxt->dst.bytes = ctxt->op_bytes; ctxt->dst.val = (ctxt->src.bytes == 1) ? (s8) ctxt->src.val : (s16) ctxt->src.val; break; case 0xc3: / movnti / ctxt->dst.bytes = ctxt->op_bytes; ctxt->dst.val = (ctxt->op_bytes == 8) ? (u64) ctxt->src.val : (u32) ctxt->src.val; break; default: goto cannot_emulate; } threebyte_insn: if (rc != X86EMUL_CONTINUE) goto done; goto writeback; cannot_emulate: return EMULATION_FAILED; } void emulator_invalidate_register_cache(struct x86_emulate_ctxt ctxt) { invalidate_registers(ctxt); } void emulator_writeback_register_cache(struct x86_emulate_ctxt *ctxt) { writeback_registers(ctxt); }	./CrossVul/dataset_final_sorted/CWE-264/c/bad_2164_0
crossvul-cpp_data_bad_3637_0	404: Not Found	./CrossVul/dataset_final_sorted/CWE-264/c/bad_3637_0
crossvul-cpp_data_bad_3470_1	/* * npw-viewer.c - Target plugin loader and viewer * * nspluginwrapper (C) 2005-2009 Gwenole Beauchesne * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, write to the Free Software Foundation, Inc., * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. / #define _GNU_SOURCE 1 / RTLD_NEXT / #include "sysdeps.h" #include <stdio.h> #include <stdlib.h> #include <string.h> #include <strings.h> #include <dlfcn.h> #include <unistd.h> #include <errno.h> #include <pthread.h> #include <fcntl.h> #include <X11/X.h> #include <X11/Xlib.h> #include <X11/Xutil.h> #include <X11/Intrinsic.h> #include <X11/Shell.h> #include <X11/StringDefs.h> #include <X11/extensions/XShm.h> #include <gtk/gtk.h> #include <gdk/gdkx.h> #include "utils.h" #include "xembed.h" #include "npw-common.h" #include "npw-malloc.h" #define DEBUG 1 #include "debug.h" // [UNIMPLEMENTED] Define to use XPCOM emulation #define USE_XPCOM 0 // Define to use XEMBED hack (don't let browser kill our window) #define USE_XEMBED_HACK 1 // Define to allow windowless plugins #define ALLOW_WINDOWLESS_PLUGINS 1 // Define to use NPIdentifier cache #define USE_NPIDENTIFIER_CACHE 1 #define NPIDENTIFIER_CACHE_SIZE 256 // RPC global connections rpc_connection_t g_rpc_connection attribute_hidden = NULL; // Viewer main thread - make sure we call into the browser from the main thread static pthread_t g_main_thread = 0; // Instance state information about the plugin typedef struct _PluginInstance { NPW_DECL_PLUGIN_INSTANCE; bool use_xembed; bool is_windowless; NPWindow window; uint32_t width, height; void toolkit_data; GdkWindow browser_toplevel; } PluginInstance; #define PLUGIN_INSTANCE(instance) \ ((PluginInstance )NPW_PLUGIN_INSTANCE(instance)) #define PLUGIN_INSTANCE_NPP(plugin) \ NPW_PLUGIN_INSTANCE_NPP((NPW_PluginInstance )(plugin)) // Browser side data for an NPStream instance typedef struct _StreamInstance { NPW_DECL_STREAM_INSTANCE; } StreamInstance; // Xt wrapper data typedef struct _XtData { Window browser_window; Widget top_widget; Widget form; } XtData; // Gtk wrapper data typedef struct _GtkData { GtkWidget container; GtkWidget socket; } GtkData; // Prototypes static void destroy_window(PluginInstance plugin); static int xt_source_create(void); static void xt_source_destroy(void); / ====================================================================== / / === Helpers === / / ====================================================================== / // PluginInstance vfuncs static void plugin_instance_allocate(void); static void plugin_instance_deallocate(PluginInstance plugin); static void plugin_instance_finalize(PluginInstance plugin); static void plugin_instance_invalidate(PluginInstance plugin); static NPW_PluginInstanceClass PluginInstanceClass = { (NPW_PluginInstanceAllocateFunctionPtr)plugin_instance_allocate, (NPW_PluginInstanceDeallocateFunctionPtr)plugin_instance_deallocate, (NPW_PluginInstanceFinalizeFunctionPtr)plugin_instance_finalize, (NPW_PluginInstanceInvalidateFunctionPtr)plugin_instance_invalidate }; static void plugin_instance_allocate(void) { return NPW_MemNew0(PluginInstance, 1); } static void plugin_instance_deallocate(PluginInstance plugin) { NPW_MemFree(plugin); } static void plugin_instance_finalize(PluginInstance plugin) { if (plugin->browser_toplevel) { g_object_unref(plugin->browser_toplevel); plugin->browser_toplevel = NULL; } if (plugin->instance) { free(plugin->instance); plugin->instance = NULL; } } static void plugin_instance_invalidate(PluginInstance plugin) { destroy_window(plugin); / NPP instance is no longer valid beyond this point. Drop the link to the PluginInstance now so that future RPC with this PluginInstance will actually emit a NULL instance, which the other side will deal as a no-op for all functions but NPN_GetValue(). However, don't free() the NPP instance yet as it could be used later, e.g. in some NPObject::Invalidate()... Note: this also means we forbid that function to call into the browser in an NPP instance. / if (plugin->instance_id) { id_remove(plugin->instance_id); plugin->instance_id = 0; } } // Thread support routines static void thread_check_init(void) { g_main_thread = pthread_self(); } #ifdef ENABLE_THREAD_CHECK static bool is_thread_check_enabled_1(void) { const char thread_check_str; if ((thread_check_str = getenv("NPW_THREAD_CHECK")) != NULL) return ((strcmp(thread_check_str, "yes") == 0) \|\| (strcmp(thread_check_str, "1") == 0)); /* enable main-thread checks by default for all builds from snapshots / return NPW_SNAPSHOT > 0; } static inline bool is_thread_check_enabled(void) { static int thread_check = -1; if (thread_check < 0) thread_check = is_thread_check_enabled_1(); return thread_check; } #endif bool thread_check(void) { #ifdef ENABLE_THREAD_CHECK if (is_thread_check_enabled()) return (g_main_thread == pthread_self()); #endif return true; } // Delayed calls machinery // XXX: use a pipe, this should be faster (avoids GSource creation and // explicit memory allocation) enum { RPC_DELAYED_NPN_RELEASE_OBJECT = 1 }; typedef struct _DelayedCall { gint type; gpointer data; } DelayedCall; static GList g_delayed_calls = NULL; static guint g_delayed_calls_id = 0; // We put delayed NPP_Destroy calls on a separate list because, unlike // NPN_ReleaseObject, these must be called on a clean stack and have no // other cause to get cleared. Otherwise, it is possible for the // delayed_calls_process in g_NPP_Destroy_Now to call it early. static GList g_delayed_destroys = NULL; static guint g_delayed_destroys_id = 0; static void g_NPN_ReleaseObject_Now(NPObject npobj); static NPError g_NPP_Destroy_Now(PluginInstance plugin, NPSavedData sdata); static gboolean delayed_calls_process_cb(gpointer user_data); static gboolean delayed_destroys_process_cb(gpointer user_data); static void delayed_calls_add(int type, gpointer data) { DelayedCall dcall = NPW_MemNew(DelayedCall, 1); if (dcall == NULL) return; dcall->type = type; dcall->data = data; g_delayed_calls = g_list_append(g_delayed_calls, dcall); if (g_delayed_calls_id == 0) g_delayed_calls_id = g_idle_add_full(G_PRIORITY_LOW, delayed_calls_process_cb, NULL, NULL); } static void delayed_destroys_add(PluginInstance plugin) { g_delayed_destroys = g_list_append(g_delayed_destroys, plugin); if (g_delayed_destroys_id == 0) g_delayed_destroys_id = g_idle_add_full(G_PRIORITY_LOW, delayed_destroys_process_cb, NULL, NULL); } // Returns whether there are pending calls left in the queue static gboolean delayed_calls_process(PluginInstance plugin, gboolean is_in_NPP_Destroy) { while (g_delayed_calls != NULL) { if (!is_in_NPP_Destroy) { /* Continue later if there is incoming RPC / if (rpc_wait_dispatch(g_rpc_connection, 0) > 0) return TRUE; } DelayedCall dcall = (DelayedCall )g_delayed_calls->data; / XXX: Remove the link first; this function /must/ be * re-entrant. We may be called again while processing the * delayed call. / g_delayed_calls = g_list_delete_link(g_delayed_calls, g_delayed_calls); switch (dcall->type) { case RPC_DELAYED_NPN_RELEASE_OBJECT: { NPObject npobj = (NPObject )dcall->data; g_NPN_ReleaseObject_Now(npobj); break; } } NPW_MemFree(dcall); } if (g_delayed_calls) return TRUE; if (g_delayed_calls_id) { g_source_remove(g_delayed_calls_id); g_delayed_calls_id = 0; } return FALSE; } static gboolean delayed_calls_process_cb(gpointer user_data) { return delayed_calls_process(NULL, FALSE); } static gboolean delayed_destroys_process_cb(gpointer user_data) { while (g_delayed_destroys != NULL) { PluginInstance plugin = (PluginInstance )g_delayed_destroys->data; g_delayed_destroys = g_list_delete_link(g_delayed_destroys, g_delayed_destroys); g_NPP_Destroy_Now(plugin, NULL); } if (g_delayed_destroys) return TRUE; if (g_delayed_destroys_id) { g_source_remove(g_delayed_destroys_id); g_delayed_destroys_id = 0; } return FALSE; } // NPIdentifier cache static inline bool use_npidentifier_cache(void) { return USE_NPIDENTIFIER_CACHE && npruntime_use_cache(); } #if USE_NPIDENTIFIER_CACHE / XXX: NPIdentifierInfo could become the NPIdentifier, thus avoiding the global hash table, if there is a garbage collector. Otherwise, we will be leaking memory since there is no function that kills an NPIdentifier. / typedef struct _NPIdentifierInfo { guint string_len; / >0 implies 1+strlen(string), =0 implies an integer / union { gchar string; int32_t value; } u; } NPIdentifierInfo; static GHashTable g_npidentifier_cache = NULL; static inline NPIdentifierInfo npidentifier_info_new(void) { return NPW_MemNew(NPIdentifierInfo, 1); } static inline void npidentifier_info_destroy(NPIdentifierInfo npi) { if (G_UNLIKELY(npi == NULL)) return; if (npi->string_len > 0) { NPW_MemFree(npi->u.string); npi->u.string = NULL; } NPW_MemFree(npi); } static inline void npidentifier_cache_create(void) { g_npidentifier_cache = g_hash_table_new_full(NULL, NULL, NULL, (GDestroyNotify)npidentifier_info_destroy); } static inline void npidentifier_cache_destroy(void) { if (g_npidentifier_cache) { g_hash_table_destroy(g_npidentifier_cache); g_npidentifier_cache = NULL; } } static void npidentifier_cache_invalidate(void) { #if defined(HAVE_G_HASH_TABLE_REMOVE_ALL) && !defined(BUILD_GENERIC) if (g_npidentifier_cache) g_hash_table_remove_all(g_npidentifier_cache); #else npidentifier_cache_destroy(); npidentifier_cache_create(); #endif } static void npidentifier_cache_reserve(int n_entries) { if (G_UNLIKELY(g_npidentifier_cache == NULL)) npidentifier_cache_create(); if (g_hash_table_size(g_npidentifier_cache) + n_entries > NPIDENTIFIER_CACHE_SIZE) npidentifier_cache_invalidate(); } static inline NPIdentifierInfo npidentifier_cache_lookup(NPIdentifier ident) { if (G_UNLIKELY(g_npidentifier_cache == NULL)) return NULL; return g_hash_table_lookup(g_npidentifier_cache, ident); } static void npidentifier_cache_add_int(NPIdentifier ident, int32_t value) { if (G_UNLIKELY(g_npidentifier_cache == NULL)) return; NPIdentifierInfo npi = npidentifier_info_new(); if (G_UNLIKELY(npi == NULL)) return; npi->string_len = 0; npi->u.value = value; g_hash_table_insert(g_npidentifier_cache, ident, npi); } typedef struct _NPIdentifierFindArgs { NPIdentifierInfo info; / in / NPIdentifier ident; / out / } NPIdentifierFindArgs; static gboolean npidentifier_cache_find_info(gpointer key, gpointer value, gpointer user_data) { NPIdentifier ident = (NPIdentifier)key; NPIdentifierInfo npi = (NPIdentifierInfo )value; NPIdentifierFindArgs args = (NPIdentifierFindArgs )user_data; #if !defined(HAVE_G_HASH_TABLE_FIND) \|\| defined(BUILD_GENERIC) if (args->ident) return FALSE; #endif if (npi->string_len != args->info.string_len) return FALSE; if (args->info.string_len > 0) { /* a string / if (memcmp(args->info.u.string, npi->u.string, args->info.string_len) == 0) { args->ident = ident; return TRUE; } } else { / an integer / if (args->info.u.value == npi->u.value) { args->ident = ident; return TRUE; } } return FALSE; } static inline bool npidentifier_cache_find(NPIdentifierFindArgs args, NPIdentifier pident) { args->ident = NULL; #if defined(HAVE_G_HASH_TABLE_FIND) && !defined(BUILD_GENERIC) if (!g_hash_table_find(g_npidentifier_cache, npidentifier_cache_find_info, args)) return false; #else g_hash_table_foreach(g_npidentifier_cache, (GHFunc)npidentifier_cache_find_info, args); if (args->ident == NULL) return false; #endif if (pident) pident = args->ident; return true; } static inline bool npidentifier_cache_has_int(int32_t value, NPIdentifier pident) { if (G_UNLIKELY(g_npidentifier_cache == NULL)) return false; NPIdentifierFindArgs args; args.info.string_len = 0; args.info.u.value = value; return npidentifier_cache_find(&args, pident); } static inline int32_t npidentifier_cache_get_int(NPIdentifier ident) { NPIdentifierInfo npi = npidentifier_cache_lookup(ident); if (G_UNLIKELY(npi == NULL \|\| npi->string_len > 0)) return 0; return npi->u.value; } static void npidentifier_cache_add_string(NPIdentifier ident, const gchar str) { if (G_UNLIKELY(g_npidentifier_cache == NULL)) return; NPIdentifierInfo npi = npidentifier_info_new(); if (G_UNLIKELY(npi == NULL)) return; npi->string_len = strlen(str) + 1; if ((npi->u.string = NPW_MemAlloc(npi->string_len)) == NULL) { npidentifier_info_destroy(npi); return; } memcpy(npi->u.string, str, npi->string_len); g_hash_table_insert(g_npidentifier_cache, ident, npi); } static inline bool npidentifier_cache_has_string(const gchar str, NPIdentifier pident) { if (G_UNLIKELY(g_npidentifier_cache == NULL)) return false; NPIdentifierFindArgs args; args.info.string_len = strlen(str) + 1; args.info.u.string = (gchar )str; return npidentifier_cache_find(&args, pident); } static inline NPUTF8 npidentifier_cache_get_string_copy(NPIdentifier ident) { NPIdentifierInfo npi = npidentifier_cache_lookup(ident); if (G_UNLIKELY(npi == NULL \|\| npi->string_len == 0)) return NULL; return NPW_MemAllocCopy(npi->string_len, npi->u.string); } #endif / ====================================================================== / / === X Toolkit glue === / / ====================================================================== / static Display x_display; static XtAppContext x_app_context; typedef struct _XtTMRec { XtTranslations translations; /* private to Translation Manager / XtBoundActions proc_table; / procedure bindings for actions / struct _XtStateRec current_state; /* Translation Manager state ptr / unsigned long lastEventTime; } XtTMRec, XtTM; typedef struct _CorePart { Widget self; /* pointer to widget itself / WidgetClass widget_class; / pointer to Widget's ClassRec / Widget parent; / parent widget / XrmName xrm_name; / widget resource name quarkified / Boolean being_destroyed; / marked for destroy / XtCallbackList destroy_callbacks; / who to call when widget destroyed / XtPointer constraints; / constraint record / Position x, y; / window position / Dimension width, height; / window dimensions / Dimension border_width; / window border width / Boolean managed; / is widget geometry managed? / Boolean sensitive; / is widget sensitive to user events/ Boolean ancestor_sensitive; / are all ancestors sensitive? / XtEventTable event_table; / private to event dispatcher / XtTMRec tm; / translation management / XtTranslations accelerators; / accelerator translations / Pixel border_pixel; / window border pixel / Pixmap border_pixmap; / window border pixmap or NULL / WidgetList popup_list; / list of popups / Cardinal num_popups; / how many popups / String name; / widget resource name / Screen screen; /* window's screen / Colormap colormap; / colormap / Window window; / window ID / Cardinal depth; / number of planes in window / Pixel background_pixel; / window background pixel / Pixmap background_pixmap; / window background pixmap or NULL / Boolean visible; / is window mapped and not occluded?/ Boolean mapped_when_managed;/ map window if it's managed? / } CorePart; typedef struct _WidgetRec { CorePart core; } WidgetRec, CoreRec; typedef struct _TimerEventRec { struct timeval te_timer_value; struct _TimerEventRec te_next; XtTimerCallbackProc te_proc; XtAppContext app; XtPointer te_closure; } TimerEventRec; typedef struct _InputEvent { XtInputCallbackProc ie_proc; XtPointer ie_closure; struct _InputEvent ie_next; struct _InputEvent ie_oq; XtAppContext app; int ie_source; XtInputMask ie_condition; } InputEvent; typedef struct _SignalEventRec { XtSignalCallbackProc se_proc; XtPointer se_closure; struct _SignalEventRec se_next; XtAppContext app; Boolean se_notice; } SignalEventRec; struct _XtAppStruct { XtAppContext next; / link to next app in process context / void process; /* back pointer to our process context / void destroy_callbacks; Display *list; TimerEventRec timerQueue; void workQueue; InputEvent input_list; InputEvent outstandingQueue; SignalEventRec signalQueue; XrmDatabase errorDB; XtErrorMsgHandler errorMsgHandler, warningMsgHandler; XtErrorHandler errorHandler, warningHandler; struct _ActionListRec action_table; void converterTable; unsigned long selectionTimeout; char __maxed__nfds[3sizeof(fd_set)+4]; short __maybe__count; /* num of assigned entries in list / short __maybe__max; / allocate size of list / short __maybe__last; short __maybe__input_count; short __maybe__input_max; / elts input_list init'd with / / ... don't care about other members / }; extern void XtResizeWidget( Widget / widget /, _XtDimension / width /, _XtDimension / height /, _XtDimension / border_width / ); // Dummy X error handler static int trapped_error_code; static int (old_error_handler)(Display , XErrorEvent ); static int error_handler(Display display, XErrorEvent error) { trapped_error_code = error->error_code; return 0; } static void trap_errors(void) { trapped_error_code = 0; old_error_handler = XSetErrorHandler(error_handler); } static int untrap_errors(void) { XSetErrorHandler(old_error_handler); return trapped_error_code; } // Install the _XEMBED_INFO property static void xt_client_set_info(Widget w, unsigned long flags) { Atom atom_XEMBED_INFO = XInternAtom(x_display, "_XEMBED_INFO", False); unsigned long buffer[2]; buffer[1] = 0; /* Protocol version / buffer[1] = flags; XChangeProperty(XtDisplay(w), XtWindow(w), atom_XEMBED_INFO, atom_XEMBED_INFO, 32, PropModeReplace, (unsigned char )buffer, 2); } // Send an XEMBED message to the specified window static void send_xembed_message(Display display, Window window, long message, long detail, long data1, long data2) { XEvent xevent; memset(&xevent, 0, sizeof(xevent)); xevent.xclient.window = window; xevent.xclient.type = ClientMessage; xevent.xclient.message_type = XInternAtom(display, "_XEMBED", False); xevent.xclient.format = 32; xevent.xclient.data.l[0] = CurrentTime; // XXX: evil? xevent.xclient.data.l[1] = message; xevent.xclient.data.l[2] = detail; xevent.xclient.data.l[3] = data1; xevent.xclient.data.l[4] = data2; trap_errors(); XSendEvent(display, xevent.xclient.window, False, NoEventMask, &xevent); XSync(display, False); untrap_errors(); } / * NSPluginWrapper strategy to handle input focus. * * - XEMBED must be enabled with NPPVpluginNeedsXEmbed set to * PR_TRUE. This causes Firefox to pass a plain GtkSocket ID into * NPWindow::window. i.e. the GtkXtBin window ID is NOT used. * * - A click into the plugin window sends an XEMBED_REQUEST_FOCUS * event to the parent (socket) window. * * - An XFocusEvent is simulated when XEMBED_FOCUS_IN and * XEMBED_FOCUS_OUT messages arrive to the plugin window. * * - Key events are forwarded from the top widget (which window was * reparented to the socket window) to the actual canvas (form). * * Reference checkpoints, i.e. check the following test cases still * work if you want to change the policy. * * [1] Debian bug #435912 * <http://www.addictinggames.com/bloxors.html> * * Goto to stage 1, use arrow keys to move the block. Now, click * outside of the game window, use arrow keys to try to move the * block: it should NOT move. * * [2] User reported bug * <http://www.forom.com/> * * Choose a language and then a mirror. Do NOT move the cursor out of * the plugin window. Now, click into the "Login" input field and try * to type in something, you should have the input focus. * * [3] Additional test that came in during debugging * * Go to either [1] or [2], double-click the browser URL entry to * select it completely. Now, click into the Flash plugin area. The * URL selection MUST now be unselected AND using the Tab key selects * various fields in the Flash window (e.g. menu items for [1]). / // Simulate client focus static void xt_client_simulate_focus(Widget w, int type) { XEvent xevent; memset(&xevent, 0, sizeof(xevent)); xevent.xfocus.type = type; xevent.xfocus.window = XtWindow(w); xevent.xfocus.display = XtDisplay(w); xevent.xfocus.mode = NotifyNormal; xevent.xfocus.detail = NotifyAncestor; trap_errors(); XSendEvent(XtDisplay(w), xevent.xfocus.window, False, NoEventMask, &xevent); XSync(XtDisplay(w), False); untrap_errors(); } // Various hacks for decent events filtery static void xt_client_event_handler(Widget w, XtPointer client_data, XEvent event, Boolean cont) { XtData toolkit = (XtData )client_data; switch (event->type) { case ClientMessage: // Handle XEMBED messages, in particular focus changes if (event->xclient.message_type == XInternAtom(x_display, "_XEMBED", False)) { switch (event->xclient.data.l[1]) { case XEMBED_FOCUS_IN: xt_client_simulate_focus(toolkit->form, FocusIn); break; case XEMBED_FOCUS_OUT: xt_client_simulate_focus(toolkit->form, FocusOut); break; } } break; case KeyPress: case KeyRelease: // Propagate key events down to the actual window if (event->xkey.window == XtWindow(toolkit->top_widget)) { event->xkey.window = XtWindow(toolkit->form); trap_errors(); XSendEvent(XtDisplay(toolkit->form), event->xfocus.window, False, NoEventMask, event); XSync(XtDisplay(toolkit->form), False); untrap_errors(); cont = False; } break; case ButtonRelease: // Notify the embedder that we want the input focus send_xembed_message(XtDisplay(w), toolkit->browser_window, XEMBED_REQUEST_FOCUS, 0, 0, 0); break; } } /* ====================================================================== / / === XPCOM glue === / / ====================================================================== / #if defined(__GNUC__) && (__GNUC__ > 2) #define NS_LIKELY(x) (__builtin_expect((x), 1)) #define NS_UNLIKELY(x) (__builtin_expect((x), 0)) #else #define NS_LIKELY(x) (x) #define NS_UNLIKELY(x) (x) #endif #define NS_FAILED(_nsresult) (NS_UNLIKELY((_nsresult) & 0x80000000)) #define NS_SUCCEEDED(_nsresult) (NS_LIKELY(!((_nsresult) & 0x80000000))) typedef uint32_t nsresult; typedef struct nsIServiceManager nsIServiceManager; extern nsresult NS_GetServiceManager(nsIServiceManager result); / ====================================================================== / / === Window utilities === / / ====================================================================== / // Reconstruct window attributes static int create_window_attributes(NPSetWindowCallbackStruct ws_info) { if (ws_info == NULL) return -1; GdkVisual gdk_visual; if (ws_info->visual) gdk_visual = gdkx_visual_get((uintptr_t)ws_info->visual); else gdk_visual = gdk_visual_get_system(); if (gdk_visual == NULL) { npw_printf("ERROR: could not reconstruct XVisual from visualID\n"); return -2; } ws_info->display = x_display; ws_info->visual = gdk_x11_visual_get_xvisual(gdk_visual); return 0; } // Destroy window attributes struct static void destroy_window_attributes(NPSetWindowCallbackStruct ws_info) { if (ws_info == NULL) return; NPW_MemFree(ws_info); } // Fix size hints in NPWindow (Flash Player doesn't like null width) static void fixup_size_hints(PluginInstance plugin) { NPWindow window = &plugin->window; // check global hints (got through EMBED plugin args) if (window->width == 0 \|\| window->height == 0) { if (plugin->width && plugin->height) { window->width = plugin->width; window->height = plugin->height; return; } } // check actual window size and commit back to plugin data if (window->window && (window->width == 0 \|\| window->height == 0)) { XWindowAttributes win_attr; if (XGetWindowAttributes(x_display, (Window)window->window, &win_attr)) { plugin->width = window->width = win_attr.width; plugin->height = window->height = win_attr.height; return; } } if (window->width == 0 \|\| window->height == 0) npw_printf("WARNING: grmpf, despite much effort, I could not determine the actual plugin area size...\n"); } // Create a new window from NPWindow static int create_window(PluginInstance plugin, NPWindow window) { // XXX destroy previous window here? if (plugin->is_windowless) { destroy_window_attributes(plugin->window.ws_info); plugin->window.ws_info = NULL; } assert(plugin->window.ws_info == NULL); // cache new window information and reconstruct window attributes NPSetWindowCallbackStruct ws_info; if ((ws_info = NPW_MemClone(NPSetWindowCallbackStruct, window->ws_info)) == NULL) return -1; if (create_window_attributes(ws_info) < 0) return -1; memcpy(&plugin->window, window, sizeof(window)); window = &plugin->window; window->ws_info = ws_info; fixup_size_hints(plugin); // that's all for windowless plugins if (plugin->is_windowless) return 0; // create the new window if (plugin->use_xembed) { GtkData toolkit = calloc(1, sizeof(toolkit)); if (toolkit == NULL) return -1; toolkit->container = gtk_plug_new((GdkNativeWindow)window->window); if (toolkit->container == NULL) return -1; gtk_widget_set_size_request(toolkit->container, window->width, window->height); gtk_widget_show(toolkit->container); toolkit->socket = gtk_socket_new(); if (toolkit->socket == NULL) return -1; gtk_widget_show(toolkit->socket); gtk_container_add(GTK_CONTAINER(toolkit->container), toolkit->socket); gtk_widget_show_all(toolkit->container); window->window = (void )gtk_socket_get_id(GTK_SOCKET(toolkit->socket)); plugin->toolkit_data = toolkit; #if USE_XEMBED_HACK // don't let the browser kill our window out of NPP_Destroy() scope g_signal_connect(toolkit->container, "delete-event", G_CALLBACK(gtk_true), NULL); #endif // make sure we don't try to destroy the widget again in destroy_window() g_signal_connect(toolkit->container, "destroy", G_CALLBACK(gtk_widget_destroyed), &toolkit->container); // keep the socket as the plugin tries to destroy the widget itself g_signal_connect(toolkit->socket, "plug_removed", G_CALLBACK(gtk_true), NULL); return 0; } XtData toolkit = calloc(1, sizeof(toolkit)); if (toolkit == NULL) return -1; String app_name, app_class; XtGetApplicationNameAndClass(x_display, &app_name, &app_class); Widget top_widget = XtVaAppCreateShell("drawingArea", app_class, topLevelShellWidgetClass, x_display, XtNoverrideRedirect, True, XtNborderWidth, 0, XtNbackgroundPixmap, None, XtNwidth, window->width, XtNheight, window->height, NULL); Widget form = XtVaCreateManagedWidget("form", compositeWidgetClass, top_widget, XtNdepth, ws_info->depth, XtNvisual, ws_info->visual, XtNcolormap, ws_info->colormap, XtNborderWidth, 0, XtNbackgroundPixmap, None, XtNwidth, window->width, XtNheight, window->height, NULL); XtRealizeWidget(top_widget); XReparentWindow(x_display, XtWindow(top_widget), (Window)window->window, 0, 0); XtRealizeWidget(form); XSelectInput(x_display, XtWindow(top_widget), 0x0fffff); XtAddEventHandler(top_widget, (SubstructureNotifyMask\|KeyPress\|KeyRelease), True, xt_client_event_handler, toolkit); XtAddEventHandler(form, (ButtonReleaseMask), True, xt_client_event_handler, toolkit); xt_client_set_info(form, 0); plugin->toolkit_data = toolkit; toolkit->top_widget = top_widget; toolkit->form = form; toolkit->browser_window = (Window)window->window; window->window = (void )XtWindow(form); return 0; } // Update window information from NPWindow static int update_window(PluginInstance plugin, NPWindow window) { if (plugin->is_windowless) { npw_printf("ERROR: update_window() called for windowless plugin\n"); return -1; } if (window->ws_info == NULL) { npw_printf("ERROR: no window attributes for window %p\n", window->window); return -1; } // always synchronize window attributes NPSetWindowCallbackStruct ws_info = plugin->window.ws_info; memcpy(ws_info, window->ws_info, sizeof(ws_info)); create_window_attributes(ws_info); // synchronize cliprect memcpy(&plugin->window.clipRect, &window->clipRect, sizeof(window->clipRect));; // synchronize window position, if it changed if (plugin->window.x != window->x \|\| plugin->window.y != window->y) { plugin->window.x = window->x; plugin->window.y = window->y; } // synchronize window size, if it changed if (plugin->window.width != window->width \|\| plugin->window.height != window->height) { plugin->window.width = window->width; plugin->window.height = window->height; if (plugin->toolkit_data) { if (plugin->use_xembed) { // window size changes are already caught per the XEMBED protocol } else { XtData toolkit = (XtData )plugin->toolkit_data; if (toolkit->form) XtResizeWidget(toolkit->form, plugin->window.width, plugin->window.height, 0); if (toolkit->top_widget) XtResizeWidget(toolkit->top_widget, plugin->window.width, plugin->window.height, 0); } } } return 0; } // Destroy window static void destroy_window(PluginInstance plugin) { if (plugin->toolkit_data) { if (plugin->use_xembed) { GtkData toolkit = (GtkData )plugin->toolkit_data; if (toolkit->container) { gdk_flush(); gtk_widget_destroy(toolkit->container); gdk_flush(); toolkit->container = NULL; } } else { XtData toolkit = (XtData )plugin->toolkit_data; if (toolkit->top_widget) { XSync(x_display, False); XtUnrealizeWidget(toolkit->top_widget); XtDestroyWidget(toolkit->top_widget); XSync(x_display, False); toolkit->top_widget = None; } } free(plugin->toolkit_data); plugin->toolkit_data = NULL; } if (plugin->window.ws_info) { destroy_window_attributes(plugin->window.ws_info); plugin->window.ws_info = NULL; } } / ====================================================================== / / === Browser side plug-in API === / / ====================================================================== / static char g_user_agent = NULL; // Does browser have specified feature? #define NPN_HAS_FEATURE(FEATURE) ((mozilla_funcs.version & 0xff) >= NPVERS_HAS_##FEATURE) // Netscape exported functions static NPNetscapeFuncs mozilla_funcs; // Forces a repaint message for a windowless plug-in static void g_NPN_ForceRedraw(NPP instance) { D(bug("NPN_ForceRedraw instance=%p\n", instance)); NPW_UNIMPLEMENTED(); } // Asks the browser to create a stream for the specified URL static NPError invoke_NPN_GetURL(PluginInstance plugin, const char url, const char target) { npw_return_val_if_fail(rpc_method_invoke_possible(g_rpc_connection), NPERR_GENERIC_ERROR); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_GET_URL, RPC_TYPE_NPW_PLUGIN_INSTANCE, plugin, RPC_TYPE_STRING, url, RPC_TYPE_STRING, target, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_GetURL() invoke", error); return NPERR_GENERIC_ERROR; } int32_t ret; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INT32, &ret, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_GetURL() wait for reply", error); return NPERR_GENERIC_ERROR; } return ret; } static NPError g_NPN_GetURL(NPP instance, const char url, const char target) { if (!thread_check()) { npw_printf("WARNING: NPN_GetURL not called from the main thread\n"); return NPERR_INVALID_INSTANCE_ERROR; } if (instance == NULL) return NPERR_INVALID_INSTANCE_ERROR; PluginInstance plugin = PLUGIN_INSTANCE(instance); if (plugin == NULL) return NPERR_INVALID_INSTANCE_ERROR; D(bugiI("NPN_GetURL instance=%p\n", instance)); npw_plugin_instance_ref(plugin); NPError ret = invoke_NPN_GetURL(plugin, url, target); npw_plugin_instance_unref(plugin); D(bugiD("NPN_GetURL return: %d [%s]\n", ret, string_of_NPError(ret))); return ret; } // Requests creation of a new stream with the contents of the specified URL static NPError invoke_NPN_GetURLNotify(PluginInstance plugin, const char url, const char target, void notifyData) { npw_return_val_if_fail(rpc_method_invoke_possible(g_rpc_connection), NPERR_GENERIC_ERROR); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_GET_URL_NOTIFY, RPC_TYPE_NPW_PLUGIN_INSTANCE, plugin, RPC_TYPE_STRING, url, RPC_TYPE_STRING, target, RPC_TYPE_NP_NOTIFY_DATA, notifyData, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_GetURLNotify() invoke", error); return NPERR_GENERIC_ERROR; } int32_t ret; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INT32, &ret, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_GetURLNotify() wait for reply", error); return NPERR_GENERIC_ERROR; } return ret; } static NPError g_NPN_GetURLNotify(NPP instance, const char url, const char target, void notifyData) { if (!thread_check()) { npw_printf("WARNING: NPN_GetURLNotify not called from the main thread\n"); return NPERR_INVALID_INSTANCE_ERROR; } if (instance == NULL) return NPERR_INVALID_INSTANCE_ERROR; PluginInstance plugin = PLUGIN_INSTANCE(instance); if (plugin == NULL) return NPERR_INVALID_INSTANCE_ERROR; D(bugiI("NPN_GetURLNotify instance=%p\n", instance)); npw_plugin_instance_ref(plugin); NPError ret = invoke_NPN_GetURLNotify(plugin, url, target, notifyData); npw_plugin_instance_unref(plugin); D(bugiD("NPN_GetURLNotify return: %d [%s]\n", ret, string_of_NPError(ret))); return ret; } // Allows the plug-in to query the browser for information static NPError invoke_NPN_GetValue(PluginInstance plugin, NPNVariable variable, void value) { npw_return_val_if_fail(rpc_method_invoke_possible(g_rpc_connection), NPERR_GENERIC_ERROR); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_GET_VALUE, RPC_TYPE_NPW_PLUGIN_INSTANCE, plugin, RPC_TYPE_UINT32, variable, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_GetValue() invoke", error); return NPERR_GENERIC_ERROR; } int32_t ret; switch (rpc_type_of_NPNVariable(variable)) { case RPC_TYPE_UINT32: { uint32_t n = 0; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INT32, &ret, RPC_TYPE_UINT32, &n, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_GetValue() wait for reply", error); ret = NPERR_GENERIC_ERROR; } D(bug("-> value: %u\n", n)); ((unsigned int )value) = n; break; } case RPC_TYPE_BOOLEAN: { uint32_t b = 0; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INT32, &ret, RPC_TYPE_BOOLEAN, &b, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_GetValue() wait for reply", error); ret = NPERR_GENERIC_ERROR; } D(bug("-> value: %s\n", b ? "true" : "false")); ((NPBool )value) = b ? TRUE : FALSE; break; } case RPC_TYPE_NP_OBJECT: { NPObject npobj = NULL; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INT32, &ret, RPC_TYPE_NP_OBJECT, &npobj, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_GetValue() wait for reply", error); ret = NPERR_GENERIC_ERROR; } D(bug("-> value: <object %p>\n", npobj)); ((NPObject *)value) = npobj; break; } } return ret; } static NPError g_NPN_GetValue_real(NPP instance, NPNVariable variable, void value) { PluginInstance plugin = NULL; if (instance) plugin = PLUGIN_INSTANCE(instance); npw_plugin_instance_ref(plugin); NPError ret = invoke_NPN_GetValue(plugin, variable, value); npw_plugin_instance_unref(plugin); return ret; } static NPError g_NPN_GetValue(NPP instance, NPNVariable variable, void value) { D(bug("NPN_GetValue instance=%p, variable=%d [%s]\n", instance, variable, string_of_NPNVariable(variable))); if (!thread_check()) { npw_printf("WARNING: NPN_GetValue not called from the main thread\n"); return NPERR_INVALID_INSTANCE_ERROR; } PluginInstance plugin = NULL; if (instance) plugin = PLUGIN_INSTANCE(instance); switch (variable) { case NPNVxDisplay: (void *)value = x_display; break; case NPNVxtAppContext: (void *)value = XtDisplayToApplicationContext(x_display); break; case NPNVToolkit: (NPNToolkitType )value = NPW_TOOLKIT; break; #if USE_XPCOM case NPNVserviceManager: { nsIServiceManager sm; int ret = NS_GetServiceManager(&sm); if (NS_FAILED(ret)) { npw_printf("WARNING: NS_GetServiceManager failed\n"); return NPERR_GENERIC_ERROR; } (nsIServiceManager )value = sm; break; } case NPNVDOMWindow: case NPNVDOMElement: npw_printf("WARNING: %s is not supported by NPN_GetValue()\n", string_of_NPNVariable(variable)); return NPERR_INVALID_PARAM; #endif case NPNVnetscapeWindow: if (plugin == NULL) { npw_printf("ERROR: NPNVnetscapeWindow requires a non NULL instance\n"); return NPERR_INVALID_INSTANCE_ERROR; } if (plugin->browser_toplevel == NULL) { GdkNativeWindow netscape_xid = None; NPError error = g_NPN_GetValue_real(instance, variable, &netscape_xid); if (error != NPERR_NO_ERROR) return error; if (netscape_xid == None) return NPERR_GENERIC_ERROR; plugin->browser_toplevel = gdk_window_foreign_new(netscape_xid); if (plugin->browser_toplevel == NULL) return NPERR_GENERIC_ERROR; } ((GdkNativeWindow )value) = GDK_WINDOW_XWINDOW(plugin->browser_toplevel); break; #if ALLOW_WINDOWLESS_PLUGINS case NPNVSupportsWindowless: #endif case NPNVSupportsXEmbedBool: case NPNVWindowNPObject: case NPNVPluginElementNPObject: return g_NPN_GetValue_real(instance, variable, value); default: switch (variable & 0xff) { case 13: / NPNVToolkit / if (NPW_TOOLKIT == NPNVGtk2) { // Gtk2 does not need to depend on a specific C++ ABI (NPNToolkitType )value = NPW_TOOLKIT; return NPERR_NO_ERROR; } break; } D(bug("WARNING: unhandled variable %d (%s) in NPN_GetValue()\n", variable, string_of_NPNVariable(variable))); return NPERR_INVALID_PARAM; } return NPERR_NO_ERROR; } // Invalidates specified drawing area prior to repainting or refreshing a windowless plug-in static void invoke_NPN_InvalidateRect(PluginInstance plugin, NPRect invalidRect) { npw_return_if_fail(rpc_method_invoke_possible(g_rpc_connection)); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_INVALIDATE_RECT, RPC_TYPE_NPW_PLUGIN_INSTANCE, plugin, RPC_TYPE_NP_RECT, invalidRect, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_InvalidateRect() invoke", error); return; } error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_InvalidateRect() wait for reply", error); return; } } static void g_NPN_InvalidateRect(NPP instance, NPRect invalidRect) { if (!thread_check()) { npw_printf("WARNING: NPN_InvalidateRect not called from the main thread\n"); return; } if (instance == NULL) return; PluginInstance plugin = PLUGIN_INSTANCE(instance); if (plugin == NULL) return; if (invalidRect == NULL) return; D(bugiI("NPN_InvalidateRect instance=%p\n", PLUGIN_INSTANCE_NPP(plugin))); npw_plugin_instance_ref(plugin); invoke_NPN_InvalidateRect(plugin, invalidRect); npw_plugin_instance_unref(plugin); D(bugiD("NPN_InvalidateRect done\n")); } // Invalidates specified region prior to repainting or refreshing a windowless plug-in static void g_NPN_InvalidateRegion(NPP instance, NPRegion invalidRegion) { D(bug("NPN_InvalidateRegion instance=%p\n", instance)); NPW_UNIMPLEMENTED(); } // Allocates memory from the browser's memory space static void g_NPN_MemAlloc(uint32_t size) { D(bugiI("NPN_MemAlloc size=%d\n", size)); void ptr = NPW_MemAlloc(size); D(bugiD("NPN_MemAlloc return: %p\n", ptr)); return ptr; } // Requests that the browser free a specified amount of memory static uint32_t g_NPN_MemFlush(uint32_t size) { D(bug("NPN_MemFlush size=%d\n", size)); return 0; } // Deallocates a block of allocated memory static void g_NPN_MemFree(void ptr) { D(bugiI("NPN_MemFree ptr=%p\n", ptr)); NPW_MemFree(ptr); D(bugiD("NPN_MemFree done\n")); } // Posts data to a URL static NPError invoke_NPN_PostURL(PluginInstance plugin, const char url, const char target, uint32_t len, const char buf, NPBool file) { npw_return_val_if_fail(rpc_method_invoke_possible(g_rpc_connection), NPERR_GENERIC_ERROR); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_POST_URL, RPC_TYPE_NPW_PLUGIN_INSTANCE, plugin, RPC_TYPE_STRING, url, RPC_TYPE_STRING, target, RPC_TYPE_ARRAY, RPC_TYPE_CHAR, len, buf, RPC_TYPE_BOOLEAN, file, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_PostURL() invoke", error); return NPERR_GENERIC_ERROR; } int32_t ret; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INT32, &ret, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_PostURL() wait for reply", error); return NPERR_GENERIC_ERROR; } return ret; } static NPError g_NPN_PostURL(NPP instance, const char url, const char target, uint32_t len, const char buf, NPBool file) { if (!thread_check()) { npw_printf("WARNING: NPN_PostURL not called from the main thread\n"); return NPERR_INVALID_INSTANCE_ERROR; } if (instance == NULL) return NPERR_INVALID_INSTANCE_ERROR; PluginInstance plugin = PLUGIN_INSTANCE(instance); if (plugin == NULL) return NPERR_INVALID_INSTANCE_ERROR; D(bugiI("NPN_PostURL instance=%p\n", instance)); npw_plugin_instance_ref(plugin); NPError ret = invoke_NPN_PostURL(plugin, url, target, len, buf, file); npw_plugin_instance_unref(plugin); D(bugiD("NPN_PostURL return: %d [%s]\n", ret, string_of_NPError(ret))); return ret; } // Posts data to a URL, and receives notification of the result static NPError invoke_NPN_PostURLNotify(PluginInstance plugin, const char url, const char target, uint32_t len, const char buf, NPBool file, void notifyData) { npw_return_val_if_fail(rpc_method_invoke_possible(g_rpc_connection), NPERR_GENERIC_ERROR); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_POST_URL_NOTIFY, RPC_TYPE_NPW_PLUGIN_INSTANCE, plugin, RPC_TYPE_STRING, url, RPC_TYPE_STRING, target, RPC_TYPE_ARRAY, RPC_TYPE_CHAR, len, buf, RPC_TYPE_BOOLEAN, file, RPC_TYPE_NP_NOTIFY_DATA, notifyData, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_PostURLNotify() invoke", error); return NPERR_GENERIC_ERROR; } int32_t ret; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INT32, &ret, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_PostURLNotify() wait for reply", error); return NPERR_GENERIC_ERROR; } return ret; } static NPError g_NPN_PostURLNotify(NPP instance, const char url, const char target, uint32_t len, const char buf, NPBool file, void notifyData) { if (!thread_check()) { npw_printf("WARNING: NPN_PostURLNotify not called from the main thread\n"); return NPERR_INVALID_INSTANCE_ERROR; } if (instance == NULL) return NPERR_INVALID_INSTANCE_ERROR; PluginInstance plugin = PLUGIN_INSTANCE(instance); if (plugin == NULL) return NPERR_INVALID_INSTANCE_ERROR; D(bugiI("NPN_PostURLNotify instance=%p\n", instance)); npw_plugin_instance_ref(plugin); NPError ret = invoke_NPN_PostURLNotify(plugin, url, target, len, buf, file, notifyData); npw_plugin_instance_unref(plugin); D(bugiD("NPN_PostURLNotify return: %d [%s]\n", ret, string_of_NPError(ret))); return ret; } // Posts data to a URL, and receives notification of the result static void g_NPN_ReloadPlugins(NPBool reloadPages) { D(bug("NPN_ReloadPlugins reloadPages=%d\n", reloadPages)); NPW_UNIMPLEMENTED(); } // Returns the Java execution environment static void * g_NPN_GetJavaEnv(void) { D(bug("NPN_GetJavaEnv\n")); return NULL; } // Returns the Java object associated with the plug-in instance static void * g_NPN_GetJavaPeer(NPP instance) { D(bug("NPN_GetJavaPeer instance=%p\n", instance)); return NULL; } // Requests a range of bytes for a seekable stream static NPError invoke_NPN_RequestRead(NPStream stream, NPByteRange rangeList) { npw_return_val_if_fail(rpc_method_invoke_possible(g_rpc_connection), NPERR_GENERIC_ERROR); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_REQUEST_READ, RPC_TYPE_NP_STREAM, stream, RPC_TYPE_NP_BYTE_RANGE, rangeList, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_RequestRead() invoke", error); return NPERR_GENERIC_ERROR; } int32_t ret; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INT32, &ret, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_RequestRead() wait for reply", error); return NPERR_GENERIC_ERROR; } return ret; } static NPError g_NPN_RequestRead(NPStream stream, NPByteRange rangeList) { if (!thread_check()) { npw_printf("WARNING: NPN_RequestRead not called from the main thread\n"); return NPERR_INVALID_INSTANCE_ERROR; } if (stream == NULL \|\| stream->ndata == NULL \|\| rangeList == NULL) return NPERR_INVALID_PARAM; D(bugiI("NPN_RequestRead stream=%p\n", stream)); NPError ret = invoke_NPN_RequestRead(stream, rangeList); D(bugiD("NPN_RequestRead return: %d [%s]\n", ret, string_of_NPError(ret))); return ret; } // Sets various modes of plug-in operation static NPError invoke_NPN_SetValue(PluginInstance plugin, NPPVariable variable, void value) { switch (rpc_type_of_NPPVariable(variable)) { case RPC_TYPE_BOOLEAN: break; default: D(bug("WARNING: unhandled variable %d in NPN_SetValue()\n", variable)); return NPERR_INVALID_PARAM; } npw_return_val_if_fail(rpc_method_invoke_possible(g_rpc_connection), NPERR_GENERIC_ERROR); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_SET_VALUE, RPC_TYPE_NPW_PLUGIN_INSTANCE, plugin, RPC_TYPE_UINT32, variable, RPC_TYPE_BOOLEAN, (uint32_t)(uintptr_t)value, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_SetValue() invoke", error); return NPERR_GENERIC_ERROR; } int32_t ret; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INT32, &ret, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_SetValue() wait for reply", error); return NPERR_GENERIC_ERROR; } return ret; } static NPError g_NPN_SetValue(NPP instance, NPPVariable variable, void value) { if (!thread_check()) { npw_printf("WARNING: NPN_SetValue not called from the main thread\n"); return NPERR_INVALID_INSTANCE_ERROR; } if (instance == NULL) return NPERR_INVALID_INSTANCE_ERROR; PluginInstance plugin = PLUGIN_INSTANCE(instance); if (plugin == NULL) return NPERR_INVALID_INSTANCE_ERROR; D(bugiI("NPN_SetValue instance=%p, variable=%d [%s]\n", instance, variable, string_of_NPPVariable(variable))); npw_plugin_instance_ref(plugin); NPError ret = invoke_NPN_SetValue(plugin, variable, value); npw_plugin_instance_unref(plugin); D(bugiD("NPN_SetValue return: %d [%s]\n", ret, string_of_NPError(ret))); return ret; } // Displays a message on the status line of the browser window static void invoke_NPN_Status(PluginInstance plugin, const char message) { npw_return_if_fail(rpc_method_invoke_possible(g_rpc_connection)); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_STATUS, RPC_TYPE_NPW_PLUGIN_INSTANCE, plugin, RPC_TYPE_STRING, message, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_Status() invoke", error); return; } error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_Status() wait for reply", error); return; } } static void g_NPN_Status(NPP instance, const char message) { if (!thread_check()) { npw_printf("WARNING: NPN_Status not called from the main thread\n"); return; } PluginInstance plugin = NULL; if (instance) plugin = PLUGIN_INSTANCE(instance); D(bugiI("NPN_Status instance=%p, message='%s'\n", instance, message)); npw_plugin_instance_ref(plugin); invoke_NPN_Status(plugin, message); npw_plugin_instance_unref(plugin); D(bugiD("NPN_Status done\n")); } // Returns the browser's user agent field static char * invoke_NPN_UserAgent(void) { npw_return_val_if_fail(rpc_method_invoke_possible(g_rpc_connection), NULL); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_USER_AGENT, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_UserAgent() invoke", error); return NULL; } char user_agent; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_STRING, &user_agent, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_UserAgent() wait for reply", error); return NULL; } return user_agent; } static const char g_NPN_UserAgent(NPP instance) { if (!thread_check()) { npw_printf("WARNING: NPN_UserAgent not called from the main thread\n"); return NULL; } D(bugiI("NPN_UserAgent instance=%p\n", instance)); if (g_user_agent == NULL) g_user_agent = invoke_NPN_UserAgent(); D(bugiD("NPN_UserAgent return: '%s'\n", g_user_agent)); return g_user_agent; } // Requests the creation of a new data stream produced by the plug-in and consumed by the browser static NPError invoke_NPN_NewStream(PluginInstance plugin, NPMIMEType type, const char target, NPStream *pstream) { npw_return_val_if_fail(rpc_method_invoke_possible(g_rpc_connection), NPERR_GENERIC_ERROR); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_NEW_STREAM, RPC_TYPE_NPW_PLUGIN_INSTANCE, plugin, RPC_TYPE_STRING, type, RPC_TYPE_STRING, target, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_NewStream() invoke", error); return NPERR_OUT_OF_MEMORY_ERROR; } int32_t ret; uint32_t stream_id; char url; uint32_t end; uint32_t lastmodified; void notifyData; char headers; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INT32, &ret, RPC_TYPE_UINT32, &stream_id, RPC_TYPE_STRING, &url, RPC_TYPE_UINT32, &end, RPC_TYPE_UINT32, &lastmodified, RPC_TYPE_NP_NOTIFY_DATA, &notifyData, RPC_TYPE_STRING, &headers, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_NewStream() wait for reply", error); return NPERR_GENERIC_ERROR; } NPStream stream = NULL; if (ret == NPERR_NO_ERROR) { if ((stream = malloc(sizeof(stream))) == NULL) return NPERR_OUT_OF_MEMORY_ERROR; memset(stream, 0, sizeof(stream)); StreamInstance stream_ndata; if ((stream_ndata = malloc(sizeof(stream_ndata))) == NULL) { free(stream); return NPERR_OUT_OF_MEMORY_ERROR; } stream->ndata = stream_ndata; stream->url = url; stream->end = end; stream->lastmodified = lastmodified; stream->notifyData = notifyData; stream->headers = headers; memset(stream_ndata, 0, sizeof(stream_ndata)); stream_ndata->stream_id = stream_id; id_link(stream_id, stream_ndata); stream_ndata->stream = stream; stream_ndata->is_plugin_stream = 1; } else { if (url) free(url); if (headers) free(headers); } pstream = stream; return ret; } static NPError g_NPN_NewStream(NPP instance, NPMIMEType type, const char target, NPStream *stream) { if (!thread_check()) { npw_printf("WARNING: NPN_NewStream not called from the main thread\n"); return NPERR_INVALID_INSTANCE_ERROR; } if (instance == NULL) return NPERR_INVALID_INSTANCE_ERROR; PluginInstance plugin = PLUGIN_INSTANCE(instance); if (plugin == NULL) return NPERR_INVALID_INSTANCE_ERROR; if (stream == NULL) return NPERR_INVALID_PARAM; stream = NULL; D(bugiI("NPN_NewStream instance=%p\n", instance)); npw_plugin_instance_ref(plugin); NPError ret = invoke_NPN_NewStream(plugin, type, target, stream); npw_plugin_instance_unref(plugin); D(bugiD("NPN_NewStream return: %d [%s]\n", ret, string_of_NPError(ret))); return ret; } // Closes and deletes a stream static NPError invoke_NPN_DestroyStream(PluginInstance plugin, NPStream stream, NPError reason) { npw_return_val_if_fail(rpc_method_invoke_possible(g_rpc_connection), NPERR_GENERIC_ERROR); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_DESTROY_STREAM, RPC_TYPE_NPW_PLUGIN_INSTANCE, plugin, RPC_TYPE_NP_STREAM, stream, RPC_TYPE_INT32, (int32_t)reason, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_DestroyStream() invoke", error); return NPERR_GENERIC_ERROR; } int32_t ret; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INT32, &ret, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_DestroyStream() wait for reply", error); return NPERR_GENERIC_ERROR; } return ret; } static NPError g_NPN_DestroyStream(NPP instance, NPStream stream, NPError reason) { if (!thread_check()) { npw_printf("WARNING: NPN_DestroyStream not called from the main thread\n"); return NPERR_INVALID_INSTANCE_ERROR; } if (instance == NULL) return NPERR_INVALID_INSTANCE_ERROR; PluginInstance plugin = PLUGIN_INSTANCE(instance); if (plugin == NULL) return NPERR_INVALID_INSTANCE_ERROR; if (stream == NULL) return NPERR_INVALID_PARAM; D(bugiI("NPN_DestroyStream instance=%p, stream=%p, reason=%s\n", instance, stream, string_of_NPReason(reason))); npw_plugin_instance_ref(plugin); NPError ret = invoke_NPN_DestroyStream(plugin, stream, reason); npw_plugin_instance_unref(plugin); D(bugiD("NPN_DestroyStream return: %d [%s]\n", ret, string_of_NPError(ret))); // Mozilla calls NPP_DestroyStream() for its streams, keep stream // info in that case StreamInstance stream_ndata = stream->ndata; if (stream_ndata && stream_ndata->is_plugin_stream) { id_remove(stream_ndata->stream_id); free(stream_ndata); free((char )stream->url); free((char )stream->headers); free(stream); } return ret; } // Pushes data into a stream produced by the plug-in and consumed by the browser static int invoke_NPN_Write(PluginInstance plugin, NPStream stream, int32_t len, void buf) { npw_return_val_if_fail(rpc_method_invoke_possible(g_rpc_connection), -1); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_WRITE, RPC_TYPE_NPW_PLUGIN_INSTANCE, plugin, RPC_TYPE_NP_STREAM, stream, RPC_TYPE_ARRAY, RPC_TYPE_CHAR, len, buf, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_Write() invoke", error); return -1; } int32_t ret; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INT32, &ret, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_Write() wait for reply", error); return -1; } return ret; } static int32_t g_NPN_Write(NPP instance, NPStream stream, int32_t len, void buf) { if (!thread_check()) { npw_printf("WARNING: NPN_Write not called from the main thread\n"); return -1; } if (instance == NULL) return -1; PluginInstance plugin = PLUGIN_INSTANCE(instance); if (plugin == NULL) return -1; if (stream == NULL) return -1; D(bugiI("NPN_Write instance=%p, stream=%p, len=%d, buf=%p\n", instance, stream, len, buf)); npw_plugin_instance_ref(plugin); int32_t ret = invoke_NPN_Write(plugin, stream, len, buf); npw_plugin_instance_unref(plugin); D(bugiD("NPN_Write return: %d\n", ret)); return ret; } // Enable popups while executing code where popups should be enabled static void invoke_NPN_PushPopupsEnabledState(PluginInstance plugin, NPBool enabled) { npw_return_if_fail(rpc_method_invoke_possible(g_rpc_connection)); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_PUSH_POPUPS_ENABLED_STATE, RPC_TYPE_NPW_PLUGIN_INSTANCE, plugin, RPC_TYPE_UINT32, (uint32_t)enabled, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_PushPopupsEnabledState() invoke", error); return; } error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) npw_perror("NPN_PushPopupsEnabledState() wait for reply", error); } static void g_NPN_PushPopupsEnabledState(NPP instance, NPBool enabled) { if (!thread_check()) { npw_printf("WARNING: NPN_PushPopupsEnabledState not called from the main thread\n"); return; } if (instance == NULL) return; PluginInstance plugin = PLUGIN_INSTANCE(instance); if (plugin == NULL) return; D(bugiI("NPN_PushPopupsEnabledState instance=%p, enabled=%d\n", instance, enabled)); npw_plugin_instance_ref(plugin); invoke_NPN_PushPopupsEnabledState(plugin, enabled); npw_plugin_instance_unref(plugin); D(bugiD("NPN_PushPopupsEnabledState done\n")); } // Restore popups state static void invoke_NPN_PopPopupsEnabledState(PluginInstance plugin) { npw_return_if_fail(rpc_method_invoke_possible(g_rpc_connection)); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_POP_POPUPS_ENABLED_STATE, RPC_TYPE_NPW_PLUGIN_INSTANCE, plugin, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_PopPopupsEnabledState() invoke", error); return; } error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) npw_perror("NPN_PopPopupsEnabledState() wait for reply", error); } static void g_NPN_PopPopupsEnabledState(NPP instance) { if (!thread_check()) { npw_printf("WARNING: NPN_PophPopupsEnabledState not called from the main thread\n"); return; } if (instance == NULL) return; PluginInstance plugin = PLUGIN_INSTANCE(instance); if (plugin == NULL) return; D(bugiI("NPN_PopPopupsEnabledState instance=%p\n", instance)); npw_plugin_instance_ref(plugin); invoke_NPN_PopPopupsEnabledState(plugin); npw_plugin_instance_unref(plugin); D(bugiD("NPN_PopPopupsEnabledState done\n")); } /* ====================================================================== / / === NPRuntime glue === / / ====================================================================== / // Allocates a new NPObject static uint32_t invoke_NPN_CreateObject(PluginInstance plugin) { npw_return_val_if_fail(rpc_method_invoke_possible(g_rpc_connection), 0); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_CREATE_OBJECT, RPC_TYPE_NPW_PLUGIN_INSTANCE, plugin, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_CreateObject() invoke", error); return 0; } uint32_t npobj_id = 0; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_UINT32, &npobj_id, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_CreateObject() wait for reply", error); return 0; } return npobj_id; } static NPObject * g_NPN_CreateObject(NPP instance, NPClass class) { if (!thread_check()) { npw_printf("WARNING: NPN_CreateObject not called from the main thread\n"); return NULL; } if (instance == NULL) return NULL; PluginInstance plugin = PLUGIN_INSTANCE(instance); if (plugin == NULL) return NULL; if (class == NULL) return NULL; D(bugiI("NPN_CreateObject\n")); npw_plugin_instance_ref(plugin); uint32_t npobj_id = invoke_NPN_CreateObject(plugin); npw_plugin_instance_unref(plugin); assert(npobj_id != 0); NPObject npobj = npobject_new(npobj_id, instance, class); D(bugiD("NPN_CreateObject return: %p (refcount: %d)\n", npobj, npobj->referenceCount)); return npobj; } // Increments the reference count of the given NPObject static uint32_t invoke_NPN_RetainObject(NPObject npobj) { npw_return_val_if_fail(rpc_method_invoke_possible(g_rpc_connection), npobj->referenceCount); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_RETAIN_OBJECT, RPC_TYPE_NP_OBJECT, npobj, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_RetainObject() invoke", error); return npobj->referenceCount; } uint32_t refcount; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_UINT32, &refcount, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_RetainObject() wait for reply", error); return npobj->referenceCount; } return refcount; } static NPObject * g_NPN_RetainObject(NPObject npobj) { if (!thread_check()) { npw_printf("WARNING: NPN_RetainObject not called from the main thread\n"); return NULL; } if (npobj == NULL) return NULL; D(bugiI("NPN_RetainObject npobj=%p\n", npobj)); uint32_t refcount = invoke_NPN_RetainObject(npobj); D(bugiD("NPN_RetainObject return: %p (refcount: %d)\n", npobj, refcount)); npobj->referenceCount = refcount; return npobj; } // Decrements the reference count of the give NPObject static uint32_t invoke_NPN_ReleaseObject(NPObject npobj) { npw_return_val_if_fail(rpc_method_invoke_possible(g_rpc_connection), npobj->referenceCount); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_RELEASE_OBJECT, RPC_TYPE_NP_OBJECT, npobj, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_ReleaseObject() invoke", error); return npobj->referenceCount; } uint32_t refcount; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_UINT32, &refcount, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_ReleaseObject() wait for reply", error); return npobj->referenceCount; } return refcount; } static void g_NPN_ReleaseObject_Now(NPObject npobj) { D(bugiI("NPN_ReleaseObject npobj=%p\n", npobj)); uint32_t refcount = invoke_NPN_ReleaseObject(npobj); D(bugiD("NPN_ReleaseObject done (refcount: %d)\n", refcount)); if ((npobj->referenceCount = refcount) == 0) npobject_destroy(npobj); } static void g_NPN_ReleaseObject_Delayed(NPObject npobj) { delayed_calls_add(RPC_DELAYED_NPN_RELEASE_OBJECT, npobj); } static void g_NPN_ReleaseObject(NPObject npobj) { if (!thread_check()) { npw_printf("WARNING: NPN_ReleaseObject not called from the main thread\n"); return; } if (npobj == NULL) return; if (rpc_method_invoke_possible(g_rpc_connection)) { D(bug("NPN_ReleaseObject <now>\n")); g_NPN_ReleaseObject_Now(npobj); } else { D(bug("NPN_ReleaseObject <delayed>\n")); g_NPN_ReleaseObject_Delayed(npobj); } } // Invokes a method on the given NPObject static bool invoke_NPN_Invoke(PluginInstance plugin, NPObject npobj, NPIdentifier methodName, const NPVariant args, uint32_t argCount, NPVariant result) { npw_return_val_if_fail(rpc_method_invoke_possible(g_rpc_connection), false); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_INVOKE, RPC_TYPE_NPW_PLUGIN_INSTANCE, plugin, RPC_TYPE_NP_OBJECT, npobj, RPC_TYPE_NP_IDENTIFIER, &methodName, RPC_TYPE_ARRAY, RPC_TYPE_NP_VARIANT, argCount, args, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_Invoke() invoke", error); return false; } uint32_t ret; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_UINT32, &ret, RPC_TYPE_NP_VARIANT, result, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_Invoke() wait for reply", error); return false; } return ret; } static bool g_NPN_Invoke(NPP instance, NPObject npobj, NPIdentifier methodName, const NPVariant args, uint32_t argCount, NPVariant result) { if (!thread_check()) { npw_printf("WARNING: NPN_Invoke not called from the main thread\n"); return false; } if (instance == NULL) return false; PluginInstance plugin = PLUGIN_INSTANCE(instance); if (plugin == NULL) return false; if (!npobj \|\| !npobj->_class \|\| !npobj->_class->invoke) return false; D(bugiI("NPN_Invoke instance=%p, npobj=%p, methodName=%p\n", instance, npobj, methodName)); print_npvariant_args(args, argCount); npw_plugin_instance_ref(plugin); bool ret = invoke_NPN_Invoke(plugin, npobj, methodName, args, argCount, result); npw_plugin_instance_unref(plugin); gchar result_str = string_of_NPVariant(result); D(bugiD("NPN_Invoke return: %d (%s)\n", ret, result_str)); g_free(result_str); return ret; } // Invokes the default method on the given NPObject static bool invoke_NPN_InvokeDefault(PluginInstance plugin, NPObject npobj, const NPVariant args, uint32_t argCount, NPVariant result) { npw_return_val_if_fail(rpc_method_invoke_possible(g_rpc_connection), false); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_INVOKE_DEFAULT, RPC_TYPE_NPW_PLUGIN_INSTANCE, plugin, RPC_TYPE_NP_OBJECT, npobj, RPC_TYPE_ARRAY, RPC_TYPE_NP_VARIANT, argCount, args, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_InvokeDefault() invoke", error); return false; } uint32_t ret; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_UINT32, &ret, RPC_TYPE_NP_VARIANT, result, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_InvokeDefault() wait for reply", error); return false; } return ret; } static bool g_NPN_InvokeDefault(NPP instance, NPObject npobj, const NPVariant args, uint32_t argCount, NPVariant result) { if (!thread_check()) { npw_printf("WARNING: NPN_InvokeDefault not called from the main thread\n"); return false; } if (instance == NULL) return false; PluginInstance plugin = PLUGIN_INSTANCE(instance); if (plugin == NULL) return false; if (!npobj \|\| !npobj->_class \|\| !npobj->_class->invokeDefault) return false; D(bugiI("NPN_InvokeDefault instance=%p, npobj=%p\n", instance, npobj)); print_npvariant_args(args, argCount); npw_plugin_instance_ref(plugin); bool ret = invoke_NPN_InvokeDefault(plugin, npobj, args, argCount, result); npw_plugin_instance_unref(plugin); gchar result_str = string_of_NPVariant(result); D(bugiD("NPN_InvokeDefault return: %d (%s)\n", ret, result_str)); g_free(result_str); return ret; } // Evaluates a script on the scope of a given NPObject static bool invoke_NPN_Evaluate(PluginInstance plugin, NPObject npobj, NPString script, NPVariant result) { npw_return_val_if_fail(rpc_method_invoke_possible(g_rpc_connection), false); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_EVALUATE, RPC_TYPE_NPW_PLUGIN_INSTANCE, plugin, RPC_TYPE_NP_OBJECT, npobj, RPC_TYPE_NP_STRING, script, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_Evaluate() invoke", error); return false; } uint32_t ret; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_UINT32, &ret, RPC_TYPE_NP_VARIANT, result, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_Evaluate() wait for reply", error); return false; } return ret; } static bool g_NPN_Evaluate(NPP instance, NPObject npobj, NPString script, NPVariant result) { if (!thread_check()) { npw_printf("WARNING: NPN_Evaluate not called from the main thread\n"); return false; } if (instance == NULL) return false; PluginInstance plugin = PLUGIN_INSTANCE(instance); if (plugin == NULL) return false; if (!npobj) return false; if (!script \|\| !script->UTF8Length \|\| !script->UTF8Characters) return true; // nothing to evaluate D(bugiI("NPN_Evaluate instance=%p, npobj=%p\n", instance, npobj)); npw_plugin_instance_ref(plugin); bool ret = invoke_NPN_Evaluate(plugin, npobj, script, result); npw_plugin_instance_unref(plugin); gchar result_str = string_of_NPVariant(result); D(bugiD("NPN_Evaluate return: %d (%s)\n", ret, result_str)); g_free(result_str); return ret; } // Gets the value of a property on the given NPObject static bool invoke_NPN_GetProperty(PluginInstance plugin, NPObject npobj, NPIdentifier propertyName, NPVariant result) { npw_return_val_if_fail(rpc_method_invoke_possible(g_rpc_connection), false); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_GET_PROPERTY, RPC_TYPE_NPW_PLUGIN_INSTANCE, plugin, RPC_TYPE_NP_OBJECT, npobj, RPC_TYPE_NP_IDENTIFIER, &propertyName, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_GetProperty() invoke", error); return false; } uint32_t ret; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_UINT32, &ret, RPC_TYPE_NP_VARIANT, result, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_GetProperty() wait for reply", error); return false; } return ret; } static bool g_NPN_GetProperty(NPP instance, NPObject npobj, NPIdentifier propertyName, NPVariant result) { if (!thread_check()) { npw_printf("WARNING: NPN_GetProperty not called from the main thread\n"); return false; } if (instance == NULL) return false; PluginInstance plugin = PLUGIN_INSTANCE(instance); if (plugin == NULL) return false; if (!npobj \|\| !npobj->_class \|\| !npobj->_class->getProperty) return false; D(bugiI("NPN_GetProperty instance=%p, npobj=%p, propertyName=%p\n", instance, npobj, propertyName)); npw_plugin_instance_ref(plugin); bool ret = invoke_NPN_GetProperty(plugin, npobj, propertyName, result); npw_plugin_instance_unref(plugin); gchar result_str = string_of_NPVariant(result); D(bugiD("NPN_GetProperty return: %d (%s)\n", ret, result_str)); g_free(result_str); return ret; } // Sets the value of a property on the given NPObject static bool invoke_NPN_SetProperty(PluginInstance plugin, NPObject npobj, NPIdentifier propertyName, const NPVariant value) { npw_return_val_if_fail(rpc_method_invoke_possible(g_rpc_connection), false); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_SET_PROPERTY, RPC_TYPE_NPW_PLUGIN_INSTANCE, plugin, RPC_TYPE_NP_OBJECT, npobj, RPC_TYPE_NP_IDENTIFIER, &propertyName, RPC_TYPE_NP_VARIANT, value, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_SetProperty() invoke", error); return false; } uint32_t ret; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_UINT32, &ret, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_SetProperty() wait for reply", error); return false; } return ret; } static bool g_NPN_SetProperty(NPP instance, NPObject npobj, NPIdentifier propertyName, const NPVariant value) { if (!thread_check()) { npw_printf("WARNING: NPN_SetProperty not called from the main thread\n"); return false; } if (instance == NULL) return false; PluginInstance plugin = PLUGIN_INSTANCE(instance); if (plugin == NULL) return false; if (!npobj \|\| !npobj->_class \|\| !npobj->_class->setProperty) return false; D(bugiI("NPN_SetProperty instance=%p, npobj=%p, propertyName=%p\n", instance, npobj, propertyName)); npw_plugin_instance_ref(plugin); bool ret = invoke_NPN_SetProperty(plugin, npobj, propertyName, value); npw_plugin_instance_unref(plugin); D(bugiD("NPN_SetProperty return: %d\n", ret)); return ret; } // Removes a property on the given NPObject static bool invoke_NPN_RemoveProperty(PluginInstance plugin, NPObject npobj, NPIdentifier propertyName) { npw_return_val_if_fail(rpc_method_invoke_possible(g_rpc_connection), false); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_REMOVE_PROPERTY, RPC_TYPE_NPW_PLUGIN_INSTANCE, plugin, RPC_TYPE_NP_OBJECT, npobj, RPC_TYPE_NP_IDENTIFIER, &propertyName, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_RemoveProperty() invoke", error); return false; } uint32_t ret; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_UINT32, &ret, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_RemoveProperty() wait for reply", error); return false; } return ret; } static bool g_NPN_RemoveProperty(NPP instance, NPObject npobj, NPIdentifier propertyName) { if (!thread_check()) { npw_printf("WARNING: NPN_RemoveProperty not called from the main thread\n"); return false; } if (instance == NULL) return false; PluginInstance plugin = PLUGIN_INSTANCE(instance); if (plugin == NULL) return false; if (!npobj \|\| !npobj->_class \|\| !npobj->_class->removeProperty) return false; D(bugiI("NPN_RemoveProperty instance=%p, npobj=%p, propertyName=%p\n", instance, npobj, propertyName)); npw_plugin_instance_ref(plugin); bool ret = invoke_NPN_RemoveProperty(plugin, npobj, propertyName); npw_plugin_instance_unref(plugin); D(bugiD("NPN_RemoveProperty return: %d\n", ret)); return ret; } // Checks if a given property exists on the given NPObject static bool invoke_NPN_HasProperty(PluginInstance plugin, NPObject npobj, NPIdentifier propertyName) { npw_return_val_if_fail(rpc_method_invoke_possible(g_rpc_connection), false); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_HAS_PROPERTY, RPC_TYPE_NPW_PLUGIN_INSTANCE, plugin, RPC_TYPE_NP_OBJECT, npobj, RPC_TYPE_NP_IDENTIFIER, &propertyName, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_HasProperty() invoke", error); return false; } uint32_t ret; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_UINT32, &ret, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_HasProperty() wait for reply", error); return false; } return ret; } static bool g_NPN_HasProperty(NPP instance, NPObject npobj, NPIdentifier propertyName) { if (!thread_check()) { npw_printf("WARNING: NPN_HasProperty not called from the main thread\n"); return false; } if (instance == NULL) return false; PluginInstance plugin = PLUGIN_INSTANCE(instance); if (plugin == NULL) return false; if (!npobj \|\| !npobj->_class \|\| !npobj->_class->hasProperty) return false; D(bugiI("NPN_HasProperty instance=%p, npobj=%p, propertyName=%p\n", instance, npobj, propertyName)); npw_plugin_instance_ref(plugin); bool ret = invoke_NPN_HasProperty(plugin, npobj, propertyName); npw_plugin_instance_unref(plugin); D(bugiD("NPN_HasProperty return: %d\n", ret)); return ret; } // Checks if a given method exists on the given NPObject static bool invoke_NPN_HasMethod(PluginInstance plugin, NPObject npobj, NPIdentifier methodName) { npw_return_val_if_fail(rpc_method_invoke_possible(g_rpc_connection), false); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_HAS_METHOD, RPC_TYPE_NPW_PLUGIN_INSTANCE, plugin, RPC_TYPE_NP_OBJECT, npobj, RPC_TYPE_NP_IDENTIFIER, &methodName, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_HasMethod() invoke", error); return false; } uint32_t ret; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_UINT32, &ret, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_HasMethod() wait for reply", error); return false; } return ret; } static bool g_NPN_HasMethod(NPP instance, NPObject npobj, NPIdentifier methodName) { if (!thread_check()) { npw_printf("WARNING: NPN_HasMethod not called from the main thread\n"); return false; } if (instance == NULL) return false; PluginInstance plugin = PLUGIN_INSTANCE(instance); if (plugin == NULL) return false; if (!npobj \|\| !npobj->_class \|\| !npobj->_class->hasMethod) return false; D(bugiI("NPN_HasMethod instance=%p, npobj=%p, methodName=%p\n", instance, npobj, methodName)); npw_plugin_instance_ref(plugin); bool ret = invoke_NPN_HasMethod(plugin, npobj, methodName); npw_plugin_instance_unref(plugin); D(bugiD("NPN_HasMethod return: %d\n", ret)); return ret; } // Indicates that a call to one of the plugins NPObjects generated an error static void invoke_NPN_SetException(NPObject npobj, const NPUTF8 message) { npw_return_if_fail(rpc_method_invoke_possible(g_rpc_connection)); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_SET_EXCEPTION, RPC_TYPE_NP_OBJECT, npobj, RPC_TYPE_STRING, message, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_SetException() invoke", error); return; } error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_SetException() wait for reply", error); return; } } static void g_NPN_SetException(NPObject npobj, const NPUTF8 message) { if (!thread_check()) { npw_printf("WARNING: NPN_SetException not called from the main thread\n"); return; } D(bugiI("NPN_SetException npobj=%p, message='%s'\n", npobj, message)); invoke_NPN_SetException(npobj, message); D(bugiD("NPN_SetException done\n")); } // Releases the value in the given variant static void g_NPN_ReleaseVariantValue(NPVariant variant) { D(bugiI("NPN_ReleaseVariantValue\n")); npvariant_clear(variant); D(bugiD("NPN_ReleaseVariantValue done\n")); } // Returns an opaque identifier for the string that is passed in static NPIdentifier invoke_NPN_GetStringIdentifier(const NPUTF8 name) { npw_return_val_if_fail(rpc_method_invoke_possible(g_rpc_connection), NULL); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_GET_STRING_IDENTIFIER, RPC_TYPE_STRING, name, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_GetStringIdentifier() invoke", error); return NULL; } NPIdentifier ident; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_NP_IDENTIFIER, &ident, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_GetStringIdentifier() wait for reply", error); return NULL; } return ident; } static NPIdentifier cached_NPN_GetStringIdentifier(const NPUTF8 name) { NPIdentifier ident; if (!use_npidentifier_cache()) ident = invoke_NPN_GetStringIdentifier(name); #if USE_NPIDENTIFIER_CACHE else if (!npidentifier_cache_has_string(name, &ident)) { ident = invoke_NPN_GetStringIdentifier(name); npidentifier_cache_reserve(1); npidentifier_cache_add_string(ident, name); } #endif return ident; } static NPIdentifier g_NPN_GetStringIdentifier(const NPUTF8 name) { if (!thread_check()) { npw_printf("WARNING: NPN_GetStringIdentifier not called from the main thread\n"); return NULL; } if (name == NULL) return NULL; D(bugiI("NPN_GetStringIdentifier name='%s'\n", name)); NPIdentifier ret = cached_NPN_GetStringIdentifier(name); D(bugiD("NPN_GetStringIdentifier return: %p\n", ret)); return ret; } // Returns an array of opaque identifiers for the names that are passed in static void invoke_NPN_GetStringIdentifiers(const NPUTF8 names, int32_t nameCount, NPIdentifier identifiers) { npw_return_if_fail(rpc_method_invoke_possible(g_rpc_connection)); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_GET_STRING_IDENTIFIERS, RPC_TYPE_ARRAY, RPC_TYPE_STRING, nameCount, names, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_GetStringIdentifiers() invoke", error); return; } uint32_t n_idents; NPIdentifier idents; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_ARRAY, RPC_TYPE_NP_IDENTIFIER, &n_idents, &idents, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_GetStringIdentifiers() wait for reply", error); return; } if (identifiers) { if (n_idents != nameCount) { npw_printf("ERROR: NPN_GetStringIdentifiers returned fewer NPIdentifiers than expected\n"); if (n_idents > nameCount) n_idents = nameCount; } for (int i = 0; i < n_idents; i++) identifiers[i] = idents[i]; free(idents); } } static void cached_NPN_GetStringIdentifiers(const NPUTF8 names, int32_t nameCount, NPIdentifier identifiers) { /* XXX: could be optimized further / invoke_NPN_GetStringIdentifiers(names, nameCount, identifiers); #if USE_NPIDENTIFIER_CACHE if (use_npidentifier_cache()) { for (int i = 0; i < nameCount; i++) { NPIdentifier ident = identifiers[i]; if (npidentifier_cache_lookup(ident) == NULL) { npidentifier_cache_reserve(1); npidentifier_cache_add_string(ident, names[i]); } } } #endif } static void g_NPN_GetStringIdentifiers(const NPUTF8 names, int32_t nameCount, NPIdentifier identifiers) { if (!thread_check()) { npw_printf("WARNING: NPN_GetStringIdentifiers not called from the main thread\n"); return; } if (names == NULL) return; if (identifiers == NULL) return; D(bugiI("NPN_GetStringIdentifiers names=%p\n", names)); cached_NPN_GetStringIdentifiers(names, nameCount, identifiers); D(bugiD("NPN_GetStringIdentifiers done\n")); } // Returns an opaque identifier for the integer that is passed in static NPIdentifier invoke_NPN_GetIntIdentifier(int32_t intid) { npw_return_val_if_fail(rpc_method_invoke_possible(g_rpc_connection), NULL); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_GET_INT_IDENTIFIER, RPC_TYPE_INT32, intid, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_GetIntIdentifier() invoke", error); return NULL; } NPIdentifier ident; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_NP_IDENTIFIER, &ident, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_GetIntIdentifier() wait for reply", error); return NULL; } return ident; } static NPIdentifier cached_NPN_GetIntIdentifier(int32_t intid) { NPIdentifier ident; if (!use_npidentifier_cache()) ident = invoke_NPN_GetIntIdentifier(intid); #if USE_NPIDENTIFIER_CACHE else if (!npidentifier_cache_has_int(intid, &ident)) { ident = invoke_NPN_GetIntIdentifier(intid); npidentifier_cache_reserve(1); npidentifier_cache_add_int(ident, intid); } #endif return ident; } static NPIdentifier g_NPN_GetIntIdentifier(int32_t intid) { if (!thread_check()) { npw_printf("WARNING: NPN_GetIntIdentifier not called from the main thread\n"); return NULL; } D(bugiI("NPN_GetIntIdentifier intid=%d\n", intid)); NPIdentifier ret = cached_NPN_GetIntIdentifier(intid); D(bugiD("NPN_GetIntIdentifier return: %p\n", ret)); return ret; } // Returns true if the given identifier is a string identifier, or false if it is an integer identifier static bool invoke_NPN_IdentifierIsString(NPIdentifier identifier) { npw_return_val_if_fail(rpc_method_invoke_possible(g_rpc_connection), false); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_IDENTIFIER_IS_STRING, RPC_TYPE_NP_IDENTIFIER, &identifier, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_IdentifierIsString() invoke", error); return false; } uint32_t ret; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_UINT32, &ret, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_IdentifierIsString() wait for reply", error); return false; } return ret; } static bool cached_NPN_IdentifierIsString(NPIdentifier ident) { #if USE_NPIDENTIFIER_CACHE if (use_npidentifier_cache()) { NPIdentifierInfo npi = npidentifier_cache_lookup(ident); if (npi) return npi->string_len > 0; } #endif / cache update is postponed to actual NPN_UTF8FromIdentifier() or NPN_IntFromIdentifier() / return invoke_NPN_IdentifierIsString(ident); } static bool g_NPN_IdentifierIsString(NPIdentifier identifier) { if (!thread_check()) { npw_printf("WARNING: NPN_IdentifierIsString not called from the main thread\n"); return false; } D(bugiI("NPN_IdentifierIsString identifier=%p\n", identifier)); bool ret = invoke_NPN_IdentifierIsString(identifier); D(bugiD("NPN_IdentifierIsString return: %d\n", ret)); return ret; } // Returns a pointer to a UTF-8 string as a sequence of 8-bit units (NPUTF8) static NPUTF8 invoke_NPN_UTF8FromIdentifier(NPIdentifier identifier) { npw_return_val_if_fail(rpc_method_invoke_possible(g_rpc_connection), NULL); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_UTF8_FROM_IDENTIFIER, RPC_TYPE_NP_IDENTIFIER, &identifier, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_UTF8FromIdentifier() invoke", error); return NULL; } NPUTF8 str; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_NP_UTF8, &str, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_UTF8FromIdentifier() wait for reply", error); return NULL; } return str; } static NPUTF8 cached_NPN_UTF8FromIdentifier(NPIdentifier identifier) { NPUTF8 str; if (!use_npidentifier_cache()) str = invoke_NPN_UTF8FromIdentifier(identifier); else { #if USE_NPIDENTIFIER_CACHE str = npidentifier_cache_get_string_copy(identifier); if (str == NULL) { str = invoke_NPN_UTF8FromIdentifier(identifier); npidentifier_cache_reserve(1); npidentifier_cache_add_string(identifier, str); } #endif } return str; } static NPUTF8 g_NPN_UTF8FromIdentifier(NPIdentifier identifier) { if (!thread_check()) { npw_printf("WARNING: NPN_UTF8FromIdentifier not called from the main thread\n"); return NULL; } D(bugiI("NPN_UTF8FromIdentifier identifier=%p\n", identifier)); NPUTF8 ret = cached_NPN_UTF8FromIdentifier(identifier); D(bugiD("NPN_UTF8FromIdentifier return: '%s'\n", ret)); return ret; } // Returns the integer value for the given integer identifier // NOTE: if the given identifier is not a integer identifier, the behavior is undefined (we return -1) static int32_t invoke_NPN_IntFromIdentifier(NPIdentifier identifier) { npw_return_val_if_fail(rpc_method_invoke_possible(g_rpc_connection), -1); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_INT_FROM_IDENTIFIER, RPC_TYPE_NP_IDENTIFIER, &identifier, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_IntFromIdentifier() invoke", error); return -1; } int32_t ret; error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INT32, &ret, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_IntFromIdentifier() wait for reply", error); return -1; } return ret; } static int32_t cached_NPN_IntFromIdentifier(NPIdentifier identifier) { int32_t value; if (!use_npidentifier_cache()) value = invoke_NPN_IntFromIdentifier(identifier); else { #if USE_NPIDENTIFIER_CACHE NPIdentifierInfo npi = npidentifier_cache_lookup(identifier); if (npi) { assert(npi->string_len == 0); value = npi->u.value; } else { value = invoke_NPN_IntFromIdentifier(identifier); npidentifier_cache_reserve(1); npidentifier_cache_add_int(identifier, value); } #endif } return value; } static int32_t g_NPN_IntFromIdentifier(NPIdentifier identifier) { if (!thread_check()) { npw_printf("WARNING: NPN_IntFromIdentifier not called from the main thread\n"); return 0; } D(bugiI("NPN_IntFromIdentifier identifier=%p\n", identifier)); int32_t ret = cached_NPN_IntFromIdentifier(identifier); D(bugiD("NPN_IntFromIdentifier return: %d\n", ret)); return ret; } /* ====================================================================== / / === Plug-in side data === / / ====================================================================== / // Functions supplied by the plug-in static NPPluginFuncs plugin_funcs; // Allows the browser to query the plug-in supported formats typedef char (NP_GetMIMEDescriptionUPP)(void); static NP_GetMIMEDescriptionUPP g_plugin_NP_GetMIMEDescription = NULL; // Allows the browser to query the plug-in for information typedef NPError (NP_GetValueUPP)(void instance, NPPVariable variable, void value); static NP_GetValueUPP g_plugin_NP_GetValue = NULL; // Provides global initialization for a plug-in typedef NPError (NP_InitializeUPP)(NPNetscapeFuncs moz_funcs, NPPluginFuncs plugin_funcs); static NP_InitializeUPP g_plugin_NP_Initialize = NULL; // Provides global deinitialization for a plug-in typedef NPError (NP_ShutdownUPP)(void); static NP_ShutdownUPP g_plugin_NP_Shutdown = NULL; /* ====================================================================== / / === RPC communication === / / ====================================================================== / // NP_GetMIMEDescription static char g_NP_GetMIMEDescription(void) { if (g_plugin_NP_GetMIMEDescription == NULL) return NULL; D(bugiI("NP_GetMIMEDescription\n")); char str = g_plugin_NP_GetMIMEDescription(); D(bugiD("NP_GetMIMEDescription return: %s\n", str ? str : "<empty>")); return str; } static int handle_NP_GetMIMEDescription(rpc_connection_t connection) { D(bug("handle_NP_GetMIMEDescription\n")); int error = rpc_method_get_args(connection, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NP_GetMIMEDescription() get args", error); return error; } char str = g_NP_GetMIMEDescription(); return rpc_method_send_reply(connection, RPC_TYPE_STRING, str, RPC_TYPE_INVALID); } // NP_GetValue static NPError g_NP_GetValue(NPPVariable variable, void value) { if (g_plugin_NP_GetValue == NULL) return NPERR_INVALID_FUNCTABLE_ERROR; D(bugiI("NP_GetValue variable=%d [%s]\n", variable, string_of_NPPVariable(variable))); NPError ret = g_plugin_NP_GetValue(NULL, variable, value); D(bugiD("NP_GetValue return: %d\n", ret)); return ret; } static int handle_NP_GetValue(rpc_connection_t connection) { D(bug("handle_NP_GetValue\n")); int32_t variable; int error = rpc_method_get_args(connection, RPC_TYPE_INT32, &variable, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NP_GetValue() get args", error); return error; } NPError ret = NPERR_GENERIC_ERROR; int variable_type = rpc_type_of_NPPVariable(variable); switch (variable_type) { case RPC_TYPE_STRING: { char str = NULL; ret = g_NP_GetValue(variable, (void )&str); return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_STRING, str, RPC_TYPE_INVALID); } case RPC_TYPE_INT32: { uint32_t n = 0; ret = g_NP_GetValue(variable, (void )&n); return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_INT32, n, RPC_TYPE_INVALID); } case RPC_TYPE_BOOLEAN: { NPBool b = FALSE; ret = g_NP_GetValue(variable, (void )&b); return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_BOOLEAN, b, RPC_TYPE_INVALID); } } npw_printf("ERROR: only basic types are supported in NP_GetValue()\n"); abort(); } // NP_Initialize static NPError g_NP_Initialize(uint32_t version) { if (g_plugin_NP_Initialize == NULL) return NPERR_INVALID_FUNCTABLE_ERROR; memset(&plugin_funcs, 0, sizeof(plugin_funcs)); plugin_funcs.size = sizeof(plugin_funcs); memset(&mozilla_funcs, 0, sizeof(mozilla_funcs)); mozilla_funcs.size = sizeof(mozilla_funcs); mozilla_funcs.version = version; mozilla_funcs.geturl = g_NPN_GetURL; mozilla_funcs.posturl = g_NPN_PostURL; mozilla_funcs.requestread = g_NPN_RequestRead; mozilla_funcs.newstream = g_NPN_NewStream; mozilla_funcs.write = g_NPN_Write; mozilla_funcs.destroystream = g_NPN_DestroyStream; mozilla_funcs.status = g_NPN_Status; mozilla_funcs.uagent = g_NPN_UserAgent; mozilla_funcs.memalloc = g_NPN_MemAlloc; mozilla_funcs.memfree = g_NPN_MemFree; mozilla_funcs.memflush = g_NPN_MemFlush; mozilla_funcs.reloadplugins = g_NPN_ReloadPlugins; mozilla_funcs.getJavaEnv = g_NPN_GetJavaEnv; mozilla_funcs.getJavaPeer = g_NPN_GetJavaPeer; mozilla_funcs.geturlnotify = g_NPN_GetURLNotify; mozilla_funcs.posturlnotify = g_NPN_PostURLNotify; mozilla_funcs.getvalue = g_NPN_GetValue; mozilla_funcs.setvalue = g_NPN_SetValue; mozilla_funcs.invalidaterect = g_NPN_InvalidateRect; mozilla_funcs.invalidateregion = g_NPN_InvalidateRegion; mozilla_funcs.forceredraw = g_NPN_ForceRedraw; mozilla_funcs.pushpopupsenabledstate = g_NPN_PushPopupsEnabledState; mozilla_funcs.poppopupsenabledstate = g_NPN_PopPopupsEnabledState; if (NPN_HAS_FEATURE(NPRUNTIME_SCRIPTING)) { D(bug(" browser supports scripting through npruntime\n")); mozilla_funcs.getstringidentifier = g_NPN_GetStringIdentifier; mozilla_funcs.getstringidentifiers = g_NPN_GetStringIdentifiers; mozilla_funcs.getintidentifier = g_NPN_GetIntIdentifier; mozilla_funcs.identifierisstring = g_NPN_IdentifierIsString; mozilla_funcs.utf8fromidentifier = g_NPN_UTF8FromIdentifier; mozilla_funcs.intfromidentifier = g_NPN_IntFromIdentifier; mozilla_funcs.createobject = g_NPN_CreateObject; mozilla_funcs.retainobject = g_NPN_RetainObject; mozilla_funcs.releaseobject = g_NPN_ReleaseObject; mozilla_funcs.invoke = g_NPN_Invoke; mozilla_funcs.invokeDefault = g_NPN_InvokeDefault; mozilla_funcs.evaluate = g_NPN_Evaluate; mozilla_funcs.getproperty = g_NPN_GetProperty; mozilla_funcs.setproperty = g_NPN_SetProperty; mozilla_funcs.removeproperty = g_NPN_RemoveProperty; mozilla_funcs.hasproperty = g_NPN_HasProperty; mozilla_funcs.hasmethod = g_NPN_HasMethod; mozilla_funcs.releasevariantvalue = g_NPN_ReleaseVariantValue; mozilla_funcs.setexception = g_NPN_SetException; if (!npobject_bridge_new()) return NPERR_OUT_OF_MEMORY_ERROR; } // Initialize function tables // XXX: remove the local copies from this file NPW_InitializeFuncs(&mozilla_funcs, &plugin_funcs); D(bugiI("NP_Initialize\n")); NPError ret = g_plugin_NP_Initialize(&mozilla_funcs, &plugin_funcs); D(bugiD("NP_Initialize return: %d\n", ret)); return ret; } static int handle_NP_Initialize(rpc_connection_t connection) { D(bug("handle_NP_Initialize\n")); uint32_t version; int error = rpc_method_get_args(connection, RPC_TYPE_UINT32, &version, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NP_Initialize() get args", error); return error; } NPError ret = g_NP_Initialize(version); return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_INVALID); } // NP_Shutdown static NPError g_NP_Shutdown(void) { if (g_plugin_NP_Shutdown == NULL) return NPERR_INVALID_FUNCTABLE_ERROR; D(bugiI("NP_Shutdown\n")); NPError ret = g_plugin_NP_Shutdown(); D(bugiD("NP_Shutdown done\n")); if (NPN_HAS_FEATURE(NPRUNTIME_SCRIPTING)) npobject_bridge_destroy(); gtk_main_quit(); return ret; } static int handle_NP_Shutdown(rpc_connection_t connection) { D(bug("handle_NP_Shutdown\n")); int error = rpc_method_get_args(connection, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NP_Shutdown() get args", error); return error; } / Clear any NPP_Destroys we may have delayed. Although it doesn't really matter, and the plugin is going to die soon. XXX: To be really picky, we should probably delay this and make sure it is run on a new event loop iteration. / delayed_destroys_process_cb(NULL); NPError ret = g_NP_Shutdown(); return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_INVALID); } // NPP_New static NPError g_NPP_New(NPMIMEType plugin_type, uint32_t instance_id, uint16_t mode, int16_t argc, char argn[], char argv[], NPSavedData saved) { PluginInstance plugin = npw_plugin_instance_new(&PluginInstanceClass); if (plugin == NULL) return NPERR_OUT_OF_MEMORY_ERROR; plugin->instance_id = instance_id; id_link(instance_id, plugin); NPP instance = malloc(sizeof(instance)); if (instance == NULL) return NPERR_OUT_OF_MEMORY_ERROR; memset(instance, 0, sizeof(instance)); instance->ndata = plugin; plugin->instance = instance; // check for size hints for (int i = 0; i < argc; i++) { if (argn[i] == NULL) continue; if (strcasecmp(argn[i], "width") == 0) { if (i < argc && argv[i]) plugin->width = atoi(argv[i]); } else if (strcasecmp(argn[i], "height") == 0) { if (i < argc && argv[i]) plugin->height = atoi(argv[i]); } } D(bugiI("NPP_New instance=%p\n", instance)); NPError ret = plugin_funcs.newp(plugin_type, instance, mode, argc, argn, argv, saved); D(bugiD("NPP_New return: %d [%s]\n", ret, string_of_NPError(ret))); // check if XEMBED is to be used long supports_XEmbed = FALSE; if (mozilla_funcs.getvalue) { // Even though NPAPI kindly provides an NPBool typedef, // NPNVSupportsXEmbedBool is documented to be a 4-byte PRBool. And // Flash treats it as such. NPError error = mozilla_funcs.getvalue(NULL, NPNVSupportsXEmbedBool, (void )&supports_XEmbed); if (error == NPERR_NO_ERROR && plugin_funcs.getvalue) { long needs_XEmbed = FALSE; error = plugin_funcs.getvalue(instance, NPPVpluginNeedsXEmbed, (void )&needs_XEmbed); if (error == NPERR_NO_ERROR) plugin->use_xembed = supports_XEmbed && needs_XEmbed; } } // assume Gtk plugin (no Xt event loop) if XEMBED is used if (!plugin->use_xembed) { if (xt_source_create() < 0) return NPERR_GENERIC_ERROR; } return ret; } static int handle_NPP_New(rpc_connection_t connection) { D(bug("handle_NPP_New\n")); rpc_connection_ref(connection); uint32_t instance_id; NPMIMEType plugin_type; int32_t mode; int argn_count, argv_count; char argn, argv; NPSavedData saved; int error = rpc_method_get_args(connection, RPC_TYPE_UINT32, &instance_id, RPC_TYPE_STRING, &plugin_type, RPC_TYPE_INT32, &mode, RPC_TYPE_ARRAY, RPC_TYPE_STRING, &argn_count, &argn, RPC_TYPE_ARRAY, RPC_TYPE_STRING, &argv_count, &argv, RPC_TYPE_NP_SAVED_DATA, &saved, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPP_New() get args", error); return error; } assert(argn_count == argv_count); NPError ret = g_NPP_New(plugin_type, instance_id, mode, argn_count, argn, argv, saved); if (plugin_type) free(plugin_type); if (argn) { for (int i = 0; i < argn_count; i++) free(argn[i]); free(argn); } if (argv) { for (int i = 0; i < argv_count; i++) free(argv[i]); free(argv); } if (saved) { if (saved->buf) NPN_MemFree(saved->buf); NPN_MemFree(saved); } return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_INVALID); } // NPP_Destroy static NPError g_NPP_Destroy(NPP instance, NPSavedData sdata) { if (instance == NULL) return NPERR_INVALID_INSTANCE_ERROR; PluginInstance plugin = PLUGIN_INSTANCE(instance); if (plugin == NULL) return NPERR_INVALID_INSTANCE_ERROR; if (sdata) sdata = NULL; // Process all pending calls as the data could become junk afterwards // XXX: this also processes delayed calls from other instances // XXX: Also, if this was delayed, the NPN_ReleaseObject calls will // be ignored; the browser thinks we've already died. delayed_calls_process(plugin, TRUE); D(bugiI("NPP_Destroy instance=%p\n", instance)); NPError ret = plugin_funcs.destroy(instance, sdata); D(bugiD("NPP_Destroy return: %d [%s]\n", ret, string_of_NPError(ret))); if (!plugin->use_xembed) xt_source_destroy(); npw_plugin_instance_invalidate(plugin); npw_plugin_instance_unref(plugin); return ret; } static NPError g_NPP_Destroy_Now(PluginInstance plugin, NPSavedData *save) { D(bug("g_NPP_Destroy_Now\n")); NPSavedData save_area = NULL; NPError ret = g_NPP_Destroy(PLUGIN_INSTANCE_NPP(plugin), &save_area); if (save) { save = save_area; } else if (save_area) { npw_printf("WARNING: NPP_Destroy returned save_area, but it was ignored\n"); if (save_area->buf) NPN_MemFree(save_area->buf); NPN_MemFree(save_area); } rpc_connection_unref(g_rpc_connection); return ret; } static int handle_NPP_Destroy(rpc_connection_t connection) { D(bug("handle_NPP_Destroy\n")); int error; PluginInstance plugin; error = rpc_method_get_args(connection, RPC_TYPE_NPW_PLUGIN_INSTANCE, &plugin, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPP_Destroy() get args", error); return error; } NPSavedData save_area = NULL; NPError ret = NPERR_NO_ERROR; /* Take a ref for the rpc_method_send_reply; otherwise the * rpc_connection_unref in g_NPP_Destroy_Now may cause a slight * nuisance. / rpc_connection_ref(connection); if (!rpc_method_in_invoke(connection)) { / The plugin is not on the stack; it's safe to call this. / D(bug("NPP_Destroy is fine.\n")); ret = g_NPP_Destroy_Now(plugin, &save_area); } else { / It is not safe to call NPP_Destroy right now. Delay it until we * return to the event loop. * * NOTE: This means that the browser never sees the real return * value of NPP_Destroy; the NPSavedData will be discarded, and any * error code will be ignored. / D(bug("NPP_Destroy raced; delaying it to get a clean stack.\n")); delayed_destroys_add(plugin); } error = rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_NP_SAVED_DATA, save_area, RPC_TYPE_INVALID); if (save_area) { if (save_area->buf) NPN_MemFree(save_area->buf); NPN_MemFree(save_area); } rpc_connection_unref(connection); return error; } // NPP_SetWindow static NPError g_NPP_SetWindow(NPP instance, NPWindow np_window) { if (instance == NULL) return NPERR_INVALID_INSTANCE_ERROR; PluginInstance plugin = PLUGIN_INSTANCE(instance); if (plugin == NULL) return NPERR_INVALID_INSTANCE_ERROR; if (plugin_funcs.setwindow == NULL) return NPERR_INVALID_FUNCTABLE_ERROR; plugin->is_windowless = np_window && np_window->type == NPWindowTypeDrawable; NPWindow window = np_window; if (window && (window->window \|\| plugin->is_windowless)) { if (plugin->toolkit_data) { if (update_window(plugin, window) < 0) return NPERR_GENERIC_ERROR; } else { if (create_window(plugin, window) < 0) return NPERR_GENERIC_ERROR; } window = &plugin->window; } D(bugiI("NPP_SetWindow instance=%p, window=%p\n", instance, window ? window->window : NULL)); NPError ret = plugin_funcs.setwindow(instance, window); D(bugiD("NPP_SetWindow return: %d [%s]\n", ret, string_of_NPError(ret))); if (np_window == NULL \|\| (np_window->window == NULL && !plugin->is_windowless)) destroy_window(plugin); return ret; } static int handle_NPP_SetWindow(rpc_connection_t connection) { D(bug("handle_NPP_SetWindow\n")); int error; PluginInstance plugin; NPWindow window; error = rpc_method_get_args(connection, RPC_TYPE_NPW_PLUGIN_INSTANCE, &plugin, RPC_TYPE_NP_WINDOW, &window, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPP_SetWindow() get args", error); return error; } NPError ret = g_NPP_SetWindow(PLUGIN_INSTANCE_NPP(plugin), window); if (window) { if (window->ws_info) { free(window->ws_info); window->ws_info = NULL; } free(window); } return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_INVALID); } // NPP_GetValue static NPError g_NPP_GetValue(NPP instance, NPPVariable variable, void value) { if (instance == NULL) return NPERR_INVALID_INSTANCE_ERROR; if (plugin_funcs.getvalue == NULL) return NPERR_INVALID_FUNCTABLE_ERROR; D(bugiI("NPP_GetValue instance=%p, variable=%d [%s]\n", instance, variable, string_of_NPPVariable(variable))); NPError ret = plugin_funcs.getvalue(instance, variable, value); D(bugiD("NPP_GetValue return: %d [%s]\n", ret, string_of_NPError(ret))); return ret; } static int handle_NPP_GetValue(rpc_connection_t connection) { D(bug("handle_NPP_GetValue\n")); int error; PluginInstance plugin; int32_t variable; error = rpc_method_get_args(connection, RPC_TYPE_NPW_PLUGIN_INSTANCE, &plugin, RPC_TYPE_INT32, &variable, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_printf("ERROR: could not get NPP_GetValue variable\n"); return error; } NPError ret = NPERR_GENERIC_ERROR; int variable_type = rpc_type_of_NPPVariable(variable); switch (variable_type) { case RPC_TYPE_STRING: { char str = NULL; ret = g_NPP_GetValue(PLUGIN_INSTANCE_NPP(plugin), variable, (void )&str); return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_STRING, str, RPC_TYPE_INVALID); } case RPC_TYPE_INT32: { uint32_t n = 0; ret = g_NPP_GetValue(PLUGIN_INSTANCE_NPP(plugin), variable, (void )&n); return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_INT32, n, RPC_TYPE_INVALID); } case RPC_TYPE_BOOLEAN: { NPBool b = FALSE; ret = g_NPP_GetValue(PLUGIN_INSTANCE_NPP(plugin), variable, (void )&b); return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_BOOLEAN, b, RPC_TYPE_INVALID); } case RPC_TYPE_NP_OBJECT: { NPObject npobj = NULL; ret = g_NPP_GetValue(PLUGIN_INSTANCE_NPP(plugin), variable, (void )&npobj); return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_NP_OBJECT, npobj, RPC_TYPE_INVALID); } } abort(); } // NPP_URLNotify static void g_NPP_URLNotify(NPP instance, const char url, NPReason reason, void notifyData) { if (instance == NULL) return; if (plugin_funcs.urlnotify == NULL) return; D(bugiI("NPP_URLNotify instance=%p, url='%s', reason=%s, notifyData=%p\n", instance, url, string_of_NPReason(reason), notifyData)); plugin_funcs.urlnotify(instance, url, reason, notifyData); D(bugiD("NPP_URLNotify done\n")); } static int handle_NPP_URLNotify(rpc_connection_t connection) { D(bug("handle_NPP_URLNotify\n")); int error; PluginInstance plugin; char url; int32_t reason; void notifyData; error = rpc_method_get_args(connection, RPC_TYPE_NPW_PLUGIN_INSTANCE, &plugin, RPC_TYPE_STRING, &url, RPC_TYPE_INT32, &reason, RPC_TYPE_NP_NOTIFY_DATA, &notifyData, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPP_URLNotify() get args", error); return error; } g_NPP_URLNotify(PLUGIN_INSTANCE_NPP(plugin), url, reason, notifyData); if (url) free(url); return rpc_method_send_reply (connection, RPC_TYPE_INVALID); } // NPP_NewStream static NPError g_NPP_NewStream(NPP instance, NPMIMEType type, NPStream stream, NPBool seekable, uint16_t stype) { if (instance == NULL) return NPERR_INVALID_INSTANCE_ERROR; if (plugin_funcs.newstream == NULL) return NPERR_INVALID_FUNCTABLE_ERROR; D(bugiI("NPP_NewStream instance=%p, stream=%p, url='%s', type='%s', seekable=%d, stype=%s, notifyData=%p\n", instance, stream, stream->url, type, seekable, string_of_NPStreamType(stype), stream->notifyData)); NPError ret = plugin_funcs.newstream(instance, type, stream, seekable, stype); D(bugiD("NPP_NewStream return: %d [%s], stype=%s\n", ret, string_of_NPError(ret), string_of_NPStreamType(stype))); return ret; } static int handle_NPP_NewStream(rpc_connection_t connection) { D(bug("handle_NPP_NewStream\n")); int error; PluginInstance plugin; uint32_t stream_id; uint32_t seekable; NPMIMEType type; NPStream stream; if ((stream = malloc(sizeof(stream))) == NULL) return RPC_ERROR_NO_MEMORY; memset(stream, 0, sizeof(stream)); error = rpc_method_get_args(connection, RPC_TYPE_NPW_PLUGIN_INSTANCE, &plugin, RPC_TYPE_STRING, &type, RPC_TYPE_UINT32, &stream_id, RPC_TYPE_STRING, &stream->url, RPC_TYPE_UINT32, &stream->end, RPC_TYPE_UINT32, &stream->lastmodified, RPC_TYPE_NP_NOTIFY_DATA, &stream->notifyData, RPC_TYPE_STRING, &stream->headers, RPC_TYPE_BOOLEAN, &seekable, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPP_NewStream() get args", error); return error; } StreamInstance stream_ndata; if ((stream_ndata = malloc(sizeof(stream_ndata))) == NULL) return RPC_ERROR_NO_MEMORY; stream->ndata = stream_ndata; memset(stream_ndata, 0, sizeof(stream_ndata)); stream_ndata->stream_id = stream_id; id_link(stream_id, stream_ndata); stream_ndata->stream = stream; stream_ndata->is_plugin_stream = 0; uint16_t stype = NP_NORMAL; NPError ret = g_NPP_NewStream(PLUGIN_INSTANCE_NPP(plugin), type, stream, seekable, &stype); if (type) free(type); return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_UINT32, (uint32_t)stype, RPC_TYPE_NP_NOTIFY_DATA, stream->notifyData, RPC_TYPE_INVALID); } // NPP_DestroyStream static NPError g_NPP_DestroyStream(NPP instance, NPStream stream, NPReason reason) { if (instance == NULL) return NPERR_INVALID_INSTANCE_ERROR; if (plugin_funcs.destroystream == NULL) return NPERR_INVALID_FUNCTABLE_ERROR; if (stream == NULL) return NPERR_INVALID_PARAM; D(bugiI("NPP_DestroyStream instance=%p, stream=%p, reason=%s\n", instance, stream, string_of_NPReason(reason))); NPError ret = plugin_funcs.destroystream(instance, stream, reason); D(bugiD("NPP_DestroyStream return: %d [%s]\n", ret, string_of_NPError(ret))); StreamInstance stream_ndata = stream->ndata; if (stream_ndata) { id_remove(stream_ndata->stream_id); free(stream_ndata); } free((char )stream->url); free((char )stream->headers); free(stream); return ret; } static int handle_NPP_DestroyStream(rpc_connection_t connection) { D(bug("handle_NPP_DestroyStream\n")); PluginInstance plugin; NPStream stream; int32_t reason; int error = rpc_method_get_args(connection, RPC_TYPE_NPW_PLUGIN_INSTANCE, &plugin, RPC_TYPE_NP_STREAM, &stream, RPC_TYPE_INT32, &reason, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPP_DestroyStream() get args", error); return error; } NPError ret = g_NPP_DestroyStream(PLUGIN_INSTANCE_NPP(plugin), stream, reason); return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_INVALID); } // NPP_WriteReady static int32_t g_NPP_WriteReady(NPP instance, NPStream stream) { if (instance == NULL) return 0; if (plugin_funcs.writeready == NULL) return 0; if (stream == NULL) return 0; D(bugiI("NPP_WriteReady instance=%p, stream=%p\n", instance, stream)); int32_t ret = plugin_funcs.writeready(instance, stream); D(bugiD("NPP_WriteReady return: %d\n", ret)); return ret; } static int handle_NPP_WriteReady(rpc_connection_t connection) { D(bug("handle_NPP_WriteReady\n")); PluginInstance plugin; NPStream stream; int error = rpc_method_get_args(connection, RPC_TYPE_NPW_PLUGIN_INSTANCE, &plugin, RPC_TYPE_NP_STREAM, &stream, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPP_WriteReady() get args", error); return error; } int32_t ret = g_NPP_WriteReady(PLUGIN_INSTANCE_NPP(plugin), stream); return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_INVALID); } // NPP_Write static int32_t g_NPP_Write(NPP instance, NPStream stream, int32_t offset, int32_t len, void buf) { if (instance == NULL) return -1; if (plugin_funcs.write == NULL) return -1; if (stream == NULL) return -1; D(bugiI("NPP_Write instance=%p, stream=%p, offset=%d, len=%d, buf=%p\n", instance, stream, offset, len, buf)); int32_t ret = plugin_funcs.write(instance, stream, offset, len, buf); D(bugiD("NPP_Write return: %d\n", ret)); return ret; } static int handle_NPP_Write(rpc_connection_t connection) { D(bug("handle_NPP_Write\n")); PluginInstance plugin; NPStream stream; unsigned char buf; int32_t offset, len; int error = rpc_method_get_args(connection, RPC_TYPE_NPW_PLUGIN_INSTANCE, &plugin, RPC_TYPE_NP_STREAM, &stream, RPC_TYPE_INT32, &offset, RPC_TYPE_ARRAY, RPC_TYPE_CHAR, &len, &buf, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPP_Write() get args", error); return error; } int32_t ret = g_NPP_Write(PLUGIN_INSTANCE_NPP(plugin), stream, offset, len, buf); if (buf) free(buf); return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_INVALID); } // NPP_StreamAsFile static void g_NPP_StreamAsFile(NPP instance, NPStream stream, const char fname) { if (instance == NULL) return; if (plugin_funcs.asfile == NULL) return; if (stream == NULL) return; D(bugiI("NPP_StreamAsFile instance=%p, stream=%p, fname='%s'\n", instance, stream, fname)); plugin_funcs.asfile(instance, stream, fname); D(bugiD("NPP_StreamAsFile done\n")); } static int handle_NPP_StreamAsFile(rpc_connection_t connection) { D(bug("handle_NPP_StreamAsFile\n")); PluginInstance plugin; NPStream stream; char fname; int error = rpc_method_get_args(connection, RPC_TYPE_NPW_PLUGIN_INSTANCE, &plugin, RPC_TYPE_NP_STREAM, &stream, RPC_TYPE_STRING, &fname, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPP_StreamAsFile() get args", error); return error; } g_NPP_StreamAsFile(PLUGIN_INSTANCE_NPP(plugin), stream, fname); if (fname) free(fname); return rpc_method_send_reply (connection, RPC_TYPE_INVALID); } // NPP_Print static void g_NPP_Print(NPP instance, NPPrint printInfo) { if (plugin_funcs.print == NULL) return; if (printInfo == NULL) return; D(bugiI("NPP_Print instance=%p, printInfo->mode=%d\n", instance, printInfo->mode)); plugin_funcs.print(instance, printInfo); D(bugiD("NPP_Print done\n")); } static void invoke_NPN_PrintData(PluginInstance plugin, uint32_t platform_print_id, NPPrintData printData) { if (printData == NULL) return; npw_return_if_fail(rpc_method_invoke_possible(g_rpc_connection)); int error = rpc_method_invoke(g_rpc_connection, RPC_METHOD_NPN_PRINT_DATA, RPC_TYPE_UINT32, platform_print_id, RPC_TYPE_NP_PRINT_DATA, printData, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_PrintData() invoke", error); return; } error = rpc_method_wait_for_reply(g_rpc_connection, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPN_PrintData() wait for reply", error); return; } } static int handle_NPP_Print(rpc_connection_t connection) { D(bug("handle_NPP_Print\n")); PluginInstance plugin; NPPrint printInfo; uint32_t platform_print_id; int error = rpc_method_get_args(connection, RPC_TYPE_NPW_PLUGIN_INSTANCE, &plugin, RPC_TYPE_UINT32, &platform_print_id, RPC_TYPE_NP_PRINT, &printInfo, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPP_Print() get args", error); return error; } // reconstruct printer info NPPrintCallbackStruct printer; printer.type = NP_PRINT; printer.fp = platform_print_id ? tmpfile() : NULL; switch (printInfo.mode) { case NP_FULL: printInfo.print.fullPrint.platformPrint = &printer; break; case NP_EMBED: printInfo.print.embedPrint.platformPrint = &printer; // XXX the window ID is unlikely to work here as is. The NPWindow // is probably only used as a bounding box? create_window_attributes(printInfo.print.embedPrint.window.ws_info); break; } g_NPP_Print(PLUGIN_INSTANCE_NPP(plugin), &printInfo); // send back the printed data if (printer.fp) { long file_size = ftell(printer.fp); D(bug(" writeback data [%d bytes]\n", file_size)); rewind(printer.fp); if (file_size > 0) { NPPrintData printData; const int printDataMaxSize = sizeof(printData.data); int n = file_size / printDataMaxSize; while (--n >= 0) { printData.size = printDataMaxSize; if (fread(&printData.data, sizeof(printData.data), 1, printer.fp) != 1) { npw_printf("ERROR: unexpected end-of-file or error condition in NPP_Print\n"); break; } npw_plugin_instance_ref(plugin); invoke_NPN_PrintData(plugin, platform_print_id, &printData); npw_plugin_instance_unref(plugin); } printData.size = file_size % printDataMaxSize; if (fread(&printData.data, printData.size, 1, printer.fp) != 1) npw_printf("ERROR: unexpected end-of-file or error condition in NPP_Print\n"); npw_plugin_instance_ref(plugin); invoke_NPN_PrintData(plugin, platform_print_id, &printData); npw_plugin_instance_unref(plugin); } fclose(printer.fp); } if (printInfo.mode == NP_EMBED) { NPWindow window = &printInfo.print.embedPrint.window; if (window->ws_info) { destroy_window_attributes(window->ws_info); window->ws_info = NULL; } } uint32_t plugin_printed = FALSE; if (printInfo.mode == NP_FULL) plugin_printed = printInfo.print.fullPrint.pluginPrinted; return rpc_method_send_reply(connection, RPC_TYPE_BOOLEAN, plugin_printed, RPC_TYPE_INVALID); } // Delivers a platform-specific window event to the instance static int16_t g_NPP_HandleEvent(NPP instance, NPEvent event) { if (instance == NULL) return false; if (plugin_funcs.event == NULL) return false; if (event == NULL) return false; D(bugiI("NPP_HandleEvent instance=%p, event=%p [%s]\n", instance, event, string_of_NPEvent_type(event->type))); int16_t ret = plugin_funcs.event(instance, event); D(bugiD("NPP_HandleEvent return: %d\n", ret)); /* XXX: let's have a chance to commit the pixmap before it's gone / if (event->type == GraphicsExpose) gdk_flush(); return ret; } static int handle_NPP_HandleEvent(rpc_connection_t connection) { D(bug("handle_NPP_HandleEvent\n")); PluginInstance plugin; NPEvent event; int error = rpc_method_get_args(connection, RPC_TYPE_NPW_PLUGIN_INSTANCE, &plugin, RPC_TYPE_NP_EVENT, &event, RPC_TYPE_INVALID); if (error != RPC_ERROR_NO_ERROR) { npw_perror("NPP_HandleEvent() get args", error); return error; } event.xany.display = x_display; int16_t ret = g_NPP_HandleEvent(PLUGIN_INSTANCE_NPP(plugin), &event); return rpc_method_send_reply(connection, RPC_TYPE_INT32, ret, RPC_TYPE_INVALID); } / ====================================================================== / / === Events processing === / / ====================================================================== / typedef gboolean (GSourcePrepare)(GSource , gint ); typedef gboolean (GSourceCheckFunc)(GSource ); typedef gboolean (GSourceDispatchFunc)(GSource , GSourceFunc, gpointer); typedef void (GSourceFinalizeFunc)(GSource ); // Xt events static GSource xt_source = NULL; static int xt_source_count = 0; static GPollFD xt_event_poll_fd; static const int XT_DEFAULT_TIMEOUT = 25; static const int XT_MAX_DISPATCH_EVENTS = 10; static void xt_dummy_timeout_cb(XtPointer closure, XtIntervalId id) { /* dummy function, never called / npw_printf("ERROR: xt_dummy_timeout_cb() should never be called\n"); } static int xt_has_compatible_appcontext_timerQueue(void) { int is_compatible; XtIntervalId id; TimerEventRec tq, tq_probe; / Try to determine where is the pointer to the next allocated TimerEventRec. Besides, XtAppAddTimeOut() shall not have been called already because we want to be sure any (libXt internal) "free" TimerEventRec pointer cache is empty. / tq = XtNew(TimerEventRec); XtFree((char )tq); tq_probe = XtNew(TimerEventRec); XtFree((char )tq_probe); if (tq != tq_probe) return 0; id = XtAppAddTimeOut(x_app_context, 0, xt_dummy_timeout_cb, GUINT_TO_POINTER(0xdeadbeef)); tq = x_app_context->timerQueue; is_compatible = tq == tq_probe && tq->app == x_app_context && tq->te_proc == xt_dummy_timeout_cb && tq->te_closure == GUINT_TO_POINTER(0xdeadbeef) ; XtRemoveTimeOut(id); return is_compatible; } static void xt_dummy_input_cb(XtPointer closure, int source, XtInputId id) { / dummy function, never called / npw_printf("ERROR: xt_dummy_input_cb() should never be called\n"); } static inline int get_appcontext_input_count_at(int offset) { return ((short )((char )x_app_context + offset)); } static inline int add_appcontext_input(int fd, int n) { return XtAppAddInput(x_app_context, fd, GUINT_TO_POINTER(XtInputWriteMask), xt_dummy_input_cb, GUINT_TO_POINTER(0xdead0000)); } static int get_appcontext_input_count_offset(void) { #define low_offset offsetof(struct _XtAppStruct, __maxed__nfds) #define high_offset offsetof(struct _XtAppStruct, __maybe__input_max) #define n_offsets_max (high_offset - low_offset)/2 int i, ofs, n_offsets = 0; int offsets[n_offsets_max] = { 0, }; #define n_inputs_max 4 /* number of refinements/input sources / int fd, id, n_inputs = 0; struct { int fd, id; } inputs[n_inputs_max] = { 0, }; if ((fd = open("/dev/null", O_WRONLY)) < 0) return 0; if ((id = add_appcontext_input(fd, 0)) < 0) { close(fd); return 0; } inputs[n_inputs].fd = fd; inputs[n_inputs].id = id; n_inputs++; for (ofs = low_offset; ofs < high_offset; ofs += 2) { if (get_appcontext_input_count_at(ofs) == 1) offsets[n_offsets++] = ofs; } while (n_inputs < n_inputs_max) { if ((fd = open("/dev/null", O_WRONLY)) < 0) break; if ((id = add_appcontext_input(fd, n_inputs)) < 0) { close(fd); break; } inputs[n_inputs].fd = fd; inputs[n_inputs].id = id; n_inputs++; int n = 0; for (i = 0; i < n_offsets; i++) { if (get_appcontext_input_count_at(offsets[i]) == n_inputs) offsets[n++] = offsets[i]; } for (i = n; i < n_offsets; i++) offsets[i] = 0; n_offsets = n; } for (i = 0; i < n_inputs; i++) { XtRemoveInput(inputs[i].id); close(inputs[i].fd); } if (n_offsets == 1) return offsets[0]; #undef n_fds_max #undef n_offsets_max #undef high_offset #undef low_offset return 0; } static int get_appcontext_input_count(void) { static int input_count_offset = -1; if (input_count_offset < 0) input_count_offset = get_appcontext_input_count_offset(); if (input_count_offset == 0) return 1; / fake we have input to trigger timeout / return get_appcontext_input_count_at(input_count_offset); } static int xt_has_compatible_appcontext(void) { return xt_has_compatible_appcontext_timerQueue(); } static int xt_get_next_timeout(GSource source) { static int has_compatible_appcontext = -1; if (has_compatible_appcontext < 0) { if ((has_compatible_appcontext = xt_has_compatible_appcontext()) == 0) npw_printf("WARNING: xt_get_next_timeout() is not optimizable\n"); } int timeout = XT_DEFAULT_TIMEOUT; if (has_compatible_appcontext) { int input_timeout, timer_timeout; /* Check there is any input source to process / if (get_appcontext_input_count() > 0) input_timeout = XT_DEFAULT_TIMEOUT; else input_timeout = -1; / Check there is any timer to process / if (x_app_context->timerQueue == NULL) timer_timeout = -1; else { / Determine delay to next timeout. Zero means timeout already expired / struct timeval next = &x_app_context->timerQueue->te_timer_value; GTimeVal now; int64_t diff; g_source_get_current_time(source, &now); if ((diff = (int64_t)next->tv_sec - (int64_t)now.tv_sec) < 0) timer_timeout = 0; else if ((diff = diff1000 + ((int64_t)next->tv_usec - (int64_t)now.tv_usec)/1000) <= 0) timer_timeout = 0; else timer_timeout = diff; } if (input_timeout < 0) timeout = timer_timeout; else if (timer_timeout < 0) timeout = input_timeout; else timeout = MIN(input_timeout, timer_timeout); } return timeout; } static gboolean xt_event_prepare(GSource source, gint timeout) { int mask = XtAppPending(x_app_context); if (mask) return TRUE; / XXX: create new GPollFD for input sources? / return (timeout = xt_get_next_timeout(source)) == 0; } static gboolean xt_event_check(GSource source) { if (xt_event_poll_fd.revents & G_IO_IN) { int mask = XtAppPending(x_app_context); if (mask) return TRUE; } return FALSE; } static gboolean xt_event_dispatch(GSource source, GSourceFunc callback, gpointer user_data) { int i; for (i = 0; i < XT_MAX_DISPATCH_EVENTS; i++) { int mask = XtAppPending(x_app_context); if (mask == 0) break; XtAppProcessEvent(x_app_context, XtIMAll); } return TRUE; } static GSourceFuncs xt_event_funcs = { xt_event_prepare, xt_event_check, xt_event_dispatch, (GSourceFinalizeFunc)g_free, (GSourceFunc)NULL, (GSourceDummyMarshal)NULL }; static int xt_source_create(void) { if (++xt_source_count > 1 && xt_source != NULL) return 0; if ((xt_source = g_source_new(&xt_event_funcs, sizeof(GSource))) == NULL) { npw_printf("ERROR: failed to initialize Xt events listener\n"); return -1; } g_source_set_priority(xt_source, GDK_PRIORITY_EVENTS); g_source_set_can_recurse(xt_source, TRUE); g_source_attach(xt_source, NULL); xt_event_poll_fd.fd = ConnectionNumber(x_display); xt_event_poll_fd.events = G_IO_IN; xt_event_poll_fd.revents = 0; g_source_add_poll(xt_source, &xt_event_poll_fd); return 0; } static void xt_source_destroy(void) { if (--xt_source_count < 1 && xt_source) { g_source_destroy(xt_source); xt_source = NULL; } } // RPC events static GPollFD rpc_event_poll_fd; static gboolean rpc_event_prepare(GSource source, gint timeout) { timeout = -1; return FALSE; } static gboolean rpc_event_check(GSource source) { return rpc_wait_dispatch(g_rpc_connection, 0) > 0; } static gboolean rpc_event_dispatch(GSource source, GSourceFunc callback, gpointer connection) { return rpc_dispatch(connection) != RPC_ERROR_CONNECTION_CLOSED; } static GSourceFuncs rpc_event_funcs = { rpc_event_prepare, rpc_event_check, rpc_event_dispatch, (GSourceFinalizeFunc)g_free, (GSourceFunc)NULL, (GSourceDummyMarshal)NULL }; // RPC error callback -- kill the plugin static void rpc_error_callback_cb(rpc_connection_t connection, void user_data) { D(bug("RPC connection %p is in a bad state, closing the plugin\n",connection)); rpc_connection_set_error_callback(connection, NULL, NULL); gtk_main_quit(); } / ====================================================================== / / === Main program === / / ====================================================================== / static int do_test(void); static int do_main(int argc, char argv, const char connection_path) { if (do_test() != 0) return 1; if (connection_path == NULL) { npw_printf("ERROR: missing connection path argument\n"); return 1; } D(bug(" Plugin connection: %s\n", connection_path)); D(bug(" Plugin viewer pid: %d\n", getpid())); thread_check_init(); D(bug(" Plugin main thread: %p\n", g_main_thread)); // Cleanup environment, the program may fork/exec a native shell // script and having 32-bit libraries in LD_PRELOAD is not right, // though not a fatal error #if defined(__linux__) if (getenv("LD_PRELOAD")) unsetenv("LD_PRELOAD"); #endif // Xt and GTK initialization XtToolkitInitialize(); x_app_context = XtCreateApplicationContext(); x_display = XtOpenDisplay(x_app_context, NULL, "npw-viewer", "npw-viewer", NULL, 0, &argc, argv); g_thread_init(NULL); gtk_init(&argc, &argv); // Initialize RPC communication channel if ((g_rpc_connection = rpc_init_server(connection_path)) == NULL) { npw_printf("ERROR: failed to initialize plugin-side RPC server connection\n"); return 1; } if (rpc_add_np_marshalers(g_rpc_connection) < 0) { npw_printf("ERROR: failed to initialize plugin-side marshalers\n"); return 1; } static const rpc_method_descriptor_t vtable[] = { { RPC_METHOD_NP_GET_MIME_DESCRIPTION, handle_NP_GetMIMEDescription }, { RPC_METHOD_NP_GET_VALUE, handle_NP_GetValue }, { RPC_METHOD_NP_INITIALIZE, handle_NP_Initialize }, { RPC_METHOD_NP_SHUTDOWN, handle_NP_Shutdown }, { RPC_METHOD_NPP_NEW, handle_NPP_New }, { RPC_METHOD_NPP_DESTROY, handle_NPP_Destroy }, { RPC_METHOD_NPP_GET_VALUE, handle_NPP_GetValue }, { RPC_METHOD_NPP_SET_WINDOW, handle_NPP_SetWindow }, { RPC_METHOD_NPP_URL_NOTIFY, handle_NPP_URLNotify }, { RPC_METHOD_NPP_NEW_STREAM, handle_NPP_NewStream }, { RPC_METHOD_NPP_DESTROY_STREAM, handle_NPP_DestroyStream }, { RPC_METHOD_NPP_WRITE_READY, handle_NPP_WriteReady }, { RPC_METHOD_NPP_WRITE, handle_NPP_Write }, { RPC_METHOD_NPP_STREAM_AS_FILE, handle_NPP_StreamAsFile }, { RPC_METHOD_NPP_PRINT, handle_NPP_Print }, { RPC_METHOD_NPP_HANDLE_EVENT, handle_NPP_HandleEvent }, { RPC_METHOD_NPCLASS_INVALIDATE, npclass_handle_Invalidate }, { RPC_METHOD_NPCLASS_HAS_METHOD, npclass_handle_HasMethod }, { RPC_METHOD_NPCLASS_INVOKE, npclass_handle_Invoke }, { RPC_METHOD_NPCLASS_INVOKE_DEFAULT, npclass_handle_InvokeDefault }, { RPC_METHOD_NPCLASS_HAS_PROPERTY, npclass_handle_HasProperty }, { RPC_METHOD_NPCLASS_GET_PROPERTY, npclass_handle_GetProperty }, { RPC_METHOD_NPCLASS_SET_PROPERTY, npclass_handle_SetProperty }, { RPC_METHOD_NPCLASS_REMOVE_PROPERTY, npclass_handle_RemoveProperty }, }; if (rpc_connection_add_method_descriptors(g_rpc_connection, vtable, sizeof(vtable) / sizeof(vtable[0])) < 0) { npw_printf("ERROR: failed to setup NPP method callbacks\n"); return 1; } id_init(); // Initialize RPC events listener GSource rpc_source = g_source_new(&rpc_event_funcs, sizeof(GSource)); if (rpc_source == NULL) { npw_printf("ERROR: failed to initialize plugin-side RPC events listener\n"); return 1; } g_source_set_priority(rpc_source, G_PRIORITY_LOW); g_source_attach(rpc_source, NULL); rpc_event_poll_fd.fd = rpc_listen_socket(g_rpc_connection); rpc_event_poll_fd.events = G_IO_IN; rpc_event_poll_fd.revents = 0; g_source_set_callback(rpc_source, (GSourceFunc)rpc_dispatch, g_rpc_connection, NULL); g_source_add_poll(rpc_source, &rpc_event_poll_fd); // Set error handler - stop plugin if there's a connection error rpc_connection_set_error_callback(g_rpc_connection, rpc_error_callback_cb, NULL); gtk_main(); D(bug("--- EXIT ---\n")); #if USE_NPIDENTIFIER_CACHE npidentifier_cache_destroy(); #endif g_source_destroy(rpc_source); if (xt_source) g_source_destroy(xt_source); if (g_user_agent) free(g_user_agent); if (g_rpc_connection) rpc_connection_unref(g_rpc_connection); id_kill(); return 0; } // Flash Player 9 beta 1 is not stable enough and will generally // freeze on NP_Shutdown when multiple Flash movies are active static int is_flash_player9_beta1(void) { const char plugin_desc = NULL; if (g_NP_GetValue(NPPVpluginDescriptionString, &plugin_desc) == NPERR_NO_ERROR && plugin_desc && strcmp(plugin_desc, "Shockwave Flash 9.0 d55") == 0) { npw_printf("WARNING: Flash Player 9 beta 1 detected and rejected\n"); return 1; } return 0; } static int do_test(void) { if (g_plugin_NP_GetMIMEDescription == NULL) return 1; if (g_plugin_NP_Initialize == NULL) return 2; if (g_plugin_NP_Shutdown == NULL) return 3; if (is_flash_player9_beta1()) return 4; return 0; } static int do_info(void) { if (do_test() != 0) return 1; const char plugin_name = NULL; if (g_NP_GetValue(NPPVpluginNameString, &plugin_name) == NPERR_NO_ERROR && plugin_name) printf("PLUGIN_NAME %zd\n%s\n", strlen(plugin_name), plugin_name); const char plugin_desc = NULL; if (g_NP_GetValue(NPPVpluginDescriptionString, &plugin_desc) == NPERR_NO_ERROR && plugin_desc) printf("PLUGIN_DESC %zd\n%s\n", strlen(plugin_desc), plugin_desc); const char mime_info = g_NP_GetMIMEDescription(); if (mime_info) printf("PLUGIN_MIME %zd\n%s\n", strlen(mime_info), mime_info); return 0; } static int do_help(const char prog) { printf("%s, NPAPI plugin viewer. Version %s\n", NPW_VIEWER, NPW_VERSION); printf("\n"); printf("usage: %s [GTK flags] [flags]\n", prog); printf(" -h --help print this message\n"); printf(" -t --test check plugin is compatible\n"); printf(" -i --info print plugin information\n"); printf(" -p --plugin set plugin path\n"); printf(" -c --connection set connection path\n"); return 0; } int main(int argc, char *argv) { const char plugin_path = NULL; const char connection_path = NULL; enum { CMD_RUN, CMD_TEST, CMD_INFO, CMD_HELP }; int cmd = CMD_RUN; // Parse command line arguments for (int i = 0; i < argc; i++) { const char arg = argv[i]; if (strcmp(arg, "-h") == 0 \|\| strcmp(arg, "--help") == 0) { argv[i] = NULL; cmd = CMD_HELP; } else if (strcmp(arg, "-t") == 0 \|\| strcmp(arg, "--test") == 0) { argv[i] = NULL; cmd = CMD_TEST; } else if (strcmp(arg, "-i") == 0 \|\| strcmp(arg, "--info") == 0) { argv[i] = NULL; cmd = CMD_INFO; } else if (strcmp(arg, "-p") == 0 \|\| strcmp(arg, "--plugin") == 0) { argv[i] = NULL; if (++i < argc) { plugin_path = argv[i]; argv[i] = NULL; } } else if (strcmp(arg, "-c") == 0 \|\| strcmp(arg, "--connection") == 0) { argv[i] = NULL; if (++i < argc) { connection_path = argv[i]; argv[i] = NULL; } } } // Remove processed arguments for (int i = 1, j = 1, n = argc; i < n; i++) { if (argv[i]) argv[j++] = argv[i]; else --argc; } // Open plug-in and get exported lib functions void handles[10] = { NULL, }; int n_handles = 0; if (plugin_path == NULL) cmd = CMD_HELP; else { void handle; const char error; #if defined(__sun) / XXX: check for Flash Player only? / const char SunStudio_libCrun[] = "libCrun.so.1"; D(bug(" trying to open SunStudio C++ runtime '%s'\n", SunStudio_libCrun)); if ((handle = dlopen(SunStudio_libCrun, RTLD_LAZY\|RTLD_GLOBAL)) == NULL) { npw_printf("ERROR: %s\n", dlerror()); return 1; } handles[n_handles++] = handle; dlerror(); #endif D(bug(" %s\n", plugin_path)); if ((handle = dlopen(plugin_path, RTLD_LAZY)) == NULL) { npw_printf("ERROR: %s\n", dlerror()); return 1; } handles[n_handles++] = handle; dlerror(); g_plugin_NP_GetMIMEDescription = (NP_GetMIMEDescriptionUPP)dlsym(handle, "NP_GetMIMEDescription"); if ((error = dlerror()) != NULL) { npw_printf("ERROR: %s\n", error); return 1; } g_plugin_NP_Initialize = (NP_InitializeUPP)dlsym(handle, "NP_Initialize"); if ((error = dlerror()) != NULL) { npw_printf("ERROR: %s\n", error); return 1; } g_plugin_NP_Shutdown = (NP_ShutdownUPP)dlsym(handle, "NP_Shutdown"); if ((error = dlerror()) != NULL) { npw_printf("ERROR: %s\n", error); return 1; } g_plugin_NP_GetValue = (NP_GetValueUPP)dlsym(handle, "NP_GetValue"); } int ret = 1; switch (cmd) { case CMD_RUN: ret = do_main(argc, argv, connection_path); break; case CMD_TEST: ret = do_test(); break; case CMD_INFO: ret = do_info(); break; case CMD_HELP: ret = do_help(argv[0]); break; } while (--n_handles >= 0) { void const handle = handles[n_handles]; if (handle) dlclose(handle); } return ret; }	./CrossVul/dataset_final_sorted/CWE-264/c/bad_3470_1
crossvul-cpp_data_bad_920_0	404: Not Found	./CrossVul/dataset_final_sorted/CWE-264/c/bad_920_0
crossvul-cpp_data_bad_1795_0	/* * * Copyright (C) 2011 Novell Inc. * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 as published by * the Free Software Foundation. / #include <linux/fs.h> #include <linux/slab.h> #include <linux/xattr.h> #include "overlayfs.h" static int ovl_copy_up_last(struct dentry dentry, struct iattr attr, bool no_data) { int err; struct dentry parent; struct kstat stat; struct path lowerpath; parent = dget_parent(dentry); err = ovl_copy_up(parent); if (err) goto out_dput_parent; ovl_path_lower(dentry, &lowerpath); err = vfs_getattr(&lowerpath, &stat); if (err) goto out_dput_parent; if (no_data) stat.size = 0; err = ovl_copy_up_one(parent, dentry, &lowerpath, &stat, attr); out_dput_parent: dput(parent); return err; } int ovl_setattr(struct dentry dentry, struct iattr attr) { int err; struct dentry upperdentry; err = ovl_want_write(dentry); if (err) goto out; upperdentry = ovl_dentry_upper(dentry); if (upperdentry) { mutex_lock(&upperdentry->d_inode->i_mutex); err = notify_change(upperdentry, attr, NULL); mutex_unlock(&upperdentry->d_inode->i_mutex); } else { err = ovl_copy_up_last(dentry, attr, false); } ovl_drop_write(dentry); out: return err; } static int ovl_getattr(struct vfsmount mnt, struct dentry dentry, struct kstat stat) { struct path realpath; ovl_path_real(dentry, &realpath); return vfs_getattr(&realpath, stat); } int ovl_permission(struct inode inode, int mask) { struct ovl_entry oe; struct dentry alias = NULL; struct inode realinode; struct dentry realdentry; bool is_upper; int err; if (S_ISDIR(inode->i_mode)) { oe = inode->i_private; } else if (mask & MAY_NOT_BLOCK) { return -ECHILD; } else { / * For non-directories find an alias and get the info * from there. / alias = d_find_any_alias(inode); if (WARN_ON(!alias)) return -ENOENT; oe = alias->d_fsdata; } realdentry = ovl_entry_real(oe, &is_upper); / Careful in RCU walk mode / realinode = ACCESS_ONCE(realdentry->d_inode); if (!realinode) { WARN_ON(!(mask & MAY_NOT_BLOCK)); err = -ENOENT; goto out_dput; } if (mask & MAY_WRITE) { umode_t mode = realinode->i_mode; / * Writes will always be redirected to upper layer, so * ignore lower layer being read-only. * * If the overlay itself is read-only then proceed * with the permission check, don't return EROFS. * This will only happen if this is the lower layer of * another overlayfs. * * If upper fs becomes read-only after the overlay was * constructed return EROFS to prevent modification of * upper layer. / err = -EROFS; if (is_upper && !IS_RDONLY(inode) && IS_RDONLY(realinode) && (S_ISREG(mode) \|\| S_ISDIR(mode) \|\| S_ISLNK(mode))) goto out_dput; } err = __inode_permission(realinode, mask); out_dput: dput(alias); return err; } struct ovl_link_data { struct dentry realdentry; void cookie; }; static const char ovl_follow_link(struct dentry dentry, void cookie) { struct dentry realdentry; struct inode realinode; struct ovl_link_data data = NULL; const char ret; realdentry = ovl_dentry_real(dentry); realinode = realdentry->d_inode; if (WARN_ON(!realinode->i_op->follow_link)) return ERR_PTR(-EPERM); if (realinode->i_op->put_link) { data = kmalloc(sizeof(struct ovl_link_data), GFP_KERNEL); if (!data) return ERR_PTR(-ENOMEM); data->realdentry = realdentry; } ret = realinode->i_op->follow_link(realdentry, cookie); if (IS_ERR_OR_NULL(ret)) { kfree(data); return ret; } if (data) data->cookie = cookie; cookie = data; return ret; } static void ovl_put_link(struct inode unused, void c) { struct inode realinode; struct ovl_link_data data = c; if (!data) return; realinode = data->realdentry->d_inode; realinode->i_op->put_link(realinode, data->cookie); kfree(data); } static int ovl_readlink(struct dentry dentry, char __user buf, int bufsiz) { struct path realpath; struct inode realinode; ovl_path_real(dentry, &realpath); realinode = realpath.dentry->d_inode; if (!realinode->i_op->readlink) return -EINVAL; touch_atime(&realpath); return realinode->i_op->readlink(realpath.dentry, buf, bufsiz); } static bool ovl_is_private_xattr(const char name) { return strncmp(name, OVL_XATTR_PRE_NAME, OVL_XATTR_PRE_LEN) == 0; } int ovl_setxattr(struct dentry dentry, const char name, const void value, size_t size, int flags) { int err; struct dentry upperdentry; err = ovl_want_write(dentry); if (err) goto out; err = -EPERM; if (ovl_is_private_xattr(name)) goto out_drop_write; err = ovl_copy_up(dentry); if (err) goto out_drop_write; upperdentry = ovl_dentry_upper(dentry); err = vfs_setxattr(upperdentry, name, value, size, flags); out_drop_write: ovl_drop_write(dentry); out: return err; } static bool ovl_need_xattr_filter(struct dentry dentry, enum ovl_path_type type) { if ((type & (__OVL_PATH_PURE \| __OVL_PATH_UPPER)) == __OVL_PATH_UPPER) return S_ISDIR(dentry->d_inode->i_mode); else return false; } ssize_t ovl_getxattr(struct dentry dentry, const char name, void value, size_t size) { struct path realpath; enum ovl_path_type type = ovl_path_real(dentry, &realpath); if (ovl_need_xattr_filter(dentry, type) && ovl_is_private_xattr(name)) return -ENODATA; return vfs_getxattr(realpath.dentry, name, value, size); } ssize_t ovl_listxattr(struct dentry dentry, char list, size_t size) { struct path realpath; enum ovl_path_type type = ovl_path_real(dentry, &realpath); ssize_t res; int off; res = vfs_listxattr(realpath.dentry, list, size); if (res <= 0 \|\| size == 0) return res; if (!ovl_need_xattr_filter(dentry, type)) return res; / filter out private xattrs / for (off = 0; off < res;) { char s = list + off; size_t slen = strlen(s) + 1; BUG_ON(off + slen > res); if (ovl_is_private_xattr(s)) { res -= slen; memmove(s, s + slen, res - off); } else { off += slen; } } return res; } int ovl_removexattr(struct dentry dentry, const char name) { int err; struct path realpath; enum ovl_path_type type = ovl_path_real(dentry, &realpath); err = ovl_want_write(dentry); if (err) goto out; err = -ENODATA; if (ovl_need_xattr_filter(dentry, type) && ovl_is_private_xattr(name)) goto out_drop_write; if (!OVL_TYPE_UPPER(type)) { err = vfs_getxattr(realpath.dentry, name, NULL, 0); if (err < 0) goto out_drop_write; err = ovl_copy_up(dentry); if (err) goto out_drop_write; ovl_path_upper(dentry, &realpath); } err = vfs_removexattr(realpath.dentry, name); out_drop_write: ovl_drop_write(dentry); out: return err; } static bool ovl_open_need_copy_up(int flags, enum ovl_path_type type, struct dentry realdentry) { if (OVL_TYPE_UPPER(type)) return false; if (special_file(realdentry->d_inode->i_mode)) return false; if (!(OPEN_FMODE(flags) & FMODE_WRITE) && !(flags & O_TRUNC)) return false; return true; } struct inode ovl_d_select_inode(struct dentry dentry, unsigned file_flags) { int err; struct path realpath; enum ovl_path_type type; if (d_is_dir(dentry)) return d_backing_inode(dentry); type = ovl_path_real(dentry, &realpath); if (ovl_open_need_copy_up(file_flags, type, realpath.dentry)) { err = ovl_want_write(dentry); if (err) return ERR_PTR(err); if (file_flags & O_TRUNC) err = ovl_copy_up_last(dentry, NULL, true); else err = ovl_copy_up(dentry); ovl_drop_write(dentry); if (err) return ERR_PTR(err); ovl_path_upper(dentry, &realpath); } if (realpath.dentry->d_flags & DCACHE_OP_SELECT_INODE) return realpath.dentry->d_op->d_select_inode(realpath.dentry, file_flags); return d_backing_inode(realpath.dentry); } static const struct inode_operations ovl_file_inode_operations = { .setattr = ovl_setattr, .permission = ovl_permission, .getattr = ovl_getattr, .setxattr = ovl_setxattr, .getxattr = ovl_getxattr, .listxattr = ovl_listxattr, .removexattr = ovl_removexattr, }; static const struct inode_operations ovl_symlink_inode_operations = { .setattr = ovl_setattr, .follow_link = ovl_follow_link, .put_link = ovl_put_link, .readlink = ovl_readlink, .getattr = ovl_getattr, .setxattr = ovl_setxattr, .getxattr = ovl_getxattr, .listxattr = ovl_listxattr, .removexattr = ovl_removexattr, }; struct inode ovl_new_inode(struct super_block sb, umode_t mode, struct ovl_entry oe) { struct inode *inode; inode = new_inode(sb); if (!inode) return NULL; mode &= S_IFMT; inode->i_ino = get_next_ino(); inode->i_mode = mode; inode->i_flags \|= S_NOATIME \| S_NOCMTIME; switch (mode) { case S_IFDIR: inode->i_private = oe; inode->i_op = &ovl_dir_inode_operations; inode->i_fop = &ovl_dir_operations; break; case S_IFLNK: inode->i_op = &ovl_symlink_inode_operations; break; case S_IFREG: case S_IFSOCK: case S_IFBLK: case S_IFCHR: case S_IFIFO: inode->i_op = &ovl_file_inode_operations; break; default: WARN(1, "illegal file type: %i\n", mode); iput(inode); inode = NULL; } return inode; }	./CrossVul/dataset_final_sorted/CWE-264/c/bad_1795_0
crossvul-cpp_data_good_3524_5	/* * drivers/net/veth.c * * Copyright (C) 2007 OpenVZ http://openvz.org, SWsoft Inc * * Author: Pavel Emelianov <xemul@openvz.org> * Ethtool interface from: Eric W. Biederman <ebiederm@xmission.com> * / #include <linux/netdevice.h> #include <linux/slab.h> #include <linux/ethtool.h> #include <linux/etherdevice.h> #include <linux/u64_stats_sync.h> #include <net/dst.h> #include <net/xfrm.h> #include <linux/veth.h> #define DRV_NAME "veth" #define DRV_VERSION "1.0" #define MIN_MTU 68 / Min L3 MTU / #define MAX_MTU 65535 / Max L3 MTU (arbitrary) / struct veth_net_stats { u64 rx_packets; u64 tx_packets; u64 rx_bytes; u64 tx_bytes; u64 rx_dropped; struct u64_stats_sync syncp; }; struct veth_priv { struct net_device peer; struct veth_net_stats __percpu stats; }; / * ethtool interface / static struct { const char string[ETH_GSTRING_LEN]; } ethtool_stats_keys[] = { { "peer_ifindex" }, }; static int veth_get_settings(struct net_device dev, struct ethtool_cmd cmd) { cmd->supported = 0; cmd->advertising = 0; ethtool_cmd_speed_set(cmd, SPEED_10000); cmd->duplex = DUPLEX_FULL; cmd->port = PORT_TP; cmd->phy_address = 0; cmd->transceiver = XCVR_INTERNAL; cmd->autoneg = AUTONEG_DISABLE; cmd->maxtxpkt = 0; cmd->maxrxpkt = 0; return 0; } static void veth_get_drvinfo(struct net_device dev, struct ethtool_drvinfo info) { strcpy(info->driver, DRV_NAME); strcpy(info->version, DRV_VERSION); strcpy(info->fw_version, "N/A"); } static void veth_get_strings(struct net_device dev, u32 stringset, u8 buf) { switch(stringset) { case ETH_SS_STATS: memcpy(buf, &ethtool_stats_keys, sizeof(ethtool_stats_keys)); break; } } static int veth_get_sset_count(struct net_device dev, int sset) { switch (sset) { case ETH_SS_STATS: return ARRAY_SIZE(ethtool_stats_keys); default: return -EOPNOTSUPP; } } static void veth_get_ethtool_stats(struct net_device dev, struct ethtool_stats stats, u64 data) { struct veth_priv priv; priv = netdev_priv(dev); data[0] = priv->peer->ifindex; } static const struct ethtool_ops veth_ethtool_ops = { .get_settings = veth_get_settings, .get_drvinfo = veth_get_drvinfo, .get_link = ethtool_op_get_link, .get_strings = veth_get_strings, .get_sset_count = veth_get_sset_count, .get_ethtool_stats = veth_get_ethtool_stats, }; /* * xmit / static netdev_tx_t veth_xmit(struct sk_buff skb, struct net_device dev) { struct net_device rcv = NULL; struct veth_priv priv, rcv_priv; struct veth_net_stats stats, rcv_stats; int length; priv = netdev_priv(dev); rcv = priv->peer; rcv_priv = netdev_priv(rcv); stats = this_cpu_ptr(priv->stats); rcv_stats = this_cpu_ptr(rcv_priv->stats); /* don't change ip_summed == CHECKSUM_PARTIAL, as that will cause bad checksum on forwarded packets / if (skb->ip_summed == CHECKSUM_NONE && rcv->features & NETIF_F_RXCSUM) skb->ip_summed = CHECKSUM_UNNECESSARY; length = skb->len; if (dev_forward_skb(rcv, skb) != NET_RX_SUCCESS) goto rx_drop; u64_stats_update_begin(&stats->syncp); stats->tx_bytes += length; stats->tx_packets++; u64_stats_update_end(&stats->syncp); u64_stats_update_begin(&rcv_stats->syncp); rcv_stats->rx_bytes += length; rcv_stats->rx_packets++; u64_stats_update_end(&rcv_stats->syncp); return NETDEV_TX_OK; rx_drop: u64_stats_update_begin(&rcv_stats->syncp); rcv_stats->rx_dropped++; u64_stats_update_end(&rcv_stats->syncp); return NETDEV_TX_OK; } / * general routines / static struct rtnl_link_stats64 veth_get_stats64(struct net_device dev, struct rtnl_link_stats64 tot) { struct veth_priv priv = netdev_priv(dev); int cpu; for_each_possible_cpu(cpu) { struct veth_net_stats stats = per_cpu_ptr(priv->stats, cpu); u64 rx_packets, rx_bytes, rx_dropped; u64 tx_packets, tx_bytes; unsigned int start; do { start = u64_stats_fetch_begin_bh(&stats->syncp); rx_packets = stats->rx_packets; tx_packets = stats->tx_packets; rx_bytes = stats->rx_bytes; tx_bytes = stats->tx_bytes; rx_dropped = stats->rx_dropped; } while (u64_stats_fetch_retry_bh(&stats->syncp, start)); tot->rx_packets += rx_packets; tot->tx_packets += tx_packets; tot->rx_bytes += rx_bytes; tot->tx_bytes += tx_bytes; tot->rx_dropped += rx_dropped; } return tot; } static int veth_open(struct net_device dev) { struct veth_priv priv; priv = netdev_priv(dev); if (priv->peer == NULL) return -ENOTCONN; if (priv->peer->flags & IFF_UP) { netif_carrier_on(dev); netif_carrier_on(priv->peer); } return 0; } static int veth_close(struct net_device dev) { struct veth_priv priv = netdev_priv(dev); netif_carrier_off(dev); netif_carrier_off(priv->peer); return 0; } static int is_valid_veth_mtu(int new_mtu) { return new_mtu >= MIN_MTU && new_mtu <= MAX_MTU; } static int veth_change_mtu(struct net_device dev, int new_mtu) { if (!is_valid_veth_mtu(new_mtu)) return -EINVAL; dev->mtu = new_mtu; return 0; } static int veth_dev_init(struct net_device dev) { struct veth_net_stats __percpu stats; struct veth_priv priv; stats = alloc_percpu(struct veth_net_stats); if (stats == NULL) return -ENOMEM; priv = netdev_priv(dev); priv->stats = stats; return 0; } static void veth_dev_free(struct net_device dev) { struct veth_priv priv; priv = netdev_priv(dev); free_percpu(priv->stats); free_netdev(dev); } static const struct net_device_ops veth_netdev_ops = { .ndo_init = veth_dev_init, .ndo_open = veth_open, .ndo_stop = veth_close, .ndo_start_xmit = veth_xmit, .ndo_change_mtu = veth_change_mtu, .ndo_get_stats64 = veth_get_stats64, .ndo_set_mac_address = eth_mac_addr, }; static void veth_setup(struct net_device dev) { ether_setup(dev); dev->priv_flags &= ~IFF_TX_SKB_SHARING; dev->netdev_ops = &veth_netdev_ops; dev->ethtool_ops = &veth_ethtool_ops; dev->features \|= NETIF_F_LLTX; dev->destructor = veth_dev_free; dev->hw_features = NETIF_F_NO_CSUM \| NETIF_F_SG \| NETIF_F_RXCSUM; } / * netlink interface / static int veth_validate(struct nlattr tb[], struct nlattr data[]) { if (tb[IFLA_ADDRESS]) { if (nla_len(tb[IFLA_ADDRESS]) != ETH_ALEN) return -EINVAL; if (!is_valid_ether_addr(nla_data(tb[IFLA_ADDRESS]))) return -EADDRNOTAVAIL; } if (tb[IFLA_MTU]) { if (!is_valid_veth_mtu(nla_get_u32(tb[IFLA_MTU]))) return -EINVAL; } return 0; } static struct rtnl_link_ops veth_link_ops; static int veth_newlink(struct net src_net, struct net_device dev, struct nlattr tb[], struct nlattr data[]) { int err; struct net_device peer; struct veth_priv priv; char ifname[IFNAMSIZ]; struct nlattr peer_tb[IFLA_MAX + 1], *tbp; struct ifinfomsg ifmp; struct net net; / * create and register peer first / if (data != NULL && data[VETH_INFO_PEER] != NULL) { struct nlattr nla_peer; nla_peer = data[VETH_INFO_PEER]; ifmp = nla_data(nla_peer); err = nla_parse(peer_tb, IFLA_MAX, nla_data(nla_peer) + sizeof(struct ifinfomsg), nla_len(nla_peer) - sizeof(struct ifinfomsg), ifla_policy); if (err < 0) return err; err = veth_validate(peer_tb, NULL); if (err < 0) return err; tbp = peer_tb; } else { ifmp = NULL; tbp = tb; } if (tbp[IFLA_IFNAME]) nla_strlcpy(ifname, tbp[IFLA_IFNAME], IFNAMSIZ); else snprintf(ifname, IFNAMSIZ, DRV_NAME "%%d"); net = rtnl_link_get_net(src_net, tbp); if (IS_ERR(net)) return PTR_ERR(net); peer = rtnl_create_link(src_net, net, ifname, &veth_link_ops, tbp); if (IS_ERR(peer)) { put_net(net); return PTR_ERR(peer); } if (tbp[IFLA_ADDRESS] == NULL) random_ether_addr(peer->dev_addr); err = register_netdevice(peer); put_net(net); net = NULL; if (err < 0) goto err_register_peer; netif_carrier_off(peer); err = rtnl_configure_link(peer, ifmp); if (err < 0) goto err_configure_peer; /* * register dev last * * note, that since we've registered new device the dev's name * should be re-allocated / if (tb[IFLA_ADDRESS] == NULL) random_ether_addr(dev->dev_addr); if (tb[IFLA_IFNAME]) nla_strlcpy(dev->name, tb[IFLA_IFNAME], IFNAMSIZ); else snprintf(dev->name, IFNAMSIZ, DRV_NAME "%%d"); if (strchr(dev->name, '%')) { err = dev_alloc_name(dev, dev->name); if (err < 0) goto err_alloc_name; } err = register_netdevice(dev); if (err < 0) goto err_register_dev; netif_carrier_off(dev); / * tie the deviced together / priv = netdev_priv(dev); priv->peer = peer; priv = netdev_priv(peer); priv->peer = dev; return 0; err_register_dev: / nothing to do / err_alloc_name: err_configure_peer: unregister_netdevice(peer); return err; err_register_peer: free_netdev(peer); return err; } static void veth_dellink(struct net_device dev, struct list_head head) { struct veth_priv priv; struct net_device peer; priv = netdev_priv(dev); peer = priv->peer; unregister_netdevice_queue(dev, head); unregister_netdevice_queue(peer, head); } static const struct nla_policy veth_policy[VETH_INFO_MAX + 1]; static struct rtnl_link_ops veth_link_ops = { .kind = DRV_NAME, .priv_size = sizeof(struct veth_priv), .setup = veth_setup, .validate = veth_validate, .newlink = veth_newlink, .dellink = veth_dellink, .policy = veth_policy, .maxtype = VETH_INFO_MAX, }; / * init/fini */ static __init int veth_init(void) { return rtnl_link_register(&veth_link_ops); } static __exit void veth_exit(void) { rtnl_link_unregister(&veth_link_ops); } module_init(veth_init); module_exit(veth_exit); MODULE_DESCRIPTION("Virtual Ethernet Tunnel"); MODULE_LICENSE("GPL v2"); MODULE_ALIAS_RTNL_LINK(DRV_NAME);	./CrossVul/dataset_final_sorted/CWE-264/c/good_3524_5
crossvul-cpp_data_good_3604_1	#include <linux/mm.h> #include <linux/hugetlb.h> #include <linux/huge_mm.h> #include <linux/mount.h> #include <linux/seq_file.h> #include <linux/highmem.h> #include <linux/ptrace.h> #include <linux/slab.h> #include <linux/pagemap.h> #include <linux/mempolicy.h> #include <linux/rmap.h> #include <linux/swap.h> #include <linux/swapops.h> #include <asm/elf.h> #include <asm/uaccess.h> #include <asm/tlbflush.h> #include "internal.h" void task_mem(struct seq_file m, struct mm_struct mm) { unsigned long data, text, lib, swap; unsigned long hiwater_vm, total_vm, hiwater_rss, total_rss; /* * Note: to minimize their overhead, mm maintains hiwater_vm and * hiwater_rss only when about to lower total_vm or rss. Any * collector of these hiwater stats must therefore get total_vm * and rss too, which will usually be the higher. Barriers? not * worth the effort, such snapshots can always be inconsistent. / hiwater_vm = total_vm = mm->total_vm; if (hiwater_vm < mm->hiwater_vm) hiwater_vm = mm->hiwater_vm; hiwater_rss = total_rss = get_mm_rss(mm); if (hiwater_rss < mm->hiwater_rss) hiwater_rss = mm->hiwater_rss; data = mm->total_vm - mm->shared_vm - mm->stack_vm; text = (PAGE_ALIGN(mm->end_code) - (mm->start_code & PAGE_MASK)) >> 10; lib = (mm->exec_vm << (PAGE_SHIFT-10)) - text; swap = get_mm_counter(mm, MM_SWAPENTS); seq_printf(m, "VmPeak:\t%8lu kB\n" "VmSize:\t%8lu kB\n" "VmLck:\t%8lu kB\n" "VmPin:\t%8lu kB\n" "VmHWM:\t%8lu kB\n" "VmRSS:\t%8lu kB\n" "VmData:\t%8lu kB\n" "VmStk:\t%8lu kB\n" "VmExe:\t%8lu kB\n" "VmLib:\t%8lu kB\n" "VmPTE:\t%8lu kB\n" "VmSwap:\t%8lu kB\n", hiwater_vm << (PAGE_SHIFT-10), (total_vm - mm->reserved_vm) << (PAGE_SHIFT-10), mm->locked_vm << (PAGE_SHIFT-10), mm->pinned_vm << (PAGE_SHIFT-10), hiwater_rss << (PAGE_SHIFT-10), total_rss << (PAGE_SHIFT-10), data << (PAGE_SHIFT-10), mm->stack_vm << (PAGE_SHIFT-10), text, lib, (PTRS_PER_PTEsizeof(pte_t)mm->nr_ptes) >> 10, swap << (PAGE_SHIFT-10)); } unsigned long task_vsize(struct mm_struct mm) { return PAGE_SIZE * mm->total_vm; } unsigned long task_statm(struct mm_struct mm, unsigned long shared, unsigned long text, unsigned long data, unsigned long resident) { shared = get_mm_counter(mm, MM_FILEPAGES); text = (PAGE_ALIGN(mm->end_code) - (mm->start_code & PAGE_MASK)) >> PAGE_SHIFT; data = mm->total_vm - mm->shared_vm; resident = shared + get_mm_counter(mm, MM_ANONPAGES); return mm->total_vm; } static void pad_len_spaces(struct seq_file m, int len) { len = 25 + sizeof(void) * 6 - len; if (len < 1) len = 1; seq_printf(m, "%c", len, ' '); } static void vma_stop(struct proc_maps_private priv, struct vm_area_struct vma) { if (vma && vma != priv->tail_vma) { struct mm_struct mm = vma->vm_mm; up_read(&mm->mmap_sem); mmput(mm); } } static void m_start(struct seq_file m, loff_t pos) { struct proc_maps_private priv = m->private; unsigned long last_addr = m->version; struct mm_struct mm; struct vm_area_struct vma, tail_vma = NULL; loff_t l = pos; /* Clear the per syscall fields in priv / priv->task = NULL; priv->tail_vma = NULL; / * We remember last_addr rather than next_addr to hit with * mmap_cache most of the time. We have zero last_addr at * the beginning and also after lseek. We will have -1 last_addr * after the end of the vmas. / if (last_addr == -1UL) return NULL; priv->task = get_pid_task(priv->pid, PIDTYPE_PID); if (!priv->task) return ERR_PTR(-ESRCH); mm = mm_for_maps(priv->task); if (!mm \|\| IS_ERR(mm)) return mm; down_read(&mm->mmap_sem); tail_vma = get_gate_vma(priv->task->mm); priv->tail_vma = tail_vma; / Start with last addr hint / vma = find_vma(mm, last_addr); if (last_addr && vma) { vma = vma->vm_next; goto out; } / * Check the vma index is within the range and do * sequential scan until m_index. / vma = NULL; if ((unsigned long)l < mm->map_count) { vma = mm->mmap; while (l-- && vma) vma = vma->vm_next; goto out; } if (l != mm->map_count) tail_vma = NULL; / After gate vma / out: if (vma) return vma; / End of vmas has been reached / m->version = (tail_vma != NULL)? 0: -1UL; up_read(&mm->mmap_sem); mmput(mm); return tail_vma; } static void m_next(struct seq_file m, void v, loff_t pos) { struct proc_maps_private priv = m->private; struct vm_area_struct vma = v; struct vm_area_struct tail_vma = priv->tail_vma; (pos)++; if (vma && (vma != tail_vma) && vma->vm_next) return vma->vm_next; vma_stop(priv, vma); return (vma != tail_vma)? tail_vma: NULL; } static void m_stop(struct seq_file m, void v) { struct proc_maps_private priv = m->private; struct vm_area_struct vma = v; if (!IS_ERR(vma)) vma_stop(priv, vma); if (priv->task) put_task_struct(priv->task); } static int do_maps_open(struct inode inode, struct file file, const struct seq_operations ops) { struct proc_maps_private priv; int ret = -ENOMEM; priv = kzalloc(sizeof(priv), GFP_KERNEL); if (priv) { priv->pid = proc_pid(inode); ret = seq_open(file, ops); if (!ret) { struct seq_file m = file->private_data; m->private = priv; } else { kfree(priv); } } return ret; } static void show_map_vma(struct seq_file m, struct vm_area_struct vma) { struct mm_struct mm = vma->vm_mm; struct file file = vma->vm_file; vm_flags_t flags = vma->vm_flags; unsigned long ino = 0; unsigned long long pgoff = 0; unsigned long start, end; dev_t dev = 0; int len; if (file) { struct inode inode = vma->vm_file->f_path.dentry->d_inode; dev = inode->i_sb->s_dev; ino = inode->i_ino; pgoff = ((loff_t)vma->vm_pgoff) << PAGE_SHIFT; } /* We don't show the stack guard page in /proc/maps / start = vma->vm_start; if (stack_guard_page_start(vma, start)) start += PAGE_SIZE; end = vma->vm_end; if (stack_guard_page_end(vma, end)) end -= PAGE_SIZE; seq_printf(m, "%08lx-%08lx %c%c%c%c %08llx %02x:%02x %lu %n", start, end, flags & VM_READ ? 'r' : '-', flags & VM_WRITE ? 'w' : '-', flags & VM_EXEC ? 'x' : '-', flags & VM_MAYSHARE ? 's' : 'p', pgoff, MAJOR(dev), MINOR(dev), ino, &len); / * Print the dentry name for named mappings, and a * special [heap] marker for the heap: / if (file) { pad_len_spaces(m, len); seq_path(m, &file->f_path, "\n"); } else { const char name = arch_vma_name(vma); if (!name) { if (mm) { if (vma->vm_start <= mm->brk && vma->vm_end >= mm->start_brk) { name = "[heap]"; } else if (vma->vm_start <= mm->start_stack && vma->vm_end >= mm->start_stack) { name = "[stack]"; } } else { name = "[vdso]"; } } if (name) { pad_len_spaces(m, len); seq_puts(m, name); } } seq_putc(m, '\n'); } static int show_map(struct seq_file m, void v) { struct vm_area_struct vma = v; struct proc_maps_private priv = m->private; struct task_struct task = priv->task; show_map_vma(m, vma); if (m->count < m->size) / vma is copied successfully / m->version = (vma != get_gate_vma(task->mm)) ? vma->vm_start : 0; return 0; } static const struct seq_operations proc_pid_maps_op = { .start = m_start, .next = m_next, .stop = m_stop, .show = show_map }; static int maps_open(struct inode inode, struct file file) { return do_maps_open(inode, file, &proc_pid_maps_op); } const struct file_operations proc_maps_operations = { .open = maps_open, .read = seq_read, .llseek = seq_lseek, .release = seq_release_private, }; / * Proportional Set Size(PSS): my share of RSS. * * PSS of a process is the count of pages it has in memory, where each * page is divided by the number of processes sharing it. So if a * process has 1000 pages all to itself, and 1000 shared with one other * process, its PSS will be 1500. * * To keep (accumulated) division errors low, we adopt a 64bit * fixed-point pss counter to minimize division errors. So (pss >> * PSS_SHIFT) would be the real byte count. * * A shift of 12 before division means (assuming 4K page size): * - 1M 3-user-pages add up to 8KB errors; * - supports mapcount up to 2^24, or 16M; * - supports PSS up to 2^52 bytes, or 4PB. / #define PSS_SHIFT 12 #ifdef CONFIG_PROC_PAGE_MONITOR struct mem_size_stats { struct vm_area_struct vma; unsigned long resident; unsigned long shared_clean; unsigned long shared_dirty; unsigned long private_clean; unsigned long private_dirty; unsigned long referenced; unsigned long anonymous; unsigned long anonymous_thp; unsigned long swap; u64 pss; }; static void smaps_pte_entry(pte_t ptent, unsigned long addr, unsigned long ptent_size, struct mm_walk walk) { struct mem_size_stats mss = walk->private; struct vm_area_struct vma = mss->vma; struct page page; int mapcount; if (is_swap_pte(ptent)) { mss->swap += ptent_size; return; } if (!pte_present(ptent)) return; page = vm_normal_page(vma, addr, ptent); if (!page) return; if (PageAnon(page)) mss->anonymous += ptent_size; mss->resident += ptent_size; /* Accumulate the size in pages that have been accessed. / if (pte_young(ptent) \|\| PageReferenced(page)) mss->referenced += ptent_size; mapcount = page_mapcount(page); if (mapcount >= 2) { if (pte_dirty(ptent) \|\| PageDirty(page)) mss->shared_dirty += ptent_size; else mss->shared_clean += ptent_size; mss->pss += (ptent_size << PSS_SHIFT) / mapcount; } else { if (pte_dirty(ptent) \|\| PageDirty(page)) mss->private_dirty += ptent_size; else mss->private_clean += ptent_size; mss->pss += (ptent_size << PSS_SHIFT); } } static int smaps_pte_range(pmd_t pmd, unsigned long addr, unsigned long end, struct mm_walk walk) { struct mem_size_stats mss = walk->private; struct vm_area_struct vma = mss->vma; pte_t pte; spinlock_t ptl; spin_lock(&walk->mm->page_table_lock); if (pmd_trans_huge(pmd)) { if (pmd_trans_splitting(pmd)) { spin_unlock(&walk->mm->page_table_lock); wait_split_huge_page(vma->anon_vma, pmd); } else { smaps_pte_entry((pte_t )pmd, addr, HPAGE_PMD_SIZE, walk); spin_unlock(&walk->mm->page_table_lock); mss->anonymous_thp += HPAGE_PMD_SIZE; return 0; } } else { spin_unlock(&walk->mm->page_table_lock); } if (pmd_trans_unstable(pmd)) return 0; / * The mmap_sem held all the way back in m_start() is what * keeps khugepaged out of here and from collapsing things * in here. / pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl); for (; addr != end; pte++, addr += PAGE_SIZE) smaps_pte_entry(pte, addr, PAGE_SIZE, walk); pte_unmap_unlock(pte - 1, ptl); cond_resched(); return 0; } static int show_smap(struct seq_file m, void v) { struct proc_maps_private priv = m->private; struct task_struct task = priv->task; struct vm_area_struct vma = v; struct mem_size_stats mss; struct mm_walk smaps_walk = { .pmd_entry = smaps_pte_range, .mm = vma->vm_mm, .private = &mss, }; memset(&mss, 0, sizeof mss); mss.vma = vma; / mmap_sem is held in m_start / if (vma->vm_mm && !is_vm_hugetlb_page(vma)) walk_page_range(vma->vm_start, vma->vm_end, &smaps_walk); show_map_vma(m, vma); seq_printf(m, "Size: %8lu kB\n" "Rss: %8lu kB\n" "Pss: %8lu kB\n" "Shared_Clean: %8lu kB\n" "Shared_Dirty: %8lu kB\n" "Private_Clean: %8lu kB\n" "Private_Dirty: %8lu kB\n" "Referenced: %8lu kB\n" "Anonymous: %8lu kB\n" "AnonHugePages: %8lu kB\n" "Swap: %8lu kB\n" "KernelPageSize: %8lu kB\n" "MMUPageSize: %8lu kB\n" "Locked: %8lu kB\n", (vma->vm_end - vma->vm_start) >> 10, mss.resident >> 10, (unsigned long)(mss.pss >> (10 + PSS_SHIFT)), mss.shared_clean >> 10, mss.shared_dirty >> 10, mss.private_clean >> 10, mss.private_dirty >> 10, mss.referenced >> 10, mss.anonymous >> 10, mss.anonymous_thp >> 10, mss.swap >> 10, vma_kernel_pagesize(vma) >> 10, vma_mmu_pagesize(vma) >> 10, (vma->vm_flags & VM_LOCKED) ? (unsigned long)(mss.pss >> (10 + PSS_SHIFT)) : 0); if (m->count < m->size) / vma is copied successfully / m->version = (vma != get_gate_vma(task->mm)) ? vma->vm_start : 0; return 0; } static const struct seq_operations proc_pid_smaps_op = { .start = m_start, .next = m_next, .stop = m_stop, .show = show_smap }; static int smaps_open(struct inode inode, struct file file) { return do_maps_open(inode, file, &proc_pid_smaps_op); } const struct file_operations proc_smaps_operations = { .open = smaps_open, .read = seq_read, .llseek = seq_lseek, .release = seq_release_private, }; static int clear_refs_pte_range(pmd_t pmd, unsigned long addr, unsigned long end, struct mm_walk walk) { struct vm_area_struct vma = walk->private; pte_t pte, ptent; spinlock_t ptl; struct page page; split_huge_page_pmd(walk->mm, pmd); if (pmd_trans_unstable(pmd)) return 0; pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl); for (; addr != end; pte++, addr += PAGE_SIZE) { ptent = pte; if (!pte_present(ptent)) continue; page = vm_normal_page(vma, addr, ptent); if (!page) continue; if (PageReserved(page)) continue; /* Clear accessed and referenced bits. / ptep_test_and_clear_young(vma, addr, pte); ClearPageReferenced(page); } pte_unmap_unlock(pte - 1, ptl); cond_resched(); return 0; } #define CLEAR_REFS_ALL 1 #define CLEAR_REFS_ANON 2 #define CLEAR_REFS_MAPPED 3 static ssize_t clear_refs_write(struct file file, const char __user buf, size_t count, loff_t ppos) { struct task_struct task; char buffer[PROC_NUMBUF]; struct mm_struct mm; struct vm_area_struct vma; int type; int rv; memset(buffer, 0, sizeof(buffer)); if (count > sizeof(buffer) - 1) count = sizeof(buffer) - 1; if (copy_from_user(buffer, buf, count)) return -EFAULT; rv = kstrtoint(strstrip(buffer), 10, &type); if (rv < 0) return rv; if (type < CLEAR_REFS_ALL \|\| type > CLEAR_REFS_MAPPED) return -EINVAL; task = get_proc_task(file->f_path.dentry->d_inode); if (!task) return -ESRCH; mm = get_task_mm(task); if (mm) { struct mm_walk clear_refs_walk = { .pmd_entry = clear_refs_pte_range, .mm = mm, }; down_read(&mm->mmap_sem); for (vma = mm->mmap; vma; vma = vma->vm_next) { clear_refs_walk.private = vma; if (is_vm_hugetlb_page(vma)) continue; / * Writing 1 to /proc/pid/clear_refs affects all pages. * * Writing 2 to /proc/pid/clear_refs only affects * Anonymous pages. * * Writing 3 to /proc/pid/clear_refs only affects file * mapped pages. / if (type == CLEAR_REFS_ANON && vma->vm_file) continue; if (type == CLEAR_REFS_MAPPED && !vma->vm_file) continue; walk_page_range(vma->vm_start, vma->vm_end, &clear_refs_walk); } flush_tlb_mm(mm); up_read(&mm->mmap_sem); mmput(mm); } put_task_struct(task); return count; } const struct file_operations proc_clear_refs_operations = { .write = clear_refs_write, .llseek = noop_llseek, }; struct pagemapread { int pos, len; u64 buffer; }; #define PM_ENTRY_BYTES sizeof(u64) #define PM_STATUS_BITS 3 #define PM_STATUS_OFFSET (64 - PM_STATUS_BITS) #define PM_STATUS_MASK (((1LL << PM_STATUS_BITS) - 1) << PM_STATUS_OFFSET) #define PM_STATUS(nr) (((nr) << PM_STATUS_OFFSET) & PM_STATUS_MASK) #define PM_PSHIFT_BITS 6 #define PM_PSHIFT_OFFSET (PM_STATUS_OFFSET - PM_PSHIFT_BITS) #define PM_PSHIFT_MASK (((1LL << PM_PSHIFT_BITS) - 1) << PM_PSHIFT_OFFSET) #define PM_PSHIFT(x) (((u64) (x) << PM_PSHIFT_OFFSET) & PM_PSHIFT_MASK) #define PM_PFRAME_MASK ((1LL << PM_PSHIFT_OFFSET) - 1) #define PM_PFRAME(x) ((x) & PM_PFRAME_MASK) #define PM_PRESENT PM_STATUS(4LL) #define PM_SWAP PM_STATUS(2LL) #define PM_NOT_PRESENT PM_PSHIFT(PAGE_SHIFT) #define PM_END_OF_BUFFER 1 static int add_to_pagemap(unsigned long addr, u64 pfn, struct pagemapread pm) { pm->buffer[pm->pos++] = pfn; if (pm->pos >= pm->len) return PM_END_OF_BUFFER; return 0; } static int pagemap_pte_hole(unsigned long start, unsigned long end, struct mm_walk walk) { struct pagemapread pm = walk->private; unsigned long addr; int err = 0; for (addr = start; addr < end; addr += PAGE_SIZE) { err = add_to_pagemap(addr, PM_NOT_PRESENT, pm); if (err) break; } return err; } static u64 swap_pte_to_pagemap_entry(pte_t pte) { swp_entry_t e = pte_to_swp_entry(pte); return swp_type(e) \| (swp_offset(e) << MAX_SWAPFILES_SHIFT); } static u64 pte_to_pagemap_entry(pte_t pte) { u64 pme = 0; if (is_swap_pte(pte)) pme = PM_PFRAME(swap_pte_to_pagemap_entry(pte)) \| PM_PSHIFT(PAGE_SHIFT) \| PM_SWAP; else if (pte_present(pte)) pme = PM_PFRAME(pte_pfn(pte)) \| PM_PSHIFT(PAGE_SHIFT) \| PM_PRESENT; return pme; } static int pagemap_pte_range(pmd_t pmd, unsigned long addr, unsigned long end, struct mm_walk walk) { struct vm_area_struct vma; struct pagemapread pm = walk->private; pte_t pte; int err = 0; split_huge_page_pmd(walk->mm, pmd); if (pmd_trans_unstable(pmd)) return 0; /* find the first VMA at or above 'addr' / vma = find_vma(walk->mm, addr); for (; addr != end; addr += PAGE_SIZE) { u64 pfn = PM_NOT_PRESENT; / check to see if we've left 'vma' behind * and need a new, higher one / if (vma && (addr >= vma->vm_end)) vma = find_vma(walk->mm, addr); / check that 'vma' actually covers this address, * and that it isn't a huge page vma / if (vma && (vma->vm_start <= addr) && !is_vm_hugetlb_page(vma)) { pte = pte_offset_map(pmd, addr); pfn = pte_to_pagemap_entry(pte); /* unmap before userspace copy / pte_unmap(pte); } err = add_to_pagemap(addr, pfn, pm); if (err) return err; } cond_resched(); return err; } #ifdef CONFIG_HUGETLB_PAGE static u64 huge_pte_to_pagemap_entry(pte_t pte, int offset) { u64 pme = 0; if (pte_present(pte)) pme = PM_PFRAME(pte_pfn(pte) + offset) \| PM_PSHIFT(PAGE_SHIFT) \| PM_PRESENT; return pme; } / This function walks within one hugetlb entry in the single call / static int pagemap_hugetlb_range(pte_t pte, unsigned long hmask, unsigned long addr, unsigned long end, struct mm_walk walk) { struct pagemapread pm = walk->private; int err = 0; u64 pfn; for (; addr != end; addr += PAGE_SIZE) { int offset = (addr & ~hmask) >> PAGE_SHIFT; pfn = huge_pte_to_pagemap_entry(pte, offset); err = add_to_pagemap(addr, pfn, pm); if (err) return err; } cond_resched(); return err; } #endif / HUGETLB_PAGE / / * /proc/pid/pagemap - an array mapping virtual pages to pfns * * For each page in the address space, this file contains one 64-bit entry * consisting of the following: * * Bits 0-55 page frame number (PFN) if present * Bits 0-4 swap type if swapped * Bits 5-55 swap offset if swapped * Bits 55-60 page shift (page size = 1<<page shift) * Bit 61 reserved for future use * Bit 62 page swapped * Bit 63 page present * * If the page is not present but in swap, then the PFN contains an * encoding of the swap file number and the page's offset into the * swap. Unmapped pages return a null PFN. This allows determining * precisely which pages are mapped (or in swap) and comparing mapped * pages between processes. * * Efficient users of this interface will use /proc/pid/maps to * determine which areas of memory are actually mapped and llseek to * skip over unmapped regions. / #define PAGEMAP_WALK_SIZE (PMD_SIZE) #define PAGEMAP_WALK_MASK (PMD_MASK) static ssize_t pagemap_read(struct file file, char __user buf, size_t count, loff_t ppos) { struct task_struct task = get_proc_task(file->f_path.dentry->d_inode); struct mm_struct mm; struct pagemapread pm; int ret = -ESRCH; struct mm_walk pagemap_walk = {}; unsigned long src; unsigned long svpfn; unsigned long start_vaddr; unsigned long end_vaddr; int copied = 0; if (!task) goto out; ret = -EINVAL; /* file position must be aligned / if ((ppos % PM_ENTRY_BYTES) \|\| (count % PM_ENTRY_BYTES)) goto out_task; ret = 0; if (!count) goto out_task; pm.len = PM_ENTRY_BYTES * (PAGEMAP_WALK_SIZE >> PAGE_SHIFT); pm.buffer = kmalloc(pm.len, GFP_TEMPORARY); ret = -ENOMEM; if (!pm.buffer) goto out_task; mm = mm_for_maps(task); ret = PTR_ERR(mm); if (!mm \|\| IS_ERR(mm)) goto out_free; pagemap_walk.pmd_entry = pagemap_pte_range; pagemap_walk.pte_hole = pagemap_pte_hole; #ifdef CONFIG_HUGETLB_PAGE pagemap_walk.hugetlb_entry = pagemap_hugetlb_range; #endif pagemap_walk.mm = mm; pagemap_walk.private = &pm; src = ppos; svpfn = src / PM_ENTRY_BYTES; start_vaddr = svpfn << PAGE_SHIFT; end_vaddr = TASK_SIZE_OF(task); / watch out for wraparound / if (svpfn > TASK_SIZE_OF(task) >> PAGE_SHIFT) start_vaddr = end_vaddr; / * The odds are that this will stop walking way * before end_vaddr, because the length of the * user buffer is tracked in "pm", and the walk * will stop when we hit the end of the buffer. / ret = 0; while (count && (start_vaddr < end_vaddr)) { int len; unsigned long end; pm.pos = 0; end = (start_vaddr + PAGEMAP_WALK_SIZE) & PAGEMAP_WALK_MASK; / overflow ? / if (end < start_vaddr \|\| end > end_vaddr) end = end_vaddr; down_read(&mm->mmap_sem); ret = walk_page_range(start_vaddr, end, &pagemap_walk); up_read(&mm->mmap_sem); start_vaddr = end; len = min(count, PM_ENTRY_BYTES pm.pos); if (copy_to_user(buf, pm.buffer, len)) { ret = -EFAULT; goto out_mm; } copied += len; buf += len; count -= len; } ppos += copied; if (!ret \|\| ret == PM_END_OF_BUFFER) ret = copied; out_mm: mmput(mm); out_free: kfree(pm.buffer); out_task: put_task_struct(task); out: return ret; } const struct file_operations proc_pagemap_operations = { .llseek = mem_lseek, / borrow this / .read = pagemap_read, }; #endif / CONFIG_PROC_PAGE_MONITOR / #ifdef CONFIG_NUMA struct numa_maps { struct vm_area_struct vma; unsigned long pages; unsigned long anon; unsigned long active; unsigned long writeback; unsigned long mapcount_max; unsigned long dirty; unsigned long swapcache; unsigned long node[MAX_NUMNODES]; }; struct numa_maps_private { struct proc_maps_private proc_maps; struct numa_maps md; }; static void gather_stats(struct page page, struct numa_maps md, int pte_dirty, unsigned long nr_pages) { int count = page_mapcount(page); md->pages += nr_pages; if (pte_dirty \|\| PageDirty(page)) md->dirty += nr_pages; if (PageSwapCache(page)) md->swapcache += nr_pages; if (PageActive(page) \|\| PageUnevictable(page)) md->active += nr_pages; if (PageWriteback(page)) md->writeback += nr_pages; if (PageAnon(page)) md->anon += nr_pages; if (count > md->mapcount_max) md->mapcount_max = count; md->node[page_to_nid(page)] += nr_pages; } static struct page can_gather_numa_stats(pte_t pte, struct vm_area_struct vma, unsigned long addr) { struct page page; int nid; if (!pte_present(pte)) return NULL; page = vm_normal_page(vma, addr, pte); if (!page) return NULL; if (PageReserved(page)) return NULL; nid = page_to_nid(page); if (!node_isset(nid, node_states[N_HIGH_MEMORY])) return NULL; return page; } static int gather_pte_stats(pmd_t pmd, unsigned long addr, unsigned long end, struct mm_walk walk) { struct numa_maps md; spinlock_t ptl; pte_t orig_pte; pte_t pte; md = walk->private; spin_lock(&walk->mm->page_table_lock); if (pmd_trans_huge(pmd)) { if (pmd_trans_splitting(pmd)) { spin_unlock(&walk->mm->page_table_lock); wait_split_huge_page(md->vma->anon_vma, pmd); } else { pte_t huge_pte = (pte_t )pmd; struct page page; page = can_gather_numa_stats(huge_pte, md->vma, addr); if (page) gather_stats(page, md, pte_dirty(huge_pte), HPAGE_PMD_SIZE/PAGE_SIZE); spin_unlock(&walk->mm->page_table_lock); return 0; } } else { spin_unlock(&walk->mm->page_table_lock); } if (pmd_trans_unstable(pmd)) return 0; orig_pte = pte = pte_offset_map_lock(walk->mm, pmd, addr, &ptl); do { struct page page = can_gather_numa_stats(pte, md->vma, addr); if (!page) continue; gather_stats(page, md, pte_dirty(pte), 1); } while (pte++, addr += PAGE_SIZE, addr != end); pte_unmap_unlock(orig_pte, ptl); return 0; } #ifdef CONFIG_HUGETLB_PAGE static int gather_hugetbl_stats(pte_t pte, unsigned long hmask, unsigned long addr, unsigned long end, struct mm_walk walk) { struct numa_maps md; struct page page; if (pte_none(pte)) return 0; page = pte_page(pte); if (!page) return 0; md = walk->private; gather_stats(page, md, pte_dirty(pte), 1); return 0; } #else static int gather_hugetbl_stats(pte_t pte, unsigned long hmask, unsigned long addr, unsigned long end, struct mm_walk walk) { return 0; } #endif /* * Display pages allocated per node and memory policy via /proc. / static int show_numa_map(struct seq_file m, void v) { struct numa_maps_private numa_priv = m->private; struct proc_maps_private proc_priv = &numa_priv->proc_maps; struct vm_area_struct vma = v; struct numa_maps md = &numa_priv->md; struct file file = vma->vm_file; struct mm_struct mm = vma->vm_mm; struct mm_walk walk = {}; struct mempolicy pol; int n; char buffer[50]; if (!mm) return 0; /* Ensure we start with an empty set of numa_maps statistics. / memset(md, 0, sizeof(md)); md->vma = vma; walk.hugetlb_entry = gather_hugetbl_stats; walk.pmd_entry = gather_pte_stats; walk.private = md; walk.mm = mm; pol = get_vma_policy(proc_priv->task, vma, vma->vm_start); mpol_to_str(buffer, sizeof(buffer), pol, 0); mpol_cond_put(pol); seq_printf(m, "%08lx %s", vma->vm_start, buffer); if (file) { seq_printf(m, " file="); seq_path(m, &file->f_path, "\n\t= "); } else if (vma->vm_start <= mm->brk && vma->vm_end >= mm->start_brk) { seq_printf(m, " heap"); } else if (vma->vm_start <= mm->start_stack && vma->vm_end >= mm->start_stack) { seq_printf(m, " stack"); } if (is_vm_hugetlb_page(vma)) seq_printf(m, " huge"); walk_page_range(vma->vm_start, vma->vm_end, &walk); if (!md->pages) goto out; if (md->anon) seq_printf(m, " anon=%lu", md->anon); if (md->dirty) seq_printf(m, " dirty=%lu", md->dirty); if (md->pages != md->anon && md->pages != md->dirty) seq_printf(m, " mapped=%lu", md->pages); if (md->mapcount_max > 1) seq_printf(m, " mapmax=%lu", md->mapcount_max); if (md->swapcache) seq_printf(m, " swapcache=%lu", md->swapcache); if (md->active < md->pages && !is_vm_hugetlb_page(vma)) seq_printf(m, " active=%lu", md->active); if (md->writeback) seq_printf(m, " writeback=%lu", md->writeback); for_each_node_state(n, N_HIGH_MEMORY) if (md->node[n]) seq_printf(m, " N%d=%lu", n, md->node[n]); out: seq_putc(m, '\n'); if (m->count < m->size) m->version = (vma != proc_priv->tail_vma) ? vma->vm_start : 0; return 0; } static const struct seq_operations proc_pid_numa_maps_op = { .start = m_start, .next = m_next, .stop = m_stop, .show = show_numa_map, }; static int numa_maps_open(struct inode inode, struct file file) { struct numa_maps_private priv; int ret = -ENOMEM; priv = kzalloc(sizeof(priv), GFP_KERNEL); if (priv) { priv->proc_maps.pid = proc_pid(inode); ret = seq_open(file, &proc_pid_numa_maps_op); if (!ret) { struct seq_file m = file->private_data; m->private = priv; } else { kfree(priv); } } return ret; } const struct file_operations proc_numa_maps_operations = { .open = numa_maps_open, .read = seq_read, .llseek = seq_lseek, .release = seq_release_private, }; #endif / CONFIG_NUMA */	./CrossVul/dataset_final_sorted/CWE-264/c/good_3604_1
crossvul-cpp_data_good_5861_46	/* * PRNG: Pseudo Random Number Generator * Based on NIST Recommended PRNG From ANSI X9.31 Appendix A.2.4 using * AES 128 cipher * * (C) Neil Horman <nhorman@tuxdriver.com> * * This program is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the * Free Software Foundation; either version 2 of the License, or (at your * any later version. * * / #include <crypto/internal/rng.h> #include <linux/err.h> #include <linux/init.h> #include <linux/module.h> #include <linux/moduleparam.h> #include <linux/string.h> #include "internal.h" #define DEFAULT_PRNG_KEY "0123456789abcdef" #define DEFAULT_PRNG_KSZ 16 #define DEFAULT_BLK_SZ 16 #define DEFAULT_V_SEED "zaybxcwdveuftgsh" / * Flags for the prng_context flags field / #define PRNG_FIXED_SIZE 0x1 #define PRNG_NEED_RESET 0x2 / * Note: DT is our counter value * I is our intermediate value * V is our seed vector * See http://csrc.nist.gov/groups/STM/cavp/documents/rng/931rngext.pdf * for implementation details / struct prng_context { spinlock_t prng_lock; unsigned char rand_data[DEFAULT_BLK_SZ]; unsigned char last_rand_data[DEFAULT_BLK_SZ]; unsigned char DT[DEFAULT_BLK_SZ]; unsigned char I[DEFAULT_BLK_SZ]; unsigned char V[DEFAULT_BLK_SZ]; u32 rand_data_valid; struct crypto_cipher tfm; u32 flags; }; static int dbg; static void hexdump(char note, unsigned char buf, unsigned int len) { if (dbg) { printk(KERN_CRIT "%s", note); print_hex_dump(KERN_CONT, "", DUMP_PREFIX_OFFSET, 16, 1, buf, len, false); } } #define dbgprint(format, args...) do {\ if (dbg)\ printk(format, ##args);\ } while (0) static void xor_vectors(unsigned char in1, unsigned char in2, unsigned char out, unsigned int size) { int i; for (i = 0; i < size; i++) out[i] = in1[i] ^ in2[i]; } / * Returns DEFAULT_BLK_SZ bytes of random data per call * returns 0 if generation succeeded, <0 if something went wrong / static int _get_more_prng_bytes(struct prng_context ctx, int cont_test) { int i; unsigned char tmp[DEFAULT_BLK_SZ]; unsigned char output = NULL; dbgprint(KERN_CRIT "Calling _get_more_prng_bytes for context %p\n", ctx); hexdump("Input DT: ", ctx->DT, DEFAULT_BLK_SZ); hexdump("Input I: ", ctx->I, DEFAULT_BLK_SZ); hexdump("Input V: ", ctx->V, DEFAULT_BLK_SZ); / * This algorithm is a 3 stage state machine / for (i = 0; i < 3; i++) { switch (i) { case 0: / * Start by encrypting the counter value * This gives us an intermediate value I / memcpy(tmp, ctx->DT, DEFAULT_BLK_SZ); output = ctx->I; hexdump("tmp stage 0: ", tmp, DEFAULT_BLK_SZ); break; case 1: / * Next xor I with our secret vector V * encrypt that result to obtain our * pseudo random data which we output / xor_vectors(ctx->I, ctx->V, tmp, DEFAULT_BLK_SZ); hexdump("tmp stage 1: ", tmp, DEFAULT_BLK_SZ); output = ctx->rand_data; break; case 2: / * First check that we didn't produce the same * random data that we did last time around through this / if (!memcmp(ctx->rand_data, ctx->last_rand_data, DEFAULT_BLK_SZ)) { if (cont_test) { panic("cprng %p Failed repetition check!\n", ctx); } printk(KERN_ERR "ctx %p Failed repetition check!\n", ctx); ctx->flags \|= PRNG_NEED_RESET; return -EINVAL; } memcpy(ctx->last_rand_data, ctx->rand_data, DEFAULT_BLK_SZ); / * Lastly xor the random data with I * and encrypt that to obtain a new secret vector V / xor_vectors(ctx->rand_data, ctx->I, tmp, DEFAULT_BLK_SZ); output = ctx->V; hexdump("tmp stage 2: ", tmp, DEFAULT_BLK_SZ); break; } / do the encryption / crypto_cipher_encrypt_one(ctx->tfm, output, tmp); } / * Now update our DT value / for (i = DEFAULT_BLK_SZ - 1; i >= 0; i--) { ctx->DT[i] += 1; if (ctx->DT[i] != 0) break; } dbgprint("Returning new block for context %p\n", ctx); ctx->rand_data_valid = 0; hexdump("Output DT: ", ctx->DT, DEFAULT_BLK_SZ); hexdump("Output I: ", ctx->I, DEFAULT_BLK_SZ); hexdump("Output V: ", ctx->V, DEFAULT_BLK_SZ); hexdump("New Random Data: ", ctx->rand_data, DEFAULT_BLK_SZ); return 0; } / Our exported functions / static int get_prng_bytes(char buf, size_t nbytes, struct prng_context ctx, int do_cont_test) { unsigned char ptr = buf; unsigned int byte_count = (unsigned int)nbytes; int err; spin_lock_bh(&ctx->prng_lock); err = -EINVAL; if (ctx->flags & PRNG_NEED_RESET) goto done; /* * If the FIXED_SIZE flag is on, only return whole blocks of * pseudo random data / err = -EINVAL; if (ctx->flags & PRNG_FIXED_SIZE) { if (nbytes < DEFAULT_BLK_SZ) goto done; byte_count = DEFAULT_BLK_SZ; } err = byte_count; dbgprint(KERN_CRIT "getting %d random bytes for context %p\n", byte_count, ctx); remainder: if (ctx->rand_data_valid == DEFAULT_BLK_SZ) { if (_get_more_prng_bytes(ctx, do_cont_test) < 0) { memset(buf, 0, nbytes); err = -EINVAL; goto done; } } / * Copy any data less than an entire block / if (byte_count < DEFAULT_BLK_SZ) { empty_rbuf: while (ctx->rand_data_valid < DEFAULT_BLK_SZ) { ptr = ctx->rand_data[ctx->rand_data_valid]; ptr++; byte_count--; ctx->rand_data_valid++; if (byte_count == 0) goto done; } } /* * Now copy whole blocks / for (; byte_count >= DEFAULT_BLK_SZ; byte_count -= DEFAULT_BLK_SZ) { if (ctx->rand_data_valid == DEFAULT_BLK_SZ) { if (_get_more_prng_bytes(ctx, do_cont_test) < 0) { memset(buf, 0, nbytes); err = -EINVAL; goto done; } } if (ctx->rand_data_valid > 0) goto empty_rbuf; memcpy(ptr, ctx->rand_data, DEFAULT_BLK_SZ); ctx->rand_data_valid += DEFAULT_BLK_SZ; ptr += DEFAULT_BLK_SZ; } / * Now go back and get any remaining partial block / if (byte_count) goto remainder; done: spin_unlock_bh(&ctx->prng_lock); dbgprint(KERN_CRIT "returning %d from get_prng_bytes in context %p\n", err, ctx); return err; } static void free_prng_context(struct prng_context ctx) { crypto_free_cipher(ctx->tfm); } static int reset_prng_context(struct prng_context ctx, unsigned char key, size_t klen, unsigned char V, unsigned char DT) { int ret; unsigned char prng_key; spin_lock_bh(&ctx->prng_lock); ctx->flags \|= PRNG_NEED_RESET; prng_key = (key != NULL) ? key : (unsigned char )DEFAULT_PRNG_KEY; if (!key) klen = DEFAULT_PRNG_KSZ; if (V) memcpy(ctx->V, V, DEFAULT_BLK_SZ); else memcpy(ctx->V, DEFAULT_V_SEED, DEFAULT_BLK_SZ); if (DT) memcpy(ctx->DT, DT, DEFAULT_BLK_SZ); else memset(ctx->DT, 0, DEFAULT_BLK_SZ); memset(ctx->rand_data, 0, DEFAULT_BLK_SZ); memset(ctx->last_rand_data, 0, DEFAULT_BLK_SZ); ctx->rand_data_valid = DEFAULT_BLK_SZ; ret = crypto_cipher_setkey(ctx->tfm, prng_key, klen); if (ret) { dbgprint(KERN_CRIT "PRNG: setkey() failed flags=%x\n", crypto_cipher_get_flags(ctx->tfm)); goto out; } ret = 0; ctx->flags &= ~PRNG_NEED_RESET; out: spin_unlock_bh(&ctx->prng_lock); return ret; } static int cprng_init(struct crypto_tfm tfm) { struct prng_context ctx = crypto_tfm_ctx(tfm); spin_lock_init(&ctx->prng_lock); ctx->tfm = crypto_alloc_cipher("aes", 0, 0); if (IS_ERR(ctx->tfm)) { dbgprint(KERN_CRIT "Failed to alloc tfm for context %p\n", ctx); return PTR_ERR(ctx->tfm); } if (reset_prng_context(ctx, NULL, DEFAULT_PRNG_KSZ, NULL, NULL) < 0) return -EINVAL; /* * after allocation, we should always force the user to reset * so they don't inadvertently use the insecure default values * without specifying them intentially / ctx->flags \|= PRNG_NEED_RESET; return 0; } static void cprng_exit(struct crypto_tfm tfm) { free_prng_context(crypto_tfm_ctx(tfm)); } static int cprng_get_random(struct crypto_rng tfm, u8 rdata, unsigned int dlen) { struct prng_context prng = crypto_rng_ctx(tfm); return get_prng_bytes(rdata, dlen, prng, 0); } / * This is the cprng_registered reset method the seed value is * interpreted as the tuple { V KEY DT} * V and KEY are required during reset, and DT is optional, detected * as being present by testing the length of the seed / static int cprng_reset(struct crypto_rng tfm, u8 seed, unsigned int slen) { struct prng_context prng = crypto_rng_ctx(tfm); u8 key = seed + DEFAULT_BLK_SZ; u8 dt = NULL; if (slen < DEFAULT_PRNG_KSZ + DEFAULT_BLK_SZ) return -EINVAL; if (slen >= (2 * DEFAULT_BLK_SZ + DEFAULT_PRNG_KSZ)) dt = key + DEFAULT_PRNG_KSZ; reset_prng_context(prng, key, DEFAULT_PRNG_KSZ, seed, dt); if (prng->flags & PRNG_NEED_RESET) return -EINVAL; return 0; } #ifdef CONFIG_CRYPTO_FIPS static int fips_cprng_get_random(struct crypto_rng tfm, u8 rdata, unsigned int dlen) { struct prng_context prng = crypto_rng_ctx(tfm); return get_prng_bytes(rdata, dlen, prng, 1); } static int fips_cprng_reset(struct crypto_rng tfm, u8 seed, unsigned int slen) { u8 rdata[DEFAULT_BLK_SZ]; u8 key = seed + DEFAULT_BLK_SZ; int rc; struct prng_context prng = crypto_rng_ctx(tfm); if (slen < DEFAULT_PRNG_KSZ + DEFAULT_BLK_SZ) return -EINVAL; / fips strictly requires seed != key / if (!memcmp(seed, key, DEFAULT_PRNG_KSZ)) return -EINVAL; rc = cprng_reset(tfm, seed, slen); if (!rc) goto out; / this primes our continuity test / rc = get_prng_bytes(rdata, DEFAULT_BLK_SZ, prng, 0); prng->rand_data_valid = DEFAULT_BLK_SZ; out: return rc; } #endif static struct crypto_alg rng_algs[] = { { .cra_name = "stdrng", .cra_driver_name = "ansi_cprng", .cra_priority = 100, .cra_flags = CRYPTO_ALG_TYPE_RNG, .cra_ctxsize = sizeof(struct prng_context), .cra_type = &crypto_rng_type, .cra_module = THIS_MODULE, .cra_init = cprng_init, .cra_exit = cprng_exit, .cra_u = { .rng = { .rng_make_random = cprng_get_random, .rng_reset = cprng_reset, .seedsize = DEFAULT_PRNG_KSZ + 2DEFAULT_BLK_SZ, } } #ifdef CONFIG_CRYPTO_FIPS }, { .cra_name = "fips(ansi_cprng)", .cra_driver_name = "fips_ansi_cprng", .cra_priority = 300, .cra_flags = CRYPTO_ALG_TYPE_RNG, .cra_ctxsize = sizeof(struct prng_context), .cra_type = &crypto_rng_type, .cra_module = THIS_MODULE, .cra_init = cprng_init, .cra_exit = cprng_exit, .cra_u = { .rng = { .rng_make_random = fips_cprng_get_random, .rng_reset = fips_cprng_reset, .seedsize = DEFAULT_PRNG_KSZ + 2DEFAULT_BLK_SZ, } } #endif } }; / Module initalization */ static int __init prng_mod_init(void) { return crypto_register_algs(rng_algs, ARRAY_SIZE(rng_algs)); } static void __exit prng_mod_fini(void) { crypto_unregister_algs(rng_algs, ARRAY_SIZE(rng_algs)); } MODULE_LICENSE("GPL"); MODULE_DESCRIPTION("Software Pseudo Random Number Generator"); MODULE_AUTHOR("Neil Horman <nhorman@tuxdriver.com>"); module_param(dbg, int, 0); MODULE_PARM_DESC(dbg, "Boolean to enable debugging (0/1 == off/on)"); module_init(prng_mod_init); module_exit(prng_mod_fini); MODULE_ALIAS_CRYPTO("stdrng");	./CrossVul/dataset_final_sorted/CWE-264/c/good_5861_46

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.