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 hfs_free_fork(sb, &file, HFS_FK_RSRC); 230 } 231 } 232 233 list_for_each(pos, &HFS_I(dir)->open_dir_list) { 234 struct hfs_readdir_data *rd = 235 list_entry(pos, struct hfs_readdir_data, list); 236 if (fd.tree->keycmp(fd.search_key, (void *)&rd->key) < 0) 237 rd->file->f_pos--; 238 } 239 240 res = hfs_brec_remove(&fd); 241 if (res) 242 goto out; 243 244 hfs_cat_build_key(sb, fd.search_key, cnid, NULL); 245 res = hfs_brec_find(&fd); 246 if (!res) { 247 res = hfs_brec_remove(&fd); 248 if (res) 249 goto out; 250 } 251 252 dir->i_size--; 253 dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC; 254 mark_inode_dirty(dir); 255 res = 0; 256out: 257 hfs_find_exit(&fd); 258 259 return res; 260} 261 262/* 263 * hfs_cat_move() 264 * 265 * Rename a file or directory, possibly to a new directory. 266 * If the destination exists it is removed and a 267 * (struct hfs_cat_entry) for it is returned in '*result'. 268 */ 269int hfs_cat_move(u32 cnid, struct inode *src_dir, struct qstr *src_name, 270 struct inode *dst_dir, struct qstr *dst_name) 271{ 272 struct super_block *sb; 273 struct hfs_find_data src_fd, dst_fd; 274 union hfs_cat_rec entry; 275 int entry_size, type; 276 int err; 277 278 dprint(DBG_CAT_MOD, "rename_cat: %u - %lu,%s - %lu,%s\n", cnid, src_dir->i_ino, src_name->name, 279 dst_dir->i_ino, dst_name->name); 280 sb = src_dir->i_sb; 281 hfs_find_init(HFS_SB(sb)->cat_tree, &src_fd); 282 dst_fd = src_fd; 283 284 /* find the old dir entry and read the data */ 285 hfs_cat_build_key(sb, src_fd.search_key, src_dir->i_ino, src_name); 286 err = hfs_brec_find(&src_fd); 287 if (err) 288 goto out; 289 if (src_fd.entrylength > sizeof(entry) || src_fd.entrylength < 0) { 290 err = -EIO; 291 goto out; 292 } 293 294 hfs_bnode_read(src_fd.bnode, &entry, src_fd.entryoffset, 295 src_fd.entrylength); 296 297 /* create new dir entry with the data from the old entry */ 298 hfs_cat_build_key(sb, dst_fd.search_key, dst_dir->i_ino, dst_name); 299 err = hfs_brec_find(&dst_fd); 300 if (err != -ENOENT) { 301 if (!err) 302 err = -EEXIST; 303 goto out; 304 } 305 306 err = hfs_brec_insert(&dst_fd, &entry, src_fd.entrylength); 307 if (err) 308 goto out; 309 dst_dir->i_size++; 310 dst_dir->i_mtime = dst_dir->i_ctime = CURRENT_TIME_SEC; 311 mark_inode_dirty(dst_dir); 312 313 /* finally remove the old entry */ 314 hfs_cat_build_key(sb, src_fd.search_key, src_dir->i_ino, src_name); 315 err = hfs_brec_find(&src_fd); 316 if (err) 317 goto out; 318 err = hfs_brec_remove(&src_fd); 319 if (err) 320 goto out; 321 src_dir->i_size--; 322 src_dir->i_mtime = src_dir->i_ctime = CURRENT_TIME_SEC; 323 mark_inode_dirty(src_dir); 324 325 type = entry.type; 326 if (type == HFS_CDR_FIL && !(entry.file.Flags & HFS_FIL_THD)) 327 goto out; 328 329 /* remove old thread entry */ 330 hfs_cat_build_key(sb, src_fd.search_key, cnid, NULL); 331 err = hfs_brec_find(&src_fd); 332 if (err) 333 goto out; 334 err = hfs_brec_remove(&src_fd); 335 if (err) 336 goto out; 337 338 /* create new thread entry */ 339 hfs_cat_build_key(sb, dst_fd.search_key, cnid, NULL); 340 entry_size = hfs_cat_build_thread(sb, &entry, type == HFS_CDR_FIL ? HFS_CDR_FTH : HFS_CDR_THD, 341 dst_dir->i_ino, dst_name); 342 err = hfs_brec_find(&dst_fd); 343 if (err != -ENOENT) { 344 if (!err) 345 err = -EEXIST; 346 goto out; 347 } 348 err = hfs_brec_insert(&dst_fd, &entry, entry_size); 349out: 350 hfs_bnode_put(dst_fd.bnode); 351 hfs_find_exit(&src_fd); 352 return err; 353} 354