-static inline void

-affs_set_blocksize(struct super_block *sb, int size)

-{

- sb_set_blocksize(sb, size);

-}

- affs_set_blocksize(sb, PAGE_SIZE);

- affs_set_blocksize(sb, blocksize);

- sb_set_blocksize(sb, (ulong) befs_sb->block_size);

- sb_set_blocksize(s, BFS_BSIZE);

- if (WARN_ON(!inode))

- if (WARN_ON(!inode))

- if (icount_read(&inode->vfs_inode) > 1)

- count = icount_read(inode);

- err = cn_printf(cn, "%d",

- __get_dumpable(cprm->mm_flags));

-/* cprm->mm_flags contains a stable snapshot of dumpability flags. */

- return __get_dumpable(cprm->mm_flags) == SUID_DUMP_ROOT;

- if (!__get_dumpable(cprm->mm_flags))

- /*

- * We must use the same mm->flags while dumping core to avoid

- * inconsistency of bit flags, since this flag is not protected

- * by any locks.

- *

- * Note that we only care about MMF_DUMP* flags.

- */

- .mm_flags = __mm_flags_get_dumpable(mm),

- if (suid_dumpable == SUID_DUMP_ROOT &&

- validate_coredump_safety();

- WARN_ON(d_really_is_positive(dentry));

-#define D_FLAG_VERIFY(dentry,x) WARN_ON_ONCE(((dentry)->d_flags & (DCACHE_LRU_LIST | DCACHE_SHRINK_LIST)) != (x))

- size_t size = offsetof(struct external_name, name[1]);

- struct external_name *p = kmalloc(size + name->len,

- GFP_KERNEL_ACCOUNT |

- __GFP_RECLAIMABLE);

- * LOCKING:

- * There are three level of locking required by epoll :

- * 1) epnested_mutex (mutex)

- * 2) ep->mtx (mutex)

- * 3) ep->lock (spinlock)

- * The acquire order is the one listed above, from 1 to 3.

- * We need a spinlock (ep->lock) because we manipulate objects

- * from inside the poll callback, that might be triggered from

- * a wake_up() that in turn might be called from IRQ context.

- * So we can't sleep inside the poll callback and hence we need

- * a spinlock. During the event transfer loop (from kernel to

- * user space) we could end up sleeping due a copy_to_user(), so

- * we need a lock that will allow us to sleep. This lock is a

- * mutex (ep->mtx). It is acquired during the event transfer loop,

- * during epoll_ctl(EPOLL_CTL_DEL) and during eventpoll_release_file().

- * The epnested_mutex is acquired when inserting an epoll fd onto another

- * epoll fd. We do this so that we walk the epoll tree and ensure that this

- * insertion does not create a cycle of epoll file descriptors, which

- * could lead to deadlock. We need a global mutex to prevent two

- * simultaneous inserts (A into B and B into A) from racing and

- * constructing a cycle without either insert observing that it is

- * going to.

- * It is necessary to acquire multiple "ep->mtx"es at once in the

- * case when one epoll fd is added to another. In this case, we

- * always acquire the locks in the order of nesting (i.e. after

- * epoll_ctl(e1, EPOLL_CTL_ADD, e2), e1->mtx will always be acquired

- * before e2->mtx). Since we disallow cycles of epoll file

- * descriptors, this ensures that the mutexes are well-ordered. In

- * order to communicate this nesting to lockdep, when walking a tree

- * of epoll file descriptors, we use the current recursion depth as

- * the lockdep subkey.

- * It is possible to drop the "ep->mtx" and to use the global

- * mutex "epnested_mutex" (together with "ep->lock") to have it working,

- * but having "ep->mtx" will make the interface more scalable.

- * Events that require holding "epnested_mutex" are very rare, while for

- * normal operations the epoll private "ep->mtx" will guarantee

- * a better scalability.

-struct epoll_filefd {

- struct file *file;

- int fd;

-} __packed;

-

- /* List header used to link this structure to the eventpoll ready list */

- * Works together "struct eventpoll"->ovflist in keeping the

- * single linked chain of items.

- struct epitem *next;

