4
* Migration to usage of "page cache" on May 2006 by
5
* Evgeniy Dushistov <dushistov@mail.ru> based on ext2 code base.
8
* Daniel Pirkl <daniel.pirkl@email.cz>
9
* Charles University, Faculty of Mathematics and Physics
13
* linux/fs/ext2/namei.c
15
* Copyright (C) 1992, 1993, 1994, 1995
16
* Remy Card (card@masi.ibp.fr)
17
* Laboratoire MASI - Institut Blaise Pascal
18
* Universite Pierre et Marie Curie (Paris VI)
22
* linux/fs/minix/namei.c
24
* Copyright (C) 1991, 1992 Linus Torvalds
26
* Big-endian to little-endian byte-swapping/bitmaps by
27
* David S. Miller (davem@caip.rutgers.edu), 1995
30
#include <linux/time.h>
37
static inline int ufs_add_nondir(struct dentry *dentry, struct inode *inode)
39
int err = ufs_add_link(dentry, inode);
41
d_instantiate(dentry, inode);
44
inode_dec_link_count(inode);
49
static struct dentry *ufs_lookup(struct inode * dir, struct dentry *dentry, struct nameidata *nd)
51
struct inode * inode = NULL;
54
if (dentry->d_name.len > UFS_MAXNAMLEN)
55
return ERR_PTR(-ENAMETOOLONG);
58
ino = ufs_inode_by_name(dir, &dentry->d_name);
60
inode = ufs_iget(dir->i_sb, ino);
61
unlock_ufs(dir->i_sb);
62
return d_splice_alias(inode, dentry);
66
* By the time this is called, we already have created
67
* the directory cache entry for the new file, but it
68
* is so far negative - it has no inode.
70
* If the create succeeds, we fill in the inode information
71
* with d_instantiate().
73
static int ufs_create (struct inode * dir, struct dentry * dentry, int mode,
81
inode = ufs_new_inode(dir, mode);
85
inode->i_op = &ufs_file_inode_operations;
86
inode->i_fop = &ufs_file_operations;
87
inode->i_mapping->a_ops = &ufs_aops;
88
mark_inode_dirty(inode);
90
err = ufs_add_nondir(dentry, inode);
91
unlock_ufs(dir->i_sb);
93
UFSD("END: err=%d\n", err);
97
static int ufs_mknod (struct inode * dir, struct dentry *dentry, int mode, dev_t rdev)
102
if (!old_valid_dev(rdev))
105
inode = ufs_new_inode(dir, mode);
106
err = PTR_ERR(inode);
107
if (!IS_ERR(inode)) {
108
init_special_inode(inode, mode, rdev);
109
ufs_set_inode_dev(inode->i_sb, UFS_I(inode), rdev);
110
mark_inode_dirty(inode);
112
err = ufs_add_nondir(dentry, inode);
113
unlock_ufs(dir->i_sb);
118
static int ufs_symlink (struct inode * dir, struct dentry * dentry,
119
const char * symname)
121
struct super_block * sb = dir->i_sb;
122
int err = -ENAMETOOLONG;
123
unsigned l = strlen(symname)+1;
124
struct inode * inode;
126
if (l > sb->s_blocksize)
130
inode = ufs_new_inode(dir, S_IFLNK | S_IRWXUGO);
131
err = PTR_ERR(inode);
135
if (l > UFS_SB(sb)->s_uspi->s_maxsymlinklen) {
137
inode->i_op = &ufs_symlink_inode_operations;
138
inode->i_mapping->a_ops = &ufs_aops;
139
err = page_symlink(inode, symname, l);
144
inode->i_op = &ufs_fast_symlink_inode_operations;
145
memcpy(UFS_I(inode)->i_u1.i_symlink, symname, l);
148
mark_inode_dirty(inode);
150
err = ufs_add_nondir(dentry, inode);
152
unlock_ufs(dir->i_sb);
157
inode_dec_link_count(inode);
162
static int ufs_link (struct dentry * old_dentry, struct inode * dir,
163
struct dentry *dentry)
165
struct inode *inode = old_dentry->d_inode;
169
if (inode->i_nlink >= UFS_LINK_MAX) {
170
unlock_ufs(dir->i_sb);
174
inode->i_ctime = CURRENT_TIME_SEC;
175
inode_inc_link_count(inode);
178
error = ufs_add_nondir(dentry, inode);
179
unlock_ufs(dir->i_sb);
183
static int ufs_mkdir(struct inode * dir, struct dentry * dentry, int mode)
185
struct inode * inode;
188
if (dir->i_nlink >= UFS_LINK_MAX)
192
inode_inc_link_count(dir);
194
inode = ufs_new_inode(dir, S_IFDIR|mode);
195
err = PTR_ERR(inode);
199
inode->i_op = &ufs_dir_inode_operations;
200
inode->i_fop = &ufs_dir_operations;
201
inode->i_mapping->a_ops = &ufs_aops;
203
inode_inc_link_count(inode);
205
err = ufs_make_empty(inode, dir);
209
err = ufs_add_link(dentry, inode);
212
unlock_ufs(dir->i_sb);
214
d_instantiate(dentry, inode);
219
inode_dec_link_count(inode);
220
inode_dec_link_count(inode);
223
inode_dec_link_count(dir);
224
unlock_ufs(dir->i_sb);
228
static int ufs_unlink(struct inode *dir, struct dentry *dentry)
230
struct inode * inode = dentry->d_inode;
231
struct ufs_dir_entry *de;
235
de = ufs_find_entry(dir, &dentry->d_name, &page);
239
err = ufs_delete_entry(dir, de, page);
243
inode->i_ctime = dir->i_ctime;
244
inode_dec_link_count(inode);
250
static int ufs_rmdir (struct inode * dir, struct dentry *dentry)
252
struct inode * inode = dentry->d_inode;
256
if (ufs_empty_dir (inode)) {
257
err = ufs_unlink(dir, dentry);
260
inode_dec_link_count(inode);
261
inode_dec_link_count(dir);
264
unlock_ufs(dir->i_sb);
268
static int ufs_rename(struct inode *old_dir, struct dentry *old_dentry,
269
struct inode *new_dir, struct dentry *new_dentry)
271
struct inode *old_inode = old_dentry->d_inode;
272
struct inode *new_inode = new_dentry->d_inode;
273
struct page *dir_page = NULL;
274
struct ufs_dir_entry * dir_de = NULL;
275
struct page *old_page;
276
struct ufs_dir_entry *old_de;
279
old_de = ufs_find_entry(old_dir, &old_dentry->d_name, &old_page);
283
if (S_ISDIR(old_inode->i_mode)) {
285
dir_de = ufs_dotdot(old_inode, &dir_page);
291
struct page *new_page;
292
struct ufs_dir_entry *new_de;
295
if (dir_de && !ufs_empty_dir(new_inode))
299
new_de = ufs_find_entry(new_dir, &new_dentry->d_name, &new_page);
302
ufs_set_link(new_dir, new_de, new_page, old_inode);
303
new_inode->i_ctime = CURRENT_TIME_SEC;
305
drop_nlink(new_inode);
306
inode_dec_link_count(new_inode);
310
if (new_dir->i_nlink >= UFS_LINK_MAX)
313
err = ufs_add_link(new_dentry, old_inode);
317
inode_inc_link_count(new_dir);
321
* Like most other Unix systems, set the ctime for inodes on a
324
old_inode->i_ctime = CURRENT_TIME_SEC;
326
ufs_delete_entry(old_dir, old_de, old_page);
327
mark_inode_dirty(old_inode);
330
ufs_set_link(old_inode, dir_de, dir_page, new_dir);
331
inode_dec_link_count(old_dir);
339
page_cache_release(dir_page);
343
page_cache_release(old_page);
348
const struct inode_operations ufs_dir_inode_operations = {
349
.create = ufs_create,
350
.lookup = ufs_lookup,
352
.unlink = ufs_unlink,
353
.symlink = ufs_symlink,
357
.rename = ufs_rename,