LXR linux/include/linux/fscrypt

   1/*
   2 * fscrypt_notsupp.h
   3 *
   4 * This stubs out the fscrypt functions for filesystems configured without
   5 * encryption support.
   6 */
   7
   8#ifndef _LINUX_FSCRYPT_NOTSUPP_H
   9#define _LINUX_FSCRYPT_NOTSUPP_H
  10
  11#include <linux/fscrypt_common.h>
  12
  13/* crypto.c */
  14static inline struct fscrypt_ctx *fscrypt_get_ctx(const struct inode *inode,
  15                                                  gfp_t gfp_flags)
  16{
  17        return ERR_PTR(-EOPNOTSUPP);
  18}
  19
  20static inline void fscrypt_release_ctx(struct fscrypt_ctx *ctx)
  21{
  22        return;
  23}
  24
  25static inline struct page *fscrypt_encrypt_page(const struct inode *inode,
  26                                                struct page *page,
  27                                                unsigned int len,
  28                                                unsigned int offs,
  29                                                u64 lblk_num, gfp_t gfp_flags)
  30{
  31        return ERR_PTR(-EOPNOTSUPP);
  32}
  33
  34static inline int fscrypt_decrypt_page(const struct inode *inode,
  35                                       struct page *page,
  36                                       unsigned int len, unsigned int offs,
  37                                       u64 lblk_num)
  38{
  39        return -EOPNOTSUPP;
  40}
  41
  42
  43static inline void fscrypt_restore_control_page(struct page *page)
  44{
  45        return;
  46}
  47
  48static inline void fscrypt_set_d_op(struct dentry *dentry)
  49{
  50        return;
  51}
  52
  53static inline void fscrypt_set_encrypted_dentry(struct dentry *dentry)
  54{
  55        return;
  56}
  57
  58/* policy.c */
  59static inline int fscrypt_ioctl_set_policy(struct file *filp,
  60                                           const void __user *arg)
  61{
  62        return -EOPNOTSUPP;
  63}
  64
  65static inline int fscrypt_ioctl_get_policy(struct file *filp, void __user *arg)
  66{
  67        return -EOPNOTSUPP;
  68}
  69
  70static inline int fscrypt_has_permitted_context(struct inode *parent,
  71                                                struct inode *child)
  72{
  73        return 0;
  74}
  75
  76static inline int fscrypt_inherit_context(struct inode *parent,
  77                                          struct inode *child,
  78                                          void *fs_data, bool preload)
  79{
  80        return -EOPNOTSUPP;
  81}
  82
  83/* keyinfo.c */
  84static inline int fscrypt_get_encryption_info(struct inode *inode)
  85{
  86        return -EOPNOTSUPP;
  87}
  88
  89static inline void fscrypt_put_encryption_info(struct inode *inode,
  90                                               struct fscrypt_info *ci)
  91{
  92        return;
  93}
  94
  95 /* fname.c */
  96static inline int fscrypt_setup_filename(struct inode *dir,
  97                                         const struct qstr *iname,
  98                                         int lookup, struct fscrypt_name *fname)
  99{
 100        if (dir->i_sb->s_cop->is_encrypted(dir))
 101                return -EOPNOTSUPP;
 102
 103        memset(fname, 0, sizeof(struct fscrypt_name));
 104        fname->usr_fname = iname;
 105        fname->disk_name.name = (unsigned char *)iname->name;
 106        fname->disk_name.len = iname->len;
 107        return 0;
 108}
 109
 110static inline void fscrypt_free_filename(struct fscrypt_name *fname)
 111{
 112        return;
 113}
 114
 115static inline u32 fscrypt_fname_encrypted_size(const struct inode *inode,
 116                                               u32 ilen)
 117{
 118        /* never happens */
 119        WARN_ON(1);
 120        return 0;
 121}
 122
 123static inline int fscrypt_fname_alloc_buffer(const struct inode *inode,
 124                                             u32 ilen,
 125                                             struct fscrypt_str *crypto_str)
 126{
 127        return -EOPNOTSUPP;
 128}
 129
 130static inline void fscrypt_fname_free_buffer(struct fscrypt_str *crypto_str)
 131{
 132        return;
 133}
 134
 135static inline int fscrypt_fname_disk_to_usr(struct inode *inode,
 136                                            u32 hash, u32 minor_hash,
 137                                            const struct fscrypt_str *iname,
 138                                            struct fscrypt_str *oname)
 139{
 140        return -EOPNOTSUPP;
 141}
 142
 143static inline int fscrypt_fname_usr_to_disk(struct inode *inode,
 144                                            const struct qstr *iname,
 145                                            struct fscrypt_str *oname)
 146{
 147        return -EOPNOTSUPP;
 148}
 149
 150static inline bool fscrypt_match_name(const struct fscrypt_name *fname,
 151                                      const u8 *de_name, u32 de_name_len)
 152{
 153        /* Encryption support disabled; use standard comparison */
 154        if (de_name_len != fname->disk_name.len)
 155                return false;
 156        return !memcmp(de_name, fname->disk_name.name, fname->disk_name.len);
 157}
 158
 159/* bio.c */
 160static inline void fscrypt_decrypt_bio_pages(struct fscrypt_ctx *ctx,
 161                                             struct bio *bio)
 162{
 163        return;
 164}
 165
 166static inline void fscrypt_pullback_bio_page(struct page **page, bool restore)
 167{
 168        return;
 169}
 170
 171static inline int fscrypt_zeroout_range(const struct inode *inode, pgoff_t lblk,
 172                                        sector_t pblk, unsigned int len)
 173{
 174        return -EOPNOTSUPP;
 175}
 176
 177#endif  /* _LINUX_FSCRYPT_NOTSUPP_H */
 178