inode.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * Copyright (C) 2018 Ernesto A. Fernández <ernesto.mnd.fernandez@gmail.com>
 */

#include<linux/slab.h>
#include<linux/buffer_head.h>
#include<linux/mount.h>
#include<linux/mpage.h>
#include<linux/blk_types.h>
#include"apfs.h"

#ifLINUX_VERSION_CODE >= KERNEL_VERSION(5, 19, 0) ||RHEL_VERSION_GE(9, 3)
#include<linux/sched/mm.h>
#endif

#ifLINUX_VERSION_CODE >= KERNEL_VERSION(5, 13, 0)
#include<linux/fileattr.h>
#endif

#defineMAX_PFK_LEN 512

#ifLINUX_VERSION_CODE >= KERNEL_VERSION(5, 19, 0) ||RHEL_VERSION_GE(9, 3)

staticintapfs_read_folio(structfile*file, structfolio*folio)
{
returnmpage_read_folio(folio, apfs_get_block);
}

#else

staticintapfs_readpage(structfile*file, structpage*page)
{
returnmpage_readpage(page, apfs_get_block);
}

#endif

#ifLINUX_VERSION_CODE >= KERNEL_VERSION(5, 8, 0) /* Misses mpage_readpages() */

staticvoidapfs_readahead(structreadahead_control*rac)
{
mpage_readahead(rac, apfs_get_block);
}

#else/* LINUX_VERSION_CODE >= KERNEL_VERSION(5, 8, 0) */

staticintapfs_readpages(structfile*file, structaddress_space*mapping,
structlist_head*pages, unsigned intnr_pages)
{
returnmpage_readpages(mapping, pages, nr_pages, apfs_get_block);
}

#endif/* LINUX_VERSION_CODE >= KERNEL_VERSION(5, 8, 0) */

/**
 * apfs_create_dstream_rec - Create a data stream record
 * @dstream: data stream info
 *
 * Does nothing if the record already exists. TODO: support cloned files.
 * Returns 0 on success or a negative error code in case of failure.
 */
staticintapfs_create_dstream_rec(structapfs_dstream_info*dstream)
{
structsuper_block*sb=dstream->ds_sb;
structapfs_sb_info*sbi=APFS_SB(sb);
structapfs_query*query;
structapfs_dstream_id_keyraw_key;
structapfs_dstream_id_valraw_val;
intret;

query=apfs_alloc_query(sbi->s_cat_root, NULL/* parent */);
if (!query)
return-ENOMEM;
apfs_init_dstream_id_key(dstream->ds_id, &query->key);
query->flags |= APFS_QUERY_CAT | APFS_QUERY_EXACT;

ret=apfs_btree_query(sb, &query);
if (ret!=-ENODATA) /* Either an error, or the record already exists */
 goto out;

apfs_key_set_hdr(APFS_TYPE_DSTREAM_ID, dstream->ds_id, &raw_key);
raw_val.refcnt=cpu_to_le32(1);
ret=apfs_btree_insert(query, &raw_key, sizeof(raw_key), &raw_val, sizeof(raw_val));
if (ret) {
apfs_err(sb, "insertion failed for id 0x%llx", dstream->ds_id);
 goto out;
 }
out:
apfs_free_query(query);
returnret;
}

staticintapfs_check_dstream_refcnt(structinode*inode);
staticintapfs_put_dstream_rec(structapfs_dstream_info*dstream);

/**
 * apfs_inode_create_exclusive_dstream - Make an inode's dstream not shared
 * @inode: the vfs inode
 *
 * Returns 0 on success, or a negative error code in case of failure.
 */
intapfs_inode_create_exclusive_dstream(structinode*inode)
{
structsuper_block*sb=inode->i_sb;
structapfs_superblock*vsb_raw=APFS_SB(sb)->s_vsb_raw;
structapfs_inode_info*ai=APFS_I(inode);
structapfs_dstream_info*dstream=&ai->i_dstream;
u64new_id;
interr;

if (!ai->i_has_dstream|| !dstream->ds_shared)
return0;

/*
 * The ds_shared field is not updated when the other user of the
 * dstream puts it, so it could be a false positive. Check it again
 * before actually putting the dstream. The double query is wasteful,
 * but I don't know if it makes sense to optimize this (TODO).
 */
err=apfs_check_dstream_refcnt(inode);
if (err) {
apfs_err(sb, "failed to check refcnt for ino 0x%llx", apfs_ino(inode));
returnerr;
 }
if (!dstream->ds_shared)
return0;
err=apfs_put_dstream_rec(dstream);
if (err) {
apfs_err(sb, "failed to put dstream for ino 0x%llx", apfs_ino(inode));
returnerr;
 }

apfs_assert_in_transaction(sb, &vsb_raw->apfs_o);
new_id=le64_to_cpu(vsb_raw->apfs_next_obj_id);
le64_add_cpu(&vsb_raw->apfs_next_obj_id, 1);

err=apfs_clone_extents(dstream, new_id);
if (err) {
apfs_err(sb, "failed clone extents for ino 0x%llx", apfs_ino(inode));
returnerr;
 }

dstream->ds_id=new_id;
err=apfs_create_dstream_rec(dstream);
if (err) {
apfs_err(sb, "failed to create dstream for ino 0x%llx", apfs_ino(inode));
returnerr;
 }

dstream->ds_shared= false;
return0;
}

