1 /* 2 * linux/fs/hfsplus/attributes.c 3 * 4 * Vyacheslav Dubeyko <slava@dubeyko.com> 5 * 6 * Handling of records in attributes tree 7 */ 8 9 #include "hfsplus_fs.h" 10 #include "hfsplus_raw.h" 11 12 static struct kmem_cache *hfsplus_attr_tree_cachep; 13 14 int hfsplus_create_attr_tree_cache(void) 15 { 16 if (hfsplus_attr_tree_cachep) 17 return -EEXIST; 18 19 hfsplus_attr_tree_cachep = 20 kmem_cache_create("hfsplus_attr_cache", 21 sizeof(hfsplus_attr_entry), 0, 22 SLAB_HWCACHE_ALIGN, NULL); 23 if (!hfsplus_attr_tree_cachep) 24 return -ENOMEM; 25 26 return 0; 27 } 28 29 void hfsplus_destroy_attr_tree_cache(void) 30 { 31 kmem_cache_destroy(hfsplus_attr_tree_cachep); 32 } 33 34 int hfsplus_attr_bin_cmp_key(const hfsplus_btree_key *k1, 35 const hfsplus_btree_key *k2) 36 { 37 __be32 k1_cnid, k2_cnid; 38 39 k1_cnid = k1->attr.cnid; 40 k2_cnid = k2->attr.cnid; 41 if (k1_cnid != k2_cnid) 42 return be32_to_cpu(k1_cnid) < be32_to_cpu(k2_cnid) ? -1 : 1; 43 44 return hfsplus_strcmp( 45 (const struct hfsplus_unistr *)&k1->attr.key_name, 46 (const struct hfsplus_unistr *)&k2->attr.key_name); 47 } 48 49 int hfsplus_attr_build_key(struct super_block *sb, hfsplus_btree_key *key, 50 u32 cnid, const char *name) 51 { 52 int len; 53 54 memset(key, 0, sizeof(struct hfsplus_attr_key)); 55 key->attr.cnid = cpu_to_be32(cnid); 56 if (name) { 57 len = strlen(name); 58 if (len > HFSPLUS_ATTR_MAX_STRLEN) { 59 pr_err("invalid xattr name's length\n"); 60 return -EINVAL; 61 } 62 hfsplus_asc2uni(sb, 63 (struct hfsplus_unistr *)&key->attr.key_name, 64 HFSPLUS_ATTR_MAX_STRLEN, name, len); 65 len = be16_to_cpu(key->attr.key_name.length); 66 } else { 67 key->attr.key_name.length = 0; 68 len = 0; 69 } 70 71 /* The length of the key, as stored in key_len field, does not include 72 * the size of the key_len field itself. 73 * So, offsetof(hfsplus_attr_key, key_name) is a trick because 74 * it takes into consideration key_len field (__be16) of 75 * hfsplus_attr_key structure instead of length field (__be16) of 76 * hfsplus_attr_unistr structure. 77 */ 78 key->key_len = 79 cpu_to_be16(offsetof(struct hfsplus_attr_key, key_name) + 80 2 * len); 81 82 return 0; 83 } 84 85 void hfsplus_attr_build_key_uni(hfsplus_btree_key *key, 86 u32 cnid, 87 struct hfsplus_attr_unistr *name) 88 { 89 int ustrlen; 90 91 memset(key, 0, sizeof(struct hfsplus_attr_key)); 92 ustrlen = be16_to_cpu(name->length); 93 key->attr.cnid = cpu_to_be32(cnid); 94 key->attr.key_name.length = cpu_to_be16(ustrlen); 95 ustrlen *= 2; 96 memcpy(key->attr.key_name.unicode, name->unicode, ustrlen); 97 98 /* The length of the key, as stored in key_len field, does not include 99 * the size of the key_len field itself. 100 * So, offsetof(hfsplus_attr_key, key_name) is a trick because 101 * it takes into consideration key_len field (__be16) of 102 * hfsplus_attr_key structure instead of length field (__be16) of 103 * hfsplus_attr_unistr structure. 104 */ 105 key->key_len = 106 cpu_to_be16(offsetof(struct hfsplus_attr_key, key_name) + 107 ustrlen); 108 } 109 110 hfsplus_attr_entry *hfsplus_alloc_attr_entry(void) 111 { 112 return kmem_cache_alloc(hfsplus_attr_tree_cachep, GFP_KERNEL); 113 } 114 115 void hfsplus_destroy_attr_entry(hfsplus_attr_entry *entry) 116 { 117 if (entry) 118 kmem_cache_free(hfsplus_attr_tree_cachep, entry); 119 } 120 121 #define HFSPLUS_INVALID_ATTR_RECORD -1 122 123 static int hfsplus_attr_build_record(hfsplus_attr_entry *entry, int record_type, 124 u32 cnid, const void *value, size_t size) 125 { 126 if (record_type == HFSPLUS_ATTR_FORK_DATA) { 127 /* 128 * Mac OS X supports only inline data attributes. 129 * Do nothing 130 */ 131 memset(entry, 0, sizeof(*entry)); 132 return sizeof(struct hfsplus_attr_fork_data); 133 } else if (record_type == HFSPLUS_ATTR_EXTENTS) { 134 /* 135 * Mac OS X supports only inline data attributes. 136 * Do nothing. 137 */ 138 memset(entry, 0, sizeof(*entry)); 139 return sizeof(struct hfsplus_attr_extents); 140 } else if (record_type == HFSPLUS_ATTR_INLINE_DATA) { 141 u16 len; 142 143 memset(entry, 0, sizeof(struct hfsplus_attr_inline_data)); 144 entry->inline_data.record_type = cpu_to_be32(record_type); 145 if (size <= HFSPLUS_MAX_INLINE_DATA_SIZE) 146 len = size; 147 else 148 return HFSPLUS_INVALID_ATTR_RECORD; 149 entry->inline_data.length = cpu_to_be16(len); 150 memcpy(entry->inline_data.raw_bytes, value, len); 151 /* 152 * Align len on two-byte boundary. 153 * It needs to add pad byte if we have odd len. 154 */ 155 len = round_up(len, 2); 156 return offsetof(struct hfsplus_attr_inline_data, raw_bytes) + 157 len; 158 } else /* invalid input */ 159 memset(entry, 0, sizeof(*entry)); 160 161 return HFSPLUS_INVALID_ATTR_RECORD; 162 } 163 164 int hfsplus_find_attr(struct super_block *sb, u32 cnid, 165 const char *name, struct hfs_find_data *fd) 166 { 167 int err = 0; 168 169 hfs_dbg(ATTR_MOD, "find_attr: %s,%d\n", name ? name : NULL, cnid); 170 171 if (!HFSPLUS_SB(sb)->attr_tree) { 172 pr_err("attributes file doesn't exist\n"); 173 return -EINVAL; 174 } 175 176 if (name) { 177 err = hfsplus_attr_build_key(sb, fd->search_key, cnid, name); 178 if (err) 179 goto failed_find_attr; 180 err = hfs_brec_find(fd, hfs_find_rec_by_key); 181 if (err) 182 goto failed_find_attr; 183 } else { 184 err = hfsplus_attr_build_key(sb, fd->search_key, cnid, NULL); 185 if (err) 186 goto failed_find_attr; 187 err = hfs_brec_find(fd, hfs_find_1st_rec_by_cnid); 188 if (err) 189 goto failed_find_attr; 190 } 191 192 failed_find_attr: 193 return err; 194 } 195 196 int hfsplus_attr_exists(struct inode *inode, const char *name) 197 { 198 int err = 0; 199 struct super_block *sb = inode->i_sb; 200 struct hfs_find_data fd; 201 202 if (!HFSPLUS_SB(sb)->attr_tree) 203 return 0; 204 205 err = hfs_find_init(HFSPLUS_SB(sb)->attr_tree, &fd); 206 if (err) 207 return 0; 208 209 err = hfsplus_find_attr(sb, inode->i_ino, name, &fd); 210 if (err) 211 goto attr_not_found; 212 213 hfs_find_exit(&fd); 214 return 1; 215 216 attr_not_found: 217 hfs_find_exit(&fd); 218 return 0; 219 } 220 221 int hfsplus_create_attr(struct inode *inode, 222 const char *name, 223 const void *value, size_t size) 224 { 225 struct super_block *sb = inode->i_sb; 226 struct hfs_find_data fd; 227 hfsplus_attr_entry *entry_ptr; 228 int entry_size; 229 int err; 230 231 hfs_dbg(ATTR_MOD, "create_attr: %s,%ld\n", 232 name ? name : NULL, inode->i_ino); 233 234 if (!HFSPLUS_SB(sb)->attr_tree) { 235 pr_err("attributes file doesn't exist\n"); 236 return -EINVAL; 237 } 238 239 entry_ptr = hfsplus_alloc_attr_entry(); 240 if (!entry_ptr) 241 return -ENOMEM; 242 243 err = hfs_find_init(HFSPLUS_SB(sb)->attr_tree, &fd); 244 if (err) 245 goto failed_init_create_attr; 246 247 if (name) { 248 err = hfsplus_attr_build_key(sb, fd.search_key, 249 inode->i_ino, name); 250 if (err) 251 goto failed_create_attr; 252 } else { 253 err = -EINVAL; 254 goto failed_create_attr; 255 } 256 257 /* Mac OS X supports only inline data attributes. */ 258 entry_size = hfsplus_attr_build_record(entry_ptr, 259 HFSPLUS_ATTR_INLINE_DATA, 260 inode->i_ino, 261 value, size); 262 if (entry_size == HFSPLUS_INVALID_ATTR_RECORD) { 263 err = -EINVAL; 264 goto failed_create_attr; 265 } 266 267 err = hfs_brec_find(&fd, hfs_find_rec_by_key); 268 if (err != -ENOENT) { 269 if (!err) 270 err = -EEXIST; 271 goto failed_create_attr; 272 } 273 274 err = hfs_brec_insert(&fd, entry_ptr, entry_size); 275 if (err) 276 goto failed_create_attr; 277 278 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_ATTR_DIRTY); 279 280 failed_create_attr: 281 hfs_find_exit(&fd); 282 283 failed_init_create_attr: 284 hfsplus_destroy_attr_entry(entry_ptr); 285 return err; 286 } 287 288 static int __hfsplus_delete_attr(struct inode *inode, u32 cnid, 289 struct hfs_find_data *fd) 290 { 291 int err = 0; 292 __be32 found_cnid, record_type; 293 294 hfs_bnode_read(fd->bnode, &found_cnid, 295 fd->keyoffset + 296 offsetof(struct hfsplus_attr_key, cnid), 297 sizeof(__be32)); 298 if (cnid != be32_to_cpu(found_cnid)) 299 return -ENOENT; 300 301 hfs_bnode_read(fd->bnode, &record_type, 302 fd->entryoffset, sizeof(record_type)); 303 304 switch (be32_to_cpu(record_type)) { 305 case HFSPLUS_ATTR_INLINE_DATA: 306 /* All is OK. Do nothing. */ 307 break; 308 case HFSPLUS_ATTR_FORK_DATA: 309 case HFSPLUS_ATTR_EXTENTS: 310 pr_err("only inline data xattr are supported\n"); 311 return -EOPNOTSUPP; 312 default: 313 pr_err("invalid extended attribute record\n"); 314 return -ENOENT; 315 } 316 317 err = hfs_brec_remove(fd); 318 if (err) 319 return err; 320 321 hfsplus_mark_inode_dirty(inode, HFSPLUS_I_ATTR_DIRTY); 322 return err; 323 } 324 325 int hfsplus_delete_attr(struct inode *inode, const char *name) 326 { 327 int err = 0; 328 struct super_block *sb = inode->i_sb; 329 struct hfs_find_data fd; 330 331 hfs_dbg(ATTR_MOD, "delete_attr: %s,%ld\n", 332 name ? name : NULL, inode->i_ino); 333 334 if (!HFSPLUS_SB(sb)->attr_tree) { 335 pr_err("attributes file doesn't exist\n"); 336 return -EINVAL; 337 } 338 339 err = hfs_find_init(HFSPLUS_SB(sb)->attr_tree, &fd); 340 if (err) 341 return err; 342 343 if (name) { 344 err = hfsplus_attr_build_key(sb, fd.search_key, 345 inode->i_ino, name); 346 if (err) 347 goto out; 348 } else { 349 pr_err("invalid extended attribute name\n"); 350 err = -EINVAL; 351 goto out; 352 } 353 354 err = hfs_brec_find(&fd, hfs_find_rec_by_key); 355 if (err) 356 goto out; 357 358 err = __hfsplus_delete_attr(inode, inode->i_ino, &fd); 359 if (err) 360 goto out; 361 362 out: 363 hfs_find_exit(&fd); 364 return err; 365 } 366 367 int hfsplus_delete_all_attrs(struct inode *dir, u32 cnid) 368 { 369 int err = 0; 370 struct hfs_find_data fd; 371 372 hfs_dbg(ATTR_MOD, "delete_all_attrs: %d\n", cnid); 373 374 if (!HFSPLUS_SB(dir->i_sb)->attr_tree) { 375 pr_err("attributes file doesn't exist\n"); 376 return -EINVAL; 377 } 378 379 err = hfs_find_init(HFSPLUS_SB(dir->i_sb)->attr_tree, &fd); 380 if (err) 381 return err; 382 383 for (;;) { 384 err = hfsplus_find_attr(dir->i_sb, cnid, NULL, &fd); 385 if (err) { 386 if (err != -ENOENT) 387 pr_err("xattr search failed\n"); 388 goto end_delete_all; 389 } 390 391 err = __hfsplus_delete_attr(dir, cnid, &fd); 392 if (err) 393 goto end_delete_all; 394 } 395 396 end_delete_all: 397 hfs_find_exit(&fd); 398 return err; 399 } 400