オープンソース・ソフトウェアの開発とダウンロード

TOMOYO

Subversion リポジトリの参照

/[tomoyo]/trunk/1.6.x/ccs-patch/fs/realpath.c

Diff of /trunk/1.6.x/ccs-patch/fs/realpath.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

trunk/1.5.x/ccs-patch/fs/realpath.c revision 856 by kumaneko, Thu Jan 3 07:16:18 2008 UTC trunk/1.6.x/ccs-patch/fs/realpath.c revision 1064 by kumaneko, Fri Mar 28 05:06:28 2008 UTC
# Line 5  Line 5 
5   *   *
6   * Copyright (C) 2005-2008  NTT DATA CORPORATION   * Copyright (C) 2005-2008  NTT DATA CORPORATION
7   *   *
8   * Version: 1.5.3-pre   2008/01/03   * Version: 1.6.0-rc   2008/03/28
9   *   *
10   * This file is applicable to both 2.4.30 and 2.6.11 and later.   * This file is applicable to both 2.4.30 and 2.6.11 and later.
11   * See README.ccs for ChangeLog.   * See README.ccs for ChangeLog.
# Line 21  Line 21 
21  #include <asm/uaccess.h>  #include <asm/uaccess.h>
22  #include <asm/atomic.h>  #include <asm/atomic.h>
23  #include <linux/version.h>  #include <linux/version.h>
24  #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)  #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 0)
25  #include <linux/namei.h>  #include <linux/namei.h>
26  #include <linux/mount.h>  #include <linux/mount.h>
27  static const int lookup_flags = LOOKUP_FOLLOW;  static const int lookup_flags = LOOKUP_FOLLOW;
# Line 32  static const int lookup_flags = LOOKUP_F Line 32  static const int lookup_flags = LOOKUP_F
32  #include <linux/proc_fs.h>  #include <linux/proc_fs.h>
33  #include <linux/ccs_common.h>  #include <linux/ccs_common.h>
34    
35  extern int sbin_init_started;  /**
36     * get_absolute_path - Get the path of a dentry but ignores chroot'ed root.
37  /***** realpath handler *****/   *
38     * @dentry: Pointer to "struct dentry".
39  /*   * @vfsmnt: Pointer to "struct vfsmount".
40   * GetAbsolutePath - return the path of a dentry but ignores chroot'ed root.   * @buffer: Pointer to buffer to return value in.
41   * @dentry: dentry to report   * @buflen: Sizeof @buffer.
  * @vfsmnt: vfsmnt to which the dentry belongs  
  * @buffer: buffer to return value in  
  * @buflen: buffer length  
42   *   *
43   * Caller holds the dcache_lock.   * Returns 0 on success, -ENOMEM otherwise.
44     *
45     * Caller holds the dcache_lock and vfsmount_lock.
46   * Based on __d_path() in fs/dcache.c   * Based on __d_path() in fs/dcache.c
47   *   *
48   * If dentry is a directory, trailing '/' is appended.   * If dentry is a directory, trailing '/' is appended.
49   * Characters other than ' ' < c < 127 are converted to \ooo style octal string.   * Characters out of 0x20 < c < 0x7F range are converted to
50     * \ooo style octal string.
51   * Character \ is converted to \\ string.   * Character \ is converted to \\ string.
52   */   */
53  static int GetAbsolutePath(struct dentry *dentry, struct vfsmount *vfsmnt, char *buffer, int buflen)  static int get_absolute_path(struct dentry *dentry, struct vfsmount *vfsmnt,
54                                 char *buffer, int buflen)
55  {  {
56            /***** CRITICAL SECTION START *****/
57          char *start = buffer;          char *start = buffer;
58          char *end = buffer + buflen;          char *end = buffer + buflen;
59          bool is_dir = (dentry->d_inode && S_ISDIR(dentry->d_inode->i_mode));          bool is_dir = (dentry->d_inode && S_ISDIR(dentry->d_inode->i_mode));
60    
61          if (buflen < 256) goto out;          if (buflen < 256)
62                    goto out;
63    
64          *--end = '\0';          *--end = '\0';
65          buflen--;          buflen--;
# Line 66  static int GetAbsolutePath(struct dentry Line 69  static int GetAbsolutePath(struct dentry
69    
70                  if (dentry == vfsmnt->mnt_root || IS_ROOT(dentry)) {                  if (dentry == vfsmnt->mnt_root || IS_ROOT(dentry)) {
71                          /* Global root? */                          /* Global root? */
72  #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)                          if (vfsmnt->mnt_parent == vfsmnt)
                         spin_lock(&vfsmount_lock);  
 #endif  
                         if (vfsmnt->mnt_parent == vfsmnt) {  
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)  
                                 spin_unlock(&vfsmount_lock);  
 #endif  
73                                  break;                                  break;
                         }  
74                          dentry = vfsmnt->mnt_mountpoint;                          dentry = vfsmnt->mnt_mountpoint;
75                          vfsmnt = vfsmnt->mnt_parent;                          vfsmnt = vfsmnt->mnt_parent;
 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)  
                         spin_unlock(&vfsmount_lock);  
 #endif  
76                          continue;                          continue;
77                  }                  }
78                  if (is_dir) {                  if (is_dir) {
79                          is_dir = 0; *--end = '/'; buflen--;                          is_dir = false;
80                            *--end = '/';
81                            buflen--;
82                  }                  }
83                  parent = dentry->d_parent;                  parent = dentry->d_parent;
84                  {                  {
# Line 91  static int GetAbsolutePath(struct dentry Line 86  static int GetAbsolutePath(struct dentry
86                          const char *cp = sp + dentry->d_name.len - 1;                          const char *cp = sp + dentry->d_name.len - 1;
87                          unsigned char c;                          unsigned char c;
88    
89                          /* Exception: Use /proc/self/ rather than /proc/\$/ for current process. */                          /*
90                          if (IS_ROOT(parent) && *sp > '0' && *sp <= '9' && parent->d_sb && parent->d_sb->s_magic == PROC_SUPER_MAGIC) {                           * Exception: Use /proc/self/ rather than
91                             * /proc/\$/ for current process.
92                             */
93                            if (IS_ROOT(parent) && *sp > '0' && *sp <= '9' &&
94                                parent->d_sb &&
95                                parent->d_sb->s_magic == PROC_SUPER_MAGIC) {
96                                  char *ep;                                  char *ep;
97                                  const pid_t pid = (pid_t) simple_strtoul(sp, &ep, 10);                                  const pid_t pid
98  #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)                                          = (pid_t) simple_strtoul(sp, &ep, 10);
99                                  if (!*ep && pid == current->tgid) { sp = "self"; cp = sp + 3; }  #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 0)
100                                    if (!*ep && pid == current->tgid) {
101                                            sp = "self";
102                                            cp = sp + 3;
103                                    }
104  #else  #else
105                                  if (!*ep && pid == current->pid) { sp = "self"; cp = sp + 3; }                                  if (!*ep && pid == current->pid) {
106                                            sp = "self";
107                                            cp = sp + 3;
108                                    }
109  #endif  #endif
110                          }                          }
111    
112                          while (sp <= cp) {                          while (sp <= cp) {
113                                  c = * (unsigned char *) cp;                                  c = *(unsigned char *) cp;
114                                  if (c == '\\') {                                  if (c == '\\') {
115                                          buflen -= 2;                                          buflen -= 2;
116                                          if (buflen < 0) goto out;                                          if (buflen < 0)
117                                                    goto out;
118                                          *--end = '\\';                                          *--end = '\\';
119                                          *--end = '\\';                                          *--end = '\\';
120                                  } else if (c > ' ' && c < 127) {                                  } else if (c > ' ' && c < 127) {
121                                          if (--buflen < 0) goto out;                                          if (--buflen < 0)
122                                                    goto out;
123                                          *--end = (char) c;                                          *--end = (char) c;
124                                  } else {                                  } else {
125                                          buflen -= 4;                                          buflen -= 4;
126                                          if (buflen < 0) goto out;                                          if (buflen < 0)
127                                                    goto out;
128                                          *--end = (c & 7) + '0';                                          *--end = (c & 7) + '0';
129                                          *--end = ((c >> 3) & 7) + '0';                                          *--end = ((c >> 3) & 7) + '0';
130                                          *--end = (c >> 6) + '0';                                          *--end = (c >> 6) + '0';
# Line 122  static int GetAbsolutePath(struct dentry Line 132  static int GetAbsolutePath(struct dentry
132                                  }                                  }
133                                  cp--;                                  cp--;
134                          }                          }
135                          if (--buflen < 0) goto out;                          if (--buflen < 0)
136                                    goto out;
137                          *--end = '/';                          *--end = '/';
138                  }                  }
139                  dentry = parent;                  dentry = parent;
140          }          }
141          if (*end == '/') { buflen++; end++; }          if (*end == '/') {
142                    buflen++;
143                    end++;
144            }
145          {          {
146                  const char *sp = dentry->d_name.name;                  const char *sp = dentry->d_name.name;
147                  const char *cp = sp + dentry->d_name.len - 1;                  const char *cp = sp + dentry->d_name.len - 1;
148                  unsigned char c;                  unsigned char c;
149                  while (sp <= cp) {                  while (sp <= cp) {
150                          c = * (unsigned char *) cp;                          c = *(unsigned char *) cp;
151                          if (c == '\\') {                          if (c == '\\') {
152                                  buflen -= 2;                                  buflen -= 2;
153                                  if (buflen < 0) goto out;                                  if (buflen < 0)
154                                            goto out;
155                                  *--end = '\\';                                  *--end = '\\';
156                                  *--end = '\\';                                  *--end = '\\';
157                          } else if (c > ' ' && c < 127) {                          } else if (c > ' ' && c < 127) {
158                                  if (--buflen < 0) goto out;                                  if (--buflen < 0)
159                                            goto out;
160                                  *--end = (char) c;                                  *--end = (char) c;
161                          } else {                          } else {
162                                  buflen -= 4;                                  buflen -= 4;
163                                  if (buflen < 0) goto out;                                  if (buflen < 0)
164                                            goto out;
165                                  *--end = (c & 7) + '0';                                  *--end = (c & 7) + '0';
166                                  *--end = ((c >> 3) & 7) + '0';                                  *--end = ((c >> 3) & 7) + '0';
167                                  *--end = (c >> 6) + '0';                                  *--end = (c >> 6) + '0';
# Line 158  static int GetAbsolutePath(struct dentry Line 175  static int GetAbsolutePath(struct dentry
175          return 0;          return 0;
176   out:   out:
177          return -ENOMEM;          return -ENOMEM;
178            /***** CRITICAL SECTION END *****/
179  }  }
180    
181  /* Returns realpath(3) of the given dentry but ignores chroot'ed root. */  /**
182  int realpath_from_dentry2(struct dentry *dentry, struct vfsmount *mnt, char *newname, int newname_len)   * ccs_realpath_from_dentry2 - Returns realpath(3) of the given dentry but ignores chroot'ed root.
183     *
184     * @dentry:      Pointer to "struct dentry".
185     * @mnt:         Pointer to "struct vfsmount".
186     * @newname:     Pointer to buffer to return value in.
187     * @newname_len: Size of @newname.
188     *
189     * Returns 0 on success, negative value otherwise.
190     */
191    int ccs_realpath_from_dentry2(struct dentry *dentry, struct vfsmount *mnt,
192                                  char *newname, int newname_len)
193  {  {
194          int error;          int error;
195          struct dentry *d_dentry;          struct dentry *d_dentry;
196          struct vfsmount *d_mnt;          struct vfsmount *d_mnt;
197          if (!dentry || !mnt || !newname || newname_len <= 0) return -EINVAL;          if (!dentry || !mnt || !newname || newname_len <= 0)
198                    return -EINVAL;
199          d_dentry = dget(dentry);          d_dentry = dget(dentry);
200          d_mnt = mntget(mnt);          d_mnt = mntget(mnt);
201          /***** CRITICAL SECTION START *****/          /***** CRITICAL SECTION START *****/
202          spin_lock(&dcache_lock);          spin_lock(&dcache_lock);
203          error = GetAbsolutePath(d_dentry, d_mnt, newname, newname_len);  #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 0)
204            spin_lock(&vfsmount_lock);
205    #endif
206            error = get_absolute_path(d_dentry, d_mnt, newname, newname_len);
207    #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 0)
208            spin_unlock(&vfsmount_lock);
209    #endif
210          spin_unlock(&dcache_lock);          spin_unlock(&dcache_lock);
211          /***** CRITICAL SECTION END *****/          /***** CRITICAL SECTION END *****/
212          dput(d_dentry);          dput(d_dentry);
213          mntput(d_mnt);          mntput(d_mnt);
214            if (error)
215                    printk(KERN_WARNING "ccs_realpath: Pathname too long.\n");
216          return error;          return error;
217  }  }
218    
219  /* Returns realpath(3) of the given pathname but ignores chroot'ed root. */  /**
220  /* These functions use ccs_alloc(), so caller must ccs_free() if these functions didn't return NULL. */   * ccs_realpath_from_dentry - Returns realpath(3) of the given pathname but ignores chroot'ed root.
221  char *realpath_from_dentry(struct dentry *dentry, struct vfsmount *mnt)   *
222     * @dentry: Pointer to "struct dentry".
223     * @mnt:    Pointer to "struct vfsmount".
224     *
225     * Returns the realpath of the given @dentry and @mnt on success,
226     * NULL otherwise.
227     *
228     * These functions use ccs_alloc(), so caller must ccs_free()
229     * if these functions didn't return NULL.
230     */
231    char *ccs_realpath_from_dentry(struct dentry *dentry, struct vfsmount *mnt)
232  {  {
233          char *buf = ccs_alloc(CCS_MAX_PATHNAME_LEN);          char *buf = ccs_alloc(sizeof(struct ccs_page_buffer));
234          if (buf && realpath_from_dentry2(dentry, mnt, buf, CCS_MAX_PATHNAME_LEN - 1) == 0) return buf;          if (buf && ccs_realpath_from_dentry2(dentry, mnt, buf,
235                                                 CCS_MAX_PATHNAME_LEN - 1) == 0)
236                    return buf;
237          ccs_free(buf);          ccs_free(buf);
238          return NULL;          return NULL;
239  }  }
240    
241  char *realpath(const char *pathname)  /**
242     * ccs_realpath - Get realpath of a pathname.
243     *
244     * @pathname: The pathname to solve.
245     *
246     * Returns the realpath of @pathname on success, NULL otherwise.
247     */
248    char *ccs_realpath(const char *pathname)
249  {  {
250          struct nameidata nd;          struct nameidata nd;
251          if (pathname && path_lookup(pathname, lookup_flags, &nd) == 0) {          if (pathname && path_lookup(pathname, lookup_flags, &nd) == 0) {
252                  char *buf = realpath_from_dentry(nd.dentry, nd.mnt);  #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25)
253                    char *buf = ccs_realpath_from_dentry(nd.path.dentry,
254                                                         nd.path.mnt);
255                    path_put(&nd.path);
256    #else
257                    char *buf = ccs_realpath_from_dentry(nd.dentry, nd.mnt);
258                  path_release(&nd);                  path_release(&nd);
259    #endif
260                  return buf;                  return buf;
261          }          }
262          return NULL;          return NULL;
263  }  }
264    
265  char *realpath_nofollow(const char *pathname)  /**
266     * ccs_realpath_nofollow - Get realpath of a pathname.
267     *
268     * @pathname: The pathname to solve.
269     *
270     * Returns the realpath of @pathname on success, NULL otherwise.
271     */
272    char *ccs_realpath_nofollow(const char *pathname)
273  {  {
274          struct nameidata nd;          struct nameidata nd;
275          if (pathname && path_lookup(pathname, lookup_flags ^ LOOKUP_FOLLOW, &nd) == 0) {          if (pathname && path_lookup(pathname, lookup_flags ^ LOOKUP_FOLLOW,
276                  char *buf = realpath_from_dentry(nd.dentry, nd.mnt);                                      &nd) == 0) {
277    #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 25)
278                    char *buf = ccs_realpath_from_dentry(nd.path.dentry,
279                                                         nd.path.mnt);
280                    path_put(&nd.path);
281    #else
282                    char *buf = ccs_realpath_from_dentry(nd.dentry, nd.mnt);
283                  path_release(&nd);                  path_release(&nd);
284    #endif
285                  return buf;                  return buf;
286          }          }
287          return NULL;          return NULL;
288  }  }
289    
290  /***** Private memory allocator. *****/  /**
291     * round_up - Round up an integer so that the returned pointers are appropriately aligned.
292  /*   *
293   * Round up an integer so that the returned pointers are appropriately aligned.   * @size: Size in bytes.
294   * FIXME: Are there more requirements that is needed for assigning value atomically?   *
295   */   * Returns rounded value of @size.
296  static inline unsigned int ROUNDUP(const unsigned int size) {   *
297          if (sizeof(void *) >= sizeof(long)) {   * FIXME: Are there more requirements that is needed for assigning value
298                  return ((size + sizeof(void *) - 1) / sizeof(void *)) * sizeof(void *);   * atomically?
299          } else {   */
300                  return ((size + sizeof(long) - 1) / sizeof(long)) * sizeof(long);  static inline unsigned int round_up(const unsigned int size)
301          }  {
302            if (sizeof(void *) >= sizeof(long))
303                    return ((size + sizeof(void *) - 1)
304                            / sizeof(void *)) * sizeof(void *);
305            else
306                    return ((size + sizeof(long) - 1)
307                            / sizeof(long)) * sizeof(long);
308  }  }
309    
310  static unsigned int allocated_memory_for_elements = 0;  static unsigned int allocated_memory_for_elements;
311    
312  unsigned int GetMemoryUsedForElements(void)  /**
313     * ccs_get_memory_used_for_elements - Get memory used for keeping ACL structures.
314     *
315     * Returns memory used for keeping ACL structures.
316     */
317    unsigned int ccs_get_memory_used_for_elements(void)
318  {  {
319          return allocated_memory_for_elements;          return allocated_memory_for_elements;
320  }  }
321    
322  /* Allocate memory for structures. The RAM is chunked, so NEVER try to kfree() the returned pointer. */  /**
323  void *alloc_element(const unsigned int size)   * ccs_alloc_element - Allocate permanent memory for structures.
324     *
325     * @size: Size in bytes.
326     *
327     * Returns pointer to allocated memory on success, NULL otherwise.
328     *
329     * The RAM is chunked, so NEVER try to kfree() the returned pointer.
330     */
331    void *ccs_alloc_element(const unsigned int size)
332  {  {
333          static DEFINE_MUTEX(lock);          static DEFINE_MUTEX(lock);
334          static char *buf = NULL;          static char *buf;
335          static unsigned int buf_used_len = PAGE_SIZE;          static unsigned int buf_used_len = PAGE_SIZE;
336          char *ptr = NULL;          char *ptr = NULL;
337          const unsigned int word_aligned_size = ROUNDUP(size);          const unsigned int word_aligned_size = round_up(size);
338          if (word_aligned_size > PAGE_SIZE) return NULL;          if (word_aligned_size > PAGE_SIZE)
339                    return NULL;
340          mutex_lock(&lock);          mutex_lock(&lock);
341          if (buf_used_len + word_aligned_size > PAGE_SIZE) {          if (buf_used_len + word_aligned_size > PAGE_SIZE) {
342                  if ((ptr = kmalloc(PAGE_SIZE, GFP_KERNEL)) == NULL) {                  ptr = kzalloc(PAGE_SIZE, GFP_KERNEL);
343                          printk("ERROR: Out of memory for alloc_element().\n");                  if (!ptr) {
344                          if (!sbin_init_started) panic("MAC Initialization failed.\n");                          printk(KERN_WARNING "ERROR: Out of memory "
345                                   "for ccs_alloc_element().\n");
346                            if (!sbin_init_started)
347                                    panic("MAC Initialization failed.\n");
348                  } else {                  } else {
                         memset(ptr, 0, PAGE_SIZE);  
349                          buf = ptr;                          buf = ptr;
350                          allocated_memory_for_elements += PAGE_SIZE;                          allocated_memory_for_elements += PAGE_SIZE;
351                          buf_used_len = word_aligned_size;                          buf_used_len = word_aligned_size;
# Line 258  void *alloc_element(const unsigned int s Line 356  void *alloc_element(const unsigned int s
356                  ptr = buf + buf_used_len;                  ptr = buf + buf_used_len;
357                  buf_used_len += word_aligned_size;                  buf_used_len += word_aligned_size;
358                  for (i = 0; i < word_aligned_size; i++) {                  for (i = 0; i < word_aligned_size; i++) {
359                          if (ptr[i]) {                          if (!ptr[i])
360                                  printk(KERN_ERR "WARNING: Reserved memory was tainted! The system might go wrong.\n");                                  continue;
361                                  ptr[i] = '\0';                          printk(KERN_ERR "WARNING: Reserved memory was tainted! "
362                          }                                 "The system might go wrong.\n");
363                            ptr[i] = '\0';
364                  }                  }
365          }          }
366          mutex_unlock(&lock);          mutex_unlock(&lock);
367          return ptr;          return ptr;
368  }  }
369    
370  /***** Shared memory allocator. *****/  static unsigned int allocated_memory_for_savename;
   
 static unsigned int allocated_memory_for_savename = 0;  
371    
372  unsigned int GetMemoryUsedForSaveName(void)  /**
373     * ccs_get_memory_used_for_save_name - Get memory used for keeping string data.
374     *
375     * Returns memory used for keeping string data.
376     */
377    unsigned int ccs_get_memory_used_for_save_name(void)
378  {  {
379          return allocated_memory_for_savename;          return allocated_memory_for_savename;
380  }  }
381    
382  #define MAX_HASH 256  #define MAX_HASH 256
383    
384    /* Structure for string data. */
385  struct name_entry {  struct name_entry {
386          struct list1_head list;          struct list1_head list;
387          struct path_info entry;          struct path_info entry;
388  };  };
389    
390    /* Structure for available memory region. */
391  struct free_memory_block_list {  struct free_memory_block_list {
392          struct list_head list;          struct list_head list;
393          char *ptr;                           /* Pointer to a free area.               */          char *ptr;             /* Pointer to a free area. */
394          int len;                             /* Length of the area.                   */          int len;               /* Length of the area.     */
395  };  };
396    
397  static struct list1_head name_list[MAX_HASH]; /* The list of names. */  /* The list for "struct name_entry". */
398    static struct list1_head name_list[MAX_HASH];
399    
400  /* Keep the given name on the RAM. The RAM is shared, so NEVER try to modify or kfree() the returned name. */  /**
401  const struct path_info *SaveName(const char *name)   * ccs_save_name - Allocate permanent memory for string data.
402     *
403     * @name: The string to store into the permernent memory.
404     *
405     * Returns pointer to "struct path_info" on success, NULL otherwise.
406     *
407     * The RAM is shared, so NEVER try to modify or kfree() the returned name.
408     */
409    const struct path_info *ccs_save_name(const char *name)
410  {  {
411          static LIST_HEAD(fmb_list);          static LIST_HEAD(fmb_list);
412          static DEFINE_MUTEX(lock);          static DEFINE_MUTEX(lock);
# Line 302  const struct path_info *SaveName(const c Line 415  const struct path_info *SaveName(const c
415          struct free_memory_block_list *fmb;          struct free_memory_block_list *fmb;
416          int len;          int len;
417          char *cp;          char *cp;
418          if (!name) return NULL;          if (!name)
419                    return NULL;
420          len = strlen(name) + 1;          len = strlen(name) + 1;
421          if (len > CCS_MAX_PATHNAME_LEN) {          if (len > CCS_MAX_PATHNAME_LEN) {
422                  printk("ERROR: Name too long for SaveName().\n");                  printk(KERN_WARNING "ERROR: Name too long "
423                           "for ccs_save_name().\n");
424                  return NULL;                  return NULL;
425          }          }
426          hash = full_name_hash((const unsigned char *) name, len - 1);          hash = full_name_hash((const unsigned char *) name, len - 1);
427          mutex_lock(&lock);          mutex_lock(&lock);
428          list1_for_each_entry(ptr, &name_list[hash % MAX_HASH], list) {          list1_for_each_entry(ptr, &name_list[hash % MAX_HASH], list) {
429                  if (hash == ptr->entry.hash && strcmp(name, ptr->entry.name) == 0) goto out;                  if (hash == ptr->entry.hash && !strcmp(name, ptr->entry.name))
430                            goto out;
431          }          }
432          list_for_each_entry(fmb, &fmb_list, list) {          list_for_each_entry(fmb, &fmb_list, list) {
433                  if (len <= fmb->len) goto ready;                  if (len <= fmb->len)
434                            goto ready;
435          }          }
436          cp = kmalloc(PAGE_SIZE, GFP_KERNEL);          cp = kzalloc(PAGE_SIZE, GFP_KERNEL);
437          fmb = kmalloc(sizeof(*fmb), GFP_KERNEL);          fmb = kzalloc(sizeof(*fmb), GFP_KERNEL);
438          if (!cp || !fmb) {          if (!cp || !fmb) {
439                  kfree(cp);                  kfree(cp);
440                  kfree(fmb);                  kfree(fmb);
441                  printk("ERROR: Out of memory for SaveName().\n");                  printk(KERN_WARNING "ERROR: Out of memory "
442                  if (!sbin_init_started) panic("MAC Initialization failed.\n");                         "for ccs_save_name().\n");
443                    if (!sbin_init_started)
444                            panic("MAC Initialization failed.\n");
445                  ptr = NULL;                  ptr = NULL;
446                  goto out;                  goto out;
447          }          }
         memset(cp, 0, PAGE_SIZE);  
448          allocated_memory_for_savename += PAGE_SIZE;          allocated_memory_for_savename += PAGE_SIZE;
449          list_add(&fmb->list, &fmb_list);          list_add(&fmb->list, &fmb_list);
450          fmb->ptr = cp;          fmb->ptr = cp;
451          fmb->len = PAGE_SIZE;          fmb->len = PAGE_SIZE;
452   ready:   ready:
453          ptr = alloc_element(sizeof(*ptr));          ptr = ccs_alloc_element(sizeof(*ptr));
454          if (!ptr) goto out;          if (!ptr)
455                    goto out;
456          ptr->entry.name = fmb->ptr;          ptr->entry.name = fmb->ptr;
457          memmove(fmb->ptr, name, len);          memmove(fmb->ptr, name, len);
458          fill_path_info(&ptr->entry);          ccs_fill_path_info(&ptr->entry);
459          fmb->ptr += len;          fmb->ptr += len;
460          fmb->len -= len;          fmb->len -= len;
461          list1_add_tail_mb(&ptr->list, &name_list[hash % MAX_HASH]);          list1_add_tail_mb(&ptr->list, &name_list[hash % MAX_HASH]);
# Line 349  const struct path_info *SaveName(const c Line 468  const struct path_info *SaveName(const c
468          return ptr ? &ptr->entry : NULL;          return ptr ? &ptr->entry : NULL;
469  }  }
470    
471  /***** Dynamic memory allocator. *****/  /* Structure for temporarily allocated memory. */
   
472  struct cache_entry {  struct cache_entry {
473          struct list_head list;          struct list_head list;
474          void *ptr;          void *ptr;
475          int size;          int size;
476  };  };
477    
478  #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,20)  #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 20)
479  static struct kmem_cache *ccs_cachep = NULL;  static struct kmem_cache *ccs_cachep;
480  #else  #else
481  static kmem_cache_t *ccs_cachep = NULL;  static kmem_cache_t *ccs_cachep;
482  #endif  #endif
483    
484  void __init realpath_Init(void)  /**
485     * ccs_realpath_init - Initialize realpath related code.
486     *
487     * Returns 0.
488     */
489    static int __init ccs_realpath_init(void)
490  {  {
491          int i;          int i;
492  #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,23)          if (CCS_MAX_PATHNAME_LEN > PAGE_SIZE)
493          ccs_cachep = kmem_cache_create("ccs_cache", sizeof(struct cache_entry), 0, 0, NULL);                  panic("Bad size.");
494    #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 6, 23)
495            ccs_cachep = kmem_cache_create("ccs_cache", sizeof(struct cache_entry),
496                                           0, 0, NULL);
497  #else  #else
498          ccs_cachep = kmem_cache_create("ccs_cache", sizeof(struct cache_entry), 0, 0, NULL, NULL);          ccs_cachep = kmem_cache_create("ccs_cache", sizeof(struct cache_entry),
499                                           0, 0, NULL, NULL);
500  #endif  #endif
501          if (!ccs_cachep) panic("Can't create cache.\n");          if (!ccs_cachep)
502          for (i = 0; i < MAX_HASH; i++) {                  panic("Can't create cache.\n");
503            for (i = 0; i < MAX_HASH; i++)
504                  INIT_LIST1_HEAD(&name_list[i]);                  INIT_LIST1_HEAD(&name_list[i]);
         }  
         if (CCS_MAX_PATHNAME_LEN > PAGE_SIZE) panic("Bad size.");  
505          INIT_LIST1_HEAD(&KERNEL_DOMAIN.acl_info_list);          INIT_LIST1_HEAD(&KERNEL_DOMAIN.acl_info_list);
506          KERNEL_DOMAIN.domainname = SaveName(ROOT_NAME);          KERNEL_DOMAIN.domainname = ccs_save_name(ROOT_NAME);
507          list1_add_tail_mb(&KERNEL_DOMAIN.list, &domain_list);          list1_add_tail_mb(&KERNEL_DOMAIN.list, &domain_list);
508          if (FindDomain(ROOT_NAME) != &KERNEL_DOMAIN) panic("Can't register KERNEL_DOMAIN");          if (ccs_find_domain(ROOT_NAME) != &KERNEL_DOMAIN)
509                    panic("Can't register KERNEL_DOMAIN");
510            return 0;
511  }  }
512    
513    __initcall(ccs_realpath_init);
514    
515    /* The list for "struct cache_entry". */
516  static LIST_HEAD(cache_list);  static LIST_HEAD(cache_list);
 static spinlock_t cache_list_lock = SPIN_LOCK_UNLOCKED;  
 static unsigned int dynamic_memory_size = 0;  
517    
518  unsigned int GetMemoryUsedForDynamic(void)  static DEFINE_SPINLOCK(cache_list_lock);
519    
520    static unsigned int dynamic_memory_size;
521    
522    /**
523     * ccs_get_memory_used_for_dynamic - Get memory used for temporal purpose.
524     *
525     * Returns memory used for temporal purpose.
526     */
527    unsigned int ccs_get_memory_used_for_dynamic(void)
528  {  {
529          return dynamic_memory_size;          return dynamic_memory_size;
530  }  }
531    
532  #if LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)  #if LINUX_VERSION_CODE < KERNEL_VERSION(2, 5, 0)
533    /**
534     * round2 - Rounded up to power-of-two value.
535     *
536     * @size: Size in bytes.
537     *
538     * Returns power-of-two of @size.
539     */
540  static int round2(size_t size)  static int round2(size_t size)
541  {  {
542  #if PAGE_SIZE == 4096  #if PAGE_SIZE == 4096
# Line 399  static int round2(size_t size) Line 544  static int round2(size_t size)
544  #else  #else
545          size_t bsize = 64;          size_t bsize = 64;
546  #endif  #endif
547          while (size > bsize) bsize <<= 1;          while (size > bsize)
548                    bsize <<= 1;
549          return bsize;          return bsize;
550  }  }
551  #endif  #endif
552    
553    /**
554     * ccs_alloc - Allocate memory for temporal purpose.
555     *
556     * @size: Size in bytes.
557     *
558     * Returns pointer to allocated memory on success, NULL otherwise.
559     */
560  void *ccs_alloc(const size_t size)  void *ccs_alloc(const size_t size)
561  {  {
562          void *ret = kmalloc(size, GFP_KERNEL);          struct cache_entry *new_entry;
563          if (ret) {          void *ret = kzalloc(size, GFP_KERNEL);
564                  struct cache_entry *new_entry = kmem_cache_alloc(ccs_cachep, GFP_KERNEL);          if (!ret)
565                  if (!new_entry) {                  goto out;
566                          kfree(ret); ret = NULL;          new_entry = kmem_cache_alloc(ccs_cachep, GFP_KERNEL);
567                  } else {          if (!new_entry) {
568                          INIT_LIST_HEAD(&new_entry->list);                  kfree(ret);
569                          new_entry->ptr = ret;                  ret = NULL;
570  #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0)                  goto out;
571                          new_entry->size = ksize(ret);          }
572            INIT_LIST_HEAD(&new_entry->list);
573            new_entry->ptr = ret;
574    #if LINUX_VERSION_CODE >= KERNEL_VERSION(2, 5, 0)
575            new_entry->size = ksize(ret);
576  #else  #else
577                          new_entry->size = round2(size);          new_entry->size = round2(size);
578  #endif  #endif
579                          spin_lock(&cache_list_lock);          /***** CRITICAL SECTION START *****/
580                          list_add_tail(&new_entry->list, &cache_list);          spin_lock(&cache_list_lock);
581                          dynamic_memory_size += new_entry->size;          list_add_tail(&new_entry->list, &cache_list);
582                          spin_unlock(&cache_list_lock);          dynamic_memory_size += new_entry->size;
583                          memset(ret, 0, size);          spin_unlock(&cache_list_lock);
584                  }          /***** CRITICAL SECTION END *****/
585          }   out:
586          return ret;          return ret;
587  }  }
588    
589    /**
590     * ccs_free - Release memory allocated by ccs_alloc().
591     *
592     * @p: Pointer returned by ccs_alloc(). May be NULL.
593     *
594     * Returns nothing.
595     */
596  void ccs_free(const void *p)  void ccs_free(const void *p)
597  {  {
598          struct list_head *v;          struct list_head *v;
599          struct cache_entry *entry = NULL;          struct cache_entry *entry = NULL;
600          if (!p) return;          if (!p)
601                    return;
602            /***** CRITICAL SECTION START *****/
603          spin_lock(&cache_list_lock);          spin_lock(&cache_list_lock);
604          list_for_each(v, &cache_list) {          list_for_each(v, &cache_list) {
605                  entry = list_entry(v, struct cache_entry, list);                  entry = list_entry(v, struct cache_entry, list);
606                  if (entry->ptr != p) {                  if (entry->ptr != p) {
607                          entry = NULL; continue;                          entry = NULL;
608                            continue;
609                  }                  }
610                  list_del(&entry->list);                  list_del(&entry->list);
611                  dynamic_memory_size -= entry->size;                  dynamic_memory_size -= entry->size;
612                  break;                  break;
613          }          }
614          spin_unlock(&cache_list_lock);          spin_unlock(&cache_list_lock);
615            /***** CRITICAL SECTION END *****/
616          if (entry) {          if (entry) {
617                  kfree(p);                  kfree(p);
618                  kmem_cache_free(ccs_cachep, entry);                  kmem_cache_free(ccs_cachep, entry);
619          } else {          } else {
620                  printk("BUG: ccs_free() with invalid pointer.\n");                  printk(KERN_WARNING "BUG: ccs_free() with invalid pointer.\n");
621          }          }
622  }  }
Legend:
Removed from v.856  
changed lines
  Added in v.1064
Back to OSDN">Back to OSDN
 ViewVC Help
Powered by ViewVC 1.1.26  
サイト情報
ソフトウェアを探す
ソフトウェアを作る
コミュニティ
ヘルプ