/**
 * apfs_inode_create_dstream_rec - Create the data stream record for an inode
 * @inode: the vfs inode
 *
 * Does nothing if the record already exists. TODO: support cloned files.
 * Returns 0 on success or a negative error code in case of failure.
 */
staticintapfs_inode_create_dstream_rec(structinode*inode)
{
structapfs_inode_info*ai=APFS_I(inode);
interr;

if (ai->i_has_dstream)
returnapfs_inode_create_exclusive_dstream(inode);

err=apfs_create_dstream_rec(&ai->i_dstream);
if (err)
returnerr;

ai->i_has_dstream= true;
return0;
}

/**
 * apfs_dstream_adj_refcnt - Adjust dstream record refcount
 * @dstream: data stream info
 * @delta: desired change in reference count
 *
 * Deletes the record if the reference count goes to zero. Returns 0 on success
 * or a negative error code in case of failure.
 */
intapfs_dstream_adj_refcnt(structapfs_dstream_info*dstream, u32delta)
{
structsuper_block*sb=dstream->ds_sb;
structapfs_sb_info*sbi=APFS_SB(sb);
structapfs_query*query;
structapfs_dstream_id_valraw_val;
void*raw=NULL;
u32refcnt;
intret;

ASSERT(APFS_I(dstream->ds_inode)->i_has_dstream);

query=apfs_alloc_query(sbi->s_cat_root, NULL/* parent */);
if (!query)
return-ENOMEM;
apfs_init_dstream_id_key(dstream->ds_id, &query->key);
query->flags |= APFS_QUERY_CAT | APFS_QUERY_EXACT;

ret=apfs_btree_query(sb, &query);
if (ret) {
apfs_err(sb, "query failed for id 0x%llx", dstream->ds_id);
if (ret==-ENODATA)
ret=-EFSCORRUPTED;
 goto out;
 }

if (query->len!=sizeof(raw_val)) {
apfs_err(sb, "bad value length (%d)", query->len);
ret=-EFSCORRUPTED;
 goto out;
 }
raw=query->node->object.data;
raw_val=*(structapfs_dstream_id_val*)(raw+query->off);
refcnt=le32_to_cpu(raw_val.refcnt);

refcnt+=delta;
if (refcnt==0) {
ret=apfs_btree_remove(query);
if (ret)
apfs_err(sb, "removal failed for id 0x%llx", dstream->ds_id);
 goto out;
 }

raw_val.refcnt=cpu_to_le32(refcnt);
ret=apfs_btree_replace(query, NULL/* key */, 0/* key_len */, &raw_val, sizeof(raw_val));
if (ret)
apfs_err(sb, "update failed for id 0x%llx", dstream->ds_id);
out:
apfs_free_query(query);
returnret;
}

/**
 * apfs_put_dstream_rec - Put a reference for a data stream record
 * @dstream: data stream info
 *
 * Deletes the record if the reference count goes to zero. Returns 0 on success
 * or a negative error code in case of failure.
 */
staticintapfs_put_dstream_rec(structapfs_dstream_info*dstream)
{
structapfs_inode_info*ai=APFS_I(dstream->ds_inode);

if (!ai->i_has_dstream)
return0;
returnapfs_dstream_adj_refcnt(dstream, -1);
}

/**
 * apfs_create_crypto_rec - Create the crypto state record for an inode
 * @inode: the vfs inode
 *
 * Does nothing if the record already exists. TODO: support cloned files.
 * Returns 0 on success or a negative error code in case of failure.
 */
