leaving function in locked state

|static struct vfsmount *shm_mnt;
|struct inode;
|struct dentry;
|
|struct xattr_handler {
| const char *prefix;
| int flags;
| 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);
|};
|
|ssize_t xattr_getsecurity(struct inode *, const char *, void *, size_t);
|ssize_t vfs_getxattr(struct dentry *, const char *, void *, size_t);
|ssize_t vfs_listxattr(struct dentry *d, char *list, size_t size);
|int __vfs_setxattr_noperm(struct dentry *, const char *, const void *, size_t, int);
|int vfs_setxattr(struct dentry *, const char *, const void *, size_t, int);
|int vfs_removexattr(struct dentry *, const char *);
|
|ssize_t generic_getxattr(struct dentry *dentry, const char *name, void *buffer, size_t size);
|ssize_t generic_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size);
|int generic_setxattr(struct dentry *dentry, const char *name, const void *value, size_t size, int flags);
|int generic_removexattr(struct dentry *dentry, const char *name);
|
|
|
|
|
|struct dentry;
|struct inode;
|struct super_block;
|struct vfsmount;
|enum fid_type {
|
|
|
|
| FILEID_ROOT = 0,
|
|
|
|
| FILEID_INO32_GEN = 1,
|
|
|
|
|
| FILEID_INO32_GEN_PARENT = 2,
|
|
|
|
|
| FILEID_BTRFS_WITHOUT_PARENT = 0x4d,
|
|
|
|
|
|
| FILEID_BTRFS_WITH_PARENT = 0x4e,
|
|
|
|
|
|
|
| FILEID_BTRFS_WITH_PARENT_ROOT = 0x4f,
|
|
|
|
|
| FILEID_UDF_WITHOUT_PARENT = 0x51,
|
|
|
|
|
|
| FILEID_UDF_WITH_PARENT = 0x52,
|
|
|
|
|
| FILEID_NILFS_WITHOUT_PARENT = 0x61,
|
|
|
|
|
|
| FILEID_NILFS_WITH_PARENT = 0x62,
|};
|
|struct fid {
| union {
|  struct {
|   u32 ino;
|   u32 gen;
|   u32 parent_ino;
|   u32 parent_gen;
|  } i32;
|   struct {
|    u32 block;
|    u16 partref;
|    u16 parent_partref;
|    u32 generation;
|    u32 parent_block;
|    u32 parent_generation;
|   } udf;
|  __u32 raw[0];
| };
|};
|struct export_operations {
| int (*encode_fh)(struct dentry *de, __u32 *fh, int *max_len,
|   int connectable);
| 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);
|};
|
|extern int exportfs_encode_fh(struct dentry *dentry, struct fid *fid,
| int *max_len, int connectable);
|extern struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid,
| int fh_len, int fileid_type, int (*acceptable)(void *, struct dentry *),
| void *context);
|
|
|
|
|extern struct dentry *generic_fh_to_dentry(struct super_block *sb,
| struct fid *fid, int fh_len, int fh_type,
| struct inode *(*get_inode) (struct super_block *sb, u64 ino, u32 gen));
|extern struct dentry *generic_fh_to_parent(struct super_block *sb,
| struct fid *fid, int fh_len, int fh_type,
| struct inode *(*get_inode) (struct super_block *sb, u64 ino, u32 gen));
|void kmem_cache_init(void);
|int slab_is_available(void);
|
|struct kmem_cache *kmem_cache_create(const char *, size_t, size_t,
|   unsigned long,
|   void (*)(void *));
|void kmem_cache_destroy(struct kmem_cache *);
|int kmem_cache_shrink(struct kmem_cache *);
|void kmem_cache_free(struct kmem_cache *, void *);
|unsigned int kmem_cache_size(struct kmem_cache *);
|const char *kmem_cache_name(struct kmem_cache *);
|int kern_ptr_validate(const void *ptr, unsigned long size);
|int kmem_ptr_validate(struct kmem_cache *cachep, const void *ptr);
|void * __krealloc(const void *, size_t, gfp_t);
|void * krealloc(const void *, size_t, gfp_t);
|void kfree(const void *);
|void kzfree(const void *);
|size_t ksize(const void *);
|static inline void kmemleak_init(void)
|{
|}
|static inline void kmemleak_alloc(const void *ptr, size_t size, int min_count,
|      gfp_t gfp)
|{
|}
|static inline void kmemleak_alloc_recursive(const void *ptr, size_t size,
|         int min_count, unsigned long flags,
|         gfp_t gfp)
|{
|}
|static inline void kmemleak_free(const void *ptr)
|{
|}
|static inline void kmemleak_free_part(const void *ptr, size_t size)
|{
|}
|static inline void kmemleak_free_recursive(const void *ptr, unsigned long flags)
|{
|}
|static inline void kmemleak_not_leak(const void *ptr)
|{
|}
|static inline void kmemleak_ignore(const void *ptr)
|{
|}
|static inline void kmemleak_scan_area(const void *ptr, size_t size, gfp_t gfp)
|{
|}
|static inline void kmemleak_erase(void **ptr)
|{
|}
|static inline void kmemleak_no_scan(const void *ptr)
|{
|}
|
|enum stat_item {
| ALLOC_FASTPATH,
| ALLOC_SLOWPATH,
| FREE_FASTPATH,
| FREE_SLOWPATH,
| FREE_FROZEN,
| FREE_ADD_PARTIAL,
| FREE_REMOVE_PARTIAL,
| ALLOC_FROM_PARTIAL,
| ALLOC_SLAB,
| ALLOC_REFILL,
| FREE_SLAB,
| CPUSLAB_FLUSH,
| DEACTIVATE_FULL,
| DEACTIVATE_EMPTY,
| DEACTIVATE_TO_HEAD,
| DEACTIVATE_TO_TAIL,
| DEACTIVATE_REMOTE_FREES,
| ORDER_FALLBACK,
| NR_SLUB_STAT_ITEMS };
|
|struct kmem_cache_cpu {
| void **freelist;
| struct page *page;
| int node;
|
|
|
|};
|
|struct kmem_cache_node {
| spinlock_t list_lock;
| unsigned long nr_partial;
| struct list_head partial;
|
| atomic_long_t nr_slabs;
| atomic_long_t total_objects;
| struct list_head full;
|
|};
|
|
|
|
|
|
|struct kmem_cache_order_objects {
| unsigned long x;
|};
|
|
|
|
|struct kmem_cache {
| struct kmem_cache_cpu *cpu_slab;
|
| unsigned long flags;
| int size;
| int objsize;
| int offset;
| struct kmem_cache_order_objects oo;
|
|
| struct kmem_cache_order_objects max;
| struct kmem_cache_order_objects min;
| gfp_t allocflags;
| int refcount;
| void (*ctor)(void *);
| int inuse;
| int align;
| unsigned long min_partial;
| const char *name;
| struct list_head list;
|
| struct kobject kobj;
|
|
|
|
|
|
| int remote_node_defrag_ratio;
|
| struct kmem_cache_node *node[(1 << 10)];
|};
|extern struct kmem_cache *kmalloc_caches[(12 + 2)];
|
|
|
|
|
|static inline int kmalloc_index(size_t size)
|{
| if (!size)
|  return 0;
|
| if (size <= 8)
|  return ( __builtin_constant_p(8) ? ( (8) < 1 ? ____ilog2_NaN() : (8) & (1ULL << 63) ? 63 : (8) & (1ULL << 62) ? 62 : (8) & (1ULL << 61) ? 61 : (8) & (1ULL << 60) ? 60 : (8) & (1ULL << 59) ? 59 : (8) & (1ULL << 58) ? 58 : (8) & (1ULL << 57) ? 57 : (8) & (1ULL << 56) ? 56 : (8) & (1ULL << 55) ? 55 : (8) & (1ULL << 54) ? 54 : (8) & (1ULL << 53) ? 53 : (8) & (1ULL << 52) ? 52 : (8) & (1ULL << 51) ? 51 : (8) & (1ULL << 50) ? 50 : (8) & (1ULL << 49) ? 49 : (8) & (1ULL << 48) ? 48 : (8) & (1ULL << 47) ? 47 : (8) & (1ULL << 46) ? 46 : (8) & (1ULL << 45) ? 45 : (8) & (1ULL << 44) ? 44 : (8) & (1ULL << 43) ? 43 : (8) & (1ULL << 42) ? 42 : (8) & (1ULL << 41) ? 41 : (8) & (1ULL << 40) ? 40 : (8) & (1ULL << 39) ? 39 : (8) & (1ULL << 38) ? 38 : (8) & (1ULL << 37) ? 37 : (8) & (1ULL << 36) ? 36 : (8) & (1ULL << 35) ? 35 : (8) & (1ULL << 34) ? 34 : (8) & (1ULL << 33) ? 33 : (8) & (1ULL << 32) ? 32 : (8) & (1ULL << 31) ? 31 : (8) & (1ULL << 30) ? 30 : (8) & (1ULL << 29) ? 29 : (8) & (1ULL << 28) ? 28 : (8) & (1ULL << 27) ? 27 : (8) & (1ULL << 26) ? 26 : (8) & (1ULL << 25) ? 25 : (8) & (1ULL << 24) ? 24 : (8) & (1ULL << 23) ? 23 : (8) & (1ULL << 22) ? 22 : (8) & (1ULL << 21) ? 21 : (8) & (1ULL << 20) ? 20 : (8) & (1ULL << 19) ? 19 : (8) & (1ULL << 18) ? 18 : (8) & (1ULL << 17) ? 17 : (8) & (1ULL << 16) ? 16 : (8) & (1ULL << 15) ? 15 : (8) & (1ULL << 14) ? 14 : (8) & (1ULL << 13) ? 13 : (8) & (1ULL << 12) ? 12 : (8) & (1ULL << 11) ? 11 : (8) & (1ULL << 10) ? 10 : (8) & (1ULL << 9) ? 9 : (8) & (1ULL << 8) ? 8 : (8) & (1ULL << 7) ? 7 : (8) & (1ULL << 6) ? 6 : (8) & (1ULL << 5) ? 5 : (8) & (1ULL << 4) ? 4 : (8) & (1ULL << 3) ? 3 : (8) & (1ULL << 2) ? 2 : (8) & (1ULL << 1) ? 1 : (8) & (1ULL << 0) ? 0 : ____ilog2_NaN() ) : (sizeof(8) <= 4) ? __ilog2_u32(8) : __ilog2_u64(8) );
|
| if (8 <= 32 && size > 64 && size <= 96)
|  return 1;
| if (8 <= 64 && size > 128 && size <= 192)
|  return 2;
| if (size <= 8) return 3;
| if (size <= 16) return 4;
| if (size <= 32) return 5;
| if (size <= 64) return 6;
| if (size <= 128) return 7;
| if (size <= 256) return 8;
| if (size <= 512) return 9;
| if (size <= 1024) return 10;
| if (size <= 2 * 1024) return 11;
| if (size <= 4 * 1024) return 12;
|
|
|
|
| if (size <= 8 * 1024) return 13;
| if (size <= 16 * 1024) return 14;
| if (size <= 32 * 1024) return 15;
| if (size <= 64 * 1024) return 16;
| if (size <= 128 * 1024) return 17;
| if (size <= 256 * 1024) return 18;
| if (size <= 512 * 1024) return 19;
| if (size <= 1024 * 1024) return 20;
| if (size <= 2 * 1024 * 1024) return 21;
| return -1;
|}
|
|
|
|
|
|
|
|static inline struct kmem_cache *kmalloc_slab(size_t size)
|{
| int index = kmalloc_index(size);
|
| if (index == 0)
|  return ((void *)0);
|
| return kmalloc_caches[index];
|}
|
|void *kmem_cache_alloc(struct kmem_cache *, gfp_t);
|void *__kmalloc(size_t size, gfp_t flags);
|
|static inline void *
|kmalloc_order(size_t size, gfp_t flags, unsigned int order)
|{
| void *ret = (void *) __get_free_pages(flags | (( gfp_t)0x4000u), order);
| kmemleak_alloc(ret, size, 1, flags);
| return ret;
|}
|
|
|extern void *
|kmem_cache_alloc_trace(struct kmem_cache *s, gfp_t gfpflags, size_t size);
|extern void *kmalloc_order_trace(size_t size, gfp_t flags, unsigned int order);
|static inline void *kmalloc_large(size_t size, gfp_t flags)
|{
| unsigned int order = get_order(size);
| return kmalloc_order_trace(size, flags, order);
|}
|
|static inline void *kmalloc(size_t size, gfp_t flags)
|{
| if (__builtin_constant_p(size)) {
|  if (size > (2 * ((1UL) << 12)))
|   return kmalloc_large(size, flags);
|
|  if (!(flags & (( gfp_t)0x01u))) {
|   struct kmem_cache *s = kmalloc_slab(size);
|
|   if (!s)
|    return ((void *)16);
|
|   return kmem_cache_alloc_trace(s, flags, size);
|  }
| }
| return __kmalloc(size, flags);
|}
|
|
|void *__kmalloc_node(size_t size, gfp_t flags, int node);
|void *kmem_cache_alloc_node(struct kmem_cache *, gfp_t flags, int node);
|
|
|extern void *kmem_cache_alloc_node_trace(struct kmem_cache *s,
|        gfp_t gfpflags,
|        int node, size_t size);
|static inline void *kmalloc_node(size_t size, gfp_t flags, int node)
|{
| if (__builtin_constant_p(size) &&
|  size <= (2 * ((1UL) << 12)) && !(flags & (( gfp_t)0x01u))) {
|   struct kmem_cache *s = kmalloc_slab(size);
|
|  if (!s)
|   return ((void *)16);
|
|  return kmem_cache_alloc_node_trace(s, flags, node, size);
| }
| return __kmalloc_node(size, flags, node);
|}
|static inline void *kcalloc(size_t n, size_t size, gfp_t flags)
|{
| if (size != 0 && n > (~0UL) / size)
|  return ((void *)0);
| return __kmalloc(n * size, flags | (( gfp_t)0x8000u));
|}
|extern void *__kmalloc_track_caller(size_t, gfp_t, unsigned long);
|extern void *__kmalloc_node_track_caller(size_t, gfp_t, int, unsigned long);
|static inline void *kmem_cache_zalloc(struct kmem_cache *k, gfp_t flags)
|{
| return kmem_cache_alloc(k, flags | (( gfp_t)0x8000u));
|}
|
|
|
|
|
|
|static inline void *kzalloc(size_t size, gfp_t flags)
|{
| return kmalloc(size, flags | (( gfp_t)0x8000u));
|}
|
|
|
|
|
|
|
|static inline void *kzalloc_node(size_t size, gfp_t flags, int node)
|{
| return kmalloc_node(size, flags | (( gfp_t)0x8000u), node);
|}
|
|void kmem_cache_init_late(void);
|struct posix_acl_entry {
| short e_tag;
| unsigned short e_perm;
| unsigned int e_id;
|};
|
|struct posix_acl {
| atomic_t a_refcount;
| unsigned int a_count;
| struct posix_acl_entry a_entries[0];
|};
|static inline struct posix_acl *
|posix_acl_dup(struct posix_acl *acl)
|{
| if (acl)
|  atomic_inc(&acl->a_refcount);
| return acl;
|}
|
|
|
|
|static inline void
|posix_acl_release(struct posix_acl *acl)
|{
| if (acl && atomic_dec_and_test(&acl->a_refcount))
|  kfree(acl);
|}
|
|
|
|
|extern struct posix_acl *posix_acl_alloc(int, gfp_t);
|extern struct posix_acl *posix_acl_clone(const struct posix_acl *, gfp_t);
|extern int posix_acl_valid(const struct posix_acl *);
|extern int posix_acl_permission(struct inode *, const struct posix_acl *, int);
|extern struct posix_acl *posix_acl_from_mode(mode_t, gfp_t);
|extern int posix_acl_equiv_mode(const struct posix_acl *, mode_t *);
|extern int posix_acl_create_masq(struct posix_acl *, mode_t *);
|extern int posix_acl_chmod_masq(struct posix_acl *, mode_t);
|
|extern struct posix_acl *get_posix_acl(struct inode *, int);
|extern int set_posix_acl(struct inode *, int, struct posix_acl *);
|
|
|static inline struct posix_acl *get_cached_acl(struct inode *inode, int type)
|{
| struct posix_acl **p, *acl;
| switch (type) {
| case (0x8000):
|  p = &inode->i_acl;
|  break;
| case (0x4000):
|  p = &inode->i_default_acl;
|  break;
| default:
|  return ERR_PTR(-22);
| }
| acl = (*(volatile typeof(*p) *)&(*p));
| if (acl) {
|  spin_lock(&inode->i_lock);
|  acl = *p;
|  if (acl != ((void *)(-1)))
|   acl = posix_acl_dup(acl);
|  spin_unlock(&inode->i_lock);
| }
| return acl;
|}
|
|static inline void set_cached_acl(struct inode *inode,
|      int type,
|      struct posix_acl *acl)
|{
| struct posix_acl *old = ((void *)0);
| spin_lock(&inode->i_lock);
| switch (type) {
| case (0x8000):
|  old = inode->i_acl;
|  inode->i_acl = posix_acl_dup(acl);
|  break;
| case (0x4000):
|  old = inode->i_default_acl;
|  inode->i_default_acl = posix_acl_dup(acl);
|  break;
| }
| spin_unlock(&inode->i_lock);
| if (old != ((void *)(-1)))
|  posix_acl_release(old);
|}
|
|static inline void forget_cached_acl(struct inode *inode, int type)
|{
| struct posix_acl *old = ((void *)0);
| spin_lock(&inode->i_lock);
| switch (type) {
| case (0x8000):
|  old = inode->i_acl;
|  inode->i_acl = ((void *)(-1));
|  break;
| case (0x4000):
|  old = inode->i_default_acl;
|  inode->i_default_acl = ((void *)(-1));
|  break;
| }
| spin_unlock(&inode->i_lock);
| if (old != ((void *)(-1)))
|  posix_acl_release(old);
|}
|
|static inline void forget_all_cached_acls(struct inode *inode)
|{
| struct posix_acl *old_access, *old_default;
| spin_lock(&inode->i_lock);
| old_access = inode->i_acl;
| old_default = inode->i_default_acl;
| inode->i_acl = inode->i_default_acl = ((void *)(-1));
| spin_unlock(&inode->i_lock);
| if (old_access != ((void *)(-1)))
|  posix_acl_release(old_access);
| if (old_default != ((void *)(-1)))
|  posix_acl_release(old_default);
|}
|
|
|static inline void cache_no_acl(struct inode *inode)
|{
|
| inode->i_acl = ((void *)0);
| inode->i_default_acl = ((void *)0);
|
|}
|
|
|
|
|
|struct inode;
|
|extern const struct xattr_handler generic_acl_access_handler;
|extern const struct xattr_handler generic_acl_default_handler;
|
|int generic_acl_init(struct inode *, struct inode *);
|int generic_acl_chmod(struct inode *);
|int generic_check_acl(struct inode *inode, int mask);
|
|
|
|
|
|
|
|
|
|
|
|extern int sysctl_overcommit_memory;
|extern int sysctl_overcommit_ratio;
|extern struct percpu_counter vm_committed_as;
|
|static inline void vm_acct_memory(long pages)
|{
| percpu_counter_add(&vm_committed_as, pages);
|}
|
|static inline void vm_unacct_memory(long pages)
|{
| vm_acct_memory(-pages);
|}
|static inline int arch_validate_prot(unsigned long prot)
|{
| return (prot & ~(0x1 | 0x2 | 0x4 | 0x8)) == 0;
|}
|static inline unsigned long
|calc_vm_prot_bits(unsigned long prot)
|{
| return ((0x1) <= (0x00000001) ? ((prot) & (0x1)) * ((0x00000001) / (0x1)) : ((prot) & (0x1)) / ((0x1) / (0x00000001))) |
|        ((0x2) <= (0x00000002) ? ((prot) & (0x2)) * ((0x00000002) / (0x2)) : ((prot) & (0x2)) / ((0x2) / (0x00000002))) |
|        ((0x4) <= (0x00000004) ? ((prot) & (0x4)) * ((0x00000004) / (0x4)) : ((prot) & (0x4)) / ((0x4) / (0x00000004))) |
|        0;
|}
|
|
|
|
|static inline unsigned long
|calc_vm_flag_bits(unsigned long flags)
|{
| return ((0x0100) <= (0x00000100) ? ((flags) & (0x0100)) * ((0x00000100) / (0x0100)) : ((flags) & (0x0100)) / ((0x0100) / (0x00000100))) |
|        ((0x0800) <= (0x00000800) ? ((flags) & (0x0800)) * ((0x00000800) / (0x0800)) : ((flags) & (0x0800)) / ((0x0800) / (0x00000800))) |
|        ((0x1000) <= (0x00001000) ? ((flags) & (0x1000)) * ((0x00001000) / (0x1000)) : ((flags) & (0x1000)) / ((0x1000) / (0x00001000))) |
|        ((0x2000) <= (0x00002000) ? ((flags) & (0x2000)) * ((0x00002000) / (0x2000)) : ((flags) & (0x2000)) / ((0x2000) / (0x00002000)));
|}
|
|
|struct backing_dev_info;
|
|extern spinlock_t inode_lock;
|
|
|
|
|enum writeback_sync_modes {
| WB_SYNC_NONE,
| WB_SYNC_ALL,
|};
|
|
|
|
|
|
|struct writeback_control {
| enum writeback_sync_modes sync_mode;
| unsigned long *older_than_this;
|
| unsigned long wb_start;
|
|
| long nr_to_write;
|
| long pages_skipped;
|
|
|
|
|
|
| loff_t range_start;
| loff_t range_end;
|
| unsigned nonblocking:1;
| unsigned encountered_congestion:1;
| unsigned for_kupdate:1;
| unsigned for_background:1;
| unsigned for_reclaim:1;
| unsigned range_cyclic:1;
| unsigned more_io:1;
|};
|
|
|
|
|struct bdi_writeback;
|int inode_wait(void *);
|void writeback_inodes_sb(struct super_block *);
|void writeback_inodes_sb_nr(struct super_block *, unsigned long nr);
|int writeback_inodes_sb_if_idle(struct super_block *);
|int writeback_inodes_sb_nr_if_idle(struct super_block *, unsigned long nr);
|void sync_inodes_sb(struct super_block *);
|void writeback_inodes_wb(struct bdi_writeback *wb,
|  struct writeback_control *wbc);
|long wb_do_writeback(struct bdi_writeback *wb, int force_wait);
|void wakeup_flusher_threads(long nr_pages);
|
|
|static inline void wait_on_inode(struct inode *inode)
|{
| do { __might_sleep("/home/l/latest/linux/include/linux/writeback.h", 73, 0); do { } while (0); } while (0);
| wait_on_bit(&inode->i_state, 3, inode_wait, 2);
|}
|static inline void inode_sync_wait(struct inode *inode)
|{
| do { __might_sleep("/home/l/latest/linux/include/linux/writeback.h", 78, 0); do { } while (0); } while (0);
| wait_on_bit(&inode->i_state, 7, inode_wait,
|       2);
|}
|
|
|
|
|
|
|void laptop_io_completion(struct backing_dev_info *info);
|void laptop_sync_completion(void);
|void laptop_mode_sync(struct work_struct *work);
|void laptop_mode_timer_fn(unsigned long data);
|
|
|
|void throttle_vm_writeout(gfp_t gfp_mask);
|
|
|extern int dirty_background_ratio;
|extern unsigned long dirty_background_bytes;
|extern int vm_dirty_ratio;
|extern unsigned long vm_dirty_bytes;
|extern unsigned int dirty_writeback_interval;
|extern unsigned int dirty_expire_interval;
|extern int vm_highmem_is_dirtyable;
|extern int block_dump;
|extern int laptop_mode;
|
|extern unsigned long determine_dirtyable_memory(void);
|
|extern int dirty_background_ratio_handler(struct ctl_table *table, int write,
|  void *buffer, size_t *lenp,
|  loff_t *ppos);
|extern int dirty_background_bytes_handler(struct ctl_table *table, int write,
|  void *buffer, size_t *lenp,
|  loff_t *ppos);
|extern int dirty_ratio_handler(struct ctl_table *table, int write,
|  void *buffer, size_t *lenp,
|  loff_t *ppos);
|extern int dirty_bytes_handler(struct ctl_table *table, int write,
|  void *buffer, size_t *lenp,
|  loff_t *ppos);
|
|struct ctl_table;
|int dirty_writeback_centisecs_handler(struct ctl_table *, int,
|          void *, size_t *, loff_t *);
|
|void global_dirty_limits(unsigned long *pbackground, unsigned long *pdirty);
|unsigned long bdi_dirty_limit(struct backing_dev_info *bdi,
|          unsigned long dirty);
|
|void page_writeback_init(void);
|void balance_dirty_pages_ratelimited_nr(struct address_space *mapping,
|     unsigned long nr_pages_dirtied);
|
|static inline void
|balance_dirty_pages_ratelimited(struct address_space *mapping)
|{
| balance_dirty_pages_ratelimited_nr(mapping, 1);
|}
|
|typedef int (*writepage_t)(struct page *page, struct writeback_control *wbc,
|    void *data);
|
|int generic_writepages(struct address_space *mapping,
|         struct writeback_control *wbc);
|void tag_pages_for_writeback(struct address_space *mapping,
|        unsigned long start, unsigned long end);
|int write_cache_pages(struct address_space *mapping,
|        struct writeback_control *wbc, writepage_t writepage,
|        void *data);
|int do_writepages(struct address_space *mapping, struct writeback_control *wbc);
|void set_page_dirty_balance(struct page *page, int page_mkwrite);
|void writeback_set_ratelimit(void);
|void tag_pages_for_writeback(struct address_space *mapping,
|        unsigned long start, unsigned long end);
|
|
|extern int nr_pdflush_threads;
|
|
|struct page;
|struct device;
|struct dentry;
|
|
|
|
|enum bdi_state {
| BDI_pending,
| BDI_wb_alloc,
| BDI_async_congested,
| BDI_sync_congested,
| BDI_registered,
| BDI_writeback_running,
| BDI_unused,
|};
|
|typedef int (congested_fn)(void *, int);
|
|enum bdi_stat_item {
| BDI_RECLAIMABLE,
| BDI_WRITEBACK,
| NR_BDI_STAT_ITEMS
|};
|
|
|
|struct bdi_writeback {
| struct backing_dev_info *bdi;
| unsigned int nr;
|
| unsigned long last_old_flush;
| unsigned long last_active;
|
| struct task_struct *task;
| struct timer_list wakeup_timer;
| struct list_head b_dirty;
| struct list_head b_io;
| struct list_head b_more_io;
|};
|
|struct backing_dev_info {
| struct list_head bdi_list;
| unsigned long ra_pages;
| unsigned long state;
| unsigned int capabilities;
| congested_fn *congested_fn;
| void *congested_data;
| void (*unplug_io_fn)(struct backing_dev_info *, struct page *);
| void *unplug_io_data;
|
| char *name;
|
| struct percpu_counter bdi_stat[NR_BDI_STAT_ITEMS];
|
| struct prop_local_percpu completions;
| int dirty_exceeded;
|
| unsigned int min_ratio;
| unsigned int max_ratio, max_prop_frac;
|
| struct bdi_writeback wb;
| spinlock_t wb_lock;
|
| struct list_head work_list;
|
| struct device *dev;
|
| struct timer_list laptop_mode_wb_timer;
|
|
| struct dentry *debug_dir;
| struct dentry *debug_stats;
|
|};
|
|int bdi_init(struct backing_dev_info *bdi);
|void bdi_destroy(struct backing_dev_info *bdi);
|
|int bdi_register(struct backing_dev_info *bdi, struct device *parent,
|  const char *fmt, ...);
|int bdi_register_dev(struct backing_dev_info *bdi, dev_t dev);
|void bdi_unregister(struct backing_dev_info *bdi);
|int bdi_setup_and_register(struct backing_dev_info *, char *, unsigned int);
|void bdi_start_writeback(struct backing_dev_info *bdi, long nr_pages);
|void bdi_start_background_writeback(struct backing_dev_info *bdi);
|int bdi_writeback_thread(void *data);
|int bdi_has_dirty_io(struct backing_dev_info *bdi);
|void bdi_arm_supers_timer(void);
|void bdi_wakeup_thread_delayed(struct backing_dev_info *bdi);
|
|extern spinlock_t bdi_lock;
|extern struct list_head bdi_list;
|extern struct list_head bdi_pending_list;
|
|static inline int wb_has_dirty_io(struct bdi_writeback *wb)
|{
| return !list_empty(&wb->b_dirty) ||
|        !list_empty(&wb->b_io) ||
|        !list_empty(&wb->b_more_io);
|}
|
|static inline void __add_bdi_stat(struct backing_dev_info *bdi,
|  enum bdi_stat_item item, s64 amount)
|{
| __percpu_counter_add(&bdi->bdi_stat[item], amount, (8*(1+( __builtin_constant_p(nr_cpu_ids) ? ( (nr_cpu_ids) < 1 ? ____ilog2_NaN() : (nr_cpu_ids) & (1ULL << 63) ? 63 : (nr_cpu_ids) & (1ULL << 62) ? 62 : (nr_cpu_ids) & (1ULL << 61) ? 61 : (nr_cpu_ids) & (1ULL << 60) ? 60 : (nr_cpu_ids) & (1ULL << 59) ? 59 : (nr_cpu_ids) & (1ULL << 58) ? 58 : (nr_cpu_ids) & (1ULL << 57) ? 57 : (nr_cpu_ids) & (1ULL << 56) ? 56 : (nr_cpu_ids) & (1ULL << 55) ? 55 : (nr_cpu_ids) & (1ULL << 54) ? 54 : (nr_cpu_ids) & (1ULL << 53) ? 53 : (nr_cpu_ids) & (1ULL << 52) ? 52 : (nr_cpu_ids) & (1ULL << 51) ? 51 : (nr_cpu_ids) & (1ULL << 50) ? 50 : (nr_cpu_ids) & (1ULL << 49) ? 49 : (nr_cpu_ids) & (1ULL << 48) ? 48 : (nr_cpu_ids) & (1ULL << 47) ? 47 : (nr_cpu_ids) & (1ULL << 46) ? 46 : (nr_cpu_ids) & (1ULL << 45) ? 45 : (nr_cpu_ids) & (1ULL << 44) ? 44 : (nr_cpu_ids) & (1ULL << 43) ? 43 : (nr_cpu_ids) & (1ULL << 42) ? 42 : (nr_cpu_ids) & (1ULL << 41) ? 41 : (nr_cpu_ids) & (1ULL << 40) ? 40 : (nr_cpu_ids) & (1ULL << 39) ? 39 : (nr_cpu_ids) & (1ULL << 38) ? 38 : (nr_cpu_ids) & (1ULL << 37) ? 37 : (nr_cpu_ids) & (1ULL << 36) ? 36 : (nr_cpu_ids) & (1ULL << 35) ? 35 : (nr_cpu_ids) & (1ULL << 34) ? 34 : (nr_cpu_ids) & (1ULL << 33) ? 33 : (nr_cpu_ids) & (1ULL << 32) ? 32 : (nr_cpu_ids) & (1ULL << 31) ? 31 : (nr_cpu_ids) & (1ULL << 30) ? 30 : (nr_cpu_ids) & (1ULL << 29) ? 29 : (nr_cpu_ids) & (1ULL << 28) ? 28 : (nr_cpu_ids) & (1ULL << 27) ? 27 : (nr_cpu_ids) & (1ULL << 26) ? 26 : (nr_cpu_ids) & (1ULL << 25) ? 25 : (nr_cpu_ids) & (1ULL << 24) ? 24 : (nr_cpu_ids) & (1ULL << 23) ? 23 : (nr_cpu_ids) & (1ULL << 22) ? 22 : (nr_cpu_ids) & (1ULL << 21) ? 21 : (nr_cpu_ids) & (1ULL << 20) ? 20 : (nr_cpu_ids) & (1ULL << 19) ? 19 : (nr_cpu_ids) & (1ULL << 18) ? 18 : (nr_cpu_ids) & (1ULL << 17) ? 17 : (nr_cpu_ids) & (1ULL << 16) ? 16 : (nr_cpu_ids) & (1ULL << 15) ? 15 : (nr_cpu_ids) & (1ULL << 14) ? 14 : (nr_cpu_ids) & (1ULL << 13) ? 13 : (nr_cpu_ids) & (1ULL << 12) ? 12 : (nr_cpu_ids) & (1ULL << 11) ? 11 : (nr_cpu_ids) & (1ULL << 10) ? 10 : (nr_cpu_ids) & (1ULL << 9) ? 9 : (nr_cpu_ids) & (1ULL << 8) ? 8 : (nr_cpu_ids) & (1ULL << 7) ? 7 : (nr_cpu_ids) & (1ULL << 6) ? 6 : (nr_cpu_ids) & (1ULL << 5) ? 5 : (nr_cpu_ids) & (1ULL << 4) ? 4 : (nr_cpu_ids) & (1ULL << 3) ? 3 : (nr_cpu_ids) & (1ULL << 2) ? 2 : (nr_cpu_ids) & (1ULL << 1) ? 1 : (nr_cpu_ids) & (1ULL << 0) ? 0 : ____ilog2_NaN() ) : (sizeof(nr_cpu_ids) <= 4) ? __ilog2_u32(nr_cpu_ids) : __ilog2_u64(nr_cpu_ids) ))));
|}
|
|static inline void __inc_bdi_stat(struct backing_dev_info *bdi,
|  enum bdi_stat_item item)
|{
| __add_bdi_stat(bdi, item, 1);
|}
|
|static inline void inc_bdi_stat(struct backing_dev_info *bdi,
|  enum bdi_stat_item item)
|{
| unsigned long flags;
|
| do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0); trace_hardirqs_off(); } while (0);
| __inc_bdi_stat(bdi, item);
| do { if (({ ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_irqs_disabled_flags(flags); })) { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(flags); } while (0); trace_hardirqs_off(); } else { trace_hardirqs_on(); do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(flags); } while (0); } } while (0);
|}
|
|static inline void __dec_bdi_stat(struct backing_dev_info *bdi,
|  enum bdi_stat_item item)
|{
| __add_bdi_stat(bdi, item, -1);
|}
|
|static inline void dec_bdi_stat(struct backing_dev_info *bdi,
|  enum bdi_stat_item item)
|{
| unsigned long flags;
|
| do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0); trace_hardirqs_off(); } while (0);
| __dec_bdi_stat(bdi, item);
| do { if (({ ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_irqs_disabled_flags(flags); })) { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(flags); } while (0); trace_hardirqs_off(); } else { trace_hardirqs_on(); do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(flags); } while (0); } } while (0);
|}
|
|static inline s64 bdi_stat(struct backing_dev_info *bdi,
|  enum bdi_stat_item item)
|{
| return percpu_counter_read_positive(&bdi->bdi_stat[item]);
|}
|
|static inline s64 __bdi_stat_sum(struct backing_dev_info *bdi,
|  enum bdi_stat_item item)
|{
| return percpu_counter_sum_positive(&bdi->bdi_stat[item]);
|}
|
|static inline s64 bdi_stat_sum(struct backing_dev_info *bdi,
|  enum bdi_stat_item item)
|{
| s64 sum;
| unsigned long flags;
|
| do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0); trace_hardirqs_off(); } while (0);
| sum = __bdi_stat_sum(bdi, item);
| do { if (({ ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_irqs_disabled_flags(flags); })) { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(flags); } while (0); trace_hardirqs_off(); } else { trace_hardirqs_on(); do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_local_irq_restore(flags); } while (0); } } while (0);
|
| return sum;
|}
|
|extern void bdi_writeout_inc(struct backing_dev_info *bdi);
|
|
|
|
|static inline unsigned long bdi_stat_error(struct backing_dev_info *bdi)
|{
|
| return nr_cpu_ids * (8*(1+( __builtin_constant_p(nr_cpu_ids) ? ( (nr_cpu_ids) < 1 ? ____ilog2_NaN() : (nr_cpu_ids) & (1ULL << 63) ? 63 : (nr_cpu_ids) & (1ULL << 62) ? 62 : (nr_cpu_ids) & (1ULL << 61) ? 61 : (nr_cpu_ids) & (1ULL << 60) ? 60 : (nr_cpu_ids) & (1ULL << 59) ? 59 : (nr_cpu_ids) & (1ULL << 58) ? 58 : (nr_cpu_ids) & (1ULL << 57) ? 57 : (nr_cpu_ids) & (1ULL << 56) ? 56 : (nr_cpu_ids) & (1ULL << 55) ? 55 : (nr_cpu_ids) & (1ULL << 54) ? 54 : (nr_cpu_ids) & (1ULL << 53) ? 53 : (nr_cpu_ids) & (1ULL << 52) ? 52 : (nr_cpu_ids) & (1ULL << 51) ? 51 : (nr_cpu_ids) & (1ULL << 50) ? 50 : (nr_cpu_ids) & (1ULL << 49) ? 49 : (nr_cpu_ids) & (1ULL << 48) ? 48 : (nr_cpu_ids) & (1ULL << 47) ? 47 : (nr_cpu_ids) & (1ULL << 46) ? 46 : (nr_cpu_ids) & (1ULL << 45) ? 45 : (nr_cpu_ids) & (1ULL << 44) ? 44 : (nr_cpu_ids) & (1ULL << 43) ? 43 : (nr_cpu_ids) & (1ULL << 42) ? 42 : (nr_cpu_ids) & (1ULL << 41) ? 41 : (nr_cpu_ids) & (1ULL << 40) ? 40 : (nr_cpu_ids) & (1ULL << 39) ? 39 : (nr_cpu_ids) & (1ULL << 38) ? 38 : (nr_cpu_ids) & (1ULL << 37) ? 37 : (nr_cpu_ids) & (1ULL << 36) ? 36 : (nr_cpu_ids) & (1ULL << 35) ? 35 : (nr_cpu_ids) & (1ULL << 34) ? 34 : (nr_cpu_ids) & (1ULL << 33) ? 33 : (nr_cpu_ids) & (1ULL << 32) ? 32 : (nr_cpu_ids) & (1ULL << 31) ? 31 : (nr_cpu_ids) & (1ULL << 30) ? 30 : (nr_cpu_ids) & (1ULL << 29) ? 29 : (nr_cpu_ids) & (1ULL << 28) ? 28 : (nr_cpu_ids) & (1ULL << 27) ? 27 : (nr_cpu_ids) & (1ULL << 26) ? 26 : (nr_cpu_ids) & (1ULL << 25) ? 25 : (nr_cpu_ids) & (1ULL << 24) ? 24 : (nr_cpu_ids) & (1ULL << 23) ? 23 : (nr_cpu_ids) & (1ULL << 22) ? 22 : (nr_cpu_ids) & (1ULL << 21) ? 21 : (nr_cpu_ids) & (1ULL << 20) ? 20 : (nr_cpu_ids) & (1ULL << 19) ? 19 : (nr_cpu_ids) & (1ULL << 18) ? 18 : (nr_cpu_ids) & (1ULL << 17) ? 17 : (nr_cpu_ids) & (1ULL << 16) ? 16 : (nr_cpu_ids) & (1ULL << 15) ? 15 : (nr_cpu_ids) & (1ULL << 14) ? 14 : (nr_cpu_ids) & (1ULL << 13) ? 13 : (nr_cpu_ids) & (1ULL << 12) ? 12 : (nr_cpu_ids) & (1ULL << 11) ? 11 : (nr_cpu_ids) & (1ULL << 10) ? 10 : (nr_cpu_ids) & (1ULL << 9) ? 9 : (nr_cpu_ids) & (1ULL << 8) ? 8 : (nr_cpu_ids) & (1ULL << 7) ? 7 : (nr_cpu_ids) & (1ULL << 6) ? 6 : (nr_cpu_ids) & (1ULL << 5) ? 5 : (nr_cpu_ids) & (1ULL << 4) ? 4 : (nr_cpu_ids) & (1ULL << 3) ? 3 : (nr_cpu_ids) & (1ULL << 2) ? 2 : (nr_cpu_ids) & (1ULL << 1) ? 1 : (nr_cpu_ids) & (1ULL << 0) ? 0 : ____ilog2_NaN() ) : (sizeof(nr_cpu_ids) <= 4) ? __ilog2_u32(nr_cpu_ids) : __ilog2_u64(nr_cpu_ids) )));
|
|
|
|}
|
|int bdi_set_min_ratio(struct backing_dev_info *bdi, unsigned int min_ratio);
|int bdi_set_max_ratio(struct backing_dev_info *bdi, unsigned int max_ratio);
|extern struct backing_dev_info default_backing_dev_info;
|extern struct backing_dev_info noop_backing_dev_info;
|void default_unplug_io_fn(struct backing_dev_info *bdi, struct page *page);
|
|int writeback_in_progress(struct backing_dev_info *bdi);
|
|static inline int bdi_congested(struct backing_dev_info *bdi, int bdi_bits)
|{
| if (bdi->congested_fn)
|  return bdi->congested_fn(bdi->congested_data, bdi_bits);
| return (bdi->state & bdi_bits);
|}
|
|static inline int bdi_read_congested(struct backing_dev_info *bdi)
|{
| return bdi_congested(bdi, 1 << BDI_sync_congested);
|}
|
|static inline int bdi_write_congested(struct backing_dev_info *bdi)
|{
| return bdi_congested(bdi, 1 << BDI_async_congested);
|}
|
|static inline int bdi_rw_congested(struct backing_dev_info *bdi)
|{
| return bdi_congested(bdi, (1 << BDI_sync_congested) |
|      (1 << BDI_async_congested));
|}
|
|enum {
| BLK_RW_ASYNC = 0,
| BLK_RW_SYNC = 1,
|};
|
|void clear_bdi_congested(struct backing_dev_info *bdi, int sync);
|void set_bdi_congested(struct backing_dev_info *bdi, int sync);
|long congestion_wait(int sync, long timeout);
|long wait_iff_congested(struct zone *zone, int sync, long timeout);
|
|static inline bool bdi_cap_writeback_dirty(struct backing_dev_info *bdi)
|{
| return !(bdi->capabilities & 0x00000002);
|}
|
|static inline bool bdi_cap_account_dirty(struct backing_dev_info *bdi)
|{
| return !(bdi->capabilities & 0x00000001);
|}
|
|static inline bool bdi_cap_account_writeback(struct backing_dev_info *bdi)
|{
|
| return !(bdi->capabilities & (0x00000080 |
|          0x00000002));
|}
|
|static inline bool bdi_cap_swap_backed(struct backing_dev_info *bdi)
|{
| return bdi->capabilities & 0x00000100;
|}
|
|static inline bool bdi_cap_flush_forker(struct backing_dev_info *bdi)
|{
| return bdi == &default_backing_dev_info;
|}
|
|static inline bool mapping_cap_writeback_dirty(struct address_space *mapping)
|{
| return bdi_cap_writeback_dirty(mapping->backing_dev_info);
|}
|
|static inline bool mapping_cap_account_dirty(struct address_space *mapping)
|{
| return bdi_cap_account_dirty(mapping->backing_dev_info);
|}
|
|static inline bool mapping_cap_swap_backed(struct address_space *mapping)
|{
| return bdi_cap_swap_backed(mapping->backing_dev_info);
|}
|
|static inline int bdi_sched_wait(void *word)
|{
| schedule();
| return 0;
|}
|
|static inline void blk_run_backing_dev(struct backing_dev_info *bdi,
|           struct page *page)
|{
| if (bdi && bdi->unplug_io_fn)
|  bdi->unplug_io_fn(bdi, page);
|}
|
|static inline void blk_run_address_space(struct address_space *mapping)
|{
| if (mapping)
|  blk_run_backing_dev(mapping->backing_dev_info, ((void *)0));
|}
|
|
|
|
|enum {
| MPOL_DEFAULT,
| MPOL_PREFERRED,
| MPOL_BIND,
| MPOL_INTERLEAVE,
| MPOL_MAX,
|};
|
|enum mpol_rebind_step {
| MPOL_REBIND_ONCE,
| MPOL_REBIND_STEP1,
| MPOL_REBIND_STEP2,
| MPOL_REBIND_NSTEP,
|};
|struct mm_struct;
|struct mempolicy {
| atomic_t refcnt;
| unsigned short mode;
| unsigned short flags;
| union {
|  short preferred_node;
|  nodemask_t nodes;
|
| } v;
| union {
|  nodemask_t cpuset_mems_allowed;
|  nodemask_t user_nodemask;
| } w;
|};
|
|
|
|
|
|
|extern void __mpol_put(struct mempolicy *pol);
|static inline void mpol_put(struct mempolicy *pol)
|{
| if (pol)
|  __mpol_put(pol);
|}
|
|
|
|
|
|static inline int mpol_needs_cond_ref(struct mempolicy *pol)
|{
| return (pol && (pol->flags & (1 << 0)));
|}
|
|static inline void mpol_cond_put(struct mempolicy *pol)
|{
| if (mpol_needs_cond_ref(pol))
|  __mpol_put(pol);
|}
|
|extern struct mempolicy *__mpol_cond_copy(struct mempolicy *tompol,
|       struct mempolicy *frompol);
|static inline struct mempolicy *mpol_cond_copy(struct mempolicy *tompol,
|      struct mempolicy *frompol)
|{
| if (!frompol)
|  return frompol;
| return __mpol_cond_copy(tompol, frompol);
|}
|
|extern struct mempolicy *__mpol_dup(struct mempolicy *pol);
|static inline struct mempolicy *mpol_dup(struct mempolicy *pol)
|{
| if (pol)
|  pol = __mpol_dup(pol);
| return pol;
|}
|
|
|
|
|static inline void mpol_get(struct mempolicy *pol)
|{
| if (pol)
|  atomic_inc(&pol->refcnt);
|}
|
|extern int __mpol_equal(struct mempolicy *a, struct mempolicy *b);
|static inline int mpol_equal(struct mempolicy *a, struct mempolicy *b)
|{
| if (a == b)
|  return 1;
| return __mpol_equal(a, b);
|}
|struct sp_node {
| struct rb_node nd;
| unsigned long start, end;
| struct mempolicy *policy;
|};
|
|struct shared_policy {
| struct rb_root root;
| spinlock_t lock;
|};
|
|void mpol_shared_policy_init(struct shared_policy *sp, struct mempolicy *mpol);
|int mpol_set_shared_policy(struct shared_policy *info,
|    struct vm_area_struct *vma,
|    struct mempolicy *new);
|void mpol_free_shared_policy(struct shared_policy *p);
|struct mempolicy *mpol_shared_policy_lookup(struct shared_policy *sp,
|         unsigned long idx);
|
|extern void numa_default_policy(void);
|extern void numa_policy_init(void);
|extern void mpol_rebind_task(struct task_struct *tsk, const nodemask_t *new,
|    enum mpol_rebind_step step);
|extern void mpol_rebind_mm(struct mm_struct *mm, nodemask_t *new);
|extern void mpol_fix_fork_child_flag(struct task_struct *p);
|
|extern struct zonelist *huge_zonelist(struct vm_area_struct *vma,
|    unsigned long addr, gfp_t gfp_flags,
|    struct mempolicy **mpol, nodemask_t **nodemask);
|extern bool init_nodemask_of_mempolicy(nodemask_t *mask);
|extern bool mempolicy_nodemask_intersects(struct task_struct *tsk,
|    const nodemask_t *mask);
|extern unsigned slab_node(struct mempolicy *policy);
|
|extern enum zone_type policy_zone;
|
|static inline void check_highest_zone(enum zone_type k)
|{
| if (k > policy_zone && k != ZONE_MOVABLE)
|  policy_zone = k;
|}
|
|int do_migrate_pages(struct mm_struct *mm,
| const nodemask_t *from_nodes, const nodemask_t *to_nodes, int flags);
|
|
|
|extern int mpol_parse_str(char *str, struct mempolicy **mpol, int no_context);
|
|extern int mpol_to_str(char *buffer, int maxlen, struct mempolicy *pol,
|   int no_context);
|
|
|
|static inline int vma_migratable(struct vm_area_struct *vma)
|{
| if (vma->vm_flags & (0x00004000|0x00400000|0x00000400|0x00080000))
|  return 0;
|
|
|
|
|
| if (vma->vm_file &&
|  gfp_zone(mapping_gfp_mask(vma->vm_file->f_mapping))
|        < policy_zone)
|   return 0;
| return 1;
|}
|
|
|
|
|
|
|struct shmem_inode_info {
| spinlock_t lock;
| unsigned long flags;
| unsigned long alloced;
| unsigned long swapped;
| unsigned long next_index;
| struct shared_policy policy;
| struct page *i_indirect;
| swp_entry_t i_direct[16];
| struct list_head swaplist;
| struct inode vfs_inode;
|};
|
|struct shmem_sb_info {
| unsigned long max_blocks;
| struct percpu_counter used_blocks;
| unsigned long max_inodes;
| unsigned long free_inodes;
| spinlock_t stat_lock;
| uid_t uid;
| gid_t gid;
| mode_t mode;
| struct mempolicy *mpol;
|};
|
|static inline struct shmem_inode_info *SHMEM_I(struct inode *inode)
|{
| return ({ const typeof( ((struct shmem_inode_info *)0)->vfs_inode ) *__mptr = (inode); (struct shmem_inode_info *)( (char *)__mptr - 1 );});
|}
|
|extern int init_tmpfs(void);
|extern int shmem_fill_super(struct super_block *sb, void *data, int silent);
|
|
|
|
|
|
|
|extern struct device_type part_type;
|extern struct kobject *block_depr;
|extern struct class block_class;
|
|enum {
|
|
| DOS_EXTENDED_PARTITION = 5,
| LINUX_EXTENDED_PARTITION = 0x85,
| WIN98_EXTENDED_PARTITION = 0x0f,
|
| SUN_WHOLE_DISK = DOS_EXTENDED_PARTITION,
|
| LINUX_SWAP_PARTITION = 0x82,
| LINUX_DATA_PARTITION = 0x83,
| LINUX_LVM_PARTITION = 0x8e,
| LINUX_RAID_PARTITION = 0xfd,
|
| SOLARIS_X86_PARTITION = LINUX_SWAP_PARTITION,
| NEW_SOLARIS_X86_PARTITION = 0xbf,
|
| DM6_AUX1PARTITION = 0x51,
| DM6_AUX3PARTITION = 0x53,
| DM6_PARTITION = 0x54,
| EZD_PARTITION = 0x55,
|
| FREEBSD_PARTITION = 0xa5,
| OPENBSD_PARTITION = 0xa6,
| NETBSD_PARTITION = 0xa9,
| BSDI_PARTITION = 0xb7,
| MINIX_PARTITION = 0x81,
| UNIXWARE_PARTITION = 0x63,
|};
|
|
|
|
|
|struct klist_node;
|struct klist {
| spinlock_t k_lock;
| struct list_head k_list;
| void (*get)(struct klist_node *);
| void (*put)(struct klist_node *);
|} ;
|extern void klist_init(struct klist *k, void (*get)(struct klist_node *),
|         void (*put)(struct klist_node *));
|
|struct klist_node {
| void *n_klist;
| struct list_head n_node;
| struct kref n_ref;
|};
|
|extern void klist_add_tail(struct klist_node *n, struct klist *k);
|extern void klist_add_head(struct klist_node *n, struct klist *k);
|extern void klist_add_after(struct klist_node *n, struct klist_node *pos);
|extern void klist_add_before(struct klist_node *n, struct klist_node *pos);
|
|extern void klist_del(struct klist_node *n);
|extern void klist_remove(struct klist_node *n);
|
|extern int klist_node_attached(struct klist_node *n);
|
|
|struct klist_iter {
| struct klist *i_klist;
| struct klist_node *i_cur;
|};
|
|
|extern void klist_iter_init(struct klist *k, struct klist_iter *i);
|extern void klist_iter_init_node(struct klist *k, struct klist_iter *i,
|     struct klist_node *n);
|extern void klist_iter_exit(struct klist_iter *i);
|extern struct klist_node *klist_next(struct klist_iter *i);
|
|
|
|
|
|
|
|
|
|
|struct dev_archdata {
|
| void *acpi_handle;
|
|
|struct dma_map_ops *dma_ops;
|
|
| void *iommu;
|
|};
|
|struct pdev_archdata {
|};
|
|struct device;
|struct device_private;
|struct device_driver;
|struct driver_private;
|struct class;
|struct subsys_private;
|struct bus_type;
|struct device_node;
|
|struct bus_attribute {
| struct attribute attr;
| ssize_t (*show)(struct bus_type *bus, char *buf);
| ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count);
|};
|
|
|
|
|extern int bus_create_file(struct bus_type *,
|     struct bus_attribute *);
|extern void bus_remove_file(struct bus_type *, struct bus_attribute *);
|
|struct bus_type {
| const char *name;
| struct bus_attribute *bus_attrs;
| struct device_attribute *dev_attrs;
| struct driver_attribute *drv_attrs;
|
| int (*match)(struct device *dev, struct device_driver *drv);
| int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
| int (*probe)(struct device *dev);
| int (*remove)(struct device *dev);
| void (*shutdown)(struct device *dev);
|
| int (*suspend)(struct device *dev, pm_message_t state);
| int (*resume)(struct device *dev);
|
| const struct dev_pm_ops *pm;
|
| struct subsys_private *p;
|};
|
|extern int bus_register(struct bus_type *bus);
|extern void bus_unregister(struct bus_type *bus);
|
|extern int bus_rescan_devices(struct bus_type *bus);
|
|
|
|int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data,
|       int (*fn)(struct device *dev, void *data));
|struct device *bus_find_device(struct bus_type *bus, struct device *start,
|          void *data,
|          int (*match)(struct device *dev, void *data));
|struct device *bus_find_device_by_name(struct bus_type *bus,
|           struct device *start,
|           const char *name);
|
|int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
|       void *data, int (*fn)(struct device_driver *, void *));
|
|void bus_sort_breadthfirst(struct bus_type *bus,
|      int (*compare)(const struct device *a,
|       const struct device *b));
|
|
|
|
|
|
|struct notifier_block;
|
|extern int bus_register_notifier(struct bus_type *bus,
|     struct notifier_block *nb);
|extern int bus_unregister_notifier(struct bus_type *bus,
|       struct notifier_block *nb);
|extern struct kset *bus_get_kset(struct bus_type *bus);
|extern struct klist *bus_get_device_klist(struct bus_type *bus);
|
|struct device_driver {
| const char *name;
| struct bus_type *bus;
|
| struct module *owner;
| const char *mod_name;
|
| bool suppress_bind_attrs;
|
|
|
|
|
| int (*probe) (struct device *dev);
| int (*remove) (struct device *dev);
| void (*shutdown) (struct device *dev);
| int (*suspend) (struct device *dev, pm_message_t state);
| int (*resume) (struct device *dev);
| const struct attribute_group **groups;
|
| const struct dev_pm_ops *pm;
|
| struct driver_private *p;
|};
|
|
|extern int driver_register(struct device_driver *drv);
|extern void driver_unregister(struct device_driver *drv);
|
|extern struct device_driver *get_driver(struct device_driver *drv);
|extern void put_driver(struct device_driver *drv);
|extern struct device_driver *driver_find(const char *name,
|      struct bus_type *bus);
|extern int driver_probe_done(void);
|extern void wait_for_device_probe(void);
|
|
|
|
|struct driver_attribute {
| struct attribute attr;
| ssize_t (*show)(struct device_driver *driver, char *buf);
| ssize_t (*store)(struct device_driver *driver, const char *buf,
|    size_t count);
|};
|
|
|
|
|
|extern int driver_create_file(struct device_driver *driver,
|     const struct driver_attribute *attr);
|extern void driver_remove_file(struct device_driver *driver,
|          const struct driver_attribute *attr);
|
|extern int driver_add_kobj(struct device_driver *drv,
|     struct kobject *kobj,
|     const char *fmt, ...);
|
|extern int driver_for_each_device(struct device_driver *drv,
|            struct device *start,
|            void *data,
|            int (*fn)(struct device *dev,
|        void *));
|struct device *driver_find_device(struct device_driver *drv,
|      struct device *start, void *data,
|      int (*match)(struct device *dev, void *data));
|
|
|
|
|struct class {
| const char *name;
| struct module *owner;
|
| struct class_attribute *class_attrs;
| struct device_attribute *dev_attrs;
| struct kobject *dev_kobj;
|
| int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env);
| char *(*devnode)(struct device *dev, mode_t *mode);
|
| void (*class_release)(struct class *class);
| void (*dev_release)(struct device *dev);
|
| int (*suspend)(struct device *dev, pm_message_t state);
| int (*resume)(struct device *dev);
|
| const struct kobj_ns_type_operations *ns_type;
| const void *(*namespace)(struct device *dev);
|
| const struct dev_pm_ops *pm;
|
| struct subsys_private *p;
|};
|
|struct class_dev_iter {
| struct klist_iter ki;
| const struct device_type *type;
|};
|
|extern struct kobject *sysfs_dev_block_kobj;
|extern struct kobject *sysfs_dev_char_kobj;
|extern int __class_register(struct class *class,
|      struct lock_class_key *key);
|extern void class_unregister(struct class *class);
|struct class_compat;
|struct class_compat *class_compat_register(const char *name);
|void class_compat_unregister(struct class_compat *cls);
|int class_compat_create_link(struct class_compat *cls, struct device *dev,
|        struct device *device_link);
|void class_compat_remove_link(struct class_compat *cls, struct device *dev,
|         struct device *device_link);
|
|extern void class_dev_iter_init(struct class_dev_iter *iter,
|    struct class *class,
|    struct device *start,
|    const struct device_type *type);
|extern struct device *class_dev_iter_next(struct class_dev_iter *iter);
|extern void class_dev_iter_exit(struct class_dev_iter *iter);
|
|extern int class_for_each_device(struct class *class, struct device *start,
|     void *data,
|     int (*fn)(struct device *dev, void *data));
|extern struct device *class_find_device(struct class *class,
|     struct device *start, void *data,
|     int (*match)(struct device *, void *));
|
|struct class_attribute {
| struct attribute attr;
| ssize_t (*show)(struct class *class, struct class_attribute *attr,
|   char *buf);
| ssize_t (*store)(struct class *class, struct class_attribute *attr,
|   const char *buf, size_t count);
|};
|
|
|
|
|extern int class_create_file(struct class *class,
|       const struct class_attribute *attr);
|extern void class_remove_file(struct class *class,
|         const struct class_attribute *attr);
|
|
|
|struct class_attribute_string {
| struct class_attribute attr;
| char *str;
|};
|extern ssize_t show_class_attr_string(struct class *class, struct class_attribute *attr,
|                        char *buf);
|
|struct class_interface {
| struct list_head node;
| struct class *class;
|
| int (*add_dev) (struct device *, struct class_interface *);
| void (*remove_dev) (struct device *, struct class_interface *);
|};
|
|extern int class_interface_register(struct class_interface *);
|extern void class_interface_unregister(struct class_interface *);
|
|extern struct class * __class_create(struct module *owner,
|        const char *name,
|        struct lock_class_key *key);
|extern void class_destroy(struct class *cls);
|struct device_type {
| const char *name;
| const struct attribute_group **groups;
| int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
| char *(*devnode)(struct device *dev, mode_t *mode);
| void (*release)(struct device *dev);
|
| const struct dev_pm_ops *pm;
|};
|
|
|struct device_attribute {
| struct attribute attr;
| ssize_t (*show)(struct device *dev, struct device_attribute *attr,
|   char *buf);
| ssize_t (*store)(struct device *dev, struct device_attribute *attr,
|    const char *buf, size_t count);
|};
|
|
|
|
|extern int device_create_file(struct device *device,
|     const struct device_attribute *entry);
|extern void device_remove_file(struct device *dev,
|          const struct device_attribute *attr);
|extern int device_create_bin_file(struct device *dev,
|     const struct bin_attribute *attr);
|extern void device_remove_bin_file(struct device *dev,
|       const struct bin_attribute *attr);
|extern int device_schedule_callback_owner(struct device *dev,
|  void (*func)(struct device *dev), struct module *owner);
|
|
|
|
|
|
|typedef void (*dr_release_t)(struct device *dev, void *res);
|typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data);
|
|
|extern void *__devres_alloc(dr_release_t release, size_t size, gfp_t gfp,
|        const char *name);
|
|
|
|
|
|extern void devres_free(void *res);
|extern void devres_add(struct device *dev, void *res);
|extern void *devres_find(struct device *dev, dr_release_t release,
|    dr_match_t match, void *match_data);
|extern void *devres_get(struct device *dev, void *new_res,
|   dr_match_t match, void *match_data);
|extern void *devres_remove(struct device *dev, dr_release_t release,
|      dr_match_t match, void *match_data);
|extern int devres_destroy(struct device *dev, dr_release_t release,
|     dr_match_t match, void *match_data);
|
|
|extern void * devres_open_group(struct device *dev, void *id,
|          gfp_t gfp);
|extern void devres_close_group(struct device *dev, void *id);
|extern void devres_remove_group(struct device *dev, void *id);
|extern int devres_release_group(struct device *dev, void *id);
|
|
|extern void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp);
|extern void devm_kfree(struct device *dev, void *p);
|
|struct device_dma_parameters {
|
|
|
|
| unsigned int max_segment_size;
| unsigned long segment_boundary_mask;
|};
|
|struct device {
| struct device *parent;
|
| struct device_private *p;
|
| struct kobject kobj;
| const char *init_name;
| struct device_type *type;
|
| struct mutex mutex;
|
|
|
| struct bus_type *bus;
| struct device_driver *driver;
|
| void *platform_data;
|
| struct dev_pm_info power;
|
|
| int numa_node;
|
| 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;
|
|
|
|
| dev_t devt;
|
| 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 wakeup_source {
| char *name;
| struct list_head entry;
| spinlock_t lock;
| struct timer_list timer;
| unsigned long timer_expires;
| ktime_t total_time;
| ktime_t max_time;
| ktime_t last_time;
| unsigned long event_count;
| unsigned long active_count;
| unsigned long relax_count;
| unsigned long hit_count;
| unsigned int active:1;
|};
|
|
|
|
|
|
|
|static inline void device_set_wakeup_capable(struct device *dev, bool capable)
|{
| dev->power.can_wakeup = capable;
|}
|
|static inline bool device_can_wakeup(struct device *dev)
|{
| return dev->power.can_wakeup;
|}
|
|
|
|static inline bool device_may_wakeup(struct device *dev)
|{
| return dev->power.can_wakeup && !!dev->power.wakeup;
|}
|
|
|extern struct wakeup_source *wakeup_source_create(const char *name);
|extern void wakeup_source_destroy(struct wakeup_source *ws);
|extern void wakeup_source_add(struct wakeup_source *ws);
|extern void wakeup_source_remove(struct wakeup_source *ws);
|extern struct wakeup_source *wakeup_source_register(const char *name);
|extern void wakeup_source_unregister(struct wakeup_source *ws);
|extern int device_wakeup_enable(struct device *dev);
|extern int device_wakeup_disable(struct device *dev);
|extern int device_init_wakeup(struct device *dev, bool val);
|extern int device_set_wakeup_enable(struct device *dev, bool enable);
|extern void __pm_stay_awake(struct wakeup_source *ws);
|extern void pm_stay_awake(struct device *dev);
|extern void __pm_relax(struct wakeup_source *ws);
|extern void pm_relax(struct device *dev);
|extern void __pm_wakeup_event(struct wakeup_source *ws, unsigned int msec);
|extern void pm_wakeup_event(struct device *dev, unsigned int msec);
|
|static inline const char *dev_name(const struct device *dev)
|{
|
| if (dev->init_name)
|  return dev->init_name;
|
| return kobject_name(&dev->kobj);
|}
|
|extern int dev_set_name(struct device *dev, const char *name, ...)
|   ;
|
|
|static inline int dev_to_node(struct device *dev)
|{
| return dev->numa_node;
|}
|static inline void set_dev_node(struct device *dev, int node)
|{
| dev->numa_node = node;
|}
|static inline unsigned int dev_get_uevent_suppress(const struct device *dev)
|{
| return dev->kobj.uevent_suppress;
|}
|
|static inline void dev_set_uevent_suppress(struct device *dev, int val)
|{
| dev->kobj.uevent_suppress = val;
|}
|
|static inline int device_is_registered(struct device *dev)
|{
| return dev->kobj.state_in_sysfs;
|}
|
|static inline void device_enable_async_suspend(struct device *dev)
|{
| if (dev->power.status == DPM_ON)
|  dev->power.async_suspend = true;
|}
|
|static inline void device_disable_async_suspend(struct device *dev)
|{
| if (dev->power.status == DPM_ON)
|  dev->power.async_suspend = false;
|}
|
|static inline bool device_async_suspend_enabled(struct device *dev)
|{
| return !!dev->power.async_suspend;
|}
|
|static inline void device_lock(struct device *dev)
|{
| mutex_lock_nested(&dev->mutex, 0);
|}
|
|static inline int device_trylock(struct device *dev)
|{
| return mutex_trylock(&dev->mutex);
|}
|
|static inline void device_unlock(struct device *dev)
|{
| mutex_unlock(&dev->mutex);
|}
|
|void driver_init(void);
|
|
|
|
|extern int device_register(struct device *dev);
|extern void device_unregister(struct device *dev);
|extern void device_initialize(struct device *dev);
|extern int device_add(struct device *dev);
|extern void device_del(struct device *dev);
|extern int device_for_each_child(struct device *dev, void *data,
|       int (*fn)(struct device *dev, void *data));
|extern struct device *device_find_child(struct device *dev, void *data,
|    int (*match)(struct device *dev, void *data));
|extern int device_rename(struct device *dev, const char *new_name);
|extern int device_move(struct device *dev, struct device *new_parent,
|         enum dpm_order dpm_order);
|extern const char *device_get_devnode(struct device *dev,
|          mode_t *mode, const char **tmp);
|extern void *dev_get_drvdata(const struct device *dev);
|extern void dev_set_drvdata(struct device *dev, void *data);
|
|
|
|
|extern struct device *__root_device_register(const char *name,
|          struct module *owner);
|static inline struct device *root_device_register(const char *name)
|{
| return __root_device_register(name, ((struct module *)0));
|}
|extern void root_device_unregister(struct device *root);
|
|static inline void *dev_get_platdata(const struct device *dev)
|{
| return dev->platform_data;
|}
|
|
|
|
|
|extern int device_bind_driver(struct device *dev);
|extern void device_release_driver(struct device *dev);
|extern int device_attach(struct device *dev);
|extern int driver_attach(struct device_driver *drv);
|extern int device_reprobe(struct device *dev);
|
|
|
|
|extern struct device *device_create_vargs(struct class *cls,
|       struct device *parent,
|       dev_t devt,
|       void *drvdata,
|       const char *fmt,
|       int vargs);
|extern struct device *device_create(struct class *cls, struct device *parent,
|        dev_t devt, void *drvdata,
|        const char *fmt, ...)
|        ;
|extern void device_destroy(struct class *cls, dev_t devt);
|
|
|
|
|
|
|
|extern int (*platform_notify)(struct device *dev);
|
|extern int (*platform_notify_remove)(struct device *dev);
|
|
|
|
|
|
|extern struct device *get_device(struct device *dev);
|extern void put_device(struct device *dev);
|
|extern void wait_for_device_probe(void);
|
|
|extern int devtmpfs_create_node(struct device *dev);
|extern int devtmpfs_delete_node(struct device *dev);
|extern int devtmpfs_mount(const char *mntdir);
|
|
|
|
|
|
|
|extern void device_shutdown(void);
|
|
|extern void sysdev_shutdown(void);
|
|
|extern const char *dev_driver_string(const struct device *dev);
|
|
|
|
|extern int dev_printk(const char *level, const struct device *dev,
|        const char *fmt, ...)
| ;
|extern int dev_emerg(const struct device *dev, const char *fmt, ...)
| ;
|extern int dev_alert(const struct device *dev, const char *fmt, ...)
| ;
|extern int dev_crit(const struct device *dev, const char *fmt, ...)
| ;
|extern int dev_err(const struct device *dev, const char *fmt, ...)
| ;
|extern int dev_warn(const struct device *dev, const char *fmt, ...)
| ;
|extern int dev_notice(const struct device *dev, const char *fmt, ...)
| ;
|extern int _dev_info(const struct device *dev, const char *fmt, ...)
| ;
|extern long sysfs_deprecated;
|
|
|
|
|
|struct partition {
| unsigned char boot_ind;
| unsigned char head;
| unsigned char sector;
| unsigned char cyl;
| unsigned char sys_ind;
| unsigned char end_head;
| unsigned char end_sector;
| unsigned char end_cyl;
| __le32 start_sect;
| __le32 nr_sects;
|} ;
|
|struct disk_stats {
| unsigned long sectors[2];
| unsigned long ios[2];
| unsigned long merges[2];
| unsigned long ticks[2];
| unsigned long io_ticks;
| unsigned long time_in_queue;
|};
|
|
|
|
|struct partition_meta_info {
| u8 uuid[16];
| u8 volname[64];
|};
|
|struct hd_struct {
| sector_t start_sect;
| sector_t nr_sects;
| sector_t alignment_offset;
| unsigned int discard_alignment;
| struct device __dev;
| struct kobject *holder_dir;
| int policy, partno;
| struct partition_meta_info *info;
|
| int make_it_fail;
|
| unsigned long stamp;
| int in_flight[2];
|
| struct disk_stats *dkstats;
|
|
|
| struct rcu_head rcu_head;
|};
|struct blk_scsi_cmd_filter {
| unsigned long read_ok[((256) / (sizeof(long) * 8))];
| unsigned long write_ok[((256) / (sizeof(long) * 8))];
| struct kobject kobj;
|};
|
|struct disk_part_tbl {
| struct rcu_head rcu_head;
| int len;
| struct hd_struct *last_lookup;
| struct hd_struct *part[];
|};
|
|struct gendisk {
|
|
|
| int major;
| int first_minor;
| int minors;
|
|
| char disk_name[32];
| char *(*devnode)(struct gendisk *gd, mode_t *mode);
|
|
|
|
|
| struct disk_part_tbl *part_tbl;
| struct hd_struct part0;
|
| const struct block_device_operations *fops;
| struct request_queue *queue;
| void *private_data;
|
| int flags;
| struct device *driverfs_dev;
| struct kobject *slave_dir;
|
| struct timer_rand_state *random;
|
| atomic_t sync_io;
| struct work_struct async_notify;
|
| struct blk_integrity *integrity;
|
| int node_id;
|};
|
|static inline struct gendisk *part_to_disk(struct hd_struct *part)
|{
| if (__builtin_expect(!!(part), 1)) {
|  if (part->partno)
|   return ({ const typeof( ((struct gendisk *)0)->part0.__dev ) *__mptr = (((&((part)->__dev))->parent)); (struct gendisk *)( (char *)__mptr - 1 );});
|  else
|   return ({ const typeof( ((struct gendisk *)0)->part0.__dev ) *__mptr = (((&((part)->__dev)))); (struct gendisk *)( (char *)__mptr - 1 );});
| }
| return ((void *)0);
|}
|
|static inline void part_pack_uuid(const u8 *uuid_str, u8 *to)
|{
| int i;
| for (i = 0; i < 16; ++i) {
|  *to++ = (hex_to_bin(*uuid_str) << 4) |
|   (hex_to_bin(*(uuid_str + 1)));
|  uuid_str += 2;
|  switch (i) {
|  case 3:
|  case 5:
|  case 7:
|  case 9:
|   uuid_str++;
|   continue;
|  }
| }
|}
|
|static inline char *part_unpack_uuid(const u8 *uuid, char *out)
|{
| sprintf(out, "%pU", uuid);
| return out;
|}
|
|static inline int disk_max_parts(struct gendisk *disk)
|{
| if (disk->flags & 64)
|  return 256;
| return disk->minors;
|}
|
|static inline bool disk_partitionable(struct gendisk *disk)
|{
| return disk_max_parts(disk) > 1;
|}
|
|static inline dev_t disk_devt(struct gendisk *disk)
|{
| return (&(disk)->part0.__dev)->devt;
|}
|
|static inline dev_t part_devt(struct hd_struct *part)
|{
| return (&((part)->__dev))->devt;
|}
|
|extern struct hd_struct *disk_get_part(struct gendisk *disk, int partno);
|
|static inline void disk_put_part(struct hd_struct *part)
|{
| if (__builtin_expect(!!(part), 1))
|  put_device((&((part)->__dev)));
|}
|struct disk_part_iter {
| struct gendisk *disk;
| struct hd_struct *part;
| int idx;
| unsigned int flags;
|};
|
|extern void disk_part_iter_init(struct disk_part_iter *piter,
|     struct gendisk *disk, unsigned int flags);
|extern struct hd_struct *disk_part_iter_next(struct disk_part_iter *piter);
|extern void disk_part_iter_exit(struct disk_part_iter *piter);
|
|extern struct hd_struct *disk_map_sector_rcu(struct gendisk *disk,
|          sector_t sector);
|static inline void part_stat_set_all(struct hd_struct *part, int value)
|{
| int i;
|
| for (((i)) = -1; ((i)) = cpumask_next(((i)), (cpu_possible_mask)), ((i)) < nr_cpu_ids;)
|  memset(({ do { const void *__vpp_verify = (typeof(((part->dkstats))))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*((part->dkstats))) *)((part->dkstats)))); (typeof((typeof(*((part->dkstats))) *)((part->dkstats)))) (__ptr + (((__per_cpu_offset[(i)])))); }); }), value,
|    sizeof(struct disk_stats));
|}
|
|static inline int init_part_stats(struct hd_struct *part)
|{
| part->dkstats = (typeof(struct disk_stats) *)__alloc_percpu(sizeof(struct disk_stats), __alignof__(struct disk_stats));
| if (!part->dkstats)
|  return 0;
| return 1;
|}
|
|static inline void free_part_stats(struct hd_struct *part)
|{
| free_percpu(part->dkstats);
|}
|static inline void part_inc_in_flight(struct hd_struct *part, int rw)
|{
| part->in_flight[rw]++;
| if (part->partno)
|  part_to_disk(part)->part0.in_flight[rw]++;
|}
|
|static inline void part_dec_in_flight(struct hd_struct *part, int rw)
|{
| part->in_flight[rw]--;
| if (part->partno)
|  part_to_disk(part)->part0.in_flight[rw]--;
|}
|
|static inline int part_in_flight(struct hd_struct *part)
|{
| return part->in_flight[0] + part->in_flight[1];
|}
|
|static inline struct partition_meta_info *alloc_part_info(struct gendisk *disk)
|{
| if (disk)
|  return kzalloc_node(sizeof(struct partition_meta_info),
|        ((( gfp_t)0x10u) | (( gfp_t)0x40u) | (( gfp_t)0x80u)), disk->node_id);
| return kzalloc(sizeof(struct partition_meta_info), ((( gfp_t)0x10u) | (( gfp_t)0x40u) | (( gfp_t)0x80u)));
|}
|
|static inline void free_part_info(struct hd_struct *part)
|{
| kfree(part->info);
|}
|
|
|extern void part_round_stats(int cpu, struct hd_struct *part);
|
|
|extern void add_disk(struct gendisk *disk);
|extern void del_gendisk(struct gendisk *gp);
|extern void unlink_gendisk(struct gendisk *gp);
|extern struct gendisk *get_gendisk(dev_t dev, int *partno);
|extern struct block_device *bdget_disk(struct gendisk *disk, int partno);
|
|extern void set_device_ro(struct block_device *bdev, int flag);
|extern void set_disk_ro(struct gendisk *disk, int flag);
|
|static inline int get_disk_ro(struct gendisk *disk)
|{
| return disk->part0.policy;
|}
|
|
|extern void add_disk_randomness(struct gendisk *disk);
|extern void rand_initialize_disk(struct gendisk *disk);
|
|static inline sector_t get_start_sect(struct block_device *bdev)
|{
| return bdev->bd_part->start_sect;
|}
|static inline sector_t get_capacity(struct gendisk *disk)
|{
| return disk->part0.nr_sects;
|}
|static inline void set_capacity(struct gendisk *disk, sector_t size)
|{
| disk->part0.nr_sects = size;
|}
|
|
|
|
|
|
|struct solaris_x86_slice {
| __le16 s_tag;
| __le16 s_flag;
| __le32 s_start;
| __le32 s_size;
|};
|
|struct solaris_x86_vtoc {
| unsigned int v_bootinfo[3];
| __le32 v_sanity;
| __le32 v_version;
| char v_volume[8];
| __le16 v_sectorsz;
| __le16 v_nparts;
| unsigned int v_reserved[10];
| struct solaris_x86_slice
|  v_slice[16];
| unsigned int timestamp[16];
| char v_asciilabel[128];
|};
|struct bsd_disklabel {
| __le32 d_magic;
| __s16 d_type;
| __s16 d_subtype;
| char d_typename[16];
| char d_packname[16];
| __u32 d_secsize;
| __u32 d_nsectors;
| __u32 d_ntracks;
| __u32 d_ncylinders;
| __u32 d_secpercyl;
| __u32 d_secperunit;
| __u16 d_sparespertrack;
| __u16 d_sparespercyl;
| __u32 d_acylinders;
| __u16 d_rpm;
| __u16 d_interleave;
| __u16 d_trackskew;
| __u16 d_cylskew;
| __u32 d_headswitch;
| __u32 d_trkseek;
| __u32 d_flags;
|
| __u32 d_drivedata[5];
|
| __u32 d_spare[5];
| __le32 d_magic2;
| __le16 d_checksum;
|
|
| __le16 d_npartitions;
| __le32 d_bbsize;
| __le32 d_sbsize;
| struct bsd_partition {
|  __le32 p_size;
|  __le32 p_offset;
|  __le32 p_fsize;
|  __u8 p_fstype;
|  __u8 p_frag;
|  __le16 p_cpg;
| } d_partitions[16];
|};
|struct unixware_slice {
| __le16 s_label;
| __le16 s_flags;
| __le32 start_sect;
| __le32 nr_sects;
|};
|
|struct unixware_disklabel {
| __le32 d_type;
| __le32 d_magic;
| __le32 d_version;
| char d_serial[12];
| __le32 d_ncylinders;
| __le32 d_ntracks;
| __le32 d_nsectors;
| __le32 d_secsize;
| __le32 d_part_start;
| __le32 d_unknown1[12];
|  __le32 d_alt_tbl;
|  __le32 d_alt_len;
|  __le32 d_phys_cyl;
|  __le32 d_phys_trk;
|  __le32 d_phys_sec;
|  __le32 d_phys_bytes;
|  __le32 d_unknown2;
| __le32 d_unknown3;
| __le32 d_pad[8];
|
| struct unixware_vtoc {
|  __le32 v_magic;
|  __le32 v_version;
|  char v_name[8];
|  __le16 v_nslices;
|  __le16 v_unknown1;
|  __le32 v_reserved[10];
|  struct unixware_slice
|   v_slice[16];
| } vtoc;
|
|};
|extern int blk_alloc_devt(struct hd_struct *part, dev_t *devt);
|extern void blk_free_devt(dev_t devt);
|extern dev_t blk_lookup_devt(const char *name, int partno);
|extern char *disk_name (struct gendisk *hd, int partno, char *buf);
|
|extern int disk_expand_part_tbl(struct gendisk *disk, int target);
|extern int rescan_partitions(struct gendisk *disk, struct block_device *bdev);
|extern struct hd_struct * add_partition(struct gendisk *disk,
|           int partno, sector_t start,
|           sector_t len, int flags,
|           struct partition_meta_info
|             *info);
|extern void delete_partition(struct gendisk *, int);
|extern void printk_all_partitions(void);
|
|extern struct gendisk *alloc_disk_node(int minors, int node_id);
|extern struct gendisk *alloc_disk(int minors);
|extern struct kobject *get_disk(struct gendisk *disk);
|extern void put_disk(struct gendisk *disk);
|extern void blk_register_region(dev_t devt, unsigned long range,
|   struct module *module,
|   struct kobject *(*probe)(dev_t, int *, void *),
|   int (*lock)(dev_t, void *),
|   void *data);
|extern void blk_unregister_region(dev_t devt, unsigned long range);
|
|extern ssize_t part_size_show(struct device *dev,
|         struct device_attribute *attr, char *buf);
|extern ssize_t part_stat_show(struct device *dev,
|         struct device_attribute *attr, char *buf);
|extern ssize_t part_inflight_show(struct device *dev,
|         struct device_attribute *attr, char *buf);
|
|extern ssize_t part_fail_show(struct device *dev,
|         struct device_attribute *attr, char *buf);
|extern ssize_t part_fail_store(struct device *dev,
|          struct device_attribute *attr,
|          const char *buf, size_t count);
|
|
|
|
|
|
|struct kmem_cache;
|
|typedef void * (mempool_alloc_t)(gfp_t gfp_mask, void *pool_data);
|typedef void (mempool_free_t)(void *element, void *pool_data);
|
|typedef struct mempool_s {
| spinlock_t lock;
| int min_nr;
| int curr_nr;
| void **elements;
|
| void *pool_data;
| mempool_alloc_t *alloc;
| mempool_free_t *free;
| wait_queue_head_t wait;
|} mempool_t;
|
|extern mempool_t *mempool_create(int min_nr, mempool_alloc_t *alloc_fn,
|   mempool_free_t *free_fn, void *pool_data);
|extern mempool_t *mempool_create_node(int min_nr, mempool_alloc_t *alloc_fn,
|   mempool_free_t *free_fn, void *pool_data, int nid);
|
|extern int mempool_resize(mempool_t *pool, int new_min_nr, gfp_t gfp_mask);
|extern void mempool_destroy(mempool_t *pool);
|extern void * mempool_alloc(mempool_t *pool, gfp_t gfp_mask);
|extern void mempool_free(void *element, mempool_t *pool);
|
|
|
|
|
|void *mempool_alloc_slab(gfp_t gfp_mask, void *pool_data);
|void mempool_free_slab(void *element, void *pool_data);
|static inline mempool_t *
|mempool_create_slab_pool(int min_nr, struct kmem_cache *kc)
|{
| return mempool_create(min_nr, mempool_alloc_slab, mempool_free_slab,
|         (void *) kc);
|}
|
|
|
|
|
|void *mempool_kmalloc(gfp_t gfp_mask, void *pool_data);
|void mempool_kfree(void *element, void *pool_data);
|static inline mempool_t *mempool_create_kmalloc_pool(int min_nr, size_t size)
|{
| return mempool_create(min_nr, mempool_kmalloc, mempool_kfree,
|         (void *) size);
|}
|
|
|
|
|
|void *mempool_alloc_pages(gfp_t gfp_mask, void *pool_data);
|void mempool_free_pages(void *element, void *pool_data);
|static inline mempool_t *mempool_create_page_pool(int min_nr, int order)
|{
| return mempool_create(min_nr, mempool_alloc_pages, mempool_free_pages,
|         (void *)(long)order);
|}
|
|
|
|
|
|
|
|
|
|
|struct cfq_queue;
|struct cfq_io_context {
| void *key;
|
| struct cfq_queue *cfqq[2];
|
| struct io_context *ioc;
|
| unsigned long last_end_request;
|
| unsigned long ttime_total;
| unsigned long ttime_samples;
| unsigned long ttime_mean;
|
| struct list_head queue_list;
| struct hlist_node cic_list;
|
| void (*dtor)(struct io_context *);
| void (*exit)(struct io_context *);
|
| struct rcu_head rcu_head;
|};
|
|
|
|
|
|struct io_context {
| atomic_long_t refcount;
| atomic_t nr_tasks;
|
|
| spinlock_t lock;
|
| unsigned short ioprio;
| unsigned short ioprio_changed;
|
|
| unsigned short cgroup_changed;
|
|
|
|
|
| int nr_batch_requests;
| unsigned long last_waited;
|
| struct radix_tree_root radix_root;
| struct hlist_head cic_list;
| void *ioc_data;
|};
|
|static inline struct io_context *ioc_task_link(struct io_context *ioc)
|{
|
|
|
|
| if (ioc && atomic64_add_unless(((atomic64_t *)(&ioc->refcount)), 1, 0)) {
|  atomic_inc(&ioc->nr_tasks);
|  return ioc;
| }
|
| return ((void *)0);
|}
|
|struct task_struct;
|
|int put_io_context(struct io_context *ioc);
|void exit_io_context(struct task_struct *task);
|struct io_context *get_io_context(gfp_t gfp_flags, int node);
|struct io_context *alloc_io_context(gfp_t gfp_flags, int node);
|enum {
| IOPRIO_CLASS_NONE,
| IOPRIO_CLASS_RT,
| IOPRIO_CLASS_BE,
| IOPRIO_CLASS_IDLE,
|};
|
|
|
|
|
|
|enum {
| IOPRIO_WHO_PROCESS = 1,
| IOPRIO_WHO_PGRP,
| IOPRIO_WHO_USER,
|};
|
|
|
|
|
|
|static inline int task_ioprio(struct io_context *ioc)
|{
| if (((((ioc->ioprio)) >> (13)) != IOPRIO_CLASS_NONE))
|  return ((ioc->ioprio) & ((1UL << (13)) - 1));
|
| return (4);
|}
|
|static inline int task_ioprio_class(struct io_context *ioc)
|{
| if (((((ioc->ioprio)) >> (13)) != IOPRIO_CLASS_NONE))
|  return ((ioc->ioprio) >> (13));
|
| return IOPRIO_CLASS_BE;
|}
|
|static inline int task_nice_ioprio(struct task_struct *task)
|{
| return (task_nice(task) + 20) / 5;
|}
|
|
|
|
|
|static inline int task_nice_ioclass(struct task_struct *task)
|{
| if (task->policy == 5)
|  return IOPRIO_CLASS_IDLE;
| else if (task->policy == 1 || task->policy == 2)
|  return IOPRIO_CLASS_RT;
| else
|  return IOPRIO_CLASS_BE;
|}
|
|
|
|
|extern int ioprio_best(unsigned short aprio, unsigned short bprio);
|
|extern int set_task_ioprio(struct task_struct *task, int ioprio);
|
|
|
|
|
|
|enum xen_domain_type {
| XEN_NATIVE,
| XEN_PV_DOMAIN,
| XEN_HVM_DOMAIN,
|};
|
|
|extern enum xen_domain_type xen_domain_type;
|typedef unsigned char * __guest_handle_uchar;
|typedef unsigned int * __guest_handle_uint;
|typedef unsigned long * __guest_handle_ulong;
|typedef char * __guest_handle_char;
|typedef int * __guest_handle_int;
|typedef long * __guest_handle_long;
|typedef void * __guest_handle_void;
|struct trap_info {
|    uint8_t vector;
|    uint8_t flags;
|    uint16_t cs;
|    unsigned long address;
|};
|typedef struct trap_info * __guest_handle_trap_info;
|
|struct arch_shared_info {
|    unsigned long max_pfn;
|
|    unsigned long pfn_to_mfn_frame_list_list;
|    unsigned long nmi_reason;
|};
|
|
|
|
|
|struct iret_context {
|
|    uint64_t rax, r11, rcx, flags, rip, cs, rflags, rsp, ss;
|
|};
|struct cpu_user_regs {
|    uint64_t r15;
|    uint64_t r14;
|    uint64_t r13;
|    uint64_t r12;
|    union { uint64_t rbp, ebp; uint32_t _ebp; };
|    union { uint64_t rbx, ebx; uint32_t _ebx; };
|    uint64_t r11;
|    uint64_t r10;
|    uint64_t r9;
|    uint64_t r8;
|    union { uint64_t rax, eax; uint32_t _eax; };
|    union { uint64_t rcx, ecx; uint32_t _ecx; };
|    union { uint64_t rdx, edx; uint32_t _edx; };
|    union { uint64_t rsi, esi; uint32_t _esi; };
|    union { uint64_t rdi, edi; uint32_t _edi; };
|    uint32_t error_code;
|    uint32_t entry_vector;
|    union { uint64_t rip, eip; uint32_t _eip; };
|    uint16_t cs, _pad0[1];
|    uint8_t saved_upcall_mask;
|    uint8_t _pad1[3];
|    union { uint64_t rflags, eflags; uint32_t _eflags; };
|    union { uint64_t rsp, esp; uint32_t _esp; };
|    uint16_t ss, _pad2[3];
|    uint16_t es, _pad3[3];
|    uint16_t ds, _pad4[3];
|    uint16_t fs, _pad5[3];
|    uint16_t gs, _pad6[3];
|};
|typedef struct cpu_user_regs * __guest_handle_cpu_user_regs;
|
|
|
|
|
|
|struct arch_vcpu_info {
|    unsigned long cr2;
|    unsigned long pad;
|};
|
|typedef unsigned long xen_callback_t;
|
|
|
|
|
|
|
|struct vcpu_guest_context {
|
|    struct { char x[512]; } fpu_ctxt;
|
|
|
|    unsigned long flags;
|    struct cpu_user_regs user_regs;
|    struct trap_info trap_ctxt[256];
|    unsigned long ldt_base, ldt_ents;
|    unsigned long gdt_frames[16], gdt_ents;
|    unsigned long kernel_ss, kernel_sp;
|
|    unsigned long ctrlreg[8];
|    unsigned long debugreg[8];
|
|
|
|
|
|
|    unsigned long event_callback_eip;
|    unsigned long failsafe_callback_eip;
|    unsigned long syscall_callback_eip;
|
|    unsigned long vm_assist;
|
|
|    uint64_t fs_base;
|    uint64_t gs_base_kernel;
|    uint64_t gs_base_user;
|
|};
|typedef struct vcpu_guest_context * __guest_handle_vcpu_guest_context;
|struct pvclock_vcpu_time_info {
| u32 version;
| u32 pad0;
| u64 tsc_timestamp;
| u64 system_time;
| u32 tsc_to_system_mul;
| s8 tsc_shift;
| u8 flags;
| u8 pad[2];
|} ;
|
|struct pvclock_wall_clock {
| u32 version;
| u32 sec;
| u32 nsec;
|} ;
|struct mmuext_op {
| unsigned int cmd;
| union {
|
|  unsigned long mfn;
|
|  unsigned long linear_addr;
| } arg1;
| union {
|
|  unsigned int nr_ents;
|
|  void *vcpumask;
| } arg2;
|};
|typedef struct mmuext_op * __guest_handle_mmuext_op;
|typedef uint16_t domid_t;
|struct mmu_update {
|    uint64_t ptr;
|    uint64_t val;
|};
|typedef struct mmu_update * __guest_handle_mmu_update;
|
|
|
|
|
|struct multicall_entry {
|    unsigned long op;
|    long result;
|    unsigned long args[6];
|};
|typedef struct multicall_entry * __guest_handle_multicall_entry;
|
|
|
|
|
|
|
|struct vcpu_time_info {
| uint32_t version;
| uint32_t pad0;
| uint64_t tsc_timestamp;
| uint64_t system_time;
|
|
|
|
|
|
| uint32_t tsc_to_system_mul;
| int8_t tsc_shift;
| int8_t pad1[3];
|};
|
|struct vcpu_info {
| uint8_t evtchn_upcall_pending;
| uint8_t evtchn_upcall_mask;
| unsigned long evtchn_pending_sel;
| struct arch_vcpu_info arch;
| struct pvclock_vcpu_time_info time;
|};
|
|
|
|
|
|struct shared_info {
| struct vcpu_info vcpu_info[32];
| unsigned long evtchn_pending[sizeof(unsigned long) * 8];
| unsigned long evtchn_mask[sizeof(unsigned long) * 8];
|
|
|
|
|
| struct pvclock_wall_clock wc;
|
| struct arch_shared_info arch;
|
|};
|struct start_info {
|
| char magic[32];
| unsigned long nr_pages;
| unsigned long shared_info;
| uint32_t flags;
| unsigned long store_mfn;
| uint32_t store_evtchn;
| union {
|  struct {
|   unsigned long mfn;
|   uint32_t evtchn;
|  } domU;
|  struct {
|   uint32_t info_off;
|   uint32_t info_size;
|  } dom0;
| } console;
|
| unsigned long pt_base;
| unsigned long nr_pt_frames;
| unsigned long mfn_list;
| unsigned long mod_start;
| unsigned long mod_len;
| int8_t cmd_line[1024];
|};
|
|
|
|
|
|typedef uint64_t cpumap_t;
|
|typedef uint8_t xen_domain_handle_t[16];
|
|
|
|
|
|
|
|struct tmem_op {
| uint32_t cmd;
| int32_t pool_id;
| union {
|  struct {
|   uint64_t uuid[2];
|   uint32_t flags;
|  } new;
|  struct {
|   uint64_t oid[3];
|   uint32_t index;
|   uint32_t tmem_offset;
|   uint32_t pfn_offset;
|   uint32_t len;
|   __guest_handle_void gmfn;
|  } gen;
| } u;
|};
|extern struct shared_info *HYPERVISOR_shared_info;
|extern struct start_info *xen_start_info;
|static inline unsigned char readb(const volatile void *addr) { unsigned char ret; asm volatile("mov" "b" " %1,%0":"=q" (ret) :"m" (*(volatile unsigned char *)addr) :"memory"); return ret; }
|static inline unsigned short readw(const volatile void *addr) { unsigned short ret; asm volatile("mov" "w" " %1,%0":"=r" (ret) :"m" (*(volatile unsigned short *)addr) :"memory"); return ret; }
|static inline unsigned int readl(const volatile void *addr) { unsigned int ret; asm volatile("mov" "l" " %1,%0":"=r" (ret) :"m" (*(volatile unsigned int *)addr) :"memory"); return ret; }
|
|static inline unsigned char __readb(const volatile void *addr) { unsigned char ret; asm volatile("mov" "b" " %1,%0":"=q" (ret) :"m" (*(volatile unsigned char *)addr) ); return ret; }
|static inline unsigned short __readw(const volatile void *addr) { unsigned short ret; asm volatile("mov" "w" " %1,%0":"=r" (ret) :"m" (*(volatile unsigned short *)addr) ); return ret; }
|static inline unsigned int __readl(const volatile void *addr) { unsigned int ret; asm volatile("mov" "l" " %1,%0":"=r" (ret) :"m" (*(volatile unsigned int *)addr) ); return ret; }
|
|static inline void writeb(unsigned char val, volatile void *addr) { asm volatile("mov" "b" " %0,%1": :"q" (val), "m" (*(volatile unsigned char *)addr) :"memory"); }
|static inline void writew(unsigned short val, volatile void *addr) { asm volatile("mov" "w" " %0,%1": :"r" (val), "m" (*(volatile unsigned short *)addr) :"memory"); }
|static inline void writel(unsigned int val, volatile void *addr) { asm volatile("mov" "l" " %0,%1": :"r" (val), "m" (*(volatile unsigned int *)addr) :"memory"); }
|
|static inline void __writeb(unsigned char val, volatile void *addr) { asm volatile("mov" "b" " %0,%1": :"q" (val), "m" (*(volatile unsigned char *)addr) ); }
|static inline void __writew(unsigned short val, volatile void *addr) { asm volatile("mov" "w" " %0,%1": :"r" (val), "m" (*(volatile unsigned short *)addr) ); }
|static inline void __writel(unsigned int val, volatile void *addr) { asm volatile("mov" "l" " %0,%1": :"r" (val), "m" (*(volatile unsigned int *)addr) ); }
|static inline unsigned long readq(const volatile void *addr) { unsigned long ret; asm volatile("mov" "q" " %1,%0":"=r" (ret) :"m" (*(volatile unsigned long *)addr) :"memory"); return ret; }
|static inline void writeq(unsigned long val, volatile void *addr) { asm volatile("mov" "q" " %0,%1": :"r" (val), "m" (*(volatile unsigned long *)addr) :"memory"); }
|static inline phys_addr_t virt_to_phys(volatile void *address)
|{
| return __phys_addr((unsigned long)(address));
|}
|static inline void *phys_to_virt(phys_addr_t address)
|{
| return ((void *)((unsigned long)(address)+((unsigned long)(0xffff880000000000UL))));
|}
|static inline unsigned int isa_virt_to_bus(volatile void *address)
|{
| return (unsigned int)virt_to_phys(address);
|}
|extern void *ioremap_nocache(resource_size_t offset, unsigned long size);
|extern void *ioremap_cache(resource_size_t offset, unsigned long size);
|extern void *ioremap_prot(resource_size_t offset, unsigned long size,
|    unsigned long prot_val);
|
|
|
|
|static inline void *ioremap(resource_size_t offset, unsigned long size)
|{
| return ioremap_nocache(offset, size);
|}
|
|extern void iounmap(volatile void *addr);
|
|extern void set_iounmap_nonlazy(void);
|
|
|
|extern unsigned int ioread8(void *);
|extern unsigned int ioread16(void *);
|extern unsigned int ioread16be(void *);
|extern unsigned int ioread32(void *);
|extern unsigned int ioread32be(void *);
|
|extern void iowrite8(u8, void *);
|extern void iowrite16(u16, void *);
|extern void iowrite16be(u16, void *);
|extern void iowrite32(u32, void *);
|extern void iowrite32be(u32, void *);
|extern void ioread8_rep(void *port, void *buf, unsigned long count);
|extern void ioread16_rep(void *port, void *buf, unsigned long count);
|extern void ioread32_rep(void *port, void *buf, unsigned long count);
|
|extern void iowrite8_rep(void *port, const void *buf, unsigned long count);
|extern void iowrite16_rep(void *port, const void *buf, unsigned long count);
|extern void iowrite32_rep(void *port, const void *buf, unsigned long count);
|
|
|extern void *ioport_map(unsigned long port, unsigned int nr);
|extern void ioport_unmap(void *);
|
|
|
|
|
|
|struct pci_dev;
|extern void *pci_iomap(struct pci_dev *dev, int bar, unsigned long max);
|extern void pci_iounmap(struct pci_dev *dev, void *);
|
|
|
|
|
|
|
|
|struct vm_area_struct;
|
|extern bool vmap_lazy_unmap;
|struct vm_struct {
| struct vm_struct *next;
| void *addr;
| unsigned long size;
| unsigned long flags;
| struct page **pages;
| unsigned int nr_pages;
| phys_addr_t phys_addr;
| void *caller;
|};
|
|
|
|
|extern void vm_unmap_ram(const void *mem, unsigned int count);
|extern void *vm_map_ram(struct page **pages, unsigned int count,
|    int node, pgprot_t prot);
|extern void vm_unmap_aliases(void);
|
|
|extern void vmalloc_init(void);
|
|
|
|
|
|
|extern void *vmalloc(unsigned long size);
|extern void *vzalloc(unsigned long size);
|extern void *vmalloc_user(unsigned long size);
|extern void *vmalloc_node(unsigned long size, int node);
|extern void *vzalloc_node(unsigned long size, int node);
|extern void *vmalloc_exec(unsigned long size);
|extern void *vmalloc_32(unsigned long size);
|extern void *vmalloc_32_user(unsigned long size);
|extern void *__vmalloc(unsigned long size, gfp_t gfp_mask, pgprot_t prot);
|extern void *__vmalloc_area(struct vm_struct *area, gfp_t gfp_mask,
|    pgprot_t prot);
|extern void vfree(const void *addr);
|
|extern void *vmap(struct page **pages, unsigned int count,
|   unsigned long flags, pgprot_t prot);
|extern void vunmap(const void *addr);
|
|extern int remap_vmalloc_range(struct vm_area_struct *vma, void *addr,
|       unsigned long pgoff);
|void vmalloc_sync_all(void);
|
|
|
|
|
|static inline size_t get_vm_area_size(const struct vm_struct *area)
|{
|
| return area->size - ((1UL) << 12);
|}
|
|extern struct vm_struct *get_vm_area(unsigned long size, unsigned long flags);
|extern struct vm_struct *get_vm_area_caller(unsigned long size,
|     unsigned long flags, void *caller);
|extern struct vm_struct *__get_vm_area(unsigned long size, unsigned long flags,
|     unsigned long start, unsigned long end);
|extern struct vm_struct *__get_vm_area_caller(unsigned long size,
|     unsigned long flags,
|     unsigned long start, unsigned long end,
|     void *caller);
|extern struct vm_struct *get_vm_area_node(unsigned long size,
|       unsigned long flags, int node,
|       gfp_t gfp_mask);
|extern struct vm_struct *remove_vm_area(const void *addr);
|
|extern int map_vm_area(struct vm_struct *area, pgprot_t prot,
|   struct page ***pages);
|extern int map_kernel_range_noflush(unsigned long start, unsigned long size,
|        pgprot_t prot, struct page **pages);
|extern void unmap_kernel_range_noflush(unsigned long addr, unsigned long size);
|extern void unmap_kernel_range(unsigned long addr, unsigned long size);
|
|
|extern struct vm_struct *alloc_vm_area(size_t size);
|extern void free_vm_area(struct vm_struct *area);
|
|
|extern long vread(char *buf, char *addr, unsigned long count);
|extern long vwrite(char *buf, char *addr, unsigned long count);
|
|
|
|
|extern rwlock_t vmlist_lock;
|extern struct vm_struct *vmlist;
|extern void vm_area_register_early(struct vm_struct *vm, size_t align);
|
|
|struct vm_struct **pcpu_get_vm_areas(const unsigned long *offsets,
|         const size_t *sizes, int nr_vms,
|         size_t align, gfp_t gfp_mask);
|
|void pcpu_free_vm_areas(struct vm_struct **vms, int nr_vms);
|
|
|
|
|
|
|static inline void
|memset_io(volatile void *addr, unsigned char val, size_t count)
|{
| memset((void *)addr, val, count);
|}
|
|static inline void
|memcpy_fromio(void *dst, const volatile void *src, size_t count)
|{
| memcpy(dst, (const void *)src, count);
|}
|
|static inline void
|memcpy_toio(volatile void *dst, const void *src, size_t count)
|{
| memcpy((void *)dst, src, count);
|}
|static inline void flush_write_buffers(void)
|{
|
|
|
|}
|
|
|
|extern void native_io_delay(void);
|
|extern int io_delay_type;
|extern void io_delay_init(void);
|static inline void outb(unsigned char value, int port) { asm volatile("out" "b" " %" "b" "0, %w1" : : "a"(value), "Nd"(port)); } static inline unsigned char inb(int port) { unsigned char value; asm volatile("in" "b" " %w1, %" "b" "0" : "=a"(value) : "Nd"(port)); return value; } static inline void outb_p(unsigned char value, int port) { outb(value, port); slow_down_io(); } static inline unsigned char inb_p(int port) { unsigned char value = inb(port); slow_down_io(); return value; } static inline void outsb(int port, const void *addr, unsigned long count) { asm volatile("rep; outs" "b" : "+S"(addr), "+c"(count) : "d"(port)); } static inline void insb(int port, void *addr, unsigned long count) { asm volatile("rep; ins" "b" : "+D"(addr), "+c"(count) : "d"(port)); }
|static inline void outw(unsigned short value, int port) { asm volatile("out" "w" " %" "w" "0, %w1" : : "a"(value), "Nd"(port)); } static inline unsigned short inw(int port) { unsigned short value; asm volatile("in" "w" " %w1, %" "w" "0" : "=a"(value) : "Nd"(port)); return value; } static inline void outw_p(unsigned short value, int port) { outw(value, port); slow_down_io(); } static inline unsigned short inw_p(int port) { unsigned short value = inw(port); slow_down_io(); return value; } static inline void outsw(int port, const void *addr, unsigned long count) { asm volatile("rep; outs" "w" : "+S"(addr), "+c"(count) : "d"(port)); } static inline void insw(int port, void *addr, unsigned long count) { asm volatile("rep; ins" "w" : "+D"(addr), "+c"(count) : "d"(port)); }
|static inline void outl(unsigned int value, int port) { asm volatile("out" "l" " %" "" "0, %w1" : : "a"(value), "Nd"(port)); } static inline unsigned int inl(int port) { unsigned int value; asm volatile("in" "l" " %w1, %" "" "0" : "=a"(value) : "Nd"(port)); return value; } static inline void outl_p(unsigned int value, int port) { outl(value, port); slow_down_io(); } static inline unsigned int inl_p(int port) { unsigned int value = inl(port); slow_down_io(); return value; } static inline void outsl(int port, const void *addr, unsigned long count) { asm volatile("rep; outs" "l" : "+S"(addr), "+c"(count) : "d"(port)); } static inline void insl(int port, void *addr, unsigned long count) { asm volatile("rep; ins" "l" : "+D"(addr), "+c"(count) : "d"(port)); }
|
|extern void *xlate_dev_mem_ptr(unsigned long phys);
|extern void unxlate_dev_mem_ptr(unsigned long phys, void *addr);
|
|extern int ioremap_change_attr(unsigned long vaddr, unsigned long size,
|    unsigned long prot_val);
|extern void *ioremap_wc(resource_size_t offset, unsigned long size);
|
|
|
|
|
|
|extern void early_ioremap_init(void);
|extern void early_ioremap_reset(void);
|extern void *early_ioremap(resource_size_t phys_addr,
|       unsigned long size);
|extern void *early_memremap(resource_size_t phys_addr,
|        unsigned long size);
|extern void early_iounmap(void *addr, unsigned long size);
|extern void fixup_early_ioremap(void);
|extern bool is_early_ioremap_ptep(pte_t *ptep);
|
|
|struct bio_vec;
|
|extern bool xen_biovec_phys_mergeable(const struct bio_vec *vec1,
|          const struct bio_vec *vec2);
|static inline unsigned int bio_cur_bytes(struct bio *bio)
|{
| if (bio->bi_vcnt)
|  return (&(((bio))->bi_io_vec[((bio)->bi_idx)]))->bv_len;
| else
|  return bio->bi_size;
|}
|
|static inline void *bio_data(struct bio *bio)
|{
| if (bio->bi_vcnt)
|  return lowmem_page_address((&((((bio)))->bi_io_vec[(((bio))->bi_idx)]))->bv_page) + (&((((bio)))->bi_io_vec[(((bio))->bi_idx)]))->bv_offset;
|
| return ((void *)0);
|}
|
|static inline int bio_has_allocated_vec(struct bio *bio)
|{
| return bio->bi_io_vec && bio->bi_io_vec != bio->bi_inline_vecs;
|}
|struct bio_integrity_payload {
| struct bio *bip_bio;
|
| sector_t bip_sector;
|
| void *bip_buf;
| bio_end_io_t *bip_end_io;
|
| unsigned int bip_size;
|
| unsigned short bip_slab;
| unsigned short bip_vcnt;
| unsigned short bip_idx;
|
| struct work_struct bip_work;
| struct bio_vec bip_vec[0];
|};
|struct bio_pair {
| struct bio bio1, bio2;
| struct bio_vec bv1, bv2;
|
| struct bio_integrity_payload bip1, bip2;
| struct bio_vec iv1, iv2;
|
| atomic_t cnt;
| int error;
|};
|extern struct bio_pair *bio_split(struct bio *bi, int first_sectors);
|extern void bio_pair_release(struct bio_pair *dbio);
|
|extern struct bio_set *bioset_create(unsigned int, unsigned int);
|extern void bioset_free(struct bio_set *);
|
|extern struct bio *bio_alloc(gfp_t, int);
|extern struct bio *bio_kmalloc(gfp_t, int);
|extern struct bio *bio_alloc_bioset(gfp_t, int, struct bio_set *);
|extern void bio_put(struct bio *);
|extern void bio_free(struct bio *, struct bio_set *);
|
|extern void bio_endio(struct bio *, int);
|struct request_queue;
|extern int bio_phys_segments(struct request_queue *, struct bio *);
|
|extern void __bio_clone(struct bio *, struct bio *);
|extern struct bio *bio_clone(struct bio *, gfp_t);
|
|extern void bio_init(struct bio *);
|
|extern int bio_add_page(struct bio *, struct page *, unsigned int,unsigned int);
|extern int bio_add_pc_page(struct request_queue *, struct bio *, struct page *,
|      unsigned int, unsigned int);
|extern int bio_get_nr_vecs(struct block_device *);
|extern sector_t bio_sector_offset(struct bio *, unsigned short, unsigned int);
|extern struct bio *bio_map_user(struct request_queue *, struct block_device *,
|    unsigned long, unsigned int, int, gfp_t);
|struct sg_iovec;
|struct rq_map_data;
|extern struct bio *bio_map_user_iov(struct request_queue *,
|        struct block_device *,
|        struct sg_iovec *, int, int, gfp_t);
|extern void bio_unmap_user(struct bio *);
|extern struct bio *bio_map_kern(struct request_queue *, void *, unsigned int,
|    gfp_t);
|extern struct bio *bio_copy_kern(struct request_queue *, void *, unsigned int,
|     gfp_t, int);
|extern void bio_set_pages_dirty(struct bio *bio);
|extern void bio_check_pages_dirty(struct bio *bio);
|
|
|
|
|
|
|
|static inline void bio_flush_dcache_pages(struct bio *bi)
|{
|}
|
|
|extern struct bio *bio_copy_user(struct request_queue *, struct rq_map_data *,
|     unsigned long, unsigned int, int, gfp_t);
|extern struct bio *bio_copy_user_iov(struct request_queue *,
|         struct rq_map_data *, struct sg_iovec *,
|         int, int, gfp_t);
|extern int bio_uncopy_user(struct bio *);
|void zero_fill_bio(struct bio *bio);
|extern struct bio_vec *bvec_alloc_bs(gfp_t, int, unsigned long *, struct bio_set *);
|extern void bvec_free_bs(struct bio_set *, struct bio_vec *, unsigned int);
|extern unsigned int bvec_nr_vecs(unsigned short idx);
|
|
|
|
|static inline void bio_set_completion_cpu(struct bio *bio, unsigned int cpu)
|{
| bio->bi_comp_cpu = cpu;
|}
|struct bio_set {
| struct kmem_cache *bio_slab;
| unsigned int front_pad;
|
| mempool_t *bio_pool;
|
| mempool_t *bio_integrity_pool;
|
| mempool_t *bvec_pool;
|};
|
|struct biovec_slab {
| int nr_vecs;
| char *name;
| struct kmem_cache *slab;
|};
|
|extern struct bio_set *fs_bio_set;
|extern struct biovec_slab bvec_slabs[6] ;
|static inline char *bvec_kmap_irq(struct bio_vec *bvec, unsigned long *flags)
|{
| return lowmem_page_address(bvec->bv_page) + bvec->bv_offset;
|}
|
|static inline void bvec_kunmap_irq(char *buffer, unsigned long *flags)
|{
| *flags = 0;
|}
|
|
|static inline char *__bio_kmap_irq(struct bio *bio, unsigned short idx,
|       unsigned long *flags)
|{
| return bvec_kmap_irq((&((bio)->bi_io_vec[(idx)])), flags);
|}
|static inline int bio_has_data(struct bio *bio)
|{
| return bio && bio->bi_io_vec != ((void *)0);
|}
|struct bio_list {
| struct bio *head;
| struct bio *tail;
|};
|
|static inline int bio_list_empty(const struct bio_list *bl)
|{
| return bl->head == ((void *)0);
|}
|
|static inline void bio_list_init(struct bio_list *bl)
|{
| bl->head = bl->tail = ((void *)0);
|}
|
|
|
|
|static inline unsigned bio_list_size(const struct bio_list *bl)
|{
| unsigned sz = 0;
| struct bio *bio;
|
| for (bio = (bl)->head; bio; bio = bio->bi_next)
|  sz++;
|
| return sz;
|}
|
|static inline void bio_list_add(struct bio_list *bl, struct bio *bio)
|{
| bio->bi_next = ((void *)0);
|
| if (bl->tail)
|  bl->tail->bi_next = bio;
| else
|  bl->head = bio;
|
| bl->tail = bio;
|}
|
|static inline void bio_list_add_head(struct bio_list *bl, struct bio *bio)
|{
| bio->bi_next = bl->head;
|
| bl->head = bio;
|
| if (!bl->tail)
|  bl->tail = bio;
|}
|
|static inline void bio_list_merge(struct bio_list *bl, struct bio_list *bl2)
|{
| if (!bl2->head)
|  return;
|
| if (bl->tail)
|  bl->tail->bi_next = bl2->head;
| else
|  bl->head = bl2->head;
|
| bl->tail = bl2->tail;
|}
|
|static inline void bio_list_merge_head(struct bio_list *bl,
|           struct bio_list *bl2)
|{
| if (!bl2->head)
|  return;
|
| if (bl->head)
|  bl2->tail->bi_next = bl->head;
| else
|  bl->tail = bl2->tail;
|
| bl->head = bl2->head;
|}
|
|static inline struct bio *bio_list_peek(struct bio_list *bl)
|{
| return bl->head;
|}
|
|static inline struct bio *bio_list_pop(struct bio_list *bl)
|{
| struct bio *bio = bl->head;
|
| if (bio) {
|  bl->head = bl->head->bi_next;
|  if (!bl->head)
|   bl->tail = ((void *)0);
|
|  bio->bi_next = ((void *)0);
| }
|
| return bio;
|}
|
|static inline struct bio *bio_list_get(struct bio_list *bl)
|{
| struct bio *bio = bl->head;
|
| bl->head = bl->tail = ((void *)0);
|
| return bio;
|}
|extern struct bio_integrity_payload *bio_integrity_alloc_bioset(struct bio *, gfp_t, unsigned int, struct bio_set *);
|extern struct bio_integrity_payload *bio_integrity_alloc(struct bio *, gfp_t, unsigned int);
|extern void bio_integrity_free(struct bio *, struct bio_set *);
|extern int bio_integrity_add_page(struct bio *, struct page *, unsigned int, unsigned int);
|extern int bio_integrity_enabled(struct bio *bio);
|extern int bio_integrity_set_tag(struct bio *, void *, unsigned int);
|extern int bio_integrity_get_tag(struct bio *, void *, unsigned int);
|extern int bio_integrity_prep(struct bio *);
|extern void bio_integrity_endio(struct bio *, int);
|extern void bio_integrity_advance(struct bio *, unsigned int);
|extern void bio_integrity_trim(struct bio *, unsigned int, unsigned int);
|extern void bio_integrity_split(struct bio *, struct bio_pair *, int);
|extern int bio_integrity_clone(struct bio *, struct bio *, gfp_t, struct bio_set *);
|extern int bioset_integrity_create(struct bio_set *, int);
|extern void bioset_integrity_free(struct bio_set *);
|extern void bio_integrity_init(void);
|
|
|
|struct sg_io_v4 {
| __s32 guard;
| __u32 protocol;
| __u32 subprotocol;
|
|
| __u32 request_len;
| __u64 request;
| __u64 request_tag;
| __u32 request_attr;
| __u32 request_priority;
| __u32 request_extra;
| __u32 max_response_len;
| __u64 response;
|
|
| __u32 dout_iovec_count;
|
| __u32 dout_xfer_len;
| __u32 din_iovec_count;
| __u32 din_xfer_len;
| __u64 dout_xferp;
| __u64 din_xferp;
|
| __u32 timeout;
| __u32 flags;
| __u64 usr_ptr;
| __u32 spare_in;
|
| __u32 driver_status;
| __u32 transport_status;
| __u32 device_status;
| __u32 retry_delay;
| __u32 info;
| __u32 duration;
| __u32 response_len;
| __s32 din_resid;
| __s32 dout_resid;
| __u64 generated_tag;
| __u32 spare_out;
|
| __u32 padding;
|};
|
|
|
|
|struct bsg_class_device {
| struct device *class_dev;
| struct device *parent;
| int minor;
| struct request_queue *queue;
| struct kref ref;
| void (*release)(struct device *);
|};
|
|extern int bsg_register_queue(struct request_queue *q,
|         struct device *parent, const char *name,
|         void (*release)(struct device *));
|extern void bsg_unregister_queue(struct request_queue *);
|
|
|
|
|
|
|
|
|
|
|struct scatterlist {
|
| unsigned long sg_magic;
|
| unsigned long page_link;
| unsigned int offset;
| unsigned int length;
| dma_addr_t dma_address;
|
| unsigned int dma_length;
|
|};
|
|struct scsi_ioctl_command;
|
|struct request_queue;
|struct elevator_queue;
|struct request_pm_state;
|struct blk_trace;
|struct request;
|struct sg_io_hdr;
|
|
|
|
|struct request;
|typedef void (rq_end_io_fn)(struct request *, int);
|
|struct request_list {
|
|
|
|
| int count[2];
| int starved[2];
| int elvpriv;
| mempool_t *rq_pool;
| wait_queue_head_t wait[2];
|};
|
|
|
|
|enum rq_cmd_type_bits {
| REQ_TYPE_FS = 1,
| REQ_TYPE_BLOCK_PC,
| REQ_TYPE_SENSE,
| REQ_TYPE_PM_SUSPEND,
| REQ_TYPE_PM_RESUME,
| REQ_TYPE_PM_SHUTDOWN,
| REQ_TYPE_SPECIAL,
|
|
|
|
|
| REQ_TYPE_ATA_TASKFILE,
| REQ_TYPE_ATA_PC,
|};
|struct request {
| struct list_head queuelist;
| struct call_single_data csd;
|
| struct request_queue *q;
|
| unsigned int 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;
| };
|
|
|
|
|
| void *elevator_private;
| void *elevator_private2;
| void *elevator_private3;
|
| struct gendisk *rq_disk;
| unsigned long start_time;
|
|
|
|
|
|
|
| unsigned short nr_phys_segments;
|
| unsigned short nr_integrity_segments;
|
|
| unsigned short ioprio;
|
| int ref_count;
|
| void *special;
| char *buffer;
|
| int tag;
| int errors;
|
|
|
|
| unsigned char __cmd[16];
| 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;
|};
|
|static inline unsigned short req_get_ioprio(struct request *req)
|{
| return req->ioprio;
|}
|
|
|
|
|
|struct request_pm_state
|{
|
| int pm_step;
|
| u32 pm_state;
| void* data;
|};
|
|
|
|
|
|
|
|
|typedef int (elevator_merge_fn) (struct request_queue *, struct request **,
|     struct bio *);
|
|typedef void (elevator_merge_req_fn) (struct request_queue *, struct request *, struct request *);
|
|typedef void (elevator_merged_fn) (struct request_queue *, struct request *, int);
|
|typedef int (elevator_allow_merge_fn) (struct request_queue *, struct request *, struct bio *);
|
|typedef void (elevator_bio_merged_fn) (struct request_queue *,
|      struct request *, struct bio *);
|
|typedef int (elevator_dispatch_fn) (struct request_queue *, int);
|
|typedef void (elevator_add_req_fn) (struct request_queue *, struct request *);
|typedef int (elevator_queue_empty_fn) (struct request_queue *);
|typedef struct request *(elevator_request_list_fn) (struct request_queue *, struct request *);
|typedef void (elevator_completed_req_fn) (struct request_queue *, struct request *);
|typedef int (elevator_may_queue_fn) (struct request_queue *, int);
|
|typedef int (elevator_set_req_fn) (struct request_queue *, struct request *, gfp_t);
|typedef void (elevator_put_req_fn) (struct request *);
|typedef void (elevator_activate_req_fn) (struct request_queue *, struct request *);
|typedef void (elevator_deactivate_req_fn) (struct request_queue *, struct request *);
|
|typedef void *(elevator_init_fn) (struct request_queue *);
|typedef void (elevator_exit_fn) (struct elevator_queue *);
|
|struct elevator_ops
|{
| elevator_merge_fn *elevator_merge_fn;
| elevator_merged_fn *elevator_merged_fn;
| elevator_merge_req_fn *elevator_merge_req_fn;
| elevator_allow_merge_fn *elevator_allow_merge_fn;
| elevator_bio_merged_fn *elevator_bio_merged_fn;
|
| elevator_dispatch_fn *elevator_dispatch_fn;
| elevator_add_req_fn *elevator_add_req_fn;
| elevator_activate_req_fn *elevator_activate_req_fn;
| elevator_deactivate_req_fn *elevator_deactivate_req_fn;
|
| elevator_queue_empty_fn *elevator_queue_empty_fn;
| elevator_completed_req_fn *elevator_completed_req_fn;
|
| elevator_request_list_fn *elevator_former_req_fn;
| elevator_request_list_fn *elevator_latter_req_fn;
|
| elevator_set_req_fn *elevator_set_req_fn;
| elevator_put_req_fn *elevator_put_req_fn;
|
| elevator_may_queue_fn *elevator_may_queue_fn;
|
| elevator_init_fn *elevator_init_fn;
| elevator_exit_fn *elevator_exit_fn;
| void (*trim)(struct io_context *);
|};
|
|
|
|struct elv_fs_entry {
| struct attribute attr;
| ssize_t (*show)(struct elevator_queue *, char *);
| ssize_t (*store)(struct elevator_queue *, const char *, size_t);
|};
|
|
|
|
|struct elevator_type
|{
| struct list_head list;
| struct elevator_ops ops;
| struct elv_fs_entry *elevator_attrs;
| char elevator_name[(16)];
| struct module *elevator_owner;
|};
|
|
|
|
|struct elevator_queue
|{
| struct elevator_ops *ops;
| void *elevator_data;
| struct kobject kobj;
| struct elevator_type *elevator_type;
| struct mutex sysfs_lock;
| struct hlist_head *hash;
| unsigned int registered:1;
|};
|
|
|
|
|extern void elv_dispatch_sort(struct request_queue *, struct request *);
|extern void elv_dispatch_add_tail(struct request_queue *, struct request *);
|extern void elv_add_request(struct request_queue *, struct request *, int, int);
|extern void __elv_add_request(struct request_queue *, struct request *, int, int);
|extern void elv_insert(struct request_queue *, struct request *, int);
|extern int elv_merge(struct request_queue *, struct request **, struct bio *);
|extern void elv_merge_requests(struct request_queue *, struct request *,
|          struct request *);
|extern void elv_merged_request(struct request_queue *, struct request *, int);
|extern void elv_bio_merged(struct request_queue *q, struct request *,
|    struct bio *);
|extern void elv_requeue_request(struct request_queue *, struct request *);
|extern int elv_queue_empty(struct request_queue *);
|extern struct request *elv_former_request(struct request_queue *, struct request *);
|extern struct request *elv_latter_request(struct request_queue *, struct request *);
|extern int elv_register_queue(struct request_queue *q);
|extern void elv_unregister_queue(struct request_queue *q);
|extern int elv_may_queue(struct request_queue *, int);
|extern void elv_abort_queue(struct request_queue *);
|extern void elv_completed_request(struct request_queue *, struct request *);
|extern int elv_set_request(struct request_queue *, struct request *, gfp_t);
|extern void elv_put_request(struct request_queue *, struct request *);
|extern void elv_drain_elevator(struct request_queue *);
|
|
|
|
|extern void elv_register(struct elevator_type *);
|extern void elv_unregister(struct elevator_type *);
|
|
|
|
|extern ssize_t elv_iosched_show(struct request_queue *, char *);
|extern ssize_t elv_iosched_store(struct request_queue *, const char *, size_t);
|
|extern int elevator_init(struct request_queue *, char *);
|extern void elevator_exit(struct elevator_queue *);
|extern int elevator_change(struct request_queue *, const char *);
|extern int elv_rq_merge_ok(struct request *, struct bio *);
|
|
|
|
|extern struct request *elv_rb_former_request(struct request_queue *, struct request *);
|extern struct request *elv_rb_latter_request(struct request_queue *, struct request *);
|
|
|
|
|extern struct request *elv_rb_add(struct rb_root *, struct request *);
|extern void elv_rb_del(struct rb_root *, struct request *);
|extern struct request *elv_rb_find(struct rb_root *, sector_t);
|enum {
| ELV_MQUEUE_MAY,
| ELV_MQUEUE_NO,
| ELV_MQUEUE_MUST,
|};
|
|typedef void (request_fn_proc) (struct request_queue *q);
|typedef int (make_request_fn) (struct request_queue *q, struct bio *bio);
|typedef int (prep_rq_fn) (struct request_queue *, struct request *);
|typedef void (unprep_rq_fn) (struct request_queue *, struct request *);
|typedef void (unplug_fn) (struct request_queue *);
|
|struct bio_vec;
|struct bvec_merge_data {
| struct block_device *bi_bdev;
| sector_t bi_sector;
| unsigned bi_size;
| unsigned long bi_rw;
|};
|typedef int (merge_bvec_fn) (struct request_queue *, struct bvec_merge_data *,
|        struct bio_vec *);
|typedef void (softirq_done_fn)(struct request *);
|typedef int (dma_drain_needed_fn)(struct request *);
|typedef int (lld_busy_fn) (struct request_queue *q);
|
|enum blk_eh_timer_return {
| BLK_EH_NOT_HANDLED,
| BLK_EH_HANDLED,
| BLK_EH_RESET_TIMER,
|};
|
|typedef enum blk_eh_timer_return (rq_timed_out_fn)(struct request *);
|
|enum blk_queue_state {
| Queue_down,
| Queue_up,
|};
|
|struct blk_queue_tag {
| struct request **tag_index;
| unsigned long *tag_map;
| int busy;
| int max_depth;
| int real_max_depth;
| atomic_t refcnt;
|};
|
|
|
|
|struct queue_limits {
| unsigned long bounce_pfn;
| unsigned long seg_boundary_mask;
|
| unsigned int max_hw_sectors;
| unsigned int max_sectors;
| unsigned int max_segment_size;
| unsigned int physical_block_size;
| unsigned int alignment_offset;
| unsigned int io_min;
| unsigned int io_opt;
| unsigned int max_discard_sectors;
| unsigned int discard_granularity;
| unsigned int discard_alignment;
|
| unsigned short logical_block_size;
| unsigned short max_segments;
| unsigned short max_integrity_segments;
|
| unsigned char misaligned;
| unsigned char discard_misaligned;
| unsigned char no_cluster;
| signed char discard_zeroes_data;
|};
|
|struct request_queue
|{
|
|
|
| struct list_head queue_head;
| struct request *last_merge;
| struct elevator_queue *elevator;
|
|
|
|
| struct request_list rq;
|
| request_fn_proc *request_fn;
| make_request_fn *make_request_fn;
| prep_rq_fn *prep_rq_fn;
| unprep_rq_fn *unprep_rq_fn;
| unplug_fn *unplug_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;
|
|
|
|
| sector_t end_sector;
| struct request *boundary_rq;
|
|
|
|
| struct timer_list unplug_timer;
| int unplug_thresh;
| unsigned long unplug_delay;
| struct work_struct unplug_work;
|
| struct backing_dev_info backing_dev_info;
|
|
|
|
|
| void *queuedata;
|
|
|
|
| gfp_t bounce_gfp;
|
|
|
|
| unsigned long queue_flags;
|
|
|
|
|
|
| spinlock_t __queue_lock;
| spinlock_t *queue_lock;
|
|
|
|
| struct kobject kobj;
|
|
|
|
| unsigned long nr_requests;
| unsigned int nr_congestion_on;
| unsigned int nr_congestion_off;
| unsigned int nr_batching;
|
| void *dma_drain_buffer;
| unsigned int dma_drain_size;
| 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 rq_timeout;
| struct timer_list timeout;
| struct list_head timeout_list;
|
| struct queue_limits limits;
|
|
|
|
| unsigned int sg_timeout;
| unsigned int sg_reserved_size;
| int node;
|
| struct blk_trace *blk_trace;
|
|
|
|
| unsigned int flush_flags;
| unsigned int flush_seq;
| int flush_err;
| struct request flush_rq;
| struct request *orig_flush_rq;
| struct list_head pending_flushes;
|
| struct mutex sysfs_lock;
|
|
| struct bsg_class_device bsg_dev;
|
|
|
|
|
|
|};
|static inline int queue_is_locked(struct request_queue *q)
|{
|
| spinlock_t *lock = q->queue_lock;
| return lock && spin_is_locked(lock);
|
|
|
|}
|
|static inline void queue_flag_set_unlocked(unsigned int flag,
|        struct request_queue *q)
|{
| __set_bit(flag, &q->queue_flags);
|}
|
|static inline int queue_flag_test_and_clear(unsigned int flag,
|         struct request_queue *q)
|{
| ({ static bool __warned; int __ret_warn_once = !!(!queue_is_locked(q)); if (__builtin_expect(!!(__ret_warn_once), 0)) if (({ int __ret_warn_on = !!(!__warned); if (__builtin_expect(!!(__ret_warn_on), 0)) warn_slowpath_null("/home/l/latest/linux/include/linux/blkdev.h", 430); __builtin_expect(!!(__ret_warn_on), 0); })) __warned = true; __builtin_expect(!!(__ret_warn_once), 0); });
|
| if ((__builtin_constant_p((flag)) ? constant_test_bit((flag), (&q->queue_flags)) : variable_test_bit((flag), (&q->queue_flags)))) {
|  __clear_bit(flag, &q->queue_flags);
|  return 1;
| }
|
| return 0;
|}
|
|static inline int queue_flag_test_and_set(unsigned int flag,
|       struct request_queue *q)
|{
| ({ static bool __warned; int __ret_warn_once = !!(!queue_is_locked(q)); if (__builtin_expect(!!(__ret_warn_once), 0)) if (({ int __ret_warn_on = !!(!__warned); if (__builtin_expect(!!(__ret_warn_on), 0)) warn_slowpath_null("/home/l/latest/linux/include/linux/blkdev.h", 443); __builtin_expect(!!(__ret_warn_on), 0); })) __warned = true; __builtin_expect(!!(__ret_warn_once), 0); });
|
| if (!(__builtin_constant_p((flag)) ? constant_test_bit((flag), (&q->queue_flags)) : variable_test_bit((flag), (&q->queue_flags)))) {
|  __set_bit(flag, &q->queue_flags);
|  return 0;
| }
|
| return 1;
|}
|
|static inline void queue_flag_set(unsigned int flag, struct request_queue *q)
|{
| ({ static bool __warned; int __ret_warn_once = !!(!queue_is_locked(q)); if (__builtin_expect(!!(__ret_warn_once), 0)) if (({ int __ret_warn_on = !!(!__warned); if (__builtin_expect(!!(__ret_warn_on), 0)) warn_slowpath_null("/home/l/latest/linux/include/linux/blkdev.h", 455); __builtin_expect(!!(__ret_warn_on), 0); })) __warned = true; __builtin_expect(!!(__ret_warn_once), 0); });
| __set_bit(flag, &q->queue_flags);
|}
|
|static inline void queue_flag_clear_unlocked(unsigned int flag,
|          struct request_queue *q)
|{
| __clear_bit(flag, &q->queue_flags);
|}
|
|static inline int queue_in_flight(struct request_queue *q)
|{
| return q->in_flight[0] + q->in_flight[1];
|}
|
|static inline void queue_flag_clear(unsigned int flag, struct request_queue *q)
|{
| ({ static bool __warned; int __ret_warn_once = !!(!queue_is_locked(q)); if (__builtin_expect(!!(__ret_warn_once), 0)) if (({ int __ret_warn_on = !!(!__warned); if (__builtin_expect(!!(__ret_warn_on), 0)) warn_slowpath_null("/home/l/latest/linux/include/linux/blkdev.h", 472); __builtin_expect(!!(__ret_warn_on), 0); })) __warned = true; __builtin_expect(!!(__ret_warn_once), 0); });
| __clear_bit(flag, &q->queue_flags);
|}
|static inline bool rw_is_sync(unsigned int rw_flags)
|{
| return !(rw_flags & (1 << __REQ_WRITE)) || (rw_flags & (1 << __REQ_SYNC));
|}
|
|static inline bool rq_is_sync(struct request *rq)
|{
| return rw_is_sync(rq->cmd_flags);
|}
|
|static inline int blk_queue_full(struct request_queue *q, int sync)
|{
| if (sync)
|  return (__builtin_constant_p((3)) ? constant_test_bit((3), (&q->queue_flags)) : variable_test_bit((3), (&q->queue_flags)));
| return (__builtin_constant_p((4)) ? constant_test_bit((4), (&q->queue_flags)) : variable_test_bit((4), (&q->queue_flags)));
|}
|
|static inline void blk_set_queue_full(struct request_queue *q, int sync)
|{
| if (sync)
|  queue_flag_set(3, q);
| else
|  queue_flag_set(4, q);
|}
|
|static inline void blk_clear_queue_full(struct request_queue *q, int sync)
|{
| if (sync)
|  queue_flag_clear(3, q);
| else
|  queue_flag_clear(4, q);
|}
|extern unsigned long blk_max_low_pfn, blk_max_pfn;
|extern int init_emergency_isa_pool(void);
|extern void blk_queue_bounce(struct request_queue *q, struct bio **bio);
|struct rq_map_data {
| struct page **pages;
| int page_order;
| int nr_entries;
| unsigned long offset;
| int null_mapped;
| int from_user;
|};
|
|struct req_iterator {
| int i;
| struct bio *bio;
|};
|static inline void rq_flush_dcache_pages(struct request *rq)
|{
|}
|
|
|extern int blk_register_queue(struct gendisk *disk);
|extern void blk_unregister_queue(struct gendisk *disk);
|extern void register_disk(struct gendisk *dev);
|extern void generic_make_request(struct bio *bio);
|extern void blk_rq_init(struct request_queue *q, struct request *rq);
|extern void blk_put_request(struct request *);
|extern void __blk_put_request(struct request_queue *, struct request *);
|extern struct request *blk_get_request(struct request_queue *, int, gfp_t);
|extern struct request *blk_make_request(struct request_queue *, struct bio *,
|     gfp_t);
|extern void blk_insert_request(struct request_queue *, struct request *, int, void *);
|extern void blk_requeue_request(struct request_queue *, struct request *);
|extern void blk_add_request_payload(struct request *rq, struct page *page,
|  unsigned int len);
|extern int blk_rq_check_limits(struct request_queue *q, struct request *rq);
|extern int blk_lld_busy(struct request_queue *q);
|extern int blk_rq_prep_clone(struct request *rq, struct request *rq_src,
|        struct bio_set *bs, gfp_t gfp_mask,
|        int (*bio_ctr)(struct bio *, struct bio *, void *),
|        void *data);
|extern void blk_rq_unprep_clone(struct request *rq);
|extern int blk_insert_cloned_request(struct request_queue *q,
|         struct request *rq);
|extern void blk_plug_device(struct request_queue *);
|extern void blk_plug_device_unlocked(struct request_queue *);
|extern int blk_remove_plug(struct request_queue *);
|extern void blk_recount_segments(struct request_queue *, struct bio *);
|extern int scsi_cmd_ioctl(struct request_queue *, struct gendisk *, fmode_t,
|     unsigned int, void *);
|extern int sg_scsi_ioctl(struct request_queue *, struct gendisk *, fmode_t,
|    struct scsi_ioctl_command *);
|
|
|
|
|
|
|static inline void blk_clear_queue_congested(struct request_queue *q, int sync)
|{
| clear_bdi_congested(&q->backing_dev_info, sync);
|}
|
|
|
|
|
|static inline void blk_set_queue_congested(struct request_queue *q, int sync)
|{
| set_bdi_congested(&q->backing_dev_info, sync);
|}
|
|extern void blk_start_queue(struct request_queue *q);
|extern void blk_stop_queue(struct request_queue *q);
|extern void blk_sync_queue(struct request_queue *q);
|extern void __blk_stop_queue(struct request_queue *q);
|extern void __blk_run_queue(struct request_queue *);
|extern void blk_run_queue(struct request_queue *);
|extern int blk_rq_map_user(struct request_queue *, struct request *,
|      struct rq_map_data *, void *, unsigned long,
|      gfp_t);
|extern int blk_rq_unmap_user(struct bio *);
|extern int blk_rq_map_kern(struct request_queue *, struct request *, void *, unsigned int, gfp_t);
|extern int blk_rq_map_user_iov(struct request_queue *, struct request *,
|          struct rq_map_data *, struct sg_iovec *, int,
|          unsigned int, gfp_t);
|extern int blk_execute_rq(struct request_queue *, struct gendisk *,
|     struct request *, int);
|extern void blk_execute_rq_nowait(struct request_queue *, struct gendisk *,
|      struct request *, int, rq_end_io_fn *);
|extern void blk_unplug(struct request_queue *q);
|
|static inline struct request_queue *bdev_get_queue(struct block_device *bdev)
|{
| return bdev->bd_disk->queue;
|}
|static inline sector_t blk_rq_pos(const struct request *rq)
|{
| return rq->__sector;
|}
|
|static inline unsigned int blk_rq_bytes(const struct request *rq)
|{
| return rq->__data_len;
|}
|
|static inline int blk_rq_cur_bytes(const struct request *rq)
|{
| return rq->bio ? bio_cur_bytes(rq->bio) : 0;
|}
|
|extern unsigned int blk_rq_err_bytes(const struct request *rq);
|
|static inline unsigned int blk_rq_sectors(const struct request *rq)
|{
| return blk_rq_bytes(rq) >> 9;
|}
|
|static inline unsigned int blk_rq_cur_sectors(const struct request *rq)
|{
| return blk_rq_cur_bytes(rq) >> 9;
|}
|
|
|
|
|extern struct request *blk_peek_request(struct request_queue *q);
|extern void blk_start_request(struct request *rq);
|extern struct request *blk_fetch_request(struct request_queue *q);
|extern bool blk_update_request(struct request *rq, int error,
|          unsigned int nr_bytes);
|extern bool blk_end_request(struct request *rq, int error,
|       unsigned int nr_bytes);
|extern void blk_end_request_all(struct request *rq, int error);
|extern bool blk_end_request_cur(struct request *rq, int error);
|extern bool blk_end_request_err(struct request *rq, int error);
|extern bool __blk_end_request(struct request *rq, int error,
|         unsigned int nr_bytes);
|extern void __blk_end_request_all(struct request *rq, int error);
|extern bool __blk_end_request_cur(struct request *rq, int error);
|extern bool __blk_end_request_err(struct request *rq, int error);
|
|extern void blk_complete_request(struct request *);
|extern void __blk_complete_request(struct request *);
|extern void blk_abort_request(struct request *);
|extern void blk_abort_queue(struct request_queue *);
|extern void blk_unprep_request(struct request *);
|
|
|
|
|extern struct request_queue *blk_init_queue_node(request_fn_proc *rfn,
|     spinlock_t *lock, int node_id);
|extern struct request_queue *blk_init_allocated_queue_node(struct request_queue *,
|          request_fn_proc *,
|          spinlock_t *, int node_id);
|extern struct request_queue *blk_init_queue(request_fn_proc *, spinlock_t *);
|extern struct request_queue *blk_init_allocated_queue(struct request_queue *,
|            request_fn_proc *, spinlock_t *);
|extern void blk_cleanup_queue(struct request_queue *);
|extern void blk_queue_make_request(struct request_queue *, make_request_fn *);
|extern void blk_queue_bounce_limit(struct request_queue *, u64);
|extern void blk_queue_max_hw_sectors(struct request_queue *, unsigned int);
|extern void blk_queue_max_segments(struct request_queue *, unsigned short);
|extern void blk_queue_max_segment_size(struct request_queue *, unsigned int);
|extern void blk_queue_max_discard_sectors(struct request_queue *q,
|  unsigned int max_discard_sectors);
|extern void blk_queue_logical_block_size(struct request_queue *, unsigned short);
|extern void blk_queue_physical_block_size(struct request_queue *, unsigned int);
|extern void blk_queue_alignment_offset(struct request_queue *q,
|           unsigned int alignment);
|extern void blk_limits_io_min(struct queue_limits *limits, unsigned int min);
|extern void blk_queue_io_min(struct request_queue *q, unsigned int min);
|extern void blk_limits_io_opt(struct queue_limits *limits, unsigned int opt);
|extern void blk_queue_io_opt(struct request_queue *q, unsigned int opt);
|extern void blk_set_default_limits(struct queue_limits *lim);
|extern int blk_stack_limits(struct queue_limits *t, struct queue_limits *b,
|       sector_t offset);
|extern int bdev_stack_limits(struct queue_limits *t, struct block_device *bdev,
|       sector_t offset);
|extern void disk_stack_limits(struct gendisk *disk, struct block_device *bdev,
|         sector_t offset);
|extern void blk_queue_stack_limits(struct request_queue *t, struct request_queue *b);
|extern void blk_queue_dma_pad(struct request_queue *, unsigned int);
|extern void blk_queue_update_dma_pad(struct request_queue *, unsigned int);
|extern int blk_queue_dma_drain(struct request_queue *q,
|          dma_drain_needed_fn *dma_drain_needed,
|          void *buf, unsigned int size);
|extern void blk_queue_lld_busy(struct request_queue *q, lld_busy_fn *fn);
|extern void blk_queue_segment_boundary(struct request_queue *, unsigned long);
|extern void blk_queue_prep_rq(struct request_queue *, prep_rq_fn *pfn);
|extern void blk_queue_unprep_rq(struct request_queue *, unprep_rq_fn *ufn);
|extern void blk_queue_merge_bvec(struct request_queue *, merge_bvec_fn *);
|extern void blk_queue_dma_alignment(struct request_queue *, int);
|extern void blk_queue_update_dma_alignment(struct request_queue *, int);
|extern void blk_queue_softirq_done(struct request_queue *, softirq_done_fn *);
|extern void blk_queue_rq_timed_out(struct request_queue *, rq_timed_out_fn *);
|extern void blk_queue_rq_timeout(struct request_queue *, unsigned int);
|extern void blk_queue_flush(struct request_queue *q, unsigned int flush);
|extern struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev);
|
|extern int blk_rq_map_sg(struct request_queue *, struct request *, struct scatterlist *);
|extern void blk_dump_rq_flags(struct request *, char *);
|extern void generic_unplug_device(struct request_queue *);
|extern long nr_blockdev_pages(void);
|
|int blk_get_queue(struct request_queue *);
|struct request_queue *blk_alloc_queue(gfp_t);
|struct request_queue *blk_alloc_queue_node(gfp_t, int);
|extern void blk_put_queue(struct request_queue *);
|
|
|
|
|
|extern int blk_queue_start_tag(struct request_queue *, struct request *);
|extern struct request *blk_queue_find_tag(struct request_queue *, int);
|extern void blk_queue_end_tag(struct request_queue *, struct request *);
|extern int blk_queue_init_tags(struct request_queue *, int, struct blk_queue_tag *);
|extern void blk_queue_free_tags(struct request_queue *);
|extern int blk_queue_resize_tags(struct request_queue *, int);
|extern void blk_queue_invalidate_tags(struct request_queue *);
|extern struct blk_queue_tag *blk_init_tags(int);
|extern void blk_free_tags(struct blk_queue_tag *);
|
|static inline struct request *blk_map_queue_find_tag(struct blk_queue_tag *bqt,
|      int tag)
|{
| if (__builtin_expect(!!(bqt == ((void *)0) || tag >= bqt->real_max_depth), 0))
|  return ((void *)0);
| return bqt->tag_index[tag];
|}
|
|
|
|extern int blkdev_issue_flush(struct block_device *, gfp_t, sector_t *);
|extern int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
|  sector_t nr_sects, gfp_t gfp_mask, unsigned long flags);
|extern int blkdev_issue_zeroout(struct block_device *bdev, sector_t sector,
|   sector_t nr_sects, gfp_t gfp_mask);
|static inline int sb_issue_discard(struct super_block *sb, sector_t block,
|  sector_t nr_blocks, gfp_t gfp_mask, unsigned long flags)
|{
| return blkdev_issue_discard(sb->s_bdev, block << (sb->s_blocksize_bits - 9),
|        nr_blocks << (sb->s_blocksize_bits - 9),
|        gfp_mask, flags);
|}
|static inline int sb_issue_zeroout(struct super_block *sb, sector_t block,
|  sector_t nr_blocks, gfp_t gfp_mask)
|{
| return blkdev_issue_zeroout(sb->s_bdev,
|        block << (sb->s_blocksize_bits - 9),
|        nr_blocks << (sb->s_blocksize_bits - 9),
|        gfp_mask);
|}
|
|extern int blk_verify_command(unsigned char *cmd, fmode_t has_write_perm);
|
|enum blk_default_limits {
| BLK_MAX_SEGMENTS = 128,
| BLK_SAFE_MAX_SECTORS = 255,
| BLK_DEF_MAX_SECTORS = 1024,
| BLK_MAX_SEGMENT_SIZE = 65536,
| BLK_SEG_BOUNDARY_MASK = 0xFFFFFFFFUL,
|};
|
|
|
|static inline unsigned long queue_bounce_pfn(struct request_queue *q)
|{
| return q->limits.bounce_pfn;
|}
|
|static inline unsigned long queue_segment_boundary(struct request_queue *q)
|{
| return q->limits.seg_boundary_mask;
|}
|
|static inline unsigned int queue_max_sectors(struct request_queue *q)
|{
| return q->limits.max_sectors;
|}
|
|static inline unsigned int queue_max_hw_sectors(struct request_queue *q)
|{
| return q->limits.max_hw_sectors;
|}
|
|static inline unsigned short queue_max_segments(struct request_queue *q)
|{
| return q->limits.max_segments;
|}
|
|static inline unsigned int queue_max_segment_size(struct request_queue *q)
|{
| return q->limits.max_segment_size;
|}
|
|static inline unsigned short queue_logical_block_size(struct request_queue *q)
|{
| int retval = 512;
|
| if (q && q->limits.logical_block_size)
|  retval = q->limits.logical_block_size;
|
| return retval;
|}
|
|static inline unsigned short bdev_logical_block_size(struct block_device *bdev)
|{
| return queue_logical_block_size(bdev_get_queue(bdev));
|}
|
|static inline unsigned int queue_physical_block_size(struct request_queue *q)
|{
| return q->limits.physical_block_size;
|}
|
|static inline unsigned int bdev_physical_block_size(struct block_device *bdev)
|{
| return queue_physical_block_size(bdev_get_queue(bdev));
|}
|
|static inline unsigned int queue_io_min(struct request_queue *q)
|{
| return q->limits.io_min;
|}
|
|static inline int bdev_io_min(struct block_device *bdev)
|{
| return queue_io_min(bdev_get_queue(bdev));
|}
|
|static inline unsigned int queue_io_opt(struct request_queue *q)
|{
| return q->limits.io_opt;
|}
|
|static inline int bdev_io_opt(struct block_device *bdev)
|{
| return queue_io_opt(bdev_get_queue(bdev));
|}
|
|static inline int queue_alignment_offset(struct request_queue *q)
|{
| if (q->limits.misaligned)
|  return -1;
|
| return q->limits.alignment_offset;
|}
|
|static inline int queue_limit_alignment_offset(struct queue_limits *lim, sector_t sector)
|{
| unsigned int granularity = ({ typeof(lim->physical_block_size) _max1 = (lim->physical_block_size); typeof(lim->io_min) _max2 = (lim->io_min); (void) (&_max1 == &_max2); _max1 > _max2 ? _max1 : _max2; });
| unsigned int alignment = (sector << 9) & (granularity - 1);
|
| return (granularity + lim->alignment_offset - alignment)
|  & (granularity - 1);
|}
|
|static inline int bdev_alignment_offset(struct block_device *bdev)
|{
| struct request_queue *q = bdev_get_queue(bdev);
|
| if (q->limits.misaligned)
|  return -1;
|
| if (bdev != bdev->bd_contains)
|  return bdev->bd_part->alignment_offset;
|
| return q->limits.alignment_offset;
|}
|
|static inline int queue_discard_alignment(struct request_queue *q)
|{
| if (q->limits.discard_misaligned)
|  return -1;
|
| return q->limits.discard_alignment;
|}
|
|static inline int queue_limit_discard_alignment(struct queue_limits *lim, sector_t sector)
|{
| unsigned int alignment = (sector << 9) & (lim->discard_granularity - 1);
|
| return (lim->discard_granularity + lim->discard_alignment - alignment)
|  & (lim->discard_granularity - 1);
|}
|
|static inline unsigned int queue_discard_zeroes_data(struct request_queue *q)
|{
| if (q->limits.discard_zeroes_data == 1)
|  return 1;
|
| return 0;
|}
|
|static inline unsigned int bdev_discard_zeroes_data(struct block_device *bdev)
|{
| return queue_discard_zeroes_data(bdev_get_queue(bdev));
|}
|
|static inline int queue_dma_alignment(struct request_queue *q)
|{
| return q ? q->dma_alignment : 511;
|}
|
|static inline int blk_rq_aligned(struct request_queue *q, unsigned long addr,
|     unsigned int len)
|{
| unsigned int alignment = queue_dma_alignment(q) | q->dma_pad_mask;
| return !(addr & alignment) && !(len & alignment);
|}
|
|
|static inline unsigned int blksize_bits(unsigned int size)
|{
| unsigned int bits = 8;
| do {
|  bits++;
|  size >>= 1;
| } while (size > 256);
| return bits;
|}
|
|static inline unsigned int block_size(struct block_device *bdev)
|{
| return bdev->bd_block_size;
|}
|
|typedef struct {struct page *v;} Sector;
|
|unsigned char *read_dev_sector(struct block_device *, sector_t, Sector *);
|
|static inline void put_dev_sector(Sector p)
|{
| put_page(p.v);
|}
|
|struct work_struct;
|int kblockd_schedule_work(struct request_queue *q, struct work_struct *work);
|int kblockd_schedule_delayed_work(struct request_queue *q, struct delayed_work *dwork, unsigned long delay);
|static inline void set_start_time_ns(struct request *req) {}
|static inline void set_io_start_time_ns(struct request *req) {}
|static inline uint64_t rq_start_time_ns(struct request *req)
|{
| return 0;
|}
|static inline uint64_t rq_io_start_time_ns(struct request *req)
|{
| return 0;
|}
|static inline int blk_throtl_bio(struct request_queue *q, struct bio **bio)
|{
| return 0;
|}
|
|static inline int blk_throtl_init(struct request_queue *q) { return 0; }
|static inline int blk_throtl_exit(struct request_queue *q) { return 0; }
|static inline void throtl_schedule_delayed_work(struct request_queue *q, unsigned long delay) {}
|static inline void throtl_shutdown_timer_wq(struct request_queue *q) {}
|struct blk_integrity_exchg {
| void *prot_buf;
| void *data_buf;
| sector_t sector;
| unsigned int data_size;
| unsigned short sector_size;
| const char *disk_name;
|};
|
|typedef void (integrity_gen_fn) (struct blk_integrity_exchg *);
|typedef int (integrity_vrfy_fn) (struct blk_integrity_exchg *);
|typedef void (integrity_set_tag_fn) (void *, void *, unsigned int);
|typedef void (integrity_get_tag_fn) (void *, void *, unsigned int);
|
|struct blk_integrity {
| integrity_gen_fn *generate_fn;
| integrity_vrfy_fn *verify_fn;
| integrity_set_tag_fn *set_tag_fn;
| integrity_get_tag_fn *get_tag_fn;
|
| unsigned short flags;
| unsigned short tuple_size;
| unsigned short sector_size;
| unsigned short tag_size;
|
| const char *name;
|
| struct kobject kobj;
|};
|
|extern int blk_integrity_register(struct gendisk *, struct blk_integrity *);
|extern void blk_integrity_unregister(struct gendisk *);
|extern int blk_integrity_compare(struct gendisk *, struct gendisk *);
|extern int blk_rq_map_integrity_sg(struct request_queue *, struct bio *,
|       struct scatterlist *);
|extern int blk_rq_count_integrity_sg(struct request_queue *, struct bio *);
|extern int blk_integrity_merge_rq(struct request_queue *, struct request *,
|      struct request *);
|extern int blk_integrity_merge_bio(struct request_queue *, struct request *,
|       struct bio *);
|
|static inline
|struct blk_integrity *bdev_get_integrity(struct block_device *bdev)
|{
| return bdev->bd_disk->integrity;
|}
|
|static inline struct blk_integrity *blk_get_integrity(struct gendisk *disk)
|{
| return disk->integrity;
|}
|
|static inline int blk_integrity_rq(struct request *rq)
|{
| if (rq->bio == ((void *)0))
|  return 0;
|
| return (rq->bio->bi_integrity != ((void *)0));
|}
|
|static inline void blk_queue_max_integrity_segments(struct request_queue *q,
|          unsigned int segs)
|{
| q->limits.max_integrity_segments = segs;
|}
|
|static inline unsigned short
|queue_max_integrity_segments(struct request_queue *q)
|{
| return q->limits.max_integrity_segments;
|}
|struct block_device_operations {
| int (*open) (struct block_device *, fmode_t);
| int (*release) (struct gendisk *, fmode_t);
| int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
| int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
| int (*direct_access) (struct block_device *, sector_t,
|      void **, unsigned long *);
| int (*media_changed) (struct gendisk *);
| void (*unlock_native_capacity) (struct gendisk *);
| int (*revalidate_disk) (struct gendisk *);
| int (*getgeo)(struct block_device *, struct hd_geometry *);
|
| void (*swap_slot_free_notify) (struct block_device *, unsigned long);
| struct module *owner;
|};
|
|extern int __blkdev_driver_ioctl(struct block_device *, fmode_t, unsigned int,
|     unsigned long);
|struct fsnotify_group;
|struct fsnotify_event;
|struct fsnotify_mark;
|struct fsnotify_event_private_data;
|struct fsnotify_ops {
| bool (*should_send_event)(struct fsnotify_group *group, struct inode *inode,
|      struct fsnotify_mark *inode_mark,
|      struct fsnotify_mark *vfsmount_mark,
|      __u32 mask, void *data, int data_type);
| int (*handle_event)(struct fsnotify_group *group,
|       struct fsnotify_mark *inode_mark,
|       struct fsnotify_mark *vfsmount_mark,
|       struct fsnotify_event *event);
| void (*free_group_priv)(struct fsnotify_group *group);
| void (*freeing_mark)(struct fsnotify_mark *mark, struct fsnotify_group *group);
| void (*free_event_priv)(struct fsnotify_event_private_data *priv);
|};
|
|
|
|
|
|
|
|struct fsnotify_group {
| atomic_t refcnt;
|
| const struct fsnotify_ops *ops;
|
|
| struct mutex notification_mutex;
| struct list_head notification_list;
| wait_queue_head_t notification_waitq;
| unsigned int q_len;
| unsigned int max_events;
|
|
|
|
|
|
|
| unsigned int priority;
|
|
| spinlock_t mark_lock;
| atomic_t num_marks;
|
|
| struct list_head marks_list;
|
|
| union {
|  void *private;
|
|  struct inotify_group_private_data {
|   spinlock_t idr_lock;
|   struct idr idr;
|   u32 last_wd;
|   struct fasync_struct *fa;
|   struct user_struct *user;
|  } inotify_data;
|
|
|  struct fanotify_group_private_data {
|
|
|   struct mutex access_mutex;
|   struct list_head access_list;
|   wait_queue_head_t access_waitq;
|   bool bypass_perm;
|
|   bool readonly_fallback;
|   int f_flags;
|   unsigned int max_marks;
|   struct user_struct *user;
|  } fanotify_data;
|
| };
|};
|struct fsnotify_event_holder {
| struct fsnotify_event *event;
| struct list_head event_list;
|};
|
|
|
|
|
|struct fsnotify_event_private_data {
| struct fsnotify_group *group;
| struct list_head event_list;
|};
|
|
|
|
|
|
|struct fsnotify_event {
|
|
|
|
|
| struct fsnotify_event_holder holder;
| spinlock_t lock;
|
| struct inode *to_tell;
| union {
|  struct path path;
|  struct inode *inode;
| };
|
|
|
|
| int data_type;
| atomic_t refcnt;
| __u32 mask;
|
| u32 sync_cookie;
| const unsigned char *file_name;
| size_t name_len;
| struct pid *tgid;
|
|
| __u32 response;
|
|
| struct list_head private_data_list;
|};
|
|
|
|
|struct fsnotify_inode_mark {
| struct inode *inode;
| struct hlist_node i_list;
| struct list_head free_i_list;
|};
|
|
|
|
|struct fsnotify_vfsmount_mark {
| struct vfsmount *mnt;
| struct hlist_node m_list;
| struct list_head free_m_list;
|};
|struct fsnotify_mark {
| __u32 mask;
|
|
| atomic_t refcnt;
| struct fsnotify_group *group;
| struct list_head g_list;
| spinlock_t lock;
| union {
|  struct fsnotify_inode_mark i;
|  struct fsnotify_vfsmount_mark m;
| };
| struct list_head free_g_list;
| __u32 ignored_mask;
|
|
|
|
|
| unsigned int flags;
| struct list_head destroy_list;
| void (*free_mark)(struct fsnotify_mark *mark);
|};
|
|
|
|
|
|
|extern int fsnotify(struct inode *to_tell, __u32 mask, void *data, int data_is,
|      const unsigned char *name, u32 cookie);
|extern int __fsnotify_parent(struct path *path, struct dentry *dentry, __u32 mask);
|extern void __fsnotify_inode_delete(struct inode *inode);
|extern void __fsnotify_vfsmount_delete(struct vfsmount *mnt);
|extern u32 fsnotify_get_cookie(void);
|
|static inline int fsnotify_inode_watches_children(struct inode *inode)
|{
|
| if (!(inode->i_fsnotify_mask & 0x08000000))
|  return 0;
|
|
| return inode->i_fsnotify_mask & (0x00000001 | 0x00000002 | 0x00000004 | 0x00000008 | 0x00000010 | 0x00000020 | 0x00000040 | 0x00000080 | 0x00000100 | 0x00000200);
|}
|
|
|
|
|
|static inline void __fsnotify_update_dcache_flags(struct dentry *dentry)
|{
| struct dentry *parent;
|
| assert_spin_locked(&dcache_lock);
| assert_spin_locked(&dentry->d_lock);
|
| parent = dentry->d_parent;
| if (parent->d_inode && fsnotify_inode_watches_children(parent->d_inode))
|  dentry->d_flags |= 0x0080;
| else
|  dentry->d_flags &= ~0x0080;
|}
|
|
|
|
|
|static inline void __fsnotify_d_instantiate(struct dentry *dentry, struct inode *inode)
|{
| if (!inode)
|  return;
|
| assert_spin_locked(&dcache_lock);
|
| spin_lock(&dentry->d_lock);
| __fsnotify_update_dcache_flags(dentry);
| spin_unlock(&dentry->d_lock);
|}
|
|
|
|
|extern struct fsnotify_group *fsnotify_alloc_group(const struct fsnotify_ops *ops);
|
|extern void fsnotify_put_group(struct fsnotify_group *group);
|
|
|extern void fsnotify_get_event(struct fsnotify_event *event);
|extern void fsnotify_put_event(struct fsnotify_event *event);
|
|extern struct fsnotify_event_private_data *fsnotify_remove_priv_from_event(struct fsnotify_group *group,
|            struct fsnotify_event *event);
|
|
|extern struct fsnotify_event *fsnotify_add_notify_event(struct fsnotify_group *group,
|       struct fsnotify_event *event,
|       struct fsnotify_event_private_data *priv,
|       struct fsnotify_event *(*merge)(struct list_head *,
|           struct fsnotify_event *));
|
|extern bool fsnotify_notify_queue_is_empty(struct fsnotify_group *group);
|
|extern struct fsnotify_event *fsnotify_peek_notify_event(struct fsnotify_group *group);
|
|extern struct fsnotify_event *fsnotify_remove_notify_event(struct fsnotify_group *group);
|
|
|
|
|extern void fsnotify_recalc_vfsmount_mask(struct vfsmount *mnt);
|
|extern void fsnotify_recalc_inode_mask(struct inode *inode);
|extern void fsnotify_init_mark(struct fsnotify_mark *mark, void (*free_mark)(struct fsnotify_mark *mark));
|
|extern struct fsnotify_mark *fsnotify_find_inode_mark(struct fsnotify_group *group, struct inode *inode);
|
|extern struct fsnotify_mark *fsnotify_find_vfsmount_mark(struct fsnotify_group *group, struct vfsmount *mnt);
|
|extern void fsnotify_duplicate_mark(struct fsnotify_mark *new, struct fsnotify_mark *old);
|
|extern void fsnotify_set_mark_ignored_mask_locked(struct fsnotify_mark *mark, __u32 mask);
|
|extern void fsnotify_set_mark_mask_locked(struct fsnotify_mark *mark, __u32 mask);
|
|extern int fsnotify_add_mark(struct fsnotify_mark *mark, struct fsnotify_group *group,
|        struct inode *inode, struct vfsmount *mnt, int allow_dups);
|
|extern void fsnotify_destroy_mark(struct fsnotify_mark *mark);
|
|extern void fsnotify_clear_vfsmount_marks_by_group(struct fsnotify_group *group);
|
|extern void fsnotify_clear_inode_marks_by_group(struct fsnotify_group *group);
|
|extern void fsnotify_clear_marks_by_group_flags(struct fsnotify_group *group, unsigned int flags);
|
|extern void fsnotify_clear_marks_by_group(struct fsnotify_group *group);
|extern void fsnotify_unmount_inodes(struct list_head *list);
|
|
|extern struct fsnotify_event *fsnotify_create_event(struct inode *to_tell, __u32 mask,
|          void *data, int data_is,
|          const unsigned char *name,
|          u32 cookie, gfp_t gfp);
|
|
|extern struct fsnotify_event *fsnotify_clone_event(struct fsnotify_event *old_event);
|extern int fsnotify_replace_event(struct fsnotify_event_holder *old_holder,
|      struct fsnotify_event *new_event);
|
|static inline void fsnotify_get_mark(struct fsnotify_mark *mark)
|{
| atomic_inc(&mark->refcnt);
|}
|
|static inline void fsnotify_put_mark(struct fsnotify_mark *mark)
|{
| if (atomic_dec_and_test(&mark->refcnt))
|  mark->free_mark(mark);
|}
|enum {
| Audit_equal,
| Audit_not_equal,
| Audit_bitmask,
| Audit_bittest,
| Audit_lt,
| Audit_gt,
| Audit_le,
| Audit_ge,
| Audit_bad
|};
|struct audit_status {
| __u32 mask;
| __u32 enabled;
| __u32 failure;
| __u32 pid;
| __u32 rate_limit;
| __u32 backlog_limit;
| __u32 lost;
| __u32 backlog;
|};
|
|struct audit_tty_status {
| __u32 enabled;
|};
|
|
|
|
|
|struct audit_rule_data {
| __u32 flags;
| __u32 action;
| __u32 field_count;
| __u32 mask[64];
| __u32 fields[64];
| __u32 values[64];
| __u32 fieldflags[64];
| __u32 buflen;
| char buf[0];
|};
|
|
|
|
|
|struct audit_rule {
| __u32 flags;
| __u32 action;
| __u32 field_count;
| __u32 mask[64];
| __u32 fields[64];
| __u32 values[64];
|};
|
|
|
|
|struct audit_sig_info {
| uid_t uid;
| pid_t pid;
| char ctx[0];
|};
|
|struct audit_buffer;
|struct audit_context;
|struct inode;
|struct netlink_skb_parms;
|struct linux_binprm;
|struct mq_attr;
|struct mqstat;
|struct audit_watch;
|struct audit_tree;
|
|struct audit_krule {
| int vers_ops;
| u32 flags;
| u32 listnr;
| u32 action;
| u32 mask[64];
| u32 buflen;
| u32 field_count;
| char *filterkey;
| struct audit_field *fields;
| struct audit_field *arch_f;
| struct audit_field *inode_f;
| struct audit_watch *watch;
| struct audit_tree *tree;
| struct list_head rlist;
| struct list_head list;
| u64 prio;
|};
|
|struct audit_field {
| u32 type;
| u32 val;
| u32 op;
| char *lsm_str;
| void *lsm_rule;
|};
|
|
|
|
|
|extern int audit_register_class(int class, unsigned *list);
|extern int audit_classify_syscall(int abi, unsigned syscall);
|extern int audit_classify_arch(int arch);
|
|
|
|extern void audit_finish_fork(struct task_struct *child);
|extern int audit_alloc(struct task_struct *task);
|extern void audit_free(struct task_struct *task);
|extern void audit_syscall_entry(int arch,
|    int major, unsigned long a0, unsigned long a1,
|    unsigned long a2, unsigned long a3);
|extern void audit_syscall_exit(int failed, long return_code);
|extern void __audit_getname(const char *name);
|extern void audit_putname(const char *name);
|extern void __audit_inode(const char *name, const struct dentry *dentry);
|extern void __audit_inode_child(const struct dentry *dentry,
|    const struct inode *parent);
|extern void __audit_ptrace(struct task_struct *t);
|
|static inline int audit_dummy_context(void)
|{
| void *p = get_current()->audit_context;
| return !p || *(int *)p;
|}
|static inline void audit_getname(const char *name)
|{
| if (__builtin_expect(!!(!audit_dummy_context()), 0))
|  __audit_getname(name);
|}
|static inline void audit_inode(const char *name, const struct dentry *dentry) {
| if (__builtin_expect(!!(!audit_dummy_context()), 0))
|  __audit_inode(name, dentry);
|}
|static inline void audit_inode_child(const struct dentry *dentry,
|         const struct inode *parent) {
| if (__builtin_expect(!!(!audit_dummy_context()), 0))
|  __audit_inode_child(dentry, parent);
|}
|void audit_core_dumps(long signr);
|
|static inline void audit_ptrace(struct task_struct *t)
|{
| if (__builtin_expect(!!(!audit_dummy_context()), 0))
|  __audit_ptrace(t);
|}
|
|
|extern unsigned int audit_serial(void);
|extern int auditsc_get_stamp(struct audit_context *ctx,
|         struct timespec *t, unsigned int *serial);
|extern int audit_set_loginuid(struct task_struct *task, uid_t loginuid);
|
|
|extern void audit_log_task_context(struct audit_buffer *ab);
|extern void __audit_ipc_obj(struct kern_ipc_perm *ipcp);
|extern void __audit_ipc_set_perm(unsigned long qbytes, uid_t uid, gid_t gid, mode_t mode);
|extern int audit_bprm(struct linux_binprm *bprm);
|extern void audit_socketcall(int nargs, unsigned long *args);
|extern int audit_sockaddr(int len, void *addr);
|extern void __audit_fd_pair(int fd1, int fd2);
|extern int audit_set_macxattr(const char *name);
|extern void __audit_mq_open(int oflag, mode_t mode, struct mq_attr *attr);
|extern void __audit_mq_sendrecv(mqd_t mqdes, size_t msg_len, unsigned int msg_prio, const struct timespec *abs_timeout);
|extern void __audit_mq_notify(mqd_t mqdes, const struct sigevent *notification);
|extern void __audit_mq_getsetattr(mqd_t mqdes, struct mq_attr *mqstat);
|extern int __audit_log_bprm_fcaps(struct linux_binprm *bprm,
|      const struct cred *new,
|      const struct cred *old);
|extern void __audit_log_capset(pid_t pid, const struct cred *new, const struct cred *old);
|extern void __audit_mmap_fd(int fd, int flags);
|
|static inline void audit_ipc_obj(struct kern_ipc_perm *ipcp)
|{
| if (__builtin_expect(!!(!audit_dummy_context()), 0))
|  __audit_ipc_obj(ipcp);
|}
|static inline void audit_fd_pair(int fd1, int fd2)
|{
| if (__builtin_expect(!!(!audit_dummy_context()), 0))
|  __audit_fd_pair(fd1, fd2);
|}
|static inline void audit_ipc_set_perm(unsigned long qbytes, uid_t uid, gid_t gid, mode_t mode)
|{
| if (__builtin_expect(!!(!audit_dummy_context()), 0))
|  __audit_ipc_set_perm(qbytes, uid, gid, mode);
|}
|static inline void audit_mq_open(int oflag, mode_t mode, struct mq_attr *attr)
|{
| if (__builtin_expect(!!(!audit_dummy_context()), 0))
|  __audit_mq_open(oflag, mode, attr);
|}
|static inline void audit_mq_sendrecv(mqd_t mqdes, size_t msg_len, unsigned int msg_prio, const struct timespec *abs_timeout)
|{
| if (__builtin_expect(!!(!audit_dummy_context()), 0))
|  __audit_mq_sendrecv(mqdes, msg_len, msg_prio, abs_timeout);
|}
|static inline void audit_mq_notify(mqd_t mqdes, const struct sigevent *notification)
|{
| if (__builtin_expect(!!(!audit_dummy_context()), 0))
|  __audit_mq_notify(mqdes, notification);
|}
|static inline void audit_mq_getsetattr(mqd_t mqdes, struct mq_attr *mqstat)
|{
| if (__builtin_expect(!!(!audit_dummy_context()), 0))
|  __audit_mq_getsetattr(mqdes, mqstat);
|}
|
|static inline int audit_log_bprm_fcaps(struct linux_binprm *bprm,
|           const struct cred *new,
|           const struct cred *old)
|{
| if (__builtin_expect(!!(!audit_dummy_context()), 0))
|  return __audit_log_bprm_fcaps(bprm, new, old);
| return 0;
|}
|
|static inline void audit_log_capset(pid_t pid, const struct cred *new,
|       const struct cred *old)
|{
| if (__builtin_expect(!!(!audit_dummy_context()), 0))
|  __audit_log_capset(pid, new, old);
|}
|
|static inline void audit_mmap_fd(int fd, int flags)
|{
| if (__builtin_expect(!!(!audit_dummy_context()), 0))
|  __audit_mmap_fd(fd, flags);
|}
|
|extern int audit_n_rules;
|extern int audit_signals;
|extern void audit_log(struct audit_context *ctx, gfp_t gfp_mask,
|          int type, const char *fmt, ...)
|          ;
|
|extern struct audit_buffer *audit_log_start(struct audit_context *ctx, gfp_t gfp_mask, int type);
|extern void audit_log_format(struct audit_buffer *ab,
|          const char *fmt, ...)
|       ;
|extern void audit_log_end(struct audit_buffer *ab);
|extern int audit_string_contains_control(const char *string,
|         size_t len);
|extern void audit_log_n_hex(struct audit_buffer *ab,
|       const unsigned char *buf,
|       size_t len);
|extern void audit_log_n_string(struct audit_buffer *ab,
|            const char *buf,
|            size_t n);
|
|extern void audit_log_n_untrustedstring(struct audit_buffer *ab,
|       const char *string,
|       size_t n);
|extern void audit_log_untrustedstring(struct audit_buffer *ab,
|            const char *string);
|extern void audit_log_d_path(struct audit_buffer *ab,
|          const char *prefix,
|          struct path *path);
|extern void audit_log_key(struct audit_buffer *ab,
|       char *key);
|extern void audit_log_lost(const char *message);
|extern int audit_update_lsm_rules(void);
|
|
|extern int audit_filter_user(struct netlink_skb_parms *cb);
|extern int audit_filter_type(int type);
|extern int audit_receive_filter(int type, int pid, int uid, int seq,
|    void *data, size_t datasz, uid_t loginuid,
|    u32 sessionid, u32 sid);
|extern int audit_enabled;
|
|
|
|
|
|
|static inline void fsnotify_d_instantiate(struct dentry *dentry,
|       struct inode *inode)
|{
| __fsnotify_d_instantiate(dentry, inode);
|}
|
|
|static inline int fsnotify_parent(struct path *path, struct dentry *dentry, __u32 mask)
|{
| if (!dentry)
|  dentry = path->dentry;
|
| return __fsnotify_parent(path, dentry, mask);
|}
|
|
|static inline int fsnotify_perm(struct file *file, int mask)
|{
| struct path *path = &file->f_path;
| struct inode *inode = path->dentry->d_inode;
| __u32 fsnotify_mask = 0;
| int ret;
|
| if (file->f_mode & (( fmode_t)0x1000000))
|  return 0;
| if (!(mask & (4 | 32)))
|  return 0;
| if (mask & 32)
|  fsnotify_mask = 0x00010000;
| else if (mask & 4)
|  fsnotify_mask = 0x00020000;
| else
|  do { asm volatile("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b - 2b, %c0 - 2b\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection" : : "i" ("/home/l/latest/linux/include/linux/fsnotify.h"), "i" (54), "i" (sizeof(struct bug_entry))); __builtin_unreachable(); } while (0);
|
| ret = fsnotify_parent(path, ((void *)0), fsnotify_mask);
| if (ret)
|  return ret;
|
| return fsnotify(inode, fsnotify_mask, path, 1, ((void *)0), 0);
|}
|
|
|
|
|
|static inline void fsnotify_d_move(struct dentry *dentry)
|{
|
|
|
|
| __fsnotify_update_dcache_flags(dentry);
|}
|
|
|
|
|static inline void fsnotify_link_count(struct inode *inode)
|{
| fsnotify(inode, 0x00000004, inode, 2, ((void *)0), 0);
|}
|
|
|
|
|static inline void fsnotify_move(struct inode *old_dir, struct inode *new_dir,
|     const unsigned char *old_name,
|     int isdir, struct inode *target, struct dentry *moved)
|{
| struct inode *source = moved->d_inode;
| u32 fs_cookie = fsnotify_get_cookie();
| __u32 old_dir_mask = (0x08000000 | 0x00000040);
| __u32 new_dir_mask = (0x08000000 | 0x00000080);
| const unsigned char *new_name = moved->d_name.name;
|
| if (old_dir == new_dir)
|  old_dir_mask |= 0x10000000;
|
| if (isdir) {
|  old_dir_mask |= 0x40000000;
|  new_dir_mask |= 0x40000000;
| }
|
| fsnotify(old_dir, old_dir_mask, old_dir, 2, old_name, fs_cookie);
| fsnotify(new_dir, new_dir_mask, new_dir, 2, new_name, fs_cookie);
|
| if (target)
|  fsnotify_link_count(target);
|
| if (source)
|  fsnotify(source, 0x00000800, moved->d_inode, 2, ((void *)0), 0);
| audit_inode_child(moved, new_dir);
|}
|
|
|
|
|static inline void fsnotify_inode_delete(struct inode *inode)
|{
| __fsnotify_inode_delete(inode);
|}
|
|
|
|
|static inline void fsnotify_vfsmount_delete(struct vfsmount *mnt)
|{
| __fsnotify_vfsmount_delete(mnt);
|}
|
|
|
|
|static inline void fsnotify_nameremove(struct dentry *dentry, int isdir)
|{
| __u32 mask = 0x00000200;
|
| if (isdir)
|  mask |= 0x40000000;
|
| fsnotify_parent(((void *)0), dentry, mask);
|}
|
|
|
|
|static inline void fsnotify_inoderemove(struct inode *inode)
|{
| fsnotify(inode, 0x00000400, inode, 2, ((void *)0), 0);
| __fsnotify_inode_delete(inode);
|}
|
|
|
|
|static inline void fsnotify_create(struct inode *inode, struct dentry *dentry)
|{
| audit_inode_child(dentry, inode);
|
| fsnotify(inode, 0x00000100, dentry->d_inode, 2, dentry->d_name.name, 0);
|}
|
|
|
|
|
|
|static inline void fsnotify_link(struct inode *dir, struct inode *inode, struct dentry *new_dentry)
|{
| fsnotify_link_count(inode);
| audit_inode_child(new_dentry, dir);
|
| fsnotify(dir, 0x00000100, inode, 2, new_dentry->d_name.name, 0);
|}
|
|
|
|
|static inline void fsnotify_mkdir(struct inode *inode, struct dentry *dentry)
|{
| __u32 mask = (0x00000100 | 0x40000000);
| struct inode *d_inode = dentry->d_inode;
|
| audit_inode_child(dentry, inode);
|
| fsnotify(inode, mask, d_inode, 2, dentry->d_name.name, 0);
|}
|
|
|
|
|static inline void fsnotify_access(struct file *file)
|{
| struct path *path = &file->f_path;
| struct inode *inode = path->dentry->d_inode;
| __u32 mask = 0x00000001;
|
| if ((((inode->i_mode) & 00170000) == 0040000))
|  mask |= 0x40000000;
|
| if (!(file->f_mode & (( fmode_t)0x1000000))) {
|  fsnotify_parent(path, ((void *)0), mask);
|  fsnotify(inode, mask, path, 1, ((void *)0), 0);
| }
|}
|
|
|
|
|static inline void fsnotify_modify(struct file *file)
|{
| struct path *path = &file->f_path;
| struct inode *inode = path->dentry->d_inode;
| __u32 mask = 0x00000002;
|
| if ((((inode->i_mode) & 00170000) == 0040000))
|  mask |= 0x40000000;
|
| if (!(file->f_mode & (( fmode_t)0x1000000))) {
|  fsnotify_parent(path, ((void *)0), mask);
|  fsnotify(inode, mask, path, 1, ((void *)0), 0);
| }
|}
|
|
|
|
|static inline void fsnotify_open(struct file *file)
|{
| struct path *path = &file->f_path;
| struct inode *inode = path->dentry->d_inode;
| __u32 mask = 0x00000020;
|
| if ((((inode->i_mode) & 00170000) == 0040000))
|  mask |= 0x40000000;
|
| fsnotify_parent(path, ((void *)0), mask);
| fsnotify(inode, mask, path, 1, ((void *)0), 0);
|}
|
|
|
|
|static inline void fsnotify_close(struct file *file)
|{
| struct path *path = &file->f_path;
| struct inode *inode = file->f_path.dentry->d_inode;
| fmode_t mode = file->f_mode;
| __u32 mask = (mode & (( fmode_t)0x2)) ? 0x00000008 : 0x00000010;
|
| if ((((inode->i_mode) & 00170000) == 0040000))
|  mask |= 0x40000000;
|
| if (!(file->f_mode & (( fmode_t)0x1000000))) {
|  fsnotify_parent(path, ((void *)0), mask);
|  fsnotify(inode, mask, path, 1, ((void *)0), 0);
| }
|}
|
|
|
|
|static inline void fsnotify_xattr(struct dentry *dentry)
|{
| struct inode *inode = dentry->d_inode;
| __u32 mask = 0x00000004;
|
| if ((((inode->i_mode) & 00170000) == 0040000))
|  mask |= 0x40000000;
|
| fsnotify_parent(((void *)0), dentry, mask);
| fsnotify(inode, mask, inode, 2, ((void *)0), 0);
|}
|
|
|
|
|
|static inline void fsnotify_change(struct dentry *dentry, unsigned int ia_valid)
|{
| struct inode *inode = dentry->d_inode;
| __u32 mask = 0;
|
| if (ia_valid & (1 << 1))
|  mask |= 0x00000004;
| if (ia_valid & (1 << 2))
|  mask |= 0x00000004;
| if (ia_valid & (1 << 3))
|  mask |= 0x00000002;
|
|
| if ((ia_valid & ((1 << 4) | (1 << 5))) == ((1 << 4) | (1 << 5)))
|  mask |= 0x00000004;
| else if (ia_valid & (1 << 4))
|  mask |= 0x00000001;
| else if (ia_valid & (1 << 5))
|  mask |= 0x00000002;
|
| if (ia_valid & (1 << 0))
|  mask |= 0x00000004;
|
| if (mask) {
|  if ((((inode->i_mode) & 00170000) == 0040000))
|   mask |= 0x40000000;
|
|  fsnotify_parent(((void *)0), dentry, mask);
|  fsnotify(inode, mask, inode, 2, ((void *)0), 0);
| }
|}
|
|
|
|
|
|
|static inline const unsigned char *fsnotify_oldname_init(const unsigned char *name)
|{
| return kstrdup(name, ((( gfp_t)0x10u) | (( gfp_t)0x40u) | (( gfp_t)0x80u)));
|}
|
|
|
|
|static inline void fsnotify_oldname_free(const unsigned char *old_name)
|{
| kfree(old_name);
|}
|
|
|
|
|
|struct pt_regs;
|struct linux_binprm{
| char buf[128];
|
| struct vm_area_struct *vma;
|
|
|
|
| struct mm_struct *mm;
| unsigned long p;
| unsigned int
|  cred_prepared:1,
|
|  cap_effective:1;
|
|
|
|
|
| unsigned int recursion_depth;
| struct file * file;
| struct cred *cred;
| int unsafe;
| unsigned int per_clear;
| int argc, envc;
| const char * filename;
| const char * interp;
|
|
| unsigned interp_flags;
| unsigned interp_data;
| unsigned long loader, exec;
|};
|struct coredump_params {
| long signr;
| struct pt_regs *regs;
| struct file *file;
| unsigned long limit;
| unsigned long mm_flags;
|};
|
|
|
|
|
|struct linux_binfmt {
| struct list_head lh;
| struct module *module;
| int (*load_binary)(struct linux_binprm *, struct pt_regs * regs);
| int (*load_shlib)(struct file *);
| int (*core_dump)(struct coredump_params *cprm);
| unsigned long min_coredump;
| int hasvdso;
|};
|
|extern int __register_binfmt(struct linux_binfmt *fmt, int insert);
|
|
|static inline int register_binfmt(struct linux_binfmt *fmt)
|{
| return __register_binfmt(fmt, 0);
|}
|
|static inline int insert_binfmt(struct linux_binfmt *fmt)
|{
| return __register_binfmt(fmt, 1);
|}
|
|extern void unregister_binfmt(struct linux_binfmt *);
|
|extern int prepare_binprm(struct linux_binprm *);
|extern int remove_arg_zero(struct linux_binprm *);
|extern int search_binary_handler(struct linux_binprm *,struct pt_regs *);
|extern int flush_old_exec(struct linux_binprm * bprm);
|extern void setup_new_exec(struct linux_binprm * bprm);
|
|extern int suid_dumpable;
|extern int setup_arg_pages(struct linux_binprm * bprm,
|      unsigned long stack_top,
|      int executable_stack);
|extern int bprm_mm_init(struct linux_binprm *bprm);
|extern int copy_strings_kernel(int argc, const char *const *argv,
|          struct linux_binprm *bprm);
|extern int prepare_bprm_creds(struct linux_binprm *bprm);
|extern void install_exec_creds(struct linux_binprm *bprm);
|extern void do_coredump(long signr, int exit_code, struct pt_regs *regs);
|extern void set_binfmt(struct linux_binfmt *new);
|extern void free_bprm(struct linux_binprm *);
|
|
|
|
|
|
|struct shmid_ds {
| struct ipc_perm shm_perm;
| int shm_segsz;
| __kernel_time_t shm_atime;
| __kernel_time_t shm_dtime;
| __kernel_time_t shm_ctime;
| __kernel_ipc_pid_t shm_cpid;
| __kernel_ipc_pid_t shm_lpid;
| unsigned short shm_nattch;
| unsigned short shm_unused;
| void *shm_unused2;
| void *shm_unused3;
|};
|
|
|struct shmid64_ds {
| struct ipc64_perm shm_perm;
| size_t shm_segsz;
| __kernel_time_t shm_atime;
|
|
|
| __kernel_time_t shm_dtime;
|
|
|
| __kernel_time_t shm_ctime;
|
|
|
| __kernel_pid_t shm_cpid;
| __kernel_pid_t shm_lpid;
| unsigned long shm_nattch;
| unsigned long __unused4;
| unsigned long __unused5;
|};
|
|struct shminfo64 {
| unsigned long shmmax;
| unsigned long shmmin;
| unsigned long shmmni;
| unsigned long shmseg;
| unsigned long shmall;
| unsigned long __unused1;
| unsigned long __unused2;
| unsigned long __unused3;
| unsigned long __unused4;
|};
|struct shminfo {
| int shmmax;
| int shmmin;
| int shmmni;
| int shmseg;
| int shmall;
|};
|
|struct shm_info {
| int used_ids;
| unsigned long shm_tot;
| unsigned long shm_rss;
| unsigned long shm_swp;
| unsigned long swap_attempts;
| unsigned long swap_successes;
|};
|
|
|struct shmid_kernel
|{
| struct kern_ipc_perm shm_perm;
| struct file * shm_file;
| unsigned long shm_nattch;
| unsigned long shm_segsz;
| time_t shm_atim;
| time_t shm_dtim;
| time_t shm_ctim;
| pid_t shm_cprid;
| pid_t shm_lprid;
| struct user_struct *mlock_user;
|};
|long do_shmat(int shmid, char *shmaddr, int shmflg, unsigned long *addr);
|extern int is_file_shm_hugepages(struct file *file);
|
|struct msqid_ds {
| struct ipc_perm msg_perm;
| struct msg *msg_first;
| struct msg *msg_last;
| __kernel_time_t msg_stime;
| __kernel_time_t msg_rtime;
| __kernel_time_t msg_ctime;
| unsigned long msg_lcbytes;
| unsigned long msg_lqbytes;
| unsigned short msg_cbytes;
| unsigned short msg_qnum;
| unsigned short msg_qbytes;
| __kernel_ipc_pid_t msg_lspid;
| __kernel_ipc_pid_t msg_lrpid;
|};
|
|
|struct msqid64_ds {
| struct ipc64_perm msg_perm;
| __kernel_time_t msg_stime;
|
|
|
| __kernel_time_t msg_rtime;
|
|
|
| __kernel_time_t msg_ctime;
|
|
|
| unsigned long msg_cbytes;
| unsigned long msg_qnum;
| unsigned long msg_qbytes;
| __kernel_pid_t msg_lspid;
| __kernel_pid_t msg_lrpid;
| unsigned long __unused4;
| unsigned long __unused5;
|};
|
|
|struct msgbuf {
| long mtype;
| char mtext[1];
|};
|
|
|struct msginfo {
| int msgpool;
| int msgmap;
| int msgmax;
| int msgmnb;
| int msgmni;
| int msgssz;
| int msgtql;
| unsigned short msgseg;
|};
|struct msg_msg {
| struct list_head m_list;
| long m_type;
| int m_ts;
| struct msg_msgseg* next;
| void *security;
|
|};
|
|
|struct msg_queue {
| struct kern_ipc_perm q_perm;
| time_t q_stime;
| time_t q_rtime;
| time_t q_ctime;
| unsigned long q_cbytes;
| unsigned long q_qnum;
| unsigned long q_qbytes;
| pid_t q_lspid;
| pid_t q_lrpid;
|
| struct list_head q_messages;
| struct list_head q_receivers;
| struct list_head q_senders;
|};
|
|
|extern long do_msgsnd(int msqid, long mtype, void *mtext,
|   size_t msgsz, int msgflg);
|extern long do_msgrcv(int msqid, long *pmtype, void *mtext,
|   size_t msgsz, long msgtyp, int msgflg);
|
|
|typedef union {
| __be32 a4;
| __be32 a6[4];
|} xfrm_address_t;
|
|
|
|
|
|struct xfrm_id {
| xfrm_address_t daddr;
| __be32 spi;
| __u8 proto;
|};
|
|struct xfrm_sec_ctx {
| __u8 ctx_doi;
| __u8 ctx_alg;
| __u16 ctx_len;
| __u32 ctx_sid;
| char ctx_str[0];
|};
|struct xfrm_selector {
| xfrm_address_t daddr;
| xfrm_address_t saddr;
| __be16 dport;
| __be16 dport_mask;
| __be16 sport;
| __be16 sport_mask;
| __u16 family;
| __u8 prefixlen_d;
| __u8 prefixlen_s;
| __u8 proto;
| int ifindex;
| __kernel_uid32_t user;
|};
|
|
|
|struct xfrm_lifetime_cfg {
| __u64 soft_byte_limit;
| __u64 hard_byte_limit;
| __u64 soft_packet_limit;
| __u64 hard_packet_limit;
| __u64 soft_add_expires_seconds;
| __u64 hard_add_expires_seconds;
| __u64 soft_use_expires_seconds;
| __u64 hard_use_expires_seconds;
|};
|
|struct xfrm_lifetime_cur {
| __u64 bytes;
| __u64 packets;
| __u64 add_time;
| __u64 use_time;
|};
|
|struct xfrm_replay_state {
| __u32 oseq;
| __u32 seq;
| __u32 bitmap;
|};
|
|struct xfrm_algo {
| char alg_name[64];
| unsigned int alg_key_len;
| char alg_key[0];
|};
|
|struct xfrm_algo_auth {
| char alg_name[64];
| unsigned int alg_key_len;
| unsigned int alg_trunc_len;
| char alg_key[0];
|};
|
|struct xfrm_algo_aead {
| char alg_name[64];
| unsigned int alg_key_len;
| unsigned int alg_icv_len;
| char alg_key[0];
|};
|
|struct xfrm_stats {
| __u32 replay_window;
| __u32 replay;
| __u32 integrity_failed;
|};
|
|enum {
| XFRM_POLICY_TYPE_MAIN = 0,
| XFRM_POLICY_TYPE_SUB = 1,
| XFRM_POLICY_TYPE_MAX = 2,
| XFRM_POLICY_TYPE_ANY = 255
|};
|
|enum {
| XFRM_POLICY_IN = 0,
| XFRM_POLICY_OUT = 1,
| XFRM_POLICY_FWD = 2,
| XFRM_POLICY_MASK = 3,
| XFRM_POLICY_MAX = 3
|};
|
|enum {
| XFRM_SHARE_ANY,
| XFRM_SHARE_SESSION,
| XFRM_SHARE_USER,
| XFRM_SHARE_UNIQUE
|};
|enum {
| XFRM_MSG_BASE = 0x10,
|
| XFRM_MSG_NEWSA = 0x10,
|
| XFRM_MSG_DELSA,
|
| XFRM_MSG_GETSA,
|
|
| XFRM_MSG_NEWPOLICY,
|
| XFRM_MSG_DELPOLICY,
|
| XFRM_MSG_GETPOLICY,
|
|
| XFRM_MSG_ALLOCSPI,
|
| XFRM_MSG_ACQUIRE,
|
| XFRM_MSG_EXPIRE,
|
|
| XFRM_MSG_UPDPOLICY,
|
| XFRM_MSG_UPDSA,
|
|
| XFRM_MSG_POLEXPIRE,
|
|
| XFRM_MSG_FLUSHSA,
|
| XFRM_MSG_FLUSHPOLICY,
|
|
| XFRM_MSG_NEWAE,
|
| XFRM_MSG_GETAE,
|
|
| XFRM_MSG_REPORT,
|
|
| XFRM_MSG_MIGRATE,
|
|
| XFRM_MSG_NEWSADINFO,
|
| XFRM_MSG_GETSADINFO,
|
|
| XFRM_MSG_NEWSPDINFO,
|
| XFRM_MSG_GETSPDINFO,
|
|
| XFRM_MSG_MAPPING,
|
| __XFRM_MSG_MAX
|};
|struct xfrm_user_sec_ctx {
| __u16 len;
| __u16 exttype;
| __u8 ctx_alg;
| __u8 ctx_doi;
| __u16 ctx_len;
|};
|
|struct xfrm_user_tmpl {
| struct xfrm_id id;
| __u16 family;
| xfrm_address_t saddr;
| __u32 reqid;
| __u8 mode;
| __u8 share;
| __u8 optional;
| __u32 aalgos;
| __u32 ealgos;
| __u32 calgos;
|};
|
|struct xfrm_encap_tmpl {
| __u16 encap_type;
| __be16 encap_sport;
| __be16 encap_dport;
| xfrm_address_t encap_oa;
|};
|
|
|enum xfrm_ae_ftype_t {
| XFRM_AE_UNSPEC,
| XFRM_AE_RTHR=1,
| XFRM_AE_RVAL=2,
| XFRM_AE_LVAL=4,
| XFRM_AE_ETHR=8,
| XFRM_AE_CR=16,
| XFRM_AE_CE=32,
| XFRM_AE_CU=64,
| __XFRM_AE_MAX
|
|
|};
|
|struct xfrm_userpolicy_type {
| __u8 type;
| __u16 reserved1;
| __u8 reserved2;
|};
|
|
|enum xfrm_attr_type_t {
| XFRMA_UNSPEC,
| XFRMA_ALG_AUTH,
| XFRMA_ALG_CRYPT,
| XFRMA_ALG_COMP,
| XFRMA_ENCAP,
| XFRMA_TMPL,
| XFRMA_SA,
| XFRMA_POLICY,
| XFRMA_SEC_CTX,
| XFRMA_LTIME_VAL,
| XFRMA_REPLAY_VAL,
| XFRMA_REPLAY_THRESH,
| XFRMA_ETIMER_THRESH,
| XFRMA_SRCADDR,
| XFRMA_COADDR,
| XFRMA_LASTUSED,
| XFRMA_POLICY_TYPE,
| XFRMA_MIGRATE,
| XFRMA_ALG_AEAD,
| XFRMA_KMADDRESS,
| XFRMA_ALG_AUTH_TRUNC,
| XFRMA_MARK,
| __XFRMA_MAX
|
|
|};
|
|struct xfrm_mark {
| __u32 v;
| __u32 m;
|};
|
|enum xfrm_sadattr_type_t {
| XFRMA_SAD_UNSPEC,
| XFRMA_SAD_CNT,
| XFRMA_SAD_HINFO,
| __XFRMA_SAD_MAX
|
|
|};
|
|struct xfrmu_sadhinfo {
| __u32 sadhcnt;
| __u32 sadhmcnt;
|};
|
|enum xfrm_spdattr_type_t {
| XFRMA_SPD_UNSPEC,
| XFRMA_SPD_INFO,
| XFRMA_SPD_HINFO,
| __XFRMA_SPD_MAX
|
|
|};
|
|struct xfrmu_spdinfo {
| __u32 incnt;
| __u32 outcnt;
| __u32 fwdcnt;
| __u32 inscnt;
| __u32 outscnt;
| __u32 fwdscnt;
|};
|
|struct xfrmu_spdhinfo {
| __u32 spdhcnt;
| __u32 spdhmcnt;
|};
|
|struct xfrm_usersa_info {
| struct xfrm_selector sel;
| struct xfrm_id id;
| xfrm_address_t saddr;
| struct xfrm_lifetime_cfg lft;
| struct xfrm_lifetime_cur curlft;
| struct xfrm_stats stats;
| __u32 seq;
| __u32 reqid;
| __u16 family;
| __u8 mode;
| __u8 replay_window;
| __u8 flags;
|
|
|
|
|
|
|};
|
|struct xfrm_usersa_id {
| xfrm_address_t daddr;
| __be32 spi;
| __u16 family;
| __u8 proto;
|};
|
|struct xfrm_aevent_id {
| struct xfrm_usersa_id sa_id;
| xfrm_address_t saddr;
| __u32 flags;
| __u32 reqid;
|};
|
|struct xfrm_userspi_info {
| struct xfrm_usersa_info info;
| __u32 min;
| __u32 max;
|};
|
|struct xfrm_userpolicy_info {
| struct xfrm_selector sel;
| struct xfrm_lifetime_cfg lft;
| struct xfrm_lifetime_cur curlft;
| __u32 priority;
| __u32 index;
| __u8 dir;
| __u8 action;
|
|
| __u8 flags;
|
|
|
| __u8 share;
|};
|
|struct xfrm_userpolicy_id {
| struct xfrm_selector sel;
| __u32 index;
| __u8 dir;
|};
|
|struct xfrm_user_acquire {
| struct xfrm_id id;
| xfrm_address_t saddr;
| struct xfrm_selector sel;
| struct xfrm_userpolicy_info policy;
| __u32 aalgos;
| __u32 ealgos;
| __u32 calgos;
| __u32 seq;
|};
|
|struct xfrm_user_expire {
| struct xfrm_usersa_info state;
| __u8 hard;
|};
|
|struct xfrm_user_polexpire {
| struct xfrm_userpolicy_info pol;
| __u8 hard;
|};
|
|struct xfrm_usersa_flush {
| __u8 proto;
|};
|
|struct xfrm_user_report {
| __u8 proto;
| struct xfrm_selector sel;
|};
|
|
|
|struct xfrm_user_kmaddress {
| xfrm_address_t local;
| xfrm_address_t remote;
| __u32 reserved;
| __u16 family;
|};
|
|struct xfrm_user_migrate {
| xfrm_address_t old_daddr;
| xfrm_address_t old_saddr;
| xfrm_address_t new_daddr;
| xfrm_address_t new_saddr;
| __u8 proto;
| __u8 mode;
| __u16 reserved;
| __u32 reqid;
| __u16 old_family;
| __u16 new_family;
|};
|
|struct xfrm_user_mapping {
| struct xfrm_usersa_id id;
| __u32 reqid;
| xfrm_address_t old_saddr;
| xfrm_address_t new_saddr;
| __be16 old_sport;
| __be16 new_sport;
|};
|enum xfrm_nlgroups {
| XFRMNLGRP_NONE,
|
| XFRMNLGRP_ACQUIRE,
|
| XFRMNLGRP_EXPIRE,
|
| XFRMNLGRP_SA,
|
| XFRMNLGRP_POLICY,
|
| XFRMNLGRP_AEVENTS,
|
| XFRMNLGRP_REPORT,
|
| XFRMNLGRP_MIGRATE,
|
| XFRMNLGRP_MAPPING,
|
| __XFRMNLGRP_MAX
|};
|
|struct in6_addr {
| union {
|  __u8 u6_addr8[16];
|  __be16 u6_addr16[8];
|  __be32 u6_addr32[4];
| } in6_u;
|
|
|
|};
|
|
|
|
|
|
|extern const struct in6_addr in6addr_any;
|
|extern const struct in6_addr in6addr_loopback;
|
|extern const struct in6_addr in6addr_linklocal_allnodes;
|
|
|extern const struct in6_addr in6addr_linklocal_allrouters;
|
|
|
|
|struct sockaddr_in6 {
| unsigned short int sin6_family;
| __be16 sin6_port;
| __be32 sin6_flowinfo;
| struct in6_addr sin6_addr;
| __u32 sin6_scope_id;
|};
|
|struct ipv6_mreq {
|
| struct in6_addr ipv6mr_multiaddr;
|
|
| int ipv6mr_ifindex;
|};
|
|
|
|struct in6_flowlabel_req {
| struct in6_addr flr_dst;
| __be32 flr_label;
| __u8 flr_action;
| __u8 flr_share;
| __u16 flr_flags;
| __u16 flr_expires;
| __u16 flr_linger;
| __u32 __flr_pad;
|
|};
|
|
|struct flowi {
| int oif;
| int iif;
| __u32 mark;
|
| union {
|  struct {
|   __be32 daddr;
|   __be32 saddr;
|   __u8 tos;
|   __u8 scope;
|  } ip4_u;
|
|  struct {
|   struct in6_addr daddr;
|   struct in6_addr saddr;
|   __be32 flowlabel;
|  } ip6_u;
|
|  struct {
|   __le16 daddr;
|   __le16 saddr;
|   __u8 scope;
|  } dn_u;
| } nl_u;
| __u8 proto;
| __u8 flags;
|
|
| union {
|  struct {
|   __be16 sport;
|   __be16 dport;
|  } ports;
|
|  struct {
|   __u8 type;
|   __u8 code;
|  } icmpt;
|
|  struct {
|   __le16 sport;
|   __le16 dport;
|  } dnports;
|
|  __be32 spi;
|  __be32 gre_key;
|
|  struct {
|   __u8 type;
|  } mht;
| } uli_u;
|
|
|
|
|
|
|
| __u32 secid;
|} ;
|
|
|
|
|
|struct net;
|struct sock;
|struct flow_cache_ops;
|
|struct flow_cache_object {
| const struct flow_cache_ops *ops;
|};
|
|struct flow_cache_ops {
| struct flow_cache_object *(*get)(struct flow_cache_object *);
| int (*check)(struct flow_cache_object *);
| void (*delete)(struct flow_cache_object *);
|};
|
|typedef struct flow_cache_object *(*flow_resolve_t)(
|  struct net *net, struct flowi *key, u16 family,
|  u8 dir, struct flow_cache_object *oldobj, void *ctx);
|
|extern struct flow_cache_object *flow_cache_lookup(
|  struct net *net, struct flowi *key, u16 family,
|  u8 dir, flow_resolve_t resolver, void *ctx);
|
|extern void flow_cache_flush(void);
|extern atomic_t flow_cache_genid;
|
|static inline int flow_cache_uli_match(struct flowi *fl1, struct flowi *fl2)
|{
| return (fl1->proto == fl2->proto &&
|  !memcmp(&fl1->uli_u, &fl2->uli_u, sizeof(fl1->uli_u)));
|}
|struct ctl_table;
|struct audit_krule;
|
|
|
|
|
|extern int cap_capable(struct task_struct *tsk, const struct cred *cred,
|         int cap, int audit);
|extern int cap_settime(struct timespec *ts, struct timezone *tz);
|extern int cap_ptrace_access_check(struct task_struct *child, unsigned int mode);
|extern int cap_ptrace_traceme(struct task_struct *parent);
|extern int cap_capget(struct task_struct *target, kernel_cap_t *effective, kernel_cap_t *inheritable, kernel_cap_t *permitted);
|extern int cap_capset(struct cred *new, const struct cred *old,
|        const kernel_cap_t *effective,
|        const kernel_cap_t *inheritable,
|        const kernel_cap_t *permitted);
|extern int cap_bprm_set_creds(struct linux_binprm *bprm);
|extern int cap_bprm_secureexec(struct linux_binprm *bprm);
|extern int cap_inode_setxattr(struct dentry *dentry, const char *name,
|         const void *value, size_t size, int flags);
|extern int cap_inode_removexattr(struct dentry *dentry, const char *name);
|extern int cap_inode_need_killpriv(struct dentry *dentry);
|extern int cap_inode_killpriv(struct dentry *dentry);
|extern int cap_file_mmap(struct file *file, unsigned long reqprot,
|    unsigned long prot, unsigned long flags,
|    unsigned long addr, unsigned long addr_only);
|extern int cap_task_fix_setuid(struct cred *new, const struct cred *old, int flags);
|extern int cap_task_prctl(int option, unsigned long arg2, unsigned long arg3,
|     unsigned long arg4, unsigned long arg5);
|extern int cap_task_setscheduler(struct task_struct *p);
|extern int cap_task_setioprio(struct task_struct *p, int ioprio);
|extern int cap_task_setnice(struct task_struct *p, int nice);
|extern int cap_vm_enough_memory(struct mm_struct *mm, long pages);
|
|struct msghdr;
|struct sk_buff;
|struct sock;
|struct sockaddr;
|struct socket;
|struct flowi;
|struct dst_entry;
|struct xfrm_selector;
|struct xfrm_policy;
|struct xfrm_state;
|struct xfrm_user_sec_ctx;
|struct seq_file;
|
|extern int cap_netlink_send(struct sock *sk, struct sk_buff *skb);
|extern int cap_netlink_recv(struct sk_buff *skb, int cap);
|
|void reset_security_ops(void);
|
|
|extern unsigned long mmap_min_addr;
|extern unsigned long dac_mmap_min_addr;
|struct sched_param;
|struct request_sock;
|static inline unsigned long round_hint_to_min(unsigned long hint)
|{
| hint &= (~(((1UL) << 12)-1));
| if (((void *)hint != ((void *)0)) &&
|     (hint < mmap_min_addr))
|  return ((((mmap_min_addr)) + ((typeof((mmap_min_addr)))((((1UL) << 12))) - 1)) & ~((typeof((mmap_min_addr)))((((1UL) << 12))) - 1));
| return hint;
|}
|extern int mmap_min_addr_handler(struct ctl_table *table, int write,
|     void *buffer, size_t *lenp, loff_t *ppos);
|
|
|
|
|struct security_mnt_opts {
| char **mnt_opts;
| int *mnt_opts_flags;
| int num_mnt_opts;
|};
|
|static inline void security_init_mnt_opts(struct security_mnt_opts *opts)
|{
| opts->mnt_opts = ((void *)0);
| opts->mnt_opts_flags = ((void *)0);
| opts->num_mnt_opts = 0;
|}
|
|static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
|{
| int i;
| if (opts->mnt_opts)
|  for (i = 0; i < opts->num_mnt_opts; i++)
|   kfree(opts->mnt_opts[i]);
| kfree(opts->mnt_opts);
| opts->mnt_opts = ((void *)0);
| kfree(opts->mnt_opts_flags);
| opts->mnt_opts_flags = ((void *)0);
| opts->num_mnt_opts = 0;
|}
|struct security_operations {
| char name[10 + 1];
|
| int (*ptrace_access_check) (struct task_struct *child, unsigned int mode);
| int (*ptrace_traceme) (struct task_struct *parent);
| int (*capget) (struct task_struct *target,
|         kernel_cap_t *effective,
|         kernel_cap_t *inheritable, kernel_cap_t *permitted);
| int (*capset) (struct cred *new,
|         const struct cred *old,
|         const kernel_cap_t *effective,
|         const kernel_cap_t *inheritable,
|         const kernel_cap_t *permitted);
| int (*capable) (struct task_struct *tsk, const struct cred *cred,
|   int cap, int audit);
| int (*sysctl) (struct ctl_table *table, int op);
| int (*quotactl) (int cmds, int type, int id, struct super_block *sb);
| int (*quota_on) (struct dentry *dentry);
| int (*syslog) (int type);
| int (*settime) (struct timespec *ts, struct timezone *tz);
| int (*vm_enough_memory) (struct mm_struct *mm, long pages);
|
| int (*bprm_set_creds) (struct linux_binprm *bprm);
| int (*bprm_check_security) (struct linux_binprm *bprm);
| int (*bprm_secureexec) (struct linux_binprm *bprm);
| void (*bprm_committing_creds) (struct linux_binprm *bprm);
| void (*bprm_committed_creds) (struct linux_binprm *bprm);
|
| int (*sb_alloc_security) (struct super_block *sb);
| void (*sb_free_security) (struct super_block *sb);
| int (*sb_copy_data) (char *orig, char *copy);
| int (*sb_kern_mount) (struct super_block *sb, int flags, void *data);
| int (*sb_show_options) (struct seq_file *m, struct super_block *sb);
| int (*sb_statfs) (struct dentry *dentry);
| int (*sb_mount) (char *dev_name, struct path *path,
|    char *type, unsigned long flags, void *data);
| int (*sb_umount) (struct vfsmount *mnt, int flags);
| int (*sb_pivotroot) (struct path *old_path,
|        struct path *new_path);
| int (*sb_set_mnt_opts) (struct super_block *sb,
|    struct security_mnt_opts *opts);
| void (*sb_clone_mnt_opts) (const struct super_block *oldsb,
|       struct super_block *newsb);
| int (*sb_parse_opts_str) (char *options, struct security_mnt_opts *opts);
|
|
| int (*path_unlink) (struct path *dir, struct dentry *dentry);
| int (*path_mkdir) (struct path *dir, struct dentry *dentry, int mode);
| int (*path_rmdir) (struct path *dir, struct dentry *dentry);
| int (*path_mknod) (struct path *dir, struct dentry *dentry, int mode,
|      unsigned int dev);
| int (*path_truncate) (struct path *path);
| int (*path_symlink) (struct path *dir, struct dentry *dentry,
|        const char *old_name);
| int (*path_link) (struct dentry *old_dentry, struct path *new_dir,
|     struct dentry *new_dentry);
| int (*path_rename) (struct path *old_dir, struct dentry *old_dentry,
|       struct path *new_dir, struct dentry *new_dentry);
| int (*path_chmod) (struct dentry *dentry, struct vfsmount *mnt,
|      mode_t mode);
| int (*path_chown) (struct path *path, uid_t uid, gid_t gid);
| int (*path_chroot) (struct path *path);
|
|
| int (*inode_alloc_security) (struct inode *inode);
| void (*inode_free_security) (struct inode *inode);
| int (*inode_init_security) (struct inode *inode, struct inode *dir,
|        char **name, void **value, size_t *len);
| int (*inode_create) (struct inode *dir,
|        struct dentry *dentry, int mode);
| int (*inode_link) (struct dentry *old_dentry,
|      struct inode *dir, struct dentry *new_dentry);
| int (*inode_unlink) (struct inode *dir, struct dentry *dentry);
| int (*inode_symlink) (struct inode *dir,
|         struct dentry *dentry, const char *old_name);
| int (*inode_mkdir) (struct inode *dir, struct dentry *dentry, int mode);
| int (*inode_rmdir) (struct inode *dir, struct dentry *dentry);
| int (*inode_mknod) (struct inode *dir, struct dentry *dentry,
|       int mode, dev_t dev);
| int (*inode_rename) (struct inode *old_dir, struct dentry *old_dentry,
|        struct inode *new_dir, struct dentry *new_dentry);
| int (*inode_readlink) (struct dentry *dentry);
| int (*inode_follow_link) (struct dentry *dentry, struct nameidata *nd);
| int (*inode_permission) (struct inode *inode, int mask);
| int (*inode_setattr) (struct dentry *dentry, struct iattr *attr);
| int (*inode_getattr) (struct vfsmount *mnt, struct dentry *dentry);
| int (*inode_setxattr) (struct dentry *dentry, const char *name,
|          const void *value, size_t size, int flags);
| void (*inode_post_setxattr) (struct dentry *dentry, const char *name,
|         const void *value, size_t size, int flags);
| int (*inode_getxattr) (struct dentry *dentry, const char *name);
| int (*inode_listxattr) (struct dentry *dentry);
| int (*inode_removexattr) (struct dentry *dentry, const char *name);
| int (*inode_need_killpriv) (struct dentry *dentry);
| int (*inode_killpriv) (struct dentry *dentry);
| int (*inode_getsecurity) (const struct inode *inode, const char *name, void **buffer, bool alloc);
| int (*inode_setsecurity) (struct inode *inode, const char *name, const void *value, size_t size, int flags);
| int (*inode_listsecurity) (struct inode *inode, char *buffer, size_t buffer_size);
| void (*inode_getsecid) (const struct inode *inode, u32 *secid);
|
| int (*file_permission) (struct file *file, int mask);
| int (*file_alloc_security) (struct file *file);
| void (*file_free_security) (struct file *file);
| int (*file_ioctl) (struct file *file, unsigned int cmd,
|      unsigned long arg);
| int (*file_mmap) (struct file *file,
|     unsigned long reqprot, unsigned long prot,
|     unsigned long flags, unsigned long addr,
|     unsigned long addr_only);
| int (*file_mprotect) (struct vm_area_struct *vma,
|         unsigned long reqprot,
|         unsigned long prot);
| int (*file_lock) (struct file *file, unsigned int cmd);
| int (*file_fcntl) (struct file *file, unsigned int cmd,
|      unsigned long arg);
| int (*file_set_fowner) (struct file *file);
| int (*file_send_sigiotask) (struct task_struct *tsk,
|        struct fown_struct *fown, int sig);
| int (*file_receive) (struct file *file);
| int (*dentry_open) (struct file *file, const struct cred *cred);
|
| int (*task_create) (unsigned long clone_flags);
| int (*cred_alloc_blank) (struct cred *cred, gfp_t gfp);
| void (*cred_free) (struct cred *cred);
| int (*cred_prepare)(struct cred *new, const struct cred *old,
|       gfp_t gfp);
| void (*cred_transfer)(struct cred *new, const struct cred *old);
| int (*kernel_act_as)(struct cred *new, u32 secid);
| int (*kernel_create_files_as)(struct cred *new, struct inode *inode);
| int (*kernel_module_request)(char *kmod_name);
| int (*task_fix_setuid) (struct cred *new, const struct cred *old,
|    int flags);
| int (*task_setpgid) (struct task_struct *p, pid_t pgid);
| int (*task_getpgid) (struct task_struct *p);
| int (*task_getsid) (struct task_struct *p);
| void (*task_getsecid) (struct task_struct *p, u32 *secid);
| int (*task_setnice) (struct task_struct *p, int nice);
| int (*task_setioprio) (struct task_struct *p, int ioprio);
| int (*task_getioprio) (struct task_struct *p);
| int (*task_setrlimit) (struct task_struct *p, unsigned int resource,
|   struct rlimit *new_rlim);
| int (*task_setscheduler) (struct task_struct *p);
| int (*task_getscheduler) (struct task_struct *p);
| int (*task_movememory) (struct task_struct *p);
| int (*task_kill) (struct task_struct *p,
|     struct siginfo *info, int sig, u32 secid);
| int (*task_wait) (struct task_struct *p);
| int (*task_prctl) (int option, unsigned long arg2,
|      unsigned long arg3, unsigned long arg4,
|      unsigned long arg5);
| void (*task_to_inode) (struct task_struct *p, struct inode *inode);
|
| int (*ipc_permission) (struct kern_ipc_perm *ipcp, short flag);
| void (*ipc_getsecid) (struct kern_ipc_perm *ipcp, u32 *secid);
|
| int (*msg_msg_alloc_security) (struct msg_msg *msg);
| void (*msg_msg_free_security) (struct msg_msg *msg);
|
| int (*msg_queue_alloc_security) (struct msg_queue *msq);
| void (*msg_queue_free_security) (struct msg_queue *msq);
| int (*msg_queue_associate) (struct msg_queue *msq, int msqflg);
| int (*msg_queue_msgctl) (struct msg_queue *msq, int cmd);
| int (*msg_queue_msgsnd) (struct msg_queue *msq,
|     struct msg_msg *msg, int msqflg);
| int (*msg_queue_msgrcv) (struct msg_queue *msq,
|     struct msg_msg *msg,
|     struct task_struct *target,
|     long type, int mode);
|
| int (*shm_alloc_security) (struct shmid_kernel *shp);
| void (*shm_free_security) (struct shmid_kernel *shp);
| int (*shm_associate) (struct shmid_kernel *shp, int shmflg);
| int (*shm_shmctl) (struct shmid_kernel *shp, int cmd);
| int (*shm_shmat) (struct shmid_kernel *shp,
|     char *shmaddr, int shmflg);
|
| int (*sem_alloc_security) (struct sem_array *sma);
| void (*sem_free_security) (struct sem_array *sma);
| int (*sem_associate) (struct sem_array *sma, int semflg);
| int (*sem_semctl) (struct sem_array *sma, int cmd);
| int (*sem_semop) (struct sem_array *sma,
|     struct sembuf *sops, unsigned nsops, int alter);
|
| int (*netlink_send) (struct sock *sk, struct sk_buff *skb);
| int (*netlink_recv) (struct sk_buff *skb, int cap);
|
| void (*d_instantiate) (struct dentry *dentry, struct inode *inode);
|
| int (*getprocattr) (struct task_struct *p, char *name, char **value);
| int (*setprocattr) (struct task_struct *p, char *name, void *value, size_t size);
| int (*secid_to_secctx) (u32 secid, char **secdata, u32 *seclen);
| int (*secctx_to_secid) (const char *secdata, u32 seclen, u32 *secid);
| void (*release_secctx) (char *secdata, u32 seclen);
|
| int (*inode_notifysecctx)(struct inode *inode, void *ctx, u32 ctxlen);
| int (*inode_setsecctx)(struct dentry *dentry, void *ctx, u32 ctxlen);
| int (*inode_getsecctx)(struct inode *inode, void **ctx, u32 *ctxlen);
|
|
| int (*unix_stream_connect) (struct socket *sock,
|        struct socket *other, struct sock *newsk);
| int (*unix_may_send) (struct socket *sock, struct socket *other);
|
| int (*socket_create) (int family, int type, int protocol, int kern);
| int (*socket_post_create) (struct socket *sock, int family,
|       int type, int protocol, int kern);
| int (*socket_bind) (struct socket *sock,
|       struct sockaddr *address, int addrlen);
| int (*socket_connect) (struct socket *sock,
|          struct sockaddr *address, int addrlen);
| int (*socket_listen) (struct socket *sock, int backlog);
| int (*socket_accept) (struct socket *sock, struct socket *newsock);
| int (*socket_sendmsg) (struct socket *sock,
|          struct msghdr *msg, int size);
| int (*socket_recvmsg) (struct socket *sock,
|          struct msghdr *msg, int size, int flags);
| int (*socket_getsockname) (struct socket *sock);
| int (*socket_getpeername) (struct socket *sock);
| int (*socket_getsockopt) (struct socket *sock, int level, int optname);
| int (*socket_setsockopt) (struct socket *sock, int level, int optname);
| int (*socket_shutdown) (struct socket *sock, int how);
| int (*socket_sock_rcv_skb) (struct sock *sk, struct sk_buff *skb);
| int (*socket_getpeersec_stream) (struct socket *sock, char *optval, int *optlen, unsigned len);
| int (*socket_getpeersec_dgram) (struct socket *sock, struct sk_buff *skb, u32 *secid);
| int (*sk_alloc_security) (struct sock *sk, int family, gfp_t priority);
| void (*sk_free_security) (struct sock *sk);
| void (*sk_clone_security) (const struct sock *sk, struct sock *newsk);
| void (*sk_getsecid) (struct sock *sk, u32 *secid);
| void (*sock_graft) (struct sock *sk, struct socket *parent);
| int (*inet_conn_request) (struct sock *sk, struct sk_buff *skb,
|      struct request_sock *req);
| void (*inet_csk_clone) (struct sock *newsk, const struct request_sock *req);
| void (*inet_conn_established) (struct sock *sk, struct sk_buff *skb);
| int (*secmark_relabel_packet) (u32 secid);
| void (*secmark_refcount_inc) (void);
| void (*secmark_refcount_dec) (void);
| void (*req_classify_flow) (const struct request_sock *req, struct flowi *fl);
| int (*tun_dev_create)(void);
| void (*tun_dev_post_create)(struct sock *sk);
| int (*tun_dev_attach)(struct sock *sk);
|
|
|
| int (*xfrm_policy_alloc_security) (struct xfrm_sec_ctx **ctxp,
|   struct xfrm_user_sec_ctx *sec_ctx);
| int (*xfrm_policy_clone_security) (struct xfrm_sec_ctx *old_ctx, struct xfrm_sec_ctx **new_ctx);
| void (*xfrm_policy_free_security) (struct xfrm_sec_ctx *ctx);
| int (*xfrm_policy_delete_security) (struct xfrm_sec_ctx *ctx);
| int (*xfrm_state_alloc_security) (struct xfrm_state *x,
|  struct xfrm_user_sec_ctx *sec_ctx,
|  u32 secid);
| void (*xfrm_state_free_security) (struct xfrm_state *x);
| int (*xfrm_state_delete_security) (struct xfrm_state *x);
| int (*xfrm_policy_lookup) (struct xfrm_sec_ctx *ctx, u32 fl_secid, u8 dir);
| int (*xfrm_state_pol_flow_match) (struct xfrm_state *x,
|       struct xfrm_policy *xp,
|       struct flowi *fl);
| int (*xfrm_decode_session) (struct sk_buff *skb, u32 *secid, int ckall);
|
|
|
|
| int (*key_alloc) (struct key *key, const struct cred *cred, unsigned long flags);
| void (*key_free) (struct key *key);
| int (*key_permission) (key_ref_t key_ref,
|          const struct cred *cred,
|          key_perm_t perm);
| int (*key_getsecurity)(struct key *key, char **_buffer);
|
|
|
| int (*audit_rule_init) (u32 field, u32 op, char *rulestr, void **lsmrule);
| int (*audit_rule_known) (struct audit_krule *krule);
| int (*audit_rule_match) (u32 secid, u32 field, u32 op, void *lsmrule,
|     struct audit_context *actx);
| void (*audit_rule_free) (void *lsmrule);
|
|};
|
|
|extern int security_init(void);
|extern int security_module_enable(struct security_operations *ops);
|extern int register_security(struct security_operations *ops);
|
|
|int security_ptrace_access_check(struct task_struct *child, unsigned int mode);
|int security_ptrace_traceme(struct task_struct *parent);
|int security_capget(struct task_struct *target,
|      kernel_cap_t *effective,
|      kernel_cap_t *inheritable,
|      kernel_cap_t *permitted);
|int security_capset(struct cred *new, const struct cred *old,
|      const kernel_cap_t *effective,
|      const kernel_cap_t *inheritable,
|      const kernel_cap_t *permitted);
|int security_capable(int cap);
|int security_real_capable(struct task_struct *tsk, int cap);
|int security_real_capable_noaudit(struct task_struct *tsk, int cap);
|int security_sysctl(struct ctl_table *table, int op);
|int security_quotactl(int cmds, int type, int id, struct super_block *sb);
|int security_quota_on(struct dentry *dentry);
|int security_syslog(int type);
|int security_settime(struct timespec *ts, struct timezone *tz);
|int security_vm_enough_memory(long pages);
|int security_vm_enough_memory_mm(struct mm_struct *mm, long pages);
|int security_vm_enough_memory_kern(long pages);
|int security_bprm_set_creds(struct linux_binprm *bprm);
|int security_bprm_check(struct linux_binprm *bprm);
|void security_bprm_committing_creds(struct linux_binprm *bprm);
|void security_bprm_committed_creds(struct linux_binprm *bprm);
|int security_bprm_secureexec(struct linux_binprm *bprm);
|int security_sb_alloc(struct super_block *sb);
|void security_sb_free(struct super_block *sb);
|int security_sb_copy_data(char *orig, char *copy);
|int security_sb_kern_mount(struct super_block *sb, int flags, void *data);
|int security_sb_show_options(struct seq_file *m, struct super_block *sb);
|int security_sb_statfs(struct dentry *dentry);
|int security_sb_mount(char *dev_name, struct path *path,
|        char *type, unsigned long flags, void *data);
|int security_sb_umount(struct vfsmount *mnt, int flags);
|int security_sb_pivotroot(struct path *old_path, struct path *new_path);
|int security_sb_set_mnt_opts(struct super_block *sb, struct security_mnt_opts *opts);
|void security_sb_clone_mnt_opts(const struct super_block *oldsb,
|    struct super_block *newsb);
|int security_sb_parse_opts_str(char *options, struct security_mnt_opts *opts);
|
|int security_inode_alloc(struct inode *inode);
|void security_inode_free(struct inode *inode);
|int security_inode_init_security(struct inode *inode, struct inode *dir,
|      char **name, void **value, size_t *len);
|int security_inode_create(struct inode *dir, struct dentry *dentry, int mode);
|int security_inode_link(struct dentry *old_dentry, struct inode *dir,
|    struct dentry *new_dentry);
|int security_inode_unlink(struct inode *dir, struct dentry *dentry);
|int security_inode_symlink(struct inode *dir, struct dentry *dentry,
|      const char *old_name);
|int security_inode_mkdir(struct inode *dir, struct dentry *dentry, int mode);
|int security_inode_rmdir(struct inode *dir, struct dentry *dentry);
|int security_inode_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev);
|int security_inode_rename(struct inode *old_dir, struct dentry *old_dentry,
|     struct inode *new_dir, struct dentry *new_dentry);
|int security_inode_readlink(struct dentry *dentry);
|int security_inode_follow_link(struct dentry *dentry, struct nameidata *nd);
|int security_inode_permission(struct inode *inode, int mask);
|int security_inode_setattr(struct dentry *dentry, struct iattr *attr);
|int security_inode_getattr(struct vfsmount *mnt, struct dentry *dentry);
|int security_inode_setxattr(struct dentry *dentry, const char *name,
|       const void *value, size_t size, int flags);
|void security_inode_post_setxattr(struct dentry *dentry, const char *name,
|      const void *value, size_t size, int flags);
|int security_inode_getxattr(struct dentry *dentry, const char *name);
|int security_inode_listxattr(struct dentry *dentry);
|int security_inode_removexattr(struct dentry *dentry, const char *name);
|int security_inode_need_killpriv(struct dentry *dentry);
|int security_inode_killpriv(struct dentry *dentry);
|int security_inode_getsecurity(const struct inode *inode, const char *name, void **buffer, bool alloc);
|int security_inode_setsecurity(struct inode *inode, const char *name, const void *value, size_t size, int flags);
|int security_inode_listsecurity(struct inode *inode, char *buffer, size_t buffer_size);
|void security_inode_getsecid(const struct inode *inode, u32 *secid);
|int security_file_permission(struct file *file, int mask);
|int security_file_alloc(struct file *file);
|void security_file_free(struct file *file);
|int security_file_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
|int security_file_mmap(struct file *file, unsigned long reqprot,
|   unsigned long prot, unsigned long flags,
|   unsigned long addr, unsigned long addr_only);
|int security_file_mprotect(struct vm_area_struct *vma, unsigned long reqprot,
|      unsigned long prot);
|int security_file_lock(struct file *file, unsigned int cmd);
|int security_file_fcntl(struct file *file, unsigned int cmd, unsigned long arg);
|int security_file_set_fowner(struct file *file);
|int security_file_send_sigiotask(struct task_struct *tsk,
|     struct fown_struct *fown, int sig);
|int security_file_receive(struct file *file);
|int security_dentry_open(struct file *file, const struct cred *cred);
|int security_task_create(unsigned long clone_flags);
|int security_cred_alloc_blank(struct cred *cred, gfp_t gfp);
|void security_cred_free(struct cred *cred);
|int security_prepare_creds(struct cred *new, const struct cred *old, gfp_t gfp);
|void security_transfer_creds(struct cred *new, const struct cred *old);
|int security_kernel_act_as(struct cred *new, u32 secid);
|int security_kernel_create_files_as(struct cred *new, struct inode *inode);
|int security_kernel_module_request(char *kmod_name);
|int security_task_fix_setuid(struct cred *new, const struct cred *old,
|        int flags);
|int security_task_setpgid(struct task_struct *p, pid_t pgid);
|int security_task_getpgid(struct task_struct *p);
|int security_task_getsid(struct task_struct *p);
|void security_task_getsecid(struct task_struct *p, u32 *secid);
|int security_task_setnice(struct task_struct *p, int nice);
|int security_task_setioprio(struct task_struct *p, int ioprio);
|int security_task_getioprio(struct task_struct *p);
|int security_task_setrlimit(struct task_struct *p, unsigned int resource,
|  struct rlimit *new_rlim);
|int security_task_setscheduler(struct task_struct *p);
|int security_task_getscheduler(struct task_struct *p);
|int security_task_movememory(struct task_struct *p);
|int security_task_kill(struct task_struct *p, struct siginfo *info,
|   int sig, u32 secid);
|int security_task_wait(struct task_struct *p);
|int security_task_prctl(int option, unsigned long arg2, unsigned long arg3,
|   unsigned long arg4, unsigned long arg5);
|void security_task_to_inode(struct task_struct *p, struct inode *inode);
|int security_ipc_permission(struct kern_ipc_perm *ipcp, short flag);
|void security_ipc_getsecid(struct kern_ipc_perm *ipcp, u32 *secid);
|int security_msg_msg_alloc(struct msg_msg *msg);
|void security_msg_msg_free(struct msg_msg *msg);
|int security_msg_queue_alloc(struct msg_queue *msq);
|void security_msg_queue_free(struct msg_queue *msq);
|int security_msg_queue_associate(struct msg_queue *msq, int msqflg);
|int security_msg_queue_msgctl(struct msg_queue *msq, int cmd);
|int security_msg_queue_msgsnd(struct msg_queue *msq,
|         struct msg_msg *msg, int msqflg);
|int security_msg_queue_msgrcv(struct msg_queue *msq, struct msg_msg *msg,
|         struct task_struct *target, long type, int mode);
|int security_shm_alloc(struct shmid_kernel *shp);
|void security_shm_free(struct shmid_kernel *shp);
|int security_shm_associate(struct shmid_kernel *shp, int shmflg);
|int security_shm_shmctl(struct shmid_kernel *shp, int cmd);
|int security_shm_shmat(struct shmid_kernel *shp, char *shmaddr, int shmflg);
|int security_sem_alloc(struct sem_array *sma);
|void security_sem_free(struct sem_array *sma);
|int security_sem_associate(struct sem_array *sma, int semflg);
|int security_sem_semctl(struct sem_array *sma, int cmd);
|int security_sem_semop(struct sem_array *sma, struct sembuf *sops,
|   unsigned nsops, int alter);
|void security_d_instantiate(struct dentry *dentry, struct inode *inode);
|int security_getprocattr(struct task_struct *p, char *name, char **value);
|int security_setprocattr(struct task_struct *p, char *name, void *value, size_t size);
|int security_netlink_send(struct sock *sk, struct sk_buff *skb);
|int security_netlink_recv(struct sk_buff *skb, int cap);
|int security_secid_to_secctx(u32 secid, char **secdata, u32 *seclen);
|int security_secctx_to_secid(const char *secdata, u32 seclen, u32 *secid);
|void security_release_secctx(char *secdata, u32 seclen);
|
|int security_inode_notifysecctx(struct inode *inode, void *ctx, u32 ctxlen);
|int security_inode_setsecctx(struct dentry *dentry, void *ctx, u32 ctxlen);
|int security_inode_getsecctx(struct inode *inode, void **ctx, u32 *ctxlen);
|int security_unix_stream_connect(struct socket *sock, struct socket *other,
|     struct sock *newsk);
|int security_unix_may_send(struct socket *sock, struct socket *other);
|int security_socket_create(int family, int type, int protocol, int kern);
|int security_socket_post_create(struct socket *sock, int family,
|    int type, int protocol, int kern);
|int security_socket_bind(struct socket *sock, struct sockaddr *address, int addrlen);
|int security_socket_connect(struct socket *sock, struct sockaddr *address, int addrlen);
|int security_socket_listen(struct socket *sock, int backlog);
|int security_socket_accept(struct socket *sock, struct socket *newsock);
|int security_socket_sendmsg(struct socket *sock, struct msghdr *msg, int size);
|int security_socket_recvmsg(struct socket *sock, struct msghdr *msg,
|       int size, int flags);
|int security_socket_getsockname(struct socket *sock);
|int security_socket_getpeername(struct socket *sock);
|int security_socket_getsockopt(struct socket *sock, int level, int optname);
|int security_socket_setsockopt(struct socket *sock, int level, int optname);
|int security_socket_shutdown(struct socket *sock, int how);
|int security_sock_rcv_skb(struct sock *sk, struct sk_buff *skb);
|int security_socket_getpeersec_stream(struct socket *sock, char *optval,
|          int *optlen, unsigned len);
|int security_socket_getpeersec_dgram(struct socket *sock, struct sk_buff *skb, u32 *secid);
|int security_sk_alloc(struct sock *sk, int family, gfp_t priority);
|void security_sk_free(struct sock *sk);
|void security_sk_clone(const struct sock *sk, struct sock *newsk);
|void security_sk_classify_flow(struct sock *sk, struct flowi *fl);
|void security_req_classify_flow(const struct request_sock *req, struct flowi *fl);
|void security_sock_graft(struct sock*sk, struct socket *parent);
|int security_inet_conn_request(struct sock *sk,
|   struct sk_buff *skb, struct request_sock *req);
|void security_inet_csk_clone(struct sock *newsk,
|   const struct request_sock *req);
|void security_inet_conn_established(struct sock *sk,
|   struct sk_buff *skb);
|int security_secmark_relabel_packet(u32 secid);
|void security_secmark_refcount_inc(void);
|void security_secmark_refcount_dec(void);
|int security_tun_dev_create(void);
|void security_tun_dev_post_create(struct sock *sk);
|int security_tun_dev_attach(struct sock *sk);
|int security_xfrm_policy_alloc(struct xfrm_sec_ctx **ctxp, struct xfrm_user_sec_ctx *sec_ctx);
|int security_xfrm_policy_clone(struct xfrm_sec_ctx *old_ctx, struct xfrm_sec_ctx **new_ctxp);
|void security_xfrm_policy_free(struct xfrm_sec_ctx *ctx);
|int security_xfrm_policy_delete(struct xfrm_sec_ctx *ctx);
|int security_xfrm_state_alloc(struct xfrm_state *x, struct xfrm_user_sec_ctx *sec_ctx);
|int security_xfrm_state_alloc_acquire(struct xfrm_state *x,
|          struct xfrm_sec_ctx *polsec, u32 secid);
|int security_xfrm_state_delete(struct xfrm_state *x);
|void security_xfrm_state_free(struct xfrm_state *x);
|int security_xfrm_policy_lookup(struct xfrm_sec_ctx *ctx, u32 fl_secid, u8 dir);
|int security_xfrm_state_pol_flow_match(struct xfrm_state *x,
|           struct xfrm_policy *xp, struct flowi *fl);
|int security_xfrm_decode_session(struct sk_buff *skb, u32 *secid);
|void security_skb_classify_flow(struct sk_buff *skb, struct flowi *fl);
|int security_path_unlink(struct path *dir, struct dentry *dentry);
|int security_path_mkdir(struct path *dir, struct dentry *dentry, int mode);
|int security_path_rmdir(struct path *dir, struct dentry *dentry);
|int security_path_mknod(struct path *dir, struct dentry *dentry, int mode,
|   unsigned int dev);
|int security_path_truncate(struct path *path);
|int security_path_symlink(struct path *dir, struct dentry *dentry,
|     const char *old_name);
|int security_path_link(struct dentry *old_dentry, struct path *new_dir,
|         struct dentry *new_dentry);
|int security_path_rename(struct path *old_dir, struct dentry *old_dentry,
|    struct path *new_dir, struct dentry *new_dentry);
|int security_path_chmod(struct dentry *dentry, struct vfsmount *mnt,
|   mode_t mode);
|int security_path_chown(struct path *path, uid_t uid, gid_t gid);
|int security_path_chroot(struct path *path);
|int security_key_alloc(struct key *key, const struct cred *cred, unsigned long flags);
|void security_key_free(struct key *key);
|int security_key_permission(key_ref_t key_ref,
|       const struct cred *cred, key_perm_t perm);
|int security_key_getsecurity(struct key *key, char **_buffer);
|int security_audit_rule_init(u32 field, u32 op, char *rulestr, void **lsmrule);
|int security_audit_rule_known(struct audit_krule *krule);
|int security_audit_rule_match(u32 secid, u32 field, u32 op, void *lsmrule,
|         struct audit_context *actx);
|void security_audit_rule_free(void *lsmrule);
|extern struct dentry *securityfs_create_file(const char *name, mode_t mode,
|          struct dentry *parent, void *data,
|          const struct file_operations *fops);
|extern struct dentry *securityfs_create_dir(const char *name, struct dentry *parent);
|extern void securityfs_remove(struct dentry *dentry);
|static inline char *alloc_secdata(void)
|{
| return (char *)get_zeroed_page(((( gfp_t)0x10u) | (( gfp_t)0x40u) | (( gfp_t)0x80u)));
|}
|
|static inline void free_secdata(void *secdata)
|{
| free_pages(((unsigned long)secdata), 0);
|}
|static inline swp_entry_t swp_entry(unsigned long type, unsigned long offset)
|{
| swp_entry_t ret;
|
| ret.val = (type << (sizeof(ret.val) * 8 - 5)) |
|   (offset & ((1UL << (sizeof(ret.val) * 8 - 5)) - 1));
| return ret;
|}
|
|
|
|
|
|static inline unsigned swp_type(swp_entry_t entry)
|{
| return (entry.val >> (sizeof(entry.val) * 8 - 5));
|}
|
|
|
|
|
|static inline unsigned long swp_offset(swp_entry_t entry)
|{
| return entry.val & ((1UL << (sizeof(entry.val) * 8 - 5)) - 1);
|}
|
|
|
|static inline int is_swap_pte(pte_t pte)
|{
| return !pte_none(pte) && !pte_present(pte) && !pte_file(pte);
|}
|
|
|
|
|
|
|static inline swp_entry_t pte_to_swp_entry(pte_t pte)
|{
| swp_entry_t arch_entry;
|
| do { if (__builtin_expect(!!(pte_file(pte)), 0)) do { asm volatile("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b - 2b, %c0 - 2b\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection" : : "i" ("/home/l/latest/linux/include/linux/swapops.h"), "i" (61), "i" (sizeof(struct bug_entry))); __builtin_unreachable(); } while (0); } while(0);
| arch_entry = ((swp_entry_t) { pte_val((pte)) });
| return swp_entry((((arch_entry).val >> (0 + 1)) & ((1U << (6 - 0 - 1)) - 1)), ((arch_entry).val >> (8 + 1)));
|}
|
|
|
|
|
|static inline pte_t swp_entry_to_pte(swp_entry_t entry)
|{
| swp_entry_t arch_entry;
|
| arch_entry = ((swp_entry_t) { ((swp_type(entry)) << (0 + 1)) | ((swp_offset(entry)) << (8 + 1)) });
| do { if (__builtin_expect(!!(pte_file(((pte_t) { .pte = (arch_entry).val }))), 0)) do { asm volatile("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b - 2b, %c0 - 2b\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection" : : "i" ("/home/l/latest/linux/include/linux/swapops.h"), "i" (75), "i" (sizeof(struct bug_entry))); __builtin_unreachable(); } while (0); } while(0);
| return ((pte_t) { .pte = (arch_entry).val });
|}
|
|
|static inline swp_entry_t make_migration_entry(struct page *page, int write)
|{
| do { if (__builtin_expect(!!(!PageLocked(page)), 0)) do { asm volatile("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b - 2b, %c0 - 2b\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection" : : "i" ("/home/l/latest/linux/include/linux/swapops.h"), "i" (82), "i" (sizeof(struct bug_entry))); __builtin_unreachable(); } while (0); } while(0);
| return swp_entry(write ? (((1 << 5) - 2 - 1) + 1 + 1) : (((1 << 5) - 2 - 1) + 1),
|   (unsigned long)((page) - ((struct page *)(0xffffea0000000000UL))));
|}
|
|static inline int is_migration_entry(swp_entry_t entry)
|{
| return __builtin_expect(!!(swp_type(entry) == (((1 << 5) - 2 - 1) + 1) || swp_type(entry) == (((1 << 5) - 2 - 1) + 1 + 1)), 0)
|                                          ;
|}
|
|static inline int is_write_migration_entry(swp_entry_t entry)
|{
| return __builtin_expect(!!(swp_type(entry) == (((1 << 5) - 2 - 1) + 1 + 1)), 0);
|}
|
|static inline struct page *migration_entry_to_page(swp_entry_t entry)
|{
| struct page *p = (((struct page *)(0xffffea0000000000UL)) + (swp_offset(entry)));
|
|
|
|
| do { if (__builtin_expect(!!(!PageLocked(p)), 0)) do { asm volatile("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b - 2b, %c0 - 2b\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection" : : "i" ("/home/l/latest/linux/include/linux/swapops.h"), "i" (105), "i" (sizeof(struct bug_entry))); __builtin_unreachable(); } while (0); } while(0);
| return p;
|}
|
|static inline void make_migration_entry_read(swp_entry_t *entry)
|{
| *entry = swp_entry((((1 << 5) - 2 - 1) + 1), swp_offset(*entry));
|}
|
|extern void migration_entry_wait(struct mm_struct *mm, pmd_t *pmd,
|     unsigned long address);
|static inline swp_entry_t make_hwpoison_entry(struct page *page)
|{
| do { if (__builtin_expect(!!(!PageLocked(page)), 0)) do { asm volatile("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b - 2b, %c0 - 2b\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection" : : "i" ("/home/l/latest/linux/include/linux/swapops.h"), "i" (140), "i" (sizeof(struct bug_entry))); __builtin_unreachable(); } while (0); } while(0);
| return swp_entry(((1 << 5) - 2 - 1), (unsigned long)((page) - ((struct page *)(0xffffea0000000000UL))));
|}
|
|static inline int is_hwpoison_entry(swp_entry_t entry)
|{
| return swp_type(entry) == ((1 << 5) - 2 - 1);
|}
|static inline int non_swap_entry(swp_entry_t entry)
|{
| return swp_type(entry) >= ((1 << 5) - 2 - 1);
|}
|
|
|
|
|
|
|
|
|struct vfsmount;
|
|struct open_intent {
| int flags;
| int create_mode;
| struct file *file;
|};
|
|enum { MAX_NESTED_LINKS = 8 };
|
|struct nameidata {
| struct path path;
| struct qstr last;
| struct path root;
| unsigned int flags;
| int last_type;
| unsigned depth;
| char *saved_names[MAX_NESTED_LINKS + 1];
|
|
| union {
|  struct open_intent open;
| } intent;
|};
|
|
|
|
|enum {LAST_NORM, LAST_ROOT, LAST_DOT, LAST_DOTDOT, LAST_BIND};
|extern int user_path_at(int, const char *, unsigned, struct path *);
|
|
|
|
|
|
|extern int kern_path(const char *, unsigned, struct path *);
|
|extern int path_lookup(const char *, unsigned, struct nameidata *);
|extern int vfs_path_lookup(struct dentry *, struct vfsmount *,
|      const char *, unsigned int, struct nameidata *);
|
|extern struct file *lookup_instantiate_filp(struct nameidata *nd, struct dentry *dentry,
|  int (*open)(struct inode *, struct file *));
|
|extern struct dentry *lookup_one_len(const char *, struct dentry *, int);
|
|extern int follow_down(struct path *);
|extern int follow_up(struct path *);
|
|extern struct dentry *lock_rename(struct dentry *, struct dentry *);
|extern void unlock_rename(struct dentry *, struct dentry *);
|
|static inline void nd_set_link(struct nameidata *nd, char *path)
|{
| nd->saved_names[nd->depth] = path;
|}
|
|static inline char *nd_get_link(struct nameidata *nd)
|{
| return nd->saved_names[nd->depth];
|}
|
|static inline void nd_terminate_link(void *name, size_t len, size_t maxlen)
|{
| ((char *) name)[({ typeof(len) _min1 = (len); typeof(maxlen) _min2 = (maxlen); (void) (&_min1 == &_min2); _min1 < _min2 ? _min1 : _min2; })] = '\0';
|}
|extern const unsigned char _ctype[];
|static inline unsigned char __tolower(unsigned char c)
|{
| if ((((_ctype[(int)(unsigned char)(c)])&(0x01)) != 0))
|  c -= 'A'-'a';
| return c;
|}
|
|static inline unsigned char __toupper(unsigned char c)
|{
| if ((((_ctype[(int)(unsigned char)(c)])&(0x02)) != 0))
|  c -= 'a'-'A';
| return c;
|}
|
|
|
|
|
|
|typedef struct page *new_page_t(struct page *, unsigned long private, int **);
|
|
|
|
|extern void putback_lru_pages(struct list_head *l);
|extern int migrate_page(struct address_space *,
|   struct page *, struct page *);
|extern int migrate_pages(struct list_head *l, new_page_t x,
|   unsigned long private, int offlining);
|extern int migrate_huge_pages(struct list_head *l, new_page_t x,
|   unsigned long private, int offlining);
|
|extern int fail_migrate_page(struct address_space *,
|   struct page *, struct page *);
|
|extern int migrate_prep(void);
|extern int migrate_prep_local(void);
|extern int migrate_vmas(struct mm_struct *mm,
|  const nodemask_t *from, const nodemask_t *to,
|  unsigned long flags);
|extern void migrate_page_copy(struct page *newpage, struct page *page);
|extern int migrate_huge_page_move_mapping(struct address_space *mapping,
|      struct page *newpage, struct page *page);
|
|struct seq_operations;
|struct file;
|struct path;
|struct inode;
|struct dentry;
|
|struct seq_file {
| char *buf;
| size_t size;
| size_t from;
| size_t count;
| loff_t index;
| loff_t read_pos;
| u64 version;
| struct mutex lock;
| const struct seq_operations *op;
| void *private;
|};
|
|struct seq_operations {
| void * (*start) (struct seq_file *m, loff_t *pos);
| void (*stop) (struct seq_file *m, void *v);
| void * (*next) (struct seq_file *m, void *v, loff_t *pos);
| int (*show) (struct seq_file *m, void *v);
|};
|static inline size_t seq_get_buf(struct seq_file *m, char **bufp)
|{
| do { if (__builtin_expect(!!(m->count > m->size), 0)) do { asm volatile("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b - 2b, %c0 - 2b\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection" : : "i" ("/home/l/latest/linux/include/linux/seq_file.h"), "i" (48), "i" (sizeof(struct bug_entry))); __builtin_unreachable(); } while (0); } while(0);
| if (m->count < m->size)
|  *bufp = m->buf + m->count;
| else
|  *bufp = ((void *)0);
|
| return m->size - m->count;
|}
|static inline void seq_commit(struct seq_file *m, int num)
|{
| if (num < 0) {
|  m->count = m->size;
| } else {
|  do { if (__builtin_expect(!!(m->count + num > m->size), 0)) do { asm volatile("1:\tud2\n" ".pushsection __bug_table,\"a\"\n" "2:\t.long 1b - 2b, %c0 - 2b\n" "\t.word %c1, 0\n" "\t.org 2b+%c2\n" ".popsection" : : "i" ("/home/l/latest/linux/include/linux/seq_file.h"), "i" (71), "i" (sizeof(struct bug_entry))); __builtin_unreachable(); } while (0); } while(0);
|  m->count += num;
| }
|}
|
|char *mangle_path(char *s, char *p, char *esc);
|int seq_open(struct file *, const struct seq_operations *);
|ssize_t seq_read(struct file *, char *, size_t, loff_t *);
|loff_t seq_lseek(struct file *, loff_t, int);
|int seq_release(struct inode *, struct file *);
|int seq_escape(struct seq_file *, const char *, const char *);
|int seq_putc(struct seq_file *m, char c);
|int seq_puts(struct seq_file *m, const char *s);
|int seq_write(struct seq_file *seq, const void *data, size_t len);
|
|int seq_printf(struct seq_file *, const char *, ...)
| ;
|
|int seq_path(struct seq_file *, struct path *, char *);
|int seq_dentry(struct seq_file *, struct dentry *, char *);
|int seq_path_root(struct seq_file *m, struct path *path, struct path *root,
|    char *esc);
|int seq_bitmap(struct seq_file *m, const unsigned long *bits,
|       unsigned int nr_bits);
|static inline int seq_cpumask(struct seq_file *m, const struct cpumask *mask)
|{
| return seq_bitmap(m, ((mask)->bits), nr_cpu_ids);
|}
|
|static inline int seq_nodemask(struct seq_file *m, nodemask_t *mask)
|{
| return seq_bitmap(m, mask->bits, (1 << 10));
|}
|
|int seq_bitmap_list(struct seq_file *m, const unsigned long *bits,
|  unsigned int nr_bits);
|
|static inline int seq_cpumask_list(struct seq_file *m,
|       const struct cpumask *mask)
|{
| return seq_bitmap_list(m, ((mask)->bits), nr_cpu_ids);
|}
|
|static inline int seq_nodemask_list(struct seq_file *m, nodemask_t *mask)
|{
| return seq_bitmap_list(m, mask->bits, (1 << 10));
|}
|
|int single_open(struct file *, int (*)(struct seq_file *, void *), void *);
|int single_release(struct inode *, struct file *);
|void *__seq_open_private(struct file *, const struct seq_operations *, int);
|int seq_open_private(struct file *, const struct seq_operations *, int);
|int seq_release_private(struct inode *, struct file *);
|
|
|
|
|
|
|
|extern struct list_head *seq_list_start(struct list_head *head,
|  loff_t pos);
|extern struct list_head *seq_list_start_head(struct list_head *head,
|  loff_t pos);
|extern struct list_head *seq_list_next(void *v, struct list_head *head,
|  loff_t *ppos);
|
|
|
|
|
|extern struct hlist_node *seq_hlist_start(struct hlist_head *head,
|       loff_t pos);
|extern struct hlist_node *seq_hlist_start_head(struct hlist_head *head,
|            loff_t pos);
|extern struct hlist_node *seq_hlist_next(void *v, struct hlist_head *head,
|      loff_t *ppos);
|
|extern struct hlist_node *seq_hlist_start_rcu(struct hlist_head *head,
|           loff_t pos);
|extern struct hlist_node *seq_hlist_start_head_rcu(struct hlist_head *head,
|         loff_t pos);
|extern struct hlist_node *seq_hlist_next_rcu(void *v,
|         struct hlist_head *head,
|         loff_t *ppos);
|enum sgp_type {
| SGP_READ,
| SGP_CACHE,
| SGP_DIRTY,
| SGP_WRITE,
|};
|
|
|static unsigned long shmem_default_max_blocks(void)
|{
| return totalram_pages / 2;
|}
|
|static unsigned long shmem_default_max_inodes(void)
|{
| return ({ typeof(totalram_pages - 0UL) _min1 = (totalram_pages - 0UL); typeof(totalram_pages / 2) _min2 = (totalram_pages / 2); (void) (&_min1 == &_min2); _min1 < _min2 ? _min1 : _min2; });
|}
|
|
|static int shmem_getpage(struct inode *inode, unsigned long idx,
|    struct page **pagep, enum sgp_type sgp, int *type);
|
|static inline struct page *shmem_dir_alloc(gfp_t gfp_mask)
|{
|
|
|
|
|
|
|
| return alloc_pages((gfp_mask & ~((( gfp_t)0x80000u)|(( gfp_t)0x08u))) | (( gfp_t)0x8000u),
|    12 -12);
|}
|
|static inline void shmem_dir_free(struct page *page)
|{
| __free_pages(page, 12 -12);
|}
|
|static struct page **shmem_dir_map(struct page *page)
|{
| return (struct page **)__kmap_atomic(page);
     |not affected ==> the lock is still locked. prev next
|}
     |not affected ==> the lock is still locked. prev next
|
|static inline void shmem_dir_unmap(struct page **dir)
|{
| do { ((void)(sizeof(struct { int:-!!(0); }))); __kunmap_atomic(dir); } while (0);
     |not affected ==> the lock is still locked. prev next
|}
     |not affected ==> the lock is still locked. prev next
|
|static swp_entry_t *shmem_swp_map(struct page *page)
|{
| return (swp_entry_t *)__kmap_atomic(page);
|}
|
|static inline void shmem_swp_balance_unmap(void)
|{
|
|
|
|
|
|
|
| (void) __kmap_atomic(((((struct page *)(0xffffea0000000000UL)) + (__phys_addr((unsigned long)(empty_zero_page)) >> 12))));
|}
|
|static inline void shmem_swp_unmap(swp_entry_t *entry)
|{
| do { ((void)(sizeof(struct { int:-!!(0); }))); __kunmap_atomic(entry); } while (0);
|}
|
|static inline struct shmem_sb_info *SHMEM_SB(struct super_block *sb)
|{
| return sb->s_fs_info;
|}
|
|
|
|
|
|
|
|static inline int shmem_acct_size(unsigned long flags, loff_t size)
|{
| return (flags & 0x00200000) ?
|  0 : security_vm_enough_memory_kern(((((size)+((1UL) << 12)-1)&(~(((1UL) << 12)-1))) >> 12));
|}
|
|static inline void shmem_unacct_size(unsigned long flags, loff_t size)
|{
| if (!(flags & 0x00200000))
|  vm_unacct_memory(((((size)+((1UL) << 12)-1)&(~(((1UL) << 12)-1))) >> 12));
|}
|
|
|
|
|
|
|
|static inline int shmem_acct_block(unsigned long flags)
|{
| return (flags & 0x00200000) ?
|  security_vm_enough_memory_kern(((((((1UL) << 12))+((1UL) << 12)-1)&(~(((1UL) << 12)-1))) >> 12)) : 0;
|}
|
|static inline void shmem_unacct_blocks(unsigned long flags, long pages)
|{
| if (flags & 0x00200000)
|  vm_unacct_memory(pages * ((((((1UL) << 12))+((1UL) << 12)-1)&(~(((1UL) << 12)-1))) >> 12));
|}
|
|static const struct super_operations shmem_ops;
|static const struct address_space_operations shmem_aops;
|static const struct file_operations shmem_file_operations;
|static const struct inode_operations shmem_inode_operations;
|static const struct inode_operations shmem_dir_inode_operations;
|static const struct inode_operations shmem_special_inode_operations;
|static const struct vm_operations_struct shmem_vm_ops;
|
|static struct backing_dev_info shmem_backing_dev_info = {
| .ra_pages = 0,
| .capabilities = (0x00000002 | 0x00000001 | 0x00000080) | 0x00000100,
| .unplug_io_fn = default_unplug_io_fn,
|};
|
|static struct list_head shmem_swaplist = { &(shmem_swaplist), &(shmem_swaplist) };
|static struct mutex shmem_swaplist_mutex = { .count = { (1) } , .wait_lock = (spinlock_t ) { { .rlock = { .raw_lock = { 0 }, .magic = 0xdead4ead, .owner_cpu = -1, .owner = ((void *)-1L), .dep_map = { .name = "shmem_swaplist_mutex.wait_lock" } } } } , .wait_list = { &(shmem_swaplist_mutex.wait_list), &(shmem_swaplist_mutex.wait_list) } , .magic = &shmem_swaplist_mutex , .dep_map = { .name = "shmem_swaplist_mutex" } };
|
|static void shmem_free_blocks(struct inode *inode, long pages)
|{
| struct shmem_sb_info *sbinfo = SHMEM_SB(inode->i_sb);
| if (sbinfo->max_blocks) {
|  percpu_counter_add(&sbinfo->used_blocks, -pages);
|  __st_spin_lock_st__(&inode->i_lock);
|  inode->i_blocks -= pages*(((1UL) << 12)/512);
|  __st_spin_unlock_st__(&inode->i_lock);
| }
|}
|
|static int shmem_reserve_inode(struct super_block *sb)
|{
| struct shmem_sb_info *sbinfo = SHMEM_SB(sb);
| if (sbinfo->max_inodes) {
|  __st_spin_lock_st__(&sbinfo->stat_lock);
|  if (!sbinfo->free_inodes) {
|   __st_spin_unlock_st__(&sbinfo->stat_lock);
|   return -28;
|  }
|  sbinfo->free_inodes--;
|  __st_spin_unlock_st__(&sbinfo->stat_lock);
| }
| return 0;
|}
|
|static void shmem_free_inode(struct super_block *sb)
|{
| struct shmem_sb_info *sbinfo = SHMEM_SB(sb);
| if (sbinfo->max_inodes) {
|  __st_spin_lock_st__(&sbinfo->stat_lock);
|  sbinfo->free_inodes++;
|  __st_spin_unlock_st__(&sbinfo->stat_lock);
| }
|}
|static void shmem_recalc_inode(struct inode *inode)
|{
| struct shmem_inode_info *info = SHMEM_I(inode);
| long freed;
|
| freed = info->alloced - info->swapped - inode->i_mapping->nrpages;
| if (freed > 0) {
|  info->alloced -= freed;
|  shmem_unacct_blocks(info->flags, freed);
|  shmem_free_blocks(inode, freed);
| }
|}
|static swp_entry_t *shmem_swp_entry(struct shmem_inode_info *info, unsigned long index, struct page **page)
|{
| unsigned long offset;
| struct page **dir;
| struct page *subdir;
|
| if (index < 16) {
|  shmem_swp_balance_unmap();
|  return info->i_direct+index;
| }
| if (!info->i_indirect) {
|  if (page) {
|   info->i_indirect = *page;
|   *page = ((void *)0);
|  }
|  return ((void *)0);
| }
|
| index -= 16;
| offset = index % (((1UL) << 12)/sizeof(unsigned long));
| index /= (((1UL) << 12)/sizeof(unsigned long));
| dir = shmem_dir_map(info->i_indirect);
|
| if (index >= (((1UL) << 12)/sizeof(unsigned long))/2) {
|  index -= (((1UL) << 12)/sizeof(unsigned long))/2;
|  dir += (((1UL) << 12)/sizeof(unsigned long))/2 + index/(((1UL) << 12)/sizeof(unsigned long));
|  index %= (((1UL) << 12)/sizeof(unsigned long));
|  subdir = *dir;
|  if (!subdir) {
|   if (page) {
|    *dir = *page;
|    *page = ((void *)0);
|   }
|   shmem_dir_unmap(dir);
|   return ((void *)0);
|  }
|  shmem_dir_unmap(dir);
|  dir = shmem_dir_map(subdir);
| }
|
| dir += index;
| subdir = *dir;
| if (!subdir) {
|  if (!page || !(subdir = *page)) {
|   shmem_dir_unmap(dir);
|   return ((void *)0);
|  }
|  *dir = subdir;
|  *page = ((void *)0);
| }
| shmem_dir_unmap(dir);
| return shmem_swp_map(subdir) + offset;
|}
|
|static void shmem_swp_set(struct shmem_inode_info *info, swp_entry_t *entry, unsigned long value)
|{
| long incdec = value? 1: -1;
|
| entry->val = value;
| info->swapped += incdec;
| if ((unsigned long)(entry - info->i_direct) >= 16) {
|  struct page *page = (((struct page *)(0xffffea0000000000UL)) + (__phys_addr((unsigned long)(entry)) >> 12));
|  ((page)->private = (((page)->private) + incdec));
| }
|}
|static swp_entry_t *shmem_swp_alloc(struct shmem_inode_info *info, unsigned long index, enum sgp_type sgp)
|{
| struct inode *inode = &info->vfs_inode;
| struct shmem_sb_info *sbinfo = SHMEM_SB(inode->i_sb);
| struct page *page = ((void *)0);
| swp_entry_t *entry;
|
| if (sgp != SGP_WRITE &&
|     ((loff_t) index << 12) >= i_size_read(inode))
|  return ERR_PTR(-22);
|
| while (!(entry = shmem_swp_entry(info, index, &page))) {
|  if (sgp == SGP_READ)
|   return shmem_swp_map(((((struct page *)(0xffffea0000000000UL)) + (__phys_addr((unsigned long)(empty_zero_page)) >> 12))));
|
|
|
|
|
|  if (sbinfo->max_blocks) {
|   if (percpu_counter_compare(&sbinfo->used_blocks, (sbinfo->max_blocks - 1)) > 0)
|    return ERR_PTR(-28);
|   percpu_counter_inc(&sbinfo->used_blocks);
|   __st_spin_lock_st__(&inode->i_lock);
|   inode->i_blocks += (((1UL) << 12)/512);
|   __st_spin_unlock_st__(&inode->i_lock);
|  }
|
|  __st_spin_unlock_st__(&info->lock);
|  page = shmem_dir_alloc(mapping_gfp_mask(inode->i_mapping));
|  __st_spin_lock_st__(&info->lock);
|
|  if (!page) {
|   shmem_free_blocks(inode, 1);
|   return ERR_PTR(-12);
|  }
|  if (sgp != SGP_WRITE &&
|      ((loff_t) index << 12) >= i_size_read(inode)) {
|   entry = ERR_PTR(-22);
|   break;
|  }
|  if (info->next_index <= index)
|   info->next_index = index + 1;
| }
| if (page) {
|
|  shmem_free_blocks(inode, 1);
|  shmem_dir_free(page);
| }
| if (info->next_index <= index && !IS_ERR(entry))
|  info->next_index = index + 1;
| return entry;
|}
|
|
|
|
|
|
|
|static int shmem_free_swp(swp_entry_t *dir, swp_entry_t *edir,
|      spinlock_t *punch_lock)
|{
| spinlock_t *punch_unlock = ((void *)0);
| swp_entry_t *ptr;
| int freed = 0;
|
| for (ptr = dir; ptr < edir; ptr++) {
|  if (ptr->val) {
|   if (punch_lock) {
|    punch_unlock = punch_lock;
|    punch_lock = ((void *)0);
|    __st_spin_lock_st__(punch_unlock);
|    if (!ptr->val)
|     continue;
|   }
|   free_swap_and_cache(*ptr);
|   *ptr = (swp_entry_t){0};
|   freed++;
|  }
| }
| if (punch_unlock)
|  __st_spin_unlock_st__(punch_unlock);
| return freed;
|}
|
|static int shmem_map_and_free_swp(struct page *subdir, int offset,
|  int limit, struct page ***dir, spinlock_t *punch_lock)
|{
| swp_entry_t *ptr;
| int freed = 0;
|
| ptr = shmem_swp_map(subdir);
| for (; offset < limit; offset += 64) {
|  int size = limit - offset;
|  if (size > 64)
|   size = 64;
|  freed += shmem_free_swp(ptr+offset, ptr+offset+size,
|       punch_lock);
|  if (need_resched()) {
|   shmem_swp_unmap(ptr);
|   if (*dir) {
|    shmem_dir_unmap(*dir);
|    *dir = ((void *)0);
|   }
|   ({ __might_sleep("mm/.tmp_shmem.o.armored.c", 510, 0); _cond_resched(); });
|   ptr = shmem_swp_map(subdir);
|  }
| }
| shmem_swp_unmap(ptr);
| return freed;
|}
|
|static void shmem_free_pages(struct list_head *next)
|{
| struct page *page;
| int freed = 0;
|
| do {
|  page = ({ const typeof( ((struct page *)0)->lru ) *__mptr = (next); (struct page *)( (char *)__mptr - 1 );});
|  next = next->next;
|  shmem_dir_free(page);
|  freed++;
|  if (freed >= 64) {
|   ({ __might_sleep("mm/.tmp_shmem.o.armored.c", 529, 0); _cond_resched(); });
|   freed = 0;
|  }
| } while (next);
|}
|
|static void shmem_truncate_range(struct inode *inode, loff_t start, loff_t end)
|{
| struct shmem_inode_info *info = SHMEM_I(inode);
| unsigned long idx;
| unsigned long size;
| unsigned long limit;
| unsigned long stage;
| unsigned long diroff;
| struct page **dir;
| struct page *topdir;
| struct page *middir;
| struct page *subdir;
| swp_entry_t *ptr;
| struct list_head pages_to_free = { &(pages_to_free), &(pages_to_free) };
| long nr_pages_to_free = 0;
| long nr_swaps_freed = 0;
| int offset;
| int freed;
| int punch_hole;
| spinlock_t *needs_lock;
| spinlock_t *punch_lock;
| unsigned long upper_limit;
|
| inode->i_ctime = inode->i_mtime = (current_kernel_time());
| idx = (start + ((1UL) << 12) - 1) >> 12;
| if (idx >= info->next_index)
|  return;
|
| __st_spin_lock_st__(&info->lock);
| info->flags |= 0x00000002;
| if (end == (loff_t) -1) {
|  limit = info->next_index;
|  upper_limit = ((unsigned long)((({ unsigned long long __min1 = (((16 + (((unsigned long long)(((1UL) << 12)/sizeof(unsigned long))*(((1UL) << 12)/sizeof(unsigned long)))/2) * ((((1UL) << 12)/sizeof(unsigned long))+1)) << 12)); unsigned long long __min2 = (0x7fffffffffffffffUL); __min1 < __min2 ? __min1: __min2; })+1) >> 12));
|  info->next_index = idx;
|  needs_lock = ((void *)0);
|  punch_hole = 0;
| } else {
|  if (end + 1 >= inode->i_size) {
|   limit = (inode->i_size + ((1UL) << 12) - 1) >>
|       12;
|   upper_limit = ((unsigned long)((({ unsigned long long __min1 = (((16 + (((unsigned long long)(((1UL) << 12)/sizeof(unsigned long))*(((1UL) << 12)/sizeof(unsigned long)))/2) * ((((1UL) << 12)/sizeof(unsigned long))+1)) << 12)); unsigned long long __min2 = (0x7fffffffffffffffUL); __min1 < __min2 ? __min1: __min2; })+1) >> 12));
|  } else {
|   limit = (end + 1) >> 12;
|   upper_limit = limit;
|  }
|  needs_lock = &info->lock;
|  punch_hole = 1;
| }
|
| topdir = info->i_indirect;
| if (topdir && idx <= 16 && !punch_hole) {
|  info->i_indirect = ((void *)0);
|  nr_pages_to_free++;
|  list_add(&topdir->lru, &pages_to_free);
| }
| __st_spin_unlock_st__(&info->lock);
|
| if (info->swapped && idx < 16) {
|  ptr = info->i_direct;
|  size = limit;
|  if (size > 16)
|   size = 16;
|  nr_swaps_freed = shmem_free_swp(ptr+idx, ptr+size, needs_lock);
| }
|
|
|
|
|
| if (!topdir || limit <= 16)
|  goto done2;
| upper_limit -= 16;
| limit -= 16;
| idx = (idx > 16)? (idx - 16): 0;
| offset = idx % (((1UL) << 12)/sizeof(unsigned long));
| idx -= offset;
|
| dir = shmem_dir_map(topdir);
| stage = ((unsigned long long)(((1UL) << 12)/sizeof(unsigned long))*(((1UL) << 12)/sizeof(unsigned long)))/2;
| if (idx < ((unsigned long long)(((1UL) << 12)/sizeof(unsigned long))*(((1UL) << 12)/sizeof(unsigned long)))/2) {
|  middir = topdir;
|  diroff = idx/(((1UL) << 12)/sizeof(unsigned long));
| } else {
|  dir += (((1UL) << 12)/sizeof(unsigned long))/2;
|  dir += (idx - ((unsigned long long)(((1UL) << 12)/sizeof(unsigned long))*(((1UL) << 12)/sizeof(unsigned long)))/2)/((unsigned long long)(((1UL) << 12)/sizeof(unsigned long))*(((1UL) << 12)/sizeof(unsigned long)));
|  while (stage <= idx)
|   stage += ((unsigned long long)(((1UL) << 12)/sizeof(unsigned long))*(((1UL) << 12)/sizeof(unsigned long)));
|  middir = *dir;
|  if (*dir) {
|   diroff = ((idx - ((unsigned long long)(((1UL) << 12)/sizeof(unsigned long))*(((1UL) << 12)/sizeof(unsigned long)))/2) %
|    ((unsigned long long)(((1UL) << 12)/sizeof(unsigned long))*(((1UL) << 12)/sizeof(unsigned long)))) / (((1UL) << 12)/sizeof(unsigned long));
|   if (!diroff && !offset && upper_limit >= stage) {
|    if (needs_lock) {
|     __st_spin_lock_st__(needs_lock);
|     *dir = ((void *)0);
|     __st_spin_unlock_st__(needs_lock);
|     needs_lock = ((void *)0);
|    } else
|     *dir = ((void *)0);
|    nr_pages_to_free++;
|    list_add(&middir->lru, &pages_to_free);
|   }
|   shmem_dir_unmap(dir);
|   dir = shmem_dir_map(middir);
|  } else {
|   diroff = 0;
|   offset = 0;
|   idx = stage;
|  }
| }
|
| for (; idx < limit; idx += (((1UL) << 12)/sizeof(unsigned long)), diroff++) {
|  if (idx == stage) {
|   shmem_dir_unmap(dir);
|   dir = shmem_dir_map(topdir) +
|       (((1UL) << 12)/sizeof(unsigned long))/2 + idx/((unsigned long long)(((1UL) << 12)/sizeof(unsigned long))*(((1UL) << 12)/sizeof(unsigned long)));
|   while (!*dir) {
|    dir++;
|    idx += ((unsigned long long)(((1UL) << 12)/sizeof(unsigned long))*(((1UL) << 12)/sizeof(unsigned long)));
|    if (idx >= limit)
|     goto done1;
|   }
|   stage = idx + ((unsigned long long)(((1UL) << 12)/sizeof(unsigned long))*(((1UL) << 12)/sizeof(unsigned long)));
|   middir = *dir;
|   if (punch_hole)
|    needs_lock = &info->lock;
|   if (upper_limit >= stage) {
|    if (needs_lock) {
|     __st_spin_lock_st__(needs_lock);
|     *dir = ((void *)0);
|     __st_spin_unlock_st__(needs_lock);
|     needs_lock = ((void *)0);
|    } else
|     *dir = ((void *)0);
|    nr_pages_to_free++;
|    list_add(&middir->lru, &pages_to_free);
|   }
|   shmem_dir_unmap(dir);
|   ({ __might_sleep("mm/.tmp_shmem.o.armored.c", 687, 0); _cond_resched(); });
|   dir = shmem_dir_map(middir);
|   diroff = 0;
|  }
|  punch_lock = needs_lock;
|  subdir = dir[diroff];
|  if (subdir && !offset && upper_limit-idx >= (((1UL) << 12)/sizeof(unsigned long))) {
|   if (needs_lock) {
|    __st_spin_lock_st__(needs_lock);
|    dir[diroff] = ((void *)0);
|    __st_spin_unlock_st__(needs_lock);
|    punch_lock = ((void *)0);
|   } else
|    dir[diroff] = ((void *)0);
|   nr_pages_to_free++;
|   list_add(&subdir->lru, &pages_to_free);
|  }
|  if (subdir && ((subdir)->private) ) {
|   size = limit - idx;
|   if (size > (((1UL) << 12)/sizeof(unsigned long)))
|    size = (((1UL) << 12)/sizeof(unsigned long));
|   freed = shmem_map_and_free_swp(subdir,
|     offset, size, &dir, punch_lock);
|   if (!dir)
|    dir = shmem_dir_map(middir);
|   nr_swaps_freed += freed;
|   if (offset || punch_lock) {
|    __st_spin_lock_st__(&info->lock);
|    ((subdir)->private = (((subdir)->private) - freed))
|                                  ;
|    __st_spin_unlock_st__(&info->lock);
|   } else
|    __st_BUG_ON_st__(((subdir)->private) != freed);
|  }
|  offset = 0;
| }
|done1:
| shmem_dir_unmap(dir);
|done2:
| if (inode->i_mapping->nrpages && (info->flags & 0x00000001)) {
|  truncate_inode_pages_range(inode->i_mapping, start, end);
|  if (punch_hole)
|   unmap_mapping_range(inode->i_mapping, start,
|       end - start, 1);
| }
|
| __st_spin_lock_st__(&info->lock);
| info->flags &= ~0x00000002;
| info->swapped -= nr_swaps_freed;
| if (nr_pages_to_free)
|  shmem_free_blocks(inode, nr_pages_to_free);
| shmem_recalc_inode(inode);
| __st_spin_unlock_st__(&info->lock);
|
|
|
|
| if (!list_empty(&pages_to_free)) {
|  pages_to_free.prev->next = ((void *)0);
|  shmem_free_pages(pages_to_free.next);
| }
|}
|
|static int shmem_notify_change(struct dentry *dentry, struct iattr *attr)
|{
| struct inode *inode = dentry->d_inode;
| loff_t newsize = attr->ia_size;
| int error;
|
| error = inode_change_ok(inode, attr);
| if (error)
|  return error;
|
| if ((((inode->i_mode) & 00170000) == 0100000) && (attr->ia_valid & (1 << 3))
|     && newsize != inode->i_size) {
|  struct page *page = ((void *)0);
|
|  if (newsize < inode->i_size) {
|
|
|
|
|
|
|
|   if (newsize & (((1UL) << 12)-1)) {
|    (void) shmem_getpage(inode,
|     newsize >> 12,
|      &page, SGP_READ, ((void *)0));
|    if (page)
|     unlock_page(page);
|   }
|
|
|
|
|
|
|
|   if (newsize) {
|    struct shmem_inode_info *info = SHMEM_I(inode);
|    __st_spin_lock_st__(&info->lock);
|    info->flags &= ~0x00000001;
|    __st_spin_unlock_st__(&info->lock);
|   }
|  }
|
|
|  truncate_setsize(inode, newsize);
|  if (page)
|   put_page(page);
|  shmem_truncate_range(inode, newsize, (loff_t)-1);
| }
|
| setattr_copy(inode, attr);
|
| if (attr->ia_valid & (1 << 0))
|  error = generic_acl_chmod(inode);
|
| return error;
|}
|
|static void shmem_evict_inode(struct inode *inode)
|{
| struct shmem_inode_info *info = SHMEM_I(inode);
|
| if (inode->i_mapping->a_ops == &shmem_aops) {
|  truncate_inode_pages(inode->i_mapping, 0);
|  shmem_unacct_size(info->flags, inode->i_size);
|  inode->i_size = 0;
|  shmem_truncate_range(inode, 0, (loff_t)-1);
|  if (!list_empty(&info->swaplist)) {
|   __st_mutex_lock_st__(&shmem_swaplist_mutex);
|   list_del_init(&info->swaplist);
|   __st_mutex_unlock_st__(&shmem_swaplist_mutex);
|  }
| }
| __st_BUG_ON_st__(inode->i_blocks);
| shmem_free_inode(inode->i_sb);
| end_writeback(inode);
|}
|
|static inline int shmem_find_swp(swp_entry_t entry, swp_entry_t *dir, swp_entry_t *edir)
|{
| swp_entry_t *ptr;
|
| for (ptr = dir; ptr < edir; ptr++) {
     |not affected ==> the lock is still locked. prev next
|  if (ptr->val == entry.val)
     |not affected ==> the lock is still locked. prev next
|   return ptr - dir;
     |not affected ==> the lock is still locked. prev next
| }
| return -1;
|}
     |not affected ==> the lock is still locked. prev next
|
|static int shmem_unuse_inode(struct shmem_inode_info *info, swp_entry_t entry, struct page *page)
|{
| struct inode *inode;
| unsigned long idx;
| unsigned long size;
| unsigned long limit;
| unsigned long stage;
| struct page **dir;
| struct page *subdir;
| swp_entry_t *ptr;
| int offset;
| int error;
|
| idx = 0;
     |not affected ==> the lock is still locked. prev next
| ptr = info->i_direct;
     |not affected ==> the lock is still locked. prev next
| __st_spin_lock_st__(&info->lock);
     |not affected ==> the lock is still locked. prev next
| if (!info->swapped) {
     |not affected ==> the lock is still locked. prev next
|  list_del_init(&info->swaplist);
|  goto lost2;
| }
| limit = info->next_index;
     |not affected ==> the lock is still locked. prev next
| size = limit;
     |not affected ==> the lock is still locked. prev next
| if (size > 16)
     |not affected ==> the lock is still locked. prev next
|  size = 16;
| offset = shmem_find_swp(entry, ptr, ptr+size);
     |not affected ==> the lock is still locked. prev next
| if (offset >= 0)
     |not affected ==> the lock is still locked. prev next
|  goto found;
| if (!info->i_indirect)
     |not affected ==> the lock is still locked. prev next
|  goto lost2;
|
| dir = shmem_dir_map(info->i_indirect);
     |not affected ==> the lock is still locked. prev next
| stage = 16 + ((unsigned long long)(((1UL) << 12)/sizeof(unsigned long))*(((1UL) << 12)/sizeof(unsigned long)))/2;
     |not affected ==> the lock is still locked. prev next
|
| for (idx = 16; idx < limit; idx += (((1UL) << 12)/sizeof(unsigned long)), dir++) {
     |not affected ==> the lock is still locked. prev next
|  if (idx == stage) {
|   shmem_dir_unmap(dir-1);
|   if (({ __might_sleep("mm/.tmp_shmem.o.armored.c", 889, 0); __cond_resched_lock(&info->lock); })) {
|
|    if (limit > info->next_index) {
|     limit = info->next_index;
|     if (idx >= limit)
|      goto lost2;
|    }
|   }
|   dir = shmem_dir_map(info->i_indirect) +
|       (((1UL) << 12)/sizeof(unsigned long))/2 + idx/((unsigned long long)(((1UL) << 12)/sizeof(unsigned long))*(((1UL) << 12)/sizeof(unsigned long)));
|   while (!*dir) {
|    dir++;
|    idx += ((unsigned long long)(((1UL) << 12)/sizeof(unsigned long))*(((1UL) << 12)/sizeof(unsigned long)));
|    if (idx >= limit)
|     goto lost1;
|   }
|   stage = idx + ((unsigned long long)(((1UL) << 12)/sizeof(unsigned long))*(((1UL) << 12)/sizeof(unsigned long)));
|   subdir = *dir;
|   shmem_dir_unmap(dir);
|   dir = shmem_dir_map(subdir);
|  }
|  subdir = *dir;
|  if (subdir && ((subdir)->private)) {
|   ptr = shmem_swp_map(subdir);
|   size = limit - idx;
|   if (size > (((1UL) << 12)/sizeof(unsigned long)))
|    size = (((1UL) << 12)/sizeof(unsigned long));
|   offset = shmem_find_swp(entry, ptr, ptr+size);
|   shmem_swp_unmap(ptr);
|   if (offset >= 0) {
|    shmem_dir_unmap(dir);
|    goto found;
|   }
|  }
| }
|lost1:
| shmem_dir_unmap(dir-1);
     |not affected ==> the lock is still locked. prev next
|lost2:
| __st_spin_unlock_st__(&info->lock);
     |not affected ==> the lock is still locked. prev next
| return 0;
     |not affected ==> the lock is still locked. prev next
|found:
| idx += offset;
| inode = igrab(&info->vfs_inode);
| __st_spin_unlock_st__(&info->lock);
| if (shmem_swaplist.next != &info->swaplist)
|  list_move_tail(&shmem_swaplist, &info->swaplist);
| __st_mutex_unlock_st__(&shmem_swaplist_mutex);
|
| error = 1;
| if (!inode)
|  goto out;
|
|
|
|
|
| error = mem_cgroup_cache_charge(page, get_current()->mm, __st_GFP_KERNEL_st__);
| if (error)
|  goto out;
| error = radix_tree_preload(__st_GFP_KERNEL_st__);
| if (error) {
|  mem_cgroup_uncharge_cache_page(page);
|  goto out;
| }
| error = 1;
|
| __st_spin_lock_st__(&info->lock);
| ptr = shmem_swp_entry(info, idx, ((void *)0));
| if (ptr && ptr->val == entry.val) {
|  error = add_to_page_cache_locked(page, inode->i_mapping,
|      idx, (((( gfp_t)0x20u)) & ~(( gfp_t)0x20u)));
|
| } else
|  mem_cgroup_uncharge_cache_page(page);
|
| if (error == -17) {
|  struct page *filepage = find_get_page(inode->i_mapping, idx);
|  error = 1;
|  if (filepage) {
|
|
|
|
|   if (PageUptodate(filepage))
|    error = 0;
|   put_page(filepage);
|  }
| }
| if (!error) {
|  delete_from_swap_cache(page);
|  set_page_dirty(page);
|  info->flags |= 0x00000001;
|  shmem_swp_set(info, ptr, 0);
|  swap_free(entry);
|  error = 1;
| }
| if (ptr)
|  shmem_swp_unmap(ptr);
| __st_spin_unlock_st__(&info->lock);
| radix_tree_preload_end();
|out:
| unlock_page(page);
| put_page(page);
| iput(inode);
| return error;
|}
     |not affected ==> the lock is still locked. prev next
|
|
|
|
|int shmem_unuse(swp_entry_t entry, struct page *page)
|{
| struct list_head *p, *next;
| struct shmem_inode_info *info;
| int found = 0;
|
| __st_mutex_lock_st__(&shmem_swaplist_mutex);
     |The lock is locked here. next
| for (p = (&shmem_swaplist)->next, next = p->next; p != (&shmem_swaplist); p = next, next = p->next) {
     |not affected ==> the lock is still locked. prev next
|  info = ({ const typeof( ((struct shmem_inode_info *)0)->swaplist ) *__mptr = (p); (struct shmem_inode_info *)( (char *)__mptr - 1 );});
     |not affected ==> the lock is still locked. prev next
|  found = shmem_unuse_inode(info, entry, page);
     |not affected ==> the lock is still locked. prev next
|  ({ __might_sleep("mm/.tmp_shmem.o.armored.c", 1017, 0); _cond_resched(); });
     |not affected ==> the lock is still locked. prev next
|  if (found)
     |not affected ==> the lock is still locked. prev next
|   goto out;
     |not affected ==> the lock is still locked. prev next
| }
| __st_mutex_unlock_st__(&shmem_swaplist_mutex);
|
|
|
|
| unlock_page(page);
| put_page(page);
|out:
| return (found < 0) ? found : 0;
     |not affected ==> the lock is still locked. prev next
|}
     |Leaving function in locked state.[& shmem_swaplist_mutex] prev
|
|
|
|
|static int shmem_writepage(struct page *page, struct writeback_control *wbc)
|{
| struct shmem_inode_info *info;
| swp_entry_t *entry, swap;
| struct address_space *mapping;
| unsigned long index;
| struct inode *inode;
|
| __st_BUG_ON_st__(!PageLocked(page));
| mapping = page->mapping;
| index = page->index;
| inode = mapping->host;
| info = SHMEM_I(inode);
| if (info->flags & 0x00002000)
|  goto redirty;
| if (!total_swap_pages)
|  goto redirty;
| if (wbc->for_reclaim)
|  swap = get_swap_page();
| else
|  swap.val = 0;
|
| __st_spin_lock_st__(&info->lock);
| if (index >= info->next_index) {
|  __st_BUG_ON_st__(!(info->flags & 0x00000002));
|  goto unlock;
| }
| entry = shmem_swp_entry(info, index, ((void *)0));
| if (entry->val) {
|
|
|
|
|  free_swap_and_cache(*entry);
|  shmem_swp_set(info, entry, 0);
| }
| shmem_recalc_inode(inode);
|
| if (swap.val && add_to_swap_cache(page, swap, ((( gfp_t)0x20u))) == 0) {
|  remove_from_page_cache(page);
|  shmem_swp_set(info, entry, swap.val);
|  shmem_swp_unmap(entry);
|  if (list_empty(&info->swaplist))
|   inode = igrab(inode);
|  else
|   inode = ((void *)0);
|  __st_spin_unlock_st__(&info->lock);
|  swap_shmem_alloc(swap);
|  __st_BUG_ON_st__(page_mapped(page));
|  put_page(page);
|  swap_writepage(page, wbc);
|  if (inode) {
|   __st_mutex_lock_st__(&shmem_swaplist_mutex);
|
|   list_move_tail(&info->swaplist, &shmem_swaplist);
|   __st_mutex_unlock_st__(&shmem_swaplist_mutex);
|   iput(inode);
|  }
|  return 0;
| }
|
| shmem_swp_unmap(entry);
|unlock:
| __st_spin_unlock_st__(&info->lock);
|
|
|
|
| swapcache_free(swap, ((void *)0));
|redirty:
| set_page_dirty(page);
| if (wbc->for_reclaim)
|  return AOP_WRITEPAGE_ACTIVATE;
| unlock_page(page);
| return 0;
|}
|
|
|
|static void shmem_show_mpol(struct seq_file *seq, struct mempolicy *mpol)
|{
| char buffer[64];
|
| if (!mpol || mpol->mode == MPOL_DEFAULT)
|  return;
|
| mpol_to_str(buffer, sizeof(buffer), mpol, 1);
|
| seq_printf(seq, ",mpol=%s", buffer);
|}
|
|static struct mempolicy *shmem_get_sbmpol(struct shmem_sb_info *sbinfo)
|{
| struct mempolicy *mpol = ((void *)0);
| if (sbinfo->mpol) {
|  __st_spin_lock_st__(&sbinfo->stat_lock);
|  mpol = sbinfo->mpol;
|  mpol_get(mpol);
|  __st_spin_unlock_st__(&sbinfo->stat_lock);
| }
| return mpol;
|}
|
|
|static struct page *shmem_swapin(swp_entry_t entry, gfp_t gfp,
|   struct shmem_inode_info *info, unsigned long idx)
|{
| struct mempolicy mpol, *spol;
| struct vm_area_struct pvma;
| struct page *page;
|
| spol = mpol_cond_copy(&mpol,
|    mpol_shared_policy_lookup(&info->policy, idx));
|
|
| pvma.vm_start = 0;
| pvma.vm_pgoff = idx;
| pvma.vm_ops = ((void *)0);
| pvma.vm_policy = spol;
| page = swapin_readahead(entry, gfp, &pvma, 0);
| return page;
|}
|
|static struct page *shmem_alloc_page(gfp_t gfp,
|   struct shmem_inode_info *info, unsigned long idx)
|{
| struct vm_area_struct pvma;
|
|
| pvma.vm_start = 0;
| pvma.vm_pgoff = idx;
| pvma.vm_ops = ((void *)0);
| pvma.vm_policy = mpol_shared_policy_lookup(&info->policy, idx);
|
|
|
|
| return alloc_page_vma(gfp, &pvma, 0);
|}
|static int shmem_getpage(struct inode *inode, unsigned long idx,
|   struct page **pagep, enum sgp_type sgp, int *type)
|{
| struct address_space *mapping = inode->i_mapping;
| struct shmem_inode_info *info = SHMEM_I(inode);
| struct shmem_sb_info *sbinfo;
| struct page *filepage = *pagep;
| struct page *swappage;
| struct page *prealloc_page = ((void *)0);
| swp_entry_t *entry;
| swp_entry_t swap;
| gfp_t gfp;
| int error;
|
| if (idx >= ((unsigned long)((({ unsigned long long __min1 = (((16 + (((unsigned long long)(((1UL) << 12)/sizeof(unsigned long))*(((1UL) << 12)/sizeof(unsigned long)))/2) * ((((1UL) << 12)/sizeof(unsigned long))+1)) << 12)); unsigned long long __min2 = (0x7fffffffffffffffUL); __min1 < __min2 ? __min1: __min2; })+1) >> 12)))
|  return -27;
|
| if (type)
|  *type = 0;
|repeat:
| if (!filepage)
|  filepage = find_lock_page(mapping, idx);
| if (filepage && PageUptodate(filepage))
|  goto done;
| gfp = mapping_gfp_mask(mapping);
| if (!filepage) {
|
|
|
|
|  error = radix_tree_preload(gfp & ~(( gfp_t)0x02u));
|  if (error)
|   goto failed;
|  radix_tree_preload_end();
|  if (sgp != SGP_READ && !prealloc_page) {
|
|   prealloc_page = shmem_alloc_page(gfp, info, idx);
|   if (prealloc_page) {
|    if (mem_cgroup_cache_charge(prealloc_page,
|      get_current()->mm, __st_GFP_KERNEL_st__)) {
|     put_page(prealloc_page);
|     prealloc_page = ((void *)0);
|    }
|   }
|  }
| }
| error = 0;
|
| __st_spin_lock_st__(&info->lock);
| shmem_recalc_inode(inode);
| entry = shmem_swp_alloc(info, idx, sgp);
| if (IS_ERR(entry)) {
|  __st_spin_unlock_st__(&info->lock);
|  error = PTR_ERR(entry);
|  goto failed;
| }
| swap = *entry;
|
| if (swap.val) {
|
|  swappage = lookup_swap_cache(swap);
|  if (!swappage) {
|   shmem_swp_unmap(entry);
|
|   if (type && !(*type & 0x0004)) {
|    __count_vm_event(PGMAJFAULT);
|    *type |= 0x0004;
|   }
|   __st_spin_unlock_st__(&info->lock);
|   swappage = shmem_swapin(swap, gfp, info, idx);
|   if (!swappage) {
|    __st_spin_lock_st__(&info->lock);
|    entry = shmem_swp_alloc(info, idx, sgp);
|    if (IS_ERR(entry))
|     error = PTR_ERR(entry);
|    else {
|     if (entry->val == swap.val)
|      error = -12;
|     shmem_swp_unmap(entry);
|    }
|    __st_spin_unlock_st__(&info->lock);
|    if (error)
|     goto failed;
|    goto repeat;
|   }
|   wait_on_page_locked(swappage);
|   put_page(swappage);
|   goto repeat;
|  }
|
|
|  if (!trylock_page(swappage)) {
|   shmem_swp_unmap(entry);
|   __st_spin_unlock_st__(&info->lock);
|   wait_on_page_locked(swappage);
|   put_page(swappage);
|   goto repeat;
|  }
|  if (PageWriteback(swappage)) {
|   shmem_swp_unmap(entry);
|   __st_spin_unlock_st__(&info->lock);
|   wait_on_page_writeback(swappage);
|   unlock_page(swappage);
|   put_page(swappage);
|   goto repeat;
|  }
|  if (!PageUptodate(swappage)) {
|   shmem_swp_unmap(entry);
|   __st_spin_unlock_st__(&info->lock);
|   unlock_page(swappage);
|   put_page(swappage);
|   error = -5;
|   goto failed;
|  }
|
|  if (filepage) {
|   shmem_swp_set(info, entry, 0);
|   shmem_swp_unmap(entry);
|   delete_from_swap_cache(swappage);
|   __st_spin_unlock_st__(&info->lock);
|   copy_highpage(filepage, swappage);
|   unlock_page(swappage);
|   put_page(swappage);
|   flush_dcache_page(filepage);
|   SetPageUptodate(filepage);
|   set_page_dirty(filepage);
|   swap_free(swap);
|  } else if (!(error = add_to_page_cache_locked(swappage, mapping,
|     idx, (((( gfp_t)0x20u)) & ~(( gfp_t)0x20u))))) {
|   info->flags |= 0x00000001;
|   shmem_swp_set(info, entry, 0);
|   shmem_swp_unmap(entry);
|   delete_from_swap_cache(swappage);
|   __st_spin_unlock_st__(&info->lock);
|   filepage = swappage;
|   set_page_dirty(filepage);
|   swap_free(swap);
|  } else {
|   shmem_swp_unmap(entry);
|   __st_spin_unlock_st__(&info->lock);
|   if (error == -12) {
|
|
|
|
|    error = mem_cgroup_shmem_charge_fallback(
|        swappage,
|        get_current()->mm,
|        gfp);
|    if (error) {
|     unlock_page(swappage);
|     put_page(swappage);
|     goto failed;
|    }
|   }
|   unlock_page(swappage);
|   put_page(swappage);
|   goto repeat;
|  }
| } else if (sgp == SGP_READ && !filepage) {
|  shmem_swp_unmap(entry);
|  filepage = find_get_page(mapping, idx);
|  if (filepage &&
|      (!PageUptodate(filepage) || !trylock_page(filepage))) {
|   __st_spin_unlock_st__(&info->lock);
|   wait_on_page_locked(filepage);
|   put_page(filepage);
|   filepage = ((void *)0);
|   goto repeat;
|  }
|  __st_spin_unlock_st__(&info->lock);
| } else {
|  shmem_swp_unmap(entry);
|  sbinfo = SHMEM_SB(inode->i_sb);
|  if (sbinfo->max_blocks) {
|   if ((percpu_counter_compare(&sbinfo->used_blocks, sbinfo->max_blocks) > 0) ||
|       shmem_acct_block(info->flags)) {
|    __st_spin_unlock_st__(&info->lock);
|    error = -28;
|    goto failed;
|   }
|   percpu_counter_inc(&sbinfo->used_blocks);
|   __st_spin_lock_st__(&inode->i_lock);
|   inode->i_blocks += (((1UL) << 12)/512);
|   __st_spin_unlock_st__(&inode->i_lock);
|  } else if (shmem_acct_block(info->flags)) {
|   __st_spin_unlock_st__(&info->lock);
|   error = -28;
|   goto failed;
|  }
|
|  if (!filepage) {
|   int ret;
|
|   if (!prealloc_page) {
|    __st_spin_unlock_st__(&info->lock);
|    filepage = shmem_alloc_page(gfp, info, idx);
|    if (!filepage) {
|     shmem_unacct_blocks(info->flags, 1);
|     shmem_free_blocks(inode, 1);
|     error = -12;
|     goto failed;
|    }
|    SetPageSwapBacked(filepage);
|
|
|
|
|
|    error = mem_cgroup_cache_charge(filepage,
|     get_current()->mm, __st_GFP_KERNEL_st__);
|    if (error) {
|     put_page(filepage);
|     shmem_unacct_blocks(info->flags, 1);
|     shmem_free_blocks(inode, 1);
|     filepage = ((void *)0);
|     goto failed;
|    }
|
|    __st_spin_lock_st__(&info->lock);
|   } else {
|    filepage = prealloc_page;
|    prealloc_page = ((void *)0);
|    SetPageSwapBacked(filepage);
|   }
|
|   entry = shmem_swp_alloc(info, idx, sgp);
|   if (IS_ERR(entry))
|    error = PTR_ERR(entry);
|   else {
|    swap = *entry;
|    shmem_swp_unmap(entry);
|   }
|   ret = error || swap.val;
|   if (ret)
|    mem_cgroup_uncharge_cache_page(filepage);
|   else
|    ret = add_to_page_cache_lru(filepage, mapping,
|      idx, (((( gfp_t)0x20u)) & ~(( gfp_t)0x20u)));
|
|
|
|
|   if (ret) {
|    __st_spin_unlock_st__(&info->lock);
|    put_page(filepage);
|    shmem_unacct_blocks(info->flags, 1);
|    shmem_free_blocks(inode, 1);
|    filepage = ((void *)0);
|    if (error)
|     goto failed;
|    goto repeat;
|   }
|   info->flags |= 0x00000001;
|  }
|
|  info->alloced++;
|  __st_spin_unlock_st__(&info->lock);
|  clear_highpage(filepage);
|  flush_dcache_page(filepage);
|  SetPageUptodate(filepage);
|  if (sgp == SGP_DIRTY)
|   set_page_dirty(filepage);
| }
|done:
| *pagep = filepage;
| error = 0;
| goto out;
|
|failed:
| if (*pagep != filepage) {
|  unlock_page(filepage);
|  put_page(filepage);
| }
|out:
| if (prealloc_page) {
|  mem_cgroup_uncharge_cache_page(prealloc_page);
|  put_page(prealloc_page);
| }
| return error;
|}
|
|static int shmem_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
|{
| struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
| int error;
| int ret;
|
| if (((loff_t)vmf->pgoff << 12) >= i_size_read(inode))
|  return 0x0002;
|
| error = shmem_getpage(inode, vmf->pgoff, &vmf->page, SGP_CACHE, &ret);
| if (error)
|  return ((error == -12) ? 0x0001 : 0x0002);
|
| return ret | 0x0200;
|}
|
|
|static int shmem_set_policy(struct vm_area_struct *vma, struct mempolicy *new)
|{
| struct inode *i = vma->vm_file->f_path.dentry->d_inode;
| return mpol_set_shared_policy(&SHMEM_I(i)->policy, vma, new);
|}
|
|static struct mempolicy *shmem_get_policy(struct vm_area_struct *vma,
|       unsigned long addr)
|{
| struct inode *i = vma->vm_file->f_path.dentry->d_inode;
| unsigned long idx;
|
| idx = ((addr - vma->vm_start) >> 12) + vma->vm_pgoff;
| return mpol_shared_policy_lookup(&SHMEM_I(i)->policy, idx);
|}
|
|
|int shmem_lock(struct file *file, int lock, struct user_struct *user)
|{
| struct inode *inode = file->f_path.dentry->d_inode;
| struct shmem_inode_info *info = SHMEM_I(inode);
| int retval = -12;
|
| __st_spin_lock_st__(&info->lock);
| if (lock && !(info->flags & 0x00002000)) {
|  if (!user_shm_lock(inode->i_size, user))
|   goto out_nomem;
|  info->flags |= 0x00002000;
|  mapping_set_unevictable(file->f_mapping);
| }
| if (!lock && (info->flags & 0x00002000) && user) {
|  user_shm_unlock(inode->i_size, user);
|  info->flags &= ~0x00002000;
|  mapping_clear_unevictable(file->f_mapping);
|  scan_mapping_unevictable_pages(file->f_mapping);
| }
| retval = 0;
|
|out_nomem:
| __st_spin_unlock_st__(&info->lock);
| return retval;
|}
|
|static int shmem_mmap(struct file *file, struct vm_area_struct *vma)
|{
| file_accessed(file);
| vma->vm_ops = &shmem_vm_ops;
| vma->vm_flags |= 0x08000000;
| return 0;
|}
|
|static struct inode *shmem_get_inode(struct super_block *sb, const struct inode *dir,
|         int mode, dev_t dev, unsigned long flags)
|{
| struct inode *inode;
| struct shmem_inode_info *info;
| struct shmem_sb_info *sbinfo = SHMEM_SB(sb);
|
| if (shmem_reserve_inode(sb))
|  return ((void *)0);
|
| inode = new_inode(sb);
| if (inode) {
|  inode->i_ino = get_next_ino();
|  inode_init_owner(inode, dir, mode);
|  inode->i_blocks = 0;
|  inode->i_mapping->backing_dev_info = &shmem_backing_dev_info;
|  inode->i_atime = inode->i_mtime = inode->i_ctime = (current_kernel_time());
|  inode->i_generation = get_seconds();
|  info = SHMEM_I(inode);
|  __st_memset_st__(info, 0, (char *)inode - (char *)info);
|  do { spinlock_check(&info->lock); do { static struct lock_class_key __key; __raw_spin_lock_init((&(&info->lock)->rlock), "&(&info->lock)->rlock", &__key); } while (0); } while (0);
|  info->flags = flags & 0x00200000;
|  INIT_LIST_HEAD(&info->swaplist);
|  cache_no_acl(inode);
|
|  switch (mode & 00170000) {
|  default:
|   inode->i_op = &shmem_special_inode_operations;
|   init_special_inode(inode, mode, dev);
|   break;
|  case 0100000:
|   inode->i_mapping->a_ops = &shmem_aops;
|   inode->i_op = &shmem_inode_operations;
|   inode->i_fop = &shmem_file_operations;
|   mpol_shared_policy_init(&info->policy,
|       shmem_get_sbmpol(sbinfo));
|   break;
|  case 0040000:
|   inc_nlink(inode);
|
|   inode->i_size = 2 * 20;
|   inode->i_op = &shmem_dir_inode_operations;
|   inode->i_fop = &simple_dir_operations;
|   break;
|  case 0120000:
|
|
|
|
|   mpol_shared_policy_init(&info->policy, ((void *)0));
|   break;
|  }
| } else
|  shmem_free_inode(sb);
| return inode;
|}
|
|
|static const struct inode_operations shmem_symlink_inode_operations;
|static const struct inode_operations shmem_symlink_inline_operations;
|
|
|
|
|
|
|static int shmem_readpage(struct file *file, struct page *page)
|{
| struct inode *inode = page->mapping->host;
| int error = shmem_getpage(inode, page->index, &page, SGP_CACHE, ((void *)0));
| unlock_page(page);
| return error;
|}
|
|static int
|shmem_write_begin(struct file *file, struct address_space *mapping,
|   loff_t pos, unsigned len, unsigned flags,
|   struct page **pagep, void **fsdata)
|{
| struct inode *inode = mapping->host;
| unsigned long index = pos >> 12;
| *pagep = ((void *)0);
| return shmem_getpage(inode, index, pagep, SGP_WRITE, ((void *)0));
|}
|
|static int
|shmem_write_end(struct file *file, struct address_space *mapping,
|   loff_t pos, unsigned len, unsigned copied,
|   struct page *page, void *fsdata)
|{
| struct inode *inode = mapping->host;
|
| if (pos + copied > inode->i_size)
|  i_size_write(inode, pos + copied);
|
| set_page_dirty(page);
| unlock_page(page);
| put_page(page);
|
| return copied;
|}
|
|static void do_shmem_file_read(struct file *filp, loff_t *ppos, read_descriptor_t *desc, read_actor_t actor)
|{
| struct inode *inode = filp->f_path.dentry->d_inode;
| struct address_space *mapping = inode->i_mapping;
| unsigned long index, offset;
| enum sgp_type sgp = SGP_READ;
|
|
|
|
|
|
| if ((((current_thread_info()->addr_limit)).seg == (((mm_segment_t) { (-1UL) })).seg))
|  sgp = SGP_DIRTY;
|
| index = *ppos >> 12;
| offset = *ppos & ~(~(((1UL) << 12)-1));
|
| for (;;) {
|  struct page *page = ((void *)0);
|  unsigned long end_index, nr, ret;
|  loff_t i_size = i_size_read(inode);
|
|  end_index = i_size >> 12;
|  if (index > end_index)
|   break;
|  if (index == end_index) {
|   nr = i_size & ~(~(((1UL) << 12)-1));
|   if (nr <= offset)
|    break;
|  }
|
|  desc->error = shmem_getpage(inode, index, &page, sgp, ((void *)0));
|  if (desc->error) {
|   if (desc->error == -22)
|    desc->error = 0;
|   break;
|  }
|  if (page)
|   unlock_page(page);
|
|
|
|
|
|  nr = ((1UL) << 12);
|  i_size = i_size_read(inode);
|  end_index = i_size >> 12;
|  if (index == end_index) {
|   nr = i_size & ~(~(((1UL) << 12)-1));
|   if (nr <= offset) {
|    if (page)
|     put_page(page);
|    break;
|   }
|  }
|  nr -= offset;
|
|  if (page) {
|
|
|
|
|
|   if (mapping_writably_mapped(mapping))
|    flush_dcache_page(page);
|
|
|
|   if (!offset)
|    mark_page_accessed(page);
|  } else {
|   page = ((((struct page *)(0xffffea0000000000UL)) + (__phys_addr((unsigned long)(empty_zero_page)) >> 12)));
|   get_page(page);
|  }
|  ret = actor(desc, page, offset, nr);
|  offset += ret;
|  index += offset >> 12;
|  offset &= ~(~(((1UL) << 12)-1));
|
|  put_page(page);
|  if (ret != nr || !desc->count)
|   break;
|
|  ({ __might_sleep("mm/.tmp_shmem.o.armored.c", 1774, 0); _cond_resched(); });
| }
|
| *ppos = ((loff_t) index << 12) + offset;
| file_accessed(filp);
|}
|
|static ssize_t shmem_file_aio_read(struct kiocb *iocb,
|  const struct iovec *iov, unsigned long nr_segs, loff_t pos)
|{
| struct file *filp = iocb->ki_filp;
| ssize_t retval;
| unsigned long seg;
| size_t count;
| loff_t *ppos = &iocb->ki_pos;
|
| retval = generic_segment_checks(iov, &nr_segs, &count, 1);
| if (retval)
|  return retval;
|
| for (seg = 0; seg < nr_segs; seg++) {
|  read_descriptor_t desc;
|
|  desc.written = 0;
|  desc.arg.buf = iov[seg].iov_base;
|  desc.count = iov[seg].iov_len;
|  if (desc.count == 0)
|   continue;
|  desc.error = 0;
|  do_shmem_file_read(filp, ppos, &desc, file_read_actor);
|  retval += desc.written;
|  if (desc.error) {
|   retval = retval ?: desc.error;
|   break;
|  }
|  if (desc.count > 0)
|   break;
| }
| return retval;
|}
|
|static int shmem_statfs(struct dentry *dentry, struct kstatfs *buf)
|{
| struct shmem_sb_info *sbinfo = SHMEM_SB(dentry->d_sb);
|
| buf->f_type = 0x01021994;
| buf->f_bsize = ((1UL) << 12);
| buf->f_namelen = 255;
| if (sbinfo->max_blocks) {
|  buf->f_blocks = sbinfo->max_blocks;
|  buf->f_bavail = buf->f_bfree =
|    sbinfo->max_blocks - percpu_counter_sum(&sbinfo->used_blocks);
| }
| if (sbinfo->max_inodes) {
|  buf->f_files = sbinfo->max_inodes;
|  buf->f_ffree = sbinfo->free_inodes;
| }
|
| return 0;
|}
|
|
|
|
|static int
|shmem_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
|{
| struct inode *inode;
| int error = -28;
|
| inode = shmem_get_inode(dir->i_sb, dir, mode, dev, 0x00200000);
| if (inode) {
|  error = security_inode_init_security(inode, dir, ((void *)0), ((void *)0),
|           ((void *)0));
|  if (error) {
|   if (error != -95) {
|    iput(inode);
|    return error;
|   }
|  }
|
|  error = generic_acl_init(inode, dir);
|  if (error) {
|   iput(inode);
|   return error;
|  }
|
|
|
|  dir->i_size += 20;
|  dir->i_ctime = dir->i_mtime = (current_kernel_time());
|  d_instantiate(dentry, inode);
|  dget(dentry);
| }
| return error;
|}
|
|static int shmem_mkdir(struct inode *dir, struct dentry *dentry, int mode)
|{
| int error;
|
| if ((error = shmem_mknod(dir, dentry, mode | 0040000, 0)))
|  return error;
| inc_nlink(dir);
| return 0;
|}
|
|static int shmem_create(struct inode *dir, struct dentry *dentry, int mode,
|  struct nameidata *nd)
|{
| return shmem_mknod(dir, dentry, mode | 0100000, 0);
|}
|
|
|
|
|static int shmem_link(struct dentry *old_dentry, struct inode *dir, struct dentry *dentry)
|{
| struct inode *inode = old_dentry->d_inode;
| int ret;
|
|
|
|
|
|
| ret = shmem_reserve_inode(inode->i_sb);
| if (ret)
|  goto out;
|
| dir->i_size += 20;
| inode->i_ctime = dir->i_ctime = dir->i_mtime = (current_kernel_time());
| inc_nlink(inode);
| ihold(inode);
| dget(dentry);
| d_instantiate(dentry, inode);
|out:
| return ret;
|}
|
|static int shmem_unlink(struct inode *dir, struct dentry *dentry)
|{
| struct inode *inode = dentry->d_inode;
|
| if (inode->i_nlink > 1 && !(((inode->i_mode) & 00170000) == 0040000))
|  shmem_free_inode(inode->i_sb);
|
| dir->i_size -= 20;
| inode->i_ctime = dir->i_ctime = dir->i_mtime = (current_kernel_time());
| drop_nlink(inode);
| dput(dentry);
| return 0;
|}
|
|static int shmem_rmdir(struct inode *dir, struct dentry *dentry)
|{
| if (!simple_empty(dentry))
|  return -39;
|
| drop_nlink(dentry->d_inode);
| drop_nlink(dir);
| return shmem_unlink(dir, dentry);
|}
|
|
|
|
|
|
|
|static int shmem_rename(struct inode *old_dir, struct dentry *old_dentry, struct inode *new_dir, struct dentry *new_dentry)
|{
| struct inode *inode = old_dentry->d_inode;
| int they_are_dirs = (((inode->i_mode) & 00170000) == 0040000);
|
| if (!simple_empty(new_dentry))
|  return -39;
|
| if (new_dentry->d_inode) {
|  (void) shmem_unlink(new_dir, new_dentry);
|  if (they_are_dirs)
|   drop_nlink(old_dir);
| } else if (they_are_dirs) {
|  drop_nlink(old_dir);
|  inc_nlink(new_dir);
| }
|
| old_dir->i_size -= 20;
| new_dir->i_size += 20;
| old_dir->i_ctime = old_dir->i_mtime =
| new_dir->i_ctime = new_dir->i_mtime =
| inode->i_ctime = (current_kernel_time());
| return 0;
|}
|
|static int shmem_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
|{
| int error;
| int len;
| struct inode *inode;
| struct page *page = ((void *)0);
| char *kaddr;
| struct shmem_inode_info *info;
|
| len = strlen(symname) + 1;
| if (len > ((1UL) << 12))
|  return -36;
|
| inode = shmem_get_inode(dir->i_sb, dir, 0120000|(00700|00070|00007), 0, 0x00200000);
| if (!inode)
|  return -28;
|
| error = security_inode_init_security(inode, dir, ((void *)0), ((void *)0),
|          ((void *)0));
| if (error) {
|  if (error != -95) {
|   iput(inode);
|   return error;
|  }
|  error = 0;
| }
|
| info = SHMEM_I(inode);
| inode->i_size = len-1;
| if (len <= (char *)inode - (char *)info) {
|
|  __st_memcpy_st__(info, symname, len);
|  inode->i_op = &shmem_symlink_inline_operations;
| } else {
|  error = shmem_getpage(inode, 0, &page, SGP_WRITE, ((void *)0));
|  if (error) {
|   iput(inode);
|   return error;
|  }
|  inode->i_mapping->a_ops = &shmem_aops;
|  inode->i_op = &shmem_symlink_inode_operations;
|  kaddr = __kmap_atomic(page);
|  __st_memcpy_st__(kaddr, symname, len);
|  do { ((void)(sizeof(struct { int:-!!(0); }))); __kunmap_atomic(kaddr); } while (0);
|  set_page_dirty(page);
|  unlock_page(page);
|  put_page(page);
| }
| dir->i_size += 20;
| dir->i_ctime = dir->i_mtime = (current_kernel_time());
| d_instantiate(dentry, inode);
| dget(dentry);
| return 0;
|}
|
|static void *shmem_follow_link_inline(struct dentry *dentry, struct nameidata *nd)
|{
| nd_set_link(nd, (char *)SHMEM_I(dentry->d_inode));
| return ((void *)0);
|}
|
|static void *shmem_follow_link(struct dentry *dentry, struct nameidata *nd)
|{
| struct page *page = ((void *)0);
| int res = shmem_getpage(dentry->d_inode, 0, &page, SGP_READ, ((void *)0));
| nd_set_link(nd, res ? ERR_PTR(res) : kmap(page));
| if (page)
|  unlock_page(page);
| return page;
|}
|
|static void shmem_put_link(struct dentry *dentry, struct nameidata *nd, void *cookie)
|{
| if (!IS_ERR(nd_get_link(nd))) {
|  struct page *page = cookie;
|  kunmap(page);
|  mark_page_accessed(page);
|  put_page(page);
| }
|}
|
|static const struct inode_operations shmem_symlink_inline_operations = {
| .readlink = generic_readlink,
| .follow_link = shmem_follow_link_inline,
|};
|
|static const struct inode_operations shmem_symlink_inode_operations = {
| .readlink = generic_readlink,
| .follow_link = shmem_follow_link,
| .put_link = shmem_put_link,
|};
|static size_t shmem_xattr_security_list(struct dentry *dentry, char *list,
|     size_t list_len, const char *name,
|     size_t name_len, int handler_flags)
|{
| return security_inode_listsecurity(dentry->d_inode, list, list_len);
|}
|
|static int shmem_xattr_security_get(struct dentry *dentry, const char *name,
|  void *buffer, size_t size, int handler_flags)
|{
| if (strcmp(name, "") == 0)
|  return -22;
| return xattr_getsecurity(dentry->d_inode, name, buffer, size);
|}
|
|static int shmem_xattr_security_set(struct dentry *dentry, const char *name,
|  const void *value, size_t size, int flags, int handler_flags)
|{
| if (strcmp(name, "") == 0)
|  return -22;
| return security_inode_setsecurity(dentry->d_inode, name, value,
|       size, flags);
|}
|
|static const struct xattr_handler shmem_xattr_security_handler = {
| .prefix = "security.",
| .list = shmem_xattr_security_list,
| .get = shmem_xattr_security_get,
| .set = shmem_xattr_security_set,
|};
|
|static const struct xattr_handler *shmem_xattr_handlers[] = {
| &generic_acl_access_handler,
| &generic_acl_default_handler,
| &shmem_xattr_security_handler,
| ((void *)0)
|};
|
|
|static struct dentry *shmem_get_parent(struct dentry *child)
|{
| return ERR_PTR(-116);
|}
|
|static int shmem_match(struct inode *ino, void *vfh)
|{
| __u32 *fh = vfh;
| __u64 inum = fh[2];
| inum = (inum << 32) | fh[1];
| return ino->i_ino == inum && fh[0] == ino->i_generation;
|}
|
|static struct dentry *shmem_fh_to_dentry(struct super_block *sb,
|  struct fid *fid, int fh_len, int fh_type)
|{
| struct inode *inode;
| struct dentry *dentry = ((void *)0);
| u64 inum = fid->raw[2];
| inum = (inum << 32) | fid->raw[1];
|
| if (fh_len < 3)
|  return ((void *)0);
|
| inode = ilookup5(sb, (unsigned long)(inum + fid->raw[0]),
|   shmem_match, fid->raw);
| if (inode) {
|  dentry = d_find_alias(inode);
|  iput(inode);
| }
|
| return dentry;
|}
|
|static int shmem_encode_fh(struct dentry *dentry, __u32 *fh, int *len,
|    int connectable)
|{
| struct inode *inode = dentry->d_inode;
|
| if (*len < 3)
|  return 255;
|
| if (inode_unhashed(inode)) {
|
|
|
|
|
|  static spinlock_t lock = (spinlock_t ) { { .rlock = { .raw_lock = { 0 }, .magic = 0xdead4ead, .owner_cpu = -1, .owner = ((void *)-1L), .dep_map = { .name = "lock" } } } };
|  __st_spin_lock_st__(&lock);
|  if (inode_unhashed(inode))
|   __insert_inode_hash(inode,
|         inode->i_ino + inode->i_generation);
|  __st_spin_unlock_st__(&lock);
| }
|
| fh[0] = inode->i_generation;
| fh[1] = inode->i_ino;
| fh[2] = ((__u64)inode->i_ino) >> 32;
|
| *len = 3;
| return 1;
|}
|
|static const struct export_operations shmem_export_ops = {
| .get_parent = shmem_get_parent,
| .encode_fh = shmem_encode_fh,
| .fh_to_dentry = shmem_fh_to_dentry,
|};
|
|static int shmem_parse_options(char *options, struct shmem_sb_info *sbinfo,
|          bool remount)
|{
| char *this_char, *value, *rest;
|
| while (options != ((void *)0)) {
|  this_char = options;
|  for (;;) {
|
|
|
|
|
|   options = strchr(options, ',');
|   if (options == ((void *)0))
|    break;
|   options++;
|   if (!(((_ctype[(int)(unsigned char)(*options)])&(0x04)) != 0)) {
|    options[-1] = '\0';
|    break;
|   }
|  }
|  if (!*this_char)
|   continue;
|  if ((value = strchr(this_char,'=')) != ((void *)0)) {
|   *value++ = 0;
|  } else {
|   printk("<3>"
|       "tmpfs: No value for mount option '%s'\n",
|       this_char);
|   return 1;
|  }
|
|  if (!strcmp(this_char,"size")) {
|   unsigned long long size;
|   size = memparse(value,&rest);
|   if (*rest == '%') {
|    size <<= 12;
|    size *= totalram_pages;
|    ({ uint32_t __base = (100); uint32_t __rem; __rem = ((uint64_t)(size)) % __base; (size) = ((uint64_t)(size)) / __base; __rem; });
|    rest++;
|   }
|   if (*rest)
|    goto bad_val;
|   sbinfo->max_blocks =
|    (((size) + (((1UL) << 12)) - 1) / (((1UL) << 12)));
|  } else if (!strcmp(this_char,"nr_blocks")) {
|   sbinfo->max_blocks = memparse(value, &rest);
|   if (*rest)
|    goto bad_val;
|  } else if (!strcmp(this_char,"nr_inodes")) {
|   sbinfo->max_inodes = memparse(value, &rest);
|   if (*rest)
|    goto bad_val;
|  } else if (!strcmp(this_char,"mode")) {
|   if (remount)
|    continue;
|   sbinfo->mode = simple_strtoul(value, &rest, 8) & 07777;
|   if (*rest)
|    goto bad_val;
|  } else if (!strcmp(this_char,"uid")) {
|   if (remount)
|    continue;
|   sbinfo->uid = simple_strtoul(value, &rest, 0);
|   if (*rest)
|    goto bad_val;
|  } else if (!strcmp(this_char,"gid")) {
|   if (remount)
|    continue;
|   sbinfo->gid = simple_strtoul(value, &rest, 0);
|   if (*rest)
|    goto bad_val;
|  } else if (!strcmp(this_char,"mpol")) {
|   if (mpol_parse_str(value, &sbinfo->mpol, 1))
|    goto bad_val;
|  } else {
|   printk("<3>" "tmpfs: Bad mount option %s\n",
|          this_char);
|   return 1;
|  }
| }
| return 0;
|
|bad_val:
| printk("<3>" "tmpfs: Bad value '%s' for mount option '%s'\n",
|        value, this_char);
| return 1;
|
|}
|
|static int shmem_remount_fs(struct super_block *sb, int *flags, char *data)
|{
| struct shmem_sb_info *sbinfo = SHMEM_SB(sb);
| struct shmem_sb_info config = *sbinfo;
| unsigned long inodes;
| int error = -22;
|
| if (shmem_parse_options(data, &config, true))
|  return error;
|
| __st_spin_lock_st__(&sbinfo->stat_lock);
| inodes = sbinfo->max_inodes - sbinfo->free_inodes;
| if (percpu_counter_compare(&sbinfo->used_blocks, config.max_blocks) > 0)
|  goto out;
| if (config.max_inodes < inodes)
|  goto out;
|
|
|
|
|
|
| if (config.max_blocks && !sbinfo->max_blocks)
|  goto out;
| if (config.max_inodes && !sbinfo->max_inodes)
|  goto out;
|
| error = 0;
| sbinfo->max_blocks = config.max_blocks;
| sbinfo->max_inodes = config.max_inodes;
| sbinfo->free_inodes = config.max_inodes - inodes;
|
| mpol_put(sbinfo->mpol);
| sbinfo->mpol = config.mpol;
|out:
| __st_spin_unlock_st__(&sbinfo->stat_lock);
| return error;
|}
|
|static int shmem_show_options(struct seq_file *seq, struct vfsmount *vfs)
|{
| struct shmem_sb_info *sbinfo = SHMEM_SB(vfs->mnt_sb);
|
| if (sbinfo->max_blocks != shmem_default_max_blocks())
|  seq_printf(seq, ",size=%luk",
|   sbinfo->max_blocks << (12 - 10));
| if (sbinfo->max_inodes != shmem_default_max_inodes())
|  seq_printf(seq, ",nr_inodes=%lu", sbinfo->max_inodes);
| if (sbinfo->mode != ((00700|00070|00007) | 0001000))
|  seq_printf(seq, ",mode=%03o", sbinfo->mode);
| if (sbinfo->uid != 0)
|  seq_printf(seq, ",uid=%u", sbinfo->uid);
| if (sbinfo->gid != 0)
|  seq_printf(seq, ",gid=%u", sbinfo->gid);
| shmem_show_mpol(seq, sbinfo->mpol);
| return 0;
|}
|
|
|static void shmem_put_super(struct super_block *sb)
|{
| struct shmem_sb_info *sbinfo = SHMEM_SB(sb);
|
| percpu_counter_destroy(&sbinfo->used_blocks);
| kfree(sbinfo);
| sb->s_fs_info = ((void *)0);
|}
|
|int shmem_fill_super(struct super_block *sb, void *data, int silent)
|{
| struct inode *inode;
| struct dentry *root;
| struct shmem_sb_info *sbinfo;
| int err = -12;
|
|
| sbinfo = kzalloc(({ typeof((int)sizeof(struct shmem_sb_info)) _max1 = ((int)sizeof(struct shmem_sb_info)); typeof((1 << (6))) _max2 = ((1 << (6))); (void) (&_max1 == &_max2); _max1 > _max2 ? _max1 : _max2; })
|                   , __st_GFP_KERNEL_st__);
| if (!sbinfo)
|  return -12;
|
| sbinfo->mode = (00700|00070|00007) | 0001000;
| sbinfo->uid = (({ get_current()->cred->fsuid; }));
| sbinfo->gid = (({ get_current()->cred->fsgid; }));
| sb->s_fs_info = sbinfo;
|
|
|
|
|
|
|
| if (!(sb->s_flags & (1<<31))) {
|  sbinfo->max_blocks = shmem_default_max_blocks();
|  sbinfo->max_inodes = shmem_default_max_inodes();
|  if (shmem_parse_options(data, sbinfo, false)) {
|   err = -22;
|   goto failed;
|  }
| }
| sb->s_export_op = &shmem_export_ops;
|
|
|
|
| do { spinlock_check(&sbinfo->stat_lock); do { static struct lock_class_key __key; __raw_spin_lock_init((&(&sbinfo->stat_lock)->rlock), "&(&sbinfo->stat_lock)->rlock", &__key); } while (0); } while (0);
| if (({ static struct lock_class_key __key; __percpu_counter_init(&sbinfo->used_blocks, 0, &__key); }))
|  goto failed;
| sbinfo->free_inodes = sbinfo->max_inodes;
|
| sb->s_maxbytes = ({ unsigned long long __min1 = (((16 + (((unsigned long long)(((1UL) << 12)/sizeof(unsigned long))*(((1UL) << 12)/sizeof(unsigned long)))/2) * ((((1UL) << 12)/sizeof(unsigned long))+1)) << 12)); unsigned long long __min2 = (0x7fffffffffffffffUL); __min1 < __min2 ? __min1: __min2; });
| sb->s_blocksize = ((1UL) << 12);
| sb->s_blocksize_bits = 12;
| sb->s_magic = 0x01021994;
| sb->s_op = &shmem_ops;
| sb->s_time_gran = 1;
|
| sb->s_xattr = shmem_xattr_handlers;
| sb->s_flags |= (1<<16);
|
|
| inode = shmem_get_inode(sb, ((void *)0), 0040000 | sbinfo->mode, 0, 0x00200000);
| if (!inode)
|  goto failed;
| inode->i_uid = sbinfo->uid;
| inode->i_gid = sbinfo->gid;
| root = d_alloc_root(inode);
| if (!root)
|  goto failed_iput;
| sb->s_root = root;
| return 0;
|
|failed_iput:
| iput(inode);
|failed:
| shmem_put_super(sb);
| return err;
|}
|
|static struct kmem_cache *shmem_inode_cachep;
|
|static struct inode *shmem_alloc_inode(struct super_block *sb)
|{
| struct shmem_inode_info *p;
| p = (struct shmem_inode_info *)kmem_cache_alloc(shmem_inode_cachep, __st_GFP_KERNEL_st__);
| if (!p)
|  return ((void *)0);
| return &p->vfs_inode;
|}
|
|static void shmem_destroy_inode(struct inode *inode)
|{
| if ((inode->i_mode & 00170000) == 0100000) {
|
|  mpol_free_shared_policy(&SHMEM_I(inode)->policy);
| }
| kmem_cache_free(shmem_inode_cachep, SHMEM_I(inode));
|}
|
|static void init_once(void *foo)
|{
| struct shmem_inode_info *p = (struct shmem_inode_info *) foo;
|
| inode_init_once(&p->vfs_inode);
|}
|
|static int init_inodecache(void)
|{
| shmem_inode_cachep = kmem_cache_create("shmem_inode_cache",
|    sizeof(struct shmem_inode_info),
|    0, 0x00040000UL, init_once);
| return 0;
|}
|
|static void destroy_inodecache(void)
|{
| kmem_cache_destroy(shmem_inode_cachep);
|}
|
|static const struct address_space_operations shmem_aops = {
| .writepage = shmem_writepage,
| .set_page_dirty = __set_page_dirty_no_writeback,
|
| .readpage = shmem_readpage,
| .write_begin = shmem_write_begin,
| .write_end = shmem_write_end,
|
| .migratepage = migrate_page,
| .error_remove_page = generic_error_remove_page,
|};
|
|static const struct file_operations shmem_file_operations = {
| .mmap = shmem_mmap,
|
| .llseek = generic_file_llseek,
| .read = do_sync_read,
| .write = do_sync_write,
| .aio_read = shmem_file_aio_read,
| .aio_write = generic_file_aio_write,
| .fsync = noop_fsync,
| .splice_read = generic_file_splice_read,
| .splice_write = generic_file_splice_write,
|
|};
|
|static const struct inode_operations shmem_inode_operations = {
| .setattr = shmem_notify_change,
| .truncate_range = shmem_truncate_range,
|
| .setxattr = generic_setxattr,
| .getxattr = generic_getxattr,
| .listxattr = generic_listxattr,
| .removexattr = generic_removexattr,
| .check_acl = generic_check_acl,
|
|
|};
|
|static const struct inode_operations shmem_dir_inode_operations = {
|
| .create = shmem_create,
| .lookup = simple_lookup,
| .link = shmem_link,
| .unlink = shmem_unlink,
| .symlink = shmem_symlink,
| .mkdir = shmem_mkdir,
| .rmdir = shmem_rmdir,
| .mknod = shmem_mknod,
| .rename = shmem_rename,
|
|
| .setattr = shmem_notify_change,
| .setxattr = generic_setxattr,
| .getxattr = generic_getxattr,
| .listxattr = generic_listxattr,
| .removexattr = generic_removexattr,
| .check_acl = generic_check_acl,
|
|};
|
|static const struct inode_operations shmem_special_inode_operations = {
|
| .setattr = shmem_notify_change,
| .setxattr = generic_setxattr,
| .getxattr = generic_getxattr,
| .listxattr = generic_listxattr,
| .removexattr = generic_removexattr,
| .check_acl = generic_check_acl,
|
|};
|
|static const struct super_operations shmem_ops = {
| .alloc_inode = shmem_alloc_inode,
| .destroy_inode = shmem_destroy_inode,
|
| .statfs = shmem_statfs,
| .remount_fs = shmem_remount_fs,
| .show_options = shmem_show_options,
|
| .evict_inode = shmem_evict_inode,
| .drop_inode = generic_delete_inode,
| .put_super = shmem_put_super,
|};
|
|static const struct vm_operations_struct shmem_vm_ops = {
| .fault = shmem_fault,
|
| .set_policy = shmem_set_policy,
| .get_policy = shmem_get_policy,
|
|};
|
|
|static struct dentry *shmem_mount(struct file_system_type *fs_type,
| int flags, const char *dev_name, void *data)
|{
| return mount_nodev(fs_type, flags, data, shmem_fill_super);
|}
|
|static struct file_system_type tmpfs_fs_type = {
| .owner = ((struct module *)0),
| .name = "tmpfs",
| .mount = shmem_mount,
| .kill_sb = kill_litter_super,
|};
|
|int init_tmpfs(void)
|{
| int error;
|
| error = bdi_init(&shmem_backing_dev_info);
| if (error)
|  goto out4;
|
| error = init_inodecache();
| if (error)
|  goto out3;
|
| error = register_filesystem(&tmpfs_fs_type);
| if (error) {
|  printk("<3>" "Could not register tmpfs\n");
|  goto out2;
| }
|
| shm_mnt = vfs_kern_mount(&tmpfs_fs_type, (1<<31),
|    tmpfs_fs_type.name, ((void *)0));
| if (IS_ERR(shm_mnt)) {
|  error = PTR_ERR(shm_mnt);
|  printk("<3>" "Could not kern_mount tmpfs\n");
|  goto out1;
| }
| return 0;
|
|out1:
| unregister_filesystem(&tmpfs_fs_type);
|out2:
| destroy_inodecache();
|out3:
| bdi_destroy(&shmem_backing_dev_info);
|out4:
| shm_mnt = ERR_PTR(error);
| return error;
|}
|void mem_cgroup_get_shmem_target(struct inode *inode, unsigned long pgoff,
|     struct page **pagep, swp_entry_t *ent)
|{
| swp_entry_t entry = { .val = 0 }, *ptr;
| struct page *page = ((void *)0);
| struct shmem_inode_info *info = SHMEM_I(inode);
|
| if ((pgoff << 12) >= i_size_read(inode))
|  goto out;
|
| __st_spin_lock_st__(&info->lock);
| ptr = shmem_swp_entry(info, pgoff, ((void *)0));
|
| if (ptr && ptr->val) {
|  entry.val = ptr->val;
|  page = find_get_page(&swapper_space, entry.val);
| } else
|
|  page = find_get_page(inode->i_mapping, pgoff);
| if (ptr)
|  shmem_swp_unmap(ptr);
| __st_spin_unlock_st__(&info->lock);
|out:
| *pagep = page;
| *ent = entry;
|}
|struct file *shmem_file_setup(const char *name, loff_t size, unsigned long flags)
|{
| int error;
| struct file *file;
| struct inode *inode;
| struct path path;
| struct dentry *root;
| struct qstr this;
|
| if (IS_ERR(shm_mnt))
|  return (void *)shm_mnt;
|
| if (size < 0 || size > ({ unsigned long long __min1 = (((16 + (((unsigned long long)(((1UL) << 12)/sizeof(unsigned long))*(((1UL) << 12)/sizeof(unsigned long)))/2) * ((((1UL) << 12)/sizeof(unsigned long))+1)) << 12)); unsigned long long __min2 = (0x7fffffffffffffffUL); __min1 < __min2 ? __min1: __min2; }))
|  return ERR_PTR(-22);
|
| if (shmem_acct_size(flags, size))
|  return ERR_PTR(-12);
|
| error = -12;
| this.name = name;
| this.len = strlen(name);
| this.hash = 0;
| root = shm_mnt->mnt_root;
| path.dentry = d_alloc(root, &this);
| if (!path.dentry)
|  goto put_memory;
| path.mnt = mntget(shm_mnt);
|
| error = -28;
| inode = shmem_get_inode(root->d_sb, ((void *)0), 0100000 | (00700|00070|00007), 0, flags);
| if (!inode)
|  goto put_dentry;
|
| d_instantiate(path.dentry, inode);
| inode->i_size = size;
| inode->i_nlink = 0;
|
|
|
|
|
|
| error = -23;
| file = alloc_file(&path, (( fmode_t)0x2) | (( fmode_t)0x1),
|    &shmem_file_operations);
| if (!file)
|  goto put_dentry;
|
| return file;
|
|put_dentry:
| path_put(&path);
|put_memory:
| shmem_unacct_size(flags, size);
| return ERR_PTR(error);
|}
|extern typeof(shmem_file_setup) shmem_file_setup; extern void *__crc_shmem_file_setup ; static const unsigned long __kcrctab_shmem_file_setup = (unsigned long) &__crc_shmem_file_setup; static const char __kstrtab_shmem_file_setup[] = "" "shmem_file_setup"; static const struct kernel_symbol __ksymtab_shmem_file_setup = { (unsigned long)&shmem_file_setup, __kstrtab_shmem_file_setup };
|
|
|
|
|
|int shmem_zero_setup(struct vm_area_struct *vma)
|{
| struct file *file;
| loff_t size = vma->vm_end - vma->vm_start;
|
| file = shmem_file_setup("dev/zero", size, vma->vm_flags);
| if (IS_ERR(file))
|  return PTR_ERR(file);
|
| if (vma->vm_file)
|  fput(vma->vm_file);
| vma->vm_file = file;
| vma->vm_ops = &shmem_vm_ops;
| return 0;
|}