SYTest

Retired DISLab
(버전 사이의 차이)
이동: 둘러보기, 찾기
(새 문서: test)
 
 
(사용자 2명의 중간의 편집 6개 숨겨짐)
1번째 줄: 1번째 줄:
−
test
+
<uml>
 +
page 2x2
 +
 
 +
class  Scsi_Host<< (S,#FF7700)/scsi/scsi_host.h >> {
 +
struct list_head __devices;
 +
struct list_head __targets;     
 +
struct scsi_host_cmd_pool *cmd_pool;
 +
spinlock_t free_list_lock;
 +
struct list_head free_list;
 +
struct list_head starved_list;
 +
spinlock_t default_lock;
 +
spinlock_t *host_lock;
 +
struct mutex scan_mutex;
 +
struct list_head eh_cmd_q;
 +
struct task_struct * ehandler;
 +
struct completion * eh_action;
 +
wait_queue_head_t host_wait;
 +
struct scsi_host_template *hostt;
 +
struct scsi_transport_template *transportt;
 +
struct blk_queue_tag *bqt;unsigned int host_busy;
 +
unsigned int host_failed;     
 +
unsigned int host_eh_scheduled; 
 +
unsigned int host_no;
 +
int eh_deadline;
 +
unsigned long last_reset;
 +
unsigned int max_id;
 +
unsigned int max_lun;
 +
unsigned int max_channel;
 +
unsigned int unique_id;
 +
unsigned short max_cmd_len;
 +
int this_id;
 +
int can_queue;
 +
short cmd_per_lun;
 +
short unsigned int sg_tablesize;
 +
short unsigned int sg_prot_tablesize;
 +
short unsigned int max_sectors;
 +
unsigned long dma_boundary;
 +
unsigned long cmd_serial_number;
 +
unsigned active_mode:2;
 +
unsigned unchecked_isa_dma:1;
 +
unsigned use_clustering:1;
 +
unsigned use_blk_tcq:1;
 +
unsigned host_self_blocked:1;
 +
unsigned reverse_ordering:1;
 +
unsigned ordered_tag:1;
 +
unsigned eh_noresume:1;
 +
unsigned no_write_same:1;
 +
char work_q_name[20];
 +
struct workqueue_struct *work_q;
 +
struct workqueue_struct *tmf_work_q;
 +
unsigned int host_blocked;
 +
unsigned int max_host_blocked;
 +
unsigned int prot_capabilities;
 +
unsigned char prot_guard_type;
 +
struct request_queue *uspace_req_q;
 +
unsigned long base;
 +
unsigned long io_port;
 +
unsigned char n_io_port;
 +
unsigned char dma_channel;
 +
unsigned int  irq;
 +
enum scsi_host_state shost_state;
 +
struct device shost_gendev, shost_dev;
 +
struct list_head sht_legacy_list;
 +
void *shost_data;
 +
struct device *dma_dev;
 +
unsigned long hostdata[0];
 +
}
 +
Scsi_Host --> scsi_host_cmd_pool
 +
Scsi_Host --> mutex
 +
Scsi_Host --> task_struct
 +
Scsi_Host --> completion
 +
Scsi_Host --> scsi_host_template
 +
Scsi_Host --> scsi_transport_template
 +
Scsi_Host --> blk_queue_tag
 +
Scsi_Host --> workqueue_struct
 +
Scsi_Host --> request_queue
 +
Scsi_Host --> scsi_host_state
 +
Scsi_Host --> device
 +
 
 +
 
 +
class scsi_host_cmd_pool << (S,#77FF00)/scsi/scsi.c >> {
 +
struct kmem_cache *cmd_slab;
 +
struct kmem_cache *sense_slab;
 +
unsigned int users;
 +
char *cmd_name;
 +
char *sense_name;
 +
unsigned int slab_flags;
 +
gfp_t gfp_mask;
 +
}
 +
scsi_host_cmd_pool --> kmem_cache
 +
 
 +
 
 +
class kmem_cache << (S,#77FF00)/linux/slub_def.h >> {
 +
struct kmem_cache_cpu __percpu *cpu_slab;
 +
unsigned long flags;
 +
unsigned long min_partial;
 +
int size;              /* The size of an object including meta data */
 +
int object_size;        /* The size of an object without meta data */
 +
int offset;            /* Free pointer offset. */
 +
int cpu_partial;        /* Number of per cpu partial objects to keep around */
 +
struct kmem_cache_order_objects oo;
 +
struct kmem_cache_order_objects max;
 +
struct kmem_cache_order_objects min;
 +
gfp_t allocflags;      /* gfp flags to use on each alloc */
 +
int refcount;          /* Refcount for slab cache destroy */
 +
void (*ctor)(void *);
 +
int inuse;              /* Offset to metadata */
 +
int align;              /* Alignment */
 +
int reserved;          /* Reserved bytes at the end of slabs */
 +
const char *name;      /* Name (only for display!) */
 +
struct list_head list;  /* List of slab caches */
 +
}
 +
kmem_cache --> kmem_cache_cpu
 +
kmem_cache --> kmem_cache_order_objects
 +
 
 +
 
 +
class kmem_cache_cpu << (S,#77FF00)/linux/slub_def.h >> {
 +
void **freelist;        /* Pointer to next available object */
 +
unsigned long tid;      /* Globally unique transaction id */
 +
struct page *page;      /* The slab from which we are allocating */
 +
struct page *partial;  /* Partially allocated frozen slabs */
 +
}
 +
kmem_cache_cpu --> page
 +
 
 +
 
 +
 
 +
class page << (S,#77FF00)/linux/mm_types.h >>{
 +
unsigned long flags;
 +
union {
 +
struct address_space *mapping;
 +
void *s_mem;
 +
};
 +
union {
 +
pgoff_t index; 
 +
void *freelist; 
 +
bool pfmemalloc; 
 +
};
 +
union {
 +
struct list_head lru; 
 +
struct page *next;
 +
struct list_head list; 
 +
struct slab *slab_page;
 +
struct rcu_head rcu_head;
 +
};
 +
unsigned long private;
 +
}
 +
page --> address_space
 +
page --> slab
 +
 
 +
 
 +
class address_space << (S,#77FF00)/linux/fs.h >> {
 +
struct inode *host;          /* owner: inode, block_device */
 +
struct radix_tree_root page_tree;      /* radix tree of all pages */
 +
spinlock_t tree_lock;      /* and lock protecting it */
 +
unsigned int i_mmap_writable;/* count VM_SHARED mappings */
 +
struct rb_root i_mmap;        /* tree of private and shared mappings */
 +
struct list_head i_mmap_nonlinear;/*list VM_NONLINEAR mappings */
 +
struct mutex i_mmap_mutex;
 +
unsigned long nrpages;        /* number of total pages */
 +
pgoff_t writeback_index;/* writeback starts here */
 +
const struct address_space_operations *a_ops;  /* methods */
 +
unsigned long flags;          /* error bits/gfp mask */
 +
struct backing_dev_info *backing_dev_info; /* device readahead, etc */
 +
spinlock_t private_lock;  /* for use by the address_space */
 +
struct list_head private_list;  /* ditto */
 +
void *private_data;
 +
}
 +
address_space --> inode
 +
address_space --> radix_tree_root
 +
address_space --> rb_root
 +
address_space --> mutex
 +
address_space --> backing_dev_info
 +
 
 +
class radix_tree_root << (S,#77FF00)/linux/radix-tree.h >> {
 +
unsigned int height;
 +
gfp_t gfp_mask;
 +
struct radix_tree_node __rcu *rnode;
 +
}
 +
 
 +