staticintapfs_create_crypto_rec(structinode*inode)
{
structsuper_block*sb=inode->i_sb;
structapfs_sb_info*sbi=APFS_SB(sb);
structapfs_dstream_info*dstream=&APFS_I(inode)->i_dstream;
structapfs_query*query;
structapfs_crypto_state_keyraw_key;
intret;

if (inode->i_size||inode->i_blocks) /* Already has a dstream */
return0;

query=apfs_alloc_query(sbi->s_cat_root, NULL/* parent */);
if (!query)
return-ENOMEM;
apfs_init_crypto_state_key(dstream->ds_id, &query->key);
query->flags |= APFS_QUERY_CAT | APFS_QUERY_EXACT;

ret=apfs_btree_query(sb, &query);
if (ret!=-ENODATA) /* Either an error, or the record already exists */
 goto out;

apfs_key_set_hdr(APFS_TYPE_CRYPTO_STATE, dstream->ds_id, &raw_key);
if (sbi->s_dflt_pfk) {
structapfs_crypto_state_val*raw_val=sbi->s_dflt_pfk;
unsigned intkey_len=le16_to_cpu(raw_val->state.key_len);

ret=apfs_btree_insert(query, &raw_key, sizeof(raw_key), raw_val, sizeof(*raw_val) +key_len);
if (ret)
apfs_err(sb, "insertion failed for id 0x%llx", dstream->ds_id);
 } else {
structapfs_crypto_state_valraw_val;

raw_val.refcnt=cpu_to_le32(1);
raw_val.state.major_version=cpu_to_le16(APFS_WMCS_MAJOR_VERSION);
raw_val.state.minor_version=cpu_to_le16(APFS_WMCS_MINOR_VERSION);
raw_val.state.cpflags=0;
raw_val.state.persistent_class=cpu_to_le32(APFS_PROTECTION_CLASS_F);
raw_val.state.key_os_version=0;
raw_val.state.key_revision=cpu_to_le16(1);
raw_val.state.key_len=cpu_to_le16(0);
ret=apfs_btree_insert(query, &raw_key, sizeof(raw_key), &raw_val, sizeof(raw_val));
if (ret)
apfs_err(sb, "insertion failed for id 0x%llx", dstream->ds_id);
 }
out:
apfs_free_query(query);
returnret;
}

/**
 * apfs_dflt_key_class - Returns default key class for files in volume
 * @sb: volume superblock
 */
staticunsigned intapfs_dflt_key_class(structsuper_block*sb)
{
structapfs_sb_info*sbi=APFS_SB(sb);

if (!sbi->s_dflt_pfk)
returnAPFS_PROTECTION_CLASS_F;

returnle32_to_cpu(sbi->s_dflt_pfk->state.persistent_class);
}

/**
 * apfs_create_crypto_rec - Adjust crypto state record refcount
 * @sb: volume superblock
 * @crypto_id: crypto_id to adjust
 * @delta: desired change in reference count
 *
 * This function is used when adding or removing extents, as each extent holds
 * a reference to the crypto ID. It should also be used when removing inodes,
 * and in that case it should also remove the crypto record (TODO).
 */
intapfs_crypto_adj_refcnt(structsuper_block*sb, u64crypto_id, intdelta)
{
structapfs_sb_info*sbi=APFS_SB(sb);
structapfs_query*query;
structapfs_crypto_state_val*raw_val;
char*raw;
intret;

if (!crypto_id)
return0;

query=apfs_alloc_query(sbi->s_cat_root, NULL/* parent */);
if (!query)
return-ENOMEM;
apfs_init_crypto_state_key(crypto_id, &query->key);
query->flags |= APFS_QUERY_CAT | APFS_QUERY_EXACT;

ret=apfs_btree_query(sb, &query);
if (ret) {
apfs_err(sb, "query failed for id 0x%llx", crypto_id);
 goto out;
 }

ret=apfs_query_join_transaction(query);
if (ret) {
apfs_err(sb, "query join failed");
returnret;
 }
raw=query->node->object.data;
raw_val= (void*)raw+query->off;

le32_add_cpu(&raw_val->refcnt, delta);

out:
apfs_free_query(query);
returnret;
}

/**
 * apfs_crypto_set_key - Modify content of crypto state record
 * @sb: volume superblock
 * @crypto_id: crypto_id to modify
 * @new_val: new crypto state data; new_val->refcnt is overridden
 *
 * This function does not alter the inode's default protection class field.
 * It needs to be done separately if the class changes.
 */
