litmus-rt.git - The LITMUS^RT kernel.

diff options

author	Herbert Xu <herbert@gondor.apana.org.au>	2005-06-20 16:21:43 -0400
committer	David S. Miller <davem@davemloft.net>	2005-06-20 16:21:43 -0400
commit	dd87147eed934eaff92869f3d158697c7239d1d2 (patch)
tree	5a5d59c2678767530c2a3299a70ccfc14062b347 /lib/kobject.c
parent	d094cd83c06e06e01d8edb540555f3f64e4081c2 (diff)

[IPSEC]: Add XFRM_STATE_NOPMTUDISC flag

This patch adds the flag XFRM_STATE_NOPMTUDISC for xfrm states. It is similar to the nopmtudisc on IPIP/GRE tunnels. It only has an effect on IPv4 tunnel mode states. For these states, it will ensure that the DF flag is always cleared. This is primarily useful to work around ICMP blackholes. In future this flag could also allow a larger MTU to be set within the tunnel just like IPIP/GRE tunnels. This could be useful for short haul tunnels where temporary fragmentation outside the tunnel is desired over smaller fragments inside the tunnel. Signed-off-by: Herbert Xu <herbert@gondor.apana.org.au> Acked-by: James Morris <jmorris@redhat.com> Signed-off-by: David S. Miller <davem@davemloft.net>

Diffstat (limited to 'lib/kobject.c')

0 files changed, 0 insertions, 0 deletions

// SPDX-License-Identifier: GPL-2.0 #include <linux/ceph/ceph_debug.h> #include <linux/ceph/striper.h> #include <linux/module.h> #include <linux/sched.h> #include <linux/slab.h> #include <linux/file.h> #include <linux/mount.h> #include <linux/namei.h> #include <linux/writeback.h> #include <linux/falloc.h> #include "super.h" #include "mds_client.h" #include "cache.h" static __le32 ceph_flags_sys2wire(u32 flags) { u32 wire_flags = 0; switch (flags & O_ACCMODE) { case O_RDONLY: wire_flags |= CEPH_O_RDONLY; break; case O_WRONLY: wire_flags |= CEPH_O_WRONLY; break; case O_RDWR: wire_flags |= CEPH_O_RDWR; break; } flags &= ~O_ACCMODE; #define ceph_sys2wire(a) if (flags & a) { wire_flags |= CEPH_##a; flags &= ~a; } ceph_sys2wire(O_CREAT); ceph_sys2wire(O_EXCL); ceph_sys2wire(O_TRUNC); ceph_sys2wire(O_DIRECTORY); ceph_sys2wire(O_NOFOLLOW); #undef ceph_sys2wire if (flags) dout("unused open flags: %x\n", flags); return cpu_to_le32(wire_flags); } /* * Ceph file operations * * Implement basic open/close functionality, and implement * read/write. * * We implement three modes of file I/O: * - buffered uses the generic_file_aio_{read,write} helpers * * - synchronous is used when there is multi-client read/write * sharing, avoids the page cache, and synchronously waits for an * ack from the OSD. * * - direct io takes the variant of the sync path that references * user pages directly. * * fsync() flushes and waits on dirty pages, but just queues metadata * for writeback: since the MDS can recover size and mtime there is no * need to wait for MDS acknowledgement. */ /* * How many pages to get in one call to iov_iter_get_pages(). This * determines the size of the on-stack array used as a buffer. */ #define ITER_GET_BVECS_PAGES 64 static ssize_t __iter_get_bvecs(struct iov_iter *iter, size_t maxsize, struct bio_vec *bvecs) { size_t size = 0; int bvec_idx = 0; if (maxsize > iov_iter_count(iter)) maxsize = iov_iter_count(iter); while (size < maxsize) { struct page *pages[ITER_GET_BVECS_PAGES]; ssize_t bytes; size_t start; int idx = 0; bytes = iov_iter_get_pages(iter, pages, maxsize - size, ITER_GET_BVECS_PAGES, &start); if (bytes < 0) return size ?: bytes; iov_iter_advance(iter, bytes); size += bytes; for ( ; bytes; idx++, bvec_idx++) { struct bio_vec bv = { .bv_page = pages[idx], .bv_len = min_t(int, bytes, PAGE_SIZE - start), .bv_offset = start, }; bvecs[bvec_idx] = bv; bytes -= bv.bv_len; start = 0; } } return size; } /* * iov_iter_get_pages() only considers one iov_iter segment, no matter * what maxsize or maxpages are given. For ITER_BVEC that is a single * page. * * Attempt to get up to @maxsize bytes worth of pages from @iter. * Return the number of bytes in the created bio_vec array, or an error. */ static ssize_t iter_get_bvecs_alloc(struct iov_iter *iter, size_t maxsize, struct bio_vec **bvecs, int *num_bvecs) { struct bio_vec *bv; size_t orig_count = iov_iter_count(iter); ssize_t bytes; int npages; iov_iter_truncate(iter, maxsize); npages = iov_iter_npages(iter, INT_MAX); iov_iter_reexpand(iter, orig_count); /* * __iter_get_bvecs() may populate only part of the array -- zero it * out. */ bv = kvmalloc_array(npages, sizeof(*bv), GFP_KERNEL | __GFP_ZERO); if (!bv) return -ENOMEM; bytes = __iter_get_bvecs(iter, maxsize, bv); if (bytes < 0) { /* * No pages were pinned -- just free the array. */ kvfree(bv); return bytes; } *bvecs = bv; *num_bvecs = npages; return bytes; } static void put_bvecs(struct bio_vec *bvecs, int num_bvecs, bool should_dirty) { int i; for (i = 0; i < num_bvecs; i++) { if (bvecs[i].bv_page) { if (should_dirty) set_page_dirty_lock(bvecs[i].bv_page); put_page(bvecs[i].bv_page); } } kvfree(bvecs); } /* * Prepare an open request. Preallocate ceph_cap to avoid an * inopportune ENOMEM later. */ static struct ceph_mds_request * prepare_open_request(struct super_block *sb, int flags, int create_mode) { struct ceph_fs_client *fsc = ceph_sb_to_client(sb); struct ceph_mds_client *mdsc = fsc->mdsc; struct ceph_mds_request *req; int want_auth = USE_ANY_MDS; int op = (flags & O_CREAT) ? CEPH_MDS_OP_CREATE : CEPH_MDS_OP_OPEN; if (flags & (O_WRONLY|O_RDWR|O_CREAT|O_TRUNC)) want_auth = USE_AUTH_MDS; req = ceph_mdsc_create_request(mdsc, op, want_auth); if (IS_ERR(req)) goto out; req->r_fmode = ceph_flags_to_mode(flags); req->r_args.open.flags = ceph_flags_sys2wire(flags); req->r_args.open.mode = cpu_to_le32(create_mode); out: return req; } static int ceph_init_file_info(struct inode *inode, struct file *file, int fmode, bool isdir) { struct ceph_file_info *fi; dout("%s %p %p 0%o (%s)\n", __func__, inode, file, inode->i_mode, isdir ? "dir" : "regular");


context:
space:
mode: