1 /* 2 * linux/fs/ufs/namei.c 3 * 4 * Migration to usage of "page cache" on May 2006 by 5 * Evgeniy Dushistov <dushistov@mail.ru> based on ext2 code base. 6 * 7 * Copyright (C) 1998 8 * Daniel Pirkl <daniel.pirkl@email.cz> 9 * Charles University, Faculty of Mathematics and Physics 10 * 11 * from 12 * 13 * linux/fs/ext2/namei.c 14 * 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) 19 * 20 * from 21 * 22 * linux/fs/minix/namei.c 23 * 24 * Copyright (C) 1991, 1992 Linus Torvalds 25 * 26 * Big-endian to little-endian byte-swapping/bitmaps by 27 * David S. Miller (davem@caip.rutgers.edu), 1995 28 */ 29 30 #include <linux/time.h> 31 #include <linux/fs.h> 32 33 #include "ufs_fs.h" 34 #include "ufs.h" 35 #include "util.h" 36 37 static inline int ufs_add_nondir(struct dentry *dentry, struct inode *inode) 38 { 39 int err = ufs_add_link(dentry, inode); 40 if (!err) { 41 unlock_new_inode(inode); 42 d_instantiate(dentry, inode); 43 return 0; 44 } 45 inode_dec_link_count(inode); 46 unlock_new_inode(inode); 47 iput(inode); 48 return err; 49 } 50 51 static struct dentry *ufs_lookup(struct inode * dir, struct dentry *dentry, unsigned int flags) 52 { 53 struct inode * inode = NULL; 54 ino_t ino; 55 56 if (dentry->d_name.len > UFS_MAXNAMLEN) 57 return ERR_PTR(-ENAMETOOLONG); 58 59 ino = ufs_inode_by_name(dir, &dentry->d_name); 60 if (ino) 61 inode = ufs_iget(dir->i_sb, ino); 62 return d_splice_alias(inode, dentry); 63 } 64 65 /* 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. 69 * 70 * If the create succeeds, we fill in the inode information 71 * with d_instantiate(). 72 */ 73 static int ufs_create (struct inode * dir, struct dentry * dentry, umode_t mode, 74 bool excl) 75 { 76 struct inode *inode; 77 78 inode = ufs_new_inode(dir, mode); 79 if (IS_ERR(inode)) 80 return PTR_ERR(inode); 81 82 inode->i_op = &ufs_file_inode_operations; 83 inode->i_fop = &ufs_file_operations; 84 inode->i_mapping->a_ops = &ufs_aops; 85 mark_inode_dirty(inode); 86 return ufs_add_nondir(dentry, inode); 87 } 88 89 static int ufs_mknod(struct inode *dir, struct dentry *dentry, umode_t mode, dev_t rdev) 90 { 91 struct inode *inode; 92 int err; 93 94 if (!old_valid_dev(rdev)) 95 return -EINVAL; 96 97 inode = ufs_new_inode(dir, mode); 98 err = PTR_ERR(inode); 99 if (!IS_ERR(inode)) { 100 init_special_inode(inode, mode, rdev); 101 ufs_set_inode_dev(inode->i_sb, UFS_I(inode), rdev); 102 mark_inode_dirty(inode); 103 err = ufs_add_nondir(dentry, inode); 104 } 105 return err; 106 } 107 108 static int ufs_symlink (struct inode * dir, struct dentry * dentry, 109 const char * symname) 110 { 111 struct super_block * sb = dir->i_sb; 112 int err; 113 unsigned l = strlen(symname)+1; 114 struct inode * inode; 115 116 if (l > sb->s_blocksize) 117 return -ENAMETOOLONG; 118 119 inode = ufs_new_inode(dir, S_IFLNK | S_IRWXUGO); 120 err = PTR_ERR(inode); 121 if (IS_ERR(inode)) 122 return err; 123 124 if (l > UFS_SB(sb)->s_uspi->s_maxsymlinklen) { 125 /* slow symlink */ 126 inode->i_op = &page_symlink_inode_operations; 127 inode_nohighmem(inode); 128 inode->i_mapping->a_ops = &ufs_aops; 129 err = page_symlink(inode, symname, l); 130 if (err) 131 goto out_fail; 132 } else { 133 /* fast symlink */ 134 inode->i_op = &simple_symlink_inode_operations; 135 inode->i_link = (char *)UFS_I(inode)->i_u1.i_symlink; 136 memcpy(inode->i_link, symname, l); 137 inode->i_size = l-1; 138 } 139 mark_inode_dirty(inode); 140 141 return ufs_add_nondir(dentry, inode); 142 143 out_fail: 144 inode_dec_link_count(inode); 145 unlock_new_inode(inode); 146 iput(inode); 147 return err; 148 } 149 150 static int ufs_link (struct dentry * old_dentry, struct inode * dir, 151 struct dentry *dentry) 152 { 153 struct inode *inode = d_inode(old_dentry); 154 int error; 155 156 inode->i_ctime = current_time(inode); 157 inode_inc_link_count(inode); 158 ihold(inode); 159 160 error = ufs_add_link(dentry, inode); 161 if (error) { 162 inode_dec_link_count(inode); 163 iput(inode); 164 } else 165 d_instantiate(dentry, inode); 166 return error; 167 } 168 169 static int ufs_mkdir(struct inode * dir, struct dentry * dentry, umode_t mode) 170 { 171 struct inode * inode; 172 int err; 173 174 inode_inc_link_count(dir); 175 176 inode = ufs_new_inode(dir, S_IFDIR|mode); 177 err = PTR_ERR(inode); 178 if (IS_ERR(inode)) 179 goto out_dir; 180 181 inode->i_op = &ufs_dir_inode_operations; 182 inode->i_fop = &ufs_dir_operations; 183 inode->i_mapping->a_ops = &ufs_aops; 184 185 inode_inc_link_count(inode); 186 187 err = ufs_make_empty(inode, dir); 188 if (err) 189 goto out_fail; 190 191 err = ufs_add_link(dentry, inode); 192 if (err) 193 goto out_fail; 194 195 unlock_new_inode(inode); 196 d_instantiate(dentry, inode); 197 return 0; 198 199 out_fail: 200 inode_dec_link_count(inode); 201 inode_dec_link_count(inode); 202 unlock_new_inode(inode); 203 iput (inode); 204 out_dir: 205 inode_dec_link_count(dir); 206 return err; 207 } 208 209 static int ufs_unlink(struct inode *dir, struct dentry *dentry) 210 { 211 struct inode * inode = d_inode(dentry); 212 struct ufs_dir_entry *de; 213 struct page *page; 214 int err = -ENOENT; 215 216 de = ufs_find_entry(dir, &dentry->d_name, &page); 217 if (!de) 218 goto out; 219 220 err = ufs_delete_entry(dir, de, page); 221 if (err) 222 goto out; 223 224 inode->i_ctime = dir->i_ctime; 225 inode_dec_link_count(inode); 226 err = 0; 227 out: 228 return err; 229 } 230 231 static int ufs_rmdir (struct inode * dir, struct dentry *dentry) 232 { 233 struct inode * inode = d_inode(dentry); 234 int err= -ENOTEMPTY; 235 236 if (ufs_empty_dir (inode)) { 237 err = ufs_unlink(dir, dentry); 238 if (!err) { 239 inode->i_size = 0; 240 inode_dec_link_count(inode); 241 inode_dec_link_count(dir); 242 } 243 } 244 return err; 245 } 246 247 static int ufs_rename(struct inode *old_dir, struct dentry *old_dentry, 248 struct inode *new_dir, struct dentry *new_dentry, 249 unsigned int flags) 250 { 251 struct inode *old_inode = d_inode(old_dentry); 252 struct inode *new_inode = d_inode(new_dentry); 253 struct page *dir_page = NULL; 254 struct ufs_dir_entry * dir_de = NULL; 255 struct page *old_page; 256 struct ufs_dir_entry *old_de; 257 int err = -ENOENT; 258 259 if (flags & ~RENAME_NOREPLACE) 260 return -EINVAL; 261 262 old_de = ufs_find_entry(old_dir, &old_dentry->d_name, &old_page); 263 if (!old_de) 264 goto out; 265 266 if (S_ISDIR(old_inode->i_mode)) { 267 err = -EIO; 268 dir_de = ufs_dotdot(old_inode, &dir_page); 269 if (!dir_de) 270 goto out_old; 271 } 272 273 if (new_inode) { 274 struct page *new_page; 275 struct ufs_dir_entry *new_de; 276 277 err = -ENOTEMPTY; 278 if (dir_de && !ufs_empty_dir(new_inode)) 279 goto out_dir; 280 281 err = -ENOENT; 282 new_de = ufs_find_entry(new_dir, &new_dentry->d_name, &new_page); 283 if (!new_de) 284 goto out_dir; 285 ufs_set_link(new_dir, new_de, new_page, old_inode, 1); 286 new_inode->i_ctime = current_time(new_inode); 287 if (dir_de) 288 drop_nlink(new_inode); 289 inode_dec_link_count(new_inode); 290 } else { 291 err = ufs_add_link(new_dentry, old_inode); 292 if (err) 293 goto out_dir; 294 if (dir_de) 295 inode_inc_link_count(new_dir); 296 } 297 298 /* 299 * Like most other Unix systems, set the ctime for inodes on a 300 * rename. 301 */ 302 old_inode->i_ctime = current_time(old_inode); 303 304 ufs_delete_entry(old_dir, old_de, old_page); 305 mark_inode_dirty(old_inode); 306 307 if (dir_de) { 308 if (old_dir != new_dir) 309 ufs_set_link(old_inode, dir_de, dir_page, new_dir, 0); 310 else { 311 kunmap(dir_page); 312 put_page(dir_page); 313 } 314 inode_dec_link_count(old_dir); 315 } 316 return 0; 317 318 319 out_dir: 320 if (dir_de) { 321 kunmap(dir_page); 322 put_page(dir_page); 323 } 324 out_old: 325 kunmap(old_page); 326 put_page(old_page); 327 out: 328 return err; 329 } 330 331 const struct inode_operations ufs_dir_inode_operations = { 332 .create = ufs_create, 333 .lookup = ufs_lookup, 334 .link = ufs_link, 335 .unlink = ufs_unlink, 336 .symlink = ufs_symlink, 337 .mkdir = ufs_mkdir, 338 .rmdir = ufs_rmdir, 339 .mknod = ufs_mknod, 340 .rename = ufs_rename, 341 }; 342