staticintapfs_crypto_set_key(structsuper_block*sb, u64crypto_id, structapfs_crypto_state_val*new_val)
{
structapfs_sb_info*sbi=APFS_SB(sb);
structapfs_query*query;
structapfs_crypto_state_val*raw_val;
char*raw;
intret;
unsigned intpfk_len;

if (!crypto_id)
return0;

pfk_len=le16_to_cpu(new_val->state.key_len);

query=apfs_alloc_query(sbi->s_cat_root, NULL/* parent */);
if (!query)
return-ENOMEM;
apfs_init_crypto_state_key(crypto_id, &query->key);
query->flags |= APFS_QUERY_CAT | APFS_QUERY_EXACT;

ret=apfs_btree_query(sb, &query);
if (ret) {
apfs_err(sb, "query failed for id 0x%llx", crypto_id);
 goto out;
 }
raw=query->node->object.data;
raw_val= (void*)raw+query->off;

new_val->refcnt=raw_val->refcnt;

ret=apfs_btree_replace(query, NULL/* key */, 0/* key_len */, new_val, sizeof(*new_val) +pfk_len);
if (ret)
apfs_err(sb, "update failed for id 0x%llx", crypto_id);

out:
apfs_free_query(query);
returnret;
}

/**
 * apfs_crypto_get_key - Retrieve content of crypto state record
 * @sb: volume superblock
 * @crypto_id: crypto_id to modify
 * @val: result crypto state data
 * @max_len: maximum allowed value of val->state.key_len
 */
staticintapfs_crypto_get_key(structsuper_block*sb, u64crypto_id, structapfs_crypto_state_val*val,
unsigned intmax_len)
{
structapfs_sb_info*sbi=APFS_SB(sb);
structapfs_query*query;
structapfs_crypto_state_val*raw_val;
char*raw;
intret;
unsigned intpfk_len;

if (!crypto_id)
return-ENOENT;

query=apfs_alloc_query(sbi->s_cat_root, NULL/* parent */);
if (!query)
return-ENOMEM;
apfs_init_crypto_state_key(crypto_id, &query->key);
query->flags |= APFS_QUERY_CAT | APFS_QUERY_EXACT;

ret=apfs_btree_query(sb, &query);
if (ret)
 goto out;
raw=query->node->object.data;
raw_val= (void*)raw+query->off;

pfk_len=le16_to_cpu(raw_val->state.key_len);
if (pfk_len>max_len) {
ret=-ENOSPC;
 goto out;
 }

memcpy(val, raw_val, sizeof(*val) +pfk_len);

out:
apfs_free_query(query);
returnret;
}

int__apfs_write_begin(structfile*file, structaddress_space*mapping, loff_tpos, unsigned intlen, unsigned intflags, structpage**pagep, void**fsdata)
{
structinode*inode=mapping->host;
structapfs_dstream_info*dstream=&APFS_I(inode)->i_dstream;
structsuper_block*sb=inode->i_sb;
structpage*page;
#ifLINUX_VERSION_CODE >= KERNEL_VERSION(6, 7, 0)
structfolio*folio;
#endif
structbuffer_head*bh, *head;
unsigned intblocksize, block_start, block_end, from, to;
pgoff_tindex=pos >> PAGE_SHIFT;
sector_tiblock= (sector_t)index << (PAGE_SHIFT-inode->i_blkbits);
loff_ti_blks_end;
interr;

apfs_inode_join_transaction(sb, inode);

err=apfs_inode_create_dstream_rec(inode);
if (err) {
apfs_err(sb, "failed to create dstream for ino 0x%llx", apfs_ino(inode));
returnerr;
 }

if (apfs_vol_is_encrypted(sb)) {
err=apfs_create_crypto_rec(inode);
if (err) {
apfs_err(sb, "crypto creation failed for ino 0x%llx", apfs_ino(inode));
returnerr;
 }
 }

#ifLINUX_VERSION_CODE >= KERNEL_VERSION(5, 19, 0) ||RHEL_VERSION_GE(9, 3)
flags=memalloc_nofs_save();
page=grab_cache_page_write_begin(mapping, index);
memalloc_nofs_restore(flags);
#else
page=grab_cache_page_write_begin(mapping, index, flags | AOP_FLAG_NOFS);
#endif
if (!page)
return-ENOMEM;
if (!page_has_buffers(page)) {
#ifLINUX_VERSION_CODE<KERNEL_VERSION(6, 7, 0)
create_empty_buffers(page, sb->s_blocksize, 0);
#else
folio=page_folio(page);
bh=folio_buffers(folio);
if (!bh)
bh=create_empty_buffers(folio, sb->s_blocksize, 0);
#endif
 }

/* CoW moves existing blocks, so read them but mark them as unmapped */
head=page_buffers(page);
blocksize=head->b_size;
i_blks_end= (inode->i_size+sb->s_blocksize-1) >> inode->i_blkbits;
i_blks_end <<= inode->i_blkbits;
if (i_blks_end >= pos) {
from=pos& (PAGE_SIZE-1);
to=from+min(i_blks_end-pos, (loff_t)len);
 } else {
/* TODO: deal with preallocated tail blocks */
from=UINT_MAX;
to=0;
 }
for (bh=head, block_start=0; bh!=head|| !block_start;
block_start=block_end, bh=bh->b_this_page, ++iblock) {
block_end=block_start+blocksize;
if (to>block_start&&from<block_end) {
if (buffer_trans(bh))
continue;
if (!buffer_mapped(bh)) {
err=__apfs_get_block(dstream, iblock, bh,
 false /* create */);
if (err) {
apfs_err(sb, "failed to map block for ino 0x%llx", apfs_ino(inode));
 goto out_put_page;
 }
 }
if (buffer_mapped(bh) && !buffer_uptodate(bh)) {
get_bh(bh);
lock_buffer(bh);
bh->b_end_io=end_buffer_read_sync;
apfs_submit_bh(REQ_OP_READ, 0, bh);
wait_on_buffer(bh);
if (!buffer_uptodate(bh)) {
apfs_err(sb, "failed to read block for ino 0x%llx", apfs_ino(inode));
err=-EIO;
 goto out_put_page;
 }
 }
clear_buffer_mapped(bh);
 }
 }

#ifLINUX_VERSION_CODE >= KERNEL_VERSION(6, 12, 0)
err=__block_write_begin(page_folio(page), pos, len, apfs_get_new_block);
#else
err=__block_write_begin(page, pos, len, apfs_get_new_block);
#endif
if (err) {
apfs_err(sb, "CoW failed in inode 0x%llx", apfs_ino(inode));
 goto out_put_page;
 }

*pagep=page;
return0;

out_put_page:
unlock_page(page);
put_page(page);
returnerr;
}