- struct epoll_filefd ffd;

-/* Used for cycles detection */

-

-/* Used to check for epoll file descriptor inclusion loops */

-static struct eventpoll *inserting_into;

- * List of files with newly added links, where we may need to limit the number

- * of emanating paths. Protected by the epnested_mutex.

-static struct epitems_head *tfile_check_list = EP_UNACTIVE_PTR;

-static void list_file(struct file *file)

- head->next = tfile_check_list;

- tfile_check_list = head;

-static inline int is_file_epoll(struct file *f)

-/* Setup the structure that is used as key for the RB tree */

-static inline void ep_set_ffd(struct epoll_filefd *ffd,

- struct file *file, int fd)

-{

- ffd->file = file;

- ffd->fd = fd;

-}

-

-static inline int ep_cmp_ffd(struct epoll_filefd *p1,

- struct epoll_filefd *p2)

-/* Tells us if the item is currently linked */

-static inline int ep_is_linked(struct epitem *epi)

-/**

- * ep_events_available - Checks if ready events might be available.

- *

- * @ep: Pointer to the eventpoll context.

- *

- * Return: a value different than %zero if ready events are available,

- * or %zero otherwise.

-static inline int ep_events_available(struct eventpoll *ep)

- return !list_empty_careful(&ep->rdllist) ||

- READ_ONCE(ep->ovflist) != EP_UNACTIVE_PTR;

- * If it is cleared by POLLFREE, it should be rcu-safe.

- * If we read NULL we need a barrier paired with

- * smp_store_release() in ep_poll_callback(), otherwise

- * we rely on whead->lock.

-static void ep_start_scan(struct eventpoll *ep, struct list_head *txlist)

- list_splice_init(&ep->rdllist, txlist);

- WRITE_ONCE(ep->ovflist, NULL);

- struct list_head *txlist)

- for (nepi = READ_ONCE(ep->ovflist); (epi = nepi) != NULL;

- nepi = epi->next, epi->next = EP_UNACTIVE_PTR) {

- * We need to check if the item is already in the list.

- * During the "sproc" callback execution time, items are

- * queued into ->ovflist but the "txlist" might already

- * contain them, and the list_splice() below takes care of them.

- * ->ovflist is LIFO, so we have to reverse it in order

- * to keep in FIFO.

- /*

- * We need to set back ep->ovflist to EP_UNACTIVE_PTR, so that after

- * releasing the lock, events will be queued in the normal way inside

- * ep->rdllist.

- */

- WRITE_ONCE(ep->ovflist, EP_UNACTIVE_PTR);

- * Quickly re-inject items left on "txlist".

- list_splice(txlist, &ep->rdllist);

- * Returns true if the event poll can be disposed

-static bool ep_refcount_dec_and_test(struct eventpoll *ep)

- * The ffd.file pointer may be in the process of being torn down due to

- * being closed, but we may not have finished eventpoll_release() yet.

- *

- * Normally, even with the atomic_long_inc_not_zero, the file may have

- * been free'd and then gotten re-allocated to something else (since

- * files are not RCU-delayed, they are SLAB_TYPESAFE_BY_RCU).

- * But for epoll, users hold the ep->mtx mutex, and as such any file in

- * the process of being free'd will block in eventpoll_release_file()

- * and thus the underlying file allocation will not be free'd, and the

- * file re-use cannot happen.

- * For the same reason we can avoid a rcu_read_lock() around the

- * operation - 'ffd.file' cannot go away even if the refcount has

- * reached zero (but we must still not call out to ->poll() functions

- * etc).

- /* See eventpoll_release() for details. */

- WARN_ON_ONCE(ep_refcount_dec_and_test(ep));

-static void ep_clear_and_put(struct eventpoll *ep)

- struct rb_node *rbp, *next;

- /* We need to release all tasks waiting for these file */

- if (waitqueue_active(&ep->poll_wait))

- ep_poll_safewake(ep, NULL, 0);

-

- mutex_lock(&ep->mtx);

- /*

- * Walks through the whole tree by unregistering poll callbacks.

- */