class radix_tree_node << (S,#77FF00)/linux/radix-tree.c >> {
 +
unsigned int height;     
 +
unsigned int count;
 +
union {
 +
struct radix_tree_node *parent;
 +
struct rcu_head rcu_head;   
 +
};
 +
void __rcu *slots[RADIX_TREE_MAP_SIZE];
 +
unsigned long tags[RADIX_TREE_MAX_TAGS][RADIX_TREE_TAG_LONGS];
 +
}
 +
 
 +
 
 +
class rb_root << (S,#77FF00)/linux/rbtree.h >> {
 +
struct rb_node *rb_node;
 +
}
 +
rb_root --> rb_node
 +
 
 +
 
 +
class rb_node << (S,#77FF00)/linux/rbtree.h >> {
 +
unsigned long __rb_parent_color;
 +
struct rb_node *rb_right;
 +
struct rb_node *rb_left;
 +
}
 +
 
 +
class inode << (S,#77FF00)/linux/fs.h >> {
 +
umode_t i_mode;
 +
unsigned short i_opflags;
 +
kuid_t i_uid;
 +
kgid_t i_gid;
 +
unsigned int i_flags;
 +
const struct inode_operations *i_op;
 +
struct super_block *i_sb;
 +
struct address_space *i_mapping;
 +
union {
 +
const unsigned int i_nlink;
 +
unsigned int __i_nlink;
 +
};
 +
dev_t i_rdev;
 +
loff_t i_size;
 +
struct timespec i_atime;
 +
struct timespec i_mtime;
 +
struct timespec i_ctime;
 +
spinlock_t i_lock; /* i_blocks, i_bytes, maybe i_size */
 +
unsigned short i_bytes;
 +
unsigned int i_blkbits;
 +
blkcnt_t i_blocks;
 +
unsigned long i_state;
 +
struct mutex i_mutex;
 +
unsigned long dirtied_when;  /* jiffies of first dirtying */
 +
struct hlist_node i_hash;
 +
struct list_head i_wb_list;      /* backing dev IO list */
 +
struct list_head i_lru;          /* inode LRU list */
 +
struct list_head i_sb_list;
 +
union {
 +
struct hlist_head i_dentry;
 +
struct rcu_head i_rcu;
 +
};
 +
u64 i_version;
 +
atomic_t i_count;
 +
atomic_t i_dio_count;
 +
atomic_t i_writecount;
 +
const struct file_operations *i_fop; /* former ->i_op->default_file_ops */
 +
struct file_lock *i_flock;
 +
struct address_space i_data;
 +
struct list_head i_devices;
 +
__u32 i_generation;
 +
}
 +
inode --> inode_operations
 +
inode --> super_block
 +
inode --> address_space
 +
inode --> timespec
 +
inode --> mutex
 +
inode --> hlist_node
 +
inode --> file_lock
 +
 
 +
class inode_operations << (S,#77FF00)/linux/fs.h>> {
 +
struct dentry * (*lookup) (struct inode *,struct dentry *, unsigned int);
 +
void * (*follow_link) (struct dentry *, struct nameidata *);
 +
int (*permission) (struct inode *, int);
 +
struct posix_acl * (*get_acl)(struct inode *, int);
 +
(*readlink) (struct dentry *, char __user *,int) : int
 +
(*put_link) (struct dentry *, struct nameidata *, void *) : void
 +
int (*create) (struct inode *,struct dentry *, umode_t, bool);
 +
int (*link) (struct dentry *,struct inode *,struct dentry *);
 +
int (*unlink) (struct inode *,struct dentry *);
 +
int (*symlink) (struct inode *,struct dentry *,const char *);
 +
int (*mkdir) (struct inode *,struct dentry *,umode_t);
 +
int (*rmdir) (struct inode *,struct dentry *);
 +
int (*mknod) (struct inode *,struct dentry *,umode_t,dev_t);
 +
int (*rename) (struct inode *, struct dentry *, struct inode *, struct dentry *);
 +
int (*setattr) (struct dentry *, struct iattr *);
 +
int (*getattr) (struct vfsmount *mnt, struct dentry *, struct kstat *);
 +
int (*setxattr) (struct dentry *, const char *,const void *,size_t,int);
 +
ssize_t (*getxattr) (struct dentry *, const char *, void *, size_t);
 +
ssize_t (*listxattr) (struct dentry *, char *, size_t);
 +
int (*removexattr) (struct dentry *, const char *);
 +
int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start, u64 len);
 +
int (*update_time)(struct inode *, struct timespec *, int);
 +
int (*atomic_open)(struct inode *, struct dentry *, struct file *, unsigned open_flag, umode_t create_mode, int *opened);
 +
int (*tmpfile) (struct inode *, struct dentry *, umode_t);
 +
int (*set_acl)(struct inode *, struct posix_acl *, int);
 +
}
 +
inode_operations --> dentry
 +
inode_operations --> posix_acl
 +
 
 +
class dentry<< (S,#77FF00)/linux/dcache.h >> {
 +
d_flags : unsigned int
 +
d_seq : seqcount_t
 +
d_hash : struct hlist_bl_node
 +
struct dentry *d_parent;   
 +
struct qstr d_name;
 +
struct inode *d_inode;
 +
unsigned char d_iname[DNAME_INLINE_LEN]; 
 +
struct lockref d_lockref; 
 +
const struct dentry_operations *d_op;
 +
struct super_block *d_sb;   
 +
unsigned long d_time;     
 +
void *d_fsdata;               
 +
struct list_head d_lru;     
 +
union {
 +
struct list_head d_child;   
 +
struct rcu_head d_rcu;
 +
} d_u;
 +
struct list_head d_subdirs; 
 +
struct hlist_node d_alias;     
 +
}
 +
dentry --> hlist_bl_node
 +
dentry --> qstr
 +
dentry --> inode
 +
dentry --> lockref
 +
dentry --> super_block
 +
dentry --> hlist_node
 +
 
 +
 
 +
class hlist_bl_node << (S,#77FF00)/linux/list_bl.h >> {
 +
struct hlist_bl_node *next, **pprev;
 +
}
 +
 
 +
class qstr  << (S,#77FF00)/linux/dcache.h >> {
 +
union {
 +
struct {
 +
HASH_LEN_DECLARE;
 +
};
 +
u64 hash_len;
 +
};
 +
const unsigned char *name;
 +
}
 +
 
 +
class lockref << (S,#77FF00)/linux/lockref.h >> {
 +
struct {
 +
spinlock_t lock;
 +
unsigned int count;
 +
};
 +
}
 +
 
 +
 
 +
class posix_acl << (S,#77FF00)/linux/posix_acl.h >> {
 +
union {
 +
atomic_t a_refcount;
 +
struct rcu_head a_rcu;
 +
};
 +
unsigned int a_count;
 +
struct posix_acl_entry a_entries[0];
 +
}
 +
posix_acl --> posix_acl_entry
 +
 
 +
 
 +
class posix_acl_entry << (S,#77FF00)/linux/posix_acl.h >> {
 +
short e_tag;
 +
unsigned short e_perm;
 +
union {
 +
kuid_t e_uid;
 +
kgid_t e_gid;
 +
};
 +
}
 +
 
 +
 
 +
class super_block << (S,#77FF00)/linux/fs.h >> {
 +
struct list_head s_list; 
 +
dev_t  s_dev;     
 +
unsigned char s_blocksize_bits;
 +
unsigned long s_blocksize;
 +
loff_t s_maxbytes; 
 +
struct file_system_type *s_type;
 +
const struct super_operations *s_op;
 +
const struct dquot_operations *dq_op;
 +
const struct quotactl_ops *s_qcop;
 +
const struct export_operations *s_export_op;
 +
unsigned long s_flags;
 +
unsigned long s_magic;
 +
struct dentry *s_root;
 +
struct rw_semaphore s_umount;
 +
int s_count;
 +
atomic_t s_active;
 +
const struct xattr_handler **s_xattr;
 +
struct list_head s_inodes;   
 +
struct hlist_bl_head s_anon;       
 +
struct list_head s_mounts; 
 +
struct block_device *s_bdev;
 +
struct backing_dev_info *s_bdi;
 +
struct mtd_info *s_mtd;
 +
struct hlist_node s_instances;
 +
struct quota_info s_dquot;     
 +
struct sb_writers s_writers;
 +
char s_id[32];                       
 +
u8 s_uuid[16];                 
 +
void *s_fs_info;   
 +
unsigned int s_max_links;
 +
fmode_t s_mode;
 +
u32 s_time_gran;
 +
struct mutex s_vfs_rename_mutex;
 +
char *s_subtype;
 +
char __rcu *s_options;
 +
const struct dentry_operations *s_d_op;
 +
int cleancache_poolid;
 +
struct shrinker s_shrink;
 +
atomic_long_t s_remove_count;
 +
int s_readonly_remount;
 +
struct workqueue_struct *s_dio_done_wq;
 +
struct list_lru s_dentry_lru ____cacheline_aligned_in_smp;
 +
struct list_lru s_inode_lru ____cacheline_aligned_in_smp;
 +
struct rcu_head rcu;
 +
}
 +
super_block --> file_system_type
 +
super_block --> super_operations
 +
super_block --> dquot_operations
 +
super_block --> quotactl_ops
 +
super_block --> export_operations
 +
super_block --> xattr_handler
 +
super_block --> hlist_bl_head
 +
super_block --> block_device
 +
super_block --> backing_dev_info
 +
super_block --> mtd_info
 +
super_block --> quota_info
 +
super_block --> sb_writers
 +
super_block --> mutex
 +
super_block --> dentry_operations
 +
super_block --> shrinker
 +
super_block --> workqueue_struct
 +
super_block --> list_lru
 +
 
 +
class file_system_type << (S,#77FF00)/linux/fs.h >> {
 +
const char *name;
 +
int fs_flags;
 +
struct dentry *(*mount) (struct file_system_type *, int,
 +
const char *, void *);
 +
void (*kill_sb) (struct super_block *);
 +
struct module *owner;
 +
struct file_system_type * next;
 +
struct hlist_head fs_supers;
 +
struct lock_class_key s_lock_key;
 +
struct lock_class_key s_umount_key;
 +
struct lock_class_key s_vfs_rename_key;
 +
struct lock_class_key s_writers_key[SB_FREEZE_LEVELS];
 +
struct lock_class_key i_lock_key;
 +
struct lock_class_key i_mutex_key;
 +
struct lock_class_key i_mutex_dir_key;
 +
}
 +
file_system_type --> dentry
 +
file_system_type --> module
 +
file_system_type --> hlist_head
 +
file_system_type --> lock_class_key
 +
 
 +
 
 +
class module << (S,#77FF00)/mod/modpost.h >> {
 +
struct module *next;
 +
const char *name;
 +
int gpl_compatible;
 +
struct symbol *unres;
 +
int seen;
 +
int skip;
 +
int has_init;
 +
int has_cleanup;
 +
struct buffer dev_table_buf;
 +
char        srcversion[25];
 +
int is_dot_o;
 +
}
 +
module --> symbol
 +
module --> buffer
 +
 
 +
 
 +
class symbol << (S,#77FF00)/mod/modpost.h >> {
 +
struct symbol *next;
 +
struct module *module;
 +
unsigned int crc;
 +
int crc_valid;
 +
unsigned int weak:1;
 +
unsigned int vmlinux:1;
 +
unsigned int kernel:1;
 +
unsigned int preloaded:1; 
 +
enum export  export;
 +
char name[0];
 +
}
 +
symbol --> module
 +
 
 +
 
 +
class buffer << (S,#77FF00)/mod/modpost.h >> {
 +
char *p;
 +
int pos;
 +
int size;
 +
}
 +
 
 +
class hlist_head << (S,#77FF00)/linux/types.h >> {
 +
struct hlist_node *first;
 +
}
 +
hlist_head --> hlist_node
 +
 
 +
class lock_class_key << (S,#77FF00)/linux/lockdep.h >> {
 +
struct lockdep_subclass_key subkeys[MAX_LOCKDEP_SUBCLASSES];
 +
}
 +
lock_class_key --> lockdep_subclass_key
 +
 
 +
 
 +
class lockdep_subclass_key << (S,#77FF00)/linux/lockdep.h >> {
 +
char __one_byte;
 +
}
 +
 
 +
 
 +
class super_operations<< (S,#77FF00)/linux/fs.h >> {
 +
struct inode *(*alloc_inode)(struct super_block *sb);
 +
void (*destroy_inode)(struct inode *);
 +
void (*dirty_inode) (struct inode *, int flags);
 +
int (*write_inode) (struct inode *, struct writeback_control *wbc);
 +
int (*drop_inode) (struct inode *);
 +
void (*evict_inode) (struct inode *);
 +
void (*put_super) (struct super_block *);
 +
int (*sync_fs)(struct super_block *sb, int wait);
 +
int (*freeze_fs) (struct super_block *);
 +
int (*unfreeze_fs) (struct super_block *);
 +
int (*statfs) (struct dentry *, struct kstatfs *);
 +
int (*remount_fs) (struct super_block *, int *, char *);
 +
void (*umount_begin) (struct super_block *);
 +
int (*show_options)(struct seq_file *, struct dentry *);
 +
int (*show_devname)(struct seq_file *, struct dentry *);
 +
int (*show_path)(struct seq_file *, struct dentry *);
 +
int (*show_stats)(struct seq_file *, struct dentry *);
 +
}
 +
super_operations --> inode
 +
 
 +
 
 +
class dquot_operations << (S,#77FF00)/linust/quota.h >> {
 +
int (*write_dquot) (struct dquot *);            /* Ordinary dquot write */
 +
struct dquot *(*alloc_dquot)(struct super_block *, int);   
 +
void (*destroy_dquot)(struct dquot *);   
 +
int (*acquire_dquot) (struct dquot *);     
 +
int (*release_dquot) (struct dquot *);       
 +
int (*mark_dirty) (struct dquot *);         
 +
int (*write_info) (struct super_block *, int);
 +
qsize_t *(*get_reserved_space) (struct inode *);
 +
}
 +
dquot_operations --> dquot
 +
 
 +
 
 +
class dquot << (S,#77FF00/linust/quota.h) >> {
 +
struct hlist_node dq_hash; 
 +
struct list_head dq_inuse;   
 +
struct list_head dq_free; 
 +
struct list_head dq_dirty;   
 +
struct mutex dq_lock;   
 +
atomic_t dq_count;         
 +
wait_queue_head_t dq_wait_unused;     
 +
struct super_block *dq_sb; 
 +
struct kqid dq_id;           
 +
loff_t dq_off;               
 +
unsigned long dq_flags;     
 +
struct mem_dqblk dq_dqb;     
 +
}
 +
dquot --> hlist_node
 +
dquot --> mutex
 +
dquot --> super_block
 +
