Root/fs/hfs/catalog.c

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 */
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        /* 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
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 * create_entry()
78 *
79 * Add a new file or directory to the catalog B-tree and
80 * return a (struct hfs_cat_entry) for it in '*result'.
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        /* panic? */
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 * hfs_cat_compare()
141 *
142 * Description:
143 * This is the comparison function used for the catalog B-tree. In
144 * comparing catalog B-tree entries, the parent id is the most
145 * significant field (compared as unsigned ints). The name field is
146 * the least significant (compared in "Macintosh lexical order",
147 * see hfs_strcmp() in string.c)
148 * Input Variable(s):
149 * struct hfs_cat_key *key1: pointer to the first key to compare
150 * struct hfs_cat_key *key2: pointer to the second key to compare
151 * Output Variable(s):
152 * NONE
153 * Returns:
154 * int: negative if key1<key2, positive if key1>key2, and 0 if key1==key2
155 * Preconditions:
156 * key1 and key2 point to "valid" (struct hfs_cat_key)s.
157 * Postconditions:
158 * This function has no side-effects
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/* Try to get a catalog entry for given catalog id */
173// move to read_super???
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    if (len > HFS_NAMELEN) {
194        printk(KERN_ERR "hfs: bad catalog namelength\n");
195        return -EIO;
196    }
197    memcpy(fd->search_key->cat.CName.name, rec.thread.CName.name, len);
198    return hfs_brec_find(fd);
199}
200
201
202/*
203 * hfs_cat_delete()
204 *
205 * Delete the indicated file or directory.
206 * The associated thread is also removed unless ('with_thread'==0).
207 */
208int hfs_cat_delete(u32 cnid, struct inode *dir, struct qstr *str)
209{
210    struct super_block *sb;
211    struct hfs_find_data fd;
212    struct list_head *pos;
213    int res, type;
214
215    dprint(DBG_CAT_MOD, "delete_cat: %s,%u\n", str ? str->name : NULL, cnid);
216    sb = dir->i_sb;
217    hfs_find_init(HFS_SB(sb)->cat_tree, &fd);
218
219    hfs_cat_build_key(sb, fd.search_key, dir->i_ino, str);
220    res = hfs_brec_find(&fd);
221    if (res)
222        goto out;
223
224    type = hfs_bnode_read_u8(fd.bnode, fd.entryoffset);
225    if (type == HFS_CDR_FIL) {
226        struct hfs_cat_file file;
227        hfs_bnode_read(fd.bnode, &file, fd.entryoffset, sizeof(file));
228        if (be32_to_cpu(file.FlNum) == cnid) {
229#if 0
230            hfs_free_fork(sb, &file, HFS_FK_DATA);
231#endif
232            hfs_free_fork(sb, &file, HFS_FK_RSRC);
233        }
234    }
235
236    list_for_each(pos, &HFS_I(dir)->open_dir_list) {
237        struct hfs_readdir_data *rd =
238            list_entry(pos, struct hfs_readdir_data, list);
239        if (fd.tree->keycmp(fd.search_key, (void *)&rd->key) < 0)
240            rd->file->f_pos--;
241    }
242
243    res = hfs_brec_remove(&fd);
244    if (res)
245        goto out;
246
247    hfs_cat_build_key(sb, fd.search_key, cnid, NULL);
248    res = hfs_brec_find(&fd);
249    if (!res) {
250        res = hfs_brec_remove(&fd);
251        if (res)
252            goto out;
253    }
254
255    dir->i_size--;
256    dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC;
257    mark_inode_dirty(dir);
258    res = 0;
259out:
260    hfs_find_exit(&fd);
261
262    return res;
263}
264
265/*
266 * hfs_cat_move()
267 *
268 * Rename a file or directory, possibly to a new directory.
269 * If the destination exists it is removed and a
270 * (struct hfs_cat_entry) for it is returned in '*result'.
271 */
272int hfs_cat_move(u32 cnid, struct inode *src_dir, struct qstr *src_name,
273         struct inode *dst_dir, struct qstr *dst_name)
274{
275    struct super_block *sb;
276    struct hfs_find_data src_fd, dst_fd;
277    union hfs_cat_rec entry;
278    int entry_size, type;
279    int err;
280
281    dprint(DBG_CAT_MOD, "rename_cat: %u - %lu,%s - %lu,%s\n", cnid, src_dir->i_ino, src_name->name,
282        dst_dir->i_ino, dst_name->name);
283    sb = src_dir->i_sb;
284    hfs_find_init(HFS_SB(sb)->cat_tree, &src_fd);
285    dst_fd = src_fd;
286
287    /* find the old dir entry and read the data */
288    hfs_cat_build_key(sb, src_fd.search_key, src_dir->i_ino, src_name);
289    err = hfs_brec_find(&src_fd);
290    if (err)
291        goto out;
292    if (src_fd.entrylength > sizeof(entry) || src_fd.entrylength < 0) {
293        err = -EIO;
294        goto out;
295    }
296
297    hfs_bnode_read(src_fd.bnode, &entry, src_fd.entryoffset,
298                src_fd.entrylength);
299
300    /* create new dir entry with the data from the old entry */
301    hfs_cat_build_key(sb, dst_fd.search_key, dst_dir->i_ino, dst_name);
302    err = hfs_brec_find(&dst_fd);
303    if (err != -ENOENT) {
304        if (!err)
305            err = -EEXIST;
306        goto out;
307    }
308
309    err = hfs_brec_insert(&dst_fd, &entry, src_fd.entrylength);
310    if (err)
311        goto out;
312    dst_dir->i_size++;
313    dst_dir->i_mtime = dst_dir->i_ctime = CURRENT_TIME_SEC;
314    mark_inode_dirty(dst_dir);
315
316    /* finally remove the old entry */
317    hfs_cat_build_key(sb, src_fd.search_key, src_dir->i_ino, src_name);
318    err = hfs_brec_find(&src_fd);
319    if (err)
320        goto out;
321    err = hfs_brec_remove(&src_fd);
322    if (err)
323        goto out;
324    src_dir->i_size--;
325    src_dir->i_mtime = src_dir->i_ctime = CURRENT_TIME_SEC;
326    mark_inode_dirty(src_dir);
327
328    type = entry.type;
329    if (type == HFS_CDR_FIL && !(entry.file.Flags & HFS_FIL_THD))
330        goto out;
331
332    /* remove old thread entry */
333    hfs_cat_build_key(sb, src_fd.search_key, cnid, NULL);
334    err = hfs_brec_find(&src_fd);
335    if (err)
336        goto out;
337    err = hfs_brec_remove(&src_fd);
338    if (err)
339        goto out;
340
341    /* create new thread entry */
342    hfs_cat_build_key(sb, dst_fd.search_key, cnid, NULL);
343    entry_size = hfs_cat_build_thread(sb, &entry, type == HFS_CDR_FIL ? HFS_CDR_FTH : HFS_CDR_THD,
344                    dst_dir->i_ino, dst_name);
345    err = hfs_brec_find(&dst_fd);
346    if (err != -ENOENT) {
347        if (!err)
348            err = -EEXIST;
349        goto out;
350    }
351    err = hfs_brec_insert(&dst_fd, &entry, entry_size);
352out:
353    hfs_bnode_put(dst_fd.bnode);
354    hfs_find_exit(&src_fd);
355    return err;
356}
357

Archive Download this file



interactive