LCOV - code coverage report
Current view: top level - fs/xfs - xfs_linux.h (source / functions) Hit Total Coverage
Test: fstests of 6.5.0-rc3-achx @ Mon Jul 31 20:08:12 PDT 2023 Lines: 17 17 100.0 %
Date: 2023-07-31 20:08:12 Functions: 4 4 100.0 %

          Line data    Source code
       1             : // SPDX-License-Identifier: GPL-2.0
       2             : /*
       3             :  * Copyright (c) 2000-2005 Silicon Graphics, Inc.
       4             :  * All Rights Reserved.
       5             :  */
       6             : #ifndef __XFS_LINUX__
       7             : #define __XFS_LINUX__
       8             : 
       9             : #include <linux/types.h>
      10             : #include <linux/uuid.h>
      11             : 
      12             : /*
      13             :  * Kernel specific type declarations for XFS
      14             :  */
      15             : 
      16             : typedef __s64                   xfs_off_t;      /* <file offset> type */
      17             : typedef unsigned long long      xfs_ino_t;      /* <inode> type */
      18             : typedef __s64                   xfs_daddr_t;    /* <disk address> type */
      19             : typedef __u32                   xfs_dev_t;
      20             : typedef __u32                   xfs_nlink_t;
      21             : 
      22             : #include "xfs_types.h"
      23             : 
      24             : #include "kmem.h"
      25             : #include "mrlock.h"
      26             : 
      27             : #include <linux/semaphore.h>
      28             : #include <linux/mm.h>
      29             : #include <linux/sched/mm.h>
      30             : #include <linux/kernel.h>
      31             : #include <linux/blkdev.h>
      32             : #include <linux/slab.h>
      33             : #include <linux/crc32c.h>
      34             : #include <linux/module.h>
      35             : #include <linux/mutex.h>
      36             : #include <linux/file.h>
      37             : #include <linux/filelock.h>
      38             : #include <linux/swap.h>
      39             : #include <linux/errno.h>
      40             : #include <linux/sched/signal.h>
      41             : #include <linux/bitops.h>
      42             : #include <linux/major.h>
      43             : #include <linux/pagemap.h>
      44             : #include <linux/vfs.h>
      45             : #include <linux/seq_file.h>
      46             : #include <linux/init.h>
      47             : #include <linux/list.h>
      48             : #include <linux/proc_fs.h>
      49             : #include <linux/sort.h>
      50             : #include <linux/cpu.h>
      51             : #include <linux/notifier.h>
      52             : #include <linux/delay.h>
      53             : #include <linux/log2.h>
      54             : #include <linux/spinlock.h>
      55             : #include <linux/random.h>
      56             : #include <linux/ctype.h>
      57             : #include <linux/writeback.h>
      58             : #include <linux/capability.h>
      59             : #include <linux/kthread.h>
      60             : #include <linux/freezer.h>
      61             : #include <linux/list_sort.h>
      62             : #include <linux/ratelimit.h>
      63             : #include <linux/rhashtable.h>
      64             : #include <linux/xattr.h>
      65             : #include <linux/mnt_idmapping.h>
      66             : #include <linux/debugfs.h>
      67             : 
      68             : #include <asm/page.h>
      69             : #include <asm/div64.h>
      70             : #include <asm/param.h>
      71             : #include <linux/uaccess.h>
      72             : #include <asm/byteorder.h>
      73             : #include <asm/unaligned.h>
      74             : 
      75             : #include "xfs_fs.h"
      76             : #include "xfs_fs_staging.h"
      77             : #include "xfs_stats.h"
      78             : #include "xfs_sysctl.h"
      79             : #include "xfs_iops.h"
      80             : #include "xfs_aops.h"
      81             : #include "xfs_super.h"
      82             : #include "xfs_cksum.h"
      83             : #include "xfs_buf.h"
      84             : #include "xfs_message.h"
      85             : #include "xfs_drain.h"
      86             : #include "xfs_hooks.h"
      87             : 
      88             : #ifdef __BIG_ENDIAN
      89             : #define XFS_NATIVE_HOST 1
      90             : #else
      91             : #undef XFS_NATIVE_HOST
      92             : #endif
      93             : 
      94             : #define irix_sgid_inherit       xfs_params.sgid_inherit.val
      95             : #define irix_symlink_mode       xfs_params.symlink_mode.val
      96             : #define xfs_panic_mask          xfs_params.panic_mask.val
      97             : #define xfs_error_level         xfs_params.error_level.val
      98             : #define xfs_syncd_centisecs     xfs_params.syncd_timer.val
      99             : #define xfs_stats_clear         xfs_params.stats_clear.val
     100             : #define xfs_inherit_sync        xfs_params.inherit_sync.val
     101             : #define xfs_inherit_nodump      xfs_params.inherit_nodump.val
     102             : #define xfs_inherit_noatime     xfs_params.inherit_noatim.val
     103             : #define xfs_inherit_nosymlinks  xfs_params.inherit_nosym.val
     104             : #define xfs_rotorstep           xfs_params.rotorstep.val
     105             : #define xfs_inherit_nodefrag    xfs_params.inherit_nodfrg.val
     106             : #define xfs_fstrm_centisecs     xfs_params.fstrm_timer.val
     107             : #define xfs_blockgc_secs        xfs_params.blockgc_timer.val
     108             : 
     109             : #define current_cpu()           (raw_smp_processor_id())
     110             : #define current_set_flags_nested(sp, f)         \
     111             :                 (*(sp) = current->flags, current->flags |= (f))
     112             : #define current_restore_flags_nested(sp, f)     \
     113             :                 (current->flags = ((current->flags & ~(f)) | (*(sp) & (f))))
     114             : 
     115             : #define NBBY            8               /* number of bits per byte */
     116             : 
     117             : /*
     118             :  * Size of block device i/o is parameterized here.
     119             :  * Currently the system supports page-sized i/o.
     120             :  */
     121             : #define BLKDEV_IOSHIFT          PAGE_SHIFT
     122             : #define BLKDEV_IOSIZE           (1<<BLKDEV_IOSHIFT)
     123             : /* number of BB's per block device block */
     124             : #define BLKDEV_BB               BTOBB(BLKDEV_IOSIZE)
     125             : 
     126             : #define ENOATTR         ENODATA         /* Attribute not found */
     127             : #define EWRONGFS        EINVAL          /* Mount with wrong filesystem type */
     128             : #define EFSCORRUPTED    EUCLEAN         /* Filesystem is corrupted */
     129             : #define EFSBADCRC       EBADMSG         /* Bad CRC detected */
     130             : 
     131             : #define __return_address __builtin_return_address(0)
     132             : 
     133             : /*
     134             :  * Return the address of a label.  Use barrier() so that the optimizer
     135             :  * won't reorder code to refactor the error jumpouts into a single
     136             :  * return, which throws off the reported address.
     137             :  */
     138             : #define __this_address  ({ __label__ __here; __here: barrier(); &&__here; })
     139             : 
     140             : #define XFS_PROJID_DEFAULT      0
     141             : 
     142             : #define howmany(x, y)   (((x)+((y)-1))/(y))
     143             : 
     144             : static inline void delay(long ticks)
     145             : {
     146     3275278 :         schedule_timeout_uninterruptible(ticks);
     147       14249 : }
     148             : 
     149             : /*
     150             :  * XFS wrapper structure for sysfs support. It depends on external data
     151             :  * structures and is embedded in various internal data structures to implement
     152             :  * the XFS sysfs object heirarchy. Define it here for broad access throughout
     153             :  * the codebase.
     154             :  */
     155             : struct xfs_kobj {
     156             :         struct kobject          kobject;
     157             :         struct completion       complete;
     158             : };
     159             : 
     160             : struct xstats {
     161             :         struct xfsstats __percpu        *xs_stats;
     162             :         struct xfs_kobj                 xs_kobj;
     163             : };
     164             : 
     165             : extern struct xstats xfsstats;
     166             : 
     167             : static inline dev_t xfs_to_linux_dev_t(xfs_dev_t dev)
     168             : {
     169   140369134 :         return MKDEV(sysv_major(dev) & 0x1ff, sysv_minor(dev));
     170             : }
     171             : 
     172             : static inline xfs_dev_t linux_to_xfs_dev_t(dev_t dev)
     173             : {
     174    12174232 :         return sysv_encode_dev(dev);
     175             : }
     176             : 
     177             : /*
     178             :  * Various platform dependent calls that don't fit anywhere else
     179             :  */
     180             : #define xfs_sort(a,n,s,fn)      sort(a,n,s,fn,NULL)
     181             : #define xfs_stack_trace()       dump_stack()
     182             : 
     183     1636381 : static inline uint64_t rounddown_64(uint64_t x, uint32_t y)
     184             : {
     185     1636381 :         do_div(x, y);
     186     1636381 :         return x * y;
     187             : }
     188             : 
     189    79575140 : static inline uint64_t roundup_64(uint64_t x, uint32_t y)
     190             : {
     191    79575140 :         x += y - 1;
     192    79575140 :         do_div(x, y);
     193    79575140 :         return x * y;
     194             : }
     195             : 
     196    41737433 : static inline uint64_t howmany_64(uint64_t x, uint32_t y)
     197             : {
     198  3682882669 :         x += y - 1;
     199  3682882669 :         do_div(x, y);
     200  3682882669 :         return x;
     201             : }
     202             : 
     203      531765 : static inline bool isaligned_64(uint64_t x, uint32_t y)
     204             : {
     205      531765 :         return do_div(x, y) == 0;
     206             : }
     207             : 
     208             : int xfs_rw_bdev(struct block_device *bdev, sector_t sector, unsigned int count,
     209             :                 char *data, enum req_op op);
     210             : 
     211             : #define ASSERT_ALWAYS(expr)     \
     212             :         (likely(expr) ? (void)0 : assfail(NULL, #expr, __FILE__, __LINE__))
     213             : 
     214             : #ifdef DEBUG
     215             : #define ASSERT(expr)    \
     216             :         (likely(expr) ? (void)0 : assfail(NULL, #expr, __FILE__, __LINE__))
     217             : 
     218             : #else   /* !DEBUG */
     219             : 
     220             : #ifdef XFS_WARN
     221             : 
     222             : #define ASSERT(expr)    \
     223             :         (likely(expr) ? (void)0 : asswarn(NULL, #expr, __FILE__, __LINE__))
     224             : 
     225             : #else   /* !DEBUG && !XFS_WARN */
     226             : 
     227             : #define ASSERT(expr)            ((void)0)
     228             : 
     229             : #endif /* XFS_WARN */
     230             : #endif /* DEBUG */
     231             : 
     232             : #define XFS_IS_CORRUPT(mp, expr)        \
     233             :         (unlikely(expr) ? xfs_corruption_error(#expr, XFS_ERRLEVEL_LOW, (mp), \
     234             :                                                NULL, 0, __FILE__, __LINE__, \
     235             :                                                __this_address), \
     236             :                           true : false)
     237             : 
     238             : #define STATIC static noinline
     239             : 
     240             : #ifdef CONFIG_XFS_RT
     241             : 
     242             : /*
     243             :  * make sure we ignore the inode flag if the filesystem doesn't have a
     244             :  * configured realtime device.
     245             :  */
     246             : #define XFS_IS_REALTIME_INODE(ip)                       \
     247             :         (((ip)->i_diflags & XFS_DIFLAG_REALTIME) &&      \
     248             :          (ip)->i_mount->m_rtdev_targp)
     249             : #define XFS_IS_REALTIME_MOUNT(mp) ((mp)->m_rtdev_targp ? 1 : 0)
     250             : #else
     251             : #define XFS_IS_REALTIME_INODE(ip) (0)
     252             : #define XFS_IS_REALTIME_MOUNT(mp) (0)
     253             : #endif
     254             : 
     255             : /*
     256             :  * Starting in Linux 4.15, the %p (raw pointer value) printk modifier
     257             :  * prints a hashed version of the pointer to avoid leaking kernel
     258             :  * pointers into dmesg.  If we're trying to debug the kernel we want the
     259             :  * raw values, so override this behavior as best we can.
     260             :  */
     261             : #ifdef DEBUG
     262             : # define PTR_FMT "%px"
     263             : #else
     264             : # define PTR_FMT "%p"
     265             : #endif
     266             : 
     267             : #endif /* __XFS_LINUX__ */

Generated by: LCOV version 1.14