dquot --> kqid
 +
dquot --> mem_dqblk
 +
 
 +
class kqid << (S,#77FF00)/linust/quota.h >> {
 +
kuid_t uid;
 +
kgid_t gid;
 +
kprojid_t projid;
 +
}
 +
 
 +
class mem_dqblk << (S,#77FF00)/linust/quota.h >> {
 +
qsize_t dqb_bhardlimit;
 +
qsize_t dqb_bsoftlimit;
 +
qsize_t dqb_curspace;
 +
qsize_t dqb_rsvspace;
 +
qsize_t dqb_ihardlimit;
 +
qsize_t dqb_isoftlimit;
 +
qsize_t dqb_curinodes;
 +
time_t dqb_btime;     
 +
time_t dqb_itime;   
 +
}
 +
 
 +
 
 +
class quotactl_ops << (S,#77FF00))/linust/quota.h >> {
 +
int (*quota_on)(struct super_block *, int, int, struct path *);
 +
int (*quota_on_meta)(struct super_block *, int, int);
 +
int (*quota_off)(struct super_block *, int);
 +
int (*quota_sync)(struct super_block *, int);
 +
int (*get_info)(struct super_block *, int, struct if_dqinfo *);
 +
int (*set_info)(struct super_block *, int, struct if_dqinfo *);
 +
int (*get_dqblk)(struct super_block *, struct kqid, struct fs_disk_quota *);
 +
int (*set_dqblk)(struct super_block *, struct kqid, struct fs_disk_quota *);
 +
int (*get_xstate)(struct super_block *, struct fs_quota_stat *);
 +
int (*set_xstate)(struct super_block *, unsigned int, int);
 +
int (*get_xstatev)(struct super_block *, struct fs_quota_statv *);
 +
}
 +
 
 +
class export_operations<< (S,#77FF00)/linux/exportfs.h >> {
 +
int (*encode_fh)(struct inode *inode, __u32 *fh, int *max_len, struct inode *parent);
 +
struct dentry * (*fh_to_dentry)(struct super_block *sb, struct fid *fid, int fh_len, int fh_type);
 +
struct dentry * (*fh_to_parent)(struct super_block *sb, struct fid *fid, int fh_len, int fh_type);
 +
int (*get_name)(struct dentry *parent, char *name, struct dentry *child);
 +
struct dentry * (*get_parent)(struct dentry *child);
 +
int (*commit_metadata)(struct inode *inode);
 +
}
 +
export_operations --> dentry
 +
 
 +
class  xattr_handler<< (S,#77FF00)/linux/xattr.h >> {
 +
const char *prefix;
 +
int flags;      /* fs private flags passed back to the handlers */
 +
size_t (*list)(struct dentry *dentry, char *list, size_t list_size, const char *name, size_t name_len, int handler_flags);
 +
int (*get)(struct dentry *dentry, const char *name, void *buffer, size_t size, int handler_flags);
 +
int (*set)(struct dentry *dentry, const char *name, const void *buffer, size_t size, int flags, int handler_flags);
 +
}
 +
 
 +
 
 +
class hlist_bl_head << (S,#77FF00)/linust/list_bl.h >> {
 +
struct hlist_bl_node *first;
 +
}
 +
hlist_blk_head --> hlist_bl_node
 +
 
 +
 
 +
class block_device << (S,#77FF00)/linux/fs.h >> {
 +
dev_t bd_dev;  /* not a kdev_t - it's a search key */
 +
int bd_openers;
 +
struct inode * bd_inode;   
 +
struct super_block * bd_super;
 +
struct mutex bd_mutex;     
 +
struct list_head bd_inodes;
 +
void * bd_claiming;
 +
void * bd_holder;
 +
int bd_holders;
 +
bool bd_write_holder;
 +
struct block_device * bd_contains;
 +
unsigned bd_block_size;
 +
struct hd_struct * bd_part;
 +
unsigned bd_part_count;
 +
int bd_invalidated;
 +
struct gendisk * bd_disk;
 +
struct request_queue * bd_queue;
 +
struct list_head bd_list;
 +
unsigned long bd_private;
 +
int bd_fsfreeze_count;
 +
struct mutex bd_fsfreeze_mutex;
 +
}
 +
block_device --> inode
 +
block_device --> super_block
 +
block_device --> mutex
 +
block_device --> hd_struct
 +
block_device --> gendisk
 +
block_device --> request_queue
 +
 
 +
 
 +
class hd_struct<< (S,#77FF00)/linux/genhd.h >> {
 +
sector_t start_sect;
 +
sector_t nr_sects;
 +
seqcount_t nr_sects_seq;
 +
sector_t alignment_offset;
 +
unsigned int discard_alignment;
 +
struct device __dev;
 +
struct kobject *holder_dir;
 +
int policy, partno;
 +
struct partition_meta_info *info;
 +
unsigned long stamp;
 +
atomic_t in_flight[2];
 +
atomic_t ref;
 +
struct rcu_head rcu_head;
 +
}
 +
hd_struct --> device
 +
hd_struct --> kobject
 +
hd_struct --> partition_meta_info
 +
 
 +
 
 +
class kobject << (S,#77FF00)/linux/kobject.h >> {
 +
const char *name;
 +
struct list_head entry;
 +
struct kobject *parent;
 +
struct kset *kset;
 +
struct kobj_type *ktype;
 +
struct kernfs_node *sd;
 +
struct kref kref;
 +
unsigned int state_initialized:1;
 +
unsigned int state_in_sysfs:1;
 +
unsigned int state_add_uevent_sent:1;
 +
unsigned int state_remove_uevent_sent:1;
 +
unsigned int uevent_suppress:1;
 +
}
 +
kobject --> kset
 +
kobject --> kobj_type
 +
kobject --> kernfs_node
 +
kobject --> kref
 +
 
 +
 
 +
class kset << (S,#77FF00)/linux/kobject.h >> {
 +
struct list_head list;
 +
spinlock_t list_lock;
 +
struct kobject kobj;
 +
const struct kset_uevent_ops *uevent_ops;
 +
}
 +
kset --> kobject
 +
 
 +
class kobj_type << (S,#77FF00)/linux/kobject.h >> {
 +
void (*release)(struct kobject *kobj);
 +
const struct sysfs_ops *sysfs_ops;
 +
struct attribute **default_attrs;
 +
const struct kobj_ns_type_operations *(*child_ns_type)(struct kobject *kobj);
 +
const void *(*namespace)(struct kobject *kobj);
 +
}
 +
kobj_type --> sysfs_ops
 +
kobj_type --> attribute
 +
kobj_type --> kobj_ns_type_operations
 +
 
 +
 
 +
class sysfs_ops << (S,#77FF00)/linux/sysfs.h >> {
 +
ssize_t (*show)(struct kobject *, struct attribute *, char *);
 +
ssize_t (*store)(struct kobject *, struct attribute *, const char *, size_t);
 +
}
 +
 
 +
 
 +
class attribute << (S,#77FF00)/linux/sysfs.h >> {
 +
const char              *name;
 +
umode_t                mode;
 +
}
 +
 
 +
 
 +
class kobj_ns_type_operations << (S,#77FF00)/linux/kobject_ns.h >> {
 +
enum kobj_ns_type type;
 +
bool (*current_may_mount)(void);
 +
void *(*grab_current_ns)(void);
 +
const void *(*netlink_ns)(struct sock *sk);
 +
const void *(*initial_ns)(void);
 +
void (*drop_ns)(void *);
 +
}
 +
 
 +
 
 +