#ifLINUX_VERSION_CODE >= KERNEL_VERSION(6, 12, 0)
staticintapfs_write_begin(structfile*file, structaddress_space*mapping,
loff_tpos, unsigned intlen,
structfolio**foliop, void**fsdata)
#elifLINUX_VERSION_CODE >= KERNEL_VERSION(5, 19, 0) ||RHEL_VERSION_GE(9, 3)
staticintapfs_write_begin(structfile*file, structaddress_space*mapping,
loff_tpos, unsigned intlen,
structpage**pagep, void**fsdata)
#else
staticintapfs_write_begin(structfile*file, structaddress_space*mapping,
loff_tpos, unsigned intlen, unsigned intflags,
structpage**pagep, void**fsdata)
#endif
{
structinode*inode=mapping->host;
structsuper_block*sb=inode->i_sb;
#ifLINUX_VERSION_CODE >= KERNEL_VERSION(6, 12, 0)
structpage*page=NULL;
structpage**pagep=&page;
#endif
interr;
#ifLINUX_VERSION_CODE >= KERNEL_VERSION(5, 19, 0) ||RHEL_VERSION_GE(9, 3)
unsigned intflags=0;
#endif

if (unlikely(pos >= APFS_MAX_FILE_SIZE))
return-EFBIG;

err=apfs_transaction_start(sb, APFS_TRANS_REG);
if (err)
returnerr;

err=__apfs_write_begin(file, mapping, pos, len, flags, pagep, fsdata);
if (err)
 goto fail;
#ifLINUX_VERSION_CODE >= KERNEL_VERSION(6, 12, 0)
*foliop=page_folio(page);
#endif
return0;

fail:
apfs_transaction_abort(sb);
returnerr;
}

int__apfs_write_end(structfile*file, structaddress_space*mapping, loff_tpos, unsigned intlen, unsigned intcopied, structpage*page, void*fsdata)
{
structinode*inode=mapping->host;
structapfs_dstream_info*dstream=&APFS_I(inode)->i_dstream;
intret, err;

#ifLINUX_VERSION_CODE >= KERNEL_VERSION(6, 12, 0)
ret=generic_write_end(file, mapping, pos, len, copied, page_folio(page), fsdata);
#else
ret=generic_write_end(file, mapping, pos, len, copied, page, fsdata);
#endif
dstream->ds_size=i_size_read(inode);
if (ret<len&&pos+len>inode->i_size) {
truncate_pagecache(inode, inode->i_size);
err=apfs_truncate(dstream, inode->i_size);
if (err) {
apfs_err(inode->i_sb, "truncation failed for ino 0x%llx", apfs_ino(inode));
returnerr;
 }
 }
returnret;
}

