home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / KERNEL-S / V1.2 / LINUX-1.2 / LINUX-1 / linux / fs / inode.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-11-30  |  13.5 KB  |  578 lines
  1. /*
  2.  *  linux/fs/inode.c
  3.  *
  4.  *  Copyright (C) 1991, 1992  Linus Torvalds
  5.  */
  6.  
  7. #include <linux/stat.h>
  8. #include <linux/sched.h>
  9. #include <linux/kernel.h>
  10. #include <linux/mm.h>
  11. #include <linux/string.h>
  12.  
  13. #include <asm/system.h>
  14.  
  15. static struct inode_hash_entry {
  16.     struct inode * inode;
  17.     int updating;
  18. } hash_table[NR_IHASH];
  19.  
  20. static struct inode * first_inode;
  21. static struct wait_queue * inode_wait = NULL;
  22. static int nr_inodes = 0, nr_free_inodes = 0;
  23.  
  24. static inline int const hashfn(dev_t dev, unsigned int i)
  25. {
  26.     return (dev ^ i) % NR_IHASH;
  27. }
  28.  
  29. static inline struct inode_hash_entry * const hash(dev_t dev, int i)
  30. {
  31.     return hash_table + hashfn(dev, i);
  32. }
  33.  
  34. static void insert_inode_free(struct inode *inode)
  35. {
  36.     inode->i_next = first_inode;
  37.     inode->i_prev = first_inode->i_prev;
  38.     inode->i_next->i_prev = inode;
  39.     inode->i_prev->i_next = inode;
  40.     first_inode = inode;
  41. }
  42.  
  43. static void remove_inode_free(struct inode *inode)
  44. {
  45.     if (first_inode == inode)
  46.         first_inode = first_inode->i_next;
  47.     if (inode->i_next)
  48.         inode->i_next->i_prev = inode->i_prev;
  49.     if (inode->i_prev)
  50.         inode->i_prev->i_next = inode->i_next;
  51.     inode->i_next = inode->i_prev = NULL;
  52. }
  53.  
  54. void insert_inode_hash(struct inode *inode)
  55. {
  56.     struct inode_hash_entry *h;
  57.     h = hash(inode->i_dev, inode->i_ino);
  58.  
  59.     inode->i_hash_next = h->inode;
  60.     inode->i_hash_prev = NULL;
  61.     if (inode->i_hash_next)
  62.         inode->i_hash_next->i_hash_prev = inode;
  63.     h->inode = inode;
  64. }
  65.  
  66. static void remove_inode_hash(struct inode *inode)
  67. {
  68.     struct inode_hash_entry *h;
  69.     h = hash(inode->i_dev, inode->i_ino);
  70.  
  71.     if (h->inode == inode)
  72.         h->inode = inode->i_hash_next;
  73.     if (inode->i_hash_next)
  74.         inode->i_hash_next->i_hash_prev = inode->i_hash_prev;
  75.     if (inode->i_hash_prev)
  76.         inode->i_hash_prev->i_hash_next = inode->i_hash_next;
  77.     inode->i_hash_prev = inode->i_hash_next = NULL;
  78. }
  79.  
  80. static void put_last_free(struct inode *inode)
  81. {
  82.     remove_inode_free(inode);
  83.     inode->i_prev = first_inode->i_prev;
  84.     inode->i_prev->i_next = inode;
  85.     inode->i_next = first_inode;
  86.     inode->i_next->i_prev = inode;
  87. }
  88.  
  89. void grow_inodes(void)
  90. {
  91.     struct inode * inode;
  92.     int i;
  93.  
  94.     if (!(inode = (struct inode*) get_free_page(GFP_KERNEL)))
  95.         return;
  96.  
  97.     i=PAGE_SIZE / sizeof(struct inode);
  98.     nr_inodes += i;
  99.     nr_free_inodes += i;
  100.  
  101.     if (!first_inode)
  102.         inode->i_next = inode->i_prev = first_inode = inode++, i--;
  103.  
  104.     for ( ; i ; i-- )
  105.         insert_inode_free(inode++);
  106. }
  107.  
  108. unsigned long inode_init(unsigned long start, unsigned long end)
  109. {
  110.     memset(hash_table, 0, sizeof(hash_table));
  111.     first_inode = NULL;
  112.     return start;
  113. }
  114.  
  115. static void __wait_on_inode(struct inode *);
  116.  
  117. static inline void wait_on_inode(struct inode * inode)
  118. {
  119.     if (inode->i_lock)
  120.         __wait_on_inode(inode);
  121. }
  122.  
  123. static inline void lock_inode(struct inode * inode)
  124. {
  125.     wait_on_inode(inode);
  126.     inode->i_lock = 1;
  127. }
  128.  
  129. static inline void unlock_inode(struct inode * inode)
  130. {
  131.     inode->i_lock = 0;
  132.     wake_up(&inode->i_wait);
  133. }
  134.  
  135. /*
  136.  * Note that we don't want to disturb any wait-queues when we discard
  137.  * an inode.
  138.  *
  139.  * Argghh. Got bitten by a gcc problem with inlining: no way to tell
  140.  * the compiler that the inline asm function 'memset' changes 'inode'.
  141.  * I've been searching for the bug for days, and was getting desperate.
  142.  * Finally looked at the assembler output... Grrr.
  143.  *
  144.  * The solution is the weird use of 'volatile'. Ho humm. Have to report
  145.  * it to the gcc lists, and hope we can do this more cleanly some day..
  146.  */
  147. void clear_inode(struct inode * inode)
  148. {
  149.     struct wait_queue * wait;
  150.  
  151.     wait_on_inode(inode);
  152.     remove_inode_hash(inode);
  153.     remove_inode_free(inode);
  154.     wait = ((volatile struct inode *) inode)->i_wait;
  155.     if (inode->i_count)
  156.         nr_free_inodes++;
  157.     memset(inode,0,sizeof(*inode));
  158.     ((volatile struct inode *) inode)->i_wait = wait;
  159.     insert_inode_free(inode);
  160. }
  161.  
  162. int fs_may_mount(dev_t dev)
  163. {
  164.     struct inode * inode, * next;
  165.     int i;
  166.  
  167.     next = first_inode;
  168.     for (i = nr_inodes ; i > 0 ; i--) {
  169.         inode = next;
  170.         next = inode->i_next;    /* clear_inode() changes the queues.. */
  171.         if (inode->i_dev != dev)
  172.             continue;
  173.         if (inode->i_count || inode->i_dirt || inode->i_lock)
  174.             return 0;
  175.         clear_inode(inode);
  176.     }
  177.     return 1;
  178. }
  179.  
  180. int fs_may_umount(dev_t dev, struct inode * mount_root)
  181. {
  182.     struct inode * inode;
  183.     int i;
  184.  
  185.     inode = first_inode;
  186.     for (i=0 ; i < nr_inodes ; i++, inode = inode->i_next) {
  187.         if (inode->i_dev != dev || !inode->i_count)
  188.             continue;
  189.         if (inode == mount_root && inode->i_count == 1)
  190.             continue;
  191.         return 0;
  192.     }
  193.     return 1;
  194. }
  195.  
  196. int fs_may_remount_ro(dev_t dev)
  197. {
  198.     struct file * file;
  199.     int i;
  200.  
  201.     /* Check that no files are currently opened for writing. */
  202.     for (file = first_file, i=0; i<nr_files; i++, file=file->f_next) {
  203.         if (!file->f_count || !file->f_inode ||
  204.             file->f_inode->i_dev != dev)
  205.             continue;
  206.         if (S_ISREG(file->f_inode->i_mode) && (file->f_mode & 2))
  207.             return 0;
  208.     }
  209.     return 1;
  210. }
  211.  
  212. static void write_inode(struct inode * inode)
  213. {
  214.     if (!inode->i_dirt)
  215.         return;
  216.     wait_on_inode(inode);
  217.     if (!inode->i_dirt)
  218.         return;
  219.     if (!inode->i_sb || !inode->i_sb->s_op || !inode->i_sb->s_op->write_inode) {
  220.         inode->i_dirt = 0;
  221.         return;
  222.     }
  223.     inode->i_lock = 1;    
  224.     inode->i_sb->s_op->write_inode(inode);
  225.     unlock_inode(inode);
  226. }
  227.  
  228. static void read_inode(struct inode * inode)
  229. {
  230.     lock_inode(inode);
  231.     if (inode->i_sb && inode->i_sb->s_op && inode->i_sb->s_op->read_inode)
  232.         inode->i_sb->s_op->read_inode(inode);
  233.     unlock_inode(inode);
  234. }
  235.  
  236. /* POSIX UID/GID verification for setting inode attributes */
  237. int inode_change_ok(struct inode *inode, struct iattr *attr)
  238. {
  239.     /* Make sure a caller can chown */
  240.     if ((attr->ia_valid & ATTR_UID) &&
  241.         (current->fsuid != inode->i_uid ||
  242.          attr->ia_uid != inode->i_uid) && !fsuser())
  243.         return -EPERM;
  244.  
  245.     /* Make sure caller can chgrp */
  246.     if ((attr->ia_valid & ATTR_GID) &&
  247.         (!in_group_p(attr->ia_gid) && attr->ia_gid != inode->i_gid) &&
  248.         !fsuser())
  249.         return -EPERM;
  250.  
  251.     /* Make sure a caller can chmod */
  252.     if (attr->ia_valid & ATTR_MODE) {
  253.         if ((current->fsuid != inode->i_uid) && !fsuser())
  254.             return -EPERM;
  255.         /* Also check the setgid bit! */
  256.         if (!fsuser() && !in_group_p((attr->ia_valid & ATTR_GID) ? attr->ia_gid :
  257.                          inode->i_gid))
  258.             attr->ia_mode &= ~S_ISGID;
  259.     }
  260.  
  261.     /* Check for setting the inode time */
  262.     if ((attr->ia_valid & ATTR_ATIME_SET) &&
  263.         ((current->fsuid != inode->i_uid) && !fsuser()))
  264.         return -EPERM;
  265.     if ((attr->ia_valid & ATTR_MTIME_SET) &&
  266.         ((current->fsuid != inode->i_uid) && !fsuser()))
  267.         return -EPERM;
  268.  
  269.  
  270.     return 0;
  271. }
  272.  
  273. /*
  274.  * Set the appropriate attributes from an attribute structure into
  275.  * the inode structure.
  276.  */
  277. void inode_setattr(struct inode *inode, struct iattr *attr)
  278. {
  279.     if (attr->ia_valid & ATTR_UID)
  280.         inode->i_uid = attr->ia_uid;
  281.     if (attr->ia_valid & ATTR_GID)
  282.         inode->i_gid = attr->ia_gid;
  283.     if (attr->ia_valid & ATTR_SIZE)
  284.         inode->i_size = attr->ia_size;
  285.     if (attr->ia_valid & ATTR_ATIME)
  286.         inode->i_atime = attr->ia_atime;
  287.     if (attr->ia_valid & ATTR_MTIME)
  288.         inode->i_mtime = attr->ia_mtime;
  289.     if (attr->ia_valid & ATTR_CTIME)
  290.         inode->i_ctime = attr->ia_ctime;
  291.     if (attr->ia_valid & ATTR_MODE) {
  292.         inode->i_mode = attr->ia_mode;
  293.         if (!fsuser() && !in_group_p(inode->i_gid))
  294.             inode->i_mode &= ~S_ISGID;
  295.     }
  296.     inode->i_dirt = 1;
  297. }
  298.  
  299. /*
  300.  * notify_change is called for inode-changing operations such as
  301.  * chown, chmod, utime, and truncate.  It is guaranteed (unlike
  302.  * write_inode) to be called from the context of the user requesting
  303.  * the change.  It is not called for ordinary access-time updates.
  304.  * NFS uses this to get the authentication correct.  -- jrs
  305.  */
  306.  
  307. int notify_change(struct inode * inode, struct iattr *attr)
  308. {
  309.     int retval;
  310.  
  311.     if (inode->i_sb && inode->i_sb->s_op  &&
  312.         inode->i_sb->s_op->notify_change) 
  313.         return inode->i_sb->s_op->notify_change(inode, attr);
  314.  
  315.     if ((retval = inode_change_ok(inode, attr)) != 0)
  316.         return retval;
  317.  
  318.     inode_setattr(inode, attr);
  319.     return 0;
  320. }
  321.  
  322. /*
  323.  * bmap is needed for demand-loading and paging: if this function
  324.  * doesn't exist for a filesystem, then those things are impossible:
  325.  * executables cannot be run from the filesystem etc...
  326.  *
  327.  * This isn't as bad as it sounds: the read-routines might still work,
  328.  * so the filesystem would be otherwise ok (for example, you might have
  329.  * a DOS filesystem, which doesn't lend itself to bmap very well, but
  330.  * you could still transfer files to/from the filesystem)
  331.  */
  332. int bmap(struct inode * inode, int block)
  333. {
  334.     if (inode->i_op && inode->i_op->bmap)
  335.         return inode->i_op->bmap(inode,block);
  336.     return 0;
  337. }
  338.  
  339. void invalidate_inodes(dev_t dev)
  340. {
  341.     struct inode * inode, * next;
  342.     int i;
  343.  
  344.     next = first_inode;
  345.     for(i = nr_inodes ; i > 0 ; i--) {
  346.         inode = next;
  347.         next = inode->i_next;        /* clear_inode() changes the queues.. */
  348.         if (inode->i_dev != dev)
  349.             continue;
  350.         if (inode->i_count || inode->i_dirt || inode->i_lock) {
  351.             printk("VFS: inode busy on removed device %d/%d\n", MAJOR(dev), MINOR(dev));
  352.             continue;
  353.         }
  354.         clear_inode(inode);
  355.     }
  356. }
  357.  
  358. void sync_inodes(dev_t dev)
  359. {
  360.     int i;
  361.     struct inode * inode;
  362.  
  363.     inode = first_inode;
  364.     for(i = 0; i < nr_inodes*2; i++, inode = inode->i_next) {
  365.         if (dev && inode->i_dev != dev)
  366.             continue;
  367.         wait_on_inode(inode);
  368.         if (inode->i_dirt)
  369.             write_inode(inode);
  370.     }
  371. }
  372.  
  373. void iput(struct inode * inode)
  374. {
  375.     if (!inode)
  376.         return;
  377.     wait_on_inode(inode);
  378.     if (!inode->i_count) {
  379.         printk("VFS: iput: trying to free free inode\n");
  380.         printk("VFS: device %d/%d, inode %lu, mode=0%07o\n",
  381.             MAJOR(inode->i_rdev), MINOR(inode->i_rdev),
  382.                     inode->i_ino, inode->i_mode);
  383.         return;
  384.     }
  385.     if (inode->i_pipe)
  386.         wake_up_interruptible(&PIPE_WAIT(*inode));
  387. repeat:
  388.     if (inode->i_count>1) {
  389.         inode->i_count--;
  390.         return;
  391.     }
  392.     wake_up(&inode_wait);
  393.     if (inode->i_pipe) {
  394.         unsigned long page = (unsigned long) PIPE_BASE(*inode);
  395.         PIPE_BASE(*inode) = NULL;
  396.         free_page(page);
  397.     }
  398.     if (inode->i_sb && inode->i_sb->s_op && inode->i_sb->s_op->put_inode) {
  399.         inode->i_sb->s_op->put_inode(inode);
  400.         if (!inode->i_nlink)
  401.             return;
  402.     }
  403.     if (inode->i_dirt) {
  404.         write_inode(inode);    /* we can sleep - so do again */
  405.         wait_on_inode(inode);
  406.         goto repeat;
  407.     }
  408.     inode->i_count--;
  409.     if (inode->i_mmap) {
  410.         printk("iput: inode %lu on device %d/%d still has mappings.\n",
  411.             inode->i_ino, MAJOR(inode->i_dev), MINOR(inode->i_dev));
  412.         inode->i_mmap = NULL;
  413.     }
  414.     nr_free_inodes++;
  415.     return;
  416. }
  417.  
  418. struct inode * get_empty_inode(void)
  419. {
  420.     struct inode * inode, * best;
  421.     int i;
  422.  
  423.     if (nr_inodes < NR_INODE && nr_free_inodes < (nr_inodes >> 2))
  424.         grow_inodes();
  425. repeat:
  426.     inode = first_inode;
  427.     best = NULL;
  428.     for (i = 0; i<nr_inodes; inode = inode->i_next, i++) {
  429.         if (!inode->i_count) {
  430.             if (!best)
  431.                 best = inode;
  432.             if (!inode->i_dirt && !inode->i_lock) {
  433.                 best = inode;
  434.                 break;
  435.             }
  436.         }
  437.     }
  438.     if (!best || best->i_dirt || best->i_lock)
  439.         if (nr_inodes < NR_INODE) {
  440.             grow_inodes();
  441.             goto repeat;
  442.         }
  443.     inode = best;
  444.     if (!inode) {
  445.         printk("VFS: No free inodes - contact Linus\n");
  446.         sleep_on(&inode_wait);
  447.         goto repeat;
  448.     }
  449.     if (inode->i_lock) {
  450.         wait_on_inode(inode);
  451.         goto repeat;
  452.     }
  453.     if (inode->i_dirt) {
  454.         write_inode(inode);
  455.         goto repeat;
  456.     }
  457.     if (inode->i_count)
  458.         goto repeat;
  459.     clear_inode(inode);
  460.     inode->i_count = 1;
  461.     inode->i_nlink = 1;
  462.     inode->i_version = ++event;
  463.     inode->i_sem.count = 1;
  464.     nr_free_inodes--;
  465.     if (nr_free_inodes < 0) {
  466.         printk ("VFS: get_empty_inode: bad free inode count.\n");
  467.         nr_free_inodes = 0;
  468.     }
  469.     return inode;
  470. }
  471.  
  472. struct inode * get_pipe_inode(void)
  473. {
  474.     struct inode * inode;
  475.     extern struct inode_operations pipe_inode_operations;
  476.  
  477.     if (!(inode = get_empty_inode()))
  478.         return NULL;
  479.     if (!(PIPE_BASE(*inode) = (char*) __get_free_page(GFP_USER))) {
  480.         iput(inode);
  481.         return NULL;
  482.     }
  483.     inode->i_op = &pipe_inode_operations;
  484.     inode->i_count = 2;    /* sum of readers/writers */
  485.     PIPE_WAIT(*inode) = NULL;
  486.     PIPE_START(*inode) = PIPE_LEN(*inode) = 0;
  487.     PIPE_RD_OPENERS(*inode) = PIPE_WR_OPENERS(*inode) = 0;
  488.     PIPE_READERS(*inode) = PIPE_WRITERS(*inode) = 1;
  489.     PIPE_LOCK(*inode) = 0;
  490.     inode->i_pipe = 1;
  491.     inode->i_mode |= S_IFIFO | S_IRUSR | S_IWUSR;
  492.     inode->i_uid = current->fsuid;
  493.     inode->i_gid = current->fsgid;
  494.     inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
  495.     inode->i_blksize = PAGE_SIZE;
  496.     return inode;
  497. }
  498.  
  499. struct inode * __iget(struct super_block * sb, int nr, int crossmntp)
  500. {
  501.     static struct wait_queue * update_wait = NULL;
  502.     struct inode_hash_entry * h;
  503.     struct inode * inode;
  504.     struct inode * empty = NULL;
  505.  
  506.     if (!sb)
  507.         panic("VFS: iget with sb==NULL");
  508.     h = hash(sb->s_dev, nr);
  509. repeat:
  510.     for (inode = h->inode; inode ; inode = inode->i_hash_next)
  511.         if (inode->i_dev == sb->s_dev && inode->i_ino == nr)
  512.             goto found_it;
  513.     if (!empty) {
  514.         h->updating++;
  515.         empty = get_empty_inode();
  516.         if (!--h->updating)
  517.             wake_up(&update_wait);
  518.         if (empty)
  519.             goto repeat;
  520.         return (NULL);
  521.     }
  522.     inode = empty;
  523.     inode->i_sb = sb;
  524.     inode->i_dev = sb->s_dev;
  525.     inode->i_ino = nr;
  526.     inode->i_flags = sb->s_flags;
  527.     put_last_free(inode);
  528.     insert_inode_hash(inode);
  529.     read_inode(inode);
  530.     goto return_it;
  531.  
  532. found_it:
  533.     if (!inode->i_count)
  534.         nr_free_inodes--;
  535.     inode->i_count++;
  536.     wait_on_inode(inode);
  537.     if (inode->i_dev != sb->s_dev || inode->i_ino != nr) {
  538.         printk("Whee.. inode changed from under us. Tell Linus\n");
  539.         iput(inode);
  540.         goto repeat;
  541.     }
  542.     if (crossmntp && inode->i_mount) {
  543.         struct inode * tmp = inode->i_mount;
  544.         tmp->i_count++;
  545.         iput(inode);
  546.         inode = tmp;
  547.         wait_on_inode(inode);
  548.     }
  549.     if (empty)
  550.         iput(empty);
  551.  
  552. return_it:
  553.     while (h->updating)
  554.         sleep_on(&update_wait);
  555.     return inode;
  556. }
  557.  
  558. /*
  559.  * The "new" scheduling primitives (new as of 0.97 or so) allow this to
  560.  * be done without disabling interrupts (other than in the actual queue
  561.  * updating things: only a couple of 386 instructions). This should be
  562.  * much better for interrupt latency.
  563.  */
  564. static void __wait_on_inode(struct inode * inode)
  565. {
  566.     struct wait_queue wait = { current, NULL };
  567.  
  568.     add_wait_queue(&inode->i_wait, &wait);
  569. repeat:
  570.     current->state = TASK_UNINTERRUPTIBLE;
  571.     if (inode->i_lock) {
  572.         schedule();
  573.         goto repeat;
  574.     }
  575.     remove_wait_queue(&inode->i_wait, &wait);
  576.     current->state = TASK_RUNNING;
  577. }
  578.