1 /* 2 * Copyright (C) 2007 Oracle. All rights reserved. 3 * 4 * This program is free software; you can redistribute it and/or 5 * modify it under the terms of the GNU General Public 6 * License v2 as published by the Free Software Foundation. 7 * 8 * This program is distributed in the hope that it will be useful, 9 * but WITHOUT ANY WARRANTY; without even the implied warranty of 10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 11 * General Public License for more details. 12 * 13 * You should have received a copy of the GNU General Public 14 * License along with this program; if not, write to the 15 * Free Software Foundation, Inc., 59 Temple Place - Suite 330, 16 * Boston, MA 021110-1307, USA. 17 */ 18 19 #include "ctree.h" 20 #include "disk-io.h" 21 #include "transaction.h" 22 23 static int find_name_in_backref(struct btrfs_path *path, const char *name, 24 int name_len, struct btrfs_inode_ref **ref_ret) 25 { 26 struct extent_buffer *leaf; 27 struct btrfs_inode_ref *ref; 28 unsigned long ptr; 29 unsigned long name_ptr; 30 u32 item_size; 31 u32 cur_offset = 0; 32 int len; 33 34 leaf = path->nodes[0]; 35 item_size = btrfs_item_size_nr(leaf, path->slots[0]); 36 ptr = btrfs_item_ptr_offset(leaf, path->slots[0]); 37 while (cur_offset < item_size) { 38 ref = (struct btrfs_inode_ref *)(ptr + cur_offset); 39 len = btrfs_inode_ref_name_len(leaf, ref); 40 name_ptr = (unsigned long)(ref + 1); 41 cur_offset += len + sizeof(*ref); 42 if (len != name_len) 43 continue; 44 if (memcmp_extent_buffer(leaf, name, name_ptr, name_len) == 0) { 45 *ref_ret = ref; 46 return 1; 47 } 48 } 49 return 0; 50 } 51 52 struct btrfs_inode_ref * 53 btrfs_lookup_inode_ref(struct btrfs_trans_handle *trans, 54 struct btrfs_root *root, 55 struct btrfs_path *path, 56 const char *name, int name_len, 57 u64 inode_objectid, u64 ref_objectid, int mod) 58 { 59 struct btrfs_key key; 60 struct btrfs_inode_ref *ref; 61 int ins_len = mod < 0 ? -1 : 0; 62 int cow = mod != 0; 63 int ret; 64 65 key.objectid = inode_objectid; 66 key.type = BTRFS_INODE_REF_KEY; 67 key.offset = ref_objectid; 68 69 ret = btrfs_search_slot(trans, root, &key, path, ins_len, cow); 70 if (ret < 0) 71 return ERR_PTR(ret); 72 if (ret > 0) 73 return NULL; 74 if (!find_name_in_backref(path, name, name_len, &ref)) 75 return NULL; 76 return ref; 77 } 78 79 int btrfs_del_inode_ref(struct btrfs_trans_handle *trans, 80 struct btrfs_root *root, 81 const char *name, int name_len, 82 u64 inode_objectid, u64 ref_objectid, u64 *index) 83 { 84 struct btrfs_path *path; 85 struct btrfs_key key; 86 struct btrfs_inode_ref *ref; 87 struct extent_buffer *leaf; 88 unsigned long ptr; 89 unsigned long item_start; 90 u32 item_size; 91 u32 sub_item_len; 92 int ret; 93 int del_len = name_len + sizeof(*ref); 94 95 key.objectid = inode_objectid; 96 key.offset = ref_objectid; 97 btrfs_set_key_type(&key, BTRFS_INODE_REF_KEY); 98 99 path = btrfs_alloc_path(); 100 if (!path) 101 return -ENOMEM; 102 103 path->leave_spinning = 1; 104 105 ret = btrfs_search_slot(trans, root, &key, path, -1, 1); 106 if (ret > 0) { 107 ret = -ENOENT; 108 goto out; 109 } else if (ret < 0) { 110 goto out; 111 } 112 if (!find_name_in_backref(path, name, name_len, &ref)) { 113 ret = -ENOENT; 114 goto out; 115 } 116 leaf = path->nodes[0]; 117 item_size = btrfs_item_size_nr(leaf, path->slots[0]); 118 119 if (index) 120 *index = btrfs_inode_ref_index(leaf, ref); 121 122 if (del_len == item_size) { 123 ret = btrfs_del_item(trans, root, path); 124 goto out; 125 } 126 ptr = (unsigned long)ref; 127 sub_item_len = name_len + sizeof(*ref); 128 item_start = btrfs_item_ptr_offset(leaf, path->slots[0]); 129 memmove_extent_buffer(leaf, ptr, ptr + sub_item_len, 130 item_size - (ptr + sub_item_len - item_start)); 131 ret = btrfs_truncate_item(trans, root, path, 132 item_size - sub_item_len, 1); 133 BUG_ON(ret); 134 out: 135 btrfs_free_path(path); 136 return ret; 137 } 138 139 int btrfs_insert_inode_ref(struct btrfs_trans_handle *trans, 140 struct btrfs_root *root, 141 const char *name, int name_len, 142 u64 inode_objectid, u64 ref_objectid, u64 index) 143 { 144 struct btrfs_path *path; 145 struct btrfs_key key; 146 struct btrfs_inode_ref *ref; 147 unsigned long ptr; 148 int ret; 149 int ins_len = name_len + sizeof(*ref); 150 151 key.objectid = inode_objectid; 152 key.offset = ref_objectid; 153 btrfs_set_key_type(&key, BTRFS_INODE_REF_KEY); 154 155 path = btrfs_alloc_path(); 156 if (!path) 157 return -ENOMEM; 158 159 path->leave_spinning = 1; 160 ret = btrfs_insert_empty_item(trans, root, path, &key, 161 ins_len); 162 if (ret == -EEXIST) { 163 u32 old_size; 164 165 if (find_name_in_backref(path, name, name_len, &ref)) 166 goto out; 167 168 old_size = btrfs_item_size_nr(path->nodes[0], path->slots[0]); 169 ret = btrfs_extend_item(trans, root, path, ins_len); 170 BUG_ON(ret); 171 ref = btrfs_item_ptr(path->nodes[0], path->slots[0], 172 struct btrfs_inode_ref); 173 ref = (struct btrfs_inode_ref *)((unsigned long)ref + old_size); 174 btrfs_set_inode_ref_name_len(path->nodes[0], ref, name_len); 175 btrfs_set_inode_ref_index(path->nodes[0], ref, index); 176 ptr = (unsigned long)(ref + 1); 177 ret = 0; 178 } else if (ret < 0) { 179 if (ret == -EOVERFLOW) 180 ret = -EMLINK; 181 goto out; 182 } else { 183 ref = btrfs_item_ptr(path->nodes[0], path->slots[0], 184 struct btrfs_inode_ref); 185 btrfs_set_inode_ref_name_len(path->nodes[0], ref, name_len); 186 btrfs_set_inode_ref_index(path->nodes[0], ref, index); 187 ptr = (unsigned long)(ref + 1); 188 } 189 write_extent_buffer(path->nodes[0], name, ptr, name_len); 190 btrfs_mark_buffer_dirty(path->nodes[0]); 191 192 out: 193 btrfs_free_path(path); 194 return ret; 195 } 196 197 int btrfs_insert_empty_inode(struct btrfs_trans_handle *trans, 198 struct btrfs_root *root, 199 struct btrfs_path *path, u64 objectid) 200 { 201 struct btrfs_key key; 202 int ret; 203 key.objectid = objectid; 204 btrfs_set_key_type(&key, BTRFS_INODE_ITEM_KEY); 205 key.offset = 0; 206 207 ret = btrfs_insert_empty_item(trans, root, path, &key, 208 sizeof(struct btrfs_inode_item)); 209 return ret; 210 } 211 212 int btrfs_lookup_inode(struct btrfs_trans_handle *trans, struct btrfs_root 213 *root, struct btrfs_path *path, 214 struct btrfs_key *location, int mod) 215 { 216 int ins_len = mod < 0 ? -1 : 0; 217 int cow = mod != 0; 218 int ret; 219 int slot; 220 struct extent_buffer *leaf; 221 struct btrfs_key found_key; 222 223 ret = btrfs_search_slot(trans, root, location, path, ins_len, cow); 224 if (ret > 0 && btrfs_key_type(location) == BTRFS_ROOT_ITEM_KEY && 225 location->offset == (u64)-1 && path->slots[0] != 0) { 226 slot = path->slots[0] - 1; 227 leaf = path->nodes[0]; 228 btrfs_item_key_to_cpu(leaf, &found_key, slot); 229 if (found_key.objectid == location->objectid && 230 btrfs_key_type(&found_key) == btrfs_key_type(location)) { 231 path->slots[0]--; 232 return 0; 233 } 234 } 235 return ret; 236 } 237