linux/fs/ntfs/object_id.c

// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Pocessing of object ids
 *
 * Part of this file is based on code from the NTFS-3G.
 *
 * Copyright (c) 2009-2019 Jean-Pierre Andre
 * Copyright (c) 2026 LG Electronics Co., Ltd.
 */

#include "ntfs.h"
#include "index.h"
#include "object_id.h"

struct object_id_index_key {
	union {
		u32 alignment;
		struct guid guid;
	} object_id;
} __packed;

struct object_id_index_data {
	__le64 file_id;
	struct guid birth_volume_id;
	struct guid birth_object_id;
	struct guid domain_id;
} __packed;

/* Index entry in $Extend/$ObjId */
struct object_id_index {
	struct index_entry_header header;
	struct object_id_index_key key;
	struct object_id_index_data data;
} __packed;

__le16 objid_index_name[] = {cpu_to_le16('$'), cpu_to_le16('O'), 0};

/*
 * open_object_id_index - Open the $Extend/$ObjId file and its index
 * @vol: NTFS volume structure
 *
 * Opens the $ObjId system file and retrieves its index context.
 *
 * Return: The index context if opened successfully, or NULL if an error
 *	   occurred.
 */
static struct ntfs_index_context *open_object_id_index(struct ntfs_volume *vol)
{
	struct inode *dir_vi, *vi;
	struct ntfs_inode *dir_ni;
	struct ntfs_index_context *xo = NULL;
	struct ntfs_name *name = NULL;
	u64 mref;
	int uname_len;
	__le16 *uname;

	uname_len = ntfs_nlstoucs(vol, "$ObjId", 6, &uname,
			NTFS_MAX_NAME_LEN);
	if (uname_len < 0)
		return NULL;

	/* do not use path_name_to inode - could reopen root */
	dir_vi = ntfs_iget(vol->sb, FILE_Extend);
	if (IS_ERR(dir_vi)) {
		kmem_cache_free(ntfs_name_cache, uname);
		return NULL;
	}
	dir_ni = NTFS_I(dir_vi);

	mutex_lock_nested(&dir_ni->mrec_lock, NTFS_EXTEND_MUTEX_PARENT);
	mref = ntfs_lookup_inode_by_name(dir_ni, uname, uname_len, &name);
	mutex_unlock(&dir_ni->mrec_lock);
	kfree(name);
	kmem_cache_free(ntfs_name_cache, uname);
	if (IS_ERR_MREF(mref))
		goto put_dir_vi;

	vi = ntfs_iget(vol->sb, MREF(mref));
	if (IS_ERR(vi))
		goto put_dir_vi;

	xo = ntfs_index_ctx_get(NTFS_I(vi), objid_index_name, 2);
	if (!xo)
		iput(vi);
put_dir_vi:
	iput(dir_vi);
	return xo;
}


/*
 * remove_object_id_index - Remove an object id index entry if attribute present
 * @ni: NTFS inode structure containing the attribute
 * @xo:	Index context for the object id index
 *
 * Reads the existing object ID attribute and removes it from the index.
 *
 * Return: 0 on success, or a negative error code on failure.
 */
static int remove_object_id_index(struct ntfs_inode *ni, struct ntfs_index_context *xo)
{
	struct object_id_index_key key = {0};
	s64 size;

	if (ni->data_size == 0)
		return -ENODATA;

	/* read the existing object id attribute */
	size = ntfs_inode_attr_pread(VFS_I(ni), 0, sizeof(struct guid),
				     (char *)&key);
	if (size != sizeof(struct guid))
		return -ENODATA;

	if (!ntfs_index_lookup(&key, sizeof(struct object_id_index_key), xo))
		return ntfs_index_rm(xo);

	return 0;
}

/*
 * ntfs_delete_object_id_index - Delete an object_id index entry
 * @ni:	NTFS inode structure
 *
 * Opens the object ID index and removes the entry corresponding to the inode.
 *
 * Return: 0 on success, or a negative error code on failure.
 */
int ntfs_delete_object_id_index(struct ntfs_inode *ni)
{
	struct ntfs_index_context *xo;
	struct ntfs_inode *xoni;
	struct inode *attr_vi;
	int ret = 0;

	attr_vi = ntfs_attr_iget(VFS_I(ni), AT_OBJECT_ID, AT_UNNAMED, 0);
	if (IS_ERR(attr_vi))
		return PTR_ERR(attr_vi);

	/*
	 * read the existing object id and un-index it
	 */
	xo = open_object_id_index(ni->vol);
	if (xo) {
		xoni = xo->idx_ni;
		mutex_lock_nested(&xoni->mrec_lock, NTFS_EXTEND_MUTEX_PARENT);
		ret = remove_object_id_index(NTFS_I(attr_vi), xo);
		if (!ret) {
			ntfs_index_entry_mark_dirty(xo);
			mark_mft_record_dirty(xoni);
		}
		ntfs_index_ctx_put(xo);
		mutex_unlock(&xoni->mrec_lock);
		iput(VFS_I(xoni));
	}

	iput(attr_vi);
	return ret;
}