1 /* 2 * linux/fs/minix/dir.c 3 * 4 * Copyright (C) 1991, 1992 Linus Torvalds 5 * 6 * minix directory handling functions 7 * 8 * Updated to filesystem version 3 by Daniel Aragones 9 */ 10 11 #include "minix.h" 12 #include <linux/buffer_head.h> 13 #include <linux/highmem.h> 14 #include <linux/swap.h> 15 16 typedef struct minix_dir_entry minix_dirent; 17 typedef struct minix3_dir_entry minix3_dirent; 18 19 static int minix_readdir(struct file *, void *, filldir_t); 20 21 const struct file_operations minix_dir_operations = { 22 .llseek = generic_file_llseek, 23 .read = generic_read_dir, 24 .readdir = minix_readdir, 25 .fsync = generic_file_fsync, 26 }; 27 28 static inline void dir_put_page(struct page *page) 29 { 30 kunmap(page); 31 page_cache_release(page); 32 } 33 34 /* 35 * Return the offset into page `page_nr' of the last valid 36 * byte in that page, plus one. 37 */ 38 static unsigned 39 minix_last_byte(struct inode *inode, unsigned long page_nr) 40 { 41 unsigned last_byte = PAGE_CACHE_SIZE; 42 43 if (page_nr == (inode->i_size >> PAGE_CACHE_SHIFT)) 44 last_byte = inode->i_size & (PAGE_CACHE_SIZE - 1); 45 return last_byte; 46 } 47 48 static inline unsigned long dir_pages(struct inode *inode) 49 { 50 return (inode->i_size+PAGE_CACHE_SIZE-1)>>PAGE_CACHE_SHIFT; 51 } 52 53 static int dir_commit_chunk(struct page *page, loff_t pos, unsigned len) 54 { 55 struct address_space *mapping = page->mapping; 56 struct inode *dir = mapping->host; 57 int err = 0; 58 block_write_end(NULL, mapping, pos, len, len, page, NULL); 59 60 if (pos+len > dir->i_size) { 61 i_size_write(dir, pos+len); 62 mark_inode_dirty(dir); 63 } 64 if (IS_DIRSYNC(dir)) 65 err = write_one_page(page, 1); 66 else 67 unlock_page(page); 68 return err; 69 } 70 71 static struct page * dir_get_page(struct inode *dir, unsigned long n) 72 { 73 struct address_space *mapping = dir->i_mapping; 74 struct page *page = read_mapping_page(mapping, n, NULL); 75 if (!IS_ERR(page)) 76 kmap(page); 77 return page; 78 } 79 80 static inline void *minix_next_entry(void *de, struct minix_sb_info *sbi) 81 { 82 return (void*)((char*)de + sbi->s_dirsize); 83 } 84 85 static int minix_readdir(struct file * filp, void * dirent, filldir_t filldir) 86 { 87 unsigned long pos = filp->f_pos; 88 struct inode *inode = file_inode(filp); 89 struct super_block *sb = inode->i_sb; 90 unsigned offset = pos & ~PAGE_CACHE_MASK; 91 unsigned long n = pos >> PAGE_CACHE_SHIFT; 92 unsigned long npages = dir_pages(inode); 93 struct minix_sb_info *sbi = minix_sb(sb); 94 unsigned chunk_size = sbi->s_dirsize; 95 char *name; 96 __u32 inumber; 97 98 pos = (pos + chunk_size-1) & ~(chunk_size-1); 99 if (pos >= inode->i_size) 100 goto done; 101 102 for ( ; n < npages; n++, offset = 0) { 103 char *p, *kaddr, *limit; 104 struct page *page = dir_get_page(inode, n); 105 106 if (IS_ERR(page)) 107 continue; 108 kaddr = (char *)page_address(page); 109 p = kaddr+offset; 110 limit = kaddr + minix_last_byte(inode, n) - chunk_size; 111 for ( ; p <= limit; p = minix_next_entry(p, sbi)) { 112 if (sbi->s_version == MINIX_V3) { 113 minix3_dirent *de3 = (minix3_dirent *)p; 114 name = de3->name; 115 inumber = de3->inode; 116 } else { 117 minix_dirent *de = (minix_dirent *)p; 118 name = de->name; 119 inumber = de->inode; 120 } 121 if (inumber) { 122 int over; 123 124 unsigned l = strnlen(name, sbi->s_namelen); 125 offset = p - kaddr; 126 over = filldir(dirent, name, l, 127 (n << PAGE_CACHE_SHIFT) | offset, 128 inumber, DT_UNKNOWN); 129 if (over) { 130 dir_put_page(page); 131 goto done; 132 } 133 } 134 } 135 dir_put_page(page); 136 } 137 138 done: 139 filp->f_pos = (n << PAGE_CACHE_SHIFT) | offset; 140 return 0; 141 } 142 143 static inline int namecompare(int len, int maxlen, 144 const char * name, const char * buffer) 145 { 146 if (len < maxlen && buffer[len]) 147 return 0; 148 return !memcmp(name, buffer, len); 149 } 150 151 /* 152 * minix_find_entry() 153 * 154 * finds an entry in the specified directory with the wanted name. It 155 * returns the cache buffer in which the entry was found, and the entry 156 * itself (as a parameter - res_dir). It does NOT read the inode of the 157 * entry - you'll have to do that yourself if you want to. 158 */ 159 minix_dirent *minix_find_entry(struct dentry *dentry, struct page **res_page) 160 { 161 const char * name = dentry->d_name.name; 162 int namelen = dentry->d_name.len; 163 struct inode * dir = dentry->d_parent->d_inode; 164 struct super_block * sb = dir->i_sb; 165 struct minix_sb_info * sbi = minix_sb(sb); 166 unsigned long n; 167 unsigned long npages = dir_pages(dir); 168 struct page *page = NULL; 169 char *p; 170 171 char *namx; 172 __u32 inumber; 173 *res_page = NULL; 174 175 for (n = 0; n < npages; n++) { 176 char *kaddr, *limit; 177 178 page = dir_get_page(dir, n); 179 if (IS_ERR(page)) 180 continue; 181 182 kaddr = (char*)page_address(page); 183 limit = kaddr + minix_last_byte(dir, n) - sbi->s_dirsize; 184 for (p = kaddr; p <= limit; p = minix_next_entry(p, sbi)) { 185 if (sbi->s_version == MINIX_V3) { 186 minix3_dirent *de3 = (minix3_dirent *)p; 187 namx = de3->name; 188 inumber = de3->inode; 189 } else { 190 minix_dirent *de = (minix_dirent *)p; 191 namx = de->name; 192 inumber = de->inode; 193 } 194 if (!inumber) 195 continue; 196 if (namecompare(namelen, sbi->s_namelen, name, namx)) 197 goto found; 198 } 199 dir_put_page(page); 200 } 201 return NULL; 202 203 found: 204 *res_page = page; 205 return (minix_dirent *)p; 206 } 207 208 int minix_add_link(struct dentry *dentry, struct inode *inode) 209 { 210 struct inode *dir = dentry->d_parent->d_inode; 211 const char * name = dentry->d_name.name; 212 int namelen = dentry->d_name.len; 213 struct super_block * sb = dir->i_sb; 214 struct minix_sb_info * sbi = minix_sb(sb); 215 struct page *page = NULL; 216 unsigned long npages = dir_pages(dir); 217 unsigned long n; 218 char *kaddr, *p; 219 minix_dirent *de; 220 minix3_dirent *de3; 221 loff_t pos; 222 int err; 223 char *namx = NULL; 224 __u32 inumber; 225 226 /* 227 * We take care of directory expansion in the same loop 228 * This code plays outside i_size, so it locks the page 229 * to protect that region. 230 */ 231 for (n = 0; n <= npages; n++) { 232 char *limit, *dir_end; 233 234 page = dir_get_page(dir, n); 235 err = PTR_ERR(page); 236 if (IS_ERR(page)) 237 goto out; 238 lock_page(page); 239 kaddr = (char*)page_address(page); 240 dir_end = kaddr + minix_last_byte(dir, n); 241 limit = kaddr + PAGE_CACHE_SIZE - sbi->s_dirsize; 242 for (p = kaddr; p <= limit; p = minix_next_entry(p, sbi)) { 243 de = (minix_dirent *)p; 244 de3 = (minix3_dirent *)p; 245 if (sbi->s_version == MINIX_V3) { 246 namx = de3->name; 247 inumber = de3->inode; 248 } else { 249 namx = de->name; 250 inumber = de->inode; 251 } 252 if (p == dir_end) { 253 /* We hit i_size */ 254 if (sbi->s_version == MINIX_V3) 255 de3->inode = 0; 256 else 257 de->inode = 0; 258 goto got_it; 259 } 260 if (!inumber) 261 goto got_it; 262 err = -EEXIST; 263 if (namecompare(namelen, sbi->s_namelen, name, namx)) 264 goto out_unlock; 265 } 266 unlock_page(page); 267 dir_put_page(page); 268 } 269 BUG(); 270 return -EINVAL; 271 272 got_it: 273 pos = page_offset(page) + p - (char *)page_address(page); 274 err = minix_prepare_chunk(page, pos, sbi->s_dirsize); 275 if (err) 276 goto out_unlock; 277 memcpy (namx, name, namelen); 278 if (sbi->s_version == MINIX_V3) { 279 memset (namx + namelen, 0, sbi->s_dirsize - namelen - 4); 280 de3->inode = inode->i_ino; 281 } else { 282 memset (namx + namelen, 0, sbi->s_dirsize - namelen - 2); 283 de->inode = inode->i_ino; 284 } 285 err = dir_commit_chunk(page, pos, sbi->s_dirsize); 286 dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC; 287 mark_inode_dirty(dir); 288 out_put: 289 dir_put_page(page); 290 out: 291 return err; 292 out_unlock: 293 unlock_page(page); 294 goto out_put; 295 } 296 297 int minix_delete_entry(struct minix_dir_entry *de, struct page *page) 298 { 299 struct inode *inode = page->mapping->host; 300 char *kaddr = page_address(page); 301 loff_t pos = page_offset(page) + (char*)de - kaddr; 302 struct minix_sb_info *sbi = minix_sb(inode->i_sb); 303 unsigned len = sbi->s_dirsize; 304 int err; 305 306 lock_page(page); 307 err = minix_prepare_chunk(page, pos, len); 308 if (err == 0) { 309 if (sbi->s_version == MINIX_V3) 310 ((minix3_dirent *) de)->inode = 0; 311 else 312 de->inode = 0; 313 err = dir_commit_chunk(page, pos, len); 314 } else { 315 unlock_page(page); 316 } 317 dir_put_page(page); 318 inode->i_ctime = inode->i_mtime = CURRENT_TIME_SEC; 319 mark_inode_dirty(inode); 320 return err; 321 } 322 323 int minix_make_empty(struct inode *inode, struct inode *dir) 324 { 325 struct page *page = grab_cache_page(inode->i_mapping, 0); 326 struct minix_sb_info *sbi = minix_sb(inode->i_sb); 327 char *kaddr; 328 int err; 329 330 if (!page) 331 return -ENOMEM; 332 err = minix_prepare_chunk(page, 0, 2 * sbi->s_dirsize); 333 if (err) { 334 unlock_page(page); 335 goto fail; 336 } 337 338 kaddr = kmap_atomic(page); 339 memset(kaddr, 0, PAGE_CACHE_SIZE); 340 341 if (sbi->s_version == MINIX_V3) { 342 minix3_dirent *de3 = (minix3_dirent *)kaddr; 343 344 de3->inode = inode->i_ino; 345 strcpy(de3->name, "."); 346 de3 = minix_next_entry(de3, sbi); 347 de3->inode = dir->i_ino; 348 strcpy(de3->name, ".."); 349 } else { 350 minix_dirent *de = (minix_dirent *)kaddr; 351 352 de->inode = inode->i_ino; 353 strcpy(de->name, "."); 354 de = minix_next_entry(de, sbi); 355 de->inode = dir->i_ino; 356 strcpy(de->name, ".."); 357 } 358 kunmap_atomic(kaddr); 359 360 err = dir_commit_chunk(page, 0, 2 * sbi->s_dirsize); 361 fail: 362 page_cache_release(page); 363 return err; 364 } 365 366 /* 367 * routine to check that the specified directory is empty (for rmdir) 368 */ 369 int minix_empty_dir(struct inode * inode) 370 { 371 struct page *page = NULL; 372 unsigned long i, npages = dir_pages(inode); 373 struct minix_sb_info *sbi = minix_sb(inode->i_sb); 374 char *name; 375 __u32 inumber; 376 377 for (i = 0; i < npages; i++) { 378 char *p, *kaddr, *limit; 379 380 page = dir_get_page(inode, i); 381 if (IS_ERR(page)) 382 continue; 383 384 kaddr = (char *)page_address(page); 385 limit = kaddr + minix_last_byte(inode, i) - sbi->s_dirsize; 386 for (p = kaddr; p <= limit; p = minix_next_entry(p, sbi)) { 387 if (sbi->s_version == MINIX_V3) { 388 minix3_dirent *de3 = (minix3_dirent *)p; 389 name = de3->name; 390 inumber = de3->inode; 391 } else { 392 minix_dirent *de = (minix_dirent *)p; 393 name = de->name; 394 inumber = de->inode; 395 } 396 397 if (inumber != 0) { 398 /* check for . and .. */ 399 if (name[0] != '.') 400 goto not_empty; 401 if (!name[1]) { 402 if (inumber != inode->i_ino) 403 goto not_empty; 404 } else if (name[1] != '.') 405 goto not_empty; 406 else if (name[2]) 407 goto not_empty; 408 } 409 } 410 dir_put_page(page); 411 } 412 return 1; 413 414 not_empty: 415 dir_put_page(page); 416 return 0; 417 } 418 419 /* Releases the page */ 420 void minix_set_link(struct minix_dir_entry *de, struct page *page, 421 struct inode *inode) 422 { 423 struct inode *dir = page->mapping->host; 424 struct minix_sb_info *sbi = minix_sb(dir->i_sb); 425 loff_t pos = page_offset(page) + 426 (char *)de-(char*)page_address(page); 427 int err; 428 429 lock_page(page); 430 431 err = minix_prepare_chunk(page, pos, sbi->s_dirsize); 432 if (err == 0) { 433 if (sbi->s_version == MINIX_V3) 434 ((minix3_dirent *) de)->inode = inode->i_ino; 435 else 436 de->inode = inode->i_ino; 437 err = dir_commit_chunk(page, pos, sbi->s_dirsize); 438 } else { 439 unlock_page(page); 440 } 441 dir_put_page(page); 442 dir->i_mtime = dir->i_ctime = CURRENT_TIME_SEC; 443 mark_inode_dirty(dir); 444 } 445 446 struct minix_dir_entry * minix_dotdot (struct inode *dir, struct page **p) 447 { 448 struct page *page = dir_get_page(dir, 0); 449 struct minix_sb_info *sbi = minix_sb(dir->i_sb); 450 struct minix_dir_entry *de = NULL; 451 452 if (!IS_ERR(page)) { 453 de = minix_next_entry(page_address(page), sbi); 454 *p = page; 455 } 456 return de; 457 } 458 459 ino_t minix_inode_by_name(struct dentry *dentry) 460 { 461 struct page *page; 462 struct minix_dir_entry *de = minix_find_entry(dentry, &page); 463 ino_t res = 0; 464 465 if (de) { 466 struct address_space *mapping = page->mapping; 467 struct inode *inode = mapping->host; 468 struct minix_sb_info *sbi = minix_sb(inode->i_sb); 469 470 if (sbi->s_version == MINIX_V3) 471 res = ((minix3_dirent *) de)->inode; 472 else 473 res = de->inode; 474 dir_put_page(page); 475 } 476 return res; 477 } 478