- /*

- * Walks through the whole tree and try to free each "struct epitem".

- * Note that ep_remove() will not remove the epitem in case of a

- * racing eventpoll_release_file(); the latter will do the removal.

- * At this point we are sure no poll callbacks will be lingering around.

- * Since we still own a reference to the eventpoll struct, the loop can't

- * dispose it.

- */

- if (ep_refcount_dec_and_test(ep))

- LIST_HEAD(txlist);

- ep_start_scan(ep, &txlist);

- list_for_each_entry_safe(epi, tmp, &txlist, rdllink) {

- ep_done_scan(ep, &txlist);

- if (ep_refcount_dec_and_test(ep))

- ep->ovflist = EP_UNACTIVE_PTR;

-static struct epitem *ep_find(struct eventpoll *ep, struct file *file, int fd)

- struct epoll_filefd ffd;

- ep_set_ffd(&ffd, file, fd);

- kcmp = ep_cmp_ffd(&ffd, &epi->ffd);

-#ifdef CONFIG_KCMP

-static struct epitem *ep_find_tfd(struct eventpoll *ep, int tfd, unsigned long toff)

-{

- struct rb_node *rbp;

- struct epitem *epi;

-

- for (rbp = rb_first_cached(&ep->rbr); rbp; rbp = rb_next(rbp)) {

- epi = rb_entry(rbp, struct epitem, rbn);

- if (epi->ffd.fd == tfd) {

- if (toff == 0)

- return epi;

- else

- toff--;

- }

- cond_resched();

- }

-

- return NULL;

-}

-

-struct file *get_epoll_tfile_raw_ptr(struct file *file, int tfd,

- unsigned long toff)

-{

- struct file *file_raw;

- struct eventpoll *ep;

- struct epitem *epi;

-

- if (!is_file_epoll(file))

- return ERR_PTR(-EINVAL);

-

- ep = file->private_data;

-

- mutex_lock(&ep->mtx);

- epi = ep_find_tfd(ep, tfd, toff);

- if (epi)

- file_raw = epi->ffd.file;

- else

- file_raw = ERR_PTR(-ENOENT);

- mutex_unlock(&ep->mtx);

-

- return file_raw;

-}

-#endif /* CONFIG_KCMP */

-

- if (READ_ONCE(ep->ovflist) != EP_UNACTIVE_PTR) {

- if (epi->next == EP_UNACTIVE_PTR) {

- epi->next = READ_ONCE(ep->ovflist);

- * If we race with ep_remove_wait_queue() it can miss

- * ->whead = NULL and do another remove_wait_queue() after

- * us, so we can't use __remove_wait_queue().

- /*

- * ->whead != NULL protects us from the race with

- * ep_clear_and_put() or ep_remove(), ep_remove_wait_queue()

- * takes whead->lock held by the caller. Once we nullify it,

- * nothing protects ep/epi or even wait.

- */

-#define PATH_ARR_SIZE 5

- * These are the number paths of length 1 to 5, that we are allowing to emanate

- * from a single file of interest. For example, we allow 1000 paths of length

- * 1, to emanate from each file of interest. This essentially represents the

- * potential wakeup paths, which need to be limited in order to avoid massive

- * uncontrolled wakeup storms. The common use case should be a single ep which

- * is connected to n file sources. In this case each file source has 1 path

- * of length 1. Thus, the numbers below should be more than sufficient. These

- * path limits are enforced during an EPOLL_CTL_ADD operation, since a modify

- * and delete can't add additional paths. Protected by the epnested_mutex.

-static int path_count[PATH_ARR_SIZE];

-static int path_count_inc(int nests)

- if (++path_count[nests] > path_limits[nests])

-static void path_count_init(void)

- path_count[i] = 0;

-static int reverse_path_check_proc(struct hlist_head *refs, int depth)

- error = path_count_inc(depth);

- error = reverse_path_check_proc(refs, depth + 1);

- * reverse_path_check - The tfile_check_list is list of epitem_head, which have

- * links that are proposed to be newly added. We need to

- * make sure that those added links don't add too many

- * paths such that we will spend all our time waking up

- * eventpoll objects.

-static int reverse_path_check(void)

- for (p = tfile_check_list; p != EP_UNACTIVE_PTR; p = p->next) {

- path_count_init();

- error = reverse_path_check_proc(&p->epitems, 0);

-static int attach_epitem(struct file *file, struct epitem *epi)

- * Must be called with "mtx" held.

-static int ep_insert(struct eventpoll *ep, const struct epoll_event *event,

- struct file *tfile, int fd, int full_check)

- int error, pwake = 0;

- __poll_t revents;

- struct ep_pqueue epq;

- struct eventpoll *tep = NULL;

-

- if (is_file_epoll(tfile))

- tep = tfile->private_data;

-

- lockdep_assert_irqs_enabled();

- return -ENOSPC;

- if (!(epi = kmem_cache_zalloc(epi_cache, GFP_KERNEL))) {

- return -ENOMEM;

- /* Item initialization follow here ... */

- ep_set_ffd(&epi->ffd, tfile, fd);

- epi->next = EP_UNACTIVE_PTR;

- /* Add the current item to the list of active epoll hook for this file */

- if (unlikely(attach_epitem(tfile, epi) < 0)) {

- return -ENOMEM;

- list_file(tfile);

- /*

- * Add the current item to the RB tree. All RB tree operations are

- * protected by "mtx", and ep_insert() is called with "mtx" held.

- */

- /*

- * ep_remove() calls in the later error paths can't lead to

- * ep_free() as the ep file itself still holds an ep reference.

- */

- /* now check if we've created too many backpaths */

- if (unlikely(full_check && reverse_path_check())) {

- /*

- * We have to check if something went wrong during the poll wait queue

- * install process. Namely an allocation for a wait queue failed due

- * high memory pressure.

- */

- /* We have to drop the new item inside our item list to keep track of it */

- /* record NAPI ID of new item if present */

- /* If the file is already "ready" we drop it inside the ready list */

- /* Notify waiting tasks that events are available */

- LIST_HEAD(txlist);

- ep_start_scan(ep, &txlist);

- * We can loop without lock because we are passed a task private list.

- * Items cannot vanish during the loop we are holding ep->mtx.

- list_for_each_entry_safe(epi, tmp, &txlist, rdllink) {

- struct wakeup_source *ws;

- __poll_t revents;

- /*

- * Activate ep->ws before deactivating epi->ws to prevent

- * triggering auto-suspend here (in case we reactive epi->ws

- * below).

- *

- * This could be rearranged to delay the deactivation of epi->ws

- * instead, but then epi->ws would temporarily be out of sync

- * with ep_is_linked().

- */

- ws = ep_wakeup_source(epi);

- if (ws) {

- if (ws->active)

- __pm_stay_awake(ep->ws);

- __pm_relax(ws);

- }

-

- list_del_init(&epi->rdllink);

-

- /*

- * If the event mask intersect the caller-requested one,

- * deliver the event to userspace. Again, we are holding ep->mtx,

- * so no operations coming from userspace can change the item.

- */

- revents = ep_item_poll(epi, &pt, 1);

- if (!revents)

- continue;

-

- events = epoll_put_uevent(revents, epi->event.data, events);

- if (!events) {

- list_add(&epi->rdllink, &txlist);

- ep_pm_stay_awake(epi);

- res = -EFAULT;

- res++;

- if (epi->event.events & EPOLLONESHOT)

- epi->event.events &= EP_PRIVATE_BITS;

- else if (!(epi->event.events & EPOLLET)) {

- /*

- * If this file has been added with Level

- * Trigger mode, we need to insert back inside

- * the ready list, so that the next call to

- * epoll_wait() will check again the events

- * availability. At this point, no one can insert

- * into ep->rdllist besides us. The epoll_ctl()

- * callers are locked out by

- * ep_send_events() holding "mtx" and the

- * poll callback will queue them in ep->ovflist.

- */

- list_add_tail(&epi->rdllink, &ep->rdllist);

- ep_pm_stay_awake(epi);

- }

- ep_done_scan(ep, &txlist);

- int res, eavail, timed_out = 0;

- eavail = 1;

-static int ep_loop_check_proc(struct eventpoll *ep, int depth)

- if (ep_tovisit == inserting_into || depth > EP_MAX_NESTS)

- result = max(result, ep_loop_check_proc(ep_tovisit, depth + 1) + 1);

- * If we've reached a file that is not associated with

- * an ep, then we need to check if the newly added

- * links are going to add too many wakeup paths. We do

- * this by adding it to the tfile_check_list, if it's

- * not already there, and calling reverse_path_check()

- * during ep_insert().

- list_file(epi->ffd.file);

- * @ep: Pointer to the epoll we are inserting into.

- * @to: Pointer to the epoll to be inserted.

-static int ep_loop_check(struct eventpoll *ep, struct eventpoll *to)

- inserting_into = ep;

- depth = ep_loop_check_proc(to, 0);

-static void clear_tfile_check_list(void)

- while (tfile_check_list != EP_UNACTIVE_PTR) {

- struct epitems_head *head = tfile_check_list;

- tfile_check_list = head->next;

-static inline int epoll_mutex_lock(struct mutex *mutex, int depth,

- bool nonblock)

- mutex_lock_nested(mutex, depth);

- if (mutex_trylock(mutex))

- return -EAGAIN;

-int do_epoll_ctl(int epfd, int op, int fd, struct epoll_event *epds,

- bool nonblock)

- int full_check = 0;

- struct eventpoll *tep = NULL;

-

- CLASS(fd, f)(epfd);

- if (fd_empty(f))

- return -EBADF;

-

- /* Get the "struct file *" for the target file */

- CLASS(fd, tf)(fd);

- if (fd_empty(tf))

- return -EBADF;

- if (!file_can_poll(fd_file(tf)))

- * We have to check that the file structure underneath the file descriptor

- * the user passed to us _is_ an eventpoll file. And also we do not permit

- error = -EINVAL;

- if (fd_file(f) == fd_file(tf) || !is_file_epoll(fd_file(f)))

- goto error_tgt_fput;

- * Also, we do not currently supported nested exclusive wakeups.

- goto error_tgt_fput;

- if (op == EPOLL_CTL_ADD && (is_file_epoll(fd_file(tf)) ||

- goto error_tgt_fput;

- /*

- * At this point it is safe to assume that the "private_data" contains

- * our own data structure.

- */

- ep = fd_file(f)->private_data;

- /*

- * When we insert an epoll file descriptor inside another epoll file

- * descriptor, there is the chance of creating closed loops, which are

- * better be handled here, than in more critical paths. While we are

- * checking for loops we also determine the list of files reachable

- * and hang them on the tfile_check_list, so we can check that we

- * haven't created too many possible wakeup paths.

- *

- * We do not need to take the global 'epumutex' on EPOLL_CTL_ADD when

- * the epoll file descriptor is attaching directly to a wakeup source,

- * unless the epoll file descriptor is nested. The purpose of taking the

- * 'epnested_mutex' on add is to prevent complex toplogies such as loops and

- * deep wakeup paths from forming in parallel through multiple

- * EPOLL_CTL_ADD operations.

- */

- error = epoll_mutex_lock(&ep->mtx, 0, nonblock);

- if (error)

- goto error_tgt_fput;

- if (op == EPOLL_CTL_ADD) {

- if (READ_ONCE(fd_file(f)->f_ep) || ep->gen == loop_check_gen ||

- is_file_epoll(fd_file(tf))) {

- mutex_unlock(&ep->mtx);

- error = epoll_mutex_lock(&epnested_mutex, 0, nonblock);

- if (error)

- goto error_tgt_fput;

- loop_check_gen++;

- full_check = 1;

- if (is_file_epoll(fd_file(tf))) {

- tep = fd_file(tf)->private_data;

- error = -ELOOP;

- if (ep_loop_check(ep, tep) != 0)

- goto error_tgt_fput;

- }

- error = epoll_mutex_lock(&ep->mtx, 0, nonblock);

- if (error)

- goto error_tgt_fput;

- }

- }

- * Try to lookup the file inside our RB tree. Since we grabbed "mtx"

- * above, we can be sure to be able to use the item looked up by

- * ep_find() till we release the mutex.

- epi = ep_find(ep, fd_file(tf), fd);

- error = ep_insert(ep, epds, fd_file(tf), fd, full_check);

- mutex_unlock(&ep->mtx);

-error_tgt_fput:

- if (full_check) {

- clear_tfile_check_list();

- loop_check_gen++;

- mutex_unlock(&epnested_mutex);

- }

-static int exec_mmap(struct mm_struct *mm)

- retval = exec_mmap(bprm->mm);

- set_dumpable(current->mm, suid_dumpable);

- set_dumpable(current->mm, SUID_DUMP_USER);

- if (get_dumpable(me->mm) != SUID_DUMP_USER)

- /* Ensure mm->user_ns contains the executable */

- user_ns = old = bprm->mm->user_ns;

- bprm->mm->user_ns = get_user_ns(user_ns);

-/*

- * set_dumpable stores three-value SUID_DUMP_* into mm->flags.

- */

-void set_dumpable(struct mm_struct *mm, int value)

-{

- if (WARN_ON((unsigned)value > SUID_DUMP_ROOT))

- return;

-

- __mm_flags_set_mask_dumpable(mm, value);

-}

-

- int error = proc_dointvec_minmax(table, write, buffer, lenp, ppos);

- if (!error && write)

- if (icount_read(inode) > 1) {

- icount_read(inode));

- BUILD_BUG_ON(20 - 1 /* for O_RDONLY being 0 */ !=

- __FMODE_EXEC));

- unsigned int maxbit = maxfd / BITS_PER_LONG;

- unsigned int bitbit = start / BITS_PER_LONG;

- bit = find_next_zero_bit(&fdt->open_fds[bitbit], BITS_PER_LONG,

- return bit + bitbit * BITS_PER_LONG;

- bitbit = find_next_zero_bit(fdt->full_fds_bits, maxbit, bitbit) * BITS_PER_LONG;

- if (bitbit >= maxfd)

- if (bitbit > start)

- start = bitbit;

- return find_next_zero_bit(fdt->open_fds, maxfd, start);

- * Handling of filesystem drivers list.

- * Rules:

- * Inclusion to/removals from/scanning of list are protected by spinlock.

- * During the unload module must call unregister_filesystem().

- * We can access the fields of list element if:

- * 1) spinlock is held or

- * 2) we hold the reference to the module.

- * The latter can be guaranteed by call of try_module_get(); if it

- * returned 0 we must skip the element, otherwise we got the reference.

- * Once the reference is obtained we can drop the spinlock.

-static struct file_system_type *file_systems;

-static DEFINE_RWLOCK(file_systems_lock);

-static struct file_system_type **find_filesystem(const char *name, unsigned len)

- struct file_system_type **p;

- for (p = &file_systems; *p; p = &(*p)->next)

- if (strncmp((*p)->name, name, len) == 0 &&

- !(*p)->name[len])

- break;

- return p;

- * The &struct file_system_type that is passed is linked into the kernel

-

-int register_filesystem(struct file_system_type * fs)

- int res = 0;

- struct file_system_type ** p;

-

- if (fs->next)

- write_lock(&file_systems_lock);

- p = find_filesystem(fs->name, strlen(fs->name));

- if (*p)

- res = -EBUSY;

- else

- *p = fs;

- write_unlock(&file_systems_lock);

- return res;

-}

- *

-

-int unregister_filesystem(struct file_system_type * fs)

- struct file_system_type ** tmp;

-

- write_lock(&file_systems_lock);

- tmp = &file_systems;

- while (*tmp) {

- if (fs == *tmp) {

- *tmp = fs->next;

- fs->next = NULL;

- write_unlock(&file_systems_lock);

- synchronize_rcu();

- return 0;

- }

- tmp = &(*tmp)->next;

- write_unlock(&file_systems_lock);

-

- return -EINVAL;

-

-static int fs_index(const char __user * __name)

- struct file_system_type * tmp;

- int err, index;

- err = -EINVAL;

- read_lock(&file_systems_lock);

- for (tmp=file_systems, index=0 ; tmp ; tmp=tmp->next, index++) {

- if (strcmp(tmp->name, name) == 0) {

- err = index;

- break;

- }

- read_unlock(&file_systems_lock);

- return err;

-static int fs_name(unsigned int index, char __user * buf)

- struct file_system_type * tmp;

- int len, res = -EINVAL;

- read_lock(&file_systems_lock);

- for (tmp = file_systems; tmp; tmp = tmp->next, index--) {

- if (index == 0) {

- if (try_module_get(tmp->owner))

- res = 0;

- read_unlock(&file_systems_lock);

- if (res)

- return res;

- len = strlen(tmp->name) + 1;

- res = copy_to_user(buf, tmp->name, len) ? -EFAULT : 0;

- put_filesystem(tmp);

- struct file_system_type * tmp;

- int index;

- read_lock(&file_systems_lock);

- for (tmp = file_systems, index = 0 ; tmp ; tmp = tmp->next, index++)

- ;

- read_unlock(&file_systems_lock);

- * Whee.. Weird sysv syscall.

- read_lock(&file_systems_lock);

- for (p = file_systems; p; p = p->next) {

- read_unlock(&file_systems_lock);

-static int filesystems_proc_show(struct seq_file *m, void *v)

- struct file_system_type * tmp;

- read_lock(&file_systems_lock);

- tmp = file_systems;

- while (tmp) {

- (tmp->fs_flags & FS_REQUIRES_DEV) ? "" : "nodev",

- tmp->name);

- tmp = tmp->next;

- read_unlock(&file_systems_lock);

- proc_create_single("filesystems", 0, NULL, filesystems_proc_show);

- read_lock(&file_systems_lock);

- fs = *(find_filesystem(name, len));

- read_unlock(&file_systems_lock);

-

- if (hpfs_inode->i_rddir_off && !icount_read(i)) {

- sb_set_blocksize(s, 512);

- * inode->i_sb->s_inode_list_lock

- *

- * iunique_lock

- * inode_hash_lock

-/*

- * get additional reference to inode; caller must already hold one.

- */

-void ihold(struct inode *inode)

-{

- WARN_ON(atomic_inc_return(&inode->i_count) < 2);

-}

-EXPORT_SYMBOL(ihold);

-

- if (icount_read(inode))

- VFS_BUG_ON_INODE(atomic_read(&inode->i_count) != 0, inode);

- VFS_BUG_ON_INODE(atomic_read(&inode->i_count) != 0, inode);

- VFS_BUG_ON_INODE(atomic_read(&inode->i_count) < 1, inode);

- VFS_BUG_ON_INODE(atomic_read(&inode->i_count) < 2, inode);

- count = atomic_read(&inode->i_count);

- sb_set_blocksize(s, orig_zonesize);

- sb_set_blocksize(sb, PSIZE);

- sb_set_blocksize(s, m3s->s_blocksize);

-static struct dentry *__start_removing_path(int dfd, struct filename *name,

- struct path *path)

- error = filename_parentat(dfd, name, 0, &parent_path, &last, &type);

-struct dentry *start_removing_path(const char *name, struct path *path)

-{

- CLASS(filename_kernel, filename)(name);

- return __start_removing_path(AT_FDCWD, filename, path);

-}

-

-struct dentry *start_removing_user_path_at(int dfd,

- const char __user *name,

- struct path *path)

-{

- CLASS(filename, filename)(name);

- return __start_removing_path(dfd, filename, path);

-}

-EXPORT_SYMBOL(start_removing_user_path_at);

-

- struct qstr this = QSTR_INIT("pts", 3);

- child = d_hash_and_lookup(parent, &this);

- struct mount *mnt, *n;

- rbtree_postorder_for_each_entry_safe(mnt, n, &ns->mounts, mnt_node) {

- if (mnt->mnt.mnt_sb->s_type != sb->s_type)

- /* This mount is not fully visible if it's root directory

- * is not the root directory of the filesystem.

- if (mnt->mnt.mnt_root != mnt->mnt.mnt_sb->s_root)

- s_iflags = sb->s_iflags;

- if (!(s_iflags & SB_I_USERNS_VISIBLE))

- icount_read(inode));

- icount_read(inode), fattr->valid);

- sb_set_blocksize(sb, min_t(u32, sbi->cluster_size, PAGE_SIZE));

- sb_set_blocksize(sb, block_size);

- .next = NULL,

- sb_set_blocksize(sb, 0x200);

- sb_set_blocksize(sb, sbi->s_sys_blocksize);

- f->f_flags &= ~(O_CREAT | O_EXCL | O_NOCTTY | O_TRUNC);

-#define O_PATH_FLAGS (O_DIRECTORY | O_NOFOLLOW | O_PATH | O_CLOEXEC)

- "struct open_flags doesn't yet handle flags > 32 bits");

- if (flags & ~VALID_OPEN_FLAGS)

- CLASS(filename, name)(filename);

-static __u32 pidfs_coredump_mask(unsigned long mm_flags)

- switch (__get_dumpable(mm_flags)) {

- case SUID_DUMP_USER:

- case SUID_DUMP_ROOT:

- case SUID_DUMP_DISABLE:

- guard(task_lock)(task);

- if (task->mm) {

- unsigned long flags = __mm_flags_get_dumpable(task->mm);

-

- kinfo.coredump_mask = pidfs_coredump_mask(flags);

- kinfo.mask |= PIDFD_INFO_COREDUMP;

- /* No coredump actually took place, so no coredump signal. */

- }

- attr->coredump_mask = pidfs_coredump_mask(cprm->mm_flags) |

- WRITE_ONCE(pipe->poll_usage, true);

- rcu_read_unlock();

- if (mode != (S_IFDIR|S_IRUGO|S_IXUGO)) {

- struct mm_struct *mm;

- task_lock(task);

- mm = task->mm;

- /* Make non-dumpable tasks owned by some root */

- if (mm) {

- if (get_dumpable(mm) != SUID_DUMP_USER) {

- struct user_namespace *user_ns = mm->user_ns;

- uid = make_kuid(user_ns, 0);

- if (!uid_valid(uid))

- uid = GLOBAL_ROOT_UID;

- gid = make_kgid(user_ns, 0);

- if (!gid_valid(gid))

- gid = GLOBAL_ROOT_GID;

- }

- } else {

- uid = GLOBAL_ROOT_UID;

- gid = GLOBAL_ROOT_GID;

- task_unlock(task);

- unsigned long flags = __mm_flags_get_dumpable(mm);

-static void proc_apply_options(struct proc_fs_info *fs_info,

- proc_apply_options(fs_info, fc, current_user_ns());

- s->s_iflags |= SB_I_USERNS_VISIBLE | SB_I_NOEXEC | SB_I_NODEV;

- proc_apply_options(fs_info, fc, current_user_ns());

- return 0;

- .fs_flags = FS_USERNS_MOUNT | FS_DISALLOW_NOTIFY_PERM,

- sb_set_blocksize(s, QNX4_BLOCK_SIZE);

- if (newinode && S_ISDIR(newinode->i_mode)) {

- rc = -EISDIR;

- goto out_err;

- full_path, inode, icount_read(inode),

-EXPORT_SYMBOL(drop_super_exclusive);

- if (!S_ISREG(i_mode) && !S_ISBLK(i_mode) && !S_ISDIR(i_mode) &&

- !S_ISLNK(i_mode))

-static int sysfs_get_tree(struct fs_context *fc)

-{

- struct kernfs_fs_context *kfc = fc->fs_private;

- int ret;

-

- ret = kernfs_get_tree(fc);

- if (ret)

- return ret;

-

- if (kfc->new_sb_created)

- fc->root->d_sb->s_iflags |= SB_I_USERNS_VISIBLE;

- return 0;

-}

-

- .get_tree = sysfs_get_tree,

- .fs_flags = FS_USERNS_MOUNT,

- ubifs_assert(c, !icount_read(inode));

- if (icount_read(VFS_I(ip)))

- __entry->count = icount_read(VFS_I(ip));