2 * linux/fs/hfsplus/catalog.c
5 * Brad Boyer (flar@allandria.com)
6 * (C) 2003 Ardis Technologies <roman@ardistech.com>
8 * Handling of catalog records
11 #include <linux/sched.h>
13 #include "hfsplus_fs.h"
14 #include "hfsplus_raw.h"
16 int hfsplus_cat_case_cmp_key(const hfsplus_btree_key
*k1
,
17 const hfsplus_btree_key
*k2
)
24 return be32_to_cpu(k1p
) < be32_to_cpu(k2p
) ? -1 : 1;
26 return hfsplus_strcasecmp(&k1
->cat
.name
, &k2
->cat
.name
);
29 int hfsplus_cat_bin_cmp_key(const hfsplus_btree_key
*k1
,
30 const hfsplus_btree_key
*k2
)
37 return be32_to_cpu(k1p
) < be32_to_cpu(k2p
) ? -1 : 1;
39 return hfsplus_strcmp(&k1
->cat
.name
, &k2
->cat
.name
);
42 void hfsplus_cat_build_key(struct super_block
*sb
, hfsplus_btree_key
*key
,
43 u32 parent
, struct qstr
*str
)
47 key
->cat
.parent
= cpu_to_be32(parent
);
49 hfsplus_asc2uni(sb
, &key
->cat
.name
, str
->name
, str
->len
);
50 len
= be16_to_cpu(key
->cat
.name
.length
);
52 key
->cat
.name
.length
= 0;
55 key
->key_len
= cpu_to_be16(6 + 2 * len
);
58 static void hfsplus_cat_build_key_uni(hfsplus_btree_key
*key
, u32 parent
,
59 struct hfsplus_unistr
*name
)
63 ustrlen
= be16_to_cpu(name
->length
);
64 key
->cat
.parent
= cpu_to_be32(parent
);
65 key
->cat
.name
.length
= cpu_to_be16(ustrlen
);
67 memcpy(key
->cat
.name
.unicode
, name
->unicode
, ustrlen
);
68 key
->key_len
= cpu_to_be16(6 + ustrlen
);
71 static void hfsplus_set_perms(struct inode
*inode
, struct hfsplus_perm
*perms
)
73 if (inode
->i_flags
& S_IMMUTABLE
)
74 perms
->rootflags
|= HFSPLUS_FLG_IMMUTABLE
;
76 perms
->rootflags
&= ~HFSPLUS_FLG_IMMUTABLE
;
77 if (inode
->i_flags
& S_APPEND
)
78 perms
->rootflags
|= HFSPLUS_FLG_APPEND
;
80 perms
->rootflags
&= ~HFSPLUS_FLG_APPEND
;
81 HFSPLUS_I(inode
).rootflags
= perms
->rootflags
;
82 HFSPLUS_I(inode
).userflags
= perms
->userflags
;
83 perms
->mode
= cpu_to_be16(inode
->i_mode
);
84 perms
->owner
= cpu_to_be32(inode
->i_uid
);
85 perms
->group
= cpu_to_be32(inode
->i_gid
);
88 static int hfsplus_cat_build_record(hfsplus_cat_entry
*entry
, u32 cnid
, struct inode
*inode
)
90 if (S_ISDIR(inode
->i_mode
)) {
91 struct hfsplus_cat_folder
*folder
;
93 folder
= &entry
->folder
;
94 memset(folder
, 0, sizeof(*folder
));
95 folder
->type
= cpu_to_be16(HFSPLUS_FOLDER
);
96 folder
->id
= cpu_to_be32(inode
->i_ino
);
97 HFSPLUS_I(inode
).create_date
=
99 folder
->content_mod_date
=
100 folder
->attribute_mod_date
=
101 folder
->access_date
= hfsp_now2mt();
102 hfsplus_set_perms(inode
, &folder
->permissions
);
103 if (inode
== HFSPLUS_SB(inode
->i_sb
).hidden_dir
)
104 /* invisible and namelocked */
105 folder
->user_info
.frFlags
= cpu_to_be16(0x5000);
106 return sizeof(*folder
);
108 struct hfsplus_cat_file
*file
;
111 memset(file
, 0, sizeof(*file
));
112 file
->type
= cpu_to_be16(HFSPLUS_FILE
);
113 file
->flags
= cpu_to_be16(HFSPLUS_FILE_THREAD_EXISTS
);
114 file
->id
= cpu_to_be32(cnid
);
115 HFSPLUS_I(inode
).create_date
=
117 file
->content_mod_date
=
118 file
->attribute_mod_date
=
119 file
->access_date
= hfsp_now2mt();
120 if (cnid
== inode
->i_ino
) {
121 hfsplus_set_perms(inode
, &file
->permissions
);
122 file
->user_info
.fdType
= cpu_to_be32(HFSPLUS_SB(inode
->i_sb
).type
);
123 file
->user_info
.fdCreator
= cpu_to_be32(HFSPLUS_SB(inode
->i_sb
).creator
);
124 if ((file
->permissions
.rootflags
| file
->permissions
.userflags
) & HFSPLUS_FLG_IMMUTABLE
)
125 file
->flags
|= cpu_to_be16(HFSPLUS_FILE_LOCKED
);
127 file
->user_info
.fdType
= cpu_to_be32(HFSP_HARDLINK_TYPE
);
128 file
->user_info
.fdCreator
= cpu_to_be32(HFSP_HFSPLUS_CREATOR
);
129 file
->user_info
.fdFlags
= cpu_to_be16(0x100);
130 file
->create_date
= HFSPLUS_I(HFSPLUS_SB(inode
->i_sb
).hidden_dir
).create_date
;
131 file
->permissions
.dev
= cpu_to_be32(HFSPLUS_I(inode
).dev
);
133 return sizeof(*file
);
137 static int hfsplus_fill_cat_thread(struct super_block
*sb
,
138 hfsplus_cat_entry
*entry
, int type
,
139 u32 parentid
, struct qstr
*str
)
141 entry
->type
= cpu_to_be16(type
);
142 entry
->thread
.reserved
= 0;
143 entry
->thread
.parentID
= cpu_to_be32(parentid
);
144 hfsplus_asc2uni(sb
, &entry
->thread
.nodeName
, str
->name
, str
->len
);
145 return 10 + be16_to_cpu(entry
->thread
.nodeName
.length
) * 2;
148 /* Try to get a catalog entry for given catalog id */
149 int hfsplus_find_cat(struct super_block
*sb
, u32 cnid
,
150 struct hfs_find_data
*fd
)
152 hfsplus_cat_entry tmp
;
156 hfsplus_cat_build_key(sb
, fd
->search_key
, cnid
, NULL
);
157 err
= hfs_brec_read(fd
, &tmp
, sizeof(hfsplus_cat_entry
));
161 type
= be16_to_cpu(tmp
.type
);
162 if (type
!= HFSPLUS_FOLDER_THREAD
&& type
!= HFSPLUS_FILE_THREAD
) {
163 printk(KERN_ERR
"hfs: found bad thread record in catalog\n");
167 hfsplus_cat_build_key_uni(fd
->search_key
, be32_to_cpu(tmp
.thread
.parentID
),
168 &tmp
.thread
.nodeName
);
169 return hfs_brec_find(fd
);
172 int hfsplus_create_cat(u32 cnid
, struct inode
*dir
, struct qstr
*str
, struct inode
*inode
)
174 struct hfs_find_data fd
;
175 struct super_block
*sb
;
176 hfsplus_cat_entry entry
;
180 dprint(DBG_CAT_MOD
, "create_cat: %s,%u(%d)\n", str
->name
, cnid
, inode
->i_nlink
);
182 hfs_find_init(HFSPLUS_SB(sb
).cat_tree
, &fd
);
184 hfsplus_cat_build_key(sb
, fd
.search_key
, cnid
, NULL
);
185 entry_size
= hfsplus_fill_cat_thread(sb
, &entry
, S_ISDIR(inode
->i_mode
) ?
186 HFSPLUS_FOLDER_THREAD
: HFSPLUS_FILE_THREAD
,
188 err
= hfs_brec_find(&fd
);
189 if (err
!= -ENOENT
) {
194 err
= hfs_brec_insert(&fd
, &entry
, entry_size
);
198 hfsplus_cat_build_key(sb
, fd
.search_key
, dir
->i_ino
, str
);
199 entry_size
= hfsplus_cat_build_record(&entry
, cnid
, inode
);
200 err
= hfs_brec_find(&fd
);
201 if (err
!= -ENOENT
) {
207 err
= hfs_brec_insert(&fd
, &entry
, entry_size
);
212 dir
->i_mtime
= dir
->i_ctime
= CURRENT_TIME_SEC
;
213 mark_inode_dirty(dir
);
218 hfsplus_cat_build_key(sb
, fd
.search_key
, cnid
, NULL
);
219 if (!hfs_brec_find(&fd
))
220 hfs_brec_remove(&fd
);
226 int hfsplus_delete_cat(u32 cnid
, struct inode
*dir
, struct qstr
*str
)
228 struct super_block
*sb
;
229 struct hfs_find_data fd
;
230 struct hfsplus_fork_raw fork
;
231 struct list_head
*pos
;
235 dprint(DBG_CAT_MOD
, "delete_cat: %s,%u\n", str
? str
->name
: NULL
, cnid
);
237 hfs_find_init(HFSPLUS_SB(sb
).cat_tree
, &fd
);
242 hfsplus_cat_build_key(sb
, fd
.search_key
, cnid
, NULL
);
243 err
= hfs_brec_find(&fd
);
247 off
= fd
.entryoffset
+ offsetof(struct hfsplus_cat_thread
, nodeName
);
248 fd
.search_key
->cat
.parent
= cpu_to_be32(dir
->i_ino
);
249 hfs_bnode_read(fd
.bnode
, &fd
.search_key
->cat
.name
.length
, off
, 2);
250 len
= be16_to_cpu(fd
.search_key
->cat
.name
.length
) * 2;
251 hfs_bnode_read(fd
.bnode
, &fd
.search_key
->cat
.name
.unicode
, off
+ 2, len
);
252 fd
.search_key
->key_len
= cpu_to_be16(6 + len
);
254 hfsplus_cat_build_key(sb
, fd
.search_key
, dir
->i_ino
, str
);
256 err
= hfs_brec_find(&fd
);
260 type
= hfs_bnode_read_u16(fd
.bnode
, fd
.entryoffset
);
261 if (type
== HFSPLUS_FILE
) {
263 off
= fd
.entryoffset
+ offsetof(hfsplus_cat_file
, data_fork
);
264 hfs_bnode_read(fd
.bnode
, &fork
, off
, sizeof(fork
));
265 hfsplus_free_fork(sb
, cnid
, &fork
, HFSPLUS_TYPE_DATA
);
268 off
= fd
.entryoffset
+ offsetof(struct hfsplus_cat_file
, rsrc_fork
);
269 hfs_bnode_read(fd
.bnode
, &fork
, off
, sizeof(fork
));
270 hfsplus_free_fork(sb
, cnid
, &fork
, HFSPLUS_TYPE_RSRC
);
273 list_for_each(pos
, &HFSPLUS_I(dir
).open_dir_list
) {
274 struct hfsplus_readdir_data
*rd
=
275 list_entry(pos
, struct hfsplus_readdir_data
, list
);
276 if (fd
.tree
->keycmp(fd
.search_key
, (void *)&rd
->key
) < 0)
280 err
= hfs_brec_remove(&fd
);
284 hfsplus_cat_build_key(sb
, fd
.search_key
, cnid
, NULL
);
285 err
= hfs_brec_find(&fd
);
289 err
= hfs_brec_remove(&fd
);
294 dir
->i_mtime
= dir
->i_ctime
= CURRENT_TIME_SEC
;
295 mark_inode_dirty(dir
);
302 int hfsplus_rename_cat(u32 cnid
,
303 struct inode
*src_dir
, struct qstr
*src_name
,
304 struct inode
*dst_dir
, struct qstr
*dst_name
)
306 struct super_block
*sb
;
307 struct hfs_find_data src_fd
, dst_fd
;
308 hfsplus_cat_entry entry
;
309 int entry_size
, type
;
312 dprint(DBG_CAT_MOD
, "rename_cat: %u - %lu,%s - %lu,%s\n", cnid
, src_dir
->i_ino
, src_name
->name
,
313 dst_dir
->i_ino
, dst_name
->name
);
315 hfs_find_init(HFSPLUS_SB(sb
).cat_tree
, &src_fd
);
318 /* find the old dir entry and read the data */
319 hfsplus_cat_build_key(sb
, src_fd
.search_key
, src_dir
->i_ino
, src_name
);
320 err
= hfs_brec_find(&src_fd
);
324 hfs_bnode_read(src_fd
.bnode
, &entry
, src_fd
.entryoffset
,
327 /* create new dir entry with the data from the old entry */
328 hfsplus_cat_build_key(sb
, dst_fd
.search_key
, dst_dir
->i_ino
, dst_name
);
329 err
= hfs_brec_find(&dst_fd
);
330 if (err
!= -ENOENT
) {
336 err
= hfs_brec_insert(&dst_fd
, &entry
, src_fd
.entrylength
);
340 dst_dir
->i_mtime
= dst_dir
->i_ctime
= CURRENT_TIME_SEC
;
341 mark_inode_dirty(dst_dir
);
343 /* finally remove the old entry */
344 hfsplus_cat_build_key(sb
, src_fd
.search_key
, src_dir
->i_ino
, src_name
);
345 err
= hfs_brec_find(&src_fd
);
348 err
= hfs_brec_remove(&src_fd
);
352 src_dir
->i_mtime
= src_dir
->i_ctime
= CURRENT_TIME_SEC
;
353 mark_inode_dirty(src_dir
);
355 /* remove old thread entry */
356 hfsplus_cat_build_key(sb
, src_fd
.search_key
, cnid
, NULL
);
357 err
= hfs_brec_find(&src_fd
);
360 type
= hfs_bnode_read_u16(src_fd
.bnode
, src_fd
.entryoffset
);
361 err
= hfs_brec_remove(&src_fd
);
365 /* create new thread entry */
366 hfsplus_cat_build_key(sb
, dst_fd
.search_key
, cnid
, NULL
);
367 entry_size
= hfsplus_fill_cat_thread(sb
, &entry
, type
, dst_dir
->i_ino
, dst_name
);
368 err
= hfs_brec_find(&dst_fd
);
369 if (err
!= -ENOENT
) {
374 err
= hfs_brec_insert(&dst_fd
, &entry
, entry_size
);
376 hfs_bnode_put(dst_fd
.bnode
);
377 hfs_find_exit(&src_fd
);