class kernfs_node << (S,#77FF00)/linux/kernfs.h >> {
 +
atomic_t                count;
 +
atomic_t                active;
 +
struct kernfs_node      *parent;
 +
const char              *name;
 +
struct rb_node          rb;
 +
union {
 +
struct completion      *completion;
 +
struct kernfs_node      *removed_list;
 +
} u;
 +
const void              *ns;    /* namespace tag */
 +
unsigned int            hash;  /* ns + name hash */
 +
union {
 +
struct kernfs_elem_dir          dir;
 +
struct kernfs_elem_symlink      symlink;
 +
struct kernfs_elem_attr        attr;
 +
};
 +
void                    *priv;
 +
unsigned short          flags;
 +
umode_t                mode;
 +
unsigned int            ino;
 +
struct kernfs_iattrs    *iattr;
 +
}
 +
kernfs_node --> rb_node
 +
kernfs_node --> completion
 +
kernfs_node --> kernfs_elem_dir
 +
kernfs_node --> kernfs_symlink
 +
kernfs_node --> kernfs_elem_attr
 +
kernfs_node --> kernfs_iattrs
 +
 
 +
 
 +
class kref << (S,#77FF00)/linux/kobject.h>> {
 +
 
 +
}
 +
 
 +
 
 +
class partition_meta_info << (S,#77FF00) >> {
 +
 
 +
}
 +
 
 +
class gendisk << (S,#77FF00) >> {
 +
 
 +
}
 +
 
 +
 
 +
 
 +
class mtd_info << (S,#77FF00) >> {
 +
 
 +
}
 +
 
 +
class quota_info << (S,#77FF00) >> {
 +
 
 +
}
 +
 
 +
class sb_writers << (S,#77FF00) >> {
 +
 
 +
}
 +
 
 +
class dentry_operations << (S,#77FF00) >> {
 +
 
 +
}
 +
 
 +
class shrinker << (S,#77FF00) >> {
 +
 
 +
}
 +
 
 +
class list_lru << (S,#77FF00) >> {
 +
 
 +
}
 +
 
 +
 
 +
class backing_dev_info << (S,#77FF00) >> {
 +
 
 +
}
 +
 
 +
class timespec << (S,#77FF00)can't find >> {
 +
 
 +
}
 +
 
 +
class file_lock << (S,#77FF00)can't find >> {
 +
 
 +
}
 +
 
 +
class backing_dev_info << (S,#77FF00)can't find >> {
 +
 
 +
}
 +
 
 +
 
 +
class backing_dev_info << (S,#77FF00)can't find >> {
 +
 
 +
}
 +
 
 +
 
 +
class slab << (S,#77FF00)can't find >> {
 +
 
 +
}
 +
 
 +
class kmem_cache_order_objects << (S,#77FF00)/linux/slub_def.h >> {
 +
unsigned long x;
 +
}
 +
 
 +
 
 +
 
 +
 
 +
class scsi_transport_template << (S,#77FF00)/ >> {
 +
 
 +
}
 +
 
 +
class blk_queue_tag << (S,#77FF00)/ >> {
 +
 
 +
}
 +
 
 +
class scsi_host_state << (S,#77FF00)/ >> {
 +
 
 +
}
 +
 
 +
class request_queue << (S,#FF7700)/linux/blkdev.h >> {
 +
struct list_head queue_head
 +
struct request *last_merge;
 +
struct elevator_queue *elevator;
 +
int nr_rqs[2];
 +
int nr_rqs_elvpriv;
 +
 
 +
struct request_list root_rl;
 +
request_fn_proc *request_fn;
 +
prep_rq_fn *prep_rq_fn;
 +
unprep_rq_fn *unprep_rq_fn;
 +
merge_bvec_fn *merge_bvec_fn;
 +
softirq_done_fn *softirq_done_fn;
 +
rq_timed_out_fn *rq_timed_out_fn;
 +
dma_drain_needed_fn *dma_drain_needed;
 +
lld_busy_fn *lld_busy_fn;
 +
 
 +
struct blk_mq_ops *mq_ops;
 +
unsigned int *mq_map;
 +
struct blk_mq_ctx *queue_ctx;
 +
unsigned int nr_hw_queues;
 +
sector_t end_sector;
 +
struct request *boundary_rq;
 +
struct delayed_work delay_work;
 +
struct backing_dev_info backing_dev_info;
 +
void queuedata;
 +
unsigned long queue_flags;
 +
int id;
 +
gfp_t bounce_gfp;
 +
spinlock_t __queue_lock;
 +
spinlock_t *queue_lock;
 +
struct kobject kobj;
 +
struct kobject mq_kobj;
 +
 
 +
unsigned long nr_requests;
 +
unsigned int  nr_congestion_on;
 +
unsigned int nr_congestion_off;
 +
unsigned int nr_batching;
 +
unsigned int dma_drain_size;
 +
void *dma_drain_buffer;
 +
unsigned int dma_pad_mask;
 +
unsigned int dma_alignment;
 +
struct blk_queue_tag *queue_tags;
 +
struct list_head tag_busy_list;
 +
unsigned int  nr_sorted;
 +
unsigned int in_flight[2];
 +
unsigned int request_fn_active;
 +
unsigned int rq_timeout;
 +
struct timer_list timeout;
 +
struct list_head timeout_list;
 +
struct list_head icq_list;
 +
 
 +
struct queue_limits limits;
 +
unsigned int sg_timeout;
 +
unsigned int sg_reserved_size;
 +
int node;
 +
 
 +
unsigned int flush_flags;
 +
unsigned int flush_not_queueable:1;
 +
unsigned int flush_queue_delayed:1;
 +
unsigned int flush_pending_idx:1;
 +
unsigned int flush_running_idx:1;
 +
unsigned long flush_pending_since;
 +
struct list_head flush_queue[2];
 +
struct list_head flush_data_in_flight;
 +
struct request *flush_rq;
 +
spinlock_t mq_flush_lock;
 +
struct mutex sysfs_lock;
 +
int bypass_depth;
 +
 
 +
struct rcu_head rcu_head;
 +
wait_queue_head_t mq_freeze_wq;
 +
struct percpu_counter mq_usage_counter;
 +
struct list_head all_q_node;
 +
}
 +
request_queue --> request
 +
request_queue --> elevator_queue
 +
request_queue --> request_list
 +
request_queue --> blk_mq_ops
 +
request_queue --> blk_mq_ctx
 +
request_queue --> delayed_work
 +
request_queue --> backing_dev_info
 +
request_queue --> kobject
 +
request_queue --> blk_queue_tag
 +
request_queue --> timer_list
 +
request_queue --> queue_limits
 +
request_queue --> mutex
 +
request_queue --> percpu_counter
 +
 
 +
 
 +
class device << (S,#FF7700)/linux/device.h >> {
 +
struct device *parent;
 +
struct device_private *p;
 +
struct kobject kobj;
 +
const char *init_name;
 +
const struct device_type *type;
 +
struct mutex mutex;
 +
struct bus_type *bus; 
 +
struct device_driver *driver;
 +
void *platform_data;
 +
struct dev_pm_info power;
 +
struct dev_pm_domain *pm_domain;
 +
 
 +
u64 *dma_mask;
 +
u64 coherent_dma_mask
 +
struct device_dma_parameters *dma_parms;
 +
struct list_head dma_pools;
 +
struct dma_coherent_mem *dma_mem;
 +
struct dev_archdata    archdata;
 +
struct device_node      *of_node;
 +
struct acpi_dev_node    acpi_node;
 +
dev_t devt; 
 +
u32 id; 
 +
spinlock_t devres_lock;
 +
struct list_head devres_head;
 +
struct klist_node knode_class;
 +
struct class *class;
 +
const struct attribute_group **groups;
 +
void (*release)(struct device *dev);
 +
struct iommu_group *iommu_group;
 +
bool offline_disabled:1;
 +
bool offline:1;
 +
}
 +
