root/fs/xfs/xfs_icache.h

INCLUDED FROM

DEFINITIONS

1. xfs_fs_eofblocks_from_user

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (c) 2000-2006 Silicon Graphics, Inc.
   4  * All Rights Reserved.
   5  */
   6 #ifndef XFS_SYNC_H
   7 #define XFS_SYNC_H 1
   8 
   9 struct xfs_mount;
  10 struct xfs_perag;
  11 
  12 struct xfs_eofblocks {
  13         __u32           eof_flags;
  14         kuid_t          eof_uid;
  15         kgid_t          eof_gid;
  16         prid_t          eof_prid;
  17         __u64           eof_min_file_size;
  18 };
  19 
  20 #define SYNC_WAIT               0x0001  /* wait for i/o to complete */
  21 #define SYNC_TRYLOCK            0x0002  /* only try to lock inodes */
  22 
  23 /*
  24  * tags for inode radix tree
  25  */
  26 #define XFS_ICI_NO_TAG          (-1)    /* special flag for an untagged lookup
  27                                            in xfs_inode_ag_iterator */
  28 #define XFS_ICI_RECLAIM_TAG     0       /* inode is to be reclaimed */
  29 #define XFS_ICI_EOFBLOCKS_TAG   1       /* inode has blocks beyond EOF */
  30 #define XFS_ICI_COWBLOCKS_TAG   2       /* inode can have cow blocks to gc */
  31 
  32 /*
  33  * Flags for xfs_iget()
  34  */
  35 #define XFS_IGET_CREATE         0x1
  36 #define XFS_IGET_UNTRUSTED      0x2
  37 #define XFS_IGET_DONTCACHE      0x4
  38 #define XFS_IGET_INCORE         0x8     /* don't read from disk or reinit */
  39 
  40 /*
  41  * flags for AG inode iterator
  42  */
  43 #define XFS_AGITER_INEW_WAIT    0x1     /* wait on new inodes */
  44 
  45 int xfs_iget(struct xfs_mount *mp, struct xfs_trans *tp, xfs_ino_t ino,
  46              uint flags, uint lock_flags, xfs_inode_t **ipp);
  47 
  48 /* recovery needs direct inode allocation capability */
  49 struct xfs_inode * xfs_inode_alloc(struct xfs_mount *mp, xfs_ino_t ino);
  50 void xfs_inode_free(struct xfs_inode *ip);
  51 
  52 void xfs_reclaim_worker(struct work_struct *work);
  53 
  54 int xfs_reclaim_inodes(struct xfs_mount *mp, int mode);
  55 int xfs_reclaim_inodes_count(struct xfs_mount *mp);
  56 long xfs_reclaim_inodes_nr(struct xfs_mount *mp, int nr_to_scan);
  57 
  58 void xfs_inode_set_reclaim_tag(struct xfs_inode *ip);
  59 
  60 void xfs_inode_set_eofblocks_tag(struct xfs_inode *ip);
  61 void xfs_inode_clear_eofblocks_tag(struct xfs_inode *ip);
  62 int xfs_icache_free_eofblocks(struct xfs_mount *, struct xfs_eofblocks *);
  63 int xfs_inode_free_quota_eofblocks(struct xfs_inode *ip);
  64 void xfs_eofblocks_worker(struct work_struct *);
  65 void xfs_queue_eofblocks(struct xfs_mount *);
  66 
  67 void xfs_inode_set_cowblocks_tag(struct xfs_inode *ip);
  68 void xfs_inode_clear_cowblocks_tag(struct xfs_inode *ip);
  69 int xfs_icache_free_cowblocks(struct xfs_mount *, struct xfs_eofblocks *);
  70 int xfs_inode_free_quota_cowblocks(struct xfs_inode *ip);
  71 void xfs_cowblocks_worker(struct work_struct *);
  72 void xfs_queue_cowblocks(struct xfs_mount *);
  73 
  74 int xfs_inode_ag_iterator(struct xfs_mount *mp,
  75         int (*execute)(struct xfs_inode *ip, int flags, void *args),
  76         int flags, void *args);
  77 int xfs_inode_ag_iterator_flags(struct xfs_mount *mp,
  78         int (*execute)(struct xfs_inode *ip, int flags, void *args),
  79         int flags, void *args, int iter_flags);
  80 int xfs_inode_ag_iterator_tag(struct xfs_mount *mp,
  81         int (*execute)(struct xfs_inode *ip, int flags, void *args),
  82         int flags, void *args, int tag);
  83 
  84 static inline int
  85 xfs_fs_eofblocks_from_user(
  86         struct xfs_fs_eofblocks         *src,
  87         struct xfs_eofblocks            *dst)
  88 {
  89         if (src->eof_version != XFS_EOFBLOCKS_VERSION)
  90                 return -EINVAL;
  91 
  92         if (src->eof_flags & ~XFS_EOF_FLAGS_VALID)
  93                 return -EINVAL;
  94 
  95         if (memchr_inv(&src->pad32, 0, sizeof(src->pad32)) ||
  96             memchr_inv(src->pad64, 0, sizeof(src->pad64)))
  97                 return -EINVAL;
  98 
  99         dst->eof_flags = src->eof_flags;
 100         dst->eof_prid = src->eof_prid;
 101         dst->eof_min_file_size = src->eof_min_file_size;
 102 
 103         dst->eof_uid = INVALID_UID;
 104         if (src->eof_flags & XFS_EOF_FLAGS_UID) {
 105                 dst->eof_uid = make_kuid(current_user_ns(), src->eof_uid);
 106                 if (!uid_valid(dst->eof_uid))
 107                         return -EINVAL;
 108         }
 109 
 110         dst->eof_gid = INVALID_GID;
 111         if (src->eof_flags & XFS_EOF_FLAGS_GID) {
 112                 dst->eof_gid = make_kgid(current_user_ns(), src->eof_gid);
 113                 if (!gid_valid(dst->eof_gid))
 114                         return -EINVAL;
 115         }
 116         return 0;
 117 }
 118 
 119 int xfs_icache_inode_is_allocated(struct xfs_mount *mp, struct xfs_trans *tp,
 120                                   xfs_ino_t ino, bool *inuse);
 121 
 122 void xfs_stop_block_reaping(struct xfs_mount *mp);
 123 void xfs_start_block_reaping(struct xfs_mount *mp);
 124 
 125 #endif