FilesExpand file tree

 workqueue-mod

/

fops.c

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

156 lines (138 loc) · 3.76 KB

 workqueue-mod

/

fops.c

Copy path

Top

File metadata and controls

• Code
• Blame

156 lines (138 loc) · 3.76 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

/*

Basic fops example, with a fixed size static data buffer.

Usage:

/fops.sh

No, there ain't no official docs:

http://stackoverflow.com/questions/15213932/what-are-the-struct-file-operations-arguments

fops define what the kernel will do on filesystem system calls on all of

/dev, /proc, /sys, and consistute the main method of userland communication

in drivers (syscalls being the other one).

Here we use debugfs.

*/

#include <linux/debugfs.h>

#include <linux/errno.h> /* EFAULT */

#include <linux/fs.h>

#include <linux/kernel.h> /* min */

#include <linux/module.h>

#include <linux/printk.h> /* printk */

#include <asm/uaccess.h> /* copy_from_user, copy_to_user */

MODULE_LICENSE("GPL");

static struct dentry *dir = 0;

static char data[] = {'a', 'b', 'c', 'd'};

static int fop_open(struct inode *inode, struct file *file)

{

printk(KERN_INFO "open\n");

return 0;

}

/* @param[in,out] off: gives the initial position into the buffer.

* We must increment this by the ammount of bytes read.

* Then when userland reads the same file descriptor again,

* we start from that point instead.

* */

static ssize_t fop_read(struct file *file, char __user *buf, size_t len, loff_t *off)

{

ssize_t ret;

printk(KERN_INFO "read\n");

printk(KERN_INFO "len = %zu\n", len);

printk(KERN_INFO "off = %lld\n", (long long)*off);

if (sizeof(data) <= *off) {

ret = 0;

} else {

ret = min(len, sizeof(data) - (size_t)*off);

if (copy_to_user(buf, data + *off, ret)) {

ret = -EFAULT;

} else {

*off += ret;

}

}

printk(KERN_INFO "buf = %.*s\n", (int)len, buf);

printk(KERN_INFO "ret = %lld\n", (long long)ret);

return ret;

}

/* Similar to read, but with one notable difference:

* we must return ENOSPC if the user tries to write more

* than the size of our buffer. Otherwise, Bash > just

* keeps trying to write to it infinitely. */

static ssize_t fop_write(struct file *file, const char __user *buf, size_t len, loff_t *off)

{

ssize_t ret;

printk(KERN_INFO "write\n");

printk(KERN_INFO "buf = %.*s\n", (int)len, buf);

printk(KERN_INFO "len = %zu\n", len);

printk(KERN_INFO "off = %lld\n", (long long)*off);

if (sizeof(data) <= *off) {

ret = 0;

} else {

if (sizeof(data) - (size_t)*off < len) {

ret = -ENOSPC;

} else {

if (copy_from_user(data + *off, buf, len)) {

ret = -EFAULT;

} else {

ret = len;

*off += ret;

}

}

}

printk(KERN_INFO "ret = %lld\n", (long long)ret);

return ret;

}

/*

Called on the last close:

http://stackoverflow.com/questions/11393674/why-is-the-close-function-is-called-release-in-struct-file-operations-in-the-l

*/

static int fop_release (struct inode *inode, struct file *file)

{

printk(KERN_INFO "release\n");

return 0;

}

static loff_t fop_llseek(struct file *filp, loff_t off, int whence)

{

loff_t newpos;

printk(KERN_INFO "llseek\n");

printk(KERN_INFO "off = %lld\n", (long long)off);

printk(KERN_INFO "whence = %lld\n", (long long)whence);

switch(whence) {

case SEEK_SET:

newpos = off;

break;

case SEEK_CUR:

newpos = filp->f_pos + off;

break;

case SEEK_END:

newpos = sizeof(data) + off;

break;

default:

return -EINVAL;

}

if (newpos < 0) return -EINVAL;

filp->f_pos = newpos;

printk(KERN_INFO "newpos = %lld\n", (long long)newpos);

return newpos;

}

static const struct file_operations fops = {

.llseek = fop_llseek,

.open = fop_open,

.read = fop_read,

.release = fop_release,

.write = fop_write,

};

int init_module(void)

{

struct dentry *file;

dir = debugfs_create_dir("kernel_module_cheat", 0);

if (!dir) {

printk(KERN_ALERT "debugfs_create_dir failed");

return -1;

}

file = debugfs_create_file("fops", 0666, dir, NULL, &fops);

if (!file) {

printk(KERN_ALERT "debugfs_create_file failed");

return -1;

}

return 0;

}

void cleanup_module(void)

{

debugfs_remove_recursive(dir);

}