vfs: add init and exit support
Subsystems (4)
RFC 6/11 vfs: add init and exit support
From: Zhi Yong Wu <[email protected]>
Add initialization function to create some
key data structures when hot tracking is enabled;
Clean up them when hot tracking is disabled.
--- fs/hot_rb.c | 45 +++++++++++++++++++++++++++++++++++++++++++++ fs/hot_rb.h | 6 ++++++ fs/hot_track.c | 15 +++++++++++++++ fs/hot_track.h | 2 ++ fs/namespace.c | 4 ++++ fs/super.c | 6 ++++++ 6 files changed, 78 insertions(+), 0 deletions(-)
fs/hot_rb.c +45 -0
@@ -133,6 +133,33 @@ void hot_rb_free_hot_range_item(struct hot_range_item *hr) } } +/* Frees the entire hot_inode_tree. */ +void hot_rb_free_hot_inode_tree (struct hot_info *root) +{ +struct rb_node *node, *node2; +struct hot_inode_item *he; +struct hot_range_item *hr; + +/* Free hot inode and range trees on fs root */ + node =rb_first (&root->hot_inode_tree.map); + +while (node) { + he = rb_entry(node, struct hot_inode_item, rb_node); + + node2 =rb_first (&he->hot_range_tree.map); +while (node2) { + hr = rb_entry(node2, struct hot_range_item, rb_node); +hot_rb_remove_hot_range_item (&he->hot_range_tree, hr); +hot_rb_free_hot_range_item (hr); + node2 =rb_first (&he->hot_range_tree.map); + } + +hot_rb_remove_hot_inode_item (&root->hot_inode_tree, he); +hot_rb_free_hot_inode_item (he); + node =rb_first (&root->hot_inode_tree.map); + } +} +static struct rb_node *hot_rb_insert_hot_inode_item (struct rb_root *root,unsigned long inode_num,struct rb_node *node)
@@ -309,6 +336,24 @@ struct hot_range_itemreturn NULL ; } +int hot_rb_remove_hot_inode_item (struct hot_inode_tree *tree, +struct hot_inode_item *he) +{ +int ret =0 ; +rb_erase (&he->rb_node, &tree->map); + he->in_tree =0 ; +return ret; +} + +int hot_rb_remove_hot_range_item (struct hot_range_tree *tree, +struct hot_range_item *hr) +{ +int ret =0 ; +rb_erase (&hr->rb_node, &tree->map); + hr->in_tree =0 ; +return ret; +} +/* Update inode frequency struct */ static struct hot_inode_item *hot_rb_update_inode_freq (struct inode *inode,int rw)
fs/hot_rb.h +6 -0
@@ -46,8 +46,14 @@ int hot_rb_add_hot_inode_item(struct hot_inode_tree *tree,int hot_rb_add_hot_range_item (struct hot_range_tree *tree,struct hot_range_item *hr); +int hot_rb_remove_hot_inode_item (struct hot_inode_tree *tree, +struct hot_inode_item *he); +int hot_rb_remove_hot_range_item (struct hot_range_tree *tree, +struct hot_range_item *hr); +void hot_rb_free_hot_inode_item (struct hot_inode_item *he);void hot_rb_free_hot_range_item (struct hot_range_item *hr); +void hot_rb_free_hot_inode_tree (struct hot_info *root);int __init hot_rb_item_cache_init (void );
fs/hot_track.c +15 -0
@@ -58,3 +58,18 @@ void __init hot_track_item_cache_init(void)if (hot_rb_item_cache_init ())return ; } + +/* +* Initialize the data structures for hot data tracking. +*/ +void hot_track_init (struct super_block *sb,const char *name) +{ + sb->s_hotinfo.mount_opt |=HOT_MOUNT_HOT_TRACK ; +hot_rb_inode_tree_init (&sb->s_hotinfo.hot_inode_tree); +} + +void hot_track_exit (struct super_block *sb) +{ + sb->s_hotinfo.mount_opt &= ~HOT_MOUNT_HOT_TRACK ; +hot_rb_free_hot_inode_tree (&sb->s_hotinfo); +}
fs/hot_track.h +2 -0
@@ -17,5 +17,7 @@bool hot_track_parse_options (char *options);void __init hot_track_item_cache_init (void ); +void hot_track_init (struct super_block *sb,const char *name); +void hot_track_exit (struct super_block *sb);#endif /* __HOT_TRACK__ */
fs/namespace.c +4 -0
@@ -22,6 +22,7 @@#include <linux/uaccess.h> #include "pnode.h" #include "internal.h" +#include "hot_track.h" #define HASH_SHIFT ilog2(PAGE_SIZE / sizeof(struct list_head))#define HASH_SIZE (1UL << HASH_SHIFT)
@@ -1215,6 +1216,9 @@ static int do_umount(struct mount *mnt, int flags)return retval; } +if (sb->s_hotinfo.mount_opt &HOT_MOUNT_HOT_TRACK ) +hot_track_exit (sb); +down_write (&namespace_sem);br_write_lock (&vfsmount_lock); event++;
fs/super.c +6 -0
@@ -1153,6 +1153,9 @@ mount_fs(struct file_system_type *type, int flags, const char *name, void *data)WARN_ON (sb->s_bdi == &default_backing_dev_info); sb->s_flags |=MS_BORN ; +if (hottrack) +hot_track_init (sb, name); + error =security_sb_kern_mount (sb, flags, secdata);if (error) goto out_sb;
@@ -1170,6 +1173,9 @@ mount_fs(struct file_system_type *type, int flags, const char *name, void *data)free_secdata (secdata);return root; out_sb: +if (hottrack) +hot_track_exit (sb); +dput (root);deactivate_locked_super (sb); out_free_secdata:
Signature · 1 line
1.7.6.5
RFC 7/11 vfs: introduce one hash table
From: Zhi Yong Wu <[email protected]>
Adds a hash table structure which contains
a lot of hash list and is used to efficiently look up the data temperature of a file or its ranges.
In each hash list of hash table, the hash node
will keep track of temperature info.
--- fs/Makefile | 2 +- fs/hot_hash.c | 66 +++++++++++++++++++++++++++++++++++++++++++++ fs/hot_hash.h | 26 +++++++++++++++++ fs/hot_rb.c | 20 +++++++++++++ fs/hot_rb.h | 2 + fs/hot_track.c | 6 ++++ fs/hot_track.h | 1 + include/linux/hot_track.h | 38 ++++++++++++++++++++++++++ 8 files changed, 160 insertions(+), 1 deletions(-) create mode 100644 fs/hot_hash.c create mode 100644 fs/hot_hash.h
fs/Makefile +1 -1
@@ -12,7 +12,7 @@ obj-y := open.o read_write.o file_table.o super.o \ seq_file.o xattr.o libfs.o fs-writeback.o \ pnode.o drop_caches.o splice.o sync.o utimes.o \ stack.o fs_struct.o statfs.o \ - hot_rb.o hot_track.o + hot_rb.o hot_track.o hot_hash.o ifeq ($(CONFIG_BLOCK),y) obj-y += buffer.o bio.o block_dev.o direct-io.o mpage.o ioprio.o
fs/hot_hash.c new file +66 -0
66 lines not on this page · raw message
fs/hot_hash.h new file +26 -0
@@ -0,0 +1,26 @@ +/* +* fs/hot_hash.h +* +* Copyright (C) 2012 IBM Corp. All rights reserved. +* Written by Zhi Yong Wu <[email protected]> +* Ben Chociej <[email protected]> +* +* This program is free software; you can redistribute it and/or +* modify it under the terms of the GNU General Public +* License v2 as published by the Free Software Foundation. +*/ + +#ifndef __HOT_HASH__ +#define __HOT_HASH__ + +#include <linux/list.h> +#include <linux/hash.h> +#include <linux/hot_track.h> + +void hot_hash_heat_node_init (void *_node); + +int __init hot_hash_node_cache_init (void ); + +void hot_hash_heat_rwlock_init (struct hot_info *root); + +#endif /* __HOT_HASH__ */
fs/hot_rb.c +20 -0
@@ -68,6 +68,18 @@ inode_err:return -ENOMEM ; } +void hot_rb_inode_item_exit (void ) +{ +if (hot_inode_item_cache) +kmem_cache_destroy (hot_inode_item_cache); +} + +void hot_rb_range_item_exit (void ) +{ +if (hot_range_item_cache) +kmem_cache_destroy (hot_range_item_cache); +} +/* * Initialize a new hot_inode_item structure. The new structure is * returned with a reference count of one and needs to be
@@ -80,6 +92,10 @@ void hot_rb_inode_item_init(void *_item)memset (he,0 ,sizeof (*he));kref_init (&he->refs);spin_lock_init (&he->lock); + he->heat_node =kmem_cache_alloc (hot_hash_node_cache, +GFP_KERNEL |GFP_NOFS ); +hot_hash_heat_node_init (he->heat_node); + he->heat_node->hot_freq_data = &he->hot_freq_data; he->hot_freq_data.avg_delta_reads = (u64) -1 ; he->hot_freq_data.avg_delta_writes = (u64) -1 ; he->hot_freq_data.flags =FREQ_DATA_TYPE_INODE ;
@@ -98,6 +114,10 @@ void hot_rb_range_item_init(void *_item)memset (hr,0 ,sizeof (*hr));kref_init (&hr->refs);spin_lock_init (&hr->lock); + hr->heat_node =kmem_cache_alloc (hot_hash_node_cache, +GFP_KERNEL |GFP_NOFS ); +hot_hash_heat_node_init (hr->heat_node); + hr->heat_node->hot_freq_data = &hr->hot_freq_data; hr->hot_freq_data.avg_delta_reads = (u64) -1 ; hr->hot_freq_data.avg_delta_writes = (u64) -1 ; hr->hot_freq_data.flags =FREQ_DATA_TYPE_RANGE ;
fs/hot_rb.h +2 -0
@@ -57,6 +57,8 @@ void hot_rb_free_hot_inode_tree(struct hot_info *root);int __init hot_rb_item_cache_init (void ); +void hot_rb_inode_item_exit (void ); +void hot_rb_range_item_exit (void );void hot_rb_update_freq (struct hot_freq_data *freq_data,int rw);void hot_rb_update_freqs (struct inode *inode,u64 start,u64 len,int rw);
fs/hot_track.c +6 -0
@@ -57,6 +57,11 @@ void __init hot_track_item_cache_init(void) {if (hot_rb_item_cache_init ())return ; + +if (hot_hash_node_cache_init ()) { +hot_rb_inode_item_exit (); +hot_rb_range_item_exit (); + } }/*
@@ -66,6 +71,7 @@ void hot_track_init(struct super_block *sb, const char *name) { sb->s_hotinfo.mount_opt |=HOT_MOUNT_HOT_TRACK ;hot_rb_inode_tree_init (&sb->s_hotinfo.hot_inode_tree); +hot_hash_heat_rwlock_init (&sb->s_hotinfo); }void hot_track_exit (struct super_block *sb)
fs/hot_track.h +1 -0
@@ -14,6 +14,7 @@#define __HOT_TRACK__#include "hot_rb.h" +#include "hot_hash.h" bool hot_track_parse_options (char *options);void __init hot_track_item_cache_init (void );
include/linux/hot_track.h +38 -0
@@ -20,11 +20,17 @@#include <linux/rbtree.h> #include <linux/kref.h> +#define HEAT_HASH_BITS 8 +#define HEAT_HASH_SIZE (1 << HEAT_HASH_BITS) +/* * Flags for hot data tracking mount options. */ #define HOT_MOUNT_HOT_TRACK (1 << 0) +/* kmem_cache pointers for slab caches */ +extern struct kmem_cache *hot_hash_node_cache; +/* A tree that sits on the hot_info */ struct hot_inode_tree {struct rb_root map;
@@ -52,6 +58,28 @@ struct hot_freq_data {u32 last_temperature; }; +/* Hash list heads for hot hash table */ +struct hot_hash_head { +struct hlist_head hashhead; +rwlock_t rwlock; +u32 temperature; +}; + +/* Nodes stored in each hash list of hash table */ +struct hot_hash_node { +struct hlist_node hashnode; +struct list_head node; +struct hot_freq_data *hot_freq_data; +struct hot_hash_head *hlist; +spinlock_t lock;/* protects hlist */ + +/* +* number of references to this node +* equals 1 (hashlist entry) +*/ +struct kref refs; +}; +/* An item representing an inode and its access frequency */ struct hot_inode_item {/* node for hot_inode_tree rb_tree */
@@ -68,6 +96,8 @@ struct hot_inode_item {spinlock_t lock;/* prevents kfree */ struct kref refs; +/* hashlist node for this inode */ +struct hot_hash_node *heat_node; };/*
@@ -91,6 +121,8 @@ struct hot_range_item {spinlock_t lock;/* prevents kfree */ struct kref refs; +/* hashlist node for this range */ +struct hot_hash_node *heat_node; };struct hot_info {
@@ -98,6 +130,12 @@ struct hot_info {/* red-black tree that keeps track of fs-wide hot data */ struct hot_inode_tree hot_inode_tree; + +/* hash map of inode temperature */ +struct hot_hash_head heat_inode_hl[HEAT_HASH_SIZE ]; + +/* hash map of range temperature */ + struct hot_hash_head heat_range_hl[HEAT_HASH_SIZE]; };#endif /* _LINUX_HOTTRACK_H */
Signature · 1 line
1.7.6.5
RFC 8/11 vfs: enable hot data tracking
In reply to [email protected]From: Zhi Yong Wu <[email protected]>
Miscellaneous features that implement hot data tracking
and generally make the hot data functions a bit more friendly.
--- fs/direct-io.c | 10 ++++++++++ include/linux/hot_track.h | 11 +++++++++++ mm/filemap.c | 8 ++++++++ mm/page-writeback.c | 21 +++++++++++++++++++++ mm/readahead.c | 9 +++++++++ 5 files changed, 59 insertions(+), 0 deletions(-)
fs/direct-io.c +10 -0
@@ -37,6 +37,7 @@#include <linux/uio.h> #include <linux/atomic.h> #include <linux/prefetch.h> +#include <linux/hot_track.h> /* * How many user pages to map in one call to get_user_pages(). This determines
@@ -1297,6 +1298,15 @@ __blockdev_direct_IO(int rw, struct kiocb *iocb, struct inode *inode,prefetch (bdev->bd_queue);prefetch ((char *)bdev->bd_queue +SMP_CACHE_BYTES ); +/* Hot data tracking */ +if (TRACK_THIS_INODE (iocb->ki_filp->f_mapping->host) + &&iov_length (iov, nr_segs) >0 ) { +hot_rb_update_freqs (iocb->ki_filp->f_mapping->host, + (u64 )offset, + (u64 )iov_length (iov, nr_segs), + rw &WRITE ); + } +return do_blockdev_direct_IO (rw, iocb, inode, bdev, iov, offset, nr_segs, get_block, end_io, submit_io, flags);
include/linux/hot_track.h +11 -0
@@ -28,6 +28,14 @@*/ #define HOT_MOUNT_HOT_TRACK (1 << 0) +/* Hot data tracking -- guard macros */ +#define TRACKING_HOT_TRACK (root) \ + (root->s_hotinfo.mount_opt & HOT_MOUNT_HOT_TRACK) + +#define TRACK_THIS_INODE (inode) \ + ((TRACKING_HOT_TRACK(inode->i_sb)) && \ + !(inode->i_flags & S_NOHOTDATATRACK)) +/* kmem_cache pointers for slab caches */ extern struct kmem_cache *hot_hash_node_cache;
@@ -138,4 +146,7 @@ struct hot_info { struct hot_hash_head heat_range_hl[HEAT_HASH_SIZE]; }; +extern void hot_rb_update_freqs (struct inode *inode, +u64 start,u64 len,int rw); +#endif /* _LINUX_HOTTRACK_H */
mm/filemap.c +8 -0
@@ -33,6 +33,7 @@#include <linux/hardirq.h> /* for BUG_ON(!in_atomic()) only */ #include <linux/memcontrol.h> #include <linux/cleancache.h> +#include <linux/hot_track.h> #include "internal.h" /*
@@ -1224,6 +1225,13 @@ readpage:* PG_error will be set again if readpage fails. */ ClearPageError (page); + +/* Hot data tracking */ +if (TRACK_THIS_INODE (filp->f_mapping->host)) +hot_rb_update_freqs (filp->f_mapping->host, + (u64 )page->index <<PAGE_CACHE_SHIFT , +PAGE_CACHE_SIZE ,0 ); +/* Start the actual read. The read will unlock the page. */ error = mapping->a_ops->readpage (filp, page);
mm/page-writeback.c +21 -0
@@ -35,6 +35,7 @@#include <linux/buffer_head.h> /* __set_page_dirty_buffers */ #include <linux/pagevec.h> #include <linux/timer.h> +#include <linux/hot_track.h> #include <trace/events/writeback.h> /*
@@ -1895,13 +1896,33 @@ EXPORT_SYMBOL(generic_writepages);int do_writepages (struct address_space *mapping,struct writeback_control *wbc) {int ret; +pgoff_t start =0 ; +u64 prev_count =0 , count =0 ;if (wbc->nr_to_write <=0 )return 0 ; + +/* Hot data tracking */ +if (TRACK_THIS_INODE (mapping->host) + && wbc->range_cyclic) { + start = mapping->writeback_index <<PAGE_CACHE_SHIFT ; + prev_count = (u64 )wbc->nr_to_write; + } +if (mapping->a_ops->writepages) ret = mapping->a_ops->writepages (mapping, wbc);else ret =generic_writepages (mapping, wbc); + +/* Hot data tracking */ +if (TRACK_THIS_INODE (mapping->host) + && wbc->range_cyclic) { + count = prev_count - (u64 )wbc->nr_to_write; +if (count) +hot_rb_update_freqs (mapping->host, (u64 )start, + count *PAGE_CACHE_SIZE ,1 ); + } +return ret; }
mm/readahead.c +9 -0
@@ -19,6 +19,7 @@#include <linux/pagemap.h> #include <linux/syscalls.h> #include <linux/file.h> +#include <linux/hot_track.h> /* * Initialise a struct file's readahead state. Assumes that the caller has
@@ -138,6 +139,14 @@ static int read_pages(struct address_space *mapping, struct file *filp, out:blk_finish_plug (&plug); +/* Hot data tracking */ +if (TRACK_THIS_INODE (mapping->host) && nr_pages >0 ) { +u64 start = (u64)(list_entry (pages->prev, + struct page, lru)->index) << PAGE_CACHE_SHIFT; +hot_rb_update_freqs (mapping->host, start, + (u64 )nr_pages *PAGE_CACHE_SIZE ,0 ); + } +return ret; }
Signature · 1 line
1.7.6.5
RFC 9/11 vfs: fork one private kthread to update temperature info
In reply to [email protected]From: Zhi Yong Wu <[email protected]>
Fork and run one kernel kthread to calculate
that temperature based on some metrics kept
in custom frequency data structs, and store
the info in the hash table.
--- fs/hot_hash.c | 316 +++++++++++++++++++++++++++++++++++++++++++++ fs/hot_hash.h | 86 ++++++++++++ fs/hot_rb.c | 132 ++++++++++++++++++- fs/hot_rb.h | 15 ++ fs/hot_track.c | 3 + include/linux/hot_track.h | 5 + 6 files changed, 551 insertions(+), 6 deletions(-)
fs/hot_hash.c +316 -0
@@ -27,6 +27,8 @@/* kmem_cache pointers for slab caches */ struct kmem_cache *hot_hash_node_cache; +struct task_struct *hot_data_update_kthread; +void hot_hash_heat_node_init (void *_node) {struct hot_hash_node *node = _node;
@@ -64,3 +66,317 @@ void hot_hash_heat_rwlock_init(struct hot_info *root) } } +static void hot_hash_free_heat_node (struct hlist_head *head) +{ +struct hlist_node *pos =NULL , *pos2 =NULL ; +struct hot_hash_node *heatnode =NULL ; + +hlist_for_each_safe (pos, pos2, head) { + heatnode =hlist_entry (pos, + struct hot_hash_node, + hashnode); +hlist_del (pos); +kfree (heatnode); + } + +} + +void hot_hash_free_heat_hash_list (struct hot_info *root) +{ +int i; + +/* Free node/range heat hash lists */ +for (i =0 ; i <HEAT_HASH_SIZE ; i++) { +hot_hash_free_heat_node (&root->heat_inode_hl[i].hashhead); +hot_hash_free_heat_node (&root->heat_range_hl[i].hashhead); + } +} + +static u64 hot_hash_shift (u64 counter,u32 bits,bool shift_dir) +{ +if (shift_dir) +return counter << bits; +else +return counter >> bits; +} + +/* +* hot_hash_calc_temperature() is responsible for distilling the six heat +* criteria, which are described in detail in hot_hash.h) down into a single +* temperature value for the data, which is an integer between 0 +* and HEAT_MAX_VALUE. +* +* To accomplish this, the raw values from the hot_freq_data structure +* are shifted various ways in order to make the temperature calculation more +* or less sensitive to each value. +* +* Once this calibration has happened, we do some additional normalization and +* make sure that everything fits nicely in a u32. From there, we take a very +* rudimentary kind of "average" of each of the values, where the *_COEFF_POWER +* values act as weights for the average. +* +* Finally, we use the HEAT_HASH_BITS value, which determines the size of the +* heat hash list, to normalize the temperature to the proper granularity. +*/ +int hot_hash_calc_temperature (struct hot_freq_data *freq_data) +{ +u64 result =0 ; + +struct timespec ckt =current_kernel_time (); +u64 cur_time =timespec_to_ns (&ckt); + +u32 nrr_heat = (u32 )hot_hash_shift ((u64 )freq_data->nr_reads, +NRR_MULTIPLIER_POWER , true); +u32 nrw_heat = (u32 )hot_hash_shift ((u64 )freq_data->nr_writes, +NRW_MULTIPLIER_POWER , true); + +u64 ltr_heat = +hot_hash_shift ((cur_time -timespec_to_ns (&freq_data->last_read_time)), +LTR_DIVIDER_POWER , false); +u64 ltw_heat = +hot_hash_shift ((cur_time -timespec_to_ns (&freq_data->last_write_time)), +LTW_DIVIDER_POWER , false); + +u64 avr_heat = +hot_hash_shift ((((u64) -1 ) - freq_data->avg_delta_reads), +AVR_DIVIDER_POWER , false); +u64 avw_heat = +hot_hash_shift ((((u64) -1 ) - freq_data->avg_delta_writes), +AVW_DIVIDER_POWER , false); + +/* ltr_heat is now guaranteed to be u32 safe */ +if (ltr_heat >=hot_hash_shift ((u64 )1 ,32 , true)) + ltr_heat =0 ; +else + ltr_heat =hot_hash_shift ((u64 )1 ,32 , true) - ltr_heat; + +/* ltw_heat is now guaranteed to be u32 safe */ +if (ltw_heat >=hot_hash_shift ((u64 )1 ,32 , true)) + ltw_heat =0 ; +else + ltw_heat =hot_hash_shift ((u64 )1 ,32 , true) - ltw_heat; + +/* avr_heat is now guaranteed to be u32 safe */ +if (avr_heat >=hot_hash_shift ((u64 )1 ,32 , true)) + avr_heat = (u32) -1 ; + +/* avw_heat is now guaranteed to be u32 safe */ +if (avw_heat >=hot_hash_shift ((u64 )1 ,32 , true)) + avw_heat = (u32) -1 ; + + nrr_heat = (u32 )hot_hash_shift ((u64 )nrr_heat, + (3 -NRR_COEFF_POWER ), false); + nrw_heat = (u32 )hot_hash_shift ((u64 )nrw_heat, + (3 -NRW_COEFF_POWER ), false); + ltr_heat =hot_hash_shift (ltr_heat, (3 -LTR_COEFF_POWER ), false); + ltw_heat =hot_hash_shift (ltw_heat, (3 -LTW_COEFF_POWER ), false); + avr_heat =hot_hash_shift (avr_heat, (3 -AVR_COEFF_POWER ), false); + avw_heat =hot_hash_shift (avw_heat, (3 -AVW_COEFF_POWER ), false); + + result = nrr_heat + nrw_heat + (u32 ) ltr_heat + + (u32 ) ltw_heat + (u32 ) avr_heat + (u32 ) avw_heat; + +return result >> (32 -HEAT_HASH_BITS ); +} + +int hot_hash_is_aging (struct hot_freq_data *freq_data) +{ +int ret =0 ; +struct timespec ckt =current_kernel_time (); + +u64 cur_time =timespec_to_ns (&ckt); +u64 last_read_ns = + (cur_time -timespec_to_ns (&freq_data->last_read_time)); +u64 last_write_ns = + (cur_time -timespec_to_ns (&freq_data->last_write_time)); +u64 kick_ns =TIME_TO_KICK * (u64 )1000000000 ; + +if ((last_read_ns > kick_ns) && (last_write_ns > kick_ns)) + ret =1 ; + +return ret; +} + +/* +* Calc a new temperature and, if necessary, move the heat_node corresponding +* to this inode or range to the proper hashlist with the new temperature +*/ +void hot_hash_update_heat_hash_list (struct hot_freq_data *freq_data, +struct hot_info *root) +{ +int temperature =0 ; +int moved =0 ; +struct hot_hash_head *buckets, *current_bucket =NULL ; +struct hot_inode_item *he; +struct hot_range_item *hr; + +if (freq_data->flags &FREQ_DATA_TYPE_INODE ) { + he =hot_freq_data_get_he (freq_data); + buckets = root->heat_inode_hl; + +spin_lock (&he->lock); + temperature =hot_hash_calc_temperature (freq_data); + freq_data->last_temperature = temperature; +spin_unlock (&he->lock); + +if (he ==NULL ) +return ; + +spin_lock (&he->heat_node->lock); +if (he->heat_node->hlist ==NULL ) { + current_bucket = buckets + temperature; + moved =1 ; + }else { +write_lock (&he->heat_node->hlist->rwlock); + current_bucket = he->heat_node->hlist; +if (current_bucket->temperature != temperature) { +hlist_del (&he->heat_node->hashnode); + current_bucket = buckets + temperature; + moved =1 ; + } +write_unlock (&he->heat_node->hlist->rwlock); + } + +if (moved) { +write_lock (¤t_bucket->rwlock); +hlist_add_head (&he->heat_node->hashnode, + ¤t_bucket->hashhead); + he->heat_node->hlist = current_bucket; +write_unlock (¤t_bucket->rwlock); + } +spin_unlock (&he->heat_node->lock); + }else if (freq_data->flags &FREQ_DATA_TYPE_RANGE ) { + hr =hot_freq_data_get_hr (freq_data); + buckets = root->heat_range_hl; + +spin_lock (&hr->lock); + temperature =hot_hash_calc_temperature (freq_data); + freq_data->last_temperature = temperature; +spin_unlock (&hr->lock); + +if (hr ==NULL ) +return ; + +spin_lock (&hr->heat_node->lock); +if (hr->heat_node->hlist ==NULL ) { + current_bucket = buckets + temperature; + moved =1 ; + }else { +write_lock (&hr->heat_node->hlist->rwlock); + current_bucket = hr->heat_node->hlist; +if (current_bucket->temperature != temperature) { +hlist_del (&hr->heat_node->hashnode); + current_bucket = buckets + temperature; + moved =1 ; + } +write_unlock (&hr->heat_node->hlist->rwlock); + } + +if (moved) { +write_lock (¤t_bucket->rwlock); +hlist_add_head (&hr->heat_node->hashnode, + ¤t_bucket->hashhead); + hr->heat_node->hlist = current_bucket; +write_unlock (¤t_bucket->rwlock); + } +spin_unlock (&hr->heat_node->lock); + } +} + +/* +* Update temperatures for each hot inode item and +* hot range item for aging purposes +*/ +static void hot_hash_iterate_and_update_heat (struct hot_info *root) +{ +struct hot_inode_item *current_hot_inode; +struct hot_inode_tree *hot_inode_tree; +unsigned long inode_num; + + hot_inode_tree = &root->hot_inode_tree; + +/* walk the inode tree */ + current_hot_inode =hot_rb_find_next_hot_inode (root,0 ); +while (current_hot_inode) { +hot_hash_update_heat_hash_list ( + ¤t_hot_inode->hot_freq_data, root); +hot_rb_update_range_data (current_hot_inode, root); + inode_num = current_hot_inode->i_ino; +hot_rb_free_hot_inode_item (current_hot_inode); + current_hot_inode =hot_rb_find_next_hot_inode (root, + inode_num +1 ); + } +} + +/* Determine if there is hot data tracking to be enabled */ +static bool hot_hash_global_hot_track (void ) +{ +struct super_block *sb; +bool ret = false; + +spin_lock (&sb_lock); +list_for_each_entry (sb, &super_blocks, s_list) { +if (hlist_unhashed (&sb->s_instances)) +continue ; +if (sb->s_hotinfo.mount_opt &HOT_MOUNT_HOT_TRACK ) + ret = true; + } +spin_unlock (&sb_lock); + +return ret; +} + +/* +* kthread iterates each hot_inode_item and hot_range_item +* and update temperatures to be shifted in heat hash table +* for purposes of relocation and such hot file detection +*/ +static int hot_hash_update_temperature_kthread (void *arg) +{ +struct super_block *sb; +struct hot_info *root; +unsigned long delay; + +do { +spin_lock (&sb_lock); +list_for_each_entry (sb, &super_blocks, s_list) { +if (hlist_unhashed (&sb->s_instances)) +continue ; + delay =HZ *HEAT_UPDATE_DELAY ; + root = &sb->s_hotinfo; +if (mutex_trylock ( + &root->hot_data_update_kthread_mutex)) { +hot_hash_iterate_and_update_heat (root); +mutex_unlock ( + &root->hot_data_update_kthread_mutex); + } +if (unlikely (freezing (current))) { +__refrigerator (true); + }else { +set_current_state (TASK_INTERRUPTIBLE ); +if (!kthread_should_stop ()) { +spin_unlock (&sb_lock); +schedule_timeout (delay); +spin_lock (&sb_lock); + } +__set_current_state (TASK_RUNNING ); + } + } +spin_unlock (&sb_lock); + }while (!kthread_should_stop () || !hot_hash_global_hot_track ()); + +return 0 ; +} + +/* Fork the kthread to do temperature updates for all filesystems */ +void hot_hash_fork_update_temperature_kthread () +{ +if (hot_data_update_kthread) +return ; + + hot_data_update_kthread = +kthread_run (hot_hash_update_temperature_kthread,NULL , +"update_hot_temperature_kthread" ); +if (IS_ERR (hot_data_update_kthread)) +kthread_stop (hot_data_update_kthread); +}
fs/hot_hash.h +86 -0
96 lines not on this page · raw message
fs/hot_rb.c +126 -6
153 lines not on this page · raw message
fs/hot_rb.h +15 -0
@@ -59,8 +59,23 @@ int __init hot_rb_item_cache_init(void);void hot_rb_inode_item_exit (void );void hot_rb_range_item_exit (void ); + +/* +* recalculates temperatures for inode or range +* and moves around in heat hash table based on temp +*/ +void hot_rb_update_heat_hash_list (struct hot_freq_data *freq_data, +struct hot_info *root); + +struct hot_inode_item +*hot_rb_find_next_hot_inode (struct hot_info *root, +u64 objectid);void hot_rb_update_freq (struct hot_freq_data *freq_data,int rw);void hot_rb_update_freqs (struct inode *inode,u64 start,u64 len,int rw); +/* Update temperatures for each range item for aging purposes */ +void hot_rb_update_range_data (struct hot_inode_item *hot_inode, +struct hot_info *root); +#endif /* __HOT_MAP__ */
fs/hot_track.c +3 -0
@@ -72,10 +72,13 @@ void hot_track_init(struct super_block *sb, const char *name) sb->s_hotinfo.mount_opt |=HOT_MOUNT_HOT_TRACK ;hot_rb_inode_tree_init (&sb->s_hotinfo.hot_inode_tree);hot_hash_heat_rwlock_init (&sb->s_hotinfo); +hot_hash_fork_update_temperature_kthread (); +hot_debugfs_volume_init (name, sb); }void hot_track_exit (struct super_block *sb) { sb->s_hotinfo.mount_opt &= ~HOT_MOUNT_HOT_TRACK ; +hot_hash_free_heat_hash_list (&sb->s_hotinfo);hot_rb_free_hot_inode_tree (&sb->s_hotinfo); }
include/linux/hot_track.h +5 -0
@@ -36,6 +36,8 @@ ((TRACKING_HOT_TRACK (inode->i_sb)) && \ !(inode->i_flags & S_NOHOTDATATRACK)) +extern struct task_struct *hot_data_update_kthread; +/* kmem_cache pointers for slab caches */ extern struct kmem_cache *hot_hash_node_cache;
@@ -144,6 +146,9 @@ struct hot_info {/* hash map of range temperature */ struct hot_hash_head heat_range_hl[HEAT_HASH_SIZE ]; + +/* protects hot data items while being iterated and updated */ +struct mutex hot_data_update_kthread_mutex; }; extern void hot_rb_update_freqs(struct inode *inode,
Signature · 1 line
1.7.6.5
RFC 10/11 vfs: add 3 new ioctl interfaces
In reply to [email protected]From: Zhi Yong Wu <[email protected]>
FS_IOC_GET_HEAT_INFO: return a struct containing the various
metrics collected in btrfs_freq_data structs, and also return a calculated data temperature based on those metrics. Optionally, retrieve the temperature from the hot data hash list instead of recalculating it.
FS_IOC_GET_HEAT_OPTS: return an integer representing the current
state of hot data tracking and migration:
0 = do nothing
1 = track frequency of access
FS_IOC_SET_HEAT_OPTS: change the state of hot data tracking and migration, as described above.
--- fs/compat_ioctl.c | 8 +++ fs/ioctl.c | 132 +++++++++++++++++++++++++++++++++++++++++++++ include/linux/fs.h | 11 ++++ include/linux/hot_track.h | 12 ++++ 4 files changed, 163 insertions(+), 0 deletions(-)
fs/compat_ioctl.c +8 -0
@@ -1390,6 +1390,11 @@ COMPATIBLE_IOCTL(TIOCSTART) COMPATIBLE_IOCTL(TIOCSTOP) #endif +/*Hot data tracking*/ +COMPATIBLE_IOCTL(FS_IOC_GET_HEAT_INFO) +COMPATIBLE_IOCTL(FS_IOC_SET_HEAT_OPTS) +COMPATIBLE_IOCTL(FS_IOC_GET_HEAT_OPTS) + /* fat 'r' ioctls. These are handled by fat with ->compat_ioctl, but we don't want warnings on other file systems. So declare them as compatible here. */
@@ -1572,6 +1577,9 @@ asmlinkage long compat_sys_ioctl(unsigned int fd, unsigned int cmd,case FIBMAP :case FIGETBSZ :case FIONREAD : +case FS_IOC_GET_HEAT_INFO : +case FS_IOC_SET_HEAT_OPTS : +case FS_IOC_GET_HEAT_OPTS :if (S_ISREG (filp->f_path.dentry->d_inode->i_mode))break ;/*FALL THROUGH*/
fs/ioctl.c +132 -0
150 lines not on this page · raw message
include/linux/fs.h +11 -0
@@ -256,6 +256,7 @@ struct inodes_stat_t {#define S_IMA 1024/* Inode has an associated IMA struct */ #define S_AUTOMOUNT 2048/* Automount/referral quasi-directory */ #define S_NOSEC 4096/* no suid or xattr security attributes */ +#define S_NOHOTDATATRACK (1 << 13)/* hot data tracking */ /* * Note that nosuid etc flags are inode-specific: setting some file-system
@@ -354,6 +355,16 @@ struct inodes_stat_t {#define FS_IOC32_SETVERSION _IOW('v', 2, int)/* +* Hot data tracking ioctls: +* +* HOT_INFO - retrieve info on frequency of access +*/ +#define FS_IOC_GET_HEAT_INFO _IOR('f', 17, \ + struct heat_info) +#define FS_IOC_SET_HEAT_OPTS _IOW('f', 18, int) +#define FS_IOC_GET_HEAT_OPTS _IOR('f', 19, int) + +/* * Inode flags (FS_IOC_GETFLAGS / FS_IOC_SETFLAGS) */ #define FS_SECRM_FL 0x00000001/* Secure deletion */
include/linux/hot_track.h +12 -0
@@ -68,6 +68,18 @@ struct hot_freq_data {u32 last_temperature; }; +struct heat_info { +__u64 avg_delta_reads; +__u64 avg_delta_writes; +__u64 last_read_time; +__u64 last_write_time; +__u32 num_reads; +__u32 num_writes; +__u32 temperature; +__u8 live; +char filename[PATH_MAX ]; +}; +/* Hash list heads for hot hash table */ struct hot_hash_head {struct hlist_head hashhead;
Signature · 1 line
1.7.6.5
RFC 11/11 vfs: add debugfs support
In reply to [email protected]From: Zhi Yong Wu <[email protected]>
Add a /sys/kernel/debug/hot_track/<device_name>/ directory for each
volume that contains two files. The first, inode_data', contains the heat information for inodes that have been brought into the hot data map structures. The second, range_data', contains similar information for subfile ranges.
--- fs/Makefile | 2 +- fs/hot_debugfs.c | 488 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ fs/hot_debugfs.h | 60 +++++++ fs/hot_track.c | 1 + fs/hot_track.h | 3 +- fs/namespace.c | 6 + 6 files changed, 557 insertions(+), 3 deletions(-) create mode 100644 fs/hot_debugfs.c create mode 100644 fs/hot_debugfs.h
fs/Makefile +1 -1
@@ -12,7 +12,7 @@ obj-y := open.o read_write.o file_table.o super.o \ seq_file.o xattr.o libfs.o fs-writeback.o \ pnode.o drop_caches.o splice.o sync.o utimes.o \ stack.o fs_struct.o statfs.o \ - hot_rb.o hot_track.o hot_hash.o + hot_rb.o hot_track.o hot_hash.o hot_debugfs.o ifeq ($(CONFIG_BLOCK),y) obj-y += buffer.o bio.o block_dev.o direct-io.o mpage.o ioprio.o
fs/hot_debugfs.c new file +488 -0
488 lines not on this page · raw message
fs/hot_debugfs.h new file +60 -0
60 lines not on this page · raw message
fs/hot_track.c +1 -0
@@ -81,4 +81,5 @@ void hot_track_exit(struct super_block *sb) sb->s_hotinfo.mount_opt &= ~HOT_MOUNT_HOT_TRACK ;hot_hash_free_heat_hash_list (&sb->s_hotinfo);hot_rb_free_hot_inode_tree (&sb->s_hotinfo); +hot_debugfs_volume_exit (sb); }
fs/hot_track.h +1 -2
@@ -13,8 +13,7 @@#ifndef __HOT_TRACK__#define __HOT_TRACK__ -#include "hot_rb.h" -#include "hot_hash.h" +#include "hot_debugfs.h" bool hot_track_parse_options (char *options);void __init hot_track_item_cache_init (void );
fs/namespace.c +6 -0
@@ -2629,6 +2629,12 @@ void __init mnt_init(void) fs_kobj =kobject_create_and_add ("fs" ,NULL );if (!fs_kobj)printk (KERN_WARNING "%s: kobj create error\n" , __func__); + + err =hot_debugfs_init (); +if (err) +printk (KERN_WARNING "%s: sysfs_init error: %d\n" , + __func__, err); +init_rootfs ();init_mount_tree (); }
Signature · 1 line
1.7.6.5