From 5b7c4cabbb65f5c469464da6c5f614cbd7f730f2 Mon Sep 17 00:00:00 2001 From: Linus Torvalds Date: Tue, 21 Feb 2023 18:24:12 -0800 Subject: Merge tag 'net-next-6.3' of git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next Pull networking updates from Jakub Kicinski: "Core: - Add dedicated kmem_cache for typical/small skb->head, avoid having to access struct page at kfree time, and improve memory use. - Introduce sysctl to set default RPS configuration for new netdevs. - Define Netlink protocol specification format which can be used to describe messages used by each family and auto-generate parsers. Add tools for generating kernel data structures and uAPI headers. - Expose all net/core sysctls inside netns. - Remove 4s sleep in netpoll if carrier is instantly detected on boot. - Add configurable limit of MDB entries per port, and port-vlan. - Continue populating drop reasons throughout the stack. - Retire a handful of legacy Qdiscs and classifiers. Protocols: - Support IPv4 big TCP (TSO frames larger than 64kB). - Add IP_LOCAL_PORT_RANGE socket option, to control local port range on socket by socket basis. - Track and report in procfs number of MPTCP sockets used. - Support mixing IPv4 and IPv6 flows in the in-kernel MPTCP path manager. - IPv6: don't check net.ipv6.route.max_size and rely on garbage collection to free memory (similarly to IPv4). - Support Penultimate Segment Pop (PSP) flavor in SRv6 (RFC8986). - ICMP: add per-rate limit counters. - Add support for user scanning requests in ieee802154. - Remove static WEP support. - Support minimal Wi-Fi 7 Extremely High Throughput (EHT) rate reporting. - WiFi 7 EHT channel puncturing support (client & AP). BPF: - Add a rbtree data structure following the "next-gen data structure" precedent set by recently added linked list, that is, by using kfunc + kptr instead of adding a new BPF map type. - Expose XDP hints via kfuncs with initial support for RX hash and timestamp metadata. - Add BPF_F_NO_TUNNEL_KEY extension to bpf_skb_set_tunnel_key to better support decap on GRE tunnel devices not operating in collect metadata. - Improve x86 JIT's codegen for PROBE_MEM runtime error checks. - Remove the need for trace_printk_lock for bpf_trace_printk and bpf_trace_vprintk helpers. - Extend libbpf's bpf_tracing.h support for tracing arguments of kprobes/uprobes and syscall as a special case. - Significantly reduce the search time for module symbols by livepatch and BPF. - Enable cpumasks to be used as kptrs, which is useful for tracing programs tracking which tasks end up running on which CPUs in different time intervals. - Add support for BPF trampoline on s390x and riscv64. - Add capability to export the XDP features supported by the NIC. - Add __bpf_kfunc tag for marking kernel functions as kfuncs. - Add cgroup.memory=nobpf kernel parameter option to disable BPF memory accounting for container environments. Netfilter: - Remove the CLUSTERIP target. It has been marked as obsolete for years, and we still have WARN splats wrt races of the out-of-band /proc interface installed by this target. - Add 'destroy' commands to nf_tables. They are identical to the existing 'delete' commands, but do not return an error if the referenced object (set, chain, rule...) did not exist. Driver API: - Improve cpumask_local_spread() locality to help NICs set the right IRQ affinity on AMD platforms. - Separate C22 and C45 MDIO bus transactions more clearly. - Introduce new DCB table to control DSCP rewrite on egress. - Support configuration of Physical Layer Collision Avoidance (PLCA) Reconciliation Sublayer (RS) (802.3cg-2019). Modern version of shared medium Ethernet. - Support for MAC Merge layer (IEEE 802.3-2018 clause 99). Allowing preemption of low priority frames by high priority frames. - Add support for controlling MACSec offload using netlink SET. - Rework devlink instance refcounts to allow registration and de-registration under the instance lock. Split the code into multiple files, drop some of the unnecessarily granular locks and factor out common parts of netlink operation handling. - Add TX frame aggregation parameters (for USB drivers). - Add a new attr TCA_EXT_WARN_MSG to report TC (offload) warning messages with notifications for debug. - Allow offloading of UDP NEW connections via act_ct. - Add support for per action HW stats in TC. - Support hardware miss to TC action (continue processing in SW from a specific point in the action chain). - Warn if old Wireless Extension user space interface is used with modern cfg80211/mac80211 drivers. Do not support Wireless Extensions for Wi-Fi 7 devices at all. Everyone should switch to using nl80211 interface instead. - Improve the CAN bit timing configuration. Use extack to return error messages directly to user space, update the SJW handling, including the definition of a new default value that will benefit CAN-FD controllers, by increasing their oscillator tolerance. New hardware / drivers: - Ethernet: - nVidia BlueField-3 support (control traffic driver) - Ethernet support for imx93 SoCs - Motorcomm yt8531 gigabit Ethernet PHY - onsemi NCN26000 10BASE-T1S PHY (with support for PLCA) - Microchip LAN8841 PHY (incl. cable diagnostics and PTP) - Amlogic gxl MDIO mux - WiFi: - RealTek RTL8188EU (rtl8xxxu) - Qualcomm Wi-Fi 7 devices (ath12k) - CAN: - Renesas R-Car V4H Drivers: - Bluetooth: - Set Per Platform Antenna Gain (PPAG) for Intel controllers. - Ethernet NICs: - Intel (1G, igc): - support TSN / Qbv / packet scheduling features of i226 model - Intel (100G, ice): - use GNSS subsystem instead of TTY - multi-buffer XDP support - extend support for GPIO pins to E823 devices - nVidia/Mellanox: - update the shared buffer configuration on PFC commands - implement PTP adjphase function for HW offset control - TC support for Geneve and GRE with VF tunnel offload - more efficient crypto key management method - multi-port eswitch support - Netronome/Corigine: - add DCB IEEE support - support IPsec offloading for NFP3800 - Freescale/NXP (enetc): - support XDP_REDIRECT for XDP non-linear buffers - improve reconfig, avoid link flap and waiting for idle - support MAC Merge layer - Other NICs: - sfc/ef100: add basic devlink support for ef100 - ionic: rx_push mode operation (writing descriptors via MMIO) - bnxt: use the auxiliary bus abstraction for RDMA - r8169: disable ASPM and reset bus in case of tx timeout - cpsw: support QSGMII mode for J721e CPSW9G - cpts: support pulse-per-second output - ngbe: add an mdio bus driver - usbnet: optimize usbnet_bh() by avoiding unnecessary queuing - r8152: handle devices with FW with NCM support - amd-xgbe: support 10Mbps, 2.5GbE speeds and rx-adaptation - virtio-net: support multi buffer XDP - virtio/vsock: replace virtio_vsock_pkt with sk_buff - tsnep: XDP support - Ethernet high-speed switches: - nVidia/Mellanox (mlxsw): - add support for latency TLV (in FW control messages) - Microchip (sparx5): - separate explicit and implicit traffic forwarding rules, make the implicit rules always active - add support for egress DSCP rewrite - IS0 VCAP support (Ingress Classification) - IS2 VCAP filters (protos, L3 addrs, L4 ports, flags, ToS etc.) - ES2 VCAP support (Egress Access Control) - support for Per-Stream Filtering and Policing (802.1Q, 8.6.5.1) - Ethernet embedded switches: - Marvell (mv88e6xxx): - add MAB (port auth) offload support - enable PTP receive for mv88e6390 - NXP (ocelot): - support MAC Merge layer - support for the the vsc7512 internal copper phys - Microchip: - lan9303: convert to PHYLINK - lan966x: support TC flower filter statistics - lan937x: PTP support for KSZ9563/KSZ8563 and LAN937x - lan937x: support Credit Based Shaper configuration - ksz9477: support Energy Efficient Ethernet - other: - qca8k: convert to regmap read/write API, use bulk operations - rswitch: Improve TX timestamp accuracy - Intel WiFi (iwlwifi): - EHT (Wi-Fi 7) rate reporting - STEP equalizer support: transfer some STEP (connection to radio on platforms with integrated wifi) related parameters from the BIOS to the firmware. - Qualcomm 802.11ax WiFi (ath11k): - IPQ5018 support - Fine Timing Measurement (FTM) responder role support - channel 177 support - MediaTek WiFi (mt76): - per-PHY LED support - mt7996: EHT (Wi-Fi 7) support - Wireless Ethernet Dispatch (WED) reset support - switch to using page pool allocator - RealTek WiFi (rtw89): - support new version of Bluetooth co-existance - Mobile: - rmnet: support TX aggregation" * tag 'net-next-6.3' of git://git.kernel.org/pub/scm/linux/kernel/git/netdev/net-next: (1872 commits) page_pool: add a comment explaining the fragment counter usage net: ethtool: fix __ethtool_dev_mm_supported() implementation ethtool: pse-pd: Fix double word in comments xsk: add linux/vmalloc.h to xsk.c sefltests: netdevsim: wait for devlink instance after netns removal selftest: fib_tests: Always cleanup before exit net/mlx5e: Align IPsec ASO result memory to be as required by hardware net/mlx5e: TC, Set CT miss to the specific ct action instance net/mlx5e: Rename CHAIN_TO_REG to MAPPED_OBJ_TO_REG net/mlx5: Refactor tc miss handling to a single function net/mlx5: Kconfig: Make tc offload depend on tc skb extension net/sched: flower: Support hardware miss to tc action net/sched: flower: Move filter handle initialization earlier net/sched: cls_api: Support hardware miss to tc action net/sched: Rename user cookie and act cookie sfc: fix builds without CONFIG_RTC_LIB sfc: clean up some inconsistent indentings net/mlx4_en: Introduce flexible array to silence overflow warning net: lan966x: Fix possible deadlock inside PTP net/ulp: Remove redundant ->clone() test in inet_clone_ulp(). ... --- fs/reiserfs/item_ops.c | 744 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 744 insertions(+) create mode 100644 fs/reiserfs/item_ops.c (limited to 'fs/reiserfs/item_ops.c') diff --git a/fs/reiserfs/item_ops.c b/fs/reiserfs/item_ops.c new file mode 100644 index 000000000..3a5a752d9 --- /dev/null +++ b/fs/reiserfs/item_ops.c @@ -0,0 +1,744 @@ +/* + * Copyright 2000 by Hans Reiser, licensing governed by reiserfs/README + */ + +#include +#include "reiserfs.h" + +/* + * this contains item handlers for old item types: sd, direct, + * indirect, directory + */ + +/* + * and where are the comments? how about saying where we can find an + * explanation of each item handler method? -Hans + */ + +/* stat data functions */ +static int sd_bytes_number(struct item_head *ih, int block_size) +{ + return 0; +} + +static void sd_decrement_key(struct cpu_key *key) +{ + key->on_disk_key.k_objectid--; + set_cpu_key_k_type(key, TYPE_ANY); + set_cpu_key_k_offset(key, (loff_t)(~0ULL >> 1)); +} + +static int sd_is_left_mergeable(struct reiserfs_key *key, unsigned long bsize) +{ + return 0; +} + +static void sd_print_item(struct item_head *ih, char *item) +{ + printk("\tmode | size | nlinks | first direct | mtime\n"); + if (stat_data_v1(ih)) { + struct stat_data_v1 *sd = (struct stat_data_v1 *)item; + + printk("\t0%-6o | %6u | %2u | %d | %u\n", sd_v1_mode(sd), + sd_v1_size(sd), sd_v1_nlink(sd), + sd_v1_first_direct_byte(sd), + sd_v1_mtime(sd)); + } else { + struct stat_data *sd = (struct stat_data *)item; + + printk("\t0%-6o | %6llu | %2u | %d | %u\n", sd_v2_mode(sd), + (unsigned long long)sd_v2_size(sd), sd_v2_nlink(sd), + sd_v2_rdev(sd), sd_v2_mtime(sd)); + } +} + +static void sd_check_item(struct item_head *ih, char *item) +{ + /* unused */ +} + +static int sd_create_vi(struct virtual_node *vn, + struct virtual_item *vi, + int is_affected, int insert_size) +{ + vi->vi_index = TYPE_STAT_DATA; + return 0; +} + +static int sd_check_left(struct virtual_item *vi, int free, + int start_skip, int end_skip) +{ + BUG_ON(start_skip || end_skip); + return -1; +} + +static int sd_check_right(struct virtual_item *vi, int free) +{ + return -1; +} + +static int sd_part_size(struct virtual_item *vi, int first, int count) +{ + BUG_ON(count); + return 0; +} + +static int sd_unit_num(struct virtual_item *vi) +{ + return vi->vi_item_len - IH_SIZE; +} + +static void sd_print_vi(struct virtual_item *vi) +{ + reiserfs_warning(NULL, "reiserfs-16100", + "STATDATA, index %d, type 0x%x, %h", + vi->vi_index, vi->vi_type, vi->vi_ih); +} + +static struct item_operations stat_data_ops = { + .bytes_number = sd_bytes_number, + .decrement_key = sd_decrement_key, + .is_left_mergeable = sd_is_left_mergeable, + .print_item = sd_print_item, + .check_item = sd_check_item, + + .create_vi = sd_create_vi, + .check_left = sd_check_left, + .check_right = sd_check_right, + .part_size = sd_part_size, + .unit_num = sd_unit_num, + .print_vi = sd_print_vi +}; + +/* direct item functions */ +static int direct_bytes_number(struct item_head *ih, int block_size) +{ + return ih_item_len(ih); +} + +/* FIXME: this should probably switch to indirect as well */ +static void direct_decrement_key(struct cpu_key *key) +{ + cpu_key_k_offset_dec(key); + if (cpu_key_k_offset(key) == 0) + set_cpu_key_k_type(key, TYPE_STAT_DATA); +} + +static int direct_is_left_mergeable(struct reiserfs_key *key, + unsigned long bsize) +{ + int version = le_key_version(key); + return ((le_key_k_offset(version, key) & (bsize - 1)) != 1); +} + +static void direct_print_item(struct item_head *ih, char *item) +{ + int j = 0; + +/* return; */ + printk("\""); + while (j < ih_item_len(ih)) + printk("%c", item[j++]); + printk("\"\n"); +} + +static void direct_check_item(struct item_head *ih, char *item) +{ + /* unused */ +} + +static int direct_create_vi(struct virtual_node *vn, + struct virtual_item *vi, + int is_affected, int insert_size) +{ + vi->vi_index = TYPE_DIRECT; + return 0; +} + +static int direct_check_left(struct virtual_item *vi, int free, + int start_skip, int end_skip) +{ + int bytes; + + bytes = free - free % 8; + return bytes ? : -1; +} + +static int direct_check_right(struct virtual_item *vi, int free) +{ + return direct_check_left(vi, free, 0, 0); +} + +static int direct_part_size(struct virtual_item *vi, int first, int count) +{ + return count; +} + +static int direct_unit_num(struct virtual_item *vi) +{ + return vi->vi_item_len - IH_SIZE; +} + +static void direct_print_vi(struct virtual_item *vi) +{ + reiserfs_warning(NULL, "reiserfs-16101", + "DIRECT, index %d, type 0x%x, %h", + vi->vi_index, vi->vi_type, vi->vi_ih); +} + +static struct item_operations direct_ops = { + .bytes_number = direct_bytes_number, + .decrement_key = direct_decrement_key, + .is_left_mergeable = direct_is_left_mergeable, + .print_item = direct_print_item, + .check_item = direct_check_item, + + .create_vi = direct_create_vi, + .check_left = direct_check_left, + .check_right = direct_check_right, + .part_size = direct_part_size, + .unit_num = direct_unit_num, + .print_vi = direct_print_vi +}; + +/* indirect item functions */ +static int indirect_bytes_number(struct item_head *ih, int block_size) +{ + return ih_item_len(ih) / UNFM_P_SIZE * block_size; +} + +/* decrease offset, if it becomes 0, change type to stat data */ +static void indirect_decrement_key(struct cpu_key *key) +{ + cpu_key_k_offset_dec(key); + if (cpu_key_k_offset(key) == 0) + set_cpu_key_k_type(key, TYPE_STAT_DATA); +} + +/* if it is not first item of the body, then it is mergeable */ +static int indirect_is_left_mergeable(struct reiserfs_key *key, + unsigned long bsize) +{ + int version = le_key_version(key); + return (le_key_k_offset(version, key) != 1); +} + +/* printing of indirect item */ +static void start_new_sequence(__u32 * start, int *len, __u32 new) +{ + *start = new; + *len = 1; +} + +static int sequence_finished(__u32 start, int *len, __u32 new) +{ + if (start == INT_MAX) + return 1; + + if (start == 0 && new == 0) { + (*len)++; + return 0; + } + if (start != 0 && (start + *len) == new) { + (*len)++; + return 0; + } + return 1; +} + +static void print_sequence(__u32 start, int len) +{ + if (start == INT_MAX) + return; + + if (len == 1) + printk(" %d", start); + else + printk(" %d(%d)", start, len); +} + +static void indirect_print_item(struct item_head *ih, char *item) +{ + int j; + __le32 *unp; + __u32 prev = INT_MAX; + int num = 0; + + unp = (__le32 *) item; + + if (ih_item_len(ih) % UNFM_P_SIZE) + reiserfs_warning(NULL, "reiserfs-16102", "invalid item len"); + + printk("%d pointers\n[ ", (int)I_UNFM_NUM(ih)); + for (j = 0; j < I_UNFM_NUM(ih); j++) { + if (sequence_finished(prev, &num, get_block_num(unp, j))) { + print_sequence(prev, num); + start_new_sequence(&prev, &num, get_block_num(unp, j)); + } + } + print_sequence(prev, num); + printk("]\n"); +} + +static void indirect_check_item(struct item_head *ih, char *item) +{ + /* unused */ +} + +static int indirect_create_vi(struct virtual_node *vn, + struct virtual_item *vi, + int is_affected, int insert_size) +{ + vi->vi_index = TYPE_INDIRECT; + return 0; +} + +static int indirect_check_left(struct virtual_item *vi, int free, + int start_skip, int end_skip) +{ + int bytes; + + bytes = free - free % UNFM_P_SIZE; + return bytes ? : -1; +} + +static int indirect_check_right(struct virtual_item *vi, int free) +{ + return indirect_check_left(vi, free, 0, 0); +} + +/* + * return size in bytes of 'units' units. If first == 0 - calculate + * from the head (left), otherwise - from tail (right) + */ +static int indirect_part_size(struct virtual_item *vi, int first, int units) +{ + /* unit of indirect item is byte (yet) */ + return units; +} + +static int indirect_unit_num(struct virtual_item *vi) +{ + /* unit of indirect item is byte (yet) */ + return vi->vi_item_len - IH_SIZE; +} + +static void indirect_print_vi(struct virtual_item *vi) +{ + reiserfs_warning(NULL, "reiserfs-16103", + "INDIRECT, index %d, type 0x%x, %h", + vi->vi_index, vi->vi_type, vi->vi_ih); +} + +static struct item_operations indirect_ops = { + .bytes_number = indirect_bytes_number, + .decrement_key = indirect_decrement_key, + .is_left_mergeable = indirect_is_left_mergeable, + .print_item = indirect_print_item, + .check_item = indirect_check_item, + + .create_vi = indirect_create_vi, + .check_left = indirect_check_left, + .check_right = indirect_check_right, + .part_size = indirect_part_size, + .unit_num = indirect_unit_num, + .print_vi = indirect_print_vi +}; + +/* direntry functions */ +static int direntry_bytes_number(struct item_head *ih, int block_size) +{ + reiserfs_warning(NULL, "vs-16090", + "bytes number is asked for direntry"); + return 0; +} + +static void direntry_decrement_key(struct cpu_key *key) +{ + cpu_key_k_offset_dec(key); + if (cpu_key_k_offset(key) == 0) + set_cpu_key_k_type(key, TYPE_STAT_DATA); +} + +static int direntry_is_left_mergeable(struct reiserfs_key *key, + unsigned long bsize) +{ + if (le32_to_cpu(key->u.k_offset_v1.k_offset) == DOT_OFFSET) + return 0; + return 1; + +} + +static void direntry_print_item(struct item_head *ih, char *item) +{ + int i; + int namelen; + struct reiserfs_de_head *deh; + char *name; + static char namebuf[80]; + + printk("\n # %-15s%-30s%-15s%-15s%-15s\n", "Name", + "Key of pointed object", "Hash", "Gen number", "Status"); + + deh = (struct reiserfs_de_head *)item; + + for (i = 0; i < ih_entry_count(ih); i++, deh++) { + namelen = + (i ? (deh_location(deh - 1)) : ih_item_len(ih)) - + deh_location(deh); + name = item + deh_location(deh); + if (name[namelen - 1] == 0) + namelen = strlen(name); + namebuf[0] = '"'; + if (namelen > sizeof(namebuf) - 3) { + strncpy(namebuf + 1, name, sizeof(namebuf) - 3); + namebuf[sizeof(namebuf) - 2] = '"'; + namebuf[sizeof(namebuf) - 1] = 0; + } else { + memcpy(namebuf + 1, name, namelen); + namebuf[namelen + 1] = '"'; + namebuf[namelen + 2] = 0; + } + + printk("%d: %-15s%-15d%-15d%-15lld%-15lld(%s)\n", + i, namebuf, + deh_dir_id(deh), deh_objectid(deh), + GET_HASH_VALUE(deh_offset(deh)), + GET_GENERATION_NUMBER((deh_offset(deh))), + (de_hidden(deh)) ? "HIDDEN" : "VISIBLE"); + } +} + +static void direntry_check_item(struct item_head *ih, char *item) +{ + int i; + struct reiserfs_de_head *deh; + + /* unused */ + deh = (struct reiserfs_de_head *)item; + for (i = 0; i < ih_entry_count(ih); i++, deh++) { + ; + } +} + +#define DIRENTRY_VI_FIRST_DIRENTRY_ITEM 1 + +/* + * function returns old entry number in directory item in real node + * using new entry number in virtual item in virtual node + */ +static inline int old_entry_num(int is_affected, int virtual_entry_num, + int pos_in_item, int mode) +{ + if (mode == M_INSERT || mode == M_DELETE) + return virtual_entry_num; + + if (!is_affected) + /* cut or paste is applied to another item */ + return virtual_entry_num; + + if (virtual_entry_num < pos_in_item) + return virtual_entry_num; + + if (mode == M_CUT) + return virtual_entry_num + 1; + + RFALSE(mode != M_PASTE || virtual_entry_num == 0, + "vs-8015: old_entry_num: mode must be M_PASTE (mode = \'%c\'", + mode); + + return virtual_entry_num - 1; +} + +/* + * Create an array of sizes of directory entries for virtual + * item. Return space used by an item. FIXME: no control over + * consuming of space used by this item handler + */ +static int direntry_create_vi(struct virtual_node *vn, + struct virtual_item *vi, + int is_affected, int insert_size) +{ + struct direntry_uarea *dir_u = vi->vi_uarea; + int i, j; + int size = sizeof(struct direntry_uarea); + struct reiserfs_de_head *deh; + + vi->vi_index = TYPE_DIRENTRY; + + BUG_ON(!(vi->vi_ih) || !vi->vi_item); + + dir_u->flags = 0; + if (le_ih_k_offset(vi->vi_ih) == DOT_OFFSET) + dir_u->flags |= DIRENTRY_VI_FIRST_DIRENTRY_ITEM; + + deh = (struct reiserfs_de_head *)(vi->vi_item); + + /* virtual directory item have this amount of entry after */ + dir_u->entry_count = ih_entry_count(vi->vi_ih) + + ((is_affected) ? ((vn->vn_mode == M_CUT) ? -1 : + (vn->vn_mode == M_PASTE ? 1 : 0)) : 0); + + for (i = 0; i < dir_u->entry_count; i++) { + j = old_entry_num(is_affected, i, vn->vn_pos_in_item, + vn->vn_mode); + dir_u->entry_sizes[i] = + (j ? deh_location(&deh[j - 1]) : ih_item_len(vi->vi_ih)) - + deh_location(&deh[j]) + DEH_SIZE; + } + + size += (dir_u->entry_count * sizeof(short)); + + /* set size of pasted entry */ + if (is_affected && vn->vn_mode == M_PASTE) + dir_u->entry_sizes[vn->vn_pos_in_item] = insert_size; + +#ifdef CONFIG_REISERFS_CHECK + /* compare total size of entries with item length */ + { + int k, l; + + l = 0; + for (k = 0; k < dir_u->entry_count; k++) + l += dir_u->entry_sizes[k]; + + if (l + IH_SIZE != vi->vi_item_len + + ((is_affected + && (vn->vn_mode == M_PASTE + || vn->vn_mode == M_CUT)) ? insert_size : 0)) { + reiserfs_panic(NULL, "vs-8025", "(mode==%c, " + "insert_size==%d), invalid length of " + "directory item", + vn->vn_mode, insert_size); + } + } +#endif + + return size; + +} + +/* + * return number of entries which may fit into specified amount of + * free space, or -1 if free space is not enough even for 1 entry + */ +static int direntry_check_left(struct virtual_item *vi, int free, + int start_skip, int end_skip) +{ + int i; + int entries = 0; + struct direntry_uarea *dir_u = vi->vi_uarea; + + for (i = start_skip; i < dir_u->entry_count - end_skip; i++) { + /* i-th entry doesn't fit into the remaining free space */ + if (dir_u->entry_sizes[i] > free) + break; + + free -= dir_u->entry_sizes[i]; + entries++; + } + + if (entries == dir_u->entry_count) { + reiserfs_panic(NULL, "item_ops-1", + "free space %d, entry_count %d", free, + dir_u->entry_count); + } + + /* "." and ".." can not be separated from each other */ + if (start_skip == 0 && (dir_u->flags & DIRENTRY_VI_FIRST_DIRENTRY_ITEM) + && entries < 2) + entries = 0; + + return entries ? : -1; +} + +static int direntry_check_right(struct virtual_item *vi, int free) +{ + int i; + int entries = 0; + struct direntry_uarea *dir_u = vi->vi_uarea; + + for (i = dir_u->entry_count - 1; i >= 0; i--) { + /* i-th entry doesn't fit into the remaining free space */ + if (dir_u->entry_sizes[i] > free) + break; + + free -= dir_u->entry_sizes[i]; + entries++; + } + BUG_ON(entries == dir_u->entry_count); + + /* "." and ".." can not be separated from each other */ + if ((dir_u->flags & DIRENTRY_VI_FIRST_DIRENTRY_ITEM) + && entries > dir_u->entry_count - 2) + entries = dir_u->entry_count - 2; + + return entries ? : -1; +} + +/* sum of entry sizes between from-th and to-th entries including both edges */ +static int direntry_part_size(struct virtual_item *vi, int first, int count) +{ + int i, retval; + int from, to; + struct direntry_uarea *dir_u = vi->vi_uarea; + + retval = 0; + if (first == 0) + from = 0; + else + from = dir_u->entry_count - count; + to = from + count - 1; + + for (i = from; i <= to; i++) + retval += dir_u->entry_sizes[i]; + + return retval; +} + +static int direntry_unit_num(struct virtual_item *vi) +{ + struct direntry_uarea *dir_u = vi->vi_uarea; + + return dir_u->entry_count; +} + +static void direntry_print_vi(struct virtual_item *vi) +{ + int i; + struct direntry_uarea *dir_u = vi->vi_uarea; + + reiserfs_warning(NULL, "reiserfs-16104", + "DIRENTRY, index %d, type 0x%x, %h, flags 0x%x", + vi->vi_index, vi->vi_type, vi->vi_ih, dir_u->flags); + printk("%d entries: ", dir_u->entry_count); + for (i = 0; i < dir_u->entry_count; i++) + printk("%d ", dir_u->entry_sizes[i]); + printk("\n"); +} + +static struct item_operations direntry_ops = { + .bytes_number = direntry_bytes_number, + .decrement_key = direntry_decrement_key, + .is_left_mergeable = direntry_is_left_mergeable, + .print_item = direntry_print_item, + .check_item = direntry_check_item, + + .create_vi = direntry_create_vi, + .check_left = direntry_check_left, + .check_right = direntry_check_right, + .part_size = direntry_part_size, + .unit_num = direntry_unit_num, + .print_vi = direntry_print_vi +}; + +/* Error catching functions to catch errors caused by incorrect item types. */ +static int errcatch_bytes_number(struct item_head *ih, int block_size) +{ + reiserfs_warning(NULL, "green-16001", + "Invalid item type observed, run fsck ASAP"); + return 0; +} + +static void errcatch_decrement_key(struct cpu_key *key) +{ + reiserfs_warning(NULL, "green-16002", + "Invalid item type observed, run fsck ASAP"); +} + +static int errcatch_is_left_mergeable(struct reiserfs_key *key, + unsigned long bsize) +{ + reiserfs_warning(NULL, "green-16003", + "Invalid item type observed, run fsck ASAP"); + return 0; +} + +static void errcatch_print_item(struct item_head *ih, char *item) +{ + reiserfs_warning(NULL, "green-16004", + "Invalid item type observed, run fsck ASAP"); +} + +static void errcatch_check_item(struct item_head *ih, char *item) +{ + reiserfs_warning(NULL, "green-16005", + "Invalid item type observed, run fsck ASAP"); +} + +static int errcatch_create_vi(struct virtual_node *vn, + struct virtual_item *vi, + int is_affected, int insert_size) +{ + reiserfs_warning(NULL, "green-16006", + "Invalid item type observed, run fsck ASAP"); + /* + * We might return -1 here as well, but it won't help as + * create_virtual_node() from where this operation is called + * from is of return type void. + */ + return 0; +} + +static int errcatch_check_left(struct virtual_item *vi, int free, + int start_skip, int end_skip) +{ + reiserfs_warning(NULL, "green-16007", + "Invalid item type observed, run fsck ASAP"); + return -1; +} + +static int errcatch_check_right(struct virtual_item *vi, int free) +{ + reiserfs_warning(NULL, "green-16008", + "Invalid item type observed, run fsck ASAP"); + return -1; +} + +static int errcatch_part_size(struct virtual_item *vi, int first, int count) +{ + reiserfs_warning(NULL, "green-16009", + "Invalid item type observed, run fsck ASAP"); + return 0; +} + +static int errcatch_unit_num(struct virtual_item *vi) +{ + reiserfs_warning(NULL, "green-16010", + "Invalid item type observed, run fsck ASAP"); + return 0; +} + +static void errcatch_print_vi(struct virtual_item *vi) +{ + reiserfs_warning(NULL, "green-16011", + "Invalid item type observed, run fsck ASAP"); +} + +static struct item_operations errcatch_ops = { + .bytes_number = errcatch_bytes_number, + .decrement_key = errcatch_decrement_key, + .is_left_mergeable = errcatch_is_left_mergeable, + .print_item = errcatch_print_item, + .check_item = errcatch_check_item, + + .create_vi = errcatch_create_vi, + .check_left = errcatch_check_left, + .check_right = errcatch_check_right, + .part_size = errcatch_part_size, + .unit_num = errcatch_unit_num, + .print_vi = errcatch_print_vi +}; + +#if ! (TYPE_STAT_DATA == 0 && TYPE_INDIRECT == 1 && TYPE_DIRECT == 2 && TYPE_DIRENTRY == 3) +#error Item types must use disk-format assigned values. +#endif + +struct item_operations *item_ops[TYPE_ANY + 1] = { + &stat_data_ops, + &indirect_ops, + &direct_ops, + &direntry_ops, + NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, + &errcatch_ops /* This is to catch errors with invalid type (15th entry for TYPE_ANY) */ +}; -- cgit v1.2.3