446 lines · c
1// SPDX-License-Identifier: GPL-2.02/*3 * Copyright (C) 2007 Oracle. All rights reserved.4 */5 6#include "messages.h"7#include "ctree.h"8#include "disk-io.h"9#include "transaction.h"10#include "accessors.h"11#include "dir-item.h"12 13/*14 * insert a name into a directory, doing overflow properly if there is a hash15 * collision. data_size indicates how big the item inserted should be. On16 * success a struct btrfs_dir_item pointer is returned, otherwise it is17 * an ERR_PTR.18 *19 * The name is not copied into the dir item, you have to do that yourself.20 */21static struct btrfs_dir_item *insert_with_overflow(struct btrfs_trans_handle22 *trans,23 struct btrfs_root *root,24 struct btrfs_path *path,25 const struct btrfs_key *cpu_key,26 u32 data_size,27 const char *name,28 int name_len)29{30 struct btrfs_fs_info *fs_info = root->fs_info;31 int ret;32 char *ptr;33 struct extent_buffer *leaf;34 35 ret = btrfs_insert_empty_item(trans, root, path, cpu_key, data_size);36 if (ret == -EEXIST) {37 struct btrfs_dir_item *di;38 di = btrfs_match_dir_item_name(fs_info, path, name, name_len);39 if (di)40 return ERR_PTR(-EEXIST);41 btrfs_extend_item(trans, path, data_size);42 } else if (ret < 0)43 return ERR_PTR(ret);44 WARN_ON(ret > 0);45 leaf = path->nodes[0];46 ptr = btrfs_item_ptr(leaf, path->slots[0], char);47 ASSERT(data_size <= btrfs_item_size(leaf, path->slots[0]));48 ptr += btrfs_item_size(leaf, path->slots[0]) - data_size;49 return (struct btrfs_dir_item *)ptr;50}51 52/*53 * xattrs work a lot like directories, this inserts an xattr item54 * into the tree55 */56int btrfs_insert_xattr_item(struct btrfs_trans_handle *trans,57 struct btrfs_root *root,58 struct btrfs_path *path, u64 objectid,59 const char *name, u16 name_len,60 const void *data, u16 data_len)61{62 int ret = 0;63 struct btrfs_dir_item *dir_item;64 unsigned long name_ptr, data_ptr;65 struct btrfs_key key, location;66 struct btrfs_disk_key disk_key;67 struct extent_buffer *leaf;68 u32 data_size;69 70 if (name_len + data_len > BTRFS_MAX_XATTR_SIZE(root->fs_info))71 return -ENOSPC;72 73 key.objectid = objectid;74 key.type = BTRFS_XATTR_ITEM_KEY;75 key.offset = btrfs_name_hash(name, name_len);76 77 data_size = sizeof(*dir_item) + name_len + data_len;78 dir_item = insert_with_overflow(trans, root, path, &key, data_size,79 name, name_len);80 if (IS_ERR(dir_item))81 return PTR_ERR(dir_item);82 memset(&location, 0, sizeof(location));83 84 leaf = path->nodes[0];85 btrfs_cpu_key_to_disk(&disk_key, &location);86 btrfs_set_dir_item_key(leaf, dir_item, &disk_key);87 btrfs_set_dir_flags(leaf, dir_item, BTRFS_FT_XATTR);88 btrfs_set_dir_name_len(leaf, dir_item, name_len);89 btrfs_set_dir_transid(leaf, dir_item, trans->transid);90 btrfs_set_dir_data_len(leaf, dir_item, data_len);91 name_ptr = (unsigned long)(dir_item + 1);92 data_ptr = (unsigned long)((char *)name_ptr + name_len);93 94 write_extent_buffer(leaf, name, name_ptr, name_len);95 write_extent_buffer(leaf, data, data_ptr, data_len);96 btrfs_mark_buffer_dirty(trans, path->nodes[0]);97 98 return ret;99}100 101/*102 * insert a directory item in the tree, doing all the magic for103 * both indexes. 'dir' indicates which objectid to insert it into,104 * 'location' is the key to stuff into the directory item, 'type' is the105 * type of the inode we're pointing to, and 'index' is the sequence number106 * to use for the second index (if one is created).107 * Will return 0 or -ENOMEM108 */109int btrfs_insert_dir_item(struct btrfs_trans_handle *trans,110 const struct fscrypt_str *name, struct btrfs_inode *dir,111 const struct btrfs_key *location, u8 type, u64 index)112{113 int ret = 0;114 int ret2 = 0;115 struct btrfs_root *root = dir->root;116 struct btrfs_path *path;117 struct btrfs_dir_item *dir_item;118 struct extent_buffer *leaf;119 unsigned long name_ptr;120 struct btrfs_key key;121 struct btrfs_disk_key disk_key;122 u32 data_size;123 124 key.objectid = btrfs_ino(dir);125 key.type = BTRFS_DIR_ITEM_KEY;126 key.offset = btrfs_name_hash(name->name, name->len);127 128 path = btrfs_alloc_path();129 if (!path)130 return -ENOMEM;131 132 btrfs_cpu_key_to_disk(&disk_key, location);133 134 data_size = sizeof(*dir_item) + name->len;135 dir_item = insert_with_overflow(trans, root, path, &key, data_size,136 name->name, name->len);137 if (IS_ERR(dir_item)) {138 ret = PTR_ERR(dir_item);139 if (ret == -EEXIST)140 goto second_insert;141 goto out_free;142 }143 144 if (IS_ENCRYPTED(&dir->vfs_inode))145 type |= BTRFS_FT_ENCRYPTED;146 147 leaf = path->nodes[0];148 btrfs_set_dir_item_key(leaf, dir_item, &disk_key);149 btrfs_set_dir_flags(leaf, dir_item, type);150 btrfs_set_dir_data_len(leaf, dir_item, 0);151 btrfs_set_dir_name_len(leaf, dir_item, name->len);152 btrfs_set_dir_transid(leaf, dir_item, trans->transid);153 name_ptr = (unsigned long)(dir_item + 1);154 155 write_extent_buffer(leaf, name->name, name_ptr, name->len);156 btrfs_mark_buffer_dirty(trans, leaf);157 158second_insert:159 /* FIXME, use some real flag for selecting the extra index */160 if (root == root->fs_info->tree_root) {161 ret = 0;162 goto out_free;163 }164 btrfs_release_path(path);165 166 ret2 = btrfs_insert_delayed_dir_index(trans, name->name, name->len, dir,167 &disk_key, type, index);168out_free:169 btrfs_free_path(path);170 if (ret)171 return ret;172 if (ret2)173 return ret2;174 return 0;175}176 177static struct btrfs_dir_item *btrfs_lookup_match_dir(178 struct btrfs_trans_handle *trans,179 struct btrfs_root *root, struct btrfs_path *path,180 struct btrfs_key *key, const char *name,181 int name_len, int mod)182{183 const int ins_len = (mod < 0 ? -1 : 0);184 const int cow = (mod != 0);185 int ret;186 187 ret = btrfs_search_slot(trans, root, key, path, ins_len, cow);188 if (ret < 0)189 return ERR_PTR(ret);190 if (ret > 0)191 return ERR_PTR(-ENOENT);192 193 return btrfs_match_dir_item_name(root->fs_info, path, name, name_len);194}195 196/*197 * Lookup for a directory item by name.198 *199 * @trans: The transaction handle to use. Can be NULL if @mod is 0.200 * @root: The root of the target tree.201 * @path: Path to use for the search.202 * @dir: The inode number (objectid) of the directory.203 * @name: The name associated to the directory entry we are looking for.204 * @name_len: The length of the name.205 * @mod: Used to indicate if the tree search is meant for a read only206 * lookup, for a modification lookup or for a deletion lookup, so207 * its value should be 0, 1 or -1, respectively.208 *209 * Returns: NULL if the dir item does not exists, an error pointer if an error210 * happened, or a pointer to a dir item if a dir item exists for the given name.211 */212struct btrfs_dir_item *btrfs_lookup_dir_item(struct btrfs_trans_handle *trans,213 struct btrfs_root *root,214 struct btrfs_path *path, u64 dir,215 const struct fscrypt_str *name,216 int mod)217{218 struct btrfs_key key;219 struct btrfs_dir_item *di;220 221 key.objectid = dir;222 key.type = BTRFS_DIR_ITEM_KEY;223 key.offset = btrfs_name_hash(name->name, name->len);224 225 di = btrfs_lookup_match_dir(trans, root, path, &key, name->name,226 name->len, mod);227 if (IS_ERR(di) && PTR_ERR(di) == -ENOENT)228 return NULL;229 230 return di;231}232 233int btrfs_check_dir_item_collision(struct btrfs_root *root, u64 dir,234 const struct fscrypt_str *name)235{236 int ret;237 struct btrfs_key key;238 struct btrfs_dir_item *di;239 int data_size;240 struct extent_buffer *leaf;241 int slot;242 struct btrfs_path *path;243 244 path = btrfs_alloc_path();245 if (!path)246 return -ENOMEM;247 248 key.objectid = dir;249 key.type = BTRFS_DIR_ITEM_KEY;250 key.offset = btrfs_name_hash(name->name, name->len);251 252 di = btrfs_lookup_match_dir(NULL, root, path, &key, name->name,253 name->len, 0);254 if (IS_ERR(di)) {255 ret = PTR_ERR(di);256 /* Nothing found, we're safe */257 if (ret == -ENOENT) {258 ret = 0;259 goto out;260 }261 262 if (ret < 0)263 goto out;264 }265 266 /* we found an item, look for our name in the item */267 if (di) {268 /* our exact name was found */269 ret = -EEXIST;270 goto out;271 }272 273 /* See if there is room in the item to insert this name. */274 data_size = sizeof(*di) + name->len;275 leaf = path->nodes[0];276 slot = path->slots[0];277 if (data_size + btrfs_item_size(leaf, slot) +278 sizeof(struct btrfs_item) > BTRFS_LEAF_DATA_SIZE(root->fs_info)) {279 ret = -EOVERFLOW;280 } else {281 /* plenty of insertion room */282 ret = 0;283 }284out:285 btrfs_free_path(path);286 return ret;287}288 289/*290 * Lookup for a directory index item by name and index number.291 *292 * @trans: The transaction handle to use. Can be NULL if @mod is 0.293 * @root: The root of the target tree.294 * @path: Path to use for the search.295 * @dir: The inode number (objectid) of the directory.296 * @index: The index number.297 * @name: The name associated to the directory entry we are looking for.298 * @name_len: The length of the name.299 * @mod: Used to indicate if the tree search is meant for a read only300 * lookup, for a modification lookup or for a deletion lookup, so301 * its value should be 0, 1 or -1, respectively.302 *303 * Returns: NULL if the dir index item does not exists, an error pointer if an304 * error happened, or a pointer to a dir item if the dir index item exists and305 * matches the criteria (name and index number).306 */307struct btrfs_dir_item *308btrfs_lookup_dir_index_item(struct btrfs_trans_handle *trans,309 struct btrfs_root *root,310 struct btrfs_path *path, u64 dir,311 u64 index, const struct fscrypt_str *name, int mod)312{313 struct btrfs_dir_item *di;314 struct btrfs_key key;315 316 key.objectid = dir;317 key.type = BTRFS_DIR_INDEX_KEY;318 key.offset = index;319 320 di = btrfs_lookup_match_dir(trans, root, path, &key, name->name,321 name->len, mod);322 if (di == ERR_PTR(-ENOENT))323 return NULL;324 325 return di;326}327 328struct btrfs_dir_item *329btrfs_search_dir_index_item(struct btrfs_root *root, struct btrfs_path *path,330 u64 dirid, const struct fscrypt_str *name)331{332 struct btrfs_dir_item *di;333 struct btrfs_key key;334 int ret;335 336 key.objectid = dirid;337 key.type = BTRFS_DIR_INDEX_KEY;338 key.offset = 0;339 340 btrfs_for_each_slot(root, &key, &key, path, ret) {341 if (key.objectid != dirid || key.type != BTRFS_DIR_INDEX_KEY)342 break;343 344 di = btrfs_match_dir_item_name(root->fs_info, path,345 name->name, name->len);346 if (di)347 return di;348 }349 /* Adjust return code if the key was not found in the next leaf. */350 if (ret >= 0)351 ret = -ENOENT;352 353 return ERR_PTR(ret);354}355 356struct btrfs_dir_item *btrfs_lookup_xattr(struct btrfs_trans_handle *trans,357 struct btrfs_root *root,358 struct btrfs_path *path, u64 dir,359 const char *name, u16 name_len,360 int mod)361{362 struct btrfs_key key;363 struct btrfs_dir_item *di;364 365 key.objectid = dir;366 key.type = BTRFS_XATTR_ITEM_KEY;367 key.offset = btrfs_name_hash(name, name_len);368 369 di = btrfs_lookup_match_dir(trans, root, path, &key, name, name_len, mod);370 if (IS_ERR(di) && PTR_ERR(di) == -ENOENT)371 return NULL;372 373 return di;374}375 376/*377 * helper function to look at the directory item pointed to by 'path'378 * this walks through all the entries in a dir item and finds one379 * for a specific name.380 */381struct btrfs_dir_item *btrfs_match_dir_item_name(struct btrfs_fs_info *fs_info,382 const struct btrfs_path *path,383 const char *name, int name_len)384{385 struct btrfs_dir_item *dir_item;386 unsigned long name_ptr;387 u32 total_len;388 u32 cur = 0;389 u32 this_len;390 struct extent_buffer *leaf;391 392 leaf = path->nodes[0];393 dir_item = btrfs_item_ptr(leaf, path->slots[0], struct btrfs_dir_item);394 395 total_len = btrfs_item_size(leaf, path->slots[0]);396 while (cur < total_len) {397 this_len = sizeof(*dir_item) +398 btrfs_dir_name_len(leaf, dir_item) +399 btrfs_dir_data_len(leaf, dir_item);400 name_ptr = (unsigned long)(dir_item + 1);401 402 if (btrfs_dir_name_len(leaf, dir_item) == name_len &&403 memcmp_extent_buffer(leaf, name, name_ptr, name_len) == 0)404 return dir_item;405 406 cur += this_len;407 dir_item = (struct btrfs_dir_item *)((char *)dir_item +408 this_len);409 }410 return NULL;411}412 413/*414 * given a pointer into a directory item, delete it. This415 * handles items that have more than one entry in them.416 */417int btrfs_delete_one_dir_name(struct btrfs_trans_handle *trans,418 struct btrfs_root *root,419 struct btrfs_path *path,420 const struct btrfs_dir_item *di)421{422 423 struct extent_buffer *leaf;424 u32 sub_item_len;425 u32 item_len;426 int ret = 0;427 428 leaf = path->nodes[0];429 sub_item_len = sizeof(*di) + btrfs_dir_name_len(leaf, di) +430 btrfs_dir_data_len(leaf, di);431 item_len = btrfs_item_size(leaf, path->slots[0]);432 if (sub_item_len == item_len) {433 ret = btrfs_del_item(trans, root, path);434 } else {435 /* MARKER */436 unsigned long ptr = (unsigned long)di;437 unsigned long start;438 439 start = btrfs_item_ptr_offset(leaf, path->slots[0]);440 memmove_extent_buffer(leaf, ptr, ptr + sub_item_len,441 item_len - (ptr + sub_item_len - start));442 btrfs_truncate_item(trans, path, item_len - sub_item_len, 1);443 }444 return ret;445}446