Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Merge tag 'vfs-7.1-rc1.kino' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs
Pull vfs i_ino updates from Christian Brauner:
"For historical reasons, the inode->i_ino field is an unsigned long,
which means that it's 32 bits on 32 bit architectures. This has caused
a number of filesystems to implement hacks to hash a 64-bit identifier
into a 32-bit field, and deprives us of a universal identifier field
for an inode.
This changes the inode->i_ino field from an unsigned long to a u64.
This shouldn't make any material difference on 64-bit hosts, but
32-bit hosts will see struct inode grow by at least 4 bytes. This
could have effects on slabcache sizes and field alignment.
The bulk of the changes are to format strings and tracepoints, since
the kernel itself doesn't care that much about the i_ino field. The
first patch changes some vfs function arguments, so check that one out
carefully.
With this change, we may be able to shrink some inode structures. For
instance, struct nfs_inode has a fileid field that holds the 64-bit
inode number. With this set of changes, that field could be
eliminated. I'd rather leave that sort of cleanups for later just to
keep this simple"
* tag 'vfs-7.1-rc1.kino' of git://git.kernel.org/pub/scm/linux/kernel/git/vfs/vfs:
nilfs2: fix 64-bit division operations in nilfs_bmap_find_target_in_group()
EVM: add comment describing why ino field is still unsigned long
vfs: remove externs from fs.h on functions modified by i_ino widening
treewide: fix missed i_ino format specifier conversions
ext4: fix signed format specifier in ext4_load_inode trace event
treewide: change inode->i_ino from unsigned long to u64
nilfs2: widen trace event i_ino fields to u64
f2fs: widen trace event i_ino fields to u64
ext4: widen trace event i_ino fields to u64
zonefs: widen trace event i_ino fields to u64
hugetlbfs: widen trace event i_ino fields to u64
ext2: widen trace event i_ino fields to u64
cachefiles: widen trace event i_ino fields to u64
vfs: widen trace event i_ino fields to u64
net: change sock.sk_ino and sock_i_ino() to u64
audit: widen ino fields to u64
vfs: widen inode hash/lookup functions to u64
+1337
-1327
+1
-1
drivers/dma-buf/dma-buf.c
+1
-1
drivers/dma-buf/dma-buf.c
···
1708
1708
1709
1709
1710
1710
spin_lock(&buf_obj->name_lock);
1711
-
seq_printf(s, "%08zu\t%08x\t%08x\t%08ld\t%s\t%08lu\t%s\n",
1711
+
seq_printf(s, "%08zu\t%08x\t%08x\t%08ld\t%s\t%08llu\t%s\n",
1712
1712
buf_obj->size,
1713
1713
buf_obj->file->f_flags, buf_obj->file->f_mode,
1714
1714
file_count(buf_obj->file),
+2
-2
drivers/gpu/drm/amd/amdgpu/amdgpu_object.c
+2
-2
drivers/gpu/drm/amd/amdgpu/amdgpu_object.c
···
1676
1676
attachment = READ_ONCE(bo->tbo.base.import_attach);
1677
1677
1678
1678
if (attachment)
1679
-
seq_printf(m, " imported from ino:%lu", file_inode(dma_buf->file)->i_ino);
1679
+
seq_printf(m, " imported from ino:%llu", file_inode(dma_buf->file)->i_ino);
1680
1680
else if (dma_buf)
1681
-
seq_printf(m, " exported as ino:%lu", file_inode(dma_buf->file)->i_ino);
1681
+
seq_printf(m, " exported as ino:%llu", file_inode(dma_buf->file)->i_ino);
1682
1682
1683
1683
amdgpu_bo_print_flag(m, bo, CPU_ACCESS_REQUIRED);
1684
1684
amdgpu_bo_print_flag(m, bo, NO_CPU_ACCESS);
+2
-2
fs/9p/vfs_addr.c
+2
-2
fs/9p/vfs_addr.c
···
36
36
37
37
fid = v9fs_fid_find_inode(wreq->inode, true, INVALID_UID, true);
38
38
if (!fid) {
39
-
WARN_ONCE(1, "folio expected an open fid inode->i_ino=%lx\n",
39
+
WARN_ONCE(1, "folio expected an open fid inode->i_ino=%llx\n",
40
40
wreq->inode->i_ino);
41
41
return;
42
42
}
···
133
133
return 0;
134
134
135
135
no_fid:
136
-
WARN_ONCE(1, "folio expected an open fid inode->i_ino=%lx\n",
136
+
WARN_ONCE(1, "folio expected an open fid inode->i_ino=%llx\n",
137
137
rreq->inode->i_ino);
138
138
return -EINVAL;
139
139
}
+3
-3
fs/9p/vfs_inode.c
+3
-3
fs/9p/vfs_inode.c
···
1245
1245
v9fs_vfs_symlink(struct mnt_idmap *idmap, struct inode *dir,
1246
1246
struct dentry *dentry, const char *symname)
1247
1247
{
1248
-
p9_debug(P9_DEBUG_VFS, " %lu,%pd,%s\n",
1248
+
p9_debug(P9_DEBUG_VFS, " %llu,%pd,%s\n",
1249
1249
dir->i_ino, dentry, symname);
1250
1250
1251
1251
return v9fs_vfs_mkspecial(dir, dentry, P9_DMSYMLINK, symname);
···
1269
1269
char name[1 + U32_MAX_DIGITS + 2]; /* sign + number + \n + \0 */
1270
1270
struct p9_fid *oldfid;
1271
1271
1272
-
p9_debug(P9_DEBUG_VFS, " %lu,%pd,%pd\n",
1272
+
p9_debug(P9_DEBUG_VFS, " %llu,%pd,%pd\n",
1273
1273
dir->i_ino, dentry, old_dentry);
1274
1274
1275
1275
oldfid = v9fs_fid_clone(old_dentry);
···
1305
1305
char name[2 + U32_MAX_DIGITS + 1 + U32_MAX_DIGITS + 1];
1306
1306
u32 perm;
1307
1307
1308
-
p9_debug(P9_DEBUG_VFS, " %lu,%pd mode: %x MAJOR: %u MINOR: %u\n",
1308
+
p9_debug(P9_DEBUG_VFS, " %llu,%pd mode: %x MAJOR: %u MINOR: %u\n",
1309
1309
dir->i_ino, dentry, mode,
1310
1310
MAJOR(rdev), MINOR(rdev));
1311
1311
+3
-3
fs/9p/vfs_inode_dotl.c
+3
-3
fs/9p/vfs_inode_dotl.c
···
691
691
struct p9_fid *fid = NULL;
692
692
693
693
name = dentry->d_name.name;
694
-
p9_debug(P9_DEBUG_VFS, "%lu,%s,%s\n", dir->i_ino, name, symname);
694
+
p9_debug(P9_DEBUG_VFS, "%llu,%s,%s\n", dir->i_ino, name, symname);
695
695
696
696
dfid = v9fs_parent_fid(dentry);
697
697
if (IS_ERR(dfid)) {
···
734
734
struct p9_fid *dfid, *oldfid;
735
735
struct v9fs_session_info *v9ses;
736
736
737
-
p9_debug(P9_DEBUG_VFS, "dir ino: %lu, old_name: %pd, new_name: %pd\n",
737
+
p9_debug(P9_DEBUG_VFS, "dir ino: %llu, old_name: %pd, new_name: %pd\n",
738
738
dir->i_ino, old_dentry, dentry);
739
739
740
740
v9ses = v9fs_inode2v9ses(dir);
···
798
798
struct p9_qid qid;
799
799
struct posix_acl *dacl = NULL, *pacl = NULL;
800
800
801
-
p9_debug(P9_DEBUG_VFS, " %lu,%pd mode: %x MAJOR: %u MINOR: %u\n",
801
+
p9_debug(P9_DEBUG_VFS, " %llu,%pd mode: %x MAJOR: %u MINOR: %u\n",
802
802
dir->i_ino, dentry, omode,
803
803
MAJOR(rdev), MINOR(rdev));
804
804
+5
-5
fs/affs/amigaffs.c
+5
-5
fs/affs/amigaffs.c
···
33
33
ino = bh->b_blocknr;
34
34
offset = affs_hash_name(sb, AFFS_TAIL(sb, bh)->name + 1, AFFS_TAIL(sb, bh)->name[0]);
35
35
36
-
pr_debug("%s(dir=%lu, ino=%d)\n", __func__, dir->i_ino, ino);
36
+
pr_debug("%s(dir=%llu, ino=%d)\n", __func__, dir->i_ino, ino);
37
37
38
38
dir_bh = affs_bread(sb, dir->i_ino);
39
39
if (!dir_bh)
···
83
83
sb = dir->i_sb;
84
84
rem_ino = rem_bh->b_blocknr;
85
85
offset = affs_hash_name(sb, AFFS_TAIL(sb, rem_bh)->name+1, AFFS_TAIL(sb, rem_bh)->name[0]);
86
-
pr_debug("%s(dir=%lu, ino=%d, hashval=%d)\n", __func__, dir->i_ino,
86
+
pr_debug("%s(dir=%llu, ino=%d, hashval=%d)\n", __func__, dir->i_ino,
87
87
rem_ino, offset);
88
88
89
89
bh = affs_bread(sb, dir->i_ino);
···
128
128
spin_lock(&inode->i_lock);
129
129
hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
130
130
if (entry_ino == (u32)(long)dentry->d_fsdata) {
131
-
dentry->d_fsdata = (void *)inode->i_ino;
131
+
dentry->d_fsdata = (void *)(unsigned long)inode->i_ino;
132
132
break;
133
133
}
134
134
}
···
147
147
u32 link_ino, ino;
148
148
int retval;
149
149
150
-
pr_debug("%s(key=%ld)\n", __func__, inode->i_ino);
150
+
pr_debug("%s(key=%llu)\n", __func__, inode->i_ino);
151
151
retval = -EIO;
152
152
bh = affs_bread(sb, inode->i_ino);
153
153
if (!bh)
···
279
279
if (!inode)
280
280
goto done;
281
281
282
-
pr_debug("%s(key=%ld)\n", __func__, inode->i_ino);
282
+
pr_debug("%s(key=%llu)\n", __func__, inode->i_ino);
283
283
retval = -EIO;
284
284
bh = affs_bread(sb, (u32)(long)dentry->d_fsdata);
285
285
if (!bh)
+1
-1
fs/affs/bitmap.c
+1
-1
fs/affs/bitmap.c
···
125
125
sb = inode->i_sb;
126
126
sbi = AFFS_SB(sb);
127
127
128
-
pr_debug("balloc(inode=%lu,goal=%u): ", inode->i_ino, goal);
128
+
pr_debug("balloc(inode=%llu,goal=%u): ", inode->i_ino, goal);
129
129
130
130
if (AFFS_I(inode)->i_pa_cnt) {
131
131
pr_debug("%d\n", AFFS_I(inode)->i_lastalloc+1);
+1
-1
fs/affs/dir.c
+1
-1
fs/affs/dir.c
+10
-10
fs/affs/file.c
+10
-10
fs/affs/file.c
···
24
24
static int
25
25
affs_file_open(struct inode *inode, struct file *filp)
26
26
{
27
-
pr_debug("open(%lu,%d)\n",
27
+
pr_debug("open(%llu,%d)\n",
28
28
inode->i_ino, atomic_read(&AFFS_I(inode)->i_opencnt));
29
29
atomic_inc(&AFFS_I(inode)->i_opencnt);
30
30
return 0;
···
33
33
static int
34
34
affs_file_release(struct inode *inode, struct file *filp)
35
35
{
36
-
pr_debug("release(%lu, %d)\n",
36
+
pr_debug("release(%llu, %d)\n",
37
37
inode->i_ino, atomic_read(&AFFS_I(inode)->i_opencnt));
38
38
39
39
if (atomic_dec_and_test(&AFFS_I(inode)->i_opencnt)) {
···
301
301
struct buffer_head *ext_bh;
302
302
u32 ext;
303
303
304
-
pr_debug("%s(%lu, %llu)\n", __func__, inode->i_ino,
304
+
pr_debug("%s(%llu, %llu)\n", __func__, inode->i_ino,
305
305
(unsigned long long)block);
306
306
307
307
BUG_ON(block > (sector_t)0x7fffffffUL);
···
534
534
size_t bidx, boff, bsize;
535
535
u32 tmp;
536
536
537
-
pr_debug("%s(%lu, %ld, 0, %zu)\n", __func__, inode->i_ino,
537
+
pr_debug("%s(%llu, %ld, 0, %zu)\n", __func__, inode->i_ino,
538
538
folio->index, to);
539
539
BUG_ON(to > folio_size(folio));
540
540
bsize = AFFS_SB(sb)->s_data_blksize;
···
566
566
u32 size, bsize;
567
567
u32 tmp;
568
568
569
-
pr_debug("%s(%lu, %d)\n", __func__, inode->i_ino, newsize);
569
+
pr_debug("%s(%llu, %d)\n", __func__, inode->i_ino, newsize);
570
570
bsize = AFFS_SB(sb)->s_data_blksize;
571
571
bh = NULL;
572
572
size = AFFS_I(inode)->mmu_private;
···
634
634
size_t to;
635
635
int err;
636
636
637
-
pr_debug("%s(%lu, %ld)\n", __func__, inode->i_ino, folio->index);
637
+
pr_debug("%s(%llu, %ld)\n", __func__, inode->i_ino, folio->index);
638
638
to = folio_size(folio);
639
639
if (folio_pos(folio) + to > inode->i_size) {
640
640
to = inode->i_size - folio_pos(folio);
···
658
658
pgoff_t index;
659
659
int err = 0;
660
660
661
-
pr_debug("%s(%lu, %llu, %llu)\n", __func__, inode->i_ino, pos,
661
+
pr_debug("%s(%llu, %llu, %llu)\n", __func__, inode->i_ino, pos,
662
662
pos + len);
663
663
if (pos > AFFS_I(inode)->mmu_private) {
664
664
/* XXX: this probably leaves a too-big i_size in case of
···
710
710
* due to write_begin.
711
711
*/
712
712
713
-
pr_debug("%s(%lu, %llu, %llu)\n", __func__, inode->i_ino, pos,
713
+
pr_debug("%s(%llu, %llu, %llu)\n", __func__, inode->i_ino, pos,
714
714
pos + len);
715
715
bsize = AFFS_SB(sb)->s_data_blksize;
716
716
data = folio_address(folio);
···
854
854
{
855
855
struct super_block *sb = inode->i_sb;
856
856
857
-
pr_debug("free_prealloc(ino=%lu)\n", inode->i_ino);
857
+
pr_debug("free_prealloc(ino=%llu)\n", inode->i_ino);
858
858
859
859
while (AFFS_I(inode)->i_pa_cnt) {
860
860
AFFS_I(inode)->i_pa_cnt--;
···
874
874
struct buffer_head *ext_bh;
875
875
int i;
876
876
877
-
pr_debug("truncate(inode=%lu, oldsize=%llu, newsize=%llu)\n",
877
+
pr_debug("truncate(inode=%llu, oldsize=%llu, newsize=%llu)\n",
878
878
inode->i_ino, AFFS_I(inode)->mmu_private, inode->i_size);
879
879
880
880
last_blk = 0;
+6
-6
fs/affs/inode.c
+6
-6
fs/affs/inode.c
···
32
32
if (!(inode_state_read_once(inode) & I_NEW))
33
33
return inode;
34
34
35
-
pr_debug("affs_iget(%lu)\n", inode->i_ino);
35
+
pr_debug("affs_iget(%llu)\n", inode->i_ino);
36
36
37
37
block = inode->i_ino;
38
38
bh = affs_bread(sb, block);
···
171
171
uid_t uid;
172
172
gid_t gid;
173
173
174
-
pr_debug("write_inode(%lu)\n", inode->i_ino);
174
+
pr_debug("write_inode(%llu)\n", inode->i_ino);
175
175
176
176
if (!inode->i_nlink)
177
177
// possibly free block
178
178
return 0;
179
179
bh = affs_bread(sb, inode->i_ino);
180
180
if (!bh) {
181
-
affs_error(sb,"write_inode","Cannot read block %lu",inode->i_ino);
181
+
affs_error(sb, "write_inode", "Cannot read block %llu", inode->i_ino);
182
182
return -EIO;
183
183
}
184
184
tail = AFFS_TAIL(sb, bh);
···
219
219
struct inode *inode = d_inode(dentry);
220
220
int error;
221
221
222
-
pr_debug("notify_change(%lu,0x%x)\n", inode->i_ino, attr->ia_valid);
222
+
pr_debug("notify_change(%llu,0x%x)\n", inode->i_ino, attr->ia_valid);
223
223
224
224
error = setattr_prepare(&nop_mnt_idmap, dentry, attr);
225
225
if (error)
···
260
260
affs_evict_inode(struct inode *inode)
261
261
{
262
262
unsigned long cache_page;
263
-
pr_debug("evict_inode(ino=%lu, nlink=%u)\n",
263
+
pr_debug("evict_inode(ino=%llu, nlink=%u)\n",
264
264
inode->i_ino, inode->i_nlink);
265
265
truncate_inode_pages_final(&inode->i_data);
266
266
···
353
353
u32 block = 0;
354
354
int retval;
355
355
356
-
pr_debug("%s(dir=%lu, inode=%lu, \"%pd\", type=%d)\n", __func__,
356
+
pr_debug("%s(dir=%llu, inode=%llu, \"%pd\", type=%d)\n", __func__,
357
357
dir->i_ino, inode->i_ino, dentry, type);
358
358
359
359
retval = -EIO;
+7
-7
fs/affs/namei.c
+7
-7
fs/affs/namei.c
···
235
235
int
236
236
affs_unlink(struct inode *dir, struct dentry *dentry)
237
237
{
238
-
pr_debug("%s(dir=%lu, %lu \"%pd\")\n", __func__, dir->i_ino,
238
+
pr_debug("%s(dir=%llu, %llu \"%pd\")\n", __func__, dir->i_ino,
239
239
d_inode(dentry)->i_ino, dentry);
240
240
241
241
return affs_remove_header(dentry);
···
249
249
struct inode *inode;
250
250
int error;
251
251
252
-
pr_debug("%s(%lu,\"%pd\",0%ho)\n",
252
+
pr_debug("%s(%llu,\"%pd\",0%ho)\n",
253
253
__func__, dir->i_ino, dentry, mode);
254
254
255
255
inode = affs_new_inode(dir);
···
280
280
struct inode *inode;
281
281
int error;
282
282
283
-
pr_debug("%s(%lu,\"%pd\",0%ho)\n",
283
+
pr_debug("%s(%llu,\"%pd\",0%ho)\n",
284
284
__func__, dir->i_ino, dentry, mode);
285
285
286
286
inode = affs_new_inode(dir);
···
306
306
int
307
307
affs_rmdir(struct inode *dir, struct dentry *dentry)
308
308
{
309
-
pr_debug("%s(dir=%lu, %lu \"%pd\")\n", __func__, dir->i_ino,
309
+
pr_debug("%s(dir=%llu, %llu \"%pd\")\n", __func__, dir->i_ino,
310
310
d_inode(dentry)->i_ino, dentry);
311
311
312
312
return affs_remove_header(dentry);
···
323
323
int i, maxlen, error;
324
324
char c, lc;
325
325
326
-
pr_debug("%s(%lu,\"%pd\" -> \"%s\")\n",
326
+
pr_debug("%s(%llu,\"%pd\" -> \"%s\")\n",
327
327
__func__, dir->i_ino, dentry, symname);
328
328
329
329
maxlen = AFFS_SB(sb)->s_hashsize * sizeof(u32) - 1;
···
395
395
{
396
396
struct inode *inode = d_inode(old_dentry);
397
397
398
-
pr_debug("%s(%lu, %lu, \"%pd\")\n", __func__, inode->i_ino, dir->i_ino,
398
+
pr_debug("%s(%llu, %llu, \"%pd\")\n", __func__, inode->i_ino, dir->i_ino,
399
399
dentry);
400
400
401
401
return affs_add_entry(dir, inode, dentry, ST_LINKFILE);
···
511
511
if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE))
512
512
return -EINVAL;
513
513
514
-
pr_debug("%s(old=%lu,\"%pd\" to new=%lu,\"%pd\")\n", __func__,
514
+
pr_debug("%s(old=%llu,\"%pd\" to new=%llu,\"%pd\")\n", __func__,
515
515
old_dir->i_ino, old_dentry, new_dir->i_ino, new_dentry);
516
516
517
517
if (flags & RENAME_EXCHANGE)
+1
-1
fs/affs/symlink.c
+1
-1
fs/affs/symlink.c
+5
-5
fs/afs/dir.c
+5
-5
fs/afs/dir.c
···
148
148
union afs_xdr_dir_block *block)
149
149
{
150
150
if (block->hdr.magic != AFS_DIR_MAGIC) {
151
-
pr_warn("%s(%lx): [%zx] bad magic %04x\n",
151
+
pr_warn("%s(%llx): [%zx] bad magic %04x\n",
152
152
__func__, dvnode->netfs.inode.i_ino,
153
153
progress, ntohs(block->hdr.magic));
154
154
trace_afs_dir_check_failed(dvnode, progress);
···
214
214
*/
215
215
static int afs_dir_open(struct inode *inode, struct file *file)
216
216
{
217
-
_enter("{%lu}", inode->i_ino);
217
+
_enter("{%llu}", inode->i_ino);
218
218
219
219
BUILD_BUG_ON(sizeof(union afs_xdr_dir_block) != 2048);
220
220
BUILD_BUG_ON(sizeof(union afs_xdr_dirent) != 32);
···
523
523
int retry_limit = 100;
524
524
int ret;
525
525
526
-
_enter("{%lu},%llx,,", dir->i_ino, ctx->pos);
526
+
_enter("{%llu},%llx,,", dir->i_ino, ctx->pos);
527
527
528
528
do {
529
529
if (--retry_limit < 0) {
···
610
610
};
611
611
int ret;
612
612
613
-
_enter("{%lu},{%.*s},", dir->i_ino, name->len, name->name);
613
+
_enter("{%llu},{%.*s},", dir->i_ino, name->len, name->name);
614
614
615
615
/* search the directory */
616
616
ret = afs_dir_iterate(dir, &cookie.ctx, NULL, _dir_version);
···
783
783
long ret;
784
784
int i;
785
785
786
-
_enter("{%lu},%p{%pd},", dir->i_ino, dentry, dentry);
786
+
_enter("{%llu},%p{%pd},", dir->i_ino, dentry, dentry);
787
787
788
788
cookie = kzalloc_obj(struct afs_lookup_cookie);
789
789
if (!cookie)
+1
-1
fs/afs/dir_search.c
+1
-1
fs/afs/dir_search.c
+1
-1
fs/afs/dynroot.c
+1
-1
fs/afs/dynroot.c
+1
-1
fs/afs/inode.c
+1
-1
fs/afs/inode.c
+1
-1
fs/autofs/inode.c
+1
-1
fs/autofs/inode.c
+14
-14
fs/befs/linuxvfs.c
+14
-14
fs/befs/linuxvfs.c
···
140
140
int res;
141
141
ulong disk_off;
142
142
143
-
befs_debug(sb, "---> befs_get_block() for inode %lu, block %ld",
144
-
(unsigned long)inode->i_ino, (long)block);
143
+
befs_debug(sb, "---> befs_get_block() for inode %llu, block %ld",
144
+
inode->i_ino, (long)block);
145
145
if (create) {
146
146
befs_error(sb, "befs_get_block() was asked to write to "
147
-
"block %ld in inode %lu", (long)block,
148
-
(unsigned long)inode->i_ino);
147
+
"block %ld in inode %llu", (long)block,
148
+
inode->i_ino);
149
149
return -EPERM;
150
150
}
151
151
152
152
res = befs_fblock2brun(sb, ds, block, &run);
153
153
if (res != BEFS_OK) {
154
154
befs_error(sb,
155
-
"<--- %s for inode %lu, block %ld ERROR",
156
-
__func__, (unsigned long)inode->i_ino,
155
+
"<--- %s for inode %llu, block %ld ERROR",
156
+
__func__, inode->i_ino,
157
157
(long)block);
158
158
return -EFBIG;
159
159
}
···
162
162
163
163
map_bh(bh_result, inode->i_sb, disk_off);
164
164
165
-
befs_debug(sb, "<--- %s for inode %lu, block %ld, disk address %lu",
166
-
__func__, (unsigned long)inode->i_ino, (long)block,
165
+
befs_debug(sb, "<--- %s for inode %llu, block %ld, disk address %lu",
166
+
__func__, inode->i_ino, (long)block,
167
167
(unsigned long)disk_off);
168
168
169
169
return 0;
···
181
181
char *utfname;
182
182
const char *name = dentry->d_name.name;
183
183
184
-
befs_debug(sb, "---> %s name %pd inode %ld", __func__,
184
+
befs_debug(sb, "---> %s name %pd inode %llu", __func__,
185
185
dentry, dir->i_ino);
186
186
187
187
/* Convert to UTF-8 */
···
224
224
size_t keysize;
225
225
char keybuf[BEFS_NAME_LEN + 1];
226
226
227
-
befs_debug(sb, "---> %s name %pD, inode %ld, ctx->pos %lld",
227
+
befs_debug(sb, "---> %s name %pD, inode %llu, ctx->pos %lld",
228
228
__func__, file, inode->i_ino, ctx->pos);
229
229
230
230
while (1) {
···
233
233
234
234
if (result == BEFS_ERR) {
235
235
befs_debug(sb, "<--- %s ERROR", __func__);
236
-
befs_error(sb, "IO error reading %pD (inode %lu)",
236
+
befs_error(sb, "IO error reading %pD (inode %llu)",
237
237
file, inode->i_ino);
238
238
return -EIO;
239
239
···
324
324
bh = sb_bread(sb, inode->i_ino);
325
325
if (!bh) {
326
326
befs_error(sb, "unable to read inode block - "
327
-
"inode = %lu", inode->i_ino);
327
+
"inode = %llu", inode->i_ino);
328
328
goto unacquire_none;
329
329
}
330
330
···
333
333
befs_dump_inode(sb, raw_inode);
334
334
335
335
if (befs_check_inode(sb, raw_inode, inode->i_ino) != BEFS_OK) {
336
-
befs_error(sb, "Bad inode: %lu", inode->i_ino);
336
+
befs_error(sb, "Bad inode: %llu", inode->i_ino);
337
337
goto unacquire_bh;
338
338
}
339
339
···
407
407
inode->i_op = &simple_symlink_inode_operations;
408
408
}
409
409
} else {
410
-
befs_error(sb, "Inode %lu is not a regular file, "
410
+
befs_error(sb, "Inode %llu is not a regular file, "
411
411
"directory or symlink. THAT IS WRONG! BeFS has no "
412
412
"on disk special files", inode->i_ino);
413
413
goto unacquire_bh;
+2
-2
fs/bfs/dir.c
+2
-2
fs/bfs/dir.c
···
35
35
int block;
36
36
37
37
if (ctx->pos & (BFS_DIRENT_SIZE - 1)) {
38
-
printf("Bad f_pos=%08lx for %s:%08lx\n",
38
+
printf("Bad f_pos=%08lx for %s:%08llx\n",
39
39
(unsigned long)ctx->pos,
40
40
dir->i_sb->s_id, dir->i_ino);
41
41
return -EINVAL;
···
180
180
goto out_brelse;
181
181
182
182
if (!inode->i_nlink) {
183
-
printf("unlinking non-existent file %s:%lu (nlink=%d)\n",
183
+
printf("unlinking non-existent file %s:%llu (nlink=%d)\n",
184
184
inode->i_sb->s_id, inode->i_ino,
185
185
inode->i_nlink);
186
186
set_nlink(inode, 1);
+1
-1
fs/binfmt_elf_fdpic.c
+1
-1
fs/binfmt_elf_fdpic.c
+3
-3
fs/cachefiles/io.c
+3
-3
fs/cachefiles/io.c
···
93
93
object = cachefiles_cres_object(cres);
94
94
file = cachefiles_cres_file(cres);
95
95
96
-
_enter("%pD,%li,%llx,%zx/%llx",
96
+
_enter("%pD,%llu,%llx,%zx/%llx",
97
97
file, file_inode(file)->i_ino, start_pos, len,
98
98
i_size_read(file_inode(file)));
99
99
···
214
214
file = cachefiles_cres_file(cres);
215
215
granularity = max_t(size_t, object->volume->cache->bsize, granularity);
216
216
217
-
_enter("%pD,%li,%llx,%zx/%llx",
217
+
_enter("%pD,%llu,%llx,%zx/%llx",
218
218
file, file_inode(file)->i_ino, start, len,
219
219
i_size_read(file_inode(file)));
220
220
···
294
294
fscache_count_write();
295
295
cache = object->volume->cache;
296
296
297
-
_enter("%pD,%li,%llx,%zx/%llx",
297
+
_enter("%pD,%llu,%llx,%zx/%llx",
298
298
file, file_inode(file)->i_ino, start_pos, len,
299
299
i_size_read(file_inode(file)));
300
300
+6
-6
fs/cachefiles/namei.c
+6
-6
fs/cachefiles/namei.c
···
147
147
}
148
148
ASSERT(d_backing_inode(subdir));
149
149
150
-
_debug("mkdir -> %pd{ino=%lu}",
150
+
_debug("mkdir -> %pd{ino=%llu}",
151
151
subdir, d_backing_inode(subdir)->i_ino);
152
152
if (_is_new)
153
153
*_is_new = true;
···
158
158
end_creating_keep(subdir);
159
159
160
160
if (!__cachefiles_mark_inode_in_use(NULL, d_inode(subdir))) {
161
-
pr_notice("cachefiles: Inode already in use: %pd (B=%lx)\n",
161
+
pr_notice("cachefiles: Inode already in use: %pd (B=%llx)\n",
162
162
subdir, d_inode(subdir)->i_ino);
163
163
goto mark_error;
164
164
}
···
183
183
!d_backing_inode(subdir)->i_op->unlink)
184
184
goto check_error;
185
185
186
-
_leave(" = [%lu]", d_backing_inode(subdir)->i_ino);
186
+
_leave(" = [%llu]", d_backing_inode(subdir)->i_ino);
187
187
return subdir;
188
188
189
189
check_error:
···
500
500
501
501
set_bit(FSCACHE_COOKIE_NEEDS_UPDATE, &object->cookie->flags);
502
502
set_bit(CACHEFILES_OBJECT_USING_TMPFILE, &object->flags);
503
-
_debug("create -> %pD{ino=%lu}", file, file_inode(file)->i_ino);
503
+
_debug("create -> %pD{ino=%llu}", file, file_inode(file)->i_ino);
504
504
object->file = file;
505
505
return true;
506
506
}
···
520
520
_enter("%pd", dentry);
521
521
522
522
if (!cachefiles_mark_inode_in_use(object, d_inode(dentry))) {
523
-
pr_notice("cachefiles: Inode already in use: %pd (B=%lx)\n",
523
+
pr_notice("cachefiles: Inode already in use: %pd (B=%llx)\n",
524
524
dentry, d_inode(dentry)->i_ino);
525
525
return false;
526
526
}
···
628
628
if (!ret)
629
629
return false;
630
630
631
-
_leave(" = t [%lu]", file_inode(object->file)->i_ino);
631
+
_leave(" = t [%llu]", file_inode(object->file)->i_ino);
632
632
return true;
633
633
634
634
new_file:
+1
-1
fs/cachefiles/xattr.c
+1
-1
fs/cachefiles/xattr.c
+2
-2
fs/ceph/crypto.c
+2
-2
fs/ceph/crypto.c
···
272
272
/* To understand the 240 limit, see CEPH_NOHASH_NAME_MAX comments */
273
273
WARN_ON(elen > 240);
274
274
if (dir != parent) // leading _ is already there; append _<inum>
275
-
elen += 1 + sprintf(p + elen, "_%ld", dir->i_ino);
275
+
elen += 1 + sprintf(p + elen, "_%llu", dir->i_ino);
276
276
277
277
out:
278
278
kfree(cryptbuf);
···
377
377
if (!ret && (dir != fname->dir)) {
378
378
char tmp_buf[BASE64_CHARS(NAME_MAX)];
379
379
380
-
name_len = snprintf(tmp_buf, sizeof(tmp_buf), "_%.*s_%ld",
380
+
name_len = snprintf(tmp_buf, sizeof(tmp_buf), "_%.*s_%llu",
381
381
oname->len, oname->name, dir->i_ino);
382
382
memcpy(oname->name, tmp_buf, name_len);
383
383
oname->len = name_len;
+1
-1
fs/coda/dir.c
+1
-1
fs/coda/dir.c
+1
-1
fs/coda/inode.c
+1
-1
fs/coda/inode.c
+1
-1
fs/cramfs/inode.c
+1
-1
fs/cramfs/inode.c
···
125
125
old_decode_dev(cramfs_inode->size));
126
126
break;
127
127
default:
128
-
printk(KERN_DEBUG "CRAMFS: Invalid file type 0%04o for inode %lu.\n",
128
+
printk(KERN_DEBUG "CRAMFS: Invalid file type 0%04o for inode %llu.\n",
129
129
inode->i_mode, inode->i_ino);
130
130
iget_failed(inode);
131
131
return ERR_PTR(-EIO);
+1
-1
fs/crypto/crypto.c
+1
-1
fs/crypto/crypto.c
···
365
365
vaf.fmt = fmt;
366
366
vaf.va = &args;
367
367
if (inode && inode->i_ino)
368
-
printk("%sfscrypt (%s, inode %lu): %pV\n",
368
+
printk("%sfscrypt (%s, inode %llu): %pV\n",
369
369
level, inode->i_sb->s_id, inode->i_ino, &vaf);
370
370
else if (inode)
371
371
printk("%sfscrypt (%s): %pV\n", level, inode->i_sb->s_id, &vaf);
+1
-1
fs/crypto/hooks.c
+1
-1
fs/crypto/hooks.c
···
62
62
dentry_parent = dget_parent(dentry);
63
63
if (!fscrypt_has_permitted_context(d_inode(dentry_parent), inode)) {
64
64
fscrypt_warn(inode,
65
-
"Inconsistent encryption context (parent directory: %lu)",
65
+
"Inconsistent encryption context (parent directory: %llu)",
66
66
d_inode(dentry_parent)->i_ino);
67
67
err = -EPERM;
68
68
}
+2
-2
fs/crypto/keyring.c
+2
-2
fs/crypto/keyring.c
···
969
969
{
970
970
struct list_head *pos;
971
971
size_t busy_count = 0;
972
-
unsigned long ino;
973
972
char ino_str[50] = "";
973
+
u64 ino;
974
974
975
975
spin_lock(&mk->mk_decrypted_inodes_lock);
976
976
···
994
994
995
995
/* If the inode is currently being created, ino may still be 0. */
996
996
if (ino)
997
-
snprintf(ino_str, sizeof(ino_str), ", including ino %lu", ino);
997
+
snprintf(ino_str, sizeof(ino_str), ", including ino %llu", ino);
998
998
999
999
fscrypt_warn(NULL,
1000
1000
"%s: %zu inode(s) still busy after removing key with %s %*phN%s",
+1
-1
fs/crypto/keysetup.c
+1
-1
fs/crypto/keysetup.c
···
91
91
if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))
92
92
return &fscrypt_modes[fscrypt_policy_fnames_mode(policy)];
93
93
94
-
WARN_ONCE(1, "fscrypt: filesystem tried to load encryption info for inode %lu, which is not encryptable (file type %d)\n",
94
+
WARN_ONCE(1, "fscrypt: filesystem tried to load encryption info for inode %llu, which is not encryptable (file type %d)\n",
95
95
inode->i_ino, (inode->i_mode & S_IFMT));
96
96
return ERR_PTR(-EINVAL);
97
97
}
+2
-2
fs/dcache.c
+2
-2
fs/dcache.c
···
1637
1637
if (dentry == _data && dentry->d_lockref.count == 1)
1638
1638
return D_WALK_CONTINUE;
1639
1639
1640
-
WARN(1, "BUG: Dentry %p{i=%lx,n=%pd} "
1640
+
WARN(1, "BUG: Dentry %p{i=%llx,n=%pd} "
1641
1641
" still in use (%d) [unmount of %s %s]\n",
1642
1642
dentry,
1643
1643
dentry->d_inode ?
1644
-
dentry->d_inode->i_ino : 0UL,
1644
+
dentry->d_inode->i_ino : (u64)0,
1645
1645
dentry,
1646
1646
dentry->d_lockref.count,
1647
1647
dentry->d_sb->s_type->name,
+3
-3
fs/ecryptfs/crypto.c
+3
-3
fs/ecryptfs/crypto.c
···
1313
1313
rc = ecryptfs_read_xattr_region(page_virt, ecryptfs_inode);
1314
1314
if (rc) {
1315
1315
printk(KERN_DEBUG "Valid eCryptfs headers not found in "
1316
-
"file header region or xattr region, inode %lu\n",
1316
+
"file header region or xattr region, inode %llu\n",
1317
1317
ecryptfs_inode->i_ino);
1318
1318
rc = -EINVAL;
1319
1319
goto out;
···
1323
1323
ECRYPTFS_DONT_VALIDATE_HEADER_SIZE);
1324
1324
if (rc) {
1325
1325
printk(KERN_DEBUG "Valid eCryptfs headers not found in "
1326
-
"file xattr region either, inode %lu\n",
1326
+
"file xattr region either, inode %llu\n",
1327
1327
ecryptfs_inode->i_ino);
1328
1328
rc = -EINVAL;
1329
1329
}
···
1335
1335
"crypto metadata only in the extended attribute "
1336
1336
"region, but eCryptfs was mounted without "
1337
1337
"xattr support enabled. eCryptfs will not treat "
1338
-
"this like an encrypted file, inode %lu\n",
1338
+
"this like an encrypted file, inode %llu\n",
1339
1339
ecryptfs_inode->i_ino);
1340
1340
rc = -EINVAL;
1341
1341
}
+1
-1
fs/ecryptfs/file.c
+1
-1
fs/ecryptfs/file.c
···
253
253
if (rc)
254
254
goto out_put;
255
255
ecryptfs_printk(KERN_DEBUG, "inode w/ addr = [0x%p], i_ino = "
256
-
"[0x%.16lx] size: [0x%.16llx]\n", inode, inode->i_ino,
256
+
"[0x%.16llx] size: [0x%.16llx]\n", inode, inode->i_ino,
257
257
(unsigned long long)i_size_read(inode));
258
258
goto out;
259
259
out_put:
+3
-3
fs/efs/inode.c
+3
-3
fs/efs/inode.c
···
132
132
for(i = 0; i < EFS_DIRECTEXTENTS; i++) {
133
133
extent_copy(&(efs_inode->di_u.di_extents[i]), &(in->extents[i]));
134
134
if (i < in->numextents && in->extents[i].cooked.ex_magic != 0) {
135
-
pr_warn("extent %d has bad magic number in inode %lu\n",
135
+
pr_warn("extent %d has bad magic number in inode %llu\n",
136
136
i, inode->i_ino);
137
137
brelse(bh);
138
138
goto read_inode_error;
···
140
140
}
141
141
142
142
brelse(bh);
143
-
pr_debug("efs_iget(): inode %lu, extents %d, mode %o\n",
143
+
pr_debug("efs_iget(): inode %llu, extents %d, mode %o\n",
144
144
inode->i_ino, in->numextents, inode->i_mode);
145
145
switch (inode->i_mode & S_IFMT) {
146
146
case S_IFDIR:
···
171
171
return inode;
172
172
173
173
read_inode_error:
174
-
pr_warn("failed to read inode %lu\n", inode->i_ino);
174
+
pr_warn("failed to read inode %llu\n", inode->i_ino);
175
175
iget_failed(inode);
176
176
return ERR_PTR(-EIO);
177
177
}
+1
-1
fs/eventpoll.c
+1
-1
fs/eventpoll.c
···
1084
1084
struct inode *inode = file_inode(epi->ffd.file);
1085
1085
1086
1086
seq_printf(m, "tfd: %8d events: %8x data: %16llx "
1087
-
" pos:%lli ino:%lx sdev:%x\n",
1087
+
" pos:%lli ino:%llx sdev:%x\n",
1088
1088
epi->ffd.fd, epi->event.events,
1089
1089
(long long)epi->event.data,
1090
1090
(long long)epi->ffd.file->f_pos,
+2
-2
fs/exportfs/expfs.c
+2
-2
fs/exportfs/expfs.c
···
130
130
parent = mnt->mnt_sb->s_export_op->get_parent(dentry);
131
131
132
132
if (IS_ERR(parent)) {
133
-
dprintk("get_parent of %lu failed, err %ld\n",
133
+
dprintk("get_parent of %llu failed, err %ld\n",
134
134
dentry->d_inode->i_ino, PTR_ERR(parent));
135
135
return parent;
136
136
}
137
137
138
-
dprintk("%s: find name of %lu in %lu\n", __func__,
138
+
dprintk("%s: find name of %llu in %llu\n", __func__,
139
139
dentry->d_inode->i_ino, parent->d_inode->i_ino);
140
140
err = exportfs_get_name(mnt, parent, nbuf, dentry);
141
141
if (err == -ENOENT)
+5
-5
fs/ext2/dir.c
+5
-5
fs/ext2/dir.c
···
141
141
Ebadsize:
142
142
if (!quiet)
143
143
ext2_error(sb, __func__,
144
-
"size of directory #%lu is not a multiple "
144
+
"size of directory #%llu is not a multiple "
145
145
"of chunk size", dir->i_ino);
146
146
goto fail;
147
147
Eshort:
···
160
160
error = "inode out of bounds";
161
161
bad_entry:
162
162
if (!quiet)
163
-
ext2_error(sb, __func__, "bad entry in directory #%lu: : %s - "
163
+
ext2_error(sb, __func__, "bad entry in directory #%llu: : %s - "
164
164
"offset=%llu, inode=%lu, rec_len=%d, name_len=%d",
165
165
dir->i_ino, error, folio_pos(folio) + offs,
166
166
(unsigned long) le32_to_cpu(p->inode),
···
170
170
if (!quiet) {
171
171
p = (ext2_dirent *)(kaddr + offs);
172
172
ext2_error(sb, "ext2_check_folio",
173
-
"entry in directory #%lu spans the page boundary"
173
+
"entry in directory #%llu spans the page boundary"
174
174
"offset=%llu, inode=%lu",
175
175
dir->i_ino, folio_pos(folio) + offs,
176
176
(unsigned long) le32_to_cpu(p->inode));
···
281
281
282
282
if (IS_ERR(kaddr)) {
283
283
ext2_error(sb, __func__,
284
-
"bad page in #%lu",
284
+
"bad page in #%llu",
285
285
inode->i_ino);
286
286
ctx->pos += PAGE_SIZE - offset;
287
287
return PTR_ERR(kaddr);
···
383
383
/* next folio is past the blocks we've got */
384
384
if (unlikely(n > (dir->i_blocks >> (PAGE_SHIFT - 9)))) {
385
385
ext2_error(dir->i_sb, __func__,
386
-
"dir %lu size %lld exceeds block count %llu",
386
+
"dir %llu size %lld exceeds block count %llu",
387
387
dir->i_ino, dir->i_size,
388
388
(unsigned long long)dir->i_blocks);
389
389
goto out;
+5
-4
fs/ext2/ialloc.c
+5
-4
fs/ext2/ialloc.c
···
169
169
unsigned long block_group;
170
170
unsigned long offset;
171
171
unsigned long block;
172
+
unsigned int ino = inode->i_ino;
172
173
struct ext2_group_desc * gdp;
173
174
174
-
block_group = (inode->i_ino - 1) / EXT2_INODES_PER_GROUP(inode->i_sb);
175
+
block_group = (ino - 1) / EXT2_INODES_PER_GROUP(inode->i_sb);
175
176
gdp = ext2_get_group_desc(inode->i_sb, block_group, NULL);
176
177
if (gdp == NULL)
177
178
return;
···
180
179
/*
181
180
* Figure out the offset within the block group inode table
182
181
*/
183
-
offset = ((inode->i_ino - 1) % EXT2_INODES_PER_GROUP(inode->i_sb)) *
182
+
offset = ((ino - 1) % EXT2_INODES_PER_GROUP(inode->i_sb)) *
184
183
EXT2_INODE_SIZE(inode->i_sb);
185
184
block = le32_to_cpu(gdp->bg_inode_table) +
186
185
(offset >> EXT2_BLOCK_SIZE_BITS(inode->i_sb));
···
382
381
*
383
382
* So add our directory's i_ino into the starting point for the hash.
384
383
*/
385
-
group = (group + parent->i_ino) % ngroups;
384
+
group = (group + (unsigned int)parent->i_ino) % ngroups;
386
385
387
386
/*
388
387
* Use a quadratic hash to find a group with a free inode and some
···
590
589
goto fail_free_drop;
591
590
592
591
mark_inode_dirty(inode);
593
-
ext2_debug("allocating inode %lu\n", inode->i_ino);
592
+
ext2_debug("allocating inode %llu\n", inode->i_ino);
594
593
ext2_preread_inode(inode);
595
594
return inode;
596
595
+1
-1
fs/ext2/inode.c
+1
-1
fs/ext2/inode.c
+4
-4
fs/ext2/trace.h
+4
-4
fs/ext2/trace.h
···
13
13
TP_ARGS(iocb, iter, ret),
14
14
TP_STRUCT__entry(
15
15
__field(dev_t, dev)
16
-
__field(ino_t, ino)
16
+
__field(u64, ino)
17
17
__field(loff_t, isize)
18
18
__field(loff_t, pos)
19
19
__field(size_t, count)
···
31
31
__entry->aio = !is_sync_kiocb(iocb);
32
32
__entry->ret = ret;
33
33
),
34
-
TP_printk("dev %d:%d ino 0x%lx isize 0x%llx pos 0x%llx len %zu flags %s aio %d ret %zd",
34
+
TP_printk("dev %d:%d ino 0x%llx isize 0x%llx pos 0x%llx len %zu flags %s aio %d ret %zd",
35
35
MAJOR(__entry->dev), MINOR(__entry->dev),
36
36
__entry->ino,
37
37
__entry->isize,
···
57
57
TP_ARGS(iocb, size, ret),
58
58
TP_STRUCT__entry(
59
59
__field(dev_t, dev)
60
-
__field(ino_t, ino)
60
+
__field(u64, ino)
61
61
__field(loff_t, isize)
62
62
__field(loff_t, pos)
63
63
__field(ssize_t, size)
···
75
75
__entry->aio = !is_sync_kiocb(iocb);
76
76
__entry->ret = ret;
77
77
),
78
-
TP_printk("dev %d:%d ino 0x%lx isize 0x%llx pos 0x%llx len %zd flags %s aio %d ret %d",
78
+
TP_printk("dev %d:%d ino 0x%llx isize 0x%llx pos 0x%llx len %zd flags %s aio %d ret %d",
79
79
MAJOR(__entry->dev), MINOR(__entry->dev),
80
80
__entry->ino,
81
81
__entry->isize,
+8
-8
fs/ext2/xattr.c
+8
-8
fs/ext2/xattr.c
···
73
73
74
74
#ifdef EXT2_XATTR_DEBUG
75
75
# define ea_idebug(inode, f...) do { \
76
-
printk(KERN_DEBUG "inode %s:%ld: ", \
76
+
printk(KERN_DEBUG "inode %s:%llu: ", \
77
77
inode->i_sb->s_id, inode->i_ino); \
78
78
printk(f); \
79
79
printk("\n"); \
···
227
227
if (!ext2_xattr_header_valid(HDR(bh))) {
228
228
bad_block:
229
229
ext2_error(inode->i_sb, "ext2_xattr_get",
230
-
"inode %ld: bad block %d", inode->i_ino,
230
+
"inode %llu: bad block %d", inode->i_ino,
231
231
EXT2_I(inode)->i_file_acl);
232
232
error = -EIO;
233
233
goto cleanup;
···
313
313
if (!ext2_xattr_header_valid(HDR(bh))) {
314
314
bad_block:
315
315
ext2_error(inode->i_sb, "ext2_xattr_list",
316
-
"inode %ld: bad block %d", inode->i_ino,
316
+
"inode %llu: bad block %d", inode->i_ino,
317
317
EXT2_I(inode)->i_file_acl);
318
318
error = -EIO;
319
319
goto cleanup;
···
454
454
if (!ext2_xattr_header_valid(header)) {
455
455
bad_block:
456
456
ext2_error(sb, "ext2_xattr_set",
457
-
"inode %ld: bad block %d", inode->i_ino,
457
+
"inode %llu: bad block %d", inode->i_ino,
458
458
EXT2_I(inode)->i_file_acl);
459
459
error = -EIO;
460
460
goto cleanup;
···
833
833
834
834
if (!ext2_data_block_valid(sbi, EXT2_I(inode)->i_file_acl, 1)) {
835
835
ext2_error(inode->i_sb, "ext2_xattr_delete_inode",
836
-
"inode %ld: xattr block %d is out of data blocks range",
836
+
"inode %llu: xattr block %d is out of data blocks range",
837
837
inode->i_ino, EXT2_I(inode)->i_file_acl);
838
838
goto cleanup;
839
839
}
···
841
841
bh = sb_bread(inode->i_sb, EXT2_I(inode)->i_file_acl);
842
842
if (!bh) {
843
843
ext2_error(inode->i_sb, "ext2_xattr_delete_inode",
844
-
"inode %ld: block %d read error", inode->i_ino,
844
+
"inode %llu: block %d read error", inode->i_ino,
845
845
EXT2_I(inode)->i_file_acl);
846
846
goto cleanup;
847
847
}
848
848
ea_bdebug(bh, "b_count=%d", atomic_read(&(bh->b_count)));
849
849
if (!ext2_xattr_header_valid(HDR(bh))) {
850
850
ext2_error(inode->i_sb, "ext2_xattr_delete_inode",
851
-
"inode %ld: bad block %d", inode->i_ino,
851
+
"inode %llu: bad block %d", inode->i_ino,
852
852
EXT2_I(inode)->i_file_acl);
853
853
goto cleanup;
854
854
}
···
952
952
bh = sb_bread(inode->i_sb, ce->e_value);
953
953
if (!bh) {
954
954
ext2_error(inode->i_sb, "ext2_xattr_cache_find",
955
-
"inode %ld: block %ld read error",
955
+
"inode %llu: block %ld read error",
956
956
inode->i_ino, (unsigned long) ce->e_value);
957
957
} else {
958
958
lock_buffer(bh);
+1
-1
fs/ext4/dir.c
+1
-1
fs/ext4/dir.c
···
535
535
struct super_block *sb = inode->i_sb;
536
536
537
537
if (!fname) {
538
-
ext4_msg(sb, KERN_ERR, "%s:%d: inode #%lu: comm %s: "
538
+
ext4_msg(sb, KERN_ERR, "%s:%d: inode #%llu: comm %s: "
539
539
"called with null fname?!?", __func__, __LINE__,
540
540
inode->i_ino, current->comm);
541
541
return 0;
+2
-2
fs/ext4/ext4.h
+2
-2
fs/ext4/ext4.h
···
92
92
*/
93
93
#ifdef CONFIG_EXT4_DEBUG
94
94
#define ext_debug(ino, fmt, ...) \
95
-
pr_debug("[%s/%d] EXT4-fs (%s): ino %lu: (%s, %d): %s:" fmt, \
95
+
pr_debug("[%s/%d] EXT4-fs (%s): ino %llu: (%s, %d): %s:" fmt, \
96
96
current->comm, task_pid_nr(current), \
97
97
ino->i_sb->s_id, ino->i_ino, __FILE__, __LINE__, \
98
98
__func__, ##__VA_ARGS__)
···
3230
3230
extern __printf(7, 8)
3231
3231
void __ext4_grp_locked_error(const char *, unsigned int,
3232
3232
struct super_block *, ext4_group_t,
3233
-
unsigned long, ext4_fsblk_t,
3233
+
u64, ext4_fsblk_t,
3234
3234
const char *, ...);
3235
3235
3236
3236
#define EXT4_ERROR_INODE(inode, fmt, a...) \
+4
-4
fs/ext4/extents.c
+4
-4
fs/ext4/extents.c
···
4632
4632
}
4633
4633
ret = ext4_map_blocks(handle, inode, &map, flags);
4634
4634
if (ret <= 0) {
4635
-
ext4_debug("inode #%lu: block %u: len %u: "
4635
+
ext4_debug("inode #%llu: block %u: len %u: "
4636
4636
"ext4_ext_map_blocks returned %d",
4637
4637
inode->i_ino, map.m_lblk,
4638
4638
map.m_len, ret);
···
4984
4984
ret = ext4_map_blocks(handle, inode, &map, flags);
4985
4985
if (ret != max_blocks)
4986
4986
ext4_msg(inode->i_sb, KERN_INFO,
4987
-
"inode #%lu: block %u: len %u: "
4987
+
"inode #%llu: block %u: len %u: "
4988
4988
"split block mapping found for atomic write, "
4989
4989
"ret = %d",
4990
4990
inode->i_ino, map.m_lblk,
···
5003
5003
5004
5004
if (ret <= 0 || ret2)
5005
5005
ext4_warning(inode->i_sb,
5006
-
"inode #%lu: block %u: len %u: "
5006
+
"inode #%llu: block %u: len %u: "
5007
5007
"returned %d or %d",
5008
5008
inode->i_ino, map.m_lblk,
5009
5009
map.m_len, ret, ret2);
···
5060
5060
EXT4_EX_NOCACHE);
5061
5061
if (ret <= 0)
5062
5062
ext4_warning(inode->i_sb,
5063
-
"inode #%lu: block %u: len %u: "
5063
+
"inode #%llu: block %u: len %u: "
5064
5064
"ext4_ext_map_blocks returned %d",
5065
5065
inode->i_ino, map.m_lblk,
5066
5066
map.m_len, ret);
+14
-14
fs/ext4/extents_status.c
+14
-14
fs/ext4/extents_status.c
···
214
214
struct ext4_es_tree *tree;
215
215
struct rb_node *node;
216
216
217
-
printk(KERN_DEBUG "status extents for inode %lu:", inode->i_ino);
217
+
printk(KERN_DEBUG "status extents for inode %llu:", inode->i_ino);
218
218
tree = &EXT4_I(inode)->i_es_tree;
219
219
node = rb_first(&tree->root);
220
220
while (node) {
···
703
703
if (!ext4_es_is_written(es) && !ext4_es_is_unwritten(es)) {
704
704
if (in_range(es->es_lblk, ee_block, ee_len)) {
705
705
pr_warn("ES insert assertion failed for "
706
-
"inode: %lu we can find an extent "
706
+
"inode: %llu we can find an extent "
707
707
"at block [%d/%d/%llu/%c], but we "
708
708
"want to add a delayed/hole extent "
709
709
"[%d/%d/%llu/%x]\n",
···
721
721
*/
722
722
if (es->es_lblk < ee_block ||
723
723
ext4_es_pblock(es) != ee_start + es->es_lblk - ee_block) {
724
-
pr_warn("ES insert assertion failed for inode: %lu "
724
+
pr_warn("ES insert assertion failed for inode: %llu "
725
725
"ex_status [%d/%d/%llu/%c] != "
726
726
"es_status [%d/%d/%llu/%c]\n", inode->i_ino,
727
727
ee_block, ee_len, ee_start,
···
731
731
}
732
732
733
733
if (ee_status ^ es_status) {
734
-
pr_warn("ES insert assertion failed for inode: %lu "
734
+
pr_warn("ES insert assertion failed for inode: %llu "
735
735
"ex_status [%d/%d/%llu/%c] != "
736
736
"es_status [%d/%d/%llu/%c]\n", inode->i_ino,
737
737
ee_block, ee_len, ee_start,
···
744
744
* that we don't want to add an written/unwritten extent.
745
745
*/
746
746
if (!ext4_es_is_delayed(es) && !ext4_es_is_hole(es)) {
747
-
pr_warn("ES insert assertion failed for inode: %lu "
747
+
pr_warn("ES insert assertion failed for inode: %llu "
748
748
"can't find an extent at block %d but we want "
749
749
"to add a written/unwritten extent "
750
750
"[%d/%d/%llu/%x]\n", inode->i_ino,
···
779
779
* We want to add a delayed/hole extent but this
780
780
* block has been allocated.
781
781
*/
782
-
pr_warn("ES insert assertion failed for inode: %lu "
782
+
pr_warn("ES insert assertion failed for inode: %llu "
783
783
"We can find blocks but we want to add a "
784
784
"delayed/hole extent [%d/%d/%llu/%x]\n",
785
785
inode->i_ino, es->es_lblk, es->es_len,
···
788
788
} else if (ext4_es_is_written(es)) {
789
789
if (retval != es->es_len) {
790
790
pr_warn("ES insert assertion failed for "
791
-
"inode: %lu retval %d != es_len %d\n",
791
+
"inode: %llu retval %d != es_len %d\n",
792
792
inode->i_ino, retval, es->es_len);
793
793
return;
794
794
}
795
795
if (map.m_pblk != ext4_es_pblock(es)) {
796
796
pr_warn("ES insert assertion failed for "
797
-
"inode: %lu m_pblk %llu != "
797
+
"inode: %llu m_pblk %llu != "
798
798
"es_pblk %llu\n",
799
799
inode->i_ino, map.m_pblk,
800
800
ext4_es_pblock(es));
···
809
809
}
810
810
} else if (retval == 0) {
811
811
if (ext4_es_is_written(es)) {
812
-
pr_warn("ES insert assertion failed for inode: %lu "
812
+
pr_warn("ES insert assertion failed for inode: %llu "
813
813
"We can't find the block but we want to add "
814
814
"a written extent [%d/%d/%llu/%x]\n",
815
815
inode->i_ino, es->es_lblk, es->es_len,
···
919
919
if (EXT4_SB(inode->i_sb)->s_mount_state & EXT4_FC_REPLAY)
920
920
return;
921
921
922
-
es_debug("add [%u/%u) %llu %x %d to extent status tree of inode %lu\n",
922
+
es_debug("add [%u/%u) %llu %x %d to extent status tree of inode %llu\n",
923
923
lblk, len, pblk, status, delalloc_reserve_used, inode->i_ino);
924
924
925
925
if (!len)
···
1631
1631
if (EXT4_SB(inode->i_sb)->s_mount_state & EXT4_FC_REPLAY)
1632
1632
return;
1633
1633
1634
-
es_debug("remove [%u/%u) from extent status tree of inode %lu\n",
1634
+
es_debug("remove [%u/%u) from extent status tree of inode %llu\n",
1635
1635
lblk, len, inode->i_ino);
1636
1636
1637
1637
if (!len)
···
1821
1821
seq_printf(seq, " %lu shrunk objects\n", es_stats->es_stats_shrunk);
1822
1822
if (inode_cnt)
1823
1823
seq_printf(seq,
1824
-
"maximum:\n %lu inode (%u objects, %u reclaimable)\n"
1824
+
"maximum:\n %llu inode (%u objects, %u reclaimable)\n"
1825
1825
" %llu us max scan time\n",
1826
1826
max->vfs_inode.i_ino, max->i_es_all_nr, max->i_es_shk_nr,
1827
1827
div_u64(es_stats->es_stats_max_scan_time, 1000));
···
1998
1998
struct rb_node *node;
1999
1999
struct pending_reservation *pr;
2000
2000
2001
-
printk(KERN_DEBUG "pending reservations for inode %lu:", inode->i_ino);
2001
+
printk(KERN_DEBUG "pending reservations for inode %llu:", inode->i_ino);
2002
2002
tree = &EXT4_I(inode)->i_pending_tree;
2003
2003
node = rb_first(&tree->root);
2004
2004
while (node) {
···
2214
2214
if (EXT4_SB(inode->i_sb)->s_mount_state & EXT4_FC_REPLAY)
2215
2215
return;
2216
2216
2217
-
es_debug("add [%u/%u) delayed to extent status tree of inode %lu\n",
2217
+
es_debug("add [%u/%u) delayed to extent status tree of inode %llu\n",
2218
2218
lblk, len, inode->i_ino);
2219
2219
if (!len)
2220
2220
return;
+4
-4
fs/ext4/fast_commit.c
+4
-4
fs/ext4/fast_commit.c
···
616
616
(struct __track_range_args *)arg;
617
617
618
618
if (inode->i_ino < EXT4_FIRST_INO(inode->i_sb)) {
619
-
ext4_debug("Special inode %ld being modified\n", inode->i_ino);
619
+
ext4_debug("Special inode %llu being modified\n", inode->i_ino);
620
620
return -ECANCELED;
621
621
}
622
622
···
914
914
spin_unlock(&ei->i_fc_lock);
915
915
916
916
cur_lblk_off = old_blk_size;
917
-
ext4_debug("will try writing %d to %d for inode %ld\n",
917
+
ext4_debug("will try writing %d to %d for inode %llu\n",
918
918
cur_lblk_off, new_blk_size, inode->i_ino);
919
919
920
920
while (cur_lblk_off <= new_blk_size) {
···
1795
1795
1796
1796
cur = start;
1797
1797
remaining = len;
1798
-
ext4_debug("ADD_RANGE, lblk %d, pblk %lld, len %d, unwritten %d, inode %ld\n",
1798
+
ext4_debug("ADD_RANGE, lblk %d, pblk %lld, len %d, unwritten %d, inode %llu\n",
1799
1799
start, start_pblk, len, ext4_ext_is_unwritten(ex),
1800
1800
inode->i_ino);
1801
1801
···
1906
1906
if (ret)
1907
1907
goto out;
1908
1908
1909
-
ext4_debug("DEL_RANGE, inode %ld, lblk %d, len %d\n",
1909
+
ext4_debug("DEL_RANGE, inode %llu, lblk %d, len %d\n",
1910
1910
inode->i_ino, le32_to_cpu(lrange.fc_lblk),
1911
1911
le32_to_cpu(lrange.fc_len));
1912
1912
while (remaining > 0) {
+5
-5
fs/ext4/ialloc.c
+5
-5
fs/ext4/ialloc.c
···
253
253
return;
254
254
}
255
255
if (icount_read(inode) > 1) {
256
-
ext4_msg(sb, KERN_ERR, "%s:%d: inode #%lu: count=%d",
256
+
ext4_msg(sb, KERN_ERR, "%s:%d: inode #%llu: count=%d",
257
257
__func__, __LINE__, inode->i_ino,
258
258
icount_read(inode));
259
259
return;
260
260
}
261
261
if (inode->i_nlink) {
262
-
ext4_msg(sb, KERN_ERR, "%s:%d: inode #%lu: nlink=%d\n",
262
+
ext4_msg(sb, KERN_ERR, "%s:%d: inode #%llu: nlink=%d\n",
263
263
__func__, __LINE__, inode->i_ino, inode->i_nlink);
264
264
return;
265
265
}
···
631
631
*
632
632
* So add our directory's i_ino into the starting point for the hash.
633
633
*/
634
-
*group = (*group + parent->i_ino) % ngroups;
634
+
*group = (*group + (unsigned int)parent->i_ino) % ngroups;
635
635
636
636
/*
637
637
* Use a quadratic hash to find a group with a free inode and some free
···
1281
1281
* twice.
1282
1282
*/
1283
1283
err = -EIO;
1284
-
ext4_error(sb, "failed to insert inode %lu: doubly allocated?",
1284
+
ext4_error(sb, "failed to insert inode %llu: doubly allocated?",
1285
1285
inode->i_ino);
1286
1286
ext4_mark_group_bitmap_corrupted(sb, group,
1287
1287
EXT4_GROUP_INFO_IBITMAP_CORRUPT);
···
1350
1350
goto fail_free_drop;
1351
1351
}
1352
1352
1353
-
ext4_debug("allocating inode %lu\n", inode->i_ino);
1353
+
ext4_debug("allocating inode %llu\n", inode->i_ino);
1354
1354
trace_ext4_allocate_inode(inode, dir, mode);
1355
1355
brelse(inode_bitmap_bh);
1356
1356
return ret;
+1
-1
fs/ext4/indirect.c
+1
-1
fs/ext4/indirect.c
···
102
102
offsets[n++] = i_block & (ptrs - 1);
103
103
final = ptrs;
104
104
} else {
105
-
ext4_warning(inode->i_sb, "block %lu > max in inode %lu",
105
+
ext4_warning(inode->i_sb, "block %lu > max in inode %llu",
106
106
i_block + direct_blocks +
107
107
indirect_blocks + double_blocks, inode->i_ino);
108
108
}
+7
-7
fs/ext4/inline.c
+7
-7
fs/ext4/inline.c
···
119
119
error = ext4_get_inode_loc(inode, &iloc);
120
120
if (error) {
121
121
ext4_error_inode_err(inode, __func__, __LINE__, 0, -error,
122
-
"can't get inode location %lu",
122
+
"can't get inode location %llu",
123
123
inode->i_ino);
124
124
return 0;
125
125
}
···
512
512
BUG_ON(folio->index);
513
513
514
514
if (!EXT4_I(inode)->i_inline_off) {
515
-
ext4_warning(inode->i_sb, "inode %lu doesn't have inline data.",
515
+
ext4_warning(inode->i_sb, "inode %llu doesn't have inline data.",
516
516
inode->i_ino);
517
517
goto out;
518
518
}
···
942
942
struct ext4_dir_entry_2 *de = inline_start;
943
943
void *dlimit = inline_start + inline_size;
944
944
945
-
trace_printk("inode %lu\n", dir->i_ino);
945
+
trace_printk("inode %llu\n", dir->i_ino);
946
946
offset = 0;
947
947
while ((void *)de < dlimit) {
948
948
de_len = ext4_rec_len_from_disk(de->rec_len, inline_size);
···
1079
1079
ret = ext4_create_inline_data(handle, inode, inline_size);
1080
1080
if (ret) {
1081
1081
ext4_msg(inode->i_sb, KERN_EMERG,
1082
-
"error restoring inline_data for inode -- potential data loss! (inode %lu, error %d)",
1082
+
"error restoring inline_data for inode -- potential data loss! (inode %llu, error %d)",
1083
1083
inode->i_ino, ret);
1084
1084
return;
1085
1085
}
···
1748
1748
err = ext4_get_inode_loc(dir, &iloc);
1749
1749
if (err) {
1750
1750
EXT4_ERROR_INODE_ERR(dir, -err,
1751
-
"error %d getting inode %lu block",
1751
+
"error %d getting inode %llu block",
1752
1752
err, dir->i_ino);
1753
1753
return false;
1754
1754
}
···
1763
1763
de = (struct ext4_dir_entry_2 *)ext4_raw_inode(&iloc)->i_block;
1764
1764
if (!le32_to_cpu(de->inode)) {
1765
1765
ext4_warning(dir->i_sb,
1766
-
"bad inline directory (dir #%lu) - no `..'",
1766
+
"bad inline directory (dir #%llu) - no `..'",
1767
1767
dir->i_ino);
1768
1768
goto out;
1769
1769
}
···
1777
1777
iloc.bh, inline_pos,
1778
1778
inline_size, offset)) {
1779
1779
ext4_warning(dir->i_sb,
1780
-
"bad inline directory (dir #%lu) - "
1780
+
"bad inline directory (dir #%llu) - "
1781
1781
"inode %u, rec_len %u, name_len %d"
1782
1782
"inline size %d",
1783
1783
dir->i_ino, le32_to_cpu(de->inode),
+11
-11
fs/ext4/inode.c
+11
-11
fs/ext4/inode.c
···
272
272
err = ext4_truncate(inode);
273
273
if (err) {
274
274
ext4_error_err(inode->i_sb, -err,
275
-
"couldn't truncate inode %lu (err %d)",
275
+
"couldn't truncate inode %llu (err %d)",
276
276
inode->i_ino, err);
277
277
goto stop_handle;
278
278
}
···
352
352
spin_lock(&ei->i_block_reservation_lock);
353
353
trace_ext4_da_update_reserve_space(inode, used, quota_claim);
354
354
if (unlikely(used > ei->i_reserved_data_blocks)) {
355
-
ext4_warning(inode->i_sb, "%s: ino %lu, used %d "
355
+
ext4_warning(inode->i_sb, "%s: ino %llu, used %d "
356
356
"with only %d reserved data blocks",
357
357
__func__, inode->i_ino, used,
358
358
ei->i_reserved_data_blocks);
···
485
485
if (es_map->m_lblk != map->m_lblk ||
486
486
es_map->m_flags != map->m_flags ||
487
487
es_map->m_pblk != map->m_pblk) {
488
-
printk("ES cache assertion failed for inode: %lu "
488
+
printk("ES cache assertion failed for inode: %llu "
489
489
"es_cached ex [%d/%d/%llu/%x] != "
490
490
"found ex [%d/%d/%llu/%x] retval %d flags %x\n",
491
491
inode->i_ino, es_map->m_lblk, es_map->m_len,
···
525
525
if (unlikely(retval != map2.m_len)) {
526
526
ext4_warning(inode->i_sb,
527
527
"ES len assertion failed for inode "
528
-
"%lu: retval %d != map->m_len %d",
528
+
"%llu: retval %d != map->m_len %d",
529
529
inode->i_ino, retval, map2.m_len);
530
530
WARN_ON(1);
531
531
}
···
573
573
if (unlikely(retval != map->m_len)) {
574
574
ext4_warning(inode->i_sb,
575
575
"ES len assertion failed for inode "
576
-
"%lu: retval %d != map->m_len %d",
576
+
"%llu: retval %d != map->m_len %d",
577
577
inode->i_ino, retval, map->m_len);
578
578
WARN_ON(1);
579
579
}
···
640
640
641
641
if (unlikely(retval != map->m_len)) {
642
642
ext4_warning(inode->i_sb,
643
-
"ES len assertion failed for inode %lu: "
643
+
"ES len assertion failed for inode %llu: "
644
644
"retval %d != map->m_len %d",
645
645
inode->i_ino, retval, map->m_len);
646
646
WARN_ON(1);
···
947
947
{
948
948
int ret = 0;
949
949
950
-
ext4_debug("ext4_get_block_unwritten: inode %lu, create flag %d\n",
950
+
ext4_debug("ext4_get_block_unwritten: inode %llu, create flag %d\n",
951
951
inode->i_ino, create);
952
952
ret = _ext4_get_block(inode, iblock, bh_result,
953
953
EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT);
···
1669
1669
* harmless to return without any action.
1670
1670
*/
1671
1671
ext4_warning(inode->i_sb, "ext4_da_release_space: "
1672
-
"ino %lu, to_free %d with only %d reserved "
1672
+
"ino %llu, to_free %d with only %d reserved "
1673
1673
"data blocks", inode->i_ino, to_free,
1674
1674
ei->i_reserved_data_blocks);
1675
1675
WARN_ON(1);
···
2501
2501
}
2502
2502
ext4_msg(sb, KERN_CRIT,
2503
2503
"Delayed block allocation failed for "
2504
-
"inode %lu at logical offset %llu with"
2504
+
"inode %llu at logical offset %llu with"
2505
2505
" max blocks %u with error %d",
2506
2506
inode->i_ino,
2507
2507
(unsigned long long)map->m_lblk,
···
2545
2545
err2 = ext4_mark_inode_dirty(handle, inode);
2546
2546
if (err2) {
2547
2547
ext4_error_err(inode->i_sb, -err2,
2548
-
"Failed to mark inode %lu dirty",
2548
+
"Failed to mark inode %llu dirty",
2549
2549
inode->i_ino);
2550
2550
}
2551
2551
if (!err)
···
2919
2919
if (IS_ERR(handle)) {
2920
2920
ret = PTR_ERR(handle);
2921
2921
ext4_msg(inode->i_sb, KERN_CRIT, "%s: jbd2_start: "
2922
-
"%ld pages, ino %lu; err %d", __func__,
2922
+
"%ld pages, ino %llu; err %d", __func__,
2923
2923
wbc->nr_to_write, inode->i_ino, ret);
2924
2924
/* Release allocated io_end */
2925
2925
ext4_put_io_end(mpd->io_submit.io_end);
+2
-2
fs/ext4/ioctl.c
+2
-2
fs/ext4/ioctl.c
···
477
477
if (err < 0) {
478
478
/* No need to update quota information. */
479
479
ext4_warning(inode->i_sb,
480
-
"couldn't mark inode #%lu dirty (err %d)",
480
+
"couldn't mark inode #%llu dirty (err %d)",
481
481
inode->i_ino, err);
482
482
/* Revert all changes: */
483
483
swap_inode_data(inode, inode_bl);
···
493
493
if (err < 0) {
494
494
/* No need to update quota information. */
495
495
ext4_warning(inode_bl->i_sb,
496
-
"couldn't mark inode #%lu dirty (err %d)",
496
+
"couldn't mark inode #%llu dirty (err %d)",
497
497
inode_bl->i_ino, err);
498
498
goto revert;
499
499
}
+3
-3
fs/ext4/mballoc.c
+3
-3
fs/ext4/mballoc.c
···
2268
2268
folio_get(ac->ac_buddy_folio);
2269
2269
/* store last allocated for subsequent stream allocation */
2270
2270
if (ac->ac_flags & EXT4_MB_STREAM_ALLOC) {
2271
-
int hash = ac->ac_inode->i_ino % sbi->s_mb_nr_global_goals;
2271
+
int hash = (unsigned int)ac->ac_inode->i_ino % sbi->s_mb_nr_global_goals;
2272
2272
2273
2273
WRITE_ONCE(sbi->s_mb_last_groups[hash], ac->ac_f_ex.fe_group);
2274
2274
}
···
3038
3038
3039
3039
/* if stream allocation is enabled, use global goal */
3040
3040
if (ac->ac_flags & EXT4_MB_STREAM_ALLOC) {
3041
-
int hash = ac->ac_inode->i_ino % sbi->s_mb_nr_global_goals;
3041
+
int hash = (unsigned int)ac->ac_inode->i_ino % sbi->s_mb_nr_global_goals;
3042
3042
3043
3043
ac->ac_g_ex.fe_group = READ_ONCE(sbi->s_mb_last_groups[hash]);
3044
3044
ac->ac_g_ex.fe_start = -1;
···
5628
5628
if (EXT4_SB(sb)->s_mount_state & EXT4_FC_REPLAY)
5629
5629
return;
5630
5630
5631
-
mb_debug(sb, "discard preallocation for inode %lu\n",
5631
+
mb_debug(sb, "discard preallocation for inode %llu\n",
5632
5632
inode->i_ino);
5633
5633
trace_ext4_discard_preallocations(inode,
5634
5634
atomic_read(&ei->i_prealloc_active));
+1
-1
fs/ext4/migrate.c
+1
-1
fs/ext4/migrate.c
···
455
455
* log, so disable fast commits for this transaction.
456
456
*/
457
457
ext4_fc_mark_ineligible(inode->i_sb, EXT4_FC_REASON_MIGRATE, handle);
458
-
goal = (((inode->i_ino - 1) / EXT4_INODES_PER_GROUP(inode->i_sb)) *
458
+
goal = ((((u32)inode->i_ino - 1) / EXT4_INODES_PER_GROUP(inode->i_sb)) *
459
459
EXT4_INODES_PER_GROUP(inode->i_sb)) + 1;
460
460
owner[0] = i_uid_read(inode);
461
461
owner[1] = i_gid_read(inode);
+10
-10
fs/ext4/move_extent.c
+10
-10
fs/ext4/move_extent.c
···
420
420
421
421
/* origin and donor should be different inodes */
422
422
if (orig_inode == donor_inode) {
423
-
ext4_debug("ext4 move extent: The argument files should not be same inode [ino:orig %lu, donor %lu]\n",
423
+
ext4_debug("ext4 move extent: The argument files should not be same inode [ino:orig %llu, donor %llu]\n",
424
424
orig_inode->i_ino, donor_inode->i_ino);
425
425
return -EINVAL;
426
426
}
427
427
428
428
/* origin and donor should belone to the same filesystem */
429
429
if (orig_inode->i_sb != donor_inode->i_sb) {
430
-
ext4_debug("ext4 move extent: The argument files should be in same FS [ino:orig %lu, donor %lu]\n",
430
+
ext4_debug("ext4 move extent: The argument files should be in same FS [ino:orig %llu, donor %llu]\n",
431
431
orig_inode->i_ino, donor_inode->i_ino);
432
432
return -EINVAL;
433
433
}
434
434
435
435
/* Regular file check */
436
436
if (!S_ISREG(orig_inode->i_mode) || !S_ISREG(donor_inode->i_mode)) {
437
-
ext4_debug("ext4 move extent: The argument files should be regular file [ino:orig %lu, donor %lu]\n",
437
+
ext4_debug("ext4 move extent: The argument files should be regular file [ino:orig %llu, donor %llu]\n",
438
438
orig_inode->i_ino, donor_inode->i_ino);
439
439
return -EINVAL;
440
440
}
···
477
477
}
478
478
479
479
if (donor_inode->i_mode & (S_ISUID|S_ISGID)) {
480
-
ext4_debug("ext4 move extent: suid or sgid is set to donor file [ino:orig %lu, donor %lu]\n",
480
+
ext4_debug("ext4 move extent: suid or sgid is set to donor file [ino:orig %llu, donor %llu]\n",
481
481
orig_inode->i_ino, donor_inode->i_ino);
482
482
return -EINVAL;
483
483
}
484
484
485
485
if (IS_IMMUTABLE(donor_inode) || IS_APPEND(donor_inode)) {
486
-
ext4_debug("ext4 move extent: donor should not be immutable or append file [ino:orig %lu, donor %lu]\n",
486
+
ext4_debug("ext4 move extent: donor should not be immutable or append file [ino:orig %llu, donor %llu]\n",
487
487
orig_inode->i_ino, donor_inode->i_ino);
488
488
return -EPERM;
489
489
}
490
490
491
491
/* Ext4 move extent does not support swap files */
492
492
if (IS_SWAPFILE(orig_inode) || IS_SWAPFILE(donor_inode)) {
493
-
ext4_debug("ext4 move extent: The argument files should not be swap files [ino:orig %lu, donor %lu]\n",
493
+
ext4_debug("ext4 move extent: The argument files should not be swap files [ino:orig %llu, donor %llu]\n",
494
494
orig_inode->i_ino, donor_inode->i_ino);
495
495
return -ETXTBSY;
496
496
}
497
497
498
498
if (ext4_is_quota_file(orig_inode) || ext4_is_quota_file(donor_inode)) {
499
-
ext4_debug("ext4 move extent: The argument files should not be quota files [ino:orig %lu, donor %lu]\n",
499
+
ext4_debug("ext4 move extent: The argument files should not be quota files [ino:orig %llu, donor %llu]\n",
500
500
orig_inode->i_ino, donor_inode->i_ino);
501
501
return -EOPNOTSUPP;
502
502
}
···
523
523
/* Start offset should be same */
524
524
if ((orig_start & ~(PAGE_MASK >> orig_inode->i_blkbits)) !=
525
525
(donor_start & ~(PAGE_MASK >> orig_inode->i_blkbits))) {
526
-
ext4_debug("ext4 move extent: orig and donor's start offsets are not aligned [ino:orig %lu, donor %lu]\n",
526
+
ext4_debug("ext4 move extent: orig and donor's start offsets are not aligned [ino:orig %llu, donor %llu]\n",
527
527
orig_inode->i_ino, donor_inode->i_ino);
528
528
return -EINVAL;
529
529
}
···
533
533
(*len > EXT_MAX_BLOCKS) ||
534
534
(donor_start + *len >= EXT_MAX_BLOCKS) ||
535
535
(orig_start + *len >= EXT_MAX_BLOCKS)) {
536
-
ext4_debug("ext4 move extent: Can't handle over [%u] blocks [ino:orig %lu, donor %lu]\n",
536
+
ext4_debug("ext4 move extent: Can't handle over [%u] blocks [ino:orig %llu, donor %llu]\n",
537
537
EXT_MAX_BLOCKS,
538
538
orig_inode->i_ino, donor_inode->i_ino);
539
539
return -EINVAL;
···
550
550
else if (donor_eof < donor_start + *len - 1)
551
551
*len = donor_eof - donor_start;
552
552
if (!*len) {
553
-
ext4_debug("ext4 move extent: len should not be 0 [ino:orig %lu, donor %lu]\n",
553
+
ext4_debug("ext4 move extent: len should not be 0 [ino:orig %llu, donor %llu]\n",
554
554
orig_inode->i_ino, donor_inode->i_ino);
555
555
return -EINVAL;
556
556
}
+5
-5
fs/ext4/namei.c
+5
-5
fs/ext4/namei.c
···
144
144
bh = ext4_bread(NULL, inode, block, 0);
145
145
if (IS_ERR(bh)) {
146
146
__ext4_warning(inode->i_sb, func, line,
147
-
"inode #%lu: lblock %lu: comm %s: "
147
+
"inode #%llu: lblock %lu: comm %s: "
148
148
"error %ld reading directory block",
149
149
inode->i_ino, (unsigned long)block,
150
150
current->comm, PTR_ERR(bh));
···
841
841
indirect = root->info.indirect_levels;
842
842
if (indirect >= ext4_dir_htree_level(dir->i_sb)) {
843
843
ext4_warning(dir->i_sb,
844
-
"Directory (ino: %lu) htree depth %#06x exceed"
844
+
"Directory (ino: %llu) htree depth %#06x exceed"
845
845
"supported value", dir->i_ino,
846
846
ext4_dir_htree_level(dir->i_sb));
847
847
if (ext4_dir_htree_level(dir->i_sb) < EXT4_HTREE_LEVEL) {
···
1793
1793
(S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) &&
1794
1794
!fscrypt_has_permitted_context(dir, inode)) {
1795
1795
ext4_warning(inode->i_sb,
1796
-
"Inconsistent encryption contexts: %lu/%lu",
1796
+
"Inconsistent encryption contexts: %llu/%llu",
1797
1797
dir->i_ino, inode->i_ino);
1798
1798
iput(inode);
1799
1799
return ERR_PTR(-EPERM);
···
2227
2227
csum_size = sizeof(struct ext4_dir_entry_tail);
2228
2228
2229
2229
blocksize = dir->i_sb->s_blocksize;
2230
-
dxtrace(printk(KERN_DEBUG "Creating index: inode %lu\n", dir->i_ino));
2230
+
dxtrace(printk(KERN_DEBUG "Creating index: inode %llu\n", dir->i_ino));
2231
2231
BUFFER_TRACE(bh, "get_write_access");
2232
2232
retval = ext4_journal_get_write_access(handle, dir->i_sb, bh,
2233
2233
EXT4_JTR_NONE);
···
2523
2523
restart = 1;
2524
2524
}
2525
2525
if (add_level && levels == ext4_dir_htree_level(sb)) {
2526
-
ext4_warning(sb, "Directory (ino: %lu) index full, "
2526
+
ext4_warning(sb, "Directory (ino: %llu) index full, "
2527
2527
"reach max htree level :%d",
2528
2528
dir->i_ino, levels);
2529
2529
if (ext4_dir_htree_level(sb) < EXT4_HTREE_LEVEL) {
+8
-8
fs/ext4/orphan.c
+8
-8
fs/ext4/orphan.c
···
179
179
} else
180
180
brelse(iloc.bh);
181
181
182
-
ext4_debug("superblock will point to %lu\n", inode->i_ino);
183
-
ext4_debug("orphan inode %lu will point to %d\n",
182
+
ext4_debug("superblock will point to %llu\n", inode->i_ino);
183
+
ext4_debug("orphan inode %llu will point to %d\n",
184
184
inode->i_ino, NEXT_ORPHAN(inode));
185
185
out:
186
186
ext4_std_error(sb, err);
···
249
249
}
250
250
251
251
mutex_lock(&sbi->s_orphan_lock);
252
-
ext4_debug("remove inode %lu from orphan list\n", inode->i_ino);
252
+
ext4_debug("remove inode %llu from orphan list\n", inode->i_ino);
253
253
254
254
prev = ei->i_orphan.prev;
255
255
list_del_init(&ei->i_orphan);
···
284
284
struct inode *i_prev =
285
285
&list_entry(prev, struct ext4_inode_info, i_orphan)->vfs_inode;
286
286
287
-
ext4_debug("orphan inode %lu will point to %u\n",
287
+
ext4_debug("orphan inode %llu will point to %u\n",
288
288
i_prev->i_ino, ino_next);
289
289
err = ext4_reserve_inode_write(handle, i_prev, &iloc2);
290
290
if (err) {
···
328
328
if (inode->i_nlink) {
329
329
if (test_opt(sb, DEBUG))
330
330
ext4_msg(sb, KERN_DEBUG,
331
-
"%s: truncating inode %lu to %lld bytes",
331
+
"%s: truncating inode %llu to %lld bytes",
332
332
__func__, inode->i_ino, inode->i_size);
333
-
ext4_debug("truncating inode %lu to %lld bytes\n",
333
+
ext4_debug("truncating inode %llu to %lld bytes\n",
334
334
inode->i_ino, inode->i_size);
335
335
inode_lock(inode);
336
336
truncate_inode_pages(inode->i_mapping, inode->i_size);
···
349
349
} else {
350
350
if (test_opt(sb, DEBUG))
351
351
ext4_msg(sb, KERN_DEBUG,
352
-
"%s: deleting unreferenced inode %lu",
352
+
"%s: deleting unreferenced inode %llu",
353
353
__func__, inode->i_ino);
354
-
ext4_debug("deleting unreferenced inode %lu\n",
354
+
ext4_debug("deleting unreferenced inode %llu\n",
355
355
inode->i_ino);
356
356
(*nr_orphans)++;
357
357
}
+5
-5
fs/ext4/page-io.c
+5
-5
fs/ext4/page-io.c
···
180
180
struct super_block *sb = inode->i_sb;
181
181
int ret = 0;
182
182
183
-
ext4_debug("ext4_end_io_nolock: io_end 0x%p from inode %lu,list->next 0x%p,"
183
+
ext4_debug("ext4_end_io_nolock: io_end 0x%p from inode %llu,list->next 0x%p,"
184
184
"list->prev 0x%p\n",
185
185
io_end, inode->i_ino, io_end->list.next, io_end->list.prev);
186
186
···
204
204
ext4_msg(sb, KERN_EMERG,
205
205
"failed to convert unwritten extents to written "
206
206
"extents -- potential data loss! "
207
-
"(inode %lu, error %d)", inode->i_ino, ret);
207
+
"(inode %llu, error %d)", inode->i_ino, ret);
208
208
}
209
209
210
210
ext4_clear_io_unwritten_flag(io_end);
···
221
221
if (list_empty(head))
222
222
return;
223
223
224
-
ext4_debug("Dump inode %lu completed io list\n", inode->i_ino);
224
+
ext4_debug("Dump inode %llu completed io list\n", inode->i_ino);
225
225
list_for_each_entry(io_end, head, list) {
226
226
cur = &io_end->list;
227
227
before = cur->prev;
···
229
229
after = cur->next;
230
230
io_end1 = container_of(after, ext4_io_end_t, list);
231
231
232
-
ext4_debug("io 0x%p from inode %lu,prev 0x%p,next 0x%p\n",
232
+
ext4_debug("io 0x%p from inode %llu,prev 0x%p,next 0x%p\n",
233
233
io_end, inode->i_ino, io_end0, io_end1);
234
234
}
235
235
#endif
···
366
366
if (bio->bi_status) {
367
367
struct inode *inode = io_end->inode;
368
368
369
-
ext4_warning(inode->i_sb, "I/O error %d writing to inode %lu "
369
+
ext4_warning(inode->i_sb, "I/O error %d writing to inode %llu "
370
370
"starting block %llu)",
371
371
bio->bi_status, inode->i_ino,
372
372
(unsigned long long)
+11
-11
fs/ext4/super.c
+11
-11
fs/ext4/super.c
···
848
848
vaf.va = &args;
849
849
if (block)
850
850
printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: "
851
-
"inode #%lu: block %llu: comm %s: %pV\n",
851
+
"inode #%llu: block %llu: comm %s: %pV\n",
852
852
inode->i_sb->s_id, function, line, inode->i_ino,
853
853
block, current->comm, &vaf);
854
854
else
855
855
printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: "
856
-
"inode #%lu: comm %s: %pV\n",
856
+
"inode #%llu: comm %s: %pV\n",
857
857
inode->i_sb->s_id, function, line, inode->i_ino,
858
858
current->comm, &vaf);
859
859
va_end(args);
···
888
888
vaf.va = &args;
889
889
if (block)
890
890
printk(KERN_CRIT
891
-
"EXT4-fs error (device %s): %s:%d: inode #%lu: "
891
+
"EXT4-fs error (device %s): %s:%d: inode #%llu: "
892
892
"block %llu: comm %s: path %s: %pV\n",
893
893
inode->i_sb->s_id, function, line, inode->i_ino,
894
894
block, current->comm, path, &vaf);
895
895
else
896
896
printk(KERN_CRIT
897
-
"EXT4-fs error (device %s): %s:%d: inode #%lu: "
897
+
"EXT4-fs error (device %s): %s:%d: inode #%llu: "
898
898
"comm %s: path %s: %pV\n",
899
899
inode->i_sb->s_id, function, line, inode->i_ino,
900
900
current->comm, path, &vaf);
···
1035
1035
vaf.fmt = fmt;
1036
1036
vaf.va = &args;
1037
1037
printk(KERN_WARNING "EXT4-fs warning (device %s): %s:%d: "
1038
-
"inode #%lu: comm %s: %pV\n", inode->i_sb->s_id,
1038
+
"inode #%llu: comm %s: %pV\n", inode->i_sb->s_id,
1039
1039
function, line, inode->i_ino, current->comm, &vaf);
1040
1040
va_end(args);
1041
1041
}
1042
1042
1043
1043
void __ext4_grp_locked_error(const char *function, unsigned int line,
1044
1044
struct super_block *sb, ext4_group_t grp,
1045
-
unsigned long ino, ext4_fsblk_t block,
1045
+
u64 ino, ext4_fsblk_t block,
1046
1046
const char *fmt, ...)
1047
1047
__releases(bitlock)
1048
1048
__acquires(bitlock)
···
1061
1061
printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: group %u, ",
1062
1062
sb->s_id, function, line, grp);
1063
1063
if (ino)
1064
-
printk(KERN_CONT "inode %lu: ", ino);
1064
+
printk(KERN_CONT "inode %llu: ", ino);
1065
1065
if (block)
1066
1066
printk(KERN_CONT "block %llu:",
1067
1067
(unsigned long long) block);
···
1170
1170
list_for_each(l, &sbi->s_orphan) {
1171
1171
struct inode *inode = orphan_list_entry(l);
1172
1172
printk(KERN_ERR " "
1173
-
"inode %s:%lu at %p: mode %o, nlink %d, next %d\n",
1173
+
"inode %s:%llu at %p: mode %o, nlink %d, next %d\n",
1174
1174
inode->i_sb->s_id, inode->i_ino, inode,
1175
1175
inode->i_mode, inode->i_nlink,
1176
1176
NEXT_ORPHAN(inode));
···
1442
1442
{
1443
1443
fscrypt_free_inode(inode);
1444
1444
if (!list_empty(&(EXT4_I(inode)->i_fc_list))) {
1445
-
pr_warn("%s: inode %ld still in fc list",
1445
+
pr_warn("%s: inode %llu still in fc list",
1446
1446
__func__, inode->i_ino);
1447
1447
}
1448
1448
kmem_cache_free(ext4_inode_cachep, EXT4_I(inode));
···
1452
1452
{
1453
1453
if (ext4_inode_orphan_tracked(inode)) {
1454
1454
ext4_msg(inode->i_sb, KERN_ERR,
1455
-
"Inode %lu (%p): inode tracked as orphan!",
1455
+
"Inode %llu (%p): inode tracked as orphan!",
1456
1456
inode->i_ino, EXT4_I(inode));
1457
1457
print_hex_dump(KERN_INFO, "", DUMP_PREFIX_ADDRESS, 16, 4,
1458
1458
EXT4_I(inode), sizeof(struct ext4_inode_info),
···
1463
1463
if (!(EXT4_SB(inode->i_sb)->s_mount_state & EXT4_ERROR_FS) &&
1464
1464
WARN_ON_ONCE(EXT4_I(inode)->i_reserved_data_blocks))
1465
1465
ext4_msg(inode->i_sb, KERN_ERR,
1466
-
"Inode %lu (%p): i_reserved_data_blocks (%u) not cleared!",
1466
+
"Inode %llu (%p): i_reserved_data_blocks (%u) not cleared!",
1467
1467
inode->i_ino, EXT4_I(inode),
1468
1468
EXT4_I(inode)->i_reserved_data_blocks);
1469
1469
}
+5
-5
fs/ext4/xattr.c
+5
-5
fs/ext4/xattr.c
···
64
64
65
65
#ifdef EXT4_XATTR_DEBUG
66
66
# define ea_idebug(inode, fmt, ...) \
67
-
printk(KERN_DEBUG "inode %s:%lu: " fmt "\n", \
67
+
printk(KERN_DEBUG "inode %s:%llu: " fmt "\n", \
68
68
inode->i_sb->s_id, inode->i_ino, ##__VA_ARGS__)
69
69
# define ea_bdebug(bh, fmt, ...) \
70
70
printk(KERN_DEBUG "block %pg:%lu: " fmt "\n", \
···
1035
1035
ref_count = ext4_xattr_inode_get_ref(ea_inode);
1036
1036
if ((ref_count == 0 && ref_change < 0) || (ref_count == U64_MAX && ref_change > 0)) {
1037
1037
ext4_error_inode(ea_inode, __func__, __LINE__, 0,
1038
-
"EA inode %lu ref wraparound: ref_count=%lld ref_change=%d",
1038
+
"EA inode %llu ref wraparound: ref_count=%lld ref_change=%d",
1039
1039
ea_inode->i_ino, ref_count, ref_change);
1040
1040
brelse(iloc.bh);
1041
1041
ret = -EFSCORRUPTED;
···
1046
1046
1047
1047
if (ref_change > 0) {
1048
1048
if (ref_count == 1) {
1049
-
WARN_ONCE(ea_inode->i_nlink, "EA inode %lu i_nlink=%u",
1049
+
WARN_ONCE(ea_inode->i_nlink, "EA inode %llu i_nlink=%u",
1050
1050
ea_inode->i_ino, ea_inode->i_nlink);
1051
1051
1052
1052
set_nlink(ea_inode, 1);
···
1055
1055
} else {
1056
1056
if (ref_count == 0) {
1057
1057
WARN_ONCE(ea_inode->i_nlink != 1,
1058
-
"EA inode %lu i_nlink=%u",
1058
+
"EA inode %llu i_nlink=%u",
1059
1059
ea_inode->i_ino, ea_inode->i_nlink);
1060
1060
1061
1061
clear_nlink(ea_inode);
···
2854
2854
2855
2855
cleanup:
2856
2856
if (error && (mnt_count != le16_to_cpu(sbi->s_es->s_mnt_count))) {
2857
-
ext4_warning(inode->i_sb, "Unable to expand inode %lu. Delete some EAs or run e2fsck.",
2857
+
ext4_warning(inode->i_sb, "Unable to expand inode %llu. Delete some EAs or run e2fsck.",
2858
2858
inode->i_ino);
2859
2859
mnt_count = le16_to_cpu(sbi->s_es->s_mnt_count);
2860
2860
}
+2
-2
fs/f2fs/compress.c
+2
-2
fs/f2fs/compress.c
···
773
773
if (!is_inode_flag_set(dic->inode, FI_COMPRESS_CORRUPT)) {
774
774
set_inode_flag(dic->inode, FI_COMPRESS_CORRUPT);
775
775
f2fs_info_ratelimited(sbi,
776
-
"checksum invalid, nid = %lu, %x vs %x",
776
+
"checksum invalid, nid = %llu, %x vs %x",
777
777
dic->inode->i_ino,
778
778
provided, calculated);
779
779
}
···
932
932
933
933
return false;
934
934
out:
935
-
f2fs_warn(sbi, "access invalid cluster, ino:%lu, nid:%u, ofs_in_node:%u, reason:%s",
935
+
f2fs_warn(sbi, "access invalid cluster, ino:%llu, nid:%u, ofs_in_node:%u, reason:%s",
936
936
dn->inode->i_ino, dn->nid, dn->ofs_in_node, reason);
937
937
set_sbi_flag(sbi, SBI_NEED_FSCK);
938
938
return true;
+1
-1
fs/f2fs/dir.c
+1
-1
fs/f2fs/dir.c
···
368
368
369
369
max_depth = F2FS_I(dir)->i_current_depth;
370
370
if (unlikely(max_depth > MAX_DIR_HASH_DEPTH)) {
371
-
f2fs_warn(F2FS_I_SB(dir), "Corrupted max_depth of %lu: %u",
371
+
f2fs_warn(F2FS_I_SB(dir), "Corrupted max_depth of %llu: %u",
372
372
dir->i_ino, max_depth);
373
373
max_depth = MAX_DIR_HASH_DEPTH;
374
374
f2fs_i_depth_write(dir, max_depth);
+4
-4
fs/f2fs/extent_cache.c
+4
-4
fs/f2fs/extent_cache.c
···
34
34
if (!f2fs_is_valid_blkaddr(sbi, ei.blk, DATA_GENERIC_ENHANCE) ||
35
35
!f2fs_is_valid_blkaddr(sbi, ei.blk + ei.len - 1,
36
36
DATA_GENERIC_ENHANCE)) {
37
-
f2fs_warn(sbi, "%s: inode (ino=%lx) extent info [%u, %u, %u] is incorrect, run fsck to fix",
37
+
f2fs_warn(sbi, "%s: inode (ino=%llx) extent info [%u, %u, %u] is incorrect, run fsck to fix",
38
38
__func__, inode->i_ino,
39
39
ei.blk, ei.fofs, ei.len);
40
40
return false;
···
50
50
51
51
if (devi == 0) {
52
52
f2fs_warn(sbi,
53
-
"%s: inode (ino=%lx) is an alias of meta device",
53
+
"%s: inode (ino=%llx) is an alias of meta device",
54
54
__func__, inode->i_ino);
55
55
return false;
56
56
}
57
57
58
58
if (bdev_is_zoned(FDEV(devi).bdev)) {
59
59
f2fs_warn(sbi,
60
-
"%s: device alias inode (ino=%lx)'s extent info "
60
+
"%s: device alias inode (ino=%llx)'s extent info "
61
61
"[%u, %u, %u] maps to zoned block device",
62
62
__func__, inode->i_ino, ei.blk, ei.fofs, ei.len);
63
63
return false;
···
65
65
return true;
66
66
}
67
67
68
-
f2fs_warn(sbi, "%s: device alias inode (ino=%lx)'s extent info "
68
+
f2fs_warn(sbi, "%s: device alias inode (ino=%llx)'s extent info "
69
69
"[%u, %u, %u] is inconsistent w/ any devices",
70
70
__func__, inode->i_ino, ei.blk, ei.fofs, ei.len);
71
71
return false;
+3
-3
fs/f2fs/f2fs.h
+3
-3
fs/f2fs/f2fs.h
···
2706
2706
2707
2707
spin_lock(&sbi->stat_lock);
2708
2708
if (unlikely(sbi->total_valid_block_count < count)) {
2709
-
f2fs_warn(sbi, "Inconsistent total_valid_block_count:%u, ino:%lu, count:%u",
2709
+
f2fs_warn(sbi, "Inconsistent total_valid_block_count:%u, ino:%llu, count:%u",
2710
2710
sbi->total_valid_block_count, inode->i_ino, count);
2711
2711
sbi->total_valid_block_count = 0;
2712
2712
set_sbi_flag(sbi, SBI_NEED_FSCK);
···
2719
2719
sbi->current_reserved_blocks + count);
2720
2720
spin_unlock(&sbi->stat_lock);
2721
2721
if (unlikely(inode->i_blocks < sectors)) {
2722
-
f2fs_warn(sbi, "Inconsistent i_blocks, ino:%lu, iblocks:%llu, sectors:%llu",
2722
+
f2fs_warn(sbi, "Inconsistent i_blocks, ino:%llu, iblocks:%llu, sectors:%llu",
2723
2723
inode->i_ino,
2724
2724
(unsigned long long)inode->i_blocks,
2725
2725
(unsigned long long)sectors);
···
2993
2993
dquot_free_inode(inode);
2994
2994
} else {
2995
2995
if (unlikely(inode->i_blocks == 0)) {
2996
-
f2fs_warn(sbi, "dec_valid_node_count: inconsistent i_blocks, ino:%lu, iblocks:%llu",
2996
+
f2fs_warn(sbi, "dec_valid_node_count: inconsistent i_blocks, ino:%llu, iblocks:%llu",
2997
2997
inode->i_ino,
2998
2998
(unsigned long long)inode->i_blocks);
2999
2999
set_sbi_flag(sbi, SBI_NEED_FSCK);
+6
-6
fs/f2fs/file.c
+6
-6
fs/f2fs/file.c
···
1917
1917
f2fs_up_write(&sbi->pin_sem);
1918
1918
err = -ENOSPC;
1919
1919
f2fs_warn_ratelimited(sbi,
1920
-
"ino:%lu, start:%lu, end:%lu, need to trigger GC to "
1920
+
"ino:%llu, start:%lu, end:%lu, need to trigger GC to "
1921
1921
"reclaim enough free segment when checkpoint is enabled",
1922
1922
inode->i_ino, pg_start, pg_end);
1923
1923
goto out_err;
···
2307
2307
* f2fs_is_atomic_file.
2308
2308
*/
2309
2309
if (get_dirty_pages(inode))
2310
-
f2fs_warn(sbi, "Unexpected flush for atomic writes: ino=%lu, npages=%u",
2310
+
f2fs_warn(sbi, "Unexpected flush for atomic writes: ino=%llu, npages=%u",
2311
2311
inode->i_ino, get_dirty_pages(inode));
2312
2312
ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX);
2313
2313
if (ret)
···
3494
3494
return -EINVAL;
3495
3495
3496
3496
if (fi->i_gc_failures >= sbi->gc_pin_file_threshold) {
3497
-
f2fs_warn(sbi, "%s: Enable GC = ino %lx after %x GC trials",
3497
+
f2fs_warn(sbi, "%s: Enable GC = ino %llx after %x GC trials",
3498
3498
__func__, inode->i_ino, fi->i_gc_failures);
3499
3499
clear_inode_flag(inode, FI_PIN_FILE);
3500
3500
return -EAGAIN;
···
3679
3679
3680
3680
if (!f2fs_sb_has_verity(F2FS_I_SB(inode))) {
3681
3681
f2fs_warn(F2FS_I_SB(inode),
3682
-
"Can't enable fs-verity on inode %lu: the verity feature is not enabled on this filesystem",
3682
+
"Can't enable fs-verity on inode %llu: the verity feature is not enabled on this filesystem",
3683
3683
inode->i_ino);
3684
3684
return -EOPNOTSUPP;
3685
3685
}
···
3950
3950
} else if (released_blocks &&
3951
3951
atomic_read(&fi->i_compr_blocks)) {
3952
3952
set_sbi_flag(sbi, SBI_NEED_FSCK);
3953
-
f2fs_warn(sbi, "%s: partial blocks were released i_ino=%lx "
3953
+
f2fs_warn(sbi, "%s: partial blocks were released i_ino=%llx "
3954
3954
"iblocks=%llu, released=%u, compr_blocks=%u, "
3955
3955
"run fsck to fix.",
3956
3956
__func__, inode->i_ino, inode->i_blocks,
···
4133
4133
} else if (reserved_blocks &&
4134
4134
atomic_read(&fi->i_compr_blocks)) {
4135
4135
set_sbi_flag(sbi, SBI_NEED_FSCK);
4136
-
f2fs_warn(sbi, "%s: partial blocks were reserved i_ino=%lx "
4136
+
f2fs_warn(sbi, "%s: partial blocks were reserved i_ino=%llx "
4137
4137
"iblocks=%llu, reserved=%u, compr_blocks=%u, "
4138
4138
"run fsck to fix.",
4139
4139
__func__, inode->i_ino, inode->i_blocks,
+1
-1
fs/f2fs/gc.c
+1
-1
fs/f2fs/gc.c
···
1622
1622
iput(inode);
1623
1623
set_sbi_flag(sbi, SBI_NEED_FSCK);
1624
1624
f2fs_err_ratelimited(sbi,
1625
-
"inode %lx has both inline_data flag and "
1625
+
"inode %llu has both inline_data flag and "
1626
1626
"data block, nid=%u, ofs_in_node=%u",
1627
1627
inode->i_ino, dni.nid, ofs_in_node);
1628
1628
continue;
+2
-2
fs/f2fs/inline.c
+2
-2
fs/f2fs/inline.c
···
176
176
if (unlikely(dn->data_blkaddr != NEW_ADDR)) {
177
177
f2fs_put_dnode(dn);
178
178
set_sbi_flag(fio.sbi, SBI_NEED_FSCK);
179
-
f2fs_warn(fio.sbi, "%s: corrupted inline inode ino=%lx, i_addr[0]:0x%x, run fsck to fix.",
179
+
f2fs_warn(fio.sbi, "%s: corrupted inline inode ino=%llu, i_addr[0]:0x%x, run fsck to fix.",
180
180
__func__, dn->inode->i_ino, dn->data_blkaddr);
181
181
f2fs_handle_error(fio.sbi, ERROR_INVALID_BLKADDR);
182
182
return -EFSCORRUPTED;
···
431
431
if (unlikely(dn.data_blkaddr != NEW_ADDR)) {
432
432
f2fs_put_dnode(&dn);
433
433
set_sbi_flag(F2FS_F_SB(folio), SBI_NEED_FSCK);
434
-
f2fs_warn(F2FS_F_SB(folio), "%s: corrupted inline inode ino=%lx, i_addr[0]:0x%x, run fsck to fix.",
434
+
f2fs_warn(F2FS_F_SB(folio), "%s: corrupted inline inode ino=%llu, i_addr[0]:0x%x, run fsck to fix.",
435
435
__func__, dir->i_ino, dn.data_blkaddr);
436
436
f2fs_handle_error(F2FS_F_SB(folio), ERROR_INVALID_BLKADDR);
437
437
err = -EFSCORRUPTED;
+24
-24
fs/f2fs/inode.c
+24
-24
fs/f2fs/inode.c
···
203
203
204
204
if (ri->i_compress_algorithm >= COMPRESS_MAX) {
205
205
f2fs_warn(sbi,
206
-
"%s: inode (ino=%lx) has unsupported compress algorithm: %u, run fsck to fix",
206
+
"%s: inode (ino=%llx) has unsupported compress algorithm: %u, run fsck to fix",
207
207
__func__, inode->i_ino, ri->i_compress_algorithm);
208
208
return false;
209
209
}
210
210
if (le64_to_cpu(ri->i_compr_blocks) >
211
211
SECTOR_TO_BLOCK(inode->i_blocks)) {
212
212
f2fs_warn(sbi,
213
-
"%s: inode (ino=%lx) has inconsistent i_compr_blocks:%llu, i_blocks:%llu, run fsck to fix",
213
+
"%s: inode (ino=%llx) has inconsistent i_compr_blocks:%llu, i_blocks:%llu, run fsck to fix",
214
214
__func__, inode->i_ino, le64_to_cpu(ri->i_compr_blocks),
215
215
SECTOR_TO_BLOCK(inode->i_blocks));
216
216
return false;
···
218
218
if (ri->i_log_cluster_size < MIN_COMPRESS_LOG_SIZE ||
219
219
ri->i_log_cluster_size > MAX_COMPRESS_LOG_SIZE) {
220
220
f2fs_warn(sbi,
221
-
"%s: inode (ino=%lx) has unsupported log cluster size: %u, run fsck to fix",
221
+
"%s: inode (ino=%llx) has unsupported log cluster size: %u, run fsck to fix",
222
222
__func__, inode->i_ino, ri->i_log_cluster_size);
223
223
return false;
224
224
}
···
262
262
263
263
return true;
264
264
err_level:
265
-
f2fs_warn(sbi, "%s: inode (ino=%lx) has unsupported compress level: %u, run fsck to fix",
265
+
f2fs_warn(sbi, "%s: inode (ino=%llx) has unsupported compress level: %u, run fsck to fix",
266
266
__func__, inode->i_ino, clevel);
267
267
return false;
268
268
}
···
276
276
277
277
iblocks = le64_to_cpu(F2FS_INODE(node_folio)->i_blocks);
278
278
if (!iblocks) {
279
-
f2fs_warn(sbi, "%s: corrupted inode i_blocks i_ino=%lx iblocks=%llu, run fsck to fix.",
279
+
f2fs_warn(sbi, "%s: corrupted inode i_blocks i_ino=%llx iblocks=%llu, run fsck to fix.",
280
280
__func__, inode->i_ino, iblocks);
281
281
return false;
282
282
}
283
283
284
284
if (ino_of_node(node_folio) != nid_of_node(node_folio)) {
285
-
f2fs_warn(sbi, "%s: corrupted inode footer i_ino=%lx, ino,nid: [%u, %u] run fsck to fix.",
285
+
f2fs_warn(sbi, "%s: corrupted inode footer i_ino=%llx, ino,nid: [%u, %u] run fsck to fix.",
286
286
__func__, inode->i_ino,
287
287
ino_of_node(node_folio), nid_of_node(node_folio));
288
288
return false;
289
289
}
290
290
291
291
if (ino_of_node(node_folio) == fi->i_xattr_nid) {
292
-
f2fs_warn(sbi, "%s: corrupted inode i_ino=%lx, xnid=%x, run fsck to fix.",
292
+
f2fs_warn(sbi, "%s: corrupted inode i_ino=%llx, xnid=%x, run fsck to fix.",
293
293
__func__, inode->i_ino, fi->i_xattr_nid);
294
294
return false;
295
295
}
296
296
297
297
if (S_ISDIR(inode->i_mode) && unlikely(inode->i_nlink == 1)) {
298
-
f2fs_warn(sbi, "%s: directory inode (ino=%lx) has a single i_nlink",
298
+
f2fs_warn(sbi, "%s: directory inode (ino=%llx) has a single i_nlink",
299
299
__func__, inode->i_ino);
300
300
return false;
301
301
}
302
302
303
303
if (f2fs_has_extra_attr(inode)) {
304
304
if (!f2fs_sb_has_extra_attr(sbi)) {
305
-
f2fs_warn(sbi, "%s: inode (ino=%lx) is with extra_attr, but extra_attr feature is off",
305
+
f2fs_warn(sbi, "%s: inode (ino=%llx) is with extra_attr, but extra_attr feature is off",
306
306
__func__, inode->i_ino);
307
307
return false;
308
308
}
309
309
if (fi->i_extra_isize > F2FS_TOTAL_EXTRA_ATTR_SIZE ||
310
310
fi->i_extra_isize < F2FS_MIN_EXTRA_ATTR_SIZE ||
311
311
fi->i_extra_isize % sizeof(__le32)) {
312
-
f2fs_warn(sbi, "%s: inode (ino=%lx) has corrupted i_extra_isize: %d, max: %zu",
312
+
f2fs_warn(sbi, "%s: inode (ino=%llx) has corrupted i_extra_isize: %d, max: %zu",
313
313
__func__, inode->i_ino, fi->i_extra_isize,
314
314
F2FS_TOTAL_EXTRA_ATTR_SIZE);
315
315
return false;
···
327
327
f2fs_has_inline_xattr(inode) &&
328
328
(fi->i_inline_xattr_size < MIN_INLINE_XATTR_SIZE ||
329
329
fi->i_inline_xattr_size > MAX_INLINE_XATTR_SIZE)) {
330
-
f2fs_warn(sbi, "%s: inode (ino=%lx) has corrupted i_inline_xattr_size: %d, min: %zu, max: %lu",
330
+
f2fs_warn(sbi, "%s: inode (ino=%llx) has corrupted i_inline_xattr_size: %d, min: %zu, max: %lu",
331
331
__func__, inode->i_ino, fi->i_inline_xattr_size,
332
332
MIN_INLINE_XATTR_SIZE, MAX_INLINE_XATTR_SIZE);
333
333
return false;
···
335
335
336
336
if (!f2fs_sb_has_extra_attr(sbi)) {
337
337
if (f2fs_sb_has_project_quota(sbi)) {
338
-
f2fs_warn(sbi, "%s: corrupted inode ino=%lx, wrong feature flag: %u, run fsck to fix.",
338
+
f2fs_warn(sbi, "%s: corrupted inode ino=%llx, wrong feature flag: %u, run fsck to fix.",
339
339
__func__, inode->i_ino, F2FS_FEATURE_PRJQUOTA);
340
340
return false;
341
341
}
342
342
if (f2fs_sb_has_inode_chksum(sbi)) {
343
-
f2fs_warn(sbi, "%s: corrupted inode ino=%lx, wrong feature flag: %u, run fsck to fix.",
343
+
f2fs_warn(sbi, "%s: corrupted inode ino=%llx, wrong feature flag: %u, run fsck to fix.",
344
344
__func__, inode->i_ino, F2FS_FEATURE_INODE_CHKSUM);
345
345
return false;
346
346
}
347
347
if (f2fs_sb_has_flexible_inline_xattr(sbi)) {
348
-
f2fs_warn(sbi, "%s: corrupted inode ino=%lx, wrong feature flag: %u, run fsck to fix.",
348
+
f2fs_warn(sbi, "%s: corrupted inode ino=%llx, wrong feature flag: %u, run fsck to fix.",
349
349
__func__, inode->i_ino, F2FS_FEATURE_FLEXIBLE_INLINE_XATTR);
350
350
return false;
351
351
}
352
352
if (f2fs_sb_has_inode_crtime(sbi)) {
353
-
f2fs_warn(sbi, "%s: corrupted inode ino=%lx, wrong feature flag: %u, run fsck to fix.",
353
+
f2fs_warn(sbi, "%s: corrupted inode ino=%llx, wrong feature flag: %u, run fsck to fix.",
354
354
__func__, inode->i_ino, F2FS_FEATURE_INODE_CRTIME);
355
355
return false;
356
356
}
357
357
if (f2fs_sb_has_compression(sbi)) {
358
-
f2fs_warn(sbi, "%s: corrupted inode ino=%lx, wrong feature flag: %u, run fsck to fix.",
358
+
f2fs_warn(sbi, "%s: corrupted inode ino=%llx, wrong feature flag: %u, run fsck to fix.",
359
359
__func__, inode->i_ino, F2FS_FEATURE_COMPRESSION);
360
360
return false;
361
361
}
362
362
}
363
363
364
364
if (f2fs_sanity_check_inline_data(inode, node_folio)) {
365
-
f2fs_warn(sbi, "%s: inode (ino=%lx, mode=%u) should not have inline_data, run fsck to fix",
365
+
f2fs_warn(sbi, "%s: inode (ino=%llx, mode=%u) should not have inline_data, run fsck to fix",
366
366
__func__, inode->i_ino, inode->i_mode);
367
367
return false;
368
368
}
369
369
370
370
if (f2fs_has_inline_dentry(inode) && !S_ISDIR(inode->i_mode)) {
371
-
f2fs_warn(sbi, "%s: inode (ino=%lx, mode=%u) should not have inline_dentry, run fsck to fix",
371
+
f2fs_warn(sbi, "%s: inode (ino=%llx, mode=%u) should not have inline_dentry, run fsck to fix",
372
372
__func__, inode->i_ino, inode->i_mode);
373
373
return false;
374
374
}
375
375
376
376
if ((fi->i_flags & F2FS_CASEFOLD_FL) && !f2fs_sb_has_casefold(sbi)) {
377
-
f2fs_warn(sbi, "%s: inode (ino=%lx) has casefold flag, but casefold feature is off",
377
+
f2fs_warn(sbi, "%s: inode (ino=%llx) has casefold flag, but casefold feature is off",
378
378
__func__, inode->i_ino);
379
379
return false;
380
380
}
381
381
382
382
if (fi->i_xattr_nid && f2fs_check_nid_range(sbi, fi->i_xattr_nid)) {
383
-
f2fs_warn(sbi, "%s: inode (ino=%lx) has corrupted i_xattr_nid: %u, run fsck to fix.",
383
+
f2fs_warn(sbi, "%s: inode (ino=%llx) has corrupted i_xattr_nid: %u, run fsck to fix.",
384
384
__func__, inode->i_ino, fi->i_xattr_nid);
385
385
return false;
386
386
}
387
387
388
388
if (IS_DEVICE_ALIASING(inode)) {
389
389
if (!f2fs_sb_has_device_alias(sbi)) {
390
-
f2fs_warn(sbi, "%s: inode (ino=%lx) has device alias flag, but the feature is off",
390
+
f2fs_warn(sbi, "%s: inode (ino=%llx) has device alias flag, but the feature is off",
391
391
__func__, inode->i_ino);
392
392
return false;
393
393
}
394
394
if (!f2fs_is_pinned_file(inode)) {
395
-
f2fs_warn(sbi, "%s: inode (ino=%lx) has device alias flag, but is not pinned",
395
+
f2fs_warn(sbi, "%s: inode (ino=%llx) has device alias flag, but is not pinned",
396
396
__func__, inode->i_ino);
397
397
return false;
398
398
}
···
925
925
*/
926
926
if (is_inode_flag_set(inode, FI_DIRTY_INODE)) {
927
927
f2fs_warn(F2FS_I_SB(inode),
928
-
"f2fs_evict_inode: inconsistent node id, ino:%lu",
928
+
"f2fs_evict_inode: inconsistent node id, ino:%llu",
929
929
inode->i_ino);
930
930
f2fs_inode_synced(inode);
931
931
set_sbi_flag(sbi, SBI_NEED_FSCK);
···
954
954
*/
955
955
if (is_inode_flag_set(inode, FI_DIRTY_INODE)) {
956
956
f2fs_warn(sbi,
957
-
"f2fs_evict_inode: inode is dirty, ino:%lu",
957
+
"f2fs_evict_inode: inode is dirty, ino:%llu",
958
958
inode->i_ino);
959
959
f2fs_inode_synced(inode);
960
960
set_sbi_flag(sbi, SBI_NEED_FSCK);
+4
-4
fs/f2fs/namei.c
+4
-4
fs/f2fs/namei.c
···
505
505
}
506
506
507
507
if (inode->i_nlink == 0) {
508
-
f2fs_warn(F2FS_I_SB(inode), "%s: inode (ino=%lx) has zero i_nlink",
508
+
f2fs_warn(F2FS_I_SB(inode), "%s: inode (ino=%llx) has zero i_nlink",
509
509
__func__, inode->i_ino);
510
510
err = -EFSCORRUPTED;
511
511
set_sbi_flag(F2FS_I_SB(inode), SBI_NEED_FSCK);
···
515
515
if (IS_ENCRYPTED(dir) &&
516
516
(S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) &&
517
517
!fscrypt_has_permitted_context(dir, inode)) {
518
-
f2fs_warn(F2FS_I_SB(inode), "Inconsistent encryption contexts: %lu/%lu",
518
+
f2fs_warn(F2FS_I_SB(inode), "Inconsistent encryption contexts: %llu/%llu",
519
519
dir->i_ino, inode->i_ino);
520
520
err = -EPERM;
521
521
goto out_iput;
···
573
573
}
574
574
575
575
if (unlikely(inode->i_nlink == 0)) {
576
-
f2fs_warn(sbi, "%s: inode (ino=%lx) has zero i_nlink",
576
+
f2fs_warn(sbi, "%s: inode (ino=%llx) has zero i_nlink",
577
577
__func__, inode->i_ino);
578
578
goto corrupted;
579
579
} else if (S_ISDIR(inode->i_mode) && unlikely(inode->i_nlink == 1)) {
580
-
f2fs_warn(sbi, "%s: directory inode (ino=%lx) has a single i_nlink",
580
+
f2fs_warn(sbi, "%s: directory inode (ino=%llx) has a single i_nlink",
581
581
__func__, inode->i_ino);
582
582
goto corrupted;
583
583
}
+6
-6
fs/f2fs/node.c
+6
-6
fs/f2fs/node.c
···
847
847
err = -EFSCORRUPTED;
848
848
f2fs_err_ratelimited(sbi,
849
849
"inode mapping table is corrupted, run fsck to fix it, "
850
-
"ino:%lu, nid:%u, level:%d, offset:%d",
850
+
"ino:%llu, nid:%u, level:%d, offset:%d",
851
851
dn->inode->i_ino, nids[i], level, offset[level]);
852
852
set_sbi_flag(sbi, SBI_NEED_FSCK);
853
853
goto release_pages;
···
1013
1013
return PTR_ERR(folio);
1014
1014
1015
1015
if (IS_INODE(folio) || ino_of_node(folio) != dn->inode->i_ino) {
1016
-
f2fs_err(sbi, "incorrect node reference, ino: %lu, nid: %u, ino_of_node: %u",
1016
+
f2fs_err(sbi, "incorrect node reference, ino: %llu, nid: %u, ino_of_node: %u",
1017
1017
dn->inode->i_ino, dn->nid, ino_of_node(folio));
1018
1018
set_sbi_flag(sbi, SBI_NEED_FSCK);
1019
1019
f2fs_handle_error(sbi, ERROR_INVALID_NODE_REFERENCE);
···
1194
1194
if (level <= 0) {
1195
1195
if (!level) {
1196
1196
level = -EFSCORRUPTED;
1197
-
f2fs_err(sbi, "%s: inode ino=%lx has corrupted node block, from:%lu addrs:%u",
1197
+
f2fs_err(sbi, "%s: inode ino=%llx has corrupted node block, from:%lu addrs:%u",
1198
1198
__func__, inode->i_ino,
1199
1199
from, ADDRS_PER_INODE(inode));
1200
1200
set_sbi_flag(sbi, SBI_NEED_FSCK);
···
1265
1265
set_sbi_flag(F2FS_F_SB(folio), SBI_NEED_FSCK);
1266
1266
f2fs_handle_error(sbi, ERROR_INVALID_BLKADDR);
1267
1267
f2fs_err_ratelimited(sbi,
1268
-
"truncate node fail, ino:%lu, nid:%u, "
1268
+
"truncate node fail, ino:%llu, nid:%u, "
1269
1269
"offset[0]:%d, offset[1]:%d, nofs:%d",
1270
1270
inode->i_ino, dn.nid, offset[0],
1271
1271
offset[1], nofs);
···
1351
1351
1352
1352
if (unlikely(inode->i_blocks != 0 && inode->i_blocks != 8)) {
1353
1353
f2fs_warn(F2FS_I_SB(inode),
1354
-
"f2fs_remove_inode_page: inconsistent i_blocks, ino:%lu, iblocks:%llu",
1354
+
"f2fs_remove_inode_page: inconsistent i_blocks, ino:%llu, iblocks:%llu",
1355
1355
inode->i_ino, (unsigned long long)inode->i_blocks);
1356
1356
set_sbi_flag(F2FS_I_SB(inode), SBI_NEED_FSCK);
1357
1357
}
···
1997
1997
return ret;
1998
1998
}
1999
1999
2000
-
static int f2fs_match_ino(struct inode *inode, unsigned long ino, void *data)
2000
+
static int f2fs_match_ino(struct inode *inode, u64 ino, void *data)
2001
2001
{
2002
2002
struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
2003
2003
bool clean;
+5
-5
fs/f2fs/recovery.c
+5
-5
fs/f2fs/recovery.c
···
232
232
name = "<encrypted>";
233
233
else
234
234
name = raw_inode->i_name;
235
-
f2fs_notice(F2FS_I_SB(inode), "%s: ino = %x, name = %s, dir = %lx, err = %d",
235
+
f2fs_notice(F2FS_I_SB(inode), "%s: ino = %x, name = %s, dir = %llu, err = %d",
236
236
__func__, ino_of_node(ifolio), name,
237
237
IS_ERR(dir) ? 0 : dir->i_ino, err);
238
238
return err;
···
532
532
533
533
max_addrs = ADDRS_PER_PAGE(dn->node_folio, dn->inode);
534
534
if (ofs_in_node >= max_addrs) {
535
-
f2fs_err(sbi, "Inconsistent ofs_in_node:%u in summary, ino:%lu, nid:%u, max:%u",
535
+
f2fs_err(sbi, "Inconsistent ofs_in_node:%u in summary, ino:%llu, nid:%u, max:%u",
536
536
ofs_in_node, dn->inode->i_ino, nid, max_addrs);
537
537
f2fs_handle_error(sbi, ERROR_INCONSISTENT_SUMMARY);
538
538
return -EFSCORRUPTED;
···
674
674
f2fs_bug_on(sbi, ni.ino != ino_of_node(folio));
675
675
676
676
if (ofs_of_node(dn.node_folio) != ofs_of_node(folio)) {
677
-
f2fs_warn(sbi, "Inconsistent ofs_of_node, ino:%lu, ofs:%u, %u",
677
+
f2fs_warn(sbi, "Inconsistent ofs_of_node, ino:%llu, ofs:%u, %u",
678
678
inode->i_ino, ofs_of_node(dn.node_folio),
679
679
ofs_of_node(folio));
680
680
err = -EFSCORRUPTED;
···
748
748
749
749
if (f2fs_is_valid_blkaddr(sbi, dest,
750
750
DATA_GENERIC_ENHANCE_UPDATE)) {
751
-
f2fs_err(sbi, "Inconsistent dest blkaddr:%u, ino:%lu, ofs:%u",
751
+
f2fs_err(sbi, "Inconsistent dest blkaddr:%u, ino:%llu, ofs:%u",
752
752
dest, inode->i_ino, dn.ofs_in_node);
753
753
err = -EFSCORRUPTED;
754
754
goto err;
···
768
768
err:
769
769
f2fs_put_dnode(&dn);
770
770
out:
771
-
f2fs_notice(sbi, "recover_data: ino = %lx, nid = %x (i_size: %s), "
771
+
f2fs_notice(sbi, "recover_data: ino = %llx, nid = %x (i_size: %s), "
772
772
"range (%u, %u), recovered = %d, err = %d",
773
773
inode->i_ino, nid_of_node(folio),
774
774
file_keep_isize(inode) ? "keep" : "recover",
+5
-5
fs/f2fs/xattr.c
+5
-5
fs/f2fs/xattr.c
···
365
365
366
366
*xe = __find_xattr(cur_addr, last_txattr_addr, NULL, index, len, name);
367
367
if (!*xe) {
368
-
f2fs_err(F2FS_I_SB(inode), "lookup inode (%lu) has corrupted xattr",
368
+
f2fs_err(F2FS_I_SB(inode), "lookup inode (%llu) has corrupted xattr",
369
369
inode->i_ino);
370
370
set_sbi_flag(F2FS_I_SB(inode), SBI_NEED_FSCK);
371
371
err = -ENODATA;
···
585
585
586
586
if ((void *)(entry) + sizeof(__u32) > last_base_addr ||
587
587
(void *)XATTR_NEXT_ENTRY(entry) > last_base_addr) {
588
-
f2fs_err(F2FS_I_SB(inode), "list inode (%lu) has corrupted xattr",
588
+
f2fs_err(F2FS_I_SB(inode), "list inode (%llu) has corrupted xattr",
589
589
inode->i_ino);
590
590
set_sbi_flag(F2FS_I_SB(inode), SBI_NEED_FSCK);
591
591
f2fs_handle_error(F2FS_I_SB(inode),
···
664
664
if (!F2FS_I(inode)->i_xattr_nid) {
665
665
error = f2fs_recover_xattr_data(inode, NULL);
666
666
f2fs_notice(F2FS_I_SB(inode),
667
-
"recover xattr in inode (%lu), error(%d)",
667
+
"recover xattr in inode (%llu), error(%d)",
668
668
inode->i_ino, error);
669
669
if (!error) {
670
670
kfree(base_addr);
671
671
goto retry;
672
672
}
673
673
}
674
-
f2fs_err(F2FS_I_SB(inode), "set inode (%lu) has corrupted xattr",
674
+
f2fs_err(F2FS_I_SB(inode), "set inode (%llu) has corrupted xattr",
675
675
inode->i_ino);
676
676
set_sbi_flag(F2FS_I_SB(inode), SBI_NEED_FSCK);
677
677
error = -EFSCORRUPTED;
···
699
699
while (!IS_XATTR_LAST_ENTRY(last)) {
700
700
if ((void *)(last) + sizeof(__u32) > last_base_addr ||
701
701
(void *)XATTR_NEXT_ENTRY(last) > last_base_addr) {
702
-
f2fs_err(F2FS_I_SB(inode), "inode (%lu) has invalid last xattr entry, entry_size: %zu",
702
+
f2fs_err(F2FS_I_SB(inode), "inode (%llu) has invalid last xattr entry, entry_size: %zu",
703
703
inode->i_ino, ENTRY_SIZE(last));
704
704
set_sbi_flag(F2FS_I_SB(inode), SBI_NEED_FSCK);
705
705
error = -EFSCORRUPTED;
+2
-2
fs/freevxfs/vxfs_bmap.c
+2
-2
fs/freevxfs/vxfs_bmap.c
···
260
260
if (VXFS_ISIMMED(vip))
261
261
goto unsupp;
262
262
263
-
printk(KERN_WARNING "vxfs: inode %ld has no valid orgtype (%x)\n",
263
+
printk(KERN_WARNING "vxfs: inode %llu has no valid orgtype (%x)\n",
264
264
ip->i_ino, vip->vii_orgtype);
265
265
BUG();
266
266
267
267
unsupp:
268
-
printk(KERN_WARNING "vxfs: inode %ld has an unsupported orgtype (%x)\n",
268
+
printk(KERN_WARNING "vxfs: inode %llu has an unsupported orgtype (%x)\n",
269
269
ip->i_ino, vip->vii_orgtype);
270
270
return 0;
271
271
}
+1
-1
fs/fserror.c
+1
-1
fs/fserror.c
···
176
176
lost:
177
177
if (inode)
178
178
pr_err_ratelimited(
179
-
"%s: lost file I/O error report for ino %lu type %u pos 0x%llx len 0x%llx error %d",
179
+
"%s: lost file I/O error report for ino %llu type %u pos 0x%llx len 0x%llx error %d",
180
180
sb->s_id, inode->i_ino, type, pos, len, error);
181
181
else
182
182
pr_err_ratelimited(
+1
-1
fs/hfs/catalog.c
+1
-1
fs/hfs/catalog.c
···
417
417
int entry_size, type;
418
418
int err;
419
419
420
-
hfs_dbg("cnid %u - (ino %lu, name %s) - (ino %lu, name %s)\n",
420
+
hfs_dbg("cnid %u - (ino %llu, name %s) - (ino %llu, name %s)\n",
421
421
cnid, src_dir->i_ino, src_name->name,
422
422
dst_dir->i_ino, dst_name->name);
423
423
sb = src_dir->i_sb;
+2
-2
fs/hfs/extent.c
+2
-2
fs/hfs/extent.c
···
411
411
goto out;
412
412
}
413
413
414
-
hfs_dbg("ino %lu, start %u, len %u\n", inode->i_ino, start, len);
414
+
hfs_dbg("ino %llu, start %u, len %u\n", inode->i_ino, start, len);
415
415
if (HFS_I(inode)->alloc_blocks == HFS_I(inode)->first_blocks) {
416
416
if (!HFS_I(inode)->first_blocks) {
417
417
hfs_dbg("first_extent: start %u, len %u\n",
···
482
482
u32 size;
483
483
int res;
484
484
485
-
hfs_dbg("ino %lu, phys_size %llu -> i_size %llu\n",
485
+
hfs_dbg("ino %llu, phys_size %llu -> i_size %llu\n",
486
486
inode->i_ino, (long long)HFS_I(inode)->phys_size,
487
487
inode->i_size);
488
488
if (inode->i_size > HFS_I(inode)->phys_size) {
+2
-2
fs/hfs/inode.c
+2
-2
fs/hfs/inode.c
···
270
270
{
271
271
struct super_block *sb = inode->i_sb;
272
272
273
-
hfs_dbg("ino %lu\n", inode->i_ino);
273
+
hfs_dbg("ino %llu\n", inode->i_ino);
274
274
if (S_ISDIR(inode->i_mode)) {
275
275
atomic64_dec(&HFS_SB(sb)->folder_count);
276
276
if (HFS_I(inode)->cat_key.ParID == cpu_to_be32(HFS_ROOT_CNID))
···
455
455
hfs_cat_rec rec;
456
456
int res;
457
457
458
-
hfs_dbg("ino %lu\n", inode->i_ino);
458
+
hfs_dbg("ino %llu\n", inode->i_ino);
459
459
res = hfs_ext_write_extent(inode);
460
460
if (res)
461
461
return res;
+5
-5
fs/hfsplus/attributes.c
+5
-5
fs/hfsplus/attributes.c
···
203
203
int entry_size;
204
204
int err;
205
205
206
-
hfs_dbg("name %s, ino %ld\n",
206
+
hfs_dbg("name %s, ino %llu\n",
207
207
name ? name : NULL, inode->i_ino);
208
208
209
209
if (name) {
···
255
255
hfsplus_attr_entry *entry_ptr;
256
256
int err;
257
257
258
-
hfs_dbg("name %s, ino %ld\n",
258
+
hfs_dbg("name %s, ino %llu\n",
259
259
name ? name : NULL, inode->i_ino);
260
260
261
261
if (!HFSPLUS_SB(sb)->attr_tree) {
···
337
337
struct super_block *sb = inode->i_sb;
338
338
int err;
339
339
340
-
hfs_dbg("name %s, ino %ld\n",
340
+
hfs_dbg("name %s, ino %llu\n",
341
341
name ? name : NULL, inode->i_ino);
342
342
343
343
if (name) {
···
367
367
struct super_block *sb = inode->i_sb;
368
368
struct hfs_find_data fd;
369
369
370
-
hfs_dbg("name %s, ino %ld\n",
370
+
hfs_dbg("name %s, ino %llu\n",
371
371
name ? name : NULL, inode->i_ino);
372
372
373
373
if (!HFSPLUS_SB(sb)->attr_tree) {
···
436
436
hfsplus_attr_entry *entry_ptr;
437
437
int err = 0;
438
438
439
-
hfs_dbg("name %s, ino %ld\n",
439
+
hfs_dbg("name %s, ino %llu\n",
440
440
name ? name : NULL, inode->i_ino);
441
441
442
442
if (!HFSPLUS_SB(sb)->attr_tree) {
+1
-1
fs/hfsplus/catalog.c
+1
-1
fs/hfsplus/catalog.c
···
441
441
int entry_size, type;
442
442
int err;
443
443
444
-
hfs_dbg("cnid %u - ino %lu, name %s - ino %lu, name %s\n",
444
+
hfs_dbg("cnid %u - ino %llu, name %s - ino %llu, name %s\n",
445
445
cnid, src_dir->i_ino, src_name->name,
446
446
dst_dir->i_ino, dst_name->name);
447
447
err = hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &src_fd);
+3
-3
fs/hfsplus/dir.c
+3
-3
fs/hfsplus/dir.c
···
313
313
if (!S_ISREG(inode->i_mode))
314
314
return -EPERM;
315
315
316
-
hfs_dbg("src_dir->i_ino %lu, dst_dir->i_ino %lu, inode->i_ino %lu\n",
316
+
hfs_dbg("src_dir->i_ino %llu, dst_dir->i_ino %llu, inode->i_ino %llu\n",
317
317
src_dir->i_ino, dst_dir->i_ino, inode->i_ino);
318
318
319
319
mutex_lock(&sbi->vh_mutex);
···
385
385
if (HFSPLUS_IS_RSRC(inode))
386
386
return -EPERM;
387
387
388
-
hfs_dbg("dir->i_ino %lu, inode->i_ino %lu\n",
388
+
hfs_dbg("dir->i_ino %llu, inode->i_ino %llu\n",
389
389
dir->i_ino, inode->i_ino);
390
390
391
391
mutex_lock(&sbi->vh_mutex);
···
393
393
if (inode->i_ino == cnid &&
394
394
atomic_read(&HFSPLUS_I(inode)->opencnt)) {
395
395
str.name = name;
396
-
str.len = sprintf(name, "temp%lu", inode->i_ino);
396
+
str.len = sprintf(name, "temp%llu", inode->i_ino);
397
397
res = hfsplus_rename_cat(inode->i_ino,
398
398
dir, &dentry->d_name,
399
399
sbi->hidden_dir, &str);
+3
-3
fs/hfsplus/extents.c
+3
-3
fs/hfsplus/extents.c
···
275
275
mutex_unlock(&hip->extents_lock);
276
276
277
277
done:
278
-
hfs_dbg("ino %lu, iblock %llu - dblock %u\n",
278
+
hfs_dbg("ino %llu, iblock %llu - dblock %u\n",
279
279
inode->i_ino, (long long)iblock, dblock);
280
280
281
281
mask = (1 << sbi->fs_shift) - 1;
···
476
476
goto out;
477
477
}
478
478
479
-
hfs_dbg("ino %lu, start %u, len %u\n", inode->i_ino, start, len);
479
+
hfs_dbg("ino %llu, start %u, len %u\n", inode->i_ino, start, len);
480
480
481
481
if (hip->alloc_blocks <= hip->first_blocks) {
482
482
if (!hip->first_blocks) {
···
545
545
u32 alloc_cnt, blk_cnt, start;
546
546
int res;
547
547
548
-
hfs_dbg("ino %lu, phys_size %llu -> i_size %llu\n",
548
+
hfs_dbg("ino %llu, phys_size %llu -> i_size %llu\n",
549
549
inode->i_ino, (long long)hip->phys_size, inode->i_size);
550
550
551
551
if (inode->i_size > hip->phys_size) {
+4
-4
fs/hfsplus/inode.c
+4
-4
fs/hfsplus/inode.c
···
230
230
inode->i_flags &= ~S_APPEND;
231
231
return 0;
232
232
bad_type:
233
-
pr_err("invalid file type 0%04o for inode %lu\n", mode, inode->i_ino);
233
+
pr_err("invalid file type 0%04o for inode %llu\n", mode, inode->i_ino);
234
234
return -EIO;
235
235
}
236
236
···
328
328
struct hfsplus_vh *vhdr = sbi->s_vhdr;
329
329
int error = 0, error2;
330
330
331
-
hfs_dbg("inode->i_ino %lu, start %llu, end %llu\n",
331
+
hfs_dbg("inode->i_ino %llu, start %llu, end %llu\n",
332
332
inode->i_ino, start, end);
333
333
334
334
error = file_write_and_wait_range(file, start, end);
···
639
639
hfsplus_cat_entry entry;
640
640
int res = 0;
641
641
642
-
hfs_dbg("inode->i_ino %lu\n", inode->i_ino);
642
+
hfs_dbg("inode->i_ino %llu\n", inode->i_ino);
643
643
644
644
if (HFSPLUS_IS_RSRC(inode))
645
645
main_inode = HFSPLUS_I(inode)->rsrc_inode;
···
716
716
if (!res) {
717
717
res = hfs_btree_write(tree);
718
718
if (res) {
719
-
pr_err("b-tree write err: %d, ino %lu\n",
719
+
pr_err("b-tree write err: %d, ino %llu\n",
720
720
res, inode->i_ino);
721
721
}
722
722
}
+3
-3
fs/hfsplus/super.c
+3
-3
fs/hfsplus/super.c
···
156
156
int err = hfs_btree_write(tree);
157
157
158
158
if (err) {
159
-
pr_err("b-tree write err: %d, ino %lu\n",
159
+
pr_err("b-tree write err: %d, ino %llu\n",
160
160
err, inode->i_ino);
161
161
return err;
162
162
}
···
169
169
{
170
170
int err;
171
171
172
-
hfs_dbg("ino %lu\n", inode->i_ino);
172
+
hfs_dbg("ino %llu\n", inode->i_ino);
173
173
174
174
err = hfsplus_ext_write_extent(inode);
175
175
if (err)
···
184
184
185
185
static void hfsplus_evict_inode(struct inode *inode)
186
186
{
187
-
hfs_dbg("ino %lu\n", inode->i_ino);
187
+
hfs_dbg("ino %llu\n", inode->i_ino);
188
188
truncate_inode_pages_final(&inode->i_data);
189
189
clear_inode(inode);
190
190
if (HFSPLUS_IS_RSRC(inode)) {
+5
-5
fs/hfsplus/xattr.c
+5
-5
fs/hfsplus/xattr.c
···
277
277
u16 folder_finderinfo_len = sizeof(DInfo) + sizeof(DXInfo);
278
278
u16 file_finderinfo_len = sizeof(FInfo) + sizeof(FXInfo);
279
279
280
-
hfs_dbg("ino %lu, name %s, value %p, size %zu\n",
280
+
hfs_dbg("ino %llu, name %s, value %p, size %zu\n",
281
281
inode->i_ino, name ? name : NULL,
282
282
value, size);
283
283
···
447
447
NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN + 1;
448
448
int res;
449
449
450
-
hfs_dbg("ino %lu, name %s, prefix %s, prefixlen %zu, "
450
+
hfs_dbg("ino %llu, name %s, prefix %s, prefixlen %zu, "
451
451
"value %p, size %zu\n",
452
452
inode->i_ino, name ? name : NULL,
453
453
prefix ? prefix : NULL, prefixlen,
···
607
607
int res;
608
608
char *xattr_name;
609
609
610
-
hfs_dbg("ino %lu, name %s, prefix %s\n",
610
+
hfs_dbg("ino %llu, name %s, prefix %s\n",
611
611
inode->i_ino, name ? name : NULL,
612
612
prefix ? prefix : NULL);
613
613
···
717
717
size_t strbuf_size;
718
718
int xattr_name_len;
719
719
720
-
hfs_dbg("ino %lu\n", inode->i_ino);
720
+
hfs_dbg("ino %llu\n", inode->i_ino);
721
721
722
722
if (!is_xattr_operation_supported(inode))
723
723
return -EOPNOTSUPP;
···
819
819
int is_xattr_acl_deleted;
820
820
int is_all_xattrs_deleted;
821
821
822
-
hfs_dbg("ino %lu, name %s\n",
822
+
hfs_dbg("ino %llu, name %s\n",
823
823
inode->i_ino, name ? name : NULL);
824
824
825
825
if (!HFSPLUS_SB(inode->i_sb)->attr_tree)
+2
-2
fs/hpfs/dir.c
+2
-2
fs/hpfs/dir.c
···
96
96
}
97
97
if (!fnode_is_dir(fno)) {
98
98
e = 1;
99
-
hpfs_error(inode->i_sb, "not a directory, fnode %08lx",
100
-
(unsigned long)inode->i_ino);
99
+
hpfs_error(inode->i_sb, "not a directory, fnode %08llx",
100
+
inode->i_ino);
101
101
}
102
102
if (hpfs_inode->i_dno != le32_to_cpu(fno->u.external[0].disk_secno)) {
103
103
e = 1;
+2
-2
fs/hpfs/dnode.c
+2
-2
fs/hpfs/dnode.c
···
550
550
if (hpfs_sb(i->i_sb)->sb_chk)
551
551
if (up != i->i_ino) {
552
552
hpfs_error(i->i_sb,
553
-
"bad pointer to fnode, dnode %08x, pointing to %08x, should be %08lx",
553
+
"bad pointer to fnode, dnode %08x, pointing to %08x, should be %08llx",
554
554
dno, up,
555
-
(unsigned long)i->i_ino);
555
+
i->i_ino);
556
556
return;
557
557
}
558
558
if ((d1 = hpfs_map_dnode(i->i_sb, down, &qbh1))) {
+2
-2
fs/hpfs/ea.c
+2
-2
fs/hpfs/ea.c
···
245
245
fnode->ea_offs = cpu_to_le16(0xc4);
246
246
}
247
247
if (le16_to_cpu(fnode->ea_offs) < 0xc4 || le16_to_cpu(fnode->ea_offs) + le16_to_cpu(fnode->acl_size_s) + le16_to_cpu(fnode->ea_size_s) > 0x200) {
248
-
hpfs_error(s, "fnode %08lx: ea_offs == %03x, ea_size_s == %03x",
249
-
(unsigned long)inode->i_ino,
248
+
hpfs_error(s, "fnode %08llx: ea_offs == %03x, ea_size_s == %03x",
249
+
inode->i_ino,
250
250
le16_to_cpu(fnode->ea_offs), le16_to_cpu(fnode->ea_size_s));
251
251
return;
252
252
}
+2
-2
fs/hpfs/inode.c
+2
-2
fs/hpfs/inode.c
+24
-25
fs/inode.c
+24
-25
fs/inode.c
···
672
672
}
673
673
}
674
674
675
-
static unsigned long hash(struct super_block *sb, unsigned long hashval)
675
+
static unsigned long hash(struct super_block *sb, u64 hashval)
676
676
{
677
677
unsigned long tmp;
678
678
···
685
685
/**
686
686
* __insert_inode_hash - hash an inode
687
687
* @inode: unhashed inode
688
-
* @hashval: unsigned long value used to locate this object in the
688
+
* @hashval: u64 value used to locate this object in the
689
689
* inode_hashtable.
690
690
*
691
691
* Add an inode to the inode hash for this superblock.
692
692
*/
693
-
void __insert_inode_hash(struct inode *inode, unsigned long hashval)
693
+
void __insert_inode_hash(struct inode *inode, u64 hashval)
694
694
{
695
695
struct hlist_head *b = inode_hashtable + hash(inode->i_sb, hashval);
696
696
···
726
726
struct dentry *dentry_ptr;
727
727
struct dentry dentry;
728
728
char fname[64] = {};
729
-
unsigned long ino;
729
+
u64 ino;
730
730
731
731
/*
732
732
* If mapping is an invalid pointer, we don't want to crash
···
750
750
}
751
751
752
752
if (!dentry_first) {
753
-
pr_warn("aops:%ps ino:%lx\n", a_ops, ino);
753
+
pr_warn("aops:%ps ino:%llx\n", a_ops, ino);
754
754
return;
755
755
}
756
756
757
757
dentry_ptr = container_of(dentry_first, struct dentry, d_u.d_alias);
758
758
if (get_kernel_nofault(dentry, dentry_ptr) ||
759
759
!dentry.d_parent || !dentry.d_name.name) {
760
-
pr_warn("aops:%ps ino:%lx invalid dentry:%px\n",
760
+
pr_warn("aops:%ps ino:%llx invalid dentry:%px\n",
761
761
a_ops, ino, dentry_ptr);
762
762
return;
763
763
}
···
768
768
* Even if strncpy_from_kernel_nofault() succeeded,
769
769
* the fname could be unreliable
770
770
*/
771
-
pr_warn("aops:%ps ino:%lx dentry name(?):\"%s\"\n",
771
+
pr_warn("aops:%ps ino:%llx dentry name(?):\"%s\"\n",
772
772
a_ops, ino, fname);
773
773
}
774
774
···
1087
1087
* iget_locked for details.
1088
1088
*/
1089
1089
static struct inode *find_inode_fast(struct super_block *sb,
1090
-
struct hlist_head *head, unsigned long ino,
1090
+
struct hlist_head *head, u64 ino,
1091
1091
bool hash_locked, bool *isnew)
1092
1092
{
1093
1093
struct inode *inode = NULL;
···
1301
1301
* Note that both @test and @set are called with the inode_hash_lock held, so
1302
1302
* they can't sleep.
1303
1303
*/
1304
-
struct inode *inode_insert5(struct inode *inode, unsigned long hashval,
1304
+
struct inode *inode_insert5(struct inode *inode, u64 hashval,
1305
1305
int (*test)(struct inode *, void *),
1306
1306
int (*set)(struct inode *, void *), void *data)
1307
1307
{
···
1378
1378
* Note that both @test and @set are called with the inode_hash_lock held, so
1379
1379
* they can't sleep.
1380
1380
*/
1381
-
struct inode *iget5_locked(struct super_block *sb, unsigned long hashval,
1381
+
struct inode *iget5_locked(struct super_block *sb, u64 hashval,
1382
1382
int (*test)(struct inode *, void *),
1383
1383
int (*set)(struct inode *, void *), void *data)
1384
1384
{
···
1408
1408
* This is equivalent to iget5_locked, except the @test callback must
1409
1409
* tolerate the inode not being stable, including being mid-teardown.
1410
1410
*/
1411
-
struct inode *iget5_locked_rcu(struct super_block *sb, unsigned long hashval,
1411
+
struct inode *iget5_locked_rcu(struct super_block *sb, u64 hashval,
1412
1412
int (*test)(struct inode *, void *),
1413
1413
int (*set)(struct inode *, void *), void *data)
1414
1414
{
···
1455
1455
* hashed, and with the I_NEW flag set. The file system gets to fill it in
1456
1456
* before unlocking it via unlock_new_inode().
1457
1457
*/
1458
-
struct inode *iget_locked(struct super_block *sb, unsigned long ino)
1458
+
struct inode *iget_locked(struct super_block *sb, u64 ino)
1459
1459
{
1460
1460
struct hlist_head *head = inode_hashtable + hash(sb, ino);
1461
1461
struct inode *inode;
···
1527
1527
*
1528
1528
* Returns 1 if the inode number is unique, 0 if it is not.
1529
1529
*/
1530
-
static int test_inode_iunique(struct super_block *sb, unsigned long ino)
1530
+
static int test_inode_iunique(struct super_block *sb, u64 ino)
1531
1531
{
1532
1532
struct hlist_head *b = inode_hashtable + hash(sb, ino);
1533
1533
struct inode *inode;
···
1616
1616
*
1617
1617
* Note2: @test is called with the inode_hash_lock held, so can't sleep.
1618
1618
*/
1619
-
struct inode *ilookup5_nowait(struct super_block *sb, unsigned long hashval,
1619
+
struct inode *ilookup5_nowait(struct super_block *sb, u64 hashval,
1620
1620
int (*test)(struct inode *, void *), void *data, bool *isnew)
1621
1621
{
1622
1622
struct hlist_head *head = inode_hashtable + hash(sb, hashval);
···
1647
1647
*
1648
1648
* Note: @test is called with the inode_hash_lock held, so can't sleep.
1649
1649
*/
1650
-
struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
1650
+
struct inode *ilookup5(struct super_block *sb, u64 hashval,
1651
1651
int (*test)(struct inode *, void *), void *data)
1652
1652
{
1653
1653
struct inode *inode;
···
1677
1677
* Search for the inode @ino in the inode cache, and if the inode is in the
1678
1678
* cache, the inode is returned with an incremented reference count.
1679
1679
*/
1680
-
struct inode *ilookup(struct super_block *sb, unsigned long ino)
1680
+
struct inode *ilookup(struct super_block *sb, u64 ino)
1681
1681
{
1682
1682
struct hlist_head *head = inode_hashtable + hash(sb, ino);
1683
1683
struct inode *inode;
···
1726
1726
* very carefully implemented.
1727
1727
*/
1728
1728
struct inode *find_inode_nowait(struct super_block *sb,
1729
-
unsigned long hashval,
1730
-
int (*match)(struct inode *, unsigned long,
1729
+
u64 hashval,
1730
+
int (*match)(struct inode *, u64,
1731
1731
void *),
1732
1732
void *data)
1733
1733
{
···
1773
1773
*
1774
1774
* The caller must hold the RCU read lock.
1775
1775
*/
1776
-
struct inode *find_inode_rcu(struct super_block *sb, unsigned long hashval,
1776
+
struct inode *find_inode_rcu(struct super_block *sb, u64 hashval,
1777
1777
int (*test)(struct inode *, void *), void *data)
1778
1778
{
1779
1779
struct hlist_head *head = inode_hashtable + hash(sb, hashval);
···
1812
1812
* The caller must hold the RCU read lock.
1813
1813
*/
1814
1814
struct inode *find_inode_by_ino_rcu(struct super_block *sb,
1815
-
unsigned long ino)
1815
+
u64 ino)
1816
1816
{
1817
1817
struct hlist_head *head = inode_hashtable + hash(sb, ino);
1818
1818
struct inode *inode;
···
1833
1833
int insert_inode_locked(struct inode *inode)
1834
1834
{
1835
1835
struct super_block *sb = inode->i_sb;
1836
-
ino_t ino = inode->i_ino;
1836
+
u64 ino = inode->i_ino;
1837
1837
struct hlist_head *head = inode_hashtable + hash(sb, ino);
1838
1838
bool isnew;
1839
1839
···
1884
1884
}
1885
1885
EXPORT_SYMBOL(insert_inode_locked);
1886
1886
1887
-
int insert_inode_locked4(struct inode *inode, unsigned long hashval,
1887
+
int insert_inode_locked4(struct inode *inode, u64 hashval,
1888
1888
int (*test)(struct inode *, void *), void *data)
1889
1889
{
1890
1890
struct inode *old;
···
2641
2641
/* leave it no_open_fops */
2642
2642
break;
2643
2643
default:
2644
-
printk(KERN_DEBUG "init_special_inode: bogus i_mode (%o) for"
2645
-
" inode %s:%lu\n", mode, inode->i_sb->s_id,
2646
-
inode->i_ino);
2644
+
pr_debug("init_special_inode: bogus i_mode (%o) for inode %s:%llu\n",
2645
+
mode, inode->i_sb->s_id, inode->i_ino);
2647
2646
break;
2648
2647
}
2649
2648
}
+1
-1
fs/iomap/ioend.c
+1
-1
fs/iomap/ioend.c
···
49
49
mapping_set_error(inode->i_mapping, ioend->io_error);
50
50
if (!bio_flagged(bio, BIO_QUIET)) {
51
51
pr_err_ratelimited(
52
-
"%s: writeback error on inode %lu, offset %lld, sector %llu",
52
+
"%s: writeback error on inode %llu, offset %lld, sector %llu",
53
53
inode->i_sb->s_id, inode->i_ino,
54
54
ioend->io_offset, ioend->io_sector);
55
55
}
+4
-4
fs/iomap/trace.h
+4
-4
fs/iomap/trace.h
···
257
257
TP_ARGS(iocb, iter, dio_flags, done_before),
258
258
TP_STRUCT__entry(
259
259
__field(dev_t, dev)
260
-
__field(ino_t, ino)
260
+
__field(u64, ino)
261
261
__field(loff_t, isize)
262
262
__field(loff_t, pos)
263
263
__field(size_t, count)
···
277
277
__entry->dio_flags = dio_flags;
278
278
__entry->aio = !is_sync_kiocb(iocb);
279
279
),
280
-
TP_printk("dev %d:%d ino 0x%lx size 0x%llx offset 0x%llx length 0x%zx done_before 0x%zx flags %s dio_flags %s aio %d",
280
+
TP_printk("dev %d:%d ino 0x%llx size 0x%llx offset 0x%llx length 0x%zx done_before 0x%zx flags %s dio_flags %s aio %d",
281
281
MAJOR(__entry->dev), MINOR(__entry->dev),
282
282
__entry->ino,
283
283
__entry->isize,
···
294
294
TP_ARGS(iocb, error, ret),
295
295
TP_STRUCT__entry(
296
296
__field(dev_t, dev)
297
-
__field(ino_t, ino)
297
+
__field(u64, ino)
298
298
__field(loff_t, isize)
299
299
__field(loff_t, pos)
300
300
__field(int, ki_flags)
···
312
312
__entry->error = error;
313
313
__entry->ret = ret;
314
314
),
315
-
TP_printk("dev %d:%d ino 0x%lx size 0x%llx offset 0x%llx flags %s aio %d error %d ret %zd",
315
+
TP_printk("dev %d:%d ino 0x%llx size 0x%llx offset 0x%llx flags %s aio %d error %d ret %zd",
316
316
MAJOR(__entry->dev), MINOR(__entry->dev),
317
317
__entry->ino,
318
318
__entry->isize,
+1
-1
fs/isofs/compress.c
+1
-1
fs/isofs/compress.c
+1
-1
fs/isofs/dir.c
+1
-1
fs/isofs/dir.c
···
152
152
de_len < de->name_len[0] +
153
153
sizeof(struct iso_directory_record)) {
154
154
printk(KERN_NOTICE "iso9660: Corrupted directory entry"
155
-
" in block %lu of inode %lu\n", block,
155
+
" in block %lu of inode %llu\n", block,
156
156
inode->i_ino);
157
157
brelse(bh);
158
158
return -EIO;
+4
-4
fs/isofs/inode.c
+4
-4
fs/isofs/inode.c
···
1261
1261
1262
1262
out_toomany:
1263
1263
printk(KERN_INFO "%s: More than 100 file sections ?!?, aborting...\n"
1264
-
"isofs_read_level3_size: inode=%lu\n",
1264
+
"isofs_read_level3_size: inode=%llu\n",
1265
1265
__func__, inode->i_ino);
1266
1266
goto out;
1267
1267
}
···
1380
1380
/* I have no idea what file_unit_size is used for, so
1381
1381
we will flag it for now */
1382
1382
if (de->file_unit_size[0] != 0) {
1383
-
printk(KERN_DEBUG "ISOFS: File unit size != 0 for ISO file (%ld).\n",
1383
+
printk(KERN_DEBUG "ISOFS: File unit size != 0 for ISO file (%llu).\n",
1384
1384
inode->i_ino);
1385
1385
}
1386
1386
···
1389
1389
#ifdef DEBUG
1390
1390
if((de->flags[-high_sierra] & ~2)!= 0){
1391
1391
printk(KERN_DEBUG "ISOFS: Unusual flag settings for ISO file "
1392
-
"(%ld %x).\n",
1392
+
"(%llu %x).\n",
1393
1393
inode->i_ino, de->flags[-high_sierra]);
1394
1394
}
1395
1395
#endif
···
1450
1450
/* XXX - parse_rock_ridge_inode() had already set i_rdev. */
1451
1451
init_special_inode(inode, inode->i_mode, inode->i_rdev);
1452
1452
} else {
1453
-
printk(KERN_DEBUG "ISOFS: Invalid file type 0%04o for inode %lu.\n",
1453
+
printk(KERN_DEBUG "ISOFS: Invalid file type 0%04o for inode %llu.\n",
1454
1454
inode->i_mode, inode->i_ino);
1455
1455
ret = -EIO;
1456
1456
goto fail;
+1
-1
fs/isofs/namei.c
+1
-1
fs/isofs/namei.c
···
100
100
/* Basic sanity check, whether name doesn't exceed dir entry */
101
101
if (de_len < dlen + sizeof(struct iso_directory_record)) {
102
102
printk(KERN_NOTICE "iso9660: Corrupted directory entry"
103
-
" in block %lu of inode %lu\n", block,
103
+
" in block %lu of inode %llu\n", block,
104
104
dir->i_ino);
105
105
brelse(bh);
106
106
return 0;
+2
-2
fs/jbd2/journal.c
+2
-2
fs/jbd2/journal.c
···
1677
1677
return err ? ERR_PTR(err) : ERR_PTR(-EINVAL);
1678
1678
}
1679
1679
1680
-
jbd2_debug(1, "JBD2: inode %s/%ld, size %lld, bits %d, blksize %ld\n",
1680
+
jbd2_debug(1, "JBD2: inode %s/%llu, size %lld, bits %d, blksize %ld\n",
1681
1681
inode->i_sb->s_id, inode->i_ino, (long long) inode->i_size,
1682
1682
inode->i_sb->s_blocksize_bits, inode->i_sb->s_blocksize);
1683
1683
···
1689
1689
1690
1690
journal->j_inode = inode;
1691
1691
snprintf(journal->j_devname, sizeof(journal->j_devname),
1692
-
"%pg-%lu", journal->j_dev, journal->j_inode->i_ino);
1692
+
"%pg-%llu", journal->j_dev, journal->j_inode->i_ino);
1693
1693
strreplace(journal->j_devname, '/', '!');
1694
1694
jbd2_stats_proc_init(journal);
1695
1695
+1
-1
fs/jbd2/transaction.c
+1
-1
fs/jbd2/transaction.c
···
2651
2651
return -EROFS;
2652
2652
journal = transaction->t_journal;
2653
2653
2654
-
jbd2_debug(4, "Adding inode %lu, tid:%d\n", jinode->i_vfs_inode->i_ino,
2654
+
jbd2_debug(4, "Adding inode %llu, tid:%d\n", jinode->i_vfs_inode->i_ino,
2655
2655
transaction->t_tid);
2656
2656
2657
2657
spin_lock(&journal->j_list_lock);
+2
-2
fs/jffs2/dir.c
+2
-2
fs/jffs2/dir.c
···
129
129
struct jffs2_full_dirent *fd;
130
130
unsigned long curofs = 1;
131
131
132
-
jffs2_dbg(1, "jffs2_readdir() for dir_i #%lu\n", inode->i_ino);
132
+
jffs2_dbg(1, "jffs2_readdir() for dir_i #%llu\n", inode->i_ino);
133
133
134
134
if (!dir_emit_dots(file, ctx))
135
135
return 0;
···
211
211
212
212
jffs2_free_raw_inode(ri);
213
213
214
-
jffs2_dbg(1, "%s(): Created ino #%lu with mode %o, nlink %d(%d). nrpages %ld\n",
214
+
jffs2_dbg(1, "%s(): Created ino #%llu with mode %o, nlink %d(%d). nrpages %ld\n",
215
215
__func__, inode->i_ino, inode->i_mode, inode->i_nlink,
216
216
f->inocache->pino_nlink, inode->i_mapping->nrpages);
217
217
+2
-2
fs/jffs2/file.c
+2
-2
fs/jffs2/file.c
···
88
88
unsigned char *kaddr;
89
89
int ret;
90
90
91
-
jffs2_dbg(2, "%s(): ino #%lu, page at offset 0x%lx\n",
91
+
jffs2_dbg(2, "%s(): ino #%llu, page at offset 0x%lx\n",
92
92
__func__, inode->i_ino, folio->index << PAGE_SHIFT);
93
93
94
94
BUG_ON(!folio_test_locked(folio));
···
259
259
uint32_t writtenlen = 0;
260
260
void *buf;
261
261
262
-
jffs2_dbg(1, "%s(): ino #%lu, page at 0x%llx, range %d-%d, flags %lx\n",
262
+
jffs2_dbg(1, "%s(): ino #%llu, page at 0x%llx, range %d-%d, flags %lx\n",
263
263
__func__, inode->i_ino, folio_pos(folio),
264
264
start, end, folio->flags.f);
265
265
+9
-9
fs/jffs2/fs.c
+9
-9
fs/jffs2/fs.c
···
43
43
int ret;
44
44
int alloc_type = ALLOC_NORMAL;
45
45
46
-
jffs2_dbg(1, "%s(): ino #%lu\n", __func__, inode->i_ino);
46
+
jffs2_dbg(1, "%s(): ino #%llu\n", __func__, inode->i_ino);
47
47
48
48
/* Special cases - we don't want more than one data node
49
49
for these types on the medium at any time. So setattr
···
243
243
struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
244
244
struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
245
245
246
-
jffs2_dbg(1, "%s(): ino #%lu mode %o\n",
246
+
jffs2_dbg(1, "%s(): ino #%llu mode %o\n",
247
247
__func__, inode->i_ino, inode->i_mode);
248
248
truncate_inode_pages_final(&inode->i_data);
249
249
clear_inode(inode);
···
334
334
ret = jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size);
335
335
if (ret < 0) {
336
336
/* Eep */
337
-
pr_notice("Read device numbers for inode %lu failed\n",
338
-
(unsigned long)inode->i_ino);
337
+
pr_notice("Read device numbers for inode %llu failed\n",
338
+
inode->i_ino);
339
339
goto error;
340
340
}
341
341
if (f->metadata->size == sizeof(jdev.old_id))
···
351
351
break;
352
352
353
353
default:
354
-
pr_warn("%s(): Bogus i_mode %o for ino %lu\n",
355
-
__func__, inode->i_mode, (unsigned long)inode->i_ino);
354
+
pr_warn("%s(): Bogus i_mode %o for ino %llu\n",
355
+
__func__, inode->i_mode, inode->i_ino);
356
356
}
357
357
358
358
mutex_unlock(&f->sem);
···
374
374
struct iattr iattr;
375
375
376
376
if (!(inode_state_read_once(inode) & I_DIRTY_DATASYNC)) {
377
-
jffs2_dbg(2, "%s(): not calling setattr() for ino #%lu\n",
377
+
jffs2_dbg(2, "%s(): not calling setattr() for ino #%llu\n",
378
378
__func__, inode->i_ino);
379
379
return;
380
380
}
381
381
382
-
jffs2_dbg(1, "%s(): calling setattr() for ino #%lu\n",
382
+
jffs2_dbg(1, "%s(): calling setattr() for ino #%llu\n",
383
383
__func__, inode->i_ino);
384
384
385
385
iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
···
428
428
struct jffs2_inode_info *f;
429
429
int ret;
430
430
431
-
jffs2_dbg(1, "%s(): dir_i %ld, mode 0x%x\n",
431
+
jffs2_dbg(1, "%s(): dir_i %llu, mode 0x%x\n",
432
432
__func__, dir_i->i_ino, mode);
433
433
434
434
c = JFFS2_SB_INFO(sb);
+1
-1
fs/jfs/inode.c
+1
-1
fs/jfs/inode.c
···
64
64
inode->i_op = &jfs_file_inode_operations;
65
65
init_special_inode(inode, inode->i_mode, inode->i_rdev);
66
66
} else {
67
-
printk(KERN_DEBUG "JFS: Invalid file type 0%04o for inode %lu.\n",
67
+
printk(KERN_DEBUG "JFS: Invalid file type 0%04o for inode %llu.\n",
68
68
inode->i_mode, inode->i_ino);
69
69
iget_failed(inode);
70
70
return ERR_PTR(-EIO);
+1
-1
fs/jfs/jfs_imap.c
+1
-1
fs/jfs/jfs_imap.c
+1
-1
fs/jfs/jfs_metapage.c
+1
-1
fs/jfs/jfs_metapage.c
···
692
692
unsigned long page_index;
693
693
unsigned long page_offset;
694
694
695
-
jfs_info("__get_metapage: ino = %ld, lblock = 0x%lx, abs=%d",
695
+
jfs_info("__get_metapage: ino = %llu, lblock = 0x%lx, abs=%d",
696
696
inode->i_ino, lblock, absolute);
697
697
698
698
l2bsize = inode->i_blkbits;
+4
-4
fs/lockd/svclock.c
+4
-4
fs/lockd/svclock.c
···
487
487
int async_block = 0;
488
488
__be32 ret;
489
489
490
-
dprintk("lockd: nlmsvc_lock(%s/%ld, ty=%d, pi=%d, %Ld-%Ld, bl=%d)\n",
490
+
dprintk("lockd: nlmsvc_lock(%s/%llu, ty=%d, pi=%d, %Ld-%Ld, bl=%d)\n",
491
491
inode->i_sb->s_id, inode->i_ino,
492
492
lock->fl.c.flc_type,
493
493
lock->fl.c.flc_pid,
···
617
617
int mode;
618
618
__be32 ret;
619
619
620
-
dprintk("lockd: nlmsvc_testlock(%s/%ld, ty=%d, %Ld-%Ld)\n",
620
+
dprintk("lockd: nlmsvc_testlock(%s/%llu, ty=%d, %Ld-%Ld)\n",
621
621
nlmsvc_file_inode(file)->i_sb->s_id,
622
622
nlmsvc_file_inode(file)->i_ino,
623
623
lock->fl.c.flc_type,
···
676
676
{
677
677
int error = 0;
678
678
679
-
dprintk("lockd: nlmsvc_unlock(%s/%ld, pi=%d, %Ld-%Ld)\n",
679
+
dprintk("lockd: nlmsvc_unlock(%s/%llu, pi=%d, %Ld-%Ld)\n",
680
680
nlmsvc_file_inode(file)->i_sb->s_id,
681
681
nlmsvc_file_inode(file)->i_ino,
682
682
lock->fl.c.flc_pid,
···
716
716
int status = 0;
717
717
int mode;
718
718
719
-
dprintk("lockd: nlmsvc_cancel(%s/%ld, pi=%d, %Ld-%Ld)\n",
719
+
dprintk("lockd: nlmsvc_cancel(%s/%llu, pi=%d, %Ld-%Ld)\n",
720
720
nlmsvc_file_inode(file)->i_sb->s_id,
721
721
nlmsvc_file_inode(file)->i_ino,
722
722
lock->fl.c.flc_pid,
+1
-1
fs/lockd/svcsubs.c
+1
-1
fs/lockd/svcsubs.c
+3
-3
fs/locks.c
+3
-3
fs/locks.c
···
234
234
if (unlikely(!list_empty(&ctx->flc_flock) ||
235
235
!list_empty(&ctx->flc_posix) ||
236
236
!list_empty(&ctx->flc_lease))) {
237
-
pr_warn("Leaked locks on dev=0x%x:0x%x ino=0x%lx:\n",
237
+
pr_warn("Leaked locks on dev=0x%x:0x%x ino=0x%llx:\n",
238
238
MAJOR(inode->i_sb->s_dev), MINOR(inode->i_sb->s_dev),
239
239
inode->i_ino);
240
240
locks_dump_ctx_list(&ctx->flc_flock, "FLOCK");
···
251
251
252
252
list_for_each_entry(flc, list, flc_list)
253
253
if (flc->flc_file == filp)
254
-
pr_warn("Leaked %s lock on dev=0x%x:0x%x ino=0x%lx "
254
+
pr_warn("Leaked %s lock on dev=0x%x:0x%x ino=0x%llx "
255
255
" fl_owner=%p fl_flags=0x%x fl_type=0x%x fl_pid=%u\n",
256
256
list_type, MAJOR(inode->i_sb->s_dev),
257
257
MINOR(inode->i_sb->s_dev), inode->i_ino,
···
2896
2896
(type == F_RDLCK) ? "READ" : "UNLCK");
2897
2897
if (inode) {
2898
2898
/* userspace relies on this representation of dev_t */
2899
-
seq_printf(f, "%d %02x:%02x:%lu ", pid,
2899
+
seq_printf(f, "%d %02x:%02x:%llu ", pid,
2900
2900
MAJOR(inode->i_sb->s_dev),
2901
2901
MINOR(inode->i_sb->s_dev), inode->i_ino);
2902
2902
} else {
+5
-5
fs/minix/inode.c
+5
-5
fs/minix/inode.c
···
36
36
vaf.fmt = fmt;
37
37
vaf.va = &args;
38
38
printk(KERN_CRIT "minix-fs error (device %s): %s:%d: "
39
-
"inode #%lu: comm %s: %pV\n",
39
+
"inode #%llu: comm %s: %pV\n",
40
40
inode->i_sb->s_id, function, line, inode->i_ino,
41
41
current->comm, &vaf);
42
42
va_end(args);
···
520
520
S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
521
521
init_special_inode(inode, inode->i_mode, rdev);
522
522
} else {
523
-
printk(KERN_DEBUG "MINIX-fs: Invalid file type 0%04o for inode %lu.\n",
523
+
printk(KERN_DEBUG "MINIX-fs: Invalid file type 0%04o for inode %llu.\n",
524
524
inode->i_mode, inode->i_ino);
525
525
make_bad_inode(inode);
526
526
}
···
542
542
return ERR_PTR(-EIO);
543
543
}
544
544
if (raw_inode->i_nlinks == 0) {
545
-
printk("MINIX-fs: deleted inode referenced: %lu\n",
545
+
printk("MINIX-fs: deleted inode referenced: %llu\n",
546
546
inode->i_ino);
547
547
brelse(bh);
548
548
iget_failed(inode);
···
580
580
return ERR_PTR(-EIO);
581
581
}
582
582
if (raw_inode->i_nlinks == 0) {
583
-
printk("MINIX-fs: deleted inode referenced: %lu\n",
583
+
printk("MINIX-fs: deleted inode referenced: %llu\n",
584
584
inode->i_ino);
585
585
brelse(bh);
586
586
iget_failed(inode);
···
692
692
if (wbc->sync_mode == WB_SYNC_ALL && buffer_dirty(bh)) {
693
693
sync_dirty_buffer(bh);
694
694
if (buffer_req(bh) && !buffer_uptodate(bh)) {
695
-
printk("IO error syncing minix inode [%s:%08lx]\n",
695
+
printk("IO error syncing minix inode [%s:%08llx]\n",
696
696
inode->i_sb->s_id, inode->i_ino);
697
697
err = -EIO;
698
698
}
+10
-10
fs/nfs/dir.c
+10
-10
fs/nfs/dir.c
···
1906
1906
}
1907
1907
1908
1908
error = nfs_lookup_verify_inode(inode, flags);
1909
-
dfprintk(LOOKUPCACHE, "NFS: %s: inode %lu is %s\n",
1909
+
dfprintk(LOOKUPCACHE, "NFS: %s: inode %llu is %s\n",
1910
1910
__func__, inode->i_ino, error ? "invalid" : "valid");
1911
1911
return !error;
1912
1912
}
···
2121
2121
/* Expect a negative dentry */
2122
2122
BUG_ON(d_inode(dentry));
2123
2123
2124
-
dfprintk(VFS, "NFS: atomic_open(%s/%lu), %pd\n",
2124
+
dfprintk(VFS, "NFS: atomic_open(%s/%llu), %pd\n",
2125
2125
dir->i_sb->s_id, dir->i_ino, dentry);
2126
2126
2127
2127
err = nfs_check_flags(open_flags);
···
2404
2404
2405
2405
open_flags |= O_CREAT;
2406
2406
2407
-
dfprintk(VFS, "NFS: create(%s/%lu), %pd\n",
2407
+
dfprintk(VFS, "NFS: create(%s/%llu), %pd\n",
2408
2408
dir->i_sb->s_id, dir->i_ino, dentry);
2409
2409
2410
2410
attr.ia_mode = mode;
···
2442
2442
struct iattr attr;
2443
2443
int status;
2444
2444
2445
-
dfprintk(VFS, "NFS: mknod(%s/%lu), %pd\n",
2445
+
dfprintk(VFS, "NFS: mknod(%s/%llu), %pd\n",
2446
2446
dir->i_sb->s_id, dir->i_ino, dentry);
2447
2447
2448
2448
attr.ia_mode = mode;
···
2469
2469
struct iattr attr;
2470
2470
struct dentry *ret;
2471
2471
2472
-
dfprintk(VFS, "NFS: mkdir(%s/%lu), %pd\n",
2472
+
dfprintk(VFS, "NFS: mkdir(%s/%llu), %pd\n",
2473
2473
dir->i_sb->s_id, dir->i_ino, dentry);
2474
2474
2475
2475
attr.ia_valid = ATTR_MODE;
···
2507
2507
{
2508
2508
int error;
2509
2509
2510
-
dfprintk(VFS, "NFS: rmdir(%s/%lu), %pd\n",
2510
+
dfprintk(VFS, "NFS: rmdir(%s/%llu), %pd\n",
2511
2511
dir->i_sb->s_id, dir->i_ino, dentry);
2512
2512
2513
2513
trace_nfs_rmdir_enter(dir, dentry);
···
2578
2578
{
2579
2579
int error;
2580
2580
2581
-
dfprintk(VFS, "NFS: unlink(%s/%lu, %pd)\n", dir->i_sb->s_id,
2581
+
dfprintk(VFS, "NFS: unlink(%s/%llu, %pd)\n", dir->i_sb->s_id,
2582
2582
dir->i_ino, dentry);
2583
2583
2584
2584
trace_nfs_unlink_enter(dir, dentry);
···
2638
2638
unsigned int pathlen = strlen(symname);
2639
2639
int error;
2640
2640
2641
-
dfprintk(VFS, "NFS: symlink(%s/%lu, %pd, %s)\n", dir->i_sb->s_id,
2641
+
dfprintk(VFS, "NFS: symlink(%s/%llu, %pd, %s)\n", dir->i_sb->s_id,
2642
2642
dir->i_ino, dentry, symname);
2643
2643
2644
2644
if (pathlen > PAGE_SIZE)
···
2660
2660
error = NFS_PROTO(dir)->symlink(dir, dentry, folio, pathlen, &attr);
2661
2661
trace_nfs_symlink_exit(dir, dentry, error);
2662
2662
if (error != 0) {
2663
-
dfprintk(VFS, "NFS: symlink(%s/%lu, %pd, %s) error %d\n",
2663
+
dfprintk(VFS, "NFS: symlink(%s/%llu, %pd, %s) error %d\n",
2664
2664
dir->i_sb->s_id, dir->i_ino,
2665
2665
dentry, symname, error);
2666
2666
d_drop(dentry);
···
3414
3414
if (!res && (mask & MAY_EXEC))
3415
3415
res = nfs_execute_ok(inode, mask);
3416
3416
3417
-
dfprintk(VFS, "NFS: permission(%s/%lu), mask=0x%x, res=%d\n",
3417
+
dfprintk(VFS, "NFS: permission(%s/%llu), mask=0x%x, res=%d\n",
3418
3418
inode->i_sb->s_id, inode->i_ino, mask, res);
3419
3419
return res;
3420
3420
out_notsup:
+4
-4
fs/nfs/file.c
+4
-4
fs/nfs/file.c
···
391
391
392
392
trace_nfs_write_begin(file_inode(file), pos, len);
393
393
394
-
dfprintk(PAGECACHE, "NFS: write_begin(%pD2(%lu), %u@%lld)\n",
394
+
dfprintk(PAGECACHE, "NFS: write_begin(%pD2(%llu), %u@%lld)\n",
395
395
file, mapping->host->i_ino, len, (long long) pos);
396
396
nfs_truncate_last_folio(mapping, i_size_read(mapping->host), pos);
397
397
···
432
432
int status;
433
433
434
434
trace_nfs_write_end(file_inode(file), pos, len);
435
-
dfprintk(PAGECACHE, "NFS: write_end(%pD2(%lu), %u@%lld)\n",
435
+
dfprintk(PAGECACHE, "NFS: write_end(%pD2(%llu), %u@%lld)\n",
436
436
file, mapping->host->i_ino, len, (long long) pos);
437
437
438
438
/*
···
557
557
struct inode *inode = folio->mapping->host;
558
558
int ret;
559
559
560
-
dfprintk(PAGECACHE, "NFS: launder_folio(%ld, %llu)\n",
560
+
dfprintk(PAGECACHE, "NFS: launder_folio(%llu, %llu)\n",
561
561
inode->i_ino, folio_pos(folio));
562
562
563
563
folio_wait_private_2(folio); /* [DEPRECATED] */
···
647
647
struct address_space *mapping;
648
648
struct folio *folio = page_folio(vmf->page);
649
649
650
-
dfprintk(PAGECACHE, "NFS: vm_page_mkwrite(%pD2(%lu), offset %lld)\n",
650
+
dfprintk(PAGECACHE, "NFS: vm_page_mkwrite(%pD2(%llu), offset %lld)\n",
651
651
filp, filp->f_mapping->host->i_ino,
652
652
(long long)folio_pos(folio));
653
653
+4
-4
fs/nfs/filelayout/filelayout.c
+4
-4
fs/nfs/filelayout/filelayout.c
···
241
241
242
242
/* Note: if the write is unstable, don't set end_offs until commit */
243
243
pnfs_set_layoutcommit(hdr->inode, hdr->lseg, end_offs);
244
-
dprintk("%s inode %lu pls_end_pos %lu\n", __func__, hdr->inode->i_ino,
244
+
dprintk("%s inode %llu pls_end_pos %lu\n", __func__, hdr->inode->i_ino,
245
245
(unsigned long) NFS_I(hdr->inode)->layout->plh_lwb);
246
246
}
247
247
···
456
456
u32 j, idx;
457
457
struct nfs_fh *fh;
458
458
459
-
dprintk("--> %s ino %lu pgbase %u req %zu@%llu\n",
459
+
dprintk("--> %s ino %llu pgbase %u req %zu@%llu\n",
460
460
__func__, hdr->inode->i_ino,
461
461
hdr->args.pgbase, (size_t)hdr->args.count, offset);
462
462
···
514
514
if (IS_ERR(ds_clnt))
515
515
return PNFS_NOT_ATTEMPTED;
516
516
517
-
dprintk("%s ino %lu sync %d req %zu@%llu DS: %s cl_count %d\n",
517
+
dprintk("%s ino %llu sync %d req %zu@%llu DS: %s cl_count %d\n",
518
518
__func__, hdr->inode->i_ino, sync, (size_t) hdr->args.count,
519
519
offset, ds->ds_remotestr, refcount_read(&ds->ds_clp->cl_count));
520
520
···
1001
1001
if (IS_ERR(ds_clnt))
1002
1002
goto out_err;
1003
1003
1004
-
dprintk("%s ino %lu, how %d cl_count %d\n", __func__,
1004
+
dprintk("%s ino %llu, how %d cl_count %d\n", __func__,
1005
1005
data->inode->i_ino, how, refcount_read(&ds->ds_clp->cl_count));
1006
1006
data->commit_done_cb = filelayout_commit_done_cb;
1007
1007
refcount_inc(&ds->ds_clp->cl_count);
+4
-4
fs/nfs/flexfilelayout/flexfilelayout.c
+4
-4
fs/nfs/flexfilelayout/flexfilelayout.c
···
1631
1631
return;
1632
1632
1633
1633
pnfs_set_layoutcommit(inode, lseg, end_offset);
1634
-
dprintk("%s inode %lu pls_end_pos %llu\n", __func__, inode->i_ino,
1634
+
dprintk("%s inode %llu pls_end_pos %llu\n", __func__, inode->i_ino,
1635
1635
(unsigned long long) NFS_I(inode)->layout->plh_lwb);
1636
1636
}
1637
1637
···
2136
2136
u32 dss_id;
2137
2137
bool ds_fatal_error = false;
2138
2138
2139
-
dprintk("--> %s ino %lu pgbase %u req %zu@%llu\n",
2139
+
dprintk("--> %s ino %llu pgbase %u req %zu@%llu\n",
2140
2140
__func__, hdr->inode->i_ino,
2141
2141
hdr->args.pgbase, (size_t)hdr->args.count, offset);
2142
2142
···
2245
2245
2246
2246
vers = nfs4_ff_layout_ds_version(mirror, dss_id);
2247
2247
2248
-
dprintk("%s ino %lu sync %d req %zu@%llu DS: %s cl_count %d vers %d\n",
2248
+
dprintk("%s ino %llu sync %d req %zu@%llu DS: %s cl_count %d vers %d\n",
2249
2249
__func__, hdr->inode->i_ino, sync, (size_t) hdr->args.count,
2250
2250
offset, ds->ds_remotestr, refcount_read(&ds->ds_clp->cl_count),
2251
2251
vers);
···
2336
2336
2337
2337
vers = nfs4_ff_layout_ds_version(mirror, dss_id);
2338
2338
2339
-
dprintk("%s ino %lu, how %d cl_count %d vers %d\n", __func__,
2339
+
dprintk("%s ino %llu, how %d cl_count %d vers %d\n", __func__,
2340
2340
data->inode->i_ino, how, refcount_read(&ds->ds_clp->cl_count),
2341
2341
vers);
2342
2342
data->commit_done_cb = ff_layout_commit_done_cb;
+3
-3
fs/nfs/inode.c
+3
-3
fs/nfs/inode.c
···
2258
2258
bool attr_changed = false;
2259
2259
bool have_delegation;
2260
2260
2261
-
dfprintk(VFS, "NFS: %s(%s/%lu fh_crc=0x%08x ct=%d info=0x%llx)\n",
2261
+
dfprintk(VFS, "NFS: %s(%s/%llu fh_crc=0x%08x ct=%d info=0x%llx)\n",
2262
2262
__func__, inode->i_sb->s_id, inode->i_ino,
2263
2263
nfs_display_fhandle_hash(NFS_FH(inode)),
2264
2264
icount_read(inode), fattr->valid);
···
2288
2288
/*
2289
2289
* Big trouble! The inode has become a different object.
2290
2290
*/
2291
-
printk(KERN_DEBUG "NFS: %s: inode %lu mode changed, %07o to %07o\n",
2291
+
printk(KERN_DEBUG "NFS: %s: inode %llu mode changed, %07o to %07o\n",
2292
2292
__func__, inode->i_ino, inode->i_mode, fattr->mode);
2293
2293
goto out_err;
2294
2294
}
···
2358
2358
if (S_ISDIR(inode->i_mode))
2359
2359
nfs_force_lookup_revalidate(inode);
2360
2360
attr_changed = true;
2361
-
dprintk("NFS: change_attr change on server for file %s/%ld\n",
2361
+
dprintk("NFS: change_attr change on server for file %s/%llu\n",
2362
2362
inode->i_sb->s_id,
2363
2363
inode->i_ino);
2364
2364
} else if (!have_delegation) {
+2
-2
fs/nfs/nfs4proc.c
+2
-2
fs/nfs/nfs4proc.c
···
4714
4714
nfs_fattr_init(fattr);
4715
4715
nfs4_init_sequence(server->nfs_client, &args.seq_args, &res.seq_res, 0, 0);
4716
4716
4717
-
dprintk("NFS call lookupp ino=0x%lx\n", inode->i_ino);
4717
+
dprintk("NFS call lookupp ino=0x%llx\n", inode->i_ino);
4718
4718
status = nfs4_do_call_sync(clnt, server, &msg, &args.seq_args,
4719
4719
&res.seq_res, task_flags);
4720
4720
dprintk("NFS reply lookupp: %d\n", status);
···
10019
10019
int status = 0;
10020
10020
10021
10021
dprintk("NFS: initiating layoutcommit call. sync %d "
10022
-
"lbw: %llu inode %lu\n", sync,
10022
+
"lbw: %llu inode %llu\n", sync,
10023
10023
data->args.lastbytewritten,
10024
10024
data->args.inode->i_ino);
10025
10025
+6
-6
fs/nfs/pnfs.c
+6
-6
fs/nfs/pnfs.c
···
891
891
while (!list_empty(layout_list)) {
892
892
lo = list_entry(layout_list->next, struct pnfs_layout_hdr,
893
893
plh_bulk_destroy);
894
-
dprintk("%s freeing layout for inode %lu\n", __func__,
894
+
dprintk("%s freeing layout for inode %llu\n", __func__,
895
895
lo->plh_inode->i_ino);
896
896
inode = lo->plh_inode;
897
897
···
1440
1440
int status = 0;
1441
1441
bool send, valid_layout;
1442
1442
1443
-
dprintk("NFS: %s for inode %lu\n", __func__, ino->i_ino);
1443
+
dprintk("NFS: %s for inode %llu\n", __func__, ino->i_ino);
1444
1444
1445
1445
spin_lock(&ino->i_lock);
1446
1446
lo = nfsi->layout;
···
3055
3055
3056
3056
hdr->mds_ops = call_ops;
3057
3057
3058
-
dprintk("%s: Writing ino:%lu %u@%llu (how %d)\n", __func__,
3058
+
dprintk("%s: Writing ino:%llu %u@%llu (how %d)\n", __func__,
3059
3059
inode->i_ino, hdr->args.count, hdr->args.offset, how);
3060
3060
trypnfs = nfss->pnfs_curr_ld->write_pagelist(hdr, how);
3061
3061
if (trypnfs != PNFS_NOT_ATTEMPTED)
···
3181
3181
3182
3182
hdr->mds_ops = call_ops;
3183
3183
3184
-
dprintk("%s: Reading ino:%lu %u@%llu\n",
3184
+
dprintk("%s: Reading ino:%llu %u@%llu\n",
3185
3185
__func__, inode->i_ino, hdr->args.count, hdr->args.offset);
3186
3186
3187
3187
trypnfs = nfss->pnfs_curr_ld->read_pagelist(hdr);
···
3314
3314
if (!test_and_set_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags)) {
3315
3315
nfsi->layout->plh_lwb = end_pos;
3316
3316
mark_as_dirty = true;
3317
-
dprintk("%s: Set layoutcommit for inode %lu ",
3317
+
dprintk("%s: Set layoutcommit for inode %llu ",
3318
3318
__func__, inode->i_ino);
3319
3319
} else if (end_pos > nfsi->layout->plh_lwb)
3320
3320
nfsi->layout->plh_lwb = end_pos;
···
3363
3363
if (!pnfs_layoutcommit_outstanding(inode))
3364
3364
return 0;
3365
3365
3366
-
dprintk("--> %s inode %lu\n", __func__, inode->i_ino);
3366
+
dprintk("--> %s inode %llu\n", __func__, inode->i_ino);
3367
3367
3368
3368
status = -EAGAIN;
3369
3369
if (test_and_set_bit(NFS_INO_LAYOUTCOMMITTING, &nfsi->flags)) {
+1
-1
fs/nfsd/export.c
+1
-1
fs/nfsd/export.c
···
1051
1051
}
1052
1052
inode = d_inode(path.dentry);
1053
1053
1054
-
dprintk("nfsd: exp_rootfh(%s [%p] %s:%s/%ld)\n",
1054
+
dprintk("nfsd: exp_rootfh(%s [%p] %s:%s/%llu)\n",
1055
1055
name, path.dentry, clp->name,
1056
1056
inode->i_sb->s_id, inode->i_ino);
1057
1057
exp = exp_parent(cd, clp, &path);
+2
-2
fs/nfsd/nfs4state.c
+2
-2
fs/nfsd/nfs4state.c
···
1253
1253
if (ret) {
1254
1254
struct inode *inode = file_inode(f);
1255
1255
1256
-
pr_notice_ratelimited("nfsd: Unable to update timestamps on inode %02x:%02x:%lu: %d\n",
1256
+
pr_notice_ratelimited("nfsd: Unable to update timestamps on inode %02x:%02x:%llu: %d\n",
1257
1257
MAJOR(inode->i_sb->s_dev),
1258
1258
MINOR(inode->i_sb->s_dev),
1259
1259
inode->i_ino, ret);
···
2888
2888
{
2889
2889
struct inode *inode = file_inode(f->nf_file);
2890
2890
2891
-
seq_printf(s, "superblock: \"%02x:%02x:%ld\"",
2891
+
seq_printf(s, "superblock: \"%02x:%02x:%llu\"",
2892
2892
MAJOR(inode->i_sb->s_dev),
2893
2893
MINOR(inode->i_sb->s_dev),
2894
2894
inode->i_ino);
+2
-2
fs/nfsd/nfsfh.c
+2
-2
fs/nfsd/nfsfh.c
···
601
601
struct inode * inode = d_inode(dentry);
602
602
dev_t ex_dev = exp_sb(exp)->s_dev;
603
603
604
-
dprintk("nfsd: fh_compose(exp %02x:%02x/%ld %pd2, ino=%ld)\n",
604
+
dprintk("nfsd: fh_compose(exp %02x:%02x/%llu %pd2, ino=%llu)\n",
605
605
MAJOR(ex_dev), MINOR(ex_dev),
606
-
(long) d_inode(exp->ex_path.dentry)->i_ino,
606
+
d_inode(exp->ex_path.dentry)->i_ino,
607
607
dentry,
608
608
(inode ? inode->i_ino : 0));
609
609
+1
-1
fs/nfsd/vfs.c
+1
-1
fs/nfsd/vfs.c
···
1163
1163
} else if (unlikely(host_err == -EINVAL)) {
1164
1164
struct inode *inode = d_inode(fhp->fh_dentry);
1165
1165
1166
-
pr_info_ratelimited("nfsd: Direct I/O alignment failure on %s/%ld\n",
1166
+
pr_info_ratelimited("nfsd: Direct I/O alignment failure on %s/%llu\n",
1167
1167
inode->i_sb->s_id, inode->i_ino);
1168
1168
host_err = -ESERVERFAULT;
1169
1169
}
+5
-5
fs/nilfs2/alloc.c
+5
-5
fs/nilfs2/alloc.c
···
707
707
708
708
if (!nilfs_clear_bit_atomic(lock, group_offset, bitmap))
709
709
nilfs_warn(inode->i_sb,
710
-
"%s (ino=%lu): entry number %llu already freed",
710
+
"%s (ino=%llu): entry number %llu already freed",
711
711
__func__, inode->i_ino,
712
712
(unsigned long long)req->pr_entry_nr);
713
713
else
···
748
748
749
749
if (!nilfs_clear_bit_atomic(lock, group_offset, bitmap))
750
750
nilfs_warn(inode->i_sb,
751
-
"%s (ino=%lu): entry number %llu already freed",
751
+
"%s (ino=%llu): entry number %llu already freed",
752
752
__func__, inode->i_ino,
753
753
(unsigned long long)req->pr_entry_nr);
754
754
else
···
861
861
if (!nilfs_clear_bit_atomic(lock, group_offset,
862
862
bitmap)) {
863
863
nilfs_warn(inode->i_sb,
864
-
"%s (ino=%lu): entry number %llu already freed",
864
+
"%s (ino=%llu): entry number %llu already freed",
865
865
__func__, inode->i_ino,
866
866
(unsigned long long)entry_nrs[j]);
867
867
} else {
···
906
906
last_nrs[k]);
907
907
if (ret && ret != -ENOENT)
908
908
nilfs_warn(inode->i_sb,
909
-
"error %d deleting block that object (entry=%llu, ino=%lu) belongs to",
909
+
"error %d deleting block that object (entry=%llu, ino=%llu) belongs to",
910
910
ret, (unsigned long long)last_nrs[k],
911
911
inode->i_ino);
912
912
}
···
923
923
ret = nilfs_palloc_delete_bitmap_block(inode, group);
924
924
if (ret && ret != -ENOENT)
925
925
nilfs_warn(inode->i_sb,
926
-
"error %d deleting bitmap block of group=%lu, ino=%lu",
926
+
"error %d deleting bitmap block of group=%lu, ino=%llu",
927
927
ret, group, inode->i_ino);
928
928
}
929
929
}
+12
-5
fs/nilfs2/bmap.c
+12
-5
fs/nilfs2/bmap.c
···
33
33
34
34
if (err == -EINVAL) {
35
35
__nilfs_error(inode->i_sb, fname,
36
-
"broken bmap (inode number=%lu)", inode->i_ino);
36
+
"broken bmap (inode number=%llu)", inode->i_ino);
37
37
err = -EIO;
38
38
}
39
39
return err;
···
450
450
return NILFS_BMAP_INVALID_PTR;
451
451
}
452
452
453
-
#define NILFS_BMAP_GROUP_DIV 8
453
+
#define NILFS_BMAP_GROUP_DIV 8 /* must be power of 2 */
454
+
454
455
__u64 nilfs_bmap_find_target_in_group(const struct nilfs_bmap *bmap)
455
456
{
456
457
struct inode *dat = nilfs_bmap_get_dat(bmap);
457
458
unsigned long entries_per_group = nilfs_palloc_entries_per_group(dat);
458
-
unsigned long group = bmap->b_inode->i_ino / entries_per_group;
459
+
unsigned long group;
460
+
u32 index;
461
+
462
+
BUILD_BUG_ON_NOT_POWER_OF_2(NILFS_BMAP_GROUP_DIV);
463
+
464
+
group = div_u64(bmap->b_inode->i_ino, entries_per_group);
465
+
index = bmap->b_inode->i_ino & (NILFS_BMAP_GROUP_DIV - 1);
459
466
460
467
return group * entries_per_group +
461
-
(bmap->b_inode->i_ino % NILFS_BMAP_GROUP_DIV) *
462
-
(entries_per_group / NILFS_BMAP_GROUP_DIV);
468
+
index * (entries_per_group / NILFS_BMAP_GROUP_DIV);
463
469
}
470
+
464
471
465
472
static struct lock_class_key nilfs_bmap_dat_lock_key;
466
473
static struct lock_class_key nilfs_bmap_mdt_lock_key;
+1
-1
fs/nilfs2/btnode.c
+1
-1
fs/nilfs2/btnode.c
···
64
64
* clearing of an abandoned b-tree node is missing somewhere).
65
65
*/
66
66
nilfs_error(inode->i_sb,
67
-
"state inconsistency probably due to duplicate use of b-tree node block address %llu (ino=%lu)",
67
+
"state inconsistency probably due to duplicate use of b-tree node block address %llu (ino=%llu)",
68
68
(unsigned long long)blocknr, inode->i_ino);
69
69
goto failed;
70
70
}
+6
-6
fs/nilfs2/btree.c
+6
-6
fs/nilfs2/btree.c
···
353
353
nchildren <= 0 ||
354
354
nchildren > NILFS_BTREE_NODE_NCHILDREN_MAX(size))) {
355
355
nilfs_crit(inode->i_sb,
356
-
"bad btree node (ino=%lu, blocknr=%llu): level = %d, flags = 0x%x, nchildren = %d",
356
+
"bad btree node (ino=%llu, blocknr=%llu): level = %d, flags = 0x%x, nchildren = %d",
357
357
inode->i_ino, (unsigned long long)blocknr, level,
358
358
flags, nchildren);
359
359
ret = 1;
···
384
384
nchildren > NILFS_BTREE_ROOT_NCHILDREN_MAX ||
385
385
(nchildren == 0 && level > NILFS_BTREE_LEVEL_NODE_MIN))) {
386
386
nilfs_crit(inode->i_sb,
387
-
"bad btree root (ino=%lu): level = %d, flags = 0x%x, nchildren = %d",
387
+
"bad btree root (ino=%llu): level = %d, flags = 0x%x, nchildren = %d",
388
388
inode->i_ino, level, flags, nchildren);
389
389
ret = 1;
390
390
}
···
453
453
if (unlikely(nilfs_btree_node_get_level(node) != level)) {
454
454
dump_stack();
455
455
nilfs_crit(btree->b_inode->i_sb,
456
-
"btree level mismatch (ino=%lu): %d != %d",
456
+
"btree level mismatch (ino=%llu): %d != %d",
457
457
btree->b_inode->i_ino,
458
458
nilfs_btree_node_get_level(node), level);
459
459
return 1;
···
521
521
out_no_wait:
522
522
if (!buffer_uptodate(bh)) {
523
523
nilfs_err(btree->b_inode->i_sb,
524
-
"I/O error reading b-tree node block (ino=%lu, blocknr=%llu)",
524
+
"I/O error reading b-tree node block (ino=%llu, blocknr=%llu)",
525
525
btree->b_inode->i_ino, (unsigned long long)ptr);
526
526
brelse(bh);
527
527
return -EIO;
···
2104
2104
if (ret < 0) {
2105
2105
if (unlikely(ret == -ENOENT)) {
2106
2106
nilfs_crit(btree->b_inode->i_sb,
2107
-
"writing node/leaf block does not appear in b-tree (ino=%lu) at key=%llu, level=%d",
2107
+
"writing node/leaf block does not appear in b-tree (ino=%llu) at key=%llu, level=%d",
2108
2108
btree->b_inode->i_ino,
2109
2109
(unsigned long long)key, level);
2110
2110
ret = -EINVAL;
···
2146
2146
level >= NILFS_BTREE_LEVEL_MAX) {
2147
2147
dump_stack();
2148
2148
nilfs_warn(btree->b_inode->i_sb,
2149
-
"invalid btree level: %d (key=%llu, ino=%lu, blocknr=%llu)",
2149
+
"invalid btree level: %d (key=%llu, ino=%llu, blocknr=%llu)",
2150
2150
level, (unsigned long long)key,
2151
2151
btree->b_inode->i_ino,
2152
2152
(unsigned long long)bh->b_blocknr);
+6
-6
fs/nilfs2/dir.c
+6
-6
fs/nilfs2/dir.c
···
150
150
151
151
Ebadsize:
152
152
nilfs_error(sb,
153
-
"size of directory #%lu is not a multiple of chunk size",
153
+
"size of directory #%llu is not a multiple of chunk size",
154
154
dir->i_ino);
155
155
goto fail;
156
156
Eshort:
···
169
169
error = "disallowed inode number";
170
170
bad_entry:
171
171
nilfs_error(sb,
172
-
"bad entry in directory #%lu: %s - offset=%lu, inode=%lu, rec_len=%zd, name_len=%d",
172
+
"bad entry in directory #%llu: %s - offset=%lu, inode=%lu, rec_len=%zd, name_len=%d",
173
173
dir->i_ino, error, (folio->index << PAGE_SHIFT) + offs,
174
174
(unsigned long)le64_to_cpu(p->inode),
175
175
rec_len, p->name_len);
···
177
177
Eend:
178
178
p = (struct nilfs_dir_entry *)(kaddr + offs);
179
179
nilfs_error(sb,
180
-
"entry in directory #%lu spans the page boundary offset=%lu, inode=%lu",
180
+
"entry in directory #%llu spans the page boundary offset=%lu, inode=%lu",
181
181
dir->i_ino, (folio->index << PAGE_SHIFT) + offs,
182
182
(unsigned long)le64_to_cpu(p->inode));
183
183
fail:
···
251
251
252
252
kaddr = nilfs_get_folio(inode, n, &folio);
253
253
if (IS_ERR(kaddr)) {
254
-
nilfs_error(sb, "bad page in #%lu", inode->i_ino);
254
+
nilfs_error(sb, "bad page in #%llu", inode->i_ino);
255
255
ctx->pos += PAGE_SIZE - offset;
256
256
return -EIO;
257
257
}
···
336
336
/* next folio is past the blocks we've got */
337
337
if (unlikely(n > (dir->i_blocks >> (PAGE_SHIFT - 9)))) {
338
338
nilfs_error(dir->i_sb,
339
-
"dir %lu size %lld exceeds block count %llu",
339
+
"dir %llu size %lld exceeds block count %llu",
340
340
dir->i_ino, dir->i_size,
341
341
(unsigned long long)dir->i_blocks);
342
342
goto out;
···
382
382
return next_de;
383
383
384
384
fail:
385
-
nilfs_error(dir->i_sb, "directory #%lu %s", dir->i_ino, msg);
385
+
nilfs_error(dir->i_sb, "directory #%llu %s", dir->i_ino, msg);
386
386
folio_release_kmap(folio, de);
387
387
return NULL;
388
388
}
+2
-2
fs/nilfs2/direct.c
+2
-2
fs/nilfs2/direct.c
···
338
338
key = nilfs_bmap_data_get_key(bmap, *bh);
339
339
if (unlikely(key > NILFS_DIRECT_KEY_MAX)) {
340
340
nilfs_crit(bmap->b_inode->i_sb,
341
-
"%s (ino=%lu): invalid key: %llu",
341
+
"%s (ino=%llu): invalid key: %llu",
342
342
__func__,
343
343
bmap->b_inode->i_ino, (unsigned long long)key);
344
344
return -EINVAL;
···
346
346
ptr = nilfs_direct_get_ptr(bmap, key);
347
347
if (unlikely(ptr == NILFS_BMAP_INVALID_PTR)) {
348
348
nilfs_crit(bmap->b_inode->i_sb,
349
-
"%s (ino=%lu): invalid pointer: %llu",
349
+
"%s (ino=%llu): invalid pointer: %llu",
350
350
__func__,
351
351
bmap->b_inode->i_ino, (unsigned long long)ptr);
352
352
return -EINVAL;
+1
-1
fs/nilfs2/gcinode.c
+1
-1
fs/nilfs2/gcinode.c
···
137
137
struct inode *inode = bh->b_folio->mapping->host;
138
138
139
139
nilfs_err(inode->i_sb,
140
-
"I/O error reading %s block for GC (ino=%lu, vblocknr=%llu)",
140
+
"I/O error reading %s block for GC (ino=%llu, vblocknr=%llu)",
141
141
buffer_nilfs_node(bh) ? "node" : "data",
142
142
inode->i_ino, (unsigned long long)bh->b_blocknr);
143
143
return -EIO;
+4
-4
fs/nilfs2/inode.c
+4
-4
fs/nilfs2/inode.c
···
108
108
* be locked in this case.
109
109
*/
110
110
nilfs_warn(inode->i_sb,
111
-
"%s (ino=%lu): a race condition while inserting a data block at offset=%llu",
111
+
"%s (ino=%llu): a race condition while inserting a data block at offset=%llu",
112
112
__func__, inode->i_ino,
113
113
(unsigned long long)blkoff);
114
114
err = -EAGAIN;
···
789
789
goto repeat;
790
790
791
791
failed:
792
-
nilfs_warn(ii->vfs_inode.i_sb, "error %d truncating bmap (ino=%lu)",
792
+
nilfs_warn(ii->vfs_inode.i_sb, "error %d truncating bmap (ino=%llu)",
793
793
ret, ii->vfs_inode.i_ino);
794
794
}
795
795
···
1026
1026
* this inode.
1027
1027
*/
1028
1028
nilfs_warn(inode->i_sb,
1029
-
"cannot set file dirty (ino=%lu): the file is being freed",
1029
+
"cannot set file dirty (ino=%llu): the file is being freed",
1030
1030
inode->i_ino);
1031
1031
spin_unlock(&nilfs->ns_inode_lock);
1032
1032
return -EINVAL; /*
···
1057
1057
err = nilfs_load_inode_block(inode, &ibh);
1058
1058
if (unlikely(err)) {
1059
1059
nilfs_warn(inode->i_sb,
1060
-
"cannot mark inode dirty (ino=%lu): error %d loading inode block",
1060
+
"cannot mark inode dirty (ino=%llu): error %d loading inode block",
1061
1061
inode->i_ino, err);
1062
1062
return err;
1063
1063
}
+1
-1
fs/nilfs2/mdt.c
+1
-1
fs/nilfs2/mdt.c
···
203
203
err = -EIO;
204
204
if (!buffer_uptodate(first_bh)) {
205
205
nilfs_err(inode->i_sb,
206
-
"I/O error reading meta-data file (ino=%lu, block-offset=%lu)",
206
+
"I/O error reading meta-data file (ino=%llu, block-offset=%lu)",
207
207
inode->i_ino, block);
208
208
goto failed_bh;
209
209
}
+1
-1
fs/nilfs2/namei.c
+1
-1
fs/nilfs2/namei.c
+1
-1
fs/nilfs2/segment.c
+1
-1
fs/nilfs2/segment.c
···
2024
2024
ifile, ii->vfs_inode.i_ino, &ibh);
2025
2025
if (unlikely(err)) {
2026
2026
nilfs_warn(sci->sc_super,
2027
-
"log writer: error %d getting inode block (ino=%lu)",
2027
+
"log writer: error %d getting inode block (ino=%llu)",
2028
2028
err, ii->vfs_inode.i_ino);
2029
2029
return err;
2030
2030
}
+2
-2
fs/notify/fdinfo.c
+2
-2
fs/notify/fdinfo.c
···
84
84
inode_mark = container_of(mark, struct inotify_inode_mark, fsn_mark);
85
85
inode = igrab(fsnotify_conn_inode(mark->connector));
86
86
if (inode) {
87
-
seq_printf(m, "inotify wd:%x ino:%lx sdev:%x mask:%x ignored_mask:0 ",
87
+
seq_printf(m, "inotify wd:%x ino:%llx sdev:%x mask:%x ignored_mask:0 ",
88
88
inode_mark->wd, inode->i_ino, inode->i_sb->s_dev,
89
89
inotify_mark_user_mask(mark));
90
90
show_mark_fhandle(m, inode);
···
111
111
inode = igrab(fsnotify_conn_inode(mark->connector));
112
112
if (!inode)
113
113
return;
114
-
seq_printf(m, "fanotify ino:%lx sdev:%x mflags:%x mask:%x ignored_mask:%x ",
114
+
seq_printf(m, "fanotify ino:%llx sdev:%x mflags:%x mask:%x ignored_mask:%x ",
115
115
inode->i_ino, inode->i_sb->s_dev,
116
116
mflags, mark->mask, mark->ignore_mask);
117
117
show_mark_fhandle(m, inode);
+2
-2
fs/nsfs.c
+2
-2
fs/nsfs.c
···
46
46
struct ns_common *ns = inode->i_private;
47
47
const struct proc_ns_operations *ns_ops = ns->ops;
48
48
49
-
return dynamic_dname(buffer, buflen, "%s:[%lu]",
49
+
return dynamic_dname(buffer, buflen, "%s:[%llu]",
50
50
ns_ops->name, inode->i_ino);
51
51
}
52
52
···
407
407
const struct ns_common *ns = inode->i_private;
408
408
const struct proc_ns_operations *ns_ops = ns->ops;
409
409
410
-
seq_printf(seq, "%s:[%lu]", ns_ops->name, inode->i_ino);
410
+
seq_printf(seq, "%s:[%llu]", ns_ops->name, inode->i_ino);
411
411
return 0;
412
412
}
413
413
+1
-1
fs/ntfs3/super.c
+1
-1
fs/ntfs3/super.c
···
153
153
vaf.fmt = printk_skip_level(fmt);
154
154
vaf.va = &args;
155
155
156
-
printk("%c%cntfs3(%s): ino=%lx,%s %pV\n", KERN_SOH_ASCII, level,
156
+
printk("%c%cntfs3(%s): ino=%llx,%s %pV\n", KERN_SOH_ASCII, level,
157
157
sb->s_id, inode->i_ino, name ? name : "", &vaf);
158
158
159
159
va_end(args);
+1
-1
fs/ocfs2/alloc.c
+1
-1
fs/ocfs2/alloc.c
···
7318
7318
* to check it up here before changing the tree.
7319
7319
*/
7320
7320
if (root_el->l_tree_depth && rec->e_int_clusters == 0) {
7321
-
mlog(ML_ERROR, "Inode %lu has an empty "
7321
+
mlog(ML_ERROR, "Inode %llu has an empty "
7322
7322
"extent record, depth %u\n", inode->i_ino,
7323
7323
le16_to_cpu(root_el->l_tree_depth));
7324
7324
status = ocfs2_remove_rightmost_empty_extent(osb,
+2
-2
fs/ocfs2/aops.c
+2
-2
fs/ocfs2/aops.c
···
137
137
(unsigned long long)iblock, bh_result, create);
138
138
139
139
if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_SYSTEM_FILE)
140
-
mlog(ML_NOTICE, "get_block on system inode 0x%p (%lu)\n",
140
+
mlog(ML_NOTICE, "get_block on system inode 0x%p (%llu)\n",
141
141
inode, inode->i_ino);
142
142
143
143
if (S_ISLNK(inode->i_mode)) {
···
2146
2146
((iblock + ((len - 1) >> i_blkbits)) > endblk))
2147
2147
len = (endblk - iblock + 1) << i_blkbits;
2148
2148
2149
-
mlog(0, "get block of %lu at %llu:%u req %u\n",
2149
+
mlog(0, "get block of %llu at %llu:%u req %u\n",
2150
2150
inode->i_ino, pos, len, total_len);
2151
2151
2152
2152
/*
+4
-4
fs/ocfs2/dir.c
+4
-4
fs/ocfs2/dir.c
···
794
794
if (le16_to_cpu(el->l_count) !=
795
795
ocfs2_extent_recs_per_dx_root(inode->i_sb)) {
796
796
ret = ocfs2_error(inode->i_sb,
797
-
"Inode %lu has invalid extent list length %u\n",
797
+
"Inode %llu has invalid extent list length %u\n",
798
798
inode->i_ino, le16_to_cpu(el->l_count));
799
799
goto out;
800
800
}
···
812
812
813
813
if (el->l_tree_depth) {
814
814
ret = ocfs2_error(inode->i_sb,
815
-
"Inode %lu has non zero tree depth in btree tree block %llu\n",
815
+
"Inode %llu has non zero tree depth in btree tree block %llu\n",
816
816
inode->i_ino,
817
817
(unsigned long long)eb_bh->b_blocknr);
818
818
goto out;
···
821
821
822
822
if (le16_to_cpu(el->l_next_free_rec) == 0) {
823
823
ret = ocfs2_error(inode->i_sb,
824
-
"Inode %lu has empty extent list at depth %u\n",
824
+
"Inode %llu has empty extent list at depth %u\n",
825
825
inode->i_ino,
826
826
le16_to_cpu(el->l_tree_depth));
827
827
goto out;
···
839
839
840
840
if (!found) {
841
841
ret = ocfs2_error(inode->i_sb,
842
-
"Inode %lu has bad extent record (%u, %u, 0) in btree\n",
842
+
"Inode %llu has bad extent record (%u, %u, 0) in btree\n",
843
843
inode->i_ino,
844
844
le32_to_cpu(rec->e_cpos),
845
845
ocfs2_rec_clusters(el, rec));
+5
-5
fs/ocfs2/dlmfs/dlmfs.c
+5
-5
fs/ocfs2/dlmfs/dlmfs.c
···
123
123
if (S_ISDIR(inode->i_mode))
124
124
BUG();
125
125
126
-
mlog(0, "open called on inode %lu, flags 0x%x\n", inode->i_ino,
126
+
mlog(0, "open called on inode %llu, flags 0x%x\n", inode->i_ino,
127
127
file->f_flags);
128
128
129
129
status = dlmfs_decode_open_flags(file->f_flags, &level, &flags);
···
170
170
if (S_ISDIR(inode->i_mode))
171
171
BUG();
172
172
173
-
mlog(0, "close called on inode %lu\n", inode->i_ino);
173
+
mlog(0, "close called on inode %llu\n", inode->i_ino);
174
174
175
175
if (fp) {
176
176
level = fp->fp_lock_level;
···
242
242
int bytes_left;
243
243
struct inode *inode = file_inode(filp);
244
244
245
-
mlog(0, "inode %lu, count = %zu, *ppos = %llu\n",
245
+
mlog(0, "inode %llu, count = %zu, *ppos = %llu\n",
246
246
inode->i_ino, count, *ppos);
247
247
248
248
if (*ppos >= DLM_LVB_LEN)
···
301
301
302
302
clear_inode(inode);
303
303
304
-
mlog(0, "inode %lu\n", inode->i_ino);
304
+
mlog(0, "inode %llu\n", inode->i_ino);
305
305
306
306
ip = DLMFS_I(inode);
307
307
lockres = &ip->ip_lockres;
···
490
490
int status;
491
491
struct inode *inode = d_inode(dentry);
492
492
493
-
mlog(0, "unlink inode %lu\n", inode->i_ino);
493
+
mlog(0, "unlink inode %llu\n", inode->i_ino);
494
494
495
495
/* if there are no current holders, or none that are waiting
496
496
* to acquire a lock, this basically destroys our lockres. */
+6
-6
fs/ocfs2/extent_map.c
+6
-6
fs/ocfs2/extent_map.c
···
291
291
292
292
if (el->l_tree_depth) {
293
293
ocfs2_error(inode->i_sb,
294
-
"Inode %lu has non zero tree depth in leaf block %llu\n",
294
+
"Inode %llu has non zero tree depth in leaf block %llu\n",
295
295
inode->i_ino,
296
296
(unsigned long long)eb_bh->b_blocknr);
297
297
ret = -EROFS;
···
427
427
428
428
if (el->l_tree_depth) {
429
429
ocfs2_error(inode->i_sb,
430
-
"Inode %lu has non zero tree depth in leaf block %llu\n",
430
+
"Inode %llu has non zero tree depth in leaf block %llu\n",
431
431
inode->i_ino,
432
432
(unsigned long long)eb_bh->b_blocknr);
433
433
ret = -EROFS;
···
437
437
438
438
if (le16_to_cpu(el->l_next_free_rec) > le16_to_cpu(el->l_count)) {
439
439
ocfs2_error(inode->i_sb,
440
-
"Inode %lu has an invalid extent (next_free_rec %u, count %u)\n",
440
+
"Inode %llu has an invalid extent (next_free_rec %u, count %u)\n",
441
441
inode->i_ino,
442
442
le16_to_cpu(el->l_next_free_rec),
443
443
le16_to_cpu(el->l_count));
···
472
472
473
473
if (!rec->e_blkno) {
474
474
ocfs2_error(inode->i_sb,
475
-
"Inode %lu has bad extent record (%u, %u, 0)\n",
475
+
"Inode %llu has bad extent record (%u, %u, 0)\n",
476
476
inode->i_ino,
477
477
le32_to_cpu(rec->e_cpos),
478
478
ocfs2_rec_clusters(el, rec));
···
561
561
562
562
if (el->l_tree_depth) {
563
563
ocfs2_error(inode->i_sb,
564
-
"Inode %lu has non zero tree depth in xattr leaf block %llu\n",
564
+
"Inode %llu has non zero tree depth in xattr leaf block %llu\n",
565
565
inode->i_ino,
566
566
(unsigned long long)eb_bh->b_blocknr);
567
567
ret = -EROFS;
···
580
580
581
581
if (!rec->e_blkno) {
582
582
ocfs2_error(inode->i_sb,
583
-
"Inode %lu has bad extent record (%u, %u, 0) in xattr\n",
583
+
"Inode %llu has bad extent record (%u, %u, 0) in xattr\n",
584
584
inode->i_ino,
585
585
le32_to_cpu(rec->e_cpos),
586
586
ocfs2_rec_clusters(el, rec));
+1
-1
fs/ocfs2/inode.c
+1
-1
fs/ocfs2/inode.c
+1
-1
fs/ocfs2/quota_local.c
+1
-1
fs/ocfs2/quota_local.c
···
471
471
qsize_t spacechange, inodechange;
472
472
unsigned int memalloc;
473
473
474
-
trace_ocfs2_recover_local_quota_file((unsigned long)lqinode->i_ino, type);
474
+
trace_ocfs2_recover_local_quota_file(lqinode->i_ino, type);
475
475
476
476
list_for_each_entry_safe(rchunk, next, &(rec->r_list[type]), rc_list) {
477
477
chunk = rchunk->rc_chunk;
+5
-5
fs/ocfs2/refcounttree.c
+5
-5
fs/ocfs2/refcounttree.c
···
2341
2341
cpos, len, phys);
2342
2342
2343
2343
if (!ocfs2_refcount_tree(OCFS2_SB(inode->i_sb))) {
2344
-
ret = ocfs2_error(inode->i_sb, "Inode %lu want to use refcount tree, but the feature bit is not set in the super block\n",
2344
+
ret = ocfs2_error(inode->i_sb, "Inode %llu want to use refcount tree, but the feature bit is not set in the super block\n",
2345
2345
inode->i_ino);
2346
2346
goto out;
2347
2347
}
···
2524
2524
u64 start_cpos = ocfs2_blocks_to_clusters(inode->i_sb, phys_blkno);
2525
2525
2526
2526
if (!ocfs2_refcount_tree(OCFS2_SB(inode->i_sb))) {
2527
-
ret = ocfs2_error(inode->i_sb, "Inode %lu want to use refcount tree, but the feature bit is not set in the super block\n",
2527
+
ret = ocfs2_error(inode->i_sb, "Inode %llu want to use refcount tree, but the feature bit is not set in the super block\n",
2528
2528
inode->i_ino);
2529
2529
goto out;
2530
2530
}
···
2650
2650
2651
2651
if (el->l_tree_depth) {
2652
2652
ret = ocfs2_error(inode->i_sb,
2653
-
"Inode %lu has non zero tree depth in leaf block %llu\n",
2653
+
"Inode %llu has non zero tree depth in leaf block %llu\n",
2654
2654
inode->i_ino,
2655
2655
(unsigned long long)eb_bh->b_blocknr);
2656
2656
goto out;
···
2662
2662
rec = &el->l_recs[i];
2663
2663
2664
2664
if (ocfs2_is_empty_extent(rec)) {
2665
-
mlog_bug_on_msg(i != 0, "Inode %lu has empty record in "
2665
+
mlog_bug_on_msg(i != 0, "Inode %llu has empty record in "
2666
2666
"index %d\n", inode->i_ino, i);
2667
2667
continue;
2668
2668
}
···
3325
3325
struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
3326
3326
3327
3327
if (!ocfs2_refcount_tree(osb)) {
3328
-
return ocfs2_error(inode->i_sb, "Inode %lu want to use refcount tree, but the feature bit is not set in the super block\n",
3328
+
return ocfs2_error(inode->i_sb, "Inode %llu want to use refcount tree, but the feature bit is not set in the super block\n",
3329
3329
inode->i_ino);
3330
3330
}
3331
3331
+2
-2
fs/ocfs2/xattr.c
+2
-2
fs/ocfs2/xattr.c
···
3741
3741
3742
3742
if (el->l_tree_depth) {
3743
3743
ret = ocfs2_error(inode->i_sb,
3744
-
"Inode %lu has non zero tree depth in xattr tree block %llu\n",
3744
+
"Inode %llu has non zero tree depth in xattr tree block %llu\n",
3745
3745
inode->i_ino,
3746
3746
(unsigned long long)eb_bh->b_blocknr);
3747
3747
goto out;
···
3758
3758
}
3759
3759
3760
3760
if (!e_blkno) {
3761
-
ret = ocfs2_error(inode->i_sb, "Inode %lu has bad extent record (%u, %u, 0) in xattr\n",
3761
+
ret = ocfs2_error(inode->i_sb, "Inode %llu has bad extent record (%u, %u, 0) in xattr\n",
3762
3762
inode->i_ino,
3763
3763
le32_to_cpu(rec->e_cpos),
3764
3764
ocfs2_rec_clusters(el, rec));
+1
-1
fs/orangefs/inode.c
+1
-1
fs/orangefs/inode.c
+1
-1
fs/overlayfs/export.c
+1
-1
fs/overlayfs/export.c
+2
-2
fs/overlayfs/namei.c
+2
-2
fs/overlayfs/namei.c
···
591
591
592
592
fail:
593
593
inode = d_inode(real);
594
-
pr_warn_ratelimited("failed to verify %s (%pd2, ino=%lu, err=%i)\n",
594
+
pr_warn_ratelimited("failed to verify %s (%pd2, ino=%llu, err=%i)\n",
595
595
is_upper ? "upper" : "origin", real,
596
596
inode ? inode->i_ino : 0, err);
597
597
goto out;
···
831
831
index = NULL;
832
832
goto out;
833
833
}
834
-
pr_warn_ratelimited("failed inode index lookup (ino=%lu, key=%.*s, err=%i);\n"
834
+
pr_warn_ratelimited("failed inode index lookup (ino=%llu, key=%.*s, err=%i);\n"
835
835
"overlayfs: mount with '-o index=off' to disable inodes index.\n",
836
836
d_inode(origin)->i_ino, name.len, name.name,
837
837
err);
+1
-1
fs/overlayfs/util.c
+1
-1
fs/overlayfs/util.c
···
1095
1095
got_write = true;
1096
1096
inode = d_inode(upperdentry);
1097
1097
if (!S_ISDIR(inode->i_mode) && inode->i_nlink != 1) {
1098
-
pr_warn_ratelimited("cleanup linked index (%pd2, ino=%lu, nlink=%u)\n",
1098
+
pr_warn_ratelimited("cleanup linked index (%pd2, ino=%llu, nlink=%u)\n",
1099
1099
upperdentry, inode->i_ino, inode->i_nlink);
1100
1100
/*
1101
1101
* We either have a bug with persistent union nlink or a lower
+1
-1
fs/pipe.c
+1
-1
fs/pipe.c
+1
-1
fs/proc/fd.c
+1
-1
fs/proc/fd.c
···
54
54
if (ret)
55
55
return ret;
56
56
57
-
seq_printf(m, "pos:\t%lli\nflags:\t0%o\nmnt_id:\t%i\nino:\t%lu\n",
57
+
seq_printf(m, "pos:\t%lli\nflags:\t0%o\nmnt_id:\t%i\nino:\t%llu\n",
58
58
(long long)file->f_pos, f_flags,
59
59
real_mount(file->f_path.mnt)->mnt_id,
60
60
file_inode(file)->i_ino);
+2
-2
fs/proc/task_mmu.c
+2
-2
fs/proc/task_mmu.c
···
442
442
static void show_vma_header_prefix(struct seq_file *m,
443
443
unsigned long start, unsigned long end,
444
444
vm_flags_t flags, unsigned long long pgoff,
445
-
dev_t dev, unsigned long ino)
445
+
dev_t dev, u64 ino)
446
446
{
447
447
seq_setwidth(m, 25 + sizeof(void *) * 6 - 1);
448
448
seq_put_hex_ll(m, NULL, start, 8);
···
465
465
const struct path *path;
466
466
const char *name_fmt, *name;
467
467
vm_flags_t flags = vma->vm_flags;
468
-
unsigned long ino = 0;
468
+
u64 ino = 0;
469
469
unsigned long long pgoff = 0;
470
470
unsigned long start, end;
471
471
dev_t dev = 0;
+2
-2
fs/qnx4/inode.c
+2
-2
fs/qnx4/inode.c
···
62
62
{
63
63
unsigned long phys;
64
64
65
-
QNX4DEBUG((KERN_INFO "qnx4: qnx4_get_block inode=[%ld] iblock=[%ld]\n",inode->i_ino,iblock));
65
+
QNX4DEBUG((KERN_INFO "qnx4: qnx4_get_block inode=[%llu] iblock=[%ld]\n", inode->i_ino, iblock));
66
66
67
67
phys = qnx4_block_map( inode, iblock );
68
68
if ( phys ) {
···
128
128
brelse( bh );
129
129
}
130
130
131
-
QNX4DEBUG((KERN_INFO "qnx4: mapping block %ld of inode %ld = %ld\n",iblock,inode->i_ino,block));
131
+
QNX4DEBUG((KERN_INFO "qnx4: mapping block %ld of inode %llu = %ld\n", iblock, inode->i_ino, block));
132
132
return block;
133
133
}
134
134
+1
-1
fs/qnx6/inode.c
+1
-1
fs/qnx6/inode.c
+4
-4
fs/ubifs/debug.c
+4
-4
fs/ubifs/debug.c
···
230
230
int count = 2;
231
231
232
232
pr_err("Dump in-memory inode:");
233
-
pr_err("\tinode %lu\n", inode->i_ino);
233
+
pr_err("\tinode %llu\n", inode->i_ino);
234
234
pr_err("\tsize %llu\n",
235
235
(unsigned long long)i_size_read(inode));
236
236
pr_err("\tnlink %u\n", inode->i_nlink);
···
1101
1101
if (ui->ui_size != ui->synced_i_size && !ui->dirty) {
1102
1102
ubifs_err(c, "ui_size is %lld, synced_i_size is %lld, but inode is clean",
1103
1103
ui->ui_size, ui->synced_i_size);
1104
-
ubifs_err(c, "i_ino %lu, i_mode %#x, i_size %lld", inode->i_ino,
1104
+
ubifs_err(c, "i_ino %llu, i_mode %#x, i_size %lld", inode->i_ino,
1105
1105
inode->i_mode, i_size_read(inode));
1106
1106
dump_stack();
1107
1107
err = -EINVAL;
···
1163
1163
kfree(pdent);
1164
1164
1165
1165
if (i_size_read(dir) != size) {
1166
-
ubifs_err(c, "directory inode %lu has size %llu, but calculated size is %llu",
1166
+
ubifs_err(c, "directory inode %llu has size %llu, but calculated size is %llu",
1167
1167
dir->i_ino, (unsigned long long)i_size_read(dir),
1168
1168
(unsigned long long)size);
1169
1169
ubifs_dump_inode(c, dir);
···
1171
1171
return -EINVAL;
1172
1172
}
1173
1173
if (dir->i_nlink != nlink) {
1174
-
ubifs_err(c, "directory inode %lu has nlink %u, but calculated nlink is %u",
1174
+
ubifs_err(c, "directory inode %llu has nlink %u, but calculated nlink is %u",
1175
1175
dir->i_ino, dir->i_nlink, nlink);
1176
1176
ubifs_dump_inode(c, dir);
1177
1177
dump_stack();
+14
-14
fs/ubifs/dir.c
+14
-14
fs/ubifs/dir.c
···
223
223
struct ubifs_info *c = dir->i_sb->s_fs_info;
224
224
struct fscrypt_name nm;
225
225
226
-
dbg_gen("'%pd' in dir ino %lu", dentry, dir->i_ino);
226
+
dbg_gen("'%pd' in dir ino %llu", dentry, dir->i_ino);
227
227
228
228
err = fscrypt_prepare_lookup(dir, dentry, &nm);
229
229
if (err == -ENOENT)
···
281
281
if (IS_ENCRYPTED(dir) &&
282
282
(S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) &&
283
283
!fscrypt_has_permitted_context(dir, inode)) {
284
-
ubifs_warn(c, "Inconsistent encryption contexts: %lu/%lu",
284
+
ubifs_warn(c, "Inconsistent encryption contexts: %llu/%llu",
285
285
dir->i_ino, inode->i_ino);
286
286
iput(inode);
287
287
inode = ERR_PTR(-EPERM);
···
318
318
* parent directory inode.
319
319
*/
320
320
321
-
dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
321
+
dbg_gen("dent '%pd', mode %#hx in dir ino %llu",
322
322
dentry, mode, dir->i_ino);
323
323
324
324
err = ubifs_budget_space(c, &req);
···
386
386
* atomically.
387
387
*/
388
388
389
-
dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
389
+
dbg_gen("dent '%pd', mode %#hx in dir ino %llu",
390
390
dentry, mode, dir->i_ino);
391
391
392
392
inode = ubifs_new_inode(c, dir, mode, false);
···
460
460
* be released via writeback.
461
461
*/
462
462
463
-
dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
463
+
dbg_gen("dent '%pd', mode %#hx in dir ino %llu",
464
464
dentry, mode, dir->i_ino);
465
465
466
466
err = fscrypt_setup_filename(dir, &dentry->d_name, 0, &nm);
···
589
589
bool encrypted = IS_ENCRYPTED(dir);
590
590
struct ubifs_dir_data *data = file->private_data;
591
591
592
-
dbg_gen("dir ino %lu, f_pos %#llx", dir->i_ino, ctx->pos);
592
+
dbg_gen("dir ino %llu, f_pos %#llx", dir->i_ino, ctx->pos);
593
593
594
594
if (ctx->pos > UBIFS_S_KEY_HASH_MASK || ctx->pos == 2)
595
595
/*
···
764
764
* changing the parent inode.
765
765
*/
766
766
767
-
dbg_gen("dent '%pd' to ino %lu (nlink %d) in dir ino %lu",
767
+
dbg_gen("dent '%pd' to ino %llu (nlink %d) in dir ino %llu",
768
768
dentry, inode->i_ino,
769
769
inode->i_nlink, dir->i_ino);
770
770
ubifs_assert(c, inode_is_locked(dir));
···
836
836
* deletions.
837
837
*/
838
838
839
-
dbg_gen("dent '%pd' from ino %lu (nlink %d) in dir ino %lu",
839
+
dbg_gen("dent '%pd' from ino %llu (nlink %d) in dir ino %llu",
840
840
dentry, inode->i_ino,
841
841
inode->i_nlink, dir->i_ino);
842
842
···
941
941
* because we have extra space reserved for deletions.
942
942
*/
943
943
944
-
dbg_gen("directory '%pd', ino %lu in dir ino %lu", dentry,
944
+
dbg_gen("directory '%pd', ino %llu in dir ino %llu", dentry,
945
945
inode->i_ino, dir->i_ino);
946
946
ubifs_assert(c, inode_is_locked(dir));
947
947
ubifs_assert(c, inode_is_locked(inode));
···
1018
1018
* directory inode.
1019
1019
*/
1020
1020
1021
-
dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
1021
+
dbg_gen("dent '%pd', mode %#hx in dir ino %llu",
1022
1022
dentry, mode, dir->i_ino);
1023
1023
1024
1024
err = ubifs_budget_space(c, &req);
···
1096
1096
* directory inode.
1097
1097
*/
1098
1098
1099
-
dbg_gen("dent '%pd' in dir ino %lu", dentry, dir->i_ino);
1099
+
dbg_gen("dent '%pd' in dir ino %llu", dentry, dir->i_ino);
1100
1100
1101
1101
if (S_ISBLK(mode) || S_ISCHR(mode)) {
1102
1102
dev = kmalloc_obj(union ubifs_dev_desc, GFP_NOFS);
···
1183
1183
.dirtied_ino = 1 };
1184
1184
struct fscrypt_name nm;
1185
1185
1186
-
dbg_gen("dent '%pd', target '%s' in dir ino %lu", dentry,
1186
+
dbg_gen("dent '%pd', target '%s' in dir ino %llu", dentry,
1187
1187
symname, dir->i_ino);
1188
1188
1189
1189
err = fscrypt_prepare_symlink(dir, symname, len, UBIFS_MAX_INO_DATA,
···
1349
1349
* ino_req: marks the target inode as dirty and does not write it.
1350
1350
*/
1351
1351
1352
-
dbg_gen("dent '%pd' ino %lu in dir ino %lu to dent '%pd' in dir ino %lu flags 0x%x",
1352
+
dbg_gen("dent '%pd' ino %llu in dir ino %llu to dent '%pd' in dir ino %llu flags 0x%x",
1353
1353
old_dentry, old_inode->i_ino, old_dir->i_ino,
1354
1354
new_dentry, new_dir->i_ino, flags);
1355
1355
···
1597
1597
* parent directory inodes.
1598
1598
*/
1599
1599
1600
-
dbg_gen("dent '%pd' ino %lu in dir ino %lu exchange dent '%pd' ino %lu in dir ino %lu",
1600
+
dbg_gen("dent '%pd' ino %llu in dir ino %llu exchange dent '%pd' ino %llu in dir ino %llu",
1601
1601
old_dentry, fst_inode->i_ino, old_dir->i_ino,
1602
1602
new_dentry, snd_inode->i_ino, new_dir->i_ino);
1603
1603
+14
-14
fs/ubifs/file.c
+14
-14
fs/ubifs/file.c
···
90
90
return 0;
91
91
92
92
dump:
93
-
ubifs_err(c, "bad data node (block %u, inode %lu)",
93
+
ubifs_err(c, "bad data node (block %u, inode %llu)",
94
94
block, inode->i_ino);
95
95
ubifs_dump_node(c, dn, UBIFS_MAX_DATA_NODE_SZ);
96
96
return -EINVAL;
···
106
106
loff_t i_size = i_size_read(inode);
107
107
size_t offset = 0;
108
108
109
-
dbg_gen("ino %lu, pg %lu, i_size %lld, flags %#lx",
109
+
dbg_gen("ino %llu, pg %lu, i_size %lld, flags %#lx",
110
110
inode->i_ino, folio->index, i_size, folio->flags.f);
111
111
ubifs_assert(c, !folio_test_checked(folio));
112
112
ubifs_assert(c, !folio->private);
···
162
162
dbg_gen("hole");
163
163
err = 0;
164
164
} else {
165
-
ubifs_err(c, "cannot read page %lu of inode %lu, error %d",
165
+
ubifs_err(c, "cannot read page %lu of inode %llu, error %d",
166
166
folio->index, inode->i_ino, err);
167
167
}
168
168
}
···
212
212
int err, appending = !!(pos + len > inode->i_size);
213
213
struct folio *folio;
214
214
215
-
dbg_gen("ino %lu, pos %llu, len %u, i_size %lld",
215
+
dbg_gen("ino %llu, pos %llu, len %u, i_size %lld",
216
216
inode->i_ino, pos, len, inode->i_size);
217
217
218
218
/*
···
526
526
loff_t end_pos = pos + len;
527
527
int appending = !!(end_pos > inode->i_size);
528
528
529
-
dbg_gen("ino %lu, pos %llu, pg %lu, len %u, copied %d, i_size %lld",
529
+
dbg_gen("ino %llu, pos %llu, pg %lu, len %u, copied %d, i_size %lld",
530
530
inode->i_ino, pos, folio->index, len, copied, inode->i_size);
531
531
532
532
if (unlikely(copied < len && !folio_test_uptodate(folio))) {
···
599
599
size_t offset = 0;
600
600
pgoff_t end_index;
601
601
602
-
dbg_gen("ino %lu, pg %lu, i_size %lld, flags %#lx",
602
+
dbg_gen("ino %llu, pg %lu, i_size %lld, flags %#lx",
603
603
inode->i_ino, folio->index, i_size, folio->flags.f);
604
604
605
605
end_index = (i_size - 1) >> PAGE_SHIFT;
···
680
680
return 0;
681
681
682
682
out_err:
683
-
ubifs_err(c, "bad data node (block %u, inode %lu)",
683
+
ubifs_err(c, "bad data node (block %u, inode %llu)",
684
684
page_block, inode->i_ino);
685
685
return -EINVAL;
686
686
}
···
913
913
}
914
914
if (err) {
915
915
mapping_set_error(folio->mapping, err);
916
-
ubifs_err(c, "cannot write folio %lu of inode %lu, error %d",
916
+
ubifs_err(c, "cannot write folio %lu of inode %llu, error %d",
917
917
folio->index, inode->i_ino, err);
918
918
ubifs_ro_mode(c, err);
919
919
}
···
987
987
loff_t i_size = i_size_read(inode), synced_i_size;
988
988
int err, len = folio_size(folio);
989
989
990
-
dbg_gen("ino %lu, pg %lu, pg flags %#lx",
990
+
dbg_gen("ino %llu, pg %lu, pg flags %#lx",
991
991
inode->i_ino, folio->index, folio->flags.f);
992
992
ubifs_assert(c, folio->private != NULL);
993
993
···
1106
1106
int offset = new_size & (UBIFS_BLOCK_SIZE - 1), budgeted = 1;
1107
1107
struct ubifs_inode *ui = ubifs_inode(inode);
1108
1108
1109
-
dbg_gen("ino %lu, size %lld -> %lld", inode->i_ino, old_size, new_size);
1109
+
dbg_gen("ino %llu, size %lld -> %lld", inode->i_ino, old_size, new_size);
1110
1110
memset(&req, 0, sizeof(struct ubifs_budget_req));
1111
1111
1112
1112
/*
···
1258
1258
struct inode *inode = d_inode(dentry);
1259
1259
struct ubifs_info *c = inode->i_sb->s_fs_info;
1260
1260
1261
-
dbg_gen("ino %lu, mode %#x, ia_valid %#x",
1261
+
dbg_gen("ino %llu, mode %#x, ia_valid %#x",
1262
1262
inode->i_ino, inode->i_mode, attr->ia_valid);
1263
1263
err = setattr_prepare(&nop_mnt_idmap, dentry, attr);
1264
1264
if (err)
···
1308
1308
struct ubifs_info *c = inode->i_sb->s_fs_info;
1309
1309
int err;
1310
1310
1311
-
dbg_gen("syncing inode %lu", inode->i_ino);
1311
+
dbg_gen("syncing inode %llu", inode->i_ino);
1312
1312
1313
1313
if (c->ro_mount)
1314
1314
/*
···
1495
1495
struct ubifs_budget_req req = { .new_page = 1 };
1496
1496
int err, update_time;
1497
1497
1498
-
dbg_gen("ino %lu, pg %lu, i_size %lld", inode->i_ino, folio->index,
1498
+
dbg_gen("ino %llu, pg %lu, i_size %lld", inode->i_ino, folio->index,
1499
1499
i_size_read(inode));
1500
1500
ubifs_assert(c, !c->ro_media && !c->ro_mount);
1501
1501
···
1531
1531
err = ubifs_budget_space(c, &req);
1532
1532
if (unlikely(err)) {
1533
1533
if (err == -ENOSPC)
1534
-
ubifs_warn(c, "out of space for mmapped file (inode number %lu)",
1534
+
ubifs_warn(c, "out of space for mmapped file (inode number %llu)",
1535
1535
inode->i_ino);
1536
1536
return VM_FAULT_SIGBUS;
1537
1537
}
+3
-3
fs/ubifs/journal.c
+3
-3
fs/ubifs/journal.c
···
982
982
int kill_xattrs = ui->xattr_cnt && last_reference;
983
983
u8 hash[UBIFS_HASH_ARR_SZ];
984
984
985
-
dbg_jnl("ino %lu, nlink %u", inode->i_ino, inode->i_nlink);
985
+
dbg_jnl("ino %llu, nlink %u", inode->i_ino, inode->i_nlink);
986
986
987
987
if (kill_xattrs && ui->xattr_cnt > ubifs_xattr_max_cnt(c)) {
988
988
ubifs_err(c, "Cannot delete inode, it has too many xattrs!");
···
1743
1743
int dn_len = le32_to_cpu(dn->size);
1744
1744
1745
1745
if (dn_len <= 0 || dn_len > UBIFS_BLOCK_SIZE) {
1746
-
ubifs_err(c, "bad data node (block %u, inode %lu)",
1746
+
ubifs_err(c, "bad data node (block %u, inode %llu)",
1747
1747
blk, inode->i_ino);
1748
1748
ubifs_dump_node(c, dn, dn_size);
1749
1749
err = -EUCLEAN;
···
1987
1987
u8 hash_host[UBIFS_HASH_ARR_SZ];
1988
1988
u8 hash[UBIFS_HASH_ARR_SZ];
1989
1989
1990
-
dbg_jnl("ino %lu, ino %lu", host->i_ino, inode->i_ino);
1990
+
dbg_jnl("ino %llu, ino %llu", host->i_ino, inode->i_ino);
1991
1991
ubifs_assert(c, inode->i_nlink > 0);
1992
1992
ubifs_assert(c, mutex_is_locked(&host_ui->ui_mutex));
1993
1993
+8
-8
fs/ubifs/super.c
+8
-8
fs/ubifs/super.c
···
92
92
return 5;
93
93
94
94
if (!ubifs_compr_present(c, ui->compr_type)) {
95
-
ubifs_warn(c, "inode %lu uses '%s' compression, but it was not compiled in",
95
+
ubifs_warn(c, "inode %llu uses '%s' compression, but it was not compiled in",
96
96
inode->i_ino, ubifs_compr_name(c, ui->compr_type));
97
97
}
98
98
···
248
248
return inode;
249
249
250
250
out_invalid:
251
-
ubifs_err(c, "inode %lu validation failed, error %d", inode->i_ino, err);
251
+
ubifs_err(c, "inode %llu validation failed, error %d", inode->i_ino, err);
252
252
ubifs_dump_node(c, ino, UBIFS_MAX_INO_NODE_SZ);
253
253
ubifs_dump_inode(c, inode);
254
254
err = -EINVAL;
255
255
out_ino:
256
256
kfree(ino);
257
257
out:
258
-
ubifs_err(c, "failed to read inode %lu, error %d", inode->i_ino, err);
258
+
ubifs_err(c, "failed to read inode %llu, error %d", inode->i_ino, err);
259
259
iget_failed(inode);
260
260
return ERR_PTR(err);
261
261
}
···
316
316
* As an optimization, do not write orphan inodes to the media just
317
317
* because this is not needed.
318
318
*/
319
-
dbg_gen("inode %lu, mode %#x, nlink %u",
319
+
dbg_gen("inode %llu, mode %#x, nlink %u",
320
320
inode->i_ino, (int)inode->i_mode, inode->i_nlink);
321
321
if (inode->i_nlink) {
322
322
err = ubifs_jnl_write_inode(c, inode);
323
323
if (err)
324
-
ubifs_err(c, "can't write inode %lu, error %d",
324
+
ubifs_err(c, "can't write inode %llu, error %d",
325
325
inode->i_ino, err);
326
326
else
327
327
err = dbg_check_inode_size(c, inode, ui->ui_size);
···
357
357
*/
358
358
goto out;
359
359
360
-
dbg_gen("inode %lu, mode %#x", inode->i_ino, (int)inode->i_mode);
360
+
dbg_gen("inode %llu, mode %#x", inode->i_ino, (int)inode->i_mode);
361
361
ubifs_assert(c, !icount_read(inode));
362
362
363
363
truncate_inode_pages_final(&inode->i_data);
···
375
375
* Worst case we have a lost orphan inode wasting space, so a
376
376
* simple error message is OK here.
377
377
*/
378
-
ubifs_err(c, "can't delete inode %lu, error %d",
378
+
ubifs_err(c, "can't delete inode %llu, error %d",
379
379
inode->i_ino, err);
380
380
381
381
out:
···
399
399
ubifs_assert(c, mutex_is_locked(&ui->ui_mutex));
400
400
if (!ui->dirty) {
401
401
ui->dirty = 1;
402
-
dbg_gen("inode %lu", inode->i_ino);
402
+
dbg_gen("inode %llu", inode->i_ino);
403
403
}
404
404
}
405
405
+2
-2
fs/ubifs/tnc.c
+2
-2
fs/ubifs/tnc.c
···
3561
3561
3562
3562
out_dump:
3563
3563
block = key_block(c, key);
3564
-
ubifs_err(c, "inode %lu has size %lld, but there are data at offset %lld",
3565
-
(unsigned long)inode->i_ino, size,
3564
+
ubifs_err(c, "inode %llu has size %lld, but there are data at offset %lld",
3565
+
inode->i_ino, size,
3566
3566
((loff_t)block) << UBIFS_BLOCK_SHIFT);
3567
3567
mutex_unlock(&c->tnc_mutex);
3568
3568
ubifs_dump_inode(c, inode);
+7
-7
fs/ubifs/xattr.c
+7
-7
fs/ubifs/xattr.c
···
76
76
.dirtied_ino_d = ALIGN(host_ui->data_len, 8) };
77
77
78
78
if (host_ui->xattr_cnt >= ubifs_xattr_max_cnt(c)) {
79
-
ubifs_err(c, "inode %lu already has too many xattrs (%d), cannot create more",
79
+
ubifs_err(c, "inode %llu already has too many xattrs (%d), cannot create more",
80
80
host->i_ino, host_ui->xattr_cnt);
81
81
return -ENOSPC;
82
82
}
···
88
88
*/
89
89
names_len = host_ui->xattr_names + host_ui->xattr_cnt + fname_len(nm) + 1;
90
90
if (names_len > XATTR_LIST_MAX) {
91
-
ubifs_err(c, "cannot add one more xattr name to inode %lu, total names length would become %d, max. is %d",
91
+
ubifs_err(c, "cannot add one more xattr name to inode %llu, total names length would become %d, max. is %d",
92
92
host->i_ino, names_len, XATTR_LIST_MAX);
93
93
return -ENOSPC;
94
94
}
···
390
390
int err, len, written = 0;
391
391
struct fscrypt_name nm = {0};
392
392
393
-
dbg_gen("ino %lu ('%pd'), buffer size %zd", host->i_ino,
393
+
dbg_gen("ino %llu ('%pd'), buffer size %zd", host->i_ino,
394
394
dentry, size);
395
395
396
396
down_read(&host_ui->xattr_sem);
···
498
498
if (ubifs_inode(host)->xattr_cnt <= ubifs_xattr_max_cnt(c))
499
499
return 0;
500
500
501
-
ubifs_warn(c, "inode %lu has too many xattrs, doing a non-atomic deletion",
501
+
ubifs_warn(c, "inode %llu has too many xattrs, doing a non-atomic deletion",
502
502
host->i_ino);
503
503
504
504
down_write(&ubifs_inode(host)->xattr_sem);
···
641
641
&init_xattrs, NULL);
642
642
if (err) {
643
643
struct ubifs_info *c = dentry->i_sb->s_fs_info;
644
-
ubifs_err(c, "cannot initialize security for inode %lu, error %d",
644
+
ubifs_err(c, "cannot initialize security for inode %llu, error %d",
645
645
inode->i_ino, err);
646
646
}
647
647
return err;
···
652
652
struct dentry *dentry, struct inode *inode,
653
653
const char *name, void *buffer, size_t size)
654
654
{
655
-
dbg_gen("xattr '%s', ino %lu ('%pd'), buf size %zd", name,
655
+
dbg_gen("xattr '%s', ino %llu ('%pd'), buf size %zd", name,
656
656
inode->i_ino, dentry, size);
657
657
658
658
name = xattr_full_name(handler, name);
···
665
665
const char *name, const void *value,
666
666
size_t size, int flags)
667
667
{
668
-
dbg_gen("xattr '%s', host ino %lu ('%pd'), size %zd",
668
+
dbg_gen("xattr '%s', host ino %llu ('%pd'), size %zd",
669
669
name, inode->i_ino, dentry, size);
670
670
671
671
name = xattr_full_name(handler, name);
+9
-9
fs/udf/directory.c
+9
-9
fs/udf/directory.c
···
22
22
23
23
if (iter->fi.descTag.tagIdent != cpu_to_le16(TAG_IDENT_FID)) {
24
24
udf_err(iter->dir->i_sb,
25
-
"directory (ino %lu) has entry at pos %llu with incorrect tag %x\n",
25
+
"directory (ino %llu) has entry at pos %llu with incorrect tag %x\n",
26
26
iter->dir->i_ino, (unsigned long long)iter->pos,
27
27
le16_to_cpu(iter->fi.descTag.tagIdent));
28
28
return -EFSCORRUPTED;
···
30
30
len = udf_dir_entry_len(&iter->fi);
31
31
if (le16_to_cpu(iter->fi.lengthOfImpUse) & 3) {
32
32
udf_err(iter->dir->i_sb,
33
-
"directory (ino %lu) has entry at pos %llu with unaligned length of impUse field\n",
33
+
"directory (ino %llu) has entry at pos %llu with unaligned length of impUse field\n",
34
34
iter->dir->i_ino, (unsigned long long)iter->pos);
35
35
return -EFSCORRUPTED;
36
36
}
···
41
41
*/
42
42
if (len > 1 << iter->dir->i_blkbits) {
43
43
udf_err(iter->dir->i_sb,
44
-
"directory (ino %lu) has too big (%u) entry at pos %llu\n",
44
+
"directory (ino %llu) has too big (%u) entry at pos %llu\n",
45
45
iter->dir->i_ino, len, (unsigned long long)iter->pos);
46
46
return -EFSCORRUPTED;
47
47
}
48
48
if (iter->pos + len > iter->dir->i_size) {
49
49
udf_err(iter->dir->i_sb,
50
-
"directory (ino %lu) has entry past directory size at pos %llu\n",
50
+
"directory (ino %llu) has entry past directory size at pos %llu\n",
51
51
iter->dir->i_ino, (unsigned long long)iter->pos);
52
52
return -EFSCORRUPTED;
53
53
}
54
54
if (udf_dir_entry_len(&iter->fi) !=
55
55
sizeof(struct tag) + le16_to_cpu(iter->fi.descTag.descCRCLength)) {
56
56
udf_err(iter->dir->i_sb,
57
-
"directory (ino %lu) has entry where CRC length (%u) does not match entry length (%u)\n",
57
+
"directory (ino %llu) has entry where CRC length (%u) does not match entry length (%u)\n",
58
58
iter->dir->i_ino,
59
59
(unsigned)le16_to_cpu(iter->fi.descTag.descCRCLength),
60
60
(unsigned)(udf_dir_entry_len(&iter->fi) -
···
78
78
}
79
79
if (iter->dir->i_size < iter->pos + sizeof(struct fileIdentDesc)) {
80
80
udf_err(iter->dir->i_sb,
81
-
"directory (ino %lu) has entry straddling EOF\n",
81
+
"directory (ino %llu) has entry straddling EOF\n",
82
82
iter->dir->i_ino);
83
83
return -EFSCORRUPTED;
84
84
}
···
184
184
return 0;
185
185
}
186
186
udf_err(iter->dir->i_sb,
187
-
"extent after position %llu not allocated in directory (ino %lu)\n",
187
+
"extent after position %llu not allocated in directory (ino %llu)\n",
188
188
(unsigned long long)iter->pos, iter->dir->i_ino);
189
189
return -EFSCORRUPTED;
190
190
}
···
272
272
if (pos == dir->i_size)
273
273
return 0;
274
274
udf_err(dir->i_sb,
275
-
"position %llu not allocated in directory (ino %lu)\n",
275
+
"position %llu not allocated in directory (ino %llu)\n",
276
276
(unsigned long long)pos, dir->i_ino);
277
277
err = -EFSCORRUPTED;
278
278
goto out;
···
483
483
&iter->loffset, &etype);
484
484
if (err <= 0 || etype != (EXT_RECORDED_ALLOCATED >> 30)) {
485
485
udf_err(iter->dir->i_sb,
486
-
"block %llu not allocated in directory (ino %lu)\n",
486
+
"block %llu not allocated in directory (ino %llu)\n",
487
487
(unsigned long long)block, iter->dir->i_ino);
488
488
return -EFSCORRUPTED;
489
489
}
+1
-1
fs/udf/file.c
+1
-1
fs/udf/file.c
+6
-6
fs/udf/inode.c
+6
-6
fs/udf/inode.c
···
147
147
if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB &&
148
148
inode->i_size != iinfo->i_lenExtents) {
149
149
udf_warn(inode->i_sb,
150
-
"Inode %lu (mode %o) has inode size %llu different from extent length %llu. Filesystem need not be standards compliant.\n",
150
+
"Inode %llu (mode %o) has inode size %llu different from extent length %llu. Filesystem need not be standards compliant.\n",
151
151
inode->i_ino, inode->i_mode,
152
152
(unsigned long long)inode->i_size,
153
153
(unsigned long long)iinfo->i_lenExtents);
···
1383
1383
*/
1384
1384
bh = udf_read_ptagged(inode->i_sb, iloc, 0, &ident);
1385
1385
if (!bh) {
1386
-
udf_err(inode->i_sb, "(ino %lu) failed !bh\n", inode->i_ino);
1386
+
udf_err(inode->i_sb, "(ino %llu) failed !bh\n", inode->i_ino);
1387
1387
return -EIO;
1388
1388
}
1389
1389
1390
1390
if (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE &&
1391
1391
ident != TAG_IDENT_USE) {
1392
-
udf_err(inode->i_sb, "(ino %lu) failed ident=%u\n",
1392
+
udf_err(inode->i_sb, "(ino %llu) failed ident=%u\n",
1393
1393
inode->i_ino, ident);
1394
1394
goto out;
1395
1395
}
···
1638
1638
udf_debug("METADATA BITMAP FILE-----\n");
1639
1639
break;
1640
1640
default:
1641
-
udf_err(inode->i_sb, "(ino %lu) failed unknown file type=%u\n",
1641
+
udf_err(inode->i_sb, "(ino %llu) failed unknown file type=%u\n",
1642
1642
inode->i_ino, fe->icbTag.fileType);
1643
1643
goto out;
1644
1644
}
···
1939
1939
if (do_sync) {
1940
1940
sync_dirty_buffer(bh);
1941
1941
if (buffer_write_io_error(bh)) {
1942
-
udf_warn(inode->i_sb, "IO error syncing udf inode [%08lx]\n",
1942
+
udf_warn(inode->i_sb, "IO error syncing udf inode [%08llx]\n",
1943
1943
inode->i_ino);
1944
1944
err = -EIO;
1945
1945
}
···
2221
2221
2222
2222
if (++indirections > UDF_MAX_INDIR_EXTS) {
2223
2223
udf_err(inode->i_sb,
2224
-
"too many indirect extents in inode %lu\n",
2224
+
"too many indirect extents in inode %llu\n",
2225
2225
inode->i_ino);
2226
2226
return -EFSCORRUPTED;
2227
2227
}
+4
-4
fs/udf/namei.c
+4
-4
fs/udf/namei.c
···
550
550
goto end_unlink;
551
551
552
552
if (!inode->i_nlink) {
553
-
udf_debug("Deleting nonexistent file (%lu), %u\n",
553
+
udf_debug("Deleting nonexistent file (%llu), %u\n",
554
554
inode->i_ino, inode->i_nlink);
555
555
set_nlink(inode, 1);
556
556
}
···
809
809
&diriter);
810
810
if (retval == -ENOENT) {
811
811
udf_err(old_inode->i_sb,
812
-
"directory (ino %lu) has no '..' entry\n",
812
+
"directory (ino %llu) has no '..' entry\n",
813
813
old_inode->i_ino);
814
814
retval = -EFSCORRUPTED;
815
815
}
···
821
821
old_dir->i_ino) {
822
822
retval = -EFSCORRUPTED;
823
823
udf_err(old_inode->i_sb,
824
-
"directory (ino %lu) has parent entry pointing to another inode (%lu != %u)\n",
824
+
"directory (ino %llu) has parent entry pointing to another inode (%llu != %u)\n",
825
825
old_inode->i_ino, old_dir->i_ino,
826
826
udf_get_lb_pblock(old_inode->i_sb, &tloc, 0));
827
827
goto out_oiter;
···
869
869
retval = udf_fiiter_find_entry(old_dir, &old_dentry->d_name, &oiter);
870
870
if (retval) {
871
871
udf_err(old_dir->i_sb,
872
-
"failed to find renamed entry again in directory (ino %lu)\n",
872
+
"failed to find renamed entry again in directory (ino %llu)\n",
873
873
old_dir->i_ino);
874
874
} else {
875
875
udf_fiiter_delete_entry(&oiter);
+1
-1
fs/udf/super.c
+1
-1
fs/udf/super.c
···
1166
1166
}
1167
1167
map->s_uspace.s_table = inode;
1168
1168
map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_TABLE;
1169
-
udf_debug("unallocSpaceTable (part %d) @ %lu\n",
1169
+
udf_debug("unallocSpaceTable (part %d) @ %llu\n",
1170
1170
p_index, map->s_uspace.s_table->i_ino);
1171
1171
}
1172
1172
+3
-3
fs/ufs/balloc.c
+3
-3
fs/ufs/balloc.c
···
245
245
sector_t end, i;
246
246
struct buffer_head *head, *bh;
247
247
248
-
UFSD("ENTER, ino %lu, count %u, oldb %llu, newb %llu\n",
248
+
UFSD("ENTER, ino %llu, count %u, oldb %llu, newb %llu\n",
249
249
inode->i_ino, count,
250
250
(unsigned long long)oldb, (unsigned long long)newb);
251
251
···
340
340
unsigned cgno, oldcount, newcount;
341
341
u64 tmp, request, result;
342
342
343
-
UFSD("ENTER, ino %lu, fragment %llu, goal %llu, count %u\n",
343
+
UFSD("ENTER, ino %llu, fragment %llu, goal %llu, count %u\n",
344
344
inode->i_ino, (unsigned long long)fragment,
345
345
(unsigned long long)goal, count);
346
346
···
583
583
unsigned oldcg, i, j, k, allocsize;
584
584
u64 result;
585
585
586
-
UFSD("ENTER, ino %lu, cgno %u, goal %llu, count %u\n",
586
+
UFSD("ENTER, ino %llu, cgno %u, goal %llu, count %u\n",
587
587
inode->i_ino, cgno, (unsigned long long)goal, count);
588
588
589
589
sb = inode->i_sb;
+5
-5
fs/ufs/dir.c
+5
-5
fs/ufs/dir.c
···
150
150
151
151
Ebadsize:
152
152
ufs_error(sb, __func__,
153
-
"size of directory #%lu is not a multiple of chunk size",
153
+
"size of directory #%llu is not a multiple of chunk size",
154
154
dir->i_ino
155
155
);
156
156
goto fail;
···
169
169
Einumber:
170
170
error = "inode out of bounds";
171
171
bad_entry:
172
-
ufs_error(sb, __func__, "bad entry in directory #%lu: %s - "
172
+
ufs_error(sb, __func__, "bad entry in directory #%llu: %s - "
173
173
"offset=%llu, rec_len=%d, name_len=%d",
174
174
dir->i_ino, error, folio_pos(folio) + offs,
175
175
rec_len, ufs_get_de_namlen(sb, p));
···
177
177
Eend:
178
178
p = (struct ufs_dir_entry *)(kaddr + offs);
179
179
ufs_error(sb, __func__,
180
-
"entry in directory #%lu spans the page boundary"
180
+
"entry in directory #%llu spans the page boundary"
181
181
"offset=%llu",
182
182
dir->i_ino, folio_pos(folio) + offs);
183
183
fail:
···
258
258
struct ufs_inode_info *ui = UFS_I(dir);
259
259
struct ufs_dir_entry *de;
260
260
261
-
UFSD("ENTER, dir_ino %lu, name %s, namlen %u\n", dir->i_ino, name, namelen);
261
+
UFSD("ENTER, dir_ino %llu, name %s, namlen %u\n", dir->i_ino, name, namelen);
262
262
263
263
if (npages == 0 || namelen > UFS_MAXNAMLEN)
264
264
goto out;
···
434
434
435
435
if (IS_ERR(kaddr)) {
436
436
ufs_error(sb, __func__,
437
-
"bad page in #%lu",
437
+
"bad page in #%llu",
438
438
inode->i_ino);
439
439
ctx->pos += PAGE_SIZE - offset;
440
440
return PTR_ERR(kaddr);
+3
-3
fs/ufs/ialloc.c
+3
-3
fs/ufs/ialloc.c
···
63
63
int is_directory;
64
64
unsigned ino, cg, bit;
65
65
66
-
UFSD("ENTER, ino %lu\n", inode->i_ino);
66
+
UFSD("ENTER, ino %llu\n", inode->i_ino);
67
67
68
68
sb = inode->i_sb;
69
69
uspi = UFS_SB(sb)->s_uspi;
···
317
317
bh = sb_bread(sb, uspi->s_sbbase + ufs_inotofsba(inode->i_ino));
318
318
if (!bh) {
319
319
ufs_warning(sb, "ufs_read_inode",
320
-
"unable to read inode %lu\n",
320
+
"unable to read inode %llu\n",
321
321
inode->i_ino);
322
322
err = -EIO;
323
323
goto fail_remove_inode;
···
336
336
}
337
337
mutex_unlock(&sbi->s_lock);
338
338
339
-
UFSD("allocating inode %lu\n", inode->i_ino);
339
+
UFSD("allocating inode %llu\n", inode->i_ino);
340
340
UFSD("EXIT\n");
341
341
return inode;
342
342
+9
-9
fs/ufs/inode.c
+9
-9
fs/ufs/inode.c
···
400
400
401
401
mutex_lock(&UFS_I(inode)->truncate_mutex);
402
402
403
-
UFSD("ENTER, ino %lu, fragment %llu\n", inode->i_ino, (unsigned long long)fragment);
403
+
UFSD("ENTER, ino %llu, fragment %llu\n", inode->i_ino, (unsigned long long)fragment);
404
404
if (unlikely(!depth)) {
405
405
ufs_warning(sb, "ufs_get_block", "block > big");
406
406
err = -EIO;
···
595
595
struct super_block *sb = inode->i_sb;
596
596
umode_t mode;
597
597
598
-
UFSD("Reading ufs2 inode, ino %lu\n", inode->i_ino);
598
+
UFSD("Reading ufs2 inode, ino %llu\n", inode->i_ino);
599
599
/*
600
600
* Copy data to the in-core inode.
601
601
*/
···
662
662
663
663
bh = sb_bread(sb, uspi->s_sbbase + ufs_inotofsba(inode->i_ino));
664
664
if (!bh) {
665
-
ufs_warning(sb, "ufs_read_inode", "unable to read inode %lu\n",
665
+
ufs_warning(sb, "ufs_read_inode", "unable to read inode %llu\n",
666
666
inode->i_ino);
667
667
goto bad_inode;
668
668
}
···
793
793
struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
794
794
struct buffer_head * bh;
795
795
796
-
UFSD("ENTER, ino %lu\n", inode->i_ino);
796
+
UFSD("ENTER, ino %llu\n", inode->i_ino);
797
797
798
798
if (inode->i_ino < UFS_ROOTINO ||
799
799
inode->i_ino > (uspi->s_ncg * uspi->s_ipg)) {
800
-
ufs_warning (sb, "ufs_read_inode", "bad inode number (%lu)\n", inode->i_ino);
800
+
ufs_warning (sb, "ufs_read_inode", "bad inode number (%llu)\n", inode->i_ino);
801
801
return -1;
802
802
}
803
803
804
804
bh = sb_bread(sb, ufs_inotofsba(inode->i_ino));
805
805
if (!bh) {
806
-
ufs_warning (sb, "ufs_read_inode", "unable to read inode %lu\n", inode->i_ino);
806
+
ufs_warning (sb, "ufs_read_inode", "unable to read inode %llu\n", inode->i_ino);
807
807
return -1;
808
808
}
809
809
if (uspi->fs_magic == UFS2_MAGIC) {
···
891
891
unsigned int old_tail, new_tail;
892
892
struct to_free ctx = {.inode = inode};
893
893
894
-
UFSD("ENTER: ino %lu\n", inode->i_ino);
894
+
UFSD("ENTER: ino %llu\n", inode->i_ino);
895
895
896
896
new_frags = DIRECT_FRAGMENT;
897
897
// new_frags = first fragment past the new EOF
···
956
956
}
957
957
}
958
958
done:
959
-
UFSD("EXIT: ino %lu\n", inode->i_ino);
959
+
UFSD("EXIT: ino %llu\n", inode->i_ino);
960
960
}
961
961
962
962
static void free_full_branch(struct inode *inode, u64 ind_block, int depth)
···
1169
1169
{
1170
1170
int err = 0;
1171
1171
1172
-
UFSD("ENTER: ino %lu, i_size: %llu, old_i_size: %llu\n",
1172
+
UFSD("ENTER: ino %llu, i_size: %llu, old_i_size: %llu\n",
1173
1173
inode->i_ino, (unsigned long long)size,
1174
1174
(unsigned long long)i_size_read(inode));
1175
1175
+3
-3
fs/ufs/ufs_fs.h
+3
-3
fs/ufs/ufs_fs.h
···
226
226
* inode number to cylinder group number.
227
227
* inode number to file system block address.
228
228
*/
229
-
#define ufs_inotocg(x) ((x) / uspi->s_ipg)
230
-
#define ufs_inotocgoff(x) ((x) % uspi->s_ipg)
229
+
#define ufs_inotocg(x) ((unsigned int)(x) / uspi->s_ipg)
230
+
#define ufs_inotocgoff(x) ((unsigned int)(x) % uspi->s_ipg)
231
231
#define ufs_inotofsba(x) (((u64)ufs_cgimin(ufs_inotocg(x))) + ufs_inotocgoff(x) / uspi->s_inopf)
232
-
#define ufs_inotofsbo(x) ((x) % uspi->s_inopf)
232
+
#define ufs_inotofsbo(x) ((unsigned int)(x) % uspi->s_inopf)
233
233
234
234
/*
235
235
* Compute the cylinder and rotational position of a cyl block addr.
+1
-1
fs/ufs/util.c
+1
-1
fs/ufs/util.c
···
203
203
folio = read_mapping_folio(mapping, index, NULL);
204
204
205
205
if (IS_ERR(folio)) {
206
-
printk(KERN_ERR "ufs_change_blocknr: read_mapping_folio error: ino %lu, index: %lu\n",
206
+
printk(KERN_ERR "ufs_change_blocknr: read_mapping_folio error: ino %llu, index: %lu\n",
207
207
mapping->host->i_ino, index);
208
208
return folio;
209
209
}
+1
-1
fs/verity/init.c
+1
-1
fs/verity/init.c
+4
-4
fs/zonefs/super.c
+4
-4
fs/zonefs/super.c
···
297
297
*/
298
298
if (isize != data_size)
299
299
zonefs_warn(sb,
300
-
"inode %lu: invalid size %lld (should be %lld)\n",
300
+
"inode %llu: invalid size %lld (should be %lld)\n",
301
301
inode->i_ino, isize, data_size);
302
302
303
303
/*
···
308
308
*/
309
309
if ((z->z_flags & ZONEFS_ZONE_OFFLINE) ||
310
310
(sbi->s_mount_opts & ZONEFS_MNTOPT_ERRORS_ZOL)) {
311
-
zonefs_warn(sb, "inode %lu: read/write access disabled\n",
311
+
zonefs_warn(sb, "inode %llu: read/write access disabled\n",
312
312
inode->i_ino);
313
313
if (!(z->z_flags & ZONEFS_ZONE_OFFLINE))
314
314
z->z_flags |= ZONEFS_ZONE_OFFLINE;
···
316
316
data_size = 0;
317
317
} else if ((z->z_flags & ZONEFS_ZONE_READONLY) ||
318
318
(sbi->s_mount_opts & ZONEFS_MNTOPT_ERRORS_ZRO)) {
319
-
zonefs_warn(sb, "inode %lu: write access disabled\n",
319
+
zonefs_warn(sb, "inode %llu: write access disabled\n",
320
320
inode->i_ino);
321
321
if (!(z->z_flags & ZONEFS_ZONE_READONLY))
322
322
z->z_flags |= ZONEFS_ZONE_READONLY;
···
402
402
memalloc_noio_restore(noio_flag);
403
403
404
404
if (ret != 1) {
405
-
zonefs_err(sb, "Get inode %lu zone information failed %d\n",
405
+
zonefs_err(sb, "Get inode %llu zone information failed %d\n",
406
406
inode->i_ino, ret);
407
407
zonefs_warn(sb, "remounting filesystem read-only\n");
408
408
sb->s_flags |= SB_RDONLY;
+9
-9
fs/zonefs/trace.h
+9
-9
fs/zonefs/trace.h
···
25
25
TP_ARGS(sb, z, op),
26
26
TP_STRUCT__entry(
27
27
__field(dev_t, dev)
28
-
__field(ino_t, ino)
28
+
__field(u64, ino)
29
29
__field(enum req_op, op)
30
30
__field(sector_t, sector)
31
31
__field(sector_t, nr_sectors)
···
38
38
__entry->sector = z->z_sector;
39
39
__entry->nr_sectors = z->z_size >> SECTOR_SHIFT;
40
40
),
41
-
TP_printk("bdev=(%d,%d), ino=%lu op=%s, sector=%llu, nr_sectors=%llu",
42
-
show_dev(__entry->dev), (unsigned long)__entry->ino,
41
+
TP_printk("bdev=(%d,%d), ino=%llu op=%s, sector=%llu, nr_sectors=%llu",
42
+
show_dev(__entry->dev), __entry->ino,
43
43
blk_op_str(__entry->op), __entry->sector,
44
44
__entry->nr_sectors
45
45
)
···
50
50
TP_ARGS(inode, size, ret),
51
51
TP_STRUCT__entry(
52
52
__field(dev_t, dev)
53
-
__field(ino_t, ino)
53
+
__field(u64, ino)
54
54
__field(sector_t, sector)
55
55
__field(ssize_t, size)
56
56
__field(loff_t, wpoffset)
···
65
65
zonefs_inode_zone(inode)->z_wpoffset;
66
66
__entry->ret = ret;
67
67
),
68
-
TP_printk("bdev=(%d, %d), ino=%lu, sector=%llu, size=%zu, wpoffset=%llu, ret=%zu",
69
-
show_dev(__entry->dev), (unsigned long)__entry->ino,
68
+
TP_printk("bdev=(%d, %d), ino=%llu, sector=%llu, size=%zu, wpoffset=%llu, ret=%zu",
69
+
show_dev(__entry->dev), __entry->ino,
70
70
__entry->sector, __entry->size, __entry->wpoffset,
71
71
__entry->ret
72
72
)
···
77
77
TP_ARGS(inode, iomap),
78
78
TP_STRUCT__entry(
79
79
__field(dev_t, dev)
80
-
__field(ino_t, ino)
80
+
__field(u64, ino)
81
81
__field(u64, addr)
82
82
__field(loff_t, offset)
83
83
__field(u64, length)
···
89
89
__entry->offset = iomap->offset;
90
90
__entry->length = iomap->length;
91
91
),
92
-
TP_printk("bdev=(%d,%d), ino=%lu, addr=%llu, offset=%llu, length=%llu",
93
-
show_dev(__entry->dev), (unsigned long)__entry->ino,
92
+
TP_printk("bdev=(%d,%d), ino=%llu, addr=%llu, offset=%llu, length=%llu",
93
+
show_dev(__entry->dev), __entry->ino,
94
94
__entry->addr, __entry->offset, __entry->length
95
95
)
96
96
);
+1
-1
include/linux/audit.h
+1
-1
include/linux/audit.h
+43
-45
include/linux/fs.h
+43
-45
include/linux/fs.h
···
783
783
#endif
784
784
785
785
/* Stat data, not accessed from path walking */
786
-
unsigned long i_ino;
786
+
u64 i_ino;
787
787
/*
788
788
* Filesystems may only read i_nlink directly. They shall use the
789
789
* following functions for modification:
···
2912
2912
#include <linux/err.h>
2913
2913
2914
2914
/* needed for stackable file system support */
2915
-
extern loff_t default_llseek(struct file *file, loff_t offset, int whence);
2915
+
loff_t default_llseek(struct file *file, loff_t offset, int whence);
2916
2916
2917
-
extern loff_t vfs_llseek(struct file *file, loff_t offset, int whence);
2917
+
loff_t vfs_llseek(struct file *file, loff_t offset, int whence);
2918
2918
2919
-
extern int inode_init_always_gfp(struct super_block *, struct inode *, gfp_t);
2919
+
int inode_init_always_gfp(struct super_block *sb, struct inode *inode, gfp_t gfp);
2920
2920
static inline int inode_init_always(struct super_block *sb, struct inode *inode)
2921
2921
{
2922
2922
return inode_init_always_gfp(sb, inode, GFP_NOFS);
2923
2923
}
2924
2924
2925
-
extern void inode_init_once(struct inode *);
2926
-
extern void address_space_init_once(struct address_space *mapping);
2927
-
extern struct inode * igrab(struct inode *);
2928
-
extern ino_t iunique(struct super_block *, ino_t);
2929
-
extern int inode_needs_sync(struct inode *inode);
2930
-
extern int inode_just_drop(struct inode *inode);
2925
+
void inode_init_once(struct inode *inode);
2926
+
void address_space_init_once(struct address_space *mapping);
2927
+
struct inode *igrab(struct inode *inode);
2928
+
ino_t iunique(struct super_block *sb, ino_t max_reserved);
2929
+
int inode_needs_sync(struct inode *inode);
2930
+
int inode_just_drop(struct inode *inode);
2931
2931
static inline int inode_generic_drop(struct inode *inode)
2932
2932
{
2933
2933
return !inode->i_nlink || inode_unhashed(inode);
2934
2934
}
2935
-
extern void d_mark_dontcache(struct inode *inode);
2935
+
void d_mark_dontcache(struct inode *inode);
2936
2936
2937
-
extern struct inode *ilookup5_nowait(struct super_block *sb,
2938
-
unsigned long hashval, int (*test)(struct inode *, void *),
2939
-
void *data, bool *isnew);
2940
-
extern struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
2941
-
int (*test)(struct inode *, void *), void *data);
2942
-
extern struct inode *ilookup(struct super_block *sb, unsigned long ino);
2937
+
struct inode *ilookup5_nowait(struct super_block *sb, u64 hashval,
2938
+
int (*test)(struct inode *, void *), void *data,
2939
+
bool *isnew);
2940
+
struct inode *ilookup5(struct super_block *sb, u64 hashval,
2941
+
int (*test)(struct inode *, void *), void *data);
2942
+
struct inode *ilookup(struct super_block *sb, u64 ino);
2943
2943
2944
-
extern struct inode *inode_insert5(struct inode *inode, unsigned long hashval,
2945
-
int (*test)(struct inode *, void *),
2946
-
int (*set)(struct inode *, void *),
2947
-
void *data);
2948
-
struct inode *iget5_locked(struct super_block *, unsigned long,
2944
+
struct inode *inode_insert5(struct inode *inode, u64 hashval,
2945
+
int (*test)(struct inode *, void *),
2946
+
int (*set)(struct inode *, void *), void *data);
2947
+
struct inode *iget5_locked(struct super_block *sb, u64 hashval,
2949
2948
int (*test)(struct inode *, void *),
2950
-
int (*set)(struct inode *, void *), void *);
2951
-
struct inode *iget5_locked_rcu(struct super_block *, unsigned long,
2949
+
int (*set)(struct inode *, void *), void *data);
2950
+
struct inode *iget5_locked_rcu(struct super_block *sb, u64 hashval,
2952
2951
int (*test)(struct inode *, void *),
2953
-
int (*set)(struct inode *, void *), void *);
2954
-
extern struct inode * iget_locked(struct super_block *, unsigned long);
2955
-
extern struct inode *find_inode_nowait(struct super_block *,
2956
-
unsigned long,
2957
-
int (*match)(struct inode *,
2958
-
unsigned long, void *),
2959
-
void *data);
2960
-
extern struct inode *find_inode_rcu(struct super_block *, unsigned long,
2961
-
int (*)(struct inode *, void *), void *);
2962
-
extern struct inode *find_inode_by_ino_rcu(struct super_block *, unsigned long);
2963
-
extern int insert_inode_locked4(struct inode *, unsigned long, int (*test)(struct inode *, void *), void *);
2964
-
extern int insert_inode_locked(struct inode *);
2952
+
int (*set)(struct inode *, void *), void *data);
2953
+
struct inode *iget_locked(struct super_block *sb, u64 ino);
2954
+
struct inode *find_inode_nowait(struct super_block *sb, u64 hashval,
2955
+
int (*match)(struct inode *, u64, void *),
2956
+
void *data);
2957
+
struct inode *find_inode_rcu(struct super_block *sb, u64 hashval,
2958
+
int (*test)(struct inode *, void *), void *data);
2959
+
struct inode *find_inode_by_ino_rcu(struct super_block *sb, u64 ino);
2960
+
int insert_inode_locked4(struct inode *inode, u64 hashval,
2961
+
int (*test)(struct inode *, void *), void *data);
2962
+
int insert_inode_locked(struct inode *inode);
2965
2963
#ifdef CONFIG_DEBUG_LOCK_ALLOC
2966
-
extern void lockdep_annotate_inode_mutex_key(struct inode *inode);
2964
+
void lockdep_annotate_inode_mutex_key(struct inode *inode);
2967
2965
#else
2968
2966
static inline void lockdep_annotate_inode_mutex_key(struct inode *inode) { };
2969
2967
#endif
2970
-
extern void unlock_new_inode(struct inode *);
2971
-
extern void discard_new_inode(struct inode *);
2972
-
extern unsigned int get_next_ino(void);
2973
-
extern void evict_inodes(struct super_block *sb);
2968
+
void unlock_new_inode(struct inode *inode);
2969
+
void discard_new_inode(struct inode *inode);
2970
+
unsigned int get_next_ino(void);
2971
+
void evict_inodes(struct super_block *sb);
2974
2972
void dump_mapping(const struct address_space *);
2975
2973
2976
2974
/*
···
3013
3015
*/
3014
3016
#define alloc_inode_sb(_sb, _cache, _gfp) kmem_cache_alloc_lru(_cache, &_sb->s_inode_lru, _gfp)
3015
3017
3016
-
extern void __insert_inode_hash(struct inode *, unsigned long hashval);
3018
+
void __insert_inode_hash(struct inode *inode, u64 hashval);
3017
3019
static inline void insert_inode_hash(struct inode *inode)
3018
3020
{
3019
3021
__insert_inode_hash(inode, inode->i_ino);
3020
3022
}
3021
3023
3022
-
extern void __remove_inode_hash(struct inode *);
3024
+
void __remove_inode_hash(struct inode *inode);
3023
3025
static inline void remove_inode_hash(struct inode *inode)
3024
3026
{
3025
3027
if (!inode_unhashed(inode) && !hlist_fake(&inode->i_hash))
3026
3028
__remove_inode_hash(inode);
3027
3029
}
3028
3030
3029
-
extern void inode_sb_list_add(struct inode *inode);
3030
-
extern void inode_lru_list_add(struct inode *inode);
3031
+
void inode_sb_list_add(struct inode *inode);
3032
+
void inode_lru_list_add(struct inode *inode);
3031
3033
3032
3034
int generic_file_mmap(struct file *, struct vm_area_struct *);
3033
3035
int generic_file_mmap_prepare(struct vm_area_desc *desc);
+2
-2
include/net/sock.h
+2
-2
include/net/sock.h
···
537
537
rwlock_t sk_callback_lock;
538
538
u32 sk_ack_backlog;
539
539
u32 sk_max_ack_backlog;
540
-
unsigned long sk_ino;
540
+
u64 sk_ino;
541
541
spinlock_t sk_peer_lock;
542
542
int sk_bind_phc;
543
543
struct pid *sk_peer_pid;
···
2140
2140
write_unlock_bh(&sk->sk_callback_lock);
2141
2141
}
2142
2142
2143
-
static inline unsigned long sock_i_ino(const struct sock *sk)
2143
+
static inline u64 sock_i_ino(const struct sock *sk)
2144
2144
{
2145
2145
/* Paired with WRITE_ONCE() in sock_graft() and sock_orphan() */
2146
2146
return READ_ONCE(sk->sk_ino);
+9
-9
include/trace/events/cachefiles.h
+9
-9
include/trace/events/cachefiles.h
···
249
249
TP_ARGS(obj, dir, de),
250
250
251
251
TP_STRUCT__entry(
252
+
__field(u64, dino)
253
+
__field(u64, ino)
252
254
__field(unsigned int, obj)
253
255
__field(short, error)
254
-
__field(unsigned long, dino)
255
-
__field(unsigned long, ino)
256
256
),
257
257
258
258
TP_fast_assign(
···
263
263
__entry->error = IS_ERR(de) ? PTR_ERR(de) : 0;
264
264
),
265
265
266
-
TP_printk("o=%08x dB=%lx B=%lx e=%d",
266
+
TP_printk("o=%08x dB=%llx B=%llx e=%d",
267
267
__entry->obj, __entry->dino, __entry->ino, __entry->error)
268
268
);
269
269
···
578
578
579
579
/* Note that obj may be NULL */
580
580
TP_STRUCT__entry(
581
+
__field(u64, inode)
581
582
__field(unsigned int, obj)
582
-
__field(ino_t, inode)
583
583
),
584
584
585
585
TP_fast_assign(
···
587
587
__entry->inode = inode->i_ino;
588
588
),
589
589
590
-
TP_printk("o=%08x B=%lx",
590
+
TP_printk("o=%08x B=%llx",
591
591
__entry->obj, __entry->inode)
592
592
);
593
593
···
599
599
600
600
/* Note that obj may be NULL */
601
601
TP_STRUCT__entry(
602
+
__field(u64, inode)
602
603
__field(unsigned int, obj)
603
-
__field(ino_t, inode)
604
604
),
605
605
606
606
TP_fast_assign(
···
608
608
__entry->inode = inode->i_ino;
609
609
),
610
610
611
-
TP_printk("o=%08x B=%lx",
611
+
TP_printk("o=%08x B=%llx",
612
612
__entry->obj, __entry->inode)
613
613
);
614
614
···
620
620
621
621
/* Note that obj may be NULL */
622
622
TP_STRUCT__entry(
623
+
__field(u64, inode)
623
624
__field(unsigned int, obj)
624
-
__field(ino_t, inode)
625
625
),
626
626
627
627
TP_fast_assign(
···
629
629
__entry->inode = inode->i_ino;
630
630
),
631
631
632
-
TP_printk("o=%08x B=%lx",
632
+
TP_printk("o=%08x B=%llx",
633
633
__entry->obj, __entry->inode)
634
634
);
635
635
+275
-275
include/trace/events/ext4.h
+275
-275
include/trace/events/ext4.h
···
138
138
{ CR_ANY_FREE, "CR_ANY_FREE" })
139
139
140
140
TRACE_EVENT(ext4_other_inode_update_time,
141
-
TP_PROTO(struct inode *inode, ino_t orig_ino),
141
+
TP_PROTO(struct inode *inode, u64 orig_ino),
142
142
143
143
TP_ARGS(inode, orig_ino),
144
144
145
145
TP_STRUCT__entry(
146
+
__field( u64, ino )
147
+
__field( u64, orig_ino )
146
148
__field( dev_t, dev )
147
-
__field( ino_t, ino )
148
-
__field( ino_t, orig_ino )
149
149
__field( uid_t, uid )
150
150
__field( gid_t, gid )
151
151
__field( __u16, mode )
···
160
160
__entry->mode = inode->i_mode;
161
161
),
162
162
163
-
TP_printk("dev %d,%d orig_ino %lu ino %lu mode 0%o uid %u gid %u",
163
+
TP_printk("dev %d,%d orig_ino %llu ino %llu mode 0%o uid %u gid %u",
164
164
MAJOR(__entry->dev), MINOR(__entry->dev),
165
-
(unsigned long) __entry->orig_ino,
166
-
(unsigned long) __entry->ino, __entry->mode,
165
+
__entry->orig_ino,
166
+
__entry->ino, __entry->mode,
167
167
__entry->uid, __entry->gid)
168
168
);
169
169
···
173
173
TP_ARGS(inode),
174
174
175
175
TP_STRUCT__entry(
176
+
__field( u64, ino )
177
+
__field( __u64, blocks )
176
178
__field( dev_t, dev )
177
-
__field( ino_t, ino )
178
179
__field( uid_t, uid )
179
180
__field( gid_t, gid )
180
-
__field( __u64, blocks )
181
181
__field( __u16, mode )
182
182
),
183
183
···
190
190
__entry->mode = inode->i_mode;
191
191
),
192
192
193
-
TP_printk("dev %d,%d ino %lu mode 0%o uid %u gid %u blocks %llu",
193
+
TP_printk("dev %d,%d ino %llu mode 0%o uid %u gid %u blocks %llu",
194
194
MAJOR(__entry->dev), MINOR(__entry->dev),
195
-
(unsigned long) __entry->ino, __entry->mode,
195
+
__entry->ino, __entry->mode,
196
196
__entry->uid, __entry->gid, __entry->blocks)
197
197
);
198
198
···
202
202
TP_ARGS(dir, mode),
203
203
204
204
TP_STRUCT__entry(
205
+
__field( u64, dir )
205
206
__field( dev_t, dev )
206
-
__field( ino_t, dir )
207
207
__field( __u16, mode )
208
208
),
209
209
···
213
213
__entry->mode = mode;
214
214
),
215
215
216
-
TP_printk("dev %d,%d dir %lu mode 0%o",
216
+
TP_printk("dev %d,%d dir %llu mode 0%o",
217
217
MAJOR(__entry->dev), MINOR(__entry->dev),
218
-
(unsigned long) __entry->dir, __entry->mode)
218
+
__entry->dir, __entry->mode)
219
219
);
220
220
221
221
TRACE_EVENT(ext4_allocate_inode,
···
224
224
TP_ARGS(inode, dir, mode),
225
225
226
226
TP_STRUCT__entry(
227
+
__field( u64, ino )
228
+
__field( u64, dir )
227
229
__field( dev_t, dev )
228
-
__field( ino_t, ino )
229
-
__field( ino_t, dir )
230
230
__field( __u16, mode )
231
231
),
232
232
···
237
237
__entry->mode = mode;
238
238
),
239
239
240
-
TP_printk("dev %d,%d ino %lu dir %lu mode 0%o",
240
+
TP_printk("dev %d,%d ino %llu dir %llu mode 0%o",
241
241
MAJOR(__entry->dev), MINOR(__entry->dev),
242
-
(unsigned long) __entry->ino,
243
-
(unsigned long) __entry->dir, __entry->mode)
242
+
__entry->ino,
243
+
__entry->dir, __entry->mode)
244
244
);
245
245
246
246
TRACE_EVENT(ext4_evict_inode,
···
249
249
TP_ARGS(inode),
250
250
251
251
TP_STRUCT__entry(
252
+
__field( u64, ino )
252
253
__field( dev_t, dev )
253
-
__field( ino_t, ino )
254
254
__field( int, nlink )
255
255
),
256
256
···
260
260
__entry->nlink = inode->i_nlink;
261
261
),
262
262
263
-
TP_printk("dev %d,%d ino %lu nlink %d",
263
+
TP_printk("dev %d,%d ino %llu nlink %d",
264
264
MAJOR(__entry->dev), MINOR(__entry->dev),
265
-
(unsigned long) __entry->ino, __entry->nlink)
265
+
__entry->ino, __entry->nlink)
266
266
);
267
267
268
268
TRACE_EVENT(ext4_drop_inode,
···
271
271
TP_ARGS(inode, drop),
272
272
273
273
TP_STRUCT__entry(
274
+
__field( u64, ino )
274
275
__field( dev_t, dev )
275
-
__field( ino_t, ino )
276
276
__field( int, drop )
277
277
),
278
278
···
282
282
__entry->drop = drop;
283
283
),
284
284
285
-
TP_printk("dev %d,%d ino %lu drop %d",
285
+
TP_printk("dev %d,%d ino %llu drop %d",
286
286
MAJOR(__entry->dev), MINOR(__entry->dev),
287
-
(unsigned long) __entry->ino, __entry->drop)
287
+
__entry->ino, __entry->drop)
288
288
);
289
289
290
290
TRACE_EVENT(ext4_nfs_commit_metadata,
···
293
293
TP_ARGS(inode),
294
294
295
295
TP_STRUCT__entry(
296
+
__field( u64, ino )
296
297
__field( dev_t, dev )
297
-
__field( ino_t, ino )
298
298
),
299
299
300
300
TP_fast_assign(
···
302
302
__entry->ino = inode->i_ino;
303
303
),
304
304
305
-
TP_printk("dev %d,%d ino %lu",
305
+
TP_printk("dev %d,%d ino %llu",
306
306
MAJOR(__entry->dev), MINOR(__entry->dev),
307
-
(unsigned long) __entry->ino)
307
+
__entry->ino)
308
308
);
309
309
310
310
TRACE_EVENT(ext4_mark_inode_dirty,
···
313
313
TP_ARGS(inode, IP),
314
314
315
315
TP_STRUCT__entry(
316
-
__field( dev_t, dev )
317
-
__field( ino_t, ino )
316
+
__field( u64, ino )
318
317
__field(unsigned long, ip )
318
+
__field( dev_t, dev )
319
319
),
320
320
321
321
TP_fast_assign(
···
324
324
__entry->ip = IP;
325
325
),
326
326
327
-
TP_printk("dev %d,%d ino %lu caller %pS",
327
+
TP_printk("dev %d,%d ino %llu caller %pS",
328
328
MAJOR(__entry->dev), MINOR(__entry->dev),
329
-
(unsigned long) __entry->ino, (void *)__entry->ip)
329
+
__entry->ino, (void *)__entry->ip)
330
330
);
331
331
332
332
TRACE_EVENT(ext4_begin_ordered_truncate,
···
335
335
TP_ARGS(inode, new_size),
336
336
337
337
TP_STRUCT__entry(
338
-
__field( dev_t, dev )
339
-
__field( ino_t, ino )
338
+
__field( u64, ino )
340
339
__field( loff_t, new_size )
340
+
__field( dev_t, dev )
341
341
),
342
342
343
343
TP_fast_assign(
···
346
346
__entry->new_size = new_size;
347
347
),
348
348
349
-
TP_printk("dev %d,%d ino %lu new_size %lld",
349
+
TP_printk("dev %d,%d ino %llu new_size %lld",
350
350
MAJOR(__entry->dev), MINOR(__entry->dev),
351
-
(unsigned long) __entry->ino,
351
+
__entry->ino,
352
352
__entry->new_size)
353
353
);
354
354
···
359
359
TP_ARGS(inode, pos, len),
360
360
361
361
TP_STRUCT__entry(
362
-
__field( dev_t, dev )
363
-
__field( ino_t, ino )
362
+
__field( u64, ino )
364
363
__field( loff_t, pos )
364
+
__field( dev_t, dev )
365
365
__field( unsigned int, len )
366
366
),
367
367
···
372
372
__entry->len = len;
373
373
),
374
374
375
-
TP_printk("dev %d,%d ino %lu pos %lld len %u",
375
+
TP_printk("dev %d,%d ino %llu pos %lld len %u",
376
376
MAJOR(__entry->dev), MINOR(__entry->dev),
377
-
(unsigned long) __entry->ino,
377
+
__entry->ino,
378
378
__entry->pos, __entry->len)
379
379
);
380
380
···
399
399
TP_ARGS(inode, pos, len, copied),
400
400
401
401
TP_STRUCT__entry(
402
-
__field( dev_t, dev )
403
-
__field( ino_t, ino )
402
+
__field( u64, ino )
404
403
__field( loff_t, pos )
404
+
__field( dev_t, dev )
405
405
__field( unsigned int, len )
406
406
__field( unsigned int, copied )
407
407
),
···
414
414
__entry->copied = copied;
415
415
),
416
416
417
-
TP_printk("dev %d,%d ino %lu pos %lld len %u copied %u",
417
+
TP_printk("dev %d,%d ino %llu pos %lld len %u copied %u",
418
418
MAJOR(__entry->dev), MINOR(__entry->dev),
419
-
(unsigned long) __entry->ino,
419
+
__entry->ino,
420
420
__entry->pos, __entry->len, __entry->copied)
421
421
);
422
422
···
450
450
TP_ARGS(inode, wbc),
451
451
452
452
TP_STRUCT__entry(
453
-
__field( dev_t, dev )
454
-
__field( ino_t, ino )
455
-
__field( long, nr_to_write )
456
-
__field( long, pages_skipped )
453
+
__field( u64, ino )
457
454
__field( loff_t, range_start )
458
455
__field( loff_t, range_end )
456
+
__field( long, nr_to_write )
457
+
__field( long, pages_skipped )
459
458
__field( pgoff_t, writeback_index )
459
+
__field( dev_t, dev )
460
460
__field( int, sync_mode )
461
461
__field( char, for_kupdate )
462
462
__field( char, range_cyclic )
···
475
475
__entry->range_cyclic = wbc->range_cyclic;
476
476
),
477
477
478
-
TP_printk("dev %d,%d ino %lu nr_to_write %ld pages_skipped %ld "
478
+
TP_printk("dev %d,%d ino %llu nr_to_write %ld pages_skipped %ld "
479
479
"range_start %lld range_end %lld sync_mode %d "
480
480
"for_kupdate %d range_cyclic %d writeback_index %lu",
481
481
MAJOR(__entry->dev), MINOR(__entry->dev),
482
-
(unsigned long) __entry->ino, __entry->nr_to_write,
482
+
__entry->ino, __entry->nr_to_write,
483
483
__entry->pages_skipped, __entry->range_start,
484
484
__entry->range_end, __entry->sync_mode,
485
485
__entry->for_kupdate, __entry->range_cyclic,
···
493
493
TP_ARGS(inode, start_pos, next_pos, wbc),
494
494
495
495
TP_STRUCT__entry(
496
-
__field( dev_t, dev )
497
-
__field( ino_t, ino )
496
+
__field( u64, ino )
498
497
__field( loff_t, start_pos )
499
498
__field( loff_t, next_pos )
500
499
__field( long, nr_to_write )
500
+
__field( dev_t, dev )
501
501
__field( int, sync_mode )
502
502
),
503
503
···
510
510
__entry->sync_mode = wbc->sync_mode;
511
511
),
512
512
513
-
TP_printk("dev %d,%d ino %lu start_pos 0x%llx next_pos 0x%llx nr_to_write %ld sync_mode %d",
513
+
TP_printk("dev %d,%d ino %llu start_pos 0x%llx next_pos 0x%llx nr_to_write %ld sync_mode %d",
514
514
MAJOR(__entry->dev), MINOR(__entry->dev),
515
-
(unsigned long) __entry->ino, __entry->start_pos, __entry->next_pos,
515
+
__entry->ino, __entry->start_pos, __entry->next_pos,
516
516
__entry->nr_to_write, __entry->sync_mode)
517
517
);
518
518
···
523
523
TP_ARGS(inode, start_pos, next_pos, wbc, ret),
524
524
525
525
TP_STRUCT__entry(
526
-
__field( dev_t, dev )
527
-
__field( ino_t, ino )
526
+
__field( u64, ino )
528
527
__field( loff_t, start_pos )
529
528
__field( loff_t, next_pos )
530
529
__field( long, nr_to_write )
530
+
__field( dev_t, dev )
531
531
__field( int, ret )
532
532
),
533
533
···
540
540
__entry->ret = ret;
541
541
),
542
542
543
-
TP_printk("dev %d,%d ino %lu start_pos 0x%llx next_pos 0x%llx nr_to_write %ld ret %d",
543
+
TP_printk("dev %d,%d ino %llu start_pos 0x%llx next_pos 0x%llx nr_to_write %ld ret %d",
544
544
MAJOR(__entry->dev), MINOR(__entry->dev),
545
-
(unsigned long) __entry->ino, __entry->start_pos, __entry->next_pos,
545
+
__entry->ino, __entry->start_pos, __entry->next_pos,
546
546
__entry->nr_to_write, __entry->ret)
547
547
);
548
548
···
552
552
TP_ARGS(inode, map),
553
553
554
554
TP_STRUCT__entry(
555
-
__field( dev_t, dev )
556
-
__field( ino_t, ino )
555
+
__field( u64, ino )
557
556
__field( __u64, lblk )
557
+
__field( dev_t, dev )
558
558
__field( __u32, len )
559
559
__field( __u32, flags )
560
560
),
···
567
567
__entry->flags = map->m_flags;
568
568
),
569
569
570
-
TP_printk("dev %d,%d ino %lu lblk %llu len %u flags %s",
570
+
TP_printk("dev %d,%d ino %llu lblk %llu len %u flags %s",
571
571
MAJOR(__entry->dev), MINOR(__entry->dev),
572
-
(unsigned long) __entry->ino, __entry->lblk, __entry->len,
572
+
__entry->ino, __entry->lblk, __entry->len,
573
573
show_mflags(__entry->flags))
574
574
);
575
575
···
580
580
TP_ARGS(inode, wbc, ret, pages_written),
581
581
582
582
TP_STRUCT__entry(
583
-
__field( dev_t, dev )
584
-
__field( ino_t, ino )
585
-
__field( int, ret )
586
-
__field( int, pages_written )
583
+
__field( u64, ino )
587
584
__field( long, pages_skipped )
588
585
__field( pgoff_t, writeback_index )
586
+
__field( dev_t, dev )
587
+
__field( int, ret )
588
+
__field( int, pages_written )
589
589
__field( int, sync_mode )
590
590
),
591
591
···
599
599
__entry->sync_mode = wbc->sync_mode;
600
600
),
601
601
602
-
TP_printk("dev %d,%d ino %lu ret %d pages_written %d pages_skipped %ld "
602
+
TP_printk("dev %d,%d ino %llu ret %d pages_written %d pages_skipped %ld "
603
603
"sync_mode %d writeback_index %lu",
604
604
MAJOR(__entry->dev), MINOR(__entry->dev),
605
-
(unsigned long) __entry->ino, __entry->ret,
605
+
__entry->ino, __entry->ret,
606
606
__entry->pages_written, __entry->pages_skipped,
607
607
__entry->sync_mode,
608
608
(unsigned long) __entry->writeback_index)
···
614
614
TP_ARGS(inode, folio),
615
615
616
616
TP_STRUCT__entry(
617
-
__field( dev_t, dev )
618
-
__field( ino_t, ino )
617
+
__field( u64, ino )
619
618
__field( pgoff_t, index )
619
+
__field( dev_t, dev )
620
620
621
621
),
622
622
···
626
626
__entry->index = folio->index;
627
627
),
628
628
629
-
TP_printk("dev %d,%d ino %lu folio_index %lu",
629
+
TP_printk("dev %d,%d ino %llu folio_index %lu",
630
630
MAJOR(__entry->dev), MINOR(__entry->dev),
631
-
(unsigned long) __entry->ino,
631
+
__entry->ino,
632
632
(unsigned long) __entry->index)
633
633
);
634
634
···
652
652
TP_ARGS(folio, offset, length),
653
653
654
654
TP_STRUCT__entry(
655
-
__field( dev_t, dev )
656
-
__field( ino_t, ino )
655
+
__field( u64, ino )
657
656
__field( pgoff_t, index )
658
657
__field( size_t, offset )
659
658
__field( size_t, length )
659
+
__field( dev_t, dev )
660
660
),
661
661
662
662
TP_fast_assign(
···
667
667
__entry->length = length;
668
668
),
669
669
670
-
TP_printk("dev %d,%d ino %lu folio_index %lu offset %zu length %zu",
670
+
TP_printk("dev %d,%d ino %llu folio_index %lu offset %zu length %zu",
671
671
MAJOR(__entry->dev), MINOR(__entry->dev),
672
-
(unsigned long) __entry->ino,
672
+
__entry->ino,
673
673
(unsigned long) __entry->index,
674
674
__entry->offset, __entry->length)
675
675
);
···
717
717
TP_ARGS(ac, pa),
718
718
719
719
TP_STRUCT__entry(
720
-
__field( dev_t, dev )
721
-
__field( ino_t, ino )
720
+
__field( u64, ino )
722
721
__field( __u64, pa_pstart )
723
722
__field( __u64, pa_lstart )
723
+
__field( dev_t, dev )
724
724
__field( __u32, pa_len )
725
725
726
726
),
···
733
733
__entry->pa_len = pa->pa_len;
734
734
),
735
735
736
-
TP_printk("dev %d,%d ino %lu pstart %llu len %u lstart %llu",
736
+
TP_printk("dev %d,%d ino %llu pstart %llu len %u lstart %llu",
737
737
MAJOR(__entry->dev), MINOR(__entry->dev),
738
-
(unsigned long) __entry->ino,
738
+
__entry->ino,
739
739
__entry->pa_pstart, __entry->pa_len, __entry->pa_lstart)
740
740
);
741
741
···
762
762
TP_ARGS(pa, block, count),
763
763
764
764
TP_STRUCT__entry(
765
-
__field( dev_t, dev )
766
-
__field( ino_t, ino )
765
+
__field( u64, ino )
767
766
__field( __u64, block )
767
+
__field( dev_t, dev )
768
768
__field( __u32, count )
769
769
770
770
),
···
776
776
__entry->count = count;
777
777
),
778
778
779
-
TP_printk("dev %d,%d ino %lu block %llu count %u",
779
+
TP_printk("dev %d,%d ino %llu block %llu count %u",
780
780
MAJOR(__entry->dev), MINOR(__entry->dev),
781
-
(unsigned long) __entry->ino,
781
+
__entry->ino,
782
782
__entry->block, __entry->count)
783
783
);
784
784
···
811
811
TP_ARGS(inode, len),
812
812
813
813
TP_STRUCT__entry(
814
+
__field( u64, ino )
814
815
__field( dev_t, dev )
815
-
__field( ino_t, ino )
816
816
__field( unsigned int, len )
817
817
818
818
),
···
823
823
__entry->len = len;
824
824
),
825
825
826
-
TP_printk("dev %d,%d ino %lu len: %u",
826
+
TP_printk("dev %d,%d ino %llu len: %u",
827
827
MAJOR(__entry->dev), MINOR(__entry->dev),
828
-
(unsigned long) __entry->ino, __entry->len)
828
+
__entry->ino, __entry->len)
829
829
);
830
830
831
831
TRACE_EVENT(ext4_mb_discard_preallocations,
···
855
855
TP_ARGS(ar),
856
856
857
857
TP_STRUCT__entry(
858
+
__field( u64, ino )
859
+
__field( __u64, goal )
860
+
__field( __u64, pleft )
861
+
__field( __u64, pright )
858
862
__field( dev_t, dev )
859
-
__field( ino_t, ino )
860
863
__field( unsigned int, len )
861
864
__field( __u32, logical )
862
865
__field( __u32, lleft )
863
866
__field( __u32, lright )
864
-
__field( __u64, goal )
865
-
__field( __u64, pleft )
866
-
__field( __u64, pright )
867
867
__field( unsigned int, flags )
868
868
),
869
869
···
880
880
__entry->flags = ar->flags;
881
881
),
882
882
883
-
TP_printk("dev %d,%d ino %lu flags %s len %u lblk %u goal %llu "
883
+
TP_printk("dev %d,%d ino %llu flags %s len %u lblk %u goal %llu "
884
884
"lleft %u lright %u pleft %llu pright %llu ",
885
885
MAJOR(__entry->dev), MINOR(__entry->dev),
886
-
(unsigned long) __entry->ino, show_mballoc_flags(__entry->flags),
886
+
__entry->ino, show_mballoc_flags(__entry->flags),
887
887
__entry->len, __entry->logical, __entry->goal,
888
888
__entry->lleft, __entry->lright, __entry->pleft,
889
889
__entry->pright)
···
895
895
TP_ARGS(ar, block),
896
896
897
897
TP_STRUCT__entry(
898
-
__field( dev_t, dev )
899
-
__field( ino_t, ino )
898
+
__field( u64, ino )
900
899
__field( __u64, block )
900
+
__field( __u64, goal )
901
+
__field( __u64, pleft )
902
+
__field( __u64, pright )
903
+
__field( dev_t, dev )
901
904
__field( unsigned int, len )
902
905
__field( __u32, logical )
903
906
__field( __u32, lleft )
904
907
__field( __u32, lright )
905
-
__field( __u64, goal )
906
-
__field( __u64, pleft )
907
-
__field( __u64, pright )
908
908
__field( unsigned int, flags )
909
909
),
910
910
···
922
922
__entry->flags = ar->flags;
923
923
),
924
924
925
-
TP_printk("dev %d,%d ino %lu flags %s len %u block %llu lblk %u "
925
+
TP_printk("dev %d,%d ino %llu flags %s len %u block %llu lblk %u "
926
926
"goal %llu lleft %u lright %u pleft %llu pright %llu",
927
927
MAJOR(__entry->dev), MINOR(__entry->dev),
928
-
(unsigned long) __entry->ino, show_mballoc_flags(__entry->flags),
928
+
__entry->ino, show_mballoc_flags(__entry->flags),
929
929
__entry->len, __entry->block, __entry->logical,
930
930
__entry->goal, __entry->lleft, __entry->lright,
931
931
__entry->pleft, __entry->pright)
···
938
938
TP_ARGS(inode, block, count, flags),
939
939
940
940
TP_STRUCT__entry(
941
-
__field( dev_t, dev )
942
-
__field( ino_t, ino )
941
+
__field( u64, ino )
943
942
__field( __u64, block )
944
943
__field( unsigned long, count )
944
+
__field( dev_t, dev )
945
945
__field( int, flags )
946
946
__field( __u16, mode )
947
947
),
···
955
955
__entry->mode = inode->i_mode;
956
956
),
957
957
958
-
TP_printk("dev %d,%d ino %lu mode 0%o block %llu count %lu flags %s",
958
+
TP_printk("dev %d,%d ino %llu mode 0%o block %llu count %lu flags %s",
959
959
MAJOR(__entry->dev), MINOR(__entry->dev),
960
-
(unsigned long) __entry->ino,
960
+
__entry->ino,
961
961
__entry->mode, __entry->block, __entry->count,
962
962
show_free_flags(__entry->flags))
963
963
);
···
968
968
TP_ARGS(file, datasync),
969
969
970
970
TP_STRUCT__entry(
971
+
__field( u64, ino )
972
+
__field( u64, parent )
971
973
__field( dev_t, dev )
972
-
__field( ino_t, ino )
973
-
__field( ino_t, parent )
974
974
__field( int, datasync )
975
975
),
976
976
···
983
983
__entry->parent = d_inode(dentry->d_parent)->i_ino;
984
984
),
985
985
986
-
TP_printk("dev %d,%d ino %lu parent %lu datasync %d ",
986
+
TP_printk("dev %d,%d ino %llu parent %llu datasync %d ",
987
987
MAJOR(__entry->dev), MINOR(__entry->dev),
988
-
(unsigned long) __entry->ino,
989
-
(unsigned long) __entry->parent, __entry->datasync)
988
+
__entry->ino,
989
+
__entry->parent, __entry->datasync)
990
990
);
991
991
992
992
TRACE_EVENT(ext4_sync_file_exit,
···
995
995
TP_ARGS(inode, ret),
996
996
997
997
TP_STRUCT__entry(
998
+
__field( u64, ino )
998
999
__field( dev_t, dev )
999
-
__field( ino_t, ino )
1000
1000
__field( int, ret )
1001
1001
),
1002
1002
···
1006
1006
__entry->ret = ret;
1007
1007
),
1008
1008
1009
-
TP_printk("dev %d,%d ino %lu ret %d",
1009
+
TP_printk("dev %d,%d ino %llu ret %d",
1010
1010
MAJOR(__entry->dev), MINOR(__entry->dev),
1011
-
(unsigned long) __entry->ino,
1011
+
__entry->ino,
1012
1012
__entry->ret)
1013
1013
);
1014
1014
···
1039
1039
TP_ARGS(inode),
1040
1040
1041
1041
TP_STRUCT__entry(
1042
+
__field( u64, ino )
1042
1043
__field( dev_t, dev )
1043
-
__field( ino_t, ino )
1044
1044
__field( unsigned int, data_blocks )
1045
1045
),
1046
1046
···
1050
1050
__entry->data_blocks = EXT4_I(inode)->i_reserved_data_blocks;
1051
1051
),
1052
1052
1053
-
TP_printk("dev %d,%d ino %lu reserved_data_blocks %u",
1053
+
TP_printk("dev %d,%d ino %llu reserved_data_blocks %u",
1054
1054
MAJOR(__entry->dev), MINOR(__entry->dev),
1055
-
(unsigned long) __entry->ino,
1055
+
__entry->ino,
1056
1056
__entry->data_blocks)
1057
1057
);
1058
1058
···
1062
1062
TP_ARGS(ac),
1063
1063
1064
1064
TP_STRUCT__entry(
1065
+
__field( u64, ino )
1065
1066
__field( dev_t, dev )
1066
-
__field( ino_t, ino )
1067
1067
__field( __u32, orig_logical )
1068
1068
__field( int, orig_start )
1069
1069
__field( __u32, orig_group )
···
1107
1107
__entry->cr = ac->ac_criteria;
1108
1108
),
1109
1109
1110
-
TP_printk("dev %d,%d inode %lu orig %u/%d/%u@%u goal %u/%d/%u@%u "
1110
+
TP_printk("dev %d,%d inode %llu orig %u/%d/%u@%u goal %u/%d/%u@%u "
1111
1111
"result %u/%d/%u@%u blks %u grps %u cr %s flags %s "
1112
1112
"tail %u broken %u",
1113
1113
MAJOR(__entry->dev), MINOR(__entry->dev),
1114
-
(unsigned long) __entry->ino,
1114
+
__entry->ino,
1115
1115
__entry->orig_group, __entry->orig_start,
1116
1116
__entry->orig_len, __entry->orig_logical,
1117
1117
__entry->goal_group, __entry->goal_start,
···
1129
1129
TP_ARGS(ac),
1130
1130
1131
1131
TP_STRUCT__entry(
1132
+
__field( u64, ino )
1132
1133
__field( dev_t, dev )
1133
-
__field( ino_t, ino )
1134
1134
__field( __u32, orig_logical )
1135
1135
__field( int, orig_start )
1136
1136
__field( __u32, orig_group )
···
1154
1154
__entry->result_len = ac->ac_b_ex.fe_len;
1155
1155
),
1156
1156
1157
-
TP_printk("dev %d,%d inode %lu orig %u/%d/%u@%u result %u/%d/%u@%u",
1157
+
TP_printk("dev %d,%d inode %llu orig %u/%d/%u@%u result %u/%d/%u@%u",
1158
1158
MAJOR(__entry->dev), MINOR(__entry->dev),
1159
-
(unsigned long) __entry->ino,
1159
+
__entry->ino,
1160
1160
__entry->orig_group, __entry->orig_start,
1161
1161
__entry->orig_len, __entry->orig_logical,
1162
1162
__entry->result_group, __entry->result_start,
···
1173
1173
TP_ARGS(sb, inode, group, start, len),
1174
1174
1175
1175
TP_STRUCT__entry(
1176
+
__field( u64, ino )
1176
1177
__field( dev_t, dev )
1177
-
__field( ino_t, ino )
1178
1178
__field( int, result_start )
1179
1179
__field( __u32, result_group )
1180
1180
__field( int, result_len )
···
1188
1188
__entry->result_len = len;
1189
1189
),
1190
1190
1191
-
TP_printk("dev %d,%d inode %lu extent %u/%d/%d ",
1191
+
TP_printk("dev %d,%d inode %llu extent %u/%d/%d ",
1192
1192
MAJOR(__entry->dev), MINOR(__entry->dev),
1193
-
(unsigned long) __entry->ino,
1193
+
__entry->ino,
1194
1194
__entry->result_group, __entry->result_start,
1195
1195
__entry->result_len)
1196
1196
);
···
1223
1223
TP_ARGS(inode, is_metadata, block),
1224
1224
1225
1225
TP_STRUCT__entry(
1226
-
__field( dev_t, dev )
1227
-
__field( ino_t, ino )
1226
+
__field( u64, ino )
1228
1227
__field( __u64, block )
1228
+
__field( dev_t, dev )
1229
1229
__field( int, is_metadata )
1230
1230
__field( __u16, mode )
1231
1231
),
···
1238
1238
__entry->mode = inode->i_mode;
1239
1239
),
1240
1240
1241
-
TP_printk("dev %d,%d ino %lu mode 0%o is_metadata %d block %llu",
1241
+
TP_printk("dev %d,%d ino %llu mode 0%o is_metadata %d block %llu",
1242
1242
MAJOR(__entry->dev), MINOR(__entry->dev),
1243
-
(unsigned long) __entry->ino,
1243
+
__entry->ino,
1244
1244
__entry->mode, __entry->is_metadata, __entry->block)
1245
1245
);
1246
1246
···
1250
1250
TP_ARGS(inode, used_blocks, quota_claim),
1251
1251
1252
1252
TP_STRUCT__entry(
1253
-
__field( dev_t, dev )
1254
-
__field( ino_t, ino )
1253
+
__field( u64, ino )
1255
1254
__field( __u64, i_blocks )
1255
+
__field( dev_t, dev )
1256
1256
__field( int, used_blocks )
1257
1257
__field( int, reserved_data_blocks )
1258
1258
__field( int, quota_claim )
···
1270
1270
__entry->mode = inode->i_mode;
1271
1271
),
1272
1272
1273
-
TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu used_blocks %d "
1273
+
TP_printk("dev %d,%d ino %llu mode 0%o i_blocks %llu used_blocks %d "
1274
1274
"reserved_data_blocks %d quota_claim %d",
1275
1275
MAJOR(__entry->dev), MINOR(__entry->dev),
1276
-
(unsigned long) __entry->ino,
1276
+
__entry->ino,
1277
1277
__entry->mode, __entry->i_blocks,
1278
1278
__entry->used_blocks, __entry->reserved_data_blocks,
1279
1279
__entry->quota_claim)
···
1285
1285
TP_ARGS(inode, nr_resv),
1286
1286
1287
1287
TP_STRUCT__entry(
1288
-
__field( dev_t, dev )
1289
-
__field( ino_t, ino )
1288
+
__field( u64, ino )
1290
1289
__field( __u64, i_blocks )
1290
+
__field( dev_t, dev )
1291
1291
__field( int, reserve_blocks )
1292
1292
__field( int, reserved_data_blocks )
1293
1293
__field( __u16, mode )
···
1302
1302
__entry->mode = inode->i_mode;
1303
1303
),
1304
1304
1305
-
TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu reserve_blocks %d"
1305
+
TP_printk("dev %d,%d ino %llu mode 0%o i_blocks %llu reserve_blocks %d"
1306
1306
"reserved_data_blocks %d",
1307
1307
MAJOR(__entry->dev), MINOR(__entry->dev),
1308
-
(unsigned long) __entry->ino,
1308
+
__entry->ino,
1309
1309
__entry->mode, __entry->i_blocks,
1310
1310
__entry->reserve_blocks, __entry->reserved_data_blocks)
1311
1311
);
···
1316
1316
TP_ARGS(inode, freed_blocks),
1317
1317
1318
1318
TP_STRUCT__entry(
1319
-
__field( dev_t, dev )
1320
-
__field( ino_t, ino )
1319
+
__field( u64, ino )
1321
1320
__field( __u64, i_blocks )
1321
+
__field( dev_t, dev )
1322
1322
__field( int, freed_blocks )
1323
1323
__field( int, reserved_data_blocks )
1324
1324
__field( __u16, mode )
···
1333
1333
__entry->mode = inode->i_mode;
1334
1334
),
1335
1335
1336
-
TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu freed_blocks %d "
1336
+
TP_printk("dev %d,%d ino %llu mode 0%o i_blocks %llu freed_blocks %d "
1337
1337
"reserved_data_blocks %d",
1338
1338
MAJOR(__entry->dev), MINOR(__entry->dev),
1339
-
(unsigned long) __entry->ino,
1339
+
__entry->ino,
1340
1340
__entry->mode, __entry->i_blocks,
1341
1341
__entry->freed_blocks, __entry->reserved_data_blocks)
1342
1342
);
···
1412
1412
TP_ARGS(inode, offset, len, mode),
1413
1413
1414
1414
TP_STRUCT__entry(
1415
-
__field( dev_t, dev )
1416
-
__field( ino_t, ino )
1415
+
__field( u64, ino )
1417
1416
__field( loff_t, offset )
1418
1417
__field( loff_t, len )
1418
+
__field( dev_t, dev )
1419
1419
__field( int, mode )
1420
1420
),
1421
1421
···
1427
1427
__entry->mode = mode;
1428
1428
),
1429
1429
1430
-
TP_printk("dev %d,%d ino %lu offset %lld len %lld mode %s",
1430
+
TP_printk("dev %d,%d ino %llu offset %lld len %lld mode %s",
1431
1431
MAJOR(__entry->dev), MINOR(__entry->dev),
1432
-
(unsigned long) __entry->ino,
1432
+
__entry->ino,
1433
1433
__entry->offset, __entry->len,
1434
1434
show_falloc_mode(__entry->mode))
1435
1435
);
···
1462
1462
TP_ARGS(inode, offset, max_blocks, ret),
1463
1463
1464
1464
TP_STRUCT__entry(
1465
-
__field( dev_t, dev )
1466
-
__field( ino_t, ino )
1465
+
__field( u64, ino )
1467
1466
__field( loff_t, pos )
1467
+
__field( dev_t, dev )
1468
1468
__field( unsigned int, blocks )
1469
1469
__field( int, ret )
1470
1470
),
···
1477
1477
__entry->ret = ret;
1478
1478
),
1479
1479
1480
-
TP_printk("dev %d,%d ino %lu pos %lld blocks %u ret %d",
1480
+
TP_printk("dev %d,%d ino %llu pos %lld blocks %u ret %d",
1481
1481
MAJOR(__entry->dev), MINOR(__entry->dev),
1482
-
(unsigned long) __entry->ino,
1482
+
__entry->ino,
1483
1483
__entry->pos, __entry->blocks,
1484
1484
__entry->ret)
1485
1485
);
···
1490
1490
TP_ARGS(parent, dentry),
1491
1491
1492
1492
TP_STRUCT__entry(
1493
-
__field( dev_t, dev )
1494
-
__field( ino_t, ino )
1495
-
__field( ino_t, parent )
1493
+
__field( u64, ino )
1494
+
__field( u64, parent )
1496
1495
__field( loff_t, size )
1496
+
__field( dev_t, dev )
1497
1497
),
1498
1498
1499
1499
TP_fast_assign(
···
1503
1503
__entry->size = d_inode(dentry)->i_size;
1504
1504
),
1505
1505
1506
-
TP_printk("dev %d,%d ino %lu size %lld parent %lu",
1506
+
TP_printk("dev %d,%d ino %llu size %lld parent %llu",
1507
1507
MAJOR(__entry->dev), MINOR(__entry->dev),
1508
-
(unsigned long) __entry->ino, __entry->size,
1509
-
(unsigned long) __entry->parent)
1508
+
__entry->ino, __entry->size,
1509
+
__entry->parent)
1510
1510
);
1511
1511
1512
1512
TRACE_EVENT(ext4_unlink_exit,
···
1515
1515
TP_ARGS(dentry, ret),
1516
1516
1517
1517
TP_STRUCT__entry(
1518
+
__field( u64, ino )
1518
1519
__field( dev_t, dev )
1519
-
__field( ino_t, ino )
1520
1520
__field( int, ret )
1521
1521
),
1522
1522
···
1526
1526
__entry->ret = ret;
1527
1527
),
1528
1528
1529
-
TP_printk("dev %d,%d ino %lu ret %d",
1529
+
TP_printk("dev %d,%d ino %llu ret %d",
1530
1530
MAJOR(__entry->dev), MINOR(__entry->dev),
1531
-
(unsigned long) __entry->ino,
1531
+
__entry->ino,
1532
1532
__entry->ret)
1533
1533
);
1534
1534
···
1538
1538
TP_ARGS(inode),
1539
1539
1540
1540
TP_STRUCT__entry(
1541
-
__field( dev_t, dev )
1542
-
__field( ino_t, ino )
1541
+
__field( u64, ino )
1543
1542
__field( __u64, blocks )
1543
+
__field( dev_t, dev )
1544
1544
),
1545
1545
1546
1546
TP_fast_assign(
···
1549
1549
__entry->blocks = inode->i_blocks;
1550
1550
),
1551
1551
1552
-
TP_printk("dev %d,%d ino %lu blocks %llu",
1552
+
TP_printk("dev %d,%d ino %llu blocks %llu",
1553
1553
MAJOR(__entry->dev), MINOR(__entry->dev),
1554
-
(unsigned long) __entry->ino, __entry->blocks)
1554
+
__entry->ino, __entry->blocks)
1555
1555
);
1556
1556
1557
1557
DEFINE_EVENT(ext4__truncate, ext4_truncate_enter,
···
1576
1576
TP_ARGS(inode, map, ux),
1577
1577
1578
1578
TP_STRUCT__entry(
1579
+
__field( u64, ino )
1580
+
__field( ext4_fsblk_t, u_pblk )
1579
1581
__field( dev_t, dev )
1580
-
__field( ino_t, ino )
1581
1582
__field( ext4_lblk_t, m_lblk )
1582
1583
__field( unsigned, m_len )
1583
1584
__field( ext4_lblk_t, u_lblk )
1584
1585
__field( unsigned, u_len )
1585
-
__field( ext4_fsblk_t, u_pblk )
1586
1586
),
1587
1587
1588
1588
TP_fast_assign(
···
1595
1595
__entry->u_pblk = ext4_ext_pblock(ux);
1596
1596
),
1597
1597
1598
-
TP_printk("dev %d,%d ino %lu m_lblk %u m_len %u u_lblk %u u_len %u "
1598
+
TP_printk("dev %d,%d ino %llu m_lblk %u m_len %u u_lblk %u u_len %u "
1599
1599
"u_pblk %llu",
1600
1600
MAJOR(__entry->dev), MINOR(__entry->dev),
1601
-
(unsigned long) __entry->ino,
1601
+
__entry->ino,
1602
1602
__entry->m_lblk, __entry->m_len,
1603
1603
__entry->u_lblk, __entry->u_len, __entry->u_pblk)
1604
1604
);
···
1614
1614
TP_ARGS(inode, map, ux, ix),
1615
1615
1616
1616
TP_STRUCT__entry(
1617
+
__field( u64, ino )
1618
+
__field( ext4_fsblk_t, u_pblk )
1619
+
__field( ext4_fsblk_t, i_pblk )
1617
1620
__field( dev_t, dev )
1618
-
__field( ino_t, ino )
1619
1621
__field( ext4_lblk_t, m_lblk )
1620
1622
__field( unsigned, m_len )
1621
1623
__field( ext4_lblk_t, u_lblk )
1622
1624
__field( unsigned, u_len )
1623
-
__field( ext4_fsblk_t, u_pblk )
1624
1625
__field( ext4_lblk_t, i_lblk )
1625
1626
__field( unsigned, i_len )
1626
-
__field( ext4_fsblk_t, i_pblk )
1627
1627
),
1628
1628
1629
1629
TP_fast_assign(
···
1639
1639
__entry->i_pblk = ext4_ext_pblock(ix);
1640
1640
),
1641
1641
1642
-
TP_printk("dev %d,%d ino %lu m_lblk %u m_len %u "
1642
+
TP_printk("dev %d,%d ino %llu m_lblk %u m_len %u "
1643
1643
"u_lblk %u u_len %u u_pblk %llu "
1644
1644
"i_lblk %u i_len %u i_pblk %llu ",
1645
1645
MAJOR(__entry->dev), MINOR(__entry->dev),
1646
-
(unsigned long) __entry->ino,
1646
+
__entry->ino,
1647
1647
__entry->m_lblk, __entry->m_len,
1648
1648
__entry->u_lblk, __entry->u_len, __entry->u_pblk,
1649
1649
__entry->i_lblk, __entry->i_len, __entry->i_pblk)
···
1656
1656
TP_ARGS(inode, lblk, len, flags),
1657
1657
1658
1658
TP_STRUCT__entry(
1659
+
__field( u64, ino )
1659
1660
__field( dev_t, dev )
1660
-
__field( ino_t, ino )
1661
1661
__field( ext4_lblk_t, lblk )
1662
1662
__field( unsigned int, len )
1663
1663
__field( unsigned int, flags )
···
1671
1671
__entry->flags = flags;
1672
1672
),
1673
1673
1674
-
TP_printk("dev %d,%d ino %lu lblk %u len %u flags %s",
1674
+
TP_printk("dev %d,%d ino %llu lblk %u len %u flags %s",
1675
1675
MAJOR(__entry->dev), MINOR(__entry->dev),
1676
-
(unsigned long) __entry->ino,
1676
+
__entry->ino,
1677
1677
__entry->lblk, __entry->len, show_map_flags(__entry->flags))
1678
1678
);
1679
1679
···
1698
1698
TP_ARGS(inode, flags, map, ret),
1699
1699
1700
1700
TP_STRUCT__entry(
1701
-
__field( dev_t, dev )
1702
-
__field( ino_t, ino )
1703
-
__field( unsigned int, flags )
1701
+
__field( u64, ino )
1704
1702
__field( ext4_fsblk_t, pblk )
1703
+
__field( dev_t, dev )
1704
+
__field( unsigned int, flags )
1705
1705
__field( ext4_lblk_t, lblk )
1706
1706
__field( unsigned int, len )
1707
1707
__field( unsigned int, mflags )
···
1719
1719
__entry->ret = ret;
1720
1720
),
1721
1721
1722
-
TP_printk("dev %d,%d ino %lu flags %s lblk %u pblk %llu len %u "
1722
+
TP_printk("dev %d,%d ino %llu flags %s lblk %u pblk %llu len %u "
1723
1723
"mflags %s ret %d",
1724
1724
MAJOR(__entry->dev), MINOR(__entry->dev),
1725
-
(unsigned long) __entry->ino,
1725
+
__entry->ino,
1726
1726
show_map_flags(__entry->flags), __entry->lblk, __entry->pblk,
1727
1727
__entry->len, show_mflags(__entry->mflags), __entry->ret)
1728
1728
);
···
1747
1747
TP_ARGS(inode, lblk, pblk),
1748
1748
1749
1749
TP_STRUCT__entry(
1750
-
__field( dev_t, dev )
1751
-
__field( ino_t, ino )
1750
+
__field( u64, ino )
1752
1751
__field( ext4_fsblk_t, pblk )
1752
+
__field( dev_t, dev )
1753
1753
__field( ext4_lblk_t, lblk )
1754
1754
),
1755
1755
···
1760
1760
__entry->lblk = lblk;
1761
1761
),
1762
1762
1763
-
TP_printk("dev %d,%d ino %lu lblk %u pblk %llu",
1763
+
TP_printk("dev %d,%d ino %llu lblk %u pblk %llu",
1764
1764
MAJOR(__entry->dev), MINOR(__entry->dev),
1765
-
(unsigned long) __entry->ino,
1765
+
__entry->ino,
1766
1766
__entry->lblk, __entry->pblk)
1767
1767
);
1768
1768
···
1772
1772
TP_ARGS(sb, ino),
1773
1773
1774
1774
TP_STRUCT__entry(
1775
+
__field( u64, ino )
1775
1776
__field( dev_t, dev )
1776
-
__field( ino_t, ino )
1777
1777
),
1778
1778
1779
1779
TP_fast_assign(
···
1781
1781
__entry->ino = ino;
1782
1782
),
1783
1783
1784
-
TP_printk("dev %d,%d ino %ld",
1784
+
TP_printk("dev %d,%d ino %llu",
1785
1785
MAJOR(__entry->dev), MINOR(__entry->dev),
1786
-
(unsigned long) __entry->ino)
1786
+
__entry->ino)
1787
1787
);
1788
1788
1789
1789
TRACE_EVENT(ext4_journal_start_sb,
···
1823
1823
TP_ARGS(inode, blocks, rsv_blocks, revoke_creds, type, IP),
1824
1824
1825
1825
TP_STRUCT__entry(
1826
-
__field( unsigned long, ino )
1826
+
__field( u64, ino )
1827
1827
__field( dev_t, dev )
1828
1828
__field( unsigned long, ip )
1829
1829
__field( int, blocks )
···
1843
1843
),
1844
1844
1845
1845
TP_printk("dev %d,%d blocks %d, rsv_blocks %d, revoke_creds %d,"
1846
-
" type %d, ino %lu, caller %pS", MAJOR(__entry->dev),
1846
+
" type %d, ino %llu, caller %pS", MAJOR(__entry->dev),
1847
1847
MINOR(__entry->dev), __entry->blocks, __entry->rsv_blocks,
1848
-
__entry->revoke_creds, __entry->type, __entry->ino,
1849
-
(void *)__entry->ip)
1848
+
__entry->revoke_creds, __entry->type,
1849
+
__entry->ino, (void *)__entry->ip)
1850
1850
);
1851
1851
1852
1852
TRACE_EVENT(ext4_journal_start_reserved,
···
1927
1927
TP_ARGS(inode, map, flags, allocated, newblock),
1928
1928
1929
1929
TP_STRUCT__entry(
1930
+
__field( u64, ino )
1931
+
__field( ext4_fsblk_t, pblk )
1932
+
__field( ext4_fsblk_t, newblk )
1930
1933
__field( dev_t, dev )
1931
-
__field( ino_t, ino )
1932
1934
__field( int, flags )
1933
1935
__field( ext4_lblk_t, lblk )
1934
-
__field( ext4_fsblk_t, pblk )
1935
1936
__field( unsigned int, len )
1936
1937
__field( unsigned int, allocated )
1937
-
__field( ext4_fsblk_t, newblk )
1938
1938
),
1939
1939
1940
1940
TP_fast_assign(
···
1948
1948
__entry->newblk = newblock;
1949
1949
),
1950
1950
1951
-
TP_printk("dev %d,%d ino %lu m_lblk %u m_pblk %llu m_len %u flags %s "
1951
+
TP_printk("dev %d,%d ino %llu m_lblk %u m_pblk %llu m_len %u flags %s "
1952
1952
"allocated %d newblock %llu",
1953
1953
MAJOR(__entry->dev), MINOR(__entry->dev),
1954
-
(unsigned long) __entry->ino,
1954
+
__entry->ino,
1955
1955
(unsigned) __entry->lblk, (unsigned long long) __entry->pblk,
1956
1956
__entry->len, show_map_flags(__entry->flags),
1957
1957
(unsigned int) __entry->allocated,
···
1994
1994
TP_ARGS(inode, lblk, pblk, len),
1995
1995
1996
1996
TP_STRUCT__entry(
1997
-
__field( dev_t, dev )
1998
-
__field( ino_t, ino )
1997
+
__field( u64, ino )
1999
1998
__field( ext4_fsblk_t, pblk )
1999
+
__field( dev_t, dev )
2000
2000
__field( ext4_lblk_t, lblk )
2001
2001
__field( unsigned short, len )
2002
2002
),
···
2009
2009
__entry->len = len;
2010
2010
),
2011
2011
2012
-
TP_printk("dev %d,%d ino %lu lblk %u pblk %llu len %u",
2012
+
TP_printk("dev %d,%d ino %llu lblk %u pblk %llu len %u",
2013
2013
MAJOR(__entry->dev), MINOR(__entry->dev),
2014
-
(unsigned long) __entry->ino,
2014
+
__entry->ino,
2015
2015
(unsigned) __entry->lblk,
2016
2016
(unsigned long long) __entry->pblk,
2017
2017
(unsigned short) __entry->len)
···
2025
2025
TP_ARGS(inode, ex, from, to, pc),
2026
2026
2027
2027
TP_STRUCT__entry(
2028
+
__field( u64, ino )
2029
+
__field( ext4_fsblk_t, ee_pblk )
2030
+
__field( ext4_fsblk_t, pc_pclu )
2028
2031
__field( dev_t, dev )
2029
-
__field( ino_t, ino )
2030
2032
__field( ext4_lblk_t, from )
2031
2033
__field( ext4_lblk_t, to )
2032
-
__field( ext4_fsblk_t, ee_pblk )
2033
2034
__field( ext4_lblk_t, ee_lblk )
2034
2035
__field( unsigned short, ee_len )
2035
-
__field( ext4_fsblk_t, pc_pclu )
2036
2036
__field( ext4_lblk_t, pc_lblk )
2037
2037
__field( int, pc_state)
2038
2038
),
···
2050
2050
__entry->pc_state = pc->state;
2051
2051
),
2052
2052
2053
-
TP_printk("dev %d,%d ino %lu extent [%u(%llu), %u]"
2053
+
TP_printk("dev %d,%d ino %llu extent [%u(%llu), %u]"
2054
2054
"from %u to %u partial [pclu %lld lblk %u state %d]",
2055
2055
MAJOR(__entry->dev), MINOR(__entry->dev),
2056
-
(unsigned long) __entry->ino,
2056
+
__entry->ino,
2057
2057
(unsigned) __entry->ee_lblk,
2058
2058
(unsigned long long) __entry->ee_pblk,
2059
2059
(unsigned short) __entry->ee_len,
···
2072
2072
TP_ARGS(inode, start, ex, pc),
2073
2073
2074
2074
TP_STRUCT__entry(
2075
+
__field( u64, ino )
2076
+
__field( ext4_fsblk_t, ee_pblk )
2077
+
__field( ext4_fsblk_t, pc_pclu )
2075
2078
__field( dev_t, dev )
2076
-
__field( ino_t, ino )
2077
2079
__field( ext4_lblk_t, start )
2078
2080
__field( ext4_lblk_t, ee_lblk )
2079
-
__field( ext4_fsblk_t, ee_pblk )
2080
2081
__field( short, ee_len )
2081
-
__field( ext4_fsblk_t, pc_pclu )
2082
2082
__field( ext4_lblk_t, pc_lblk )
2083
2083
__field( int, pc_state)
2084
2084
),
···
2095
2095
__entry->pc_state = pc->state;
2096
2096
),
2097
2097
2098
-
TP_printk("dev %d,%d ino %lu start_lblk %u last_extent [%u(%llu), %u]"
2098
+
TP_printk("dev %d,%d ino %llu start_lblk %u last_extent [%u(%llu), %u]"
2099
2099
"partial [pclu %lld lblk %u state %d]",
2100
2100
MAJOR(__entry->dev), MINOR(__entry->dev),
2101
-
(unsigned long) __entry->ino,
2101
+
__entry->ino,
2102
2102
(unsigned) __entry->start,
2103
2103
(unsigned) __entry->ee_lblk,
2104
2104
(unsigned long long) __entry->ee_pblk,
···
2114
2114
TP_ARGS(inode, pblk),
2115
2115
2116
2116
TP_STRUCT__entry(
2117
-
__field( dev_t, dev )
2118
-
__field( ino_t, ino )
2117
+
__field( u64, ino )
2119
2118
__field( ext4_fsblk_t, pblk )
2119
+
__field( dev_t, dev )
2120
2120
),
2121
2121
2122
2122
TP_fast_assign(
···
2125
2125
__entry->pblk = pblk;
2126
2126
),
2127
2127
2128
-
TP_printk("dev %d,%d ino %lu index_pblk %llu",
2128
+
TP_printk("dev %d,%d ino %llu index_pblk %llu",
2129
2129
MAJOR(__entry->dev), MINOR(__entry->dev),
2130
-
(unsigned long) __entry->ino,
2130
+
__entry->ino,
2131
2131
(unsigned long long) __entry->pblk)
2132
2132
);
2133
2133
···
2138
2138
TP_ARGS(inode, start, end, depth),
2139
2139
2140
2140
TP_STRUCT__entry(
2141
+
__field( u64, ino )
2141
2142
__field( dev_t, dev )
2142
-
__field( ino_t, ino )
2143
2143
__field( ext4_lblk_t, start )
2144
2144
__field( ext4_lblk_t, end )
2145
2145
__field( int, depth )
···
2153
2153
__entry->depth = depth;
2154
2154
),
2155
2155
2156
-
TP_printk("dev %d,%d ino %lu since %u end %u depth %d",
2156
+
TP_printk("dev %d,%d ino %llu since %u end %u depth %d",
2157
2157
MAJOR(__entry->dev), MINOR(__entry->dev),
2158
-
(unsigned long) __entry->ino,
2158
+
__entry->ino,
2159
2159
(unsigned) __entry->start,
2160
2160
(unsigned) __entry->end,
2161
2161
__entry->depth)
···
2168
2168
TP_ARGS(inode, start, end, depth, pc, eh_entries),
2169
2169
2170
2170
TP_STRUCT__entry(
2171
+
__field( u64, ino )
2172
+
__field( ext4_fsblk_t, pc_pclu )
2171
2173
__field( dev_t, dev )
2172
-
__field( ino_t, ino )
2173
2174
__field( ext4_lblk_t, start )
2174
2175
__field( ext4_lblk_t, end )
2175
2176
__field( int, depth )
2176
-
__field( ext4_fsblk_t, pc_pclu )
2177
2177
__field( ext4_lblk_t, pc_lblk )
2178
2178
__field( int, pc_state )
2179
2179
__field( unsigned short, eh_entries )
···
2191
2191
__entry->eh_entries = le16_to_cpu(eh_entries);
2192
2192
),
2193
2193
2194
-
TP_printk("dev %d,%d ino %lu since %u end %u depth %d "
2194
+
TP_printk("dev %d,%d ino %llu since %u end %u depth %d "
2195
2195
"partial [pclu %lld lblk %u state %d] "
2196
2196
"remaining_entries %u",
2197
2197
MAJOR(__entry->dev), MINOR(__entry->dev),
2198
-
(unsigned long) __entry->ino,
2198
+
__entry->ino,
2199
2199
(unsigned) __entry->start,
2200
2200
(unsigned) __entry->end,
2201
2201
__entry->depth,
···
2211
2211
TP_ARGS(inode, es),
2212
2212
2213
2213
TP_STRUCT__entry(
2214
+
__field( u64, ino )
2215
+
__field( u64, seq )
2216
+
__field( ext4_fsblk_t, pblk )
2214
2217
__field( dev_t, dev )
2215
-
__field( ino_t, ino )
2216
2218
__field( ext4_lblk_t, lblk )
2217
2219
__field( ext4_lblk_t, len )
2218
-
__field( ext4_fsblk_t, pblk )
2219
2220
__field( char, status )
2220
-
__field( u64, seq )
2221
2221
),
2222
2222
2223
2223
TP_fast_assign(
···
2230
2230
__entry->seq = EXT4_I(inode)->i_es_seq;
2231
2231
),
2232
2232
2233
-
TP_printk("dev %d,%d ino %lu es [%u/%u) mapped %llu status %s seq %llu",
2233
+
TP_printk("dev %d,%d ino %llu es [%u/%u) mapped %llu status %s seq %llu",
2234
2234
MAJOR(__entry->dev), MINOR(__entry->dev),
2235
-
(unsigned long) __entry->ino,
2235
+
__entry->ino,
2236
2236
__entry->lblk, __entry->len,
2237
2237
__entry->pblk, show_extent_status(__entry->status),
2238
2238
__entry->seq)
···
2256
2256
TP_ARGS(inode, lblk, len),
2257
2257
2258
2258
TP_STRUCT__entry(
2259
-
__field( dev_t, dev )
2260
-
__field( ino_t, ino )
2259
+
__field( u64, ino )
2261
2260
__field( loff_t, lblk )
2262
2261
__field( loff_t, len )
2263
2262
__field( u64, seq )
2263
+
__field( dev_t, dev )
2264
2264
),
2265
2265
2266
2266
TP_fast_assign(
···
2271
2271
__entry->seq = EXT4_I(inode)->i_es_seq;
2272
2272
),
2273
2273
2274
-
TP_printk("dev %d,%d ino %lu es [%lld/%lld) seq %llu",
2274
+
TP_printk("dev %d,%d ino %llu es [%lld/%lld) seq %llu",
2275
2275
MAJOR(__entry->dev), MINOR(__entry->dev),
2276
-
(unsigned long) __entry->ino,
2276
+
__entry->ino,
2277
2277
__entry->lblk, __entry->len, __entry->seq)
2278
2278
);
2279
2279
···
2283
2283
TP_ARGS(inode, lblk),
2284
2284
2285
2285
TP_STRUCT__entry(
2286
+
__field( u64, ino )
2286
2287
__field( dev_t, dev )
2287
-
__field( ino_t, ino )
2288
2288
__field( ext4_lblk_t, lblk )
2289
2289
),
2290
2290
···
2294
2294
__entry->lblk = lblk;
2295
2295
),
2296
2296
2297
-
TP_printk("dev %d,%d ino %lu lblk %u",
2297
+
TP_printk("dev %d,%d ino %llu lblk %u",
2298
2298
MAJOR(__entry->dev), MINOR(__entry->dev),
2299
-
(unsigned long) __entry->ino, __entry->lblk)
2299
+
__entry->ino, __entry->lblk)
2300
2300
);
2301
2301
2302
2302
TRACE_EVENT(ext4_es_find_extent_range_exit,
···
2305
2305
TP_ARGS(inode, es),
2306
2306
2307
2307
TP_STRUCT__entry(
2308
+
__field( u64, ino )
2309
+
__field( ext4_fsblk_t, pblk )
2308
2310
__field( dev_t, dev )
2309
-
__field( ino_t, ino )
2310
2311
__field( ext4_lblk_t, lblk )
2311
2312
__field( ext4_lblk_t, len )
2312
-
__field( ext4_fsblk_t, pblk )
2313
2313
__field( char, status )
2314
2314
),
2315
2315
···
2322
2322
__entry->status = ext4_es_status(es);
2323
2323
),
2324
2324
2325
-
TP_printk("dev %d,%d ino %lu es [%u/%u) mapped %llu status %s",
2325
+
TP_printk("dev %d,%d ino %llu es [%u/%u) mapped %llu status %s",
2326
2326
MAJOR(__entry->dev), MINOR(__entry->dev),
2327
-
(unsigned long) __entry->ino,
2327
+
__entry->ino,
2328
2328
__entry->lblk, __entry->len,
2329
2329
__entry->pblk, show_extent_status(__entry->status))
2330
2330
);
···
2335
2335
TP_ARGS(inode, lblk),
2336
2336
2337
2337
TP_STRUCT__entry(
2338
+
__field( u64, ino )
2338
2339
__field( dev_t, dev )
2339
-
__field( ino_t, ino )
2340
2340
__field( ext4_lblk_t, lblk )
2341
2341
),
2342
2342
···
2346
2346
__entry->lblk = lblk;
2347
2347
),
2348
2348
2349
-
TP_printk("dev %d,%d ino %lu lblk %u",
2349
+
TP_printk("dev %d,%d ino %llu lblk %u",
2350
2350
MAJOR(__entry->dev), MINOR(__entry->dev),
2351
-
(unsigned long) __entry->ino, __entry->lblk)
2351
+
__entry->ino, __entry->lblk)
2352
2352
);
2353
2353
2354
2354
TRACE_EVENT(ext4_es_lookup_extent_exit,
···
2358
2358
TP_ARGS(inode, es, found),
2359
2359
2360
2360
TP_STRUCT__entry(
2361
+
__field( u64, ino )
2362
+
__field( ext4_fsblk_t, pblk )
2361
2363
__field( dev_t, dev )
2362
-
__field( ino_t, ino )
2363
2364
__field( ext4_lblk_t, lblk )
2364
2365
__field( ext4_lblk_t, len )
2365
-
__field( ext4_fsblk_t, pblk )
2366
-
__field( char, status )
2367
2366
__field( int, found )
2367
+
__field( char, status )
2368
2368
),
2369
2369
2370
2370
TP_fast_assign(
···
2377
2377
__entry->found = found;
2378
2378
),
2379
2379
2380
-
TP_printk("dev %d,%d ino %lu found %d [%u/%u) %llu %s",
2380
+
TP_printk("dev %d,%d ino %llu found %d [%u/%u) %llu %s",
2381
2381
MAJOR(__entry->dev), MINOR(__entry->dev),
2382
-
(unsigned long) __entry->ino, __entry->found,
2382
+
__entry->ino, __entry->found,
2383
2383
__entry->lblk, __entry->len,
2384
2384
__entry->found ? __entry->pblk : 0,
2385
2385
show_extent_status(__entry->found ? __entry->status : 0))
···
2447
2447
TP_ARGS(inode, offset, len),
2448
2448
2449
2449
TP_STRUCT__entry(
2450
-
__field(dev_t, dev)
2451
-
__field(ino_t, ino)
2450
+
__field(u64, ino)
2452
2451
__field(loff_t, offset)
2453
2452
__field(loff_t, len)
2453
+
__field(dev_t, dev)
2454
2454
),
2455
2455
2456
2456
TP_fast_assign(
···
2460
2460
__entry->len = len;
2461
2461
),
2462
2462
2463
-
TP_printk("dev %d,%d ino %lu offset %lld len %lld",
2463
+
TP_printk("dev %d,%d ino %llu offset %lld len %lld",
2464
2464
MAJOR(__entry->dev), MINOR(__entry->dev),
2465
-
(unsigned long) __entry->ino,
2465
+
__entry->ino,
2466
2466
__entry->offset, __entry->len)
2467
2467
);
2468
2468
···
2472
2472
TP_ARGS(inode, offset, len),
2473
2473
2474
2474
TP_STRUCT__entry(
2475
-
__field(dev_t, dev)
2476
-
__field(ino_t, ino)
2475
+
__field(u64, ino)
2477
2476
__field(loff_t, offset)
2478
2477
__field(loff_t, len)
2478
+
__field(dev_t, dev)
2479
2479
),
2480
2480
2481
2481
TP_fast_assign(
···
2485
2485
__entry->len = len;
2486
2486
),
2487
2487
2488
-
TP_printk("dev %d,%d ino %lu offset %lld len %lld",
2488
+
TP_printk("dev %d,%d ino %llu offset %lld len %lld",
2489
2489
MAJOR(__entry->dev), MINOR(__entry->dev),
2490
-
(unsigned long) __entry->ino,
2490
+
__entry->ino,
2491
2491
__entry->offset, __entry->len)
2492
2492
);
2493
2493
···
2526
2526
TP_ARGS(inode, es, lclu_allocated, end_allocated),
2527
2527
2528
2528
TP_STRUCT__entry(
2529
+
__field( u64, ino )
2530
+
__field( u64, seq )
2531
+
__field( ext4_fsblk_t, pblk )
2529
2532
__field( dev_t, dev )
2530
-
__field( ino_t, ino )
2531
2533
__field( ext4_lblk_t, lblk )
2532
2534
__field( ext4_lblk_t, len )
2533
-
__field( ext4_fsblk_t, pblk )
2534
2535
__field( char, status )
2535
2536
__field( bool, lclu_allocated )
2536
2537
__field( bool, end_allocated )
2537
-
__field( u64, seq )
2538
2538
),
2539
2539
2540
2540
TP_fast_assign(
···
2549
2549
__entry->seq = EXT4_I(inode)->i_es_seq;
2550
2550
),
2551
2551
2552
-
TP_printk("dev %d,%d ino %lu es [%u/%u) mapped %llu status %s allocated %d %d seq %llu",
2552
+
TP_printk("dev %d,%d ino %llu es [%u/%u) mapped %llu status %s allocated %d %d seq %llu",
2553
2553
MAJOR(__entry->dev), MINOR(__entry->dev),
2554
-
(unsigned long) __entry->ino,
2554
+
__entry->ino,
2555
2555
__entry->lblk, __entry->len,
2556
2556
__entry->pblk, show_extent_status(__entry->status),
2557
2557
__entry->lclu_allocated, __entry->end_allocated,
···
2875
2875
TP_ARGS(handle, inode, dentry, ret),
2876
2876
2877
2877
TP_STRUCT__entry(
2878
+
__field(u64, i_ino)
2878
2879
__field(dev_t, dev)
2879
2880
__field(tid_t, t_tid)
2880
-
__field(ino_t, i_ino)
2881
2881
__field(tid_t, i_sync_tid)
2882
2882
__field(int, error)
2883
2883
),
···
2892
2892
__entry->error = ret;
2893
2893
),
2894
2894
2895
-
TP_printk("dev %d,%d, t_tid %u, ino %lu, i_sync_tid %u, error %d",
2895
+
TP_printk("dev %d,%d, t_tid %u, ino %llu, i_sync_tid %u, error %d",
2896
2896
MAJOR(__entry->dev), MINOR(__entry->dev),
2897
2897
__entry->t_tid, __entry->i_ino, __entry->i_sync_tid,
2898
2898
__entry->error
···
2916
2916
TP_ARGS(handle, inode, ret),
2917
2917
2918
2918
TP_STRUCT__entry(
2919
+
__field(u64, i_ino)
2919
2920
__field(dev_t, dev)
2920
2921
__field(tid_t, t_tid)
2921
-
__field(ino_t, i_ino)
2922
2922
__field(tid_t, i_sync_tid)
2923
2923
__field(int, error)
2924
2924
),
···
2933
2933
__entry->error = ret;
2934
2934
),
2935
2935
2936
-
TP_printk("dev %d:%d, t_tid %u, inode %lu, i_sync_tid %u, error %d",
2936
+
TP_printk("dev %d:%d, t_tid %u, inode %llu, i_sync_tid %u, error %d",
2937
2937
MAJOR(__entry->dev), MINOR(__entry->dev),
2938
2938
__entry->t_tid, __entry->i_ino, __entry->i_sync_tid,
2939
2939
__entry->error)
···
2946
2946
TP_ARGS(handle, inode, start, end, ret),
2947
2947
2948
2948
TP_STRUCT__entry(
2949
-
__field(dev_t, dev)
2950
-
__field(tid_t, t_tid)
2951
-
__field(ino_t, i_ino)
2952
-
__field(tid_t, i_sync_tid)
2949
+
__field(u64, i_ino)
2953
2950
__field(long, start)
2954
2951
__field(long, end)
2952
+
__field(dev_t, dev)
2953
+
__field(tid_t, t_tid)
2954
+
__field(tid_t, i_sync_tid)
2955
2955
__field(int, error)
2956
2956
),
2957
2957
···
2967
2967
__entry->error = ret;
2968
2968
),
2969
2969
2970
-
TP_printk("dev %d:%d, t_tid %u, inode %lu, i_sync_tid %u, error %d, start %ld, end %ld",
2970
+
TP_printk("dev %d:%d, t_tid %u, inode %llu, i_sync_tid %u, error %d, start %ld, end %ld",
2971
2971
MAJOR(__entry->dev), MINOR(__entry->dev),
2972
2972
__entry->t_tid, __entry->i_ino, __entry->i_sync_tid,
2973
2973
__entry->error, __entry->start, __entry->end)
···
3029
3029
TP_ARGS(orig_inode, orig_map, donor_inode, donor_lblk),
3030
3030
3031
3031
TP_STRUCT__entry(
3032
+
__field(u64, orig_ino)
3033
+
__field(u64, donor_ino)
3032
3034
__field(dev_t, dev)
3033
-
__field(ino_t, orig_ino)
3034
3035
__field(ext4_lblk_t, orig_lblk)
3035
3036
__field(unsigned int, orig_flags)
3036
-
__field(ino_t, donor_ino)
3037
3037
__field(ext4_lblk_t, donor_lblk)
3038
3038
__field(unsigned int, len)
3039
3039
),
···
3048
3048
__entry->len = orig_map->m_len;
3049
3049
),
3050
3050
3051
-
TP_printk("dev %d,%d origin ino %lu lblk %u flags %s donor ino %lu lblk %u len %u",
3051
+
TP_printk("dev %d,%d origin ino %llu lblk %u flags %s donor ino %llu lblk %u len %u",
3052
3052
MAJOR(__entry->dev), MINOR(__entry->dev),
3053
-
(unsigned long) __entry->orig_ino, __entry->orig_lblk,
3053
+
__entry->orig_ino, __entry->orig_lblk,
3054
3054
show_mflags(__entry->orig_flags),
3055
-
(unsigned long) __entry->donor_ino, __entry->donor_lblk,
3055
+
__entry->donor_ino, __entry->donor_lblk,
3056
3056
__entry->len)
3057
3057
);
3058
3058
···
3065
3065
move_len, move_type, ret),
3066
3066
3067
3067
TP_STRUCT__entry(
3068
+
__field(u64, orig_ino)
3069
+
__field(u64, donor_ino)
3070
+
__field(u64, move_len)
3068
3071
__field(dev_t, dev)
3069
-
__field(ino_t, orig_ino)
3070
3072
__field(ext4_lblk_t, orig_lblk)
3071
-
__field(ino_t, donor_ino)
3072
3073
__field(ext4_lblk_t, donor_lblk)
3073
3074
__field(unsigned int, m_len)
3074
-
__field(u64, move_len)
3075
3075
__field(int, move_type)
3076
3076
__field(int, ret)
3077
3077
),
···
3088
3088
__entry->ret = ret;
3089
3089
),
3090
3090
3091
-
TP_printk("dev %d,%d origin ino %lu lblk %u donor ino %lu lblk %u m_len %u, move_len %llu type %d ret %d",
3091
+
TP_printk("dev %d,%d origin ino %llu lblk %u donor ino %llu lblk %u m_len %u, move_len %llu type %d ret %d",
3092
3092
MAJOR(__entry->dev), MINOR(__entry->dev),
3093
-
(unsigned long) __entry->orig_ino, __entry->orig_lblk,
3094
-
(unsigned long) __entry->donor_ino, __entry->donor_lblk,
3093
+
__entry->orig_ino, __entry->orig_lblk,
3094
+
__entry->donor_ino, __entry->donor_lblk,
3095
3095
__entry->m_len, __entry->move_len, __entry->move_type,
3096
3096
__entry->ret)
3097
3097
);
+124
-124
include/trace/events/f2fs.h
+124
-124
include/trace/events/f2fs.h
···
9
9
#include <uapi/linux/f2fs.h>
10
10
11
11
#define show_dev(dev) MAJOR(dev), MINOR(dev)
12
-
#define show_dev_ino(entry) show_dev(entry->dev), (unsigned long)entry->ino
12
+
#define show_dev_ino(entry) show_dev(entry->dev), (unsigned long long)entry->ino
13
13
14
14
TRACE_DEFINE_ENUM(NODE);
15
15
TRACE_DEFINE_ENUM(DATA);
···
206
206
TP_ARGS(inode),
207
207
208
208
TP_STRUCT__entry(
209
-
__field(dev_t, dev)
210
-
__field(ino_t, ino)
211
-
__field(ino_t, pino)
212
-
__field(umode_t, mode)
209
+
__field(u64, ino)
210
+
__field(u64, pino)
213
211
__field(loff_t, size)
214
-
__field(unsigned int, nlink)
215
212
__field(blkcnt_t, blocks)
213
+
__field(dev_t, dev)
214
+
__field(umode_t, mode)
215
+
__field(unsigned int, nlink)
216
216
__field(__u8, advise)
217
217
),
218
218
···
227
227
__entry->advise = F2FS_I(inode)->i_advise;
228
228
),
229
229
230
-
TP_printk("dev = (%d,%d), ino = %lu, pino = %lu, i_mode = 0x%hx, "
230
+
TP_printk("dev = (%d,%d), ino = %llu, pino = %llu, i_mode = 0x%hx, "
231
231
"i_size = %lld, i_nlink = %u, i_blocks = %llu, i_advise = 0x%x",
232
232
show_dev_ino(__entry),
233
-
(unsigned long)__entry->pino,
233
+
__entry->pino,
234
234
__entry->mode,
235
235
__entry->size,
236
236
(unsigned int)__entry->nlink,
···
245
245
TP_ARGS(inode, ret),
246
246
247
247
TP_STRUCT__entry(
248
+
__field(u64, ino)
248
249
__field(dev_t, dev)
249
-
__field(ino_t, ino)
250
250
__field(umode_t, mode)
251
251
__field(int, ret)
252
252
),
···
258
258
__entry->ret = ret;
259
259
),
260
260
261
-
TP_printk("dev = (%d,%d), ino = %lu, type: %s, mode = 0%o, ret = %d",
261
+
TP_printk("dev = (%d,%d), ino = %llu, type: %s, mode = 0%o, ret = %d",
262
262
show_dev_ino(__entry),
263
263
show_inode_type(__entry->mode & S_IFMT),
264
264
__entry->mode & S_ALL_PERM,
···
279
279
TP_ARGS(inode, cp_reason, datasync, ret),
280
280
281
281
TP_STRUCT__entry(
282
+
__field(u64, ino)
282
283
__field(dev_t, dev)
283
-
__field(ino_t, ino)
284
284
__field(int, cp_reason)
285
285
__field(int, datasync)
286
286
__field(int, ret)
···
294
294
__entry->ret = ret;
295
295
),
296
296
297
-
TP_printk("dev = (%d,%d), ino = %lu, cp_reason: %s, "
297
+
TP_printk("dev = (%d,%d), ino = %llu, cp_reason: %s, "
298
298
"datasync = %d, ret = %d",
299
299
show_dev_ino(__entry),
300
300
show_fsync_cpreason(__entry->cp_reason),
···
361
361
TP_ARGS(dir, dentry),
362
362
363
363
TP_STRUCT__entry(
364
-
__field(dev_t, dev)
365
-
__field(ino_t, ino)
364
+
__field(u64, ino)
366
365
__field(loff_t, size)
367
366
__field(blkcnt_t, blocks)
367
+
__field(dev_t, dev)
368
368
__string(name, dentry->d_name.name)
369
369
),
370
370
···
376
376
__assign_str(name);
377
377
),
378
378
379
-
TP_printk("dev = (%d,%d), dir ino = %lu, i_size = %lld, "
379
+
TP_printk("dev = (%d,%d), dir ino = %llu, i_size = %lld, "
380
380
"i_blocks = %llu, name = %s",
381
381
show_dev_ino(__entry),
382
382
__entry->size,
···
412
412
TP_ARGS(inode, nid, ofs, free),
413
413
414
414
TP_STRUCT__entry(
415
+
__field(u64, ino)
415
416
__field(dev_t, dev)
416
-
__field(ino_t, ino)
417
417
__field(nid_t, nid)
418
418
__field(unsigned int, ofs)
419
419
__field(int, free)
···
427
427
__entry->free = free;
428
428
),
429
429
430
-
TP_printk("dev = (%d,%d), ino = %lu, nid = %u, offset = %u, freed = %d",
430
+
TP_printk("dev = (%d,%d), ino = %llu, nid = %u, offset = %u, freed = %d",
431
431
show_dev_ino(__entry),
432
432
(unsigned int)__entry->nid,
433
433
__entry->ofs,
···
441
441
TP_ARGS(inode, from),
442
442
443
443
TP_STRUCT__entry(
444
-
__field(dev_t, dev)
445
-
__field(ino_t, ino)
444
+
__field(u64, ino)
446
445
__field(loff_t, size)
447
446
__field(blkcnt_t, blocks)
448
447
__field(u64, from)
448
+
__field(dev_t, dev)
449
449
),
450
450
451
451
TP_fast_assign(
···
456
456
__entry->from = from;
457
457
),
458
458
459
-
TP_printk("dev = (%d,%d), ino = %lu, i_size = %lld, i_blocks = %llu, "
459
+
TP_printk("dev = (%d,%d), ino = %llu, i_size = %lld, i_blocks = %llu, "
460
460
"start file offset = %llu",
461
461
show_dev_ino(__entry),
462
462
__entry->size,
···
499
499
TP_ARGS(inode, nid, blk_addr),
500
500
501
501
TP_STRUCT__entry(
502
+
__field(u64, ino)
502
503
__field(dev_t, dev)
503
-
__field(ino_t, ino)
504
504
__field(nid_t, nid)
505
505
__field(block_t, blk_addr)
506
506
),
···
512
512
__entry->blk_addr = blk_addr;
513
513
),
514
514
515
-
TP_printk("dev = (%d,%d), ino = %lu, nid = %u, block_address = 0x%llx",
515
+
TP_printk("dev = (%d,%d), ino = %llu, nid = %u, block_address = 0x%llx",
516
516
show_dev_ino(__entry),
517
517
(unsigned int)__entry->nid,
518
518
(unsigned long long)__entry->blk_addr)
···
546
546
TP_ARGS(inode, nid, depth, err),
547
547
548
548
TP_STRUCT__entry(
549
+
__field(u64, ino)
549
550
__field(dev_t, dev)
550
-
__field(ino_t, ino)
551
551
__array(nid_t, nid, 3)
552
552
__field(int, depth)
553
553
__field(int, err)
···
563
563
__entry->err = err;
564
564
),
565
565
566
-
TP_printk("dev = (%d,%d), ino = %lu, "
566
+
TP_printk("dev = (%d,%d), ino = %llu, "
567
567
"nid[0] = %u, nid[1] = %u, nid[2] = %u, depth = %d, err = %d",
568
568
show_dev_ino(__entry),
569
569
(unsigned int)__entry->nid[0],
···
581
581
TP_ARGS(inode, offset, length, ret),
582
582
583
583
TP_STRUCT__entry(
584
-
__field(dev_t, dev)
585
-
__field(ino_t, ino)
584
+
__field(u64, ino)
586
585
__field(loff_t, offset)
587
586
__field(size_t, length)
588
587
__field(ssize_t, ret)
588
+
__field(dev_t, dev)
589
589
),
590
590
591
591
TP_fast_assign(
···
596
596
__entry->ret = ret;
597
597
),
598
598
599
-
TP_printk("dev = (%d,%d), ino = %lu, "
599
+
TP_printk("dev = (%d,%d), ino = %llu, "
600
600
"offset = %lld, length = %zu, written(err) = %zd",
601
601
show_dev_ino(__entry),
602
602
__entry->offset,
···
611
611
TP_ARGS(inode, offset, len, advice),
612
612
613
613
TP_STRUCT__entry(
614
-
__field(dev_t, dev)
615
-
__field(ino_t, ino)
614
+
__field(u64, ino)
616
615
__field(loff_t, size)
617
616
__field(loff_t, offset)
618
617
__field(loff_t, len)
618
+
__field(dev_t, dev)
619
619
__field(int, advice)
620
620
),
621
621
···
628
628
__entry->advice = advice;
629
629
),
630
630
631
-
TP_printk("dev = (%d,%d), ino = %lu, i_size = %lld offset:%llu, len:%llu, advise:%d",
631
+
TP_printk("dev = (%d,%d), ino = %llu, i_size = %lld offset:%llu, len:%llu, advise:%d",
632
632
show_dev_ino(__entry),
633
633
(unsigned long long)__entry->size,
634
634
__entry->offset,
···
643
643
TP_ARGS(inode, map, flag, ret),
644
644
645
645
TP_STRUCT__entry(
646
+
__field(u64, ino)
646
647
__field(dev_t, dev)
647
-
__field(ino_t, ino)
648
648
__field(block_t, m_lblk)
649
649
__field(block_t, m_pblk)
650
650
__field(unsigned int, m_len)
···
670
670
__entry->ret = ret;
671
671
),
672
672
673
-
TP_printk("dev = (%d,%d), ino = %lu, file offset = %llu, "
673
+
TP_printk("dev = (%d,%d), ino = %llu, file offset = %llu, "
674
674
"start blkaddr = 0x%llx, len = 0x%llx, flags = %u, "
675
675
"seg_type = %d, may_create = %d, multidevice = %d, "
676
676
"flag = %d, err = %d",
···
885
885
TP_ARGS(dir, dentry, flags),
886
886
887
887
TP_STRUCT__entry(
888
+
__field(u64, ino)
888
889
__field(dev_t, dev)
889
-
__field(ino_t, ino)
890
890
__string(name, dentry->d_name.name)
891
891
__field(unsigned int, flags)
892
892
),
···
898
898
__entry->flags = flags;
899
899
),
900
900
901
-
TP_printk("dev = (%d,%d), pino = %lu, name:%s, flags:%u",
901
+
TP_printk("dev = (%d,%d), pino = %llu, name:%s, flags:%u",
902
902
show_dev_ino(__entry),
903
903
__get_str(name),
904
904
__entry->flags)
···
912
912
TP_ARGS(dir, dentry, ino, err),
913
913
914
914
TP_STRUCT__entry(
915
+
__field(u64, ino)
915
916
__field(dev_t, dev)
916
-
__field(ino_t, ino)
917
917
__string(name, dentry->d_name.name)
918
918
__field(nid_t, cino)
919
919
__field(int, err)
···
927
927
__entry->err = err;
928
928
),
929
929
930
-
TP_printk("dev = (%d,%d), pino = %lu, name:%s, ino:%u, err:%d",
930
+
TP_printk("dev = (%d,%d), pino = %llu, name:%s, ino:%u, err:%d",
931
931
show_dev_ino(__entry),
932
932
__get_str(name),
933
933
__entry->cino,
···
943
943
TP_ARGS(old_dir, old_dentry, new_dir, new_dentry, flags),
944
944
945
945
TP_STRUCT__entry(
946
+
__field(u64, ino)
947
+
__field(u64, new_pino)
946
948
__field(dev_t, dev)
947
-
__field(ino_t, ino)
948
949
__string(old_name, old_dentry->d_name.name)
949
-
__field(ino_t, new_pino)
950
950
__string(new_name, new_dentry->d_name.name)
951
951
__field(unsigned int, flags)
952
952
),
···
960
960
__entry->flags = flags;
961
961
),
962
962
963
-
TP_printk("dev = (%d,%d), old_dir = %lu, old_name: %s, "
964
-
"new_dir = %lu, new_name: %s, flags = %u",
963
+
TP_printk("dev = (%d,%d), old_dir = %llu, old_name: %s, "
964
+
"new_dir = %llu, new_name: %s, flags = %u",
965
965
show_dev_ino(__entry),
966
966
__get_str(old_name),
967
967
__entry->new_pino,
···
977
977
TP_ARGS(old_dentry, new_dentry, flags, ret),
978
978
979
979
TP_STRUCT__entry(
980
+
__field(u64, ino)
980
981
__field(dev_t, dev)
981
-
__field(ino_t, ino)
982
982
__string(old_name, old_dentry->d_name.name)
983
983
__string(new_name, new_dentry->d_name.name)
984
984
__field(unsigned int, flags)
···
994
994
__entry->ret = ret;
995
995
),
996
996
997
-
TP_printk("dev = (%d,%d), ino = %lu, old_name: %s, "
997
+
TP_printk("dev = (%d,%d), ino = %llu, old_name: %s, "
998
998
"new_name: %s, flags = %u, ret = %d",
999
999
show_dev_ino(__entry),
1000
1000
__get_str(old_name),
···
1010
1010
TP_ARGS(dir, start_pos, end_pos, err),
1011
1011
1012
1012
TP_STRUCT__entry(
1013
-
__field(dev_t, dev)
1014
-
__field(ino_t, ino)
1013
+
__field(u64, ino)
1015
1014
__field(loff_t, start)
1016
1015
__field(loff_t, end)
1016
+
__field(dev_t, dev)
1017
1017
__field(int, err)
1018
1018
),
1019
1019
···
1025
1025
__entry->err = err;
1026
1026
),
1027
1027
1028
-
TP_printk("dev = (%d,%d), ino = %lu, start_pos:%llu, end_pos:%llu, err:%d",
1028
+
TP_printk("dev = (%d,%d), ino = %llu, start_pos:%llu, end_pos:%llu, err:%d",
1029
1029
show_dev_ino(__entry),
1030
1030
__entry->start,
1031
1031
__entry->end,
···
1040
1040
TP_ARGS(inode, mode, offset, len, ret),
1041
1041
1042
1042
TP_STRUCT__entry(
1043
-
__field(dev_t, dev)
1044
-
__field(ino_t, ino)
1045
-
__field(int, mode)
1043
+
__field(u64, ino)
1046
1044
__field(loff_t, offset)
1047
1045
__field(loff_t, len)
1048
1046
__field(loff_t, size)
1049
1047
__field(blkcnt_t, blocks)
1048
+
__field(dev_t, dev)
1049
+
__field(int, mode)
1050
1050
__field(int, ret)
1051
1051
),
1052
1052
···
1061
1061
__entry->ret = ret;
1062
1062
),
1063
1063
1064
-
TP_printk("dev = (%d,%d), ino = %lu, mode = %x, offset = %lld, "
1064
+
TP_printk("dev = (%d,%d), ino = %llu, mode = %x, offset = %lld, "
1065
1065
"len = %lld, i_size = %lld, i_blocks = %llu, ret = %d",
1066
1066
show_dev_ino(__entry),
1067
1067
__entry->mode,
···
1079
1079
TP_ARGS(inode, iocb, len, rw),
1080
1080
1081
1081
TP_STRUCT__entry(
1082
-
__field(dev_t, dev)
1083
-
__field(ino_t, ino)
1082
+
__field(u64, ino)
1084
1083
__field(loff_t, ki_pos)
1084
+
__field(unsigned long, len)
1085
+
__field(dev_t, dev)
1085
1086
__field(int, ki_flags)
1086
1087
__field(u16, ki_ioprio)
1087
-
__field(unsigned long, len)
1088
1088
__field(int, rw)
1089
1089
),
1090
1090
···
1098
1098
__entry->rw = rw;
1099
1099
),
1100
1100
1101
-
TP_printk("dev = (%d,%d), ino = %lu pos = %lld len = %lu ki_flags = %x ki_ioprio = %x rw = %d",
1101
+
TP_printk("dev = (%d,%d), ino = %llu pos = %lld len = %lu ki_flags = %x ki_ioprio = %x rw = %d",
1102
1102
show_dev_ino(__entry),
1103
1103
__entry->ki_pos,
1104
1104
__entry->len,
···
1115
1115
TP_ARGS(inode, offset, len, rw, ret),
1116
1116
1117
1117
TP_STRUCT__entry(
1118
-
__field(dev_t, dev)
1119
-
__field(ino_t, ino)
1118
+
__field(u64, ino)
1120
1119
__field(loff_t, pos)
1121
1120
__field(unsigned long, len)
1121
+
__field(dev_t, dev)
1122
1122
__field(int, rw)
1123
1123
__field(int, ret)
1124
1124
),
···
1132
1132
__entry->ret = ret;
1133
1133
),
1134
1134
1135
-
TP_printk("dev = (%d,%d), ino = %lu pos = %lld len = %lu "
1135
+
TP_printk("dev = (%d,%d), ino = %llu pos = %lld len = %lu "
1136
1136
"rw = %d ret = %d",
1137
1137
show_dev_ino(__entry),
1138
1138
__entry->pos,
···
1176
1176
TP_ARGS(folio, fio),
1177
1177
1178
1178
TP_STRUCT__entry(
1179
-
__field(dev_t, dev)
1180
-
__field(ino_t, ino)
1179
+
__field(u64, ino)
1181
1180
__field(pgoff_t, index)
1181
+
__field(dev_t, dev)
1182
1182
__field(block_t, old_blkaddr)
1183
1183
__field(block_t, new_blkaddr)
1184
1184
__field(enum req_op, op)
···
1199
1199
__entry->type = fio->type;
1200
1200
),
1201
1201
1202
-
TP_printk("dev = (%d,%d), ino = %lu, folio_index = 0x%lx, "
1202
+
TP_printk("dev = (%d,%d), ino = %llu, folio_index = 0x%lx, "
1203
1203
"oldaddr = 0x%llx, newaddr = 0x%llx, rw = %s(%s), type = %s_%s",
1204
1204
show_dev_ino(__entry),
1205
1205
(unsigned long)__entry->index,
···
1306
1306
TP_ARGS(inode, pos, len),
1307
1307
1308
1308
TP_STRUCT__entry(
1309
-
__field(dev_t, dev)
1310
-
__field(ino_t, ino)
1309
+
__field(u64, ino)
1311
1310
__field(loff_t, pos)
1311
+
__field(dev_t, dev)
1312
1312
__field(unsigned int, len)
1313
1313
),
1314
1314
···
1319
1319
__entry->len = len;
1320
1320
),
1321
1321
1322
-
TP_printk("dev = (%d,%d), ino = %lu, pos = %llu, len = %u",
1322
+
TP_printk("dev = (%d,%d), ino = %llu, pos = %llu, len = %u",
1323
1323
show_dev_ino(__entry),
1324
1324
(unsigned long long)__entry->pos,
1325
1325
__entry->len)
···
1333
1333
TP_ARGS(inode, pos, len, copied),
1334
1334
1335
1335
TP_STRUCT__entry(
1336
-
__field(dev_t, dev)
1337
-
__field(ino_t, ino)
1336
+
__field(u64, ino)
1338
1337
__field(loff_t, pos)
1338
+
__field(dev_t, dev)
1339
1339
__field(unsigned int, len)
1340
1340
__field(unsigned int, copied)
1341
1341
),
···
1348
1348
__entry->copied = copied;
1349
1349
),
1350
1350
1351
-
TP_printk("dev = (%d,%d), ino = %lu, pos = %llu, len = %u, copied = %u",
1351
+
TP_printk("dev = (%d,%d), ino = %llu, pos = %llu, len = %u, copied = %u",
1352
1352
show_dev_ino(__entry),
1353
1353
(unsigned long long)__entry->pos,
1354
1354
__entry->len,
···
1362
1362
TP_ARGS(folio, type),
1363
1363
1364
1364
TP_STRUCT__entry(
1365
-
__field(dev_t, dev)
1366
-
__field(ino_t, ino)
1367
-
__field(int, type)
1368
-
__field(int, dir)
1365
+
__field(u64, ino)
1369
1366
__field(pgoff_t, index)
1370
1367
__field(pgoff_t, nrpages)
1368
+
__field(dev_t, dev)
1369
+
__field(int, type)
1370
+
__field(int, dir)
1371
1371
__field(int, dirty)
1372
1372
__field(int, uptodate)
1373
1373
),
···
1383
1383
__entry->uptodate = folio_test_uptodate(folio);
1384
1384
),
1385
1385
1386
-
TP_printk("dev = (%d,%d), ino = %lu, %s, %s, index = %lu, nr_pages = %lu, "
1386
+
TP_printk("dev = (%d,%d), ino = %llu, %s, %s, index = %lu, nr_pages = %lu, "
1387
1387
"dirty = %d, uptodate = %d",
1388
1388
show_dev_ino(__entry),
1389
1389
show_block_type(__entry->type),
···
1437
1437
TP_ARGS(inode, cow_inode, index, old_addr, new_addr, recovery),
1438
1438
1439
1439
TP_STRUCT__entry(
1440
-
__field(dev_t, dev)
1441
-
__field(ino_t, ino)
1442
-
__field(ino_t, cow_ino)
1440
+
__field(u64, ino)
1441
+
__field(u64, cow_ino)
1443
1442
__field(pgoff_t, index)
1443
+
__field(dev_t, dev)
1444
1444
__field(block_t, old_addr)
1445
1445
__field(block_t, new_addr)
1446
1446
__field(bool, recovery)
···
1456
1456
__entry->recovery = recovery;
1457
1457
),
1458
1458
1459
-
TP_printk("dev = (%d,%d), ino = %lu, cow_ino = %lu, index = %lu, "
1459
+
TP_printk("dev = (%d,%d), ino = %llu, cow_ino = %llu, index = %lu, "
1460
1460
"old_addr = 0x%llx, new_addr = 0x%llx, recovery = %d",
1461
1461
show_dev_ino(__entry),
1462
1462
__entry->cow_ino,
···
1474
1474
TP_ARGS(inode, index, flags, ret),
1475
1475
1476
1476
TP_STRUCT__entry(
1477
-
__field(dev_t, dev)
1478
-
__field(ino_t, ino)
1477
+
__field(u64, ino)
1479
1478
__field(pgoff_t, index)
1480
1479
__field(vm_flags_t, flags)
1480
+
__field(dev_t, dev)
1481
1481
__field(vm_fault_t, ret)
1482
1482
),
1483
1483
···
1489
1489
__entry->ret = ret;
1490
1490
),
1491
1491
1492
-
TP_printk("dev = (%d,%d), ino = %lu, index = %lu, flags: %s, ret: %s",
1492
+
TP_printk("dev = (%d,%d), ino = %llu, index = %lu, flags: %s, ret: %s",
1493
1493
show_dev_ino(__entry),
1494
1494
(unsigned long)__entry->index,
1495
1495
__print_flags(__entry->flags, "|", FAULT_FLAG_TRACE),
···
1519
1519
TP_ARGS(inode, wbc, type),
1520
1520
1521
1521
TP_STRUCT__entry(
1522
-
__field(dev_t, dev)
1523
-
__field(ino_t, ino)
1524
-
__field(int, type)
1525
-
__field(int, dir)
1526
-
__field(long, nr_to_write)
1527
-
__field(long, pages_skipped)
1522
+
__field(u64, ino)
1528
1523
__field(loff_t, range_start)
1529
1524
__field(loff_t, range_end)
1525
+
__field(long, nr_to_write)
1526
+
__field(long, pages_skipped)
1530
1527
__field(pgoff_t, writeback_index)
1528
+
__field(dev_t, dev)
1529
+
__field(int, type)
1530
+
__field(int, dir)
1531
1531
__field(int, sync_mode)
1532
1532
__field(char, for_kupdate)
1533
1533
__field(char, for_background)
···
1554
1554
__entry->for_sync = wbc->for_sync;
1555
1555
),
1556
1556
1557
-
TP_printk("dev = (%d,%d), ino = %lu, %s, %s, nr_to_write %ld, "
1557
+
TP_printk("dev = (%d,%d), ino = %llu, %s, %s, nr_to_write %ld, "
1558
1558
"skipped %ld, start %lld, end %lld, wb_idx %lu, sync_mode %d, "
1559
1559
"kupdate %u background %u tagged %u cyclic %u sync %u",
1560
1560
show_dev_ino(__entry),
···
1580
1580
TP_ARGS(inode, start, nrpage),
1581
1581
1582
1582
TP_STRUCT__entry(
1583
-
__field(dev_t, dev)
1584
-
__field(ino_t, ino)
1583
+
__field(u64, ino)
1585
1584
__field(pgoff_t, start)
1585
+
__field(dev_t, dev)
1586
1586
__field(unsigned int, nrpage)
1587
1587
),
1588
1588
···
1593
1593
__entry->nrpage = nrpage;
1594
1594
),
1595
1595
1596
-
TP_printk("dev = (%d,%d), ino = %lu, start = %lu nrpage = %u",
1596
+
TP_printk("dev = (%d,%d), ino = %llu, start = %lu nrpage = %u",
1597
1597
show_dev_ino(__entry),
1598
1598
(unsigned long)__entry->start,
1599
1599
__entry->nrpage)
···
1738
1738
TP_ARGS(inode, pgofs, type),
1739
1739
1740
1740
TP_STRUCT__entry(
1741
+
__field(u64, ino)
1741
1742
__field(dev_t, dev)
1742
-
__field(ino_t, ino)
1743
1743
__field(unsigned int, pgofs)
1744
1744
__field(enum extent_type, type)
1745
1745
),
···
1751
1751
__entry->type = type;
1752
1752
),
1753
1753
1754
-
TP_printk("dev = (%d,%d), ino = %lu, pgofs = %u, type = %s",
1754
+
TP_printk("dev = (%d,%d), ino = %llu, pgofs = %u, type = %s",
1755
1755
show_dev_ino(__entry),
1756
1756
__entry->pgofs,
1757
1757
show_extent_type(__entry->type))
···
1767
1767
TP_CONDITION(ei),
1768
1768
1769
1769
TP_STRUCT__entry(
1770
+
__field(u64, ino)
1770
1771
__field(dev_t, dev)
1771
-
__field(ino_t, ino)
1772
1772
__field(unsigned int, pgofs)
1773
1773
__field(unsigned int, fofs)
1774
1774
__field(unsigned int, len)
···
1784
1784
__entry->blk = ei->blk;
1785
1785
),
1786
1786
1787
-
TP_printk("dev = (%d,%d), ino = %lu, pgofs = %u, "
1787
+
TP_printk("dev = (%d,%d), ino = %llu, pgofs = %u, "
1788
1788
"read_ext_info(fofs: %u, len: %u, blk: %u)",
1789
1789
show_dev_ino(__entry),
1790
1790
__entry->pgofs,
···
1803
1803
TP_CONDITION(ei),
1804
1804
1805
1805
TP_STRUCT__entry(
1806
+
__field(u64, ino)
1807
+
__field(unsigned long long, age)
1808
+
__field(unsigned long long, blocks)
1806
1809
__field(dev_t, dev)
1807
-
__field(ino_t, ino)
1808
1810
__field(unsigned int, pgofs)
1809
1811
__field(unsigned int, fofs)
1810
1812
__field(unsigned int, len)
1811
-
__field(unsigned long long, age)
1812
-
__field(unsigned long long, blocks)
1813
1813
),
1814
1814
1815
1815
TP_fast_assign(
···
1822
1822
__entry->blocks = ei->last_blocks;
1823
1823
),
1824
1824
1825
-
TP_printk("dev = (%d,%d), ino = %lu, pgofs = %u, "
1825
+
TP_printk("dev = (%d,%d), ino = %llu, pgofs = %u, "
1826
1826
"age_ext_info(fofs: %u, len: %u, age: %llu, blocks: %llu)",
1827
1827
show_dev_ino(__entry),
1828
1828
__entry->pgofs,
···
1841
1841
TP_ARGS(inode, pgofs, len, blkaddr, c_len),
1842
1842
1843
1843
TP_STRUCT__entry(
1844
+
__field(u64, ino)
1844
1845
__field(dev_t, dev)
1845
-
__field(ino_t, ino)
1846
1846
__field(unsigned int, pgofs)
1847
1847
__field(u32, blk)
1848
1848
__field(unsigned int, len)
···
1858
1858
__entry->c_len = c_len;
1859
1859
),
1860
1860
1861
-
TP_printk("dev = (%d,%d), ino = %lu, pgofs = %u, "
1861
+
TP_printk("dev = (%d,%d), ino = %llu, pgofs = %u, "
1862
1862
"len = %u, blkaddr = %u, c_len = %u",
1863
1863
show_dev_ino(__entry),
1864
1864
__entry->pgofs,
···
1876
1876
TP_ARGS(inode, pgofs, len, age, last_blks),
1877
1877
1878
1878
TP_STRUCT__entry(
1879
-
__field(dev_t, dev)
1880
-
__field(ino_t, ino)
1881
-
__field(unsigned int, pgofs)
1882
-
__field(unsigned int, len)
1879
+
__field(u64, ino)
1883
1880
__field(unsigned long long, age)
1884
1881
__field(unsigned long long, blocks)
1882
+
__field(dev_t, dev)
1883
+
__field(unsigned int, pgofs)
1884
+
__field(unsigned int, len)
1885
1885
),
1886
1886
1887
1887
TP_fast_assign(
···
1893
1893
__entry->blocks = last_blks;
1894
1894
),
1895
1895
1896
-
TP_printk("dev = (%d,%d), ino = %lu, pgofs = %u, "
1896
+
TP_printk("dev = (%d,%d), ino = %llu, pgofs = %u, "
1897
1897
"len = %u, age = %llu, blocks = %llu",
1898
1898
show_dev_ino(__entry),
1899
1899
__entry->pgofs,
···
1938
1938
TP_ARGS(inode, node_cnt, type),
1939
1939
1940
1940
TP_STRUCT__entry(
1941
+
__field(u64, ino)
1941
1942
__field(dev_t, dev)
1942
-
__field(ino_t, ino)
1943
1943
__field(unsigned int, node_cnt)
1944
1944
__field(enum extent_type, type)
1945
1945
),
···
1951
1951
__entry->type = type;
1952
1952
),
1953
1953
1954
-
TP_printk("dev = (%d,%d), ino = %lu, destroyed: node_cnt = %u, type = %s",
1954
+
TP_printk("dev = (%d,%d), ino = %llu, destroyed: node_cnt = %u, type = %s",
1955
1955
show_dev_ino(__entry),
1956
1956
__entry->node_cnt,
1957
1957
show_extent_type(__entry->type))
···
2027
2027
TP_ARGS(inode, cluster_idx, cluster_size, algtype),
2028
2028
2029
2029
TP_STRUCT__entry(
2030
-
__field(dev_t, dev)
2031
-
__field(ino_t, ino)
2030
+
__field(u64, ino)
2032
2031
__field(pgoff_t, idx)
2032
+
__field(dev_t, dev)
2033
2033
__field(unsigned int, size)
2034
2034
__field(unsigned int, algtype)
2035
2035
),
···
2042
2042
__entry->algtype = algtype;
2043
2043
),
2044
2044
2045
-
TP_printk("dev = (%d,%d), ino = %lu, cluster_idx:%lu, "
2045
+
TP_printk("dev = (%d,%d), ino = %llu, cluster_idx:%lu, "
2046
2046
"cluster_size = %u, algorithm = %s",
2047
2047
show_dev_ino(__entry),
2048
2048
__entry->idx,
···
2058
2058
TP_ARGS(inode, cluster_idx, compressed_size, ret),
2059
2059
2060
2060
TP_STRUCT__entry(
2061
-
__field(dev_t, dev)
2062
-
__field(ino_t, ino)
2061
+
__field(u64, ino)
2063
2062
__field(pgoff_t, idx)
2063
+
__field(dev_t, dev)
2064
2064
__field(unsigned int, size)
2065
2065
__field(unsigned int, ret)
2066
2066
),
···
2073
2073
__entry->ret = ret;
2074
2074
),
2075
2075
2076
-
TP_printk("dev = (%d,%d), ino = %lu, cluster_idx:%lu, "
2076
+
TP_printk("dev = (%d,%d), ino = %llu, cluster_idx:%lu, "
2077
2077
"compressed_size = %u, ret = %d",
2078
2078
show_dev_ino(__entry),
2079
2079
__entry->idx,
···
2311
2311
TP_ARGS(inode, lblock, pblock),
2312
2312
2313
2313
TP_STRUCT__entry(
2314
-
__field(dev_t, dev)
2315
-
__field(ino_t, ino)
2314
+
__field(u64, ino)
2316
2315
__field(sector_t, lblock)
2317
2316
__field(sector_t, pblock)
2317
+
__field(dev_t, dev)
2318
2318
),
2319
2319
2320
2320
TP_fast_assign(
···
2324
2324
__entry->pblock = pblock;
2325
2325
),
2326
2326
2327
-
TP_printk("dev = (%d,%d), ino = %lu, lblock:%lld, pblock:%lld",
2327
+
TP_printk("dev = (%d,%d), ino = %llu, lblock:%lld, pblock:%lld",
2328
2328
show_dev_ino(__entry),
2329
2329
(unsigned long long)__entry->lblock,
2330
2330
(unsigned long long)__entry->pblock)
···
2338
2338
TP_ARGS(inode, lblock, pblock, len, flags, ret),
2339
2339
2340
2340
TP_STRUCT__entry(
2341
-
__field(dev_t, dev)
2342
-
__field(ino_t, ino)
2341
+
__field(u64, ino)
2343
2342
__field(sector_t, lblock)
2344
2343
__field(sector_t, pblock)
2345
2344
__field(unsigned long long, len)
2345
+
__field(dev_t, dev)
2346
2346
__field(unsigned int, flags)
2347
2347
__field(int, ret)
2348
2348
),
···
2357
2357
__entry->ret = ret;
2358
2358
),
2359
2359
2360
-
TP_printk("dev = (%d,%d), ino = %lu, lblock:%lld, pblock:%lld, "
2360
+
TP_printk("dev = (%d,%d), ino = %llu, lblock:%lld, pblock:%lld, "
2361
2361
"len:%llu, flags:%u, ret:%d",
2362
2362
show_dev_ino(__entry),
2363
2363
(unsigned long long)__entry->lblock,
···
2375
2375
TP_ARGS(inode, offset, bytes, pid, pathname, command),
2376
2376
2377
2377
TP_STRUCT__entry(
2378
-
__string(pathbuf, pathname)
2378
+
__field(u64, ino)
2379
2379
__field(loff_t, offset)
2380
-
__field(int, bytes)
2381
2380
__field(loff_t, i_size)
2381
+
__string(pathbuf, pathname)
2382
2382
__string(cmdline, command)
2383
2383
__field(pid_t, pid)
2384
-
__field(ino_t, ino)
2384
+
__field(int, bytes)
2385
2385
),
2386
2386
2387
2387
TP_fast_assign(
···
2402
2402
),
2403
2403
2404
2404
TP_printk("entry_name %s, offset %llu, bytes %d, cmdline %s,"
2405
-
" pid %d, i_size %llu, ino %lu",
2405
+
" pid %d, i_size %llu, ino %llu",
2406
2406
__get_str(pathbuf), __entry->offset, __entry->bytes,
2407
2407
__get_str(cmdline), __entry->pid, __entry->i_size,
2408
-
(unsigned long) __entry->ino)
2408
+
__entry->ino)
2409
2409
);
2410
2410
2411
2411
DECLARE_EVENT_CLASS(f2fs__rw_end,
···
2415
2415
TP_ARGS(inode, offset, bytes),
2416
2416
2417
2417
TP_STRUCT__entry(
2418
-
__field(ino_t, ino)
2418
+
__field(u64, ino)
2419
2419
__field(loff_t, offset)
2420
2420
__field(int, bytes)
2421
2421
),
···
2426
2426
__entry->bytes = bytes;
2427
2427
),
2428
2428
2429
-
TP_printk("ino %lu, offset %llu, bytes %d",
2430
-
(unsigned long) __entry->ino,
2429
+
TP_printk("ino %llu, offset %llu, bytes %d",
2430
+
__entry->ino,
2431
2431
__entry->offset, __entry->bytes)
2432
2432
);
2433
2433
+17
-17
include/trace/events/filelock.h
+17
-17
include/trace/events/filelock.h
···
42
42
TP_ARGS(inode, type, ctx),
43
43
44
44
TP_STRUCT__entry(
45
-
__field(unsigned long, i_ino)
45
+
__field(u64, i_ino)
46
+
__field(struct file_lock_context *, ctx)
46
47
__field(dev_t, s_dev)
47
48
__field(unsigned char, type)
48
-
__field(struct file_lock_context *, ctx)
49
49
),
50
50
51
51
TP_fast_assign(
···
55
55
__entry->ctx = ctx;
56
56
),
57
57
58
-
TP_printk("dev=0x%x:0x%x ino=0x%lx type=%s ctx=%p",
58
+
TP_printk("dev=0x%x:0x%x ino=0x%llx type=%s ctx=%p",
59
59
MAJOR(__entry->s_dev), MINOR(__entry->s_dev),
60
60
__entry->i_ino, show_fl_type(__entry->type), __entry->ctx)
61
61
);
···
66
66
TP_ARGS(inode, fl, ret),
67
67
68
68
TP_STRUCT__entry(
69
+
__field(u64, i_ino)
70
+
__field(loff_t, fl_start)
71
+
__field(loff_t, fl_end)
69
72
__field(struct file_lock *, fl)
70
-
__field(unsigned long, i_ino)
71
-
__field(dev_t, s_dev)
72
73
__field(struct file_lock_core *, blocker)
73
74
__field(fl_owner_t, owner)
75
+
__field(dev_t, s_dev)
74
76
__field(unsigned int, pid)
75
77
__field(unsigned int, flags)
76
78
__field(unsigned char, type)
77
-
__field(loff_t, fl_start)
78
-
__field(loff_t, fl_end)
79
79
__field(int, ret)
80
80
),
81
81
···
93
93
__entry->ret = ret;
94
94
),
95
95
96
-
TP_printk("fl=%p dev=0x%x:0x%x ino=0x%lx fl_blocker=%p fl_owner=%p fl_pid=%u fl_flags=%s fl_type=%s fl_start=%lld fl_end=%lld ret=%d",
96
+
TP_printk("fl=%p dev=0x%x:0x%x ino=0x%llx fl_blocker=%p fl_owner=%p fl_pid=%u fl_flags=%s fl_type=%s fl_start=%lld fl_end=%lld ret=%d",
97
97
__entry->fl, MAJOR(__entry->s_dev), MINOR(__entry->s_dev),
98
98
__entry->i_ino, __entry->blocker, __entry->owner,
99
99
__entry->pid, show_fl_flags(__entry->flags),
···
123
123
TP_ARGS(inode, fl),
124
124
125
125
TP_STRUCT__entry(
126
+
__field(u64, i_ino)
126
127
__field(struct file_lease *, fl)
127
-
__field(unsigned long, i_ino)
128
-
__field(dev_t, s_dev)
129
128
__field(struct file_lock_core *, blocker)
130
129
__field(fl_owner_t, owner)
131
-
__field(unsigned int, flags)
132
-
__field(unsigned char, type)
133
130
__field(unsigned long, break_time)
134
131
__field(unsigned long, downgrade_time)
132
+
__field(dev_t, s_dev)
133
+
__field(unsigned int, flags)
134
+
__field(unsigned char, type)
135
135
),
136
136
137
137
TP_fast_assign(
···
146
146
__entry->downgrade_time = fl ? fl->fl_downgrade_time : 0;
147
147
),
148
148
149
-
TP_printk("fl=%p dev=0x%x:0x%x ino=0x%lx fl_blocker=%p fl_owner=%p fl_flags=%s fl_type=%s fl_break_time=%lu fl_downgrade_time=%lu",
149
+
TP_printk("fl=%p dev=0x%x:0x%x ino=0x%llx fl_blocker=%p fl_owner=%p fl_flags=%s fl_type=%s fl_break_time=%lu fl_downgrade_time=%lu",
150
150
__entry->fl, MAJOR(__entry->s_dev), MINOR(__entry->s_dev),
151
151
__entry->i_ino, __entry->blocker, __entry->owner,
152
152
show_fl_flags(__entry->flags),
···
175
175
TP_ARGS(inode, fl),
176
176
177
177
TP_STRUCT__entry(
178
-
__field(unsigned long, i_ino)
178
+
__field(u64, i_ino)
179
+
__field(fl_owner_t, owner)
180
+
__field(dev_t, s_dev)
179
181
__field(int, wcount)
180
182
__field(int, rcount)
181
183
__field(int, icount)
182
-
__field(dev_t, s_dev)
183
-
__field(fl_owner_t, owner)
184
184
__field(unsigned int, flags)
185
185
__field(unsigned char, type)
186
186
),
···
196
196
__entry->type = fl->c.flc_type;
197
197
),
198
198
199
-
TP_printk("dev=0x%x:0x%x ino=0x%lx wcount=%d rcount=%d icount=%d fl_owner=%p fl_flags=%s fl_type=%s",
199
+
TP_printk("dev=0x%x:0x%x ino=0x%llx wcount=%d rcount=%d icount=%d fl_owner=%p fl_flags=%s fl_type=%s",
200
200
MAJOR(__entry->s_dev), MINOR(__entry->s_dev),
201
201
__entry->i_ino, __entry->wcount, __entry->rcount,
202
202
__entry->icount, __entry->owner,
+10
-10
include/trace/events/filemap.h
+10
-10
include/trace/events/filemap.h
···
20
20
TP_ARGS(folio),
21
21
22
22
TP_STRUCT__entry(
23
+
__field(u64, i_ino)
23
24
__field(unsigned long, pfn)
24
-
__field(unsigned long, i_ino)
25
25
__field(unsigned long, index)
26
26
__field(dev_t, s_dev)
27
27
__field(unsigned char, order)
···
38
38
__entry->order = folio_order(folio);
39
39
),
40
40
41
-
TP_printk("dev %d:%d ino %lx pfn=0x%lx ofs=%lu order=%u",
41
+
TP_printk("dev %d:%d ino %llx pfn=0x%lx ofs=%lu order=%u",
42
42
MAJOR(__entry->s_dev), MINOR(__entry->s_dev),
43
43
__entry->i_ino,
44
44
__entry->pfn,
···
67
67
TP_ARGS(mapping, index, last_index),
68
68
69
69
TP_STRUCT__entry(
70
-
__field(unsigned long, i_ino)
70
+
__field(u64, i_ino)
71
71
__field(dev_t, s_dev)
72
72
__field(unsigned long, index)
73
73
__field(unsigned long, last_index)
···
85
85
),
86
86
87
87
TP_printk(
88
-
"dev=%d:%d ino=%lx ofs=%lld-%lld",
88
+
"dev=%d:%d ino=%llx ofs=%lld-%lld",
89
89
MAJOR(__entry->s_dev),
90
90
MINOR(__entry->s_dev), __entry->i_ino,
91
91
((loff_t)__entry->index) << PAGE_SHIFT,
···
117
117
TP_ARGS(mapping, index),
118
118
119
119
TP_STRUCT__entry(
120
-
__field(unsigned long, i_ino)
120
+
__field(u64, i_ino)
121
121
__field(dev_t, s_dev)
122
122
__field(unsigned long, index)
123
123
),
···
133
133
),
134
134
135
135
TP_printk(
136
-
"dev=%d:%d ino=%lx ofs=%lld",
136
+
"dev=%d:%d ino=%llx ofs=%lld",
137
137
MAJOR(__entry->s_dev),
138
138
MINOR(__entry->s_dev), __entry->i_ino,
139
139
((loff_t)__entry->index) << PAGE_SHIFT
···
146
146
TP_ARGS(mapping, eseq),
147
147
148
148
TP_STRUCT__entry(
149
-
__field(unsigned long, i_ino)
149
+
__field(u64, i_ino)
150
150
__field(dev_t, s_dev)
151
151
__field(errseq_t, errseq)
152
152
),
···
160
160
__entry->s_dev = mapping->host->i_rdev;
161
161
),
162
162
163
-
TP_printk("dev=%d:%d ino=0x%lx errseq=0x%x",
163
+
TP_printk("dev=%d:%d ino=0x%llx errseq=0x%x",
164
164
MAJOR(__entry->s_dev), MINOR(__entry->s_dev),
165
165
__entry->i_ino, __entry->errseq)
166
166
);
···
171
171
TP_ARGS(file, old),
172
172
173
173
TP_STRUCT__entry(
174
+
__field(u64, i_ino)
174
175
__field(struct file *, file)
175
-
__field(unsigned long, i_ino)
176
176
__field(dev_t, s_dev)
177
177
__field(errseq_t, old)
178
178
__field(errseq_t, new)
···
191
191
__entry->new = file->f_wb_err;
192
192
),
193
193
194
-
TP_printk("file=%p dev=%d:%d ino=0x%lx old=0x%x new=0x%x",
194
+
TP_printk("file=%p dev=%d:%d ino=0x%llx old=0x%x new=0x%x",
195
195
__entry->file, MAJOR(__entry->s_dev),
196
196
MINOR(__entry->s_dev), __entry->i_ino, __entry->old,
197
197
__entry->new)
+10
-10
include/trace/events/fs_dax.h
+10
-10
include/trace/events/fs_dax.h
···
12
12
pgoff_t max_pgoff, int result),
13
13
TP_ARGS(inode, vmf, max_pgoff, result),
14
14
TP_STRUCT__entry(
15
-
__field(unsigned long, ino)
15
+
__field(u64, ino)
16
16
__field(unsigned long, vm_start)
17
17
__field(unsigned long, vm_end)
18
18
__field(vm_flags_t, vm_flags)
···
35
35
__entry->max_pgoff = max_pgoff;
36
36
__entry->result = result;
37
37
),
38
-
TP_printk("dev %d:%d ino %#lx %s %s address %#lx vm_start "
38
+
TP_printk("dev %d:%d ino %#llx %s %s address %#lx vm_start "
39
39
"%#lx vm_end %#lx pgoff %#lx max_pgoff %#lx %s",
40
40
MAJOR(__entry->dev),
41
41
MINOR(__entry->dev),
···
66
66
void *radix_entry),
67
67
TP_ARGS(inode, vmf, zero_folio, radix_entry),
68
68
TP_STRUCT__entry(
69
-
__field(unsigned long, ino)
69
+
__field(u64, ino)
70
70
__field(vm_flags_t, vm_flags)
71
71
__field(unsigned long, address)
72
72
__field(struct folio *, zero_folio)
···
81
81
__entry->zero_folio = zero_folio;
82
82
__entry->radix_entry = radix_entry;
83
83
),
84
-
TP_printk("dev %d:%d ino %#lx %s address %#lx zero_folio %p "
84
+
TP_printk("dev %d:%d ino %#llx %s address %#lx zero_folio %p "
85
85
"radix_entry %#lx",
86
86
MAJOR(__entry->dev),
87
87
MINOR(__entry->dev),
···
106
106
TP_PROTO(struct inode *inode, struct vm_fault *vmf, int result),
107
107
TP_ARGS(inode, vmf, result),
108
108
TP_STRUCT__entry(
109
-
__field(unsigned long, ino)
109
+
__field(u64, ino)
110
110
__field(vm_flags_t, vm_flags)
111
111
__field(unsigned long, address)
112
112
__field(pgoff_t, pgoff)
···
123
123
__entry->pgoff = vmf->pgoff;
124
124
__entry->result = result;
125
125
),
126
-
TP_printk("dev %d:%d ino %#lx %s %s address %#lx pgoff %#lx %s",
126
+
TP_printk("dev %d:%d ino %#llx %s %s address %#lx pgoff %#lx %s",
127
127
MAJOR(__entry->dev),
128
128
MINOR(__entry->dev),
129
129
__entry->ino,
···
150
150
TP_PROTO(struct inode *inode, pgoff_t start_index, pgoff_t end_index),
151
151
TP_ARGS(inode, start_index, end_index),
152
152
TP_STRUCT__entry(
153
-
__field(unsigned long, ino)
153
+
__field(u64, ino)
154
154
__field(pgoff_t, start_index)
155
155
__field(pgoff_t, end_index)
156
156
__field(dev_t, dev)
···
161
161
__entry->start_index = start_index;
162
162
__entry->end_index = end_index;
163
163
),
164
-
TP_printk("dev %d:%d ino %#lx pgoff %#lx-%#lx",
164
+
TP_printk("dev %d:%d ino %#llx pgoff %#lx-%#lx",
165
165
MAJOR(__entry->dev),
166
166
MINOR(__entry->dev),
167
167
__entry->ino,
···
182
182
TP_PROTO(struct inode *inode, pgoff_t pgoff, pgoff_t pglen),
183
183
TP_ARGS(inode, pgoff, pglen),
184
184
TP_STRUCT__entry(
185
-
__field(unsigned long, ino)
185
+
__field(u64, ino)
186
186
__field(pgoff_t, pgoff)
187
187
__field(pgoff_t, pglen)
188
188
__field(dev_t, dev)
···
193
193
__entry->pgoff = pgoff;
194
194
__entry->pglen = pglen;
195
195
),
196
-
TP_printk("dev %d:%d ino %#lx pgoff %#lx pglen %#lx",
196
+
TP_printk("dev %d:%d ino %#llx pgoff %#lx pglen %#lx",
197
197
MAJOR(__entry->dev),
198
198
MINOR(__entry->dev),
199
199
__entry->ino,
+15
-15
include/trace/events/fsverity.h
+15
-15
include/trace/events/fsverity.h
···
16
16
const struct merkle_tree_params *params),
17
17
TP_ARGS(inode, params),
18
18
TP_STRUCT__entry(
19
-
__field(ino_t, ino)
19
+
__field(u64, ino)
20
20
__field(u64, data_size)
21
21
__field(u64, tree_size)
22
22
__field(unsigned int, merkle_block)
···
29
29
__entry->merkle_block = params->block_size;
30
30
__entry->num_levels = params->num_levels;
31
31
),
32
-
TP_printk("ino %lu data_size %llu tree_size %llu merkle_block %u levels %u",
33
-
(unsigned long) __entry->ino,
32
+
TP_printk("ino %llu data_size %llu tree_size %llu merkle_block %u levels %u",
33
+
__entry->ino,
34
34
__entry->data_size,
35
35
__entry->tree_size,
36
36
__entry->merkle_block,
···
42
42
const struct merkle_tree_params *params),
43
43
TP_ARGS(inode, vi, params),
44
44
TP_STRUCT__entry(
45
-
__field(ino_t, ino)
45
+
__field(u64, ino)
46
46
__field(u64, data_size)
47
47
__field(u64, tree_size)
48
48
__field(unsigned int, merkle_block)
···
59
59
memcpy(__get_dynamic_array(root_hash), vi->root_hash, __get_dynamic_array_len(root_hash));
60
60
memcpy(__get_dynamic_array(file_digest), vi->file_digest, __get_dynamic_array_len(file_digest));
61
61
),
62
-
TP_printk("ino %lu data_size %llu tree_size %lld merkle_block %u levels %u root_hash %s digest %s",
63
-
(unsigned long) __entry->ino,
62
+
TP_printk("ino %llu data_size %llu tree_size %lld merkle_block %u levels %u root_hash %s digest %s",
63
+
__entry->ino,
64
64
__entry->data_size,
65
65
__entry->tree_size,
66
66
__entry->merkle_block,
···
75
75
u64 data_pos),
76
76
TP_ARGS(inode, params, data_pos),
77
77
TP_STRUCT__entry(
78
-
__field(ino_t, ino)
78
+
__field(u64, ino)
79
79
__field(u64, data_pos)
80
80
__field(unsigned int, merkle_block)
81
81
),
···
84
84
__entry->data_pos = data_pos;
85
85
__entry->merkle_block = params->block_size;
86
86
),
87
-
TP_printk("ino %lu data_pos %llu merkle_block %u",
88
-
(unsigned long) __entry->ino,
87
+
TP_printk("ino %llu data_pos %llu merkle_block %u",
88
+
__entry->ino,
89
89
__entry->data_pos,
90
90
__entry->merkle_block)
91
91
);
···
96
96
unsigned int hidx),
97
97
TP_ARGS(inode, data_pos, hblock_idx, level, hidx),
98
98
TP_STRUCT__entry(
99
-
__field(ino_t, ino)
99
+
__field(u64, ino)
100
100
__field(u64, data_pos)
101
101
__field(unsigned long, hblock_idx)
102
102
__field(unsigned int, level)
···
109
109
__entry->level = level;
110
110
__entry->hidx = hidx;
111
111
),
112
-
TP_printk("ino %lu data_pos %llu hblock_idx %lu level %u hidx %u",
113
-
(unsigned long) __entry->ino,
112
+
TP_printk("ino %llu data_pos %llu hblock_idx %lu level %u hidx %u",
113
+
__entry->ino,
114
114
__entry->data_pos,
115
115
__entry->hblock_idx,
116
116
__entry->level,
···
122
122
unsigned int level, unsigned int hidx),
123
123
TP_ARGS(inode, hblock_idx, level, hidx),
124
124
TP_STRUCT__entry(
125
-
__field(ino_t, ino)
125
+
__field(u64, ino)
126
126
__field(unsigned long, hblock_idx)
127
127
__field(unsigned int, level)
128
128
__field(unsigned int, hidx)
···
133
133
__entry->level = level;
134
134
__entry->hidx = hidx;
135
135
),
136
-
TP_printk("ino %lu hblock_idx %lu level %u hidx %u",
137
-
(unsigned long) __entry->ino,
136
+
TP_printk("ino %llu hblock_idx %lu level %u hidx %u",
137
+
__entry->ino,
138
138
__entry->hblock_idx,
139
139
__entry->level,
140
140
__entry->hidx)
+21
-21
include/trace/events/hugetlbfs.h
+21
-21
include/trace/events/hugetlbfs.h
···
14
14
TP_ARGS(inode, dir, mode),
15
15
16
16
TP_STRUCT__entry(
17
+
__field(u64, ino)
18
+
__field(u64, dir)
17
19
__field(dev_t, dev)
18
-
__field(ino_t, ino)
19
-
__field(ino_t, dir)
20
20
__field(__u16, mode)
21
21
),
22
22
···
27
27
__entry->mode = mode;
28
28
),
29
29
30
-
TP_printk("dev %d,%d ino %lu dir %lu mode 0%o",
30
+
TP_printk("dev %d,%d ino %llu dir %llu mode 0%o",
31
31
MAJOR(__entry->dev), MINOR(__entry->dev),
32
-
(unsigned long) __entry->ino,
33
-
(unsigned long) __entry->dir, __entry->mode)
32
+
__entry->ino,
33
+
__entry->dir, __entry->mode)
34
34
);
35
35
36
36
DECLARE_EVENT_CLASS(hugetlbfs__inode,
···
40
40
TP_ARGS(inode),
41
41
42
42
TP_STRUCT__entry(
43
-
__field(dev_t, dev)
44
-
__field(ino_t, ino)
45
-
__field(__u16, mode)
43
+
__field(u64, ino)
46
44
__field(loff_t, size)
45
+
__field(blkcnt_t, blocks)
46
+
__field(dev_t, dev)
47
47
__field(unsigned int, nlink)
48
48
__field(unsigned int, seals)
49
-
__field(blkcnt_t, blocks)
49
+
__field(__u16, mode)
50
50
),
51
51
52
52
TP_fast_assign(
···
59
59
__entry->blocks = inode->i_blocks;
60
60
),
61
61
62
-
TP_printk("dev %d,%d ino %lu mode 0%o size %lld nlink %u seals %u blocks %llu",
63
-
MAJOR(__entry->dev), MINOR(__entry->dev), (unsigned long) __entry->ino,
62
+
TP_printk("dev %d,%d ino %llu mode 0%o size %lld nlink %u seals %u blocks %llu",
63
+
MAJOR(__entry->dev), MINOR(__entry->dev), __entry->ino,
64
64
__entry->mode, __entry->size, __entry->nlink, __entry->seals,
65
65
(unsigned long long)__entry->blocks)
66
66
);
···
87
87
TP_ARGS(inode, dentry, attr),
88
88
89
89
TP_STRUCT__entry(
90
+
__field(u64, ino)
91
+
__field(loff_t, old_size)
92
+
__field(loff_t, ia_size)
90
93
__field(dev_t, dev)
91
-
__field(ino_t, ino)
92
94
__field(unsigned int, d_len)
93
95
__string(d_name, dentry->d_name.name)
94
96
__field(unsigned int, ia_valid)
95
97
__field(unsigned int, ia_mode)
96
-
__field(loff_t, old_size)
97
-
__field(loff_t, ia_size)
98
98
),
99
99
100
100
TP_fast_assign(
···
108
108
__entry->ia_size = attr->ia_size;
109
109
),
110
110
111
-
TP_printk("dev %d,%d ino %lu name %.*s valid %#x mode 0%o old_size %lld size %lld",
112
-
MAJOR(__entry->dev), MINOR(__entry->dev), (unsigned long)__entry->ino,
111
+
TP_printk("dev %d,%d ino %llu name %.*s valid %#x mode 0%o old_size %lld size %lld",
112
+
MAJOR(__entry->dev), MINOR(__entry->dev), __entry->ino,
113
113
__entry->d_len, __get_str(d_name), __entry->ia_valid, __entry->ia_mode,
114
114
__entry->old_size, __entry->ia_size)
115
115
);
···
122
122
TP_ARGS(inode, mode, offset, len, ret),
123
123
124
124
TP_STRUCT__entry(
125
-
__field(dev_t, dev)
126
-
__field(ino_t, ino)
127
-
__field(int, mode)
125
+
__field(u64, ino)
128
126
__field(loff_t, offset)
129
127
__field(loff_t, len)
130
128
__field(loff_t, size)
129
+
__field(dev_t, dev)
130
+
__field(int, mode)
131
131
__field(int, ret)
132
132
),
133
133
···
141
141
__entry->ret = ret;
142
142
),
143
143
144
-
TP_printk("dev %d,%d ino %lu mode 0%o offset %lld len %lld size %lld ret %d",
144
+
TP_printk("dev %d,%d ino %llu mode 0%o offset %lld len %lld size %lld ret %d",
145
145
MAJOR(__entry->dev), MINOR(__entry->dev),
146
-
(unsigned long)__entry->ino, __entry->mode,
146
+
__entry->ino, __entry->mode,
147
147
(unsigned long long)__entry->offset,
148
148
(unsigned long long)__entry->len,
149
149
(unsigned long long)__entry->size,
+4
-4
include/trace/events/netfs.h
+4
-4
include/trace/events/netfs.h
···
300
300
__field(loff_t, start)
301
301
__field(size_t, len)
302
302
__field(enum netfs_read_trace, what)
303
-
__field(unsigned int, netfs_inode)
303
+
__field(u64, netfs_inode)
304
304
),
305
305
306
306
TP_fast_assign(
···
313
313
__entry->netfs_inode = rreq->inode->i_ino;
314
314
),
315
315
316
-
TP_printk("R=%08x %s c=%08x ni=%x s=%llx l=%zx sz=%llx",
316
+
TP_printk("R=%08x %s c=%08x ni=%llx s=%llx l=%zx sz=%llx",
317
317
__entry->rreq,
318
318
__print_symbolic(__entry->what, netfs_read_traces),
319
319
__entry->cookie,
···
486
486
TP_ARGS(folio, why),
487
487
488
488
TP_STRUCT__entry(
489
-
__field(ino_t, ino)
489
+
__field(u64, ino)
490
490
__field(pgoff_t, index)
491
491
__field(unsigned int, nr)
492
492
__field(enum netfs_folio_trace, why)
···
500
500
__entry->nr = folio_nr_pages(folio);
501
501
),
502
502
503
-
TP_printk("i=%05lx ix=%05lx-%05lx %s",
503
+
TP_printk("i=%05llx ix=%05lx-%05lx %s",
504
504
__entry->ino, __entry->index, __entry->index + __entry->nr - 1,
505
505
__print_symbolic(__entry->why, netfs_folio_traces))
506
506
);
+6
-6
include/trace/events/nilfs2.h
+6
-6
include/trace/events/nilfs2.h
···
165
165
166
166
TRACE_EVENT(nilfs2_mdt_insert_new_block,
167
167
TP_PROTO(struct inode *inode,
168
-
unsigned long ino,
168
+
u64 ino,
169
169
unsigned long block),
170
170
171
171
TP_ARGS(inode, ino, block),
172
172
173
173
TP_STRUCT__entry(
174
+
__field(u64, ino)
174
175
__field(struct inode *, inode)
175
-
__field(unsigned long, ino)
176
176
__field(unsigned long, block)
177
177
),
178
178
···
182
182
__entry->block = block;
183
183
),
184
184
185
-
TP_printk("inode = %p ino = %lu block = %lu",
185
+
TP_printk("inode = %p ino = %llu block = %lu",
186
186
__entry->inode,
187
187
__entry->ino,
188
188
__entry->block)
···
190
190
191
191
TRACE_EVENT(nilfs2_mdt_submit_block,
192
192
TP_PROTO(struct inode *inode,
193
-
unsigned long ino,
193
+
u64 ino,
194
194
unsigned long blkoff,
195
195
enum req_op mode),
196
196
197
197
TP_ARGS(inode, ino, blkoff, mode),
198
198
199
199
TP_STRUCT__entry(
200
+
__field(u64, ino)
200
201
__field(struct inode *, inode)
201
-
__field(unsigned long, ino)
202
202
__field(unsigned long, blkoff)
203
203
/*
204
204
* Use field_struct() to avoid is_signed_type() on the
···
214
214
__entry->mode = mode;
215
215
),
216
216
217
-
TP_printk("inode = %p ino = %lu blkoff = %lu mode = %x",
217
+
TP_printk("inode = %p ino = %llu blkoff = %lu mode = %x",
218
218
__entry->inode,
219
219
__entry->ino,
220
220
__entry->blkoff,
+9
-9
include/trace/events/readahead.h
+9
-9
include/trace/events/readahead.h
···
18
18
TP_ARGS(inode, index, nr_to_read, lookahead_size),
19
19
20
20
TP_STRUCT__entry(
21
-
__field(unsigned long, i_ino)
21
+
__field(u64, i_ino)
22
22
__field(dev_t, s_dev)
23
23
__field(pgoff_t, index)
24
24
__field(unsigned long, nr_to_read)
···
34
34
),
35
35
36
36
TP_printk(
37
-
"dev=%d:%d ino=%lx index=%lu nr_to_read=%lu lookahead_size=%lu",
37
+
"dev=%d:%d ino=%llx index=%lu nr_to_read=%lu lookahead_size=%lu",
38
38
MAJOR(__entry->s_dev), MINOR(__entry->s_dev), __entry->i_ino,
39
39
__entry->index, __entry->nr_to_read, __entry->lookahead_size
40
40
)
···
46
46
TP_ARGS(inode, index, ra),
47
47
48
48
TP_STRUCT__entry(
49
-
__field(unsigned long, i_ino)
49
+
__field(u64, i_ino)
50
50
__field(dev_t, s_dev)
51
51
__field(pgoff_t, index)
52
52
__field(unsigned int, order)
···
66
66
),
67
67
68
68
TP_printk(
69
-
"dev=%d:%d ino=%lx index=%lu order=%u size=%u async_size=%u ra_pages=%u",
69
+
"dev=%d:%d ino=%llx index=%lu order=%u size=%u async_size=%u ra_pages=%u",
70
70
MAJOR(__entry->s_dev), MINOR(__entry->s_dev), __entry->i_ino,
71
71
__entry->index, __entry->order, __entry->size,
72
72
__entry->async_size, __entry->ra_pages
···
80
80
TP_ARGS(inode, index, ra, req_count),
81
81
82
82
TP_STRUCT__entry(
83
-
__field(unsigned long, i_ino)
84
-
__field(dev_t, s_dev)
83
+
__field(u64, i_ino)
84
+
__field(loff_t, prev_pos)
85
85
__field(pgoff_t, index)
86
+
__field(unsigned long, req_count)
87
+
__field(dev_t, s_dev)
86
88
__field(unsigned int, order)
87
89
__field(unsigned int, size)
88
90
__field(unsigned int, async_size)
89
91
__field(unsigned int, ra_pages)
90
92
__field(unsigned int, mmap_miss)
91
-
__field(loff_t, prev_pos)
92
-
__field(unsigned long, req_count)
93
93
),
94
94
95
95
TP_fast_assign(
···
106
106
),
107
107
108
108
TP_printk(
109
-
"dev=%d:%d ino=%lx index=%lu req_count=%lu order=%u size=%u async_size=%u ra_pages=%u mmap_miss=%u prev_pos=%lld",
109
+
"dev=%d:%d ino=%llx index=%lu req_count=%lu order=%u size=%u async_size=%u ra_pages=%u mmap_miss=%u prev_pos=%lld",
110
110
MAJOR(__entry->s_dev), MINOR(__entry->s_dev), __entry->i_ino,
111
111
__entry->index, __entry->req_count, __entry->order,
112
112
__entry->size, __entry->async_size, __entry->ra_pages,
+8
-8
include/trace/events/timestamp.h
+8
-8
include/trace/events/timestamp.h
···
18
18
TP_ARGS(inode, ctime),
19
19
20
20
TP_STRUCT__entry(
21
-
__field(dev_t, dev)
22
-
__field(ino_t, ino)
21
+
__field(u64, ino)
23
22
__field(time64_t, ctime_s)
23
+
__field(dev_t, dev)
24
24
__field(u32, ctime_ns)
25
25
__field(u32, gen)
26
26
),
···
33
33
__entry->ctime_ns = ctime->tv_nsec;
34
34
),
35
35
36
-
TP_printk("ino=%d:%d:%ld:%u ctime=%lld.%u",
36
+
TP_printk("ino=%d:%d:%llu:%u ctime=%lld.%u",
37
37
MAJOR(__entry->dev), MINOR(__entry->dev), __entry->ino, __entry->gen,
38
38
__entry->ctime_s, __entry->ctime_ns
39
39
)
···
58
58
TP_ARGS(inode, old, new, cur),
59
59
60
60
TP_STRUCT__entry(
61
+
__field(u64, ino)
61
62
__field(dev_t, dev)
62
-
__field(ino_t, ino)
63
63
__field(u32, gen)
64
64
__field(u32, old)
65
65
__field(u32, new)
···
75
75
__entry->cur = cur;
76
76
),
77
77
78
-
TP_printk("ino=%d:%d:%ld:%u old=%u:%s new=%u cur=%u:%s",
78
+
TP_printk("ino=%d:%d:%llu:%u old=%u:%s new=%u cur=%u:%s",
79
79
MAJOR(__entry->dev), MINOR(__entry->dev), __entry->ino, __entry->gen,
80
80
__entry->old & ~I_CTIME_QUERIED,
81
81
__print_flags(__entry->old & I_CTIME_QUERIED, "|", CTIME_QUERIED_FLAGS),
···
93
93
TP_ARGS(inode, ctime, mtime),
94
94
95
95
TP_STRUCT__entry(
96
-
__field(dev_t, dev)
97
-
__field(ino_t, ino)
96
+
__field(u64, ino)
98
97
__field(time64_t, ctime_s)
99
98
__field(time64_t, mtime_s)
99
+
__field(dev_t, dev)
100
100
__field(u32, ctime_ns)
101
101
__field(u32, mtime_ns)
102
102
__field(u32, gen)
···
112
112
__entry->mtime_ns = mtime->tv_nsec;
113
113
),
114
114
115
-
TP_printk("ino=%d:%d:%ld:%u ctime=%lld.%u mtime=%lld.%u",
115
+
TP_printk("ino=%d:%d:%llu:%u ctime=%lld.%u mtime=%lld.%u",
116
116
MAJOR(__entry->dev), MINOR(__entry->dev), __entry->ino, __entry->gen,
117
117
__entry->ctime_s, __entry->ctime_ns,
118
118
__entry->mtime_s, __entry->mtime_ns
+81
-81
include/trace/events/writeback.h
+81
-81
include/trace/events/writeback.h
···
67
67
68
68
TP_STRUCT__entry (
69
69
__array(char, name, 32)
70
-
__field(ino_t, ino)
70
+
__field(u64, ino)
71
71
__field(pgoff_t, index)
72
72
),
73
73
···
79
79
__entry->index = folio->index;
80
80
),
81
81
82
-
TP_printk("bdi %s: ino=%lu index=%lu",
82
+
TP_printk("bdi %s: ino=%llu index=%lu",
83
83
__entry->name,
84
-
(unsigned long)__entry->ino,
84
+
__entry->ino,
85
85
__entry->index
86
86
)
87
87
);
···
108
108
109
109
TP_STRUCT__entry (
110
110
__array(char, name, 32)
111
-
__field(ino_t, ino)
111
+
__field(u64, ino)
112
112
__field(unsigned long, state)
113
113
__field(unsigned long, flags)
114
114
),
···
123
123
__entry->flags = flags;
124
124
),
125
125
126
-
TP_printk("bdi %s: ino=%lu state=%s flags=%s",
126
+
TP_printk("bdi %s: ino=%llu state=%s flags=%s",
127
127
__entry->name,
128
-
(unsigned long)__entry->ino,
128
+
__entry->ino,
129
129
show_inode_state(__entry->state),
130
130
show_inode_state(__entry->flags)
131
131
)
···
155
155
#ifdef CREATE_TRACE_POINTS
156
156
#ifdef CONFIG_CGROUP_WRITEBACK
157
157
158
-
static inline ino_t __trace_wb_assign_cgroup(struct bdi_writeback *wb)
158
+
static inline u64 __trace_wb_assign_cgroup(struct bdi_writeback *wb)
159
159
{
160
160
return cgroup_ino(wb->memcg_css->cgroup);
161
161
}
162
162
163
-
static inline ino_t __trace_wbc_assign_cgroup(struct writeback_control *wbc)
163
+
static inline u64 __trace_wbc_assign_cgroup(struct writeback_control *wbc)
164
164
{
165
165
if (wbc->wb)
166
166
return __trace_wb_assign_cgroup(wbc->wb);
···
169
169
}
170
170
#else /* CONFIG_CGROUP_WRITEBACK */
171
171
172
-
static inline ino_t __trace_wb_assign_cgroup(struct bdi_writeback *wb)
172
+
static inline u64 __trace_wb_assign_cgroup(struct bdi_writeback *wb)
173
173
{
174
174
return 1;
175
175
}
176
176
177
-
static inline ino_t __trace_wbc_assign_cgroup(struct writeback_control *wbc)
177
+
static inline u64 __trace_wbc_assign_cgroup(struct writeback_control *wbc)
178
178
{
179
179
return 1;
180
180
}
···
192
192
193
193
TP_STRUCT__entry(
194
194
__array(char, name, 32)
195
-
__field(ino_t, ino)
196
-
__field(ino_t, cgroup_ino)
195
+
__field(u64, ino)
196
+
__field(u64, cgroup_ino)
197
197
__field(unsigned int, history)
198
198
),
199
199
···
204
204
__entry->history = history;
205
205
),
206
206
207
-
TP_printk("bdi %s: ino=%lu cgroup_ino=%lu history=0x%x",
207
+
TP_printk("bdi %s: ino=%llu cgroup_ino=%llu history=0x%x",
208
208
__entry->name,
209
-
(unsigned long)__entry->ino,
210
-
(unsigned long)__entry->cgroup_ino,
209
+
__entry->ino,
210
+
__entry->cgroup_ino,
211
211
__entry->history
212
212
)
213
213
);
···
221
221
222
222
TP_STRUCT__entry(
223
223
__array(char, name, 32)
224
-
__field(ino_t, old_cgroup_ino)
225
-
__field(ino_t, new_cgroup_ino)
224
+
__field(u64, old_cgroup_ino)
225
+
__field(u64, new_cgroup_ino)
226
226
__field(unsigned int, count)
227
227
),
228
228
···
233
233
__entry->count = count;
234
234
),
235
235
236
-
TP_printk("bdi %s: old_cgroup_ino=%lu new_cgroup_ino=%lu count=%u",
236
+
TP_printk("bdi %s: old_cgroup_ino=%llu new_cgroup_ino=%llu count=%u",
237
237
__entry->name,
238
-
(unsigned long)__entry->old_cgroup_ino,
239
-
(unsigned long)__entry->new_cgroup_ino,
238
+
__entry->old_cgroup_ino,
239
+
__entry->new_cgroup_ino,
240
240
__entry->count
241
241
)
242
242
);
···
250
250
251
251
TP_STRUCT__entry(
252
252
__array(char, name, 32)
253
-
__field(ino_t, ino)
254
-
__field(ino_t, old_cgroup_ino)
255
-
__field(ino_t, new_cgroup_ino)
253
+
__field(u64, ino)
254
+
__field(u64, old_cgroup_ino)
255
+
__field(u64, new_cgroup_ino)
256
256
),
257
257
258
258
TP_fast_assign(
···
262
262
__entry->new_cgroup_ino = __trace_wb_assign_cgroup(new_wb);
263
263
),
264
264
265
-
TP_printk("bdi %s: ino=%lu old_cgroup_ino=%lu new_cgroup_ino=%lu",
265
+
TP_printk("bdi %s: ino=%llu old_cgroup_ino=%llu new_cgroup_ino=%llu",
266
266
__entry->name,
267
-
(unsigned long)__entry->ino,
268
-
(unsigned long)__entry->old_cgroup_ino,
269
-
(unsigned long)__entry->new_cgroup_ino
267
+
__entry->ino,
268
+
__entry->old_cgroup_ino,
269
+
__entry->new_cgroup_ino
270
270
)
271
271
);
272
272
···
279
279
TP_STRUCT__entry(
280
280
__array(char, name, 32)
281
281
__field(u64, bdi_id)
282
-
__field(ino_t, ino)
282
+
__field(u64, ino)
283
+
__field(u64, cgroup_ino)
284
+
__field(u64, page_cgroup_ino)
283
285
__field(unsigned int, memcg_id)
284
-
__field(ino_t, cgroup_ino)
285
-
__field(ino_t, page_cgroup_ino)
286
286
),
287
287
288
288
TP_fast_assign(
···
297
297
__entry->page_cgroup_ino = cgroup_ino(folio_memcg(folio)->css.cgroup);
298
298
),
299
299
300
-
TP_printk("bdi %s[%llu]: ino=%lu memcg_id=%u cgroup_ino=%lu page_cgroup_ino=%lu",
300
+
TP_printk("bdi %s[%llu]: ino=%llu memcg_id=%u cgroup_ino=%llu page_cgroup_ino=%llu",
301
301
__entry->name,
302
302
__entry->bdi_id,
303
-
(unsigned long)__entry->ino,
303
+
__entry->ino,
304
304
__entry->memcg_id,
305
-
(unsigned long)__entry->cgroup_ino,
306
-
(unsigned long)__entry->page_cgroup_ino
305
+
__entry->cgroup_ino,
306
+
__entry->page_cgroup_ino
307
307
)
308
308
);
309
309
···
316
316
317
317
TP_STRUCT__entry(
318
318
__array(char, name, 32)
319
-
__field(ino_t, cgroup_ino)
319
+
__field(u64, cgroup_ino)
320
320
__field(unsigned int, frn_bdi_id)
321
321
__field(unsigned int, frn_memcg_id)
322
322
),
···
328
328
__entry->frn_memcg_id = frn_memcg_id;
329
329
),
330
330
331
-
TP_printk("bdi %s: cgroup_ino=%lu frn_bdi_id=%u frn_memcg_id=%u",
331
+
TP_printk("bdi %s: cgroup_ino=%llu frn_bdi_id=%u frn_memcg_id=%u",
332
332
__entry->name,
333
-
(unsigned long)__entry->cgroup_ino,
333
+
__entry->cgroup_ino,
334
334
__entry->frn_bdi_id,
335
335
__entry->frn_memcg_id
336
336
)
···
345
345
346
346
TP_STRUCT__entry (
347
347
__array(char, name, 32)
348
-
__field(ino_t, ino)
348
+
__field(u64, ino)
349
+
__field(u64, cgroup_ino)
349
350
__field(int, sync_mode)
350
-
__field(ino_t, cgroup_ino)
351
351
),
352
352
353
353
TP_fast_assign(
···
358
358
__entry->cgroup_ino = __trace_wbc_assign_cgroup(wbc);
359
359
),
360
360
361
-
TP_printk("bdi %s: ino=%lu sync_mode=%d cgroup_ino=%lu",
361
+
TP_printk("bdi %s: ino=%llu sync_mode=%d cgroup_ino=%llu",
362
362
__entry->name,
363
-
(unsigned long)__entry->ino,
363
+
__entry->ino,
364
364
__entry->sync_mode,
365
-
(unsigned long)__entry->cgroup_ino
365
+
__entry->cgroup_ino
366
366
)
367
367
);
368
368
···
385
385
TP_ARGS(wb, work),
386
386
TP_STRUCT__entry(
387
387
__array(char, name, 32)
388
+
__field(u64, cgroup_ino)
388
389
__field(long, nr_pages)
389
390
__field(dev_t, sb_dev)
390
391
__field(int, sync_mode)
···
393
392
__field(int, range_cyclic)
394
393
__field(int, for_background)
395
394
__field(int, reason)
396
-
__field(ino_t, cgroup_ino)
397
395
),
398
396
TP_fast_assign(
399
397
strscpy_pad(__entry->name, bdi_dev_name(wb->bdi), 32);
···
406
406
__entry->cgroup_ino = __trace_wb_assign_cgroup(wb);
407
407
),
408
408
TP_printk("bdi %s: sb_dev %d:%d nr_pages=%ld sync_mode=%d "
409
-
"kupdate=%d range_cyclic=%d background=%d reason=%s cgroup_ino=%lu",
409
+
"kupdate=%d range_cyclic=%d background=%d reason=%s cgroup_ino=%llu",
410
410
__entry->name,
411
411
MAJOR(__entry->sb_dev), MINOR(__entry->sb_dev),
412
412
__entry->nr_pages,
···
415
415
__entry->range_cyclic,
416
416
__entry->for_background,
417
417
__print_symbolic(__entry->reason, WB_WORK_REASON),
418
-
(unsigned long)__entry->cgroup_ino
418
+
__entry->cgroup_ino
419
419
)
420
420
);
421
421
#define DEFINE_WRITEBACK_WORK_EVENT(name) \
···
445
445
TP_ARGS(wb),
446
446
TP_STRUCT__entry(
447
447
__array(char, name, 32)
448
-
__field(ino_t, cgroup_ino)
448
+
__field(u64, cgroup_ino)
449
449
),
450
450
TP_fast_assign(
451
451
strscpy_pad(__entry->name, bdi_dev_name(wb->bdi), 32);
452
452
__entry->cgroup_ino = __trace_wb_assign_cgroup(wb);
453
453
),
454
-
TP_printk("bdi %s: cgroup_ino=%lu",
454
+
TP_printk("bdi %s: cgroup_ino=%llu",
455
455
__entry->name,
456
-
(unsigned long)__entry->cgroup_ino
456
+
__entry->cgroup_ino
457
457
)
458
458
);
459
459
#define DEFINE_WRITEBACK_EVENT(name) \
···
482
482
TP_ARGS(wbc, bdi),
483
483
TP_STRUCT__entry(
484
484
__array(char, name, 32)
485
+
__field(u64, cgroup_ino)
485
486
__field(long, nr_to_write)
486
487
__field(long, pages_skipped)
488
+
__field(long, range_start)
489
+
__field(long, range_end)
487
490
__field(int, sync_mode)
488
491
__field(int, for_kupdate)
489
492
__field(int, for_background)
490
493
__field(int, range_cyclic)
491
-
__field(long, range_start)
492
-
__field(long, range_end)
493
-
__field(ino_t, cgroup_ino)
494
494
),
495
495
496
496
TP_fast_assign(
···
507
507
),
508
508
509
509
TP_printk("bdi %s: towrt=%ld skip=%ld mode=%d kupd=%d bgrd=%d "
510
-
"cyclic=%d start=0x%lx end=0x%lx cgroup_ino=%lu",
510
+
"cyclic=%d start=0x%lx end=0x%lx cgroup_ino=%llu",
511
511
__entry->name,
512
512
__entry->nr_to_write,
513
513
__entry->pages_skipped,
···
517
517
__entry->range_cyclic,
518
518
__entry->range_start,
519
519
__entry->range_end,
520
-
(unsigned long)__entry->cgroup_ino
520
+
__entry->cgroup_ino
521
521
)
522
522
)
523
523
···
535
535
TP_ARGS(wb, work, dirtied_before, moved),
536
536
TP_STRUCT__entry(
537
537
__array(char, name, 32)
538
+
__field(u64, cgroup_ino)
538
539
__field(unsigned long, older)
539
540
__field(long, age)
540
541
__field(int, moved)
541
542
__field(int, reason)
542
-
__field(ino_t, cgroup_ino)
543
543
),
544
544
TP_fast_assign(
545
545
strscpy_pad(__entry->name, bdi_dev_name(wb->bdi), 32);
···
549
549
__entry->reason = work->reason;
550
550
__entry->cgroup_ino = __trace_wb_assign_cgroup(wb);
551
551
),
552
-
TP_printk("bdi %s: older=%lu age=%ld enqueue=%d reason=%s cgroup_ino=%lu",
552
+
TP_printk("bdi %s: older=%lu age=%ld enqueue=%d reason=%s cgroup_ino=%llu",
553
553
__entry->name,
554
554
__entry->older, /* dirtied_before in jiffies */
555
555
__entry->age, /* dirtied_before in relative milliseconds */
556
556
__entry->moved,
557
557
__print_symbolic(__entry->reason, WB_WORK_REASON),
558
-
(unsigned long)__entry->cgroup_ino
558
+
__entry->cgroup_ino
559
559
)
560
560
);
561
561
···
614
614
615
615
TP_STRUCT__entry(
616
616
__array(char, bdi, 32)
617
+
__field(u64, cgroup_ino)
617
618
__field(unsigned long, write_bw)
618
619
__field(unsigned long, avg_write_bw)
619
620
__field(unsigned long, dirty_rate)
620
621
__field(unsigned long, dirty_ratelimit)
621
622
__field(unsigned long, task_ratelimit)
622
623
__field(unsigned long, balanced_dirty_ratelimit)
623
-
__field(ino_t, cgroup_ino)
624
624
),
625
625
626
626
TP_fast_assign(
···
638
638
TP_printk("bdi %s: "
639
639
"write_bw=%lu awrite_bw=%lu dirty_rate=%lu "
640
640
"dirty_ratelimit=%lu task_ratelimit=%lu "
641
-
"balanced_dirty_ratelimit=%lu cgroup_ino=%lu",
641
+
"balanced_dirty_ratelimit=%lu cgroup_ino=%llu",
642
642
__entry->bdi,
643
643
__entry->write_bw, /* write bandwidth */
644
644
__entry->avg_write_bw, /* avg write bandwidth */
···
646
646
__entry->dirty_ratelimit, /* base ratelimit */
647
647
__entry->task_ratelimit, /* ratelimit with position control */
648
648
__entry->balanced_dirty_ratelimit, /* the balanced ratelimit */
649
-
(unsigned long)__entry->cgroup_ino
649
+
__entry->cgroup_ino
650
650
)
651
651
);
652
652
···
667
667
668
668
TP_STRUCT__entry(
669
669
__array( char, bdi, 32)
670
+
__field(u64, cgroup_ino)
670
671
__field(unsigned long, limit)
671
672
__field(unsigned long, setpoint)
672
673
__field(unsigned long, dirty)
···
675
674
__field(unsigned long, wb_dirty)
676
675
__field(unsigned long, dirty_ratelimit)
677
676
__field(unsigned long, task_ratelimit)
678
-
__field(unsigned int, dirtied)
679
-
__field(unsigned int, dirtied_pause)
680
677
__field(unsigned long, paused)
681
678
__field( long, pause)
682
679
__field(unsigned long, period)
683
680
__field( long, think)
684
-
__field(ino_t, cgroup_ino)
681
+
__field(unsigned int, dirtied)
682
+
__field(unsigned int, dirtied_pause)
685
683
),
686
684
687
685
TP_fast_assign(
···
711
711
"wb_setpoint=%lu wb_dirty=%lu "
712
712
"dirty_ratelimit=%lu task_ratelimit=%lu "
713
713
"dirtied=%u dirtied_pause=%u "
714
-
"paused=%lu pause=%ld period=%lu think=%ld cgroup_ino=%lu",
714
+
"paused=%lu pause=%ld period=%lu think=%ld cgroup_ino=%llu",
715
715
__entry->bdi,
716
716
__entry->limit,
717
717
__entry->setpoint,
···
726
726
__entry->pause, /* ms */
727
727
__entry->period, /* ms */
728
728
__entry->think, /* ms */
729
-
(unsigned long)__entry->cgroup_ino
729
+
__entry->cgroup_ino
730
730
)
731
731
);
732
732
···
737
737
738
738
TP_STRUCT__entry(
739
739
__array(char, name, 32)
740
-
__field(ino_t, ino)
740
+
__field(u64, ino)
741
+
__field(u64, cgroup_ino)
741
742
__field(unsigned long, state)
742
743
__field(unsigned long, dirtied_when)
743
-
__field(ino_t, cgroup_ino)
744
744
),
745
745
746
746
TP_fast_assign(
···
752
752
__entry->cgroup_ino = __trace_wb_assign_cgroup(inode_to_wb(inode));
753
753
),
754
754
755
-
TP_printk("bdi %s: ino=%lu state=%s dirtied_when=%lu age=%lu cgroup_ino=%lu",
755
+
TP_printk("bdi %s: ino=%llu state=%s dirtied_when=%lu age=%lu cgroup_ino=%llu",
756
756
__entry->name,
757
-
(unsigned long)__entry->ino,
757
+
__entry->ino,
758
758
show_inode_state(__entry->state),
759
759
__entry->dirtied_when,
760
760
(jiffies - __entry->dirtied_when) / HZ,
761
-
(unsigned long)__entry->cgroup_ino
761
+
__entry->cgroup_ino
762
762
)
763
763
);
764
764
···
773
773
774
774
TP_STRUCT__entry(
775
775
__array(char, name, 32)
776
-
__field(ino_t, ino)
776
+
__field(u64, ino)
777
+
__field(u64, cgroup_ino)
777
778
__field(unsigned long, state)
778
779
__field(unsigned long, dirtied_when)
779
780
__field(unsigned long, writeback_index)
780
-
__field(long, nr_to_write)
781
781
__field(unsigned long, wrote)
782
-
__field(ino_t, cgroup_ino)
782
+
__field(long, nr_to_write)
783
783
),
784
784
785
785
TP_fast_assign(
···
794
794
__entry->cgroup_ino = __trace_wbc_assign_cgroup(wbc);
795
795
),
796
796
797
-
TP_printk("bdi %s: ino=%lu state=%s dirtied_when=%lu age=%lu "
798
-
"index=%lu to_write=%ld wrote=%lu cgroup_ino=%lu",
797
+
TP_printk("bdi %s: ino=%llu state=%s dirtied_when=%lu age=%lu "
798
+
"index=%lu to_write=%ld wrote=%lu cgroup_ino=%llu",
799
799
__entry->name,
800
-
(unsigned long)__entry->ino,
800
+
__entry->ino,
801
801
show_inode_state(__entry->state),
802
802
__entry->dirtied_when,
803
803
(jiffies - __entry->dirtied_when) / HZ,
804
804
__entry->writeback_index,
805
805
__entry->nr_to_write,
806
806
__entry->wrote,
807
-
(unsigned long)__entry->cgroup_ino
807
+
__entry->cgroup_ino
808
808
)
809
809
);
810
810
···
828
828
TP_ARGS(inode),
829
829
830
830
TP_STRUCT__entry(
831
-
__field( dev_t, dev )
832
-
__field( ino_t, ino )
831
+
__field( u64, ino )
833
832
__field(unsigned long, state )
834
-
__field( __u16, mode )
835
833
__field(unsigned long, dirtied_when )
834
+
__field( dev_t, dev )
835
+
__field( __u16, mode )
836
836
),
837
837
838
838
TP_fast_assign(
···
843
843
__entry->dirtied_when = inode->dirtied_when;
844
844
),
845
845
846
-
TP_printk("dev %d,%d ino %lu dirtied %lu state %s mode 0%o",
846
+
TP_printk("dev %d,%d ino %llu dirtied %lu state %s mode 0%o",
847
847
MAJOR(__entry->dev), MINOR(__entry->dev),
848
-
(unsigned long)__entry->ino, __entry->dirtied_when,
848
+
__entry->ino, __entry->dirtied_when,
849
849
show_inode_state(__entry->state), __entry->mode)
850
850
);
851
851
+6
-7
kernel/audit.h
+6
-7
kernel/audit.h
···
76
76
int name_len; /* number of chars to log */
77
77
bool hidden; /* don't log this record */
78
78
79
-
unsigned long ino;
79
+
u64 ino;
80
80
dev_t dev;
81
81
umode_t mode;
82
82
kuid_t uid;
···
225
225
#define AUDIT_INODE_BUCKETS 32
226
226
extern struct list_head audit_inode_hash[AUDIT_INODE_BUCKETS];
227
227
228
-
static inline int audit_hash_ino(u32 ino)
228
+
static inline int audit_hash_ino(u64 ino)
229
229
{
230
-
return (ino & (AUDIT_INODE_BUCKETS-1));
230
+
return ((u32)ino & (AUDIT_INODE_BUCKETS-1));
231
231
}
232
232
233
233
/* Indicates that audit should log the full pathname. */
···
277
277
extern int audit_add_watch(struct audit_krule *krule, struct list_head **list);
278
278
extern void audit_remove_watch_rule(struct audit_krule *krule);
279
279
extern char *audit_watch_path(struct audit_watch *watch);
280
-
extern int audit_watch_compare(struct audit_watch *watch, unsigned long ino,
281
-
dev_t dev);
280
+
extern int audit_watch_compare(struct audit_watch *watch, u64 ino, dev_t dev);
282
281
283
282
extern struct audit_fsnotify_mark *audit_alloc_mark(struct audit_krule *krule,
284
283
char *pathname, int len);
285
284
extern char *audit_mark_path(struct audit_fsnotify_mark *mark);
286
285
extern void audit_remove_mark(struct audit_fsnotify_mark *audit_mark);
287
286
extern void audit_remove_mark_rule(struct audit_krule *krule);
288
-
extern int audit_mark_compare(struct audit_fsnotify_mark *mark,
289
-
unsigned long ino, dev_t dev);
287
+
extern int audit_mark_compare(struct audit_fsnotify_mark *mark, u64 ino,
288
+
dev_t dev);
290
289
extern int audit_dupe_exe(struct audit_krule *new, struct audit_krule *old);
291
290
extern int audit_exe_compare(struct task_struct *tsk,
292
291
struct audit_fsnotify_mark *mark);
+2
-2
kernel/audit_fsnotify.c
+2
-2
kernel/audit_fsnotify.c
···
25
25
*/
26
26
struct audit_fsnotify_mark {
27
27
dev_t dev; /* associated superblock device */
28
-
unsigned long ino; /* associated inode number */
28
+
u64 ino; /* associated inode number */
29
29
char *path; /* insertion path */
30
30
struct fsnotify_mark mark; /* fsnotify mark on the inode */
31
31
struct audit_krule *rule;
···
57
57
return mark->path;
58
58
}
59
59
60
-
int audit_mark_compare(struct audit_fsnotify_mark *mark, unsigned long ino, dev_t dev)
60
+
int audit_mark_compare(struct audit_fsnotify_mark *mark, u64 ino, dev_t dev)
61
61
{
62
62
if (mark->ino == AUDIT_INO_UNSET)
63
63
return 0;
+6
-6
kernel/audit_watch.c
+6
-6
kernel/audit_watch.c
···
37
37
refcount_t count; /* reference count */
38
38
dev_t dev; /* associated superblock device */
39
39
char *path; /* insertion path */
40
-
unsigned long ino; /* associated inode number */
40
+
u64 ino; /* associated inode number */
41
41
struct audit_parent *parent; /* associated parent */
42
42
struct list_head wlist; /* entry in parent->watches list */
43
43
struct list_head rules; /* anchor for krule->rlist */
···
125
125
return watch->path;
126
126
}
127
127
128
-
int audit_watch_compare(struct audit_watch *watch, unsigned long ino, dev_t dev)
128
+
int audit_watch_compare(struct audit_watch *watch, u64 ino, dev_t dev)
129
129
{
130
130
return (watch->ino != AUDIT_INO_UNSET) &&
131
131
(watch->ino == ino) &&
···
244
244
/* Update inode info in audit rules based on filesystem event. */
245
245
static void audit_update_watch(struct audit_parent *parent,
246
246
const struct qstr *dname, dev_t dev,
247
-
unsigned long ino, unsigned invalidating)
247
+
u64 ino, unsigned invalidating)
248
248
{
249
249
struct audit_watch *owatch, *nwatch, *nextw;
250
250
struct audit_krule *r, *nextr;
···
285
285
list_del(&oentry->rule.list);
286
286
audit_panic("error updating watch, removing");
287
287
} else {
288
-
int h = audit_hash_ino((u32)ino);
288
+
int h = audit_hash_ino(ino);
289
289
290
290
/*
291
291
* nentry->rule.watch == oentry->rule.watch so
···
439
439
440
440
audit_add_to_parent(krule, parent);
441
441
442
-
h = audit_hash_ino((u32)watch->ino);
442
+
h = audit_hash_ino(watch->ino);
443
443
*list = &audit_inode_hash[h];
444
444
error:
445
445
path_put(&parent_path);
···
527
527
int audit_exe_compare(struct task_struct *tsk, struct audit_fsnotify_mark *mark)
528
528
{
529
529
struct file *exe_file;
530
-
unsigned long ino;
530
+
u64 ino;
531
531
dev_t dev;
532
532
533
533
/* only do exe filtering if we are recording @current events/records */
+2
-2
kernel/auditsc.c
+2
-2
kernel/auditsc.c
···
886
886
struct audit_names *n,
887
887
struct audit_context *ctx)
888
888
{
889
-
int h = audit_hash_ino((u32)n->ino);
889
+
int h = audit_hash_ino(n->ino);
890
890
struct list_head *list = &audit_inode_hash[h];
891
891
892
892
return __audit_filter_op(tsk, ctx, list, n, ctx->major);
···
1534
1534
audit_log_format(ab, " name=(null)");
1535
1535
1536
1536
if (n->ino != AUDIT_INO_UNSET)
1537
-
audit_log_format(ab, " inode=%lu dev=%02x:%02x mode=%#ho ouid=%u ogid=%u rdev=%02x:%02x",
1537
+
audit_log_format(ab, " inode=%llu dev=%02x:%02x mode=%#ho ouid=%u ogid=%u rdev=%02x:%02x",
1538
1538
n->ino,
1539
1539
MAJOR(n->dev),
1540
1540
MINOR(n->dev),
+2
-2
kernel/events/uprobes.c
+2
-2
kernel/events/uprobes.c
···
344
344
static void update_ref_ctr_warn(struct uprobe *uprobe,
345
345
struct mm_struct *mm, short d)
346
346
{
347
-
pr_warn("ref_ctr %s failed for inode: 0x%lx offset: "
347
+
pr_warn("ref_ctr %s failed for inode: 0x%llx offset: "
348
348
"0x%llx ref_ctr_offset: 0x%llx of mm: 0x%p\n",
349
349
d > 0 ? "increment" : "decrement", uprobe->inode->i_ino,
350
350
(unsigned long long) uprobe->offset,
···
982
982
static void
983
983
ref_ctr_mismatch_warn(struct uprobe *cur_uprobe, struct uprobe *uprobe)
984
984
{
985
-
pr_warn("ref_ctr_offset mismatch. inode: 0x%lx offset: 0x%llx "
985
+
pr_warn("ref_ctr_offset mismatch. inode: 0x%llx offset: 0x%llx "
986
986
"ref_ctr_offset(old): 0x%llx ref_ctr_offset(new): 0x%llx\n",
987
987
uprobe->inode->i_ino, (unsigned long long) uprobe->offset,
988
988
(unsigned long long) cur_uprobe->ref_ctr_offset,
+1
-1
net/ax25/af_ax25.c
+1
-1
net/ax25/af_ax25.c
+2
-2
net/bluetooth/af_bluetooth.c
+2
-2
net/bluetooth/af_bluetooth.c
···
817
817
struct bt_sock *bt = bt_sk(sk);
818
818
819
819
seq_printf(seq,
820
-
"%pK %-6d %-6u %-6u %-6u %-6lu %-6lu",
820
+
"%pK %-6d %-6u %-6u %-6u %-6llu %-6llu",
821
821
sk,
822
822
refcount_read(&sk->sk_refcnt),
823
823
sk_rmem_alloc_get(sk),
824
824
sk_wmem_alloc_get(sk),
825
825
from_kuid(seq_user_ns(seq), sk_uid(sk)),
826
826
sock_i_ino(sk),
827
-
bt->parent ? sock_i_ino(bt->parent) : 0LU);
827
+
bt->parent ? sock_i_ino(bt->parent) : 0ULL);
828
828
829
829
if (l->custom_seq_show) {
830
830
seq_putc(seq, ' ');
+1
-1
net/can/bcm.c
+1
-1
net/can/bcm.c
···
1713
1713
#if IS_ENABLED(CONFIG_PROC_FS)
1714
1714
if (net->can.bcmproc_dir) {
1715
1715
/* unique socket address as filename */
1716
-
sprintf(bo->procname, "%lu", sock_i_ino(sk));
1716
+
sprintf(bo->procname, "%llu", sock_i_ino(sk));
1717
1717
bo->bcm_proc_read = proc_create_net_single(bo->procname, 0644,
1718
1718
net->can.bcmproc_dir,
1719
1719
bcm_proc_show, sk);
+1
-1
net/ipv4/ping.c
+1
-1
net/ipv4/ping.c
···
1111
1111
__u16 srcp = ntohs(inet->inet_sport);
1112
1112
1113
1113
seq_printf(f, "%5d: %08X:%04X %08X:%04X"
1114
-
" %02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %u",
1114
+
" %02X %08X:%08X %02X:%08lX %08X %5u %8d %llu %d %pK %u",
1115
1115
bucket, src, srcp, dest, destp, sp->sk_state,
1116
1116
sk_wmem_alloc_get(sp),
1117
1117
sk_rmem_alloc_get(sp),
+1
-1
net/ipv4/raw.c
+1
-1
net/ipv4/raw.c
···
1041
1041
srcp = inet->inet_num;
1042
1042
1043
1043
seq_printf(seq, "%4d: %08X:%04X %08X:%04X"
1044
-
" %02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %u\n",
1044
+
" %02X %08X:%08X %02X:%08lX %08X %5u %8d %llu %d %pK %u\n",
1045
1045
i, src, srcp, dest, destp, sp->sk_state,
1046
1046
sk_wmem_alloc_get(sp),
1047
1047
sk_rmem_alloc_get(sp),
+1
-1
net/ipv4/tcp_ipv4.c
+1
-1
net/ipv4/tcp_ipv4.c
···
2887
2887
READ_ONCE(tp->copied_seq), 0);
2888
2888
2889
2889
seq_printf(f, "%4d: %08X:%04X %08X:%04X %02X %08X:%08X %02X:%08lX "
2890
-
"%08X %5u %8d %lu %d %pK %lu %lu %u %u %d",
2890
+
"%08X %5u %8d %llu %d %pK %lu %lu %u %u %d",
2891
2891
i, src, srcp, dest, destp, state,
2892
2892
READ_ONCE(tp->write_seq) - tp->snd_una,
2893
2893
rx_queue,
+1
-1
net/ipv4/udp.c
+1
-1
net/ipv4/udp.c
···
3433
3433
__u16 srcp = ntohs(inet->inet_sport);
3434
3434
3435
3435
seq_printf(f, "%5d: %08X:%04X %08X:%04X"
3436
-
" %02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %u",
3436
+
" %02X %08X:%08X %02X:%08lX %08X %5u %8d %llu %d %pK %u",
3437
3437
bucket, src, srcp, dest, destp, sp->sk_state,
3438
3438
sk_wmem_alloc_get(sp),
3439
3439
udp_rqueue_get(sp),
+1
-1
net/ipv6/datagram.c
+1
-1
net/ipv6/datagram.c
···
1065
1065
src = &sp->sk_v6_rcv_saddr;
1066
1066
seq_printf(seq,
1067
1067
"%5d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
1068
-
"%02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %u\n",
1068
+
"%02X %08X:%08X %02X:%08lX %08X %5u %8d %llu %d %pK %u\n",
1069
1069
bucket,
1070
1070
src->s6_addr32[0], src->s6_addr32[1],
1071
1071
src->s6_addr32[2], src->s6_addr32[3], srcp,
+1
-1
net/ipv6/tcp_ipv6.c
+1
-1
net/ipv6/tcp_ipv6.c
···
2173
2173
2174
2174
seq_printf(seq,
2175
2175
"%4d: %08X%08X%08X%08X:%04X %08X%08X%08X%08X:%04X "
2176
-
"%02X %08X:%08X %02X:%08lX %08X %5u %8d %lu %d %pK %lu %lu %u %u %d\n",
2176
+
"%02X %08X:%08X %02X:%08lX %08X %5u %8d %llu %d %pK %lu %lu %u %u %d\n",
2177
2177
i,
2178
2178
src->s6_addr32[0], src->s6_addr32[1],
2179
2179
src->s6_addr32[2], src->s6_addr32[3], srcp,
+1
-1
net/key/af_key.c
+1
-1
net/key/af_key.c
···
3804
3804
if (v == SEQ_START_TOKEN)
3805
3805
seq_printf(f ,"sk RefCnt Rmem Wmem User Inode\n");
3806
3806
else
3807
-
seq_printf(f, "%pK %-6d %-6u %-6u %-6u %-6lu\n",
3807
+
seq_printf(f, "%pK %-6d %-6u %-6u %-6u %-6llu\n",
3808
3808
s,
3809
3809
refcount_read(&s->sk_refcnt),
3810
3810
sk_rmem_alloc_get(s),
+1
-1
net/netlink/af_netlink.c
+1
-1
net/netlink/af_netlink.c
···
2700
2700
struct sock *s = v;
2701
2701
struct netlink_sock *nlk = nlk_sk(s);
2702
2702
2703
-
seq_printf(seq, "%pK %-3d %-10u %08x %-8d %-8d %-5d %-8d %-8u %-8lu\n",
2703
+
seq_printf(seq, "%pK %-3d %-10u %08x %-8d %-8d %-5d %-8d %-8u %-8llu\n",
2704
2704
s,
2705
2705
s->sk_protocol,
2706
2706
nlk->portid,
+1
-1
net/netlink/diag.c
+1
-1
net/netlink/diag.c
+2
-2
net/netrom/af_netrom.c
+2
-2
net/netrom/af_netrom.c
···
1305
1305
seq_printf(seq, "%-9s ", ax2asc(buf, &nr->user_addr));
1306
1306
seq_printf(seq, "%-9s ", ax2asc(buf, &nr->dest_addr));
1307
1307
seq_printf(seq,
1308
-
"%-9s %-3s %02X/%02X %02X/%02X %2d %3d %3d %3d %3lu/%03lu %2lu/%02lu %3lu/%03lu %3lu/%03lu %2d/%02d %3d %5d %5d %ld\n",
1308
+
"%-9s %-3s %02X/%02X %02X/%02X %2d %3d %3d %3d %3lu/%03lu %2lu/%02lu %3lu/%03lu %3lu/%03lu %2d/%02d %3d %5d %5d %llu\n",
1309
1309
ax2asc(buf, &nr->source_addr),
1310
1310
devname,
1311
1311
nr->my_index,
···
1329
1329
nr->window,
1330
1330
sk_wmem_alloc_get(s),
1331
1331
sk_rmem_alloc_get(s),
1332
-
s->sk_socket ? SOCK_INODE(s->sk_socket)->i_ino : 0L);
1332
+
s->sk_socket ? SOCK_INODE(s->sk_socket)->i_ino : (u64)0);
1333
1333
1334
1334
bh_unlock_sock(s);
1335
1335
}
+1
-1
net/packet/af_packet.c
+1
-1
net/packet/af_packet.c
+1
-1
net/packet/diag.c
+1
-1
net/packet/diag.c
+2
-2
net/phonet/socket.c
+2
-2
net/phonet/socket.c
···
579
579
struct sock *sk = v;
580
580
struct pn_sock *pn = pn_sk(sk);
581
581
582
-
seq_printf(seq, "%2d %04X:%04X:%02X %02X %08X:%08X %5d %lu "
582
+
seq_printf(seq, "%2d %04X:%04X:%02X %02X %08X:%08X %5d %llu "
583
583
"%d %pK %u",
584
584
sk->sk_protocol, pn->sobject, pn->dobject,
585
585
pn->resource, sk->sk_state,
···
754
754
struct sock *sk = rcu_dereference_protected(*psk,
755
755
lockdep_is_held(&resource_mutex));
756
756
757
-
seq_printf(seq, "%02X %5u %lu",
757
+
seq_printf(seq, "%02X %5u %llu",
758
758
(int) (psk - pnres.sk),
759
759
from_kuid_munged(seq_user_ns(seq), sk_uid(sk)),
760
760
sock_i_ino(sk));
+2
-2
net/rose/af_rose.c
+2
-2
net/rose/af_rose.c
···
1484
1484
callsign = ax2asc(buf, &rose->source_call);
1485
1485
1486
1486
seq_printf(seq,
1487
-
"%-10s %-9s %-5s %3.3X %05d %d %d %d %d %3lu %3lu %3lu %3lu %3lu %3lu/%03lu %5d %5d %ld\n",
1487
+
"%-10s %-9s %-5s %3.3X %05d %d %d %d %d %3lu %3lu %3lu %3lu %3lu %3lu/%03lu %5d %5d %llu\n",
1488
1488
rose2asc(rsbuf, &rose->source_addr),
1489
1489
callsign,
1490
1490
devname,
···
1503
1503
rose->idle / (60 * HZ),
1504
1504
sk_wmem_alloc_get(s),
1505
1505
sk_rmem_alloc_get(s),
1506
-
s->sk_socket ? SOCK_INODE(s->sk_socket)->i_ino : 0L);
1506
+
s->sk_socket ? SOCK_INODE(s->sk_socket)->i_ino : (u64)0);
1507
1507
}
1508
1508
1509
1509
return 0;
+2
-2
net/sctp/proc.c
+2
-2
net/sctp/proc.c
···
174
174
sk = ep->base.sk;
175
175
if (!net_eq(sock_net(sk), seq_file_net(seq)))
176
176
continue;
177
-
seq_printf(seq, "%8pK %8pK %-3d %-3d %-4d %-5d %5u %5lu ", ep, sk,
177
+
seq_printf(seq, "%8pK %8pK %-3d %-3d %-4d %-5d %5u %5llu ", ep, sk,
178
178
sctp_sk(sk)->type, sk->sk_state, hash,
179
179
ep->base.bind_addr.port,
180
180
from_kuid_munged(seq_user_ns(seq), sk_uid(sk)),
···
261
261
262
262
seq_printf(seq,
263
263
"%8pK %8pK %-3d %-3d %-2d %-4d "
264
-
"%4d %8d %8d %7u %5lu %-5d %5d ",
264
+
"%4d %8d %8d %7u %5llu %-5d %5d ",
265
265
assoc, sk, sctp_sk(sk)->type, sk->sk_state,
266
266
assoc->state, 0,
267
267
assoc->assoc_id,
+1
-1
net/socket.c
+1
-1
net/socket.c
+1
-1
net/unix/af_unix.c
+1
-1
net/unix/af_unix.c
+3
-3
net/unix/diag.c
+3
-3
net/unix/diag.c
···
50
50
static int sk_diag_dump_peer(struct sock *sk, struct sk_buff *nlskb)
51
51
{
52
52
struct sock *peer;
53
-
int ino;
53
+
u64 ino;
54
54
55
55
peer = unix_peer_get(sk);
56
56
if (peer) {
···
117
117
118
118
static int sk_diag_fill(struct sock *sk, struct sk_buff *skb, struct unix_diag_req *req,
119
119
struct user_namespace *user_ns,
120
-
u32 portid, u32 seq, u32 flags, int sk_ino)
120
+
u32 portid, u32 seq, u32 flags, u64 sk_ino)
121
121
{
122
122
struct nlmsghdr *nlh;
123
123
struct unix_diag_msg *rep;
···
191
191
num = 0;
192
192
spin_lock(&net->unx.table.locks[slot]);
193
193
sk_for_each(sk, &net->unx.table.buckets[slot]) {
194
-
int sk_ino;
194
+
u64 sk_ino;
195
195
196
196
if (num < s_num)
197
197
goto next;
+2
-2
net/x25/x25_proc.c
+2
-2
net/x25/x25_proc.c
···
96
96
devname = x25->neighbour->dev->name;
97
97
98
98
seq_printf(seq, "%-10s %-10s %-5s %3.3X %d %d %d %d %3lu %3lu "
99
-
"%3lu %3lu %3lu %5d %5d %ld\n",
99
+
"%3lu %3lu %3lu %5d %5d %llu\n",
100
100
!x25->dest_addr.x25_addr[0] ? "*" : x25->dest_addr.x25_addr,
101
101
!x25->source_addr.x25_addr[0] ? "*" : x25->source_addr.x25_addr,
102
102
devname, x25->lci & 0x0FFF, x25->state, x25->vs, x25->vr,
···
104
104
x25->t21 / HZ, x25->t22 / HZ, x25->t23 / HZ,
105
105
sk_wmem_alloc_get(s),
106
106
sk_rmem_alloc_get(s),
107
-
s->sk_socket ? SOCK_INODE(s->sk_socket)->i_ino : 0L);
107
+
s->sk_socket ? SOCK_INODE(s->sk_socket)->i_ino : (u64)0);
108
108
out:
109
109
return 0;
110
110
}
+1
-1
net/xdp/xsk_diag.c
+1
-1
net/xdp/xsk_diag.c
···
92
92
static int xsk_diag_fill(struct sock *sk, struct sk_buff *nlskb,
93
93
struct xdp_diag_req *req,
94
94
struct user_namespace *user_ns,
95
-
u32 portid, u32 seq, u32 flags, int sk_ino)
95
+
u32 portid, u32 seq, u32 flags, u64 sk_ino)
96
96
{
97
97
struct xdp_sock *xs = xdp_sk(sk);
98
98
struct xdp_diag_msg *msg;
+2
-2
security/apparmor/apparmorfs.c
+2
-2
security/apparmor/apparmorfs.c
···
151
151
152
152
static int aafs_show_path(struct seq_file *seq, struct dentry *dentry)
153
153
{
154
-
seq_printf(seq, "%s:[%lu]", AAFS_NAME, d_inode(dentry)->i_ino);
154
+
seq_printf(seq, "%s:[%llu]", AAFS_NAME, d_inode(dentry)->i_ino);
155
155
return 0;
156
156
}
157
157
···
2669
2669
char name[32];
2670
2670
int res;
2671
2671
2672
-
res = snprintf(name, sizeof(name), "%s:[%lu]", AAFS_NAME,
2672
+
res = snprintf(name, sizeof(name), "%s:[%llu]", AAFS_NAME,
2673
2673
d_inode(dentry)->i_ino);
2674
2674
if (res > 0 && res < sizeof(name))
2675
2675
res = readlink_copy(buffer, buflen, name, strlen(name));
+6
security/integrity/evm/evm_crypto.c
+6
security/integrity/evm/evm_crypto.c
···
144
144
char type, char *digest)
145
145
{
146
146
struct h_misc {
147
+
/*
148
+
* Although inode->i_ino is now u64, this field remains
149
+
* unsigned long to allow existing HMAC and signatures from
150
+
* 32-bit hosts to continue working when i_ino hasn't changed
151
+
* and fits in a u32.
152
+
*/
147
153
unsigned long ino;
148
154
__u32 generation;
149
155
uid_t uid;
+1
-1
security/integrity/integrity_audit.c
+1
-1
security/integrity/integrity_audit.c
···
62
62
if (inode) {
63
63
audit_log_format(ab, " dev=");
64
64
audit_log_untrustedstring(ab, inode->i_sb->s_id);
65
-
audit_log_format(ab, " ino=%lu", inode->i_ino);
65
+
audit_log_format(ab, " ino=%llu", inode->i_ino);
66
66
}
67
67
audit_log_format(ab, " res=%d errno=%d", !result, errno);
68
68
audit_log_end(ab);
+1
-1
security/ipe/audit.c
+1
-1
security/ipe/audit.c
···
153
153
if (inode) {
154
154
audit_log_format(ab, " dev=");
155
155
audit_log_untrustedstring(ab, inode->i_sb->s_id);
156
-
audit_log_format(ab, " ino=%lu", inode->i_ino);
156
+
audit_log_format(ab, " ino=%llu", inode->i_ino);
157
157
} else {
158
158
audit_log_format(ab, " dev=? ino=?");
159
159
}
+5
-5
security/lsm_audit.c
+5
-5
security/lsm_audit.c
···
202
202
if (inode) {
203
203
audit_log_format(ab, " dev=");
204
204
audit_log_untrustedstring(ab, inode->i_sb->s_id);
205
-
audit_log_format(ab, " ino=%lu", inode->i_ino);
205
+
audit_log_format(ab, " ino=%llu", inode->i_ino);
206
206
}
207
207
break;
208
208
}
···
215
215
if (inode) {
216
216
audit_log_format(ab, " dev=");
217
217
audit_log_untrustedstring(ab, inode->i_sb->s_id);
218
-
audit_log_format(ab, " ino=%lu", inode->i_ino);
218
+
audit_log_format(ab, " ino=%llu", inode->i_ino);
219
219
}
220
220
break;
221
221
}
···
228
228
if (inode) {
229
229
audit_log_format(ab, " dev=");
230
230
audit_log_untrustedstring(ab, inode->i_sb->s_id);
231
-
audit_log_format(ab, " ino=%lu", inode->i_ino);
231
+
audit_log_format(ab, " ino=%llu", inode->i_ino);
232
232
}
233
233
234
234
audit_log_format(ab, " ioctlcmd=0x%hx", a->u.op->cmd);
···
246
246
if (inode) {
247
247
audit_log_format(ab, " dev=");
248
248
audit_log_untrustedstring(ab, inode->i_sb->s_id);
249
-
audit_log_format(ab, " ino=%lu", inode->i_ino);
249
+
audit_log_format(ab, " ino=%llu", inode->i_ino);
250
250
}
251
251
break;
252
252
}
···
265
265
}
266
266
audit_log_format(ab, " dev=");
267
267
audit_log_untrustedstring(ab, inode->i_sb->s_id);
268
-
audit_log_format(ab, " ino=%lu", inode->i_ino);
268
+
audit_log_format(ab, " ino=%llu", inode->i_ino);
269
269
rcu_read_unlock();
270
270
break;
271
271
}
+5
-5
security/selinux/hooks.c
+5
-5
security/selinux/hooks.c
···
1400
1400
if (rc < 0) {
1401
1401
kfree(context);
1402
1402
if (rc != -ENODATA) {
1403
-
pr_warn("SELinux: %s: getxattr returned %d for dev=%s ino=%ld\n",
1403
+
pr_warn("SELinux: %s: getxattr returned %d for dev=%s ino=%llu\n",
1404
1404
__func__, -rc, inode->i_sb->s_id, inode->i_ino);
1405
1405
return rc;
1406
1406
}
···
1412
1412
def_sid, GFP_NOFS);
1413
1413
if (rc) {
1414
1414
char *dev = inode->i_sb->s_id;
1415
-
unsigned long ino = inode->i_ino;
1415
+
u64 ino = inode->i_ino;
1416
1416
1417
1417
if (rc == -EINVAL) {
1418
-
pr_notice_ratelimited("SELinux: inode=%lu on dev=%s was found to have an invalid context=%s. This indicates you may need to relabel the inode or the filesystem in question.\n",
1418
+
pr_notice_ratelimited("SELinux: inode=%llu on dev=%s was found to have an invalid context=%s. This indicates you may need to relabel the inode or the filesystem in question.\n",
1419
1419
ino, dev, context);
1420
1420
} else {
1421
-
pr_warn("SELinux: %s: context_to_sid(%s) returned %d for dev=%s ino=%ld\n",
1421
+
pr_warn("SELinux: %s: context_to_sid(%s) returned %d for dev=%s ino=%llu\n",
1422
1422
__func__, context, -rc, dev, ino);
1423
1423
}
1424
1424
}
···
3477
3477
&newsid);
3478
3478
if (rc) {
3479
3479
pr_err("SELinux: unable to map context to SID"
3480
-
"for (%s, %lu), rc=%d\n",
3480
+
"for (%s, %llu), rc=%d\n",
3481
3481
inode->i_sb->s_id, inode->i_ino, -rc);
3482
3482
return;
3483
3483
}
+6
-6
security/smack/smack_lsm.c
+6
-6
security/smack/smack_lsm.c
···
182
182
char acc[SMK_NUM_ACCESS_TYPE + 1];
183
183
184
184
if (isp->smk_flags & SMK_INODE_IMPURE)
185
-
pr_info("Smack Unconfined Corruption: inode=(%s %ld) %s\n",
185
+
pr_info("Smack Unconfined Corruption: inode=(%s %llu) %s\n",
186
186
inode->i_sb->s_id, inode->i_ino, current->comm);
187
187
188
188
if (rc <= 0)
···
195
195
196
196
smk_bu_mode(mode, acc);
197
197
198
-
pr_info("Smack %s: (%s %s %s) inode=(%s %ld) %s\n", smk_bu_mess[rc],
198
+
pr_info("Smack %s: (%s %s %s) inode=(%s %llu) %s\n", smk_bu_mess[rc],
199
199
tsp->smk_task->smk_known, isp->smk_inode->smk_known, acc,
200
200
inode->i_sb->s_id, inode->i_ino, current->comm);
201
201
return 0;
···
214
214
char acc[SMK_NUM_ACCESS_TYPE + 1];
215
215
216
216
if (isp->smk_flags & SMK_INODE_IMPURE)
217
-
pr_info("Smack Unconfined Corruption: inode=(%s %ld) %s\n",
217
+
pr_info("Smack Unconfined Corruption: inode=(%s %llu) %s\n",
218
218
inode->i_sb->s_id, inode->i_ino, current->comm);
219
219
220
220
if (rc <= 0)
···
223
223
rc = 0;
224
224
225
225
smk_bu_mode(mode, acc);
226
-
pr_info("Smack %s: (%s %s %s) file=(%s %ld %pD) %s\n", smk_bu_mess[rc],
226
+
pr_info("Smack %s: (%s %s %s) file=(%s %llu %pD) %s\n", smk_bu_mess[rc],
227
227
sskp->smk_known, smk_of_inode(inode)->smk_known, acc,
228
228
inode->i_sb->s_id, inode->i_ino, file,
229
229
current->comm);
···
244
244
char acc[SMK_NUM_ACCESS_TYPE + 1];
245
245
246
246
if (isp->smk_flags & SMK_INODE_IMPURE)
247
-
pr_info("Smack Unconfined Corruption: inode=(%s %ld) %s\n",
247
+
pr_info("Smack Unconfined Corruption: inode=(%s %llu) %s\n",
248
248
inode->i_sb->s_id, inode->i_ino, current->comm);
249
249
250
250
if (rc <= 0)
···
253
253
rc = 0;
254
254
255
255
smk_bu_mode(mode, acc);
256
-
pr_info("Smack %s: (%s %s %s) file=(%s %ld %pD) %s\n", smk_bu_mess[rc],
256
+
pr_info("Smack %s: (%s %s %s) file=(%s %llu %pD) %s\n", smk_bu_mess[rc],
257
257
sskp->smk_known, smk_of_inode(inode)->smk_known, acc,
258
258
inode->i_sb->s_id, inode->i_ino, file,
259
259
current->comm);