Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: GPL-2.0-only */
       2                 :            : /*
       3                 :            :  * fs/kernfs/kernfs-internal.h - kernfs internal header file
       4                 :            :  *
       5                 :            :  * Copyright (c) 2001-3 Patrick Mochel
       6                 :            :  * Copyright (c) 2007 SUSE Linux Products GmbH
       7                 :            :  * Copyright (c) 2007, 2013 Tejun Heo <teheo@suse.de>
       8                 :            :  */
       9                 :            : 
      10                 :            : #ifndef __KERNFS_INTERNAL_H
      11                 :            : #define __KERNFS_INTERNAL_H
      12                 :            : 
      13                 :            : #include <linux/lockdep.h>
      14                 :            : #include <linux/fs.h>
      15                 :            : #include <linux/mutex.h>
      16                 :            : #include <linux/xattr.h>
      17                 :            : 
      18                 :            : #include <linux/kernfs.h>
      19                 :            : #include <linux/fs_context.h>
      20                 :            : 
      21                 :            : struct kernfs_iattrs {
      22                 :            :         kuid_t                  ia_uid;
      23                 :            :         kgid_t                  ia_gid;
      24                 :            :         struct timespec64       ia_atime;
      25                 :            :         struct timespec64       ia_mtime;
      26                 :            :         struct timespec64       ia_ctime;
      27                 :            : 
      28                 :            :         struct simple_xattrs    xattrs;
      29                 :            : };
      30                 :            : 
      31                 :            : /* +1 to avoid triggering overflow warning when negating it */
      32                 :            : #define KN_DEACTIVATED_BIAS             (INT_MIN + 1)
      33                 :            : 
      34                 :            : /* KERNFS_TYPE_MASK and types are defined in include/linux/kernfs.h */
      35                 :            : 
      36                 :            : /**
      37                 :            :  * kernfs_root - find out the kernfs_root a kernfs_node belongs to
      38                 :            :  * @kn: kernfs_node of interest
      39                 :            :  *
      40                 :            :  * Return the kernfs_root @kn belongs to.
      41                 :            :  */
      42                 :     478819 : static inline struct kernfs_root *kernfs_root(struct kernfs_node *kn)
      43                 :            : {
      44                 :            :         /* if parent exists, it's always a dir; otherwise, @sd is a dir */
      45   [ +  +  +  +  :     477048 :         if (kn->parent)
          +  -  +  +  +  
          -  +  +  +  -  
          +  -  +  -  -  
                -  -  + ]
      46                 :     461180 :                 kn = kn->parent;
      47   [ +  +  +  +  :     478819 :         return kn->dir.root;
          +  +  +  +  +  
                -  +  - ]
      48                 :            : }
      49                 :            : 
      50                 :            : /*
      51                 :            :  * mount.c
      52                 :            :  */
      53                 :            : struct kernfs_super_info {
      54                 :            :         struct super_block      *sb;
      55                 :            : 
      56                 :            :         /*
      57                 :            :          * The root associated with this super_block.  Each super_block is
      58                 :            :          * identified by the root and ns it's associated with.
      59                 :            :          */
      60                 :            :         struct kernfs_root      *root;
      61                 :            : 
      62                 :            :         /*
      63                 :            :          * Each sb is associated with one namespace tag, currently the
      64                 :            :          * network namespace of the task which mounted this kernfs
      65                 :            :          * instance.  If multiple tags become necessary, make the following
      66                 :            :          * an array and compare kernfs_node tag against every entry.
      67                 :            :          */
      68                 :            :         const void              *ns;
      69                 :            : 
      70                 :            :         /* anchored at kernfs_root->supers, protected by kernfs_mutex */
      71                 :            :         struct list_head        node;
      72                 :            : };
      73                 :            : #define kernfs_info(SB) ((struct kernfs_super_info *)(SB->s_fs_info))
      74                 :            : 
      75                 :     778293 : static inline struct kernfs_node *kernfs_dentry_node(struct dentry *dentry)
      76                 :            : {
      77   [ +  -  +  -  :     778293 :         if (d_really_is_negative(dentry))
             +  -  +  - ]
      78                 :            :                 return NULL;
      79                 :     778293 :         return d_inode(dentry)->i_private;
      80                 :            : }
      81                 :            : 
      82                 :            : extern const struct super_operations kernfs_sops;
      83                 :            : extern struct kmem_cache *kernfs_node_cache, *kernfs_iattrs_cache;
      84                 :            : 
      85                 :            : /*
      86                 :            :  * inode.c
      87                 :            :  */
      88                 :            : extern const struct xattr_handler *kernfs_xattr_handlers[];
      89                 :            : void kernfs_evict_inode(struct inode *inode);
      90                 :            : int kernfs_iop_permission(struct inode *inode, int mask);
      91                 :            : int kernfs_iop_setattr(struct dentry *dentry, struct iattr *iattr);
      92                 :            : int kernfs_iop_getattr(const struct path *path, struct kstat *stat,
      93                 :            :                        u32 request_mask, unsigned int query_flags);
      94                 :            : ssize_t kernfs_iop_listxattr(struct dentry *dentry, char *buf, size_t size);
      95                 :            : int __kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr);
      96                 :            : 
      97                 :            : /*
      98                 :            :  * dir.c
      99                 :            :  */
     100                 :            : extern struct mutex kernfs_mutex;
     101                 :            : extern const struct dentry_operations kernfs_dops;
     102                 :            : extern const struct file_operations kernfs_dir_fops;
     103                 :            : extern const struct inode_operations kernfs_dir_iops;
     104                 :            : 
     105                 :            : struct kernfs_node *kernfs_get_active(struct kernfs_node *kn);
     106                 :            : void kernfs_put_active(struct kernfs_node *kn);
     107                 :            : int kernfs_add_one(struct kernfs_node *kn);
     108                 :            : struct kernfs_node *kernfs_new_node(struct kernfs_node *parent,
     109                 :            :                                     const char *name, umode_t mode,
     110                 :            :                                     kuid_t uid, kgid_t gid,
     111                 :            :                                     unsigned flags);
     112                 :            : 
     113                 :            : /*
     114                 :            :  * file.c
     115                 :            :  */
     116                 :            : extern const struct file_operations kernfs_file_fops;
     117                 :            : 
     118                 :            : void kernfs_drain_open_files(struct kernfs_node *kn);
     119                 :            : 
     120                 :            : /*
     121                 :            :  * symlink.c
     122                 :            :  */
     123                 :            : extern const struct inode_operations kernfs_symlink_iops;
     124                 :            : 
     125                 :            : #endif  /* __KERNFS_INTERNAL_H */