1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * linux/fs/hfsplus/catalog.c |
4 | * |
5 | * Copyright (C) 2001 |
6 | * Brad Boyer (flar@allandria.com) |
7 | * (C) 2003 Ardis Technologies <roman@ardistech.com> |
8 | * |
9 | * Handling of catalog records |
10 | */ |
11 | |
12 | |
13 | #include "hfsplus_fs.h" |
14 | #include "hfsplus_raw.h" |
15 | |
16 | int hfsplus_cat_case_cmp_key(const hfsplus_btree_key *k1, |
17 | const hfsplus_btree_key *k2) |
18 | { |
19 | __be32 k1p, k2p; |
20 | |
21 | k1p = k1->cat.parent; |
22 | k2p = k2->cat.parent; |
23 | if (k1p != k2p) |
24 | return be32_to_cpu(k1p) < be32_to_cpu(k2p) ? -1 : 1; |
25 | |
26 | return hfsplus_strcasecmp(s1: &k1->cat.name, s2: &k2->cat.name); |
27 | } |
28 | |
29 | int hfsplus_cat_bin_cmp_key(const hfsplus_btree_key *k1, |
30 | const hfsplus_btree_key *k2) |
31 | { |
32 | __be32 k1p, k2p; |
33 | |
34 | k1p = k1->cat.parent; |
35 | k2p = k2->cat.parent; |
36 | if (k1p != k2p) |
37 | return be32_to_cpu(k1p) < be32_to_cpu(k2p) ? -1 : 1; |
38 | |
39 | return hfsplus_strcmp(s1: &k1->cat.name, s2: &k2->cat.name); |
40 | } |
41 | |
42 | /* Generates key for catalog file/folders record. */ |
43 | int hfsplus_cat_build_key(struct super_block *sb, |
44 | hfsplus_btree_key *key, u32 parent, const struct qstr *str) |
45 | { |
46 | int len, err; |
47 | |
48 | key->cat.parent = cpu_to_be32(parent); |
49 | err = hfsplus_asc2uni(sb, ustr: &key->cat.name, HFSPLUS_MAX_STRLEN, |
50 | astr: str->name, len: str->len); |
51 | if (unlikely(err < 0)) |
52 | return err; |
53 | |
54 | len = be16_to_cpu(key->cat.name.length); |
55 | key->key_len = cpu_to_be16(6 + 2 * len); |
56 | return 0; |
57 | } |
58 | |
59 | /* Generates key for catalog thread record. */ |
60 | void hfsplus_cat_build_key_with_cnid(struct super_block *sb, |
61 | hfsplus_btree_key *key, u32 parent) |
62 | { |
63 | key->cat.parent = cpu_to_be32(parent); |
64 | key->cat.name.length = 0; |
65 | key->key_len = cpu_to_be16(6); |
66 | } |
67 | |
68 | static void hfsplus_cat_build_key_uni(hfsplus_btree_key *key, u32 parent, |
69 | struct hfsplus_unistr *name) |
70 | { |
71 | int ustrlen; |
72 | |
73 | ustrlen = be16_to_cpu(name->length); |
74 | key->cat.parent = cpu_to_be32(parent); |
75 | key->cat.name.length = cpu_to_be16(ustrlen); |
76 | ustrlen *= 2; |
77 | memcpy(key->cat.name.unicode, name->unicode, ustrlen); |
78 | key->key_len = cpu_to_be16(6 + ustrlen); |
79 | } |
80 | |
81 | void hfsplus_cat_set_perms(struct inode *inode, struct hfsplus_perm *perms) |
82 | { |
83 | if (inode->i_flags & S_IMMUTABLE) |
84 | perms->rootflags |= HFSPLUS_FLG_IMMUTABLE; |
85 | else |
86 | perms->rootflags &= ~HFSPLUS_FLG_IMMUTABLE; |
87 | if (inode->i_flags & S_APPEND) |
88 | perms->rootflags |= HFSPLUS_FLG_APPEND; |
89 | else |
90 | perms->rootflags &= ~HFSPLUS_FLG_APPEND; |
91 | |
92 | perms->userflags = HFSPLUS_I(inode)->userflags; |
93 | perms->mode = cpu_to_be16(inode->i_mode); |
94 | perms->owner = cpu_to_be32(i_uid_read(inode)); |
95 | perms->group = cpu_to_be32(i_gid_read(inode)); |
96 | |
97 | if (S_ISREG(inode->i_mode)) |
98 | perms->dev = cpu_to_be32(inode->i_nlink); |
99 | else if (S_ISBLK(inode->i_mode) || S_ISCHR(inode->i_mode)) |
100 | perms->dev = cpu_to_be32(inode->i_rdev); |
101 | else |
102 | perms->dev = 0; |
103 | } |
104 | |
105 | static int hfsplus_cat_build_record(hfsplus_cat_entry *entry, |
106 | u32 cnid, struct inode *inode) |
107 | { |
108 | struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb: inode->i_sb); |
109 | |
110 | if (S_ISDIR(inode->i_mode)) { |
111 | struct hfsplus_cat_folder *folder; |
112 | |
113 | folder = &entry->folder; |
114 | memset(folder, 0, sizeof(*folder)); |
115 | folder->type = cpu_to_be16(HFSPLUS_FOLDER); |
116 | if (test_bit(HFSPLUS_SB_HFSX, &sbi->flags)) |
117 | folder->flags |= cpu_to_be16(HFSPLUS_HAS_FOLDER_COUNT); |
118 | folder->id = cpu_to_be32(inode->i_ino); |
119 | HFSPLUS_I(inode)->create_date = |
120 | folder->create_date = |
121 | folder->content_mod_date = |
122 | folder->attribute_mod_date = |
123 | folder->access_date = hfsp_now2mt(); |
124 | hfsplus_cat_set_perms(inode, perms: &folder->permissions); |
125 | if (inode == sbi->hidden_dir) |
126 | /* invisible and namelocked */ |
127 | folder->user_info.frFlags = cpu_to_be16(0x5000); |
128 | return sizeof(*folder); |
129 | } else { |
130 | struct hfsplus_cat_file *file; |
131 | |
132 | file = &entry->file; |
133 | memset(file, 0, sizeof(*file)); |
134 | file->type = cpu_to_be16(HFSPLUS_FILE); |
135 | file->flags = cpu_to_be16(HFSPLUS_FILE_THREAD_EXISTS); |
136 | file->id = cpu_to_be32(cnid); |
137 | HFSPLUS_I(inode)->create_date = |
138 | file->create_date = |
139 | file->content_mod_date = |
140 | file->attribute_mod_date = |
141 | file->access_date = hfsp_now2mt(); |
142 | if (cnid == inode->i_ino) { |
143 | hfsplus_cat_set_perms(inode, perms: &file->permissions); |
144 | if (S_ISLNK(inode->i_mode)) { |
145 | file->user_info.fdType = |
146 | cpu_to_be32(HFSP_SYMLINK_TYPE); |
147 | file->user_info.fdCreator = |
148 | cpu_to_be32(HFSP_SYMLINK_CREATOR); |
149 | } else { |
150 | file->user_info.fdType = |
151 | cpu_to_be32(sbi->type); |
152 | file->user_info.fdCreator = |
153 | cpu_to_be32(sbi->creator); |
154 | } |
155 | if (HFSPLUS_FLG_IMMUTABLE & |
156 | (file->permissions.rootflags | |
157 | file->permissions.userflags)) |
158 | file->flags |= |
159 | cpu_to_be16(HFSPLUS_FILE_LOCKED); |
160 | } else { |
161 | file->user_info.fdType = |
162 | cpu_to_be32(HFSP_HARDLINK_TYPE); |
163 | file->user_info.fdCreator = |
164 | cpu_to_be32(HFSP_HFSPLUS_CREATOR); |
165 | file->user_info.fdFlags = |
166 | cpu_to_be16(0x100); |
167 | file->create_date = |
168 | HFSPLUS_I(inode: sbi->hidden_dir)->create_date; |
169 | file->permissions.dev = |
170 | cpu_to_be32(HFSPLUS_I(inode)->linkid); |
171 | } |
172 | return sizeof(*file); |
173 | } |
174 | } |
175 | |
176 | static int hfsplus_fill_cat_thread(struct super_block *sb, |
177 | hfsplus_cat_entry *entry, int type, |
178 | u32 parentid, const struct qstr *str) |
179 | { |
180 | int err; |
181 | |
182 | entry->type = cpu_to_be16(type); |
183 | entry->thread.reserved = 0; |
184 | entry->thread.parentID = cpu_to_be32(parentid); |
185 | err = hfsplus_asc2uni(sb, ustr: &entry->thread.nodeName, HFSPLUS_MAX_STRLEN, |
186 | astr: str->name, len: str->len); |
187 | if (unlikely(err < 0)) |
188 | return err; |
189 | |
190 | return 10 + be16_to_cpu(entry->thread.nodeName.length) * 2; |
191 | } |
192 | |
193 | /* Try to get a catalog entry for given catalog id */ |
194 | int hfsplus_find_cat(struct super_block *sb, u32 cnid, |
195 | struct hfs_find_data *fd) |
196 | { |
197 | hfsplus_cat_entry tmp; |
198 | int err; |
199 | u16 type; |
200 | |
201 | hfsplus_cat_build_key_with_cnid(sb, key: fd->search_key, parent: cnid); |
202 | err = hfs_brec_read(fd, rec: &tmp, rec_len: sizeof(hfsplus_cat_entry)); |
203 | if (err) |
204 | return err; |
205 | |
206 | type = be16_to_cpu(tmp.type); |
207 | if (type != HFSPLUS_FOLDER_THREAD && type != HFSPLUS_FILE_THREAD) { |
208 | pr_err("found bad thread record in catalog\n" ); |
209 | return -EIO; |
210 | } |
211 | |
212 | if (be16_to_cpu(tmp.thread.nodeName.length) > 255) { |
213 | pr_err("catalog name length corrupted\n" ); |
214 | return -EIO; |
215 | } |
216 | |
217 | hfsplus_cat_build_key_uni(key: fd->search_key, |
218 | be32_to_cpu(tmp.thread.parentID), |
219 | name: &tmp.thread.nodeName); |
220 | return hfs_brec_find(fd, do_key_compare: hfs_find_rec_by_key); |
221 | } |
222 | |
223 | static void hfsplus_subfolders_inc(struct inode *dir) |
224 | { |
225 | struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb: dir->i_sb); |
226 | |
227 | if (test_bit(HFSPLUS_SB_HFSX, &sbi->flags)) { |
228 | /* |
229 | * Increment subfolder count. Note, the value is only meaningful |
230 | * for folders with HFSPLUS_HAS_FOLDER_COUNT flag set. |
231 | */ |
232 | HFSPLUS_I(inode: dir)->subfolders++; |
233 | } |
234 | } |
235 | |
236 | static void hfsplus_subfolders_dec(struct inode *dir) |
237 | { |
238 | struct hfsplus_sb_info *sbi = HFSPLUS_SB(sb: dir->i_sb); |
239 | |
240 | if (test_bit(HFSPLUS_SB_HFSX, &sbi->flags)) { |
241 | /* |
242 | * Decrement subfolder count. Note, the value is only meaningful |
243 | * for folders with HFSPLUS_HAS_FOLDER_COUNT flag set. |
244 | * |
245 | * Check for zero. Some subfolders may have been created |
246 | * by an implementation ignorant of this counter. |
247 | */ |
248 | if (HFSPLUS_I(inode: dir)->subfolders) |
249 | HFSPLUS_I(inode: dir)->subfolders--; |
250 | } |
251 | } |
252 | |
253 | int hfsplus_create_cat(u32 cnid, struct inode *dir, |
254 | const struct qstr *str, struct inode *inode) |
255 | { |
256 | struct super_block *sb = dir->i_sb; |
257 | struct hfs_find_data fd; |
258 | hfsplus_cat_entry entry; |
259 | int entry_size; |
260 | int err; |
261 | |
262 | hfs_dbg(CAT_MOD, "create_cat: %s,%u(%d)\n" , |
263 | str->name, cnid, inode->i_nlink); |
264 | err = hfs_find_init(tree: HFSPLUS_SB(sb)->cat_tree, fd: &fd); |
265 | if (err) |
266 | return err; |
267 | |
268 | /* |
269 | * Fail early and avoid ENOSPC during the btree operations. We may |
270 | * have to split the root node at most once. |
271 | */ |
272 | err = hfs_bmap_reserve(tree: fd.tree, rsvd_nodes: 2 * fd.tree->depth); |
273 | if (err) |
274 | goto err2; |
275 | |
276 | hfsplus_cat_build_key_with_cnid(sb, key: fd.search_key, parent: cnid); |
277 | entry_size = hfsplus_fill_cat_thread(sb, entry: &entry, |
278 | S_ISDIR(inode->i_mode) ? |
279 | HFSPLUS_FOLDER_THREAD : HFSPLUS_FILE_THREAD, |
280 | parentid: dir->i_ino, str); |
281 | if (unlikely(entry_size < 0)) { |
282 | err = entry_size; |
283 | goto err2; |
284 | } |
285 | |
286 | err = hfs_brec_find(fd: &fd, do_key_compare: hfs_find_rec_by_key); |
287 | if (err != -ENOENT) { |
288 | if (!err) |
289 | err = -EEXIST; |
290 | goto err2; |
291 | } |
292 | err = hfs_brec_insert(fd: &fd, entry: &entry, entry_len: entry_size); |
293 | if (err) |
294 | goto err2; |
295 | |
296 | err = hfsplus_cat_build_key(sb, key: fd.search_key, parent: dir->i_ino, str); |
297 | if (unlikely(err)) |
298 | goto err1; |
299 | |
300 | entry_size = hfsplus_cat_build_record(entry: &entry, cnid, inode); |
301 | err = hfs_brec_find(fd: &fd, do_key_compare: hfs_find_rec_by_key); |
302 | if (err != -ENOENT) { |
303 | /* panic? */ |
304 | if (!err) |
305 | err = -EEXIST; |
306 | goto err1; |
307 | } |
308 | err = hfs_brec_insert(fd: &fd, entry: &entry, entry_len: entry_size); |
309 | if (err) |
310 | goto err1; |
311 | |
312 | dir->i_size++; |
313 | if (S_ISDIR(inode->i_mode)) |
314 | hfsplus_subfolders_inc(dir); |
315 | inode_set_mtime_to_ts(inode: dir, ts: inode_set_ctime_current(inode: dir)); |
316 | hfsplus_mark_inode_dirty(inode: dir, HFSPLUS_I_CAT_DIRTY); |
317 | |
318 | hfs_find_exit(fd: &fd); |
319 | return 0; |
320 | |
321 | err1: |
322 | hfsplus_cat_build_key_with_cnid(sb, key: fd.search_key, parent: cnid); |
323 | if (!hfs_brec_find(fd: &fd, do_key_compare: hfs_find_rec_by_key)) |
324 | hfs_brec_remove(fd: &fd); |
325 | err2: |
326 | hfs_find_exit(fd: &fd); |
327 | return err; |
328 | } |
329 | |
330 | int hfsplus_delete_cat(u32 cnid, struct inode *dir, const struct qstr *str) |
331 | { |
332 | struct super_block *sb = dir->i_sb; |
333 | struct hfs_find_data fd; |
334 | struct hfsplus_fork_raw fork; |
335 | struct list_head *pos; |
336 | int err, off; |
337 | u16 type; |
338 | |
339 | hfs_dbg(CAT_MOD, "delete_cat: %s,%u\n" , str ? str->name : NULL, cnid); |
340 | err = hfs_find_init(tree: HFSPLUS_SB(sb)->cat_tree, fd: &fd); |
341 | if (err) |
342 | return err; |
343 | |
344 | /* |
345 | * Fail early and avoid ENOSPC during the btree operations. We may |
346 | * have to split the root node at most once. |
347 | */ |
348 | err = hfs_bmap_reserve(tree: fd.tree, rsvd_nodes: 2 * (int)fd.tree->depth - 2); |
349 | if (err) |
350 | goto out; |
351 | |
352 | if (!str) { |
353 | int len; |
354 | |
355 | hfsplus_cat_build_key_with_cnid(sb, key: fd.search_key, parent: cnid); |
356 | err = hfs_brec_find(fd: &fd, do_key_compare: hfs_find_rec_by_key); |
357 | if (err) |
358 | goto out; |
359 | |
360 | off = fd.entryoffset + |
361 | offsetof(struct hfsplus_cat_thread, nodeName); |
362 | fd.search_key->cat.parent = cpu_to_be32(dir->i_ino); |
363 | hfs_bnode_read(node: fd.bnode, |
364 | buf: &fd.search_key->cat.name.length, off, len: 2); |
365 | len = be16_to_cpu(fd.search_key->cat.name.length) * 2; |
366 | hfs_bnode_read(node: fd.bnode, |
367 | buf: &fd.search_key->cat.name.unicode, |
368 | off: off + 2, len); |
369 | fd.search_key->key_len = cpu_to_be16(6 + len); |
370 | } else { |
371 | err = hfsplus_cat_build_key(sb, key: fd.search_key, parent: dir->i_ino, str); |
372 | if (unlikely(err)) |
373 | goto out; |
374 | } |
375 | |
376 | err = hfs_brec_find(fd: &fd, do_key_compare: hfs_find_rec_by_key); |
377 | if (err) |
378 | goto out; |
379 | |
380 | type = hfs_bnode_read_u16(node: fd.bnode, off: fd.entryoffset); |
381 | if (type == HFSPLUS_FILE) { |
382 | #if 0 |
383 | off = fd.entryoffset + offsetof(hfsplus_cat_file, data_fork); |
384 | hfs_bnode_read(fd.bnode, &fork, off, sizeof(fork)); |
385 | hfsplus_free_fork(sb, cnid, &fork, HFSPLUS_TYPE_DATA); |
386 | #endif |
387 | |
388 | off = fd.entryoffset + |
389 | offsetof(struct hfsplus_cat_file, rsrc_fork); |
390 | hfs_bnode_read(node: fd.bnode, buf: &fork, off, len: sizeof(fork)); |
391 | hfsplus_free_fork(sb, cnid, fork: &fork, HFSPLUS_TYPE_RSRC); |
392 | } |
393 | |
394 | /* we only need to take spinlock for exclusion with ->release() */ |
395 | spin_lock(lock: &HFSPLUS_I(inode: dir)->open_dir_lock); |
396 | list_for_each(pos, &HFSPLUS_I(dir)->open_dir_list) { |
397 | struct hfsplus_readdir_data *rd = |
398 | list_entry(pos, struct hfsplus_readdir_data, list); |
399 | if (fd.tree->keycmp(fd.search_key, (void *)&rd->key) < 0) |
400 | rd->file->f_pos--; |
401 | } |
402 | spin_unlock(lock: &HFSPLUS_I(inode: dir)->open_dir_lock); |
403 | |
404 | err = hfs_brec_remove(fd: &fd); |
405 | if (err) |
406 | goto out; |
407 | |
408 | hfsplus_cat_build_key_with_cnid(sb, key: fd.search_key, parent: cnid); |
409 | err = hfs_brec_find(fd: &fd, do_key_compare: hfs_find_rec_by_key); |
410 | if (err) |
411 | goto out; |
412 | |
413 | err = hfs_brec_remove(fd: &fd); |
414 | if (err) |
415 | goto out; |
416 | |
417 | dir->i_size--; |
418 | if (type == HFSPLUS_FOLDER) |
419 | hfsplus_subfolders_dec(dir); |
420 | inode_set_mtime_to_ts(inode: dir, ts: inode_set_ctime_current(inode: dir)); |
421 | hfsplus_mark_inode_dirty(inode: dir, HFSPLUS_I_CAT_DIRTY); |
422 | |
423 | if (type == HFSPLUS_FILE || type == HFSPLUS_FOLDER) { |
424 | if (HFSPLUS_SB(sb)->attr_tree) |
425 | hfsplus_delete_all_attrs(dir, cnid); |
426 | } |
427 | |
428 | out: |
429 | hfs_find_exit(fd: &fd); |
430 | |
431 | return err; |
432 | } |
433 | |
434 | int hfsplus_rename_cat(u32 cnid, |
435 | struct inode *src_dir, const struct qstr *src_name, |
436 | struct inode *dst_dir, const struct qstr *dst_name) |
437 | { |
438 | struct super_block *sb = src_dir->i_sb; |
439 | struct hfs_find_data src_fd, dst_fd; |
440 | hfsplus_cat_entry entry; |
441 | int entry_size, type; |
442 | int err; |
443 | |
444 | hfs_dbg(CAT_MOD, "rename_cat: %u - %lu,%s - %lu,%s\n" , |
445 | cnid, src_dir->i_ino, src_name->name, |
446 | dst_dir->i_ino, dst_name->name); |
447 | err = hfs_find_init(tree: HFSPLUS_SB(sb)->cat_tree, fd: &src_fd); |
448 | if (err) |
449 | return err; |
450 | dst_fd = src_fd; |
451 | |
452 | /* |
453 | * Fail early and avoid ENOSPC during the btree operations. We may |
454 | * have to split the root node at most twice. |
455 | */ |
456 | err = hfs_bmap_reserve(tree: src_fd.tree, rsvd_nodes: 4 * (int)src_fd.tree->depth - 1); |
457 | if (err) |
458 | goto out; |
459 | |
460 | /* find the old dir entry and read the data */ |
461 | err = hfsplus_cat_build_key(sb, key: src_fd.search_key, |
462 | parent: src_dir->i_ino, str: src_name); |
463 | if (unlikely(err)) |
464 | goto out; |
465 | |
466 | err = hfs_brec_find(fd: &src_fd, do_key_compare: hfs_find_rec_by_key); |
467 | if (err) |
468 | goto out; |
469 | if (src_fd.entrylength > sizeof(entry) || src_fd.entrylength < 0) { |
470 | err = -EIO; |
471 | goto out; |
472 | } |
473 | |
474 | hfs_bnode_read(node: src_fd.bnode, buf: &entry, off: src_fd.entryoffset, |
475 | len: src_fd.entrylength); |
476 | type = be16_to_cpu(entry.type); |
477 | |
478 | /* create new dir entry with the data from the old entry */ |
479 | err = hfsplus_cat_build_key(sb, key: dst_fd.search_key, |
480 | parent: dst_dir->i_ino, str: dst_name); |
481 | if (unlikely(err)) |
482 | goto out; |
483 | |
484 | err = hfs_brec_find(fd: &dst_fd, do_key_compare: hfs_find_rec_by_key); |
485 | if (err != -ENOENT) { |
486 | if (!err) |
487 | err = -EEXIST; |
488 | goto out; |
489 | } |
490 | |
491 | err = hfs_brec_insert(fd: &dst_fd, entry: &entry, entry_len: src_fd.entrylength); |
492 | if (err) |
493 | goto out; |
494 | dst_dir->i_size++; |
495 | if (type == HFSPLUS_FOLDER) |
496 | hfsplus_subfolders_inc(dir: dst_dir); |
497 | inode_set_mtime_to_ts(inode: dst_dir, ts: inode_set_ctime_current(inode: dst_dir)); |
498 | |
499 | /* finally remove the old entry */ |
500 | err = hfsplus_cat_build_key(sb, key: src_fd.search_key, |
501 | parent: src_dir->i_ino, str: src_name); |
502 | if (unlikely(err)) |
503 | goto out; |
504 | |
505 | err = hfs_brec_find(fd: &src_fd, do_key_compare: hfs_find_rec_by_key); |
506 | if (err) |
507 | goto out; |
508 | err = hfs_brec_remove(fd: &src_fd); |
509 | if (err) |
510 | goto out; |
511 | src_dir->i_size--; |
512 | if (type == HFSPLUS_FOLDER) |
513 | hfsplus_subfolders_dec(dir: src_dir); |
514 | inode_set_mtime_to_ts(inode: src_dir, ts: inode_set_ctime_current(inode: src_dir)); |
515 | |
516 | /* remove old thread entry */ |
517 | hfsplus_cat_build_key_with_cnid(sb, key: src_fd.search_key, parent: cnid); |
518 | err = hfs_brec_find(fd: &src_fd, do_key_compare: hfs_find_rec_by_key); |
519 | if (err) |
520 | goto out; |
521 | type = hfs_bnode_read_u16(node: src_fd.bnode, off: src_fd.entryoffset); |
522 | err = hfs_brec_remove(fd: &src_fd); |
523 | if (err) |
524 | goto out; |
525 | |
526 | /* create new thread entry */ |
527 | hfsplus_cat_build_key_with_cnid(sb, key: dst_fd.search_key, parent: cnid); |
528 | entry_size = hfsplus_fill_cat_thread(sb, entry: &entry, type, |
529 | parentid: dst_dir->i_ino, str: dst_name); |
530 | if (unlikely(entry_size < 0)) { |
531 | err = entry_size; |
532 | goto out; |
533 | } |
534 | |
535 | err = hfs_brec_find(fd: &dst_fd, do_key_compare: hfs_find_rec_by_key); |
536 | if (err != -ENOENT) { |
537 | if (!err) |
538 | err = -EEXIST; |
539 | goto out; |
540 | } |
541 | err = hfs_brec_insert(fd: &dst_fd, entry: &entry, entry_len: entry_size); |
542 | |
543 | hfsplus_mark_inode_dirty(inode: dst_dir, HFSPLUS_I_CAT_DIRTY); |
544 | hfsplus_mark_inode_dirty(inode: src_dir, HFSPLUS_I_CAT_DIRTY); |
545 | out: |
546 | hfs_bnode_put(node: dst_fd.bnode); |
547 | hfs_find_exit(fd: &src_fd); |
548 | return err; |
549 | } |
550 | |