spin_lock(&buf_obj->name_lock);
- seq_printf(s, "%08zu\t%08x\t%08x\t%08ld\t%s\t%08lu\t%s\n",
+ seq_printf(s, "%08zu\t%08x\t%08x\t%08ld\t%s\t%08llu\t%s\n",
buf_obj->size,
buf_obj->file->f_flags, buf_obj->file->f_mode,
file_count(buf_obj->file),
attachment = READ_ONCE(bo->tbo.base.import_attach);
if (attachment)
- seq_printf(m, " imported from ino:%lu", file_inode(dma_buf->file)->i_ino);
+ seq_printf(m, " imported from ino:%llu", file_inode(dma_buf->file)->i_ino);
else if (dma_buf)
- seq_printf(m, " exported as ino:%lu", file_inode(dma_buf->file)->i_ino);
+ seq_printf(m, " exported as ino:%llu", file_inode(dma_buf->file)->i_ino);
amdgpu_bo_print_flag(m, bo, CPU_ACCESS_REQUIRED);
amdgpu_bo_print_flag(m, bo, NO_CPU_ACCESS);
fid = v9fs_fid_find_inode(wreq->inode, true, INVALID_UID, true);
if (!fid) {
- WARN_ONCE(1, "folio expected an open fid inode->i_ino=%lx\n",
+ WARN_ONCE(1, "folio expected an open fid inode->i_ino=%llx\n",
wreq->inode->i_ino);
return;
}
return 0;
no_fid:
- WARN_ONCE(1, "folio expected an open fid inode->i_ino=%lx\n",
+ WARN_ONCE(1, "folio expected an open fid inode->i_ino=%llx\n",
rreq->inode->i_ino);
return -EINVAL;
}
v9fs_vfs_symlink(struct mnt_idmap *idmap, struct inode *dir,
struct dentry *dentry, const char *symname)
{
- p9_debug(P9_DEBUG_VFS, " %lu,%pd,%s\n",
+ p9_debug(P9_DEBUG_VFS, " %llu,%pd,%s\n",
dir->i_ino, dentry, symname);
return v9fs_vfs_mkspecial(dir, dentry, P9_DMSYMLINK, symname);
char name[1 + U32_MAX_DIGITS + 2]; /* sign + number + \n + \0 */
struct p9_fid *oldfid;
- p9_debug(P9_DEBUG_VFS, " %lu,%pd,%pd\n",
+ p9_debug(P9_DEBUG_VFS, " %llu,%pd,%pd\n",
dir->i_ino, dentry, old_dentry);
oldfid = v9fs_fid_clone(old_dentry);
char name[2 + U32_MAX_DIGITS + 1 + U32_MAX_DIGITS + 1];
u32 perm;
- p9_debug(P9_DEBUG_VFS, " %lu,%pd mode: %x MAJOR: %u MINOR: %u\n",
+ p9_debug(P9_DEBUG_VFS, " %llu,%pd mode: %x MAJOR: %u MINOR: %u\n",
dir->i_ino, dentry, mode,
MAJOR(rdev), MINOR(rdev));
struct p9_fid *fid = NULL;
name = dentry->d_name.name;
- p9_debug(P9_DEBUG_VFS, "%lu,%s,%s\n", dir->i_ino, name, symname);
+ p9_debug(P9_DEBUG_VFS, "%llu,%s,%s\n", dir->i_ino, name, symname);
dfid = v9fs_parent_fid(dentry);
if (IS_ERR(dfid)) {
struct p9_fid *dfid, *oldfid;
struct v9fs_session_info *v9ses;
- p9_debug(P9_DEBUG_VFS, "dir ino: %lu, old_name: %pd, new_name: %pd\n",
+ p9_debug(P9_DEBUG_VFS, "dir ino: %llu, old_name: %pd, new_name: %pd\n",
dir->i_ino, old_dentry, dentry);
v9ses = v9fs_inode2v9ses(dir);
struct p9_qid qid;
struct posix_acl *dacl = NULL, *pacl = NULL;
- p9_debug(P9_DEBUG_VFS, " %lu,%pd mode: %x MAJOR: %u MINOR: %u\n",
+ p9_debug(P9_DEBUG_VFS, " %llu,%pd mode: %x MAJOR: %u MINOR: %u\n",
dir->i_ino, dentry, omode,
MAJOR(rdev), MINOR(rdev));
ino = bh->b_blocknr;
offset = affs_hash_name(sb, AFFS_TAIL(sb, bh)->name + 1, AFFS_TAIL(sb, bh)->name[0]);
- pr_debug("%s(dir=%lu, ino=%d)\n", __func__, dir->i_ino, ino);
+ pr_debug("%s(dir=%llu, ino=%d)\n", __func__, dir->i_ino, ino);
dir_bh = affs_bread(sb, dir->i_ino);
if (!dir_bh)
sb = dir->i_sb;
rem_ino = rem_bh->b_blocknr;
offset = affs_hash_name(sb, AFFS_TAIL(sb, rem_bh)->name+1, AFFS_TAIL(sb, rem_bh)->name[0]);
- pr_debug("%s(dir=%lu, ino=%d, hashval=%d)\n", __func__, dir->i_ino,
+ pr_debug("%s(dir=%llu, ino=%d, hashval=%d)\n", __func__, dir->i_ino,
rem_ino, offset);
bh = affs_bread(sb, dir->i_ino);
spin_lock(&inode->i_lock);
hlist_for_each_entry(dentry, &inode->i_dentry, d_u.d_alias) {
if (entry_ino == (u32)(long)dentry->d_fsdata) {
- dentry->d_fsdata = (void *)inode->i_ino;
+ dentry->d_fsdata = (void *)(unsigned long)inode->i_ino;
break;
}
}
u32 link_ino, ino;
int retval;
- pr_debug("%s(key=%ld)\n", __func__, inode->i_ino);
+ pr_debug("%s(key=%llu)\n", __func__, inode->i_ino);
retval = -EIO;
bh = affs_bread(sb, inode->i_ino);
if (!bh)
if (!inode)
goto done;
- pr_debug("%s(key=%ld)\n", __func__, inode->i_ino);
+ pr_debug("%s(key=%llu)\n", __func__, inode->i_ino);
retval = -EIO;
bh = affs_bread(sb, (u32)(long)dentry->d_fsdata);
if (!bh)
sb = inode->i_sb;
sbi = AFFS_SB(sb);
- pr_debug("balloc(inode=%lu,goal=%u): ", inode->i_ino, goal);
+ pr_debug("balloc(inode=%llu,goal=%u): ", inode->i_ino, goal);
if (AFFS_I(inode)->i_pa_cnt) {
pr_debug("%d\n", AFFS_I(inode)->i_lastalloc+1);
u32 ino;
int error = 0;
- pr_debug("%s(ino=%lu,f_pos=%llx)\n", __func__, inode->i_ino, ctx->pos);
+ pr_debug("%s(ino=%llu,f_pos=%llx)\n", __func__, inode->i_ino, ctx->pos);
if (ctx->pos < 2) {
data->ino = 0;
static int
affs_file_open(struct inode *inode, struct file *filp)
{
- pr_debug("open(%lu,%d)\n",
+ pr_debug("open(%llu,%d)\n",
inode->i_ino, atomic_read(&AFFS_I(inode)->i_opencnt));
atomic_inc(&AFFS_I(inode)->i_opencnt);
return 0;
static int
affs_file_release(struct inode *inode, struct file *filp)
{
- pr_debug("release(%lu, %d)\n",
+ pr_debug("release(%llu, %d)\n",
inode->i_ino, atomic_read(&AFFS_I(inode)->i_opencnt));
if (atomic_dec_and_test(&AFFS_I(inode)->i_opencnt)) {
struct buffer_head *ext_bh;
u32 ext;
- pr_debug("%s(%lu, %llu)\n", __func__, inode->i_ino,
+ pr_debug("%s(%llu, %llu)\n", __func__, inode->i_ino,
(unsigned long long)block);
BUG_ON(block > (sector_t)0x7fffffffUL);
size_t bidx, boff, bsize;
u32 tmp;
- pr_debug("%s(%lu, %ld, 0, %zu)\n", __func__, inode->i_ino,
+ pr_debug("%s(%llu, %ld, 0, %zu)\n", __func__, inode->i_ino,
folio->index, to);
BUG_ON(to > folio_size(folio));
bsize = AFFS_SB(sb)->s_data_blksize;
u32 size, bsize;
u32 tmp;
- pr_debug("%s(%lu, %d)\n", __func__, inode->i_ino, newsize);
+ pr_debug("%s(%llu, %d)\n", __func__, inode->i_ino, newsize);
bsize = AFFS_SB(sb)->s_data_blksize;
bh = NULL;
size = AFFS_I(inode)->mmu_private;
size_t to;
int err;
- pr_debug("%s(%lu, %ld)\n", __func__, inode->i_ino, folio->index);
+ pr_debug("%s(%llu, %ld)\n", __func__, inode->i_ino, folio->index);
to = folio_size(folio);
if (folio_pos(folio) + to > inode->i_size) {
to = inode->i_size - folio_pos(folio);
pgoff_t index;
int err = 0;
- pr_debug("%s(%lu, %llu, %llu)\n", __func__, inode->i_ino, pos,
+ pr_debug("%s(%llu, %llu, %llu)\n", __func__, inode->i_ino, pos,
pos + len);
if (pos > AFFS_I(inode)->mmu_private) {
/* XXX: this probably leaves a too-big i_size in case of
* due to write_begin.
*/
- pr_debug("%s(%lu, %llu, %llu)\n", __func__, inode->i_ino, pos,
+ pr_debug("%s(%llu, %llu, %llu)\n", __func__, inode->i_ino, pos,
pos + len);
bsize = AFFS_SB(sb)->s_data_blksize;
data = folio_address(folio);
{
struct super_block *sb = inode->i_sb;
- pr_debug("free_prealloc(ino=%lu)\n", inode->i_ino);
+ pr_debug("free_prealloc(ino=%llu)\n", inode->i_ino);
while (AFFS_I(inode)->i_pa_cnt) {
AFFS_I(inode)->i_pa_cnt--;
struct buffer_head *ext_bh;
int i;
- pr_debug("truncate(inode=%lu, oldsize=%llu, newsize=%llu)\n",
+ pr_debug("truncate(inode=%llu, oldsize=%llu, newsize=%llu)\n",
inode->i_ino, AFFS_I(inode)->mmu_private, inode->i_size);
last_blk = 0;
if (!(inode_state_read_once(inode) & I_NEW))
return inode;
- pr_debug("affs_iget(%lu)\n", inode->i_ino);
+ pr_debug("affs_iget(%llu)\n", inode->i_ino);
block = inode->i_ino;
bh = affs_bread(sb, block);
uid_t uid;
gid_t gid;
- pr_debug("write_inode(%lu)\n", inode->i_ino);
+ pr_debug("write_inode(%llu)\n", inode->i_ino);
if (!inode->i_nlink)
// possibly free block
return 0;
bh = affs_bread(sb, inode->i_ino);
if (!bh) {
- affs_error(sb,"write_inode","Cannot read block %lu",inode->i_ino);
+ affs_error(sb, "write_inode", "Cannot read block %llu", inode->i_ino);
return -EIO;
}
tail = AFFS_TAIL(sb, bh);
struct inode *inode = d_inode(dentry);
int error;
- pr_debug("notify_change(%lu,0x%x)\n", inode->i_ino, attr->ia_valid);
+ pr_debug("notify_change(%llu,0x%x)\n", inode->i_ino, attr->ia_valid);
error = setattr_prepare(&nop_mnt_idmap, dentry, attr);
if (error)
affs_evict_inode(struct inode *inode)
{
unsigned long cache_page;
- pr_debug("evict_inode(ino=%lu, nlink=%u)\n",
+ pr_debug("evict_inode(ino=%llu, nlink=%u)\n",
inode->i_ino, inode->i_nlink);
truncate_inode_pages_final(&inode->i_data);
u32 block = 0;
int retval;
- pr_debug("%s(dir=%lu, inode=%lu, \"%pd\", type=%d)\n", __func__,
+ pr_debug("%s(dir=%llu, inode=%llu, \"%pd\", type=%d)\n", __func__,
dir->i_ino, inode->i_ino, dentry, type);
retval = -EIO;
int
affs_unlink(struct inode *dir, struct dentry *dentry)
{
- pr_debug("%s(dir=%lu, %lu \"%pd\")\n", __func__, dir->i_ino,
+ pr_debug("%s(dir=%llu, %llu \"%pd\")\n", __func__, dir->i_ino,
d_inode(dentry)->i_ino, dentry);
return affs_remove_header(dentry);
struct inode *inode;
int error;
- pr_debug("%s(%lu,\"%pd\",0%ho)\n",
+ pr_debug("%s(%llu,\"%pd\",0%ho)\n",
__func__, dir->i_ino, dentry, mode);
inode = affs_new_inode(dir);
struct inode *inode;
int error;
- pr_debug("%s(%lu,\"%pd\",0%ho)\n",
+ pr_debug("%s(%llu,\"%pd\",0%ho)\n",
__func__, dir->i_ino, dentry, mode);
inode = affs_new_inode(dir);
int
affs_rmdir(struct inode *dir, struct dentry *dentry)
{
- pr_debug("%s(dir=%lu, %lu \"%pd\")\n", __func__, dir->i_ino,
+ pr_debug("%s(dir=%llu, %llu \"%pd\")\n", __func__, dir->i_ino,
d_inode(dentry)->i_ino, dentry);
return affs_remove_header(dentry);
int i, maxlen, error;
char c, lc;
- pr_debug("%s(%lu,\"%pd\" -> \"%s\")\n",
+ pr_debug("%s(%llu,\"%pd\" -> \"%s\")\n",
__func__, dir->i_ino, dentry, symname);
maxlen = AFFS_SB(sb)->s_hashsize * sizeof(u32) - 1;
{
struct inode *inode = d_inode(old_dentry);
- pr_debug("%s(%lu, %lu, \"%pd\")\n", __func__, inode->i_ino, dir->i_ino,
+ pr_debug("%s(%llu, %llu, \"%pd\")\n", __func__, inode->i_ino, dir->i_ino,
dentry);
return affs_add_entry(dir, inode, dentry, ST_LINKFILE);
if (flags & ~(RENAME_NOREPLACE | RENAME_EXCHANGE))
return -EINVAL;
- pr_debug("%s(old=%lu,\"%pd\" to new=%lu,\"%pd\")\n", __func__,
+ pr_debug("%s(old=%llu,\"%pd\" to new=%llu,\"%pd\")\n", __func__,
old_dir->i_ino, old_dentry, new_dir->i_ino, new_dentry);
if (flags & RENAME_EXCHANGE)
char c;
char lc;
- pr_debug("get_link(ino=%lu)\n", inode->i_ino);
+ pr_debug("get_link(ino=%llu)\n", inode->i_ino);
bh = affs_bread(inode->i_sb, inode->i_ino);
if (!bh)
union afs_xdr_dir_block *block)
{
if (block->hdr.magic != AFS_DIR_MAGIC) {
- pr_warn("%s(%lx): [%zx] bad magic %04x\n",
+ pr_warn("%s(%llx): [%zx] bad magic %04x\n",
__func__, dvnode->netfs.inode.i_ino,
progress, ntohs(block->hdr.magic));
trace_afs_dir_check_failed(dvnode, progress);
*/
static int afs_dir_open(struct inode *inode, struct file *file)
{
- _enter("{%lu}", inode->i_ino);
+ _enter("{%llu}", inode->i_ino);
BUILD_BUG_ON(sizeof(union afs_xdr_dir_block) != 2048);
BUILD_BUG_ON(sizeof(union afs_xdr_dirent) != 32);
int retry_limit = 100;
int ret;
- _enter("{%lu},%llx,,", dir->i_ino, ctx->pos);
+ _enter("{%llu},%llx,,", dir->i_ino, ctx->pos);
do {
if (--retry_limit < 0) {
};
int ret;
- _enter("{%lu},{%.*s},", dir->i_ino, name->len, name->name);
+ _enter("{%llu},{%.*s},", dir->i_ino, name->len, name->name);
/* search the directory */
ret = afs_dir_iterate(dir, &cookie.ctx, NULL, _dir_version);
long ret;
int i;
- _enter("{%lu},%p{%pd},", dir->i_ino, dentry, dentry);
+ _enter("{%llu},%p{%pd},", dir->i_ino, dentry, dentry);
cookie = kzalloc_obj(struct afs_lookup_cookie);
if (!cookie)
struct afs_dir_iter iter = { .dvnode = dvnode, };
int ret, retry_limit = 3;
- _enter("{%lu},,,", dvnode->netfs.inode.i_ino);
+ _enter("{%llu},,,", dvnode->netfs.inode.i_ino);
if (!afs_dir_init_iter(&iter, name))
return -ENOENT;
return ERR_PTR(-ENOMEM);
}
- _debug("GOT INODE %p { ino=%lu, vl=%llx, vn=%llx, u=%x }",
+ _debug("GOT INODE %p { ino=%llu, vl=%llx, vn=%llx, u=%x }",
inode, inode->i_ino, fid.vid, fid.vnode, fid.unique);
vnode = AFS_FS_I(inode);
struct key *key;
int ret, seq;
- _enter("{ ino=%lu v=%u }", inode->i_ino, inode->i_generation);
+ _enter("{ ino=%llu v=%u }", inode->i_ino, inode->i_generation);
if (vnode->volume &&
!(query_flags & AT_STATX_DONT_SYNC) &&
seq_puts(m, ",ignore");
#ifdef CONFIG_CHECKPOINT_RESTORE
if (sbi->pipe)
- seq_printf(m, ",pipe_ino=%ld", file_inode(sbi->pipe)->i_ino);
+ seq_printf(m, ",pipe_ino=%llu", file_inode(sbi->pipe)->i_ino);
else
seq_puts(m, ",pipe_ino=-1");
#endif
int res;
ulong disk_off;
- befs_debug(sb, "---> befs_get_block() for inode %lu, block %ld",
- (unsigned long)inode->i_ino, (long)block);
+ befs_debug(sb, "---> befs_get_block() for inode %llu, block %ld",
+ inode->i_ino, (long)block);
if (create) {
befs_error(sb, "befs_get_block() was asked to write to "
- "block %ld in inode %lu", (long)block,
- (unsigned long)inode->i_ino);
+ "block %ld in inode %llu", (long)block,
+ inode->i_ino);
return -EPERM;
}
res = befs_fblock2brun(sb, ds, block, &run);
if (res != BEFS_OK) {
befs_error(sb,
- "<--- %s for inode %lu, block %ld ERROR",
- __func__, (unsigned long)inode->i_ino,
+ "<--- %s for inode %llu, block %ld ERROR",
+ __func__, inode->i_ino,
(long)block);
return -EFBIG;
}
map_bh(bh_result, inode->i_sb, disk_off);
- befs_debug(sb, "<--- %s for inode %lu, block %ld, disk address %lu",
- __func__, (unsigned long)inode->i_ino, (long)block,
+ befs_debug(sb, "<--- %s for inode %llu, block %ld, disk address %lu",
+ __func__, inode->i_ino, (long)block,
(unsigned long)disk_off);
return 0;
char *utfname;
const char *name = dentry->d_name.name;
- befs_debug(sb, "---> %s name %pd inode %ld", __func__,
+ befs_debug(sb, "---> %s name %pd inode %llu", __func__,
dentry, dir->i_ino);
/* Convert to UTF-8 */
size_t keysize;
char keybuf[BEFS_NAME_LEN + 1];
- befs_debug(sb, "---> %s name %pD, inode %ld, ctx->pos %lld",
+ befs_debug(sb, "---> %s name %pD, inode %llu, ctx->pos %lld",
__func__, file, inode->i_ino, ctx->pos);
while (1) {
if (result == BEFS_ERR) {
befs_debug(sb, "<--- %s ERROR", __func__);
- befs_error(sb, "IO error reading %pD (inode %lu)",
+ befs_error(sb, "IO error reading %pD (inode %llu)",
file, inode->i_ino);
return -EIO;
bh = sb_bread(sb, inode->i_ino);
if (!bh) {
befs_error(sb, "unable to read inode block - "
- "inode = %lu", inode->i_ino);
+ "inode = %llu", inode->i_ino);
goto unacquire_none;
}
befs_dump_inode(sb, raw_inode);
if (befs_check_inode(sb, raw_inode, inode->i_ino) != BEFS_OK) {
- befs_error(sb, "Bad inode: %lu", inode->i_ino);
+ befs_error(sb, "Bad inode: %llu", inode->i_ino);
goto unacquire_bh;
}
inode->i_op = &simple_symlink_inode_operations;
}
} else {
- befs_error(sb, "Inode %lu is not a regular file, "
+ befs_error(sb, "Inode %llu is not a regular file, "
"directory or symlink. THAT IS WRONG! BeFS has no "
"on disk special files", inode->i_ino);
goto unacquire_bh;
int block;
if (ctx->pos & (BFS_DIRENT_SIZE - 1)) {
- printf("Bad f_pos=%08lx for %s:%08lx\n",
+ printf("Bad f_pos=%08lx for %s:%08llx\n",
(unsigned long)ctx->pos,
dir->i_sb->s_id, dir->i_ino);
return -EINVAL;
goto out_brelse;
if (!inode->i_nlink) {
- printf("unlinking non-existent file %s:%lu (nlink=%d)\n",
+ printf("unlinking non-existent file %s:%llu (nlink=%d)\n",
inode->i_sb->s_id, inode->i_ino,
inode->i_nlink);
set_nlink(inode, 1);
object = cachefiles_cres_object(cres);
file = cachefiles_cres_file(cres);
- _enter("%pD,%li,%llx,%zx/%llx",
+ _enter("%pD,%llu,%llx,%zx/%llx",
file, file_inode(file)->i_ino, start_pos, len,
i_size_read(file_inode(file)));
file = cachefiles_cres_file(cres);
granularity = max_t(size_t, object->volume->cache->bsize, granularity);
- _enter("%pD,%li,%llx,%zx/%llx",
+ _enter("%pD,%llu,%llx,%zx/%llx",
file, file_inode(file)->i_ino, start, len,
i_size_read(file_inode(file)));
fscache_count_write();
cache = object->volume->cache;
- _enter("%pD,%li,%llx,%zx/%llx",
+ _enter("%pD,%llu,%llx,%zx/%llx",
file, file_inode(file)->i_ino, start_pos, len,
i_size_read(file_inode(file)));
}
ASSERT(d_backing_inode(subdir));
- _debug("mkdir -> %pd{ino=%lu}",
+ _debug("mkdir -> %pd{ino=%llu}",
subdir, d_backing_inode(subdir)->i_ino);
if (_is_new)
*_is_new = true;
end_creating_keep(subdir);
if (!__cachefiles_mark_inode_in_use(NULL, d_inode(subdir))) {
- pr_notice("cachefiles: Inode already in use: %pd (B=%lx)\n",
+ pr_notice("cachefiles: Inode already in use: %pd (B=%llx)\n",
subdir, d_inode(subdir)->i_ino);
goto mark_error;
}
!d_backing_inode(subdir)->i_op->unlink)
goto check_error;
- _leave(" = [%lu]", d_backing_inode(subdir)->i_ino);
+ _leave(" = [%llu]", d_backing_inode(subdir)->i_ino);
return subdir;
check_error:
set_bit(FSCACHE_COOKIE_NEEDS_UPDATE, &object->cookie->flags);
set_bit(CACHEFILES_OBJECT_USING_TMPFILE, &object->flags);
- _debug("create -> %pD{ino=%lu}", file, file_inode(file)->i_ino);
+ _debug("create -> %pD{ino=%llu}", file, file_inode(file)->i_ino);
object->file = file;
return true;
}
_enter("%pd", dentry);
if (!cachefiles_mark_inode_in_use(object, d_inode(dentry))) {
- pr_notice("cachefiles: Inode already in use: %pd (B=%lx)\n",
+ pr_notice("cachefiles: Inode already in use: %pd (B=%llx)\n",
dentry, d_inode(dentry)->i_ino);
return false;
}
if (!ret)
return false;
- _leave(" = t [%lu]", file_inode(object->file)->i_ino);
+ _leave(" = t [%llu]", file_inode(object->file)->i_ino);
return true;
new_file:
ret = 0;
else if (ret != -ENOMEM)
cachefiles_io_error(cache,
- "Can't remove xattr from %lu"
+ "Can't remove xattr from %llu"
" (error %d)",
d_backing_inode(dentry)->i_ino, -ret);
}
/* To understand the 240 limit, see CEPH_NOHASH_NAME_MAX comments */
WARN_ON(elen > 240);
if (dir != parent) // leading _ is already there; append _<inum>
- elen += 1 + sprintf(p + elen, "_%ld", dir->i_ino);
+ elen += 1 + sprintf(p + elen, "_%llu", dir->i_ino);
out:
kfree(cryptbuf);
if (!ret && (dir != fname->dir)) {
char tmp_buf[BASE64_CHARS(NAME_MAX)];
- name_len = snprintf(tmp_buf, sizeof(tmp_buf), "_%.*s_%ld",
+ name_len = snprintf(tmp_buf, sizeof(tmp_buf), "_%.*s_%llu",
oname->len, oname->name, dir->i_ino);
memcpy(oname->name, tmp_buf, name_len);
oname->len = name_len;
coda_vattr_to_iattr(inode, &attr);
if ((old_mode & S_IFMT) != (inode->i_mode & S_IFMT)) {
- pr_warn("inode %ld, fid %s changed type!\n",
+ pr_warn("inode %llu, fid %s changed type!\n",
inode->i_ino, coda_f2s(&(cii->c_fid)));
}
goto error;
}
- pr_info("%s: rootinode is %ld dev %s\n",
+ pr_info("%s: rootinode is %llu dev %s\n",
__func__, root->i_ino, root->i_sb->s_id);
sb->s_root = d_make_root(root);
if (!sb->s_root) {
old_decode_dev(cramfs_inode->size));
break;
default:
- printk(KERN_DEBUG "CRAMFS: Invalid file type 0%04o for inode %lu.\n",
+ printk(KERN_DEBUG "CRAMFS: Invalid file type 0%04o for inode %llu.\n",
inode->i_mode, inode->i_ino);
iget_failed(inode);
return ERR_PTR(-EIO);
vaf.fmt = fmt;
vaf.va = &args;
if (inode && inode->i_ino)
- printk("%sfscrypt (%s, inode %lu): %pV\n",
+ printk("%sfscrypt (%s, inode %llu): %pV\n",
level, inode->i_sb->s_id, inode->i_ino, &vaf);
else if (inode)
printk("%sfscrypt (%s): %pV\n", level, inode->i_sb->s_id, &vaf);
dentry_parent = dget_parent(dentry);
if (!fscrypt_has_permitted_context(d_inode(dentry_parent), inode)) {
fscrypt_warn(inode,
- "Inconsistent encryption context (parent directory: %lu)",
+ "Inconsistent encryption context (parent directory: %llu)",
d_inode(dentry_parent)->i_ino);
err = -EPERM;
}
{
struct list_head *pos;
size_t busy_count = 0;
- unsigned long ino;
char ino_str[50] = "";
+ u64 ino;
spin_lock(&mk->mk_decrypted_inodes_lock);
/* If the inode is currently being created, ino may still be 0. */
if (ino)
- snprintf(ino_str, sizeof(ino_str), ", including ino %lu", ino);
+ snprintf(ino_str, sizeof(ino_str), ", including ino %llu", ino);
fscrypt_warn(NULL,
"%s: %zu inode(s) still busy after removing key with %s %*phN%s",
if (S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode))
return &fscrypt_modes[fscrypt_policy_fnames_mode(policy)];
- WARN_ONCE(1, "fscrypt: filesystem tried to load encryption info for inode %lu, which is not encryptable (file type %d)\n",
+ WARN_ONCE(1, "fscrypt: filesystem tried to load encryption info for inode %llu, which is not encryptable (file type %d)\n",
inode->i_ino, (inode->i_mode & S_IFMT));
return ERR_PTR(-EINVAL);
}
if (dentry == _data && dentry->d_lockref.count == 1)
return D_WALK_CONTINUE;
- WARN(1, "BUG: Dentry %p{i=%lx,n=%pd} "
+ WARN(1, "BUG: Dentry %p{i=%llx,n=%pd} "
" still in use (%d) [unmount of %s %s]\n",
dentry,
dentry->d_inode ?
- dentry->d_inode->i_ino : 0UL,
+ dentry->d_inode->i_ino : (u64)0,
dentry,
dentry->d_lockref.count,
dentry->d_sb->s_type->name,
rc = ecryptfs_read_xattr_region(page_virt, ecryptfs_inode);
if (rc) {
printk(KERN_DEBUG "Valid eCryptfs headers not found in "
- "file header region or xattr region, inode %lu\n",
+ "file header region or xattr region, inode %llu\n",
ecryptfs_inode->i_ino);
rc = -EINVAL;
goto out;
ECRYPTFS_DONT_VALIDATE_HEADER_SIZE);
if (rc) {
printk(KERN_DEBUG "Valid eCryptfs headers not found in "
- "file xattr region either, inode %lu\n",
+ "file xattr region either, inode %llu\n",
ecryptfs_inode->i_ino);
rc = -EINVAL;
}
"crypto metadata only in the extended attribute "
"region, but eCryptfs was mounted without "
"xattr support enabled. eCryptfs will not treat "
- "this like an encrypted file, inode %lu\n",
+ "this like an encrypted file, inode %llu\n",
ecryptfs_inode->i_ino);
rc = -EINVAL;
}
if (rc)
goto out_put;
ecryptfs_printk(KERN_DEBUG, "inode w/ addr = [0x%p], i_ino = "
- "[0x%.16lx] size: [0x%.16llx]\n", inode, inode->i_ino,
+ "[0x%.16llx] size: [0x%.16llx]\n", inode, inode->i_ino,
(unsigned long long)i_size_read(inode));
goto out;
out_put:
for(i = 0; i < EFS_DIRECTEXTENTS; i++) {
extent_copy(&(efs_inode->di_u.di_extents[i]), &(in->extents[i]));
if (i < in->numextents && in->extents[i].cooked.ex_magic != 0) {
- pr_warn("extent %d has bad magic number in inode %lu\n",
+ pr_warn("extent %d has bad magic number in inode %llu\n",
i, inode->i_ino);
brelse(bh);
goto read_inode_error;
}
brelse(bh);
- pr_debug("efs_iget(): inode %lu, extents %d, mode %o\n",
+ pr_debug("efs_iget(): inode %llu, extents %d, mode %o\n",
inode->i_ino, in->numextents, inode->i_mode);
switch (inode->i_mode & S_IFMT) {
case S_IFDIR:
return inode;
read_inode_error:
- pr_warn("failed to read inode %lu\n", inode->i_ino);
+ pr_warn("failed to read inode %llu\n", inode->i_ino);
iget_failed(inode);
return ERR_PTR(-EIO);
}
struct inode *inode = file_inode(epi->ffd.file);
seq_printf(m, "tfd: %8d events: %8x data: %16llx "
- " pos:%lli ino:%lx sdev:%x\n",
+ " pos:%lli ino:%llx sdev:%x\n",
epi->ffd.fd, epi->event.events,
(long long)epi->event.data,
(long long)epi->ffd.file->f_pos,
parent = mnt->mnt_sb->s_export_op->get_parent(dentry);
if (IS_ERR(parent)) {
- dprintk("get_parent of %lu failed, err %ld\n",
+ dprintk("get_parent of %llu failed, err %ld\n",
dentry->d_inode->i_ino, PTR_ERR(parent));
return parent;
}
- dprintk("%s: find name of %lu in %lu\n", __func__,
+ dprintk("%s: find name of %llu in %llu\n", __func__,
dentry->d_inode->i_ino, parent->d_inode->i_ino);
err = exportfs_get_name(mnt, parent, nbuf, dentry);
if (err == -ENOENT)
Ebadsize:
if (!quiet)
ext2_error(sb, __func__,
- "size of directory #%lu is not a multiple "
+ "size of directory #%llu is not a multiple "
"of chunk size", dir->i_ino);
goto fail;
Eshort:
error = "inode out of bounds";
bad_entry:
if (!quiet)
- ext2_error(sb, __func__, "bad entry in directory #%lu: : %s - "
+ ext2_error(sb, __func__, "bad entry in directory #%llu: : %s - "
"offset=%llu, inode=%lu, rec_len=%d, name_len=%d",
dir->i_ino, error, folio_pos(folio) + offs,
(unsigned long) le32_to_cpu(p->inode),
if (!quiet) {
p = (ext2_dirent *)(kaddr + offs);
ext2_error(sb, "ext2_check_folio",
- "entry in directory #%lu spans the page boundary"
+ "entry in directory #%llu spans the page boundary"
"offset=%llu, inode=%lu",
dir->i_ino, folio_pos(folio) + offs,
(unsigned long) le32_to_cpu(p->inode));
if (IS_ERR(kaddr)) {
ext2_error(sb, __func__,
- "bad page in #%lu",
+ "bad page in #%llu",
inode->i_ino);
ctx->pos += PAGE_SIZE - offset;
return PTR_ERR(kaddr);
/* next folio is past the blocks we've got */
if (unlikely(n > (dir->i_blocks >> (PAGE_SHIFT - 9)))) {
ext2_error(dir->i_sb, __func__,
- "dir %lu size %lld exceeds block count %llu",
+ "dir %llu size %lld exceeds block count %llu",
dir->i_ino, dir->i_size,
(unsigned long long)dir->i_blocks);
goto out;
unsigned long block_group;
unsigned long offset;
unsigned long block;
+ unsigned int ino = inode->i_ino;
struct ext2_group_desc * gdp;
- block_group = (inode->i_ino - 1) / EXT2_INODES_PER_GROUP(inode->i_sb);
+ block_group = (ino - 1) / EXT2_INODES_PER_GROUP(inode->i_sb);
gdp = ext2_get_group_desc(inode->i_sb, block_group, NULL);
if (gdp == NULL)
return;
/*
* Figure out the offset within the block group inode table
*/
- offset = ((inode->i_ino - 1) % EXT2_INODES_PER_GROUP(inode->i_sb)) *
+ offset = ((ino - 1) % EXT2_INODES_PER_GROUP(inode->i_sb)) *
EXT2_INODE_SIZE(inode->i_sb);
block = le32_to_cpu(gdp->bg_inode_table) +
(offset >> EXT2_BLOCK_SIZE_BITS(inode->i_sb));
*
* So add our directory's i_ino into the starting point for the hash.
*/
- group = (group + parent->i_ino) % ngroups;
+ group = (group + (unsigned int)parent->i_ino) % ngroups;
/*
* Use a quadratic hash to find a group with a free inode and some
goto fail_free_drop;
mark_inode_dirty(inode);
- ext2_debug("allocating inode %lu\n", inode->i_ino);
+ ext2_debug("allocating inode %llu\n", inode->i_ino);
ext2_preread_inode(inode);
return inode;
*/
if (!bh) {
ext2_error(inode->i_sb, "ext2_free_branches",
- "Read failure, inode=%ld, block=%ld",
+ "Read failure, inode=%llu, block=%ld",
inode->i_ino, nr);
continue;
}
if (!ext2_xattr_header_valid(HDR(bh))) {
bad_block:
ext2_error(inode->i_sb, "ext2_xattr_get",
- "inode %ld: bad block %d", inode->i_ino,
+ "inode %llu: bad block %d", inode->i_ino,
EXT2_I(inode)->i_file_acl);
error = -EIO;
goto cleanup;
if (!ext2_xattr_header_valid(HDR(bh))) {
bad_block:
ext2_error(inode->i_sb, "ext2_xattr_list",
- "inode %ld: bad block %d", inode->i_ino,
+ "inode %llu: bad block %d", inode->i_ino,
EXT2_I(inode)->i_file_acl);
error = -EIO;
goto cleanup;
if (!ext2_xattr_header_valid(header)) {
bad_block:
ext2_error(sb, "ext2_xattr_set",
- "inode %ld: bad block %d", inode->i_ino,
+ "inode %llu: bad block %d", inode->i_ino,
EXT2_I(inode)->i_file_acl);
error = -EIO;
goto cleanup;
if (!ext2_data_block_valid(sbi, EXT2_I(inode)->i_file_acl, 1)) {
ext2_error(inode->i_sb, "ext2_xattr_delete_inode",
- "inode %ld: xattr block %d is out of data blocks range",
+ "inode %llu: xattr block %d is out of data blocks range",
inode->i_ino, EXT2_I(inode)->i_file_acl);
goto cleanup;
}
bh = sb_bread(inode->i_sb, EXT2_I(inode)->i_file_acl);
if (!bh) {
ext2_error(inode->i_sb, "ext2_xattr_delete_inode",
- "inode %ld: block %d read error", inode->i_ino,
+ "inode %llu: block %d read error", inode->i_ino,
EXT2_I(inode)->i_file_acl);
goto cleanup;
}
ea_bdebug(bh, "b_count=%d", atomic_read(&(bh->b_count)));
if (!ext2_xattr_header_valid(HDR(bh))) {
ext2_error(inode->i_sb, "ext2_xattr_delete_inode",
- "inode %ld: bad block %d", inode->i_ino,
+ "inode %llu: bad block %d", inode->i_ino,
EXT2_I(inode)->i_file_acl);
goto cleanup;
}
bh = sb_bread(inode->i_sb, ce->e_value);
if (!bh) {
ext2_error(inode->i_sb, "ext2_xattr_cache_find",
- "inode %ld: block %ld read error",
+ "inode %llu: block %ld read error",
inode->i_ino, (unsigned long) ce->e_value);
} else {
lock_buffer(bh);
struct super_block *sb = inode->i_sb;
if (!fname) {
- ext4_msg(sb, KERN_ERR, "%s:%d: inode #%lu: comm %s: "
+ ext4_msg(sb, KERN_ERR, "%s:%d: inode #%llu: comm %s: "
"called with null fname?!?", __func__, __LINE__,
inode->i_ino, current->comm);
return 0;
*/
#ifdef CONFIG_EXT4_DEBUG
#define ext_debug(ino, fmt, ...) \
- pr_debug("[%s/%d] EXT4-fs (%s): ino %lu: (%s, %d): %s:" fmt, \
+ pr_debug("[%s/%d] EXT4-fs (%s): ino %llu: (%s, %d): %s:" fmt, \
current->comm, task_pid_nr(current), \
ino->i_sb->s_id, ino->i_ino, __FILE__, __LINE__, \
__func__, ##__VA_ARGS__)
extern __printf(7, 8)
void __ext4_grp_locked_error(const char *, unsigned int,
struct super_block *, ext4_group_t,
- unsigned long, ext4_fsblk_t,
+ u64, ext4_fsblk_t,
const char *, ...);
#define EXT4_ERROR_INODE(inode, fmt, a...) \
}
ret = ext4_map_blocks(handle, inode, &map, flags);
if (ret <= 0) {
- ext4_debug("inode #%lu: block %u: len %u: "
+ ext4_debug("inode #%llu: block %u: len %u: "
"ext4_ext_map_blocks returned %d",
inode->i_ino, map.m_lblk,
map.m_len, ret);
ret = ext4_map_blocks(handle, inode, &map, flags);
if (ret != max_blocks)
ext4_msg(inode->i_sb, KERN_INFO,
- "inode #%lu: block %u: len %u: "
+ "inode #%llu: block %u: len %u: "
"split block mapping found for atomic write, "
"ret = %d",
inode->i_ino, map.m_lblk,
if (ret <= 0 || ret2)
ext4_warning(inode->i_sb,
- "inode #%lu: block %u: len %u: "
+ "inode #%llu: block %u: len %u: "
"returned %d or %d",
inode->i_ino, map.m_lblk,
map.m_len, ret, ret2);
EXT4_EX_NOCACHE);
if (ret <= 0)
ext4_warning(inode->i_sb,
- "inode #%lu: block %u: len %u: "
+ "inode #%llu: block %u: len %u: "
"ext4_ext_map_blocks returned %d",
inode->i_ino, map.m_lblk,
map.m_len, ret);
struct ext4_es_tree *tree;
struct rb_node *node;
- printk(KERN_DEBUG "status extents for inode %lu:", inode->i_ino);
+ printk(KERN_DEBUG "status extents for inode %llu:", inode->i_ino);
tree = &EXT4_I(inode)->i_es_tree;
node = rb_first(&tree->root);
while (node) {
if (!ext4_es_is_written(es) && !ext4_es_is_unwritten(es)) {
if (in_range(es->es_lblk, ee_block, ee_len)) {
pr_warn("ES insert assertion failed for "
- "inode: %lu we can find an extent "
+ "inode: %llu we can find an extent "
"at block [%d/%d/%llu/%c], but we "
"want to add a delayed/hole extent "
"[%d/%d/%llu/%x]\n",
*/
if (es->es_lblk < ee_block ||
ext4_es_pblock(es) != ee_start + es->es_lblk - ee_block) {
- pr_warn("ES insert assertion failed for inode: %lu "
+ pr_warn("ES insert assertion failed for inode: %llu "
"ex_status [%d/%d/%llu/%c] != "
"es_status [%d/%d/%llu/%c]\n", inode->i_ino,
ee_block, ee_len, ee_start,
}
if (ee_status ^ es_status) {
- pr_warn("ES insert assertion failed for inode: %lu "
+ pr_warn("ES insert assertion failed for inode: %llu "
"ex_status [%d/%d/%llu/%c] != "
"es_status [%d/%d/%llu/%c]\n", inode->i_ino,
ee_block, ee_len, ee_start,
* that we don't want to add an written/unwritten extent.
*/
if (!ext4_es_is_delayed(es) && !ext4_es_is_hole(es)) {
- pr_warn("ES insert assertion failed for inode: %lu "
+ pr_warn("ES insert assertion failed for inode: %llu "
"can't find an extent at block %d but we want "
"to add a written/unwritten extent "
"[%d/%d/%llu/%x]\n", inode->i_ino,
* We want to add a delayed/hole extent but this
* block has been allocated.
*/
- pr_warn("ES insert assertion failed for inode: %lu "
+ pr_warn("ES insert assertion failed for inode: %llu "
"We can find blocks but we want to add a "
"delayed/hole extent [%d/%d/%llu/%x]\n",
inode->i_ino, es->es_lblk, es->es_len,
} else if (ext4_es_is_written(es)) {
if (retval != es->es_len) {
pr_warn("ES insert assertion failed for "
- "inode: %lu retval %d != es_len %d\n",
+ "inode: %llu retval %d != es_len %d\n",
inode->i_ino, retval, es->es_len);
return;
}
if (map.m_pblk != ext4_es_pblock(es)) {
pr_warn("ES insert assertion failed for "
- "inode: %lu m_pblk %llu != "
+ "inode: %llu m_pblk %llu != "
"es_pblk %llu\n",
inode->i_ino, map.m_pblk,
ext4_es_pblock(es));
}
} else if (retval == 0) {
if (ext4_es_is_written(es)) {
- pr_warn("ES insert assertion failed for inode: %lu "
+ pr_warn("ES insert assertion failed for inode: %llu "
"We can't find the block but we want to add "
"a written extent [%d/%d/%llu/%x]\n",
inode->i_ino, es->es_lblk, es->es_len,
if (EXT4_SB(inode->i_sb)->s_mount_state & EXT4_FC_REPLAY)
return;
- es_debug("add [%u/%u) %llu %x %d to extent status tree of inode %lu\n",
+ es_debug("add [%u/%u) %llu %x %d to extent status tree of inode %llu\n",
lblk, len, pblk, status, delalloc_reserve_used, inode->i_ino);
if (!len)
if (EXT4_SB(inode->i_sb)->s_mount_state & EXT4_FC_REPLAY)
return;
- es_debug("remove [%u/%u) from extent status tree of inode %lu\n",
+ es_debug("remove [%u/%u) from extent status tree of inode %llu\n",
lblk, len, inode->i_ino);
if (!len)
seq_printf(seq, " %lu shrunk objects\n", es_stats->es_stats_shrunk);
if (inode_cnt)
seq_printf(seq,
- "maximum:\n %lu inode (%u objects, %u reclaimable)\n"
+ "maximum:\n %llu inode (%u objects, %u reclaimable)\n"
" %llu us max scan time\n",
max->vfs_inode.i_ino, max->i_es_all_nr, max->i_es_shk_nr,
div_u64(es_stats->es_stats_max_scan_time, 1000));
struct rb_node *node;
struct pending_reservation *pr;
- printk(KERN_DEBUG "pending reservations for inode %lu:", inode->i_ino);
+ printk(KERN_DEBUG "pending reservations for inode %llu:", inode->i_ino);
tree = &EXT4_I(inode)->i_pending_tree;
node = rb_first(&tree->root);
while (node) {
if (EXT4_SB(inode->i_sb)->s_mount_state & EXT4_FC_REPLAY)
return;
- es_debug("add [%u/%u) delayed to extent status tree of inode %lu\n",
+ es_debug("add [%u/%u) delayed to extent status tree of inode %llu\n",
lblk, len, inode->i_ino);
if (!len)
return;
(struct __track_range_args *)arg;
if (inode->i_ino < EXT4_FIRST_INO(inode->i_sb)) {
- ext4_debug("Special inode %ld being modified\n", inode->i_ino);
+ ext4_debug("Special inode %llu being modified\n", inode->i_ino);
return -ECANCELED;
}
spin_unlock(&ei->i_fc_lock);
cur_lblk_off = old_blk_size;
- ext4_debug("will try writing %d to %d for inode %ld\n",
+ ext4_debug("will try writing %d to %d for inode %llu\n",
cur_lblk_off, new_blk_size, inode->i_ino);
while (cur_lblk_off <= new_blk_size) {
cur = start;
remaining = len;
- ext4_debug("ADD_RANGE, lblk %d, pblk %lld, len %d, unwritten %d, inode %ld\n",
+ ext4_debug("ADD_RANGE, lblk %d, pblk %lld, len %d, unwritten %d, inode %llu\n",
start, start_pblk, len, ext4_ext_is_unwritten(ex),
inode->i_ino);
if (ret)
goto out;
- ext4_debug("DEL_RANGE, inode %ld, lblk %d, len %d\n",
+ ext4_debug("DEL_RANGE, inode %llu, lblk %d, len %d\n",
inode->i_ino, le32_to_cpu(lrange.fc_lblk),
le32_to_cpu(lrange.fc_len));
while (remaining > 0) {
return;
}
if (icount_read(inode) > 1) {
- ext4_msg(sb, KERN_ERR, "%s:%d: inode #%lu: count=%d",
+ ext4_msg(sb, KERN_ERR, "%s:%d: inode #%llu: count=%d",
__func__, __LINE__, inode->i_ino,
icount_read(inode));
return;
}
if (inode->i_nlink) {
- ext4_msg(sb, KERN_ERR, "%s:%d: inode #%lu: nlink=%d\n",
+ ext4_msg(sb, KERN_ERR, "%s:%d: inode #%llu: nlink=%d\n",
__func__, __LINE__, inode->i_ino, inode->i_nlink);
return;
}
*
* So add our directory's i_ino into the starting point for the hash.
*/
- *group = (*group + parent->i_ino) % ngroups;
+ *group = (*group + (unsigned int)parent->i_ino) % ngroups;
/*
* Use a quadratic hash to find a group with a free inode and some free
* twice.
*/
err = -EIO;
- ext4_error(sb, "failed to insert inode %lu: doubly allocated?",
+ ext4_error(sb, "failed to insert inode %llu: doubly allocated?",
inode->i_ino);
ext4_mark_group_bitmap_corrupted(sb, group,
EXT4_GROUP_INFO_IBITMAP_CORRUPT);
goto fail_free_drop;
}
- ext4_debug("allocating inode %lu\n", inode->i_ino);
+ ext4_debug("allocating inode %llu\n", inode->i_ino);
trace_ext4_allocate_inode(inode, dir, mode);
brelse(inode_bitmap_bh);
return ret;
offsets[n++] = i_block & (ptrs - 1);
final = ptrs;
} else {
- ext4_warning(inode->i_sb, "block %lu > max in inode %lu",
+ ext4_warning(inode->i_sb, "block %lu > max in inode %llu",
i_block + direct_blocks +
indirect_blocks + double_blocks, inode->i_ino);
}
error = ext4_get_inode_loc(inode, &iloc);
if (error) {
ext4_error_inode_err(inode, __func__, __LINE__, 0, -error,
- "can't get inode location %lu",
+ "can't get inode location %llu",
inode->i_ino);
return 0;
}
BUG_ON(folio->index);
if (!EXT4_I(inode)->i_inline_off) {
- ext4_warning(inode->i_sb, "inode %lu doesn't have inline data.",
+ ext4_warning(inode->i_sb, "inode %llu doesn't have inline data.",
inode->i_ino);
goto out;
}
struct ext4_dir_entry_2 *de = inline_start;
void *dlimit = inline_start + inline_size;
- trace_printk("inode %lu\n", dir->i_ino);
+ trace_printk("inode %llu\n", dir->i_ino);
offset = 0;
while ((void *)de < dlimit) {
de_len = ext4_rec_len_from_disk(de->rec_len, inline_size);
ret = ext4_create_inline_data(handle, inode, inline_size);
if (ret) {
ext4_msg(inode->i_sb, KERN_EMERG,
- "error restoring inline_data for inode -- potential data loss! (inode %lu, error %d)",
+ "error restoring inline_data for inode -- potential data loss! (inode %llu, error %d)",
inode->i_ino, ret);
return;
}
err = ext4_get_inode_loc(dir, &iloc);
if (err) {
EXT4_ERROR_INODE_ERR(dir, -err,
- "error %d getting inode %lu block",
+ "error %d getting inode %llu block",
err, dir->i_ino);
return false;
}
de = (struct ext4_dir_entry_2 *)ext4_raw_inode(&iloc)->i_block;
if (!le32_to_cpu(de->inode)) {
ext4_warning(dir->i_sb,
- "bad inline directory (dir #%lu) - no `..'",
+ "bad inline directory (dir #%llu) - no `..'",
dir->i_ino);
goto out;
}
iloc.bh, inline_pos,
inline_size, offset)) {
ext4_warning(dir->i_sb,
- "bad inline directory (dir #%lu) - "
+ "bad inline directory (dir #%llu) - "
"inode %u, rec_len %u, name_len %d"
"inline size %d",
dir->i_ino, le32_to_cpu(de->inode),
err = ext4_truncate(inode);
if (err) {
ext4_error_err(inode->i_sb, -err,
- "couldn't truncate inode %lu (err %d)",
+ "couldn't truncate inode %llu (err %d)",
inode->i_ino, err);
goto stop_handle;
}
spin_lock(&ei->i_block_reservation_lock);
trace_ext4_da_update_reserve_space(inode, used, quota_claim);
if (unlikely(used > ei->i_reserved_data_blocks)) {
- ext4_warning(inode->i_sb, "%s: ino %lu, used %d "
+ ext4_warning(inode->i_sb, "%s: ino %llu, used %d "
"with only %d reserved data blocks",
__func__, inode->i_ino, used,
ei->i_reserved_data_blocks);
if (es_map->m_lblk != map->m_lblk ||
es_map->m_flags != map->m_flags ||
es_map->m_pblk != map->m_pblk) {
- printk("ES cache assertion failed for inode: %lu "
+ printk("ES cache assertion failed for inode: %llu "
"es_cached ex [%d/%d/%llu/%x] != "
"found ex [%d/%d/%llu/%x] retval %d flags %x\n",
inode->i_ino, es_map->m_lblk, es_map->m_len,
if (unlikely(retval != map2.m_len)) {
ext4_warning(inode->i_sb,
"ES len assertion failed for inode "
- "%lu: retval %d != map->m_len %d",
+ "%llu: retval %d != map->m_len %d",
inode->i_ino, retval, map2.m_len);
WARN_ON(1);
}
if (unlikely(retval != map->m_len)) {
ext4_warning(inode->i_sb,
"ES len assertion failed for inode "
- "%lu: retval %d != map->m_len %d",
+ "%llu: retval %d != map->m_len %d",
inode->i_ino, retval, map->m_len);
WARN_ON(1);
}
if (unlikely(retval != map->m_len)) {
ext4_warning(inode->i_sb,
- "ES len assertion failed for inode %lu: "
+ "ES len assertion failed for inode %llu: "
"retval %d != map->m_len %d",
inode->i_ino, retval, map->m_len);
WARN_ON(1);
{
int ret = 0;
- ext4_debug("ext4_get_block_unwritten: inode %lu, create flag %d\n",
+ ext4_debug("ext4_get_block_unwritten: inode %llu, create flag %d\n",
inode->i_ino, create);
ret = _ext4_get_block(inode, iblock, bh_result,
EXT4_GET_BLOCKS_CREATE_UNWRIT_EXT);
* harmless to return without any action.
*/
ext4_warning(inode->i_sb, "ext4_da_release_space: "
- "ino %lu, to_free %d with only %d reserved "
+ "ino %llu, to_free %d with only %d reserved "
"data blocks", inode->i_ino, to_free,
ei->i_reserved_data_blocks);
WARN_ON(1);
}
ext4_msg(sb, KERN_CRIT,
"Delayed block allocation failed for "
- "inode %lu at logical offset %llu with"
+ "inode %llu at logical offset %llu with"
" max blocks %u with error %d",
inode->i_ino,
(unsigned long long)map->m_lblk,
err2 = ext4_mark_inode_dirty(handle, inode);
if (err2) {
ext4_error_err(inode->i_sb, -err2,
- "Failed to mark inode %lu dirty",
+ "Failed to mark inode %llu dirty",
inode->i_ino);
}
if (!err)
if (IS_ERR(handle)) {
ret = PTR_ERR(handle);
ext4_msg(inode->i_sb, KERN_CRIT, "%s: jbd2_start: "
- "%ld pages, ino %lu; err %d", __func__,
+ "%ld pages, ino %llu; err %d", __func__,
wbc->nr_to_write, inode->i_ino, ret);
/* Release allocated io_end */
ext4_put_io_end(mpd->io_submit.io_end);
if (err < 0) {
/* No need to update quota information. */
ext4_warning(inode->i_sb,
- "couldn't mark inode #%lu dirty (err %d)",
+ "couldn't mark inode #%llu dirty (err %d)",
inode->i_ino, err);
/* Revert all changes: */
swap_inode_data(inode, inode_bl);
if (err < 0) {
/* No need to update quota information. */
ext4_warning(inode_bl->i_sb,
- "couldn't mark inode #%lu dirty (err %d)",
+ "couldn't mark inode #%llu dirty (err %d)",
inode_bl->i_ino, err);
goto revert;
}
folio_get(ac->ac_buddy_folio);
/* store last allocated for subsequent stream allocation */
if (ac->ac_flags & EXT4_MB_STREAM_ALLOC) {
- int hash = ac->ac_inode->i_ino % sbi->s_mb_nr_global_goals;
+ int hash = (unsigned int)ac->ac_inode->i_ino % sbi->s_mb_nr_global_goals;
WRITE_ONCE(sbi->s_mb_last_groups[hash], ac->ac_f_ex.fe_group);
}
/* if stream allocation is enabled, use global goal */
if (ac->ac_flags & EXT4_MB_STREAM_ALLOC) {
- int hash = ac->ac_inode->i_ino % sbi->s_mb_nr_global_goals;
+ int hash = (unsigned int)ac->ac_inode->i_ino % sbi->s_mb_nr_global_goals;
ac->ac_g_ex.fe_group = READ_ONCE(sbi->s_mb_last_groups[hash]);
ac->ac_g_ex.fe_start = -1;
if (EXT4_SB(sb)->s_mount_state & EXT4_FC_REPLAY)
return;
- mb_debug(sb, "discard preallocation for inode %lu\n",
+ mb_debug(sb, "discard preallocation for inode %llu\n",
inode->i_ino);
trace_ext4_discard_preallocations(inode,
atomic_read(&ei->i_prealloc_active));
* log, so disable fast commits for this transaction.
*/
ext4_fc_mark_ineligible(inode->i_sb, EXT4_FC_REASON_MIGRATE, handle);
- goal = (((inode->i_ino - 1) / EXT4_INODES_PER_GROUP(inode->i_sb)) *
+ goal = ((((u32)inode->i_ino - 1) / EXT4_INODES_PER_GROUP(inode->i_sb)) *
EXT4_INODES_PER_GROUP(inode->i_sb)) + 1;
owner[0] = i_uid_read(inode);
owner[1] = i_gid_read(inode);
/* origin and donor should be different inodes */
if (orig_inode == donor_inode) {
- ext4_debug("ext4 move extent: The argument files should not be same inode [ino:orig %lu, donor %lu]\n",
+ ext4_debug("ext4 move extent: The argument files should not be same inode [ino:orig %llu, donor %llu]\n",
orig_inode->i_ino, donor_inode->i_ino);
return -EINVAL;
}
/* origin and donor should belone to the same filesystem */
if (orig_inode->i_sb != donor_inode->i_sb) {
- ext4_debug("ext4 move extent: The argument files should be in same FS [ino:orig %lu, donor %lu]\n",
+ ext4_debug("ext4 move extent: The argument files should be in same FS [ino:orig %llu, donor %llu]\n",
orig_inode->i_ino, donor_inode->i_ino);
return -EINVAL;
}
/* Regular file check */
if (!S_ISREG(orig_inode->i_mode) || !S_ISREG(donor_inode->i_mode)) {
- ext4_debug("ext4 move extent: The argument files should be regular file [ino:orig %lu, donor %lu]\n",
+ ext4_debug("ext4 move extent: The argument files should be regular file [ino:orig %llu, donor %llu]\n",
orig_inode->i_ino, donor_inode->i_ino);
return -EINVAL;
}
}
if (donor_inode->i_mode & (S_ISUID|S_ISGID)) {
- ext4_debug("ext4 move extent: suid or sgid is set to donor file [ino:orig %lu, donor %lu]\n",
+ ext4_debug("ext4 move extent: suid or sgid is set to donor file [ino:orig %llu, donor %llu]\n",
orig_inode->i_ino, donor_inode->i_ino);
return -EINVAL;
}
if (IS_IMMUTABLE(donor_inode) || IS_APPEND(donor_inode)) {
- ext4_debug("ext4 move extent: donor should not be immutable or append file [ino:orig %lu, donor %lu]\n",
+ ext4_debug("ext4 move extent: donor should not be immutable or append file [ino:orig %llu, donor %llu]\n",
orig_inode->i_ino, donor_inode->i_ino);
return -EPERM;
}
/* Ext4 move extent does not support swap files */
if (IS_SWAPFILE(orig_inode) || IS_SWAPFILE(donor_inode)) {
- ext4_debug("ext4 move extent: The argument files should not be swap files [ino:orig %lu, donor %lu]\n",
+ ext4_debug("ext4 move extent: The argument files should not be swap files [ino:orig %llu, donor %llu]\n",
orig_inode->i_ino, donor_inode->i_ino);
return -ETXTBSY;
}
if (ext4_is_quota_file(orig_inode) || ext4_is_quota_file(donor_inode)) {
- ext4_debug("ext4 move extent: The argument files should not be quota files [ino:orig %lu, donor %lu]\n",
+ ext4_debug("ext4 move extent: The argument files should not be quota files [ino:orig %llu, donor %llu]\n",
orig_inode->i_ino, donor_inode->i_ino);
return -EOPNOTSUPP;
}
/* Start offset should be same */
if ((orig_start & ~(PAGE_MASK >> orig_inode->i_blkbits)) !=
(donor_start & ~(PAGE_MASK >> orig_inode->i_blkbits))) {
- ext4_debug("ext4 move extent: orig and donor's start offsets are not aligned [ino:orig %lu, donor %lu]\n",
+ ext4_debug("ext4 move extent: orig and donor's start offsets are not aligned [ino:orig %llu, donor %llu]\n",
orig_inode->i_ino, donor_inode->i_ino);
return -EINVAL;
}
(*len > EXT_MAX_BLOCKS) ||
(donor_start + *len >= EXT_MAX_BLOCKS) ||
(orig_start + *len >= EXT_MAX_BLOCKS)) {
- ext4_debug("ext4 move extent: Can't handle over [%u] blocks [ino:orig %lu, donor %lu]\n",
+ ext4_debug("ext4 move extent: Can't handle over [%u] blocks [ino:orig %llu, donor %llu]\n",
EXT_MAX_BLOCKS,
orig_inode->i_ino, donor_inode->i_ino);
return -EINVAL;
else if (donor_eof < donor_start + *len - 1)
*len = donor_eof - donor_start;
if (!*len) {
- ext4_debug("ext4 move extent: len should not be 0 [ino:orig %lu, donor %lu]\n",
+ ext4_debug("ext4 move extent: len should not be 0 [ino:orig %llu, donor %llu]\n",
orig_inode->i_ino, donor_inode->i_ino);
return -EINVAL;
}
bh = ext4_bread(NULL, inode, block, 0);
if (IS_ERR(bh)) {
__ext4_warning(inode->i_sb, func, line,
- "inode #%lu: lblock %lu: comm %s: "
+ "inode #%llu: lblock %lu: comm %s: "
"error %ld reading directory block",
inode->i_ino, (unsigned long)block,
current->comm, PTR_ERR(bh));
indirect = root->info.indirect_levels;
if (indirect >= ext4_dir_htree_level(dir->i_sb)) {
ext4_warning(dir->i_sb,
- "Directory (ino: %lu) htree depth %#06x exceed"
+ "Directory (ino: %llu) htree depth %#06x exceed"
"supported value", dir->i_ino,
ext4_dir_htree_level(dir->i_sb));
if (ext4_dir_htree_level(dir->i_sb) < EXT4_HTREE_LEVEL) {
(S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) &&
!fscrypt_has_permitted_context(dir, inode)) {
ext4_warning(inode->i_sb,
- "Inconsistent encryption contexts: %lu/%lu",
+ "Inconsistent encryption contexts: %llu/%llu",
dir->i_ino, inode->i_ino);
iput(inode);
return ERR_PTR(-EPERM);
csum_size = sizeof(struct ext4_dir_entry_tail);
blocksize = dir->i_sb->s_blocksize;
- dxtrace(printk(KERN_DEBUG "Creating index: inode %lu\n", dir->i_ino));
+ dxtrace(printk(KERN_DEBUG "Creating index: inode %llu\n", dir->i_ino));
BUFFER_TRACE(bh, "get_write_access");
retval = ext4_journal_get_write_access(handle, dir->i_sb, bh,
EXT4_JTR_NONE);
restart = 1;
}
if (add_level && levels == ext4_dir_htree_level(sb)) {
- ext4_warning(sb, "Directory (ino: %lu) index full, "
+ ext4_warning(sb, "Directory (ino: %llu) index full, "
"reach max htree level :%d",
dir->i_ino, levels);
if (ext4_dir_htree_level(sb) < EXT4_HTREE_LEVEL) {
} else
brelse(iloc.bh);
- ext4_debug("superblock will point to %lu\n", inode->i_ino);
- ext4_debug("orphan inode %lu will point to %d\n",
+ ext4_debug("superblock will point to %llu\n", inode->i_ino);
+ ext4_debug("orphan inode %llu will point to %d\n",
inode->i_ino, NEXT_ORPHAN(inode));
out:
ext4_std_error(sb, err);
}
mutex_lock(&sbi->s_orphan_lock);
- ext4_debug("remove inode %lu from orphan list\n", inode->i_ino);
+ ext4_debug("remove inode %llu from orphan list\n", inode->i_ino);
prev = ei->i_orphan.prev;
list_del_init(&ei->i_orphan);
struct inode *i_prev =
&list_entry(prev, struct ext4_inode_info, i_orphan)->vfs_inode;
- ext4_debug("orphan inode %lu will point to %u\n",
+ ext4_debug("orphan inode %llu will point to %u\n",
i_prev->i_ino, ino_next);
err = ext4_reserve_inode_write(handle, i_prev, &iloc2);
if (err) {
if (inode->i_nlink) {
if (test_opt(sb, DEBUG))
ext4_msg(sb, KERN_DEBUG,
- "%s: truncating inode %lu to %lld bytes",
+ "%s: truncating inode %llu to %lld bytes",
__func__, inode->i_ino, inode->i_size);
- ext4_debug("truncating inode %lu to %lld bytes\n",
+ ext4_debug("truncating inode %llu to %lld bytes\n",
inode->i_ino, inode->i_size);
inode_lock(inode);
truncate_inode_pages(inode->i_mapping, inode->i_size);
} else {
if (test_opt(sb, DEBUG))
ext4_msg(sb, KERN_DEBUG,
- "%s: deleting unreferenced inode %lu",
+ "%s: deleting unreferenced inode %llu",
__func__, inode->i_ino);
- ext4_debug("deleting unreferenced inode %lu\n",
+ ext4_debug("deleting unreferenced inode %llu\n",
inode->i_ino);
(*nr_orphans)++;
}
struct super_block *sb = inode->i_sb;
int ret = 0;
- ext4_debug("ext4_end_io_nolock: io_end 0x%p from inode %lu,list->next 0x%p,"
+ ext4_debug("ext4_end_io_nolock: io_end 0x%p from inode %llu,list->next 0x%p,"
"list->prev 0x%p\n",
io_end, inode->i_ino, io_end->list.next, io_end->list.prev);
ext4_msg(sb, KERN_EMERG,
"failed to convert unwritten extents to written "
"extents -- potential data loss! "
- "(inode %lu, error %d)", inode->i_ino, ret);
+ "(inode %llu, error %d)", inode->i_ino, ret);
}
ext4_clear_io_unwritten_flag(io_end);
if (list_empty(head))
return;
- ext4_debug("Dump inode %lu completed io list\n", inode->i_ino);
+ ext4_debug("Dump inode %llu completed io list\n", inode->i_ino);
list_for_each_entry(io_end, head, list) {
cur = &io_end->list;
before = cur->prev;
after = cur->next;
io_end1 = container_of(after, ext4_io_end_t, list);
- ext4_debug("io 0x%p from inode %lu,prev 0x%p,next 0x%p\n",
+ ext4_debug("io 0x%p from inode %llu,prev 0x%p,next 0x%p\n",
io_end, inode->i_ino, io_end0, io_end1);
}
#endif
if (bio->bi_status) {
struct inode *inode = io_end->inode;
- ext4_warning(inode->i_sb, "I/O error %d writing to inode %lu "
+ ext4_warning(inode->i_sb, "I/O error %d writing to inode %llu "
"starting block %llu)",
bio->bi_status, inode->i_ino,
(unsigned long long)
vaf.va = &args;
if (block)
printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: "
- "inode #%lu: block %llu: comm %s: %pV\n",
+ "inode #%llu: block %llu: comm %s: %pV\n",
inode->i_sb->s_id, function, line, inode->i_ino,
block, current->comm, &vaf);
else
printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: "
- "inode #%lu: comm %s: %pV\n",
+ "inode #%llu: comm %s: %pV\n",
inode->i_sb->s_id, function, line, inode->i_ino,
current->comm, &vaf);
va_end(args);
vaf.va = &args;
if (block)
printk(KERN_CRIT
- "EXT4-fs error (device %s): %s:%d: inode #%lu: "
+ "EXT4-fs error (device %s): %s:%d: inode #%llu: "
"block %llu: comm %s: path %s: %pV\n",
inode->i_sb->s_id, function, line, inode->i_ino,
block, current->comm, path, &vaf);
else
printk(KERN_CRIT
- "EXT4-fs error (device %s): %s:%d: inode #%lu: "
+ "EXT4-fs error (device %s): %s:%d: inode #%llu: "
"comm %s: path %s: %pV\n",
inode->i_sb->s_id, function, line, inode->i_ino,
current->comm, path, &vaf);
vaf.fmt = fmt;
vaf.va = &args;
printk(KERN_WARNING "EXT4-fs warning (device %s): %s:%d: "
- "inode #%lu: comm %s: %pV\n", inode->i_sb->s_id,
+ "inode #%llu: comm %s: %pV\n", inode->i_sb->s_id,
function, line, inode->i_ino, current->comm, &vaf);
va_end(args);
}
void __ext4_grp_locked_error(const char *function, unsigned int line,
struct super_block *sb, ext4_group_t grp,
- unsigned long ino, ext4_fsblk_t block,
+ u64 ino, ext4_fsblk_t block,
const char *fmt, ...)
__releases(bitlock)
__acquires(bitlock)
printk(KERN_CRIT "EXT4-fs error (device %s): %s:%d: group %u, ",
sb->s_id, function, line, grp);
if (ino)
- printk(KERN_CONT "inode %lu: ", ino);
+ printk(KERN_CONT "inode %llu: ", ino);
if (block)
printk(KERN_CONT "block %llu:",
(unsigned long long) block);
list_for_each(l, &sbi->s_orphan) {
struct inode *inode = orphan_list_entry(l);
printk(KERN_ERR " "
- "inode %s:%lu at %p: mode %o, nlink %d, next %d\n",
+ "inode %s:%llu at %p: mode %o, nlink %d, next %d\n",
inode->i_sb->s_id, inode->i_ino, inode,
inode->i_mode, inode->i_nlink,
NEXT_ORPHAN(inode));
{
fscrypt_free_inode(inode);
if (!list_empty(&(EXT4_I(inode)->i_fc_list))) {
- pr_warn("%s: inode %ld still in fc list",
+ pr_warn("%s: inode %llu still in fc list",
__func__, inode->i_ino);
}
kmem_cache_free(ext4_inode_cachep, EXT4_I(inode));
{
if (ext4_inode_orphan_tracked(inode)) {
ext4_msg(inode->i_sb, KERN_ERR,
- "Inode %lu (%p): inode tracked as orphan!",
+ "Inode %llu (%p): inode tracked as orphan!",
inode->i_ino, EXT4_I(inode));
print_hex_dump(KERN_INFO, "", DUMP_PREFIX_ADDRESS, 16, 4,
EXT4_I(inode), sizeof(struct ext4_inode_info),
if (!(EXT4_SB(inode->i_sb)->s_mount_state & EXT4_ERROR_FS) &&
WARN_ON_ONCE(EXT4_I(inode)->i_reserved_data_blocks))
ext4_msg(inode->i_sb, KERN_ERR,
- "Inode %lu (%p): i_reserved_data_blocks (%u) not cleared!",
+ "Inode %llu (%p): i_reserved_data_blocks (%u) not cleared!",
inode->i_ino, EXT4_I(inode),
EXT4_I(inode)->i_reserved_data_blocks);
}
#ifdef EXT4_XATTR_DEBUG
# define ea_idebug(inode, fmt, ...) \
- printk(KERN_DEBUG "inode %s:%lu: " fmt "\n", \
+ printk(KERN_DEBUG "inode %s:%llu: " fmt "\n", \
inode->i_sb->s_id, inode->i_ino, ##__VA_ARGS__)
# define ea_bdebug(bh, fmt, ...) \
printk(KERN_DEBUG "block %pg:%lu: " fmt "\n", \
ref_count = ext4_xattr_inode_get_ref(ea_inode);
if ((ref_count == 0 && ref_change < 0) || (ref_count == U64_MAX && ref_change > 0)) {
ext4_error_inode(ea_inode, __func__, __LINE__, 0,
- "EA inode %lu ref wraparound: ref_count=%lld ref_change=%d",
+ "EA inode %llu ref wraparound: ref_count=%lld ref_change=%d",
ea_inode->i_ino, ref_count, ref_change);
brelse(iloc.bh);
ret = -EFSCORRUPTED;
if (ref_change > 0) {
if (ref_count == 1) {
- WARN_ONCE(ea_inode->i_nlink, "EA inode %lu i_nlink=%u",
+ WARN_ONCE(ea_inode->i_nlink, "EA inode %llu i_nlink=%u",
ea_inode->i_ino, ea_inode->i_nlink);
set_nlink(ea_inode, 1);
} else {
if (ref_count == 0) {
WARN_ONCE(ea_inode->i_nlink != 1,
- "EA inode %lu i_nlink=%u",
+ "EA inode %llu i_nlink=%u",
ea_inode->i_ino, ea_inode->i_nlink);
clear_nlink(ea_inode);
cleanup:
if (error && (mnt_count != le16_to_cpu(sbi->s_es->s_mnt_count))) {
- ext4_warning(inode->i_sb, "Unable to expand inode %lu. Delete some EAs or run e2fsck.",
+ ext4_warning(inode->i_sb, "Unable to expand inode %llu. Delete some EAs or run e2fsck.",
inode->i_ino);
mnt_count = le16_to_cpu(sbi->s_es->s_mnt_count);
}
if (!is_inode_flag_set(dic->inode, FI_COMPRESS_CORRUPT)) {
set_inode_flag(dic->inode, FI_COMPRESS_CORRUPT);
f2fs_info_ratelimited(sbi,
- "checksum invalid, nid = %lu, %x vs %x",
+ "checksum invalid, nid = %llu, %x vs %x",
dic->inode->i_ino,
provided, calculated);
}
return false;
out:
- f2fs_warn(sbi, "access invalid cluster, ino:%lu, nid:%u, ofs_in_node:%u, reason:%s",
+ f2fs_warn(sbi, "access invalid cluster, ino:%llu, nid:%u, ofs_in_node:%u, reason:%s",
dn->inode->i_ino, dn->nid, dn->ofs_in_node, reason);
set_sbi_flag(sbi, SBI_NEED_FSCK);
return true;
max_depth = F2FS_I(dir)->i_current_depth;
if (unlikely(max_depth > MAX_DIR_HASH_DEPTH)) {
- f2fs_warn(F2FS_I_SB(dir), "Corrupted max_depth of %lu: %u",
+ f2fs_warn(F2FS_I_SB(dir), "Corrupted max_depth of %llu: %u",
dir->i_ino, max_depth);
max_depth = MAX_DIR_HASH_DEPTH;
f2fs_i_depth_write(dir, max_depth);
if (!f2fs_is_valid_blkaddr(sbi, ei.blk, DATA_GENERIC_ENHANCE) ||
!f2fs_is_valid_blkaddr(sbi, ei.blk + ei.len - 1,
DATA_GENERIC_ENHANCE)) {
- f2fs_warn(sbi, "%s: inode (ino=%lx) extent info [%u, %u, %u] is incorrect, run fsck to fix",
+ f2fs_warn(sbi, "%s: inode (ino=%llx) extent info [%u, %u, %u] is incorrect, run fsck to fix",
__func__, inode->i_ino,
ei.blk, ei.fofs, ei.len);
return false;
if (devi == 0) {
f2fs_warn(sbi,
- "%s: inode (ino=%lx) is an alias of meta device",
+ "%s: inode (ino=%llx) is an alias of meta device",
__func__, inode->i_ino);
return false;
}
if (bdev_is_zoned(FDEV(devi).bdev)) {
f2fs_warn(sbi,
- "%s: device alias inode (ino=%lx)'s extent info "
+ "%s: device alias inode (ino=%llx)'s extent info "
"[%u, %u, %u] maps to zoned block device",
__func__, inode->i_ino, ei.blk, ei.fofs, ei.len);
return false;
return true;
}
- f2fs_warn(sbi, "%s: device alias inode (ino=%lx)'s extent info "
+ f2fs_warn(sbi, "%s: device alias inode (ino=%llx)'s extent info "
"[%u, %u, %u] is inconsistent w/ any devices",
__func__, inode->i_ino, ei.blk, ei.fofs, ei.len);
return false;
spin_lock(&sbi->stat_lock);
if (unlikely(sbi->total_valid_block_count < count)) {
- f2fs_warn(sbi, "Inconsistent total_valid_block_count:%u, ino:%lu, count:%u",
+ f2fs_warn(sbi, "Inconsistent total_valid_block_count:%u, ino:%llu, count:%u",
sbi->total_valid_block_count, inode->i_ino, count);
sbi->total_valid_block_count = 0;
set_sbi_flag(sbi, SBI_NEED_FSCK);
sbi->current_reserved_blocks + count);
spin_unlock(&sbi->stat_lock);
if (unlikely(inode->i_blocks < sectors)) {
- f2fs_warn(sbi, "Inconsistent i_blocks, ino:%lu, iblocks:%llu, sectors:%llu",
+ f2fs_warn(sbi, "Inconsistent i_blocks, ino:%llu, iblocks:%llu, sectors:%llu",
inode->i_ino,
(unsigned long long)inode->i_blocks,
(unsigned long long)sectors);
dquot_free_inode(inode);
} else {
if (unlikely(inode->i_blocks == 0)) {
- f2fs_warn(sbi, "dec_valid_node_count: inconsistent i_blocks, ino:%lu, iblocks:%llu",
+ f2fs_warn(sbi, "dec_valid_node_count: inconsistent i_blocks, ino:%llu, iblocks:%llu",
inode->i_ino,
(unsigned long long)inode->i_blocks);
set_sbi_flag(sbi, SBI_NEED_FSCK);
f2fs_up_write(&sbi->pin_sem);
err = -ENOSPC;
f2fs_warn_ratelimited(sbi,
- "ino:%lu, start:%lu, end:%lu, need to trigger GC to "
+ "ino:%llu, start:%lu, end:%lu, need to trigger GC to "
"reclaim enough free segment when checkpoint is enabled",
inode->i_ino, pg_start, pg_end);
goto out_err;
* f2fs_is_atomic_file.
*/
if (get_dirty_pages(inode))
- f2fs_warn(sbi, "Unexpected flush for atomic writes: ino=%lu, npages=%u",
+ f2fs_warn(sbi, "Unexpected flush for atomic writes: ino=%llu, npages=%u",
inode->i_ino, get_dirty_pages(inode));
ret = filemap_write_and_wait_range(inode->i_mapping, 0, LLONG_MAX);
if (ret)
return -EINVAL;
if (fi->i_gc_failures >= sbi->gc_pin_file_threshold) {
- f2fs_warn(sbi, "%s: Enable GC = ino %lx after %x GC trials",
+ f2fs_warn(sbi, "%s: Enable GC = ino %llx after %x GC trials",
__func__, inode->i_ino, fi->i_gc_failures);
clear_inode_flag(inode, FI_PIN_FILE);
return -EAGAIN;
if (!f2fs_sb_has_verity(F2FS_I_SB(inode))) {
f2fs_warn(F2FS_I_SB(inode),
- "Can't enable fs-verity on inode %lu: the verity feature is not enabled on this filesystem",
+ "Can't enable fs-verity on inode %llu: the verity feature is not enabled on this filesystem",
inode->i_ino);
return -EOPNOTSUPP;
}
} else if (released_blocks &&
atomic_read(&fi->i_compr_blocks)) {
set_sbi_flag(sbi, SBI_NEED_FSCK);
- f2fs_warn(sbi, "%s: partial blocks were released i_ino=%lx "
+ f2fs_warn(sbi, "%s: partial blocks were released i_ino=%llx "
"iblocks=%llu, released=%u, compr_blocks=%u, "
"run fsck to fix.",
__func__, inode->i_ino, inode->i_blocks,
} else if (reserved_blocks &&
atomic_read(&fi->i_compr_blocks)) {
set_sbi_flag(sbi, SBI_NEED_FSCK);
- f2fs_warn(sbi, "%s: partial blocks were reserved i_ino=%lx "
+ f2fs_warn(sbi, "%s: partial blocks were reserved i_ino=%llx "
"iblocks=%llu, reserved=%u, compr_blocks=%u, "
"run fsck to fix.",
__func__, inode->i_ino, inode->i_blocks,
iput(inode);
set_sbi_flag(sbi, SBI_NEED_FSCK);
f2fs_err_ratelimited(sbi,
- "inode %lx has both inline_data flag and "
+ "inode %llu has both inline_data flag and "
"data block, nid=%u, ofs_in_node=%u",
inode->i_ino, dni.nid, ofs_in_node);
continue;
if (unlikely(dn->data_blkaddr != NEW_ADDR)) {
f2fs_put_dnode(dn);
set_sbi_flag(fio.sbi, SBI_NEED_FSCK);
- f2fs_warn(fio.sbi, "%s: corrupted inline inode ino=%lx, i_addr[0]:0x%x, run fsck to fix.",
+ f2fs_warn(fio.sbi, "%s: corrupted inline inode ino=%llu, i_addr[0]:0x%x, run fsck to fix.",
__func__, dn->inode->i_ino, dn->data_blkaddr);
f2fs_handle_error(fio.sbi, ERROR_INVALID_BLKADDR);
return -EFSCORRUPTED;
if (unlikely(dn.data_blkaddr != NEW_ADDR)) {
f2fs_put_dnode(&dn);
set_sbi_flag(F2FS_F_SB(folio), SBI_NEED_FSCK);
- f2fs_warn(F2FS_F_SB(folio), "%s: corrupted inline inode ino=%lx, i_addr[0]:0x%x, run fsck to fix.",
+ f2fs_warn(F2FS_F_SB(folio), "%s: corrupted inline inode ino=%llu, i_addr[0]:0x%x, run fsck to fix.",
__func__, dir->i_ino, dn.data_blkaddr);
f2fs_handle_error(F2FS_F_SB(folio), ERROR_INVALID_BLKADDR);
err = -EFSCORRUPTED;
if (ri->i_compress_algorithm >= COMPRESS_MAX) {
f2fs_warn(sbi,
- "%s: inode (ino=%lx) has unsupported compress algorithm: %u, run fsck to fix",
+ "%s: inode (ino=%llx) has unsupported compress algorithm: %u, run fsck to fix",
__func__, inode->i_ino, ri->i_compress_algorithm);
return false;
}
if (le64_to_cpu(ri->i_compr_blocks) >
SECTOR_TO_BLOCK(inode->i_blocks)) {
f2fs_warn(sbi,
- "%s: inode (ino=%lx) has inconsistent i_compr_blocks:%llu, i_blocks:%llu, run fsck to fix",
+ "%s: inode (ino=%llx) has inconsistent i_compr_blocks:%llu, i_blocks:%llu, run fsck to fix",
__func__, inode->i_ino, le64_to_cpu(ri->i_compr_blocks),
SECTOR_TO_BLOCK(inode->i_blocks));
return false;
if (ri->i_log_cluster_size < MIN_COMPRESS_LOG_SIZE ||
ri->i_log_cluster_size > MAX_COMPRESS_LOG_SIZE) {
f2fs_warn(sbi,
- "%s: inode (ino=%lx) has unsupported log cluster size: %u, run fsck to fix",
+ "%s: inode (ino=%llx) has unsupported log cluster size: %u, run fsck to fix",
__func__, inode->i_ino, ri->i_log_cluster_size);
return false;
}
return true;
err_level:
- f2fs_warn(sbi, "%s: inode (ino=%lx) has unsupported compress level: %u, run fsck to fix",
+ f2fs_warn(sbi, "%s: inode (ino=%llx) has unsupported compress level: %u, run fsck to fix",
__func__, inode->i_ino, clevel);
return false;
}
iblocks = le64_to_cpu(F2FS_INODE(node_folio)->i_blocks);
if (!iblocks) {
- f2fs_warn(sbi, "%s: corrupted inode i_blocks i_ino=%lx iblocks=%llu, run fsck to fix.",
+ f2fs_warn(sbi, "%s: corrupted inode i_blocks i_ino=%llx iblocks=%llu, run fsck to fix.",
__func__, inode->i_ino, iblocks);
return false;
}
if (ino_of_node(node_folio) != nid_of_node(node_folio)) {
- f2fs_warn(sbi, "%s: corrupted inode footer i_ino=%lx, ino,nid: [%u, %u] run fsck to fix.",
+ f2fs_warn(sbi, "%s: corrupted inode footer i_ino=%llx, ino,nid: [%u, %u] run fsck to fix.",
__func__, inode->i_ino,
ino_of_node(node_folio), nid_of_node(node_folio));
return false;
}
if (ino_of_node(node_folio) == fi->i_xattr_nid) {
- f2fs_warn(sbi, "%s: corrupted inode i_ino=%lx, xnid=%x, run fsck to fix.",
+ f2fs_warn(sbi, "%s: corrupted inode i_ino=%llx, xnid=%x, run fsck to fix.",
__func__, inode->i_ino, fi->i_xattr_nid);
return false;
}
if (S_ISDIR(inode->i_mode) && unlikely(inode->i_nlink == 1)) {
- f2fs_warn(sbi, "%s: directory inode (ino=%lx) has a single i_nlink",
+ f2fs_warn(sbi, "%s: directory inode (ino=%llx) has a single i_nlink",
__func__, inode->i_ino);
return false;
}
if (f2fs_has_extra_attr(inode)) {
if (!f2fs_sb_has_extra_attr(sbi)) {
- f2fs_warn(sbi, "%s: inode (ino=%lx) is with extra_attr, but extra_attr feature is off",
+ f2fs_warn(sbi, "%s: inode (ino=%llx) is with extra_attr, but extra_attr feature is off",
__func__, inode->i_ino);
return false;
}
if (fi->i_extra_isize > F2FS_TOTAL_EXTRA_ATTR_SIZE ||
fi->i_extra_isize < F2FS_MIN_EXTRA_ATTR_SIZE ||
fi->i_extra_isize % sizeof(__le32)) {
- f2fs_warn(sbi, "%s: inode (ino=%lx) has corrupted i_extra_isize: %d, max: %zu",
+ f2fs_warn(sbi, "%s: inode (ino=%llx) has corrupted i_extra_isize: %d, max: %zu",
__func__, inode->i_ino, fi->i_extra_isize,
F2FS_TOTAL_EXTRA_ATTR_SIZE);
return false;
f2fs_has_inline_xattr(inode) &&
(fi->i_inline_xattr_size < MIN_INLINE_XATTR_SIZE ||
fi->i_inline_xattr_size > MAX_INLINE_XATTR_SIZE)) {
- f2fs_warn(sbi, "%s: inode (ino=%lx) has corrupted i_inline_xattr_size: %d, min: %zu, max: %lu",
+ f2fs_warn(sbi, "%s: inode (ino=%llx) has corrupted i_inline_xattr_size: %d, min: %zu, max: %lu",
__func__, inode->i_ino, fi->i_inline_xattr_size,
MIN_INLINE_XATTR_SIZE, MAX_INLINE_XATTR_SIZE);
return false;
if (!f2fs_sb_has_extra_attr(sbi)) {
if (f2fs_sb_has_project_quota(sbi)) {
- f2fs_warn(sbi, "%s: corrupted inode ino=%lx, wrong feature flag: %u, run fsck to fix.",
+ f2fs_warn(sbi, "%s: corrupted inode ino=%llx, wrong feature flag: %u, run fsck to fix.",
__func__, inode->i_ino, F2FS_FEATURE_PRJQUOTA);
return false;
}
if (f2fs_sb_has_inode_chksum(sbi)) {
- f2fs_warn(sbi, "%s: corrupted inode ino=%lx, wrong feature flag: %u, run fsck to fix.",
+ f2fs_warn(sbi, "%s: corrupted inode ino=%llx, wrong feature flag: %u, run fsck to fix.",
__func__, inode->i_ino, F2FS_FEATURE_INODE_CHKSUM);
return false;
}
if (f2fs_sb_has_flexible_inline_xattr(sbi)) {
- f2fs_warn(sbi, "%s: corrupted inode ino=%lx, wrong feature flag: %u, run fsck to fix.",
+ f2fs_warn(sbi, "%s: corrupted inode ino=%llx, wrong feature flag: %u, run fsck to fix.",
__func__, inode->i_ino, F2FS_FEATURE_FLEXIBLE_INLINE_XATTR);
return false;
}
if (f2fs_sb_has_inode_crtime(sbi)) {
- f2fs_warn(sbi, "%s: corrupted inode ino=%lx, wrong feature flag: %u, run fsck to fix.",
+ f2fs_warn(sbi, "%s: corrupted inode ino=%llx, wrong feature flag: %u, run fsck to fix.",
__func__, inode->i_ino, F2FS_FEATURE_INODE_CRTIME);
return false;
}
if (f2fs_sb_has_compression(sbi)) {
- f2fs_warn(sbi, "%s: corrupted inode ino=%lx, wrong feature flag: %u, run fsck to fix.",
+ f2fs_warn(sbi, "%s: corrupted inode ino=%llx, wrong feature flag: %u, run fsck to fix.",
__func__, inode->i_ino, F2FS_FEATURE_COMPRESSION);
return false;
}
}
if (f2fs_sanity_check_inline_data(inode, node_folio)) {
- f2fs_warn(sbi, "%s: inode (ino=%lx, mode=%u) should not have inline_data, run fsck to fix",
+ f2fs_warn(sbi, "%s: inode (ino=%llx, mode=%u) should not have inline_data, run fsck to fix",
__func__, inode->i_ino, inode->i_mode);
return false;
}
if (f2fs_has_inline_dentry(inode) && !S_ISDIR(inode->i_mode)) {
- f2fs_warn(sbi, "%s: inode (ino=%lx, mode=%u) should not have inline_dentry, run fsck to fix",
+ f2fs_warn(sbi, "%s: inode (ino=%llx, mode=%u) should not have inline_dentry, run fsck to fix",
__func__, inode->i_ino, inode->i_mode);
return false;
}
if ((fi->i_flags & F2FS_CASEFOLD_FL) && !f2fs_sb_has_casefold(sbi)) {
- f2fs_warn(sbi, "%s: inode (ino=%lx) has casefold flag, but casefold feature is off",
+ f2fs_warn(sbi, "%s: inode (ino=%llx) has casefold flag, but casefold feature is off",
__func__, inode->i_ino);
return false;
}
if (fi->i_xattr_nid && f2fs_check_nid_range(sbi, fi->i_xattr_nid)) {
- f2fs_warn(sbi, "%s: inode (ino=%lx) has corrupted i_xattr_nid: %u, run fsck to fix.",
+ f2fs_warn(sbi, "%s: inode (ino=%llx) has corrupted i_xattr_nid: %u, run fsck to fix.",
__func__, inode->i_ino, fi->i_xattr_nid);
return false;
}
if (IS_DEVICE_ALIASING(inode)) {
if (!f2fs_sb_has_device_alias(sbi)) {
- f2fs_warn(sbi, "%s: inode (ino=%lx) has device alias flag, but the feature is off",
+ f2fs_warn(sbi, "%s: inode (ino=%llx) has device alias flag, but the feature is off",
__func__, inode->i_ino);
return false;
}
if (!f2fs_is_pinned_file(inode)) {
- f2fs_warn(sbi, "%s: inode (ino=%lx) has device alias flag, but is not pinned",
+ f2fs_warn(sbi, "%s: inode (ino=%llx) has device alias flag, but is not pinned",
__func__, inode->i_ino);
return false;
}
*/
if (is_inode_flag_set(inode, FI_DIRTY_INODE)) {
f2fs_warn(F2FS_I_SB(inode),
- "f2fs_evict_inode: inconsistent node id, ino:%lu",
+ "f2fs_evict_inode: inconsistent node id, ino:%llu",
inode->i_ino);
f2fs_inode_synced(inode);
set_sbi_flag(sbi, SBI_NEED_FSCK);
*/
if (is_inode_flag_set(inode, FI_DIRTY_INODE)) {
f2fs_warn(sbi,
- "f2fs_evict_inode: inode is dirty, ino:%lu",
+ "f2fs_evict_inode: inode is dirty, ino:%llu",
inode->i_ino);
f2fs_inode_synced(inode);
set_sbi_flag(sbi, SBI_NEED_FSCK);
}
if (inode->i_nlink == 0) {
- f2fs_warn(F2FS_I_SB(inode), "%s: inode (ino=%lx) has zero i_nlink",
+ f2fs_warn(F2FS_I_SB(inode), "%s: inode (ino=%llx) has zero i_nlink",
__func__, inode->i_ino);
err = -EFSCORRUPTED;
set_sbi_flag(F2FS_I_SB(inode), SBI_NEED_FSCK);
if (IS_ENCRYPTED(dir) &&
(S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) &&
!fscrypt_has_permitted_context(dir, inode)) {
- f2fs_warn(F2FS_I_SB(inode), "Inconsistent encryption contexts: %lu/%lu",
+ f2fs_warn(F2FS_I_SB(inode), "Inconsistent encryption contexts: %llu/%llu",
dir->i_ino, inode->i_ino);
err = -EPERM;
goto out_iput;
}
if (unlikely(inode->i_nlink == 0)) {
- f2fs_warn(sbi, "%s: inode (ino=%lx) has zero i_nlink",
+ f2fs_warn(sbi, "%s: inode (ino=%llx) has zero i_nlink",
__func__, inode->i_ino);
goto corrupted;
} else if (S_ISDIR(inode->i_mode) && unlikely(inode->i_nlink == 1)) {
- f2fs_warn(sbi, "%s: directory inode (ino=%lx) has a single i_nlink",
+ f2fs_warn(sbi, "%s: directory inode (ino=%llx) has a single i_nlink",
__func__, inode->i_ino);
goto corrupted;
}
err = -EFSCORRUPTED;
f2fs_err_ratelimited(sbi,
"inode mapping table is corrupted, run fsck to fix it, "
- "ino:%lu, nid:%u, level:%d, offset:%d",
+ "ino:%llu, nid:%u, level:%d, offset:%d",
dn->inode->i_ino, nids[i], level, offset[level]);
set_sbi_flag(sbi, SBI_NEED_FSCK);
goto release_pages;
return PTR_ERR(folio);
if (IS_INODE(folio) || ino_of_node(folio) != dn->inode->i_ino) {
- f2fs_err(sbi, "incorrect node reference, ino: %lu, nid: %u, ino_of_node: %u",
+ f2fs_err(sbi, "incorrect node reference, ino: %llu, nid: %u, ino_of_node: %u",
dn->inode->i_ino, dn->nid, ino_of_node(folio));
set_sbi_flag(sbi, SBI_NEED_FSCK);
f2fs_handle_error(sbi, ERROR_INVALID_NODE_REFERENCE);
if (level <= 0) {
if (!level) {
level = -EFSCORRUPTED;
- f2fs_err(sbi, "%s: inode ino=%lx has corrupted node block, from:%lu addrs:%u",
+ f2fs_err(sbi, "%s: inode ino=%llx has corrupted node block, from:%lu addrs:%u",
__func__, inode->i_ino,
from, ADDRS_PER_INODE(inode));
set_sbi_flag(sbi, SBI_NEED_FSCK);
set_sbi_flag(F2FS_F_SB(folio), SBI_NEED_FSCK);
f2fs_handle_error(sbi, ERROR_INVALID_BLKADDR);
f2fs_err_ratelimited(sbi,
- "truncate node fail, ino:%lu, nid:%u, "
+ "truncate node fail, ino:%llu, nid:%u, "
"offset[0]:%d, offset[1]:%d, nofs:%d",
inode->i_ino, dn.nid, offset[0],
offset[1], nofs);
if (unlikely(inode->i_blocks != 0 && inode->i_blocks != 8)) {
f2fs_warn(F2FS_I_SB(inode),
- "f2fs_remove_inode_page: inconsistent i_blocks, ino:%lu, iblocks:%llu",
+ "f2fs_remove_inode_page: inconsistent i_blocks, ino:%llu, iblocks:%llu",
inode->i_ino, (unsigned long long)inode->i_blocks);
set_sbi_flag(F2FS_I_SB(inode), SBI_NEED_FSCK);
}
name = "<encrypted>";
else
name = raw_inode->i_name;
- f2fs_notice(F2FS_I_SB(inode), "%s: ino = %x, name = %s, dir = %lx, err = %d",
+ f2fs_notice(F2FS_I_SB(inode), "%s: ino = %x, name = %s, dir = %llu, err = %d",
__func__, ino_of_node(ifolio), name,
IS_ERR(dir) ? 0 : dir->i_ino, err);
return err;
max_addrs = ADDRS_PER_PAGE(dn->node_folio, dn->inode);
if (ofs_in_node >= max_addrs) {
- f2fs_err(sbi, "Inconsistent ofs_in_node:%u in summary, ino:%lu, nid:%u, max:%u",
+ f2fs_err(sbi, "Inconsistent ofs_in_node:%u in summary, ino:%llu, nid:%u, max:%u",
ofs_in_node, dn->inode->i_ino, nid, max_addrs);
f2fs_handle_error(sbi, ERROR_INCONSISTENT_SUMMARY);
return -EFSCORRUPTED;
f2fs_bug_on(sbi, ni.ino != ino_of_node(folio));
if (ofs_of_node(dn.node_folio) != ofs_of_node(folio)) {
- f2fs_warn(sbi, "Inconsistent ofs_of_node, ino:%lu, ofs:%u, %u",
+ f2fs_warn(sbi, "Inconsistent ofs_of_node, ino:%llu, ofs:%u, %u",
inode->i_ino, ofs_of_node(dn.node_folio),
ofs_of_node(folio));
err = -EFSCORRUPTED;
if (f2fs_is_valid_blkaddr(sbi, dest,
DATA_GENERIC_ENHANCE_UPDATE)) {
- f2fs_err(sbi, "Inconsistent dest blkaddr:%u, ino:%lu, ofs:%u",
+ f2fs_err(sbi, "Inconsistent dest blkaddr:%u, ino:%llu, ofs:%u",
dest, inode->i_ino, dn.ofs_in_node);
err = -EFSCORRUPTED;
goto err;
err:
f2fs_put_dnode(&dn);
out:
- f2fs_notice(sbi, "recover_data: ino = %lx, nid = %x (i_size: %s), "
+ f2fs_notice(sbi, "recover_data: ino = %llx, nid = %x (i_size: %s), "
"range (%u, %u), recovered = %d, err = %d",
inode->i_ino, nid_of_node(folio),
file_keep_isize(inode) ? "keep" : "recover",
*xe = __find_xattr(cur_addr, last_txattr_addr, NULL, index, len, name);
if (!*xe) {
- f2fs_err(F2FS_I_SB(inode), "lookup inode (%lu) has corrupted xattr",
+ f2fs_err(F2FS_I_SB(inode), "lookup inode (%llu) has corrupted xattr",
inode->i_ino);
set_sbi_flag(F2FS_I_SB(inode), SBI_NEED_FSCK);
err = -ENODATA;
if ((void *)(entry) + sizeof(__u32) > last_base_addr ||
(void *)XATTR_NEXT_ENTRY(entry) > last_base_addr) {
- f2fs_err(F2FS_I_SB(inode), "list inode (%lu) has corrupted xattr",
+ f2fs_err(F2FS_I_SB(inode), "list inode (%llu) has corrupted xattr",
inode->i_ino);
set_sbi_flag(F2FS_I_SB(inode), SBI_NEED_FSCK);
f2fs_handle_error(F2FS_I_SB(inode),
if (!F2FS_I(inode)->i_xattr_nid) {
error = f2fs_recover_xattr_data(inode, NULL);
f2fs_notice(F2FS_I_SB(inode),
- "recover xattr in inode (%lu), error(%d)",
+ "recover xattr in inode (%llu), error(%d)",
inode->i_ino, error);
if (!error) {
kfree(base_addr);
goto retry;
}
}
- f2fs_err(F2FS_I_SB(inode), "set inode (%lu) has corrupted xattr",
+ f2fs_err(F2FS_I_SB(inode), "set inode (%llu) has corrupted xattr",
inode->i_ino);
set_sbi_flag(F2FS_I_SB(inode), SBI_NEED_FSCK);
error = -EFSCORRUPTED;
while (!IS_XATTR_LAST_ENTRY(last)) {
if ((void *)(last) + sizeof(__u32) > last_base_addr ||
(void *)XATTR_NEXT_ENTRY(last) > last_base_addr) {
- f2fs_err(F2FS_I_SB(inode), "inode (%lu) has invalid last xattr entry, entry_size: %zu",
+ f2fs_err(F2FS_I_SB(inode), "inode (%llu) has invalid last xattr entry, entry_size: %zu",
inode->i_ino, ENTRY_SIZE(last));
set_sbi_flag(F2FS_I_SB(inode), SBI_NEED_FSCK);
error = -EFSCORRUPTED;
if (VXFS_ISIMMED(vip))
goto unsupp;
- printk(KERN_WARNING "vxfs: inode %ld has no valid orgtype (%x)\n",
+ printk(KERN_WARNING "vxfs: inode %llu has no valid orgtype (%x)\n",
ip->i_ino, vip->vii_orgtype);
BUG();
unsupp:
- printk(KERN_WARNING "vxfs: inode %ld has an unsupported orgtype (%x)\n",
+ printk(KERN_WARNING "vxfs: inode %llu has an unsupported orgtype (%x)\n",
ip->i_ino, vip->vii_orgtype);
return 0;
}
lost:
if (inode)
pr_err_ratelimited(
- "%s: lost file I/O error report for ino %lu type %u pos 0x%llx len 0x%llx error %d",
+ "%s: lost file I/O error report for ino %llu type %u pos 0x%llx len 0x%llx error %d",
sb->s_id, inode->i_ino, type, pos, len, error);
else
pr_err_ratelimited(
int entry_size, type;
int err;
- hfs_dbg("cnid %u - (ino %lu, name %s) - (ino %lu, name %s)\n",
+ hfs_dbg("cnid %u - (ino %llu, name %s) - (ino %llu, name %s)\n",
cnid, src_dir->i_ino, src_name->name,
dst_dir->i_ino, dst_name->name);
sb = src_dir->i_sb;
goto out;
}
- hfs_dbg("ino %lu, start %u, len %u\n", inode->i_ino, start, len);
+ hfs_dbg("ino %llu, start %u, len %u\n", inode->i_ino, start, len);
if (HFS_I(inode)->alloc_blocks == HFS_I(inode)->first_blocks) {
if (!HFS_I(inode)->first_blocks) {
hfs_dbg("first_extent: start %u, len %u\n",
u32 size;
int res;
- hfs_dbg("ino %lu, phys_size %llu -> i_size %llu\n",
+ hfs_dbg("ino %llu, phys_size %llu -> i_size %llu\n",
inode->i_ino, (long long)HFS_I(inode)->phys_size,
inode->i_size);
if (inode->i_size > HFS_I(inode)->phys_size) {
{
struct super_block *sb = inode->i_sb;
- hfs_dbg("ino %lu\n", inode->i_ino);
+ hfs_dbg("ino %llu\n", inode->i_ino);
if (S_ISDIR(inode->i_mode)) {
atomic64_dec(&HFS_SB(sb)->folder_count);
if (HFS_I(inode)->cat_key.ParID == cpu_to_be32(HFS_ROOT_CNID))
hfs_cat_rec rec;
int res;
- hfs_dbg("ino %lu\n", inode->i_ino);
+ hfs_dbg("ino %llu\n", inode->i_ino);
res = hfs_ext_write_extent(inode);
if (res)
return res;
int entry_size;
int err;
- hfs_dbg("name %s, ino %ld\n",
+ hfs_dbg("name %s, ino %llu\n",
name ? name : NULL, inode->i_ino);
if (name) {
hfsplus_attr_entry *entry_ptr;
int err;
- hfs_dbg("name %s, ino %ld\n",
+ hfs_dbg("name %s, ino %llu\n",
name ? name : NULL, inode->i_ino);
if (!HFSPLUS_SB(sb)->attr_tree) {
struct super_block *sb = inode->i_sb;
int err;
- hfs_dbg("name %s, ino %ld\n",
+ hfs_dbg("name %s, ino %llu\n",
name ? name : NULL, inode->i_ino);
if (name) {
struct super_block *sb = inode->i_sb;
struct hfs_find_data fd;
- hfs_dbg("name %s, ino %ld\n",
+ hfs_dbg("name %s, ino %llu\n",
name ? name : NULL, inode->i_ino);
if (!HFSPLUS_SB(sb)->attr_tree) {
hfsplus_attr_entry *entry_ptr;
int err = 0;
- hfs_dbg("name %s, ino %ld\n",
+ hfs_dbg("name %s, ino %llu\n",
name ? name : NULL, inode->i_ino);
if (!HFSPLUS_SB(sb)->attr_tree) {
int entry_size, type;
int err;
- hfs_dbg("cnid %u - ino %lu, name %s - ino %lu, name %s\n",
+ hfs_dbg("cnid %u - ino %llu, name %s - ino %llu, name %s\n",
cnid, src_dir->i_ino, src_name->name,
dst_dir->i_ino, dst_name->name);
err = hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &src_fd);
if (!S_ISREG(inode->i_mode))
return -EPERM;
- hfs_dbg("src_dir->i_ino %lu, dst_dir->i_ino %lu, inode->i_ino %lu\n",
+ hfs_dbg("src_dir->i_ino %llu, dst_dir->i_ino %llu, inode->i_ino %llu\n",
src_dir->i_ino, dst_dir->i_ino, inode->i_ino);
mutex_lock(&sbi->vh_mutex);
if (HFSPLUS_IS_RSRC(inode))
return -EPERM;
- hfs_dbg("dir->i_ino %lu, inode->i_ino %lu\n",
+ hfs_dbg("dir->i_ino %llu, inode->i_ino %llu\n",
dir->i_ino, inode->i_ino);
mutex_lock(&sbi->vh_mutex);
if (inode->i_ino == cnid &&
atomic_read(&HFSPLUS_I(inode)->opencnt)) {
str.name = name;
- str.len = sprintf(name, "temp%lu", inode->i_ino);
+ str.len = sprintf(name, "temp%llu", inode->i_ino);
res = hfsplus_rename_cat(inode->i_ino,
dir, &dentry->d_name,
sbi->hidden_dir, &str);
mutex_unlock(&hip->extents_lock);
done:
- hfs_dbg("ino %lu, iblock %llu - dblock %u\n",
+ hfs_dbg("ino %llu, iblock %llu - dblock %u\n",
inode->i_ino, (long long)iblock, dblock);
mask = (1 << sbi->fs_shift) - 1;
goto out;
}
- hfs_dbg("ino %lu, start %u, len %u\n", inode->i_ino, start, len);
+ hfs_dbg("ino %llu, start %u, len %u\n", inode->i_ino, start, len);
if (hip->alloc_blocks <= hip->first_blocks) {
if (!hip->first_blocks) {
u32 alloc_cnt, blk_cnt, start;
int res;
- hfs_dbg("ino %lu, phys_size %llu -> i_size %llu\n",
+ hfs_dbg("ino %llu, phys_size %llu -> i_size %llu\n",
inode->i_ino, (long long)hip->phys_size, inode->i_size);
if (inode->i_size > hip->phys_size) {
inode->i_flags &= ~S_APPEND;
return 0;
bad_type:
- pr_err("invalid file type 0%04o for inode %lu\n", mode, inode->i_ino);
+ pr_err("invalid file type 0%04o for inode %llu\n", mode, inode->i_ino);
return -EIO;
}
struct hfsplus_vh *vhdr = sbi->s_vhdr;
int error = 0, error2;
- hfs_dbg("inode->i_ino %lu, start %llu, end %llu\n",
+ hfs_dbg("inode->i_ino %llu, start %llu, end %llu\n",
inode->i_ino, start, end);
error = file_write_and_wait_range(file, start, end);
hfsplus_cat_entry entry;
int res = 0;
- hfs_dbg("inode->i_ino %lu\n", inode->i_ino);
+ hfs_dbg("inode->i_ino %llu\n", inode->i_ino);
if (HFSPLUS_IS_RSRC(inode))
main_inode = HFSPLUS_I(inode)->rsrc_inode;
if (!res) {
res = hfs_btree_write(tree);
if (res) {
- pr_err("b-tree write err: %d, ino %lu\n",
+ pr_err("b-tree write err: %d, ino %llu\n",
res, inode->i_ino);
}
}
int err = hfs_btree_write(tree);
if (err) {
- pr_err("b-tree write err: %d, ino %lu\n",
+ pr_err("b-tree write err: %d, ino %llu\n",
err, inode->i_ino);
return err;
}
{
int err;
- hfs_dbg("ino %lu\n", inode->i_ino);
+ hfs_dbg("ino %llu\n", inode->i_ino);
err = hfsplus_ext_write_extent(inode);
if (err)
static void hfsplus_evict_inode(struct inode *inode)
{
- hfs_dbg("ino %lu\n", inode->i_ino);
+ hfs_dbg("ino %llu\n", inode->i_ino);
truncate_inode_pages_final(&inode->i_data);
clear_inode(inode);
if (HFSPLUS_IS_RSRC(inode)) {
u16 folder_finderinfo_len = sizeof(DInfo) + sizeof(DXInfo);
u16 file_finderinfo_len = sizeof(FInfo) + sizeof(FXInfo);
- hfs_dbg("ino %lu, name %s, value %p, size %zu\n",
+ hfs_dbg("ino %llu, name %s, value %p, size %zu\n",
inode->i_ino, name ? name : NULL,
value, size);
NLS_MAX_CHARSET_SIZE * HFSPLUS_ATTR_MAX_STRLEN + 1;
int res;
- hfs_dbg("ino %lu, name %s, prefix %s, prefixlen %zu, "
+ hfs_dbg("ino %llu, name %s, prefix %s, prefixlen %zu, "
"value %p, size %zu\n",
inode->i_ino, name ? name : NULL,
prefix ? prefix : NULL, prefixlen,
int res;
char *xattr_name;
- hfs_dbg("ino %lu, name %s, prefix %s\n",
+ hfs_dbg("ino %llu, name %s, prefix %s\n",
inode->i_ino, name ? name : NULL,
prefix ? prefix : NULL);
size_t strbuf_size;
int xattr_name_len;
- hfs_dbg("ino %lu\n", inode->i_ino);
+ hfs_dbg("ino %llu\n", inode->i_ino);
if (!is_xattr_operation_supported(inode))
return -EOPNOTSUPP;
int is_xattr_acl_deleted;
int is_all_xattrs_deleted;
- hfs_dbg("ino %lu, name %s\n",
+ hfs_dbg("ino %llu, name %s\n",
inode->i_ino, name ? name : NULL);
if (!HFSPLUS_SB(inode->i_sb)->attr_tree)
}
if (!fnode_is_dir(fno)) {
e = 1;
- hpfs_error(inode->i_sb, "not a directory, fnode %08lx",
- (unsigned long)inode->i_ino);
+ hpfs_error(inode->i_sb, "not a directory, fnode %08llx",
+ inode->i_ino);
}
if (hpfs_inode->i_dno != le32_to_cpu(fno->u.external[0].disk_secno)) {
e = 1;
if (hpfs_sb(i->i_sb)->sb_chk)
if (up != i->i_ino) {
hpfs_error(i->i_sb,
- "bad pointer to fnode, dnode %08x, pointing to %08x, should be %08lx",
+ "bad pointer to fnode, dnode %08x, pointing to %08x, should be %08llx",
dno, up,
- (unsigned long)i->i_ino);
+ i->i_ino);
return;
}
if ((d1 = hpfs_map_dnode(i->i_sb, down, &qbh1))) {
fnode->ea_offs = cpu_to_le16(0xc4);
}
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) {
- hpfs_error(s, "fnode %08lx: ea_offs == %03x, ea_size_s == %03x",
- (unsigned long)inode->i_ino,
+ hpfs_error(s, "fnode %08llx: ea_offs == %03x, ea_size_s == %03x",
+ inode->i_ino,
le16_to_cpu(fnode->ea_offs), le16_to_cpu(fnode->ea_size_s));
return;
}
hpfs_brelse4(&qbh);
} else
hpfs_error(i->i_sb,
- "directory %08lx doesn't have '.' entry",
- (unsigned long)i->i_ino);
+ "directory %08llx doesn't have '.' entry",
+ i->i_ino);
}
mark_buffer_dirty(bh);
brelse(bh);
struct dentry *dentry_ptr;
struct dentry dentry;
char fname[64] = {};
- unsigned long ino;
+ u64 ino;
/*
* If mapping is an invalid pointer, we don't want to crash
}
if (!dentry_first) {
- pr_warn("aops:%ps ino:%lx\n", a_ops, ino);
+ pr_warn("aops:%ps ino:%llx\n", a_ops, ino);
return;
}
dentry_ptr = container_of(dentry_first, struct dentry, d_u.d_alias);
if (get_kernel_nofault(dentry, dentry_ptr) ||
!dentry.d_parent || !dentry.d_name.name) {
- pr_warn("aops:%ps ino:%lx invalid dentry:%px\n",
+ pr_warn("aops:%ps ino:%llx invalid dentry:%px\n",
a_ops, ino, dentry_ptr);
return;
}
* Even if strncpy_from_kernel_nofault() succeeded,
* the fname could be unreliable
*/
- pr_warn("aops:%ps ino:%lx dentry name(?):\"%s\"\n",
+ pr_warn("aops:%ps ino:%llx dentry name(?):\"%s\"\n",
a_ops, ino, fname);
}
/* leave it no_open_fops */
break;
default:
- printk(KERN_DEBUG "init_special_inode: bogus i_mode (%o) for"
- " inode %s:%lu\n", mode, inode->i_sb->s_id,
- inode->i_ino);
+ pr_debug("init_special_inode: bogus i_mode (%o) for inode %s:%llu\n",
+ mode, inode->i_sb->s_id, inode->i_ino);
break;
}
}
mapping_set_error(inode->i_mapping, ioend->io_error);
if (!bio_flagged(bio, BIO_QUIET)) {
pr_err_ratelimited(
-"%s: writeback error on inode %lu, offset %lld, sector %llu",
+"%s: writeback error on inode %llu, offset %lld, sector %llu",
inode->i_sb->s_id, inode->i_ino,
ioend->io_offset, ioend->io_sector);
}
else {
printk(KERN_DEBUG
"zisofs: zisofs_inflate returned"
- " %d, inode = %lu,"
+ " %d, inode = %llu,"
" page idx = %d, bh idx = %d,"
" avail_in = %ld,"
" avail_out = %ld\n",
de_len < de->name_len[0] +
sizeof(struct iso_directory_record)) {
printk(KERN_NOTICE "iso9660: Corrupted directory entry"
- " in block %lu of inode %lu\n", block,
+ " in block %lu of inode %llu\n", block,
inode->i_ino);
brelse(bh);
return -EIO;
out_toomany:
printk(KERN_INFO "%s: More than 100 file sections ?!?, aborting...\n"
- "isofs_read_level3_size: inode=%lu\n",
+ "isofs_read_level3_size: inode=%llu\n",
__func__, inode->i_ino);
goto out;
}
/* I have no idea what file_unit_size is used for, so
we will flag it for now */
if (de->file_unit_size[0] != 0) {
- printk(KERN_DEBUG "ISOFS: File unit size != 0 for ISO file (%ld).\n",
+ printk(KERN_DEBUG "ISOFS: File unit size != 0 for ISO file (%llu).\n",
inode->i_ino);
}
/* XXX - parse_rock_ridge_inode() had already set i_rdev. */
init_special_inode(inode, inode->i_mode, inode->i_rdev);
} else {
- printk(KERN_DEBUG "ISOFS: Invalid file type 0%04o for inode %lu.\n",
+ printk(KERN_DEBUG "ISOFS: Invalid file type 0%04o for inode %llu.\n",
inode->i_mode, inode->i_ino);
ret = -EIO;
goto fail;
/* Basic sanity check, whether name doesn't exceed dir entry */
if (de_len < dlen + sizeof(struct iso_directory_record)) {
printk(KERN_NOTICE "iso9660: Corrupted directory entry"
- " in block %lu of inode %lu\n", block,
+ " in block %lu of inode %llu\n", block,
dir->i_ino);
brelse(bh);
return 0;
return err ? ERR_PTR(err) : ERR_PTR(-EINVAL);
}
- jbd2_debug(1, "JBD2: inode %s/%ld, size %lld, bits %d, blksize %ld\n",
+ jbd2_debug(1, "JBD2: inode %s/%llu, size %lld, bits %d, blksize %ld\n",
inode->i_sb->s_id, inode->i_ino, (long long) inode->i_size,
inode->i_sb->s_blocksize_bits, inode->i_sb->s_blocksize);
journal->j_inode = inode;
snprintf(journal->j_devname, sizeof(journal->j_devname),
- "%pg-%lu", journal->j_dev, journal->j_inode->i_ino);
+ "%pg-%llu", journal->j_dev, journal->j_inode->i_ino);
strreplace(journal->j_devname, '/', '!');
jbd2_stats_proc_init(journal);
return -EROFS;
journal = transaction->t_journal;
- jbd2_debug(4, "Adding inode %lu, tid:%d\n", jinode->i_vfs_inode->i_ino,
+ jbd2_debug(4, "Adding inode %llu, tid:%d\n", jinode->i_vfs_inode->i_ino,
transaction->t_tid);
spin_lock(&journal->j_list_lock);
struct jffs2_full_dirent *fd;
unsigned long curofs = 1;
- jffs2_dbg(1, "jffs2_readdir() for dir_i #%lu\n", inode->i_ino);
+ jffs2_dbg(1, "jffs2_readdir() for dir_i #%llu\n", inode->i_ino);
if (!dir_emit_dots(file, ctx))
return 0;
jffs2_free_raw_inode(ri);
- jffs2_dbg(1, "%s(): Created ino #%lu with mode %o, nlink %d(%d). nrpages %ld\n",
+ jffs2_dbg(1, "%s(): Created ino #%llu with mode %o, nlink %d(%d). nrpages %ld\n",
__func__, inode->i_ino, inode->i_mode, inode->i_nlink,
f->inocache->pino_nlink, inode->i_mapping->nrpages);
unsigned char *kaddr;
int ret;
- jffs2_dbg(2, "%s(): ino #%lu, page at offset 0x%lx\n",
+ jffs2_dbg(2, "%s(): ino #%llu, page at offset 0x%lx\n",
__func__, inode->i_ino, folio->index << PAGE_SHIFT);
BUG_ON(!folio_test_locked(folio));
uint32_t writtenlen = 0;
void *buf;
- jffs2_dbg(1, "%s(): ino #%lu, page at 0x%llx, range %d-%d, flags %lx\n",
+ jffs2_dbg(1, "%s(): ino #%llu, page at 0x%llx, range %d-%d, flags %lx\n",
__func__, inode->i_ino, folio_pos(folio),
start, end, folio->flags.f);
int ret;
int alloc_type = ALLOC_NORMAL;
- jffs2_dbg(1, "%s(): ino #%lu\n", __func__, inode->i_ino);
+ jffs2_dbg(1, "%s(): ino #%llu\n", __func__, inode->i_ino);
/* Special cases - we don't want more than one data node
for these types on the medium at any time. So setattr
struct jffs2_sb_info *c = JFFS2_SB_INFO(inode->i_sb);
struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
- jffs2_dbg(1, "%s(): ino #%lu mode %o\n",
+ jffs2_dbg(1, "%s(): ino #%llu mode %o\n",
__func__, inode->i_ino, inode->i_mode);
truncate_inode_pages_final(&inode->i_data);
clear_inode(inode);
ret = jffs2_read_dnode(c, f, f->metadata, (char *)&jdev, 0, f->metadata->size);
if (ret < 0) {
/* Eep */
- pr_notice("Read device numbers for inode %lu failed\n",
- (unsigned long)inode->i_ino);
+ pr_notice("Read device numbers for inode %llu failed\n",
+ inode->i_ino);
goto error;
}
if (f->metadata->size == sizeof(jdev.old_id))
break;
default:
- pr_warn("%s(): Bogus i_mode %o for ino %lu\n",
- __func__, inode->i_mode, (unsigned long)inode->i_ino);
+ pr_warn("%s(): Bogus i_mode %o for ino %llu\n",
+ __func__, inode->i_mode, inode->i_ino);
}
mutex_unlock(&f->sem);
struct iattr iattr;
if (!(inode_state_read_once(inode) & I_DIRTY_DATASYNC)) {
- jffs2_dbg(2, "%s(): not calling setattr() for ino #%lu\n",
+ jffs2_dbg(2, "%s(): not calling setattr() for ino #%llu\n",
__func__, inode->i_ino);
return;
}
- jffs2_dbg(1, "%s(): calling setattr() for ino #%lu\n",
+ jffs2_dbg(1, "%s(): calling setattr() for ino #%llu\n",
__func__, inode->i_ino);
iattr.ia_valid = ATTR_MODE|ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_MTIME|ATTR_CTIME;
struct jffs2_inode_info *f;
int ret;
- jffs2_dbg(1, "%s(): dir_i %ld, mode 0x%x\n",
+ jffs2_dbg(1, "%s(): dir_i %llu, mode 0x%x\n",
__func__, dir_i->i_ino, mode);
c = JFFS2_SB_INFO(sb);
inode->i_op = &jfs_file_inode_operations;
init_special_inode(inode, inode->i_mode, inode->i_rdev);
} else {
- printk(KERN_DEBUG "JFS: Invalid file type 0%04o for inode %lu.\n",
+ printk(KERN_DEBUG "JFS: Invalid file type 0%04o for inode %llu.\n",
inode->i_mode, inode->i_ino);
iget_failed(inode);
return ERR_PTR(-EIO);
unsigned long pageno;
int rel_inode;
- jfs_info("diRead: ino = %ld", ip->i_ino);
+ jfs_info("diRead: ino = %llu", ip->i_ino);
ipimap = sbi->ipimap;
JFS_IP(ip)->ipimap = ipimap;
unsigned long page_index;
unsigned long page_offset;
- jfs_info("__get_metapage: ino = %ld, lblock = 0x%lx, abs=%d",
+ jfs_info("__get_metapage: ino = %llu, lblock = 0x%lx, abs=%d",
inode->i_ino, lblock, absolute);
l2bsize = inode->i_blkbits;
int async_block = 0;
__be32 ret;
- dprintk("lockd: nlmsvc_lock(%s/%ld, ty=%d, pi=%d, %Ld-%Ld, bl=%d)\n",
+ dprintk("lockd: nlmsvc_lock(%s/%llu, ty=%d, pi=%d, %Ld-%Ld, bl=%d)\n",
inode->i_sb->s_id, inode->i_ino,
lock->fl.c.flc_type,
lock->fl.c.flc_pid,
int mode;
__be32 ret;
- dprintk("lockd: nlmsvc_testlock(%s/%ld, ty=%d, %Ld-%Ld)\n",
+ dprintk("lockd: nlmsvc_testlock(%s/%llu, ty=%d, %Ld-%Ld)\n",
nlmsvc_file_inode(file)->i_sb->s_id,
nlmsvc_file_inode(file)->i_ino,
lock->fl.c.flc_type,
{
int error = 0;
- dprintk("lockd: nlmsvc_unlock(%s/%ld, pi=%d, %Ld-%Ld)\n",
+ dprintk("lockd: nlmsvc_unlock(%s/%llu, pi=%d, %Ld-%Ld)\n",
nlmsvc_file_inode(file)->i_sb->s_id,
nlmsvc_file_inode(file)->i_ino,
lock->fl.c.flc_pid,
int status = 0;
int mode;
- dprintk("lockd: nlmsvc_cancel(%s/%ld, pi=%d, %Ld-%Ld)\n",
+ dprintk("lockd: nlmsvc_cancel(%s/%llu, pi=%d, %Ld-%Ld)\n",
nlmsvc_file_inode(file)->i_sb->s_id,
nlmsvc_file_inode(file)->i_ino,
lock->fl.c.flc_pid,
{
struct inode *inode = nlmsvc_file_inode(file);
- dprintk("lockd: %s %s/%ld\n",
+ dprintk("lockd: %s %s/%llu\n",
msg, inode->i_sb->s_id, inode->i_ino);
}
#else
if (unlikely(!list_empty(&ctx->flc_flock) ||
!list_empty(&ctx->flc_posix) ||
!list_empty(&ctx->flc_lease))) {
- pr_warn("Leaked locks on dev=0x%x:0x%x ino=0x%lx:\n",
+ pr_warn("Leaked locks on dev=0x%x:0x%x ino=0x%llx:\n",
MAJOR(inode->i_sb->s_dev), MINOR(inode->i_sb->s_dev),
inode->i_ino);
locks_dump_ctx_list(&ctx->flc_flock, "FLOCK");
list_for_each_entry(flc, list, flc_list)
if (flc->flc_file == filp)
- pr_warn("Leaked %s lock on dev=0x%x:0x%x ino=0x%lx "
+ pr_warn("Leaked %s lock on dev=0x%x:0x%x ino=0x%llx "
" fl_owner=%p fl_flags=0x%x fl_type=0x%x fl_pid=%u\n",
list_type, MAJOR(inode->i_sb->s_dev),
MINOR(inode->i_sb->s_dev), inode->i_ino,
(type == F_RDLCK) ? "READ" : "UNLCK");
if (inode) {
/* userspace relies on this representation of dev_t */
- seq_printf(f, "%d %02x:%02x:%lu ", pid,
+ seq_printf(f, "%d %02x:%02x:%llu ", pid,
MAJOR(inode->i_sb->s_dev),
MINOR(inode->i_sb->s_dev), inode->i_ino);
} else {
vaf.fmt = fmt;
vaf.va = &args;
printk(KERN_CRIT "minix-fs error (device %s): %s:%d: "
- "inode #%lu: comm %s: %pV\n",
+ "inode #%llu: comm %s: %pV\n",
inode->i_sb->s_id, function, line, inode->i_ino,
current->comm, &vaf);
va_end(args);
S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
init_special_inode(inode, inode->i_mode, rdev);
} else {
- printk(KERN_DEBUG "MINIX-fs: Invalid file type 0%04o for inode %lu.\n",
+ printk(KERN_DEBUG "MINIX-fs: Invalid file type 0%04o for inode %llu.\n",
inode->i_mode, inode->i_ino);
make_bad_inode(inode);
}
return ERR_PTR(-EIO);
}
if (raw_inode->i_nlinks == 0) {
- printk("MINIX-fs: deleted inode referenced: %lu\n",
+ printk("MINIX-fs: deleted inode referenced: %llu\n",
inode->i_ino);
brelse(bh);
iget_failed(inode);
return ERR_PTR(-EIO);
}
if (raw_inode->i_nlinks == 0) {
- printk("MINIX-fs: deleted inode referenced: %lu\n",
+ printk("MINIX-fs: deleted inode referenced: %llu\n",
inode->i_ino);
brelse(bh);
iget_failed(inode);
if (wbc->sync_mode == WB_SYNC_ALL && buffer_dirty(bh)) {
sync_dirty_buffer(bh);
if (buffer_req(bh) && !buffer_uptodate(bh)) {
- printk("IO error syncing minix inode [%s:%08lx]\n",
+ printk("IO error syncing minix inode [%s:%08llx]\n",
inode->i_sb->s_id, inode->i_ino);
err = -EIO;
}
}
error = nfs_lookup_verify_inode(inode, flags);
- dfprintk(LOOKUPCACHE, "NFS: %s: inode %lu is %s\n",
+ dfprintk(LOOKUPCACHE, "NFS: %s: inode %llu is %s\n",
__func__, inode->i_ino, error ? "invalid" : "valid");
return !error;
}
/* Expect a negative dentry */
BUG_ON(d_inode(dentry));
- dfprintk(VFS, "NFS: atomic_open(%s/%lu), %pd\n",
+ dfprintk(VFS, "NFS: atomic_open(%s/%llu), %pd\n",
dir->i_sb->s_id, dir->i_ino, dentry);
err = nfs_check_flags(open_flags);
open_flags |= O_CREAT;
- dfprintk(VFS, "NFS: create(%s/%lu), %pd\n",
+ dfprintk(VFS, "NFS: create(%s/%llu), %pd\n",
dir->i_sb->s_id, dir->i_ino, dentry);
attr.ia_mode = mode;
struct iattr attr;
int status;
- dfprintk(VFS, "NFS: mknod(%s/%lu), %pd\n",
+ dfprintk(VFS, "NFS: mknod(%s/%llu), %pd\n",
dir->i_sb->s_id, dir->i_ino, dentry);
attr.ia_mode = mode;
struct iattr attr;
struct dentry *ret;
- dfprintk(VFS, "NFS: mkdir(%s/%lu), %pd\n",
+ dfprintk(VFS, "NFS: mkdir(%s/%llu), %pd\n",
dir->i_sb->s_id, dir->i_ino, dentry);
attr.ia_valid = ATTR_MODE;
{
int error;
- dfprintk(VFS, "NFS: rmdir(%s/%lu), %pd\n",
+ dfprintk(VFS, "NFS: rmdir(%s/%llu), %pd\n",
dir->i_sb->s_id, dir->i_ino, dentry);
trace_nfs_rmdir_enter(dir, dentry);
{
int error;
- dfprintk(VFS, "NFS: unlink(%s/%lu, %pd)\n", dir->i_sb->s_id,
+ dfprintk(VFS, "NFS: unlink(%s/%llu, %pd)\n", dir->i_sb->s_id,
dir->i_ino, dentry);
trace_nfs_unlink_enter(dir, dentry);
unsigned int pathlen = strlen(symname);
int error;
- dfprintk(VFS, "NFS: symlink(%s/%lu, %pd, %s)\n", dir->i_sb->s_id,
+ dfprintk(VFS, "NFS: symlink(%s/%llu, %pd, %s)\n", dir->i_sb->s_id,
dir->i_ino, dentry, symname);
if (pathlen > PAGE_SIZE)
error = NFS_PROTO(dir)->symlink(dir, dentry, folio, pathlen, &attr);
trace_nfs_symlink_exit(dir, dentry, error);
if (error != 0) {
- dfprintk(VFS, "NFS: symlink(%s/%lu, %pd, %s) error %d\n",
+ dfprintk(VFS, "NFS: symlink(%s/%llu, %pd, %s) error %d\n",
dir->i_sb->s_id, dir->i_ino,
dentry, symname, error);
d_drop(dentry);
if (!res && (mask & MAY_EXEC))
res = nfs_execute_ok(inode, mask);
- dfprintk(VFS, "NFS: permission(%s/%lu), mask=0x%x, res=%d\n",
+ dfprintk(VFS, "NFS: permission(%s/%llu), mask=0x%x, res=%d\n",
inode->i_sb->s_id, inode->i_ino, mask, res);
return res;
out_notsup:
trace_nfs_write_begin(file_inode(file), pos, len);
- dfprintk(PAGECACHE, "NFS: write_begin(%pD2(%lu), %u@%lld)\n",
+ dfprintk(PAGECACHE, "NFS: write_begin(%pD2(%llu), %u@%lld)\n",
file, mapping->host->i_ino, len, (long long) pos);
nfs_truncate_last_folio(mapping, i_size_read(mapping->host), pos);
int status;
trace_nfs_write_end(file_inode(file), pos, len);
- dfprintk(PAGECACHE, "NFS: write_end(%pD2(%lu), %u@%lld)\n",
+ dfprintk(PAGECACHE, "NFS: write_end(%pD2(%llu), %u@%lld)\n",
file, mapping->host->i_ino, len, (long long) pos);
/*
struct inode *inode = folio->mapping->host;
int ret;
- dfprintk(PAGECACHE, "NFS: launder_folio(%ld, %llu)\n",
+ dfprintk(PAGECACHE, "NFS: launder_folio(%llu, %llu)\n",
inode->i_ino, folio_pos(folio));
folio_wait_private_2(folio); /* [DEPRECATED] */
struct address_space *mapping;
struct folio *folio = page_folio(vmf->page);
- dfprintk(PAGECACHE, "NFS: vm_page_mkwrite(%pD2(%lu), offset %lld)\n",
+ dfprintk(PAGECACHE, "NFS: vm_page_mkwrite(%pD2(%llu), offset %lld)\n",
filp, filp->f_mapping->host->i_ino,
(long long)folio_pos(folio));
/* Note: if the write is unstable, don't set end_offs until commit */
pnfs_set_layoutcommit(hdr->inode, hdr->lseg, end_offs);
- dprintk("%s inode %lu pls_end_pos %lu\n", __func__, hdr->inode->i_ino,
+ dprintk("%s inode %llu pls_end_pos %lu\n", __func__, hdr->inode->i_ino,
(unsigned long) NFS_I(hdr->inode)->layout->plh_lwb);
}
u32 j, idx;
struct nfs_fh *fh;
- dprintk("--> %s ino %lu pgbase %u req %zu@%llu\n",
+ dprintk("--> %s ino %llu pgbase %u req %zu@%llu\n",
__func__, hdr->inode->i_ino,
hdr->args.pgbase, (size_t)hdr->args.count, offset);
if (IS_ERR(ds_clnt))
return PNFS_NOT_ATTEMPTED;
- dprintk("%s ino %lu sync %d req %zu@%llu DS: %s cl_count %d\n",
+ dprintk("%s ino %llu sync %d req %zu@%llu DS: %s cl_count %d\n",
__func__, hdr->inode->i_ino, sync, (size_t) hdr->args.count,
offset, ds->ds_remotestr, refcount_read(&ds->ds_clp->cl_count));
if (IS_ERR(ds_clnt))
goto out_err;
- dprintk("%s ino %lu, how %d cl_count %d\n", __func__,
+ dprintk("%s ino %llu, how %d cl_count %d\n", __func__,
data->inode->i_ino, how, refcount_read(&ds->ds_clp->cl_count));
data->commit_done_cb = filelayout_commit_done_cb;
refcount_inc(&ds->ds_clp->cl_count);
return;
pnfs_set_layoutcommit(inode, lseg, end_offset);
- dprintk("%s inode %lu pls_end_pos %llu\n", __func__, inode->i_ino,
+ dprintk("%s inode %llu pls_end_pos %llu\n", __func__, inode->i_ino,
(unsigned long long) NFS_I(inode)->layout->plh_lwb);
}
u32 dss_id;
bool ds_fatal_error = false;
- dprintk("--> %s ino %lu pgbase %u req %zu@%llu\n",
+ dprintk("--> %s ino %llu pgbase %u req %zu@%llu\n",
__func__, hdr->inode->i_ino,
hdr->args.pgbase, (size_t)hdr->args.count, offset);
vers = nfs4_ff_layout_ds_version(mirror, dss_id);
- dprintk("%s ino %lu sync %d req %zu@%llu DS: %s cl_count %d vers %d\n",
+ dprintk("%s ino %llu sync %d req %zu@%llu DS: %s cl_count %d vers %d\n",
__func__, hdr->inode->i_ino, sync, (size_t) hdr->args.count,
offset, ds->ds_remotestr, refcount_read(&ds->ds_clp->cl_count),
vers);
vers = nfs4_ff_layout_ds_version(mirror, dss_id);
- dprintk("%s ino %lu, how %d cl_count %d vers %d\n", __func__,
+ dprintk("%s ino %llu, how %d cl_count %d vers %d\n", __func__,
data->inode->i_ino, how, refcount_read(&ds->ds_clp->cl_count),
vers);
data->commit_done_cb = ff_layout_commit_done_cb;
bool attr_changed = false;
bool have_delegation;
- dfprintk(VFS, "NFS: %s(%s/%lu fh_crc=0x%08x ct=%d info=0x%llx)\n",
+ dfprintk(VFS, "NFS: %s(%s/%llu fh_crc=0x%08x ct=%d info=0x%llx)\n",
__func__, inode->i_sb->s_id, inode->i_ino,
nfs_display_fhandle_hash(NFS_FH(inode)),
icount_read(inode), fattr->valid);
/*
* Big trouble! The inode has become a different object.
*/
- printk(KERN_DEBUG "NFS: %s: inode %lu mode changed, %07o to %07o\n",
+ printk(KERN_DEBUG "NFS: %s: inode %llu mode changed, %07o to %07o\n",
__func__, inode->i_ino, inode->i_mode, fattr->mode);
goto out_err;
}
if (S_ISDIR(inode->i_mode))
nfs_force_lookup_revalidate(inode);
attr_changed = true;
- dprintk("NFS: change_attr change on server for file %s/%ld\n",
+ dprintk("NFS: change_attr change on server for file %s/%llu\n",
inode->i_sb->s_id,
inode->i_ino);
} else if (!have_delegation) {
nfs_fattr_init(fattr);
nfs4_init_sequence(server->nfs_client, &args.seq_args, &res.seq_res, 0, 0);
- dprintk("NFS call lookupp ino=0x%lx\n", inode->i_ino);
+ dprintk("NFS call lookupp ino=0x%llx\n", inode->i_ino);
status = nfs4_do_call_sync(clnt, server, &msg, &args.seq_args,
&res.seq_res, task_flags);
dprintk("NFS reply lookupp: %d\n", status);
int status = 0;
dprintk("NFS: initiating layoutcommit call. sync %d "
- "lbw: %llu inode %lu\n", sync,
+ "lbw: %llu inode %llu\n", sync,
data->args.lastbytewritten,
data->args.inode->i_ino);
while (!list_empty(layout_list)) {
lo = list_entry(layout_list->next, struct pnfs_layout_hdr,
plh_bulk_destroy);
- dprintk("%s freeing layout for inode %lu\n", __func__,
+ dprintk("%s freeing layout for inode %llu\n", __func__,
lo->plh_inode->i_ino);
inode = lo->plh_inode;
int status = 0;
bool send, valid_layout;
- dprintk("NFS: %s for inode %lu\n", __func__, ino->i_ino);
+ dprintk("NFS: %s for inode %llu\n", __func__, ino->i_ino);
spin_lock(&ino->i_lock);
lo = nfsi->layout;
hdr->mds_ops = call_ops;
- dprintk("%s: Writing ino:%lu %u@%llu (how %d)\n", __func__,
+ dprintk("%s: Writing ino:%llu %u@%llu (how %d)\n", __func__,
inode->i_ino, hdr->args.count, hdr->args.offset, how);
trypnfs = nfss->pnfs_curr_ld->write_pagelist(hdr, how);
if (trypnfs != PNFS_NOT_ATTEMPTED)
hdr->mds_ops = call_ops;
- dprintk("%s: Reading ino:%lu %u@%llu\n",
+ dprintk("%s: Reading ino:%llu %u@%llu\n",
__func__, inode->i_ino, hdr->args.count, hdr->args.offset);
trypnfs = nfss->pnfs_curr_ld->read_pagelist(hdr);
if (!test_and_set_bit(NFS_INO_LAYOUTCOMMIT, &nfsi->flags)) {
nfsi->layout->plh_lwb = end_pos;
mark_as_dirty = true;
- dprintk("%s: Set layoutcommit for inode %lu ",
+ dprintk("%s: Set layoutcommit for inode %llu ",
__func__, inode->i_ino);
} else if (end_pos > nfsi->layout->plh_lwb)
nfsi->layout->plh_lwb = end_pos;
if (!pnfs_layoutcommit_outstanding(inode))
return 0;
- dprintk("--> %s inode %lu\n", __func__, inode->i_ino);
+ dprintk("--> %s inode %llu\n", __func__, inode->i_ino);
status = -EAGAIN;
if (test_and_set_bit(NFS_INO_LAYOUTCOMMITTING, &nfsi->flags)) {
}
inode = d_inode(path.dentry);
- dprintk("nfsd: exp_rootfh(%s [%p] %s:%s/%ld)\n",
+ dprintk("nfsd: exp_rootfh(%s [%p] %s:%s/%llu)\n",
name, path.dentry, clp->name,
inode->i_sb->s_id, inode->i_ino);
exp = exp_parent(cd, clp, &path);
if (ret) {
struct inode *inode = file_inode(f);
- pr_notice_ratelimited("nfsd: Unable to update timestamps on inode %02x:%02x:%lu: %d\n",
+ pr_notice_ratelimited("nfsd: Unable to update timestamps on inode %02x:%02x:%llu: %d\n",
MAJOR(inode->i_sb->s_dev),
MINOR(inode->i_sb->s_dev),
inode->i_ino, ret);
{
struct inode *inode = file_inode(f->nf_file);
- seq_printf(s, "superblock: \"%02x:%02x:%ld\"",
+ seq_printf(s, "superblock: \"%02x:%02x:%llu\"",
MAJOR(inode->i_sb->s_dev),
MINOR(inode->i_sb->s_dev),
inode->i_ino);
struct inode * inode = d_inode(dentry);
dev_t ex_dev = exp_sb(exp)->s_dev;
- dprintk("nfsd: fh_compose(exp %02x:%02x/%ld %pd2, ino=%ld)\n",
+ dprintk("nfsd: fh_compose(exp %02x:%02x/%llu %pd2, ino=%llu)\n",
MAJOR(ex_dev), MINOR(ex_dev),
- (long) d_inode(exp->ex_path.dentry)->i_ino,
+ d_inode(exp->ex_path.dentry)->i_ino,
dentry,
(inode ? inode->i_ino : 0));
} else if (unlikely(host_err == -EINVAL)) {
struct inode *inode = d_inode(fhp->fh_dentry);
- pr_info_ratelimited("nfsd: Direct I/O alignment failure on %s/%ld\n",
+ pr_info_ratelimited("nfsd: Direct I/O alignment failure on %s/%llu\n",
inode->i_sb->s_id, inode->i_ino);
host_err = -ESERVERFAULT;
}
if (!nilfs_clear_bit_atomic(lock, group_offset, bitmap))
nilfs_warn(inode->i_sb,
- "%s (ino=%lu): entry number %llu already freed",
+ "%s (ino=%llu): entry number %llu already freed",
__func__, inode->i_ino,
(unsigned long long)req->pr_entry_nr);
else
if (!nilfs_clear_bit_atomic(lock, group_offset, bitmap))
nilfs_warn(inode->i_sb,
- "%s (ino=%lu): entry number %llu already freed",
+ "%s (ino=%llu): entry number %llu already freed",
__func__, inode->i_ino,
(unsigned long long)req->pr_entry_nr);
else
if (!nilfs_clear_bit_atomic(lock, group_offset,
bitmap)) {
nilfs_warn(inode->i_sb,
- "%s (ino=%lu): entry number %llu already freed",
+ "%s (ino=%llu): entry number %llu already freed",
__func__, inode->i_ino,
(unsigned long long)entry_nrs[j]);
} else {
last_nrs[k]);
if (ret && ret != -ENOENT)
nilfs_warn(inode->i_sb,
- "error %d deleting block that object (entry=%llu, ino=%lu) belongs to",
+ "error %d deleting block that object (entry=%llu, ino=%llu) belongs to",
ret, (unsigned long long)last_nrs[k],
inode->i_ino);
}
ret = nilfs_palloc_delete_bitmap_block(inode, group);
if (ret && ret != -ENOENT)
nilfs_warn(inode->i_sb,
- "error %d deleting bitmap block of group=%lu, ino=%lu",
+ "error %d deleting bitmap block of group=%lu, ino=%llu",
ret, group, inode->i_ino);
}
}
if (err == -EINVAL) {
__nilfs_error(inode->i_sb, fname,
- "broken bmap (inode number=%lu)", inode->i_ino);
+ "broken bmap (inode number=%llu)", inode->i_ino);
err = -EIO;
}
return err;
* clearing of an abandoned b-tree node is missing somewhere).
*/
nilfs_error(inode->i_sb,
- "state inconsistency probably due to duplicate use of b-tree node block address %llu (ino=%lu)",
+ "state inconsistency probably due to duplicate use of b-tree node block address %llu (ino=%llu)",
(unsigned long long)blocknr, inode->i_ino);
goto failed;
}
nchildren <= 0 ||
nchildren > NILFS_BTREE_NODE_NCHILDREN_MAX(size))) {
nilfs_crit(inode->i_sb,
- "bad btree node (ino=%lu, blocknr=%llu): level = %d, flags = 0x%x, nchildren = %d",
+ "bad btree node (ino=%llu, blocknr=%llu): level = %d, flags = 0x%x, nchildren = %d",
inode->i_ino, (unsigned long long)blocknr, level,
flags, nchildren);
ret = 1;
nchildren > NILFS_BTREE_ROOT_NCHILDREN_MAX ||
(nchildren == 0 && level > NILFS_BTREE_LEVEL_NODE_MIN))) {
nilfs_crit(inode->i_sb,
- "bad btree root (ino=%lu): level = %d, flags = 0x%x, nchildren = %d",
+ "bad btree root (ino=%llu): level = %d, flags = 0x%x, nchildren = %d",
inode->i_ino, level, flags, nchildren);
ret = 1;
}
if (unlikely(nilfs_btree_node_get_level(node) != level)) {
dump_stack();
nilfs_crit(btree->b_inode->i_sb,
- "btree level mismatch (ino=%lu): %d != %d",
+ "btree level mismatch (ino=%llu): %d != %d",
btree->b_inode->i_ino,
nilfs_btree_node_get_level(node), level);
return 1;
out_no_wait:
if (!buffer_uptodate(bh)) {
nilfs_err(btree->b_inode->i_sb,
- "I/O error reading b-tree node block (ino=%lu, blocknr=%llu)",
+ "I/O error reading b-tree node block (ino=%llu, blocknr=%llu)",
btree->b_inode->i_ino, (unsigned long long)ptr);
brelse(bh);
return -EIO;
if (ret < 0) {
if (unlikely(ret == -ENOENT)) {
nilfs_crit(btree->b_inode->i_sb,
- "writing node/leaf block does not appear in b-tree (ino=%lu) at key=%llu, level=%d",
+ "writing node/leaf block does not appear in b-tree (ino=%llu) at key=%llu, level=%d",
btree->b_inode->i_ino,
(unsigned long long)key, level);
ret = -EINVAL;
level >= NILFS_BTREE_LEVEL_MAX) {
dump_stack();
nilfs_warn(btree->b_inode->i_sb,
- "invalid btree level: %d (key=%llu, ino=%lu, blocknr=%llu)",
+ "invalid btree level: %d (key=%llu, ino=%llu, blocknr=%llu)",
level, (unsigned long long)key,
btree->b_inode->i_ino,
(unsigned long long)bh->b_blocknr);
Ebadsize:
nilfs_error(sb,
- "size of directory #%lu is not a multiple of chunk size",
+ "size of directory #%llu is not a multiple of chunk size",
dir->i_ino);
goto fail;
Eshort:
error = "disallowed inode number";
bad_entry:
nilfs_error(sb,
- "bad entry in directory #%lu: %s - offset=%lu, inode=%lu, rec_len=%zd, name_len=%d",
+ "bad entry in directory #%llu: %s - offset=%lu, inode=%lu, rec_len=%zd, name_len=%d",
dir->i_ino, error, (folio->index << PAGE_SHIFT) + offs,
(unsigned long)le64_to_cpu(p->inode),
rec_len, p->name_len);
Eend:
p = (struct nilfs_dir_entry *)(kaddr + offs);
nilfs_error(sb,
- "entry in directory #%lu spans the page boundary offset=%lu, inode=%lu",
+ "entry in directory #%llu spans the page boundary offset=%lu, inode=%lu",
dir->i_ino, (folio->index << PAGE_SHIFT) + offs,
(unsigned long)le64_to_cpu(p->inode));
fail:
kaddr = nilfs_get_folio(inode, n, &folio);
if (IS_ERR(kaddr)) {
- nilfs_error(sb, "bad page in #%lu", inode->i_ino);
+ nilfs_error(sb, "bad page in #%llu", inode->i_ino);
ctx->pos += PAGE_SIZE - offset;
return -EIO;
}
/* next folio is past the blocks we've got */
if (unlikely(n > (dir->i_blocks >> (PAGE_SHIFT - 9)))) {
nilfs_error(dir->i_sb,
- "dir %lu size %lld exceeds block count %llu",
+ "dir %llu size %lld exceeds block count %llu",
dir->i_ino, dir->i_size,
(unsigned long long)dir->i_blocks);
goto out;
return next_de;
fail:
- nilfs_error(dir->i_sb, "directory #%lu %s", dir->i_ino, msg);
+ nilfs_error(dir->i_sb, "directory #%llu %s", dir->i_ino, msg);
folio_release_kmap(folio, de);
return NULL;
}
key = nilfs_bmap_data_get_key(bmap, *bh);
if (unlikely(key > NILFS_DIRECT_KEY_MAX)) {
nilfs_crit(bmap->b_inode->i_sb,
- "%s (ino=%lu): invalid key: %llu",
+ "%s (ino=%llu): invalid key: %llu",
__func__,
bmap->b_inode->i_ino, (unsigned long long)key);
return -EINVAL;
ptr = nilfs_direct_get_ptr(bmap, key);
if (unlikely(ptr == NILFS_BMAP_INVALID_PTR)) {
nilfs_crit(bmap->b_inode->i_sb,
- "%s (ino=%lu): invalid pointer: %llu",
+ "%s (ino=%llu): invalid pointer: %llu",
__func__,
bmap->b_inode->i_ino, (unsigned long long)ptr);
return -EINVAL;
struct inode *inode = bh->b_folio->mapping->host;
nilfs_err(inode->i_sb,
- "I/O error reading %s block for GC (ino=%lu, vblocknr=%llu)",
+ "I/O error reading %s block for GC (ino=%llu, vblocknr=%llu)",
buffer_nilfs_node(bh) ? "node" : "data",
inode->i_ino, (unsigned long long)bh->b_blocknr);
return -EIO;
* be locked in this case.
*/
nilfs_warn(inode->i_sb,
- "%s (ino=%lu): a race condition while inserting a data block at offset=%llu",
+ "%s (ino=%llu): a race condition while inserting a data block at offset=%llu",
__func__, inode->i_ino,
(unsigned long long)blkoff);
err = -EAGAIN;
goto repeat;
failed:
- nilfs_warn(ii->vfs_inode.i_sb, "error %d truncating bmap (ino=%lu)",
+ nilfs_warn(ii->vfs_inode.i_sb, "error %d truncating bmap (ino=%llu)",
ret, ii->vfs_inode.i_ino);
}
* this inode.
*/
nilfs_warn(inode->i_sb,
- "cannot set file dirty (ino=%lu): the file is being freed",
+ "cannot set file dirty (ino=%llu): the file is being freed",
inode->i_ino);
spin_unlock(&nilfs->ns_inode_lock);
return -EINVAL; /*
err = nilfs_load_inode_block(inode, &ibh);
if (unlikely(err)) {
nilfs_warn(inode->i_sb,
- "cannot mark inode dirty (ino=%lu): error %d loading inode block",
+ "cannot mark inode dirty (ino=%llu): error %d loading inode block",
inode->i_ino, err);
return err;
}
err = -EIO;
if (!buffer_uptodate(first_bh)) {
nilfs_err(inode->i_sb,
- "I/O error reading meta-data file (ino=%lu, block-offset=%lu)",
+ "I/O error reading meta-data file (ino=%llu, block-offset=%lu)",
inode->i_ino, block);
goto failed_bh;
}
if (!inode->i_nlink) {
nilfs_warn(inode->i_sb,
- "deleting nonexistent file (ino=%lu), %d",
+ "deleting nonexistent file (ino=%llu), %d",
inode->i_ino, inode->i_nlink);
set_nlink(inode, 1);
}
ifile, ii->vfs_inode.i_ino, &ibh);
if (unlikely(err)) {
nilfs_warn(sci->sc_super,
- "log writer: error %d getting inode block (ino=%lu)",
+ "log writer: error %d getting inode block (ino=%llu)",
err, ii->vfs_inode.i_ino);
return err;
}
inode_mark = container_of(mark, struct inotify_inode_mark, fsn_mark);
inode = igrab(fsnotify_conn_inode(mark->connector));
if (inode) {
- seq_printf(m, "inotify wd:%x ino:%lx sdev:%x mask:%x ignored_mask:0 ",
+ seq_printf(m, "inotify wd:%x ino:%llx sdev:%x mask:%x ignored_mask:0 ",
inode_mark->wd, inode->i_ino, inode->i_sb->s_dev,
inotify_mark_user_mask(mark));
show_mark_fhandle(m, inode);
inode = igrab(fsnotify_conn_inode(mark->connector));
if (!inode)
return;
- seq_printf(m, "fanotify ino:%lx sdev:%x mflags:%x mask:%x ignored_mask:%x ",
+ seq_printf(m, "fanotify ino:%llx sdev:%x mflags:%x mask:%x ignored_mask:%x ",
inode->i_ino, inode->i_sb->s_dev,
mflags, mark->mask, mark->ignore_mask);
show_mark_fhandle(m, inode);
struct ns_common *ns = inode->i_private;
const struct proc_ns_operations *ns_ops = ns->ops;
- return dynamic_dname(buffer, buflen, "%s:[%lu]",
+ return dynamic_dname(buffer, buflen, "%s:[%llu]",
ns_ops->name, inode->i_ino);
}
const struct ns_common *ns = inode->i_private;
const struct proc_ns_operations *ns_ops = ns->ops;
- seq_printf(seq, "%s:[%lu]", ns_ops->name, inode->i_ino);
+ seq_printf(seq, "%s:[%llu]", ns_ops->name, inode->i_ino);
return 0;
}
vaf.fmt = printk_skip_level(fmt);
vaf.va = &args;
- printk("%c%cntfs3(%s): ino=%lx,%s %pV\n", KERN_SOH_ASCII, level,
+ printk("%c%cntfs3(%s): ino=%llx,%s %pV\n", KERN_SOH_ASCII, level,
sb->s_id, inode->i_ino, name ? name : "", &vaf);
va_end(args);
* to check it up here before changing the tree.
*/
if (root_el->l_tree_depth && rec->e_int_clusters == 0) {
- mlog(ML_ERROR, "Inode %lu has an empty "
+ mlog(ML_ERROR, "Inode %llu has an empty "
"extent record, depth %u\n", inode->i_ino,
le16_to_cpu(root_el->l_tree_depth));
status = ocfs2_remove_rightmost_empty_extent(osb,
(unsigned long long)iblock, bh_result, create);
if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_SYSTEM_FILE)
- mlog(ML_NOTICE, "get_block on system inode 0x%p (%lu)\n",
+ mlog(ML_NOTICE, "get_block on system inode 0x%p (%llu)\n",
inode, inode->i_ino);
if (S_ISLNK(inode->i_mode)) {
((iblock + ((len - 1) >> i_blkbits)) > endblk))
len = (endblk - iblock + 1) << i_blkbits;
- mlog(0, "get block of %lu at %llu:%u req %u\n",
+ mlog(0, "get block of %llu at %llu:%u req %u\n",
inode->i_ino, pos, len, total_len);
/*
if (le16_to_cpu(el->l_count) !=
ocfs2_extent_recs_per_dx_root(inode->i_sb)) {
ret = ocfs2_error(inode->i_sb,
- "Inode %lu has invalid extent list length %u\n",
+ "Inode %llu has invalid extent list length %u\n",
inode->i_ino, le16_to_cpu(el->l_count));
goto out;
}
if (el->l_tree_depth) {
ret = ocfs2_error(inode->i_sb,
- "Inode %lu has non zero tree depth in btree tree block %llu\n",
+ "Inode %llu has non zero tree depth in btree tree block %llu\n",
inode->i_ino,
(unsigned long long)eb_bh->b_blocknr);
goto out;
if (le16_to_cpu(el->l_next_free_rec) == 0) {
ret = ocfs2_error(inode->i_sb,
- "Inode %lu has empty extent list at depth %u\n",
+ "Inode %llu has empty extent list at depth %u\n",
inode->i_ino,
le16_to_cpu(el->l_tree_depth));
goto out;
if (!found) {
ret = ocfs2_error(inode->i_sb,
- "Inode %lu has bad extent record (%u, %u, 0) in btree\n",
+ "Inode %llu has bad extent record (%u, %u, 0) in btree\n",
inode->i_ino,
le32_to_cpu(rec->e_cpos),
ocfs2_rec_clusters(el, rec));
if (S_ISDIR(inode->i_mode))
BUG();
- mlog(0, "open called on inode %lu, flags 0x%x\n", inode->i_ino,
+ mlog(0, "open called on inode %llu, flags 0x%x\n", inode->i_ino,
file->f_flags);
status = dlmfs_decode_open_flags(file->f_flags, &level, &flags);
if (S_ISDIR(inode->i_mode))
BUG();
- mlog(0, "close called on inode %lu\n", inode->i_ino);
+ mlog(0, "close called on inode %llu\n", inode->i_ino);
if (fp) {
level = fp->fp_lock_level;
int bytes_left;
struct inode *inode = file_inode(filp);
- mlog(0, "inode %lu, count = %zu, *ppos = %llu\n",
+ mlog(0, "inode %llu, count = %zu, *ppos = %llu\n",
inode->i_ino, count, *ppos);
if (*ppos >= DLM_LVB_LEN)
clear_inode(inode);
- mlog(0, "inode %lu\n", inode->i_ino);
+ mlog(0, "inode %llu\n", inode->i_ino);
ip = DLMFS_I(inode);
lockres = &ip->ip_lockres;
int status;
struct inode *inode = d_inode(dentry);
- mlog(0, "unlink inode %lu\n", inode->i_ino);
+ mlog(0, "unlink inode %llu\n", inode->i_ino);
/* if there are no current holders, or none that are waiting
* to acquire a lock, this basically destroys our lockres. */
if (el->l_tree_depth) {
ocfs2_error(inode->i_sb,
- "Inode %lu has non zero tree depth in leaf block %llu\n",
+ "Inode %llu has non zero tree depth in leaf block %llu\n",
inode->i_ino,
(unsigned long long)eb_bh->b_blocknr);
ret = -EROFS;
if (el->l_tree_depth) {
ocfs2_error(inode->i_sb,
- "Inode %lu has non zero tree depth in leaf block %llu\n",
+ "Inode %llu has non zero tree depth in leaf block %llu\n",
inode->i_ino,
(unsigned long long)eb_bh->b_blocknr);
ret = -EROFS;
if (le16_to_cpu(el->l_next_free_rec) > le16_to_cpu(el->l_count)) {
ocfs2_error(inode->i_sb,
- "Inode %lu has an invalid extent (next_free_rec %u, count %u)\n",
+ "Inode %llu has an invalid extent (next_free_rec %u, count %u)\n",
inode->i_ino,
le16_to_cpu(el->l_next_free_rec),
le16_to_cpu(el->l_count));
if (!rec->e_blkno) {
ocfs2_error(inode->i_sb,
- "Inode %lu has bad extent record (%u, %u, 0)\n",
+ "Inode %llu has bad extent record (%u, %u, 0)\n",
inode->i_ino,
le32_to_cpu(rec->e_cpos),
ocfs2_rec_clusters(el, rec));
if (el->l_tree_depth) {
ocfs2_error(inode->i_sb,
- "Inode %lu has non zero tree depth in xattr leaf block %llu\n",
+ "Inode %llu has non zero tree depth in xattr leaf block %llu\n",
inode->i_ino,
(unsigned long long)eb_bh->b_blocknr);
ret = -EROFS;
if (!rec->e_blkno) {
ocfs2_error(inode->i_sb,
- "Inode %lu has bad extent record (%u, %u, 0) in xattr\n",
+ "Inode %llu has bad extent record (%u, %u, 0) in xattr\n",
inode->i_ino,
le32_to_cpu(rec->e_cpos),
ocfs2_rec_clusters(el, rec));
inode->i_nlink);
mlog_bug_on_msg(osb == NULL,
- "Inode=%lu\n", inode->i_ino);
+ "Inode=%llu\n", inode->i_ino);
dquot_drop(inode);
qsize_t spacechange, inodechange;
unsigned int memalloc;
- trace_ocfs2_recover_local_quota_file((unsigned long)lqinode->i_ino, type);
+ trace_ocfs2_recover_local_quota_file(lqinode->i_ino, type);
list_for_each_entry_safe(rchunk, next, &(rec->r_list[type]), rc_list) {
chunk = rchunk->rc_chunk;
cpos, len, phys);
if (!ocfs2_refcount_tree(OCFS2_SB(inode->i_sb))) {
- 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",
+ 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",
inode->i_ino);
goto out;
}
u64 start_cpos = ocfs2_blocks_to_clusters(inode->i_sb, phys_blkno);
if (!ocfs2_refcount_tree(OCFS2_SB(inode->i_sb))) {
- 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",
+ 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",
inode->i_ino);
goto out;
}
if (el->l_tree_depth) {
ret = ocfs2_error(inode->i_sb,
- "Inode %lu has non zero tree depth in leaf block %llu\n",
+ "Inode %llu has non zero tree depth in leaf block %llu\n",
inode->i_ino,
(unsigned long long)eb_bh->b_blocknr);
goto out;
rec = &el->l_recs[i];
if (ocfs2_is_empty_extent(rec)) {
- mlog_bug_on_msg(i != 0, "Inode %lu has empty record in "
+ mlog_bug_on_msg(i != 0, "Inode %llu has empty record in "
"index %d\n", inode->i_ino, i);
continue;
}
struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
if (!ocfs2_refcount_tree(osb)) {
- 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",
+ 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",
inode->i_ino);
}
if (el->l_tree_depth) {
ret = ocfs2_error(inode->i_sb,
- "Inode %lu has non zero tree depth in xattr tree block %llu\n",
+ "Inode %llu has non zero tree depth in xattr tree block %llu\n",
inode->i_ino,
(unsigned long long)eb_bh->b_blocknr);
goto out;
}
if (!e_blkno) {
- ret = ocfs2_error(inode->i_sb, "Inode %lu has bad extent record (%u, %u, 0) in xattr\n",
+ ret = ocfs2_error(inode->i_sb, "Inode %llu has bad extent record (%u, %u, 0) in xattr\n",
inode->i_ino,
le32_to_cpu(rec->e_cpos),
ocfs2_rec_clusters(el, rec));
unlock_new_inode(inode);
gossip_debug(GOSSIP_INODE_DEBUG,
- "iget handle %pU, fsid %d hash %ld i_ino %lu\n",
+ "iget handle %pU, fsid %d hash %ld i_ino %llu\n",
&ref->khandle,
ref->fs_id,
hash,
return err;
fail:
- pr_warn_ratelimited("failed to encode file handle (ino=%lu, err=%i)\n",
+ pr_warn_ratelimited("failed to encode file handle (ino=%llu, err=%i)\n",
inode->i_ino, err);
goto out;
}
fail:
inode = d_inode(real);
- pr_warn_ratelimited("failed to verify %s (%pd2, ino=%lu, err=%i)\n",
+ pr_warn_ratelimited("failed to verify %s (%pd2, ino=%llu, err=%i)\n",
is_upper ? "upper" : "origin", real,
inode ? inode->i_ino : 0, err);
goto out;
index = NULL;
goto out;
}
- pr_warn_ratelimited("failed inode index lookup (ino=%lu, key=%.*s, err=%i);\n"
+ pr_warn_ratelimited("failed inode index lookup (ino=%llu, key=%.*s, err=%i);\n"
"overlayfs: mount with '-o index=off' to disable inodes index.\n",
d_inode(origin)->i_ino, name.len, name.name,
err);
got_write = true;
inode = d_inode(upperdentry);
if (!S_ISDIR(inode->i_mode) && inode->i_nlink != 1) {
- pr_warn_ratelimited("cleanup linked index (%pd2, ino=%lu, nlink=%u)\n",
+ pr_warn_ratelimited("cleanup linked index (%pd2, ino=%llu, nlink=%u)\n",
upperdentry, inode->i_ino, inode->i_nlink);
/*
* We either have a bug with persistent union nlink or a lower
*/
static char *pipefs_dname(struct dentry *dentry, char *buffer, int buflen)
{
- return dynamic_dname(buffer, buflen, "pipe:[%lu]",
+ return dynamic_dname(buffer, buflen, "pipe:[%llu]",
d_inode(dentry)->i_ino);
}
if (ret)
return ret;
- seq_printf(m, "pos:\t%lli\nflags:\t0%o\nmnt_id:\t%i\nino:\t%lu\n",
+ seq_printf(m, "pos:\t%lli\nflags:\t0%o\nmnt_id:\t%i\nino:\t%llu\n",
(long long)file->f_pos, f_flags,
real_mount(file->f_path.mnt)->mnt_id,
file_inode(file)->i_ino);
static void show_vma_header_prefix(struct seq_file *m,
unsigned long start, unsigned long end,
vm_flags_t flags, unsigned long long pgoff,
- dev_t dev, unsigned long ino)
+ dev_t dev, u64 ino)
{
seq_setwidth(m, 25 + sizeof(void *) * 6 - 1);
seq_put_hex_ll(m, NULL, start, 8);
const struct path *path;
const char *name_fmt, *name;
vm_flags_t flags = vma->vm_flags;
- unsigned long ino = 0;
+ u64 ino = 0;
unsigned long long pgoff = 0;
unsigned long start, end;
dev_t dev = 0;
{
unsigned long phys;
- QNX4DEBUG((KERN_INFO "qnx4: qnx4_get_block inode=[%ld] iblock=[%ld]\n",inode->i_ino,iblock));
+ QNX4DEBUG((KERN_INFO "qnx4: qnx4_get_block inode=[%llu] iblock=[%ld]\n", inode->i_ino, iblock));
phys = qnx4_block_map( inode, iblock );
if ( phys ) {
brelse( bh );
}
- QNX4DEBUG((KERN_INFO "qnx4: mapping block %ld of inode %ld = %ld\n",iblock,inode->i_ino,block));
+ QNX4DEBUG((KERN_INFO "qnx4: mapping block %ld of inode %llu = %ld\n", iblock, inode->i_ino, block));
return block;
}
{
unsigned phys;
- pr_debug("qnx6_get_block inode=[%ld] iblock=[%ld]\n",
+ pr_debug("qnx6_get_block inode=[%llu] iblock=[%ld]\n",
inode->i_ino, (unsigned long)iblock);
phys = qnx6_block_map(inode, iblock);
int count = 2;
pr_err("Dump in-memory inode:");
- pr_err("\tinode %lu\n", inode->i_ino);
+ pr_err("\tinode %llu\n", inode->i_ino);
pr_err("\tsize %llu\n",
(unsigned long long)i_size_read(inode));
pr_err("\tnlink %u\n", inode->i_nlink);
if (ui->ui_size != ui->synced_i_size && !ui->dirty) {
ubifs_err(c, "ui_size is %lld, synced_i_size is %lld, but inode is clean",
ui->ui_size, ui->synced_i_size);
- ubifs_err(c, "i_ino %lu, i_mode %#x, i_size %lld", inode->i_ino,
+ ubifs_err(c, "i_ino %llu, i_mode %#x, i_size %lld", inode->i_ino,
inode->i_mode, i_size_read(inode));
dump_stack();
err = -EINVAL;
kfree(pdent);
if (i_size_read(dir) != size) {
- ubifs_err(c, "directory inode %lu has size %llu, but calculated size is %llu",
+ ubifs_err(c, "directory inode %llu has size %llu, but calculated size is %llu",
dir->i_ino, (unsigned long long)i_size_read(dir),
(unsigned long long)size);
ubifs_dump_inode(c, dir);
return -EINVAL;
}
if (dir->i_nlink != nlink) {
- ubifs_err(c, "directory inode %lu has nlink %u, but calculated nlink is %u",
+ ubifs_err(c, "directory inode %llu has nlink %u, but calculated nlink is %u",
dir->i_ino, dir->i_nlink, nlink);
ubifs_dump_inode(c, dir);
dump_stack();
struct ubifs_info *c = dir->i_sb->s_fs_info;
struct fscrypt_name nm;
- dbg_gen("'%pd' in dir ino %lu", dentry, dir->i_ino);
+ dbg_gen("'%pd' in dir ino %llu", dentry, dir->i_ino);
err = fscrypt_prepare_lookup(dir, dentry, &nm);
if (err == -ENOENT)
if (IS_ENCRYPTED(dir) &&
(S_ISDIR(inode->i_mode) || S_ISLNK(inode->i_mode)) &&
!fscrypt_has_permitted_context(dir, inode)) {
- ubifs_warn(c, "Inconsistent encryption contexts: %lu/%lu",
+ ubifs_warn(c, "Inconsistent encryption contexts: %llu/%llu",
dir->i_ino, inode->i_ino);
iput(inode);
inode = ERR_PTR(-EPERM);
* parent directory inode.
*/
- dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
+ dbg_gen("dent '%pd', mode %#hx in dir ino %llu",
dentry, mode, dir->i_ino);
err = ubifs_budget_space(c, &req);
* atomically.
*/
- dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
+ dbg_gen("dent '%pd', mode %#hx in dir ino %llu",
dentry, mode, dir->i_ino);
inode = ubifs_new_inode(c, dir, mode, false);
* be released via writeback.
*/
- dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
+ dbg_gen("dent '%pd', mode %#hx in dir ino %llu",
dentry, mode, dir->i_ino);
err = fscrypt_setup_filename(dir, &dentry->d_name, 0, &nm);
bool encrypted = IS_ENCRYPTED(dir);
struct ubifs_dir_data *data = file->private_data;
- dbg_gen("dir ino %lu, f_pos %#llx", dir->i_ino, ctx->pos);
+ dbg_gen("dir ino %llu, f_pos %#llx", dir->i_ino, ctx->pos);
if (ctx->pos > UBIFS_S_KEY_HASH_MASK || ctx->pos == 2)
/*
* changing the parent inode.
*/
- dbg_gen("dent '%pd' to ino %lu (nlink %d) in dir ino %lu",
+ dbg_gen("dent '%pd' to ino %llu (nlink %d) in dir ino %llu",
dentry, inode->i_ino,
inode->i_nlink, dir->i_ino);
ubifs_assert(c, inode_is_locked(dir));
* deletions.
*/
- dbg_gen("dent '%pd' from ino %lu (nlink %d) in dir ino %lu",
+ dbg_gen("dent '%pd' from ino %llu (nlink %d) in dir ino %llu",
dentry, inode->i_ino,
inode->i_nlink, dir->i_ino);
* because we have extra space reserved for deletions.
*/
- dbg_gen("directory '%pd', ino %lu in dir ino %lu", dentry,
+ dbg_gen("directory '%pd', ino %llu in dir ino %llu", dentry,
inode->i_ino, dir->i_ino);
ubifs_assert(c, inode_is_locked(dir));
ubifs_assert(c, inode_is_locked(inode));
* directory inode.
*/
- dbg_gen("dent '%pd', mode %#hx in dir ino %lu",
+ dbg_gen("dent '%pd', mode %#hx in dir ino %llu",
dentry, mode, dir->i_ino);
err = ubifs_budget_space(c, &req);
* directory inode.
*/
- dbg_gen("dent '%pd' in dir ino %lu", dentry, dir->i_ino);
+ dbg_gen("dent '%pd' in dir ino %llu", dentry, dir->i_ino);
if (S_ISBLK(mode) || S_ISCHR(mode)) {
dev = kmalloc_obj(union ubifs_dev_desc, GFP_NOFS);
.dirtied_ino = 1 };
struct fscrypt_name nm;
- dbg_gen("dent '%pd', target '%s' in dir ino %lu", dentry,
+ dbg_gen("dent '%pd', target '%s' in dir ino %llu", dentry,
symname, dir->i_ino);
err = fscrypt_prepare_symlink(dir, symname, len, UBIFS_MAX_INO_DATA,
* ino_req: marks the target inode as dirty and does not write it.
*/
- dbg_gen("dent '%pd' ino %lu in dir ino %lu to dent '%pd' in dir ino %lu flags 0x%x",
+ dbg_gen("dent '%pd' ino %llu in dir ino %llu to dent '%pd' in dir ino %llu flags 0x%x",
old_dentry, old_inode->i_ino, old_dir->i_ino,
new_dentry, new_dir->i_ino, flags);
* parent directory inodes.
*/
- dbg_gen("dent '%pd' ino %lu in dir ino %lu exchange dent '%pd' ino %lu in dir ino %lu",
+ dbg_gen("dent '%pd' ino %llu in dir ino %llu exchange dent '%pd' ino %llu in dir ino %llu",
old_dentry, fst_inode->i_ino, old_dir->i_ino,
new_dentry, snd_inode->i_ino, new_dir->i_ino);
return 0;
dump:
- ubifs_err(c, "bad data node (block %u, inode %lu)",
+ ubifs_err(c, "bad data node (block %u, inode %llu)",
block, inode->i_ino);
ubifs_dump_node(c, dn, UBIFS_MAX_DATA_NODE_SZ);
return -EINVAL;
loff_t i_size = i_size_read(inode);
size_t offset = 0;
- dbg_gen("ino %lu, pg %lu, i_size %lld, flags %#lx",
+ dbg_gen("ino %llu, pg %lu, i_size %lld, flags %#lx",
inode->i_ino, folio->index, i_size, folio->flags.f);
ubifs_assert(c, !folio_test_checked(folio));
ubifs_assert(c, !folio->private);
dbg_gen("hole");
err = 0;
} else {
- ubifs_err(c, "cannot read page %lu of inode %lu, error %d",
+ ubifs_err(c, "cannot read page %lu of inode %llu, error %d",
folio->index, inode->i_ino, err);
}
}
int err, appending = !!(pos + len > inode->i_size);
struct folio *folio;
- dbg_gen("ino %lu, pos %llu, len %u, i_size %lld",
+ dbg_gen("ino %llu, pos %llu, len %u, i_size %lld",
inode->i_ino, pos, len, inode->i_size);
/*
loff_t end_pos = pos + len;
int appending = !!(end_pos > inode->i_size);
- dbg_gen("ino %lu, pos %llu, pg %lu, len %u, copied %d, i_size %lld",
+ dbg_gen("ino %llu, pos %llu, pg %lu, len %u, copied %d, i_size %lld",
inode->i_ino, pos, folio->index, len, copied, inode->i_size);
if (unlikely(copied < len && !folio_test_uptodate(folio))) {
size_t offset = 0;
pgoff_t end_index;
- dbg_gen("ino %lu, pg %lu, i_size %lld, flags %#lx",
+ dbg_gen("ino %llu, pg %lu, i_size %lld, flags %#lx",
inode->i_ino, folio->index, i_size, folio->flags.f);
end_index = (i_size - 1) >> PAGE_SHIFT;
return 0;
out_err:
- ubifs_err(c, "bad data node (block %u, inode %lu)",
+ ubifs_err(c, "bad data node (block %u, inode %llu)",
page_block, inode->i_ino);
return -EINVAL;
}
}
if (err) {
mapping_set_error(folio->mapping, err);
- ubifs_err(c, "cannot write folio %lu of inode %lu, error %d",
+ ubifs_err(c, "cannot write folio %lu of inode %llu, error %d",
folio->index, inode->i_ino, err);
ubifs_ro_mode(c, err);
}
loff_t i_size = i_size_read(inode), synced_i_size;
int err, len = folio_size(folio);
- dbg_gen("ino %lu, pg %lu, pg flags %#lx",
+ dbg_gen("ino %llu, pg %lu, pg flags %#lx",
inode->i_ino, folio->index, folio->flags.f);
ubifs_assert(c, folio->private != NULL);
int offset = new_size & (UBIFS_BLOCK_SIZE - 1), budgeted = 1;
struct ubifs_inode *ui = ubifs_inode(inode);
- dbg_gen("ino %lu, size %lld -> %lld", inode->i_ino, old_size, new_size);
+ dbg_gen("ino %llu, size %lld -> %lld", inode->i_ino, old_size, new_size);
memset(&req, 0, sizeof(struct ubifs_budget_req));
/*
struct inode *inode = d_inode(dentry);
struct ubifs_info *c = inode->i_sb->s_fs_info;
- dbg_gen("ino %lu, mode %#x, ia_valid %#x",
+ dbg_gen("ino %llu, mode %#x, ia_valid %#x",
inode->i_ino, inode->i_mode, attr->ia_valid);
err = setattr_prepare(&nop_mnt_idmap, dentry, attr);
if (err)
struct ubifs_info *c = inode->i_sb->s_fs_info;
int err;
- dbg_gen("syncing inode %lu", inode->i_ino);
+ dbg_gen("syncing inode %llu", inode->i_ino);
if (c->ro_mount)
/*
struct ubifs_budget_req req = { .new_page = 1 };
int err, update_time;
- dbg_gen("ino %lu, pg %lu, i_size %lld", inode->i_ino, folio->index,
+ dbg_gen("ino %llu, pg %lu, i_size %lld", inode->i_ino, folio->index,
i_size_read(inode));
ubifs_assert(c, !c->ro_media && !c->ro_mount);
err = ubifs_budget_space(c, &req);
if (unlikely(err)) {
if (err == -ENOSPC)
- ubifs_warn(c, "out of space for mmapped file (inode number %lu)",
+ ubifs_warn(c, "out of space for mmapped file (inode number %llu)",
inode->i_ino);
return VM_FAULT_SIGBUS;
}
int kill_xattrs = ui->xattr_cnt && last_reference;
u8 hash[UBIFS_HASH_ARR_SZ];
- dbg_jnl("ino %lu, nlink %u", inode->i_ino, inode->i_nlink);
+ dbg_jnl("ino %llu, nlink %u", inode->i_ino, inode->i_nlink);
if (kill_xattrs && ui->xattr_cnt > ubifs_xattr_max_cnt(c)) {
ubifs_err(c, "Cannot delete inode, it has too many xattrs!");
int dn_len = le32_to_cpu(dn->size);
if (dn_len <= 0 || dn_len > UBIFS_BLOCK_SIZE) {
- ubifs_err(c, "bad data node (block %u, inode %lu)",
+ ubifs_err(c, "bad data node (block %u, inode %llu)",
blk, inode->i_ino);
ubifs_dump_node(c, dn, dn_size);
err = -EUCLEAN;
u8 hash_host[UBIFS_HASH_ARR_SZ];
u8 hash[UBIFS_HASH_ARR_SZ];
- dbg_jnl("ino %lu, ino %lu", host->i_ino, inode->i_ino);
+ dbg_jnl("ino %llu, ino %llu", host->i_ino, inode->i_ino);
ubifs_assert(c, inode->i_nlink > 0);
ubifs_assert(c, mutex_is_locked(&host_ui->ui_mutex));
return 5;
if (!ubifs_compr_present(c, ui->compr_type)) {
- ubifs_warn(c, "inode %lu uses '%s' compression, but it was not compiled in",
+ ubifs_warn(c, "inode %llu uses '%s' compression, but it was not compiled in",
inode->i_ino, ubifs_compr_name(c, ui->compr_type));
}
return inode;
out_invalid:
- ubifs_err(c, "inode %lu validation failed, error %d", inode->i_ino, err);
+ ubifs_err(c, "inode %llu validation failed, error %d", inode->i_ino, err);
ubifs_dump_node(c, ino, UBIFS_MAX_INO_NODE_SZ);
ubifs_dump_inode(c, inode);
err = -EINVAL;
out_ino:
kfree(ino);
out:
- ubifs_err(c, "failed to read inode %lu, error %d", inode->i_ino, err);
+ ubifs_err(c, "failed to read inode %llu, error %d", inode->i_ino, err);
iget_failed(inode);
return ERR_PTR(err);
}
* As an optimization, do not write orphan inodes to the media just
* because this is not needed.
*/
- dbg_gen("inode %lu, mode %#x, nlink %u",
+ dbg_gen("inode %llu, mode %#x, nlink %u",
inode->i_ino, (int)inode->i_mode, inode->i_nlink);
if (inode->i_nlink) {
err = ubifs_jnl_write_inode(c, inode);
if (err)
- ubifs_err(c, "can't write inode %lu, error %d",
+ ubifs_err(c, "can't write inode %llu, error %d",
inode->i_ino, err);
else
err = dbg_check_inode_size(c, inode, ui->ui_size);
*/
goto out;
- dbg_gen("inode %lu, mode %#x", inode->i_ino, (int)inode->i_mode);
+ dbg_gen("inode %llu, mode %#x", inode->i_ino, (int)inode->i_mode);
ubifs_assert(c, !icount_read(inode));
truncate_inode_pages_final(&inode->i_data);
* Worst case we have a lost orphan inode wasting space, so a
* simple error message is OK here.
*/
- ubifs_err(c, "can't delete inode %lu, error %d",
+ ubifs_err(c, "can't delete inode %llu, error %d",
inode->i_ino, err);
out:
ubifs_assert(c, mutex_is_locked(&ui->ui_mutex));
if (!ui->dirty) {
ui->dirty = 1;
- dbg_gen("inode %lu", inode->i_ino);
+ dbg_gen("inode %llu", inode->i_ino);
}
}
out_dump:
block = key_block(c, key);
- ubifs_err(c, "inode %lu has size %lld, but there are data at offset %lld",
- (unsigned long)inode->i_ino, size,
+ ubifs_err(c, "inode %llu has size %lld, but there are data at offset %lld",
+ inode->i_ino, size,
((loff_t)block) << UBIFS_BLOCK_SHIFT);
mutex_unlock(&c->tnc_mutex);
ubifs_dump_inode(c, inode);
.dirtied_ino_d = ALIGN(host_ui->data_len, 8) };
if (host_ui->xattr_cnt >= ubifs_xattr_max_cnt(c)) {
- ubifs_err(c, "inode %lu already has too many xattrs (%d), cannot create more",
+ ubifs_err(c, "inode %llu already has too many xattrs (%d), cannot create more",
host->i_ino, host_ui->xattr_cnt);
return -ENOSPC;
}
*/
names_len = host_ui->xattr_names + host_ui->xattr_cnt + fname_len(nm) + 1;
if (names_len > XATTR_LIST_MAX) {
- ubifs_err(c, "cannot add one more xattr name to inode %lu, total names length would become %d, max. is %d",
+ ubifs_err(c, "cannot add one more xattr name to inode %llu, total names length would become %d, max. is %d",
host->i_ino, names_len, XATTR_LIST_MAX);
return -ENOSPC;
}
int err, len, written = 0;
struct fscrypt_name nm = {0};
- dbg_gen("ino %lu ('%pd'), buffer size %zd", host->i_ino,
+ dbg_gen("ino %llu ('%pd'), buffer size %zd", host->i_ino,
dentry, size);
down_read(&host_ui->xattr_sem);
if (ubifs_inode(host)->xattr_cnt <= ubifs_xattr_max_cnt(c))
return 0;
- ubifs_warn(c, "inode %lu has too many xattrs, doing a non-atomic deletion",
+ ubifs_warn(c, "inode %llu has too many xattrs, doing a non-atomic deletion",
host->i_ino);
down_write(&ubifs_inode(host)->xattr_sem);
&init_xattrs, NULL);
if (err) {
struct ubifs_info *c = dentry->i_sb->s_fs_info;
- ubifs_err(c, "cannot initialize security for inode %lu, error %d",
+ ubifs_err(c, "cannot initialize security for inode %llu, error %d",
inode->i_ino, err);
}
return err;
struct dentry *dentry, struct inode *inode,
const char *name, void *buffer, size_t size)
{
- dbg_gen("xattr '%s', ino %lu ('%pd'), buf size %zd", name,
+ dbg_gen("xattr '%s', ino %llu ('%pd'), buf size %zd", name,
inode->i_ino, dentry, size);
name = xattr_full_name(handler, name);
const char *name, const void *value,
size_t size, int flags)
{
- dbg_gen("xattr '%s', host ino %lu ('%pd'), size %zd",
+ dbg_gen("xattr '%s', host ino %llu ('%pd'), size %zd",
name, inode->i_ino, dentry, size);
name = xattr_full_name(handler, name);
if (iter->fi.descTag.tagIdent != cpu_to_le16(TAG_IDENT_FID)) {
udf_err(iter->dir->i_sb,
- "directory (ino %lu) has entry at pos %llu with incorrect tag %x\n",
+ "directory (ino %llu) has entry at pos %llu with incorrect tag %x\n",
iter->dir->i_ino, (unsigned long long)iter->pos,
le16_to_cpu(iter->fi.descTag.tagIdent));
return -EFSCORRUPTED;
len = udf_dir_entry_len(&iter->fi);
if (le16_to_cpu(iter->fi.lengthOfImpUse) & 3) {
udf_err(iter->dir->i_sb,
- "directory (ino %lu) has entry at pos %llu with unaligned length of impUse field\n",
+ "directory (ino %llu) has entry at pos %llu with unaligned length of impUse field\n",
iter->dir->i_ino, (unsigned long long)iter->pos);
return -EFSCORRUPTED;
}
*/
if (len > 1 << iter->dir->i_blkbits) {
udf_err(iter->dir->i_sb,
- "directory (ino %lu) has too big (%u) entry at pos %llu\n",
+ "directory (ino %llu) has too big (%u) entry at pos %llu\n",
iter->dir->i_ino, len, (unsigned long long)iter->pos);
return -EFSCORRUPTED;
}
if (iter->pos + len > iter->dir->i_size) {
udf_err(iter->dir->i_sb,
- "directory (ino %lu) has entry past directory size at pos %llu\n",
+ "directory (ino %llu) has entry past directory size at pos %llu\n",
iter->dir->i_ino, (unsigned long long)iter->pos);
return -EFSCORRUPTED;
}
if (udf_dir_entry_len(&iter->fi) !=
sizeof(struct tag) + le16_to_cpu(iter->fi.descTag.descCRCLength)) {
udf_err(iter->dir->i_sb,
- "directory (ino %lu) has entry where CRC length (%u) does not match entry length (%u)\n",
+ "directory (ino %llu) has entry where CRC length (%u) does not match entry length (%u)\n",
iter->dir->i_ino,
(unsigned)le16_to_cpu(iter->fi.descTag.descCRCLength),
(unsigned)(udf_dir_entry_len(&iter->fi) -
}
if (iter->dir->i_size < iter->pos + sizeof(struct fileIdentDesc)) {
udf_err(iter->dir->i_sb,
- "directory (ino %lu) has entry straddling EOF\n",
+ "directory (ino %llu) has entry straddling EOF\n",
iter->dir->i_ino);
return -EFSCORRUPTED;
}
return 0;
}
udf_err(iter->dir->i_sb,
- "extent after position %llu not allocated in directory (ino %lu)\n",
+ "extent after position %llu not allocated in directory (ino %llu)\n",
(unsigned long long)iter->pos, iter->dir->i_ino);
return -EFSCORRUPTED;
}
if (pos == dir->i_size)
return 0;
udf_err(dir->i_sb,
- "position %llu not allocated in directory (ino %lu)\n",
+ "position %llu not allocated in directory (ino %llu)\n",
(unsigned long long)pos, dir->i_ino);
err = -EFSCORRUPTED;
goto out;
&iter->loffset, &etype);
if (err <= 0 || etype != (EXT_RECORDED_ALLOCATED >> 30)) {
udf_err(iter->dir->i_sb,
- "block %llu not allocated in directory (ino %lu)\n",
+ "block %llu not allocated in directory (ino %llu)\n",
(unsigned long long)block, iter->dir->i_ino);
return -EFSCORRUPTED;
}
int result;
if (file_permission(filp, MAY_READ) != 0) {
- udf_debug("no permission to access inode %lu\n", inode->i_ino);
+ udf_debug("no permission to access inode %llu\n", inode->i_ino);
return -EPERM;
}
if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB &&
inode->i_size != iinfo->i_lenExtents) {
udf_warn(inode->i_sb,
- "Inode %lu (mode %o) has inode size %llu different from extent length %llu. Filesystem need not be standards compliant.\n",
+ "Inode %llu (mode %o) has inode size %llu different from extent length %llu. Filesystem need not be standards compliant.\n",
inode->i_ino, inode->i_mode,
(unsigned long long)inode->i_size,
(unsigned long long)iinfo->i_lenExtents);
*/
bh = udf_read_ptagged(inode->i_sb, iloc, 0, &ident);
if (!bh) {
- udf_err(inode->i_sb, "(ino %lu) failed !bh\n", inode->i_ino);
+ udf_err(inode->i_sb, "(ino %llu) failed !bh\n", inode->i_ino);
return -EIO;
}
if (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE &&
ident != TAG_IDENT_USE) {
- udf_err(inode->i_sb, "(ino %lu) failed ident=%u\n",
+ udf_err(inode->i_sb, "(ino %llu) failed ident=%u\n",
inode->i_ino, ident);
goto out;
}
udf_debug("METADATA BITMAP FILE-----\n");
break;
default:
- udf_err(inode->i_sb, "(ino %lu) failed unknown file type=%u\n",
+ udf_err(inode->i_sb, "(ino %llu) failed unknown file type=%u\n",
inode->i_ino, fe->icbTag.fileType);
goto out;
}
if (do_sync) {
sync_dirty_buffer(bh);
if (buffer_write_io_error(bh)) {
- udf_warn(inode->i_sb, "IO error syncing udf inode [%08lx]\n",
+ udf_warn(inode->i_sb, "IO error syncing udf inode [%08llx]\n",
inode->i_ino);
err = -EIO;
}
if (++indirections > UDF_MAX_INDIR_EXTS) {
udf_err(inode->i_sb,
- "too many indirect extents in inode %lu\n",
+ "too many indirect extents in inode %llu\n",
inode->i_ino);
return -EFSCORRUPTED;
}
goto end_unlink;
if (!inode->i_nlink) {
- udf_debug("Deleting nonexistent file (%lu), %u\n",
+ udf_debug("Deleting nonexistent file (%llu), %u\n",
inode->i_ino, inode->i_nlink);
set_nlink(inode, 1);
}
&diriter);
if (retval == -ENOENT) {
udf_err(old_inode->i_sb,
- "directory (ino %lu) has no '..' entry\n",
+ "directory (ino %llu) has no '..' entry\n",
old_inode->i_ino);
retval = -EFSCORRUPTED;
}
old_dir->i_ino) {
retval = -EFSCORRUPTED;
udf_err(old_inode->i_sb,
- "directory (ino %lu) has parent entry pointing to another inode (%lu != %u)\n",
+ "directory (ino %llu) has parent entry pointing to another inode (%llu != %u)\n",
old_inode->i_ino, old_dir->i_ino,
udf_get_lb_pblock(old_inode->i_sb, &tloc, 0));
goto out_oiter;
retval = udf_fiiter_find_entry(old_dir, &old_dentry->d_name, &oiter);
if (retval) {
udf_err(old_dir->i_sb,
- "failed to find renamed entry again in directory (ino %lu)\n",
+ "failed to find renamed entry again in directory (ino %llu)\n",
old_dir->i_ino);
} else {
udf_fiiter_delete_entry(&oiter);
}
map->s_uspace.s_table = inode;
map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_TABLE;
- udf_debug("unallocSpaceTable (part %d) @ %lu\n",
+ udf_debug("unallocSpaceTable (part %d) @ %llu\n",
p_index, map->s_uspace.s_table->i_ino);
}
sector_t end, i;
struct buffer_head *head, *bh;
- UFSD("ENTER, ino %lu, count %u, oldb %llu, newb %llu\n",
+ UFSD("ENTER, ino %llu, count %u, oldb %llu, newb %llu\n",
inode->i_ino, count,
(unsigned long long)oldb, (unsigned long long)newb);
unsigned cgno, oldcount, newcount;
u64 tmp, request, result;
- UFSD("ENTER, ino %lu, fragment %llu, goal %llu, count %u\n",
+ UFSD("ENTER, ino %llu, fragment %llu, goal %llu, count %u\n",
inode->i_ino, (unsigned long long)fragment,
(unsigned long long)goal, count);
unsigned oldcg, i, j, k, allocsize;
u64 result;
- UFSD("ENTER, ino %lu, cgno %u, goal %llu, count %u\n",
+ UFSD("ENTER, ino %llu, cgno %u, goal %llu, count %u\n",
inode->i_ino, cgno, (unsigned long long)goal, count);
sb = inode->i_sb;
Ebadsize:
ufs_error(sb, __func__,
- "size of directory #%lu is not a multiple of chunk size",
+ "size of directory #%llu is not a multiple of chunk size",
dir->i_ino
);
goto fail;
Einumber:
error = "inode out of bounds";
bad_entry:
- ufs_error(sb, __func__, "bad entry in directory #%lu: %s - "
+ ufs_error(sb, __func__, "bad entry in directory #%llu: %s - "
"offset=%llu, rec_len=%d, name_len=%d",
dir->i_ino, error, folio_pos(folio) + offs,
rec_len, ufs_get_de_namlen(sb, p));
Eend:
p = (struct ufs_dir_entry *)(kaddr + offs);
ufs_error(sb, __func__,
- "entry in directory #%lu spans the page boundary"
+ "entry in directory #%llu spans the page boundary"
"offset=%llu",
dir->i_ino, folio_pos(folio) + offs);
fail:
struct ufs_inode_info *ui = UFS_I(dir);
struct ufs_dir_entry *de;
- UFSD("ENTER, dir_ino %lu, name %s, namlen %u\n", dir->i_ino, name, namelen);
+ UFSD("ENTER, dir_ino %llu, name %s, namlen %u\n", dir->i_ino, name, namelen);
if (npages == 0 || namelen > UFS_MAXNAMLEN)
goto out;
if (IS_ERR(kaddr)) {
ufs_error(sb, __func__,
- "bad page in #%lu",
+ "bad page in #%llu",
inode->i_ino);
ctx->pos += PAGE_SIZE - offset;
return PTR_ERR(kaddr);
int is_directory;
unsigned ino, cg, bit;
- UFSD("ENTER, ino %lu\n", inode->i_ino);
+ UFSD("ENTER, ino %llu\n", inode->i_ino);
sb = inode->i_sb;
uspi = UFS_SB(sb)->s_uspi;
bh = sb_bread(sb, uspi->s_sbbase + ufs_inotofsba(inode->i_ino));
if (!bh) {
ufs_warning(sb, "ufs_read_inode",
- "unable to read inode %lu\n",
+ "unable to read inode %llu\n",
inode->i_ino);
err = -EIO;
goto fail_remove_inode;
}
mutex_unlock(&sbi->s_lock);
- UFSD("allocating inode %lu\n", inode->i_ino);
+ UFSD("allocating inode %llu\n", inode->i_ino);
UFSD("EXIT\n");
return inode;
mutex_lock(&UFS_I(inode)->truncate_mutex);
- UFSD("ENTER, ino %lu, fragment %llu\n", inode->i_ino, (unsigned long long)fragment);
+ UFSD("ENTER, ino %llu, fragment %llu\n", inode->i_ino, (unsigned long long)fragment);
if (unlikely(!depth)) {
ufs_warning(sb, "ufs_get_block", "block > big");
err = -EIO;
struct super_block *sb = inode->i_sb;
umode_t mode;
- UFSD("Reading ufs2 inode, ino %lu\n", inode->i_ino);
+ UFSD("Reading ufs2 inode, ino %llu\n", inode->i_ino);
/*
* Copy data to the in-core inode.
*/
bh = sb_bread(sb, uspi->s_sbbase + ufs_inotofsba(inode->i_ino));
if (!bh) {
- ufs_warning(sb, "ufs_read_inode", "unable to read inode %lu\n",
+ ufs_warning(sb, "ufs_read_inode", "unable to read inode %llu\n",
inode->i_ino);
goto bad_inode;
}
struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
struct buffer_head * bh;
- UFSD("ENTER, ino %lu\n", inode->i_ino);
+ UFSD("ENTER, ino %llu\n", inode->i_ino);
if (inode->i_ino < UFS_ROOTINO ||
inode->i_ino > (uspi->s_ncg * uspi->s_ipg)) {
- ufs_warning (sb, "ufs_read_inode", "bad inode number (%lu)\n", inode->i_ino);
+ ufs_warning (sb, "ufs_read_inode", "bad inode number (%llu)\n", inode->i_ino);
return -1;
}
bh = sb_bread(sb, ufs_inotofsba(inode->i_ino));
if (!bh) {
- ufs_warning (sb, "ufs_read_inode", "unable to read inode %lu\n", inode->i_ino);
+ ufs_warning (sb, "ufs_read_inode", "unable to read inode %llu\n", inode->i_ino);
return -1;
}
if (uspi->fs_magic == UFS2_MAGIC) {
unsigned int old_tail, new_tail;
struct to_free ctx = {.inode = inode};
- UFSD("ENTER: ino %lu\n", inode->i_ino);
+ UFSD("ENTER: ino %llu\n", inode->i_ino);
new_frags = DIRECT_FRAGMENT;
// new_frags = first fragment past the new EOF
}
}
done:
- UFSD("EXIT: ino %lu\n", inode->i_ino);
+ UFSD("EXIT: ino %llu\n", inode->i_ino);
}
static void free_full_branch(struct inode *inode, u64 ind_block, int depth)
{
int err = 0;
- UFSD("ENTER: ino %lu, i_size: %llu, old_i_size: %llu\n",
+ UFSD("ENTER: ino %llu, i_size: %llu, old_i_size: %llu\n",
inode->i_ino, (unsigned long long)size,
(unsigned long long)i_size_read(inode));
* inode number to cylinder group number.
* inode number to file system block address.
*/
-#define ufs_inotocg(x) ((x) / uspi->s_ipg)
-#define ufs_inotocgoff(x) ((x) % uspi->s_ipg)
+#define ufs_inotocg(x) ((unsigned int)(x) / uspi->s_ipg)
+#define ufs_inotocgoff(x) ((unsigned int)(x) % uspi->s_ipg)
#define ufs_inotofsba(x) (((u64)ufs_cgimin(ufs_inotocg(x))) + ufs_inotocgoff(x) / uspi->s_inopf)
-#define ufs_inotofsbo(x) ((x) % uspi->s_inopf)
+#define ufs_inotofsbo(x) ((unsigned int)(x) % uspi->s_inopf)
/*
* Compute the cylinder and rotational position of a cyl block addr.
folio = read_mapping_folio(mapping, index, NULL);
if (IS_ERR(folio)) {
- printk(KERN_ERR "ufs_change_blocknr: read_mapping_folio error: ino %lu, index: %lu\n",
+ printk(KERN_ERR "ufs_change_blocknr: read_mapping_folio error: ino %llu, index: %lu\n",
mapping->host->i_ino, index);
return folio;
}
vaf.fmt = fmt;
vaf.va = &args;
if (inode)
- printk("%sfs-verity (%s, inode %lu): %pV\n",
+ printk("%sfs-verity (%s, inode %llu): %pV\n",
level, inode->i_sb->s_id, inode->i_ino, &vaf);
else
printk("%sfs-verity: %pV\n", level, &vaf);
*/
if (isize != data_size)
zonefs_warn(sb,
- "inode %lu: invalid size %lld (should be %lld)\n",
+ "inode %llu: invalid size %lld (should be %lld)\n",
inode->i_ino, isize, data_size);
/*
*/
if ((z->z_flags & ZONEFS_ZONE_OFFLINE) ||
(sbi->s_mount_opts & ZONEFS_MNTOPT_ERRORS_ZOL)) {
- zonefs_warn(sb, "inode %lu: read/write access disabled\n",
+ zonefs_warn(sb, "inode %llu: read/write access disabled\n",
inode->i_ino);
if (!(z->z_flags & ZONEFS_ZONE_OFFLINE))
z->z_flags |= ZONEFS_ZONE_OFFLINE;
data_size = 0;
} else if ((z->z_flags & ZONEFS_ZONE_READONLY) ||
(sbi->s_mount_opts & ZONEFS_MNTOPT_ERRORS_ZRO)) {
- zonefs_warn(sb, "inode %lu: write access disabled\n",
+ zonefs_warn(sb, "inode %llu: write access disabled\n",
inode->i_ino);
if (!(z->z_flags & ZONEFS_ZONE_READONLY))
z->z_flags |= ZONEFS_ZONE_READONLY;
memalloc_noio_restore(noio_flag);
if (ret != 1) {
- zonefs_err(sb, "Get inode %lu zone information failed %d\n",
+ zonefs_err(sb, "Get inode %llu zone information failed %d\n",
inode->i_ino, ret);
zonefs_warn(sb, "remounting filesystem read-only\n");
sb->s_flags |= SB_RDONLY;
#endif
/* Stat data, not accessed from path walking */
- unsigned long i_ino;
+ u64 i_ino;
/*
* Filesystems may only read i_nlink directly. They shall use the
* following functions for modification:
static void update_ref_ctr_warn(struct uprobe *uprobe,
struct mm_struct *mm, short d)
{
- pr_warn("ref_ctr %s failed for inode: 0x%lx offset: "
+ pr_warn("ref_ctr %s failed for inode: 0x%llx offset: "
"0x%llx ref_ctr_offset: 0x%llx of mm: 0x%p\n",
d > 0 ? "increment" : "decrement", uprobe->inode->i_ino,
(unsigned long long) uprobe->offset,
static void
ref_ctr_mismatch_warn(struct uprobe *cur_uprobe, struct uprobe *uprobe)
{
- pr_warn("ref_ctr_offset mismatch. inode: 0x%lx offset: 0x%llx "
+ pr_warn("ref_ctr_offset mismatch. inode: 0x%llx offset: 0x%llx "
"ref_ctr_offset(old): 0x%llx ref_ctr_offset(new): 0x%llx\n",
uprobe->inode->i_ino, (unsigned long long) uprobe->offset,
(unsigned long long) cur_uprobe->ref_ctr_offset,
seq_printf(seq, "%-9s ", ax2asc(buf, &nr->user_addr));
seq_printf(seq, "%-9s ", ax2asc(buf, &nr->dest_addr));
seq_printf(seq,
-"%-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",
+"%-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",
ax2asc(buf, &nr->source_addr),
devname,
nr->my_index,
nr->window,
sk_wmem_alloc_get(s),
sk_rmem_alloc_get(s),
- s->sk_socket ? SOCK_INODE(s->sk_socket)->i_ino : 0L);
+ s->sk_socket ? SOCK_INODE(s->sk_socket)->i_ino : (u64)0);
bh_unlock_sock(s);
}
callsign = ax2asc(buf, &rose->source_call);
seq_printf(seq,
- "%-10s %-9s %-5s %3.3X %05d %d %d %d %d %3lu %3lu %3lu %3lu %3lu %3lu/%03lu %5d %5d %ld\n",
+ "%-10s %-9s %-5s %3.3X %05d %d %d %d %d %3lu %3lu %3lu %3lu %3lu %3lu/%03lu %5d %5d %llu\n",
rose2asc(rsbuf, &rose->source_addr),
callsign,
devname,
rose->idle / (60 * HZ),
sk_wmem_alloc_get(s),
sk_rmem_alloc_get(s),
- s->sk_socket ? SOCK_INODE(s->sk_socket)->i_ino : 0L);
+ s->sk_socket ? SOCK_INODE(s->sk_socket)->i_ino : (u64)0);
}
return 0;
*/
static char *sockfs_dname(struct dentry *dentry, char *buffer, int buflen)
{
- return dynamic_dname(buffer, buflen, "socket:[%lu]",
+ return dynamic_dname(buffer, buflen, "socket:[%llu]",
d_inode(dentry)->i_ino);
}
devname = x25->neighbour->dev->name;
seq_printf(seq, "%-10s %-10s %-5s %3.3X %d %d %d %d %3lu %3lu "
- "%3lu %3lu %3lu %5d %5d %ld\n",
+ "%3lu %3lu %3lu %5d %5d %llu\n",
!x25->dest_addr.x25_addr[0] ? "*" : x25->dest_addr.x25_addr,
!x25->source_addr.x25_addr[0] ? "*" : x25->source_addr.x25_addr,
devname, x25->lci & 0x0FFF, x25->state, x25->vs, x25->vr,
x25->t21 / HZ, x25->t22 / HZ, x25->t23 / HZ,
sk_wmem_alloc_get(s),
sk_rmem_alloc_get(s),
- s->sk_socket ? SOCK_INODE(s->sk_socket)->i_ino : 0L);
+ s->sk_socket ? SOCK_INODE(s->sk_socket)->i_ino : (u64)0);
out:
return 0;
}
static int aafs_show_path(struct seq_file *seq, struct dentry *dentry)
{
- seq_printf(seq, "%s:[%lu]", AAFS_NAME, d_inode(dentry)->i_ino);
+ seq_printf(seq, "%s:[%llu]", AAFS_NAME, d_inode(dentry)->i_ino);
return 0;
}
char name[32];
int res;
- res = snprintf(name, sizeof(name), "%s:[%lu]", AAFS_NAME,
+ res = snprintf(name, sizeof(name), "%s:[%llu]", AAFS_NAME,
d_inode(dentry)->i_ino);
if (res > 0 && res < sizeof(name))
res = readlink_copy(buffer, buflen, name, strlen(name));
if (inode) {
audit_log_format(ab, " dev=");
audit_log_untrustedstring(ab, inode->i_sb->s_id);
- audit_log_format(ab, " ino=%lu", inode->i_ino);
+ audit_log_format(ab, " ino=%llu", inode->i_ino);
}
audit_log_format(ab, " res=%d errno=%d", !result, errno);
audit_log_end(ab);
if (inode) {
audit_log_format(ab, " dev=");
audit_log_untrustedstring(ab, inode->i_sb->s_id);
- audit_log_format(ab, " ino=%lu", inode->i_ino);
+ audit_log_format(ab, " ino=%llu", inode->i_ino);
} else {
audit_log_format(ab, " dev=? ino=?");
}
if (inode) {
audit_log_format(ab, " dev=");
audit_log_untrustedstring(ab, inode->i_sb->s_id);
- audit_log_format(ab, " ino=%lu", inode->i_ino);
+ audit_log_format(ab, " ino=%llu", inode->i_ino);
}
break;
}
if (inode) {
audit_log_format(ab, " dev=");
audit_log_untrustedstring(ab, inode->i_sb->s_id);
- audit_log_format(ab, " ino=%lu", inode->i_ino);
+ audit_log_format(ab, " ino=%llu", inode->i_ino);
}
break;
}
if (inode) {
audit_log_format(ab, " dev=");
audit_log_untrustedstring(ab, inode->i_sb->s_id);
- audit_log_format(ab, " ino=%lu", inode->i_ino);
+ audit_log_format(ab, " ino=%llu", inode->i_ino);
}
audit_log_format(ab, " ioctlcmd=0x%hx", a->u.op->cmd);
if (inode) {
audit_log_format(ab, " dev=");
audit_log_untrustedstring(ab, inode->i_sb->s_id);
- audit_log_format(ab, " ino=%lu", inode->i_ino);
+ audit_log_format(ab, " ino=%llu", inode->i_ino);
}
break;
}
}
audit_log_format(ab, " dev=");
audit_log_untrustedstring(ab, inode->i_sb->s_id);
- audit_log_format(ab, " ino=%lu", inode->i_ino);
+ audit_log_format(ab, " ino=%llu", inode->i_ino);
rcu_read_unlock();
break;
}
if (rc < 0) {
kfree(context);
if (rc != -ENODATA) {
- pr_warn("SELinux: %s: getxattr returned %d for dev=%s ino=%ld\n",
+ pr_warn("SELinux: %s: getxattr returned %d for dev=%s ino=%llu\n",
__func__, -rc, inode->i_sb->s_id, inode->i_ino);
return rc;
}
def_sid, GFP_NOFS);
if (rc) {
char *dev = inode->i_sb->s_id;
- unsigned long ino = inode->i_ino;
+ u64 ino = inode->i_ino;
if (rc == -EINVAL) {
- 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",
+ 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",
ino, dev, context);
} else {
- pr_warn("SELinux: %s: context_to_sid(%s) returned %d for dev=%s ino=%ld\n",
+ pr_warn("SELinux: %s: context_to_sid(%s) returned %d for dev=%s ino=%llu\n",
__func__, context, -rc, dev, ino);
}
}
&newsid);
if (rc) {
pr_err("SELinux: unable to map context to SID"
- "for (%s, %lu), rc=%d\n",
+ "for (%s, %llu), rc=%d\n",
inode->i_sb->s_id, inode->i_ino, -rc);
return;
}
char acc[SMK_NUM_ACCESS_TYPE + 1];
if (isp->smk_flags & SMK_INODE_IMPURE)
- pr_info("Smack Unconfined Corruption: inode=(%s %ld) %s\n",
+ pr_info("Smack Unconfined Corruption: inode=(%s %llu) %s\n",
inode->i_sb->s_id, inode->i_ino, current->comm);
if (rc <= 0)
smk_bu_mode(mode, acc);
- pr_info("Smack %s: (%s %s %s) inode=(%s %ld) %s\n", smk_bu_mess[rc],
+ pr_info("Smack %s: (%s %s %s) inode=(%s %llu) %s\n", smk_bu_mess[rc],
tsp->smk_task->smk_known, isp->smk_inode->smk_known, acc,
inode->i_sb->s_id, inode->i_ino, current->comm);
return 0;
char acc[SMK_NUM_ACCESS_TYPE + 1];
if (isp->smk_flags & SMK_INODE_IMPURE)
- pr_info("Smack Unconfined Corruption: inode=(%s %ld) %s\n",
+ pr_info("Smack Unconfined Corruption: inode=(%s %llu) %s\n",
inode->i_sb->s_id, inode->i_ino, current->comm);
if (rc <= 0)
rc = 0;
smk_bu_mode(mode, acc);
- pr_info("Smack %s: (%s %s %s) file=(%s %ld %pD) %s\n", smk_bu_mess[rc],
+ pr_info("Smack %s: (%s %s %s) file=(%s %llu %pD) %s\n", smk_bu_mess[rc],
sskp->smk_known, smk_of_inode(inode)->smk_known, acc,
inode->i_sb->s_id, inode->i_ino, file,
current->comm);
char acc[SMK_NUM_ACCESS_TYPE + 1];
if (isp->smk_flags & SMK_INODE_IMPURE)
- pr_info("Smack Unconfined Corruption: inode=(%s %ld) %s\n",
+ pr_info("Smack Unconfined Corruption: inode=(%s %llu) %s\n",
inode->i_sb->s_id, inode->i_ino, current->comm);
if (rc <= 0)
rc = 0;
smk_bu_mode(mode, acc);
- pr_info("Smack %s: (%s %s %s) file=(%s %ld %pD) %s\n", smk_bu_mess[rc],
+ pr_info("Smack %s: (%s %s %s) file=(%s %llu %pD) %s\n", smk_bu_mess[rc],
sskp->smk_known, smk_of_inode(inode)->smk_known, acc,
inode->i_sb->s_id, inode->i_ino, file,
current->comm);
projects / thirdparty / kernel / linux.git / commitdiff