#ifLINUX_VERSION_CODE >= KERNEL_VERSION(6, 12, 0)
staticintapfs_write_end(structfile*file, structaddress_space*mapping,
loff_tpos, unsigned intlen, unsigned intcopied,
structfolio*folio, void*fsdata)
#else
staticintapfs_write_end(structfile*file, structaddress_space*mapping,
loff_tpos, unsigned intlen, unsigned intcopied,
structpage*page, void*fsdata)
#endif
{
structinode*inode=mapping->host;
structsuper_block*sb=inode->i_sb;
structapfs_nx_transaction*trans=&APFS_NXI(sb)->nx_transaction;
#ifLINUX_VERSION_CODE >= KERNEL_VERSION(6, 12, 0)
structpage*page=&folio->page;
#endif
intret, err;

ret=__apfs_write_end(file, mapping, pos, len, copied, page, fsdata);
if (ret<0) {
err=ret;
 goto fail;
 }

if ((pos+ret) & (sb->s_blocksize-1))
trans->t_state |= APFS_NX_TRANS_INCOMPLETE_BLOCK;
else
trans->t_state &= ~APFS_NX_TRANS_INCOMPLETE_BLOCK;

err=apfs_transaction_commit(sb);
if (!err)
returnret;

fail:
apfs_transaction_abort(sb);
returnerr;
}

#ifLINUX_VERSION_CODE >= KERNEL_VERSION(5, 18, 0) ||RHEL_VERSION_GE(9, 3)
staticvoidapfs_noop_invalidate_folio(structfolio*folio, size_toffset, size_tlength)
#else
staticvoidapfs_noop_invalidatepage(structpage*page, unsigned intoffset, unsigned intlength)
#endif
{
}

/* bmap is not implemented to avoid issues with CoW on swapfiles */
staticconststructaddress_space_operationsapfs_aops= {
#ifLINUX_VERSION_CODE >= KERNEL_VERSION(5, 18, 0) ||RHEL_VERSION_GE(9, 2)
 .dirty_folio=block_dirty_folio,
#elifLINUX_VERSION_CODE >= KERNEL_VERSION(5, 14, 0)
 .set_page_dirty=__set_page_dirty_buffers,
#endif

#ifLINUX_VERSION_CODE >= KERNEL_VERSION(5, 19, 0) ||RHEL_VERSION_GE(9, 3)
 .read_folio=apfs_read_folio,
#else
 .readpage=apfs_readpage,
#endif

#ifLINUX_VERSION_CODE >= KERNEL_VERSION(5, 8, 0)
 .readahead=apfs_readahead,
#else
 .readpages=apfs_readpages,
#endif

 .write_begin=apfs_write_begin,
 .write_end=apfs_write_end,

/* The intention is to keep bhs around until the transaction is over */
#ifLINUX_VERSION_CODE >= KERNEL_VERSION(5, 18, 0) ||RHEL_VERSION_GE(9, 3)
 .invalidate_folio=apfs_noop_invalidate_folio,
#else
 .invalidatepage=apfs_noop_invalidatepage,
#endif
};

/**
 * apfs_inode_set_ops - Set up an inode's operations
 * @inode: vfs inode to set up
 * @rdev: device id (0 if not a device file)
 * @compressed: is this a compressed inode?
 *
 * For device files, also sets the device id to @rdev.
 */
staticvoidapfs_inode_set_ops(structinode*inode, dev_trdev, boolcompressed)
{
/* A lot of operations still missing, of course */
switch (inode->i_mode&S_IFMT) {
caseS_IFREG:
inode->i_op=&apfs_file_inode_operations;
if (compressed) {
inode->i_fop=&apfs_compress_file_operations;
inode->i_mapping->a_ops=&apfs_compress_aops;
 } else {
inode->i_fop=&apfs_file_operations;
inode->i_mapping->a_ops=&apfs_aops;
 }
break;
caseS_IFDIR:
inode->i_op=&apfs_dir_inode_operations;
inode->i_fop=&apfs_dir_operations;
break;
caseS_IFLNK:
inode->i_op=&apfs_symlink_inode_operations;
break;
default:
inode->i_op=&apfs_special_inode_operations;
init_special_inode(inode, inode->i_mode, rdev);
break;
 }
}

