entry 72 arch/x86/kernel/acpi/boot.c (!entry) || (unsigned long)entry + sizeof(*entry) > end || \
entry 73 arch/x86/kernel/acpi/boot.c ((struct acpi_subtable_header *)entry)->length < sizeof(*entry))
entry 397 arch/x86/kernel/amd_iommu.c for (i = entry->devid_start; i <= entry->devid_end; ++i) {
entry 414 arch/x86/kernel/amd_iommu.c struct unity_map_entry *entry;
entry 417 arch/x86/kernel/amd_iommu.c list_for_each_entry(entry, &amd_iommu_unity_map, list) {
entry 418 arch/x86/kernel/amd_iommu.c if (!iommu_for_unity_map(iommu, entry))
entry 420 arch/x86/kernel/amd_iommu.c ret = dma_ops_unity_map(iommu->default_dom, entry);
entry 789 arch/x86/kernel/amd_iommu.c struct dma_ops_domain *entry, *ret = NULL;
entry 797 arch/x86/kernel/amd_iommu.c list_for_each_entry(entry, &iommu_pd_list, list) {
entry 798 arch/x86/kernel/amd_iommu.c if (entry->target_dev == devid) {
entry 799 arch/x86/kernel/amd_iommu.c ret = entry;
entry 198 arch/x86/kernel/amd_iommu_init.c u64 entry;
entry 203 arch/x86/kernel/amd_iommu_init.c entry = start | MMIO_EXCL_ENABLE_MASK;
entry 205 arch/x86/kernel/amd_iommu_init.c &entry, sizeof(entry));
entry 207 arch/x86/kernel/amd_iommu_init.c entry = limit;
entry 209 arch/x86/kernel/amd_iommu_init.c &entry, sizeof(entry));
entry 215 arch/x86/kernel/amd_iommu_init.c u32 entry;
entry 219 arch/x86/kernel/amd_iommu_init.c entry = virt_to_phys(amd_iommu_dev_table);
entry 220 arch/x86/kernel/amd_iommu_init.c entry |= (dev_table_size >> 12) - 1;
entry 222 arch/x86/kernel/amd_iommu_init.c &entry, sizeof(entry));
entry 418 arch/x86/kernel/amd_iommu_init.c u64 entry;
entry 425 arch/x86/kernel/amd_iommu_init.c entry = (u64)virt_to_phys(cmd_buf);
entry 426 arch/x86/kernel/amd_iommu_init.c entry |= MMIO_CMD_SIZE_512;
entry 428 arch/x86/kernel/amd_iommu_init.c &entry, sizeof(entry));
entry 444 arch/x86/kernel/amd_iommu_init.c u64 entry;
entry 451 arch/x86/kernel/amd_iommu_init.c entry = (u64)virt_to_phys(iommu->evt_buf) | EVT_LEN_MASK;
entry 453 arch/x86/kernel/amd_iommu_init.c &entry, sizeof(entry));
entry 782 arch/x86/kernel/amd_iommu_init.c entries[nvec].entry = curr->evt_msi_num;
entry 864 arch/x86/kernel/amd_iommu_init.c struct unity_map_entry *entry, *next;
entry 866 arch/x86/kernel/amd_iommu_init.c list_for_each_entry_safe(entry, next, &amd_iommu_unity_map, list) {
entry 867 arch/x86/kernel/amd_iommu_init.c list_del(&entry->list);
entry 868 arch/x86/kernel/amd_iommu_init.c kfree(entry);
entry 33 arch/x86/kernel/asm-offsets_64.c #define ENTRY(entry) DEFINE(tsk_ ## entry, offsetof(struct task_struct, entry))
entry 39 arch/x86/kernel/asm-offsets_64.c #define ENTRY(entry) DEFINE(TI_ ## entry, offsetof(struct thread_info, entry))
entry 49 arch/x86/kernel/asm-offsets_64.c #define ENTRY(entry) DEFINE(pda_ ## entry, offsetof(struct x8664_pda, entry))
entry 77 arch/x86/kernel/asm-offsets_64.c #define ENTRY(entry) DEFINE(IA32_SIGCONTEXT_ ## entry, offsetof(struct sigcontext_ia32, entry))
entry 97 arch/x86/kernel/asm-offsets_64.c #define ENTRY(entry) DEFINE(pt_regs_ ## entry, offsetof(struct pt_regs, entry))
entry 117 arch/x86/kernel/asm-offsets_64.c #define ENTRY(entry) DEFINE(saved_context_ ## entry, offsetof(struct saved_context, entry))
entry 74 arch/x86/kernel/cpu/mcheck/mce_64.c unsigned next, entry;
entry 79 arch/x86/kernel/cpu/mcheck/mce_64.c entry = rcu_dereference(mcelog.next);
entry 83 arch/x86/kernel/cpu/mcheck/mce_64.c if (entry >= MCE_LOG_LEN) {
entry 88 arch/x86/kernel/cpu/mcheck/mce_64.c if (mcelog.entry[entry].finished) {
entry 89 arch/x86/kernel/cpu/mcheck/mce_64.c entry++;
entry 95 arch/x86/kernel/cpu/mcheck/mce_64.c next = entry + 1;
entry 96 arch/x86/kernel/cpu/mcheck/mce_64.c if (cmpxchg(&mcelog.next, entry, next) == entry)
entry 99 arch/x86/kernel/cpu/mcheck/mce_64.c memcpy(mcelog.entry + entry, mce, sizeof(struct mce));
entry 101 arch/x86/kernel/cpu/mcheck/mce_64.c mcelog.entry[entry].finished = 1;
entry 139 arch/x86/kernel/cpu/mcheck/mce_64.c unsigned long tsc = mcelog.entry[i].tsc;
entry 143 arch/x86/kernel/cpu/mcheck/mce_64.c print_mce(&mcelog.entry[i]);
entry 144 arch/x86/kernel/cpu/mcheck/mce_64.c if (backup && mcelog.entry[i].tsc == backup->tsc)
entry 601 arch/x86/kernel/cpu/mcheck/mce_64.c while (!mcelog.entry[i].finished) {
entry 603 arch/x86/kernel/cpu/mcheck/mce_64.c memset(mcelog.entry + i,0, sizeof(struct mce));
entry 609 arch/x86/kernel/cpu/mcheck/mce_64.c err |= copy_to_user(buf, mcelog.entry + i, sizeof(struct mce));
entry 615 arch/x86/kernel/cpu/mcheck/mce_64.c memset(mcelog.entry, 0, next * sizeof(struct mce));
entry 626 arch/x86/kernel/cpu/mcheck/mce_64.c if (mcelog.entry[i].finished &&
entry 627 arch/x86/kernel/cpu/mcheck/mce_64.c mcelog.entry[i].tsc < cpu_tsc[mcelog.entry[i].cpu]) {
entry 628 arch/x86/kernel/cpu/mcheck/mce_64.c err |= copy_to_user(buf, mcelog.entry+i,
entry 632 arch/x86/kernel/cpu/mcheck/mce_64.c memset(&mcelog.entry[i], 0, sizeof(struct mce));
entry 1308 arch/x86/kernel/e820.c struct e820entry *entry = &e820_saved.map[i];
entry 1309 arch/x86/kernel/e820.c firmware_map_add_early(entry->addr,
entry 1310 arch/x86/kernel/e820.c entry->addr + entry->size - 1,
entry 1311 arch/x86/kernel/e820.c e820_type_to_string(entry->type));
entry 156 arch/x86/kernel/io_apic_32.c struct IO_APIC_route_entry entry;
entry 167 arch/x86/kernel/io_apic_32.c return eu.entry;
entry 180 arch/x86/kernel/io_apic_32.c eu.entry = e;
entry 201 arch/x86/kernel/io_apic_32.c union entry_union eu = { .entry.mask = 1 };
entry 217 arch/x86/kernel/io_apic_32.c struct irq_pin_list *entry = irq_2_pin + irq;
entry 219 arch/x86/kernel/io_apic_32.c while (entry->next)
entry 220 arch/x86/kernel/io_apic_32.c entry = irq_2_pin + entry->next;
entry 222 arch/x86/kernel/io_apic_32.c if (entry->pin != -1) {
entry 223 arch/x86/kernel/io_apic_32.c entry->next = first_free_entry;
entry 224 arch/x86/kernel/io_apic_32.c entry = irq_2_pin + entry->next;
entry 228 arch/x86/kernel/io_apic_32.c entry->apic = apic;
entry 229 arch/x86/kernel/io_apic_32.c entry->pin = pin;
entry 239 arch/x86/kernel/io_apic_32.c struct irq_pin_list *entry = irq_2_pin + irq;
entry 242 arch/x86/kernel/io_apic_32.c if (entry->apic == oldapic && entry->pin == oldpin) {
entry 243 arch/x86/kernel/io_apic_32.c entry->apic = newapic;
entry 244 arch/x86/kernel/io_apic_32.c entry->pin = newpin;
entry 246 arch/x86/kernel/io_apic_32.c if (!entry->next)
entry 248 arch/x86/kernel/io_apic_32.c entry = irq_2_pin + entry->next;
entry 254 arch/x86/kernel/io_apic_32.c struct irq_pin_list *entry = irq_2_pin + irq;
entry 258 arch/x86/kernel/io_apic_32.c pin = entry->pin;
entry 261 arch/x86/kernel/io_apic_32.c reg = io_apic_read(entry->apic, 0x10 + pin*2);
entry 264 arch/x86/kernel/io_apic_32.c io_apic_modify(entry->apic, 0x10 + pin*2, reg);
entry 265 arch/x86/kernel/io_apic_32.c if (!entry->next)
entry 267 arch/x86/kernel/io_apic_32.c entry = irq_2_pin + entry->next;
entry 317 arch/x86/kernel/io_apic_32.c struct IO_APIC_route_entry entry;
entry 320 arch/x86/kernel/io_apic_32.c entry = ioapic_read_entry(apic, pin);
entry 321 arch/x86/kernel/io_apic_32.c if (entry.delivery_mode == dest_SMI)
entry 344 arch/x86/kernel/io_apic_32.c struct irq_pin_list *entry = irq_2_pin + irq;
entry 359 arch/x86/kernel/io_apic_32.c pin = entry->pin;
entry 362 arch/x86/kernel/io_apic_32.c io_apic_write(entry->apic, 0x10 + 1 + pin*2, apicid_value);
entry 363 arch/x86/kernel/io_apic_32.c if (!entry->next)
entry 365 arch/x86/kernel/io_apic_32.c entry = irq_2_pin + entry->next;
entry 1238 arch/x86/kernel/io_apic_32.c struct IO_APIC_route_entry entry;
entry 1249 arch/x86/kernel/io_apic_32.c memset(&entry, 0, sizeof(entry));
entry 1251 arch/x86/kernel/io_apic_32.c entry.delivery_mode = INT_DELIVERY_MODE;
entry 1252 arch/x86/kernel/io_apic_32.c entry.dest_mode = INT_DEST_MODE;
entry 1253 arch/x86/kernel/io_apic_32.c entry.mask = 0; /* enable IRQ */
entry 1254 arch/x86/kernel/io_apic_32.c entry.dest.logical.logical_dest =
entry 1276 arch/x86/kernel/io_apic_32.c entry.trigger = irq_trigger(idx);
entry 1277 arch/x86/kernel/io_apic_32.c entry.polarity = irq_polarity(idx);
entry 1280 arch/x86/kernel/io_apic_32.c entry.trigger = 1;
entry 1281 arch/x86/kernel/io_apic_32.c entry.mask = 1;
entry 1299 arch/x86/kernel/io_apic_32.c entry.vector = vector;
entry 1305 arch/x86/kernel/io_apic_32.c ioapic_write_entry(apic, pin, entry);
entry 1319 arch/x86/kernel/io_apic_32.c struct IO_APIC_route_entry entry;
entry 1321 arch/x86/kernel/io_apic_32.c memset(&entry, 0, sizeof(entry));
entry 1327 arch/x86/kernel/io_apic_32.c entry.dest_mode = INT_DEST_MODE;
entry 1328 arch/x86/kernel/io_apic_32.c entry.mask = 1; /* mask IRQ now */
entry 1329 arch/x86/kernel/io_apic_32.c entry.dest.logical.logical_dest = cpu_mask_to_apicid(TARGET_CPUS);
entry 1330 arch/x86/kernel/io_apic_32.c entry.delivery_mode = INT_DELIVERY_MODE;
entry 1331 arch/x86/kernel/io_apic_32.c entry.polarity = 0;
entry 1332 arch/x86/kernel/io_apic_32.c entry.trigger = 0;
entry 1333 arch/x86/kernel/io_apic_32.c entry.vector = vector;
entry 1344 arch/x86/kernel/io_apic_32.c ioapic_write_entry(apic, pin, entry);
entry 1421 arch/x86/kernel/io_apic_32.c struct IO_APIC_route_entry entry;
entry 1423 arch/x86/kernel/io_apic_32.c entry = ioapic_read_entry(apic, i);
entry 1427 arch/x86/kernel/io_apic_32.c entry.dest.logical.logical_dest,
entry 1428 arch/x86/kernel/io_apic_32.c entry.dest.physical.physical_dest
entry 1432 arch/x86/kernel/io_apic_32.c entry.mask,
entry 1433 arch/x86/kernel/io_apic_32.c entry.trigger,
entry 1434 arch/x86/kernel/io_apic_32.c entry.irr,
entry 1435 arch/x86/kernel/io_apic_32.c entry.polarity,
entry 1436 arch/x86/kernel/io_apic_32.c entry.delivery_status,
entry 1437 arch/x86/kernel/io_apic_32.c entry.dest_mode,
entry 1438 arch/x86/kernel/io_apic_32.c entry.delivery_mode,
entry 1439 arch/x86/kernel/io_apic_32.c entry.vector
entry 1445 arch/x86/kernel/io_apic_32.c struct irq_pin_list *entry = irq_2_pin + i;
entry 1446 arch/x86/kernel/io_apic_32.c if (entry->pin < 0)
entry 1450 arch/x86/kernel/io_apic_32.c printk("-> %d:%d", entry->apic, entry->pin);
entry 1451 arch/x86/kernel/io_apic_32.c if (!entry->next)
entry 1453 arch/x86/kernel/io_apic_32.c entry = irq_2_pin + entry->next;
entry 1645 arch/x86/kernel/io_apic_32.c struct IO_APIC_route_entry entry;
entry 1646 arch/x86/kernel/io_apic_32.c entry = ioapic_read_entry(apic, pin);
entry 1652 arch/x86/kernel/io_apic_32.c if ((entry.mask == 0) && (entry.delivery_mode == dest_ExtINT)) {
entry 1702 arch/x86/kernel/io_apic_32.c struct IO_APIC_route_entry entry;
entry 1704 arch/x86/kernel/io_apic_32.c memset(&entry, 0, sizeof(entry));
entry 1705 arch/x86/kernel/io_apic_32.c entry.mask = 0; /* Enabled */
entry 1706 arch/x86/kernel/io_apic_32.c entry.trigger = 0; /* Edge */
entry 1707 arch/x86/kernel/io_apic_32.c entry.irr = 0;
entry 1708 arch/x86/kernel/io_apic_32.c entry.polarity = 0; /* High */
entry 1709 arch/x86/kernel/io_apic_32.c entry.delivery_status = 0;
entry 1710 arch/x86/kernel/io_apic_32.c entry.dest_mode = 0; /* Physical */
entry 1711 arch/x86/kernel/io_apic_32.c entry.delivery_mode = dest_ExtINT; /* ExtInt */
entry 1712 arch/x86/kernel/io_apic_32.c entry.vector = 0;
entry 1713 arch/x86/kernel/io_apic_32.c entry.dest.physical.physical_dest = read_apic_id();
entry 1718 arch/x86/kernel/io_apic_32.c ioapic_write_entry(ioapic_i8259.apic, ioapic_i8259.pin, entry);
entry 2359 arch/x86/kernel/io_apic_32.c struct IO_APIC_route_entry entry[0];
entry 2365 arch/x86/kernel/io_apic_32.c struct IO_APIC_route_entry *entry;
entry 2370 arch/x86/kernel/io_apic_32.c entry = data->entry;
entry 2372 arch/x86/kernel/io_apic_32.c entry[i] = ioapic_read_entry(dev->id, i);
entry 2379 arch/x86/kernel/io_apic_32.c struct IO_APIC_route_entry *entry;
entry 2386 arch/x86/kernel/io_apic_32.c entry = data->entry;
entry 2396 arch/x86/kernel/io_apic_32.c ioapic_write_entry(dev->id, i, entry[i]);
entry 2790 arch/x86/kernel/io_apic_32.c struct IO_APIC_route_entry entry;
entry 2804 arch/x86/kernel/io_apic_32.c memset(&entry, 0, sizeof(entry));
entry 2806 arch/x86/kernel/io_apic_32.c entry.delivery_mode = INT_DELIVERY_MODE;
entry 2807 arch/x86/kernel/io_apic_32.c entry.dest_mode = INT_DEST_MODE;
entry 2808 arch/x86/kernel/io_apic_32.c entry.dest.logical.logical_dest = cpu_mask_to_apicid(TARGET_CPUS);
entry 2809 arch/x86/kernel/io_apic_32.c entry.trigger = edge_level;
entry 2810 arch/x86/kernel/io_apic_32.c entry.polarity = active_high_low;
entry 2811 arch/x86/kernel/io_apic_32.c entry.mask = 1;
entry 2819 arch/x86/kernel/io_apic_32.c entry.vector = assign_irq_vector(irq);
entry 2823 arch/x86/kernel/io_apic_32.c mp_ioapics[ioapic].mp_apicid, pin, entry.vector, irq,
entry 2826 arch/x86/kernel/io_apic_32.c ioapic_register_intr(irq, entry.vector, edge_level);
entry 2831 arch/x86/kernel/io_apic_32.c ioapic_write_entry(ioapic, pin, entry);
entry 184 arch/x86/kernel/io_apic_64.c struct irq_pin_list *entry;
entry 188 arch/x86/kernel/io_apic_64.c entry = irq_2_pin + irq;
entry 193 arch/x86/kernel/io_apic_64.c pin = entry->pin;
entry 196 arch/x86/kernel/io_apic_64.c reg = io_apic_read(entry->apic, 0x10 + pin*2);
entry 202 arch/x86/kernel/io_apic_64.c if (!entry->next)
entry 204 arch/x86/kernel/io_apic_64.c entry = irq_2_pin + entry->next;
entry 225 arch/x86/kernel/io_apic_64.c struct irq_pin_list *entry = irq_2_pin + irq; \
entry 230 arch/x86/kernel/io_apic_64.c pin = entry->pin; \
entry 233 arch/x86/kernel/io_apic_64.c reg = io_apic_read(entry->apic, 0x10 + R + pin*2); \
entry 235 arch/x86/kernel/io_apic_64.c io_apic_modify(entry->apic, reg); \
entry 237 arch/x86/kernel/io_apic_64.c if (!entry->next) \
entry 239 arch/x86/kernel/io_apic_64.c entry = irq_2_pin + entry->next; \
entry 245 arch/x86/kernel/io_apic_64.c struct IO_APIC_route_entry entry;
entry 256 arch/x86/kernel/io_apic_64.c return eu.entry;
entry 269 arch/x86/kernel/io_apic_64.c eu.entry = e;
entry 290 arch/x86/kernel/io_apic_64.c union entry_union eu = { .entry.mask = 1 };
entry 302 arch/x86/kernel/io_apic_64.c struct irq_pin_list *entry = irq_2_pin + irq;
entry 307 arch/x86/kernel/io_apic_64.c apic = entry->apic;
entry 308 arch/x86/kernel/io_apic_64.c pin = entry->pin;
entry 321 arch/x86/kernel/io_apic_64.c if (!entry->next)
entry 323 arch/x86/kernel/io_apic_64.c entry = irq_2_pin + entry->next;
entry 364 arch/x86/kernel/io_apic_64.c struct irq_pin_list *entry = irq_2_pin + irq;
entry 367 arch/x86/kernel/io_apic_64.c while (entry->next)
entry 368 arch/x86/kernel/io_apic_64.c entry = irq_2_pin + entry->next;
entry 370 arch/x86/kernel/io_apic_64.c if (entry->pin != -1) {
entry 371 arch/x86/kernel/io_apic_64.c entry->next = first_free_entry;
entry 372 arch/x86/kernel/io_apic_64.c entry = irq_2_pin + entry->next;
entry 376 arch/x86/kernel/io_apic_64.c entry->apic = apic;
entry 377 arch/x86/kernel/io_apic_64.c entry->pin = pin;
entry 387 arch/x86/kernel/io_apic_64.c struct irq_pin_list *entry = irq_2_pin + irq;
entry 390 arch/x86/kernel/io_apic_64.c if (entry->apic == oldapic && entry->pin == oldpin) {
entry 391 arch/x86/kernel/io_apic_64.c entry->apic = newapic;
entry 392 arch/x86/kernel/io_apic_64.c entry->pin = newpin;
entry 394 arch/x86/kernel/io_apic_64.c if (!entry->next)
entry 396 arch/x86/kernel/io_apic_64.c entry = irq_2_pin + entry->next;
entry 432 arch/x86/kernel/io_apic_64.c struct IO_APIC_route_entry entry;
entry 435 arch/x86/kernel/io_apic_64.c entry = ioapic_read_entry(apic, pin);
entry 436 arch/x86/kernel/io_apic_64.c if (entry.delivery_mode == dest_SMI)
entry 482 arch/x86/kernel/io_apic_64.c struct IO_APIC_route_entry entry;
entry 484 arch/x86/kernel/io_apic_64.c entry = early_ioapic_entries[apic][pin] =
entry 486 arch/x86/kernel/io_apic_64.c if (!entry.mask) {
entry 487 arch/x86/kernel/io_apic_64.c entry.mask = 1;
entry 488 arch/x86/kernel/io_apic_64.c ioapic_write_entry(apic, pin, entry);
entry 956 arch/x86/kernel/io_apic_64.c memset(entry,0,sizeof(*entry));
entry 963 arch/x86/kernel/io_apic_64.c (struct IR_IO_APIC_route_entry *) entry;
entry 991 arch/x86/kernel/io_apic_64.c entry->delivery_mode = INT_DELIVERY_MODE;
entry 992 arch/x86/kernel/io_apic_64.c entry->dest_mode = INT_DEST_MODE;
entry 993 arch/x86/kernel/io_apic_64.c entry->dest = destination;
entry 996 arch/x86/kernel/io_apic_64.c entry->mask = 0; /* enable IRQ */
entry 997 arch/x86/kernel/io_apic_64.c entry->trigger = trigger;
entry 998 arch/x86/kernel/io_apic_64.c entry->polarity = polarity;
entry 999 arch/x86/kernel/io_apic_64.c entry->vector = vector;
entry 1005 arch/x86/kernel/io_apic_64.c entry->mask = 1;
entry 1013 arch/x86/kernel/io_apic_64.c struct IO_APIC_route_entry entry;
entry 1032 arch/x86/kernel/io_apic_64.c if (setup_ioapic_entry(mp_ioapics[apic].mp_apicid, irq, &entry,
entry 1045 arch/x86/kernel/io_apic_64.c ioapic_write_entry(apic, pin, entry);
entry 1089 arch/x86/kernel/io_apic_64.c struct IO_APIC_route_entry entry;
entry 1094 arch/x86/kernel/io_apic_64.c memset(&entry, 0, sizeof(entry));
entry 1100 arch/x86/kernel/io_apic_64.c entry.dest_mode = INT_DEST_MODE;
entry 1101 arch/x86/kernel/io_apic_64.c entry.mask = 1; /* mask IRQ now */
entry 1102 arch/x86/kernel/io_apic_64.c entry.dest = cpu_mask_to_apicid(TARGET_CPUS);
entry 1103 arch/x86/kernel/io_apic_64.c entry.delivery_mode = INT_DELIVERY_MODE;
entry 1104 arch/x86/kernel/io_apic_64.c entry.polarity = 0;
entry 1105 arch/x86/kernel/io_apic_64.c entry.trigger = 0;
entry 1106 arch/x86/kernel/io_apic_64.c entry.vector = vector;
entry 1117 arch/x86/kernel/io_apic_64.c ioapic_write_entry(apic, pin, entry);
entry 1174 arch/x86/kernel/io_apic_64.c struct IO_APIC_route_entry entry;
entry 1176 arch/x86/kernel/io_apic_64.c entry = ioapic_read_entry(apic, i);
entry 1180 arch/x86/kernel/io_apic_64.c entry.dest
entry 1184 arch/x86/kernel/io_apic_64.c entry.mask,
entry 1185 arch/x86/kernel/io_apic_64.c entry.trigger,
entry 1186 arch/x86/kernel/io_apic_64.c entry.irr,
entry 1187 arch/x86/kernel/io_apic_64.c entry.polarity,
entry 1188 arch/x86/kernel/io_apic_64.c entry.delivery_status,
entry 1189 arch/x86/kernel/io_apic_64.c entry.dest_mode,
entry 1190 arch/x86/kernel/io_apic_64.c entry.delivery_mode,
entry 1191 arch/x86/kernel/io_apic_64.c entry.vector
entry 1197 arch/x86/kernel/io_apic_64.c struct irq_pin_list *entry = irq_2_pin + i;
entry 1198 arch/x86/kernel/io_apic_64.c if (entry->pin < 0)
entry 1202 arch/x86/kernel/io_apic_64.c printk("-> %d:%d", entry->apic, entry->pin);
entry 1203 arch/x86/kernel/io_apic_64.c if (!entry->next)
entry 1205 arch/x86/kernel/io_apic_64.c entry = irq_2_pin + entry->next;
entry 1387 arch/x86/kernel/io_apic_64.c struct IO_APIC_route_entry entry;
entry 1388 arch/x86/kernel/io_apic_64.c entry = ioapic_read_entry(apic, pin);
entry 1393 arch/x86/kernel/io_apic_64.c if ((entry.mask == 0) && (entry.delivery_mode == dest_ExtINT)) {
entry 1439 arch/x86/kernel/io_apic_64.c struct IO_APIC_route_entry entry;
entry 1441 arch/x86/kernel/io_apic_64.c memset(&entry, 0, sizeof(entry));
entry 1442 arch/x86/kernel/io_apic_64.c entry.mask = 0; /* Enabled */
entry 1443 arch/x86/kernel/io_apic_64.c entry.trigger = 0; /* Edge */
entry 1444 arch/x86/kernel/io_apic_64.c entry.irr = 0;
entry 1445 arch/x86/kernel/io_apic_64.c entry.polarity = 0; /* High */
entry 1446 arch/x86/kernel/io_apic_64.c entry.delivery_status = 0;
entry 1447 arch/x86/kernel/io_apic_64.c entry.dest_mode = 0; /* Physical */
entry 1448 arch/x86/kernel/io_apic_64.c entry.delivery_mode = dest_ExtINT; /* ExtInt */
entry 1449 arch/x86/kernel/io_apic_64.c entry.vector = 0;
entry 1450 arch/x86/kernel/io_apic_64.c entry.dest = read_apic_id();
entry 1455 arch/x86/kernel/io_apic_64.c ioapic_write_entry(ioapic_i8259.apic, ioapic_i8259.pin, entry);
entry 2188 arch/x86/kernel/io_apic_64.c struct IO_APIC_route_entry entry[0];
entry 2194 arch/x86/kernel/io_apic_64.c struct IO_APIC_route_entry *entry;
entry 2199 arch/x86/kernel/io_apic_64.c entry = data->entry;
entry 2200 arch/x86/kernel/io_apic_64.c for (i = 0; i < nr_ioapic_registers[dev->id]; i ++, entry ++ )
entry 2201 arch/x86/kernel/io_apic_64.c *entry = ioapic_read_entry(dev->id, i);
entry 2208 arch/x86/kernel/io_apic_64.c struct IO_APIC_route_entry *entry;
entry 2215 arch/x86/kernel/io_apic_64.c entry = data->entry;
entry 2225 arch/x86/kernel/io_apic_64.c ioapic_write_entry(dev->id, i, entry[i]);
entry 1005 arch/x86/kernel/kprobes.c regs->ip = (unsigned long)(jp->entry);
entry 312 arch/x86/kernel/pci-calgary_64.c unsigned long entry;
entry 315 arch/x86/kernel/pci-calgary_64.c entry = iommu_range_alloc(dev, tbl, npages);
entry 317 arch/x86/kernel/pci-calgary_64.c if (unlikely(entry == bad_dma_address))
entry 321 arch/x86/kernel/pci-calgary_64.c ret = (entry << PAGE_SHIFT) | ((unsigned long)vaddr & ~PAGE_MASK);
entry 324 arch/x86/kernel/pci-calgary_64.c tce_build(tbl, entry, npages, (unsigned long)vaddr & PAGE_MASK,
entry 338 arch/x86/kernel/pci-calgary_64.c unsigned long entry;
entry 351 arch/x86/kernel/pci-calgary_64.c entry = dma_addr >> PAGE_SHIFT;
entry 353 arch/x86/kernel/pci-calgary_64.c BUG_ON(entry + npages > tbl->it_size);
entry 355 arch/x86/kernel/pci-calgary_64.c tce_free(tbl, entry, npages);
entry 359 arch/x86/kernel/pci-calgary_64.c badbit = verify_bit_range(tbl->it_map, 1, entry, entry + npages);
entry 364 arch/x86/kernel/pci-calgary_64.c badbit, tbl, dma_addr, entry, npages);
entry 367 arch/x86/kernel/pci-calgary_64.c iommu_area_free(tbl->it_map, entry, npages);
entry 423 arch/x86/kernel/pci-calgary_64.c unsigned long entry;
entry 432 arch/x86/kernel/pci-calgary_64.c entry = iommu_range_alloc(dev, tbl, npages);
entry 433 arch/x86/kernel/pci-calgary_64.c if (entry == bad_dma_address) {
entry 439 arch/x86/kernel/pci-calgary_64.c s->dma_address = (entry << PAGE_SHIFT) | s->offset;
entry 442 arch/x86/kernel/pci-calgary_64.c tce_build(tbl, entry, npages, vaddr & PAGE_MASK,
entry 431 arch/x86/kernel/visws_quirks.c co_apic_write(CO_APIC_LO(entry), CO_APIC_LEVEL | (irq + FIRST_EXTERNAL_VECTOR));
entry 432 arch/x86/kernel/visws_quirks.c co_apic_write(CO_APIC_HI(entry), 0);
entry 473 arch/x86/kernel/visws_quirks.c int entry = is_co_apic(irq);
entry 475 arch/x86/kernel/visws_quirks.c co_apic_write(CO_APIC_LO(entry), CO_APIC_MASK);
entry 476 arch/x86/kernel/visws_quirks.c co_apic_read(CO_APIC_LO(entry));
entry 224 arch/x86/kernel/vmi_32.c vmi_ops.write_idt_entry(dt, entry, idt_entry[0], idt_entry[1]);
entry 231 arch/x86/kernel/vmi_32.c vmi_ops.write_gdt_entry(dt, entry, gdt_entry[0], gdt_entry[1]);
entry 238 arch/x86/kernel/vmi_32.c vmi_ops.write_ldt_entry(dt, entry, ldt_entry[0], ldt_entry[1]);
entry 1808 arch/x86/kvm/mmu.c u64 entry, gentry;
entry 1893 arch/x86/kvm/mmu.c entry = *spte;
entry 1897 arch/x86/kvm/mmu.c mmu_pte_write_flush_tlb(vcpu, entry, *spte);
entry 994 arch/x86/kvm/x86.c struct kvm_cpuid_entry2 *e, *entry;
entry 996 arch/x86/kvm/x86.c entry = NULL;
entry 1000 arch/x86/kvm/x86.c entry = e;
entry 1004 arch/x86/kvm/x86.c if (entry && (entry->edx & (1 << 20)) && !is_efer_nx()) {
entry 1005 arch/x86/kvm/x86.c entry->edx &= ~(1 << 20);
entry 1099 arch/x86/kvm/x86.c entry->function = function;
entry 1100 arch/x86/kvm/x86.c entry->index = index;
entry 1101 arch/x86/kvm/x86.c cpuid_count(entry->function, entry->index,
entry 1102 arch/x86/kvm/x86.c &entry->eax, &entry->ebx, &entry->ecx, &entry->edx);
entry 1103 arch/x86/kvm/x86.c entry->flags = 0;
entry 1142 arch/x86/kvm/x86.c do_cpuid_1_ent(entry, function, index);
entry 1147 arch/x86/kvm/x86.c entry->eax = min(entry->eax, (u32)0xb);
entry 1150 arch/x86/kvm/x86.c entry->edx &= kvm_supported_word0_x86_features;
entry 1151 arch/x86/kvm/x86.c entry->ecx &= kvm_supported_word3_x86_features;
entry 1158 arch/x86/kvm/x86.c int t, times = entry->eax & 0xff;
entry 1160 arch/x86/kvm/x86.c entry->flags |= KVM_CPUID_FLAG_STATEFUL_FUNC;
entry 1162 arch/x86/kvm/x86.c do_cpuid_1_ent(&entry[t], function, 0);
entry 1163 arch/x86/kvm/x86.c entry[t].flags |= KVM_CPUID_FLAG_STATEFUL_FUNC;
entry 1172 arch/x86/kvm/x86.c entry->flags |= KVM_CPUID_FLAG_SIGNIFCANT_INDEX;
entry 1175 arch/x86/kvm/x86.c cache_type = entry[i - 1].eax & 0x1f;
entry 1178 arch/x86/kvm/x86.c do_cpuid_1_ent(&entry[i], function, i);
entry 1179 arch/x86/kvm/x86.c entry[i].flags |=
entry 1188 arch/x86/kvm/x86.c entry->flags |= KVM_CPUID_FLAG_SIGNIFCANT_INDEX;
entry 1191 arch/x86/kvm/x86.c level_type = entry[i - 1].ecx & 0xff;
entry 1194 arch/x86/kvm/x86.c do_cpuid_1_ent(&entry[i], function, i);
entry 1195 arch/x86/kvm/x86.c entry[i].flags |=
entry 1202 arch/x86/kvm/x86.c entry->eax = min(entry->eax, 0x8000001a);
entry 1205 arch/x86/kvm/x86.c entry->edx &= kvm_supported_word1_x86_features;
entry 1206 arch/x86/kvm/x86.c entry->ecx &= kvm_supported_word6_x86_features;
entry 1182 arch/x86/mm/init_64.c pte_t entry;
entry 1188 arch/x86/mm/init_64.c entry = pfn_pte(__pa(p) >> PAGE_SHIFT,
entry 1190 arch/x86/mm/init_64.c set_pmd(pmd, __pmd(pte_val(entry)));
entry 187 arch/x86/mm/pat.c if (new->type != entry->type) {
entry 189 arch/x86/mm/pat.c new->type = entry->type;
entry 190 arch/x86/mm/pat.c *type = entry->type;
entry 196 arch/x86/mm/pat.c list_for_each_entry_continue(entry, &memtype_list, nd) {
entry 197 arch/x86/mm/pat.c if (new->end <= entry->start)
entry 199 arch/x86/mm/pat.c else if (new->type != entry->type)
entry 207 arch/x86/mm/pat.c new->end, cattr_name(new->type), cattr_name(entry->type));
entry 292 arch/x86/mm/pat.c struct memtype *new, *entry;
entry 356 arch/x86/mm/pat.c entry = cached_entry;
entry 358 arch/x86/mm/pat.c entry = list_entry(&memtype_list, struct memtype, nd);
entry 362 arch/x86/mm/pat.c list_for_each_entry_continue(entry, &memtype_list, nd) {
entry 363 arch/x86/mm/pat.c if (end <= entry->start) {
entry 364 arch/x86/mm/pat.c where = entry->nd.prev;
entry 367 arch/x86/mm/pat.c } else if (start <= entry->start) { /* end > entry->start */
entry 368 arch/x86/mm/pat.c err = chk_conflict(new, entry, new_type);
entry 371 arch/x86/mm/pat.c entry->start, entry->end);
entry 372 arch/x86/mm/pat.c where = entry->nd.prev;
entry 377 arch/x86/mm/pat.c } else if (start < entry->end) { /* start > entry->start */
entry 378 arch/x86/mm/pat.c err = chk_conflict(new, entry, new_type);
entry 381 arch/x86/mm/pat.c entry->start, entry->end);
entry 382 arch/x86/mm/pat.c cached_entry = list_entry(entry->nd.prev,
entry 389 arch/x86/mm/pat.c list_for_each_entry_continue(entry,
entry 391 arch/x86/mm/pat.c if (start <= entry->start) {
entry 392 arch/x86/mm/pat.c where = entry->nd.prev;
entry 429 arch/x86/mm/pat.c struct memtype *entry;
entry 447 arch/x86/mm/pat.c list_for_each_entry(entry, &memtype_list, nd) {
entry 448 arch/x86/mm/pat.c if (entry->start == start && entry->end == end) {
entry 449 arch/x86/mm/pat.c if (cached_entry == entry || cached_start == start)
entry 452 arch/x86/mm/pat.c list_del(&entry->nd);
entry 453 arch/x86/mm/pat.c kfree(entry);
entry 278 arch/x86/mm/pgtable.c int changed = !pte_same(*ptep, entry);
entry 281 arch/x86/mm/pgtable.c *ptep = entry;
entry 505 arch/x86/mm/srat_64.c return acpi_slit->entry[index + node_to_pxm(b)];
entry 41 arch/x86/pci/pcbios.c unsigned long entry; /* 32 bit physical address */
entry 71 arch/x86/pci/pcbios.c unsigned long entry; /* %edx */
entry 79 arch/x86/pci/pcbios.c "=d" (entry)
entry 87 arch/x86/pci/pcbios.c return address + entry;
entry 326 arch/x86/pci/pcbios.c if (check->fields.entry >= 0x100000) {
entry 331 arch/x86/pci/pcbios.c unsigned long bios32_entry = check->fields.entry;
entry 404 arch/x86/xen/enlighten.c u64 entry = *(u64 *)ptr;
entry 409 arch/x86/xen/enlighten.c if (HYPERVISOR_update_descriptor(mach_lp.maddr, entry))
entry 473 arch/x86/xen/enlighten.c gate_desc *entry = (gate_desc*)(desc->address) + in;
entry 475 arch/x86/xen/enlighten.c if (cvt_gate_to_trap(in, entry, &traps[out]))
entry 523 arch/x86/xen/enlighten.c xmaddr_t maddr = virt_to_machine(&dt[entry]);
entry 175 block/blk-integrity.c struct integrity_sysfs_entry *entry =
entry 178 block/blk-integrity.c return entry->show(bi, page);
entry 187 block/blk-integrity.c struct integrity_sysfs_entry *entry =
entry 191 block/blk-integrity.c if (entry->store)
entry 192 block/blk-integrity.c ret = entry->store(bi, page, count);
entry 247 block/blk-sysfs.c struct queue_sysfs_entry *entry = to_queue(attr);
entry 252 block/blk-sysfs.c if (!entry->show)
entry 259 block/blk-sysfs.c res = entry->show(q, page);
entry 268 block/blk-sysfs.c struct queue_sysfs_entry *entry = to_queue(attr);
entry 272 block/blk-sysfs.c if (!entry->store)
entry 281 block/blk-sysfs.c res = entry->store(q, page, length);
entry 792 block/bsg.c struct hlist_node *entry;
entry 796 block/bsg.c hlist_for_each_entry(bd, entry, bsg_dev_idx_hash(minor), dev_list) {
entry 173 block/cmd-filter.c struct rcf_sysfs_entry *entry = to_rcf(attr);
entry 177 block/cmd-filter.c if (entry->show)
entry 178 block/cmd-filter.c return entry->show(filter, page);
entry 187 block/cmd-filter.c struct rcf_sysfs_entry *entry = to_rcf(attr);
entry 193 block/cmd-filter.c if (!entry->store)
entry 197 block/cmd-filter.c return entry->store(filter, page, length);
entry 351 block/elevator.c struct hlist_node *entry, *next;
entry 354 block/elevator.c hlist_for_each_entry_safe(rq, entry, next, hash_list, hash) {
entry 433 block/elevator.c struct list_head *entry;
entry 445 block/elevator.c list_for_each_prev(entry, &q->queue_head) {
entry 446 block/elevator.c struct request *pos = list_entry_rq(entry);
entry 465 block/elevator.c list_add(&rq->queuelist, entry);
entry 964 block/elevator.c struct elv_fs_entry *entry = to_elv(attr);
entry 967 block/elevator.c if (!entry->show)
entry 971 block/elevator.c error = e->ops ? entry->show(e, page) : -ENOENT;
entry 981 block/elevator.c struct elv_fs_entry *entry = to_elv(attr);
entry 984 block/elevator.c if (!entry->store)
entry 988 block/elevator.c error = e->ops ? entry->store(e, page, length) : -ENOENT;
entry 246 fs/adfs/dir.c if (entry->len != name->len)
entry 252 fs/adfs/dir.c a = entry->name[i];
entry 33 fs/afs/cache.c const struct afs_cache_cell *ccell = entry;
entry 54 fs/afs/cache.c struct afs_cache_cell *ccell = entry;
entry 57 fs/afs/cache.c _enter("%p,%p", source, entry);
entry 90 fs/afs/cache.c const struct afs_cache_vlocation *vldb = entry;
entry 132 fs/afs/cache.c struct afs_cache_vlocation *vldb = entry;
entry 163 fs/afs/cache.c const struct afs_cache_vhash *vhash = entry;
entry 184 fs/afs/cache.c struct afs_cache_vhash *vhash = entry;
entry 214 fs/afs/cache.c const struct afs_cache_vnode *cvnode = entry;
entry 247 fs/afs/cache.c struct afs_cache_vnode *cvnode = entry;
entry 63 fs/afs/vlclient.c struct afs_cache_vlocation *entry;
entry 78 fs/afs/vlclient.c entry = call->reply;
entry 82 fs/afs/vlclient.c entry->name[loop] = ntohl(*bp++);
entry 83 fs/afs/vlclient.c entry->name[loop] = 0;
entry 87 fs/afs/vlclient.c entry->nservers = ntohl(*bp++);
entry 90 fs/afs/vlclient.c entry->servers[loop].s_addr = *bp++;
entry 96 fs/afs/vlclient.c entry->srvtmask[loop] = 0;
entry 98 fs/afs/vlclient.c entry->srvtmask[loop] |= AFS_VOL_VTM_RW;
entry 100 fs/afs/vlclient.c entry->srvtmask[loop] |= AFS_VOL_VTM_RO;
entry 102 fs/afs/vlclient.c entry->srvtmask[loop] |= AFS_VOL_VTM_BAK;
entry 105 fs/afs/vlclient.c entry->vid[0] = ntohl(*bp++);
entry 106 fs/afs/vlclient.c entry->vid[1] = ntohl(*bp++);
entry 107 fs/afs/vlclient.c entry->vid[2] = ntohl(*bp++);
entry 112 fs/afs/vlclient.c entry->vidmask = 0;
entry 114 fs/afs/vlclient.c entry->vidmask |= AFS_VOL_VTM_RW;
entry 116 fs/afs/vlclient.c entry->vidmask |= AFS_VOL_VTM_RO;
entry 118 fs/afs/vlclient.c entry->vidmask |= AFS_VOL_VTM_BAK;
entry 119 fs/afs/vlclient.c if (!entry->vidmask)
entry 170 fs/afs/vlclient.c call->reply = entry;
entry 206 fs/afs/vlclient.c call->reply = entry;
entry 66 fs/binfmt_flat.c unsigned long entry; /* Start address for this module */
entry 669 fs/binfmt_flat.c (int)textpos, 0x00ffffff&ntohl(hdr->entry), ntohl(hdr->data_start));
entry 706 fs/binfmt_flat.c libinfo->lib_list[id].entry = (0x00ffffff & ntohl(hdr->entry)) + textpos;
entry 902 fs/binfmt_flat.c start_addr = libinfo.lib_list[0].entry;
entry 909 fs/binfmt_flat.c start_addr = libinfo.lib_list[i].entry;
entry 102 fs/coda/dir.c const char *name = entry->d_name.name;
entry 103 fs/coda/dir.c size_t length = entry->d_name.len;
entry 131 fs/coda/dir.c entry->d_op = &coda_dentry_operations;
entry 136 fs/coda/dir.c return d_splice_alias(inode, entry);
entry 40 fs/configfs/item.c return container_of(entry,struct config_item,ci_entry);
entry 198 fs/configfs/item.c struct list_head * entry;
entry 201 fs/configfs/item.c list_for_each(entry,&group->cg_children) {
entry 202 fs/configfs/item.c struct config_item * item = to_item(entry);
entry 447 fs/cramfs/inode.c struct cramfs_inode entry = *de;
entry 449 fs/cramfs/inode.c d_add(dentry, get_cramfs_inode(dir->i_sb, &entry));
entry 997 fs/dcache.c BUG_ON(!list_empty(&entry->d_alias));
entry 1000 fs/dcache.c list_add(&entry->d_alias, &inode->i_dentry);
entry 1001 fs/dcache.c entry->d_inode = inode;
entry 1002 fs/dcache.c fsnotify_d_instantiate(entry, inode);
entry 1004 fs/dcache.c security_d_instantiate(entry, inode);
entry 1027 fs/dcache.c int len = entry->d_name.len;
entry 1028 fs/dcache.c const char *name = entry->d_name.name;
entry 1029 fs/dcache.c unsigned int hash = entry->d_name.hash;
entry 1032 fs/dcache.c entry->d_inode = NULL;
entry 1041 fs/dcache.c if (alias->d_parent != entry->d_parent)
entry 1051 fs/dcache.c list_add(&entry->d_alias, &inode->i_dentry);
entry 1052 fs/dcache.c entry->d_inode = inode;
entry 1053 fs/dcache.c fsnotify_d_instantiate(entry, inode);
entry 1061 fs/dcache.c BUG_ON(!list_empty(&entry->d_alias));
entry 1064 fs/dcache.c result = __d_instantiate_unique(entry, inode);
entry 1068 fs/dcache.c security_d_instantiate(entry, inode);
entry 1544 fs/dcache.c entry->d_flags &= ~DCACHE_UNHASHED;
entry 1545 fs/dcache.c hlist_add_head_rcu(&entry->d_hash, list);
entry 1550 fs/dcache.c __d_rehash(entry, d_hash(entry->d_parent, entry->d_name.hash));
entry 1563 fs/dcache.c spin_lock(&entry->d_lock);
entry 1564 fs/dcache.c _d_rehash(entry);
entry 1565 fs/dcache.c spin_unlock(&entry->d_lock);
entry 29 fs/dlm/debug_fs.c int entry;
entry 223 fs/dlm/debug_fs.c for (i = ri->entry; i < ls->ls_rsbtbl_size; i++) {
entry 235 fs/dlm/debug_fs.c ri->entry = i;
entry 237 fs/dlm/debug_fs.c if (ri->entry >= ls->ls_rsbtbl_size)
entry 241 fs/dlm/debug_fs.c i = ri->entry;
entry 247 fs/dlm/debug_fs.c ri->entry++;
entry 275 fs/dlm/debug_fs.c ri->entry = 0;
entry 386 fs/dlm/debug_fs.c ri->entry = 0;
entry 1160 fs/dlm/lowcomms.c struct writequeue_entry *entry;
entry 1162 fs/dlm/lowcomms.c entry = kmalloc(sizeof(struct writequeue_entry), allocation);
entry 1163 fs/dlm/lowcomms.c if (!entry)
entry 1166 fs/dlm/lowcomms.c entry->page = alloc_page(allocation);
entry 1167 fs/dlm/lowcomms.c if (!entry->page) {
entry 1168 fs/dlm/lowcomms.c kfree(entry);
entry 1172 fs/dlm/lowcomms.c entry->offset = 0;
entry 1173 fs/dlm/lowcomms.c entry->len = 0;
entry 1174 fs/dlm/lowcomms.c entry->end = 0;
entry 1175 fs/dlm/lowcomms.c entry->users = 0;
entry 1176 fs/dlm/lowcomms.c entry->con = con;
entry 1178 fs/dlm/lowcomms.c return entry;
entry 1192 fs/exec.c bprm->sh_bang = eh->ah.entry < 0x100000000UL;
entry 43 fs/ext2/acl.c ext2_acl_entry *entry =
entry 47 fs/ext2/acl.c acl->a_entries[n].e_tag = le16_to_cpu(entry->e_tag);
entry 48 fs/ext2/acl.c acl->a_entries[n].e_perm = le16_to_cpu(entry->e_perm);
entry 65 fs/ext2/acl.c le32_to_cpu(entry->e_id);
entry 99 fs/ext2/acl.c ext2_acl_entry *entry = (ext2_acl_entry *)e;
entry 100 fs/ext2/acl.c entry->e_tag = cpu_to_le16(acl->a_entries[n].e_tag);
entry 101 fs/ext2/acl.c entry->e_perm = cpu_to_le16(acl->a_entries[n].e_perm);
entry 105 fs/ext2/acl.c entry->e_id =
entry 70 fs/ext2/xattr.c #define IS_LAST_ENTRY(entry) (*(__u32 *)(entry) == 0)
entry 153 fs/ext2/xattr.c struct ext2_xattr_entry *entry;
entry 189 fs/ext2/xattr.c entry = FIRST_ENTRY(bh);
entry 190 fs/ext2/xattr.c while (!IS_LAST_ENTRY(entry)) {
entry 192 fs/ext2/xattr.c EXT2_XATTR_NEXT(entry);
entry 195 fs/ext2/xattr.c if (name_index == entry->e_name_index &&
entry 196 fs/ext2/xattr.c name_len == entry->e_name_len &&
entry 197 fs/ext2/xattr.c memcmp(name, entry->e_name, name_len) == 0)
entry 199 fs/ext2/xattr.c entry = next;
entry 202 fs/ext2/xattr.c while (!IS_LAST_ENTRY(entry)) {
entry 204 fs/ext2/xattr.c EXT2_XATTR_NEXT(entry);
entry 207 fs/ext2/xattr.c entry = next;
entry 215 fs/ext2/xattr.c if (entry->e_value_block != 0)
entry 217 fs/ext2/xattr.c size = le32_to_cpu(entry->e_value_size);
entry 219 fs/ext2/xattr.c le16_to_cpu(entry->e_value_offs) + size > inode->i_sb->s_blocksize)
entry 229 fs/ext2/xattr.c memcpy(buffer, bh->b_data + le16_to_cpu(entry->e_value_offs),
entry 255 fs/ext2/xattr.c struct ext2_xattr_entry *entry;
entry 285 fs/ext2/xattr.c entry = FIRST_ENTRY(bh);
entry 286 fs/ext2/xattr.c while (!IS_LAST_ENTRY(entry)) {
entry 287 fs/ext2/xattr.c struct ext2_xattr_entry *next = EXT2_XATTR_NEXT(entry);
entry 291 fs/ext2/xattr.c entry = next;
entry 297 fs/ext2/xattr.c for (entry = FIRST_ENTRY(bh); !IS_LAST_ENTRY(entry);
entry 298 fs/ext2/xattr.c entry = EXT2_XATTR_NEXT(entry)) {
entry 300 fs/ext2/xattr.c ext2_xattr_handler(entry->e_name_index);
entry 304 fs/ext2/xattr.c entry->e_name,
entry 305 fs/ext2/xattr.c entry->e_name_len);
entry 960 fs/ext2/xattr.c char *name = entry->e_name;
entry 963 fs/ext2/xattr.c for (n=0; n < entry->e_name_len; n++) {
entry 969 fs/ext2/xattr.c if (entry->e_value_block == 0 && entry->e_value_size != 0) {
entry 971 fs/ext2/xattr.c le16_to_cpu(entry->e_value_offs));
entry 972 fs/ext2/xattr.c for (n = (le32_to_cpu(entry->e_value_size) +
entry 979 fs/ext2/xattr.c entry->e_hash = cpu_to_le32(hash);
entry 998 fs/ext2/xattr.c ext2_xattr_hash_entry(header, entry);
entry 52 fs/ext2/xattr.h (char *)(entry) + EXT2_XATTR_LEN((entry)->e_name_len)) )
entry 44 fs/ext3/acl.c ext3_acl_entry *entry =
entry 48 fs/ext3/acl.c acl->a_entries[n].e_tag = le16_to_cpu(entry->e_tag);
entry 49 fs/ext3/acl.c acl->a_entries[n].e_perm = le16_to_cpu(entry->e_perm);
entry 66 fs/ext3/acl.c le32_to_cpu(entry->e_id);
entry 100 fs/ext3/acl.c ext3_acl_entry *entry = (ext3_acl_entry *)e;
entry 101 fs/ext3/acl.c entry->e_tag = cpu_to_le16(acl->a_entries[n].e_tag);
entry 102 fs/ext3/acl.c entry->e_perm = cpu_to_le16(acl->a_entries[n].e_perm);
entry 106 fs/ext3/acl.c entry->e_id =
entry 201 fs/ext3/namei.c return le32_to_cpu(entry->block) & 0x00ffffff;
entry 206 fs/ext3/namei.c entry->block = cpu_to_le32(value);
entry 211 fs/ext3/namei.c return le32_to_cpu(entry->hash);
entry 216 fs/ext3/namei.c entry->hash = cpu_to_le32(value);
entry 67 fs/ext3/xattr.c #define IS_LAST_ENTRY(entry) (*(__u32 *)(entry) == 0)
entry 156 fs/ext3/xattr.c while (!IS_LAST_ENTRY(entry)) {
entry 157 fs/ext3/xattr.c struct ext3_xattr_entry *next = EXT3_XATTR_NEXT(entry);
entry 160 fs/ext3/xattr.c entry = next;
entry 180 fs/ext3/xattr.c size_t value_size = le32_to_cpu(entry->e_value_size);
entry 182 fs/ext3/xattr.c if (entry->e_value_block != 0 || value_size > size ||
entry 183 fs/ext3/xattr.c le16_to_cpu(entry->e_value_offs) + value_size > size)
entry 192 fs/ext3/xattr.c struct ext3_xattr_entry *entry;
entry 199 fs/ext3/xattr.c entry = *pentry;
entry 200 fs/ext3/xattr.c for (; !IS_LAST_ENTRY(entry); entry = EXT3_XATTR_NEXT(entry)) {
entry 201 fs/ext3/xattr.c cmp = name_index - entry->e_name_index;
entry 203 fs/ext3/xattr.c cmp = name_len - entry->e_name_len;
entry 205 fs/ext3/xattr.c cmp = memcmp(name, entry->e_name, name_len);
entry 209 fs/ext3/xattr.c *pentry = entry;
entry 210 fs/ext3/xattr.c if (!cmp && ext3_xattr_check_entry(entry, size))
entry 220 fs/ext3/xattr.c struct ext3_xattr_entry *entry;
entry 244 fs/ext3/xattr.c entry = BFIRST(bh);
entry 245 fs/ext3/xattr.c error = ext3_xattr_find_entry(&entry, name_index, name, bh->b_size, 1);
entry 250 fs/ext3/xattr.c size = le32_to_cpu(entry->e_value_size);
entry 255 fs/ext3/xattr.c memcpy(buffer, bh->b_data + le16_to_cpu(entry->e_value_offs),
entry 270 fs/ext3/xattr.c struct ext3_xattr_entry *entry;
entry 284 fs/ext3/xattr.c entry = IFIRST(header);
entry 286 fs/ext3/xattr.c error = ext3_xattr_check_names(entry, end);
entry 289 fs/ext3/xattr.c error = ext3_xattr_find_entry(&entry, name_index, name,
entry 290 fs/ext3/xattr.c end - (void *)entry, 0);
entry 293 fs/ext3/xattr.c size = le32_to_cpu(entry->e_value_size);
entry 299 fs/ext3/xattr.c le16_to_cpu(entry->e_value_offs), size);
entry 340 fs/ext3/xattr.c for (; !IS_LAST_ENTRY(entry); entry = EXT3_XATTR_NEXT(entry)) {
entry 342 fs/ext3/xattr.c ext3_xattr_handler(entry->e_name_index);
entry 346 fs/ext3/xattr.c entry->e_name,
entry 347 fs/ext3/xattr.c entry->e_name_len);
entry 1254 fs/ext3/xattr.c char *name = entry->e_name;
entry 1257 fs/ext3/xattr.c for (n=0; n < entry->e_name_len; n++) {
entry 1263 fs/ext3/xattr.c if (entry->e_value_block == 0 && entry->e_value_size != 0) {
entry 1265 fs/ext3/xattr.c le16_to_cpu(entry->e_value_offs));
entry 1266 fs/ext3/xattr.c for (n = (le32_to_cpu(entry->e_value_size) +
entry 1273 fs/ext3/xattr.c entry->e_hash = cpu_to_le32(hash);
entry 1292 fs/ext3/xattr.c ext3_xattr_hash_entry(header, entry);
entry 55 fs/ext3/xattr.h (char *)(entry) + EXT3_XATTR_LEN((entry)->e_name_len)) )
entry 44 fs/ext4/acl.c ext4_acl_entry *entry =
entry 48 fs/ext4/acl.c acl->a_entries[n].e_tag = le16_to_cpu(entry->e_tag);
entry 49 fs/ext4/acl.c acl->a_entries[n].e_perm = le16_to_cpu(entry->e_perm);
entry 67 fs/ext4/acl.c le32_to_cpu(entry->e_id);
entry 101 fs/ext4/acl.c ext4_acl_entry *entry = (ext4_acl_entry *)e;
entry 102 fs/ext4/acl.c entry->e_tag = cpu_to_le16(acl->a_entries[n].e_tag);
entry 103 fs/ext4/acl.c entry->e_perm = cpu_to_le16(acl->a_entries[n].e_perm);
entry 107 fs/ext4/acl.c entry->e_id = cpu_to_le32(acl->a_entries[n].e_id);
entry 4725 fs/ext4/inode.c struct ext4_xattr_entry *entry;
entry 4733 fs/ext4/inode.c entry = IFIRST(header);
entry 204 fs/ext4/namei.c return le32_to_cpu(entry->block) & 0x00ffffff;
entry 209 fs/ext4/namei.c entry->block = cpu_to_le32(value);
entry 214 fs/ext4/namei.c return le32_to_cpu(entry->hash);
entry 219 fs/ext4/namei.c entry->hash = cpu_to_le32(value);
entry 67 fs/ext4/xattr.c #define IS_LAST_ENTRY(entry) (*(__u32 *)(entry) == 0)
entry 149 fs/ext4/xattr.c while (!IS_LAST_ENTRY(entry)) {
entry 150 fs/ext4/xattr.c struct ext4_xattr_entry *next = EXT4_XATTR_NEXT(entry);
entry 153 fs/ext4/xattr.c entry = next;
entry 173 fs/ext4/xattr.c size_t value_size = le32_to_cpu(entry->e_value_size);
entry 175 fs/ext4/xattr.c if (entry->e_value_block != 0 || value_size > size ||
entry 176 fs/ext4/xattr.c le16_to_cpu(entry->e_value_offs) + value_size > size)
entry 185 fs/ext4/xattr.c struct ext4_xattr_entry *entry;
entry 192 fs/ext4/xattr.c entry = *pentry;
entry 193 fs/ext4/xattr.c for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
entry 194 fs/ext4/xattr.c cmp = name_index - entry->e_name_index;
entry 196 fs/ext4/xattr.c cmp = name_len - entry->e_name_len;
entry 198 fs/ext4/xattr.c cmp = memcmp(name, entry->e_name, name_len);
entry 202 fs/ext4/xattr.c *pentry = entry;
entry 203 fs/ext4/xattr.c if (!cmp && ext4_xattr_check_entry(entry, size))
entry 213 fs/ext4/xattr.c struct ext4_xattr_entry *entry;
entry 237 fs/ext4/xattr.c entry = BFIRST(bh);
entry 238 fs/ext4/xattr.c error = ext4_xattr_find_entry(&entry, name_index, name, bh->b_size, 1);
entry 243 fs/ext4/xattr.c size = le32_to_cpu(entry->e_value_size);
entry 248 fs/ext4/xattr.c memcpy(buffer, bh->b_data + le16_to_cpu(entry->e_value_offs),
entry 263 fs/ext4/xattr.c struct ext4_xattr_entry *entry;
entry 277 fs/ext4/xattr.c entry = IFIRST(header);
entry 279 fs/ext4/xattr.c error = ext4_xattr_check_names(entry, end);
entry 282 fs/ext4/xattr.c error = ext4_xattr_find_entry(&entry, name_index, name,
entry 283 fs/ext4/xattr.c end - (void *)entry, 0);
entry 286 fs/ext4/xattr.c size = le32_to_cpu(entry->e_value_size);
entry 292 fs/ext4/xattr.c le16_to_cpu(entry->e_value_offs), size);
entry 333 fs/ext4/xattr.c for (; !IS_LAST_ENTRY(entry); entry = EXT4_XATTR_NEXT(entry)) {
entry 335 fs/ext4/xattr.c ext4_xattr_handler(entry->e_name_index);
entry 339 fs/ext4/xattr.c entry->e_name,
entry 340 fs/ext4/xattr.c entry->e_name_len);
entry 1098 fs/ext4/xattr.c struct ext4_xattr_entry *last = entry;
entry 1123 fs/ext4/xattr.c struct ext4_xattr_entry *entry, *last, *first;
entry 1142 fs/ext4/xattr.c entry = IFIRST(header);
entry 1149 fs/ext4/xattr.c base = start = entry;
entry 1152 fs/ext4/xattr.c last = entry;
entry 1157 fs/ext4/xattr.c entry = IFIRST(header);
entry 1158 fs/ext4/xattr.c ext4_xattr_shift_entries(entry, EXT4_I(inode)->i_extra_isize
entry 1229 fs/ext4/xattr.c entry = NULL;
entry 1238 fs/ext4/xattr.c entry = last;
entry 1244 fs/ext4/xattr.c if (entry == NULL) {
entry 1246 fs/ext4/xattr.c entry = small_entry;
entry 1258 fs/ext4/xattr.c offs = le16_to_cpu(entry->e_value_offs);
entry 1259 fs/ext4/xattr.c size = le32_to_cpu(entry->e_value_size);
entry 1260 fs/ext4/xattr.c entry_size = EXT4_XATTR_LEN(entry->e_name_len);
entry 1261 fs/ext4/xattr.c i.name_index = entry->e_name_index,
entry 1263 fs/ext4/xattr.c b_entry_name = kmalloc(entry->e_name_len + 1, GFP_NOFS);
entry 1271 fs/ext4/xattr.c memcpy(b_entry_name, entry->e_name, entry->e_name_len);
entry 1272 fs/ext4/xattr.c b_entry_name[entry->e_name_len] = '\0';
entry 1286 fs/ext4/xattr.c entry = IFIRST(header);
entry 1292 fs/ext4/xattr.c ext4_xattr_shift_entries(entry, EXT4_I(inode)->i_extra_isize -
entry 1518 fs/ext4/xattr.c char *name = entry->e_name;
entry 1521 fs/ext4/xattr.c for (n = 0; n < entry->e_name_len; n++) {
entry 1527 fs/ext4/xattr.c if (entry->e_value_block == 0 && entry->e_value_size != 0) {
entry 1529 fs/ext4/xattr.c le16_to_cpu(entry->e_value_offs));
entry 1530 fs/ext4/xattr.c for (n = (le32_to_cpu(entry->e_value_size) +
entry 1537 fs/ext4/xattr.c entry->e_hash = cpu_to_le32(hash);
entry 1556 fs/ext4/xattr.c ext4_xattr_hash_entry(header, entry);
entry 55 fs/ext4/xattr.h (char *)(entry) + EXT4_XATTR_LEN((entry)->e_name_len)))
entry 27 fs/fat/fatent.c int bytes = entry + (entry >> 1);
entry 28 fs/fat/fatent.c WARN_ON(entry < FAT_START_ENT || sbi->max_cluster <= entry);
entry 37 fs/fat/fatent.c int bytes = (entry << sbi->fatent_shift);
entry 38 fs/fat/fatent.c WARN_ON(entry < FAT_START_ENT || sbi->max_cluster <= entry);
entry 123 fs/fat/fatent.c if (fatent->entry & 1)
entry 161 fs/fat/fatent.c if (fatent->entry & 1) {
entry 199 fs/fat/fatent.c u8 *nextp = ent12_p[1] + 1 + (fatent->entry & 1);
entry 201 fs/fat/fatent.c fatent->entry++;
entry 228 fs/fat/fatent.c fatent->entry++;
entry 240 fs/fat/fatent.c fatent->entry++;
entry 336 fs/fat/fatent.c if (entry < FAT_START_ENT || sbi->max_cluster <= entry) {
entry 338 fs/fat/fatent.c fat_fs_panic(sb, "invalid access to FAT (entry 0x%08x)", entry);
entry 342 fs/fat/fatent.c fatent_set_entry(fatent, entry);
entry 343 fs/fat/fatent.c ops->ent_blocknr(sb, entry, &offset, &blocknr);
entry 406 fs/fat/fatent.c if (fatent->entry < sbi->max_cluster)
entry 420 fs/fat/fatent.c ops->ent_blocknr(sb, fatent->entry, &offset, &blocknr);
entry 466 fs/fat/fatent.c if (fatent.entry >= sbi->max_cluster)
entry 467 fs/fat/fatent.c fatent.entry = FAT_START_ENT;
entry 468 fs/fat/fatent.c fatent_set_entry(&fatent, fatent.entry);
entry 476 fs/fat/fatent.c int entry = fatent.entry;
entry 481 fs/fat/fatent.c ops->ent_put(&prev_ent, entry);
entry 485 fs/fat/fatent.c sbi->prev_free = entry;
entry 490 fs/fat/fatent.c cluster[idx_clus] = entry;
entry 560 fs/fat/fatent.c if (cluster != fatent.entry + 1) {
entry 561 fs/fat/fatent.c int nr_clus = fatent.entry - first_cl + 1;
entry 617 fs/fat/fatent.c ops->ent_blocknr(sb, fatent->entry, &offset, &blocknr);
entry 642 fs/fat/fatent.c while (fatent.entry < sbi->max_cluster) {
entry 173 fs/fuse/control.c list_for_each_entry(fc, &fuse_conn_list, entry) {
entry 200 fs/fuse/control.c list_for_each_entry(fc, &fuse_conn_list, entry)
entry 819 fs/fuse/dev.c struct list_head *entry;
entry 821 fs/fuse/dev.c list_for_each(entry, &fc->processing) {
entry 823 fs/fuse/dev.c req = list_entry(entry, struct fuse_req, list);
entry 20 fs/fuse/dir.c entry->d_time = time;
entry 25 fs/fuse/dir.c return entry->d_time;
entry 33 fs/fuse/dir.c entry->d_time = time;
entry 34 fs/fuse/dir.c entry->d_fsdata = (void *) (unsigned long) (time >> 32);
entry 39 fs/fuse/dir.c return (u64) entry->d_time +
entry 40 fs/fuse/dir.c ((u64) (unsigned long) entry->d_fsdata << 32);
entry 69 fs/fuse/dir.c fuse_dentry_settime(entry,
entry 102 fs/fuse/dir.c fuse_dentry_settime(entry, 0);
entry 111 fs/fuse/dir.c d_invalidate(entry);
entry 112 fs/fuse/dir.c fuse_invalidate_entry_cache(entry);
entry 159 fs/fuse/dir.c struct inode *inode = entry->d_inode;
entry 163 fs/fuse/dir.c else if (fuse_dentry_time(entry) < get_jiffies_64()) {
entry 189 fs/fuse/dir.c parent = dget_parent(entry);
entry 191 fs/fuse/dir.c &entry->d_name, &outarg);
entry 217 fs/fuse/dir.c fuse_change_entry_timeout(entry, &outarg);
entry 254 fs/fuse/dir.c return d_splice_alias(inode, entry);
entry 325 fs/fuse/dir.c err = fuse_lookup_name(dir->i_sb, get_node_id(dir), &entry->d_name,
entry 340 fs/fuse/dir.c newent = fuse_d_add_directory(entry, inode);
entry 346 fs/fuse/dir.c newent = d_splice_alias(inode, entry);
entry 349 fs/fuse/dir.c entry = newent ? newent : entry;
entry 350 fs/fuse/dir.c entry->d_op = &fuse_dentry_operations;
entry 352 fs/fuse/dir.c fuse_change_entry_timeout(entry, &outarg);
entry 354 fs/fuse/dir.c fuse_invalidate_entry_cache(entry);
entry 425 fs/fuse/dir.c req->in.args[1].size = entry->d_name.len + 1;
entry 426 fs/fuse/dir.c req->in.args[1].value = entry->d_name.name;
entry 458 fs/fuse/dir.c d_instantiate(entry, inode);
entry 459 fs/fuse/dir.c fuse_change_entry_timeout(entry, &outentry);
entry 461 fs/fuse/dir.c file = lookup_instantiate_filp(nd, entry, generic_file_open);
entry 537 fs/fuse/dir.c d_instantiate(entry, inode);
entry 540 fs/fuse/dir.c d_instantiate(entry, inode);
entry 542 fs/fuse/dir.c fuse_change_entry_timeout(entry, &outarg);
entry 567 fs/fuse/dir.c req->in.args[1].size = entry->d_name.len + 1;
entry 568 fs/fuse/dir.c req->in.args[1].value = entry->d_name.name;
entry 569 fs/fuse/dir.c return create_new_entry(fc, req, dir, entry, mode);
entry 576 fs/fuse/dir.c int err = fuse_create_open(dir, entry, mode, nd);
entry 581 fs/fuse/dir.c return fuse_mknod(dir, entry, mode, 0);
entry 598 fs/fuse/dir.c req->in.args[1].size = entry->d_name.len + 1;
entry 599 fs/fuse/dir.c req->in.args[1].value = entry->d_name.name;
entry 600 fs/fuse/dir.c return create_new_entry(fc, req, dir, entry, S_IFDIR);
entry 614 fs/fuse/dir.c req->in.args[0].size = entry->d_name.len + 1;
entry 615 fs/fuse/dir.c req->in.args[0].value = entry->d_name.name;
entry 618 fs/fuse/dir.c return create_new_entry(fc, req, dir, entry, S_IFLNK);
entry 632 fs/fuse/dir.c req->in.args[0].size = entry->d_name.len + 1;
entry 633 fs/fuse/dir.c req->in.args[0].value = entry->d_name.name;
entry 638 fs/fuse/dir.c struct inode *inode = entry->d_inode;
entry 646 fs/fuse/dir.c fuse_invalidate_entry_cache(entry);
entry 648 fs/fuse/dir.c fuse_invalidate_entry(entry);
entry 663 fs/fuse/dir.c req->in.args[0].size = entry->d_name.len + 1;
entry 664 fs/fuse/dir.c req->in.args[0].value = entry->d_name.name;
entry 669 fs/fuse/dir.c clear_nlink(entry->d_inode);
entry 671 fs/fuse/dir.c fuse_invalidate_entry_cache(entry);
entry 673 fs/fuse/dir.c fuse_invalidate_entry(entry);
entry 731 fs/fuse/dir.c struct inode *inode = entry->d_inode;
entry 1205 fs/fuse/dir.c struct inode *inode = entry->d_inode;
entry 1318 fs/fuse/dir.c return fuse_do_setattr(entry, attr, attr->ia_file);
entry 1320 fs/fuse/dir.c return fuse_do_setattr(entry, attr, NULL);
entry 1326 fs/fuse/dir.c struct inode *inode = entry->d_inode;
entry 1338 fs/fuse/dir.c struct inode *inode = entry->d_inode;
entry 1376 fs/fuse/dir.c struct inode *inode = entry->d_inode;
entry 1425 fs/fuse/dir.c struct inode *inode = entry->d_inode;
entry 1475 fs/fuse/dir.c struct inode *inode = entry->d_inode;
entry 423 fs/fuse/fuse_i.h struct list_head entry;
entry 292 fs/fuse/inode.c list_del(&fc->entry);
entry 567 fs/fuse/inode.c struct dentry *entry;
entry 599 fs/fuse/inode.c entry = d_alloc_anon(inode);
entry 601 fs/fuse/inode.c if (!entry)
entry 605 fs/fuse/inode.c entry->d_op = &fuse_dentry_operations;
entry 606 fs/fuse/inode.c fuse_invalidate_entry_cache(entry);
entry 609 fs/fuse/inode.c return entry;
entry 880 fs/fuse/inode.c list_add_tail(&fc->entry, &fuse_conn_list);
entry 132 fs/hfs/brec.c hfs_bnode_write(node, entry, data_off + key_len, entry_len);
entry 151 fs/hfs/brec.c entry = &cnid;
entry 86 fs/hfs/catalog.c union hfs_cat_rec entry;
entry 98 fs/hfs/catalog.c entry_size = hfs_cat_build_thread(sb, &entry, S_ISDIR(inode->i_mode) ?
entry 107 fs/hfs/catalog.c err = hfs_brec_insert(&fd, &entry, entry_size);
entry 112 fs/hfs/catalog.c entry_size = hfs_cat_build_record(&entry, cnid, inode);
entry 120 fs/hfs/catalog.c err = hfs_brec_insert(&fd, &entry, entry_size);
entry 273 fs/hfs/catalog.c union hfs_cat_rec entry;
entry 289 fs/hfs/catalog.c hfs_bnode_read(src_fd.bnode, &entry, src_fd.entryoffset,
entry 301 fs/hfs/catalog.c err = hfs_brec_insert(&dst_fd, &entry, src_fd.entrylength);
entry 320 fs/hfs/catalog.c type = entry.type;
entry 321 fs/hfs/catalog.c if (type == HFS_CDR_FIL && !(entry.file.Flags & HFS_FIL_THD))
entry 335 fs/hfs/catalog.c entry_size = hfs_cat_build_thread(sb, &entry, type == HFS_CDR_FIL ? HFS_CDR_FTH : HFS_CDR_THD,
entry 343 fs/hfs/catalog.c err = hfs_brec_insert(&dst_fd, &entry, entry_size);
entry 60 fs/hfs/dir.c union hfs_cat_rec entry;
entry 82 fs/hfs/dir.c hfs_bnode_read(fd.bnode, &entry, fd.entryoffset, fd.entrylength);
entry 83 fs/hfs/dir.c if (entry.type != HFS_CDR_THD) {
entry 94 fs/hfs/dir.c be32_to_cpu(entry.thread.ParID), DT_DIR))
entry 112 fs/hfs/dir.c hfs_bnode_read(fd.bnode, &entry, fd.entryoffset, fd.entrylength);
entry 113 fs/hfs/dir.c type = entry.type;
entry 122 fs/hfs/dir.c be32_to_cpu(entry.dir.DirID), DT_DIR))
entry 131 fs/hfs/dir.c be32_to_cpu(entry.file.FlNum), DT_REG))
entry 119 fs/hfsplus/brec.c hfs_bnode_write(node, entry, data_off + key_len, entry_len);
entry 138 fs/hfsplus/brec.c entry = &cnid;
entry 92 fs/hfsplus/catalog.c folder = &entry->folder;
entry 109 fs/hfsplus/catalog.c file = &entry->file;
entry 145 fs/hfsplus/catalog.c entry->type = cpu_to_be16(type);
entry 146 fs/hfsplus/catalog.c entry->thread.reserved = 0;
entry 147 fs/hfsplus/catalog.c entry->thread.parentID = cpu_to_be32(parentid);
entry 148 fs/hfsplus/catalog.c hfsplus_asc2uni(sb, &entry->thread.nodeName, str->name, str->len);
entry 149 fs/hfsplus/catalog.c return 10 + be16_to_cpu(entry->thread.nodeName.length) * 2;
entry 180 fs/hfsplus/catalog.c hfsplus_cat_entry entry;
entry 189 fs/hfsplus/catalog.c entry_size = hfsplus_fill_cat_thread(sb, &entry, S_ISDIR(inode->i_mode) ?
entry 198 fs/hfsplus/catalog.c err = hfs_brec_insert(&fd, &entry, entry_size);
entry 203 fs/hfsplus/catalog.c entry_size = hfsplus_cat_build_record(&entry, cnid, inode);
entry 211 fs/hfsplus/catalog.c err = hfs_brec_insert(&fd, &entry, entry_size);
entry 312 fs/hfsplus/catalog.c hfsplus_cat_entry entry;
entry 328 fs/hfsplus/catalog.c hfs_bnode_read(src_fd.bnode, &entry, src_fd.entryoffset,
entry 340 fs/hfsplus/catalog.c err = hfs_brec_insert(&dst_fd, &entry, src_fd.entrylength);
entry 371 fs/hfsplus/catalog.c entry_size = hfsplus_fill_cat_thread(sb, &entry, type, dst_dir->i_ino, dst_name);
entry 378 fs/hfsplus/catalog.c err = hfs_brec_insert(&dst_fd, &entry, entry_size);
entry 33 fs/hfsplus/dir.c hfsplus_cat_entry entry;
entry 45 fs/hfsplus/dir.c err = hfs_brec_read(&fd, &entry, sizeof(entry));
entry 55 fs/hfsplus/dir.c type = be16_to_cpu(entry.type);
entry 61 fs/hfsplus/dir.c cnid = be32_to_cpu(entry.folder.id);
entry 68 fs/hfsplus/dir.c cnid = be32_to_cpu(entry.file.id);
entry 69 fs/hfsplus/dir.c if (entry.file.user_info.fdType == cpu_to_be32(HFSP_HARDLINK_TYPE) &&
entry 70 fs/hfsplus/dir.c entry.file.user_info.fdCreator == cpu_to_be32(HFSP_HFSPLUS_CREATOR) &&
entry 71 fs/hfsplus/dir.c (entry.file.create_date == HFSPLUS_I(HFSPLUS_SB(sb).hidden_dir).create_date ||
entry 72 fs/hfsplus/dir.c entry.file.create_date == HFSPLUS_I(sb->s_root->d_inode).create_date) &&
entry 86 fs/hfsplus/dir.c linkid = be32_to_cpu(entry.file.permissions.dev);
entry 119 fs/hfsplus/dir.c hfsplus_cat_entry entry;
entry 141 fs/hfsplus/dir.c hfs_bnode_read(fd.bnode, &entry, fd.entryoffset, fd.entrylength);
entry 142 fs/hfsplus/dir.c if (be16_to_cpu(entry.type) != HFSPLUS_FOLDER_THREAD) {
entry 153 fs/hfsplus/dir.c be32_to_cpu(entry.thread.parentID), DT_DIR))
entry 171 fs/hfsplus/dir.c hfs_bnode_read(fd.bnode, &entry, fd.entryoffset, fd.entrylength);
entry 172 fs/hfsplus/dir.c type = be16_to_cpu(entry.type);
entry 184 fs/hfsplus/dir.c HFSPLUS_SB(sb).hidden_dir->i_ino == be32_to_cpu(entry.folder.id))
entry 187 fs/hfsplus/dir.c be32_to_cpu(entry.folder.id), DT_DIR))
entry 196 fs/hfsplus/dir.c be32_to_cpu(entry.file.id), DT_REG))
entry 409 fs/hfsplus/inode.c hfsplus_cat_entry entry;
entry 417 fs/hfsplus/inode.c struct hfsplus_cat_folder *folder = &entry.folder;
entry 421 fs/hfsplus/inode.c hfs_bnode_read(fd->bnode, &entry, fd->entryoffset,
entry 434 fs/hfsplus/inode.c struct hfsplus_cat_file *file = &entry.file;
entry 438 fs/hfsplus/inode.c hfs_bnode_read(fd->bnode, &entry, fd->entryoffset,
entry 473 fs/hfsplus/inode.c hfsplus_cat_entry entry;
entry 490 fs/hfsplus/inode.c struct hfsplus_cat_folder *folder = &entry.folder;
entry 494 fs/hfsplus/inode.c hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
entry 502 fs/hfsplus/inode.c hfs_bnode_write(fd.bnode, &entry, fd.entryoffset,
entry 505 fs/hfsplus/inode.c struct hfsplus_cat_file *file = &entry.file;
entry 506 fs/hfsplus/inode.c hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
entry 509 fs/hfsplus/inode.c hfs_bnode_write(fd.bnode, &entry, fd.entryoffset,
entry 512 fs/hfsplus/inode.c struct hfsplus_cat_file *file = &entry.file;
entry 516 fs/hfsplus/inode.c hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
entry 531 fs/hfsplus/inode.c hfs_bnode_write(fd.bnode, &entry, fd.entryoffset,
entry 100 fs/hfsplus/ioctl.c hfsplus_cat_entry entry;
entry 113 fs/hfsplus/ioctl.c hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
entry 115 fs/hfsplus/ioctl.c file = &entry.file;
entry 130 fs/hfsplus/ioctl.c hfs_bnode_write(fd.bnode, &entry, fd.entryoffset,
entry 142 fs/hfsplus/ioctl.c hfsplus_cat_entry entry;
entry 156 fs/hfsplus/ioctl.c hfs_bnode_read(fd.bnode, &entry, fd.entryoffset,
entry 159 fs/hfsplus/ioctl.c file = &entry.file;
entry 288 fs/hfsplus/super.c hfsplus_cat_entry entry;
entry 405 fs/hfsplus/super.c if (!hfs_brec_read(&fd, &entry, sizeof(entry))) {
entry 407 fs/hfsplus/super.c if (entry.type != cpu_to_be16(HFSPLUS_FOLDER))
entry 409 fs/hfsplus/super.c inode = hfsplus_iget(sb, be32_to_cpu(entry.folder.id));
entry 250 fs/inotify.c spin_lock(&entry->d_lock);
entry 251 fs/inotify.c parent = entry->d_parent;
entry 253 fs/inotify.c entry->d_flags |= DCACHE_INOTIFY_PARENT_WATCHED;
entry 254 fs/inotify.c spin_unlock(&entry->d_lock);
entry 264 fs/inotify.c parent = entry->d_parent;
entry 266 fs/inotify.c entry->d_flags |= DCACHE_INOTIFY_PARENT_WATCHED;
entry 268 fs/inotify.c entry->d_flags &= ~DCACHE_INOTIFY_PARENT_WATCHED;
entry 57 fs/jffs2/acl.c struct jffs2_acl_entry *entry;
entry 84 fs/jffs2/acl.c entry = value;
entry 87 fs/jffs2/acl.c acl->a_entries[i].e_tag = je16_to_cpu(entry->e_tag);
entry 88 fs/jffs2/acl.c acl->a_entries[i].e_perm = je16_to_cpu(entry->e_perm);
entry 103 fs/jffs2/acl.c acl->a_entries[i].e_id = je32_to_cpu(entry->e_id);
entry 121 fs/jffs2/acl.c struct jffs2_acl_entry *entry;
entry 126 fs/jffs2/acl.c header = kmalloc(sizeof(*header) + acl->a_count * sizeof(*entry), GFP_KERNEL);
entry 132 fs/jffs2/acl.c entry = e;
entry 133 fs/jffs2/acl.c entry->e_tag = cpu_to_je16(acl->a_entries[i].e_tag);
entry 134 fs/jffs2/acl.c entry->e_perm = cpu_to_je16(acl->a_entries[i].e_perm);
entry 138 fs/jffs2/acl.c entry->e_id = cpu_to_je32(acl->a_entries[i].e_id);
entry 4523 fs/jfs/jfs_dtree.c struct ldtentry *entry;
entry 4555 fs/jfs/jfs_dtree.c entry = (struct ldtentry *) & p->slot[entry_si];
entry 4558 fs/jfs/jfs_dtree.c entry->inumber = cpu_to_le32(new_ino);
entry 568 fs/ncpfs/dir.c entry->i.entryName, entry->i.nameLen,
entry 569 fs/ncpfs/dir.c !ncp_preserve_entry_case(inode, entry->i.NSCreator)))
entry 592 fs/ncpfs/dir.c entry->opened = 0;
entry 593 fs/ncpfs/dir.c entry->ino = iunique(inode->i_sb, 2);
entry 594 fs/ncpfs/dir.c newino = ncp_iget(inode->i_sb, entry);
entry 602 fs/ncpfs/dir.c ncp_update_inode2(newdent->d_inode, entry);
entry 656 fs/ncpfs/dir.c struct ncp_entry_info entry;
entry 673 fs/ncpfs/dir.c &entry.i)) {
entry 678 fs/ncpfs/dir.c entry.volume = entry.i.volNumber;
entry 679 fs/ncpfs/dir.c if (!ncp_fill_cache(filp, dirent, filldir, ctl, &entry))
entry 692 fs/ncpfs/dir.c struct ncp_entry_info entry;
entry 734 fs/ncpfs/dir.c ncp_extract_file_info(rpl, &entry.i);
entry 735 fs/ncpfs/dir.c onerpl = offsetof(struct nw_info_struct, entryName) + entry.i.nameLen;
entry 738 fs/ncpfs/dir.c (void)ncp_obtain_nfs_info(server, &entry.i);
entry 741 fs/ncpfs/dir.c entry.volume = entry.i.volNumber;
entry 742 fs/ncpfs/dir.c if (!ncp_fill_cache(filp, dirent, filldir, ctl, &entry))
entry 155 fs/nfs/dir.c struct nfs_entry *entry;
entry 184 fs/nfs/dir.c __func__, (long long)desc->entry->cookie,
entry 189 fs/nfs/dir.c error = NFS_PROTO(inode)->readdir(file->f_path.dentry, cred, desc->entry->cookie, page,
entry 223 fs/nfs/dir.c p = desc->decode(p, desc->entry, desc->plus);
entry 228 fs/nfs/dir.c desc->entry->fattr->time_start = desc->timestamp;
entry 230 fs/nfs/dir.c desc->entry->fattr->valid &= ~NFS_ATTR_FATTR;
entry 254 fs/nfs/dir.c struct nfs_entry *entry = desc->entry;
entry 260 fs/nfs/dir.c __func__, (unsigned long long)entry->cookie);
entry 261 fs/nfs/dir.c if (entry->prev_cookie == *desc->dir_cookie)
entry 282 fs/nfs/dir.c struct nfs_entry *entry = desc->entry;
entry 292 fs/nfs/dir.c (unsigned long long)entry->cookie, desc->current_index);
entry 295 fs/nfs/dir.c *desc->dir_cookie = entry->cookie;
entry 365 fs/nfs/dir.c desc->entry->cookie = desc->entry->prev_cookie = 0;
entry 366 fs/nfs/dir.c desc->entry->eof = 0;
entry 403 fs/nfs/dir.c struct nfs_entry *entry = desc->entry;
entry 410 fs/nfs/dir.c (unsigned long long)entry->cookie);
entry 416 fs/nfs/dir.c fileid = entry->ino;
entry 429 fs/nfs/dir.c res = filldir(dirent, entry->name, entry->len,
entry 435 fs/nfs/dir.c *desc->dir_cookie = entry->cookie;
entry 495 fs/nfs/dir.c desc->entry->prev_cookie = *desc->dir_cookie;
entry 506 fs/nfs/dir.c desc->entry->cookie = desc->entry->prev_cookie = 0;
entry 507 fs/nfs/dir.c desc->entry->eof = 0;
entry 555 fs/nfs/dir.c desc->entry = &my_entry;
entry 562 fs/nfs/dir.c while(!desc->entry->eof) {
entry 567 fs/nfs/dir.c if (*desc->dir_cookie && desc->entry->cookie != *desc->dir_cookie) {
entry 580 fs/nfs/dir.c desc->entry->eof = 0;
entry 1088 fs/nfs/dir.c struct nfs_entry *entry = desc->entry;
entry 1091 fs/nfs/dir.c .name = entry->name,
entry 1092 fs/nfs/dir.c .len = entry->len,
entry 1119 fs/nfs/dir.c (NFS_FILEID(dentry->d_inode) == entry->ino ||
entry 1121 fs/nfs/dir.c if (!desc->plus || entry->fh->size == 0)
entry 1124 fs/nfs/dir.c entry->fh) == 0)
entry 1131 fs/nfs/dir.c if (!desc->plus || !(entry->fattr->valid & NFS_ATTR_FATTR))
entry 1140 fs/nfs/dir.c inode = nfs_fhget(dentry->d_sb, entry->fh, entry->fattr);
entry 1660 fs/nfs/dir.c put_rpccred(entry->cred);
entry 1661 fs/nfs/dir.c kfree(entry);
entry 1724 fs/nfs/dir.c struct nfs_access_entry *entry;
entry 1728 fs/nfs/dir.c entry = rb_entry(n, struct nfs_access_entry, rb_node);
entry 1730 fs/nfs/dir.c list_del(&entry->lru);
entry 1762 fs/nfs/dir.c struct nfs_access_entry *entry;
entry 1765 fs/nfs/dir.c entry = rb_entry(n, struct nfs_access_entry, rb_node);
entry 1767 fs/nfs/dir.c if (cred < entry->cred)
entry 1769 fs/nfs/dir.c else if (cred > entry->cred)
entry 1772 fs/nfs/dir.c return entry;
entry 1817 fs/nfs/dir.c struct nfs_access_entry *entry;
entry 1822 fs/nfs/dir.c entry = rb_entry(parent, struct nfs_access_entry, rb_node);
entry 1824 fs/nfs/dir.c if (set->cred < entry->cred)
entry 1826 fs/nfs/dir.c else if (set->cred > entry->cred)
entry 1839 fs/nfs/dir.c list_del(&entry->lru);
entry 1841 fs/nfs/dir.c nfs_access_free_entry(entry);
entry 432 fs/nfs/nfs2xdr.c __be32 *end, *entry, *kaddr;
entry 454 fs/nfs/nfs2xdr.c entry = p;
entry 457 fs/nfs/nfs2xdr.c if ((entry + 1) > end)
entry 473 fs/nfs/nfs2xdr.c entry = p;
entry 481 fs/nfs/nfs2xdr.c if (!nr && entry[1] == 0) {
entry 483 fs/nfs/nfs2xdr.c entry[1] = 1;
entry 498 fs/nfs/nfs2xdr.c entry[0] = entry[1] = 0;
entry 513 fs/nfs/nfs2xdr.c entry->eof = 1;
entry 517 fs/nfs/nfs2xdr.c entry->ino = ntohl(*p++);
entry 518 fs/nfs/nfs2xdr.c entry->len = ntohl(*p++);
entry 519 fs/nfs/nfs2xdr.c entry->name = (const char *) p;
entry 520 fs/nfs/nfs2xdr.c p += XDR_QUADLEN(entry->len);
entry 521 fs/nfs/nfs2xdr.c entry->prev_cookie = entry->cookie;
entry 522 fs/nfs/nfs2xdr.c entry->cookie = ntohl(*p++);
entry 523 fs/nfs/nfs2xdr.c entry->eof = !p[0] && p[1];
entry 192 fs/nfs/nfs3proc.c .rpc_cred = entry->cred,
entry 194 fs/nfs/nfs3proc.c int mode = entry->mask;
entry 216 fs/nfs/nfs3proc.c entry->mask = 0;
entry 218 fs/nfs/nfs3proc.c entry->mask |= MAY_READ;
entry 220 fs/nfs/nfs3proc.c entry->mask |= MAY_WRITE;
entry 222 fs/nfs/nfs3proc.c entry->mask |= MAY_EXEC;
entry 512 fs/nfs/nfs3xdr.c __be32 *entry, *end, *kaddr;
entry 544 fs/nfs/nfs3xdr.c entry = p;
entry 547 fs/nfs/nfs3xdr.c if ((entry + 1) > end)
entry 587 fs/nfs/nfs3xdr.c entry = p;
entry 595 fs/nfs/nfs3xdr.c if (!nr && entry[1] == 0) {
entry 597 fs/nfs/nfs3xdr.c entry[1] = 1;
entry 612 fs/nfs/nfs3xdr.c entry[0] = entry[1] = 0;
entry 624 fs/nfs/nfs3xdr.c struct nfs_entry old = *entry;
entry 629 fs/nfs/nfs3xdr.c entry->eof = 1;
entry 633 fs/nfs/nfs3xdr.c p = xdr_decode_hyper(p, &entry->ino);
entry 634 fs/nfs/nfs3xdr.c entry->len = ntohl(*p++);
entry 635 fs/nfs/nfs3xdr.c entry->name = (const char *) p;
entry 636 fs/nfs/nfs3xdr.c p += XDR_QUADLEN(entry->len);
entry 637 fs/nfs/nfs3xdr.c entry->prev_cookie = entry->cookie;
entry 638 fs/nfs/nfs3xdr.c p = xdr_decode_hyper(p, &entry->cookie);
entry 641 fs/nfs/nfs3xdr.c entry->fattr->valid = 0;
entry 642 fs/nfs/nfs3xdr.c p = xdr_decode_post_op_attr(p, entry->fattr);
entry 645 fs/nfs/nfs3xdr.c p = xdr_decode_fhandle(p, entry->fh);
entry 649 fs/nfs/nfs3xdr.c *entry = old;
entry 653 fs/nfs/nfs3xdr.c memset((u8*)(entry->fh), 0, sizeof(*entry->fh));
entry 656 fs/nfs/nfs3xdr.c entry->eof = !p[0] && p[1];
entry 1760 fs/nfs/nfs4proc.c .rpc_cred = entry->cred,
entry 1762 fs/nfs/nfs4proc.c int mode = entry->mask;
entry 1784 fs/nfs/nfs4proc.c entry->mask = 0;
entry 1786 fs/nfs/nfs4proc.c entry->mask |= MAY_READ;
entry 1788 fs/nfs/nfs4proc.c entry->mask |= MAY_WRITE;
entry 1790 fs/nfs/nfs4proc.c entry->mask |= MAY_EXEC;
entry 1802 fs/nfs/nfs4proc.c _nfs4_proc_access(inode, entry),
entry 3499 fs/nfs/nfs4xdr.c __be32 *end, *entry, *p, *kaddr;
entry 3523 fs/nfs/nfs4xdr.c entry = p;
entry 3526 fs/nfs/nfs4xdr.c if ((entry + 1) > end)
entry 3554 fs/nfs/nfs4xdr.c entry = p;
entry 3561 fs/nfs/nfs4xdr.c if (!nr && entry[1] == 0) {
entry 3563 fs/nfs/nfs4xdr.c entry[1] = 1;
entry 3579 fs/nfs/nfs4xdr.c entry[0] = entry[1] = 0;
entry 4594 fs/nfs/nfs4xdr.c entry->eof = 1;
entry 4598 fs/nfs/nfs4xdr.c entry->prev_cookie = entry->cookie;
entry 4599 fs/nfs/nfs4xdr.c p = xdr_decode_hyper(p, &entry->cookie);
entry 4600 fs/nfs/nfs4xdr.c entry->len = ntohl(*p++);
entry 4601 fs/nfs/nfs4xdr.c entry->name = (const char *) p;
entry 4602 fs/nfs/nfs4xdr.c p += XDR_QUADLEN(entry->len);
entry 4609 fs/nfs/nfs4xdr.c entry->ino = 1;
entry 4628 fs/nfs/nfs4xdr.c xdr_decode_hyper(p, &entry->ino);
entry 4630 fs/nfs/nfs4xdr.c xdr_decode_hyper(p, &entry->ino);
entry 4634 fs/nfs/nfs4xdr.c entry->eof = !p[0] && p[1];
entry 51 fs/nfs_common/nfsacl.c struct posix_acl_entry *entry =
entry 54 fs/nfs_common/nfsacl.c *p++ = htonl(entry->e_tag | nfsacl_desc->typeflag);
entry 55 fs/nfs_common/nfsacl.c switch(entry->e_tag) {
entry 64 fs/nfs_common/nfsacl.c *p++ = htonl(entry->e_id);
entry 70 fs/nfs_common/nfsacl.c *p++ = htonl(entry->e_perm & S_IRWXO);
entry 131 fs/nfs_common/nfsacl.c struct posix_acl_entry *entry;
entry 142 fs/nfs_common/nfsacl.c entry = &nfsacl_desc->acl->a_entries[nfsacl_desc->count++];
entry 143 fs/nfs_common/nfsacl.c entry->e_tag = ntohl(*p++) & ~NFS_ACL_DEFAULT;
entry 144 fs/nfs_common/nfsacl.c entry->e_id = ntohl(*p++);
entry 145 fs/nfs_common/nfsacl.c entry->e_perm = ntohl(*p++);
entry 147 fs/nfs_common/nfsacl.c switch(entry->e_tag) {
entry 153 fs/nfs_common/nfsacl.c if (entry->e_perm & ~S_IRWXO)
entry 158 fs/nfs_common/nfsacl.c entry->e_perm &= S_IRWXO;
entry 854 fs/nfsd/nfsctl.c struct proc_dir_entry *entry;
entry 856 fs/nfsd/nfsctl.c entry = proc_mkdir("fs/nfs", NULL);
entry 857 fs/nfsd/nfsctl.c if (!entry)
entry 859 fs/nfsd/nfsctl.c entry = proc_create("exports", 0, entry, &exports_operations);
entry 860 fs/nfsd/nfsctl.c if (!entry)
entry 57 fs/ntfs/index.c if (ictx->entry) {
entry 214 fs/ntfs/index.c ictx->entry = ie;
entry 77 fs/ntfs/index.h INDEX_ENTRY *entry;
entry 178 fs/ocfs2/xattr.c char *name = (char *)header + le16_to_cpu(entry->xe_name_offset);
entry 180 fs/ocfs2/xattr.c hash = ocfs2_xattr_name_hash(inode, name, entry->xe_name_len);
entry 181 fs/ocfs2/xattr.c entry->xe_name_hash = cpu_to_le32(hash);
entry 488 fs/ocfs2/xattr.c struct ocfs2_xattr_entry *entry = &header->xh_entries[i];
entry 489 fs/ocfs2/xattr.c type = ocfs2_xattr_get_type(entry);
entry 494 fs/ocfs2/xattr.c le16_to_cpu(entry->xe_name_offset);
entry 498 fs/ocfs2/xattr.c entry->xe_name_len);
entry 618 fs/ocfs2/xattr.c struct ocfs2_xattr_entry *entry;
entry 626 fs/ocfs2/xattr.c entry = xs->here;
entry 628 fs/ocfs2/xattr.c cmp = name_index - ocfs2_xattr_get_type(entry);
entry 630 fs/ocfs2/xattr.c cmp = name_len - entry->xe_name_len;
entry 633 fs/ocfs2/xattr.c le16_to_cpu(entry->xe_name_offset)),
entry 637 fs/ocfs2/xattr.c entry += 1;
entry 639 fs/ocfs2/xattr.c xs->here = entry;
entry 1444 fs/ocfs2/xattr.c struct ocfs2_xattr_entry *entry = &header->xh_entries[i];
entry 1446 fs/ocfs2/xattr.c if (!ocfs2_xattr_is_local(entry)) {
entry 1451 fs/ocfs2/xattr.c le16_to_cpu(entry->xe_name_offset);
entry 1453 fs/ocfs2/xattr.c (val + OCFS2_XATTR_SIZE(entry->xe_name_len));
entry 2500 fs/ocfs2/xattr.c struct ocfs2_xattr_entry *entry = &bucket->xh->xh_entries[i];
entry 2501 fs/ocfs2/xattr.c type = ocfs2_xattr_get_type(entry);
entry 2519 fs/ocfs2/xattr.c entry->xe_name_len);
entry 122 fs/omfs/dir.c __be64 *entry;
entry 130 fs/omfs/dir.c entry = (__be64 *) &bh->b_data[ofs];
entry 131 fs/omfs/dir.c block = be64_to_cpu(*entry);
entry 132 fs/omfs/dir.c *entry = cpu_to_be64(inode->i_ino);
entry 167 fs/omfs/dir.c __be64 *entry, next;
entry 177 fs/omfs/dir.c entry = (__be64 *) &bh->b_data[ofs];
entry 178 fs/omfs/dir.c block = be64_to_cpu(*entry);
entry 199 fs/omfs/dir.c entry = &oi->i_sibling;
entry 202 fs/omfs/dir.c *entry = next;
entry 51 fs/omfs/file.c struct omfs_extent_entry *entry;
entry 87 fs/omfs/file.c entry = &oe->e_entry;
entry 92 fs/omfs/file.c start = be64_to_cpu(entry->e_cluster);
entry 93 fs/omfs/file.c count = be64_to_cpu(entry->e_blocks);
entry 96 fs/omfs/file.c entry++;
entry 136 fs/omfs/file.c struct omfs_extent_entry *entry = &oe->e_entry;
entry 158 fs/omfs/file.c terminator = entry + extent_count - 1;
entry 160 fs/omfs/file.c entry = terminator-1;
entry 161 fs/omfs/file.c new_block = be64_to_cpu(entry->e_cluster) +
entry 162 fs/omfs/file.c be64_to_cpu(entry->e_blocks);
entry 165 fs/omfs/file.c entry->e_blocks =
entry 166 fs/omfs/file.c cpu_to_be64(be64_to_cpu(entry->e_blocks) + 1);
entry 185 fs/omfs/file.c entry = terminator;
entry 187 fs/omfs/file.c memcpy(terminator, entry, sizeof(struct omfs_extent_entry));
entry 189 fs/omfs/file.c entry->e_cluster = cpu_to_be64(new_block);
entry 190 fs/omfs/file.c entry->e_blocks = cpu_to_be64((u64) new_count);
entry 244 fs/omfs/file.c struct omfs_extent_entry *entry;
entry 265 fs/omfs/file.c entry = &oe->e_entry;
entry 270 fs/omfs/file.c offset = find_block(inode, entry, block, extent_count, &remain);
entry 171 fs/reiserfs/journal.c struct list_head *entry = journal->j_bitmap_nodes.next;
entry 176 fs/reiserfs/journal.c if (entry != &journal->j_bitmap_nodes) {
entry 177 fs/reiserfs/journal.c bn = list_entry(entry, struct reiserfs_bitmap_node, list);
entry 178 fs/reiserfs/journal.c list_del(entry);
entry 605 fs/reiserfs/journal.c struct list_head *entry = &journal->j_journal_list;
entry 608 fs/reiserfs/journal.c if (!list_empty(entry)) {
entry 609 fs/reiserfs/journal.c jl = JOURNAL_LIST_ENTRY(entry->next);
entry 935 fs/reiserfs/journal.c struct list_head *entry;
entry 945 fs/reiserfs/journal.c entry = jl->j_list.prev;
entry 947 fs/reiserfs/journal.c other_jl = JOURNAL_LIST_ENTRY(entry);
entry 948 fs/reiserfs/journal.c if (entry == &journal->j_journal_list ||
entry 953 fs/reiserfs/journal.c entry = other_jl->j_list.prev;
entry 963 fs/reiserfs/journal.c entry = &first_jl->j_list;
entry 965 fs/reiserfs/journal.c other_jl = JOURNAL_LIST_ENTRY(entry);
entry 985 fs/reiserfs/journal.c entry = entry->next;
entry 986 fs/reiserfs/journal.c if (entry == &journal->j_journal_list)
entry 1344 fs/reiserfs/journal.c struct list_head *entry;
entry 1353 fs/reiserfs/journal.c entry = journal->j_journal_list.next;
entry 1355 fs/reiserfs/journal.c if (entry == &journal->j_journal_list)
entry 1357 fs/reiserfs/journal.c other_jl = JOURNAL_LIST_ENTRY(entry);
entry 1769 fs/reiserfs/journal.c struct list_head *entry;
entry 1796 fs/reiserfs/journal.c entry = jl->j_list.next;
entry 1799 fs/reiserfs/journal.c if (entry == &journal->j_journal_list) {
entry 1802 fs/reiserfs/journal.c jl = JOURNAL_LIST_ENTRY(entry);
entry 3495 fs/reiserfs/journal.c struct list_head *entry;
entry 3500 fs/reiserfs/journal.c entry = journal->j_journal_list.prev;
entry 3501 fs/reiserfs/journal.c jl = JOURNAL_LIST_ENTRY(entry);
entry 3892 fs/reiserfs/journal.c struct list_head *entry;
entry 3896 fs/reiserfs/journal.c entry = journal->j_journal_list.next;
entry 3897 fs/reiserfs/journal.c jl = JOURNAL_LIST_ENTRY(entry);
entry 3936 fs/reiserfs/journal.c struct list_head *entry, *safe;
entry 4217 fs/reiserfs/journal.c list_for_each_safe(entry, safe, &journal->j_journal_list) {
entry 4218 fs/reiserfs/journal.c temp_jl = JOURNAL_LIST_ENTRY(entry);
entry 92 fs/reiserfs/xattr_acl.c reiserfs_acl_entry *entry = (reiserfs_acl_entry *) value;
entry 95 fs/reiserfs/xattr_acl.c acl->a_entries[n].e_tag = le16_to_cpu(entry->e_tag);
entry 96 fs/reiserfs/xattr_acl.c acl->a_entries[n].e_perm = le16_to_cpu(entry->e_perm);
entry 112 fs/reiserfs/xattr_acl.c acl->a_entries[n].e_id = le32_to_cpu(entry->e_id);
entry 147 fs/reiserfs/xattr_acl.c reiserfs_acl_entry *entry = (reiserfs_acl_entry *) e;
entry 148 fs/reiserfs/xattr_acl.c entry->e_tag = cpu_to_le16(acl->a_entries[n].e_tag);
entry 149 fs/reiserfs/xattr_acl.c entry->e_perm = cpu_to_le16(acl->a_entries[n].e_perm);
entry 153 fs/reiserfs/xattr_acl.c entry->e_id = cpu_to_le32(acl->a_entries[n].e_id);
entry 32 fs/select.c struct poll_table_entry * entry;
entry 37 fs/select.c ((unsigned long)((table)->entry+1) > PAGE_SIZE + (unsigned long)(table))
entry 66 fs/select.c remove_wait_queue(entry->wait_address, &entry->wait);
entry 67 fs/select.c fput(entry->filp);
entry 77 fs/select.c struct poll_table_entry * entry;
entry 80 fs/select.c entry = p->entry;
entry 82 fs/select.c entry--;
entry 83 fs/select.c free_poll_entry(entry);
entry 84 fs/select.c } while (entry > p->entries);
entry 110 fs/select.c new_table->entry = new_table->entries;
entry 116 fs/select.c return table->entry++;
entry 123 fs/select.c struct poll_table_entry *entry = poll_get_entry(p);
entry 124 fs/select.c if (!entry)
entry 127 fs/select.c entry->filp = filp;
entry 128 fs/select.c entry->wait_address = wait_address;
entry 129 fs/select.c init_waitqueue_entry(&entry->wait, current);
entry 130 fs/select.c add_wait_queue(wait_address, &entry->wait);
entry 154 fs/smbfs/cache.c entry->f_ino = iunique(inode->i_sb, 2);
entry 155 fs/smbfs/cache.c newino = smb_iget(inode->i_sb, entry);
entry 163 fs/smbfs/cache.c smb_set_inode_attr(newdent->d_inode, entry);
entry 536 fs/smbfs/inode.c INIT_LIST_HEAD(&server->entry);
entry 316 fs/smbfs/proc.c if (entry == NULL)
entry 322 fs/smbfs/proc.c if (IS_ROOT(entry) && !name) {
entry 334 fs/smbfs/proc.c dget(entry);
entry 335 fs/smbfs/proc.c spin_lock(&entry->d_lock);
entry 336 fs/smbfs/proc.c while (!IS_ROOT(entry)) {
entry 340 fs/smbfs/proc.c spin_unlock(&entry->d_lock);
entry 341 fs/smbfs/proc.c dput(entry);
entry 346 fs/smbfs/proc.c entry->d_name.name, entry->d_name.len,
entry 349 fs/smbfs/proc.c spin_unlock(&entry->d_lock);
entry 350 fs/smbfs/proc.c dput(entry);
entry 363 fs/smbfs/proc.c parent = entry->d_parent;
entry 365 fs/smbfs/proc.c spin_unlock(&entry->d_lock);
entry 366 fs/smbfs/proc.c dput(entry);
entry 367 fs/smbfs/proc.c entry = parent;
entry 368 fs/smbfs/proc.c spin_lock(&entry->d_lock);
entry 370 fs/smbfs/proc.c spin_unlock(&entry->d_lock);
entry 371 fs/smbfs/proc.c dput(entry);
entry 438 fs/smbfs/proc.c res = smb_encode_path(server, s, maxlen-1, entry, name);
entry 1909 fs/smbfs/proc.c str_upper(entry->name, len);
entry 1912 fs/smbfs/proc.c str_lower(entry->name, len);
entry 101 fs/smbfs/smbiod.c list_add(&server->entry, &smb_servers);
entry 115 fs/smbfs/smbiod.c list_del_init(&server->entry);
entry 327 fs/smbfs/smbiod.c server = list_entry(pos, struct smb_sb_info, entry);
entry 1181 fs/splice.c struct iovec entry;
entry 1187 fs/splice.c if (copy_from_user(&entry, iov, sizeof(entry)))
entry 1190 fs/splice.c base = entry.iov_base;
entry 1191 fs/splice.c len = entry.iov_len;
entry 137 fs/udf/partition.c struct sparingEntry *entry = &st->mapEntry[i];
entry 138 fs/udf/partition.c u32 origLoc = le32_to_cpu(entry->origLocation);
entry 142 fs/udf/partition.c return le32_to_cpu(entry->mappedLocation) +
entry 185 fs/udf/partition.c struct sparingEntry *entry = &st->mapEntry[k];
entry 186 fs/udf/partition.c u32 origLoc = le32_to_cpu(entry->origLocation);
entry 197 fs/udf/partition.c entry->origLocation =
entry 207 fs/udf/partition.c entry->mappedLocation) +
entry 214 fs/udf/partition.c entry->mappedLocation) +
entry 224 fs/udf/partition.c struct sparingEntry *entry = &st->mapEntry[l];
entry 225 fs/udf/partition.c u32 origLoc = le32_to_cpu(entry->origLocation);
entry 21 fs/xattr_acl.c posix_acl_xattr_entry *entry = (posix_acl_xattr_entry *)(header+1), *end;
entry 44 fs/xattr_acl.c for (end = entry + count; entry != end; acl_e++, entry++) {
entry 45 fs/xattr_acl.c acl_e->e_tag = le16_to_cpu(entry->e_tag);
entry 46 fs/xattr_acl.c acl_e->e_perm = le16_to_cpu(entry->e_perm);
entry 58 fs/xattr_acl.c acl_e->e_id = le32_to_cpu(entry->e_id);
entry 488 fs/xfs/xfs_acl.c xfs_acl_entry_t *entry, *e;
entry 500 fs/xfs/xfs_acl.c entry = &aclp->acl_entry[i];
entry 501 fs/xfs/xfs_acl.c switch (entry->ae_tag) {
entry 518 fs/xfs/xfs_acl.c if (e->ae_id == entry->ae_id &&
entry 519 fs/xfs/xfs_acl.c e->ae_tag == entry->ae_tag)
entry 725 fs/xfs/xfs_attr_leaf.c xfs_attr_leaf_entry_t *entry;
entry 732 fs/xfs/xfs_attr_leaf.c entry = &leaf->entries[0];
entry 734 fs/xfs/xfs_attr_leaf.c for (i = 0; i < be16_to_cpu(leaf->hdr.count); entry++, i++) {
entry 735 fs/xfs/xfs_attr_leaf.c if (entry->flags & XFS_ATTR_INCOMPLETE)
entry 737 fs/xfs/xfs_attr_leaf.c if (!(entry->flags & XFS_ATTR_LOCAL))
entry 762 fs/xfs/xfs_attr_leaf.c xfs_attr_leaf_entry_t *entry;
entry 819 fs/xfs/xfs_attr_leaf.c entry = &leaf->entries[0];
entry 820 fs/xfs/xfs_attr_leaf.c for (i = 0; i < be16_to_cpu(leaf->hdr.count); entry++, i++) {
entry 821 fs/xfs/xfs_attr_leaf.c if (entry->flags & XFS_ATTR_INCOMPLETE)
entry 823 fs/xfs/xfs_attr_leaf.c if (!entry->nameidx)
entry 825 fs/xfs/xfs_attr_leaf.c ASSERT(entry->flags & XFS_ATTR_LOCAL);
entry 831 fs/xfs/xfs_attr_leaf.c nargs.hashval = be32_to_cpu(entry->hashval);
entry 832 fs/xfs/xfs_attr_leaf.c nargs.flags = XFS_ATTR_NSP_ONDISK_TO_ARGS(entry->flags);
entry 1074 fs/xfs/xfs_attr_leaf.c xfs_attr_leaf_entry_t *entry;
entry 1090 fs/xfs/xfs_attr_leaf.c entry = &leaf->entries[args->index];
entry 1094 fs/xfs/xfs_attr_leaf.c memmove((char *)(entry+1), (char *)entry, tmp);
entry 1096 fs/xfs/xfs_attr_leaf.c XFS_DA_LOGRANGE(leaf, entry, tmp + sizeof(*entry)));
entry 1115 fs/xfs/xfs_attr_leaf.c entry->nameidx = cpu_to_be16(be16_to_cpu(map->base) +
entry 1117 fs/xfs/xfs_attr_leaf.c entry->hashval = cpu_to_be32(args->hashval);
entry 1118 fs/xfs/xfs_attr_leaf.c entry->flags = tmp ? XFS_ATTR_LOCAL : 0;
entry 1119 fs/xfs/xfs_attr_leaf.c entry->flags |= XFS_ATTR_NSP_ARGS_TO_ONDISK(args->flags);
entry 1121 fs/xfs/xfs_attr_leaf.c entry->flags |= XFS_ATTR_INCOMPLETE;
entry 1128 fs/xfs/xfs_attr_leaf.c XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));
entry 1130 fs/xfs/xfs_attr_leaf.c (be32_to_cpu(entry->hashval) >= be32_to_cpu((entry-1)->hashval)));
entry 1132 fs/xfs/xfs_attr_leaf.c (be32_to_cpu(entry->hashval) <= be32_to_cpu((entry+1)->hashval)));
entry 1143 fs/xfs/xfs_attr_leaf.c if (entry->flags & XFS_ATTR_LOCAL) {
entry 1154 fs/xfs/xfs_attr_leaf.c entry->flags |= XFS_ATTR_INCOMPLETE;
entry 1168 fs/xfs/xfs_attr_leaf.c if (be16_to_cpu(entry->nameidx) < be16_to_cpu(hdr->firstused)) {
entry 1170 fs/xfs/xfs_attr_leaf.c hdr->firstused = entry->nameidx;
entry 1173 fs/xfs/xfs_attr_leaf.c ((be16_to_cpu(hdr->count) * sizeof(*entry)) + sizeof(*hdr)));
entry 1426 fs/xfs/xfs_attr_leaf.c xfs_attr_leaf_entry_t *entry;
entry 1445 fs/xfs/xfs_attr_leaf.c half = (max+1) * sizeof(*entry);
entry 1454 fs/xfs/xfs_attr_leaf.c entry = &leaf1->entries[0];
entry 1455 fs/xfs/xfs_attr_leaf.c for (count = index = 0; count < max; entry++, index++, count++) {
entry 1462 fs/xfs/xfs_attr_leaf.c tmp = totallen + sizeof(*entry) +
entry 1479 fs/xfs/xfs_attr_leaf.c entry = &leaf1->entries[0];
entry 1486 fs/xfs/xfs_attr_leaf.c tmp = totallen + sizeof(*entry) + xfs_attr_leaf_entsize(leaf1,
entry 1499 fs/xfs/xfs_attr_leaf.c totallen -= count * sizeof(*entry);
entry 1501 fs/xfs/xfs_attr_leaf.c totallen -= sizeof(*entry) +
entry 1656 fs/xfs/xfs_attr_leaf.c xfs_attr_leaf_entry_t *entry;
entry 1670 fs/xfs/xfs_attr_leaf.c ((be16_to_cpu(hdr->count) * sizeof(*entry)) + sizeof(*hdr)));
entry 1671 fs/xfs/xfs_attr_leaf.c entry = &leaf->entries[args->index];
entry 1672 fs/xfs/xfs_attr_leaf.c ASSERT(be16_to_cpu(entry->nameidx) >= be16_to_cpu(hdr->firstused));
entry 1673 fs/xfs/xfs_attr_leaf.c ASSERT(be16_to_cpu(entry->nameidx) < XFS_LBSIZE(mp));
entry 1698 fs/xfs/xfs_attr_leaf.c == be16_to_cpu(entry->nameidx)) {
entry 1701 fs/xfs/xfs_attr_leaf.c == (be16_to_cpu(entry->nameidx) + entsize)) {
entry 1727 fs/xfs/xfs_attr_leaf.c map->base = entry->nameidx;
entry 1736 fs/xfs/xfs_attr_leaf.c map->base = cpu_to_be16(be16_to_cpu(entry->nameidx));
entry 1744 fs/xfs/xfs_attr_leaf.c if (be16_to_cpu(entry->nameidx) == be16_to_cpu(hdr->firstused))
entry 1760 fs/xfs/xfs_attr_leaf.c memmove((char *)entry, (char *)(entry+1), tmp);
entry 1763 fs/xfs/xfs_attr_leaf.c XFS_DA_LOGRANGE(leaf, entry, tmp + sizeof(*entry)));
entry 1764 fs/xfs/xfs_attr_leaf.c entry = &leaf->entries[be16_to_cpu(hdr->count)];
entry 1765 fs/xfs/xfs_attr_leaf.c memset((char *)entry, 0, sizeof(xfs_attr_leaf_entry_t));
entry 1775 fs/xfs/xfs_attr_leaf.c entry = &leaf->entries[0];
entry 1776 fs/xfs/xfs_attr_leaf.c for (i = be16_to_cpu(hdr->count)-1; i >= 0; entry++, i--) {
entry 1777 fs/xfs/xfs_attr_leaf.c ASSERT(be16_to_cpu(entry->nameidx) >=
entry 1779 fs/xfs/xfs_attr_leaf.c ASSERT(be16_to_cpu(entry->nameidx) < XFS_LBSIZE(mp));
entry 1781 fs/xfs/xfs_attr_leaf.c if (be16_to_cpu(entry->nameidx) < tmp)
entry 1782 fs/xfs/xfs_attr_leaf.c tmp = be16_to_cpu(entry->nameidx);
entry 1920 fs/xfs/xfs_attr_leaf.c xfs_attr_leaf_entry_t *entry;
entry 1936 fs/xfs/xfs_attr_leaf.c for (entry = &leaf->entries[probe]; span > 4;
entry 1937 fs/xfs/xfs_attr_leaf.c entry = &leaf->entries[probe]) {
entry 1939 fs/xfs/xfs_attr_leaf.c if (be32_to_cpu(entry->hashval) < hashval)
entry 1941 fs/xfs/xfs_attr_leaf.c else if (be32_to_cpu(entry->hashval) > hashval)
entry 1949 fs/xfs/xfs_attr_leaf.c ASSERT((span <= 4) || (be32_to_cpu(entry->hashval) == hashval));
entry 1955 fs/xfs/xfs_attr_leaf.c while ((probe > 0) && (be32_to_cpu(entry->hashval) >= hashval)) {
entry 1956 fs/xfs/xfs_attr_leaf.c entry--;
entry 1960 fs/xfs/xfs_attr_leaf.c (be32_to_cpu(entry->hashval) < hashval)) {
entry 1961 fs/xfs/xfs_attr_leaf.c entry++;
entry 1965 fs/xfs/xfs_attr_leaf.c (be32_to_cpu(entry->hashval) != hashval)) {
entry 1974 fs/xfs/xfs_attr_leaf.c (be32_to_cpu(entry->hashval) == hashval);
entry 1975 fs/xfs/xfs_attr_leaf.c entry++, probe++) {
entry 1984 fs/xfs/xfs_attr_leaf.c (entry->flags & XFS_ATTR_INCOMPLETE)) {
entry 1987 fs/xfs/xfs_attr_leaf.c if (entry->flags & XFS_ATTR_LOCAL) {
entry 1993 fs/xfs/xfs_attr_leaf.c if (!xfs_attr_namesp_match(args->flags, entry->flags))
entry 2004 fs/xfs/xfs_attr_leaf.c if (!xfs_attr_namesp_match(args->flags, entry->flags))
entry 2026 fs/xfs/xfs_attr_leaf.c xfs_attr_leaf_entry_t *entry;
entry 2036 fs/xfs/xfs_attr_leaf.c entry = &leaf->entries[args->index];
entry 2037 fs/xfs/xfs_attr_leaf.c if (entry->flags & XFS_ATTR_LOCAL) {
entry 2322 fs/xfs/xfs_attr_leaf.c xfs_attr_leaf_entry_t *entry;
entry 2336 fs/xfs/xfs_attr_leaf.c entry = &leaf->entries[0];
entry 2337 fs/xfs/xfs_attr_leaf.c for (i = 0; i < be16_to_cpu(leaf->hdr.count); entry++, i++) {
entry 2338 fs/xfs/xfs_attr_leaf.c if (be32_to_cpu(entry->hashval) == cursor->hashval) {
entry 2344 fs/xfs/xfs_attr_leaf.c } else if (be32_to_cpu(entry->hashval) >
entry 2355 fs/xfs/xfs_attr_leaf.c entry = &leaf->entries[0];
entry 2364 fs/xfs/xfs_attr_leaf.c for ( ; (i < be16_to_cpu(leaf->hdr.count)); entry++, i++) {
entry 2365 fs/xfs/xfs_attr_leaf.c if (be32_to_cpu(entry->hashval) != cursor->hashval) {
entry 2366 fs/xfs/xfs_attr_leaf.c cursor->hashval = be32_to_cpu(entry->hashval);
entry 2370 fs/xfs/xfs_attr_leaf.c if (entry->flags & XFS_ATTR_INCOMPLETE)
entry 2373 fs/xfs/xfs_attr_leaf.c if (entry->flags & XFS_ATTR_LOCAL) {
entry 2378 fs/xfs/xfs_attr_leaf.c entry->flags,
entry 2405 fs/xfs/xfs_attr_leaf.c entry->flags,
entry 2413 fs/xfs/xfs_attr_leaf.c entry->flags,
entry 2442 fs/xfs/xfs_attr_leaf.c xfs_attr_leaf_entry_t *entry;
entry 2466 fs/xfs/xfs_attr_leaf.c entry = &leaf->entries[ args->index ];
entry 2467 fs/xfs/xfs_attr_leaf.c ASSERT(entry->flags & XFS_ATTR_INCOMPLETE);
entry 2470 fs/xfs/xfs_attr_leaf.c if (entry->flags & XFS_ATTR_LOCAL) {
entry 2479 fs/xfs/xfs_attr_leaf.c ASSERT(be32_to_cpu(entry->hashval) == args->hashval);
entry 2484 fs/xfs/xfs_attr_leaf.c entry->flags &= ~XFS_ATTR_INCOMPLETE;
entry 2486 fs/xfs/xfs_attr_leaf.c XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));
entry 2489 fs/xfs/xfs_attr_leaf.c ASSERT((entry->flags & XFS_ATTR_LOCAL) == 0);
entry 2511 fs/xfs/xfs_attr_leaf.c xfs_attr_leaf_entry_t *entry;
entry 2530 fs/xfs/xfs_attr_leaf.c entry = &leaf->entries[ args->index ];
entry 2532 fs/xfs/xfs_attr_leaf.c ASSERT((entry->flags & XFS_ATTR_INCOMPLETE) == 0);
entry 2533 fs/xfs/xfs_attr_leaf.c entry->flags |= XFS_ATTR_INCOMPLETE;
entry 2535 fs/xfs/xfs_attr_leaf.c XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));
entry 2536 fs/xfs/xfs_attr_leaf.c if ((entry->flags & XFS_ATTR_LOCAL) == 0) {
entry 2842 fs/xfs/xfs_attr_leaf.c xfs_attr_leaf_entry_t *entry;
entry 2854 fs/xfs/xfs_attr_leaf.c entry = &leaf->entries[0];
entry 2855 fs/xfs/xfs_attr_leaf.c for (i = 0; i < be16_to_cpu(leaf->hdr.count); entry++, i++) {
entry 2856 fs/xfs/xfs_attr_leaf.c if (be16_to_cpu(entry->nameidx) &&
entry 2857 fs/xfs/xfs_attr_leaf.c ((entry->flags & XFS_ATTR_LOCAL) == 0)) {
entry 2882 fs/xfs/xfs_attr_leaf.c entry = &leaf->entries[0];
entry 2883 fs/xfs/xfs_attr_leaf.c for (i = 0; i < be16_to_cpu(leaf->hdr.count); entry++, i++) {
entry 2884 fs/xfs/xfs_attr_leaf.c if (be16_to_cpu(entry->nameidx) &&
entry 2885 fs/xfs/xfs_attr_leaf.c ((entry->flags & XFS_ATTR_LOCAL) == 0)) {
entry 81 fs/xfs/xfs_da_btree.h (((bno) << (mp)->m_dircook_elog) | (entry))
entry 83 fs/xfs/xfs_da_btree.h (((xfs_off_t)XFS_DA_MAKE_BNOENTRY(mp, bno, entry) << 32) | (hash))
entry 107 fs/xfs/xfs_dir2_data.h xfs_dir2_data_entry_t entry;
entry 178 include/acpi/acpi_bus.h struct proc_dir_entry *entry;
entry 181 include/acpi/acpi_bus.h #define acpi_device_dir(d) ((d)->dir.entry)
entry 1080 include/acpi/actbl1.h u8 entry[1]; /* Real size = localities^2 */
entry 424 include/asm-frv/pgtable.h #define mk_pte_huge(entry) ((entry).pte_low |= _PAGE_PRESENT | _PAGE_PSE)
entry 33 include/asm-m32r/mmu_context.h #define set_tlb_tag(entry, tag) (*entry = (tag & PAGE_MASK)|get_asid())
entry 34 include/asm-m32r/mmu_context.h #define set_tlb_data(entry, data) (*entry = (data | _PAGE_PRESENT))
entry 87 include/asm-m68k/sun3mmu.h register unsigned long entry;
entry 94 include/asm-m68k/sun3mmu.h entry = c;
entry 96 include/asm-m68k/sun3mmu.h return entry;
entry 106 include/asm-m68k/sun3mmu.h SET_CONTROL_BYTE (AC_SEGMAP | (addr & SUN3_CONTROL_MASK), entry);
entry 115 include/asm-m68k/sun3mmu.h register unsigned long entry;
entry 120 include/asm-m68k/sun3mmu.h GET_CONTROL_WORD (AC_PAGEMAP | (addr & SUN3_CONTROL_MASK), entry);
entry 123 include/asm-m68k/sun3mmu.h return entry;
entry 133 include/asm-m68k/sun3mmu.h SET_CONTROL_WORD (AC_PAGEMAP | (addr & SUN3_CONTROL_MASK), entry);
entry 386 include/asm-mn10300/pgtable.h ((entry).pte |= _PAGE_PRESENT | _PAGE_PSE | _PAGE_VALID)
entry 100 include/asm-x86/desc.h native_write_ldt_entry(dt, entry, desc)
entry 102 include/asm-x86/desc.h native_write_gdt_entry(dt, entry, desc, type)
entry 104 include/asm-x86/desc.h native_write_idt_entry(dt, entry, g)
entry 118 include/asm-x86/desc.h memcpy(&idt[entry], gate, sizeof(*gate));
entry 124 include/asm-x86/desc.h memcpy(&ldt[entry], desc, 8);
entry 142 include/asm-x86/desc.h memcpy(&gdt[entry], desc, size);
entry 191 include/asm-x86/desc.h write_gdt_entry(d, entry, &tss, DESC_TSS);
entry 59 include/asm-x86/mce.h struct mce entry[MCE_LOG_LEN];
entry 891 include/asm-x86/paravirt.h PVOP_VCALL3(pv_cpu_ops.write_ldt_entry, dt, entry, desc);
entry 897 include/asm-x86/paravirt.h PVOP_VCALL4(pv_cpu_ops.write_gdt_entry, dt, entry, desc, type);
entry 902 include/asm-x86/paravirt.h PVOP_VCALL3(pv_cpu_ops.write_idt_entry, dt, entry, g);
entry 344 include/asm-xtensa/pgtable.h #define __swp_type(entry) (((entry).val >> 6) & 0x1f)
entry 345 include/asm-xtensa/pgtable.h #define __swp_offset(entry) ((entry).val >> 11)
entry 78 include/asm-xtensa/tlbflush.h __asm__ __volatile__ ("iitlb %0\n" : : "a" (entry) );
entry 84 include/asm-xtensa/tlbflush.h __asm__ __volatile__ ("idtlb %0\n" : : "a" (entry) );
entry 115 include/asm-xtensa/tlbflush.h : : "r" (way), "r" (entry) );
entry 121 include/asm-xtensa/tlbflush.h : : "r" (way), "r" (entry) );
entry 85 include/drm/drm_os_linux.h DECLARE_WAITQUEUE(entry, current); \
entry 87 include/drm/drm_os_linux.h add_wait_queue(&(queue), &entry); \
entry 104 include/drm/drm_os_linux.h remove_wait_queue(&(queue), &entry); \
entry 335 include/linux/atmdev.h struct list_head entry; /* next address */
entry 915 include/linux/blkdev.h #define blkdev_entry_to_request(entry) list_entry((entry), struct request, queuelist)
entry 136 include/linux/coff.h char entry[4]; /* entry pt. */
entry 267 include/linux/dcache.h d_instantiate(entry, inode);
entry 268 include/linux/dcache.h d_rehash(entry);
entry 283 include/linux/dcache.h res = d_instantiate_unique(entry, inode);
entry 284 include/linux/dcache.h d_rehash(res != NULL ? res : entry);
entry 33 include/linux/flat.h unsigned long entry; /* Offset of first executable instruction
entry 25 include/linux/fsnotify.h inotify_d_instantiate(entry, inode);
entry 34 include/linux/fsnotify.h inotify_d_move(entry);
entry 79 include/linux/kexec.h kimage_entry_t *entry;
entry 61 include/linux/kobject.h struct list_head entry;
entry 119 include/linux/kprobes.h void *entry; /* probe handling code to jump to */
entry 105 include/linux/list.h __list_del(entry->prev, entry->next);
entry 106 include/linux/list.h entry->next = LIST_POISON1;
entry 107 include/linux/list.h entry->prev = LIST_POISON2;
entry 142 include/linux/list.h __list_del(entry->prev, entry->next);
entry 143 include/linux/list.h INIT_LIST_HEAD(entry);
entry 220 include/linux/list.h struct list_head *new_first = entry->next;
entry 223 include/linux/list.h list->prev = entry;
entry 224 include/linux/list.h entry->next = list;
entry 249 include/linux/list.h (head->next != entry && head != entry))
entry 251 include/linux/list.h if (entry == head)
entry 254 include/linux/list.h __list_cut_position(list, head, entry);
entry 176 include/linux/lockdep.h struct list_head entry;
entry 189 include/linux/lockdep.h struct list_head entry;
entry 368 include/linux/msdos_fs.h int entry;
entry 381 include/linux/msdos_fs.h fatent->entry = 0;
entry 388 include/linux/msdos_fs.h fatent->entry = entry;
entry 252 include/linux/netfilter.h struct nf_queue_entry *entry);
entry 254 include/linux/netfilter.h const struct nf_queue_entry *entry);
entry 229 include/linux/netfilter_arp/arp_tables.h struct arpt_entry entry;
entry 241 include/linux/netfilter_arp/arp_tables.h struct arpt_entry entry;
entry 253 include/linux/netfilter_arp/arp_tables.h .entry = ARPT_ENTRY_INIT(sizeof(struct arpt_standard)), \
entry 261 include/linux/netfilter_arp/arp_tables.h .entry = ARPT_ENTRY_INIT(sizeof(struct arpt_error)), \
entry 217 include/linux/netfilter_bridge/ebtables.h bool (*checkentry)(const char *table, const void *entry,
entry 235 include/linux/netfilter_bridge/ebtables.h bool (*checkentry)(const char *table, const void *entry,
entry 254 include/linux/netfilter_bridge/ebtables.h bool (*checkentry)(const char *table, const void *entry,
entry 255 include/linux/netfilter_ipv4/ip_tables.h struct ipt_entry entry;
entry 267 include/linux/netfilter_ipv4/ip_tables.h struct ipt_entry entry;
entry 279 include/linux/netfilter_ipv4/ip_tables.h .entry = IPT_ENTRY_INIT(sizeof(struct ipt_standard)), \
entry 287 include/linux/netfilter_ipv4/ip_tables.h .entry = IPT_ENTRY_INIT(sizeof(struct ipt_error)), \
entry 116 include/linux/netfilter_ipv6/ip6_tables.h struct ip6t_entry entry;
entry 128 include/linux/netfilter_ipv6/ip6_tables.h struct ip6t_entry entry;
entry 140 include/linux/netfilter_ipv6/ip6_tables.h .entry = IP6T_ENTRY_INIT(sizeof(struct ip6t_standard)), \
entry 148 include/linux/netfilter_ipv6/ip6_tables.h .entry = IP6T_ENTRY_INIT(sizeof(struct ip6t_error)), \
entry 727 include/linux/pci.h u16 entry; /* driver uses to specify entry, OS writes */
entry 350 include/linux/pm.h struct list_head entry;
entry 14 include/linux/posix-timers.h struct list_head entry;
entry 96 include/linux/rculist.h __list_del(entry->prev, entry->next);
entry 97 include/linux/rculist.h entry->prev = LIST_POISON2;
entry 38 include/linux/smb_fs_sb.h struct list_head entry;
entry 344 include/linux/swap.h swp_entry_t entry;
entry 345 include/linux/swap.h entry.val = 0;
entry 346 include/linux/swap.h return entry;
entry 33 include/linux/swapops.h return (entry.val >> SWP_TYPE_SHIFT(entry));
entry 42 include/linux/swapops.h return entry.val & SWP_OFFSET_MASK(entry);
entry 74 include/linux/swapops.h arch_entry = __swp_entry(swp_type(entry), swp_offset(entry));
entry 89 include/linux/swapops.h return unlikely(swp_type(entry) == SWP_MIGRATION_READ ||
entry 90 include/linux/swapops.h swp_type(entry) == SWP_MIGRATION_WRITE);
entry 95 include/linux/swapops.h return unlikely(swp_type(entry) == SWP_MIGRATION_WRITE);
entry 100 include/linux/swapops.h struct page *p = pfn_to_page(swp_offset(entry));
entry 111 include/linux/swapops.h *entry = swp_entry(SWP_MIGRATION_READ, swp_offset(*entry));
entry 72 include/linux/sysdev.h struct list_head entry;
entry 12 include/linux/timer.h struct list_head entry;
entry 29 include/linux/timer.h .entry = { .prev = TIMER_ENTRY_STATIC }, \
entry 84 include/linux/timer.h return timer->entry.next != NULL;
entry 1228 include/linux/videodev2.h struct v4l2_enc_idx_entry entry[V4L2_ENC_IDX_ENTRIES];
entry 30 include/linux/workqueue.h struct list_head entry;
entry 62 include/linux/workqueue.h .entry = { &(n).entry, &(n).entry }, \
entry 103 include/linux/workqueue.h INIT_LIST_HEAD(&(_work)->entry); \
entry 110 include/linux/workqueue.h INIT_LIST_HEAD(&(_work)->entry); \
entry 24 include/net/atmclip.h struct atmarp_entry *entry; /* ATMARP table entry, NULL if IP addr.
entry 22 include/net/netfilter/nf_queue.h int (*outfn)(struct nf_queue_entry *entry,
entry 36 include/net/snmp.h int entry;
entry 41 include/net/snmp.h .entry = _entry, \
entry 46 include/net/snmp.h .entry = 0, \
entry 43 include/sound/info.h void (*read) (struct snd_info_entry *entry, struct snd_info_buffer *buffer);
entry 44 include/sound/info.h void (*write) (struct snd_info_entry *entry, struct snd_info_buffer *buffer);
entry 48 include/sound/info.h int (*open) (struct snd_info_entry *entry,
entry 50 include/sound/info.h int (*release) (struct snd_info_entry * entry,
entry 52 include/sound/info.h long (*read) (struct snd_info_entry *entry, void *file_private_data,
entry 55 include/sound/info.h long (*write) (struct snd_info_entry *entry, void *file_private_data,
entry 58 include/sound/info.h long long (*llseek) (struct snd_info_entry *entry, void *file_private_data,
entry 60 include/sound/info.h unsigned int (*poll) (struct snd_info_entry *entry, void *file_private_data,
entry 62 include/sound/info.h int (*ioctl) (struct snd_info_entry *entry, void *file_private_data,
entry 64 include/sound/info.h int (*mmap) (struct snd_info_entry *entry, void *file_private_data,
entry 82 include/sound/info.h void (*private_free)(struct snd_info_entry *entry);
entry 138 include/sound/info.h entry->private_data = private_data;
entry 139 include/sound/info.h entry->c.text.read = read;
entry 400 kernel/audit_tree.c struct audit_entry *entry;
entry 404 kernel/audit_tree.c entry = container_of(rule, struct audit_entry, rule);
entry 420 kernel/audit_tree.c list_del_rcu(&entry->list);
entry 421 kernel/audit_tree.c call_rcu(&entry->rcu, audit_free_rule_rcu);
entry 198 kernel/auditfilter.c struct audit_entry *entry;
entry 201 kernel/auditfilter.c entry = kzalloc(sizeof(*entry), GFP_KERNEL);
entry 202 kernel/auditfilter.c if (unlikely(!entry))
entry 207 kernel/auditfilter.c kfree(entry);
entry 210 kernel/auditfilter.c entry->rule.fields = fields;
entry 212 kernel/auditfilter.c return entry;
entry 326 kernel/auditfilter.c struct audit_field *arch = entry->rule.arch_f;
entry 332 kernel/auditfilter.c entry->rule.mask) &&
entry 334 kernel/auditfilter.c entry->rule.mask));
entry 340 kernel/auditfilter.c entry->rule.mask));
entry 343 kernel/auditfilter.c entry->rule.mask));
entry 354 kernel/auditfilter.c struct audit_entry *entry;
entry 381 kernel/auditfilter.c entry = audit_init_entry(rule->field_count);
entry 382 kernel/auditfilter.c if (!entry)
entry 385 kernel/auditfilter.c entry->rule.flags = rule->flags & AUDIT_FILTER_PREPEND;
entry 386 kernel/auditfilter.c entry->rule.listnr = listnr;
entry 387 kernel/auditfilter.c entry->rule.action = rule->action;
entry 388 kernel/auditfilter.c entry->rule.field_count = rule->field_count;
entry 391 kernel/auditfilter.c entry->rule.mask[i] = rule->mask[i];
entry 395 kernel/auditfilter.c __u32 *p = &entry->rule.mask[AUDIT_WORD(bit)];
entry 405 kernel/auditfilter.c entry->rule.mask[j] |= class[j];
entry 409 kernel/auditfilter.c return entry;
entry 419 kernel/auditfilter.c struct audit_entry *entry;
entry 424 kernel/auditfilter.c entry = audit_to_entry_common(rule);
entry 425 kernel/auditfilter.c if (IS_ERR(entry))
entry 429 kernel/auditfilter.c struct audit_field *f = &entry->rule.fields[i];
entry 475 kernel/auditfilter.c entry->rule.arch_f = f;
entry 486 kernel/auditfilter.c err = audit_to_inode(&entry->rule, f);
entry 492 kernel/auditfilter.c entry->rule.vers_ops = (f->op & AUDIT_OPERATORS) ? 2 : 1;
entry 506 kernel/auditfilter.c ino_f = entry->rule.inode_f;
entry 510 kernel/auditfilter.c entry->rule.inode_f = NULL;
entry 520 kernel/auditfilter.c return entry;
entry 523 kernel/auditfilter.c audit_free_rule(entry);
entry 532 kernel/auditfilter.c struct audit_entry *entry;
entry 539 kernel/auditfilter.c entry = audit_to_entry_common((struct audit_rule *)data);
entry 540 kernel/auditfilter.c if (IS_ERR(entry))
entry 544 kernel/auditfilter.c entry->rule.vers_ops = 2;
entry 546 kernel/auditfilter.c struct audit_field *f = &entry->rule.fields[i];
entry 582 kernel/auditfilter.c entry->rule.arch_f = f;
entry 597 kernel/auditfilter.c entry->rule.buflen += f->val;
entry 618 kernel/auditfilter.c entry->rule.buflen += f->val;
entry 620 kernel/auditfilter.c err = audit_to_watch(&entry->rule, str, f->val, f->op);
entry 630 kernel/auditfilter.c entry->rule.buflen += f->val;
entry 632 kernel/auditfilter.c err = audit_make_tree(&entry->rule, str, f->op);
entry 638 kernel/auditfilter.c err = audit_to_inode(&entry->rule, f);
entry 644 kernel/auditfilter.c if (entry->rule.filterkey || f->val > AUDIT_MAX_KEY_LEN)
entry 649 kernel/auditfilter.c entry->rule.buflen += f->val;
entry 650 kernel/auditfilter.c entry->rule.filterkey = str;
entry 665 kernel/auditfilter.c ino_f = entry->rule.inode_f;
entry 669 kernel/auditfilter.c entry->rule.inode_f = NULL;
entry 679 kernel/auditfilter.c return entry;
entry 682 kernel/auditfilter.c audit_free_rule(entry);
entry 906 kernel/auditfilter.c struct audit_entry *entry;
entry 911 kernel/auditfilter.c entry = audit_init_entry(fcount);
entry 912 kernel/auditfilter.c if (unlikely(!entry))
entry 915 kernel/auditfilter.c new = &entry->rule;
entry 961 kernel/auditfilter.c audit_free_rule(entry);
entry 971 kernel/auditfilter.c return entry;
entry 1110 kernel/auditfilter.c if (entry->rule.watch) {
entry 1115 kernel/auditfilter.c if (!audit_compare_rule(&entry->rule, &e->rule)) {
entry 1124 kernel/auditfilter.c if (!audit_compare_rule(&entry->rule, &e->rule)) {
entry 1266 kernel/auditfilter.c struct audit_field *inode_f = entry->rule.inode_f;
entry 1267 kernel/auditfilter.c struct audit_watch *watch = entry->rule.watch;
entry 1268 kernel/auditfilter.c struct audit_tree *tree = entry->rule.tree;
entry 1275 kernel/auditfilter.c if (entry->rule.listnr == AUDIT_FILTER_USER ||
entry 1276 kernel/auditfilter.c entry->rule.listnr == AUDIT_FILTER_TYPE)
entry 1286 kernel/auditfilter.c e = audit_find_rule(entry, list);
entry 1306 kernel/auditfilter.c err = audit_add_watch(&entry->rule, ndp, ndw);
entry 1315 kernel/auditfilter.c err = audit_add_tree_rule(&entry->rule);
entry 1322 kernel/auditfilter.c if (entry->rule.flags & AUDIT_FILTER_PREPEND) {
entry 1323 kernel/auditfilter.c list_add_rcu(&entry->list, list);
entry 1324 kernel/auditfilter.c entry->rule.flags &= ~AUDIT_FILTER_PREPEND;
entry 1326 kernel/auditfilter.c list_add_tail_rcu(&entry->list, list);
entry 1332 kernel/auditfilter.c if (!audit_match_signal(entry))
entry 1352 kernel/auditfilter.c struct audit_field *inode_f = entry->rule.inode_f;
entry 1353 kernel/auditfilter.c struct audit_watch *watch, *tmp_watch = entry->rule.watch;
entry 1354 kernel/auditfilter.c struct audit_tree *tree = entry->rule.tree;
entry 1361 kernel/auditfilter.c if (entry->rule.listnr == AUDIT_FILTER_USER ||
entry 1362 kernel/auditfilter.c entry->rule.listnr == AUDIT_FILTER_TYPE)
entry 1372 kernel/auditfilter.c e = audit_find_rule(entry, list);
entry 1409 kernel/auditfilter.c if (!audit_match_signal(entry))
entry 1431 kernel/auditfilter.c struct audit_entry *entry;
entry 1437 kernel/auditfilter.c list_for_each_entry(entry, &audit_filter_list[i], list) {
entry 1440 kernel/auditfilter.c rule = audit_krule_to_rule(&entry->rule);
entry 1451 kernel/auditfilter.c list_for_each_entry(entry, &audit_inode_hash[i], list) {
entry 1454 kernel/auditfilter.c rule = audit_krule_to_rule(&entry->rule);
entry 1562 kernel/auditfilter.c struct audit_entry *entry;
entry 1596 kernel/auditfilter.c entry = audit_rule_to_entry(data);
entry 1598 kernel/auditfilter.c entry = audit_data_to_entry(data, datasz);
entry 1599 kernel/auditfilter.c if (IS_ERR(entry))
entry 1600 kernel/auditfilter.c return PTR_ERR(entry);
entry 1602 kernel/auditfilter.c err = audit_add_rule(entry,
entry 1603 kernel/auditfilter.c &audit_filter_list[entry->rule.listnr]);
entry 1605 kernel/auditfilter.c &entry->rule, !err);
entry 1608 kernel/auditfilter.c audit_free_rule(entry);
entry 1613 kernel/auditfilter.c entry = audit_rule_to_entry(data);
entry 1615 kernel/auditfilter.c entry = audit_data_to_entry(data, datasz);
entry 1616 kernel/auditfilter.c if (IS_ERR(entry))
entry 1617 kernel/auditfilter.c return PTR_ERR(entry);
entry 1619 kernel/auditfilter.c err = audit_del_rule(entry,
entry 1620 kernel/auditfilter.c &audit_filter_list[entry->rule.listnr]);
entry 1622 kernel/auditfilter.c &entry->rule, !err);
entry 1624 kernel/auditfilter.c audit_free_rule(entry);
entry 1784 kernel/auditfilter.c struct audit_entry *entry, *n, *nentry;
entry 1793 kernel/auditfilter.c list_for_each_entry_safe(entry, n, &audit_filter_list[i], list) {
entry 1794 kernel/auditfilter.c if (!security_audit_rule_known(&entry->rule))
entry 1797 kernel/auditfilter.c watch = entry->rule.watch;
entry 1798 kernel/auditfilter.c tree = entry->rule.tree;
entry 1799 kernel/auditfilter.c nentry = audit_dupe_rule(&entry->rule, watch);
entry 1807 kernel/auditfilter.c list_del(&entry->rule.rlist);
entry 1808 kernel/auditfilter.c list_del_rcu(&entry->list);
entry 1813 kernel/auditfilter.c list_del(&entry->rule.rlist);
entry 1815 kernel/auditfilter.c list_replace_init(&entry->rule.rlist,
entry 1817 kernel/auditfilter.c list_replace_rcu(&entry->list, &nentry->list);
entry 1819 kernel/auditfilter.c call_rcu(&entry->rcu, audit_free_rule_rcu);
entry 79 kernel/configs.c struct proc_dir_entry *entry;
entry 82 kernel/configs.c entry = proc_create("config.gz", S_IFREG | S_IRUGO, NULL,
entry 84 kernel/configs.c if (!entry)
entry 87 kernel/configs.c entry->size = kernel_config_data_size;
entry 1916 kernel/futex.c *entry = (void __user *)(uentry & ~1UL);
entry 1931 kernel/futex.c struct robust_list __user *entry, *next_entry, *pending;
entry 1943 kernel/futex.c if (fetch_robust_entry(&entry, &head->list.next, &pi))
entry 1958 kernel/futex.c while (entry != &head->list) {
entry 1963 kernel/futex.c rc = fetch_robust_entry(&next_entry, &entry->next, &next_pi);
entry 1968 kernel/futex.c if (entry != pending)
entry 1969 kernel/futex.c if (handle_futex_death((void __user *)entry + futex_offset,
entry 1974 kernel/futex.c entry = next_entry;
entry 27 kernel/futex_compat.c *entry = compat_ptr((*uentry) & ~1);
entry 36 kernel/futex_compat.c compat_uptr_t base = ptr_to_compat(entry);
entry 51 kernel/futex_compat.c struct robust_list __user *entry, *next_entry, *pending;
entry 64 kernel/futex_compat.c if (fetch_robust_entry(&uentry, &entry, &head->list.next, &pi))
entry 80 kernel/futex_compat.c while (entry != (struct robust_list __user *) &head->list) {
entry 86 kernel/futex_compat.c (compat_uptr_t __user *)&entry->next, &next_pi);
entry 91 kernel/futex_compat.c if (entry != pending) {
entry 92 kernel/futex_compat.c void __user *uaddr = futex_uaddr(entry, futex_offset);
entry 100 kernel/futex_compat.c entry = next_entry;
entry 836 kernel/hrtimer.c struct hrtimer *entry;
entry 846 kernel/hrtimer.c entry = rb_entry(parent, struct hrtimer, node);
entry 851 kernel/hrtimer.c if (timer->expires.tv64 < entry->expires.tv64) {
entry 184 kernel/irq/chip.c desc->msi_desc = entry;
entry 185 kernel/irq/chip.c if (entry)
entry 186 kernel/irq/chip.c entry->irq = irq;
entry 187 kernel/irq/proc.c struct proc_dir_entry *entry;
entry 206 kernel/irq/proc.c entry = create_proc_entry("spurious", 0444, irq_desc[irq].dir);
entry 207 kernel/irq/proc.c if (entry) {
entry 208 kernel/irq/proc.c entry->data = (void *)(long)irq;
entry 209 kernel/irq/proc.c entry->read_proc = irq_spurious_read;
entry 132 kernel/kexec.c image->entry = &image->head;
entry 135 kernel/kexec.c image->start = entry;
entry 232 kernel/kexec.c result = do_kimage_alloc(&image, entry, nr_segments, segments);
entry 277 kernel/kexec.c if ((entry < crashk_res.start) || (entry > crashk_res.end)) {
entry 283 kernel/kexec.c result = do_kimage_alloc(&image, entry, nr_segments, segments);
entry 544 kernel/kexec.c if (*image->entry != 0)
entry 545 kernel/kexec.c image->entry++;
entry 547 kernel/kexec.c if (image->entry == image->last_entry) {
entry 556 kernel/kexec.c *image->entry = virt_to_phys(ind_page) | IND_INDIRECTION;
entry 557 kernel/kexec.c image->entry = ind_page;
entry 561 kernel/kexec.c *image->entry = entry;
entry 562 kernel/kexec.c image->entry++;
entry 563 kernel/kexec.c *image->entry = 0;
entry 606 kernel/kexec.c if (*image->entry != 0)
entry 607 kernel/kexec.c image->entry++;
entry 609 kernel/kexec.c *image->entry = IND_DONE;
entry 613 kernel/kexec.c for (ptr = &image->head; (entry = *ptr) && !(entry & IND_DONE); \
entry 614 kernel/kexec.c ptr = (entry & IND_INDIRECTION)? \
entry 615 kernel/kexec.c phys_to_virt((entry & PAGE_MASK)): ptr +1)
entry 621 kernel/kexec.c page = pfn_to_page(entry >> PAGE_SHIFT);
entry 627 kernel/kexec.c kimage_entry_t *ptr, entry;
entry 634 kernel/kexec.c for_each_kimage_entry(image, ptr, entry) {
entry 635 kernel/kexec.c if (entry & IND_INDIRECTION) {
entry 642 kernel/kexec.c ind = entry;
entry 644 kernel/kexec.c else if (entry & IND_SOURCE)
entry 645 kernel/kexec.c kimage_free_entry(entry);
entry 662 kernel/kexec.c kimage_entry_t *ptr, entry;
entry 665 kernel/kexec.c for_each_kimage_entry(image, ptr, entry) {
entry 666 kernel/kexec.c if (entry & IND_DESTINATION)
entry 667 kernel/kexec.c destination = entry & PAGE_MASK;
entry 668 kernel/kexec.c else if (entry & IND_SOURCE) {
entry 987 kernel/kexec.c result = kimage_normal_alloc(&image, entry,
entry 995 kernel/kexec.c result = kimage_crash_alloc(&image, entry,
entry 1059 kernel/kexec.c return sys_kexec_load(entry, nr_segments, ksegments, flags);
entry 800 kernel/kprobes.c return (unsigned long)entry;
entry 814 kernel/kprobes.c addr = arch_deref_entry_point(jp->entry);
entry 581 kernel/lockdep.c struct lock_list *entry;
entry 591 kernel/lockdep.c list_for_each_entry(entry, &class->locks_after, entry) {
entry 592 kernel/lockdep.c if (DEBUG_LOCKS_WARN_ON(!entry->class))
entry 595 kernel/lockdep.c print_lock_dependencies(entry->class, depth + 1);
entry 598 kernel/lockdep.c print_stack_trace(&entry->trace, 2);
entry 869 kernel/lockdep.c struct lock_list *entry;
entry 874 kernel/lockdep.c entry = alloc_list_entry();
entry 875 kernel/lockdep.c if (!entry)
entry 878 kernel/lockdep.c if (!save_trace(&entry->trace))
entry 881 kernel/lockdep.c entry->class = this;
entry 882 kernel/lockdep.c entry->distance = distance;
entry 890 kernel/lockdep.c list_add_tail_rcu(&entry->entry, head);
entry 947 kernel/lockdep.c print_circular_bug_entry(entry, depth);
entry 990 kernel/lockdep.c struct lock_list *entry;
entry 999 kernel/lockdep.c list_for_each_entry(entry, &class->locks_after, entry)
entry 1000 kernel/lockdep.c ret += __lockdep_count_forward_deps(entry->class, depth + 1);
entry 1021 kernel/lockdep.c struct lock_list *entry;
entry 1029 kernel/lockdep.c list_for_each_entry(entry, &class->locks_before, entry)
entry 1030 kernel/lockdep.c ret += __lockdep_count_backward_deps(entry->class, depth + 1);
entry 1055 kernel/lockdep.c struct lock_list *entry;
entry 1068 kernel/lockdep.c list_for_each_entry(entry, &source->locks_after, entry) {
entry 1069 kernel/lockdep.c if (entry->class == hlock_class(check_target))
entry 1070 kernel/lockdep.c return print_circular_bug_header(entry, depth+1);
entry 1072 kernel/lockdep.c if (!check_noncircular(entry->class, depth+1))
entry 1073 kernel/lockdep.c return print_circular_bug_entry(entry, depth+1);
entry 1100 kernel/lockdep.c struct lock_list *entry;
entry 1120 kernel/lockdep.c list_for_each_entry(entry, &source->locks_after, entry) {
entry 1122 kernel/lockdep.c ret = find_usage_forwards(entry->class, depth+1);
entry 1142 kernel/lockdep.c struct lock_list *entry;
entry 1170 kernel/lockdep.c list_for_each_entry(entry, &source->locks_before, entry) {
entry 1172 kernel/lockdep.c ret = find_usage_backwards(entry->class, depth+1);
entry 1432 kernel/lockdep.c struct lock_list *entry;
entry 1470 kernel/lockdep.c list_for_each_entry(entry, &hlock_class(prev)->locks_after, entry) {
entry 1471 kernel/lockdep.c if (entry->class == hlock_class(next)) {
entry 1473 kernel/lockdep.c entry->distance = 1;
entry 1612 kernel/lockdep.c list_for_each_entry(chain, hash_head, entry) {
entry 1636 kernel/lockdep.c list_for_each_entry(chain, hash_head, entry) {
entry 1678 kernel/lockdep.c list_add_tail_rcu(&chain->entry, hash_head);
entry 3163 kernel/lockdep.c list_del_rcu(&list_entries[i].entry);
entry 86 kernel/lockdep_proc.c struct lock_list *entry;
entry 110 kernel/lockdep_proc.c list_for_each_entry(entry, &class->locks_after, entry) {
entry 111 kernel/lockdep_proc.c if (entry->distance == 1) {
entry 112 kernel/lockdep_proc.c seq_printf(m, " -> [%p] ", entry->class->key);
entry 113 kernel/lockdep_proc.c print_name(m, entry->class);
entry 204 kernel/marker.c struct marker_entry *entry = container_of(head,
entry 206 kernel/marker.c kfree(entry->oldptr);
entry 209 kernel/marker.c entry->rcu_pending = 0;
entry 219 kernel/marker.c if (!entry->ptype) {
entry 221 kernel/marker.c entry->single.func,
entry 222 kernel/marker.c entry->single.probe_private);
entry 224 kernel/marker.c for (i = 0; entry->multi[i].func; i++)
entry 226 kernel/marker.c entry->multi[i].func,
entry 227 kernel/marker.c entry->multi[i].probe_private);
entry 240 kernel/marker.c debug_print_probes(entry);
entry 241 kernel/marker.c old = entry->multi;
entry 242 kernel/marker.c if (!entry->ptype) {
entry 243 kernel/marker.c if (entry->single.func == probe &&
entry 244 kernel/marker.c entry->single.probe_private == probe_private)
entry 246 kernel/marker.c if (entry->single.func == __mark_empty_function) {
entry 248 kernel/marker.c entry->single.func = probe;
entry 249 kernel/marker.c entry->single.probe_private = probe_private;
entry 250 kernel/marker.c entry->refcount = 1;
entry 251 kernel/marker.c entry->ptype = 0;
entry 252 kernel/marker.c debug_print_probes(entry);
entry 273 kernel/marker.c new[0] = entry->single;
entry 279 kernel/marker.c entry->refcount = nr_probes + 1;
entry 280 kernel/marker.c entry->multi = new;
entry 281 kernel/marker.c entry->ptype = 1;
entry 282 kernel/marker.c debug_print_probes(entry);
entry 293 kernel/marker.c old = entry->multi;
entry 295 kernel/marker.c debug_print_probes(entry);
entry 296 kernel/marker.c if (!entry->ptype) {
entry 298 kernel/marker.c WARN_ON(entry->single.func == __mark_empty_function);
entry 300 kernel/marker.c WARN_ON(probe && entry->single.func != probe);
entry 301 kernel/marker.c WARN_ON(entry->single.probe_private != probe_private);
entry 302 kernel/marker.c entry->single.func = __mark_empty_function;
entry 303 kernel/marker.c entry->refcount = 0;
entry 304 kernel/marker.c entry->ptype = 0;
entry 305 kernel/marker.c debug_print_probes(entry);
entry 319 kernel/marker.c entry->single.func = __mark_empty_function;
entry 320 kernel/marker.c entry->refcount = 0;
entry 321 kernel/marker.c entry->ptype = 0;
entry 327 kernel/marker.c entry->single = old[i];
entry 328 kernel/marker.c entry->refcount = 1;
entry 329 kernel/marker.c entry->ptype = 0;
entry 342 kernel/marker.c entry->refcount = nr_probes - nr_del;
entry 343 kernel/marker.c entry->ptype = 1;
entry 344 kernel/marker.c entry->multi = new;
entry 346 kernel/marker.c debug_print_probes(entry);
entry 463 kernel/marker.c size_t name_len = strlen((*entry)->name) + 1;
entry 471 kernel/marker.c memcpy(&e->name[0], (*entry)->name, name_len);
entry 478 kernel/marker.c e->single = (*entry)->single;
entry 479 kernel/marker.c e->multi = (*entry)->multi;
entry 480 kernel/marker.c e->ptype = (*entry)->ptype;
entry 481 kernel/marker.c e->refcount = (*entry)->refcount;
entry 483 kernel/marker.c hlist_add_before(&e->hlist, &(*entry)->hlist);
entry 484 kernel/marker.c hlist_del(&(*entry)->hlist);
entry 486 kernel/marker.c if ((*entry)->rcu_pending)
entry 488 kernel/marker.c kfree(*entry);
entry 489 kernel/marker.c *entry = e;
entry 502 kernel/marker.c WARN_ON(strcmp((*entry)->name, elem->name) != 0);
entry 504 kernel/marker.c if ((*entry)->format) {
entry 505 kernel/marker.c if (strcmp((*entry)->format, elem->format) != 0) {
entry 509 kernel/marker.c (*entry)->name,
entry 510 kernel/marker.c (*entry)->format,
entry 515 kernel/marker.c ret = marker_set_format(entry, elem->format);
entry 526 kernel/marker.c elem->call = (*entry)->call;
entry 534 kernel/marker.c != (*entry)->single.probe_private &&
entry 536 kernel/marker.c elem->single.probe_private = (*entry)->single.probe_private;
entry 542 kernel/marker.c elem->single.func = (*entry)->single.func;
entry 547 kernel/marker.c rcu_assign_pointer(elem->multi, (*entry)->multi);
entry 553 kernel/marker.c elem->ptype = (*entry)->ptype;
entry 648 kernel/marker.c struct marker_entry *entry;
entry 653 kernel/marker.c entry = get_marker(name);
entry 654 kernel/marker.c if (!entry) {
entry 655 kernel/marker.c entry = add_marker(name, format);
entry 656 kernel/marker.c if (IS_ERR(entry)) {
entry 657 kernel/marker.c ret = PTR_ERR(entry);
entry 665 kernel/marker.c if (entry->rcu_pending)
entry 667 kernel/marker.c old = marker_entry_add_probe(entry, probe, probe_private);
entry 675 kernel/marker.c entry = get_marker(name);
entry 676 kernel/marker.c WARN_ON(!entry);
entry 677 kernel/marker.c entry->oldptr = old;
entry 678 kernel/marker.c entry->rcu_pending = 1;
entry 681 kernel/marker.c call_rcu_sched(&entry->rcu, free_old_closure);
entry 703 kernel/marker.c struct marker_entry *entry;
entry 708 kernel/marker.c entry = get_marker(name);
entry 709 kernel/marker.c if (!entry)
entry 711 kernel/marker.c if (entry->rcu_pending)
entry 713 kernel/marker.c old = marker_entry_remove_probe(entry, probe, probe_private);
entry 717 kernel/marker.c entry = get_marker(name);
entry 718 kernel/marker.c if (!entry)
entry 720 kernel/marker.c entry->oldptr = old;
entry 721 kernel/marker.c entry->rcu_pending = 1;
entry 724 kernel/marker.c call_rcu_sched(&entry->rcu, free_old_closure);
entry 736 kernel/marker.c struct marker_entry *entry;
entry 743 kernel/marker.c hlist_for_each_entry(entry, node, head, hlist) {
entry 744 kernel/marker.c if (!entry->ptype) {
entry 745 kernel/marker.c if (entry->single.func == probe
entry 746 kernel/marker.c && entry->single.probe_private
entry 748 kernel/marker.c return entry;
entry 751 kernel/marker.c closure = entry->multi;
entry 756 kernel/marker.c return entry;
entry 780 kernel/marker.c struct marker_entry *entry;
entry 785 kernel/marker.c entry = get_marker_from_private_data(probe, probe_private);
entry 786 kernel/marker.c if (!entry) {
entry 790 kernel/marker.c if (entry->rcu_pending)
entry 792 kernel/marker.c old = marker_entry_remove_probe(entry, NULL, probe_private);
entry 796 kernel/marker.c entry = get_marker_from_private_data(probe, probe_private);
entry 797 kernel/marker.c WARN_ON(!entry);
entry 798 kernel/marker.c entry->oldptr = old;
entry 799 kernel/marker.c entry->rcu_pending = 1;
entry 802 kernel/marker.c call_rcu_sched(&entry->rcu, free_old_closure);
entry 803 kernel/marker.c remove_marker(entry->name); /* Ignore busy error message */
entry 347 kernel/posix-cpu-timers.c INIT_LIST_HEAD(&new_timer->it.cpu.entry);
entry 398 kernel/posix-cpu-timers.c BUG_ON(!list_empty(&timer->it.cpu.entry));
entry 404 kernel/posix-cpu-timers.c list_del(&timer->it.cpu.entry);
entry 429 kernel/posix-cpu-timers.c list_for_each_entry_safe(timer, next, head, entry) {
entry 430 kernel/posix-cpu-timers.c list_del_init(&timer->entry);
entry 440 kernel/posix-cpu-timers.c list_for_each_entry_safe(timer, next, head, entry) {
entry 441 kernel/posix-cpu-timers.c list_del_init(&timer->entry);
entry 451 kernel/posix-cpu-timers.c list_for_each_entry_safe(timer, next, head, entry) {
entry 452 kernel/posix-cpu-timers.c list_del_init(&timer->entry);
entry 585 kernel/posix-cpu-timers.c list_for_each_entry(next, head, entry) {
entry 588 kernel/posix-cpu-timers.c listpos = &next->entry;
entry 591 kernel/posix-cpu-timers.c list_for_each_entry(next, head, entry) {
entry 594 kernel/posix-cpu-timers.c listpos = &next->entry;
entry 597 kernel/posix-cpu-timers.c list_add(&nt->entry, listpos);
entry 746 kernel/posix-cpu-timers.c list_del_init(&timer->it.cpu.entry);
entry 976 kernel/posix-cpu-timers.c entry);
entry 982 kernel/posix-cpu-timers.c list_move_tail(&t->entry, firing);
entry 991 kernel/posix-cpu-timers.c entry);
entry 997 kernel/posix-cpu-timers.c list_move_tail(&t->entry, firing);
entry 1006 kernel/posix-cpu-timers.c entry);
entry 1012 kernel/posix-cpu-timers.c list_move_tail(&t->entry, firing);
entry 1094 kernel/posix-cpu-timers.c entry);
entry 1100 kernel/posix-cpu-timers.c list_move_tail(&tl->entry, firing);
entry 1109 kernel/posix-cpu-timers.c entry);
entry 1115 kernel/posix-cpu-timers.c list_move_tail(&tl->entry, firing);
entry 1124 kernel/posix-cpu-timers.c entry);
entry 1130 kernel/posix-cpu-timers.c list_move_tail(&tl->entry, firing);
entry 1372 kernel/posix-cpu-timers.c list_for_each_entry_safe(timer, next, &firing, it.cpu.entry) {
entry 1375 kernel/posix-cpu-timers.c list_del_init(&timer->it.cpu.entry);
entry 1436 kernel/posix-cpu-timers.c struct cpu_timer_list, entry)->expires.cpu,
entry 448 kernel/profile.c struct proc_dir_entry *entry;
entry 451 kernel/profile.c entry = create_proc_entry("prof_cpu_mask", 0600, root_irq_dir);
entry 452 kernel/profile.c if (!entry)
entry 454 kernel/profile.c entry->data = (void *)&prof_cpu_mask;
entry 455 kernel/profile.c entry->read_proc = prof_cpu_mask_read_proc;
entry 456 kernel/profile.c entry->write_proc = prof_cpu_mask_write_proc;
entry 580 kernel/profile.c struct proc_dir_entry *entry;
entry 586 kernel/profile.c entry = proc_create("profile", S_IWUSR | S_IRUGO,
entry 588 kernel/profile.c if (!entry)
entry 590 kernel/profile.c entry->size = (1+prof_len) * sizeof(atomic_t);
entry 6312 kernel/sched.c struct ctl_table *entry =
entry 6315 kernel/sched.c return entry;
entry 6320 kernel/sched.c struct ctl_table *entry;
entry 6328 kernel/sched.c for (entry = *tablep; entry->mode; entry++) {
entry 6329 kernel/sched.c if (entry->child)
entry 6330 kernel/sched.c sd_free_ctl_entry(&entry->child);
entry 6331 kernel/sched.c if (entry->proc_handler == NULL)
entry 6332 kernel/sched.c kfree(entry->procname);
entry 6344 kernel/sched.c entry->procname = procname;
entry 6345 kernel/sched.c entry->data = data;
entry 6346 kernel/sched.c entry->maxlen = maxlen;
entry 6347 kernel/sched.c entry->mode = mode;
entry 6348 kernel/sched.c entry->proc_handler = proc_handler;
entry 6391 kernel/sched.c struct ctl_table *entry, *table;
entry 6398 kernel/sched.c entry = table = sd_alloc_ctl_entry(domain_num + 1);
entry 6405 kernel/sched.c entry->procname = kstrdup(buf, GFP_KERNEL);
entry 6406 kernel/sched.c entry->mode = 0555;
entry 6407 kernel/sched.c entry->child = sd_alloc_ctl_domain_table(sd);
entry 6408 kernel/sched.c entry++;
entry 6418 kernel/sched.c struct ctl_table *entry = sd_alloc_ctl_entry(cpu_num + 1);
entry 6422 kernel/sched.c sd_ctl_dir[0].child = entry;
entry 6424 kernel/sched.c if (entry == NULL)
entry 6429 kernel/sched.c entry->procname = kstrdup(buf, GFP_KERNEL);
entry 6430 kernel/sched.c entry->mode = 0555;
entry 6431 kernel/sched.c entry->child = sd_alloc_ctl_cpu_table(i);
entry 6432 kernel/sched.c entry++;
entry 231 kernel/sched_fair.c struct sched_entity *entry;
entry 240 kernel/sched_fair.c entry = rb_entry(parent, struct sched_entity, run_node);
entry 245 kernel/sched_fair.c if (key < entity_key(cfs_rq, entry)) {
entry 109 kernel/test_kprobes.c .entry = j_kprobe_target,
entry 296 kernel/time/clocksource.c struct list_head *tmp, *entry = &clocksource_list;
entry 306 kernel/time/clocksource.c entry = tmp;
entry 308 kernel/time/clocksource.c list_add(&c->list, entry);
entry 57 kernel/time/timer_stats.c struct entry *next;
entry 117 kernel/time/timer_stats.c static struct entry entries[MAX_ENTRIES];
entry 129 kernel/time/timer_stats.c (((unsigned long)(entry)->timer ^ \
entry 130 kernel/time/timer_stats.c (unsigned long)(entry)->start_func ^ \
entry 131 kernel/time/timer_stats.c (unsigned long)(entry)->expire_func ^ \
entry 132 kernel/time/timer_stats.c (unsigned long)(entry)->pid ) & TSTAT_HASH_MASK)
entry 134 kernel/time/timer_stats.c #define tstat_hashentry(entry) (tstat_hash_table + __tstat_hashfn(entry))
entry 136 kernel/time/timer_stats.c static struct entry *tstat_hash_table[TSTAT_HASH_SIZE] __read_mostly;
entry 146 kernel/time/timer_stats.c static struct entry *alloc_entry(void)
entry 167 kernel/time/timer_stats.c static struct entry *tstat_lookup(struct entry *entry, char *comm)
entry 169 kernel/time/timer_stats.c struct entry **head, *curr, *prev;
entry 171 kernel/time/timer_stats.c head = tstat_hashentry(entry);
entry 180 kernel/time/timer_stats.c if (match_entries(curr, entry))
entry 196 kernel/time/timer_stats.c if (match_entries(curr, entry))
entry 205 kernel/time/timer_stats.c *curr = *entry;
entry 242 kernel/time/timer_stats.c struct entry *entry, input;
entry 260 kernel/time/timer_stats.c entry = tstat_lookup(&input, comm);
entry 261 kernel/time/timer_stats.c if (likely(entry))
entry 262 kernel/time/timer_stats.c entry->count++;
entry 283 kernel/time/timer_stats.c struct entry *entry;
entry 308 kernel/time/timer_stats.c entry = entries + i;
entry 309 kernel/time/timer_stats.c if (entry->timer_flag & TIMER_STATS_FLAG_DEFERRABLE) {
entry 311 kernel/time/timer_stats.c entry->count, entry->pid, entry->comm);
entry 314 kernel/time/timer_stats.c entry->count, entry->pid, entry->comm);
entry 317 kernel/time/timer_stats.c print_name_offset(m, (unsigned long)entry->start_func);
entry 319 kernel/time/timer_stats.c print_name_offset(m, (unsigned long)entry->expire_func);
entry 322 kernel/time/timer_stats.c events += entry->count;
entry 294 kernel/timer.c list_add_tail(&timer->entry, vec);
entry 362 kernel/timer.c if (timer->entry.next == NULL &&
entry 363 kernel/timer.c timer->entry.prev == TIMER_ENTRY_STATIC) {
entry 448 kernel/timer.c timer->entry.next = NULL;
entry 481 kernel/timer.c struct list_head *entry = &timer->entry;
entry 485 kernel/timer.c __list_del(entry->prev, entry->next);
entry 487 kernel/timer.c entry->next = NULL;
entry 488 kernel/timer.c entry->prev = LIST_POISON2;
entry 746 kernel/timer.c list_for_each_entry_safe(timer, tmp, &tv_list, entry) {
entry 787 kernel/timer.c timer = list_first_entry(head, struct timer_list,entry);
entry 832 kernel/timer.c list_for_each_entry(nte, base->tv1.vec + slot, entry) {
entry 863 kernel/timer.c list_for_each_entry(nte, varp->vec + slot, entry) {
entry 1422 kernel/timer.c timer = list_first_entry(head, struct timer_list, entry);
entry 1522 kernel/trace/ftrace.c struct dentry *entry;
entry 1526 kernel/trace/ftrace.c entry = debugfs_create_file("available_filter_functions", 0444,
entry 1528 kernel/trace/ftrace.c if (!entry)
entry 1532 kernel/trace/ftrace.c entry = debugfs_create_file("failures", 0444,
entry 1534 kernel/trace/ftrace.c if (!entry)
entry 1537 kernel/trace/ftrace.c entry = debugfs_create_file("set_ftrace_filter", 0644, d_tracer,
entry 1539 kernel/trace/ftrace.c if (!entry)
entry 1543 kernel/trace/ftrace.c entry = debugfs_create_file("set_ftrace_notrace", 0644, d_tracer,
entry 1545 kernel/trace/ftrace.c if (!entry)
entry 1549 kernel/trace/ftrace.c entry = debugfs_create_file("ftraced_enabled", 0644, d_tracer,
entry 1551 kernel/trace/ftrace.c if (!entry)
entry 780 kernel/trace/trace.c struct trace_entry *entry;
entry 788 kernel/trace/trace.c entry = data->trace_head + idx * TRACE_ENTRY_SIZE;
entry 809 kernel/trace/trace.c return entry;
entry 820 kernel/trace/trace.c entry->preempt_count = pc & 0xff;
entry 821 kernel/trace/trace.c entry->pid = (tsk) ? tsk->pid : 0;
entry 822 kernel/trace/trace.c entry->t = ftrace_now(raw_smp_processor_id());
entry 823 kernel/trace/trace.c entry->flags = (irqs_disabled_flags(flags) ? TRACE_FLAG_IRQS_OFF : 0) |
entry 833 kernel/trace/trace.c struct trace_entry *entry;
entry 838 kernel/trace/trace.c entry = tracing_get_trace_entry(tr, data);
entry 839 kernel/trace/trace.c tracing_generic_entry_update(entry, flags);
entry 840 kernel/trace/trace.c entry->type = TRACE_FN;
entry 841 kernel/trace/trace.c entry->fn.ip = ip;
entry 842 kernel/trace/trace.c entry->fn.parent_ip = parent_ip;
entry 859 kernel/trace/trace.c struct trace_entry *entry;
entry 865 kernel/trace/trace.c entry = tracing_get_trace_entry(tr, data);
entry 866 kernel/trace/trace.c tracing_generic_entry_update(entry, 0);
entry 867 kernel/trace/trace.c entry->type = TRACE_MMIO_RW;
entry 868 kernel/trace/trace.c entry->mmiorw = *rw;
entry 879 kernel/trace/trace.c struct trace_entry *entry;
entry 885 kernel/trace/trace.c entry = tracing_get_trace_entry(tr, data);
entry 886 kernel/trace/trace.c tracing_generic_entry_update(entry, 0);
entry 887 kernel/trace/trace.c entry->type = TRACE_MMIO_MAP;
entry 888 kernel/trace/trace.c entry->mmiomap = *map;
entry 902 kernel/trace/trace.c struct trace_entry *entry;
entry 908 kernel/trace/trace.c entry = tracing_get_trace_entry(tr, data);
entry 909 kernel/trace/trace.c tracing_generic_entry_update(entry, flags);
entry 910 kernel/trace/trace.c entry->type = TRACE_STACK;
entry 912 kernel/trace/trace.c memset(&entry->stack, 0, sizeof(entry->stack));
entry 917 kernel/trace/trace.c trace.entries = entry->stack.caller;
entry 928 kernel/trace/trace.c struct trace_entry *entry;
entry 933 kernel/trace/trace.c entry = tracing_get_trace_entry(tr, data);
entry 934 kernel/trace/trace.c tracing_generic_entry_update(entry, 0);
entry 935 kernel/trace/trace.c entry->type = TRACE_SPECIAL;
entry 936 kernel/trace/trace.c entry->special.arg1 = arg1;
entry 937 kernel/trace/trace.c entry->special.arg2 = arg2;
entry 938 kernel/trace/trace.c entry->special.arg3 = arg3;
entry 953 kernel/trace/trace.c struct trace_entry *entry;
entry 958 kernel/trace/trace.c entry = tracing_get_trace_entry(tr, data);
entry 959 kernel/trace/trace.c tracing_generic_entry_update(entry, flags);
entry 960 kernel/trace/trace.c entry->type = TRACE_CTX;
entry 961 kernel/trace/trace.c entry->ctx.prev_pid = prev->pid;
entry 962 kernel/trace/trace.c entry->ctx.prev_prio = prev->prio;
entry 963 kernel/trace/trace.c entry->ctx.prev_state = prev->state;
entry 964 kernel/trace/trace.c entry->ctx.next_pid = next->pid;
entry 965 kernel/trace/trace.c entry->ctx.next_prio = next->prio;
entry 966 kernel/trace/trace.c entry->ctx.next_state = next->state;
entry 979 kernel/trace/trace.c struct trace_entry *entry;
entry 984 kernel/trace/trace.c entry = tracing_get_trace_entry(tr, data);
entry 985 kernel/trace/trace.c tracing_generic_entry_update(entry, flags);
entry 986 kernel/trace/trace.c entry->type = TRACE_WAKE;
entry 987 kernel/trace/trace.c entry->ctx.prev_pid = curr->pid;
entry 988 kernel/trace/trace.c entry->ctx.prev_prio = curr->prio;
entry 989 kernel/trace/trace.c entry->ctx.prev_state = curr->state;
entry 990 kernel/trace/trace.c entry->ctx.next_pid = wakee->pid;
entry 991 kernel/trace/trace.c entry->ctx.next_prio = wakee->prio;
entry 992 kernel/trace/trace.c entry->ctx.next_state = wakee->state;
entry 1428 kernel/trace/trace.c comm = trace_find_cmdline(entry->pid);
entry 1430 kernel/trace/trace.c trace_seq_printf(s, "%8.8s-%-5d ", comm, entry->pid);
entry 1433 kernel/trace/trace.c (entry->flags & TRACE_FLAG_IRQS_OFF) ? 'd' : '.',
entry 1434 kernel/trace/trace.c ((entry->flags & TRACE_FLAG_NEED_RESCHED) ? 'N' : '.'));
entry 1436 kernel/trace/trace.c hardirq = entry->flags & TRACE_FLAG_HARDIRQ;
entry 1437 kernel/trace/trace.c softirq = entry->flags & TRACE_FLAG_SOFTIRQ;
entry 1451 kernel/trace/trace.c if (entry->preempt_count)
entry 1452 kernel/trace/trace.c trace_seq_printf(s, "%x", entry->preempt_count);
entry 1481 kernel/trace/trace.c struct trace_entry *entry = iter->ent;
entry 1490 kernel/trace/trace.c next_entry = entry;
entry 1491 kernel/trace/trace.c rel_usecs = ns2usecs(next_entry->t - entry->t);
entry 1492 kernel/trace/trace.c abs_usecs = ns2usecs(entry->t - iter->tr->time_start);
entry 1495 kernel/trace/trace.c comm = trace_find_cmdline(entry->pid);
entry 1499 kernel/trace/trace.c entry->pid, cpu, entry->flags,
entry 1500 kernel/trace/trace.c entry->preempt_count, trace_idx,
entry 1501 kernel/trace/trace.c ns2usecs(entry->t),
entry 1506 kernel/trace/trace.c lat_print_generic(s, entry, cpu);
entry 1509 kernel/trace/trace.c switch (entry->type) {
entry 1511 kernel/trace/trace.c seq_print_ip_sym(s, entry->fn.ip, sym_flags);
entry 1513 kernel/trace/trace.c if (kretprobed(entry->fn.parent_ip))
entry 1516 kernel/trace/trace.c seq_print_ip_sym(s, entry->fn.parent_ip, sym_flags);
entry 1521 kernel/trace/trace.c T = entry->ctx.next_state < sizeof(state_to_char) ?
entry 1522 kernel/trace/trace.c state_to_char[entry->ctx.next_state] : 'X';
entry 1524 kernel/trace/trace.c state = entry->ctx.prev_state ? __ffs(entry->ctx.prev_state) + 1 : 0;
entry 1526 kernel/trace/trace.c comm = trace_find_cmdline(entry->ctx.next_pid);
entry 1528 kernel/trace/trace.c entry->ctx.prev_pid,
entry 1529 kernel/trace/trace.c entry->ctx.prev_prio,
entry 1530 kernel/trace/trace.c S, entry->type == TRACE_CTX ? "==>" : " +",
entry 1531 kernel/trace/trace.c entry->ctx.next_pid,
entry 1532 kernel/trace/trace.c entry->ctx.next_prio,
entry 1537 kernel/trace/trace.c entry->special.arg1,
entry 1538 kernel/trace/trace.c entry->special.arg2,
entry 1539 kernel/trace/trace.c entry->special.arg3);
entry 1545 kernel/trace/trace.c seq_print_ip_sym(s, entry->stack.caller[i], sym_flags);
entry 1550 kernel/trace/trace.c trace_seq_printf(s, "Unknown type %d\n", entry->type);
entry 1559 kernel/trace/trace.c struct trace_entry *entry;
entry 1568 kernel/trace/trace.c entry = iter->ent;
entry 1572 kernel/trace/trace.c t = ns2usecs(entry->t);
entry 1576 kernel/trace/trace.c ret = trace_seq_printf(s, "%16s-%-5d ", comm, entry->pid);
entry 1586 kernel/trace/trace.c switch (entry->type) {
entry 1588 kernel/trace/trace.c ret = seq_print_ip_sym(s, entry->fn.ip, sym_flags);
entry 1592 kernel/trace/trace.c entry->fn.parent_ip) {
entry 1596 kernel/trace/trace.c if (kretprobed(entry->fn.parent_ip))
entry 1599 kernel/trace/trace.c ret = seq_print_ip_sym(s, entry->fn.parent_ip,
entry 1610 kernel/trace/trace.c S = entry->ctx.prev_state < sizeof(state_to_char) ?
entry 1611 kernel/trace/trace.c state_to_char[entry->ctx.prev_state] : 'X';
entry 1612 kernel/trace/trace.c T = entry->ctx.next_state < sizeof(state_to_char) ?
entry 1613 kernel/trace/trace.c state_to_char[entry->ctx.next_state] : 'X';
entry 1615 kernel/trace/trace.c entry->ctx.prev_pid,
entry 1616 kernel/trace/trace.c entry->ctx.prev_prio,
entry 1618 kernel/trace/trace.c entry->type == TRACE_CTX ? "==>" : " +",
entry 1619 kernel/trace/trace.c entry->ctx.next_pid,
entry 1620 kernel/trace/trace.c entry->ctx.next_prio,
entry 1627 kernel/trace/trace.c entry->special.arg1,
entry 1628 kernel/trace/trace.c entry->special.arg2,
entry 1629 kernel/trace/trace.c entry->special.arg3);
entry 1640 kernel/trace/trace.c ret = seq_print_ip_sym(s, entry->stack.caller[i],
entry 1656 kernel/trace/trace.c struct trace_entry *entry;
entry 1660 kernel/trace/trace.c entry = iter->ent;
entry 1663 kernel/trace/trace.c entry->pid, iter->cpu, entry->t);
entry 1667 kernel/trace/trace.c switch (entry->type) {
entry 1670 kernel/trace/trace.c entry->fn.ip, entry->fn.parent_ip);
entry 1676 kernel/trace/trace.c S = entry->ctx.prev_state < sizeof(state_to_char) ?
entry 1677 kernel/trace/trace.c state_to_char[entry->ctx.prev_state] : 'X';
entry 1678 kernel/trace/trace.c T = entry->ctx.next_state < sizeof(state_to_char) ?
entry 1679 kernel/trace/trace.c state_to_char[entry->ctx.next_state] : 'X';
entry 1680 kernel/trace/trace.c if (entry->type == TRACE_WAKE)
entry 1683 kernel/trace/trace.c entry->ctx.prev_pid,
entry 1684 kernel/trace/trace.c entry->ctx.prev_prio,
entry 1686 kernel/trace/trace.c entry->ctx.next_pid,
entry 1687 kernel/trace/trace.c entry->ctx.next_prio,
entry 1695 kernel/trace/trace.c entry->special.arg1,
entry 1696 kernel/trace/trace.c entry->special.arg2,
entry 1697 kernel/trace/trace.c entry->special.arg3);
entry 1721 kernel/trace/trace.c struct trace_entry *entry;
entry 1724 kernel/trace/trace.c entry = iter->ent;
entry 1726 kernel/trace/trace.c SEQ_PUT_HEX_FIELD_RET(s, entry->pid);
entry 1728 kernel/trace/trace.c SEQ_PUT_HEX_FIELD_RET(s, entry->t);
entry 1730 kernel/trace/trace.c switch (entry->type) {
entry 1732 kernel/trace/trace.c SEQ_PUT_HEX_FIELD_RET(s, entry->fn.ip);
entry 1733 kernel/trace/trace.c SEQ_PUT_HEX_FIELD_RET(s, entry->fn.parent_ip);
entry 1737 kernel/trace/trace.c S = entry->ctx.prev_state < sizeof(state_to_char) ?
entry 1738 kernel/trace/trace.c state_to_char[entry->ctx.prev_state] : 'X';
entry 1739 kernel/trace/trace.c T = entry->ctx.next_state < sizeof(state_to_char) ?
entry 1740 kernel/trace/trace.c state_to_char[entry->ctx.next_state] : 'X';
entry 1741 kernel/trace/trace.c if (entry->type == TRACE_WAKE)
entry 1743 kernel/trace/trace.c SEQ_PUT_HEX_FIELD_RET(s, entry->ctx.prev_pid);
entry 1744 kernel/trace/trace.c SEQ_PUT_HEX_FIELD_RET(s, entry->ctx.prev_prio);
entry 1746 kernel/trace/trace.c SEQ_PUT_HEX_FIELD_RET(s, entry->ctx.next_pid);
entry 1747 kernel/trace/trace.c SEQ_PUT_HEX_FIELD_RET(s, entry->ctx.next_prio);
entry 1748 kernel/trace/trace.c SEQ_PUT_HEX_FIELD_RET(s, entry->fn.parent_ip);
entry 1753 kernel/trace/trace.c SEQ_PUT_HEX_FIELD_RET(s, entry->special.arg1);
entry 1754 kernel/trace/trace.c SEQ_PUT_HEX_FIELD_RET(s, entry->special.arg2);
entry 1755 kernel/trace/trace.c SEQ_PUT_HEX_FIELD_RET(s, entry->special.arg3);
entry 1766 kernel/trace/trace.c struct trace_entry *entry;
entry 1768 kernel/trace/trace.c entry = iter->ent;
entry 1770 kernel/trace/trace.c SEQ_PUT_FIELD_RET(s, entry->pid);
entry 1771 kernel/trace/trace.c SEQ_PUT_FIELD_RET(s, entry->cpu);
entry 1772 kernel/trace/trace.c SEQ_PUT_FIELD_RET(s, entry->t);
entry 1774 kernel/trace/trace.c switch (entry->type) {
entry 1776 kernel/trace/trace.c SEQ_PUT_FIELD_RET(s, entry->fn.ip);
entry 1777 kernel/trace/trace.c SEQ_PUT_FIELD_RET(s, entry->fn.parent_ip);
entry 1780 kernel/trace/trace.c SEQ_PUT_FIELD_RET(s, entry->ctx.prev_pid);
entry 1781 kernel/trace/trace.c SEQ_PUT_FIELD_RET(s, entry->ctx.prev_prio);
entry 1782 kernel/trace/trace.c SEQ_PUT_FIELD_RET(s, entry->ctx.prev_state);
entry 1783 kernel/trace/trace.c SEQ_PUT_FIELD_RET(s, entry->ctx.next_pid);
entry 1784 kernel/trace/trace.c SEQ_PUT_FIELD_RET(s, entry->ctx.next_prio);
entry 1785 kernel/trace/trace.c SEQ_PUT_FIELD_RET(s, entry->ctx.next_state);
entry 1789 kernel/trace/trace.c SEQ_PUT_FIELD_RET(s, entry->special.arg1);
entry 1790 kernel/trace/trace.c SEQ_PUT_FIELD_RET(s, entry->special.arg2);
entry 1791 kernel/trace/trace.c SEQ_PUT_FIELD_RET(s, entry->special.arg3);
entry 2852 kernel/trace/trace.c struct dentry *entry;
entry 2856 kernel/trace/trace.c entry = debugfs_create_file("tracing_enabled", 0644, d_tracer,
entry 2858 kernel/trace/trace.c if (!entry)
entry 2861 kernel/trace/trace.c entry = debugfs_create_file("iter_ctrl", 0644, d_tracer,
entry 2863 kernel/trace/trace.c if (!entry)
entry 2866 kernel/trace/trace.c entry = debugfs_create_file("tracing_cpumask", 0644, d_tracer,
entry 2868 kernel/trace/trace.c if (!entry)
entry 2871 kernel/trace/trace.c entry = debugfs_create_file("latency_trace", 0444, d_tracer,
entry 2873 kernel/trace/trace.c if (!entry)
entry 2876 kernel/trace/trace.c entry = debugfs_create_file("trace", 0444, d_tracer,
entry 2878 kernel/trace/trace.c if (!entry)
entry 2881 kernel/trace/trace.c entry = debugfs_create_file("available_tracers", 0444, d_tracer,
entry 2883 kernel/trace/trace.c if (!entry)
entry 2886 kernel/trace/trace.c entry = debugfs_create_file("current_tracer", 0444, d_tracer,
entry 2888 kernel/trace/trace.c if (!entry)
entry 2891 kernel/trace/trace.c entry = debugfs_create_file("tracing_max_latency", 0644, d_tracer,
entry 2894 kernel/trace/trace.c if (!entry)
entry 2898 kernel/trace/trace.c entry = debugfs_create_file("tracing_thresh", 0644, d_tracer,
entry 2900 kernel/trace/trace.c if (!entry)
entry 2903 kernel/trace/trace.c entry = debugfs_create_file("README", 0644, d_tracer,
entry 2905 kernel/trace/trace.c if (!entry)
entry 2908 kernel/trace/trace.c entry = debugfs_create_file("trace_pipe", 0644, d_tracer,
entry 2910 kernel/trace/trace.c if (!entry)
entry 2914 kernel/trace/trace.c entry = debugfs_create_file("trace_entries", 0644, d_tracer,
entry 2916 kernel/trace/trace.c if (!entry)
entry 2921 kernel/trace/trace.c entry = debugfs_create_file("dyn_ftrace_total_info", 0444, d_tracer,
entry 2924 kernel/trace/trace.c if (!entry)
entry 176 kernel/trace/trace_mmiotrace.c struct trace_entry *entry = iter->ent;
entry 177 kernel/trace/trace_mmiotrace.c struct mmiotrace_rw *rw = &entry->mmiorw;
entry 179 kernel/trace/trace_mmiotrace.c unsigned long long t = ns2usecs(entry->t);
entry 184 kernel/trace/trace_mmiotrace.c switch (entry->mmiorw.opcode) {
entry 218 kernel/trace/trace_mmiotrace.c struct trace_entry *entry = iter->ent;
entry 219 kernel/trace/trace_mmiotrace.c struct mmiotrace_map *m = &entry->mmiomap;
entry 221 kernel/trace/trace_mmiotrace.c unsigned long long t = ns2usecs(entry->t);
entry 226 kernel/trace/trace_mmiotrace.c switch (entry->mmiorw.opcode) {
entry 8 kernel/trace/trace_selftest.c switch (entry->type) {
entry 356 kernel/trace/trace_sysprof.c struct dentry *entry;
entry 358 kernel/trace/trace_sysprof.c entry = debugfs_create_file("sysprof_sample_period", 0644,
entry 360 kernel/trace/trace_sysprof.c if (entry)
entry 136 kernel/workqueue.c list_add_tail(&work->entry, head);
entry 188 kernel/workqueue.c BUG_ON(!list_empty(&work->entry));
entry 241 kernel/workqueue.c BUG_ON(!list_empty(&work->entry));
entry 273 kernel/workqueue.c struct work_struct, entry);
entry 449 kernel/workqueue.c if (!list_empty(&work->entry)) {
entry 457 kernel/workqueue.c prev = &work->entry;
entry 496 kernel/workqueue.c if (!list_empty(&work->entry)) {
entry 504 kernel/workqueue.c list_del_init(&work->entry);
entry 129 lib/kobject.c list_add_tail(&kobj->entry, &kobj->kset->list);
entry 140 lib/kobject.c list_del_init(&kobj->entry);
entry 150 lib/kobject.c INIT_LIST_HEAD(&kobj->entry);
entry 745 lib/kobject.c list_for_each_entry(k, &kset->list, entry) {
entry 46 lib/list_debug.c WARN(entry->prev->next != entry,
entry 48 lib/list_debug.c "but was %p\n", entry, entry->prev->next);
entry 49 lib/list_debug.c WARN(entry->next->prev != entry,
entry 51 lib/list_debug.c "but was %p\n", entry, entry->next->prev);
entry 52 lib/list_debug.c __list_del(entry->prev, entry->next);
entry 53 lib/list_debug.c entry->next = LIST_POISON1;
entry 54 lib/list_debug.c entry->prev = LIST_POISON2;
entry 1595 mm/hugetlb.c pte_t entry;
entry 1598 mm/hugetlb.c entry =
entry 1601 mm/hugetlb.c entry = huge_pte_wrprotect(mk_pte(page, vma->vm_page_prot));
entry 1603 mm/hugetlb.c entry = pte_mkyoung(entry);
entry 1604 mm/hugetlb.c entry = pte_mkhuge(entry);
entry 1606 mm/hugetlb.c return entry;
entry 1612 mm/hugetlb.c pte_t entry;
entry 1614 mm/hugetlb.c entry = pte_mkwrite(pte_mkdirty(huge_ptep_get(ptep)));
entry 1615 mm/hugetlb.c if (huge_ptep_set_access_flags(vma, address, ptep, entry, 1)) {
entry 1616 mm/hugetlb.c update_mmu_cache(vma, address, entry);
entry 1624 mm/hugetlb.c pte_t *src_pte, *dst_pte, entry;
entry 1650 mm/hugetlb.c entry = huge_ptep_get(src_pte);
entry 1651 mm/hugetlb.c ptepage = pte_page(entry);
entry 1653 mm/hugetlb.c set_huge_pte_at(dst, addr, dst_pte, entry);
entry 1992 mm/hugetlb.c pte_t entry;
entry 2008 mm/hugetlb.c entry = huge_ptep_get(ptep);
entry 2009 mm/hugetlb.c if (huge_pte_none(entry)) {
entry 2024 mm/hugetlb.c if (write_access && !pte_write(entry)) {
entry 2037 mm/hugetlb.c if (likely(pte_same(entry, huge_ptep_get(ptep))))
entry 2038 mm/hugetlb.c if (write_access && !pte_write(entry))
entry 2039 mm/hugetlb.c ret = hugetlb_cow(mm, vma, address, ptep, entry,
entry 503 mm/memory.c swp_entry_t entry = pte_to_swp_entry(pte);
entry 505 mm/memory.c swap_duplicate(entry);
entry 514 mm/memory.c if (is_write_migration_entry(entry) &&
entry 520 mm/memory.c make_migration_entry_read(&entry);
entry 521 mm/memory.c pte = swp_entry_to_pte(entry);
entry 1371 mm/memory.c pte_t *pte, entry;
entry 1383 mm/memory.c entry = pte_mkspecial(pfn_pte(pfn, prot));
entry 1384 mm/memory.c set_pte_at(mm, addr, pte, entry);
entry 1385 mm/memory.c update_mmu_cache(vma, addr, entry); /* XXX: why not for insert_page? */
entry 1767 mm/memory.c pte_t entry;
entry 1840 mm/memory.c entry = pte_mkyoung(orig_pte);
entry 1841 mm/memory.c entry = maybe_mkwrite(pte_mkdirty(entry), vma);
entry 1842 mm/memory.c if (ptep_set_access_flags(vma, address, page_table, entry,1))
entry 1843 mm/memory.c update_mmu_cache(vma, address, entry);
entry 1880 mm/memory.c entry = mk_pte(new_page, vma->vm_page_prot);
entry 1881 mm/memory.c entry = maybe_mkwrite(pte_mkdirty(entry), vma);
entry 1889 mm/memory.c set_pte_at(mm, address, page_table, entry);
entry 1890 mm/memory.c update_mmu_cache(vma, address, entry);
entry 2256 mm/memory.c swp_entry_t entry;
entry 2263 mm/memory.c entry = pte_to_swp_entry(orig_pte);
entry 2264 mm/memory.c if (is_migration_entry(entry)) {
entry 2269 mm/memory.c page = lookup_swap_cache(entry);
entry 2272 mm/memory.c page = swapin_readahead(entry,
entry 2326 mm/memory.c swap_free(entry);
entry 2363 mm/memory.c pte_t entry;
entry 2378 mm/memory.c entry = mk_pte(page, vma->vm_page_prot);
entry 2379 mm/memory.c entry = maybe_mkwrite(pte_mkdirty(entry), vma);
entry 2387 mm/memory.c set_pte_at(mm, address, page_table, entry);
entry 2390 mm/memory.c update_mmu_cache(vma, address, entry);
entry 2424 mm/memory.c pte_t entry;
entry 2520 mm/memory.c entry = mk_pte(page, vma->vm_page_prot);
entry 2522 mm/memory.c entry = maybe_mkwrite(pte_mkdirty(entry), vma);
entry 2523 mm/memory.c set_pte_at(mm, address, page_table, entry);
entry 2538 mm/memory.c update_mmu_cache(vma, address, entry);
entry 2627 mm/memory.c pte_t entry;
entry 2630 mm/memory.c entry = *pte;
entry 2631 mm/memory.c if (!pte_present(entry)) {
entry 2632 mm/memory.c if (pte_none(entry)) {
entry 2636 mm/memory.c pte, pmd, write_access, entry);
entry 2641 mm/memory.c if (pte_file(entry))
entry 2643 mm/memory.c pte, pmd, write_access, entry);
entry 2645 mm/memory.c pte, pmd, write_access, entry);
entry 2650 mm/memory.c if (unlikely(!pte_same(*pte, entry)))
entry 2653 mm/memory.c if (!pte_write(entry))
entry 2655 mm/memory.c pte, pmd, ptl, entry);
entry 2656 mm/memory.c entry = pte_mkdirty(entry);
entry 2658 mm/memory.c entry = pte_mkyoung(entry);
entry 2659 mm/memory.c if (ptep_set_access_flags(vma, address, pte, entry, write_access)) {
entry 2660 mm/memory.c update_mmu_cache(vma, address, entry);
entry 127 mm/migrate.c swp_entry_t entry;
entry 163 mm/migrate.c entry = pte_to_swp_entry(pte);
entry 165 mm/migrate.c if (!is_migration_entry(entry) || migration_entry_to_page(entry) != old)
entry 184 mm/migrate.c if (is_write_migration_entry(entry))
entry 274 mm/migrate.c swp_entry_t entry;
entry 282 mm/migrate.c entry = pte_to_swp_entry(pte);
entry 283 mm/migrate.c if (!is_migration_entry(entry))
entry 286 mm/migrate.c page = migration_entry_to_page(entry);
entry 122 mm/mincore.c swp_entry_t entry = pte_to_swp_entry(pte);
entry 123 mm/mincore.c if (is_migration_entry(entry)) {
entry 128 mm/mincore.c pgoff = entry.val;
entry 64 mm/mprotect.c swp_entry_t entry = pte_to_swp_entry(oldpte);
entry 66 mm/mprotect.c if (is_write_migration_entry(entry)) {
entry 71 mm/mprotect.c make_migration_entry_read(&entry);
entry 73 mm/mprotect.c swp_entry_to_pte(entry));
entry 30 mm/page_io.c swp_entry_t entry = { .val = index, };
entry 32 mm/page_io.c sis = get_swap_info_struct(swp_type(entry));
entry 33 mm/page_io.c bio->bi_sector = map_swap_page(sis, swp_offset(entry)) *
entry 462 mm/rmap.c pte_t entry;
entry 465 mm/rmap.c entry = ptep_clear_flush_notify(vma, address, pte);
entry 466 mm/rmap.c entry = pte_wrprotect(entry);
entry 467 mm/rmap.c entry = pte_mkclean(entry);
entry 468 mm/rmap.c set_pte_at(mm, address, pte, entry);
entry 738 mm/rmap.c swp_entry_t entry = { .val = page_private(page) };
entry 745 mm/rmap.c swap_duplicate(entry);
entry 761 mm/rmap.c entry = make_migration_entry(page, pte_write(pteval));
entry 764 mm/rmap.c set_pte_at(mm, address, pte, swp_entry_to_pte(entry));
entry 770 mm/rmap.c swp_entry_t entry;
entry 771 mm/rmap.c entry = make_migration_entry(page, pte_write(pteval));
entry 772 mm/rmap.c set_pte_at(mm, address, pte, swp_entry_to_pte(entry));
entry 148 mm/shmem.c kunmap_atomic(entry, KM_USER1);
entry 365 mm/shmem.c entry->val = value;
entry 367 mm/shmem.c if ((unsigned long)(entry - info->i_direct) >= SHMEM_NR_DIRECT) {
entry 368 mm/shmem.c struct page *page = kmap_atomic_to_page(entry);
entry 386 mm/shmem.c swp_entry_t *entry;
entry 392 mm/shmem.c while (!(entry = shmem_swp_entry(info, index, &page))) {
entry 423 mm/shmem.c entry = ERR_PTR(-EINVAL);
entry 434 mm/shmem.c if (info->next_index <= index && !IS_ERR(entry))
entry 436 mm/shmem.c return entry;
entry 822 mm/shmem.c if (ptr->val == entry.val)
entry 852 mm/shmem.c offset = shmem_find_swp(entry, ptr, ptr+size);
entry 891 mm/shmem.c offset = shmem_find_swp(entry, ptr, ptr+size);
entry 936 mm/shmem.c if (ptr && ptr->val == entry.val) {
entry 961 mm/shmem.c swap_free(entry);
entry 987 mm/shmem.c found = shmem_unuse_inode(info, entry, page);
entry 1002 mm/shmem.c swp_entry_t *entry, swap;
entry 1035 mm/shmem.c entry = shmem_swp_entry(info, index, NULL);
entry 1036 mm/shmem.c if (entry->val) {
entry 1041 mm/shmem.c free_swap_and_cache(*entry);
entry 1042 mm/shmem.c shmem_swp_set(info, entry, 0);
entry 1048 mm/shmem.c shmem_swp_set(info, entry, swap.val);
entry 1049 mm/shmem.c shmem_swp_unmap(entry);
entry 1070 mm/shmem.c shmem_swp_unmap(entry);
entry 1124 mm/shmem.c page = swapin_readahead(entry, gfp, &pvma, 0);
entry 1154 mm/shmem.c return swapin_readahead(entry, gfp, NULL, 0);
entry 1186 mm/shmem.c swp_entry_t *entry;
entry 1225 mm/shmem.c entry = shmem_swp_alloc(info, idx, sgp);
entry 1226 mm/shmem.c if (IS_ERR(entry)) {
entry 1228 mm/shmem.c error = PTR_ERR(entry);
entry 1231 mm/shmem.c swap = *entry;
entry 1237 mm/shmem.c shmem_swp_unmap(entry);
entry 1247 mm/shmem.c entry = shmem_swp_alloc(info, idx, sgp);
entry 1248 mm/shmem.c if (IS_ERR(entry))
entry 1249 mm/shmem.c error = PTR_ERR(entry);
entry 1251 mm/shmem.c if (entry->val == swap.val)
entry 1253 mm/shmem.c shmem_swp_unmap(entry);
entry 1267 mm/shmem.c shmem_swp_unmap(entry);
entry 1274 mm/shmem.c shmem_swp_unmap(entry);
entry 1282 mm/shmem.c shmem_swp_unmap(entry);
entry 1291 mm/shmem.c shmem_swp_set(info, entry, 0);
entry 1292 mm/shmem.c shmem_swp_unmap(entry);
entry 1305 mm/shmem.c shmem_swp_set(info, entry, 0);
entry 1306 mm/shmem.c shmem_swp_unmap(entry);
entry 1313 mm/shmem.c shmem_swp_unmap(entry);
entry 1327 mm/shmem.c shmem_swp_unmap(entry);
entry 1339 mm/shmem.c shmem_swp_unmap(entry);
entry 1383 mm/shmem.c entry = shmem_swp_alloc(info, idx, sgp);
entry 1384 mm/shmem.c if (IS_ERR(entry))
entry 1385 mm/shmem.c error = PTR_ERR(entry);
entry 1387 mm/shmem.c swap = *entry;
entry 1388 mm/shmem.c shmem_swp_unmap(entry);
entry 269 mm/slab.c void *entry[]; /*
entry 982 mm/slab.c memcpy(to->entry + to->avail, from->entry + from->avail -nr,
entry 1080 mm/slab.c free_block(cachep, ac->entry, ac->avail, node);
entry 1146 mm/slab.c alien->entry[alien->avail++] = objp;
entry 1182 mm/slab.c free_block(cachep, nc->entry, nc->avail, node);
entry 1191 mm/slab.c free_block(cachep, shared->entry,
entry 2438 mm/slab.c free_block(cachep, ac->entry, ac->avail, node);
entry 2979 mm/slab.c struct list_head *entry;
entry 2982 mm/slab.c entry = l3->slabs_partial.next;
entry 2983 mm/slab.c if (entry == &l3->slabs_partial) {
entry 2985 mm/slab.c entry = l3->slabs_free.next;
entry 2986 mm/slab.c if (entry == &l3->slabs_free)
entry 2990 mm/slab.c slabp = list_entry(entry, struct slab, list);
entry 3006 mm/slab.c ac->entry[ac->avail++] = slab_get_obj(cachep, slabp,
entry 3037 mm/slab.c return ac->entry[--ac->avail];
entry 3192 mm/slab.c objp = ac->entry[--ac->avail];
entry 3308 mm/slab.c struct list_head *entry;
entry 3320 mm/slab.c entry = l3->slabs_partial.next;
entry 3321 mm/slab.c if (entry == &l3->slabs_partial) {
entry 3323 mm/slab.c entry = l3->slabs_free.next;
entry 3324 mm/slab.c if (entry == &l3->slabs_free)
entry 3328 mm/slab.c slabp = list_entry(entry, struct slab, list);
entry 3541 mm/slab.c memcpy(&(shared_array->entry[shared_array->avail]),
entry 3542 mm/slab.c ac->entry, sizeof(void *) * batchcount);
entry 3548 mm/slab.c free_block(cachep, ac->entry, batchcount, node);
entry 3570 mm/slab.c memmove(ac->entry, &(ac->entry[batchcount]), sizeof(void *)*ac->avail);
entry 3596 mm/slab.c ac->entry[ac->avail++] = objp;
entry 3601 mm/slab.c ac->entry[ac->avail++] = objp;
entry 3841 mm/slab.c free_block(cachep, shared->entry,
entry 3945 mm/slab.c free_block(cachep, ccold->entry, ccold->avail, cpu_to_node(i));
entry 4027 mm/slab.c free_block(cachep, ac->entry, tofree, node);
entry 4029 mm/slab.c memmove(ac->entry, &(ac->entry[tofree]),
entry 76 mm/sparse-vmemmap.c pte_t entry;
entry 80 mm/sparse-vmemmap.c entry = pfn_pte(__pa(p) >> PAGE_SHIFT, PAGE_KERNEL);
entry 81 mm/sparse-vmemmap.c set_pte_at(&init_mm, addr, pte, entry);
entry 82 mm/swap_state.c set_page_private(page, entry.val);
entry 86 mm/swap_state.c entry.val, page);
entry 133 mm/swap_state.c swp_entry_t entry;
entry 140 mm/swap_state.c entry = get_swap_page();
entry 141 mm/swap_state.c if (!entry.val)
entry 155 mm/swap_state.c err = add_to_swap_cache(page, entry,
entry 164 mm/swap_state.c swap_free(entry);
entry 168 mm/swap_state.c swap_free(entry);
entry 182 mm/swap_state.c swp_entry_t entry;
entry 184 mm/swap_state.c entry.val = page_private(page);
entry 190 mm/swap_state.c swap_free(entry);
entry 251 mm/swap_state.c page = find_get_page(&swapper_space, entry.val);
entry 278 mm/swap_state.c found_page = find_get_page(&swapper_space, entry.val);
entry 294 mm/swap_state.c if (!swap_duplicate(entry))
entry 306 mm/swap_state.c err = add_to_swap_cache(new_page, entry, gfp_mask & GFP_KERNEL);
entry 316 mm/swap_state.c swap_free(entry);
entry 358 mm/swap_state.c nr_pages = valid_swaphandles(entry, &offset);
entry 361 mm/swap_state.c page = read_swap_cache_async(swp_entry(swp_type(entry), offset),
entry 368 mm/swap_state.c return read_swap_cache_async(entry, gfp_mask, vma, addr);
entry 62 mm/swapfile.c swp_entry_t entry;
entry 65 mm/swapfile.c entry.val = page_private(page);
entry 67 mm/swapfile.c struct block_device *bdev = swap_info[swp_type(entry)].bdev;
entry 242 mm/swapfile.c if (!entry.val)
entry 244 mm/swapfile.c type = swp_type(entry);
entry 250 mm/swapfile.c offset = swp_offset(entry);
entry 259 mm/swapfile.c printk(KERN_ERR "swap_free: %s%08lx\n", Unused_offset, entry.val);
entry 262 mm/swapfile.c printk(KERN_ERR "swap_free: %s%08lx\n", Bad_offset, entry.val);
entry 265 mm/swapfile.c printk(KERN_ERR "swap_free: %s%08lx\n", Unused_file, entry.val);
entry 268 mm/swapfile.c printk(KERN_ERR "swap_free: %s%08lx\n", Bad_file, entry.val);
entry 302 mm/swapfile.c p = swap_info_get(entry);
entry 304 mm/swapfile.c swap_entry_free(p, swp_offset(entry));
entry 316 mm/swapfile.c swp_entry_t entry;
entry 318 mm/swapfile.c entry.val = page_private(page);
entry 319 mm/swapfile.c p = swap_info_get(entry);
entry 322 mm/swapfile.c count = p->swap_map[swp_offset(entry)] - 1;
entry 351 mm/swapfile.c swp_entry_t entry;
entry 363 mm/swapfile.c entry.val = page_private(page);
entry 364 mm/swapfile.c p = swap_info_get(entry);
entry 370 mm/swapfile.c if (p->swap_map[swp_offset(entry)] == 1) {
entry 383 mm/swapfile.c swap_free(entry);
entry 399 mm/swapfile.c if (is_migration_entry(entry))
entry 402 mm/swapfile.c p = swap_info_get(entry);
entry 404 mm/swapfile.c if (swap_entry_free(p, swp_offset(entry)) == 1) {
entry 405 mm/swapfile.c page = find_get_page(&swapper_space, entry.val);
entry 522 mm/swapfile.c if (unlikely(!pte_same(*pte, swp_entry_to_pte(entry)))) {
entry 534 mm/swapfile.c swap_free(entry);
entry 549 mm/swapfile.c pte_t swp_pte = swp_entry_to_pte(entry);
entry 570 mm/swapfile.c ret = unuse_pte(vma, pmd, addr, entry, page);
entry 594 mm/swapfile.c ret = unuse_pte_range(vma, pmd, addr, next, entry, page);
entry 614 mm/swapfile.c ret = unuse_pmd_range(vma, pud, addr, next, entry, page);
entry 644 mm/swapfile.c ret = unuse_pud_range(vma, pgd, addr, next, entry, page);
entry 668 mm/swapfile.c if (vma->anon_vma && (ret = unuse_vma(vma, entry, page)))
entry 725 mm/swapfile.c swp_entry_t entry;
entry 766 mm/swapfile.c entry = swp_entry(type, i);
entry 767 mm/swapfile.c page = read_swap_cache_async(entry,
entry 813 mm/swapfile.c shmem = shmem_unuse(entry, page);
entry 815 mm/swapfile.c retval = unuse_mm(start_mm, entry, page);
entry 843 mm/swapfile.c shmem = shmem_unuse(entry, page);
entry 845 mm/swapfile.c retval = unuse_mm(mm, entry, page);
entry 1196 mm/swapfile.c swp_entry_t entry = { .val = page_private(page) };
entry 1199 mm/swapfile.c sis = get_swap_info_struct(swp_type(entry));
entry 1765 mm/swapfile.c if (is_migration_entry(entry))
entry 1768 mm/swapfile.c type = swp_type(entry);
entry 1772 mm/swapfile.c offset = swp_offset(entry);
entry 1791 mm/swapfile.c printk(KERN_ERR "swap_dup: %s%08lx\n", Bad_file, entry.val);
entry 1816 mm/swapfile.c si = &swap_info[swp_type(entry)];
entry 1817 mm/swapfile.c target = swp_offset(entry);
entry 256 net/802/tr.c struct rif_cache *entry;
entry 280 net/802/tr.c for(entry=rif_table[hash];entry && memcmp(&(entry->addr[0]),&(trh->daddr[0]),TR_ALEN);entry=entry->next);
entry 285 net/802/tr.c if(entry)
entry 293 net/802/tr.c if(!entry->local_ring && (ntohs(entry->rcf) & TR_RCF_LEN_MASK) >> 8)
entry 295 net/802/tr.c trh->rcf=entry->rcf;
entry 296 net/802/tr.c memcpy(&trh->rseg[0],&entry->rseg[0],8*sizeof(unsigned short));
entry 302 net/802/tr.c printk("entry found with rcf %04x\n", entry->rcf);
entry 306 net/802/tr.c printk("entry found but without rcf length, local=%02x\n", entry->local_ring);
entry 309 net/802/tr.c entry->last_used=jiffies;
entry 348 net/802/tr.c struct rif_cache *entry;
entry 368 net/802/tr.c for(entry=rif_table[hash];entry && memcmp(&(entry->addr[0]),&(trh->saddr[0]),TR_ALEN);entry=entry->next);
entry 370 net/802/tr.c if(entry==NULL)
entry 384 net/802/tr.c entry=kmalloc(sizeof(struct rif_cache),GFP_ATOMIC);
entry 386 net/802/tr.c if(!entry)
entry 393 net/802/tr.c memcpy(&(entry->addr[0]),&(trh->saddr[0]),TR_ALEN);
entry 394 net/802/tr.c entry->iface = dev->ifindex;
entry 395 net/802/tr.c entry->next=rif_table[hash];
entry 396 net/802/tr.c entry->last_used=jiffies;
entry 397 net/802/tr.c rif_table[hash]=entry;
entry 401 net/802/tr.c entry->rcf = trh->rcf & htons((unsigned short)~TR_RCF_BROADCAST_MASK);
entry 402 net/802/tr.c memcpy(&(entry->rseg[0]),&(trh->rseg[0]),8*sizeof(unsigned short));
entry 403 net/802/tr.c entry->local_ring = 0;
entry 407 net/802/tr.c entry->local_ring = 1;
entry 415 net/802/tr.c if (!entry->local_ring)
entry 416 net/802/tr.c if (entry->rcf != (trh->rcf & htons((unsigned short)~TR_RCF_BROADCAST_MASK)) &&
entry 426 net/802/tr.c entry->rcf = trh->rcf & htons((unsigned short)~TR_RCF_BROADCAST_MASK);
entry 427 net/802/tr.c memcpy(&(entry->rseg[0]),&(trh->rseg[0]),8*sizeof(unsigned short));
entry 429 net/802/tr.c entry->last_used=jiffies;
entry 447 net/802/tr.c struct rif_cache *entry, **pentry;
entry 450 net/802/tr.c while((entry=*pentry) != NULL) {
entry 452 net/802/tr.c = entry->last_used + sysctl_tr_rif_timeout;
entry 455 net/802/tr.c *pentry = entry->next;
entry 456 net/802/tr.c kfree(entry);
entry 458 net/802/tr.c pentry = &entry->next;
entry 482 net/802/tr.c struct rif_cache *entry;
entry 486 net/802/tr.c for(entry = rif_table[i]; entry; entry = entry->next) {
entry 488 net/802/tr.c return entry;
entry 534 net/802/tr.c struct rif_cache *entry = v;
entry 541 net/802/tr.c struct net_device *dev = dev_get_by_index(&init_net, entry->iface);
entry 542 net/802/tr.c long ttl = (long) (entry->last_used + sysctl_tr_rif_timeout)
entry 547 net/802/tr.c print_mac(mac, entry->addr),
entry 550 net/802/tr.c if (entry->local_ring)
entry 554 net/802/tr.c seq_printf(seq, "%04X", ntohs(entry->rcf));
entry 555 net/802/tr.c rcf_len = ((ntohs(entry->rcf) & TR_RCF_LEN_MASK)>>8)-2;
entry 560 net/802/tr.c segment=ntohs(entry->rseg[j-1])>>4;
entry 564 net/802/tr.c segment=ntohs(entry->rseg[j])>>4;
entry 565 net/802/tr.c brdgnmb=ntohs(entry->rseg[j-1])&0x00f;
entry 486 net/appletalk/aarp.c struct aarp_entry *entry;
entry 501 net/appletalk/aarp.c entry = aarp_alloc();
entry 503 net/appletalk/aarp.c if (!entry)
entry 506 net/appletalk/aarp.c entry->expires_at = -1;
entry 507 net/appletalk/aarp.c entry->status = ATIF_PROBE;
entry 508 net/appletalk/aarp.c entry->target_addr.s_node = sa->s_node;
entry 509 net/appletalk/aarp.c entry->target_addr.s_net = sa->s_net;
entry 510 net/appletalk/aarp.c entry->dev = atif->dev;
entry 515 net/appletalk/aarp.c entry->next = proxies[hash];
entry 516 net/appletalk/aarp.c proxies[hash] = entry;
entry 526 net/appletalk/aarp.c if (entry->status & ATIF_PROBE_FAIL)
entry 530 net/appletalk/aarp.c if (entry->status & ATIF_PROBE_FAIL) {
entry 531 net/appletalk/aarp.c entry->expires_at = jiffies - 1; /* free the entry */
entry 534 net/appletalk/aarp.c entry->status &= ~ATIF_PROBE;
entry 916 net/appletalk/aarp.c struct aarp_entry *entry;
entry 920 net/appletalk/aarp.c for (entry = table[ct]; entry; entry = entry->next) {
entry 924 net/appletalk/aarp.c return entry;
entry 957 net/appletalk/aarp.c struct aarp_entry *entry = v;
entry 964 net/appletalk/aarp.c entry = iter_next(iter, NULL);
entry 967 net/appletalk/aarp.c else if (entry->next)
entry 968 net/appletalk/aarp.c entry = entry->next;
entry 973 net/appletalk/aarp.c entry = iter_next(iter, NULL);
entry 975 net/appletalk/aarp.c return entry;
entry 996 net/appletalk/aarp.c struct aarp_entry *entry = v;
entry 1006 net/appletalk/aarp.c ntohs(entry->target_addr.s_net),
entry 1007 net/appletalk/aarp.c (unsigned int) entry->target_addr.s_node,
entry 1008 net/appletalk/aarp.c entry->dev ? entry->dev->name : "????");
entry 1009 net/appletalk/aarp.c seq_printf(seq, "%s", print_mac(mac, entry->hwaddr));
entry 1011 net/appletalk/aarp.c dt2str((long)entry->expires_at - (long)now));
entry 1014 net/appletalk/aarp.c dt2str(now - entry->last_sent),
entry 1015 net/appletalk/aarp.c entry->xmit_count);
entry 57 net/atm/addr.c list_for_each_entry_safe(this, p, head, entry) {
entry 58 net/atm/addr.c list_del(&this->entry);
entry 82 net/atm/addr.c list_for_each_entry(this, head, entry) {
entry 94 net/atm/addr.c list_add(&this->entry, head);
entry 117 net/atm/addr.c list_for_each_entry(this, head, entry) {
entry 119 net/atm/addr.c list_del(&this->entry);
entry 145 net/atm/addr.c list_for_each_entry(this, head, entry)
entry 152 net/atm/addr.c list_for_each_entry(this, head, entry)
entry 44 net/atm/atm_sysfs.c list_for_each_entry(aaddr, &adev->local, entry) {
entry 74 net/atm/clip.c pr_debug("link_vcc %p to entry %p (neigh %p)\n", clip_vcc, entry,
entry 75 net/atm/clip.c entry->neigh);
entry 76 net/atm/clip.c clip_vcc->entry = entry;
entry 78 net/atm/clip.c clip_vcc->next = entry->vccs;
entry 79 net/atm/clip.c entry->vccs = clip_vcc;
entry 80 net/atm/clip.c entry->neigh->used = jiffies;
entry 85 net/atm/clip.c struct atmarp_entry *entry = clip_vcc->entry;
entry 88 net/atm/clip.c if (!entry) {
entry 92 net/atm/clip.c netif_tx_lock_bh(entry->neigh->dev); /* block clip_start_xmit() */
entry 93 net/atm/clip.c entry->neigh->used = jiffies;
entry 94 net/atm/clip.c for (walk = &entry->vccs; *walk; walk = &(*walk)->next)
entry 99 net/atm/clip.c clip_vcc->entry = NULL;
entry 101 net/atm/clip.c netif_wake_queue(entry->neigh->dev);
entry 102 net/atm/clip.c if (entry->vccs)
entry 104 net/atm/clip.c entry->expires = jiffies - 1;
entry 106 net/atm/clip.c error = neigh_update(entry->neigh, NULL, NUD_NONE,
entry 114 net/atm/clip.c "0x%p)\n", entry, clip_vcc);
entry 116 net/atm/clip.c netif_tx_unlock_bh(entry->neigh->dev);
entry 122 net/atm/clip.c struct atmarp_entry *entry = NEIGH2ENTRY(n);
entry 125 net/atm/clip.c for (cv = entry->vccs; cv; cv = cv->next) {
entry 130 net/atm/clip.c cv, cv->vcc, entry);
entry 135 net/atm/clip.c if (entry->vccs || time_before(jiffies, entry->expires))
entry 194 net/atm/clip.c if (clip_vcc->entry)
entry 201 net/atm/clip.c skb->dev = clip_vcc->entry ? clip_vcc->entry->neigh->dev : clip_devs;
entry 282 net/atm/clip.c struct atmarp_entry *entry = NEIGH2ENTRY(neigh);
entry 287 net/atm/clip.c pr_debug("clip_constructor (neigh %p, entry %p)\n", neigh, entry);
entry 288 net/atm/clip.c neigh->type = inet_addr_type(&init_net, entry->ip);
entry 307 net/atm/clip.c entry->neigh = neigh;
entry 308 net/atm/clip.c entry->vccs = NULL;
entry 309 net/atm/clip.c entry->expires = jiffies - 1;
entry 366 net/atm/clip.c struct atmarp_entry *entry;
entry 392 net/atm/clip.c entry = NEIGH2ENTRY(skb->dst->neighbour);
entry 393 net/atm/clip.c if (!entry->vccs) {
entry 394 net/atm/clip.c if (time_after(jiffies, entry->expires)) {
entry 396 net/atm/clip.c entry->expires = jiffies + ATMARP_RETRY_DELAY * HZ;
entry 397 net/atm/clip.c to_atmarpd(act_need, PRIV(dev)->number, entry->ip);
entry 399 net/atm/clip.c if (entry->neigh->arp_queue.qlen < ATMARP_MAX_UNRES_PACKETS)
entry 400 net/atm/clip.c skb_queue_tail(&entry->neigh->arp_queue, skb);
entry 407 net/atm/clip.c pr_debug("neigh %p, vccs %p\n", entry, entry->vccs);
entry 408 net/atm/clip.c ATM_SKB(skb)->vcc = vcc = entry->vccs->vcc;
entry 410 net/atm/clip.c if (entry->vccs->encap) {
entry 419 net/atm/clip.c entry->vccs->last_use = jiffies;
entry 421 net/atm/clip.c old = xchg(&entry->vccs->xoff, 1); /* assume XOFF ... */
entry 430 net/atm/clip.c entry->vccs->xoff = 0;
entry 436 net/atm/clip.c if (!entry->vccs->xoff)
entry 467 net/atm/clip.c clip_vcc->entry = NULL;
entry 517 net/atm/clip.c struct atmarp_entry *entry;
entry 529 net/atm/clip.c if (!clip_vcc->entry) {
entry 544 net/atm/clip.c entry = NEIGH2ENTRY(neigh);
entry 545 net/atm/clip.c if (entry != clip_vcc->entry) {
entry 546 net/atm/clip.c if (!clip_vcc->entry)
entry 552 net/atm/clip.c link_vcc(clip_vcc, entry);
entry 816 net/atm/clip.c exp = entry->neigh->used;
entry 826 net/atm/clip.c NIPQUAD(entry->ip));
entry 833 net/atm/clip.c if (time_before(jiffies, entry->expires))
entry 837 net/atm/clip.c atomic_read(&entry->neigh->refcnt));
entry 106 net/atm/lec.c atomic_inc(&entry->usage);
entry 111 net/atm/lec.c if (atomic_dec_and_test(&entry->usage))
entry 112 net/atm/lec.c kfree(entry);
entry 258 net/atm/lec.c struct lec_arp_table *entry;
entry 368 net/atm/lec.c entry = NULL;
entry 369 net/atm/lec.c vcc = lec_arp_resolve(priv, dst, is_rdesc, &entry);
entry 371 net/atm/lec.c vcc, vcc ? vcc->flags : 0, entry);
entry 373 net/atm/lec.c if (entry && (entry->tx_wait.qlen < LEC_UNRES_QUE_LEN)) {
entry 380 net/atm/lec.c skb_queue_tail(&entry->tx_wait, skb);
entry 398 net/atm/lec.c while (entry && (skb2 = skb_dequeue(&entry->tx_wait))) {
entry 426 net/atm/lec.c if (entry)
entry 427 net/atm/lec.c lec_arp_put(entry);
entry 454 net/atm/lec.c struct lec_arp_table *entry;
entry 486 net/atm/lec.c entry = lec_arp_find(priv, mesg->content.normal.mac_addr);
entry 487 net/atm/lec.c lec_arp_remove(priv, entry);
entry 768 net/atm/lec.c struct lec_arp_table *entry;
entry 805 net/atm/lec.c entry = lec_arp_find(priv, src);
entry 806 net/atm/lec.c if (entry && entry->vcc != vcc) {
entry 807 net/atm/lec.c lec_arp_remove(priv, entry);
entry 808 net/atm/lec.c lec_arp_put(entry);
entry 990 net/atm/lec.c seq_printf(seq, "%2.2x", entry->mac_addr[i] & 0xff);
entry 993 net/atm/lec.c seq_printf(seq, "%2.2x", entry->atm_addr[i] & 0xff);
entry 994 net/atm/lec.c seq_printf(seq, " %s %4.4x", lec_arp_get_status_string(entry->status),
entry 995 net/atm/lec.c entry->flags & 0xffff);
entry 996 net/atm/lec.c if (entry->vcc)
entry 997 net/atm/lec.c seq_printf(seq, "%3d %3d ", entry->vcc->vpi, entry->vcc->vci);
entry 1000 net/atm/lec.c if (entry->recv_vcc) {
entry 1001 net/atm/lec.c seq_printf(seq, " %3d %3d", entry->recv_vcc->vpi,
entry 1002 net/atm/lec.c entry->recv_vcc->vci);
entry 1163 net/atm/lec.c struct lec_arp_table *entry = hlist_entry(state->node, struct lec_arp_table, next);
entry 1166 net/atm/lec.c lec_info(seq, entry);
entry 1373 net/atm/lec.c struct lec_arp_table *entry = lec_arp_find(priv, mac_addr);
entry 1375 net/atm/lec.c if (entry == NULL)
entry 1378 net/atm/lec.c kfree(entry->tlvs);
entry 1380 net/atm/lec.c entry->tlvs = kmemdup(tlvs, sizeoftlvs, GFP_KERNEL);
entry 1381 net/atm/lec.c if (entry->tlvs == NULL)
entry 1383 net/atm/lec.c entry->sizeoftlvs = sizeoftlvs;
entry 1455 net/atm/lec.c if (entry->vcc) {
entry 1456 net/atm/lec.c struct atm_vcc *vcc = entry->vcc;
entry 1465 net/atm/lec.c vcc->push = entry->old_push;
entry 1467 net/atm/lec.c entry->vcc = NULL;
entry 1469 net/atm/lec.c if (entry->recv_vcc) {
entry 1470 net/atm/lec.c entry->recv_vcc->push = entry->old_recv_push;
entry 1471 net/atm/lec.c vcc_release_async(entry->recv_vcc, -EPIPE);
entry 1472 net/atm/lec.c entry->recv_vcc = NULL;
entry 1485 net/atm/lec.c tmp = &priv->lec_arp_tables[HASH(entry->mac_addr[ETH_ALEN - 1])];
entry 1486 net/atm/lec.c hlist_add_head(&entry->next, tmp);
entry 1489 net/atm/lec.c 0xff & entry->mac_addr[0], 0xff & entry->mac_addr[1],
entry 1490 net/atm/lec.c 0xff & entry->mac_addr[2], 0xff & entry->mac_addr[3],
entry 1491 net/atm/lec.c 0xff & entry->mac_addr[4], 0xff & entry->mac_addr[5]);
entry 1501 net/atm/lec.c struct lec_arp_table *entry;
entry 1517 net/atm/lec.c hlist_for_each_entry(entry, node, &priv->lec_arp_tables[i], next) {
entry 1519 net/atm/lec.c entry->atm_addr, ATM_ESA_LEN) == 0) {
entry 1697 net/atm/lec.c struct lec_arp_table *entry;
entry 1708 net/atm/lec.c hlist_for_each_entry_safe(entry, node, next, &priv->lec_arp_tables[i], next) {
entry 1709 net/atm/lec.c lec_arp_remove(priv, entry);
entry 1710 net/atm/lec.c lec_arp_put(entry);
entry 1715 net/atm/lec.c hlist_for_each_entry_safe(entry, node, next, &priv->lec_arp_empty_ones, next) {
entry 1716 net/atm/lec.c del_timer_sync(&entry->timer);
entry 1717 net/atm/lec.c lec_arp_clear_vccs(entry);
entry 1718 net/atm/lec.c hlist_del(&entry->next);
entry 1719 net/atm/lec.c lec_arp_put(entry);
entry 1723 net/atm/lec.c hlist_for_each_entry_safe(entry, node, next, &priv->lec_no_forward, next) {
entry 1724 net/atm/lec.c del_timer_sync(&entry->timer);
entry 1725 net/atm/lec.c lec_arp_clear_vccs(entry);
entry 1726 net/atm/lec.c hlist_del(&entry->next);
entry 1727 net/atm/lec.c lec_arp_put(entry);
entry 1731 net/atm/lec.c hlist_for_each_entry_safe(entry, node, next, &priv->mcast_fwds, next) {
entry 1733 net/atm/lec.c lec_arp_clear_vccs(entry);
entry 1734 net/atm/lec.c hlist_del(&entry->next);
entry 1735 net/atm/lec.c lec_arp_put(entry);
entry 1750 net/atm/lec.c struct lec_arp_table *entry;
entry 1757 net/atm/lec.c hlist_for_each_entry(entry, node, head, next) {
entry 1758 net/atm/lec.c if (!compare_ether_addr(mac_addr, entry->mac_addr)) {
entry 1759 net/atm/lec.c return entry;
entry 1789 net/atm/lec.c struct lec_arp_table *entry;
entry 1791 net/atm/lec.c entry = (struct lec_arp_table *)data;
entry 1794 net/atm/lec.c if (entry->status == ESI_ARP_PENDING) {
entry 1795 net/atm/lec.c if (entry->no_tries <= entry->priv->max_retry_count) {
entry 1796 net/atm/lec.c if (entry->is_rdesc)
entry 1797 net/atm/lec.c send_to_lecd(entry->priv, l_rdesc_arp_xmt,
entry 1798 net/atm/lec.c entry->mac_addr, NULL, NULL);
entry 1800 net/atm/lec.c send_to_lecd(entry->priv, l_arp_xmt,
entry 1801 net/atm/lec.c entry->mac_addr, NULL, NULL);
entry 1802 net/atm/lec.c entry->no_tries++;
entry 1804 net/atm/lec.c mod_timer(&entry->timer, jiffies + (1 * HZ));
entry 1852 net/atm/lec.c struct lec_arp_table *entry;
entry 1862 net/atm/lec.c hlist_for_each_entry_safe(entry, node, next, &priv->lec_arp_tables[i], next) {
entry 1863 net/atm/lec.c if ((entry->flags) & LEC_REMOTE_FLAG &&
entry 1870 net/atm/lec.c now, entry->last_used, time_to_check);
entry 1871 net/atm/lec.c if (time_after(now, entry->last_used + time_to_check)
entry 1872 net/atm/lec.c && !(entry->flags & LEC_PERMANENT_FLAG)
entry 1873 net/atm/lec.c && !(entry->mac_addr[0] & 0x01)) { /* LANE2: 7.1.20 */
entry 1876 net/atm/lec.c lec_arp_remove(priv, entry);
entry 1877 net/atm/lec.c lec_arp_put(entry);
entry 1880 net/atm/lec.c if ((entry->status == ESI_VC_PENDING ||
entry 1881 net/atm/lec.c entry->status == ESI_ARP_PENDING)
entry 1883 net/atm/lec.c entry->timestamp +
entry 1886 net/atm/lec.c entry->timestamp = jiffies;
entry 1887 net/atm/lec.c entry->packets_flooded = 0;
entry 1888 net/atm/lec.c if (entry->status == ESI_VC_PENDING)
entry 1890 net/atm/lec.c entry->mac_addr,
entry 1891 net/atm/lec.c entry->atm_addr,
entry 1894 net/atm/lec.c if (entry->status == ESI_FLUSH_PENDING
entry 1896 net/atm/lec.c time_after_eq(now, entry->timestamp +
entry 1899 net/atm/lec.c struct atm_vcc *vcc = entry->vcc;
entry 1901 net/atm/lec.c lec_arp_hold(entry);
entry 1903 net/atm/lec.c while ((skb = skb_dequeue(&entry->tx_wait)) != NULL)
entry 1904 net/atm/lec.c lec_send(vcc, skb, entry->priv);
entry 1905 net/atm/lec.c entry->last_used = jiffies;
entry 1906 net/atm/lec.c entry->status = ESI_FORWARD_DIRECT;
entry 1907 net/atm/lec.c lec_arp_put(entry);
entry 1927 net/atm/lec.c struct lec_arp_table *entry;
entry 1944 net/atm/lec.c entry = lec_arp_find(priv, mac_to_find);
entry 1946 net/atm/lec.c if (entry) {
entry 1947 net/atm/lec.c if (entry->status == ESI_FORWARD_DIRECT) {
entry 1949 net/atm/lec.c entry->last_used = jiffies;
entry 1950 net/atm/lec.c lec_arp_hold(entry);
entry 1951 net/atm/lec.c *ret_entry = entry;
entry 1952 net/atm/lec.c found = entry->vcc;
entry 1959 net/atm/lec.c if (entry->status == ESI_ARP_PENDING) {
entry 1960 net/atm/lec.c entry->no_tries = 0;
entry 1968 net/atm/lec.c if (entry->status != ESI_FLUSH_PENDING &&
entry 1969 net/atm/lec.c entry->packets_flooded <
entry 1971 net/atm/lec.c entry->packets_flooded++;
entry 1981 net/atm/lec.c lec_arp_hold(entry);
entry 1982 net/atm/lec.c *ret_entry = entry;
entry 1983 net/atm/lec.c pr_debug("lec: entry->status %d entry->vcc %p\n", entry->status,
entry 1984 net/atm/lec.c entry->vcc);
entry 1988 net/atm/lec.c entry = make_entry(priv, mac_to_find);
entry 1990 net/atm/lec.c if (!entry) {
entry 1994 net/atm/lec.c lec_arp_add(priv, entry);
entry 1996 net/atm/lec.c entry->packets_flooded = 1;
entry 1997 net/atm/lec.c entry->status = ESI_ARP_PENDING;
entry 1998 net/atm/lec.c entry->no_tries = 1;
entry 1999 net/atm/lec.c entry->last_used = entry->timestamp = jiffies;
entry 2000 net/atm/lec.c entry->is_rdesc = is_rdesc;
entry 2001 net/atm/lec.c if (entry->is_rdesc)
entry 2006 net/atm/lec.c entry->timer.expires = jiffies + (1 * HZ);
entry 2007 net/atm/lec.c entry->timer.function = lec_arp_expire_arp;
entry 2008 net/atm/lec.c add_timer(&entry->timer);
entry 2023 net/atm/lec.c struct lec_arp_table *entry;
entry 2029 net/atm/lec.c hlist_for_each_entry_safe(entry, node, next, &priv->lec_arp_tables[i], next) {
entry 2030 net/atm/lec.c if (!memcmp(atm_addr, entry->atm_addr, ATM_ESA_LEN)
entry 2032 net/atm/lec.c !(entry->flags & LEC_PERMANENT_FLAG))) {
entry 2033 net/atm/lec.c lec_arp_remove(priv, entry);
entry 2034 net/atm/lec.c lec_arp_put(entry);
entry 2054 net/atm/lec.c struct lec_arp_table *entry, *tmp;
entry 2063 net/atm/lec.c entry = lec_arp_find(priv, mac_addr);
entry 2064 net/atm/lec.c if (entry == NULL && targetless_le_arp)
entry 2070 net/atm/lec.c hlist_for_each_entry_safe(entry, node, next, &priv->lec_arp_empty_ones, next) {
entry 2071 net/atm/lec.c if (memcmp(entry->atm_addr, atm_addr, ATM_ESA_LEN) == 0) {
entry 2072 net/atm/lec.c hlist_del(&entry->next);
entry 2073 net/atm/lec.c del_timer(&entry->timer);
entry 2079 net/atm/lec.c tmp->vcc = entry->vcc;
entry 2080 net/atm/lec.c tmp->old_push = entry->old_push;
entry 2082 net/atm/lec.c del_timer(&entry->timer);
entry 2083 net/atm/lec.c lec_arp_put(entry);
entry 2084 net/atm/lec.c entry = tmp;
entry 2086 net/atm/lec.c entry->status = ESI_FORWARD_DIRECT;
entry 2087 net/atm/lec.c memcpy(entry->mac_addr, mac_addr, ETH_ALEN);
entry 2088 net/atm/lec.c entry->last_used = jiffies;
entry 2089 net/atm/lec.c lec_arp_add(priv, entry);
entry 2092 net/atm/lec.c entry->flags |= LEC_REMOTE_FLAG;
entry 2094 net/atm/lec.c entry->flags &= ~LEC_REMOTE_FLAG;
entry 2102 net/atm/lec.c entry = lec_arp_find(priv, mac_addr);
entry 2103 net/atm/lec.c if (!entry) {
entry 2104 net/atm/lec.c entry = make_entry(priv, mac_addr);
entry 2105 net/atm/lec.c if (!entry)
entry 2107 net/atm/lec.c entry->status = ESI_UNKNOWN;
entry 2108 net/atm/lec.c lec_arp_add(priv, entry);
entry 2111 net/atm/lec.c memcpy(entry->atm_addr, atm_addr, ATM_ESA_LEN);
entry 2112 net/atm/lec.c del_timer(&entry->timer);
entry 2115 net/atm/lec.c if (entry != tmp &&
entry 2123 net/atm/lec.c entry->vcc = tmp->vcc;
entry 2124 net/atm/lec.c entry->old_push = tmp->old_push;
entry 2126 net/atm/lec.c entry->status = tmp->status;
entry 2132 net/atm/lec.c entry->flags |= LEC_REMOTE_FLAG;
entry 2134 net/atm/lec.c entry->flags &= ~LEC_REMOTE_FLAG;
entry 2135 net/atm/lec.c if (entry->status == ESI_ARP_PENDING || entry->status == ESI_UNKNOWN) {
entry 2136 net/atm/lec.c entry->status = ESI_VC_PENDING;
entry 2137 net/atm/lec.c send_to_lecd(priv, l_svc_setup, entry->mac_addr, atm_addr, NULL);
entry 2155 net/atm/lec.c struct lec_arp_table *entry;
entry 2164 net/atm/lec.c entry = lec_arp_find(priv, bus_mac);
entry 2165 net/atm/lec.c if (!entry) {
entry 2169 net/atm/lec.c memcpy(entry->atm_addr, ioc_data->atm_addr, ATM_ESA_LEN);
entry 2170 net/atm/lec.c entry->recv_vcc = vcc;
entry 2171 net/atm/lec.c entry->old_recv_push = old_push;
entry 2173 net/atm/lec.c entry = make_entry(priv, bus_mac);
entry 2174 net/atm/lec.c if (entry == NULL)
entry 2176 net/atm/lec.c del_timer(&entry->timer);
entry 2177 net/atm/lec.c memcpy(entry->atm_addr, ioc_data->atm_addr, ATM_ESA_LEN);
entry 2178 net/atm/lec.c entry->recv_vcc = vcc;
entry 2179 net/atm/lec.c entry->old_recv_push = old_push;
entry 2180 net/atm/lec.c hlist_add_head(&entry->next, &priv->mcast_fwds);
entry 2200 net/atm/lec.c entry = make_entry(priv, bus_mac);
entry 2201 net/atm/lec.c if (entry == NULL)
entry 2203 net/atm/lec.c memcpy(entry->atm_addr, ioc_data->atm_addr, ATM_ESA_LEN);
entry 2204 net/atm/lec.c memset(entry->mac_addr, 0, ETH_ALEN);
entry 2205 net/atm/lec.c entry->recv_vcc = vcc;
entry 2206 net/atm/lec.c entry->old_recv_push = old_push;
entry 2207 net/atm/lec.c entry->status = ESI_UNKNOWN;
entry 2208 net/atm/lec.c entry->timer.expires = jiffies + priv->vcc_timeout_period;
entry 2209 net/atm/lec.c entry->timer.function = lec_arp_expire_vcc;
entry 2210 net/atm/lec.c hlist_add_head(&entry->next, &priv->lec_no_forward);
entry 2211 net/atm/lec.c add_timer(&entry->timer);
entry 2229 net/atm/lec.c hlist_for_each_entry(entry, node, &priv->lec_arp_tables[i], next) {
entry 2231 net/atm/lec.c (ioc_data->atm_addr, entry->atm_addr,
entry 2235 net/atm/lec.c entry->vcc ? entry->vcc->vci : 0,
entry 2236 net/atm/lec.c entry->recv_vcc ? entry->recv_vcc->
entry 2239 net/atm/lec.c del_timer(&entry->timer);
entry 2240 net/atm/lec.c entry->vcc = vcc;
entry 2241 net/atm/lec.c entry->old_push = old_push;
entry 2242 net/atm/lec.c if (entry->status == ESI_VC_PENDING) {
entry 2245 net/atm/lec.c entry->status =
entry 2248 net/atm/lec.c entry->timestamp = jiffies;
entry 2249 net/atm/lec.c entry->status =
entry 2254 net/atm/lec.c entry->atm_addr,
entry 2284 net/atm/lec.c entry = make_entry(priv, bus_mac);
entry 2285 net/atm/lec.c if (!entry)
entry 2287 net/atm/lec.c entry->vcc = vcc;
entry 2288 net/atm/lec.c entry->old_push = old_push;
entry 2289 net/atm/lec.c memcpy(entry->atm_addr, ioc_data->atm_addr, ATM_ESA_LEN);
entry 2290 net/atm/lec.c memset(entry->mac_addr, 0, ETH_ALEN);
entry 2291 net/atm/lec.c entry->status = ESI_UNKNOWN;
entry 2292 net/atm/lec.c hlist_add_head(&entry->next, &priv->lec_arp_empty_ones);
entry 2293 net/atm/lec.c entry->timer.expires = jiffies + priv->vcc_timeout_period;
entry 2294 net/atm/lec.c entry->timer.function = lec_arp_expire_vcc;
entry 2295 net/atm/lec.c add_timer(&entry->timer);
entry 2306 net/atm/lec.c struct lec_arp_table *entry;
entry 2313 net/atm/lec.c hlist_for_each_entry(entry, node, &priv->lec_arp_tables[i], next) {
entry 2314 net/atm/lec.c if (entry->flush_tran_id == tran_id
entry 2315 net/atm/lec.c && entry->status == ESI_FLUSH_PENDING) {
entry 2317 net/atm/lec.c struct atm_vcc *vcc = entry->vcc;
entry 2319 net/atm/lec.c lec_arp_hold(entry);
entry 2321 net/atm/lec.c while ((skb = skb_dequeue(&entry->tx_wait)) != NULL)
entry 2322 net/atm/lec.c lec_send(vcc, skb, entry->priv);
entry 2323 net/atm/lec.c entry->last_used = jiffies;
entry 2324 net/atm/lec.c entry->status = ESI_FORWARD_DIRECT;
entry 2325 net/atm/lec.c lec_arp_put(entry);
entry 2341 net/atm/lec.c struct lec_arp_table *entry;
entry 2346 net/atm/lec.c hlist_for_each_entry(entry, node, &priv->lec_arp_tables[i], next) {
entry 2347 net/atm/lec.c if (!memcmp(atm_addr, entry->atm_addr, ATM_ESA_LEN)) {
entry 2348 net/atm/lec.c entry->flush_tran_id = tran_id;
entry 2350 net/atm/lec.c tran_id, entry);
entry 2397 net/atm/lec.c struct lec_arp_table *entry;
entry 2406 net/atm/lec.c hlist_for_each_entry_safe(entry, node, next, &priv->lec_arp_tables[i], next) {
entry 2407 net/atm/lec.c if (vcc == entry->vcc) {
entry 2408 net/atm/lec.c lec_arp_remove(priv, entry);
entry 2409 net/atm/lec.c lec_arp_put(entry);
entry 2417 net/atm/lec.c hlist_for_each_entry_safe(entry, node, next, &priv->lec_arp_empty_ones, next) {
entry 2418 net/atm/lec.c if (entry->vcc == vcc) {
entry 2419 net/atm/lec.c lec_arp_clear_vccs(entry);
entry 2420 net/atm/lec.c del_timer(&entry->timer);
entry 2421 net/atm/lec.c hlist_del(&entry->next);
entry 2422 net/atm/lec.c lec_arp_put(entry);
entry 2426 net/atm/lec.c hlist_for_each_entry_safe(entry, node, next, &priv->lec_no_forward, next) {
entry 2427 net/atm/lec.c if (entry->recv_vcc == vcc) {
entry 2428 net/atm/lec.c lec_arp_clear_vccs(entry);
entry 2429 net/atm/lec.c del_timer(&entry->timer);
entry 2430 net/atm/lec.c hlist_del(&entry->next);
entry 2431 net/atm/lec.c lec_arp_put(entry);
entry 2435 net/atm/lec.c hlist_for_each_entry_safe(entry, node, next, &priv->mcast_fwds, next) {
entry 2436 net/atm/lec.c if (entry->recv_vcc == vcc) {
entry 2437 net/atm/lec.c lec_arp_clear_vccs(entry);
entry 2439 net/atm/lec.c hlist_del(&entry->next);
entry 2440 net/atm/lec.c lec_arp_put(entry);
entry 2454 net/atm/lec.c struct lec_arp_table *entry, *tmp;
entry 2467 net/atm/lec.c hlist_for_each_entry_safe(entry, node, next, &priv->lec_arp_empty_ones, next) {
entry 2468 net/atm/lec.c if (vcc == entry->vcc) {
entry 2469 net/atm/lec.c del_timer(&entry->timer);
entry 2470 net/atm/lec.c memcpy(entry->mac_addr, src, ETH_ALEN);
entry 2471 net/atm/lec.c entry->status = ESI_FORWARD_DIRECT;
entry 2472 net/atm/lec.c entry->last_used = jiffies;
entry 2478 net/atm/lec.c hlist_del(&entry->next);
entry 2479 net/atm/lec.c lec_arp_add(priv, entry);
entry 159 net/atm/mpc.c struct atm_mpoa_qos *entry;
entry 161 net/atm/mpc.c entry = atm_mpoa_search_qos(dst_ip);
entry 162 net/atm/mpc.c if (entry != NULL) {
entry 163 net/atm/mpc.c entry->qos = *qos;
entry 164 net/atm/mpc.c return entry;
entry 167 net/atm/mpc.c entry = kmalloc(sizeof(struct atm_mpoa_qos), GFP_KERNEL);
entry 168 net/atm/mpc.c if (entry == NULL) {
entry 170 net/atm/mpc.c return entry;
entry 173 net/atm/mpc.c entry->ipaddr = dst_ip;
entry 174 net/atm/mpc.c entry->qos = *qos;
entry 176 net/atm/mpc.c entry->next = qos_head;
entry 177 net/atm/mpc.c qos_head = entry;
entry 179 net/atm/mpc.c return entry;
entry 205 net/atm/mpc.c if (entry == NULL) return 0;
entry 206 net/atm/mpc.c if (entry == qos_head) {
entry 208 net/atm/mpc.c kfree(entry);
entry 214 net/atm/mpc.c if (curr->next == entry) {
entry 215 net/atm/mpc.c curr->next = entry->next;
entry 216 net/atm/mpc.c kfree(entry);
entry 464 net/atm/mpc.c in_cache_entry *entry;
entry 483 net/atm/mpc.c entry = mpc->in_ops->get(ipaddr, mpc);
entry 484 net/atm/mpc.c if (entry == NULL) {
entry 485 net/atm/mpc.c entry = mpc->in_ops->add_entry(ipaddr, mpc);
entry 486 net/atm/mpc.c if (entry != NULL) mpc->in_ops->put(entry);
entry 489 net/atm/mpc.c if (mpc->in_ops->cache_hit(entry, mpc) != OPEN){ /* threshold not exceeded or VCC not ready */
entry 491 net/atm/mpc.c mpc->in_ops->put(entry);
entry 499 net/atm/mpc.c mpc->in_ops->put(entry);
entry 506 net/atm/mpc.c if (entry->ctrl_info.tag != 0) {
entry 507 net/atm/mpc.c ddprintk("mpoa: (%s) send_via_shortcut: adding tag 0x%x\n", mpc->dev->name, entry->ctrl_info.tag);
entry 508 net/atm/mpc.c tagged_llc_snap_hdr.tag = entry->ctrl_info.tag;
entry 520 net/atm/mpc.c atomic_add(skb->truesize, &sk_atm(entry->shortcut)->sk_wmem_alloc);
entry 521 net/atm/mpc.c ATM_SKB(skb)->atm_options = entry->shortcut->atm_options;
entry 522 net/atm/mpc.c entry->shortcut->send(entry->shortcut, skb);
entry 523 net/atm/mpc.c entry->packets_fwded++;
entry 524 net/atm/mpc.c mpc->in_ops->put(entry);
entry 1051 net/atm/mpc.c in_cache_entry *entry;
entry 1053 net/atm/mpc.c entry = mpc->in_ops->get(dst_ip, mpc);
entry 1054 net/atm/mpc.c if(entry == NULL){
entry 1055 net/atm/mpc.c entry = mpc->in_ops->add_entry(dst_ip, mpc);
entry 1056 net/atm/mpc.c entry->entry_state = INGRESS_RESOLVING;
entry 1058 net/atm/mpc.c msg->content.in_info = entry->ctrl_info;
entry 1060 net/atm/mpc.c do_gettimeofday(&(entry->reply_wait));
entry 1061 net/atm/mpc.c mpc->in_ops->put(entry);
entry 1065 net/atm/mpc.c if(entry->entry_state == INGRESS_INVALID){
entry 1066 net/atm/mpc.c entry->entry_state = INGRESS_RESOLVING;
entry 1068 net/atm/mpc.c msg->content.in_info = entry->ctrl_info;
entry 1070 net/atm/mpc.c do_gettimeofday(&(entry->reply_wait));
entry 1071 net/atm/mpc.c mpc->in_ops->put(entry);
entry 1077 net/atm/mpc.c mpc->in_ops->put(entry);
entry 1096 net/atm/mpc.c entry->shortcut = eg_entry->shortcut;
entry 1098 net/atm/mpc.c entry->shortcut = eg_entry->shortcut;
entry 1100 net/atm/mpc.c if(entry->shortcut){
entry 1124 net/atm/mpc.c in_cache_entry *entry = mpc->in_ops->get(dst_ip, mpc);
entry 1127 net/atm/mpc.c ddprintk("mpoa: (%s) MPOA_res_reply_rcvd() entry = %p", mpc->dev->name, entry);
entry 1128 net/atm/mpc.c if(entry == NULL){
entry 1132 net/atm/mpc.c ddprintk(" entry_state = %d ", entry->entry_state);
entry 1134 net/atm/mpc.c if (entry->entry_state == INGRESS_RESOLVED) {
entry 1136 net/atm/mpc.c mpc->in_ops->put(entry);
entry 1140 net/atm/mpc.c entry->ctrl_info = msg->content.in_info;
entry 1141 net/atm/mpc.c do_gettimeofday(&(entry->tv));
entry 1142 net/atm/mpc.c do_gettimeofday(&(entry->reply_wait)); /* Used in refreshing func from now on */
entry 1143 net/atm/mpc.c entry->refresh_time = 0;
entry 1144 net/atm/mpc.c ddprintk("entry->shortcut = %p\n", entry->shortcut);
entry 1146 net/atm/mpc.c if(entry->entry_state == INGRESS_RESOLVING && entry->shortcut != NULL){
entry 1147 net/atm/mpc.c entry->entry_state = INGRESS_RESOLVED;
entry 1148 net/atm/mpc.c mpc->in_ops->put(entry);
entry 1152 net/atm/mpc.c if (entry->shortcut != NULL) {
entry 1155 net/atm/mpc.c mpc->in_ops->put(entry);
entry 1159 net/atm/mpc.c check_qos_and_open_shortcut(msg, mpc, entry);
entry 1160 net/atm/mpc.c entry->entry_state = INGRESS_RESOLVED;
entry 1161 net/atm/mpc.c mpc->in_ops->put(entry);
entry 1171 net/atm/mpc.c in_cache_entry *entry = mpc->in_ops->get_with_mask(dst_ip, mpc, mask);
entry 1173 net/atm/mpc.c if(entry == NULL){
entry 1183 net/atm/mpc.c mpc->in_ops->remove_entry(entry, mpc);
entry 1185 net/atm/mpc.c mpc->in_ops->put(entry);
entry 1186 net/atm/mpc.c entry = mpc->in_ops->get_with_mask(dst_ip, mpc, mask);
entry 1187 net/atm/mpc.c } while (entry != NULL);
entry 1195 net/atm/mpc.c eg_cache_entry *entry = mpc->eg_ops->get_by_cache_id(cache_id, mpc);
entry 1197 net/atm/mpc.c if (entry == NULL) {
entry 1203 net/atm/mpc.c mpc->eg_ops->remove_entry(entry, mpc);
entry 1206 net/atm/mpc.c mpc->eg_ops->put(entry);
entry 1233 net/atm/mpc.c if (entry != NULL)
entry 1234 net/atm/mpc.c purge_msg->content.eg_info = entry->ctrl_info;
entry 1252 net/atm/mpc.c eg_cache_entry *entry;
entry 1263 net/atm/mpc.c entry = mpc->eg_cache;
entry 1264 net/atm/mpc.c while (entry != NULL) {
entry 1265 net/atm/mpc.c purge_egress_shortcut(entry->shortcut, entry);
entry 1266 net/atm/mpc.c entry = entry->next;
entry 1279 net/atm/mpc.c eg_cache_entry *entry = mpc->eg_ops->get_by_cache_id(msg->content.eg_info.cache_id, mpc);
entry 1283 net/atm/mpc.c mpc->dev->name, entry, holding_time);
entry 1284 net/atm/mpc.c if(entry == NULL && holding_time) {
entry 1285 net/atm/mpc.c entry = mpc->eg_ops->add_entry(msg, mpc);
entry 1286 net/atm/mpc.c mpc->eg_ops->put(entry);
entry 1290 net/atm/mpc.c mpc->eg_ops->update(entry, holding_time);
entry 1295 net/atm/mpc.c mpc->eg_ops->remove_entry(entry, mpc);
entry 1298 net/atm/mpc.c mpc->eg_ops->put(entry);
entry 1359 net/atm/mpc.c eg_cache_entry *entry;
entry 1365 net/atm/mpc.c entry = mpc->eg_cache;
entry 1366 net/atm/mpc.c while (entry != NULL){
entry 1367 net/atm/mpc.c msg->content.eg_info = entry->ctrl_info;
entry 1368 net/atm/mpc.c dprintk("mpoa: cache_id %u\n", entry->ctrl_info.cache_id);
entry 1370 net/atm/mpc.c entry = entry->next;
entry 28 net/atm/mpoa_caches.c in_cache_entry *entry;
entry 31 net/atm/mpoa_caches.c entry = client->in_cache;
entry 32 net/atm/mpoa_caches.c while(entry != NULL){
entry 33 net/atm/mpoa_caches.c if( entry->ctrl_info.in_dst_ip == dst_ip ){
entry 34 net/atm/mpoa_caches.c atomic_inc(&entry->use);
entry 36 net/atm/mpoa_caches.c return entry;
entry 38 net/atm/mpoa_caches.c entry = entry->next;
entry 49 net/atm/mpoa_caches.c in_cache_entry *entry;
entry 52 net/atm/mpoa_caches.c entry = client->in_cache;
entry 53 net/atm/mpoa_caches.c while(entry != NULL){
entry 54 net/atm/mpoa_caches.c if((entry->ctrl_info.in_dst_ip & mask) == (dst_ip & mask )){
entry 55 net/atm/mpoa_caches.c atomic_inc(&entry->use);
entry 57 net/atm/mpoa_caches.c return entry;
entry 59 net/atm/mpoa_caches.c entry = entry->next;
entry 70 net/atm/mpoa_caches.c in_cache_entry *entry;
entry 73 net/atm/mpoa_caches.c entry = client->in_cache;
entry 74 net/atm/mpoa_caches.c while(entry != NULL){
entry 75 net/atm/mpoa_caches.c if(entry->shortcut == vcc) {
entry 76 net/atm/mpoa_caches.c atomic_inc(&entry->use);
entry 78 net/atm/mpoa_caches.c return entry;
entry 80 net/atm/mpoa_caches.c entry = entry->next;
entry 90 net/atm/mpoa_caches.c in_cache_entry *entry = kzalloc(sizeof(in_cache_entry), GFP_KERNEL);
entry 92 net/atm/mpoa_caches.c if (entry == NULL) {
entry 99 net/atm/mpoa_caches.c atomic_set(&entry->use, 1);
entry 102 net/atm/mpoa_caches.c entry->next = client->in_cache;
entry 103 net/atm/mpoa_caches.c entry->prev = NULL;
entry 105 net/atm/mpoa_caches.c client->in_cache->prev = entry;
entry 106 net/atm/mpoa_caches.c client->in_cache = entry;
entry 108 net/atm/mpoa_caches.c memcpy(entry->MPS_ctrl_ATM_addr, client->mps_ctrl_addr, ATM_ESA_LEN);
entry 109 net/atm/mpoa_caches.c entry->ctrl_info.in_dst_ip = dst_ip;
entry 110 net/atm/mpoa_caches.c do_gettimeofday(&(entry->tv));
entry 111 net/atm/mpoa_caches.c entry->retry_time = client->parameters.mpc_p4;
entry 112 net/atm/mpoa_caches.c entry->count = 1;
entry 113 net/atm/mpoa_caches.c entry->entry_state = INGRESS_INVALID;
entry 114 net/atm/mpoa_caches.c entry->ctrl_info.holding_time = HOLDING_TIME_DEFAULT;
entry 115 net/atm/mpoa_caches.c atomic_inc(&entry->use);
entry 120 net/atm/mpoa_caches.c return entry;
entry 128 net/atm/mpoa_caches.c entry->count++;
entry 129 net/atm/mpoa_caches.c if(entry->entry_state == INGRESS_RESOLVED && entry->shortcut != NULL)
entry 132 net/atm/mpoa_caches.c if(entry->entry_state == INGRESS_REFRESHING){
entry 133 net/atm/mpoa_caches.c if(entry->count > mpc->parameters.mpc_p1){
entry 135 net/atm/mpoa_caches.c msg.content.in_info = entry->ctrl_info;
entry 137 net/atm/mpoa_caches.c qos = atm_mpoa_search_qos(entry->ctrl_info.in_dst_ip);
entry 140 net/atm/mpoa_caches.c do_gettimeofday(&(entry->reply_wait));
entry 141 net/atm/mpoa_caches.c entry->entry_state = INGRESS_RESOLVING;
entry 143 net/atm/mpoa_caches.c if(entry->shortcut != NULL)
entry 148 net/atm/mpoa_caches.c if(entry->entry_state == INGRESS_RESOLVING && entry->shortcut != NULL)
entry 151 net/atm/mpoa_caches.c if( entry->count > mpc->parameters.mpc_p1 &&
entry 152 net/atm/mpoa_caches.c entry->entry_state == INGRESS_INVALID){
entry 153 net/atm/mpoa_caches.c dprintk("mpoa: (%s) mpoa_caches.c: threshold exceeded for ip %u.%u.%u.%u, sending MPOA res req\n", mpc->dev->name, NIPQUAD(entry->ctrl_info.in_dst_ip));
entry 154 net/atm/mpoa_caches.c entry->entry_state = INGRESS_RESOLVING;
entry 157 net/atm/mpoa_caches.c msg.content.in_info = entry->ctrl_info;
entry 158 net/atm/mpoa_caches.c qos = atm_mpoa_search_qos(entry->ctrl_info.in_dst_ip);
entry 161 net/atm/mpoa_caches.c do_gettimeofday(&(entry->reply_wait));
entry 169 net/atm/mpoa_caches.c if (atomic_dec_and_test(&entry->use)) {
entry 170 net/atm/mpoa_caches.c memset(entry, 0, sizeof(in_cache_entry));
entry 171 net/atm/mpoa_caches.c kfree(entry);
entry 186 net/atm/mpoa_caches.c vcc = entry->shortcut;
entry 187 net/atm/mpoa_caches.c dprintk("mpoa: mpoa_caches.c: removing an ingress entry, ip = %u.%u.%u.%u\n",NIPQUAD(entry->ctrl_info.in_dst_ip));
entry 189 net/atm/mpoa_caches.c if (entry->prev != NULL)
entry 190 net/atm/mpoa_caches.c entry->prev->next = entry->next;
entry 192 net/atm/mpoa_caches.c client->in_cache = entry->next;
entry 193 net/atm/mpoa_caches.c if (entry->next != NULL)
entry 194 net/atm/mpoa_caches.c entry->next->prev = entry->prev;
entry 195 net/atm/mpoa_caches.c client->in_ops->put(entry);
entry 219 net/atm/mpoa_caches.c in_cache_entry *entry, *next_entry;
entry 225 net/atm/mpoa_caches.c entry = client->in_cache;
entry 226 net/atm/mpoa_caches.c while(entry != NULL){
entry 227 net/atm/mpoa_caches.c entry->count=0;
entry 228 net/atm/mpoa_caches.c next_entry = entry->next;
entry 229 net/atm/mpoa_caches.c if((now.tv_sec - entry->tv.tv_sec)
entry 230 net/atm/mpoa_caches.c > entry->ctrl_info.holding_time){
entry 231 net/atm/mpoa_caches.c dprintk("mpoa: mpoa_caches.c: holding time expired, ip = %u.%u.%u.%u\n", NIPQUAD(entry->ctrl_info.in_dst_ip));
entry 232 net/atm/mpoa_caches.c client->in_ops->remove_entry(entry, client);
entry 234 net/atm/mpoa_caches.c entry = next_entry;
entry 246 net/atm/mpoa_caches.c in_cache_entry *entry;
entry 253 net/atm/mpoa_caches.c entry = client->in_cache;
entry 254 net/atm/mpoa_caches.c while( entry != NULL ){
entry 255 net/atm/mpoa_caches.c if(entry->entry_state == INGRESS_RESOLVING){
entry 256 net/atm/mpoa_caches.c if(now.tv_sec - entry->hold_down.tv_sec < client->parameters.mpc_p6){
entry 257 net/atm/mpoa_caches.c entry = entry->next; /* Entry in hold down */
entry 260 net/atm/mpoa_caches.c if( (now.tv_sec - entry->reply_wait.tv_sec) >
entry 261 net/atm/mpoa_caches.c entry->retry_time ){
entry 262 net/atm/mpoa_caches.c entry->retry_time = MPC_C1*( entry->retry_time );
entry 263 net/atm/mpoa_caches.c if(entry->retry_time > client->parameters.mpc_p5){
entry 265 net/atm/mpoa_caches.c do_gettimeofday(&(entry->hold_down));
entry 266 net/atm/mpoa_caches.c entry->retry_time = client->parameters.mpc_p4;
entry 267 net/atm/mpoa_caches.c entry = entry->next;
entry 271 net/atm/mpoa_caches.c memset(&(entry->hold_down),0,sizeof(struct timeval));
entry 274 net/atm/mpoa_caches.c msg.content.in_info = entry->ctrl_info;
entry 275 net/atm/mpoa_caches.c qos = atm_mpoa_search_qos(entry->ctrl_info.in_dst_ip);
entry 278 net/atm/mpoa_caches.c do_gettimeofday(&(entry->reply_wait));
entry 281 net/atm/mpoa_caches.c entry = entry->next;
entry 290 net/atm/mpoa_caches.c struct in_cache_entry *entry = client->in_cache;
entry 296 net/atm/mpoa_caches.c while( entry != NULL ){
entry 297 net/atm/mpoa_caches.c if( entry->entry_state == INGRESS_RESOLVED ){
entry 298 net/atm/mpoa_caches.c if(!(entry->refresh_time))
entry 299 net/atm/mpoa_caches.c entry->refresh_time = (2*(entry->ctrl_info.holding_time))/3;
entry 300 net/atm/mpoa_caches.c if( (now.tv_sec - entry->reply_wait.tv_sec) > entry->refresh_time ){
entry 302 net/atm/mpoa_caches.c entry->entry_state = INGRESS_REFRESHING;
entry 306 net/atm/mpoa_caches.c entry = entry->next;
entry 323 net/atm/mpoa_caches.c eg_cache_entry *entry;
entry 326 net/atm/mpoa_caches.c entry = mpc->eg_cache;
entry 327 net/atm/mpoa_caches.c while(entry != NULL){
entry 328 net/atm/mpoa_caches.c if(entry->ctrl_info.cache_id == cache_id){
entry 329 net/atm/mpoa_caches.c atomic_inc(&entry->use);
entry 331 net/atm/mpoa_caches.c return entry;
entry 333 net/atm/mpoa_caches.c entry = entry->next;
entry 344 net/atm/mpoa_caches.c eg_cache_entry *entry;
entry 347 net/atm/mpoa_caches.c entry = mpc->eg_cache;
entry 348 net/atm/mpoa_caches.c while (entry != NULL){
entry 349 net/atm/mpoa_caches.c if (entry->ctrl_info.tag == tag) {
entry 350 net/atm/mpoa_caches.c atomic_inc(&entry->use);
entry 352 net/atm/mpoa_caches.c return entry;
entry 354 net/atm/mpoa_caches.c entry = entry->next;
entry 365 net/atm/mpoa_caches.c eg_cache_entry *entry;
entry 368 net/atm/mpoa_caches.c entry = mpc->eg_cache;
entry 369 net/atm/mpoa_caches.c while (entry != NULL){
entry 370 net/atm/mpoa_caches.c if (entry->shortcut == vcc) {
entry 371 net/atm/mpoa_caches.c atomic_inc(&entry->use);
entry 373 net/atm/mpoa_caches.c return entry;
entry 375 net/atm/mpoa_caches.c entry = entry->next;
entry 384 net/atm/mpoa_caches.c eg_cache_entry *entry;
entry 387 net/atm/mpoa_caches.c entry = mpc->eg_cache;
entry 388 net/atm/mpoa_caches.c while(entry != NULL){
entry 389 net/atm/mpoa_caches.c if(entry->latest_ip_addr == ipaddr) {
entry 390 net/atm/mpoa_caches.c atomic_inc(&entry->use);
entry 392 net/atm/mpoa_caches.c return entry;
entry 394 net/atm/mpoa_caches.c entry = entry->next;
entry 403 net/atm/mpoa_caches.c if (atomic_dec_and_test(&entry->use)) {
entry 404 net/atm/mpoa_caches.c memset(entry, 0, sizeof(eg_cache_entry));
entry 405 net/atm/mpoa_caches.c kfree(entry);
entry 420 net/atm/mpoa_caches.c vcc = entry->shortcut;
entry 422 net/atm/mpoa_caches.c if (entry->prev != NULL)
entry 423 net/atm/mpoa_caches.c entry->prev->next = entry->next;
entry 425 net/atm/mpoa_caches.c client->eg_cache = entry->next;
entry 426 net/atm/mpoa_caches.c if (entry->next != NULL)
entry 427 net/atm/mpoa_caches.c entry->next->prev = entry->prev;
entry 428 net/atm/mpoa_caches.c client->eg_ops->put(entry);
entry 449 net/atm/mpoa_caches.c eg_cache_entry *entry = kzalloc(sizeof(eg_cache_entry), GFP_KERNEL);
entry 451 net/atm/mpoa_caches.c if (entry == NULL) {
entry 458 net/atm/mpoa_caches.c atomic_set(&entry->use, 1);
entry 461 net/atm/mpoa_caches.c entry->next = client->eg_cache;
entry 462 net/atm/mpoa_caches.c entry->prev = NULL;
entry 464 net/atm/mpoa_caches.c client->eg_cache->prev = entry;
entry 465 net/atm/mpoa_caches.c client->eg_cache = entry;
entry 467 net/atm/mpoa_caches.c memcpy(entry->MPS_ctrl_ATM_addr, client->mps_ctrl_addr, ATM_ESA_LEN);
entry 468 net/atm/mpoa_caches.c entry->ctrl_info = msg->content.eg_info;
entry 469 net/atm/mpoa_caches.c do_gettimeofday(&(entry->tv));
entry 470 net/atm/mpoa_caches.c entry->entry_state = EGRESS_RESOLVED;
entry 471 net/atm/mpoa_caches.c dprintk("mpoa: mpoa_caches.c: new_eg_cache_entry cache_id %lu\n", ntohl(entry->ctrl_info.cache_id));
entry 473 net/atm/mpoa_caches.c NIPQUAD(entry->ctrl_info.mps_ip));
entry 474 net/atm/mpoa_caches.c atomic_inc(&entry->use);
entry 479 net/atm/mpoa_caches.c return entry;
entry 484 net/atm/mpoa_caches.c do_gettimeofday(&(entry->tv));
entry 485 net/atm/mpoa_caches.c entry->entry_state = EGRESS_RESOLVED;
entry 486 net/atm/mpoa_caches.c entry->ctrl_info.holding_time = holding_time;
entry 493 net/atm/mpoa_caches.c eg_cache_entry *entry, *next_entry;
entry 500 net/atm/mpoa_caches.c entry = client->eg_cache;
entry 501 net/atm/mpoa_caches.c while(entry != NULL){
entry 502 net/atm/mpoa_caches.c next_entry = entry->next;
entry 503 net/atm/mpoa_caches.c if((now.tv_sec - entry->tv.tv_sec)
entry 504 net/atm/mpoa_caches.c > entry->ctrl_info.holding_time){
entry 506 net/atm/mpoa_caches.c msg.content.eg_info = entry->ctrl_info;
entry 507 net/atm/mpoa_caches.c dprintk("mpoa: mpoa_caches.c: egress_cache: holding time expired, cache_id = %lu.\n",ntohl(entry->ctrl_info.cache_id));
entry 509 net/atm/mpoa_caches.c client->eg_ops->remove_entry(entry, client);
entry 511 net/atm/mpoa_caches.c entry = next_entry;
entry 40 net/atm/mpoa_caches.h void (*put)(in_cache_entry *entry);
entry 43 net/atm/mpoa_caches.h int (*cache_hit)(in_cache_entry *entry,
entry 70 net/atm/mpoa_caches.h void (*put)(eg_cache_entry *entry);
entry 71 net/atm/mpoa_caches.h void (*remove_entry)(eg_cache_entry *entry, struct mpoa_client *client);
entry 72 net/atm/mpoa_caches.h void (*update)(eg_cache_entry *entry, uint16_t holding_time);
entry 171 net/atm/proc.c dev = clip_vcc->entry ? clip_vcc->entry->neigh->dev : NULL;
entry 233 net/bluetooth/rfcomm/tty.c struct rfcomm_dev *entry = list_entry(p, struct rfcomm_dev, list);
entry 235 net/bluetooth/rfcomm/tty.c if (entry->id == dev->id) {
entry 240 net/bluetooth/rfcomm/tty.c if (entry->id > dev->id - 1)
entry 91 net/bridge/netfilter/ebtables.c if (*entry == '\0')
entry 96 net/bridge/netfilter/ebtables.c while (entry[i] != '\0' && entry[i] != 1 && entry[i] == devname[i])
entry 98 net/bridge/netfilter/ebtables.c return (devname[i] != entry[i] && entry[i] != 1);
entry 232 net/core/pktgen.c struct proc_dir_entry *entry; /* proc file */
entry 1871 net/core/pktgen.c remove_proc_entry(pkt_dev->entry->name, pg_proc_dir);
entry 1873 net/core/pktgen.c pkt_dev->entry = create_proc_entry(dev->name, 0600,
entry 1875 net/core/pktgen.c if (!pkt_dev->entry)
entry 3663 net/core/pktgen.c pkt_dev->entry = proc_create_data(ifname, 0600, pg_proc_dir,
entry 3665 net/core/pktgen.c if (!pkt_dev->entry) {
entry 3777 net/core/pktgen.c if (pkt_dev->entry)
entry 3778 net/core/pktgen.c remove_proc_entry(pkt_dev->entry->name, pg_proc_dir);
entry 87 net/dccp/ccids/lib/packet_history.c struct tfrc_tx_hist_entry *entry = kmem_cache_alloc(tfrc_tx_hist_slab, gfp_any());
entry 89 net/dccp/ccids/lib/packet_history.c if (entry == NULL)
entry 91 net/dccp/ccids/lib/packet_history.c entry->seqno = seqno;
entry 92 net/dccp/ccids/lib/packet_history.c entry->stamp = ktime_get_real();
entry 93 net/dccp/ccids/lib/packet_history.c entry->next = *headp;
entry 94 net/dccp/ccids/lib/packet_history.c *headp = entry;
entry 160 net/dccp/ccids/lib/packet_history.c entry->tfrchrx_seqno = DCCP_SKB_CB(skb)->dccpd_seq;
entry 161 net/dccp/ccids/lib/packet_history.c entry->tfrchrx_ccval = dh->dccph_ccval;
entry 162 net/dccp/ccids/lib/packet_history.c entry->tfrchrx_type = dh->dccph_type;
entry 163 net/dccp/ccids/lib/packet_history.c entry->tfrchrx_ndp = ndp;
entry 164 net/dccp/ccids/lib/packet_history.c entry->tfrchrx_tstamp = ktime_get_real();
entry 171 net/dccp/ccids/lib/packet_history.c struct tfrc_rx_hist_entry *entry = tfrc_rx_hist_last_rcv(h);
entry 173 net/dccp/ccids/lib/packet_history.c tfrc_rx_hist_entry_from_skb(entry, skb, ndp);
entry 111 net/dccp/probe.c .entry = jdccp_sendmsg,
entry 35 net/ieee80211/ieee80211_crypt.c struct ieee80211_crypt_data *entry, *next;
entry 39 net/ieee80211/ieee80211_crypt.c list_for_each_entry_safe(entry, next, &ieee->crypt_deinit_list, list) {
entry 40 net/ieee80211/ieee80211_crypt.c if (atomic_read(&entry->refcnt) != 0 && !force)
entry 43 net/ieee80211/ieee80211_crypt.c list_del(&entry->list);
entry 45 net/ieee80211/ieee80211_crypt.c if (entry->ops) {
entry 46 net/ieee80211/ieee80211_crypt.c entry->ops->deinit(entry->priv);
entry 47 net/ieee80211/ieee80211_crypt.c module_put(entry->ops->owner);
entry 49 net/ieee80211/ieee80211_crypt.c kfree(entry);
entry 62 net/ieee80211/ieee80211_rx.c struct ieee80211_frag_entry *entry;
entry 66 net/ieee80211/ieee80211_rx.c entry = &ieee->frag_cache[i];
entry 67 net/ieee80211/ieee80211_rx.c if (entry->skb != NULL &&
entry 68 net/ieee80211/ieee80211_rx.c time_after(jiffies, entry->first_frag_time + 2 * HZ)) {
entry 71 net/ieee80211/ieee80211_rx.c entry->seq, entry->last_frag);
entry 72 net/ieee80211/ieee80211_rx.c dev_kfree_skb_any(entry->skb);
entry 73 net/ieee80211/ieee80211_rx.c entry->skb = NULL;
entry 76 net/ieee80211/ieee80211_rx.c if (entry->skb != NULL && entry->seq == seq &&
entry 77 net/ieee80211/ieee80211_rx.c (entry->last_frag + 1 == frag || frag == -1) &&
entry 78 net/ieee80211/ieee80211_rx.c !compare_ether_addr(entry->src_addr, src) &&
entry 79 net/ieee80211/ieee80211_rx.c !compare_ether_addr(entry->dst_addr, dst))
entry 80 net/ieee80211/ieee80211_rx.c return entry;
entry 93 net/ieee80211/ieee80211_rx.c struct ieee80211_frag_entry *entry;
entry 109 net/ieee80211/ieee80211_rx.c entry = &ieee->frag_cache[ieee->frag_next_idx];
entry 114 net/ieee80211/ieee80211_rx.c if (entry->skb != NULL)
entry 115 net/ieee80211/ieee80211_rx.c dev_kfree_skb_any(entry->skb);
entry 117 net/ieee80211/ieee80211_rx.c entry->first_frag_time = jiffies;
entry 118 net/ieee80211/ieee80211_rx.c entry->seq = seq;
entry 119 net/ieee80211/ieee80211_rx.c entry->last_frag = frag;
entry 120 net/ieee80211/ieee80211_rx.c entry->skb = skb;
entry 121 net/ieee80211/ieee80211_rx.c memcpy(entry->src_addr, hdr->addr2, ETH_ALEN);
entry 122 net/ieee80211/ieee80211_rx.c memcpy(entry->dst_addr, hdr->addr1, ETH_ALEN);
entry 126 net/ieee80211/ieee80211_rx.c entry = ieee80211_frag_cache_find(ieee, seq, frag, hdr->addr2,
entry 128 net/ieee80211/ieee80211_rx.c if (entry != NULL) {
entry 129 net/ieee80211/ieee80211_rx.c entry->last_frag = frag;
entry 130 net/ieee80211/ieee80211_rx.c skb = entry->skb;
entry 143 net/ieee80211/ieee80211_rx.c struct ieee80211_frag_entry *entry;
entry 148 net/ieee80211/ieee80211_rx.c entry = ieee80211_frag_cache_find(ieee, seq, -1, hdr->addr2,
entry 151 net/ieee80211/ieee80211_rx.c if (entry == NULL) {
entry 157 net/ieee80211/ieee80211_rx.c entry->skb = NULL;
entry 210 net/ipv4/cipso_ipv4.c if (entry->lsm_data)
entry 211 net/ipv4/cipso_ipv4.c netlbl_secattr_cache_free(entry->lsm_data);
entry 212 net/ipv4/cipso_ipv4.c kfree(entry->key);
entry 213 net/ipv4/cipso_ipv4.c kfree(entry);
entry 272 net/ipv4/cipso_ipv4.c struct cipso_v4_map_cache_entry *entry, *tmp_entry;
entry 277 net/ipv4/cipso_ipv4.c list_for_each_entry_safe(entry,
entry 280 net/ipv4/cipso_ipv4.c list_del(&entry->list);
entry 281 net/ipv4/cipso_ipv4.c cipso_v4_cache_entry_free(entry);
entry 317 net/ipv4/cipso_ipv4.c struct cipso_v4_map_cache_entry *entry;
entry 327 net/ipv4/cipso_ipv4.c list_for_each_entry(entry, &cipso_v4_cache[bkt].list, list) {
entry 328 net/ipv4/cipso_ipv4.c if (entry->hash == hash &&
entry 329 net/ipv4/cipso_ipv4.c entry->key_len == key_len &&
entry 330 net/ipv4/cipso_ipv4.c memcmp(entry->key, key, key_len) == 0) {
entry 331 net/ipv4/cipso_ipv4.c entry->activity += 1;
entry 332 net/ipv4/cipso_ipv4.c atomic_inc(&entry->lsm_data->refcount);
entry 333 net/ipv4/cipso_ipv4.c secattr->cache = entry->lsm_data;
entry 343 net/ipv4/cipso_ipv4.c if (entry->activity > prev_entry->activity &&
entry 344 net/ipv4/cipso_ipv4.c entry->activity - prev_entry->activity >
entry 346 net/ipv4/cipso_ipv4.c __list_del(entry->list.prev, entry->list.next);
entry 347 net/ipv4/cipso_ipv4.c __list_add(&entry->list,
entry 355 net/ipv4/cipso_ipv4.c prev_entry = entry;
entry 380 net/ipv4/cipso_ipv4.c struct cipso_v4_map_cache_entry *entry = NULL;
entry 391 net/ipv4/cipso_ipv4.c entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
entry 392 net/ipv4/cipso_ipv4.c if (entry == NULL)
entry 394 net/ipv4/cipso_ipv4.c entry->key = kmemdup(cipso_ptr, cipso_ptr_len, GFP_ATOMIC);
entry 395 net/ipv4/cipso_ipv4.c if (entry->key == NULL) {
entry 399 net/ipv4/cipso_ipv4.c entry->key_len = cipso_ptr_len;
entry 400 net/ipv4/cipso_ipv4.c entry->hash = cipso_v4_map_cache_hash(cipso_ptr, cipso_ptr_len);
entry 402 net/ipv4/cipso_ipv4.c entry->lsm_data = secattr->cache;
entry 404 net/ipv4/cipso_ipv4.c bkt = entry->hash & (CIPSO_V4_CACHE_BUCKETS - 1);
entry 407 net/ipv4/cipso_ipv4.c list_add(&entry->list, &cipso_v4_cache[bkt].list);
entry 413 net/ipv4/cipso_ipv4.c list_add(&entry->list, &cipso_v4_cache[bkt].list);
entry 421 net/ipv4/cipso_ipv4.c if (entry)
entry 422 net/ipv4/cipso_ipv4.c cipso_v4_cache_entry_free(entry);
entry 546 net/ipv4/cipso_ipv4.c doi_def = container_of(entry, struct cipso_v4_doi, rcu);
entry 372 net/ipv4/inet_diag.c yes = entry->sport >= op[1].no;
entry 375 net/ipv4/inet_diag.c yes = entry->dport <= op[1].no;
entry 378 net/ipv4/inet_diag.c yes = entry->dport >= op[1].no;
entry 381 net/ipv4/inet_diag.c yes = entry->dport <= op[1].no;
entry 384 net/ipv4/inet_diag.c yes = !(entry->userlocks & SOCK_BINDPORT_LOCK);
entry 394 net/ipv4/inet_diag.c entry->sport : entry->dport)) {
entry 403 net/ipv4/inet_diag.c addr = entry->saddr;
entry 405 net/ipv4/inet_diag.c addr = entry->daddr;
entry 410 net/ipv4/inet_diag.c if (entry->family == AF_INET6 &&
entry 497 net/ipv4/inet_diag.c struct inet_diag_entry entry;
entry 501 net/ipv4/inet_diag.c entry.family = sk->sk_family;
entry 503 net/ipv4/inet_diag.c if (entry.family == AF_INET6) {
entry 506 net/ipv4/inet_diag.c entry.saddr = np->rcv_saddr.s6_addr32;
entry 507 net/ipv4/inet_diag.c entry.daddr = np->daddr.s6_addr32;
entry 511 net/ipv4/inet_diag.c entry.saddr = &inet->rcv_saddr;
entry 512 net/ipv4/inet_diag.c entry.daddr = &inet->daddr;
entry 514 net/ipv4/inet_diag.c entry.sport = inet->num;
entry 515 net/ipv4/inet_diag.c entry.dport = ntohs(inet->dport);
entry 516 net/ipv4/inet_diag.c entry.userlocks = sk->sk_userlocks;
entry 518 net/ipv4/inet_diag.c if (!inet_diag_bc_run(RTA_DATA(bc), RTA_PAYLOAD(bc), &entry))
entry 534 net/ipv4/inet_diag.c struct inet_diag_entry entry;
entry 537 net/ipv4/inet_diag.c entry.family = tw->tw_family;
entry 542 net/ipv4/inet_diag.c entry.saddr = tw6->tw_v6_rcv_saddr.s6_addr32;
entry 543 net/ipv4/inet_diag.c entry.daddr = tw6->tw_v6_daddr.s6_addr32;
entry 547 net/ipv4/inet_diag.c entry.saddr = &tw->tw_rcv_saddr;
entry 548 net/ipv4/inet_diag.c entry.daddr = &tw->tw_daddr;
entry 550 net/ipv4/inet_diag.c entry.sport = tw->tw_num;
entry 551 net/ipv4/inet_diag.c entry.dport = ntohs(tw->tw_dport);
entry 552 net/ipv4/inet_diag.c entry.userlocks = 0;
entry 554 net/ipv4/inet_diag.c if (!inet_diag_bc_run(RTA_DATA(bc), RTA_PAYLOAD(bc), &entry))
entry 620 net/ipv4/inet_diag.c struct inet_diag_entry entry;
entry 636 net/ipv4/inet_diag.c entry.family = sk->sk_family;
entry 646 net/ipv4/inet_diag.c entry.sport = inet->num;
entry 647 net/ipv4/inet_diag.c entry.userlocks = sk->sk_userlocks;
entry 664 net/ipv4/inet_diag.c entry.saddr =
entry 666 net/ipv4/inet_diag.c (entry.family == AF_INET6) ?
entry 670 net/ipv4/inet_diag.c entry.daddr =
entry 672 net/ipv4/inet_diag.c (entry.family == AF_INET6) ?
entry 676 net/ipv4/inet_diag.c entry.dport = ntohs(ireq->rmt_port);
entry 679 net/ipv4/inet_diag.c RTA_PAYLOAD(bc), &entry))
entry 133 net/ipv4/netfilter.c struct ip_rt_info *rt_info = nf_queue_entry_reroute(entry);
entry 135 net/ipv4/netfilter.c if (entry->hook == NF_INET_LOCAL_OUT) {
entry 147 net/ipv4/netfilter.c const struct ip_rt_info *rt_info = nf_queue_entry_reroute(entry);
entry 149 net/ipv4/netfilter.c if (entry->hook == NF_INET_LOCAL_OUT) {
entry 56 net/ipv4/netfilter/ip_queue.c list_add_tail(&entry->list, &queue_list);
entry 100 net/ipv4/netfilter/ip_queue.c struct nf_queue_entry *entry = NULL, *i;
entry 106 net/ipv4/netfilter/ip_queue.c entry = i;
entry 111 net/ipv4/netfilter/ip_queue.c if (entry) {
entry 112 net/ipv4/netfilter/ip_queue.c list_del(&entry->list);
entry 117 net/ipv4/netfilter/ip_queue.c return entry;
entry 123 net/ipv4/netfilter/ip_queue.c struct nf_queue_entry *entry, *next;
entry 125 net/ipv4/netfilter/ip_queue.c list_for_each_entry_safe(entry, next, &queue_list, list) {
entry 126 net/ipv4/netfilter/ip_queue.c if (!cmpfn || cmpfn(entry, data)) {
entry 127 net/ipv4/netfilter/ip_queue.c list_del(&entry->list);
entry 129 net/ipv4/netfilter/ip_queue.c nf_reinject(entry, NF_DROP);
entry 162 net/ipv4/netfilter/ip_queue.c if ((entry->skb->ip_summed == CHECKSUM_PARTIAL ||
entry 163 net/ipv4/netfilter/ip_queue.c entry->skb->ip_summed == CHECKSUM_COMPLETE) &&
entry 164 net/ipv4/netfilter/ip_queue.c (*errp = skb_checksum_help(entry->skb))) {
entry 168 net/ipv4/netfilter/ip_queue.c if (copy_range == 0 || copy_range > entry->skb->len)
entry 169 net/ipv4/netfilter/ip_queue.c data_len = entry->skb->len;
entry 193 net/ipv4/netfilter/ip_queue.c pmsg->packet_id = (unsigned long )entry;
entry 195 net/ipv4/netfilter/ip_queue.c tv = ktime_to_timeval(entry->skb->tstamp);
entry 198 net/ipv4/netfilter/ip_queue.c pmsg->mark = entry->skb->mark;
entry 199 net/ipv4/netfilter/ip_queue.c pmsg->hook = entry->hook;
entry 200 net/ipv4/netfilter/ip_queue.c pmsg->hw_protocol = entry->skb->protocol;
entry 202 net/ipv4/netfilter/ip_queue.c if (entry->indev)
entry 203 net/ipv4/netfilter/ip_queue.c strcpy(pmsg->indev_name, entry->indev->name);
entry 207 net/ipv4/netfilter/ip_queue.c if (entry->outdev)
entry 208 net/ipv4/netfilter/ip_queue.c strcpy(pmsg->outdev_name, entry->outdev->name);
entry 212 net/ipv4/netfilter/ip_queue.c if (entry->indev && entry->skb->dev) {
entry 213 net/ipv4/netfilter/ip_queue.c pmsg->hw_type = entry->skb->dev->type;
entry 214 net/ipv4/netfilter/ip_queue.c pmsg->hw_addrlen = dev_parse_header(entry->skb,
entry 219 net/ipv4/netfilter/ip_queue.c if (skb_copy_bits(entry->skb, 0, pmsg->payload, data_len))
entry 240 net/ipv4/netfilter/ip_queue.c nskb = ipq_build_packet_message(entry, &status);
entry 266 net/ipv4/netfilter/ip_queue.c __ipq_enqueue_entry(entry);
entry 319 net/ipv4/netfilter/ip_queue.c struct nf_queue_entry *entry;
entry 324 net/ipv4/netfilter/ip_queue.c entry = ipq_find_dequeue_entry(vmsg->id);
entry 325 net/ipv4/netfilter/ip_queue.c if (entry == NULL)
entry 331 net/ipv4/netfilter/ip_queue.c if (ipq_mangle_ipv4(vmsg, entry) < 0)
entry 334 net/ipv4/netfilter/ip_queue.c nf_reinject(entry, verdict);
entry 381 net/ipv4/netfilter/ip_queue.c if (entry->indev)
entry 382 net/ipv4/netfilter/ip_queue.c if (entry->indev->ifindex == ifindex)
entry 384 net/ipv4/netfilter/ip_queue.c if (entry->outdev)
entry 385 net/ipv4/netfilter/ip_queue.c if (entry->outdev->ifindex == ifindex)
entry 388 net/ipv4/netfilter/ip_queue.c if (entry->skb->nf_bridge) {
entry 389 net/ipv4/netfilter/ip_queue.c if (entry->skb->nf_bridge->physindev &&
entry 390 net/ipv4/netfilter/ip_queue.c entry->skb->nf_bridge->physindev->ifindex == ifindex)
entry 392 net/ipv4/netfilter/ip_queue.c if (entry->skb->nf_bridge->physoutdev &&
entry 393 net/ipv4/netfilter/ip_queue.c entry->skb->nf_bridge->physoutdev->ifindex == ifindex)
entry 129 net/ipv4/netfilter/ipt_CLUSTERIP.c if (entry)
entry 328 net/ipv4/proc.c snmp4_ipstats_list[i].entry));
entry 340 net/ipv4/proc.c if (snmp4_tcp_list[i].entry == TCP_MIB_MAXCONN)
entry 343 net/ipv4/proc.c snmp4_tcp_list[i].entry));
entry 347 net/ipv4/proc.c snmp4_tcp_list[i].entry));
entry 358 net/ipv4/proc.c snmp4_udp_list[i].entry));
entry 369 net/ipv4/proc.c snmp4_udp_list[i].entry));
entry 406 net/ipv4/proc.c snmp4_net_list[i].entry));
entry 416 net/ipv4/proc.c snmp4_ipextstats_list[i].entry));
entry 134 net/ipv4/tcp_probe.c .entry = jtcp_rcv_established,
entry 64 net/ipv6/netfilter.c struct ip6_rt_info *rt_info = nf_queue_entry_reroute(entry);
entry 66 net/ipv6/netfilter.c if (entry->hook == NF_INET_LOCAL_OUT) {
entry 77 net/ipv6/netfilter.c struct ip6_rt_info *rt_info = nf_queue_entry_reroute(entry);
entry 79 net/ipv6/netfilter.c if (entry->hook == NF_INET_LOCAL_OUT) {
entry 59 net/ipv6/netfilter/ip6_queue.c list_add_tail(&entry->list, &queue_list);
entry 103 net/ipv6/netfilter/ip6_queue.c struct nf_queue_entry *entry = NULL, *i;
entry 109 net/ipv6/netfilter/ip6_queue.c entry = i;
entry 114 net/ipv6/netfilter/ip6_queue.c if (entry) {
entry 115 net/ipv6/netfilter/ip6_queue.c list_del(&entry->list);
entry 120 net/ipv6/netfilter/ip6_queue.c return entry;
entry 126 net/ipv6/netfilter/ip6_queue.c struct nf_queue_entry *entry, *next;
entry 128 net/ipv6/netfilter/ip6_queue.c list_for_each_entry_safe(entry, next, &queue_list, list) {
entry 129 net/ipv6/netfilter/ip6_queue.c if (!cmpfn || cmpfn(entry, data)) {
entry 130 net/ipv6/netfilter/ip6_queue.c list_del(&entry->list);
entry 132 net/ipv6/netfilter/ip6_queue.c nf_reinject(entry, NF_DROP);
entry 165 net/ipv6/netfilter/ip6_queue.c if ((entry->skb->ip_summed == CHECKSUM_PARTIAL ||
entry 166 net/ipv6/netfilter/ip6_queue.c entry->skb->ip_summed == CHECKSUM_COMPLETE) &&
entry 167 net/ipv6/netfilter/ip6_queue.c (*errp = skb_checksum_help(entry->skb))) {
entry 171 net/ipv6/netfilter/ip6_queue.c if (copy_range == 0 || copy_range > entry->skb->len)
entry 172 net/ipv6/netfilter/ip6_queue.c data_len = entry->skb->len;
entry 196 net/ipv6/netfilter/ip6_queue.c pmsg->packet_id = (unsigned long )entry;
entry 198 net/ipv6/netfilter/ip6_queue.c tv = ktime_to_timeval(entry->skb->tstamp);
entry 201 net/ipv6/netfilter/ip6_queue.c pmsg->mark = entry->skb->mark;
entry 202 net/ipv6/netfilter/ip6_queue.c pmsg->hook = entry->hook;
entry 203 net/ipv6/netfilter/ip6_queue.c pmsg->hw_protocol = entry->skb->protocol;
entry 205 net/ipv6/netfilter/ip6_queue.c if (entry->indev)
entry 206 net/ipv6/netfilter/ip6_queue.c strcpy(pmsg->indev_name, entry->indev->name);
entry 210 net/ipv6/netfilter/ip6_queue.c if (entry->outdev)
entry 211 net/ipv6/netfilter/ip6_queue.c strcpy(pmsg->outdev_name, entry->outdev->name);
entry 215 net/ipv6/netfilter/ip6_queue.c if (entry->indev && entry->skb->dev) {
entry 216 net/ipv6/netfilter/ip6_queue.c pmsg->hw_type = entry->skb->dev->type;
entry 217 net/ipv6/netfilter/ip6_queue.c pmsg->hw_addrlen = dev_parse_header(entry->skb, pmsg->hw_addr);
entry 221 net/ipv6/netfilter/ip6_queue.c if (skb_copy_bits(entry->skb, 0, pmsg->payload, data_len))
entry 242 net/ipv6/netfilter/ip6_queue.c nskb = ipq_build_packet_message(entry, &status);
entry 268 net/ipv6/netfilter/ip6_queue.c __ipq_enqueue_entry(entry);
entry 321 net/ipv6/netfilter/ip6_queue.c struct nf_queue_entry *entry;
entry 326 net/ipv6/netfilter/ip6_queue.c entry = ipq_find_dequeue_entry(vmsg->id);
entry 327 net/ipv6/netfilter/ip6_queue.c if (entry == NULL)
entry 333 net/ipv6/netfilter/ip6_queue.c if (ipq_mangle_ipv6(vmsg, entry) < 0)
entry 336 net/ipv6/netfilter/ip6_queue.c nf_reinject(entry, verdict);
entry 383 net/ipv6/netfilter/ip6_queue.c if (entry->indev)
entry 384 net/ipv6/netfilter/ip6_queue.c if (entry->indev->ifindex == ifindex)
entry 387 net/ipv6/netfilter/ip6_queue.c if (entry->outdev)
entry 388 net/ipv6/netfilter/ip6_queue.c if (entry->outdev->ifindex == ifindex)
entry 391 net/ipv6/netfilter/ip6_queue.c if (entry->skb->nf_bridge) {
entry 392 net/ipv6/netfilter/ip6_queue.c if (entry->skb->nf_bridge->physindev &&
entry 393 net/ipv6/netfilter/ip6_queue.c entry->skb->nf_bridge->physindev->ifindex == ifindex)
entry 395 net/ipv6/netfilter/ip6_queue.c if (entry->skb->nf_bridge->physoutdev &&
entry 396 net/ipv6/netfilter/ip6_queue.c entry->skb->nf_bridge->physoutdev->ifindex == ifindex)
entry 173 net/ipv6/proc.c snmp_fold_field(mib, itemlist[i].entry));
entry 189 net/irda/ircomm/ircomm_core.c struct ircomm_cb *entry;
entry 196 net/irda/ircomm/ircomm_core.c entry = hashbin_remove(ircomm, self->line, NULL);
entry 198 net/irda/ircomm/ircomm_core.c IRDA_ASSERT(entry == self, return -1;);
entry 242 net/irda/iriap.c struct iriap_cb *entry;
entry 254 net/irda/iriap.c entry = (struct iriap_cb *) hashbin_remove(iriap, (long) self, NULL);
entry 255 net/irda/iriap.c IRDA_ASSERT(entry == self, return;);
entry 624 net/irda/irnet/irnet_irda.c struct irnet_socket * entry;
entry 627 net/irda/irnet/irnet_irda.c entry = hashbin_remove_this(irnet_server.list, (irda_queue_t *) self);
entry 630 net/irda/irnet/irnet_irda.c DASSERT(entry == self, , IRDA_SOCK_ERROR, "Can't remove from hash.\n");
entry 474 net/irda/irqueue.c entry->q_hash = hashv;
entry 476 net/irda/irqueue.c strlcpy( entry->q_name, name, sizeof(entry->q_name));
entry 482 net/irda/irqueue.c entry);
entry 504 net/irda/irqueue.c irda_queue_t *entry = NULL;
entry 511 net/irda/irqueue.c entry = hashbin_get_first( hashbin);
entry 512 net/irda/irqueue.c if ( entry != NULL) {
entry 518 net/irda/irqueue.c hashv = entry->q_hash;
entry 525 net/irda/irqueue.c (irda_queue_t*) entry );
entry 527 net/irda/irqueue.c entry->q_next = NULL;
entry 528 net/irda/irqueue.c entry->q_prev = NULL;
entry 534 net/irda/irqueue.c if ( entry == hashbin->hb_current)
entry 543 net/irda/irqueue.c return entry;
entry 565 net/irda/irqueue.c irda_queue_t* entry;
entry 587 net/irda/irqueue.c entry = hashbin->hb_queue[ bin ];
entry 588 net/irda/irqueue.c if ( entry ) {
entry 593 net/irda/irqueue.c if ( entry->q_hash == hashv ) {
entry 598 net/irda/irqueue.c if ( strcmp( entry->q_name, name) == 0)
entry 608 net/irda/irqueue.c entry = entry->q_next;
entry 609 net/irda/irqueue.c } while ( entry != hashbin->hb_queue[ bin ] );
entry 617 net/irda/irqueue.c (irda_queue_t*) entry );
entry 624 net/irda/irqueue.c if ( entry == hashbin->hb_current)
entry 636 net/irda/irqueue.c return entry;
entry 664 net/irda/irqueue.c IRDA_ASSERT( entry != NULL, return NULL;);
entry 672 net/irda/irqueue.c if((entry->q_next == NULL) || (entry->q_prev == NULL)) {
entry 673 net/irda/irqueue.c entry = NULL;
entry 680 net/irda/irqueue.c hashv = entry->q_hash;
entry 687 net/irda/irqueue.c (irda_queue_t*) entry );
entry 689 net/irda/irqueue.c entry->q_next = NULL;
entry 690 net/irda/irqueue.c entry->q_prev = NULL;
entry 696 net/irda/irqueue.c if ( entry == hashbin->hb_current)
entry 704 net/irda/irqueue.c return entry;
entry 719 net/irda/irqueue.c irda_queue_t* entry;
entry 736 net/irda/irqueue.c entry = hashbin->hb_queue[ bin];
entry 737 net/irda/irqueue.c if ( entry ) {
entry 742 net/irda/irqueue.c if ( entry->q_hash == hashv ) {
entry 747 net/irda/irqueue.c if ( strcmp( entry->q_name, name ) == 0 ) {
entry 748 net/irda/irqueue.c return entry;
entry 751 net/irda/irqueue.c return entry;
entry 754 net/irda/irqueue.c entry = entry->q_next;
entry 755 net/irda/irqueue.c } while ( entry != hashbin->hb_queue[ bin ] );
entry 774 net/irda/irqueue.c irda_queue_t* entry;
entry 782 net/irda/irqueue.c entry = (irda_queue_t* ) hashbin_find( hashbin, hashv, name );
entry 787 net/irda/irqueue.c return entry;
entry 805 net/irda/irqueue.c irda_queue_t* entry;
entry 815 net/irda/irqueue.c entry = (irda_queue_t* ) hashbin_find( hashbin, hashv, name );
entry 820 net/irda/irqueue.c if(entry) {
entry 821 net/irda/irqueue.c hashbin->hb_current = entry;
entry 829 net/irda/irqueue.c return entry;
entry 841 net/irda/irqueue.c irda_queue_t *entry;
entry 851 net/irda/irqueue.c entry = hashbin->hb_queue[ i];
entry 852 net/irda/irqueue.c if ( entry) {
entry 853 net/irda/irqueue.c hashbin->hb_current = entry;
entry 854 net/irda/irqueue.c return entry;
entry 876 net/irda/irqueue.c irda_queue_t* entry;
entry 887 net/irda/irqueue.c entry = hashbin->hb_current->q_next;
entry 888 net/irda/irqueue.c bin = GET_HASHBIN( entry->q_hash);
entry 894 net/irda/irqueue.c if ( entry != hashbin->hb_queue[ bin ]) {
entry 895 net/irda/irqueue.c hashbin->hb_current = entry;
entry 897 net/irda/irqueue.c return entry;
entry 911 net/irda/irqueue.c entry = hashbin->hb_queue[ i];
entry 912 net/irda/irqueue.c if ( entry) {
entry 913 net/irda/irqueue.c hashbin->hb_current = entry;
entry 915 net/irda/irqueue.c return entry;
entry 86 net/lapb/lapb_iface.c struct list_head *entry;
entry 89 net/lapb/lapb_iface.c list_for_each(entry, &lapb_list) {
entry 90 net/lapb/lapb_iface.c lapb = list_entry(entry, struct lapb_cb, node);
entry 780 net/mac80211/rx.c struct ieee80211_fragment_entry *entry;
entry 784 net/mac80211/rx.c entry = &sdata->fragments[sdata->fragment_next++];
entry 788 net/mac80211/rx.c if (!skb_queue_empty(&entry->skb_list)) {
entry 791 net/mac80211/rx.c (struct ieee80211_hdr *) entry->skb_list.next->data;
entry 798 net/mac80211/rx.c jiffies - entry->first_frag_time, entry->seq,
entry 799 net/mac80211/rx.c entry->last_frag, print_mac(mac, hdr->addr1),
entry 802 net/mac80211/rx.c __skb_queue_purge(&entry->skb_list);
entry 805 net/mac80211/rx.c __skb_queue_tail(&entry->skb_list, *skb); /* no need for locking */
entry 807 net/mac80211/rx.c entry->first_frag_time = jiffies;
entry 808 net/mac80211/rx.c entry->seq = seq;
entry 809 net/mac80211/rx.c entry->rx_queue = rx_queue;
entry 810 net/mac80211/rx.c entry->last_frag = frag;
entry 811 net/mac80211/rx.c entry->ccmp = 0;
entry 812 net/mac80211/rx.c entry->extra_len = 0;
entry 814 net/mac80211/rx.c return entry;
entry 822 net/mac80211/rx.c struct ieee80211_fragment_entry *entry;
entry 833 net/mac80211/rx.c entry = &sdata->fragments[idx];
entry 834 net/mac80211/rx.c if (skb_queue_empty(&entry->skb_list) || entry->seq != seq ||
entry 835 net/mac80211/rx.c entry->rx_queue != rx_queue ||
entry 836 net/mac80211/rx.c entry->last_frag + 1 != frag)
entry 839 net/mac80211/rx.c f_hdr = (struct ieee80211_hdr *)entry->skb_list.next->data;
entry 850 net/mac80211/rx.c if (time_after(jiffies, entry->first_frag_time + 2 * HZ)) {
entry 851 net/mac80211/rx.c __skb_queue_purge(&entry->skb_list);
entry 854 net/mac80211/rx.c return entry;
entry 867 net/mac80211/rx.c struct ieee80211_fragment_entry *entry;
entry 888 net/mac80211/rx.c entry = ieee80211_reassemble_add(rx->sdata, frag, seq,
entry 894 net/mac80211/rx.c entry->ccmp = 1;
entry 895 net/mac80211/rx.c memcpy(entry->last_pn,
entry 905 net/mac80211/rx.c entry = ieee80211_reassemble_find(rx->sdata, frag, seq, rx->queue, hdr);
entry 906 net/mac80211/rx.c if (!entry) {
entry 913 net/mac80211/rx.c if (entry->ccmp) {
entry 918 net/mac80211/rx.c memcpy(pn, entry->last_pn, CCMP_PN_LEN);
entry 927 net/mac80211/rx.c memcpy(entry->last_pn, pn, CCMP_PN_LEN);
entry 931 net/mac80211/rx.c __skb_queue_tail(&entry->skb_list, rx->skb);
entry 932 net/mac80211/rx.c entry->last_frag = frag;
entry 933 net/mac80211/rx.c entry->extra_len += rx->skb->len;
entry 939 net/mac80211/rx.c rx->skb = __skb_dequeue(&entry->skb_list);
entry 940 net/mac80211/rx.c if (skb_tailroom(rx->skb) < entry->extra_len) {
entry 942 net/mac80211/rx.c if (unlikely(pskb_expand_head(rx->skb, 0, entry->extra_len,
entry 945 net/mac80211/rx.c __skb_queue_purge(&entry->skb_list);
entry 949 net/mac80211/rx.c while ((skb = __skb_dequeue(&entry->skb_list))) {
entry 2237 net/netfilter/ipvs/ip_vs_ctl.c struct ip_vs_service_entry entry;
entry 2248 net/netfilter/ipvs/ip_vs_ctl.c memset(&entry, 0, sizeof(entry));
entry 2249 net/netfilter/ipvs/ip_vs_ctl.c ip_vs_copy_service(&entry, svc);
entry 2251 net/netfilter/ipvs/ip_vs_ctl.c &entry, sizeof(entry))) {
entry 2267 net/netfilter/ipvs/ip_vs_ctl.c memset(&entry, 0, sizeof(entry));
entry 2268 net/netfilter/ipvs/ip_vs_ctl.c ip_vs_copy_service(&entry, svc);
entry 2270 net/netfilter/ipvs/ip_vs_ctl.c &entry, sizeof(entry))) {
entry 2298 net/netfilter/ipvs/ip_vs_ctl.c struct ip_vs_dest_entry entry;
entry 2304 net/netfilter/ipvs/ip_vs_ctl.c entry.addr = dest->addr.ip;
entry 2305 net/netfilter/ipvs/ip_vs_ctl.c entry.port = dest->port;
entry 2306 net/netfilter/ipvs/ip_vs_ctl.c entry.conn_flags = atomic_read(&dest->conn_flags);
entry 2307 net/netfilter/ipvs/ip_vs_ctl.c entry.weight = atomic_read(&dest->weight);
entry 2308 net/netfilter/ipvs/ip_vs_ctl.c entry.u_threshold = dest->u_threshold;
entry 2309 net/netfilter/ipvs/ip_vs_ctl.c entry.l_threshold = dest->l_threshold;
entry 2310 net/netfilter/ipvs/ip_vs_ctl.c entry.activeconns = atomic_read(&dest->activeconns);
entry 2311 net/netfilter/ipvs/ip_vs_ctl.c entry.inactconns = atomic_read(&dest->inactconns);
entry 2312 net/netfilter/ipvs/ip_vs_ctl.c entry.persistconns = atomic_read(&dest->persistconns);
entry 2313 net/netfilter/ipvs/ip_vs_ctl.c ip_vs_copy_stats(&entry.stats, &dest->stats);
entry 2315 net/netfilter/ipvs/ip_vs_ctl.c &entry, sizeof(entry))) {
entry 2427 net/netfilter/ipvs/ip_vs_ctl.c struct ip_vs_service_entry *entry;
entry 2431 net/netfilter/ipvs/ip_vs_ctl.c entry = (struct ip_vs_service_entry *)arg;
entry 2432 net/netfilter/ipvs/ip_vs_ctl.c addr.ip = entry->addr;
entry 2433 net/netfilter/ipvs/ip_vs_ctl.c if (entry->fwmark)
entry 2434 net/netfilter/ipvs/ip_vs_ctl.c svc = __ip_vs_svc_fwm_get(AF_INET, entry->fwmark);
entry 2436 net/netfilter/ipvs/ip_vs_ctl.c svc = __ip_vs_service_get(AF_INET, entry->protocol,
entry 2437 net/netfilter/ipvs/ip_vs_ctl.c &addr, entry->port);
entry 2439 net/netfilter/ipvs/ip_vs_ctl.c ip_vs_copy_service(entry, svc);
entry 2440 net/netfilter/ipvs/ip_vs_ctl.c if (copy_to_user(user, entry, sizeof(*entry)) != 0)
entry 86 net/netfilter/nf_queue.c if (entry->indev)
entry 87 net/netfilter/nf_queue.c dev_put(entry->indev);
entry 88 net/netfilter/nf_queue.c if (entry->outdev)
entry 89 net/netfilter/nf_queue.c dev_put(entry->outdev);
entry 91 net/netfilter/nf_queue.c if (entry->skb->nf_bridge) {
entry 92 net/netfilter/nf_queue.c struct nf_bridge_info *nf_bridge = entry->skb->nf_bridge;
entry 101 net/netfilter/nf_queue.c module_put(entry->elem->owner);
entry 117 net/netfilter/nf_queue.c struct nf_queue_entry *entry = NULL;
entry 136 net/netfilter/nf_queue.c entry = kmalloc(sizeof(*entry) + afinfo->route_key_size, GFP_ATOMIC);
entry 137 net/netfilter/nf_queue.c if (!entry)
entry 140 net/netfilter/nf_queue.c *entry = (struct nf_queue_entry) {
entry 151 net/netfilter/nf_queue.c if (!try_module_get(entry->elem->owner)) {
entry 153 net/netfilter/nf_queue.c kfree(entry);
entry 172 net/netfilter/nf_queue.c afinfo->saveroute(skb, entry);
entry 173 net/netfilter/nf_queue.c status = qh->outfn(entry, queuenum);
entry 178 net/netfilter/nf_queue.c nf_queue_entry_release_refs(entry);
entry 188 net/netfilter/nf_queue.c kfree(entry);
entry 234 net/netfilter/nf_queue.c struct sk_buff *skb = entry->skb;
entry 235 net/netfilter/nf_queue.c struct list_head *elem = &entry->elem->list;
entry 240 net/netfilter/nf_queue.c nf_queue_entry_release_refs(entry);
entry 249 net/netfilter/nf_queue.c afinfo = nf_get_afinfo(entry->pf);
entry 250 net/netfilter/nf_queue.c if (!afinfo || afinfo->reroute(skb, entry) < 0)
entry 256 net/netfilter/nf_queue.c verdict = nf_iterate(&nf_hooks[entry->pf][entry->hook],
entry 257 net/netfilter/nf_queue.c skb, entry->hook,
entry 258 net/netfilter/nf_queue.c entry->indev, entry->outdev, &elem,
entry 259 net/netfilter/nf_queue.c entry->okfn, INT_MIN);
entry 266 net/netfilter/nf_queue.c entry->okfn(skb);
entry 271 net/netfilter/nf_queue.c if (!__nf_queue(skb, elem, entry->pf, entry->hook,
entry 272 net/netfilter/nf_queue.c entry->indev, entry->outdev, entry->okfn,
entry 280 net/netfilter/nf_queue.c kfree(entry);
entry 168 net/netfilter/nfnetlink_queue.c list_add_tail(&entry->list, &queue->queue_list);
entry 175 net/netfilter/nfnetlink_queue.c struct nf_queue_entry *entry = NULL, *i;
entry 181 net/netfilter/nfnetlink_queue.c entry = i;
entry 186 net/netfilter/nfnetlink_queue.c if (entry) {
entry 187 net/netfilter/nfnetlink_queue.c list_del(&entry->list);
entry 193 net/netfilter/nfnetlink_queue.c return entry;
entry 199 net/netfilter/nfnetlink_queue.c struct nf_queue_entry *entry, *next;
entry 202 net/netfilter/nfnetlink_queue.c list_for_each_entry_safe(entry, next, &queue->queue_list, list) {
entry 203 net/netfilter/nfnetlink_queue.c if (!cmpfn || cmpfn(entry, data)) {
entry 204 net/netfilter/nfnetlink_queue.c list_del(&entry->list);
entry 206 net/netfilter/nfnetlink_queue.c nf_reinject(entry, NF_DROP);
entry 223 net/netfilter/nfnetlink_queue.c struct sk_buff *entskb = entry->skb;
entry 239 net/netfilter/nfnetlink_queue.c outdev = entry->outdev;
entry 265 net/netfilter/nfnetlink_queue.c entry->id = queue->id_sequence++;
entry 278 net/netfilter/nfnetlink_queue.c nfmsg->nfgen_family = entry->pf;
entry 282 net/netfilter/nfnetlink_queue.c pmsg.packet_id = htonl(entry->id);
entry 284 net/netfilter/nfnetlink_queue.c pmsg.hook = entry->hook;
entry 288 net/netfilter/nfnetlink_queue.c indev = entry->indev;
entry 293 net/netfilter/nfnetlink_queue.c if (entry->pf == PF_BRIDGE) {
entry 318 net/netfilter/nfnetlink_queue.c if (entry->pf == PF_BRIDGE) {
entry 404 net/netfilter/nfnetlink_queue.c nskb = nfqnl_build_packet_message(queue, entry);
entry 429 net/netfilter/nfnetlink_queue.c __enqueue_entry(queue, entry);
entry 510 net/netfilter/nfnetlink_queue.c if (entry->indev)
entry 511 net/netfilter/nfnetlink_queue.c if (entry->indev->ifindex == ifindex)
entry 513 net/netfilter/nfnetlink_queue.c if (entry->outdev)
entry 514 net/netfilter/nfnetlink_queue.c if (entry->outdev->ifindex == ifindex)
entry 517 net/netfilter/nfnetlink_queue.c if (entry->skb->nf_bridge) {
entry 518 net/netfilter/nfnetlink_queue.c if (entry->skb->nf_bridge->physindev &&
entry 519 net/netfilter/nfnetlink_queue.c entry->skb->nf_bridge->physindev->ifindex == ifindex)
entry 521 net/netfilter/nfnetlink_queue.c if (entry->skb->nf_bridge->physoutdev &&
entry 522 net/netfilter/nfnetlink_queue.c entry->skb->nf_bridge->physoutdev->ifindex == ifindex)
entry 619 net/netfilter/nfnetlink_queue.c struct nf_queue_entry *entry;
entry 647 net/netfilter/nfnetlink_queue.c entry = find_dequeue_entry(queue, ntohl(vhdr->id));
entry 648 net/netfilter/nfnetlink_queue.c if (entry == NULL) {
entry 656 net/netfilter/nfnetlink_queue.c nla_len(nfqa[NFQA_PAYLOAD]), entry) < 0)
entry 661 net/netfilter/nfnetlink_queue.c entry->skb->mark = ntohl(nla_get_be32(nfqa[NFQA_MARK]));
entry 663 net/netfilter/nfnetlink_queue.c nf_reinject(entry, verdict);
entry 167 net/netlabel/netlabel_addrlist.c iter = netlbl_af4list_search(entry->addr, head);
entry 169 net/netlabel/netlabel_addrlist.c iter->addr == entry->addr && iter->mask == entry->mask)
entry 178 net/netlabel/netlabel_addrlist.c ntohl(entry->mask) > ntohl(iter->mask)) {
entry 179 net/netlabel/netlabel_addrlist.c __list_add_rcu(&entry->list,
entry 184 net/netlabel/netlabel_addrlist.c list_add_tail_rcu(&entry->list, head);
entry 204 net/netlabel/netlabel_addrlist.c iter = netlbl_af6list_search(&entry->addr, head);
entry 206 net/netlabel/netlabel_addrlist.c ipv6_addr_equal(&iter->addr, &entry->addr) &&
entry 207 net/netlabel/netlabel_addrlist.c ipv6_addr_equal(&iter->mask, &entry->mask))
entry 216 net/netlabel/netlabel_addrlist.c ipv6_addr_cmp(&entry->mask, &iter->mask) > 0) {
entry 217 net/netlabel/netlabel_addrlist.c __list_add_rcu(&entry->list,
entry 222 net/netlabel/netlabel_addrlist.c list_add_tail_rcu(&entry->list, head);
entry 238 net/netlabel/netlabel_addrlist.c entry->valid = 0;
entry 239 net/netlabel/netlabel_addrlist.c list_del_rcu(&entry->list);
entry 257 net/netlabel/netlabel_addrlist.c struct netlbl_af4list *entry;
entry 259 net/netlabel/netlabel_addrlist.c entry = netlbl_af4list_search(addr, head);
entry 260 net/netlabel/netlabel_addrlist.c if (entry != NULL && entry->addr == addr && entry->mask == mask) {
entry 261 net/netlabel/netlabel_addrlist.c netlbl_af4list_remove_entry(entry);
entry 262 net/netlabel/netlabel_addrlist.c return entry;
entry 280 net/netlabel/netlabel_addrlist.c entry->valid = 0;
entry 281 net/netlabel/netlabel_addrlist.c list_del_rcu(&entry->list);
entry 300 net/netlabel/netlabel_addrlist.c struct netlbl_af6list *entry;
entry 302 net/netlabel/netlabel_addrlist.c entry = netlbl_af6list_search(addr, head);
entry 303 net/netlabel/netlabel_addrlist.c if (entry != NULL &&
entry 304 net/netlabel/netlabel_addrlist.c ipv6_addr_equal(&entry->addr, addr) &&
entry 305 net/netlabel/netlabel_addrlist.c ipv6_addr_equal(&entry->mask, mask)) {
entry 306 net/netlabel/netlabel_addrlist.c netlbl_af6list_remove_entry(entry);
entry 307 net/netlabel/netlabel_addrlist.c return entry;
entry 708 net/netlabel/netlabel_cipso_v4.c if (entry->type == NETLBL_NLTYPE_CIPSOV4 &&
entry 709 net/netlabel/netlabel_cipso_v4.c entry->type_def.cipsov4->doi == cb_arg->doi)
entry 710 net/netlabel/netlabel_cipso_v4.c return netlbl_domhsh_remove_entry(entry, cb_arg->audit_info);
entry 83 net/netlabel/netlabel_domainhash.c ptr = container_of(entry, struct netlbl_dom_map, rcu);
entry 168 net/netlabel/netlabel_domainhash.c struct netlbl_dom_map *entry;
entry 170 net/netlabel/netlabel_domainhash.c entry = netlbl_domhsh_search(domain);
entry 171 net/netlabel/netlabel_domainhash.c if (entry == NULL) {
entry 172 net/netlabel/netlabel_domainhash.c entry = rcu_dereference(netlbl_domhsh_def);
entry 173 net/netlabel/netlabel_domainhash.c if (entry != NULL && !entry->valid)
entry 174 net/netlabel/netlabel_domainhash.c entry = NULL;
entry 177 net/netlabel/netlabel_domainhash.c return entry;
entry 207 net/netlabel/netlabel_domainhash.c entry->domain ? entry->domain : "(default)");
entry 224 net/netlabel/netlabel_domainhash.c type = entry->type;
entry 225 net/netlabel/netlabel_domainhash.c cipsov4 = entry->type_def.cipsov4;
entry 312 net/netlabel/netlabel_domainhash.c if (entry->domain != NULL)
entry 313 net/netlabel/netlabel_domainhash.c entry_old = netlbl_domhsh_search(entry->domain);
entry 315 net/netlabel/netlabel_domainhash.c entry_old = netlbl_domhsh_search_def(entry->domain);
entry 317 net/netlabel/netlabel_domainhash.c entry->valid = 1;
entry 318 net/netlabel/netlabel_domainhash.c INIT_RCU_HEAD(&entry->rcu);
entry 320 net/netlabel/netlabel_domainhash.c if (entry->domain != NULL) {
entry 321 net/netlabel/netlabel_domainhash.c u32 bkt = netlbl_domhsh_hash(entry->domain);
entry 322 net/netlabel/netlabel_domainhash.c list_add_tail_rcu(&entry->list,
entry 325 net/netlabel/netlabel_domainhash.c INIT_LIST_HEAD(&entry->list);
entry 326 net/netlabel/netlabel_domainhash.c rcu_assign_pointer(netlbl_domhsh_def, entry);
entry 329 net/netlabel/netlabel_domainhash.c if (entry->type == NETLBL_NLTYPE_ADDRSELECT) {
entry 331 net/netlabel/netlabel_domainhash.c &entry->type_def.addrsel->list4)
entry 332 net/netlabel/netlabel_domainhash.c netlbl_domhsh_audit_add(entry, iter4, NULL,
entry 336 net/netlabel/netlabel_domainhash.c &entry->type_def.addrsel->list6)
entry 337 net/netlabel/netlabel_domainhash.c netlbl_domhsh_audit_add(entry, NULL, iter6,
entry 341 net/netlabel/netlabel_domainhash.c netlbl_domhsh_audit_add(entry, NULL, NULL,
entry 344 net/netlabel/netlabel_domainhash.c entry->type == NETLBL_NLTYPE_ADDRSELECT) {
entry 354 net/netlabel/netlabel_domainhash.c &entry->type_def.addrsel->list4)
entry 363 net/netlabel/netlabel_domainhash.c &entry->type_def.addrsel->list6)
entry 373 net/netlabel/netlabel_domainhash.c &entry->type_def.addrsel->list4) {
entry 384 net/netlabel/netlabel_domainhash.c &entry->type_def.addrsel->list6) {
entry 417 net/netlabel/netlabel_domainhash.c return netlbl_domhsh_add(entry, audit_info);
entry 438 net/netlabel/netlabel_domainhash.c if (entry == NULL)
entry 442 net/netlabel/netlabel_domainhash.c if (entry->valid) {
entry 443 net/netlabel/netlabel_domainhash.c entry->valid = 0;
entry 444 net/netlabel/netlabel_domainhash.c if (entry != rcu_dereference(netlbl_domhsh_def))
entry 445 net/netlabel/netlabel_domainhash.c list_del_rcu(&entry->list);
entry 456 net/netlabel/netlabel_domainhash.c entry->domain ? entry->domain : "(default)",
entry 465 net/netlabel/netlabel_domainhash.c switch (entry->type) {
entry 468 net/netlabel/netlabel_domainhash.c &entry->type_def.addrsel->list4) {
entry 476 net/netlabel/netlabel_domainhash.c cipso_v4_doi_putdef(entry->type_def.cipsov4);
entry 479 net/netlabel/netlabel_domainhash.c call_rcu(&entry->rcu, netlbl_domhsh_free_entry);
entry 499 net/netlabel/netlabel_domainhash.c struct netlbl_dom_map *entry;
entry 503 net/netlabel/netlabel_domainhash.c entry = netlbl_domhsh_search(domain);
entry 505 net/netlabel/netlabel_domainhash.c entry = netlbl_domhsh_search_def(domain);
entry 506 net/netlabel/netlabel_domainhash.c ret_val = netlbl_domhsh_remove_entry(entry, audit_info);
entry 81 net/netlabel/netlabel_kapi.c struct netlbl_dom_map *entry;
entry 83 net/netlabel/netlabel_kapi.c entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
entry 84 net/netlabel/netlabel_kapi.c if (entry == NULL)
entry 87 net/netlabel/netlabel_kapi.c entry->domain = kstrdup(domain, GFP_ATOMIC);
entry 88 net/netlabel/netlabel_kapi.c if (entry->domain == NULL)
entry 91 net/netlabel/netlabel_kapi.c entry->type = NETLBL_NLTYPE_UNLABELED;
entry 93 net/netlabel/netlabel_kapi.c ret_val = netlbl_domhsh_add(entry, audit_info);
entry 100 net/netlabel/netlabel_kapi.c if (entry != NULL)
entry 101 net/netlabel/netlabel_kapi.c kfree(entry->domain);
entry 102 net/netlabel/netlabel_kapi.c kfree(entry);
entry 126 net/netlabel/netlabel_kapi.c struct netlbl_dom_map *entry;
entry 133 net/netlabel/netlabel_kapi.c entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
entry 134 net/netlabel/netlabel_kapi.c if (entry == NULL)
entry 137 net/netlabel/netlabel_kapi.c entry->domain = kstrdup(domain, GFP_ATOMIC);
entry 138 net/netlabel/netlabel_kapi.c if (entry->domain == NULL)
entry 145 net/netlabel/netlabel_kapi.c entry->type = NETLBL_NLTYPE_CIPSOV4;
entry 146 net/netlabel/netlabel_kapi.c entry->type_def.cipsov4 = cipso_v4_doi_getdef(doi);
entry 147 net/netlabel/netlabel_kapi.c if (entry->type_def.cipsov4 == NULL) {
entry 151 net/netlabel/netlabel_kapi.c ret_val = netlbl_domhsh_add(entry, audit_info);
entry 185 net/netlabel/netlabel_kapi.c if (entry != NULL)
entry 186 net/netlabel/netlabel_kapi.c kfree(entry->domain);
entry 187 net/netlabel/netlabel_kapi.c kfree(entry);
entry 96 net/netlabel/netlabel_mgmt.c struct netlbl_dom_map *entry = NULL;
entry 101 net/netlabel/netlabel_mgmt.c entry = kzalloc(sizeof(*entry), GFP_KERNEL);
entry 102 net/netlabel/netlabel_mgmt.c if (entry == NULL) {
entry 106 net/netlabel/netlabel_mgmt.c entry->type = nla_get_u32(info->attrs[NLBL_MGMT_A_PROTOCOL]);
entry 109 net/netlabel/netlabel_mgmt.c entry->domain = kmalloc(tmp_size, GFP_KERNEL);
entry 110 net/netlabel/netlabel_mgmt.c if (entry->domain == NULL) {
entry 114 net/netlabel/netlabel_mgmt.c nla_strlcpy(entry->domain,
entry 123 net/netlabel/netlabel_mgmt.c switch (entry->type) {
entry 134 net/netlabel/netlabel_mgmt.c entry->type_def.cipsov4 = cipsov4;
entry 174 net/netlabel/netlabel_mgmt.c map->type = entry->type;
entry 184 net/netlabel/netlabel_mgmt.c entry->type = NETLBL_NLTYPE_ADDRSELECT;
entry 185 net/netlabel/netlabel_mgmt.c entry->type_def.addrsel = addrmap;
entry 225 net/netlabel/netlabel_mgmt.c map->type = entry->type;
entry 233 net/netlabel/netlabel_mgmt.c entry->type = NETLBL_NLTYPE_ADDRSELECT;
entry 234 net/netlabel/netlabel_mgmt.c entry->type_def.addrsel = addrmap;
entry 238 net/netlabel/netlabel_mgmt.c ret_val = netlbl_domhsh_add(entry, audit_info);
entry 247 net/netlabel/netlabel_mgmt.c if (entry)
entry 248 net/netlabel/netlabel_mgmt.c kfree(entry->domain);
entry 250 net/netlabel/netlabel_mgmt.c kfree(entry);
entry 276 net/netlabel/netlabel_mgmt.c if (entry->domain != NULL) {
entry 278 net/netlabel/netlabel_mgmt.c NLBL_MGMT_A_DOMAIN, entry->domain);
entry 283 net/netlabel/netlabel_mgmt.c switch (entry->type) {
entry 290 net/netlabel/netlabel_mgmt.c &entry->type_def.addrsel->list4) {
entry 328 net/netlabel/netlabel_mgmt.c &entry->type_def.addrsel->list6) {
entry 358 net/netlabel/netlabel_mgmt.c ret_val = nla_put_u32(skb, NLBL_MGMT_A_PROTOCOL, entry->type);
entry 361 net/netlabel/netlabel_mgmt.c ret_val = nla_put_u32(skb, NLBL_MGMT_A_PROTOCOL, entry->type);
entry 365 net/netlabel/netlabel_mgmt.c entry->type_def.cipsov4->doi);
entry 456 net/netlabel/netlabel_mgmt.c ret_val = netlbl_mgmt_listentry(cb_arg->skb, entry);
entry 565 net/netlabel/netlabel_mgmt.c struct netlbl_dom_map *entry;
entry 576 net/netlabel/netlabel_mgmt.c entry = netlbl_domhsh_getentry(NULL);
entry 577 net/netlabel/netlabel_mgmt.c if (entry == NULL) {
entry 581 net/netlabel/netlabel_mgmt.c ret_val = netlbl_mgmt_listentry(ans_skb, entry);
entry 166 net/netlabel/netlabel_unlabeled.c ptr = container_of(entry, struct netlbl_unlhsh_addr4, rcu);
entry 185 net/netlabel/netlabel_unlabeled.c ptr = container_of(entry, struct netlbl_unlhsh_addr6, rcu);
entry 213 net/netlabel/netlabel_unlabeled.c iface = container_of(entry, struct netlbl_unlhsh_iface, rcu);
entry 288 net/netlabel/netlabel_unlabeled.c struct netlbl_unlhsh_iface *entry;
entry 290 net/netlabel/netlabel_unlabeled.c entry = netlbl_unlhsh_search_iface(ifindex);
entry 291 net/netlabel/netlabel_unlabeled.c if (entry != NULL)
entry 292 net/netlabel/netlabel_unlabeled.c return entry;
entry 294 net/netlabel/netlabel_unlabeled.c entry = rcu_dereference(netlbl_unlhsh_def);
entry 295 net/netlabel/netlabel_unlabeled.c if (entry != NULL && entry->valid)
entry 296 net/netlabel/netlabel_unlabeled.c return entry;
entry 321 net/netlabel/netlabel_unlabeled.c struct netlbl_unlhsh_addr4 *entry;
entry 323 net/netlabel/netlabel_unlabeled.c entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
entry 324 net/netlabel/netlabel_unlabeled.c if (entry == NULL)
entry 327 net/netlabel/netlabel_unlabeled.c entry->list.addr = addr->s_addr & mask->s_addr;
entry 328 net/netlabel/netlabel_unlabeled.c entry->list.mask = mask->s_addr;
entry 329 net/netlabel/netlabel_unlabeled.c entry->list.valid = 1;
entry 330 net/netlabel/netlabel_unlabeled.c INIT_RCU_HEAD(&entry->rcu);
entry 331 net/netlabel/netlabel_unlabeled.c entry->secid = secid;
entry 334 net/netlabel/netlabel_unlabeled.c ret_val = netlbl_af4list_add(&entry->list, &iface->addr4_list);
entry 338 net/netlabel/netlabel_unlabeled.c kfree(entry);
entry 363 net/netlabel/netlabel_unlabeled.c struct netlbl_unlhsh_addr6 *entry;
entry 365 net/netlabel/netlabel_unlabeled.c entry = kzalloc(sizeof(*entry), GFP_ATOMIC);
entry 366 net/netlabel/netlabel_unlabeled.c if (entry == NULL)
entry 369 net/netlabel/netlabel_unlabeled.c ipv6_addr_copy(&entry->list.addr, addr);
entry 370 net/netlabel/netlabel_unlabeled.c entry->list.addr.s6_addr32[0] &= mask->s6_addr32[0];
entry 371 net/netlabel/netlabel_unlabeled.c entry->list.addr.s6_addr32[1] &= mask->s6_addr32[1];
entry 372 net/netlabel/netlabel_unlabeled.c entry->list.addr.s6_addr32[2] &= mask->s6_addr32[2];
entry 373 net/netlabel/netlabel_unlabeled.c entry->list.addr.s6_addr32[3] &= mask->s6_addr32[3];
entry 374 net/netlabel/netlabel_unlabeled.c ipv6_addr_copy(&entry->list.mask, mask);
entry 375 net/netlabel/netlabel_unlabeled.c entry->list.valid = 1;
entry 376 net/netlabel/netlabel_unlabeled.c INIT_RCU_HEAD(&entry->rcu);
entry 377 net/netlabel/netlabel_unlabeled.c entry->secid = secid;
entry 380 net/netlabel/netlabel_unlabeled.c ret_val = netlbl_af6list_add(&entry->list, &iface->addr6_list);
entry 384 net/netlabel/netlabel_unlabeled.c kfree(entry);
entry 567 net/netlabel/netlabel_unlabeled.c struct netlbl_unlhsh_addr4 *entry;
entry 579 net/netlabel/netlabel_unlabeled.c entry = netlbl_unlhsh_addr4_entry(list_entry);
entry 590 net/netlabel/netlabel_unlabeled.c if (entry && security_secid_to_secctx(entry->secid,
entry 601 net/netlabel/netlabel_unlabeled.c call_rcu(&entry->rcu, netlbl_unlhsh_free_addr4);
entry 628 net/netlabel/netlabel_unlabeled.c struct netlbl_unlhsh_addr6 *entry;
entry 639 net/netlabel/netlabel_unlabeled.c entry = netlbl_unlhsh_addr6_entry(list_entry);
entry 650 net/netlabel/netlabel_unlabeled.c if (entry && security_secid_to_secctx(entry->secid,
entry 661 net/netlabel/netlabel_unlabeled.c call_rcu(&entry->rcu, netlbl_unlhsh_free_addr6);
entry 1621 net/netlabel/netlabel_unlabeled.c struct netlbl_dom_map *entry;
entry 1631 net/netlabel/netlabel_unlabeled.c entry = kzalloc(sizeof(*entry), GFP_KERNEL);
entry 1632 net/netlabel/netlabel_unlabeled.c if (entry == NULL)
entry 1634 net/netlabel/netlabel_unlabeled.c entry->type = NETLBL_NLTYPE_UNLABELED;
entry 1635 net/netlabel/netlabel_unlabeled.c ret_val = netlbl_domhsh_add_default(entry, &audit_info);
entry 169 net/sctp/inqueue.c struct list_head *entry;
entry 175 net/sctp/inqueue.c entry = queue->in_chunk_list.next;
entry 177 net/sctp/inqueue.c list_entry(entry, struct sctp_chunk, list);
entry 178 net/sctp/inqueue.c list_del_init(entry);
entry 91 net/sctp/outqueue.c struct list_head *entry = q->out_chunk_list.next;
entry 93 net/sctp/outqueue.c ch = list_entry(entry, struct sctp_chunk, list);
entry 94 net/sctp/outqueue.c list_del_init(entry);
entry 87 net/sctp/proc.c sctp_snmp_list[i].entry));
entry 3298 net/sctp/sm_make_chunk.c struct list_head *entry = asoc->addip_chunk_list.next;
entry 3299 net/sctp/sm_make_chunk.c asconf = list_entry(entry, struct sctp_chunk, list);
entry 3301 net/sctp/sm_make_chunk.c list_del_init(entry);
entry 291 net/sunrpc/auth.c *entry, *new;
entry 297 net/sunrpc/auth.c hlist_for_each_entry_rcu(entry, pos, &cache->hashtable[nr], cr_hash) {
entry 298 net/sunrpc/auth.c if (!entry->cr_ops->crmatch(acred, entry, flags))
entry 301 net/sunrpc/auth.c if (test_bit(RPCAUTH_CRED_HASHED, &entry->cr_flags) == 0) {
entry 305 net/sunrpc/auth.c cred = get_rpccred(entry);
entry 321 net/sunrpc/auth.c hlist_for_each_entry(entry, pos, &cache->hashtable[nr], cr_hash) {
entry 322 net/sunrpc/auth.c if (!entry->cr_ops->crmatch(acred, entry, flags))
entry 324 net/sunrpc/auth.c cred = get_rpccred(entry);
entry 1161 net/sunrpc/cache.c unsigned hash, entry;
entry 1170 net/sunrpc/cache.c entry = n & ((1LL<<32) - 1);
entry 1173 net/sunrpc/cache.c if (!entry--)
entry 730 net/sunrpc/xprt.c struct rpc_rqst *entry = list_entry(pos, struct rpc_rqst, rq_list);
entry 731 net/sunrpc/xprt.c if (entry->rq_xid == xid)
entry 732 net/sunrpc/xprt.c return entry;
entry 156 net/tipc/ref.c struct reference *entry;
entry 176 net/tipc/ref.c entry = &(tipc_ref_table.entries[index]);
entry 179 net/tipc/ref.c spin_lock_bh(&entry->lock);
entry 180 net/tipc/ref.c next_plus_upper = entry->ref;
entry 183 net/tipc/ref.c entry->ref = ref;
entry 184 net/tipc/ref.c entry->object = object;
entry 185 net/tipc/ref.c *lock = &entry->lock;
entry 189 net/tipc/ref.c entry = &(tipc_ref_table.entries[index]);
entry 190 net/tipc/ref.c spin_lock_init(&entry->lock);
entry 191 net/tipc/ref.c spin_lock_bh(&entry->lock);
entry 193 net/tipc/ref.c entry->ref = ref;
entry 194 net/tipc/ref.c entry->object = object;
entry 195 net/tipc/ref.c *lock = &entry->lock;
entry 214 net/tipc/ref.c struct reference *entry;
entry 225 net/tipc/ref.c entry = &(tipc_ref_table.entries[index]);
entry 229 net/tipc/ref.c if (!entry->object) {
entry 233 net/tipc/ref.c if (entry->ref != ref) {
entry 243 net/tipc/ref.c entry->object = NULL;
entry 244 net/tipc/ref.c entry->ref = (ref & ~index_mask) + (index_mask + 1);
entry 265 net/tipc/ref.c struct reference *entry;
entry 267 net/tipc/ref.c entry = &tipc_ref_table.entries[ref &
entry 269 net/tipc/ref.c if (likely(entry->ref != 0)) {
entry 270 net/tipc/ref.c spin_lock_bh(&entry->lock);
entry 271 net/tipc/ref.c if (likely((entry->ref == ref) && (entry->object)))
entry 272 net/tipc/ref.c return entry->object;
entry 273 net/tipc/ref.c spin_unlock_bh(&entry->lock);
entry 286 net/tipc/ref.c struct reference *entry;
entry 288 net/tipc/ref.c entry = &tipc_ref_table.entries[ref &
entry 290 net/tipc/ref.c if (likely((entry->ref == ref) && (entry->object)))
entry 291 net/tipc/ref.c spin_unlock_bh(&entry->lock);
entry 304 net/tipc/ref.c struct reference *entry;
entry 306 net/tipc/ref.c entry = &tipc_ref_table.entries[ref &
entry 308 net/tipc/ref.c if (likely(entry->ref == ref))
entry 309 net/tipc/ref.c return entry->object;
entry 23 net/x25/x25_forward.c struct list_head *entry;
entry 50 net/x25/x25_forward.c list_for_each(entry, &x25_forward_list) {
entry 51 net/x25/x25_forward.c x25_frwd = list_entry(entry, struct x25_forward, node);
entry 96 net/x25/x25_forward.c struct list_head *entry;
entry 103 net/x25/x25_forward.c list_for_each(entry, &x25_forward_list) {
entry 104 net/x25/x25_forward.c frwd = list_entry(entry, struct x25_forward, node);
entry 136 net/x25/x25_forward.c struct list_head *entry, *tmp;
entry 140 net/x25/x25_forward.c list_for_each_safe(entry, tmp, &x25_forward_list) {
entry 141 net/x25/x25_forward.c fwd = list_entry(entry, struct x25_forward, node);
entry 154 net/x25/x25_forward.c struct list_head *entry, *tmp;
entry 158 net/x25/x25_forward.c list_for_each_safe(entry, tmp, &x25_forward_list) {
entry 159 net/x25/x25_forward.c fwd = list_entry(entry, struct x25_forward, node);
entry 295 net/x25/x25_link.c struct list_head *entry, *tmp;
entry 299 net/x25/x25_link.c list_for_each_safe(entry, tmp, &x25_neigh_list) {
entry 300 net/x25/x25_link.c nb = list_entry(entry, struct x25_neigh, node);
entry 317 net/x25/x25_link.c struct list_head *entry;
entry 320 net/x25/x25_link.c list_for_each(entry, &x25_neigh_list) {
entry 321 net/x25/x25_link.c nb = list_entry(entry, struct x25_neigh, node);
entry 389 net/x25/x25_link.c struct list_head *entry, *tmp;
entry 393 net/x25/x25_link.c list_for_each_safe(entry, tmp, &x25_neigh_list) {
entry 394 net/x25/x25_link.c nb = list_entry(entry, struct x25_neigh, node);
entry 176 net/x25/x25_proc.c struct list_head *entry;
entry 178 net/x25/x25_proc.c list_for_each(entry, &x25_forward_list) {
entry 179 net/x25/x25_proc.c f = list_entry(entry, struct x25_forward, node);
entry 34 net/x25/x25_route.c struct list_head *entry;
entry 39 net/x25/x25_route.c list_for_each(entry, &x25_route_list) {
entry 40 net/x25/x25_route.c rt = list_entry(entry, struct x25_route, node);
entry 85 net/x25/x25_route.c struct list_head *entry;
entry 90 net/x25/x25_route.c list_for_each(entry, &x25_route_list) {
entry 91 net/x25/x25_route.c rt = list_entry(entry, struct x25_route, node);
entry 111 net/x25/x25_route.c struct list_head *entry, *tmp;
entry 115 net/x25/x25_route.c list_for_each_safe(entry, tmp, &x25_route_list) {
entry 116 net/x25/x25_route.c rt = list_entry(entry, struct x25_route, node);
entry 154 net/x25/x25_route.c struct list_head *entry;
entry 158 net/x25/x25_route.c list_for_each(entry, &x25_route_list) {
entry 159 net/x25/x25_route.c rt = list_entry(entry, struct x25_route, node);
entry 215 net/x25/x25_route.c struct list_head *entry, *tmp;
entry 218 net/x25/x25_route.c list_for_each_safe(entry, tmp, &x25_route_list) {
entry 219 net/x25/x25_route.c rt = list_entry(entry, struct x25_route, node);
entry 537 net/xfrm/xfrm_algo.c return entry->desc.sadb_alg_id == (unsigned long)data;
entry 566 net/xfrm/xfrm_algo.c return name && (!strcmp(name, entry->name) ||
entry 567 net/xfrm/xfrm_algo.c (entry->compat && !strcmp(name, entry->compat)));
entry 602 net/xfrm/xfrm_algo.c return aead->icvbits == entry->uinfo.aead.icv_truncbits && name &&
entry 603 net/xfrm/xfrm_algo.c !strcmp(name, entry->name);
entry 288 net/xfrm/xfrm_policy.c struct hlist_node *entry, *tmp;
entry 296 net/xfrm/xfrm_policy.c hlist_for_each_entry_safe(policy, entry, tmp, &gc_list, bydst)
entry 363 net/xfrm/xfrm_policy.c struct hlist_node *entry, *tmp, *entry0 = NULL;
entry 368 net/xfrm/xfrm_policy.c hlist_for_each_entry_safe(pol, entry, tmp, list, bydst) {
entry 374 net/xfrm/xfrm_policy.c hlist_del(entry);
entry 380 net/xfrm/xfrm_policy.c hlist_del(entry);
entry 383 net/xfrm/xfrm_policy.c entry0 = entry;
entry 395 net/xfrm/xfrm_policy.c struct hlist_node *entry, *tmp;
entry 398 net/xfrm/xfrm_policy.c hlist_for_each_entry_safe(pol, entry, tmp, list, byidx) {
entry 529 net/xfrm/xfrm_policy.c struct hlist_node *entry;
entry 541 net/xfrm/xfrm_policy.c hlist_for_each_entry(p, entry, list, byidx) {
entry 572 net/xfrm/xfrm_policy.c struct hlist_node *entry, *newpos;
entry 579 net/xfrm/xfrm_policy.c hlist_for_each_entry(pol, entry, chain, bydst) {
entry 627 net/xfrm/xfrm_policy.c entry = &policy->bydst;
entry 628 net/xfrm/xfrm_policy.c hlist_for_each_entry_continue(policy, entry, bydst) {
entry 664 net/xfrm/xfrm_policy.c struct hlist_node *entry;
entry 670 net/xfrm/xfrm_policy.c hlist_for_each_entry(pol, entry, chain, bydst) {
entry 706 net/xfrm/xfrm_policy.c struct hlist_node *entry;
entry 716 net/xfrm/xfrm_policy.c hlist_for_each_entry(pol, entry, chain, byidx) {
entry 753 net/xfrm/xfrm_policy.c struct hlist_node *entry;
entry 756 net/xfrm/xfrm_policy.c hlist_for_each_entry(pol, entry,
entry 770 net/xfrm/xfrm_policy.c hlist_for_each_entry(pol, entry,
entry 809 net/xfrm/xfrm_policy.c struct hlist_node *entry;
entry 814 net/xfrm/xfrm_policy.c hlist_for_each_entry(pol, entry,
entry 835 net/xfrm/xfrm_policy.c hlist_for_each_entry(pol, entry,
entry 961 net/xfrm/xfrm_policy.c struct hlist_node *entry;
entry 973 net/xfrm/xfrm_policy.c hlist_for_each_entry(pol, entry, chain, bydst) {
entry 989 net/xfrm/xfrm_policy.c hlist_for_each_entry(pol, entry, chain, bydst) {
entry 2150 net/xfrm/xfrm_policy.c struct hlist_node *entry;
entry 2154 net/xfrm/xfrm_policy.c hlist_for_each_entry(pol, entry,
entry 2160 net/xfrm/xfrm_policy.c hlist_for_each_entry(pol, entry, table + i, bydst)
entry 2541 net/xfrm/xfrm_policy.c struct hlist_node *entry;
entry 2547 net/xfrm/xfrm_policy.c hlist_for_each_entry(pol, entry, chain, bydst) {
entry 2556 net/xfrm/xfrm_policy.c hlist_for_each_entry(pol, entry, chain, bydst) {
entry 66 net/xfrm/xfrm_proc.c xfrm_mib_list[i].entry));
entry 99 net/xfrm/xfrm_state.c struct hlist_node *entry, *tmp;
entry 102 net/xfrm/xfrm_state.c hlist_for_each_entry_safe(x, entry, tmp, list, bydst) {
entry 407 net/xfrm/xfrm_state.c struct hlist_node *entry, *tmp;
entry 414 net/xfrm/xfrm_state.c hlist_for_each_entry_safe(x, entry, tmp, &gc_list, gclist)
entry 595 net/xfrm/xfrm_state.c struct hlist_node *entry;
entry 598 net/xfrm/xfrm_state.c hlist_for_each_entry(x, entry, xfrm_state_bydst+i, bydst) {
entry 630 net/xfrm/xfrm_state.c struct hlist_node *entry;
entry 633 net/xfrm/xfrm_state.c hlist_for_each_entry(x, entry, xfrm_state_bydst+i, bydst) {
entry 688 net/xfrm/xfrm_state.c struct hlist_node *entry;
entry 690 net/xfrm/xfrm_state.c hlist_for_each_entry(x, entry, xfrm_state_byspi+h, byspi) {
entry 720 net/xfrm/xfrm_state.c struct hlist_node *entry;
entry 722 net/xfrm/xfrm_state.c hlist_for_each_entry(x, entry, xfrm_state_bysrc+h, bysrc) {
entry 778 net/xfrm/xfrm_state.c struct hlist_node *entry;
entry 788 net/xfrm/xfrm_state.c hlist_for_each_entry(x, entry, xfrm_state_bydst+h, bydst) {
entry 894 net/xfrm/xfrm_state.c struct hlist_node *entry;
entry 898 net/xfrm/xfrm_state.c hlist_for_each_entry(x, entry, xfrm_state_bydst+h, bydst) {
entry 959 net/xfrm/xfrm_state.c struct hlist_node *entry;
entry 963 net/xfrm/xfrm_state.c hlist_for_each_entry(x, entry, xfrm_state_bydst+h, bydst) {
entry 985 net/xfrm/xfrm_state.c struct hlist_node *entry;
entry 988 net/xfrm/xfrm_state.c hlist_for_each_entry(x, entry, xfrm_state_bydst+h, bydst) {
entry 1206 net/xfrm/xfrm_state.c struct hlist_node *entry;
entry 1211 net/xfrm/xfrm_state.c hlist_for_each_entry(x, entry, xfrm_state_bydst+h, bydst) {
entry 1228 net/xfrm/xfrm_state.c hlist_for_each_entry(x, entry, xfrm_state_bysrc+h, bysrc) {
entry 1457 net/xfrm/xfrm_state.c struct hlist_node *entry;
entry 1460 net/xfrm/xfrm_state.c hlist_for_each_entry(x, entry, xfrm_state_bydst+i, bydst) {
entry 40 samples/kprobes/jprobe_example.c .entry = jdo_fork,
entry 56 samples/kprobes/jprobe_example.c my_jprobe.kp.addr, my_jprobe.entry);
entry 1663 scripts/kconfig/qconf.cc QString entry;
entry 1666 scripts/kconfig/qconf.cc entry = "single";
entry 1670 scripts/kconfig/qconf.cc entry = "split";
entry 1674 scripts/kconfig/qconf.cc entry = "full";
entry 1677 scripts/kconfig/qconf.cc configSettings->writeEntry("/listMode", entry);
entry 718 scripts/mod/file2alias.c int (*do_entry)(const char *, void *entry, char *alias) = function;
entry 879 security/selinux/avc.c struct avc_entry entry, *p_ae;
entry 890 security/selinux/avc.c rc = security_compute_av(ssid, tsid, tclass, requested, &entry.avd);
entry 894 security/selinux/avc.c node = avc_insert(ssid, tsid, tclass, &entry);
entry 897 security/selinux/avc.c p_ae = node ? &node->ae : &entry;
entry 484 sound/core/hwdep.c struct snd_info_entry *entry;
entry 486 sound/core/hwdep.c if ((entry = snd_info_create_module_entry(THIS_MODULE, "hwdep", NULL)) != NULL) {
entry 487 sound/core/hwdep.c entry->c.text.read = snd_hwdep_proc_read;
entry 488 sound/core/hwdep.c if (snd_info_register(entry) < 0) {
entry 489 sound/core/hwdep.c snd_info_free_entry(entry);
entry 490 sound/core/hwdep.c entry = NULL;
entry 493 sound/core/hwdep.c snd_hwdep_proc_entry = entry;
entry 75 sound/core/info.c struct snd_info_entry *entry;
entry 172 sound/core/info.c struct snd_info_entry *entry;
entry 176 sound/core/info.c entry = data->entry;
entry 178 sound/core/info.c switch (entry->content) {
entry 196 sound/core/info.c if (entry->c.ops->llseek) {
entry 197 sound/core/info.c ret = entry->c.ops->llseek(entry,
entry 214 sound/core/info.c struct snd_info_entry *entry;
entry 227 sound/core/info.c entry = data->entry;
entry 228 sound/core/info.c switch (entry->content) {
entry 241 sound/core/info.c if (entry->c.ops->read)
entry 242 sound/core/info.c size = entry->c.ops->read(entry,
entry 256 sound/core/info.c struct snd_info_entry *entry;
entry 264 sound/core/info.c entry = data->entry;
entry 270 sound/core/info.c switch (entry->content) {
entry 275 sound/core/info.c mutex_lock(&entry->access);
entry 278 sound/core/info.c mutex_unlock(&entry->access);
entry 283 sound/core/info.c mutex_unlock(&entry->access);
entry 287 sound/core/info.c mutex_unlock(&entry->access);
entry 291 sound/core/info.c if (entry->c.ops->write)
entry 292 sound/core/info.c size = entry->c.ops->write(entry,
entry 304 sound/core/info.c struct snd_info_entry *entry;
entry 312 sound/core/info.c entry = p == NULL ? NULL : (struct snd_info_entry *)p->data;
entry 313 sound/core/info.c if (entry == NULL || ! entry->p) {
entry 317 sound/core/info.c if (!try_module_get(entry->module)) {
entry 323 sound/core/info.c if ((entry->content == SNDRV_INFO_CONTENT_DATA &&
entry 324 sound/core/info.c entry->c.ops->read == NULL)) {
entry 330 sound/core/info.c if ((entry->content == SNDRV_INFO_CONTENT_DATA &&
entry 331 sound/core/info.c entry->c.ops->write == NULL)) {
entry 341 sound/core/info.c data->entry = entry;
entry 342 sound/core/info.c switch (entry->content) {
entry 366 sound/core/info.c if (entry->c.ops->open) {
entry 367 sound/core/info.c if ((err = entry->c.ops->open(entry, mode,
entry 377 sound/core/info.c if (entry->content == SNDRV_INFO_CONTENT_TEXT &&
entry 379 sound/core/info.c if (entry->c.text.read) {
entry 380 sound/core/info.c mutex_lock(&entry->access);
entry 381 sound/core/info.c entry->c.text.read(entry, data->rbuffer);
entry 382 sound/core/info.c mutex_unlock(&entry->access);
entry 399 sound/core/info.c module_put(entry->module);
entry 407 sound/core/info.c struct snd_info_entry *entry;
entry 413 sound/core/info.c entry = data->entry;
entry 414 sound/core/info.c switch (entry->content) {
entry 421 sound/core/info.c if (entry->c.text.write) {
entry 422 sound/core/info.c entry->c.text.write(entry, data->wbuffer);
entry 425 sound/core/info.c entry->name,
entry 434 sound/core/info.c if (entry->c.ops->release)
entry 435 sound/core/info.c entry->c.ops->release(entry, mode,
entry 439 sound/core/info.c module_put(entry->module);
entry 447 sound/core/info.c struct snd_info_entry *entry;
entry 453 sound/core/info.c entry = data->entry;
entry 455 sound/core/info.c switch (entry->content) {
entry 457 sound/core/info.c if (entry->c.ops->poll)
entry 458 sound/core/info.c return entry->c.ops->poll(entry,
entry 461 sound/core/info.c if (entry->c.ops->read)
entry 463 sound/core/info.c if (entry->c.ops->write)
entry 474 sound/core/info.c struct snd_info_entry *entry;
entry 479 sound/core/info.c entry = data->entry;
entry 480 sound/core/info.c switch (entry->content) {
entry 482 sound/core/info.c if (entry->c.ops->ioctl)
entry 483 sound/core/info.c return entry->c.ops->ioctl(entry,
entry 495 sound/core/info.c struct snd_info_entry *entry;
entry 500 sound/core/info.c entry = data->entry;
entry 501 sound/core/info.c switch (entry->content) {
entry 503 sound/core/info.c if (entry->c.ops->mmap)
entry 504 sound/core/info.c return entry->c.ops->mmap(entry,
entry 556 sound/core/info.c struct snd_info_entry *entry;
entry 557 sound/core/info.c if ((entry = snd_info_create_module_entry(THIS_MODULE, "oss", NULL)) == NULL)
entry 559 sound/core/info.c entry->mode = S_IFDIR | S_IRUGO | S_IXUGO;
entry 560 sound/core/info.c if (snd_info_register(entry) < 0) {
entry 561 sound/core/info.c snd_info_free_entry(entry);
entry 564 sound/core/info.c snd_oss_root = entry;
entry 569 sound/core/info.c struct snd_info_entry *entry;
entry 570 sound/core/info.c if ((entry = snd_info_create_module_entry(THIS_MODULE, "seq", NULL)) == NULL)
entry 572 sound/core/info.c entry->mode = S_IFDIR | S_IRUGO | S_IXUGO;
entry 573 sound/core/info.c if (snd_info_register(entry) < 0) {
entry 574 sound/core/info.c snd_info_free_entry(entry);
entry 577 sound/core/info.c snd_seq_root = entry;
entry 617 sound/core/info.c struct snd_info_entry *entry;
entry 623 sound/core/info.c if ((entry = snd_info_create_module_entry(card->module, str, NULL)) == NULL)
entry 625 sound/core/info.c entry->mode = S_IFDIR | S_IRUGO | S_IXUGO;
entry 626 sound/core/info.c if (snd_info_register(entry) < 0) {
entry 627 sound/core/info.c snd_info_free_entry(entry);
entry 630 sound/core/info.c card->proc_root = entry;
entry 779 sound/core/info.c struct snd_info_entry *entry;
entry 780 sound/core/info.c entry = kzalloc(sizeof(*entry), GFP_KERNEL);
entry 781 sound/core/info.c if (entry == NULL)
entry 783 sound/core/info.c entry->name = kstrdup(name, GFP_KERNEL);
entry 784 sound/core/info.c if (entry->name == NULL) {
entry 785 sound/core/info.c kfree(entry);
entry 788 sound/core/info.c entry->mode = S_IFREG | S_IRUGO;
entry 789 sound/core/info.c entry->content = SNDRV_INFO_CONTENT_TEXT;
entry 790 sound/core/info.c mutex_init(&entry->access);
entry 791 sound/core/info.c INIT_LIST_HEAD(&entry->children);
entry 792 sound/core/info.c INIT_LIST_HEAD(&entry->list);
entry 793 sound/core/info.c return entry;
entry 810 sound/core/info.c struct snd_info_entry *entry = snd_info_create_entry(name);
entry 811 sound/core/info.c if (entry) {
entry 812 sound/core/info.c entry->module = module;
entry 813 sound/core/info.c entry->parent = parent;
entry 815 sound/core/info.c return entry;
entry 834 sound/core/info.c struct snd_info_entry *entry = snd_info_create_entry(name);
entry 835 sound/core/info.c if (entry) {
entry 836 sound/core/info.c entry->module = card->module;
entry 837 sound/core/info.c entry->card = card;
entry 838 sound/core/info.c entry->parent = parent;
entry 840 sound/core/info.c return entry;
entry 850 sound/core/info.c list_for_each_safe(p, n, &entry->children) {
entry 854 sound/core/info.c if (! entry->p)
entry 856 sound/core/info.c list_del_init(&entry->list);
entry 857 sound/core/info.c root = entry->parent == NULL ? snd_proc_root : entry->parent->p;
entry 859 sound/core/info.c snd_remove_proc_entry(root, entry->p);
entry 860 sound/core/info.c entry->p = NULL;
entry 865 sound/core/info.c struct snd_info_entry *entry = device->device_data;
entry 866 sound/core/info.c snd_info_free_entry(entry);
entry 872 sound/core/info.c struct snd_info_entry *entry = device->device_data;
entry 873 sound/core/info.c return snd_info_register(entry);
entry 904 sound/core/info.c struct snd_info_entry *entry;
entry 907 sound/core/info.c entry = snd_info_create_card_entry(card, name, card->proc_root);
entry 908 sound/core/info.c if (! entry)
entry 910 sound/core/info.c if ((err = snd_device_new(card, SNDRV_DEV_INFO, entry, &ops)) < 0) {
entry 911 sound/core/info.c snd_info_free_entry(entry);
entry 915 sound/core/info.c *entryp = entry;
entry 929 sound/core/info.c if (entry == NULL)
entry 931 sound/core/info.c if (entry->p) {
entry 933 sound/core/info.c snd_info_disconnect(entry);
entry 936 sound/core/info.c kfree(entry->name);
entry 937 sound/core/info.c if (entry->private_free)
entry 938 sound/core/info.c entry->private_free(entry);
entry 939 sound/core/info.c kfree(entry);
entry 956 sound/core/info.c if (snd_BUG_ON(!entry))
entry 958 sound/core/info.c root = entry->parent == NULL ? snd_proc_root : entry->parent->p;
entry 960 sound/core/info.c p = snd_create_proc_entry(entry->name, entry->mode, root);
entry 965 sound/core/info.c p->owner = entry->module;
entry 966 sound/core/info.c if (!S_ISDIR(entry->mode))
entry 968 sound/core/info.c p->size = entry->size;
entry 969 sound/core/info.c p->data = entry;
entry 970 sound/core/info.c entry->p = p;
entry 971 sound/core/info.c if (entry->parent)
entry 972 sound/core/info.c list_add_tail(&entry->list, &entry->parent->children);
entry 995 sound/core/info.c struct snd_info_entry *entry;
entry 997 sound/core/info.c entry = snd_info_create_module_entry(THIS_MODULE, "version", NULL);
entry 998 sound/core/info.c if (entry == NULL)
entry 1000 sound/core/info.c entry->c.text.read = snd_info_version_read;
entry 1001 sound/core/info.c if (snd_info_register(entry) < 0) {
entry 1002 sound/core/info.c snd_info_free_entry(entry);
entry 1005 sound/core/info.c snd_info_version_entry = entry;
entry 117 sound/core/info_oss.c struct snd_info_entry *entry;
entry 120 sound/core/info_oss.c if ((entry = snd_info_create_module_entry(THIS_MODULE, "sndstat", snd_oss_root)) != NULL) {
entry 121 sound/core/info_oss.c entry->c.text.read = snd_sndstat_proc_read;
entry 122 sound/core/info_oss.c if (snd_info_register(entry) < 0) {
entry 123 sound/core/info_oss.c snd_info_free_entry(entry);
entry 124 sound/core/info_oss.c entry = NULL;
entry 127 sound/core/info_oss.c snd_sndstat_proc_entry = entry;
entry 95 sound/core/init.c snd_iprintf(buffer, "%s\n", entry->card->id);
entry 101 sound/core/init.c struct snd_info_entry *entry;
entry 107 sound/core/init.c if ((entry = snd_info_create_card_entry(card, "id", card->proc_root)) == NULL) {
entry 111 sound/core/init.c entry->c.text.read = snd_card_id_read;
entry 112 sound/core/init.c if (snd_info_register(entry) < 0) {
entry 113 sound/core/init.c snd_info_free_entry(entry);
entry 114 sound/core/init.c entry = NULL;
entry 116 sound/core/init.c card->proc_id = entry;
entry 650 sound/core/init.c struct snd_info_entry *entry;
entry 652 sound/core/init.c entry = snd_info_create_module_entry(THIS_MODULE, "cards", NULL);
entry 653 sound/core/init.c if (! entry)
entry 655 sound/core/init.c entry->c.text.read = snd_card_info_read;
entry 656 sound/core/init.c if (snd_info_register(entry) < 0) {
entry 657 sound/core/init.c snd_info_free_entry(entry);
entry 660 sound/core/init.c snd_card_info_entry = entry;
entry 663 sound/core/init.c entry = snd_info_create_module_entry(THIS_MODULE, "modules", NULL);
entry 664 sound/core/init.c if (entry) {
entry 665 sound/core/init.c entry->c.text.read = snd_card_module_info_read;
entry 666 sound/core/init.c if (snd_info_register(entry) < 0)
entry 667 sound/core/init.c snd_info_free_entry(entry);
entry 669 sound/core/init.c snd_card_module_info_entry = entry;
entry 1121 sound/core/oss/mixer_oss.c struct snd_mixer_oss *mixer = entry->private_data;
entry 1145 sound/core/oss/mixer_oss.c struct snd_mixer_oss *mixer = entry->private_data;
entry 1203 sound/core/oss/mixer_oss.c struct snd_info_entry *entry;
entry 1205 sound/core/oss/mixer_oss.c entry = snd_info_create_card_entry(mixer->card, "oss_mixer",
entry 1207 sound/core/oss/mixer_oss.c if (! entry)
entry 1209 sound/core/oss/mixer_oss.c entry->content = SNDRV_INFO_CONTENT_TEXT;
entry 1210 sound/core/oss/mixer_oss.c entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
entry 1211 sound/core/oss/mixer_oss.c entry->c.text.read = snd_mixer_oss_proc_read;
entry 1212 sound/core/oss/mixer_oss.c entry->c.text.write = snd_mixer_oss_proc_write;
entry 1213 sound/core/oss/mixer_oss.c entry->private_data = mixer;
entry 1214 sound/core/oss/mixer_oss.c if (snd_info_register(entry) < 0) {
entry 1215 sound/core/oss/mixer_oss.c snd_info_free_entry(entry);
entry 1216 sound/core/oss/mixer_oss.c entry = NULL;
entry 1218 sound/core/oss/mixer_oss.c mixer->proc_entry = entry;
entry 2789 sound/core/oss/pcm_oss.c struct snd_pcm_str *pstr = entry->private_data;
entry 2824 sound/core/oss/pcm_oss.c struct snd_pcm_str *pstr = entry->private_data;
entry 2902 sound/core/oss/pcm_oss.c struct snd_info_entry *entry;
entry 2906 sound/core/oss/pcm_oss.c if ((entry = snd_info_create_card_entry(pcm->card, "oss", pstr->proc_root)) != NULL) {
entry 2907 sound/core/oss/pcm_oss.c entry->content = SNDRV_INFO_CONTENT_TEXT;
entry 2908 sound/core/oss/pcm_oss.c entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
entry 2909 sound/core/oss/pcm_oss.c entry->c.text.read = snd_pcm_oss_proc_read;
entry 2910 sound/core/oss/pcm_oss.c entry->c.text.write = snd_pcm_oss_proc_write;
entry 2911 sound/core/oss/pcm_oss.c entry->private_data = pstr;
entry 2912 sound/core/oss/pcm_oss.c if (snd_info_register(entry) < 0) {
entry 2913 sound/core/oss/pcm_oss.c snd_info_free_entry(entry);
entry 2914 sound/core/oss/pcm_oss.c entry = NULL;
entry 2917 sound/core/oss/pcm_oss.c pstr->oss.proc_entry = entry;
entry 352 sound/core/pcm.c snd_pcm_proc_info_read(((struct snd_pcm_str *)entry->private_data)->substream,
entry 359 sound/core/pcm.c snd_pcm_proc_info_read((struct snd_pcm_substream *)entry->private_data,
entry 366 sound/core/pcm.c struct snd_pcm_substream *substream = entry->private_data;
entry 398 sound/core/pcm.c struct snd_pcm_substream *substream = entry->private_data;
entry 421 sound/core/pcm.c struct snd_pcm_substream *substream = entry->private_data;
entry 452 sound/core/pcm.c struct snd_pcm_str *pstr = entry->private_data;
entry 459 sound/core/pcm.c struct snd_pcm_str *pstr = entry->private_data;
entry 469 sound/core/pcm.c struct snd_info_entry *entry;
entry 474 sound/core/pcm.c if ((entry = snd_info_create_card_entry(pcm->card, name, pcm->card->proc_root)) == NULL)
entry 476 sound/core/pcm.c entry->mode = S_IFDIR | S_IRUGO | S_IXUGO;
entry 477 sound/core/pcm.c if (snd_info_register(entry) < 0) {
entry 478 sound/core/pcm.c snd_info_free_entry(entry);
entry 481 sound/core/pcm.c pstr->proc_root = entry;
entry 483 sound/core/pcm.c if ((entry = snd_info_create_card_entry(pcm->card, "info", pstr->proc_root)) != NULL) {
entry 484 sound/core/pcm.c snd_info_set_text_ops(entry, pstr, snd_pcm_stream_proc_info_read);
entry 485 sound/core/pcm.c if (snd_info_register(entry) < 0) {
entry 486 sound/core/pcm.c snd_info_free_entry(entry);
entry 487 sound/core/pcm.c entry = NULL;
entry 490 sound/core/pcm.c pstr->proc_info_entry = entry;
entry 493 sound/core/pcm.c if ((entry = snd_info_create_card_entry(pcm->card, "xrun_debug",
entry 495 sound/core/pcm.c entry->c.text.read = snd_pcm_xrun_debug_read;
entry 496 sound/core/pcm.c entry->c.text.write = snd_pcm_xrun_debug_write;
entry 497 sound/core/pcm.c entry->mode |= S_IWUSR;
entry 498 sound/core/pcm.c entry->private_data = pstr;
entry 499 sound/core/pcm.c if (snd_info_register(entry) < 0) {
entry 500 sound/core/pcm.c snd_info_free_entry(entry);
entry 501 sound/core/pcm.c entry = NULL;
entry 504 sound/core/pcm.c pstr->proc_xrun_debug_entry = entry;
entry 524 sound/core/pcm.c struct snd_info_entry *entry;
entry 531 sound/core/pcm.c if ((entry = snd_info_create_card_entry(card, name, substream->pstr->proc_root)) == NULL)
entry 533 sound/core/pcm.c entry->mode = S_IFDIR | S_IRUGO | S_IXUGO;
entry 534 sound/core/pcm.c if (snd_info_register(entry) < 0) {
entry 535 sound/core/pcm.c snd_info_free_entry(entry);
entry 538 sound/core/pcm.c substream->proc_root = entry;
entry 540 sound/core/pcm.c if ((entry = snd_info_create_card_entry(card, "info", substream->proc_root)) != NULL) {
entry 541 sound/core/pcm.c snd_info_set_text_ops(entry, substream,
entry 543 sound/core/pcm.c if (snd_info_register(entry) < 0) {
entry 544 sound/core/pcm.c snd_info_free_entry(entry);
entry 545 sound/core/pcm.c entry = NULL;
entry 548 sound/core/pcm.c substream->proc_info_entry = entry;
entry 550 sound/core/pcm.c if ((entry = snd_info_create_card_entry(card, "hw_params", substream->proc_root)) != NULL) {
entry 551 sound/core/pcm.c snd_info_set_text_ops(entry, substream,
entry 553 sound/core/pcm.c if (snd_info_register(entry) < 0) {
entry 554 sound/core/pcm.c snd_info_free_entry(entry);
entry 555 sound/core/pcm.c entry = NULL;
entry 558 sound/core/pcm.c substream->proc_hw_params_entry = entry;
entry 560 sound/core/pcm.c if ((entry = snd_info_create_card_entry(card, "sw_params", substream->proc_root)) != NULL) {
entry 561 sound/core/pcm.c snd_info_set_text_ops(entry, substream,
entry 563 sound/core/pcm.c if (snd_info_register(entry) < 0) {
entry 564 sound/core/pcm.c snd_info_free_entry(entry);
entry 565 sound/core/pcm.c entry = NULL;
entry 568 sound/core/pcm.c substream->proc_sw_params_entry = entry;
entry 570 sound/core/pcm.c if ((entry = snd_info_create_card_entry(card, "status", substream->proc_root)) != NULL) {
entry 571 sound/core/pcm.c snd_info_set_text_ops(entry, substream,
entry 573 sound/core/pcm.c if (snd_info_register(entry) < 0) {
entry 574 sound/core/pcm.c snd_info_free_entry(entry);
entry 575 sound/core/pcm.c entry = NULL;
entry 578 sound/core/pcm.c substream->proc_status_entry = entry;
entry 1099 sound/core/pcm.c struct snd_info_entry *entry;
entry 1101 sound/core/pcm.c if ((entry = snd_info_create_module_entry(THIS_MODULE, "pcm", NULL)) != NULL) {
entry 1102 sound/core/pcm.c snd_info_set_text_ops(entry, NULL, snd_pcm_proc_read);
entry 1103 sound/core/pcm.c if (snd_info_register(entry) < 0) {
entry 1104 sound/core/pcm.c snd_info_free_entry(entry);
entry 1105 sound/core/pcm.c entry = NULL;
entry 1108 sound/core/pcm.c snd_pcm_proc_entry = entry;
entry 139 sound/core/pcm_memory.c struct snd_pcm_substream *substream = entry->private_data;
entry 151 sound/core/pcm_memory.c struct snd_pcm_substream *substream = entry->private_data;
entry 163 sound/core/pcm_memory.c struct snd_pcm_substream *substream = entry->private_data;
entry 204 sound/core/pcm_memory.c struct snd_info_entry *entry;
entry 206 sound/core/pcm_memory.c if ((entry = snd_info_create_card_entry(substream->pcm->card, "prealloc", substream->proc_root)) != NULL) {
entry 207 sound/core/pcm_memory.c entry->c.text.read = snd_pcm_lib_preallocate_proc_read;
entry 208 sound/core/pcm_memory.c entry->c.text.write = snd_pcm_lib_preallocate_proc_write;
entry 209 sound/core/pcm_memory.c entry->mode |= S_IWUSR;
entry 210 sound/core/pcm_memory.c entry->private_data = substream;
entry 211 sound/core/pcm_memory.c if (snd_info_register(entry) < 0) {
entry 212 sound/core/pcm_memory.c snd_info_free_entry(entry);
entry 213 sound/core/pcm_memory.c entry = NULL;
entry 216 sound/core/pcm_memory.c substream->proc_prealloc_entry = entry;
entry 217 sound/core/pcm_memory.c if ((entry = snd_info_create_card_entry(substream->pcm->card, "prealloc_max", substream->proc_root)) != NULL) {
entry 218 sound/core/pcm_memory.c entry->c.text.read = snd_pcm_lib_preallocate_max_proc_read;
entry 219 sound/core/pcm_memory.c entry->private_data = substream;
entry 220 sound/core/pcm_memory.c if (snd_info_register(entry) < 0) {
entry 221 sound/core/pcm_memory.c snd_info_free_entry(entry);
entry 222 sound/core/pcm_memory.c entry = NULL;
entry 225 sound/core/pcm_memory.c substream->proc_prealloc_max_entry = entry;
entry 1311 sound/core/rawmidi.c rmidi = entry->private_data;
entry 1514 sound/core/rawmidi.c struct snd_info_entry *entry;
entry 1568 sound/core/rawmidi.c entry = snd_info_create_card_entry(rmidi->card, name, rmidi->card->proc_root);
entry 1569 sound/core/rawmidi.c if (entry) {
entry 1570 sound/core/rawmidi.c entry->private_data = rmidi;
entry 1571 sound/core/rawmidi.c entry->c.text.read = snd_rawmidi_proc_info_read;
entry 1572 sound/core/rawmidi.c if (snd_info_register(entry) < 0) {
entry 1573 sound/core/rawmidi.c snd_info_free_entry(entry);
entry 1574 sound/core/rawmidi.c entry = NULL;
entry 1577 sound/core/rawmidi.c rmidi->proc_entry = entry;
entry 288 sound/core/seq/oss/seq_oss.c struct snd_info_entry *entry;
entry 290 sound/core/seq/oss/seq_oss.c entry = snd_info_create_module_entry(THIS_MODULE, SNDRV_SEQ_OSS_PROCNAME, snd_seq_root);
entry 291 sound/core/seq/oss/seq_oss.c if (entry == NULL)
entry 294 sound/core/seq/oss/seq_oss.c entry->content = SNDRV_INFO_CONTENT_TEXT;
entry 295 sound/core/seq/oss/seq_oss.c entry->private_data = NULL;
entry 296 sound/core/seq/oss/seq_oss.c entry->c.text.read = info_read;
entry 297 sound/core/seq/oss/seq_oss.c if (snd_info_register(entry) < 0) {
entry 298 sound/core/seq/oss/seq_oss.c snd_info_free_entry(entry);
entry 301 sound/core/seq/oss/seq_oss.c info_entry = entry;
entry 316 sound/core/seq/seq_device.c if (id == NULL || entry == NULL ||
entry 317 sound/core/seq/seq_device.c entry->init_device == NULL || entry->free_device == NULL)
entry 335 sound/core/seq/seq_device.c ops->ops = *entry;
entry 39 sound/core/seq/seq_info.c struct snd_info_entry *entry;
entry 41 sound/core/seq/seq_info.c entry = snd_info_create_module_entry(THIS_MODULE, name, snd_seq_root);
entry 42 sound/core/seq/seq_info.c if (entry == NULL)
entry 44 sound/core/seq/seq_info.c entry->content = SNDRV_INFO_CONTENT_TEXT;
entry 45 sound/core/seq/seq_info.c entry->c.text.read = read;
entry 46 sound/core/seq/seq_info.c if (snd_info_register(entry) < 0) {
entry 47 sound/core/seq/seq_info.c snd_info_free_entry(entry);
entry 50 sound/core/seq/seq_info.c return entry;
entry 417 sound/core/sound.c struct snd_info_entry *entry;
entry 419 sound/core/sound.c entry = snd_info_create_module_entry(THIS_MODULE, "devices", NULL);
entry 420 sound/core/sound.c if (entry) {
entry 421 sound/core/sound.c entry->c.text.read = snd_minor_info_read;
entry 422 sound/core/sound.c if (snd_info_register(entry) < 0) {
entry 423 sound/core/sound.c snd_info_free_entry(entry);
entry 424 sound/core/sound.c entry = NULL;
entry 427 sound/core/sound.c snd_minor_info_entry = entry;
entry 257 sound/core/sound_oss.c struct snd_info_entry *entry;
entry 259 sound/core/sound_oss.c entry = snd_info_create_module_entry(THIS_MODULE, "devices", snd_oss_root);
entry 260 sound/core/sound_oss.c if (entry) {
entry 261 sound/core/sound_oss.c entry->c.text.read = snd_minor_info_oss_read;
entry 262 sound/core/sound_oss.c if (snd_info_register(entry) < 0) {
entry 263 sound/core/sound_oss.c snd_info_free_entry(entry);
entry 264 sound/core/sound_oss.c entry = NULL;
entry 267 sound/core/sound_oss.c snd_minor_info_oss_entry = entry;
entry 1086 sound/core/timer.c struct snd_info_entry *entry;
entry 1088 sound/core/timer.c entry = snd_info_create_module_entry(THIS_MODULE, "timers", NULL);
entry 1089 sound/core/timer.c if (entry != NULL) {
entry 1090 sound/core/timer.c entry->c.text.read = snd_timer_proc_read;
entry 1091 sound/core/timer.c if (snd_info_register(entry) < 0) {
entry 1092 sound/core/timer.c snd_info_free_entry(entry);
entry 1093 sound/core/timer.c entry = NULL;
entry 1096 sound/core/timer.c snd_timer_proc_entry = entry;
entry 29 sound/drivers/opl4/opl4_proc.c struct snd_opl4 *opl4 = entry->private_data;
entry 44 sound/drivers/opl4/opl4_proc.c struct snd_opl4 *opl4 = entry->private_data;
entry 56 sound/drivers/opl4/opl4_proc.c struct snd_opl4 *opl4 = entry->private_data;
entry 61 sound/drivers/opl4/opl4_proc.c if (pos + size > entry->size)
entry 62 sound/drivers/opl4/opl4_proc.c size = entry->size - pos;
entry 82 sound/drivers/opl4/opl4_proc.c struct snd_opl4 *opl4 = entry->private_data;
entry 87 sound/drivers/opl4/opl4_proc.c if (pos + size > entry->size)
entry 88 sound/drivers/opl4/opl4_proc.c size = entry->size - pos;
entry 115 sound/drivers/opl4/opl4_proc.c file->f_pos = entry->size + offset;
entry 120 sound/drivers/opl4/opl4_proc.c if (file->f_pos > entry->size)
entry 121 sound/drivers/opl4/opl4_proc.c file->f_pos = entry->size;
entry 135 sound/drivers/opl4/opl4_proc.c struct snd_info_entry *entry;
entry 137 sound/drivers/opl4/opl4_proc.c entry = snd_info_create_card_entry(opl4->card, "opl4-mem", opl4->card->proc_root);
entry 138 sound/drivers/opl4/opl4_proc.c if (entry) {
entry 141 sound/drivers/opl4/opl4_proc.c entry->mode |= S_IWUSR;
entry 142 sound/drivers/opl4/opl4_proc.c entry->size = 4 * 1024 * 1024;
entry 145 sound/drivers/opl4/opl4_proc.c entry->size = 1 * 1024 * 1024;
entry 147 sound/drivers/opl4/opl4_proc.c entry->content = SNDRV_INFO_CONTENT_DATA;
entry 148 sound/drivers/opl4/opl4_proc.c entry->c.ops = &snd_opl4_mem_proc_ops;
entry 149 sound/drivers/opl4/opl4_proc.c entry->module = THIS_MODULE;
entry 150 sound/drivers/opl4/opl4_proc.c entry->private_data = opl4;
entry 151 sound/drivers/opl4/opl4_proc.c if (snd_info_register(entry) < 0) {
entry 152 sound/drivers/opl4/opl4_proc.c snd_info_free_entry(entry);
entry 153 sound/drivers/opl4/opl4_proc.c entry = NULL;
entry 156 sound/drivers/opl4/opl4_proc.c opl4->proc_entry = entry;
entry 601 sound/drivers/vx/vx_core.c struct vx_core *chip = entry->private_data;
entry 644 sound/drivers/vx/vx_core.c struct snd_info_entry *entry;
entry 646 sound/drivers/vx/vx_core.c if (! snd_card_proc_new(chip->card, "vx-status", &entry))
entry 647 sound/drivers/vx/vx_core.c snd_info_set_text_ops(entry, chip, vx_proc_read);
entry 430 sound/i2c/l3/uda1341.c struct l3_client *clnt = entry->private_data;
entry 495 sound/i2c/l3/uda1341.c struct l3_client *clnt = entry->private_data;
entry 514 sound/i2c/l3/uda1341.c struct snd_info_entry *entry;
entry 516 sound/i2c/l3/uda1341.c if (! snd_card_proc_new(card, "uda1341", &entry))
entry 517 sound/i2c/l3/uda1341.c snd_info_set_text_ops(entry, clnt, snd_uda1341_proc_read);
entry 518 sound/i2c/l3/uda1341.c if (! snd_card_proc_new(card, "uda1341-regs", &entry))
entry 519 sound/i2c/l3/uda1341.c snd_info_set_text_ops(entry, clnt, snd_uda1341_proc_regs_read);
entry 454 sound/i2c/other/ak4114.c struct ak4114 *ak4114 = entry->private_data;
entry 465 sound/i2c/other/ak4114.c struct snd_info_entry *entry;
entry 466 sound/i2c/other/ak4114.c if (!snd_card_proc_new(ak4114->card, "ak4114", &entry))
entry 467 sound/i2c/other/ak4114.c snd_info_set_text_ops(entry, ak4114, snd_ak4114_proc_regs_read);
entry 122 sound/isa/gus/gus_irq.c gus = entry->private_data;
entry 141 sound/isa/gus/gus_irq.c struct snd_info_entry *entry;
entry 143 sound/isa/gus/gus_irq.c if (! snd_card_proc_new(gus->card, "gusirq", &entry))
entry 144 sound/isa/gus/gus_irq.c snd_info_set_text_ops(entry, gus, snd_gus_irq_info_read);
entry 241 sound/isa/gus/gus_mem.c struct snd_info_entry *entry;
entry 265 sound/isa/gus/gus_mem.c if (! snd_card_proc_new(gus->card, "gusmem", &entry))
entry 266 sound/isa/gus/gus_mem.c snd_info_set_text_ops(entry, gus, snd_gf1_mem_info_read);
entry 296 sound/isa/gus/gus_mem.c gus = entry->private_data;
entry 39 sound/isa/gus/gus_mem_proc.c struct gus_proc_private *priv = entry->private_data;
entry 60 sound/isa/gus/gus_mem_proc.c struct gus_proc_private *priv = entry->private_data;
entry 82 sound/isa/gus/gus_mem_proc.c struct gus_proc_private *priv = entry->private_data;
entry 96 sound/isa/gus/gus_mem_proc.c struct snd_info_entry *entry;
entry 105 sound/isa/gus/gus_mem_proc.c if (! snd_card_proc_new(gus->card, name, &entry)) {
entry 106 sound/isa/gus/gus_mem_proc.c entry->content = SNDRV_INFO_CONTENT_DATA;
entry 107 sound/isa/gus/gus_mem_proc.c entry->private_data = priv;
entry 108 sound/isa/gus/gus_mem_proc.c entry->private_free = snd_gf1_mem_proc_free;
entry 109 sound/isa/gus/gus_mem_proc.c entry->c.ops = &snd_gf1_mem_proc_ops;
entry 111 sound/isa/gus/gus_mem_proc.c priv->size = entry->size = gus->gf1.mem_alloc.banks_8[idx].size;
entry 123 sound/isa/gus/gus_mem_proc.c if (! snd_card_proc_new(gus->card, name, &entry)) {
entry 124 sound/isa/gus/gus_mem_proc.c entry->content = SNDRV_INFO_CONTENT_DATA;
entry 125 sound/isa/gus/gus_mem_proc.c entry->private_data = priv;
entry 126 sound/isa/gus/gus_mem_proc.c entry->private_free = snd_gf1_mem_proc_free;
entry 127 sound/isa/gus/gus_mem_proc.c entry->c.ops = &snd_gf1_mem_proc_ops;
entry 129 sound/isa/gus/gus_mem_proc.c priv->size = entry->size = gus->gf1.rom_memory;
entry 855 sound/isa/opti9xx/miro.c struct snd_miro *miro = (struct snd_miro *) entry->private_data;
entry 958 sound/isa/opti9xx/miro.c struct snd_info_entry *entry;
entry 960 sound/isa/opti9xx/miro.c if (! snd_card_proc_new(miro->card, "miro", &entry))
entry 961 sound/isa/opti9xx/miro.c snd_info_set_text_ops(entry, miro, snd_miro_proc_read);
entry 1126 sound/isa/sb/sb16_csp.c struct snd_info_entry *entry;
entry 1128 sound/isa/sb/sb16_csp.c if (! snd_card_proc_new(p->chip->card, name, &entry))
entry 1129 sound/isa/sb/sb16_csp.c snd_info_set_text_ops(entry, p, info_read);
entry 1135 sound/isa/sb/sb16_csp.c struct snd_sb_csp *p = entry->private_data;
entry 1535 sound/oss/swarm_cs4297a.c struct list_head *entry;
entry 1540 sound/oss/swarm_cs4297a.c list_for_each(entry, &cs4297a_devs)
entry 1542 sound/oss/swarm_cs4297a.c s = list_entry(entry, struct cs4297a_state, list);
entry 2377 sound/oss/swarm_cs4297a.c struct list_head *entry;
entry 2385 sound/oss/swarm_cs4297a.c list_for_each(entry, &cs4297a_devs)
entry 2387 sound/oss/swarm_cs4297a.c s = list_entry(entry, struct cs4297a_state, list);
entry 2392 sound/oss/swarm_cs4297a.c if (entry == &cs4297a_devs)
entry 344 sound/pci/ac97/ac97_proc.c struct snd_ac97 *ac97 = entry->private_data;
entry 379 sound/pci/ac97/ac97_proc.c struct snd_ac97 *ac97 = entry->private_data;
entry 407 sound/pci/ac97/ac97_proc.c struct snd_ac97 *ac97 = entry->private_data;
entry 430 sound/pci/ac97/ac97_proc.c struct snd_info_entry *entry;
entry 438 sound/pci/ac97/ac97_proc.c if ((entry = snd_info_create_card_entry(ac97->bus->card, name, ac97->bus->proc)) != NULL) {
entry 439 sound/pci/ac97/ac97_proc.c snd_info_set_text_ops(entry, ac97, snd_ac97_proc_read);
entry 440 sound/pci/ac97/ac97_proc.c if (snd_info_register(entry) < 0) {
entry 441 sound/pci/ac97/ac97_proc.c snd_info_free_entry(entry);
entry 442 sound/pci/ac97/ac97_proc.c entry = NULL;
entry 445 sound/pci/ac97/ac97_proc.c ac97->proc = entry;
entry 447 sound/pci/ac97/ac97_proc.c if ((entry = snd_info_create_card_entry(ac97->bus->card, name, ac97->bus->proc)) != NULL) {
entry 448 sound/pci/ac97/ac97_proc.c snd_info_set_text_ops(entry, ac97, snd_ac97_proc_regs_read);
entry 450 sound/pci/ac97/ac97_proc.c entry->mode |= S_IWUSR;
entry 451 sound/pci/ac97/ac97_proc.c entry->c.text.write = snd_ac97_proc_regs_write;
entry 453 sound/pci/ac97/ac97_proc.c if (snd_info_register(entry) < 0) {
entry 454 sound/pci/ac97/ac97_proc.c snd_info_free_entry(entry);
entry 455 sound/pci/ac97/ac97_proc.c entry = NULL;
entry 458 sound/pci/ac97/ac97_proc.c ac97->proc_regs = entry;
entry 471 sound/pci/ac97/ac97_proc.c struct snd_info_entry *entry;
entry 475 sound/pci/ac97/ac97_proc.c if ((entry = snd_info_create_card_entry(bus->card, name, bus->card->proc_root)) != NULL) {
entry 476 sound/pci/ac97/ac97_proc.c entry->mode = S_IFDIR | S_IRUGO | S_IXUGO;
entry 477 sound/pci/ac97/ac97_proc.c if (snd_info_register(entry) < 0) {
entry 478 sound/pci/ac97/ac97_proc.c snd_info_free_entry(entry);
entry 479 sound/pci/ac97/ac97_proc.c entry = NULL;
entry 482 sound/pci/ac97/ac97_proc.c bus->proc = entry;
entry 671 sound/pci/ad1889.c struct snd_ad1889 *chip = entry->private_data;
entry 752 sound/pci/ad1889.c struct snd_info_entry *entry;
entry 754 sound/pci/ad1889.c if (!snd_card_proc_new(chip->card, chip->card->driver, &entry))
entry 755 sound/pci/ad1889.c snd_info_set_text_ops(entry, chip, snd_ad1889_proc_read);
entry 475 sound/pci/ak4531_codec.c struct snd_ak4531 *ak4531 = entry->private_data;
entry 487 sound/pci/ak4531_codec.c struct snd_info_entry *entry;
entry 489 sound/pci/ak4531_codec.c if (! snd_card_proc_new(card, "ak4531", &entry))
entry 490 sound/pci/ak4531_codec.c snd_info_set_text_ops(entry, ak4531, snd_ak4531_proc_read);
entry 2128 sound/pci/ali5451/ali5451.c struct snd_ali *codec = entry->private_data;
entry 2136 sound/pci/ali5451/ali5451.c struct snd_info_entry *entry;
entry 2137 sound/pci/ali5451/ali5451.c if (!snd_card_proc_new(codec->card, "ali5451", &entry))
entry 2138 sound/pci/ali5451/ali5451.c snd_info_set_text_ops(entry, codec, snd_ali_proc_read);
entry 1533 sound/pci/atiixp.c struct atiixp *chip = entry->private_data;
entry 1542 sound/pci/atiixp.c struct snd_info_entry *entry;
entry 1544 sound/pci/atiixp.c if (! snd_card_proc_new(chip->card, "atiixp", &entry))
entry 1545 sound/pci/atiixp.c snd_info_set_text_ops(entry, chip, snd_atiixp_proc_read);
entry 1176 sound/pci/atiixp_modem.c struct atiixp_modem *chip = entry->private_data;
entry 1185 sound/pci/atiixp_modem.c struct snd_info_entry *entry;
entry 1187 sound/pci/atiixp_modem.c if (! snd_card_proc_new(chip->card, "atiixp-modem", &entry))
entry 1188 sound/pci/atiixp_modem.c snd_info_set_text_ops(entry, chip, snd_atiixp_proc_read);
entry 278 sound/pci/ca0106/ca0106_proc.c struct snd_ca0106 *emu = entry->private_data;
entry 300 sound/pci/ca0106/ca0106_proc.c struct snd_ca0106 *emu = entry->private_data;
entry 318 sound/pci/ca0106/ca0106_proc.c struct snd_ca0106 *emu = entry->private_data;
entry 334 sound/pci/ca0106/ca0106_proc.c struct snd_ca0106 *emu = entry->private_data;
entry 350 sound/pci/ca0106/ca0106_proc.c struct snd_ca0106 *emu = entry->private_data;
entry 366 sound/pci/ca0106/ca0106_proc.c struct snd_ca0106 *emu = entry->private_data;
entry 384 sound/pci/ca0106/ca0106_proc.c struct snd_ca0106 *emu = entry->private_data;
entry 402 sound/pci/ca0106/ca0106_proc.c struct snd_ca0106 *emu = entry->private_data;
entry 416 sound/pci/ca0106/ca0106_proc.c struct snd_ca0106 *emu = entry->private_data;
entry 430 sound/pci/ca0106/ca0106_proc.c struct snd_info_entry *entry;
entry 432 sound/pci/ca0106/ca0106_proc.c if(! snd_card_proc_new(emu->card, "iec958", &entry))
entry 433 sound/pci/ca0106/ca0106_proc.c snd_info_set_text_ops(entry, emu, snd_ca0106_proc_iec958);
entry 434 sound/pci/ca0106/ca0106_proc.c if(! snd_card_proc_new(emu->card, "ca0106_reg32", &entry)) {
entry 435 sound/pci/ca0106/ca0106_proc.c snd_info_set_text_ops(entry, emu, snd_ca0106_proc_reg_read32);
entry 436 sound/pci/ca0106/ca0106_proc.c entry->c.text.write = snd_ca0106_proc_reg_write32;
entry 437 sound/pci/ca0106/ca0106_proc.c entry->mode |= S_IWUSR;
entry 439 sound/pci/ca0106/ca0106_proc.c if(! snd_card_proc_new(emu->card, "ca0106_reg16", &entry))
entry 440 sound/pci/ca0106/ca0106_proc.c snd_info_set_text_ops(entry, emu, snd_ca0106_proc_reg_read16);
entry 441 sound/pci/ca0106/ca0106_proc.c if(! snd_card_proc_new(emu->card, "ca0106_reg8", &entry))
entry 442 sound/pci/ca0106/ca0106_proc.c snd_info_set_text_ops(entry, emu, snd_ca0106_proc_reg_read8);
entry 443 sound/pci/ca0106/ca0106_proc.c if(! snd_card_proc_new(emu->card, "ca0106_regs1", &entry)) {
entry 444 sound/pci/ca0106/ca0106_proc.c snd_info_set_text_ops(entry, emu, snd_ca0106_proc_reg_read1);
entry 445 sound/pci/ca0106/ca0106_proc.c entry->c.text.write = snd_ca0106_proc_reg_write;
entry 446 sound/pci/ca0106/ca0106_proc.c entry->mode |= S_IWUSR;
entry 448 sound/pci/ca0106/ca0106_proc.c if(! snd_card_proc_new(emu->card, "ca0106_i2c", &entry)) {
entry 449 sound/pci/ca0106/ca0106_proc.c entry->c.text.write = snd_ca0106_proc_i2c_write;
entry 450 sound/pci/ca0106/ca0106_proc.c entry->private_data = emu;
entry 451 sound/pci/ca0106/ca0106_proc.c entry->mode |= S_IWUSR;
entry 453 sound/pci/ca0106/ca0106_proc.c if(! snd_card_proc_new(emu->card, "ca0106_regs2", &entry))
entry 454 sound/pci/ca0106/ca0106_proc.c snd_info_set_text_ops(entry, emu, snd_ca0106_proc_reg_read2);
entry 2772 sound/pci/cmipci.c struct cmipci *cm = entry->private_data;
entry 2789 sound/pci/cmipci.c struct snd_info_entry *entry;
entry 2791 sound/pci/cmipci.c if (! snd_card_proc_new(cm->card, "cmipci", &entry))
entry 2792 sound/pci/cmipci.c snd_info_set_text_ops(entry, cm, snd_cmipci_proc_read);
entry 1131 sound/pci/cs4281.c struct cs4281 *chip = entry->private_data;
entry 1144 sound/pci/cs4281.c struct cs4281 *chip = entry->private_data;
entry 1162 sound/pci/cs4281.c struct cs4281 *chip = entry->private_data;
entry 1184 sound/pci/cs4281.c struct snd_info_entry *entry;
entry 1186 sound/pci/cs4281.c if (! snd_card_proc_new(chip->card, "cs4281", &entry))
entry 1187 sound/pci/cs4281.c snd_info_set_text_ops(entry, chip, snd_cs4281_proc_read);
entry 1188 sound/pci/cs4281.c if (! snd_card_proc_new(chip->card, "cs4281_BA0", &entry)) {
entry 1189 sound/pci/cs4281.c entry->content = SNDRV_INFO_CONTENT_DATA;
entry 1190 sound/pci/cs4281.c entry->private_data = chip;
entry 1191 sound/pci/cs4281.c entry->c.ops = &snd_cs4281_proc_ops_BA0;
entry 1192 sound/pci/cs4281.c entry->size = CS4281_BA0_SIZE;
entry 1194 sound/pci/cs4281.c if (! snd_card_proc_new(chip->card, "cs4281_BA1", &entry)) {
entry 1195 sound/pci/cs4281.c entry->content = SNDRV_INFO_CONTENT_DATA;
entry 1196 sound/pci/cs4281.c entry->private_data = chip;
entry 1197 sound/pci/cs4281.c entry->c.ops = &snd_cs4281_proc_ops_BA1;
entry 1198 sound/pci/cs4281.c entry->size = CS4281_BA1_SIZE;
entry 2665 sound/pci/cs46xx/cs46xx_lib.c struct snd_cs46xx_region *region = entry->private_data;
entry 2683 sound/pci/cs46xx/cs46xx_lib.c struct snd_info_entry *entry;
entry 2688 sound/pci/cs46xx/cs46xx_lib.c if (! snd_card_proc_new(card, region->name, &entry)) {
entry 2689 sound/pci/cs46xx/cs46xx_lib.c entry->content = SNDRV_INFO_CONTENT_DATA;
entry 2690 sound/pci/cs46xx/cs46xx_lib.c entry->private_data = chip;
entry 2691 sound/pci/cs46xx/cs46xx_lib.c entry->c.ops = &snd_cs46xx_proc_io_ops;
entry 2692 sound/pci/cs46xx/cs46xx_lib.c entry->size = region->size;
entry 2693 sound/pci/cs46xx/cs46xx_lib.c entry->mode = S_IFREG | S_IRUSR;
entry 492 sound/pci/cs46xx/dsp_spos.c struct snd_cs46xx *chip = entry->private_data;
entry 520 sound/pci/cs46xx/dsp_spos.c struct snd_cs46xx *chip = entry->private_data;
entry 543 sound/pci/cs46xx/dsp_spos.c struct snd_cs46xx *chip = entry->private_data;
entry 571 sound/pci/cs46xx/dsp_spos.c struct snd_cs46xx *chip = entry->private_data;
entry 604 sound/pci/cs46xx/dsp_spos.c struct snd_cs46xx *chip = entry->private_data;
entry 632 sound/pci/cs46xx/dsp_spos.c struct snd_cs46xx *chip = entry->private_data;
entry 779 sound/pci/cs46xx/dsp_spos.c struct snd_info_entry *entry;
entry 785 sound/pci/cs46xx/dsp_spos.c if ((entry = snd_info_create_card_entry(card, "dsp", card->proc_root)) != NULL) {
entry 786 sound/pci/cs46xx/dsp_spos.c entry->content = SNDRV_INFO_CONTENT_TEXT;
entry 787 sound/pci/cs46xx/dsp_spos.c entry->mode = S_IFDIR | S_IRUGO | S_IXUGO;
entry 789 sound/pci/cs46xx/dsp_spos.c if (snd_info_register(entry) < 0) {
entry 790 sound/pci/cs46xx/dsp_spos.c snd_info_free_entry(entry);
entry 791 sound/pci/cs46xx/dsp_spos.c entry = NULL;
entry 795 sound/pci/cs46xx/dsp_spos.c ins->proc_dsp_dir = entry;
entry 800 sound/pci/cs46xx/dsp_spos.c if ((entry = snd_info_create_card_entry(card, "spos_symbols", ins->proc_dsp_dir)) != NULL) {
entry 801 sound/pci/cs46xx/dsp_spos.c entry->content = SNDRV_INFO_CONTENT_TEXT;
entry 802 sound/pci/cs46xx/dsp_spos.c entry->private_data = chip;
entry 803 sound/pci/cs46xx/dsp_spos.c entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
entry 804 sound/pci/cs46xx/dsp_spos.c entry->c.text.read = cs46xx_dsp_proc_symbol_table_read;
entry 805 sound/pci/cs46xx/dsp_spos.c if (snd_info_register(entry) < 0) {
entry 806 sound/pci/cs46xx/dsp_spos.c snd_info_free_entry(entry);
entry 807 sound/pci/cs46xx/dsp_spos.c entry = NULL;
entry 810 sound/pci/cs46xx/dsp_spos.c ins->proc_sym_info_entry = entry;
entry 812 sound/pci/cs46xx/dsp_spos.c if ((entry = snd_info_create_card_entry(card, "spos_modules", ins->proc_dsp_dir)) != NULL) {
entry 813 sound/pci/cs46xx/dsp_spos.c entry->content = SNDRV_INFO_CONTENT_TEXT;
entry 814 sound/pci/cs46xx/dsp_spos.c entry->private_data = chip;
entry 815 sound/pci/cs46xx/dsp_spos.c entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
entry 816 sound/pci/cs46xx/dsp_spos.c entry->c.text.read = cs46xx_dsp_proc_modules_read;
entry 817 sound/pci/cs46xx/dsp_spos.c if (snd_info_register(entry) < 0) {
entry 818 sound/pci/cs46xx/dsp_spos.c snd_info_free_entry(entry);
entry 819 sound/pci/cs46xx/dsp_spos.c entry = NULL;
entry 822 sound/pci/cs46xx/dsp_spos.c ins->proc_modules_info_entry = entry;
entry 824 sound/pci/cs46xx/dsp_spos.c if ((entry = snd_info_create_card_entry(card, "parameter", ins->proc_dsp_dir)) != NULL) {
entry 825 sound/pci/cs46xx/dsp_spos.c entry->content = SNDRV_INFO_CONTENT_TEXT;
entry 826 sound/pci/cs46xx/dsp_spos.c entry->private_data = chip;
entry 827 sound/pci/cs46xx/dsp_spos.c entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
entry 828 sound/pci/cs46xx/dsp_spos.c entry->c.text.read = cs46xx_dsp_proc_parameter_dump_read;
entry 829 sound/pci/cs46xx/dsp_spos.c if (snd_info_register(entry) < 0) {
entry 830 sound/pci/cs46xx/dsp_spos.c snd_info_free_entry(entry);
entry 831 sound/pci/cs46xx/dsp_spos.c entry = NULL;
entry 834 sound/pci/cs46xx/dsp_spos.c ins->proc_parameter_dump_info_entry = entry;
entry 836 sound/pci/cs46xx/dsp_spos.c if ((entry = snd_info_create_card_entry(card, "sample", ins->proc_dsp_dir)) != NULL) {
entry 837 sound/pci/cs46xx/dsp_spos.c entry->content = SNDRV_INFO_CONTENT_TEXT;
entry 838 sound/pci/cs46xx/dsp_spos.c entry->private_data = chip;
entry 839 sound/pci/cs46xx/dsp_spos.c entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
entry 840 sound/pci/cs46xx/dsp_spos.c entry->c.text.read = cs46xx_dsp_proc_sample_dump_read;
entry 841 sound/pci/cs46xx/dsp_spos.c if (snd_info_register(entry) < 0) {
entry 842 sound/pci/cs46xx/dsp_spos.c snd_info_free_entry(entry);
entry 843 sound/pci/cs46xx/dsp_spos.c entry = NULL;
entry 846 sound/pci/cs46xx/dsp_spos.c ins->proc_sample_dump_info_entry = entry;
entry 848 sound/pci/cs46xx/dsp_spos.c if ((entry = snd_info_create_card_entry(card, "task_tree", ins->proc_dsp_dir)) != NULL) {
entry 849 sound/pci/cs46xx/dsp_spos.c entry->content = SNDRV_INFO_CONTENT_TEXT;
entry 850 sound/pci/cs46xx/dsp_spos.c entry->private_data = chip;
entry 851 sound/pci/cs46xx/dsp_spos.c entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
entry 852 sound/pci/cs46xx/dsp_spos.c entry->c.text.read = cs46xx_dsp_proc_task_tree_read;
entry 853 sound/pci/cs46xx/dsp_spos.c if (snd_info_register(entry) < 0) {
entry 854 sound/pci/cs46xx/dsp_spos.c snd_info_free_entry(entry);
entry 855 sound/pci/cs46xx/dsp_spos.c entry = NULL;
entry 858 sound/pci/cs46xx/dsp_spos.c ins->proc_task_info_entry = entry;
entry 860 sound/pci/cs46xx/dsp_spos.c if ((entry = snd_info_create_card_entry(card, "scb_info", ins->proc_dsp_dir)) != NULL) {
entry 861 sound/pci/cs46xx/dsp_spos.c entry->content = SNDRV_INFO_CONTENT_TEXT;
entry 862 sound/pci/cs46xx/dsp_spos.c entry->private_data = chip;
entry 863 sound/pci/cs46xx/dsp_spos.c entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
entry 864 sound/pci/cs46xx/dsp_spos.c entry->c.text.read = cs46xx_dsp_proc_scb_read;
entry 865 sound/pci/cs46xx/dsp_spos.c if (snd_info_register(entry) < 0) {
entry 866 sound/pci/cs46xx/dsp_spos.c snd_info_free_entry(entry);
entry 867 sound/pci/cs46xx/dsp_spos.c entry = NULL;
entry 870 sound/pci/cs46xx/dsp_spos.c ins->proc_scb_info_entry = entry;
entry 74 sound/pci/cs46xx/dsp_spos_scb_lib.c struct proc_scb_info * scb_info = entry->private_data;
entry 250 sound/pci/cs46xx/dsp_spos_scb_lib.c struct snd_info_entry * entry;
entry 257 sound/pci/cs46xx/dsp_spos_scb_lib.c if ((entry = snd_info_create_card_entry(ins->snd_card, scb->scb_name,
entry 261 sound/pci/cs46xx/dsp_spos_scb_lib.c snd_info_free_entry(entry);
entry 262 sound/pci/cs46xx/dsp_spos_scb_lib.c entry = NULL;
entry 269 sound/pci/cs46xx/dsp_spos_scb_lib.c entry->content = SNDRV_INFO_CONTENT_TEXT;
entry 270 sound/pci/cs46xx/dsp_spos_scb_lib.c entry->private_data = scb_info;
entry 271 sound/pci/cs46xx/dsp_spos_scb_lib.c entry->mode = S_IFREG | S_IRUGO | S_IWUSR;
entry 273 sound/pci/cs46xx/dsp_spos_scb_lib.c entry->c.text.read = cs46xx_dsp_proc_scb_info_read;
entry 275 sound/pci/cs46xx/dsp_spos_scb_lib.c if (snd_info_register(entry) < 0) {
entry 276 sound/pci/cs46xx/dsp_spos_scb_lib.c snd_info_free_entry(entry);
entry 278 sound/pci/cs46xx/dsp_spos_scb_lib.c entry = NULL;
entry 282 sound/pci/cs46xx/dsp_spos_scb_lib.c scb->proc_info = entry;
entry 1008 sound/pci/emu10k1/emu10k1x.c struct emu10k1x *emu = entry->private_data;
entry 1036 sound/pci/emu10k1/emu10k1x.c struct emu10k1x *emu = entry->private_data;
entry 1052 sound/pci/emu10k1/emu10k1x.c struct snd_info_entry *entry;
entry 1054 sound/pci/emu10k1/emu10k1x.c if(! snd_card_proc_new(emu->card, "emu10k1x_regs", &entry)) {
entry 1055 sound/pci/emu10k1/emu10k1x.c snd_info_set_text_ops(entry, emu, snd_emu10k1x_proc_reg_read);
entry 1056 sound/pci/emu10k1/emu10k1x.c entry->c.text.write = snd_emu10k1x_proc_reg_write;
entry 1057 sound/pci/emu10k1/emu10k1x.c entry->mode |= S_IWUSR;
entry 1058 sound/pci/emu10k1/emu10k1x.c entry->private_data = emu;
entry 187 sound/pci/emu10k1/emuproc.c struct snd_emu10k1 *emu = entry->private_data;
entry 241 sound/pci/emu10k1/emuproc.c struct snd_emu10k1 *emu = entry->private_data;
entry 290 sound/pci/emu10k1/emuproc.c struct snd_emu10k1 *emu = entry->private_data;
entry 305 sound/pci/emu10k1/emuproc.c struct snd_emu10k1 *emu = entry->private_data;
entry 350 sound/pci/emu10k1/emuproc.c struct snd_emu10k1 *emu = entry->private_data;
entry 354 sound/pci/emu10k1/emuproc.c if (!strcmp(entry->name, "fx8010_tram_addr")) {
entry 357 sound/pci/emu10k1/emuproc.c } else if (!strcmp(entry->name, "fx8010_tram_data")) {
entry 359 sound/pci/emu10k1/emuproc.c } else if (!strcmp(entry->name, "fx8010_code")) {
entry 365 sound/pci/emu10k1/emuproc.c if (pos + size > entry->size)
entry 366 sound/pci/emu10k1/emuproc.c size = (long)entry->size - pos;
entry 393 sound/pci/emu10k1/emuproc.c struct snd_emu10k1 *emu = entry->private_data;
entry 414 sound/pci/emu10k1/emuproc.c struct snd_emu10k1 *emu = entry->private_data;
entry 431 sound/pci/emu10k1/emuproc.c struct snd_emu10k1 *emu = entry->private_data;
entry 447 sound/pci/emu10k1/emuproc.c struct snd_emu10k1 *emu = entry->private_data;
entry 500 sound/pci/emu10k1/emuproc.c struct snd_emu10k1 *emu = entry->private_data;
entry 524 sound/pci/emu10k1/emuproc.c struct snd_emu10k1 *emu = entry->private_data;
entry 538 sound/pci/emu10k1/emuproc.c snd_emu_proc_ptr_reg_write(entry, buffer, 0);
entry 544 sound/pci/emu10k1/emuproc.c snd_emu_proc_ptr_reg_write(entry, buffer, 0x20);
entry 551 sound/pci/emu10k1/emuproc.c snd_emu_proc_ptr_reg_read(entry, buffer, 0, 0, 0x40, 64);
entry 557 sound/pci/emu10k1/emuproc.c snd_emu_proc_ptr_reg_read(entry, buffer, 0, 0x40, 0x40, 64);
entry 563 sound/pci/emu10k1/emuproc.c snd_emu_proc_ptr_reg_read(entry, buffer, 0x20, 0, 0x40, 4);
entry 569 sound/pci/emu10k1/emuproc.c snd_emu_proc_ptr_reg_read(entry, buffer, 0x20, 0x40, 0x40, 4);
entry 575 sound/pci/emu10k1/emuproc.c snd_emu_proc_ptr_reg_read(entry, buffer, 0x20, 0x80, 0x20, 4);
entry 585 sound/pci/emu10k1/emuproc.c struct snd_info_entry *entry;
entry 588 sound/pci/emu10k1/emuproc.c if (! snd_card_proc_new(emu->card, "emu1010_regs", &entry))
entry 589 sound/pci/emu10k1/emuproc.c snd_info_set_text_ops(entry, emu, snd_emu_proc_emu1010_reg_read);
entry 591 sound/pci/emu10k1/emuproc.c if (! snd_card_proc_new(emu->card, "io_regs", &entry)) {
entry 592 sound/pci/emu10k1/emuproc.c snd_info_set_text_ops(entry, emu, snd_emu_proc_io_reg_read);
entry 593 sound/pci/emu10k1/emuproc.c entry->c.text.write = snd_emu_proc_io_reg_write;
entry 594 sound/pci/emu10k1/emuproc.c entry->mode |= S_IWUSR;
entry 596 sound/pci/emu10k1/emuproc.c if (! snd_card_proc_new(emu->card, "ptr_regs00a", &entry)) {
entry 597 sound/pci/emu10k1/emuproc.c snd_info_set_text_ops(entry, emu, snd_emu_proc_ptr_reg_read00a);
entry 598 sound/pci/emu10k1/emuproc.c entry->c.text.write = snd_emu_proc_ptr_reg_write00;
entry 599 sound/pci/emu10k1/emuproc.c entry->mode |= S_IWUSR;
entry 601 sound/pci/emu10k1/emuproc.c if (! snd_card_proc_new(emu->card, "ptr_regs00b", &entry)) {
entry 602 sound/pci/emu10k1/emuproc.c snd_info_set_text_ops(entry, emu, snd_emu_proc_ptr_reg_read00b);
entry 603 sound/pci/emu10k1/emuproc.c entry->c.text.write = snd_emu_proc_ptr_reg_write00;
entry 604 sound/pci/emu10k1/emuproc.c entry->mode |= S_IWUSR;
entry 606 sound/pci/emu10k1/emuproc.c if (! snd_card_proc_new(emu->card, "ptr_regs20a", &entry)) {
entry 607 sound/pci/emu10k1/emuproc.c snd_info_set_text_ops(entry, emu, snd_emu_proc_ptr_reg_read20a);
entry 608 sound/pci/emu10k1/emuproc.c entry->c.text.write = snd_emu_proc_ptr_reg_write20;
entry 609 sound/pci/emu10k1/emuproc.c entry->mode |= S_IWUSR;
entry 611 sound/pci/emu10k1/emuproc.c if (! snd_card_proc_new(emu->card, "ptr_regs20b", &entry)) {
entry 612 sound/pci/emu10k1/emuproc.c snd_info_set_text_ops(entry, emu, snd_emu_proc_ptr_reg_read20b);
entry 613 sound/pci/emu10k1/emuproc.c entry->c.text.write = snd_emu_proc_ptr_reg_write20;
entry 614 sound/pci/emu10k1/emuproc.c entry->mode |= S_IWUSR;
entry 616 sound/pci/emu10k1/emuproc.c if (! snd_card_proc_new(emu->card, "ptr_regs20c", &entry)) {
entry 617 sound/pci/emu10k1/emuproc.c snd_info_set_text_ops(entry, emu, snd_emu_proc_ptr_reg_read20c);
entry 618 sound/pci/emu10k1/emuproc.c entry->c.text.write = snd_emu_proc_ptr_reg_write20;
entry 619 sound/pci/emu10k1/emuproc.c entry->mode |= S_IWUSR;
entry 623 sound/pci/emu10k1/emuproc.c if (! snd_card_proc_new(emu->card, "emu10k1", &entry))
entry 624 sound/pci/emu10k1/emuproc.c snd_info_set_text_ops(entry, emu, snd_emu10k1_proc_read);
entry 627 sound/pci/emu10k1/emuproc.c if (! snd_card_proc_new(emu->card, "spdif-in", &entry))
entry 628 sound/pci/emu10k1/emuproc.c snd_info_set_text_ops(entry, emu, snd_emu10k1_proc_spdif_read);
entry 631 sound/pci/emu10k1/emuproc.c if (! snd_card_proc_new(emu->card, "capture-rates", &entry))
entry 632 sound/pci/emu10k1/emuproc.c snd_info_set_text_ops(entry, emu, snd_emu10k1_proc_rates_read);
entry 635 sound/pci/emu10k1/emuproc.c if (! snd_card_proc_new(emu->card, "voices", &entry))
entry 636 sound/pci/emu10k1/emuproc.c snd_info_set_text_ops(entry, emu, snd_emu10k1_proc_voices_read);
entry 638 sound/pci/emu10k1/emuproc.c if (! snd_card_proc_new(emu->card, "fx8010_gpr", &entry)) {
entry 639 sound/pci/emu10k1/emuproc.c entry->content = SNDRV_INFO_CONTENT_DATA;
entry 640 sound/pci/emu10k1/emuproc.c entry->private_data = emu;
entry 641 sound/pci/emu10k1/emuproc.c entry->mode = S_IFREG | S_IRUGO /*| S_IWUSR*/;
entry 642 sound/pci/emu10k1/emuproc.c entry->size = emu->audigy ? A_TOTAL_SIZE_GPR : TOTAL_SIZE_GPR;
entry 643 sound/pci/emu10k1/emuproc.c entry->c.ops = &snd_emu10k1_proc_ops_fx8010;
entry 645 sound/pci/emu10k1/emuproc.c if (! snd_card_proc_new(emu->card, "fx8010_tram_data", &entry)) {
entry 646 sound/pci/emu10k1/emuproc.c entry->content = SNDRV_INFO_CONTENT_DATA;
entry 647 sound/pci/emu10k1/emuproc.c entry->private_data = emu;
entry 648 sound/pci/emu10k1/emuproc.c entry->mode = S_IFREG | S_IRUGO /*| S_IWUSR*/;
entry 649 sound/pci/emu10k1/emuproc.c entry->size = emu->audigy ? A_TOTAL_SIZE_TANKMEM_DATA : TOTAL_SIZE_TANKMEM_DATA ;
entry 650 sound/pci/emu10k1/emuproc.c entry->c.ops = &snd_emu10k1_proc_ops_fx8010;
entry 652 sound/pci/emu10k1/emuproc.c if (! snd_card_proc_new(emu->card, "fx8010_tram_addr", &entry)) {
entry 653 sound/pci/emu10k1/emuproc.c entry->content = SNDRV_INFO_CONTENT_DATA;
entry 654 sound/pci/emu10k1/emuproc.c entry->private_data = emu;
entry 655 sound/pci/emu10k1/emuproc.c entry->mode = S_IFREG | S_IRUGO /*| S_IWUSR*/;
entry 656 sound/pci/emu10k1/emuproc.c entry->size = emu->audigy ? A_TOTAL_SIZE_TANKMEM_ADDR : TOTAL_SIZE_TANKMEM_ADDR ;
entry 657 sound/pci/emu10k1/emuproc.c entry->c.ops = &snd_emu10k1_proc_ops_fx8010;
entry 659 sound/pci/emu10k1/emuproc.c if (! snd_card_proc_new(emu->card, "fx8010_code", &entry)) {
entry 660 sound/pci/emu10k1/emuproc.c entry->content = SNDRV_INFO_CONTENT_DATA;
entry 661 sound/pci/emu10k1/emuproc.c entry->private_data = emu;
entry 662 sound/pci/emu10k1/emuproc.c entry->mode = S_IFREG | S_IRUGO /*| S_IWUSR*/;
entry 663 sound/pci/emu10k1/emuproc.c entry->size = emu->audigy ? A_TOTAL_SIZE_CODE : TOTAL_SIZE_CODE;
entry 664 sound/pci/emu10k1/emuproc.c entry->c.ops = &snd_emu10k1_proc_ops_fx8010;
entry 666 sound/pci/emu10k1/emuproc.c if (! snd_card_proc_new(emu->card, "fx8010_acode", &entry)) {
entry 667 sound/pci/emu10k1/emuproc.c entry->content = SNDRV_INFO_CONTENT_TEXT;
entry 668 sound/pci/emu10k1/emuproc.c entry->private_data = emu;
entry 669 sound/pci/emu10k1/emuproc.c entry->mode = S_IFREG | S_IRUGO /*| S_IWUSR*/;
entry 670 sound/pci/emu10k1/emuproc.c entry->c.text.read = snd_emu10k1_proc_acode_read;
entry 1870 sound/pci/ens1370.c struct ensoniq *ensoniq = entry->private_data;
entry 1892 sound/pci/ens1370.c struct snd_info_entry *entry;
entry 1894 sound/pci/ens1370.c if (! snd_card_proc_new(ensoniq->card, "audiopci", &entry))
entry 1895 sound/pci/ens1370.c snd_info_set_text_ops(entry, ensoniq, snd_ensoniq_proc_read);
entry 513 sound/pci/hda/hda_proc.c struct hda_codec *codec = entry->private_data;
entry 663 sound/pci/hda/hda_proc.c struct snd_info_entry *entry;
entry 667 sound/pci/hda/hda_proc.c err = snd_card_proc_new(codec->bus->card, name, &entry);
entry 671 sound/pci/hda/hda_proc.c snd_info_set_text_ops(entry, codec, print_codec_info);
entry 1558 sound/pci/ice1712/ice1712.c struct snd_ice1712 *ice = entry->private_data;
entry 1597 sound/pci/ice1712/ice1712.c struct snd_info_entry *entry;
entry 1599 sound/pci/ice1712/ice1712.c if (!snd_card_proc_new(ice->card, "ice1712", &entry))
entry 1600 sound/pci/ice1712/ice1712.c snd_info_set_text_ops(entry, ice, snd_ice1712_proc_read);
entry 1431 sound/pci/ice1712/ice1724.c struct snd_ice1712 *ice = entry->private_data;
entry 1472 sound/pci/ice1712/ice1724.c struct snd_info_entry *entry;
entry 1474 sound/pci/ice1712/ice1724.c if (!snd_card_proc_new(ice->card, "ice1724", &entry))
entry 1475 sound/pci/ice1712/ice1724.c snd_info_set_text_ops(entry, ice, snd_vt1724_proc_read);
entry 418 sound/pci/ice1712/juli.c struct snd_ice1712 *ice = (struct snd_ice1712 *)entry->private_data;
entry 428 sound/pci/ice1712/juli.c struct snd_info_entry *entry;
entry 429 sound/pci/ice1712/juli.c if (!snd_card_proc_new(ice->card, "ak4358_codec", &entry))
entry 430 sound/pci/ice1712/juli.c snd_info_set_text_ops(entry, ice, ak4358_proc_regs_read);
entry 641 sound/pci/ice1712/pontis.c struct snd_ice1712 *ice = (struct snd_ice1712 *)entry->private_data;
entry 656 sound/pci/ice1712/pontis.c struct snd_ice1712 *ice = (struct snd_ice1712 *)entry->private_data;
entry 669 sound/pci/ice1712/pontis.c struct snd_info_entry *entry;
entry 670 sound/pci/ice1712/pontis.c if (! snd_card_proc_new(ice->card, "wm_codec", &entry)) {
entry 671 sound/pci/ice1712/pontis.c snd_info_set_text_ops(entry, ice, wm_proc_regs_read);
entry 672 sound/pci/ice1712/pontis.c entry->mode |= S_IWUSR;
entry 673 sound/pci/ice1712/pontis.c entry->c.text.write = wm_proc_regs_write;
entry 679 sound/pci/ice1712/pontis.c struct snd_ice1712 *ice = (struct snd_ice1712 *)entry->private_data;
entry 694 sound/pci/ice1712/pontis.c struct snd_info_entry *entry;
entry 695 sound/pci/ice1712/pontis.c if (! snd_card_proc_new(ice->card, "cs_codec", &entry))
entry 696 sound/pci/ice1712/pontis.c snd_info_set_text_ops(entry, ice, cs_proc_regs_read);
entry 652 sound/pci/ice1712/prodigy192.c struct snd_ice1712 *ice = (struct snd_ice1712 *)entry->private_data;
entry 664 sound/pci/ice1712/prodigy192.c struct snd_info_entry *entry;
entry 665 sound/pci/ice1712/prodigy192.c if (!snd_card_proc_new(ice->card, "stac9460_codec", &entry))
entry 666 sound/pci/ice1712/prodigy192.c snd_info_set_text_ops(entry, ice, stac9460_proc_regs_read);
entry 904 sound/pci/ice1712/prodigy_hifi.c struct snd_ice1712 *ice = entry->private_data;
entry 920 sound/pci/ice1712/prodigy_hifi.c struct snd_ice1712 *ice = entry->private_data;
entry 933 sound/pci/ice1712/prodigy_hifi.c struct snd_info_entry *entry;
entry 934 sound/pci/ice1712/prodigy_hifi.c if (!snd_card_proc_new(ice->card, "wm_codec", &entry)) {
entry 935 sound/pci/ice1712/prodigy_hifi.c snd_info_set_text_ops(entry, ice, wm_proc_regs_read);
entry 936 sound/pci/ice1712/prodigy_hifi.c entry->mode |= S_IWUSR;
entry 937 sound/pci/ice1712/prodigy_hifi.c entry->c.text.write = wm_proc_regs_write;
entry 2727 sound/pci/intel8x0.c struct intel8x0 *chip = entry->private_data;
entry 2760 sound/pci/intel8x0.c struct snd_info_entry *entry;
entry 2762 sound/pci/intel8x0.c if (! snd_card_proc_new(chip->card, "intel8x0", &entry))
entry 2763 sound/pci/intel8x0.c snd_info_set_text_ops(entry, chip, snd_intel8x0_proc_read);
entry 1062 sound/pci/intel8x0m.c struct intel8x0m *chip = entry->private_data;
entry 1081 sound/pci/intel8x0m.c struct snd_info_entry *entry;
entry 1083 sound/pci/intel8x0m.c if (! snd_card_proc_new(chip->card, "intel8x0m", &entry))
entry 1084 sound/pci/intel8x0m.c snd_info_set_text_ops(entry, chip, snd_intel8x0m_proc_read);
entry 2060 sound/pci/korg1212/korg1212.c struct snd_korg1212 *korg1212 = entry->private_data;
entry 2086 sound/pci/korg1212/korg1212.c struct snd_info_entry *entry;
entry 2088 sound/pci/korg1212/korg1212.c if (! snd_card_proc_new(korg1212->card, "korg1212", &entry))
entry 2089 sound/pci/korg1212/korg1212.c snd_info_set_text_ops(entry, korg1212, snd_korg1212_proc_read);
entry 1161 sound/pci/mixart/mixart.c struct mixart_mgr *mgr = entry->private_data;
entry 1180 sound/pci/mixart/mixart.c struct mixart_mgr *mgr = entry->private_data;
entry 1206 sound/pci/mixart/mixart.c struct snd_mixart *chip = entry->private_data;
entry 1241 sound/pci/mixart/mixart.c struct snd_info_entry *entry;
entry 1244 sound/pci/mixart/mixart.c if (! snd_card_proc_new(chip->card, "board_info", &entry)) {
entry 1245 sound/pci/mixart/mixart.c entry->private_data = chip;
entry 1246 sound/pci/mixart/mixart.c entry->c.text.read = snd_mixart_proc_read;
entry 1249 sound/pci/mixart/mixart.c if (! snd_card_proc_new(chip->card, "mixart_BA0", &entry)) {
entry 1250 sound/pci/mixart/mixart.c entry->content = SNDRV_INFO_CONTENT_DATA;
entry 1251 sound/pci/mixart/mixart.c entry->private_data = chip->mgr;
entry 1252 sound/pci/mixart/mixart.c entry->c.ops = &snd_mixart_proc_ops_BA0;
entry 1253 sound/pci/mixart/mixart.c entry->size = MIXART_BA0_SIZE;
entry 1255 sound/pci/mixart/mixart.c if (! snd_card_proc_new(chip->card, "mixart_BA1", &entry)) {
entry 1256 sound/pci/mixart/mixart.c entry->content = SNDRV_INFO_CONTENT_DATA;
entry 1257 sound/pci/mixart/mixart.c entry->private_data = chip->mgr;
entry 1258 sound/pci/mixart/mixart.c entry->c.ops = &snd_mixart_proc_ops_BA1;
entry 1259 sound/pci/mixart/mixart.c entry->size = MIXART_BA1_SIZE;
entry 200 sound/pci/oxygen/oxygen_lib.c struct oxygen *chip = entry->private_data;
entry 237 sound/pci/oxygen/oxygen_lib.c struct snd_info_entry *entry;
entry 239 sound/pci/oxygen/oxygen_lib.c if (!snd_card_proc_new(chip->card, "cmi8788", &entry))
entry 240 sound/pci/oxygen/oxygen_lib.c snd_info_set_text_ops(entry, chip, oxygen_proc_read);
entry 1061 sound/pci/pcxhr/pcxhr.c struct snd_pcxhr *chip = entry->private_data;
entry 1122 sound/pci/pcxhr/pcxhr.c struct snd_pcxhr *chip = entry->private_data;
entry 1148 sound/pci/pcxhr/pcxhr.c struct snd_info_entry *entry;
entry 1150 sound/pci/pcxhr/pcxhr.c if (! snd_card_proc_new(chip->card, "info", &entry))
entry 1151 sound/pci/pcxhr/pcxhr.c snd_info_set_text_ops(entry, chip, pcxhr_proc_info);
entry 1152 sound/pci/pcxhr/pcxhr.c if (! snd_card_proc_new(chip->card, "sync", &entry))
entry 1153 sound/pci/pcxhr/pcxhr.c snd_info_set_text_ops(entry, chip, pcxhr_proc_sync);
entry 1939 sound/pci/riptide/riptide.c struct snd_riptide *chip = entry->private_data;
entry 2008 sound/pci/riptide/riptide.c struct snd_info_entry *entry;
entry 2010 sound/pci/riptide/riptide.c if (!snd_card_proc_new(chip->card, "riptide", &entry))
entry 2011 sound/pci/riptide/riptide.c snd_info_set_text_ops(entry, chip, snd_riptide_proc_read);
entry 1469 sound/pci/rme32.c struct rme32 *rme32 = (struct rme32 *) entry->private_data;
entry 1562 sound/pci/rme32.c struct snd_info_entry *entry;
entry 1564 sound/pci/rme32.c if (! snd_card_proc_new(rme32->card, "rme32", &entry))
entry 1565 sound/pci/rme32.c snd_info_set_text_ops(entry, rme32, snd_rme32_proc_read);
entry 1669 sound/pci/rme96.c struct rme96 *rme96 = (struct rme96 *)entry->private_data;
entry 1797 sound/pci/rme96.c struct snd_info_entry *entry;
entry 1799 sound/pci/rme96.c if (! snd_card_proc_new(rme96->card, "rme96", &entry))
entry 1800 sound/pci/rme96.c snd_info_set_text_ops(entry, rme96, snd_rme96_proc_read);
entry 3268 sound/pci/rme9652/hdsp.c struct hdsp *hdsp = (struct hdsp *) entry->private_data;
entry 3584 sound/pci/rme9652/hdsp.c struct snd_info_entry *entry;
entry 3586 sound/pci/rme9652/hdsp.c if (! snd_card_proc_new(hdsp->card, "hdsp", &entry))
entry 3587 sound/pci/rme9652/hdsp.c snd_info_set_text_ops(entry, hdsp, snd_hdsp_proc_read);
entry 2944 sound/pci/rme9652/hdspm.c struct hdspm *hdspm = entry->private_data;
entry 3139 sound/pci/rme9652/hdspm.c struct hdspm *hdspm = entry->private_data;
entry 3311 sound/pci/rme9652/hdspm.c struct hdspm *hdspm = entry->private_data;
entry 3328 sound/pci/rme9652/hdspm.c struct snd_info_entry *entry;
entry 3330 sound/pci/rme9652/hdspm.c if (!snd_card_proc_new(hdspm->card, "hdspm", &entry))
entry 3331 sound/pci/rme9652/hdspm.c snd_info_set_text_ops(entry, hdspm,
entry 3337 sound/pci/rme9652/hdspm.c if (!snd_card_proc_new(hdspm->card, "debug", &entry))
entry 3338 sound/pci/rme9652/hdspm.c snd_info_set_text_ops(entry, hdspm,
entry 1591 sound/pci/rme9652/rme9652.c struct snd_rme9652 *rme9652 = (struct snd_rme9652 *) entry->private_data;
entry 1763 sound/pci/rme9652/rme9652.c struct snd_info_entry *entry;
entry 1765 sound/pci/rme9652/rme9652.c if (! snd_card_proc_new(rme9652->card, "rme9652", &entry))
entry 1766 sound/pci/rme9652/rme9652.c snd_info_set_text_ops(entry, rme9652, snd_rme9652_proc_read);
entry 1116 sound/pci/sonicvibes.c struct sonicvibes *sonic = entry->private_data;
entry 1145 sound/pci/sonicvibes.c struct snd_info_entry *entry;
entry 1147 sound/pci/sonicvibes.c if (! snd_card_proc_new(sonic->card, "sonicvibes", &entry))
entry 1148 sound/pci/sonicvibes.c snd_info_set_text_ops(entry, sonic, snd_sonicvibes_proc_read);
entry 3294 sound/pci/trident/trident_main.c struct snd_trident *trident = entry->private_data;
entry 3328 sound/pci/trident/trident_main.c struct snd_info_entry *entry;
entry 3333 sound/pci/trident/trident_main.c if (! snd_card_proc_new(trident->card, s, &entry))
entry 3334 sound/pci/trident/trident_main.c snd_info_set_text_ops(entry, trident, snd_trident_proc_read);
entry 2027 sound/pci/via82xx.c struct via82xx *chip = entry->private_data;
entry 2038 sound/pci/via82xx.c struct snd_info_entry *entry;
entry 2040 sound/pci/via82xx.c if (! snd_card_proc_new(chip->card, "via82xx", &entry))
entry 2041 sound/pci/via82xx.c snd_info_set_text_ops(entry, chip, snd_via82xx_proc_read);
entry 919 sound/pci/via82xx_modem.c struct via82xx_modem *chip = entry->private_data;
entry 930 sound/pci/via82xx_modem.c struct snd_info_entry *entry;
entry 932 sound/pci/via82xx_modem.c if (! snd_card_proc_new(chip->card, "via82xx", &entry))
entry 933 sound/pci/via82xx_modem.c snd_info_set_text_ops(entry, chip, snd_via82xx_proc_read);
entry 1943 sound/pci/ymfpci/ymfpci_main.c struct snd_ymfpci *chip = entry->private_data;
entry 1953 sound/pci/ymfpci/ymfpci_main.c struct snd_info_entry *entry;
entry 1955 sound/pci/ymfpci/ymfpci_main.c if (! snd_card_proc_new(card, "ymfpci", &entry))
entry 1956 sound/pci/ymfpci/ymfpci_main.c snd_info_set_text_ops(entry, chip, snd_ymfpci_proc_read);
entry 132 sound/pcmcia/pdaudiocf/pdaudiocf_core.c struct snd_pdacf *chip = entry->private_data;
entry 143 sound/pcmcia/pdaudiocf/pdaudiocf_core.c struct snd_info_entry *entry;
entry 145 sound/pcmcia/pdaudiocf/pdaudiocf_core.c if (! snd_card_proc_new(chip->card, "pdaudiocf", &entry))
entry 146 sound/pcmcia/pdaudiocf/pdaudiocf_core.c snd_info_set_text_ops(entry, chip, pdacf_proc_read);
entry 2406 sound/sparc/dbri.c .private_value = (entry) | ((shift) << 8) | ((mask) << 16) | \
entry 2468 sound/sparc/dbri.c struct snd_dbri *dbri = entry->private_data;
entry 2480 sound/sparc/dbri.c struct snd_dbri *dbri = entry->private_data;
entry 2503 sound/sparc/dbri.c struct snd_info_entry *entry;
entry 2505 sound/sparc/dbri.c if (!snd_card_proc_new(card, "regs", &entry))
entry 2506 sound/sparc/dbri.c snd_info_set_text_ops(entry, dbri, dbri_regs_read);
entry 2509 sound/sparc/dbri.c if (!snd_card_proc_new(card, "debug", &entry)) {
entry 2510 sound/sparc/dbri.c snd_info_set_text_ops(entry, dbri, dbri_debug_read);
entry 2511 sound/sparc/dbri.c entry->mode = S_IFREG | S_IRUGO; /* Readable only. */
entry 37 sound/synth/emux/emux_proc.c emu = entry->private_data;
entry 110 sound/synth/emux/emux_proc.c struct snd_info_entry *entry;
entry 114 sound/synth/emux/emux_proc.c entry = snd_info_create_card_entry(card, name, card->proc_root);
entry 115 sound/synth/emux/emux_proc.c if (entry == NULL)
entry 118 sound/synth/emux/emux_proc.c entry->content = SNDRV_INFO_CONTENT_TEXT;
entry 119 sound/synth/emux/emux_proc.c entry->private_data = emu;
entry 120 sound/synth/emux/emux_proc.c entry->c.text.read = snd_emux_proc_info_read;
entry 121 sound/synth/emux/emux_proc.c if (snd_info_register(entry) < 0)
entry 122 sound/synth/emux/emux_proc.c snd_info_free_entry(entry);
entry 124 sound/synth/emux/emux_proc.c emu->proc = entry;
entry 2211 sound/usb/usbaudio.c struct snd_usb_stream *stream = entry->private_data;
entry 2229 sound/usb/usbaudio.c struct snd_info_entry *entry;
entry 2234 sound/usb/usbaudio.c if (!snd_card_proc_new(card, name, &entry))
entry 2235 sound/usb/usbaudio.c snd_info_set_text_ops(entry, stream, proc_pcm_format_read);
entry 3399 sound/usb/usbaudio.c struct snd_usb_audio *chip = entry->private_data;
entry 3406 sound/usb/usbaudio.c struct snd_usb_audio *chip = entry->private_data;
entry 3415 sound/usb/usbaudio.c struct snd_info_entry *entry;
entry 3416 sound/usb/usbaudio.c if (!snd_card_proc_new(chip->card, "usbbus", &entry))
entry 3417 sound/usb/usbaudio.c snd_info_set_text_ops(entry, chip, proc_audio_usbbus_read);
entry 3418 sound/usb/usbaudio.c if (!snd_card_proc_new(chip->card, "usbid", &entry))
entry 3419 sound/usb/usbaudio.c snd_info_set_text_ops(entry, chip, proc_audio_usbid_read);
entry 1991 sound/usb/usbmixer.c struct usb_mixer_interface *mixer = entry->private_data;
entry 2049 sound/usb/usbmixer.c struct snd_info_entry *entry;
entry 2053 sound/usb/usbmixer.c if (!snd_card_proc_new(chip->card, "audigy2nx", &entry))
entry 2054 sound/usb/usbmixer.c snd_info_set_text_ops(entry, mixer,
entry 272 virt/kvm/ioapic.c union ioapic_redir_entry entry;
entry 275 virt/kvm/ioapic.c entry = ioapic->redirtbl[irq];
entry 276 virt/kvm/ioapic.c level ^= entry.fields.polarity;
entry 281 virt/kvm/ioapic.c if ((!entry.fields.trig_mode && old_irr != ioapic->irr)
entry 282 virt/kvm/ioapic.c || !entry.fields.remote_irr)