device --> device_private
 +
device --> kobject
 +
device --> device_type
 +
device --> mutex
 +
device --> bus_type
 +
device --> device_driver
 +
device --> dev_pm_info
 +
device --> dev_pm_domain
 +
device --> device_dma_parameters
 +
device --> dma_coherent_mem
 +
device --> dev_archdata
 +
device --> device_node
 +
device --> acpi_dev_node
 +
device --> klist_node
 +
device --> class
 +
device --> attribute_group
 +
device --> device
 +
device --> iommu_group
 +
 
 +
 
 +
 
 +
class scsi_host_template << (S,#FF7700)/scsi/scsi_host.h >> {
 +
struct module *module;
 +
const char *name;
 +
int (* detect)(struct scsi_host_template *);
 +
int (* release)(struct Scsi_Host *);
 +
const char *(* info)(struct Scsi_Host *);
 +
int (* ioctl)(struct scsi_device *dev, int cmd, void __user *arg);
 +
}
 +
scsi_host_template --> module
 +
 
 +
 
 +
class bio << (S,#FF7700)/linux/blk_types.h >> {
 +
struct bio *bi_next;
 +
struct block_device *bi_bdev;
 +
unsigned long bi_flags;
 +
unsigned long bi_rw;
 +
struct bvec_iter bi_iter;
 +
unsigned int bi_phys_segments;
 +
unsigned int bi_seg_front_size;
 +
unsigned int bi_seg_back_size;
 +
atomic_t bi_remaining;
 +
bio_end_io_t *bi_end_io;
 +
void *bi_private;
 +
unsigned short bi_vcnt;
 +
unsigned short bi_max_vecs;
 +
atomic_t bi_cnt;       
 +
struct bio_vec *bi_io_vec;
 +
struct bio_set *bi_pool;
 +
struct bio_vec bi_inline_vecs[0];
 +
}
 +
bio --> block_device
 +
bio --> bvec_iter
 +
bio --> bio_vec
 +
bio --> bio_set
 +
 
 +
 
 +
class bio_list << (S,#FF7700)linux/bio.h >> {
 +
struct bio *head;
 +
struct bio *tail;
 +
}
 +
bio_list --> bio
 +
 
 +
 
 +
class request << (S,#FF7700)/linux/blkdev.h >> {
 +
struct list_head queuelist;
 +
union {
 +
      struct call_single_data csd;
 +
      struct work_struct mq_flush_work;
 +
};
 +
struct request_queue *q;
 +
struct blk_mq_ctx *mq_ctx;
 +
u64 cmd_flags;
 +
enum rq_cmd_type_bits cmd_type;
 +
unsigned long atomic_flags;
 +
int cpu;
 +
unsigned int __data_len;
 +
sector_t __sector;
 +
struct bio *bio;
 +
struct bio *biotail;
 +
struct hlist_node hash;
 +
union {
 +
struct rb_node rb_node;
 +
void *completion_data;
 +
};
 +
union {
 +
struct {
 +
struct io_cq *icq;
 +
void *priv[2];
 +
} elv;
 +
struct {
 +
unsigned int seq;
 +
struct list_head list;
 +
rq_end_io_fn *saved_end_io;
 +
} flush;
 +
};
 +
struct gendisk *rq_disk;
 +
struct hd_struct *part;
 +
unsigned long start_time;
 +
unsigned short ioprio;
 +
void *special; 
 +
char *buffer;
 +
int tag;
 +
int errors;
 +
unsigned char __cmd[BLK_MAX_CDB];
 +
unsigned char *cmd;
 +
unsigned short cmd_len;
 +
unsigned int extra_len;
 +
unsigned int sense_len;
 +
unsigned int resid_len;
 +
void *sense;
 +
unsigned long deadline;
 +
struct list_head timeout_list;
 +
unsigned int timeout;
 +
int retries;
 +
rq_end_io_fn *end_io;
 +
void *end_io_data;
 +
struct request *next_rq;
 +
}
 +
request --> call_single_data
 +
request --> work_struct
 +
request --> request_queue
 +
request --> blk_mq_ctx
 +
request --> bio
 +
request --> hlist_node
 +
request --> rb_node
 +
request --> io_cq
 +
request --> gendisk
 +
request --> hd_struct
 +
 
 +
 
 +
class blk_plug << (S,#FF7700)/linux/blkdev.h >> {
 +
unsigned long magic;
 +
struct list_head list;
 +
struct list_head mq_list;
 +
struct list_head cb_list;
 +
}
 +
blk_plug --> list_head
 +
 
 +
 
 +
class scsi_device << (S,#FF7700)/scsi/scsi_device >> {
 +
struct Scsi_Host *host;
 +
struct request_queue *request_queue;
 +
struct list_head    siblings; 
 +
struct list_head    same_target_siblings;
 +
unsigned int device_busy;
 +
spinlock_t list_lock;
 +
struct list_head cmd_list; 
 +
struct list_head starved_entry;
 +
struct scsi_cmnd *current_cmnd;
 +
unsigned short queue_depth;   
 +
unsigned short max_queue_depth;
 +
unsigned short last_queue_full_depth;
 +
unsigned short last_queue_full_count;
 +
unsigned long last_queue_full_time; 
 +
unsigned long queue_ramp_up_period; 
 +
unsigned long last_queue_ramp_up;
 +
unsigned int id, lun, channel;
 +
unsigned int manufacturer;
 +
unsigned sector_size;
 +
void *hostdata;
 +
char type;
 +
char scsi_level;
 +
char inq_periph_qual;
 +
unsigned char inquiry_len;
 +
unsigned char * inquiry; 
 +
const char * vendor;       
 +
const char * model;         
 +
const char * rev;           
 +
unsigned char current_tag;     
 +
struct scsi_target *sdev_target;
 +
unsigned int sdev_bflags;
 +
unsigned int eh_timeout;
 +
unsigned writeable:1;
 +
unsigned removable:1;
 +
unsigned changed:1;   
 +
unsigned busy:1;     
 +
unsigned lockable:1; 
 +
unsigned locked:1;   
 +
unsigned borken:1;
 +
unsigned disconnect:1;
 +
unsigned soft_reset:1; 
 +
unsigned sdtr:1;     
 +
unsigned wdtr:1;       
 +
unsigned ppr:1;     
 +
unsigned tagged_supported:1;
 +
unsigned simple_tags:1;
 +
unsigned ordered_tags:1;
 +
unsigned was_reset:1;
 +
unsigned expecting_cc_ua:1;
 +
unsigned use_10_for_rw:1;
 +
unsigned use_10_for_ms:1;
 +
unsigned no_report_opcodes:1; 
 +
unsigned no_write_same:1;   
 +
unsigned use_16_for_rw:1;
 +
unsigned skip_ms_page_8:1;   
 +
unsigned skip_ms_page_3f:1;   
 +
unsigned skip_vpd_pages:1;     
 +
unsigned use_192_bytes_for_3f:1;
 +
unsigned no_start_on_add:1; 
 +
unsigned allow_restart:1;
 +
unsigned manage_start_stop:1;
 +
unsigned start_stop_pwr_cond:1;
 +
unsigned no_uld_attach:1;
 +
unsigned select_no_atn:1;
 +
unsigned fix_capacity:1;   
 +
unsigned guess_capacity:1;   
 +
unsigned retry_hwerror:1;     
 +
unsigned last_sector_bug:1;
 +
unsigned no_read_disc_info:1; 
 +
unsigned no_read_capacity_16:1;
 +
unsigned try_rc_10_first:1;   
 +
unsigned is_visible:1; 
 +
unsigned wce_default_on:1;   
 +
unsigned no_dif:1;
 +
atomic_t disk_events_disable_depth;
 +
DECLARE_BITMAP(supported_events, SDEV_EVT_MAXBITS);
 +
DECLARE_BITMAP(pending_events, SDEV_EVT_MAXBITS);
 +
struct list_head event_list;
 +
struct work_struct event_work;
 +
unsigned int device_blocked; 
 +
unsigned int max_device_blocked;
 +
}
 +
