env 182 arch/alpha/include/asm/err_ev7.h struct ev7_pal_environmental_subpacket env; /* Type 10-16 */ env 196 arch/alpha/include/asm/err_ev7.h struct ev7_pal_environmental_subpacket *env[7]; /* Type 10-16 */ env 104 arch/alpha/kernel/err_ev7.c lf_subpackets->env[ev7_lf_env_index(subpacket->type)] = env 28 arch/alpha/kernel/err_marvel.c struct ev7_pal_environmental_subpacket *env; env 49 arch/alpha/kernel/err_marvel.c env = lf_subpackets->env[ev7_lf_env_index(ev_packets[i].type)]; env 50 arch/alpha/kernel/err_marvel.c if (!env) env 56 arch/alpha/kernel/err_marvel.c env->cabinet, env 57 arch/alpha/kernel/err_marvel.c env->drawer); env 61 arch/alpha/kernel/err_marvel.c env->module_type, env 62 arch/alpha/kernel/err_marvel.c env->unit_id, env 63 arch/alpha/kernel/err_marvel.c env->condition); env 77 arch/alpha/kernel/err_marvel.c if (lf_subpackets->env[i]) env 63 arch/mips/alchemy/common/prom.c char **env = prom_envp; env 65 arch/mips/alchemy/common/prom.c int yamon = (*env && strchr(*env, '=') == NULL); env 67 arch/mips/alchemy/common/prom.c while (*env) { env 69 arch/mips/alchemy/common/prom.c if (strcmp(envname, *env++) == 0) env 70 arch/mips/alchemy/common/prom.c return *env; env 71 arch/mips/alchemy/common/prom.c } else if (strncmp(envname, *env, i) == 0 && (*env)[i] == '=') env 72 arch/mips/alchemy/common/prom.c return *env + i + 1; env 73 arch/mips/alchemy/common/prom.c env++; env 172 arch/mips/ar7/prom.c static void __init ar7_init_env(struct env_var *env) env 181 arch/mips/ar7/prom.c for (i = 0; i < MAX_ENTRY; i++, env++) env 182 arch/mips/ar7/prom.c if (env->name) env 183 arch/mips/ar7/prom.c add_adam2_var(env->name, env->value); env 20 arch/mips/loongson32/common/prom.c char **env = prom_envp; env 25 arch/mips/loongson32/common/prom.c while (*env) { env 26 arch/mips/loongson32/common/prom.c if (strncmp(envname, *env, i) == 0 && *(*env + i) == '=') env 27 arch/mips/loongson32/common/prom.c return *env + i + 1; env 28 arch/mips/loongson32/common/prom.c env++; env 34 arch/mips/loongson32/common/prom.c static inline unsigned long env_or_default(char *env, unsigned long dfl) env 36 arch/mips/loongson32/common/prom.c char *str = prom_getenv(env); env 35 arch/mips/pnx833x/common/prom.c char **env = prom_envp; env 40 arch/mips/pnx833x/common/prom.c while (*env) { env 41 arch/mips/pnx833x/common/prom.c if (strncmp(envname, *env, i) == 0 && *(*env+i) == '=') env 42 arch/mips/pnx833x/common/prom.c return *env + i + 1; env 43 arch/mips/pnx833x/common/prom.c env++; env 39 arch/mips/pnx833x/stb22x/board.c static inline unsigned long env_or_default(char *env, unsigned long dfl) env 41 arch/mips/pnx833x/stb22x/board.c char *str = prom_getenv(env); env 203 arch/mips/sgi-ip22/ip22-gio.c static int gio_device_uevent(struct device *dev, struct kobj_uevent_env *env) env 207 arch/mips/sgi-ip22/ip22-gio.c add_uevent_var(env, "MODALIAS=gio:%x", gio_dev->id.id); env 566 arch/parisc/kernel/drivers.c static int parisc_uevent(struct device *dev, struct kobj_uevent_env *env) env 578 arch/parisc/kernel/drivers.c if (add_uevent_var(env, "PARISC_NAME=%s", padev->name)) env 582 arch/parisc/kernel/drivers.c if (add_uevent_var(env, "MODALIAS=%s", modalias)) env 12 arch/powerpc/include/asm/setjmp.h extern int setjmp(jmp_buf env) __attribute__((returns_twice)); env 13 arch/powerpc/include/asm/setjmp.h extern void longjmp(jmp_buf env, int val) __attribute__((noreturn)); env 29 arch/powerpc/include/asm/types.h unsigned long env; env 443 arch/powerpc/platforms/ps3/system-bus.c static int ps3_system_bus_uevent(struct device *_dev, struct kobj_uevent_env *env) env 447 arch/powerpc/platforms/ps3/system-bus.c if (add_uevent_var(env, "MODALIAS=ps3:%d:%d", dev->match_id, env 1590 arch/powerpc/platforms/pseries/vio.c static int vio_hotplug(struct device *dev, struct kobj_uevent_env *env) env 1603 arch/powerpc/platforms/pseries/vio.c add_uevent_var(env, "MODALIAS=vio:T%sS%s", vio_dev->type, cp); env 61 arch/sparc/kernel/ldc.c u8 env; env 435 arch/sparc/kernel/ldc.c p->env = lp->cfg.mode; env 440 arch/sparc/kernel/ldc.c p->env, p->seqid); env 455 arch/sparc/kernel/ldc.c p->env = lp->cfg.mode; env 459 arch/sparc/kernel/ldc.c p->env, p->seqid); env 474 arch/sparc/kernel/ldc.c p->env = 0; env 479 arch/sparc/kernel/ldc.c p->env, p->seqid, p->u.r.ackid); env 673 arch/sparc/kernel/ldc.c p->stype, p->seqid, p->env); env 677 arch/sparc/kernel/ldc.c p->env != lp->cfg.mode) env 693 arch/sparc/kernel/ldc.c p->stype, p->seqid, p->env); env 696 arch/sparc/kernel/ldc.c p->env != lp->cfg.mode) env 716 arch/sparc/kernel/ldc.c p->stype, p->seqid, p->env, p->u.r.ackid); env 1612 arch/sparc/kernel/ldc.c p->env = (data_len | env 1622 arch/sparc/kernel/ldc.c p->env, env 1774 arch/sparc/kernel/ldc.c p->env, env 1816 arch/sparc/kernel/ldc.c pkt_len = p->env & LDC_LEN; env 1831 arch/sparc/kernel/ldc.c if ((first_frag == NULL && !(p->env & LDC_START)) || env 1832 arch/sparc/kernel/ldc.c (first_frag != NULL && (p->env & LDC_START))) { env 1872 arch/sparc/kernel/ldc.c if (p->env & LDC_STOP) env 49 arch/sparc/kernel/vio.c static int vio_hotplug(struct device *dev, struct kobj_uevent_env *env) env 53 arch/sparc/kernel/vio.c add_uevent_var(env, "MODALIAS=vio:T%sS%s", vio_dev->type, vio_dev->compat); env 23 arch/x86/include/asm/fpu/signal.h extern void convert_from_fxsr(struct user_i387_ia32_struct *env, env 26 arch/x86/include/asm/fpu/signal.h const struct user_i387_ia32_struct *env); env 232 arch/x86/kernel/fpu/regset.c convert_from_fxsr(struct user_i387_ia32_struct *env, struct task_struct *tsk) env 235 arch/x86/kernel/fpu/regset.c struct _fpreg *to = (struct _fpreg *) &env->st_space[0]; env 239 arch/x86/kernel/fpu/regset.c env->cwd = fxsave->cwd | 0xffff0000u; env 240 arch/x86/kernel/fpu/regset.c env->swd = fxsave->swd | 0xffff0000u; env 241 arch/x86/kernel/fpu/regset.c env->twd = twd_fxsr_to_i387(fxsave); env 244 arch/x86/kernel/fpu/regset.c env->fip = fxsave->rip; env 245 arch/x86/kernel/fpu/regset.c env->foo = fxsave->rdp; env 250 arch/x86/kernel/fpu/regset.c env->fcs = task_pt_regs(tsk)->cs; env 252 arch/x86/kernel/fpu/regset.c savesegment(ds, env->fos); env 254 arch/x86/kernel/fpu/regset.c env->fos = tsk->thread.ds; env 256 arch/x86/kernel/fpu/regset.c env->fos |= 0xffff0000; env 258 arch/x86/kernel/fpu/regset.c env->fip = fxsave->fip; env 259 arch/x86/kernel/fpu/regset.c env->fcs = (u16) fxsave->fcs | ((u32) fxsave->fop << 16); env 260 arch/x86/kernel/fpu/regset.c env->foo = fxsave->foo; env 261 arch/x86/kernel/fpu/regset.c env->fos = fxsave->fos; env 269 arch/x86/kernel/fpu/regset.c const struct user_i387_ia32_struct *env) env 272 arch/x86/kernel/fpu/regset.c struct _fpreg *from = (struct _fpreg *) &env->st_space[0]; env 276 arch/x86/kernel/fpu/regset.c fxsave->cwd = env->cwd; env 277 arch/x86/kernel/fpu/regset.c fxsave->swd = env->swd; env 278 arch/x86/kernel/fpu/regset.c fxsave->twd = twd_i387_to_fxsr(env->twd); env 279 arch/x86/kernel/fpu/regset.c fxsave->fop = (u16) ((u32) env->fcs >> 16); env 281 arch/x86/kernel/fpu/regset.c fxsave->rip = env->fip; env 282 arch/x86/kernel/fpu/regset.c fxsave->rdp = env->foo; env 285 arch/x86/kernel/fpu/regset.c fxsave->fip = env->fip; env 286 arch/x86/kernel/fpu/regset.c fxsave->fcs = (env->fcs & 0xffff); env 287 arch/x86/kernel/fpu/regset.c fxsave->foo = env->foo; env 288 arch/x86/kernel/fpu/regset.c fxsave->fos = env->fos; env 300 arch/x86/kernel/fpu/regset.c struct user_i387_ia32_struct env; env 314 arch/x86/kernel/fpu/regset.c if (kbuf && pos == 0 && count == sizeof(env)) { env 319 arch/x86/kernel/fpu/regset.c convert_from_fxsr(&env, target); env 321 arch/x86/kernel/fpu/regset.c return user_regset_copyout(&pos, &count, &kbuf, &ubuf, &env, 0, -1); env 329 arch/x86/kernel/fpu/regset.c struct user_i387_ia32_struct env; env 343 arch/x86/kernel/fpu/regset.c if (pos > 0 || count < sizeof(env)) env 344 arch/x86/kernel/fpu/regset.c convert_from_fxsr(&env, target); env 346 arch/x86/kernel/fpu/regset.c ret = user_regset_copyin(&pos, &count, &kbuf, &ubuf, &env, 0, -1); env 348 arch/x86/kernel/fpu/regset.c convert_to_fxsr(&target->thread.fpu.state.fxsave, &env); env 62 arch/x86/kernel/fpu/signal.c struct user_i387_ia32_struct env; env 70 arch/x86/kernel/fpu/signal.c convert_from_fxsr(&env, tsk); env 72 arch/x86/kernel/fpu/signal.c if (__copy_to_user(buf, &env, sizeof(env)) || env 279 arch/x86/kernel/fpu/signal.c struct user_i387_ia32_struct env; env 334 arch/x86/kernel/fpu/signal.c ret = __copy_from_user(&env, buf, sizeof(env)); env 337 arch/x86/kernel/fpu/signal.c envp = &env; env 85 arch/x86/um/signal.c unsigned long env[7]; env 90 arch/x86/um/signal.c env[0] = (unsigned long)fxsave->cwd | 0xffff0000ul; env 91 arch/x86/um/signal.c env[1] = (unsigned long)fxsave->swd | 0xffff0000ul; env 92 arch/x86/um/signal.c env[2] = twd_fxsr_to_i387(fxsave); env 93 arch/x86/um/signal.c env[3] = fxsave->fip; env 94 arch/x86/um/signal.c env[4] = fxsave->fcs | ((unsigned long)fxsave->fop << 16); env 95 arch/x86/um/signal.c env[5] = fxsave->foo; env 96 arch/x86/um/signal.c env[6] = fxsave->fos; env 98 arch/x86/um/signal.c if (__copy_to_user(buf, env, 7 * sizeof(unsigned long))) env 118 arch/x86/um/signal.c unsigned long env[7]; env 123 arch/x86/um/signal.c if (copy_from_user( env, buf, 7 * sizeof(long))) env 126 arch/x86/um/signal.c fxsave->cwd = (unsigned short)(env[0] & 0xffff); env 127 arch/x86/um/signal.c fxsave->swd = (unsigned short)(env[1] & 0xffff); env 128 arch/x86/um/signal.c fxsave->twd = twd_i387_to_fxsr((unsigned short)(env[2] & 0xffff)); env 129 arch/x86/um/signal.c fxsave->fip = env[3]; env 130 arch/x86/um/signal.c fxsave->fop = (unsigned short)((env[4] & 0xffff0000ul) >> 16); env 131 arch/x86/um/signal.c fxsave->fcs = (env[4] & 0xffff); env 132 arch/x86/um/signal.c fxsave->foo = env[5]; env 133 arch/x86/um/signal.c fxsave->fos = env[6]; env 231 block/partition-generic.c static int part_uevent(struct device *dev, struct kobj_uevent_env *env) env 235 block/partition-generic.c add_uevent_var(env, "PARTN=%u", part->partno); env 237 block/partition-generic.c add_uevent_var(env, "PARTNAME=%s", part->info->volname); env 891 drivers/acpi/bus.c static int acpi_device_uevent(struct device *dev, struct kobj_uevent_env *env) env 893 drivers/acpi/bus.c return __acpi_device_uevent_modalias(to_acpi_device(dev), env); env 241 drivers/acpi/device_sysfs.c struct kobj_uevent_env *env) env 251 drivers/acpi/device_sysfs.c if (add_uevent_var(env, "MODALIAS=")) env 254 drivers/acpi/device_sysfs.c len = create_pnp_modalias(adev, &env->buf[env->buflen - 1], env 255 drivers/acpi/device_sysfs.c sizeof(env->buf) - env->buflen); env 259 drivers/acpi/device_sysfs.c env->buflen += len; env 263 drivers/acpi/device_sysfs.c if (len > 0 && add_uevent_var(env, "MODALIAS=")) env 266 drivers/acpi/device_sysfs.c len = create_of_modalias(adev, &env->buf[env->buflen - 1], env 267 drivers/acpi/device_sysfs.c sizeof(env->buf) - env->buflen); env 271 drivers/acpi/device_sysfs.c env->buflen += len; env 284 drivers/acpi/device_sysfs.c int acpi_device_uevent_modalias(struct device *dev, struct kobj_uevent_env *env) env 286 drivers/acpi/device_sysfs.c return __acpi_device_uevent_modalias(acpi_companion_match(dev), env); env 124 drivers/acpi/internal.h struct kobj_uevent_env *env); env 71 drivers/amba/bus.c static int amba_uevent(struct device *dev, struct kobj_uevent_env *env) env 76 drivers/amba/bus.c retval = add_uevent_var(env, "AMBA_ID=%08x", pcdev->periphid); env 80 drivers/amba/bus.c retval = add_uevent_var(env, "MODALIAS=amba:d%08X", pcdev->periphid); env 1161 drivers/base/core.c struct kobj_uevent_env *env) env 1174 drivers/base/core.c add_uevent_var(env, "MAJOR=%u", MAJOR(dev->devt)); env 1175 drivers/base/core.c add_uevent_var(env, "MINOR=%u", MINOR(dev->devt)); env 1178 drivers/base/core.c add_uevent_var(env, "DEVNAME=%s", name); env 1180 drivers/base/core.c add_uevent_var(env, "DEVMODE=%#o", mode & 0777); env 1182 drivers/base/core.c add_uevent_var(env, "DEVUID=%u", from_kuid(&init_user_ns, uid)); env 1184 drivers/base/core.c add_uevent_var(env, "DEVGID=%u", from_kgid(&init_user_ns, gid)); env 1190 drivers/base/core.c add_uevent_var(env, "DEVTYPE=%s", dev->type->name); env 1193 drivers/base/core.c add_uevent_var(env, "DRIVER=%s", dev->driver->name); env 1196 drivers/base/core.c of_device_uevent(dev, env); env 1200 drivers/base/core.c retval = dev->bus->uevent(dev, env); env 1208 drivers/base/core.c retval = dev->class->dev_uevent(dev, env); env 1217 drivers/base/core.c retval = dev->type->uevent(dev, env); env 1238 drivers/base/core.c struct kobj_uevent_env *env = NULL; env 1259 drivers/base/core.c env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL); env 1260 drivers/base/core.c if (!env) env 1264 drivers/base/core.c retval = kset->uevent_ops->uevent(kset, &dev->kobj, env); env 1269 drivers/base/core.c for (i = 0; i < env->envp_idx; i++) env 1270 drivers/base/core.c count += sprintf(&buf[count], "%s\n", env->envp[i]); env 1272 drivers/base/core.c kfree(env); env 346 drivers/base/cpu.c static int cpu_uevent(struct device *dev, struct kobj_uevent_env *env) env 351 drivers/base/cpu.c add_uevent_var(env, "MODALIAS=%s", buf); env 167 drivers/base/firmware_loader/fallback.c static int do_firmware_uevent(struct fw_sysfs *fw_sysfs, struct kobj_uevent_env *env) env 169 drivers/base/firmware_loader/fallback.c if (add_uevent_var(env, "FIRMWARE=%s", fw_sysfs->fw_priv->fw_name)) env 171 drivers/base/firmware_loader/fallback.c if (add_uevent_var(env, "TIMEOUT=%i", __firmware_loading_timeout())) env 173 drivers/base/firmware_loader/fallback.c if (add_uevent_var(env, "ASYNC=%d", fw_sysfs->nowait)) env 179 drivers/base/firmware_loader/fallback.c static int firmware_uevent(struct device *dev, struct kobj_uevent_env *env) env 186 drivers/base/firmware_loader/fallback.c err = do_firmware_uevent(fw_sysfs, env); env 1024 drivers/base/platform.c static int platform_uevent(struct device *dev, struct kobj_uevent_env *env) env 1030 drivers/base/platform.c rc = of_device_uevent_modalias(dev, env); env 1034 drivers/base/platform.c rc = acpi_device_uevent_modalias(dev, env); env 1038 drivers/base/platform.c add_uevent_var(env, "MODALIAS=%s%s", PLATFORM_MODULE_PREFIX, env 31 drivers/bcma/main.c static int bcma_device_uevent(struct device *dev, struct kobj_uevent_env *env); env 630 drivers/bcma/main.c static int bcma_device_uevent(struct device *dev, struct kobj_uevent_env *env) env 634 drivers/bcma/main.c return add_uevent_var(env, env 118 drivers/bus/fsl-mc/fsl-mc-bus.c static int fsl_mc_bus_uevent(struct device *dev, struct kobj_uevent_env *env) env 122 drivers/bus/fsl-mc/fsl-mc-bus.c if (add_uevent_var(env, "MODALIAS=fsl-mc:v%08Xd%s", env 68 drivers/bus/mips_cdmm.c static int mips_cdmm_uevent(struct device *dev, struct kobj_uevent_env *env) env 73 drivers/bus/mips_cdmm.c retval = add_uevent_var(env, "CDMM_CPU=%u", cdev->cpu); env 77 drivers/bus/mips_cdmm.c retval = add_uevent_var(env, "CDMM_TYPE=0x%02x", cdev->type); env 81 drivers/bus/mips_cdmm.c retval = add_uevent_var(env, "CDMM_REV=%u", cdev->rev); env 85 drivers/bus/mips_cdmm.c retval = add_uevent_var(env, "MODALIAS=mipscdmm:t%02X", cdev->type); env 22 drivers/dax/bus.c static int dax_bus_uevent(struct device *dev, struct kobj_uevent_env *env) env 28 drivers/dax/bus.c return add_uevent_var(env, "MODALIAS=" DAX_DEVICE_MODALIAS_FMT, 0); env 130 drivers/eisa/eisa-bus.c static int eisa_bus_uevent(struct device *dev, struct kobj_uevent_env *env) env 134 drivers/eisa/eisa-bus.c add_uevent_var(env, "MODALIAS=" EISA_DEVICE_MODALIAS_FMT, edev->id.sig); env 209 drivers/firewire/core-device.c static int fw_unit_uevent(struct device *dev, struct kobj_uevent_env *env) env 216 drivers/firewire/core-device.c if (add_uevent_var(env, "MODALIAS=%s", modalias)) env 149 drivers/firmware/dmi-id.c static int dmi_dev_uevent(struct device *dev, struct kobj_uevent_env *env) env 153 drivers/firmware/dmi-id.c if (add_uevent_var(env, "MODALIAS=")) env 155 drivers/firmware/dmi-id.c len = get_modalias(&env->buf[env->buflen - 1], env 156 drivers/firmware/dmi-id.c sizeof(env->buf) - env->buflen); env 157 drivers/firmware/dmi-id.c if (len >= (sizeof(env->buf) - env->buflen)) env 159 drivers/firmware/dmi-id.c env->buflen += len; env 368 drivers/gnss/core.c static int gnss_uevent(struct device *dev, struct kobj_uevent_env *env) env 373 drivers/gnss/core.c ret = add_uevent_var(env, "GNSS_TYPE=%s", gnss_type_name(gdev)); env 63 drivers/gpu/drm/drm_mipi_dsi.c static int mipi_dsi_uevent(struct device *dev, struct kobj_uevent_env *env) env 68 drivers/gpu/drm/drm_mipi_dsi.c err = of_device_uevent_modalias(dev, env); env 72 drivers/gpu/drm/drm_mipi_dsi.c add_uevent_var(env, "MODALIAS=%s%s", MIPI_DSI_MODULE_PREFIX, env 1241 drivers/gpu/drm/i915/gvt/handlers.c char *env[3] = {NULL, NULL, NULL}; env 1246 drivers/gpu/drm/i915/gvt/handlers.c env[0] = display_ready_str; env 1249 drivers/gpu/drm/i915/gvt/handlers.c env[1] = vmid_str; env 1251 drivers/gpu/drm/i915/gvt/handlers.c return kobject_uevent_env(kobj, KOBJ_ADD, env); env 309 drivers/gpu/host1x/bus.c struct kobj_uevent_env *env) env 325 drivers/gpu/host1x/bus.c add_uevent_var(env, "OF_NAME=%pOFn", np); env 326 drivers/gpu/host1x/bus.c add_uevent_var(env, "OF_FULLNAME=%pOF", np); env 329 drivers/gpu/host1x/bus.c add_uevent_var(env, "OF_COMPATIBLE_%u=%s", count, compat); env 333 drivers/gpu/host1x/bus.c add_uevent_var(env, "OF_COMPATIBLE_N=%u", count); env 81 drivers/greybus/core.c static int greybus_uevent(struct device *dev, struct kobj_uevent_env *env) env 117 drivers/greybus/core.c if (add_uevent_var(env, "BUS=%u", hd->bus_id)) env 121 drivers/greybus/core.c if (add_uevent_var(env, "MODULE=%u", module->module_id)) env 126 drivers/greybus/core.c if (add_uevent_var(env, "INTERFACE=%u", intf->interface_id)) env 128 drivers/greybus/core.c if (add_uevent_var(env, "GREYBUS_ID=%08x/%08x", env 139 drivers/greybus/core.c if (add_uevent_var(env, "BUNDLE=%u", bundle->id)) env 141 drivers/greybus/core.c if (add_uevent_var(env, "BUNDLE_CLASS=%02x", bundle->class)) env 2333 drivers/hid/hid-core.c static int hid_uevent(struct device *dev, struct kobj_uevent_env *env) env 2337 drivers/hid/hid-core.c if (add_uevent_var(env, "HID_ID=%04X:%08X:%08X", env 2341 drivers/hid/hid-core.c if (add_uevent_var(env, "HID_NAME=%s", hdev->name)) env 2344 drivers/hid/hid-core.c if (add_uevent_var(env, "HID_PHYS=%s", hdev->phys)) env 2347 drivers/hid/hid-core.c if (add_uevent_var(env, "HID_UNIQ=%s", hdev->uniq)) env 2350 drivers/hid/hid-core.c if (add_uevent_var(env, "MODALIAS=hid:b%04Xg%04Xv%08Xp%08X", env 379 drivers/hid/intel-ish-hid/ishtp/bus.c static int ishtp_cl_uevent(struct device *dev, struct kobj_uevent_env *env) env 381 drivers/hid/intel-ish-hid/ishtp/bus.c if (add_uevent_var(env, "MODALIAS=ishtp:%s", dev_name(dev))) env 33 drivers/hsi/hsi_core.c static int hsi_bus_uevent(struct device *dev, struct kobj_uevent_env *env) env 35 drivers/hsi/hsi_core.c add_uevent_var(env, "MODALIAS=hsi:%s", dev_name(dev)); env 693 drivers/hv/vmbus_drv.c static int vmbus_uevent(struct device *device, struct kobj_uevent_env *env) env 700 drivers/hv/vmbus_drv.c ret = add_uevent_var(env, "MODALIAS=vmbus:%s", alias_name); env 68 drivers/hwmon/ultra45_env.c static u8 env_read(struct env *p, u8 ireg) env 80 drivers/hwmon/ultra45_env.c static void env_write(struct env *p, u8 ireg, u8 val) env 101 drivers/hwmon/ultra45_env.c struct env *p = dev_get_drvdata(dev); env 120 drivers/hwmon/ultra45_env.c struct env *p = dev_get_drvdata(dev); env 143 drivers/hwmon/ultra45_env.c struct env *p = dev_get_drvdata(dev); env 166 drivers/hwmon/ultra45_env.c struct env *p = dev_get_drvdata(dev); env 187 drivers/hwmon/ultra45_env.c struct env *p = dev_get_drvdata(dev); env 203 drivers/hwmon/ultra45_env.c struct env *p = dev_get_drvdata(dev); env 256 drivers/hwmon/ultra45_env.c struct env *p = devm_kzalloc(&op->dev, sizeof(*p), GFP_KERNEL); env 295 drivers/hwmon/ultra45_env.c struct env *p = platform_get_drvdata(op); env 116 drivers/i2c/i2c-core-base.c static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env) env 121 drivers/i2c/i2c-core-base.c rc = of_device_uevent_modalias(dev, env); env 125 drivers/i2c/i2c-core-base.c rc = acpi_device_uevent_modalias(dev, env); env 129 drivers/i2c/i2c-core-base.c return add_uevent_var(env, "MODALIAS=%s%s", I2C_MODULE_PREFIX, client->name); env 254 drivers/i3c/master.c static int i3c_device_uevent(struct device *dev, struct kobj_uevent_env *env) env 266 drivers/i3c/master.c return add_uevent_var(env, "MODALIAS=i3c:dcr%02Xmanuf%04X", env 269 drivers/i3c/master.c return add_uevent_var(env, env 116 drivers/ide/ide.c static int ide_uevent(struct device *dev, struct kobj_uevent_env *env) env 120 drivers/ide/ide.c add_uevent_var(env, "MEDIA=%s", ide_media_string(drive)); env 121 drivers/ide/ide.c add_uevent_var(env, "DRIVENAME=%s", drive->name); env 122 drivers/ide/ide.c add_uevent_var(env, "MODALIAS=ide:m-%s", ide_media_string(drive)); env 80 drivers/iio/adc/envelope-detector.c static int envelope_detector_comp_latch(struct envelope *env) env 84 drivers/iio/adc/envelope-detector.c spin_lock_irq(&env->comp_lock); env 85 drivers/iio/adc/envelope-detector.c comp = env->comp; env 86 drivers/iio/adc/envelope-detector.c env->comp = 0; env 87 drivers/iio/adc/envelope-detector.c spin_unlock_irq(&env->comp_lock); env 99 drivers/iio/adc/envelope-detector.c enable_irq(env->comp_irq); env 102 drivers/iio/adc/envelope-detector.c synchronize_irq(env->comp_irq); env 105 drivers/iio/adc/envelope-detector.c spin_lock_irq(&env->comp_lock); env 106 drivers/iio/adc/envelope-detector.c comp = env->comp; env 107 drivers/iio/adc/envelope-detector.c env->comp = 0; env 108 drivers/iio/adc/envelope-detector.c spin_unlock_irq(&env->comp_lock); env 111 drivers/iio/adc/envelope-detector.c enable_irq(env->comp_irq); env 118 drivers/iio/adc/envelope-detector.c struct envelope *env = ctx; env 120 drivers/iio/adc/envelope-detector.c spin_lock(&env->comp_lock); env 121 drivers/iio/adc/envelope-detector.c env->comp = 1; env 122 drivers/iio/adc/envelope-detector.c disable_irq_nosync(env->comp_irq); env 123 drivers/iio/adc/envelope-detector.c spin_unlock(&env->comp_lock); env 128 drivers/iio/adc/envelope-detector.c static void envelope_detector_setup_compare(struct envelope *env) env 142 drivers/iio/adc/envelope-detector.c env->level = (env->high + env->low + !env->invert) / 2; env 144 drivers/iio/adc/envelope-detector.c if (env->high == env->low + 1) { env 145 drivers/iio/adc/envelope-detector.c complete(&env->done); env 150 drivers/iio/adc/envelope-detector.c ret = iio_write_channel_raw(env->dac, env->invert ? 0 : env->dac_max); env 155 drivers/iio/adc/envelope-detector.c envelope_detector_comp_latch(env); env 158 drivers/iio/adc/envelope-detector.c ret = iio_write_channel_raw(env->dac, env->level); env 163 drivers/iio/adc/envelope-detector.c schedule_delayed_work(&env->comp_timeout, env 164 drivers/iio/adc/envelope-detector.c msecs_to_jiffies(env->comp_interval)); env 168 drivers/iio/adc/envelope-detector.c env->level = ret; env 169 drivers/iio/adc/envelope-detector.c complete(&env->done); env 174 drivers/iio/adc/envelope-detector.c struct envelope *env = container_of(work, struct envelope, env 178 drivers/iio/adc/envelope-detector.c if (!envelope_detector_comp_latch(env) ^ !env->invert) env 179 drivers/iio/adc/envelope-detector.c env->low = env->level; env 181 drivers/iio/adc/envelope-detector.c env->high = env->level; env 184 drivers/iio/adc/envelope-detector.c envelope_detector_setup_compare(env); env 191 drivers/iio/adc/envelope-detector.c struct envelope *env = iio_priv(indio_dev); env 206 drivers/iio/adc/envelope-detector.c mutex_lock(&env->read_lock); env 207 drivers/iio/adc/envelope-detector.c env->high = env->dac_max + env->invert; env 208 drivers/iio/adc/envelope-detector.c env->low = -1 + env->invert; env 209 drivers/iio/adc/envelope-detector.c envelope_detector_setup_compare(env); env 210 drivers/iio/adc/envelope-detector.c wait_for_completion(&env->done); env 211 drivers/iio/adc/envelope-detector.c if (env->level < 0) { env 212 drivers/iio/adc/envelope-detector.c ret = env->level; env 215 drivers/iio/adc/envelope-detector.c *val = env->invert ? env->dac_max - env->level : env->level; env 216 drivers/iio/adc/envelope-detector.c mutex_unlock(&env->read_lock); env 221 drivers/iio/adc/envelope-detector.c return iio_read_channel_scale(env->dac, val, val2); env 227 drivers/iio/adc/envelope-detector.c mutex_unlock(&env->read_lock); env 235 drivers/iio/adc/envelope-detector.c struct envelope *env = iio_priv(indio_dev); env 237 drivers/iio/adc/envelope-detector.c return sprintf(buf, "%u\n", env->invert); env 245 drivers/iio/adc/envelope-detector.c struct envelope *env = iio_priv(indio_dev); env 256 drivers/iio/adc/envelope-detector.c trigger = invert ? env->comp_irq_trigger_inv : env->comp_irq_trigger; env 258 drivers/iio/adc/envelope-detector.c mutex_lock(&env->read_lock); env 259 drivers/iio/adc/envelope-detector.c if (invert != env->invert) env 260 drivers/iio/adc/envelope-detector.c ret = irq_set_irq_type(env->comp_irq, trigger); env 262 drivers/iio/adc/envelope-detector.c env->invert = invert; env 265 drivers/iio/adc/envelope-detector.c mutex_unlock(&env->read_lock); env 275 drivers/iio/adc/envelope-detector.c struct envelope *env = iio_priv(indio_dev); env 277 drivers/iio/adc/envelope-detector.c return sprintf(buf, "%u\n", env->comp_interval); env 285 drivers/iio/adc/envelope-detector.c struct envelope *env = iio_priv(indio_dev); env 295 drivers/iio/adc/envelope-detector.c mutex_lock(&env->read_lock); env 296 drivers/iio/adc/envelope-detector.c env->comp_interval = interval; env 297 drivers/iio/adc/envelope-detector.c mutex_unlock(&env->read_lock); env 328 drivers/iio/adc/envelope-detector.c struct envelope *env; env 332 drivers/iio/adc/envelope-detector.c indio_dev = devm_iio_device_alloc(dev, sizeof(*env)); env 337 drivers/iio/adc/envelope-detector.c env = iio_priv(indio_dev); env 338 drivers/iio/adc/envelope-detector.c env->comp_interval = 50; /* some sensible default? */ env 340 drivers/iio/adc/envelope-detector.c spin_lock_init(&env->comp_lock); env 341 drivers/iio/adc/envelope-detector.c mutex_init(&env->read_lock); env 342 drivers/iio/adc/envelope-detector.c init_completion(&env->done); env 343 drivers/iio/adc/envelope-detector.c INIT_DELAYED_WORK(&env->comp_timeout, envelope_detector_timeout); env 352 drivers/iio/adc/envelope-detector.c env->dac = devm_iio_channel_get(dev, "dac"); env 353 drivers/iio/adc/envelope-detector.c if (IS_ERR(env->dac)) { env 354 drivers/iio/adc/envelope-detector.c if (PTR_ERR(env->dac) != -EPROBE_DEFER) env 356 drivers/iio/adc/envelope-detector.c return PTR_ERR(env->dac); env 359 drivers/iio/adc/envelope-detector.c env->comp_irq = platform_get_irq_byname(pdev, "comp"); env 360 drivers/iio/adc/envelope-detector.c if (env->comp_irq < 0) env 361 drivers/iio/adc/envelope-detector.c return env->comp_irq; env 363 drivers/iio/adc/envelope-detector.c ret = devm_request_irq(dev, env->comp_irq, envelope_detector_comp_isr, env 364 drivers/iio/adc/envelope-detector.c 0, "envelope-detector", env); env 370 drivers/iio/adc/envelope-detector.c env->comp_irq_trigger = irq_get_trigger_type(env->comp_irq); env 371 drivers/iio/adc/envelope-detector.c if (env->comp_irq_trigger & IRQF_TRIGGER_RISING) env 372 drivers/iio/adc/envelope-detector.c env->comp_irq_trigger_inv |= IRQF_TRIGGER_FALLING; env 373 drivers/iio/adc/envelope-detector.c if (env->comp_irq_trigger & IRQF_TRIGGER_FALLING) env 374 drivers/iio/adc/envelope-detector.c env->comp_irq_trigger_inv |= IRQF_TRIGGER_RISING; env 375 drivers/iio/adc/envelope-detector.c if (env->comp_irq_trigger & IRQF_TRIGGER_HIGH) env 376 drivers/iio/adc/envelope-detector.c env->comp_irq_trigger_inv |= IRQF_TRIGGER_LOW; env 377 drivers/iio/adc/envelope-detector.c if (env->comp_irq_trigger & IRQF_TRIGGER_LOW) env 378 drivers/iio/adc/envelope-detector.c env->comp_irq_trigger_inv |= IRQF_TRIGGER_HIGH; env 380 drivers/iio/adc/envelope-detector.c ret = iio_get_channel_type(env->dac, &type); env 389 drivers/iio/adc/envelope-detector.c ret = iio_read_max_channel_raw(env->dac, &env->dac_max); env 515 drivers/infiniband/core/device.c struct kobj_uevent_env *env) env 517 drivers/infiniband/core/device.c if (add_uevent_var(env, "NAME=%s", dev_name(device))) env 1558 drivers/input/input.c static int input_add_uevent_bm_var(struct kobj_uevent_env *env, env 1563 drivers/input/input.c if (add_uevent_var(env, "%s", name)) env 1566 drivers/input/input.c len = input_print_bitmap(&env->buf[env->buflen - 1], env 1567 drivers/input/input.c sizeof(env->buf) - env->buflen, env 1569 drivers/input/input.c if (len >= (sizeof(env->buf) - env->buflen)) env 1572 drivers/input/input.c env->buflen += len; env 1576 drivers/input/input.c static int input_add_uevent_modalias_var(struct kobj_uevent_env *env, env 1581 drivers/input/input.c if (add_uevent_var(env, "MODALIAS=")) env 1584 drivers/input/input.c len = input_print_modalias(&env->buf[env->buflen - 1], env 1585 drivers/input/input.c sizeof(env->buf) - env->buflen, env 1587 drivers/input/input.c if (len >= (sizeof(env->buf) - env->buflen)) env 1590 drivers/input/input.c env->buflen += len; env 1596 drivers/input/input.c int err = add_uevent_var(env, fmt, val); \ env 1603 drivers/input/input.c int err = input_add_uevent_bm_var(env, name, bm, max); \ env 1610 drivers/input/input.c int err = input_add_uevent_modalias_var(env, dev); \ env 1615 drivers/input/input.c static int input_dev_uevent(struct device *device, struct kobj_uevent_env *env) env 897 drivers/input/serio/serio.c int err = add_uevent_var(env, fmt, val); \ env 902 drivers/input/serio/serio.c static int serio_uevent(struct device *dev, struct kobj_uevent_env *env) env 85 drivers/ipack/ipack.c static int ipack_uevent(struct device *dev, struct kobj_uevent_env *env) env 94 drivers/ipack/ipack.c if (add_uevent_var(env, env 142 drivers/isdn/mISDN/core.c static int mISDN_uevent(struct device *dev, struct kobj_uevent_env *env) env 149 drivers/isdn/mISDN/core.c if (add_uevent_var(env, "nchans=%d", mdev->nrbchan)) env 44 drivers/mcb/mcb-core.c static int mcb_uevent(struct device *dev, struct kobj_uevent_env *env) env 49 drivers/mcb/mcb-core.c ret = add_uevent_var(env, "MODALIAS=mcb:16z%03d", mdev->id); env 947 drivers/md/bcache/super.c char *env[] = { env 957 drivers/md/bcache/super.c kfree(env[1]); env 958 drivers/md/bcache/super.c kfree(env[2]); env 964 drivers/md/bcache/super.c kfree(env[1]); env 965 drivers/md/bcache/super.c kfree(env[2]); env 989 drivers/md/bcache/super.c kobject_uevent_env(&disk_to_dev(d->disk)->kobj, KOBJ_CHANGE, env); env 990 drivers/md/bcache/super.c kfree(env[1]); env 991 drivers/md/bcache/super.c kfree(env[2]); env 286 drivers/md/bcache/sysfs.c struct kobj_uevent_env *env; env 398 drivers/md/bcache/sysfs.c env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL); env 399 drivers/md/bcache/sysfs.c if (!env) env 401 drivers/md/bcache/sysfs.c add_uevent_var(env, "DRIVER=bcache"); env 402 drivers/md/bcache/sysfs.c add_uevent_var(env, "CACHED_UUID=%pU", dc->sb.uuid), env 403 drivers/md/bcache/sysfs.c add_uevent_var(env, "CACHED_LABEL=%s", buf); env 406 drivers/md/bcache/sysfs.c env->envp); env 407 drivers/md/bcache/sysfs.c kfree(env); env 1013 drivers/media/dvb-core/dvbdev.c static int dvb_uevent(struct device *dev, struct kobj_uevent_env *env) env 1017 drivers/media/dvb-core/dvbdev.c add_uevent_var(env, "DVB_ADAPTER_NUM=%d", dvbdev->adapter->num); env 1018 drivers/media/dvb-core/dvbdev.c add_uevent_var(env, "DVB_DEVICE_TYPE=%s", dnames[dvbdev->type]); env 1019 drivers/media/dvb-core/dvbdev.c add_uevent_var(env, "DVB_DEVICE_NUM=%d", dvbdev->id); env 1570 drivers/media/rc/rc-main.c int err = add_uevent_var(env, fmt, val); \ env 1575 drivers/media/rc/rc-main.c static int rc_dev_uevent(struct device *device, struct kobj_uevent_env *env) env 60 drivers/memstick/core/memstick.c static int memstick_uevent(struct device *dev, struct kobj_uevent_env *env) env 65 drivers/memstick/core/memstick.c if (add_uevent_var(env, "MEMSTICK_TYPE=%02X", card->id.type)) env 68 drivers/memstick/core/memstick.c if (add_uevent_var(env, "MEMSTICK_CATEGORY=%02X", card->id.category)) env 71 drivers/memstick/core/memstick.c if (add_uevent_var(env, "MEMSTICK_CLASS=%02X", card->id.class)) env 811 drivers/misc/mei/bus.c static int mei_cl_device_uevent(struct device *dev, struct kobj_uevent_env *env) env 817 drivers/misc/mei/bus.c if (add_uevent_var(env, "MEI_CL_VERSION=%d", version)) env 820 drivers/misc/mei/bus.c if (add_uevent_var(env, "MEI_CL_UUID=%pUl", uuid)) env 823 drivers/misc/mei/bus.c if (add_uevent_var(env, "MEI_CL_NAME=%s", cldev->name)) env 826 drivers/misc/mei/bus.c if (add_uevent_var(env, "MODALIAS=mei:%s:%pUl:%02X:", env 76 drivers/misc/mic/bus/mic_bus.c static int mbus_uevent(struct device *dv, struct kobj_uevent_env *env) env 80 drivers/misc/mic/bus/mic_bus.c return add_uevent_var(env, "MODALIAS=mbus:d%08Xv%08X", env 78 drivers/misc/mic/bus/scif_bus.c static int scif_uevent(struct device *dv, struct kobj_uevent_env *env) env 82 drivers/misc/mic/bus/scif_bus.c return add_uevent_var(env, "MODALIAS=scif:d%08Xv%08X", env 78 drivers/misc/mic/bus/vop_bus.c static int vop_uevent(struct device *dv, struct kobj_uevent_env *env) env 82 drivers/misc/mic/bus/vop_bus.c return add_uevent_var(env, "MODALIAS=vop:d%08Xv%08X", env 58 drivers/misc/tifm_core.c static int tifm_uevent(struct device *dev, struct kobj_uevent_env *env) env 62 drivers/misc/tifm_core.c if (add_uevent_var(env, "TIFM_CARD_TYPE=%s", tifm_media_type_name(sock->type, 1))) env 67 drivers/mmc/core/bus.c mmc_bus_uevent(struct device *dev, struct kobj_uevent_env *env) env 91 drivers/mmc/core/bus.c retval = add_uevent_var(env, "MMC_TYPE=%s", type); env 96 drivers/mmc/core/bus.c retval = add_uevent_var(env, "MMC_NAME=%s", mmc_card_name(card)); env 104 drivers/mmc/core/bus.c retval = add_uevent_var(env, "MODALIAS=mmc:block"); env 106 drivers/mmc/core/sdio_bus.c sdio_bus_uevent(struct device *dev, struct kobj_uevent_env *env) env 110 drivers/mmc/core/sdio_bus.c if (add_uevent_var(env, env 114 drivers/mmc/core/sdio_bus.c if (add_uevent_var(env, env 118 drivers/mmc/core/sdio_bus.c if (add_uevent_var(env, env 56 drivers/mtd/maps/pmcmsp-flash.c char *env; env 70 drivers/mtd/maps/pmcmsp-flash.c for (fcnt = 0; (env = prom_getenv(flash_name)); fcnt++) env 95 drivers/mtd/maps/pmcmsp-flash.c for (pcnt = 0; (env = prom_getenv(part_name)); pcnt++) env 111 drivers/mtd/maps/pmcmsp-flash.c env = prom_getenv(flash_name); env 113 drivers/mtd/maps/pmcmsp-flash.c if (sscanf(env, "%x:%x", &addr, &size) < 2) { env 153 drivers/mtd/maps/pmcmsp-flash.c env = prom_getenv(part_name); env 155 drivers/mtd/maps/pmcmsp-flash.c if (sscanf(env, "%x:%x:%n", &offset, &size, env 166 drivers/mtd/maps/pmcmsp-flash.c msp_parts[i][j].name = env + coff; env 564 drivers/net/ethernet/netronome/nfp/bpf/main.h int nfp_verify_insn(struct bpf_verifier_env *env, int insn_idx, env 566 drivers/net/ethernet/netronome/nfp/bpf/main.h int nfp_bpf_finalize(struct bpf_verifier_env *env); env 568 drivers/net/ethernet/netronome/nfp/bpf/main.h int nfp_bpf_opt_replace_insn(struct bpf_verifier_env *env, u32 off, env 570 drivers/net/ethernet/netronome/nfp/bpf/main.h int nfp_bpf_opt_remove_insns(struct bpf_verifier_env *env, u32 off, u32 cnt); env 16 drivers/net/ethernet/netronome/nfp/bpf/verifier.c #define pr_vlog(env, fmt, ...) \ env 17 drivers/net/ethernet/netronome/nfp/bpf/verifier.c bpf_verifier_log_write(env, "[nfp] " fmt, ##__VA_ARGS__) env 83 drivers/net/ethernet/netronome/nfp/bpf/verifier.c static bool nfp_bpf_map_update_value_ok(struct bpf_verifier_env *env) env 85 drivers/net/ethernet/netronome/nfp/bpf/verifier.c const struct bpf_reg_state *reg1 = cur_regs(env) + BPF_REG_1; env 86 drivers/net/ethernet/netronome/nfp/bpf/verifier.c const struct bpf_reg_state *reg3 = cur_regs(env) + BPF_REG_3; env 92 drivers/net/ethernet/netronome/nfp/bpf/verifier.c state = env->cur_state->frame[reg3->frameno]; env 113 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "value at offset %d/%d may be non-zero, bpf_map_update_elem() is required to initialize atomic counters to zero to avoid offload endian issues\n", env 124 drivers/net/ethernet/netronome/nfp/bpf/verifier.c nfp_bpf_stack_arg_ok(const char *fname, struct bpf_verifier_env *env, env 131 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "%s: unsupported ptr type %d\n", env 136 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "%s: variable pointer\n", fname); env 142 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "%s: unaligned stack pointer %lld\n", fname, -off); env 157 drivers/net/ethernet/netronome/nfp/bpf/verifier.c nfp_bpf_map_call_ok(const char *fname, struct bpf_verifier_env *env, env 162 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "%s: not supported by FW\n", fname); env 171 drivers/net/ethernet/netronome/nfp/bpf/verifier.c struct bpf_verifier_env *env, env 174 drivers/net/ethernet/netronome/nfp/bpf/verifier.c const struct bpf_reg_state *reg1 = cur_regs(env) + BPF_REG_1; env 175 drivers/net/ethernet/netronome/nfp/bpf/verifier.c const struct bpf_reg_state *reg2 = cur_regs(env) + BPF_REG_2; env 176 drivers/net/ethernet/netronome/nfp/bpf/verifier.c const struct bpf_reg_state *reg3 = cur_regs(env) + BPF_REG_3; env 183 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "adjust_head not supported by FW\n"); env 187 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "adjust_head: FW requires shifting metadata, not supported by the driver\n"); env 196 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "adjust_tail not supported by FW\n"); env 202 drivers/net/ethernet/netronome/nfp/bpf/verifier.c if (!nfp_bpf_map_call_ok("map_lookup", env, meta, env 204 drivers/net/ethernet/netronome/nfp/bpf/verifier.c !nfp_bpf_stack_arg_ok("map_lookup", env, reg2, env 210 drivers/net/ethernet/netronome/nfp/bpf/verifier.c if (!nfp_bpf_map_call_ok("map_update", env, meta, env 212 drivers/net/ethernet/netronome/nfp/bpf/verifier.c !nfp_bpf_stack_arg_ok("map_update", env, reg2, env 214 drivers/net/ethernet/netronome/nfp/bpf/verifier.c !nfp_bpf_stack_arg_ok("map_update", env, reg3, NULL) || env 215 drivers/net/ethernet/netronome/nfp/bpf/verifier.c !nfp_bpf_map_update_value_ok(env)) env 220 drivers/net/ethernet/netronome/nfp/bpf/verifier.c if (!nfp_bpf_map_call_ok("map_delete", env, meta, env 222 drivers/net/ethernet/netronome/nfp/bpf/verifier.c !nfp_bpf_stack_arg_ok("map_delete", env, reg2, env 230 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "bpf_get_prandom_u32(): FW doesn't support random number generation\n"); env 240 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "event_output: not supported by FW\n"); env 253 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "event_output: must use BPF_F_CURRENT_CPU, var_off: %s\n", env 261 drivers/net/ethernet/netronome/nfp/bpf/verifier.c reg1 = cur_regs(env) + BPF_REG_4; env 267 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "event_output: unsupported ptr type: %d\n", env 273 drivers/net/ethernet/netronome/nfp/bpf/verifier.c !nfp_bpf_stack_arg_ok("event_output", env, reg1, NULL)) env 286 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "warning: return codes and behavior of event_output helper differ for offload!\n"); env 292 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "event_output: ptr type changed: %d %d\n", env 299 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "unsupported function id: %d\n", func_id); env 312 drivers/net/ethernet/netronome/nfp/bpf/verifier.c struct bpf_verifier_env *env) env 314 drivers/net/ethernet/netronome/nfp/bpf/verifier.c const struct bpf_reg_state *reg0 = cur_regs(env) + BPF_REG_0; env 324 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "unsupported exit state: %d, var_off: %s\n", env 334 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "unsupported exit state: %d, imm: %llx\n", env 346 drivers/net/ethernet/netronome/nfp/bpf/verifier.c struct bpf_verifier_env *env) env 350 drivers/net/ethernet/netronome/nfp/bpf/verifier.c if (reg->frameno != env->cur_state->curframe) env 354 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "variable ptr stack access\n"); env 372 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "stack access changed location was:%d is:%d\n", env 392 drivers/net/ethernet/netronome/nfp/bpf/verifier.c nfp_bpf_map_mark_used_one(struct bpf_verifier_env *env, env 398 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "map value use type conflict %s vs %s off: %u\n", env 406 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "atomic counter in map value may already be initialized to non-zero value off: %u\n", env 417 drivers/net/ethernet/netronome/nfp/bpf/verifier.c nfp_bpf_map_mark_used(struct bpf_verifier_env *env, struct nfp_insn_meta *meta, env 427 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "map value offset is variable\n"); env 437 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "map value access out-of-bounds\n"); env 442 drivers/net/ethernet/netronome/nfp/bpf/verifier.c err = nfp_bpf_map_mark_used_one(env, nfp_map, off + i, use); env 452 drivers/net/ethernet/netronome/nfp/bpf/verifier.c struct bpf_verifier_env *env, u8 reg_no) env 454 drivers/net/ethernet/netronome/nfp/bpf/verifier.c const struct bpf_reg_state *reg = cur_regs(env) + reg_no; env 461 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "unsupported ptr type: %d\n", reg->type); env 466 drivers/net/ethernet/netronome/nfp/bpf/verifier.c err = nfp_bpf_check_stack_access(nfp_prog, meta, reg, env); env 473 drivers/net/ethernet/netronome/nfp/bpf/verifier.c err = nfp_bpf_map_mark_used(env, meta, reg, env 479 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "map writes not supported\n"); env 483 drivers/net/ethernet/netronome/nfp/bpf/verifier.c err = nfp_bpf_map_mark_used(env, meta, reg, env 491 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "ptr type changed for instruction %d -> %d\n", env 503 drivers/net/ethernet/netronome/nfp/bpf/verifier.c struct bpf_verifier_env *env) env 505 drivers/net/ethernet/netronome/nfp/bpf/verifier.c const struct bpf_reg_state *reg = cur_regs(env) + meta->insn.dst_reg; env 514 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "queue selection not supported by FW\n"); env 518 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "unsupported store to context field\n"); env 522 drivers/net/ethernet/netronome/nfp/bpf/verifier.c return nfp_bpf_check_ptr(nfp_prog, meta, env, meta->insn.dst_reg); env 527 drivers/net/ethernet/netronome/nfp/bpf/verifier.c struct bpf_verifier_env *env) env 529 drivers/net/ethernet/netronome/nfp/bpf/verifier.c const struct bpf_reg_state *sreg = cur_regs(env) + meta->insn.src_reg; env 530 drivers/net/ethernet/netronome/nfp/bpf/verifier.c const struct bpf_reg_state *dreg = cur_regs(env) + meta->insn.dst_reg; env 533 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "atomic add not to a map value pointer: %d\n", env 538 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "atomic add not of a scalar: %d\n", sreg->type); env 547 drivers/net/ethernet/netronome/nfp/bpf/verifier.c return nfp_bpf_check_ptr(nfp_prog, meta, env, meta->insn.dst_reg); env 552 drivers/net/ethernet/netronome/nfp/bpf/verifier.c struct bpf_verifier_env *env) env 555 drivers/net/ethernet/netronome/nfp/bpf/verifier.c cur_regs(env) + meta->insn.src_reg; env 557 drivers/net/ethernet/netronome/nfp/bpf/verifier.c cur_regs(env) + meta->insn.dst_reg; env 578 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "multiplier is not within u32 value range\n"); env 582 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "multiplicand is not within u32 value range\n"); env 587 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "sign extended multiplicand won't be within u32 value range\n"); env 604 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "dividend is not within u32 value range\n"); env 609 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "divisor is not constant\n"); env 613 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "divisor is not within u32 value range\n"); env 618 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "divide by negative constant is not supported\n"); env 626 drivers/net/ethernet/netronome/nfp/bpf/verifier.c int nfp_verify_insn(struct bpf_verifier_env *env, int insn_idx, env 629 drivers/net/ethernet/netronome/nfp/bpf/verifier.c struct nfp_prog *nfp_prog = env->prog->aux->offload->dev_priv; env 636 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "instruction %#02x not supported\n", env 643 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "program uses extended registers - jit hardening?\n"); env 648 drivers/net/ethernet/netronome/nfp/bpf/verifier.c return nfp_bpf_check_helper_call(nfp_prog, env, meta); env 650 drivers/net/ethernet/netronome/nfp/bpf/verifier.c return nfp_bpf_check_exit(nfp_prog, env); env 653 drivers/net/ethernet/netronome/nfp/bpf/verifier.c return nfp_bpf_check_ptr(nfp_prog, meta, env, env 656 drivers/net/ethernet/netronome/nfp/bpf/verifier.c return nfp_bpf_check_store(nfp_prog, meta, env); env 659 drivers/net/ethernet/netronome/nfp/bpf/verifier.c return nfp_bpf_check_xadd(nfp_prog, meta, env); env 662 drivers/net/ethernet/netronome/nfp/bpf/verifier.c return nfp_bpf_check_alu(nfp_prog, meta, env); env 668 drivers/net/ethernet/netronome/nfp/bpf/verifier.c nfp_assign_subprog_idx_and_regs(struct bpf_verifier_env *env, env 685 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "BUG: number of processed BPF functions is not consistent (processed %d, expected %d)\n", env 758 drivers/net/ethernet/netronome/nfp/bpf/verifier.c int nfp_bpf_finalize(struct bpf_verifier_env *env) env 766 drivers/net/ethernet/netronome/nfp/bpf/verifier.c nfp_prog = env->prog->aux->offload->dev_priv; env 767 drivers/net/ethernet/netronome/nfp/bpf/verifier.c nfp_prog->subprog_cnt = env->subprog_cnt; env 773 drivers/net/ethernet/netronome/nfp/bpf/verifier.c nfp_assign_subprog_idx_and_regs(env, nfp_prog); env 775 drivers/net/ethernet/netronome/nfp/bpf/verifier.c info = env->subprog_info; env 789 drivers/net/ethernet/netronome/nfp/bpf/verifier.c nn = netdev_priv(env->prog->aux->offload->netdev); env 793 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "stack too large: program %dB > FW stack %dB\n", env 798 drivers/net/ethernet/netronome/nfp/bpf/verifier.c nfp_bpf_insn_flag_zext(nfp_prog, env->insn_aux_data); env 802 drivers/net/ethernet/netronome/nfp/bpf/verifier.c int nfp_bpf_opt_replace_insn(struct bpf_verifier_env *env, u32 off, env 805 drivers/net/ethernet/netronome/nfp/bpf/verifier.c struct nfp_prog *nfp_prog = env->prog->aux->offload->dev_priv; env 806 drivers/net/ethernet/netronome/nfp/bpf/verifier.c struct bpf_insn_aux_data *aux_data = env->insn_aux_data; env 823 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "branch hard wire at %d changes target %d -> %d\n", env 831 drivers/net/ethernet/netronome/nfp/bpf/verifier.c pr_vlog(env, "unsupported instruction replacement %hhx -> %hhx\n", env 836 drivers/net/ethernet/netronome/nfp/bpf/verifier.c int nfp_bpf_opt_remove_insns(struct bpf_verifier_env *env, u32 off, u32 cnt) env 838 drivers/net/ethernet/netronome/nfp/bpf/verifier.c struct nfp_prog *nfp_prog = env->prog->aux->offload->dev_priv; env 839 drivers/net/ethernet/netronome/nfp/bpf/verifier.c struct bpf_insn_aux_data *aux_data = env->insn_aux_data; env 26 drivers/net/netdevsim/bpf.c #define pr_vlog(env, fmt, ...) \ env 27 drivers/net/netdevsim/bpf.c bpf_verifier_log_write(env, "[netdevsim] " fmt, ##__VA_ARGS__) env 63 drivers/net/netdevsim/bpf.c nsim_bpf_verify_insn(struct bpf_verifier_env *env, int insn_idx, int prev_insn) env 67 drivers/net/netdevsim/bpf.c state = env->prog->aux->offload->dev_priv; env 71 drivers/net/netdevsim/bpf.c if (insn_idx == env->prog->len - 1) env 72 drivers/net/netdevsim/bpf.c pr_vlog(env, "Hello from netdevsim!\n"); env 77 drivers/net/netdevsim/bpf.c static int nsim_bpf_finalize(struct bpf_verifier_env *env) env 716 drivers/net/phy/mdio_bus.c static int mdio_uevent(struct device *dev, struct kobj_uevent_env *env) env 721 drivers/net/phy/mdio_bus.c rc = of_device_uevent_modalias(dev, env); env 383 drivers/net/xen-netback/xenbus.c struct kobj_uevent_env *env) env 390 drivers/net/xen-netback/xenbus.c if (add_uevent_var(env, "script=%s", be->hotplug_script)) env 396 drivers/net/xen-netback/xenbus.c return add_uevent_var(env, "vif=%s", be->vif->dev->name); env 48 drivers/nvdimm/bus.c static int nvdimm_bus_uevent(struct device *dev, struct kobj_uevent_env *env) env 50 drivers/nvdimm/bus.c return add_uevent_var(env, "MODALIAS=" ND_DEVICE_MODALIAS_FMT, env 3795 drivers/nvme/host/core.c static int nvme_class_uevent(struct device *dev, struct kobj_uevent_env *env) env 3802 drivers/nvme/host/core.c ret = add_uevent_var(env, "NVME_TRTYPE=%s", ctrl->ops->name); env 3807 drivers/nvme/host/core.c ret = add_uevent_var(env, "NVME_TRADDR=%s", opts->traddr); env 3811 drivers/nvme/host/core.c ret = add_uevent_var(env, "NVME_TRSVCID=%s", env 3816 drivers/nvme/host/core.c ret = add_uevent_var(env, "NVME_HOST_TRADDR=%s", env 282 drivers/of/device.c void of_device_uevent(struct device *dev, struct kobj_uevent_env *env) env 292 drivers/of/device.c add_uevent_var(env, "OF_NAME=%pOFn", dev->of_node); env 293 drivers/of/device.c add_uevent_var(env, "OF_FULLNAME=%pOF", dev->of_node); env 296 drivers/of/device.c add_uevent_var(env, "OF_TYPE=%s", type); env 302 drivers/of/device.c add_uevent_var(env, "OF_COMPATIBLE_%d=%s", seen, compat); env 305 drivers/of/device.c add_uevent_var(env, "OF_COMPATIBLE_N=%d", seen); env 311 drivers/of/device.c add_uevent_var(env, "OF_ALIAS_%d=%s", seen, env 319 drivers/of/device.c int of_device_uevent_modalias(struct device *dev, struct kobj_uevent_env *env) env 327 drivers/of/device.c if (add_uevent_var(env, "MODALIAS=")) env 330 drivers/of/device.c sl = of_device_get_modalias(dev, &env->buf[env->buflen-1], env 331 drivers/of/device.c sizeof(env->buf) - env->buflen); env 332 drivers/of/device.c if (sl >= (sizeof(env->buf) - env->buflen)) env 334 drivers/of/device.c env->buflen += sl; env 1555 drivers/pci/pci-driver.c static int pci_uevent(struct device *dev, struct kobj_uevent_env *env) env 1564 drivers/pci/pci-driver.c if (add_uevent_var(env, "PCI_CLASS=%04X", pdev->class)) env 1567 drivers/pci/pci-driver.c if (add_uevent_var(env, "PCI_ID=%04X:%04X", pdev->vendor, pdev->device)) env 1570 drivers/pci/pci-driver.c if (add_uevent_var(env, "PCI_SUBSYS_ID=%04X:%04X", pdev->subsystem_vendor, env 1574 drivers/pci/pci-driver.c if (add_uevent_var(env, "PCI_SLOT_NAME=%s", pci_name(pdev))) env 1577 drivers/pci/pci-driver.c if (add_uevent_var(env, "MODALIAS=pci:v%08Xd%08Xsv%08Xsd%08Xbc%02Xsc%02Xi%02X", env 816 drivers/pcmcia/cs.c struct kobj_uevent_env *env) env 820 drivers/pcmcia/cs.c if (add_uevent_var(env, "SOCKET_NO=%u", s->sock)) env 935 drivers/pcmcia/ds.c static int pcmcia_bus_uevent(struct device *dev, struct kobj_uevent_env *env) env 953 drivers/pcmcia/ds.c if (add_uevent_var(env, "SOCKET_NO=%u", p_dev->socket->sock)) env 956 drivers/pcmcia/ds.c if (add_uevent_var(env, "DEVICE_NO=%02X", p_dev->device_no)) env 959 drivers/pcmcia/ds.c if (add_uevent_var(env, "MODALIAS=pcmcia:m%04Xc%04Xf%02Xfn%02Xpfn%02X" env 522 drivers/platform/x86/asus-wmi.c static int kbd_led_read(struct asus_wmi *asus, int *level, int *env) env 544 drivers/platform/x86/asus-wmi.c if (env) env 545 drivers/platform/x86/asus-wmi.c *env = (retval >> 8) & 0x7F; env 766 drivers/platform/x86/wmi.c static int wmi_dev_uevent(struct device *dev, struct kobj_uevent_env *env) env 770 drivers/platform/x86/wmi.c if (add_uevent_var(env, "MODALIAS=wmi:%pUL", wblock->gblock.guid)) env 773 drivers/platform/x86/wmi.c if (add_uevent_var(env, "WMI_GUID=%pUL", wblock->gblock.guid)) env 19 drivers/power/supply/power_supply.h extern int power_supply_uevent(struct device *dev, struct kobj_uevent_env *env); env 382 drivers/power/supply/power_supply_sysfs.c int power_supply_uevent(struct device *dev, struct kobj_uevent_env *env) env 394 drivers/power/supply/power_supply_sysfs.c ret = add_uevent_var(env, "POWER_SUPPLY_NAME=%s", psy->desc->name); env 429 drivers/power/supply/power_supply_sysfs.c ret = add_uevent_var(env, "POWER_SUPPLY_%s=%s", attrname, prop_buf); env 208 drivers/rapidio/rio-driver.c static int rio_uevent(struct device *dev, struct kobj_uevent_env *env) env 219 drivers/rapidio/rio-driver.c if (add_uevent_var(env, "MODALIAS=rapidio:v%04Xd%04Xav%04Xad%04X", env 424 drivers/rpmsg/rpmsg_core.c static int rpmsg_uevent(struct device *dev, struct kobj_uevent_env *env) env 429 drivers/rpmsg/rpmsg_core.c ret = of_device_uevent_modalias(dev, env); env 433 drivers/rpmsg/rpmsg_core.c return add_uevent_var(env, "MODALIAS=" RPMSG_DEVICE_MODALIAS_FMT, env 1452 drivers/s390/cio/css.c static int css_uevent(struct device *dev, struct kobj_uevent_env *env) env 1457 drivers/s390/cio/css.c ret = add_uevent_var(env, "ST=%01X", sch->st); env 1460 drivers/s390/cio/css.c ret = add_uevent_var(env, "MODALIAS=css:t%01X", sch->st); env 104 drivers/s390/cio/device.c static int ccw_uevent(struct device *dev, struct kobj_uevent_env *env) env 112 drivers/s390/cio/device.c ret = add_uevent_var(env, "CU_TYPE=%04X", id->cu_type); env 117 drivers/s390/cio/device.c ret = add_uevent_var(env, "CU_MODEL=%02X", id->cu_model); env 123 drivers/s390/cio/device.c ret = add_uevent_var(env, "DEV_TYPE=%04X", id->dev_type); env 128 drivers/s390/cio/device.c ret = add_uevent_var(env, "DEV_MODEL=%02X", id->dev_model); env 134 drivers/s390/cio/device.c ret = add_uevent_var(env, "MODALIAS=%s", modalias_buf); env 39 drivers/s390/cio/scm.c static int scmdev_uevent(struct device *dev, struct kobj_uevent_env *env) env 41 drivers/s390/cio/scm.c return add_uevent_var(env, "MODALIAS=scm:scmdev"); env 571 drivers/s390/crypto/ap_bus.c static int ap_uevent(struct device *dev, struct kobj_uevent_env *env) env 580 drivers/s390/crypto/ap_bus.c retval = add_uevent_var(env, "DEV_TYPE=%04X", ap_dev->device_type); env 585 drivers/s390/crypto/ap_bus.c retval = add_uevent_var(env, "MODALIAS=ap:t%02X", ap_dev->device_type); env 1106 drivers/s390/net/qeth_l2_main.c char *env[8]; env 1114 drivers/s390/net/qeth_l2_main.c env[i] = str[i]; i++; env 1118 drivers/s390/net/qeth_l2_main.c env[i] = str[i]; i++; env 1123 drivers/s390/net/qeth_l2_main.c env[i] = str[i]; i++; env 1127 drivers/s390/net/qeth_l2_main.c env[i] = str[i]; i++; env 1129 drivers/s390/net/qeth_l2_main.c env[i] = str[i]; i++; env 1132 drivers/s390/net/qeth_l2_main.c env[i] = str[i]; i++; env 1134 drivers/s390/net/qeth_l2_main.c env[i] = str[i]; i++; env 1138 drivers/s390/net/qeth_l2_main.c env[i] = str[i]; i++; env 1142 drivers/s390/net/qeth_l2_main.c env[i] = str[i]; i++; env 1145 drivers/s390/net/qeth_l2_main.c env[i] = NULL; env 1146 drivers/s390/net/qeth_l2_main.c kobject_uevent_env(&card->gdev->dev.kobj, KOBJ_CHANGE, env); env 1164 drivers/s390/net/qeth_l2_main.c char *env[] = { env 1189 drivers/s390/net/qeth_l2_main.c KOBJ_CHANGE, env); env 512 drivers/scsi/scsi_sysfs.c static int scsi_bus_uevent(struct device *dev, struct kobj_uevent_env *env) env 521 drivers/scsi/scsi_sysfs.c add_uevent_var(env, "MODALIAS=" SCSI_DEVICE_MODALIAS_FMT, sdev->type); env 765 drivers/sh/maple/maple.c struct kobj_uevent_env *env) env 98 drivers/slimbus/core.c static int slim_device_uevent(struct device *dev, struct kobj_uevent_env *env) env 102 drivers/slimbus/core.c return add_uevent_var(env, "MODALIAS=slim:%s", dev_name(&sbdev->dev)); env 236 drivers/soc/qcom/apr.c static int apr_uevent(struct device *dev, struct kobj_uevent_env *env) env 241 drivers/soc/qcom/apr.c ret = of_device_uevent_modalias(dev, env); env 245 drivers/soc/qcom/apr.c return add_uevent_var(env, "MODALIAS=apr:%s", adev->name); env 50 drivers/soundwire/bus_type.c static int sdw_uevent(struct device *dev, struct kobj_uevent_env *env) env 57 drivers/soundwire/bus_type.c if (add_uevent_var(env, "MODALIAS=%s", modalias)) env 365 drivers/spi/spi.c static int spi_uevent(struct device *dev, struct kobj_uevent_env *env) env 370 drivers/spi/spi.c rc = acpi_device_uevent_modalias(dev, env); env 374 drivers/spi/spi.c return add_uevent_var(env, "MODALIAS=%s%s", SPI_MODULE_PREFIX, spi->modalias); env 360 drivers/spmi/spmi.c static int spmi_drv_uevent(struct device *dev, struct kobj_uevent_env *env) env 364 drivers/spmi/spmi.c ret = of_device_uevent_modalias(dev, env); env 341 drivers/ssb/main.c static int ssb_device_uevent(struct device *dev, struct kobj_uevent_env *env) env 348 drivers/ssb/main.c return add_uevent_var(env, env 74 drivers/staging/greybus/gbphy.c static int gbphy_dev_uevent(struct device *dev, struct kobj_uevent_env *env) env 83 drivers/staging/greybus/gbphy.c if (add_uevent_var(env, "BUS=%u", hd->bus_id)) env 85 drivers/staging/greybus/gbphy.c if (add_uevent_var(env, "MODULE=%u", module->module_id)) env 87 drivers/staging/greybus/gbphy.c if (add_uevent_var(env, "INTERFACE=%u", intf->interface_id)) env 89 drivers/staging/greybus/gbphy.c if (add_uevent_var(env, "GREYBUS_ID=%08x/%08x", env 92 drivers/staging/greybus/gbphy.c if (add_uevent_var(env, "BUNDLE=%u", gbphy_dev->bundle->id)) env 94 drivers/staging/greybus/gbphy.c if (add_uevent_var(env, "BUNDLE_CLASS=%02x", bundle->class)) env 96 drivers/staging/greybus/gbphy.c if (add_uevent_var(env, "GBPHY=%u", gbphy_dev->id)) env 98 drivers/staging/greybus/gbphy.c if (add_uevent_var(env, "PROTOCOL_ID=%02x", cport_desc->protocol_id)) env 1745 drivers/staging/media/ipu3/ipu3-css.c struct v4l2_rect *const env = &r[IPU3_CSS_RECT_ENVELOPE]; env 1830 drivers/staging/media/ipu3/ipu3-css.c env->width = s < MIN_ENVELOPE ? MIN_ENVELOPE : s; env 1832 drivers/staging/media/ipu3/ipu3-css.c env->height = s < MIN_ENVELOPE ? MIN_ENVELOPE : s; env 1063 drivers/tee/tee_core.c struct kobj_uevent_env *env) env 1067 drivers/tee/tee_core.c return add_uevent_var(env, "MODALIAS=tee:%pUb", dev_id); env 715 drivers/thunderbolt/xdomain.c static int tb_service_uevent(struct device *dev, struct kobj_uevent_env *env) env 721 drivers/thunderbolt/xdomain.c return add_uevent_var(env, "MODALIAS=%s", modalias); env 44 drivers/tty/serdev/core.c static int serdev_device_uevent(struct device *dev, struct kobj_uevent_env *env) env 50 drivers/tty/serdev/core.c rc = acpi_device_uevent_modalias(dev, env); env 54 drivers/tty/serdev/core.c return of_device_uevent_modalias(dev, env); env 54 drivers/usb/common/ulpi.c static int ulpi_uevent(struct device *dev, struct kobj_uevent_env *env) env 59 drivers/usb/common/ulpi.c ret = of_device_uevent_modalias(dev, env); env 63 drivers/usb/common/ulpi.c if (add_uevent_var(env, "MODALIAS=ulpi:v%04xp%04x", env 829 drivers/usb/core/driver.c static int usb_uevent(struct device *dev, struct kobj_uevent_env *env) env 854 drivers/usb/core/driver.c if (add_uevent_var(env, "PRODUCT=%x/%x/%x", env 861 drivers/usb/core/driver.c if (add_uevent_var(env, "TYPE=%d/%d/%d", env 2341 drivers/usb/core/hcd.c static char *env[] = { env 2347 drivers/usb/core/hcd.c kobject_uevent_env(&hcd->self.root_hub->dev.kobj, KOBJ_OFFLINE, env); env 1677 drivers/usb/core/message.c static int usb_if_uevent(struct device *dev, struct kobj_uevent_env *env) env 1687 drivers/usb/core/message.c if (add_uevent_var(env, "INTERFACE=%d/%d/%d", env 1693 drivers/usb/core/message.c if (add_uevent_var(env, env 428 drivers/usb/core/usb.c static int usb_dev_uevent(struct device *dev, struct kobj_uevent_env *env) env 434 drivers/usb/core/usb.c if (add_uevent_var(env, "BUSNUM=%03d", usb_dev->bus->busnum)) env 437 drivers/usb/core/usb.c if (add_uevent_var(env, "DEVNUM=%03d", usb_dev->devnum)) env 1578 drivers/usb/gadget/udc/core.c static int usb_udc_uevent(struct device *dev, struct kobj_uevent_env *env) env 1583 drivers/usb/gadget/udc/core.c ret = add_uevent_var(env, "USB_UDC_NAME=%s", udc->gadget->name); env 1590 drivers/usb/gadget/udc/core.c ret = add_uevent_var(env, "USB_UDC_DRIVER=%s", env 245 drivers/usb/roles/class.c usb_role_switch_uevent(struct device *dev, struct kobj_uevent_env *env) env 249 drivers/usb/roles/class.c ret = add_uevent_var(env, "USB_ROLE_SWITCH=%s", dev_name(dev)); env 316 drivers/usb/typec/bus.c static int typec_uevent(struct device *dev, struct kobj_uevent_env *env) env 320 drivers/usb/typec/bus.c if (add_uevent_var(env, "SVID=%04X", altmode->svid)) env 323 drivers/usb/typec/bus.c if (add_uevent_var(env, "MODE=%u", altmode->mode)) env 326 drivers/usb/typec/bus.c return add_uevent_var(env, "MODALIAS=typec:id%04Xm%02X", env 1262 drivers/usb/typec/class.c static int typec_uevent(struct device *dev, struct kobj_uevent_env *env) env 1266 drivers/usb/typec/class.c ret = add_uevent_var(env, "TYPEC_PORT=%s", dev_name(dev)); env 96 drivers/virtio/virtio.c static int virtio_uevent(struct device *_dv, struct kobj_uevent_env *env) env 100 drivers/virtio/virtio.c return add_uevent_var(env, "MODALIAS=virtio:d%08Xv%08X", env 112 drivers/visorbus/visorbus_main.c static int visorbus_uevent(struct device *xdev, struct kobj_uevent_env *env) env 119 drivers/visorbus/visorbus_main.c return add_uevent_var(env, "MODALIAS=visorbus:%pUl", guid); env 171 drivers/w1/w1.c static int w1_uevent(struct device *dev, struct kobj_uevent_env *env); env 578 drivers/w1/w1.c static int w1_uevent(struct device *dev, struct kobj_uevent_env *env) env 604 drivers/w1/w1.c err = add_uevent_var(env, "W1_FID=%02X", sl->reg_num.family); env 608 drivers/w1/w1.c err = add_uevent_var(env, "W1_SLAVE_ID=%024LX", env 1174 drivers/xen/pvcalls-back.c struct kobj_uevent_env *env) env 96 drivers/xen/xenbus/xenbus_probe_backend.c struct kobj_uevent_env *env) env 110 drivers/xen/xenbus/xenbus_probe_backend.c if (add_uevent_var(env, "MODALIAS=xen-backend:%s", xdev->devicetype)) env 114 drivers/xen/xenbus/xenbus_probe_backend.c if (add_uevent_var(env, "XENBUS_TYPE=%s", xdev->devicetype)) env 117 drivers/xen/xenbus/xenbus_probe_backend.c if (add_uevent_var(env, "XENBUS_PATH=%s", xdev->nodename)) env 120 drivers/xen/xenbus/xenbus_probe_backend.c if (add_uevent_var(env, "XENBUS_BASE_PATH=%s", bus->root)) env 126 drivers/xen/xenbus/xenbus_probe_backend.c return drv->uevent(xdev, env); env 78 drivers/xen/xenbus/xenbus_probe_frontend.c struct kobj_uevent_env *env) env 82 drivers/xen/xenbus/xenbus_probe_frontend.c if (add_uevent_var(env, "MODALIAS=xen:%s", dev->devicetype)) env 145 drivers/zorro/zorro-driver.c static int zorro_uevent(struct device *dev, struct kobj_uevent_env *env) env 156 drivers/zorro/zorro-driver.c if (add_uevent_var(env, "ZORRO_ID=%08X", z->id) || env 157 drivers/zorro/zorro-driver.c add_uevent_var(env, "ZORRO_SLOT_NAME=%s", dev_name(dev)) || env 158 drivers/zorro/zorro-driver.c add_uevent_var(env, "ZORRO_SLOT_ADDR=%04X", z->slotaddr) || env 159 drivers/zorro/zorro-driver.c add_uevent_var(env, "MODALIAS=" ZORRO_DEVICE_MODALIAS_FMT, z->id)) env 229 fs/dlm/lockspace.c struct kobj_uevent_env *env) env 233 fs/dlm/lockspace.c add_uevent_var(env, "LOCKSPACE=%s", ls->ls_name); env 698 fs/gfs2/sys.c struct kobj_uevent_env *env) env 703 fs/gfs2/sys.c add_uevent_var(env, "LOCKTABLE=%s", sdp->sd_table_name); env 704 fs/gfs2/sys.c add_uevent_var(env, "LOCKPROTO=%s", sdp->sd_proto_name); env 706 fs/gfs2/sys.c add_uevent_var(env, "JOURNALID=%d", sdp->sd_lockstruct.ls_jid); env 708 fs/gfs2/sys.c add_uevent_var(env, "UUID=%pUB", &s->s_uuid); env 829 include/linux/acpi.h struct kobj_uevent_env *env) env 329 include/linux/bpf.h int (*insn_hook)(struct bpf_verifier_env *env, env 331 include/linux/bpf.h int (*finalize)(struct bpf_verifier_env *env); env 333 include/linux/bpf.h int (*replace_insn)(struct bpf_verifier_env *env, u32 off, env 335 include/linux/bpf.h int (*remove_insns)(struct bpf_verifier_env *env, u32 off, u32 cnt); env 398 include/linux/bpf_verifier.h __printf(2, 3) void bpf_verifier_log_write(struct bpf_verifier_env *env, env 401 include/linux/bpf_verifier.h static inline struct bpf_func_state *cur_func(struct bpf_verifier_env *env) env 403 include/linux/bpf_verifier.h struct bpf_verifier_state *cur = env->cur_state; env 408 include/linux/bpf_verifier.h static inline struct bpf_reg_state *cur_regs(struct bpf_verifier_env *env) env 410 include/linux/bpf_verifier.h return cur_func(env)->regs; env 414 include/linux/bpf_verifier.h int bpf_prog_offload_verify_insn(struct bpf_verifier_env *env, env 416 include/linux/bpf_verifier.h int bpf_prog_offload_finalize(struct bpf_verifier_env *env); env 418 include/linux/bpf_verifier.h bpf_prog_offload_replace_insn(struct bpf_verifier_env *env, u32 off, env 421 include/linux/bpf_verifier.h bpf_prog_offload_remove_insns(struct bpf_verifier_env *env, u32 off, u32 cnt); env 124 include/linux/device.h int (*uevent)(struct device *dev, struct kobj_uevent_env *env); env 581 include/linux/device.h int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env); env 796 include/linux/device.h int (*uevent)(struct device *dev, struct kobj_uevent_env *env); env 161 include/linux/kobject.h struct kobj_uevent_env *env); env 246 include/linux/kobject.h int add_uevent_var(struct kobj_uevent_env *env, const char *format, ...); env 41 include/linux/of_device.h extern void of_device_uevent(struct device *dev, struct kobj_uevent_env *env); env 42 include/linux/of_device.h extern int of_device_uevent_modalias(struct device *dev, struct kobj_uevent_env *env); env 70 include/linux/of_device.h struct kobj_uevent_env *env) { } env 89 include/linux/of_device.h struct kobj_uevent_env *env) env 280 kernel/bpf/btf.c s32 (*check_meta)(struct btf_verifier_env *env, env 283 kernel/bpf/btf.c int (*resolve)(struct btf_verifier_env *env, env 285 kernel/bpf/btf.c int (*check_member)(struct btf_verifier_env *env, env 289 kernel/bpf/btf.c int (*check_kflag_member)(struct btf_verifier_env *env, env 293 kernel/bpf/btf.c void (*log_details)(struct btf_verifier_env *env, env 303 kernel/bpf/btf.c static int btf_resolve(struct btf_verifier_env *env, env 674 kernel/bpf/btf.c __printf(2, 3) static void btf_verifier_log(struct btf_verifier_env *env, env 677 kernel/bpf/btf.c struct bpf_verifier_log *log = &env->log; env 688 kernel/bpf/btf.c __printf(4, 5) static void __btf_verifier_log_type(struct btf_verifier_env *env, env 693 kernel/bpf/btf.c struct bpf_verifier_log *log = &env->log; env 695 kernel/bpf/btf.c struct btf *btf = env->btf; env 702 kernel/bpf/btf.c env->log_type_id, env 708 kernel/bpf/btf.c btf_type_ops(t)->log_details(env, t); env 720 kernel/bpf/btf.c #define btf_verifier_log_type(env, t, ...) \ env 721 kernel/bpf/btf.c __btf_verifier_log_type((env), (t), true, __VA_ARGS__) env 722 kernel/bpf/btf.c #define btf_verifier_log_basic(env, t, ...) \ env 723 kernel/bpf/btf.c __btf_verifier_log_type((env), (t), false, __VA_ARGS__) env 726 kernel/bpf/btf.c static void btf_verifier_log_member(struct btf_verifier_env *env, env 731 kernel/bpf/btf.c struct bpf_verifier_log *log = &env->log; env 732 kernel/bpf/btf.c struct btf *btf = env->btf; env 744 kernel/bpf/btf.c if (env->phase != CHECK_META) env 745 kernel/bpf/btf.c btf_verifier_log_type(env, struct_type, NULL); env 770 kernel/bpf/btf.c static void btf_verifier_log_vsi(struct btf_verifier_env *env, env 775 kernel/bpf/btf.c struct bpf_verifier_log *log = &env->log; env 780 kernel/bpf/btf.c if (env->phase != CHECK_META) env 781 kernel/bpf/btf.c btf_verifier_log_type(env, datasec_type, NULL); env 795 kernel/bpf/btf.c static void btf_verifier_log_hdr(struct btf_verifier_env *env, env 798 kernel/bpf/btf.c struct bpf_verifier_log *log = &env->log; env 799 kernel/bpf/btf.c const struct btf *btf = env->btf; env 817 kernel/bpf/btf.c static int btf_add_type(struct btf_verifier_env *env, struct btf_type *t) env 819 kernel/bpf/btf.c struct btf *btf = env->btf; env 832 kernel/bpf/btf.c btf_verifier_log(env, "Exceeded max num of types"); env 921 kernel/bpf/btf.c static int env_resolve_init(struct btf_verifier_env *env) env 923 kernel/bpf/btf.c struct btf *btf = env->btf; env 947 kernel/bpf/btf.c env->visit_states = visit_states; env 958 kernel/bpf/btf.c static void btf_verifier_env_free(struct btf_verifier_env *env) env 960 kernel/bpf/btf.c kvfree(env->visit_states); env 961 kernel/bpf/btf.c kfree(env); env 964 kernel/bpf/btf.c static bool env_type_is_resolve_sink(const struct btf_verifier_env *env, env 967 kernel/bpf/btf.c switch (env->resolve_mode) { env 989 kernel/bpf/btf.c static bool env_type_is_resolved(const struct btf_verifier_env *env, env 992 kernel/bpf/btf.c return env->visit_states[type_id] == RESOLVED; env 995 kernel/bpf/btf.c static int env_stack_push(struct btf_verifier_env *env, env 1000 kernel/bpf/btf.c if (env->top_stack == MAX_RESOLVE_DEPTH) env 1003 kernel/bpf/btf.c if (env->visit_states[type_id] != NOT_VISITED) env 1006 kernel/bpf/btf.c env->visit_states[type_id] = VISITED; env 1008 kernel/bpf/btf.c v = &env->stack[env->top_stack++]; env 1013 kernel/bpf/btf.c if (env->resolve_mode == RESOLVE_TBD) { env 1015 kernel/bpf/btf.c env->resolve_mode = RESOLVE_PTR; env 1017 kernel/bpf/btf.c env->resolve_mode = RESOLVE_STRUCT_OR_ARRAY; env 1023 kernel/bpf/btf.c static void env_stack_set_next_member(struct btf_verifier_env *env, env 1026 kernel/bpf/btf.c env->stack[env->top_stack - 1].next_member = next_member; env 1029 kernel/bpf/btf.c static void env_stack_pop_resolved(struct btf_verifier_env *env, env 1033 kernel/bpf/btf.c u32 type_id = env->stack[--(env->top_stack)].type_id; env 1034 kernel/bpf/btf.c struct btf *btf = env->btf; env 1038 kernel/bpf/btf.c env->visit_states[type_id] = RESOLVED; env 1041 kernel/bpf/btf.c static const struct resolve_vertex *env_stack_peak(struct btf_verifier_env *env) env 1043 kernel/bpf/btf.c return env->top_stack ? &env->stack[env->top_stack - 1] : NULL; env 1097 kernel/bpf/btf.c static int btf_df_check_member(struct btf_verifier_env *env, env 1102 kernel/bpf/btf.c btf_verifier_log_basic(env, struct_type, env 1107 kernel/bpf/btf.c static int btf_df_check_kflag_member(struct btf_verifier_env *env, env 1112 kernel/bpf/btf.c btf_verifier_log_basic(env, struct_type, env 1120 kernel/bpf/btf.c static int btf_generic_check_kflag_member(struct btf_verifier_env *env, env 1126 kernel/bpf/btf.c btf_verifier_log_member(env, struct_type, member, env 1134 kernel/bpf/btf.c return btf_type_ops(member_type)->check_member(env, struct_type, env 1139 kernel/bpf/btf.c static int btf_df_resolve(struct btf_verifier_env *env, env 1142 kernel/bpf/btf.c btf_verifier_log_basic(env, v->t, "Unsupported resolve"); env 1153 kernel/bpf/btf.c static int btf_int_check_member(struct btf_verifier_env *env, env 1165 kernel/bpf/btf.c btf_verifier_log_member(env, struct_type, member, env 1176 kernel/bpf/btf.c btf_verifier_log_member(env, struct_type, member, env 1183 kernel/bpf/btf.c btf_verifier_log_member(env, struct_type, member, env 1191 kernel/bpf/btf.c static int btf_int_check_kflag_member(struct btf_verifier_env *env, env 1203 kernel/bpf/btf.c btf_verifier_log_member(env, struct_type, member, env 1217 kernel/bpf/btf.c btf_verifier_log_member(env, struct_type, member, env 1224 kernel/bpf/btf.c btf_verifier_log_member(env, struct_type, member, env 1232 kernel/bpf/btf.c btf_verifier_log_member(env, struct_type, member, env 1239 kernel/bpf/btf.c btf_verifier_log_member(env, struct_type, member, env 1247 kernel/bpf/btf.c static s32 btf_int_check_meta(struct btf_verifier_env *env, env 1255 kernel/bpf/btf.c btf_verifier_log_basic(env, t, env 1262 kernel/bpf/btf.c btf_verifier_log_type(env, t, "vlen != 0"); env 1267 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid btf_info kind_flag"); env 1273 kernel/bpf/btf.c btf_verifier_log_basic(env, t, "Invalid int_data:%x", env 1281 kernel/bpf/btf.c btf_verifier_log_type(env, t, "nr_bits exceeds %zu", env 1287 kernel/bpf/btf.c btf_verifier_log_type(env, t, "nr_bits exceeds type_size"); env 1302 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Unsupported encoding"); env 1306 kernel/bpf/btf.c btf_verifier_log_type(env, t, NULL); env 1311 kernel/bpf/btf.c static void btf_int_log(struct btf_verifier_env *env, env 1316 kernel/bpf/btf.c btf_verifier_log(env, env 1489 kernel/bpf/btf.c static int btf_modifier_check_member(struct btf_verifier_env *env, env 1497 kernel/bpf/btf.c struct btf *btf = env->btf; env 1501 kernel/bpf/btf.c btf_verifier_log_member(env, struct_type, member, env 1509 kernel/bpf/btf.c return btf_type_ops(resolved_type)->check_member(env, struct_type, env 1514 kernel/bpf/btf.c static int btf_modifier_check_kflag_member(struct btf_verifier_env *env, env 1522 kernel/bpf/btf.c struct btf *btf = env->btf; env 1526 kernel/bpf/btf.c btf_verifier_log_member(env, struct_type, member, env 1534 kernel/bpf/btf.c return btf_type_ops(resolved_type)->check_kflag_member(env, struct_type, env 1539 kernel/bpf/btf.c static int btf_ptr_check_member(struct btf_verifier_env *env, env 1551 kernel/bpf/btf.c btf_verifier_log_member(env, struct_type, member, env 1557 kernel/bpf/btf.c btf_verifier_log_member(env, struct_type, member, env 1565 kernel/bpf/btf.c static int btf_ref_type_check_meta(struct btf_verifier_env *env, env 1570 kernel/bpf/btf.c btf_verifier_log_type(env, t, "vlen != 0"); env 1575 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid btf_info kind_flag"); env 1580 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid type_id"); env 1589 kernel/bpf/btf.c !btf_name_valid_identifier(env->btf, t->name_off)) { env 1590 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid name"); env 1595 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid name"); env 1600 kernel/bpf/btf.c btf_verifier_log_type(env, t, NULL); env 1605 kernel/bpf/btf.c static int btf_modifier_resolve(struct btf_verifier_env *env, env 1611 kernel/bpf/btf.c struct btf *btf = env->btf; env 1615 kernel/bpf/btf.c btf_verifier_log_type(env, v->t, "Invalid type_id"); env 1619 kernel/bpf/btf.c if (!env_type_is_resolve_sink(env, next_type) && env 1620 kernel/bpf/btf.c !env_type_is_resolved(env, next_type_id)) env 1621 kernel/bpf/btf.c return env_stack_push(env, next_type, next_type_id); env 1630 kernel/bpf/btf.c if (env_type_is_resolved(env, next_type_id)) env 1637 kernel/bpf/btf.c btf_verifier_log_type(env, v->t, "Invalid type_id"); env 1642 kernel/bpf/btf.c env_stack_pop_resolved(env, next_type_id, 0); env 1647 kernel/bpf/btf.c static int btf_var_resolve(struct btf_verifier_env *env, env 1653 kernel/bpf/btf.c struct btf *btf = env->btf; env 1657 kernel/bpf/btf.c btf_verifier_log_type(env, v->t, "Invalid type_id"); env 1661 kernel/bpf/btf.c if (!env_type_is_resolve_sink(env, next_type) && env 1662 kernel/bpf/btf.c !env_type_is_resolved(env, next_type_id)) env 1663 kernel/bpf/btf.c return env_stack_push(env, next_type, next_type_id); env 1673 kernel/bpf/btf.c !env_type_is_resolve_sink(env, resolved_type) && env 1674 kernel/bpf/btf.c !env_type_is_resolved(env, resolved_type_id)) env 1675 kernel/bpf/btf.c return env_stack_push(env, resolved_type, env 1684 kernel/bpf/btf.c btf_verifier_log_type(env, v->t, "Invalid type_id"); env 1688 kernel/bpf/btf.c env_stack_pop_resolved(env, next_type_id, 0); env 1693 kernel/bpf/btf.c static int btf_ptr_resolve(struct btf_verifier_env *env, env 1699 kernel/bpf/btf.c struct btf *btf = env->btf; env 1703 kernel/bpf/btf.c btf_verifier_log_type(env, v->t, "Invalid type_id"); env 1707 kernel/bpf/btf.c if (!env_type_is_resolve_sink(env, next_type) && env 1708 kernel/bpf/btf.c !env_type_is_resolved(env, next_type_id)) env 1709 kernel/bpf/btf.c return env_stack_push(env, next_type, next_type_id); env 1727 kernel/bpf/btf.c !env_type_is_resolve_sink(env, resolved_type) && env 1728 kernel/bpf/btf.c !env_type_is_resolved(env, resolved_type_id)) env 1729 kernel/bpf/btf.c return env_stack_push(env, resolved_type, env 1734 kernel/bpf/btf.c if (env_type_is_resolved(env, next_type_id)) env 1740 kernel/bpf/btf.c btf_verifier_log_type(env, v->t, "Invalid type_id"); env 1745 kernel/bpf/btf.c env_stack_pop_resolved(env, next_type_id, 0); env 1777 kernel/bpf/btf.c static void btf_ref_type_log(struct btf_verifier_env *env, env 1780 kernel/bpf/btf.c btf_verifier_log(env, "type_id=%u", t->type); env 1801 kernel/bpf/btf.c static s32 btf_fwd_check_meta(struct btf_verifier_env *env, env 1806 kernel/bpf/btf.c btf_verifier_log_type(env, t, "vlen != 0"); env 1811 kernel/bpf/btf.c btf_verifier_log_type(env, t, "type != 0"); env 1817 kernel/bpf/btf.c !btf_name_valid_identifier(env->btf, t->name_off)) { env 1818 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid name"); env 1822 kernel/bpf/btf.c btf_verifier_log_type(env, t, NULL); env 1827 kernel/bpf/btf.c static void btf_fwd_type_log(struct btf_verifier_env *env, env 1830 kernel/bpf/btf.c btf_verifier_log(env, "%s", btf_type_kflag(t) ? "union" : "struct"); env 1842 kernel/bpf/btf.c static int btf_array_check_member(struct btf_verifier_env *env, env 1850 kernel/bpf/btf.c struct btf *btf = env->btf; env 1853 kernel/bpf/btf.c btf_verifier_log_member(env, struct_type, member, env 1863 kernel/bpf/btf.c btf_verifier_log_member(env, struct_type, member, env 1871 kernel/bpf/btf.c static s32 btf_array_check_meta(struct btf_verifier_env *env, env 1879 kernel/bpf/btf.c btf_verifier_log_basic(env, t, env 1887 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid name"); env 1892 kernel/bpf/btf.c btf_verifier_log_type(env, t, "vlen != 0"); env 1897 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid btf_info kind_flag"); env 1902 kernel/bpf/btf.c btf_verifier_log_type(env, t, "size != 0"); env 1910 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid elem"); env 1915 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid index"); env 1919 kernel/bpf/btf.c btf_verifier_log_type(env, t, NULL); env 1924 kernel/bpf/btf.c static int btf_array_resolve(struct btf_verifier_env *env, env 1930 kernel/bpf/btf.c struct btf *btf = env->btf; env 1938 kernel/bpf/btf.c btf_verifier_log_type(env, v->t, "Invalid index"); env 1942 kernel/bpf/btf.c if (!env_type_is_resolve_sink(env, index_type) && env 1943 kernel/bpf/btf.c !env_type_is_resolved(env, index_type_id)) env 1944 kernel/bpf/btf.c return env_stack_push(env, index_type, index_type_id); env 1949 kernel/bpf/btf.c btf_verifier_log_type(env, v->t, "Invalid index"); env 1958 kernel/bpf/btf.c btf_verifier_log_type(env, v->t, env 1963 kernel/bpf/btf.c if (!env_type_is_resolve_sink(env, elem_type) && env 1964 kernel/bpf/btf.c !env_type_is_resolved(env, elem_type_id)) env 1965 kernel/bpf/btf.c return env_stack_push(env, elem_type, elem_type_id); env 1969 kernel/bpf/btf.c btf_verifier_log_type(env, v->t, "Invalid elem"); env 1974 kernel/bpf/btf.c btf_verifier_log_type(env, v->t, "Invalid array of int"); env 1979 kernel/bpf/btf.c btf_verifier_log_type(env, v->t, env 1984 kernel/bpf/btf.c env_stack_pop_resolved(env, elem_type_id, elem_size * array->nelems); env 1989 kernel/bpf/btf.c static void btf_array_log(struct btf_verifier_env *env, env 1994 kernel/bpf/btf.c btf_verifier_log(env, "type_id=%u index_type_id=%u nr_elems=%u", env 2031 kernel/bpf/btf.c static int btf_struct_check_member(struct btf_verifier_env *env, env 2040 kernel/bpf/btf.c btf_verifier_log_member(env, struct_type, member, env 2048 kernel/bpf/btf.c btf_verifier_log_member(env, struct_type, member, env 2056 kernel/bpf/btf.c static s32 btf_struct_check_meta(struct btf_verifier_env *env, env 2063 kernel/bpf/btf.c struct btf *btf = env->btf; env 2070 kernel/bpf/btf.c btf_verifier_log_basic(env, t, env 2078 kernel/bpf/btf.c !btf_name_valid_identifier(env->btf, t->name_off)) { env 2079 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid name"); env 2083 kernel/bpf/btf.c btf_verifier_log_type(env, t, NULL); env 2088 kernel/bpf/btf.c btf_verifier_log_member(env, t, member, env 2097 kernel/bpf/btf.c btf_verifier_log_member(env, t, member, "Invalid name"); env 2102 kernel/bpf/btf.c btf_verifier_log_member(env, t, member, env 2109 kernel/bpf/btf.c btf_verifier_log_member(env, t, member, env 2119 kernel/bpf/btf.c btf_verifier_log_member(env, t, member, env 2125 kernel/bpf/btf.c btf_verifier_log_member(env, t, member, env 2130 kernel/bpf/btf.c btf_verifier_log_member(env, t, member, NULL); env 2137 kernel/bpf/btf.c static int btf_struct_resolve(struct btf_verifier_env *env, env 2155 kernel/bpf/btf.c if (WARN_ON_ONCE(!env_type_is_resolved(env, env 2159 kernel/bpf/btf.c last_member_type = btf_type_by_id(env->btf, env 2162 kernel/bpf/btf.c err = btf_type_ops(last_member_type)->check_kflag_member(env, v->t, env 2166 kernel/bpf/btf.c err = btf_type_ops(last_member_type)->check_member(env, v->t, env 2175 kernel/bpf/btf.c const struct btf_type *member_type = btf_type_by_id(env->btf, env 2180 kernel/bpf/btf.c btf_verifier_log_member(env, v->t, member, env 2185 kernel/bpf/btf.c if (!env_type_is_resolve_sink(env, member_type) && env 2186 kernel/bpf/btf.c !env_type_is_resolved(env, member_type_id)) { env 2187 kernel/bpf/btf.c env_stack_set_next_member(env, i + 1); env 2188 kernel/bpf/btf.c return env_stack_push(env, member_type, member_type_id); env 2192 kernel/bpf/btf.c err = btf_type_ops(member_type)->check_kflag_member(env, v->t, env 2196 kernel/bpf/btf.c err = btf_type_ops(member_type)->check_member(env, v->t, env 2203 kernel/bpf/btf.c env_stack_pop_resolved(env, 0, 0); env 2208 kernel/bpf/btf.c static void btf_struct_log(struct btf_verifier_env *env, env 2211 kernel/bpf/btf.c btf_verifier_log(env, "size=%u vlen=%u", t->size, btf_type_vlen(t)); env 2296 kernel/bpf/btf.c static int btf_enum_check_member(struct btf_verifier_env *env, env 2305 kernel/bpf/btf.c btf_verifier_log_member(env, struct_type, member, env 2313 kernel/bpf/btf.c btf_verifier_log_member(env, struct_type, member, env 2321 kernel/bpf/btf.c static int btf_enum_check_kflag_member(struct btf_verifier_env *env, env 2333 kernel/bpf/btf.c btf_verifier_log_member(env, struct_type, member, env 2340 kernel/bpf/btf.c btf_verifier_log_member(env, struct_type, member, env 2348 kernel/bpf/btf.c btf_verifier_log_member(env, struct_type, member, env 2356 kernel/bpf/btf.c static s32 btf_enum_check_meta(struct btf_verifier_env *env, env 2361 kernel/bpf/btf.c struct btf *btf = env->btf; env 2369 kernel/bpf/btf.c btf_verifier_log_basic(env, t, env 2376 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid btf_info kind_flag"); env 2381 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Unexpected size"); env 2387 kernel/bpf/btf.c !btf_name_valid_identifier(env->btf, t->name_off)) { env 2388 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid name"); env 2392 kernel/bpf/btf.c btf_verifier_log_type(env, t, NULL); env 2396 kernel/bpf/btf.c btf_verifier_log(env, "\tInvalid name_offset:%u", env 2404 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid name"); env 2409 kernel/bpf/btf.c btf_verifier_log(env, "\t%s val=%d\n", env 2417 kernel/bpf/btf.c static void btf_enum_log(struct btf_verifier_env *env, env 2420 kernel/bpf/btf.c btf_verifier_log(env, "size=%u vlen=%u", t->size, btf_type_vlen(t)); env 2452 kernel/bpf/btf.c static s32 btf_func_proto_check_meta(struct btf_verifier_env *env, env 2459 kernel/bpf/btf.c btf_verifier_log_basic(env, t, env 2466 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid name"); env 2471 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid btf_info kind_flag"); env 2475 kernel/bpf/btf.c btf_verifier_log_type(env, t, NULL); env 2480 kernel/bpf/btf.c static void btf_func_proto_log(struct btf_verifier_env *env, env 2486 kernel/bpf/btf.c btf_verifier_log(env, "return=%u args=(", t->type); env 2488 kernel/bpf/btf.c btf_verifier_log(env, "void"); env 2494 kernel/bpf/btf.c btf_verifier_log(env, "vararg"); env 2498 kernel/bpf/btf.c btf_verifier_log(env, "%u %s", args[0].type, env 2499 kernel/bpf/btf.c __btf_name_by_offset(env->btf, env 2502 kernel/bpf/btf.c btf_verifier_log(env, ", %u %s", args[i].type, env 2503 kernel/bpf/btf.c __btf_name_by_offset(env->btf, env 2510 kernel/bpf/btf.c btf_verifier_log(env, ", %u %s", last_arg->type, env 2511 kernel/bpf/btf.c __btf_name_by_offset(env->btf, env 2514 kernel/bpf/btf.c btf_verifier_log(env, ", vararg"); env 2518 kernel/bpf/btf.c btf_verifier_log(env, ")"); env 2539 kernel/bpf/btf.c static s32 btf_func_check_meta(struct btf_verifier_env *env, env 2544 kernel/bpf/btf.c !btf_name_valid_identifier(env->btf, t->name_off)) { env 2545 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid name"); env 2550 kernel/bpf/btf.c btf_verifier_log_type(env, t, "vlen != 0"); env 2555 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid btf_info kind_flag"); env 2559 kernel/bpf/btf.c btf_verifier_log_type(env, t, NULL); env 2573 kernel/bpf/btf.c static s32 btf_var_check_meta(struct btf_verifier_env *env, env 2581 kernel/bpf/btf.c btf_verifier_log_basic(env, t, env 2588 kernel/bpf/btf.c btf_verifier_log_type(env, t, "vlen != 0"); env 2593 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid btf_info kind_flag"); env 2598 kernel/bpf/btf.c !__btf_name_valid(env->btf, t->name_off, true)) { env 2599 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid name"); env 2605 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid type_id"); env 2612 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Linkage not supported"); env 2616 kernel/bpf/btf.c btf_verifier_log_type(env, t, NULL); env 2621 kernel/bpf/btf.c static void btf_var_log(struct btf_verifier_env *env, const struct btf_type *t) env 2625 kernel/bpf/btf.c btf_verifier_log(env, "type_id=%u linkage=%u", t->type, var->linkage); env 2637 kernel/bpf/btf.c static s32 btf_datasec_check_meta(struct btf_verifier_env *env, env 2647 kernel/bpf/btf.c btf_verifier_log_basic(env, t, env 2654 kernel/bpf/btf.c btf_verifier_log_type(env, t, "vlen == 0"); env 2659 kernel/bpf/btf.c btf_verifier_log_type(env, t, "size == 0"); env 2664 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid btf_info kind_flag"); env 2669 kernel/bpf/btf.c !btf_name_valid_section(env->btf, t->name_off)) { env 2670 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid name"); env 2674 kernel/bpf/btf.c btf_verifier_log_type(env, t, NULL); env 2679 kernel/bpf/btf.c btf_verifier_log_vsi(env, t, vsi, env 2685 kernel/bpf/btf.c btf_verifier_log_vsi(env, t, vsi, env 2691 kernel/bpf/btf.c btf_verifier_log_vsi(env, t, vsi, env 2698 kernel/bpf/btf.c btf_verifier_log_vsi(env, t, vsi, env 2703 kernel/bpf/btf.c btf_verifier_log_vsi(env, t, vsi, NULL); env 2708 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid btf_info size"); env 2715 kernel/bpf/btf.c static int btf_datasec_resolve(struct btf_verifier_env *env, env 2719 kernel/bpf/btf.c struct btf *btf = env->btf; env 2724 kernel/bpf/btf.c const struct btf_type *var_type = btf_type_by_id(env->btf, env 2727 kernel/bpf/btf.c btf_verifier_log_vsi(env, v->t, vsi, env 2732 kernel/bpf/btf.c if (!env_type_is_resolve_sink(env, var_type) && env 2733 kernel/bpf/btf.c !env_type_is_resolved(env, var_type_id)) { env 2734 kernel/bpf/btf.c env_stack_set_next_member(env, i + 1); env 2735 kernel/bpf/btf.c return env_stack_push(env, var_type, var_type_id); env 2740 kernel/bpf/btf.c btf_verifier_log_vsi(env, v->t, vsi, "Invalid type"); env 2745 kernel/bpf/btf.c btf_verifier_log_vsi(env, v->t, vsi, "Invalid size"); env 2750 kernel/bpf/btf.c env_stack_pop_resolved(env, 0, 0); env 2754 kernel/bpf/btf.c static void btf_datasec_log(struct btf_verifier_env *env, env 2757 kernel/bpf/btf.c btf_verifier_log(env, "size=%u vlen=%u", t->size, btf_type_vlen(t)); env 2789 kernel/bpf/btf.c static int btf_func_proto_check(struct btf_verifier_env *env, env 2798 kernel/bpf/btf.c btf = env->btf; env 2808 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid return type"); env 2813 kernel/bpf/btf.c !env_type_is_resolved(env, ret_type_id)) { env 2814 kernel/bpf/btf.c err = btf_resolve(env, ret_type, ret_type_id); env 2821 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid return type"); env 2832 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid arg#%u", env 2847 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid arg#%u", i + 1); env 2855 kernel/bpf/btf.c btf_verifier_log_type(env, t, env 2862 kernel/bpf/btf.c !env_type_is_resolved(env, arg_type_id)) { env 2863 kernel/bpf/btf.c err = btf_resolve(env, arg_type, arg_type_id); env 2869 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid arg#%u", i + 1); env 2878 kernel/bpf/btf.c static int btf_func_check(struct btf_verifier_env *env, env 2886 kernel/bpf/btf.c btf = env->btf; env 2890 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid type_id"); env 2898 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid arg#%u", i + 1); env 2924 kernel/bpf/btf.c static s32 btf_check_meta(struct btf_verifier_env *env, env 2932 kernel/bpf/btf.c btf_verifier_log(env, "[%u] meta_left:%u meta_needed:%zu", env 2933 kernel/bpf/btf.c env->log_type_id, meta_left, sizeof(*t)); env 2939 kernel/bpf/btf.c btf_verifier_log(env, "[%u] Invalid btf_info:%x", env 2940 kernel/bpf/btf.c env->log_type_id, t->info); env 2946 kernel/bpf/btf.c btf_verifier_log(env, "[%u] Invalid kind:%u", env 2947 kernel/bpf/btf.c env->log_type_id, BTF_INFO_KIND(t->info)); env 2951 kernel/bpf/btf.c if (!btf_name_offset_valid(env->btf, t->name_off)) { env 2952 kernel/bpf/btf.c btf_verifier_log(env, "[%u] Invalid name_offset:%u", env 2953 kernel/bpf/btf.c env->log_type_id, t->name_off); env 2957 kernel/bpf/btf.c var_meta_size = btf_type_ops(t)->check_meta(env, t, meta_left); env 2966 kernel/bpf/btf.c static int btf_check_all_metas(struct btf_verifier_env *env) env 2968 kernel/bpf/btf.c struct btf *btf = env->btf; env 2976 kernel/bpf/btf.c env->log_type_id = 1; env 2981 kernel/bpf/btf.c meta_size = btf_check_meta(env, t, end - cur); env 2985 kernel/bpf/btf.c btf_add_type(env, t); env 2987 kernel/bpf/btf.c env->log_type_id++; env 2993 kernel/bpf/btf.c static bool btf_resolve_valid(struct btf_verifier_env *env, env 2997 kernel/bpf/btf.c struct btf *btf = env->btf; env 2999 kernel/bpf/btf.c if (!env_type_is_resolved(env, type_id)) env 3030 kernel/bpf/btf.c static int btf_resolve(struct btf_verifier_env *env, env 3033 kernel/bpf/btf.c u32 save_log_type_id = env->log_type_id; env 3037 kernel/bpf/btf.c env->resolve_mode = RESOLVE_TBD; env 3038 kernel/bpf/btf.c env_stack_push(env, t, type_id); env 3039 kernel/bpf/btf.c while (!err && (v = env_stack_peak(env))) { env 3040 kernel/bpf/btf.c env->log_type_id = v->type_id; env 3041 kernel/bpf/btf.c err = btf_type_ops(v->t)->resolve(env, v); env 3044 kernel/bpf/btf.c env->log_type_id = type_id; env 3046 kernel/bpf/btf.c btf_verifier_log_type(env, t, env 3050 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Loop detected"); env 3054 kernel/bpf/btf.c if (!err && !btf_resolve_valid(env, t, type_id)) { env 3055 kernel/bpf/btf.c btf_verifier_log_type(env, t, "Invalid resolve state"); env 3059 kernel/bpf/btf.c env->log_type_id = save_log_type_id; env 3063 kernel/bpf/btf.c static int btf_check_all_types(struct btf_verifier_env *env) env 3065 kernel/bpf/btf.c struct btf *btf = env->btf; env 3069 kernel/bpf/btf.c err = env_resolve_init(env); env 3073 kernel/bpf/btf.c env->phase++; env 3077 kernel/bpf/btf.c env->log_type_id = type_id; env 3079 kernel/bpf/btf.c !env_type_is_resolved(env, type_id)) { env 3080 kernel/bpf/btf.c err = btf_resolve(env, t, type_id); env 3086 kernel/bpf/btf.c err = btf_func_proto_check(env, t); env 3092 kernel/bpf/btf.c err = btf_func_check(env, t); env 3101 kernel/bpf/btf.c static int btf_parse_type_sec(struct btf_verifier_env *env) env 3103 kernel/bpf/btf.c const struct btf_header *hdr = &env->btf->hdr; env 3108 kernel/bpf/btf.c btf_verifier_log(env, "Unaligned type_off"); env 3113 kernel/bpf/btf.c btf_verifier_log(env, "No type found"); env 3117 kernel/bpf/btf.c err = btf_check_all_metas(env); env 3121 kernel/bpf/btf.c return btf_check_all_types(env); env 3124 kernel/bpf/btf.c static int btf_parse_str_sec(struct btf_verifier_env *env) env 3127 kernel/bpf/btf.c struct btf *btf = env->btf; env 3135 kernel/bpf/btf.c btf_verifier_log(env, "String section is not at the end"); env 3141 kernel/bpf/btf.c btf_verifier_log(env, "Invalid string section"); env 3163 kernel/bpf/btf.c static int btf_check_sec_info(struct btf_verifier_env *env, env 3171 kernel/bpf/btf.c btf = env->btf; env 3187 kernel/bpf/btf.c btf_verifier_log(env, "Invalid section offset"); env 3192 kernel/bpf/btf.c btf_verifier_log(env, "Unsupported section found"); env 3196 kernel/bpf/btf.c btf_verifier_log(env, "Section overlap found"); env 3200 kernel/bpf/btf.c btf_verifier_log(env, env 3209 kernel/bpf/btf.c btf_verifier_log(env, "Unsupported section found"); env 3216 kernel/bpf/btf.c static int btf_parse_hdr(struct btf_verifier_env *env) env 3223 kernel/bpf/btf.c btf = env->btf; env 3228 kernel/bpf/btf.c btf_verifier_log(env, "hdr_len not found"); env 3235 kernel/bpf/btf.c btf_verifier_log(env, "btf_header not found"); env 3246 kernel/bpf/btf.c btf_verifier_log(env, "Unsupported btf_header"); env 3257 kernel/bpf/btf.c btf_verifier_log_hdr(env, btf_data_size); env 3260 kernel/bpf/btf.c btf_verifier_log(env, "Invalid magic"); env 3265 kernel/bpf/btf.c btf_verifier_log(env, "Unsupported version"); env 3270 kernel/bpf/btf.c btf_verifier_log(env, "Unsupported flags"); env 3275 kernel/bpf/btf.c btf_verifier_log(env, "No data"); env 3279 kernel/bpf/btf.c err = btf_check_sec_info(env, btf_data_size); env 3289 kernel/bpf/btf.c struct btf_verifier_env *env = NULL; env 3298 kernel/bpf/btf.c env = kzalloc(sizeof(*env), GFP_KERNEL | __GFP_NOWARN); env 3299 kernel/bpf/btf.c if (!env) env 3302 kernel/bpf/btf.c log = &env->log; env 3324 kernel/bpf/btf.c env->btf = btf; env 3340 kernel/bpf/btf.c err = btf_parse_hdr(env); env 3346 kernel/bpf/btf.c err = btf_parse_str_sec(env); env 3350 kernel/bpf/btf.c err = btf_parse_type_sec(env); env 3359 kernel/bpf/btf.c btf_verifier_env_free(env); env 3364 kernel/bpf/btf.c btf_verifier_env_free(env); env 143 kernel/bpf/offload.c int bpf_prog_offload_verify_insn(struct bpf_verifier_env *env, env 150 kernel/bpf/offload.c offload = env->prog->aux->offload; env 152 kernel/bpf/offload.c ret = offload->offdev->ops->insn_hook(env, insn_idx, env 159 kernel/bpf/offload.c int bpf_prog_offload_finalize(struct bpf_verifier_env *env) env 165 kernel/bpf/offload.c offload = env->prog->aux->offload; env 168 kernel/bpf/offload.c ret = offload->offdev->ops->finalize(env); env 178 kernel/bpf/offload.c bpf_prog_offload_replace_insn(struct bpf_verifier_env *env, u32 off, env 186 kernel/bpf/offload.c offload = env->prog->aux->offload; env 190 kernel/bpf/offload.c ret = ops->replace_insn(env, off, insn); env 197 kernel/bpf/offload.c bpf_prog_offload_remove_insns(struct bpf_verifier_env *env, u32 off, u32 cnt) env 203 kernel/bpf/offload.c offload = env->prog->aux->offload; env 206 kernel/bpf/offload.c ret = offload->offdev->ops->remove_insns(env, off, cnt); env 212 kernel/bpf/verifier.c find_linfo(const struct bpf_verifier_env *env, u32 insn_off) env 218 kernel/bpf/verifier.c prog = env->prog; env 255 kernel/bpf/verifier.c __printf(2, 3) void bpf_verifier_log_write(struct bpf_verifier_env *env, env 260 kernel/bpf/verifier.c if (!bpf_verifier_log_needed(&env->log)) env 264 kernel/bpf/verifier.c bpf_verifier_vlog(&env->log, fmt, args); env 271 kernel/bpf/verifier.c struct bpf_verifier_env *env = private_data; env 274 kernel/bpf/verifier.c if (!bpf_verifier_log_needed(&env->log)) env 278 kernel/bpf/verifier.c bpf_verifier_vlog(&env->log, fmt, args); env 290 kernel/bpf/verifier.c __printf(3, 4) static void verbose_linfo(struct bpf_verifier_env *env, env 296 kernel/bpf/verifier.c if (!bpf_verifier_log_needed(&env->log)) env 299 kernel/bpf/verifier.c linfo = find_linfo(env, insn_off); env 300 kernel/bpf/verifier.c if (!linfo || linfo == env->prev_linfo) env 307 kernel/bpf/verifier.c bpf_verifier_vlog(&env->log, prefix_fmt, args); env 311 kernel/bpf/verifier.c verbose(env, "%s\n", env 312 kernel/bpf/verifier.c ltrim(btf_name_by_offset(env->prog->aux->btf, env 315 kernel/bpf/verifier.c env->prev_linfo = linfo; env 411 kernel/bpf/verifier.c static void print_liveness(struct bpf_verifier_env *env, env 415 kernel/bpf/verifier.c verbose(env, "_"); env 417 kernel/bpf/verifier.c verbose(env, "r"); env 419 kernel/bpf/verifier.c verbose(env, "w"); env 421 kernel/bpf/verifier.c verbose(env, "D"); env 424 kernel/bpf/verifier.c static struct bpf_func_state *func(struct bpf_verifier_env *env, env 427 kernel/bpf/verifier.c struct bpf_verifier_state *cur = env->cur_state; env 432 kernel/bpf/verifier.c static void print_verifier_state(struct bpf_verifier_env *env, env 440 kernel/bpf/verifier.c verbose(env, " frame%d:", state->frameno); env 446 kernel/bpf/verifier.c verbose(env, " R%d", i); env 447 kernel/bpf/verifier.c print_liveness(env, reg->live); env 448 kernel/bpf/verifier.c verbose(env, "=%s", reg_type_str[t]); env 450 kernel/bpf/verifier.c verbose(env, "P"); env 454 kernel/bpf/verifier.c verbose(env, "%lld", reg->var_off.value + reg->off); env 456 kernel/bpf/verifier.c verbose(env, "(id=%d", reg->id); env 458 kernel/bpf/verifier.c verbose(env, ",ref_obj_id=%d", reg->ref_obj_id); env 460 kernel/bpf/verifier.c verbose(env, ",off=%d", reg->off); env 462 kernel/bpf/verifier.c verbose(env, ",r=%d", reg->range); env 466 kernel/bpf/verifier.c verbose(env, ",ks=%d,vs=%d", env 474 kernel/bpf/verifier.c verbose(env, ",imm=%llx", reg->var_off.value); env 478 kernel/bpf/verifier.c verbose(env, ",smin_value=%lld", env 482 kernel/bpf/verifier.c verbose(env, ",smax_value=%lld", env 485 kernel/bpf/verifier.c verbose(env, ",umin_value=%llu", env 488 kernel/bpf/verifier.c verbose(env, ",umax_value=%llu", env 494 kernel/bpf/verifier.c verbose(env, ",var_off=%s", tn_buf); env 497 kernel/bpf/verifier.c verbose(env, ")"); env 514 kernel/bpf/verifier.c verbose(env, " fp%d", (-i - 1) * BPF_REG_SIZE); env 515 kernel/bpf/verifier.c print_liveness(env, state->stack[i].spilled_ptr.live); env 519 kernel/bpf/verifier.c verbose(env, "=%s", reg_type_str[t]); env 521 kernel/bpf/verifier.c verbose(env, "P"); env 523 kernel/bpf/verifier.c verbose(env, "%lld", reg->var_off.value + reg->off); env 525 kernel/bpf/verifier.c verbose(env, "=%s", types_buf); env 529 kernel/bpf/verifier.c verbose(env, " refs=%d", state->refs[0].id); env 532 kernel/bpf/verifier.c verbose(env, ",%d", state->refs[i].id); env 534 kernel/bpf/verifier.c verbose(env, "\n"); env 619 kernel/bpf/verifier.c static int acquire_reference_state(struct bpf_verifier_env *env, int insn_idx) env 621 kernel/bpf/verifier.c struct bpf_func_state *state = cur_func(env); env 628 kernel/bpf/verifier.c id = ++env->id_gen; env 758 kernel/bpf/verifier.c static void update_branch_counts(struct bpf_verifier_env *env, struct bpf_verifier_state *st) env 775 kernel/bpf/verifier.c static int pop_stack(struct bpf_verifier_env *env, int *prev_insn_idx, env 778 kernel/bpf/verifier.c struct bpf_verifier_state *cur = env->cur_state; env 779 kernel/bpf/verifier.c struct bpf_verifier_stack_elem *elem, *head = env->head; env 782 kernel/bpf/verifier.c if (env->head == NULL) env 797 kernel/bpf/verifier.c env->head = elem; env 798 kernel/bpf/verifier.c env->stack_size--; env 802 kernel/bpf/verifier.c static struct bpf_verifier_state *push_stack(struct bpf_verifier_env *env, env 806 kernel/bpf/verifier.c struct bpf_verifier_state *cur = env->cur_state; env 816 kernel/bpf/verifier.c elem->next = env->head; env 817 kernel/bpf/verifier.c env->head = elem; env 818 kernel/bpf/verifier.c env->stack_size++; env 823 kernel/bpf/verifier.c if (env->stack_size > BPF_COMPLEXITY_LIMIT_JMP_SEQ) { env 824 kernel/bpf/verifier.c verbose(env, "The sequence of %d jumps is too complex.\n", env 825 kernel/bpf/verifier.c env->stack_size); env 842 kernel/bpf/verifier.c free_verifier_state(env->cur_state, true); env 843 kernel/bpf/verifier.c env->cur_state = NULL; env 845 kernel/bpf/verifier.c while (!pop_stack(env, NULL, NULL)); env 854 kernel/bpf/verifier.c static void __mark_reg_not_init(const struct bpf_verifier_env *env, env 886 kernel/bpf/verifier.c static void mark_reg_known_zero(struct bpf_verifier_env *env, env 890 kernel/bpf/verifier.c verbose(env, "mark_reg_known_zero(regs, %u)\n", regno); env 893 kernel/bpf/verifier.c __mark_reg_not_init(env, regs + regno); env 991 kernel/bpf/verifier.c static void __mark_reg_unknown(const struct bpf_verifier_env *env, env 1002 kernel/bpf/verifier.c reg->precise = env->subprog_cnt > 1 || !env->allow_ptr_leaks ? env 1007 kernel/bpf/verifier.c static void mark_reg_unknown(struct bpf_verifier_env *env, env 1011 kernel/bpf/verifier.c verbose(env, "mark_reg_unknown(regs, %u)\n", regno); env 1014 kernel/bpf/verifier.c __mark_reg_not_init(env, regs + regno); env 1017 kernel/bpf/verifier.c __mark_reg_unknown(env, regs + regno); env 1020 kernel/bpf/verifier.c static void __mark_reg_not_init(const struct bpf_verifier_env *env, env 1023 kernel/bpf/verifier.c __mark_reg_unknown(env, reg); env 1027 kernel/bpf/verifier.c static void mark_reg_not_init(struct bpf_verifier_env *env, env 1031 kernel/bpf/verifier.c verbose(env, "mark_reg_not_init(regs, %u)\n", regno); env 1034 kernel/bpf/verifier.c __mark_reg_not_init(env, regs + regno); env 1037 kernel/bpf/verifier.c __mark_reg_not_init(env, regs + regno); env 1041 kernel/bpf/verifier.c static void init_reg_state(struct bpf_verifier_env *env, env 1048 kernel/bpf/verifier.c mark_reg_not_init(env, regs, i); env 1056 kernel/bpf/verifier.c mark_reg_known_zero(env, regs, BPF_REG_FP); env 1061 kernel/bpf/verifier.c mark_reg_known_zero(env, regs, BPF_REG_1); env 1065 kernel/bpf/verifier.c static void init_func_state(struct bpf_verifier_env *env, env 1072 kernel/bpf/verifier.c init_reg_state(env, state); env 1087 kernel/bpf/verifier.c static int find_subprog(struct bpf_verifier_env *env, int off) env 1091 kernel/bpf/verifier.c p = bsearch(&off, env->subprog_info, env->subprog_cnt, env 1092 kernel/bpf/verifier.c sizeof(env->subprog_info[0]), cmp_subprogs); env 1095 kernel/bpf/verifier.c return p - env->subprog_info; env 1099 kernel/bpf/verifier.c static int add_subprog(struct bpf_verifier_env *env, int off) env 1101 kernel/bpf/verifier.c int insn_cnt = env->prog->len; env 1105 kernel/bpf/verifier.c verbose(env, "call to invalid destination\n"); env 1108 kernel/bpf/verifier.c ret = find_subprog(env, off); env 1111 kernel/bpf/verifier.c if (env->subprog_cnt >= BPF_MAX_SUBPROGS) { env 1112 kernel/bpf/verifier.c verbose(env, "too many subprograms\n"); env 1115 kernel/bpf/verifier.c env->subprog_info[env->subprog_cnt++].start = off; env 1116 kernel/bpf/verifier.c sort(env->subprog_info, env->subprog_cnt, env 1117 kernel/bpf/verifier.c sizeof(env->subprog_info[0]), cmp_subprogs, NULL); env 1121 kernel/bpf/verifier.c static int check_subprogs(struct bpf_verifier_env *env) env 1124 kernel/bpf/verifier.c struct bpf_subprog_info *subprog = env->subprog_info; env 1125 kernel/bpf/verifier.c struct bpf_insn *insn = env->prog->insnsi; env 1126 kernel/bpf/verifier.c int insn_cnt = env->prog->len; env 1129 kernel/bpf/verifier.c ret = add_subprog(env, 0); env 1139 kernel/bpf/verifier.c if (!env->allow_ptr_leaks) { env 1140 kernel/bpf/verifier.c verbose(env, "function calls to other bpf functions are allowed for root only\n"); env 1143 kernel/bpf/verifier.c ret = add_subprog(env, i + insn[i].imm + 1); env 1151 kernel/bpf/verifier.c subprog[env->subprog_cnt].start = insn_cnt; env 1153 kernel/bpf/verifier.c if (env->log.level & BPF_LOG_LEVEL2) env 1154 kernel/bpf/verifier.c for (i = 0; i < env->subprog_cnt; i++) env 1155 kernel/bpf/verifier.c verbose(env, "func#%d @%d\n", i, subprog[i].start); env 1169 kernel/bpf/verifier.c verbose(env, "jump out of range from insn %d to %d\n", i, off); env 1180 kernel/bpf/verifier.c verbose(env, "last insn is not an exit or jmp\n"); env 1185 kernel/bpf/verifier.c if (cur_subprog < env->subprog_cnt) env 1195 kernel/bpf/verifier.c static int mark_reg_read(struct bpf_verifier_env *env, env 1207 kernel/bpf/verifier.c verbose(env, "verifier BUG type %s var_off %lld off %d\n", env 1238 kernel/bpf/verifier.c if (env->longest_mark_read_walk < cnt) env 1239 kernel/bpf/verifier.c env->longest_mark_read_walk = cnt; env 1247 kernel/bpf/verifier.c static bool is_reg64(struct bpf_verifier_env *env, struct bpf_insn *insn, env 1337 kernel/bpf/verifier.c static bool insn_has_def32(struct bpf_verifier_env *env, struct bpf_insn *insn) env 1342 kernel/bpf/verifier.c return !is_reg64(env, insn, insn->dst_reg, NULL, DST_OP); env 1345 kernel/bpf/verifier.c static void mark_insn_zext(struct bpf_verifier_env *env, env 1353 kernel/bpf/verifier.c env->insn_aux_data[def_idx - 1].zext_dst = true; env 1358 kernel/bpf/verifier.c static int check_reg_arg(struct bpf_verifier_env *env, u32 regno, env 1361 kernel/bpf/verifier.c struct bpf_verifier_state *vstate = env->cur_state; env 1363 kernel/bpf/verifier.c struct bpf_insn *insn = env->prog->insnsi + env->insn_idx; env 1368 kernel/bpf/verifier.c verbose(env, "R%d is invalid\n", regno); env 1373 kernel/bpf/verifier.c rw64 = is_reg64(env, insn, regno, reg, t); env 1377 kernel/bpf/verifier.c verbose(env, "R%d !read_ok\n", regno); env 1385 kernel/bpf/verifier.c mark_insn_zext(env, reg); env 1387 kernel/bpf/verifier.c return mark_reg_read(env, reg, reg->parent, env 1392 kernel/bpf/verifier.c verbose(env, "frame pointer is read only\n"); env 1396 kernel/bpf/verifier.c reg->subreg_def = rw64 ? DEF_NOT_SUBREG : env->insn_idx + 1; env 1398 kernel/bpf/verifier.c mark_reg_unknown(env, regs, regno); env 1404 kernel/bpf/verifier.c static int push_jmp_history(struct bpf_verifier_env *env, env 1414 kernel/bpf/verifier.c p[cnt - 1].idx = env->insn_idx; env 1415 kernel/bpf/verifier.c p[cnt - 1].prev_idx = env->prev_insn_idx; env 1442 kernel/bpf/verifier.c static int backtrack_insn(struct bpf_verifier_env *env, int idx, env 1447 kernel/bpf/verifier.c .private_data = env, env 1449 kernel/bpf/verifier.c struct bpf_insn *insn = env->prog->insnsi + idx; env 1459 kernel/bpf/verifier.c if (env->log.level & BPF_LOG_LEVEL) { env 1460 kernel/bpf/verifier.c verbose(env, "regs=%x stack=%llx before ", *reg_mask, *stack_mask); env 1461 kernel/bpf/verifier.c verbose(env, "%d: ", idx); env 1462 kernel/bpf/verifier.c print_bpf_insn(&cbs, insn, env->allow_ptr_leaks); env 1518 kernel/bpf/verifier.c verbose(env, "BUG spi %d\n", spi); env 1537 kernel/bpf/verifier.c verbose(env, "BUG spi %d\n", spi); env 1556 kernel/bpf/verifier.c verbose(env, "BUG regs %x\n", *reg_mask); env 1630 kernel/bpf/verifier.c static void mark_all_scalars_precise(struct bpf_verifier_env *env, env 1660 kernel/bpf/verifier.c static int __mark_chain_precision(struct bpf_verifier_env *env, int regno, env 1663 kernel/bpf/verifier.c struct bpf_verifier_state *st = env->cur_state; env 1665 kernel/bpf/verifier.c int last_idx = env->insn_idx; env 1674 kernel/bpf/verifier.c if (!env->allow_ptr_leaks) env 1718 kernel/bpf/verifier.c if (env->log.level & BPF_LOG_LEVEL) env 1719 kernel/bpf/verifier.c verbose(env, "last_idx %d first_idx %d\n", last_idx, first_idx); env 1725 kernel/bpf/verifier.c err = backtrack_insn(env, i, ®_mask, &stack_mask); env 1728 kernel/bpf/verifier.c mark_all_scalars_precise(env, st); env 1742 kernel/bpf/verifier.c if (i >= env->prog->len) { env 1749 kernel/bpf/verifier.c verbose(env, "BUG backtracking idx %d\n", i); env 1788 kernel/bpf/verifier.c mark_all_scalars_precise(env, st); env 1805 kernel/bpf/verifier.c if (env->log.level & BPF_LOG_LEVEL) { env 1806 kernel/bpf/verifier.c print_verifier_state(env, func); env 1807 kernel/bpf/verifier.c verbose(env, "parent %s regs=%x stack=%llx marks\n", env 1823 kernel/bpf/verifier.c static int mark_chain_precision(struct bpf_verifier_env *env, int regno) env 1825 kernel/bpf/verifier.c return __mark_chain_precision(env, regno, -1); env 1828 kernel/bpf/verifier.c static int mark_chain_precision_stack(struct bpf_verifier_env *env, int spi) env 1830 kernel/bpf/verifier.c return __mark_chain_precision(env, -1, spi); env 1893 kernel/bpf/verifier.c static int check_stack_write(struct bpf_verifier_env *env, env 1899 kernel/bpf/verifier.c u32 dst_reg = env->prog->insnsi[insn_idx].dst_reg; env 1909 kernel/bpf/verifier.c if (!env->allow_ptr_leaks && env 1912 kernel/bpf/verifier.c verbose(env, "attempt to corrupt spilled pointer on stack\n"); env 1916 kernel/bpf/verifier.c cur = env->cur_state->frame[env->cur_state->curframe]; env 1921 kernel/bpf/verifier.c !register_is_null(reg) && env->allow_ptr_leaks) { env 1929 kernel/bpf/verifier.c err = mark_chain_precision(env, value_regno); env 1937 kernel/bpf/verifier.c verbose_linfo(env, insn_idx, "; "); env 1938 kernel/bpf/verifier.c verbose(env, "invalid size of register spill\n"); env 1943 kernel/bpf/verifier.c verbose(env, "cannot spill pointers to stack into stack frame of the caller\n"); env 1947 kernel/bpf/verifier.c if (!env->allow_ptr_leaks) { env 1959 kernel/bpf/verifier.c int *poff = &env->insn_aux_data[insn_idx].sanitize_stack_off; env 1974 kernel/bpf/verifier.c verbose(env, env 2007 kernel/bpf/verifier.c err = mark_chain_precision(env, value_regno); env 2021 kernel/bpf/verifier.c static int check_stack_read(struct bpf_verifier_env *env, env 2025 kernel/bpf/verifier.c struct bpf_verifier_state *vstate = env->cur_state; env 2032 kernel/bpf/verifier.c verbose(env, "invalid read from stack off %d+0 size %d\n", env 2042 kernel/bpf/verifier.c verbose_linfo(env, env->insn_idx, "; "); env 2043 kernel/bpf/verifier.c verbose(env, "invalid size of register fill\n"); env 2047 kernel/bpf/verifier.c mark_reg_unknown(env, state->regs, value_regno); env 2050 kernel/bpf/verifier.c mark_reg_read(env, reg, reg->parent, REG_LIVE_READ64); env 2055 kernel/bpf/verifier.c verbose(env, "corrupted spill memory\n"); env 2068 kernel/bpf/verifier.c } else if (__is_pointer_value(env->allow_ptr_leaks, reg)) { env 2075 kernel/bpf/verifier.c verbose(env, "leaking pointer from stack off %d\n", env 2079 kernel/bpf/verifier.c mark_reg_read(env, reg, reg->parent, REG_LIVE_READ64); env 2090 kernel/bpf/verifier.c verbose(env, "invalid read from stack off %d+%d size %d\n", env 2094 kernel/bpf/verifier.c mark_reg_read(env, reg, reg->parent, REG_LIVE_READ64); env 2114 kernel/bpf/verifier.c mark_reg_unknown(env, state->regs, value_regno); env 2122 kernel/bpf/verifier.c static int check_stack_access(struct bpf_verifier_env *env, env 2134 kernel/bpf/verifier.c verbose(env, "variable stack access var_off=%s off=%d size=%d\n", env 2140 kernel/bpf/verifier.c verbose(env, "invalid stack off=%d size=%d\n", off, size); env 2147 kernel/bpf/verifier.c static int check_map_access_type(struct bpf_verifier_env *env, u32 regno, env 2150 kernel/bpf/verifier.c struct bpf_reg_state *regs = cur_regs(env); env 2155 kernel/bpf/verifier.c verbose(env, "write into map forbidden, value_size=%d off=%d size=%d\n", env 2161 kernel/bpf/verifier.c verbose(env, "read from map forbidden, value_size=%d off=%d size=%d\n", env 2170 kernel/bpf/verifier.c static int __check_map_access(struct bpf_verifier_env *env, u32 regno, int off, env 2173 kernel/bpf/verifier.c struct bpf_reg_state *regs = cur_regs(env); env 2178 kernel/bpf/verifier.c verbose(env, "invalid access to map value, value_size=%d off=%d size=%d\n", env 2186 kernel/bpf/verifier.c static int check_map_access(struct bpf_verifier_env *env, u32 regno, env 2189 kernel/bpf/verifier.c struct bpf_verifier_state *vstate = env->cur_state; env 2198 kernel/bpf/verifier.c if (env->log.level & BPF_LOG_LEVEL) env 2199 kernel/bpf/verifier.c print_verifier_state(env, state); env 2211 kernel/bpf/verifier.c verbose(env, "R%d min value is negative, either use unsigned index or do a if (index >=0) check.\n", env 2215 kernel/bpf/verifier.c err = __check_map_access(env, regno, reg->smin_value + off, size, env 2218 kernel/bpf/verifier.c verbose(env, "R%d min value is outside of the array range\n", env 2228 kernel/bpf/verifier.c verbose(env, "R%d unbounded memory access, make sure to bounds check any array access into a map\n", env 2232 kernel/bpf/verifier.c err = __check_map_access(env, regno, reg->umax_value + off, size, env 2235 kernel/bpf/verifier.c verbose(env, "R%d max value is outside of the array range\n", env 2248 kernel/bpf/verifier.c verbose(env, "bpf_spin_lock cannot be accessed directly by load/store\n"); env 2257 kernel/bpf/verifier.c static bool may_access_direct_pkt_data(struct bpf_verifier_env *env, env 2261 kernel/bpf/verifier.c switch (env->prog->type) { env 2283 kernel/bpf/verifier.c env->seen_direct_write = true; env 2288 kernel/bpf/verifier.c env->seen_direct_write = true; env 2297 kernel/bpf/verifier.c static int __check_packet_access(struct bpf_verifier_env *env, u32 regno, env 2300 kernel/bpf/verifier.c struct bpf_reg_state *regs = cur_regs(env); env 2305 kernel/bpf/verifier.c verbose(env, "invalid access to packet, off=%d size=%d, R%d(id=%d,off=%d,r=%d)\n", env 2312 kernel/bpf/verifier.c static int check_packet_access(struct bpf_verifier_env *env, u32 regno, int off, env 2315 kernel/bpf/verifier.c struct bpf_reg_state *regs = cur_regs(env); env 2328 kernel/bpf/verifier.c verbose(env, "R%d min value is negative, either use unsigned index or do a if (index >=0) check.\n", env 2332 kernel/bpf/verifier.c err = __check_packet_access(env, regno, off, size, zero_size_allowed); env 2334 kernel/bpf/verifier.c verbose(env, "R%d offset is outside of the packet\n", regno); env 2344 kernel/bpf/verifier.c env->prog->aux->max_pkt_offset = env 2345 kernel/bpf/verifier.c max_t(u32, env->prog->aux->max_pkt_offset, env 2352 kernel/bpf/verifier.c static int check_ctx_access(struct bpf_verifier_env *env, int insn_idx, int off, int size, env 2359 kernel/bpf/verifier.c if (env->ops->is_valid_access && env 2360 kernel/bpf/verifier.c env->ops->is_valid_access(off, size, t, env->prog, &info)) { env 2370 kernel/bpf/verifier.c env->insn_aux_data[insn_idx].ctx_field_size = info.ctx_field_size; env 2372 kernel/bpf/verifier.c if (env->prog->aux->max_ctx_offset < off + size) env 2373 kernel/bpf/verifier.c env->prog->aux->max_ctx_offset = off + size; env 2377 kernel/bpf/verifier.c verbose(env, "invalid bpf_context access off=%d size=%d\n", off, size); env 2381 kernel/bpf/verifier.c static int check_flow_keys_access(struct bpf_verifier_env *env, int off, env 2386 kernel/bpf/verifier.c verbose(env, "invalid access to flow keys off=%d size=%d\n", env 2393 kernel/bpf/verifier.c static int check_sock_access(struct bpf_verifier_env *env, int insn_idx, env 2397 kernel/bpf/verifier.c struct bpf_reg_state *regs = cur_regs(env); env 2403 kernel/bpf/verifier.c verbose(env, "R%d min value is negative, either use unsigned index or do a if (index >=0) check.\n", env 2427 kernel/bpf/verifier.c env->insn_aux_data[insn_idx].ctx_field_size = env 2432 kernel/bpf/verifier.c verbose(env, "R%d invalid %s access off=%d size=%d\n", env 2438 kernel/bpf/verifier.c static struct bpf_reg_state *reg_state(struct bpf_verifier_env *env, int regno) env 2440 kernel/bpf/verifier.c return cur_regs(env) + regno; env 2443 kernel/bpf/verifier.c static bool is_pointer_value(struct bpf_verifier_env *env, int regno) env 2445 kernel/bpf/verifier.c return __is_pointer_value(env->allow_ptr_leaks, reg_state(env, regno)); env 2448 kernel/bpf/verifier.c static bool is_ctx_reg(struct bpf_verifier_env *env, int regno) env 2450 kernel/bpf/verifier.c const struct bpf_reg_state *reg = reg_state(env, regno); env 2455 kernel/bpf/verifier.c static bool is_sk_reg(struct bpf_verifier_env *env, int regno) env 2457 kernel/bpf/verifier.c const struct bpf_reg_state *reg = reg_state(env, regno); env 2462 kernel/bpf/verifier.c static bool is_pkt_reg(struct bpf_verifier_env *env, int regno) env 2464 kernel/bpf/verifier.c const struct bpf_reg_state *reg = reg_state(env, regno); env 2469 kernel/bpf/verifier.c static bool is_flow_key_reg(struct bpf_verifier_env *env, int regno) env 2471 kernel/bpf/verifier.c const struct bpf_reg_state *reg = reg_state(env, regno); env 2477 kernel/bpf/verifier.c static int check_pkt_ptr_alignment(struct bpf_verifier_env *env, env 2503 kernel/bpf/verifier.c verbose(env, env 2512 kernel/bpf/verifier.c static int check_generic_ptr_alignment(struct bpf_verifier_env *env, env 2528 kernel/bpf/verifier.c verbose(env, "misaligned %saccess off %s+%d+%d size %d\n", env 2536 kernel/bpf/verifier.c static int check_ptr_alignment(struct bpf_verifier_env *env, env 2540 kernel/bpf/verifier.c bool strict = env->strict_alignment || strict_alignment_once; env 2549 kernel/bpf/verifier.c return check_pkt_ptr_alignment(env, reg, off, size, strict); env 2582 kernel/bpf/verifier.c return check_generic_ptr_alignment(env, reg, pointer_desc, off, size, env 2586 kernel/bpf/verifier.c static int update_stack_depth(struct bpf_verifier_env *env, env 2590 kernel/bpf/verifier.c u16 stack = env->subprog_info[func->subprogno].stack_depth; env 2596 kernel/bpf/verifier.c env->subprog_info[func->subprogno].stack_depth = -off; env 2606 kernel/bpf/verifier.c static int check_max_stack_depth(struct bpf_verifier_env *env) env 2609 kernel/bpf/verifier.c struct bpf_subprog_info *subprog = env->subprog_info; env 2610 kernel/bpf/verifier.c struct bpf_insn *insn = env->prog->insnsi; env 2620 kernel/bpf/verifier.c verbose(env, "combined stack size of %d calls is %d. Too large\n", env 2637 kernel/bpf/verifier.c idx = find_subprog(env, i); env 2645 kernel/bpf/verifier.c verbose(env, "the call stack of %d frames is too deep !\n", env 2664 kernel/bpf/verifier.c static int get_callee_stack_depth(struct bpf_verifier_env *env, env 2669 kernel/bpf/verifier.c subprog = find_subprog(env, start); env 2675 kernel/bpf/verifier.c return env->subprog_info[subprog].stack_depth; env 2679 kernel/bpf/verifier.c static int check_ctx_reg(struct bpf_verifier_env *env, env 2687 kernel/bpf/verifier.c verbose(env, "dereference of modified ctx ptr R%d off=%d disallowed\n", env 2696 kernel/bpf/verifier.c verbose(env, "variable ctx access var_off=%s disallowed\n", tn_buf); env 2703 kernel/bpf/verifier.c static int check_tp_buffer_access(struct bpf_verifier_env *env, env 2708 kernel/bpf/verifier.c verbose(env, env 2717 kernel/bpf/verifier.c verbose(env, env 2722 kernel/bpf/verifier.c if (off + size > env->prog->aux->max_tp_access) env 2723 kernel/bpf/verifier.c env->prog->aux->max_tp_access = off + size; env 2758 kernel/bpf/verifier.c static int check_mem_access(struct bpf_verifier_env *env, int insn_idx, u32 regno, env 2762 kernel/bpf/verifier.c struct bpf_reg_state *regs = cur_regs(env); env 2772 kernel/bpf/verifier.c err = check_ptr_alignment(env, reg, off, size, strict_alignment_once); env 2781 kernel/bpf/verifier.c is_pointer_value(env, value_regno)) { env 2782 kernel/bpf/verifier.c verbose(env, "R%d leaks addr into map\n", value_regno); env 2785 kernel/bpf/verifier.c err = check_map_access_type(env, regno, off, size, t); env 2788 kernel/bpf/verifier.c err = check_map_access(env, regno, off, size, false); env 2790 kernel/bpf/verifier.c mark_reg_unknown(env, regs, value_regno); env 2796 kernel/bpf/verifier.c is_pointer_value(env, value_regno)) { env 2797 kernel/bpf/verifier.c verbose(env, "R%d leaks addr into ctx\n", value_regno); env 2801 kernel/bpf/verifier.c err = check_ctx_reg(env, reg, regno); env 2805 kernel/bpf/verifier.c err = check_ctx_access(env, insn_idx, off, size, t, ®_type); env 2812 kernel/bpf/verifier.c mark_reg_unknown(env, regs, value_regno); env 2814 kernel/bpf/verifier.c mark_reg_known_zero(env, regs, env 2817 kernel/bpf/verifier.c regs[value_regno].id = ++env->id_gen; env 2830 kernel/bpf/verifier.c err = check_stack_access(env, reg, off, size); env 2834 kernel/bpf/verifier.c state = func(env, reg); env 2835 kernel/bpf/verifier.c err = update_stack_depth(env, state, off); env 2840 kernel/bpf/verifier.c err = check_stack_write(env, state, off, size, env 2843 kernel/bpf/verifier.c err = check_stack_read(env, state, off, size, env 2846 kernel/bpf/verifier.c if (t == BPF_WRITE && !may_access_direct_pkt_data(env, NULL, t)) { env 2847 kernel/bpf/verifier.c verbose(env, "cannot write into packet\n"); env 2851 kernel/bpf/verifier.c is_pointer_value(env, value_regno)) { env 2852 kernel/bpf/verifier.c verbose(env, "R%d leaks addr into packet\n", env 2856 kernel/bpf/verifier.c err = check_packet_access(env, regno, off, size, false); env 2858 kernel/bpf/verifier.c mark_reg_unknown(env, regs, value_regno); env 2861 kernel/bpf/verifier.c is_pointer_value(env, value_regno)) { env 2862 kernel/bpf/verifier.c verbose(env, "R%d leaks addr into flow keys\n", env 2867 kernel/bpf/verifier.c err = check_flow_keys_access(env, off, size); env 2869 kernel/bpf/verifier.c mark_reg_unknown(env, regs, value_regno); env 2872 kernel/bpf/verifier.c verbose(env, "R%d cannot write into %s\n", env 2876 kernel/bpf/verifier.c err = check_sock_access(env, insn_idx, regno, off, size, t); env 2878 kernel/bpf/verifier.c mark_reg_unknown(env, regs, value_regno); env 2880 kernel/bpf/verifier.c err = check_tp_buffer_access(env, reg, regno, off, size); env 2882 kernel/bpf/verifier.c mark_reg_unknown(env, regs, value_regno); env 2884 kernel/bpf/verifier.c verbose(env, "R%d invalid mem access '%s'\n", regno, env 2897 kernel/bpf/verifier.c static int check_xadd(struct bpf_verifier_env *env, int insn_idx, struct bpf_insn *insn) env 2903 kernel/bpf/verifier.c verbose(env, "BPF_XADD uses reserved fields\n"); env 2908 kernel/bpf/verifier.c err = check_reg_arg(env, insn->src_reg, SRC_OP); env 2913 kernel/bpf/verifier.c err = check_reg_arg(env, insn->dst_reg, SRC_OP); env 2917 kernel/bpf/verifier.c if (is_pointer_value(env, insn->src_reg)) { env 2918 kernel/bpf/verifier.c verbose(env, "R%d leaks addr into mem\n", insn->src_reg); env 2922 kernel/bpf/verifier.c if (is_ctx_reg(env, insn->dst_reg) || env 2923 kernel/bpf/verifier.c is_pkt_reg(env, insn->dst_reg) || env 2924 kernel/bpf/verifier.c is_flow_key_reg(env, insn->dst_reg) || env 2925 kernel/bpf/verifier.c is_sk_reg(env, insn->dst_reg)) { env 2926 kernel/bpf/verifier.c verbose(env, "BPF_XADD stores into R%d %s is not allowed\n", env 2928 kernel/bpf/verifier.c reg_type_str[reg_state(env, insn->dst_reg)->type]); env 2933 kernel/bpf/verifier.c err = check_mem_access(env, insn_idx, insn->dst_reg, insn->off, env 2939 kernel/bpf/verifier.c return check_mem_access(env, insn_idx, insn->dst_reg, insn->off, env 2943 kernel/bpf/verifier.c static int __check_stack_boundary(struct bpf_verifier_env *env, u32 regno, env 2947 kernel/bpf/verifier.c struct bpf_reg_state *reg = reg_state(env, regno); env 2952 kernel/bpf/verifier.c verbose(env, "invalid stack type R%d off=%d access_size=%d\n", env 2958 kernel/bpf/verifier.c verbose(env, "invalid stack type R%d var_off=%s access_size=%d\n", env 2972 kernel/bpf/verifier.c static int check_stack_boundary(struct bpf_verifier_env *env, int regno, env 2976 kernel/bpf/verifier.c struct bpf_reg_state *reg = reg_state(env, regno); env 2977 kernel/bpf/verifier.c struct bpf_func_state *state = func(env, reg); env 2986 kernel/bpf/verifier.c verbose(env, "R%d type=%s expected=%s\n", regno, env 2994 kernel/bpf/verifier.c err = __check_stack_boundary(env, regno, min_off, access_size, env 3004 kernel/bpf/verifier.c if (!env->allow_ptr_leaks) { env 3008 kernel/bpf/verifier.c verbose(env, "R%d indirect variable offset stack access prohibited for !root, var_off=%s\n", env 3023 kernel/bpf/verifier.c verbose(env, "R%d unbounded indirect variable offset stack access\n", env 3029 kernel/bpf/verifier.c err = __check_stack_boundary(env, regno, min_off, access_size, env 3032 kernel/bpf/verifier.c verbose(env, "R%d min value is outside of stack bound\n", env 3036 kernel/bpf/verifier.c err = __check_stack_boundary(env, regno, max_off, access_size, env 3039 kernel/bpf/verifier.c verbose(env, "R%d max value is outside of stack bound\n", env 3068 kernel/bpf/verifier.c __mark_reg_unknown(env, &state->stack[spi].spilled_ptr); env 3076 kernel/bpf/verifier.c verbose(env, "invalid indirect read from stack off %d+%d size %d\n", env 3082 kernel/bpf/verifier.c verbose(env, "invalid indirect read from stack var_off %s+%d size %d\n", env 3090 kernel/bpf/verifier.c mark_reg_read(env, &state->stack[spi].spilled_ptr, env 3094 kernel/bpf/verifier.c return update_stack_depth(env, state, min_off); env 3097 kernel/bpf/verifier.c static int check_helper_mem_access(struct bpf_verifier_env *env, int regno, env 3101 kernel/bpf/verifier.c struct bpf_reg_state *regs = cur_regs(env), *reg = ®s[regno]; env 3106 kernel/bpf/verifier.c return check_packet_access(env, regno, reg->off, access_size, env 3109 kernel/bpf/verifier.c if (check_map_access_type(env, regno, reg->off, access_size, env 3113 kernel/bpf/verifier.c return check_map_access(env, regno, reg->off, access_size, env 3116 kernel/bpf/verifier.c return check_stack_boundary(env, regno, access_size, env 3140 kernel/bpf/verifier.c static int process_spin_lock(struct bpf_verifier_env *env, int regno, env 3143 kernel/bpf/verifier.c struct bpf_reg_state *regs = cur_regs(env), *reg = ®s[regno]; env 3144 kernel/bpf/verifier.c struct bpf_verifier_state *cur = env->cur_state; env 3150 kernel/bpf/verifier.c verbose(env, "R%d is not a pointer to map_value\n", regno); env 3154 kernel/bpf/verifier.c verbose(env, env 3160 kernel/bpf/verifier.c verbose(env, env 3167 kernel/bpf/verifier.c verbose(env, env 3171 kernel/bpf/verifier.c verbose(env, env 3175 kernel/bpf/verifier.c verbose(env, env 3181 kernel/bpf/verifier.c verbose(env, "off %lld doesn't point to 'struct bpf_spin_lock'\n", env 3187 kernel/bpf/verifier.c verbose(env, env 3194 kernel/bpf/verifier.c verbose(env, "bpf_spin_unlock without taking a lock\n"); env 3198 kernel/bpf/verifier.c verbose(env, "bpf_spin_unlock of different lock\n"); env 3235 kernel/bpf/verifier.c static int check_func_arg(struct bpf_verifier_env *env, u32 regno, env 3239 kernel/bpf/verifier.c struct bpf_reg_state *regs = cur_regs(env), *reg = ®s[regno]; env 3246 kernel/bpf/verifier.c err = check_reg_arg(env, regno, SRC_OP); env 3251 kernel/bpf/verifier.c if (is_pointer_value(env, regno)) { env 3252 kernel/bpf/verifier.c verbose(env, "R%d leaks addr into helper function\n", env 3260 kernel/bpf/verifier.c !may_access_direct_pkt_data(env, meta, BPF_READ)) { env 3261 kernel/bpf/verifier.c verbose(env, "helper access to the packet is not allowed\n"); env 3290 kernel/bpf/verifier.c err = check_ctx_reg(env, reg, regno); env 3300 kernel/bpf/verifier.c verbose(env, "verifier internal error: more than one arg with ref_obj_id R%d %u %u\n", env 3313 kernel/bpf/verifier.c if (process_spin_lock(env, regno, true)) env 3316 kernel/bpf/verifier.c if (process_spin_lock(env, regno, false)) env 3319 kernel/bpf/verifier.c verbose(env, "verifier internal error\n"); env 3343 kernel/bpf/verifier.c verbose(env, "unsupported arg_type %d\n", arg_type); env 3361 kernel/bpf/verifier.c verbose(env, "invalid map_ptr to access map->key\n"); env 3364 kernel/bpf/verifier.c err = check_helper_mem_access(env, regno, env 3376 kernel/bpf/verifier.c verbose(env, "invalid map_ptr to access map->value\n"); env 3380 kernel/bpf/verifier.c err = check_helper_mem_access(env, regno, env 3403 kernel/bpf/verifier.c verbose(env, "R%d min value is negative, either use unsigned or 'var &= const'\n", env 3409 kernel/bpf/verifier.c err = check_helper_mem_access(env, regno - 1, 0, env 3417 kernel/bpf/verifier.c verbose(env, "R%d unbounded memory access, use 'var &= const' or 'if (var < const)'\n", env 3421 kernel/bpf/verifier.c err = check_helper_mem_access(env, regno - 1, env 3425 kernel/bpf/verifier.c err = mark_chain_precision(env, regno); env 3429 kernel/bpf/verifier.c err = check_helper_mem_access(env, regno, size, false, meta); env 3432 kernel/bpf/verifier.c err = check_ptr_alignment(env, reg, 0, size, true); env 3437 kernel/bpf/verifier.c verbose(env, "R%d type=%s expected=%s\n", regno, env 3442 kernel/bpf/verifier.c static int check_map_func_compatibility(struct bpf_verifier_env *env, env 3536 kernel/bpf/verifier.c if (env->subprog_cnt > 1) { env 3537 kernel/bpf/verifier.c verbose(env, "tail_calls are not allowed in programs with bpf-to-bpf calls\n"); env 3602 kernel/bpf/verifier.c verbose(env, "cannot pass map_type %d into func %s#%d\n", env 3693 kernel/bpf/verifier.c static void __clear_all_pkt_pointers(struct bpf_verifier_env *env, env 3701 kernel/bpf/verifier.c mark_reg_unknown(env, regs, i); env 3707 kernel/bpf/verifier.c __mark_reg_unknown(env, reg); env 3711 kernel/bpf/verifier.c static void clear_all_pkt_pointers(struct bpf_verifier_env *env) env 3713 kernel/bpf/verifier.c struct bpf_verifier_state *vstate = env->cur_state; env 3717 kernel/bpf/verifier.c __clear_all_pkt_pointers(env, vstate->frame[i]); env 3720 kernel/bpf/verifier.c static void release_reg_references(struct bpf_verifier_env *env, env 3729 kernel/bpf/verifier.c mark_reg_unknown(env, regs, i); env 3735 kernel/bpf/verifier.c __mark_reg_unknown(env, reg); env 3742 kernel/bpf/verifier.c static int release_reference(struct bpf_verifier_env *env, env 3745 kernel/bpf/verifier.c struct bpf_verifier_state *vstate = env->cur_state; env 3749 kernel/bpf/verifier.c err = release_reference_state(cur_func(env), ref_obj_id); env 3754 kernel/bpf/verifier.c release_reg_references(env, vstate->frame[i], ref_obj_id); env 3759 kernel/bpf/verifier.c static int check_func_call(struct bpf_verifier_env *env, struct bpf_insn *insn, env 3762 kernel/bpf/verifier.c struct bpf_verifier_state *state = env->cur_state; env 3767 kernel/bpf/verifier.c verbose(env, "the call stack of %d frames is too deep\n", env 3773 kernel/bpf/verifier.c subprog = find_subprog(env, target_insn + 1); env 3775 kernel/bpf/verifier.c verbose(env, "verifier bug. No program starts at insn %d\n", env 3782 kernel/bpf/verifier.c verbose(env, "verifier bug. Frame %d already allocated\n", env 3796 kernel/bpf/verifier.c init_func_state(env, callee, env 3815 kernel/bpf/verifier.c mark_reg_not_init(env, caller->regs, caller_saved[i]); env 3816 kernel/bpf/verifier.c check_reg_arg(env, caller_saved[i], DST_OP_NO_MARK); env 3825 kernel/bpf/verifier.c if (env->log.level & BPF_LOG_LEVEL) { env 3826 kernel/bpf/verifier.c verbose(env, "caller:\n"); env 3827 kernel/bpf/verifier.c print_verifier_state(env, caller); env 3828 kernel/bpf/verifier.c verbose(env, "callee:\n"); env 3829 kernel/bpf/verifier.c print_verifier_state(env, callee); env 3834 kernel/bpf/verifier.c static int prepare_func_exit(struct bpf_verifier_env *env, int *insn_idx) env 3836 kernel/bpf/verifier.c struct bpf_verifier_state *state = env->cur_state; env 3850 kernel/bpf/verifier.c verbose(env, "cannot return stack pointer to the caller\n"); env 3865 kernel/bpf/verifier.c if (env->log.level & BPF_LOG_LEVEL) { env 3866 kernel/bpf/verifier.c verbose(env, "returning from callee:\n"); env 3867 kernel/bpf/verifier.c print_verifier_state(env, callee); env 3868 kernel/bpf/verifier.c verbose(env, "to caller at %d:\n", *insn_idx); env 3869 kernel/bpf/verifier.c print_verifier_state(env, caller); env 3877 kernel/bpf/verifier.c static int do_refine_retval_range(struct bpf_verifier_env *env, env 3898 kernel/bpf/verifier.c ret = push_stack(env, env->insn_idx + 1, env->insn_idx, false); env 3918 kernel/bpf/verifier.c record_func_map(struct bpf_verifier_env *env, struct bpf_call_arg_meta *meta, env 3921 kernel/bpf/verifier.c struct bpf_insn_aux_data *aux = &env->insn_aux_data[insn_idx]; env 3934 kernel/bpf/verifier.c verbose(env, "kernel subsystem misconfigured verifier\n"); env 3947 kernel/bpf/verifier.c verbose(env, "write into map forbidden\n"); env 3960 kernel/bpf/verifier.c static int check_reference_leak(struct bpf_verifier_env *env) env 3962 kernel/bpf/verifier.c struct bpf_func_state *state = cur_func(env); env 3966 kernel/bpf/verifier.c verbose(env, "Unreleased reference id=%d alloc_insn=%d\n", env 3972 kernel/bpf/verifier.c static int check_helper_call(struct bpf_verifier_env *env, int func_id, int insn_idx) env 3982 kernel/bpf/verifier.c verbose(env, "invalid func %s#%d\n", func_id_name(func_id), env 3987 kernel/bpf/verifier.c if (env->ops->get_func_proto) env 3988 kernel/bpf/verifier.c fn = env->ops->get_func_proto(func_id, env->prog); env 3990 kernel/bpf/verifier.c verbose(env, "unknown func %s#%d\n", func_id_name(func_id), env 3996 kernel/bpf/verifier.c if (!env->prog->gpl_compatible && fn->gpl_only) { env 3997 kernel/bpf/verifier.c verbose(env, "cannot call GPL-restricted function from non-GPL compatible program\n"); env 4004 kernel/bpf/verifier.c verbose(env, "kernel subsystem misconfigured func %s#%d: r1 != ctx\n", env 4014 kernel/bpf/verifier.c verbose(env, "kernel subsystem misconfigured func %s#%d\n", env 4021 kernel/bpf/verifier.c err = check_func_arg(env, BPF_REG_1, fn->arg1_type, &meta); env 4024 kernel/bpf/verifier.c err = check_func_arg(env, BPF_REG_2, fn->arg2_type, &meta); env 4027 kernel/bpf/verifier.c err = check_func_arg(env, BPF_REG_3, fn->arg3_type, &meta); env 4030 kernel/bpf/verifier.c err = check_func_arg(env, BPF_REG_4, fn->arg4_type, &meta); env 4033 kernel/bpf/verifier.c err = check_func_arg(env, BPF_REG_5, fn->arg5_type, &meta); env 4037 kernel/bpf/verifier.c err = record_func_map(env, &meta, func_id, insn_idx); env 4045 kernel/bpf/verifier.c err = check_mem_access(env, insn_idx, meta.regno, i, BPF_B, env 4052 kernel/bpf/verifier.c err = check_reference_leak(env); env 4054 kernel/bpf/verifier.c verbose(env, "tail_call would lead to reference leak\n"); env 4058 kernel/bpf/verifier.c err = release_reference(env, meta.ref_obj_id); env 4060 kernel/bpf/verifier.c verbose(env, "func %s#%d reference has not been acquired before\n", env 4066 kernel/bpf/verifier.c regs = cur_regs(env); env 4073 kernel/bpf/verifier.c verbose(env, "get_local_storage() doesn't support non-zero flags\n"); env 4079 kernel/bpf/verifier.c mark_reg_not_init(env, regs, caller_saved[i]); env 4080 kernel/bpf/verifier.c check_reg_arg(env, caller_saved[i], DST_OP_NO_MARK); env 4089 kernel/bpf/verifier.c mark_reg_unknown(env, regs, BPF_REG_0); env 4095 kernel/bpf/verifier.c mark_reg_known_zero(env, regs, BPF_REG_0); env 4101 kernel/bpf/verifier.c verbose(env, env 4109 kernel/bpf/verifier.c regs[BPF_REG_0].id = ++env->id_gen; env 4112 kernel/bpf/verifier.c regs[BPF_REG_0].id = ++env->id_gen; env 4115 kernel/bpf/verifier.c mark_reg_known_zero(env, regs, BPF_REG_0); env 4117 kernel/bpf/verifier.c regs[BPF_REG_0].id = ++env->id_gen; env 4119 kernel/bpf/verifier.c mark_reg_known_zero(env, regs, BPF_REG_0); env 4121 kernel/bpf/verifier.c regs[BPF_REG_0].id = ++env->id_gen; env 4123 kernel/bpf/verifier.c mark_reg_known_zero(env, regs, BPF_REG_0); env 4125 kernel/bpf/verifier.c regs[BPF_REG_0].id = ++env->id_gen; env 4127 kernel/bpf/verifier.c verbose(env, "unknown return type %d of func %s#%d\n", env 4136 kernel/bpf/verifier.c int id = acquire_reference_state(env, insn_idx); env 4146 kernel/bpf/verifier.c err = do_refine_retval_range(env, regs, fn->ret_type, func_id, &meta); env 4150 kernel/bpf/verifier.c err = check_map_func_compatibility(env, meta.map_ptr, func_id); env 4154 kernel/bpf/verifier.c if (func_id == BPF_FUNC_get_stack && !env->prog->has_callchain_buf) { env 4165 kernel/bpf/verifier.c verbose(env, err_str, func_id_name(func_id), func_id); env 4169 kernel/bpf/verifier.c env->prog->has_callchain_buf = true; env 4173 kernel/bpf/verifier.c clear_all_pkt_pointers(env); env 4197 kernel/bpf/verifier.c static bool check_reg_sane_offset(struct bpf_verifier_env *env, env 4206 kernel/bpf/verifier.c verbose(env, "math between %s pointer and %lld is not allowed\n", env 4212 kernel/bpf/verifier.c verbose(env, "%s pointer offset %d is not allowed\n", env 4218 kernel/bpf/verifier.c verbose(env, "math between %s pointer and register with unbounded min value is not allowed\n", env 4224 kernel/bpf/verifier.c verbose(env, "value %lld makes %s pointer be out of bounds\n", env 4232 kernel/bpf/verifier.c static struct bpf_insn_aux_data *cur_aux(struct bpf_verifier_env *env) env 4234 kernel/bpf/verifier.c return &env->insn_aux_data[env->insn_idx]; env 4268 kernel/bpf/verifier.c static bool can_skip_alu_sanitation(const struct bpf_verifier_env *env, env 4271 kernel/bpf/verifier.c return env->allow_ptr_leaks || BPF_SRC(insn->code) == BPF_K; env 4291 kernel/bpf/verifier.c static int sanitize_val_alu(struct bpf_verifier_env *env, env 4294 kernel/bpf/verifier.c struct bpf_insn_aux_data *aux = cur_aux(env); env 4296 kernel/bpf/verifier.c if (can_skip_alu_sanitation(env, insn)) env 4302 kernel/bpf/verifier.c static int sanitize_ptr_alu(struct bpf_verifier_env *env, env 4308 kernel/bpf/verifier.c struct bpf_verifier_state *vstate = env->cur_state; env 4309 kernel/bpf/verifier.c struct bpf_insn_aux_data *aux = cur_aux(env); env 4316 kernel/bpf/verifier.c if (can_skip_alu_sanitation(env, insn)) env 4348 kernel/bpf/verifier.c ret = push_stack(env, env->insn_idx + 1, env->insn_idx, true); env 4359 kernel/bpf/verifier.c static int adjust_ptr_min_max_vals(struct bpf_verifier_env *env, env 4364 kernel/bpf/verifier.c struct bpf_verifier_state *vstate = env->cur_state; env 4383 kernel/bpf/verifier.c __mark_reg_unknown(env, dst_reg); env 4389 kernel/bpf/verifier.c verbose(env, env 4397 kernel/bpf/verifier.c verbose(env, "R%d pointer arithmetic on %s prohibited, null-check it first\n", env 4409 kernel/bpf/verifier.c verbose(env, "R%d pointer arithmetic on %s prohibited\n", env 4413 kernel/bpf/verifier.c if (!env->allow_ptr_leaks && !known && (smin_val < 0) != (smax_val < 0)) { env 4414 kernel/bpf/verifier.c verbose(env, "R%d has unknown scalar with mixed signed bounds, pointer arithmetic with it prohibited for !root\n", env 4429 kernel/bpf/verifier.c if (!check_reg_sane_offset(env, off_reg, ptr_reg->type) || env 4430 kernel/bpf/verifier.c !check_reg_sane_offset(env, ptr_reg, ptr_reg->type)) env 4435 kernel/bpf/verifier.c ret = sanitize_ptr_alu(env, insn, ptr_reg, dst_reg, smin_val < 0); env 4437 kernel/bpf/verifier.c verbose(env, "R%d tried to add from different maps or paths\n", dst); env 4484 kernel/bpf/verifier.c dst_reg->id = ++env->id_gen; env 4490 kernel/bpf/verifier.c ret = sanitize_ptr_alu(env, insn, ptr_reg, dst_reg, smin_val < 0); env 4492 kernel/bpf/verifier.c verbose(env, "R%d tried to sub from different maps or paths\n", dst); env 4497 kernel/bpf/verifier.c verbose(env, "R%d tried to subtract pointer from scalar\n", env 4506 kernel/bpf/verifier.c verbose(env, "R%d subtraction from stack pointer prohibited\n", env 4548 kernel/bpf/verifier.c dst_reg->id = ++env->id_gen; env 4558 kernel/bpf/verifier.c verbose(env, "R%d bitwise operator %s on pointer prohibited\n", env 4563 kernel/bpf/verifier.c verbose(env, "R%d pointer arithmetic with %s operator prohibited\n", env 4568 kernel/bpf/verifier.c if (!check_reg_sane_offset(env, dst_reg, ptr_reg->type)) env 4578 kernel/bpf/verifier.c if (!env->allow_ptr_leaks) { env 4580 kernel/bpf/verifier.c check_map_access(env, dst, dst_reg->off, 1, false)) { env 4581 kernel/bpf/verifier.c verbose(env, "R%d pointer arithmetic of map value goes out of range, " env 4585 kernel/bpf/verifier.c check_stack_access(env, dst_reg, dst_reg->off + env 4587 kernel/bpf/verifier.c verbose(env, "R%d stack pointer arithmetic goes out of range, " env 4600 kernel/bpf/verifier.c static int adjust_scalar_min_max_vals(struct bpf_verifier_env *env, env 4605 kernel/bpf/verifier.c struct bpf_reg_state *regs = cur_regs(env); env 4635 kernel/bpf/verifier.c __mark_reg_unknown(env, dst_reg); env 4641 kernel/bpf/verifier.c __mark_reg_unknown(env, dst_reg); env 4647 kernel/bpf/verifier.c ret = sanitize_val_alu(env, insn); env 4649 kernel/bpf/verifier.c verbose(env, "R%d tried to add from different pointers or scalars\n", dst); env 4671 kernel/bpf/verifier.c ret = sanitize_val_alu(env, insn); env 4673 kernel/bpf/verifier.c verbose(env, "R%d tried to sub from different pointers or scalars\n", dst); env 4787 kernel/bpf/verifier.c mark_reg_unknown(env, regs, insn->dst_reg); env 4812 kernel/bpf/verifier.c mark_reg_unknown(env, regs, insn->dst_reg); env 4842 kernel/bpf/verifier.c mark_reg_unknown(env, regs, insn->dst_reg); env 4868 kernel/bpf/verifier.c mark_reg_unknown(env, regs, insn->dst_reg); env 4885 kernel/bpf/verifier.c static int adjust_reg_min_max_vals(struct bpf_verifier_env *env, env 4888 kernel/bpf/verifier.c struct bpf_verifier_state *vstate = env->cur_state; env 4907 kernel/bpf/verifier.c if (opcode == BPF_SUB && env->allow_ptr_leaks) { env 4908 kernel/bpf/verifier.c mark_reg_unknown(env, regs, insn->dst_reg); env 4911 kernel/bpf/verifier.c verbose(env, "R%d pointer %s pointer prohibited\n", env 4920 kernel/bpf/verifier.c err = mark_chain_precision(env, insn->dst_reg); env 4923 kernel/bpf/verifier.c return adjust_ptr_min_max_vals(env, insn, env 4928 kernel/bpf/verifier.c err = mark_chain_precision(env, insn->src_reg); env 4931 kernel/bpf/verifier.c return adjust_ptr_min_max_vals(env, insn, env 4942 kernel/bpf/verifier.c return adjust_ptr_min_max_vals(env, insn, env 4948 kernel/bpf/verifier.c print_verifier_state(env, state); env 4949 kernel/bpf/verifier.c verbose(env, "verifier internal error: unexpected ptr_reg\n"); env 4953 kernel/bpf/verifier.c print_verifier_state(env, state); env 4954 kernel/bpf/verifier.c verbose(env, "verifier internal error: no src_reg\n"); env 4957 kernel/bpf/verifier.c return adjust_scalar_min_max_vals(env, insn, dst_reg, *src_reg); env 4961 kernel/bpf/verifier.c static int check_alu_op(struct bpf_verifier_env *env, struct bpf_insn *insn) env 4963 kernel/bpf/verifier.c struct bpf_reg_state *regs = cur_regs(env); env 4972 kernel/bpf/verifier.c verbose(env, "BPF_NEG uses reserved fields\n"); env 4979 kernel/bpf/verifier.c verbose(env, "BPF_END uses reserved fields\n"); env 4985 kernel/bpf/verifier.c err = check_reg_arg(env, insn->dst_reg, SRC_OP); env 4989 kernel/bpf/verifier.c if (is_pointer_value(env, insn->dst_reg)) { env 4990 kernel/bpf/verifier.c verbose(env, "R%d pointer arithmetic prohibited\n", env 4996 kernel/bpf/verifier.c err = check_reg_arg(env, insn->dst_reg, DST_OP); env 5004 kernel/bpf/verifier.c verbose(env, "BPF_MOV uses reserved fields\n"); env 5009 kernel/bpf/verifier.c err = check_reg_arg(env, insn->src_reg, SRC_OP); env 5014 kernel/bpf/verifier.c verbose(env, "BPF_MOV uses reserved fields\n"); env 5020 kernel/bpf/verifier.c err = check_reg_arg(env, insn->dst_reg, DST_OP_NO_MARK); env 5037 kernel/bpf/verifier.c if (is_pointer_value(env, insn->src_reg)) { env 5038 kernel/bpf/verifier.c verbose(env, env 5045 kernel/bpf/verifier.c dst_reg->subreg_def = env->insn_idx + 1; env 5047 kernel/bpf/verifier.c mark_reg_unknown(env, regs, env 5057 kernel/bpf/verifier.c mark_reg_unknown(env, regs, insn->dst_reg); env 5069 kernel/bpf/verifier.c verbose(env, "invalid BPF_ALU opcode %x\n", opcode); env 5076 kernel/bpf/verifier.c verbose(env, "BPF_ALU uses reserved fields\n"); env 5080 kernel/bpf/verifier.c err = check_reg_arg(env, insn->src_reg, SRC_OP); env 5085 kernel/bpf/verifier.c verbose(env, "BPF_ALU uses reserved fields\n"); env 5091 kernel/bpf/verifier.c err = check_reg_arg(env, insn->dst_reg, SRC_OP); env 5097 kernel/bpf/verifier.c verbose(env, "div by zero\n"); env 5106 kernel/bpf/verifier.c verbose(env, "invalid shift %d\n", insn->imm); env 5112 kernel/bpf/verifier.c err = check_reg_arg(env, insn->dst_reg, DST_OP_NO_MARK); env 5116 kernel/bpf/verifier.c return adjust_reg_min_max_vals(env, insn); env 5866 kernel/bpf/verifier.c static int check_cond_jmp_op(struct bpf_verifier_env *env, env 5869 kernel/bpf/verifier.c struct bpf_verifier_state *this_branch = env->cur_state; env 5880 kernel/bpf/verifier.c verbose(env, "invalid BPF_JMP/JMP32 opcode %x\n", opcode); env 5886 kernel/bpf/verifier.c verbose(env, "BPF_JMP/JMP32 uses reserved fields\n"); env 5891 kernel/bpf/verifier.c err = check_reg_arg(env, insn->src_reg, SRC_OP); env 5895 kernel/bpf/verifier.c if (is_pointer_value(env, insn->src_reg)) { env 5896 kernel/bpf/verifier.c verbose(env, "R%d pointer comparison prohibited\n", env 5903 kernel/bpf/verifier.c verbose(env, "BPF_JMP/JMP32 uses reserved fields\n"); env 5909 kernel/bpf/verifier.c err = check_reg_arg(env, insn->dst_reg, SRC_OP); env 5924 kernel/bpf/verifier.c err = mark_chain_precision(env, insn->dst_reg); env 5926 kernel/bpf/verifier.c err = mark_chain_precision(env, insn->src_reg); env 5941 kernel/bpf/verifier.c other_branch = push_stack(env, *insn_idx + insn->off + 1, *insn_idx, env 6011 kernel/bpf/verifier.c is_pointer_value(env, insn->dst_reg)) { env 6012 kernel/bpf/verifier.c verbose(env, "R%d pointer comparison prohibited\n", env 6016 kernel/bpf/verifier.c if (env->log.level & BPF_LOG_LEVEL) env 6017 kernel/bpf/verifier.c print_verifier_state(env, this_branch->frame[this_branch->curframe]); env 6022 kernel/bpf/verifier.c static int check_ld_imm(struct bpf_verifier_env *env, struct bpf_insn *insn) env 6024 kernel/bpf/verifier.c struct bpf_insn_aux_data *aux = cur_aux(env); env 6025 kernel/bpf/verifier.c struct bpf_reg_state *regs = cur_regs(env); env 6030 kernel/bpf/verifier.c verbose(env, "invalid BPF_LD_IMM insn\n"); env 6034 kernel/bpf/verifier.c verbose(env, "BPF_LD_IMM64 uses reserved fields\n"); env 6038 kernel/bpf/verifier.c err = check_reg_arg(env, insn->dst_reg, DST_OP); env 6050 kernel/bpf/verifier.c map = env->used_maps[aux->map_index]; env 6051 kernel/bpf/verifier.c mark_reg_known_zero(env, regs, insn->dst_reg); env 6058 kernel/bpf/verifier.c regs[insn->dst_reg].id = ++env->id_gen; env 6062 kernel/bpf/verifier.c verbose(env, "bpf verifier is misconfigured\n"); env 6096 kernel/bpf/verifier.c static int check_ld_abs(struct bpf_verifier_env *env, struct bpf_insn *insn) env 6098 kernel/bpf/verifier.c struct bpf_reg_state *regs = cur_regs(env); env 6103 kernel/bpf/verifier.c if (!may_access_skb(env->prog->type)) { env 6104 kernel/bpf/verifier.c verbose(env, "BPF_LD_[ABS|IND] instructions not allowed for this program type\n"); env 6108 kernel/bpf/verifier.c if (!env->ops->gen_ld_abs) { env 6109 kernel/bpf/verifier.c verbose(env, "bpf verifier is misconfigured\n"); env 6113 kernel/bpf/verifier.c if (env->subprog_cnt > 1) { env 6121 kernel/bpf/verifier.c verbose(env, "BPF_LD_[ABS|IND] instructions cannot be mixed with bpf-to-bpf calls\n"); env 6128 kernel/bpf/verifier.c verbose(env, "BPF_LD_[ABS|IND] uses reserved fields\n"); env 6133 kernel/bpf/verifier.c err = check_reg_arg(env, ctx_reg, SRC_OP); env 6141 kernel/bpf/verifier.c err = check_reference_leak(env); env 6143 kernel/bpf/verifier.c verbose(env, "BPF_LD_[ABS|IND] cannot be mixed with socket references\n"); env 6147 kernel/bpf/verifier.c if (env->cur_state->active_spin_lock) { env 6148 kernel/bpf/verifier.c verbose(env, "BPF_LD_[ABS|IND] cannot be used inside bpf_spin_lock-ed region\n"); env 6153 kernel/bpf/verifier.c verbose(env, env 6160 kernel/bpf/verifier.c err = check_reg_arg(env, insn->src_reg, SRC_OP); env 6165 kernel/bpf/verifier.c err = check_ctx_reg(env, ®s[ctx_reg], ctx_reg); env 6171 kernel/bpf/verifier.c mark_reg_not_init(env, regs, caller_saved[i]); env 6172 kernel/bpf/verifier.c check_reg_arg(env, caller_saved[i], DST_OP_NO_MARK); env 6179 kernel/bpf/verifier.c mark_reg_unknown(env, regs, BPF_REG_0); env 6181 kernel/bpf/verifier.c regs[BPF_REG_0].subreg_def = env->insn_idx + 1; env 6185 kernel/bpf/verifier.c static int check_return_code(struct bpf_verifier_env *env) env 6191 kernel/bpf/verifier.c switch (env->prog->type) { env 6193 kernel/bpf/verifier.c if (env->prog->expected_attach_type == BPF_CGROUP_UDP4_RECVMSG || env 6194 kernel/bpf/verifier.c env->prog->expected_attach_type == BPF_CGROUP_UDP6_RECVMSG) env 6198 kernel/bpf/verifier.c if (env->prog->expected_attach_type == BPF_CGROUP_INET_EGRESS) { env 6213 kernel/bpf/verifier.c reg = cur_regs(env) + BPF_REG_0; env 6215 kernel/bpf/verifier.c verbose(env, "At program exit the register R0 is not a known value (%s)\n", env 6223 kernel/bpf/verifier.c verbose(env, "At program exit the register R0 "); env 6226 kernel/bpf/verifier.c verbose(env, "has value %s", tn_buf); env 6228 kernel/bpf/verifier.c verbose(env, "has unknown scalar value"); env 6231 kernel/bpf/verifier.c verbose(env, " should have been in %s\n", tn_buf); env 6237 kernel/bpf/verifier.c env->prog->enforce_expected_attach_type = 1; env 6281 kernel/bpf/verifier.c static u32 state_htab_size(struct bpf_verifier_env *env) env 6283 kernel/bpf/verifier.c return env->prog->len; env 6287 kernel/bpf/verifier.c struct bpf_verifier_env *env, env 6290 kernel/bpf/verifier.c struct bpf_verifier_state *cur = env->cur_state; env 6293 kernel/bpf/verifier.c return &env->explored_states[(idx ^ state->callsite) % state_htab_size(env)]; env 6296 kernel/bpf/verifier.c static void init_explored_state(struct bpf_verifier_env *env, int idx) env 6298 kernel/bpf/verifier.c env->insn_aux_data[idx].prune_point = true; env 6306 kernel/bpf/verifier.c static int push_insn(int t, int w, int e, struct bpf_verifier_env *env, env 6309 kernel/bpf/verifier.c int *insn_stack = env->cfg.insn_stack; env 6310 kernel/bpf/verifier.c int *insn_state = env->cfg.insn_state; env 6318 kernel/bpf/verifier.c if (w < 0 || w >= env->prog->len) { env 6319 kernel/bpf/verifier.c verbose_linfo(env, t, "%d: ", t); env 6320 kernel/bpf/verifier.c verbose(env, "jump out of range from insn %d to %d\n", t, w); env 6326 kernel/bpf/verifier.c init_explored_state(env, w); env 6332 kernel/bpf/verifier.c if (env->cfg.cur_stack >= env->prog->len) env 6334 kernel/bpf/verifier.c insn_stack[env->cfg.cur_stack++] = w; env 6337 kernel/bpf/verifier.c if (loop_ok && env->allow_ptr_leaks) env 6339 kernel/bpf/verifier.c verbose_linfo(env, t, "%d: ", t); env 6340 kernel/bpf/verifier.c verbose_linfo(env, w, "%d: ", w); env 6341 kernel/bpf/verifier.c verbose(env, "back-edge from insn %d to %d\n", t, w); env 6347 kernel/bpf/verifier.c verbose(env, "insn state internal bug\n"); env 6356 kernel/bpf/verifier.c static int check_cfg(struct bpf_verifier_env *env) env 6358 kernel/bpf/verifier.c struct bpf_insn *insns = env->prog->insnsi; env 6359 kernel/bpf/verifier.c int insn_cnt = env->prog->len; env 6364 kernel/bpf/verifier.c insn_state = env->cfg.insn_state = kvcalloc(insn_cnt, sizeof(int), GFP_KERNEL); env 6368 kernel/bpf/verifier.c insn_stack = env->cfg.insn_stack = kvcalloc(insn_cnt, sizeof(int), GFP_KERNEL); env 6376 kernel/bpf/verifier.c env->cfg.cur_stack = 1; env 6379 kernel/bpf/verifier.c if (env->cfg.cur_stack == 0) env 6381 kernel/bpf/verifier.c t = insn_stack[env->cfg.cur_stack - 1]; env 6390 kernel/bpf/verifier.c ret = push_insn(t, t + 1, FALLTHROUGH, env, false); env 6396 kernel/bpf/verifier.c init_explored_state(env, t + 1); env 6398 kernel/bpf/verifier.c init_explored_state(env, t); env 6400 kernel/bpf/verifier.c env, false); env 6413 kernel/bpf/verifier.c FALLTHROUGH, env, true); env 6422 kernel/bpf/verifier.c init_explored_state(env, t + insns[t].off + 1); env 6427 kernel/bpf/verifier.c init_explored_state(env, t + 1); env 6430 kernel/bpf/verifier.c init_explored_state(env, t); env 6431 kernel/bpf/verifier.c ret = push_insn(t, t + 1, FALLTHROUGH, env, true); env 6437 kernel/bpf/verifier.c ret = push_insn(t, t + insns[t].off + 1, BRANCH, env, true); env 6447 kernel/bpf/verifier.c ret = push_insn(t, t + 1, FALLTHROUGH, env, false); env 6456 kernel/bpf/verifier.c if (env->cfg.cur_stack-- <= 0) { env 6457 kernel/bpf/verifier.c verbose(env, "pop stack internal bug\n"); env 6466 kernel/bpf/verifier.c verbose(env, "unreachable insn %d\n", i); env 6476 kernel/bpf/verifier.c env->cfg.insn_state = env->cfg.insn_stack = NULL; env 6484 kernel/bpf/verifier.c static int check_btf_func(struct bpf_verifier_env *env, env 6502 kernel/bpf/verifier.c if (nfuncs != env->subprog_cnt) { env 6503 kernel/bpf/verifier.c verbose(env, "number of funcs in func_info doesn't match number of subprogs\n"); env 6511 kernel/bpf/verifier.c verbose(env, "invalid func info rec size %u\n", urec_size); env 6515 kernel/bpf/verifier.c prog = env->prog; env 6529 kernel/bpf/verifier.c verbose(env, "nonzero tailing record in func info"); env 6547 kernel/bpf/verifier.c verbose(env, env 6554 kernel/bpf/verifier.c verbose(env, env 6561 kernel/bpf/verifier.c if (env->subprog_info[i].start != krecord[i].insn_off) { env 6562 kernel/bpf/verifier.c verbose(env, "func_info BTF section doesn't match subprog layout in BPF program\n"); env 6570 kernel/bpf/verifier.c verbose(env, "invalid type id %d in func info", env 6589 kernel/bpf/verifier.c static void adjust_btf_func(struct bpf_verifier_env *env) env 6593 kernel/bpf/verifier.c if (!env->prog->aux->func_info) env 6596 kernel/bpf/verifier.c for (i = 0; i < env->subprog_cnt; i++) env 6597 kernel/bpf/verifier.c env->prog->aux->func_info[i].insn_off = env->subprog_info[i].start; env 6604 kernel/bpf/verifier.c static int check_btf_line(struct bpf_verifier_env *env, env 6634 kernel/bpf/verifier.c prog = env->prog; env 6638 kernel/bpf/verifier.c sub = env->subprog_info; env 6646 kernel/bpf/verifier.c verbose(env, "nonzero tailing record in line_info"); env 6672 kernel/bpf/verifier.c verbose(env, "Invalid line_info[%u].insn_off:%u (prev_offset:%u prog->len:%u)\n", env 6680 kernel/bpf/verifier.c verbose(env, env 6689 kernel/bpf/verifier.c verbose(env, "Invalid line_info[%u].line_off or .file_name_off\n", i); env 6694 kernel/bpf/verifier.c if (s != env->subprog_cnt) { env 6699 kernel/bpf/verifier.c verbose(env, "missing bpf_line_info for func#%u\n", s); env 6709 kernel/bpf/verifier.c if (s != env->subprog_cnt) { env 6710 kernel/bpf/verifier.c verbose(env, "missing bpf_line_info for %u funcs starting from func#%u\n", env 6711 kernel/bpf/verifier.c env->subprog_cnt - s, s); env 6726 kernel/bpf/verifier.c static int check_btf_info(struct bpf_verifier_env *env, env 6739 kernel/bpf/verifier.c env->prog->aux->btf = btf; env 6741 kernel/bpf/verifier.c err = check_btf_func(env, attr, uattr); env 6745 kernel/bpf/verifier.c err = check_btf_line(env, attr, uattr); env 6798 kernel/bpf/verifier.c static void clean_func_state(struct bpf_verifier_env *env, env 6812 kernel/bpf/verifier.c __mark_reg_not_init(env, &st->regs[i]); env 6820 kernel/bpf/verifier.c __mark_reg_not_init(env, &st->stack[i].spilled_ptr); env 6827 kernel/bpf/verifier.c static void clean_verifier_state(struct bpf_verifier_env *env, env 6837 kernel/bpf/verifier.c clean_func_state(env, st->frame[i]); env 6872 kernel/bpf/verifier.c static void clean_live_states(struct bpf_verifier_env *env, int insn, env 6878 kernel/bpf/verifier.c sl = *explored_state(env, insn); env 6888 kernel/bpf/verifier.c clean_verifier_state(env, &sl->state); env 7138 kernel/bpf/verifier.c static bool states_equal(struct bpf_verifier_env *env, env 7171 kernel/bpf/verifier.c static int propagate_liveness_reg(struct bpf_verifier_env *env, env 7190 kernel/bpf/verifier.c err = mark_reg_read(env, reg, parent_reg, flag); env 7204 kernel/bpf/verifier.c static int propagate_liveness(struct bpf_verifier_env *env, env 7226 kernel/bpf/verifier.c err = propagate_liveness_reg(env, &state_reg[i], env 7231 kernel/bpf/verifier.c mark_insn_zext(env, &parent_reg[i]); env 7239 kernel/bpf/verifier.c err = propagate_liveness_reg(env, state_reg, env 7251 kernel/bpf/verifier.c static int propagate_precision(struct bpf_verifier_env *env, env 7264 kernel/bpf/verifier.c if (env->log.level & BPF_LOG_LEVEL2) env 7265 kernel/bpf/verifier.c verbose(env, "propagating r%d\n", i); env 7266 kernel/bpf/verifier.c err = mark_chain_precision(env, i); env 7278 kernel/bpf/verifier.c if (env->log.level & BPF_LOG_LEVEL2) env 7279 kernel/bpf/verifier.c verbose(env, "propagating fp%d\n", env 7281 kernel/bpf/verifier.c err = mark_chain_precision_stack(env, i); env 7307 kernel/bpf/verifier.c static int is_state_visited(struct bpf_verifier_env *env, int insn_idx) env 7311 kernel/bpf/verifier.c struct bpf_verifier_state *cur = env->cur_state, *new; env 7313 kernel/bpf/verifier.c bool add_new_state = env->test_state_freq ? true : false; env 7315 kernel/bpf/verifier.c cur->last_insn_idx = env->prev_insn_idx; env 7316 kernel/bpf/verifier.c if (!env->insn_aux_data[insn_idx].prune_point) env 7330 kernel/bpf/verifier.c if (env->jmps_processed - env->prev_jmps_processed >= 2 && env 7331 kernel/bpf/verifier.c env->insn_processed - env->prev_insn_processed >= 8) env 7334 kernel/bpf/verifier.c pprev = explored_state(env, insn_idx); env 7337 kernel/bpf/verifier.c clean_live_states(env, insn_idx, cur); env 7345 kernel/bpf/verifier.c states_equal(env, &sl->state, cur)) { env 7346 kernel/bpf/verifier.c verbose_linfo(env, insn_idx, "; "); env 7347 kernel/bpf/verifier.c verbose(env, "infinite loop detected at insn %d\n", insn_idx); env 7362 kernel/bpf/verifier.c if (env->jmps_processed - env->prev_jmps_processed < 20 && env 7363 kernel/bpf/verifier.c env->insn_processed - env->prev_insn_processed < 100) env 7367 kernel/bpf/verifier.c if (states_equal(env, &sl->state, cur)) { env 7379 kernel/bpf/verifier.c err = propagate_liveness(env, &sl->state, cur); env 7386 kernel/bpf/verifier.c err = err ? : push_jmp_history(env, cur); env 7387 kernel/bpf/verifier.c err = err ? : propagate_precision(env, &sl->state); env 7419 kernel/bpf/verifier.c env->peak_states--; env 7425 kernel/bpf/verifier.c sl->next = env->free_list; env 7426 kernel/bpf/verifier.c env->free_list = sl; env 7436 kernel/bpf/verifier.c if (env->max_states_per_insn < states_cnt) env 7437 kernel/bpf/verifier.c env->max_states_per_insn = states_cnt; env 7439 kernel/bpf/verifier.c if (!env->allow_ptr_leaks && states_cnt > BPF_COMPLEXITY_LIMIT_STATES) env 7440 kernel/bpf/verifier.c return push_jmp_history(env, cur); env 7443 kernel/bpf/verifier.c return push_jmp_history(env, cur); env 7457 kernel/bpf/verifier.c env->total_states++; env 7458 kernel/bpf/verifier.c env->peak_states++; env 7459 kernel/bpf/verifier.c env->prev_jmps_processed = env->jmps_processed; env 7460 kernel/bpf/verifier.c env->prev_insn_processed = env->insn_processed; env 7477 kernel/bpf/verifier.c new_sl->next = *explored_state(env, insn_idx); env 7478 kernel/bpf/verifier.c *explored_state(env, insn_idx) = new_sl; env 7549 kernel/bpf/verifier.c static int do_check(struct bpf_verifier_env *env) env 7552 kernel/bpf/verifier.c struct bpf_insn *insns = env->prog->insnsi; env 7554 kernel/bpf/verifier.c int insn_cnt = env->prog->len; env 7558 kernel/bpf/verifier.c env->prev_linfo = NULL; env 7571 kernel/bpf/verifier.c env->cur_state = state; env 7572 kernel/bpf/verifier.c init_func_state(env, state->frame[0], env 7582 kernel/bpf/verifier.c env->prev_insn_idx = prev_insn_idx; env 7583 kernel/bpf/verifier.c if (env->insn_idx >= insn_cnt) { env 7584 kernel/bpf/verifier.c verbose(env, "invalid insn idx %d insn_cnt %d\n", env 7585 kernel/bpf/verifier.c env->insn_idx, insn_cnt); env 7589 kernel/bpf/verifier.c insn = &insns[env->insn_idx]; env 7592 kernel/bpf/verifier.c if (++env->insn_processed > BPF_COMPLEXITY_LIMIT_INSNS) { env 7593 kernel/bpf/verifier.c verbose(env, env 7595 kernel/bpf/verifier.c env->insn_processed); env 7599 kernel/bpf/verifier.c err = is_state_visited(env, env->insn_idx); env 7604 kernel/bpf/verifier.c if (env->log.level & BPF_LOG_LEVEL) { env 7606 kernel/bpf/verifier.c verbose(env, "\nfrom %d to %d%s: safe\n", env 7607 kernel/bpf/verifier.c env->prev_insn_idx, env->insn_idx, env 7608 kernel/bpf/verifier.c env->cur_state->speculative ? env 7611 kernel/bpf/verifier.c verbose(env, "%d: safe\n", env->insn_idx); env 7622 kernel/bpf/verifier.c if (env->log.level & BPF_LOG_LEVEL2 || env 7623 kernel/bpf/verifier.c (env->log.level & BPF_LOG_LEVEL && do_print_state)) { env 7624 kernel/bpf/verifier.c if (env->log.level & BPF_LOG_LEVEL2) env 7625 kernel/bpf/verifier.c verbose(env, "%d:", env->insn_idx); env 7627 kernel/bpf/verifier.c verbose(env, "\nfrom %d to %d%s:", env 7628 kernel/bpf/verifier.c env->prev_insn_idx, env->insn_idx, env 7629 kernel/bpf/verifier.c env->cur_state->speculative ? env 7631 kernel/bpf/verifier.c print_verifier_state(env, state->frame[state->curframe]); env 7635 kernel/bpf/verifier.c if (env->log.level & BPF_LOG_LEVEL) { env 7638 kernel/bpf/verifier.c .private_data = env, env 7641 kernel/bpf/verifier.c verbose_linfo(env, env->insn_idx, "; "); env 7642 kernel/bpf/verifier.c verbose(env, "%d: ", env->insn_idx); env 7643 kernel/bpf/verifier.c print_bpf_insn(&cbs, insn, env->allow_ptr_leaks); env 7646 kernel/bpf/verifier.c if (bpf_prog_is_dev_bound(env->prog->aux)) { env 7647 kernel/bpf/verifier.c err = bpf_prog_offload_verify_insn(env, env->insn_idx, env 7648 kernel/bpf/verifier.c env->prev_insn_idx); env 7653 kernel/bpf/verifier.c regs = cur_regs(env); env 7654 kernel/bpf/verifier.c env->insn_aux_data[env->insn_idx].seen = true; env 7655 kernel/bpf/verifier.c prev_insn_idx = env->insn_idx; env 7658 kernel/bpf/verifier.c err = check_alu_op(env, insn); env 7668 kernel/bpf/verifier.c err = check_reg_arg(env, insn->src_reg, SRC_OP); env 7672 kernel/bpf/verifier.c err = check_reg_arg(env, insn->dst_reg, DST_OP_NO_MARK); env 7681 kernel/bpf/verifier.c err = check_mem_access(env, env->insn_idx, insn->src_reg, env 7687 kernel/bpf/verifier.c prev_src_type = &env->insn_aux_data[env->insn_idx].ptr_type; env 7704 kernel/bpf/verifier.c verbose(env, "same insn cannot be used with different pointers\n"); env 7712 kernel/bpf/verifier.c err = check_xadd(env, env->insn_idx, insn); env 7715 kernel/bpf/verifier.c env->insn_idx++; env 7720 kernel/bpf/verifier.c err = check_reg_arg(env, insn->src_reg, SRC_OP); env 7724 kernel/bpf/verifier.c err = check_reg_arg(env, insn->dst_reg, SRC_OP); env 7731 kernel/bpf/verifier.c err = check_mem_access(env, env->insn_idx, insn->dst_reg, env 7737 kernel/bpf/verifier.c prev_dst_type = &env->insn_aux_data[env->insn_idx].ptr_type; env 7742 kernel/bpf/verifier.c verbose(env, "same insn cannot be used with different pointers\n"); env 7749 kernel/bpf/verifier.c verbose(env, "BPF_ST uses reserved fields\n"); env 7753 kernel/bpf/verifier.c err = check_reg_arg(env, insn->dst_reg, SRC_OP); env 7757 kernel/bpf/verifier.c if (is_ctx_reg(env, insn->dst_reg)) { env 7758 kernel/bpf/verifier.c verbose(env, "BPF_ST stores into R%d %s is not allowed\n", env 7760 kernel/bpf/verifier.c reg_type_str[reg_state(env, insn->dst_reg)->type]); env 7765 kernel/bpf/verifier.c err = check_mem_access(env, env->insn_idx, insn->dst_reg, env 7774 kernel/bpf/verifier.c env->jmps_processed++; env 7782 kernel/bpf/verifier.c verbose(env, "BPF_CALL uses reserved fields\n"); env 7786 kernel/bpf/verifier.c if (env->cur_state->active_spin_lock && env 7789 kernel/bpf/verifier.c verbose(env, "function calls are not allowed while holding a lock\n"); env 7793 kernel/bpf/verifier.c err = check_func_call(env, insn, &env->insn_idx); env 7795 kernel/bpf/verifier.c err = check_helper_call(env, insn->imm, env->insn_idx); env 7805 kernel/bpf/verifier.c verbose(env, "BPF_JA uses reserved fields\n"); env 7809 kernel/bpf/verifier.c env->insn_idx += insn->off + 1; env 7818 kernel/bpf/verifier.c verbose(env, "BPF_EXIT uses reserved fields\n"); env 7822 kernel/bpf/verifier.c if (env->cur_state->active_spin_lock) { env 7823 kernel/bpf/verifier.c verbose(env, "bpf_spin_unlock is missing\n"); env 7829 kernel/bpf/verifier.c err = prepare_func_exit(env, &env->insn_idx); env 7836 kernel/bpf/verifier.c err = check_reference_leak(env); env 7846 kernel/bpf/verifier.c err = check_reg_arg(env, BPF_REG_0, SRC_OP); env 7850 kernel/bpf/verifier.c if (is_pointer_value(env, BPF_REG_0)) { env 7851 kernel/bpf/verifier.c verbose(env, "R0 leaks addr as return value\n"); env 7855 kernel/bpf/verifier.c err = check_return_code(env); env 7859 kernel/bpf/verifier.c update_branch_counts(env, env->cur_state); env 7860 kernel/bpf/verifier.c err = pop_stack(env, &prev_insn_idx, env 7861 kernel/bpf/verifier.c &env->insn_idx); env 7871 kernel/bpf/verifier.c err = check_cond_jmp_op(env, insn, &env->insn_idx); env 7879 kernel/bpf/verifier.c err = check_ld_abs(env, insn); env 7884 kernel/bpf/verifier.c err = check_ld_imm(env, insn); env 7888 kernel/bpf/verifier.c env->insn_idx++; env 7889 kernel/bpf/verifier.c env->insn_aux_data[env->insn_idx].seen = true; env 7891 kernel/bpf/verifier.c verbose(env, "invalid BPF_LD mode\n"); env 7895 kernel/bpf/verifier.c verbose(env, "unknown insn class %d\n", class); env 7899 kernel/bpf/verifier.c env->insn_idx++; env 7902 kernel/bpf/verifier.c env->prog->aux->stack_depth = env->subprog_info[0].stack_depth; env 7927 kernel/bpf/verifier.c static int check_map_prog_compatibility(struct bpf_verifier_env *env, env 7939 kernel/bpf/verifier.c verbose(env, "perf_event programs can only use preallocated hash map\n"); env 7944 kernel/bpf/verifier.c verbose(env, "perf_event programs can only use preallocated inner hash map\n"); env 7952 kernel/bpf/verifier.c verbose(env, "tracing progs cannot use bpf_spin_lock yet\n"); env 7958 kernel/bpf/verifier.c verbose(env, "offload device mismatch between prog and map\n"); env 7974 kernel/bpf/verifier.c static int replace_map_fd_with_map_ptr(struct bpf_verifier_env *env) env 7976 kernel/bpf/verifier.c struct bpf_insn *insn = env->prog->insnsi; env 7977 kernel/bpf/verifier.c int insn_cnt = env->prog->len; env 7980 kernel/bpf/verifier.c err = bpf_prog_calc_tag(env->prog); env 7987 kernel/bpf/verifier.c verbose(env, "BPF_LDX uses reserved fields\n"); env 7994 kernel/bpf/verifier.c verbose(env, "BPF_STX uses reserved fields\n"); env 8007 kernel/bpf/verifier.c verbose(env, "invalid bpf_ld_imm64 insn\n"); env 8022 kernel/bpf/verifier.c verbose(env, env 8030 kernel/bpf/verifier.c verbose(env, "fd %d is not pointing to valid bpf_map\n", env 8035 kernel/bpf/verifier.c err = check_map_prog_compatibility(env, map, env->prog); env 8041 kernel/bpf/verifier.c aux = &env->insn_aux_data[i]; env 8048 kernel/bpf/verifier.c verbose(env, "direct value offset of %u is not allowed\n", off); env 8054 kernel/bpf/verifier.c verbose(env, "no direct value access support for this map type\n"); env 8061 kernel/bpf/verifier.c verbose(env, "invalid access to map value pointer, value_size=%u off=%u\n", env 8075 kernel/bpf/verifier.c for (j = 0; j < env->used_map_cnt; j++) { env 8076 kernel/bpf/verifier.c if (env->used_maps[j] == map) { env 8083 kernel/bpf/verifier.c if (env->used_map_cnt >= MAX_USED_MAPS) { env 8099 kernel/bpf/verifier.c aux->map_index = env->used_map_cnt; env 8100 kernel/bpf/verifier.c env->used_maps[env->used_map_cnt++] = map; env 8103 kernel/bpf/verifier.c bpf_cgroup_storage_assign(env->prog, map)) { env 8104 kernel/bpf/verifier.c verbose(env, "only one cgroup storage of each type is allowed\n"); env 8118 kernel/bpf/verifier.c verbose(env, "unknown opcode %02x\n", insn->code); env 8131 kernel/bpf/verifier.c static void release_maps(struct bpf_verifier_env *env) env 8137 kernel/bpf/verifier.c if (!env->prog->aux->cgroup_storage[stype]) env 8139 kernel/bpf/verifier.c bpf_cgroup_storage_release(env->prog, env 8140 kernel/bpf/verifier.c env->prog->aux->cgroup_storage[stype]); env 8143 kernel/bpf/verifier.c for (i = 0; i < env->used_map_cnt; i++) env 8144 kernel/bpf/verifier.c bpf_map_put(env->used_maps[i]); env 8148 kernel/bpf/verifier.c static void convert_pseudo_ld_imm64(struct bpf_verifier_env *env) env 8150 kernel/bpf/verifier.c struct bpf_insn *insn = env->prog->insnsi; env 8151 kernel/bpf/verifier.c int insn_cnt = env->prog->len; env 8163 kernel/bpf/verifier.c static int adjust_insn_aux_data(struct bpf_verifier_env *env, env 8166 kernel/bpf/verifier.c struct bpf_insn_aux_data *new_data, *old_data = env->insn_aux_data; env 8175 kernel/bpf/verifier.c old_data[off].zext_dst = insn_has_def32(env, insn + off + cnt - 1); env 8189 kernel/bpf/verifier.c new_data[i].zext_dst = insn_has_def32(env, insn + i); env 8191 kernel/bpf/verifier.c env->insn_aux_data = new_data; env 8196 kernel/bpf/verifier.c static void adjust_subprog_starts(struct bpf_verifier_env *env, u32 off, u32 len) env 8203 kernel/bpf/verifier.c for (i = 0; i <= env->subprog_cnt; i++) { env 8204 kernel/bpf/verifier.c if (env->subprog_info[i].start <= off) env 8206 kernel/bpf/verifier.c env->subprog_info[i].start += len - 1; env 8210 kernel/bpf/verifier.c static struct bpf_prog *bpf_patch_insn_data(struct bpf_verifier_env *env, u32 off, env 8215 kernel/bpf/verifier.c new_prog = bpf_patch_insn_single(env->prog, off, patch, len); env 8218 kernel/bpf/verifier.c verbose(env, env 8220 kernel/bpf/verifier.c env->insn_aux_data[off].orig_idx); env 8223 kernel/bpf/verifier.c if (adjust_insn_aux_data(env, new_prog, off, len)) env 8225 kernel/bpf/verifier.c adjust_subprog_starts(env, off, len); env 8229 kernel/bpf/verifier.c static int adjust_subprog_starts_after_remove(struct bpf_verifier_env *env, env 8235 kernel/bpf/verifier.c for (i = 0; i < env->subprog_cnt; i++) env 8236 kernel/bpf/verifier.c if (env->subprog_info[i].start >= off) env 8239 kernel/bpf/verifier.c for (j = i; j < env->subprog_cnt; j++) env 8240 kernel/bpf/verifier.c if (env->subprog_info[j].start >= off + cnt) env 8245 kernel/bpf/verifier.c if (env->subprog_info[j].start != off + cnt) env 8249 kernel/bpf/verifier.c struct bpf_prog_aux *aux = env->prog->aux; env 8253 kernel/bpf/verifier.c move = env->subprog_cnt + 1 - j; env 8255 kernel/bpf/verifier.c memmove(env->subprog_info + i, env 8256 kernel/bpf/verifier.c env->subprog_info + j, env 8257 kernel/bpf/verifier.c sizeof(*env->subprog_info) * move); env 8258 kernel/bpf/verifier.c env->subprog_cnt -= j - i; env 8274 kernel/bpf/verifier.c if (env->subprog_info[i].start == off) env 8279 kernel/bpf/verifier.c for (; i <= env->subprog_cnt; i++) env 8280 kernel/bpf/verifier.c env->subprog_info[i].start -= cnt; env 8285 kernel/bpf/verifier.c static int bpf_adj_linfo_after_remove(struct bpf_verifier_env *env, u32 off, env 8288 kernel/bpf/verifier.c struct bpf_prog *prog = env->prog; env 8335 kernel/bpf/verifier.c for (i = 0; i <= env->subprog_cnt; i++) env 8336 kernel/bpf/verifier.c if (env->subprog_info[i].linfo_idx > l_off) { env 8340 kernel/bpf/verifier.c if (env->subprog_info[i].linfo_idx >= l_off + l_cnt) env 8341 kernel/bpf/verifier.c env->subprog_info[i].linfo_idx -= l_cnt; env 8343 kernel/bpf/verifier.c env->subprog_info[i].linfo_idx = l_off; env 8349 kernel/bpf/verifier.c static int verifier_remove_insns(struct bpf_verifier_env *env, u32 off, u32 cnt) env 8351 kernel/bpf/verifier.c struct bpf_insn_aux_data *aux_data = env->insn_aux_data; env 8352 kernel/bpf/verifier.c unsigned int orig_prog_len = env->prog->len; env 8355 kernel/bpf/verifier.c if (bpf_prog_is_dev_bound(env->prog->aux)) env 8356 kernel/bpf/verifier.c bpf_prog_offload_remove_insns(env, off, cnt); env 8358 kernel/bpf/verifier.c err = bpf_remove_insns(env->prog, off, cnt); env 8362 kernel/bpf/verifier.c err = adjust_subprog_starts_after_remove(env, off, cnt); env 8366 kernel/bpf/verifier.c err = bpf_adj_linfo_after_remove(env, off, cnt); env 8387 kernel/bpf/verifier.c static void sanitize_dead_code(struct bpf_verifier_env *env) env 8389 kernel/bpf/verifier.c struct bpf_insn_aux_data *aux_data = env->insn_aux_data; env 8391 kernel/bpf/verifier.c struct bpf_insn *insn = env->prog->insnsi; env 8392 kernel/bpf/verifier.c const int insn_cnt = env->prog->len; env 8416 kernel/bpf/verifier.c static void opt_hard_wire_dead_code_branches(struct bpf_verifier_env *env) env 8418 kernel/bpf/verifier.c struct bpf_insn_aux_data *aux_data = env->insn_aux_data; env 8420 kernel/bpf/verifier.c struct bpf_insn *insn = env->prog->insnsi; env 8421 kernel/bpf/verifier.c const int insn_cnt = env->prog->len; env 8435 kernel/bpf/verifier.c if (bpf_prog_is_dev_bound(env->prog->aux)) env 8436 kernel/bpf/verifier.c bpf_prog_offload_replace_insn(env, i, &ja); env 8442 kernel/bpf/verifier.c static int opt_remove_dead_code(struct bpf_verifier_env *env) env 8444 kernel/bpf/verifier.c struct bpf_insn_aux_data *aux_data = env->insn_aux_data; env 8445 kernel/bpf/verifier.c int insn_cnt = env->prog->len; env 8457 kernel/bpf/verifier.c err = verifier_remove_insns(env, i, j); env 8460 kernel/bpf/verifier.c insn_cnt = env->prog->len; env 8466 kernel/bpf/verifier.c static int opt_remove_nops(struct bpf_verifier_env *env) env 8469 kernel/bpf/verifier.c struct bpf_insn *insn = env->prog->insnsi; env 8470 kernel/bpf/verifier.c int insn_cnt = env->prog->len; env 8477 kernel/bpf/verifier.c err = verifier_remove_insns(env, i, 1); env 8487 kernel/bpf/verifier.c static int opt_subreg_zext_lo32_rnd_hi32(struct bpf_verifier_env *env, env 8491 kernel/bpf/verifier.c struct bpf_insn_aux_data *aux = env->insn_aux_data; env 8492 kernel/bpf/verifier.c int i, patch_len, delta = 0, len = env->prog->len; env 8493 kernel/bpf/verifier.c struct bpf_insn *insns = env->prog->insnsi; env 8523 kernel/bpf/verifier.c if (is_reg64(env, &insn, insn.dst_reg, NULL, DST_OP)) { env 8553 kernel/bpf/verifier.c new_prog = bpf_patch_insn_data(env, adj_idx, patch, patch_len); env 8556 kernel/bpf/verifier.c env->prog = new_prog; env 8558 kernel/bpf/verifier.c aux = env->insn_aux_data; env 8570 kernel/bpf/verifier.c static int convert_ctx_accesses(struct bpf_verifier_env *env) env 8572 kernel/bpf/verifier.c const struct bpf_verifier_ops *ops = env->ops; env 8574 kernel/bpf/verifier.c const int insn_cnt = env->prog->len; env 8581 kernel/bpf/verifier.c if (ops->gen_prologue || env->seen_direct_write) { env 8583 kernel/bpf/verifier.c verbose(env, "bpf verifier is misconfigured\n"); env 8586 kernel/bpf/verifier.c cnt = ops->gen_prologue(insn_buf, env->seen_direct_write, env 8587 kernel/bpf/verifier.c env->prog); env 8589 kernel/bpf/verifier.c verbose(env, "bpf verifier is misconfigured\n"); env 8592 kernel/bpf/verifier.c new_prog = bpf_patch_insn_data(env, 0, insn_buf, cnt); env 8596 kernel/bpf/verifier.c env->prog = new_prog; env 8601 kernel/bpf/verifier.c if (bpf_prog_is_dev_bound(env->prog->aux)) env 8604 kernel/bpf/verifier.c insn = env->prog->insnsi + delta; env 8623 kernel/bpf/verifier.c env->insn_aux_data[i + delta].sanitize_stack_off) { env 8631 kernel/bpf/verifier.c env->insn_aux_data[i + delta].sanitize_stack_off, env 8640 kernel/bpf/verifier.c new_prog = bpf_patch_insn_data(env, i + delta, patch, cnt); env 8645 kernel/bpf/verifier.c env->prog = new_prog; env 8650 kernel/bpf/verifier.c switch (env->insn_aux_data[i + delta].ptr_type) { env 8670 kernel/bpf/verifier.c ctx_field_size = env->insn_aux_data[i + delta].ctx_field_size; env 8685 kernel/bpf/verifier.c verbose(env, "bpf verifier narrow ctx access misconfigured\n"); env 8700 kernel/bpf/verifier.c cnt = convert_ctx_access(type, insn, insn_buf, env->prog, env 8704 kernel/bpf/verifier.c verbose(env, "bpf verifier is misconfigured\n"); env 8728 kernel/bpf/verifier.c new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt); env 8735 kernel/bpf/verifier.c env->prog = new_prog; env 8742 kernel/bpf/verifier.c static int jit_subprogs(struct bpf_verifier_env *env) env 8744 kernel/bpf/verifier.c struct bpf_prog *prog = env->prog, **func, *tmp; env 8750 kernel/bpf/verifier.c if (env->subprog_cnt <= 1) env 8761 kernel/bpf/verifier.c subprog = find_subprog(env, i + insn->imm + 1); env 8774 kernel/bpf/verifier.c env->insn_aux_data[i].call_imm = insn->imm; env 8784 kernel/bpf/verifier.c func = kcalloc(env->subprog_cnt, sizeof(prog), GFP_KERNEL); env 8788 kernel/bpf/verifier.c for (i = 0; i < env->subprog_cnt; i++) { env 8790 kernel/bpf/verifier.c subprog_end = env->subprog_info[i + 1].start; env 8817 kernel/bpf/verifier.c func[i]->aux->stack_depth = env->subprog_info[i].stack_depth; env 8822 kernel/bpf/verifier.c func[i]->aux->linfo_idx = env->subprog_info[i].linfo_idx; env 8834 kernel/bpf/verifier.c for (i = 0; i < env->subprog_cnt; i++) { env 8857 kernel/bpf/verifier.c func[i]->aux->func_cnt = env->subprog_cnt; env 8859 kernel/bpf/verifier.c for (i = 0; i < env->subprog_cnt; i++) { env 8863 kernel/bpf/verifier.c verbose(env, "JIT doesn't support bpf-to-bpf calls\n"); env 8873 kernel/bpf/verifier.c for (i = 0; i < env->subprog_cnt; i++) { env 8886 kernel/bpf/verifier.c insn->off = env->insn_aux_data[i].call_imm; env 8887 kernel/bpf/verifier.c subprog = find_subprog(env, i + insn->off + 1); env 8894 kernel/bpf/verifier.c prog->aux->func_cnt = env->subprog_cnt; env 8898 kernel/bpf/verifier.c for (i = 0; i < env->subprog_cnt; i++) env 8910 kernel/bpf/verifier.c insn->imm = env->insn_aux_data[i].call_imm; env 8916 kernel/bpf/verifier.c static int fixup_call_args(struct bpf_verifier_env *env) env 8919 kernel/bpf/verifier.c struct bpf_prog *prog = env->prog; env 8925 kernel/bpf/verifier.c if (env->prog->jit_requested && env 8926 kernel/bpf/verifier.c !bpf_prog_is_dev_bound(env->prog->aux)) { env 8927 kernel/bpf/verifier.c err = jit_subprogs(env); env 8938 kernel/bpf/verifier.c depth = get_callee_stack_depth(env, insn, i); env 8953 kernel/bpf/verifier.c static int fixup_bpf_calls(struct bpf_verifier_env *env) env 8955 kernel/bpf/verifier.c struct bpf_prog *prog = env->prog; env 8997 kernel/bpf/verifier.c new_prog = bpf_patch_insn_data(env, i + delta, patchlet, cnt); env 9002 kernel/bpf/verifier.c env->prog = prog = new_prog; env 9010 kernel/bpf/verifier.c cnt = env->ops->gen_ld_abs(insn, insn_buf); env 9012 kernel/bpf/verifier.c verbose(env, "bpf verifier is misconfigured\n"); env 9016 kernel/bpf/verifier.c new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt); env 9021 kernel/bpf/verifier.c env->prog = prog = new_prog; env 9035 kernel/bpf/verifier.c aux = &env->insn_aux_data[i + delta]; env 9068 kernel/bpf/verifier.c new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt); env 9073 kernel/bpf/verifier.c env->prog = prog = new_prog; env 9096 kernel/bpf/verifier.c env->prog->aux->stack_depth = MAX_BPF_STACK; env 9097 kernel/bpf/verifier.c env->prog->aux->max_pkt_offset = MAX_PACKET_OFF; env 9107 kernel/bpf/verifier.c aux = &env->insn_aux_data[i + delta]; env 9118 kernel/bpf/verifier.c verbose(env, "tail_call abusing map_ptr\n"); env 9131 kernel/bpf/verifier.c new_prog = bpf_patch_insn_data(env, i + delta, insn_buf, cnt); env 9136 kernel/bpf/verifier.c env->prog = prog = new_prog; env 9152 kernel/bpf/verifier.c aux = &env->insn_aux_data[i + delta]; env 9162 kernel/bpf/verifier.c verbose(env, "bpf verifier is misconfigured\n"); env 9166 kernel/bpf/verifier.c new_prog = bpf_patch_insn_data(env, i + delta, env 9172 kernel/bpf/verifier.c env->prog = prog = new_prog; env 9223 kernel/bpf/verifier.c fn = env->ops->get_func_proto(insn->imm, env->prog); env 9228 kernel/bpf/verifier.c verbose(env, env 9239 kernel/bpf/verifier.c static void free_states(struct bpf_verifier_env *env) env 9244 kernel/bpf/verifier.c sl = env->free_list; env 9252 kernel/bpf/verifier.c if (!env->explored_states) env 9255 kernel/bpf/verifier.c for (i = 0; i < state_htab_size(env); i++) { env 9256 kernel/bpf/verifier.c sl = env->explored_states[i]; env 9266 kernel/bpf/verifier.c kvfree(env->explored_states); env 9269 kernel/bpf/verifier.c static void print_verification_stats(struct bpf_verifier_env *env) env 9273 kernel/bpf/verifier.c if (env->log.level & BPF_LOG_STATS) { env 9274 kernel/bpf/verifier.c verbose(env, "verification time %lld usec\n", env 9275 kernel/bpf/verifier.c div_u64(env->verification_time, 1000)); env 9276 kernel/bpf/verifier.c verbose(env, "stack depth "); env 9277 kernel/bpf/verifier.c for (i = 0; i < env->subprog_cnt; i++) { env 9278 kernel/bpf/verifier.c u32 depth = env->subprog_info[i].stack_depth; env 9280 kernel/bpf/verifier.c verbose(env, "%d", depth); env 9281 kernel/bpf/verifier.c if (i + 1 < env->subprog_cnt) env 9282 kernel/bpf/verifier.c verbose(env, "+"); env 9284 kernel/bpf/verifier.c verbose(env, "\n"); env 9286 kernel/bpf/verifier.c verbose(env, "processed %d insns (limit %d) max_states_per_insn %d " env 9288 kernel/bpf/verifier.c env->insn_processed, BPF_COMPLEXITY_LIMIT_INSNS, env 9289 kernel/bpf/verifier.c env->max_states_per_insn, env->total_states, env 9290 kernel/bpf/verifier.c env->peak_states, env->longest_mark_read_walk); env 9297 kernel/bpf/verifier.c struct bpf_verifier_env *env; env 9309 kernel/bpf/verifier.c env = kzalloc(sizeof(struct bpf_verifier_env), GFP_KERNEL); env 9310 kernel/bpf/verifier.c if (!env) env 9312 kernel/bpf/verifier.c log = &env->log; env 9315 kernel/bpf/verifier.c env->insn_aux_data = env 9318 kernel/bpf/verifier.c if (!env->insn_aux_data) env 9321 kernel/bpf/verifier.c env->insn_aux_data[i].orig_idx = i; env 9322 kernel/bpf/verifier.c env->prog = *prog; env 9323 kernel/bpf/verifier.c env->ops = bpf_verifier_ops[env->prog->type]; env 9345 kernel/bpf/verifier.c env->strict_alignment = !!(attr->prog_flags & BPF_F_STRICT_ALIGNMENT); env 9347 kernel/bpf/verifier.c env->strict_alignment = true; env 9349 kernel/bpf/verifier.c env->strict_alignment = false; env 9351 kernel/bpf/verifier.c env->allow_ptr_leaks = is_priv; env 9354 kernel/bpf/verifier.c env->test_state_freq = attr->prog_flags & BPF_F_TEST_STATE_FREQ; env 9356 kernel/bpf/verifier.c ret = replace_map_fd_with_map_ptr(env); env 9360 kernel/bpf/verifier.c if (bpf_prog_is_dev_bound(env->prog->aux)) { env 9361 kernel/bpf/verifier.c ret = bpf_prog_offload_verifier_prep(env->prog); env 9366 kernel/bpf/verifier.c env->explored_states = kvcalloc(state_htab_size(env), env 9370 kernel/bpf/verifier.c if (!env->explored_states) env 9373 kernel/bpf/verifier.c ret = check_subprogs(env); env 9377 kernel/bpf/verifier.c ret = check_btf_info(env, attr, uattr); env 9381 kernel/bpf/verifier.c ret = check_cfg(env); env 9385 kernel/bpf/verifier.c ret = do_check(env); env 9386 kernel/bpf/verifier.c if (env->cur_state) { env 9387 kernel/bpf/verifier.c free_verifier_state(env->cur_state, true); env 9388 kernel/bpf/verifier.c env->cur_state = NULL; env 9391 kernel/bpf/verifier.c if (ret == 0 && bpf_prog_is_dev_bound(env->prog->aux)) env 9392 kernel/bpf/verifier.c ret = bpf_prog_offload_finalize(env); env 9395 kernel/bpf/verifier.c while (!pop_stack(env, NULL, NULL)); env 9396 kernel/bpf/verifier.c free_states(env); env 9399 kernel/bpf/verifier.c ret = check_max_stack_depth(env); env 9404 kernel/bpf/verifier.c opt_hard_wire_dead_code_branches(env); env 9406 kernel/bpf/verifier.c ret = opt_remove_dead_code(env); env 9408 kernel/bpf/verifier.c ret = opt_remove_nops(env); env 9411 kernel/bpf/verifier.c sanitize_dead_code(env); env 9416 kernel/bpf/verifier.c ret = convert_ctx_accesses(env); env 9419 kernel/bpf/verifier.c ret = fixup_bpf_calls(env); env 9424 kernel/bpf/verifier.c if (ret == 0 && !bpf_prog_is_dev_bound(env->prog->aux)) { env 9425 kernel/bpf/verifier.c ret = opt_subreg_zext_lo32_rnd_hi32(env, attr); env 9426 kernel/bpf/verifier.c env->prog->aux->verifier_zext = bpf_jit_needs_zext() ? !ret env 9431 kernel/bpf/verifier.c ret = fixup_call_args(env); env 9433 kernel/bpf/verifier.c env->verification_time = ktime_get_ns() - start_time; env 9434 kernel/bpf/verifier.c print_verification_stats(env); env 9443 kernel/bpf/verifier.c if (ret == 0 && env->used_map_cnt) { env 9445 kernel/bpf/verifier.c env->prog->aux->used_maps = kmalloc_array(env->used_map_cnt, env 9446 kernel/bpf/verifier.c sizeof(env->used_maps[0]), env 9449 kernel/bpf/verifier.c if (!env->prog->aux->used_maps) { env 9454 kernel/bpf/verifier.c memcpy(env->prog->aux->used_maps, env->used_maps, env 9455 kernel/bpf/verifier.c sizeof(env->used_maps[0]) * env->used_map_cnt); env 9456 kernel/bpf/verifier.c env->prog->aux->used_map_cnt = env->used_map_cnt; env 9461 kernel/bpf/verifier.c convert_pseudo_ld_imm64(env); env 9465 kernel/bpf/verifier.c adjust_btf_func(env); env 9468 kernel/bpf/verifier.c if (!env->prog->aux->used_maps) env 9472 kernel/bpf/verifier.c release_maps(env); env 9473 kernel/bpf/verifier.c *prog = env->prog; env 9477 kernel/bpf/verifier.c vfree(env->insn_aux_data); env 9479 kernel/bpf/verifier.c kfree(env); env 1520 kernel/sched/fair.c static void task_numa_assign(struct task_numa_env *env, env 1523 kernel/sched/fair.c struct rq *rq = cpu_rq(env->dst_cpu); env 1533 kernel/sched/fair.c if (env->best_cpu != -1) { env 1534 kernel/sched/fair.c rq = cpu_rq(env->best_cpu); env 1538 kernel/sched/fair.c if (env->best_task) env 1539 kernel/sched/fair.c put_task_struct(env->best_task); env 1543 kernel/sched/fair.c env->best_task = p; env 1544 kernel/sched/fair.c env->best_imp = imp; env 1545 kernel/sched/fair.c env->best_cpu = env->dst_cpu; env 1549 kernel/sched/fair.c struct task_numa_env *env) env 1562 kernel/sched/fair.c src_capacity = env->src_stats.compute_capacity; env 1563 kernel/sched/fair.c dst_capacity = env->dst_stats.compute_capacity; env 1567 kernel/sched/fair.c orig_src_load = env->src_stats.load; env 1568 kernel/sched/fair.c orig_dst_load = env->dst_stats.load; env 1589 kernel/sched/fair.c static void task_numa_compare(struct task_numa_env *env, env 1592 kernel/sched/fair.c struct numa_group *cur_ng, *p_ng = deref_curr_numa_group(env->p); env 1593 kernel/sched/fair.c struct rq *dst_rq = cpu_rq(env->dst_cpu); env 1597 kernel/sched/fair.c int dist = env->dist; env 1613 kernel/sched/fair.c if (cur == env->p) env 1617 kernel/sched/fair.c if (maymove && moveimp >= env->best_imp) env 1631 kernel/sched/fair.c if (!cpumask_test_cpu(env->src_cpu, cur->cpus_ptr)) env 1640 kernel/sched/fair.c imp = taskimp + task_weight(cur, env->src_nid, dist) - env 1641 kernel/sched/fair.c task_weight(cur, env->dst_nid, dist); env 1654 kernel/sched/fair.c imp += group_weight(cur, env->src_nid, dist) - env 1655 kernel/sched/fair.c group_weight(cur, env->dst_nid, dist); env 1657 kernel/sched/fair.c imp += task_weight(cur, env->src_nid, dist) - env 1658 kernel/sched/fair.c task_weight(cur, env->dst_nid, dist); env 1661 kernel/sched/fair.c if (maymove && moveimp > imp && moveimp > env->best_imp) { env 1673 kernel/sched/fair.c if (imp < SMALLIMP || imp <= env->best_imp + SMALLIMP / 2) env 1679 kernel/sched/fair.c load = task_h_load(env->p) - task_h_load(cur); env 1683 kernel/sched/fair.c dst_load = env->dst_stats.load + load; env 1684 kernel/sched/fair.c src_load = env->src_stats.load - load; env 1686 kernel/sched/fair.c if (load_too_imbalanced(src_load, dst_load, env)) env 1700 kernel/sched/fair.c env->dst_cpu = select_idle_sibling(env->p, env->src_cpu, env 1701 kernel/sched/fair.c env->dst_cpu); env 1705 kernel/sched/fair.c task_numa_assign(env, cur, imp); env 1710 kernel/sched/fair.c static void task_numa_find_cpu(struct task_numa_env *env, env 1717 kernel/sched/fair.c load = task_h_load(env->p); env 1718 kernel/sched/fair.c dst_load = env->dst_stats.load + load; env 1719 kernel/sched/fair.c src_load = env->src_stats.load - load; env 1725 kernel/sched/fair.c maymove = !load_too_imbalanced(src_load, dst_load, env); env 1727 kernel/sched/fair.c for_each_cpu(cpu, cpumask_of_node(env->dst_nid)) { env 1729 kernel/sched/fair.c if (!cpumask_test_cpu(cpu, env->p->cpus_ptr)) env 1732 kernel/sched/fair.c env->dst_cpu = cpu; env 1733 kernel/sched/fair.c task_numa_compare(env, taskimp, groupimp, maymove); env 1739 kernel/sched/fair.c struct task_numa_env env = { env 1767 kernel/sched/fair.c sd = rcu_dereference(per_cpu(sd_numa, env.src_cpu)); env 1769 kernel/sched/fair.c env.imbalance_pct = 100 + (sd->imbalance_pct - 100) / 2; env 1783 kernel/sched/fair.c env.dst_nid = p->numa_preferred_nid; env 1784 kernel/sched/fair.c dist = env.dist = node_distance(env.src_nid, env.dst_nid); env 1785 kernel/sched/fair.c taskweight = task_weight(p, env.src_nid, dist); env 1786 kernel/sched/fair.c groupweight = group_weight(p, env.src_nid, dist); env 1787 kernel/sched/fair.c update_numa_stats(&env.src_stats, env.src_nid); env 1788 kernel/sched/fair.c taskimp = task_weight(p, env.dst_nid, dist) - taskweight; env 1789 kernel/sched/fair.c groupimp = group_weight(p, env.dst_nid, dist) - groupweight; env 1790 kernel/sched/fair.c update_numa_stats(&env.dst_stats, env.dst_nid); env 1793 kernel/sched/fair.c task_numa_find_cpu(&env, taskimp, groupimp); env 1803 kernel/sched/fair.c if (env.best_cpu == -1 || (ng && ng->active_nodes > 1)) { env 1805 kernel/sched/fair.c if (nid == env.src_nid || nid == p->numa_preferred_nid) env 1808 kernel/sched/fair.c dist = node_distance(env.src_nid, env.dst_nid); env 1810 kernel/sched/fair.c dist != env.dist) { env 1811 kernel/sched/fair.c taskweight = task_weight(p, env.src_nid, dist); env 1812 kernel/sched/fair.c groupweight = group_weight(p, env.src_nid, dist); env 1821 kernel/sched/fair.c env.dist = dist; env 1822 kernel/sched/fair.c env.dst_nid = nid; env 1823 kernel/sched/fair.c update_numa_stats(&env.dst_stats, env.dst_nid); env 1824 kernel/sched/fair.c task_numa_find_cpu(&env, taskimp, groupimp); env 1837 kernel/sched/fair.c if (env.best_cpu == -1) env 1838 kernel/sched/fair.c nid = env.src_nid; env 1840 kernel/sched/fair.c nid = cpu_to_node(env.best_cpu); env 1847 kernel/sched/fair.c if (env.best_cpu == -1) env 1850 kernel/sched/fair.c best_rq = cpu_rq(env.best_cpu); env 1851 kernel/sched/fair.c if (env.best_task == NULL) { env 1852 kernel/sched/fair.c ret = migrate_task_to(p, env.best_cpu); env 1855 kernel/sched/fair.c trace_sched_stick_numa(p, env.src_cpu, env.best_cpu); env 1859 kernel/sched/fair.c ret = migrate_swap(p, env.best_task, env.best_cpu, env.src_cpu); env 1863 kernel/sched/fair.c trace_sched_stick_numa(p, env.src_cpu, task_cpu(env.best_task)); env 1864 kernel/sched/fair.c put_task_struct(env.best_task); env 7152 kernel/sched/fair.c static int task_hot(struct task_struct *p, struct lb_env *env) env 7156 kernel/sched/fair.c lockdep_assert_held(&env->src_rq->lock); env 7167 kernel/sched/fair.c if (sched_feat(CACHE_HOT_BUDDY) && env->dst_rq->nr_running && env 7177 kernel/sched/fair.c delta = rq_clock_task(env->src_rq) - p->se.exec_start; env 7188 kernel/sched/fair.c static int migrate_degrades_locality(struct task_struct *p, struct lb_env *env) env 7197 kernel/sched/fair.c if (!p->numa_faults || !(env->sd->flags & SD_NUMA)) env 7200 kernel/sched/fair.c src_nid = cpu_to_node(env->src_cpu); env 7201 kernel/sched/fair.c dst_nid = cpu_to_node(env->dst_cpu); env 7208 kernel/sched/fair.c if (env->src_rq->nr_running > env->src_rq->nr_preferred_running) env 7219 kernel/sched/fair.c if (env->idle == CPU_IDLE) env 7236 kernel/sched/fair.c struct lb_env *env) env 7246 kernel/sched/fair.c int can_migrate_task(struct task_struct *p, struct lb_env *env) env 7250 kernel/sched/fair.c lockdep_assert_held(&env->src_rq->lock); env 7259 kernel/sched/fair.c if (throttled_lb_pair(task_group(p), env->src_cpu, env->dst_cpu)) env 7262 kernel/sched/fair.c if (!cpumask_test_cpu(env->dst_cpu, p->cpus_ptr)) { env 7267 kernel/sched/fair.c env->flags |= LBF_SOME_PINNED; env 7277 kernel/sched/fair.c if (env->idle == CPU_NEWLY_IDLE || (env->flags & LBF_DST_PINNED)) env 7281 kernel/sched/fair.c for_each_cpu_and(cpu, env->dst_grpmask, env->cpus) { env 7283 kernel/sched/fair.c env->flags |= LBF_DST_PINNED; env 7284 kernel/sched/fair.c env->new_dst_cpu = cpu; env 7293 kernel/sched/fair.c env->flags &= ~LBF_ALL_PINNED; env 7295 kernel/sched/fair.c if (task_running(env->src_rq, p)) { env 7306 kernel/sched/fair.c tsk_cache_hot = migrate_degrades_locality(p, env); env 7308 kernel/sched/fair.c tsk_cache_hot = task_hot(p, env); env 7311 kernel/sched/fair.c env->sd->nr_balance_failed > env->sd->cache_nice_tries) { env 7313 kernel/sched/fair.c schedstat_inc(env->sd->lb_hot_gained[env->idle]); env 7326 kernel/sched/fair.c static void detach_task(struct task_struct *p, struct lb_env *env) env 7328 kernel/sched/fair.c lockdep_assert_held(&env->src_rq->lock); env 7330 kernel/sched/fair.c deactivate_task(env->src_rq, p, DEQUEUE_NOCLOCK); env 7331 kernel/sched/fair.c set_task_cpu(p, env->dst_cpu); env 7340 kernel/sched/fair.c static struct task_struct *detach_one_task(struct lb_env *env) env 7344 kernel/sched/fair.c lockdep_assert_held(&env->src_rq->lock); env 7347 kernel/sched/fair.c &env->src_rq->cfs_tasks, se.group_node) { env 7348 kernel/sched/fair.c if (!can_migrate_task(p, env)) env 7351 kernel/sched/fair.c detach_task(p, env); env 7359 kernel/sched/fair.c schedstat_inc(env->sd->lb_gained[env->idle]); env 7373 kernel/sched/fair.c static int detach_tasks(struct lb_env *env) env 7375 kernel/sched/fair.c struct list_head *tasks = &env->src_rq->cfs_tasks; env 7380 kernel/sched/fair.c lockdep_assert_held(&env->src_rq->lock); env 7382 kernel/sched/fair.c if (env->imbalance <= 0) env 7390 kernel/sched/fair.c if (env->idle != CPU_NOT_IDLE && env->src_rq->nr_running <= 1) env 7395 kernel/sched/fair.c env->loop++; env 7397 kernel/sched/fair.c if (env->loop > env->loop_max) env 7401 kernel/sched/fair.c if (env->loop > env->loop_break) { env 7402 kernel/sched/fair.c env->loop_break += sched_nr_migrate_break; env 7403 kernel/sched/fair.c env->flags |= LBF_NEED_BREAK; env 7407 kernel/sched/fair.c if (!can_migrate_task(p, env)) env 7412 kernel/sched/fair.c if (sched_feat(LB_MIN) && load < 16 && !env->sd->nr_balance_failed) env 7415 kernel/sched/fair.c if ((load / 2) > env->imbalance) env 7418 kernel/sched/fair.c detach_task(p, env); env 7419 kernel/sched/fair.c list_add(&p->se.group_node, &env->tasks); env 7422 kernel/sched/fair.c env->imbalance -= load; env 7430 kernel/sched/fair.c if (env->idle == CPU_NEWLY_IDLE) env 7438 kernel/sched/fair.c if (env->imbalance <= 0) env 7451 kernel/sched/fair.c schedstat_add(env->sd->lb_gained[env->idle], detached); env 7486 kernel/sched/fair.c static void attach_tasks(struct lb_env *env) env 7488 kernel/sched/fair.c struct list_head *tasks = &env->tasks; env 7492 kernel/sched/fair.c rq_lock(env->dst_rq, &rf); env 7493 kernel/sched/fair.c update_rq_clock(env->dst_rq); env 7499 kernel/sched/fair.c attach_task(env->dst_rq, p); env 7502 kernel/sched/fair.c rq_unlock(env->dst_rq, &rf); env 7954 kernel/sched/fair.c group_has_capacity(struct lb_env *env, struct sg_lb_stats *sgs) env 7960 kernel/sched/fair.c (sgs->group_util * env->sd->imbalance_pct)) env 7975 kernel/sched/fair.c group_is_overloaded(struct lb_env *env, struct sg_lb_stats *sgs) env 7981 kernel/sched/fair.c (sgs->group_util * env->sd->imbalance_pct)) env 8052 kernel/sched/fair.c static inline void update_sg_lb_stats(struct lb_env *env, env 8061 kernel/sched/fair.c for_each_cpu_and(i, sched_group_span(group), env->cpus) { env 8064 kernel/sched/fair.c if ((env->flags & LBF_NOHZ_STATS) && update_nohz_stats(rq, false)) env 8065 kernel/sched/fair.c env->flags |= LBF_NOHZ_AGAIN; env 8088 kernel/sched/fair.c if (env->sd->flags & SD_ASYM_CPUCAPACITY && env 8104 kernel/sched/fair.c sgs->group_no_capacity = group_is_overloaded(env, sgs); env 8121 kernel/sched/fair.c static bool update_sd_pick_busiest(struct lb_env *env, env 8136 kernel/sched/fair.c !group_has_capacity(env, &sds->local_stat))) env 8148 kernel/sched/fair.c if (!(env->sd->flags & SD_ASYM_CPUCAPACITY)) env 8170 kernel/sched/fair.c if (!(env->sd->flags & SD_ASYM_PACKING)) env 8174 kernel/sched/fair.c if (env->idle == CPU_NOT_IDLE) env 8182 kernel/sched/fair.c sched_asym_prefer(env->dst_cpu, sg->asym_prefer_cpu)) { env 8230 kernel/sched/fair.c static inline void update_sd_lb_stats(struct lb_env *env, struct sd_lb_stats *sds) env 8232 kernel/sched/fair.c struct sched_domain *child = env->sd->child; env 8233 kernel/sched/fair.c struct sched_group *sg = env->sd->groups; env 8240 kernel/sched/fair.c if (env->idle == CPU_NEWLY_IDLE && READ_ONCE(nohz.has_blocked)) env 8241 kernel/sched/fair.c env->flags |= LBF_NOHZ_STATS; env 8248 kernel/sched/fair.c local_group = cpumask_test_cpu(env->dst_cpu, sched_group_span(sg)); env 8253 kernel/sched/fair.c if (env->idle != CPU_NEWLY_IDLE || env 8255 kernel/sched/fair.c update_group_capacity(env->sd, env->dst_cpu); env 8258 kernel/sched/fair.c update_sg_lb_stats(env, sg, sgs, &sg_status); env 8274 kernel/sched/fair.c group_has_capacity(env, local) && env 8280 kernel/sched/fair.c if (update_sd_pick_busiest(env, sds, sg, sgs)) { env 8292 kernel/sched/fair.c } while (sg != env->sd->groups); env 8295 kernel/sched/fair.c if ((env->flags & LBF_NOHZ_AGAIN) && env 8296 kernel/sched/fair.c cpumask_subset(nohz.idle_cpus_mask, sched_domain_span(env->sd))) { env 8303 kernel/sched/fair.c if (env->sd->flags & SD_NUMA) env 8304 kernel/sched/fair.c env->fbq_type = fbq_classify_group(&sds->busiest_stat); env 8306 kernel/sched/fair.c if (!env->sd->parent) { env 8307 kernel/sched/fair.c struct root_domain *rd = env->dst_rq->rd; env 8316 kernel/sched/fair.c struct root_domain *rd = env->dst_rq->rd; env 8346 kernel/sched/fair.c static int check_asym_packing(struct lb_env *env, struct sd_lb_stats *sds) env 8350 kernel/sched/fair.c if (!(env->sd->flags & SD_ASYM_PACKING)) env 8353 kernel/sched/fair.c if (env->idle == CPU_NOT_IDLE) env 8360 kernel/sched/fair.c if (sched_asym_prefer(busiest_cpu, env->dst_cpu)) env 8363 kernel/sched/fair.c env->imbalance = sds->busiest_stat.group_load; env 8376 kernel/sched/fair.c void fix_small_imbalance(struct lb_env *env, struct sd_lb_stats *sds) env 8387 kernel/sched/fair.c local->load_per_task = cpu_avg_load_per_task(env->dst_cpu); env 8397 kernel/sched/fair.c env->imbalance = busiest->load_per_task; env 8435 kernel/sched/fair.c env->imbalance = busiest->load_per_task; env 8444 kernel/sched/fair.c static inline void calculate_imbalance(struct lb_env *env, struct sd_lb_stats *sds) env 8470 kernel/sched/fair.c env->imbalance = 0; env 8471 kernel/sched/fair.c return fix_small_imbalance(env, sds); env 8498 kernel/sched/fair.c env->imbalance = min( env 8505 kernel/sched/fair.c env->imbalance = max_t(long, env->imbalance, env 8515 kernel/sched/fair.c if (env->imbalance < busiest->load_per_task) env 8516 kernel/sched/fair.c return fix_small_imbalance(env, sds); env 8532 kernel/sched/fair.c static struct sched_group *find_busiest_group(struct lb_env *env) env 8543 kernel/sched/fair.c update_sd_lb_stats(env, &sds); env 8546 kernel/sched/fair.c struct root_domain *rd = env->dst_rq->rd; env 8556 kernel/sched/fair.c if (check_asym_packing(env, &sds)) env 8579 kernel/sched/fair.c if (env->idle != CPU_NOT_IDLE && group_has_capacity(env, local) && env 8601 kernel/sched/fair.c if (env->idle == CPU_IDLE) { env 8618 kernel/sched/fair.c env->sd->imbalance_pct * local->avg_load) env 8624 kernel/sched/fair.c env->src_grp_type = busiest->group_type; env 8625 kernel/sched/fair.c calculate_imbalance(env, &sds); env 8626 kernel/sched/fair.c return env->imbalance ? sds.busiest : NULL; env 8629 kernel/sched/fair.c env->imbalance = 0; env 8636 kernel/sched/fair.c static struct rq *find_busiest_queue(struct lb_env *env, env 8643 kernel/sched/fair.c for_each_cpu_and(i, sched_group_span(group), env->cpus) { env 8669 kernel/sched/fair.c if (rt > env->fbq_type) env 8676 kernel/sched/fair.c if (env->src_grp_type == group_misfit_task) { env 8693 kernel/sched/fair.c if (env->sd->flags & SD_ASYM_CPUCAPACITY && env 8694 kernel/sched/fair.c capacity_of(env->dst_cpu) < capacity && env 8705 kernel/sched/fair.c if (rq->nr_running == 1 && load > env->imbalance && env 8706 kernel/sched/fair.c !check_cpu_capacity(rq, env->sd)) env 8737 kernel/sched/fair.c asym_active_balance(struct lb_env *env) env 8744 kernel/sched/fair.c return env->idle != CPU_NOT_IDLE && (env->sd->flags & SD_ASYM_PACKING) && env 8745 kernel/sched/fair.c sched_asym_prefer(env->dst_cpu, env->src_cpu); env 8749 kernel/sched/fair.c voluntary_active_balance(struct lb_env *env) env 8751 kernel/sched/fair.c struct sched_domain *sd = env->sd; env 8753 kernel/sched/fair.c if (asym_active_balance(env)) env 8762 kernel/sched/fair.c if ((env->idle != CPU_NOT_IDLE) && env 8763 kernel/sched/fair.c (env->src_rq->cfs.h_nr_running == 1)) { env 8764 kernel/sched/fair.c if ((check_cpu_capacity(env->src_rq, sd)) && env 8765 kernel/sched/fair.c (capacity_of(env->src_cpu)*sd->imbalance_pct < capacity_of(env->dst_cpu)*100)) env 8769 kernel/sched/fair.c if (env->src_grp_type == group_misfit_task) env 8775 kernel/sched/fair.c static int need_active_balance(struct lb_env *env) env 8777 kernel/sched/fair.c struct sched_domain *sd = env->sd; env 8779 kernel/sched/fair.c if (voluntary_active_balance(env)) env 8787 kernel/sched/fair.c static int should_we_balance(struct lb_env *env) env 8789 kernel/sched/fair.c struct sched_group *sg = env->sd->groups; env 8796 kernel/sched/fair.c if (!cpumask_test_cpu(env->dst_cpu, env->cpus)) env 8803 kernel/sched/fair.c if (env->idle == CPU_NEWLY_IDLE) env 8807 kernel/sched/fair.c for_each_cpu_and(cpu, group_balance_mask(sg), env->cpus) { env 8822 kernel/sched/fair.c return balance_cpu == env->dst_cpu; env 8840 kernel/sched/fair.c struct lb_env env = { env 8849 kernel/sched/fair.c .tasks = LIST_HEAD_INIT(env.tasks), env 8857 kernel/sched/fair.c if (!should_we_balance(&env)) { env 8862 kernel/sched/fair.c group = find_busiest_group(&env); env 8868 kernel/sched/fair.c busiest = find_busiest_queue(&env, group); env 8874 kernel/sched/fair.c BUG_ON(busiest == env.dst_rq); env 8876 kernel/sched/fair.c schedstat_add(sd->lb_imbalance[idle], env.imbalance); env 8878 kernel/sched/fair.c env.src_cpu = busiest->cpu; env 8879 kernel/sched/fair.c env.src_rq = busiest; env 8889 kernel/sched/fair.c env.flags |= LBF_ALL_PINNED; env 8890 kernel/sched/fair.c env.loop_max = min(sysctl_sched_nr_migrate, busiest->nr_running); env 8900 kernel/sched/fair.c cur_ld_moved = detach_tasks(&env); env 8913 kernel/sched/fair.c attach_tasks(&env); env 8919 kernel/sched/fair.c if (env.flags & LBF_NEED_BREAK) { env 8920 kernel/sched/fair.c env.flags &= ~LBF_NEED_BREAK; env 8943 kernel/sched/fair.c if ((env.flags & LBF_DST_PINNED) && env.imbalance > 0) { env 8946 kernel/sched/fair.c __cpumask_clear_cpu(env.dst_cpu, env.cpus); env 8948 kernel/sched/fair.c env.dst_rq = cpu_rq(env.new_dst_cpu); env 8949 kernel/sched/fair.c env.dst_cpu = env.new_dst_cpu; env 8950 kernel/sched/fair.c env.flags &= ~LBF_DST_PINNED; env 8951 kernel/sched/fair.c env.loop = 0; env 8952 kernel/sched/fair.c env.loop_break = sched_nr_migrate_break; env 8967 kernel/sched/fair.c if ((env.flags & LBF_SOME_PINNED) && env.imbalance > 0) env 8972 kernel/sched/fair.c if (unlikely(env.flags & LBF_ALL_PINNED)) { env 8982 kernel/sched/fair.c if (!cpumask_subset(cpus, env.dst_grpmask)) { env 8983 kernel/sched/fair.c env.loop = 0; env 8984 kernel/sched/fair.c env.loop_break = sched_nr_migrate_break; env 9002 kernel/sched/fair.c if (need_active_balance(&env)) { env 9015 kernel/sched/fair.c env.flags |= LBF_ALL_PINNED; env 9043 kernel/sched/fair.c if (likely(!active_balance) || voluntary_active_balance(&env)) { env 9065 kernel/sched/fair.c if (sd_parent && !(env.flags & LBF_ALL_PINNED)) { env 9091 kernel/sched/fair.c if (env.idle == CPU_NEWLY_IDLE) env 9095 kernel/sched/fair.c if ((env.flags & LBF_ALL_PINNED && env 9181 kernel/sched/fair.c struct lb_env env = { env 9200 kernel/sched/fair.c p = detach_one_task(&env); env 117 lib/kobject_uevent.c struct kobj_uevent_env *env = NULL; env 128 lib/kobject_uevent.c env = kzalloc(sizeof(*env), GFP_KERNEL); env 129 lib/kobject_uevent.c if (!env) env 134 lib/kobject_uevent.c add_uevent_var(env, "SYNTH_UUID=%.*s", UUID_STRING_LEN, buf)) env 168 lib/kobject_uevent.c if (add_uevent_var(env, "SYNTH_ARG_%.*s=%.*s", env 176 lib/kobject_uevent.c kfree(env); env 178 lib/kobject_uevent.c *ret_env = env; env 197 lib/kobject_uevent.c struct kobj_uevent_env *env; env 213 lib/kobject_uevent.c count - (action_args - buf), &env); env 222 lib/kobject_uevent.c r = kobject_uevent_env(kobj, action, env->envp); env 223 lib/kobject_uevent.c kfree(env); env 252 lib/kobject_uevent.c static int init_uevent_argv(struct kobj_uevent_env *env, const char *subsystem) env 256 lib/kobject_uevent.c len = strlcpy(&env->buf[env->buflen], subsystem, env 257 lib/kobject_uevent.c sizeof(env->buf) - env->buflen); env 258 lib/kobject_uevent.c if (len >= (sizeof(env->buf) - env->buflen)) { env 263 lib/kobject_uevent.c env->argv[0] = uevent_helper; env 264 lib/kobject_uevent.c env->argv[1] = &env->buf[env->buflen]; env 265 lib/kobject_uevent.c env->argv[2] = NULL; env 267 lib/kobject_uevent.c env->buflen += len + 1; env 278 lib/kobject_uevent.c static struct sk_buff *alloc_uevent_skb(struct kobj_uevent_env *env, env 289 lib/kobject_uevent.c skb = alloc_skb(len + env->buflen, GFP_KERNEL); env 297 lib/kobject_uevent.c skb_put_data(skb, env->buf, env->buflen); env 308 lib/kobject_uevent.c static int uevent_net_broadcast_untagged(struct kobj_uevent_env *env, env 325 lib/kobject_uevent.c skb = alloc_uevent_skb(env, action_string, devpath); env 342 lib/kobject_uevent.c struct kobj_uevent_env *env, env 350 lib/kobject_uevent.c skb = alloc_uevent_skb(env, action_string, devpath); env 381 lib/kobject_uevent.c struct kobj_uevent_env *env, env 408 lib/kobject_uevent.c ret = uevent_net_broadcast_untagged(env, action_string, env 411 lib/kobject_uevent.c ret = uevent_net_broadcast_tagged(net->uevent_sock->sk, env, env 418 lib/kobject_uevent.c static void zap_modalias_env(struct kobj_uevent_env *env) env 424 lib/kobject_uevent.c for (i = 0; i < env->envp_idx;) { env 425 lib/kobject_uevent.c if (strncmp(env->envp[i], modalias_prefix, env 431 lib/kobject_uevent.c len = strlen(env->envp[i]) + 1; env 433 lib/kobject_uevent.c if (i != env->envp_idx - 1) { env 434 lib/kobject_uevent.c memmove(env->envp[i], env->envp[i + 1], env 435 lib/kobject_uevent.c env->buflen - len); env 437 lib/kobject_uevent.c for (j = i; j < env->envp_idx - 1; j++) env 438 lib/kobject_uevent.c env->envp[j] = env->envp[j + 1] - len; env 441 lib/kobject_uevent.c env->envp_idx--; env 442 lib/kobject_uevent.c env->buflen -= len; env 459 lib/kobject_uevent.c struct kobj_uevent_env *env; env 523 lib/kobject_uevent.c env = kzalloc(sizeof(struct kobj_uevent_env), GFP_KERNEL); env 524 lib/kobject_uevent.c if (!env) env 535 lib/kobject_uevent.c retval = add_uevent_var(env, "ACTION=%s", action_string); env 538 lib/kobject_uevent.c retval = add_uevent_var(env, "DEVPATH=%s", devpath); env 541 lib/kobject_uevent.c retval = add_uevent_var(env, "SUBSYSTEM=%s", subsystem); env 548 lib/kobject_uevent.c retval = add_uevent_var(env, "%s", envp_ext[i]); env 556 lib/kobject_uevent.c retval = uevent_ops->uevent(kset, kobj, env); env 578 lib/kobject_uevent.c zap_modalias_env(env); env 587 lib/kobject_uevent.c retval = add_uevent_var(env, "SEQNUM=%llu", ++uevent_seqnum); env 592 lib/kobject_uevent.c retval = kobject_uevent_net_broadcast(kobj, env, action_string, env 601 lib/kobject_uevent.c retval = add_uevent_var(env, "HOME=/"); env 604 lib/kobject_uevent.c retval = add_uevent_var(env, env 608 lib/kobject_uevent.c retval = init_uevent_argv(env, subsystem); env 613 lib/kobject_uevent.c info = call_usermodehelper_setup(env->argv[0], env->argv, env 614 lib/kobject_uevent.c env->envp, GFP_KERNEL, env 615 lib/kobject_uevent.c NULL, cleanup_uevent_env, env); env 618 lib/kobject_uevent.c env = NULL; /* freed by cleanup_uevent_env */ env 625 lib/kobject_uevent.c kfree(env); env 653 lib/kobject_uevent.c int add_uevent_var(struct kobj_uevent_env *env, const char *format, ...) env 658 lib/kobject_uevent.c if (env->envp_idx >= ARRAY_SIZE(env->envp)) { env 664 lib/kobject_uevent.c len = vsnprintf(&env->buf[env->buflen], env 665 lib/kobject_uevent.c sizeof(env->buf) - env->buflen, env 669 lib/kobject_uevent.c if (len >= (sizeof(env->buf) - env->buflen)) { env 674 lib/kobject_uevent.c env->envp[env->envp_idx++] = &env->buf[env->buflen]; env 675 lib/kobject_uevent.c env->buflen += len + 1; env 117 net/atm/atm_sysfs.c static int atm_uevent(struct device *cdev, struct kobj_uevent_env *env) env 128 net/atm/atm_sysfs.c if (add_uevent_var(env, "NAME=%s%d", adev->type, adev->number)) env 1610 net/core/net-sysfs.c static int netdev_uevent(struct device *d, struct kobj_uevent_env *env) env 1616 net/core/net-sysfs.c retval = add_uevent_var(env, "INTERFACE=%s", dev->name); env 1624 net/core/net-sysfs.c retval = add_uevent_var(env, "IFINDEX=%d", dev->ifindex); env 810 net/rfkill/core.c static int rfkill_dev_uevent(struct device *dev, struct kobj_uevent_env *env) env 817 net/rfkill/core.c error = add_uevent_var(env, "RFKILL_NAME=%s", rfkill->name); env 820 net/rfkill/core.c error = add_uevent_var(env, "RFKILL_TYPE=%s", env 827 net/rfkill/core.c error = add_uevent_var(env, "RFKILL_STATE=%d", env 50 net/wireless/core.h enum environment_cap env; env 546 net/wireless/reg.c char *env[] = { country, NULL }; env 563 net/wireless/reg.c ret = kobject_uevent_env(®_pdev->dev.kobj, KOBJ_CHANGE, env); env 3039 net/wireless/reg.c enum environment_cap env = ENVIRON_ANY; env 3057 net/wireless/reg.c env = ENVIRON_INDOOR; env 3059 net/wireless/reg.c env = ENVIRON_OUTDOOR; env 3080 net/wireless/reg.c request->country_ie_env = env; env 84 net/wireless/sysfs.c static int wiphy_uevent(struct device *dev, struct kobj_uevent_env *env) env 850 scripts/kconfig/confdata.c char *env; env 870 scripts/kconfig/confdata.c env = getenv("KCONFIG_OVERWRITECONFIG"); env 871 scripts/kconfig/confdata.c if (env && *env) { env 1251 scripts/kconfig/confdata.c char *env = getenv("KCONFIG_PROBABILITY"); env 1253 scripts/kconfig/confdata.c while( env && *env ) { env 1255 scripts/kconfig/confdata.c int tmp = strtol( env, &endp, 10 ); env 1263 scripts/kconfig/confdata.c env = (*endp == ':') ? endp+1 : endp; env 1446 scripts/kconfig/gconf.c char *env; env 1458 scripts/kconfig/gconf.c env = getenv(SRCTREE); env 1459 scripts/kconfig/gconf.c if (env) env 1460 scripts/kconfig/gconf.c glade_file = g_strconcat(env, "/scripts/kconfig/gconf.glade", NULL); env 46 scripts/kconfig/preprocess.c struct env *e; env 55 scripts/kconfig/preprocess.c static void env_del(struct env *e) env 66 scripts/kconfig/preprocess.c struct env *e; env 92 scripts/kconfig/preprocess.c struct env *e, *tmp; env 1570 security/tomoyo/common.c tomoyo_set_string(head, ptr->env->name); env 759 security/tomoyo/common.h const struct tomoyo_path_info *env; /* environment variable */ env 973 security/tomoyo/common.h int tomoyo_env_perm(struct tomoyo_request_info *r, const char *env); env 24 security/tomoyo/environ.c return tomoyo_path_matches_pattern(r->param.environ.name, acl->env); env 50 security/tomoyo/environ.c int tomoyo_env_perm(struct tomoyo_request_info *r, const char *env) env 55 security/tomoyo/environ.c if (!env || !*env) env 57 security/tomoyo/environ.c environ.name = env; env 82 security/tomoyo/environ.c return p1->env == p2->env; env 102 security/tomoyo/environ.c e.env = tomoyo_get_name(data); env 103 security/tomoyo/environ.c if (!e.env) env 107 security/tomoyo/environ.c tomoyo_put_name(e.env); env 211 security/tomoyo/gc.c tomoyo_put_name(entry->env); env 58 sound/aoa/soundbus/core.c static int soundbus_uevent(struct device *dev, struct kobj_uevent_env *env) env 76 sound/aoa/soundbus/core.c retval = add_uevent_var(env, "OF_NAME=%pOFn", of->dev.of_node); env 80 sound/aoa/soundbus/core.c retval = add_uevent_var(env, "OF_TYPE=%s", of_node_get_device_type(of->dev.of_node)); env 90 sound/aoa/soundbus/core.c int tmp = env->buflen; env 91 sound/aoa/soundbus/core.c retval = add_uevent_var(env, "OF_COMPATIBLE_%d=%s", seen, compat); env 94 sound/aoa/soundbus/core.c compat += env->buflen - tmp; env 95 sound/aoa/soundbus/core.c cplen -= env->buflen - tmp; env 99 sound/aoa/soundbus/core.c retval = add_uevent_var(env, "OF_COMPATIBLE_N=%d", seen); env 102 sound/aoa/soundbus/core.c retval = add_uevent_var(env, "MODALIAS=%s", soundbus_dev->modalias); env 68 sound/hda/hda_bus_type.c static int hda_uevent(struct device *dev, struct kobj_uevent_env *env) env 74 sound/hda/hda_bus_type.c if (add_uevent_var(env, "MODALIAS=%s", modalias)) env 116 tools/lib/subcmd/exec-cmd.c char *env; env 121 tools/lib/subcmd/exec-cmd.c env = getenv(subcmd_config.exec_path_env); env 122 tools/lib/subcmd/exec-cmd.c if (env && *env) env 123 tools/lib/subcmd/exec-cmd.c return strdup(env); env 115 tools/lib/subcmd/run-command.c if (cmd->env) { env 116 tools/lib/subcmd/run-command.c for (; *cmd->env; cmd->env++) { env 117 tools/lib/subcmd/run-command.c if (strchr(*cmd->env, '=')) env 118 tools/lib/subcmd/run-command.c putenv((char*)*cmd->env); env 120 tools/lib/subcmd/run-command.c unsetenv(*cmd->env); env 43 tools/lib/subcmd/run-command.h const char *const *env; env 97 tools/perf/arch/common.c char *env = getenv("PATH"); env 99 tools/perf/arch/common.c if (!env) env 102 tools/perf/arch/common.c env = strdup(env); env 103 tools/perf/arch/common.c if (!env) env 106 tools/perf/arch/common.c path = strtok_r(env, ":", &tmp); env 115 tools/perf/arch/common.c free(env); env 132 tools/perf/arch/common.c static int perf_env__lookup_binutils_path(struct perf_env *env, env 136 tools/perf/arch/common.c const char *arch = perf_env__arch(env), *cross_env; env 205 tools/perf/arch/common.c int perf_env__lookup_objdump(struct perf_env *env, const char **path) env 211 tools/perf/arch/common.c if (env->arch == NULL) env 214 tools/perf/arch/common.c return perf_env__lookup_binutils_path(env, "objdump", path); env 222 tools/perf/arch/common.c bool perf_env__single_address_space(struct perf_env *env) env 224 tools/perf/arch/common.c return strcmp(perf_env__arch(env), "sparc"); env 9 tools/perf/arch/common.h int perf_env__lookup_objdump(struct perf_env *env, const char **path); env 10 tools/perf/arch/common.h bool perf_env__single_address_space(struct perf_env *env); env 405 tools/perf/builtin-annotate.c ret = perf_env__lookup_objdump(&session->header.env, env 605 tools/perf/builtin-annotate.c ret = symbol__init(&annotate.session->header.env); env 430 tools/perf/builtin-buildid-cache.c if (symbol__init(session ? &session->header.env : NULL) < 0) env 2039 tools/perf/builtin-c2c.c c2c.nodes_cnt = session->header.env.nr_numa_nodes; env 2040 tools/perf/builtin-c2c.c c2c.cpus_cnt = session->header.env.nr_cpus_avail; env 2042 tools/perf/builtin-c2c.c n = session->header.env.numa_nodes; env 2803 tools/perf/builtin-c2c.c err = mem2node__init(&c2c.mem2node, &session->header.env); env 2811 tools/perf/builtin-c2c.c if (symbol__init(&session->header.env) < 0) env 868 tools/perf/builtin-inject.c ret = symbol__init(&inject.session->header.env); env 1988 tools/perf/builtin-kmem.c symbol__init(&session->header.env); env 720 tools/perf/builtin-kvm.c cpuid = kvm->session->header.env.cpuid; env 1102 tools/perf/builtin-kvm.c symbol__init(&kvm->session->header.env); env 881 tools/perf/builtin-lock.c symbol__init(&session->header.env); env 263 tools/perf/builtin-mem.c ret = symbol__init(&session->header.env); env 1383 tools/perf/builtin-record.c session->header.env.comp_type = PERF_COMP_ZSTD; env 1384 tools/perf/builtin-record.c session->header.env.comp_level = rec->opts.comp_level; env 1389 tools/perf/builtin-record.c session->header.env.clockid_res_ns = rec->opts.clockid_res_ns; env 1415 tools/perf/builtin-record.c session->header.env.comp_mmap_len = session->evlist->core.mmap_len; env 1458 tools/perf/builtin-record.c bpf_event__add_sb_event(&sb_evlist, &session->header.env); env 1669 tools/perf/builtin-record.c session->header.env.comp_ratio = ratio + 0.5; env 586 tools/perf/builtin-report.c &session->header.env, env 1449 tools/perf/builtin-report.c if (symbol__init(&session->header.env) < 0) env 1807 tools/perf/builtin-sched.c symbol__init(&session->header.env); env 2999 tools/perf/builtin-sched.c symbol__init(&session->header.env); env 3027 tools/perf/builtin-sched.c sched->max_cpu = session->header.env.nr_cpus_online; env 3772 tools/perf/builtin-script.c if (symbol__init(&session->header.env) < 0) env 3777 tools/perf/builtin-script.c !strcmp(uts.machine, session->header.env.arch) || env 3779 tools/perf/builtin-script.c !strcmp(session->header.env.arch, "i386"))) env 934 tools/perf/builtin-stat.c static inline int perf_env__get_cpu(struct perf_env *env, struct perf_cpu_map *map, int idx) env 943 tools/perf/builtin-stat.c if (cpu >= env->nr_cpus_avail) env 951 tools/perf/builtin-stat.c struct perf_env *env = data; env 952 tools/perf/builtin-stat.c int cpu = perf_env__get_cpu(env, map, idx); env 954 tools/perf/builtin-stat.c return cpu == -1 ? -1 : env->cpu[cpu].socket_id; env 959 tools/perf/builtin-stat.c struct perf_env *env = data; env 960 tools/perf/builtin-stat.c int die_id = -1, cpu = perf_env__get_cpu(env, map, idx); env 969 tools/perf/builtin-stat.c if (WARN_ONCE(env->cpu[cpu].socket_id >> 8, "The socket id number is too big.\n")) env 972 tools/perf/builtin-stat.c if (WARN_ONCE(env->cpu[cpu].die_id >> 8, "The die id number is too big.\n")) env 975 tools/perf/builtin-stat.c die_id = (env->cpu[cpu].socket_id << 8) | (env->cpu[cpu].die_id & 0xff); env 983 tools/perf/builtin-stat.c struct perf_env *env = data; env 984 tools/perf/builtin-stat.c int core = -1, cpu = perf_env__get_cpu(env, map, idx); env 994 tools/perf/builtin-stat.c if (WARN_ONCE(env->cpu[cpu].socket_id >> 8, "The socket id number is too big.\n")) env 997 tools/perf/builtin-stat.c if (WARN_ONCE(env->cpu[cpu].die_id >> 8, "The die id number is too big.\n")) env 1000 tools/perf/builtin-stat.c if (WARN_ONCE(env->cpu[cpu].core_id >> 16, "The core id number is too big.\n")) env 1003 tools/perf/builtin-stat.c core = (env->cpu[cpu].socket_id << 24) | env 1004 tools/perf/builtin-stat.c (env->cpu[cpu].die_id << 16) | env 1005 tools/perf/builtin-stat.c (env->cpu[cpu].core_id & 0xffff); env 1011 tools/perf/builtin-stat.c static int perf_env__build_socket_map(struct perf_env *env, struct perf_cpu_map *cpus, env 1014 tools/perf/builtin-stat.c return cpu_map__build_map(cpus, sockp, perf_env__get_socket, env); env 1017 tools/perf/builtin-stat.c static int perf_env__build_die_map(struct perf_env *env, struct perf_cpu_map *cpus, env 1020 tools/perf/builtin-stat.c return cpu_map__build_map(cpus, diep, perf_env__get_die, env); env 1023 tools/perf/builtin-stat.c static int perf_env__build_core_map(struct perf_env *env, struct perf_cpu_map *cpus, env 1026 tools/perf/builtin-stat.c return cpu_map__build_map(cpus, corep, perf_env__get_core, env); env 1032 tools/perf/builtin-stat.c return perf_env__get_socket(map, idx, &perf_stat.session->header.env); env 1037 tools/perf/builtin-stat.c return perf_env__get_die(map, idx, &perf_stat.session->header.env); env 1043 tools/perf/builtin-stat.c return perf_env__get_core(map, idx, &perf_stat.session->header.env); env 1048 tools/perf/builtin-stat.c struct perf_env *env = &st->session->header.env; env 1052 tools/perf/builtin-stat.c if (perf_env__build_socket_map(env, evsel_list->core.cpus, &stat_config.aggr_map)) { env 1059 tools/perf/builtin-stat.c if (perf_env__build_die_map(env, evsel_list->core.cpus, &stat_config.aggr_map)) { env 1066 tools/perf/builtin-stat.c if (perf_env__build_core_map(env, evsel_list->core.cpus, &stat_config.aggr_map)) { env 1459 tools/perf/builtin-stat.c const char **argv = session->header.env.cmdline_argv; env 1460 tools/perf/builtin-stat.c int argc = session->header.env.nr_cmdline; env 1514 tools/perf/builtin-timechart.c tchart->numcpus = ph->env.nr_cpus_avail; env 1521 tools/perf/builtin-timechart.c if (svg_build_topology_map(&ph->env)) env 1608 tools/perf/builtin-timechart.c symbol__init(&session->header.env); env 642 tools/perf/builtin-top.c &top->session->header.env, env 1225 tools/perf/builtin-top.c ret = perf_env__lookup_objdump(&top->session->header.env, env 2086 tools/perf/builtin-trace.c struct perf_env *env = perf_evsel__env(evsel); env 2087 tools/perf/builtin-trace.c const char *arch_name = perf_env__arch(env); env 3600 tools/perf/builtin-trace.c if (symbol__init(&session->header.env) < 0) env 579 tools/perf/tests/code-reading.c machine->env = &perf_env; env 50 tools/perf/tests/mem2node.c struct perf_env env = { env 65 tools/perf/tests/mem2node.c T("failed: mem2node__init", !mem2node__init(&map, &env)); env 94 tools/perf/tests/topology.c if (!session->header.env.cpu) env 97 tools/perf/tests/topology.c for (i = 0; i < session->header.env.nr_cpus_avail; i++) { env 101 tools/perf/tests/topology.c session->header.env.cpu[i].core_id, env 102 tools/perf/tests/topology.c session->header.env.cpu[i].socket_id); env 107 tools/perf/tests/topology.c (session->header.env.cpu[map->map[i]].core_id == (cpu_map__get_core(map, i, NULL) & 0xffff))); env 110 tools/perf/tests/topology.c (session->header.env.cpu[map->map[i]].socket_id == cpu_map__get_socket(map, i, NULL))); env 74 tools/perf/ui/browser.h int tui__header_window(struct perf_env *env); env 95 tools/perf/ui/browsers/header.c int tui__header_window(struct perf_env *env) env 104 tools/perf/ui/browsers/header.c session = container_of(env, struct perf_session, header.env); env 2198 tools/perf/ui/browsers/hists.c struct perf_env *env, env 2205 tools/perf/ui/browsers/hists.c browser->env = env; env 2376 tools/perf/ui/browsers/hists.c perf_env__lookup_objdump(browser->env, &browser->annotation_opts->objdump_path)) env 2828 tools/perf/ui/browsers/hists.c struct perf_env *env, env 2833 tools/perf/ui/browsers/hists.c struct hist_browser *browser = perf_evsel_browser__new(evsel, hbt, env, annotation_opts); env 2997 tools/perf/ui/browsers/hists.c if (env->arch) env 2998 tools/perf/ui/browsers/hists.c tui__header_window(env); env 3217 tools/perf/ui/browsers/hists.c struct perf_env *env; env 3316 tools/perf/ui/browsers/hists.c menu->env, env 3376 tools/perf/ui/browsers/hists.c struct perf_env *env, env 3392 tools/perf/ui/browsers/hists.c .env = env, env 3413 tools/perf/ui/browsers/hists.c struct perf_env *env, env 3425 tools/perf/ui/browsers/hists.c env, warn_lost_event, env 3443 tools/perf/ui/browsers/hists.c hbt, min_pcnt, env, env 16 tools/perf/ui/browsers/hists.h struct perf_env *env; env 1758 tools/perf/util/annotate.c info_node = perf_env__find_bpf_prog_info(dso->bpf_prog.env, env 1776 tools/perf/util/annotate.c node = perf_env__find_btf(dso->bpf_prog.env, env 2085 tools/perf/util/annotate.c struct perf_env *env = perf_evsel__env(evsel); env 2086 tools/perf/util/annotate.c const char *arch_name = perf_env__arch(env); env 2101 tools/perf/util/annotate.c err = arch->init(arch, env ? env->cpuid : NULL); env 39 tools/perf/util/bpf-event.c struct perf_env *env = machine->env; env 44 tools/perf/util/bpf-event.c if (env == NULL) env 47 tools/perf/util/bpf-event.c info_node = perf_env__find_bpf_prog_info(env, id); env 63 tools/perf/util/bpf-event.c map->dso->bpf_prog.env = env; env 93 tools/perf/util/bpf-event.c static int perf_env__fetch_btf(struct perf_env *env, env 111 tools/perf/util/bpf-event.c perf_env__insert_btf(env, node); env 171 tools/perf/util/bpf-event.c struct perf_env *env; env 180 tools/perf/util/bpf-event.c env = session->data ? &session->header.env : &perf_env; env 224 tools/perf/util/bpf-event.c perf_env__fetch_btf(env, info->btf_id, btf); env 278 tools/perf/util/bpf-event.c perf_env__insert_bpf_prog_info(env, info_node); env 344 tools/perf/util/bpf-event.c static void perf_env__add_bpf_info(struct perf_env *env, u32 id) env 376 tools/perf/util/bpf-event.c perf_env__insert_bpf_prog_info(env, info_node); env 388 tools/perf/util/bpf-event.c perf_env__fetch_btf(env, btf_id, btf); env 397 tools/perf/util/bpf-event.c struct perf_env *env = data; env 404 tools/perf/util/bpf-event.c perf_env__add_bpf_info(env, event->bpf.id); env 422 tools/perf/util/bpf-event.c struct perf_env *env) env 439 tools/perf/util/bpf-event.c return perf_evlist__add_sb_event(evlist, &attr, bpf_event__sb_cb, env); env 443 tools/perf/util/bpf-event.c struct perf_env *env, env 460 tools/perf/util/bpf-event.c node = perf_env__find_btf(env, info->btf_id); env 37 tools/perf/util/bpf-event.h struct perf_env *env); env 39 tools/perf/util/bpf-event.h struct perf_env *env, env 50 tools/perf/util/bpf-event.h struct perf_env *env __maybe_unused) env 56 tools/perf/util/bpf-event.h struct perf_env *env __maybe_unused, env 1337 tools/perf/util/data-convert-bt.c ncpus = ph->env.nr_cpus_avail ?: MAX_CPUS; env 1372 tools/perf/util/data-convert-bt.c ADD("host", header->env.hostname); env 1374 tools/perf/util/data-convert-bt.c ADD("release", header->env.os_release); env 1375 tools/perf/util/data-convert-bt.c ADD("version", header->env.version); env 1376 tools/perf/util/data-convert-bt.c ADD("machine", header->env.arch); env 722 tools/perf/util/dso.c node = perf_env__find_bpf_prog_info(dso->bpf_prog.env, dso->bpf_prog.id); env 743 tools/perf/util/dso.c node = perf_env__find_bpf_prog_info(dso->bpf_prog.env, dso->bpf_prog.id); env 191 tools/perf/util/dso.h struct perf_env *env; env 16 tools/perf/util/env.c void perf_env__insert_bpf_prog_info(struct perf_env *env, env 24 tools/perf/util/env.c down_write(&env->bpf_progs.lock); env 25 tools/perf/util/env.c p = &env->bpf_progs.infos.rb_node; env 41 tools/perf/util/env.c rb_insert_color(&info_node->rb_node, &env->bpf_progs.infos); env 42 tools/perf/util/env.c env->bpf_progs.infos_cnt++; env 44 tools/perf/util/env.c up_write(&env->bpf_progs.lock); env 47 tools/perf/util/env.c struct bpf_prog_info_node *perf_env__find_bpf_prog_info(struct perf_env *env, env 53 tools/perf/util/env.c down_read(&env->bpf_progs.lock); env 54 tools/perf/util/env.c n = env->bpf_progs.infos.rb_node; env 68 tools/perf/util/env.c up_read(&env->bpf_progs.lock); env 72 tools/perf/util/env.c void perf_env__insert_btf(struct perf_env *env, struct btf_node *btf_node) env 79 tools/perf/util/env.c down_write(&env->bpf_progs.lock); env 80 tools/perf/util/env.c p = &env->bpf_progs.btfs.rb_node; env 96 tools/perf/util/env.c rb_insert_color(&btf_node->rb_node, &env->bpf_progs.btfs); env 97 tools/perf/util/env.c env->bpf_progs.btfs_cnt++; env 99 tools/perf/util/env.c up_write(&env->bpf_progs.lock); env 102 tools/perf/util/env.c struct btf_node *perf_env__find_btf(struct perf_env *env, __u32 btf_id) env 107 tools/perf/util/env.c down_read(&env->bpf_progs.lock); env 108 tools/perf/util/env.c n = env->bpf_progs.btfs.rb_node; env 122 tools/perf/util/env.c up_read(&env->bpf_progs.lock); env 127 tools/perf/util/env.c static void perf_env__purge_bpf(struct perf_env *env) env 132 tools/perf/util/env.c down_write(&env->bpf_progs.lock); env 134 tools/perf/util/env.c root = &env->bpf_progs.infos; env 146 tools/perf/util/env.c env->bpf_progs.infos_cnt = 0; env 148 tools/perf/util/env.c root = &env->bpf_progs.btfs; env 160 tools/perf/util/env.c env->bpf_progs.btfs_cnt = 0; env 162 tools/perf/util/env.c up_write(&env->bpf_progs.lock); env 165 tools/perf/util/env.c void perf_env__exit(struct perf_env *env) env 169 tools/perf/util/env.c perf_env__purge_bpf(env); env 170 tools/perf/util/env.c zfree(&env->hostname); env 171 tools/perf/util/env.c zfree(&env->os_release); env 172 tools/perf/util/env.c zfree(&env->version); env 173 tools/perf/util/env.c zfree(&env->arch); env 174 tools/perf/util/env.c zfree(&env->cpu_desc); env 175 tools/perf/util/env.c zfree(&env->cpuid); env 176 tools/perf/util/env.c zfree(&env->cmdline); env 177 tools/perf/util/env.c zfree(&env->cmdline_argv); env 178 tools/perf/util/env.c zfree(&env->sibling_cores); env 179 tools/perf/util/env.c zfree(&env->sibling_threads); env 180 tools/perf/util/env.c zfree(&env->pmu_mappings); env 181 tools/perf/util/env.c zfree(&env->cpu); env 183 tools/perf/util/env.c for (i = 0; i < env->nr_numa_nodes; i++) env 184 tools/perf/util/env.c perf_cpu_map__put(env->numa_nodes[i].map); env 185 tools/perf/util/env.c zfree(&env->numa_nodes); env 187 tools/perf/util/env.c for (i = 0; i < env->caches_cnt; i++) env 188 tools/perf/util/env.c cpu_cache_level__free(&env->caches[i]); env 189 tools/perf/util/env.c zfree(&env->caches); env 191 tools/perf/util/env.c for (i = 0; i < env->nr_memory_nodes; i++) env 192 tools/perf/util/env.c zfree(&env->memory_nodes[i].set); env 193 tools/perf/util/env.c zfree(&env->memory_nodes); env 196 tools/perf/util/env.c void perf_env__init(struct perf_env *env) env 198 tools/perf/util/env.c env->bpf_progs.infos = RB_ROOT; env 199 tools/perf/util/env.c env->bpf_progs.btfs = RB_ROOT; env 200 tools/perf/util/env.c init_rwsem(&env->bpf_progs.lock); env 203 tools/perf/util/env.c int perf_env__set_cmdline(struct perf_env *env, int argc, const char *argv[]) env 208 tools/perf/util/env.c env->cmdline_argv = calloc(argc, sizeof(char *)); env 209 tools/perf/util/env.c if (env->cmdline_argv == NULL) env 217 tools/perf/util/env.c env->cmdline_argv[i] = argv[i]; env 218 tools/perf/util/env.c if (env->cmdline_argv[i] == NULL) env 222 tools/perf/util/env.c env->nr_cmdline = argc; env 226 tools/perf/util/env.c zfree(&env->cmdline_argv); env 231 tools/perf/util/env.c int perf_env__read_cpu_topology_map(struct perf_env *env) env 235 tools/perf/util/env.c if (env->cpu != NULL) env 238 tools/perf/util/env.c if (env->nr_cpus_avail == 0) env 239 tools/perf/util/env.c env->nr_cpus_avail = cpu__max_present_cpu(); env 241 tools/perf/util/env.c nr_cpus = env->nr_cpus_avail; env 245 tools/perf/util/env.c env->cpu = calloc(nr_cpus, sizeof(env->cpu[0])); env 246 tools/perf/util/env.c if (env->cpu == NULL) env 250 tools/perf/util/env.c env->cpu[cpu].core_id = cpu_map__get_core_id(cpu); env 251 tools/perf/util/env.c env->cpu[cpu].socket_id = cpu_map__get_socket_id(cpu); env 252 tools/perf/util/env.c env->cpu[cpu].die_id = cpu_map__get_die_id(cpu); env 255 tools/perf/util/env.c env->nr_cpus_avail = nr_cpus; env 259 tools/perf/util/env.c static int perf_env__read_arch(struct perf_env *env) env 263 tools/perf/util/env.c if (env->arch) env 267 tools/perf/util/env.c env->arch = strdup(uts.machine); env 269 tools/perf/util/env.c return env->arch ? 0 : -ENOMEM; env 272 tools/perf/util/env.c static int perf_env__read_nr_cpus_avail(struct perf_env *env) env 274 tools/perf/util/env.c if (env->nr_cpus_avail == 0) env 275 tools/perf/util/env.c env->nr_cpus_avail = cpu__max_present_cpu(); env 277 tools/perf/util/env.c return env->nr_cpus_avail ? 0 : -ENOENT; env 280 tools/perf/util/env.c const char *perf_env__raw_arch(struct perf_env *env) env 282 tools/perf/util/env.c return env && !perf_env__read_arch(env) ? env->arch : "unknown"; env 285 tools/perf/util/env.c int perf_env__nr_cpus_avail(struct perf_env *env) env 287 tools/perf/util/env.c return env && !perf_env__read_nr_cpus_avail(env) ? env->nr_cpus_avail : 0; env 327 tools/perf/util/env.c const char *perf_env__arch(struct perf_env *env) env 332 tools/perf/util/env.c if (!env || !env->arch) { /* Assume local operation */ env 337 tools/perf/util/env.c arch_name = env->arch; env 103 tools/perf/util/env.h void perf_env__exit(struct perf_env *env); env 105 tools/perf/util/env.h int perf_env__set_cmdline(struct perf_env *env, int argc, const char *argv[]); env 107 tools/perf/util/env.h int perf_env__read_cpu_topology_map(struct perf_env *env); env 111 tools/perf/util/env.h const char *perf_env__arch(struct perf_env *env); env 112 tools/perf/util/env.h const char *perf_env__raw_arch(struct perf_env *env); env 113 tools/perf/util/env.h int perf_env__nr_cpus_avail(struct perf_env *env); env 115 tools/perf/util/env.h void perf_env__init(struct perf_env *env); env 116 tools/perf/util/env.h void perf_env__insert_bpf_prog_info(struct perf_env *env, env 118 tools/perf/util/env.h struct bpf_prog_info_node *perf_env__find_bpf_prog_info(struct perf_env *env, env 120 tools/perf/util/env.h void perf_env__insert_btf(struct perf_env *env, struct btf_node *btf_node); env 121 tools/perf/util/env.h struct btf_node *perf_env__find_btf(struct perf_env *env, __u32 btf_id); env 581 tools/perf/util/event.c struct perf_env *env = machine->env; env 583 tools/perf/util/event.c if (env && env->cpu) env 584 tools/perf/util/event.c al->socket = env->cpu[al->cpu].socket_id; env 67 tools/perf/util/evlist.h struct perf_env *env; env 2515 tools/perf/util/evsel.c return evsel->evlist->env; env 895 tools/perf/util/header.c return do_write(ff, &ff->ph->env.clockid_res_ns, env 896 tools/perf/util/header.c sizeof(ff->ph->env.clockid_res_ns)); env 918 tools/perf/util/header.c struct perf_env *env = &ff->ph->env; env 923 tools/perf/util/header.c down_read(&env->bpf_progs.lock); env 925 tools/perf/util/header.c ret = do_write(ff, &env->bpf_progs.infos_cnt, env 926 tools/perf/util/header.c sizeof(env->bpf_progs.infos_cnt)); env 930 tools/perf/util/header.c root = &env->bpf_progs.infos; env 953 tools/perf/util/header.c up_read(&env->bpf_progs.lock); env 967 tools/perf/util/header.c struct perf_env *env = &ff->ph->env; env 972 tools/perf/util/header.c down_read(&env->bpf_progs.lock); env 974 tools/perf/util/header.c ret = do_write(ff, &env->bpf_progs.btfs_cnt, env 975 tools/perf/util/header.c sizeof(env->bpf_progs.btfs_cnt)); env 980 tools/perf/util/header.c root = &env->bpf_progs.btfs; env 993 tools/perf/util/header.c up_read(&env->bpf_progs.lock); env 1379 tools/perf/util/header.c ret = do_write(ff, &(ff->ph->env.comp_ver), sizeof(ff->ph->env.comp_ver)); env 1383 tools/perf/util/header.c ret = do_write(ff, &(ff->ph->env.comp_type), sizeof(ff->ph->env.comp_type)); env 1387 tools/perf/util/header.c ret = do_write(ff, &(ff->ph->env.comp_level), sizeof(ff->ph->env.comp_level)); env 1391 tools/perf/util/header.c ret = do_write(ff, &(ff->ph->env.comp_ratio), sizeof(ff->ph->env.comp_ratio)); env 1395 tools/perf/util/header.c return do_write(ff, &(ff->ph->env.comp_mmap_len), sizeof(ff->ph->env.comp_mmap_len)); env 1400 tools/perf/util/header.c fprintf(fp, "# hostname : %s\n", ff->ph->env.hostname); env 1405 tools/perf/util/header.c fprintf(fp, "# os release : %s\n", ff->ph->env.os_release); env 1410 tools/perf/util/header.c fprintf(fp, "# arch : %s\n", ff->ph->env.arch); env 1415 tools/perf/util/header.c fprintf(fp, "# cpudesc : %s\n", ff->ph->env.cpu_desc); env 1420 tools/perf/util/header.c fprintf(fp, "# nrcpus online : %u\n", ff->ph->env.nr_cpus_online); env 1421 tools/perf/util/header.c fprintf(fp, "# nrcpus avail : %u\n", ff->ph->env.nr_cpus_avail); env 1426 tools/perf/util/header.c fprintf(fp, "# perf version : %s\n", ff->ph->env.version); env 1433 tools/perf/util/header.c nr = ff->ph->env.nr_cmdline; env 1438 tools/perf/util/header.c char *argv_i = strdup(ff->ph->env.cmdline_argv[i]); env 1440 tools/perf/util/header.c fprintf(fp, "%s ", ff->ph->env.cmdline_argv[i]); env 1461 tools/perf/util/header.c int cpu_nr = ph->env.nr_cpus_avail; env 1465 tools/perf/util/header.c nr = ph->env.nr_sibling_cores; env 1466 tools/perf/util/header.c str = ph->env.sibling_cores; env 1473 tools/perf/util/header.c if (ph->env.nr_sibling_dies) { env 1474 tools/perf/util/header.c nr = ph->env.nr_sibling_dies; env 1475 tools/perf/util/header.c str = ph->env.sibling_dies; env 1483 tools/perf/util/header.c nr = ph->env.nr_sibling_threads; env 1484 tools/perf/util/header.c str = ph->env.sibling_threads; env 1491 tools/perf/util/header.c if (ph->env.nr_sibling_dies) { env 1492 tools/perf/util/header.c if (ph->env.cpu != NULL) { env 1496 tools/perf/util/header.c i, ph->env.cpu[i].core_id, env 1497 tools/perf/util/header.c ph->env.cpu[i].die_id, env 1498 tools/perf/util/header.c ph->env.cpu[i].socket_id); env 1503 tools/perf/util/header.c if (ph->env.cpu != NULL) { env 1507 tools/perf/util/header.c i, ph->env.cpu[i].core_id, env 1508 tools/perf/util/header.c ph->env.cpu[i].socket_id); env 1518 tools/perf/util/header.c ff->ph->env.clockid_res_ns * 1000); env 1534 tools/perf/util/header.c struct perf_env *env = &ff->ph->env; env 1538 tools/perf/util/header.c down_read(&env->bpf_progs.lock); env 1540 tools/perf/util/header.c root = &env->bpf_progs.infos; env 1550 tools/perf/util/header.c env, fp); env 1553 tools/perf/util/header.c up_read(&env->bpf_progs.lock); env 1558 tools/perf/util/header.c struct perf_env *env = &ff->ph->env; env 1562 tools/perf/util/header.c down_read(&env->bpf_progs.lock); env 1564 tools/perf/util/header.c root = &env->bpf_progs.btfs; env 1575 tools/perf/util/header.c up_read(&env->bpf_progs.lock); env 1717 tools/perf/util/header.c fprintf(fp, "# total memory : %llu kB\n", ff->ph->env.total_mem); env 1725 tools/perf/util/header.c for (i = 0; i < ff->ph->env.nr_numa_nodes; i++) { env 1726 tools/perf/util/header.c n = &ff->ph->env.numa_nodes[i]; env 1739 tools/perf/util/header.c fprintf(fp, "# cpuid : %s\n", ff->ph->env.cpuid); env 1762 tools/perf/util/header.c for (i = 0; i < ff->ph->env.caches_cnt; i++) { env 1764 tools/perf/util/header.c cpu_cache_level__fprintf(fp, &ff->ph->env.caches[i]); env 1771 tools/perf/util/header.c ff->ph->env.comp_type == PERF_COMP_ZSTD ? "Zstd" : "Unknown", env 1772 tools/perf/util/header.c ff->ph->env.comp_level, ff->ph->env.comp_ratio); env 1782 tools/perf/util/header.c pmu_num = ff->ph->env.nr_pmu_mappings; env 1788 tools/perf/util/header.c str = ff->ph->env.pmu_mappings; env 1875 tools/perf/util/header.c nodes = ff->ph->env.memory_nodes; env 1876 tools/perf/util/header.c nr = ff->ph->env.nr_memory_nodes; env 1879 tools/perf/util/header.c nr, ff->ph->env.memory_bsize); env 1882 tools/perf/util/header.c memory_node__fprintf(&nodes[i], ff->ph->env.memory_bsize, fp); env 2045 tools/perf/util/header.c ff->ph->env.__feat_env = do_read_string(ff); \ env 2046 tools/perf/util/header.c return ff->ph->env.__feat_env ? 0 : -ENOMEM; \ env 2082 tools/perf/util/header.c ff->ph->env.nr_cpus_avail = (int)nr_cpus_avail; env 2083 tools/perf/util/header.c ff->ph->env.nr_cpus_online = (int)nr_cpus_online; env 2095 tools/perf/util/header.c ff->ph->env.total_mem = (unsigned long long)total_mem; env 2165 tools/perf/util/header.c ff->ph->env.nr_cmdline = nr; env 2185 tools/perf/util/header.c ff->ph->env.cmdline = cmdline; env 2186 tools/perf/util/header.c ff->ph->env.cmdline_argv = (const char **) argv; env 2200 tools/perf/util/header.c int cpu_nr = ff->ph->env.nr_cpus_avail; env 2205 tools/perf/util/header.c ph->env.cpu = calloc(cpu_nr, sizeof(*ph->env.cpu)); env 2206 tools/perf/util/header.c if (!ph->env.cpu) env 2212 tools/perf/util/header.c ph->env.nr_sibling_cores = nr; env 2228 tools/perf/util/header.c ph->env.sibling_cores = strbuf_detach(&sb, NULL); env 2233 tools/perf/util/header.c ph->env.nr_sibling_threads = nr; env 2247 tools/perf/util/header.c ph->env.sibling_threads = strbuf_detach(&sb, NULL); env 2254 tools/perf/util/header.c zfree(&ph->env.cpu); env 2263 tools/perf/util/header.c if (ph->env.arch && (!strncmp(ph->env.arch, "s390", 4) env 2264 tools/perf/util/header.c || !strncmp(ph->env.arch, "aarch64", 7))) env 2271 tools/perf/util/header.c ph->env.cpu[i].core_id = nr; env 2283 tools/perf/util/header.c ph->env.cpu[i].socket_id = nr; env 2297 tools/perf/util/header.c ph->env.nr_sibling_dies = nr; env 2311 tools/perf/util/header.c ph->env.sibling_dies = strbuf_detach(&sb, NULL); env 2317 tools/perf/util/header.c ph->env.cpu[i].die_id = nr; env 2325 tools/perf/util/header.c zfree(&ph->env.cpu); env 2366 tools/perf/util/header.c ff->ph->env.nr_numa_nodes = nr; env 2367 tools/perf/util/header.c ff->ph->env.numa_nodes = nodes; env 2390 tools/perf/util/header.c ff->ph->env.nr_pmu_mappings = pmu_num; env 2409 tools/perf/util/header.c ff->ph->env.msr_pmu_type = type; env 2414 tools/perf/util/header.c ff->ph->env.pmu_mappings = strbuf_detach(&sb, NULL); env 2437 tools/perf/util/header.c ff->ph->env.nr_groups = nr_groups; env 2564 tools/perf/util/header.c ff->ph->env.caches = caches; env 2565 tools/perf/util/header.c ff->ph->env.caches_cnt = cnt; env 2634 tools/perf/util/header.c ff->ph->env.memory_bsize = bsize; env 2635 tools/perf/util/header.c ff->ph->env.memory_nodes = nodes; env 2636 tools/perf/util/header.c ff->ph->env.nr_memory_nodes = nr; env 2648 tools/perf/util/header.c if (do_read_u64(ff, &ff->ph->env.clockid_res_ns)) env 2674 tools/perf/util/header.c struct perf_env *env = &ff->ph->env; env 2686 tools/perf/util/header.c down_write(&env->bpf_progs.lock); env 2727 tools/perf/util/header.c perf_env__insert_bpf_prog_info(env, info_node); env 2730 tools/perf/util/header.c up_write(&env->bpf_progs.lock); env 2735 tools/perf/util/header.c up_write(&env->bpf_progs.lock); env 2747 tools/perf/util/header.c struct perf_env *env = &ff->ph->env; env 2760 tools/perf/util/header.c down_write(&env->bpf_progs.lock); env 2780 tools/perf/util/header.c perf_env__insert_btf(env, node); env 2786 tools/perf/util/header.c up_write(&env->bpf_progs.lock); env 2794 tools/perf/util/header.c if (do_read_u32(ff, &(ff->ph->env.comp_ver))) env 2797 tools/perf/util/header.c if (do_read_u32(ff, &(ff->ph->env.comp_type))) env 2800 tools/perf/util/header.c if (do_read_u32(ff, &(ff->ph->env.comp_level))) env 2803 tools/perf/util/header.c if (do_read_u32(ff, &(ff->ph->env.comp_ratio))) env 2806 tools/perf/util/header.c if (do_read_u32(ff, &(ff->ph->env.comp_mmap_len))) env 3544 tools/perf/util/header.c session->evlist->env = &header->env; env 3545 tools/perf/util/header.c session->machines.host.env = &header->env; env 92 tools/perf/util/header.h struct perf_env env; env 467 tools/perf/util/hist.h struct perf_env *env, env 483 tools/perf/util/hist.h struct perf_env *env __maybe_unused, env 853 tools/perf/util/intel-pt.c struct perf_env *env = pt->machine->env; env 937 tools/perf/util/intel-pt.c if (env->cpuid && !strncmp(env->cpuid, "GenuineIntel,6,92,", 18)) env 73 tools/perf/util/llvm-utils.c char *env, *path, *tmp = NULL; env 88 tools/perf/util/llvm-utils.c env = getenv("PATH"); env 89 tools/perf/util/llvm-utils.c if (!env) env 91 tools/perf/util/llvm-utils.c env = strdup(env); env 92 tools/perf/util/llvm-utils.c if (!env) env 96 tools/perf/util/llvm-utils.c path = strtok_r(env, ":", &tmp); env 107 tools/perf/util/llvm-utils.c free(env); env 91 tools/perf/util/machine.c machine->env = NULL; env 2590 tools/perf/util/machine.c int nr_cpus = min(machine->env->nr_cpus_online, MAX_NR_CPUS); env 2602 tools/perf/util/machine.c int nr_cpus = min(machine->env->nr_cpus_online, MAX_NR_CPUS); env 2641 tools/perf/util/machine.c return machine && !strcmp(perf_env__raw_arch(machine->env), arch); env 2646 tools/perf/util/machine.c return machine ? perf_env__nr_cpus_avail(machine->env) : 0; env 51 tools/perf/util/machine.h struct perf_env *env; env 46 tools/perf/util/mem2node.c int mem2node__init(struct mem2node *map, struct perf_env *env) env 48 tools/perf/util/mem2node.c struct memory_node *n, *nodes = &env->memory_nodes[0]; env 50 tools/perf/util/mem2node.c u64 bsize = env->memory_bsize; env 56 tools/perf/util/mem2node.c for (i = 0; i < env->nr_memory_nodes; i++) { env 65 tools/perf/util/mem2node.c for (i = 0; i < env->nr_memory_nodes; i++) { env 16 tools/perf/util/mem2node.h int mem2node__init(struct mem2node *map, struct perf_env *env); env 1138 tools/perf/util/s390-cpumsf.c sf->machine_type = s390_cpumsf_get_type(session->evlist->env->cpuid); env 14 tools/perf/util/sample-raw.c const char *arch_pf = perf_env__arch(evlist->env); env 45 tools/perf/util/session.c size_t mmap_len, decomp_len = session->header.env.comp_mmap_len; env 203 tools/perf/util/session.c perf_env__init(&session->header.env); env 235 tools/perf/util/session.c session->machines.host.env = &perf_env; env 239 tools/perf/util/session.c perf_env__single_address_space(session->machines.host.env); env 297 tools/perf/util/session.c perf_env__exit(&session->header.env); env 2316 tools/perf/util/session.c int nr_cpus = min(session->header.env.nr_cpus_online, MAX_NR_CPUS); env 752 tools/perf/util/svghelper.c int svg_build_topology_map(struct perf_env *env) env 758 tools/perf/util/svghelper.c nr_cpus = min(env->nr_cpus_online, MAX_NR_CPUS); env 760 tools/perf/util/svghelper.c t.sib_core_nr = env->nr_sibling_cores; env 761 tools/perf/util/svghelper.c t.sib_thr_nr = env->nr_sibling_threads; env 762 tools/perf/util/svghelper.c t.sib_core = calloc(env->nr_sibling_cores, sizeof(cpumask_t)); env 763 tools/perf/util/svghelper.c t.sib_thr = calloc(env->nr_sibling_threads, sizeof(cpumask_t)); env 765 tools/perf/util/svghelper.c sib_core = env->sibling_cores; env 766 tools/perf/util/svghelper.c sib_thr = env->sibling_threads; env 773 tools/perf/util/svghelper.c for (i = 0; i < env->nr_sibling_cores; i++) { env 782 tools/perf/util/svghelper.c for (i = 0; i < env->nr_sibling_threads; i++) { env 33 tools/perf/util/svghelper.h int svg_build_topology_map(struct perf_env *env); env 2125 tools/perf/util/symbol.c static int vmlinux_path__init(struct perf_env *env) env 2145 tools/perf/util/symbol.c if (env) { env 2146 tools/perf/util/symbol.c kernel_version = env->os_release; env 2237 tools/perf/util/symbol.c int symbol__init(struct perf_env *env) env 2252 tools/perf/util/symbol.c if (symbol_conf.try_vmlinux_path && vmlinux_path__init(env) < 0) env 164 tools/perf/util/symbol.h int symbol__init(struct perf_env *env); env 139 tools/perf/util/thread-stack.c const char *arch = perf_env__arch(machine->env); env 41 tools/perf/util/unwind-libunwind.c if (!mg->machine->env || !mg->machine->env->arch) env 48 tools/perf/util/unwind-libunwind.c arch = perf_env__arch(mg->machine->env); env 112 tools/testing/selftests/bpf/prog_tests/bpf_obj_id.c (env.jit_enabled && !prog_infos[i].jited_prog_len) || env 113 tools/testing/selftests/bpf/prog_tests/bpf_obj_id.c (env.jit_enabled && env 127 tools/testing/selftests/bpf/prog_tests/bpf_obj_id.c env.jit_enabled, env 94 tools/testing/selftests/bpf/prog_tests/bpf_verif_scale.c if (env.verifier_stats) { env 109 tools/testing/selftests/bpf/prog_tests/bpf_verif_scale.c if (env.verifier_stats) env 44 tools/testing/selftests/bpf/prog_tests/get_stack_raw_tp.c if (env.jit_enabled) { env 61 tools/testing/selftests/bpf/prog_tests/get_stack_raw_tp.c if (env.jit_enabled) { env 11 tools/testing/selftests/bpf/test_progs.c struct test_env env; env 43 tools/testing/selftests/bpf/test_progs.c if (stdout == env.stdout) env 48 tools/testing/selftests/bpf/test_progs.c if (env.verbose || test->force_log || failed) { env 49 tools/testing/selftests/bpf/test_progs.c if (env.log_cnt) { env 50 tools/testing/selftests/bpf/test_progs.c env.log_buf[env.log_cnt] = '\0'; env 51 tools/testing/selftests/bpf/test_progs.c fprintf(env.stdout, "%s", env.log_buf); env 52 tools/testing/selftests/bpf/test_progs.c if (env.log_buf[env.log_cnt - 1] != '\n') env 53 tools/testing/selftests/bpf/test_progs.c fprintf(env.stdout, "\n"); env 62 tools/testing/selftests/bpf/test_progs.c if (env.test->skip_cnt) { env 63 tools/testing/selftests/bpf/test_progs.c env.skip_cnt++; env 64 tools/testing/selftests/bpf/test_progs.c env.test->skip_cnt = 0; env 70 tools/testing/selftests/bpf/test_progs.c struct prog_test_def *test = env.test; env 74 tools/testing/selftests/bpf/test_progs.c env.fail_cnt++; env 76 tools/testing/selftests/bpf/test_progs.c env.sub_succ_cnt++; env 81 tools/testing/selftests/bpf/test_progs.c fprintf(env.stdout, "#%d/%d %s:%s\n", env 91 tools/testing/selftests/bpf/test_progs.c struct prog_test_def *test = env.test; env 99 tools/testing/selftests/bpf/test_progs.c fprintf(env.stderr, env 105 tools/testing/selftests/bpf/test_progs.c if (!should_run(&env.subtest_selector, test->subtest_num, name)) env 110 tools/testing/selftests/bpf/test_progs.c fprintf(env.stderr, env 115 tools/testing/selftests/bpf/test_progs.c env.test->old_error_cnt = env.test->error_cnt; env 121 tools/testing/selftests/bpf/test_progs.c env.test->force_log = true; env 126 tools/testing/selftests/bpf/test_progs.c env.test->skip_cnt++; env 131 tools/testing/selftests/bpf/test_progs.c env.test->error_cnt++; env 138 tools/testing/selftests/bpf/test_progs.c if (!env.test->need_cgroup_cleanup) { env 142 tools/testing/selftests/bpf/test_progs.c env.test->test_num, env.test->test_name); env 146 tools/testing/selftests/bpf/test_progs.c env.test->need_cgroup_cleanup = true; env 153 tools/testing/selftests/bpf/test_progs.c env.test->test_num, env.test->test_name, path, errno); env 160 tools/testing/selftests/bpf/test_progs.c env.test->test_num, env.test->test_name, path, errno); env 356 tools/testing/selftests/bpf/test_progs.c if (!env.very_verbose && level == LIBBPF_DEBUG) env 424 tools/testing/selftests/bpf/test_progs.c struct test_env *env = state->input; env 433 tools/testing/selftests/bpf/test_progs.c &env->subtest_selector)) { env 439 tools/testing/selftests/bpf/test_progs.c if (parse_num_list(arg, &env->test_selector)) { env 450 tools/testing/selftests/bpf/test_progs.c env->subtest_selector.name = strdup(subtest_str + 1); env 451 tools/testing/selftests/bpf/test_progs.c if (!env->subtest_selector.name) env 454 tools/testing/selftests/bpf/test_progs.c env->test_selector.name = strdup(arg); env 455 tools/testing/selftests/bpf/test_progs.c if (!env->test_selector.name) env 460 tools/testing/selftests/bpf/test_progs.c env->verifier_stats = true; env 465 tools/testing/selftests/bpf/test_progs.c env->very_verbose = true; env 473 tools/testing/selftests/bpf/test_progs.c env->verbose = true; env 489 tools/testing/selftests/bpf/test_progs.c env.stdout = stdout; env 490 tools/testing/selftests/bpf/test_progs.c env.stderr = stderr; env 492 tools/testing/selftests/bpf/test_progs.c if (env.verbose) { env 500 tools/testing/selftests/bpf/test_progs.c stdout = open_memstream(&env.log_buf, &env.log_cnt); env 502 tools/testing/selftests/bpf/test_progs.c stdout = env.stdout; env 514 tools/testing/selftests/bpf/test_progs.c if (stdout == env.stdout) env 518 tools/testing/selftests/bpf/test_progs.c free(env.log_buf); env 520 tools/testing/selftests/bpf/test_progs.c env.log_buf = NULL; env 521 tools/testing/selftests/bpf/test_progs.c env.log_cnt = 0; env 523 tools/testing/selftests/bpf/test_progs.c stdout = env.stdout; env 524 tools/testing/selftests/bpf/test_progs.c stderr = env.stderr; env 537 tools/testing/selftests/bpf/test_progs.c err = argp_parse(&argp, argc, argv, 0, NULL, &env); env 545 tools/testing/selftests/bpf/test_progs.c env.jit_enabled = is_jit_enabled(); env 551 tools/testing/selftests/bpf/test_progs.c env.test = test; env 554 tools/testing/selftests/bpf/test_progs.c if (!should_run(&env.test_selector, env 565 tools/testing/selftests/bpf/test_progs.c env.fail_cnt++; env 567 tools/testing/selftests/bpf/test_progs.c env.succ_cnt++; env 572 tools/testing/selftests/bpf/test_progs.c fprintf(env.stdout, "#%d %s:%s\n", env 581 tools/testing/selftests/bpf/test_progs.c env.succ_cnt, env.sub_succ_cnt, env.skip_cnt, env.fail_cnt); env 583 tools/testing/selftests/bpf/test_progs.c free(env.test_selector.num_set); env 584 tools/testing/selftests/bpf/test_progs.c free(env.subtest_selector.num_set); env 586 tools/testing/selftests/bpf/test_progs.c return env.fail_cnt ? EXIT_FAILURE : EXIT_SUCCESS; env 69 tools/testing/selftests/bpf/test_progs.h extern struct test_env env; env 113 tools/testing/selftests/powerpc/mm/wild_bctr.c unsigned long env; env 4281 virt/kvm/kvm_main.c struct kobj_uevent_env *env; env 4298 virt/kvm/kvm_main.c env = kzalloc(sizeof(*env), GFP_KERNEL_ACCOUNT); env 4299 virt/kvm/kvm_main.c if (!env) env 4302 virt/kvm/kvm_main.c add_uevent_var(env, "CREATED=%llu", created); env 4303 virt/kvm/kvm_main.c add_uevent_var(env, "COUNT=%llu", active); env 4306 virt/kvm/kvm_main.c add_uevent_var(env, "EVENT=create"); env 4309 virt/kvm/kvm_main.c add_uevent_var(env, "EVENT=destroy"); env 4311 virt/kvm/kvm_main.c add_uevent_var(env, "PID=%d", kvm->userspace_pid); env 4319 virt/kvm/kvm_main.c add_uevent_var(env, "STATS_PATH=%s", tmp); env 4324 virt/kvm/kvm_main.c env->envp[env->envp_idx++] = NULL; env 4325 virt/kvm/kvm_main.c kobject_uevent_env(&kvm_dev.this_device->kobj, KOBJ_CHANGE, env->envp); env 4326 virt/kvm/kvm_main.c kfree(env);