Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * linux/fs/hfs/catalog.c | |
3 | * | |
4 | * Copyright (C) 1995-1997 Paul H. Hargrove | |
5 | * (C) 2003 Ardis Technologies <roman@ardistech.com> | |
6 | * This file may be distributed under the terms of the GNU General Public License. | |
7 | * | |
8 | * This file contains the functions related to the catalog B-tree. | |
9 | * | |
10 | * Cache code shamelessly stolen from | |
11 | * linux/fs/inode.c Copyright (C) 1991, 1992 Linus Torvalds | |
12 | * re-shamelessly stolen Copyright (C) 1997 Linus Torvalds | |
13 | */ | |
14 | ||
15 | #include "hfs_fs.h" | |
16 | #include "btree.h" | |
17 | ||
18 | /* | |
19 | * hfs_cat_build_key() | |
20 | * | |
21 | * Given the ID of the parent and the name build a search key. | |
22 | */ | |
23 | void hfs_cat_build_key(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_triv2mac(&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 | ||
36 | static 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 | /* init some fields for the file record */ | |
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 | ||
65 | static int hfs_cat_build_thread(hfs_cat_rec *rec, int type, | |
66 | u32 parentid, struct qstr *name) | |
67 | { | |
68 | rec->type = type; | |
69 | memset(rec->thread.reserved, 0, sizeof(rec->thread.reserved)); | |
70 | rec->thread.ParID = cpu_to_be32(parentid); | |
71 | hfs_triv2mac(&rec->thread.CName, name); | |
72 | return sizeof(struct hfs_cat_thread); | |
73 | } | |
74 | ||
75 | /* | |
76 | * create_entry() | |
77 | * | |
78 | * Add a new file or directory to the catalog B-tree and | |
79 | * return a (struct hfs_cat_entry) for it in '*result'. | |
80 | */ | |
81 | int hfs_cat_create(u32 cnid, struct inode *dir, struct qstr *str, struct inode *inode) | |
82 | { | |
83 | struct hfs_find_data fd; | |
84 | struct super_block *sb; | |
85 | union hfs_cat_rec entry; | |
86 | int entry_size; | |
87 | int err; | |
88 | ||
89 | dprint(DBG_CAT_MOD, "create_cat: %s,%u(%d)\n", str->name, cnid, inode->i_nlink); | |
90 | if (dir->i_size >= HFS_MAX_VALENCE) | |
91 | return -ENOSPC; | |
92 | ||
93 | sb = dir->i_sb; | |
94 | hfs_find_init(HFS_SB(sb)->cat_tree, &fd); | |
95 | ||
96 | hfs_cat_build_key(fd.search_key, cnid, NULL); | |
97 | entry_size = hfs_cat_build_thread(&entry, S_ISDIR(inode->i_mode) ? | |
98 | HFS_CDR_THD : HFS_CDR_FTH, | |
99 | dir->i_ino, str); | |
100 | err = hfs_brec_find(&fd); | |
101 | if (err != -ENOENT) { | |
102 | if (!err) | |
103 | err = -EEXIST; | |
104 | goto err2; | |
105 | } | |
106 | err = hfs_brec_insert(&fd, &entry, entry_size); | |
107 | if (err) | |
108 | goto err2; | |
109 | ||
110 | hfs_cat_build_key(fd.search_key, dir->i_ino, str); | |
111 | entry_size = hfs_cat_build_record(&entry, cnid, inode); | |
112 | err = hfs_brec_find(&fd); | |
113 | if (err != -ENOENT) { | |
114 | /* panic? */ | |
115 | if (!err) | |
116 | err = -EEXIST; | |
117 | goto err1; | |
118 | } | |
119 | err = hfs_brec_insert(&fd, &entry, entry_size); | |
120 | if (err) | |
121 | goto err1; | |
122 | ||
123 | dir->i_size++; | |
124 | dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC; | |
125 | mark_inode_dirty(dir); | |
126 | hfs_find_exit(&fd); | |
127 | return 0; | |
128 | ||
129 | err1: | |
130 | hfs_cat_build_key(fd.search_key, cnid, NULL); | |
131 | if (!hfs_brec_find(&fd)) | |
132 | hfs_brec_remove(&fd); | |
133 | err2: | |
134 | hfs_find_exit(&fd); | |
135 | return err; | |
136 | } | |
137 | ||
138 | /* | |
139 | * hfs_cat_compare() | |
140 | * | |
141 | * Description: | |
142 | * This is the comparison function used for the catalog B-tree. In | |
143 | * comparing catalog B-tree entries, the parent id is the most | |
144 | * significant field (compared as unsigned ints). The name field is | |
145 | * the least significant (compared in "Macintosh lexical order", | |
146 | * see hfs_strcmp() in string.c) | |
147 | * Input Variable(s): | |
148 | * struct hfs_cat_key *key1: pointer to the first key to compare | |
149 | * struct hfs_cat_key *key2: pointer to the second key to compare | |
150 | * Output Variable(s): | |
151 | * NONE | |
152 | * Returns: | |
153 | * int: negative if key1<key2, positive if key1>key2, and 0 if key1==key2 | |
154 | * Preconditions: | |
155 | * key1 and key2 point to "valid" (struct hfs_cat_key)s. | |
156 | * Postconditions: | |
157 | * This function has no side-effects | |
158 | */ | |
159 | int hfs_cat_keycmp(const btree_key *key1, const btree_key *key2) | |
160 | { | |
161 | int retval; | |
162 | ||
163 | retval = be32_to_cpu(key1->cat.ParID) - be32_to_cpu(key2->cat.ParID); | |
164 | if (!retval) | |
165 | retval = hfs_strcmp(key1->cat.CName.name, key1->cat.CName.len, | |
166 | key2->cat.CName.name, key2->cat.CName.len); | |
167 | ||
168 | return retval; | |
169 | } | |
170 | ||
171 | /* Try to get a catalog entry for given catalog id */ | |
172 | // move to read_super??? | |
173 | int hfs_cat_find_brec(struct super_block *sb, u32 cnid, | |
174 | struct hfs_find_data *fd) | |
175 | { | |
176 | hfs_cat_rec rec; | |
177 | int res, len, type; | |
178 | ||
179 | hfs_cat_build_key(fd->search_key, cnid, NULL); | |
180 | res = hfs_brec_read(fd, &rec, sizeof(rec)); | |
181 | if (res) | |
182 | return res; | |
183 | ||
184 | type = rec.type; | |
185 | if (type != HFS_CDR_THD && type != HFS_CDR_FTH) { | |
186 | printk("HFS-fs: Found bad thread record in catalog\n"); | |
187 | return -EIO; | |
188 | } | |
189 | ||
190 | fd->search_key->cat.ParID = rec.thread.ParID; | |
191 | len = fd->search_key->cat.CName.len = rec.thread.CName.len; | |
192 | memcpy(fd->search_key->cat.CName.name, rec.thread.CName.name, len); | |
193 | return hfs_brec_find(fd); | |
194 | } | |
195 | ||
196 | ||
197 | /* | |
198 | * hfs_cat_delete() | |
199 | * | |
200 | * Delete the indicated file or directory. | |
201 | * The associated thread is also removed unless ('with_thread'==0). | |
202 | */ | |
203 | int hfs_cat_delete(u32 cnid, struct inode *dir, struct qstr *str) | |
204 | { | |
205 | struct super_block *sb; | |
206 | struct hfs_find_data fd; | |
207 | struct list_head *pos; | |
208 | int res, type; | |
209 | ||
210 | dprint(DBG_CAT_MOD, "delete_cat: %s,%u\n", str ? str->name : NULL, cnid); | |
211 | sb = dir->i_sb; | |
212 | hfs_find_init(HFS_SB(sb)->cat_tree, &fd); | |
213 | ||
214 | hfs_cat_build_key(fd.search_key, dir->i_ino, str); | |
215 | res = hfs_brec_find(&fd); | |
216 | if (res) | |
217 | goto out; | |
218 | ||
219 | type = hfs_bnode_read_u8(fd.bnode, fd.entryoffset); | |
220 | if (type == HFS_CDR_FIL) { | |
221 | struct hfs_cat_file file; | |
222 | hfs_bnode_read(fd.bnode, &file, fd.entryoffset, sizeof(file)); | |
223 | if (be32_to_cpu(file.FlNum) == cnid) { | |
224 | #if 0 | |
225 | hfs_free_fork(sb, &file, HFS_FK_DATA); | |
226 | #endif | |
227 | hfs_free_fork(sb, &file, HFS_FK_RSRC); | |
228 | } | |
229 | } | |
230 | ||
231 | list_for_each(pos, &HFS_I(dir)->open_dir_list) { | |
232 | struct hfs_readdir_data *rd = | |
233 | list_entry(pos, struct hfs_readdir_data, list); | |
234 | if (fd.tree->keycmp(fd.search_key, (void *)&rd->key) < 0) | |
235 | rd->file->f_pos--; | |
236 | } | |
237 | ||
238 | res = hfs_brec_remove(&fd); | |
239 | if (res) | |
240 | goto out; | |
241 | ||
242 | hfs_cat_build_key(fd.search_key, cnid, NULL); | |
243 | res = hfs_brec_find(&fd); | |
244 | if (!res) { | |
245 | res = hfs_brec_remove(&fd); | |
246 | if (res) | |
247 | goto out; | |
248 | } | |
249 | ||
250 | dir->i_size--; | |
251 | dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC; | |
252 | mark_inode_dirty(dir); | |
253 | res = 0; | |
254 | out: | |
255 | hfs_find_exit(&fd); | |
256 | ||
257 | return res; | |
258 | } | |
259 | ||
260 | /* | |
261 | * hfs_cat_move() | |
262 | * | |
263 | * Rename a file or directory, possibly to a new directory. | |
264 | * If the destination exists it is removed and a | |
265 | * (struct hfs_cat_entry) for it is returned in '*result'. | |
266 | */ | |
267 | int hfs_cat_move(u32 cnid, struct inode *src_dir, struct qstr *src_name, | |
268 | struct inode *dst_dir, struct qstr *dst_name) | |
269 | { | |
270 | struct super_block *sb; | |
271 | struct hfs_find_data src_fd, dst_fd; | |
272 | union hfs_cat_rec entry; | |
273 | int entry_size, type; | |
274 | int err; | |
275 | ||
276 | dprint(DBG_CAT_MOD, "rename_cat: %u - %lu,%s - %lu,%s\n", cnid, src_dir->i_ino, src_name->name, | |
277 | dst_dir->i_ino, dst_name->name); | |
278 | sb = src_dir->i_sb; | |
279 | hfs_find_init(HFS_SB(sb)->cat_tree, &src_fd); | |
280 | dst_fd = src_fd; | |
281 | ||
282 | /* find the old dir entry and read the data */ | |
283 | hfs_cat_build_key(src_fd.search_key, src_dir->i_ino, src_name); | |
284 | err = hfs_brec_find(&src_fd); | |
285 | if (err) | |
286 | goto out; | |
287 | ||
288 | hfs_bnode_read(src_fd.bnode, &entry, src_fd.entryoffset, | |
289 | src_fd.entrylength); | |
290 | ||
291 | /* create new dir entry with the data from the old entry */ | |
292 | hfs_cat_build_key(dst_fd.search_key, dst_dir->i_ino, dst_name); | |
293 | err = hfs_brec_find(&dst_fd); | |
294 | if (err != -ENOENT) { | |
295 | if (!err) | |
296 | err = -EEXIST; | |
297 | goto out; | |
298 | } | |
299 | ||
300 | err = hfs_brec_insert(&dst_fd, &entry, src_fd.entrylength); | |
301 | if (err) | |
302 | goto out; | |
303 | dst_dir->i_size++; | |
304 | dst_dir->i_mtime = dst_dir->i_ctime = CURRENT_TIME_SEC; | |
305 | mark_inode_dirty(dst_dir); | |
306 | ||
307 | /* finally remove the old entry */ | |
308 | hfs_cat_build_key(src_fd.search_key, src_dir->i_ino, src_name); | |
309 | err = hfs_brec_find(&src_fd); | |
310 | if (err) | |
311 | goto out; | |
312 | err = hfs_brec_remove(&src_fd); | |
313 | if (err) | |
314 | goto out; | |
315 | src_dir->i_size--; | |
316 | src_dir->i_mtime = src_dir->i_ctime = CURRENT_TIME_SEC; | |
317 | mark_inode_dirty(src_dir); | |
318 | ||
319 | type = entry.type; | |
320 | if (type == HFS_CDR_FIL && !(entry.file.Flags & HFS_FIL_THD)) | |
321 | goto out; | |
322 | ||
323 | /* remove old thread entry */ | |
324 | hfs_cat_build_key(src_fd.search_key, cnid, NULL); | |
325 | err = hfs_brec_find(&src_fd); | |
326 | if (err) | |
327 | goto out; | |
328 | err = hfs_brec_remove(&src_fd); | |
329 | if (err) | |
330 | goto out; | |
331 | ||
332 | /* create new thread entry */ | |
333 | hfs_cat_build_key(dst_fd.search_key, cnid, NULL); | |
334 | entry_size = hfs_cat_build_thread(&entry, type == HFS_CDR_FIL ? HFS_CDR_FTH : HFS_CDR_THD, | |
335 | dst_dir->i_ino, dst_name); | |
336 | err = hfs_brec_find(&dst_fd); | |
337 | if (err != -ENOENT) { | |
338 | if (!err) | |
339 | err = -EEXIST; | |
340 | goto out; | |
341 | } | |
342 | err = hfs_brec_insert(&dst_fd, &entry, entry_size); | |
343 | out: | |
344 | hfs_bnode_put(dst_fd.bnode); | |
345 | hfs_find_exit(&src_fd); | |
346 | return err; | |
347 | } |