scsi_device --> Scsi_Host
 +
scsi_device --> request_queue
 +
scsi_device --> scsi_cmnd
 +
scsi_device --> scsi_target
 +
scsi_device --> work_struct
 +
 
 +
 
 +
class scsi_cmnd << (S,#FF7700)/scsi/scsi_cmnd.h >> {
 +
struct scsi_device *device;
 +
struct list_head list;
 +
struct list_head eh_entry;
 +
struct delayed_work abort_work;
 +
int eh_eflags;       
 +
unsigned long serial_number;
 +
unsigned long jiffies_at_alloc;
 +
int retries;
 +
int allowed;
 +
unsigned char prot_op;
 +
unsigned char prot_type;
 +
unsigned short cmd_len;
 +
enum dma_data_direction sc_data_direction;
 +
unsigned char *cmnd;
 +
struct scsi_data_buffer sdb;
 +
struct scsi_data_buffer *prot_sdb;
 +
unsigned underflow;
 +
unsigned transfersize;
 +
struct request *request;
 +
unsigned char *sense_buffer;
 +
void (*scsi_done) (struct scsi_cmnd *);
 +
struct scsi_pointer SCp;
 +
unsigned char *host_scribble;
 +
int result;
 +
unsigned char tag;
 +
}
 +
scsi_cmnd --> scsi_pointer
 +
scsi_cmnd --> scsi_device
 +
scsi_cmnd --> delayed_work
 +
scsi_cmnd --> scsi_data_buffer
 +
scsi_cmnd --> request
 +
 
 +
 
 +
 
 +
class scsi_pointer << (S,#77FF00)/scsi/scsi_cmnd.h >> {
 +
char *ptr;         
 +
int this_residual;   
 +
struct scatterlist *buffer;   
 +
int buffers_residual;
 +
dma_addr_t dma_handle;
 +
volatile int Status;
 +
volatile int Message;
 +
volatile int have_data_in;
 +
volatile int sent_command;
 +
volatile int phase;
 +
}
 +
scsi_pointer --> scatterlist
 +
 
 +
 
 +
 
 +
class scatterlist << (S,#77FF00)/asm-generic/scatterlist.h >> {
 +
unsigned long page_link;
 +
unsigned int offset;
 +
unsigned int length;
 +
dma_addr_t dma_address;
 +
}
 +
 
 +
 
 +
class delayed_work << (S,#77FF00)/linux/workqueue.h >> {
 +
struct work_struct work;
 +
struct timer_list timer;
 +
struct workqueue_struct *wq;
 +
int cpu;
 +
}
 +
delayed_work --> work_struct
 +
delayed_work --> timer_list
 +
delayed_work --> workqueue_struct
 +
 
 +
 
 +
class work_struct << (S,#77FF00)/linux/workqueue.h >> {
 +
atomic_long_t data;
 +
struct list_head entry;
 +
work_func_t func;
 +
}
 +
 
 +
 
 +
class timer_list << (S,#77FF00)/linux/timer.h >> {
 +
struct list_head entry;
 +
unsigned long expires;
 +
struct tvec_base *base;
 +
void (*function)(unsigned long);
 +
unsigned long data;
 +
int slack;
 +
}
 +
timer_list --> tvec_base
 +
 
 +
 
 +
class tvec_base << (S,#77FF00)/kernel/timer.c >> {
 +
spinlock_t lock;
 +
struct timer_list *running_timer;
 +
unsigned long timer_jiffies;
 +
unsigned long next_timer;
 +
unsigned long active_timers;
 +
struct tvec_root tv1;
 +
struct tvec tv2;
 +
struct tvec tv3;
 +
struct tvec tv4;
 +
struct tvec tv5;
 +
}
 +
tvec_base --> timer_list
 +
tvec_base --> tvec_root
 +
tvec_base --> tvec
 +
 
 +
 
 +
class tvec_root << (S,#77FF00)kernel/timer.c >> {
 +
struct list_head vec[TVR_SIZE];
 +
}
 +
 
 +
class tvec << (S,#77FF00)kernel/timer.c >> {
 +
struct list_head vec[TVN_SIZE];
 +
}
 +
 
 +
class workqueue_struct << (S,#77FF00)/kernel/workqueue.c >> {
 +
struct list_head pwqs;     
 +
struct list_head list;     
 +
struct mutex mutex; 
 +
int work_color;
 +
int flush_color; 
 +
atomic_t nr_pwqs_to_flush;
 +
struct wq_flusher *first_flusher;
 +
struct list_head flusher_queue; 
 +
struct list_head flusher_overflow;
 +
struct list_head maydays;     
 +
struct worker *rescuer;   
 +
int nr_drainers; 
 +
int saved_max_active;
 +
struct workqueue_attrs *unbound_attrs;
 +
struct pool_workqueue *dfl_pwq;
 +
}
 +
workqueue_struct --> mutex
 +
workqueue_struct --> wq_flusher
 +
workqueue_struct --> worker
 +
workqueue_struct --> workqueue_attrs
 +
workqueue_struct --> pool_workqueue
 +
 
 +
 
 +
class mutex <<(S,#77FF00)/linux/mutex.h >> {
 +
atomic_t count;
 +
spinlock_t wait_lock;
 +
struct list_head wait_list;
 +
}
 +
 
 +
 
 +
class wq_flusher << (S,#77FF00)/kernel/workqueue.c >> {
 +
struct list_head list;     
 +
int flush_color; 
 +
struct completion done;   
 +
}
 +
wq_flusher --> completion
 +
 
 +
 
 +
class completion << (S,#77FF00)/linux/completion.h >> {
 +
unsigned int done;
 +
wait_queue_head_t wait;
 +
}
 +
 
 +
class worker << (S,#77FF00)/kernel/workqueue_internal.h >> {
 +
union {
 +
struct list_head entry; 
 +
struct hlist_node hentry;
 +
};
 +
struct work_struct *current_work;
 +
work_func_t current_func;
 +
struct pool_workqueue *current_pwq;
 +
bool desc_valid;
 +
struct list_head scheduled;
 +
struct task_struct *task;         
 +
struct worker_pool *pool;
 +
unsigned long last_active;
 +
unsigned int flags;
 +
int id;
 +
struct workqueue_struct *rescue_wq;
 +
}
 +
worker --> hlist_node
 +
worker --> work_struct
 +
worker --> pool_workqueue
 +
worker --> worker_pool
 +
worker --> task_struct
 +
worker --> workqueue_struct
 +
 
 +
class hlist_node << (S,#77FF00)/linux/types.h >> {
 +
struct hlist_node *next, **pprev;
 +
}
 +
 
 +