/**
 * apfs_inode_from_query - Read the inode found by a successful query
 * @query: the query that found the record
 * @inode: vfs inode to be filled with the read data
 *
 * Reads the inode record into @inode and performs some basic sanity checks,
 * mostly as a protection against crafted filesystems. Returns 0 on success
 * or a negative error code otherwise.
 */
staticintapfs_inode_from_query(structapfs_query*query, structinode*inode)
{
structapfs_inode_info*ai=APFS_I(inode);
structapfs_dstream_info*dstream=&ai->i_dstream;
structapfs_inode_val*inode_val;
char*raw=query->node->object.data;
char*xval=NULL;
intxlen;
u32rdev=0, bsd_flags;
boolcompressed= false;

if (query->len<sizeof(*inode_val))
 goto corrupted;

inode_val= (structapfs_inode_val*)(raw+query->off);

ai->i_parent_id=le64_to_cpu(inode_val->parent_id);
dstream->ds_id=le64_to_cpu(inode_val->private_id);
inode->i_mode=le16_to_cpu(inode_val->mode);
ai->i_key_class=le32_to_cpu(inode_val->default_protection_class);
ai->i_int_flags=le64_to_cpu(inode_val->internal_flags);

ai->i_saved_uid=le32_to_cpu(inode_val->owner);
i_uid_write(inode, ai->i_saved_uid);
ai->i_saved_gid=le32_to_cpu(inode_val->group);
i_gid_write(inode, ai->i_saved_gid);

ai->i_bsd_flags=bsd_flags=le32_to_cpu(inode_val->bsd_flags);
if (bsd_flags&APFS_INOBSD_IMMUTABLE)
inode->i_flags |= S_IMMUTABLE;
if (bsd_flags&APFS_INOBSD_APPEND)
inode->i_flags |= S_APPEND;

if (!S_ISDIR(inode->i_mode)) {
/*
 * Directory inodes don't store their link count, so to provide
 * it we would have to actually count the subdirectories. The
 * HFS/HFS+ modules just leave it at 1, and so do we, for now.
 */
set_nlink(inode, le32_to_cpu(inode_val->nlink));
 } else {
ai->i_nchildren=le32_to_cpu(inode_val->nchildren);
 }

#ifLINUX_VERSION_CODE<KERNEL_VERSION(6, 6, 0)
inode->i_ctime=ns_to_timespec64(le64_to_cpu(inode_val->change_time));
#else
inode_set_ctime_to_ts(inode, ns_to_timespec64(le64_to_cpu(inode_val->change_time)));
#endif

#ifLINUX_VERSION_CODE<KERNEL_VERSION(6, 7, 0)
inode->i_atime=ns_to_timespec64(le64_to_cpu(inode_val->access_time));
inode->i_mtime=ns_to_timespec64(le64_to_cpu(inode_val->mod_time));
#else
inode_set_atime_to_ts(inode, ns_to_timespec64(le64_to_cpu(inode_val->access_time)));
inode_set_mtime_to_ts(inode, ns_to_timespec64(le64_to_cpu(inode_val->mod_time)));
#endif
ai->i_crtime=ns_to_timespec64(le64_to_cpu(inode_val->create_time));

dstream->ds_size=inode->i_size=inode->i_blocks=0;
ai->i_has_dstream= false;
if ((bsd_flags&APFS_INOBSD_COMPRESSED) && !S_ISDIR(inode->i_mode)) {
if (!apfs_compress_get_size(inode, &inode->i_size)) {
inode->i_blocks= (inode->i_size+511) >> 9;
compressed= true;
 }
 } else {
xlen=apfs_find_xfield(inode_val->xfields,
query->len-sizeof(*inode_val),
APFS_INO_EXT_TYPE_DSTREAM, &xval);
if (xlen >= sizeof(structapfs_dstream)) {
structapfs_dstream*dstream_raw= (structapfs_dstream*)xval;

dstream->ds_size=inode->i_size=le64_to_cpu(dstream_raw->size);
inode->i_blocks=le64_to_cpu(dstream_raw->alloced_size) >> 9;
ai->i_has_dstream= true;
 }
 }
xval=NULL;

/* TODO: move each xfield read to its own function */
dstream->ds_sparse_bytes=0;
xlen=apfs_find_xfield(inode_val->xfields, query->len-sizeof(*inode_val), APFS_INO_EXT_TYPE_SPARSE_BYTES, &xval);
if (xlen >= sizeof(__le64)) {
__le64*sparse_bytes_p= (__le64*)xval;

dstream->ds_sparse_bytes=le64_to_cpup(sparse_bytes_p);
 }
xval=NULL;

rdev=0;
xlen=apfs_find_xfield(inode_val->xfields,
query->len-sizeof(*inode_val),
APFS_INO_EXT_TYPE_RDEV, &xval);
if (xlen >= sizeof(__le32)) {
__le32*rdev_p= (__le32*)xval;

rdev=le32_to_cpup(rdev_p);
 }

apfs_inode_set_ops(inode, rdev, compressed);
return0;

corrupted:
apfs_err(inode->i_sb, "bad inode record for inode 0x%llx", apfs_ino(inode));
return-EFSCORRUPTED;
}

