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