class worker_pool << (S,#77FF00)/kernel/workqueue.c >> {
 +
spinlock_t lock;   
 +
int cpu;         
 +
int node;   
 +
int id;     
 +
unsigned int flags; 
 +
struct list_head worklist;   
 +
int nr_workers;   
 +
int nr_idle;     
 +
struct list_head idle_list;   
 +
struct timer_list idle_timer; 
 +
struct timer_list mayday_timer;
 +
}
 +
worker_pool --> timer_list
 +
 
 +
 
 +
class workqueue_attrs << (S,#77FF00)/linux/workqueue.h >> {
 +
int nice; 
 +
cpumask_var_t cpumask;
 +
bool no_numa;
 +
}
 +
 
 +
class pool_workqueue << (S,#77FF00)/linux/workqueue.c >> {
 +
struct worker_pool      *pool;
 +
struct workqueue_struct *wq;
 +
int work_color;
 +
int flush_color; 
 +
int refcnt; 
 +
int nr_in_flight[WORK_NR_COLORS];
 +
int nr_active;   
 +
int max_active;   
 +
struct list_head delayed_works;
 +
struct list_head pwqs_node;   
 +
struct list_head mayday_node; 
 +
struct work_struct unbound_release_work;
 +
struct rcu_head rcu;
 +
}
 +
pool_workqueue --> worker_pool
 +
pool_workqueue --> workqueue_struct
 +
pool_workqueue --> work_struct
 +
 
 +
 
 +
 
 +
class callback_head << (S,#77FF00)/linux/types.h >> {
 +
struct callback_head *next;
 +
void (*func)(struct callback_head *head);
 +
}
 +
 
 +
 
 +
class scsi_data_buffer << (S,#77FF00)/scsi/scsi_cmnd >> {
 +
struct sg_table table;
 +
unsigned length;
 +
int resid;
 +
}
 +
scsi_data_buffer --> sg_table
 +
 
 +
 
 +
class sg_table << (S,#77FF00)/linux/scatterlist.h >> {
 +
struct scatterlist *sgl;   
 +
unsigned int nents;         
 +
unsigned int orig_nents; 
 +
}
 +
sg_table --> scatterlist
 +
 
 +
 
 +
 
 +
class task_struct << (S,#77FF00)/linux/sched.h >> {
 +
volatile long state;
 +
void *stack;
 +
atomic_t usage;
 +
unsigned int flags; 
 +
unsigned int ptrace;
 +
int on_rq;
 +
int prio, static_prio, normal_prio;
 +
unsigned int rt_priority;
 +
const struct sched_class *sched_class;
 +
struct sched_entity se;
 +
struct sched_rt_entity rt;
 +
struct sched_dl_entity dl;
 +
unsigned int policy;
 +
int nr_cpus_allowed;
 +
cpumask_t cpus_allowed;
 +
int exit_state;
 +
int exit_code, exit_signal;
 +
int pdeath_signal;
 +
unsigned int jobctl;   
 +
unsigned int personality;
 +
unsigned in_execve:1;
 +
unsigned in_iowait:1;
 +
unsigned no_new_privs:1;
 +
unsigned sched_reset_on_fork:1;
 +
unsigned sched_contributes_to_load:1;
 +
pid_t pid;
 +
pid_t tgid;
 +
struct task_struct __rcu *real_parent;
 +
struct task_struct __rcu *parent;
 +
struct list_head children; 
 +
struct list_head sibling;     
 +
struct task_struct *group_leader;
 +
struct list_head ptraced;
 +
struct list_head ptrace_entry;
 +
struct pid_link pids[PIDTYPE_MAX];
 +
struct list_head thread_group;
 +
struct list_head thread_node;
 +
struct completion *vfork_done; 
 +
int __user *set_child_tid;       
 +
int __user *clear_child_tid;     
 +
cputime_t utime, stime, utimescaled, stimescaled;
 +
cputime_t gtime;
 +
unsigned long nvcsw, nivcsw;
 +
struct timespec start_time;         
 +
struct timespec real_start_time;   
 +
unsigned long min_flt, maj_flt;
 +
struct task_cputime cputime_expires;
 +
struct list_head cpu_timers[3];
 +
const struct cred __rcu *real_cred;
 +
const struct cred __rcu *cred;
 +
char comm[TASK_COMM_LEN];
 +
int link_count, total_link_count;
 +
struct thread_struct thread;
 +
struct fs_struct *fs;
 +
struct files_struct *files;
 +
struct nsproxy *nsproxy;
 +
struct signal_struct *signal;
 +
struct sighand_struct *sighand;
 +
sigset_t blocked, real_blocked;
 +
sigset_t saved_sigmask;
 +
struct sigpending pending;
 +
unsigned long sas_ss_sp;
 +
size_t sas_ss_size;
 +
int (*notifier)(void *priv);
 +
void *notifier_data;
 +
sigset_t *notifier_mask;
 +
struct callback_head *task_works;
 +
struct audit_context *audit_context;
 +
struct seccomp seccomp;
 +
u32 parent_exec_id;
 +
u32 self_exec_id;
 +
spinlock_t alloc_lock;
 +
raw_spinlock_t pi_lock;
 +
struct reclaim_state *reclaim_state;
 +
struct backing_dev_info *backing_dev_info;
 +
struct io_context *io_context;
 +
unsigned long ptrace_message;
 +
siginfo_t *last_siginfo;
 +
struct task_io_accounting ioac;
 +
struct rcu_head rcu;
 +
struct pipe_inode_info *splice_pipe;
 +
struct page_frag task_frag;
 +
int nr_dirtied;
 +
int nr_dirtied_pause;
 +
unsigned long dirty_paused_when;
 +
unsigned long timer_slack_ns;
 +
unsigned long default_timer_slack_ns;
 +
}
 +
task_struct --> sched_class
 +
task_struct --> sched_entity
 +
task_struct --> sched_rt_entity
 +
task_struct --> sched_dl_entity
 +
task_struct --> pid_link
 +
task_struct --> completion
 +
task_struct --> timespec
 +
task_struct --> task_cputime
 +
task_struct --> thread_struct
 +
task_struct --> fs_struct
 +
task_struct --> files_struct
 +
task_struct --> nsproxy
 +
task_struct --> signal_struct
 +
task_struct --> sighand_struct
 +
task_struct --> sigpending
 +
task_struct --> callback_head
 +
task_struct --> audit_context
 +
task_struct --> seccomp
 +
task_struct --> reclaim_state
 +
task_struct --> backing_dev_info
 +
task_struct --> io_context
 +
task_struct --> task_io_accounting
 +
task_struct --> pipe_inode_info
 +
task_struct --> page_frag
 +
 
 +
 
 +
 
 +
class rcu_head << (S,#77FF00)/linux/types.h >> {
 +
#define rcu_head callback_head
 +
}
 +
note left: So many structs reference this. So I don't draw line to this.
 +
rcu_head --> callback_head
 +
 
 +
 
 +
class list_head << (S,#77FF00)/scripts/kconfig/list.h >> {
 +
struct list_head *next, *prev;
 +
}
 +
note left: So many structs reference this. So I don't draw line to this.
 +
 
 +
 
 +
</uml>

2014년 5월 14일 (수) 21:18 현재 판

원본 주소 ‘http://swpark.hufs.ac.kr/wiki4lab/index.php?title=SYTest&oldid=23544’
개인 도구
이름공간
변수
행위
둘러보기
구성원
연구
연구실
기타
도구모음
인쇄/내보내기