{"push_id":898415225,"size":27,"distinct_size":27,"ref":"refs/heads/cm-13.0-caf","head":"c3f9444e7b4ee073378f395cc2371c70f0492b8d","before":"20afe09183f6876d46c1ee06e2466823a0907677","commits":[{"sha":"5cec94f1d7d249e72b6d0531136faa137e07609f","author":{"email":"00e4cf8f46a57000a44449bf9dd8cbbcc209fd2a@linutronix.de","name":"Thomas Gleixner"},"message":"futex: Always cleanup owner tid in unlock_pi\n\nIf the owner died bit is set at futex_unlock_pi, we currently do not\ncleanup the user space futex. So the owner TID of the current owner\n(the unlocker) persists. That's observable inconsistant state,\nespecially when the ownership of the pi state got transferred.\n\nClean it up unconditionally.\n\nSigned-off-by: Thomas Gleixner <tglx@linutronix.de>\nCc: Kees Cook <keescook@chromium.org>\nCc: Will Drewry <wad@chromium.org>\nCc: Darren Hart <dvhart@linux.intel.com>\nCc: stable@vger.kernel.org","distinct":true,"url":"https://api.github.com/repos/CyanogenMod/android_kernel_lge_hammerhead/commits/5cec94f1d7d249e72b6d0531136faa137e07609f"},{"sha":"91c37f3bdef12b31db541666dfc45410bd84b4f8","author":{"email":"00e4cf8f46a57000a44449bf9dd8cbbcc209fd2a@linutronix.de","name":"Thomas Gleixner"},"message":"futex: Make lookup_pi_state more robust\n\nThe current implementation of lookup_pi_state has ambigous handling of\nthe TID value 0 in the user space futex. We can get into the kernel\neven if the TID value is 0, because either there is a stale waiters\nbit or the owner died bit is set or we are called from the requeue_pi\npath or from user space just for fun.\n\nThe current code avoids an explicit sanity check for pid = 0 in case\nthat kernel internal state (waiters) are found for the user space\naddress. This can lead to state leakage and worse under some\ncircumstances.\n\nHandle the cases explicit:\n\n     Waiter | pi_state | pi->owner | uTID      | uODIED | ?\n\n[1]  NULL   | ---      | ---       | 0         | 0/1    | Valid\n[2]  NULL   | ---      | ---       | >0        | 0/1    | Valid\n\n[3]  Found  | NULL     | --        | Any       | 0/1    | Invalid\n\n[4]  Found  | Found    | NULL      | 0         | 1      | Valid\n[5]  Found  | Found    | NULL      | >0        | 1      | Invalid\n\n[6]  Found  | Found    | task      | 0         | 1      | Valid\n\n[7]  Found  | Found    | NULL      | Any       | 0      | Invalid\n\n[8]  Found  | Found    | task      | ==taskTID | 0/1    | Valid\n[9]  Found  | Found    | task      | 0         | 0      | Invalid\n[10] Found  | Found    | task      | !=taskTID | 0/1    | Invalid\n\n[1]  Indicates that the kernel can acquire the futex atomically. We\n     came came here due to a stale FUTEX_WAITERS/FUTEX_OWNER_DIED bit.\n\n[2]  Valid, if TID does not belong to a kernel thread. If no matching\n     thread is found then it indicates that the owner TID has died.\n\n[3]  Invalid. The waiter is queued on a non PI futex\n\n[4]  Valid state after exit_robust_list(), which sets the user space\n     value to FUTEX_WAITERS | FUTEX_OWNER_DIED.\n\n[5]  The user space value got manipulated between exit_robust_list()\n     and exit_pi_state_list()\n\n[6]  Valid state after exit_pi_state_list() which sets the new owner in\n     the pi_state but cannot access the user space value.\n\n[7]  pi_state->owner can only be NULL when the OWNER_DIED bit is set.\n\n[8]  Owner and user space value match\n\n[9]  There is no transient state which sets the user space TID to 0\n     except exit_robust_list(), but this is indicated by the\n     FUTEX_OWNER_DIED bit. See [4]\n\n[10] There is no transient state which leaves owner and user space\n     TID out of sync.\n\nBackport to 3.13\n  conflicts: kernel/futex.c\n\nSigned-off-by: Thomas Gleixner <tglx@linutronix.de>\nSigned-off-by: John Johansen <john.johansen@canonical.com>\nCc: Kees Cook <keescook@chromium.org>\nCc: Will Drewry <wad@chromium.org>\nCc: Darren Hart <dvhart@linux.intel.com>\nCc: stable@vger.kernel.org","distinct":true,"url":"https://api.github.com/repos/CyanogenMod/android_kernel_lge_hammerhead/commits/91c37f3bdef12b31db541666dfc45410bd84b4f8"},{"sha":"b80ca7a764d7c08314dfe7945ed0f7d43da330db","author":{"email":"e9264147b413746293e539868c8edff71715e1e3@vrfy.org","name":"Kay Sievers"},"message":"printk - fix compilation for CONFIG_PRINTK=n\n\nReported-by: Randy Dunlap <rdunlap@xenotime.net>\nSigned-off-by: Kay Sievers <kay@vrfy.org>\nSigned-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>","distinct":true,"url":"https://api.github.com/repos/CyanogenMod/android_kernel_lge_hammerhead/commits/b80ca7a764d7c08314dfe7945ed0f7d43da330db"},{"sha":"d167a51a77892da84322e6e5cc440ee0a65c7a3a","author":{"email":"e9264147b413746293e539868c8edff71715e1e3@vrfy.org","name":"Kay Sievers"},"message":"printk() - do not merge continuation lines of different threads\n\nThis prevents the merging of printk() continuation lines of different\nthreads, in the case they race against each other.\n\nIt should properly isolate \"atomic\" single-line printk() users from\ncontinuation users, to make sure the single-line users will never be\nmerged with the racy continuation ones.\n\nCc: Linus Torvalds <torvalds@linux-foundation.org>\nCc: Ingo Molnar <mingo@kernel.org>\nCc: Jonathan Corbet <corbet@lwn.net>\nCc: Sasha Levin <levinsasha928@gmail.com>\nSigned-off-by: Kay Sievers <kay@vrfy.org>\nSigned-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>","distinct":true,"url":"https://api.github.com/repos/CyanogenMod/android_kernel_lge_hammerhead/commits/d167a51a77892da84322e6e5cc440ee0a65c7a3a"},{"sha":"00723cd03206c6857ff35c67471799183e87b833","author":{"email":"e9264147b413746293e539868c8edff71715e1e3@vrfy.org","name":"Kay Sievers"},"message":"printk() - restore timestamp printing at console output\n\nThe output of the timestamps got lost with the conversion of the\nkmsg buffer to records; restore the old behavior.\n\nDocument, that CONFIG_PRINTK_TIME now only controls the output of\nthe timestamps in the syslog() system call and on the console, and\nnot the recording of the timestamps.\n\nCc: Joe Perches <joe@perches.com>\nCc: Linus Torvalds <torvalds@linux-foundation.org>\nCc: Sasha Levin <levinsasha928@gmail.com>\nCc: Ingo Molnar <mingo@kernel.org>\nReported-by: Yinghai Lu <yinghai@kernel.org>\nSigned-off-by: Kay Sievers <kay@vrfy.org>\nSigned-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>","distinct":true,"url":"https://api.github.com/repos/CyanogenMod/android_kernel_lge_hammerhead/commits/00723cd03206c6857ff35c67471799183e87b833"},{"sha":"4b547e054f2dc27ffbb075e005263089f2277018","author":{"email":"5ef2a23ba3aff51d1cfc8c113c1ec34b608b3b13@nvidia.com","name":"Stephen Warren"},"message":"printk: correctly align __log_buf\n\n__log_buf must be aligned, because a 64-bit value is written directly\nto it as part of struct log. Alignment of the log entries is typically\nhandled by log_store(), but this only triggers for subsequent entries,\nnot the very first (or wrapped) entries.\n\nChange-Id: I76862db0d7c9e1c6c8107155883e6c14100535d7\nCc: Kay Sievers <kay@vrfy.org>\nSigned-off-by: Stephen Warren <swarren@nvidia.com>\nSigned-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>","distinct":true,"url":"https://api.github.com/repos/CyanogenMod/android_kernel_lge_hammerhead/commits/4b547e054f2dc27ffbb075e005263089f2277018"},{"sha":"b360d4ee5abe29bc8c653d7ec5d4d6f326fa2944","author":{"email":"6f29df8e90a57f1ba61ffd63b0468c86bb6d3a99@xenotime.net","name":"Randy Dunlap"},"message":"printk: add stub for prepend_timestamp()\n\nAdd a stub for prepend_timestamp() when CONFIG_PRINTK is not\nenabled.  Fixes this build error:\n\nkernel/printk.c:1770:3: error: implicit declaration of function 'prepend_timestamp'\n\nChange-Id: I4ac7ee2b6230fc0b211ae439ea6774716e9454a9\nCc: Kay Sievers <kay@vrfy.org>\nSigned-off-by: Randy Dunlap <rdunlap@xenotime.net>\nSigned-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>","distinct":true,"url":"https://api.github.com/repos/CyanogenMod/android_kernel_lge_hammerhead/commits/b360d4ee5abe29bc8c653d7ec5d4d6f326fa2944"},{"sha":"e00157e9dd48975e9c065e532f7e53bd6f6a2098","author":{"email":"e9264147b413746293e539868c8edff71715e1e3@vrfy.org","name":"Kay Sievers"},"message":"printk() - restore prefix/timestamp printing for multi-newline strings\n\nCalls like:\n  printk(\"\\n *** DEADLOCK ***\\n\\n\");\nwill print 3 properly indented, separated, syslog + timestamp prefixed lines in\nthe log output.\n\nReported-By: Sasha Levin <levinsasha928@gmail.com>\nSigned-off-by: Kay Sievers <kay@vrfy.org>\nSigned-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>","distinct":true,"url":"https://api.github.com/repos/CyanogenMod/android_kernel_lge_hammerhead/commits/e00157e9dd48975e9c065e532f7e53bd6f6a2098"},{"sha":"167f899eb65b4f2cbf06c4c5577b1ce08e658bb0","author":{"email":"e9264147b413746293e539868c8edff71715e1e3@vrfy.org","name":"Kay Sievers"},"message":"printk() - isolate KERN_CONT users from ordinary complete lines\n\nArrange the continuation printk() buffering to be fully separated from the\nordinary full line users.\n\nLimit the exposure to races and wrong printk() line merges to users of\ncontinuation only. Ordinary full line users racing against continuation\nusers will no longer affect each other.\n\nMultiple continuation users from different threads, racing against each\nother will not wrongly be merged into a single line, but printed as\nseparate lines.\n\nTest output of a kernel module which starts two separate threads which\nrace against each other, one of them printing a single full terminated\nline:\n  printk(\"(AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA)\\n\");\n\nThe other one printing the line, every character separate in a\ncontinuation loop:\n  printk(\"(C\");\n  for (i = 0; i < 58; i++)\n          printk(KERN_CONT \"C\");\n  printk(KERN_CONT \"C)\\n\");\n\nBehavior of single and non-thread-aware printk() buffer:\n  # modprobe printk-race\n  printk test init\n  (CC(AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA)\n  C(AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA)\n  CC(AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA)\n  C(AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA)\n  CC(AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA)\n  C(AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA)\n  C(AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA)\n  CC(AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA)\n  C(AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA)\n  C(AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA)\n  CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC)\n  (CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC)\n\nNew behavior with separate and thread-aware continuation buffer:\n  # modprobe printk-race\n  printk test init\n  (AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA)\n  (AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA)\n  (AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA)\n  (CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC)\n  (AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA)\n  (AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA)\n  (AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA)\n  (AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA)\n  (CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC)\n  (CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC)\n\nCc: Linus Torvalds <torvalds@linux-foundation.org>\nCc: Joe Perches <joe@perches.com>\nCc: Ted Ts'o <tytso@mit.edu>\nCc: Ingo Molnar  <mingo@kernel.org>\nCc: Jonathan Corbet <corbet@lwn.net>\nCc: Sasha Levin <levinsasha928@gmail.com>\nSigned-off-by: Kay Sievers <kay@vrfy.org>\nSigned-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>","distinct":true,"url":"https://api.github.com/repos/CyanogenMod/android_kernel_lge_hammerhead/commits/167f899eb65b4f2cbf06c4c5577b1ce08e658bb0"},{"sha":"0fe4652c9f8580f7eece553db347e1e02ae31d61","author":{"email":"02e0a999c50b1f88df7a8f5a04e1b76b35ea6a88@lunn.ch","name":"Andrew Lunn"},"message":"printk: Fix alignment of buf causing crash on ARM EABI\n\nCommit 7ff9554bb578ba02166071d2d487b7fc7d860d62, printk: convert\nbyte-buffer to variable-length record buffer, causes systems using\nEABI to crash very early in the boot cycle. The first entry in struct\nlog is a u64, which for EABI must be 8 byte aligned.\n\nMake use of __alignof__() so the compiler to decide the alignment, but\nallow it to be overridden using CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS,\nfor systems which can perform unaligned access and want to save\na few bytes of space.\n\nTested on Orion5x and Kirkwood.\n\nChange-Id: Ie018dba442d2666512547fbd029ad7eccf222a59\nSigned-off-by: Andrew Lunn <andrew@lunn.ch>\nTested-by: Stephen Warren <swarren@wwwdotorg.org>\nAcked-by: Stephen Warren <swarren@wwwdotorg.org>\nAcked-by: Kay Sievers <kay@vrfy.org>\nSigned-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>","distinct":true,"url":"https://api.github.com/repos/CyanogenMod/android_kernel_lge_hammerhead/commits/0fe4652c9f8580f7eece553db347e1e02ae31d61"},{"sha":"85ca375e8e947a72d08ea26540ca28683c27d0ec","author":{"email":"e9264147b413746293e539868c8edff71715e1e3@vrfy.org","name":"Kay Sievers"},"message":"kmsg - kmsg_dump() use iterator to receive log buffer content\n\nProvide an iterator to receive the log buffer content, and convert all\nkmsg_dump() users to it.\n\nThe structured data in the kmsg buffer now contains binary data, which\nshould no longer be copied verbatim to the kmsg_dump() users.\n\nThe iterator should provide reliable access to the buffer data, and also\nsupports proper log line-aware chunking of data while iterating.\n\nSigned-off-by: Kay Sievers <kay@vrfy.org>\nTested-by: Tony Luck <tony.luck@intel.com>\nReported-by: Anton Vorontsov <anton.vorontsov@linaro.org>\nTested-by: Anton Vorontsov <anton.vorontsov@linaro.org>\nSigned-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>","distinct":true,"url":"https://api.github.com/repos/CyanogenMod/android_kernel_lge_hammerhead/commits/85ca375e8e947a72d08ea26540ca28683c27d0ec"},{"sha":"e1e614ef5bfe9edeab8aa0d69fb7b6a4b8272b18","author":{"email":"5dcef21195e64c9c08aa779bb62b25e9133eaa33@linux.intel.com","name":"Yuanhan Liu"},"message":"printk: use mutex lock to stop syslog_seq from going wild\n\nAlthough syslog_seq and log_next_seq stuff are protected by logbuf_lock\nspin log, it's not enough. Say we have two processes A and B, and let\nsyslog_seq = N, while log_next_seq = N + 1, and the two processes both\ncome to syslog_print at almost the same time. And No matter which\nprocess get the spin lock first, it will increase syslog_seq by one,\nthen release spin lock; thus later, another process increase syslog_seq\nby one again. In this case, syslog_seq is bigger than syslog_next_seq.\nAnd latter, it would make:\n   wait_event_interruptiable(log_wait, syslog != log_next_seq)\ndon't wait any more even there is no new write comes. Thus it introduce\na infinite loop reading.\n\nI can easily see this kind of issue by the following steps:\n  # cat /proc/kmsg # at meantime, I don't kill rsyslog\n                   # So they are the two processes.\n  # xinit          # I added drm.debug=6 in the kernel parameter line,\n                   # so that it will produce lots of message and let that\n                   # issue happen\n\nIt's 100% reproducable on my side. And my disk will be filled up by\n/var/log/messages in a quite short time.\n\nSo, introduce a mutex_lock to stop syslog_seq from going wild just like\nwhat devkmsg_read() does. It does fix this issue as expected.\n\nv2: use mutex_lock_interruptiable() instead (comments from Kay)\n\nSigned-off-by: Yuanhan Liu <yuanhan.liu@linux.intel.com>\nReviewed-by: Fengguang Wu <fengguang.wu@intel.com>\nAcked-By: Kay Sievers <kay@vrfy.org>\nSigned-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>","distinct":true,"url":"https://api.github.com/repos/CyanogenMod/android_kernel_lge_hammerhead/commits/e1e614ef5bfe9edeab8aa0d69fb7b6a4b8272b18"},{"sha":"fbffea9ca1089d9f8dff123f9b75daa675c26833","author":{"email":"051346888327db48cce19d2cfd0e1c700bb7cf16@suse.com","name":"Jan Beulich"},"message":"syslog: fill buffer with more than a single message for SYSLOG_ACTION_READ\n\nThe recent changes to the printk buffer management resulted in\nSYSLOG_ACTION_READ to only return a single message, whereas previously\nthe buffer would get filled as much as possible. As, when too small to\nfit everything, filling it to the last byte would be pretty ugly with\nthe new code, the patch arranges for as many messages as possible to\nget returned in a single invocation. User space tools in at least all\nSLES versions depend on the old behavior.\n\nThis at once addresses the issue attempted to get fixed with commit\nb56a39ac263e5b8cafedd551a49c2105e68b98c2 (\"printk: return -EINVAL if\nthe message len is bigger than the buf size\"), and since that commit\nwidened the possibility for losing a message altogether, the patch\nhere assumes that this other commit would get reverted first\n(otherwise the patch here won't apply).\n\nFurthermore, this patch also addresses the problem dealt with in\ncommit 4a77a5a06ec66ed05199b301e7c25f42f979afdc (\"printk: use mutex\nlock to stop syslog_seq from going wild\"), so I'd recommend reverting\nthat one too (albeit there's no direct collision between the two).\n\nChange-Id: Ic27935cb36d00b0cafa9dea8bf53ca4f8961493a\nSigned-off-by: Jan Beulich <jbeulich@suse.com>\nAcked-by: Kay Sievers <kay@vrfy.org>\nCc: Yuanhan Liu <yuanhan.liu@linux.intel.com>\nSigned-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>","distinct":true,"url":"https://api.github.com/repos/CyanogenMod/android_kernel_lge_hammerhead/commits/fbffea9ca1089d9f8dff123f9b75daa675c26833"},{"sha":"25e280ec8d5efce91ac49530a628f6b28e7c10be","author":{"email":"e9264147b413746293e539868c8edff71715e1e3@vrfy.org","name":"Kay Sievers"},"message":"printk: flush continuation lines immediately to console\n\nContinuation lines are buffered internally, intended to merge the\nchunked printk()s into a single record, and to isolate potentially\nracy continuation users from usual terminated line users.\n\nThis though, has the effect that partial lines are not printed to\nthe console in the moment they are emitted. In case the kernel\ncrashes in the meantime, the potentially interesting printed\ninformation would never reach the consoles.\n\nHere we share the continuation buffer with the console copy logic,\nand partial lines are always immediately flushed to the available\nconsoles. They are still buffered internally to improve the\nreadability and integrity of the messages and minimize the amount\nof needed record headers to store.\n\nSigned-off-by: Kay Sievers <kay@vrfy.org>\nTested-by: Steven Rostedt <rostedt@goodmis.org>\nAcked-by: Steven Rostedt <rostedt@goodmis.org>\nSigned-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>","distinct":true,"url":"https://api.github.com/repos/CyanogenMod/android_kernel_lge_hammerhead/commits/25e280ec8d5efce91ac49530a628f6b28e7c10be"},{"sha":"e89171d6c20ec2a04db12483cd6f6d15f004a45b","author":{"email":"43232e92d70cc7aa53504ad0397085ee47bad87f@goodmis.org","name":"Steven Rostedt"},"message":"printk: Optimize if statement logic where newline exists\n\nIn reviewing Kay's fix up patch: \"printk: Have printk() never buffer its\ndata\", I found two if statements that could be combined and optimized.\n\nPut together the two 'cont.len && cont.owner == current' if statements\ninto a single one, and check if we need to call cont_add(). This also\nremoves the unneeded double cont_flush() calls.\n\nLink: http://lkml.kernel.org/r/1340869133.876.10.camel@mop\n\nChange-Id: I07423057a597d81a040fb80179c9636e2222c283\nSigned-off-by: Steven Rostedt <rostedt@goodmis.org>\nCc: Kay Sievers <kay@vrfy.org>\nSigned-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>","distinct":true,"url":"https://api.github.com/repos/CyanogenMod/android_kernel_lge_hammerhead/commits/e89171d6c20ec2a04db12483cd6f6d15f004a45b"},{"sha":"c9c6cdfe21eb3b7da3cd5f05a1d0f3d4f8ed44fc","author":{"email":"6f29df8e90a57f1ba61ffd63b0468c86bb6d3a99@xenotime.net","name":"Randy Dunlap"},"message":"printk.c: fix kernel-doc warnings\n\nFix kernel-doc warnings in printk.c: use correct parameter name.\n\n  Warning(kernel/printk.c:2429): No description found for parameter 'buf'\n  Warning(kernel/printk.c:2429): Excess function parameter 'line' description in 'kmsg_dump_get_buffer'\n\nChange-Id: Ie4a0b2315b6c13e8023cfd1b2a304a27e4269fa6\nSigned-off-by: Randy Dunlap <rdunlap@xenotime.net>\nSigned-off-by: Linus Torvalds <torvalds@linux-foundation.org>","distinct":true,"url":"https://api.github.com/repos/CyanogenMod/android_kernel_lge_hammerhead/commits/c9c6cdfe21eb3b7da3cd5f05a1d0f3d4f8ed44fc"},{"sha":"d3de20de1219047b8ef4cc3bd9f5aca0d452a739","author":{"email":"858732b0d97598091e89a0d1be1593caf0442efe@intel.com","name":"liu chuansheng"},"message":"printk: replacing the raw_spin_lock/unlock with raw_spin_lock/unlock_irq\n\nIn function devkmsg_read/writev/llseek/poll/open()..., the function\nraw_spin_lock/unlock is used, there is potential deadlock case happening.\nCPU1: thread1 doing the cat /dev/kmsg:\n        raw_spin_lock(&logbuf_lock);\n        while (user->seq == log_next_seq) {\nwhen thread1 run here, at this time one interrupt is coming on CPU1 and running\nbased on this thread,if the interrupt handle called the printk which need the\nlogbuf_lock spin also, it will cause deadlock.\n\nSo we should use raw_spin_lock/unlock_irq here.\n\nChange-Id: I4b1f3077c958652b40eea0748cb9e3e40e81c5f6\nAcked-by: Kay Sievers <kay@vrfy.org>\nSigned-off-by: liu chuansheng <chuansheng.liu@intel.com>\nSigned-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>","distinct":true,"url":"https://api.github.com/repos/CyanogenMod/android_kernel_lge_hammerhead/commits/d3de20de1219047b8ef4cc3bd9f5aca0d452a739"},{"sha":"1aed7c2d0752b0f3844724da4927e961c5fbeca0","author":{"email":"e9264147b413746293e539868c8edff71715e1e3@vrfy.org","name":"Kay Sievers"},"message":"kmsg: escape the backslash character while exporting data\n\nNon-printable characters in the log data are hex-escaped to ensure safe\npost processing. We need to escape a backslash we find in the data, to be\nable to distinguish it from a backslash we add for the escaping.\n\nAlso escape the non-printable character 127.\n\nThanks to Miloslav Trmac for the heads up.\n\nChange-Id: I1c6e7c53bf526dfc6fed7aa4af3b980446817955\nReported-by: Michael Neuling <mikey@neuling.org>\nSigned-off-by: Kay Sievers <kay@vrfy.org>\nSigned-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>","distinct":true,"url":"https://api.github.com/repos/CyanogenMod/android_kernel_lge_hammerhead/commits/1aed7c2d0752b0f3844724da4927e961c5fbeca0"},{"sha":"9a10ae181a11f7706aa5445ed2e97666e65e0ac9","author":{"email":"e9264147b413746293e539868c8edff71715e1e3@vrfy.org","name":"Kay Sievers"},"message":"kmsg: add the facility number to the syslog prefix\n\nAfter the recent split of facility and level into separate variables,\nwe miss the facility value (always 0 for kernel-originated messages)\nin the syslog prefix.\n\nOn Tue, Jul 3, 2012 at 12:45 PM, Dan Carpenter <dan.carpenter@oracle.com> wrote:\n> Static checkers complain about the impossible condition here.\n>\n> In 084681d14e ('printk: flush continuation lines immediately to\n> console'), we changed msg->level from being a u16 to being an unsigned\n> 3 bit bitfield.\n\nChange-Id: Ieff78155f7364088c855f3e46c245e7e88b6bc79\nCc: Dan Carpenter <dan.carpenter@oracle.com>\nSigned-off-by: Kay Sievers <kay@vrfy.org>\nSigned-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>","distinct":true,"url":"https://api.github.com/repos/CyanogenMod/android_kernel_lge_hammerhead/commits/9a10ae181a11f7706aa5445ed2e97666e65e0ac9"},{"sha":"f03c019935d804d4ccaa2203beea9b355f6479ee","author":{"email":"e9264147b413746293e539868c8edff71715e1e3@vrfy.org","name":"Kay Sievers"},"message":"kmsg: properly handle concurrent non-blocking read() from /proc/kmsg\n\nThe /proc/kmsg read() interface is internally simply wired up to a sequence\nof syslog() syscalls, which might are racy between their checks and actions,\nregarding concurrency.\n\nIn the (very uncommon) case of concurrent readers of /dev/kmsg, relying on\nusual O_NONBLOCK behavior, the recently introduced mutex might block an\nO_NONBLOCK reader in read(), when poll() returns for it, but another process\nhas already read the data in the meantime. We've seen that while running\nartificial test setups and tools that \"fight\" about /proc/kmsg data.\n\nThis restores the original /proc/kmsg behavior, where in case of concurrent\nread()s, poll() might wake up but the read() syscall will just return 0 to\nthe caller, while another process has \"stolen\" the data.\n\nThis is in the general case not the expected behavior, but it is the exact\nsame one, that can easily be triggered with a 3.4 kernel, and some tools\nmight just rely on it.\n\nThe mutex is not needed, the original integrity issue which introduced it,\nis in the meantime covered by:\n  \"fill buffer with more than a single message for SYSLOG_ACTION_READ\"\n  116e90b23f74d303e8d607c7a7d54f60f14ab9f2\n\nChange-Id: I461c3e75906399922a2d87dcf1225236ec5ae350\nCc: Yuanhan Liu <yuanhan.liu@linux.intel.com>\nAcked-by: Jan Beulich <jbeulich@suse.com>\nSigned-off-by: Kay Sievers <kay@vrfy.org>\nSigned-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>","distinct":true,"url":"https://api.github.com/repos/CyanogenMod/android_kernel_lge_hammerhead/commits/f03c019935d804d4ccaa2203beea9b355f6479ee"}]}