Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
[XFS] Merge in trivial changes, sync up headers with userspace equivalents.
SGI-PV: 907752
SGI-Modid: xfs-linux-melb:xfs-kern:24961a
Signed-off-by: Nathan Scott <nathans@sgi.com>
+2
-2
fs/xfs/quota/xfs_dquot_item.c
+2
-2
fs/xfs/quota/xfs_dquot_item.c
···
239
239
* trying to duplicate our effort.
240
240
*/
241
241
ASSERT(qip->qli_pushbuf_flag != 0);
242
-
ASSERT(qip->qli_push_owner == get_thread_id());
242
+
ASSERT(qip->qli_push_owner == current_pid());
243
243
244
244
/*
245
245
* If flushlock isn't locked anymore, chances are that the
···
333
333
qip->qli_pushbuf_flag = 1;
334
334
ASSERT(qip->qli_format.qlf_blkno == dqp->q_blkno);
335
335
#ifdef DEBUG
336
-
qip->qli_push_owner = get_thread_id();
336
+
qip->qli_push_owner = current_pid();
337
337
#endif
338
338
/*
339
339
* The dquot is left locked.
+24
-34
fs/xfs/support/debug.c
+24
-34
fs/xfs/support/debug.c
···
33
33
KERN_INFO, KERN_DEBUG};
34
34
35
35
void
36
-
assfail(char *a, char *f, int l)
37
-
{
38
-
printk("XFS assertion failed: %s, file: %s, line: %d\n", a, f, l);
39
-
BUG();
40
-
}
41
-
42
-
#if ((defined(DEBUG) || defined(INDUCE_IO_ERRROR)) && !defined(NO_WANT_RANDOM))
43
-
44
-
unsigned long
45
-
random(void)
46
-
{
47
-
static unsigned long RandomValue = 1;
48
-
/* cycles pseudo-randomly through all values between 1 and 2^31 - 2 */
49
-
register long rv = RandomValue;
50
-
register long lo;
51
-
register long hi;
52
-
53
-
hi = rv / 127773;
54
-
lo = rv % 127773;
55
-
rv = 16807 * lo - 2836 * hi;
56
-
if( rv <= 0 ) rv += 2147483647;
57
-
return( RandomValue = rv );
58
-
}
59
-
60
-
int
61
-
get_thread_id(void)
62
-
{
63
-
return current->pid;
64
-
}
65
-
66
-
#endif /* DEBUG || INDUCE_IO_ERRROR || !NO_WANT_RANDOM */
67
-
68
-
void
69
36
cmn_err(register int level, char *fmt, ...)
70
37
{
71
38
char *fp = fmt;
···
57
90
BUG();
58
91
}
59
92
60
-
61
93
void
62
94
icmn_err(register int level, char *fmt, va_list ap)
63
95
{
···
75
109
if (level == CE_PANIC)
76
110
BUG();
77
111
}
112
+
113
+
void
114
+
assfail(char *expr, char *file, int line)
115
+
{
116
+
printk("Assertion failed: %s, file: %s, line: %d\n", expr, file, line);
117
+
BUG();
118
+
}
119
+
120
+
#if ((defined(DEBUG) || defined(INDUCE_IO_ERRROR)) && !defined(NO_WANT_RANDOM))
121
+
unsigned long random(void)
122
+
{
123
+
static unsigned long RandomValue = 1;
124
+
/* cycles pseudo-randomly through all values between 1 and 2^31 - 2 */
125
+
register long rv = RandomValue;
126
+
register long lo;
127
+
register long hi;
128
+
129
+
hi = rv / 127773;
130
+
lo = rv % 127773;
131
+
rv = 16807 * lo - 2836 * hi;
132
+
if (rv <= 0) rv += 2147483647;
133
+
return RandomValue = rv;
134
+
}
135
+
#endif /* DEBUG || INDUCE_IO_ERRROR || !NO_WANT_RANDOM */
+14
-15
fs/xfs/support/debug.h
+14
-15
fs/xfs/support/debug.h
···
31
31
__attribute__ ((format (printf, 2, 0)));
32
32
extern void cmn_err(int, char *, ...)
33
33
__attribute__ ((format (printf, 2, 3)));
34
+
extern void assfail(char *expr, char *f, int l);
35
+
36
+
#define prdev(fmt,targ,args...) \
37
+
printk("Device %s - " fmt "\n", XFS_BUFTARG_NAME(targ), ## args)
38
+
39
+
#define ASSERT_ALWAYS(expr) \
40
+
(unlikely((expr) != 0) ? (void)0 : assfail(#expr, __FILE__, __LINE__))
41
+
42
+
#ifndef DEBUG
43
+
# define ASSERT(expr) ((void)0)
44
+
#else
45
+
# define ASSERT(expr) ASSERT_ALWAYS(expr)
46
+
extern unsigned long random(void);
47
+
#endif
34
48
35
49
#ifndef STATIC
36
50
# define STATIC static
37
51
#endif
38
-
39
-
#ifdef DEBUG
40
-
# define ASSERT(EX) ((EX) ? ((void)0) : assfail(#EX, __FILE__, __LINE__))
41
-
#else
42
-
# define ASSERT(x) ((void)0)
43
-
#endif
44
-
45
-
extern void assfail(char *, char *, int);
46
-
#ifdef DEBUG
47
-
extern unsigned long random(void);
48
-
extern int get_thread_id(void);
49
-
#endif
50
-
51
-
#define ASSERT_ALWAYS(EX) ((EX)?((void)0):assfail(#EX, __FILE__, __LINE__))
52
-
#define debug_stop_all_cpus(param) /* param is "cpumask_t *" */
53
52
54
53
#endif /* __XFS_SUPPORT_DEBUG_H__ */
+1
-1
fs/xfs/xfs_arch.h
+1
-1
fs/xfs/xfs_arch.h
···
44
44
#define cpu_to_be16(val) ((__be16)(val))
45
45
#define cpu_to_be32(val) ((__be32)(val))
46
46
#define cpu_to_be64(val) ((__be64)(val))
47
-
#define be16_to_cpu(val) ((__uint16_t)(val)
47
+
#define be16_to_cpu(val) ((__uint16_t)(val))
48
48
#define be32_to_cpu(val) ((__uint32_t)(val))
49
49
#define be64_to_cpu(val) ((__uint64_t)(val))
50
50
#else
+43
-36
fs/xfs/xfs_attr_leaf.h
+43
-36
fs/xfs/xfs_attr_leaf.h
···
63
63
* the leaf_entry. The namespaces are independent only because we also look
64
64
* at the namespace bit when we are looking for a matching attribute name.
65
65
*
66
-
* We also store a "incomplete" bit in the leaf_entry. It shows that an
66
+
* We also store an "incomplete" bit in the leaf_entry. It shows that an
67
67
* attribute is in the middle of being created and should not be shown to
68
68
* the user if we crash during the time that the bit is set. We clear the
69
69
* bit when we have finished setting up the attribute. We do this because
···
72
72
*/
73
73
#define XFS_ATTR_LEAF_MAPSIZE 3 /* how many freespace slots */
74
74
75
+
typedef struct xfs_attr_leaf_map { /* RLE map of free bytes */
76
+
__uint16_t base; /* base of free region */
77
+
__uint16_t size; /* length of free region */
78
+
} xfs_attr_leaf_map_t;
79
+
80
+
typedef struct xfs_attr_leaf_hdr { /* constant-structure header block */
81
+
xfs_da_blkinfo_t info; /* block type, links, etc. */
82
+
__uint16_t count; /* count of active leaf_entry's */
83
+
__uint16_t usedbytes; /* num bytes of names/values stored */
84
+
__uint16_t firstused; /* first used byte in name area */
85
+
__uint8_t holes; /* != 0 if blk needs compaction */
86
+
__uint8_t pad1;
87
+
xfs_attr_leaf_map_t freemap[XFS_ATTR_LEAF_MAPSIZE];
88
+
/* N largest free regions */
89
+
} xfs_attr_leaf_hdr_t;
90
+
91
+
typedef struct xfs_attr_leaf_entry { /* sorted on key, not name */
92
+
xfs_dahash_t hashval; /* hash value of name */
93
+
__uint16_t nameidx; /* index into buffer of name/value */
94
+
__uint8_t flags; /* LOCAL/ROOT/SECURE/INCOMPLETE flag */
95
+
__uint8_t pad2; /* unused pad byte */
96
+
} xfs_attr_leaf_entry_t;
97
+
98
+
typedef struct xfs_attr_leaf_name_local {
99
+
__uint16_t valuelen; /* number of bytes in value */
100
+
__uint8_t namelen; /* length of name bytes */
101
+
__uint8_t nameval[1]; /* name/value bytes */
102
+
} xfs_attr_leaf_name_local_t;
103
+
104
+
typedef struct xfs_attr_leaf_name_remote {
105
+
xfs_dablk_t valueblk; /* block number of value bytes */
106
+
__uint32_t valuelen; /* number of bytes in value */
107
+
__uint8_t namelen; /* length of name bytes */
108
+
__uint8_t name[1]; /* name bytes */
109
+
} xfs_attr_leaf_name_remote_t;
110
+
75
111
typedef struct xfs_attr_leafblock {
76
-
struct xfs_attr_leaf_hdr { /* constant-structure header block */
77
-
xfs_da_blkinfo_t info; /* block type, links, etc. */
78
-
__uint16_t count; /* count of active leaf_entry's */
79
-
__uint16_t usedbytes; /* num bytes of names/values stored */
80
-
__uint16_t firstused; /* first used byte in name area */
81
-
__uint8_t holes; /* != 0 if blk needs compaction */
82
-
__uint8_t pad1;
83
-
struct xfs_attr_leaf_map { /* RLE map of free bytes */
84
-
__uint16_t base; /* base of free region */
85
-
__uint16_t size; /* length of free region */
86
-
} freemap[XFS_ATTR_LEAF_MAPSIZE]; /* N largest free regions */
87
-
} hdr;
88
-
struct xfs_attr_leaf_entry { /* sorted on key, not name */
89
-
xfs_dahash_t hashval; /* hash value of name */
90
-
__uint16_t nameidx; /* index into buffer of name/value */
91
-
__uint8_t flags; /* LOCAL/ROOT/SECURE/INCOMPLETE flag */
92
-
__uint8_t pad2; /* unused pad byte */
93
-
} entries[1]; /* variable sized array */
94
-
struct xfs_attr_leaf_name_local {
95
-
__uint16_t valuelen; /* number of bytes in value */
96
-
__uint8_t namelen; /* length of name bytes */
97
-
__uint8_t nameval[1]; /* name/value bytes */
98
-
} namelist; /* grows from bottom of buf */
99
-
struct xfs_attr_leaf_name_remote {
100
-
xfs_dablk_t valueblk; /* block number of value bytes */
101
-
__uint32_t valuelen; /* number of bytes in value */
102
-
__uint8_t namelen; /* length of name bytes */
103
-
__uint8_t name[1]; /* name bytes */
104
-
} valuelist; /* grows from bottom of buf */
112
+
xfs_attr_leaf_hdr_t hdr; /* constant-structure header block */
113
+
xfs_attr_leaf_entry_t entries[1]; /* sorted on key, not name */
114
+
xfs_attr_leaf_name_local_t namelist; /* grows from bottom of buf */
115
+
xfs_attr_leaf_name_remote_t valuelist; /* grows from bottom of buf */
105
116
} xfs_attr_leafblock_t;
106
-
typedef struct xfs_attr_leaf_hdr xfs_attr_leaf_hdr_t;
107
-
typedef struct xfs_attr_leaf_map xfs_attr_leaf_map_t;
108
-
typedef struct xfs_attr_leaf_entry xfs_attr_leaf_entry_t;
109
-
typedef struct xfs_attr_leaf_name_local xfs_attr_leaf_name_local_t;
110
-
typedef struct xfs_attr_leaf_name_remote xfs_attr_leaf_name_remote_t;
111
117
112
118
/*
113
119
* Flags used in the leaf_entry[i].flags field.
···
156
150
(leafp))[INT_GET((leafp)->entries[idx].nameidx, ARCH_CONVERT)];
157
151
}
158
152
159
-
#define XFS_ATTR_LEAF_NAME(leafp,idx) xfs_attr_leaf_name(leafp,idx)
153
+
#define XFS_ATTR_LEAF_NAME(leafp,idx) \
154
+
xfs_attr_leaf_name(leafp,idx)
160
155
static inline char *xfs_attr_leaf_name(xfs_attr_leafblock_t *leafp, int idx)
161
156
{
162
157
return (&((char *)
+2
-2
fs/xfs/xfs_bmap.c
+2
-2
fs/xfs/xfs_bmap.c
···
4493
4493
num_recs = be16_to_cpu(block->bb_numrecs);
4494
4494
if (unlikely(i + num_recs > room)) {
4495
4495
ASSERT(i + num_recs <= room);
4496
-
xfs_fs_cmn_err(CE_WARN, ip->i_mount,
4497
-
"corrupt dinode %Lu, (btree extents). Unmount and run xfs_repair.",
4496
+
xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
4497
+
"corrupt dinode %Lu, (btree extents).",
4498
4498
(unsigned long long) ip->i_ino);
4499
4499
XFS_ERROR_REPORT("xfs_bmap_read_extents(1)",
4500
4500
XFS_ERRLEVEL_LOW,
+34
-30
fs/xfs/xfs_dir_leaf.h
+34
-30
fs/xfs/xfs_dir_leaf.h
···
67
67
*/
68
68
#define XFS_DIR_LEAF_MAPSIZE 3 /* how many freespace slots */
69
69
70
+
typedef struct xfs_dir_leaf_map { /* RLE map of free bytes */
71
+
__uint16_t base; /* base of free region */
72
+
__uint16_t size; /* run length of free region */
73
+
} xfs_dir_leaf_map_t;
74
+
75
+
typedef struct xfs_dir_leaf_hdr { /* constant-structure header block */
76
+
xfs_da_blkinfo_t info; /* block type, links, etc. */
77
+
__uint16_t count; /* count of active leaf_entry's */
78
+
__uint16_t namebytes; /* num bytes of name strings stored */
79
+
__uint16_t firstused; /* first used byte in name area */
80
+
__uint8_t holes; /* != 0 if blk needs compaction */
81
+
__uint8_t pad1;
82
+
xfs_dir_leaf_map_t freemap[XFS_DIR_LEAF_MAPSIZE];
83
+
} xfs_dir_leaf_hdr_t;
84
+
85
+
typedef struct xfs_dir_leaf_entry { /* sorted on key, not name */
86
+
xfs_dahash_t hashval; /* hash value of name */
87
+
__uint16_t nameidx; /* index into buffer of name */
88
+
__uint8_t namelen; /* length of name string */
89
+
__uint8_t pad2;
90
+
} xfs_dir_leaf_entry_t;
91
+
92
+
typedef struct xfs_dir_leaf_name {
93
+
xfs_dir_ino_t inumber; /* inode number for this key */
94
+
__uint8_t name[1]; /* name string itself */
95
+
} xfs_dir_leaf_name_t;
96
+
70
97
typedef struct xfs_dir_leafblock {
71
-
struct xfs_dir_leaf_hdr { /* constant-structure header block */
72
-
xfs_da_blkinfo_t info; /* block type, links, etc. */
73
-
__uint16_t count; /* count of active leaf_entry's */
74
-
__uint16_t namebytes; /* num bytes of name strings stored */
75
-
__uint16_t firstused; /* first used byte in name area */
76
-
__uint8_t holes; /* != 0 if blk needs compaction */
77
-
__uint8_t pad1;
78
-
struct xfs_dir_leaf_map {/* RLE map of free bytes */
79
-
__uint16_t base; /* base of free region */
80
-
__uint16_t size; /* run length of free region */
81
-
} freemap[XFS_DIR_LEAF_MAPSIZE]; /* N largest free regions */
82
-
} hdr;
83
-
struct xfs_dir_leaf_entry { /* sorted on key, not name */
84
-
xfs_dahash_t hashval; /* hash value of name */
85
-
__uint16_t nameidx; /* index into buffer of name */
86
-
__uint8_t namelen; /* length of name string */
87
-
__uint8_t pad2;
88
-
} entries[1]; /* var sized array */
89
-
struct xfs_dir_leaf_name {
90
-
xfs_dir_ino_t inumber; /* inode number for this key */
91
-
__uint8_t name[1]; /* name string itself */
92
-
} namelist[1]; /* grows from bottom of buf */
98
+
xfs_dir_leaf_hdr_t hdr; /* constant-structure header block */
99
+
xfs_dir_leaf_entry_t entries[1]; /* var sized array */
100
+
xfs_dir_leaf_name_t namelist[1]; /* grows from bottom of buf */
93
101
} xfs_dir_leafblock_t;
94
-
typedef struct xfs_dir_leaf_hdr xfs_dir_leaf_hdr_t;
95
-
typedef struct xfs_dir_leaf_map xfs_dir_leaf_map_t;
96
-
typedef struct xfs_dir_leaf_entry xfs_dir_leaf_entry_t;
97
-
typedef struct xfs_dir_leaf_name xfs_dir_leaf_name_t;
98
102
99
103
/*
100
104
* Length of name for which a 512-byte block filesystem
···
130
126
#define XFS_PUT_COOKIE(c,mp,bno,entry,hash) \
131
127
((c).s.be = XFS_DA_MAKE_BNOENTRY(mp, bno, entry), (c).s.h = (hash))
132
128
133
-
typedef struct xfs_dir_put_args
134
-
{
129
+
typedef struct xfs_dir_put_args {
135
130
xfs_dircook_t cook; /* cookie of (next) entry */
136
131
xfs_intino_t ino; /* inode number */
137
-
struct xfs_dirent *dbp; /* buffer pointer */
132
+
struct xfs_dirent *dbp; /* buffer pointer */
138
133
char *name; /* directory entry name */
139
134
int namelen; /* length of name */
140
135
int done; /* output: set if value was stored */
···
141
138
struct uio *uio; /* uio control structure */
142
139
} xfs_dir_put_args_t;
143
140
144
-
#define XFS_DIR_LEAF_ENTSIZE_BYNAME(len) xfs_dir_leaf_entsize_byname(len)
141
+
#define XFS_DIR_LEAF_ENTSIZE_BYNAME(len) \
142
+
xfs_dir_leaf_entsize_byname(len)
145
143
static inline int xfs_dir_leaf_entsize_byname(int len)
146
144
{
147
145
return (uint)sizeof(xfs_dir_leaf_name_t)-1 + len;
-1
fs/xfs/xfs_error.c
-1
fs/xfs/xfs_error.c
+4
-4
fs/xfs/xfs_error.h
+4
-4
fs/xfs/xfs_error.h
···
18
18
#ifndef __XFS_ERROR_H__
19
19
#define __XFS_ERROR_H__
20
20
21
-
#define prdev(fmt,targ,args...) \
22
-
printk("XFS: device %s - " fmt "\n", XFS_BUFTARG_NAME(targ), ## args)
23
-
24
21
#define XFS_ERECOVER 1 /* Failure to recover log */
25
22
#define XFS_ELOGSTAT 2 /* Failure to stat log in user space */
26
23
#define XFS_ENOLOGSPACE 3 /* Reservation too large */
···
179
182
struct xfs_mount;
180
183
/* PRINTFLIKE4 */
181
184
extern void xfs_cmn_err(int panic_tag, int level, struct xfs_mount *mp,
182
-
char *fmt, ...);
185
+
char *fmt, ...);
183
186
/* PRINTFLIKE3 */
184
187
extern void xfs_fs_cmn_err(int level, struct xfs_mount *mp, char *fmt, ...);
188
+
189
+
#define xfs_fs_repair_cmn_err(level, mp, fmt, args...) \
190
+
xfs_fs_cmn_err(level, mp, fmt " Unmount and run xfs_repair.", ## args)
185
191
186
192
#endif /* __XFS_ERROR_H__ */
+17
-16
fs/xfs/xfs_inode.c
+17
-16
fs/xfs/xfs_inode.c
···
404
404
INT_GET(dip->di_core.di_nextents, ARCH_CONVERT) +
405
405
INT_GET(dip->di_core.di_anextents, ARCH_CONVERT) >
406
406
INT_GET(dip->di_core.di_nblocks, ARCH_CONVERT))) {
407
-
xfs_fs_cmn_err(CE_WARN, ip->i_mount,
408
-
"corrupt dinode %Lu, extent total = %d, nblocks = %Lu."
409
-
" Unmount and run xfs_repair.",
407
+
xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
408
+
"corrupt dinode %Lu, extent total = %d, nblocks = %Lu.",
410
409
(unsigned long long)ip->i_ino,
411
410
(int)(INT_GET(dip->di_core.di_nextents, ARCH_CONVERT)
412
411
+ INT_GET(dip->di_core.di_anextents, ARCH_CONVERT)),
···
417
418
}
418
419
419
420
if (unlikely(INT_GET(dip->di_core.di_forkoff, ARCH_CONVERT) > ip->i_mount->m_sb.sb_inodesize)) {
420
-
xfs_fs_cmn_err(CE_WARN, ip->i_mount,
421
-
"corrupt dinode %Lu, forkoff = 0x%x."
422
-
" Unmount and run xfs_repair.",
421
+
xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
422
+
"corrupt dinode %Lu, forkoff = 0x%x.",
423
423
(unsigned long long)ip->i_ino,
424
424
(int)(INT_GET(dip->di_core.di_forkoff, ARCH_CONVERT)));
425
425
XFS_CORRUPTION_ERROR("xfs_iformat(2)", XFS_ERRLEVEL_LOW,
···
449
451
* no local regular files yet
450
452
*/
451
453
if (unlikely((INT_GET(dip->di_core.di_mode, ARCH_CONVERT) & S_IFMT) == S_IFREG)) {
452
-
xfs_fs_cmn_err(CE_WARN, ip->i_mount,
453
-
"corrupt inode (local format for regular file) %Lu. Unmount and run xfs_repair.",
454
+
xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
455
+
"corrupt inode %Lu "
456
+
"(local format for regular file).",
454
457
(unsigned long long) ip->i_ino);
455
458
XFS_CORRUPTION_ERROR("xfs_iformat(4)",
456
459
XFS_ERRLEVEL_LOW,
···
461
462
462
463
di_size = INT_GET(dip->di_core.di_size, ARCH_CONVERT);
463
464
if (unlikely(di_size > XFS_DFORK_DSIZE(dip, ip->i_mount))) {
464
-
xfs_fs_cmn_err(CE_WARN, ip->i_mount,
465
-
"corrupt inode %Lu (bad size %Ld for local inode). Unmount and run xfs_repair.",
465
+
xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
466
+
"corrupt inode %Lu "
467
+
"(bad size %Ld for local inode).",
466
468
(unsigned long long) ip->i_ino,
467
469
(long long) di_size);
468
470
XFS_CORRUPTION_ERROR("xfs_iformat(5)",
···
551
551
* kmem_alloc() or memcpy() below.
552
552
*/
553
553
if (unlikely(size > XFS_DFORK_SIZE(dip, ip->i_mount, whichfork))) {
554
-
xfs_fs_cmn_err(CE_WARN, ip->i_mount,
555
-
"corrupt inode %Lu (bad size %d for local fork, size = %d). Unmount and run xfs_repair.",
554
+
xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
555
+
"corrupt inode %Lu "
556
+
"(bad size %d for local fork, size = %d).",
556
557
(unsigned long long) ip->i_ino, size,
557
558
XFS_DFORK_SIZE(dip, ip->i_mount, whichfork));
558
559
XFS_CORRUPTION_ERROR("xfs_iformat_local", XFS_ERRLEVEL_LOW,
···
611
610
* kmem_alloc() or memcpy() below.
612
611
*/
613
612
if (unlikely(size < 0 || size > XFS_DFORK_SIZE(dip, ip->i_mount, whichfork))) {
614
-
xfs_fs_cmn_err(CE_WARN, ip->i_mount,
615
-
"corrupt inode %Lu ((a)extents = %d). Unmount and run xfs_repair.",
613
+
xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
614
+
"corrupt inode %Lu ((a)extents = %d).",
616
615
(unsigned long long) ip->i_ino, nex);
617
616
XFS_CORRUPTION_ERROR("xfs_iformat_extents(1)", XFS_ERRLEVEL_LOW,
618
617
ip->i_mount, dip);
···
693
692
|| XFS_BMDR_SPACE_CALC(nrecs) >
694
693
XFS_DFORK_SIZE(dip, ip->i_mount, whichfork)
695
694
|| XFS_IFORK_NEXTENTS(ip, whichfork) > ip->i_d.di_nblocks)) {
696
-
xfs_fs_cmn_err(CE_WARN, ip->i_mount,
697
-
"corrupt inode %Lu (btree). Unmount and run xfs_repair.",
695
+
xfs_fs_repair_cmn_err(CE_WARN, ip->i_mount,
696
+
"corrupt inode %Lu (btree).",
698
697
(unsigned long long) ip->i_ino);
699
698
XFS_ERROR_REPORT("xfs_iformat_btree", XFS_ERRLEVEL_LOW,
700
699
ip->i_mount);
+2
-2
fs/xfs/xfs_inode_item.c
+2
-2
fs/xfs/xfs_inode_item.c
···
608
608
if (iip->ili_pushbuf_flag == 0) {
609
609
iip->ili_pushbuf_flag = 1;
610
610
#ifdef DEBUG
611
-
iip->ili_push_owner = get_thread_id();
611
+
iip->ili_push_owner = current_pid();
612
612
#endif
613
613
/*
614
614
* Inode is left locked in shared mode.
···
787
787
* trying to duplicate our effort.
788
788
*/
789
789
ASSERT(iip->ili_pushbuf_flag != 0);
790
-
ASSERT(iip->ili_push_owner == get_thread_id());
790
+
ASSERT(iip->ili_push_owner == current_pid());
791
791
792
792
/*
793
793
* If flushlock isn't locked anymore, chances are that the