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