3420 lines · c
1/* SPDX-License-Identifier: GPL-2.0 */2/*3 * Copyright 1996, 1997, 1998 Hans Reiser, see reiserfs/README for4 * licensing and copyright details5 */6 7#include <linux/reiserfs_fs.h>8 9#include <linux/slab.h>10#include <linux/interrupt.h>11#include <linux/sched.h>12#include <linux/bug.h>13#include <linux/workqueue.h>14#include <linux/unaligned.h>15#include <linux/bitops.h>16#include <linux/proc_fs.h>17#include <linux/buffer_head.h>18 19/* the 32 bit compat definitions with int argument */20#define REISERFS_IOC32_UNPACK _IOW(0xCD, 1, int)21#define REISERFS_IOC32_GETVERSION FS_IOC32_GETVERSION22#define REISERFS_IOC32_SETVERSION FS_IOC32_SETVERSION23 24struct reiserfs_journal_list;25 26/* bitmasks for i_flags field in reiserfs-specific part of inode */27typedef enum {28 /*29 * this says what format of key do all items (but stat data) of30 * an object have. If this is set, that format is 3.6 otherwise - 3.531 */32 i_item_key_version_mask = 0x0001,33 34 /*35 * If this is unset, object has 3.5 stat data, otherwise,36 * it has 3.6 stat data with 64bit size, 32bit nlink etc.37 */38 i_stat_data_version_mask = 0x0002,39 40 /* file might need tail packing on close */41 i_pack_on_close_mask = 0x0004,42 43 /* don't pack tail of file */44 i_nopack_mask = 0x0008,45 46 /*47 * If either of these are set, "safe link" was created for this48 * file during truncate or unlink. Safe link is used to avoid49 * leakage of disk space on crash with some files open, but unlinked.50 */51 i_link_saved_unlink_mask = 0x0010,52 i_link_saved_truncate_mask = 0x0020,53 54 i_has_xattr_dir = 0x0040,55 i_data_log = 0x0080,56} reiserfs_inode_flags;57 58struct reiserfs_inode_info {59 __u32 i_key[4]; /* key is still 4 32 bit integers */60 61 /*62 * transient inode flags that are never stored on disk. Bitmasks63 * for this field are defined above.64 */65 __u32 i_flags;66 67 /* offset of first byte stored in direct item. */68 __u32 i_first_direct_byte;69 70 /* copy of persistent inode flags read from sd_attrs. */71 __u32 i_attrs;72 73 /* first unused block of a sequence of unused blocks */74 int i_prealloc_block;75 int i_prealloc_count; /* length of that sequence */76 77 /* per-transaction list of inodes which have preallocated blocks */78 struct list_head i_prealloc_list;79 80 /*81 * new_packing_locality is created; new blocks for the contents82 * of this directory should be displaced83 */84 unsigned new_packing_locality:1;85 86 /*87 * we use these for fsync or O_SYNC to decide which transaction88 * needs to be committed in order for this inode to be properly89 * flushed90 */91 unsigned int i_trans_id;92 93 struct reiserfs_journal_list *i_jl;94 atomic_t openers;95 struct mutex tailpack;96#ifdef CONFIG_REISERFS_FS_XATTR97 struct rw_semaphore i_xattr_sem;98#endif99#ifdef CONFIG_QUOTA100 struct dquot __rcu *i_dquot[MAXQUOTAS];101#endif102 103 struct inode vfs_inode;104};105 106typedef enum {107 reiserfs_attrs_cleared = 0x00000001,108} reiserfs_super_block_flags;109 110/*111 * struct reiserfs_super_block accessors/mutators since this is a disk112 * structure, it will always be in little endian format.113 */114#define sb_block_count(sbp) (le32_to_cpu((sbp)->s_v1.s_block_count))115#define set_sb_block_count(sbp,v) ((sbp)->s_v1.s_block_count = cpu_to_le32(v))116#define sb_free_blocks(sbp) (le32_to_cpu((sbp)->s_v1.s_free_blocks))117#define set_sb_free_blocks(sbp,v) ((sbp)->s_v1.s_free_blocks = cpu_to_le32(v))118#define sb_root_block(sbp) (le32_to_cpu((sbp)->s_v1.s_root_block))119#define set_sb_root_block(sbp,v) ((sbp)->s_v1.s_root_block = cpu_to_le32(v))120 121#define sb_jp_journal_1st_block(sbp) \122 (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_1st_block))123#define set_sb_jp_journal_1st_block(sbp,v) \124 ((sbp)->s_v1.s_journal.jp_journal_1st_block = cpu_to_le32(v))125#define sb_jp_journal_dev(sbp) \126 (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_dev))127#define set_sb_jp_journal_dev(sbp,v) \128 ((sbp)->s_v1.s_journal.jp_journal_dev = cpu_to_le32(v))129#define sb_jp_journal_size(sbp) \130 (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_size))131#define set_sb_jp_journal_size(sbp,v) \132 ((sbp)->s_v1.s_journal.jp_journal_size = cpu_to_le32(v))133#define sb_jp_journal_trans_max(sbp) \134 (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_trans_max))135#define set_sb_jp_journal_trans_max(sbp,v) \136 ((sbp)->s_v1.s_journal.jp_journal_trans_max = cpu_to_le32(v))137#define sb_jp_journal_magic(sbp) \138 (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_magic))139#define set_sb_jp_journal_magic(sbp,v) \140 ((sbp)->s_v1.s_journal.jp_journal_magic = cpu_to_le32(v))141#define sb_jp_journal_max_batch(sbp) \142 (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_max_batch))143#define set_sb_jp_journal_max_batch(sbp,v) \144 ((sbp)->s_v1.s_journal.jp_journal_max_batch = cpu_to_le32(v))145#define sb_jp_jourmal_max_commit_age(sbp) \146 (le32_to_cpu((sbp)->s_v1.s_journal.jp_journal_max_commit_age))147#define set_sb_jp_journal_max_commit_age(sbp,v) \148 ((sbp)->s_v1.s_journal.jp_journal_max_commit_age = cpu_to_le32(v))149 150#define sb_blocksize(sbp) (le16_to_cpu((sbp)->s_v1.s_blocksize))151#define set_sb_blocksize(sbp,v) ((sbp)->s_v1.s_blocksize = cpu_to_le16(v))152#define sb_oid_maxsize(sbp) (le16_to_cpu((sbp)->s_v1.s_oid_maxsize))153#define set_sb_oid_maxsize(sbp,v) ((sbp)->s_v1.s_oid_maxsize = cpu_to_le16(v))154#define sb_oid_cursize(sbp) (le16_to_cpu((sbp)->s_v1.s_oid_cursize))155#define set_sb_oid_cursize(sbp,v) ((sbp)->s_v1.s_oid_cursize = cpu_to_le16(v))156#define sb_umount_state(sbp) (le16_to_cpu((sbp)->s_v1.s_umount_state))157#define set_sb_umount_state(sbp,v) ((sbp)->s_v1.s_umount_state = cpu_to_le16(v))158#define sb_fs_state(sbp) (le16_to_cpu((sbp)->s_v1.s_fs_state))159#define set_sb_fs_state(sbp,v) ((sbp)->s_v1.s_fs_state = cpu_to_le16(v))160#define sb_hash_function_code(sbp) \161 (le32_to_cpu((sbp)->s_v1.s_hash_function_code))162#define set_sb_hash_function_code(sbp,v) \163 ((sbp)->s_v1.s_hash_function_code = cpu_to_le32(v))164#define sb_tree_height(sbp) (le16_to_cpu((sbp)->s_v1.s_tree_height))165#define set_sb_tree_height(sbp,v) ((sbp)->s_v1.s_tree_height = cpu_to_le16(v))166#define sb_bmap_nr(sbp) (le16_to_cpu((sbp)->s_v1.s_bmap_nr))167#define set_sb_bmap_nr(sbp,v) ((sbp)->s_v1.s_bmap_nr = cpu_to_le16(v))168#define sb_version(sbp) (le16_to_cpu((sbp)->s_v1.s_version))169#define set_sb_version(sbp,v) ((sbp)->s_v1.s_version = cpu_to_le16(v))170 171#define sb_mnt_count(sbp) (le16_to_cpu((sbp)->s_mnt_count))172#define set_sb_mnt_count(sbp, v) ((sbp)->s_mnt_count = cpu_to_le16(v))173 174#define sb_reserved_for_journal(sbp) \175 (le16_to_cpu((sbp)->s_v1.s_reserved_for_journal))176#define set_sb_reserved_for_journal(sbp,v) \177 ((sbp)->s_v1.s_reserved_for_journal = cpu_to_le16(v))178 179/* LOGGING -- */180 181/*182 * These all interelate for performance.183 *184 * If the journal block count is smaller than n transactions, you lose speed.185 * I don't know what n is yet, I'm guessing 8-16.186 *187 * typical transaction size depends on the application, how often fsync is188 * called, and how many metadata blocks you dirty in a 30 second period.189 * The more small files (<16k) you use, the larger your transactions will190 * be.191 *192 * If your journal fills faster than dirty buffers get flushed to disk, it193 * must flush them before allowing the journal to wrap, which slows things194 * down. If you need high speed meta data updates, the journal should be195 * big enough to prevent wrapping before dirty meta blocks get to disk.196 *197 * If the batch max is smaller than the transaction max, you'll waste space198 * at the end of the journal because journal_end sets the next transaction199 * to start at 0 if the next transaction has any chance of wrapping.200 *201 * The large the batch max age, the better the speed, and the more meta202 * data changes you'll lose after a crash.203 */204 205/* don't mess with these for a while */206/* we have a node size define somewhere in reiserfs_fs.h. -Hans */207#define JOURNAL_BLOCK_SIZE 4096 /* BUG gotta get rid of this */208#define JOURNAL_MAX_CNODE 1500 /* max cnodes to allocate. */209#define JOURNAL_HASH_SIZE 8192210 211/* number of copies of the bitmaps to have floating. Must be >= 2 */212#define JOURNAL_NUM_BITMAPS 5213 214/*215 * One of these for every block in every transaction216 * Each one is in two hash tables. First, a hash of the current transaction,217 * and after journal_end, a hash of all the in memory transactions.218 * next and prev are used by the current transaction (journal_hash).219 * hnext and hprev are used by journal_list_hash. If a block is in more220 * than one transaction, the journal_list_hash links it in multiple times.221 * This allows flush_journal_list to remove just the cnode belonging to a222 * given transaction.223 */224struct reiserfs_journal_cnode {225 struct buffer_head *bh; /* real buffer head */226 struct super_block *sb; /* dev of real buffer head */227 228 /* block number of real buffer head, == 0 when buffer on disk */229 __u32 blocknr;230 231 unsigned long state;232 233 /* journal list this cnode lives in */234 struct reiserfs_journal_list *jlist;235 236 struct reiserfs_journal_cnode *next; /* next in transaction list */237 struct reiserfs_journal_cnode *prev; /* prev in transaction list */238 struct reiserfs_journal_cnode *hprev; /* prev in hash list */239 struct reiserfs_journal_cnode *hnext; /* next in hash list */240};241 242struct reiserfs_bitmap_node {243 int id;244 char *data;245 struct list_head list;246};247 248struct reiserfs_list_bitmap {249 struct reiserfs_journal_list *journal_list;250 struct reiserfs_bitmap_node **bitmaps;251};252 253/*254 * one of these for each transaction. The most important part here is the255 * j_realblock. this list of cnodes is used to hash all the blocks in all256 * the commits, to mark all the real buffer heads dirty once all the commits257 * hit the disk, and to make sure every real block in a transaction is on258 * disk before allowing the log area to be overwritten259 */260struct reiserfs_journal_list {261 unsigned long j_start;262 unsigned long j_state;263 unsigned long j_len;264 atomic_t j_nonzerolen;265 atomic_t j_commit_left;266 267 /* all commits older than this on disk */268 atomic_t j_older_commits_done;269 270 struct mutex j_commit_mutex;271 unsigned int j_trans_id;272 time64_t j_timestamp; /* write-only but useful for crash dump analysis */273 struct reiserfs_list_bitmap *j_list_bitmap;274 struct buffer_head *j_commit_bh; /* commit buffer head */275 struct reiserfs_journal_cnode *j_realblock;276 struct reiserfs_journal_cnode *j_freedlist; /* list of buffers that were freed during this trans. free each of these on flush */277 /* time ordered list of all active transactions */278 struct list_head j_list;279 280 /*281 * time ordered list of all transactions we haven't tried282 * to flush yet283 */284 struct list_head j_working_list;285 286 /* list of tail conversion targets in need of flush before commit */287 struct list_head j_tail_bh_list;288 289 /* list of data=ordered buffers in need of flush before commit */290 struct list_head j_bh_list;291 int j_refcount;292};293 294struct reiserfs_journal {295 struct buffer_head **j_ap_blocks; /* journal blocks on disk */296 /* newest journal block */297 struct reiserfs_journal_cnode *j_last;298 299 /* oldest journal block. start here for traverse */300 struct reiserfs_journal_cnode *j_first;301 302 struct file *j_bdev_file;303 304 /* first block on s_dev of reserved area journal */305 int j_1st_reserved_block;306 307 unsigned long j_state;308 unsigned int j_trans_id;309 unsigned long j_mount_id;310 311 /* start of current waiting commit (index into j_ap_blocks) */312 unsigned long j_start;313 unsigned long j_len; /* length of current waiting commit */314 315 /* number of buffers requested by journal_begin() */316 unsigned long j_len_alloc;317 318 atomic_t j_wcount; /* count of writers for current commit */319 320 /* batch count. allows turning X transactions into 1 */321 unsigned long j_bcount;322 323 /* first unflushed transactions offset */324 unsigned long j_first_unflushed_offset;325 326 /* last fully flushed journal timestamp */327 unsigned j_last_flush_trans_id;328 329 struct buffer_head *j_header_bh;330 331 time64_t j_trans_start_time; /* time this transaction started */332 struct mutex j_mutex;333 struct mutex j_flush_mutex;334 335 /* wait for current transaction to finish before starting new one */336 wait_queue_head_t j_join_wait;337 338 atomic_t j_jlock; /* lock for j_join_wait */339 int j_list_bitmap_index; /* number of next list bitmap to use */340 341 /* no more journal begins allowed. MUST sleep on j_join_wait */342 int j_must_wait;343 344 /* next journal_end will flush all journal list */345 int j_next_full_flush;346 347 /* next journal_end will flush all async commits */348 int j_next_async_flush;349 350 int j_cnode_used; /* number of cnodes on the used list */351 int j_cnode_free; /* number of cnodes on the free list */352 353 /* max number of blocks in a transaction. */354 unsigned int j_trans_max;355 356 /* max number of blocks to batch into a trans */357 unsigned int j_max_batch;358 359 /* in seconds, how old can an async commit be */360 unsigned int j_max_commit_age;361 362 /* in seconds, how old can a transaction be */363 unsigned int j_max_trans_age;364 365 /* the default for the max commit age */366 unsigned int j_default_max_commit_age;367 368 struct reiserfs_journal_cnode *j_cnode_free_list;369 370 /* orig pointer returned from vmalloc */371 struct reiserfs_journal_cnode *j_cnode_free_orig;372 373 struct reiserfs_journal_list *j_current_jl;374 int j_free_bitmap_nodes;375 int j_used_bitmap_nodes;376 377 int j_num_lists; /* total number of active transactions */378 int j_num_work_lists; /* number that need attention from kreiserfsd */379 380 /* debugging to make sure things are flushed in order */381 unsigned int j_last_flush_id;382 383 /* debugging to make sure things are committed in order */384 unsigned int j_last_commit_id;385 386 struct list_head j_bitmap_nodes;387 struct list_head j_dirty_buffers;388 spinlock_t j_dirty_buffers_lock; /* protects j_dirty_buffers */389 390 /* list of all active transactions */391 struct list_head j_journal_list;392 393 /* lists that haven't been touched by writeback attempts */394 struct list_head j_working_list;395 396 /* hash table for real buffer heads in current trans */397 struct reiserfs_journal_cnode *j_hash_table[JOURNAL_HASH_SIZE];398 399 /* hash table for all the real buffer heads in all the transactions */400 struct reiserfs_journal_cnode *j_list_hash_table[JOURNAL_HASH_SIZE];401 402 /* array of bitmaps to record the deleted blocks */403 struct reiserfs_list_bitmap j_list_bitmap[JOURNAL_NUM_BITMAPS];404 405 /* list of inodes which have preallocated blocks */406 struct list_head j_prealloc_list;407 int j_persistent_trans;408 unsigned long j_max_trans_size;409 unsigned long j_max_batch_size;410 411 int j_errno;412 413 /* when flushing ordered buffers, throttle new ordered writers */414 struct delayed_work j_work;415 struct super_block *j_work_sb;416 atomic_t j_async_throttle;417};418 419enum journal_state_bits {420 J_WRITERS_BLOCKED = 1, /* set when new writers not allowed */421 J_WRITERS_QUEUED, /* set when log is full due to too many writers */422 J_ABORTED, /* set when log is aborted */423};424 425/* ick. magic string to find desc blocks in the journal */426#define JOURNAL_DESC_MAGIC "ReIsErLB"427 428typedef __u32(*hashf_t) (const signed char *, int);429 430struct reiserfs_bitmap_info {431 __u32 free_count;432};433 434struct proc_dir_entry;435 436#if defined( CONFIG_PROC_FS ) && defined( CONFIG_REISERFS_PROC_INFO )437typedef unsigned long int stat_cnt_t;438typedef struct reiserfs_proc_info_data {439 spinlock_t lock;440 int exiting;441 int max_hash_collisions;442 443 stat_cnt_t breads;444 stat_cnt_t bread_miss;445 stat_cnt_t search_by_key;446 stat_cnt_t search_by_key_fs_changed;447 stat_cnt_t search_by_key_restarted;448 449 stat_cnt_t insert_item_restarted;450 stat_cnt_t paste_into_item_restarted;451 stat_cnt_t cut_from_item_restarted;452 stat_cnt_t delete_solid_item_restarted;453 stat_cnt_t delete_item_restarted;454 455 stat_cnt_t leaked_oid;456 stat_cnt_t leaves_removable;457 458 /*459 * balances per level.460 * Use explicit 5 as MAX_HEIGHT is not visible yet.461 */462 stat_cnt_t balance_at[5]; /* XXX */463 /* sbk == search_by_key */464 stat_cnt_t sbk_read_at[5]; /* XXX */465 stat_cnt_t sbk_fs_changed[5];466 stat_cnt_t sbk_restarted[5];467 stat_cnt_t items_at[5]; /* XXX */468 stat_cnt_t free_at[5]; /* XXX */469 stat_cnt_t can_node_be_removed[5]; /* XXX */470 long int lnum[5]; /* XXX */471 long int rnum[5]; /* XXX */472 long int lbytes[5]; /* XXX */473 long int rbytes[5]; /* XXX */474 stat_cnt_t get_neighbors[5];475 stat_cnt_t get_neighbors_restart[5];476 stat_cnt_t need_l_neighbor[5];477 stat_cnt_t need_r_neighbor[5];478 479 stat_cnt_t free_block;480 struct __scan_bitmap_stats {481 stat_cnt_t call;482 stat_cnt_t wait;483 stat_cnt_t bmap;484 stat_cnt_t retry;485 stat_cnt_t in_journal_hint;486 stat_cnt_t in_journal_nohint;487 stat_cnt_t stolen;488 } scan_bitmap;489 struct __journal_stats {490 stat_cnt_t in_journal;491 stat_cnt_t in_journal_bitmap;492 stat_cnt_t in_journal_reusable;493 stat_cnt_t lock_journal;494 stat_cnt_t lock_journal_wait;495 stat_cnt_t journal_being;496 stat_cnt_t journal_relock_writers;497 stat_cnt_t journal_relock_wcount;498 stat_cnt_t mark_dirty;499 stat_cnt_t mark_dirty_already;500 stat_cnt_t mark_dirty_notjournal;501 stat_cnt_t restore_prepared;502 stat_cnt_t prepare;503 stat_cnt_t prepare_retry;504 } journal;505} reiserfs_proc_info_data_t;506#else507typedef struct reiserfs_proc_info_data {508} reiserfs_proc_info_data_t;509#endif510 511/* Number of quota types we support */512#define REISERFS_MAXQUOTAS 2513 514/* reiserfs union of in-core super block data */515struct reiserfs_sb_info {516 /* Buffer containing the super block */517 struct buffer_head *s_sbh;518 519 /* Pointer to the on-disk super block in the buffer */520 struct reiserfs_super_block *s_rs;521 struct reiserfs_bitmap_info *s_ap_bitmap;522 523 /* pointer to journal information */524 struct reiserfs_journal *s_journal;525 526 unsigned short s_mount_state; /* reiserfs state (valid, invalid) */527 528 /* Serialize writers access, replace the old bkl */529 struct mutex lock;530 531 /* Owner of the lock (can be recursive) */532 struct task_struct *lock_owner;533 534 /* Depth of the lock, start from -1 like the bkl */535 int lock_depth;536 537 struct workqueue_struct *commit_wq;538 539 /* Comment? -Hans */540 void (*end_io_handler) (struct buffer_head *, int);541 542 /*543 * pointer to function which is used to sort names in directory.544 * Set on mount545 */546 hashf_t s_hash_function;547 548 /* reiserfs's mount options are set here */549 unsigned long s_mount_opt;550 551 /* This is a structure that describes block allocator options */552 struct {553 /* Bitfield for enable/disable kind of options */554 unsigned long bits;555 556 /*557 * size started from which we consider file558 * to be a large one (in blocks)559 */560 unsigned long large_file_size;561 562 int border; /* percentage of disk, border takes */563 564 /*565 * Minimal file size (in blocks) starting566 * from which we do preallocations567 */568 int preallocmin;569 570 /*571 * Number of blocks we try to prealloc when file572 * reaches preallocmin size (in blocks) or prealloc_list573 is empty.574 */575 int preallocsize;576 } s_alloc_options;577 578 /* Comment? -Hans */579 wait_queue_head_t s_wait;580 /* increased by one every time the tree gets re-balanced */581 atomic_t s_generation_counter;582 583 /* File system properties. Currently holds on-disk FS format */584 unsigned long s_properties;585 586 /* session statistics */587 int s_disk_reads;588 int s_disk_writes;589 int s_fix_nodes;590 int s_do_balance;591 int s_unneeded_left_neighbor;592 int s_good_search_by_key_reada;593 int s_bmaps;594 int s_bmaps_without_search;595 int s_direct2indirect;596 int s_indirect2direct;597 598 /*599 * set up when it's ok for reiserfs_read_inode2() to read from600 * disk inode with nlink==0. Currently this is only used during601 * finish_unfinished() processing at mount time602 */603 int s_is_unlinked_ok;604 605 reiserfs_proc_info_data_t s_proc_info_data;606 struct proc_dir_entry *procdir;607 608 /* amount of blocks reserved for further allocations */609 int reserved_blocks;610 611 612 /* this lock on now only used to protect reserved_blocks variable */613 spinlock_t bitmap_lock;614 struct dentry *priv_root; /* root of /.reiserfs_priv */615 struct dentry *xattr_root; /* root of /.reiserfs_priv/xattrs */616 int j_errno;617 618 int work_queued; /* non-zero delayed work is queued */619 struct delayed_work old_work; /* old transactions flush delayed work */620 spinlock_t old_work_lock; /* protects old_work and work_queued */621 622#ifdef CONFIG_QUOTA623 char *s_qf_names[REISERFS_MAXQUOTAS];624 int s_jquota_fmt;625#endif626 char *s_jdev; /* Stored jdev for mount option showing */627#ifdef CONFIG_REISERFS_CHECK628 629 /*630 * Detects whether more than one copy of tb exists per superblock631 * as a means of checking whether do_balance is executing632 * concurrently against another tree reader/writer on a same633 * mount point.634 */635 struct tree_balance *cur_tb;636#endif637};638 639/* Definitions of reiserfs on-disk properties: */640#define REISERFS_3_5 0641#define REISERFS_3_6 1642#define REISERFS_OLD_FORMAT 2643 644/* Mount options */645enum reiserfs_mount_options {646 /* large tails will be created in a session */647 REISERFS_LARGETAIL,648 /*649 * small (for files less than block size) tails will650 * be created in a session651 */652 REISERFS_SMALLTAIL,653 654 /* replay journal and return 0. Use by fsck */655 REPLAYONLY,656 657 /*658 * -o conv: causes conversion of old format super block to the659 * new format. If not specified - old partition will be dealt660 * with in a manner of 3.5.x661 */662 REISERFS_CONVERT,663 664 /*665 * -o hash={tea, rupasov, r5, detect} is meant for properly mounting666 * reiserfs disks from 3.5.19 or earlier. 99% of the time, this667 * option is not required. If the normal autodection code can't668 * determine which hash to use (because both hashes had the same669 * value for a file) use this option to force a specific hash.670 * It won't allow you to override the existing hash on the FS, so671 * if you have a tea hash disk, and mount with -o hash=rupasov,672 * the mount will fail.673 */674 FORCE_TEA_HASH, /* try to force tea hash on mount */675 FORCE_RUPASOV_HASH, /* try to force rupasov hash on mount */676 FORCE_R5_HASH, /* try to force rupasov hash on mount */677 FORCE_HASH_DETECT, /* try to detect hash function on mount */678 679 REISERFS_DATA_LOG,680 REISERFS_DATA_ORDERED,681 REISERFS_DATA_WRITEBACK,682 683 /*684 * used for testing experimental features, makes benchmarking new685 * features with and without more convenient, should never be used by686 * users in any code shipped to users (ideally)687 */688 689 REISERFS_NO_BORDER,690 REISERFS_NO_UNHASHED_RELOCATION,691 REISERFS_HASHED_RELOCATION,692 REISERFS_ATTRS,693 REISERFS_XATTRS_USER,694 REISERFS_POSIXACL,695 REISERFS_EXPOSE_PRIVROOT,696 REISERFS_BARRIER_NONE,697 REISERFS_BARRIER_FLUSH,698 699 /* Actions on error */700 REISERFS_ERROR_PANIC,701 REISERFS_ERROR_RO,702 REISERFS_ERROR_CONTINUE,703 704 REISERFS_USRQUOTA, /* User quota option specified */705 REISERFS_GRPQUOTA, /* Group quota option specified */706 707 REISERFS_TEST1,708 REISERFS_TEST2,709 REISERFS_TEST3,710 REISERFS_TEST4,711 REISERFS_UNSUPPORTED_OPT,712};713 714#define reiserfs_r5_hash(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_R5_HASH))715#define reiserfs_rupasov_hash(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_RUPASOV_HASH))716#define reiserfs_tea_hash(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_TEA_HASH))717#define reiserfs_hash_detect(s) (REISERFS_SB(s)->s_mount_opt & (1 << FORCE_HASH_DETECT))718#define reiserfs_no_border(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_NO_BORDER))719#define reiserfs_no_unhashed_relocation(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_NO_UNHASHED_RELOCATION))720#define reiserfs_hashed_relocation(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_HASHED_RELOCATION))721#define reiserfs_test4(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_TEST4))722 723#define have_large_tails(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_LARGETAIL))724#define have_small_tails(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_SMALLTAIL))725#define replay_only(s) (REISERFS_SB(s)->s_mount_opt & (1 << REPLAYONLY))726#define reiserfs_attrs(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_ATTRS))727#define old_format_only(s) (REISERFS_SB(s)->s_properties & (1 << REISERFS_3_5))728#define convert_reiserfs(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_CONVERT))729#define reiserfs_data_log(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_DATA_LOG))730#define reiserfs_data_ordered(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_DATA_ORDERED))731#define reiserfs_data_writeback(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_DATA_WRITEBACK))732#define reiserfs_xattrs_user(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_XATTRS_USER))733#define reiserfs_posixacl(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_POSIXACL))734#define reiserfs_expose_privroot(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_EXPOSE_PRIVROOT))735#define reiserfs_xattrs_optional(s) (reiserfs_xattrs_user(s) || reiserfs_posixacl(s))736#define reiserfs_barrier_none(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_BARRIER_NONE))737#define reiserfs_barrier_flush(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_BARRIER_FLUSH))738 739#define reiserfs_error_panic(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_ERROR_PANIC))740#define reiserfs_error_ro(s) (REISERFS_SB(s)->s_mount_opt & (1 << REISERFS_ERROR_RO))741 742void reiserfs_file_buffer(struct buffer_head *bh, int list);743extern struct file_system_type reiserfs_fs_type;744int reiserfs_resize(struct super_block *, unsigned long);745 746#define CARRY_ON 0747#define SCHEDULE_OCCURRED 1748 749#define SB_BUFFER_WITH_SB(s) (REISERFS_SB(s)->s_sbh)750#define SB_JOURNAL(s) (REISERFS_SB(s)->s_journal)751#define SB_JOURNAL_1st_RESERVED_BLOCK(s) (SB_JOURNAL(s)->j_1st_reserved_block)752#define SB_JOURNAL_LEN_FREE(s) (SB_JOURNAL(s)->j_journal_len_free)753#define SB_AP_BITMAP(s) (REISERFS_SB(s)->s_ap_bitmap)754 755#define SB_DISK_JOURNAL_HEAD(s) (SB_JOURNAL(s)->j_header_bh->)756 757#define reiserfs_is_journal_aborted(journal) (unlikely (__reiserfs_is_journal_aborted (journal)))758static inline int __reiserfs_is_journal_aborted(struct reiserfs_journal759 *journal)760{761 return test_bit(J_ABORTED, &journal->j_state);762}763 764/*765 * Locking primitives. The write lock is a per superblock766 * special mutex that has properties close to the Big Kernel Lock767 * which was used in the previous locking scheme.768 */769void reiserfs_write_lock(struct super_block *s);770void reiserfs_write_unlock(struct super_block *s);771int __must_check reiserfs_write_unlock_nested(struct super_block *s);772void reiserfs_write_lock_nested(struct super_block *s, int depth);773 774#ifdef CONFIG_REISERFS_CHECK775void reiserfs_lock_check_recursive(struct super_block *s);776#else777static inline void reiserfs_lock_check_recursive(struct super_block *s) { }778#endif779 780/*781 * Several mutexes depend on the write lock.782 * However sometimes we want to relax the write lock while we hold783 * these mutexes, according to the release/reacquire on schedule()784 * properties of the Bkl that were used.785 * Reiserfs performances and locking were based on this scheme.786 * Now that the write lock is a mutex and not the bkl anymore, doing so787 * may result in a deadlock:788 *789 * A acquire write_lock790 * A acquire j_commit_mutex791 * A release write_lock and wait for something792 * B acquire write_lock793 * B can't acquire j_commit_mutex and sleep794 * A can't acquire write lock anymore795 * deadlock796 *797 * What we do here is avoiding such deadlock by playing the same game798 * than the Bkl: if we can't acquire a mutex that depends on the write lock,799 * we release the write lock, wait a bit and then retry.800 *801 * The mutexes concerned by this hack are:802 * - The commit mutex of a journal list803 * - The flush mutex804 * - The journal lock805 * - The inode mutex806 */807static inline void reiserfs_mutex_lock_safe(struct mutex *m,808 struct super_block *s)809{810 int depth;811 812 depth = reiserfs_write_unlock_nested(s);813 mutex_lock(m);814 reiserfs_write_lock_nested(s, depth);815}816 817static inline void818reiserfs_mutex_lock_nested_safe(struct mutex *m, unsigned int subclass,819 struct super_block *s)820{821 int depth;822 823 depth = reiserfs_write_unlock_nested(s);824 mutex_lock_nested(m, subclass);825 reiserfs_write_lock_nested(s, depth);826}827 828static inline void829reiserfs_down_read_safe(struct rw_semaphore *sem, struct super_block *s)830{831 int depth;832 depth = reiserfs_write_unlock_nested(s);833 down_read(sem);834 reiserfs_write_lock_nested(s, depth);835}836 837/*838 * When we schedule, we usually want to also release the write lock,839 * according to the previous bkl based locking scheme of reiserfs.840 */841static inline void reiserfs_cond_resched(struct super_block *s)842{843 if (need_resched()) {844 int depth;845 846 depth = reiserfs_write_unlock_nested(s);847 schedule();848 reiserfs_write_lock_nested(s, depth);849 }850}851 852struct fid;853 854/*855 * in reading the #defines, it may help to understand that they employ856 * the following abbreviations:857 *858 * B = Buffer859 * I = Item header860 * H = Height within the tree (should be changed to LEV)861 * N = Number of the item in the node862 * STAT = stat data863 * DEH = Directory Entry Header864 * EC = Entry Count865 * E = Entry number866 * UL = Unsigned Long867 * BLKH = BLocK Header868 * UNFM = UNForMatted node869 * DC = Disk Child870 * P = Path871 *872 * These #defines are named by concatenating these abbreviations,873 * where first comes the arguments, and last comes the return value,874 * of the macro.875 */876 877#define USE_INODE_GENERATION_COUNTER878 879#define REISERFS_PREALLOCATE880#define DISPLACE_NEW_PACKING_LOCALITIES881#define PREALLOCATION_SIZE 9882 883/* n must be power of 2 */884#define _ROUND_UP(x,n) (((x)+(n)-1u) & ~((n)-1u))885 886/*887 * to be ok for alpha and others we have to align structures to 8 byte888 * boundary.889 * FIXME: do not change 4 by anything else: there is code which relies on that890 */891#define ROUND_UP(x) _ROUND_UP(x,8LL)892 893/*894 * debug levels. Right now, CONFIG_REISERFS_CHECK means print all debug895 * messages.896 */897#define REISERFS_DEBUG_CODE 5 /* extra messages to help find/debug errors */898 899void __reiserfs_warning(struct super_block *s, const char *id,900 const char *func, const char *fmt, ...);901#define reiserfs_warning(s, id, fmt, args...) \902 __reiserfs_warning(s, id, __func__, fmt, ##args)903/* assertions handling */904 905/* always check a condition and panic if it's false. */906#define __RASSERT(cond, scond, format, args...) \907do { \908 if (!(cond)) \909 reiserfs_panic(NULL, "assertion failure", "(" #cond ") at " \910 __FILE__ ":%i:%s: " format "\n", \911 __LINE__, __func__ , ##args); \912} while (0)913 914#define RASSERT(cond, format, args...) __RASSERT(cond, #cond, format, ##args)915 916#if defined( CONFIG_REISERFS_CHECK )917#define RFALSE(cond, format, args...) __RASSERT(!(cond), "!(" #cond ")", format, ##args)918#else919#define RFALSE( cond, format, args... ) do {;} while( 0 )920#endif921 922#define CONSTF __attribute_const__923/*924 * Disk Data Structures925 */926 927/***************************************************************************928 * SUPER BLOCK *929 ***************************************************************************/930 931/*932 * Structure of super block on disk, a version of which in RAM is often933 * accessed as REISERFS_SB(s)->s_rs. The version in RAM is part of a larger934 * structure containing fields never written to disk.935 */936#define UNSET_HASH 0 /* Detect hash on disk */937#define TEA_HASH 1938#define YURA_HASH 2939#define R5_HASH 3940#define DEFAULT_HASH R5_HASH941 942struct journal_params {943 /* where does journal start from on its * device */944 __le32 jp_journal_1st_block;945 946 /* journal device st_rdev */947 __le32 jp_journal_dev;948 949 /* size of the journal */950 __le32 jp_journal_size;951 952 /* max number of blocks in a transaction. */953 __le32 jp_journal_trans_max;954 955 /*956 * random value made on fs creation957 * (this was sb_journal_block_count)958 */959 __le32 jp_journal_magic;960 961 /* max number of blocks to batch into a trans */962 __le32 jp_journal_max_batch;963 964 /* in seconds, how old can an async commit be */965 __le32 jp_journal_max_commit_age;966 967 /* in seconds, how old can a transaction be */968 __le32 jp_journal_max_trans_age;969};970 971/* this is the super from 3.5.X, where X >= 10 */972struct reiserfs_super_block_v1 {973 __le32 s_block_count; /* blocks count */974 __le32 s_free_blocks; /* free blocks count */975 __le32 s_root_block; /* root block number */976 struct journal_params s_journal;977 __le16 s_blocksize; /* block size */978 979 /* max size of object id array, see get_objectid() commentary */980 __le16 s_oid_maxsize;981 __le16 s_oid_cursize; /* current size of object id array */982 983 /* this is set to 1 when filesystem was umounted, to 2 - when not */984 __le16 s_umount_state;985 986 /*987 * reiserfs magic string indicates that file system is reiserfs:988 * "ReIsErFs" or "ReIsEr2Fs" or "ReIsEr3Fs"989 */990 char s_magic[10];991 992 /*993 * it is set to used by fsck to mark which994 * phase of rebuilding is done995 */996 __le16 s_fs_state;997 /*998 * indicate, what hash function is being use999 * to sort names in a directory1000 */1001 __le32 s_hash_function_code;1002 __le16 s_tree_height; /* height of disk tree */1003 1004 /*1005 * amount of bitmap blocks needed to address1006 * each block of file system1007 */1008 __le16 s_bmap_nr;1009 1010 /*1011 * this field is only reliable on filesystem with non-standard journal1012 */1013 __le16 s_version;1014 1015 /*1016 * size in blocks of journal area on main device, we need to1017 * keep after making fs with non-standard journal1018 */1019 __le16 s_reserved_for_journal;1020} __attribute__ ((__packed__));1021 1022#define SB_SIZE_V1 (sizeof(struct reiserfs_super_block_v1))1023 1024/* this is the on disk super block */1025struct reiserfs_super_block {1026 struct reiserfs_super_block_v1 s_v1;1027 __le32 s_inode_generation;1028 1029 /* Right now used only by inode-attributes, if enabled */1030 __le32 s_flags;1031 1032 unsigned char s_uuid[16]; /* filesystem unique identifier */1033 unsigned char s_label[16]; /* filesystem volume label */1034 __le16 s_mnt_count; /* Count of mounts since last fsck */1035 __le16 s_max_mnt_count; /* Maximum mounts before check */1036 __le32 s_lastcheck; /* Timestamp of last fsck */1037 __le32 s_check_interval; /* Interval between checks */1038 1039 /*1040 * zero filled by mkreiserfs and reiserfs_convert_objectid_map_v1()1041 * so any additions must be updated there as well. */1042 char s_unused[76];1043} __attribute__ ((__packed__));1044 1045#define SB_SIZE (sizeof(struct reiserfs_super_block))1046 1047#define REISERFS_VERSION_1 01048#define REISERFS_VERSION_2 21049 1050/* on-disk super block fields converted to cpu form */1051#define SB_DISK_SUPER_BLOCK(s) (REISERFS_SB(s)->s_rs)1052#define SB_V1_DISK_SUPER_BLOCK(s) (&(SB_DISK_SUPER_BLOCK(s)->s_v1))1053#define SB_BLOCKSIZE(s) \1054 le32_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_blocksize))1055#define SB_BLOCK_COUNT(s) \1056 le32_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_block_count))1057#define SB_FREE_BLOCKS(s) \1058 le32_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_free_blocks))1059#define SB_REISERFS_MAGIC(s) \1060 (SB_V1_DISK_SUPER_BLOCK(s)->s_magic)1061#define SB_ROOT_BLOCK(s) \1062 le32_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_root_block))1063#define SB_TREE_HEIGHT(s) \1064 le16_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_tree_height))1065#define SB_REISERFS_STATE(s) \1066 le16_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_umount_state))1067#define SB_VERSION(s) le16_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_version))1068#define SB_BMAP_NR(s) le16_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_bmap_nr))1069 1070#define PUT_SB_BLOCK_COUNT(s, val) \1071 do { SB_V1_DISK_SUPER_BLOCK(s)->s_block_count = cpu_to_le32(val); } while (0)1072#define PUT_SB_FREE_BLOCKS(s, val) \1073 do { SB_V1_DISK_SUPER_BLOCK(s)->s_free_blocks = cpu_to_le32(val); } while (0)1074#define PUT_SB_ROOT_BLOCK(s, val) \1075 do { SB_V1_DISK_SUPER_BLOCK(s)->s_root_block = cpu_to_le32(val); } while (0)1076#define PUT_SB_TREE_HEIGHT(s, val) \1077 do { SB_V1_DISK_SUPER_BLOCK(s)->s_tree_height = cpu_to_le16(val); } while (0)1078#define PUT_SB_REISERFS_STATE(s, val) \1079 do { SB_V1_DISK_SUPER_BLOCK(s)->s_umount_state = cpu_to_le16(val); } while (0)1080#define PUT_SB_VERSION(s, val) \1081 do { SB_V1_DISK_SUPER_BLOCK(s)->s_version = cpu_to_le16(val); } while (0)1082#define PUT_SB_BMAP_NR(s, val) \1083 do { SB_V1_DISK_SUPER_BLOCK(s)->s_bmap_nr = cpu_to_le16 (val); } while (0)1084 1085#define SB_ONDISK_JP(s) (&SB_V1_DISK_SUPER_BLOCK(s)->s_journal)1086#define SB_ONDISK_JOURNAL_SIZE(s) \1087 le32_to_cpu ((SB_ONDISK_JP(s)->jp_journal_size))1088#define SB_ONDISK_JOURNAL_1st_BLOCK(s) \1089 le32_to_cpu ((SB_ONDISK_JP(s)->jp_journal_1st_block))1090#define SB_ONDISK_JOURNAL_DEVICE(s) \1091 le32_to_cpu ((SB_ONDISK_JP(s)->jp_journal_dev))1092#define SB_ONDISK_RESERVED_FOR_JOURNAL(s) \1093 le16_to_cpu ((SB_V1_DISK_SUPER_BLOCK(s)->s_reserved_for_journal))1094 1095#define is_block_in_log_or_reserved_area(s, block) \1096 block >= SB_JOURNAL_1st_RESERVED_BLOCK(s) \1097 && block < SB_JOURNAL_1st_RESERVED_BLOCK(s) + \1098 ((!is_reiserfs_jr(SB_DISK_SUPER_BLOCK(s)) ? \1099 SB_ONDISK_JOURNAL_SIZE(s) + 1 : SB_ONDISK_RESERVED_FOR_JOURNAL(s)))1100 1101int is_reiserfs_3_5(struct reiserfs_super_block *rs);1102int is_reiserfs_3_6(struct reiserfs_super_block *rs);1103int is_reiserfs_jr(struct reiserfs_super_block *rs);1104 1105/*1106 * ReiserFS leaves the first 64k unused, so that partition labels have1107 * enough space. If someone wants to write a fancy bootloader that1108 * needs more than 64k, let us know, and this will be increased in size.1109 * This number must be larger than the largest block size on any1110 * platform, or code will break. -Hans1111 */1112#define REISERFS_DISK_OFFSET_IN_BYTES (64 * 1024)1113#define REISERFS_FIRST_BLOCK unused_define1114#define REISERFS_JOURNAL_OFFSET_IN_BYTES REISERFS_DISK_OFFSET_IN_BYTES1115 1116/* the spot for the super in versions 3.5 - 3.5.10 (inclusive) */1117#define REISERFS_OLD_DISK_OFFSET_IN_BYTES (8 * 1024)1118 1119/* reiserfs internal error code (used by search_by_key and fix_nodes)) */1120#define CARRY_ON 01121#define REPEAT_SEARCH -11122#define IO_ERROR -21123#define NO_DISK_SPACE -31124#define NO_BALANCING_NEEDED (-4)1125#define NO_MORE_UNUSED_CONTIGUOUS_BLOCKS (-5)1126#define QUOTA_EXCEEDED -61127 1128typedef __u32 b_blocknr_t;1129typedef __le32 unp_t;1130 1131struct unfm_nodeinfo {1132 unp_t unfm_nodenum;1133 unsigned short unfm_freespace;1134};1135 1136/* there are two formats of keys: 3.5 and 3.6 */1137#define KEY_FORMAT_3_5 01138#define KEY_FORMAT_3_6 11139 1140/* there are two stat datas */1141#define STAT_DATA_V1 01142#define STAT_DATA_V2 11143 1144static inline struct reiserfs_inode_info *REISERFS_I(const struct inode *inode)1145{1146 return container_of(inode, struct reiserfs_inode_info, vfs_inode);1147}1148 1149static inline struct reiserfs_sb_info *REISERFS_SB(const struct super_block *sb)1150{1151 return sb->s_fs_info;1152}1153 1154/*1155 * Don't trust REISERFS_SB(sb)->s_bmap_nr, it's a u161156 * which overflows on large file systems.1157 */1158static inline __u32 reiserfs_bmap_count(struct super_block *sb)1159{1160 return (SB_BLOCK_COUNT(sb) - 1) / (sb->s_blocksize * 8) + 1;1161}1162 1163static inline int bmap_would_wrap(unsigned bmap_nr)1164{1165 return bmap_nr > ((1LL << 16) - 1);1166}1167 1168extern const struct xattr_handler * const reiserfs_xattr_handlers[];1169 1170/*1171 * this says about version of key of all items (but stat data) the1172 * object consists of1173 */1174#define get_inode_item_key_version( inode ) \1175 ((REISERFS_I(inode)->i_flags & i_item_key_version_mask) ? KEY_FORMAT_3_6 : KEY_FORMAT_3_5)1176 1177#define set_inode_item_key_version( inode, version ) \1178 ({ if((version)==KEY_FORMAT_3_6) \1179 REISERFS_I(inode)->i_flags |= i_item_key_version_mask; \1180 else \1181 REISERFS_I(inode)->i_flags &= ~i_item_key_version_mask; })1182 1183#define get_inode_sd_version(inode) \1184 ((REISERFS_I(inode)->i_flags & i_stat_data_version_mask) ? STAT_DATA_V2 : STAT_DATA_V1)1185 1186#define set_inode_sd_version(inode, version) \1187 ({ if((version)==STAT_DATA_V2) \1188 REISERFS_I(inode)->i_flags |= i_stat_data_version_mask; \1189 else \1190 REISERFS_I(inode)->i_flags &= ~i_stat_data_version_mask; })1191 1192/*1193 * This is an aggressive tail suppression policy, I am hoping it1194 * improves our benchmarks. The principle behind it is that percentage1195 * space saving is what matters, not absolute space saving. This is1196 * non-intuitive, but it helps to understand it if you consider that the1197 * cost to access 4 blocks is not much more than the cost to access 11198 * block, if you have to do a seek and rotate. A tail risks a1199 * non-linear disk access that is significant as a percentage of total1200 * time cost for a 4 block file and saves an amount of space that is1201 * less significant as a percentage of space, or so goes the hypothesis.1202 * -Hans1203 */1204#define STORE_TAIL_IN_UNFM_S1(n_file_size,n_tail_size,n_block_size) \1205(\1206 (!(n_tail_size)) || \1207 (((n_tail_size) > MAX_DIRECT_ITEM_LEN(n_block_size)) || \1208 ( (n_file_size) >= (n_block_size) * 4 ) || \1209 ( ( (n_file_size) >= (n_block_size) * 3 ) && \1210 ( (n_tail_size) >= (MAX_DIRECT_ITEM_LEN(n_block_size))/4) ) || \1211 ( ( (n_file_size) >= (n_block_size) * 2 ) && \1212 ( (n_tail_size) >= (MAX_DIRECT_ITEM_LEN(n_block_size))/2) ) || \1213 ( ( (n_file_size) >= (n_block_size) ) && \1214 ( (n_tail_size) >= (MAX_DIRECT_ITEM_LEN(n_block_size) * 3)/4) ) ) \1215)1216 1217/*1218 * Another strategy for tails, this one means only create a tail if all the1219 * file would fit into one DIRECT item.1220 * Primary intention for this one is to increase performance by decreasing1221 * seeking.1222*/1223#define STORE_TAIL_IN_UNFM_S2(n_file_size,n_tail_size,n_block_size) \1224(\1225 (!(n_tail_size)) || \1226 (((n_file_size) > MAX_DIRECT_ITEM_LEN(n_block_size)) ) \1227)1228 1229/*1230 * values for s_umount_state field1231 */1232#define REISERFS_VALID_FS 11233#define REISERFS_ERROR_FS 21234 1235/*1236 * there are 5 item types currently1237 */1238#define TYPE_STAT_DATA 01239#define TYPE_INDIRECT 11240#define TYPE_DIRECT 21241#define TYPE_DIRENTRY 31242#define TYPE_MAXTYPE 31243#define TYPE_ANY 15 /* FIXME: comment is required */1244 1245/***************************************************************************1246 * KEY & ITEM HEAD *1247 ***************************************************************************/1248 1249/* * directories use this key as well as old files */1250struct offset_v1 {1251 __le32 k_offset;1252 __le32 k_uniqueness;1253} __attribute__ ((__packed__));1254 1255struct offset_v2 {1256 __le64 v;1257} __attribute__ ((__packed__));1258 1259static inline __u16 offset_v2_k_type(const struct offset_v2 *v2)1260{1261 __u8 type = le64_to_cpu(v2->v) >> 60;1262 return (type <= TYPE_MAXTYPE) ? type : TYPE_ANY;1263}1264 1265static inline void set_offset_v2_k_type(struct offset_v2 *v2, int type)1266{1267 v2->v =1268 (v2->v & cpu_to_le64(~0ULL >> 4)) | cpu_to_le64((__u64) type << 60);1269}1270 1271static inline loff_t offset_v2_k_offset(const struct offset_v2 *v2)1272{1273 return le64_to_cpu(v2->v) & (~0ULL >> 4);1274}1275 1276static inline void set_offset_v2_k_offset(struct offset_v2 *v2, loff_t offset)1277{1278 offset &= (~0ULL >> 4);1279 v2->v = (v2->v & cpu_to_le64(15ULL << 60)) | cpu_to_le64(offset);1280}1281 1282/*1283 * Key of an item determines its location in the S+tree, and1284 * is composed of 4 components1285 */1286struct reiserfs_key {1287 /* packing locality: by default parent directory object id */1288 __le32 k_dir_id;1289 1290 __le32 k_objectid; /* object identifier */1291 union {1292 struct offset_v1 k_offset_v1;1293 struct offset_v2 k_offset_v2;1294 } __attribute__ ((__packed__)) u;1295} __attribute__ ((__packed__));1296 1297struct in_core_key {1298 /* packing locality: by default parent directory object id */1299 __u32 k_dir_id;1300 __u32 k_objectid; /* object identifier */1301 __u64 k_offset;1302 __u8 k_type;1303};1304 1305struct cpu_key {1306 struct in_core_key on_disk_key;1307 int version;1308 /* 3 in all cases but direct2indirect and indirect2direct conversion */1309 int key_length;1310};1311 1312/*1313 * Our function for comparing keys can compare keys of different1314 * lengths. It takes as a parameter the length of the keys it is to1315 * compare. These defines are used in determining what is to be passed1316 * to it as that parameter.1317 */1318#define REISERFS_FULL_KEY_LEN 41319#define REISERFS_SHORT_KEY_LEN 21320 1321/* The result of the key compare */1322#define FIRST_GREATER 11323#define SECOND_GREATER -11324#define KEYS_IDENTICAL 01325#define KEY_FOUND 11326#define KEY_NOT_FOUND 01327 1328#define KEY_SIZE (sizeof(struct reiserfs_key))1329 1330/* return values for search_by_key and clones */1331#define ITEM_FOUND 11332#define ITEM_NOT_FOUND 01333#define ENTRY_FOUND 11334#define ENTRY_NOT_FOUND 01335#define DIRECTORY_NOT_FOUND -11336#define REGULAR_FILE_FOUND -21337#define DIRECTORY_FOUND -31338#define BYTE_FOUND 11339#define BYTE_NOT_FOUND 01340#define FILE_NOT_FOUND -11341 1342#define POSITION_FOUND 11343#define POSITION_NOT_FOUND 01344 1345/* return values for reiserfs_find_entry and search_by_entry_key */1346#define NAME_FOUND 11347#define NAME_NOT_FOUND 01348#define GOTO_PREVIOUS_ITEM 21349#define NAME_FOUND_INVISIBLE 31350 1351/*1352 * Everything in the filesystem is stored as a set of items. The1353 * item head contains the key of the item, its free space (for1354 * indirect items) and specifies the location of the item itself1355 * within the block.1356 */1357 1358struct item_head {1359 /*1360 * Everything in the tree is found by searching for it based on1361 * its key.1362 */1363 struct reiserfs_key ih_key;1364 union {1365 /*1366 * The free space in the last unformatted node of an1367 * indirect item if this is an indirect item. This1368 * equals 0xFFFF iff this is a direct item or stat data1369 * item. Note that the key, not this field, is used to1370 * determine the item type, and thus which field this1371 * union contains.1372 */1373 __le16 ih_free_space_reserved;1374 1375 /*1376 * Iff this is a directory item, this field equals the1377 * number of directory entries in the directory item.1378 */1379 __le16 ih_entry_count;1380 } __attribute__ ((__packed__)) u;1381 __le16 ih_item_len; /* total size of the item body */1382 1383 /* an offset to the item body within the block */1384 __le16 ih_item_location;1385 1386 /*1387 * 0 for all old items, 2 for new ones. Highest bit is set by fsck1388 * temporary, cleaned after all done1389 */1390 __le16 ih_version;1391} __attribute__ ((__packed__));1392/* size of item header */1393#define IH_SIZE (sizeof(struct item_head))1394 1395#define ih_free_space(ih) le16_to_cpu((ih)->u.ih_free_space_reserved)1396#define ih_version(ih) le16_to_cpu((ih)->ih_version)1397#define ih_entry_count(ih) le16_to_cpu((ih)->u.ih_entry_count)1398#define ih_location(ih) le16_to_cpu((ih)->ih_item_location)1399#define ih_item_len(ih) le16_to_cpu((ih)->ih_item_len)1400 1401#define put_ih_free_space(ih, val) do { (ih)->u.ih_free_space_reserved = cpu_to_le16(val); } while(0)1402#define put_ih_version(ih, val) do { (ih)->ih_version = cpu_to_le16(val); } while (0)1403#define put_ih_entry_count(ih, val) do { (ih)->u.ih_entry_count = cpu_to_le16(val); } while (0)1404#define put_ih_location(ih, val) do { (ih)->ih_item_location = cpu_to_le16(val); } while (0)1405#define put_ih_item_len(ih, val) do { (ih)->ih_item_len = cpu_to_le16(val); } while (0)1406 1407#define unreachable_item(ih) (ih_version(ih) & (1 << 15))1408 1409#define get_ih_free_space(ih) (ih_version (ih) == KEY_FORMAT_3_6 ? 0 : ih_free_space (ih))1410#define set_ih_free_space(ih,val) put_ih_free_space((ih), ((ih_version(ih) == KEY_FORMAT_3_6) ? 0 : (val)))1411 1412/*1413 * these operate on indirect items, where you've got an array of ints1414 * at a possibly unaligned location. These are a noop on ia321415 *1416 * p is the array of __u32, i is the index into the array, v is the value1417 * to store there.1418 */1419#define get_block_num(p, i) get_unaligned_le32((p) + (i))1420#define put_block_num(p, i, v) put_unaligned_le32((v), (p) + (i))1421 1422/* * in old version uniqueness field shows key type */1423#define V1_SD_UNIQUENESS 01424#define V1_INDIRECT_UNIQUENESS 0xfffffffe1425#define V1_DIRECT_UNIQUENESS 0xffffffff1426#define V1_DIRENTRY_UNIQUENESS 5001427#define V1_ANY_UNIQUENESS 555 /* FIXME: comment is required */1428 1429/* here are conversion routines */1430static inline int uniqueness2type(__u32 uniqueness) CONSTF;1431static inline int uniqueness2type(__u32 uniqueness)1432{1433 switch ((int)uniqueness) {1434 case V1_SD_UNIQUENESS:1435 return TYPE_STAT_DATA;1436 case V1_INDIRECT_UNIQUENESS:1437 return TYPE_INDIRECT;1438 case V1_DIRECT_UNIQUENESS:1439 return TYPE_DIRECT;1440 case V1_DIRENTRY_UNIQUENESS:1441 return TYPE_DIRENTRY;1442 case V1_ANY_UNIQUENESS:1443 default:1444 return TYPE_ANY;1445 }1446}1447 1448static inline __u32 type2uniqueness(int type) CONSTF;1449static inline __u32 type2uniqueness(int type)1450{1451 switch (type) {1452 case TYPE_STAT_DATA:1453 return V1_SD_UNIQUENESS;1454 case TYPE_INDIRECT:1455 return V1_INDIRECT_UNIQUENESS;1456 case TYPE_DIRECT:1457 return V1_DIRECT_UNIQUENESS;1458 case TYPE_DIRENTRY:1459 return V1_DIRENTRY_UNIQUENESS;1460 case TYPE_ANY:1461 default:1462 return V1_ANY_UNIQUENESS;1463 }1464}1465 1466/*1467 * key is pointer to on disk key which is stored in le, result is cpu,1468 * there is no way to get version of object from key, so, provide1469 * version to these defines1470 */1471static inline loff_t le_key_k_offset(int version,1472 const struct reiserfs_key *key)1473{1474 return (version == KEY_FORMAT_3_5) ?1475 le32_to_cpu(key->u.k_offset_v1.k_offset) :1476 offset_v2_k_offset(&(key->u.k_offset_v2));1477}1478 1479static inline loff_t le_ih_k_offset(const struct item_head *ih)1480{1481 return le_key_k_offset(ih_version(ih), &(ih->ih_key));1482}1483 1484static inline loff_t le_key_k_type(int version, const struct reiserfs_key *key)1485{1486 if (version == KEY_FORMAT_3_5) {1487 loff_t val = le32_to_cpu(key->u.k_offset_v1.k_uniqueness);1488 return uniqueness2type(val);1489 } else1490 return offset_v2_k_type(&(key->u.k_offset_v2));1491}1492 1493static inline loff_t le_ih_k_type(const struct item_head *ih)1494{1495 return le_key_k_type(ih_version(ih), &(ih->ih_key));1496}1497 1498static inline void set_le_key_k_offset(int version, struct reiserfs_key *key,1499 loff_t offset)1500{1501 if (version == KEY_FORMAT_3_5)1502 key->u.k_offset_v1.k_offset = cpu_to_le32(offset);1503 else1504 set_offset_v2_k_offset(&key->u.k_offset_v2, offset);1505}1506 1507static inline void add_le_key_k_offset(int version, struct reiserfs_key *key,1508 loff_t offset)1509{1510 set_le_key_k_offset(version, key,1511 le_key_k_offset(version, key) + offset);1512}1513 1514static inline void add_le_ih_k_offset(struct item_head *ih, loff_t offset)1515{1516 add_le_key_k_offset(ih_version(ih), &(ih->ih_key), offset);1517}1518 1519static inline void set_le_ih_k_offset(struct item_head *ih, loff_t offset)1520{1521 set_le_key_k_offset(ih_version(ih), &(ih->ih_key), offset);1522}1523 1524static inline void set_le_key_k_type(int version, struct reiserfs_key *key,1525 int type)1526{1527 if (version == KEY_FORMAT_3_5) {1528 type = type2uniqueness(type);1529 key->u.k_offset_v1.k_uniqueness = cpu_to_le32(type);1530 } else1531 set_offset_v2_k_type(&key->u.k_offset_v2, type);1532}1533 1534static inline void set_le_ih_k_type(struct item_head *ih, int type)1535{1536 set_le_key_k_type(ih_version(ih), &(ih->ih_key), type);1537}1538 1539static inline int is_direntry_le_key(int version, struct reiserfs_key *key)1540{1541 return le_key_k_type(version, key) == TYPE_DIRENTRY;1542}1543 1544static inline int is_direct_le_key(int version, struct reiserfs_key *key)1545{1546 return le_key_k_type(version, key) == TYPE_DIRECT;1547}1548 1549static inline int is_indirect_le_key(int version, struct reiserfs_key *key)1550{1551 return le_key_k_type(version, key) == TYPE_INDIRECT;1552}1553 1554static inline int is_statdata_le_key(int version, struct reiserfs_key *key)1555{1556 return le_key_k_type(version, key) == TYPE_STAT_DATA;1557}1558 1559/* item header has version. */1560static inline int is_direntry_le_ih(struct item_head *ih)1561{1562 return is_direntry_le_key(ih_version(ih), &ih->ih_key);1563}1564 1565static inline int is_direct_le_ih(struct item_head *ih)1566{1567 return is_direct_le_key(ih_version(ih), &ih->ih_key);1568}1569 1570static inline int is_indirect_le_ih(struct item_head *ih)1571{1572 return is_indirect_le_key(ih_version(ih), &ih->ih_key);1573}1574 1575static inline int is_statdata_le_ih(struct item_head *ih)1576{1577 return is_statdata_le_key(ih_version(ih), &ih->ih_key);1578}1579 1580/* key is pointer to cpu key, result is cpu */1581static inline loff_t cpu_key_k_offset(const struct cpu_key *key)1582{1583 return key->on_disk_key.k_offset;1584}1585 1586static inline loff_t cpu_key_k_type(const struct cpu_key *key)1587{1588 return key->on_disk_key.k_type;1589}1590 1591static inline void set_cpu_key_k_offset(struct cpu_key *key, loff_t offset)1592{1593 key->on_disk_key.k_offset = offset;1594}1595 1596static inline void set_cpu_key_k_type(struct cpu_key *key, int type)1597{1598 key->on_disk_key.k_type = type;1599}1600 1601static inline void cpu_key_k_offset_dec(struct cpu_key *key)1602{1603 key->on_disk_key.k_offset--;1604}1605 1606#define is_direntry_cpu_key(key) (cpu_key_k_type (key) == TYPE_DIRENTRY)1607#define is_direct_cpu_key(key) (cpu_key_k_type (key) == TYPE_DIRECT)1608#define is_indirect_cpu_key(key) (cpu_key_k_type (key) == TYPE_INDIRECT)1609#define is_statdata_cpu_key(key) (cpu_key_k_type (key) == TYPE_STAT_DATA)1610 1611/* are these used ? */1612#define is_direntry_cpu_ih(ih) (is_direntry_cpu_key (&((ih)->ih_key)))1613#define is_direct_cpu_ih(ih) (is_direct_cpu_key (&((ih)->ih_key)))1614#define is_indirect_cpu_ih(ih) (is_indirect_cpu_key (&((ih)->ih_key)))1615#define is_statdata_cpu_ih(ih) (is_statdata_cpu_key (&((ih)->ih_key)))1616 1617#define I_K_KEY_IN_ITEM(ih, key, n_blocksize) \1618 (!COMP_SHORT_KEYS(ih, key) && \1619 I_OFF_BYTE_IN_ITEM(ih, k_offset(key), n_blocksize))1620 1621/* maximal length of item */1622#define MAX_ITEM_LEN(block_size) (block_size - BLKH_SIZE - IH_SIZE)1623#define MIN_ITEM_LEN 11624 1625/* object identifier for root dir */1626#define REISERFS_ROOT_OBJECTID 21627#define REISERFS_ROOT_PARENT_OBJECTID 11628 1629extern struct reiserfs_key root_key;1630 1631/*1632 * Picture represents a leaf of the S+tree1633 * ______________________________________________________1634 * | | Array of | | |1635 * |Block | Object-Item | F r e e | Objects- |1636 * | head | Headers | S p a c e | Items |1637 * |______|_______________|___________________|___________|1638 */1639 1640/*1641 * Header of a disk block. More precisely, header of a formatted leaf1642 * or internal node, and not the header of an unformatted node.1643 */1644struct block_head {1645 __le16 blk_level; /* Level of a block in the tree. */1646 __le16 blk_nr_item; /* Number of keys/items in a block. */1647 __le16 blk_free_space; /* Block free space in bytes. */1648 __le16 blk_reserved;1649 /* dump this in v4/planA */1650 1651 /* kept only for compatibility */1652 struct reiserfs_key blk_right_delim_key;1653};1654 1655#define BLKH_SIZE (sizeof(struct block_head))1656#define blkh_level(p_blkh) (le16_to_cpu((p_blkh)->blk_level))1657#define blkh_nr_item(p_blkh) (le16_to_cpu((p_blkh)->blk_nr_item))1658#define blkh_free_space(p_blkh) (le16_to_cpu((p_blkh)->blk_free_space))1659#define blkh_reserved(p_blkh) (le16_to_cpu((p_blkh)->blk_reserved))1660#define set_blkh_level(p_blkh,val) ((p_blkh)->blk_level = cpu_to_le16(val))1661#define set_blkh_nr_item(p_blkh,val) ((p_blkh)->blk_nr_item = cpu_to_le16(val))1662#define set_blkh_free_space(p_blkh,val) ((p_blkh)->blk_free_space = cpu_to_le16(val))1663#define set_blkh_reserved(p_blkh,val) ((p_blkh)->blk_reserved = cpu_to_le16(val))1664#define blkh_right_delim_key(p_blkh) ((p_blkh)->blk_right_delim_key)1665#define set_blkh_right_delim_key(p_blkh,val) ((p_blkh)->blk_right_delim_key = val)1666 1667/* values for blk_level field of the struct block_head */1668 1669/*1670 * When node gets removed from the tree its blk_level is set to FREE_LEVEL.1671 * It is then used to see whether the node is still in the tree1672 */1673#define FREE_LEVEL 01674 1675#define DISK_LEAF_NODE_LEVEL 1 /* Leaf node level. */1676 1677/*1678 * Given the buffer head of a formatted node, resolve to the1679 * block head of that node.1680 */1681#define B_BLK_HEAD(bh) ((struct block_head *)((bh)->b_data))1682/* Number of items that are in buffer. */1683#define B_NR_ITEMS(bh) (blkh_nr_item(B_BLK_HEAD(bh)))1684#define B_LEVEL(bh) (blkh_level(B_BLK_HEAD(bh)))1685#define B_FREE_SPACE(bh) (blkh_free_space(B_BLK_HEAD(bh)))1686 1687#define PUT_B_NR_ITEMS(bh, val) do { set_blkh_nr_item(B_BLK_HEAD(bh), val); } while (0)1688#define PUT_B_LEVEL(bh, val) do { set_blkh_level(B_BLK_HEAD(bh), val); } while (0)1689#define PUT_B_FREE_SPACE(bh, val) do { set_blkh_free_space(B_BLK_HEAD(bh), val); } while (0)1690 1691/* Get right delimiting key. -- little endian */1692#define B_PRIGHT_DELIM_KEY(bh) (&(blk_right_delim_key(B_BLK_HEAD(bh))))1693 1694/* Does the buffer contain a disk leaf. */1695#define B_IS_ITEMS_LEVEL(bh) (B_LEVEL(bh) == DISK_LEAF_NODE_LEVEL)1696 1697/* Does the buffer contain a disk internal node */1698#define B_IS_KEYS_LEVEL(bh) (B_LEVEL(bh) > DISK_LEAF_NODE_LEVEL \1699 && B_LEVEL(bh) <= MAX_HEIGHT)1700 1701/***************************************************************************1702 * STAT DATA *1703 ***************************************************************************/1704 1705/*1706 * old stat data is 32 bytes long. We are going to distinguish new one by1707 * different size1708*/1709struct stat_data_v1 {1710 __le16 sd_mode; /* file type, permissions */1711 __le16 sd_nlink; /* number of hard links */1712 __le16 sd_uid; /* owner */1713 __le16 sd_gid; /* group */1714 __le32 sd_size; /* file size */1715 __le32 sd_atime; /* time of last access */1716 __le32 sd_mtime; /* time file was last modified */1717 1718 /*1719 * time inode (stat data) was last changed1720 * (except changes to sd_atime and sd_mtime)1721 */1722 __le32 sd_ctime;1723 union {1724 __le32 sd_rdev;1725 __le32 sd_blocks; /* number of blocks file uses */1726 } __attribute__ ((__packed__)) u;1727 1728 /*1729 * first byte of file which is stored in a direct item: except that if1730 * it equals 1 it is a symlink and if it equals ~(__u32)0 there is no1731 * direct item. The existence of this field really grates on me.1732 * Let's replace it with a macro based on sd_size and our tail1733 * suppression policy. Someday. -Hans1734 */1735 __le32 sd_first_direct_byte;1736} __attribute__ ((__packed__));1737 1738#define SD_V1_SIZE (sizeof(struct stat_data_v1))1739#define stat_data_v1(ih) (ih_version (ih) == KEY_FORMAT_3_5)1740#define sd_v1_mode(sdp) (le16_to_cpu((sdp)->sd_mode))1741#define set_sd_v1_mode(sdp,v) ((sdp)->sd_mode = cpu_to_le16(v))1742#define sd_v1_nlink(sdp) (le16_to_cpu((sdp)->sd_nlink))1743#define set_sd_v1_nlink(sdp,v) ((sdp)->sd_nlink = cpu_to_le16(v))1744#define sd_v1_uid(sdp) (le16_to_cpu((sdp)->sd_uid))1745#define set_sd_v1_uid(sdp,v) ((sdp)->sd_uid = cpu_to_le16(v))1746#define sd_v1_gid(sdp) (le16_to_cpu((sdp)->sd_gid))1747#define set_sd_v1_gid(sdp,v) ((sdp)->sd_gid = cpu_to_le16(v))1748#define sd_v1_size(sdp) (le32_to_cpu((sdp)->sd_size))1749#define set_sd_v1_size(sdp,v) ((sdp)->sd_size = cpu_to_le32(v))1750#define sd_v1_atime(sdp) (le32_to_cpu((sdp)->sd_atime))1751#define set_sd_v1_atime(sdp,v) ((sdp)->sd_atime = cpu_to_le32(v))1752#define sd_v1_mtime(sdp) (le32_to_cpu((sdp)->sd_mtime))1753#define set_sd_v1_mtime(sdp,v) ((sdp)->sd_mtime = cpu_to_le32(v))1754#define sd_v1_ctime(sdp) (le32_to_cpu((sdp)->sd_ctime))1755#define set_sd_v1_ctime(sdp,v) ((sdp)->sd_ctime = cpu_to_le32(v))1756#define sd_v1_rdev(sdp) (le32_to_cpu((sdp)->u.sd_rdev))1757#define set_sd_v1_rdev(sdp,v) ((sdp)->u.sd_rdev = cpu_to_le32(v))1758#define sd_v1_blocks(sdp) (le32_to_cpu((sdp)->u.sd_blocks))1759#define set_sd_v1_blocks(sdp,v) ((sdp)->u.sd_blocks = cpu_to_le32(v))1760#define sd_v1_first_direct_byte(sdp) \1761 (le32_to_cpu((sdp)->sd_first_direct_byte))1762#define set_sd_v1_first_direct_byte(sdp,v) \1763 ((sdp)->sd_first_direct_byte = cpu_to_le32(v))1764 1765/* inode flags stored in sd_attrs (nee sd_reserved) */1766 1767/*1768 * we want common flags to have the same values as in ext2,1769 * so chattr(1) will work without problems1770 */1771#define REISERFS_IMMUTABLE_FL FS_IMMUTABLE_FL1772#define REISERFS_APPEND_FL FS_APPEND_FL1773#define REISERFS_SYNC_FL FS_SYNC_FL1774#define REISERFS_NOATIME_FL FS_NOATIME_FL1775#define REISERFS_NODUMP_FL FS_NODUMP_FL1776#define REISERFS_SECRM_FL FS_SECRM_FL1777#define REISERFS_UNRM_FL FS_UNRM_FL1778#define REISERFS_COMPR_FL FS_COMPR_FL1779#define REISERFS_NOTAIL_FL FS_NOTAIL_FL1780 1781/* persistent flags that file inherits from the parent directory */1782#define REISERFS_INHERIT_MASK ( REISERFS_IMMUTABLE_FL | \1783 REISERFS_SYNC_FL | \1784 REISERFS_NOATIME_FL | \1785 REISERFS_NODUMP_FL | \1786 REISERFS_SECRM_FL | \1787 REISERFS_COMPR_FL | \1788 REISERFS_NOTAIL_FL )1789 1790/*1791 * Stat Data on disk (reiserfs version of UFS disk inode minus the1792 * address blocks)1793 */1794struct stat_data {1795 __le16 sd_mode; /* file type, permissions */1796 __le16 sd_attrs; /* persistent inode flags */1797 __le32 sd_nlink; /* number of hard links */1798 __le64 sd_size; /* file size */1799 __le32 sd_uid; /* owner */1800 __le32 sd_gid; /* group */1801 __le32 sd_atime; /* time of last access */1802 __le32 sd_mtime; /* time file was last modified */1803 1804 /*1805 * time inode (stat data) was last changed1806 * (except changes to sd_atime and sd_mtime)1807 */1808 __le32 sd_ctime;1809 __le32 sd_blocks;1810 union {1811 __le32 sd_rdev;1812 __le32 sd_generation;1813 } __attribute__ ((__packed__)) u;1814} __attribute__ ((__packed__));1815 1816/* this is 44 bytes long */1817#define SD_SIZE (sizeof(struct stat_data))1818#define SD_V2_SIZE SD_SIZE1819#define stat_data_v2(ih) (ih_version (ih) == KEY_FORMAT_3_6)1820#define sd_v2_mode(sdp) (le16_to_cpu((sdp)->sd_mode))1821#define set_sd_v2_mode(sdp,v) ((sdp)->sd_mode = cpu_to_le16(v))1822/* sd_reserved */1823/* set_sd_reserved */1824#define sd_v2_nlink(sdp) (le32_to_cpu((sdp)->sd_nlink))1825#define set_sd_v2_nlink(sdp,v) ((sdp)->sd_nlink = cpu_to_le32(v))1826#define sd_v2_size(sdp) (le64_to_cpu((sdp)->sd_size))1827#define set_sd_v2_size(sdp,v) ((sdp)->sd_size = cpu_to_le64(v))1828#define sd_v2_uid(sdp) (le32_to_cpu((sdp)->sd_uid))1829#define set_sd_v2_uid(sdp,v) ((sdp)->sd_uid = cpu_to_le32(v))1830#define sd_v2_gid(sdp) (le32_to_cpu((sdp)->sd_gid))1831#define set_sd_v2_gid(sdp,v) ((sdp)->sd_gid = cpu_to_le32(v))1832#define sd_v2_atime(sdp) (le32_to_cpu((sdp)->sd_atime))1833#define set_sd_v2_atime(sdp,v) ((sdp)->sd_atime = cpu_to_le32(v))1834#define sd_v2_mtime(sdp) (le32_to_cpu((sdp)->sd_mtime))1835#define set_sd_v2_mtime(sdp,v) ((sdp)->sd_mtime = cpu_to_le32(v))1836#define sd_v2_ctime(sdp) (le32_to_cpu((sdp)->sd_ctime))1837#define set_sd_v2_ctime(sdp,v) ((sdp)->sd_ctime = cpu_to_le32(v))1838#define sd_v2_blocks(sdp) (le32_to_cpu((sdp)->sd_blocks))1839#define set_sd_v2_blocks(sdp,v) ((sdp)->sd_blocks = cpu_to_le32(v))1840#define sd_v2_rdev(sdp) (le32_to_cpu((sdp)->u.sd_rdev))1841#define set_sd_v2_rdev(sdp,v) ((sdp)->u.sd_rdev = cpu_to_le32(v))1842#define sd_v2_generation(sdp) (le32_to_cpu((sdp)->u.sd_generation))1843#define set_sd_v2_generation(sdp,v) ((sdp)->u.sd_generation = cpu_to_le32(v))1844#define sd_v2_attrs(sdp) (le16_to_cpu((sdp)->sd_attrs))1845#define set_sd_v2_attrs(sdp,v) ((sdp)->sd_attrs = cpu_to_le16(v))1846 1847/***************************************************************************1848 * DIRECTORY STRUCTURE *1849 ***************************************************************************/1850/*1851 * Picture represents the structure of directory items1852 * ________________________________________________1853 * | Array of | | | | | |1854 * | directory |N-1| N-2 | .... | 1st |0th|1855 * | entry headers | | | | | |1856 * |_______________|___|_____|________|_______|___|1857 * <---- directory entries ------>1858 *1859 * First directory item has k_offset component 1. We store "." and ".."1860 * in one item, always, we never split "." and ".." into differing1861 * items. This makes, among other things, the code for removing1862 * directories simpler.1863 */1864#define SD_OFFSET 01865#define SD_UNIQUENESS 01866#define DOT_OFFSET 11867#define DOT_DOT_OFFSET 21868#define DIRENTRY_UNIQUENESS 5001869 1870#define FIRST_ITEM_OFFSET 11871 1872/*1873 * Q: How to get key of object pointed to by entry from entry?1874 *1875 * A: Each directory entry has its header. This header has deh_dir_id1876 * and deh_objectid fields, those are key of object, entry points to1877 */1878 1879/*1880 * NOT IMPLEMENTED:1881 * Directory will someday contain stat data of object1882 */1883 1884struct reiserfs_de_head {1885 __le32 deh_offset; /* third component of the directory entry key */1886 1887 /*1888 * objectid of the parent directory of the object, that is referenced1889 * by directory entry1890 */1891 __le32 deh_dir_id;1892 1893 /* objectid of the object, that is referenced by directory entry */1894 __le32 deh_objectid;1895 __le16 deh_location; /* offset of name in the whole item */1896 1897 /*1898 * whether 1) entry contains stat data (for future), and1899 * 2) whether entry is hidden (unlinked)1900 */1901 __le16 deh_state;1902} __attribute__ ((__packed__));1903#define DEH_SIZE sizeof(struct reiserfs_de_head)1904#define deh_offset(p_deh) (le32_to_cpu((p_deh)->deh_offset))1905#define deh_dir_id(p_deh) (le32_to_cpu((p_deh)->deh_dir_id))1906#define deh_objectid(p_deh) (le32_to_cpu((p_deh)->deh_objectid))1907#define deh_location(p_deh) (le16_to_cpu((p_deh)->deh_location))1908#define deh_state(p_deh) (le16_to_cpu((p_deh)->deh_state))1909 1910#define put_deh_offset(p_deh,v) ((p_deh)->deh_offset = cpu_to_le32((v)))1911#define put_deh_dir_id(p_deh,v) ((p_deh)->deh_dir_id = cpu_to_le32((v)))1912#define put_deh_objectid(p_deh,v) ((p_deh)->deh_objectid = cpu_to_le32((v)))1913#define put_deh_location(p_deh,v) ((p_deh)->deh_location = cpu_to_le16((v)))1914#define put_deh_state(p_deh,v) ((p_deh)->deh_state = cpu_to_le16((v)))1915 1916/* empty directory contains two entries "." and ".." and their headers */1917#define EMPTY_DIR_SIZE \1918(DEH_SIZE * 2 + ROUND_UP (sizeof(".") - 1) + ROUND_UP (sizeof("..") - 1))1919 1920/* old format directories have this size when empty */1921#define EMPTY_DIR_SIZE_V1 (DEH_SIZE * 2 + 3)1922 1923#define DEH_Statdata 0 /* not used now */1924#define DEH_Visible 21925 1926/* 64 bit systems (and the S/390) need to be aligned explicitly -jdm */1927#if BITS_PER_LONG == 64 || defined(__s390__) || defined(__hppa__)1928# define ADDR_UNALIGNED_BITS (3)1929#endif1930 1931/*1932 * These are only used to manipulate deh_state.1933 * Because of this, we'll use the ext2_ bit routines,1934 * since they are little endian1935 */1936#ifdef ADDR_UNALIGNED_BITS1937 1938# define aligned_address(addr) ((void *)((long)(addr) & ~((1UL << ADDR_UNALIGNED_BITS) - 1)))1939# define unaligned_offset(addr) (((int)((long)(addr) & ((1 << ADDR_UNALIGNED_BITS) - 1))) << 3)1940 1941# define set_bit_unaligned(nr, addr) \1942 __test_and_set_bit_le((nr) + unaligned_offset(addr), aligned_address(addr))1943# define clear_bit_unaligned(nr, addr) \1944 __test_and_clear_bit_le((nr) + unaligned_offset(addr), aligned_address(addr))1945# define test_bit_unaligned(nr, addr) \1946 test_bit_le((nr) + unaligned_offset(addr), aligned_address(addr))1947 1948#else1949 1950# define set_bit_unaligned(nr, addr) __test_and_set_bit_le(nr, addr)1951# define clear_bit_unaligned(nr, addr) __test_and_clear_bit_le(nr, addr)1952# define test_bit_unaligned(nr, addr) test_bit_le(nr, addr)1953 1954#endif1955 1956#define mark_de_with_sd(deh) set_bit_unaligned (DEH_Statdata, &((deh)->deh_state))1957#define mark_de_without_sd(deh) clear_bit_unaligned (DEH_Statdata, &((deh)->deh_state))1958#define mark_de_visible(deh) set_bit_unaligned (DEH_Visible, &((deh)->deh_state))1959#define mark_de_hidden(deh) clear_bit_unaligned (DEH_Visible, &((deh)->deh_state))1960 1961#define de_with_sd(deh) test_bit_unaligned (DEH_Statdata, &((deh)->deh_state))1962#define de_visible(deh) test_bit_unaligned (DEH_Visible, &((deh)->deh_state))1963#define de_hidden(deh) !test_bit_unaligned (DEH_Visible, &((deh)->deh_state))1964 1965extern void make_empty_dir_item_v1(char *body, __le32 dirid, __le32 objid,1966 __le32 par_dirid, __le32 par_objid);1967extern void make_empty_dir_item(char *body, __le32 dirid, __le32 objid,1968 __le32 par_dirid, __le32 par_objid);1969 1970/* two entries per block (at least) */1971#define REISERFS_MAX_NAME(block_size) 2551972 1973/*1974 * this structure is used for operations on directory entries. It is1975 * not a disk structure.1976 *1977 * When reiserfs_find_entry or search_by_entry_key find directory1978 * entry, they return filled reiserfs_dir_entry structure1979 */1980struct reiserfs_dir_entry {1981 struct buffer_head *de_bh;1982 int de_item_num;1983 struct item_head *de_ih;1984 int de_entry_num;1985 struct reiserfs_de_head *de_deh;1986 int de_entrylen;1987 int de_namelen;1988 char *de_name;1989 unsigned long *de_gen_number_bit_string;1990 1991 __u32 de_dir_id;1992 __u32 de_objectid;1993 1994 struct cpu_key de_entry_key;1995};1996 1997/*1998 * these defines are useful when a particular member of1999 * a reiserfs_dir_entry is needed2000 */2001 2002/* pointer to file name, stored in entry */2003#define B_I_DEH_ENTRY_FILE_NAME(bh, ih, deh) \2004 (ih_item_body(bh, ih) + deh_location(deh))2005 2006/* length of name */2007#define I_DEH_N_ENTRY_FILE_NAME_LENGTH(ih,deh,entry_num) \2008(I_DEH_N_ENTRY_LENGTH (ih, deh, entry_num) - (de_with_sd (deh) ? SD_SIZE : 0))2009 2010/* hash value occupies bits from 7 up to 30 */2011#define GET_HASH_VALUE(offset) ((offset) & 0x7fffff80LL)2012/* generation number occupies 7 bits starting from 0 up to 6 */2013#define GET_GENERATION_NUMBER(offset) ((offset) & 0x7fLL)2014#define MAX_GENERATION_NUMBER 1272015 2016#define SET_GENERATION_NUMBER(offset,gen_number) (GET_HASH_VALUE(offset)|(gen_number))2017 2018/*2019 * Picture represents an internal node of the reiserfs tree2020 * ______________________________________________________2021 * | | Array of | Array of | Free |2022 * |block | keys | pointers | space |2023 * | head | N | N+1 | |2024 * |______|_______________|___________________|___________|2025 */2026 2027/***************************************************************************2028 * DISK CHILD *2029 ***************************************************************************/2030/*2031 * Disk child pointer:2032 * The pointer from an internal node of the tree to a node that is on disk.2033 */2034struct disk_child {2035 __le32 dc_block_number; /* Disk child's block number. */2036 __le16 dc_size; /* Disk child's used space. */2037 __le16 dc_reserved;2038};2039 2040#define DC_SIZE (sizeof(struct disk_child))2041#define dc_block_number(dc_p) (le32_to_cpu((dc_p)->dc_block_number))2042#define dc_size(dc_p) (le16_to_cpu((dc_p)->dc_size))2043#define put_dc_block_number(dc_p, val) do { (dc_p)->dc_block_number = cpu_to_le32(val); } while(0)2044#define put_dc_size(dc_p, val) do { (dc_p)->dc_size = cpu_to_le16(val); } while(0)2045 2046/* Get disk child by buffer header and position in the tree node. */2047#define B_N_CHILD(bh, n_pos) ((struct disk_child *)\2048((bh)->b_data + BLKH_SIZE + B_NR_ITEMS(bh) * KEY_SIZE + DC_SIZE * (n_pos)))2049 2050/* Get disk child number by buffer header and position in the tree node. */2051#define B_N_CHILD_NUM(bh, n_pos) (dc_block_number(B_N_CHILD(bh, n_pos)))2052#define PUT_B_N_CHILD_NUM(bh, n_pos, val) \2053 (put_dc_block_number(B_N_CHILD(bh, n_pos), val))2054 2055 /* maximal value of field child_size in structure disk_child */2056 /* child size is the combined size of all items and their headers */2057#define MAX_CHILD_SIZE(bh) ((int)( (bh)->b_size - BLKH_SIZE ))2058 2059/* amount of used space in buffer (not including block head) */2060#define B_CHILD_SIZE(cur) (MAX_CHILD_SIZE(cur)-(B_FREE_SPACE(cur)))2061 2062/* max and min number of keys in internal node */2063#define MAX_NR_KEY(bh) ( (MAX_CHILD_SIZE(bh)-DC_SIZE)/(KEY_SIZE+DC_SIZE) )2064#define MIN_NR_KEY(bh) (MAX_NR_KEY(bh)/2)2065 2066/***************************************************************************2067 * PATH STRUCTURES AND DEFINES *2068 ***************************************************************************/2069 2070/*2071 * search_by_key fills up the path from the root to the leaf as it descends2072 * the tree looking for the key. It uses reiserfs_bread to try to find2073 * buffers in the cache given their block number. If it does not find2074 * them in the cache it reads them from disk. For each node search_by_key2075 * finds using reiserfs_bread it then uses bin_search to look through that2076 * node. bin_search will find the position of the block_number of the next2077 * node if it is looking through an internal node. If it is looking through2078 * a leaf node bin_search will find the position of the item which has key2079 * either equal to given key, or which is the maximal key less than the2080 * given key.2081 */2082 2083struct path_element {2084 /* Pointer to the buffer at the path in the tree. */2085 struct buffer_head *pe_buffer;2086 /* Position in the tree node which is placed in the buffer above. */2087 int pe_position;2088};2089 2090/*2091 * maximal height of a tree. don't change this without2092 * changing JOURNAL_PER_BALANCE_CNT2093 */2094#define MAX_HEIGHT 52095 2096/* Must be equals MAX_HEIGHT + FIRST_PATH_ELEMENT_OFFSET */2097#define EXTENDED_MAX_HEIGHT 72098 2099/* Must be equal to at least 2. */2100#define FIRST_PATH_ELEMENT_OFFSET 22101 2102/* Must be equal to FIRST_PATH_ELEMENT_OFFSET - 1 */2103#define ILLEGAL_PATH_ELEMENT_OFFSET 12104 2105/* this MUST be MAX_HEIGHT + 1. See about FEB below */2106#define MAX_FEB_SIZE 62107 2108/*2109 * We need to keep track of who the ancestors of nodes are. When we2110 * perform a search we record which nodes were visited while2111 * descending the tree looking for the node we searched for. This list2112 * of nodes is called the path. This information is used while2113 * performing balancing. Note that this path information may become2114 * invalid, and this means we must check it when using it to see if it2115 * is still valid. You'll need to read search_by_key and the comments2116 * in it, especially about decrement_counters_in_path(), to understand2117 * this structure.2118 *2119 * Paths make the code so much harder to work with and debug.... An2120 * enormous number of bugs are due to them, and trying to write or modify2121 * code that uses them just makes my head hurt. They are based on an2122 * excessive effort to avoid disturbing the precious VFS code.:-( The2123 * gods only know how we are going to SMP the code that uses them.2124 * znodes are the way!2125 */2126 2127#define PATH_READA 0x1 /* do read ahead */2128#define PATH_READA_BACK 0x2 /* read backwards */2129 2130struct treepath {2131 int path_length; /* Length of the array above. */2132 int reada;2133 /* Array of the path elements. */2134 struct path_element path_elements[EXTENDED_MAX_HEIGHT];2135 int pos_in_item;2136};2137 2138#define pos_in_item(path) ((path)->pos_in_item)2139 2140#define INITIALIZE_PATH(var) \2141struct treepath var = {.path_length = ILLEGAL_PATH_ELEMENT_OFFSET, .reada = 0,}2142 2143/* Get path element by path and path position. */2144#define PATH_OFFSET_PELEMENT(path, n_offset) ((path)->path_elements + (n_offset))2145 2146/* Get buffer header at the path by path and path position. */2147#define PATH_OFFSET_PBUFFER(path, n_offset) (PATH_OFFSET_PELEMENT(path, n_offset)->pe_buffer)2148 2149/* Get position in the element at the path by path and path position. */2150#define PATH_OFFSET_POSITION(path, n_offset) (PATH_OFFSET_PELEMENT(path, n_offset)->pe_position)2151 2152#define PATH_PLAST_BUFFER(path) (PATH_OFFSET_PBUFFER((path), (path)->path_length))2153 2154/*2155 * you know, to the person who didn't write this the macro name does not2156 * at first suggest what it does. Maybe POSITION_FROM_PATH_END? Or2157 * maybe we should just focus on dumping paths... -Hans2158 */2159#define PATH_LAST_POSITION(path) (PATH_OFFSET_POSITION((path), (path)->path_length))2160 2161/*2162 * in do_balance leaf has h == 0 in contrast with path structure,2163 * where root has level == 0. That is why we need these defines2164 */2165 2166/* tb->S[h] */2167#define PATH_H_PBUFFER(path, h) \2168 PATH_OFFSET_PBUFFER(path, path->path_length - (h))2169 2170/* tb->F[h] or tb->S[0]->b_parent */2171#define PATH_H_PPARENT(path, h) PATH_H_PBUFFER(path, (h) + 1)2172 2173#define PATH_H_POSITION(path, h) \2174 PATH_OFFSET_POSITION(path, path->path_length - (h))2175 2176/* tb->S[h]->b_item_order */2177#define PATH_H_B_ITEM_ORDER(path, h) PATH_H_POSITION(path, h + 1)2178 2179#define PATH_H_PATH_OFFSET(path, n_h) ((path)->path_length - (n_h))2180 2181static inline void *reiserfs_node_data(const struct buffer_head *bh)2182{2183 return bh->b_data + sizeof(struct block_head);2184}2185 2186/* get key from internal node */2187static inline struct reiserfs_key *internal_key(struct buffer_head *bh,2188 int item_num)2189{2190 struct reiserfs_key *key = reiserfs_node_data(bh);2191 2192 return &key[item_num];2193}2194 2195/* get the item header from leaf node */2196static inline struct item_head *item_head(const struct buffer_head *bh,2197 int item_num)2198{2199 struct item_head *ih = reiserfs_node_data(bh);2200 2201 return &ih[item_num];2202}2203 2204/* get the key from leaf node */2205static inline struct reiserfs_key *leaf_key(const struct buffer_head *bh,2206 int item_num)2207{2208 return &item_head(bh, item_num)->ih_key;2209}2210 2211static inline void *ih_item_body(const struct buffer_head *bh,2212 const struct item_head *ih)2213{2214 return bh->b_data + ih_location(ih);2215}2216 2217/* get item body from leaf node */2218static inline void *item_body(const struct buffer_head *bh, int item_num)2219{2220 return ih_item_body(bh, item_head(bh, item_num));2221}2222 2223static inline struct item_head *tp_item_head(const struct treepath *path)2224{2225 return item_head(PATH_PLAST_BUFFER(path), PATH_LAST_POSITION(path));2226}2227 2228static inline void *tp_item_body(const struct treepath *path)2229{2230 return item_body(PATH_PLAST_BUFFER(path), PATH_LAST_POSITION(path));2231}2232 2233#define get_last_bh(path) PATH_PLAST_BUFFER(path)2234#define get_item_pos(path) PATH_LAST_POSITION(path)2235#define item_moved(ih,path) comp_items(ih, path)2236#define path_changed(ih,path) comp_items (ih, path)2237 2238/* array of the entry headers */2239 /* get item body */2240#define B_I_DEH(bh, ih) ((struct reiserfs_de_head *)(ih_item_body(bh, ih)))2241 2242/*2243 * length of the directory entry in directory item. This define2244 * calculates length of i-th directory entry using directory entry2245 * locations from dir entry head. When it calculates length of 0-th2246 * directory entry, it uses length of whole item in place of entry2247 * location of the non-existent following entry in the calculation.2248 * See picture above.2249 */2250static inline int entry_length(const struct buffer_head *bh,2251 const struct item_head *ih, int pos_in_item)2252{2253 struct reiserfs_de_head *deh;2254 2255 deh = B_I_DEH(bh, ih) + pos_in_item;2256 if (pos_in_item)2257 return deh_location(deh - 1) - deh_location(deh);2258 2259 return ih_item_len(ih) - deh_location(deh);2260}2261 2262/***************************************************************************2263 * MISC *2264 ***************************************************************************/2265 2266/* Size of pointer to the unformatted node. */2267#define UNFM_P_SIZE (sizeof(unp_t))2268#define UNFM_P_SHIFT 22269 2270/* in in-core inode key is stored on le form */2271#define INODE_PKEY(inode) ((struct reiserfs_key *)(REISERFS_I(inode)->i_key))2272 2273#define MAX_UL_INT 0xffffffff2274#define MAX_INT 0x7ffffff2275#define MAX_US_INT 0xffff2276 2277// reiserfs version 2 has max offset 60 bits. Version 1 - 32 bit offset2278static inline loff_t max_reiserfs_offset(struct inode *inode)2279{2280 if (get_inode_item_key_version(inode) == KEY_FORMAT_3_5)2281 return (loff_t) U32_MAX;2282 2283 return (loff_t) ((~(__u64) 0) >> 4);2284}2285 2286#define MAX_KEY_OBJECTID MAX_UL_INT2287 2288#define MAX_B_NUM MAX_UL_INT2289#define MAX_FC_NUM MAX_US_INT2290 2291/* the purpose is to detect overflow of an unsigned short */2292#define REISERFS_LINK_MAX (MAX_US_INT - 1000)2293 2294/*2295 * The following defines are used in reiserfs_insert_item2296 * and reiserfs_append_item2297 */2298#define REISERFS_KERNEL_MEM 0 /* kernel memory mode */2299#define REISERFS_USER_MEM 1 /* user memory mode */2300 2301#define fs_generation(s) (REISERFS_SB(s)->s_generation_counter)2302#define get_generation(s) atomic_read (&fs_generation(s))2303#define FILESYSTEM_CHANGED_TB(tb) (get_generation((tb)->tb_sb) != (tb)->fs_gen)2304#define __fs_changed(gen,s) (gen != get_generation (s))2305#define fs_changed(gen,s) \2306({ \2307 reiserfs_cond_resched(s); \2308 __fs_changed(gen, s); \2309})2310 2311/***************************************************************************2312 * FIXATE NODES *2313 ***************************************************************************/2314 2315#define VI_TYPE_LEFT_MERGEABLE 12316#define VI_TYPE_RIGHT_MERGEABLE 22317 2318/*2319 * To make any changes in the tree we always first find node, that2320 * contains item to be changed/deleted or place to insert a new2321 * item. We call this node S. To do balancing we need to decide what2322 * we will shift to left/right neighbor, or to a new node, where new2323 * item will be etc. To make this analysis simpler we build virtual2324 * node. Virtual node is an array of items, that will replace items of2325 * node S. (For instance if we are going to delete an item, virtual2326 * node does not contain it). Virtual node keeps information about2327 * item sizes and types, mergeability of first and last items, sizes2328 * of all entries in directory item. We use this array of items when2329 * calculating what we can shift to neighbors and how many nodes we2330 * have to have if we do not any shiftings, if we shift to left/right2331 * neighbor or to both.2332 */2333struct virtual_item {2334 int vi_index; /* index in the array of item operations */2335 unsigned short vi_type; /* left/right mergeability */2336 2337 /* length of item that it will have after balancing */2338 unsigned short vi_item_len;2339 2340 struct item_head *vi_ih;2341 const char *vi_item; /* body of item (old or new) */2342 const void *vi_new_data; /* 0 always but paste mode */2343 void *vi_uarea; /* item specific area */2344};2345 2346struct virtual_node {2347 /* this is a pointer to the free space in the buffer */2348 char *vn_free_ptr;2349 2350 unsigned short vn_nr_item; /* number of items in virtual node */2351 2352 /*2353 * size of node , that node would have if it has2354 * unlimited size and no balancing is performed2355 */2356 short vn_size;2357 2358 /* mode of balancing (paste, insert, delete, cut) */2359 short vn_mode;2360 2361 short vn_affected_item_num;2362 short vn_pos_in_item;2363 2364 /* item header of inserted item, 0 for other modes */2365 struct item_head *vn_ins_ih;2366 const void *vn_data;2367 2368 /* array of items (including a new one, excluding item to be deleted) */2369 struct virtual_item *vn_vi;2370};2371 2372/* used by directory items when creating virtual nodes */2373struct direntry_uarea {2374 int flags;2375 __u16 entry_count;2376 __u16 entry_sizes[];2377} __attribute__ ((__packed__));2378 2379/***************************************************************************2380 * TREE BALANCE *2381 ***************************************************************************/2382 2383/*2384 * This temporary structure is used in tree balance algorithms, and2385 * constructed as we go to the extent that its various parts are2386 * needed. It contains arrays of nodes that can potentially be2387 * involved in the balancing of node S, and parameters that define how2388 * each of the nodes must be balanced. Note that in these algorithms2389 * for balancing the worst case is to need to balance the current node2390 * S and the left and right neighbors and all of their parents plus2391 * create a new node. We implement S1 balancing for the leaf nodes2392 * and S0 balancing for the internal nodes (S1 and S0 are defined in2393 * our papers.)2394 */2395 2396/* size of the array of buffers to free at end of do_balance */2397#define MAX_FREE_BLOCK 72398 2399/* maximum number of FEB blocknrs on a single level */2400#define MAX_AMOUNT_NEEDED 22401 2402/* someday somebody will prefix every field in this struct with tb_ */2403struct tree_balance {2404 int tb_mode;2405 int need_balance_dirty;2406 struct super_block *tb_sb;2407 struct reiserfs_transaction_handle *transaction_handle;2408 struct treepath *tb_path;2409 2410 /* array of left neighbors of nodes in the path */2411 struct buffer_head *L[MAX_HEIGHT];2412 2413 /* array of right neighbors of nodes in the path */2414 struct buffer_head *R[MAX_HEIGHT];2415 2416 /* array of fathers of the left neighbors */2417 struct buffer_head *FL[MAX_HEIGHT];2418 2419 /* array of fathers of the right neighbors */2420 struct buffer_head *FR[MAX_HEIGHT];2421 /* array of common parents of center node and its left neighbor */2422 struct buffer_head *CFL[MAX_HEIGHT];2423 2424 /* array of common parents of center node and its right neighbor */2425 struct buffer_head *CFR[MAX_HEIGHT];2426 2427 /*2428 * array of empty buffers. Number of buffers in array equals2429 * cur_blknum.2430 */2431 struct buffer_head *FEB[MAX_FEB_SIZE];2432 struct buffer_head *used[MAX_FEB_SIZE];2433 struct buffer_head *thrown[MAX_FEB_SIZE];2434 2435 /*2436 * array of number of items which must be shifted to the left in2437 * order to balance the current node; for leaves includes item that2438 * will be partially shifted; for internal nodes, it is the number2439 * of child pointers rather than items. It includes the new item2440 * being created. The code sometimes subtracts one to get the2441 * number of wholly shifted items for other purposes.2442 */2443 int lnum[MAX_HEIGHT];2444 2445 /* substitute right for left in comment above */2446 int rnum[MAX_HEIGHT];2447 2448 /*2449 * array indexed by height h mapping the key delimiting L[h] and2450 * S[h] to its item number within the node CFL[h]2451 */2452 int lkey[MAX_HEIGHT];2453 2454 /* substitute r for l in comment above */2455 int rkey[MAX_HEIGHT];2456 2457 /*2458 * the number of bytes by we are trying to add or remove from2459 * S[h]. A negative value means removing.2460 */2461 int insert_size[MAX_HEIGHT];2462 2463 /*2464 * number of nodes that will replace node S[h] after balancing2465 * on the level h of the tree. If 0 then S is being deleted,2466 * if 1 then S is remaining and no new nodes are being created,2467 * if 2 or 3 then 1 or 2 new nodes is being created2468 */2469 int blknum[MAX_HEIGHT];2470 2471 /* fields that are used only for balancing leaves of the tree */2472 2473 /* number of empty blocks having been already allocated */2474 int cur_blknum;2475 2476 /* number of items that fall into left most node when S[0] splits */2477 int s0num;2478 2479 /*2480 * number of bytes which can flow to the left neighbor from the left2481 * most liquid item that cannot be shifted from S[0] entirely2482 * if -1 then nothing will be partially shifted2483 */2484 int lbytes;2485 2486 /*2487 * number of bytes which will flow to the right neighbor from the right2488 * most liquid item that cannot be shifted from S[0] entirely2489 * if -1 then nothing will be partially shifted2490 */2491 int rbytes;2492 2493 2494 /*2495 * index into the array of item headers in2496 * S[0] of the affected item2497 */2498 int item_pos;2499 2500 /* new nodes allocated to hold what could not fit into S */2501 struct buffer_head *S_new[2];2502 2503 /*2504 * number of items that will be placed into nodes in S_new2505 * when S[0] splits2506 */2507 int snum[2];2508 2509 /*2510 * number of bytes which flow to nodes in S_new when S[0] splits2511 * note: if S[0] splits into 3 nodes, then items do not need to be cut2512 */2513 int sbytes[2];2514 2515 int pos_in_item;2516 int zeroes_num;2517 2518 /*2519 * buffers which are to be freed after do_balance finishes2520 * by unfix_nodes2521 */2522 struct buffer_head *buf_to_free[MAX_FREE_BLOCK];2523 2524 /*2525 * kmalloced memory. Used to create virtual node and keep2526 * map of dirtied bitmap blocks2527 */2528 char *vn_buf;2529 2530 int vn_buf_size; /* size of the vn_buf */2531 2532 /* VN starts after bitmap of bitmap blocks */2533 struct virtual_node *tb_vn;2534 2535 /*2536 * saved value of `reiserfs_generation' counter see2537 * FILESYSTEM_CHANGED() macro in reiserfs_fs.h2538 */2539 int fs_gen;2540 2541#ifdef DISPLACE_NEW_PACKING_LOCALITIES2542 /*2543 * key pointer, to pass to block allocator or2544 * another low-level subsystem2545 */2546 struct in_core_key key;2547#endif2548};2549 2550/* These are modes of balancing */2551 2552/* When inserting an item. */2553#define M_INSERT 'i'2554/*2555 * When inserting into (directories only) or appending onto an already2556 * existent item.2557 */2558#define M_PASTE 'p'2559/* When deleting an item. */2560#define M_DELETE 'd'2561/* When truncating an item or removing an entry from a (directory) item. */2562#define M_CUT 'c'2563 2564/* used when balancing on leaf level skipped (in reiserfsck) */2565#define M_INTERNAL 'n'2566 2567/*2568 * When further balancing is not needed, then do_balance does not need2569 * to be called.2570 */2571#define M_SKIP_BALANCING 's'2572#define M_CONVERT 'v'2573 2574/* modes of leaf_move_items */2575#define LEAF_FROM_S_TO_L 02576#define LEAF_FROM_S_TO_R 12577#define LEAF_FROM_R_TO_L 22578#define LEAF_FROM_L_TO_R 32579#define LEAF_FROM_S_TO_SNEW 42580 2581#define FIRST_TO_LAST 02582#define LAST_TO_FIRST 12583 2584/*2585 * used in do_balance for passing parent of node information that has2586 * been gotten from tb struct2587 */2588struct buffer_info {2589 struct tree_balance *tb;2590 struct buffer_head *bi_bh;2591 struct buffer_head *bi_parent;2592 int bi_position;2593};2594 2595static inline struct super_block *sb_from_tb(struct tree_balance *tb)2596{2597 return tb ? tb->tb_sb : NULL;2598}2599 2600static inline struct super_block *sb_from_bi(struct buffer_info *bi)2601{2602 return bi ? sb_from_tb(bi->tb) : NULL;2603}2604 2605/*2606 * there are 4 types of items: stat data, directory item, indirect, direct.2607 * +-------------------+------------+--------------+------------+2608 * | | k_offset | k_uniqueness | mergeable? |2609 * +-------------------+------------+--------------+------------+2610 * | stat data | 0 | 0 | no |2611 * +-------------------+------------+--------------+------------+2612 * | 1st directory item| DOT_OFFSET | DIRENTRY_ .. | no |2613 * | non 1st directory | hash value | UNIQUENESS | yes |2614 * | item | | | |2615 * +-------------------+------------+--------------+------------+2616 * | indirect item | offset + 1 |TYPE_INDIRECT | [1] |2617 * +-------------------+------------+--------------+------------+2618 * | direct item | offset + 1 |TYPE_DIRECT | [2] |2619 * +-------------------+------------+--------------+------------+2620 *2621 * [1] if this is not the first indirect item of the object2622 * [2] if this is not the first direct item of the object2623*/2624 2625struct item_operations {2626 int (*bytes_number) (struct item_head * ih, int block_size);2627 void (*decrement_key) (struct cpu_key *);2628 int (*is_left_mergeable) (struct reiserfs_key * ih,2629 unsigned long bsize);2630 void (*print_item) (struct item_head *, char *item);2631 void (*check_item) (struct item_head *, char *item);2632 2633 int (*create_vi) (struct virtual_node * vn, struct virtual_item * vi,2634 int is_affected, int insert_size);2635 int (*check_left) (struct virtual_item * vi, int free,2636 int start_skip, int end_skip);2637 int (*check_right) (struct virtual_item * vi, int free);2638 int (*part_size) (struct virtual_item * vi, int from, int to);2639 int (*unit_num) (struct virtual_item * vi);2640 void (*print_vi) (struct virtual_item * vi);2641};2642 2643extern struct item_operations *item_ops[TYPE_ANY + 1];2644 2645#define op_bytes_number(ih,bsize) item_ops[le_ih_k_type (ih)]->bytes_number (ih, bsize)2646#define op_is_left_mergeable(key,bsize) item_ops[le_key_k_type (le_key_version (key), key)]->is_left_mergeable (key, bsize)2647#define op_print_item(ih,item) item_ops[le_ih_k_type (ih)]->print_item (ih, item)2648#define op_check_item(ih,item) item_ops[le_ih_k_type (ih)]->check_item (ih, item)2649#define op_create_vi(vn,vi,is_affected,insert_size) item_ops[le_ih_k_type ((vi)->vi_ih)]->create_vi (vn,vi,is_affected,insert_size)2650#define op_check_left(vi,free,start_skip,end_skip) item_ops[(vi)->vi_index]->check_left (vi, free, start_skip, end_skip)2651#define op_check_right(vi,free) item_ops[(vi)->vi_index]->check_right (vi, free)2652#define op_part_size(vi,from,to) item_ops[(vi)->vi_index]->part_size (vi, from, to)2653#define op_unit_num(vi) item_ops[(vi)->vi_index]->unit_num (vi)2654#define op_print_vi(vi) item_ops[(vi)->vi_index]->print_vi (vi)2655 2656#define COMP_SHORT_KEYS comp_short_keys2657 2658/* number of blocks pointed to by the indirect item */2659#define I_UNFM_NUM(ih) (ih_item_len(ih) / UNFM_P_SIZE)2660 2661/*2662 * the used space within the unformatted node corresponding2663 * to pos within the item pointed to by ih2664 */2665#define I_POS_UNFM_SIZE(ih,pos,size) (((pos) == I_UNFM_NUM(ih) - 1 ) ? (size) - ih_free_space(ih) : (size))2666 2667/*2668 * number of bytes contained by the direct item or the2669 * unformatted nodes the indirect item points to2670 */2671 2672/* following defines use reiserfs buffer header and item header */2673 2674/* get stat-data */2675#define B_I_STAT_DATA(bh, ih) ( (struct stat_data * )((bh)->b_data + ih_location(ih)) )2676 2677/* this is 3976 for size==4096 */2678#define MAX_DIRECT_ITEM_LEN(size) ((size) - BLKH_SIZE - 2*IH_SIZE - SD_SIZE - UNFM_P_SIZE)2679 2680/*2681 * indirect items consist of entries which contain blocknrs, pos2682 * indicates which entry, and B_I_POS_UNFM_POINTER resolves to the2683 * blocknr contained by the entry pos points to2684 */2685#define B_I_POS_UNFM_POINTER(bh, ih, pos) \2686 le32_to_cpu(*(((unp_t *)ih_item_body(bh, ih)) + (pos)))2687#define PUT_B_I_POS_UNFM_POINTER(bh, ih, pos, val) \2688 (*(((unp_t *)ih_item_body(bh, ih)) + (pos)) = cpu_to_le32(val))2689 2690struct reiserfs_iget_args {2691 __u32 objectid;2692 __u32 dirid;2693};2694 2695/***************************************************************************2696 * FUNCTION DECLARATIONS *2697 ***************************************************************************/2698 2699#define get_journal_desc_magic(bh) (bh->b_data + bh->b_size - 12)2700 2701#define journal_trans_half(blocksize) \2702 ((blocksize - sizeof(struct reiserfs_journal_desc) - 12) / sizeof(__u32))2703 2704/* journal.c see journal.c for all the comments here */2705 2706/* first block written in a commit. */2707struct reiserfs_journal_desc {2708 __le32 j_trans_id; /* id of commit */2709 2710 /* length of commit. len +1 is the commit block */2711 __le32 j_len;2712 2713 __le32 j_mount_id; /* mount id of this trans */2714 __le32 j_realblock[]; /* real locations for each block */2715};2716 2717#define get_desc_trans_id(d) le32_to_cpu((d)->j_trans_id)2718#define get_desc_trans_len(d) le32_to_cpu((d)->j_len)2719#define get_desc_mount_id(d) le32_to_cpu((d)->j_mount_id)2720 2721#define set_desc_trans_id(d,val) do { (d)->j_trans_id = cpu_to_le32 (val); } while (0)2722#define set_desc_trans_len(d,val) do { (d)->j_len = cpu_to_le32 (val); } while (0)2723#define set_desc_mount_id(d,val) do { (d)->j_mount_id = cpu_to_le32 (val); } while (0)2724 2725/* last block written in a commit */2726struct reiserfs_journal_commit {2727 __le32 j_trans_id; /* must match j_trans_id from the desc block */2728 __le32 j_len; /* ditto */2729 __le32 j_realblock[]; /* real locations for each block */2730};2731 2732#define get_commit_trans_id(c) le32_to_cpu((c)->j_trans_id)2733#define get_commit_trans_len(c) le32_to_cpu((c)->j_len)2734#define get_commit_mount_id(c) le32_to_cpu((c)->j_mount_id)2735 2736#define set_commit_trans_id(c,val) do { (c)->j_trans_id = cpu_to_le32 (val); } while (0)2737#define set_commit_trans_len(c,val) do { (c)->j_len = cpu_to_le32 (val); } while (0)2738 2739/*2740 * this header block gets written whenever a transaction is considered2741 * fully flushed, and is more recent than the last fully flushed transaction.2742 * fully flushed means all the log blocks and all the real blocks are on2743 * disk, and this transaction does not need to be replayed.2744 */2745struct reiserfs_journal_header {2746 /* id of last fully flushed transaction */2747 __le32 j_last_flush_trans_id;2748 2749 /* offset in the log of where to start replay after a crash */2750 __le32 j_first_unflushed_offset;2751 2752 __le32 j_mount_id;2753 /* 12 */ struct journal_params jh_journal;2754};2755 2756/* biggest tunable defines are right here */2757#define JOURNAL_BLOCK_COUNT 8192 /* number of blocks in the journal */2758 2759/* biggest possible single transaction, don't change for now (8/3/99) */2760#define JOURNAL_TRANS_MAX_DEFAULT 10242761#define JOURNAL_TRANS_MIN_DEFAULT 2562762 2763/*2764 * max blocks to batch into one transaction,2765 * don't make this any bigger than 9002766 */2767#define JOURNAL_MAX_BATCH_DEFAULT 9002768#define JOURNAL_MIN_RATIO 22769#define JOURNAL_MAX_COMMIT_AGE 302770#define JOURNAL_MAX_TRANS_AGE 302771#define JOURNAL_PER_BALANCE_CNT (3 * (MAX_HEIGHT-2) + 9)2772#define JOURNAL_BLOCKS_PER_OBJECT(sb) (JOURNAL_PER_BALANCE_CNT * 3 + \2773 2 * (REISERFS_QUOTA_INIT_BLOCKS(sb) + \2774 REISERFS_QUOTA_TRANS_BLOCKS(sb)))2775 2776#ifdef CONFIG_QUOTA2777#define REISERFS_QUOTA_OPTS ((1 << REISERFS_USRQUOTA) | (1 << REISERFS_GRPQUOTA))2778/* We need to update data and inode (atime) */2779#define REISERFS_QUOTA_TRANS_BLOCKS(s) (REISERFS_SB(s)->s_mount_opt & REISERFS_QUOTA_OPTS ? 2 : 0)2780/* 1 balancing, 1 bitmap, 1 data per write + stat data update */2781#define REISERFS_QUOTA_INIT_BLOCKS(s) (REISERFS_SB(s)->s_mount_opt & REISERFS_QUOTA_OPTS ? \2782(DQUOT_INIT_ALLOC*(JOURNAL_PER_BALANCE_CNT+2)+DQUOT_INIT_REWRITE+1) : 0)2783/* same as with INIT */2784#define REISERFS_QUOTA_DEL_BLOCKS(s) (REISERFS_SB(s)->s_mount_opt & REISERFS_QUOTA_OPTS ? \2785(DQUOT_DEL_ALLOC*(JOURNAL_PER_BALANCE_CNT+2)+DQUOT_DEL_REWRITE+1) : 0)2786#else2787#define REISERFS_QUOTA_TRANS_BLOCKS(s) 02788#define REISERFS_QUOTA_INIT_BLOCKS(s) 02789#define REISERFS_QUOTA_DEL_BLOCKS(s) 02790#endif2791 2792/*2793 * both of these can be as low as 1, or as high as you want. The min is the2794 * number of 4k bitmap nodes preallocated on mount. New nodes are allocated2795 * as needed, and released when transactions are committed. On release, if2796 * the current number of nodes is > max, the node is freed, otherwise,2797 * it is put on a free list for faster use later.2798*/2799#define REISERFS_MIN_BITMAP_NODES 102800#define REISERFS_MAX_BITMAP_NODES 1002801 2802/* these are based on journal hash size of 8192 */2803#define JBH_HASH_SHIFT 132804#define JBH_HASH_MASK 81912805 2806#define _jhashfn(sb,block) \2807 (((unsigned long)sb>>L1_CACHE_SHIFT) ^ \2808 (((block)<<(JBH_HASH_SHIFT - 6)) ^ ((block) >> 13) ^ ((block) << (JBH_HASH_SHIFT - 12))))2809#define journal_hash(t,sb,block) ((t)[_jhashfn((sb),(block)) & JBH_HASH_MASK])2810 2811/* We need these to make journal.c code more readable */2812#define journal_find_get_block(s, block) __find_get_block(\2813 file_bdev(SB_JOURNAL(s)->j_bdev_file), block, s->s_blocksize)2814#define journal_getblk(s, block) __getblk(file_bdev(SB_JOURNAL(s)->j_bdev_file),\2815 block, s->s_blocksize)2816#define journal_bread(s, block) __bread(file_bdev(SB_JOURNAL(s)->j_bdev_file),\2817 block, s->s_blocksize)2818 2819enum reiserfs_bh_state_bits {2820 BH_JDirty = BH_PrivateStart, /* buffer is in current transaction */2821 BH_JDirty_wait,2822 /*2823 * disk block was taken off free list before being in a2824 * finished transaction, or written to disk. Can be reused immed.2825 */2826 BH_JNew,2827 BH_JPrepared,2828 BH_JRestore_dirty,2829 BH_JTest, /* debugging only will go away */2830};2831 2832BUFFER_FNS(JDirty, journaled);2833TAS_BUFFER_FNS(JDirty, journaled);2834BUFFER_FNS(JDirty_wait, journal_dirty);2835TAS_BUFFER_FNS(JDirty_wait, journal_dirty);2836BUFFER_FNS(JNew, journal_new);2837TAS_BUFFER_FNS(JNew, journal_new);2838BUFFER_FNS(JPrepared, journal_prepared);2839TAS_BUFFER_FNS(JPrepared, journal_prepared);2840BUFFER_FNS(JRestore_dirty, journal_restore_dirty);2841TAS_BUFFER_FNS(JRestore_dirty, journal_restore_dirty);2842BUFFER_FNS(JTest, journal_test);2843TAS_BUFFER_FNS(JTest, journal_test);2844 2845/* transaction handle which is passed around for all journal calls */2846struct reiserfs_transaction_handle {2847 /*2848 * super for this FS when journal_begin was called. saves calls to2849 * reiserfs_get_super also used by nested transactions to make2850 * sure they are nesting on the right FS _must_ be first2851 * in the handle2852 */2853 struct super_block *t_super;2854 2855 int t_refcount;2856 int t_blocks_logged; /* number of blocks this writer has logged */2857 int t_blocks_allocated; /* number of blocks this writer allocated */2858 2859 /* sanity check, equals the current trans id */2860 unsigned int t_trans_id;2861 2862 void *t_handle_save; /* save existing current->journal_info */2863 2864 /*2865 * if new block allocation occurres, that block2866 * should be displaced from others2867 */2868 unsigned displace_new_blocks:1;2869 2870 struct list_head t_list;2871};2872 2873/*2874 * used to keep track of ordered and tail writes, attached to the buffer2875 * head through b_journal_head.2876 */2877struct reiserfs_jh {2878 struct reiserfs_journal_list *jl;2879 struct buffer_head *bh;2880 struct list_head list;2881};2882 2883void reiserfs_free_jh(struct buffer_head *bh);2884int reiserfs_add_tail_list(struct inode *inode, struct buffer_head *bh);2885int reiserfs_add_ordered_list(struct inode *inode, struct buffer_head *bh);2886int journal_mark_dirty(struct reiserfs_transaction_handle *,2887 struct buffer_head *bh);2888 2889static inline int reiserfs_file_data_log(struct inode *inode)2890{2891 if (reiserfs_data_log(inode->i_sb) ||2892 (REISERFS_I(inode)->i_flags & i_data_log))2893 return 1;2894 return 0;2895}2896 2897static inline int reiserfs_transaction_running(struct super_block *s)2898{2899 struct reiserfs_transaction_handle *th = current->journal_info;2900 if (th && th->t_super == s)2901 return 1;2902 if (th && th->t_super == NULL)2903 BUG();2904 return 0;2905}2906 2907static inline int reiserfs_transaction_free_space(struct reiserfs_transaction_handle *th)2908{2909 return th->t_blocks_allocated - th->t_blocks_logged;2910}2911 2912struct reiserfs_transaction_handle *reiserfs_persistent_transaction(struct2913 super_block2914 *,2915 int count);2916int reiserfs_end_persistent_transaction(struct reiserfs_transaction_handle *);2917void reiserfs_vfs_truncate_file(struct inode *inode);2918int reiserfs_commit_page(struct inode *inode, struct page *page,2919 unsigned from, unsigned to);2920void reiserfs_flush_old_commits(struct super_block *);2921int reiserfs_commit_for_inode(struct inode *);2922int reiserfs_inode_needs_commit(struct inode *);2923void reiserfs_update_inode_transaction(struct inode *);2924void reiserfs_wait_on_write_block(struct super_block *s);2925void reiserfs_block_writes(struct reiserfs_transaction_handle *th);2926void reiserfs_allow_writes(struct super_block *s);2927void reiserfs_check_lock_depth(struct super_block *s, char *caller);2928int reiserfs_prepare_for_journal(struct super_block *, struct buffer_head *bh,2929 int wait);2930void reiserfs_restore_prepared_buffer(struct super_block *,2931 struct buffer_head *bh);2932int journal_init(struct super_block *, const char *j_dev_name, int old_format,2933 unsigned int);2934int journal_release(struct reiserfs_transaction_handle *, struct super_block *);2935int journal_release_error(struct reiserfs_transaction_handle *,2936 struct super_block *);2937int journal_end(struct reiserfs_transaction_handle *);2938int journal_end_sync(struct reiserfs_transaction_handle *);2939int journal_mark_freed(struct reiserfs_transaction_handle *,2940 struct super_block *, b_blocknr_t blocknr);2941int journal_transaction_should_end(struct reiserfs_transaction_handle *, int);2942int reiserfs_in_journal(struct super_block *sb, unsigned int bmap_nr,2943 int bit_nr, int searchall, b_blocknr_t *next);2944int journal_begin(struct reiserfs_transaction_handle *,2945 struct super_block *sb, unsigned long);2946int journal_join_abort(struct reiserfs_transaction_handle *,2947 struct super_block *sb);2948void reiserfs_abort_journal(struct super_block *sb, int errno);2949void reiserfs_abort(struct super_block *sb, int errno, const char *fmt, ...);2950int reiserfs_allocate_list_bitmaps(struct super_block *s,2951 struct reiserfs_list_bitmap *, unsigned int);2952 2953void reiserfs_schedule_old_flush(struct super_block *s);2954void reiserfs_cancel_old_flush(struct super_block *s);2955void add_save_link(struct reiserfs_transaction_handle *th,2956 struct inode *inode, int truncate);2957int remove_save_link(struct inode *inode, int truncate);2958 2959/* objectid.c */2960__u32 reiserfs_get_unused_objectid(struct reiserfs_transaction_handle *th);2961void reiserfs_release_objectid(struct reiserfs_transaction_handle *th,2962 __u32 objectid_to_release);2963int reiserfs_convert_objectid_map_v1(struct super_block *);2964 2965/* stree.c */2966int B_IS_IN_TREE(const struct buffer_head *);2967extern void copy_item_head(struct item_head *to,2968 const struct item_head *from);2969 2970/* first key is in cpu form, second - le */2971extern int comp_short_keys(const struct reiserfs_key *le_key,2972 const struct cpu_key *cpu_key);2973extern void le_key2cpu_key(struct cpu_key *to, const struct reiserfs_key *from);2974 2975/* both are in le form */2976extern int comp_le_keys(const struct reiserfs_key *,2977 const struct reiserfs_key *);2978extern int comp_short_le_keys(const struct reiserfs_key *,2979 const struct reiserfs_key *);2980 2981/* * get key version from on disk key - kludge */2982static inline int le_key_version(const struct reiserfs_key *key)2983{2984 int type;2985 2986 type = offset_v2_k_type(&(key->u.k_offset_v2));2987 if (type != TYPE_DIRECT && type != TYPE_INDIRECT2988 && type != TYPE_DIRENTRY)2989 return KEY_FORMAT_3_5;2990 2991 return KEY_FORMAT_3_6;2992 2993}2994 2995static inline void copy_key(struct reiserfs_key *to,2996 const struct reiserfs_key *from)2997{2998 memcpy(to, from, KEY_SIZE);2999}3000 3001int comp_items(const struct item_head *stored_ih, const struct treepath *path);3002const struct reiserfs_key *get_rkey(const struct treepath *chk_path,3003 const struct super_block *sb);3004int search_by_key(struct super_block *, const struct cpu_key *,3005 struct treepath *, int);3006#define search_item(s,key,path) search_by_key (s, key, path, DISK_LEAF_NODE_LEVEL)3007int search_for_position_by_key(struct super_block *sb,3008 const struct cpu_key *cpu_key,3009 struct treepath *search_path);3010extern void decrement_bcount(struct buffer_head *bh);3011void decrement_counters_in_path(struct treepath *search_path);3012void pathrelse(struct treepath *search_path);3013int reiserfs_check_path(struct treepath *p);3014void pathrelse_and_restore(struct super_block *s, struct treepath *search_path);3015 3016int reiserfs_insert_item(struct reiserfs_transaction_handle *th,3017 struct treepath *path,3018 const struct cpu_key *key,3019 struct item_head *ih,3020 struct inode *inode, const char *body);3021 3022int reiserfs_paste_into_item(struct reiserfs_transaction_handle *th,3023 struct treepath *path,3024 const struct cpu_key *key,3025 struct inode *inode,3026 const char *body, int paste_size);3027 3028int reiserfs_cut_from_item(struct reiserfs_transaction_handle *th,3029 struct treepath *path,3030 struct cpu_key *key,3031 struct inode *inode,3032 struct page *page, loff_t new_file_size);3033 3034int reiserfs_delete_item(struct reiserfs_transaction_handle *th,3035 struct treepath *path,3036 const struct cpu_key *key,3037 struct inode *inode, struct buffer_head *un_bh);3038 3039void reiserfs_delete_solid_item(struct reiserfs_transaction_handle *th,3040 struct inode *inode, struct reiserfs_key *key);3041int reiserfs_delete_object(struct reiserfs_transaction_handle *th,3042 struct inode *inode);3043int reiserfs_do_truncate(struct reiserfs_transaction_handle *th,3044 struct inode *inode, struct page *,3045 int update_timestamps);3046 3047#define i_block_size(inode) ((inode)->i_sb->s_blocksize)3048#define file_size(inode) ((inode)->i_size)3049#define tail_size(inode) (file_size (inode) & (i_block_size (inode) - 1))3050 3051#define tail_has_to_be_packed(inode) (have_large_tails ((inode)->i_sb)?\3052!STORE_TAIL_IN_UNFM_S1(file_size (inode), tail_size(inode), inode->i_sb->s_blocksize):have_small_tails ((inode)->i_sb)?!STORE_TAIL_IN_UNFM_S2(file_size (inode), tail_size(inode), inode->i_sb->s_blocksize):0 )3053 3054void padd_item(char *item, int total_length, int length);3055 3056/* inode.c */3057/* args for the create parameter of reiserfs_get_block */3058#define GET_BLOCK_NO_CREATE 0 /* don't create new blocks or convert tails */3059#define GET_BLOCK_CREATE 1 /* add anything you need to find block */3060#define GET_BLOCK_NO_HOLE 2 /* return -ENOENT for file holes */3061#define GET_BLOCK_READ_DIRECT 4 /* read the tail if indirect item not found */3062#define GET_BLOCK_NO_IMUX 8 /* i_mutex is not held, don't preallocate */3063#define GET_BLOCK_NO_DANGLE 16 /* don't leave any transactions running */3064 3065void reiserfs_read_locked_inode(struct inode *inode,3066 struct reiserfs_iget_args *args);3067int reiserfs_find_actor(struct inode *inode, void *p);3068int reiserfs_init_locked_inode(struct inode *inode, void *p);3069void reiserfs_evict_inode(struct inode *inode);3070int reiserfs_write_inode(struct inode *inode, struct writeback_control *wbc);3071int reiserfs_get_block(struct inode *inode, sector_t block,3072 struct buffer_head *bh_result, int create);3073struct dentry *reiserfs_fh_to_dentry(struct super_block *sb, struct fid *fid,3074 int fh_len, int fh_type);3075struct dentry *reiserfs_fh_to_parent(struct super_block *sb, struct fid *fid,3076 int fh_len, int fh_type);3077int reiserfs_encode_fh(struct inode *inode, __u32 * data, int *lenp,3078 struct inode *parent);3079 3080int reiserfs_truncate_file(struct inode *, int update_timestamps);3081void make_cpu_key(struct cpu_key *cpu_key, struct inode *inode, loff_t offset,3082 int type, int key_length);3083void make_le_item_head(struct item_head *ih, const struct cpu_key *key,3084 int version,3085 loff_t offset, int type, int length, int entry_count);3086struct inode *reiserfs_iget(struct super_block *s, const struct cpu_key *key);3087 3088struct reiserfs_security_handle;3089int reiserfs_new_inode(struct reiserfs_transaction_handle *th,3090 struct inode *dir, umode_t mode,3091 const char *symname, loff_t i_size,3092 struct dentry *dentry, struct inode *inode,3093 struct reiserfs_security_handle *security);3094 3095void reiserfs_update_sd_size(struct reiserfs_transaction_handle *th,3096 struct inode *inode, loff_t size);3097 3098static inline void reiserfs_update_sd(struct reiserfs_transaction_handle *th,3099 struct inode *inode)3100{3101 reiserfs_update_sd_size(th, inode, inode->i_size);3102}3103 3104void sd_attrs_to_i_attrs(__u16 sd_attrs, struct inode *inode);3105int reiserfs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,3106 struct iattr *attr);3107 3108int __reiserfs_write_begin(struct page *page, unsigned from, unsigned len);3109 3110/* namei.c */3111void reiserfs_init_priv_inode(struct inode *inode);3112void set_de_name_and_namelen(struct reiserfs_dir_entry *de);3113int search_by_entry_key(struct super_block *sb, const struct cpu_key *key,3114 struct treepath *path, struct reiserfs_dir_entry *de);3115struct dentry *reiserfs_get_parent(struct dentry *);3116 3117#ifdef CONFIG_REISERFS_PROC_INFO3118int reiserfs_proc_info_init(struct super_block *sb);3119int reiserfs_proc_info_done(struct super_block *sb);3120int reiserfs_proc_info_global_init(void);3121int reiserfs_proc_info_global_done(void);3122 3123#define PROC_EXP( e ) e3124 3125#define __PINFO( sb ) REISERFS_SB(sb) -> s_proc_info_data3126#define PROC_INFO_MAX( sb, field, value ) \3127 __PINFO( sb ).field = \3128 max( REISERFS_SB( sb ) -> s_proc_info_data.field, value )3129#define PROC_INFO_INC( sb, field ) ( ++ ( __PINFO( sb ).field ) )3130#define PROC_INFO_ADD( sb, field, val ) ( __PINFO( sb ).field += ( val ) )3131#define PROC_INFO_BH_STAT( sb, bh, level ) \3132 PROC_INFO_INC( sb, sbk_read_at[ ( level ) ] ); \3133 PROC_INFO_ADD( sb, free_at[ ( level ) ], B_FREE_SPACE( bh ) ); \3134 PROC_INFO_ADD( sb, items_at[ ( level ) ], B_NR_ITEMS( bh ) )3135#else3136static inline int reiserfs_proc_info_init(struct super_block *sb)3137{3138 return 0;3139}3140 3141static inline int reiserfs_proc_info_done(struct super_block *sb)3142{3143 return 0;3144}3145 3146static inline int reiserfs_proc_info_global_init(void)3147{3148 return 0;3149}3150 3151static inline int reiserfs_proc_info_global_done(void)3152{3153 return 0;3154}3155 3156#define PROC_EXP( e )3157#define VOID_V ( ( void ) 0 )3158#define PROC_INFO_MAX( sb, field, value ) VOID_V3159#define PROC_INFO_INC( sb, field ) VOID_V3160#define PROC_INFO_ADD( sb, field, val ) VOID_V3161#define PROC_INFO_BH_STAT(sb, bh, n_node_level) VOID_V3162#endif3163 3164/* dir.c */3165extern const struct inode_operations reiserfs_dir_inode_operations;3166extern const struct inode_operations reiserfs_symlink_inode_operations;3167extern const struct inode_operations reiserfs_special_inode_operations;3168extern const struct file_operations reiserfs_dir_operations;3169int reiserfs_readdir_inode(struct inode *, struct dir_context *);3170 3171/* tail_conversion.c */3172int direct2indirect(struct reiserfs_transaction_handle *, struct inode *,3173 struct treepath *, struct buffer_head *, loff_t);3174int indirect2direct(struct reiserfs_transaction_handle *, struct inode *,3175 struct page *, struct treepath *, const struct cpu_key *,3176 loff_t, char *);3177void reiserfs_unmap_buffer(struct buffer_head *);3178 3179/* file.c */3180extern const struct inode_operations reiserfs_file_inode_operations;3181extern const struct inode_operations reiserfs_priv_file_inode_operations;3182extern const struct file_operations reiserfs_file_operations;3183extern const struct address_space_operations reiserfs_address_space_operations;3184 3185/* fix_nodes.c */3186 3187int fix_nodes(int n_op_mode, struct tree_balance *tb,3188 struct item_head *ins_ih, const void *);3189void unfix_nodes(struct tree_balance *);3190 3191/* prints.c */3192void __reiserfs_panic(struct super_block *s, const char *id,3193 const char *function, const char *fmt, ...)3194 __attribute__ ((noreturn));3195#define reiserfs_panic(s, id, fmt, args...) \3196 __reiserfs_panic(s, id, __func__, fmt, ##args)3197void __reiserfs_error(struct super_block *s, const char *id,3198 const char *function, const char *fmt, ...);3199#define reiserfs_error(s, id, fmt, args...) \3200 __reiserfs_error(s, id, __func__, fmt, ##args)3201void reiserfs_info(struct super_block *s, const char *fmt, ...);3202void reiserfs_debug(struct super_block *s, int level, const char *fmt, ...);3203void print_indirect_item(struct buffer_head *bh, int item_num);3204void store_print_tb(struct tree_balance *tb);3205void print_cur_tb(char *mes);3206void print_de(struct reiserfs_dir_entry *de);3207void print_bi(struct buffer_info *bi, char *mes);3208#define PRINT_LEAF_ITEMS 1 /* print all items */3209#define PRINT_DIRECTORY_ITEMS 2 /* print directory items */3210#define PRINT_DIRECT_ITEMS 4 /* print contents of direct items */3211void print_block(struct buffer_head *bh, ...);3212void print_bmap(struct super_block *s, int silent);3213void print_bmap_block(int i, char *data, int size, int silent);3214/*void print_super_block (struct super_block * s, char * mes);*/3215void print_objectid_map(struct super_block *s);3216void print_block_head(struct buffer_head *bh, char *mes);3217void check_leaf(struct buffer_head *bh);3218void check_internal(struct buffer_head *bh);3219void print_statistics(struct super_block *s);3220char *reiserfs_hashname(int code);3221 3222/* lbalance.c */3223int leaf_move_items(int shift_mode, struct tree_balance *tb, int mov_num,3224 int mov_bytes, struct buffer_head *Snew);3225int leaf_shift_left(struct tree_balance *tb, int shift_num, int shift_bytes);3226int leaf_shift_right(struct tree_balance *tb, int shift_num, int shift_bytes);3227void leaf_delete_items(struct buffer_info *cur_bi, int last_first, int first,3228 int del_num, int del_bytes);3229void leaf_insert_into_buf(struct buffer_info *bi, int before,3230 struct item_head * const inserted_item_ih,3231 const char * const inserted_item_body,3232 int zeros_number);3233void leaf_paste_in_buffer(struct buffer_info *bi, int pasted_item_num,3234 int pos_in_item, int paste_size,3235 const char * const body, int zeros_number);3236void leaf_cut_from_buffer(struct buffer_info *bi, int cut_item_num,3237 int pos_in_item, int cut_size);3238void leaf_paste_entries(struct buffer_info *bi, int item_num, int before,3239 int new_entry_count, struct reiserfs_de_head *new_dehs,3240 const char *records, int paste_size);3241/* ibalance.c */3242int balance_internal(struct tree_balance *, int, int, struct item_head *,3243 struct buffer_head **);3244 3245/* do_balance.c */3246void do_balance_mark_leaf_dirty(struct tree_balance *tb,3247 struct buffer_head *bh, int flag);3248#define do_balance_mark_internal_dirty do_balance_mark_leaf_dirty3249#define do_balance_mark_sb_dirty do_balance_mark_leaf_dirty3250 3251void do_balance(struct tree_balance *tb, struct item_head *ih,3252 const char *body, int flag);3253void reiserfs_invalidate_buffer(struct tree_balance *tb,3254 struct buffer_head *bh);3255 3256int get_left_neighbor_position(struct tree_balance *tb, int h);3257int get_right_neighbor_position(struct tree_balance *tb, int h);3258void replace_key(struct tree_balance *tb, struct buffer_head *, int,3259 struct buffer_head *, int);3260void make_empty_node(struct buffer_info *);3261struct buffer_head *get_FEB(struct tree_balance *);3262 3263/* bitmap.c */3264 3265/*3266 * structure contains hints for block allocator, and it is a container for3267 * arguments, such as node, search path, transaction_handle, etc.3268 */3269struct __reiserfs_blocknr_hint {3270 /* inode passed to allocator, if we allocate unf. nodes */3271 struct inode *inode;3272 3273 sector_t block; /* file offset, in blocks */3274 struct in_core_key key;3275 3276 /*3277 * search path, used by allocator to deternine search_start by3278 * various ways3279 */3280 struct treepath *path;3281 3282 /*3283 * transaction handle is needed to log super blocks3284 * and bitmap blocks changes3285 */3286 struct reiserfs_transaction_handle *th;3287 3288 b_blocknr_t beg, end;3289 3290 /*3291 * a field used to transfer search start value (block number)3292 * between different block allocator procedures3293 * (determine_search_start() and others)3294 */3295 b_blocknr_t search_start;3296 3297 /*3298 * is set in determine_prealloc_size() function,3299 * used by underlayed function that do actual allocation3300 */3301 int prealloc_size;3302 3303 /*3304 * the allocator uses different polices for getting disk3305 * space for formatted/unformatted blocks with/without preallocation3306 */3307 unsigned formatted_node:1;3308 unsigned preallocate:1;3309};3310 3311typedef struct __reiserfs_blocknr_hint reiserfs_blocknr_hint_t;3312 3313int reiserfs_parse_alloc_options(struct super_block *, char *);3314void reiserfs_init_alloc_options(struct super_block *s);3315 3316/*3317 * given a directory, this will tell you what packing locality3318 * to use for a new object underneat it. The locality is returned3319 * in disk byte order (le).3320 */3321__le32 reiserfs_choose_packing(struct inode *dir);3322 3323void show_alloc_options(struct seq_file *seq, struct super_block *s);3324int reiserfs_init_bitmap_cache(struct super_block *sb);3325void reiserfs_free_bitmap_cache(struct super_block *sb);3326void reiserfs_cache_bitmap_metadata(struct super_block *sb, struct buffer_head *bh, struct reiserfs_bitmap_info *info);3327struct buffer_head *reiserfs_read_bitmap_block(struct super_block *sb, unsigned int bitmap);3328int is_reusable(struct super_block *s, b_blocknr_t block, int bit_value);3329void reiserfs_free_block(struct reiserfs_transaction_handle *th, struct inode *,3330 b_blocknr_t, int for_unformatted);3331int reiserfs_allocate_blocknrs(reiserfs_blocknr_hint_t *, b_blocknr_t *, int,3332 int);3333static inline int reiserfs_new_form_blocknrs(struct tree_balance *tb,3334 b_blocknr_t * new_blocknrs,3335 int amount_needed)3336{3337 reiserfs_blocknr_hint_t hint = {3338 .th = tb->transaction_handle,3339 .path = tb->tb_path,3340 .inode = NULL,3341 .key = tb->key,3342 .block = 0,3343 .formatted_node = 13344 };3345 return reiserfs_allocate_blocknrs(&hint, new_blocknrs, amount_needed,3346 0);3347}3348 3349static inline int reiserfs_new_unf_blocknrs(struct reiserfs_transaction_handle3350 *th, struct inode *inode,3351 b_blocknr_t * new_blocknrs,3352 struct treepath *path,3353 sector_t block)3354{3355 reiserfs_blocknr_hint_t hint = {3356 .th = th,3357 .path = path,3358 .inode = inode,3359 .block = block,3360 .formatted_node = 0,3361 .preallocate = 03362 };3363 return reiserfs_allocate_blocknrs(&hint, new_blocknrs, 1, 0);3364}3365 3366#ifdef REISERFS_PREALLOCATE3367static inline int reiserfs_new_unf_blocknrs2(struct reiserfs_transaction_handle3368 *th, struct inode *inode,3369 b_blocknr_t * new_blocknrs,3370 struct treepath *path,3371 sector_t block)3372{3373 reiserfs_blocknr_hint_t hint = {3374 .th = th,3375 .path = path,3376 .inode = inode,3377 .block = block,3378 .formatted_node = 0,3379 .preallocate = 13380 };3381 return reiserfs_allocate_blocknrs(&hint, new_blocknrs, 1, 0);3382}3383 3384void reiserfs_discard_prealloc(struct reiserfs_transaction_handle *th,3385 struct inode *inode);3386void reiserfs_discard_all_prealloc(struct reiserfs_transaction_handle *th);3387#endif3388 3389/* hashes.c */3390__u32 keyed_hash(const signed char *msg, int len);3391__u32 yura_hash(const signed char *msg, int len);3392__u32 r5_hash(const signed char *msg, int len);3393 3394#define reiserfs_set_le_bit __set_bit_le3395#define reiserfs_test_and_set_le_bit __test_and_set_bit_le3396#define reiserfs_clear_le_bit __clear_bit_le3397#define reiserfs_test_and_clear_le_bit __test_and_clear_bit_le3398#define reiserfs_test_le_bit test_bit_le3399#define reiserfs_find_next_zero_le_bit find_next_zero_bit_le3400 3401/*3402 * sometimes reiserfs_truncate may require to allocate few new blocks3403 * to perform indirect2direct conversion. People probably used to3404 * think, that truncate should work without problems on a filesystem3405 * without free disk space. They may complain that they can not3406 * truncate due to lack of free disk space. This spare space allows us3407 * to not worry about it. 500 is probably too much, but it should be3408 * absolutely safe3409 */3410#define SPARE_SPACE 5003411 3412/* prototypes from ioctl.c */3413int reiserfs_fileattr_get(struct dentry *dentry, struct fileattr *fa);3414int reiserfs_fileattr_set(struct mnt_idmap *idmap,3415 struct dentry *dentry, struct fileattr *fa);3416long reiserfs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);3417long reiserfs_compat_ioctl(struct file *filp,3418 unsigned int cmd, unsigned long arg);3419int reiserfs_unpack(struct inode *inode);3420