4 * Copyright (C) 1995-1997 Paul H. Hargrove
5 * This file may be distributed under the terms of the GNU General Public License.
7 * This file contains directory-related functions independent of which
8 * scheme is being used to represent forks.
10 * Based on the minix file system code, (C) 1991, 1992 by Linus Torvalds
12 * "XXX" in a comment is a note to myself to consider changing something.
14 * In function preconditions the term "valid" applied to a pointer to
15 * a structure means that the pointer is non-NULL and the structure it
16 * points to has all fields initialized to consistent values.
20 #include <linux/hfs_fs_sb.h>
21 #include <linux/hfs_fs_i.h>
22 #include <linux/hfs_fs.h>
24 /*================ File-local functions ================*/
29 * Build a key for a file by the given name in the given directory.
30 * If the name matches one of the reserved names returns 1 otherwise 0.
32 static int build_key(struct hfs_cat_key *key, struct inode *dir,
33 const char *name, int len)
35 struct hfs_name cname;
36 const struct hfs_name *reserved;
39 hfs_nameout(dir, &cname, name, len);
41 /* check against reserved names */
42 reserved = HFS_SB(dir->i_sb)->s_reserved1;
43 while (reserved->Len) {
44 if (hfs_streq(reserved->Name, reserved->Len,
45 cname.Name, cname.Len)) {
51 /* check against the names reserved only in the root directory */
52 if (HFS_I(dir)->entry->cnid == htonl(HFS_ROOT_CNID)) {
53 reserved = HFS_SB(dir->i_sb)->s_reserved2;
54 while (reserved->Len) {
55 if (hfs_streq(reserved->Name, reserved->Len,
56 cname.Name, cname.Len)) {
64 hfs_cat_build_key(HFS_I(dir)->entry->cnid, &cname, key);
72 * Update the fields 'i_size', 'i_nlink', 'i_ctime', 'i_mtime' and
73 * 'i_version' of the inodes associated with a directory that has
74 * had a file ('is_dir'==0) or directory ('is_dir'!=0) added to it.
76 static inline void update_dirs_plus(struct hfs_cat_entry *dir, int is_dir)
80 for (i = 0; i < 4; ++i) {
81 struct dentry *de = dir->sys_entry[i];
83 struct inode *tmp = de->d_inode;
84 if (S_ISDIR(tmp->i_mode)) {
86 (i == HFS_ITYPE_TO_INT(HFS_ITYPE_NORM))) {
87 /* In "normal" directory only */
90 tmp->i_size += HFS_I(tmp)->dir_size;
91 tmp->i_version = ++event;
93 tmp->i_ctime = tmp->i_mtime = CURRENT_TIME;
94 mark_inode_dirty(tmp);
100 * update_dirs_minus()
102 * Update the fields 'i_size', 'i_nlink', 'i_ctime', 'i_mtime' and
103 * 'i_version' of the inodes associated with a directory that has
104 * had a file ('is_dir'==0) or directory ('is_dir'!=0) removed.
106 static inline void update_dirs_minus(struct hfs_cat_entry *dir, int is_dir)
110 for (i = 0; i < 4; ++i) {
111 struct dentry *de = dir->sys_entry[i];
113 struct inode *tmp = de->d_inode;
114 if (S_ISDIR(tmp->i_mode)) {
116 (i == HFS_ITYPE_TO_INT(HFS_ITYPE_NORM))) {
117 /* In "normal" directory only */
120 tmp->i_size -= HFS_I(tmp)->dir_size;
121 tmp->i_version = ++event;
123 tmp->i_ctime = tmp->i_mtime = CURRENT_TIME;
124 mark_inode_dirty(tmp);
130 * mark_inodes_deleted()
132 * Update inodes associated with a deleted entry to reflect its deletion.
133 * Well, we really just drop the dentry.
135 * XXX: we should be using delete_inode for some of this stuff.
137 static inline void mark_inodes_deleted(struct hfs_cat_entry *entry,
138 struct dentry *dentry)
144 for (i = 0; i < 4; ++i) {
145 if ((de = entry->sys_entry[i]) && (dentry != de)) {
149 tmp->i_ctime = CURRENT_TIME;
150 mark_inode_dirty(tmp);
157 /*================ Global functions ================*/
162 * This is the create() entry in the inode_operations structure for
163 * regular HFS directories. The purpose is to create a new file in
164 * a directory and return a corresponding inode, given the inode for
165 * the directory and the name (and its length) of the new file.
167 int hfs_create(struct inode * dir, struct dentry *dentry, int mode)
169 struct hfs_cat_entry *entry = HFS_I(dir)->entry;
170 struct hfs_cat_entry *new;
171 struct hfs_cat_key key;
175 /* build the key, checking against reserved names */
176 if (build_key(&key, dir, dentry->d_name.name, dentry->d_name.len))
179 if ((error = hfs_cat_create(entry, &key,
180 (mode & S_IWUSR) ? 0 : HFS_FIL_LOCK,
181 HFS_SB(dir->i_sb)->s_type,
182 HFS_SB(dir->i_sb)->s_creator, &new)))
185 /* create an inode for the new file. back out if we run
187 new->count++; /* hfs_iget() eats one */
188 if (!(inode = hfs_iget(new, HFS_I(dir)->file_type, dentry))) {
189 hfs_cat_delete(entry, new, 1);
195 update_dirs_plus(entry, 0);
196 /* toss any relevant negative dentries */
197 if (HFS_I(dir)->d_drop_op)
198 HFS_I(dir)->d_drop_op(dentry, HFS_I(dir)->file_type);
199 mark_inode_dirty(inode);
200 d_instantiate(dentry, inode);
207 * This is the mkdir() entry in the inode_operations structure for
208 * regular HFS directories. The purpose is to create a new directory
209 * in a directory, given the inode for the parent directory and the
210 * name (and its length) of the new directory.
212 int hfs_mkdir(struct inode * parent, struct dentry *dentry, int mode)
214 struct hfs_cat_entry *entry = HFS_I(parent)->entry;
215 struct hfs_cat_entry *new;
216 struct hfs_cat_key key;
220 /* build the key, checking against reserved names */
221 if (build_key(&key, parent, dentry->d_name.name,
225 /* try to create the directory */
226 if ((error = hfs_cat_mkdir(entry, &key, &new)))
229 /* back out if we run into trouble */
230 new->count++; /* hfs_iget eats one */
231 if (!(inode = hfs_iget(new, HFS_I(parent)->file_type, dentry))) {
232 hfs_cat_delete(entry, new, 1);
238 update_dirs_plus(entry, 1);
239 mark_inode_dirty(inode);
240 d_instantiate(dentry, inode);
247 * This is the unlink() entry in the inode_operations structure for
248 * regular HFS directories. The purpose is to delete an existing
249 * file, given the inode for the parent directory and the name
250 * (and its length) of the existing file.
252 int hfs_unlink(struct inode * dir, struct dentry *dentry)
254 struct hfs_cat_entry *entry = HFS_I(dir)->entry;
255 struct hfs_cat_entry *victim = NULL;
256 struct hfs_cat_key key;
259 if (build_key(&key, dir, dentry->d_name.name,
263 if (!(victim = hfs_cat_get(entry->mdb, &key)))
267 if (victim->type != HFS_CDR_FIL)
270 if (!(error = hfs_cat_delete(entry, victim, 1))) {
271 struct inode *inode = dentry->d_inode;
273 mark_inodes_deleted(victim, dentry);
275 inode->i_ctime = CURRENT_TIME;
276 mark_inode_dirty(inode);
277 update_dirs_minus(entry, 0);
281 hfs_cat_put(victim); /* Note that hfs_cat_put(NULL) is safe. */
288 * This is the rmdir() entry in the inode_operations structure for
289 * regular HFS directories. The purpose is to delete an existing
290 * directory, given the inode for the parent directory and the name
291 * (and its length) of the existing directory.
293 int hfs_rmdir(struct inode * parent, struct dentry *dentry)
295 struct hfs_cat_entry *entry = HFS_I(parent)->entry;
296 struct hfs_cat_entry *victim = NULL;
297 struct inode *inode = dentry->d_inode;
298 struct hfs_cat_key key;
301 if (build_key(&key, parent, dentry->d_name.name,
305 if (!(victim = hfs_cat_get(entry->mdb, &key)))
309 if (victim->type != HFS_CDR_DIR)
313 if (!d_unhashed(dentry))
316 /* we only have to worry about 2 and 3 for mount points */
317 if (victim->sys_entry[2] && d_mountpoint(victim->sys_entry[2]))
319 if (victim->sys_entry[3] && d_mountpoint(victim->sys_entry[3]))
323 if ((error = hfs_cat_delete(entry, victim, 1)))
326 mark_inodes_deleted(victim, dentry);
328 inode->i_ctime = CURRENT_TIME;
329 mark_inode_dirty(inode);
330 update_dirs_minus(entry, 1);
333 hfs_cat_put(victim); /* Note that hfs_cat_put(NULL) is safe. */
340 * This is the rename() entry in the inode_operations structure for
341 * regular HFS directories. The purpose is to rename an existing
342 * file or directory, given the inode for the current directory and
343 * the name (and its length) of the existing file/directory and the
344 * inode for the new directory and the name (and its length) of the
345 * new file/directory.
346 * XXX: how do you handle must_be dir?
348 int hfs_rename(struct inode *old_dir, struct dentry *old_dentry,
349 struct inode *new_dir, struct dentry *new_dentry)
351 struct hfs_cat_entry *old_parent = HFS_I(old_dir)->entry;
352 struct hfs_cat_entry *new_parent = HFS_I(new_dir)->entry;
353 struct hfs_cat_entry *victim = NULL;
354 struct hfs_cat_entry *deleted;
355 struct hfs_cat_key key;
358 if (build_key(&key, old_dir, old_dentry->d_name.name,
359 old_dentry->d_name.len) ||
360 (HFS_ITYPE(old_dir->i_ino) != HFS_ITYPE(new_dir->i_ino)))
363 if (!(victim = hfs_cat_get(old_parent->mdb, &key)))
367 if (build_key(&key, new_dir, new_dentry->d_name.name,
368 new_dentry->d_name.len))
371 if (!(error = hfs_cat_move(old_parent, new_parent,
372 victim, &key, &deleted))) {
373 int is_dir = (victim->type == HFS_CDR_DIR);
375 /* drop the old dentries */
376 mark_inodes_deleted(victim, old_dentry);
377 update_dirs_minus(old_parent, is_dir);
379 mark_inodes_deleted(deleted, new_dentry);
380 hfs_cat_put(deleted);
382 /* no existing inodes. just drop negative dentries */
383 if (HFS_I(new_dir)->d_drop_op)
384 HFS_I(new_dir)->d_drop_op(new_dentry,
385 HFS_I(new_dir)->file_type);
386 update_dirs_plus(new_parent, is_dir);
392 hfs_cat_put(victim); /* Note that hfs_cat_put(NULL) is safe. */