1 /* 2 * linux/fs/affs/inode.c 3 * 4 * (c) 1996 Hans-Joachim Widmaier - Rewritten 5 * 6 * (C) 1993 Ray Burr - Modified for Amiga FFS filesystem. 7 * 8 * (C) 1992 Eric Youngdale Modified for ISO9660 filesystem. 9 * 10 * (C) 1991 Linus Torvalds - minix filesystem 11 */ 12 #include <linux/sched.h> 13 #include <linux/gfp.h> 14 #include "affs.h" 15 16 extern const struct inode_operations affs_symlink_inode_operations; 17 extern struct timezone sys_tz; 18 19 struct inode *affs_iget(struct super_block *sb, unsigned long ino) 20 { 21 struct affs_sb_info *sbi = AFFS_SB(sb); 22 struct buffer_head *bh; 23 struct affs_tail *tail; 24 struct inode *inode; 25 u32 block; 26 u32 size; 27 u32 prot; 28 u16 id; 29 30 inode = iget_locked(sb, ino); 31 if (!inode) 32 return ERR_PTR(-ENOMEM); 33 if (!(inode->i_state & I_NEW)) 34 return inode; 35 36 pr_debug("affs_iget(%lu)\n", inode->i_ino); 37 38 block = inode->i_ino; 39 bh = affs_bread(sb, block); 40 if (!bh) { 41 affs_warning(sb, "read_inode", "Cannot read block %d", block); 42 goto bad_inode; 43 } 44 if (affs_checksum_block(sb, bh) || be32_to_cpu(AFFS_HEAD(bh)->ptype) != T_SHORT) { 45 affs_warning(sb,"read_inode", 46 "Checksum or type (ptype=%d) error on inode %d", 47 AFFS_HEAD(bh)->ptype, block); 48 goto bad_inode; 49 } 50 51 tail = AFFS_TAIL(sb, bh); 52 prot = be32_to_cpu(tail->protect); 53 54 inode->i_size = 0; 55 set_nlink(inode, 1); 56 inode->i_mode = 0; 57 AFFS_I(inode)->i_extcnt = 1; 58 AFFS_I(inode)->i_ext_last = ~1; 59 AFFS_I(inode)->i_protect = prot; 60 atomic_set(&AFFS_I(inode)->i_opencnt, 0); 61 AFFS_I(inode)->i_blkcnt = 0; 62 AFFS_I(inode)->i_lc = NULL; 63 AFFS_I(inode)->i_lc_size = 0; 64 AFFS_I(inode)->i_lc_shift = 0; 65 AFFS_I(inode)->i_lc_mask = 0; 66 AFFS_I(inode)->i_ac = NULL; 67 AFFS_I(inode)->i_ext_bh = NULL; 68 AFFS_I(inode)->mmu_private = 0; 69 AFFS_I(inode)->i_lastalloc = 0; 70 AFFS_I(inode)->i_pa_cnt = 0; 71 72 if (sbi->s_flags & SF_SETMODE) 73 inode->i_mode = sbi->s_mode; 74 else 75 inode->i_mode = prot_to_mode(prot); 76 77 id = be16_to_cpu(tail->uid); 78 if (id == 0 || sbi->s_flags & SF_SETUID) 79 inode->i_uid = sbi->s_uid; 80 else if (id == 0xFFFF && sbi->s_flags & SF_MUFS) 81 i_uid_write(inode, 0); 82 else 83 i_uid_write(inode, id); 84 85 id = be16_to_cpu(tail->gid); 86 if (id == 0 || sbi->s_flags & SF_SETGID) 87 inode->i_gid = sbi->s_gid; 88 else if (id == 0xFFFF && sbi->s_flags & SF_MUFS) 89 i_gid_write(inode, 0); 90 else 91 i_gid_write(inode, id); 92 93 switch (be32_to_cpu(tail->stype)) { 94 case ST_ROOT: 95 inode->i_uid = sbi->s_uid; 96 inode->i_gid = sbi->s_gid; 97 /* fall through */ 98 case ST_USERDIR: 99 if (be32_to_cpu(tail->stype) == ST_USERDIR || 100 sbi->s_flags & SF_SETMODE) { 101 if (inode->i_mode & S_IRUSR) 102 inode->i_mode |= S_IXUSR; 103 if (inode->i_mode & S_IRGRP) 104 inode->i_mode |= S_IXGRP; 105 if (inode->i_mode & S_IROTH) 106 inode->i_mode |= S_IXOTH; 107 inode->i_mode |= S_IFDIR; 108 } else 109 inode->i_mode = S_IRUGO | S_IXUGO | S_IWUSR | S_IFDIR; 110 /* Maybe it should be controlled by mount parameter? */ 111 //inode->i_mode |= S_ISVTX; 112 inode->i_op = &affs_dir_inode_operations; 113 inode->i_fop = &affs_dir_operations; 114 break; 115 case ST_LINKDIR: 116 #if 0 117 affs_warning(sb, "read_inode", "inode is LINKDIR"); 118 goto bad_inode; 119 #else 120 inode->i_mode |= S_IFDIR; 121 /* ... and leave ->i_op and ->i_fop pointing to empty */ 122 break; 123 #endif 124 case ST_LINKFILE: 125 affs_warning(sb, "read_inode", "inode is LINKFILE"); 126 goto bad_inode; 127 case ST_FILE: 128 size = be32_to_cpu(tail->size); 129 inode->i_mode |= S_IFREG; 130 AFFS_I(inode)->mmu_private = inode->i_size = size; 131 if (inode->i_size) { 132 AFFS_I(inode)->i_blkcnt = (size - 1) / 133 sbi->s_data_blksize + 1; 134 AFFS_I(inode)->i_extcnt = (AFFS_I(inode)->i_blkcnt - 1) / 135 sbi->s_hashsize + 1; 136 } 137 if (tail->link_chain) 138 set_nlink(inode, 2); 139 inode->i_mapping->a_ops = (sbi->s_flags & SF_OFS) ? &affs_aops_ofs : &affs_aops; 140 inode->i_op = &affs_file_inode_operations; 141 inode->i_fop = &affs_file_operations; 142 break; 143 case ST_SOFTLINK: 144 inode->i_mode |= S_IFLNK; 145 inode->i_op = &affs_symlink_inode_operations; 146 inode->i_data.a_ops = &affs_symlink_aops; 147 break; 148 } 149 150 inode->i_mtime.tv_sec = inode->i_atime.tv_sec = inode->i_ctime.tv_sec 151 = (be32_to_cpu(tail->change.days) * (24 * 60 * 60) + 152 be32_to_cpu(tail->change.mins) * 60 + 153 be32_to_cpu(tail->change.ticks) / 50 + 154 ((8 * 365 + 2) * 24 * 60 * 60)) + 155 sys_tz.tz_minuteswest * 60; 156 inode->i_mtime.tv_nsec = inode->i_ctime.tv_nsec = inode->i_atime.tv_nsec = 0; 157 affs_brelse(bh); 158 unlock_new_inode(inode); 159 return inode; 160 161 bad_inode: 162 affs_brelse(bh); 163 iget_failed(inode); 164 return ERR_PTR(-EIO); 165 } 166 167 int 168 affs_write_inode(struct inode *inode, struct writeback_control *wbc) 169 { 170 struct super_block *sb = inode->i_sb; 171 struct buffer_head *bh; 172 struct affs_tail *tail; 173 uid_t uid; 174 gid_t gid; 175 176 pr_debug("write_inode(%lu)\n", inode->i_ino); 177 178 if (!inode->i_nlink) 179 // possibly free block 180 return 0; 181 bh = affs_bread(sb, inode->i_ino); 182 if (!bh) { 183 affs_error(sb,"write_inode","Cannot read block %lu",inode->i_ino); 184 return -EIO; 185 } 186 tail = AFFS_TAIL(sb, bh); 187 if (tail->stype == cpu_to_be32(ST_ROOT)) { 188 secs_to_datestamp(inode->i_mtime.tv_sec,&AFFS_ROOT_TAIL(sb, bh)->root_change); 189 } else { 190 tail->protect = cpu_to_be32(AFFS_I(inode)->i_protect); 191 tail->size = cpu_to_be32(inode->i_size); 192 secs_to_datestamp(inode->i_mtime.tv_sec,&tail->change); 193 if (!(inode->i_ino == AFFS_SB(sb)->s_root_block)) { 194 uid = i_uid_read(inode); 195 gid = i_gid_read(inode); 196 if (AFFS_SB(sb)->s_flags & SF_MUFS) { 197 if (uid == 0 || uid == 0xFFFF) 198 uid = uid ^ ~0; 199 if (gid == 0 || gid == 0xFFFF) 200 gid = gid ^ ~0; 201 } 202 if (!(AFFS_SB(sb)->s_flags & SF_SETUID)) 203 tail->uid = cpu_to_be16(uid); 204 if (!(AFFS_SB(sb)->s_flags & SF_SETGID)) 205 tail->gid = cpu_to_be16(gid); 206 } 207 } 208 affs_fix_checksum(sb, bh); 209 mark_buffer_dirty_inode(bh, inode); 210 affs_brelse(bh); 211 affs_free_prealloc(inode); 212 return 0; 213 } 214 215 int 216 affs_notify_change(struct dentry *dentry, struct iattr *attr) 217 { 218 struct inode *inode = dentry->d_inode; 219 int error; 220 221 pr_debug("notify_change(%lu,0x%x)\n", inode->i_ino, attr->ia_valid); 222 223 error = inode_change_ok(inode,attr); 224 if (error) 225 goto out; 226 227 if (((attr->ia_valid & ATTR_UID) && (AFFS_SB(inode->i_sb)->s_flags & SF_SETUID)) || 228 ((attr->ia_valid & ATTR_GID) && (AFFS_SB(inode->i_sb)->s_flags & SF_SETGID)) || 229 ((attr->ia_valid & ATTR_MODE) && 230 (AFFS_SB(inode->i_sb)->s_flags & (SF_SETMODE | SF_IMMUTABLE)))) { 231 if (!(AFFS_SB(inode->i_sb)->s_flags & SF_QUIET)) 232 error = -EPERM; 233 goto out; 234 } 235 236 if ((attr->ia_valid & ATTR_SIZE) && 237 attr->ia_size != i_size_read(inode)) { 238 error = inode_newsize_ok(inode, attr->ia_size); 239 if (error) 240 return error; 241 242 truncate_setsize(inode, attr->ia_size); 243 affs_truncate(inode); 244 } 245 246 setattr_copy(inode, attr); 247 mark_inode_dirty(inode); 248 249 if (attr->ia_valid & ATTR_MODE) 250 mode_to_prot(inode); 251 out: 252 return error; 253 } 254 255 void 256 affs_evict_inode(struct inode *inode) 257 { 258 unsigned long cache_page; 259 pr_debug("evict_inode(ino=%lu, nlink=%u)\n", 260 inode->i_ino, inode->i_nlink); 261 truncate_inode_pages_final(&inode->i_data); 262 263 if (!inode->i_nlink) { 264 inode->i_size = 0; 265 affs_truncate(inode); 266 } 267 268 invalidate_inode_buffers(inode); 269 clear_inode(inode); 270 affs_free_prealloc(inode); 271 cache_page = (unsigned long)AFFS_I(inode)->i_lc; 272 if (cache_page) { 273 pr_debug("freeing ext cache\n"); 274 AFFS_I(inode)->i_lc = NULL; 275 AFFS_I(inode)->i_ac = NULL; 276 free_page(cache_page); 277 } 278 affs_brelse(AFFS_I(inode)->i_ext_bh); 279 AFFS_I(inode)->i_ext_last = ~1; 280 AFFS_I(inode)->i_ext_bh = NULL; 281 282 if (!inode->i_nlink) 283 affs_free_block(inode->i_sb, inode->i_ino); 284 } 285 286 struct inode * 287 affs_new_inode(struct inode *dir) 288 { 289 struct super_block *sb = dir->i_sb; 290 struct inode *inode; 291 u32 block; 292 struct buffer_head *bh; 293 294 if (!(inode = new_inode(sb))) 295 goto err_inode; 296 297 if (!(block = affs_alloc_block(dir, dir->i_ino))) 298 goto err_block; 299 300 bh = affs_getzeroblk(sb, block); 301 if (!bh) 302 goto err_bh; 303 mark_buffer_dirty_inode(bh, inode); 304 affs_brelse(bh); 305 306 inode->i_uid = current_fsuid(); 307 inode->i_gid = current_fsgid(); 308 inode->i_ino = block; 309 set_nlink(inode, 1); 310 inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME_SEC; 311 atomic_set(&AFFS_I(inode)->i_opencnt, 0); 312 AFFS_I(inode)->i_blkcnt = 0; 313 AFFS_I(inode)->i_lc = NULL; 314 AFFS_I(inode)->i_lc_size = 0; 315 AFFS_I(inode)->i_lc_shift = 0; 316 AFFS_I(inode)->i_lc_mask = 0; 317 AFFS_I(inode)->i_ac = NULL; 318 AFFS_I(inode)->i_ext_bh = NULL; 319 AFFS_I(inode)->mmu_private = 0; 320 AFFS_I(inode)->i_protect = 0; 321 AFFS_I(inode)->i_lastalloc = 0; 322 AFFS_I(inode)->i_pa_cnt = 0; 323 AFFS_I(inode)->i_extcnt = 1; 324 AFFS_I(inode)->i_ext_last = ~1; 325 326 insert_inode_hash(inode); 327 328 return inode; 329 330 err_bh: 331 affs_free_block(sb, block); 332 err_block: 333 iput(inode); 334 err_inode: 335 return NULL; 336 } 337 338 /* 339 * Add an entry to a directory. Create the header block 340 * and insert it into the hash table. 341 */ 342 343 int 344 affs_add_entry(struct inode *dir, struct inode *inode, struct dentry *dentry, s32 type) 345 { 346 struct super_block *sb = dir->i_sb; 347 struct buffer_head *inode_bh = NULL; 348 struct buffer_head *bh = NULL; 349 u32 block = 0; 350 int retval; 351 352 pr_debug("%s(dir=%u, inode=%u, \"%*s\", type=%d)\n", 353 __func__, (u32)dir->i_ino, 354 (u32)inode->i_ino, (int)dentry->d_name.len, dentry->d_name.name, type); 355 356 retval = -EIO; 357 bh = affs_bread(sb, inode->i_ino); 358 if (!bh) 359 goto done; 360 361 affs_lock_link(inode); 362 switch (type) { 363 case ST_LINKFILE: 364 case ST_LINKDIR: 365 retval = -ENOSPC; 366 block = affs_alloc_block(dir, dir->i_ino); 367 if (!block) 368 goto err; 369 retval = -EIO; 370 inode_bh = bh; 371 bh = affs_getzeroblk(sb, block); 372 if (!bh) 373 goto err; 374 break; 375 default: 376 break; 377 } 378 379 AFFS_HEAD(bh)->ptype = cpu_to_be32(T_SHORT); 380 AFFS_HEAD(bh)->key = cpu_to_be32(bh->b_blocknr); 381 affs_copy_name(AFFS_TAIL(sb, bh)->name, dentry); 382 AFFS_TAIL(sb, bh)->stype = cpu_to_be32(type); 383 AFFS_TAIL(sb, bh)->parent = cpu_to_be32(dir->i_ino); 384 385 if (inode_bh) { 386 __be32 chain; 387 chain = AFFS_TAIL(sb, inode_bh)->link_chain; 388 AFFS_TAIL(sb, bh)->original = cpu_to_be32(inode->i_ino); 389 AFFS_TAIL(sb, bh)->link_chain = chain; 390 AFFS_TAIL(sb, inode_bh)->link_chain = cpu_to_be32(block); 391 affs_adjust_checksum(inode_bh, block - be32_to_cpu(chain)); 392 mark_buffer_dirty_inode(inode_bh, inode); 393 set_nlink(inode, 2); 394 ihold(inode); 395 } 396 affs_fix_checksum(sb, bh); 397 mark_buffer_dirty_inode(bh, inode); 398 dentry->d_fsdata = (void *)(long)bh->b_blocknr; 399 400 affs_lock_dir(dir); 401 retval = affs_insert_hash(dir, bh); 402 mark_buffer_dirty_inode(bh, inode); 403 affs_unlock_dir(dir); 404 affs_unlock_link(inode); 405 406 d_instantiate(dentry, inode); 407 done: 408 affs_brelse(inode_bh); 409 affs_brelse(bh); 410 return retval; 411 err: 412 if (block) 413 affs_free_block(sb, block); 414 affs_unlock_link(inode); 415 goto done; 416 } 417