1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#include "hfs_fs.h"
16#include "btree.h"
17
18
19
20
21
22
23void hfs_cat_build_key(struct super_block *sb, btree_key *key, u32 parent, struct qstr *name)
24{
25 key->cat.reserved = 0;
26 key->cat.ParID = cpu_to_be32(parent);
27 if (name) {
28 hfs_asc2mac(sb, &key->cat.CName, name);
29 key->key_len = 6 + key->cat.CName.len;
30 } else {
31 memset(&key->cat.CName, 0, sizeof(struct hfs_name));
32 key->key_len = 6;
33 }
34}
35
36static int hfs_cat_build_record(hfs_cat_rec *rec, u32 cnid, struct inode *inode)
37{
38 __be32 mtime = hfs_mtime();
39
40 memset(rec, 0, sizeof(*rec));
41 if (S_ISDIR(inode->i_mode)) {
42 rec->type = HFS_CDR_DIR;
43 rec->dir.DirID = cpu_to_be32(cnid);
44 rec->dir.CrDat = mtime;
45 rec->dir.MdDat = mtime;
46 rec->dir.BkDat = 0;
47 rec->dir.UsrInfo.frView = cpu_to_be16(0xff);
48 return sizeof(struct hfs_cat_dir);
49 } else {
50
51 rec->type = HFS_CDR_FIL;
52 rec->file.Flags = HFS_FIL_USED | HFS_FIL_THD;
53 if (!(inode->i_mode & S_IWUSR))
54 rec->file.Flags |= HFS_FIL_LOCK;
55 rec->file.FlNum = cpu_to_be32(cnid);
56 rec->file.CrDat = mtime;
57 rec->file.MdDat = mtime;
58 rec->file.BkDat = 0;
59 rec->file.UsrWds.fdType = HFS_SB(inode->i_sb)->s_type;
60 rec->file.UsrWds.fdCreator = HFS_SB(inode->i_sb)->s_creator;
61 return sizeof(struct hfs_cat_file);
62 }
63}
64
65static int hfs_cat_build_thread(struct super_block *sb,
66 hfs_cat_rec *rec, int type,
67 u32 parentid, struct qstr *name)
68{
69 rec->type = type;
70 memset(rec->thread.reserved, 0, sizeof(rec->thread.reserved));
71 rec->thread.ParID = cpu_to_be32(parentid);
72 hfs_asc2mac(sb, &rec->thread.CName, name);
73 return sizeof(struct hfs_cat_thread);
74}
75
76
77
78
79
80
81
82int hfs_cat_create(u32 cnid, struct inode *dir, struct qstr *str, struct inode *inode)
83{
84 struct hfs_find_data fd;
85 struct super_block *sb;
86 union hfs_cat_rec entry;
87 int entry_size;
88 int err;
89
90 dprint(DBG_CAT_MOD, "create_cat: %s,%u(%d)\n", str->name, cnid, inode->i_nlink);
91 if (dir->i_size >= HFS_MAX_VALENCE)
92 return -ENOSPC;
93
94 sb = dir->i_sb;
95 hfs_find_init(HFS_SB(sb)->cat_tree, &fd);
96
97 hfs_cat_build_key(sb, fd.search_key, cnid, NULL);
98 entry_size = hfs_cat_build_thread(sb, &entry, S_ISDIR(inode->i_mode) ?
99 HFS_CDR_THD : HFS_CDR_FTH,
100 dir->i_ino, str);
101 err = hfs_brec_find(&fd);
102 if (err != -ENOENT) {
103 if (!err)
104 err = -EEXIST;
105 goto err2;
106 }
107 err = hfs_brec_insert(&fd, &entry, entry_size);
108 if (err)
109 goto err2;
110
111 hfs_cat_build_key(sb, fd.search_key, dir->i_ino, str);
112 entry_size = hfs_cat_build_record(&entry, cnid, inode);
113 err = hfs_brec_find(&fd);
114 if (err != -ENOENT) {
115
116 if (!err)
117 err = -EEXIST;
118 goto err1;
119 }
120 err = hfs_brec_insert(&fd, &entry, entry_size);
121 if (err)
122 goto err1;
123
124 dir->i_size++;
125 dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
126 mark_inode_dirty(dir);
127 hfs_find_exit(&fd);
128 return 0;
129
130err1:
131 hfs_cat_build_key(sb, fd.search_key, cnid, NULL);
132 if (!hfs_brec_find(&fd))
133 hfs_brec_remove(&fd);
134err2:
135 hfs_find_exit(&fd);
136 return err;
137}
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160int hfs_cat_keycmp(const btree_key *key1, const btree_key *key2)
161{
162 int retval;
163
164 retval = be32_to_cpu(key1->cat.ParID) - be32_to_cpu(key2->cat.ParID);
165 if (!retval)
166 retval = hfs_strcmp(key1->cat.CName.name, key1->cat.CName.len,
167 key2->cat.CName.name, key2->cat.CName.len);
168
169 return retval;
170}
171
172
173
174int hfs_cat_find_brec(struct super_block *sb, u32 cnid,
175 struct hfs_find_data *fd)
176{
177 hfs_cat_rec rec;
178 int res, len, type;
179
180 hfs_cat_build_key(sb, fd->search_key, cnid, NULL);
181 res = hfs_brec_read(fd, &rec, sizeof(rec));
182 if (res)
183 return res;
184
185 type = rec.type;
186 if (type != HFS_CDR_THD && type != HFS_CDR_FTH) {
187 printk(KERN_ERR "hfs: found bad thread record in catalog\n");
188 return -EIO;
189 }
190
191 fd->search_key->cat.ParID = rec.thread.ParID;
192 len = fd->search_key->cat.CName.len = rec.thread.CName.len;
193 memcpy(fd->search_key->cat.CName.name, rec.thread.CName.name, len);
194 return hfs_brec_find(fd);
195}
196
197
198
199
200
201
202
203
204int hfs_cat_delete(u32 cnid, struct inode *dir, struct qstr *str)
205{
206 struct super_block *sb;
207 struct hfs_find_data fd;
208 struct list_head *pos;
209 int res, type;
210
211 dprint(DBG_CAT_MOD, "delete_cat: %s,%u\n", str ? str->name : NULL, cnid);
212 sb = dir->i_sb;
213 hfs_find_init(HFS_SB(sb)->cat_tree, &fd);
214
215 hfs_cat_build_key(sb, fd.search_key, dir->i_ino, str);
216 res = hfs_brec_find(&fd);
217 if (res)
218 goto out;
219
220 type = hfs_bnode_read_u8(fd.bnode, fd.entryoffset);
221 if (type == HFS_CDR_FIL) {
222 struct hfs_cat_file file;
223 hfs_bnode_read(fd.bnode, &file, fd.entryoffset, sizeof(file));
224 if (be32_to_cpu(file.FlNum) == cnid) {
225#if 0
226 hfs_free_fork(sb, &file, HFS_FK_DATA);
227#endif
228 hfs_free_fork(sb, &file, HFS_FK_RSRC);
229 }
230 }
231
232 list_for_each(pos, &HFS_I(dir)->open_dir_list) {
233 struct hfs_readdir_data *rd =
234 list_entry(pos, struct hfs_readdir_data, list);
235 if (fd.tree->keycmp(fd.search_key, (void *)&rd->key) < 0)
236 rd->file->f_pos--;
237 }
238
239 res = hfs_brec_remove(&fd);
240 if (res)
241 goto out;
242
243 hfs_cat_build_key(sb, fd.search_key, cnid, NULL);
244 res = hfs_brec_find(&fd);
245 if (!res) {
246 res = hfs_brec_remove(&fd);
247 if (res)
248 goto out;
249 }
250
251 dir->i_size--;
252 dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
253 mark_inode_dirty(dir);
254 res = 0;
255out:
256 hfs_find_exit(&fd);
257
258 return res;
259}
260
261
262
263
264
265
266
267
268int hfs_cat_move(u32 cnid, struct inode *src_dir, struct qstr *src_name,
269 struct inode *dst_dir, struct qstr *dst_name)
270{
271 struct super_block *sb;
272 struct hfs_find_data src_fd, dst_fd;
273 union hfs_cat_rec entry;
274 int entry_size, type;
275 int err;
276
277 dprint(DBG_CAT_MOD, "rename_cat: %u - %lu,%s - %lu,%s\n", cnid, src_dir->i_ino, src_name->name,
278 dst_dir->i_ino, dst_name->name);
279 sb = src_dir->i_sb;
280 hfs_find_init(HFS_SB(sb)->cat_tree, &src_fd);
281 dst_fd = src_fd;
282
283
284 hfs_cat_build_key(sb, src_fd.search_key, src_dir->i_ino, src_name);
285 err = hfs_brec_find(&src_fd);
286 if (err)
287 goto out;
288
289 hfs_bnode_read(src_fd.bnode, &entry, src_fd.entryoffset,
290 src_fd.entrylength);
291
292
293 hfs_cat_build_key(sb, dst_fd.search_key, dst_dir->i_ino, dst_name);
294 err = hfs_brec_find(&dst_fd);
295 if (err != -ENOENT) {
296 if (!err)
297 err = -EEXIST;
298 goto out;
299 }
300
301 err = hfs_brec_insert(&dst_fd, &entry, src_fd.entrylength);
302 if (err)
303 goto out;
304 dst_dir->i_size++;
305 dst_dir->i_mtime = dst_dir->i_ctime = CURRENT_TIME_SEC;
306 mark_inode_dirty(dst_dir);
307
308
309 hfs_cat_build_key(sb, src_fd.search_key, src_dir->i_ino, src_name);
310 err = hfs_brec_find(&src_fd);
311 if (err)
312 goto out;
313 err = hfs_brec_remove(&src_fd);
314 if (err)
315 goto out;
316 src_dir->i_size--;
317 src_dir->i_mtime = src_dir->i_ctime = CURRENT_TIME_SEC;
318 mark_inode_dirty(src_dir);
319
320 type = entry.type;
321 if (type == HFS_CDR_FIL && !(entry.file.Flags & HFS_FIL_THD))
322 goto out;
323
324
325 hfs_cat_build_key(sb, src_fd.search_key, cnid, NULL);
326 err = hfs_brec_find(&src_fd);
327 if (err)
328 goto out;
329 err = hfs_brec_remove(&src_fd);
330 if (err)
331 goto out;
332
333
334 hfs_cat_build_key(sb, dst_fd.search_key, cnid, NULL);
335 entry_size = hfs_cat_build_thread(sb, &entry, type == HFS_CDR_FIL ? HFS_CDR_FTH : HFS_CDR_THD,
336 dst_dir->i_ino, dst_name);
337 err = hfs_brec_find(&dst_fd);
338 if (err != -ENOENT) {
339 if (!err)
340 err = -EEXIST;
341 goto out;
342 }
343 err = hfs_brec_insert(&dst_fd, &entry, entry_size);
344out:
345 hfs_bnode_put(dst_fd.bnode);
346 hfs_find_exit(&src_fd);
347 return err;
348}
349