/**
 * apfs_inode_lookup - Lookup an inode record in the catalog b-tree
 * @inode: vfs inode to lookup
 *
 * Runs a catalog query for the apfs_ino(@inode) inode record; returns a pointer
 * to the query structure on success, or an error pointer in case of failure.
 */
staticstructapfs_query*apfs_inode_lookup(conststructinode*inode)
{
structsuper_block*sb=inode->i_sb;
structapfs_sb_info*sbi=APFS_SB(sb);
structapfs_query*query;
intret;

query=apfs_alloc_query(sbi->s_cat_root, NULL/* parent */);
if (!query)
returnERR_PTR(-ENOMEM);
apfs_init_inode_key(apfs_ino(inode), &query->key);
query->flags |= APFS_QUERY_CAT | APFS_QUERY_EXACT;

ret=apfs_btree_query(sb, &query);
if (!ret)
returnquery;

/* Don't complain if an orphan is already gone */
if (!current_work() ||ret!=-ENODATA)
apfs_err(sb, "query failed for id 0x%llx", apfs_ino(inode));
apfs_free_query(query);
returnERR_PTR(ret);
}

/**
 * apfs_test_inode - Check if the inode matches a 64-bit inode number
 * @inode: inode to test
 * @cnid: pointer to the inode number
 */
staticintapfs_test_inode(structinode*inode, void*cnid)
{
u64*ino=cnid;

returnapfs_ino(inode) ==*ino;
}

/**
 * apfs_set_inode - Set a 64-bit inode number on the given inode
 * @inode: inode to set
 * @cnid: pointer to the inode number
 */
staticintapfs_set_inode(structinode*inode, void*cnid)
{
apfs_set_ino(inode, *(u64*)cnid);
return0;
}

/**
 * apfs_iget_locked - Wrapper for iget5_locked()
 * @sb: filesystem superblock
 * @cnid: 64-bit inode number
 *
 * Works the same as iget_locked(), but can handle 64-bit inode numbers on
 * 32-bit architectures.
 */
staticstructinode*apfs_iget_locked(structsuper_block*sb, u64cnid)
{
returniget5_locked(sb, cnid, apfs_test_inode, apfs_set_inode, &cnid);
}

/**
 * apfs_check_dstream_refcnt - Check if an inode's dstream is shared
 * @inode: the inode to check
 *
 * Sets the value of ds_shared for the inode's dstream. Returns 0 on success,
 * or a negative error code in case of failure.
 */
staticintapfs_check_dstream_refcnt(structinode*inode)
{
structapfs_inode_info*ai=APFS_I(inode);
structapfs_dstream_info*dstream=&ai->i_dstream;
structsuper_block*sb=inode->i_sb;
structapfs_sb_info*sbi=APFS_SB(sb);
structapfs_query*query=NULL;
structapfs_dstream_id_valraw_val;
void*raw=NULL;
u32refcnt;
intret;

if (!ai->i_has_dstream) {
dstream->ds_shared= false;
return0;
 }

query=apfs_alloc_query(sbi->s_cat_root, NULL/* parent */);
if (!query)
return-ENOMEM;
apfs_init_dstream_id_key(dstream->ds_id, &query->key);
query->flags |= APFS_QUERY_CAT | APFS_QUERY_EXACT;

ret=apfs_btree_query(sb, &query);
if (ret) {
apfs_err(sb, "query failed for id 0x%llx", dstream->ds_id);
if (ret==-ENODATA)
ret=-EFSCORRUPTED;
 goto fail;
 }

if (query->len!=sizeof(raw_val)) {
ret=-EFSCORRUPTED;
 goto fail;
 }
raw=query->node->object.data;
raw_val=*(structapfs_dstream_id_val*)(raw+query->off);
refcnt=le32_to_cpu(raw_val.refcnt);

dstream->ds_shared=refcnt>1;
fail:
apfs_free_query(query);
returnret;
}

/**
 * apfs_iget - Populate inode structures with metadata from disk
 * @sb: filesystem superblock
 * @cnid: inode number