1 /* 2 * linux/fs/hfsplus/dir.c 3 * 4 * Copyright (C) 2001 5 * Brad Boyer (flar@allandria.com) 6 * (C) 2003 Ardis Technologies <roman@ardistech.com> 7 * 8 * Handling of directories 9 */ 10 11 #include <linux/errno.h> 12 #include <linux/fs.h> 13 #include <linux/slab.h> 14 #include <linux/random.h> 15 16 #include "hfsplus_fs.h" 17 #include "hfsplus_raw.h" 18 19 static inline void hfsplus_instantiate(struct dentry *dentry, 20 struct inode *inode, u32 cnid) 21 { 22 dentry->d_fsdata = (void *)(unsigned long)cnid; 23 d_instantiate(dentry, inode); 24 } 25 26 /* Find the entry inside dir named dentry->d_name */ 27 static struct dentry *hfsplus_lookup(struct inode *dir, struct dentry *dentry, 28 struct nameidata *nd) 29 { 30 struct inode *inode = NULL; 31 struct hfs_find_data fd; 32 struct super_block *sb; 33 hfsplus_cat_entry entry; 34 int err; 35 u32 cnid, linkid = 0; 36 u16 type; 37 38 sb = dir->i_sb; 39 40 dentry->d_op = &hfsplus_dentry_operations; 41 dentry->d_fsdata = NULL; 42 hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &fd); 43 hfsplus_cat_build_key(sb, fd.search_key, dir->i_ino, &dentry->d_name); 44 again: 45 err = hfs_brec_read(&fd, &entry, sizeof(entry)); 46 if (err) { 47 if (err == -ENOENT) { 48 hfs_find_exit(&fd); 49 /* No such entry */ 50 inode = NULL; 51 goto out; 52 } 53 goto fail; 54 } 55 type = be16_to_cpu(entry.type); 56 if (type == HFSPLUS_FOLDER) { 57 if (fd.entrylength < sizeof(struct hfsplus_cat_folder)) { 58 err = -EIO; 59 goto fail; 60 } 61 cnid = be32_to_cpu(entry.folder.id); 62 dentry->d_fsdata = (void *)(unsigned long)cnid; 63 } else if (type == HFSPLUS_FILE) { 64 if (fd.entrylength < sizeof(struct hfsplus_cat_file)) { 65 err = -EIO; 66 goto fail; 67 } 68 cnid = be32_to_cpu(entry.file.id); 69 if (entry.file.user_info.fdType == cpu_to_be32(HFSP_HARDLINK_TYPE) && 70 entry.file.user_info.fdCreator == cpu_to_be32(HFSP_HFSPLUS_CREATOR) && 71 (entry.file.create_date == HFSPLUS_I(HFSPLUS_SB(sb)->hidden_dir)->create_date || 72 entry.file.create_date == HFSPLUS_I(sb->s_root->d_inode)->create_date) && 73 HFSPLUS_SB(sb)->hidden_dir) { 74 struct qstr str; 75 char name[32]; 76 77 if (dentry->d_fsdata) { 78 /* 79 * We found a link pointing to another link, 80 * so ignore it and treat it as regular file. 81 */ 82 cnid = (unsigned long)dentry->d_fsdata; 83 linkid = 0; 84 } else { 85 dentry->d_fsdata = (void *)(unsigned long)cnid; 86 linkid = be32_to_cpu(entry.file.permissions.dev); 87 str.len = sprintf(name, "iNode%d", linkid); 88 str.name = name; 89 hfsplus_cat_build_key(sb, fd.search_key, 90 HFSPLUS_SB(sb)->hidden_dir->i_ino, &str); 91 goto again; 92 } 93 } else if (!dentry->d_fsdata) 94 dentry->d_fsdata = (void *)(unsigned long)cnid; 95 } else { 96 printk(KERN_ERR "hfs: invalid catalog entry type in lookup\n"); 97 err = -EIO; 98 goto fail; 99 } 100 hfs_find_exit(&fd); 101 inode = hfsplus_iget(dir->i_sb, cnid); 102 if (IS_ERR(inode)) 103 return ERR_CAST(inode); 104 if (S_ISREG(inode->i_mode)) 105 HFSPLUS_I(inode)->linkid = linkid; 106 out: 107 d_add(dentry, inode); 108 return NULL; 109 fail: 110 hfs_find_exit(&fd); 111 return ERR_PTR(err); 112 } 113 114 static int hfsplus_readdir(struct file *filp, void *dirent, filldir_t filldir) 115 { 116 struct inode *inode = filp->f_path.dentry->d_inode; 117 struct super_block *sb = inode->i_sb; 118 int len, err; 119 char strbuf[HFSPLUS_MAX_STRLEN + 1]; 120 hfsplus_cat_entry entry; 121 struct hfs_find_data fd; 122 struct hfsplus_readdir_data *rd; 123 u16 type; 124 125 if (filp->f_pos >= inode->i_size) 126 return 0; 127 128 hfs_find_init(HFSPLUS_SB(sb)->cat_tree, &fd); 129 hfsplus_cat_build_key(sb, fd.search_key, inode->i_ino, NULL); 130 err = hfs_brec_find(&fd); 131 if (err) 132 goto out; 133 134 switch ((u32)filp->f_pos) { 135 case 0: 136 /* This is completely artificial... */ 137 if (filldir(dirent, ".", 1, 0, inode->i_ino, DT_DIR)) 138 goto out; 139 filp->f_pos++; 140 /* fall through */ 141 case 1: 142 hfs_bnode_read(fd.bnode, &entry, fd.entryoffset, fd.entrylength); 143 if (be16_to_cpu(entry.type) != HFSPLUS_FOLDER_THREAD) { 144 printk(KERN_ERR "hfs: bad catalog folder thread\n"); 145 err = -EIO; 146 goto out; 147 } 148 if (fd.entrylength < HFSPLUS_MIN_THREAD_SZ) { 149 printk(KERN_ERR "hfs: truncated catalog thread\n"); 150 err = -EIO; 151 goto out; 152 } 153 if (filldir(dirent, "..", 2, 1, 154 be32_to_cpu(entry.thread.parentID), DT_DIR)) 155 goto out; 156 filp->f_pos++; 157 /* fall through */ 158 default: 159 if (filp->f_pos >= inode->i_size) 160 goto out; 161 err = hfs_brec_goto(&fd, filp->f_pos - 1); 162 if (err) 163 goto out; 164 } 165 166 for (;;) { 167 if (be32_to_cpu(fd.key->cat.parent) != inode->i_ino) { 168 printk(KERN_ERR "hfs: walked past end of dir\n"); 169 err = -EIO; 170 goto out; 171 } 172 hfs_bnode_read(fd.bnode, &entry, fd.entryoffset, fd.entrylength); 173 type = be16_to_cpu(entry.type); 174 len = HFSPLUS_MAX_STRLEN; 175 err = hfsplus_uni2asc(sb, &fd.key->cat.name, strbuf, &len); 176 if (err) 177 goto out; 178 if (type == HFSPLUS_FOLDER) { 179 if (fd.entrylength < sizeof(struct hfsplus_cat_folder)) { 180 printk(KERN_ERR "hfs: small dir entry\n"); 181 err = -EIO; 182 goto out; 183 } 184 if (HFSPLUS_SB(sb)->hidden_dir && 185 HFSPLUS_SB(sb)->hidden_dir->i_ino == 186 be32_to_cpu(entry.folder.id)) 187 goto next; 188 if (filldir(dirent, strbuf, len, filp->f_pos, 189 be32_to_cpu(entry.folder.id), DT_DIR)) 190 break; 191 } else if (type == HFSPLUS_FILE) { 192 if (fd.entrylength < sizeof(struct hfsplus_cat_file)) { 193 printk(KERN_ERR "hfs: small file entry\n"); 194 err = -EIO; 195 goto out; 196 } 197 if (filldir(dirent, strbuf, len, filp->f_pos, 198 be32_to_cpu(entry.file.id), DT_REG)) 199 break; 200 } else { 201 printk(KERN_ERR "hfs: bad catalog entry type\n"); 202 err = -EIO; 203 goto out; 204 } 205 next: 206 filp->f_pos++; 207 if (filp->f_pos >= inode->i_size) 208 goto out; 209 err = hfs_brec_goto(&fd, 1); 210 if (err) 211 goto out; 212 } 213 rd = filp->private_data; 214 if (!rd) { 215 rd = kmalloc(sizeof(struct hfsplus_readdir_data), GFP_KERNEL); 216 if (!rd) { 217 err = -ENOMEM; 218 goto out; 219 } 220 filp->private_data = rd; 221 rd->file = filp; 222 list_add(&rd->list, &HFSPLUS_I(inode)->open_dir_list); 223 } 224 memcpy(&rd->key, fd.key, sizeof(struct hfsplus_cat_key)); 225 out: 226 hfs_find_exit(&fd); 227 return err; 228 } 229 230 static int hfsplus_dir_release(struct inode *inode, struct file *file) 231 { 232 struct hfsplus_readdir_data *rd = file->private_data; 233 if (rd) { 234 mutex_lock(&inode->i_mutex); 235 list_del(&rd->list); 236 mutex_unlock(&inode->i_mutex); 237 kfree(rd); 238 } 239 return 0; 240 } 241 242 static int hfsplus_link(struct dentry *src_dentry, struct inode *dst_dir, 243 struct dentry *dst_dentry) 244 { 245 struct hfsplus_sb_info *sbi = HFSPLUS_SB(dst_dir->i_sb); 246 struct inode *inode = src_dentry->d_inode; 247 struct inode *src_dir = src_dentry->d_parent->d_inode; 248 struct qstr str; 249 char name[32]; 250 u32 cnid, id; 251 int res; 252 253 if (HFSPLUS_IS_RSRC(inode)) 254 return -EPERM; 255 if (!S_ISREG(inode->i_mode)) 256 return -EPERM; 257 258 mutex_lock(&sbi->vh_mutex); 259 if (inode->i_ino == (u32)(unsigned long)src_dentry->d_fsdata) { 260 for (;;) { 261 get_random_bytes(&id, sizeof(cnid)); 262 id &= 0x3fffffff; 263 str.name = name; 264 str.len = sprintf(name, "iNode%d", id); 265 res = hfsplus_rename_cat(inode->i_ino, 266 src_dir, &src_dentry->d_name, 267 sbi->hidden_dir, &str); 268 if (!res) 269 break; 270 if (res != -EEXIST) 271 goto out; 272 } 273 HFSPLUS_I(inode)->linkid = id; 274 cnid = sbi->next_cnid++; 275 src_dentry->d_fsdata = (void *)(unsigned long)cnid; 276 res = hfsplus_create_cat(cnid, src_dir, &src_dentry->d_name, inode); 277 if (res) 278 /* panic? */ 279 goto out; 280 sbi->file_count++; 281 } 282 cnid = sbi->next_cnid++; 283 res = hfsplus_create_cat(cnid, dst_dir, &dst_dentry->d_name, inode); 284 if (res) 285 goto out; 286 287 inc_nlink(inode); 288 hfsplus_instantiate(dst_dentry, inode, cnid); 289 atomic_inc(&inode->i_count); 290 inode->i_ctime = CURRENT_TIME_SEC; 291 mark_inode_dirty(inode); 292 sbi->file_count++; 293 dst_dir->i_sb->s_dirt = 1; 294 out: 295 mutex_unlock(&sbi->vh_mutex); 296 return res; 297 } 298 299 static int hfsplus_unlink(struct inode *dir, struct dentry *dentry) 300 { 301 struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb); 302 struct inode *inode = dentry->d_inode; 303 struct qstr str; 304 char name[32]; 305 u32 cnid; 306 int res; 307 308 if (HFSPLUS_IS_RSRC(inode)) 309 return -EPERM; 310 311 mutex_lock(&sbi->vh_mutex); 312 cnid = (u32)(unsigned long)dentry->d_fsdata; 313 if (inode->i_ino == cnid && 314 atomic_read(&HFSPLUS_I(inode)->opencnt)) { 315 str.name = name; 316 str.len = sprintf(name, "temp%lu", inode->i_ino); 317 res = hfsplus_rename_cat(inode->i_ino, 318 dir, &dentry->d_name, 319 sbi->hidden_dir, &str); 320 if (!res) 321 inode->i_flags |= S_DEAD; 322 goto out; 323 } 324 res = hfsplus_delete_cat(cnid, dir, &dentry->d_name); 325 if (res) 326 goto out; 327 328 if (inode->i_nlink > 0) 329 drop_nlink(inode); 330 if (inode->i_ino == cnid) 331 clear_nlink(inode); 332 if (!inode->i_nlink) { 333 if (inode->i_ino != cnid) { 334 sbi->file_count--; 335 if (!atomic_read(&HFSPLUS_I(inode)->opencnt)) { 336 res = hfsplus_delete_cat(inode->i_ino, 337 sbi->hidden_dir, 338 NULL); 339 if (!res) 340 hfsplus_delete_inode(inode); 341 } else 342 inode->i_flags |= S_DEAD; 343 } else 344 hfsplus_delete_inode(inode); 345 } else 346 sbi->file_count--; 347 inode->i_ctime = CURRENT_TIME_SEC; 348 mark_inode_dirty(inode); 349 out: 350 mutex_unlock(&sbi->vh_mutex); 351 return res; 352 } 353 354 static int hfsplus_rmdir(struct inode *dir, struct dentry *dentry) 355 { 356 struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb); 357 struct inode *inode = dentry->d_inode; 358 int res; 359 360 if (inode->i_size != 2) 361 return -ENOTEMPTY; 362 363 mutex_lock(&sbi->vh_mutex); 364 res = hfsplus_delete_cat(inode->i_ino, dir, &dentry->d_name); 365 if (res) 366 goto out; 367 clear_nlink(inode); 368 inode->i_ctime = CURRENT_TIME_SEC; 369 hfsplus_delete_inode(inode); 370 mark_inode_dirty(inode); 371 out: 372 mutex_unlock(&sbi->vh_mutex); 373 return res; 374 } 375 376 static int hfsplus_symlink(struct inode *dir, struct dentry *dentry, 377 const char *symname) 378 { 379 struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb); 380 struct inode *inode; 381 int res = -ENOSPC; 382 383 mutex_lock(&sbi->vh_mutex); 384 inode = hfsplus_new_inode(dir->i_sb, S_IFLNK | S_IRWXUGO); 385 if (!inode) 386 goto out; 387 388 res = page_symlink(inode, symname, strlen(symname) + 1); 389 if (res) 390 goto out_err; 391 392 res = hfsplus_create_cat(inode->i_ino, dir, &dentry->d_name, inode); 393 if (res) 394 goto out_err; 395 396 hfsplus_instantiate(dentry, inode, inode->i_ino); 397 mark_inode_dirty(inode); 398 goto out; 399 400 out_err: 401 inode->i_nlink = 0; 402 hfsplus_delete_inode(inode); 403 iput(inode); 404 out: 405 mutex_unlock(&sbi->vh_mutex); 406 return res; 407 } 408 409 static int hfsplus_mknod(struct inode *dir, struct dentry *dentry, 410 int mode, dev_t rdev) 411 { 412 struct hfsplus_sb_info *sbi = HFSPLUS_SB(dir->i_sb); 413 struct inode *inode; 414 int res = -ENOSPC; 415 416 mutex_lock(&sbi->vh_mutex); 417 inode = hfsplus_new_inode(dir->i_sb, mode); 418 if (!inode) 419 goto out; 420 421 res = hfsplus_create_cat(inode->i_ino, dir, &dentry->d_name, inode); 422 if (res) { 423 inode->i_nlink = 0; 424 hfsplus_delete_inode(inode); 425 iput(inode); 426 goto out; 427 } 428 429 if (S_ISBLK(mode) || S_ISCHR(mode) || S_ISFIFO(mode) || S_ISSOCK(mode)) 430 init_special_inode(inode, mode, rdev); 431 432 hfsplus_instantiate(dentry, inode, inode->i_ino); 433 mark_inode_dirty(inode); 434 out: 435 mutex_unlock(&sbi->vh_mutex); 436 return res; 437 } 438 439 static int hfsplus_create(struct inode *dir, struct dentry *dentry, int mode, 440 struct nameidata *nd) 441 { 442 return hfsplus_mknod(dir, dentry, mode, 0); 443 } 444 445 static int hfsplus_mkdir(struct inode *dir, struct dentry *dentry, int mode) 446 { 447 return hfsplus_mknod(dir, dentry, mode | S_IFDIR, 0); 448 } 449 450 static int hfsplus_rename(struct inode *old_dir, struct dentry *old_dentry, 451 struct inode *new_dir, struct dentry *new_dentry) 452 { 453 int res; 454 455 /* Unlink destination if it already exists */ 456 if (new_dentry->d_inode) { 457 if (S_ISDIR(new_dentry->d_inode->i_mode)) 458 res = hfsplus_rmdir(new_dir, new_dentry); 459 else 460 res = hfsplus_unlink(new_dir, new_dentry); 461 if (res) 462 return res; 463 } 464 465 res = hfsplus_rename_cat((u32)(unsigned long)old_dentry->d_fsdata, 466 old_dir, &old_dentry->d_name, 467 new_dir, &new_dentry->d_name); 468 if (!res) 469 new_dentry->d_fsdata = old_dentry->d_fsdata; 470 return res; 471 } 472 473 const struct inode_operations hfsplus_dir_inode_operations = { 474 .lookup = hfsplus_lookup, 475 .create = hfsplus_create, 476 .link = hfsplus_link, 477 .unlink = hfsplus_unlink, 478 .mkdir = hfsplus_mkdir, 479 .rmdir = hfsplus_rmdir, 480 .symlink = hfsplus_symlink, 481 .mknod = hfsplus_mknod, 482 .rename = hfsplus_rename, 483 }; 484 485 const struct file_operations hfsplus_dir_operations = { 486 .read = generic_read_dir, 487 .readdir = hfsplus_readdir, 488 .unlocked_ioctl = hfsplus_ioctl, 489 .llseek = generic_file_llseek, 490 .release = hfsplus_dir_release, 491 }; 492